/*
This file is part of TALER
Copyright (C) 2014, 2015, 2016 GNUnet e.V. and INRIA
TALER is free software; you can redistribute it and/or modify it under the
terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2.1, 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along with
TALER; see the file COPYING.LGPL. If not, see
*/
#include "platform.h"
#include
#include
#include
#include
#include
#include "taler_merchant_service.h"
#include "taler_merchantdb_lib.h"
#include
#include
#include
/**
* The exchange process launched by the generator
*/
static struct GNUNET_OS_Process *exchanged;
/**
* The merchant process launched by the generator
*/
static struct GNUNET_OS_Process *merchantd;
/**
* How many times the command list should be rerun.
*/
static unsigned int times = 1;
/**
* Current iteration of commands
*/
static unsigned int j = 0;
/**
* Indicates whether we use an external exchange.
* By default, the generator forks a local exchange.
*/
static int remote_exchange = 0;
/**
* Indicates whether we use an external merchant.
* By default, the generator tries to fork a local
* merchant.
*/
static int remote_merchant = 0;
/**
* Exchange URI to withdraw from and deposit to.
*/
static char *exchange_uri;
/**
* Base URL of exchange's admin interface.
*/
static char *exchange_uri_admin;
/**
* Merchant backend to get proposals from and pay.
*/
static char *merchant_uri;
/**
* Customer's bank URI, communicated at withdrawal time
* to the exchange; must be the same as the exchange's bank.
*/
static char *bank_uri;
/**
* Which merchant instance we use.
*/
static char *instance;
/**
* Currency used to generate payments.
*/
static char *currency;
/**
* Task run on timeout.
*/
static struct GNUNET_SCHEDULER_Task *timeout_task;
/**
* Handle to access the exchange.
*/
static struct TALER_EXCHANGE_Handle *exchange;
/**
* Main execution context for the main loop of the exchange.
*/
static struct GNUNET_CURL_Context *ctx;
/**
* Context for running the #ctx's event loop.
*/
static struct GNUNET_CURL_RescheduleContext *rc;
/**
* Result of the testcases, #GNUNET_OK on success.
*/
static int result;
/**
* Pipe used to communicate child death via signal.
*/
static struct GNUNET_DISK_PipeHandle *sigpipe;
/**
* State of the interpreter loop.
*/
struct InterpreterState
{
/**
* Keys from the exchange.
*/
const struct TALER_EXCHANGE_Keys *keys;
/**
* Commands the interpreter will run.
*/
struct Command *commands;
/**
* Interpreter task (if one is scheduled).
*/
struct GNUNET_SCHEDULER_Task *task;
/**
* Instruction pointer. Tells #interpreter_run() which
* instruction to run next.
*/
unsigned int ip;
};
/**
* Opcodes for the interpreter.
*/
enum OpCode
{
/**
* Termination code, stops the interpreter loop (with success).
*/
OC_END = 0,
/**
* Issue a GET /proposal to the backend.
*/
OC_PROPOSAL_LOOKUP,
/**
* Add funds to a reserve by (faking) incoming wire transfer.
*/
OC_ADMIN_ADD_INCOMING,
/**
* Check status of a reserve.
*/
OC_WITHDRAW_STATUS,
/**
* Withdraw a coin from a reserve.
*/
OC_WITHDRAW_SIGN,
/**
* Issue a PUT /proposal to the backend.
*/
OC_PROPOSAL,
/**
* Pay with coins.
*/
OC_PAY
};
/**
* Details for a exchange operation to execute.
*/
struct Command
{
/**
* Opcode of the command.
*/
enum OpCode oc;
/**
* Label for the command, can be NULL.
*/
const char *label;
/**
* Which response code do we expect for this command?
*/
unsigned int expected_response_code;
/**
* Details about the command.
*/
union
{
/**
* Information for a #OC_WITHDRAW_SIGN command.
*/
struct
{
/**
* Which reserve should we withdraw from?
*/
const char *reserve_reference;
/**
* String describing the denomination value we should withdraw.
* A corresponding denomination key must exist in the exchange's
* offerings. Can be NULL if @e pk is set instead.
* The interpreter must free this value after it doesn't need it
* anymore.
*/
char *amount;
/**
* If @e amount is NULL, this specifies the denomination key to
* use. Otherwise, this will be set (by the interpreter) to the
* denomination PK matching @e amount.
*/
const struct TALER_EXCHANGE_DenomPublicKey *pk;
/**
* Set (by the interpreter) to the exchange's signature over the
* coin's public key.
*/
struct TALER_DenominationSignature sig;
/**
* Set (by the interpreter) to the coin's private key.
*/
struct TALER_CoinSpendPrivateKeyP coin_priv;
/**
* Blinding key used for the operation.
*/
struct TALER_DenominationBlindingKeyP blinding_key;
/**
* Withdraw handle (while operation is running).
*/
struct TALER_EXCHANGE_ReserveWithdrawHandle *wsh;
} reserve_withdraw;
/**
* Information for a #OC_ADMIN_ADD_INCOMING command.
*/
struct
{
/**
* Label to another admin_add_incoming command if we
* should deposit into an existing reserve, NULL if
* a fresh reserve should be created.
*/
const char *reserve_reference;
/**
* String describing the amount to add to the reserve.
*/
const char *amount;
/**
* Sender's bank account details (JSON).
*/
const char *sender_details;
/**
* Transfer details (JSON)
*/
const char *transfer_details;
/**
* Set (by the interpreter) to the reserve's private key
* we used to fill the reserve.
*/
struct TALER_ReservePrivateKeyP reserve_priv;
/**
* Set to the API's handle during the operation.
*/
struct TALER_EXCHANGE_AdminAddIncomingHandle *aih;
} admin_add_incoming;
/**
* Information for an #OC_PROPOSAL command.
*/
struct
{
/**
* Max deposit fee accepted by the merchant.
* Given in the form "CURRENCY:X.Y".
*/
char *max_fee;
/**
* Proposal overall price.
* Given in the form "CURRENCY:X.Y".
*/
char *amount;
/**
* Handle to the active PUT /proposal operation, or NULL.
*/
struct TALER_MERCHANT_ProposalOperation *po;
/**
* Full contract in JSON, set by the /contract operation.
* FIXME: verify in the code that this bit is actually proposal
* data and not the whole proposal.
*/
json_t *proposal_data;
/**
* Proposal's signature.
*/
struct TALER_MerchantSignatureP merchant_sig;
/**
* Proposal data's hashcode.
*/
struct GNUNET_HashCode hash;
} proposal;
/**
* Information for a #OC_PAY command.
* FIXME: support tests where we pay with multiple coins at once.
*/
struct
{
/**
* Reference to the contract.
*/
const char *contract_ref;
/**
* Reference to a reserve_withdraw operation for a coin to
* be used for the /deposit operation.
*/
const char *coin_ref;
/**
* If this @e coin_ref refers to an operation that generated
* an array of coins, this value determines which coin to use.
*/
unsigned int coin_idx;
/**
* Amount to pay (from the coin, including fee).
*/
const char *amount_with_fee;
/**
* Amount to pay (from the coin, excluding fee). The sum of the
* deltas between all @e amount_with_fee and the @e
* amount_without_fee must be less than max_fee, and the sum of
* the @e amount_with_fee must be larger than the @e
* total_amount.
*/
const char *amount_without_fee;
/**
* Deposit handle while operation is running.
*/
struct TALER_MERCHANT_Pay *ph;
/**
* Hashcode of the proposal data associated to this payment.
*/
struct GNUNET_HashCode h_proposal_data;
/**
* Merchant's public key
*/
struct TALER_MerchantPublicKeyP merchant_pub;
} pay;
} details;
};
/**
* Function run when the test times out.
*
* @param cls NULL
*/
static void
do_timeout (void *cls)
{
timeout_task = NULL;
GNUNET_SCHEDULER_shutdown ();
}
/**
* The generator failed, return with an error code.
*
* @param is interpreter state to clean up
*/
static void
fail (struct InterpreterState *is)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Interpreter failed at step %s (#%u)\n",
is->commands[is->ip].label,
is->ip);
result = GNUNET_SYSERR;
GNUNET_SCHEDULER_shutdown ();
}
/**
* Run the main interpreter loop that performs exchange operations.
*
* @param cls contains the `struct InterpreterState`
*/
static void
interpreter_run (void *cls);
/**
* Run the next command with the interpreter.
*
* @param is current interpeter state.
*/
static void
next_command (struct InterpreterState *is)
{
is->ip++;
is->task = GNUNET_SCHEDULER_add_now (&interpreter_run,
is);
}
/**
* Callback that works PUT /proposal's output.
*
* @param cls closure
* @param http_status HTTP response code, 200 indicates success;
* 0 if the backend's reply is bogus (fails to follow the protocol)
* @param ec taler-specific error code
* @param obj the full received JSON reply, or
* error details if the request failed
* @param proposal_data the order + additional information provided by the
* backend, NULL on error.
* @param sig merchant's signature over the contract, NULL on error
* @param h_contract hash of the contract, NULL on error
*/
static void
proposal_cb (void *cls,
unsigned int http_status,
enum TALER_ErrorCode ec,
const json_t *obj,
const json_t *proposal_data,
const struct TALER_MerchantSignatureP *sig,
const struct GNUNET_HashCode *hash)
{
struct InterpreterState *is = cls;
struct Command *cmd = &is->commands[is->ip];
cmd->details.proposal.po = NULL;
switch (http_status)
{
case MHD_HTTP_OK:
cmd->details.proposal.proposal_data = json_incref ((json_t *) proposal_data);
cmd->details.proposal.merchant_sig = *sig;
cmd->details.proposal.hash = *hash;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Hashed proposal, '%s'\n",
GNUNET_h2s (hash));
break;
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"unexpected status code from /proposal: %u. Step %u\n",
http_status,
is->ip);
json_dumpf (obj, stderr, 0);
GNUNET_break (0);
fail (is);
return;
}
next_command (is);
}
/**
* Function called with the result of a /pay operation.
*
* @param cls closure with the interpreter state
* @param http_status HTTP response code, #MHD_HTTP_OK (200) for successful deposit;
* 0 if the exchange's reply is bogus (fails to follow the protocol)
* @param ec taler-specific error code
* @param obj the received JSON reply, should be kept as proof (and, in case of errors,
* be forwarded to the customer)
*/
static void
pay_cb (void *cls,
unsigned int http_status,
enum TALER_ErrorCode ec,
const json_t *obj)
{
struct InterpreterState *is = cls;
struct Command *cmd = &is->commands[is->ip];
struct PaymentResponsePS mr;
struct GNUNET_CRYPTO_EddsaSignature sig;
struct GNUNET_HashCode h_proposal_data;
const char *error_name;
unsigned int error_line;
cmd->details.pay.ph = NULL;
if (cmd->expected_response_code != http_status)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Unexpected response code %u to command %s\n",
http_status,
cmd->label);
json_dumpf (obj, stderr, 0);
fail (is);
return;
}
if (MHD_HTTP_OK == http_status)
{
/* Check signature */
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_fixed_auto ("sig", &sig),
GNUNET_JSON_spec_fixed_auto ("h_proposal_data", &h_proposal_data),
GNUNET_JSON_spec_end ()
};
if (GNUNET_OK !=
GNUNET_JSON_parse (obj,
spec,
&error_name,
&error_line))
{
GNUNET_break_op (0);
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Parser failed on %s:%u\n",
error_name,
error_line);
fail (is);
return;
}
mr.purpose.purpose = htonl (TALER_SIGNATURE_MERCHANT_PAYMENT_OK);
mr.purpose.size = htonl (sizeof (mr));
mr.h_proposal_data = h_proposal_data;
if (GNUNET_OK !=
GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_MERCHANT_PAYMENT_OK,
&mr.purpose,
&sig,
&cmd->details.pay.merchant_pub.eddsa_pub))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Merchant signature given in response to /pay invalid\n");
fail (is);
return;
}
}
next_command (is);
}
/**
* Function called upon completion of our /admin/add/incoming request.
*
* @param cls closure with the interpreter state
* @param http_status HTTP response code, #MHD_HTTP_OK (200) for successful status request
* 0 if the exchange's reply is bogus (fails to follow the protocol)
* @param ec taler-specific error code, #TALER_EC_NONE on success
* @param full_response full response from the exchange (for logging, in case of errors)
*/
static void
add_incoming_cb (void *cls,
unsigned int http_status,
enum TALER_ErrorCode ec,
const json_t *full_response)
{
struct InterpreterState *is = cls;
struct Command *cmd = &is->commands[is->ip];
cmd->details.admin_add_incoming.aih = NULL;
if (MHD_HTTP_OK != http_status)
{
GNUNET_break (0);
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"%s",
json_dumps (full_response, JSON_INDENT (2)));
fail (is);
return;
}
next_command (is);
}
/**
* Find a command by label.
*
* @param is interpreter state to search
* @param label label to look for
* @return NULL if command was not found
*/
static const struct Command *
find_command (const struct InterpreterState *is,
const char *label)
{
unsigned int i;
const struct Command *cmd;
if (NULL == label)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Attempt to lookup command for empty label\n");
return NULL;
}
for (i=0;OC_END != (cmd = &is->commands[i])->oc;i++)
if ( (NULL != cmd->label) &&
(0 == strcmp (cmd->label,
label)) )
return cmd;
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Command not found: %s\n",
label);
return NULL;
}
/**
* Function called upon completion of our /reserve/withdraw request.
*
* @param cls closure with the interpreter state
* @param http_status HTTP response code, #MHD_HTTP_OK (200) for successful status request
* 0 if the exchange's reply is bogus (fails to follow the protocol)
* @param ec taler-specific error code
* @param sig signature over the coin, NULL on error
* @param full_response full response from the exchange (for logging, in case of errors)
*/
static void
reserve_withdraw_cb (void *cls,
unsigned int http_status,
enum TALER_ErrorCode ec,
const struct TALER_DenominationSignature *sig,
const json_t *full_response)
{
struct InterpreterState *is = cls;
struct Command *cmd = &is->commands[is->ip];
cmd->details.reserve_withdraw.wsh = NULL;
if (cmd->expected_response_code != http_status)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Unexpected response code %u to command %s\n",
http_status,
cmd->label);
json_dumpf (full_response, stderr, 0);
GNUNET_break (0);
fail (is);
return;
}
switch (http_status)
{
case MHD_HTTP_OK:
if (NULL == sig)
{
GNUNET_break (0);
fail (is);
return;
}
cmd->details.reserve_withdraw.sig.rsa_signature
= GNUNET_CRYPTO_rsa_signature_dup (sig->rsa_signature);
break;
case MHD_HTTP_PAYMENT_REQUIRED:
/* nothing to check */
break;
default:
/* Unsupported status code (by test harness) */
GNUNET_break (0);
break;
}
next_command (is);
}
/**
* Find denomination key matching the given amount.
*
* @param keys array of keys to search
* @param amount coin value to look for
* @return NULL if no matching key was found
*/
static const struct TALER_EXCHANGE_DenomPublicKey *
find_pk (const struct TALER_EXCHANGE_Keys *keys,
const struct TALER_Amount *amount)
{
unsigned int i;
struct GNUNET_TIME_Absolute now;
struct TALER_EXCHANGE_DenomPublicKey *pk;
char *str;
now = GNUNET_TIME_absolute_get ();
for (i=0;inum_denom_keys;i++)
{
pk = &keys->denom_keys[i];
if ( (0 == TALER_amount_cmp (amount,
&pk->value)) &&
(now.abs_value_us >= pk->valid_from.abs_value_us) &&
(now.abs_value_us < pk->withdraw_valid_until.abs_value_us) )
return pk;
}
/* do 2nd pass to check if expiration times are to blame for failure */
str = TALER_amount_to_string (amount);
for (i=0;inum_denom_keys;i++)
{
pk = &keys->denom_keys[i];
if ( (0 == TALER_amount_cmp (amount,
&pk->value)) &&
( (now.abs_value_us < pk->valid_from.abs_value_us) ||
(now.abs_value_us > pk->withdraw_valid_until.abs_value_us) ) )
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Have denomination key for `%s', but with wrong expiration range %llu vs [%llu,%llu)\n",
str,
(unsigned long long) now.abs_value_us,
(unsigned long long) pk->valid_from.abs_value_us,
(unsigned long long) pk->withdraw_valid_until.abs_value_us);
GNUNET_free (str);
return NULL;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"No denomination key for amount %s found\n",
str);
GNUNET_free (str);
return NULL;
}
/**
* Allocates and return a string representing a order.
* In this process, this function gives the order those
* prices specified by the user. Please NOTE that any amount
* must be given in the form "XX.YY".
*
* @param max_fee merchant's allowed max_fee
* @param amount total amount for this order
*/
json_t *
make_order (char *maxfee,
char *total)
{
struct TALER_Amount tmp_amount;
json_t *total_j;
json_t *maxfee_j;
json_t *ret;
unsigned long long id;
TALER_string_to_amount (maxfee, &tmp_amount);
maxfee_j = TALER_JSON_from_amount (&tmp_amount);
TALER_string_to_amount (total, &tmp_amount);
total_j = TALER_JSON_from_amount (&tmp_amount);
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
&id,
sizeof (id));
ret = json_pack ("{s:O, s:s, s:s, s:s, s:s, s:O, s:s, s:[{s:s}]}",
"max_fee", maxfee_j,
"order_id", TALER_b2s (&id, sizeof (id)),
"timestamp", "/Date(42)/",
"refund_deadline", "/Date(0)/",
"pay_deadline", "/Date(9999999999)/",
"amount", total_j,
"summary", "payments generator..",
"products", "description", "ice cream");
GNUNET_assert (NULL != ret);
return ret;
}
/**
* Run the main interpreter loop that performs exchange operations.
*
* @param cls contains the `struct InterpreterState`
*/
static void
interpreter_run (void *cls)
{
const struct GNUNET_SCHEDULER_TaskContext *tc;
struct InterpreterState *is = cls;
struct Command *cmd = &is->commands[is->ip];
const struct Command *ref;
struct TALER_ReservePublicKeyP reserve_pub;
struct TALER_CoinSpendPublicKeyP coin_pub;
struct TALER_Amount amount;
struct GNUNET_TIME_Absolute execution_date;
json_t *sender_details;
json_t *transfer_details;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Interpreter runs command %u/%s(%u)\n",
is->ip,
cmd->label,
cmd->oc);
is->task = NULL;
tc = GNUNET_SCHEDULER_get_task_context ();
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
{
fprintf (stderr,
"Test aborted by shutdown request\n");
fail (is);
return;
}
switch (cmd->oc)
{
case OC_END:
j++;
if (j < times)
{
is->ip = 0;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Rewinding the interpreter.\n");
GNUNET_SCHEDULER_add_now (&interpreter_run,
is);
return;
}
result = GNUNET_OK;
GNUNET_SCHEDULER_shutdown ();
return;
case OC_PAY:
{
struct TALER_MERCHANT_PayCoin pc;
const char *order_id;
struct GNUNET_TIME_Absolute refund_deadline;
struct GNUNET_TIME_Absolute pay_deadline;
struct GNUNET_TIME_Absolute timestamp;
struct GNUNET_HashCode h_wire;
struct TALER_MerchantPublicKeyP merchant_pub;
struct TALER_MerchantSignatureP merchant_sig;
struct TALER_Amount total_amount;
struct TALER_Amount max_fee;
const char *error_name;
unsigned int error_line;
/* get proposal */
ref = find_command (is,
cmd->details.pay.contract_ref);
GNUNET_assert (NULL != ref);
merchant_sig = ref->details.proposal.merchant_sig;
GNUNET_assert (NULL != ref->details.proposal.proposal_data);
{
/* Get information that need to be replied in the deposit permission */
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_string ("order_id", &order_id),
GNUNET_JSON_spec_absolute_time ("refund_deadline", &refund_deadline),
GNUNET_JSON_spec_absolute_time ("pay_deadline", &pay_deadline),
GNUNET_JSON_spec_absolute_time ("timestamp", ×tamp),
GNUNET_JSON_spec_fixed_auto ("merchant_pub", &merchant_pub),
GNUNET_JSON_spec_fixed_auto ("H_wire", &h_wire),
TALER_JSON_spec_amount ("amount", &total_amount),
TALER_JSON_spec_amount ("max_fee", &max_fee),
GNUNET_JSON_spec_end()
};
if (GNUNET_OK !=
GNUNET_JSON_parse (ref->details.proposal.proposal_data,
spec,
&error_name,
&error_line))
{
GNUNET_break_op (0);
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Parser failed on %s:%u\n",
error_name,
error_line);
fail (is);
return;
}
cmd->details.pay.merchant_pub = merchant_pub;
}
{
const struct Command *coin_ref;
memset (&pc, 0, sizeof (pc));
coin_ref = find_command (is,
cmd->details.pay.coin_ref);
GNUNET_assert (NULL != ref);
switch (coin_ref->oc)
{
case OC_WITHDRAW_SIGN:
pc.coin_priv = coin_ref->details.reserve_withdraw.coin_priv;
pc.denom_pub = coin_ref->details.reserve_withdraw.pk->key;
pc.denom_sig = coin_ref->details.reserve_withdraw.sig;
pc.denom_value = coin_ref->details.reserve_withdraw.pk->value;
break;
default:
GNUNET_assert (0);
}
if (GNUNET_OK !=
TALER_string_to_amount (cmd->details.pay.amount_without_fee,
&pc.amount_without_fee))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to parse amount `%s' at %u\n",
cmd->details.pay.amount_without_fee,
is->ip);
fail (is);
return;
}
if (GNUNET_OK !=
TALER_string_to_amount (cmd->details.pay.amount_with_fee,
&pc.amount_with_fee))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to parse amount `%s' at %u\n",
cmd->details.pay.amount_with_fee,
is->ip);
fail (is);
return;
}
}
cmd->details.pay.ph
= TALER_MERCHANT_pay_wallet (ctx,
merchant_uri,
instance,
&ref->details.proposal.hash,
&total_amount,
&max_fee,
&merchant_pub,
&merchant_sig,
timestamp,
refund_deadline,
pay_deadline,
&h_wire,
exchange_uri,
order_id,
1 /* num_coins */,
&pc /* coins */,
&pay_cb,
is);
}
if (NULL == cmd->details.pay.ph)
{
GNUNET_break (0);
fail (is);
return;
}
return;
case OC_PROPOSAL:
{
json_t *order;
json_t *merchant_obj;
order = make_order (cmd->details.proposal.max_fee,
cmd->details.proposal.amount);
if (NULL == order)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to create the order at command #%u\n",
is->ip);
fail (is);
return;
}
GNUNET_assert (NULL != (merchant_obj = json_pack ("{s:{s:s}}",
"merchant",
"instance",
instance)));
GNUNET_assert (-1 != json_object_update (order, merchant_obj));
cmd->details.proposal.po
= TALER_MERCHANT_order_put (ctx,
merchant_uri,
order,
&proposal_cb,
is);
json_decref (order);
if (NULL == cmd->details.proposal.po)
{
GNUNET_break (0);
fail (is);
return;
}
return;
}
case OC_ADMIN_ADD_INCOMING:
if (NULL !=
cmd->details.admin_add_incoming.reserve_reference)
{
ref = find_command (is,
cmd->details.admin_add_incoming.reserve_reference);
GNUNET_assert (NULL != ref);
GNUNET_assert (OC_ADMIN_ADD_INCOMING == ref->oc);
cmd->details.admin_add_incoming.reserve_priv
= ref->details.admin_add_incoming.reserve_priv;
}
else
{
struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
priv = GNUNET_CRYPTO_eddsa_key_create ();
cmd->details.admin_add_incoming.reserve_priv.eddsa_priv = *priv;
GNUNET_free (priv);
}
GNUNET_CRYPTO_eddsa_key_get_public (&cmd->details.admin_add_incoming.reserve_priv.eddsa_priv,
&reserve_pub.eddsa_pub);
if (GNUNET_OK !=
TALER_string_to_amount (cmd->details.admin_add_incoming.amount,
&amount))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to parse amount `%s' at %u\n",
cmd->details.admin_add_incoming.amount,
is->ip);
fail (is);
return;
}
execution_date = GNUNET_TIME_absolute_get ();
GNUNET_TIME_round_abs (&execution_date);
sender_details = json_loads (cmd->details.admin_add_incoming.sender_details,
JSON_REJECT_DUPLICATES,
NULL);
if (NULL == sender_details)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to parse sender details `%s' at %u\n",
cmd->details.admin_add_incoming.sender_details,
is->ip);
fail (is);
return;
}
json_object_set (sender_details, "bank_uri", json_string (bank_uri));
transfer_details = json_loads (cmd->details.admin_add_incoming.transfer_details,
JSON_REJECT_DUPLICATES,
NULL);
if (NULL == transfer_details)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to parse transfer details `%s' at %u\n",
cmd->details.admin_add_incoming.transfer_details,
is->ip);
fail (is);
return;
}
cmd->details.admin_add_incoming.aih
= TALER_EXCHANGE_admin_add_incoming (exchange,
exchange_uri_admin,
&reserve_pub,
&amount,
execution_date,
sender_details,
transfer_details,
&add_incoming_cb,
is);
json_decref (sender_details);
json_decref (transfer_details);
if (NULL == cmd->details.admin_add_incoming.aih)
{
GNUNET_break (0);
fail (is);
return;
}
return;
case OC_WITHDRAW_SIGN:
GNUNET_assert (NULL !=
cmd->details.reserve_withdraw.reserve_reference);
ref = find_command (is,
cmd->details.reserve_withdraw.reserve_reference);
GNUNET_assert (NULL != ref);
GNUNET_assert (OC_ADMIN_ADD_INCOMING == ref->oc);
if (NULL != cmd->details.reserve_withdraw.amount)
{
if (GNUNET_OK !=
TALER_string_to_amount (cmd->details.reserve_withdraw.amount,
&amount))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to parse amount `%s' at %u\n",
cmd->details.reserve_withdraw.amount,
is->ip);
fail (is);
return;
}
cmd->details.reserve_withdraw.pk = find_pk (is->keys,
&amount);
}
if (NULL == cmd->details.reserve_withdraw.pk)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to determine denomination key at %u\n",
is->ip);
fail (is);
return;
}
/* create coin's private key */
{
struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
priv = GNUNET_CRYPTO_eddsa_key_create ();
cmd->details.reserve_withdraw.coin_priv.eddsa_priv = *priv;
GNUNET_free (priv);
}
GNUNET_CRYPTO_eddsa_key_get_public (&cmd->details.reserve_withdraw.coin_priv.eddsa_priv,
&coin_pub.eddsa_pub);
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
&cmd->details.reserve_withdraw.blinding_key,
sizeof (cmd->details.reserve_withdraw.blinding_key));
cmd->details.reserve_withdraw.wsh
= TALER_EXCHANGE_reserve_withdraw (exchange,
cmd->details.reserve_withdraw.pk,
&ref->details.admin_add_incoming.reserve_priv,
&cmd->details.reserve_withdraw.coin_priv,
&cmd->details.reserve_withdraw.blinding_key,
&reserve_withdraw_cb,
is);
if (NULL == cmd->details.reserve_withdraw.wsh)
{
GNUNET_break (0);
fail (is);
return;
}
return;
default:
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Unknown command, OC: %d, label: %s.\n",
cmd->oc,
cmd->label);
fail (is);
}
}
/**
* Functions of this type are called to provide the retrieved signing and
* denomination keys of the exchange. No TALER_EXCHANGE_*() functions should
* be called in this callback.
*
* @param cls closure
* @param keys information about keys of the exchange
*/
static void
cert_cb (void *cls,
const struct TALER_EXCHANGE_Keys *keys)
{
struct InterpreterState *is = cls;
/* check that keys is OK */
#define ERR(cond) do { if(!(cond)) break; GNUNET_break (0); GNUNET_SCHEDULER_shutdown(); return; } while (0)
ERR (NULL == keys);
ERR (0 == keys->num_sign_keys);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Read %u signing keys\n",
keys->num_sign_keys);
ERR (0 == keys->num_denom_keys);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Read %u denomination keys\n",
keys->num_denom_keys);
#undef ERR
/* run actual tests via interpreter-loop */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Certificate callback invoked, starting interpreter\n");
is->keys = keys;
is->task = GNUNET_SCHEDULER_add_now (&interpreter_run,
is);
}
/**
* Signal handler called for SIGCHLD. Triggers the
* respective handler by writing to the trigger pipe.
*/
static void
sighandler_child_death ()
{
static char c;
int old_errno = errno; /* back-up errno */
GNUNET_break (1 ==
GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
(sigpipe, GNUNET_DISK_PIPE_END_WRITE),
&c, sizeof (c)));
errno = old_errno; /* restore errno */
}
/**
* Function run when the test terminates (good or bad).
* Cleans up our state.
*
* @param cls the interpreter state.
*/
static void
do_shutdown (void *cls)
{
struct InterpreterState *is = cls;
struct Command *cmd;
if (NULL != timeout_task)
{
GNUNET_SCHEDULER_cancel (timeout_task);
timeout_task = NULL;
}
for (unsigned int i=0;OC_END != (cmd = &is->commands[i])->oc;i++)
switch (cmd->oc)
{
case OC_END:
GNUNET_assert (0);
break;
case OC_PAY:
if (NULL != cmd->details.pay.ph)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Command %u (%s) did not complete\n",
i,
cmd->label);
TALER_MERCHANT_pay_cancel (cmd->details.pay.ph);
cmd->details.pay.ph = NULL;
}
break;
case OC_PROPOSAL:
if (NULL != cmd->details.proposal.po)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Command %u (%s) did not complete\n",
i,
cmd->label);
TALER_MERCHANT_proposal_cancel (cmd->details.proposal.po);
cmd->details.proposal.po = NULL;
}
if (NULL != cmd->details.proposal.proposal_data)
{
json_decref (cmd->details.proposal.proposal_data);
cmd->details.proposal.proposal_data = NULL;
}
break;
case OC_WITHDRAW_SIGN:
if (NULL != cmd->details.reserve_withdraw.wsh)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Command %u (%s) did not complete\n",
i,
cmd->label);
TALER_EXCHANGE_reserve_withdraw_cancel (cmd->details.reserve_withdraw.wsh);
cmd->details.reserve_withdraw.wsh = NULL;
}
if (NULL != cmd->details.reserve_withdraw.sig.rsa_signature)
{
GNUNET_CRYPTO_rsa_signature_free (cmd->details.reserve_withdraw.sig.rsa_signature);
cmd->details.reserve_withdraw.sig.rsa_signature = NULL;
}
GNUNET_free_non_null (cmd->details.reserve_withdraw.amount);
break;
case OC_ADMIN_ADD_INCOMING:
if (NULL != cmd->details.admin_add_incoming.aih)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Command %u (%s) did not complete\n",
i,
cmd->label);
TALER_EXCHANGE_admin_add_incoming_cancel (cmd->details.admin_add_incoming.aih);
cmd->details.admin_add_incoming.aih = NULL;
}
break;
default:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Shutdown: unknown instruction %d at %u (%s)\n",
cmd->oc,
i,
cmd->label);
break;
}
if (NULL != is->task)
{
GNUNET_SCHEDULER_cancel (is->task);
is->task = NULL;
}
GNUNET_free (is);
if (NULL != exchange)
{
TALER_EXCHANGE_disconnect (exchange);
exchange = NULL;
}
if (NULL != ctx)
{
GNUNET_CURL_fini (ctx);
ctx = NULL;
}
if (NULL != rc)
{
GNUNET_CURL_gnunet_rc_destroy (rc);
rc = NULL;
}
}
/**
* Take currency and the part after ":" in the
* "CURRENCY:XX.YY" format, and return a string
* in the format "CURRENCY:XX.YY".
*
* @param currency currency
* @param rpart float numbers after the ":", in string form
* @return pointer to allocated and concatenated "CURRENCY:XX.YY"
* formatted string.
*
*/
char *
concat_amount (char *currency, char *rpart)
{
char *str;
GNUNET_asprintf (&str, "%s:%s",
currency, rpart);
return str;
}
/**
* Main function that will be run by the scheduler.
*
* @param cls closure
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be
* NULL!)
* @param config configuration
*/
static void
run (void *cls,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *config)
{
struct InterpreterState *is;
unsigned int cnt;
char *wget_cmd;
if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (config,
"payments-generator",
"exchange",
&exchange_uri))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"payments-generator",
"exchange");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (config,
"payments-generator",
"exchange_admin",
&exchange_uri_admin))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"payments-generator",
"exchange_admin");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (config,
"payments-generator",
"merchant",
&merchant_uri))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"payments-generator",
"merchant");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (config,
"payments-generator",
"bank",
&bank_uri))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"payments-generator",
"bank");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (config,
"payments-generator",
"instance",
&instance))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"payments-generator",
"instance");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (config,
"payments-generator",
"currency",
¤cy))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"payments-generator",
"currency");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (!remote_exchange)
{
exchanged = GNUNET_OS_start_process (GNUNET_NO,
GNUNET_OS_INHERIT_STD_ALL,
NULL, NULL, NULL,
"taler-exchange-httpd",
"taler-exchange-httpd",
NULL);
if (NULL == exchanged)
{
fprintf (stderr,
"Failed to run taler-exchange-httpd. Check your PATH.\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
fprintf (stderr,
"Waiting for taler-exchange-httpd to be ready\n");
cnt = 0;
GNUNET_asprintf (&wget_cmd, "wget -q -t 1 -T 1 %skeys -o /dev/null -O /dev/null", exchange_uri);
do
{
fprintf (stderr, ".");
sleep (1);
cnt++;
if (cnt > 60)
{
fprintf (stderr,
"\nFailed to start taler-exchange-httpd\n");
GNUNET_OS_process_kill (exchanged,
SIGKILL);
GNUNET_OS_process_wait (exchanged);
GNUNET_OS_process_destroy (exchanged);
GNUNET_SCHEDULER_shutdown ();
return;
}
}
while (0 != system (wget_cmd));
GNUNET_free (wget_cmd);
fprintf (stderr, "\n");
}
if (!remote_merchant)
{
merchantd = GNUNET_OS_start_process (GNUNET_NO,
GNUNET_OS_INHERIT_STD_ALL,
NULL, NULL, NULL,
"taler-merchant-httpd",
"taler-merchant-httpd",
"-L", "DEBUG",
NULL);
if (NULL == merchantd)
{
fprintf (stderr,
"Failed to run taler-merchant-httpd. Check your PATH.\n");
GNUNET_OS_process_kill (exchanged,
SIGKILL);
GNUNET_OS_process_wait (exchanged);
GNUNET_OS_process_destroy (exchanged);
GNUNET_SCHEDULER_shutdown ();
return;
}
/* give child time to start and bind against the socket */
fprintf (stderr,
"Waiting for taler-merchant-httpd to be ready\n");
cnt = 0;
GNUNET_asprintf (&wget_cmd, "wget -q -t 1 -T 1 %s -o /dev/null -O /dev/null", merchant_uri);
do
{
fprintf (stderr, ".");
sleep (1);
cnt++;
if (cnt > 60)
{
fprintf (stderr,
"\nFailed to start taler-merchant-httpd\n");
GNUNET_OS_process_kill (merchantd,
SIGKILL);
GNUNET_OS_process_wait (merchantd);
GNUNET_OS_process_destroy (merchantd);
GNUNET_OS_process_kill (exchanged,
SIGKILL);
GNUNET_OS_process_wait (exchanged);
GNUNET_OS_process_destroy (exchanged);
GNUNET_SCHEDULER_shutdown ();
return;
}
}
while (0 != system (wget_cmd));
fprintf (stderr, "\n");
GNUNET_free (wget_cmd);
}
struct Command commands[] =
{
/* Fill reserve with EUR:5.01, as withdraw fee is 1 ct per config */
{ .oc = OC_ADMIN_ADD_INCOMING,
.label = "create-reserve-1",
.expected_response_code = MHD_HTTP_OK,
.details.admin_add_incoming.sender_details = "{ \"type\":\"test\", \"account_number\":62, \"uuid\":1 }",
.details.admin_add_incoming.transfer_details = "{ \"uuid\": 1}",
.details.admin_add_incoming.amount = concat_amount (currency, "5.01") },
/* Fill reserve with EUR:5.01, as withdraw fee is 1 ct per config */
{ .oc = OC_ADMIN_ADD_INCOMING,
.label = "create-reserve-2",
.expected_response_code = MHD_HTTP_OK,
.details.admin_add_incoming.sender_details = "{ \"type\":\"test\", \"account_number\":62, \"uuid\":1 }",
.details.admin_add_incoming.transfer_details = "{ \"uuid\": 1}",
.details.admin_add_incoming.amount = concat_amount (currency, "5.01") },
/* Fill reserve with EUR:5.01, as withdraw fee is 1 ct per config */
{ .oc = OC_ADMIN_ADD_INCOMING,
.label = "create-reserve-3",
.expected_response_code = MHD_HTTP_OK,
.details.admin_add_incoming.sender_details = "{ \"type\":\"test\", \"account_number\":62, \"uuid\":1 }",
.details.admin_add_incoming.transfer_details = "{ \"uuid\": 1}",
.details.admin_add_incoming.amount = concat_amount (currency, "5.01") },
/* Withdraw a 5 EUR coin, at fee of 1 ct */
{ .oc = OC_WITHDRAW_SIGN,
.label = "withdraw-coin-1",
.expected_response_code = MHD_HTTP_OK,
.details.reserve_withdraw.reserve_reference = "create-reserve-1",
.details.reserve_withdraw.amount = concat_amount (currency, "5") },
/* Withdraw a 5 EUR coin, at fee of 1 ct */
{ .oc = OC_WITHDRAW_SIGN,
.label = "withdraw-coin-2",
.expected_response_code = MHD_HTTP_OK,
.details.reserve_withdraw.reserve_reference = "create-reserve-2",
.details.reserve_withdraw.amount = concat_amount (currency, "5") },
/* Withdraw a 5 EUR coin, at fee of 1 ct */
{ .oc = OC_WITHDRAW_SIGN,
.label = "withdraw-coin-3",
.expected_response_code = MHD_HTTP_OK,
.details.reserve_withdraw.reserve_reference = "create-reserve-3",
.details.reserve_withdraw.amount = concat_amount (currency, "5") },
/* Create proposal */
{ .oc = OC_PROPOSAL,
.label = "create-proposal-1",
.expected_response_code = MHD_HTTP_OK,
.details.proposal.max_fee = concat_amount (currency, "0.5"),
.details.proposal.amount = concat_amount (currency, "0.5") },
/* Create proposal */
{ .oc = OC_PROPOSAL,
.label = "create-proposal-2",
.expected_response_code = MHD_HTTP_OK,
.details.proposal.max_fee = concat_amount (currency, "0.5"),
.details.proposal.amount = concat_amount (currency, "0.5") },
/* Create proposal */
{ .oc = OC_PROPOSAL,
.label = "create-proposal-3",
.expected_response_code = MHD_HTTP_OK,
.details.proposal.max_fee = concat_amount (currency, "0.5"),
.details.proposal.amount = concat_amount (currency, "5.0") },
{ .oc = OC_PAY,
.label = "deposit-simple-1",
.expected_response_code = MHD_HTTP_OK,
.details.pay.contract_ref = "create-proposal-1",
.details.pay.coin_ref = "withdraw-coin-1",
.details.pay.amount_with_fee = concat_amount (currency, "5"),
.details.pay.amount_without_fee = concat_amount (currency, "4.99") },
{ .oc = OC_PAY,
.label = "deposit-simple-2",
.expected_response_code = MHD_HTTP_OK,
.details.pay.contract_ref = "create-proposal-2",
.details.pay.coin_ref = "withdraw-coin-2",
.details.pay.amount_with_fee = concat_amount (currency, "5"),
.details.pay.amount_without_fee = concat_amount (currency, "4.99") },
{ .oc = OC_PAY,
.label = "deposit-simple-3",
.expected_response_code = MHD_HTTP_OK,
.details.pay.contract_ref = "create-proposal-3",
.details.pay.coin_ref = "withdraw-coin-3",
.details.pay.amount_with_fee = concat_amount (currency, "5"),
.details.pay.amount_without_fee = concat_amount (currency, "4.99") },
{ .oc = OC_END,
.label = "end-of-commands"}
};
is = GNUNET_new (struct InterpreterState);
is->commands = GNUNET_malloc (sizeof (commands));
memcpy (is->commands,
commands,
sizeof (commands));
ctx = GNUNET_CURL_init (&GNUNET_CURL_gnunet_scheduler_reschedule,
&rc);
GNUNET_assert (NULL != ctx);
rc = GNUNET_CURL_gnunet_rc_create (ctx);
exchange = TALER_EXCHANGE_connect (ctx,
exchange_uri,
&cert_cb,
is,
TALER_EXCHANGE_OPTION_END);
GNUNET_assert (NULL != exchange);
timeout_task
= GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 150),
&do_timeout, NULL);
GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
is);
}
int
main (int argc,
char *argv[])
{
struct GNUNET_SIGNAL_Context *shc_chld;
struct GNUNET_GETOPT_CommandLineOption options[] = {
GNUNET_GETOPT_option_uint ('n',
"times",
"TIMES",
"How many times the commands should be run.",
×),
GNUNET_GETOPT_option_flag ('e',
"remote-exchange",
"Do not fork any exchange",
&remote_exchange),
GNUNET_GETOPT_option_flag ('m',
"remote-merchant",
"Do not fork any merchant",
&remote_merchant),
GNUNET_GETOPT_OPTION_END
};
unsetenv ("XDG_DATA_HOME");
unsetenv ("XDG_CONFIG_HOME");
GNUNET_log_setup ("taler-merchant-generate-payments",
"DEBUG",
NULL);
result = GNUNET_SYSERR;
sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO,
GNUNET_NO, GNUNET_NO);
GNUNET_assert (NULL != sigpipe);
shc_chld = GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD,
&sighandler_child_death);
if (GNUNET_OK !=
GNUNET_PROGRAM_run (argc, argv,
"taler-merchant-generate-payments",
"Populates DB with fake payments",
options,
&run, NULL))
return 77;
GNUNET_SIGNAL_handler_uninstall (shc_chld);
shc_chld = NULL;
GNUNET_DISK_pipe_close (sigpipe);
if (!remote_merchant && NULL != merchantd)
{
GNUNET_OS_process_kill (merchantd,
SIGTERM);
GNUNET_OS_process_wait (merchantd);
GNUNET_OS_process_destroy (merchantd);
}
if (!remote_exchange && NULL != exchanged)
{
GNUNET_OS_process_kill (exchanged,
SIGTERM);
GNUNET_OS_process_wait (exchanged);
GNUNET_OS_process_destroy (exchanged);
}
if (77 == result)
return 77;
return (GNUNET_OK == result) ? 0 : 1;
}