libbrandt/brandt.c

/* This file is part of libbrandt.
 * Copyright (C) 2016 GNUnet e.V.
 *
 * libbrandt 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 of the License, or (at your option) any later
 * version.
 *
 * libbrandt 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
 * libbrandt.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * @file brandt.c
 * @brief Implementation of the high level libbrandt interface.
 * @author Markus Teich
 */

#include "brandt_config.h"
#include "crypto.h"
#include "internals.h"
#include "util.h"


void
BRANDT_init (struct GNUNET_CRYPTO_EccDlogContext *dlogctx)
{
	gcry_error_t err = 0;

	if (!gcry_check_version ("1.7.0"))
		eprintf ("libgcrypt version mismatch");

	/* SECMEM cannot be resized dynamically. We do not know how much we need */
	if ((err = gcry_control (GCRYCTL_DISABLE_SECMEM, 0)))
		weprintf ("failed to set libgcrypt option DISABLE_SECMEM: %s",
		          gcry_strerror (err));

	/* ecc is slow otherwise and we don't create long term keys anyway. */
	if ((err = gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0)))
		weprintf ("failed to set libgcrypt option ENABLE_QUICK_RANDOM: %s",
		          gcry_strerror (err));

	gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
	brandt_crypto_init (dlogctx);
}


static void
start_auction (void *arg)
{
	struct BRANDT_Auction *ad = (struct BRANDT_Auction *)arg;

	/* \todo: broadcast start message to all participants */
}


struct BRANDT_Auction *
BRANDT_new (BRANDT_CbBroadcast broadcast,
            BRANDT_CbResult    result,
            void               *auction_closure,
            void               **auction_data,
            size_t             *auction_data_len,
            struct GNUNET_TIME_Absolute time_start,
            struct GNUNET_TIME_Relative time_round,
            uint16_t           num_prices,
            uint16_t           m,
            int                outcome_public)
{
	struct BRANDT_Auction *ret;

	ret = GNUNET_new (struct BRANDT_Auction);

	ret->time_start = time_start;
	ret->time_round = time_round;

	ret->k = num_prices;
	ret->m = m;
	ret->outcome_public = outcome_public;

	/* we are the seller */
	ret->seller_mode = 1;

	/* interface with application */
	ret->closure = auction_closure;
	ret->bcast = broadcast;
	ret->result = result;

	ret->cur_round = msg_join;
	ret->round_progress = gcry_mpi_new (256);

	/* \todo: store returned task somewhere to cancel it on shutdown */
	GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining (time_start),
	                              &start_auction,
	                              ret);

	return ret;
}


struct BRANDT_Auction *
BRANDT_join (BRANDT_CbBroadcast broadcast,
             BRANDT_CbUnicast   unicast,
             BRANDT_CbResult    result,
             void               *auction_closure,
             const void         *auction_data,
             size_t             auction_data_len)
{
	struct BRANDT_Auction *ret;
	struct BRANDT_DescrP *desc = (struct BRANDT_DescrP *)auction_data;

	ret = GNUNET_new (struct BRANDT_Auction);

	ret->time_start = GNUNET_TIME_absolute_ntoh(desc->time_start);
	ret->time_round = GNUNET_TIME_relative_ntoh(desc->time_round);

	ret->k = ntohs(desc->k);
	ret->m = ntohs(desc->m);
	ret->outcome_public = ntohs(desc->outcome_public);

	/* we are the seller */
	ret->seller_mode = 0;

	/* interface with application */
	ret->closure = auction_closure;
	ret->bcast = broadcast;
	ret->ucast = unicast;
	ret->result = result;

	ret->cur_round = msg_join;
	ret->round_progress = gcry_mpi_new (256);

	return ret;
}


static void
advance_round (struct BRANDT_Auction *auction, enum auction_type atype, enum outcome_type outcome)
{
	unsigned char *buf;
	size_t buflen;

	/* if we got the current round message from all participants, advance to
	 * next round */
	for (uint16_t i = 0; i < auction->n; i++)
		if (!gcry_mpi_test_bit (auction->round_progress, i))
			return;

	gcry_mpi_clear_highbit (auction->round_progress, 0);
	if (msg_last == ++(auction->cur_round))
	{
	}

	if (!handler_out[atype][outcome][auction->cur_round] ||
	    !(buf = handler_out[atype][outcome][auction->cur_round](auction, &buflen)))
	{
		/** \todo */
		weprintf ("wow fail out");
		return;
	}

	/** \todo: add msgtype header in the handler_out functions */

	/* last message only sent to seller, others are broadcasted */
	if (msg_decrypt == auction->cur_round)
		auction->ucast (auction->closure, buf, buflen);
	else
		auction->bcast (auction->closure, buf, buflen);
}


void
BRANDT_got_message (struct BRANDT_Auction *auction,
                    uint16_t              sender,
                    const unsigned char   *msg,
                    size_t                msg_len)
{
	uint16_t    mtype = *(uint16_t *)msg;
	enum auction_type         atype;
	enum outcome_type         outcome;
	enum rounds round = auction->cur_round;

	atype = auction->m > 0 ? auction_mPlusFirstPrice : auction_firstPrice;
	outcome = auction->outcome_public ? outcome_public : outcome_private;

	/** \todo: cache out of order messages */

	/* check if we already got that round message from the same user */
	if (gcry_mpi_test_bit (auction->round_progress, sender))
	{
		weprintf ("got a duplicate message from user %d", sender);
		return;
	}

	if (!handler_in[atype][outcome][round] ||
	    !handler_in[atype][outcome][round](auction,
	                                       msg + sizeof (mtype),
	                                       msg_len - sizeof (mtype),
	                                       sender))
	{
		/** \todo */
		weprintf ("wow fail in");
		return;
	}
	gcry_mpi_set_bit (auction->round_progress, sender);

	advance_round (auction, atype, outcome);
}