/*

 * Copyright (C) 2009-2012 Free Software Foundation, Inc.

 *

 * Author: Jonathan Bastien-Filiatrault

 *

 * This file is part of GNUTLS.

 *

 * The GNUTLS library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public License

 * as published by the Free Software Foundation; either version 2.1 of

 * the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>

 *

 */

#include "mbuffers.h"

#include "errors.h"

/* Here be mbuffers */

/* A note on terminology:

 *

 * Variables named bufel designate a single buffer segment (mbuffer_st

 * type). This type is textually referred to as a "segment" or a

 * "buffer element".

 *

 * Variables named buf desigate a chain of buffer segments

 * (mbuffer_head_st type).  This type is textually referred to as a

 * "buffer head" or simply as "buffer".

 *

 * Design objectives:

 *

 * - Make existing code easier to understand.

 * - Make common operations more efficient by avoiding unnecessary

 *    copying.

 * - Provide a common datatype with a well-known interface to move

 *    data around and through the multiple protocol layers.

 * - Enable a future implementation of DTLS, which needs the concept

 *    of record boundaries.

 */

/* Initialize a buffer head.

 *

 * Cost: O(1)

 */

void _mbuffer_head_init(mbuffer_head_st * buf)

{

	buf->head = NULL;

	buf->tail = NULL;

	buf->length = 0;

	buf->byte_length = 0;

}

/* Deallocate all buffer segments and reset the buffer head.

 *

 * Cost: O(n)

 * n: Number of segments currently in the buffer.

 */

void _mbuffer_head_clear(mbuffer_head_st * buf)

{

	mbuffer_st *bufel, *next;

	for (bufel = buf->head; bufel != NULL; bufel = next) {

		next = bufel->next;

		gnutls_free(bufel);

	}

	_mbuffer_head_init(buf);

}

/* Append a segment to the end of this buffer.

 *

 * Cost: O(1)

 */

void _mbuffer_enqueue(mbuffer_head_st * buf, mbuffer_st * bufel)

{

	bufel->next = NULL;

	bufel->prev = buf->tail;

	buf->length++;

	buf->byte_length += bufel->msg.size - bufel->mark;

	if (buf->tail != NULL)

		buf->tail->next = bufel;

	else

		buf->head = bufel;

	buf->tail = bufel;

}

/* Remove a segment from the buffer.

 *

 * Cost: O(1)

 *

 * Returns the buffer following it.

 */

mbuffer_st *_mbuffer_dequeue(mbuffer_head_st * buf, mbuffer_st * bufel)

{

	mbuffer_st *ret = bufel->next;

	if (buf->tail == bufel)	/* if last */

		buf->tail = bufel->prev;

	if (buf->head == bufel)	/* if first */

		buf->head = bufel->next;

	if (bufel->prev)

		bufel->prev->next = bufel->next;

	if (bufel->next)

		bufel->next->prev = NULL;

	buf->length--;

	buf->byte_length -= bufel->msg.size - bufel->mark;

	bufel->next = bufel->prev = NULL;

	return ret;

}

/* Get a reference to the first segment of the buffer and

 * remove it from the list.

 *

 * Used to start iteration.

 *

 * Cost: O(1)

 */

mbuffer_st *_mbuffer_head_pop_first(mbuffer_head_st * buf)

{

	mbuffer_st *bufel = buf->head;

	if (buf->head == NULL)

		return NULL;

	_mbuffer_dequeue(buf, bufel);

	return bufel;

}

/* Get a reference to the first segment of the buffer and its data.

 *

 * Used to start iteration or to peek at the data.

 *

 * Cost: O(1)

 */

mbuffer_st *_mbuffer_head_get_first(mbuffer_head_st * buf,

				    gnutls_datum_t * msg)

{

	mbuffer_st *bufel = buf->head;

	if (msg) {

		if (bufel) {

			msg->data = bufel->msg.data + bufel->mark;

			msg->size = bufel->msg.size - bufel->mark;

		} else {

			msg->data = NULL;

			msg->size = 0;

		}

	}

	return bufel;

}

/* Get a reference to the next segment of the buffer and its data.

 *

 * Used to iterate over the buffer segments.

 *

 * Cost: O(1)

 */

mbuffer_st *_mbuffer_head_get_next(mbuffer_st * cur, gnutls_datum_t * msg)

{

	mbuffer_st *bufel = cur->next;

	if (msg) {

		if (bufel) {

			msg->data = bufel->msg.data + bufel->mark;

			msg->size = bufel->msg.size - bufel->mark;

		} else {

			msg->data = NULL;

			msg->size = 0;

		}

	}

	return bufel;

}

/* Remove the first segment from the buffer.

 *

 * Used to dequeue data from the buffer. Not yet exposed in the

 * internal interface since it is not yet needed outside of this unit.

 *

 * Cost: O(1)

 */

static inline void remove_front(mbuffer_head_st * buf)

{

	mbuffer_st *bufel = buf->head;

	if (!bufel)

		return;

	_mbuffer_dequeue(buf, bufel);

	gnutls_free(bufel);

}

/* Remove a specified number of bytes from the start of the buffer.

 *

 * Useful for uses that treat the buffer as a simple array of bytes.

 *

 * If more than one mbuffer_st have been removed it

 * returns 1, 0 otherwise and an error code on error.

 *

 * Cost: O(n)

 * n: Number of segments needed to remove the specified amount of data.

 */

int _mbuffer_head_remove_bytes(mbuffer_head_st * buf, size_t bytes)

{

	size_t left = bytes;

	mbuffer_st *bufel, *next;

	int ret = 0;

	if (bytes > buf->byte_length) {

		gnutls_assert();

		return GNUTLS_E_INVALID_REQUEST;

	}

	for (bufel = buf->head; bufel != NULL && left > 0; bufel = next) {

		next = bufel->next;

		if (left >= (bufel->msg.size - bufel->mark)) {

			left -= (bufel->msg.size - bufel->mark);

			remove_front(buf);

			ret = 1;

		} else {

			bufel->mark += left;

			buf->byte_length -= left;

			left = 0;

		}

	}

	return ret;

}

/* Allocate a buffer segment. The segment is not initially "owned" by

 * any buffer.

 *

 * maximum_size: Amount of data that this segment can contain.

 *

 * Returns the segment or NULL on error.

 *

 * Cost: O(1)

 */

mbuffer_st *_mbuffer_alloc(size_t maximum_size)

{

	mbuffer_st *st;

	st = gnutls_malloc(maximum_size + sizeof(mbuffer_st));

	if (st == NULL) {

		gnutls_assert();

		return NULL;

	}

	/* set the structure to zero */

	memset(st, 0, sizeof(*st));

	/* payload points after the mbuffer_st structure */

	st->msg.data = (uint8_t *) st + sizeof(mbuffer_st);

	st->msg.size = 0;

	st->maximum_size = maximum_size;

	return st;

}

/* Copy data into a segment. The segment must not be part of a buffer

 * head when using this function.

 *

 * Bounds checking is performed by this function.

 *

 * Returns 0 on success or an error code otherwise.

 *

 * Cost: O(n)

 * n: number of bytes to copy

 */

int

_mbuffer_append_data(mbuffer_st * bufel, void *newdata,

		     size_t newdata_size)

{

	if (bufel->msg.size + newdata_size <= bufel->maximum_size) {

		memcpy(&bufel->msg.data[bufel->msg.size], newdata,

		       newdata_size);

		bufel->msg.size += newdata_size;

	} else {

		gnutls_assert();

		return GNUTLS_E_INVALID_REQUEST;

	}

	return 0;

}

#ifdef ENABLE_ALIGN16

# define ALIGN_SIZE 16

/* Allocate a 16-byte alligned buffer segment. The segment is not initially "owned" by

 * any buffer.

 *

 * maximum_size: Amount of data that this segment can contain.

 * align_pos: identifies the position of the buffer that will be aligned at 16-bytes

 *

 * This function should be used to ensure that encrypted data or data to

 * be encrypted are properly aligned.

 *

 * Returns the segment or NULL on error.

 *

 * Cost: O(1)

 */

mbuffer_st *_mbuffer_alloc_align16(size_t maximum_size, unsigned align_pos)

{

	mbuffer_st *st;

	size_t cur_alignment;

	st = gnutls_malloc(maximum_size + sizeof(mbuffer_st) + ALIGN_SIZE);

	if (st == NULL) {

		gnutls_assert();

		return NULL;

	}

	/* set the structure to zero */

	memset(st, 0, sizeof(*st));

	/* payload points after the mbuffer_st structure */

	st->msg.data = (uint8_t *) st + sizeof(mbuffer_st);

	cur_alignment = ((size_t)(st->msg.data+align_pos)) % ALIGN_SIZE;

	if (cur_alignment > 0)

		st->msg.data += ALIGN_SIZE - cur_alignment;

	st->msg.size = 0;

	st->maximum_size = maximum_size;

	return st;

}

static unsigned is_aligned16(mbuffer_st * bufel, unsigned align_pos)

{

	uint8_t * ptr = _mbuffer_get_udata_ptr(bufel);

	if (((size_t)(ptr+align_pos)) % ALIGN_SIZE == 0)

		return 1;

	else

		return 0;

}

/* Takes a buffer in multiple chunks and puts all the data in a single

 * contiguous segment, ensuring that the @align_pos is 16-byte aligned.

 *

 * Returns 0 on success or an error code otherwise.

 *

 * Cost: O(n)

 * n: number of segments initially in the buffer

 */

int _mbuffer_linearize_align16(mbuffer_head_st * buf, unsigned align_pos)

{

	mbuffer_st *bufel, *cur;

	gnutls_datum_t msg;

	size_t pos = 0;

	if (buf->length == 0) {

		/* Nothing to do */

		return 0;

	}

	bufel = _mbuffer_head_get_first(buf, NULL);

	if (buf->length == 1 && is_aligned16(bufel, align_pos))

		return 0;

	bufel = _mbuffer_alloc_align16(buf->byte_length, align_pos);

	if (!bufel) {

		gnutls_assert();

		return GNUTLS_E_MEMORY_ERROR;

	}

	for (cur = _mbuffer_head_get_first(buf, &msg;;

	     msg.data != NULL; cur = _mbuffer_head_get_next(cur, &msg)) {

		memcpy(&bufel->msg.data[pos], msg.data, msg.size);

		bufel->msg.size += msg.size;

		pos += msg.size;

	}

	_mbuffer_head_clear(buf);

	_mbuffer_enqueue(buf, bufel);

	return 0;

}

#else

int _mbuffer_linearize(mbuffer_head_st * buf)

{

	mbuffer_st *bufel, *cur;

	gnutls_datum_t msg;

	size_t pos = 0;

	if (buf->length <= 1) {

		/* Nothing to do */

		return 0;

	}

	bufel = _mbuffer_alloc(buf->byte_length);

	if (!bufel) {

		gnutls_assert();

		return GNUTLS_E_MEMORY_ERROR;

	}

	for (cur = _mbuffer_head_get_first(buf, &msg;;

	     msg.data != NULL; cur = _mbuffer_head_get_next(cur, &msg)) {

		memcpy(&bufel->msg.data[pos], msg.data, msg.size);

		bufel->msg.size += msg.size;

		pos += msg.size;

	}

	_mbuffer_head_clear(buf);

	_mbuffer_enqueue(buf, bufel);

	return 0;

}

#endif