ldns documentation

- Main Page
- Related Pages
- Data Structures
- Files

- File List
- Globals

buffer.c
Go to the documentation of this file.
1 /*
2 * buffer.c -- generic memory buffer .
3 *
4 * Copyright (c) 2001-2008, NLnet Labs. All rights reserved.
5 *
6 * See LICENSE for the license.
7 *
8 */
9
10 #include <ldns/config.h>
11
12 #include <ldns/ldns.h>
13 #include <ldns/buffer.h>
14
15 ldns_buffer *
16 ldns_buffer_new(size_t capacity)
17 {
18 ldns_buffer *buffer = LDNS_MALLOC(ldns_buffer);
19
20 if (!buffer) {
21 return NULL;
22 }
23
24 buffer->_data = (uint8_t *) LDNS_XMALLOC(uint8_t, capacity);
25 if (!buffer->_data) {
26 LDNS_FREE(buffer);
27 return NULL;
28 }
29
30 buffer->_position = 0;
31 buffer->_limit = buffer->_capacity = capacity;
32 buffer->_fixed = 0;
33 buffer->_status = LDNS_STATUS_OK;
34
35 ldns_buffer_invariant(buffer);
36
37 return buffer;
38 }
39
40 void
41 ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size)
42 {
43 assert(data != NULL);
44
45 buffer->_position = 0;
46 buffer->_limit = buffer->_capacity = size;
47 buffer->_fixed = 0;
48 buffer->_data = LDNS_XMALLOC(uint8_t, size);
49 if(!buffer->_data) {
50 buffer->_status = LDNS_STATUS_MEM_ERR;
51 return;
52 }
53 memcpy(buffer->_data, data, size);
54 buffer->_status = LDNS_STATUS_OK;
55
56 ldns_buffer_invariant(buffer);
57 }
58
59 bool
60 ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity)
61 {
62 void *data;
63
64 ldns_buffer_invariant(buffer);
65 assert(buffer->_position <= capacity);
66
67 data = (uint8_t *) LDNS_XREALLOC(buffer->_data, uint8_t, capacity);
68 if (!data) {
69 buffer->_status = LDNS_STATUS_MEM_ERR;
70 return false;
71 } else {
72 buffer->_data = data;
73 buffer->_limit = buffer->_capacity = capacity;
74 return true;
75 }
76 }
77
78 bool
79 ldns_buffer_reserve(ldns_buffer *buffer, size_t amount)
80 {
81 ldns_buffer_invariant(buffer);
82 assert(!buffer->_fixed);
83 if (buffer->_capacity < buffer->_position + amount) {
84 size_t new_capacity = buffer->_capacity * 3 / 2;
85
86 if (new_capacity < buffer->_position + amount) {
87 new_capacity = buffer->_position + amount;
88 }
89 if (!ldns_buffer_set_capacity(buffer, new_capacity)) {
90 buffer->_status = LDNS_STATUS_MEM_ERR;
91 return false;
92 }
93 }
94 buffer->_limit = buffer->_capacity;
95 return true;
96 }
97
98 int
99 ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...)
100 {
101 va_list args;
102 int written = 0;
103 size_t remaining;
104
105 if (ldns_buffer_status_ok(buffer)) {
106 ldns_buffer_invariant(buffer);
107 assert(buffer->_limit == buffer->_capacity);
108
109 remaining = ldns_buffer_remaining(buffer);
110 va_start(args, format);
111 written = vsnprintf((char *) ldns_buffer_current(buffer), remaining,
112 format, args);
113 va_end(args);
114 if (written == -1) {
115 buffer->_status = LDNS_STATUS_INTERNAL_ERR;
116 return -1;
117 } else if ((size_t) written >= remaining) {
118 if (!ldns_buffer_reserve(buffer, (size_t) written + 1)) {
119 buffer->_status = LDNS_STATUS_MEM_ERR;
120 return -1;
121 }
122 va_start(args, format);
123 written = vsnprintf((char *) ldns_buffer_current(buffer),
124 ldns_buffer_remaining(buffer), format, args);
125 va_end(args);
126 if (written == -1) {
127 buffer->_status = LDNS_STATUS_INTERNAL_ERR;
128 return -1;
129 }
130 }
131 buffer->_position += written;
132 }
133 return written;
134 }
135
136 void
137 ldns_buffer_free(ldns_buffer *buffer)
138 {
139 if (!buffer) {
140 return;
141 }
142
143 if (!buffer->_fixed)
144 LDNS_FREE(buffer->_data);
145
146 LDNS_FREE(buffer);
147 }
148
149 void *
150 ldns_buffer_export(ldns_buffer *buffer)
151 {
152 buffer->_fixed = 1;
153 return buffer->_data;
154 }
155
156 int
157 ldns_bgetc(ldns_buffer *buffer)
158 {
159 if (!ldns_buffer_available_at(buffer, buffer->_position, sizeof(uint8_t))) {
160 ldns_buffer_set_position(buffer, ldns_buffer_limit(buffer));
161 /* ldns_buffer_rewind(buffer);*/
162 return EOF;
163 }
164 return (int)ldns_buffer_read_u8(buffer);
165 }
166
167 void
168 ldns_buffer_copy(ldns_buffer* result, ldns_buffer* from)
169 {
170 size_t tocopy = ldns_buffer_limit(from);
171
172 if(tocopy > ldns_buffer_capacity(result))
173 tocopy = ldns_buffer_capacity(result);
174 ldns_buffer_clear(result);
175 ldns_buffer_write(result, ldns_buffer_begin(from), tocopy);
176 ldns_buffer_flip(result);
177 }
ldns_struct_buffer
implementation of buffers to ease operations
Definition: buffer.h:50
ldns_buffer_export
void * ldns_buffer_export(ldns_buffer *buffer)
Makes the buffer fixed and returns a pointer to the data.
Definition: buffer.c:150
ldns_buffer_printf
int ldns_buffer_printf(ldns_buffer *buffer, const char *format,...)
prints to the buffer, increasing the capacity if required using buffer_reserve(). ...
Definition: buffer.c:99
ldns_struct_buffer::_status
ldns_status _status
The current state of the buffer.
Definition: buffer.h:70
LDNS_STATUS_OK
Definition: error.h:26
LDNS_XMALLOC
#define LDNS_XMALLOC(type, count)
Definition: util.h:51
ldns_buffer_free
void ldns_buffer_free(ldns_buffer *buffer)
frees the buffer.
Definition: buffer.c:137
ldns_struct_buffer::_limit
size_t _limit
The read/write limit.
Definition: buffer.h:56
ldns_struct_buffer::_capacity
size_t _capacity
The amount of data the buffer can contain.
Definition: buffer.h:59
LDNS_XREALLOC
#define LDNS_XREALLOC(ptr, type, count)
Definition: util.h:57
ldns_bgetc
int ldns_bgetc(ldns_buffer *buffer)
returns the next character from a buffer.
Definition: buffer.c:157
ldns.h
Including this file will include all ldns files, and define some lookup tables.
ldns_buffer_set_capacity
bool ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity)
changes the buffer&#39;s capacity.
Definition: buffer.c:60
ldns_struct_buffer::_position
size_t _position
The current position used for reading/writing.
Definition: buffer.h:53
LDNS_STATUS_MEM_ERR
Definition: error.h:34
LDNS_MALLOC
#define LDNS_MALLOC(type)
Memory management macros.
Definition: util.h:49
ldns_buffer_new
ldns_buffer * ldns_buffer_new(size_t capacity)
creates a new buffer with the specified capacity.
Definition: buffer.c:16
buffer.h
This file contains the definition of ldns_buffer, and functions to manipulate those.
ldns_buffer_reserve
bool ldns_buffer_reserve(ldns_buffer *buffer, size_t amount)
ensures BUFFER can contain at least AMOUNT more bytes.
Definition: buffer.c:79
ldns_struct_buffer::_fixed
unsigned _fixed
If the buffer is fixed it cannot be resized.
Definition: buffer.h:65
LDNS_FREE
#define LDNS_FREE(ptr)
Definition: util.h:60
ldns_buffer_copy
void ldns_buffer_copy(ldns_buffer *result, ldns_buffer *from)
Copy contents of the from buffer to the result buffer and then flips the result buffer.
Definition: buffer.c:168
ldns_struct_buffer::_data
uint8_t * _data
The data contained in the buffer.
Definition: buffer.h:62
ldns_buffer_new_frm_data
void ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size)
creates a buffer with the specified data.
Definition: buffer.c:41
LDNS_STATUS_INTERNAL_ERR
Definition: error.h:35
config.h