/*
 * Copyright (C) 2019 Red Hat, Inc.
 *
 * Author: Daiki Ueno
 *
 * This file is part of GnuTLS.
 *
 * The GnuTLS 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 <https://www.gnu.org/licenses/>
 *
 */

#include "gnutls_int.h"
#include "iov.h"

/**
 * _gnutls_iov_iter_init:
 * @iter: the iterator
 * @iov: the data buffers
 * @iov_count: the number of data buffers
 * @block_size: block size to iterate
 *
 * Initialize the iterator.
 *
 * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise
 *   an error code is returned
 */
int
_gnutls_iov_iter_init(struct iov_iter_st *iter,
		      const giovec_t *iov, size_t iov_count,
		      size_t block_size)
{
	if (unlikely(block_size > MAX_CIPHER_BLOCK_SIZE))
		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	iter->iov = iov;
	iter->iov_count = iov_count;
	iter->iov_index = 0;
	iter->iov_offset = 0;
	iter->block_size = block_size;
	iter->block_offset = 0;
	return 0;
}

/**
 * _gnutls_iov_iter_next:
 * @iter: the iterator
 * @data: the return location of extracted data
 *
 * Retrieve block(s) pointed by @iter and advance it to the next
 * position.  It returns the number of bytes in @data.  At the end of
 * iteration, 0 is returned.
 *
 * If the data stored in @iter is not multiple of the block size, the
 * remaining data is stored in the "block" field of @iter with the
 * size stored in the "block_offset" field.
 *
 * Returns: On success, a value greater than or equal to zero is
 *   returned, otherwise a negative error code is returned
 */
ssize_t
_gnutls_iov_iter_next(struct iov_iter_st *iter, uint8_t **data)
{
	while (iter->iov_index < iter->iov_count) {
		const giovec_t *iov = &iter->iov[iter->iov_index];
		uint8_t *p = iov->iov_base;
		size_t len = iov->iov_len;
		size_t block_left;

		if (!p) {
			// skip NULL iov entries, else we run into issues below
			iter->iov_index++;
			continue;
		}

		if (unlikely(len < iter->iov_offset))
			return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
		len -= iter->iov_offset;
		p += iter->iov_offset;

		/* We have at least one full block, return a whole set
		 * of full blocks immediately. */
		if (iter->block_offset == 0 && len >= iter->block_size) {
			if ((len % iter->block_size) == 0) {
				iter->iov_index++;
				iter->iov_offset = 0;
			} else {
				len -= (len % iter->block_size);
				iter->iov_offset += len;
			}

			/* Return the blocks. */
			*data = p;
			return len;
		}

		/* We can complete one full block to return. */
		block_left = iter->block_size - iter->block_offset;
		if (len >= block_left) {
			memcpy(iter->block + iter->block_offset, p, block_left);
			if (len == block_left) {
				iter->iov_index++;
				iter->iov_offset = 0;
			} else
				iter->iov_offset += block_left;
			iter->block_offset = 0;

			/* Return the filled block. */
			*data = iter->block;
			return iter->block_size;
		}

		/* Not enough data for a full block, store in temp
		 * memory and continue. */
		memcpy(iter->block + iter->block_offset, p, len);
		iter->block_offset += len;
		iter->iov_index++;
		iter->iov_offset = 0;
	}

	if (iter->block_offset > 0) {
		size_t len = iter->block_offset;

		/* Return the incomplete block. */
		*data = iter->block;
		iter->block_offset = 0;
		return len;
	}

	return 0;
}

/**
 * _gnutls_iov_iter_sync:
 * @iter: the iterator
 * @data: data returned by _gnutls_iov_iter_next
 * @data_size: size of @data
 *
 * Flush the content of temp buffer (if any) to the data buffer.
 */
int
_gnutls_iov_iter_sync(struct iov_iter_st *iter, const uint8_t *data,
		      size_t data_size)
{
	size_t iov_index;
	size_t iov_offset;

	/* We didn't return the cached block. */
	if (data != iter->block)
		return 0;

	iov_index = iter->iov_index;
	iov_offset = iter->iov_offset;

	/* When syncing a cache block we walk backwards because we only have a
	 * pointer to were the block ends in the iovec, walking backwards is
	 * fine as we are always writing a full block, so the whole content
	 * is written in the right places:
	 * iovec:     |--0--|---1---|--2--|-3-|
	 * block:     |-----------------------|
	 * 1st write                      |---|
	 * 2nd write                |-----
	 * 3rd write        |-------
	 * last write |-----
	 */
	while (data_size > 0) {
		const giovec_t *iov;
		uint8_t *p;
		size_t to_write;

		while (iov_offset == 0) {
			if (unlikely(iov_index == 0))
				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

			iov_index--;
			iov_offset = iter->iov[iov_index].iov_len;
		}

		iov = &iter->iov[iov_index];
		p = iov->iov_base;
		to_write = MIN(data_size, iov_offset);

		iov_offset -= to_write;
		data_size -= to_write;

		memcpy(p + iov_offset, &iter->block[data_size], to_write);
	}

	return 0;
}