OpenDNSSEC-signer 2.1.10
buffer.c
Go to the documentation of this file.
1/*
2 * Copyright (c) 2011 NLNet Labs. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
17 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
19 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
21 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
22 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
23 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *
25 */
26
49#include "config.h"
50#include "log.h"
51#include "wire/buffer.h"
52
53#include <string.h>
54
55static const char* buffer_str = "buffer";
56
57ods_lookup_table ods_rcode_str[] = {
58 { LDNS_RCODE_NOERROR, "NOERROR" },
59 { LDNS_RCODE_FORMERR, "FORMERR" },
60 { LDNS_RCODE_SERVFAIL, "SERVFAIL" },
61 { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" },
62 { LDNS_RCODE_NOTIMPL, "NOTIMPL" },
63 { LDNS_RCODE_REFUSED, "REFUSED" },
64 { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" },
65 { LDNS_RCODE_YXRRSET, "YXRRSET" },
66 { LDNS_RCODE_NXRRSET, "NXRRSET" },
67 { LDNS_RCODE_NOTAUTH, "NOTAUTH" },
68 { LDNS_RCODE_NOTZONE, "NOTZONE" },
69 { 0, NULL }
70};
71
72
78buffer_create(size_t capacity)
79{
80 buffer_type* buffer = NULL;
81 if (!capacity) {
82 return NULL;
83 }
84 CHECKALLOC(buffer = (buffer_type *) malloc(sizeof(buffer_type)));
85 buffer->data = (uint8_t*) calloc(capacity, sizeof(uint8_t));
86 buffer->position = 0;
87 buffer->limit = capacity;
88 buffer->capacity = capacity;
89 buffer->fixed = 0;
90 return buffer;
91}
92
93
98void
100{
101 ods_log_assert(buffer);
102 buffer->position = 0;
103 buffer->limit = buffer->capacity;
104}
105
106
111void
113{
114 ods_log_assert(buffer);
115 buffer->limit = buffer->position;
116 buffer->position = 0;
117}
118
119
124size_t
126{
127 ods_log_assert(buffer);
128 return buffer->position;
129}
130
131
136void
138{
139 ods_log_assert(buffer);
140 ods_log_assert(pos <= buffer->limit);
141 buffer->position = pos;
142}
143
144
149void
150buffer_skip(buffer_type* buffer, ssize_t count)
151{
152 ods_log_assert(buffer);
153 ods_log_assert(buffer->position + count <= buffer->limit);
154 buffer->position += count;
155}
156
157
162static int
163get_bit(uint8_t bits[], size_t index)
164{
165 return bits[index / 8] & (1 << (7 - index % 8));
166}
167
168
173static void
174set_bit(uint8_t bits[], size_t index)
175{
176 bits[index / 8] |= (1 << (7 - index % 8));
177}
178
179
184static int
185label_is_pointer(const uint8_t* label)
186{
187 ods_log_assert(label);
188 return (label[0] & 0xc0) == 0xc0;
189}
190
191
196static uint16_t
197label_pointer_location(const uint8_t* label)
198{
199 ods_log_assert(label);
200 ods_log_assert(label_is_pointer(label));
201 return ((uint16_t) (label[0] & ~0xc0) << 8) | (uint16_t) label[1];
202}
203
204
209static int
210label_is_normal(const uint8_t* label)
211{
212 ods_log_assert(label);
213 return (label[0] & 0xc0) == 0;
214}
215
216/*
217 * Is root label?
218 *
219 */
220static inline int
221label_is_root(const uint8_t* label)
222{
223 ods_log_assert(label);
224 return label[0] == 0;
225}
226
227
228/*
229 * Label length.
230 *
231 */
232static uint8_t
233label_length(const uint8_t* label)
234{
235 ods_log_assert(label);
236 ods_log_assert(label_is_normal(label));
237 return label[0];
238}
239
240
245size_t
246buffer_read_dname(buffer_type* buffer, uint8_t* dname, unsigned allow_pointers)
247{
248 int done = 0;
249 uint8_t visited[(MAX_PACKET_SIZE+7)/8];
250 size_t dname_length = 0;
251 const uint8_t *label = NULL;
252 ssize_t mark = -1;
253 ods_log_assert(buffer);
254 memset(visited, 0, (buffer_limit(buffer)+7)/8);
255
256 while (!done) {
257 if (!buffer_available(buffer, 1)) {
258 return 0;
259 }
260 if (get_bit(visited, buffer_position(buffer))) {
261 ods_log_error("[%s] dname loop!", buffer_str);
262 return 0;
263 }
264 set_bit(visited, buffer_position(buffer));
265 label = buffer_current(buffer);
266 if (label_is_pointer(label)) {
267 size_t pointer = 0;
268 if (!allow_pointers) {
269 return 0;
270 }
271 if (!buffer_available(buffer, 2)) {
272 return 0;
273 }
274 pointer = label_pointer_location(label);
275 if (pointer >= buffer_limit(buffer)) {
276 return 0;
277 }
278 buffer_skip(buffer, 2);
279 if (mark == -1) {
280 mark = buffer_position(buffer);
281 }
282 buffer_set_position(buffer, pointer);
283 } else if (label_is_normal(label)) {
284 size_t length = label_length(label) + 1;
285 done = label_is_root(label);
286 if (!buffer_available(buffer, length)) {
287 return 0;
288 }
289 if (dname_length + length >= MAXDOMAINLEN+1) {
290 return 0;
291 }
292 buffer_read(buffer, dname + dname_length, length);
293 dname_length += length;
294 } else {
295 return 0;
296 }
297 }
298 if (mark != -1) {
299 buffer_set_position(buffer, mark);
300 }
301 return dname_length;
302}
303
304
309int
311{
312 ods_log_assert(buffer);
313 while (1) {
314 uint8_t label_size = 0;
315 if (!buffer_available(buffer, 1)) {
316 return 0;
317 }
318 label_size = buffer_read_u8(buffer);
319 if (label_size == 0) {
320 break;
321 } else if ((label_size & 0xc0) != 0) {
322 if (!buffer_available(buffer, 1)) {
323 return 0;
324 }
325 buffer_skip(buffer, 1);
326 break;
327 } else if (!buffer_available(buffer, label_size)) {
328 return 0;
329 } else {
330 buffer_skip(buffer, label_size);
331 }
332 }
333 return 1;
334}
335
336
341int
342buffer_skip_rr(buffer_type* buffer, unsigned qrr)
343{
344 if (!buffer_skip_dname(buffer)) {
345 return 0;
346 }
347 if (qrr) {
348 if (!buffer_available(buffer, 4)) {
349 return 0;
350 }
351 buffer_skip(buffer, 4);
352 } else {
353 uint16_t rdata_size;
354 if (!buffer_available(buffer, 10)) {
355 return 0;
356 }
357 buffer_skip(buffer, 8);
358 rdata_size = buffer_read_u16(buffer);
359 if (!buffer_available(buffer, rdata_size)) {
360 return 0;
361 }
362 buffer_skip(buffer, rdata_size);
363 }
364 return 1;
365}
366
367
372size_t
374{
375 ods_log_assert(buffer);
376 return buffer->limit;
377}
378
379
384void
385buffer_set_limit(buffer_type* buffer, size_t limit)
386{
387 ods_log_assert(buffer);
388 ods_log_assert(limit <= buffer->capacity);
389 buffer->limit = limit;
390 if (buffer->position > buffer->limit) {
391 buffer->position = buffer->limit;
392 }
393}
394
395
400size_t
402{
403 ods_log_assert(buffer);
404 return buffer->capacity;
405}
406
407
412uint8_t*
413buffer_at(buffer_type* buffer, size_t at)
414{
415 ods_log_assert(buffer);
416 ods_log_assert(at <= buffer->limit);
417 return buffer->data + at;
418}
419
420
425uint8_t*
427{
428 ods_log_assert(buffer);
429 return buffer_at(buffer, 0);
430}
431
432
437uint8_t*
439{
440 ods_log_assert(buffer);
441 return buffer_at(buffer, buffer->position);
442}
443
444
449static size_t
450buffer_remaining_at(buffer_type* buffer, size_t at)
451{
452 ods_log_assert(buffer);
453 ods_log_assert(at <= buffer->limit);
454 return buffer->limit - at;
455}
456
457
462size_t
464{
465 ods_log_assert(buffer);
466 return buffer_remaining_at(buffer, buffer->position);
467}
468
469
474static int
475buffer_available_at(buffer_type *buffer, size_t at, size_t count)
476{
477 ods_log_assert(buffer);
478 return count <= buffer_remaining_at(buffer, at);
479}
480
481
486int
487buffer_available(buffer_type *buffer, size_t count)
488{
489 ods_log_assert(buffer);
490 return buffer_available_at(buffer, buffer->position, count);
491}
492
493
498static void
499buffer_write_u8_at(buffer_type* buffer, size_t at, uint8_t data)
500{
501 ods_log_assert(buffer);
502 ods_log_assert(buffer_available_at(buffer, at, sizeof(data)));
503 buffer->data[at] = data;
504}
505
506
511void
512buffer_write_u16_at(buffer_type* buffer, size_t at, uint16_t data)
513{
514 ods_log_assert(buffer);
515 ods_log_assert(buffer_available_at(buffer, at, sizeof(data)));
516 write_uint16(buffer->data + at, data);
517}
518
519
524static void
525buffer_write_u32_at(buffer_type* buffer, size_t at, uint32_t data)
526{
527 ods_log_assert(buffer);
528 ods_log_assert(buffer_available_at(buffer, at, sizeof(data)));
529 write_uint32(buffer->data + at, data);
530}
531
532
537void
538buffer_write(buffer_type* buffer, const void* data, size_t count)
539{
540 ods_log_assert(buffer);
541 ods_log_assert(buffer_available(buffer, count));
542 memcpy(buffer->data + buffer->position, data, count);
543 buffer->position += count;
544}
545
546
551void
552buffer_write_u8(buffer_type* buffer, uint8_t data)
553{
554 ods_log_assert(buffer);
555 buffer_write_u8_at(buffer, buffer->position, data);
556 buffer->position += sizeof(data);
557}
558
559
564void
565buffer_write_u16(buffer_type* buffer, uint16_t data)
566{
567 ods_log_assert(buffer);
568 buffer_write_u16_at(buffer, buffer->position, data);
569 buffer->position += sizeof(data);
570}
571
572
577void
578buffer_write_u32(buffer_type* buffer, uint32_t data)
579{
580 ods_log_assert(buffer);
581 buffer_write_u32_at(buffer, buffer->position, data);
582 buffer->position += sizeof(data);
583}
584
585
590void
591buffer_write_rdf(buffer_type* buffer, ldns_rdf* rdf)
592{
593 ods_log_assert(buffer);
594 ods_log_assert(rdf);
595 buffer_write(buffer, ldns_rdf_data(rdf), ldns_rdf_size(rdf));
596 /* position updated by buffer_write() */
597}
598
599
604int
605buffer_write_rr(buffer_type* buffer, ldns_rr* rr)
606{
607 size_t i = 0;
608 size_t tc_mark = 0;
609 size_t rdlength_pos = 0;
610 uint16_t rdlength = 0;
611 ods_log_assert(buffer);
612 ods_log_assert(rr);
613 /* set truncation mark, in case rr does not fit */
614 tc_mark = buffer_position(buffer);
615 /* owner type class ttl */
616 if (!buffer_available(buffer, ldns_rdf_size(ldns_rr_owner(rr)))) {
617 goto buffer_tc;
618 }
619 buffer_write_rdf(buffer, ldns_rr_owner(rr));
620 if (!buffer_available(buffer, sizeof(uint16_t) + sizeof(uint16_t) +
621 sizeof(uint32_t) + sizeof(rdlength))) {
622 goto buffer_tc;
623 }
624 buffer_write_u16(buffer, (uint16_t) ldns_rr_get_type(rr));
625 buffer_write_u16(buffer, (uint16_t) ldns_rr_get_class(rr));
626 buffer_write_u32(buffer, (uint32_t) ldns_rr_ttl(rr));
627 /* skip rdlength */
628 rdlength_pos = buffer_position(buffer);
629 buffer_skip(buffer, sizeof(rdlength));
630 /* write rdata */
631 for (i=0; i < ldns_rr_rd_count(rr); i++) {
632 if (!buffer_available(buffer, ldns_rdf_size(ldns_rr_rdf(rr, i)))) {
633 goto buffer_tc;
634 }
635 buffer_write_rdf(buffer, ldns_rr_rdf(rr, i));
636 }
637 /* write rdlength */
638 rdlength = buffer_position(buffer) - rdlength_pos - sizeof(rdlength);
639 buffer_write_u16_at(buffer, rdlength_pos, rdlength);
640 /* position updated by buffer_write() */
641 return 1;
642
643buffer_tc:
644 buffer_set_position(buffer, tc_mark);
645 return 0;
646}
647
648
653static uint8_t
654buffer_read_u8_at(buffer_type* buffer, size_t at)
655{
656 ods_log_assert(buffer);
657 ods_log_assert(at < buffer->capacity);
658 return buffer->data[at];
659
660}
661
662
667static uint16_t
668buffer_read_u16_at(buffer_type* buffer, size_t at)
669{
670 ods_log_assert(buffer);
671 return read_uint16(buffer->data + at);
672}
673
674
679static uint32_t
680buffer_read_u32_at(buffer_type* buffer, size_t at)
681{
682 ods_log_assert(buffer);
683 return read_uint32(buffer->data + at);
684}
685
686
691void
692buffer_read(buffer_type* buffer, void* data, size_t count)
693{
694 ods_log_assert(buffer);
695 ods_log_assert(buffer_available(buffer, count));
696 memcpy(data, buffer->data + buffer->position, count);
697 buffer->position += count;
698}
699
700
705uint8_t
707{
708 uint16_t result = 0;
709 ods_log_assert(buffer);
710 result = buffer_read_u8_at(buffer, buffer->position);
711 buffer->position += sizeof(uint8_t);
712 return result;
713}
714
715
720uint16_t
722{
723 uint16_t result = 0;
724 ods_log_assert(buffer);
725 result = buffer_read_u16_at(buffer, buffer->position);
726 buffer->position += sizeof(uint16_t);
727 return result;
728}
729
730
735uint32_t
737{
738 uint32_t result = 0;
739 ods_log_assert(buffer);
740 result = buffer_read_u32_at(buffer, buffer->position);
741 buffer->position += sizeof(uint32_t);
742 return result;
743}
744
745
750uint16_t
752{
753 ods_log_assert(buffer);
754 return buffer_read_u16_at(buffer, 0);
755}
756
761static uint16_t
762random_id(void)
763{
764 return ldns_get_random();
765}
766
771void
773{
774 uint16_t qid = 0;
775 ods_log_assert(buffer);
776 qid = random_id();
777 buffer_write_u16_at(buffer, 0, qid);
778}
779
780
785uint16_t
787{
788 ods_log_assert(buffer);
789 return (uint16_t) buffer_read_u16_at(buffer, 2);
790}
791
792
797void
798buffer_pkt_set_flags(buffer_type* buffer, uint16_t flags)
799{
800 ods_log_assert(buffer);
801 buffer_write_u16_at(buffer, 2, flags);
802}
803
804
809int
811{
812 ods_log_assert(buffer);
813 return (int) QR(buffer);
814}
815
816
821void
823{
824 ods_log_assert(buffer);
825 QR_SET(buffer);
826}
827
828
833void
835{
836 ods_log_assert(buffer);
837 QR_CLR(buffer);
838}
839
840
845ldns_pkt_opcode
847{
848 ods_log_assert(buffer);
849 return (ldns_pkt_opcode) OPCODE(buffer);
850}
851
852
857void
858buffer_pkt_set_opcode(buffer_type* buffer, ldns_pkt_opcode opcode)
859{
860 ods_log_assert(buffer);
861 OPCODE_SET(buffer, opcode);
862}
863
864
869int
871{
872 ods_log_assert(buffer);
873 return (int) AA(buffer);
874}
875
876
881void
883{
884 ods_log_assert(buffer);
885 AA_SET(buffer);
886}
887
888
893int
895{
896 ods_log_assert(buffer);
897 return (int) TC(buffer);
898}
899
900
905int
907{
908 ods_log_assert(buffer);
909 return (int) RD(buffer);
910}
911
912
917int
919{
920 ods_log_assert(buffer);
921 return (int) RA(buffer);
922}
923
924
929int
931{
932 ods_log_assert(buffer);
933 return (int) AD(buffer);
934}
935
936
941int
943{
944 ods_log_assert(buffer);
945 return (int) CD(buffer);
946}
947
948
953ldns_pkt_rcode
955{
956 ods_log_assert(buffer);
957 return (ldns_pkt_rcode) RCODE(buffer);
958}
959
960
965void
966buffer_pkt_set_rcode(buffer_type* buffer, ldns_pkt_rcode rcode)
967{
968 ods_log_assert(buffer);
969 RCODE_SET(buffer, rcode);
970}
971
972
977const char*
978buffer_rcode2str(ldns_pkt_rcode rcode)
979{
980 ods_lookup_table *lt;
981 lt = ods_lookup_by_id(ods_rcode_str, rcode);
982 if (lt) {
983 return lt->name;
984 }
985 return NULL;
986}
987
988
993uint16_t
995{
996 ods_log_assert(buffer);
997 return buffer_read_u16_at(buffer, 4);
998}
999
1000
1005void
1006buffer_pkt_set_qdcount(buffer_type* buffer, uint16_t count)
1007{
1008 ods_log_assert(buffer);
1009 buffer_write_u16_at(buffer, 4, count);
1010}
1011
1012
1017uint16_t
1019{
1020 ods_log_assert(buffer);
1021 return buffer_read_u16_at(buffer, 6);
1022}
1023
1024
1029void
1030buffer_pkt_set_ancount(buffer_type* buffer, uint16_t count)
1031{
1032 ods_log_assert(buffer);
1033 buffer_write_u16_at(buffer, 6, count);
1034}
1035
1036
1041uint16_t
1043{
1044 ods_log_assert(buffer);
1045 return buffer_read_u16_at(buffer, 8);
1046}
1047
1048
1053void
1054buffer_pkt_set_nscount(buffer_type* buffer, uint16_t count)
1055{
1056 ods_log_assert(buffer);
1057 buffer_write_u16_at(buffer, 8, count);
1058}
1059
1060
1065uint16_t
1067{
1068 ods_log_assert(buffer);
1069 return buffer_read_u16_at(buffer, 10);
1070}
1071
1072
1077void
1078buffer_pkt_set_arcount(buffer_type* buffer, uint16_t count)
1079{
1080 ods_log_assert(buffer);
1081 buffer_write_u16_at(buffer, 10, count);
1082}
1083
1084
1089static void
1090buffer_pkt_new(buffer_type* buffer, ldns_rdf* qname, ldns_rr_type qtype,
1091 ldns_rr_class qclass, ldns_pkt_opcode opcode)
1092{
1093 ods_log_assert(buffer);
1094 ods_log_assert(qname);
1095 ods_log_assert(qtype);
1096 ods_log_assert(qclass);
1097 /* The header */
1098 buffer_clear(buffer);
1100 buffer_pkt_set_opcode(buffer, opcode);
1101 buffer_pkt_clear_qr(buffer);
1102 buffer_pkt_set_rcode(buffer, LDNS_RCODE_NOERROR);
1103 buffer_pkt_set_qdcount(buffer, 1);
1104 buffer_pkt_set_ancount(buffer, 0);
1105 buffer_pkt_set_nscount(buffer, 0);
1106 buffer_pkt_set_arcount(buffer, 0);
1108 /* The question record */
1109 buffer_write_rdf(buffer, qname);
1110 buffer_write_u16(buffer, qtype);
1111 buffer_write_u16(buffer, qclass);
1112}
1113
1114
1119void
1120buffer_pkt_query(buffer_type* buffer, ldns_rdf* qname, ldns_rr_type qtype,
1121 ldns_rr_class qclass)
1122{
1123 buffer_pkt_new(buffer, qname, qtype, qclass, LDNS_PACKET_QUERY);
1124 buffer_pkt_set_flags(buffer, 0);
1125}
1126
1127
1132void
1133buffer_pkt_notify(buffer_type* buffer, ldns_rdf* qname, ldns_rr_class qclass)
1134{
1135 buffer_pkt_new(buffer, qname, LDNS_RR_TYPE_SOA, qclass,
1136 LDNS_PACKET_NOTIFY);
1137}
1138
1139
1144void
1146{
1147 if (!buffer) {
1148 return;
1149 }
1150 free(buffer->data);
1151 free(buffer);
1152}
1153
1154
void buffer_pkt_set_flags(buffer_type *buffer, uint16_t flags)
Definition: buffer.c:798
int buffer_available(buffer_type *buffer, size_t count)
Definition: buffer.c:487
ods_lookup_table ods_rcode_str[]
Definition: buffer.c:57
void buffer_pkt_set_opcode(buffer_type *buffer, ldns_pkt_opcode opcode)
Definition: buffer.c:858
void buffer_pkt_set_rcode(buffer_type *buffer, ldns_pkt_rcode rcode)
Definition: buffer.c:966
size_t buffer_capacity(buffer_type *buffer)
Definition: buffer.c:401
uint16_t buffer_pkt_qdcount(buffer_type *buffer)
Definition: buffer.c:994
void buffer_clear(buffer_type *buffer)
Definition: buffer.c:99
int buffer_pkt_ad(buffer_type *buffer)
Definition: buffer.c:930
void buffer_pkt_clear_qr(buffer_type *buffer)
Definition: buffer.c:834
int buffer_skip_rr(buffer_type *buffer, unsigned qrr)
Definition: buffer.c:342
void buffer_cleanup(buffer_type *buffer)
Definition: buffer.c:1145
uint32_t buffer_read_u32(buffer_type *buffer)
Definition: buffer.c:736
uint16_t buffer_read_u16(buffer_type *buffer)
Definition: buffer.c:721
uint8_t * buffer_current(buffer_type *buffer)
Definition: buffer.c:438
void buffer_set_limit(buffer_type *buffer, size_t limit)
Definition: buffer.c:385
void buffer_write_u8(buffer_type *buffer, uint8_t data)
Definition: buffer.c:552
void buffer_set_position(buffer_type *buffer, size_t pos)
Definition: buffer.c:137
int buffer_pkt_cd(buffer_type *buffer)
Definition: buffer.c:942
const char * buffer_rcode2str(ldns_pkt_rcode rcode)
Definition: buffer.c:978
int buffer_pkt_qr(buffer_type *buffer)
Definition: buffer.c:810
uint8_t * buffer_begin(buffer_type *buffer)
Definition: buffer.c:426
ldns_pkt_opcode buffer_pkt_opcode(buffer_type *buffer)
Definition: buffer.c:846
ldns_pkt_rcode buffer_pkt_rcode(buffer_type *buffer)
Definition: buffer.c:954
void buffer_flip(buffer_type *buffer)
Definition: buffer.c:112
int buffer_pkt_aa(buffer_type *buffer)
Definition: buffer.c:870
uint8_t * buffer_at(buffer_type *buffer, size_t at)
Definition: buffer.c:413
size_t buffer_position(buffer_type *buffer)
Definition: buffer.c:125
void buffer_pkt_notify(buffer_type *buffer, ldns_rdf *qname, ldns_rr_class qclass)
Definition: buffer.c:1133
uint16_t buffer_pkt_arcount(buffer_type *buffer)
Definition: buffer.c:1066
void buffer_pkt_set_nscount(buffer_type *buffer, uint16_t count)
Definition: buffer.c:1054
void buffer_write(buffer_type *buffer, const void *data, size_t count)
Definition: buffer.c:538
void buffer_write_rdf(buffer_type *buffer, ldns_rdf *rdf)
Definition: buffer.c:591
void buffer_pkt_set_qr(buffer_type *buffer)
Definition: buffer.c:822
void buffer_read(buffer_type *buffer, void *data, size_t count)
Definition: buffer.c:692
int buffer_pkt_rd(buffer_type *buffer)
Definition: buffer.c:906
void buffer_write_u16_at(buffer_type *buffer, size_t at, uint16_t data)
Definition: buffer.c:512
void buffer_skip(buffer_type *buffer, ssize_t count)
Definition: buffer.c:150
uint16_t buffer_pkt_flags(buffer_type *buffer)
Definition: buffer.c:786
int buffer_pkt_tc(buffer_type *buffer)
Definition: buffer.c:894
int buffer_skip_dname(buffer_type *buffer)
Definition: buffer.c:310
int buffer_pkt_ra(buffer_type *buffer)
Definition: buffer.c:918
size_t buffer_remaining(buffer_type *buffer)
Definition: buffer.c:463
uint8_t buffer_read_u8(buffer_type *buffer)
Definition: buffer.c:706
void buffer_write_u32(buffer_type *buffer, uint32_t data)
Definition: buffer.c:578
int buffer_write_rr(buffer_type *buffer, ldns_rr *rr)
Definition: buffer.c:605
void buffer_pkt_query(buffer_type *buffer, ldns_rdf *qname, ldns_rr_type qtype, ldns_rr_class qclass)
Definition: buffer.c:1120
void buffer_pkt_set_random_id(buffer_type *buffer)
Definition: buffer.c:772
void buffer_pkt_set_ancount(buffer_type *buffer, uint16_t count)
Definition: buffer.c:1030
void buffer_write_u16(buffer_type *buffer, uint16_t data)
Definition: buffer.c:565
buffer_type * buffer_create(size_t capacity)
Definition: buffer.c:78
size_t buffer_read_dname(buffer_type *buffer, uint8_t *dname, unsigned allow_pointers)
Definition: buffer.c:246
size_t buffer_limit(buffer_type *buffer)
Definition: buffer.c:373
void buffer_pkt_set_aa(buffer_type *buffer)
Definition: buffer.c:882
uint16_t buffer_pkt_ancount(buffer_type *buffer)
Definition: buffer.c:1018
uint16_t buffer_pkt_nscount(buffer_type *buffer)
Definition: buffer.c:1042
void buffer_pkt_set_arcount(buffer_type *buffer, uint16_t count)
Definition: buffer.c:1078
void buffer_pkt_set_qdcount(buffer_type *buffer, uint16_t count)
Definition: buffer.c:1006
uint16_t buffer_pkt_id(buffer_type *buffer)
Definition: buffer.c:751
#define MAXDOMAINLEN
Definition: buffer.h:44
#define AA(packet)
Definition: buffer.h:66
#define BUFFER_PKT_HEADER_SIZE
Definition: buffer.h:43
#define QR_CLR(packet)
Definition: buffer.h:56
#define QR_SET(packet)
Definition: buffer.h:55
#define RD(packet)
Definition: buffer.h:78
#define RCODE(packet)
Definition: buffer.h:102
#define MAX_PACKET_SIZE
Definition: buffer.h:49
#define RCODE_SET(packet, rcode)
Definition: buffer.h:103
#define OPCODE_SET(packet, opcode)
Definition: buffer.h:61
#define QR(packet)
Definition: buffer.h:54
#define OPCODE(packet)
Definition: buffer.h:60
#define AA_SET(packet)
Definition: buffer.h:67
#define RA(packet)
Definition: buffer.h:84
#define CD(packet)
Definition: buffer.h:96
#define TC(packet)
Definition: buffer.h:72
#define AD(packet)
Definition: buffer.h:90
size_t capacity
Definition: buffer.h:115
size_t limit
Definition: buffer.h:114
size_t position
Definition: buffer.h:113
unsigned fixed
Definition: buffer.h:117
uint8_t * data
Definition: buffer.h:116