mirror of
https://github.com/monero-project/monero.git
synced 2024-12-29 07:36:16 -05:00
a85b5759f3
These files were pulled from the 1.6.3 release tarball. This new version builds against OpenSSL version 1.1 which will be the default in the new Debian Stable which is due to be released RealSoonNow (tm).
805 lines
22 KiB
C
805 lines
22 KiB
C
/*
|
|
* 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 */
|