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

Compare commits

base: taler:76c2b758a13c6feb52c3ed271bfa77c79f885de9
Branches Tags
taler:master
taler:new-amount
taler:fail-amount
taler:age-withdraw
taler:master-broken
taler:auction_brandt
..
compare: taler:b21ccdf250fac70ff998822a0ef21ae3a3fab39c
Branches Tags
taler:new-amount
taler:fail-amount
taler:age-withdraw
taler:master
taler:master-broken
taler:auction_brandt

No commits in common. "76c2b758a13c6feb52c3ed271bfa77c79f885de9" and "b21ccdf250fac70ff998822a0ef21ae3a3fab39c" have entirely different histories.
76c2b758a1 ... b21ccdf250

118 changed files with 3368 additions and 2321 deletions
Show Stats Expand all files Collapse all files

13
src/auditor/Makefile.am
View File

@ -54,12 +54,13 @@ libauditorreport_la_LIBADD = \
taler_auditor_dbinit_SOURCES = \
taler-auditor-dbinit.c
taler_auditor_dbinit_LDADD = \
$(top_builddir)/src/auditordb/libtalerauditordb.la \
$(top_builddir)/src/pq/libtalerpq.la \
$(top_builddir)/src/util/libtalerutil.la \
-lgnunetutil \
$(LIBGCRYPT_LIBS) \
$(XLIB)
$(top_builddir)/src/util/libtalerutil.la \
$(top_builddir)/src/pq/libtalerpq.la \
$(top_builddir)/src/auditordb/libtalerauditordb.la \
-lgnunetutil $(XLIB)
taler_auditor_dbinit_LDFLAGS = \
$(POSTGRESQL_LDFLAGS)
taler_auditor_dbinit_CPPFLAGS = \
-I$(top_srcdir)/src/include \
-I$(top_srcdir)/src/pq/ \
@ -181,6 +182,8 @@ taler_auditor_sync_LDADD = \
-lgnunetutil \
$(LIBGCRYPT_LIBS) \
$(XLIB)
taler_auditor_sync_LDFLAGS = \
$(POSTGRESQL_LDFLAGS)
taler_auditor_sync_CPPFLAGS = \
-I$(top_srcdir)/src/include \
-I$(top_srcdir)/src/pq/ \

8
src/auditor/report-lib.c
View File

@ -160,12 +160,12 @@ add_denomination (
TALER_amount2s (&value));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Start time is %s\n",
GNUNET_TIME_timestamp2s
(GNUNET_TIME_timestamp_ntoh (issue->start)));
GNUNET_STRINGS_absolute_time_to_string
(GNUNET_TIME_absolute_ntoh (issue->start)));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Expire deposit time is %s\n",
GNUNET_TIME_timestamp2s
(GNUNET_TIME_timestamp_ntoh (issue->expire_deposit)));
GNUNET_STRINGS_absolute_time_to_string
(GNUNET_TIME_absolute_ntoh (issue->expire_deposit)));
}
#endif
{

36
src/auditor/taler-auditor-httpd_deposit-confirmation.c
View File

@ -63,19 +63,21 @@ verify_and_execute_deposit_confirmation (
const struct TALER_AUDITORDB_ExchangeSigningKey *es)
{
enum GNUNET_DB_QueryStatus qs;
struct GNUNET_TIME_Absolute now;
struct GNUNET_HashCode h;
const char *cached;
struct TALER_ExchangeSigningKeyValidityPS skv = {
.purpose.purpose = htonl (TALER_SIGNATURE_MASTER_SIGNING_KEY_VALIDITY),
.purpose.size = htonl (sizeof (struct TALER_ExchangeSigningKeyValidityPS)),
.start = GNUNET_TIME_timestamp_hton (es->ep_start),
.expire = GNUNET_TIME_timestamp_hton (es->ep_expire),
.end = GNUNET_TIME_timestamp_hton (es->ep_end),
.start = GNUNET_TIME_absolute_hton (es->ep_start),
.expire = GNUNET_TIME_absolute_hton (es->ep_expire),
.end = GNUNET_TIME_absolute_hton (es->ep_end),
.signkey_pub = es->exchange_pub
};
if (GNUNET_TIME_absolute_is_future (es->ep_start.abs_time) ||
GNUNET_TIME_absolute_is_past (es->ep_expire.abs_time) )
now = GNUNET_TIME_absolute_get ();
if ( (es->ep_start.abs_value_us > now.abs_value_us) ||
(es->ep_expire.abs_value_us < now.abs_value_us) )
{
/* Signing key expired */
TALER_LOG_WARNING ("Expired exchange signing key\n");
@ -251,12 +253,12 @@ TAH_DEPOSIT_CONFIRMATION_handler (struct TAH_RequestHandler *rh,
&dc.h_extensions),
GNUNET_JSON_spec_fixed_auto ("h_wire",
&dc.h_wire),
GNUNET_JSON_spec_timestamp ("exchange_timestamp",
&dc.exchange_timestamp),
GNUNET_JSON_spec_timestamp ("refund_deadline",
&dc.refund_deadline),
GNUNET_JSON_spec_timestamp ("wire_deadline",
&dc.wire_deadline),
TALER_JSON_spec_absolute_time ("exchange_timestamp",
&dc.exchange_timestamp),
TALER_JSON_spec_absolute_time ("refund_deadline",
&dc.refund_deadline),
TALER_JSON_spec_absolute_time ("wire_deadline",
&dc.wire_deadline),
TALER_JSON_spec_amount ("amount_without_fee",
TAH_currency,
&dc.amount_without_fee),
@ -270,12 +272,12 @@ TAH_DEPOSIT_CONFIRMATION_handler (struct TAH_RequestHandler *rh,
&dc.exchange_pub),
GNUNET_JSON_spec_fixed_auto ("master_pub",
&es.master_public_key),
GNUNET_JSON_spec_timestamp ("ep_start",
&es.ep_start),
GNUNET_JSON_spec_timestamp ("ep_expire",
&es.ep_expire),
GNUNET_JSON_spec_timestamp ("ep_end",
&es.ep_end),
TALER_JSON_spec_absolute_time ("ep_start",
&es.ep_start),
TALER_JSON_spec_absolute_time ("ep_expire",
&es.ep_expire),
TALER_JSON_spec_absolute_time ("ep_end",
&es.ep_end),
GNUNET_JSON_spec_fixed_auto ("master_sig",
&es.master_sig),
GNUNET_JSON_spec_end ()

48
src/auditor/taler-helper-auditor-aggregation.c
View File

@ -297,12 +297,12 @@ struct WireFeeInfo
/**
* When does the fee go into effect (inclusive).
*/
struct GNUNET_TIME_Timestamp start_date;
struct GNUNET_TIME_Absolute start_date;
/**
* When does the fee stop being in effect (exclusive).
*/
struct GNUNET_TIME_Timestamp end_date;
struct GNUNET_TIME_Absolute end_date;
/**
* How high is the wire fee.
@ -365,7 +365,7 @@ struct WireCheckContext
/**
* Execution time of the wire transfer.
*/
struct GNUNET_TIME_Timestamp date;
struct GNUNET_TIME_Absolute date;
/**
* Database transaction status.
@ -698,7 +698,7 @@ wire_transfer_information_cb (
uint64_t rowid,
const struct TALER_MerchantPublicKeyP *merchant_pub,
const char *account_pay_uri,
struct GNUNET_TIME_Timestamp exec_time,
struct GNUNET_TIME_Absolute exec_time,
const struct TALER_PrivateContractHash *h_contract_terms,
const struct TALER_DenominationPublicKey *denom_pub,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
@ -849,9 +849,7 @@ wire_transfer_information_cb (
rowid,
"target of outgoing wire transfer do not match hash of wire from deposit");
}
if (GNUNET_TIME_timestamp_cmp (exec_time,
!=,
wcc->date) )
if (exec_time.abs_value_us != wcc->date.abs_value_us)
{
/* This should be impossible from database constraints */
GNUNET_break (0);
@ -883,7 +881,7 @@ wire_transfer_information_cb (
static const struct TALER_Amount *
get_wire_fee (struct AggregationContext *ac,
const char *method,
struct GNUNET_TIME_Timestamp timestamp)
struct GNUNET_TIME_Absolute timestamp)
{
struct WireFeeInfo *wfi;
struct WireFeeInfo *pos;
@ -892,16 +890,10 @@ get_wire_fee (struct AggregationContext *ac,
/* Check if fee is already loaded in cache */
for (pos = ac->fee_head; NULL != pos; pos = pos->next)
{
if (GNUNET_TIME_timestamp_cmp (pos->start_date,
<=,
timestamp) &&
GNUNET_TIME_timestamp_cmp (pos->end_date,
>,
timestamp) )
if ( (pos->start_date.abs_value_us <= timestamp.abs_value_us) &&
(pos->end_date.abs_value_us > timestamp.abs_value_us) )
return &pos->wire_fee;
if (GNUNET_TIME_timestamp_cmp (pos->start_date,
>,
timestamp))
if (pos->start_date.abs_value_us > timestamp.abs_value_us)
break;
}
@ -937,7 +929,7 @@ get_wire_fee (struct AggregationContext *ac,
&master_sig))
{
report_row_inconsistency ("wire-fee",
timestamp.abs_time.abs_value_us,
timestamp.abs_value_us,
"wire fee signature invalid at given time");
}
}
@ -946,7 +938,7 @@ get_wire_fee (struct AggregationContext *ac,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Wire fee is %s starting at %s\n",
TALER_amount2s (&wfi->wire_fee),
GNUNET_TIME_timestamp2s (wfi->start_date));
GNUNET_STRINGS_absolute_time_to_string (wfi->start_date));
if ( (NULL == pos) ||
(NULL == pos->prev) )
GNUNET_CONTAINER_DLL_insert (ac->fee_head,
@ -959,9 +951,7 @@ get_wire_fee (struct AggregationContext *ac,
wfi);
/* Check non-overlaping fee invariant */
if ( (NULL != wfi->prev) &&
GNUNET_TIME_timestamp_cmp (wfi->prev->end_date,
>,
wfi->start_date) )
(wfi->prev->end_date.abs_value_us > wfi->start_date.abs_value_us) )
{
TALER_ARL_report (report_fee_time_inconsistencies,
GNUNET_JSON_PACK (
@ -970,12 +960,10 @@ get_wire_fee (struct AggregationContext *ac,
GNUNET_JSON_pack_string ("diagnostic",
"start date before previous end date"),
TALER_JSON_pack_time_abs_human ("time",
wfi->start_date.abs_time)));
wfi->start_date)));
}
if ( (NULL != wfi->next) &&
GNUNET_TIME_timestamp_cmp (wfi->next->start_date,
>=,
wfi->end_date) )
(wfi->next->start_date.abs_value_us >= wfi->end_date.abs_value_us) )
{
TALER_ARL_report (report_fee_time_inconsistencies,
GNUNET_JSON_PACK (
@ -984,7 +972,7 @@ get_wire_fee (struct AggregationContext *ac,
GNUNET_JSON_pack_string ("diagnostic",
"end date date after next start date"),
TALER_JSON_pack_time_abs_human ("time",
wfi->end_date.abs_time)));
wfi->end_date)));
}
return &wfi->wire_fee;
}
@ -1005,7 +993,7 @@ get_wire_fee (struct AggregationContext *ac,
static enum GNUNET_GenericReturnValue
check_wire_out_cb (void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp date,
struct GNUNET_TIME_Absolute date,
const struct TALER_WireTransferIdentifierRawP *wtid,
const char *payto_uri,
const struct TALER_Amount *amount)
@ -1025,7 +1013,7 @@ check_wire_out_cb (void *cls,
"Checking wire transfer %s over %s performed on %s\n",
TALER_B2S (wtid),
TALER_amount2s (amount),
GNUNET_TIME_timestamp2s (date));
GNUNET_STRINGS_absolute_time_to_string (date));
if (NULL == (method = TALER_payto_get_method (payto_uri)))
{
report_row_inconsistency ("wire_out",
@ -1074,7 +1062,7 @@ check_wire_out_cb (void *cls,
if (NULL == wire_fee)
{
report_row_inconsistency ("wire-fee",
date.abs_time.abs_value_us,
date.abs_value_us,
"wire fee unavailable for given time");
/* If fee is unknown, we just assume the fee is zero */
final_amount = wcc.total_deposits;

109
src/auditor/taler-helper-auditor-coins.c
View File

@ -284,21 +284,20 @@ report_emergency_by_amount (
"Reporting emergency on denomination `%s' over loss of %s\n",
GNUNET_h2s (&issue->denom_hash.hash),
TALER_amount2s (loss));
TALER_ARL_report (
report_emergencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("denompub_hash",
&issue->denom_hash),
TALER_JSON_pack_amount ("denom_risk",
risk),
TALER_JSON_pack_amount ("denom_loss",
loss),
TALER_JSON_pack_time_abs_nbo_human ("start",
issue->start.abs_time_nbo),
TALER_JSON_pack_time_abs_nbo_human ("deposit_end",
issue->expire_deposit.abs_time_nbo),
TALER_JSON_pack_amount_nbo ("value",
&issue->value)));
TALER_ARL_report (report_emergencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("denompub_hash",
&issue->denom_hash),
TALER_JSON_pack_amount ("denom_risk",
risk),
TALER_JSON_pack_amount ("denom_loss",
loss),
TALER_JSON_pack_time_abs_nbo_human ("start",
issue->start),
TALER_JSON_pack_time_abs_nbo_human ("deposit_end",
issue->expire_deposit),
TALER_JSON_pack_amount_nbo ("value",
&issue->value)));
TALER_ARL_amount_add (&reported_emergency_risk_by_amount,
&reported_emergency_risk_by_amount,
risk);
@ -331,23 +330,22 @@ report_emergency_by_count (
{
struct TALER_Amount denom_value;
TALER_ARL_report (
report_emergencies_by_count,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("denompub_hash",
&issue->denom_hash),
GNUNET_JSON_pack_uint64 ("num_issued",
num_issued),
GNUNET_JSON_pack_uint64 ("num_known",
num_known),
TALER_JSON_pack_amount ("denom_risk",
risk),
TALER_JSON_pack_time_abs_nbo_human ("start",
issue->start.abs_time_nbo),
TALER_JSON_pack_time_abs_nbo_human ("deposit_end",
issue->expire_deposit.abs_time_nbo),
TALER_JSON_pack_amount_nbo ("value",
&issue->value)));
TALER_ARL_report (report_emergencies_by_count,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("denompub_hash",
&issue->denom_hash),
GNUNET_JSON_pack_uint64 ("num_issued",
num_issued),
GNUNET_JSON_pack_uint64 ("num_known",
num_known),
TALER_JSON_pack_amount ("denom_risk",
risk),
TALER_JSON_pack_time_abs_nbo_human ("start",
issue->start),
TALER_JSON_pack_time_abs_nbo_human ("deposit_end",
issue->expire_deposit),
TALER_JSON_pack_amount_nbo ("value",
&issue->value)));
TALER_ARL_amount_add (&reported_emergency_risk_by_count,
&reported_emergency_risk_by_count,
risk);
@ -796,7 +794,7 @@ get_denomination_summary (struct CoinContext *cc,
* @param value a `struct DenominationSummary`
* @return #GNUNET_OK (continue to iterate)
*/
static enum GNUNET_GenericReturnValue
static int
sync_denomination (void *cls,
const struct GNUNET_HashCode *denom_hash,
void *value)
@ -808,18 +806,16 @@ sync_denomination (void *cls,
struct DenominationSummary *ds = value;
const struct TALER_DenominationKeyValidityPS *issue = ds->issue;
struct GNUNET_TIME_Absolute now;
struct GNUNET_TIME_Timestamp expire_deposit;
struct GNUNET_TIME_Absolute expire_deposit;
struct GNUNET_TIME_Absolute expire_deposit_grace;
enum GNUNET_DB_QueryStatus qs;
now = GNUNET_TIME_absolute_get ();
expire_deposit = GNUNET_TIME_timestamp_ntoh (issue->expire_deposit);
expire_deposit = GNUNET_TIME_absolute_ntoh (issue->expire_deposit);
/* add day grace period to deal with clocks not being perfectly synchronized */
expire_deposit_grace = GNUNET_TIME_absolute_add (expire_deposit.abs_time,
expire_deposit_grace = GNUNET_TIME_absolute_add (expire_deposit,
DEPOSIT_GRACE_PERIOD);
if (GNUNET_TIME_absolute_cmp (now,
>,
expire_deposit_grace) )
if (now.abs_value_us > expire_deposit_grace.abs_value_us)
{
/* Denomination key has expired, book remaining balance of
outstanding coins as revenue; and reduce cc->risk exposure. */
@ -967,7 +963,7 @@ withdraw_cb (void *cls,
const struct TALER_DenominationPublicKey *denom_pub,
const struct TALER_ReservePublicKeyP *reserve_pub,
const struct TALER_ReserveSignatureP *reserve_sig,
struct GNUNET_TIME_Timestamp execution_date,
struct GNUNET_TIME_Absolute execution_date,
const struct TALER_Amount *amount_with_fee)
{
struct CoinContext *cc = cls;
@ -1568,7 +1564,7 @@ refresh_session_cb (void *cls,
static enum GNUNET_GenericReturnValue
deposit_cb (void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp exchange_timestamp,
struct GNUNET_TIME_Absolute exchange_timestamp,
const struct TALER_EXCHANGEDB_Deposit *deposit,
const struct TALER_DenominationPublicKey *denom_pub,
bool done)
@ -1595,9 +1591,8 @@ deposit_cb (void *cls,
return GNUNET_SYSERR;
return GNUNET_OK;
}
if (GNUNET_TIME_timestamp_cmp (deposit->refund_deadline,
>,
deposit->wire_deadline))
if (deposit->refund_deadline.abs_value_us >
deposit->wire_deadline.abs_value_us)
{
report_row_inconsistency ("deposits",
rowid,
@ -2076,7 +2071,7 @@ check_recoup (struct CoinContext *cc,
static int
recoup_cb (void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Absolute timestamp,
const struct TALER_Amount *amount,
const struct TALER_ReservePublicKeyP *reserve_pub,
const struct TALER_CoinPublicInfo *coin,
@ -2120,7 +2115,7 @@ recoup_cb (void *cls,
static int
recoup_refresh_cb (void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Absolute timestamp,
const struct TALER_Amount *amount,
const struct TALER_CoinSpendPublicKeyP *old_coin_pub,
const struct TALER_DenominationHash *old_denom_pub_hash,
@ -2216,8 +2211,8 @@ check_denomination (
struct TALER_Amount fee_deposit;
struct TALER_Amount fee_refresh;
struct TALER_Amount fee_refund;
struct GNUNET_TIME_Timestamp start;
struct GNUNET_TIME_Timestamp end;
struct GNUNET_TIME_Absolute start;
struct GNUNET_TIME_Absolute end;
(void) cls;
(void) denom_pub;
@ -2231,8 +2226,8 @@ check_denomination (
&issue->fee_refresh);
TALER_amount_ntoh (&fee_refund,
&issue->fee_refund);
start = GNUNET_TIME_timestamp_ntoh (issue->start);
end = GNUNET_TIME_timestamp_ntoh (issue->expire_legal);
start = GNUNET_TIME_absolute_ntoh (issue->start);
end = GNUNET_TIME_absolute_ntoh (issue->expire_legal);
qs = TALER_ARL_edb->select_auditor_denom_sig (TALER_ARL_edb->cls,
&issue->denom_hash,
&TALER_ARL_auditor_pub,
@ -2243,9 +2238,9 @@ check_denomination (
"Encountered denomination `%s' (%s) valid from %s (%llu-%llu) that this auditor is not auditing!\n",
GNUNET_h2s (&issue->denom_hash.hash),
TALER_amount2s (&coin_value),
GNUNET_TIME_timestamp2s (start),
(unsigned long long) start.abs_time.abs_value_us,
(unsigned long long) end.abs_time.abs_value_us);
GNUNET_STRINGS_absolute_time_to_string (start),
(unsigned long long) start.abs_value_us,
(unsigned long long) end.abs_value_us);
return; /* skip! */
}
if (GNUNET_OK !=
@ -2254,8 +2249,8 @@ check_denomination (
&issue->denom_hash,
&TALER_ARL_master_pub,
start,
GNUNET_TIME_timestamp_ntoh (issue->expire_withdraw),
GNUNET_TIME_timestamp_ntoh (issue->expire_deposit),
GNUNET_TIME_absolute_ntoh (issue->expire_withdraw),
GNUNET_TIME_absolute_ntoh (issue->expire_deposit),
end,
&coin_value,
&fee_withdraw,
@ -2272,9 +2267,9 @@ check_denomination (
TALER_JSON_pack_amount ("value",
&coin_value),
TALER_JSON_pack_time_abs_human ("start_time",
start.abs_time),
start),
TALER_JSON_pack_time_abs_human ("end_time",
end.abs_time)));
end)));
}
}

23
src/auditor/taler-helper-auditor-deposits.c
View File

@ -112,7 +112,7 @@ test_dc (void *cls,
dcc->last_seen_coin_serial = serial_id;
{
enum GNUNET_DB_QueryStatus qs;
struct GNUNET_TIME_Timestamp exchange_timestamp;
struct GNUNET_TIME_Absolute exchange_timestamp;
struct TALER_Amount deposit_fee;
qs = TALER_ARL_edb->have_deposit2 (TALER_ARL_edb->cls,
@ -140,17 +140,16 @@ test_dc (void *cls,
}
}
/* deposit confirmation missing! report! */
TALER_ARL_report (
report_deposit_confirmation_inconsistencies,
GNUNET_JSON_PACK (
TALER_JSON_pack_time_abs_human ("timestamp",
dc->exchange_timestamp.abs_time),
TALER_JSON_pack_amount ("amount",
&dc->amount_without_fee),
GNUNET_JSON_pack_uint64 ("rowid",
serial_id),
GNUNET_JSON_pack_data_auto ("account",
&dc->h_wire)));
TALER_ARL_report (report_deposit_confirmation_inconsistencies,
GNUNET_JSON_PACK (
TALER_JSON_pack_time_abs_human ("timestamp",
dc->exchange_timestamp),
TALER_JSON_pack_amount ("amount",
&dc->amount_without_fee),
GNUNET_JSON_pack_uint64 ("rowid",
serial_id),
GNUNET_JSON_pack_data_auto ("account",
&dc->h_wire)));
dcc->first_missed_coin_serial = GNUNET_MIN (dcc->first_missed_coin_serial,
serial_id);
dcc->missed_count++;

97
src/auditor/taler-helper-auditor-reserves.c
View File

@ -284,7 +284,7 @@ struct ReserveSummary
* Previous reserve expiration data, as remembered by the auditor.
* (updated on-the-fly in #handle_reserve_in()).
*/
struct GNUNET_TIME_Timestamp a_expiration_date;
struct GNUNET_TIME_Absolute a_expiration_date;
/**
* Which account did originally put money into the reserve?
@ -408,12 +408,12 @@ handle_reserve_in (void *cls,
const struct TALER_Amount *credit,
const char *sender_account_details,
uint64_t wire_reference,
struct GNUNET_TIME_Timestamp execution_date)
struct GNUNET_TIME_Absolute execution_date)
{
struct ReserveContext *rc = cls;
struct GNUNET_HashCode key;
struct ReserveSummary *rs;
struct GNUNET_TIME_Timestamp expiry;
struct GNUNET_TIME_Absolute expiry;
enum GNUNET_DB_QueryStatus qs;
(void) wire_reference;
@ -463,11 +463,10 @@ handle_reserve_in (void *cls,
"Additional incoming wire transfer for reserve `%s' of %s\n",
TALER_B2S (reserve_pub),
TALER_amount2s (credit));
expiry = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (execution_date.abs_time,
idle_reserve_expiration_time));
rs->a_expiration_date = GNUNET_TIME_timestamp_max (rs->a_expiration_date,
expiry);
expiry = GNUNET_TIME_absolute_add (execution_date,
idle_reserve_expiration_time);
rs->a_expiration_date = GNUNET_TIME_absolute_max (rs->a_expiration_date,
expiry);
if (TALER_ARL_do_abort ())
return GNUNET_SYSERR;
return GNUNET_OK;
@ -495,7 +494,7 @@ handle_reserve_out (void *cls,
const struct TALER_DenominationPublicKey *denom_pub,
const struct TALER_ReservePublicKeyP *reserve_pub,
const struct TALER_ReserveSignatureP *reserve_sig,
struct GNUNET_TIME_Timestamp execution_date,
struct GNUNET_TIME_Absolute execution_date,
const struct TALER_Amount *amount_with_fee)
{
struct ReserveContext *rc = cls;
@ -505,8 +504,8 @@ handle_reserve_out (void *cls,
struct TALER_Amount withdraw_fee;
struct TALER_Amount auditor_value;
struct TALER_Amount auditor_amount_with_fee;
struct GNUNET_TIME_Timestamp valid_start;
struct GNUNET_TIME_Timestamp expire_withdraw;
struct GNUNET_TIME_Absolute valid_start;
struct GNUNET_TIME_Absolute expire_withdraw;
enum GNUNET_DB_QueryStatus qs;
struct TALER_WithdrawRequestPS wsrd = {
.purpose.purpose = htonl (TALER_SIGNATURE_WALLET_RESERVE_WITHDRAW),
@ -546,26 +545,22 @@ handle_reserve_out (void *cls,
}
/* check that execution date is within withdraw range for denom_pub */
valid_start = GNUNET_TIME_timestamp_ntoh (issue->start);
expire_withdraw = GNUNET_TIME_timestamp_ntoh (issue->expire_withdraw);
valid_start = GNUNET_TIME_absolute_ntoh (issue->start);
expire_withdraw = GNUNET_TIME_absolute_ntoh (issue->expire_withdraw);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Checking withdraw timing: %llu, expire: %llu, timing: %llu\n",
(unsigned long long) valid_start.abs_time.abs_value_us,
(unsigned long long) expire_withdraw.abs_time.abs_value_us,
(unsigned long long) execution_date.abs_time.abs_value_us);
if (GNUNET_TIME_timestamp_cmp (valid_start,
>,
execution_date) ||
GNUNET_TIME_timestamp_cmp (expire_withdraw,
<,
execution_date))
(unsigned long long) valid_start.abs_value_us,
(unsigned long long) expire_withdraw.abs_value_us,
(unsigned long long) execution_date.abs_value_us);
if ( (valid_start.abs_value_us > execution_date.abs_value_us) ||
(expire_withdraw.abs_value_us < execution_date.abs_value_us) )
{
TALER_ARL_report (denomination_key_validity_withdraw_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rowid),
TALER_JSON_pack_time_abs_human ("execution_date",
execution_date.abs_time),
execution_date),
GNUNET_JSON_pack_data_auto ("reserve_pub",
reserve_pub),
GNUNET_JSON_pack_data_auto ("denompub_h",
@ -688,7 +683,7 @@ static int
handle_recoup_by_reserve (
void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Absolute timestamp,
const struct TALER_Amount *amount,
const struct TALER_ReservePublicKeyP *reserve_pub,
const struct TALER_CoinPublicInfo *coin,
@ -699,7 +694,7 @@ handle_recoup_by_reserve (
struct ReserveContext *rc = cls;
struct GNUNET_HashCode key;
struct ReserveSummary *rs;
struct GNUNET_TIME_Timestamp expiry;
struct GNUNET_TIME_Absolute expiry;
struct TALER_MasterSignatureP msig;
uint64_t rev_rowid;
enum GNUNET_DB_QueryStatus qs;
@ -850,11 +845,10 @@ handle_recoup_by_reserve (
"Additional /recoup value to for reserve `%s' of %s\n",
TALER_B2S (reserve_pub),
TALER_amount2s (amount));
expiry = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (timestamp.abs_time,
idle_reserve_expiration_time));
rs->a_expiration_date = GNUNET_TIME_timestamp_max (rs->a_expiration_date,
expiry);
expiry = GNUNET_TIME_absolute_add (timestamp,
idle_reserve_expiration_time);
rs->a_expiration_date = GNUNET_TIME_absolute_max (rs->a_expiration_date,
expiry);
if (TALER_ARL_do_abort ())
return GNUNET_SYSERR;
return GNUNET_OK;
@ -870,14 +864,14 @@ handle_recoup_by_reserve (
* @param[out] fee set to the closing fee
* @return #GNUNET_OK on success
*/
static enum GNUNET_GenericReturnValue
static int
get_closing_fee (const char *receiver_account,
struct GNUNET_TIME_Timestamp atime,
struct GNUNET_TIME_Absolute atime,
struct TALER_Amount *fee)
{
struct TALER_MasterSignatureP master_sig;
struct GNUNET_TIME_Timestamp start_date;
struct GNUNET_TIME_Timestamp end_date;
struct GNUNET_TIME_Absolute start_date;
struct GNUNET_TIME_Absolute end_date;
struct TALER_Amount wire_fee;
char *method;
@ -900,9 +894,9 @@ get_closing_fee (const char *receiver_account,
GNUNET_asprintf (&diag,
"closing fee for `%s' unavailable at %s\n",
method,
GNUNET_TIME_timestamp2s (atime));
GNUNET_STRINGS_absolute_time_to_string (atime));
report_row_inconsistency ("closing-fee",
atime.abs_time.abs_value_us,
atime.abs_value_us,
diag);
GNUNET_free (diag);
GNUNET_free (method);
@ -931,7 +925,7 @@ static int
handle_reserve_closed (
void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp execution_date,
struct GNUNET_TIME_Absolute execution_date,
const struct TALER_Amount *amount_with_fee,
const struct TALER_Amount *closing_fee,
const struct TALER_ReservePublicKeyP *reserve_pub,
@ -1161,10 +1155,8 @@ verify_reserve_balance (void *cls,
/* Check that reserve is being closed if it is past its expiration date
(and the closing fee would not exceed the remaining balance) */
if (GNUNET_TIME_relative_cmp (CLOSING_GRACE_PERIOD,
<,
GNUNET_TIME_absolute_get_duration (
rs->a_expiration_date.abs_time)))
if (CLOSING_GRACE_PERIOD.rel_value_us <
GNUNET_TIME_absolute_get_duration (rs->a_expiration_date).rel_value_us)
{
/* Reserve is expired */
struct TALER_Amount cfee;
@ -1191,7 +1183,7 @@ verify_reserve_balance (void *cls,
TALER_JSON_pack_amount ("balance",
&nbalance),
TALER_JSON_pack_time_abs_human ("expiration_time",
rs->a_expiration_date.abs_time)));
rs->a_expiration_date)));
}
}
else
@ -1200,17 +1192,16 @@ verify_reserve_balance (void *cls,
TALER_ARL_amount_add (&total_balance_reserve_not_closed,
&total_balance_reserve_not_closed,
&nbalance);
TALER_ARL_report (
report_reserve_not_closed_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("reserve_pub",
&rs->reserve_pub),
TALER_JSON_pack_amount ("balance",
&nbalance),
TALER_JSON_pack_time_abs_human ("expiration_time",
rs->a_expiration_date.abs_time),
GNUNET_JSON_pack_string ("diagnostic",
"could not determine closing fee")));
TALER_ARL_report (report_reserve_not_closed_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("reserve_pub",
&rs->reserve_pub),
TALER_JSON_pack_amount ("balance",
&nbalance),
TALER_JSON_pack_time_abs_human ("expiration_time",
rs->a_expiration_date),
GNUNET_JSON_pack_string ("diagnostic",
"could not determine closing fee")));
}
}

403
src/auditor/taler-helper-auditor-wire.c
View File

@ -122,7 +122,7 @@ struct ReserveClosure
/**
* When was the reserve closed?
*/
struct GNUNET_TIME_Timestamp execution_date;
struct GNUNET_TIME_Absolute execution_date;
/**
* Amount transferred (amount remaining minus fee).
@ -500,9 +500,9 @@ do_shutdown (void *cls)
GNUNET_JSON_pack_uint64 ("end_pp_reserve_close_uuid",
pp.last_reserve_close_uuid),
TALER_JSON_pack_time_abs_human ("start_pp_last_timestamp",
start_pp.last_timestamp.abs_time),
start_pp.last_timestamp),
TALER_JSON_pack_time_abs_human ("end_pp_last_timestamp",
pp.last_timestamp.abs_time),
pp.last_timestamp),
GNUNET_JSON_pack_array_steal ("account_progress",
report_account_progress)));
report_wire_out_inconsistencies = NULL;
@ -599,19 +599,18 @@ check_pending_rc (void *cls,
&rc->amount);
if ( (0 != rc->amount.value) ||
(0 != rc->amount.fraction) )
TALER_ARL_report (
report_closure_lags,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rc->rowid),
TALER_JSON_pack_amount ("amount",
&rc->amount),
TALER_JSON_pack_time_abs_human ("deadline",
rc->execution_date.abs_time),
GNUNET_JSON_pack_data_auto ("wtid",
&rc->wtid),
GNUNET_JSON_pack_string ("account",
rc->receiver_account)));
TALER_ARL_report (report_closure_lags,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rc->rowid),
TALER_JSON_pack_amount ("amount",
&rc->amount),
TALER_JSON_pack_time_abs_human ("deadline",
rc->execution_date),
GNUNET_JSON_pack_data_auto ("wtid",
&rc->wtid),
GNUNET_JSON_pack_string ("account",
rc->receiver_account)));
pp.last_reserve_close_uuid
= GNUNET_MIN (pp.last_reserve_close_uuid,
rc->rowid);
@ -732,7 +731,7 @@ commit (enum GNUNET_DB_QueryStatus qs)
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Concluded audit step at %s\n",
GNUNET_TIME_timestamp2s (pp.last_timestamp));
GNUNET_STRINGS_absolute_time_to_string (pp.last_timestamp));
if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs)
{
@ -789,7 +788,7 @@ wire_missing_cb (void *cls,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_Amount *amount,
const char *payto_uri,
struct GNUNET_TIME_Timestamp deadline,
struct GNUNET_TIME_Absolute deadline,
bool tiny,
bool done)
{
@ -822,7 +821,7 @@ wire_missing_cb (void *cls,
TALER_JSON_pack_amount ("amount",
amount),
TALER_JSON_pack_time_abs_human ("deadline",
deadline.abs_time),
deadline),
GNUNET_JSON_pack_data_auto ("coin_pub",
coin_pub),
GNUNET_JSON_pack_string ("account",
@ -847,17 +846,18 @@ wire_missing_cb (void *cls,
static void
check_for_required_transfers (void)
{
struct GNUNET_TIME_Timestamp next_timestamp;
struct GNUNET_TIME_Absolute next_timestamp;
enum GNUNET_DB_QueryStatus qs;
next_timestamp = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&next_timestamp);
/* Subtract #GRACE_PERIOD, so we can be a bit behind in processing
without immediately raising undue concern */
next_timestamp = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_subtract (GNUNET_TIME_absolute_get (),
GRACE_PERIOD));
next_timestamp = GNUNET_TIME_absolute_subtract (next_timestamp,
GRACE_PERIOD);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Analyzing exchange's unfinished deposits (deadline: %s)\n",
GNUNET_TIME_timestamp2s (next_timestamp));
GNUNET_STRINGS_absolute_time_to_string (next_timestamp));
qs = TALER_ARL_edb->select_deposits_missing_wire (TALER_ARL_edb->cls,
pp.last_timestamp,
next_timestamp,
@ -903,27 +903,25 @@ conclude_wire_out (void)
static void
check_time_difference (const char *table,
uint64_t rowid,
struct GNUNET_TIME_Timestamp want,
struct GNUNET_TIME_Timestamp have)
struct GNUNET_TIME_Absolute want,
struct GNUNET_TIME_Absolute have)
{
struct GNUNET_TIME_Relative delta;
char *details;
if (GNUNET_TIME_timestamp_cmp (have, >, want))
delta = GNUNET_TIME_absolute_get_difference (want.abs_time,
have.abs_time);
if (have.abs_value_us > want.abs_value_us)
delta = GNUNET_TIME_absolute_get_difference (want,
have);
else
delta = GNUNET_TIME_absolute_get_difference (have.abs_time,
want.abs_time);
if (GNUNET_TIME_relative_cmp (delta,
<=,
TIME_TOLERANCE))
delta = GNUNET_TIME_absolute_get_difference (have,
want);
if (delta.rel_value_us <= TIME_TOLERANCE.rel_value_us)
return;
GNUNET_asprintf (&details,
"execution date mismatch (%s)",
GNUNET_TIME_relative2s (delta,
true));
GNUNET_STRINGS_relative_time_to_string (delta,
GNUNET_YES));
TALER_ARL_report (report_row_minor_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_string ("table",
@ -951,7 +949,7 @@ check_time_difference (const char *table,
static enum GNUNET_GenericReturnValue
wire_out_cb (void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp date,
struct GNUNET_TIME_Absolute date,
const struct TALER_WireTransferIdentifierRawP *wtid,
const char *payto_uri,
const struct TALER_Amount *amount)
@ -962,7 +960,7 @@ wire_out_cb (void *cls,
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Exchange wire OUT at %s of %s with WTID %s\n",
GNUNET_TIME_timestamp2s (date),
GNUNET_STRINGS_absolute_time_to_string (date),
TALER_amount2s (amount),
TALER_B2S (wtid));
GNUNET_CRYPTO_hash (wtid,
@ -976,23 +974,22 @@ wire_out_cb (void *cls,
justified), so the entire amount is missing / still to be done.
This is moderately harmless, it might just be that the aggreator
has not yet fully caught up with the transfers it should do. */
TALER_ARL_report (
report_wire_out_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rowid),
TALER_JSON_pack_amount ("amount_wired",
&zero),
TALER_JSON_pack_amount ("amount_justified",
amount),
GNUNET_JSON_pack_data_auto ("wtid",
wtid),
TALER_JSON_pack_time_abs_human ("timestamp",
date.abs_time),
GNUNET_JSON_pack_string ("diagnostic",
"wire transfer not made (yet?)"),
GNUNET_JSON_pack_string ("account_section",
wa->ai->section_name)));
TALER_ARL_report (report_wire_out_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rowid),
TALER_JSON_pack_amount ("amount_wired",
&zero),
TALER_JSON_pack_amount ("amount_justified",
amount),
GNUNET_JSON_pack_data_auto ("wtid",
wtid),
TALER_JSON_pack_time_abs_human ("timestamp",
date),
GNUNET_JSON_pack_string ("diagnostic",
"wire transfer not made (yet?)"),
GNUNET_JSON_pack_string ("account_section",
wa->ai->section_name)));
TALER_ARL_amount_add (&total_bad_amount_out_minus,
&total_bad_amount_out_minus,
amount);
@ -1006,48 +1003,45 @@ wire_out_cb (void *cls,
/* Destination bank account is wrong in actual wire transfer, so
we should count the wire transfer as entirely spurious, and
additionally consider the justified wire transfer as missing. */
TALER_ARL_report (
report_wire_out_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rowid),
TALER_JSON_pack_amount ("amount_wired",
&roi->details.amount),
TALER_JSON_pack_amount ("amount_justified",
&zero),
GNUNET_JSON_pack_data_auto ("wtid",
wtid),
TALER_JSON_pack_time_abs_human ("timestamp",
date.abs_time),
GNUNET_JSON_pack_string ("diagnostic",
"receiver account mismatch"),
GNUNET_JSON_pack_string ("target",
payto_uri),
GNUNET_JSON_pack_string ("account_section",
wa->ai->section_name)));
TALER_ARL_report (report_wire_out_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rowid),
TALER_JSON_pack_amount ("amount_wired",
&roi->details.amount),
TALER_JSON_pack_amount ("amount_justified",
&zero),
GNUNET_JSON_pack_data_auto ("wtid", wtid),
TALER_JSON_pack_time_abs_human ("timestamp",
date),
GNUNET_JSON_pack_string ("diagnostic",
"receiver account mismatch"),
GNUNET_JSON_pack_string ("target",
payto_uri),
GNUNET_JSON_pack_string ("account_section",
wa->ai->section_name)));
TALER_ARL_amount_add (&total_bad_amount_out_plus,
&total_bad_amount_out_plus,
&roi->details.amount);
TALER_ARL_report (
report_wire_out_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rowid),
TALER_JSON_pack_amount ("amount_wired",
&zero),
TALER_JSON_pack_amount ("amount_justified",
amount),
GNUNET_JSON_pack_data_auto ("wtid",
wtid),
TALER_JSON_pack_time_abs_human ("timestamp",
date.abs_time),
GNUNET_JSON_pack_string ("diagnostic",
"receiver account mismatch"),
GNUNET_JSON_pack_string ("target",
roi->details.
credit_account_uri),
GNUNET_JSON_pack_string ("account_section",
wa->ai->section_name)));
TALER_ARL_report (report_wire_out_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rowid),
TALER_JSON_pack_amount ("amount_wired",
&zero),
TALER_JSON_pack_amount ("amount_justified",
amount),
GNUNET_JSON_pack_data_auto ("wtid",
wtid),
TALER_JSON_pack_time_abs_human ("timestamp",
date),
GNUNET_JSON_pack_string ("diagnostic",
"receiver account mismatch"),
GNUNET_JSON_pack_string ("target",
roi->details.
credit_account_uri),
GNUNET_JSON_pack_string ("account_section",
wa->ai->section_name)));
TALER_ARL_amount_add (&total_bad_amount_out_minus,
&total_bad_amount_out_minus,
amount);
@ -1056,23 +1050,22 @@ wire_out_cb (void *cls,
if (0 != TALER_amount_cmp (&roi->details.amount,
amount))
{
TALER_ARL_report (
report_wire_out_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rowid),
TALER_JSON_pack_amount ("amount_justified",
amount),
TALER_JSON_pack_amount ("amount_wired",
&roi->details.amount),
GNUNET_JSON_pack_data_auto ("wtid",
wtid),
TALER_JSON_pack_time_abs_human ("timestamp",
date.abs_time),
GNUNET_JSON_pack_string ("diagnostic",
"wire amount does not match"),
GNUNET_JSON_pack_string ("account_section",
wa->ai->section_name)));
TALER_ARL_report (report_wire_out_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rowid),
TALER_JSON_pack_amount ("amount_justified",
amount),
TALER_JSON_pack_amount ("amount_wired",
&roi->details.amount),
GNUNET_JSON_pack_data_auto ("wtid",
wtid),
TALER_JSON_pack_time_abs_human ("timestamp",
date),
GNUNET_JSON_pack_string ("diagnostic",
"wire amount does not match"),
GNUNET_JSON_pack_string ("account_section",
wa->ai->section_name)));
if (0 < TALER_amount_cmp (amount,
&roi->details.amount))
{
@ -1204,23 +1197,23 @@ complain_out_not_found (void *cls,
&ctx);
if (ctx.found)
return GNUNET_OK;
TALER_ARL_report (
report_wire_out_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
0),
TALER_JSON_pack_amount ("amount_wired",
&roi->details.amount),
TALER_JSON_pack_amount ("amount_justified",
&zero),
GNUNET_JSON_pack_data_auto ("wtid",
&roi->details.wtid),
TALER_JSON_pack_time_abs_human ("timestamp",
roi->details.execution_date.abs_time),
GNUNET_JSON_pack_string ("account_section",
wa->ai->section_name),
GNUNET_JSON_pack_string ("diagnostic",
"justification for wire transfer not found")));
TALER_ARL_report (report_wire_out_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
0),
TALER_JSON_pack_amount ("amount_wired",
&roi->details.amount),
TALER_JSON_pack_amount ("amount_justified",
&zero),
GNUNET_JSON_pack_data_auto ("wtid",
&roi->details.wtid),
TALER_JSON_pack_time_abs_human ("timestamp",
roi->details.
execution_date),
GNUNET_JSON_pack_string ("account_section",
wa->ai->section_name),
GNUNET_JSON_pack_string ("diagnostic",
"justification for wire transfer not found")));
TALER_ARL_amount_add (&total_bad_amount_out_plus,
&total_bad_amount_out_plus,
&roi->details.amount);
@ -1323,7 +1316,7 @@ history_debit_cb (void *cls,
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Analyzing bank DEBIT at %s of %s with WTID %s\n",
GNUNET_TIME_timestamp2s (details->execution_date),
GNUNET_STRINGS_absolute_time_to_string (details->execution_date),
TALER_amount2s (&details->amount),
TALER_B2S (&details->wtid));
/* Update offset */
@ -1466,7 +1459,7 @@ reserve_in_cb (void *cls,
const struct TALER_Amount *credit,
const char *sender_account_details,
uint64_t wire_reference,
struct GNUNET_TIME_Timestamp execution_date)
struct GNUNET_TIME_Absolute execution_date)
{
struct WireAccount *wa = cls;
struct ReserveInInfo *rii;
@ -1475,7 +1468,7 @@ reserve_in_cb (void *cls,
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Analyzing exchange wire IN (%llu) at %s of %s with reserve_pub %s\n",
(unsigned long long) rowid,
GNUNET_TIME_timestamp2s (execution_date),
GNUNET_STRINGS_absolute_time_to_string (execution_date),
TALER_amount2s (credit),
TALER_B2S (reserve_pub));
slen = strlen (sender_account_details) + 1;
@ -1536,23 +1529,23 @@ complain_in_not_found (void *cls,
struct ReserveInInfo *rii = value;
(void) key;
TALER_ARL_report (
report_reserve_in_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rii->rowid),
TALER_JSON_pack_amount ("amount_exchange_expected",
&rii->details.amount),
TALER_JSON_pack_amount ("amount_wired",
&zero),
GNUNET_JSON_pack_data_auto ("reserve_pub",
&rii->details.reserve_pub),
TALER_JSON_pack_time_abs_human ("timestamp",
rii->details.execution_date.abs_time),
GNUNET_JSON_pack_string ("account",
wa->ai->section_name),
GNUNET_JSON_pack_string ("diagnostic",
"incoming wire transfer claimed by exchange not found")));
TALER_ARL_report (report_reserve_in_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rii->rowid),
TALER_JSON_pack_amount ("amount_exchange_expected",
&rii->details.amount),
TALER_JSON_pack_amount ("amount_wired",
&zero),
GNUNET_JSON_pack_data_auto ("reserve_pub",
&rii->details.reserve_pub),
TALER_JSON_pack_time_abs_human ("timestamp",
rii->details.
execution_date),
GNUNET_JSON_pack_string ("account",
wa->ai->section_name),
GNUNET_JSON_pack_string ("diagnostic",
"incoming wire transfer claimed by exchange not found")));
TALER_ARL_amount_add (&total_bad_amount_in_minus,
&total_bad_amount_in_minus,
&rii->details.amount);
@ -1627,7 +1620,7 @@ history_credit_cb (void *cls,
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Analyzing bank CREDIT at %s of %s with Reserve-pub %s\n",
GNUNET_TIME_timestamp2s (details->execution_date),
GNUNET_STRINGS_absolute_time_to_string (details->execution_date),
TALER_amount2s (&details->amount),
TALER_B2S (&details->reserve_pub));
GNUNET_CRYPTO_hash (&row_off,
@ -1639,7 +1632,8 @@ history_credit_cb (void *cls,
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Failed to find wire transfer at `%s' in exchange database. Audit ends at this point in time.\n",
GNUNET_TIME_timestamp2s (details->execution_date));
GNUNET_STRINGS_absolute_time_to_string (
details->execution_date));
wa->chh = NULL;
process_credits (wa->next);
return GNUNET_SYSERR; /* not an error, just end of processing */
@ -1651,43 +1645,42 @@ history_credit_cb (void *cls,
if (0 != GNUNET_memcmp (&details->reserve_pub,
&rii->details.reserve_pub))
{
TALER_ARL_report (
report_reserve_in_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rii->rowid),
GNUNET_JSON_pack_uint64 ("bank_row",
row_off),
TALER_JSON_pack_amount ("amount_exchange_expected",
&rii->details.amount),
TALER_JSON_pack_amount ("amount_wired",
&zero),
GNUNET_JSON_pack_data_auto ("reserve_pub",
&rii->details.reserve_pub),
TALER_JSON_pack_time_abs_human ("timestamp",
rii->details.execution_date.abs_time),
GNUNET_JSON_pack_string ("diagnostic",
"wire subject does not match")));
TALER_ARL_report (report_reserve_in_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rii->rowid),
GNUNET_JSON_pack_uint64 ("bank_row",
row_off),
TALER_JSON_pack_amount ("amount_exchange_expected",
&rii->details.amount),
TALER_JSON_pack_amount ("amount_wired",
&zero),
GNUNET_JSON_pack_data_auto ("reserve_pub",
&rii->details.reserve_pub),
TALER_JSON_pack_time_abs_human ("timestamp",
rii->details.
execution_date),
GNUNET_JSON_pack_string ("diagnostic",
"wire subject does not match")));
TALER_ARL_amount_add (&total_bad_amount_in_minus,
&total_bad_amount_in_minus,
&rii->details.amount);
TALER_ARL_report (
report_reserve_in_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rii->rowid),
GNUNET_JSON_pack_uint64 ("bank_row",
row_off),
TALER_JSON_pack_amount ("amount_exchange_expected",
&zero),
TALER_JSON_pack_amount ("amount_wired",
&details->amount),
GNUNET_JSON_pack_data_auto ("reserve_pub",
&details->reserve_pub),
TALER_JSON_pack_time_abs_human ("timestamp",
details->execution_date.abs_time),
GNUNET_JSON_pack_string ("diagnostic",
"wire subject does not match")));
TALER_ARL_report (report_reserve_in_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rii->rowid),
GNUNET_JSON_pack_uint64 ("bank_row",
row_off),
TALER_JSON_pack_amount ("amount_exchange_expected",
&zero),
TALER_JSON_pack_amount ("amount_wired",
&details->amount),
GNUNET_JSON_pack_data_auto ("reserve_pub",
&details->reserve_pub),
TALER_JSON_pack_time_abs_human ("timestamp",
details->execution_date),
GNUNET_JSON_pack_string ("diagnostic",
"wire subject does not match")));
TALER_ARL_amount_add (&total_bad_amount_in_plus,
&total_bad_amount_in_plus,
@ -1697,23 +1690,22 @@ history_credit_cb (void *cls,
if (0 != TALER_amount_cmp (&rii->details.amount,
&details->amount))
{
TALER_ARL_report (
report_reserve_in_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rii->rowid),
GNUNET_JSON_pack_uint64 ("bank_row",
row_off),
TALER_JSON_pack_amount ("amount_exchange_expected",
&rii->details.amount),
TALER_JSON_pack_amount ("amount_wired",
&details->amount),
GNUNET_JSON_pack_data_auto ("reserve_pub",
&details->reserve_pub),
TALER_JSON_pack_time_abs_human ("timestamp",
details->execution_date.abs_time),
GNUNET_JSON_pack_string ("diagnostic",
"wire amount does not match")));
TALER_ARL_report (report_reserve_in_inconsistencies,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row",
rii->rowid),
GNUNET_JSON_pack_uint64 ("bank_row",
row_off),
TALER_JSON_pack_amount ("amount_exchange_expected",
&rii->details.amount),
TALER_JSON_pack_amount ("amount_wired",
&details->amount),
GNUNET_JSON_pack_data_auto ("reserve_pub",
&details->reserve_pub),
TALER_JSON_pack_time_abs_human ("timestamp",
details->execution_date),
GNUNET_JSON_pack_string ("diagnostic",
"wire amount does not match")));
if (0 < TALER_amount_cmp (&details->amount,
&rii->details.amount))
{
@ -1759,9 +1751,8 @@ history_credit_cb (void *cls,
&total_missattribution_in,
&rii->details.amount);
}
if (GNUNET_TIME_timestamp_cmp (details->execution_date,
!=,
rii->details.execution_date))
if (details->execution_date.abs_value_us !=
rii->details.execution_date.abs_value_us)
{
TALER_ARL_report (report_row_minor_inconsistencies,
GNUNET_JSON_PACK (
@ -1877,7 +1868,7 @@ begin_credit_audit (void)
static int
reserve_closed_cb (void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp execution_date,
struct GNUNET_TIME_Absolute execution_date,
const struct TALER_Amount *amount_with_fee,
const struct TALER_Amount *closing_fee,
const struct TALER_ReservePublicKeyP *reserve_pub,
@ -2005,7 +1996,7 @@ begin_transaction (void)
start_pp = pp;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Resuming wire audit at %s / %llu\n",
GNUNET_TIME_timestamp2s (pp.last_timestamp),
GNUNET_STRINGS_absolute_time_to_string (pp.last_timestamp),
(unsigned long long) pp.last_reserve_close_uuid);
}

88
src/auditordb/plugin_auditordb_postgres.c
View File

@ -792,13 +792,13 @@ postgres_commit (void *cls)
* @return #GNUNET_OK on success,
* #GNUNET_SYSERR on DB errors
*/
static enum GNUNET_GenericReturnValue
static int
postgres_gc (void *cls)
{
struct PostgresClosure *pg = cls;
struct GNUNET_TIME_Absolute now;
struct GNUNET_PQ_QueryParam params_time[] = {
GNUNET_PQ_query_param_absolute_time (&now),
TALER_PQ_query_param_absolute_time (&now),
GNUNET_PQ_query_param_end
};
struct GNUNET_PQ_Context *conn;
@ -1003,9 +1003,9 @@ postgres_insert_exchange_signkey (
struct PostgresClosure *pg = cls;
struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_auto_from_type (&sk->master_public_key),
GNUNET_PQ_query_param_timestamp (&sk->ep_start),
GNUNET_PQ_query_param_timestamp (&sk->ep_expire),
GNUNET_PQ_query_param_timestamp (&sk->ep_end),
TALER_PQ_query_param_absolute_time (&sk->ep_start),
TALER_PQ_query_param_absolute_time (&sk->ep_expire),
TALER_PQ_query_param_absolute_time (&sk->ep_end),
GNUNET_PQ_query_param_auto_from_type (&sk->exchange_pub),
GNUNET_PQ_query_param_auto_from_type (&sk->master_sig),
GNUNET_PQ_query_param_end
@ -1035,9 +1035,9 @@ postgres_insert_deposit_confirmation (
GNUNET_PQ_query_param_auto_from_type (&dc->h_contract_terms),
GNUNET_PQ_query_param_auto_from_type (&dc->h_extensions),
GNUNET_PQ_query_param_auto_from_type (&dc->h_wire),
GNUNET_PQ_query_param_timestamp (&dc->exchange_timestamp),
GNUNET_PQ_query_param_timestamp (&dc->wire_deadline),
GNUNET_PQ_query_param_timestamp (&dc->refund_deadline),
TALER_PQ_query_param_absolute_time (&dc->exchange_timestamp),
TALER_PQ_query_param_absolute_time (&dc->wire_deadline),
TALER_PQ_query_param_absolute_time (&dc->refund_deadline),
TALER_PQ_query_param_amount (&dc->amount_without_fee),
GNUNET_PQ_query_param_auto_from_type (&dc->coin_pub),
GNUNET_PQ_query_param_auto_from_type (&dc->merchant),
@ -1118,12 +1118,12 @@ deposit_confirmation_cb (void *cls,
&dc.h_extensions),
GNUNET_PQ_result_spec_auto_from_type ("h_wire",
&dc.h_wire),
GNUNET_PQ_result_spec_timestamp ("exchange_timestamp",
&dc.exchange_timestamp),
GNUNET_PQ_result_spec_timestamp ("refund_deadline",
&dc.refund_deadline),
GNUNET_PQ_result_spec_timestamp ("wire_deadline",
&dc.wire_deadline),
GNUNET_PQ_result_spec_absolute_time ("exchange_timestamp",
&dc.exchange_timestamp),
GNUNET_PQ_result_spec_absolute_time ("refund_deadline",
&dc.refund_deadline),
GNUNET_PQ_result_spec_absolute_time ("wire_deadline",
&dc.wire_deadline),
TALER_PQ_RESULT_SPEC_AMOUNT ("amount_without_fee",
&dc.amount_without_fee),
GNUNET_PQ_result_spec_auto_from_type ("coin_pub",
@ -1726,7 +1726,7 @@ postgres_insert_wire_auditor_progress (
struct PostgresClosure *pg = cls;
struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_auto_from_type (master_pub),
GNUNET_PQ_query_param_timestamp (&pp->last_timestamp),
TALER_PQ_query_param_absolute_time (&pp->last_timestamp),
GNUNET_PQ_query_param_uint64 (&pp->last_reserve_close_uuid),
GNUNET_PQ_query_param_end
};
@ -1754,7 +1754,7 @@ postgres_update_wire_auditor_progress (
{
struct PostgresClosure *pg = cls;
struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_timestamp (&pp->last_timestamp),
TALER_PQ_query_param_absolute_time (&pp->last_timestamp),
GNUNET_PQ_query_param_uint64 (&pp->last_reserve_close_uuid),
GNUNET_PQ_query_param_auto_from_type (master_pub),
GNUNET_PQ_query_param_end
@ -1786,8 +1786,8 @@ postgres_get_wire_auditor_progress (
GNUNET_PQ_query_param_end
};
struct GNUNET_PQ_ResultSpec rs[] = {
GNUNET_PQ_result_spec_timestamp ("last_timestamp",
&pp->last_timestamp),
TALER_PQ_result_spec_absolute_time ("last_timestamp",
&pp->last_timestamp),
GNUNET_PQ_result_spec_uint64 ("last_reserve_close_uuid",
&pp->last_reserve_close_uuid),
GNUNET_PQ_result_spec_end
@ -1820,7 +1820,7 @@ postgres_insert_reserve_info (void *cls,
const struct TALER_MasterPublicKeyP *master_pub,
const struct TALER_Amount *reserve_balance,
const struct TALER_Amount *withdraw_fee_balance,
struct GNUNET_TIME_Timestamp expiration_date,
struct GNUNET_TIME_Absolute expiration_date,
const char *origin_account)
{
struct PostgresClosure *pg = cls;
@ -1829,7 +1829,7 @@ postgres_insert_reserve_info (void *cls,
GNUNET_PQ_query_param_auto_from_type (master_pub),
TALER_PQ_query_param_amount (reserve_balance),
TALER_PQ_query_param_amount (withdraw_fee_balance),
GNUNET_PQ_query_param_timestamp (&expiration_date),
TALER_PQ_query_param_absolute_time (&expiration_date),
GNUNET_PQ_query_param_string (origin_account),
GNUNET_PQ_query_param_end
};
@ -1863,13 +1863,13 @@ postgres_update_reserve_info (void *cls,
const struct TALER_MasterPublicKeyP *master_pub,
const struct TALER_Amount *reserve_balance,
const struct TALER_Amount *withdraw_fee_balance,
struct GNUNET_TIME_Timestamp expiration_date)
struct GNUNET_TIME_Absolute expiration_date)
{
struct PostgresClosure *pg = cls;
struct GNUNET_PQ_QueryParam params[] = {
TALER_PQ_query_param_amount (reserve_balance),
TALER_PQ_query_param_amount (withdraw_fee_balance),
GNUNET_PQ_query_param_timestamp (&expiration_date),
TALER_PQ_query_param_absolute_time (&expiration_date),
GNUNET_PQ_query_param_auto_from_type (reserve_pub),
GNUNET_PQ_query_param_auto_from_type (master_pub),
GNUNET_PQ_query_param_end
@ -1932,7 +1932,7 @@ postgres_get_reserve_info (void *cls,
uint64_t *rowid,
struct TALER_Amount *reserve_balance,
struct TALER_Amount *withdraw_fee_balance,
struct GNUNET_TIME_Timestamp *expiration_date,
struct GNUNET_TIME_Absolute *expiration_date,
char **sender_account)
{
struct PostgresClosure *pg = cls;
@ -1944,7 +1944,7 @@ postgres_get_reserve_info (void *cls,
struct GNUNET_PQ_ResultSpec rs[] = {
TALER_PQ_RESULT_SPEC_AMOUNT ("reserve_balance", reserve_balance),
TALER_PQ_RESULT_SPEC_AMOUNT ("withdraw_fee_balance", withdraw_fee_balance),
GNUNET_PQ_result_spec_timestamp ("expiration_date", expiration_date),
TALER_PQ_result_spec_absolute_time ("expiration_date", expiration_date),
GNUNET_PQ_result_spec_uint64 ("auditor_reserves_rowid", rowid),
GNUNET_PQ_result_spec_string ("origin_account", sender_account),
GNUNET_PQ_result_spec_end
@ -2440,7 +2440,7 @@ postgres_insert_historic_denom_revenue (
void *cls,
const struct TALER_MasterPublicKeyP *master_pub,
const struct TALER_DenominationHash *denom_pub_hash,
struct GNUNET_TIME_Timestamp revenue_timestamp,
struct GNUNET_TIME_Absolute revenue_timestamp,
const struct TALER_Amount *revenue_balance,
const struct TALER_Amount *loss_balance)
{
@ -2448,7 +2448,7 @@ postgres_insert_historic_denom_revenue (
struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_auto_from_type (master_pub),
GNUNET_PQ_query_param_auto_from_type (denom_pub_hash),
GNUNET_PQ_query_param_timestamp (&revenue_timestamp),
TALER_PQ_query_param_absolute_time (&revenue_timestamp),
TALER_PQ_query_param_amount (revenue_balance),
TALER_PQ_query_param_amount (loss_balance),
GNUNET_PQ_query_param_end
@ -2507,18 +2507,15 @@ historic_denom_revenue_cb (void *cls,
for (unsigned int i = 0; i < num_results; i++)
{
struct TALER_DenominationHash denom_pub_hash;
struct GNUNET_TIME_Timestamp revenue_timestamp;
struct GNUNET_TIME_Absolute revenue_timestamp;
struct TALER_Amount revenue_balance;
struct TALER_Amount loss;
struct GNUNET_PQ_ResultSpec rs[] = {
GNUNET_PQ_result_spec_auto_from_type ("denom_pub_hash",
&denom_pub_hash),
GNUNET_PQ_result_spec_timestamp ("revenue_timestamp",
&revenue_timestamp),
TALER_PQ_RESULT_SPEC_AMOUNT ("revenue_balance",
&revenue_balance),
TALER_PQ_RESULT_SPEC_AMOUNT ("loss_balance",
&loss),
GNUNET_PQ_result_spec_auto_from_type ("denom_pub_hash", &denom_pub_hash),
TALER_PQ_result_spec_absolute_time ("revenue_timestamp",
&revenue_timestamp),
TALER_PQ_RESULT_SPEC_AMOUNT ("revenue_balance", &revenue_balance),
TALER_PQ_RESULT_SPEC_AMOUNT ("loss_balance", &loss),
GNUNET_PQ_result_spec_end
};
@ -2598,15 +2595,15 @@ static enum GNUNET_DB_QueryStatus
postgres_insert_historic_reserve_revenue (
void *cls,
const struct TALER_MasterPublicKeyP *master_pub,
struct GNUNET_TIME_Timestamp start_time,
struct GNUNET_TIME_Timestamp end_time,
struct GNUNET_TIME_Absolute start_time,
struct GNUNET_TIME_Absolute end_time,
const struct TALER_Amount *reserve_profits)
{
struct PostgresClosure *pg = cls;
struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_auto_from_type (master_pub),
GNUNET_PQ_query_param_timestamp (&start_time),
GNUNET_PQ_query_param_timestamp (&end_time),
TALER_PQ_query_param_absolute_time (&start_time),
TALER_PQ_query_param_absolute_time (&end_time),
TALER_PQ_query_param_amount (reserve_profits),
GNUNET_PQ_query_param_end
};
@ -2663,16 +2660,13 @@ historic_reserve_revenue_cb (void *cls,
for (unsigned int i = 0; i < num_results; i++)
{
struct GNUNET_TIME_Timestamp start_date;
struct GNUNET_TIME_Timestamp end_date;
struct GNUNET_TIME_Absolute start_date;
struct GNUNET_TIME_Absolute end_date;
struct TALER_Amount reserve_profits;
struct GNUNET_PQ_ResultSpec rs[] = {
GNUNET_PQ_result_spec_timestamp ("start_date",
&start_date),
GNUNET_PQ_result_spec_timestamp ("end_date",
&end_date),
TALER_PQ_RESULT_SPEC_AMOUNT ("reserve_profits",
&reserve_profits),
TALER_PQ_result_spec_absolute_time ("start_date", &start_date),
TALER_PQ_result_spec_absolute_time ("end_date", &end_date),
TALER_PQ_RESULT_SPEC_AMOUNT ("reserve_profits", &reserve_profits),
GNUNET_PQ_result_spec_end
};

42
src/auditordb/test_auditordb.c
View File

@ -134,10 +134,10 @@ run (void *cls)
struct TALER_DenominationPrivateKey denom_priv;
struct TALER_DenominationPublicKey denom_pub;
struct TALER_DenominationHash denom_pub_hash;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Timestamp past;
struct GNUNET_TIME_Timestamp future;
struct GNUNET_TIME_Timestamp date;
struct GNUNET_TIME_Absolute now;
struct GNUNET_TIME_Absolute past;
struct GNUNET_TIME_Absolute future;
struct GNUNET_TIME_Absolute date;
RND_BLK (&master_pub);
RND_BLK (&reserve_pub);
@ -152,17 +152,16 @@ run (void *cls)
TALER_denom_priv_free (&denom_priv);
TALER_denom_pub_free (&denom_pub);
now = GNUNET_TIME_timestamp_get ();
past = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_subtract (now.abs_time,
GNUNET_TIME_relative_multiply (
GNUNET_TIME_UNIT_HOURS,
4)));
future = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (now.abs_time,
GNUNET_TIME_relative_multiply (
GNUNET_TIME_UNIT_HOURS,
4)));
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
past = GNUNET_TIME_absolute_subtract (now,
GNUNET_TIME_relative_multiply (
GNUNET_TIME_UNIT_HOURS,
4));
future = GNUNET_TIME_absolute_add (now,
GNUNET_TIME_relative_multiply (
GNUNET_TIME_UNIT_HOURS,
4));
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Test: auditor_insert_exchange\n");
@ -489,7 +488,7 @@ run (void *cls)
select_historic_denom_revenue_result (
void *cls,
const struct TALER_DenominationHash *denom_pub_hash2,
struct GNUNET_TIME_Timestamp revenue_timestamp2,
struct GNUNET_TIME_Absolute revenue_timestamp2,
const struct TALER_Amount *revenue_balance2,
const struct TALER_Amount *loss2)
{
@ -549,11 +548,12 @@ run (void *cls)
"Test: select_historic_reserve_revenue\n");
int
select_historic_reserve_revenue_result (
void *cls,
struct GNUNET_TIME_Timestamp start_time2,
struct GNUNET_TIME_Timestamp end_time2,
const struct TALER_Amount *reserve_profits2)
select_historic_reserve_revenue_result (void *cls,
struct GNUNET_TIME_Absolute
start_time2,
struct GNUNET_TIME_Absolute end_time2,
const struct
TALER_Amount *reserve_profits2)
{
static int n = 0;

31
src/bank-lib/bank_api_admin.c
View File

@ -75,12 +75,12 @@ handle_admin_add_incoming_finished (void *cls,
{
struct TALER_BANK_AdminAddIncomingHandle *aai = cls;
uint64_t row_id = UINT64_MAX;
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
enum TALER_ErrorCode ec;
const json_t *j = response;
aai->job = NULL;
timestamp = GNUNET_TIME_UNIT_FOREVER_TS;
timestamp = GNUNET_TIME_UNIT_FOREVER_ABS;
switch (response_code)
{
case 0:
@ -91,8 +91,8 @@ handle_admin_add_incoming_finished (void *cls,
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_uint64 ("row_id",
&row_id),
GNUNET_JSON_spec_timestamp ("timestamp",
&timestamp),
TALER_JSON_spec_absolute_time ("timestamp",
&timestamp),
GNUNET_JSON_spec_end ()
};
@ -158,6 +158,23 @@ handle_admin_add_incoming_finished (void *cls,
}
/**
* Perform a wire transfer from some account to the exchange to fill a
* reserve. Note that this API is usually only used for testing (with
* fakebank and our Python bank) and thus may not be accessible in a
* production setting.
*
* @param ctx curl context for the event loop
* @param auth authentication data to send to the bank
* @param reserve_pub wire transfer subject for the transfer
* @param amount amount that was is to be deposited
* @param debit_account account to deposit from (payto URI, but used as 'payfrom')
* @param res_cb the callback to call when the final result for this request is available
* @param res_cb_cls closure for the above callback
* @return NULL
* if the inputs are invalid (i.e. invalid amount) or internal errors.
* In this case, the callback is not called.
*/
struct TALER_BANK_AdminAddIncomingHandle *
TALER_BANK_admin_add_incoming (
struct GNUNET_CURL_Context *ctx,
@ -251,6 +268,12 @@ TALER_BANK_admin_add_incoming (
}
/**
* Cancel an add incoming. This function cannot be used on a request
* handle if a response is already served for it.
*
* @param aai the admin add incoming request handle
*/
void
TALER_BANK_admin_add_incoming_cancel (
struct TALER_BANK_AdminAddIncomingHandle *aai)

9
src/bank-lib/bank_api_common.c
View File

@ -23,6 +23,15 @@
#include "bank_api_common.h"
/**
* Set authentication data in @a easy from @a auth.
* The API currently specifies the use of HTTP basic
* authentication.
*
* @param easy curl handle to setup for authentication
* @param auth authentication data to use
* @return #GNUNET_OK in success
*/
int
TALER_BANK_setup_auth_ (CURL *easy,
const struct TALER_BANK_AuthenticationData *auth)

4
src/bank-lib/bank_api_credit.c
View File

@ -97,8 +97,8 @@ parse_account_history (struct TALER_BANK_CreditHistoryHandle *hh,
struct GNUNET_JSON_Specification hist_spec[] = {
TALER_JSON_spec_amount_any ("amount",
&td.amount),
GNUNET_JSON_spec_timestamp ("date",
&td.execution_date),
TALER_JSON_spec_absolute_time ("date",
&td.execution_date),
GNUNET_JSON_spec_uint64 ("row_id",
&row_id),
GNUNET_JSON_spec_fixed_auto ("reserve_pub",

6
src/bank-lib/bank_api_debit.c
View File

@ -73,7 +73,7 @@ struct TALER_BANK_DebitHistoryHandle
* were set,
* #GNUNET_SYSERR if there was a protocol violation in @a history
*/
static enum GNUNET_GenericReturnValue
static int
parse_account_history (struct TALER_BANK_DebitHistoryHandle *hh,
const json_t *history)
{
@ -97,8 +97,8 @@ parse_account_history (struct TALER_BANK_DebitHistoryHandle *hh,
struct GNUNET_JSON_Specification hist_spec[] = {
TALER_JSON_spec_amount_any ("amount",
&td.amount),
GNUNET_JSON_spec_timestamp ("date",
&td.execution_date),
TALER_JSON_spec_absolute_time ("date",
&td.execution_date),
GNUNET_JSON_spec_uint64 ("row_id",
&row_id),
GNUNET_JSON_spec_fixed_auto ("wtid",

16
src/bank-lib/bank_api_parse.c
View File

@ -23,7 +23,15 @@
#include "taler_bank_service.h"
enum GNUNET_GenericReturnValue
/**
* Parse configuration section with bank authentication data.
*
* @param cfg configuration to parse
* @param section the section with the configuration data
* @param[out] auth set to the configuration data found
* @return #GNUNET_OK on success
*/
int
TALER_BANK_auth_parse_cfg (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *section,
struct TALER_BANK_AuthenticationData *auth)
@ -114,6 +122,12 @@ TALER_BANK_auth_parse_cfg (const struct GNUNET_CONFIGURATION_Handle *cfg,
}
/**
* Free memory inside of @a auth (but not @a auth itself).
* Dual to #TALER_BANK_auth_parse_cfg().
*
* @param[in] auth authentication data to free
*/
void
TALER_BANK_auth_free (struct TALER_BANK_AuthenticationData *auth)
{

6
src/bank-lib/bank_api_transfer.c
View File

@ -170,7 +170,7 @@ handle_transfer_finished (void *cls,
struct TALER_BANK_TransferHandle *th = cls;
const json_t *j = response;
uint64_t row_id = UINT64_MAX;
struct GNUNET_TIME_Timestamp timestamp = GNUNET_TIME_UNIT_FOREVER_TS;
struct GNUNET_TIME_Absolute timestamp = GNUNET_TIME_UNIT_FOREVER_ABS;
enum TALER_ErrorCode ec;
th->job = NULL;
@ -184,8 +184,8 @@ handle_transfer_finished (void *cls,
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_uint64 ("row_id",
&row_id),
GNUNET_JSON_spec_timestamp ("timestamp",
&timestamp),
TALER_JSON_spec_absolute_time ("timestamp",
&timestamp),
GNUNET_JSON_spec_end ()
};

35
src/bank-lib/fakebank.c
View File

@ -219,7 +219,7 @@ struct Transaction
/**
* When did the transaction happen?
*/
struct GNUNET_TIME_Timestamp date;
struct GNUNET_TIME_Absolute date;
/**
* Number of this transaction.
@ -963,7 +963,7 @@ make_transfer (
const char *exchange_base_url,
const struct GNUNET_HashCode *request_uid,
uint64_t *ret_row_id,
struct GNUNET_TIME_Timestamp *timestamp)
struct GNUNET_TIME_Absolute *timestamp)
{
struct Transaction *t;
struct Account *debit_acc;
@ -1022,9 +1022,9 @@ make_transfer (
t->debit_account = debit_acc;
t->credit_account = credit_acc;
t->amount = *amount;
t->date = GNUNET_TIME_timestamp_get ();
if (NULL != timestamp)
*timestamp = t->date;
t->date = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&t->date);
*timestamp = t->date;
t->type = T_DEBIT;
memcpy (t->subject.debit.exchange_base_url,
exchange_base_url,
@ -1082,7 +1082,7 @@ make_admin_transfer (
const struct TALER_Amount *amount,
const struct TALER_ReservePublicKeyP *reserve_pub,
uint64_t *row_id,
struct GNUNET_TIME_Timestamp *timestamp)
struct GNUNET_TIME_Absolute *timestamp)
{
struct Transaction *t;
const struct GNUNET_PeerIdentity *pid;
@ -1125,7 +1125,8 @@ make_admin_transfer (
t->debit_account = debit_acc;
t->credit_account = credit_acc;
t->amount = *amount;
t->date = GNUNET_TIME_timestamp_get ();
t->date = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&t->date);
if (NULL != timestamp)
*timestamp = t->date;
t->type = T_CREDIT;
@ -1333,7 +1334,7 @@ handle_admin_add_incoming (struct TALER_FAKEBANK_Handle *h,
enum GNUNET_JSON_PostResult pr;
json_t *json;
uint64_t row_id;
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
pr = GNUNET_JSON_post_parser (REQUEST_BUFFER_MAX,
connection,
@ -1430,8 +1431,8 @@ handle_admin_add_incoming (struct TALER_FAKEBANK_Handle *h,
MHD_HTTP_OK,
GNUNET_JSON_pack_uint64 ("row_id",
row_id),
GNUNET_JSON_pack_timestamp ("timestamp",
timestamp));
GNUNET_JSON_pack_time_abs ("timestamp",
timestamp));
}
@ -1457,7 +1458,7 @@ handle_transfer (struct TALER_FAKEBANK_Handle *h,
enum GNUNET_JSON_PostResult pr;
json_t *json;
uint64_t row_id;
struct GNUNET_TIME_Timestamp ts;
struct GNUNET_TIME_Absolute ts;
pr = GNUNET_JSON_post_parser (REQUEST_BUFFER_MAX,
connection,
@ -1560,8 +1561,8 @@ handle_transfer (struct TALER_FAKEBANK_Handle *h,
MHD_HTTP_OK,
GNUNET_JSON_pack_uint64 ("row_id",
row_id),
GNUNET_JSON_pack_timestamp ("timestamp",
ts));
GNUNET_JSON_pack_time_abs ("timestamp",
ts));
}
@ -2015,8 +2016,8 @@ handle_debit_history (struct TALER_FAKEBANK_Handle *h,
trans = GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row_id",
pos->row_id),
GNUNET_JSON_pack_timestamp ("date",
pos->date),
GNUNET_JSON_pack_time_abs ("date",
pos->date),
TALER_JSON_pack_amount ("amount",
&pos->amount),
GNUNET_JSON_pack_string ("credit_account",
@ -2214,8 +2215,8 @@ handle_credit_history (struct TALER_FAKEBANK_Handle *h,
trans = GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("row_id",
pos->row_id),
GNUNET_JSON_pack_timestamp ("date",
pos->date),
GNUNET_JSON_pack_time_abs ("date",
pos->date),
TALER_JSON_pack_amount ("amount",
&pos->amount),
GNUNET_JSON_pack_string ("credit_account",

10
src/bank-lib/taler-exchange-wire-gateway-client.c
View File

@ -227,7 +227,7 @@ credit_history_cb (void *cls,
details->credit_account_uri,
TALER_B2S (&details->reserve_pub),
TALER_amount2s (&details->amount),
GNUNET_TIME_timestamp2s (details->execution_date));
GNUNET_STRINGS_absolute_time_to_string (details->execution_date));
return GNUNET_OK;
}
@ -340,7 +340,7 @@ debit_history_cb (void *cls,
details->credit_account_uri,
TALER_B2S (&details->wtid),
TALER_amount2s (&details->amount),
GNUNET_TIME_timestamp2s (details->execution_date));
GNUNET_STRINGS_absolute_time_to_string (details->execution_date));
return GNUNET_OK;
}
@ -391,7 +391,7 @@ confirmation_cb (void *cls,
unsigned int response_code,
enum TALER_ErrorCode ec,
uint64_t row_id,
struct GNUNET_TIME_Timestamp timestamp)
struct GNUNET_TIME_Absolute timestamp)
{
(void) cls;
eh = NULL;
@ -408,7 +408,7 @@ confirmation_cb (void *cls,
fprintf (stdout,
"Wire transfer #%llu executed successfully at %s.\n",
(unsigned long long) row_id,
GNUNET_TIME_timestamp2s (timestamp));
GNUNET_STRINGS_absolute_time_to_string (timestamp));
global_ret = 0;
GNUNET_SCHEDULER_shutdown ();
}
@ -500,7 +500,7 @@ res_cb (void *cls,
unsigned int http_status,
enum TALER_ErrorCode ec,
uint64_t serial_id,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Absolute timestamp,
const json_t *json)
{
(void) cls;

48
src/benchmark/taler-aggregator-benchmark.c
View File

@ -86,12 +86,12 @@ static struct TALER_DenominationSignature denom_sig;
/**
* Time range when deposits start.
*/
static struct GNUNET_TIME_Timestamp start;
static struct GNUNET_TIME_Absolute start;
/**
* Time range when deposits end.
*/
static struct GNUNET_TIME_Timestamp end;
static struct GNUNET_TIME_Absolute end;
/**
@ -171,17 +171,18 @@ make_amountN (unsigned int val,
*
* @return time stamp between start and end
*/
static struct GNUNET_TIME_Timestamp
static struct GNUNET_TIME_Absolute
random_time (void)
{
uint64_t delta;
struct GNUNET_TIME_Absolute ret;
delta = end.abs_time.abs_value_us - start.abs_time.abs_value_us;
delta = end.abs_value_us - start.abs_value_us;
delta = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_NONCE,
delta);
ret.abs_value_us = start.abs_time.abs_value_us + delta;
return GNUNET_TIME_absolute_to_timestamp (ret);
ret.abs_value_us = start.abs_value_us + delta;
(void) GNUNET_TIME_round_abs (&ret);
return ret;
}
@ -432,10 +433,11 @@ run (void *cls,
/* make sure everything 'ends' before the current time,
so that the aggregator will process everything without
need for time-travel */
end = GNUNET_TIME_timestamp_get ();
start = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_subtract (end.abs_time,
GNUNET_TIME_UNIT_MONTHS));
end = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&end);
start = GNUNET_TIME_absolute_subtract (end,
GNUNET_TIME_UNIT_MONTHS);
(void) GNUNET_TIME_round_abs (&start);
cfg = c;
if (GNUNET_OK !=
TALER_config_get_currency (cfg,
@ -465,19 +467,17 @@ run (void *cls,
issue.properties.purpose.size = htonl (sizeof (issue.properties));
RANDOMIZE (&issue.properties.master);
issue.properties.start
= GNUNET_TIME_timestamp_hton (start);
= GNUNET_TIME_absolute_hton (start);
issue.properties.expire_withdraw
= GNUNET_TIME_timestamp_hton (
GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (start.abs_time,
GNUNET_TIME_UNIT_DAYS)));
= GNUNET_TIME_absolute_hton (
GNUNET_TIME_absolute_add (start,
GNUNET_TIME_UNIT_DAYS));
issue.properties.expire_deposit
= GNUNET_TIME_timestamp_hton (end);
= GNUNET_TIME_absolute_hton (end);
issue.properties.expire_legal
= GNUNET_TIME_timestamp_hton (
GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (end.abs_time,
GNUNET_TIME_UNIT_YEARS)));
= GNUNET_TIME_absolute_hton (
GNUNET_TIME_absolute_add (end,
GNUNET_TIME_UNIT_YEARS));
{
struct TALER_DenominationPrivateKey pk;
struct TALER_DenominationPublicKey denom_pub;
@ -541,14 +541,14 @@ run (void *cls,
struct TALER_Amount wire_fee;
struct TALER_MasterSignatureP master_sig;
unsigned int year;
struct GNUNET_TIME_Timestamp ws;
struct GNUNET_TIME_Timestamp we;
struct GNUNET_TIME_Absolute ws;
struct GNUNET_TIME_Absolute we;
year = GNUNET_TIME_get_current_year ();
for (unsigned int y = year - 1; y<year + 2; y++)
{
ws = GNUNET_TIME_absolute_to_timestamp (GNUNET_TIME_year_to_time (y - 1));
we = GNUNET_TIME_absolute_to_timestamp (GNUNET_TIME_year_to_time (y));
ws = GNUNET_TIME_year_to_time (y - 1);
we = GNUNET_TIME_year_to_time (y);
make_amount (0, 5, &wire_fee);
memset (&master_sig,
0,

2
src/exchange-tools/Makefile.am
View File

@ -53,6 +53,8 @@ taler_exchange_dbinit_LDADD = \
$(top_builddir)/src/exchangedb/libtalerexchangedb.la \
-lgnunetutil \
$(XLIB)
taler_exchange_dbinit_LDFLAGS = \
$(POSTGRESQL_LDFLAGS)
taler_exchange_dbinit_CPPFLAGS = \
-I$(top_srcdir)/src/include \
-I$(top_srcdir)/src/pq/ \

63
src/exchange-tools/taler-auditor-offline.c
View File

@ -752,10 +752,10 @@ show_denomkeys (const json_t *denomkeys)
const char *err_name;
unsigned int err_line;
struct TALER_DenominationPublicKey denom_pub;
struct GNUNET_TIME_Timestamp stamp_start;
struct GNUNET_TIME_Timestamp stamp_expire_withdraw;
struct GNUNET_TIME_Timestamp stamp_expire_deposit;
struct GNUNET_TIME_Timestamp stamp_expire_legal;
struct GNUNET_TIME_Absolute stamp_start;
struct GNUNET_TIME_Absolute stamp_expire_withdraw;
struct GNUNET_TIME_Absolute stamp_expire_deposit;
struct GNUNET_TIME_Absolute stamp_expire_legal;
struct TALER_Amount coin_value;
struct TALER_Amount fee_withdraw;
struct TALER_Amount fee_deposit;
@ -780,14 +780,14 @@ show_denomkeys (const json_t *denomkeys)
TALER_JSON_spec_amount ("fee_refund",
currency,
&fee_refund),
GNUNET_JSON_spec_timestamp ("stamp_start",
&stamp_start),
GNUNET_JSON_spec_timestamp ("stamp_expire_withdraw",
&stamp_expire_withdraw),
GNUNET_JSON_spec_timestamp ("stamp_expire_deposit",
&stamp_expire_deposit),
GNUNET_JSON_spec_timestamp ("stamp_expire_legal",
&stamp_expire_legal),
GNUNET_JSON_spec_absolute_time ("stamp_start",
&stamp_start),
GNUNET_JSON_spec_absolute_time ("stamp_expire_withdraw",
&stamp_expire_withdraw),
GNUNET_JSON_spec_absolute_time ("stamp_expire_deposit",
&stamp_expire_deposit),
GNUNET_JSON_spec_absolute_time ("stamp_expire_legal",
&stamp_expire_legal),
GNUNET_JSON_spec_fixed_auto ("master_sig",
&master_sig),
GNUNET_JSON_spec_end ()
@ -811,9 +811,8 @@ show_denomkeys (const json_t *denomkeys)
test_shutdown ();
return GNUNET_SYSERR;
}
duration = GNUNET_TIME_absolute_get_difference (
stamp_start.abs_time,
stamp_expire_withdraw.abs_time);
duration = GNUNET_TIME_absolute_get_difference (stamp_start,
stamp_expire_withdraw);
TALER_denom_pub_hash (&denom_pub,
&h_denom_pub);
if (GNUNET_OK !=
@ -852,18 +851,18 @@ show_denomkeys (const json_t *denomkeys)
refresh_fee_s = TALER_amount_to_string (&fee_refresh);
refund_fee_s = TALER_amount_to_string (&fee_refund);
deposit_s = GNUNET_strdup (
GNUNET_TIME_timestamp2s (stamp_expire_deposit));
GNUNET_STRINGS_absolute_time_to_string (stamp_expire_deposit));
legal_s = GNUNET_strdup (
GNUNET_TIME_timestamp2s (stamp_expire_legal));
GNUNET_STRINGS_absolute_time_to_string (stamp_expire_legal));
printf (
"DENOMINATION-KEY %s of value %s starting at %s "
"(used for: %s, deposit until: %s legal end: %s) with fees %s/%s/%s/%s\n",
TALER_B2S (&h_denom_pub),
TALER_amount2s (&coin_value),
GNUNET_TIME_timestamp2s (stamp_start),
GNUNET_TIME_relative2s (duration,
false),
GNUNET_STRINGS_absolute_time_to_string (stamp_start),
GNUNET_STRINGS_relative_time_to_string (duration,
GNUNET_NO),
deposit_s,
legal_s,
withdraw_fee_s,
@ -1053,10 +1052,10 @@ sign_denomkeys (const json_t *denomkeys)
const char *err_name;
unsigned int err_line;
struct TALER_DenominationPublicKey denom_pub;
struct GNUNET_TIME_Timestamp stamp_start;
struct GNUNET_TIME_Timestamp stamp_expire_withdraw;
struct GNUNET_TIME_Timestamp stamp_expire_deposit;
struct GNUNET_TIME_Timestamp stamp_expire_legal;
struct GNUNET_TIME_Absolute stamp_start;
struct GNUNET_TIME_Absolute stamp_expire_withdraw;
struct GNUNET_TIME_Absolute stamp_expire_deposit;
struct GNUNET_TIME_Absolute stamp_expire_legal;
struct TALER_Amount coin_value;
struct TALER_Amount fee_withdraw;
struct TALER_Amount fee_deposit;
@ -1081,14 +1080,14 @@ sign_denomkeys (const json_t *denomkeys)
TALER_JSON_spec_amount ("fee_refund",
currency,
&fee_refund),
GNUNET_JSON_spec_timestamp ("stamp_start",
&stamp_start),
GNUNET_JSON_spec_timestamp ("stamp_expire_withdraw",
&stamp_expire_withdraw),
GNUNET_JSON_spec_timestamp ("stamp_expire_deposit",
&stamp_expire_deposit),
GNUNET_JSON_spec_timestamp ("stamp_expire_legal",
&stamp_expire_legal),
GNUNET_JSON_spec_absolute_time ("stamp_start",
&stamp_start),
GNUNET_JSON_spec_absolute_time ("stamp_expire_withdraw",
&stamp_expire_withdraw),
GNUNET_JSON_spec_absolute_time ("stamp_expire_deposit",
&stamp_expire_deposit),
GNUNET_JSON_spec_absolute_time ("stamp_expire_legal",
&stamp_expire_legal),
GNUNET_JSON_spec_fixed_auto ("master_sig",
&master_sig),
GNUNET_JSON_spec_end ()

213
src/exchange-tools/taler-exchange-offline.c
View File

@ -1031,7 +1031,7 @@ upload_auditor_add (const char *exchange_url,
struct TALER_MasterSignatureP master_sig;
const char *auditor_url;
const char *auditor_name;
struct GNUNET_TIME_Timestamp start_time;
struct GNUNET_TIME_Absolute start_time;
struct TALER_AuditorPublicKeyP auditor_pub;
struct AuditorAddRequest *aar;
const char *err_name;
@ -1041,8 +1041,8 @@ upload_auditor_add (const char *exchange_url,
&auditor_url),
GNUNET_JSON_spec_string ("auditor_name",
&auditor_name),
GNUNET_JSON_spec_timestamp ("validity_start",
&start_time),
GNUNET_JSON_spec_absolute_time ("validity_start",
&start_time),
GNUNET_JSON_spec_fixed_auto ("auditor_pub",
&auditor_pub),
GNUNET_JSON_spec_fixed_auto ("master_sig",
@ -1130,15 +1130,15 @@ upload_auditor_del (const char *exchange_url,
{
struct TALER_AuditorPublicKeyP auditor_pub;
struct TALER_MasterSignatureP master_sig;
struct GNUNET_TIME_Timestamp end_time;
struct GNUNET_TIME_Absolute end_time;
struct AuditorDelRequest *adr;
const char *err_name;
unsigned int err_line;
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_fixed_auto ("auditor_pub",
&auditor_pub),
GNUNET_JSON_spec_timestamp ("validity_end",
&end_time),
GNUNET_JSON_spec_absolute_time ("validity_end",
&end_time),
GNUNET_JSON_spec_fixed_auto ("master_sig",
&master_sig),
GNUNET_JSON_spec_end ()
@ -1223,15 +1223,15 @@ upload_wire_add (const char *exchange_url,
struct TALER_MasterSignatureP master_sig_add;
struct TALER_MasterSignatureP master_sig_wire;
const char *payto_uri;
struct GNUNET_TIME_Timestamp start_time;
struct GNUNET_TIME_Absolute start_time;
struct WireAddRequest *war;
const char *err_name;
unsigned int err_line;
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_string ("payto_uri",
&payto_uri),
GNUNET_JSON_spec_timestamp ("validity_start",
&start_time),
GNUNET_JSON_spec_absolute_time ("validity_start",
&start_time),
GNUNET_JSON_spec_fixed_auto ("master_sig_add",
&master_sig_add),
GNUNET_JSON_spec_fixed_auto ("master_sig_wire",
@ -1333,15 +1333,15 @@ upload_wire_del (const char *exchange_url,
{
struct TALER_MasterSignatureP master_sig;
const char *payto_uri;
struct GNUNET_TIME_Timestamp end_time;
struct GNUNET_TIME_Absolute end_time;
struct WireDelRequest *wdr;
const char *err_name;
unsigned int err_line;
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_string ("payto_uri",
&payto_uri),
GNUNET_JSON_spec_timestamp ("validity_end",
&end_time),
GNUNET_JSON_spec_absolute_time ("validity_end",
&end_time),
GNUNET_JSON_spec_fixed_auto ("master_sig",
&master_sig),
GNUNET_JSON_spec_end ()
@ -1431,8 +1431,8 @@ upload_wire_fee (const char *exchange_url,
unsigned int err_line;
struct TALER_Amount wire_fee;
struct TALER_Amount closing_fee;
struct GNUNET_TIME_Timestamp start_time;
struct GNUNET_TIME_Timestamp end_time;
struct GNUNET_TIME_Absolute start_time;
struct GNUNET_TIME_Absolute end_time;
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_string ("wire_method",
&wire_method),
@ -1442,10 +1442,10 @@ upload_wire_fee (const char *exchange_url,
TALER_JSON_spec_amount ("closing_fee",
currency,
&closing_fee),
GNUNET_JSON_spec_timestamp ("start_time",
&start_time),
GNUNET_JSON_spec_timestamp ("end_time",
&end_time),
GNUNET_JSON_spec_absolute_time ("start_time",
&start_time),
GNUNET_JSON_spec_absolute_time ("end_time",
&end_time),
GNUNET_JSON_spec_fixed_auto ("master_sig",
&master_sig),
GNUNET_JSON_spec_end ()
@ -1926,7 +1926,7 @@ do_add_auditor (char *const *args)
{
struct TALER_MasterSignatureP master_sig;
struct TALER_AuditorPublicKeyP auditor_pub;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
if (NULL != in)
{
@ -1965,7 +1965,8 @@ do_add_auditor (char *const *args)
if (GNUNET_OK !=
load_offline_key (GNUNET_NO))
return;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
TALER_exchange_offline_auditor_add_sign (&auditor_pub,
args[1],
now,
@ -1977,8 +1978,8 @@ do_add_auditor (char *const *args)
args[1]),
GNUNET_JSON_pack_string ("auditor_name",
args[2]),
GNUNET_JSON_pack_timestamp ("validity_start",
now),
GNUNET_JSON_pack_time_abs ("validity_start",
now),
GNUNET_JSON_pack_data_auto ("auditor_pub",
&auditor_pub),
GNUNET_JSON_pack_data_auto ("master_sig",
@ -1998,7 +1999,7 @@ do_del_auditor (char *const *args)
{
struct TALER_MasterSignatureP master_sig;
struct TALER_AuditorPublicKeyP auditor_pub;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
if (NULL != in)
{
@ -2024,7 +2025,9 @@ do_del_auditor (char *const *args)
if (GNUNET_OK !=
load_offline_key (GNUNET_NO))
return;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
TALER_exchange_offline_auditor_del_sign (&auditor_pub,
now,
&master_priv,
@ -2033,8 +2036,8 @@ do_del_auditor (char *const *args)
GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("auditor_pub",
&auditor_pub),
GNUNET_JSON_pack_timestamp ("validity_end",
now),
GNUNET_JSON_pack_time_abs ("validity_end",
now),
GNUNET_JSON_pack_data_auto ("master_sig",
&master_sig)));
next (args + 1);
@ -2052,7 +2055,7 @@ do_add_wire (char *const *args)
{
struct TALER_MasterSignatureP master_sig_add;
struct TALER_MasterSignatureP master_sig_wire;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
if (NULL != in)
{
@ -2073,7 +2076,9 @@ do_add_wire (char *const *args)
if (GNUNET_OK !=
load_offline_key (GNUNET_NO))
return;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
{
char *wire_method;
@ -2100,8 +2105,8 @@ do_add_wire (char *const *args)
GNUNET_JSON_PACK (
GNUNET_JSON_pack_string ("payto_uri",
args[0]),
GNUNET_JSON_pack_timestamp ("validity_start",
now),
GNUNET_JSON_pack_time_abs ("validity_start",
now),
GNUNET_JSON_pack_data_auto ("master_sig_add",
&master_sig_add),
GNUNET_JSON_pack_data_auto ("master_sig_wire",
@ -2120,7 +2125,7 @@ static void
do_del_wire (char *const *args)
{
struct TALER_MasterSignatureP master_sig;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
if (NULL != in)
{
@ -2141,7 +2146,9 @@ do_del_wire (char *const *args)
if (GNUNET_OK !=
load_offline_key (GNUNET_NO))
return;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
TALER_exchange_offline_wire_del_sign (args[0],
now,
&master_priv,
@ -2150,8 +2157,8 @@ do_del_wire (char *const *args)
GNUNET_JSON_PACK (
GNUNET_JSON_pack_string ("payto_uri",
args[0]),
GNUNET_JSON_pack_timestamp ("validity_end",
now),
GNUNET_JSON_pack_time_abs ("validity_end",
now),
GNUNET_JSON_pack_data_auto ("master_sig",
&master_sig)));
next (args + 1);
@ -2173,8 +2180,8 @@ do_set_wire_fee (char *const *args)
unsigned int year;
struct TALER_Amount wire_fee;
struct TALER_Amount closing_fee;
struct GNUNET_TIME_Timestamp start_time;
struct GNUNET_TIME_Timestamp end_time;
struct GNUNET_TIME_Absolute start_time;
struct GNUNET_TIME_Absolute end_time;
if (NULL != in)
{
@ -2213,10 +2220,8 @@ do_set_wire_fee (char *const *args)
if (GNUNET_OK !=
load_offline_key (GNUNET_NO))
return;
start_time = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_year_to_time (year));
end_time = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_year_to_time (year + 1));
start_time = GNUNET_TIME_year_to_time (year);
end_time = GNUNET_TIME_year_to_time (year + 1);
TALER_exchange_offline_wire_fee_sign (args[1],
start_time,
@ -2229,10 +2234,10 @@ do_set_wire_fee (char *const *args)
GNUNET_JSON_PACK (
GNUNET_JSON_pack_string ("wire_method",
args[1]),
GNUNET_JSON_pack_timestamp ("start_time",
start_time),
GNUNET_JSON_pack_timestamp ("end_time",
end_time),
GNUNET_JSON_pack_time_abs ("start_time",
start_time),
GNUNET_JSON_pack_time_abs ("end_time",
end_time),
TALER_JSON_pack_amount ("wire_fee",
&wire_fee),
TALER_JSON_pack_amount ("closing_fee",
@ -2499,17 +2504,17 @@ show_signkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
unsigned int err_line;
struct TALER_ExchangePublicKeyP exchange_pub;
struct TALER_SecurityModuleSignatureP secm_sig;
struct GNUNET_TIME_Timestamp start_time;
struct GNUNET_TIME_Timestamp sign_end;
struct GNUNET_TIME_Timestamp legal_end;
struct GNUNET_TIME_Absolute start_time;
struct GNUNET_TIME_Absolute sign_end;
struct GNUNET_TIME_Absolute legal_end;
struct GNUNET_TIME_Relative duration;
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_timestamp ("stamp_start",
&start_time),
GNUNET_JSON_spec_timestamp ("stamp_expire",
&sign_end),
GNUNET_JSON_spec_timestamp ("stamp_end",
&legal_end),
GNUNET_JSON_spec_absolute_time ("stamp_start",
&start_time),
GNUNET_JSON_spec_absolute_time ("stamp_expire",
&sign_end),
GNUNET_JSON_spec_absolute_time ("stamp_end",
&legal_end),
GNUNET_JSON_spec_fixed_auto ("key",
&exchange_pub),
GNUNET_JSON_spec_fixed_auto ("signkey_secmod_sig",
@ -2535,8 +2540,8 @@ show_signkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
test_shutdown ();
return GNUNET_SYSERR;
}
duration = GNUNET_TIME_absolute_get_difference (start_time.abs_time,
sign_end.abs_time);
duration = GNUNET_TIME_absolute_get_difference (start_time,
sign_end);
if (GNUNET_OK !=
TALER_exchange_secmod_eddsa_verify (&exchange_pub,
start_time,
@ -2555,12 +2560,12 @@ show_signkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
char *legal_end_s;
legal_end_s = GNUNET_strdup (
GNUNET_TIME_timestamp2s (legal_end));
GNUNET_STRINGS_absolute_time_to_string (legal_end));
printf ("EXCHANGE-KEY %s starting at %s (used for: %s, legal end: %s)\n",
TALER_B2S (&exchange_pub),
GNUNET_TIME_timestamp2s (start_time),
GNUNET_TIME_relative2s (duration,
false),
GNUNET_STRINGS_absolute_time_to_string (start_time),
GNUNET_STRINGS_relative_time_to_string (duration,
GNUNET_NO),
legal_end_s);
GNUNET_free (legal_end_s);
}
@ -2588,10 +2593,10 @@ show_denomkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
unsigned int err_line;
const char *section_name;
struct TALER_DenominationPublicKey denom_pub;
struct GNUNET_TIME_Timestamp stamp_start;
struct GNUNET_TIME_Timestamp stamp_expire_withdraw;
struct GNUNET_TIME_Timestamp stamp_expire_deposit;
struct GNUNET_TIME_Timestamp stamp_expire_legal;
struct GNUNET_TIME_Absolute stamp_start;
struct GNUNET_TIME_Absolute stamp_expire_withdraw;
struct GNUNET_TIME_Absolute stamp_expire_deposit;
struct GNUNET_TIME_Absolute stamp_expire_legal;
struct TALER_Amount coin_value;
struct TALER_Amount fee_withdraw;
struct TALER_Amount fee_deposit;
@ -2618,14 +2623,14 @@ show_denomkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
TALER_JSON_spec_amount ("fee_refund",
currency,
&fee_refund),
GNUNET_JSON_spec_timestamp ("stamp_start",
&stamp_start),
GNUNET_JSON_spec_timestamp ("stamp_expire_withdraw",
&stamp_expire_withdraw),
GNUNET_JSON_spec_timestamp ("stamp_expire_deposit",
&stamp_expire_deposit),
GNUNET_JSON_spec_timestamp ("stamp_expire_legal",
&stamp_expire_legal),
GNUNET_JSON_spec_absolute_time ("stamp_start",
&stamp_start),
GNUNET_JSON_spec_absolute_time ("stamp_expire_withdraw",
&stamp_expire_withdraw),
GNUNET_JSON_spec_absolute_time ("stamp_expire_deposit",
&stamp_expire_deposit),
GNUNET_JSON_spec_absolute_time ("stamp_expire_legal",
&stamp_expire_legal),
GNUNET_JSON_spec_fixed_auto ("denom_secmod_sig",
&secm_sig),
GNUNET_JSON_spec_end ()
@ -2653,9 +2658,8 @@ show_denomkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
test_shutdown ();
return GNUNET_SYSERR;
}
duration = GNUNET_TIME_absolute_get_difference (
stamp_start.abs_time,
stamp_expire_withdraw.abs_time);
duration = GNUNET_TIME_absolute_get_difference (stamp_start,
stamp_expire_withdraw);
TALER_denom_pub_hash (&denom_pub,
&h_denom_pub);
switch (denom_pub.cipher)
@ -2702,9 +2706,9 @@ show_denomkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
refresh_fee_s = TALER_amount_to_string (&fee_refresh);
refund_fee_s = TALER_amount_to_string (&fee_refund);
deposit_s = GNUNET_strdup (
GNUNET_TIME_timestamp2s (stamp_expire_deposit));
GNUNET_STRINGS_absolute_time_to_string (stamp_expire_deposit));
legal_s = GNUNET_strdup (
GNUNET_TIME_timestamp2s (stamp_expire_legal));
GNUNET_STRINGS_absolute_time_to_string (stamp_expire_legal));
printf (
"DENOMINATION-KEY(%s) %s of value %s starting at %s "
@ -2712,9 +2716,9 @@ show_denomkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
section_name,
TALER_B2S (&h_denom_pub),
TALER_amount2s (&coin_value),
GNUNET_TIME_timestamp2s (stamp_start),
GNUNET_TIME_relative2s (duration,
false),
GNUNET_STRINGS_absolute_time_to_string (stamp_start),
GNUNET_STRINGS_relative_time_to_string (duration,
GNUNET_NO),
deposit_s,
legal_s,
withdraw_fee_s,
@ -2925,17 +2929,17 @@ sign_signkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
unsigned int err_line;
struct TALER_ExchangePublicKeyP exchange_pub;
struct TALER_SecurityModuleSignatureP secm_sig;
struct GNUNET_TIME_Timestamp start_time;
struct GNUNET_TIME_Timestamp sign_end;
struct GNUNET_TIME_Timestamp legal_end;
struct GNUNET_TIME_Absolute start_time;
struct GNUNET_TIME_Absolute sign_end;
struct GNUNET_TIME_Absolute legal_end;
struct GNUNET_TIME_Relative duration;
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_timestamp ("stamp_start",
&start_time),
GNUNET_JSON_spec_timestamp ("stamp_expire",
&sign_end),
GNUNET_JSON_spec_timestamp ("stamp_end",
&legal_end),
GNUNET_JSON_spec_absolute_time ("stamp_start",
&start_time),
GNUNET_JSON_spec_absolute_time ("stamp_expire",
&sign_end),
GNUNET_JSON_spec_absolute_time ("stamp_end",
&legal_end),
GNUNET_JSON_spec_fixed_auto ("key",
&exchange_pub),
GNUNET_JSON_spec_fixed_auto ("signkey_secmod_sig",
@ -2962,8 +2966,8 @@ sign_signkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
return GNUNET_SYSERR;
}
duration = GNUNET_TIME_absolute_get_difference (start_time.abs_time,
sign_end.abs_time);
duration = GNUNET_TIME_absolute_get_difference (start_time,
sign_end);
if (GNUNET_OK !=
TALER_exchange_secmod_eddsa_verify (&exchange_pub,
start_time,
@ -3024,10 +3028,10 @@ sign_denomkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
unsigned int err_line;
const char *section_name;
struct TALER_DenominationPublicKey denom_pub;
struct GNUNET_TIME_Timestamp stamp_start;
struct GNUNET_TIME_Timestamp stamp_expire_withdraw;
struct GNUNET_TIME_Timestamp stamp_expire_deposit;
struct GNUNET_TIME_Timestamp stamp_expire_legal;
struct GNUNET_TIME_Absolute stamp_start;
struct GNUNET_TIME_Absolute stamp_expire_withdraw;
struct GNUNET_TIME_Absolute stamp_expire_deposit;
struct GNUNET_TIME_Absolute stamp_expire_legal;
struct TALER_Amount coin_value;
struct TALER_Amount fee_withdraw;
struct TALER_Amount fee_deposit;
@ -3054,14 +3058,14 @@ sign_denomkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
TALER_JSON_spec_amount ("fee_refund",
currency,
&fee_refund),
GNUNET_JSON_spec_timestamp ("stamp_start",
&stamp_start),
GNUNET_JSON_spec_timestamp ("stamp_expire_withdraw",
&stamp_expire_withdraw),
GNUNET_JSON_spec_timestamp ("stamp_expire_deposit",
&stamp_expire_deposit),
GNUNET_JSON_spec_timestamp ("stamp_expire_legal",
&stamp_expire_legal),
GNUNET_JSON_spec_absolute_time ("stamp_start",
&stamp_start),
GNUNET_JSON_spec_absolute_time ("stamp_expire_withdraw",
&stamp_expire_withdraw),
GNUNET_JSON_spec_absolute_time ("stamp_expire_deposit",
&stamp_expire_deposit),
GNUNET_JSON_spec_absolute_time ("stamp_expire_legal",
&stamp_expire_legal),
GNUNET_JSON_spec_fixed_auto ("denom_secmod_sig",
&secm_sig),
GNUNET_JSON_spec_end ()
@ -3088,9 +3092,8 @@ sign_denomkeys (const struct TALER_SecurityModulePublicKeyP *secm_pub,
test_shutdown ();
return GNUNET_SYSERR;
}
duration = GNUNET_TIME_absolute_get_difference (
stamp_start.abs_time,
stamp_expire_withdraw.abs_time);
duration = GNUNET_TIME_absolute_get_difference (stamp_start,
stamp_expire_withdraw);
// FIXME-Oec: setup age mask here?
TALER_denom_pub_hash (&denom_pub,
&h_denom_pub);

21
src/exchange/taler-exchange-aggregator.c
View File

@ -71,7 +71,7 @@ struct AggregationUnit
* The current time (which triggered the aggregation and
* defines the wire fee).
*/
struct GNUNET_TIME_Timestamp execution_time;
struct GNUNET_TIME_Absolute execution_time;
/**
* Wire details of the merchant.
@ -116,7 +116,7 @@ struct Shard
/**
* When did we start processing the shard?
*/
struct GNUNET_TIME_Timestamp start_time;
struct GNUNET_TIME_Absolute start_time;
/**
* Starting row of the shard.
@ -445,11 +445,12 @@ deposit_cb (void *cls,
}
/* make sure we have current fees */
au->execution_time = GNUNET_TIME_timestamp_get ();
au->execution_time = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&au->execution_time);
{
struct TALER_Amount closing_fee;
struct GNUNET_TIME_Timestamp start_date;
struct GNUNET_TIME_Timestamp end_date;
struct GNUNET_TIME_Absolute start_date;
struct GNUNET_TIME_Absolute end_date;
struct TALER_MasterSignatureP master_sig;
enum GNUNET_DB_QueryStatus qs;
@ -466,7 +467,7 @@ deposit_cb (void *cls,
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Could not get wire fees for %s at %s. Aborting run.\n",
au->wa->method,
GNUNET_TIME_timestamp2s (au->execution_time));
GNUNET_STRINGS_absolute_time_to_string (au->execution_time));
return GNUNET_DB_STATUS_HARD_ERROR;
}
}
@ -737,7 +738,7 @@ run_aggregation (void *cls)
{
uint64_t counter = s->work_counter;
struct GNUNET_TIME_Relative duration
= GNUNET_TIME_absolute_get_duration (s->start_time.abs_time);
= GNUNET_TIME_absolute_get_duration (s->start_time);
cleanup_au (&au_active);
db_plugin->rollback (db_plugin->cls);
@ -745,8 +746,8 @@ run_aggregation (void *cls)
"Completed shard [%u,%u] after %s with %llu deposits\n",
(unsigned int) s->shard_start,
(unsigned int) s->shard_end,
GNUNET_TIME_relative2s (duration,
true),
GNUNET_STRINGS_relative_time_to_string (duration,
GNUNET_YES),
(unsigned long long) counter);
release_shard (s);
if ( (GNUNET_YES == test_mode) &&
@ -1008,7 +1009,7 @@ run_shard (void *cls)
return;
}
s = GNUNET_new (struct Shard);
s->start_time = GNUNET_TIME_timestamp_get ();
s->start_time = GNUNET_TIME_absolute_get ();
qs = db_plugin->begin_revolving_shard (db_plugin->cls,
"aggregator",
shard_size,

22
src/exchange/taler-exchange-closer.c
View File

@ -211,9 +211,9 @@ expired_reserve_cb (void *cls,
const struct TALER_ReservePublicKeyP *reserve_pub,
const struct TALER_Amount *left,
const char *account_payto_uri,
struct GNUNET_TIME_Timestamp expiration_date)
struct GNUNET_TIME_Absolute expiration_date)
{
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
struct TALER_WireTransferIdentifierRawP wtid;
struct TALER_Amount amount_without_fee;
struct TALER_Amount closing_fee;
@ -226,8 +226,9 @@ expired_reserve_cb (void *cls,
fetch this: */
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Processing reserve closure at %s\n",
GNUNET_TIME_timestamp2s (expiration_date));
now = GNUNET_TIME_timestamp_get ();
GNUNET_STRINGS_absolute_time_to_string (expiration_date));
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* lookup account we should use */
wa = TALER_EXCHANGEDB_find_account_by_payto_uri (account_payto_uri);
@ -245,8 +246,8 @@ expired_reserve_cb (void *cls,
(we may be lagging behind!) */
{
struct TALER_Amount wire_fee;
struct GNUNET_TIME_Timestamp start_date;
struct GNUNET_TIME_Timestamp end_date;
struct GNUNET_TIME_Absolute start_date;
struct GNUNET_TIME_Absolute end_date;
struct TALER_MasterSignatureP master_sig;
enum GNUNET_DB_QueryStatus qs;
@ -263,7 +264,7 @@ expired_reserve_cb (void *cls,
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Could not get wire fees for %s at %s. Aborting run.\n",
wa->method,
GNUNET_TIME_timestamp2s (expiration_date));
GNUNET_STRINGS_absolute_time_to_string (expiration_date));
return GNUNET_DB_STATUS_HARD_ERROR;
}
}
@ -381,7 +382,7 @@ static void
run_reserve_closures (void *cls)
{
enum GNUNET_DB_QueryStatus qs;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
(void) cls;
task = NULL;
@ -405,10 +406,11 @@ run_reserve_closures (void *cls)
GNUNET_SCHEDULER_shutdown ();
return;
}
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Checking for reserves to close by date %s\n",
GNUNET_TIME_timestamp2s (now));
GNUNET_STRINGS_absolute_time_to_string (now));
qs = db_plugin->get_expired_reserves (db_plugin->cls,
now,
&expired_reserve_cb,

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

@ -60,9 +60,9 @@ reply_deposit_success (struct MHD_Connection *connection,
const struct TALER_MerchantWireHash *h_wire,
const struct TALER_ExtensionContractHash *h_extensions,
const struct TALER_PrivateContractHash *h_contract_terms,
struct GNUNET_TIME_Timestamp exchange_timestamp,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Timestamp wire_deadline,
struct GNUNET_TIME_Absolute exchange_timestamp,
struct GNUNET_TIME_Absolute refund_deadline,
struct GNUNET_TIME_Absolute wire_deadline,
const struct TALER_MerchantPublicKeyP *merchant,
const struct TALER_Amount *amount_without_fee)
{
@ -73,9 +73,9 @@ reply_deposit_success (struct MHD_Connection *connection,
.purpose.size = htonl (sizeof (dc)),
.h_contract_terms = *h_contract_terms,
.h_wire = *h_wire,
.exchange_timestamp = GNUNET_TIME_timestamp_hton (exchange_timestamp),
.refund_deadline = GNUNET_TIME_timestamp_hton (refund_deadline),
.wire_deadline = GNUNET_TIME_timestamp_hton (wire_deadline),
.exchange_timestamp = GNUNET_TIME_absolute_hton (exchange_timestamp),
.refund_deadline = GNUNET_TIME_absolute_hton (refund_deadline),
.wire_deadline = GNUNET_TIME_absolute_hton (wire_deadline),
.coin_pub = *coin_pub,
.merchant_pub = *merchant
};
@ -97,8 +97,8 @@ reply_deposit_success (struct MHD_Connection *connection,
return TALER_MHD_REPLY_JSON_PACK (
connection,
MHD_HTTP_OK,
GNUNET_JSON_pack_timestamp ("exchange_timestamp",
exchange_timestamp),
GNUNET_JSON_pack_time_abs ("exchange_timestamp",
exchange_timestamp),
GNUNET_JSON_pack_data_auto ("exchange_sig",
&sig),
GNUNET_JSON_pack_data_auto ("exchange_pub",
@ -119,7 +119,7 @@ struct DepositContext
/**
* Our timestamp (when we received the request).
*/
struct GNUNET_TIME_Timestamp exchange_timestamp;
struct GNUNET_TIME_Absolute exchange_timestamp;
/**
* Calculated hash over the wire details.
@ -281,13 +281,13 @@ TEH_handler_deposit (struct MHD_Connection *connection,
&deposit.h_contract_terms),
GNUNET_JSON_spec_fixed_auto ("coin_sig",
&deposit.csig),
GNUNET_JSON_spec_timestamp ("timestamp",
&deposit.timestamp),
TALER_JSON_spec_absolute_time ("timestamp",
&deposit.timestamp),
GNUNET_JSON_spec_mark_optional (
GNUNET_JSON_spec_timestamp ("refund_deadline",
&deposit.refund_deadline)),
GNUNET_JSON_spec_timestamp ("wire_transfer_deadline",
&deposit.wire_deadline),
TALER_JSON_spec_absolute_time ("refund_deadline",
&deposit.refund_deadline)),
TALER_JSON_spec_absolute_time ("wire_transfer_deadline",
&deposit.wire_deadline),
GNUNET_JSON_spec_end ()
};
@ -332,9 +332,7 @@ TEH_handler_deposit (struct MHD_Connection *connection,
}
}
deposit.receiver_wire_account = (char *) dc.payto_uri;
if (GNUNET_TIME_timestamp_cmp (deposit.refund_deadline,
>,
deposit.wire_deadline))
if (deposit.refund_deadline.abs_value_us > deposit.wire_deadline.abs_value_us)
{
GNUNET_break_op (0);
GNUNET_JSON_parse_free (spec);
@ -349,7 +347,8 @@ TEH_handler_deposit (struct MHD_Connection *connection,
dc.deposit = &deposit;
/* new deposit */
dc.exchange_timestamp = GNUNET_TIME_timestamp_get ();
dc.exchange_timestamp = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&dc.exchange_timestamp);
/* check denomination exists and is valid */
{
struct TEH_DenominationKey *dk;
@ -363,12 +362,13 @@ TEH_handler_deposit (struct MHD_Connection *connection,
GNUNET_JSON_parse_free (spec);
return mret;
}
if (GNUNET_TIME_absolute_is_past (dk->meta.expire_deposit.abs_time))
if (GNUNET_TIME_absolute_is_past (dk->meta.expire_deposit))
{
/* This denomination is past the expiration time for deposits */
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
GNUNET_JSON_parse_free (spec);
return TEH_RESPONSE_reply_expired_denom_pub_hash (
connection,
@ -377,12 +377,13 @@ TEH_handler_deposit (struct MHD_Connection *connection,
TALER_EC_EXCHANGE_GENERIC_DENOMINATION_EXPIRED,
"DEPOSIT");
}
if (GNUNET_TIME_absolute_is_future (dk->meta.start.abs_time))
if (GNUNET_TIME_absolute_is_future (dk->meta.start))
{
/* This denomination is not yet valid */
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
GNUNET_JSON_parse_free (spec);
return TEH_RESPONSE_reply_expired_denom_pub_hash (
connection,
@ -393,9 +394,10 @@ TEH_handler_deposit (struct MHD_Connection *connection,
}
if (dk->recoup_possible)
{
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* This denomination has been revoked */
GNUNET_JSON_parse_free (spec);
return TEH_RESPONSE_reply_expired_denom_pub_hash (

14
src/exchange/taler-exchange-httpd_deposits_get.c
View File

@ -52,7 +52,7 @@ reply_deposit_details (struct MHD_Connection *connection,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_Amount *coin_contribution,
const struct TALER_WireTransferIdentifierRawP *wtid,
struct GNUNET_TIME_Timestamp exec_time)
struct GNUNET_TIME_Absolute exec_time)
{
struct TALER_ExchangePublicKeyP pub;
struct TALER_ExchangeSignatureP sig;
@ -63,7 +63,7 @@ reply_deposit_details (struct MHD_Connection *connection,
.h_contract_terms = *h_contract_terms,
.wtid = *wtid,
.coin_pub = *coin_pub,
.execution_time = GNUNET_TIME_timestamp_hton (exec_time)
.execution_time = GNUNET_TIME_absolute_hton (exec_time)
};
enum TALER_ErrorCode ec;
@ -83,8 +83,8 @@ reply_deposit_details (struct MHD_Connection *connection,
MHD_HTTP_OK,
GNUNET_JSON_pack_data_auto ("wtid",
wtid),
GNUNET_JSON_pack_timestamp ("execution_time",
exec_time),
GNUNET_JSON_pack_time_abs ("execution_time",
exec_time),
TALER_JSON_pack_amount ("coin_contribution",
coin_contribution),
GNUNET_JSON_pack_data_auto ("exchange_sig",
@ -128,7 +128,7 @@ struct DepositWtidContext
/**
* Set by #handle_wtid data to the wire transfer execution time.
*/
struct GNUNET_TIME_Timestamp execution_time;
struct GNUNET_TIME_Absolute execution_time;
/**
* Set by #handle_wtid to the coin contribution to the transaction
@ -264,8 +264,8 @@ handle_track_transaction_request (
ctx.kyc.payment_target_uuid),
GNUNET_JSON_pack_bool ("kyc_ok",
ctx.kyc.ok),
GNUNET_JSON_pack_timestamp ("execution_time",
ctx.execution_time));
GNUNET_JSON_pack_time_abs ("execution_time",
ctx.execution_time));
return reply_deposit_details (connection,
&tps->h_contract_terms,
&tps->h_wire,

227
src/exchange/taler-exchange-httpd_keys.c
View File

@ -57,7 +57,7 @@
* #TALER_PROTOCOL_CURRENT and #TALER_PROTOCOL_AGE in
* exchange_api_handle.c!
*/
#define EXCHANGE_PROTOCOL_VERSION "11:0:0"
#define EXCHANGE_PROTOCOL_VERSION "10:0:0"
/**
@ -69,7 +69,7 @@ struct HelperDenomination
/**
* When will the helper start to use this key for signing?
*/
struct GNUNET_TIME_Timestamp start_time;
struct GNUNET_TIME_Absolute start_time;
/**
* For how long will the helper allow signing? 0 if
@ -150,7 +150,7 @@ struct HelperSignkey
/**
* When will the helper start to use this key for signing?
*/
struct GNUNET_TIME_Timestamp start_time;
struct GNUNET_TIME_Absolute start_time;
/**
* For how long will the helper allow signing? 0 if
@ -234,7 +234,7 @@ struct KeysResponseData
* The client's request must include this date or a higher one
* for this response to be applicable.
*/
struct GNUNET_TIME_Timestamp cherry_pick_date;
struct GNUNET_TIME_Absolute cherry_pick_date;
};
@ -319,7 +319,7 @@ struct TEH_KeyStateHandle
/**
* When did we initiate the key reloading?
*/
struct GNUNET_TIME_Timestamp reload_time;
struct GNUNET_TIME_Absolute reload_time;
/**
* What is the period at which we rotate keys
@ -331,7 +331,7 @@ struct TEH_KeyStateHandle
* When does our online signing key expire and we
* thus need to re-generate this response?
*/
struct GNUNET_TIME_Timestamp signature_expires;
struct GNUNET_TIME_Absolute signature_expires;
/**
* True if #finish_keys_response() was not yet run and this key state
@ -811,7 +811,7 @@ static void
helper_rsa_cb (
void *cls,
const char *section_name,
struct GNUNET_TIME_Timestamp start_time,
struct GNUNET_TIME_Absolute start_time,
struct GNUNET_TIME_Relative validity_duration,
const struct TALER_RsaPubHashP *h_rsa,
const struct TALER_DenominationPublicKey *denom_pub,
@ -888,7 +888,7 @@ helper_rsa_cb (
static void
helper_esign_cb (
void *cls,
struct GNUNET_TIME_Timestamp start_time,
struct GNUNET_TIME_Absolute start_time,
struct GNUNET_TIME_Relative validity_duration,
const struct TALER_ExchangePublicKeyP *exchange_pub,
const struct TALER_SecurityModulePublicKeyP *sm_pub,
@ -1176,10 +1176,10 @@ denomination_info_cb (
struct TEH_DenominationKey *dk;
GNUNET_assert (TALER_DENOMINATION_INVALID != denom_pub->cipher);
if (GNUNET_TIME_absolute_is_zero (meta->start.abs_time) ||
GNUNET_TIME_absolute_is_zero (meta->expire_withdraw.abs_time) ||
GNUNET_TIME_absolute_is_zero (meta->expire_deposit.abs_time) ||
GNUNET_TIME_absolute_is_zero (meta->expire_legal.abs_time) )
if ( (0 == meta->start.abs_value_us) ||
(0 == meta->expire_withdraw.abs_value_us) ||
(0 == meta->expire_deposit.abs_value_us) ||
(0 == meta->expire_legal.abs_value_us) )
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Database contains invalid denomination key %s\n",
@ -1403,25 +1403,25 @@ add_sign_key_cb (void *cls,
struct SigningKey *sk = value;
(void) pid;
if (GNUNET_TIME_absolute_is_future (sk->meta.expire_sign.abs_time))
if (GNUNET_TIME_absolute_is_future (sk->meta.expire_sign))
{
ctx->min_sk_frequency =
GNUNET_TIME_relative_min (ctx->min_sk_frequency,
GNUNET_TIME_absolute_get_difference (
sk->meta.start.abs_time,
sk->meta.expire_sign.abs_time));
sk->meta.start,
sk->meta.expire_sign));
}
GNUNET_assert (
0 ==
json_array_append_new (
ctx->signkeys,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_timestamp ("stamp_start",
sk->meta.start),
GNUNET_JSON_pack_timestamp ("stamp_expire",
sk->meta.expire_sign),
GNUNET_JSON_pack_timestamp ("stamp_end",
sk->meta.expire_legal),
GNUNET_JSON_pack_time_abs ("stamp_start",
sk->meta.start),
GNUNET_JSON_pack_time_abs ("stamp_expire",
sk->meta.expire_sign),
GNUNET_JSON_pack_time_abs ("stamp_end",
sk->meta.expire_legal),
GNUNET_JSON_pack_data_auto ("master_sig",
&sk->master_sig),
GNUNET_JSON_pack_data_auto ("key",
@ -1484,17 +1484,17 @@ add_denom_key_cb (void *cls,
}
else
{
if (GNUNET_TIME_absolute_is_future (dk->meta.start.abs_time))
if (GNUNET_TIME_absolute_is_future (dk->meta.start))
{
dkc->min_dk_frequency =
GNUNET_TIME_relative_min (dkc->min_dk_frequency,
GNUNET_TIME_absolute_get_difference (
dk->meta.start.abs_time,
dk->meta.expire_withdraw.abs_time));
dk->meta.start,
dk->meta.expire_withdraw));
}
(void) GNUNET_CONTAINER_heap_insert (dkc->heap,
dk,
dk->meta.start.abs_time.abs_value_us);
dk->meta.start.abs_value_us);
}
return GNUNET_OK;
}
@ -1570,7 +1570,7 @@ setup_general_response_headers (struct TEH_KeyStateHandle *ksh,
MHD_add_response_header (response,
MHD_HTTP_HEADER_CONTENT_TYPE,
"application/json"));
get_date_string (ksh->reload_time.abs_time,
get_date_string (ksh->reload_time,
dat);
GNUNET_break (MHD_YES ==
MHD_add_response_header (response,
@ -1579,14 +1579,12 @@ setup_general_response_headers (struct TEH_KeyStateHandle *ksh,
if (! GNUNET_TIME_relative_is_zero (ksh->rekey_frequency))
{
struct GNUNET_TIME_Relative r;
struct GNUNET_TIME_Absolute a;
struct GNUNET_TIME_Timestamp m;
struct GNUNET_TIME_Absolute m;
r = GNUNET_TIME_relative_min (TEH_max_keys_caching,
ksh->rekey_frequency);
a = GNUNET_TIME_relative_to_absolute (r);
m = GNUNET_TIME_absolute_to_timestamp (a);
get_date_string (m.abs_time,
m = GNUNET_TIME_relative_to_absolute (r);
get_date_string (m,
dat);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Setting /keys 'Expires' header to '%s'\n",
@ -1596,8 +1594,8 @@ setup_general_response_headers (struct TEH_KeyStateHandle *ksh,
MHD_HTTP_HEADER_EXPIRES,
dat));
ksh->signature_expires
= GNUNET_TIME_timestamp_min (m,
ksh->signature_expires);
= GNUNET_TIME_absolute_min (m,
ksh->signature_expires);
}
return GNUNET_OK;
}
@ -1618,7 +1616,7 @@ setup_general_response_headers (struct TEH_KeyStateHandle *ksh,
static enum GNUNET_GenericReturnValue
create_krd (struct TEH_KeyStateHandle *ksh,
const struct GNUNET_HashCode *denom_keys_hash,
struct GNUNET_TIME_Timestamp last_cpd,
struct GNUNET_TIME_Absolute last_cpd,
json_t *signkeys,
json_t *recoup,
json_t *denoms)
@ -1628,7 +1626,7 @@ create_krd (struct TEH_KeyStateHandle *ksh,
struct TALER_ExchangeSignatureP exchange_sig;
json_t *keys;
GNUNET_assert (! GNUNET_TIME_absolute_is_zero (last_cpd.abs_time));
GNUNET_assert (0 != last_cpd.abs_value_us);
GNUNET_assert (NULL != signkeys);
GNUNET_assert (NULL != recoup);
GNUNET_assert (NULL != denoms);
@ -1636,13 +1634,13 @@ create_krd (struct TEH_KeyStateHandle *ksh,
GNUNET_assert (NULL != TEH_currency);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Creating /keys at cherry pick date %s\n",
GNUNET_TIME_timestamp2s (last_cpd));
GNUNET_STRINGS_absolute_time_to_string (last_cpd));
/* Sign hash over denomination keys */
{
struct TALER_ExchangeKeySetPS ks = {
.purpose.size = htonl (sizeof (ks)),
.purpose.purpose = htonl (TALER_SIGNATURE_EXCHANGE_KEY_SET),
.list_issue_date = GNUNET_TIME_timestamp_hton (last_cpd),
.list_issue_date = GNUNET_TIME_absolute_hton (last_cpd),
.hc = *denom_keys_hash
};
enum TALER_ErrorCode ec;
@ -1665,8 +1663,8 @@ create_krd (struct TEH_KeyStateHandle *ksh,
sk = GNUNET_CONTAINER_multipeermap_get (
ksh->signkey_map,
(const struct GNUNET_PeerIdentity *) &exchange_pub);
ksh->signature_expires = GNUNET_TIME_timestamp_min (sk->meta.expire_sign,
ksh->signature_expires);
ksh->signature_expires = GNUNET_TIME_absolute_min (sk->meta.expire_sign,
ksh->signature_expires);
}
keys = GNUNET_JSON_PACK (
@ -1686,8 +1684,8 @@ create_krd (struct TEH_KeyStateHandle *ksh,
denoms),
GNUNET_JSON_pack_array_incref ("auditors",
ksh->auditors),
GNUNET_JSON_pack_timestamp ("list_issue_date",
last_cpd),
GNUNET_JSON_pack_time_abs ("list_issue_date",
last_cpd),
GNUNET_JSON_pack_data_auto ("eddsa_pub",
&exchange_pub),
GNUNET_JSON_pack_data_auto ("eddsa_sig",
@ -1773,7 +1771,7 @@ finish_keys_response (struct TEH_KeyStateHandle *ksh)
json_t *recoup;
struct SignKeyCtx sctx;
json_t *denoms;
struct GNUNET_TIME_Timestamp last_cpd;
struct GNUNET_TIME_Absolute last_cpd;
struct GNUNET_CONTAINER_Heap *heap;
struct GNUNET_HashContext *hash_context;
@ -1802,7 +1800,7 @@ finish_keys_response (struct TEH_KeyStateHandle *ksh)
}
denoms = json_array ();
GNUNET_assert (NULL != denoms);
last_cpd = GNUNET_TIME_UNIT_ZERO_TS;
last_cpd = GNUNET_TIME_UNIT_ZERO_ABS;
hash_context = GNUNET_CRYPTO_hash_context_start ();
{
struct TEH_DenominationKey *dk;
@ -1810,10 +1808,8 @@ finish_keys_response (struct TEH_KeyStateHandle *ksh)
/* heap = min heap, sorted by start time */
while (NULL != (dk = GNUNET_CONTAINER_heap_remove_root (heap)))
{
if (GNUNET_TIME_timestamp_cmp (last_cpd,
!=,
dk->meta.start) &&
(! GNUNET_TIME_absolute_is_zero (last_cpd.abs_time)) )
if ( (last_cpd.abs_value_us != dk->meta.start.abs_value_us) &&
(0 != last_cpd.abs_value_us) )
{
struct GNUNET_HashCode hc;
@ -1830,7 +1826,7 @@ finish_keys_response (struct TEH_KeyStateHandle *ksh)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Failed to generate key response data for %s\n",
GNUNET_TIME_timestamp2s (last_cpd));
GNUNET_STRINGS_absolute_time_to_string (last_cpd));
GNUNET_CRYPTO_hash_context_abort (hash_context);
/* drain heap before destroying it */
while (NULL != (dk = GNUNET_CONTAINER_heap_remove_root (heap)))
@ -1853,14 +1849,14 @@ finish_keys_response (struct TEH_KeyStateHandle *ksh)
GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("master_sig",
&dk->master_sig),
GNUNET_JSON_pack_timestamp ("stamp_start",
dk->meta.start),
GNUNET_JSON_pack_timestamp ("stamp_expire_withdraw",
dk->meta.expire_withdraw),
GNUNET_JSON_pack_timestamp ("stamp_expire_deposit",
dk->meta.expire_deposit),
GNUNET_JSON_pack_timestamp ("stamp_expire_legal",
dk->meta.expire_legal),
GNUNET_JSON_pack_time_abs ("stamp_start",
dk->meta.start),
GNUNET_JSON_pack_time_abs ("stamp_expire_withdraw",
dk->meta.expire_withdraw),
GNUNET_JSON_pack_time_abs ("stamp_expire_deposit",
dk->meta.expire_deposit),
GNUNET_JSON_pack_time_abs ("stamp_expire_legal",
dk->meta.expire_legal),
TALER_JSON_pack_denom_pub ("denom_pub",
&dk->denom_pub),
TALER_JSON_pack_amount ("value",
@ -1876,7 +1872,7 @@ finish_keys_response (struct TEH_KeyStateHandle *ksh)
}
}
GNUNET_CONTAINER_heap_destroy (heap);
if (! GNUNET_TIME_absolute_is_zero (last_cpd.abs_time))
if (0 != last_cpd.abs_value_us)
{
struct GNUNET_HashCode hc;
@ -1892,7 +1888,7 @@ finish_keys_response (struct TEH_KeyStateHandle *ksh)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Failed to generate key response data for %s\n",
GNUNET_TIME_timestamp2s (last_cpd));
GNUNET_STRINGS_absolute_time_to_string (last_cpd));
json_decref (denoms);
json_decref (sctx.signkeys);
json_decref (recoup);
@ -1929,8 +1925,9 @@ build_key_state (struct HelperState *hs,
enum GNUNET_DB_QueryStatus qs;
ksh = GNUNET_new (struct TEH_KeyStateHandle);
ksh->signature_expires = GNUNET_TIME_UNIT_FOREVER_TS;
ksh->reload_time = GNUNET_TIME_timestamp_get ();
ksh->signature_expires = GNUNET_TIME_UNIT_FOREVER_ABS;
ksh->reload_time = GNUNET_TIME_absolute_get ();
GNUNET_TIME_round_abs (&ksh->reload_time);
/* We must use the key_generation from when we STARTED the process! */
ksh->key_generation = key_generation;
if (NULL == hs)
@ -2060,7 +2057,7 @@ get_key_state (bool management_only)
return ksh;
}
if ( (old_ksh->key_generation < key_generation) ||
(GNUNET_TIME_absolute_is_past (old_ksh->signature_expires.abs_time)) )
(GNUNET_TIME_absolute_is_past (old_ksh->signature_expires)) )
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Rebuilding /keys, generation upgrade from %llu to %llu\n",
@ -2304,7 +2301,7 @@ TEH_keys_exchange_revoke (const struct TALER_ExchangePublicKeyP *exchange_pub)
* Comparator used for a binary search by cherry_pick_date for @a key in the
* `struct KeysResponseData` array. See libc's qsort() and bsearch() functions.
*
* @param key pointer to a `struct GNUNET_TIME_Timestamp`
* @param key pointer to a `struct GNUNET_TIME_Absolute`
* @param value pointer to a `struct KeysResponseData` array entry
* @return 0 if time matches, -1 if key is smaller, 1 if key is larger
*/
@ -2312,16 +2309,12 @@ static int
krd_search_comparator (const void *key,
const void *value)
{
const struct GNUNET_TIME_Timestamp *kd = key;
const struct GNUNET_TIME_Absolute *kd = key;
const struct KeysResponseData *krd = value;
if (GNUNET_TIME_timestamp_cmp (*kd,
>,
krd->cherry_pick_date))
if (kd->abs_value_us > krd->cherry_pick_date.abs_value_us)
return -1;
if (GNUNET_TIME_timestamp_cmp (*kd,
<,
krd->cherry_pick_date))
if (kd->abs_value_us < krd->cherry_pick_date.abs_value_us)
return 1;
return 0;
}
@ -2331,7 +2324,7 @@ MHD_RESULT
TEH_keys_get_handler (struct TEH_RequestContext *rc,
const char *const args[])
{
struct GNUNET_TIME_Timestamp last_issue_date;
struct GNUNET_TIME_Absolute last_issue_date;
(void) args;
{
@ -2359,11 +2352,11 @@ TEH_keys_get_handler (struct TEH_RequestContext *rc,
be a problem, as giving back 'older' data than what the client asks for
(given that the client asks for data in the distant future) is not
problematic */
last_issue_date = GNUNET_TIME_timestamp_from_s (cherrypickn);
last_issue_date = GNUNET_TIME_absolute_from_s (cherrypickn);
}
else
{
last_issue_date = GNUNET_TIME_UNIT_ZERO_TS;
last_issue_date.abs_value_us = 0LLU;
}
}
@ -2395,16 +2388,16 @@ TEH_keys_get_handler (struct TEH_RequestContext *rc,
&krd_search_comparator);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Filtering /keys by cherry pick date %s found entry %u/%u\n",
GNUNET_TIME_timestamp2s (last_issue_date),
GNUNET_STRINGS_absolute_time_to_string (last_issue_date),
(unsigned int) (krd - ksh->krd_array),
ksh->krd_array_length);
if ( (NULL == krd) &&
(ksh->krd_array_length > 0) )
{
if (! GNUNET_TIME_absolute_is_zero (last_issue_date.abs_time))
if (0 != last_issue_date.abs_value_us)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Client provided invalid cherry picking timestamp %s, returning full response\n",
GNUNET_TIME_timestamp2s (last_issue_date));
GNUNET_STRINGS_absolute_time_to_string (last_issue_date));
krd = &ksh->krd_array[ksh->krd_array_length - 1];
}
if (NULL == krd)
@ -2440,7 +2433,7 @@ load_extension_data (const char *section_name,
struct GNUNET_TIME_Relative deposit_duration;
struct GNUNET_TIME_Relative legal_duration;
GNUNET_assert (! GNUNET_TIME_absolute_is_zero (meta->start.abs_time)); /* caller bug */
GNUNET_assert (0 != meta->start.abs_value_us); /* caller bug */
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (TEH_cfg,
section_name,
@ -2463,13 +2456,14 @@ load_extension_data (const char *section_name,
"DURATION_LEGAL");
return GNUNET_SYSERR;
}
meta->expire_deposit
= GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (meta->expire_withdraw.abs_time,
deposit_duration));
meta->expire_legal = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (meta->expire_deposit.abs_time,
legal_duration));
/* NOTE: this is a change from the 0.8 semantics of the configuration:
before duration_spend was relative to 'start', not to 'expire_withdraw'.
But doing it this way avoids the error case where previously
duration_spend < duration_withdraw was not allowed. */
meta->expire_deposit = GNUNET_TIME_absolute_add (meta->expire_withdraw,
deposit_duration);
meta->expire_legal = GNUNET_TIME_absolute_add (meta->expire_deposit,
legal_duration);
if (GNUNET_OK !=
TALER_config_get_amount (TEH_cfg,
section_name,
@ -2578,9 +2572,8 @@ TEH_keys_load_fees (const struct TALER_DenominationHash *h_denom_pub,
return GNUNET_NO;
}
meta->start = hd->start_time;
meta->expire_withdraw = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (meta->start.abs_time,
hd->validity_duration));
meta->expire_withdraw = GNUNET_TIME_absolute_add (meta->start,
hd->validity_duration);
ok = load_extension_data (hd->section_name,
meta);
if (GNUNET_OK == ok)
@ -2621,13 +2614,10 @@ TEH_keys_get_timing (const struct TALER_ExchangePublicKeyP *exchange_pub,
hsk = GNUNET_CONTAINER_multipeermap_get (ksh->helpers->esign_keys,
&pid);
meta->start = hsk->start_time;
meta->expire_sign = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (meta->start.abs_time,
hsk->validity_duration));
meta->expire_legal = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (meta->expire_sign.abs_time,
signkey_legal_duration));
meta->expire_sign = GNUNET_TIME_absolute_add (meta->start,
hsk->validity_duration);
meta->expire_legal = GNUNET_TIME_absolute_add (meta->expire_sign,
signkey_legal_duration);
return GNUNET_OK;
}
@ -2666,7 +2656,7 @@ struct FutureBuilderContext
* @param value a `struct HelperDenomination`
* @return #GNUNET_OK (continue to iterate)
*/
static enum GNUNET_GenericReturnValue
static int
add_future_denomkey_cb (void *cls,
const struct GNUNET_HashCode *h_denom_pub,
void *value)
@ -2683,9 +2673,8 @@ add_future_denomkey_cb (void *cls,
if (GNUNET_TIME_relative_is_zero (hd->validity_duration))
return GNUNET_OK; /* this key already expired! */
meta.start = hd->start_time;
meta.expire_withdraw = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (meta.start.abs_time,
hd->validity_duration));
meta.expire_withdraw = GNUNET_TIME_absolute_add (meta.start,
hd->validity_duration);
if (GNUNET_OK !=
load_extension_data (hd->section_name,
&meta))
@ -2700,14 +2689,14 @@ add_future_denomkey_cb (void *cls,
GNUNET_JSON_PACK (
TALER_JSON_pack_amount ("value",
&meta.value),
GNUNET_JSON_pack_timestamp ("stamp_start",
meta.start),
GNUNET_JSON_pack_timestamp ("stamp_expire_withdraw",
meta.expire_withdraw),
GNUNET_JSON_pack_timestamp ("stamp_expire_deposit",
meta.expire_deposit),
GNUNET_JSON_pack_timestamp ("stamp_expire_legal",
meta.expire_legal),
GNUNET_JSON_pack_time_abs ("stamp_start",
meta.start),
GNUNET_JSON_pack_time_abs ("stamp_expire_withdraw",
meta.expire_withdraw),
GNUNET_JSON_pack_time_abs ("stamp_expire_deposit",
meta.expire_deposit),
GNUNET_JSON_pack_time_abs ("stamp_expire_legal",
meta.expire_legal),
TALER_JSON_pack_denom_pub ("denom_pub",
&hd->denom_pub),
TALER_JSON_pack_amount ("fee_withdraw",
@ -2737,7 +2726,7 @@ add_future_denomkey_cb (void *cls,
* @param value a `struct HelperDenomination`
* @return #GNUNET_OK (continue to iterate)
*/
static enum GNUNET_GenericReturnValue
static int
add_future_signkey_cb (void *cls,
const struct GNUNET_PeerIdentity *pid,
void *value)
@ -2745,8 +2734,8 @@ add_future_signkey_cb (void *cls,
struct FutureBuilderContext *fbc = cls;
struct HelperSignkey *hsk = value;
struct SigningKey *sk;
struct GNUNET_TIME_Timestamp stamp_expire;
struct GNUNET_TIME_Timestamp legal_end;
struct GNUNET_TIME_Absolute stamp_expire;
struct GNUNET_TIME_Absolute legal_end;
sk = GNUNET_CONTAINER_multipeermap_get (fbc->ksh->signkey_map,
pid);
@ -2754,24 +2743,22 @@ add_future_signkey_cb (void *cls,
return GNUNET_OK; /* skip: this key is already active */
if (GNUNET_TIME_relative_is_zero (hsk->validity_duration))
return GNUNET_OK; /* this key already expired! */
stamp_expire = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (hsk->start_time.abs_time,
hsk->validity_duration));
legal_end = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (stamp_expire.abs_time,
signkey_legal_duration));
stamp_expire = GNUNET_TIME_absolute_add (hsk->start_time,
hsk->validity_duration);
legal_end = GNUNET_TIME_absolute_add (stamp_expire,
signkey_legal_duration);
GNUNET_assert (0 ==
json_array_append_new (
fbc->signkeys,
GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("key",
&hsk->exchange_pub),
GNUNET_JSON_pack_timestamp ("stamp_start",
hsk->start_time),
GNUNET_JSON_pack_timestamp ("stamp_expire",
stamp_expire),
GNUNET_JSON_pack_timestamp ("stamp_end",
legal_end),
GNUNET_JSON_pack_time_abs ("stamp_start",
hsk->start_time),
GNUNET_JSON_pack_time_abs ("stamp_expire",
stamp_expire),
GNUNET_JSON_pack_time_abs ("stamp_end",
legal_end),
GNUNET_JSON_pack_data_auto ("signkey_secmod_sig",
&hsk->sm_sig))));
return GNUNET_OK;

1
src/exchange/taler-exchange-httpd_keys.h
View File

@ -19,6 +19,7 @@
* @author Christian Grothoff
*/
#include "platform.h"
#include <pthread.h>
#include "taler_json_lib.h"
#include "taler_mhd_lib.h"
#include "taler-exchange-httpd_responses.h"

11
src/exchange/taler-exchange-httpd_kyc-check.c
View File

@ -236,7 +236,7 @@ TEH_handler_kyc_check (
struct KycPoller *kyp = rc->rh_ctx;
MHD_RESULT res;
enum GNUNET_GenericReturnValue ret;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
if (NULL == kyp)
{
@ -347,7 +347,8 @@ TEH_handler_kyc_check (
rc);
}
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
ret = TEH_DB_run_transaction (rc->connection,
"kyc check",
TEH_MT_OTHER,
@ -419,7 +420,7 @@ TEH_handler_kyc_check (
TALER_SIGNATURE_EXCHANGE_ACCOUNT_SETUP_SUCCESS),
.purpose.size = htonl (sizeof (as)),
.h_payto = kyp->h_payto,
.timestamp = GNUNET_TIME_timestamp_hton (now)
.timestamp = GNUNET_TIME_absolute_hton (now)
};
enum TALER_ErrorCode ec;
@ -439,8 +440,8 @@ TEH_handler_kyc_check (
&sig),
GNUNET_JSON_pack_data_auto ("exchange_pub",
&pub),
GNUNET_JSON_pack_timestamp ("now",
now));
GNUNET_JSON_pack_time_abs ("now",
now));
}
}

12
src/exchange/taler-exchange-httpd_management_auditors.c
View File

@ -59,7 +59,7 @@ struct AddAuditorContext
/**
* Timestamp for checking against replay attacks.
*/
struct GNUNET_TIME_Timestamp validity_start;
struct GNUNET_TIME_Absolute validity_start;
};
@ -84,7 +84,7 @@ add_auditor (void *cls,
MHD_RESULT *mhd_ret)
{
struct AddAuditorContext *aac = cls;
struct GNUNET_TIME_Timestamp last_date;
struct GNUNET_TIME_Absolute last_date;
enum GNUNET_DB_QueryStatus qs;
qs = TEH_plugin->lookup_auditor_timestamp (TEH_plugin->cls,
@ -102,9 +102,7 @@ add_auditor (void *cls,
return qs;
}
if ( (0 < qs) &&
(GNUNET_TIME_timestamp_cmp (last_date,
>,
aac->validity_start) ) )
(last_date.abs_value_us > aac->validity_start.abs_value_us) )
{
*mhd_ret = TALER_MHD_reply_with_error (
connection,
@ -157,8 +155,8 @@ TEH_handler_management_auditors (
&aac.auditor_url),
GNUNET_JSON_spec_string ("auditor_name",
&aac.auditor_name),
GNUNET_JSON_spec_timestamp ("validity_start",
&aac.validity_start),
TALER_JSON_spec_absolute_time ("validity_start",
&aac.validity_start),
GNUNET_JSON_spec_end ()
};
MHD_RESULT res;

12
src/exchange/taler-exchange-httpd_management_auditors_AP_disable.c
View File

@ -50,7 +50,7 @@ struct DelAuditorContext
/**
* Timestamp for checking against replay attacks.
*/
struct GNUNET_TIME_Timestamp validity_end;
struct GNUNET_TIME_Absolute validity_end;
};
@ -75,7 +75,7 @@ del_auditor (void *cls,
MHD_RESULT *mhd_ret)
{
struct DelAuditorContext *dac = cls;
struct GNUNET_TIME_Timestamp last_date;
struct GNUNET_TIME_Absolute last_date;
enum GNUNET_DB_QueryStatus qs;
qs = TEH_plugin->lookup_auditor_timestamp (TEH_plugin->cls,
@ -92,9 +92,7 @@ del_auditor (void *cls,
"lookup auditor");
return qs;
}
if (GNUNET_TIME_timestamp_cmp (last_date,
>,
dac->validity_end))
if (last_date.abs_value_us > dac->validity_end.abs_value_us)
{
*mhd_ret = TALER_MHD_reply_with_error (
connection,
@ -147,8 +145,8 @@ TEH_handler_management_auditors_AP_disable (
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_fixed_auto ("master_sig",
&master_sig),
GNUNET_JSON_spec_timestamp ("validity_end",
&dac.validity_end),
TALER_JSON_spec_absolute_time ("validity_end",
&dac.validity_end),
GNUNET_JSON_spec_end ()
};
MHD_RESULT res;

12
src/exchange/taler-exchange-httpd_management_wire_disable.c
View File

@ -50,7 +50,7 @@ struct DelWireContext
/**
* Timestamp for checking against replay attacks.
*/
struct GNUNET_TIME_Timestamp validity_end;
struct GNUNET_TIME_Absolute validity_end;
};
@ -75,7 +75,7 @@ del_wire (void *cls,
MHD_RESULT *mhd_ret)
{
struct DelWireContext *awc = cls;
struct GNUNET_TIME_Timestamp last_date;
struct GNUNET_TIME_Absolute last_date;
enum GNUNET_DB_QueryStatus qs;
qs = TEH_plugin->lookup_wire_timestamp (TEH_plugin->cls,
@ -92,9 +92,7 @@ del_wire (void *cls,
"lookup wire");
return qs;
}
if (GNUNET_TIME_timestamp_cmp (last_date,
>,
awc->validity_end))
if (last_date.abs_value_us > awc->validity_end.abs_value_us)
{
*mhd_ret = TALER_MHD_reply_with_error (
connection,
@ -142,8 +140,8 @@ TEH_handler_management_post_wire_disable (
&awc.master_sig),
GNUNET_JSON_spec_string ("payto_uri",
&awc.payto_uri),
GNUNET_JSON_spec_timestamp ("validity_end",
&awc.validity_end),
TALER_JSON_spec_absolute_time ("validity_end",
&awc.validity_end),
GNUNET_JSON_spec_end ()
};

12
src/exchange/taler-exchange-httpd_management_wire_enable.c
View File

@ -57,7 +57,7 @@ struct AddWireContext
/**
* Timestamp for checking against replay attacks.
*/
struct GNUNET_TIME_Timestamp validity_start;
struct GNUNET_TIME_Absolute validity_start;
};
@ -82,7 +82,7 @@ add_wire (void *cls,
MHD_RESULT *mhd_ret)
{
struct AddWireContext *awc = cls;
struct GNUNET_TIME_Timestamp last_date;
struct GNUNET_TIME_Absolute last_date;
enum GNUNET_DB_QueryStatus qs;
qs = TEH_plugin->lookup_wire_timestamp (TEH_plugin->cls,
@ -100,9 +100,7 @@ add_wire (void *cls,
return qs;
}
if ( (0 < qs) &&
(GNUNET_TIME_timestamp_cmp (last_date,
>,
awc->validity_start)) )
(last_date.abs_value_us > awc->validity_start.abs_value_us) )
{
*mhd_ret = TALER_MHD_reply_with_error (
connection,
@ -149,8 +147,8 @@ TEH_handler_management_post_wire (
&awc.master_sig_add),
GNUNET_JSON_spec_string ("payto_uri",
&awc.payto_uri),
GNUNET_JSON_spec_timestamp ("validity_start",
&awc.validity_start),
TALER_JSON_spec_absolute_time ("validity_start",
&awc.validity_start),
GNUNET_JSON_spec_end ()
};

14
src/exchange/taler-exchange-httpd_management_wire_fees.c
View File

@ -1,6 +1,6 @@
/*
This file is part of TALER
Copyright (C) 2020, 2021 Taler Systems SA
Copyright (C) 2020 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
@ -50,12 +50,12 @@ struct AddFeeContext
/**
* Starting period.
*/
struct GNUNET_TIME_Timestamp start_time;
struct GNUNET_TIME_Absolute start_time;
/**
* End of period.
*/
struct GNUNET_TIME_Timestamp end_time;
struct GNUNET_TIME_Absolute end_time;
/**
* Wire fee amount.
@ -171,10 +171,10 @@ TEH_handler_management_post_wire_fees (
&afc.master_sig),
GNUNET_JSON_spec_string ("wire_method",
&afc.wire_method),
GNUNET_JSON_spec_timestamp ("fee_start",
&afc.start_time),
GNUNET_JSON_spec_timestamp ("fee_end",
&afc.end_time),
TALER_JSON_spec_absolute_time ("fee_start",
&afc.start_time),
TALER_JSON_spec_absolute_time ("fee_end",
&afc.end_time),
TALER_JSON_spec_amount ("closing_fee",
TEH_currency,
&afc.closing_fee),

21
src/exchange/taler-exchange-httpd_melt.c
View File

@ -319,11 +319,12 @@ check_for_denomination_key (struct MHD_Connection *connection,
&mret);
if (NULL == dk)
return mret;
if (GNUNET_TIME_absolute_is_past (dk->meta.expire_legal.abs_time))
if (GNUNET_TIME_absolute_is_past (dk->meta.expire_legal))
{
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* Way too late now, even zombies have expired */
return TEH_RESPONSE_reply_expired_denom_pub_hash (
connection,
@ -332,11 +333,12 @@ check_for_denomination_key (struct MHD_Connection *connection,
TALER_EC_EXCHANGE_GENERIC_DENOMINATION_EXPIRED,
"MELT");
}
if (GNUNET_TIME_absolute_is_future (dk->meta.start.abs_time))
if (GNUNET_TIME_absolute_is_future (dk->meta.start))
{
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* This denomination is not yet valid */
return TEH_RESPONSE_reply_expired_denom_pub_hash (
connection,
@ -345,7 +347,7 @@ check_for_denomination_key (struct MHD_Connection *connection,
TALER_EC_EXCHANGE_GENERIC_DENOMINATION_VALIDITY_IN_FUTURE,
"MELT");
}
if (GNUNET_TIME_absolute_is_past (dk->meta.expire_deposit.abs_time))
if (GNUNET_TIME_absolute_is_past (dk->meta.expire_deposit))
{
/* We are past deposit expiration time, but maybe this is a zombie? */
struct TALER_DenominationHash denom_hash;
@ -369,9 +371,10 @@ check_for_denomination_key (struct MHD_Connection *connection,
}
if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != qs)
{
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* We never saw this coin before, so _this_ justification is not OK */
return TEH_RESPONSE_reply_expired_denom_pub_hash (
connection,

31
src/exchange/taler-exchange-httpd_recoup.c
View File

@ -92,7 +92,7 @@ struct RecoupContext
* Set by #recoup_transaction to the timestamp when the recoup
* was accepted.
*/
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
/**
* true if the client claims the coin originated from a refresh.
@ -233,7 +233,8 @@ recoup_transaction (void *cls,
}
TEH_plugin->free_coin_transaction_list (TEH_plugin->cls,
tl);
pc->now = GNUNET_TIME_timestamp_get ();
pc->now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&pc->now);
/* add coin to list of wire transfers for recoup */
if (pc->refreshed)
@ -306,33 +307,45 @@ verify_and_execute_recoup (
&mret);
if (NULL == dk)
return mret;
if (GNUNET_TIME_absolute_is_past (dk->meta.expire_deposit.abs_time))
if (GNUNET_TIME_absolute_is_past (dk->meta.expire_deposit))
{
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* This denomination is past the expiration time for recoup */
return TEH_RESPONSE_reply_expired_denom_pub_hash (
connection,
&coin->denom_pub_hash,
GNUNET_TIME_timestamp_get (),
now,
TALER_EC_EXCHANGE_GENERIC_DENOMINATION_EXPIRED,
"RECOUP");
}
if (GNUNET_TIME_absolute_is_future (dk->meta.start.abs_time))
if (GNUNET_TIME_absolute_is_future (dk->meta.start))
{
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* This denomination is not yet valid */
return TEH_RESPONSE_reply_expired_denom_pub_hash (
connection,
&coin->denom_pub_hash,
GNUNET_TIME_timestamp_get (),
now,
TALER_EC_EXCHANGE_GENERIC_DENOMINATION_VALIDITY_IN_FUTURE,
"RECOUP");
}
if (! dk->recoup_possible)
{
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* This denomination is not eligible for recoup */
return TEH_RESPONSE_reply_expired_denom_pub_hash (
connection,
&coin->denom_pub_hash,
GNUNET_TIME_timestamp_get (),
now,
TALER_EC_EXCHANGE_RECOUP_NOT_ELIGIBLE,
"RECOUP");
}
@ -517,7 +530,6 @@ TEH_handler_recoup (struct MHD_Connection *connection,
struct TALER_CoinPublicInfo coin;
union TALER_DenominationBlindingKeyP coin_bks;
struct TALER_CoinSpendSignatureP coin_sig;
struct TALER_Amount amount;
bool refreshed = false;
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_fixed_auto ("denom_pub_hash",
@ -528,9 +540,6 @@ TEH_handler_recoup (struct MHD_Connection *connection,
&coin_bks),
GNUNET_JSON_spec_fixed_auto ("coin_sig",
&coin_sig),
TALER_JSON_spec_amount ("amount",
TEH_currency,
&amount),
GNUNET_JSON_spec_mark_optional (
GNUNET_JSON_spec_bool ("refreshed",
&refreshed)),

16
src/exchange/taler-exchange-httpd_refreshes_reveal.c
View File

@ -519,23 +519,31 @@ resolve_refreshes_reveal_denominations (struct MHD_Connection *connection,
if (NULL == dks[i])
return mret;
if (GNUNET_TIME_absolute_is_past (dks[i]->meta.expire_withdraw.abs_time))
if (GNUNET_TIME_absolute_is_past (dks[i]->meta.expire_withdraw))
{
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* This denomination is past the expiration time for withdraws */
return TEH_RESPONSE_reply_expired_denom_pub_hash (
connection,
&dk_h[i],
GNUNET_TIME_timestamp_get (),
now,
TALER_EC_EXCHANGE_GENERIC_DENOMINATION_EXPIRED,
"REVEAL");
}
if (GNUNET_TIME_absolute_is_future (dks[i]->meta.start.abs_time))
if (GNUNET_TIME_absolute_is_future (dks[i]->meta.start))
{
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* This denomination is not yet valid */
return TEH_RESPONSE_reply_expired_denom_pub_hash (
connection,
&dk_h[i],
GNUNET_TIME_timestamp_get (),
now,
TALER_EC_EXCHANGE_GENERIC_DENOMINATION_VALIDITY_IN_FUTURE,
"REVEAL");
}

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

@ -96,11 +96,11 @@ TEH_RESPONSE_compile_transaction_history (
&deposit->amount_with_fee),
TALER_JSON_pack_amount ("deposit_fee",
&deposit->deposit_fee),
GNUNET_JSON_pack_timestamp ("timestamp",
deposit->timestamp),
GNUNET_JSON_pack_time_abs ("timestamp",
deposit->timestamp),
GNUNET_JSON_pack_allow_null (
GNUNET_JSON_pack_timestamp ("refund_deadline",
deposit->refund_deadline)),
GNUNET_JSON_pack_time_abs ("refund_deadline",
deposit->refund_deadline)),
GNUNET_JSON_pack_data_auto ("merchant_pub",
&deposit->merchant_pub),
GNUNET_JSON_pack_data_auto ("h_contract_terms",
@ -243,7 +243,7 @@ TEH_RESPONSE_compile_transaction_history (
.purpose.purpose = htonl (
TALER_SIGNATURE_EXCHANGE_CONFIRM_RECOUP_REFRESH),
.purpose.size = htonl (sizeof (pc)),
.timestamp = GNUNET_TIME_timestamp_hton (pr->timestamp),
.timestamp = GNUNET_TIME_absolute_hton (pr->timestamp),
.coin_pub = pr->coin.coin_pub,
.old_coin_pub = pr->old_coin_pub
};
@ -278,8 +278,8 @@ TEH_RESPONSE_compile_transaction_history (
&epub),
GNUNET_JSON_pack_data_auto ("coin_pub",
&pr->coin.coin_pub),
GNUNET_JSON_pack_timestamp ("timestamp",
pr->timestamp))))
GNUNET_JSON_pack_time_abs ("timestamp",
pr->timestamp))))
{
GNUNET_break (0);
json_decref (history);
@ -296,7 +296,7 @@ TEH_RESPONSE_compile_transaction_history (
struct TALER_RecoupConfirmationPS pc = {
.purpose.purpose = htonl (TALER_SIGNATURE_EXCHANGE_CONFIRM_RECOUP),
.purpose.size = htonl (sizeof (pc)),
.timestamp = GNUNET_TIME_timestamp_hton (recoup->timestamp),
.timestamp = GNUNET_TIME_absolute_hton (recoup->timestamp),
.coin_pub = *coin_pub,
.reserve_pub = recoup->reserve_pub
};
@ -334,8 +334,8 @@ TEH_RESPONSE_compile_transaction_history (
&recoup->coin_blind),
GNUNET_JSON_pack_data_auto ("reserve_pub",
&recoup->reserve_pub),
GNUNET_JSON_pack_timestamp ("timestamp",
recoup->timestamp))))
GNUNET_JSON_pack_time_abs ("timestamp",
recoup->timestamp))))
{
GNUNET_break (0);
json_decref (history);
@ -353,7 +353,7 @@ TEH_RESPONSE_compile_transaction_history (
.purpose.purpose = htonl (
TALER_SIGNATURE_EXCHANGE_CONFIRM_RECOUP_REFRESH),
.purpose.size = htonl (sizeof (pc)),
.timestamp = GNUNET_TIME_timestamp_hton (pr->timestamp),
.timestamp = GNUNET_TIME_absolute_hton (pr->timestamp),
.coin_pub = *coin_pub,
.old_coin_pub = pr->old_coin_pub
};
@ -394,8 +394,8 @@ TEH_RESPONSE_compile_transaction_history (
&pr->coin_sig),
GNUNET_JSON_pack_data_auto ("coin_blind",
&pr->coin_blind),
GNUNET_JSON_pack_timestamp ("timestamp",
pr->timestamp))))
GNUNET_JSON_pack_time_abs ("timestamp",
pr->timestamp))))
{
GNUNET_break (0);
json_decref (history);
@ -418,15 +418,16 @@ TEH_RESPONSE_reply_unknown_denom_pub_hash (
{
struct TALER_ExchangePublicKeyP epub;
struct TALER_ExchangeSignatureP esig;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
enum TALER_ErrorCode ec;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
GNUNET_TIME_round_abs (&now);
{
struct TALER_DenominationUnknownAffirmationPS dua = {
.purpose.size = htonl (sizeof (dua)),
.purpose.purpose = htonl (TALER_SIGNATURE_EXCHANGE_AFFIRM_DENOM_UNKNOWN),
.timestamp = GNUNET_TIME_timestamp_hton (now),
.timestamp = GNUNET_TIME_absolute_hton (now),
.h_denom_pub = *dph,
};
@ -446,8 +447,8 @@ TEH_RESPONSE_reply_unknown_denom_pub_hash (
connection,
MHD_HTTP_NOT_FOUND,
TALER_JSON_pack_ec (TALER_EC_EXCHANGE_GENERIC_DENOMINATION_KEY_UNKNOWN),
GNUNET_JSON_pack_timestamp ("timestamp",
now),
GNUNET_JSON_pack_time_abs ("timestamp",
now),
GNUNET_JSON_pack_data_auto ("exchange_pub",
&epub),
GNUNET_JSON_pack_data_auto ("exchange_sig",
@ -461,7 +462,7 @@ MHD_RESULT
TEH_RESPONSE_reply_expired_denom_pub_hash (
struct MHD_Connection *connection,
const struct TALER_DenominationHash *dph,
struct GNUNET_TIME_Timestamp now,
struct GNUNET_TIME_Absolute now,
enum TALER_ErrorCode ec,
const char *oper)
{
@ -472,7 +473,7 @@ TEH_RESPONSE_reply_expired_denom_pub_hash (
.purpose.size = htonl (sizeof (dua)),
.purpose.purpose = htonl (
TALER_SIGNATURE_EXCHANGE_AFFIRM_DENOM_EXPIRED),
.timestamp = GNUNET_TIME_timestamp_hton (now),
.timestamp = GNUNET_TIME_absolute_hton (now),
.h_denom_pub = *dph,
};
@ -498,8 +499,8 @@ TEH_RESPONSE_reply_expired_denom_pub_hash (
TALER_JSON_pack_ec (ec),
GNUNET_JSON_pack_string ("oper",
oper),
GNUNET_JSON_pack_timestamp ("timestamp",
now),
GNUNET_JSON_pack_time_abs ("timestamp",
now),
GNUNET_JSON_pack_data_auto ("exchange_pub",
&epub),
GNUNET_JSON_pack_data_auto ("exchange_sig",
@ -606,8 +607,8 @@ TEH_RESPONSE_compile_reserve_history (
GNUNET_JSON_PACK (
GNUNET_JSON_pack_string ("type",
"CREDIT"),
GNUNET_JSON_pack_timestamp ("timestamp",
bank->execution_date),
GNUNET_JSON_pack_time_abs ("timestamp",
bank->execution_date),
GNUNET_JSON_pack_string ("sender_account_url",
bank->sender_account_details),
GNUNET_JSON_pack_uint64 ("wire_reference",
@ -693,7 +694,7 @@ TEH_RESPONSE_compile_reserve_history (
struct TALER_RecoupConfirmationPS pc = {
.purpose.purpose = htonl (TALER_SIGNATURE_EXCHANGE_CONFIRM_RECOUP),
.purpose.size = htonl (sizeof (pc)),
.timestamp = GNUNET_TIME_timestamp_hton (recoup->timestamp),
.timestamp = GNUNET_TIME_absolute_hton (recoup->timestamp),
.coin_pub = recoup->coin.coin_pub,
.reserve_pub = recoup->reserve_pub
};
@ -721,8 +722,8 @@ TEH_RESPONSE_compile_reserve_history (
&pub),
GNUNET_JSON_pack_data_auto ("exchange_sig",
&sig),
GNUNET_JSON_pack_timestamp ("timestamp",
recoup->timestamp),
GNUNET_JSON_pack_time_abs ("timestamp",
recoup->timestamp),
TALER_JSON_pack_amount ("amount",
&recoup->value),
GNUNET_JSON_pack_data_auto ("coin_pub",
@ -764,7 +765,7 @@ TEH_RESPONSE_compile_reserve_history (
struct TALER_ReserveCloseConfirmationPS rcc = {
.purpose.purpose = htonl (TALER_SIGNATURE_EXCHANGE_RESERVE_CLOSED),
.purpose.size = htonl (sizeof (rcc)),
.timestamp = GNUNET_TIME_timestamp_hton (closing->execution_date),
.timestamp = GNUNET_TIME_absolute_hton (closing->execution_date),
.reserve_pub = pos->details.closing->reserve_pub,
.wtid = closing->wtid
};
@ -799,8 +800,8 @@ TEH_RESPONSE_compile_reserve_history (
&pub),
GNUNET_JSON_pack_data_auto ("exchange_sig",
&sig),
GNUNET_JSON_pack_timestamp ("timestamp",
closing->execution_date),
GNUNET_JSON_pack_time_abs ("timestamp",
closing->execution_date),
TALER_JSON_pack_amount ("amount",
&value),
TALER_JSON_pack_amount ("closing_fee",

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

@ -27,6 +27,7 @@
#include <gnunet/gnunet_util_lib.h>
#include <jansson.h>
#include <microhttpd.h>
#include <pthread.h>
#include "taler_error_codes.h"
#include "taler-exchange-httpd.h"
#include "taler-exchange-httpd_db.h"
@ -76,7 +77,7 @@ MHD_RESULT
TEH_RESPONSE_reply_expired_denom_pub_hash (
struct MHD_Connection *connection,
const struct TALER_DenominationHash *dph,
struct GNUNET_TIME_Timestamp now,
struct GNUNET_TIME_Absolute now,
enum TALER_ErrorCode ec,
const char *oper);

17
src/exchange/taler-exchange-httpd_transfers_get.c
View File

@ -89,7 +89,7 @@ reply_transfer_details (struct MHD_Connection *connection,
const struct TALER_MerchantPublicKeyP *merchant_pub,
const char *payto_uri,
const struct TALER_Amount *wire_fee,
struct GNUNET_TIME_Timestamp exec_time,
struct GNUNET_TIME_Absolute exec_time,
const struct AggregatedDepositDetail *wdd_head)
{
json_t *deposits;
@ -99,6 +99,7 @@ reply_transfer_details (struct MHD_Connection *connection,
struct TALER_ExchangePublicKeyP pub;
struct TALER_ExchangeSignatureP sig;
GNUNET_TIME_round_abs (&exec_time);
deposits = json_array ();
GNUNET_assert (NULL != deposits);
hash_context = GNUNET_CRYPTO_hash_context_start ();
@ -107,7 +108,7 @@ reply_transfer_details (struct MHD_Connection *connection,
wdd_pos = wdd_pos->next)
{
dd.h_contract_terms = wdd_pos->h_contract_terms;
dd.execution_time = GNUNET_TIME_timestamp_hton (exec_time);
dd.execution_time = GNUNET_TIME_absolute_hton (exec_time);
dd.coin_pub = wdd_pos->coin_pub;
TALER_amount_hton (&dd.deposit_value,
&wdd_pos->deposit_value);
@ -174,8 +175,8 @@ reply_transfer_details (struct MHD_Connection *connection,
merchant_pub),
GNUNET_JSON_pack_data_auto ("h_payto",
&wdp.h_payto),
GNUNET_JSON_pack_timestamp ("execution_time",
exec_time),
GNUNET_JSON_pack_time_abs ("execution_time",
exec_time),
GNUNET_JSON_pack_array_steal ("deposits",
deposits),
GNUNET_JSON_pack_data_auto ("exchange_sig",
@ -218,7 +219,7 @@ struct WtidTransactionContext
/**
* Execution time of the wire transfer
*/
struct GNUNET_TIME_Timestamp exec_time;
struct GNUNET_TIME_Absolute exec_time;
/**
* Head of DLL with deposit details for transfers GET response.
@ -272,7 +273,7 @@ handle_deposit_data (void *cls,
uint64_t rowid,
const struct TALER_MerchantPublicKeyP *merchant_pub,
const char *account_payto_uri,
struct GNUNET_TIME_Timestamp exec_time,
struct GNUNET_TIME_Absolute exec_time,
const struct TALER_PrivateContractHash *h_contract_terms,
const struct TALER_DenominationPublicKey *denom_pub,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
@ -396,8 +397,8 @@ get_transfer_deposits (void *cls,
{
struct WtidTransactionContext *ctx = cls;
enum GNUNET_DB_QueryStatus qs;
struct GNUNET_TIME_Timestamp wire_fee_start_date;
struct GNUNET_TIME_Timestamp wire_fee_end_date;
struct GNUNET_TIME_Absolute wire_fee_start_date;
struct GNUNET_TIME_Absolute wire_fee_end_date;
struct TALER_MasterSignatureP wire_fee_master_sig;
struct TALER_Amount closing_fee;

12
src/exchange/taler-exchange-httpd_wire.c
View File

@ -212,8 +212,8 @@ static void
add_wire_fee (void *cls,
const struct TALER_Amount *wire_fee,
const struct TALER_Amount *closing_fee,
struct GNUNET_TIME_Timestamp start_date,
struct GNUNET_TIME_Timestamp end_date,
struct GNUNET_TIME_Absolute start_date,
struct GNUNET_TIME_Absolute end_date,
const struct TALER_MasterSignatureP *master_sig)
{
json_t *a = cls;
@ -226,10 +226,10 @@ add_wire_fee (void *cls,
wire_fee),
TALER_JSON_pack_amount ("closing_fee",
closing_fee),
GNUNET_JSON_pack_timestamp ("start_date",
start_date),
GNUNET_JSON_pack_timestamp ("end_date",
end_date),
GNUNET_JSON_pack_time_abs ("start_date",
start_date),
GNUNET_JSON_pack_time_abs ("end_date",
end_date),
GNUNET_JSON_pack_data_auto ("sig",
master_sig))))
{

33
src/exchange/taler-exchange-httpd_withdraw.c
View File

@ -141,9 +141,11 @@ withdraw_transaction (void *cls,
bool found = false;
bool balance_ok = false;
uint64_t reserve_uuid;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
now = GNUNET_TIME_timestamp_get ();
wc->collectable.reserve_pub = wc->wsrd.reserve_pub;
wc->collectable.h_coin_envelope = wc->wsrd.h_coin_envelope;
qs = TEH_plugin->do_withdraw (TEH_plugin->cls,
@ -235,7 +237,7 @@ withdraw_transaction (void *cls,
qs2 = TEH_plugin->do_withdraw_limit_check (
TEH_plugin->cls,
reserve_uuid,
GNUNET_TIME_absolute_subtract (now.abs_time,
GNUNET_TIME_absolute_subtract (now,
TEH_kyc_config.withdraw_period),
&TEH_kyc_config.withdraw_limit,
&below_limit);
@ -353,6 +355,7 @@ TEH_handler_withdraw (struct TEH_RequestContext *rc,
}
{
MHD_RESULT mret;
struct GNUNET_TIME_Absolute now;
struct TEH_KeyStateHandle *ksh;
ksh = TEH_keys_get_state ();
@ -389,8 +392,14 @@ TEH_handler_withdraw (struct TEH_RequestContext *rc,
GNUNET_JSON_parse_free (spec);
return mret;
}
if (GNUNET_TIME_absolute_is_past (dk->meta.expire_withdraw.abs_time))
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
if (GNUNET_TIME_absolute_is_past (dk->meta.expire_withdraw))
{
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* This denomination is past the expiration time for withdraws */
if (! check_request_idempotent (rc,
&wc,
@ -400,27 +409,35 @@ TEH_handler_withdraw (struct TEH_RequestContext *rc,
return TEH_RESPONSE_reply_expired_denom_pub_hash (
rc->connection,
&wc.collectable.denom_pub_hash,
GNUNET_TIME_timestamp_get (),
now,
TALER_EC_EXCHANGE_GENERIC_DENOMINATION_EXPIRED,
"WITHDRAW");
}
GNUNET_JSON_parse_free (spec);
return mret;
}
if (GNUNET_TIME_absolute_is_future (dk->meta.start.abs_time))
if (GNUNET_TIME_absolute_is_future (dk->meta.start))
{
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* This denomination is not yet valid, no need to check
for idempotency! */
GNUNET_JSON_parse_free (spec);
return TEH_RESPONSE_reply_expired_denom_pub_hash (
rc->connection,
&wc.collectable.denom_pub_hash,
GNUNET_TIME_timestamp_get (),
now,
TALER_EC_EXCHANGE_GENERIC_DENOMINATION_VALIDITY_IN_FUTURE,
"WITHDRAW");
}
if (dk->recoup_possible)
{
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
/* This denomination has been revoked */
if (! check_request_idempotent (rc,
&wc,
@ -430,7 +447,7 @@ TEH_handler_withdraw (struct TEH_RequestContext *rc,
return TEH_RESPONSE_reply_expired_denom_pub_hash (
rc->connection,
&wc.collectable.denom_pub_hash,
GNUNET_TIME_timestamp_get (),
now,
TALER_EC_EXCHANGE_GENERIC_DENOMINATION_REVOKED,
"WITHDRAW");
}

22
src/exchange/taler-exchange-transfer.c
View File

@ -201,7 +201,7 @@ static unsigned int shard_size = DEFAULT_BATCH_SIZE;
/**
* How many workers should we plan our scheduling with?
*/
static unsigned int max_workers = 0;
static unsigned int max_workers = 16;
/**
@ -338,15 +338,6 @@ static void
run_transfers (void *cls);
static void
run_transfers_delayed (void *cls)
{
(void) cls;
shard->shard_start_time = GNUNET_TIME_absolute_get ();
run_transfers (NULL);
}
/**
* Select shard to process.
*
@ -416,7 +407,7 @@ wire_confirm_cb (void *cls,
unsigned int http_status_code,
enum TALER_ErrorCode ec,
uint64_t row_id,
struct GNUNET_TIME_Timestamp wire_timestamp)
struct GNUNET_TIME_Absolute wire_timestamp)
{
struct WirePrepareData *wpd = cls;
enum GNUNET_DB_QueryStatus qs;
@ -651,8 +642,7 @@ run_transfers (void *cls)
/* normal case */
break;
}
shard_delay = GNUNET_TIME_absolute_get_duration (
shard->shard_start_time);
shard_delay = GNUNET_TIME_absolute_get_duration (shard->shard_start_time);
GNUNET_free (shard);
GNUNET_assert (NULL == task);
task = GNUNET_SCHEDULER_add_now (&select_shard,
@ -719,7 +709,7 @@ run_transfers (void *cls)
"No more pending wire transfers, going idle\n");
GNUNET_assert (NULL == task);
task = GNUNET_SCHEDULER_add_delayed (transfer_idle_sleep_interval,
&run_transfers_delayed,
&run_transfers,
NULL);
}
return;
@ -786,8 +776,8 @@ select_shard (void *cls)
GNUNET_assert (NULL == task);
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Serialization failure, trying again in %s!\n",
GNUNET_TIME_relative2s (serialization_delay,
true));
GNUNET_STRINGS_relative_time_to_string (serialization_delay,
GNUNET_YES));
task = GNUNET_SCHEDULER_add_delayed (serialization_delay,
&select_shard,
NULL);

44
src/exchangedb/irbt_callbacks.c
View File

@ -43,13 +43,13 @@ irbt_cb_table_denominations (struct PostgresClosure *pg,
&td->details.denominations.denom_pub),
GNUNET_PQ_query_param_auto_from_type (
&td->details.denominations.master_sig),
GNUNET_PQ_query_param_timestamp (
TALER_PQ_query_param_absolute_time (
&td->details.denominations.valid_from),
GNUNET_PQ_query_param_timestamp (
TALER_PQ_query_param_absolute_time (
&td->details.denominations.expire_withdraw),
GNUNET_PQ_query_param_timestamp (
TALER_PQ_query_param_absolute_time (
&td->details.denominations.expire_deposit),
GNUNET_PQ_query_param_timestamp (
TALER_PQ_query_param_absolute_time (
&td->details.denominations.expire_legal),
TALER_PQ_query_param_amount (&td->details.denominations.coin),
TALER_PQ_query_param_amount (
@ -144,8 +144,8 @@ irbt_cb_table_reserves (struct PostgresClosure *pg,
GNUNET_PQ_query_param_uint64 (&td->serial),
GNUNET_PQ_query_param_auto_from_type (&td->details.reserves.reserve_pub),
TALER_PQ_query_param_amount (&td->details.reserves.current_balance),
GNUNET_PQ_query_param_timestamp (&td->details.reserves.expiration_date),
GNUNET_PQ_query_param_timestamp (&td->details.reserves.gc_date),
TALER_PQ_query_param_absolute_time (&td->details.reserves.expiration_date),
TALER_PQ_query_param_absolute_time (&td->details.reserves.gc_date),
GNUNET_PQ_query_param_end
};
@ -172,7 +172,7 @@ irbt_cb_table_reserves_in (struct PostgresClosure *pg,
GNUNET_PQ_query_param_uint64 (&td->details.reserves_in.sender_account),
GNUNET_PQ_query_param_string (
td->details.reserves_in.exchange_account_section),
GNUNET_PQ_query_param_timestamp (
TALER_PQ_query_param_absolute_time (
&td->details.reserves_in.execution_date),
GNUNET_PQ_query_param_uint64 (&td->details.reserves_in.reserve_uuid),
GNUNET_PQ_query_param_end
@ -196,7 +196,7 @@ irbt_cb_table_reserves_close (struct PostgresClosure *pg,
{
struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_uint64 (&td->serial),
GNUNET_PQ_query_param_timestamp (
TALER_PQ_query_param_absolute_time (
&td->details.reserves_close.execution_date),
GNUNET_PQ_query_param_auto_from_type (
&td->details.reserves_close.wtid),
@ -236,7 +236,7 @@ irbt_cb_table_reserves_out (struct PostgresClosure *pg,
&td->details.reserves_out.reserve_uuid),
GNUNET_PQ_query_param_auto_from_type (
&td->details.reserves_out.reserve_sig),
GNUNET_PQ_query_param_timestamp (
TALER_PQ_query_param_absolute_time (
&td->details.reserves_out.execution_date),
TALER_PQ_query_param_amount (
&td->details.reserves_out.amount_with_fee),
@ -266,7 +266,7 @@ irbt_cb_table_auditors (struct PostgresClosure *pg,
GNUNET_PQ_query_param_string (td->details.auditors.auditor_name),
GNUNET_PQ_query_param_string (td->details.auditors.auditor_url),
GNUNET_PQ_query_param_auto_from_type (&is_active),
GNUNET_PQ_query_param_timestamp (&td->details.auditors.last_change),
GNUNET_PQ_query_param_absolute_time (&td->details.auditors.last_change),
GNUNET_PQ_query_param_end
};
@ -318,11 +318,11 @@ irbt_cb_table_exchange_sign_keys (struct PostgresClosure *pg,
&td->details.exchange_sign_keys.exchange_pub),
GNUNET_PQ_query_param_auto_from_type (
&td->details.exchange_sign_keys.master_sig),
GNUNET_PQ_query_param_timestamp (
TALER_PQ_query_param_absolute_time (
&td->details.exchange_sign_keys.meta.start),
GNUNET_PQ_query_param_timestamp (
TALER_PQ_query_param_absolute_time (
&td->details.exchange_sign_keys.meta.expire_sign),
GNUNET_PQ_query_param_timestamp (
TALER_PQ_query_param_absolute_time (
&td->details.exchange_sign_keys.meta.expire_legal),
GNUNET_PQ_query_param_end
};
@ -503,11 +503,11 @@ irbt_cb_table_deposits (struct PostgresClosure *pg,
GNUNET_PQ_query_param_uint64 (&td->details.deposits.shard),
GNUNET_PQ_query_param_uint64 (&td->details.deposits.known_coin_id),
TALER_PQ_query_param_amount (&td->details.deposits.amount_with_fee),
GNUNET_PQ_query_param_timestamp (&td->details.deposits.wallet_timestamp),
GNUNET_PQ_query_param_timestamp (
TALER_PQ_query_param_absolute_time (&td->details.deposits.wallet_timestamp),
TALER_PQ_query_param_absolute_time (
&td->details.deposits.exchange_timestamp),
GNUNET_PQ_query_param_timestamp (&td->details.deposits.refund_deadline),
GNUNET_PQ_query_param_timestamp (&td->details.deposits.wire_deadline),
TALER_PQ_query_param_absolute_time (&td->details.deposits.refund_deadline),
TALER_PQ_query_param_absolute_time (&td->details.deposits.wire_deadline),
GNUNET_PQ_query_param_auto_from_type (&td->details.deposits.merchant_pub),
GNUNET_PQ_query_param_auto_from_type (
&td->details.deposits.h_contract_terms),
@ -565,7 +565,7 @@ irbt_cb_table_wire_out (struct PostgresClosure *pg,
{
struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_uint64 (&td->serial),
GNUNET_PQ_query_param_timestamp (&td->details.wire_out.execution_date),
TALER_PQ_query_param_absolute_time (&td->details.wire_out.execution_date),
GNUNET_PQ_query_param_auto_from_type (&td->details.wire_out.wtid_raw),
GNUNET_PQ_query_param_uint64 (&td->details.wire_out.wire_target_serial_id),
GNUNET_PQ_query_param_string (
@ -618,8 +618,8 @@ irbt_cb_table_wire_fee (struct PostgresClosure *pg,
struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_uint64 (&td->serial),
GNUNET_PQ_query_param_string (td->details.wire_fee.wire_method),
GNUNET_PQ_query_param_timestamp (&td->details.wire_fee.start_date),
GNUNET_PQ_query_param_timestamp (&td->details.wire_fee.end_date),
TALER_PQ_query_param_absolute_time (&td->details.wire_fee.start_date),
TALER_PQ_query_param_absolute_time (&td->details.wire_fee.end_date),
TALER_PQ_query_param_amount (&td->details.wire_fee.wire_fee),
TALER_PQ_query_param_amount (&td->details.wire_fee.closing_fee),
GNUNET_PQ_query_param_auto_from_type (&td->details.wire_fee.master_sig),
@ -647,7 +647,7 @@ irbt_cb_table_recoup (struct PostgresClosure *pg,
GNUNET_PQ_query_param_auto_from_type (&td->details.recoup.coin_sig),
GNUNET_PQ_query_param_auto_from_type (&td->details.recoup.coin_blind),
TALER_PQ_query_param_amount (&td->details.recoup.amount),
GNUNET_PQ_query_param_timestamp (&td->details.recoup.timestamp),
TALER_PQ_query_param_absolute_time (&td->details.recoup.timestamp),
GNUNET_PQ_query_param_uint64 (&td->details.recoup.known_coin_id),
GNUNET_PQ_query_param_uint64 (&td->details.recoup.reserve_out_serial_id),
GNUNET_PQ_query_param_end
@ -675,7 +675,7 @@ irbt_cb_table_recoup_refresh (struct PostgresClosure *pg,
GNUNET_PQ_query_param_auto_from_type (
&td->details.recoup_refresh.coin_blind),
TALER_PQ_query_param_amount (&td->details.recoup_refresh.amount),
GNUNET_PQ_query_param_timestamp (&td->details.recoup_refresh.timestamp),
TALER_PQ_query_param_absolute_time (&td->details.recoup_refresh.timestamp),
GNUNET_PQ_query_param_uint64 (&td->details.recoup_refresh.known_coin_id),
GNUNET_PQ_query_param_uint64 (&td->details.recoup_refresh.rrc_serial),
GNUNET_PQ_query_param_end

70
src/exchangedb/lrbt_callbacks.c
View File

@ -61,18 +61,18 @@ lrbt_cb_table_denominations (void *cls,
GNUNET_PQ_result_spec_auto_from_type (
"master_sig",
&td.details.denominations.master_sig),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"valid_from",
&td.details.denominations.valid_from),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"expire_withdraw",
&td.details.denominations.
expire_withdraw),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"expire_deposit",
&td.details.denominations.
expire_deposit),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"expire_legal",
&td.details.denominations.expire_legal),
TALER_PQ_RESULT_SPEC_AMOUNT (
@ -230,10 +230,10 @@ lrbt_cb_table_reserves (void *cls,
&td.details.reserves.reserve_pub),
TALER_PQ_RESULT_SPEC_AMOUNT ("current_balance",
&td.details.reserves.current_balance),
GNUNET_PQ_result_spec_timestamp ("expiration_date",
&td.details.reserves.expiration_date),
GNUNET_PQ_result_spec_timestamp ("gc_date",
&td.details.reserves.gc_date),
TALER_PQ_result_spec_absolute_time ("expiration_date",
&td.details.reserves.expiration_date),
TALER_PQ_result_spec_absolute_time ("gc_date",
&td.details.reserves.gc_date),
GNUNET_PQ_result_spec_end
};
@ -292,7 +292,7 @@ lrbt_cb_table_reserves_in (void *cls,
GNUNET_PQ_result_spec_string (
"exchange_account_section",
&td.details.reserves_in.exchange_account_section),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"execution_date",
&td.details.reserves_in.execution_date),
GNUNET_PQ_result_spec_end
@ -341,7 +341,7 @@ lrbt_cb_table_reserves_close (void *cls,
GNUNET_PQ_result_spec_uint64 (
"reserve_uuid",
&td.details.reserves_close.reserve_uuid),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"execution_date",
&td.details.reserves_close.execution_date),
GNUNET_PQ_result_spec_auto_from_type (
@ -414,7 +414,7 @@ lrbt_cb_table_reserves_out (void *cls,
GNUNET_PQ_result_spec_auto_from_type (
"reserve_sig",
&td.details.reserves_out.reserve_sig),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"execution_date",
&td.details.reserves_out.execution_date),
TALER_PQ_RESULT_SPEC_AMOUNT (
@ -470,8 +470,8 @@ lrbt_cb_table_auditors (void *cls,
&td.details.auditors.auditor_name),
GNUNET_PQ_result_spec_auto_from_type ("is_active",
&is_active8),
GNUNET_PQ_result_spec_timestamp ("last_change",
&td.details.auditors.last_change),
TALER_PQ_result_spec_absolute_time ("last_change",
&td.details.auditors.last_change),
GNUNET_PQ_result_spec_end
};
@ -571,15 +571,15 @@ lrbt_cb_table_exchange_sign_keys (void *cls,
GNUNET_PQ_result_spec_auto_from_type ("master_sig",
&td.details.exchange_sign_keys.
master_sig),
GNUNET_PQ_result_spec_timestamp ("valid_from",
&td.details.exchange_sign_keys.meta.
start),
GNUNET_PQ_result_spec_timestamp ("expire_sign",
&td.details.exchange_sign_keys.meta.
expire_sign),
GNUNET_PQ_result_spec_timestamp ("expire_legal",
&td.details.exchange_sign_keys.meta.
expire_legal),
TALER_PQ_result_spec_absolute_time ("valid_from",
&td.details.exchange_sign_keys.meta.
start),
TALER_PQ_result_spec_absolute_time ("expire_sign",
&td.details.exchange_sign_keys.meta.
expire_sign),
TALER_PQ_result_spec_absolute_time ("expire_legal",
&td.details.exchange_sign_keys.meta.
expire_legal),
GNUNET_PQ_result_spec_end
};
@ -916,16 +916,16 @@ lrbt_cb_table_deposits (void *cls,
TALER_PQ_RESULT_SPEC_AMOUNT (
"amount_with_fee",
&td.details.deposits.amount_with_fee),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"wallet_timestamp",
&td.details.deposits.wallet_timestamp),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"exchange_timestamp",
&td.details.deposits.exchange_timestamp),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"refund_deadline",
&td.details.deposits.refund_deadline),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"wire_deadline",
&td.details.deposits.wire_deadline),
GNUNET_PQ_result_spec_auto_from_type (
@ -1054,7 +1054,7 @@ lrbt_cb_table_wire_out (void *cls,
struct GNUNET_PQ_ResultSpec rs[] = {
GNUNET_PQ_result_spec_uint64 ("serial",
&td.serial),
GNUNET_PQ_result_spec_timestamp (
TALER_PQ_result_spec_absolute_time (
"execution_date",
&td.details.wire_out.execution_date),
GNUNET_PQ_result_spec_auto_from_type (
@ -1161,10 +1161,10 @@ lrbt_cb_table_wire_fee (void *cls,
&td.serial),
GNUNET_PQ_result_spec_string ("wire_method",
&td.details.wire_fee.wire_method),
GNUNET_PQ_result_spec_timestamp ("start_date",
&td.details.wire_fee.start_date),
GNUNET_PQ_result_spec_timestamp ("end_date",
&td.details.wire_fee.end_date),
TALER_PQ_result_spec_absolute_time ("start_date",
&td.details.wire_fee.start_date),
TALER_PQ_result_spec_absolute_time ("end_date",
&td.details.wire_fee.end_date),
TALER_PQ_RESULT_SPEC_AMOUNT ("wire_fee",
&td.details.wire_fee.wire_fee),
TALER_PQ_RESULT_SPEC_AMOUNT ("closing_fee",
@ -1219,8 +1219,8 @@ lrbt_cb_table_recoup (void *cls,
&td.details.recoup.coin_blind),
TALER_PQ_RESULT_SPEC_AMOUNT ("amount",
&td.details.recoup.amount),
GNUNET_PQ_result_spec_timestamp ("timestamp",
&td.details.recoup.timestamp),
TALER_PQ_result_spec_absolute_time ("timestamp",
&td.details.recoup.timestamp),
GNUNET_PQ_result_spec_uint64 ("known_coin_id",
&td.details.recoup.known_coin_id),
GNUNET_PQ_result_spec_uint64 ("reserve_out_serial_id",
@ -1274,8 +1274,8 @@ lrbt_cb_table_recoup_refresh (void *cls,
&td.details.recoup_refresh.coin_blind),
TALER_PQ_RESULT_SPEC_AMOUNT ("amount",
&td.details.recoup_refresh.amount),
GNUNET_PQ_result_spec_timestamp ("timestamp",
&td.details.recoup_refresh.timestamp),
TALER_PQ_result_spec_absolute_time ("timestamp",
&td.details.recoup_refresh.timestamp),
GNUNET_PQ_result_spec_uint64 ("known_coin_id",
&td.details.recoup_refresh.known_coin_id),
GNUNET_PQ_result_spec_uint64 ("rrc_serial",

592
src/exchangedb/plugin_exchangedb_postgres.c
View File

File diff suppressed because it is too large Load Diff

182
src/exchangedb/test_exchangedb.c
View File

@ -214,7 +214,7 @@ destroy_denom_key_pair (struct DenomKeyPair *dkp)
*/
static struct DenomKeyPair *
create_denom_key_pair (unsigned int size,
struct GNUNET_TIME_Timestamp now,
struct GNUNET_TIME_Absolute now,
const struct TALER_Amount *value,
const struct TALER_Amount *fee_withdraw,
const struct TALER_Amount *fee_deposit,
@ -237,24 +237,21 @@ create_denom_key_pair (unsigned int size,
0,
sizeof (struct TALER_EXCHANGEDB_DenominationKey));
dki.denom_pub = dkp->pub;
dki.issue.properties.start = GNUNET_TIME_timestamp_hton (now);
dki.issue.properties.expire_withdraw = GNUNET_TIME_timestamp_hton
(GNUNET_TIME_absolute_to_timestamp
(GNUNET_TIME_absolute_add (
now.abs_time,
GNUNET_TIME_UNIT_HOURS)));
dki.issue.properties.expire_deposit = GNUNET_TIME_timestamp_hton (
GNUNET_TIME_absolute_to_timestamp
(GNUNET_TIME_absolute_add
(now.abs_time,
GNUNET_TIME_relative_multiply (
GNUNET_TIME_UNIT_HOURS, 2))));
dki.issue.properties.expire_legal = GNUNET_TIME_timestamp_hton (
GNUNET_TIME_absolute_to_timestamp
(GNUNET_TIME_absolute_add
(now.abs_time,
GNUNET_TIME_relative_multiply (
GNUNET_TIME_UNIT_HOURS, 3))));
GNUNET_TIME_round_abs (&now);
dki.issue.properties.start = GNUNET_TIME_absolute_hton (now);
dki.issue.properties.expire_withdraw = GNUNET_TIME_absolute_hton
(GNUNET_TIME_absolute_add (now,
GNUNET_TIME_UNIT_HOURS));
dki.issue.properties.expire_deposit = GNUNET_TIME_absolute_hton
(GNUNET_TIME_absolute_add
(now,
GNUNET_TIME_relative_multiply (
GNUNET_TIME_UNIT_HOURS, 2)));
dki.issue.properties.expire_legal = GNUNET_TIME_absolute_hton
(GNUNET_TIME_absolute_add
(now,
GNUNET_TIME_relative_multiply (
GNUNET_TIME_UNIT_HOURS, 3)));
TALER_amount_hton (&dki.issue.properties.value, value);
TALER_amount_hton (&dki.issue.properties.fee_withdraw, fee_withdraw);
TALER_amount_hton (&dki.issue.properties.fee_deposit, fee_deposit);
@ -509,7 +506,7 @@ test_melting (void)
struct TALER_DenominationPublicKey *new_denom_pubs;
enum GNUNET_GenericReturnValue ret;
enum GNUNET_DB_QueryStatus qs;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
ret = GNUNET_SYSERR;
RND_BLK (&refresh_session);
@ -519,7 +516,8 @@ test_melting (void)
/* create and test a refresh session */
refresh_session.noreveal_index = MELT_NOREVEAL_INDEX;
/* create a denomination (value: 1; fraction: 100) */
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
GNUNET_TIME_round_abs (&now);
dkp = create_denom_key_pair (512,
now,
&value,
@ -616,9 +614,10 @@ test_melting (void)
for (unsigned int cnt = 0; cnt < MELT_NEW_COINS; cnt++)
{
struct TALER_EXCHANGEDB_RefreshRevealedCoin *ccoin;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
GNUNET_TIME_round_abs (&now);
new_dkp[cnt] = create_denom_key_pair (RSA_KEY_SIZE,
now,
&value,
@ -715,7 +714,7 @@ cb_wt_never (void *cls,
uint64_t serial_id,
const struct TALER_MerchantPublicKeyP *merchant_pub,
const char *account_payto_uri,
struct GNUNET_TIME_Timestamp exec_time,
struct GNUNET_TIME_Absolute exec_time,
const struct TALER_PrivateContractHash *h_contract_terms,
const struct TALER_DenominationPublicKey *denom_pub,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
@ -743,7 +742,7 @@ static struct TALER_CoinSpendPublicKeyP coin_pub_wt;
static struct TALER_Amount coin_value_wt;
static struct TALER_Amount coin_fee_wt;
static struct TALER_Amount transfer_value_wt;
static struct GNUNET_TIME_Timestamp wire_out_date;
static struct GNUNET_TIME_Absolute wire_out_date;
static struct TALER_WireTransferIdentifierRawP wire_out_wtid;
@ -755,7 +754,7 @@ cb_wt_check (void *cls,
uint64_t rowid,
const struct TALER_MerchantPublicKeyP *merchant_pub,
const char *account_payto_uri,
struct GNUNET_TIME_Timestamp exec_time,
struct GNUNET_TIME_Absolute exec_time,
const struct TALER_PrivateContractHash *h_contract_terms,
const struct TALER_DenominationPublicKey *denom_pub,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
@ -769,9 +768,7 @@ cb_wt_check (void *cls,
&merchant_pub_wt));
GNUNET_assert (0 == strcmp (account_payto_uri,
"payto://iban/DE67830654080004822650?receiver-name=Test"));
GNUNET_assert (GNUNET_TIME_timestamp_cmp (exec_time,
==,
wire_out_date));
GNUNET_assert (exec_time.abs_value_us == wire_out_date.abs_value_us);
GNUNET_assert (0 == GNUNET_memcmp (h_contract_terms,
&h_contract_terms_wt));
GNUNET_assert (0 == GNUNET_memcmp (coin_pub,
@ -904,7 +901,7 @@ matching_deposit_cb (void *cls,
static enum GNUNET_GenericReturnValue
audit_deposit_cb (void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp exchange_timestamp,
struct GNUNET_TIME_Absolute exchange_timestamp,
const struct TALER_EXCHANGEDB_Deposit *deposit,
const struct TALER_DenominationPublicKey *denom_pub,
bool done)
@ -980,7 +977,7 @@ audit_reserve_in_cb (void *cls,
const struct TALER_Amount *credit,
const char *sender_account_details,
uint64_t wire_reference,
struct GNUNET_TIME_Timestamp execution_date)
struct GNUNET_TIME_Absolute execution_date)
{
(void) cls;
(void) rowid;
@ -1014,7 +1011,7 @@ audit_reserve_out_cb (void *cls,
const struct TALER_DenominationPublicKey *denom_pub,
const struct TALER_ReservePublicKeyP *reserve_pub,
const struct TALER_ReserveSignatureP *reserve_sig,
struct GNUNET_TIME_Timestamp execution_date,
struct GNUNET_TIME_Absolute execution_date,
const struct TALER_Amount *amount_with_fee)
{
(void) cls;
@ -1039,17 +1036,17 @@ static enum GNUNET_GenericReturnValue
test_gc (void)
{
struct DenomKeyPair *dkp;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Timestamp past;
struct GNUNET_TIME_Absolute now;
struct GNUNET_TIME_Absolute past;
struct TALER_EXCHANGEDB_DenominationKeyInformationP issue2;
struct TALER_DenominationHash denom_hash;
now = GNUNET_TIME_timestamp_get ();
past = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_subtract (now.abs_time,
GNUNET_TIME_relative_multiply (
GNUNET_TIME_UNIT_HOURS,
4)));
now = GNUNET_TIME_absolute_get ();
GNUNET_TIME_round_abs (&now);
past = GNUNET_TIME_absolute_subtract (now,
GNUNET_TIME_relative_multiply (
GNUNET_TIME_UNIT_HOURS,
4));
dkp = create_denom_key_pair (RSA_KEY_SIZE,
past,
&value,
@ -1090,19 +1087,21 @@ test_gc (void)
static enum GNUNET_GenericReturnValue
test_wire_fees (void)
{
struct GNUNET_TIME_Timestamp start_date;
struct GNUNET_TIME_Timestamp end_date;
struct GNUNET_TIME_Absolute start_date;
struct GNUNET_TIME_Absolute end_date;
struct TALER_Amount wire_fee;
struct TALER_Amount closing_fee;
struct TALER_MasterSignatureP master_sig;
struct GNUNET_TIME_Timestamp sd;
struct GNUNET_TIME_Timestamp ed;
struct GNUNET_TIME_Absolute sd;
struct GNUNET_TIME_Absolute ed;
struct TALER_Amount fee;
struct TALER_Amount fee2;
struct TALER_MasterSignatureP ms;
start_date = GNUNET_TIME_timestamp_get ();
end_date = GNUNET_TIME_relative_to_timestamp (GNUNET_TIME_UNIT_MINUTES);
start_date = GNUNET_TIME_absolute_get ();
GNUNET_TIME_round_abs (&start_date);
end_date = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
GNUNET_TIME_round_abs (&end_date);
GNUNET_assert (GNUNET_OK ==
TALER_string_to_amount (CURRENCY ":1.424242",
&wire_fee));
@ -1164,12 +1163,8 @@ test_wire_fees (void)
GNUNET_break (0);
return GNUNET_SYSERR;
}
if ( (GNUNET_TIME_timestamp_cmp (sd,
!=,
start_date)) ||
(GNUNET_TIME_timestamp_cmp (ed,
!=,
end_date)) ||
if ( (sd.abs_value_us != start_date.abs_value_us) ||
(ed.abs_value_us != end_date.abs_value_us) ||
(0 != TALER_amount_cmp (&fee,
&wire_fee)) ||
(0 != TALER_amount_cmp (&fee2,
@ -1201,7 +1196,7 @@ static struct TALER_Amount wire_out_amount;
static enum GNUNET_GenericReturnValue
audit_wire_cb (void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp date,
struct GNUNET_TIME_Absolute date,
const struct TALER_WireTransferIdentifierRawP *wtid,
const char *payto_uri,
const struct TALER_Amount *amount)
@ -1216,9 +1211,7 @@ audit_wire_cb (void *cls,
GNUNET_assert (0 ==
GNUNET_memcmp (wtid,
&wire_out_wtid));
GNUNET_assert (GNUNET_TIME_timestamp_cmp (date,
==,
wire_out_date));
GNUNET_assert (date.abs_value_us == wire_out_date.abs_value_us);
return GNUNET_OK;
}
@ -1235,7 +1228,8 @@ test_wire_out (const struct TALER_EXCHANGEDB_Deposit *deposit)
memset (&wire_out_wtid,
42,
sizeof (wire_out_wtid));
wire_out_date = GNUNET_TIME_timestamp_get ();
wire_out_date = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&wire_out_date);
GNUNET_assert (GNUNET_OK ==
TALER_string_to_amount (CURRENCY ":1",
&wire_out_amount));
@ -1269,7 +1263,7 @@ test_wire_out (const struct TALER_EXCHANGEDB_Deposit *deposit)
struct TALER_WireTransferIdentifierRawP wtid2;
struct TALER_Amount coin_contribution2;
struct TALER_Amount coin_fee2;
struct GNUNET_TIME_Timestamp execution_time2;
struct GNUNET_TIME_Absolute execution_time2;
struct TALER_EXCHANGEDB_KycStatus kyc;
h_contract_terms_wt2.hash.bits[0]++;
@ -1327,7 +1321,7 @@ test_wire_out (const struct TALER_EXCHANGEDB_Deposit *deposit)
struct TALER_WireTransferIdentifierRawP wtid2;
struct TALER_Amount coin_contribution2;
struct TALER_Amount coin_fee2;
struct GNUNET_TIME_Timestamp execution_time2;
struct GNUNET_TIME_Absolute execution_time2;
struct TALER_EXCHANGEDB_KycStatus kyc;
FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
@ -1344,9 +1338,8 @@ test_wire_out (const struct TALER_EXCHANGEDB_Deposit *deposit)
&kyc));
GNUNET_assert (0 == GNUNET_memcmp (&wtid2,
&wire_out_wtid));
GNUNET_assert (GNUNET_TIME_timestamp_cmp (execution_time2,
==,
wire_out_date));
GNUNET_assert (execution_time2.abs_value_us ==
wire_out_date.abs_value_us);
GNUNET_assert (0 == TALER_amount_cmp (&coin_contribution2,
&coin_value_wt));
GNUNET_assert (0 == TALER_amount_cmp (&coin_fee2,
@ -1382,7 +1375,7 @@ drop:
static enum GNUNET_GenericReturnValue
recoup_cb (void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Absolute timestamp,
const struct TALER_Amount *amount,
const struct TALER_ReservePublicKeyP *reserve_pub,
const struct TALER_CoinPublicInfo *coin,
@ -1427,7 +1420,7 @@ wire_missing_cb (void *cls,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_Amount *amount,
const char *payto_uri,
struct GNUNET_TIME_Timestamp deadline,
struct GNUNET_TIME_Absolute deadline,
bool tiny,
bool done)
{
@ -1495,7 +1488,7 @@ run (void *cls)
{
struct GNUNET_CONFIGURATION_Handle *cfg = cls;
struct TALER_CoinSpendSignatureP coin_sig;
struct GNUNET_TIME_Timestamp deadline;
struct GNUNET_TIME_Absolute deadline;
union TALER_DenominationBlindingKeyP coin_blind;
struct TALER_ReservePublicKeyP reserve_pub;
struct TALER_ReservePublicKeyP reserve_pub2;
@ -1517,7 +1510,7 @@ run (void *cls)
unsigned int cnt;
uint64_t rr;
enum GNUNET_DB_QueryStatus qs;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
struct TALER_WireSalt salt;
union TALER_DenominationBlindingKeyP bks;
struct TALER_CoinPubHash c_hash;
@ -1581,7 +1574,8 @@ run (void *cls)
plugin->get_latest_reserve_in_reference (plugin->cls,
"exchange-account-1",
&rr));
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
plugin->reserves_in_insert (plugin->cls,
&reserve_pub,
@ -1600,7 +1594,8 @@ run (void *cls)
value.value,
value.fraction,
value.currency));
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
plugin->reserves_in_insert (plugin->cls,
&reserve_pub,
@ -1624,7 +1619,8 @@ run (void *cls)
value.fraction * 2,
value.currency));
result = 5;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
dkp = create_denom_key_pair (RSA_KEY_SIZE,
now,
&value,
@ -1731,7 +1727,9 @@ run (void *cls)
&cbc.sig,
&bks,
&dkp->pub));
deadline = GNUNET_TIME_timestamp_get ();
deadline = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&deadline);
FAILIF (TALER_EXCHANGEDB_CKS_ADDED !=
plugin->ensure_coin_known (plugin->cls,
&deposit.coin));
@ -1781,7 +1779,8 @@ run (void *cls)
GNUNET_assert (GNUNET_OK ==
TALER_string_to_amount (CURRENCY ":0.000010",
&fee_closing));
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
plugin->insert_reserve_closed (plugin->cls,
&reserve_pub,
@ -1918,11 +1917,12 @@ run (void *cls)
plugin->ensure_coin_known (plugin->cls,
&deposit.coin));
{
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Timestamp r;
struct GNUNET_TIME_Absolute now;
struct GNUNET_TIME_Absolute r;
struct TALER_Amount deposit_fee;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
GNUNET_TIME_round_abs (&now);
FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
plugin->insert_deposit (plugin->cls,
now,
@ -1932,20 +1932,16 @@ run (void *cls)
&deposit,
&deposit_fee,
&r));
FAILIF (GNUNET_TIME_timestamp_cmp (now,
!=,
r));
FAILIF (now.abs_value_us != r.abs_value_us);
}
{
struct GNUNET_TIME_Timestamp start_range;
struct GNUNET_TIME_Timestamp end_range;
struct GNUNET_TIME_Absolute start_range;
struct GNUNET_TIME_Absolute end_range;
start_range = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_subtract (deadline.abs_time,
GNUNET_TIME_UNIT_SECONDS));
end_range = GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_absolute_add (deadline.abs_time,
GNUNET_TIME_UNIT_SECONDS));
start_range = GNUNET_TIME_absolute_subtract (deadline,
GNUNET_TIME_UNIT_SECONDS);
end_range = GNUNET_TIME_absolute_add (deadline,
GNUNET_TIME_UNIT_SECONDS);
FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
plugin->select_deposits_missing_wire (plugin->cls,
start_range,
@ -2016,7 +2012,7 @@ run (void *cls)
"test-2"));
RND_BLK (&deposit2.merchant_pub); /* should fail if merchant is different */
{
struct GNUNET_TIME_Timestamp r;
struct GNUNET_TIME_Absolute r;
struct TALER_Amount deposit_fee;
FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
@ -2144,15 +2140,11 @@ run (void *cls)
FAILIF (0 !=
GNUNET_memcmp (&have->wire_salt,
&deposit.wire_salt));
FAILIF (GNUNET_TIME_timestamp_cmp (have->timestamp,
!=,
deposit.timestamp));
FAILIF (GNUNET_TIME_timestamp_cmp (have->refund_deadline,
!=,
deposit.refund_deadline));
FAILIF (GNUNET_TIME_timestamp_cmp (have->wire_deadline,
!=,
deposit.wire_deadline));
FAILIF (have->timestamp.abs_value_us != deposit.timestamp.abs_value_us);
FAILIF (have->refund_deadline.abs_value_us !=
deposit.refund_deadline.abs_value_us);
FAILIF (have->wire_deadline.abs_value_us !=
deposit.wire_deadline.abs_value_us);
FAILIF (0 != TALER_amount_cmp (&have->amount_with_fee,
&deposit.amount_with_fee));
FAILIF (0 != TALER_amount_cmp (&have->deposit_fee,

12
src/include/taler_auditor_service.h
View File

@ -259,18 +259,18 @@ TALER_AUDITOR_deposit_confirmation (
const struct TALER_MerchantWireHash *h_wire,
const struct TALER_ExtensionContractHash *h_extensions,
const struct TALER_PrivateContractHash *h_contract_terms,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Timestamp wire_deadline,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Absolute timestamp,
struct GNUNET_TIME_Absolute wire_deadline,
struct GNUNET_TIME_Absolute refund_deadline,
const struct TALER_Amount *amount_without_fee,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_MerchantPublicKeyP *merchant_pub,
const struct TALER_ExchangePublicKeyP *exchange_pub,
const struct TALER_ExchangeSignatureP *exchange_sig,
const struct TALER_MasterPublicKeyP *master_pub,
struct GNUNET_TIME_Timestamp ep_start,
struct GNUNET_TIME_Timestamp ep_expire,
struct GNUNET_TIME_Timestamp ep_end,
struct GNUNET_TIME_Absolute ep_start,
struct GNUNET_TIME_Absolute ep_expire,
struct GNUNET_TIME_Absolute ep_end,
const struct TALER_MasterSignatureP *master_sig,
TALER_AUDITOR_DepositConfirmationResultCallback cb,
void *cb_cls);

32
src/include/taler_auditordb_plugin.h
View File

@ -63,7 +63,7 @@ typedef enum GNUNET_GenericReturnValue
(*TALER_AUDITORDB_HistoricDenominationRevenueDataCallback)(
void *cls,
const struct TALER_DenominationHash *denom_pub_hash,
struct GNUNET_TIME_Timestamp revenue_timestamp,
struct GNUNET_TIME_Absolute revenue_timestamp,
const struct TALER_Amount *revenue_balance,
const struct TALER_Amount *loss_balance);
@ -84,8 +84,8 @@ typedef enum GNUNET_GenericReturnValue
typedef enum GNUNET_GenericReturnValue
(*TALER_AUDITORDB_HistoricReserveRevenueDataCallback)(
void *cls,
struct GNUNET_TIME_Timestamp start_time,
struct GNUNET_TIME_Timestamp end_time,
struct GNUNET_TIME_Absolute start_time,
struct GNUNET_TIME_Absolute end_time,
const struct TALER_Amount *reserve_profits);
@ -100,7 +100,7 @@ struct TALER_AUDITORDB_WireProgressPoint
* Time until which we have confirmed that all wire transactions
* that the exchange should do, have indeed been done.
*/
struct GNUNET_TIME_Timestamp last_timestamp;
struct GNUNET_TIME_Absolute last_timestamp;
/**
* reserves_close uuid until which we have checked
@ -240,17 +240,17 @@ struct TALER_AUDITORDB_ExchangeSigningKey
/**
* When does @e exchange_pub start to be used?
*/
struct GNUNET_TIME_Timestamp ep_start;
struct GNUNET_TIME_Absolute ep_start;
/**
* When will the exchange stop signing with @e exchange_pub?
*/
struct GNUNET_TIME_Timestamp ep_expire;
struct GNUNET_TIME_Absolute ep_expire;
/**
* When does the signing key expire (for legal disputes)?
*/
struct GNUNET_TIME_Timestamp ep_end;
struct GNUNET_TIME_Absolute ep_end;
/**
* What is the public offline signing key this is all about?
@ -289,7 +289,7 @@ struct TALER_AUDITORDB_DepositConfirmation
/**
* Time when this deposit confirmation was generated by the exchange.
*/
struct GNUNET_TIME_Timestamp exchange_timestamp;
struct GNUNET_TIME_Absolute exchange_timestamp;
/**
* How much time does the @e merchant have to issue a refund
@ -298,12 +298,12 @@ struct TALER_AUDITORDB_DepositConfirmation
* performed by the exchange until the refund deadline. This value
* is taken from the original deposit request.
*/
struct GNUNET_TIME_Timestamp refund_deadline;
struct GNUNET_TIME_Absolute refund_deadline;
/**
* How much time does the @e exchange have to wire the funds?
*/
struct GNUNET_TIME_Timestamp wire_deadline;
struct GNUNET_TIME_Absolute wire_deadline;
/**
* Amount to be deposited, excluding fee. Calculated from the
@ -872,7 +872,7 @@ struct TALER_AUDITORDB_Plugin
const struct TALER_MasterPublicKeyP *master_pub,
const struct TALER_Amount *reserve_balance,
const struct TALER_Amount *withdraw_fee_balance,
struct GNUNET_TIME_Timestamp expiration_date,
struct GNUNET_TIME_Absolute expiration_date,
const char *origin_account);
@ -895,7 +895,7 @@ struct TALER_AUDITORDB_Plugin
const struct TALER_MasterPublicKeyP *master_pub,
const struct TALER_Amount *reserve_balance,
const struct TALER_Amount *withdraw_fee_balance,
struct GNUNET_TIME_Timestamp expiration_date);
struct GNUNET_TIME_Absolute expiration_date);
/**
@ -919,7 +919,7 @@ struct TALER_AUDITORDB_Plugin
uint64_t *rowid,
struct TALER_Amount *reserve_balance,
struct TALER_Amount *withdraw_fee_balance,
struct GNUNET_TIME_Timestamp *expiration_date,
struct GNUNET_TIME_Absolute *expiration_date,
char **sender_account);
@ -1220,7 +1220,7 @@ struct TALER_AUDITORDB_Plugin
void *cls,
const struct TALER_MasterPublicKeyP *master_pub,
const struct TALER_DenominationHash *denom_pub_hash,
struct GNUNET_TIME_Timestamp revenue_timestamp,
struct GNUNET_TIME_Absolute revenue_timestamp,
const struct TALER_Amount *revenue_balance,
const struct TALER_Amount *recoup_loss_balance);
@ -1257,8 +1257,8 @@ struct TALER_AUDITORDB_Plugin
(*insert_historic_reserve_revenue)(
void *cls,
const struct TALER_MasterPublicKeyP *master_pub,
struct GNUNET_TIME_Timestamp start_time,
struct GNUNET_TIME_Timestamp end_time,
struct GNUNET_TIME_Absolute start_time,
struct GNUNET_TIME_Absolute end_time,
const struct TALER_Amount *reserve_profits);

45
src/include/taler_bank_service.h
View File

@ -112,13 +112,12 @@ struct TALER_BANK_AdminAddIncomingHandle;
* @param json detailed response from the HTTPD, or NULL if reply was not in JSON
*/
typedef void
(*TALER_BANK_AdminAddIncomingCallback) (
void *cls,
unsigned int http_status,
enum TALER_ErrorCode ec,
uint64_t serial_id,
struct GNUNET_TIME_Timestamp timestamp,
const json_t *json);
(*TALER_BANK_AdminAddIncomingCallback) (void *cls,
unsigned int http_status,
enum TALER_ErrorCode ec,
uint64_t serial_id,
struct GNUNET_TIME_Absolute timestamp,
const json_t *json);
/**
@ -200,12 +199,11 @@ struct TALER_BANK_TransferHandle;
* @param timestamp when did the transaction go into effect
*/
typedef void
(*TALER_BANK_TransferCallback)(
void *cls,
unsigned int response_code,
enum TALER_ErrorCode ec,
uint64_t row_id,
struct GNUNET_TIME_Timestamp timestamp);
(*TALER_BANK_TransferCallback)(void *cls,
unsigned int response_code,
enum TALER_ErrorCode ec,
uint64_t row_id,
struct GNUNET_TIME_Absolute timestamp);
/**
@ -268,7 +266,7 @@ struct TALER_BANK_CreditDetails
/**
* Time of the the transfer
*/
struct GNUNET_TIME_Timestamp execution_date;
struct GNUNET_TIME_Absolute execution_date;
/**
* Reserve public key encoded in the wire
@ -334,14 +332,13 @@ typedef enum GNUNET_GenericReturnValue
* In this case, the callback is not called.
*/
struct TALER_BANK_CreditHistoryHandle *
TALER_BANK_credit_history (
struct GNUNET_CURL_Context *ctx,
const struct TALER_BANK_AuthenticationData *auth,
uint64_t start_row,
int64_t num_results,
struct GNUNET_TIME_Relative timeout,
TALER_BANK_CreditHistoryCallback hres_cb,
void *hres_cb_cls);
TALER_BANK_credit_history (struct GNUNET_CURL_Context *ctx,
const struct TALER_BANK_AuthenticationData *auth,
uint64_t start_row,
int64_t num_results,
struct GNUNET_TIME_Relative timeout,
TALER_BANK_CreditHistoryCallback hres_cb,
void *hres_cb_cls);
/**
@ -377,7 +374,7 @@ struct TALER_BANK_DebitDetails
/**
* Time of the the transfer
*/
struct GNUNET_TIME_Timestamp execution_date;
struct GNUNET_TIME_Absolute execution_date;
/**
* Wire transfer identifier used by the exchange.
@ -480,7 +477,7 @@ TALER_BANK_debit_history_cancel (struct TALER_BANK_DebitHistoryHandle *hh);
* @param[out] auth set to the configuration data found
* @return #GNUNET_OK on success
*/
enum GNUNET_GenericReturnValue
int
TALER_BANK_auth_parse_cfg (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *section,
struct TALER_BANK_AuthenticationData *auth);

94
src/include/taler_crypto_lib.h
View File

@ -1367,7 +1367,7 @@ typedef void
(*TALER_CRYPTO_RsaDenominationKeyStatusCallback)(
void *cls,
const char *section_name,
struct GNUNET_TIME_Timestamp start_time,
struct GNUNET_TIME_Absolute start_time,
struct GNUNET_TIME_Relative validity_duration,
const struct TALER_RsaPubHashP *h_rsa,
const struct TALER_DenominationPublicKey *denom_pub,
@ -1484,7 +1484,7 @@ struct TALER_CRYPTO_ExchangeSignHelper;
typedef void
(*TALER_CRYPTO_ExchangeKeyStatusCallback)(
void *cls,
struct GNUNET_TIME_Timestamp start_time,
struct GNUNET_TIME_Absolute start_time,
struct GNUNET_TIME_Relative validity_duration,
const struct TALER_ExchangePublicKeyP *exchange_pub,
const struct TALER_SecurityModulePublicKeyP *sm_pub,
@ -1625,9 +1625,9 @@ TALER_exchange_deposit_confirm_verify (
const struct TALER_PrivateContractHash *h_contract_terms,
const struct TALER_MerchantWireHash *h_wire,
const struct TALER_ExtensionContractHash *h_extensions,
struct GNUNET_TIME_Timestamp exchange_timestamp,
struct GNUNET_TIME_Timestamp wire_deadline,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Absolute exchange_timestamp,
struct GNUNET_TIME_Absolute wire_deadline,
struct GNUNET_TIME_Absolute refund_deadline,
const struct TALER_Amount *amount_without_fee,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_MerchantPublicKeyP *merchant_pub,
@ -1661,9 +1661,9 @@ TALER_wallet_deposit_sign (
const struct TALER_PrivateContractHash *h_contract_terms,
const struct TALER_ExtensionContractHash *h_extensions,
const struct TALER_DenominationHash *h_denom_pub,
struct GNUNET_TIME_Timestamp wallet_timestamp,
struct GNUNET_TIME_Absolute wallet_timestamp,
const struct TALER_MerchantPublicKeyP *merchant_pub,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Absolute refund_deadline,
const struct TALER_CoinSpendPrivateKeyP *coin_priv,
struct TALER_CoinSpendSignatureP *coin_sig);
@ -1692,9 +1692,9 @@ TALER_wallet_deposit_verify (
const struct TALER_PrivateContractHash *h_contract_terms,
const struct TALER_ExtensionContractHash *h_extensions,
const struct TALER_DenominationHash *h_denom_pub,
struct GNUNET_TIME_Timestamp wallet_timestamp,
struct GNUNET_TIME_Absolute wallet_timestamp,
const struct TALER_MerchantPublicKeyP *merchant_pub,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Absolute refund_deadline,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_CoinSpendSignatureP *coin_sig);
@ -1754,7 +1754,7 @@ void
TALER_exchange_offline_auditor_add_sign (
const struct TALER_AuditorPublicKeyP *auditor_pub,
const char *auditor_url,
struct GNUNET_TIME_Timestamp start_date,
struct GNUNET_TIME_Absolute start_date,
const struct TALER_MasterPrivateKeyP *master_priv,
struct TALER_MasterSignatureP *master_sig);
@ -1773,7 +1773,7 @@ enum GNUNET_GenericReturnValue
TALER_exchange_offline_auditor_add_verify (
const struct TALER_AuditorPublicKeyP *auditor_pub,
const char *auditor_url,
struct GNUNET_TIME_Timestamp start_date,
struct GNUNET_TIME_Absolute start_date,
const struct TALER_MasterPublicKeyP *master_pub,
const struct TALER_MasterSignatureP *master_sig);
@ -1789,7 +1789,7 @@ TALER_exchange_offline_auditor_add_verify (
void
TALER_exchange_offline_auditor_del_sign (
const struct TALER_AuditorPublicKeyP *auditor_pub,
struct GNUNET_TIME_Timestamp end_date,
struct GNUNET_TIME_Absolute end_date,
const struct TALER_MasterPrivateKeyP *master_priv,
struct TALER_MasterSignatureP *master_sig);
@ -1806,7 +1806,7 @@ TALER_exchange_offline_auditor_del_sign (
enum GNUNET_GenericReturnValue
TALER_exchange_offline_auditor_del_verify (
const struct TALER_AuditorPublicKeyP *auditor_pub,
struct GNUNET_TIME_Timestamp end_date,
struct GNUNET_TIME_Absolute end_date,
const struct TALER_MasterPublicKeyP *master_pub,
const struct TALER_MasterSignatureP *master_sig);
@ -1882,9 +1882,9 @@ TALER_exchange_offline_signkey_revoke_verify (
void
TALER_exchange_offline_signkey_validity_sign (
const struct TALER_ExchangePublicKeyP *exchange_pub,
struct GNUNET_TIME_Timestamp start_sign,
struct GNUNET_TIME_Timestamp end_sign,
struct GNUNET_TIME_Timestamp end_legal,
struct GNUNET_TIME_Absolute start_sign,
struct GNUNET_TIME_Absolute end_sign,
struct GNUNET_TIME_Absolute end_legal,
const struct TALER_MasterPrivateKeyP *master_priv,
struct TALER_MasterSignatureP *master_sig);
@ -1903,9 +1903,9 @@ TALER_exchange_offline_signkey_validity_sign (
enum GNUNET_GenericReturnValue
TALER_exchange_offline_signkey_validity_verify (
const struct TALER_ExchangePublicKeyP *exchange_pub,
struct GNUNET_TIME_Timestamp start_sign,
struct GNUNET_TIME_Timestamp end_sign,
struct GNUNET_TIME_Timestamp end_legal,
struct GNUNET_TIME_Absolute start_sign,
struct GNUNET_TIME_Absolute end_sign,
struct GNUNET_TIME_Absolute end_legal,
const struct TALER_MasterPublicKeyP *master_pub,
const struct TALER_MasterSignatureP *master_sig);
@ -1929,10 +1929,10 @@ TALER_exchange_offline_signkey_validity_verify (
void
TALER_exchange_offline_denom_validity_sign (
const struct TALER_DenominationHash *h_denom_pub,
struct GNUNET_TIME_Timestamp stamp_start,
struct GNUNET_TIME_Timestamp stamp_expire_withdraw,
struct GNUNET_TIME_Timestamp stamp_expire_deposit,
struct GNUNET_TIME_Timestamp stamp_expire_legal,
struct GNUNET_TIME_Absolute stamp_start,
struct GNUNET_TIME_Absolute stamp_expire_withdraw,
struct GNUNET_TIME_Absolute stamp_expire_deposit,
struct GNUNET_TIME_Absolute stamp_expire_legal,
const struct TALER_Amount *coin_value,
const struct TALER_Amount *fee_withdraw,
const struct TALER_Amount *fee_deposit,
@ -1962,10 +1962,10 @@ TALER_exchange_offline_denom_validity_sign (
enum GNUNET_GenericReturnValue
TALER_exchange_offline_denom_validity_verify (
const struct TALER_DenominationHash *h_denom_pub,
struct GNUNET_TIME_Timestamp stamp_start,
struct GNUNET_TIME_Timestamp stamp_expire_withdraw,
struct GNUNET_TIME_Timestamp stamp_expire_deposit,
struct GNUNET_TIME_Timestamp stamp_expire_legal,
struct GNUNET_TIME_Absolute stamp_start,
struct GNUNET_TIME_Absolute stamp_expire_withdraw,
struct GNUNET_TIME_Absolute stamp_expire_deposit,
struct GNUNET_TIME_Absolute stamp_expire_legal,
const struct TALER_Amount *coin_value,
const struct TALER_Amount *fee_withdraw,
const struct TALER_Amount *fee_deposit,
@ -1987,7 +1987,7 @@ TALER_exchange_offline_denom_validity_verify (
void
TALER_exchange_secmod_eddsa_sign (
const struct TALER_ExchangePublicKeyP *exchange_pub,
struct GNUNET_TIME_Timestamp start_sign,
struct GNUNET_TIME_Absolute start_sign,
struct GNUNET_TIME_Relative duration,
const struct TALER_SecurityModulePrivateKeyP *secm_priv,
struct TALER_SecurityModuleSignatureP *secm_sig);
@ -2006,7 +2006,7 @@ TALER_exchange_secmod_eddsa_sign (
enum GNUNET_GenericReturnValue
TALER_exchange_secmod_eddsa_verify (
const struct TALER_ExchangePublicKeyP *exchange_pub,
struct GNUNET_TIME_Timestamp start_sign,
struct GNUNET_TIME_Absolute start_sign,
struct GNUNET_TIME_Relative duration,
const struct TALER_SecurityModulePublicKeyP *secm_pub,
const struct TALER_SecurityModuleSignatureP *secm_sig);
@ -2026,7 +2026,7 @@ void
TALER_exchange_secmod_rsa_sign (
const struct TALER_RsaPubHashP *h_rsa,
const char *section_name,
struct GNUNET_TIME_Timestamp start_sign,
struct GNUNET_TIME_Absolute start_sign,
struct GNUNET_TIME_Relative duration,
const struct TALER_SecurityModulePrivateKeyP *secm_priv,
struct TALER_SecurityModuleSignatureP *secm_sig);
@ -2047,7 +2047,7 @@ enum GNUNET_GenericReturnValue
TALER_exchange_secmod_rsa_verify (
const struct TALER_RsaPubHashP *h_rsa,
const char *section_name,
struct GNUNET_TIME_Timestamp start_sign,
struct GNUNET_TIME_Absolute start_sign,
struct GNUNET_TIME_Relative duration,
const struct TALER_SecurityModulePublicKeyP *secm_pub,
const struct TALER_SecurityModuleSignatureP *secm_sig);
@ -2076,10 +2076,10 @@ TALER_auditor_denom_validity_sign (
const char *auditor_url,
const struct TALER_DenominationHash *h_denom_pub,
const struct TALER_MasterPublicKeyP *master_pub,
struct GNUNET_TIME_Timestamp stamp_start,
struct GNUNET_TIME_Timestamp stamp_expire_withdraw,
struct GNUNET_TIME_Timestamp stamp_expire_deposit,
struct GNUNET_TIME_Timestamp stamp_expire_legal,
struct GNUNET_TIME_Absolute stamp_start,
struct GNUNET_TIME_Absolute stamp_expire_withdraw,
struct GNUNET_TIME_Absolute stamp_expire_deposit,
struct GNUNET_TIME_Absolute stamp_expire_legal,
const struct TALER_Amount *coin_value,
const struct TALER_Amount *fee_withdraw,
const struct TALER_Amount *fee_deposit,
@ -2113,10 +2113,10 @@ TALER_auditor_denom_validity_verify (
const char *auditor_url,
const struct TALER_DenominationHash *h_denom_pub,
const struct TALER_MasterPublicKeyP *master_pub,
struct GNUNET_TIME_Timestamp stamp_start,
struct GNUNET_TIME_Timestamp stamp_expire_withdraw,
struct GNUNET_TIME_Timestamp stamp_expire_deposit,
struct GNUNET_TIME_Timestamp stamp_expire_legal,
struct GNUNET_TIME_Absolute stamp_start,
struct GNUNET_TIME_Absolute stamp_expire_withdraw,
struct GNUNET_TIME_Absolute stamp_expire_deposit,
struct GNUNET_TIME_Absolute stamp_expire_legal,
const struct TALER_Amount *coin_value,
const struct TALER_Amount *fee_withdraw,
const struct TALER_Amount *fee_deposit,
@ -2143,8 +2143,8 @@ TALER_auditor_denom_validity_verify (
void
TALER_exchange_offline_wire_fee_sign (
const char *payment_method,
struct GNUNET_TIME_Timestamp start_time,
struct GNUNET_TIME_Timestamp end_time,
struct GNUNET_TIME_Absolute start_time,
struct GNUNET_TIME_Absolute end_time,
const struct TALER_Amount *wire_fee,
const struct TALER_Amount *closing_fee,
const struct TALER_MasterPrivateKeyP *master_priv,
@ -2166,8 +2166,8 @@ TALER_exchange_offline_wire_fee_sign (
enum GNUNET_GenericReturnValue
TALER_exchange_offline_wire_fee_verify (
const char *payment_method,
struct GNUNET_TIME_Timestamp start_time,
struct GNUNET_TIME_Timestamp end_time,
struct GNUNET_TIME_Absolute start_time,
struct GNUNET_TIME_Absolute end_time,
const struct TALER_Amount *wire_fee,
const struct TALER_Amount *closing_fee,
const struct TALER_MasterPublicKeyP *master_pub,
@ -2185,7 +2185,7 @@ TALER_exchange_offline_wire_fee_verify (
void
TALER_exchange_offline_wire_add_sign (
const char *payto_uri,
struct GNUNET_TIME_Timestamp now,
struct GNUNET_TIME_Absolute now,
const struct TALER_MasterPrivateKeyP *master_priv,
struct TALER_MasterSignatureP *master_sig);
@ -2202,7 +2202,7 @@ TALER_exchange_offline_wire_add_sign (
enum GNUNET_GenericReturnValue
TALER_exchange_offline_wire_add_verify (
const char *payto_uri,
struct GNUNET_TIME_Timestamp sign_time,
struct GNUNET_TIME_Absolute sign_time,
const struct TALER_MasterPublicKeyP *master_pub,
const struct TALER_MasterSignatureP *master_sig);
@ -2218,7 +2218,7 @@ TALER_exchange_offline_wire_add_verify (
void
TALER_exchange_offline_wire_del_sign (
const char *payto_uri,
struct GNUNET_TIME_Timestamp now,
struct GNUNET_TIME_Absolute now,
const struct TALER_MasterPrivateKeyP *master_priv,
struct TALER_MasterSignatureP *master_sig);
@ -2235,7 +2235,7 @@ TALER_exchange_offline_wire_del_sign (
enum GNUNET_GenericReturnValue
TALER_exchange_offline_wire_del_verify (
const char *payto_uri,
struct GNUNET_TIME_Timestamp sign_time,
struct GNUNET_TIME_Absolute sign_time,
const struct TALER_MasterPublicKeyP *master_pub,
const struct TALER_MasterSignatureP *master_sig);

80
src/include/taler_exchange_service.h
View File

@ -70,17 +70,17 @@ struct TALER_EXCHANGE_SigningPublicKey
/**
* Validity start time
*/
struct GNUNET_TIME_Timestamp valid_from;
struct GNUNET_TIME_Absolute valid_from;
/**
* Validity expiration time (how long the exchange may use it).
*/
struct GNUNET_TIME_Timestamp valid_until;
struct GNUNET_TIME_Absolute valid_until;
/**
* Validity expiration time for legal disputes.
*/
struct GNUNET_TIME_Timestamp valid_legal;
struct GNUNET_TIME_Absolute valid_legal;
};
@ -107,18 +107,18 @@ struct TALER_EXCHANGE_DenomPublicKey
/**
* Timestamp indicating when the denomination key becomes valid
*/
struct GNUNET_TIME_Timestamp valid_from;
struct GNUNET_TIME_Absolute valid_from;
/**
* Timestamp indicating when the denomination key can’t be used anymore to
* withdraw new coins.
*/
struct GNUNET_TIME_Timestamp withdraw_valid_until;
struct GNUNET_TIME_Absolute withdraw_valid_until;
/**
* Timestamp indicating when coins of this denomination become invalid.
*/
struct GNUNET_TIME_Timestamp expire_deposit;
struct GNUNET_TIME_Absolute expire_deposit;
/**
* When do signatures with this denomination key become invalid?
@ -127,7 +127,7 @@ struct TALER_EXCHANGE_DenomPublicKey
* of the evidence. @e expire_legal is expected to be significantly
* larger than @e expire_deposit (by a year or more).
*/
struct GNUNET_TIME_Timestamp expire_legal;
struct GNUNET_TIME_Absolute expire_legal;
/**
* The value of this denomination
@ -273,14 +273,14 @@ struct TALER_EXCHANGE_Keys
/**
* Timestamp indicating the /keys generation.
*/
struct GNUNET_TIME_Timestamp list_issue_date;
struct GNUNET_TIME_Absolute list_issue_date;
/**
* Timestamp indicating the creation time of the last
* denomination key in /keys.
* Used to fetch /keys incrementally.
*/
struct GNUNET_TIME_Timestamp last_denom_issue_date;
struct GNUNET_TIME_Absolute last_denom_issue_date;
/**
* Length of the @e sign_keys array (number of valid entries).
@ -491,7 +491,7 @@ TALER_EXCHANGE_get_keys (struct TALER_EXCHANGE_Handle *exchange);
*/
void
TALER_EXCHANGE_set_last_denom (struct TALER_EXCHANGE_Handle *exchange,
struct GNUNET_TIME_Timestamp last_denom_new);
struct GNUNET_TIME_Absolute last_denom_new);
/**
@ -535,7 +535,7 @@ enum TALER_EXCHANGE_CheckKeysFlags
* @param flags options controlling when to download what
* @return until when the existing response is current, 0 if we are re-downloading now
*/
struct GNUNET_TIME_Timestamp
struct GNUNET_TIME_Absolute
TALER_EXCHANGE_check_keys_current (struct TALER_EXCHANGE_Handle *exchange,
enum TALER_EXCHANGE_CheckKeysFlags flags);
@ -663,12 +663,12 @@ struct TALER_EXCHANGE_WireAggregateFees
/**
* Time when this fee goes into effect (inclusive)
*/
struct GNUNET_TIME_Timestamp start_date;
struct GNUNET_TIME_Absolute start_date;
/**
* Time when this fee stops being in effect (exclusive).
*/
struct GNUNET_TIME_Timestamp end_date;
struct GNUNET_TIME_Absolute end_date;
/**
* Signature affirming the above fee structure.
@ -789,9 +789,9 @@ TALER_EXCHANGE_deposit_permission_sign (
const struct TALER_ExtensionContractHash *h_extensions,
const struct TALER_DenominationHash *h_denom_pub,
const struct TALER_CoinSpendPrivateKeyP *coin_priv,
struct GNUNET_TIME_Timestamp wallet_timestamp,
struct GNUNET_TIME_Absolute wallet_timestamp,
const struct TALER_MerchantPublicKeyP *merchant_pub,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Absolute refund_deadline,
struct TALER_CoinSpendSignatureP *coin_sig);
@ -824,7 +824,7 @@ struct TALER_EXCHANGE_DepositResult
/**
* Time when the exchange generated the deposit confirmation
*/
struct GNUNET_TIME_Timestamp deposit_timestamp;
struct GNUNET_TIME_Absolute deposit_timestamp;
/**
* signature provided by the exchange
@ -910,7 +910,7 @@ struct TALER_EXCHANGE_DepositHandle *
TALER_EXCHANGE_deposit (
struct TALER_EXCHANGE_Handle *exchange,
const struct TALER_Amount *amount,
struct GNUNET_TIME_Timestamp wire_deadline,
struct GNUNET_TIME_Absolute wire_deadline,
const char *merchant_payto_uri,
const struct TALER_WireSalt *wire_salt,
const struct TALER_PrivateContractHash *h_contract_terms,
@ -918,9 +918,9 @@ TALER_EXCHANGE_deposit (
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_DenominationSignature *denom_sig,
const struct TALER_DenominationPublicKey *denom_pub,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Absolute timestamp,
const struct TALER_MerchantPublicKeyP *merchant_pub,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Absolute refund_deadline,
const struct TALER_CoinSpendSignatureP *coin_sig,
TALER_EXCHANGE_DepositResultCallback cb,
void *cb_cls,
@ -1102,7 +1102,7 @@ struct TALER_EXCHANGE_ReserveHistory
/**
* When did the wire transfer happen?
*/
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
} in_details;
@ -1149,7 +1149,7 @@ struct TALER_EXCHANGE_ReserveHistory
/**
* When did the /recoup operation happen?
*/
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
} recoup_details;
@ -1183,7 +1183,7 @@ struct TALER_EXCHANGE_ReserveHistory
/**
* When did the wire transfer happen?
*/
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
/**
* Fee that was charged for the closing.
@ -1716,7 +1716,7 @@ struct TALER_EXCHANGE_TransferData
/**
* time when the exchange claims to have performed the wire transfer
*/
struct GNUNET_TIME_Timestamp execution_time;
struct GNUNET_TIME_Absolute execution_time;
/**
* Actual amount of the wire transfer, excluding the wire fee.
@ -1837,7 +1837,7 @@ struct TALER_EXCHANGE_GetDepositResponse
/**
* actual execution time for the wire transfer
*/
struct GNUNET_TIME_Timestamp execution_time;
struct GNUNET_TIME_Absolute execution_time;
/**
* contribution to the total amount by this coin, all zeros if exchange did not
@ -1861,7 +1861,7 @@ struct TALER_EXCHANGE_GetDepositResponse
/**
* planned execution time for the wire transfer
*/
struct GNUNET_TIME_Timestamp execution_time;
struct GNUNET_TIME_Absolute execution_time;
/**
* Payment target that the merchant should use
@ -2029,7 +2029,6 @@ typedef void
* @param pk kind of coin to pay back
* @param denom_sig signature over the coin by the exchange using @a pk
* @param ps secret internals of the original planchet
* @param amount value remaining on the coin that is being recouped
* @param was_refreshed true if the coin in @a ps was refreshed
* @param recoup_cb the callback to call when the final result for this request is available
* @param recoup_cb_cls closure for @a recoup_cb
@ -2042,7 +2041,6 @@ TALER_EXCHANGE_recoup (struct TALER_EXCHANGE_Handle *exchange,
const struct TALER_EXCHANGE_DenomPublicKey *pk,
const struct TALER_DenominationSignature *denom_sig,
const struct TALER_PlanchetSecretsP *ps,
const struct TALER_Amount *amount,
bool was_refreshed,
TALER_EXCHANGE_RecoupResultCallback recoup_cb,
void *recoup_cb_cls);
@ -2093,7 +2091,7 @@ struct TALER_EXCHANGE_KycStatus
/**
* Time of the affirmation.
*/
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
/**
* The signing public key used for @e exchange_sig.
@ -2329,17 +2327,17 @@ struct TALER_EXCHANGE_FutureSigningPublicKey
/**
* Validity start time
*/
struct GNUNET_TIME_Timestamp valid_from;
struct GNUNET_TIME_Absolute valid_from;
/**
* Validity expiration time (how long the exchange may use it).
*/
struct GNUNET_TIME_Timestamp valid_until;
struct GNUNET_TIME_Absolute valid_until;
/**
* Validity expiration time for legal disputes.
*/
struct GNUNET_TIME_Timestamp valid_legal;
struct GNUNET_TIME_Absolute valid_legal;
};
@ -2361,18 +2359,18 @@ struct TALER_EXCHANGE_FutureDenomPublicKey
/**
* Timestamp indicating when the denomination key becomes valid
*/
struct GNUNET_TIME_Timestamp valid_from;
struct GNUNET_TIME_Absolute valid_from;
/**
* Timestamp indicating when the denomination key can’t be used anymore to
* withdraw new coins.
*/
struct GNUNET_TIME_Timestamp withdraw_valid_until;
struct GNUNET_TIME_Absolute withdraw_valid_until;
/**
* Timestamp indicating when coins of this denomination become invalid.
*/
struct GNUNET_TIME_Timestamp expire_deposit;
struct GNUNET_TIME_Absolute expire_deposit;
/**
* When do signatures with this denomination key become invalid?
@ -2381,7 +2379,7 @@ struct TALER_EXCHANGE_FutureDenomPublicKey
* of the evidence. @e expire_legal is expected to be significantly
* larger than @e expire_deposit (by a year or more).
*/
struct GNUNET_TIME_Timestamp expire_legal;
struct GNUNET_TIME_Absolute expire_legal;
/**
* The value of this denomination
@ -2808,7 +2806,7 @@ TALER_EXCHANGE_management_enable_auditor (
const struct TALER_AuditorPublicKeyP *auditor_pub,
const char *auditor_url,
const char *auditor_name,
struct GNUNET_TIME_Timestamp validity_start,
struct GNUNET_TIME_Absolute validity_start,
const struct TALER_MasterSignatureP *master_sig,
TALER_EXCHANGE_ManagementAuditorEnableCallback cb,
void *cb_cls);
@ -2859,7 +2857,7 @@ TALER_EXCHANGE_management_disable_auditor (
struct GNUNET_CURL_Context *ctx,
const char *url,
const struct TALER_AuditorPublicKeyP *auditor_pub,
struct GNUNET_TIME_Timestamp validity_end,
struct GNUNET_TIME_Absolute validity_end,
const struct TALER_MasterSignatureP *master_sig,
TALER_EXCHANGE_ManagementAuditorDisableCallback cb,
void *cb_cls);
@ -2913,7 +2911,7 @@ TALER_EXCHANGE_management_enable_wire (
struct GNUNET_CURL_Context *ctx,
const char *url,
const char *payto_uri,
struct GNUNET_TIME_Timestamp validity_start,
struct GNUNET_TIME_Absolute validity_start,
const struct TALER_MasterSignatureP *master_sig1,
const struct TALER_MasterSignatureP *master_sig2,
TALER_EXCHANGE_ManagementWireEnableCallback cb,
@ -2966,7 +2964,7 @@ TALER_EXCHANGE_management_disable_wire (
struct GNUNET_CURL_Context *ctx,
const char *url,
const char *payto_uri,
struct GNUNET_TIME_Timestamp validity_end,
struct GNUNET_TIME_Absolute validity_end,
const struct TALER_MasterSignatureP *master_sig,
TALER_EXCHANGE_ManagementWireDisableCallback cb,
void *cb_cls);
@ -3021,8 +3019,8 @@ TALER_EXCHANGE_management_set_wire_fees (
struct GNUNET_CURL_Context *ctx,
const char *exchange_base_url,
const char *wire_method,
struct GNUNET_TIME_Timestamp validity_start,
struct GNUNET_TIME_Timestamp validity_end,
struct GNUNET_TIME_Absolute validity_start,
struct GNUNET_TIME_Absolute validity_end,
const struct TALER_Amount *wire_fee,
const struct TALER_Amount *closing_fee,
const struct TALER_MasterSignatureP *master_sig,

156
src/include/taler_exchangedb_plugin.h
View File

@ -117,12 +117,12 @@ struct TALER_EXCHANGEDB_SignkeyMetaData
/**
* Start time of the validity period for this key.
*/
struct GNUNET_TIME_Timestamp start;
struct GNUNET_TIME_Absolute start;
/**
* The exchange will sign messages with this key between @e start and this time.
*/
struct GNUNET_TIME_Timestamp expire_sign;
struct GNUNET_TIME_Absolute expire_sign;
/**
* When do signatures with this sign key become invalid?
@ -131,7 +131,7 @@ struct TALER_EXCHANGEDB_SignkeyMetaData
* of the evidence. @e expire_legal is expected to be significantly
* larger than @e expire_sign (by a year or more).
*/
struct GNUNET_TIME_Timestamp expire_legal;
struct GNUNET_TIME_Absolute expire_legal;
};
@ -197,10 +197,10 @@ struct TALER_EXCHANGEDB_TableData
uint32_t age_restrictions;
struct TALER_DenominationPublicKey denom_pub;
struct TALER_MasterSignatureP master_sig;
struct GNUNET_TIME_Timestamp valid_from;
struct GNUNET_TIME_Timestamp expire_withdraw;
struct GNUNET_TIME_Timestamp expire_deposit;
struct GNUNET_TIME_Timestamp expire_legal;
struct GNUNET_TIME_Absolute valid_from;
struct GNUNET_TIME_Absolute expire_withdraw;
struct GNUNET_TIME_Absolute expire_deposit;
struct GNUNET_TIME_Absolute expire_legal;
struct TALER_Amount coin;
struct TALER_Amount fee_withdraw;
struct TALER_Amount fee_deposit;
@ -228,8 +228,8 @@ struct TALER_EXCHANGEDB_TableData
* Note: not useful for auditor, because not UPDATEd!
*/
struct TALER_Amount current_balance;
struct GNUNET_TIME_Timestamp expiration_date;
struct GNUNET_TIME_Timestamp gc_date;
struct GNUNET_TIME_Absolute expiration_date;
struct GNUNET_TIME_Absolute gc_date;
} reserves;
struct
@ -238,14 +238,14 @@ struct TALER_EXCHANGEDB_TableData
struct TALER_Amount credit;
uint64_t sender_account;
char *exchange_account_section;
struct GNUNET_TIME_Timestamp execution_date;
struct GNUNET_TIME_Absolute execution_date;
uint64_t reserve_uuid;
} reserves_in;
struct
{
uint64_t reserve_uuid;
struct GNUNET_TIME_Timestamp execution_date;
struct GNUNET_TIME_Absolute execution_date;
struct TALER_WireTransferIdentifierRawP wtid;
uint64_t wire_target_serial_id;
struct TALER_Amount amount;
@ -259,7 +259,7 @@ struct TALER_EXCHANGEDB_TableData
struct TALER_BlindedDenominationSignature denom_sig;
uint64_t reserve_uuid;
struct TALER_ReserveSignatureP reserve_sig;
struct GNUNET_TIME_Timestamp execution_date;
struct GNUNET_TIME_Absolute execution_date;
struct TALER_Amount amount_with_fee;
} reserves_out;
@ -269,7 +269,7 @@ struct TALER_EXCHANGEDB_TableData
char *auditor_url;
char *auditor_name;
bool is_active;
struct GNUNET_TIME_Timestamp last_change;
struct GNUNET_TIME_Absolute last_change;
} auditors;
struct
@ -333,10 +333,10 @@ struct TALER_EXCHANGEDB_TableData
uint64_t shard;
uint64_t known_coin_id;
struct TALER_Amount amount_with_fee;
struct GNUNET_TIME_Timestamp wallet_timestamp;
struct GNUNET_TIME_Timestamp exchange_timestamp;
struct GNUNET_TIME_Timestamp refund_deadline;
struct GNUNET_TIME_Timestamp wire_deadline;
struct GNUNET_TIME_Absolute wallet_timestamp;
struct GNUNET_TIME_Absolute exchange_timestamp;
struct GNUNET_TIME_Absolute refund_deadline;
struct GNUNET_TIME_Absolute wire_deadline;
struct TALER_MerchantPublicKeyP merchant_pub;
struct TALER_PrivateContractHash h_contract_terms;
struct TALER_CoinSpendSignatureP coin_sig;
@ -358,7 +358,7 @@ struct TALER_EXCHANGEDB_TableData
struct
{
struct GNUNET_TIME_Timestamp execution_date;
struct GNUNET_TIME_Absolute execution_date;
struct TALER_WireTransferIdentifierRawP wtid_raw;
uint64_t wire_target_serial_id;
char *exchange_account_section;
@ -374,8 +374,8 @@ struct TALER_EXCHANGEDB_TableData
struct
{
char *wire_method;
struct GNUNET_TIME_Timestamp start_date;
struct GNUNET_TIME_Timestamp end_date;
struct GNUNET_TIME_Absolute start_date;
struct GNUNET_TIME_Absolute end_date;
struct TALER_Amount wire_fee;
struct TALER_Amount closing_fee;
struct TALER_MasterSignatureP master_sig;
@ -387,7 +387,7 @@ struct TALER_EXCHANGEDB_TableData
struct TALER_CoinSpendSignatureP coin_sig;
union TALER_DenominationBlindingKeyP coin_blind;
struct TALER_Amount amount;
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
uint64_t reserve_out_serial_id;
} recoup;
@ -397,7 +397,7 @@ struct TALER_EXCHANGEDB_TableData
struct TALER_CoinSpendSignatureP coin_sig;
union TALER_DenominationBlindingKeyP coin_blind;
struct TALER_Amount amount;
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
uint64_t rrc_serial;
} recoup_refresh;
@ -467,7 +467,7 @@ struct TALER_EXCHANGEDB_BankTransfer
* (This is the execution date of the exchange's database,
* the execution date of the bank should be in @e wire).
*/
struct GNUNET_TIME_Timestamp execution_date;
struct GNUNET_TIME_Absolute execution_date;
/**
* Detailed wire information about the sending account
@ -508,7 +508,7 @@ struct TALER_EXCHANGEDB_ClosingTransfer
/**
* When did the exchange execute the transaction?
*/
struct GNUNET_TIME_Timestamp execution_date;
struct GNUNET_TIME_Absolute execution_date;
/**
* Detailed wire information about the receiving account
@ -544,13 +544,13 @@ struct TALER_EXCHANGEDB_Reserve
* The expiration date of this reserve; funds will be wired back
* at this time.
*/
struct GNUNET_TIME_Timestamp expiry;
struct GNUNET_TIME_Absolute expiry;
/**
* The legal expiration date of this reserve; we will forget about
* it at this time.
*/
struct GNUNET_TIME_Timestamp gc;
struct GNUNET_TIME_Absolute gc;
};
@ -562,7 +562,7 @@ struct TALER_EXCHANGEDB_DenominationKeyMetaData
/**
* Start time of the validity period for this key.
*/
struct GNUNET_TIME_Timestamp start;
struct GNUNET_TIME_Absolute start;
/**
* The exchange will sign fresh coins between @e start and this time.
@ -576,7 +576,7 @@ struct TALER_EXCHANGEDB_DenominationKeyMetaData
* with the same value with overlapping validity periods, to address
* issues such as clock skew.
*/
struct GNUNET_TIME_Timestamp expire_withdraw;
struct GNUNET_TIME_Absolute expire_withdraw;
/**
* Coins signed with the denomination key must be spent or refreshed
@ -588,7 +588,7 @@ struct TALER_EXCHANGEDB_DenominationKeyMetaData
* significantly larger than @e expire_withdraw (by months or even
* years).
*/
struct GNUNET_TIME_Timestamp expire_deposit;
struct GNUNET_TIME_Absolute expire_deposit;
/**
* When do signatures with this denomination key become invalid?
@ -597,7 +597,7 @@ struct TALER_EXCHANGEDB_DenominationKeyMetaData
* of the evidence. @e expire_legal is expected to be significantly
* larger than @e expire_deposit (by a year or more).
*/
struct GNUNET_TIME_Timestamp expire_legal;
struct GNUNET_TIME_Absolute expire_legal;
/**
* The value of the coins signed with this denomination key.
@ -815,7 +815,7 @@ struct TALER_EXCHANGEDB_Recoup
/**
* When did the recoup operation happen?
*/
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
};
@ -857,7 +857,7 @@ struct TALER_EXCHANGEDB_RecoupListEntry
/**
* When did the /recoup operation happen?
*/
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
};
@ -900,7 +900,7 @@ struct TALER_EXCHANGEDB_RecoupRefreshListEntry
/**
* When did the recoup operation happen?
*/
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
};
@ -1054,14 +1054,14 @@ struct TALER_EXCHANGEDB_Deposit
* deposit request in a timely fashion (so back-dating is not
* prevented).
*/
struct GNUNET_TIME_Timestamp timestamp;
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_Timestamp refund_deadline;
struct GNUNET_TIME_Absolute refund_deadline;
/**
* How much time does the merchant have to execute the wire transfer?
@ -1069,7 +1069,7 @@ struct TALER_EXCHANGEDB_Deposit
* constraint (as the merchant can theoretically pick any time,
* including one in the past).
*/
struct GNUNET_TIME_Timestamp wire_deadline;
struct GNUNET_TIME_Absolute wire_deadline;
/**
* Fraction of the coin's remaining value to be deposited, including
@ -1141,14 +1141,14 @@ struct TALER_EXCHANGEDB_DepositListEntry
* deposit request in a timely fashion (so back-dating is not
* prevented).
*/
struct GNUNET_TIME_Timestamp timestamp;
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_Timestamp refund_deadline;
struct GNUNET_TIME_Absolute refund_deadline;
/**
* How much time does the merchant have to execute the wire transfer?
@ -1156,7 +1156,7 @@ struct TALER_EXCHANGEDB_DepositListEntry
* constraint (as the merchant can theoretically pick any time,
* including one in the past).
*/
struct GNUNET_TIME_Timestamp wire_deadline;
struct GNUNET_TIME_Absolute wire_deadline;
/**
* Fraction of the coin's remaining value to be deposited, including
@ -1572,7 +1572,7 @@ typedef enum GNUNET_GenericReturnValue
(*TALER_EXCHANGEDB_DepositCallback)(
void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp exchange_timestamp,
struct GNUNET_TIME_Absolute exchange_timestamp,
const struct TALER_EXCHANGEDB_Deposit *deposit,
const struct TALER_DenominationPublicKey *denom_pub,
bool done);
@ -1787,7 +1787,7 @@ typedef enum GNUNET_GenericReturnValue
const struct TALER_Amount *credit,
const char *sender_account_details,
uint64_t wire_reference,
struct GNUNET_TIME_Timestamp execution_date);
struct GNUNET_TIME_Absolute execution_date);
/**
@ -1821,8 +1821,8 @@ typedef void
void *cls,
const struct TALER_Amount *wire_fee,
const struct TALER_Amount *closing_fee,
struct GNUNET_TIME_Timestamp start_date,
struct GNUNET_TIME_Timestamp end_date,
struct GNUNET_TIME_Absolute start_date,
struct GNUNET_TIME_Absolute end_date,
const struct TALER_MasterSignatureP *master_sig);
@ -1847,7 +1847,7 @@ typedef enum GNUNET_GenericReturnValue
const struct TALER_DenominationPublicKey *denom_pub,
const struct TALER_ReservePublicKeyP *reserve_pub,
const struct TALER_ReserveSignatureP *reserve_sig,
struct GNUNET_TIME_Timestamp execution_date,
struct GNUNET_TIME_Absolute execution_date,
const struct TALER_Amount *amount_with_fee);
@ -1888,7 +1888,7 @@ typedef void
uint64_t rowid,
const struct TALER_MerchantPublicKeyP *merchant_pub,
const char *account_payto_uri,
struct GNUNET_TIME_Timestamp exec_time,
struct GNUNET_TIME_Absolute exec_time,
const struct TALER_PrivateContractHash *h_contract_terms,
const struct TALER_DenominationPublicKey *denom_pub,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
@ -1912,7 +1912,7 @@ typedef enum GNUNET_GenericReturnValue
(*TALER_EXCHANGEDB_WireTransferOutCallback)(
void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp date,
struct GNUNET_TIME_Absolute date,
const struct TALER_WireTransferIdentifierRawP *wtid,
const char *payto_uri,
const struct TALER_Amount *amount);
@ -1956,7 +1956,7 @@ typedef enum GNUNET_GenericReturnValue
(*TALER_EXCHANGEDB_RecoupCallback)(
void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Absolute timestamp,
const struct TALER_Amount *amount,
const struct TALER_ReservePublicKeyP *reserve_pub,
const struct TALER_CoinPublicInfo *coin,
@ -1985,7 +1985,7 @@ typedef enum GNUNET_GenericReturnValue
(*TALER_EXCHANGEDB_RecoupRefreshCallback)(
void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Absolute timestamp,
const struct TALER_Amount *amount,
const struct TALER_CoinSpendPublicKeyP *old_coin_pub,
const struct TALER_DenominationHash *old_denom_pub_hash,
@ -2013,7 +2013,7 @@ typedef enum GNUNET_GenericReturnValue
(*TALER_EXCHANGEDB_ReserveClosedCallback)(
void *cls,
uint64_t rowid,
struct GNUNET_TIME_Timestamp execution_date,
struct GNUNET_TIME_Absolute execution_date,
const struct TALER_Amount *amount_with_fee,
const struct TALER_Amount *closing_fee,
const struct TALER_ReservePublicKeyP *reserve_pub,
@ -2049,7 +2049,7 @@ typedef enum GNUNET_DB_QueryStatus
const struct TALER_ReservePublicKeyP *reserve_pub,
const struct TALER_Amount *left,
const char *account_details,
struct GNUNET_TIME_Timestamp expiration_date);
struct GNUNET_TIME_Absolute expiration_date);
/**
@ -2095,7 +2095,7 @@ typedef void
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_Amount *amount,
const char *payto_uri,
struct GNUNET_TIME_Timestamp deadline,
struct GNUNET_TIME_Absolute deadline,
bool tiny,
bool done);
@ -2462,7 +2462,7 @@ struct TALER_EXCHANGEDB_Plugin
(*reserves_in_insert)(void *cls,
const struct TALER_ReservePublicKeyP *reserve_pub,
const struct TALER_Amount *balance,
struct GNUNET_TIME_Timestamp execution_time,
struct GNUNET_TIME_Absolute execution_time,
const char *sender_account_details,
const char *exchange_account_name,
uint64_t wire_reference);
@ -2544,7 +2544,7 @@ struct TALER_EXCHANGEDB_Plugin
(*do_withdraw)(
void *cls,
const struct TALER_EXCHANGEDB_CollectableBlindcoin *collectable,
struct GNUNET_TIME_Timestamp now,
struct GNUNET_TIME_Absolute now,
bool *found,
bool *balance_ok,
struct TALER_EXCHANGEDB_KycStatus *kyc_ok,
@ -2712,7 +2712,7 @@ struct TALER_EXCHANGEDB_Plugin
(*have_deposit)(void *cls,
const struct TALER_EXCHANGEDB_Deposit *deposit,
struct TALER_Amount *deposit_fee,
struct GNUNET_TIME_Timestamp *exchange_timestamp);
struct GNUNET_TIME_Absolute *exchange_timestamp);
/**
@ -2737,9 +2737,9 @@ struct TALER_EXCHANGEDB_Plugin
const struct TALER_MerchantWireHash *h_wire,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_MerchantPublicKeyP *merchant,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Absolute refund_deadline,
struct TALER_Amount *deposit_fee,
struct GNUNET_TIME_Timestamp *exchange_timestamp);
struct GNUNET_TIME_Absolute *exchange_timestamp);
/**
@ -2752,7 +2752,7 @@ struct TALER_EXCHANGEDB_Plugin
*/
enum GNUNET_DB_QueryStatus
(*insert_deposit)(void *cls,
struct GNUNET_TIME_Timestamp exchange_timestamp,
struct GNUNET_TIME_Absolute exchange_timestamp,
const struct TALER_EXCHANGEDB_Deposit *deposit);
@ -3055,7 +3055,7 @@ struct TALER_EXCHANGEDB_Plugin
const struct TALER_MerchantPublicKeyP *merchant_pub,
bool *pending,
struct TALER_WireTransferIdentifierRawP *wtid,
struct GNUNET_TIME_Timestamp *exec_time,
struct GNUNET_TIME_Absolute *exec_time,
struct TALER_Amount *amount_with_fee,
struct TALER_Amount *deposit_fee,
struct TALER_EXCHANGEDB_KycStatus *kyc);
@ -3091,8 +3091,8 @@ struct TALER_EXCHANGEDB_Plugin
enum GNUNET_DB_QueryStatus
(*insert_wire_fee)(void *cls,
const char *wire_method,
struct GNUNET_TIME_Timestamp start_date,
struct GNUNET_TIME_Timestamp end_date,
struct GNUNET_TIME_Absolute start_date,
struct GNUNET_TIME_Absolute end_date,
const struct TALER_Amount *wire_fee,
const struct TALER_Amount *closing_fee,
const struct TALER_MasterSignatureP *master_sig);
@ -3114,9 +3114,9 @@ struct TALER_EXCHANGEDB_Plugin
enum GNUNET_DB_QueryStatus
(*get_wire_fee)(void *cls,
const char *type,
struct GNUNET_TIME_Timestamp date,
struct GNUNET_TIME_Timestamp *start_date,
struct GNUNET_TIME_Timestamp *end_date,
struct GNUNET_TIME_Absolute date,
struct GNUNET_TIME_Absolute *start_date,
struct GNUNET_TIME_Absolute *end_date,
struct TALER_Amount *wire_fee,
struct TALER_Amount *closing_fee,
struct TALER_MasterSignatureP *master_sig);
@ -3134,7 +3134,7 @@ struct TALER_EXCHANGEDB_Plugin
*/
enum GNUNET_DB_QueryStatus
(*get_expired_reserves)(void *cls,
struct GNUNET_TIME_Timestamp now,
struct GNUNET_TIME_Absolute now,
TALER_EXCHANGEDB_ReserveExpiredCallback rec,
void *rec_cls);
@ -3154,7 +3154,7 @@ struct TALER_EXCHANGEDB_Plugin
enum GNUNET_DB_QueryStatus
(*insert_reserve_closed)(void *cls,
const struct TALER_ReservePublicKeyP *reserve_pub,
struct GNUNET_TIME_Timestamp execution_date,
struct GNUNET_TIME_Absolute execution_date,
const char *receiver_account,
const struct TALER_WireTransferIdentifierRawP *wtid,
const struct TALER_Amount *amount_with_fee,
@ -3248,7 +3248,7 @@ struct TALER_EXCHANGEDB_Plugin
enum GNUNET_DB_QueryStatus
(*store_wire_transfer_out)(
void *cls,
struct GNUNET_TIME_Timestamp date,
struct GNUNET_TIME_Absolute date,
const struct TALER_WireTransferIdentifierRawP *wtid,
uint64_t wire_target,
const char *exchange_account_section,
@ -3486,7 +3486,7 @@ struct TALER_EXCHANGEDB_Plugin
const union TALER_DenominationBlindingKeyP *coin_blind,
const struct TALER_Amount *amount,
const struct TALER_BlindedCoinHash *h_blind_ev,
struct GNUNET_TIME_Timestamp timestamp);
struct GNUNET_TIME_Absolute timestamp);
/**
@ -3511,7 +3511,7 @@ struct TALER_EXCHANGEDB_Plugin
const union TALER_DenominationBlindingKeyP *coin_blind,
const struct TALER_Amount *amount,
const struct TALER_BlindedCoinHash *h_blind_ev,
struct GNUNET_TIME_Timestamp timestamp);
struct GNUNET_TIME_Absolute timestamp);
/**
@ -3592,8 +3592,8 @@ struct TALER_EXCHANGEDB_Plugin
*/
enum GNUNET_DB_QueryStatus
(*select_deposits_missing_wire)(void *cls,
struct GNUNET_TIME_Timestamp start_date,
struct GNUNET_TIME_Timestamp end_date,
struct GNUNET_TIME_Absolute start_date,
struct GNUNET_TIME_Absolute end_date,
TALER_EXCHANGEDB_WireMissingCallback cb,
void *cb_cls);
@ -3609,7 +3609,7 @@ struct TALER_EXCHANGEDB_Plugin
enum GNUNET_DB_QueryStatus
(*lookup_auditor_timestamp)(void *cls,
const struct TALER_AuditorPublicKeyP *auditor_pub,
struct GNUNET_TIME_Timestamp *last_date);
struct GNUNET_TIME_Absolute *last_date);
/**
@ -3645,7 +3645,7 @@ struct TALER_EXCHANGEDB_Plugin
const struct TALER_AuditorPublicKeyP *auditor_pub,
const char *auditor_url,
const char *auditor_name,
struct GNUNET_TIME_Timestamp start_date);
struct GNUNET_TIME_Absolute start_date);
/**
@ -3665,7 +3665,7 @@ struct TALER_EXCHANGEDB_Plugin
const struct TALER_AuditorPublicKeyP *auditor_pub,
const char *auditor_url,
const char *auditor_name,
struct GNUNET_TIME_Timestamp change_date,
struct GNUNET_TIME_Absolute change_date,
bool enabled);
@ -3680,7 +3680,7 @@ struct TALER_EXCHANGEDB_Plugin
enum GNUNET_DB_QueryStatus
(*lookup_wire_timestamp)(void *cls,
const char *payto_uri,
struct GNUNET_TIME_Timestamp *last_date);
struct GNUNET_TIME_Absolute *last_date);
/**
@ -3697,7 +3697,7 @@ struct TALER_EXCHANGEDB_Plugin
enum GNUNET_DB_QueryStatus
(*insert_wire)(void *cls,
const char *payto_uri,
struct GNUNET_TIME_Timestamp start_date,
struct GNUNET_TIME_Absolute start_date,
const struct TALER_MasterSignatureP *master_sig);
@ -3714,7 +3714,7 @@ struct TALER_EXCHANGEDB_Plugin
enum GNUNET_DB_QueryStatus
(*update_wire)(void *cls,
const char *payto_uri,
struct GNUNET_TIME_Timestamp change_date,
struct GNUNET_TIME_Absolute change_date,
bool enabled);
@ -3899,8 +3899,8 @@ struct TALER_EXCHANGEDB_Plugin
(*lookup_wire_fee_by_time)(
void *cls,
const char *wire_method,
struct GNUNET_TIME_Timestamp start_time,
struct GNUNET_TIME_Timestamp end_time,
struct GNUNET_TIME_Absolute start_time,
struct GNUNET_TIME_Absolute end_time,
struct TALER_Amount *wire_fee,
struct TALER_Amount *closing_fee);

96
src/include/taler_json_lib.h
View File

@ -38,6 +38,20 @@
__FILE__, __LINE__, error.text, error.source)
/**
* Generate packer instruction for a JSON field of type
* absolute time.
* The absolute time value is expected to be already rounded.
*
* @param name name of the field to add to the object
* @param at absolute time to pack
* @return json pack specification
*/
struct GNUNET_JSON_PackSpec
TALER_JSON_pack_time_abs (const char *name,
struct GNUNET_TIME_Absolute at);
/**
* Generate packer instruction for a JSON field of type
* absolute time creating a human-readable timestamp.
@ -51,6 +65,20 @@ TALER_JSON_pack_time_abs_human (const char *name,
struct GNUNET_TIME_Absolute at);
/**
* Generate packer instruction for a JSON field of type
* absolute time in network byte order.
* The absolute time value is expected to be already rounded.
*
* @param name name of the field to add to the object
* @param at absolute time to pack
* @return json pack specification
*/
struct GNUNET_JSON_PackSpec
TALER_JSON_pack_time_abs_nbo (const char *name,
struct GNUNET_TIME_AbsoluteNBO at);
/**
* Put an error code into a JSON reply, including
* both the numeric value and the hint.
@ -74,6 +102,34 @@ TALER_JSON_pack_time_abs_nbo_human (const char *name,
struct GNUNET_TIME_AbsoluteNBO at);
/**
* Generate packer instruction for a JSON field of type
* relative time.
* The relative time value is expected to be already rounded.
*
* @param name name of the field to add to the object
* @param rt relative time to pack
* @return json pack specification
*/
struct GNUNET_JSON_PackSpec
TALER_JSON_pack_time_rel (const char *name,
struct GNUNET_TIME_Relative rt);
/**
* Generate packer instruction for a JSON field of type
* relative time in network byte order.
* The relative time value is expected to be already rounded.
*
* @param name name of the field to add to the object
* @param rt relative time to pack
* @return json pack specification
*/
struct GNUNET_JSON_PackSpec
TALER_JSON_pack_time_rel_nbo (const char *name,
struct GNUNET_TIME_RelativeNBO rt);
/**
* Generate packer instruction for a JSON field of type
* denomination public key.
@ -222,6 +278,46 @@ TALER_JSON_spec_amount_any_nbo (const char *name,
struct TALER_AmountNBO *r_amount);
/**
* Provide specification to parse given JSON object to an absolute time.
* The absolute time value is expected to be already rounded.
*
* @param name name of the time field in the JSON
* @param[out] r_time where the time has to be written
* @return spec for parsing an absolute time
*/
struct GNUNET_JSON_Specification
TALER_JSON_spec_absolute_time (const char *name,
struct GNUNET_TIME_Absolute *r_time);
/**
* Provide specification to parse given JSON object to an absolute time
* in network byte order.
* The absolute time value is expected to be already rounded.
*
* @param name name of the time field in the JSON
* @param[out] r_time where the time has to be written
* @return spec for parsing an absolute time
*/
struct GNUNET_JSON_Specification
TALER_JSON_spec_absolute_time_nbo (const char *name,
struct GNUNET_TIME_AbsoluteNBO *r_time);
/**
* Provide specification to parse given JSON object to a relative time.
* The absolute time value is expected to be already rounded.
*
* @param name name of the time field in the JSON
* @param[out] r_time where the time has to be written
* @return spec for parsing a relative time
*/
struct GNUNET_JSON_Specification
TALER_JSON_spec_relative_time (const char *name,
struct GNUNET_TIME_Relative *r_time);
/**
* Generate line in parser specification for denomination public key.
*

57
src/include/taler_pq_lib.h
View File

@ -101,6 +101,33 @@ struct GNUNET_PQ_QueryParam
TALER_PQ_query_param_json (const json_t *x);
/**
* Generate query parameter for an absolute time value.
* In contrast to
* #GNUNET_PQ_query_param_absolute_time(), this function
* will abort (!) if the time given is not rounded!
* The database must store a 64-bit integer.
*
* @param x pointer to the query parameter to pass
*/
struct GNUNET_PQ_QueryParam
TALER_PQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x);
/**
* Generate query parameter for an absolute time value.
* In contrast to
* #GNUNET_PQ_query_param_absolute_time(), this function
* will abort (!) if the time given is not rounded!
* The database must store a 64-bit integer.
*
* @param x pointer to the query parameter to pass
*/
struct GNUNET_PQ_QueryParam
TALER_PQ_query_param_absolute_time_nbo (const struct
GNUNET_TIME_AbsoluteNBO *x);
/**
* Currency amount expected.
*
@ -178,6 +205,36 @@ TALER_PQ_result_spec_json (const char *name,
json_t **jp);
/**
* Rounded absolute time expected.
* In contrast to #GNUNET_PQ_query_param_absolute_time_nbo(),
* this function ensures that the result is rounded and can
* be converted to JSON.
*
* @param name name of the field in the table
* @param[out] at where to store the result
* @return array entry for the result specification to use
*/
struct GNUNET_PQ_ResultSpec
TALER_PQ_result_spec_absolute_time (const char *name,
struct GNUNET_TIME_Absolute *at);
/**
* Rounded absolute time expected.
* In contrast to #GNUNET_PQ_result_spec_absolute_time_nbo(),
* this function ensures that the result is rounded and can
* be converted to JSON.
*
* @param name name of the field in the table
* @param[out] at where to store the result
* @return array entry for the result specification to use
*/
struct GNUNET_PQ_ResultSpec
TALER_PQ_result_spec_absolute_time_nbo (const char *name,
struct GNUNET_TIME_AbsoluteNBO *at);
#endif /* TALER_PQ_LIB_H_ */
/* end of include/taler_pq_lib.h */

66
src/include/taler_signatures.h
View File

@ -342,7 +342,7 @@ struct TALER_DenominationKeyAnnouncementPS
/**
* When does the key become available?
*/
struct GNUNET_TIME_TimestampNBO anchor_time;
struct GNUNET_TIME_AbsoluteNBO anchor_time;
/**
* How long is the key available after @e anchor_time?
@ -373,7 +373,7 @@ struct TALER_SigningKeyAnnouncementPS
/**
* When does the key become available?
*/
struct GNUNET_TIME_TimestampNBO anchor_time;
struct GNUNET_TIME_AbsoluteNBO anchor_time;
/**
* How long is the key available after @e anchor_time?
@ -497,14 +497,14 @@ struct TALER_DepositRequestPS
* deposit request in a timely fashion (so back-dating is not
* prevented).
*/
struct GNUNET_TIME_TimestampNBO wallet_timestamp;
struct GNUNET_TIME_AbsoluteNBO wallet_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_TimestampNBO refund_deadline;
struct GNUNET_TIME_AbsoluteNBO refund_deadline;
/**
* Amount to be deposited, including deposit fee charged by the
@ -565,13 +565,13 @@ struct TALER_DepositConfirmationPS
* Time when this confirmation was generated / when the exchange received
* the deposit request.
*/
struct GNUNET_TIME_TimestampNBO exchange_timestamp;
struct GNUNET_TIME_AbsoluteNBO exchange_timestamp;
/**
* By when does the exchange expect to pay the merchant
* (as per the merchant's request).
*/
struct GNUNET_TIME_TimestampNBO wire_deadline;
struct GNUNET_TIME_AbsoluteNBO wire_deadline;
/**
* How much time does the @e merchant have to issue a refund
@ -580,7 +580,7 @@ struct TALER_DepositConfirmationPS
* performed by the exchange until the refund deadline. This value
* is taken from the original deposit request.
*/
struct GNUNET_TIME_TimestampNBO refund_deadline;
struct GNUNET_TIME_AbsoluteNBO refund_deadline;
/**
* Amount to be deposited, excluding fee. Calculated from the
@ -782,7 +782,7 @@ struct TALER_ExchangeSigningKeyValidityPS
/**
* When does this signing key begin to be valid?
*/
struct GNUNET_TIME_TimestampNBO start;
struct GNUNET_TIME_AbsoluteNBO start;
/**
* When does this signing key expire? Note: This is currently when
@ -792,7 +792,7 @@ struct TALER_ExchangeSigningKeyValidityPS
* the use of either key during the overlap time (due to the
* possibility of clock skew).
*/
struct GNUNET_TIME_TimestampNBO expire;
struct GNUNET_TIME_AbsoluteNBO expire;
/**
* When do signatures with this signing key become invalid? After
@ -801,7 +801,7 @@ struct TALER_ExchangeSigningKeyValidityPS
* evidence. @e end is expected to be significantly larger than @e
* expire (by a year or more).
*/
struct GNUNET_TIME_TimestampNBO end;
struct GNUNET_TIME_AbsoluteNBO end;
/**
* The public online signing key that the exchange will use
@ -828,7 +828,7 @@ struct TALER_ExchangeKeySetPS
/**
* Time of the key set issue.
*/
struct GNUNET_TIME_TimestampNBO list_issue_date;
struct GNUNET_TIME_AbsoluteNBO list_issue_date;
/**
* Hash over the various denomination signing keys returned.
@ -858,7 +858,7 @@ struct TALER_ExchangeAccountSetupSuccessPS
/**
* When was the signature made.
*/
struct GNUNET_TIME_TimestampNBO timestamp;
struct GNUNET_TIME_AbsoluteNBO timestamp;
};
@ -878,7 +878,7 @@ struct TALER_MasterAddAuditorPS
/**
* Time of the change.
*/
struct GNUNET_TIME_TimestampNBO start_date;
struct GNUNET_TIME_AbsoluteNBO start_date;
/**
* Public key of the auditor.
@ -908,7 +908,7 @@ struct TALER_MasterDelAuditorPS
/**
* Time of the change.
*/
struct GNUNET_TIME_TimestampNBO end_date;
struct GNUNET_TIME_AbsoluteNBO end_date;
/**
* Public key of the auditor.
@ -934,7 +934,7 @@ struct TALER_MasterAddWirePS
/**
* Time of the change.
*/
struct GNUNET_TIME_TimestampNBO start_date;
struct GNUNET_TIME_AbsoluteNBO start_date;
/**
* Hash over the exchange's payto URI.
@ -959,7 +959,7 @@ struct TALER_MasterDelWirePS
/**
* Time of the change.
*/
struct GNUNET_TIME_TimestampNBO end_date;
struct GNUNET_TIME_AbsoluteNBO end_date;
/**
* Hash over the exchange's payto URI.
@ -990,7 +990,7 @@ struct TALER_DenominationKeyValidityPS
/**
* Start time of the validity period for this key.
*/
struct GNUNET_TIME_TimestampNBO start;
struct GNUNET_TIME_AbsoluteNBO start;
/**
* The exchange will sign fresh coins between @e start and this time.
@ -1004,7 +1004,7 @@ struct TALER_DenominationKeyValidityPS
* with the same value with overlapping validity periods, to address
* issues such as clock skew.
*/
struct GNUNET_TIME_TimestampNBO expire_withdraw;
struct GNUNET_TIME_AbsoluteNBO expire_withdraw;
/**
* Coins signed with the denomination key must be spent or refreshed
@ -1016,7 +1016,7 @@ struct TALER_DenominationKeyValidityPS
* significantly larger than @e expire_withdraw (by months or even
* years).
*/
struct GNUNET_TIME_TimestampNBO expire_deposit;
struct GNUNET_TIME_AbsoluteNBO expire_deposit;
/**
* When do signatures with this denomination key become invalid?
@ -1025,7 +1025,7 @@ struct TALER_DenominationKeyValidityPS
* of the evidence. @e expire_legal is expected to be significantly
* larger than @e expire_deposit (by a year or more).
*/
struct GNUNET_TIME_TimestampNBO expire_legal;
struct GNUNET_TIME_AbsoluteNBO expire_legal;
/**
* The value of the coins signed with this denomination key.
@ -1093,7 +1093,7 @@ struct TALER_ExchangeKeyValidityPS
/**
* Start time of the validity period for this key.
*/
struct GNUNET_TIME_TimestampNBO start;
struct GNUNET_TIME_AbsoluteNBO start;
/**
* The exchange will sign fresh coins between @e start and this time.
@ -1107,7 +1107,7 @@ struct TALER_ExchangeKeyValidityPS
* with the same value with overlapping validity periods, to address
* issues such as clock skew.
*/
struct GNUNET_TIME_TimestampNBO expire_withdraw;
struct GNUNET_TIME_AbsoluteNBO expire_withdraw;
/**
* Coins signed with the denomination key must be spent or refreshed
@ -1119,7 +1119,7 @@ struct TALER_ExchangeKeyValidityPS
* significantly larger than @e expire_withdraw (by months or even
* years).
*/
struct GNUNET_TIME_TimestampNBO expire_deposit;
struct GNUNET_TIME_AbsoluteNBO expire_deposit;
/**
* When do signatures with this denomination key become invalid?
@ -1128,7 +1128,7 @@ struct TALER_ExchangeKeyValidityPS
* of the evidence. @e expire_legal is expected to be significantly
* larger than @e expire_deposit (by a year or more).
*/
struct GNUNET_TIME_TimestampNBO expire_legal;
struct GNUNET_TIME_AbsoluteNBO expire_legal;
/**
* The value of the coins signed with this denomination key.
@ -1231,12 +1231,12 @@ struct TALER_MasterWireFeePS
/**
* Start date when the fee goes into effect.
*/
struct GNUNET_TIME_TimestampNBO start_date;
struct GNUNET_TIME_AbsoluteNBO start_date;
/**
* End date when the fee stops being in effect (exclusive)
*/
struct GNUNET_TIME_TimestampNBO end_date;
struct GNUNET_TIME_AbsoluteNBO end_date;
/**
* Fee charged to the merchant per wire transfer.
@ -1338,7 +1338,7 @@ struct TALER_WireDepositDetailP
/**
* Time when the wire transfer was performed by the exchange.
*/
struct GNUNET_TIME_TimestampNBO execution_time;
struct GNUNET_TIME_AbsoluteNBO execution_time;
/**
* Coin's public key.
@ -1473,7 +1473,7 @@ struct TALER_ConfirmWirePS
* timestamp may not be exactly the same on the wire, i.e.
* because the wire has a different timezone or resolution.
*/
struct GNUNET_TIME_TimestampNBO execution_time;
struct GNUNET_TIME_AbsoluteNBO execution_time;
/**
* The contribution of @e coin_pub to the total transfer volume.
@ -1532,7 +1532,7 @@ struct TALER_RecoupConfirmationPS
* Indirectly determines when the wire transfer is (likely)
* to happen.
*/
struct GNUNET_TIME_TimestampNBO timestamp;
struct GNUNET_TIME_AbsoluteNBO timestamp;
/**
* How much of the coin's value will the exchange transfer?
@ -1570,7 +1570,7 @@ struct TALER_RecoupRefreshConfirmationPS
* Indirectly determines when the wire transfer is (likely)
* to happen.
*/
struct GNUNET_TIME_TimestampNBO timestamp;
struct GNUNET_TIME_AbsoluteNBO timestamp;
/**
* How much of the coin's value will the exchange transfer?
@ -1605,7 +1605,7 @@ struct TALER_DenominationUnknownAffirmationPS
/**
* When did the exchange sign this message.
*/
struct GNUNET_TIME_TimestampNBO timestamp;
struct GNUNET_TIME_AbsoluteNBO timestamp;
/**
* Hash of the public denomination key we do not know.
@ -1630,7 +1630,7 @@ struct TALER_DenominationExpiredAffirmationPS
/**
* When did the exchange sign this message.
*/
struct GNUNET_TIME_TimestampNBO timestamp;
struct GNUNET_TIME_AbsoluteNBO timestamp;
/**
* Name of the operation that is not allowed at this time. Might NOT be 0-terminated, but is padded with 0s.
@ -1660,7 +1660,7 @@ struct TALER_ReserveCloseConfirmationPS
/**
* When did the exchange initiate the wire transfer.
*/
struct GNUNET_TIME_TimestampNBO timestamp;
struct GNUNET_TIME_AbsoluteNBO timestamp;
/**
* How much did the exchange send?

53
src/include/taler_sq_lib.h
View File

@ -60,6 +60,33 @@ struct GNUNET_SQ_QueryParam
TALER_SQ_query_param_json (const json_t *x);
/**
* Generate query parameter for an absolute time value.
* In contrast to
* #GNUNET_SQ_query_param_absolute_time(), this function
* will abort (!) if the time given is not rounded!
* The database must store a 64-bit integer.
*
* @param x pointer to the query parameter to pass
*/
struct GNUNET_SQ_QueryParam
TALER_SQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x);
/**
* Generate query parameter for an absolute time value.
* In contrast to
* #GNUNET_SQ_query_param_absolute_time(), this function
* will abort (!) if the time given is not rounded!
* The database must store a 64-bit integer.
*
* @param x pointer to the query parameter to pass
*/
struct GNUNET_SQ_QueryParam
TALER_SQ_query_param_absolute_time_nbo (const struct
GNUNET_TIME_AbsoluteNBO *x);
/**
* Currency amount expected.
*
@ -94,6 +121,32 @@ struct GNUNET_SQ_ResultSpec
TALER_SQ_result_spec_json (json_t **jp);
/**
* Rounded absolute time expected.
* In contrast to #GNUNET_SQ_query_param_absolute_time_nbo(),
* this function ensures that the result is rounded and can
* be converted to JSON.
*
* @param[out] at where to store the result
* @return array entry for the result specification to use
*/
struct GNUNET_SQ_ResultSpec
TALER_SQ_result_spec_absolute_time (struct GNUNET_TIME_Absolute *at);
/**
* Rounded absolute time expected.
* In contrast to #GNUNET_SQ_result_spec_absolute_time_nbo(),
* this function ensures that the result is rounded and can
* be converted to JSON.
*
* @param[out] at where to store the result
* @return array entry for the result specification to use
*/
struct GNUNET_SQ_ResultSpec
TALER_SQ_result_spec_absolute_time_nbo (struct GNUNET_TIME_AbsoluteNBO *at);
#endif /* TALER_SQ_LIB_H_ */
/* end of include/taler_sq_lib.h */

57
src/include/taler_testing_lib.h
View File

@ -133,7 +133,7 @@ struct TALER_TESTING_LibeufinServices
* @return #GNUNET_OK on success, #GNUNET_NO if test should be
* skipped, #GNUNET_SYSERR on test failure
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_prepare_exchange (const char *config_filename,
int reset_db,
struct TALER_TESTING_ExchangeConfiguration *ec);
@ -208,7 +208,7 @@ TALER_TESTING_cleanup_files (const char *config_name);
* @param cfg configuration
* @return #GNUNET_OK on success
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_cleanup_files_cfg (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg);
@ -222,7 +222,7 @@ TALER_TESTING_cleanup_files_cfg (void *cls,
* @param auditor_url URL of auditor to enable, can be NULL
* @return #GNUNET_OK on success
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_run_exchange_offline (const char *config_filename,
const char *payto_uri,
const char *auditor_pub,
@ -235,7 +235,7 @@ TALER_TESTING_run_exchange_offline (const char *config_filename,
* @param config_filename configuration file to use
* @return #GNUNET_OK on success
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_auditor_db_reset (const char *config_filename);
@ -245,7 +245,7 @@ TALER_TESTING_auditor_db_reset (const char *config_filename);
* @param config_filename configuration file to use
* @return #GNUNET_OK on success
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_exchange_db_reset (const char *config_filename);
@ -255,7 +255,7 @@ TALER_TESTING_exchange_db_reset (const char *config_filename);
* @param config_filename configuration file to use
* @return #GNUNET_OK on success
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_run_auditor_offline (const char *config_filename);
@ -268,7 +268,7 @@ TALER_TESTING_run_auditor_offline (const char *config_filename);
* @param do_remove #GNUNET_NO to add exchange, #GNUNET_YES to remove
* @return #GNUNET_OK on success
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_run_auditor_exchange (const char *config_filename,
const char *exchange_master_pub,
const char *exchange_base_url,
@ -281,7 +281,7 @@ TALER_TESTING_run_auditor_exchange (const char *config_filename,
* @param url URL to extract port from, 80 is default
* @return #GNUNET_OK if the port is free
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_url_port_free (const char *url);
@ -324,7 +324,7 @@ struct TALER_TESTING_BankConfiguration
* @param[out] bc set to the bank's configuration data
* @return #GNUNET_OK on success
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_prepare_fakebank (const char *config_filename,
const char *config_section,
struct TALER_TESTING_BankConfiguration *bc);
@ -531,7 +531,7 @@ struct TALER_TESTING_Command
* @param index index number of the object to extract.
* @return #GNUNET_OK on success
*/
enum GNUNET_GenericReturnValue
int
(*traits)(void *cls,
const void **ret,
const char *trait,
@ -731,7 +731,7 @@ typedef void
* non-#GNUNET_OK codes are #GNUNET_SYSERR most of the
* times.
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_setup (TALER_TESTING_Main main_cb,
void *main_cb_cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
@ -751,7 +751,7 @@ TALER_TESTING_setup (TALER_TESTING_Main main_cb,
* non-GNUNET_OK codes are #GNUNET_SYSERR most of the
* times.
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_auditor_setup (TALER_TESTING_Main main_cb,
void *main_cb_cls,
const char *config_filename);
@ -788,7 +788,7 @@ struct TALER_TESTING_SetupContext
* @param cfg configuration to use.
* @return #GNUNET_OK if no errors occurred.
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_setup_with_exchange_cfg (
void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg);
@ -809,7 +809,7 @@ TALER_TESTING_setup_with_exchange_cfg (
* at its base URL.
* @return #GNUNET_OK if no errors occurred.
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_setup_with_exchange (TALER_TESTING_Main main_cb,
void *main_cb_cls,
const char *config_file);
@ -824,7 +824,7 @@ TALER_TESTING_setup_with_exchange (TALER_TESTING_Main main_cb,
* @param cfg configuration to use.
* @return #GNUNET_OK if no errors occurred.
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_setup_with_auditor_and_exchange_cfg (
void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg);
@ -845,7 +845,7 @@ TALER_TESTING_setup_with_auditor_and_exchange_cfg (
* at its base URL.
* @return #GNUNET_OK if no errors occurred.
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_setup_with_auditor_and_exchange (TALER_TESTING_Main main_cb,
void *main_cb_cls,
const char *config_file);
@ -905,7 +905,7 @@ TALER_TESTING_run_fakebank (const char *bank_url,
* @param[out] bc set to the bank's configuration data
* @return #GNUNET_OK on success
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_prepare_bank (const char *config_filename,
int reset_db,
const char *config_section,
@ -922,7 +922,7 @@ TALER_TESTING_prepare_bank (const char *config_filename,
* @return the base url, or NULL upon errors. Must be freed
* by the caller.
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_prepare_nexus (const char *config_filename,
int reset_db,
const char *config_section,
@ -934,7 +934,7 @@ TALER_TESTING_prepare_nexus (const char *config_filename,
* @param prog program's name to look into
* @param marker chunk to find in @a prog
*/
enum GNUNET_GenericReturnValue
int
TALER_TESTING_has_in_name (const char *prog,
const char *marker);
@ -1966,7 +1966,7 @@ TALER_TESTING_cmd_insert_deposit (
const struct TALER_TESTING_DatabaseConnection *dbc,
const char *merchant_name,
const char *merchant_account,
struct GNUNET_TIME_Timestamp exchange_timestamp,
struct GNUNET_TIME_Absolute exchange_timestamp,
struct GNUNET_TIME_Relative wire_deadline,
const char *amount_with_fee,
const char *deposit_fee);
@ -2446,12 +2446,12 @@ TALER_TESTING_get_trait (const struct TALER_TESTING_Trait *traits,
op (debit_payto_uri, const char *) \
op (order_id, const char *) \
op (amount, const struct TALER_Amount) \
op (amount_with_fee, const struct TALER_Amount) \
op (deposit_amount, const struct TALER_Amount) \
op (deposit_fee_amount, const struct TALER_Amount) \
op (amount_with_fee, const struct TALER_Amount) \
op (deposit_amount, const struct TALER_Amount) \
op (deposit_fee_amount, const struct TALER_Amount) \
op (batch_cmds, struct TALER_TESTING_Command *) \
op (uuid, const struct GNUNET_Uuid) \
op (fresh_coins, const struct TALER_TESTING_FreshCoinData *) \
op (fresh_coins, const struct TALER_TESTING_FreshCoinData *) \
op (claim_token, const struct TALER_ClaimTokenP) \
op (relative_time, const struct GNUNET_TIME_Relative) \
op (process, struct GNUNET_OS_Process *)
@ -2460,15 +2460,14 @@ TALER_TESTING_get_trait (const struct TALER_TESTING_Trait *traits,
/**
* Call #op on all indexed traits.
*/
#define TALER_TESTING_INDEXED_TRAITS(op) \
#define TALER_TESTING_INDEXED_TRAITS(op) \
op (denom_pub, const struct TALER_EXCHANGE_DenomPublicKey) \
op (denom_sig, const struct TALER_DenominationSignature) \
op (denom_sig, const struct TALER_DenominationSignature) \
op (coin_priv, const struct TALER_CoinSpendPrivateKeyP) \
op (coin_pub, const struct TALER_CoinSpendPublicKeyP) \
op (absolute_time, const struct GNUNET_TIME_Absolute) \
op (timestamp, const struct GNUNET_TIME_Timestamp) \
op (wire_deadline, const struct GNUNET_TIME_Timestamp) \
op (refund_deadline, const struct GNUNET_TIME_Timestamp) \
op (wire_deadline, const struct GNUNET_TIME_Absolute) \
op (refund_deadline, const struct GNUNET_TIME_Absolute) \
op (exchange_pub, const struct TALER_ExchangePublicKeyP) \
op (exchange_sig, const struct TALER_ExchangeSignatureP) \
op (blinding_key, const union TALER_DenominationBlindingKeyP)

213
src/json/json_helper.c
View File

@ -215,6 +215,219 @@ TALER_JSON_spec_amount_any_nbo (const char *name,
}
/**
* Parse given JSON object to *rounded* absolute time.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static enum GNUNET_GenericReturnValue
parse_abs_time (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_TIME_Absolute *abs = spec->ptr;
json_t *json_t_ms;
unsigned long long int tval;
(void) cls;
if (! json_is_object (root))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
json_t_ms = json_object_get (root,
"t_ms");
if (json_is_integer (json_t_ms))
{
tval = json_integer_value (json_t_ms);
/* Time is in milliseconds in JSON, but in microseconds in GNUNET_TIME_Absolute */
abs->abs_value_us = tval * 1000LL;
if ((abs->abs_value_us) / 1000LL != tval)
{
/* Integer overflow */
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
if (GNUNET_OK !=
GNUNET_TIME_round_abs (abs))
{
/* time not rounded */
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
return GNUNET_OK;
}
if (json_is_string (json_t_ms))
{
const char *val;
val = json_string_value (json_t_ms);
if ((0 == strcasecmp (val, "never")))
{
*abs = GNUNET_TIME_UNIT_FOREVER_ABS;
return GNUNET_OK;
}
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"`%s' is not a valid absolute time\n",
json_string_value (json_t_ms));
return GNUNET_SYSERR;
}
return GNUNET_SYSERR;
}
struct GNUNET_JSON_Specification
TALER_JSON_spec_absolute_time (const char *name,
struct GNUNET_TIME_Absolute *r_time)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_abs_time,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = r_time,
.ptr_size = sizeof(struct GNUNET_TIME_Absolute),
.size_ptr = NULL
};
return ret;
}
/**
* Parse given JSON object to absolute time.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static enum GNUNET_GenericReturnValue
parse_abs_time_nbo (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_TIME_AbsoluteNBO *abs = spec->ptr;
struct GNUNET_TIME_Absolute a;
struct GNUNET_JSON_Specification ispec;
(void) cls;
ispec = *spec;
ispec.parser = &parse_abs_time;
ispec.ptr = &a;
if (GNUNET_OK !=
parse_abs_time (NULL,
root,
&ispec))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
*abs = GNUNET_TIME_absolute_hton (a);
return GNUNET_OK;
}
struct GNUNET_JSON_Specification
TALER_JSON_spec_absolute_time_nbo (const char *name,
struct GNUNET_TIME_AbsoluteNBO *r_time)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_abs_time_nbo,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = r_time,
.ptr_size = sizeof(struct GNUNET_TIME_AbsoluteNBO),
.size_ptr = NULL
};
return ret;
}
/**
* Parse given JSON object to relative time.
*
* @param cls closure, NULL
* @param root the json object representing data
* @param[out] spec where to write the data
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static enum GNUNET_GenericReturnValue
parse_rel_time (void *cls,
json_t *root,
struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_TIME_Relative *rel = spec->ptr;
json_t *json_d_ms;
unsigned long long int tval;
(void) cls;
if (! json_is_object (root))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
json_d_ms = json_object_get (root, "d_ms");
if (json_is_integer (json_d_ms))
{
tval = json_integer_value (json_d_ms);
/* Time is in milliseconds in JSON, but in microseconds in GNUNET_TIME_Absolute */
rel->rel_value_us = tval * 1000LL;
if ((rel->rel_value_us) / 1000LL != tval)
{
/* Integer overflow */
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
if (GNUNET_OK !=
GNUNET_TIME_round_rel (rel))
{
/* time not rounded */
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
return GNUNET_OK;
}
if (json_is_string (json_d_ms))
{
const char *val;
val = json_string_value (json_d_ms);
if ((0 == strcasecmp (val, "forever")))
{
*rel = GNUNET_TIME_UNIT_FOREVER_REL;
return GNUNET_OK;
}
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
struct GNUNET_JSON_Specification
TALER_JSON_spec_relative_time (const char *name,
struct GNUNET_TIME_Relative *r_time)
{
struct GNUNET_JSON_Specification ret = {
.parser = &parse_rel_time,
.cleaner = NULL,
.cls = NULL,
.field = name,
.ptr = r_time,
.ptr_size = sizeof(struct GNUNET_TIME_Relative),
.size_ptr = NULL
};
return ret;
}
/**
* Parse given JSON object to denomination public key.
*

40
src/json/json_pack.c
View File

@ -24,6 +24,17 @@
#include "taler_json_lib.h"
struct GNUNET_JSON_PackSpec
TALER_JSON_pack_time_abs (const char *name,
struct GNUNET_TIME_Absolute at)
{
GNUNET_assert (GNUNET_OK ==
GNUNET_TIME_round_abs (&at));
return GNUNET_JSON_pack_time_abs (name,
at);
}
struct GNUNET_JSON_PackSpec
TALER_JSON_pack_time_abs_human (const char *name,
struct GNUNET_TIME_Absolute at)
@ -38,6 +49,15 @@ TALER_JSON_pack_time_abs_human (const char *name,
}
struct GNUNET_JSON_PackSpec
TALER_JSON_pack_time_abs_nbo (const char *name,
struct GNUNET_TIME_AbsoluteNBO at)
{
return TALER_JSON_pack_time_abs (name,
GNUNET_TIME_absolute_ntoh (at));
}
struct GNUNET_JSON_PackSpec
TALER_JSON_pack_time_abs_nbo_human (const char *name,
struct GNUNET_TIME_AbsoluteNBO at)
@ -47,6 +67,26 @@ TALER_JSON_pack_time_abs_nbo_human (const char *name,
}
struct GNUNET_JSON_PackSpec
TALER_JSON_pack_time_rel (const char *name,
struct GNUNET_TIME_Relative rt)
{
GNUNET_assert (GNUNET_OK ==
GNUNET_TIME_round_rel (&rt));
return GNUNET_JSON_pack_time_rel (name,
rt);
}
struct GNUNET_JSON_PackSpec
TALER_JSON_pack_time_rel_nbo (const char *name,
struct GNUNET_TIME_RelativeNBO rt)
{
return TALER_JSON_pack_time_rel (name,
GNUNET_TIME_relative_ntoh (rt));
}
struct GNUNET_JSON_PackSpec
TALER_JSON_pack_denom_pub (
const char *name,

12
src/lib/auditor_api_curl_defaults.c
View File

@ -22,6 +22,12 @@
#include "auditor_api_curl_defaults.h"
/**
* Get a curl handle with the right defaults
* for the exchange lib. In the future, we might manage a pool of connections here.
*
* @param url URL to query
*/
CURL *
TALER_AUDITOR_curl_easy_get_ (const char *url)
{
@ -41,12 +47,6 @@ TALER_AUDITOR_curl_easy_get_ (const char *url)
curl_easy_setopt (eh,
CURLOPT_FOLLOWLOCATION,
1L));
/* Enable compression (using whatever curl likes), see
https://curl.se/libcurl/c/CURLOPT_ACCEPT_ENCODING.html */
GNUNET_break (CURLE_OK ==
curl_easy_setopt (eh,
CURLOPT_ACCEPT_ENCODING,
""));
/* limit MAXREDIRS to 5 as a simple security measure against
a potential infinite loop caused by a malicious target */
GNUNET_assert (CURLE_OK ==

55
src/lib/auditor_api_deposit_confirmation.c
View File

@ -173,18 +173,18 @@ static enum GNUNET_GenericReturnValue
verify_signatures (const struct TALER_MerchantWireHash *h_wire,
const struct TALER_ExtensionContractHash *h_extensions,
const struct TALER_PrivateContractHash *h_contract_terms,
struct GNUNET_TIME_Timestamp exchange_timestamp,
struct GNUNET_TIME_Timestamp wire_deadline,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Absolute exchange_timestamp,
struct GNUNET_TIME_Absolute wire_deadline,
struct GNUNET_TIME_Absolute refund_deadline,
const struct TALER_Amount *amount_without_fee,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_MerchantPublicKeyP *merchant_pub,
const struct TALER_ExchangePublicKeyP *exchange_pub,
const struct TALER_ExchangeSignatureP *exchange_sig,
const struct TALER_MasterPublicKeyP *master_pub,
struct GNUNET_TIME_Timestamp ep_start,
struct GNUNET_TIME_Timestamp ep_expire,
struct GNUNET_TIME_Timestamp ep_end,
struct GNUNET_TIME_Absolute ep_start,
struct GNUNET_TIME_Absolute ep_expire,
struct GNUNET_TIME_Absolute ep_end,
const struct TALER_MasterSignatureP *master_sig)
{
if (GNUNET_OK !=
@ -223,7 +223,7 @@ verify_signatures (const struct TALER_MerchantWireHash *h_wire,
TALER_LOG_WARNING ("Invalid signature on exchange signing key!\n");
return GNUNET_SYSERR;
}
if (GNUNET_TIME_absolute_is_past (ep_end.abs_time))
if (GNUNET_TIME_absolute_is_past (ep_end))
{
GNUNET_break (0);
TALER_LOG_WARNING ("Exchange signing key is no longer valid!\n");
@ -239,18 +239,18 @@ TALER_AUDITOR_deposit_confirmation (
const struct TALER_MerchantWireHash *h_wire,
const struct TALER_ExtensionContractHash *h_extensions,
const struct TALER_PrivateContractHash *h_contract_terms,
struct GNUNET_TIME_Timestamp exchange_timestamp,
struct GNUNET_TIME_Timestamp wire_deadline,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Absolute exchange_timestamp,
struct GNUNET_TIME_Absolute wire_deadline,
struct GNUNET_TIME_Absolute refund_deadline,
const struct TALER_Amount *amount_without_fee,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_MerchantPublicKeyP *merchant_pub,
const struct TALER_ExchangePublicKeyP *exchange_pub,
const struct TALER_ExchangeSignatureP *exchange_sig,
const struct TALER_MasterPublicKeyP *master_pub,
struct GNUNET_TIME_Timestamp ep_start,
struct GNUNET_TIME_Timestamp ep_expire,
struct GNUNET_TIME_Timestamp ep_end,
struct GNUNET_TIME_Absolute ep_start,
struct GNUNET_TIME_Absolute ep_expire,
struct GNUNET_TIME_Absolute ep_end,
const struct TALER_MasterSignatureP *master_sig,
TALER_AUDITOR_DepositConfirmationResultCallback cb,
void *cb_cls)
@ -260,6 +260,11 @@ TALER_AUDITOR_deposit_confirmation (
json_t *deposit_confirmation_obj;
CURL *eh;
(void) GNUNET_TIME_round_abs (&exchange_timestamp);
(void) GNUNET_TIME_round_abs (&refund_deadline);
(void) GNUNET_TIME_round_abs (&ep_start);
(void) GNUNET_TIME_round_abs (&ep_expire);
(void) GNUNET_TIME_round_abs (&ep_end);
GNUNET_assert (GNUNET_YES ==
TALER_AUDITOR_handle_is_ready_ (auditor));
if (GNUNET_OK !=
@ -292,12 +297,12 @@ TALER_AUDITOR_deposit_confirmation (
h_extensions),
GNUNET_JSON_pack_data_auto ("h_contract_terms",
h_contract_terms),
GNUNET_JSON_pack_timestamp ("exchange_timestamp",
exchange_timestamp),
GNUNET_JSON_pack_timestamp ("refund_deadline",
refund_deadline),
GNUNET_JSON_pack_timestamp ("wire_deadline",
wire_deadline),
GNUNET_JSON_pack_time_abs ("exchange_timestamp",
exchange_timestamp),
GNUNET_JSON_pack_time_abs ("refund_deadline",
refund_deadline),
GNUNET_JSON_pack_time_abs ("wire_deadline",
wire_deadline),
TALER_JSON_pack_amount ("amount_without_fee",
amount_without_fee),
GNUNET_JSON_pack_data_auto ("coin_pub",
@ -308,12 +313,12 @@ TALER_AUDITOR_deposit_confirmation (
exchange_sig),
GNUNET_JSON_pack_data_auto ("master_pub",
master_pub),
GNUNET_JSON_pack_timestamp ("ep_start",
ep_start),
GNUNET_JSON_pack_timestamp ("ep_expire",
ep_expire),
GNUNET_JSON_pack_timestamp ("ep_end",
ep_end),
GNUNET_JSON_pack_time_abs ("ep_start",
ep_start),
GNUNET_JSON_pack_time_abs ("ep_expire",
ep_expire),
GNUNET_JSON_pack_time_abs ("ep_end",
ep_end),
GNUNET_JSON_pack_data_auto ("master_sig",
master_sig),
GNUNET_JSON_pack_data_auto ("exchange_pub",

6
src/lib/exchange_api_auditor_add_denomination.c
View File

@ -23,7 +23,6 @@
#include "taler_json_lib.h"
#include <gnunet/gnunet_curl_lib.h>
#include "taler_exchange_service.h"
#include "auditor_api_curl_defaults.h"
#include "taler_signatures.h"
#include "taler_curl_lib.h"
#include "taler_json_lib.h"
@ -191,7 +190,7 @@ TALER_EXCHANGE_add_auditor_denomination (
body = GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("auditor_sig",
auditor_sig));
eh = TALER_AUDITOR_curl_easy_get_ (ah->url);
eh = curl_easy_init ();
GNUNET_assert (NULL != eh);
if (GNUNET_OK !=
TALER_curl_easy_post (&ah->post_ctx,
@ -208,6 +207,9 @@ TALER_EXCHANGE_add_auditor_denomination (
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Requesting URL '%s'\n",
ah->url);
GNUNET_assert (CURLE_OK == curl_easy_setopt (eh,
CURLOPT_URL,
ah->url));
ah->job = GNUNET_CURL_job_add2 (ctx,
eh,
ah->post_ctx.headers,

46
src/lib/exchange_api_common.c
View File

@ -86,12 +86,12 @@ TALER_EXCHANGE_parse_reserve_history (
{
const char *wire_url;
uint64_t wire_reference;
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
struct GNUNET_JSON_Specification withdraw_spec[] = {
GNUNET_JSON_spec_uint64 ("wire_reference",
&wire_reference),
GNUNET_JSON_spec_timestamp ("timestamp",
&timestamp),
TALER_JSON_spec_absolute_time ("timestamp",
&timestamp),
GNUNET_JSON_spec_string ("sender_account_url",
&wire_url),
GNUNET_JSON_spec_end ()
@ -226,7 +226,7 @@ TALER_EXCHANGE_parse_reserve_history (
"RECOUP"))
{
struct TALER_RecoupConfirmationPS pc;
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
const struct TALER_EXCHANGE_Keys *key_state;
struct GNUNET_JSON_Specification recoup_spec[] = {
GNUNET_JSON_spec_fixed_auto ("coin_pub",
@ -235,8 +235,8 @@ TALER_EXCHANGE_parse_reserve_history (
&rh->details.recoup_details.exchange_sig),
GNUNET_JSON_spec_fixed_auto ("exchange_pub",
&rh->details.recoup_details.exchange_pub),
GNUNET_JSON_spec_timestamp_nbo ("timestamp",
&pc.timestamp),
TALER_JSON_spec_absolute_time_nbo ("timestamp",
&pc.timestamp),
GNUNET_JSON_spec_end ()
};
@ -256,7 +256,7 @@ TALER_EXCHANGE_parse_reserve_history (
pc.purpose.size = htonl (sizeof (pc));
pc.purpose.purpose = htonl (TALER_SIGNATURE_EXCHANGE_CONFIRM_RECOUP);
pc.reserve_pub = *reserve_pub;
timestamp = GNUNET_TIME_timestamp_ntoh (pc.timestamp);
timestamp = GNUNET_TIME_absolute_ntoh (pc.timestamp);
rh->details.recoup_details.timestamp = timestamp;
key_state = TALER_EXCHANGE_get_keys (exchange);
@ -294,7 +294,7 @@ TALER_EXCHANGE_parse_reserve_history (
{
const struct TALER_EXCHANGE_Keys *key_state;
struct TALER_ReserveCloseConfirmationPS rcc;
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
struct GNUNET_JSON_Specification closing_spec[] = {
GNUNET_JSON_spec_string (
"receiver_account_details",
@ -307,8 +307,8 @@ TALER_EXCHANGE_parse_reserve_history (
&rh->details.close_details.exchange_pub),
TALER_JSON_spec_amount_any_nbo ("closing_fee",
&rcc.closing_fee),
GNUNET_JSON_spec_timestamp_nbo ("timestamp",
&rcc.timestamp),
TALER_JSON_spec_absolute_time_nbo ("timestamp",
&rcc.timestamp),
GNUNET_JSON_spec_end ()
};
@ -330,7 +330,7 @@ TALER_EXCHANGE_parse_reserve_history (
rcc.purpose.size = htonl (sizeof (rcc));
rcc.purpose.purpose = htonl (TALER_SIGNATURE_EXCHANGE_RESERVE_CLOSED);
rcc.reserve_pub = *reserve_pub;
timestamp = GNUNET_TIME_timestamp_ntoh (rcc.timestamp);
timestamp = GNUNET_TIME_absolute_ntoh (rcc.timestamp);
rh->details.close_details.timestamp = timestamp;
TALER_amount_ntoh (&rh->details.close_details.fee,
&rcc.closing_fee);
@ -478,9 +478,9 @@ TALER_EXCHANGE_verify_coin_history (
struct TALER_MerchantWireHash h_wire;
struct TALER_PrivateContractHash h_contract_terms;
// struct TALER_ExtensionContractHash h_extensions; // FIXME!
struct GNUNET_TIME_Timestamp wallet_timestamp;
struct GNUNET_TIME_Absolute wallet_timestamp;
struct TALER_MerchantPublicKeyP merchant_pub;
struct GNUNET_TIME_Timestamp refund_deadline = {0};
struct GNUNET_TIME_Absolute refund_deadline = {0};
struct TALER_CoinSpendSignatureP sig;
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_fixed_auto ("coin_sig",
@ -491,11 +491,11 @@ TALER_EXCHANGE_verify_coin_history (
&h_wire),
GNUNET_JSON_spec_fixed_auto ("h_denom_pub",
h_denom_pub),
GNUNET_JSON_spec_timestamp ("timestamp",
&wallet_timestamp),
TALER_JSON_spec_absolute_time ("timestamp",
&wallet_timestamp),
GNUNET_JSON_spec_mark_optional (
GNUNET_JSON_spec_timestamp ("refund_deadline",
&refund_deadline)),
TALER_JSON_spec_absolute_time ("refund_deadline",
&refund_deadline)),
TALER_JSON_spec_amount_any ("deposit_fee",
&fee),
GNUNET_JSON_spec_fixed_auto ("merchant_pub",
@ -711,8 +711,8 @@ TALER_EXCHANGE_verify_coin_history (
&rr.coin_blind),
GNUNET_JSON_spec_fixed_auto ("h_denom_pub",
&rr.h_denom_pub),
GNUNET_JSON_spec_timestamp_nbo ("timestamp",
&pc.timestamp),
TALER_JSON_spec_absolute_time_nbo ("timestamp",
&pc.timestamp),
GNUNET_JSON_spec_end ()
};
@ -781,8 +781,8 @@ TALER_EXCHANGE_verify_coin_history (
&rr.coin_blind),
GNUNET_JSON_spec_fixed_auto ("h_denom_pub",
&rr.h_denom_pub),
GNUNET_JSON_spec_timestamp_nbo ("timestamp",
&pc.timestamp),
TALER_JSON_spec_absolute_time_nbo ("timestamp",
&pc.timestamp),
GNUNET_JSON_spec_end ()
};
@ -840,8 +840,8 @@ TALER_EXCHANGE_verify_coin_history (
&exchange_pub),
GNUNET_JSON_spec_fixed_auto ("coin_pub",
&pc.coin_pub),
GNUNET_JSON_spec_timestamp_nbo ("timestamp",
&pc.timestamp),
TALER_JSON_spec_absolute_time_nbo ("timestamp",
&pc.timestamp),
GNUNET_JSON_spec_end ()
};

3
src/lib/exchange_api_curl_defaults.c
View File

@ -30,10 +30,7 @@ TALER_EXCHANGE_curl_easy_get_ (const char *url)
eh = curl_easy_init ();
if (NULL == eh)
{
GNUNET_break (0);
return NULL;
}
GNUNET_assert (CURLE_OK ==
curl_easy_setopt (eh,
CURLOPT_URL,

38
src/lib/exchange_api_deposit.c
View File

@ -100,13 +100,13 @@ struct TALER_EXCHANGE_DepositHandle
* Time when this confirmation was generated / when the exchange received
* the deposit request.
*/
struct GNUNET_TIME_Timestamp exchange_timestamp;
struct GNUNET_TIME_Absolute exchange_timestamp;
/**
* By when does the exchange expect to pay the merchant
* (as per the merchant's request).
*/
struct GNUNET_TIME_Timestamp wire_deadline;
struct GNUNET_TIME_Absolute wire_deadline;
/**
* How much time does the @e merchant have to issue a refund
@ -115,7 +115,7 @@ struct TALER_EXCHANGE_DepositHandle
* performed by the exchange until the refund deadline. This value
* is taken from the original deposit request.
*/
struct GNUNET_TIME_Timestamp refund_deadline;
struct GNUNET_TIME_Absolute refund_deadline;
/**
* Amount to be deposited, excluding fee. Calculated from the
@ -334,8 +334,8 @@ handle_deposit_finished (void *cls,
GNUNET_JSON_spec_mark_optional (
GNUNET_JSON_spec_string ("transaction_base_url",
&dr.details.success.transaction_base_url)),
GNUNET_JSON_spec_timestamp ("exchange_timestamp",
&dh->exchange_timestamp),
TALER_JSON_spec_absolute_time ("exchange_timestamp",
&dh->exchange_timestamp),
GNUNET_JSON_spec_end ()
};
@ -481,9 +481,9 @@ verify_signatures (const struct TALER_EXCHANGE_DenomPublicKey *dki,
const struct TALER_DenominationSignature *denom_sig,
const struct TALER_DenominationPublicKey *denom_pub,
const struct TALER_DenominationHash *denom_pub_hash,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Absolute timestamp,
const struct TALER_MerchantPublicKeyP *merchant_pub,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Absolute refund_deadline,
const struct TALER_CoinSpendSignatureP *coin_sig)
{
if (GNUNET_OK !=
@ -543,7 +543,7 @@ struct TALER_EXCHANGE_DepositHandle *
TALER_EXCHANGE_deposit (
struct TALER_EXCHANGE_Handle *exchange,
const struct TALER_Amount *amount,
struct GNUNET_TIME_Timestamp wire_deadline,
struct GNUNET_TIME_Absolute wire_deadline,
const char *merchant_payto_uri,
const struct TALER_WireSalt *wire_salt,
const struct TALER_PrivateContractHash *h_contract_terms,
@ -551,9 +551,9 @@ TALER_EXCHANGE_deposit (
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_DenominationSignature *denom_sig,
const struct TALER_DenominationPublicKey *denom_pub,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Absolute timestamp,
const struct TALER_MerchantPublicKeyP *merchant_pub,
struct GNUNET_TIME_Timestamp refund_deadline,
struct GNUNET_TIME_Absolute refund_deadline,
const struct TALER_CoinSpendSignatureP *coin_sig,
TALER_EXCHANGE_DepositResultCallback cb,
void *cb_cls,
@ -589,9 +589,9 @@ TALER_EXCHANGE_deposit (
"/coins/%s/deposit",
pub_str);
}
if (GNUNET_TIME_timestamp_cmp (refund_deadline,
>,
wire_deadline))
(void) GNUNET_TIME_round_abs (&wire_deadline);
(void) GNUNET_TIME_round_abs (&refund_deadline);
if (refund_deadline.abs_value_us > wire_deadline.abs_value_us)
{
GNUNET_break_op (0);
*ec = TALER_EC_EXCHANGE_DEPOSIT_REFUND_DEADLINE_AFTER_WIRE_DEADLINE;
@ -658,15 +658,15 @@ TALER_EXCHANGE_deposit (
&denom_pub_hash),
TALER_JSON_pack_denom_sig ("ub_sig",
denom_sig),
GNUNET_JSON_pack_timestamp ("timestamp",
timestamp),
GNUNET_JSON_pack_time_abs ("timestamp",
timestamp),
GNUNET_JSON_pack_data_auto ("merchant_pub",
merchant_pub),
GNUNET_JSON_pack_allow_null (
GNUNET_JSON_pack_timestamp ("refund_deadline",
refund_deadline)),
GNUNET_JSON_pack_timestamp ("wire_transfer_deadline",
wire_deadline),
GNUNET_JSON_pack_time_abs ("refund_deadline",
refund_deadline)),
GNUNET_JSON_pack_time_abs ("wire_transfer_deadline",
wire_deadline),
GNUNET_JSON_pack_data_auto ("coin_sig",
coin_sig));
dh = GNUNET_new (struct TALER_EXCHANGE_DepositHandle);

10
src/lib/exchange_api_deposits_get.c
View File

@ -147,8 +147,8 @@ handle_deposit_wtid_finished (void *cls,
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_fixed_auto ("wtid",
&dr.details.success.wtid),
GNUNET_JSON_spec_timestamp ("execution_time",
&dr.details.success.execution_time),
TALER_JSON_spec_absolute_time ("execution_time",
&dr.details.success.execution_time),
TALER_JSON_spec_amount_any ("coin_contribution",
&dr.details.success.coin_contribution),
GNUNET_JSON_spec_fixed_auto ("exchange_sig",
@ -168,7 +168,7 @@ handle_deposit_wtid_finished (void *cls,
dr.hr.ec = TALER_EC_GENERIC_REPLY_MALFORMED;
break;
}
dwh->depconf.execution_time = GNUNET_TIME_timestamp_hton (
dwh->depconf.execution_time = GNUNET_TIME_absolute_hton (
dr.details.success.execution_time);
dwh->depconf.wtid = dr.details.success.wtid;
TALER_amount_hton (&dwh->depconf.coin_contribution,
@ -192,8 +192,8 @@ handle_deposit_wtid_finished (void *cls,
{
/* Transaction known, but not executed yet */
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_timestamp ("execution_time",
&dr.details.accepted.execution_time),
TALER_JSON_spec_absolute_time ("execution_time",
&dr.details.accepted.execution_time),
GNUNET_JSON_spec_uint64 ("payment_target_uuid",
&dr.details.accepted.payment_target_uuid),
GNUNET_JSON_spec_bool ("kyc_ok",

171
src/lib/exchange_api_handle.c
View File

@ -39,7 +39,7 @@
* Which version of the Taler protocol is implemented
* by this library? Used to determine compatibility.
*/
#define EXCHANGE_PROTOCOL_CURRENT 11
#define EXCHANGE_PROTOCOL_CURRENT 10
/**
* How many versions are we backwards compatible with?
@ -161,7 +161,7 @@ struct KeysRequest
* Expiration time according to "Expire:" header.
* 0 if not provided by the server.
*/
struct GNUNET_TIME_Timestamp expire;
struct GNUNET_TIME_Absolute expire;
};
@ -264,12 +264,12 @@ parse_json_signkey (struct TALER_EXCHANGE_SigningPublicKey *sign_key,
&sign_key_issue_sig),
GNUNET_JSON_spec_fixed_auto ("key",
&sign_key->key),
GNUNET_JSON_spec_timestamp ("stamp_start",
&sign_key->valid_from),
GNUNET_JSON_spec_timestamp ("stamp_expire",
&sign_key->valid_until),
GNUNET_JSON_spec_timestamp ("stamp_end",
&sign_key->valid_legal),
TALER_JSON_spec_absolute_time ("stamp_start",
&sign_key->valid_from),
TALER_JSON_spec_absolute_time ("stamp_expire",
&sign_key->valid_until),
TALER_JSON_spec_absolute_time ("stamp_end",
&sign_key->valid_legal),
GNUNET_JSON_spec_end ()
};
@ -322,14 +322,14 @@ parse_json_denomkey (struct TALER_EXCHANGE_DenomPublicKey *denom_key,
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_fixed_auto ("master_sig",
&denom_key->master_sig),
GNUNET_JSON_spec_timestamp ("stamp_expire_deposit",
&denom_key->expire_deposit),
GNUNET_JSON_spec_timestamp ("stamp_expire_withdraw",
&denom_key->withdraw_valid_until),
GNUNET_JSON_spec_timestamp ("stamp_start",
&denom_key->valid_from),
GNUNET_JSON_spec_timestamp ("stamp_expire_legal",
&denom_key->expire_legal),
TALER_JSON_spec_absolute_time ("stamp_expire_deposit",
&denom_key->expire_deposit),
TALER_JSON_spec_absolute_time ("stamp_expire_withdraw",
&denom_key->withdraw_valid_until),
TALER_JSON_spec_absolute_time ("stamp_start",
&denom_key->valid_from),
TALER_JSON_spec_absolute_time ("stamp_expire_legal",
&denom_key->expire_legal),
TALER_JSON_spec_amount_any ("value",
&denom_key->value),
TALER_JSON_spec_amount_any ("fee_withdraw",
@ -675,10 +675,10 @@ decode_keys_json (const json_t *resp_obj,
&pub),
GNUNET_JSON_spec_fixed_auto ("master_public_key",
&key_data->master_pub),
GNUNET_JSON_spec_timestamp ("list_issue_date",
&key_data->list_issue_date),
GNUNET_JSON_spec_relative_time ("reserve_closing_delay",
&key_data->reserve_closing_delay),
TALER_JSON_spec_absolute_time ("list_issue_date",
&key_data->list_issue_date),
TALER_JSON_spec_relative_time ("reserve_closing_delay",
&key_data->reserve_closing_delay),
GNUNET_JSON_spec_string ("currency",
&currency),
GNUNET_JSON_spec_mark_optional (
@ -843,10 +843,10 @@ decode_keys_json (const json_t *resp_obj,
/* Update "last_denom_issue_date" */
TALER_LOG_DEBUG ("Adding denomination key that is valid_until %s\n",
GNUNET_TIME_timestamp2s (dk.valid_from));
GNUNET_STRINGS_absolute_time_to_string (dk.valid_from));
key_data->last_denom_issue_date
= GNUNET_TIME_timestamp_max (key_data->last_denom_issue_date,
dk.valid_from);
= GNUNET_TIME_absolute_max (key_data->last_denom_issue_date,
dk.valid_from);
};
}
@ -970,7 +970,7 @@ decode_keys_json (const json_t *resp_obj,
struct TALER_ExchangeKeySetPS ks = {
.purpose.size = htonl (sizeof (ks)),
.purpose.purpose = htonl (TALER_SIGNATURE_EXCHANGE_KEY_SET),
.list_issue_date = GNUNET_TIME_timestamp_hton (key_data->list_issue_date)
.list_issue_date = GNUNET_TIME_absolute_hton (key_data->list_issue_date)
};
GNUNET_CRYPTO_hash_context_finish (hash_context,
@ -1040,16 +1040,16 @@ request_keys (void *cls);
void
TALER_EXCHANGE_set_last_denom (struct TALER_EXCHANGE_Handle *exchange,
struct GNUNET_TIME_Timestamp last_denom_new)
struct GNUNET_TIME_Absolute last_denom_new)
{
TALER_LOG_DEBUG (
"Application explicitly set last denomination validity to %s\n",
GNUNET_TIME_timestamp2s (last_denom_new));
GNUNET_STRINGS_absolute_time_to_string (last_denom_new));
exchange->key_data.last_denom_issue_date = last_denom_new;
}
struct GNUNET_TIME_Timestamp
struct GNUNET_TIME_Absolute
TALER_EXCHANGE_check_keys_current (struct TALER_EXCHANGE_Handle *exchange,
enum TALER_EXCHANGE_CheckKeysFlags flags)
{
@ -1057,7 +1057,7 @@ TALER_EXCHANGE_check_keys_current (struct TALER_EXCHANGE_Handle *exchange,
bool pull_all_keys = 0 != (flags & TALER_EXCHANGE_CKF_PULL_ALL_KEYS);
if (NULL != exchange->kr)
return GNUNET_TIME_UNIT_ZERO_TS;
return GNUNET_TIME_UNIT_ZERO_ABS;
if (pull_all_keys)
{
@ -1067,13 +1067,12 @@ TALER_EXCHANGE_check_keys_current (struct TALER_EXCHANGE_Handle *exchange,
exchange->state = MHS_INIT;
}
if ( (! force_download) &&
(GNUNET_TIME_absolute_is_future (
exchange->key_data_expiration.abs_time)) )
(GNUNET_TIME_absolute_is_future (exchange->key_data_expiration)) )
return exchange->key_data_expiration;
if (NULL == exchange->retry_task)
exchange->retry_task = GNUNET_SCHEDULER_add_now (&request_keys,
exchange);
return GNUNET_TIME_UNIT_ZERO_TS;
return GNUNET_TIME_UNIT_ZERO_ABS;
}
@ -1105,16 +1104,15 @@ keys_completed_cb (void *cls,
"Received keys from URL `%s' with status %ld and expiration %s.\n",
kr->url,
response_code,
GNUNET_TIME_timestamp2s (kr->expire));
if (GNUNET_TIME_absolute_is_past (kr->expire.abs_time))
GNUNET_STRINGS_absolute_time_to_string (kr->expire));
if (GNUNET_TIME_absolute_is_past (kr->expire))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Exchange failed to give expiration time, assuming in %s\n",
GNUNET_TIME_relative2s (DEFAULT_EXPIRATION,
true));
kr->expire
= GNUNET_TIME_absolute_to_timestamp (
GNUNET_TIME_relative_to_absolute (DEFAULT_EXPIRATION));
GNUNET_STRINGS_relative_time_to_string (DEFAULT_EXPIRATION,
GNUNET_YES));
kr->expire = GNUNET_TIME_relative_to_absolute (DEFAULT_EXPIRATION);
(void) GNUNET_TIME_round_abs (&kr->expire);
}
kd_old = exchange->key_data;
memset (&kd,
@ -1252,14 +1250,13 @@ keys_completed_cb (void *cls,
break;
}
exchange->key_data = kd;
if (GNUNET_TIME_absolute_is_past (
exchange->key_data.last_denom_issue_date.abs_time))
if (GNUNET_TIME_absolute_is_past (exchange->key_data.last_denom_issue_date))
TALER_LOG_WARNING ("Last DK issue date from exchange is in the past: %s\n",
GNUNET_TIME_timestamp2s (
GNUNET_STRINGS_absolute_time_to_string (
exchange->key_data.last_denom_issue_date));
else
TALER_LOG_DEBUG ("Last DK issue date updated to: %s\n",
GNUNET_TIME_timestamp2s (
GNUNET_STRINGS_absolute_time_to_string (
exchange->key_data.last_denom_issue_date));
@ -1343,7 +1340,7 @@ TEAH_path_to_url (struct TALER_EXCHANGE_Handle *h,
*/
static enum GNUNET_GenericReturnValue
parse_date_string (const char *dateline,
struct GNUNET_TIME_Timestamp *at)
struct GNUNET_TIME_Absolute *at)
{
static const char *MONTHS[] =
{ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
@ -1425,7 +1422,7 @@ parse_date_string (const char *dateline,
}
if (t < 0)
t = 0; /* can happen due to timezone issues if date was 1.1.1970 */
*at = GNUNET_TIME_timestamp_from_s (t);
at->abs_value_us = 1000LL * 1000LL * t;
return GNUNET_OK;
}
@ -1467,7 +1464,7 @@ header_cb (char *buffer,
"Failed to parse %s-header `%s'\n",
MHD_HTTP_HEADER_EXPIRES,
val);
kr->expire = GNUNET_TIME_UNIT_ZERO_TS;
kr->expire = GNUNET_TIME_UNIT_ZERO_ABS;
}
GNUNET_free (val);
return total;
@ -1493,7 +1490,7 @@ deserialize_data (struct TALER_EXCHANGE_Handle *exchange,
json_t *keys;
const char *url;
uint32_t version;
struct GNUNET_TIME_Timestamp expire;
struct GNUNET_TIME_Absolute expire;
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_uint32 ("version",
&version),
@ -1501,8 +1498,8 @@ deserialize_data (struct TALER_EXCHANGE_Handle *exchange,
&keys),
GNUNET_JSON_spec_string ("exchange_url",
&url),
GNUNET_JSON_spec_timestamp ("expire",
&expire),
TALER_JSON_spec_absolute_time ("expire",
&expire),
GNUNET_JSON_spec_end ()
};
struct TALER_EXCHANGE_Keys key_data;
@ -1569,13 +1566,13 @@ json_t *
TALER_EXCHANGE_serialize_data (struct TALER_EXCHANGE_Handle *exchange)
{
const struct TALER_EXCHANGE_Keys *kd = &exchange->key_data;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
json_t *keys;
json_t *signkeys;
json_t *denoms;
json_t *auditors;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
signkeys = json_array ();
if (NULL == signkeys)
{
@ -1587,21 +1584,19 @@ TALER_EXCHANGE_serialize_data (struct TALER_EXCHANGE_Handle *exchange)
const struct TALER_EXCHANGE_SigningPublicKey *sk = &kd->sign_keys[i];
json_t *signkey;
if (GNUNET_TIME_timestamp_cmp (now,
>,
sk->valid_until))
if (now.abs_value_us > sk->valid_until.abs_value_us)
continue; /* skip keys that have expired */
signkey = GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("key",
&sk->key),
GNUNET_JSON_pack_data_auto ("master_sig",
&sk->master_sig),
GNUNET_JSON_pack_timestamp ("stamp_start",
sk->valid_from),
GNUNET_JSON_pack_timestamp ("stamp_expire",
sk->valid_until),
GNUNET_JSON_pack_timestamp ("stamp_end",
sk->valid_legal));
GNUNET_JSON_pack_time_abs ("stamp_start",
sk->valid_from),
GNUNET_JSON_pack_time_abs ("stamp_expire",
sk->valid_until),
GNUNET_JSON_pack_time_abs ("stamp_end",
sk->valid_legal));
if (NULL == signkey)
{
GNUNET_break (0);
@ -1628,19 +1623,17 @@ TALER_EXCHANGE_serialize_data (struct TALER_EXCHANGE_Handle *exchange)
const struct TALER_EXCHANGE_DenomPublicKey *dk = &kd->denom_keys[i];
json_t *denom;
if (GNUNET_TIME_timestamp_cmp (now,
>,
dk->expire_deposit))
if (now.abs_value_us > dk->expire_deposit.abs_value_us)
continue; /* skip keys that have expired */
denom = GNUNET_JSON_PACK (
GNUNET_JSON_pack_timestamp ("stamp_expire_deposit",
dk->expire_deposit),
GNUNET_JSON_pack_timestamp ("stamp_expire_withdraw",
dk->withdraw_valid_until),
GNUNET_JSON_pack_timestamp ("stamp_start",
dk->valid_from),
GNUNET_JSON_pack_timestamp ("stamp_expire_legal",
dk->expire_legal),
GNUNET_JSON_pack_time_abs ("stamp_expire_deposit",
dk->expire_deposit),
GNUNET_JSON_pack_time_abs ("stamp_expire_withdraw",
dk->withdraw_valid_until),
GNUNET_JSON_pack_time_abs ("stamp_start",
dk->valid_from),
GNUNET_JSON_pack_time_abs ("stamp_expire_legal",
dk->expire_legal),
TALER_JSON_pack_amount ("value",
&dk->value),
TALER_JSON_pack_amount ("fee_withdraw",
@ -1684,9 +1677,7 @@ TALER_EXCHANGE_serialize_data (struct TALER_EXCHANGE_Handle *exchange)
&kd->denom_keys[adi->denom_key_offset];
json_t *k;
if (GNUNET_TIME_timestamp_cmp (now,
>,
dk->expire_deposit))
if (now.abs_value_us > dk->expire_deposit.abs_value_us)
continue; /* skip auditor signatures for denomination keys that have expired */
GNUNET_assert (adi->denom_key_offset < kd->num_denom_keys);
k = GNUNET_JSON_PACK (
@ -1719,8 +1710,8 @@ TALER_EXCHANGE_serialize_data (struct TALER_EXCHANGE_Handle *exchange)
&kd->master_pub),
GNUNET_JSON_pack_time_rel ("reserve_closing_delay",
kd->reserve_closing_delay),
GNUNET_JSON_pack_timestamp ("list_issue_date",
kd->list_issue_date),
GNUNET_JSON_pack_time_abs ("list_issue_date",
kd->list_issue_date),
GNUNET_JSON_pack_array_steal ("signkeys",
signkeys),
GNUNET_JSON_pack_array_steal ("denoms",
@ -1730,8 +1721,8 @@ TALER_EXCHANGE_serialize_data (struct TALER_EXCHANGE_Handle *exchange)
return GNUNET_JSON_PACK (
GNUNET_JSON_pack_uint64 ("version",
EXCHANGE_SERIALIZATION_FORMAT_VERSION),
GNUNET_JSON_pack_timestamp ("expire",
exchange->key_data_expiration),
GNUNET_JSON_pack_time_abs ("expire",
exchange->key_data_expiration),
GNUNET_JSON_pack_string ("exchange_url",
exchange->url),
GNUNET_JSON_pack_object_steal ("keys",
@ -1832,12 +1823,12 @@ request_keys (void *cls)
if (GNUNET_YES == TEAH_handle_is_ready (exchange))
{
TALER_LOG_DEBUG ("Last DK issue date (before GETting /keys): %s\n",
GNUNET_TIME_timestamp2s (
GNUNET_STRINGS_absolute_time_to_string (
exchange->key_data.last_denom_issue_date));
sprintf (&url[strlen (url)],
"last_issue_date=%llu&",
(unsigned long long)
exchange->key_data.last_denom_issue_date.abs_time.abs_value_us
(unsigned long
long) exchange->key_data.last_denom_issue_date.abs_value_us
/ 1000000LLU);
}
@ -1960,22 +1951,18 @@ TALER_EXCHANGE_test_signing_key (const struct TALER_EXCHANGE_Keys *keys,
/* we will check using a tolerance of 1h for the time */
now = GNUNET_TIME_absolute_get ();
for (unsigned int i = 0; i<keys->num_sign_keys; i++)
if ( (GNUNET_TIME_absolute_cmp (
keys->sign_keys[i].valid_from.abs_time,
<=,
GNUNET_TIME_absolute_add (now,
LIFETIME_TOLERANCE))) &&
(GNUNET_TIME_absolute_cmp (
keys->sign_keys[i].valid_until.abs_time,
>,
GNUNET_TIME_absolute_subtract (now,
LIFETIME_TOLERANCE))) &&
if ( (keys->sign_keys[i].valid_from.abs_value_us <=
GNUNET_TIME_absolute_add (now,
LIFETIME_TOLERANCE).abs_value_us) &&
(keys->sign_keys[i].valid_until.abs_value_us >
GNUNET_TIME_absolute_subtract (now,
LIFETIME_TOLERANCE).abs_value_us) &&
(0 == GNUNET_memcmp (pub,
&keys->sign_keys[i].key)) )
return GNUNET_OK;
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Signing key not valid at time %s\n",
GNUNET_TIME_absolute2s (now));
"Signing key not valid at time %llu\n",
(unsigned long long) now.abs_value_us);
return GNUNET_SYSERR;
}

2
src/lib/exchange_api_handle.h
View File

@ -147,7 +147,7 @@ struct TALER_EXCHANGE_Handle
/**
* When does @e key_data expire?
*/
struct GNUNET_TIME_Timestamp key_data_expiration;
struct GNUNET_TIME_Absolute key_data_expiration;
/**
* Number of subsequent failed requests to /keys.

6
src/lib/exchange_api_kyc_check.c
View File

@ -100,8 +100,8 @@ handle_kyc_check_finished (void *cls,
&ks.details.kyc_ok.exchange_sig),
GNUNET_JSON_spec_fixed_auto ("exchange_pub",
&ks.details.kyc_ok.exchange_pub),
GNUNET_JSON_spec_timestamp ("now",
&ks.details.kyc_ok.timestamp),
TALER_JSON_spec_absolute_time ("now",
&ks.details.kyc_ok.timestamp),
GNUNET_JSON_spec_end ()
};
const struct TALER_EXCHANGE_Keys *key_state;
@ -122,7 +122,7 @@ handle_kyc_check_finished (void *cls,
ks.ec = TALER_EC_GENERIC_INVALID_RESPONSE;
break;
}
kyc_purpose.timestamp = GNUNET_TIME_timestamp_hton (
kyc_purpose.timestamp = GNUNET_TIME_absolute_hton (
ks.details.kyc_ok.timestamp);
key_state = TALER_EXCHANGE_get_keys (kch->exchange);
if (GNUNET_OK !=

12
src/lib/exchange_api_management_auditor_disable.c
View File

@ -23,7 +23,6 @@
#include "taler_json_lib.h"
#include <gnunet/gnunet_curl_lib.h>
#include "taler_exchange_service.h"
#include "exchange_api_curl_defaults.h"
#include "taler_signatures.h"
#include "taler_curl_lib.h"
#include "taler_json_lib.h"
@ -129,7 +128,7 @@ TALER_EXCHANGE_management_disable_auditor (
struct GNUNET_CURL_Context *ctx,
const char *url,
const struct TALER_AuditorPublicKeyP *auditor_pub,
struct GNUNET_TIME_Timestamp validity_end,
struct GNUNET_TIME_Absolute validity_end,
const struct TALER_MasterSignatureP *master_sig,
TALER_EXCHANGE_ManagementAuditorDisableCallback cb,
void *cb_cls)
@ -170,9 +169,9 @@ TALER_EXCHANGE_management_disable_auditor (
body = GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("master_sig",
master_sig),
GNUNET_JSON_pack_timestamp ("validity_end",
validity_end));
eh = TALER_EXCHANGE_curl_easy_get_ (ah->url);
GNUNET_JSON_pack_time_abs ("validity_end",
validity_end));
eh = curl_easy_init ();
GNUNET_assert (NULL != eh);
if (GNUNET_OK !=
TALER_curl_easy_post (&ah->post_ctx,
@ -189,6 +188,9 @@ TALER_EXCHANGE_management_disable_auditor (
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Requesting URL '%s'\n",
ah->url);
GNUNET_assert (CURLE_OK == curl_easy_setopt (eh,
CURLOPT_URL,
ah->url));
ah->job = GNUNET_CURL_job_add2 (ctx,
eh,
ah->post_ctx.headers,

12
src/lib/exchange_api_management_auditor_enable.c
View File

@ -23,7 +23,6 @@
#include "taler_json_lib.h"
#include <gnunet/gnunet_curl_lib.h>
#include "taler_exchange_service.h"
#include "exchange_api_curl_defaults.h"
#include "taler_signatures.h"
#include "taler_curl_lib.h"
#include "taler_json_lib.h"
@ -128,7 +127,7 @@ TALER_EXCHANGE_management_enable_auditor (
const struct TALER_AuditorPublicKeyP *auditor_pub,
const char *auditor_url,
const char *auditor_name,
struct GNUNET_TIME_Timestamp validity_start,
struct GNUNET_TIME_Absolute validity_start,
const struct TALER_MasterSignatureP *master_sig,
TALER_EXCHANGE_ManagementAuditorEnableCallback cb,
void *cb_cls)
@ -160,9 +159,9 @@ TALER_EXCHANGE_management_enable_auditor (
auditor_pub),
GNUNET_JSON_pack_data_auto ("master_sig",
master_sig),
GNUNET_JSON_pack_timestamp ("validity_start",
validity_start));
eh = TALER_EXCHANGE_curl_easy_get_ (ah->url);
GNUNET_JSON_pack_time_abs ("validity_start",
validity_start));
eh = curl_easy_init ();
GNUNET_assert (NULL != eh);
if (GNUNET_OK !=
TALER_curl_easy_post (&ah->post_ctx,
@ -179,6 +178,9 @@ TALER_EXCHANGE_management_enable_auditor (
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Requesting URL '%s'\n",
ah->url);
GNUNET_assert (CURLE_OK == curl_easy_setopt (eh,
CURLOPT_URL,
ah->url));
ah->job = GNUNET_CURL_job_add2 (ctx,
eh,
ah->post_ctx.headers,

59
src/lib/exchange_api_management_get_keys.c
View File

@ -23,7 +23,6 @@
#include "taler_json_lib.h"
#include <gnunet/gnunet_curl_lib.h>
#include "taler_exchange_service.h"
#include "exchange_api_curl_defaults.h"
#include "taler_signatures.h"
#include "taler_curl_lib.h"
#include "taler_crypto_lib.h"
@ -125,12 +124,12 @@ handle_ok (struct TALER_EXCHANGE_ManagementGetKeysHandle *gh,
&sign_key->key),
GNUNET_JSON_spec_fixed_auto ("signkey_secmod_sig",
&sign_key->signkey_secmod_sig),
GNUNET_JSON_spec_timestamp ("stamp_start",
&sign_key->valid_from),
GNUNET_JSON_spec_timestamp ("stamp_expire",
&sign_key->valid_until),
GNUNET_JSON_spec_timestamp ("stamp_end",
&sign_key->valid_legal),
TALER_JSON_spec_absolute_time ("stamp_start",
&sign_key->valid_from),
TALER_JSON_spec_absolute_time ("stamp_expire",
&sign_key->valid_until),
TALER_JSON_spec_absolute_time ("stamp_end",
&sign_key->valid_legal),
GNUNET_JSON_spec_end ()
};
@ -145,8 +144,8 @@ handle_ok (struct TALER_EXCHANGE_ManagementGetKeysHandle *gh,
}
{
struct GNUNET_TIME_Relative duration
= GNUNET_TIME_absolute_get_difference (sign_key->valid_from.abs_time,
sign_key->valid_until.abs_time);
= GNUNET_TIME_absolute_get_difference (sign_key->valid_from,
sign_key->valid_until);
if (GNUNET_OK !=
TALER_exchange_secmod_eddsa_verify (
@ -172,14 +171,14 @@ handle_ok (struct TALER_EXCHANGE_ManagementGetKeysHandle *gh,
struct GNUNET_JSON_Specification spec[] = {
TALER_JSON_spec_amount_any ("value",
&denom_key->value),
GNUNET_JSON_spec_timestamp ("stamp_start",
&denom_key->valid_from),
GNUNET_JSON_spec_timestamp ("stamp_expire_withdraw",
&denom_key->withdraw_valid_until),
GNUNET_JSON_spec_timestamp ("stamp_expire_deposit",
&denom_key->expire_deposit),
GNUNET_JSON_spec_timestamp ("stamp_expire_legal",
&denom_key->expire_legal),
TALER_JSON_spec_absolute_time ("stamp_start",
&denom_key->valid_from),
TALER_JSON_spec_absolute_time ("stamp_expire_withdraw",
&denom_key->withdraw_valid_until),
TALER_JSON_spec_absolute_time ("stamp_expire_deposit",
&denom_key->expire_deposit),
TALER_JSON_spec_absolute_time ("stamp_expire_legal",
&denom_key->expire_legal),
TALER_JSON_spec_denom_pub ("denom_pub",
&denom_key->key),
TALER_JSON_spec_amount_any ("fee_withdraw",
@ -215,9 +214,8 @@ handle_ok (struct TALER_EXCHANGE_ManagementGetKeysHandle *gh,
{
struct TALER_DenominationHash h_denom_pub;
struct GNUNET_TIME_Relative duration
= GNUNET_TIME_absolute_get_difference (
denom_key->valid_from.abs_time,
denom_key->withdraw_valid_until.abs_time);
= GNUNET_TIME_absolute_get_difference (denom_key->valid_from,
denom_key->withdraw_valid_until);
TALER_denom_pub_hash (&denom_key->key,
&h_denom_pub);
@ -337,6 +335,16 @@ handle_get_keys_finished (void *cls,
};
/**
* Request future keys from the exchange. The obtained information will be
* passed to the @a cb.
*
* @param ctx the context
* @param url HTTP base URL for the exchange
* @param cb function to call with the exchange's future keys result
* @param cb_cls closure for @a cb
* @return the request handle; NULL upon error
*/
struct TALER_EXCHANGE_ManagementGetKeysHandle *
TALER_EXCHANGE_get_management_keys (struct GNUNET_CURL_Context *ctx,
const char *url,
@ -360,10 +368,14 @@ TALER_EXCHANGE_get_management_keys (struct GNUNET_CURL_Context *ctx,
GNUNET_free (gh);
return NULL;
}
eh = TALER_EXCHANGE_curl_easy_get_ (gh->url);
eh = curl_easy_init ();
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Requesting URL '%s'\n",
gh->url);
GNUNET_assert (CURLE_OK ==
curl_easy_setopt (eh,
CURLOPT_URL,
gh->url));
gh->job = GNUNET_CURL_job_add (ctx,
eh,
&handle_get_keys_finished,
@ -377,6 +389,11 @@ TALER_EXCHANGE_get_management_keys (struct GNUNET_CURL_Context *ctx,
}
/**
* Cancel #TALER_EXCHANGE_get_management_keys() operation.
*
* @param gh handle of the operation to cancel
*/
void
TALER_EXCHANGE_get_management_keys_cancel (
struct TALER_EXCHANGE_ManagementGetKeysHandle *gh)

6
src/lib/exchange_api_management_post_keys.c
View File

@ -23,7 +23,6 @@
#include "taler_json_lib.h"
#include <gnunet/gnunet_curl_lib.h>
#include "taler_exchange_service.h"
#include "exchange_api_curl_defaults.h"
#include "taler_signatures.h"
#include "taler_curl_lib.h"
#include "taler_json_lib.h"
@ -190,7 +189,7 @@ TALER_EXCHANGE_post_management_keys (
denom_sigs),
GNUNET_JSON_pack_array_steal ("signkey_sigs",
signkey_sigs));
eh = TALER_EXCHANGE_curl_easy_get_ (ph->url);
eh = curl_easy_init ();
GNUNET_assert (NULL != eh);
if (GNUNET_OK !=
TALER_curl_easy_post (&ph->post_ctx,
@ -207,6 +206,9 @@ TALER_EXCHANGE_post_management_keys (
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Requesting URL '%s'\n",
ph->url);
GNUNET_assert (CURLE_OK == curl_easy_setopt (eh,
CURLOPT_URL,
ph->url));
ph->job = GNUNET_CURL_job_add2 (ctx,
eh,
ph->post_ctx.headers,

6
src/lib/exchange_api_management_revoke_denomination_key.c
View File

@ -23,7 +23,6 @@
#include "taler_json_lib.h"
#include <gnunet/gnunet_curl_lib.h>
#include "taler_exchange_service.h"
#include "exchange_api_curl_defaults.h"
#include "taler_signatures.h"
#include "taler_curl_lib.h"
#include "taler_json_lib.h"
@ -174,7 +173,7 @@ TALER_EXCHANGE_management_revoke_denomination_key (
GNUNET_free (rh);
return NULL;
}
eh = TALER_EXCHANGE_curl_easy_get_ (rh->url);
eh = curl_easy_init ();
if (GNUNET_OK !=
TALER_curl_easy_post (&rh->post_ctx,
eh,
@ -190,6 +189,9 @@ TALER_EXCHANGE_management_revoke_denomination_key (
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Requesting URL '%s'\n",
rh->url);
GNUNET_assert (CURLE_OK == curl_easy_setopt (eh,
CURLOPT_URL,
rh->url));
rh->job = GNUNET_CURL_job_add2 (ctx,
eh,
rh->post_ctx.headers,

6
src/lib/exchange_api_management_revoke_signing_key.c
View File

@ -23,7 +23,6 @@
#include "taler_json_lib.h"
#include <gnunet/gnunet_curl_lib.h>
#include "taler_exchange_service.h"
#include "exchange_api_curl_defaults.h"
#include "taler_signatures.h"
#include "taler_curl_lib.h"
#include "taler_json_lib.h"
@ -164,7 +163,7 @@ TALER_EXCHANGE_management_revoke_signing_key (
body = GNUNET_JSON_PACK (
GNUNET_JSON_pack_data_auto ("master_sig",
master_sig));
eh = TALER_EXCHANGE_curl_easy_get_ (rh->url);
eh = curl_easy_init ();
GNUNET_assert (NULL != eh);
if (GNUNET_OK !=
TALER_curl_easy_post (&rh->post_ctx,
@ -181,6 +180,9 @@ TALER_EXCHANGE_management_revoke_signing_key (
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Requesting URL '%s'\n",
rh->url);
GNUNET_assert (CURLE_OK == curl_easy_setopt (eh,
CURLOPT_URL,
rh->url));
rh->job = GNUNET_CURL_job_add2 (ctx,
eh,
rh->post_ctx.headers,

18
src/lib/exchange_api_management_set_wire_fee.c
View File

@ -22,7 +22,6 @@
#include "platform.h"
#include "taler_json_lib.h"
#include <gnunet/gnunet_curl_lib.h>
#include "exchange_api_curl_defaults.h"
#include "taler_exchange_service.h"
#include "taler_signatures.h"
#include "taler_curl_lib.h"
@ -127,8 +126,8 @@ TALER_EXCHANGE_management_set_wire_fees (
struct GNUNET_CURL_Context *ctx,
const char *exchange_base_url,
const char *wire_method,
struct GNUNET_TIME_Timestamp validity_start,
struct GNUNET_TIME_Timestamp validity_end,
struct GNUNET_TIME_Absolute validity_start,
struct GNUNET_TIME_Absolute validity_end,
const struct TALER_Amount *wire_fee,
const struct TALER_Amount *closing_fee,
const struct TALER_MasterSignatureP *master_sig,
@ -158,15 +157,15 @@ TALER_EXCHANGE_management_set_wire_fees (
wire_method),
GNUNET_JSON_pack_data_auto ("master_sig",
master_sig),
GNUNET_JSON_pack_timestamp ("fee_start",
validity_start),
GNUNET_JSON_pack_timestamp ("fee_end",
validity_end),
GNUNET_JSON_pack_time_abs ("fee_start",
validity_start),
GNUNET_JSON_pack_time_abs ("fee_end",
validity_end),
TALER_JSON_pack_amount ("closing_fee",
closing_fee),
TALER_JSON_pack_amount ("wire_fee",
wire_fee));
eh = TALER_EXCHANGE_curl_easy_get_ (swfh->url);
eh = curl_easy_init ();
GNUNET_assert (NULL != eh);
if (GNUNET_OK !=
TALER_curl_easy_post (&swfh->post_ctx,
@ -183,6 +182,9 @@ TALER_EXCHANGE_management_set_wire_fees (
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Requesting URL '%s'\n",
swfh->url);
GNUNET_assert (CURLE_OK == curl_easy_setopt (eh,
CURLOPT_URL,
swfh->url));
swfh->job = GNUNET_CURL_job_add2 (ctx,
eh,
swfh->post_ctx.headers,

12
src/lib/exchange_api_management_wire_disable.c
View File

@ -23,7 +23,6 @@
#include "taler_json_lib.h"
#include <gnunet/gnunet_curl_lib.h>
#include "taler_exchange_service.h"
#include "exchange_api_curl_defaults.h"
#include "taler_signatures.h"
#include "taler_curl_lib.h"
#include "taler_json_lib.h"
@ -132,7 +131,7 @@ TALER_EXCHANGE_management_disable_wire (
struct GNUNET_CURL_Context *ctx,
const char *url,
const char *payto_uri,
struct GNUNET_TIME_Timestamp validity_end,
struct GNUNET_TIME_Absolute validity_end,
const struct TALER_MasterSignatureP *master_sig,
TALER_EXCHANGE_ManagementWireDisableCallback cb,
void *cb_cls)
@ -160,9 +159,9 @@ TALER_EXCHANGE_management_disable_wire (
payto_uri),
GNUNET_JSON_pack_data_auto ("master_sig_del",
master_sig),
GNUNET_JSON_pack_timestamp ("validity_end",
validity_end));
eh = TALER_EXCHANGE_curl_easy_get_ (wh->url);
GNUNET_JSON_pack_time_abs ("validity_end",
validity_end));
eh = curl_easy_init ();
GNUNET_assert (NULL != eh);
if (GNUNET_OK !=
TALER_curl_easy_post (&wh->post_ctx,
@ -179,6 +178,9 @@ TALER_EXCHANGE_management_disable_wire (
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Requesting URL '%s'\n",
wh->url);
GNUNET_assert (CURLE_OK == curl_easy_setopt (eh,
CURLOPT_URL,
wh->url));
wh->job = GNUNET_CURL_job_add2 (ctx,
eh,
wh->post_ctx.headers,

12
src/lib/exchange_api_management_wire_enable.c
View File

@ -23,7 +23,6 @@
#include "taler_json_lib.h"
#include <gnunet/gnunet_curl_lib.h>
#include "taler_exchange_service.h"
#include "exchange_api_curl_defaults.h"
#include "taler_signatures.h"
#include "taler_curl_lib.h"
#include "taler_json_lib.h"
@ -128,7 +127,7 @@ TALER_EXCHANGE_management_enable_wire (
struct GNUNET_CURL_Context *ctx,
const char *url,
const char *payto_uri,
struct GNUNET_TIME_Timestamp validity_start,
struct GNUNET_TIME_Absolute validity_start,
const struct TALER_MasterSignatureP *master_sig1,
const struct TALER_MasterSignatureP *master_sig2,
TALER_EXCHANGE_ManagementWireEnableCallback cb,
@ -159,9 +158,9 @@ TALER_EXCHANGE_management_enable_wire (
master_sig1),
GNUNET_JSON_pack_data_auto ("master_sig_wire",
master_sig2),
GNUNET_JSON_pack_timestamp ("validity_start",
validity_start));
eh = TALER_EXCHANGE_curl_easy_get_ (wh->url);
GNUNET_JSON_pack_time_abs ("validity_start",
validity_start));
eh = curl_easy_init ();
GNUNET_assert (NULL != eh);
if (GNUNET_OK !=
TALER_curl_easy_post (&wh->post_ctx,
@ -178,6 +177,9 @@ TALER_EXCHANGE_management_enable_wire (
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Requesting URL '%s'\n",
wh->url);
GNUNET_assert (CURLE_OK == curl_easy_setopt (eh,
CURLOPT_URL,
wh->url));
wh->job = GNUNET_CURL_job_add2 (ctx,
eh,
wh->post_ctx.headers,

3
src/lib/exchange_api_recoup.c
View File

@ -305,7 +305,6 @@ TALER_EXCHANGE_recoup (struct TALER_EXCHANGE_Handle *exchange,
const struct TALER_EXCHANGE_DenomPublicKey *pk,
const struct TALER_DenominationSignature *denom_sig,
const struct TALER_PlanchetSecretsP *ps,
const struct TALER_Amount *amount,
bool was_refreshed,
TALER_EXCHANGE_RecoupResultCallback recoup_cb,
void *recoup_cb_cls)
@ -337,8 +336,6 @@ TALER_EXCHANGE_recoup (struct TALER_EXCHANGE_Handle *exchange,
&h_denom_pub),
TALER_JSON_pack_denom_sig ("denom_sig",
denom_sig),
TALER_JSON_pack_amount ("amount",
amount),
GNUNET_JSON_pack_data_auto ("coin_sig",
&coin_sig),
GNUNET_JSON_pack_data_auto ("coin_blind_key_secret",

8
src/lib/exchange_api_refresh_common.c
View File

@ -89,8 +89,8 @@ serialize_melted_coin (const struct MeltedCoin *mc)
&mc->original_value),
TALER_JSON_pack_amount ("melt_fee",
&mc->fee_melt),
GNUNET_JSON_pack_timestamp ("expire_deposit",
mc->expire_deposit),
GNUNET_JSON_pack_time_abs ("expire_deposit",
mc->expire_deposit),
GNUNET_JSON_pack_array_steal ("transfer_privs",
tprivs));
}
@ -126,8 +126,8 @@ deserialize_melted_coin (struct MeltedCoin *mc,
TALER_JSON_spec_amount ("melt_fee",
currency,
&mc->fee_melt),
GNUNET_JSON_spec_timestamp ("expire_deposit",
&mc->expire_deposit),
TALER_JSON_spec_absolute_time ("expire_deposit",
&mc->expire_deposit),
GNUNET_JSON_spec_json ("transfer_privs",
&trans_privs),
GNUNET_JSON_spec_end ()

2
src/lib/exchange_api_refresh_common.h
View File

@ -60,7 +60,7 @@ struct MeltedCoin
/**
* Timestamp indicating when coins of this denomination become invalid.
*/
struct GNUNET_TIME_Timestamp expire_deposit;
struct GNUNET_TIME_Absolute expire_deposit;
/**
* Denomination key of the original coin.

12
src/lib/exchange_api_refund.c
View File

@ -203,9 +203,9 @@ verify_conflict_history_ok (struct TALER_EXCHANGE_RefundHandle *rh,
struct TALER_PrivateContractHash h_contract_terms;
// struct TALER_ExtensionContractHash h_extensions; // FIXME!
struct TALER_DenominationHash h_denom_pub;
struct GNUNET_TIME_Timestamp wallet_timestamp;
struct GNUNET_TIME_Absolute wallet_timestamp;
struct TALER_MerchantPublicKeyP merchant_pub;
struct GNUNET_TIME_Timestamp refund_deadline;
struct GNUNET_TIME_Absolute refund_deadline;
struct TALER_CoinSpendSignatureP sig;
struct GNUNET_JSON_Specification ispec[] = {
GNUNET_JSON_spec_fixed_auto ("coin_sig",
@ -216,10 +216,10 @@ verify_conflict_history_ok (struct TALER_EXCHANGE_RefundHandle *rh,
&h_wire),
GNUNET_JSON_spec_fixed_auto ("h_denom_pub",
&h_denom_pub),
GNUNET_JSON_spec_timestamp ("timestamp",
&wallet_timestamp),
GNUNET_JSON_spec_timestamp ("refund_deadline",
&refund_deadline),
TALER_JSON_spec_absolute_time ("timestamp",
&wallet_timestamp),
TALER_JSON_spec_absolute_time ("refund_deadline",
&refund_deadline),
TALER_JSON_spec_amount_any ("deposit_fee",
&deposit_fee),
GNUNET_JSON_spec_fixed_auto ("merchant_pub",

4
src/lib/exchange_api_transfers_get.c
View File

@ -93,7 +93,7 @@ check_transfers_get_response_ok (
TALER_JSON_spec_amount_any ("wire_fee", &td.wire_fee),
GNUNET_JSON_spec_fixed_auto ("merchant_pub", &merchant_pub),
GNUNET_JSON_spec_fixed_auto ("h_payto", &td.h_payto),
GNUNET_JSON_spec_timestamp ("execution_time", &td.execution_time),
TALER_JSON_spec_absolute_time ("execution_time", &td.execution_time),
GNUNET_JSON_spec_json ("deposits", &details_j),
GNUNET_JSON_spec_fixed_auto ("exchange_sig", &td.exchange_sig),
GNUNET_JSON_spec_fixed_auto ("exchange_pub", &td.exchange_pub),
@ -181,7 +181,7 @@ check_transfers_get_response_ok (
struct TALER_WireDepositDetailP dd;
dd.h_contract_terms = detail->h_contract_terms;
dd.execution_time = GNUNET_TIME_timestamp_hton (td.execution_time);
dd.execution_time = GNUNET_TIME_absolute_hton (td.execution_time);
dd.coin_pub = detail->coin_pub;
TALER_amount_hton (&dd.deposit_value,
&detail->coin_value);

8
src/lib/exchange_api_wire.c
View File

@ -147,10 +147,10 @@ parse_fees (json_t *fees)
&wa->wire_fee),
TALER_JSON_spec_amount_any ("closing_fee",
&wa->closing_fee),
GNUNET_JSON_spec_timestamp ("start_date",
&wa->start_date),
GNUNET_JSON_spec_timestamp ("end_date",
&wa->end_date),
TALER_JSON_spec_absolute_time ("start_date",
&wa->start_date),
TALER_JSON_spec_absolute_time ("end_date",
&wa->end_date),
GNUNET_JSON_spec_end ()
};

119
src/pq/pq_query_helper.c
View File

@ -474,4 +474,123 @@ TALER_PQ_query_param_json (const json_t *x)
}
/**
* Function called to convert input argument into SQL parameters.
*
* @param cls closure
* @param data pointer to input argument
* @param data_len number of bytes in @a data (if applicable)
* @param[out] param_values SQL data to set
* @param[out] param_lengths SQL length data to set
* @param[out] param_formats SQL format data to set
* @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
* @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
* @param scratch_length number of entries left in @a scratch
* @return -1 on error, number of offsets used in @a scratch otherwise
*/
static int
qconv_round_time (void *cls,
const void *data,
size_t data_len,
void *param_values[],
int param_lengths[],
int param_formats[],
unsigned int param_length,
void *scratch[],
unsigned int scratch_length)
{
const struct GNUNET_TIME_Absolute *at = data;
struct GNUNET_TIME_Absolute tmp;
struct GNUNET_TIME_AbsoluteNBO *buf;
(void) cls;
GNUNET_assert (1 == param_length);
GNUNET_assert (sizeof (struct GNUNET_TIME_AbsoluteNBO) == data_len);
GNUNET_assert (scratch_length > 0);
GNUNET_break (NULL == cls);
tmp = *at;
GNUNET_assert (GNUNET_OK ==
GNUNET_TIME_round_abs (&tmp));
buf = GNUNET_new (struct GNUNET_TIME_AbsoluteNBO);
*buf = GNUNET_TIME_absolute_hton (tmp);
scratch[0] = buf;
param_values[0] = (void *) buf;
param_lengths[0] = sizeof (struct GNUNET_TIME_AbsoluteNBO);
param_formats[0] = 1;
return 1;
}
struct GNUNET_PQ_QueryParam
TALER_PQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x)
{
struct GNUNET_PQ_QueryParam res = {
.conv = &qconv_round_time,
.data = x,
.size = sizeof (*x),
.num_params = 1
};
return res;
}
/**
* Function called to convert input argument into SQL parameters.
*
* @param cls closure
* @param data pointer to input argument
* @param data_len number of bytes in @a data (if applicable)
* @param[out] param_values SQL data to set
* @param[out] param_lengths SQL length data to set
* @param[out] param_formats SQL format data to set
* @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
* @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
* @param scratch_length number of entries left in @a scratch
* @return -1 on error, number of offsets used in @a scratch otherwise
*/
static int
qconv_round_time_abs (void *cls,
const void *data,
size_t data_len,
void *param_values[],
int param_lengths[],
int param_formats[],
unsigned int param_length,
void *scratch[],
unsigned int scratch_length)
{
const struct GNUNET_TIME_AbsoluteNBO *at = data;
struct GNUNET_TIME_Absolute tmp;
(void) cls;
(void) scratch;
(void) scratch_length;
GNUNET_assert (1 == param_length);
GNUNET_assert (sizeof (struct GNUNET_TIME_AbsoluteNBO) == data_len);
GNUNET_break (NULL == cls);
tmp = GNUNET_TIME_absolute_ntoh (*at);
GNUNET_assert (GNUNET_OK ==
GNUNET_TIME_round_abs (&tmp));
param_values[0] = (void *) at;
param_lengths[0] = sizeof (struct GNUNET_TIME_AbsoluteNBO);
param_formats[0] = 1;
return 0;
}
struct GNUNET_PQ_QueryParam
TALER_PQ_query_param_absolute_time_nbo (const struct GNUNET_TIME_AbsoluteNBO *x)
{
struct GNUNET_PQ_QueryParam res = {
.conv = &qconv_round_time_abs,
.data = x,
.size = sizeof (*x),
.num_params = 1
};
return res;
}
/* end of pq/pq_query_helper.c */

140
src/pq/pq_result_helper.c
View File

@ -352,6 +352,146 @@ TALER_PQ_result_spec_json (const char *name,
}
/**
* Extract data from a Postgres database @a result at row @a row.
*
* @param cls closure
* @param result where to extract data from
* @param row the row to extract data from
* @param fname name (or prefix) of the fields to extract from
* @param[in,out] dst_size where to store size of result, may be NULL
* @param[out] dst where to store the result
* @return
* #GNUNET_YES if all results could be extracted
* #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
*/
static enum GNUNET_GenericReturnValue
extract_round_time (void *cls,
PGresult *result,
int row,
const char *fname,
size_t *dst_size,
void *dst)
{
struct GNUNET_TIME_Absolute *udst = dst;
const struct GNUNET_TIME_AbsoluteNBO *res;
struct GNUNET_TIME_Absolute tmp;
int fnum;
(void) cls;
fnum = PQfnumber (result,
fname);
if (fnum < 0)
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
if (PQgetisnull (result,
row,
fnum))
return GNUNET_NO;
GNUNET_assert (NULL != dst);
if (sizeof (struct GNUNET_TIME_Absolute) != *dst_size)
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
res = (struct GNUNET_TIME_AbsoluteNBO *) PQgetvalue (result,
row,
fnum);
tmp = GNUNET_TIME_absolute_ntoh (*res);
GNUNET_break (GNUNET_OK ==
GNUNET_TIME_round_abs (&tmp));
*udst = tmp;
return GNUNET_OK;
}
struct GNUNET_PQ_ResultSpec
TALER_PQ_result_spec_absolute_time (const char *name,
struct GNUNET_TIME_Absolute *at)
{
struct GNUNET_PQ_ResultSpec res = {
.conv = &extract_round_time,
.dst = (void *) at,
.dst_size = sizeof (struct GNUNET_TIME_Absolute),
.fname = name
};
return res;
}
/**
* Extract data from a Postgres database @a result at row @a row.
*
* @param cls closure
* @param result where to extract data from
* @param row the row to extract data from
* @param fname name (or prefix) of the fields to extract from
* @param[in,out] dst_size where to store size of result, may be NULL
* @param[out] dst where to store the result
* @return
* #GNUNET_YES if all results could be extracted
* #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
*/
static enum GNUNET_GenericReturnValue
extract_round_time_nbo (void *cls,
PGresult *result,
int row,
const char *fname,
size_t *dst_size,
void *dst)
{
struct GNUNET_TIME_AbsoluteNBO *udst = dst;
const struct GNUNET_TIME_AbsoluteNBO *res;
struct GNUNET_TIME_Absolute tmp;
int fnum;
(void) cls;
fnum = PQfnumber (result,
fname);
if (fnum < 0)
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
if (PQgetisnull (result,
row,
fnum))
return GNUNET_NO;
GNUNET_assert (NULL != dst);
if (sizeof (struct GNUNET_TIME_AbsoluteNBO) != *dst_size)
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
res = (struct GNUNET_TIME_AbsoluteNBO *) PQgetvalue (result,
row,
fnum);
tmp = GNUNET_TIME_absolute_ntoh (*res);
GNUNET_break (GNUNET_OK ==
GNUNET_TIME_round_abs (&tmp));
*udst = GNUNET_TIME_absolute_hton (tmp);
return GNUNET_OK;
}
struct GNUNET_PQ_ResultSpec
TALER_PQ_result_spec_absolute_time_nbo (const char *name,
struct GNUNET_TIME_AbsoluteNBO *at)
{
struct GNUNET_PQ_ResultSpec res = {
.conv = &extract_round_time_nbo,
.dst = (void *) at,
.dst_size = sizeof (struct GNUNET_TIME_AbsoluteNBO),
.fname = name
};
return res;
}
/**
* Extract data from a Postgres database @a result at row @a row.
*

160
src/sq/sq_query_helper.c
View File

@ -36,7 +36,7 @@
* so immediately suitable for passing to `sqlite3_bind`-functions.
* @return #GNUNET_SYSERR on error, #GNUNET_OK on success
*/
static enum GNUNET_GenericReturnValue
static int
qconv_amount (void *cls,
const void *data,
size_t data_len,
@ -59,16 +59,18 @@ qconv_amount (void *cls,
}
/**
* Generate query parameter for a currency, consisting of the
* components "value", "fraction" in this order. The
* types must be a 64-bit integer and a 64-bit integer.
*
* @param x pointer to the query parameter to pass
*/
struct GNUNET_SQ_QueryParam
TALER_SQ_query_param_amount (const struct TALER_Amount *x)
{
struct GNUNET_SQ_QueryParam res = {
.conv = &qconv_amount,
.data = x,
.size = sizeof (*x),
.num_params = 2
};
struct GNUNET_SQ_QueryParam res =
{ &qconv_amount, NULL, x, sizeof (*x), 2 };
return res;
}
@ -84,7 +86,7 @@ TALER_SQ_query_param_amount (const struct TALER_Amount *x)
* so immediately suitable for passing to `sqlite3_bind`-functions.
* @return #GNUNET_SYSERR on error, #GNUNET_OK on success
*/
static enum GNUNET_GenericReturnValue
static int
qconv_amount_nbo (void *cls,
const void *data,
size_t data_len,
@ -106,16 +108,18 @@ qconv_amount_nbo (void *cls,
}
/**
* Generate query parameter for a currency, consisting of the
* components "value", "fraction" in this order. The
* types must be a 64-bit integer and a 64-bit integer.
*
* @param x pointer to the query parameter to pass
*/
struct GNUNET_SQ_QueryParam
TALER_SQ_query_param_amount_nbo (const struct TALER_AmountNBO *x)
{
struct GNUNET_SQ_QueryParam res = {
.conv = &qconv_amount_nbo,
.data = x,
.size = sizeof (*x),
.num_params = 2
};
struct GNUNET_SQ_QueryParam res =
{ &qconv_amount_nbo, NULL, x, sizeof (*x), 2 };
return res;
}
@ -131,7 +135,7 @@ TALER_SQ_query_param_amount_nbo (const struct TALER_AmountNBO *x)
* so immediately suitable for passing to `sqlite3_bind`-functions.
* @return #GNUNET_SYSERR on error, #GNUNET_OK on success
*/
static enum GNUNET_GenericReturnValue
static int
qconv_json (void *cls,
const void *data,
size_t data_len,
@ -158,16 +162,126 @@ qconv_json (void *cls,
}
/**
* Generate query parameter for a JSON object (stored as a string
* in the DB). Note that @a x must really be a JSON object or array,
* passing just a value (string, integer) is not supported and will
* result in an abort.
*
* @param x pointer to the json object to pass
*/
struct GNUNET_SQ_QueryParam
TALER_SQ_query_param_json (const json_t *x)
{
struct GNUNET_SQ_QueryParam res = {
.conv = &qconv_json,
.data = x,
.size = sizeof (*x),
.num_params = 1
};
struct GNUNET_SQ_QueryParam res =
{ &qconv_json, NULL, x, sizeof (*x), 1 };
return res;
}
/**
* Function called to convert input argument into SQL parameters.
*
* @param cls closure
* @param data pointer to input argument, here a `struct TALER_Amount`
* @param data_len number of bytes in @a data (if applicable)
* @param stmt sqlite statement to parameters for
* @param off offset of the argument to bind in @a stmt, numbered from 1,
* so immediately suitable for passing to `sqlite3_bind`-functions.
* @return #GNUNET_SYSERR on error, #GNUNET_OK on success
*/
static int
qconv_round_time (void *cls,
const void *data,
size_t data_len,
sqlite3_stmt *stmt,
unsigned int off)
{
const struct GNUNET_TIME_Absolute *at = data;
struct GNUNET_TIME_Absolute tmp;
(void) cls;
GNUNET_assert (sizeof (struct GNUNET_TIME_AbsoluteNBO) == data_len);
GNUNET_break (NULL == cls);
tmp = *at;
GNUNET_assert (GNUNET_OK ==
GNUNET_TIME_round_abs (&tmp));
if (SQLITE_OK != sqlite3_bind_int64 (stmt,
(int) off,
(sqlite3_int64) at->abs_value_us))
return GNUNET_SYSERR;
return GNUNET_OK;
}
/**
* Generate query parameter for an absolute time value.
* In contrast to
* #GNUNET_SQ_query_param_absolute_time(), this function
* will abort (!) if the time given is not rounded!
* The database must store a 64-bit integer.
*
* @param x pointer to the query parameter to pass
*/
struct GNUNET_SQ_QueryParam
TALER_SQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x)
{
struct GNUNET_SQ_QueryParam res =
{ &qconv_round_time, NULL, x, sizeof (*x), 1 };
return res;
}
/**
* Function called to convert input argument into SQL parameters.
*
* @param cls closure
* @param data pointer to input argument, here a `struct TALER_Amount`
* @param data_len number of bytes in @a data (if applicable)
* @param stmt sqlite statement to parameters for
* @param off offset of the argument to bind in @a stmt, numbered from 1,
* so immediately suitable for passing to `sqlite3_bind`-functions.
* @return #GNUNET_SYSERR on error, #GNUNET_OK on success
*/
static int
qconv_round_time_abs (void *cls,
const void *data,
size_t data_len,
sqlite3_stmt *stmt,
unsigned int off)
{
const struct GNUNET_TIME_AbsoluteNBO *at = data;
struct GNUNET_TIME_Absolute tmp;
(void) cls;
GNUNET_assert (sizeof (struct GNUNET_TIME_AbsoluteNBO) == data_len);
GNUNET_break (NULL == cls);
tmp = GNUNET_TIME_absolute_ntoh (*at);
GNUNET_assert (GNUNET_OK ==
GNUNET_TIME_round_abs (&tmp));
if (SQLITE_OK != sqlite3_bind_int64 (stmt,
(int) off,
(sqlite3_int64) tmp.abs_value_us))
return GNUNET_SYSERR;
return GNUNET_OK;
}
/**
* Generate query parameter for an absolute time value.
* In contrast to
* #GNUNET_SQ_query_param_absolute_time(), this function
* will abort (!) if the time given is not rounded!
* The database must store a 64-bit integer.
*
* @param x pointer to the query parameter to pass
*/
struct GNUNET_SQ_QueryParam
TALER_SQ_query_param_absolute_time_nbo (const struct
GNUNET_TIME_AbsoluteNBO *x)
{
struct GNUNET_SQ_QueryParam res =
{ &qconv_round_time_abs, NULL, x, sizeof (*x), 1 };
return res;
}

154
src/sq/sq_result_helper.c
View File

@ -38,7 +38,7 @@
* #GNUNET_YES if all results could be extracted
* #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
*/
static enum GNUNET_GenericReturnValue
static int
extract_amount (void *cls,
sqlite3_stmt *result,
unsigned int column,
@ -68,6 +68,13 @@ extract_amount (void *cls,
}
/**
* Currency amount expected.
*
* @param currency the currency to use for @a amount
* @param[out] amount where to store the result
* @return array entry for the result specification to use
*/
struct GNUNET_SQ_ResultSpec
TALER_SQ_result_spec_amount (const char *currency,
struct TALER_Amount *amount)
@ -96,7 +103,7 @@ TALER_SQ_result_spec_amount (const char *currency,
* #GNUNET_YES if all results could be extracted
* #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
*/
static enum GNUNET_GenericReturnValue
static int
extract_amount_nbo (void *cls,
sqlite3_stmt *result,
unsigned int column,
@ -125,6 +132,13 @@ extract_amount_nbo (void *cls,
}
/**
* Currency amount expected.
*
* @param currency the currency to use for @a amount
* @param[out] amount where to store the result
* @return array entry for the result specification to use
*/
struct GNUNET_SQ_ResultSpec
TALER_SQ_result_spec_amount_nbo (const char *currency,
struct TALER_AmountNBO *amount)
@ -153,7 +167,7 @@ TALER_SQ_result_spec_amount_nbo (const char *currency,
* #GNUNET_YES if all results could be extracted
* #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
*/
static enum GNUNET_GenericReturnValue
static int
extract_json (void *cls,
sqlite3_stmt *result,
unsigned int column,
@ -234,4 +248,138 @@ TALER_SQ_result_spec_json (json_t **jp)
}
/**
* Extract amount data from a SQLite database
*
* @param cls closure
* @param result where to extract data from
* @param column column to extract data from
* @param[in,out] dst_size where to store size of result, may be NULL
* @param[out] dst where to store the result
* @return
* #GNUNET_YES if all results could be extracted
* #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
*/
static int
extract_round_time (void *cls,
sqlite3_stmt *result,
unsigned int column,
size_t *dst_size,
void *dst)
{
struct GNUNET_TIME_Absolute *udst = dst;
struct GNUNET_TIME_Absolute tmp;
(void) cls;
if (SQLITE_INTEGER != sqlite3_column_type (result,
(int) column))
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
GNUNET_assert (NULL != dst);
if (sizeof (struct GNUNET_TIME_Absolute) != *dst_size)
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
tmp.abs_value_us = sqlite3_column_int64 (result,
(int) column);
GNUNET_break (GNUNET_OK ==
GNUNET_TIME_round_abs (&tmp));
*udst = tmp;
return GNUNET_OK;
}
/**
* Rounded absolute time expected.
* In contrast to #GNUNET_SQ_query_param_absolute_time_nbo(),
* this function ensures that the result is rounded and can
* be converted to JSON.
*
* @param[out] at where to store the result
* @return array entry for the result specification to use
*/
struct GNUNET_SQ_ResultSpec
TALER_SQ_result_spec_absolute_time (struct GNUNET_TIME_Absolute *at)
{
struct GNUNET_SQ_ResultSpec res = {
.conv = &extract_round_time,
.dst = (void *) at,
.dst_size = sizeof (struct GNUNET_TIME_Absolute),
.num_params = 1
};
return res;
}
/**
* Extract amount data from a SQLite database
*
* @param cls closure
* @param result where to extract data from
* @param column column to extract data from
* @param[in,out] dst_size where to store size of result, may be NULL
* @param[out] dst where to store the result
* @return
* #GNUNET_YES if all results could be extracted
* #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
*/
static int
extract_round_time_nbo (void *cls,
sqlite3_stmt *result,
unsigned int column,
size_t *dst_size,
void *dst)
{
struct GNUNET_TIME_AbsoluteNBO *udst = dst;
struct GNUNET_TIME_Absolute tmp;
(void) cls;
if (SQLITE_INTEGER != sqlite3_column_type (result,
(int) column))
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
GNUNET_assert (NULL != dst);
if (sizeof (struct GNUNET_TIME_AbsoluteNBO) != *dst_size)
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
tmp.abs_value_us = sqlite3_column_int64 (result,
(int) column);
GNUNET_break (GNUNET_OK ==
GNUNET_TIME_round_abs (&tmp));
*udst = GNUNET_TIME_absolute_hton (tmp);
return GNUNET_OK;
}
/**
* Rounded absolute time expected.
* In contrast to #GNUNET_SQ_result_spec_absolute_time_nbo(),
* this function ensures that the result is rounded and can
* be converted to JSON.
*
* @param[out] at where to store the result
* @return array entry for the result specification to use
*/
struct GNUNET_SQ_ResultSpec
TALER_SQ_result_spec_absolute_time_nbo (struct GNUNET_TIME_AbsoluteNBO *at)
{
struct GNUNET_SQ_ResultSpec res = {
.conv = &extract_round_time_nbo,
.dst = (void *) at,
.dst_size = sizeof (struct GNUNET_TIME_AbsoluteNBO),
.num_params = 1
};
return res;
}
/* end of sq/sq_result_helper.c */

28
src/sq/test_sq.c
View File

@ -33,6 +33,8 @@ run_queries (sqlite3 *db)
struct TALER_Amount hamount;
struct TALER_AmountNBO namount;
json_t *json;
struct GNUNET_TIME_Absolute htime = GNUNET_TIME_absolute_get ();
struct GNUNET_TIME_AbsoluteNBO ntime;
sqlite3_stmt *test_insert;
sqlite3_stmt *test_select;
struct GNUNET_SQ_PrepareStatement ps[] = {
@ -42,8 +44,10 @@ run_queries (sqlite3 *db)
",namount_val"
",namount_frac"
",json"
",htime"
",ntime"
") VALUES "
"($1, $2, $3, $4, $5)",
"($1, $2, $3, $4, $5, $6, $7)",
&test_insert),
GNUNET_SQ_make_prepare ("SELECT"
" hamount_val"
@ -51,6 +55,8 @@ run_queries (sqlite3 *db)
",namount_val"
",namount_frac"
",json"
",htime"
",ntime"
" FROM test_sq",
&test_select),
GNUNET_SQ_PREPARE_END
@ -65,15 +71,19 @@ run_queries (sqlite3 *db)
json = json_object ();
json_object_set_new (json, "foo", json_integer (42));
GNUNET_assert (NULL != json);
GNUNET_assert (GNUNET_OK ==
GNUNET_SQ_prepare (db,
ps));
GNUNET_TIME_round_abs (&htime);
ntime = GNUNET_TIME_absolute_hton (htime);
GNUNET_assert (GNUNET_OK == GNUNET_SQ_prepare (db,
ps));
{
struct GNUNET_SQ_QueryParam params_insert[] = {
TALER_SQ_query_param_amount (&hamount),
TALER_SQ_query_param_amount_nbo (&namount),
TALER_SQ_query_param_json (json),
TALER_SQ_query_param_absolute_time (&htime),
TALER_SQ_query_param_absolute_time_nbo (&ntime),
GNUNET_SQ_query_param_end
};
GNUNET_SQ_reset (db,
@ -89,6 +99,8 @@ run_queries (sqlite3 *db)
struct TALER_AmountNBO nresult_amount;
struct TALER_Amount nresult_amount_converted;
json_t *result_json;
struct GNUNET_TIME_Absolute hresult_time;
struct GNUNET_TIME_AbsoluteNBO nresult_time;
struct GNUNET_SQ_QueryParam params_select[] = {
GNUNET_SQ_query_param_end
};
@ -98,6 +110,8 @@ run_queries (sqlite3 *db)
TALER_SQ_result_spec_amount_nbo ("EUR",
&nresult_amount),
TALER_SQ_result_spec_json (&result_json),
TALER_SQ_result_spec_absolute_time (&hresult_time),
TALER_SQ_result_spec_absolute_time_nbo (&nresult_time),
GNUNET_SQ_result_spec_end
};
@ -120,7 +134,9 @@ run_queries (sqlite3 *db)
(0 != TALER_amount_cmp (&hamount,
&nresult_amount_converted)) ||
(1 != json_equal (json,
result_json)) )
result_json)) ||
(htime.abs_value_us != hresult_time.abs_value_us) ||
(ntime.abs_value_us__ != nresult_time.abs_value_us__))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Result from database doesn't match input\n");
@ -146,6 +162,8 @@ main (int argc,
",namount_val INT8 NOT NULL"
",namount_frac INT8 NOT NULL"
",json VARCHAR NOT NULL"
",htime INT8 NOT NULL"
",ntime INT8 NOT NULL"
")"),
GNUNET_SQ_EXECUTE_STATEMENT_END
};

48
src/testing/test_taler_exchange_aggregator.c
View File

@ -111,7 +111,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:1",
"EUR:0.1"),
@ -130,7 +130,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:1",
"EUR:0.1"),
@ -139,7 +139,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:1",
"EUR:0.1"),
@ -159,7 +159,7 @@ run (void *cls,
&dbc,
"bob",
"4",
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:1",
"EUR:0.1"),
@ -167,7 +167,7 @@ run (void *cls,
&dbc,
"bob",
"5",
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:1",
"EUR:0.1"),
@ -175,7 +175,7 @@ run (void *cls,
&dbc,
"alice",
"4",
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:1",
"EUR:0.1"),
@ -204,7 +204,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS,
5),
@ -214,7 +214,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS,
5),
@ -240,7 +240,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS,
10),
@ -251,7 +251,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS,
5),
@ -276,7 +276,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:0.102",
"EUR:0.1"),
@ -288,7 +288,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:0.102",
"EUR:0.1"),
@ -296,7 +296,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:0.102",
"EUR:0.1"),
@ -308,7 +308,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:0.102",
"EUR:0.1"),
@ -320,7 +320,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:0.112",
"EUR:0.1"),
@ -337,7 +337,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:0.109",
"EUR:0.1"),
@ -349,7 +349,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:0.119",
"EUR:0.1"),
@ -366,7 +366,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:0.122",
"EUR:0.1"),
@ -383,7 +383,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS,
5),
@ -397,7 +397,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS,
5),
@ -413,7 +413,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:0.122",
"EUR:0.1"),
@ -430,7 +430,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS,
5),
@ -444,7 +444,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS,
5),
@ -460,7 +460,7 @@ run (void *cls,
&dbc,
"bob",
USER42_ACCOUNT,
GNUNET_TIME_timestamp_get (),
GNUNET_TIME_absolute_get (),
GNUNET_TIME_UNIT_ZERO,
"EUR:0.112",
"EUR:0.1"),

5
src/testing/testing_api_cmd_auditor_add.c
View File

@ -102,11 +102,12 @@ auditor_add_run (void *cls,
struct TALER_TESTING_Interpreter *is)
{
struct AuditorAddState *ds = cls;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
struct TALER_MasterSignatureP master_sig;
(void) cmd;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
ds->is = is;
if (ds->bad_sig)
{

5
src/testing/testing_api_cmd_auditor_del.c
View File

@ -103,10 +103,11 @@ auditor_del_run (void *cls,
{
struct AuditorDelState *ds = cls;
struct TALER_MasterSignatureP master_sig;
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
(void) cmd;
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
ds->is = is;
if (ds->bad_sig)
{

26
src/testing/testing_api_cmd_auditor_deposit_confirmation.c
View File

@ -204,11 +204,11 @@ deposit_confirmation_run (void *cls,
const struct TALER_TESTING_Command *deposit_cmd;
struct TALER_MerchantWireHash h_wire;
struct TALER_PrivateContractHash h_contract_terms;
const struct GNUNET_TIME_Timestamp *exchange_timestamp = NULL;
struct GNUNET_TIME_Timestamp timestamp;
const struct GNUNET_TIME_Timestamp *wire_deadline;
struct GNUNET_TIME_Timestamp refund_deadline
= GNUNET_TIME_UNIT_ZERO_TS;
const struct GNUNET_TIME_Absolute *exchange_timestamp = NULL;
struct GNUNET_TIME_Absolute timestamp;
const struct GNUNET_TIME_Absolute *wire_deadline;
struct GNUNET_TIME_Absolute refund_deadline
= GNUNET_TIME_UNIT_ZERO_ABS;
struct TALER_Amount amount_without_fee;
struct TALER_CoinSpendPublicKeyP coin_pub;
const struct TALER_MerchantPrivateKeyP *merchant_priv;
@ -243,9 +243,9 @@ deposit_confirmation_run (void *cls,
dcs->coin_index,
&exchange_sig));
GNUNET_assert (GNUNET_OK ==
TALER_TESTING_get_trait_timestamp (deposit_cmd,
dcs->coin_index,
&exchange_timestamp));
TALER_TESTING_get_trait_absolute_time (deposit_cmd,
dcs->coin_index,
&exchange_timestamp));
GNUNET_assert (GNUNET_OK ==
TALER_TESTING_get_trait_wire_deadline (deposit_cmd,
dcs->coin_index,
@ -287,11 +287,11 @@ deposit_confirmation_run (void *cls,
{
struct GNUNET_JSON_Specification spec[] = {
/* timestamp is mandatory */
GNUNET_JSON_spec_timestamp ("timestamp",
&timestamp),
TALER_JSON_spec_absolute_time ("timestamp",
&timestamp),
GNUNET_JSON_spec_mark_optional (
GNUNET_JSON_spec_timestamp ("refund_deadline",
&refund_deadline)),
TALER_JSON_spec_absolute_time ("refund_deadline",
&refund_deadline)),
GNUNET_JSON_spec_end ()
};
@ -304,7 +304,7 @@ deposit_confirmation_run (void *cls,
TALER_TESTING_interpreter_fail (is);
return;
}
if (GNUNET_TIME_absolute_is_zero (refund_deadline.abs_time))
if (0 == refund_deadline.abs_value_us)
refund_deadline = timestamp;
}
dcs->dc = TALER_AUDITOR_deposit_confirmation (dcs->auditor,

8
src/testing/testing_api_cmd_bank_admin_add_incoming.c
View File

@ -117,7 +117,7 @@ struct AdminAddIncomingState
/**
* Timestamp of the transaction (as returned from the bank).
*/
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
/**
* Merchant instance. Sometimes used to get the tip reserve
@ -207,7 +207,7 @@ confirmation_cb (void *cls,
unsigned int http_status,
enum TALER_ErrorCode ec,
uint64_t serial_id,
struct GNUNET_TIME_Timestamp timestamp,
struct GNUNET_TIME_Absolute timestamp,
const json_t *json)
{
struct AdminAddIncomingState *fts = cls;
@ -432,7 +432,7 @@ admin_add_incoming_traits (void *cls,
TALER_TESTING_make_trait_exchange_bank_account_url (
&fts->exchange_credit_url),
TALER_TESTING_make_trait_amount (&fts->amount),
TALER_TESTING_make_trait_timestamp (0, &fts->timestamp),
TALER_TESTING_make_trait_absolute_time (0, &fts->timestamp),
TALER_TESTING_make_trait_reserve_priv (&fts->reserve_priv),
TALER_TESTING_make_trait_reserve_pub (&fts->reserve_pub),
TALER_TESTING_make_trait_reserve_history (&fts->reserve_history),
@ -454,7 +454,7 @@ admin_add_incoming_traits (void *cls,
TALER_TESTING_make_trait_exchange_bank_account_url (
&fts->exchange_credit_url),
TALER_TESTING_make_trait_amount (&fts->amount),
TALER_TESTING_make_trait_timestamp (0, &fts->timestamp),
TALER_TESTING_make_trait_absolute_time (0, &fts->timestamp),
TALER_TESTING_make_trait_reserve_pub (&fts->reserve_pub),
TALER_TESTING_make_trait_reserve_history (&fts->reserve_history),
TALER_TESTING_trait_end ()

6
src/testing/testing_api_cmd_bank_transfer.c
View File

@ -97,7 +97,7 @@ struct TransferState
/**
* Timestamp of the transaction (as returned from the bank).
*/
struct GNUNET_TIME_Timestamp timestamp;
struct GNUNET_TIME_Absolute timestamp;
/**
* Configuration filename. Used to get the tip reserve key
@ -175,7 +175,7 @@ confirmation_cb (void *cls,
unsigned int http_status,
enum TALER_ErrorCode ec,
uint64_t serial_id,
struct GNUNET_TIME_Timestamp timestamp)
struct GNUNET_TIME_Absolute timestamp)
{
struct TransferState *fts = cls;
struct TALER_TESTING_Interpreter *is = fts->is;
@ -326,7 +326,7 @@ transfer_traits (void *cls,
TALER_TESTING_make_trait_debit_payto_uri (
(const char **) &fts->payto_debit_account),
TALER_TESTING_make_trait_amount (&fts->amount),
TALER_TESTING_make_trait_timestamp (0, &fts->timestamp),
TALER_TESTING_make_trait_absolute_time (0, &fts->timestamp),
TALER_TESTING_make_trait_wtid (&fts->wtid),
TALER_TESTING_trait_end ()
};

23
src/testing/testing_api_cmd_check_keys.c
View File

@ -1,6 +1,6 @@
/*
This file is part of TALER
(C) 2018, 2020, 2021 Taler Systems SA
(C) 2018, 2020 Taler Systems SA
TALER is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as
@ -55,7 +55,7 @@ struct CheckKeysState
/**
* Last denomination date we received when doing this request.
*/
struct GNUNET_TIME_Timestamp my_denom_date;
struct GNUNET_TIME_Absolute my_denom_date;
};
@ -80,7 +80,7 @@ check_keys_run (void *cls,
is->key_generation);
if (is->key_generation < cks->generation)
{
struct GNUNET_TIME_Timestamp rdate;
struct GNUNET_TIME_Absolute rdate;
is->working = GNUNET_NO;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
@ -93,11 +93,11 @@ check_keys_run (void *cls,
{
TALER_LOG_DEBUG ("Forcing last_denom_date URL argument set to zero\n");
TALER_EXCHANGE_set_last_denom (is->exchange,
GNUNET_TIME_UNIT_ZERO_TS);
GNUNET_TIME_UNIT_ZERO_ABS);
}
else
{
const struct GNUNET_TIME_Timestamp *last_denom_date;
const struct GNUNET_TIME_Absolute *last_denom_date;
const struct TALER_TESTING_Command *ref;
ref = TALER_TESTING_interpreter_lookup_command (is,
@ -109,9 +109,9 @@ check_keys_run (void *cls,
return;
}
if (GNUNET_OK !=
TALER_TESTING_get_trait_timestamp (ref,
0,
&last_denom_date))
TALER_TESTING_get_trait_absolute_time (ref,
0,
&last_denom_date))
{
GNUNET_break (0);
TALER_TESTING_interpreter_fail (is);
@ -130,7 +130,8 @@ check_keys_run (void *cls,
? TALER_EXCHANGE_CKF_FORCE_ALL_NOW
: TALER_EXCHANGE_CKF_FORCE_DOWNLOAD);
/* Redownload /keys. */
GNUNET_break (GNUNET_TIME_absolute_is_zero (rdate.abs_time));
GNUNET_break (0 ==
rdate.abs_value_us);
return;
}
{
@ -185,8 +186,8 @@ check_keys_traits (void *cls,
struct CheckKeysState *cks = cls;
struct TALER_TESTING_Trait traits[] = {
/* history entry MUST be first due to response code logic below! */
TALER_TESTING_make_trait_timestamp (0,
&cks->my_denom_date),
TALER_TESTING_make_trait_absolute_time (0,
&cks->my_denom_date),
TALER_TESTING_trait_end ()
};

48
src/testing/testing_api_cmd_deposit.c
View File

@ -82,12 +82,12 @@ struct DepositState
/**
* Refund deadline. Zero for no refunds.
*/
struct GNUNET_TIME_Timestamp refund_deadline;
struct GNUNET_TIME_Absolute refund_deadline;
/**
* Wire deadline.
*/
struct GNUNET_TIME_Timestamp wire_deadline;
struct GNUNET_TIME_Absolute wire_deadline;
/**
* Set (by the interpreter) to a fresh private key. This
@ -103,7 +103,7 @@ struct DepositState
/**
* Timestamp of the /deposit operation in the wallet (contract signing time).
*/
struct GNUNET_TIME_Timestamp wallet_timestamp;
struct GNUNET_TIME_Absolute wallet_timestamp;
/**
* Interpreter state.
@ -139,7 +139,7 @@ struct DepositState
/**
* When did the exchange receive the deposit?
*/
struct GNUNET_TIME_Timestamp exchange_timestamp;
struct GNUNET_TIME_Absolute exchange_timestamp;
/**
* Signing key used by the exchange to sign the
@ -402,25 +402,27 @@ deposit_run (void *cls,
GNUNET_CRYPTO_eddsa_key_get_public (&coin_priv->eddsa_priv,
&coin_pub.eddsa_pub);
if (! GNUNET_TIME_absolute_is_zero (ds->refund_deadline.abs_time))
if (0 != ds->refund_deadline.abs_value_us)
{
struct GNUNET_TIME_Relative refund_deadline;
refund_deadline
= GNUNET_TIME_absolute_get_remaining (ds->refund_deadline.abs_time);
= GNUNET_TIME_absolute_get_remaining (ds->refund_deadline);
ds->wire_deadline
=
GNUNET_TIME_relative_to_timestamp (
= GNUNET_TIME_relative_to_absolute (
GNUNET_TIME_relative_multiply (refund_deadline,
2));
}
else
{
ds->refund_deadline = ds->wallet_timestamp;
ds->wire_deadline = GNUNET_TIME_timestamp_get ();
ds->wire_deadline
= GNUNET_TIME_relative_to_absolute (
GNUNET_TIME_UNIT_ZERO);
}
GNUNET_CRYPTO_eddsa_key_get_public (&ds->merchant_priv.eddsa_priv,
&merchant_pub.eddsa_pub);
(void) GNUNET_TIME_round_abs (&ds->wire_deadline);
{
struct TALER_MerchantWireHash h_wire;
@ -560,8 +562,8 @@ deposit_traits (void *cls,
TALER_TESTING_make_trait_merchant_priv (&ds->merchant_priv),
TALER_TESTING_make_trait_deposit_amount (&ds->amount),
TALER_TESTING_make_trait_deposit_fee_amount (&ds->deposit_fee),
TALER_TESTING_make_trait_timestamp (0,
&ds->exchange_timestamp),
TALER_TESTING_make_trait_absolute_time (0,
&ds->exchange_timestamp),
TALER_TESTING_make_trait_wire_deadline (0,
&ds->wire_deadline),
TALER_TESTING_make_trait_refund_deadline (0,
@ -608,19 +610,22 @@ TALER_TESTING_cmd_deposit (const char *label,
label);
GNUNET_assert (0);
}
ds->wallet_timestamp = GNUNET_TIME_timestamp_get ();
ds->wallet_timestamp = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&ds->wallet_timestamp);
GNUNET_assert (0 ==
json_object_set_new (ds->contract_terms,
"timestamp",
GNUNET_JSON_from_timestamp (
GNUNET_JSON_from_time_abs (
ds->wallet_timestamp)));
if (! GNUNET_TIME_relative_is_zero (refund_deadline))
if (0 != refund_deadline.rel_value_us)
{
ds->refund_deadline = GNUNET_TIME_relative_to_timestamp (refund_deadline);
ds->refund_deadline = GNUNET_TIME_relative_to_absolute (refund_deadline);
(void) GNUNET_TIME_round_abs (&ds->refund_deadline);
GNUNET_assert (0 ==
json_object_set_new (ds->contract_terms,
"refund_deadline",
GNUNET_JSON_from_timestamp (
GNUNET_JSON_from_time_abs (
ds->refund_deadline)));
}
GNUNET_assert (GNUNET_OK ==
@ -672,16 +677,19 @@ TALER_TESTING_cmd_deposit_with_ref (const char *label,
label);
GNUNET_assert (0);
}
ds->wallet_timestamp = GNUNET_TIME_timestamp_get ();
ds->wallet_timestamp = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&ds->wallet_timestamp);
json_object_set_new (ds->contract_terms,
"timestamp",
GNUNET_JSON_from_timestamp (ds->wallet_timestamp));
GNUNET_JSON_from_time_abs (ds->wallet_timestamp));
if (0 != refund_deadline.rel_value_us)
{
ds->refund_deadline = GNUNET_TIME_relative_to_timestamp (refund_deadline);
ds->refund_deadline = GNUNET_TIME_relative_to_absolute (refund_deadline);
(void) GNUNET_TIME_round_abs (&ds->refund_deadline);
json_object_set_new (ds->contract_terms,
"refund_deadline",
GNUNET_JSON_from_timestamp (ds->refund_deadline));
GNUNET_JSON_from_time_abs (ds->refund_deadline));
}
GNUNET_assert (GNUNET_OK ==
TALER_string_to_amount (amount,

35
src/testing/testing_api_cmd_insert_deposit.c
View File

@ -60,7 +60,7 @@ struct InsertDepositState
/**
* When did the exchange receive the deposit?
*/
struct GNUNET_TIME_Timestamp exchange_timestamp;
struct GNUNET_TIME_Absolute exchange_timestamp;
/**
* Amount to deposit, inclusive of deposit fee.
@ -81,23 +81,27 @@ struct InsertDepositState
static void
fake_issue (struct TALER_EXCHANGEDB_DenominationKeyInformationP *issue)
{
struct GNUNET_TIME_Timestamp now;
struct GNUNET_TIME_Absolute now;
memset (issue,
0,
sizeof (struct TALER_EXCHANGEDB_DenominationKeyInformationP));
now = GNUNET_TIME_timestamp_get ();
now = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&now);
issue->properties.start
= GNUNET_TIME_timestamp_hton (now);
= GNUNET_TIME_absolute_hton (now);
issue->properties.expire_withdraw
= GNUNET_TIME_timestamp_hton (
GNUNET_TIME_relative_to_timestamp (GNUNET_TIME_UNIT_MINUTES));
= GNUNET_TIME_absolute_hton (
GNUNET_TIME_absolute_add (now,
GNUNET_TIME_UNIT_MINUTES));
issue->properties.expire_deposit
= GNUNET_TIME_timestamp_hton (
GNUNET_TIME_relative_to_timestamp (GNUNET_TIME_UNIT_HOURS));
= GNUNET_TIME_absolute_hton (
GNUNET_TIME_absolute_add (now,
GNUNET_TIME_UNIT_HOURS));
issue->properties.expire_legal
= GNUNET_TIME_timestamp_hton (
GNUNET_TIME_relative_to_timestamp (GNUNET_TIME_UNIT_DAYS));
= GNUNET_TIME_absolute_hton (
GNUNET_TIME_absolute_add (now,
GNUNET_TIME_UNIT_DAYS));
GNUNET_assert (GNUNET_OK ==
TALER_string_to_amount_nbo ("EUR:1",
&issue->properties.value));
@ -231,9 +235,11 @@ insert_deposit_run (void *cls,
memset (&deposit.wire_salt,
46,
sizeof (deposit.wire_salt));
deposit.timestamp = GNUNET_TIME_timestamp_get ();
deposit.wire_deadline = GNUNET_TIME_relative_to_timestamp (
ids->wire_deadline);
deposit.timestamp = GNUNET_TIME_absolute_get ();
(void) GNUNET_TIME_round_abs (&deposit.timestamp);
deposit.wire_deadline = GNUNET_TIME_relative_to_absolute (ids->wire_deadline);
(void) GNUNET_TIME_round_abs (&deposit.wire_deadline);
/* finally, actually perform the DB operation */
if ( (GNUNET_OK !=
ids->dbc->plugin->start (ids->dbc->plugin->cls,
@ -289,13 +295,14 @@ TALER_TESTING_cmd_insert_deposit (
const struct TALER_TESTING_DatabaseConnection *dbc,
const char *merchant_name,
const char *merchant_account,
struct GNUNET_TIME_Timestamp exchange_timestamp,
struct GNUNET_TIME_Absolute exchange_timestamp,
struct GNUNET_TIME_Relative wire_deadline,
const char *amount_with_fee,
const char *deposit_fee)
{
struct InsertDepositState *ids;
GNUNET_TIME_round_abs (&exchange_timestamp);
ids = GNUNET_new (struct InsertDepositState);
ids->dbc = dbc;
ids->merchant_name = merchant_name;

8
src/testing/testing_api_cmd_recoup.c
View File

@ -364,7 +364,6 @@ recoup_run (void *cls,
denom_pub,
coin_sig,
&planchet,
&ps->reserve_history.amount,
NULL != ps->melt_reference,
recoup_cb,
ps);
@ -441,9 +440,10 @@ TALER_TESTING_cmd_recoup (const char *label,
ps->expected_response_code = expected_response_code;
ps->coin_reference = coin_reference;
ps->melt_reference = melt_reference;
if (GNUNET_OK !=
TALER_string_to_amount (amount,
&ps->reserve_history.amount))
if ( (NULL != amount) &&
(GNUNET_OK !=
TALER_string_to_amount (amount,
&ps->reserve_history.amount)) )
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to parse amount `%s' at %s\n",

Some files were not shown because too many files have changed in this diff Show More