sbuffer.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	sldns_buffer

Macros
#define	INLINE   static inline

Typedefs
typedef struct sldns_buffer	sldns_buffer

Functions
INLINE uint16_t	sldns_read_uint16 (const void *src)
INLINE uint32_t	sldns_read_uint32 (const void *src)
INLINE void	sldns_write_uint16 (void *dst, uint16_t data)
INLINE void	sldns_write_uint32 (void *dst, uint32_t data)
INLINE void	sldns_write_uint48 (void *dst, uint64_t data)
INLINE void	sldns_buffer_invariant (sldns_buffer *buffer)
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)
INLINE void	sldns_buffer_flip (sldns_buffer *buffer)
INLINE void	sldns_buffer_rewind (sldns_buffer *buffer)
INLINE size_t	sldns_buffer_position (sldns_buffer *buffer)
INLINE void	sldns_buffer_set_position (sldns_buffer *buffer, size_t mark)
INLINE void	sldns_buffer_skip (sldns_buffer *buffer, ssize_t count)
INLINE size_t	sldns_buffer_limit (sldns_buffer *buffer)
INLINE void	sldns_buffer_set_limit (sldns_buffer *buffer, size_t limit)
INLINE size_t	sldns_buffer_capacity (sldns_buffer *buffer)
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)
INLINE uint8_t *	sldns_buffer_begin (const sldns_buffer *buffer)
INLINE uint8_t *	sldns_buffer_end (sldns_buffer *buffer)
INLINE uint8_t *	sldns_buffer_current (sldns_buffer *buffer)
INLINE size_t	sldns_buffer_remaining_at (sldns_buffer *buffer, size_t at)
INLINE size_t	sldns_buffer_remaining (sldns_buffer *buffer)
INLINE int	sldns_buffer_available_at (sldns_buffer *buffer, size_t at, size_t count)
INLINE int	sldns_buffer_available (sldns_buffer *buffer, size_t count)
INLINE void	sldns_buffer_write_at (sldns_buffer *buffer, size_t at, const void *data, size_t count)
INLINE void	sldns_buffer_set_at (sldns_buffer *buffer, size_t at, int c, size_t count)
INLINE void	sldns_buffer_write (sldns_buffer *buffer, const void *data, size_t count)
INLINE void	sldns_buffer_write_string_at (sldns_buffer *buffer, size_t at, const char *str)
INLINE void	sldns_buffer_write_string (sldns_buffer *buffer, const char *str)
INLINE void	sldns_buffer_write_u8_at (sldns_buffer *buffer, size_t at, uint8_t data)
INLINE void	sldns_buffer_write_u8 (sldns_buffer *buffer, uint8_t data)
INLINE void	sldns_buffer_write_u16_at (sldns_buffer *buffer, size_t at, uint16_t data)
INLINE void	sldns_buffer_write_u16 (sldns_buffer *buffer, uint16_t data)
INLINE void	sldns_buffer_write_u32_at (sldns_buffer *buffer, size_t at, uint32_t data)
INLINE void	sldns_buffer_write_u48_at (sldns_buffer *buffer, size_t at, uint64_t data)
INLINE void	sldns_buffer_write_u32 (sldns_buffer *buffer, uint32_t data)
INLINE void	sldns_buffer_write_u48 (sldns_buffer *buffer, uint64_t data)
INLINE void	sldns_buffer_read_at (sldns_buffer *buffer, size_t at, void *data, size_t count)
INLINE void	sldns_buffer_read (sldns_buffer *buffer, void *data, size_t count)
INLINE uint8_t	sldns_buffer_read_u8_at (sldns_buffer *buffer, size_t at)
INLINE uint8_t	sldns_buffer_read_u8 (sldns_buffer *buffer)
INLINE uint16_t	sldns_buffer_read_u16_at (sldns_buffer *buffer, size_t at)
INLINE uint16_t	sldns_buffer_read_u16 (sldns_buffer *buffer)
INLINE uint32_t	sldns_buffer_read_u32_at (sldns_buffer *buffer, size_t at)
INLINE uint32_t	sldns_buffer_read_u32 (sldns_buffer *buffer)
INLINE int	sldns_buffer_status (sldns_buffer *buffer)
INLINE int	sldns_buffer_status_ok (sldns_buffer *buffer)
int	sldns_buffer_printf (sldns_buffer *buffer, const char *format,...) ATTR_FORMAT(printf
int void	sldns_buffer_free (sldns_buffer *buffer)
void *	sldns_buffer_export (sldns_buffer *buffer)
void	sldns_buffer_copy (sldns_buffer *result, sldns_buffer *from)

Detailed Description

This file contains the definition of sldns_buffer, and functions to manipulate those.

Definition in file sbuffer.h.

Macro Definition Documentation

INLINE

#define INLINE   static inline

Definition at line 26 of file sbuffer.h.

Typedef Documentation

sldns_buffer

typedef struct sldns_buffer sldns_buffer

Definition at line 149 of file sbuffer.h.

Function Documentation

sldns_buffer_at()

INLINE uint8_t * sldns_buffer_at	(	const sldns_buffer *	buffer,
		size_t	at )

returns a pointer to the data at the indicated position.

Parameters

[in]	buffer	the buffer
[in]	at	position

Returns

the pointer to the data

Definition at line 355 of file sbuffer.h.

{
    assert(at <= buffer->_limit || buffer->_vfixed);
    return buffer->_data + at;
}

Here is the caller graph for this function:

sldns_buffer_available()

INLINE int sldns_buffer_available	(	sldns_buffer *	buffer,
		size_t	count )

checks if the buffer has count bytes available at the current position

Parameters

[in]	buffer	the buffer
[in]	count	how much is available

Returns

true or false (as int?)

Definition at line 445 of file sbuffer.h.

{
    return sldns_buffer_available_at(buffer, buffer->_position, count);
}

Here is the call graph for this function:

sldns_buffer_available_at()

INLINE int sldns_buffer_available_at	(	sldns_buffer *	buffer,
		size_t	at,
		size_t	count )

checks if the buffer has at least COUNT more bytes available. Before reading or writing the caller needs to ensure enough space is available!

Parameters

[in]	buffer	the buffer
[in]	at	indicated position
[in]	count	how much is available

Returns

true or false (as int?)

Definition at line 433 of file sbuffer.h.

{
    return count <= sldns_buffer_remaining_at(buffer, at);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_begin()

INLINE uint8_t * sldns_buffer_begin

(

const sldns_buffer *

buffer

)

returns a pointer to the beginning of the buffer (the data at position 0).

Parameters

[in]

buffer

the buffer

Returns

the pointer

Definition at line 368 of file sbuffer.h.

{
    return sldns_buffer_at(buffer, 0);
}

Here is the call graph for this function:

sldns_buffer_capacity()

INLINE size_t sldns_buffer_capacity

(

sldns_buffer *

buffer

)

returns the number of bytes the buffer can hold.

Parameters

[in]

buffer

the buffer

Returns

the number of bytes

Definition at line 321 of file sbuffer.h.

{
    return buffer->_capacity;
}

sldns_buffer_clear()

INLINE void sldns_buffer_clear

(

sldns_buffer *

buffer

)

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.

Parameters

[in]

buffer

the buffer to clear

Definition at line 213 of file sbuffer.h.

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

Here is the call graph for this function:

sldns_buffer_copy()

void sldns_buffer_copy	(	sldns_buffer *	result,
		sldns_buffer *	from )

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.

Parameters

[out]	*result	resulting buffer which is copied to.
[in]	*from	what to copy to result.

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_current()

INLINE uint8_t * sldns_buffer_current

(

sldns_buffer *

buffer

)

returns a pointer to the data at the buffer's current position.

Parameters

[in]

buffer

the buffer

Returns

the pointer

Definition at line 391 of file sbuffer.h.

{
    return sldns_buffer_at(buffer, buffer->_position);
}

Here is the call graph for this function:

sldns_buffer_end()

INLINE uint8_t * sldns_buffer_end

(

sldns_buffer *

buffer

)

returns a pointer to the end of the buffer (the data at the buffer's limit).

Parameters

[in]

buffer

the buffer

Returns

the pointer

Definition at line 380 of file sbuffer.h.

{
    return sldns_buffer_at(buffer, buffer->_limit);
}

Here is the call graph for this function:

sldns_buffer_export()

void * sldns_buffer_export

(

sldns_buffer *

buffer

)

Makes the buffer fixed and returns a pointer to the data. The caller is responsible for free'ing the result.

Parameters

[in]

*buffer

the buffer to be exported

Returns

void

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_flip()

INLINE void sldns_buffer_flip

(

sldns_buffer *

buffer

)

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.

Parameters

[in]

buffer

the buffer to flip

Returns

void

Definition at line 231 of file sbuffer.h.

{
    sldns_buffer_invariant(buffer);
 
    buffer->_limit = buffer->_position;
    buffer->_position = 0;
}

Here is the call graph for this function:

sldns_buffer_free()

int void sldns_buffer_free

(

sldns_buffer *

buffer

)

frees the buffer.

Parameters

[in]

*buffer

the buffer to be freed

Returns

void

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_init_frm_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 fixed.

Parameters

[in]	buffer	pointer to the buffer to put the data in
[in]	data	the data to encapsulate in the buffer
[in]	size	the size of the data

sldns_buffer_init_vfixed_frm_data()

void sldns_buffer_init_vfixed_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.

Parameters

[in]	buffer	pointer to the buffer to put the data in
[in]	data	the data to encapsulate in the buffer
[in]	size	the size of the data

sldns_buffer_invariant()

INLINE void sldns_buffer_invariant

(

sldns_buffer *

buffer

)

Definition at line 158 of file sbuffer.h.

{
    assert(buffer != NULL);
    assert(buffer->_position <= buffer->_limit || buffer->_vfixed);
    assert(buffer->_limit <= buffer->_capacity);
    assert(buffer->_data != NULL || (buffer->_vfixed && buffer->_capacity == 0));
}

Here is the caller graph for this function:

sldns_buffer_limit()

INLINE size_t sldns_buffer_limit

(

sldns_buffer *

buffer

)

returns the maximum size of the buffer

Parameters

[in]

buffer

Returns

the size

Definition at line 295 of file sbuffer.h.

{
    return buffer->_limit;
}

sldns_buffer_new()

sldns_buffer * sldns_buffer_new

(

size_t

capacity

)

creates a new buffer with the specified capacity.

Parameters

[in]

capacity

the size (in bytes) to allocate for the buffer

Returns

the created buffer

sldns_buffer_new_frm_data()

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

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().

Parameters

[in]	buffer	pointer to the buffer to put the data in
[in]	data	the data to encapsulate in the buffer
[in]	size	the size of the data

sldns_buffer_position()

INLINE size_t sldns_buffer_position

(

sldns_buffer *

buffer

)

returns the current position in the buffer (as a number of bytes)

Parameters

[in]

buffer

the buffer

Returns

the current position

Definition at line 257 of file sbuffer.h.

{
    return buffer->_position;
}

sldns_buffer_printf()

int sldns_buffer_printf	(	sldns_buffer *	buffer,
		const char *	format,
			... )

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.

sldns_buffer_read()

INLINE void sldns_buffer_read	(	sldns_buffer *	buffer,
		void *	data,
		size_t	count )

copies count bytes of data at the current position to the given data-array

Parameters

[in]	buffer	the buffer
[out]	data	buffer to copy to
[in]	count	the length of the data to copy

Definition at line 657 of file sbuffer.h.

{
    sldns_buffer_read_at(buffer, buffer->_position, data, count);
    buffer->_position += count;
}

Here is the call graph for this function:

sldns_buffer_read_at()

INLINE void sldns_buffer_read_at	(	sldns_buffer *	buffer,
		size_t	at,
		void *	data,
		size_t	count )

copies count bytes of data at the given position to the given data-array

Parameters

[in]	buffer	the buffer
[in]	at	the position in the buffer to start
[out]	data	buffer to copy to
[in]	count	the length of the data to copy

Definition at line 644 of file sbuffer.h.

{
    assert(sldns_buffer_available_at(buffer, at, count));
    memcpy(data, buffer->_data + at, count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_read_u16()

INLINE uint16_t sldns_buffer_read_u16

(

sldns_buffer *

buffer

)

returns the 2-byte integer value at the current position in the buffer

Parameters

[in]

buffer

the buffer

Returns

2 byte integer

Definition at line 708 of file sbuffer.h.

{
    uint16_t result = sldns_buffer_read_u16_at(buffer, buffer->_position);
    buffer->_position += sizeof(uint16_t);
    return result;
}

Here is the call graph for this function:

sldns_buffer_read_u16_at()

INLINE uint16_t sldns_buffer_read_u16_at	(	sldns_buffer *	buffer,
		size_t	at )

returns the 2-byte integer value at the given position in the buffer

Parameters

[in]	buffer	the buffer
[in]	at	position in the buffer

Returns

2 byte integer

Definition at line 696 of file sbuffer.h.

{
    assert(sldns_buffer_available_at(buffer, at, sizeof(uint16_t)));
    return sldns_read_uint16(buffer->_data + at);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_read_u32()

INLINE uint32_t sldns_buffer_read_u32

(

sldns_buffer *

buffer

)

returns the 4-byte integer value at the current position in the buffer

Parameters

[in]

buffer

the buffer

Returns

4 byte integer

Definition at line 734 of file sbuffer.h.

{
    uint32_t result = sldns_buffer_read_u32_at(buffer, buffer->_position);
    buffer->_position += sizeof(uint32_t);
    return result;
}

Here is the call graph for this function:

sldns_buffer_read_u32_at()

INLINE uint32_t sldns_buffer_read_u32_at	(	sldns_buffer *	buffer,
		size_t	at )

returns the 4-byte integer value at the given position in the buffer

Parameters

[in]	buffer	the buffer
[in]	at	position in the buffer

Returns

4 byte integer

Definition at line 722 of file sbuffer.h.

{
    assert(sldns_buffer_available_at(buffer, at, sizeof(uint32_t)));
    return sldns_read_uint32(buffer->_data + at);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_read_u8()

INLINE uint8_t sldns_buffer_read_u8

(

sldns_buffer *

buffer

)

returns the byte value at the current position in the buffer

Parameters

[in]

buffer

the buffer

Returns

1 byte integer

Definition at line 682 of file sbuffer.h.

{
    uint8_t result = sldns_buffer_read_u8_at(buffer, buffer->_position);
    buffer->_position += sizeof(uint8_t);
    return result;
}

Here is the call graph for this function:

sldns_buffer_read_u8_at()

INLINE uint8_t sldns_buffer_read_u8_at	(	sldns_buffer *	buffer,
		size_t	at )

returns the byte value at the given position in the buffer

Parameters

[in]	buffer	the buffer
[in]	at	the position in the buffer

Returns

1 byte integer

Definition at line 670 of file sbuffer.h.

{
    assert(sldns_buffer_available_at(buffer, at, sizeof(uint8_t)));
    return buffer->_data[at];
}

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_remaining()

INLINE size_t sldns_buffer_remaining

(

sldns_buffer *

buffer

)

returns the number of bytes remaining between the buffer's position and limit.

Parameters

[in]

buffer

the buffer

Returns

the number of bytes

Definition at line 418 of file sbuffer.h.

{
    return sldns_buffer_remaining_at(buffer, buffer->_position);
}

Here is the call graph for this function:

sldns_buffer_remaining_at()

INLINE size_t sldns_buffer_remaining_at	(	sldns_buffer *	buffer,
		size_t	at )

returns the number of bytes remaining between the indicated position and the limit.

Parameters

[in]	buffer	the buffer
[in]	at	indicated position

Returns

number of bytes

Definition at line 404 of file sbuffer.h.

{
    sldns_buffer_invariant(buffer);
    assert(at <= buffer->_limit || buffer->_vfixed);
    return at < buffer->_limit ? buffer->_limit - at : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_reserve()

int sldns_buffer_reserve	(	sldns_buffer *	buffer,
		size_t	amount )

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.

Parameters

[in]	buffer	the buffer
[in]	amount	amount to use

Returns

whether this failed or succeeded

sldns_buffer_rewind()

INLINE void sldns_buffer_rewind

(

sldns_buffer *

buffer

)

make the buffer ready for re-reading the data. The buffer's position is reset to 0.

Parameters

[in]

buffer

the buffer to rewind

Definition at line 244 of file sbuffer.h.

{
    sldns_buffer_invariant(buffer);
 
    buffer->_position = 0;
}

Here is the call graph for this function:

sldns_buffer_set_at()

INLINE void sldns_buffer_set_at	(	sldns_buffer *	buffer,
		size_t	at,
		int	c,
		size_t	count )

set the given byte to the buffer at the specified position

Parameters

[in]	buffer	the buffer
[in]	at	the position (in number of bytes) to write the data at
[in]	c	the byte to set to the buffer
[in]	count	the number of bytes of bytes to write

Definition at line 481 of file sbuffer.h.

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

Here is the call graph for this function:

sldns_buffer_set_capacity()

int sldns_buffer_set_capacity	(	sldns_buffer *	buffer,
		size_t	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.

Parameters

[in]	buffer	the buffer
[in]	capacity	the capacity to use

Returns

whether this failed or succeeded

sldns_buffer_set_limit()

INLINE void sldns_buffer_set_limit	(	sldns_buffer *	buffer,
		size_t	limit )

changes the buffer's limit. If the buffer's position is greater than the new limit the position is set to the limit.

Parameters

[in]	buffer	the buffer
[in]	limit	the new limit

Definition at line 307 of file sbuffer.h.

{
    assert(limit <= buffer->_capacity);
    buffer->_limit = limit;
    if (buffer->_position > buffer->_limit)
        buffer->_position = buffer->_limit;
}

sldns_buffer_set_position()

INLINE void sldns_buffer_set_position	(	sldns_buffer *	buffer,
		size_t	mark )

sets the buffer's position to MARK. The position must be less than or equal to the buffer's limit.

Parameters

[in]	buffer	the buffer
[in]	mark	the mark to use

Definition at line 269 of file sbuffer.h.

{
    assert(mark <= buffer->_limit || buffer->_vfixed);
    buffer->_position = mark;
}

sldns_buffer_skip()

INLINE void sldns_buffer_skip	(	sldns_buffer *	buffer,
		ssize_t	count )

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.

Parameters

[in]	buffer	the buffer
[in]	count	the count to use

Definition at line 283 of file sbuffer.h.

{
    assert(buffer->_position + count <= buffer->_limit || buffer->_vfixed);
    buffer->_position += count;
}

sldns_buffer_status()

INLINE int sldns_buffer_status

(

sldns_buffer *

buffer

)

returns the status of the buffer

Parameters

[in]

buffer

Returns

the status

Definition at line 747 of file sbuffer.h.

{
    return (int)buffer->_status_err;
}

Here is the caller graph for this function:

sldns_buffer_status_ok()

INLINE int sldns_buffer_status_ok

(

sldns_buffer *

buffer

)

returns true if the status of the buffer is LDNS_STATUS_OK, false otherwise

Parameters

[in]

buffer

the buffer

Returns

true or false

Definition at line 758 of file sbuffer.h.

{
    if (buffer) {
        return sldns_buffer_status(buffer) == 0;
    } else {
        return 0;
    }
}

Here is the call graph for this function:

sldns_buffer_write()

INLINE void sldns_buffer_write	(	sldns_buffer *	buffer,
		const void *	data,
		size_t	count )

writes count bytes of data to the current position of the buffer

Parameters

[in]	buffer	the buffer
[in]	data	the data to write
[in]	count	the length of the data to write

Definition at line 503 of file sbuffer.h.

{
    sldns_buffer_write_at(buffer, buffer->_position, data, count);
    buffer->_position += count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_write_at()

INLINE void sldns_buffer_write_at	(	sldns_buffer *	buffer,
		size_t	at,
		const void *	data,
		size_t	count )

writes the given data to the buffer at the specified position

Parameters

[in]	buffer	the buffer
[in]	at	the position (in number of bytes) to write the data at
[in]	data	pointer to the data to write to the buffer
[in]	count	the number of bytes of data to write

Definition at line 458 of file sbuffer.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_write_string()

INLINE void sldns_buffer_write_string	(	sldns_buffer *	buffer,
		const char *	str )

copies the given (null-delimited) string to the current position at the buffer

Parameters

[in]	buffer	the buffer
[in]	str	the string to write

Definition at line 527 of file sbuffer.h.

{
    sldns_buffer_write(buffer, str, strlen(str));
}

Here is the call graph for this function:

sldns_buffer_write_string_at()

INLINE void sldns_buffer_write_string_at	(	sldns_buffer *	buffer,
		size_t	at,
		const char *	str )

copies the given (null-delimited) string to the specified position at the buffer

Parameters

[in]	buffer	the buffer
[in]	at	the position in the buffer
[in]	str	the string to write

Definition at line 516 of file sbuffer.h.

{
    sldns_buffer_write_at(buffer, at, str, strlen(str));
}

Here is the call graph for this function:

sldns_buffer_write_u16()

INLINE void sldns_buffer_write_u16	(	sldns_buffer *	buffer,
		uint16_t	data )

writes the given 2 byte integer at the current position in the buffer

Parameters

[in]	buffer	the buffer
[in]	data	the 16 bits to write

Definition at line 578 of file sbuffer.h.

{
    sldns_buffer_write_u16_at(buffer, buffer->_position, data);
    buffer->_position += sizeof(data);
}

Here is the call graph for this function:

sldns_buffer_write_u16_at()

INLINE void sldns_buffer_write_u16_at	(	sldns_buffer *	buffer,
		size_t	at,
		uint16_t	data )

writes the given 2 byte integer at the given position in the buffer

Parameters

[in]	buffer	the buffer
[in]	at	the position in the buffer
[in]	data	the 16 bits to write

Definition at line 565 of file sbuffer.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_write_u32()

INLINE void sldns_buffer_write_u32	(	sldns_buffer *	buffer,
		uint32_t	data )

writes the given 4 byte integer at the current position in the buffer

Parameters

[in]	buffer	the buffer
[in]	data	the 32 bits to write

Definition at line 618 of file sbuffer.h.

{
    sldns_buffer_write_u32_at(buffer, buffer->_position, data);
    buffer->_position += sizeof(data);
}

Here is the call graph for this function:

sldns_buffer_write_u32_at()

INLINE void sldns_buffer_write_u32_at	(	sldns_buffer *	buffer,
		size_t	at,
		uint32_t	data )

writes the given 4 byte integer at the given position in the buffer

Parameters

[in]	buffer	the buffer
[in]	at	the position in the buffer
[in]	data	the 32 bits to write

Definition at line 591 of file sbuffer.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_write_u48()

INLINE void sldns_buffer_write_u48	(	sldns_buffer *	buffer,
		uint64_t	data )

writes the given 6 byte integer at the current position in the buffer

Parameters

[in]	buffer	the buffer
[in]	data	the 48 bits to write

Definition at line 630 of file sbuffer.h.

{
    sldns_buffer_write_u48_at(buffer, buffer->_position, data);
    buffer->_position += 6;
}

Here is the call graph for this function:

sldns_buffer_write_u48_at()

INLINE void sldns_buffer_write_u48_at	(	sldns_buffer *	buffer,
		size_t	at,
		uint64_t	data )

writes the given 6 byte integer at the given position in the buffer

Parameters

[in]	buffer	the buffer
[in]	at	the position in the buffer
[in]	data	the (lower) 48 bits to write

Definition at line 605 of file sbuffer.h.

{
    if (buffer->_vfixed && at + 6 > buffer->_limit) return;
    assert(sldns_buffer_available_at(buffer, at, 6));
    sldns_write_uint48(buffer->_data + at, data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_buffer_write_u8()

INLINE void sldns_buffer_write_u8	(	sldns_buffer *	buffer,
		uint8_t	data )

writes the given byte of data at the current position in the buffer

Parameters

[in]	buffer	the buffer
[in]	data	the 8 bits to write

Definition at line 552 of file sbuffer.h.

{
    sldns_buffer_write_u8_at(buffer, buffer->_position, data);
    buffer->_position += sizeof(data);
}

Here is the call graph for this function:

sldns_buffer_write_u8_at()

INLINE void sldns_buffer_write_u8_at	(	sldns_buffer *	buffer,
		size_t	at,
		uint8_t	data )

writes the given byte of data at the given position in the buffer

Parameters

[in]	buffer	the buffer
[in]	at	the position in the buffer
[in]	data	the 8 bits to write

Definition at line 539 of file sbuffer.h.

{
    if (buffer->_vfixed && at + sizeof(data) > buffer->_limit) return;
    assert(sldns_buffer_available_at(buffer, at, sizeof(data)));
    buffer->_data[at] = data;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sldns_read_uint16()

INLINE uint16_t sldns_read_uint16

(

const void *

src

)

Definition at line 35 of file sbuffer.h.

{
#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
}

Here is the caller graph for this function:

sldns_read_uint32()

INLINE uint32_t sldns_read_uint32

(

const void *

src

)

Definition at line 46 of file sbuffer.h.

{
#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
}

Here is the caller graph for this function:

sldns_write_uint16()

INLINE void sldns_write_uint16	(	void *	dst,
		uint16_t	data )

Definition at line 64 of file sbuffer.h.

{
#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
}

Here is the caller graph for this function:

sldns_write_uint32()

INLINE void sldns_write_uint32	(	void *	dst,
		uint32_t	data )

Definition at line 76 of file sbuffer.h.

{
#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
}

Here is the caller graph for this function:

sldns_write_uint48()

INLINE void sldns_write_uint48	(	void *	dst,
		uint64_t	data )

Definition at line 91 of file sbuffer.h.

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

Here is the caller graph for this function: