2015-09-14 15:29:40 +02:00
|
|
|
/*
|
|
|
|
This file is part of TALER
|
2016-04-01 16:15:35 +02:00
|
|
|
Copyright (C) 2014, 2015, 2016 Inria and GNUnet e.V.
|
2015-09-14 15:29:40 +02:00
|
|
|
|
|
|
|
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
|
|
|
|
<http://www.gnu.org/licenses/>
|
|
|
|
*/
|
|
|
|
/**
|
2016-03-01 15:35:04 +01:00
|
|
|
* @file exchange-lib/exchange_api_wire.c
|
|
|
|
* @brief Implementation of the /wire request of the exchange's HTTP API
|
2015-09-14 15:29:40 +02:00
|
|
|
* @author Christian Grothoff
|
|
|
|
*/
|
|
|
|
#include "platform.h"
|
|
|
|
#include <curl/curl.h>
|
|
|
|
#include <jansson.h>
|
|
|
|
#include <microhttpd.h> /* just for HTTP status codes */
|
|
|
|
#include <gnunet/gnunet_util_lib.h>
|
2016-04-17 17:45:15 +02:00
|
|
|
#include <gnunet/gnunet_curl_lib.h>
|
2016-03-01 15:35:04 +01:00
|
|
|
#include "taler_exchange_service.h"
|
2016-03-19 15:54:21 +01:00
|
|
|
#include "taler_json_lib.h"
|
2016-03-19 15:23:11 +01:00
|
|
|
#include "taler_wire_plugin.h"
|
2016-03-01 15:35:04 +01:00
|
|
|
#include "exchange_api_common.h"
|
|
|
|
#include "exchange_api_handle.h"
|
2015-09-14 15:29:40 +02:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief A Wire Handle
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGE_WireHandle
|
2015-09-14 15:29:40 +02:00
|
|
|
{
|
|
|
|
|
|
|
|
/**
|
2016-03-01 15:35:04 +01:00
|
|
|
* The connection to exchange this request handle will use
|
2015-09-14 15:29:40 +02:00
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGE_Handle *exchange;
|
2015-09-14 15:29:40 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The url for this request.
|
|
|
|
*/
|
|
|
|
char *url;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handle for the request.
|
|
|
|
*/
|
2016-04-17 17:45:15 +02:00
|
|
|
struct GNUNET_CURL_Job *job;
|
2015-09-14 15:29:40 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Function to call with the result.
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
TALER_EXCHANGE_WireResultCallback cb;
|
2015-09-14 15:29:40 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Closure for @a cb.
|
|
|
|
*/
|
|
|
|
void *cb_cls;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set to the "methods" JSON array returned by the
|
|
|
|
* /wire request.
|
|
|
|
*/
|
|
|
|
json_t *methods;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Current iteration offset in the @e methods array.
|
|
|
|
*/
|
|
|
|
unsigned int methods_off;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Verify that the signature on the "200 OK" response
|
2016-03-01 15:35:04 +01:00
|
|
|
* for /wire/METHOD from the exchange is valid.
|
2015-09-14 15:29:40 +02:00
|
|
|
*
|
|
|
|
* @param wh wire handle with key material
|
|
|
|
* @param method method to verify the reply for
|
|
|
|
* @param json json reply with the signature
|
|
|
|
* @return #GNUNET_SYSERR if @a json is invalid,
|
|
|
|
* #GNUNET_NO if the method is unknown,
|
|
|
|
* #GNUNET_OK if the json is valid
|
|
|
|
*/
|
|
|
|
static int
|
2016-03-01 15:35:04 +01:00
|
|
|
verify_wire_method_signature_ok (const struct TALER_EXCHANGE_WireHandle *wh,
|
2015-09-14 15:29:40 +02:00
|
|
|
const char *method,
|
2016-04-17 17:45:15 +02:00
|
|
|
const json_t *json)
|
2015-09-14 15:29:40 +02:00
|
|
|
{
|
2016-03-19 15:23:11 +01:00
|
|
|
const struct TALER_EXCHANGE_Keys *key_state;
|
|
|
|
struct TALER_WIRE_Plugin *plugin;
|
|
|
|
char *lib_name;
|
|
|
|
int ret;
|
2015-09-14 15:29:40 +02:00
|
|
|
|
2016-03-19 15:23:11 +01:00
|
|
|
key_state = TALER_EXCHANGE_get_keys (wh->exchange);
|
|
|
|
(void) GNUNET_asprintf (&lib_name,
|
|
|
|
"libtaler_plugin_wire_%s",
|
|
|
|
method);
|
|
|
|
plugin = GNUNET_PLUGIN_load (lib_name,
|
|
|
|
NULL);
|
|
|
|
if (NULL == plugin)
|
|
|
|
{
|
|
|
|
GNUNET_free (lib_name);
|
|
|
|
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
|
|
|
|
"Wire transfer method `%s' not supported\n",
|
|
|
|
method);
|
|
|
|
return GNUNET_NO;
|
|
|
|
}
|
|
|
|
plugin->library_name = lib_name;
|
|
|
|
ret = plugin->wire_validate (plugin->cls,
|
|
|
|
json,
|
|
|
|
&key_state->master_pub);
|
|
|
|
GNUNET_PLUGIN_unload (lib_name,
|
|
|
|
plugin);
|
|
|
|
GNUNET_free (lib_name);
|
|
|
|
return (GNUNET_YES == ret) ? GNUNET_OK : GNUNET_SYSERR;
|
2015-09-14 15:29:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function called when we're done processing the
|
|
|
|
* HTTP /wire request.
|
|
|
|
*
|
2016-03-01 15:35:04 +01:00
|
|
|
* @param cls the `struct TALER_EXCHANGE_WireHandle`
|
2016-04-17 17:45:15 +02:00
|
|
|
* @param response_code HTTP response code, 0 on error
|
|
|
|
* @param json parsed JSON result, NULL on error
|
2015-09-14 15:29:40 +02:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
handle_wire_finished (void *cls,
|
2016-04-17 17:45:15 +02:00
|
|
|
long response_code,
|
|
|
|
const json_t *json)
|
2015-09-14 15:29:40 +02:00
|
|
|
{
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGE_WireHandle *wh = cls;
|
2016-04-17 17:45:15 +02:00
|
|
|
json_t *keep = NULL;
|
2015-09-14 15:29:40 +02:00
|
|
|
|
|
|
|
wh->job = NULL;
|
|
|
|
switch (response_code)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case MHD_HTTP_OK:
|
|
|
|
{
|
2016-04-01 16:15:35 +02:00
|
|
|
const char *key;
|
|
|
|
json_t *method;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* We 'keep' methods that we support and that are well-formed;
|
|
|
|
we fail (by setting response_code=0) if any method that we do
|
|
|
|
support fails to verify. */
|
|
|
|
keep = json_object ();
|
2016-04-17 17:45:15 +02:00
|
|
|
json_object_foreach ((json_t *) json, key, method) {
|
2016-04-01 16:15:35 +02:00
|
|
|
ret = verify_wire_method_signature_ok (wh,
|
|
|
|
key,
|
|
|
|
method);
|
|
|
|
if (GNUNET_SYSERR == ret)
|
|
|
|
{
|
|
|
|
/* bogus reply */
|
|
|
|
GNUNET_break_op (0);
|
|
|
|
response_code = 0;
|
|
|
|
}
|
|
|
|
/* GNUNET_NO: not understood by us, simply skip! */
|
|
|
|
if (GNUNET_OK == ret)
|
|
|
|
{
|
|
|
|
/* supported and valid, keep! */
|
|
|
|
json_object_set (keep,
|
|
|
|
key,
|
|
|
|
method);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (0 != response_code)
|
2015-09-14 15:29:40 +02:00
|
|
|
{
|
2016-04-01 16:15:35 +02:00
|
|
|
/* all supported methods were valid, use 'keep' for 'json' */
|
2015-09-14 15:29:40 +02:00
|
|
|
break;
|
|
|
|
}
|
2016-04-01 16:15:35 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* some supported methods were invalid, release 'keep', preserve
|
|
|
|
full 'json' for application-level error handling. */
|
|
|
|
json_decref (keep);
|
2016-04-17 17:45:15 +02:00
|
|
|
keep = NULL;
|
2016-04-01 16:15:35 +02:00
|
|
|
}
|
2015-09-14 15:29:40 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case MHD_HTTP_BAD_REQUEST:
|
2016-03-01 15:35:04 +01:00
|
|
|
/* This should never happen, either us or the exchange is buggy
|
2015-09-14 15:29:40 +02:00
|
|
|
(or API version conflict); just pass JSON reply to the application */
|
|
|
|
break;
|
|
|
|
case MHD_HTTP_NOT_FOUND:
|
|
|
|
/* Nothing really to verify, this should never
|
|
|
|
happen, we should pass the JSON reply to the application */
|
|
|
|
break;
|
|
|
|
case MHD_HTTP_INTERNAL_SERVER_ERROR:
|
|
|
|
/* Server had an internal issue; we should retry, but this API
|
|
|
|
leaves this to the application */
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* unexpected response code */
|
|
|
|
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
|
|
|
|
"Unexpected response code %u\n",
|
2016-05-04 13:21:22 +02:00
|
|
|
(unsigned int) response_code);
|
2015-09-14 15:29:40 +02:00
|
|
|
GNUNET_break (0);
|
|
|
|
response_code = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
wh->cb (wh->cb_cls,
|
2016-04-01 16:15:35 +02:00
|
|
|
response_code,
|
2016-04-17 17:45:15 +02:00
|
|
|
(NULL != keep) ? keep : json);
|
|
|
|
if (NULL != keep)
|
|
|
|
json_decref (keep);
|
2016-03-01 15:35:04 +01:00
|
|
|
TALER_EXCHANGE_wire_cancel (wh);
|
2015-09-14 15:29:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2016-03-01 15:35:04 +01:00
|
|
|
* Obtain information about a exchange's wire instructions.
|
|
|
|
* A exchange may provide wire instructions for creating
|
2015-09-14 15:29:40 +02:00
|
|
|
* a reserve. The wire instructions also indicate
|
2016-03-01 15:35:04 +01:00
|
|
|
* which wire formats merchants may use with the exchange.
|
2015-09-14 15:29:40 +02:00
|
|
|
* This API is typically used by a wallet for wiring
|
|
|
|
* funds, and possibly by a merchant to determine
|
|
|
|
* supported wire formats.
|
|
|
|
*
|
|
|
|
* Note that while we return the (main) response verbatim to the
|
|
|
|
* caller for further processing, we do already verify that the
|
|
|
|
* response is well-formed (i.e. that signatures included in the
|
2016-03-01 15:35:04 +01:00
|
|
|
* response are all valid). If the exchange's reply is not well-formed,
|
2015-09-14 15:29:40 +02:00
|
|
|
* we return an HTTP status code of zero to @a cb.
|
|
|
|
*
|
2016-03-01 15:35:04 +01:00
|
|
|
* @param exchange the exchange handle; the exchange must be ready to operate
|
2015-09-14 15:29:40 +02:00
|
|
|
* @param wire_cb the callback to call when a reply for this request is available
|
|
|
|
* @param wire_cb_cls closure for the above callback
|
|
|
|
* @return a handle for this request
|
|
|
|
*/
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGE_WireHandle *
|
|
|
|
TALER_EXCHANGE_wire (struct TALER_EXCHANGE_Handle *exchange,
|
2016-04-01 16:15:35 +02:00
|
|
|
TALER_EXCHANGE_WireResultCallback wire_cb,
|
|
|
|
void *wire_cb_cls)
|
2015-09-14 15:29:40 +02:00
|
|
|
{
|
2016-03-01 15:35:04 +01:00
|
|
|
struct TALER_EXCHANGE_WireHandle *wh;
|
2016-04-17 17:45:15 +02:00
|
|
|
struct GNUNET_CURL_Context *ctx;
|
2015-09-14 15:29:40 +02:00
|
|
|
CURL *eh;
|
|
|
|
|
|
|
|
if (GNUNET_YES !=
|
2016-03-01 15:35:04 +01:00
|
|
|
MAH_handle_is_ready (exchange))
|
2015-09-14 15:29:40 +02:00
|
|
|
{
|
|
|
|
GNUNET_break (0);
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-03-01 15:35:04 +01:00
|
|
|
wh = GNUNET_new (struct TALER_EXCHANGE_WireHandle);
|
|
|
|
wh->exchange = exchange;
|
2015-09-14 15:29:40 +02:00
|
|
|
wh->cb = wire_cb;
|
|
|
|
wh->cb_cls = wire_cb_cls;
|
2016-03-01 15:35:04 +01:00
|
|
|
wh->url = MAH_path_to_url (exchange, "/wire");
|
2015-09-14 15:29:40 +02:00
|
|
|
|
|
|
|
eh = curl_easy_init ();
|
|
|
|
GNUNET_assert (CURLE_OK ==
|
|
|
|
curl_easy_setopt (eh,
|
|
|
|
CURLOPT_URL,
|
|
|
|
wh->url));
|
2016-03-01 15:35:04 +01:00
|
|
|
ctx = MAH_handle_to_context (exchange);
|
2016-04-17 17:45:15 +02:00
|
|
|
wh->job = GNUNET_CURL_job_add (ctx,
|
2015-09-14 15:29:40 +02:00
|
|
|
eh,
|
|
|
|
GNUNET_YES,
|
|
|
|
&handle_wire_finished,
|
|
|
|
wh);
|
|
|
|
return wh;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Cancel a wire information request. This function cannot be used
|
|
|
|
* on a request handle if a response is already served for it.
|
|
|
|
*
|
2015-10-05 10:39:17 +02:00
|
|
|
* @param wh the wire information request handle
|
2015-09-14 15:29:40 +02:00
|
|
|
*/
|
|
|
|
void
|
2016-03-01 15:35:04 +01:00
|
|
|
TALER_EXCHANGE_wire_cancel (struct TALER_EXCHANGE_WireHandle *wh)
|
2015-09-14 15:29:40 +02:00
|
|
|
{
|
2015-10-05 10:39:17 +02:00
|
|
|
if (NULL != wh->job)
|
2015-09-14 15:29:40 +02:00
|
|
|
{
|
2016-04-17 17:45:15 +02:00
|
|
|
GNUNET_CURL_job_cancel (wh->job);
|
2015-10-05 10:39:17 +02:00
|
|
|
wh->job = NULL;
|
2015-09-14 15:29:40 +02:00
|
|
|
}
|
2015-10-05 10:39:17 +02:00
|
|
|
if (NULL != wh->methods)
|
2015-09-14 15:29:40 +02:00
|
|
|
{
|
2015-10-05 10:39:17 +02:00
|
|
|
json_decref (wh->methods);
|
|
|
|
wh->methods = NULL;
|
2015-09-14 15:29:40 +02:00
|
|
|
}
|
2015-10-05 10:39:17 +02:00
|
|
|
GNUNET_free (wh->url);
|
|
|
|
GNUNET_free (wh);
|
2015-09-14 15:29:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-03-01 15:35:04 +01:00
|
|
|
/* end of exchange_api_wire.c */
|