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 *buffer)
00074 {
00075         (void)buffer;
00076 }
00077 #else
00078 INLINE void
00079 ldns_buffer_invariant(ldns_buffer *buffer)
00080 {
00081         assert(buffer != NULL);
00082         assert(buffer->_position <= buffer->_limit);
00083         assert(buffer->_limit <= buffer->_capacity);
00084         assert(buffer->_data != NULL);
00085 }
00086 #endif
00087 
00094 ldns_buffer *ldns_buffer_new(size_t capacity);
00095 
00105 void ldns_buffer_new_frm_data(ldns_buffer *buffer, void *data, size_t size);
00106 
00112 void ldns_buffer_clear(ldns_buffer *buffer);
00113 
00122 void ldns_buffer_flip(ldns_buffer *buffer);
00123 
00129 void ldns_buffer_rewind(ldns_buffer *buffer);
00130 
00136 INLINE size_t
00137 ldns_buffer_position(ldns_buffer *buffer)
00138 {
00139         return buffer->_position;
00140 }
00141 
00148 INLINE void
00149 ldns_buffer_set_position(ldns_buffer *buffer, size_t mark)
00150 {
00151         assert(mark <= buffer->_limit);
00152         buffer->_position = mark;
00153 }
00154 
00162 INLINE void
00163 ldns_buffer_skip(ldns_buffer *buffer, ssize_t count)
00164 {
00165         assert(buffer->_position + count <= buffer->_limit);
00166         buffer->_position += count;
00167 }
00168 
00174 INLINE size_t
00175 ldns_buffer_limit(ldns_buffer *buffer)
00176 {
00177         return buffer->_limit;
00178 }
00179 
00186 INLINE void
00187 ldns_buffer_set_limit(ldns_buffer *buffer, size_t limit)
00188 {
00189         assert(limit <= buffer->_capacity);
00190         buffer->_limit = limit;
00191         if (buffer->_position > buffer->_limit)
00192                 buffer->_position = buffer->_limit;
00193 }
00194 
00200 INLINE size_t
00201 ldns_buffer_capacity(ldns_buffer *buffer)
00202 {
00203         return buffer->_capacity;
00204 }
00205 
00214 bool ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity);
00215 
00226 bool ldns_buffer_reserve(ldns_buffer *buffer, size_t amount);
00227 
00234 INLINE uint8_t *
00235 ldns_buffer_at(ldns_buffer *buffer, size_t at)
00236 {
00237         assert(at <= buffer->_limit);
00238         return buffer->_data + at;
00239 }
00240 
00247 INLINE uint8_t *
00248 ldns_buffer_begin(ldns_buffer *buffer)
00249 {
00250         return ldns_buffer_at(buffer, 0);
00251 }
00252 
00259 INLINE uint8_t *
00260 ldns_buffer_end(ldns_buffer *buffer)
00261 {
00262         return ldns_buffer_at(buffer, buffer->_limit);
00263 }
00264 
00270 INLINE uint8_t *
00271 ldns_buffer_current(ldns_buffer *buffer)
00272 {
00273         return ldns_buffer_at(buffer, buffer->_position);
00274 }
00275 
00283 INLINE size_t
00284 ldns_buffer_remaining_at(ldns_buffer *buffer, size_t at)
00285 {
00286         ldns_buffer_invariant(buffer);
00287         assert(at <= buffer->_limit);
00288         return buffer->_limit - at;
00289 }
00290 
00297 INLINE size_t
00298 ldns_buffer_remaining(ldns_buffer *buffer)
00299 {
00300         return ldns_buffer_remaining_at(buffer, buffer->_position);
00301 }
00302 
00312 INLINE int
00313 ldns_buffer_available_at(ldns_buffer *buffer, size_t at, size_t count)
00314 {
00315         return count <= ldns_buffer_remaining_at(buffer, at);
00316 }
00317 
00324 INLINE int
00325 ldns_buffer_available(ldns_buffer *buffer, size_t count)
00326 {
00327         return ldns_buffer_available_at(buffer, buffer->_position, count);
00328 }
00329 
00337 INLINE void
00338 ldns_buffer_write_at(ldns_buffer *buffer, size_t at, const void *data, size_t count)
00339 {
00340         assert(ldns_buffer_available_at(buffer, at, count));
00341         memcpy(buffer->_data + at, data, count);
00342 }
00343 
00350 INLINE void
00351 ldns_buffer_write(ldns_buffer *buffer, const void *data, size_t count)
00352 {
00353         ldns_buffer_write_at(buffer, buffer->_position, data, count);
00354         buffer->_position += count;
00355 }
00356 
00363 INLINE void
00364 ldns_buffer_write_string_at(ldns_buffer *buffer, size_t at, const char *str)
00365 {
00366         ldns_buffer_write_at(buffer, at, str, strlen(str));
00367 }
00368 
00374 INLINE void
00375 ldns_buffer_write_string(ldns_buffer *buffer, const char *str)
00376 {
00377         ldns_buffer_write(buffer, str, strlen(str));
00378 }
00379 
00386 INLINE void
00387 ldns_buffer_write_u8_at(ldns_buffer *buffer, size_t at, uint8_t data)
00388 {
00389         assert(ldns_buffer_available_at(buffer, at, sizeof(data)));
00390         buffer->_data[at] = data;
00391 }
00392 
00398 INLINE void
00399 ldns_buffer_write_u8(ldns_buffer *buffer, uint8_t data)
00400 {
00401         ldns_buffer_write_u8_at(buffer, buffer->_position, data);
00402         buffer->_position += sizeof(data);
00403 }
00404 
00411 INLINE void
00412 ldns_buffer_write_u16_at(ldns_buffer *buffer, size_t at, uint16_t data)
00413 {
00414         assert(ldns_buffer_available_at(buffer, at, sizeof(data)));
00415         ldns_write_uint16(buffer->_data + at, data);
00416 }
00417 
00423 INLINE void
00424 ldns_buffer_write_u16(ldns_buffer *buffer, uint16_t data)
00425 {
00426         ldns_buffer_write_u16_at(buffer, buffer->_position, data);
00427         buffer->_position += sizeof(data);
00428 }
00429 
00436 INLINE void
00437 ldns_buffer_write_u32_at(ldns_buffer *buffer, size_t at, uint32_t data)
00438 {
00439         assert(ldns_buffer_available_at(buffer, at, sizeof(data)));
00440         ldns_write_uint32(buffer->_data + at, data);
00441 }
00442 
00448 INLINE void
00449 ldns_buffer_write_u32(ldns_buffer *buffer, uint32_t data)
00450 {
00451         ldns_buffer_write_u32_at(buffer, buffer->_position, data);
00452         buffer->_position += sizeof(data);
00453 }
00454 
00462 INLINE void
00463 ldns_buffer_read_at(ldns_buffer *buffer, size_t at, void *data, size_t count)
00464 {
00465         assert(ldns_buffer_available_at(buffer, at, count));
00466         memcpy(data, buffer->_data + at, count);
00467 }
00468 
00475 INLINE void
00476 ldns_buffer_read(ldns_buffer *buffer, void *data, size_t count)
00477 {
00478         ldns_buffer_read_at(buffer, buffer->_position, data, count);
00479         buffer->_position += count;
00480 }
00481 
00488 INLINE uint8_t
00489 ldns_buffer_read_u8_at(ldns_buffer *buffer, size_t at)
00490 {
00491         assert(ldns_buffer_available_at(buffer, at, sizeof(uint8_t)));
00492         return buffer->_data[at];
00493 }
00494 
00500 INLINE uint8_t
00501 ldns_buffer_read_u8(ldns_buffer *buffer)
00502 {
00503         uint8_t result = ldns_buffer_read_u8_at(buffer, buffer->_position);
00504         buffer->_position += sizeof(uint8_t);
00505         return result;
00506 }
00507 
00514 INLINE uint16_t
00515 ldns_buffer_read_u16_at(ldns_buffer *buffer, size_t at)
00516 {
00517         assert(ldns_buffer_available_at(buffer, at, sizeof(uint16_t)));
00518         return ldns_read_uint16(buffer->_data + at);
00519 }
00520 
00526 INLINE uint16_t
00527 ldns_buffer_read_u16(ldns_buffer *buffer)
00528 {
00529         uint16_t result = ldns_buffer_read_u16_at(buffer, buffer->_position);
00530         buffer->_position += sizeof(uint16_t);
00531         return result;
00532 }
00533 
00540 INLINE uint32_t
00541 ldns_buffer_read_u32_at(ldns_buffer *buffer, size_t at)
00542 {
00543         assert(ldns_buffer_available_at(buffer, at, sizeof(uint32_t)));
00544         return ldns_read_uint32(buffer->_data + at);
00545 }
00546 
00552 INLINE uint32_t
00553 ldns_buffer_read_u32(ldns_buffer *buffer)
00554 {
00555         uint32_t result = ldns_buffer_read_u32_at(buffer, buffer->_position);
00556         buffer->_position += sizeof(uint32_t);
00557         return result;
00558 }
00559 
00565 INLINE ldns_status
00566 ldns_buffer_status(ldns_buffer *buffer)
00567 {
00568         return buffer->_status;
00569 }
00570 
00576 INLINE bool
00577 ldns_buffer_status_ok(ldns_buffer *buffer)
00578 {
00579         if (buffer) {
00580                 return ldns_buffer_status(buffer) == LDNS_STATUS_OK;
00581         } else {
00582                 return false;
00583         }
00584 }
00585 
00592 int ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...);
00593 /*      ATTR_FORMAT(printf, 2, 3);*/
00594 
00600 void ldns_buffer_free(ldns_buffer *buffer);
00601 
00608 void *ldns_buffer_export(ldns_buffer *buffer);
00609 
00610 #endif /* LDNS_BUFFER_H */

Generated on Sat Sep 27 00:16:44 2008 for ldns by  doxygen 1.5.6