From b4075653516167f96464afa366482e1618e4b06b Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sun, 24 Jan 2016 16:26:54 +0100 Subject: defining wire plugin API --- src/include/taler_wire_plugin.h | 178 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 178 insertions(+) create mode 100644 src/include/taler_wire_plugin.h (limited to 'src/include/taler_wire_plugin.h') diff --git a/src/include/taler_wire_plugin.h b/src/include/taler_wire_plugin.h new file mode 100644 index 000000000..fd86ca289 --- /dev/null +++ b/src/include/taler_wire_plugin.h @@ -0,0 +1,178 @@ +/* + This file is part of TALER + Copyright (C) 2016 GNUnet e.V. + + 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 include/taler_wire_plugin.h + * @brief Plugin API for the handling of wire transactions + * @author Christian Grothoff + */ +#ifndef TALER_WIRE_PLUGIN_H +#define TALER_WIRE_PLUGIN_H + +#include + + +/** + * Callback with prepared transaction. + * + * @param cls closure + * @param buf transaction data to persist + * @param buf_size number of bytes in @a buf + */ +typedef void +(*TALER_WIRE_PrepareTransactionCallback) (void *cls, + const char *buf, + size_t buf_size); + + +/** + * Handle returned for cancelling a preparation step. + */ +struct TALER_WIRE_PrepareHandle; + + +/** + * Handle returned for cancelling an execution step. + */ +struct TALER_WIRE_ExecuteHandle; + + +/** + * Function called with the result from the execute step. + * + * @param cls closure + * @param success #GNUNET_OK on success, #GNUNET_SYSERR on failure + * @param emsg NULL on success, otherwise an error message + */ +typedef void +(*TALER_WIRE_ConfirmationCallback)(void *cls, + int success, + const char *emsg); + + +/** + * @brief The plugin API, returned from the plugin's "init" function. + * The argument given to "init" is simply a configuration handle. + */ +struct TALER_WIRE_Plugin +{ + + /** + * Closure for all callbacks. + */ + void *cls; + + /** + * Name of the library which generated this plugin. Set by the + * plugin loader. + */ + char *library_name; + + /** + * 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 + */ + int + (*amount_round) (void *cls, + struct TALER_Amount *amount); + + + /** + * Check if the given wire format JSON object is correctly formatted + * + * @param wire the JSON wire format object + * @return #GNUNET_YES if correctly formatted; #GNUNET_NO if not + */ + int + wire_validate (const json_t *wire); + + + /** + * Prepare for exeuction of a wire transfer. + * + * @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 + */ + struct TALER_WIRE_PrepareHandle * + (*prepare_wire_transfer) (void *cls, + const json_t *wire, + const struct TALER_Amount *amount, + const void *wtid, + TALER_WIRE_PrepareTransactionCallback ptc, + void *ptc_cls); + + /** + * 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 + */ + void + (*prepare_wire_transfer_cancel) (void *cls, + struct TALER_WIRE_PrepareHandle *pth); + + + /** + * 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 + */ + struct TALER_WIRE_ExecuteHandle * + (*execute_wire_transfer) (void *cls, + const char *buf, + size_t buf_size, + TALER_WIRE_ConfirmatinCallback cc, + void *cc_cls); + + + /** + * 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 + */ + void + (*execute_wire_transfer_cancel) (void *cls, + struct TALER_WIRE_ExecuteHandle *eh); + + +}; + + +#endif /* TALER_WIRE_PLUGIN_H */ -- cgit v1.2.3 From 9aa323ca7bcf1567f6ecf98cf73b5691ade1b816 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sun, 24 Jan 2016 16:44:57 +0100 Subject: adding skeletons for plugins --- configure.ac | 1 + src/Makefile.am | 4 +- src/include/taler_wire_plugin.h | 6 +- src/wire/Makefile.am | 36 ++++++ src/wire/plugin_wire_template.c | 235 ++++++++++++++++++++++++++++++++++++++++ src/wire/plugin_wire_test.c | 235 ++++++++++++++++++++++++++++++++++++++++ 6 files changed, 513 insertions(+), 4 deletions(-) create mode 100644 src/wire/Makefile.am create mode 100644 src/wire/plugin_wire_template.c create mode 100644 src/wire/plugin_wire_test.c (limited to 'src/include/taler_wire_plugin.h') diff --git a/configure.ac b/configure.ac index ccb0c1f31..8f06b520b 100644 --- a/configure.ac +++ b/configure.ac @@ -357,6 +357,7 @@ AC_CONFIG_FILES([Makefile src/include/Makefile src/util/Makefile src/pq/Makefile + src/wire/Makefile src/mintdb/Makefile src/mint/Makefile src/mint-tools/Makefile diff --git a/src/Makefile.am b/src/Makefile.am index 0d1d4572f..986dcc5d3 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -7,10 +7,10 @@ if WALLET_ONLY SUBDIRS = include util else -SUBDIRS = include util $(PQ_DIR) mintdb mint mint-tools +SUBDIRS = include util $(PQ_DIR) wire mintdb mint mint-tools if HAVE_LIBCURL SUBDIRS += mint-lib -else +else if HAVE_LIBGNURL SUBDIRS += mint-lib endif diff --git a/src/include/taler_wire_plugin.h b/src/include/taler_wire_plugin.h index fd86ca289..00bcc42e9 100644 --- a/src/include/taler_wire_plugin.h +++ b/src/include/taler_wire_plugin.h @@ -22,6 +22,8 @@ #define TALER_WIRE_PLUGIN_H #include +#include +#include "taler_util.h" /** @@ -103,7 +105,7 @@ struct TALER_WIRE_Plugin * @return #GNUNET_YES if correctly formatted; #GNUNET_NO if not */ int - wire_validate (const json_t *wire); + (*wire_validate) (const json_t *wire); /** @@ -151,7 +153,7 @@ struct TALER_WIRE_Plugin (*execute_wire_transfer) (void *cls, const char *buf, size_t buf_size, - TALER_WIRE_ConfirmatinCallback cc, + TALER_WIRE_ConfirmationCallback cc, void *cc_cls); diff --git a/src/wire/Makefile.am b/src/wire/Makefile.am new file mode 100644 index 000000000..a27a59c78 --- /dev/null +++ b/src/wire/Makefile.am @@ -0,0 +1,36 @@ +# This Makefile.am is in the public domain +AM_CPPFLAGS = -I$(top_srcdir)/src/include + +if USE_COVERAGE + AM_CFLAGS = --coverage -O0 + XLIB = -lgcov +endif + +plugindir = $(libdir)/taler + +plugin_LTLIBRARIES = \ + libtaler_plugin_wire_test.la + +noinst_LTLIBRARIES = \ + libtaler_plugin_wire_template.la + + +libtaler_plugin_wire_test_la_SOURCES = \ + plugin_wire_test.c +libtaler_plugin_wire_test_la_LIBADD = \ + $(LTLIBINTL) +libtaler_plugin_wire_test_la_LDFLAGS = \ + $(TALER_PLUGIN_LDFLAGS) \ + $(top_builddir)/src/util/libtalerutil.la \ + -lgnunetutil $(XLIB) + + + +libtaler_plugin_wire_template_la_SOURCES = \ + plugin_wire_template.c +libtaler_plugin_wire_template_la_LIBADD = \ + $(LTLIBINTL) +libtaler_plugin_wire_template_la_LDFLAGS = \ + $(TALER_PLUGIN_LDFLAGS) \ + $(top_builddir)/src/util/libtalerutil.la \ + -lgnunetutil $(XLIB) diff --git a/src/wire/plugin_wire_template.c b/src/wire/plugin_wire_template.c new file mode 100644 index 000000000..8abcca8c9 --- /dev/null +++ b/src/wire/plugin_wire_template.c @@ -0,0 +1,235 @@ +/* + This file is part of TALER + Copyright (C) 2016 GNUnet e.V. + + 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_template.c + * @brief template for wire plugins; replace "template" with real plugin name! + * @author Florian Dold + * @author Christian Grothoff + * @author Sree Harsha Totakura + */ +#include "platform.h" +#include "taler_wire_plugin.h" + + +/** + * Type of the "cls" argument given to each of the functions in + * our API. + */ +struct TemplateClosure +{ + + /** + * URI of the bank for sending funds to the bank. + */ + char *bank_uri; + + /** + * Which currency do we support? + */ + char *currency; + +}; + + +/** + * 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 +template_amount_round (void *cls, + struct TALER_Amount *amount) +{ + GNUNET_break (0); + return GNUNET_SYSERR; +} + + +/** + * Check if the given wire format JSON object is correctly formatted + * + * @param wire the JSON wire format object + * @return #GNUNET_YES if correctly formatted; #GNUNET_NO if not + */ +static int +template_wire_validate (const json_t *wire) +{ + GNUNET_break (0); + return GNUNET_SYSERR; +} + + +/** + * Prepare for exeuction of a wire transfer. + * + * @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 * +template_prepare_wire_transfer (void *cls, + const json_t *wire, + const struct TALER_Amount *amount, + const void *wtid, + TALER_WIRE_PrepareTransactionCallback ptc, + void *ptc_cls) +{ + GNUNET_break (0); + return NULL; +} + + +/** + * 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 +template_prepare_wire_transfer_cancel (void *cls, + struct TALER_WIRE_PrepareHandle *pth) +{ + GNUNET_break (0); +} + + +/** + * 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 * +template_execute_wire_transfer (void *cls, + const char *buf, + size_t buf_size, + TALER_WIRE_ConfirmationCallback cc, + void *cc_cls) +{ + GNUNET_break (0); + return NULL; +} + + +/** + * 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 +template_execute_wire_transfer_cancel (void *cls, + struct TALER_WIRE_ExecuteHandle *eh) +{ + GNUNET_break (0); +} + + +/** + * Initialize template-wire subsystem. + * + * @param cls a configuration instance + * @return NULL on error, otherwise a `struct TALER_WIRE_Plugin` + */ +void * +libtaler_plugin_wire_template_init (void *cls) +{ + struct GNUNET_CONFIGURATION_Handle *cfg = cls; + struct TemplateClosure *tc; + struct TALER_WIRE_Plugin *plugin; + + tc = GNUNET_new (struct TemplateClosure); + + if (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_string (cfg, + "wire-template", + "bank_uri", + &tc->bank_uri)) + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, + "wire-template", + "bank_uri"); + GNUNET_free (tc); + return NULL; + } + if (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_string (cfg, + "mint", + "CURRENCY", + &tc->currency)) + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, + "mint", + "CURRENCY"); + GNUNET_free (tc->bank_uri); + GNUNET_free (tc); + return NULL; + } + + plugin = GNUNET_new (struct TALER_WIRE_Plugin); + plugin->cls = tc; + plugin->amount_round = &template_amount_round; + plugin->wire_validate = &template_wire_validate; + plugin->prepare_wire_transfer = &template_prepare_wire_transfer; + plugin->prepare_wire_transfer_cancel = &template_prepare_wire_transfer_cancel; + plugin->execute_wire_transfer = &template_execute_wire_transfer; + plugin->execute_wire_transfer_cancel = &template_execute_wire_transfer_cancel; + return plugin; +} + + +/** + * Shutdown Template wire subsystem. + * + * @param cls a `struct TALER_WIRE_Plugin` + * @return NULL (always) + */ +void * +libtaler_plugin_wire_template_done (void *cls) +{ + struct TALER_WIRE_Plugin *plugin = cls; + struct TemplateClosure *tc = plugin->cls; + + GNUNET_free (tc->bank_uri); + GNUNET_free (tc->currency); + GNUNET_free (tc); + GNUNET_free (plugin); + return NULL; +} + +/* end of plugin_wire_template.c */ diff --git a/src/wire/plugin_wire_test.c b/src/wire/plugin_wire_test.c new file mode 100644 index 000000000..72c87ef55 --- /dev/null +++ b/src/wire/plugin_wire_test.c @@ -0,0 +1,235 @@ +/* + This file is part of TALER + Copyright (C) 2016 GNUnet e.V. + + 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 Florian Dold + * @author Christian Grothoff + * @author Sree Harsha Totakura + */ +#include "platform.h" +#include "taler_wire_plugin.h" + + +/** + * Type of the "cls" argument given to each of the functions in + * our API. + */ +struct TestClosure +{ + + /** + * URI of the bank for sending funds to the bank. + */ + char *bank_uri; + + /** + * Which currency do we support? + */ + char *currency; + +}; + + +/** + * 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) +{ + GNUNET_break (0); + return GNUNET_SYSERR; +} + + +/** + * Check if the given wire format JSON object is correctly formatted + * + * @param wire the JSON wire format object + * @return #GNUNET_YES if correctly formatted; #GNUNET_NO if not + */ +static int +test_wire_validate (const json_t *wire) +{ + GNUNET_break (0); + return GNUNET_SYSERR; +} + + +/** + * Prepare for exeuction of a wire transfer. + * + * @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 void *wtid, + TALER_WIRE_PrepareTransactionCallback ptc, + void *ptc_cls) +{ + GNUNET_break (0); + return NULL; +} + + +/** + * 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_break (0); +} + + +/** + * 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) +{ + GNUNET_break (0); + return NULL; +} + + +/** + * 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) +{ + GNUNET_break (0); +} + + +/** + * 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 (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_string (cfg, + "wire-test", + "bank_uri", + &tc->bank_uri)) + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, + "wire-test", + "bank_uri"); + GNUNET_free (tc); + return NULL; + } + if (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_string (cfg, + "mint", + "CURRENCY", + &tc->currency)) + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, + "mint", + "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->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; + + GNUNET_free (tc->bank_uri); + GNUNET_free (tc->currency); + GNUNET_free (tc); + GNUNET_free (plugin); + return NULL; +} + +/* end of plugin_wire_test.c */ -- cgit v1.2.3 From 5c58c43609609e6871c7105c7ca8fc3d794dca04 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sun, 24 Jan 2016 16:52:39 +0100 Subject: more work on wire plugins --- src/include/taler_wire_plugin.h | 2 +- src/wire/plugin_wire_template.c | 12 ++++++++++-- src/wire/plugin_wire_test.c | 24 +++++++++++++++++++----- 3 files changed, 30 insertions(+), 8 deletions(-) (limited to 'src/include/taler_wire_plugin.h') diff --git a/src/include/taler_wire_plugin.h b/src/include/taler_wire_plugin.h index 00bcc42e9..62930450c 100644 --- a/src/include/taler_wire_plugin.h +++ b/src/include/taler_wire_plugin.h @@ -123,7 +123,7 @@ struct TALER_WIRE_Plugin (*prepare_wire_transfer) (void *cls, const json_t *wire, const struct TALER_Amount *amount, - const void *wtid, + const struct TALER_WireTransferIdentifierRawP *wtid, TALER_WIRE_PrepareTransactionCallback ptc, void *ptc_cls); diff --git a/src/wire/plugin_wire_template.c b/src/wire/plugin_wire_template.c index 8abcca8c9..baf0ee7d5 100644 --- a/src/wire/plugin_wire_template.c +++ b/src/wire/plugin_wire_template.c @@ -60,7 +60,15 @@ static int template_amount_round (void *cls, struct TALER_Amount *amount) { - GNUNET_break (0); + struct TemplateClosure *tc = cls; + + if (0 != strcasecmp (amount->currency, + tc->currency)) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + GNUNET_break (0); // not implemented return GNUNET_SYSERR; } @@ -94,7 +102,7 @@ static struct TALER_WIRE_PrepareHandle * template_prepare_wire_transfer (void *cls, const json_t *wire, const struct TALER_Amount *amount, - const void *wtid, + const struct TALER_WireTransferIdentifierRawP *wtid, TALER_WIRE_PrepareTransactionCallback ptc, void *ptc_cls) { diff --git a/src/wire/plugin_wire_test.c b/src/wire/plugin_wire_test.c index 72c87ef55..1ea856fd1 100644 --- a/src/wire/plugin_wire_test.c +++ b/src/wire/plugin_wire_test.c @@ -60,8 +60,21 @@ static int test_amount_round (void *cls, struct TALER_Amount *amount) { - GNUNET_break (0); - return GNUNET_SYSERR; + struct TestClosure *tc = cls; + uint32_t delta; + + 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; } @@ -74,8 +87,9 @@ test_amount_round (void *cls, static int test_wire_validate (const json_t *wire) { - GNUNET_break (0); - return GNUNET_SYSERR; + GNUNET_break (0); /* FIXME: we still need to define the + proper wire format for 'test' */ + return GNUNET_YES; } @@ -94,7 +108,7 @@ static struct TALER_WIRE_PrepareHandle * test_prepare_wire_transfer (void *cls, const json_t *wire, const struct TALER_Amount *amount, - const void *wtid, + const struct TALER_WireTransferIdentifierRawP *wtid, TALER_WIRE_PrepareTransactionCallback ptc, void *ptc_cls) { -- cgit v1.2.3 From 891b533a217a23dfd21c6135d62ca5bc91adc38d Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Mon, 25 Jan 2016 11:21:55 +0100 Subject: finish serialization/deserialization logic for test wire transfers --- src/include/taler_wire_plugin.h | 4 +- src/wire/plugin_wire_test.c | 89 +++++++++++++++++++++++++++++++++++++---- 2 files changed, 83 insertions(+), 10 deletions(-) (limited to 'src/include/taler_wire_plugin.h') diff --git a/src/include/taler_wire_plugin.h b/src/include/taler_wire_plugin.h index 62930450c..8fb194c57 100644 --- a/src/include/taler_wire_plugin.h +++ b/src/include/taler_wire_plugin.h @@ -30,8 +30,8 @@ * Callback with prepared transaction. * * @param cls closure - * @param buf transaction data to persist - * @param buf_size number of bytes in @a buf + * @param buf transaction data to persist, NULL on error + * @param buf_size number of bytes in @a buf, 0 on error */ typedef void (*TALER_WIRE_PrepareTransactionCallback) (void *cls, diff --git a/src/wire/plugin_wire_test.c b/src/wire/plugin_wire_test.c index 776b786e7..7940b4775 100644 --- a/src/wire/plugin_wire_test.c +++ b/src/wire/plugin_wire_test.c @@ -240,6 +240,29 @@ test_wire_validate (const json_t *wire) } +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. @@ -252,12 +275,44 @@ do_prepare (void *cls, const struct GNUNET_SCHEDULER_TaskContext *sct) { struct TALER_WIRE_PrepareHandle *pth = cls; - char buf[42]; // FIXME: init: serialize buf! + char *wire_enc; + size_t len; + struct BufFormatP bf; pth->task = NULL; - pth->ptc (pth->ptc_cls, - buf, - sizeof (buf)); + /* 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); } @@ -373,10 +428,27 @@ test_execute_wire_transfer (void *cls, struct TALER_WIRE_ExecuteHandle *eh; json_t *wire; struct TALER_Amount amount; - struct TALER_WireTransferIdentifierRawP wtid; + struct BufFormatP bf; - /* FIXME: deserialize buf */ - wire = NULL; + 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 (wire)); @@ -384,11 +456,12 @@ test_execute_wire_transfer (void *cls, eh->cc = cc; eh->cc_cls = cc_cls; eh->aaih = TALER_BANK_admin_add_incoming (tc->bank, - &wtid, + &bf.wtid, &amount, wire, &execute_cb, eh); + json_decref (wire); if (NULL == eh->aaih) { GNUNET_break (0); -- cgit v1.2.3