buffer.h

Go to the documentation of this file.
00001 /*
00002  * buffer.h -- generic memory buffer.
00003  *
00004  * Copyright (c) 2005-2006, NLnet Labs. All rights reserved.
00005  *
00006  * See LICENSE for the license.
00007  *
00008  *
00009  * The buffer module implements a generic buffer.  The API is based on
00010  * the java.nio.Buffer interface.
00011  */
00012 
00013 #ifndef LDNS_BUFFER_H
00014 #define LDNS_BUFFER_H
00015 
00016 #include <assert.h>
00017 #include <stdarg.h>
00018 #include <string.h>
00019 
00020 #include <ldns/error.h>
00021 #include <ldns/common.h>
00022 
00023 #include "ldns/util.h"
00024 
00029 #define LDNS_MIN_BUFLEN 256
00030 
00046 struct ldns_struct_buffer
00047 {
00049         size_t   _position;
00050 
00052         size_t   _limit;
00053 
00055         size_t   _capacity;
00056 
00058         uint8_t *_data;
00059 
00061         unsigned _fixed : 1;
00062 
00066         ldns_status _status;
00067 };
00068 typedef struct ldns_struct_buffer ldns_buffer;
00069 
00070 
00071 #ifdef NDEBUG
00072 INLINE void
00073 ldns_buffer_invariant(ldns_buffer *ATTR_UNUSED(buffer))
00074 {
00075 }
00076 #else
00077 INLINE void
00078 ldns_buffer_invariant(ldns_buffer *buffer)
00079 {
00080         assert(buffer != NULL);
00081         assert(buffer->_position <= buffer->_limit);
00082         assert(buffer->_limit <= buffer->_capacity);
00083         assert(buffer->_data != NULL);
00084 }
00085 #endif
00086 
00093 ldns_buffer *ldns_buffer_new(size_t capacity);
00094 
00104 void ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size);
00105 
00111 INLINE void ldns_buffer_clear(ldns_buffer *buffer)
00112 {
00113         ldns_buffer_invariant(buffer);
00114 
00115         /* reset status here? */
00116 
00117         buffer->_position = 0;
00118         buffer->_limit = buffer->_capacity;
00119 }
00120 
00129 INLINE void ldns_buffer_flip(ldns_buffer *buffer)
00130 {
00131         ldns_buffer_invariant(buffer);
00132 
00133         buffer->_limit = buffer->_position;
00134         buffer->_position = 0;
00135 }
00136 
00142 INLINE void ldns_buffer_rewind(ldns_buffer *buffer)
00143 {
00144         ldns_buffer_invariant(buffer);
00145 
00146         buffer->_position = 0;
00147 }
00148 
00154 INLINE size_t
00155 ldns_buffer_position(ldns_buffer *buffer)
00156 {
00157         return buffer->_position;
00158 }
00159 
00166 INLINE void
00167 ldns_buffer_set_position(ldns_buffer *buffer, size_t mark)
00168 {
00169         assert(mark <= buffer->_limit);
00170         buffer->_position = mark;
00171 }
00172 
00180 INLINE void
00181 ldns_buffer_skip(ldns_buffer *buffer, ssize_t count)
00182 {
00183         assert(buffer->_position + count <= buffer->_limit);
00184         buffer->_position += count;
00185 }
00186 
00192 INLINE size_t
00193 ldns_buffer_limit(ldns_buffer *buffer)
00194 {
00195         return buffer->_limit;
00196 }
00197 
00204 INLINE void
00205 ldns_buffer_set_limit(ldns_buffer *buffer, size_t limit)
00206 {
00207         assert(limit <= buffer->_capacity);
00208         buffer->_limit = limit;
00209         if (buffer->_position > buffer->_limit)
00210                 buffer->_position = buffer->_limit;
00211 }
00212 
00218 INLINE size_t
00219 ldns_buffer_capacity(ldns_buffer *buffer)
00220 {
00221         return buffer->_capacity;
00222 }
00223 
00232 bool ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity);
00233 
00244 bool ldns_buffer_reserve(ldns_buffer *buffer, size_t amount);
00245 
00252 INLINE uint8_t *
00253 ldns_buffer_at(ldns_buffer *buffer, size_t at)
00254 {
00255         assert(at <= buffer->_limit);
00256         return buffer->_data + at;
00257 }
00258 
00265 INLINE uint8_t *
00266 ldns_buffer_begin(ldns_buffer *buffer)
00267 {
00268         return ldns_buffer_at(buffer, 0);
00269 }
00270 
00277 INLINE uint8_t *
00278 ldns_buffer_end(ldns_buffer *buffer)
00279 {
00280         return ldns_buffer_at(buffer, buffer->_limit);
00281 }
00282 
00288 INLINE uint8_t *
00289 ldns_buffer_current(ldns_buffer *buffer)
00290 {
00291         return ldns_buffer_at(buffer, buffer->_position);
00292 }
00293 
00301 INLINE size_t
00302 ldns_buffer_remaining_at(ldns_buffer *buffer, size_t at)
00303 {
00304         ldns_buffer_invariant(buffer);
00305         assert(at <= buffer->_limit);
00306         return buffer->_limit - at;
00307 }
00308 
00315 INLINE size_t
00316 ldns_buffer_remaining(ldns_buffer *buffer)
00317 {
00318         return ldns_buffer_remaining_at(buffer, buffer->_position);
00319 }
00320 
00330 INLINE int
00331 ldns_buffer_available_at(ldns_buffer *buffer, size_t at, size_t count)
00332 {
00333         return count <= ldns_buffer_remaining_at(buffer, at);
00334 }
00335 
00342 INLINE int
00343 ldns_buffer_available(ldns_buffer *buffer, size_t count)
00344 {
00345         return ldns_buffer_available_at(buffer, buffer->_position, count);
00346 }
00347 
00355 INLINE void
00356 ldns_buffer_write_at(ldns_buffer *buffer, size_t at, const void *data, size_t count)
00357 {
00358         assert(ldns_buffer_available_at(buffer, at, count));
00359         memcpy(buffer->_data + at, data, count);
00360 }
00361 
00368 INLINE void
00369 ldns_buffer_write(ldns_buffer *buffer, const void *data, size_t count)
00370 {
00371         ldns_buffer_write_at(buffer, buffer->_position, data, count);
00372         buffer->_position += count;
00373 }
00374 
00381 INLINE void
00382 ldns_buffer_write_string_at(ldns_buffer *buffer, size_t at, const char *str)
00383 {
00384         ldns_buffer_write_at(buffer, at, str, strlen(str));
00385 }
00386 
00392 INLINE void
00393 ldns_buffer_write_string(ldns_buffer *buffer, const char *str)
00394 {
00395         ldns_buffer_write(buffer, str, strlen(str));
00396 }
00397 
00404 INLINE void
00405 ldns_buffer_write_u8_at(ldns_buffer *buffer, size_t at, uint8_t data)
00406 {
00407         assert(ldns_buffer_available_at(buffer, at, sizeof(data)));
00408         buffer->_data[at] = data;
00409 }
00410 
00416 INLINE void
00417 ldns_buffer_write_u8(ldns_buffer *buffer, uint8_t data)
00418 {
00419         ldns_buffer_write_u8_at(buffer, buffer->_position, data);
00420         buffer->_position += sizeof(data);
00421 }
00422 
00429 INLINE void
00430 ldns_buffer_write_u16_at(ldns_buffer *buffer, size_t at, uint16_t data)
00431 {
00432         assert(ldns_buffer_available_at(buffer, at, sizeof(data)));
00433         ldns_write_uint16(buffer->_data + at, data);
00434 }
00435 
00441 INLINE void
00442 ldns_buffer_write_u16(ldns_buffer *buffer, uint16_t data)
00443 {
00444         ldns_buffer_write_u16_at(buffer, buffer->_position, data);
00445         buffer->_position += sizeof(data);
00446 }
00447 
00454 INLINE void
00455 ldns_buffer_write_u32_at(ldns_buffer *buffer, size_t at, uint32_t data)
00456 {
00457         assert(ldns_buffer_available_at(buffer, at, sizeof(data)));
00458         ldns_write_uint32(buffer->_data + at, data);
00459 }
00460 
00466 INLINE void
00467 ldns_buffer_write_u32(ldns_buffer *buffer, uint32_t data)
00468 {
00469         ldns_buffer_write_u32_at(buffer, buffer->_position, data);
00470         buffer->_position += sizeof(data);
00471 }
00472 
00480 INLINE void
00481 ldns_buffer_read_at(ldns_buffer *buffer, size_t at, void *data, size_t count)
00482 {
00483         assert(ldns_buffer_available_at(buffer, at, count));
00484         memcpy(data, buffer->_data + at, count);
00485 }
00486 
00493 INLINE void
00494 ldns_buffer_read(ldns_buffer *buffer, void *data, size_t count)
00495 {
00496         ldns_buffer_read_at(buffer, buffer->_position, data, count);
00497         buffer->_position += count;
00498 }
00499 
00506 INLINE uint8_t
00507 ldns_buffer_read_u8_at(ldns_buffer *buffer, size_t at)
00508 {
00509         assert(ldns_buffer_available_at(buffer, at, sizeof(uint8_t)));
00510         return buffer->_data[at];
00511 }
00512 
00518 INLINE uint8_t
00519 ldns_buffer_read_u8(ldns_buffer *buffer)
00520 {
00521         uint8_t result = ldns_buffer_read_u8_at(buffer, buffer->_position);
00522         buffer->_position += sizeof(uint8_t);
00523         return result;
00524 }
00525 
00532 INLINE uint16_t
00533 ldns_buffer_read_u16_at(ldns_buffer *buffer, size_t at)
00534 {
00535         assert(ldns_buffer_available_at(buffer, at, sizeof(uint16_t)));
00536         return ldns_read_uint16(buffer->_data + at);
00537 }
00538 
00544 INLINE uint16_t
00545 ldns_buffer_read_u16(ldns_buffer *buffer)
00546 {
00547         uint16_t result = ldns_buffer_read_u16_at(buffer, buffer->_position);
00548         buffer->_position += sizeof(uint16_t);
00549         return result;
00550 }
00551 
00558 INLINE uint32_t
00559 ldns_buffer_read_u32_at(ldns_buffer *buffer, size_t at)
00560 {
00561         assert(ldns_buffer_available_at(buffer, at, sizeof(uint32_t)));
00562         return ldns_read_uint32(buffer->_data + at);
00563 }
00564 
00570 INLINE uint32_t
00571 ldns_buffer_read_u32(ldns_buffer *buffer)
00572 {
00573         uint32_t result = ldns_buffer_read_u32_at(buffer, buffer->_position);
00574         buffer->_position += sizeof(uint32_t);
00575         return result;
00576 }
00577 
00583 INLINE ldns_status
00584 ldns_buffer_status(ldns_buffer *buffer)
00585 {
00586         return buffer->_status;
00587 }
00588 
00594 INLINE bool
00595 ldns_buffer_status_ok(ldns_buffer *buffer)
00596 {
00597         if (buffer) {
00598                 return ldns_buffer_status(buffer) == LDNS_STATUS_OK;
00599         } else {
00600                 return false;
00601         }
00602 }
00603 
00610 int ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...);
00611 /*      ATTR_FORMAT(printf, 2, 3);*/
00612 
00618 void ldns_buffer_free(ldns_buffer *buffer);
00619 
00626 void *ldns_buffer_export(ldns_buffer *buffer);
00627 
00634 void ldns_buffer_copy(ldns_buffer* result, ldns_buffer* from);
00635 
00636 #endif /* LDNS_BUFFER_H */

Generated on Fri Sep 19 13:35:25 2008 for ldns by  doxygen 1.5.5