704 lines
20 KiB
C
704 lines
20 KiB
C
/*
|
|
This file is part of TALER
|
|
Copyright (C) 2018-2021 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
|
|
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, see
|
|
<http://www.gnu.org/licenses/>
|
|
*/
|
|
/**
|
|
* @file testing/testing_api_helpers_bank.c
|
|
* @brief convenience functions for bank tests.
|
|
* @author Marcello Stanisci
|
|
* @author Christian Grothoff
|
|
*/
|
|
#include "platform.h"
|
|
#include <gnunet/gnunet_util_lib.h>
|
|
#include "taler_testing_lib.h"
|
|
#include "taler_fakebank_lib.h"
|
|
|
|
#define BANK_FAIL() \
|
|
do {GNUNET_break (0); return NULL; } while (0)
|
|
|
|
|
|
struct TALER_FAKEBANK_Handle *
|
|
TALER_TESTING_run_fakebank (const char *bank_url,
|
|
const char *currency)
|
|
{
|
|
const char *port;
|
|
long pnum;
|
|
struct TALER_FAKEBANK_Handle *fakebankd;
|
|
|
|
port = strrchr (bank_url,
|
|
(unsigned char) ':');
|
|
if (NULL == port)
|
|
pnum = 80;
|
|
else
|
|
pnum = strtol (port + 1, NULL, 10);
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
|
|
"Starting Fakebank on port %u (%s)\n",
|
|
(unsigned int) pnum,
|
|
bank_url);
|
|
fakebankd = TALER_FAKEBANK_start ((uint16_t) pnum,
|
|
currency);
|
|
if (NULL == fakebankd)
|
|
{
|
|
GNUNET_break (0);
|
|
return NULL;
|
|
}
|
|
return fakebankd;
|
|
}
|
|
|
|
|
|
int
|
|
TALER_TESTING_has_in_name (const char *prog,
|
|
const char *marker)
|
|
{
|
|
size_t name_pos;
|
|
size_t pos;
|
|
|
|
if (! prog || ! marker)
|
|
return GNUNET_NO;
|
|
|
|
pos = 0;
|
|
name_pos = 0;
|
|
while (prog[pos])
|
|
{
|
|
if ('/' == prog[pos])
|
|
name_pos = pos + 1;
|
|
pos++;
|
|
}
|
|
if (name_pos == pos)
|
|
return GNUNET_YES;
|
|
return (NULL != strstr (prog + name_pos, marker));
|
|
}
|
|
|
|
|
|
struct TALER_TESTING_LibeufinServices
|
|
TALER_TESTING_run_libeufin (const struct TALER_TESTING_BankConfiguration *bc)
|
|
{
|
|
struct GNUNET_OS_Process *nexus_proc;
|
|
struct GNUNET_OS_Process *sandbox_proc;
|
|
struct TALER_TESTING_LibeufinServices ret = { 0 };
|
|
unsigned int iter;
|
|
char *curl_check_cmd;
|
|
const char *db_conn = "jdbc:sqlite:/tmp/libeufin-exchange-test.sqlite3";
|
|
|
|
setenv (
|
|
"LIBEUFIN_NEXUS_DB_CONNECTION",
|
|
db_conn,
|
|
1); // not overwriting any potentially existing DB.
|
|
|
|
nexus_proc = GNUNET_OS_start_process (
|
|
GNUNET_OS_INHERIT_STD_ERR,
|
|
NULL, NULL, NULL,
|
|
"libeufin-nexus",
|
|
"libeufin-nexus",
|
|
"serve",
|
|
NULL);
|
|
if (NULL == nexus_proc)
|
|
{
|
|
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
|
|
"exec",
|
|
"libeufin-nexus");
|
|
return ret;
|
|
}
|
|
GNUNET_asprintf (&curl_check_cmd,
|
|
"curl -s %s",
|
|
bc->exchange_auth.wire_gateway_url);
|
|
/* give child time to start and bind against the socket */
|
|
fprintf (stderr,
|
|
"Waiting for `nexus' to be ready (via %s)\n", curl_check_cmd);
|
|
iter = 0;
|
|
do
|
|
{
|
|
if (10 == iter)
|
|
{
|
|
fprintf (
|
|
stderr,
|
|
"Failed to launch `nexus'\n");
|
|
GNUNET_OS_process_kill (nexus_proc,
|
|
SIGTERM);
|
|
GNUNET_OS_process_wait (nexus_proc);
|
|
GNUNET_OS_process_destroy (nexus_proc);
|
|
GNUNET_free (curl_check_cmd);
|
|
GNUNET_break (0);
|
|
return ret;
|
|
}
|
|
fprintf (stderr, ".");
|
|
sleep (1);
|
|
iter++;
|
|
}
|
|
while (0 != system (curl_check_cmd));
|
|
|
|
// start sandbox.
|
|
GNUNET_free (curl_check_cmd);
|
|
fprintf (stderr, "\n");
|
|
setenv (
|
|
"LIBEUFIN_SANDBOX_DB_CONNECTION",
|
|
db_conn,
|
|
1); // not overwriting existing any potentially existing DB.
|
|
setenv (
|
|
"LIBEUFIN_SANDBOX_ADMIN_PASSWORD",
|
|
"secret",
|
|
1);
|
|
if (0 != system ("libeufin-sandbox config --currency=KUDOS default"))
|
|
{
|
|
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
|
|
"Could not create the default demobank.\n");
|
|
return ret;
|
|
}
|
|
sandbox_proc = GNUNET_OS_start_process (
|
|
GNUNET_OS_INHERIT_STD_ERR,
|
|
NULL, NULL, NULL,
|
|
"libeufin-sandbox",
|
|
"libeufin-sandbox",
|
|
"serve",
|
|
NULL);
|
|
if (NULL == sandbox_proc)
|
|
{
|
|
GNUNET_break (0);
|
|
return ret;
|
|
}
|
|
|
|
/* give child time to start and bind against the socket */
|
|
fprintf (stderr,
|
|
"Waiting for `sandbox' to be ready.\n");
|
|
iter = 0;
|
|
do
|
|
{
|
|
if (10 == iter)
|
|
{
|
|
fprintf (
|
|
stderr,
|
|
"Failed to launch `sandbox'\n");
|
|
GNUNET_OS_process_kill (sandbox_proc,
|
|
SIGTERM);
|
|
GNUNET_OS_process_wait (sandbox_proc);
|
|
GNUNET_OS_process_destroy (sandbox_proc);
|
|
GNUNET_break (0);
|
|
return ret;
|
|
}
|
|
fprintf (stderr, ".");
|
|
sleep (1);
|
|
iter++;
|
|
}
|
|
while (0 != system ("curl -s http://localhost:5000/"));
|
|
fprintf (stderr, "\n");
|
|
|
|
// Creates nexus user + bank loopback connection + Taler facade.
|
|
if (0 != system ("taler-nexus-prepare"))
|
|
{
|
|
GNUNET_OS_process_kill (nexus_proc, SIGTERM);
|
|
GNUNET_OS_process_wait (nexus_proc);
|
|
GNUNET_OS_process_destroy (nexus_proc);
|
|
GNUNET_OS_process_kill (sandbox_proc, SIGTERM);
|
|
GNUNET_OS_process_wait (sandbox_proc);
|
|
GNUNET_OS_process_destroy (sandbox_proc);
|
|
TALER_LOG_ERROR ("Could not prepare nexus\n");
|
|
GNUNET_break (0);
|
|
return ret;
|
|
}
|
|
ret.nexus = nexus_proc;
|
|
ret.sandbox = sandbox_proc;
|
|
return ret;
|
|
}
|
|
|
|
|
|
struct GNUNET_OS_Process *
|
|
TALER_TESTING_run_bank (const char *config_filename,
|
|
const char *bank_url)
|
|
{
|
|
struct GNUNET_OS_Process *bank_proc;
|
|
unsigned int iter;
|
|
char *wget_cmd;
|
|
char *database;
|
|
struct GNUNET_CONFIGURATION_Handle *cfg;
|
|
|
|
cfg = GNUNET_CONFIGURATION_create ();
|
|
if (GNUNET_OK !=
|
|
GNUNET_CONFIGURATION_load (cfg,
|
|
config_filename))
|
|
{
|
|
GNUNET_break (0);
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
exit (77);
|
|
}
|
|
|
|
if (GNUNET_OK !=
|
|
GNUNET_CONFIGURATION_get_value_string (cfg,
|
|
"bank",
|
|
"database",
|
|
&database))
|
|
{
|
|
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
|
|
"bank",
|
|
"database");
|
|
GNUNET_break (0);
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
exit (77);
|
|
}
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
bank_proc = GNUNET_OS_start_process (
|
|
GNUNET_OS_INHERIT_STD_ERR,
|
|
NULL, NULL, NULL,
|
|
"taler-bank-manage-testing",
|
|
"taler-bank-manage-testing",
|
|
config_filename,
|
|
database,
|
|
"serve", NULL);
|
|
GNUNET_free (database);
|
|
if (NULL == bank_proc)
|
|
{
|
|
BANK_FAIL ();
|
|
}
|
|
|
|
GNUNET_asprintf (&wget_cmd,
|
|
"wget -q -t 2 -T 1 %s -o /dev/null -O /dev/null",
|
|
bank_url);
|
|
|
|
/* give child time to start and bind against the socket */
|
|
fprintf (stderr,
|
|
"Waiting for `taler-bank-manage' to be ready (via %s)\n", wget_cmd);
|
|
iter = 0;
|
|
do
|
|
{
|
|
if (10 == iter)
|
|
{
|
|
fprintf (
|
|
stderr,
|
|
"Failed to launch `taler-bank-manage' (or `wget')\n");
|
|
GNUNET_OS_process_kill (bank_proc,
|
|
SIGTERM);
|
|
GNUNET_OS_process_wait (bank_proc);
|
|
GNUNET_OS_process_destroy (bank_proc);
|
|
GNUNET_free (wget_cmd);
|
|
BANK_FAIL ();
|
|
}
|
|
fprintf (stderr, ".");
|
|
sleep (1);
|
|
iter++;
|
|
}
|
|
while (0 != system (wget_cmd));
|
|
GNUNET_free (wget_cmd);
|
|
fprintf (stderr, "\n");
|
|
|
|
return bank_proc;
|
|
|
|
}
|
|
|
|
|
|
enum GNUNET_GenericReturnValue
|
|
TALER_TESTING_prepare_nexus (const char *config_filename,
|
|
int reset_db,
|
|
const char *config_section,
|
|
struct TALER_TESTING_BankConfiguration *bc)
|
|
{
|
|
struct GNUNET_CONFIGURATION_Handle *cfg;
|
|
unsigned long long port;
|
|
char *database = NULL; // silence compiler
|
|
char *exchange_payto_uri;
|
|
|
|
GNUNET_assert (0 ==
|
|
strncasecmp (config_section,
|
|
"exchange-account-",
|
|
strlen ("exchange-account-")));
|
|
cfg = GNUNET_CONFIGURATION_create ();
|
|
if (GNUNET_OK !=
|
|
GNUNET_CONFIGURATION_load (cfg,
|
|
config_filename))
|
|
{
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
GNUNET_break (0);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
|
|
if (GNUNET_OK !=
|
|
GNUNET_CONFIGURATION_get_value_string (cfg,
|
|
config_section,
|
|
"PAYTO_URI",
|
|
&exchange_payto_uri))
|
|
{
|
|
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
|
|
config_section,
|
|
"PAYTO_URI");
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
|
|
if (GNUNET_OK !=
|
|
GNUNET_CONFIGURATION_get_value_number (cfg,
|
|
"bank",
|
|
"HTTP_PORT",
|
|
&port))
|
|
{
|
|
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
|
|
"bank",
|
|
"HTTP_PORT");
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
GNUNET_free (database);
|
|
GNUNET_break (0);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
|
|
if (GNUNET_OK !=
|
|
GNUNET_NETWORK_test_port_free (IPPROTO_TCP,
|
|
(uint16_t) port))
|
|
{
|
|
fprintf (stderr,
|
|
"Required port %llu not available, skipping.\n",
|
|
port);
|
|
GNUNET_break (0);
|
|
GNUNET_free (database);
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
|
|
/* DB preparation */
|
|
if (GNUNET_YES == reset_db)
|
|
{
|
|
if (0 != system ("rm -f /tmp/libeufin-exchange-test.sqlite3"))
|
|
{
|
|
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
|
|
"Failed to invoke db-removal command.\n");
|
|
GNUNET_free (database);
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
}
|
|
|
|
{
|
|
char *csn;
|
|
|
|
GNUNET_asprintf (&csn,
|
|
"exchange-accountcredentials-%s",
|
|
&config_section[strlen ("exchange-account-")]);
|
|
|
|
|
|
if (GNUNET_OK !=
|
|
TALER_BANK_auth_parse_cfg (cfg,
|
|
csn,
|
|
&bc->exchange_auth))
|
|
{
|
|
GNUNET_break (0);
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
GNUNET_free (csn);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
GNUNET_free (csn);
|
|
}
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
bc->exchange_payto = exchange_payto_uri;
|
|
bc->user42_payto =
|
|
"payto://iban/SANDBOXX/FR7630006000011234567890189?receiver-name=User42";
|
|
bc->user43_payto =
|
|
"payto://iban/SANDBOXX/GB33BUKB20201555555555?receiver-name=User43";
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
|
|
"Relying on nexus %s on port %u\n",
|
|
bc->exchange_auth.wire_gateway_url,
|
|
(unsigned int) port);
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "exchange payto: %s\n",
|
|
bc->exchange_payto);
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "user42_payto: %s\n",
|
|
bc->user42_payto);
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "user42_payto: %s\n",
|
|
bc->user43_payto);
|
|
return GNUNET_OK;
|
|
}
|
|
|
|
|
|
enum GNUNET_GenericReturnValue
|
|
TALER_TESTING_prepare_bank (const char *config_filename,
|
|
int reset_db,
|
|
const char *config_section,
|
|
struct TALER_TESTING_BankConfiguration *bc)
|
|
{
|
|
struct GNUNET_CONFIGURATION_Handle *cfg;
|
|
unsigned long long port;
|
|
struct GNUNET_OS_Process *dbreset_proc;
|
|
enum GNUNET_OS_ProcessStatusType type;
|
|
unsigned long code;
|
|
char *database;
|
|
char *exchange_payto_uri;
|
|
|
|
GNUNET_assert (0 ==
|
|
strncasecmp (config_section,
|
|
"exchange-account-",
|
|
strlen ("exchange-account-")));
|
|
cfg = GNUNET_CONFIGURATION_create ();
|
|
|
|
if (GNUNET_OK !=
|
|
GNUNET_CONFIGURATION_load (cfg,
|
|
config_filename))
|
|
{
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
GNUNET_break (0);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
if (GNUNET_OK !=
|
|
GNUNET_CONFIGURATION_get_value_string (cfg,
|
|
"bank",
|
|
"DATABASE",
|
|
&database))
|
|
{
|
|
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
|
|
"bank",
|
|
"DATABASE");
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
GNUNET_break (0);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
|
|
if (GNUNET_OK !=
|
|
GNUNET_CONFIGURATION_get_value_string (cfg,
|
|
config_section,
|
|
"PAYTO_URI",
|
|
&exchange_payto_uri))
|
|
{
|
|
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
|
|
config_section,
|
|
"PAYTO_URI");
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
|
|
if (GNUNET_OK !=
|
|
GNUNET_CONFIGURATION_get_value_number (cfg,
|
|
"bank",
|
|
"HTTP_PORT",
|
|
&port))
|
|
{
|
|
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
|
|
"bank",
|
|
"HTTP_PORT");
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
GNUNET_free (database);
|
|
GNUNET_break (0);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
|
|
if (GNUNET_OK !=
|
|
GNUNET_NETWORK_test_port_free (IPPROTO_TCP,
|
|
(uint16_t) port))
|
|
{
|
|
fprintf (stderr,
|
|
"Required port %llu not available, skipping.\n",
|
|
port);
|
|
GNUNET_break (0);
|
|
GNUNET_free (database);
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
|
|
/* DB preparation */
|
|
if (GNUNET_YES == reset_db)
|
|
{
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
|
|
"Flushing bank database\n");
|
|
if (NULL ==
|
|
(dbreset_proc = GNUNET_OS_start_process (
|
|
GNUNET_OS_INHERIT_STD_ERR,
|
|
NULL, NULL, NULL,
|
|
"taler-bank-manage",
|
|
"taler-bank-manage",
|
|
"-c", config_filename,
|
|
"--with-db", database,
|
|
"django",
|
|
"flush",
|
|
"--no-input", NULL)))
|
|
{
|
|
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
|
|
"Failed to flush the bank db.\n");
|
|
GNUNET_free (database);
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
|
|
if (GNUNET_SYSERR ==
|
|
GNUNET_OS_process_wait_status (dbreset_proc,
|
|
&type,
|
|
&code))
|
|
{
|
|
GNUNET_OS_process_destroy (dbreset_proc);
|
|
GNUNET_break (0);
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
GNUNET_free (database);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
if ( (type == GNUNET_OS_PROCESS_EXITED) &&
|
|
(0 != code) )
|
|
{
|
|
fprintf (stderr,
|
|
"Failed to setup database `%s'\n",
|
|
database);
|
|
GNUNET_break (0);
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
GNUNET_free (database);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
GNUNET_free (database);
|
|
if ( (type != GNUNET_OS_PROCESS_EXITED) ||
|
|
(0 != code) )
|
|
{
|
|
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
|
|
"Unexpected error running `taler-bank-manage django flush'!\n");
|
|
GNUNET_break (0);
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
GNUNET_OS_process_destroy (dbreset_proc);
|
|
}
|
|
{
|
|
char *csn;
|
|
|
|
GNUNET_asprintf (&csn,
|
|
"exchange-accountcredentials-%s",
|
|
&config_section[strlen ("exchange-account-")]);
|
|
|
|
if (GNUNET_OK !=
|
|
TALER_BANK_auth_parse_cfg (cfg,
|
|
csn,
|
|
&bc->exchange_auth))
|
|
{
|
|
GNUNET_break (0);
|
|
GNUNET_free (csn);
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
GNUNET_free (csn);
|
|
}
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
bc->exchange_payto = exchange_payto_uri;
|
|
bc->user42_payto = "payto://x-taler-bank/localhost/42?receiver-name=42";
|
|
bc->user43_payto = "payto://x-taler-bank/localhost/43?receiver-name=43";
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
|
|
"Using pybank %s on port %u\n",
|
|
bc->exchange_auth.wire_gateway_url,
|
|
(unsigned int) port);
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
|
|
"exchange payto: %s\n",
|
|
bc->exchange_payto);
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
|
|
"user42_payto: %s\n",
|
|
bc->user42_payto);
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
|
|
"user43_payto: %s\n",
|
|
bc->user43_payto);
|
|
return GNUNET_OK;
|
|
}
|
|
|
|
|
|
enum GNUNET_GenericReturnValue
|
|
TALER_TESTING_prepare_fakebank (const char *config_filename,
|
|
const char *config_section,
|
|
struct TALER_TESTING_BankConfiguration *bc)
|
|
{
|
|
struct GNUNET_CONFIGURATION_Handle *cfg;
|
|
unsigned long long fakebank_port;
|
|
char *exchange_payto_uri;
|
|
|
|
cfg = GNUNET_CONFIGURATION_create ();
|
|
if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg,
|
|
config_filename))
|
|
return GNUNET_SYSERR;
|
|
|
|
if (GNUNET_OK !=
|
|
GNUNET_CONFIGURATION_get_value_number (cfg,
|
|
"BANK",
|
|
"HTTP_PORT",
|
|
&fakebank_port))
|
|
{
|
|
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
|
|
"BANK",
|
|
"HTTP_PORT");
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
if (GNUNET_OK !=
|
|
GNUNET_CONFIGURATION_get_value_string (cfg,
|
|
config_section,
|
|
"PAYTO_URI",
|
|
&exchange_payto_uri))
|
|
{
|
|
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
|
|
config_section,
|
|
"PAYTO_URI");
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
{
|
|
char *exchange_xtalerbank_account;
|
|
|
|
exchange_xtalerbank_account
|
|
= TALER_xtalerbank_account_from_payto (exchange_payto_uri);
|
|
if (NULL == exchange_xtalerbank_account)
|
|
{
|
|
GNUNET_break (0);
|
|
GNUNET_free (exchange_payto_uri);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
GNUNET_asprintf (&bc->exchange_auth.wire_gateway_url,
|
|
"http://localhost:%u/%s/",
|
|
(unsigned int) fakebank_port,
|
|
exchange_xtalerbank_account);
|
|
GNUNET_free (exchange_xtalerbank_account);
|
|
}
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
|
|
"Using fakebank %s on port %u\n",
|
|
bc->exchange_auth.wire_gateway_url,
|
|
(unsigned int) fakebank_port);
|
|
|
|
GNUNET_CONFIGURATION_destroy (cfg);
|
|
if (GNUNET_OK !=
|
|
TALER_TESTING_url_port_free (bc->exchange_auth.wire_gateway_url))
|
|
{
|
|
GNUNET_free (bc->exchange_auth.wire_gateway_url);
|
|
bc->exchange_auth.wire_gateway_url = NULL;
|
|
GNUNET_free (exchange_payto_uri);
|
|
return GNUNET_SYSERR;
|
|
}
|
|
/* Now we know it's the fake bank, for purpose of authentication, we
|
|
* don't have any auth. */
|
|
bc->exchange_auth.method = TALER_BANK_AUTH_NONE;
|
|
bc->exchange_payto = exchange_payto_uri;
|
|
bc->user42_payto = "payto://x-taler-bank/localhost/42?receiver-name=42";
|
|
bc->user43_payto = "payto://x-taler-bank/localhost/43?receiver-name=43";
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "exchange payto: %s\n",
|
|
bc->exchange_payto);
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "user42_payto: %s\n",
|
|
bc->user42_payto);
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "user43_payto: %s\n",
|
|
bc->user43_payto);
|
|
return GNUNET_OK;
|
|
}
|
|
|
|
|
|
json_t *
|
|
TALER_TESTING_make_wire_details (const char *payto)
|
|
{
|
|
struct TALER_WireSaltP salt;
|
|
|
|
/* salt must be constant for aggregation tests! */
|
|
memset (&salt,
|
|
47,
|
|
sizeof (salt));
|
|
return GNUNET_JSON_PACK (
|
|
GNUNET_JSON_pack_string ("payto_uri",
|
|
payto),
|
|
GNUNET_JSON_pack_data_auto ("salt",
|
|
&salt));
|
|
}
|
|
|
|
|
|
/* end of testing_api_helpers_bank.c */
|