diff options
Diffstat (limited to 'external/unbound/sldns/sbuffer.h')
| -rw-r--r-- | external/unbound/sldns/sbuffer.h | 804 |
1 files changed, 0 insertions, 804 deletions
diff --git a/external/unbound/sldns/sbuffer.h b/external/unbound/sldns/sbuffer.h deleted file mode 100644 index d1aadf8a1..000000000 --- a/external/unbound/sldns/sbuffer.h +++ /dev/null @@ -1,804 +0,0 @@ -/* - * buffer.h -- generic memory buffer. - * - * Copyright (c) 2005-2008, NLnet Labs. All rights reserved. - * - * See LICENSE for the license. - * - * - * The buffer module implements a generic buffer. The API is based on - * the java.nio.Buffer interface. - */ - -#ifndef LDNS_SBUFFER_H -#define LDNS_SBUFFER_H - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef S_SPLINT_S -# define INLINE -#else -# ifdef SWIG -# define INLINE static -# else -# define INLINE static inline -# endif -#endif - -/* - * Copy data allowing for unaligned accesses in network byte order - * (big endian). - */ -INLINE uint16_t -sldns_read_uint16(const void *src) -{ -#ifdef ALLOW_UNALIGNED_ACCESSES - return ntohs(*(const uint16_t *) src); -#else - const uint8_t *p = (const uint8_t *) src; - return ((uint16_t) p[0] << 8) | (uint16_t) p[1]; -#endif -} - -INLINE uint32_t -sldns_read_uint32(const void *src) -{ -#ifdef ALLOW_UNALIGNED_ACCESSES - return ntohl(*(const uint32_t *) src); -#else - const uint8_t *p = (const uint8_t *) src; - return ( ((uint32_t) p[0] << 24) - | ((uint32_t) p[1] << 16) - | ((uint32_t) p[2] << 8) - | (uint32_t) p[3]); -#endif -} - -/* - * Copy data allowing for unaligned accesses in network byte order - * (big endian). - */ -INLINE void -sldns_write_uint16(void *dst, uint16_t data) -{ -#ifdef ALLOW_UNALIGNED_ACCESSES - * (uint16_t *) dst = htons(data); -#else - uint8_t *p = (uint8_t *) dst; - p[0] = (uint8_t) ((data >> 8) & 0xff); - p[1] = (uint8_t) (data & 0xff); -#endif -} - -INLINE void -sldns_write_uint32(void *dst, uint32_t data) -{ -#ifdef ALLOW_UNALIGNED_ACCESSES - * (uint32_t *) dst = htonl(data); -#else - uint8_t *p = (uint8_t *) dst; - p[0] = (uint8_t) ((data >> 24) & 0xff); - p[1] = (uint8_t) ((data >> 16) & 0xff); - p[2] = (uint8_t) ((data >> 8) & 0xff); - p[3] = (uint8_t) (data & 0xff); -#endif -} - - -INLINE void -sldns_write_uint48(void *dst, uint64_t data) -{ - uint8_t *p = (uint8_t *) dst; - p[0] = (uint8_t) ((data >> 40) & 0xff); - p[1] = (uint8_t) ((data >> 32) & 0xff); - p[2] = (uint8_t) ((data >> 24) & 0xff); - p[3] = (uint8_t) ((data >> 16) & 0xff); - p[4] = (uint8_t) ((data >> 8) & 0xff); - p[5] = (uint8_t) (data & 0xff); -} - - -/** - * \file sbuffer.h - * - * This file contains the definition of sldns_buffer, and functions to manipulate those. - */ - -/** - * implementation of buffers to ease operations - * - * sldns_buffers can contain arbitrary information, per octet. You can write - * to the current end of a buffer, read from the current position, and - * access any data within it. - */ -struct sldns_buffer -{ - /** The current position used for reading/writing */ - size_t _position; - - /** The read/write limit */ - size_t _limit; - - /** The amount of data the buffer can contain */ - size_t _capacity; - - /** The data contained in the buffer */ - uint8_t *_data; - - /** If the buffer is fixed it cannot be resized */ - unsigned _fixed : 1; - - /** If the buffer is vfixed, no more than capacity bytes willl be - * written to _data, however the _position counter will be updated - * with the amount that would have been written in consecutive - * writes. This allows for a modus operandi in which a sequence is - * written on a fixed capacity buffer (perhaps with _data on stack). - * When everything could be written, then the _data is immediately - * usable, if not, then a buffer could be allocated sized precisely - * to fit the data for a second attempt. - */ - unsigned _vfixed : 1; - - /** The current state of the buffer. If writing to the buffer fails - * for any reason, this value is changed. This way, you can perform - * multiple writes in sequence and check for success afterwards. */ - unsigned _status_err : 1; -}; -typedef struct sldns_buffer sldns_buffer; - -#ifdef NDEBUG -INLINE void -sldns_buffer_invariant(sldns_buffer *ATTR_UNUSED(buffer)) -{ -} -#else -INLINE void -sldns_buffer_invariant(sldns_buffer *buffer) -{ - assert(buffer != NULL); - assert(buffer->_position <= buffer->_limit || buffer->_vfixed); - assert(buffer->_limit <= buffer->_capacity); - assert(buffer->_data != NULL || (buffer->_vfixed && buffer->_capacity == 0)); -} -#endif - -/** - * creates a new buffer with the specified capacity. - * - * \param[in] capacity the size (in bytes) to allocate for the buffer - * \return the created buffer - */ -sldns_buffer *sldns_buffer_new(size_t capacity); - -/** - * creates a buffer with the specified data. The data IS copied - * and MEMORY allocations are done. The buffer is not fixed and can - * be resized using buffer_reserve(). - * - * \param[in] buffer pointer to the buffer to put the data in - * \param[in] data the data to encapsulate in the buffer - * \param[in] size the size of the data - */ -void sldns_buffer_new_frm_data(sldns_buffer *buffer, void *data, size_t size); - -/** - * Setup a buffer with the data pointed to. No data copied, no memory allocs. - * The buffer is fixed. - * \param[in] buffer pointer to the buffer to put the data in - * \param[in] data the data to encapsulate in the buffer - * \param[in] size the size of the data - */ -void sldns_buffer_init_frm_data(sldns_buffer *buffer, void *data, size_t size); - -/** - * Setup a buffer with the data pointed to. No data copied, no memory allocs. - * The buffer is "virtually" fixed. Writes beyond size (the capacity) will - * only update position, but no data will be written beyond capacity. This - * allows to determine how big the buffer should have been to contain all the - * written data, by looking at the position with sldns_buffer_position(), - * similarly to the return value of POSIX's snprintf. - * \param[in] buffer pointer to the buffer to put the data in - * \param[in] data the data to encapsulate in the buffer - * \param[in] size the size of the data - */ -void sldns_buffer_init_vfixed_frm_data(sldns_buffer *buffer, void *data, size_t size); - -/** - * clears the buffer and make it ready for writing. The buffer's limit - * is set to the capacity and the position is set to 0. - * \param[in] buffer the buffer to clear - */ -INLINE void sldns_buffer_clear(sldns_buffer *buffer) -{ - sldns_buffer_invariant(buffer); - - /* reset status here? */ - - buffer->_position = 0; - buffer->_limit = buffer->_capacity; -} - -/** - * makes the buffer ready for reading the data that has been written to - * the buffer. The buffer's limit is set to the current position and - * the position is set to 0. - * - * \param[in] buffer the buffer to flip - * \return void - */ -INLINE void sldns_buffer_flip(sldns_buffer *buffer) -{ - sldns_buffer_invariant(buffer); - - buffer->_limit = buffer->_position; - buffer->_position = 0; -} - -/** - * make the buffer ready for re-reading the data. The buffer's - * position is reset to 0. - * \param[in] buffer the buffer to rewind - */ -INLINE void sldns_buffer_rewind(sldns_buffer *buffer) -{ - sldns_buffer_invariant(buffer); - - buffer->_position = 0; -} - -/** - * returns the current position in the buffer (as a number of bytes) - * \param[in] buffer the buffer - * \return the current position - */ -INLINE size_t -sldns_buffer_position(sldns_buffer *buffer) -{ - return buffer->_position; -} - -/** - * sets the buffer's position to MARK. The position must be less than - * or equal to the buffer's limit. - * \param[in] buffer the buffer - * \param[in] mark the mark to use - */ -INLINE void -sldns_buffer_set_position(sldns_buffer *buffer, size_t mark) -{ - assert(mark <= buffer->_limit || buffer->_vfixed); - buffer->_position = mark; -} - -/** - * changes the buffer's position by COUNT bytes. The position must not - * be moved behind the buffer's limit or before the beginning of the - * buffer. - * \param[in] buffer the buffer - * \param[in] count the count to use - */ -INLINE void -sldns_buffer_skip(sldns_buffer *buffer, ssize_t count) -{ - assert(buffer->_position + count <= buffer->_limit || buffer->_vfixed); - buffer->_position += count; -} - -/** - * returns the maximum size of the buffer - * \param[in] buffer - * \return the size - */ -INLINE size_t -sldns_buffer_limit(sldns_buffer *buffer) -{ - return buffer->_limit; -} - -/** - * changes the buffer's limit. If the buffer's position is greater - * than the new limit the position is set to the limit. - * \param[in] buffer the buffer - * \param[in] limit the new limit - */ -INLINE void -sldns_buffer_set_limit(sldns_buffer *buffer, size_t limit) -{ - assert(limit <= buffer->_capacity); - buffer->_limit = limit; - if (buffer->_position > buffer->_limit) - buffer->_position = buffer->_limit; -} - -/** - * returns the number of bytes the buffer can hold. - * \param[in] buffer the buffer - * \return the number of bytes - */ -INLINE size_t -sldns_buffer_capacity(sldns_buffer *buffer) -{ - return buffer->_capacity; -} - -/** - * changes the buffer's capacity. The data is reallocated so any - * pointers to the data may become invalid. The buffer's limit is set - * to the buffer's new capacity. - * \param[in] buffer the buffer - * \param[in] capacity the capacity to use - * \return whether this failed or succeeded - */ -int sldns_buffer_set_capacity(sldns_buffer *buffer, size_t capacity); - -/** - * ensures BUFFER can contain at least AMOUNT more bytes. The buffer's - * capacity is increased if necessary using buffer_set_capacity(). - * - * The buffer's limit is always set to the (possibly increased) - * capacity. - * \param[in] buffer the buffer - * \param[in] amount amount to use - * \return whether this failed or succeeded - */ -int sldns_buffer_reserve(sldns_buffer *buffer, size_t amount); - -/** - * returns a pointer to the data at the indicated position. - * \param[in] buffer the buffer - * \param[in] at position - * \return the pointer to the data - */ -INLINE uint8_t * -sldns_buffer_at(const sldns_buffer *buffer, size_t at) -{ - assert(at <= buffer->_limit || buffer->_vfixed); - return buffer->_data + at; -} - -/** - * returns a pointer to the beginning of the buffer (the data at - * position 0). - * \param[in] buffer the buffer - * \return the pointer - */ -INLINE uint8_t * -sldns_buffer_begin(const sldns_buffer *buffer) -{ - return sldns_buffer_at(buffer, 0); -} - -/** - * returns a pointer to the end of the buffer (the data at the buffer's - * limit). - * \param[in] buffer the buffer - * \return the pointer - */ -INLINE uint8_t * -sldns_buffer_end(sldns_buffer *buffer) -{ - return sldns_buffer_at(buffer, buffer->_limit); -} - -/** - * returns a pointer to the data at the buffer's current position. - * \param[in] buffer the buffer - * \return the pointer - */ -INLINE uint8_t * -sldns_buffer_current(sldns_buffer *buffer) -{ - return sldns_buffer_at(buffer, buffer->_position); -} - -/** - * returns the number of bytes remaining between the indicated position and - * the limit. - * \param[in] buffer the buffer - * \param[in] at indicated position - * \return number of bytes - */ -INLINE size_t -sldns_buffer_remaining_at(sldns_buffer *buffer, size_t at) -{ - sldns_buffer_invariant(buffer); - assert(at <= buffer->_limit || buffer->_vfixed); - return at < buffer->_limit ? buffer->_limit - at : 0; -} - -/** - * returns the number of bytes remaining between the buffer's position and - * limit. - * \param[in] buffer the buffer - * \return the number of bytes - */ -INLINE size_t -sldns_buffer_remaining(sldns_buffer *buffer) -{ - return sldns_buffer_remaining_at(buffer, buffer->_position); -} - -/** - * checks if the buffer has at least COUNT more bytes available. - * Before reading or writing the caller needs to ensure enough space - * is available! - * \param[in] buffer the buffer - * \param[in] at indicated position - * \param[in] count how much is available - * \return true or false (as int?) - */ -INLINE int -sldns_buffer_available_at(sldns_buffer *buffer, size_t at, size_t count) -{ - return count <= sldns_buffer_remaining_at(buffer, at); -} - -/** - * checks if the buffer has count bytes available at the current position - * \param[in] buffer the buffer - * \param[in] count how much is available - * \return true or false (as int?) - */ -INLINE int -sldns_buffer_available(sldns_buffer *buffer, size_t count) -{ - return sldns_buffer_available_at(buffer, buffer->_position, count); -} - -/** - * writes the given data to the buffer at the specified position - * \param[in] buffer the buffer - * \param[in] at the position (in number of bytes) to write the data at - * \param[in] data pointer to the data to write to the buffer - * \param[in] count the number of bytes of data to write - */ -INLINE void -sldns_buffer_write_at(sldns_buffer *buffer, size_t at, const void *data, size_t count) -{ - if (!buffer->_vfixed) - assert(sldns_buffer_available_at(buffer, at, count)); - else if (sldns_buffer_remaining_at(buffer, at) == 0) - return; - else if (count > sldns_buffer_remaining_at(buffer, at)) { - memcpy(buffer->_data + at, data, - sldns_buffer_remaining_at(buffer, at)); - return; - } - memcpy(buffer->_data + at, data, count); -} - -/** - * set the given byte to the buffer at the specified position - * \param[in] buffer the buffer - * \param[in] at the position (in number of bytes) to write the data at - * \param[in] c the byte to set to the buffer - * \param[in] count the number of bytes of bytes to write - */ - -INLINE void -sldns_buffer_set_at(sldns_buffer *buffer, size_t at, int c, size_t count) -{ - if (!buffer->_vfixed) - assert(sldns_buffer_available_at(buffer, at, count)); - else if (sldns_buffer_remaining_at(buffer, at) == 0) - return; - else if (count > sldns_buffer_remaining_at(buffer, at)) { - memset(buffer->_data + at, c, - sldns_buffer_remaining_at(buffer, at)); - return; - } - memset(buffer->_data + at, c, count); -} - - -/** - * writes count bytes of data to the current position of the buffer - * \param[in] buffer the buffer - * \param[in] data the data to write - * \param[in] count the lenght of the data to write - */ -INLINE void -sldns_buffer_write(sldns_buffer *buffer, const void *data, size_t count) -{ - sldns_buffer_write_at(buffer, buffer->_position, data, count); - buffer->_position += count; -} - -/** - * copies the given (null-delimited) string to the specified position at the buffer - * \param[in] buffer the buffer - * \param[in] at the position in the buffer - * \param[in] str the string to write - */ -INLINE void -sldns_buffer_write_string_at(sldns_buffer *buffer, size_t at, const char *str) -{ - sldns_buffer_write_at(buffer, at, str, strlen(str)); -} - -/** - * copies the given (null-delimited) string to the current position at the buffer - * \param[in] buffer the buffer - * \param[in] str the string to write - */ -INLINE void -sldns_buffer_write_string(sldns_buffer *buffer, const char *str) -{ - sldns_buffer_write(buffer, str, strlen(str)); -} - -/** - * writes the given byte of data at the given position in the buffer - * \param[in] buffer the buffer - * \param[in] at the position in the buffer - * \param[in] data the 8 bits to write - */ -INLINE void -sldns_buffer_write_u8_at(sldns_buffer *buffer, size_t at, uint8_t data) -{ - if (buffer->_vfixed && at + sizeof(data) > buffer->_limit) return; - assert(sldns_buffer_available_at(buffer, at, sizeof(data))); - buffer->_data[at] = data; -} - -/** - * writes the given byte of data at the current position in the buffer - * \param[in] buffer the buffer - * \param[in] data the 8 bits to write - */ -INLINE void -sldns_buffer_write_u8(sldns_buffer *buffer, uint8_t data) -{ - sldns_buffer_write_u8_at(buffer, buffer->_position, data); - buffer->_position += sizeof(data); -} - -/** - * writes the given 2 byte integer at the given position in the buffer - * \param[in] buffer the buffer - * \param[in] at the position in the buffer - * \param[in] data the 16 bits to write - */ -INLINE void -sldns_buffer_write_u16_at(sldns_buffer *buffer, size_t at, uint16_t data) -{ - if (buffer->_vfixed && at + sizeof(data) > buffer->_limit) return; - assert(sldns_buffer_available_at(buffer, at, sizeof(data))); - sldns_write_uint16(buffer->_data + at, data); -} - -/** - * writes the given 2 byte integer at the current position in the buffer - * \param[in] buffer the buffer - * \param[in] data the 16 bits to write - */ -INLINE void -sldns_buffer_write_u16(sldns_buffer *buffer, uint16_t data) -{ - sldns_buffer_write_u16_at(buffer, buffer->_position, data); - buffer->_position += sizeof(data); -} - -/** - * writes the given 4 byte integer at the given position in the buffer - * \param[in] buffer the buffer - * \param[in] at the position in the buffer - * \param[in] data the 32 bits to write - */ -INLINE void -sldns_buffer_write_u32_at(sldns_buffer *buffer, size_t at, uint32_t data) -{ - if (buffer->_vfixed && at + sizeof(data) > buffer->_limit) return; - assert(sldns_buffer_available_at(buffer, at, sizeof(data))); - sldns_write_uint32(buffer->_data + at, data); -} - -/** - * writes the given 6 byte integer at the given position in the buffer - * \param[in] buffer the buffer - * \param[in] at the position in the buffer - * \param[in] data the (lower) 48 bits to write - */ -INLINE void -sldns_buffer_write_u48_at(sldns_buffer *buffer, size_t at, uint64_t data) -{ - if (buffer->_vfixed && at + 6 > buffer->_limit) return; - assert(sldns_buffer_available_at(buffer, at, 6)); - sldns_write_uint48(buffer->_data + at, data); -} - -/** - * writes the given 4 byte integer at the current position in the buffer - * \param[in] buffer the buffer - * \param[in] data the 32 bits to write - */ -INLINE void -sldns_buffer_write_u32(sldns_buffer *buffer, uint32_t data) -{ - sldns_buffer_write_u32_at(buffer, buffer->_position, data); - buffer->_position += sizeof(data); -} - -/** - * writes the given 6 byte integer at the current position in the buffer - * \param[in] buffer the buffer - * \param[in] data the 48 bits to write - */ -INLINE void -sldns_buffer_write_u48(sldns_buffer *buffer, uint64_t data) -{ - sldns_buffer_write_u48_at(buffer, buffer->_position, data); - buffer->_position += 6; -} - -/** - * copies count bytes of data at the given position to the given data-array - * \param[in] buffer the buffer - * \param[in] at the position in the buffer to start - * \param[out] data buffer to copy to - * \param[in] count the length of the data to copy - */ -INLINE void -sldns_buffer_read_at(sldns_buffer *buffer, size_t at, void *data, size_t count) -{ - assert(sldns_buffer_available_at(buffer, at, count)); - memcpy(data, buffer->_data + at, count); -} - -/** - * copies count bytes of data at the current position to the given data-array - * \param[in] buffer the buffer - * \param[out] data buffer to copy to - * \param[in] count the length of the data to copy - */ -INLINE void -sldns_buffer_read(sldns_buffer *buffer, void *data, size_t count) -{ - sldns_buffer_read_at(buffer, buffer->_position, data, count); - buffer->_position += count; -} - -/** - * returns the byte value at the given position in the buffer - * \param[in] buffer the buffer - * \param[in] at the position in the buffer - * \return 1 byte integer - */ -INLINE uint8_t -sldns_buffer_read_u8_at(sldns_buffer *buffer, size_t at) -{ - assert(sldns_buffer_available_at(buffer, at, sizeof(uint8_t))); - return buffer->_data[at]; -} - -/** - * returns the byte value at the current position in the buffer - * \param[in] buffer the buffer - * \return 1 byte integer - */ -INLINE uint8_t -sldns_buffer_read_u8(sldns_buffer *buffer) -{ - uint8_t result = sldns_buffer_read_u8_at(buffer, buffer->_position); - buffer->_position += sizeof(uint8_t); - return result; -} - -/** - * returns the 2-byte integer value at the given position in the buffer - * \param[in] buffer the buffer - * \param[in] at position in the buffer - * \return 2 byte integer - */ -INLINE uint16_t -sldns_buffer_read_u16_at(sldns_buffer *buffer, size_t at) -{ - assert(sldns_buffer_available_at(buffer, at, sizeof(uint16_t))); - return sldns_read_uint16(buffer->_data + at); -} - -/** - * returns the 2-byte integer value at the current position in the buffer - * \param[in] buffer the buffer - * \return 2 byte integer - */ -INLINE uint16_t -sldns_buffer_read_u16(sldns_buffer *buffer) -{ - uint16_t result = sldns_buffer_read_u16_at(buffer, buffer->_position); - buffer->_position += sizeof(uint16_t); - return result; -} - -/** - * returns the 4-byte integer value at the given position in the buffer - * \param[in] buffer the buffer - * \param[in] at position in the buffer - * \return 4 byte integer - */ -INLINE uint32_t -sldns_buffer_read_u32_at(sldns_buffer *buffer, size_t at) -{ - assert(sldns_buffer_available_at(buffer, at, sizeof(uint32_t))); - return sldns_read_uint32(buffer->_data + at); -} - -/** - * returns the 4-byte integer value at the current position in the buffer - * \param[in] buffer the buffer - * \return 4 byte integer - */ -INLINE uint32_t -sldns_buffer_read_u32(sldns_buffer *buffer) -{ - uint32_t result = sldns_buffer_read_u32_at(buffer, buffer->_position); - buffer->_position += sizeof(uint32_t); - return result; -} - -/** - * returns the status of the buffer - * \param[in] buffer - * \return the status - */ -INLINE int -sldns_buffer_status(sldns_buffer *buffer) -{ - return (int)buffer->_status_err; -} - -/** - * returns true if the status of the buffer is LDNS_STATUS_OK, false otherwise - * \param[in] buffer the buffer - * \return true or false - */ -INLINE int -sldns_buffer_status_ok(sldns_buffer *buffer) -{ - if (buffer) { - return sldns_buffer_status(buffer) == 0; - } else { - return 0; - } -} - -/** - * prints to the buffer, increasing the capacity if required using - * buffer_reserve(). The buffer's position is set to the terminating '\\0' - * Returns the number of characters written (not including the - * terminating '\\0') or -1 on failure. - */ -int sldns_buffer_printf(sldns_buffer *buffer, const char *format, ...) - ATTR_FORMAT(printf, 2, 3); - -/** - * frees the buffer. - * \param[in] *buffer the buffer to be freed - * \return void - */ -void sldns_buffer_free(sldns_buffer *buffer); - -/** - * Makes the buffer fixed and returns a pointer to the data. The - * caller is responsible for free'ing the result. - * \param[in] *buffer the buffer to be exported - * \return void - */ -void *sldns_buffer_export(sldns_buffer *buffer); - -/** - * Copy contents of the from buffer to the result buffer and then flips - * the result buffer. Data will be silently truncated if the result buffer is - * too small. - * \param[out] *result resulting buffer which is copied to. - * \param[in] *from what to copy to result. - */ -void sldns_buffer_copy(sldns_buffer* result, sldns_buffer* from); - -#ifdef __cplusplus -} -#endif - -#endif /* LDNS_SBUFFER_H */ |