aboutsummaryrefslogtreecommitdiff
path: root/src/wire
diff options
context:
space:
mode:
Diffstat (limited to 'src/wire')
-rw-r--r--src/wire/Makefile.am78
-rw-r--r--src/wire/plugin_wire_sepa.c545
-rw-r--r--src/wire/plugin_wire_template.c243
-rw-r--r--src/wire/plugin_wire_test.c581
-rw-r--r--src/wire/test_sepa_wireformat.c104
-rw-r--r--src/wire/wire.c72
6 files changed, 1623 insertions, 0 deletions
diff --git a/src/wire/Makefile.am b/src/wire/Makefile.am
new file mode 100644
index 000000000..eb2e893fa
--- /dev/null
+++ b/src/wire/Makefile.am
@@ -0,0 +1,78 @@
+# 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_sepa.la \
+ libtaler_plugin_wire_test.la
+
+noinst_LTLIBRARIES = \
+ libtaler_plugin_wire_template.la
+
+lib_LTLIBRARIES = \
+ libtalerwire.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/bank-lib/libtalerbank.la \
+ $(top_builddir)/src/util/libtalerutil.la \
+ -lgnunetutil $(XLIB)
+
+
+libtaler_plugin_wire_sepa_la_SOURCES = \
+ plugin_wire_sepa.c
+libtaler_plugin_wire_sepa_la_LIBADD = \
+ $(LTLIBINTL)
+libtaler_plugin_wire_sepa_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)
+
+
+libtalerwire_la_SOURCES = \
+ wire.c
+libtalerwire_la_LIBADD = \
+ -lgnunetutil \
+ $(XLIB)
+libtalerwire_la_LDFLAGS = \
+ -version-info 0:0:0 \
+ -export-dynamic -no-undefined
+
+
+TESTS = \
+ test_sepa_wireformat
+
+check_PROGRAMS= \
+ test_sepa_wireformat
+
+
+
+test_sepa_wireformat_SOURCES = \
+ test_sepa_wireformat.c
+test_sepa_wireformat_LDADD = \
+ -lgnunetutil \
+ -ljansson \
+ libtalerwire.la \
+ $(top_builddir)/src/util/libtalerutil.la
+
diff --git a/src/wire/plugin_wire_sepa.c b/src/wire/plugin_wire_sepa.c
new file mode 100644
index 000000000..00d19d4b0
--- /dev/null
+++ b/src/wire/plugin_wire_sepa.c
@@ -0,0 +1,545 @@
+/*
+ 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 <http://www.gnu.org/licenses/>
+*/
+
+/**
+ * @file plugin_wire_sepa.c
+ * @brief wire plugin for transfers using SEPA/EBICS
+ * @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 SepaClosure
+{
+
+ /**
+ * 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
+sepa_amount_round (void *cls,
+ struct TALER_Amount *amount)
+{
+ struct SepaClosure *sc = cls;
+ uint32_t delta;
+
+ if (0 != strcasecmp (amount->currency,
+ sc->currency))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ delta = amount->fraction % (TALER_AMOUNT_FRAC_BASE / 100);
+ if (0 == delta)
+ return GNUNET_NO;
+ amount->fraction -= delta;
+ return GNUNET_SYSERR;
+}
+
+
+/* Taken from GNU gettext */
+
+/**
+ * Entry in the country table.
+ */
+struct table_entry
+{
+ /**
+ * 2-Character international country code.
+ */
+ const char *code;
+
+ /**
+ * Long English name of the country.
+ */
+ const char *english;
+};
+
+
+/* Keep the following table in sync with gettext.
+ WARNING: the entries should stay sorted according to the code */
+/**
+ * List of country codes.
+ */
+static const struct table_entry country_table[] =
+ {
+ { "AE", "U.A.E." },
+ { "AF", "Afghanistan" },
+ { "AL", "Albania" },
+ { "AM", "Armenia" },
+ { "AN", "Netherlands Antilles" },
+ { "AR", "Argentina" },
+ { "AT", "Austria" },
+ { "AU", "Australia" },
+ { "AZ", "Azerbaijan" },
+ { "BA", "Bosnia and Herzegovina" },
+ { "BD", "Bangladesh" },
+ { "BE", "Belgium" },
+ { "BG", "Bulgaria" },
+ { "BH", "Bahrain" },
+ { "BN", "Brunei Darussalam" },
+ { "BO", "Bolivia" },
+ { "BR", "Brazil" },
+ { "BT", "Bhutan" },
+ { "BY", "Belarus" },
+ { "BZ", "Belize" },
+ { "CA", "Canada" },
+ { "CG", "Congo" },
+ { "CH", "Switzerland" },
+ { "CI", "Cote d'Ivoire" },
+ { "CL", "Chile" },
+ { "CM", "Cameroon" },
+ { "CN", "People's Republic of China" },
+ { "CO", "Colombia" },
+ { "CR", "Costa Rica" },
+ { "CS", "Serbia and Montenegro" },
+ { "CZ", "Czech Republic" },
+ { "DE", "Germany" },
+ { "DK", "Denmark" },
+ { "DO", "Dominican Republic" },
+ { "DZ", "Algeria" },
+ { "EC", "Ecuador" },
+ { "EE", "Estonia" },
+ { "EG", "Egypt" },
+ { "ER", "Eritrea" },
+ { "ES", "Spain" },
+ { "ET", "Ethiopia" },
+ { "FI", "Finland" },
+ { "FO", "Faroe Islands" },
+ { "FR", "France" },
+ { "GB", "United Kingdom" },
+ { "GD", "Caribbean" },
+ { "GE", "Georgia" },
+ { "GL", "Greenland" },
+ { "GR", "Greece" },
+ { "GT", "Guatemala" },
+ { "HK", "Hong Kong" },
+ { "HK", "Hong Kong S.A.R." },
+ { "HN", "Honduras" },
+ { "HR", "Croatia" },
+ { "HT", "Haiti" },
+ { "HU", "Hungary" },
+ { "ID", "Indonesia" },
+ { "IE", "Ireland" },
+ { "IL", "Israel" },
+ { "IN", "India" },
+ { "IQ", "Iraq" },
+ { "IR", "Iran" },
+ { "IS", "Iceland" },
+ { "IT", "Italy" },
+ { "JM", "Jamaica" },
+ { "JO", "Jordan" },
+ { "JP", "Japan" },
+ { "KE", "Kenya" },
+ { "KG", "Kyrgyzstan" },
+ { "KH", "Cambodia" },
+ { "KR", "South Korea" },
+ { "KW", "Kuwait" },
+ { "KZ", "Kazakhstan" },
+ { "LA", "Laos" },
+ { "LB", "Lebanon" },
+ { "LI", "Liechtenstein" },
+ { "LK", "Sri Lanka" },
+ { "LT", "Lithuania" },
+ { "LU", "Luxembourg" },
+ { "LV", "Latvia" },
+ { "LY", "Libya" },
+ { "MA", "Morocco" },
+ { "MC", "Principality of Monaco" },
+ { "MD", "Moldava" },
+ { "MD", "Moldova" },
+ { "ME", "Montenegro" },
+ { "MK", "Former Yugoslav Republic of Macedonia" },
+ { "ML", "Mali" },
+ { "MM", "Myanmar" },
+ { "MN", "Mongolia" },
+ { "MO", "Macau S.A.R." },
+ { "MT", "Malta" },
+ { "MV", "Maldives" },
+ { "MX", "Mexico" },
+ { "MY", "Malaysia" },
+ { "NG", "Nigeria" },
+ { "NI", "Nicaragua" },
+ { "NL", "Netherlands" },
+ { "NO", "Norway" },
+ { "NP", "Nepal" },
+ { "NZ", "New Zealand" },
+ { "OM", "Oman" },
+ { "PA", "Panama" },
+ { "PE", "Peru" },
+ { "PH", "Philippines" },
+ { "PK", "Islamic Republic of Pakistan" },
+ { "PL", "Poland" },
+ { "PR", "Puerto Rico" },
+ { "PT", "Portugal" },
+ { "PY", "Paraguay" },
+ { "QA", "Qatar" },
+ { "RE", "Reunion" },
+ { "RO", "Romania" },
+ { "RS", "Serbia" },
+ { "RU", "Russia" },
+ { "RW", "Rwanda" },
+ { "SA", "Saudi Arabia" },
+ { "SE", "Sweden" },
+ { "SG", "Singapore" },
+ { "SI", "Slovenia" },
+ { "SK", "Slovak" },
+ { "SN", "Senegal" },
+ { "SO", "Somalia" },
+ { "SR", "Suriname" },
+ { "SV", "El Salvador" },
+ { "SY", "Syria" },
+ { "TH", "Thailand" },
+ { "TJ", "Tajikistan" },
+ { "TM", "Turkmenistan" },
+ { "TN", "Tunisia" },
+ { "TR", "Turkey" },
+ { "TT", "Trinidad and Tobago" },
+ { "TW", "Taiwan" },
+ { "TZ", "Tanzania" },
+ { "UA", "Ukraine" },
+ { "US", "United States" },
+ { "UY", "Uruguay" },
+ { "VA", "Vatican" },
+ { "VE", "Venezuela" },
+ { "VN", "Viet Nam" },
+ { "YE", "Yemen" },
+ { "ZA", "South Africa" },
+ { "ZW", "Zimbabwe" }
+ };
+
+
+/**
+ * Country code comparator function, for binary search with bsearch().
+ *
+ * @param ptr1 pointer to a `struct table_entry`
+ * @param ptr2 pointer to a `struct table_entry`
+ * @return result of strncmp()'ing the 2-digit country codes of the entries
+ */
+static int
+cmp_country_code (const void *ptr1,
+ const void *ptr2)
+{
+ const struct table_entry *cc1 = ptr1;
+ const struct table_entry *cc2 = ptr2;
+
+ return strncmp (cc1->code,
+ cc2->code,
+ 2);
+}
+
+
+/**
+ * Validates given IBAN according to the European Banking Standards. See:
+ * http://www.europeanpaymentscouncil.eu/documents/ECBS%20IBAN%20standard%20EBS204_V3.2.pdf
+ *
+ * @param iban the IBAN number to validate
+ * @return #GNUNET_YES if correctly formatted; #GNUNET_NO if not
+ */
+static int
+validate_iban (const char *iban)
+{
+ char cc[2];
+ char ibancpy[35];
+ struct table_entry cc_entry;
+ unsigned int len;
+ char *nbuf;
+ unsigned int i;
+ unsigned int j;
+ unsigned long long dividend;
+ unsigned long long remainder;
+ int nread;
+ int ret;
+
+ len = strlen (iban);
+ if (len > 34)
+ return GNUNET_NO;
+ strncpy (cc, iban, 2);
+ strncpy (ibancpy, iban + 4, len - 4);
+ strncpy (ibancpy + len - 4, iban, 4);
+ ibancpy[len] = '\0';
+ cc_entry.code = cc;
+ cc_entry.english = NULL;
+ if (NULL ==
+ bsearch (&cc_entry,
+ country_table,
+ sizeof (country_table) / sizeof (struct table_entry),
+ sizeof (struct table_entry),
+ &cmp_country_code))
+ return GNUNET_NO;
+ nbuf = GNUNET_malloc ((len * 2) + 1);
+ for (i=0, j=0; i < len; i++)
+ {
+ if (isalpha ((int) ibancpy[i]))
+ {
+ if (2 != snprintf(&nbuf[j],
+ 3,
+ "%2u",
+ (ibancpy[i] - 'A' + 10)))
+ {
+ GNUNET_free (nbuf);
+ return GNUNET_NO;
+ }
+ j += 2;
+ continue;
+ }
+ nbuf[j] = ibancpy[i];
+ j++;
+ }
+ for (j=0;'\0' != nbuf[j];j++)
+ GNUNET_assert (isdigit(nbuf[j]));
+ GNUNET_assert (sizeof(dividend) >= 8);
+ remainder = 0;
+ for (i=0; i<j; i+=16)
+ {
+ if (1 !=
+ (ret = sscanf (&nbuf[i],
+ "%16llu %n",
+ &dividend,
+ &nread)))
+ {
+ GNUNET_free (nbuf);
+ return GNUNET_NO;
+ }
+ if (0 != remainder)
+ dividend += remainder * (pow (10, nread));
+ remainder = dividend % 97;
+ }
+ GNUNET_free (nbuf);
+ if (1 == remainder)
+ return GNUNET_YES;
+ return GNUNET_NO;
+}
+
+
+/**
+ * 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
+sepa_wire_validate (const json_t *wire)
+{
+ json_error_t error;
+ const char *type;
+ const char *iban;
+ const char *name;
+ const char *bic;
+ uint64_t r;
+ const char *address;
+
+ if (0 != json_unpack_ex
+ ((json_t *) wire,
+ &error, JSON_STRICT,
+ "{"
+ "s:s," /* TYPE: sepa */
+ "s:s," /* IBAN: iban */
+ "s:s," /* name: beneficiary name */
+ "s:s," /* BIC: beneficiary bank's BIC */
+ "s:i," /* r: random 64-bit integer nounce */
+ "s:s" /* address: address of the beneficiary */
+ "}",
+ "type", &type,
+ "IBAN", &iban,
+ "name", &name,
+ "bic", &bic,
+ "r", &r,
+ "address", &address))
+ {
+ TALER_json_warn (error);
+ return GNUNET_SYSERR;
+ }
+ if (0 != strcasecmp (type,
+ "sepa"))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Transfer type `%s' invalid\n",
+ type);
+ return GNUNET_SYSERR;
+ }
+ if (1 != validate_iban (iban))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "IBAN `%s' invalid\n",
+ iban);
+ return GNUNET_NO;
+ }
+ return GNUNET_YES;
+}
+
+
+/**
+ * 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 psc function to call with the prepared data to persist
+ * @param psc_cls closure for @a psc
+ * @return NULL on failure
+ */
+static struct TALER_WIRE_PrepareHandle *
+sepa_prepare_wire_transfer (void *cls,
+ const json_t *wire,
+ const struct TALER_Amount *amount,
+ const struct TALER_WireTransferIdentifierRawP *wtid,
+ TALER_WIRE_PrepareTransactionCallback psc,
+ void *psc_cls)
+{
+ GNUNET_break (0); // FIXME: not implemented
+ 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
+sepa_prepare_wire_transfer_cancel (void *cls,
+ struct TALER_WIRE_PrepareHandle *pth)
+{
+ GNUNET_break (0); // FIXME: not implemented
+}
+
+
+/**
+ * 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 *
+sepa_execute_wire_transfer (void *cls,
+ const char *buf,
+ size_t buf_size,
+ TALER_WIRE_ConfirmationCallback cc,
+ void *cc_cls)
+{
+ GNUNET_break (0); // FIXME: not implemented
+ 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
+sepa_execute_wire_transfer_cancel (void *cls,
+ struct TALER_WIRE_ExecuteHandle *eh)
+{
+ GNUNET_break (0); // FIXME: not implemented
+}
+
+
+/**
+ * Initialize sepa-wire subsystem.
+ *
+ * @param cls a configuration instance
+ * @return NULL on error, otherwise a `struct TALER_WIRE_Plugin`
+ */
+void *
+libtaler_plugin_wire_sepa_init (void *cls)
+{
+ struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+ struct SepaClosure *sc;
+ struct TALER_WIRE_Plugin *plugin;
+
+ sc = GNUNET_new (struct SepaClosure);
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string (cfg,
+ "mint",
+ "CURRENCY",
+ &sc->currency))
+ {
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+ "mint",
+ "CURRENCY");
+ GNUNET_free (sc);
+ return NULL;
+ }
+
+ plugin = GNUNET_new (struct TALER_WIRE_Plugin);
+ plugin->cls = sc;
+ plugin->amount_round = &sepa_amount_round;
+ plugin->wire_validate = &sepa_wire_validate;
+ plugin->prepare_wire_transfer = &sepa_prepare_wire_transfer;
+ plugin->prepare_wire_transfer_cancel = &sepa_prepare_wire_transfer_cancel;
+ plugin->execute_wire_transfer = &sepa_execute_wire_transfer;
+ plugin->execute_wire_transfer_cancel = &sepa_execute_wire_transfer_cancel;
+ return plugin;
+}
+
+
+/**
+ * Shutdown Sepa wire subsystem.
+ *
+ * @param cls a `struct TALER_WIRE_Plugin`
+ * @return NULL (always)
+ */
+void *
+libtaler_plugin_wire_sepa_done (void *cls)
+{
+ struct TALER_WIRE_Plugin *plugin = cls;
+ struct SepaClosure *sc = plugin->cls;
+
+ GNUNET_free (sc->currency);
+ GNUNET_free (sc);
+ GNUNET_free (plugin);
+ return NULL;
+}
+
+/* end of plugin_wire_sepa.c */
diff --git a/src/wire/plugin_wire_template.c b/src/wire/plugin_wire_template.c
new file mode 100644
index 000000000..baf0ee7d5
--- /dev/null
+++ b/src/wire/plugin_wire_template.c
@@ -0,0 +1,243 @@
+/*
+ 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 <http://www.gnu.org/licenses/>
+*/
+
+/**
+ * @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)
+{
+ 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;
+}
+
+
+/**
+ * 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 struct TALER_WireTransferIdentifierRawP *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..7940b4775
--- /dev/null
+++ b/src/wire/plugin_wire_test.c
@@ -0,0 +1,581 @@
+/*
+ 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 <http://www.gnu.org/licenses/>
+*/
+
+/**
+ * @file plugin_wire_test.c
+ * @brief plugin for the "test" wire method
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "taler_wire_plugin.h"
+#include "taler_bank_service.h"
+
+/* only for HTTP status codes */
+#include <microhttpd.h>
+
+/**
+ * Type of the "cls" argument given to each of the functions in
+ * our API.
+ */
+struct TestClosure
+{
+
+ /**
+ * Handle to the bank for sending funds to the bank.
+ */
+ struct TALER_BANK_Context *bank;
+
+ /**
+ * Which currency do we support?
+ */
+ char *currency;
+
+ /**
+ * Handle to the bank task, or NULL.
+ */
+ struct GNUNET_SCHEDULER_Task *bt;
+
+};
+
+
+/**
+ * Handle returned by #test_prepare_wire_transfer.
+ */
+struct TALER_WIRE_PrepareHandle
+{
+
+ /**
+ * Task we use for async execution.
+ */
+ struct GNUNET_SCHEDULER_Task *task;
+
+ /**
+ * Test closure we run in.
+ */
+ struct TestClosure *tc;
+
+ /**
+ * Wire data for the transfer.
+ */
+ json_t *wire;
+
+ /**
+ * Function to call with the serialized data.
+ */
+ TALER_WIRE_PrepareTransactionCallback ptc;
+
+ /**
+ * Closure for @e ptc.
+ */
+ void *ptc_cls;
+
+ /**
+ * Amount to transfer.
+ */
+ struct TALER_Amount amount;
+
+ /**
+ * Subject of the wire transfer.
+ */
+ struct TALER_WireTransferIdentifierRawP wtid;
+
+
+};
+
+
+/**
+ * Handle returned by #test_execute_wire_transfer.
+ */
+struct TALER_WIRE_ExecuteHandle
+{
+
+ /**
+ * Handle to the HTTP request to the bank.
+ */
+ struct TALER_BANK_AdminAddIncomingHandle *aaih;
+
+ /**
+ * Function to call with the result.
+ */
+ TALER_WIRE_ConfirmationCallback cc;
+
+ /**
+ * Closure for @e cc.
+ */
+ void *cc_cls;
+};
+
+
+/**
+ * Task that runs the bank's context's event loop with the GNUnet
+ * scheduler.
+ *
+ * @param cls our `struct TestClosure`
+ * @param tc scheduler context (unused)
+ */
+static void
+context_task (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *sct)
+{
+ struct TestClosure *tc = cls;
+ long timeout;
+ int max_fd;
+ fd_set read_fd_set;
+ fd_set write_fd_set;
+ fd_set except_fd_set;
+ struct GNUNET_NETWORK_FDSet *rs;
+ struct GNUNET_NETWORK_FDSet *ws;
+ struct GNUNET_TIME_Relative delay;
+
+ tc->bt = NULL;
+ TALER_BANK_perform (tc->bank);
+ max_fd = -1;
+ timeout = -1;
+ FD_ZERO (&read_fd_set);
+ FD_ZERO (&write_fd_set);
+ FD_ZERO (&except_fd_set);
+ TALER_BANK_get_select_info (tc->bank,
+ &read_fd_set,
+ &write_fd_set,
+ &except_fd_set,
+ &max_fd,
+ &timeout);
+ if (timeout >= 0)
+ delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
+ timeout);
+ else
+ delay = GNUNET_TIME_UNIT_FOREVER_REL;
+ rs = GNUNET_NETWORK_fdset_create ();
+ GNUNET_NETWORK_fdset_copy_native (rs,
+ &read_fd_set,
+ max_fd + 1);
+ ws = GNUNET_NETWORK_fdset_create ();
+ GNUNET_NETWORK_fdset_copy_native (ws,
+ &write_fd_set,
+ max_fd + 1);
+ tc->bt = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+ delay,
+ rs,
+ ws,
+ &context_task,
+ cls);
+ GNUNET_NETWORK_fdset_destroy (rs);
+ GNUNET_NETWORK_fdset_destroy (ws);
+}
+
+
+/**
+ * Run the bank task now.
+ *
+ * @param tc context for which we should initiate running the task
+ */
+static void
+run_bt (struct TestClosure *tc)
+{
+ if (NULL != tc->bt)
+ GNUNET_SCHEDULER_cancel (tc->bt);
+ tc->bt = GNUNET_SCHEDULER_add_now (&context_task,
+ tc);
+}
+
+
+/**
+ * Round amount DOWN to the amount that can be transferred via the wire
+ * method. For example, Taler may support 0.000001 EUR as a unit of
+ * payment, but SEPA only supports 0.01 EUR. This function would
+ * round 0.125 EUR to 0.12 EUR in this case.
+ *
+ * @param cls the @e cls of this struct with the plugin-specific state
+ * @param[in,out] amount amount to round down
+ * @return #GNUNET_OK on success, #GNUNET_NO if rounding was unnecessary,
+ * #GNUNET_SYSERR if the amount or currency was invalid
+ */
+static int
+test_amount_round (void *cls,
+ struct TALER_Amount *amount)
+{
+ struct TestClosure *tc = cls;
+ uint32_t delta;
+
+ if (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;
+}
+
+
+/**
+ * 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); /* FIXME: we still need to define the
+ proper wire format for 'test' */
+ return GNUNET_YES;
+}
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+/**
+ * Format we used for serialized transaction data.
+ */
+struct BufFormatP
+{
+
+ /**
+ * The wire transfer identifier.
+ */
+ struct TALER_WireTransferIdentifierRawP wtid;
+
+ /**
+ * The amount.
+ */
+ struct TALER_AmountNBO amount;
+
+ /* followed by serialized 'wire' JSON data */
+
+};
+GNUNET_NETWORK_STRUCT_END
+
+
+/**
+ * Prepare for exeuction of a wire transfer. Calls the
+ * callback with the serialized state.
+ *
+ * @param cls the `struct TALER_WIRE_PrepareHandle`
+ * @param sct unused
+ */
+static void
+do_prepare (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *sct)
+{
+ struct TALER_WIRE_PrepareHandle *pth = cls;
+ char *wire_enc;
+ size_t len;
+ struct BufFormatP bf;
+
+ pth->task = NULL;
+ /* serialize the state into a 'buf' */
+ wire_enc = json_dumps (pth->wire,
+ JSON_COMPACT | JSON_SORT_KEYS);
+ if (NULL == wire_enc)
+ {
+ GNUNET_break (0);
+ pth->ptc (pth->ptc_cls,
+ NULL,
+ 0);
+ GNUNET_free (pth);
+ return;
+ }
+ len = strlen (wire_enc) + 1;
+ bf.wtid = pth->wtid;
+ TALER_amount_hton (&bf.amount,
+ &pth->amount);
+ {
+ char buf[sizeof (struct BufFormatP) + len];
+
+ memcpy (buf,
+ &bf,
+ sizeof (struct BufFormatP));
+ memcpy (&buf[sizeof (struct BufFormatP)],
+ wire_enc,
+ len);
+
+ /* finally give the state back */
+ pth->ptc (pth->ptc_cls,
+ buf,
+ sizeof (buf));
+ }
+ free (wire_enc); /* not using GNUNET_free(),
+ as this one is allocated by libjansson */
+ GNUNET_free (pth);
+}
+
+
+/**
+ * Prepare for exeuction of a wire transfer. Note that we should call
+ * @a ptc asynchronously (as that is what the API requires, because
+ * some transfer methods need it). So while we could immediately call
+ * @a ptc, we first bundle up all the data and schedule a task to do
+ * the work.
+ *
+ * @param cls the @e cls of this struct with the plugin-specific state
+ * @param wire valid wire account information
+ * @param amount amount to transfer, already rounded
+ * @param wtid wire transfer identifier to use
+ * @param ptc function to call with the prepared data to persist
+ * @param ptc_cls closure for @a ptc
+ * @return NULL on failure
+ */
+static struct TALER_WIRE_PrepareHandle *
+test_prepare_wire_transfer (void *cls,
+ const json_t *wire,
+ const struct TALER_Amount *amount,
+ const struct TALER_WireTransferIdentifierRawP *wtid,
+ TALER_WIRE_PrepareTransactionCallback ptc,
+ void *ptc_cls)
+{
+ struct TestClosure *tc = cls;
+ struct TALER_WIRE_PrepareHandle *pth;
+
+ if (GNUNET_YES !=
+ test_wire_validate (wire))
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
+ pth = GNUNET_new (struct TALER_WIRE_PrepareHandle);
+ pth->tc = tc;
+ pth->wire = (json_t *) wire;
+ json_incref (pth->wire);
+ pth->wtid = *wtid;
+ pth->ptc = ptc;
+ pth->ptc_cls = ptc_cls;
+ pth->amount = *amount;
+ pth->task = GNUNET_SCHEDULER_add_now (&do_prepare,
+ pth);
+ return pth;
+}
+
+
+/**
+ * Abort preparation of a wire transfer. For example,
+ * because we are shutting down.
+ *
+ * @param cls the @e cls of this struct with the plugin-specific state
+ * @param pth preparation to cancel
+ */
+static void
+test_prepare_wire_transfer_cancel (void *cls,
+ struct TALER_WIRE_PrepareHandle *pth)
+{
+ GNUNET_SCHEDULER_cancel (pth->task);
+ json_decref (pth->wire);
+ GNUNET_free (pth);
+}
+
+
+/**
+ * Called with the result of submitting information about an incoming
+ * transaction to a bank.
+ *
+ * @param cls closure with the `struct TALER_WIRE_ExecuteHandle`
+ * @param http_status HTTP response code, #MHD_HTTP_OK (200) for successful status request
+ * 0 if the bank's reply is bogus (fails to follow the protocol)
+ */
+static void
+execute_cb (void *cls,
+ unsigned int http_status)
+{
+ struct TALER_WIRE_ExecuteHandle *eh = cls;
+ char s[14];
+
+ eh->aaih = NULL;
+ GNUNET_snprintf (s,
+ sizeof (s),
+ "%u",
+ http_status);
+ eh->cc (eh->cc_cls,
+ (MHD_HTTP_OK == http_status) ? GNUNET_OK : GNUNET_SYSERR,
+ (MHD_HTTP_OK == http_status) ? NULL : s);
+ GNUNET_free (eh);
+}
+
+
+/**
+ * Execute a wire transfer.
+ *
+ * @param cls the @e cls of this struct with the plugin-specific state
+ * @param buf buffer with the prepared execution details
+ * @param buf_size number of bytes in @a buf
+ * @param cc function to call upon success
+ * @param cc_cls closure for @a cc
+ * @return NULL on error
+ */
+static struct TALER_WIRE_ExecuteHandle *
+test_execute_wire_transfer (void *cls,
+ const char *buf,
+ size_t buf_size,
+ TALER_WIRE_ConfirmationCallback cc,
+ void *cc_cls)
+{
+ struct TestClosure *tc = cls;
+ struct TALER_WIRE_ExecuteHandle *eh;
+ json_t *wire;
+ struct TALER_Amount amount;
+ struct BufFormatP bf;
+
+ 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));
+ eh = GNUNET_new (struct TALER_WIRE_ExecuteHandle);
+ eh->cc = cc;
+ eh->cc_cls = cc_cls;
+ eh->aaih = TALER_BANK_admin_add_incoming (tc->bank,
+ &bf.wtid,
+ &amount,
+ wire,
+ &execute_cb,
+ eh);
+ json_decref (wire);
+ if (NULL == eh->aaih)
+ {
+ GNUNET_break (0);
+ GNUNET_free (eh);
+ return NULL;
+ }
+ run_bt (tc);
+ return eh;
+}
+
+
+/**
+ * Abort execution of a wire transfer. For example, because we are
+ * shutting down. Note that if an execution is aborted, it may or
+ * may not still succeed. The caller MUST run @e
+ * execute_wire_transfer again for the same request as soon as
+ * possilbe, to ensure that the request either ultimately succeeds
+ * or ultimately fails. Until this has been done, the transaction is
+ * in limbo (i.e. may or may not have been committed).
+ *
+ * @param cls the @e cls of this struct with the plugin-specific state
+ * @param eh execution to cancel
+ */
+static void
+test_execute_wire_transfer_cancel (void *cls,
+ struct TALER_WIRE_ExecuteHandle *eh)
+{
+ TALER_BANK_admin_add_incoming_cancel (eh->aaih);
+ GNUNET_free (eh);
+}
+
+
+/**
+ * Initialize test-wire subsystem.
+ *
+ * @param cls a configuration instance
+ * @return NULL on error, otherwise a `struct TALER_WIRE_Plugin`
+ */
+void *
+libtaler_plugin_wire_test_init (void *cls)
+{
+ struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+ struct TestClosure *tc;
+ struct TALER_WIRE_Plugin *plugin;
+ char *uri;
+
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string (cfg,
+ "wire-test",
+ "bank_uri",
+ &uri))
+ {
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+ "wire-test",
+ "bank_uri");
+ return NULL;
+ }
+ tc = GNUNET_new (struct TestClosure);
+ 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 (uri);
+ GNUNET_free (tc);
+ return NULL;
+ }
+ tc->bank = TALER_BANK_init (uri);
+ if (NULL == tc->bank)
+ {
+ GNUNET_break (0);
+ GNUNET_free (tc->currency);
+ 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;
+
+ if (NULL != tc->bt)
+ {
+ GNUNET_SCHEDULER_cancel (tc->bt);
+ tc->bt = NULL;
+ }
+ TALER_BANK_fini (tc->bank);
+ GNUNET_free (tc->currency);
+ GNUNET_free (tc);
+ GNUNET_free (plugin);
+ return NULL;
+}
+
+/* end of plugin_wire_test.c */
diff --git a/src/wire/test_sepa_wireformat.c b/src/wire/test_sepa_wireformat.c
new file mode 100644
index 000000000..edbe5bc45
--- /dev/null
+++ b/src/wire/test_sepa_wireformat.c
@@ -0,0 +1,104 @@
+/*
+ This file is part of TALER
+ (C) 2015, 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 <http://www.gnu.org/licenses/>
+*/
+
+/**
+ * @file wire/test_sepa_wireformat.c
+ * @brief Tests for JSON SEPA format validation
+ * @author Sree Harsha Totakura <sreeharsha@totakura.in>
+ */
+
+#include "platform.h"
+#include "taler_util.h"
+#include "taler_wire_lib.h"
+
+
+/* Valid SEPA data */
+static const char * const valid_wire_str =
+ "{ \"type\":\"SEPA\", \
+\"IBAN\":\"DE67830654080004822650\", \
+\"name\":\"GNUnet e.V.\", \
+\"bic\":\"GENODEF1SLR\", \
+\"r\":123456789, \
+\"address\": \"foobar\"}";
+
+/* IBAN has wrong country code */
+static const char * const invalid_wire_str =
+ "{ \"type\":\"SEPA\", \
+\"IBAN\":\"XX67830654080004822650\", \
+\"name\":\"GNUnet e.V.\", \
+\"bic\":\"GENODEF1SLR\", \
+\"r\":123456789, \
+\"address\": \"foobar\"}";
+
+/* IBAN has wrong checksum */
+static const char * const invalid_wire_str2 =
+ "{ \"type\":\"SEPA\", \
+\"IBAN\":\"DE67830654080004822651\", \
+\"name\":\"GNUnet e.V.\", \
+\"bic\":\"GENODEF1SLR\", \
+\"r\":123456789, \
+\"address\": \"foobar\"}";
+
+/* Unsupported wireformat type */
+static const char * const unsupported_wire_str =
+ "{ \"type\":\"unsupported\", \
+\"IBAN\":\"DE67830654080004822650\", \
+\"name\":\"GNUnet e.V.\", \
+\"bic\":\"GENODEF1SLR\", \
+\"r\":123456789, \
+\"address\": \"foobar\"}";
+
+
+int
+main(int argc,
+ const char *const argv[])
+{
+ json_t *wire;
+ json_error_t error;
+ int ret;
+ struct GNUNET_CONFIGURATION_Handle *cfg;
+ struct TALER_WIRE_Plugin *plugin;
+
+ GNUNET_log_setup ("test-sepa-wireformats",
+ "WARNING",
+ NULL);
+ cfg = GNUNET_CONFIGURATION_create ();
+ GNUNET_CONFIGURATION_set_value_string (cfg,
+ "mint",
+ "currency",
+ "EUR");
+ plugin = TALER_WIRE_plugin_load (cfg,
+ "sepa");
+ GNUNET_assert (NULL != plugin);
+ (void) memset(&error, 0, sizeof(error));
+ GNUNET_assert (NULL != (wire = json_loads (unsupported_wire_str, 0, NULL)));
+ GNUNET_assert (GNUNET_YES != plugin->wire_validate (wire));
+ json_decref (wire);
+ GNUNET_assert (NULL != (wire = json_loads (invalid_wire_str, 0, NULL)));
+ GNUNET_assert (GNUNET_NO == plugin->wire_validate (wire));
+ json_decref (wire);
+ GNUNET_assert (NULL != (wire = json_loads (invalid_wire_str2, 0, NULL)));
+ GNUNET_assert (GNUNET_NO == plugin->wire_validate (wire));
+ json_decref (wire);
+ GNUNET_assert (NULL != (wire = json_loads (valid_wire_str, 0, &error)));
+ ret = plugin->wire_validate (wire);
+ json_decref (wire);
+ TALER_WIRE_plugin_unload (plugin);
+ GNUNET_CONFIGURATION_destroy (cfg);
+ if (GNUNET_NO == ret)
+ return 1;
+ return 0;
+}
diff --git a/src/wire/wire.c b/src/wire/wire.c
new file mode 100644
index 000000000..f0c0cd7a9
--- /dev/null
+++ b/src/wire/wire.c
@@ -0,0 +1,72 @@
+/*
+ This file is part of TALER
+ (C) 2015, 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 <http://www.gnu.org/licenses/>
+*/
+
+/**
+ * @file wire/wire.c
+ * @brief Functions for loading wire plugins
+ * @author Christian Grothoff <christian@grothoff.org>
+ */
+#include "platform.h"
+#include "taler_util.h"
+#include "taler_wire_lib.h"
+
+/**
+ * Load a WIRE plugin.
+ *
+ * @param cfg configuration to use
+ * @param plugin_name name of the plugin to load
+ * @return #GNUNET_OK on success
+ */
+struct TALER_WIRE_Plugin *
+TALER_WIRE_plugin_load (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ const char *plugin_name)
+{
+ char *lib_name;
+ struct TALER_WIRE_Plugin *plugin;
+
+ (void) GNUNET_asprintf (&lib_name,
+ "libtaler_plugin_wire_%s",
+ plugin_name);
+ plugin = GNUNET_PLUGIN_load (lib_name,
+ (void *) cfg);
+ if (NULL != plugin)
+ plugin->library_name = lib_name;
+ else
+ GNUNET_free (lib_name);
+ return plugin;
+}
+
+
+/**
+ * Unload a WIRE plugin.
+ *
+ * @param plugin the plugin to unload
+ */
+void
+TALER_WIRE_plugin_unload (struct TALER_WIRE_Plugin *plugin)
+{
+ char *lib_name;
+
+ if (NULL == plugin)
+ return;
+ lib_name = plugin->library_name;
+ GNUNET_assert (NULL == GNUNET_PLUGIN_unload (lib_name,
+ plugin));
+ GNUNET_free (lib_name);
+}
+
+
+/* end of wire.c */
generated by cgit v1.2.3 (git 2.26.2) at 2024-09-13 18:23:09 +0000