/*

 * nghttp2 - HTTP/2 C Library

 *

 * Copyright (c) 2014 Tatsuhiro Tsujikawa

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sublicense, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

#ifndef NGHTTP2_BUF_H

#define NGHTTP2_BUF_H

#ifdef HAVE_CONFIG_H

#  include <config.h>

#endif /* HAVE_CONFIG_H */

#include <nghttp2/nghttp2.h>

#include "nghttp2_int.h"

#include "nghttp2_mem.h"

typedef struct {

  /* This points to the beginning of the buffer. The effective range

     of buffer is [begin, end). */

  uint8_t *begin;

  /* This points to the memory one byte beyond the end of the

     buffer. */

  uint8_t *end;

  /* The position indicator for effective start of the buffer. pos <=

     last must be hold. */

  uint8_t *pos;

  /* The position indicator for effective one beyond of the end of the

     buffer. last <= end must be hold. */

  uint8_t *last;

  /* Mark arbitrary position in buffer [begin, end) */

  uint8_t *mark;

} nghttp2_buf;

#define nghttp2_buf_len(BUF) ((size_t)((BUF)->last - (BUF)->pos))

#define nghttp2_buf_avail(BUF) ((size_t)((BUF)->end - (BUF)->last))

#define nghttp2_buf_mark_avail(BUF) ((size_t)((BUF)->mark - (BUF)->last))

#define nghttp2_buf_cap(BUF) ((size_t)((BUF)->end - (BUF)->begin))

#define nghttp2_buf_pos_offset(BUF) ((size_t)((BUF)->pos - (BUF)->begin))

#define nghttp2_buf_last_offset(BUF) ((size_t)((BUF)->last - (BUF)->begin))

#define nghttp2_buf_shift_right(BUF, AMT)                                      \

  do {                                                                         \

    (BUF)->pos += AMT;                                                         \

    (BUF)->last += AMT;                                                        \

  } while (0)

#define nghttp2_buf_shift_left(BUF, AMT)                                       \

  do {                                                                         \

    (BUF)->pos -= AMT;                                                         \

    (BUF)->last -= AMT;                                                        \

  } while (0)

/*

 * Initializes the |buf|. No memory is allocated in this function. Use

 * nghttp2_buf_reserve() to allocate memory.

 */

void nghttp2_buf_init(nghttp2_buf *buf);

/*

 * Initializes the |buf| and allocates at least |initial| bytes of

 * memory.

 *

 * This function returns 0 if it succeeds, or one of the following

 * negative error codes:

 *

 * NGHTTP2_ERR_NOMEM

 *     Out of memory

 */

int nghttp2_buf_init2(nghttp2_buf *buf, size_t initial, nghttp2_mem *mem);

/*

 * Frees buffer in |buf|.

 */

void nghttp2_buf_free(nghttp2_buf *buf, nghttp2_mem *mem);

/*

 * Extends buffer so that nghttp2_buf_cap() returns at least

 * |new_cap|. If extensions took place, buffer pointers in |buf| will

 * change.

 *

 * This function returns 0 if it succeeds, or one of the followings

 * negative error codes:

 *

 * NGHTTP2_ERR_NOMEM

 *     Out of memory

 */

int nghttp2_buf_reserve(nghttp2_buf *buf, size_t new_cap, nghttp2_mem *mem);

/*

 * Resets pos, last, mark member of |buf| to buf->begin.

 */

void nghttp2_buf_reset(nghttp2_buf *buf);

/*

 * Initializes |buf| using supplied buffer |begin| of length

 * |len|. Semantically, the application should not call *_reserve() or

 * nghttp2_free() functions for |buf|.

 */

void nghttp2_buf_wrap_init(nghttp2_buf *buf, uint8_t *begin, size_t len);

struct nghttp2_buf_chain;

typedef struct nghttp2_buf_chain nghttp2_buf_chain;

/* Chains 2 buffers */

struct nghttp2_buf_chain {

  /* Points to the subsequent buffer. NULL if there is no such

     buffer. */

  nghttp2_buf_chain *next;

  nghttp2_buf buf;

};

typedef struct {

  /* Points to the first buffer */

  nghttp2_buf_chain *head;

  /* Buffer pointer where write occurs. */

  nghttp2_buf_chain *cur;

  /* Memory allocator */

  nghttp2_mem *mem;

  /* The buffer capacity of each buf.  This field may be 0 if

     nghttp2_bufs is initialized by nghttp2_bufs_wrap_init* family

     functions. */

  size_t chunk_length;

  /* The maximum number of nghttp2_buf_chain */

  size_t max_chunk;

  /* The number of nghttp2_buf_chain allocated */

  size_t chunk_used;

  /* The number of nghttp2_buf_chain to keep on reset */

  size_t chunk_keep;

  /* pos offset from begin in each buffers. On initialization and

     reset, buf->pos and buf->last are positioned at buf->begin +

     offset. */

  size_t offset;

} nghttp2_bufs;

/*

 * This is the same as calling nghttp2_bufs_init2 with the given

 * arguments and offset = 0.

 */

int nghttp2_bufs_init(nghttp2_bufs *bufs, size_t chunk_length, size_t max_chunk,

                      nghttp2_mem *mem);

/*

 * This is the same as calling nghttp2_bufs_init3 with the given

 * arguments and chunk_keep = max_chunk.

 */

int nghttp2_bufs_init2(nghttp2_bufs *bufs, size_t chunk_length,

                       size_t max_chunk, size_t offset, nghttp2_mem *mem);

/*

 * Initializes |bufs|. Each buffer size is given in the

 * |chunk_length|.  The maximum number of buffers is given in the

 * |max_chunk|.  On reset, first |chunk_keep| buffers are kept and

 * remaining buffers are deleted.  Each buffer will have bufs->pos and

 * bufs->last shifted to left by |offset| bytes on creation and reset.

 *

 * This function allocates first buffer.  bufs->head and bufs->cur

 * will point to the first buffer after this call.

 *

 * This function returns 0 if it succeeds, or one of the following

 * negative error codes:

 *

 * NGHTTP2_ERR_NOMEM

 *     Out of memory.

 * NGHTTP2_ERR_INVALID_ARGUMENT

 *     chunk_keep is 0; or max_chunk < chunk_keep; or offset is too

 *     long.

 */

int nghttp2_bufs_init3(nghttp2_bufs *bufs, size_t chunk_length,

                       size_t max_chunk, size_t chunk_keep, size_t offset,

                       nghttp2_mem *mem);

/*

 * Frees any related resources to the |bufs|.

 */

void nghttp2_bufs_free(nghttp2_bufs *bufs);

/*

 * Initializes |bufs| using supplied buffer |begin| of length |len|.

 * The first buffer bufs->head uses buffer |begin|.  The buffer size

 * is fixed and no extra chunk buffer is allocated.  In other

 * words, max_chunk = chunk_keep = 1.  To free the resource allocated

 * for |bufs|, use nghttp2_bufs_wrap_free().

 *

 * Don't use the function which performs allocation, such as

 * nghttp2_bufs_realloc().

 *

 * This function returns 0 if it succeeds, or one of the following

 * negative error codes:

 *

 * NGHTTP2_ERR_NOMEM

 *     Out of memory.

 */

int nghttp2_bufs_wrap_init(nghttp2_bufs *bufs, uint8_t *begin, size_t len,

                           nghttp2_mem *mem);

/*

 * Initializes |bufs| using supplied |veclen| size of buf vector

 * |vec|.  The number of buffers is fixed and no extra chunk buffer is

 * allocated.  In other words, max_chunk = chunk_keep = |in_len|.  To

 * free the resource allocated for |bufs|, use

 * nghttp2_bufs_wrap_free().

 *

 * Don't use the function which performs allocation, such as

 * nghttp2_bufs_realloc().

 *

 * This function returns 0 if it succeeds, or one of the following

 * negative error codes:

 *

 * NGHTTP2_ERR_NOMEM

 *     Out of memory.

 */

int nghttp2_bufs_wrap_init2(nghttp2_bufs *bufs, const nghttp2_vec *vec,

                            size_t veclen, nghttp2_mem *mem);

/*

 * Frees any related resource to the |bufs|.  This function does not

 * free supplied buffer provided in nghttp2_bufs_wrap_init().

 */

void nghttp2_bufs_wrap_free(nghttp2_bufs *bufs);

/*

 * Reallocates internal buffer using |chunk_length|.  The max_chunk,

 * chunk_keep and offset do not change.  After successful allocation

 * of new buffer, previous buffers are deallocated without copying

 * anything into new buffers.  chunk_used is reset to 1.

 *

 * This function returns 0 if it succeeds, or one of the following

 * negative error codes:

 *

 * NGHTTP2_ERR_NOMEM

 *     Out of memory.

 * NGHTTP2_ERR_INVALID_ARGUMENT

 *     chunk_length < offset

 */

int nghttp2_bufs_realloc(nghttp2_bufs *bufs, size_t chunk_length);

/*

 * Appends the |data| of length |len| to the |bufs|. The write starts

 * at bufs->cur->buf.last. A new buffers will be allocated to store

 * all data.

 *

 * This function returns 0 if it succeeds, or one of the following

 * negative error codes:

 *

 * NGHTTP2_ERR_NOMEM

 *     Out of memory.

 * NGHTTP2_ERR_BUFFER_ERROR

 *     Out of buffer space.

 */

int nghttp2_bufs_add(nghttp2_bufs *bufs, const void *data, size_t len);

/*

 * Appends a single byte |b| to the |bufs|. The write starts at

 * bufs->cur->buf.last. A new buffers will be allocated to store all

 * data.

 *

 * This function returns 0 if it succeeds, or one of the following

 * negative error codes:

 *

 * NGHTTP2_ERR_NOMEM

 *     Out of memory.

 * NGHTTP2_ERR_BUFFER_ERROR

 *     Out of buffer space.

 */

int nghttp2_bufs_addb(nghttp2_bufs *bufs, uint8_t b);

/*

 * Behaves like nghttp2_bufs_addb(), but this does not update

 * buf->last pointer.

 */

int nghttp2_bufs_addb_hold(nghttp2_bufs *bufs, uint8_t b);

#define nghttp2_bufs_fast_addb(BUFS, B)                                        \

  do {                                                                         \

    *(BUFS)->cur->buf.last++ = B;                                              \

  } while (0)

#define nghttp2_bufs_fast_addb_hold(BUFS, B)                                   \

  do {                                                                         \

    *(BUFS)->cur->buf.last = B;                                                \

  } while (0)

/*

 * Performs bitwise-OR of |b| at bufs->cur->buf.last. A new buffers

 * will be allocated if necessary.

 *

 * This function returns 0 if it succeeds, or one of the following

 * negative error codes:

 *

 * NGHTTP2_ERR_NOMEM

 *     Out of memory.

 * NGHTTP2_ERR_BUFFER_ERROR

 *     Out of buffer space.

 */

int nghttp2_bufs_orb(nghttp2_bufs *bufs, uint8_t b);

/*

 * Behaves like nghttp2_bufs_orb(), but does not update buf->last

 * pointer.

 */

int nghttp2_bufs_orb_hold(nghttp2_bufs *bufs, uint8_t b);

#define nghttp2_bufs_fast_orb(BUFS, B)                                         \

  do {                                                                         \

    uint8_t **p = &(BUFS)->cur->buf.last;                                      \

    **p = (uint8_t)(**p | (B));                                                \

    ++(*p);                                                                    \

  } while (0)

#define nghttp2_bufs_fast_orb_hold(BUFS, B)                                    \

  do {                                                                         \

    uint8_t *p = (BUFS)->cur->buf.last;                                        \

    *p = (uint8_t)(*p | (B));                                                  \

  } while (0)

/*

 * Copies all data stored in |bufs| to the contiguous buffer.  This

 * function allocates the contiguous memory to store all data in

 * |bufs| and assigns it to |*out|.

 *

 * The contents of |bufs| is left unchanged.

 *

 * This function returns the length of copied data and assigns the

 * pointer to copied data to |*out| if it succeeds, or one of the

 * following negative error codes:

 *

 * NGHTTP2_ERR_NOMEM

 *     Out of memory

 */

ssize_t nghttp2_bufs_remove(nghttp2_bufs *bufs, uint8_t **out);

/*

 * Copies all data stored in |bufs| to |out|.  This function assumes

 * that the buffer space pointed by |out| has at least

 * nghttp2_bufs(bufs) bytes.

 *

 * The contents of |bufs| is left unchanged.

 *

 * This function returns the length of copied data.

 */

size_t nghttp2_bufs_remove_copy(nghttp2_bufs *bufs, uint8_t *out);

/*

 * Resets |bufs| and makes the buffers empty.

 */

void nghttp2_bufs_reset(nghttp2_bufs *bufs);

/*

 * Moves bufs->cur to bufs->cur->next.  If resulting bufs->cur is

 * NULL, this function allocates new buffers and bufs->cur points to

 * it.

 *

 * This function returns 0 if it succeeds, or one of the following

 * negative error codes:

 *

 * NGHTTP2_ERR_NOMEM

 *     Out of memory

 * NGHTTP2_ERR_BUFFER_ERROR

 *     Out of buffer space.

 */

int nghttp2_bufs_advance(nghttp2_bufs *bufs);

/* Sets bufs->cur to bufs->head */

#define nghttp2_bufs_rewind(BUFS)                                              \

  do {                                                                         \

    (BUFS)->cur = (BUFS)->head;                                                \

  } while (0)

/*

 * Move bufs->cur, from the current position, using next member, to

 * the last buf which has nghttp2_buf_len(buf) > 0 without seeing buf

 * which satisfies nghttp2_buf_len(buf) == 0.  If

 * nghttp2_buf_len(&bufs->cur->buf) == 0 or bufs->cur->next is NULL,

 * bufs->cur is unchanged.

 */

void nghttp2_bufs_seek_last_present(nghttp2_bufs *bufs);

/*

 * Returns nonzero if bufs->cur->next is not empty.

 */

int nghttp2_bufs_next_present(nghttp2_bufs *bufs);

#define nghttp2_bufs_cur_avail(BUFS) nghttp2_buf_avail(&(BUFS)->cur->buf)

/*

 * Returns the total buffer length of |bufs|.

 */

size_t nghttp2_bufs_len(nghttp2_bufs *bufs);

#endif /* NGHTTP2_BUF_H */