/*
This file is part of TALER
Copyright (C) 2016 GNUnet e.V. & Inria
TALER is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3, or (at your option) any later version.
TALER is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
TALER; see the file COPYING. If not, If not, see
*/
/**
* @file plugin_wire_test.c
* @brief plugin for the "test" wire method
* @author Christian Grothoff
*/
#include "platform.h"
#include "taler_wire_plugin.h"
#include "taler_bank_service.h"
#include "taler_signatures.h"
#include
/* only for HTTP status codes */
#include
/**
* Type of the "cls" argument given to each of the functions in
* our API.
*/
struct TestClosure
{
/**
* Which currency do we support?
*/
char *currency;
/**
* URI of our bank.
*/
char *bank_uri;
/**
* Handle to the context for sending funds to the bank.
*/
struct GNUNET_CURL_Context *ctx;
/**
* Handle to the bank task, or NULL.
*/
struct GNUNET_SCHEDULER_Task *bt;
/**
* Number of the account that the exchange has at the bank for
* outgoing transfers.
*/
unsigned long long exchange_account_outgoing_no;
};
/**
* Handle returned by #test_prepare_wire_transfer.
*/
struct TALER_WIRE_PrepareHandle
{
/**
* Task we use for async execution.
*/
struct GNUNET_SCHEDULER_Task *task;
/**
* Test closure we run in.
*/
struct TestClosure *tc;
/**
* Wire data for the transfer.
*/
json_t *wire;
/**
* Function to call with the serialized data.
*/
TALER_WIRE_PrepareTransactionCallback ptc;
/**
* Closure for @e ptc.
*/
void *ptc_cls;
/**
* Amount to transfer.
*/
struct TALER_Amount amount;
/**
* Subject of the wire transfer.
*/
struct TALER_WireTransferIdentifierRawP wtid;
};
/**
* Handle returned by #test_execute_wire_transfer.
*/
struct TALER_WIRE_ExecuteHandle
{
/**
* Handle to the HTTP request to the bank.
*/
struct TALER_BANK_AdminAddIncomingHandle *aaih;
/**
* Function to call with the result.
*/
TALER_WIRE_ConfirmationCallback cc;
/**
* Closure for @e cc.
*/
void *cc_cls;
};
/**
* Task that runs the bank's context's event loop with the GNUnet
* scheduler.
*
* @param cls our `struct TestClosure`
*/
static void
context_task (void *cls)
{
struct TestClosure *tc = cls;
long timeout;
int max_fd;
fd_set read_fd_set;
fd_set write_fd_set;
fd_set except_fd_set;
struct GNUNET_NETWORK_FDSet *rs;
struct GNUNET_NETWORK_FDSet *ws;
struct GNUNET_TIME_Relative delay;
tc->bt = NULL;
GNUNET_CURL_perform (tc->ctx);
max_fd = -1;
timeout = -1;
FD_ZERO (&read_fd_set);
FD_ZERO (&write_fd_set);
FD_ZERO (&except_fd_set);
GNUNET_CURL_get_select_info (tc->ctx,
&read_fd_set,
&write_fd_set,
&except_fd_set,
&max_fd,
&timeout);
if (timeout >= 0)
delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
timeout);
else
delay = GNUNET_TIME_UNIT_FOREVER_REL;
rs = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_copy_native (rs,
&read_fd_set,
max_fd + 1);
ws = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_copy_native (ws,
&write_fd_set,
max_fd + 1);
tc->bt = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
delay,
rs,
ws,
&context_task,
tc);
GNUNET_NETWORK_fdset_destroy (rs);
GNUNET_NETWORK_fdset_destroy (ws);
}
/**
* Run the bank task now.
*
* @param tc context for which we should initiate running the task
*/
static void
run_bt (struct TestClosure *tc)
{
if (NULL != tc->bt)
GNUNET_SCHEDULER_cancel (tc->bt);
tc->bt = GNUNET_SCHEDULER_add_now (&context_task,
tc);
}
/**
* Round amount DOWN to the amount that can be transferred via the wire
* method. For example, Taler may support 0.000001 EUR as a unit of
* payment, but SEPA only supports 0.01 EUR. This function would
* round 0.125 EUR to 0.12 EUR in this case.
*
* @param cls the @e cls of this struct with the plugin-specific state
* @param[in,out] amount amount to round down
* @return #GNUNET_OK on success, #GNUNET_NO if rounding was unnecessary,
* #GNUNET_SYSERR if the amount or currency was invalid
*/
static int
test_amount_round (void *cls,
struct TALER_Amount *amount)
{
struct TestClosure *tc = cls;
uint32_t delta;
if (NULL == tc->currency)
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"taler",
"CURRENCY");
return GNUNET_SYSERR; /* not configured with currency */
}
if (0 != strcasecmp (amount->currency,
tc->currency))
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
/* 'test' method supports 1/100 of the unit currency, i.e. 0.01 CUR */
delta = amount->fraction % (TALER_AMOUNT_FRAC_BASE / 100);
if (0 == delta)
return GNUNET_NO;
amount->fraction -= delta;
return GNUNET_OK;
}
/**
* Compute purpose for signing.
*
* @param account number of the account
* @param bank_uri URI of the bank
* @param[out] mp purpose to be signed
*/
static void
compute_purpose (uint64_t account,
const char *bank_uri,
struct TALER_MasterWireDetailsPS *wsd)
{
struct GNUNET_HashContext *hc;
uint64_t n = GNUNET_htonll (account);
wsd->purpose.size = htonl (sizeof (struct TALER_MasterWireDetailsPS));
wsd->purpose.purpose = htonl (TALER_SIGNATURE_MASTER_TEST_DETAILS);
hc = GNUNET_CRYPTO_hash_context_start ();
GNUNET_CRYPTO_hash_context_read (hc,
"test",
strlen ("test") + 1);
GNUNET_CRYPTO_hash_context_read (hc,
&n,
sizeof (n));
GNUNET_CRYPTO_hash_context_read (hc,
bank_uri,
strlen (bank_uri) + 1);
GNUNET_CRYPTO_hash_context_finish (hc,
&wsd->h_sepa_details);
}
/**
* Check if the given wire format JSON object is correctly formatted.
* Right now, the only thing we require is a field
* "account_number" which must contain a positive 53-bit integer.
*
* @param cls the @e cls of this struct with the plugin-specific state
* @param wire the JSON wire format object
* @param master_pub public key of the exchange to verify against
* @return #GNUNET_YES if correctly formatted; #GNUNET_NO if not
*/
static int
test_wire_validate (void *cls,
const json_t *wire,
const struct TALER_MasterPublicKeyP *master_pub)
{
struct TestClosure *tc = cls;
json_error_t error;
json_int_t account_no;
const char *bank_uri;
const char *sig_s;
struct TALER_MasterWireDetailsPS wsd;
struct TALER_MasterSignatureP sig;
if (0 !=
json_unpack_ex ((json_t *) wire,
&error,
0,
"{s:I, s:s}",
"account_number", &account_no,
"bank_uri", &bank_uri))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
if ( (account_no < 0) ||
(account_no > (1LL << 53)) )
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
if ( (NULL != tc->bank_uri) &&
(0 != strcmp (bank_uri,
tc->bank_uri)) )
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Wire specifies bank URI %s, but this exchange only supports %s\n",
bank_uri,
tc->bank_uri);
return GNUNET_NO;
}
if (NULL == master_pub)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Skipping signature check as master public key not given\n");
return GNUNET_OK;
}
if (0 !=
json_unpack_ex ((json_t *) wire,
&error,
0,
"{s:s}",
"sig", &sig_s))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Signature check required, but signature is missing\n");
return GNUNET_NO;
}
compute_purpose (account_no,
bank_uri,
&wsd);
if (GNUNET_OK !=
GNUNET_STRINGS_string_to_data (sig_s,
strlen (sig_s),
&sig,
sizeof (sig)))
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
if (GNUNET_OK !=
GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_MASTER_TEST_DETAILS,
&wsd.purpose,
&sig.eddsa_signature,
&master_pub->eddsa_pub))
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
return GNUNET_YES;
}
/**
* Obtain wire transfer details in the plugin-specific format
* from the configuration.
*
* @param cls closure
* @param cfg configuration with details about wire accounts
* @param account_name which section in the configuration should we parse
* @return NULL if @a cfg fails to have valid wire details for @a account_name
*/
static json_t *
test_get_wire_details (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *account_name)
{
struct TestClosure *tc = cls;
char *test_wire_file;
json_error_t err;
json_t *ret;
/* Fetch reply */
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg,
account_name,
"TEST_RESPONSE_FILE",
&test_wire_file))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
account_name,
"TEST_RESPONSE_FILE");
return NULL;
}
ret = json_load_file (test_wire_file,
JSON_REJECT_DUPLICATES,
&err);
if (NULL == ret)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to parse JSON in %s: %s (%s:%u)\n",
test_wire_file,
err.text,
err.source,
err.line);
GNUNET_free (test_wire_file);
return NULL;
}
if (GNUNET_YES != test_wire_validate (tc,
ret,
NULL))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to validate TEST wire data in %s\n",
test_wire_file);
GNUNET_free (test_wire_file);
json_decref (ret);
return NULL;
}
GNUNET_free (test_wire_file);
return ret;
}
GNUNET_NETWORK_STRUCT_BEGIN
/**
* Format we used for serialized transaction data.
*/
struct BufFormatP
{
/**
* The wire transfer identifier.
*/
struct TALER_WireTransferIdentifierRawP wtid;
/**
* The amount.
*/
struct TALER_AmountNBO amount;
/* followed by serialized 'wire' JSON data */
};
GNUNET_NETWORK_STRUCT_END
/**
* Prepare for exeuction of a wire transfer. Calls the
* callback with the serialized state.
*
* @param cls the `struct TALER_WIRE_PrepareHandle`
*/
static void
do_prepare (void *cls)
{
struct TALER_WIRE_PrepareHandle *pth = cls;
char *wire_enc;
size_t len;
struct BufFormatP bf;
pth->task = NULL;
/* serialize the state into a 'buf' */
wire_enc = json_dumps (pth->wire,
JSON_COMPACT | JSON_SORT_KEYS);
if (NULL == wire_enc)
{
GNUNET_break (0);
pth->ptc (pth->ptc_cls,
NULL,
0);
GNUNET_free (pth);
return;
}
len = strlen (wire_enc) + 1;
bf.wtid = pth->wtid;
TALER_amount_hton (&bf.amount,
&pth->amount);
{
char buf[sizeof (struct BufFormatP) + len];
memcpy (buf,
&bf,
sizeof (struct BufFormatP));
memcpy (&buf[sizeof (struct BufFormatP)],
wire_enc,
len);
/* finally give the state back */
pth->ptc (pth->ptc_cls,
buf,
sizeof (buf));
}
free (wire_enc); /* not using GNUNET_free(),
as this one is allocated by libjansson */
GNUNET_free (pth);
}
/**
* Prepare for exeuction of a wire transfer. Note that we should call
* @a ptc asynchronously (as that is what the API requires, because
* some transfer methods need it). So while we could immediately call
* @a ptc, we first bundle up all the data and schedule a task to do
* the work.
*
* @param cls the @e cls of this struct with the plugin-specific state
* @param wire valid wire account information
* @param amount amount to transfer, already rounded
* @param wtid wire transfer identifier to use
* @param ptc function to call with the prepared data to persist
* @param ptc_cls closure for @a ptc
* @return NULL on failure
*/
static struct TALER_WIRE_PrepareHandle *
test_prepare_wire_transfer (void *cls,
const json_t *wire,
const struct TALER_Amount *amount,
const struct TALER_WireTransferIdentifierRawP *wtid,
TALER_WIRE_PrepareTransactionCallback ptc,
void *ptc_cls)
{
struct TestClosure *tc = cls;
struct TALER_WIRE_PrepareHandle *pth;
if (GNUNET_YES !=
test_wire_validate (tc,
wire,
NULL))
{
GNUNET_break_op (0);
return NULL;
}
pth = GNUNET_new (struct TALER_WIRE_PrepareHandle);
pth->tc = tc;
pth->wire = (json_t *) wire;
json_incref (pth->wire);
pth->wtid = *wtid;
pth->ptc = ptc;
pth->ptc_cls = ptc_cls;
pth->amount = *amount;
pth->task = GNUNET_SCHEDULER_add_now (&do_prepare,
pth);
return pth;
}
/**
* Abort preparation of a wire transfer. For example,
* because we are shutting down.
*
* @param cls the @e cls of this struct with the plugin-specific state
* @param pth preparation to cancel
*/
static void
test_prepare_wire_transfer_cancel (void *cls,
struct TALER_WIRE_PrepareHandle *pth)
{
GNUNET_SCHEDULER_cancel (pth->task);
json_decref (pth->wire);
GNUNET_free (pth);
}
/**
* Called with the result of submitting information about an incoming
* transaction to a bank.
*
* @param cls closure with the `struct TALER_WIRE_ExecuteHandle`
* @param http_status HTTP response code, #MHD_HTTP_OK (200) for successful status request
* 0 if the bank's reply is bogus (fails to follow the protocol)
* @param json detailed response from the HTTPD, or NULL if reply was not JSON
*/
static void
execute_cb (void *cls,
unsigned int http_status,
const json_t *json)
{
struct TALER_WIRE_ExecuteHandle *eh = cls;
json_t *reason;
const char *emsg;
char *s;
eh->aaih = NULL;
emsg = NULL;
if (NULL != json)
{
reason = json_object_get (json,
"reason");
if (NULL != reason)
emsg = json_string_value (reason);
}
if (NULL != emsg)
GNUNET_asprintf (&s,
"%u (%s)",
http_status,
emsg);
else
GNUNET_asprintf (&s,
"%u",
http_status);
eh->cc (eh->cc_cls,
(MHD_HTTP_OK == http_status) ? GNUNET_OK : GNUNET_SYSERR,
(MHD_HTTP_OK == http_status) ? NULL : s);
GNUNET_free (s);
GNUNET_free (eh);
}
/**
* Sign wire transfer details in the plugin-specific format.
*
* @param cls closure
* @param in wire transfer details in JSON format
* @param key private signing key to use
* @param salt salt to add
* @param[out] sig where to write the signature
* @return #GNUNET_OK on success
*/
static int
test_sign_wire_details (void *cls,
const json_t *in,
const struct TALER_MasterPrivateKeyP *key,
const struct GNUNET_HashCode *salt,
struct TALER_MasterSignatureP *sig)
{
struct TALER_MasterWireDetailsPS wsd;
const char *bank_uri;
const char *type;
json_int_t account;
json_error_t err;
if (0 !=
json_unpack_ex ((json_t *) in,
&err,
0 /* flags */,
"{s:s, s:s, s:I}",
"type", &type,
"bank_uri", &bank_uri,
"account_number", &account))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Failed to unpack JSON: %s (at %u)\n",
err.text,
err.position);
return GNUNET_SYSERR;
}
if (0 != strcmp (type,
"test"))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"`type' must be `test' for test wire details\n");
return GNUNET_SYSERR;
}
compute_purpose (account,
bank_uri,
&wsd);
GNUNET_CRYPTO_eddsa_sign (&key->eddsa_priv,
&wsd.purpose,
&sig->eddsa_signature);
return GNUNET_OK;
}
/**
* Execute a wire transfer.
*
* @param cls the @e cls of this struct with the plugin-specific state
* @param buf buffer with the prepared execution details
* @param buf_size number of bytes in @a buf
* @param cc function to call upon success
* @param cc_cls closure for @a cc
* @return NULL on error
*/
static struct TALER_WIRE_ExecuteHandle *
test_execute_wire_transfer (void *cls,
const char *buf,
size_t buf_size,
TALER_WIRE_ConfirmationCallback cc,
void *cc_cls)
{
struct TestClosure *tc = cls;
struct TALER_WIRE_ExecuteHandle *eh;
json_t *wire;
json_error_t error;
struct TALER_Amount amount;
json_int_t account_no;
struct BufFormatP bf;
if (NULL == tc->ctx)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Bank not initialized, cannot do transfers!\n");
return NULL; /* not initialized with configuration, cannot do transfers */
}
if ( (buf_size <= sizeof (struct BufFormatP)) ||
('\0' != buf[buf_size -1]) )
{
GNUNET_break (0);
return NULL;
}
memcpy (&bf,
buf,
sizeof (bf));
TALER_amount_ntoh (&amount,
&bf.amount);
wire = json_loads (&buf[sizeof (struct BufFormatP)],
JSON_REJECT_DUPLICATES,
NULL);
if (NULL == wire)
{
GNUNET_break (0);
return NULL;
}
GNUNET_assert (GNUNET_YES ==
test_wire_validate (tc,
wire,
NULL));
if (0 !=
json_unpack_ex (wire,
&error,
0,
"{s:I}",
"account_number", &account_no))
{
GNUNET_break (0);
return NULL;
}
eh = GNUNET_new (struct TALER_WIRE_ExecuteHandle);
eh->cc = cc;
eh->cc_cls = cc_cls;
eh->aaih = TALER_BANK_admin_add_incoming (tc->ctx,
tc->bank_uri,
&bf.wtid,
&amount,
(uint64_t) tc->exchange_account_outgoing_no,
(uint64_t) account_no,
&execute_cb,
eh);
json_decref (wire);
if (NULL == eh->aaih)
{
GNUNET_break (0);
GNUNET_free (eh);
return NULL;
}
run_bt (tc);
return eh;
}
/**
* Abort execution of a wire transfer. For example, because we are
* shutting down. Note that if an execution is aborted, it may or
* may not still succeed. The caller MUST run @e
* execute_wire_transfer again for the same request as soon as
* possilbe, to ensure that the request either ultimately succeeds
* or ultimately fails. Until this has been done, the transaction is
* in limbo (i.e. may or may not have been committed).
*
* @param cls the @e cls of this struct with the plugin-specific state
* @param eh execution to cancel
*/
static void
test_execute_wire_transfer_cancel (void *cls,
struct TALER_WIRE_ExecuteHandle *eh)
{
TALER_BANK_admin_add_incoming_cancel (eh->aaih);
GNUNET_free (eh);
}
/**
* Initialize test-wire subsystem.
*
* @param cls a configuration instance
* @return NULL on error, otherwise a `struct TALER_WIRE_Plugin`
*/
void *
libtaler_plugin_wire_test_init (void *cls)
{
struct GNUNET_CONFIGURATION_Handle *cfg = cls;
struct TestClosure *tc;
struct TALER_WIRE_Plugin *plugin;
tc = GNUNET_new (struct TestClosure);
if (NULL != cfg)
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg,
"exchange-wire-outgoing-test",
"BANK_URI",
&tc->bank_uri))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"exchange-wire-outgoing-test",
"BANK_URI");
GNUNET_free (tc);
return NULL;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg,
"exchange-wire-outgoing-test",
"EXCHANGE_ACCOUNT_NUMBER",
&tc->exchange_account_outgoing_no))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"exchange-wire-outgoing-test",
"EXCHANGE_ACCOUNT_NUMBER");
GNUNET_free (tc->bank_uri);
GNUNET_free (tc);
return NULL;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg,
"taler",
"CURRENCY",
&tc->currency))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"taler",
"CURRENCY");
GNUNET_free (tc->bank_uri);
GNUNET_free (tc);
return NULL;
}
tc->ctx = GNUNET_CURL_init ();
if (NULL == tc->ctx)
{
GNUNET_break (0);
GNUNET_free (tc->currency);
GNUNET_free (tc->bank_uri);
GNUNET_free (tc);
return NULL;
}
}
plugin = GNUNET_new (struct TALER_WIRE_Plugin);
plugin->cls = tc;
plugin->amount_round = &test_amount_round;
plugin->get_wire_details = &test_get_wire_details;
plugin->sign_wire_details = &test_sign_wire_details;
plugin->wire_validate = &test_wire_validate;
plugin->prepare_wire_transfer = &test_prepare_wire_transfer;
plugin->prepare_wire_transfer_cancel = &test_prepare_wire_transfer_cancel;
plugin->execute_wire_transfer = &test_execute_wire_transfer;
plugin->execute_wire_transfer_cancel = &test_execute_wire_transfer_cancel;
return plugin;
}
/**
* Shutdown Test wire subsystem.
*
* @param cls a `struct TALER_WIRE_Plugin`
* @return NULL (always)
*/
void *
libtaler_plugin_wire_test_done (void *cls)
{
struct TALER_WIRE_Plugin *plugin = cls;
struct TestClosure *tc = plugin->cls;
if (NULL != tc->bt)
{
GNUNET_SCHEDULER_cancel (tc->bt);
tc->bt = NULL;
}
if (NULL != tc->ctx)
{
GNUNET_CURL_fini (tc->ctx);
tc->ctx = NULL;
}
GNUNET_free_non_null (tc->currency);
GNUNET_free_non_null (tc->bank_uri);
GNUNET_free (tc);
GNUNET_free (plugin);
return NULL;
}
/* end of plugin_wire_test.c */