/*
 * Copyright (c) 2014, STMicroelectronics International N.V.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef GUARD_MPALIB_H
#define GUARD_MPALIB_H

/*************************************************************
 *
 *   How functions are exported.
 *
 *************************************************************/
#define MPALIB_EXPORT

/*************************************************************
 *
 *   Include common configuration definitions
 *
 *************************************************************/
#include "mpalib_config.h"

/*************************************************************
 *
 *   TYPE DEFINITIONS
 *
 *************************************************************/

#if defined(MPA_SUPPORT_DWORD_T)
typedef unsigned long long mpa_dword_t;
#endif

/*! \struct mpa_numbase_struct
 * The internal representation of a multi precision integer.
 *
 *  \param alloc  The size of the allocated array d in number of mpa_word_t.
 *
 *  \param size   The number of used words in *d to represent the number, or
 *		  minus the number if the mpa_numbase is representing a
 *		  negative number. The mpa_numbase
 *                is representing zero if and only if size == 0.
 *
 *  \param d      The digits of the integer. The digits are in radix
 *		  2^WORD_SIZE.
 *                The digits are stored in a little endian format, i.e.
 *                the least significant word_t is stored in d[0].
 *
 * \internal ** NOTE **
 * If you change this struct, you must update the const variables
 * in mpa_misc.c and mpa_primetest.c
 * And the
 * MPA_NUMBASE_METADATA_SIZE_IN_U32
 * below.
 */
typedef struct mpa_numbase_struct {
	mpa_asize_t alloc;
	mpa_usize_t size;
	mpa_word_t d[];
} mpa_num_base;

/*/ mpanum is the type we use as parameters to function calls in this library */
typedef mpa_num_base *mpanum;

/*!
 * The Context struct for a Montgomery multiplication
 *
 * \internal ** NOTE **
 * If you change this struct, you must update the
 * MPA_FMM_CONTEXT_METADATA_SIZE_IN_U32
 * below.
 *
 */
typedef struct mpa_fmm_context_struct {
	mpanum r_ptr;
	mpanum r2_ptr;
	mpa_word_t n_inv;
	uint32_t m[];
} mpa_fmm_context_base;

typedef mpa_fmm_context_base *mpa_fmm_context;

struct mpa_scratch_mem_sync;
typedef void (mpa_scratch_mem_sync_fn)(struct mpa_scratch_mem_sync *sync);

typedef struct mpa_scratch_mem_struct {
	uint32_t size;	/* size of the memory pool, in bytes */
	uint32_t bn_bits; /* default size of a temporary variables */
	uint32_t last_offset;	/* offset to the last one */
	mpa_scratch_mem_sync_fn *get;
	mpa_scratch_mem_sync_fn *put;
	struct mpa_scratch_mem_sync *sync;
	uint32_t m[];		/* mpa_scratch_item are stored there */
} mpa_scratch_mem_base;
typedef mpa_scratch_mem_base *mpa_scratch_mem;

struct mpa_scratch_item {
	uint32_t size;		/* total size of this item */
	/* the offset of the previous and next mpa_scratch_item */
	uint32_t prev_item_offset;
	uint32_t next_item_offset;
	/* followed by a mpa_num_base, being the big number to save */
};

/*************************************************************
 *
 *   EXPORTED VARIABLES
 *
 *************************************************************/

/*************************************************************
 *
 *   MACROS
 *
 *************************************************************/

#define MPA_STRING_MODE_HEX_UC  16
#define MPA_STRING_MODE_HEX_LC  17

#define MPA_EVEN_PARITY 0
#define MPA_ODD_PARITY  1

/*! Returns true if the mpanum 'a' is even (zero included) */
#define mpa_is_even(a) (mpa_parity((a)) == MPA_EVEN_PARITY)
/*! Returns true if the mpanum 'a' is odd */
#define mpa_is_odd(a)  (mpa_parity((a)) == MPA_ODD_PARITY)
/* Short hand for setting the value of 'a' to the value of 'b' */
#define mpa_set(a, b) mpa_copy((a), (b))

/* */
/* Define how to convert between sizes given in uint32_t and mpa_word_t */
/* */
#define ASIZE_TO_U32(x) (((sizeof(mpa_word_t) * (x)) + 3) / 4)
#define U32_TO_ASIZE(x) \
	((mpa_asize_t)(((4 * (x)) + (sizeof(mpa_word_t) - 1)) / \
		sizeof(mpa_word_t)))

/*************************************************************
 *
 *   STATIC MEMORY MODE DEFINES
 *
 *************************************************************/

/*
 *   The number of extra uint32_t in the internal representation.
 *   This is used in the static memory mode.
 *   It is chosen to be complient with the requirments of GlobalPlatform.
 */
#define MPA_NUMBASE_METADATA_SIZE_IN_U32 2

#define MPA_SCRATCHMEM_METADATA_SIZE_IN_U32  (sizeof(mpa_scratch_mem_base)/ 4)

/*
 * The size (in uint32_t) of the constituent variables
 * of mpa_fmm_context apart from m[]
 */

#define MPA_FMM_CONTEXT_METADATA_SIZE_IN_U32 (sizeof(mpa_fmm_context_base)/4)

/*
 * This macro returns the size of the complete mpa_num_base struct that
 * can hold n-bits integers. This is used in the static memory mode.
 */
#define mpa_StaticVarSizeInU32(n)  \
	((((n)+31)/32) + MPA_NUMBASE_METADATA_SIZE_IN_U32)

/*
 *
 */
#define mpa_StaticTempVarSizeInU32(max_bits) \
	(2 * mpa_StaticVarSizeInU32((max_bits)) - \
	 MPA_NUMBASE_METADATA_SIZE_IN_U32)

/*
 *
 */
#define mpa_scratch_mem_size_in_U32(nr_temp_vars, max_bits) \
	(((nr_temp_vars) * (mpa_StaticTempVarSizeInU32((max_bits)) + \
			sizeof(struct mpa_scratch_item))) + \
	  sizeof(struct mpa_scratch_mem_struct))

/*
 *
 */
#define mpa_fmm_context_size_in_U32(n) \
	(2 * (mpa_StaticVarSizeInU32((n)) + 2) + \
	 MPA_FMM_CONTEXT_METADATA_SIZE_IN_U32)

/*************************************************************
 *
 *   FUNCTION PROTOTYPES
 *
 *  All externally available functions from this lib.
 *
 *************************************************************/

/*
 * From mpa_init.c
 */

/*
 * mpa_init_scratch_mem
 * Initiate a chunk of memory to be used as a scratch pool.
 * The size of the pool (in uint32_t) must corresponde to the
 * size returned by the macro mpa_ScratchMemSizeInU32
 * with the same parameters 'nr_vars' and 'max_bits'
 *
 * \param pool         The pool to initialize
 * \param size         the size, in bytes, of the pool
 * \prama bn_bits      default size, in bits, of a big number
 * \param get          increase reference counter to pool
 * \param put          decrease reference counter to pool
 * \param sync         argument to supply to get() and put()
 */
MPALIB_EXPORT void mpa_init_scratch_mem_sync(mpa_scratch_mem pool, size_t size,
			uint32_t bn_bits, mpa_scratch_mem_sync_fn get,
			mpa_scratch_mem_sync_fn put,
			struct mpa_scratch_mem_sync *sync);

MPALIB_EXPORT void mpa_init_scratch_mem(mpa_scratch_mem pool, size_t size,
					uint32_t bn_bits);


/*
 * mpa_init_static
 * Initiate a mpanum to hold an integer of a certain size.
 * The parameter 'len' is the return value of the macro
 * mpa_StaticVarSizeInU32 called with the max bit size as parameter.
 *
 * \param src  The mpanum to be initialized
 * \param len  The allocated size in uint32_t of src
 */
MPALIB_EXPORT void mpa_init_static(mpanum src, uint32_t len);

MPALIB_EXPORT void mpa_init_static_fmm_context(mpa_fmm_context_base *context,
					       uint32_t len);

/*
 * From mpa_addsub.c
 */
MPALIB_EXPORT void mpa_add(mpanum dest, const mpanum op1, const mpanum op2,
			   mpa_scratch_mem pool);

MPALIB_EXPORT void mpa_sub(mpanum dest, const mpanum op1, const mpanum op2,
			   mpa_scratch_mem pool);

MPALIB_EXPORT void mpa_add_word(mpanum dest, const mpanum op1, mpa_word_t op2,
				mpa_scratch_mem pool);

MPALIB_EXPORT void mpa_sub_word(mpanum dest, const mpanum op1, mpa_word_t op2,
				mpa_scratch_mem pool);

MPALIB_EXPORT void mpa_neg(mpanum dest, const mpanum src);

/*
 * From mpa_mul.c
 */

MPALIB_EXPORT void mpa_mul(mpanum dest, const mpanum op1, const mpanum op2,
			   mpa_scratch_mem pool);

MPALIB_EXPORT void mpa_mul_word(mpanum dest, const mpanum op1, mpa_word_t op2,
				mpa_scratch_mem pool);

/*
 * From mpa_div.c
 */

MPALIB_EXPORT void mpa_div(mpanum q, mpanum r,
			   const mpanum op1, const mpanum op2,
			   mpa_scratch_mem pool);

/*
 * From mpa_modulus.c
 */

MPALIB_EXPORT void mpa_mod(mpanum dest, const mpanum op, const mpanum n,
			   mpa_scratch_mem pool);

MPALIB_EXPORT void mpa_add_mod(mpanum dest, const mpanum op1, const mpanum op2,
			       const mpanum n, mpa_scratch_mem pool);

MPALIB_EXPORT void mpa_sub_mod(mpanum dest, const mpanum op1, const mpanum op2,
			       const mpanum n, mpa_scratch_mem pool);

MPALIB_EXPORT void mpa_mul_mod(mpanum dest, const mpanum op1, const mpanum op2,
			       const mpanum n, mpa_scratch_mem pool);

MPALIB_EXPORT int mpa_inv_mod(mpanum dest, const mpanum op, const mpanum n,
			      mpa_scratch_mem pool);

/*
 * From mpa_cmp.c
 */

MPALIB_EXPORT int32_t mpa_cmp(const mpanum op1, const mpanum op2);

MPALIB_EXPORT int32_t mpa_cmp_short(const mpanum op1, int32_t op2);

/*
 * From mpa_conv.c
 */

MPALIB_EXPORT void mpa_set_S32(mpanum dest, int32_t short_val);

MPALIB_EXPORT int32_t mpa_get_S32(int32_t *dest, mpanum src);

MPALIB_EXPORT void mpa_set_word(mpanum dest, mpa_word_t src);

MPALIB_EXPORT mpa_word_t mpa_get_word(mpanum src);

/*
 * From mpa_shift.c
 */

MPALIB_EXPORT void mpa_shift_left(mpanum dest, const mpanum src,
				  mpa_word_t steps);

MPALIB_EXPORT void mpa_shift_right(mpanum dest, const mpanum src,
				   mpa_word_t steps);

/*
 * From mpa_gcd.c
 */
MPALIB_EXPORT void mpa_gcd(mpanum dest, const mpanum src1, const mpanum src2,
			   mpa_scratch_mem pool);

MPALIB_EXPORT void mpa_extended_gcd(mpanum gcd, mpanum dest1, mpanum dest2,
				    const mpanum src1, const mpanum src2,
				    mpa_scratch_mem pool);

/*
 * From mpa_io.c
 */
MPALIB_EXPORT int mpa_get_str_size(void);

MPALIB_EXPORT int mpa_set_str(mpanum dest, const char *digitstr);

MPALIB_EXPORT char *mpa_get_str(char *str, int mode, const mpanum n);

MPALIB_EXPORT int mpa_set_oct_str(mpanum dest, const uint8_t *buffer,
				  size_t buffer_len, bool negative);

MPALIB_EXPORT int mpa_get_oct_str(uint8_t *buffer, size_t *buffer_len,
				  const mpanum n);

/*
 * From mpa_expmod.c
 */
MPALIB_EXPORT void mpa_exp_mod(mpanum dest, const mpanum op1, const mpanum op2,
			       const mpanum n, const mpanum r_modn,
			       const mpanum r2_modn, const mpa_word_t n_inv,
			       mpa_scratch_mem pool);

/*
 * From mpa_misc.c
 */

MPALIB_EXPORT void mpa_wipe(mpanum src);

MPALIB_EXPORT void mpa_copy(mpanum dest, const mpanum src);

MPALIB_EXPORT void mpa_abs(mpanum dest, const mpanum src);

MPALIB_EXPORT int mpa_highest_bit_index(const mpanum src);

MPALIB_EXPORT uint32_t mpa_get_bit(const mpanum src, uint32_t idx);

MPALIB_EXPORT int mpa_can_hold(mpanum dest, const mpanum src);

MPALIB_EXPORT int mpa_parity(const mpanum src);

MPALIB_EXPORT mpanum mpa_constant_one(void);

/*
 * From mpa_Random.c
 */

typedef uint32_t (*random_generator_cb)(void *buf, size_t blen);

MPALIB_EXPORT void mpa_set_random_generator(random_generator_cb callback);

MPALIB_EXPORT void mpa_get_random(mpanum dest, mpanum limit);

/*
 * From mpa_montgomery.c
 */
MPALIB_EXPORT int mpa_compute_fmm_context(const mpanum modulus, mpanum r_modn,
					  mpanum r2_modn, mpa_word_t *n_inv,
					  mpa_scratch_mem pool);

MPALIB_EXPORT void mpa_montgomery_mul(mpanum dest, mpanum op1, mpanum op2,
				      mpanum n, mpa_word_t n_inv,
				      mpa_scratch_mem pool);

/*
 * From mpa_mem_static.c
 */
MPALIB_EXPORT mpanum mpa_alloc_static_temp_var(mpanum *var,
					       mpa_scratch_mem pool);
MPALIB_EXPORT mpanum mpa_alloc_static_temp_var_size(int size_bits,
						    mpanum *var,
						    mpa_scratch_mem pool);
MPALIB_EXPORT void mpa_free_static_temp_var(mpanum *var, mpa_scratch_mem pool);

/*
 * From mpa_primetest.c
 */
MPALIB_EXPORT int mpa_is_prob_prime(mpanum n, int conf_level,
				    mpa_scratch_mem pool);

#endif /* include guard */