/*

 * 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;

}