sbuffer.h

Go to the documentation of this file.

/*
 * 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);
}
 


struct sldns_buffer
{ 
    size_t   _position;

    size_t   _limit;

    size_t   _capacity;

    uint8_t *_data;

    unsigned _fixed : 1;

    unsigned _vfixed : 1;

    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

sldns_buffer *sldns_buffer_new(size_t capacity);

void sldns_buffer_new_frm_data(sldns_buffer *buffer, void *data, size_t size);

void sldns_buffer_init_frm_data(sldns_buffer *buffer, void *data, size_t size);

void sldns_buffer_init_vfixed_frm_data(sldns_buffer *buffer, void *data, size_t size);

INLINE void sldns_buffer_clear(sldns_buffer *buffer)
{
    sldns_buffer_invariant(buffer);
 
    /* reset status here? */
 
    buffer->_position = 0;
    buffer->_limit = buffer->_capacity;
}

INLINE void sldns_buffer_flip(sldns_buffer *buffer)
{
    sldns_buffer_invariant(buffer);
 
    buffer->_limit = buffer->_position;
    buffer->_position = 0;
}

INLINE void sldns_buffer_rewind(sldns_buffer *buffer)
{
    sldns_buffer_invariant(buffer);
 
    buffer->_position = 0;
}

INLINE size_t
sldns_buffer_position(sldns_buffer *buffer)
{
    return buffer->_position;
}

INLINE void
sldns_buffer_set_position(sldns_buffer *buffer, size_t mark)
{
    assert(mark <= buffer->_limit || buffer->_vfixed);
    buffer->_position = mark;
}

INLINE void
sldns_buffer_skip(sldns_buffer *buffer, ssize_t count)
{
    assert(buffer->_position + count <= buffer->_limit || buffer->_vfixed);
    buffer->_position += count;
}

INLINE size_t
sldns_buffer_limit(sldns_buffer *buffer)
{
    return buffer->_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;
}

INLINE size_t
sldns_buffer_capacity(sldns_buffer *buffer)
{
    return buffer->_capacity;
}

int sldns_buffer_set_capacity(sldns_buffer *buffer, size_t capacity);

int sldns_buffer_reserve(sldns_buffer *buffer, size_t amount);

INLINE uint8_t *
sldns_buffer_at(const sldns_buffer *buffer, size_t at)
{
    assert(at <= buffer->_limit || buffer->_vfixed);
    return buffer->_data + at;
}

INLINE uint8_t *
sldns_buffer_begin(const sldns_buffer *buffer)
{
    return sldns_buffer_at(buffer, 0);
}

INLINE uint8_t *
sldns_buffer_end(sldns_buffer *buffer)
{
    return sldns_buffer_at(buffer, buffer->_limit);
}

INLINE uint8_t *
sldns_buffer_current(sldns_buffer *buffer)
{
    return sldns_buffer_at(buffer, buffer->_position);
}

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

INLINE size_t
sldns_buffer_remaining(sldns_buffer *buffer)
{
    return sldns_buffer_remaining_at(buffer, buffer->_position);
}

INLINE int
sldns_buffer_available_at(sldns_buffer *buffer, size_t at, size_t count)
{
    return count <= sldns_buffer_remaining_at(buffer, at);
}

INLINE int
sldns_buffer_available(sldns_buffer *buffer, size_t count)
{
    return sldns_buffer_available_at(buffer, buffer->_position, count);
}

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);
}

 
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);
}
 

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

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));
}

INLINE void
sldns_buffer_write_string(sldns_buffer *buffer, const char *str)
{
    sldns_buffer_write(buffer, str, strlen(str));
}

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

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

INLINE void
sldns_buffer_write_u48(sldns_buffer *buffer, uint64_t data)
{
    sldns_buffer_write_u48_at(buffer, buffer->_position, data);
    buffer->_position += 6;
}

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);
}

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

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];
}

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

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);
}

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

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);
}

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

INLINE int
sldns_buffer_status(sldns_buffer *buffer)
{
    return (int)buffer->_status_err;
}

INLINE int
sldns_buffer_status_ok(sldns_buffer *buffer)
{
    if (buffer) {
        return sldns_buffer_status(buffer) == 0;
    } else {
        return 0;
    }
}

int sldns_buffer_printf(sldns_buffer *buffer, const char *format, ...)
    ATTR_FORMAT(printf, 2, 3);

void sldns_buffer_free(sldns_buffer *buffer);

void *sldns_buffer_export(sldns_buffer *buffer);

void sldns_buffer_copy(sldns_buffer* result, sldns_buffer* from);
 
#ifdef __cplusplus
}
#endif
 
#endif /* LDNS_SBUFFER_H */