OpenDNSSEC-signer  2.0.4
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 
55 static const char* buffer_str = "buffer";
56 
57 ods_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 
78 buffer_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 
98 void
100 {
101  ods_log_assert(buffer);
102  buffer->position = 0;
103  buffer->limit = buffer->capacity;
104 }
105 
106 
111 void
113 {
114  ods_log_assert(buffer);
115  buffer->limit = buffer->position;
116  buffer->position = 0;
117 }
118 
119 
124 size_t
126 {
127  ods_log_assert(buffer);
128  return buffer->position;
129 }
130 
131 
136 void
137 buffer_set_position(buffer_type* buffer, size_t pos)
138 {
139  ods_log_assert(buffer);
140  ods_log_assert(pos <= buffer->limit);
141  buffer->position = pos;
142 }
143 
144 
149 void
150 buffer_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 
162 static int
163 get_bit(uint8_t bits[], size_t index)
164 {
165  return bits[index / 8] & (1 << (7 - index % 8));
166 }
167 
168 
173 static void
174 set_bit(uint8_t bits[], size_t index)
175 {
176  bits[index / 8] |= (1 << (7 - index % 8));
177 }
178 
179 
184 static int
185 label_is_pointer(const uint8_t* label)
186 {
187  ods_log_assert(label);
188  return (label[0] & 0xc0) == 0xc0;
189 }
190 
191 
196 static uint16_t
197 label_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 
209 static int
210 label_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  */
220 static inline int
221 label_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  */
232 static uint8_t
233 label_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 
245 size_t
246 buffer_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 
309 int
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 
341 int
342 buffer_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 
372 size_t
374 {
375  ods_log_assert(buffer);
376  return buffer->limit;
377 }
378 
379 
384 void
385 buffer_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 
400 size_t
402 {
403  ods_log_assert(buffer);
404  return buffer->capacity;
405 }
406 
407 
412 uint8_t*
413 buffer_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 
425 uint8_t*
427 {
428  ods_log_assert(buffer);
429  return buffer_at(buffer, 0);
430 }
431 
432 
437 uint8_t*
439 {
440  ods_log_assert(buffer);
441  return buffer_at(buffer, buffer->position);
442 }
443 
444 
449 static size_t
450 buffer_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 
462 size_t
464 {
465  ods_log_assert(buffer);
466  return buffer_remaining_at(buffer, buffer->position);
467 }
468 
469 
474 static int
475 buffer_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 
486 int
487 buffer_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 
498 static void
499 buffer_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 
511 void
512 buffer_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 
524 static void
525 buffer_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 
537 void
538 buffer_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 
551 void
552 buffer_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 
564 void
565 buffer_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 
577 void
578 buffer_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 
590 void
591 buffer_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 
604 int
605 buffer_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 
643 buffer_tc:
644  buffer_set_position(buffer, tc_mark);
645  return 0;
646 }
647 
648 
653 static uint8_t
654 buffer_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 
667 static uint16_t
668 buffer_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 
679 static uint32_t
680 buffer_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 
691 void
692 buffer_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 
705 uint8_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 
720 uint16_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 
735 uint32_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 
750 uint16_t
752 {
753  ods_log_assert(buffer);
754  return buffer_read_u16_at(buffer, 0);
755 }
756 
761 static uint16_t
762 random_id(void)
763 {
764  return ldns_get_random();
765 }
766 
771 void
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 
785 uint16_t
787 {
788  ods_log_assert(buffer);
789  return (uint16_t) buffer_read_u16_at(buffer, 2);
790 }
791 
792 
797 void
798 buffer_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 
809 int
811 {
812  ods_log_assert(buffer);
813  return (int) QR(buffer);
814 }
815 
816 
821 void
823 {
824  ods_log_assert(buffer);
825  QR_SET(buffer);
826 }
827 
828 
833 void
835 {
836  ods_log_assert(buffer);
837  QR_CLR(buffer);
838 }
839 
840 
845 ldns_pkt_opcode
847 {
848  ods_log_assert(buffer);
849  return (ldns_pkt_opcode) OPCODE(buffer);
850 }
851 
852 
857 void
858 buffer_pkt_set_opcode(buffer_type* buffer, ldns_pkt_opcode opcode)
859 {
860  ods_log_assert(buffer);
861  OPCODE_SET(buffer, opcode);
862 }
863 
864 
869 int
871 {
872  ods_log_assert(buffer);
873  return (int) AA(buffer);
874 }
875 
876 
881 void
883 {
884  ods_log_assert(buffer);
885  AA_SET(buffer);
886 }
887 
888 
893 int
895 {
896  ods_log_assert(buffer);
897  return (int) TC(buffer);
898 }
899 
900 
905 int
907 {
908  ods_log_assert(buffer);
909  return (int) RD(buffer);
910 }
911 
912 
917 int
919 {
920  ods_log_assert(buffer);
921  return (int) RA(buffer);
922 }
923 
924 
929 int
931 {
932  ods_log_assert(buffer);
933  return (int) AD(buffer);
934 }
935 
936 
941 int
943 {
944  ods_log_assert(buffer);
945  return (int) CD(buffer);
946 }
947 
948 
953 ldns_pkt_rcode
955 {
956  ods_log_assert(buffer);
957  return (ldns_pkt_rcode) RCODE(buffer);
958 }
959 
960 
965 void
966 buffer_pkt_set_rcode(buffer_type* buffer, ldns_pkt_rcode rcode)
967 {
968  ods_log_assert(buffer);
969  RCODE_SET(buffer, rcode);
970 }
971 
972 
977 const char*
978 buffer_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 
993 uint16_t
995 {
996  ods_log_assert(buffer);
997  return buffer_read_u16_at(buffer, 4);
998 }
999 
1000 
1005 void
1006 buffer_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 
1017 uint16_t
1019 {
1020  ods_log_assert(buffer);
1021  return buffer_read_u16_at(buffer, 6);
1022 }
1023 
1024 
1029 void
1030 buffer_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 
1041 uint16_t
1043 {
1044  ods_log_assert(buffer);
1045  return buffer_read_u16_at(buffer, 8);
1046 }
1047 
1048 
1053 void
1054 buffer_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 
1065 uint16_t
1067 {
1068  ods_log_assert(buffer);
1069  return buffer_read_u16_at(buffer, 10);
1070 }
1071 
1072 
1077 void
1078 buffer_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 
1089 static void
1090 buffer_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);
1099  buffer_pkt_set_random_id(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 
1119 void
1120 buffer_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 
1132 void
1133 buffer_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 
1144 void
1146 {
1147  if (!buffer) {
1148  return;
1149  }
1150  free(buffer->data);
1151  free(buffer);
1152 }
1153 
1154 
ldns_pkt_opcode buffer_pkt_opcode(buffer_type *buffer)
Definition: buffer.c:846
#define OPCODE(packet)
Definition: buffer.h:60
int buffer_pkt_rd(buffer_type *buffer)
Definition: buffer.c:906
void buffer_pkt_set_random_id(buffer_type *buffer)
Definition: buffer.c:772
uint8_t * buffer_at(buffer_type *buffer, size_t at)
Definition: buffer.c:413
uint16_t buffer_pkt_arcount(buffer_type *buffer)
Definition: buffer.c:1066
#define BUFFER_PKT_HEADER_SIZE
Definition: buffer.h:43
uint16_t buffer_pkt_qdcount(buffer_type *buffer)
Definition: buffer.c:994
#define QR(packet)
Definition: buffer.h:54
void buffer_skip(buffer_type *buffer, ssize_t count)
Definition: buffer.c:150
void buffer_pkt_set_flags(buffer_type *buffer, uint16_t flags)
Definition: buffer.c:798
uint16_t buffer_read_u16(buffer_type *buffer)
Definition: buffer.c:721
int buffer_skip_rr(buffer_type *buffer, unsigned qrr)
Definition: buffer.c:342
void buffer_flip(buffer_type *buffer)
Definition: buffer.c:112
void buffer_pkt_set_qdcount(buffer_type *buffer, uint16_t count)
Definition: buffer.c:1006
void buffer_clear(buffer_type *buffer)
Definition: buffer.c:99
#define OPCODE_SET(packet, opcode)
Definition: buffer.h:61
uint8_t buffer_read_u8(buffer_type *buffer)
Definition: buffer.c:706
void buffer_write_u8(buffer_type *buffer, uint8_t data)
Definition: buffer.c:552
#define AA(packet)
Definition: buffer.h:66
int buffer_pkt_qr(buffer_type *buffer)
Definition: buffer.c:810
void buffer_write(buffer_type *buffer, const void *data, size_t count)
Definition: buffer.c:538
uint16_t buffer_pkt_id(buffer_type *buffer)
Definition: buffer.c:751
uint8_t * buffer_current(buffer_type *buffer)
Definition: buffer.c:438
uint16_t buffer_pkt_ancount(buffer_type *buffer)
Definition: buffer.c:1018
size_t buffer_limit(buffer_type *buffer)
Definition: buffer.c:373
#define CD(packet)
Definition: buffer.h:96
size_t capacity
Definition: buffer.h:115
void buffer_pkt_set_ancount(buffer_type *buffer, uint16_t count)
Definition: buffer.c:1030
void buffer_pkt_set_nscount(buffer_type *buffer, uint16_t count)
Definition: buffer.c:1054
void buffer_set_limit(buffer_type *buffer, size_t limit)
Definition: buffer.c:385
#define QR_SET(packet)
Definition: buffer.h:55
void buffer_cleanup(buffer_type *buffer)
Definition: buffer.c:1145
unsigned fixed
Definition: buffer.h:117
uint16_t buffer_pkt_flags(buffer_type *buffer)
Definition: buffer.c:786
#define RA(packet)
Definition: buffer.h:84
size_t buffer_capacity(buffer_type *buffer)
Definition: buffer.c:401
int buffer_skip_dname(buffer_type *buffer)
Definition: buffer.c:310
uint32_t buffer_read_u32(buffer_type *buffer)
Definition: buffer.c:736
size_t position
Definition: buffer.h:113
void buffer_pkt_set_opcode(buffer_type *buffer, ldns_pkt_opcode opcode)
Definition: buffer.c:858
#define MAX_PACKET_SIZE
Definition: buffer.h:49
void buffer_pkt_query(buffer_type *buffer, ldns_rdf *qname, ldns_rr_type qtype, ldns_rr_class qclass)
Definition: buffer.c:1120
void buffer_write_u16(buffer_type *buffer, uint16_t data)
Definition: buffer.c:565
size_t buffer_read_dname(buffer_type *buffer, uint8_t *dname, unsigned allow_pointers)
Definition: buffer.c:246
void buffer_write_u32(buffer_type *buffer, uint32_t data)
Definition: buffer.c:578
void buffer_pkt_set_aa(buffer_type *buffer)
Definition: buffer.c:882
void buffer_read(buffer_type *buffer, void *data, size_t count)
Definition: buffer.c:692
#define TC(packet)
Definition: buffer.h:72
const char * buffer_rcode2str(ldns_pkt_rcode rcode)
Definition: buffer.c:978
int buffer_pkt_aa(buffer_type *buffer)
Definition: buffer.c:870
uint8_t * data
Definition: buffer.h:116
uint16_t buffer_pkt_nscount(buffer_type *buffer)
Definition: buffer.c:1042
ods_lookup_table ods_rcode_str[]
Definition: buffer.c:57
#define RD(packet)
Definition: buffer.h:78
void buffer_write_u16_at(buffer_type *buffer, size_t at, uint16_t data)
Definition: buffer.c:512
void buffer_set_position(buffer_type *buffer, size_t pos)
Definition: buffer.c:137
size_t limit
Definition: buffer.h:114
#define AA_SET(packet)
Definition: buffer.h:67
void buffer_pkt_notify(buffer_type *buffer, ldns_rdf *qname, ldns_rr_class qclass)
Definition: buffer.c:1133
int buffer_available(buffer_type *buffer, size_t count)
Definition: buffer.c:487
int buffer_pkt_ad(buffer_type *buffer)
Definition: buffer.c:930
#define MAXDOMAINLEN
Definition: buffer.h:44
#define RCODE_SET(packet, rcode)
Definition: buffer.h:103
void buffer_pkt_clear_qr(buffer_type *buffer)
Definition: buffer.c:834
#define AD(packet)
Definition: buffer.h:90
size_t buffer_remaining(buffer_type *buffer)
Definition: buffer.c:463
void buffer_pkt_set_rcode(buffer_type *buffer, ldns_pkt_rcode rcode)
Definition: buffer.c:966
void buffer_write_rdf(buffer_type *buffer, ldns_rdf *rdf)
Definition: buffer.c:591
int buffer_write_rr(buffer_type *buffer, ldns_rr *rr)
Definition: buffer.c:605
int buffer_pkt_ra(buffer_type *buffer)
Definition: buffer.c:918
#define RCODE(packet)
Definition: buffer.h:102
size_t buffer_position(buffer_type *buffer)
Definition: buffer.c:125
void buffer_pkt_set_arcount(buffer_type *buffer, uint16_t count)
Definition: buffer.c:1078
int buffer_pkt_cd(buffer_type *buffer)
Definition: buffer.c:942
#define QR_CLR(packet)
Definition: buffer.h:56
void buffer_pkt_set_qr(buffer_type *buffer)
Definition: buffer.c:822
uint8_t * buffer_begin(buffer_type *buffer)
Definition: buffer.c:426
ldns_pkt_rcode buffer_pkt_rcode(buffer_type *buffer)
Definition: buffer.c:954
buffer_type * buffer_create(size_t capacity)
Definition: buffer.c:78
int buffer_pkt_tc(buffer_type *buffer)
Definition: buffer.c:894