taler/exchange
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
3ec07d62c3
exchange/src/extensions/auction_brandt/extension_auction_brandt.c

734 lines
19 KiB
C
Raw Blame History

/*
This file is part of TALER
Copyright (C) 2021-2022 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 extension_auction_brandt.c
* @brief Extension for replay of auctions of type brandt
* @author Özgür Kesim
*/
#include "platform.h"
#include "taler_util.h"
#include "taler_extensions.h"
#include "../../exchange/taler-exchange-httpd.h"
#include "taler_mhd_lib.h"
#include "stdint.h"
#include <microhttpd.h>
#define AUCTION_BRANDT "auction_brandt"
#define LOG_PREFIX "[auction_brandt] "
#define MAX_RESULT_SIZE 10 * 1024
/* Path to the replay program. */
static char *replay_program;
/* supported currency */
static char *currency;
/* This is basically BRANDT_Result with an extra string field */
struct result
{
uint16_t bidder;
uint16_t price_idx;
const char *price;
};
/*
* @brief Transcript information
*
*/
struct transcript
{
/*
* The first couple of fields are from a JSON transcript
*/
/* Public key of seller */
struct GNUNET_CRYPTO_EddsaPublicKey seller_pub;
/* Payto URL */
const char *payto;
/* Number of bidders + 1 (for seller) */
uint16_t n;
/* (n-1) public keys of bidders */
struct GNUNET_CRYPTO_EddsaPublicKey *bidder_pub;
/* Type of auction, see libbrandt */
uint16_t m;
/* Auction public outcome? */
bool public;
/* Start date of the auction */
struct GNUNET_TIME_Timestamp time_start;
/* End date of the auction */
struct GNUNET_TIME_Relative time_round;
/* Number of prices */
uint16_t k;
/* Prices, must be length k */
struct TALER_Amount *prices;
/* Expected winner(s), maybe NULL */
struct result *expected;
size_t expected_len;
/*
* These are the results from the replay via the external program.
*/
struct result *results;
size_t results_len;
};
/**
* @brief returns an JSON with the error
*/
static enum GNUNET_GenericReturnValue
json_error (json_t **output,
char *error, ...)
{
va_list ap;
int n = 0;
char buf[4096];
GNUNET_assert (error);
va_start (ap, error);
n = vsprintf (buf, error, ap);
va_end (ap);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
LOG_PREFIX "got error: %s\n",
n < 0 ? error: buf);
*output = json_pack ("{s:s}",
"error",
n < 0 ? error : buf);
GNUNET_assert (*output);
return GNUNET_SYSERR;
};
/**
* @brief returns an JSON with the result
*/
#if 0
static enum GNUNET_GenericReturnValue
json_result (json_t **output,
const struct transcript *tr)
{
json_t *results;
GNUNET_assert (NULL != tr);
*output = json_object ();
results = json_array ();
GNUNET_assert (*output);
GNUNET_assert (results);
for (size_t i = 0; i < tr->results_len; i++)
{
json_t *result = json_pack ("{s:i, s:s}",
"bidder", tr->results[i].bidder,
"price", tr->results[i].price);
GNUNET_assert (result);
GNUNET_assert (-1 !=
json_array_append_new (results, result));
}
GNUNET_assert (-1 !=
json_object_set_new (*output,
"winners",
results));
return GNUNET_OK;
}
#endif
/*
* @brief Parses a given json as transcript.
*
* @param[in] jtr JSON input
* @param[out] tr Parsed transcript data
* @param[out] jerror JSON output for errors
* @return GNUNET_OK on succes
*
* TODO:
* - parse and verify signatures
*/
static enum GNUNET_GenericReturnValue
parse_transcript (const json_t *jtr,
struct transcript *tr,
json_t **jerror)
{
json_t *auc;
// TODO: struct GNUNET_CRYPTO_EddsaSignature sig;
GNUNET_assert (jtr);
GNUNET_assert (tr);
// Parse auction
{
char *perr;
unsigned int eline;
struct GNUNET_JSON_Specification au_spec[] = {
GNUNET_JSON_spec_bool ("public", &tr->public),
GNUNET_JSON_spec_uint16 ("type", &tr->m),
GNUNET_JSON_spec_fixed_auto ("pubkey", &tr->seller_pub),
GNUNET_JSON_spec_timestamp ("time_start", &tr->time_start),
GNUNET_JSON_spec_relative_time ("time_round", &tr->time_round),
GNUNET_JSON_spec_string ("payto", &tr->payto),
GNUNET_JSON_spec_end ()
};
auc = json_object_get (jtr, "auction");
if (NULL == auc)
return json_error (jerror,
"no auction found in transcript");
if (GNUNET_OK !=
GNUNET_JSON_parse (auc,
au_spec,
(const char **) &perr,
&eline))
return json_error (jerror,
perr);
// Prices...
{
size_t idx;
json_t *val;
json_t *prices;
prices = json_object_get (auc, "prices");
if (! json_is_array (prices))
return json_error (jerror,
"no prices found");
tr->k = json_array_size (prices);
tr->prices = GNUNET_new_array (tr->k, struct TALER_Amount);
json_array_foreach (prices, idx, val)
{
struct GNUNET_JSON_Specification spec[] = {
TALER_JSON_spec_amount (NULL,
currency,
&(tr->prices[idx])),
GNUNET_JSON_spec_end (),
};
if (GNUNET_OK !=
GNUNET_JSON_parse (val,
spec,
NULL,
NULL))
return json_error (jerror,
"price no. %ld couldn't be parsed",
idx + 1);
}
}
}
// Bidders
{
size_t idx;
json_t *val;
json_t *bidders;
bidders = json_object_get (jtr, "bidders");
if (! bidders || ! json_is_array (bidders))
return json_error (jerror,
"no bidders found");
tr->n = json_array_size (bidders);
tr->bidder_pub = GNUNET_new_array (tr->n, struct
GNUNET_CRYPTO_EddsaPublicKey);
json_array_foreach (bidders, idx, val)
{
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_fixed_auto (NULL,
&(tr->bidder_pub[idx])),
GNUNET_JSON_spec_end (),
};
if (GNUNET_OK !=
GNUNET_JSON_parse (val,
spec,
NULL,
NULL))
return json_error (jerror,
"bidder no %ld public key couldn't be parsed",
idx + 1);
}
}
// TODO: parse and verify signatures from bidders of the auction
// Messages
{
size_t nm;
json_t *messages = json_object_get (jtr, "transcript");
if (! json_is_array (messages))
return json_error (jerror,
"no messages found");
nm = json_array_size (messages);
if (nm != (4 * tr->n))
return json_error (jerror,
"not the right no. of messages found");
/* TODO: parse and evaluate signatures */
}
// Winners
{
size_t idx;
json_t *val;
json_t *winners = json_object_get (jtr, "winners");
if (! json_is_array (winners))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
LOG_PREFIX "winners not provided, continuing without\n");
goto DONE;
}
tr->expected_len = json_array_size (winners);
tr->expected = GNUNET_new_array (tr->expected_len,
struct result);
json_array_foreach (winners, idx, val) {
struct GNUNET_JSON_Specification spec[] = {
GNUNET_JSON_spec_uint16 ("bidder",
&(tr->expected[idx].bidder)),
GNUNET_JSON_spec_uint16 ("price_idx",
&(tr->expected[idx].price_idx)),
GNUNET_JSON_spec_string ("price",
&(tr->expected[idx].price)),
GNUNET_JSON_spec_end ()
};
if (GNUNET_OK !=
GNUNET_JSON_parse (val,
spec,
NULL,
NULL))
return json_error (jerror,
"couldn't parse winner no. %ld",
idx + 1);
}
}
// TODO: parse and evalue sig of seller
// TODO: check for max values
DONE:
*jerror = NULL;
return GNUNET_OK;
}
/**
* @brief replay an auction using the external program
*
* @param[in] root The original JSON transcript
* @param[in] transcript The transcript object parsed so far
* @param[out] result The JSON result from the program
* @return GNUNET_OK on success
*
* TODO: Make this resumable
*/
static enum GNUNET_GenericReturnValue
replay_transcript (const json_t*root,
struct transcript *tr,
json_t **result)
{
struct GNUNET_DISK_PipeHandle *pi;
struct GNUNET_DISK_PipeHandle *po;
const struct GNUNET_DISK_FileHandle *fd;
struct GNUNET_OS_Process *proc;
pi = GNUNET_DISK_pipe (GNUNET_DISK_PF_BLOCKING_WRITE);
po = GNUNET_DISK_pipe (GNUNET_DISK_PF_BLOCKING_READ);
proc = GNUNET_OS_start_process (GNUNET_OS_INHERIT_STD_ERR,
pi, po, NULL,
replay_program,
replay_program,
NULL);
if (NULL == proc)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
LOG_PREFIX "couldn't create auction replay program '%s'\n",
replay_program);
return json_error (result, "internal error");
}
// Write original transcript JSON to stdin
{
ssize_t sz;
char *str;
size_t str_len;
fd = GNUNET_DISK_pipe_handle (pi, GNUNET_DISK_PIPE_END_WRITE);
str = json_dumps (root, JSON_COMPACT);
str_len = strlen (str);
sz = GNUNET_DISK_file_write (fd,
str,
str_len);
free (str);
if (sz != str_len)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
LOG_PREFIX "couldn't write all data to replay_program\n");
}
}
// Read output from stdout
{
ssize_t sz;
char buf[MAX_RESULT_SIZE];
json_error_t error;
json_t *res;
fd = GNUNET_DISK_pipe_handle (po, GNUNET_DISK_PIPE_END_READ);
sz = GNUNET_DISK_file_read (fd,
buf,
sizeof(buf));
if (GNUNET_SYSERR == sz)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
LOG_PREFIX "couldn't read data from replay_program\n");
return json_error (result, "internal error");
}
buf[sz] = 0;
res = json_loads (buf,
JSON_DECODE_ANY,
&error);
if (! res)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
LOG_PREFIX
"couldn't parse response from replay_program: %s (for '%s')\n",
error.text,
buf);
return json_error (result, error.text);
}
// Handle error case first
{
json_t *err = json_object_get (res,
"error");
if (NULL != err)
{
*result = json_copy (res);
json_decref (res);
return GNUNET_SYSERR;
}
}
// Parse the result
{
json_t *winners = json_object_get (res,
"winners");
if ((NULL == winners) ||
(! json_is_array (winners)))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
LOG_PREFIX
"replay program didn't return a known result type, instead: '%s'\n",
json_dumps (res, JSON_INDENT (2)));
return json_error (result, "internal error");
}
{
// TODO: check each winner with tr->expected, if applicable
json_object_set (res, "exchange_sig", json_string (
"sig(priv_E, winners)"));
}
// TODO: return own result object.
*result = json_copy (res);
json_decref (res);
}
}
if (GNUNET_OK != GNUNET_OS_process_wait (proc))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
LOG_PREFIX "error while launching auction replay program '%s'\n",
replay_program);
json_object_clear (*result);
return json_error (result, "internal error");
}
return GNUNET_OK;
}
/**
* @brief implements the TALER_Extension.disable interface.
*
* @param ext Pointer to the current extension
*/
static void
auction_disable (
struct TALER_Extension *ext)
{
/* TODO: cleanup configuration */
ext->enabled = false;
}
/**
* @brief implements the TALER_Extension.test_json_config interface.
*
* @param config configuration as json_t* to test
* @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise.
*/
static enum GNUNET_GenericReturnValue
auction_test_json_config (
const json_t *config)
{
/* This extension has no configuration */
return GNUNET_OK;
}
/**
* @brief implements the TALER_Extension.config_to_json interface.
*
* @param ext if NULL, only tests the configuration
* @return configuration as json_t* object, maybe NULL
*/
static json_t *
auction_config_to_json (
const struct TALER_Extension *ext)
{
/* TODO: add configuration */
return GNUNET_JSON_PACK (
GNUNET_JSON_pack_bool ("critical", ext->critical),
GNUNET_JSON_pack_string ("version", ext->version));
}
/**
* @brief implements the TALER_Extension.load_json_config interface.
*
* @param ext if NULL, only tests the configuration
* @param jconfig the configuration as json
*/
static enum GNUNET_GenericReturnValue
auction_load_json_config (
struct TALER_Extension *ext,
json_t *jconfig)
{
/* TODO: add configuration */
ext->enabled = true;
return GNUNET_OK;
}
/**
* @brief implements the TALER_Extension.http_get_handler
*/
static MHD_RESULT
auction_http_get_handler (
struct MHD_Connection *connection,
const char *const args[])
{
/* TODO: return some meta-data about supported version, limits, etc.*/
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
LOG_PREFIX "auction_http_get_handler not implemented yet\n");
return TALER_MHD_reply_with_error (connection,
MHD_HTTP_NOT_IMPLEMENTED,
TALER_EC_EXCHANGE_GENERIC_OPERATION_UNKNOWN,
"auction_http_get_handler not implemented yet\n");
}
/**
* @brief implements the TALER_Extension.http_post_handler
*
* TODO: make this non-blocking
*/
static MHD_RESULT
auction_http_post_handler (
struct MHD_Connection *connection,
const json_t *root,
const char *const args[])
{
struct transcript tr = {};
enum GNUNET_GenericReturnValue ret;
json_t *result1;
json_t *result2;
ret = parse_transcript (root,
&tr,
&result1);
if (GNUNET_OK != ret)
return TALER_MHD_reply_json_steal (connection,
result1,
MHD_HTTP_BAD_REQUEST);
GNUNET_assert (NULL == result1);
ret = replay_transcript (root,
&tr,
&result2);
return TALER_MHD_reply_json_steal (connection,
result2,
GNUNET_OK == ret?
MHD_HTTP_OK :
MHD_HTTP_BAD_REQUEST);
}
/* The extension struct for auctions of brandt-style */
struct TALER_Extension TE_auction_brandt = {
.type = TALER_Extension_AuctionBrandt,
.name = AUCTION_BRANDT,
.critical = false,
.version = "0",
.enabled = false, /* disabled per default */
.has_config = true,
.config = NULL,
.config_json = NULL,
.disable = &auction_disable,
.test_json_config = &auction_test_json_config,
.load_json_config = &auction_load_json_config,
.config_to_json = &auction_config_to_json,
.http_get_handler = &auction_http_get_handler,
.http_post_handler = &auction_http_post_handler,
};
/* TODO: sql handler */
/**
* ===========================================
* Handler for GNUNET_PLUGIN_load and _unload
* ===========================================
*/
/**
* @brief Initialization function for the extension.
* Will be called by GNUNET_PLUGIN_load.
*
* @param arg Configuration - ptr to GNUNET_CONFIGURATION_Handle
* @return Pointer to TE_auction_brandt
*/
struct TALER_Extension *
libtaler_extension_auction_brandt_init (void *arg)
{
const struct GNUNET_CONFIGURATION_Handle *cfg = arg;
if (GNUNET_OK !=
TALER_config_get_currency (cfg,
&currency))
return NULL;
if (GNUNET_SYSERR ==
GNUNET_CONFIGURATION_get_value_string (cfg,
TALER_EXTENSION_SECTION_PREFIX
AUCTION_BRANDT,
"REPLAY_PROGRAM",
&replay_program))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
TALER_EXTENSION_SECTION_PREFIX AUCTION_BRANDT,
"REPLAY_PROGRAM");
return NULL;
}
/* check if replay_program is actually an executable */
{
struct stat sb;
if (0 != stat (replay_program, &sb))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
LOG_PREFIX "replay_program '%s' not found\n",
replay_program);
return NULL;
}
if ( (sb.st_mode & S_IFDIR) ||
! (sb.st_mode & S_IXUSR))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
LOG_PREFIX "replay_program '%s' is not an executable\n",
replay_program);
return NULL;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
LOG_PREFIX "loading... using replay_program '%s'\n",
replay_program);
/* TODO: read other config parameters and generate configuration */
return &TE_auction_brandt;
}
/**
* @brief Tear-down function for the extension.
* Will be called by GNUNET_PLUGIN_unload.
*
* @param ignored
* @return null
*/
void *
libtaler_extension_auction_brandt_done (void *arg)
{
auction_disable (&TE_auction_brandt);
GNUNET_free (replay_program);
replay_program = NULL;
return NULL;
}
/* end of extension_auction_brandt.c */
Reference in New Issue View Git Blame Copy Permalink