/*
* OpenVPN -- An application to securely tunnel IP networks
* over a single UDP port, with support for SSL/TLS-based
* session authentication and key exchange,
* packet encryption, packet authentication, and
* packet compression.
*
* Copyright (C) 2002-2018 OpenVPN Inc <sales@openvpn.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef BUFFER_H
#define BUFFER_H
#include "basic.h"
#include "error.h"
#define BUF_SIZE_MAX 1000000
/*
* Define verify_align function, otherwise
* it will be a noop.
*/
/* #define VERIFY_ALIGNMENT */
/*
* Keep track of source file/line of buf_init calls
*/
#ifdef VERIFY_ALIGNMENT
#define BUF_INIT_TRACKING
#endif
/**************************************************************************/
/**
* Wrapper structure for dynamically allocated memory.
*
* The actual content stored in a \c buffer structure starts at the memory
* location \c buffer.data \c + \c buffer.offset, and has a length of \c
* buffer.len bytes. This, together with the space available before and
* after the content, is represented in the pseudocode below:
* @code
* uint8_t *content_start = buffer.data + buffer.offset;
* uint8_t *content_end = buffer.data + buffer.offset + buffer.len;
* int prepend_capacity = buffer.offset;
* int append_capacity = buffer.capacity - (buffer.offset + buffer.len);
* @endcode
*/
struct buffer
{
int capacity; /**< Size in bytes of memory allocated by
* \c malloc(). */
int offset; /**< Offset in bytes of the actual content
* within the allocated memory. */
int len; /**< Length in bytes of the actual content
* within the allocated memory. */
uint8_t *data; /**< Pointer to the allocated memory. */
#ifdef BUF_INIT_TRACKING
const char *debug_file;
int debug_line;
#endif
};
/**************************************************************************/
/**
* Garbage collection entry for one dynamically allocated block of memory.
*
* This structure represents one link in the linked list contained in a \c
* gc_arena structure. Each time the \c gc_malloc() function is called,
* it allocates \c sizeof(gc_entry) + the requested number of bytes. The
* \c gc_entry is then stored as a header in front of the memory address
* returned to the caller.
*/
struct gc_entry
{
struct gc_entry *next; /**< Pointer to the next item in the
* linked list. */
};
/**
* Garbage collection entry for a specially allocated structure that needs
* a custom free function to be freed like struct addrinfo
*
*/
struct gc_entry_special
{
struct gc_entry_special *next;
void (*free_fnc)(void *);
void *addr;
};
/**
* Garbage collection arena used to keep track of dynamically allocated
* memory.
*
* This structure contains a linked list of \c gc_entry structures. When
* a block of memory is allocated using the \c gc_malloc() function, the
* allocation is registered in the function's \c gc_arena argument. All
* the dynamically allocated memory registered in a \c gc_arena can be
* freed using the \c gc_free() function.
*/
struct gc_arena
{
struct gc_entry *list; /**< First element of the linked list of
* \c gc_entry structures. */
struct gc_entry_special *list_special;
};
#define BPTR(buf) (buf_bptr(buf))
#define BEND(buf) (buf_bend(buf))
#define BLAST(buf) (buf_blast(buf))
#define BLEN(buf) (buf_len(buf))
#define BDEF(buf) (buf_defined(buf))
#define BSTR(buf) (buf_str(buf))
#define BCAP(buf) (buf_forward_capacity(buf))
void buf_clear(struct buffer *buf);
void free_buf(struct buffer *buf);
bool buf_assign(struct buffer *dest, const struct buffer *src);
void string_clear(char *str);
int string_array_len(const char **array);
size_t array_mult_safe(const size_t m1, const size_t m2, const size_t extra);
#define PA_BRACKET (1<<0)
char *print_argv(const char **p, struct gc_arena *gc, const unsigned int flags);
void buf_size_error(const size_t size);
/* for dmalloc debugging */
#ifdef DMALLOC
#define alloc_buf(size) alloc_buf_debug(size, __FILE__, __LINE__)
#define alloc_buf_gc(size, gc) alloc_buf_gc_debug(size, gc, __FILE__, __LINE__);
#define clone_buf(buf) clone_buf_debug(buf, __FILE__, __LINE__);
#define gc_malloc(size, clear, arena) gc_malloc_debug(size, clear, arena, __FILE__, __LINE__)
#define string_alloc(str, gc) string_alloc_debug(str, gc, __FILE__, __LINE__)
#define string_alloc_buf(str, gc) string_alloc_buf_debug(str, gc, __FILE__, __LINE__)
struct buffer alloc_buf_debug(size_t size, const char *file, int line);
struct buffer alloc_buf_gc_debug(size_t size, struct gc_arena *gc, const char *file, int line);
struct buffer clone_buf_debug(const struct buffer *buf, const char *file, int line);
void *gc_malloc_debug(size_t size, bool clear, struct gc_arena *a, const char *file, int line);
char *string_alloc_debug(const char *str, struct gc_arena *gc, const char *file, int line);
struct buffer string_alloc_buf_debug(const char *str, struct gc_arena *gc, const char *file, int line);
#else /* ifdef DMALLOC */
struct buffer alloc_buf(size_t size);
struct buffer alloc_buf_gc(size_t size, struct gc_arena *gc); /* allocate buffer with garbage collection */
struct buffer clone_buf(const struct buffer *buf);
void *gc_malloc(size_t size, bool clear, struct gc_arena *a);
char *string_alloc(const char *str, struct gc_arena *gc);
struct buffer string_alloc_buf(const char *str, struct gc_arena *gc);
#endif /* ifdef DMALLOC */
void gc_addspecial(void *addr, void (*free_function)(void *), struct gc_arena *a);
#ifdef BUF_INIT_TRACKING
#define buf_init(buf, offset) buf_init_debug(buf, offset, __FILE__, __LINE__)
bool buf_init_debug(struct buffer *buf, int offset, const char *file, int line);
#else
#define buf_init(buf, offset) buf_init_dowork(buf, offset)
#endif
/* inline functions */
inline static void
gc_freeaddrinfo_callback(void *addr)
{
freeaddrinfo((struct addrinfo *) addr);
}
/** Return an empty struct buffer */
static inline struct buffer
clear_buf(void)
{
return (struct buffer) { 0 };
}
static inline bool
buf_defined(const struct buffer *buf)
{
return buf->data != NULL;
}
static inline bool
buf_valid(const struct buffer *buf)
{
return likely(buf->data != NULL) && likely(buf->len >= 0);
}
static inline uint8_t *
buf_bptr(const struct buffer *buf)
{
if (buf_valid(buf))
{
return buf->data + buf->offset;
}
else
{
return NULL;
}
}
static int
buf_len(const struct buffer *buf)
{
if (buf_valid(buf))
{
return buf->len;
}
else
{
return 0;
}
}
static inline uint8_t *
buf_bend(const struct buffer *buf)
{
return buf_bptr(buf) + buf_len(buf);
}
static inline uint8_t *
buf_blast(const struct buffer *buf)
{
if (buf_len(buf) > 0)
{
return buf_bptr(buf) + buf_len(buf) - 1;
}
else
{
return NULL;
}
}
static inline bool
buf_size_valid(const size_t size)
{
return likely(size < BUF_SIZE_MAX);
}
static inline bool
buf_size_valid_signed(const int size)
{
return likely(size >= -BUF_SIZE_MAX) && likely(size < BUF_SIZE_MAX);
}
static inline char *
buf_str(const struct buffer *buf)
{
return (char *)buf_bptr(buf);
}
static inline void
buf_reset(struct buffer *buf)
{
buf->capacity = 0;
buf->offset = 0;
buf->len = 0;
buf->data = NULL;
}
static inline void
buf_reset_len(struct buffer *buf)
{
buf->len = 0;
buf->offset = 0;
}
static inline bool
buf_init_dowork(struct buffer *buf, int offset)
{
if (offset < 0 || offset > buf->capacity || buf->data == NULL)
{
return false;
}
buf->len = 0;
buf->offset = offset;
return true;
}
static inline void
buf_set_write(struct buffer *buf, uint8_t *data, int size)
{
if (!buf_size_valid(size))
{
buf_size_error(size);
}
buf->len = 0;
buf->offset = 0;
buf->capacity = size;
buf->data = data;
if (size > 0 && data)
{
*data = 0;
}
}
static inline void
buf_set_read(struct buffer *buf, const uint8_t *data, int size)
{
if (!buf_size_valid(size))
{
buf_size_error(size);
}
buf->len = buf->capacity = size;
buf->offset = 0;
buf->data = (uint8_t *)data;
}
/* Like strncpy but makes sure dest is always null terminated */
static inline void
strncpynt(char *dest, const char *src, size_t maxlen)
{
strncpy(dest, src, maxlen);
if (maxlen > 0)
{
dest[maxlen - 1] = 0;
}
}
/* return true if string contains at least one numerical digit */
static inline bool
has_digit(const unsigned char *src)
{
unsigned char c;
while ((c = *src++))
{
if (isdigit(c))
{
return true;
}
}
return false;
}
/**
* Securely zeroise memory.
*
* This code and description are based on code supplied by Zhaomo Yang, of the
* University of California, San Diego (which was released into the public
* domain).
*
* The secure_memzero function attempts to ensure that an optimizing compiler
* does not remove the intended operation if cleared memory is not accessed
* again by the program. This code has been tested under Clang 3.9.0 and GCC
* 6.2 with optimization flags -O, -Os, -O0, -O1, -O2, and -O3 on
* Ubuntu 16.04.1 LTS; under Clang 3.9.0 with optimization flags -O, -Os,
* -O0, -O1, -O2, and -O3 on FreeBSD 10.2-RELEASE; under Microsoft Visual Studio
* 2015 with optimization flags /O1, /O2 and /Ox on Windows 10.
*
* Theory of operation:
*
* 1. On Windows, use the SecureZeroMemory which ensures that data is
* overwritten.
* 2. Under GCC or Clang, use a memory barrier, which forces the preceding
* memset to be carried out. The overhead of a memory barrier is usually
* negligible.
* 3. If none of the above are available, use the volatile pointer
* technique to zero memory one byte at a time.
*
* @param data Pointer to data to zeroise.
* @param len Length of data, in bytes.
*/
static inline void
secure_memzero(void *data, size_t len)
{
#if defined(_WIN32)
SecureZeroMemory(data, len);
#elif defined(__GNUC__) || defined(__clang__)
memset(data, 0, len);
__asm__ __volatile__ ("" : : "r" (data) : "memory");
#else
volatile char *p = (volatile char *) data;
while (len--)
{
*p++ = 0;
}
#endif
}
/*
* printf append to a buffer with overflow check,
* due to usage of vsnprintf, it will leave space for
* a final null character and thus use only
* capacity - 1
*/
bool buf_printf(struct buffer *buf, const char *format, ...)
#ifdef __GNUC__
#if __USE_MINGW_ANSI_STDIO
__attribute__ ((format(gnu_printf, 2, 3)))
#else
__attribute__ ((format(__printf__, 2, 3)))
#endif
#endif
;
/*
* puts append to a buffer with overflow check
*/
bool buf_puts(struct buffer *buf, const char *str);
/*
* Like snprintf but guarantees null termination for size > 0
*/
bool openvpn_snprintf(char *str, size_t size, const char *format, ...)
#ifdef __GNUC__
#if __USE_MINGW_ANSI_STDIO
__attribute__ ((format(gnu_printf, 3, 4)))
#else
__attribute__ ((format(__printf__, 3, 4)))
#endif
#endif
;
#ifdef _WIN32
/*
* Like swprintf but guarantees null termination for size > 0
*
* This is under #ifdef because only Windows-specific code in tun.c
* uses this function and its implementation breaks OpenBSD <= 4.9
*/
bool
openvpn_swprintf(wchar_t *const str, const size_t size, const wchar_t *const format, ...);
/*
* Unlike in openvpn_snprintf, we cannot use format attributes since
* GCC doesn't support wprintf as archetype.
*/
#endif
/*
* remove/add trailing characters
*/
void buf_null_terminate(struct buffer *buf);
void buf_chomp(struct buffer *buf);
void buf_rmtail(struct buffer *buf, uint8_t remove);
/*
* non-buffer string functions
*/
void chomp(char *str);
void rm_trailing_chars(char *str, const char *what_to_delete);
const char *skip_leading_whitespace(const char *str);
void string_null_terminate(char *str, int len, int capacity);
/**
* Write buffer contents to file.
*
* @param filename The filename to write the buffer to.
* @param buf The buffer to write to the file.
*
* @return true on success, false otherwise.
*/
bool buffer_write_file(const char *filename, const struct buffer *buf);
/*
* write a string to the end of a buffer that was
* truncated by buf_printf
*/
void buf_catrunc(struct buffer *buf, const char *str);
/*
* convert a multi-line output to one line
*/
void convert_to_one_line(struct buffer *buf);
/*
* Parse a string based on a given delimiter char
*/
bool buf_parse(struct buffer *buf, const int delim, char *line, const int size);
/*
* Hex dump -- Output a binary buffer to a hex string and return it.
*/
#define FHE_SPACE_BREAK_MASK 0xFF /* space_break parameter in lower 8 bits */
#define FHE_CAPS 0x100 /* output hex in caps */
char *
format_hex_ex(const uint8_t *data, int size, int maxoutput,
unsigned int space_break_flags, const char *separator,
struct gc_arena *gc);
static inline char *
format_hex(const uint8_t *data, int size, int maxoutput, struct gc_arena *gc)
{
return format_hex_ex(data, size, maxoutput, 4, " ", gc);
}
/*
* Return a buffer that is a subset of another buffer.
*/
struct buffer buf_sub(struct buffer *buf, int size, bool prepend);
/*
* Check if sufficient space to append to buffer.
*/
static inline bool
buf_safe(const struct buffer *buf, int len)
{
return buf_valid(buf) && buf_size_valid(len)
&& buf->offset + buf->len + len <= buf->capacity;
}
static inline bool
buf_safe_bidir(const struct buffer *buf, int len)
{
if (buf_valid(buf) && buf_size_valid_signed(len))
{
const int newlen = buf->len + len;
return newlen >= 0 && buf->offset + newlen <= buf->capacity;
}
else
{
return false;
}
}
static inline int
buf_forward_capacity(const struct buffer *buf)
{
if (buf_valid(buf))
{
int ret = buf->capacity - (buf->offset + buf->len);
if (ret < 0)
{
ret = 0;
}
return ret;
}
else
{
return 0;
}
}
static inline int
buf_forward_capacity_total(const struct buffer *buf)
{
if (buf_valid(buf))
{
int ret = buf->capacity - buf->offset;
if (ret < 0)
{
ret = 0;
}
return ret;
}
else
{
return 0;
}
}
static inline int
buf_reverse_capacity(const struct buffer *buf)
{
if (buf_valid(buf))
{
return buf->offset;
}
else
{
return 0;
}
}
static inline bool
buf_inc_len(struct buffer *buf, int inc)
{
if (!buf_safe_bidir(buf, inc))
{
return false;
}
buf->len += inc;
return true;
}
/*
* Make space to prepend to a buffer.
* Return NULL if no space.
*/
static inline uint8_t *
buf_prepend(struct buffer *buf, int size)
{
if (!buf_valid(buf) || size < 0 || size > buf->offset)
{
return NULL;
}
buf->offset -= size;
buf->len += size;
return BPTR(buf);
}
static inline bool
buf_advance(struct buffer *buf, int size)
{
if (!buf_valid(buf) || size < 0 || buf->len < size)
{
return false;
}
buf->offset += size;
buf->len -= size;
return true;
}
/*
* Return a pointer to allocated space inside a buffer.
* Return NULL if no space.
*/
static inline uint8_t *
buf_write_alloc(struct buffer *buf, int size)
{
uint8_t *ret;
if (!buf_safe(buf, size))
{
return NULL;
}
ret = BPTR(buf) + buf->len;
buf->len += size;
return ret;
}
static inline uint8_t *
buf_write_alloc_prepend(struct buffer *buf, int size, bool prepend)
{
return prepend ? buf_prepend(buf, size) : buf_write_alloc(buf, size);
}
static inline uint8_t *
buf_read_alloc(struct buffer *buf, int size)
{
uint8_t *ret;
if (size < 0 || buf->len < size)
{
return NULL;
}
ret = BPTR(buf);
buf->offset += size;
buf->len -= size;
return ret;
}
static inline bool
buf_write(struct buffer *dest, const void *src, int size)
{
uint8_t *cp = buf_write_alloc(dest, size);
if (!cp)
{
return false;
}
memcpy(cp, src, size);
return true;
}
static inline bool
buf_write_prepend(struct buffer *dest, const void *src, int size)
{
uint8_t *cp = buf_prepend(dest, size);
if (!cp)
{
return false;
}
memcpy(cp, src, size);
return true;
}
static inline bool
buf_write_u8(struct buffer *dest, int data)
{
uint8_t u8 = (uint8_t) data;
return buf_write(dest, &u8, sizeof(uint8_t));
}
static inline bool
buf_write_u16(struct buffer *dest, int data)
{
uint16_t u16 = htons((uint16_t) data);
return buf_write(dest, &u16, sizeof(uint16_t));
}
static inline bool
buf_write_u32(struct buffer *dest, int data)
{
uint32_t u32 = htonl((uint32_t) data);
return buf_write(dest, &u32, sizeof(uint32_t));
}
static inline bool
buf_copy(struct buffer *dest, const struct buffer *src)
{
return buf_write(dest, BPTR(src), BLEN(src));
}
static inline bool
buf_copy_n(struct buffer *dest, struct buffer *src, int n)
{
uint8_t *cp = buf_read_alloc(src, n);
if (!cp)
{
return false;
}
return buf_write(dest, cp, n);
}
static inline bool
buf_copy_range(struct buffer *dest,
int dest_index,
const struct buffer *src,
int src_index,
int src_len)
{
if (src_index < 0
|| src_len < 0
|| src_index + src_len > src->len
|| dest_index < 0
|| dest->offset + dest_index + src_len > dest->capacity)
{
return false;
}
memcpy(dest->data + dest->offset + dest_index, src->data + src->offset + src_index, src_len);
if (dest_index + src_len > dest->len)
{
dest->len = dest_index + src_len;
}
return true;
}
/* truncate src to len, copy excess data beyond len to dest */
static inline bool
buf_copy_excess(struct buffer *dest,
struct buffer *src,
int len)
{
if (len < 0)
{
return false;
}
if (src->len > len)
{
struct buffer b = *src;
src->len = len;
if (!buf_advance(&b, len))
{
return false;
}
return buf_copy(dest, &b);
}
else
{
return true;
}
}
static inline bool
buf_read(struct buffer *src, void *dest, int size)
{
uint8_t *cp = buf_read_alloc(src, size);
if (!cp)
{
return false;
}
memcpy(dest, cp, size);
return true;
}
static inline int
buf_read_u8(struct buffer *buf)
{
int ret;
if (BLEN(buf) < 1)
{
return -1;
}
ret = *BPTR(buf);
buf_advance(buf, 1);
return ret;
}
static inline int
buf_read_u16(struct buffer *buf)
{
uint16_t ret;
if (!buf_read(buf, &ret, sizeof(uint16_t)))
{
return -1;
}
return ntohs(ret);
}
static inline uint32_t
buf_read_u32(struct buffer *buf, bool *good)
{
uint32_t ret;
if (!buf_read(buf, &ret, sizeof(uint32_t)))
{
if (good)
{
*good = false;
}
return 0;
}
else
{
if (good)
{
*good = true;
}
return ntohl(ret);
}
}
/**
* Compare src buffer contents with match.
* *NOT* constant time. Do not use when comparing HMACs.
*/
static inline bool
buf_string_match(const struct buffer *src, const void *match, int size)
{
if (size != src->len)
{
return false;
}
return memcmp(BPTR(src), match, size) == 0;
}
/**
* Compare first size bytes of src buffer contents with match.
* *NOT* constant time. Do not use when comparing HMACs.
*/
static inline bool
buf_string_match_head(const struct buffer *src, const void *match, int size)
{
if (size < 0 || size > src->len)
{
return false;
}
return memcmp(BPTR(src), match, size) == 0;
}
bool buf_string_match_head_str(const struct buffer *src, const char *match);
bool buf_string_compare_advance(struct buffer *src, const char *match);
int buf_substring_len(const struct buffer *buf, int delim);
/*
* Print a string which might be NULL
*/
const char *np(const char *str);
/*#define CHARACTER_CLASS_DEBUG*/
/* character classes */
#define CC_ANY (1<<0)
#define CC_NULL (1<<1)
#define CC_ALNUM (1<<2)
#define CC_ALPHA (1<<3)
#define CC_ASCII (1<<4)
#define CC_CNTRL (1<<5)
#define CC_DIGIT (1<<6)
#define CC_PRINT (1<<7)
#define CC_PUNCT (1<<8)
#define CC_SPACE (1<<9)
#define CC_XDIGIT (1<<10)
#define CC_BLANK (1<<11)
#define CC_NEWLINE (1<<12)
#define CC_CR (1<<13)
#define CC_BACKSLASH (1<<14)
#define CC_UNDERBAR (1<<15)
#define CC_DASH (1<<16)
#define CC_DOT (1<<17)
#define CC_COMMA (1<<18)
#define CC_COLON (1<<19)
#define CC_SLASH (1<<20)
#define CC_SINGLE_QUOTE (1<<21)
#define CC_DOUBLE_QUOTE (1<<22)
#define CC_REVERSE_QUOTE (1<<23)
#define CC_AT (1<<24)
#define CC_EQUAL (1<<25)
#define CC_LESS_THAN (1<<26)
#define CC_GREATER_THAN (1<<27)
#define CC_PIPE (1<<28)
#define CC_QUESTION_MARK (1<<29)
#define CC_ASTERISK (1<<30)
/* macro classes */
#define CC_NAME (CC_ALNUM|CC_UNDERBAR)
#define CC_CRLF (CC_CR|CC_NEWLINE)
bool char_class(const unsigned char c, const unsigned int flags);
bool string_class(const char *str, const unsigned int inclusive, const unsigned int exclusive);
bool string_mod(char *str, const unsigned int inclusive, const unsigned int exclusive, const char replace);
const char *string_mod_const(const char *str,
const unsigned int inclusive,
const unsigned int exclusive,
const char replace,
struct gc_arena *gc);
void string_replace_leading(char *str, const char match, const char replace);
/** Return true iff str starts with prefix */
static inline bool
strprefix(const char *str, const char *prefix)
{
return 0 == strncmp(str, prefix, strlen(prefix));
}
#ifdef CHARACTER_CLASS_DEBUG
void character_class_debug(void);
#endif
/*
* Verify that a pointer is correctly aligned
*/
#ifdef VERIFY_ALIGNMENT
void valign4(const struct buffer *buf, const char *file, const int line);
#define verify_align_4(ptr) valign4(buf, __FILE__, __LINE__)
#else
#define verify_align_4(ptr)
#endif
/*
* Very basic garbage collection, mostly for routines that return
* char ptrs to malloced strings.
*/
void gc_transfer(struct gc_arena *dest, struct gc_arena *src);
void x_gc_free(struct gc_arena *a);
void x_gc_freespecial(struct gc_arena *a);
static inline bool
gc_defined(struct gc_arena *a)
{
return a->list != NULL;
}
static inline void
gc_init(struct gc_arena *a)
{
a->list = NULL;
a->list_special = NULL;
}
static inline void
gc_detach(struct gc_arena *a)
{
gc_init(a);
}
static inline struct gc_arena
gc_new(void)
{
struct gc_arena ret;
gc_init(&ret);
return ret;
}
static inline void
gc_free(struct gc_arena *a)
{
if (a->list)
{
x_gc_free(a);
}
if (a->list_special)
{
x_gc_freespecial(a);
}
}
static inline void
gc_reset(struct gc_arena *a)
{
gc_free(a);
}
/*
* Allocate memory to hold a structure
*/
#define ALLOC_OBJ(dptr, type) \
{ \
check_malloc_return((dptr) = (type *) malloc(sizeof(type))); \
}
#define ALLOC_OBJ_CLEAR(dptr, type) \
{ \
ALLOC_OBJ(dptr, type); \
memset((dptr), 0, sizeof(type)); \
}
#define ALLOC_ARRAY(dptr, type, n) \
{ \
check_malloc_return((dptr) = (type *) malloc(array_mult_safe(sizeof(type), (n), 0))); \
}
#define ALLOC_ARRAY_GC(dptr, type, n, gc) \
{ \
(dptr) = (type *) gc_malloc(array_mult_safe(sizeof(type), (n), 0), false, (gc)); \
}
#define ALLOC_ARRAY_CLEAR(dptr, type, n) \
{ \
ALLOC_ARRAY(dptr, type, n); \
memset((dptr), 0, (array_mult_safe(sizeof(type), (n), 0))); \
}
#define ALLOC_ARRAY_CLEAR_GC(dptr, type, n, gc) \
{ \
(dptr) = (type *) gc_malloc(array_mult_safe(sizeof(type), (n), 0), true, (gc)); \
}
#define ALLOC_VAR_ARRAY_CLEAR_GC(dptr, type, atype, n, gc) \
{ \
(dptr) = (type *) gc_malloc(array_mult_safe(sizeof(atype), (n), sizeof(type)), true, (gc)); \
}
#define ALLOC_OBJ_GC(dptr, type, gc) \
{ \
(dptr) = (type *) gc_malloc(sizeof(type), false, (gc)); \
}
#define ALLOC_OBJ_CLEAR_GC(dptr, type, gc) \
{ \
(dptr) = (type *) gc_malloc(sizeof(type), true, (gc)); \
}
static inline void
check_malloc_return(const void *p)
{
if (!p)
{
out_of_memory();
}
}
/*
* Manage lists of buffers
*/
struct buffer_entry
{
struct buffer buf;
struct buffer_entry *next;
};
struct buffer_list
{
struct buffer_entry *head; /* next item to pop/peek */
struct buffer_entry *tail; /* last item pushed */
int size; /* current number of entries */
int max_size; /* maximum size list should grow to */
};
/**
* Allocate an empty buffer list of capacity \c max_size.
*
* @param max_size the capacity of the list to allocate
*
* @return the new list
*/
struct buffer_list *buffer_list_new(const int max_size);
/**
* Frees a buffer list and all the buffers in it.
*
* @param ol the list to free
*/
void buffer_list_free(struct buffer_list *ol);
/**
* Checks if the list is valid and non-empty
*
* @param ol the list to check
*
* @return true iff \c ol is not NULL and contains at least one buffer
*/
bool buffer_list_defined(const struct buffer_list *ol);
/**
* Empty the list \c ol and frees all the contained buffers
*
* @param ol the list to reset
*/
void buffer_list_reset(struct buffer_list *ol);
/**
* Allocates and appends a new buffer containing \c str as data to \c ol
*
* @param ol the list to append the new buffer to
* @param str the string to copy into the new buffer
*/
void buffer_list_push(struct buffer_list *ol, const char *str);
/**
* Allocates and appends a new buffer containing \c data of length \c size.
*
* @param ol the list to append the new buffer to
* @param data the data to copy into the new buffer
* @param size the length of \c data to copy into the buffer
*
* @return the new buffer
*/
struct buffer_entry *buffer_list_push_data(struct buffer_list *ol, const void *data, size_t size);
/**
* Retrieve the head buffer
*
* @param ol the list to retrieve the buffer from
*
* @return a pointer to the head buffer or NULL if the list is empty
*/
struct buffer *buffer_list_peek(struct buffer_list *ol);
void buffer_list_advance(struct buffer_list *ol, int n);
void buffer_list_pop(struct buffer_list *ol);
/**
* Aggregates as many buffers as possible from \c bl in a new buffer of maximum
* length \c max_len .
* All the aggregated buffers are removed from the list and replaced by the new
* one, followed by any additional (non-aggregated) data.
*
* @param bl the list of buffer to aggregate
* @param max the maximum length of the aggregated buffer
*/
void buffer_list_aggregate(struct buffer_list *bl, const size_t max);
/**
* Aggregates as many buffers as possible from \c bl in a new buffer
* of maximum length \c max_len . \c sep is written after
* each copied buffer (also after the last one). All the aggregated buffers are
* removed from the list and replaced by the new one, followed by any additional
* (non-aggregated) data.
* Nothing happens if \c max_len is not enough to aggregate at least 2 buffers.
*
* @param bl the list of buffer to aggregate
* @param max_len the maximum length of the aggregated buffer
* @param sep the separator to put between buffers during aggregation
*/
void buffer_list_aggregate_separator(struct buffer_list *bl,
const size_t max_len, const char *sep);
struct buffer_list *buffer_list_file(const char *fn, int max_line_len);
/**
* buffer_read_from_file - copy the content of a file into a buffer
*
* @param file path to the file to read
* @param gc the garbage collector to use when allocating the buffer. It
* is passed to alloc_buf_gc() and therefore can be NULL.
*
* @return the buffer storing the file content or an invalid buffer in case of
* error
*/
struct buffer buffer_read_from_file(const char *filename, struct gc_arena *gc);
#endif /* BUFFER_H */