Electroneum
sbuffer.h
Go to the documentation of this file.
1 /*
2  * buffer.h -- generic memory buffer.
3  *
4  * Copyright (c) 2005-2008, NLnet Labs. All rights reserved.
5  *
6  * See LICENSE for the license.
7  *
8  *
9  * The buffer module implements a generic buffer. The API is based on
10  * the java.nio.Buffer interface.
11  */
12 
13 #ifndef LDNS_SBUFFER_H
14 #define LDNS_SBUFFER_H
15 
16 #ifdef __cplusplus
17 extern "C" {
18 #endif
19 
20 #ifdef S_SPLINT_S
21 # define INLINE
22 #else
23 # ifdef SWIG
24 # define INLINE static
25 # else
26 # define INLINE static inline
27 # endif
28 #endif
29 
30 /*
31  * Copy data allowing for unaligned accesses in network byte order
32  * (big endian).
33  */
35 sldns_read_uint16(const void *src)
36 {
37 #ifdef ALLOW_UNALIGNED_ACCESSES
38  return ntohs(*(const uint16_t *) src);
39 #else
40  const uint8_t *p = (const uint8_t *) src;
41  return ((uint16_t) p[0] << 8) | (uint16_t) p[1];
42 #endif
43 }
44 
46 sldns_read_uint32(const void *src)
47 {
48 #ifdef ALLOW_UNALIGNED_ACCESSES
49  return ntohl(*(const uint32_t *) src);
50 #else
51  const uint8_t *p = (const uint8_t *) src;
52  return ( ((uint32_t) p[0] << 24)
53  | ((uint32_t) p[1] << 16)
54  | ((uint32_t) p[2] << 8)
55  | (uint32_t) p[3]);
56 #endif
57 }
58 
59 /*
60  * Copy data allowing for unaligned accesses in network byte order
61  * (big endian).
62  */
63 INLINE void
64 sldns_write_uint16(void *dst, uint16_t data)
65 {
66 #ifdef ALLOW_UNALIGNED_ACCESSES
67  * (uint16_t *) dst = htons(data);
68 #else
69  uint8_t *p = (uint8_t *) dst;
70  p[0] = (uint8_t) ((data >> 8) & 0xff);
71  p[1] = (uint8_t) (data & 0xff);
72 #endif
73 }
74 
75 INLINE void
76 sldns_write_uint32(void *dst, uint32_t data)
77 {
78 #ifdef ALLOW_UNALIGNED_ACCESSES
79  * (uint32_t *) dst = htonl(data);
80 #else
81  uint8_t *p = (uint8_t *) dst;
82  p[0] = (uint8_t) ((data >> 24) & 0xff);
83  p[1] = (uint8_t) ((data >> 16) & 0xff);
84  p[2] = (uint8_t) ((data >> 8) & 0xff);
85  p[3] = (uint8_t) (data & 0xff);
86 #endif
87 }
88 
89 
90 INLINE void
91 sldns_write_uint48(void *dst, uint64_t data)
92 {
93  uint8_t *p = (uint8_t *) dst;
94  p[0] = (uint8_t) ((data >> 40) & 0xff);
95  p[1] = (uint8_t) ((data >> 32) & 0xff);
96  p[2] = (uint8_t) ((data >> 24) & 0xff);
97  p[3] = (uint8_t) ((data >> 16) & 0xff);
98  p[4] = (uint8_t) ((data >> 8) & 0xff);
99  p[5] = (uint8_t) (data & 0xff);
100 }
101 
102 
117 {
119  size_t _position;
120 
122  size_t _limit;
123 
125  size_t _capacity;
126 
129 
131  unsigned _fixed : 1;
132 
142  unsigned _vfixed : 1;
143 
147  unsigned _status_err : 1;
148 };
149 typedef struct sldns_buffer sldns_buffer;
150 
151 #ifdef NDEBUG
152 INLINE void
153 sldns_buffer_invariant(sldns_buffer *ATTR_UNUSED(buffer))
154 {
155 }
156 #else
157 INLINE void
159 {
160  assert(buffer != NULL);
161  assert(buffer->_position <= buffer->_limit || buffer->_vfixed);
162  assert(buffer->_limit <= buffer->_capacity);
163  assert(buffer->_data != NULL || (buffer->_vfixed && buffer->_capacity == 0));
164 }
165 #endif
166 
173 sldns_buffer *sldns_buffer_new(size_t capacity);
174 
184 void sldns_buffer_new_frm_data(sldns_buffer *buffer, void *data, size_t size);
185 
193 void sldns_buffer_init_frm_data(sldns_buffer *buffer, void *data, size_t size);
194 
206 void sldns_buffer_init_vfixed_frm_data(sldns_buffer *buffer, void *data, size_t size);
207 
214 {
215  sldns_buffer_invariant(buffer);
216 
217  /* reset status here? */
218 
219  buffer->_position = 0;
220  buffer->_limit = buffer->_capacity;
221 }
222 
232 {
233  sldns_buffer_invariant(buffer);
234 
235  buffer->_limit = buffer->_position;
236  buffer->_position = 0;
237 }
238 
245 {
246  sldns_buffer_invariant(buffer);
247 
248  buffer->_position = 0;
249 }
250 
256 INLINE size_t
258 {
259  return buffer->_position;
260 }
261 
268 INLINE void
270 {
271  assert(mark <= buffer->_limit || buffer->_vfixed);
272  buffer->_position = mark;
273 }
274 
282 INLINE void
284 {
285  assert(buffer->_position + count <= buffer->_limit || buffer->_vfixed);
286  buffer->_position += count;
287 }
288 
294 INLINE size_t
296 {
297  return buffer->_limit;
298 }
299 
306 INLINE void
307 sldns_buffer_set_limit(sldns_buffer *buffer, size_t limit)
308 {
309  assert(limit <= buffer->_capacity);
310  buffer->_limit = limit;
311  if (buffer->_position > buffer->_limit)
312  buffer->_position = buffer->_limit;
313 }
314 
320 INLINE size_t
322 {
323  return buffer->_capacity;
324 }
325 
334 int sldns_buffer_set_capacity(sldns_buffer *buffer, size_t capacity);
335 
346 int sldns_buffer_reserve(sldns_buffer *buffer, size_t amount);
347 
354 INLINE uint8_t *
355 sldns_buffer_at(const sldns_buffer *buffer, size_t at)
356 {
357  assert(at <= buffer->_limit || buffer->_vfixed);
358  return buffer->_data + at;
359 }
360 
367 INLINE uint8_t *
369 {
370  return sldns_buffer_at(buffer, 0);
371 }
372 
379 INLINE uint8_t *
381 {
382  return sldns_buffer_at(buffer, buffer->_limit);
383 }
384 
390 INLINE uint8_t *
392 {
393  return sldns_buffer_at(buffer, buffer->_position);
394 }
395 
403 INLINE size_t
405 {
406  sldns_buffer_invariant(buffer);
407  assert(at <= buffer->_limit || buffer->_vfixed);
408  return at < buffer->_limit ? buffer->_limit - at : 0;
409 }
410 
417 INLINE size_t
419 {
420  return sldns_buffer_remaining_at(buffer, buffer->_position);
421 }
422 
432 INLINE int
433 sldns_buffer_available_at(sldns_buffer *buffer, size_t at, size_t count)
434 {
435  return count <= sldns_buffer_remaining_at(buffer, at);
436 }
437 
444 INLINE int
446 {
447  return sldns_buffer_available_at(buffer, buffer->_position, count);
448 }
449 
457 INLINE void
458 sldns_buffer_write_at(sldns_buffer *buffer, size_t at, const void *data, size_t count)
459 {
460  if (!buffer->_vfixed)
461  assert(sldns_buffer_available_at(buffer, at, count));
462  else if (sldns_buffer_remaining_at(buffer, at) == 0)
463  return;
464  else if (count > sldns_buffer_remaining_at(buffer, at)) {
465  memcpy(buffer->_data + at, data,
466  sldns_buffer_remaining_at(buffer, at));
467  return;
468  }
469  memcpy(buffer->_data + at, data, count);
470 }
471 
480 INLINE void
481 sldns_buffer_set_at(sldns_buffer *buffer, size_t at, int c, size_t count)
482 {
483  if (!buffer->_vfixed)
484  assert(sldns_buffer_available_at(buffer, at, count));
485  else if (sldns_buffer_remaining_at(buffer, at) == 0)
486  return;
487  else if (count > sldns_buffer_remaining_at(buffer, at)) {
488  memset(buffer->_data + at, c,
489  sldns_buffer_remaining_at(buffer, at));
490  return;
491  }
492  memset(buffer->_data + at, c, count);
493 }
494 
495 
502 INLINE void
503 sldns_buffer_write(sldns_buffer *buffer, const void *data, size_t count)
504 {
505  sldns_buffer_write_at(buffer, buffer->_position, data, count);
506  buffer->_position += count;
507 }
508 
515 INLINE void
516 sldns_buffer_write_string_at(sldns_buffer *buffer, size_t at, const char *str)
517 {
518  sldns_buffer_write_at(buffer, at, str, strlen(str));
519 }
520 
526 INLINE void
527 sldns_buffer_write_string(sldns_buffer *buffer, const char *str)
528 {
529  sldns_buffer_write(buffer, str, strlen(str));
530 }
531 
538 INLINE void
540 {
541  if (buffer->_vfixed && at + sizeof(data) > buffer->_limit) return;
542  assert(sldns_buffer_available_at(buffer, at, sizeof(data)));
543  buffer->_data[at] = data;
544 }
545 
551 INLINE void
553 {
554  sldns_buffer_write_u8_at(buffer, buffer->_position, data);
555  buffer->_position += sizeof(data);
556 }
557 
564 INLINE void
566 {
567  if (buffer->_vfixed && at + sizeof(data) > buffer->_limit) return;
568  assert(sldns_buffer_available_at(buffer, at, sizeof(data)));
569  sldns_write_uint16(buffer->_data + at, data);
570 }
571 
577 INLINE void
579 {
580  sldns_buffer_write_u16_at(buffer, buffer->_position, data);
581  buffer->_position += sizeof(data);
582 }
583 
590 INLINE void
592 {
593  if (buffer->_vfixed && at + sizeof(data) > buffer->_limit) return;
594  assert(sldns_buffer_available_at(buffer, at, sizeof(data)));
595  sldns_write_uint32(buffer->_data + at, data);
596 }
597 
604 INLINE void
606 {
607  if (buffer->_vfixed && at + 6 > buffer->_limit) return;
608  assert(sldns_buffer_available_at(buffer, at, 6));
609  sldns_write_uint48(buffer->_data + at, data);
610 }
611 
617 INLINE void
619 {
620  sldns_buffer_write_u32_at(buffer, buffer->_position, data);
621  buffer->_position += sizeof(data);
622 }
623 
629 INLINE void
631 {
632  sldns_buffer_write_u48_at(buffer, buffer->_position, data);
633  buffer->_position += 6;
634 }
635 
643 INLINE void
644 sldns_buffer_read_at(sldns_buffer *buffer, size_t at, void *data, size_t count)
645 {
646  assert(sldns_buffer_available_at(buffer, at, count));
647  memcpy(data, buffer->_data + at, count);
648 }
649 
656 INLINE void
657 sldns_buffer_read(sldns_buffer *buffer, void *data, size_t count)
658 {
659  sldns_buffer_read_at(buffer, buffer->_position, data, count);
660  buffer->_position += count;
661 }
662 
671 {
672  assert(sldns_buffer_available_at(buffer, at, sizeof(uint8_t)));
673  return buffer->_data[at];
674 }
675 
683 {
684  uint8_t result = sldns_buffer_read_u8_at(buffer, buffer->_position);
685  buffer->_position += sizeof(uint8_t);
686  return result;
687 }
688 
697 {
698  assert(sldns_buffer_available_at(buffer, at, sizeof(uint16_t)));
699  return sldns_read_uint16(buffer->_data + at);
700 }
701 
709 {
710  uint16_t result = sldns_buffer_read_u16_at(buffer, buffer->_position);
711  buffer->_position += sizeof(uint16_t);
712  return result;
713 }
714 
723 {
724  assert(sldns_buffer_available_at(buffer, at, sizeof(uint32_t)));
725  return sldns_read_uint32(buffer->_data + at);
726 }
727 
735 {
736  uint32_t result = sldns_buffer_read_u32_at(buffer, buffer->_position);
737  buffer->_position += sizeof(uint32_t);
738  return result;
739 }
740 
746 INLINE int
748 {
749  return (int)buffer->_status_err;
750 }
751 
757 INLINE int
759 {
760  if (buffer) {
761  return sldns_buffer_status(buffer) == 0;
762  } else {
763  return 0;
764  }
765 }
766 
773 int sldns_buffer_printf(sldns_buffer *buffer, const char *format, ...)
774  ATTR_FORMAT(printf, 2, 3);
775 
781 void sldns_buffer_free(sldns_buffer *buffer);
782 
789 void *sldns_buffer_export(sldns_buffer *buffer);
790 
798 void sldns_buffer_copy(sldns_buffer* result, sldns_buffer* from);
799 
800 #ifdef __cplusplus
801 }
802 #endif
803 
804 #endif /* LDNS_SBUFFER_H */
INLINE int sldns_buffer_available(sldns_buffer *buffer, size_t count)
Definition: sbuffer.h:445
INLINE uint32_t sldns_buffer_read_u32_at(sldns_buffer *buffer, size_t at)
Definition: sbuffer.h:722
void sldns_buffer_copy(sldns_buffer *result, sldns_buffer *from)
INLINE size_t sldns_buffer_remaining(sldns_buffer *buffer)
Definition: sbuffer.h:418
size_t _position
Definition: sbuffer.h:119
INLINE void sldns_buffer_set_limit(sldns_buffer *buffer, size_t limit)
Definition: sbuffer.h:307
size_t _limit
Definition: sbuffer.h:122
INLINE void sldns_buffer_write_u16_at(sldns_buffer *buffer, size_t at, uint16_t data)
Definition: sbuffer.h:565
INLINE void sldns_write_uint16(void *dst, uint16_t data)
Definition: sbuffer.h:64
INLINE void sldns_buffer_invariant(sldns_buffer *buffer)
Definition: sbuffer.h:158
INLINE void sldns_buffer_clear(sldns_buffer *buffer)
Definition: sbuffer.h:213
INLINE size_t sldns_buffer_remaining_at(sldns_buffer *buffer, size_t at)
Definition: sbuffer.h:404
INLINE void sldns_buffer_rewind(sldns_buffer *buffer)
Definition: sbuffer.h:244
INLINE uint32_t sldns_read_uint32(const void *src)
Definition: sbuffer.h:46
void * sldns_buffer_export(sldns_buffer *buffer)
INLINE void sldns_buffer_read(sldns_buffer *buffer, void *data, size_t count)
Definition: sbuffer.h:657
INLINE void sldns_buffer_write(sldns_buffer *buffer, const void *data, size_t count)
Definition: sbuffer.h:503
INLINE uint32_t sldns_buffer_read_u32(sldns_buffer *buffer)
Definition: sbuffer.h:734
INLINE void sldns_buffer_write_u32(sldns_buffer *buffer, uint32_t data)
Definition: sbuffer.h:618
INLINE uint8_t sldns_buffer_read_u8_at(sldns_buffer *buffer, size_t at)
Definition: sbuffer.h:670
INLINE void sldns_write_uint32(void *dst, uint32_t data)
Definition: sbuffer.h:76
INLINE void sldns_buffer_read_at(sldns_buffer *buffer, size_t at, void *data, size_t count)
Definition: sbuffer.h:644
#define INLINE
Definition: sbuffer.h:26
unsigned short uint16_t
Definition: stdint.h:125
INLINE void sldns_write_uint48(void *dst, uint64_t data)
Definition: sbuffer.h:91
void sldns_buffer_init_frm_data(sldns_buffer *buffer, void *data, size_t size)
INLINE uint16_t sldns_buffer_read_u16_at(sldns_buffer *buffer, size_t at)
Definition: sbuffer.h:696
INLINE uint16_t sldns_buffer_read_u16(sldns_buffer *buffer)
Definition: sbuffer.h:708
INLINE void sldns_buffer_write_u8_at(sldns_buffer *buffer, size_t at, uint8_t data)
Definition: sbuffer.h:539
INLINE size_t sldns_buffer_capacity(sldns_buffer *buffer)
Definition: sbuffer.h:321
INLINE void sldns_buffer_write_string(sldns_buffer *buffer, const char *str)
Definition: sbuffer.h:527
unsigned char uint8_t
Definition: stdint.h:124
INLINE uint8_t * sldns_buffer_begin(const sldns_buffer *buffer)
Definition: sbuffer.h:368
unsigned _fixed
Definition: sbuffer.h:131
INLINE int sldns_buffer_status_ok(sldns_buffer *buffer)
Definition: sbuffer.h:758
int sldns_buffer_printf(sldns_buffer *buffer, const char *format,...) ATTR_FORMAT(printf
INLINE uint16_t sldns_read_uint16(const void *src)
Definition: sbuffer.h:35
INLINE void sldns_buffer_write_u48(sldns_buffer *buffer, uint64_t data)
Definition: sbuffer.h:630
INLINE uint8_t sldns_buffer_read_u8(sldns_buffer *buffer)
Definition: sbuffer.h:682
mdb_size_t count(MDB_cursor *cur)
INLINE void sldns_buffer_write_u16(sldns_buffer *buffer, uint16_t data)
Definition: sbuffer.h:578
sldns_buffer * sldns_buffer_new(size_t capacity)
unsigned int uint32_t
Definition: stdint.h:126
void sldns_buffer_new_frm_data(sldns_buffer *buffer, void *data, size_t size)
INLINE void sldns_buffer_write_u48_at(sldns_buffer *buffer, size_t at, uint64_t data)
Definition: sbuffer.h:605
uint8_t * _data
Definition: sbuffer.h:128
INLINE void sldns_buffer_write_at(sldns_buffer *buffer, size_t at, const void *data, size_t count)
Definition: sbuffer.h:458
INLINE void sldns_buffer_write_u32_at(sldns_buffer *buffer, size_t at, uint32_t data)
Definition: sbuffer.h:591
INLINE void sldns_buffer_write_string_at(sldns_buffer *buffer, size_t at, const char *str)
Definition: sbuffer.h:516
INLINE void sldns_buffer_set_at(sldns_buffer *buffer, size_t at, int c, size_t count)
Definition: sbuffer.h:481
unsigned __int64 uint64_t
Definition: stdint.h:136
int sldns_buffer_set_capacity(sldns_buffer *buffer, size_t capacity)
unsigned _vfixed
Definition: sbuffer.h:142
INLINE uint8_t * sldns_buffer_end(sldns_buffer *buffer)
Definition: sbuffer.h:380
INLINE size_t sldns_buffer_limit(sldns_buffer *buffer)
Definition: sbuffer.h:295
int void sldns_buffer_free(sldns_buffer *buffer)
INLINE void sldns_buffer_skip(sldns_buffer *buffer, ssize_t count)
Definition: sbuffer.h:283
int sldns_buffer_reserve(sldns_buffer *buffer, size_t amount)
INLINE int sldns_buffer_status(sldns_buffer *buffer)
Definition: sbuffer.h:747
size_t _capacity
Definition: sbuffer.h:125
void * memcpy(void *a, const void *b, size_t c)
INLINE void sldns_buffer_flip(sldns_buffer *buffer)
Definition: sbuffer.h:231
INLINE int sldns_buffer_available_at(sldns_buffer *buffer, size_t at, size_t count)
Definition: sbuffer.h:433
unsigned _status_err
Definition: sbuffer.h:147
void sldns_buffer_init_vfixed_frm_data(sldns_buffer *buffer, void *data, size_t size)
INLINE size_t sldns_buffer_position(sldns_buffer *buffer)
Definition: sbuffer.h:257
INLINE uint8_t * sldns_buffer_current(sldns_buffer *buffer)
Definition: sbuffer.h:391
INLINE void sldns_buffer_set_position(sldns_buffer *buffer, size_t mark)
Definition: sbuffer.h:269
INLINE void sldns_buffer_write_u8(sldns_buffer *buffer, uint8_t data)
Definition: sbuffer.h:552
INLINE uint8_t * sldns_buffer_at(const sldns_buffer *buffer, size_t at)
Definition: sbuffer.h:355