1 /* rr.c
2 *
3 * access functions for ldns_rr -
4 * a Net::DNS like library for C
5 * LibDNS Team @ NLnet Labs
6 *
7 * (c) NLnet Labs, 2004-2006
8 * See the file LICENSE for the license
9 */
10 #include <ldns/config.h>
11
12 #include <ldns/ldns.h>
13 #include <ldns/internal.h>
14
15 #include <strings.h>
16 #include <limits.h>
17
18 #include <errno.h>
19
20 #define LDNS_SYNTAX_DATALEN 16
21 #define LDNS_TTL_DATALEN 21
22 #define LDNS_RRLIST_INIT 8
23
24 #define _IS_WHITESPACE(chr) \
25 ( NULL != strchr( LDNS_PARSE_NO_NL, chr) )
26
27 #define _BUFFER_IS_AT_WHITESPACE(rd_buf) \
28 _IS_WHITESPACE(*(ldns_buffer_current(rd_buf)))
29
30 ldns_rr *
ldns_rr_new(void)31 ldns_rr_new(void)
32 {
33 ldns_rr *rr;
34 rr = LDNS_MALLOC(ldns_rr);
35 if (!rr) {
36 return NULL;
37 }
38
39 ldns_rr_set_owner(rr, NULL);
40 ldns_rr_set_question(rr, false);
41 ldns_rr_set_rd_count(rr, 0);
42 rr->_rdata_fields = NULL;
43 ldns_rr_set_class(rr, LDNS_RR_CLASS_IN);
44 ldns_rr_set_ttl(rr, LDNS_DEFAULT_TTL);
45 return rr;
46 }
47
48 ldns_rr *
ldns_rr_new_frm_type(ldns_rr_type t)49 ldns_rr_new_frm_type(ldns_rr_type t)
50 {
51 ldns_rr *rr;
52 const ldns_rr_descriptor *desc;
53 size_t i;
54
55 rr = LDNS_MALLOC(ldns_rr);
56 if (!rr) {
57 return NULL;
58 }
59
60 desc = ldns_rr_descript(t);
61
62 rr->_rdata_fields = LDNS_XMALLOC(ldns_rdf *, ldns_rr_descriptor_minimum(desc));
63 if(!rr->_rdata_fields) {
64 LDNS_FREE(rr);
65 return NULL;
66 }
67 for (i = 0; i < ldns_rr_descriptor_minimum(desc); i++) {
68 rr->_rdata_fields[i] = NULL;
69 }
70
71 ldns_rr_set_owner(rr, NULL);
72 ldns_rr_set_question(rr, false);
73 /* set the count to minimum */
74 ldns_rr_set_rd_count(rr, ldns_rr_descriptor_minimum(desc));
75 ldns_rr_set_class(rr, LDNS_RR_CLASS_IN);
76 ldns_rr_set_ttl(rr, LDNS_DEFAULT_TTL);
77 ldns_rr_set_type(rr, t);
78 return rr;
79 }
80
81 void
ldns_rr_free(ldns_rr * rr)82 ldns_rr_free(ldns_rr *rr)
83 {
84 size_t i;
85 if (rr) {
86 if (ldns_rr_owner(rr)) {
87 ldns_rdf_deep_free(ldns_rr_owner(rr));
88 }
89 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
90 ldns_rdf_deep_free(ldns_rr_rdf(rr, i));
91 }
92 LDNS_FREE(rr->_rdata_fields);
93 LDNS_FREE(rr);
94 }
95 }
96
97 /* Syntactic sugar for ldns_rr_new_frm_str_internal */
98 INLINE bool
ldns_rdf_type_maybe_quoted(ldns_rdf_type rdf_type)99 ldns_rdf_type_maybe_quoted(ldns_rdf_type rdf_type)
100 {
101 return rdf_type == LDNS_RDF_TYPE_STR ||
102 rdf_type == LDNS_RDF_TYPE_LONG_STR;
103 }
104
105 /*
106 * trailing spaces are allowed
107 * leading spaces are not allowed
108 * allow ttl to be optional
109 * class is optional too
110 * if ttl is missing, and default_ttl is 0, use DEF_TTL
111 * allow ttl to be written as 1d3h
112 * So the RR should look like. e.g.
113 * miek.nl. 3600 IN MX 10 elektron.atoom.net
114 * or
115 * miek.nl. 1h IN MX 10 elektron.atoom.net
116 * or
117 * miek.nl. IN MX 10 elektron.atoom.net
118 */
119 static ldns_status
ldns_rr_new_frm_str_internal(ldns_rr ** newrr,const char * str,uint32_t default_ttl,const ldns_rdf * origin,ldns_rdf ** prev,bool question,bool * explicit_ttl)120 ldns_rr_new_frm_str_internal(ldns_rr **newrr, const char *str,
121 uint32_t default_ttl, const ldns_rdf *origin,
122 ldns_rdf **prev, bool question,
123 bool *explicit_ttl)
124 {
125 ldns_rr *new;
126 const ldns_rr_descriptor *desc;
127 ldns_rr_type rr_type;
128 ldns_buffer *rr_buf = NULL;
129 ldns_buffer *rd_buf = NULL;
130 uint32_t ttl_val;
131 char *owner = NULL;
132 char *ttl = NULL;
133 ldns_rr_class clas_val;
134 char *clas = NULL;
135 char *type = NULL;
136 size_t type_sz;
137 char *rdata = NULL;
138 char *rd = NULL;
139 char *xtok = NULL; /* For RDF types with spaces (i.e. extra tokens) */
140 size_t rd_strlen;
141 const char *delimiters;
142 ssize_t c;
143 ldns_rdf *owner_dname;
144 const char* endptr;
145 int was_unknown_rr_format = 0;
146 ldns_status status = LDNS_STATUS_OK;
147
148 /* used for types with unknown number of rdatas */
149 bool done;
150 bool quoted;
151
152 ldns_rdf *r = NULL;
153 uint16_t r_cnt;
154 uint16_t r_min;
155 uint16_t r_max;
156 size_t pre_data_pos;
157
158 uint16_t hex_data_size;
159 char *hex_data_str = NULL;
160 uint16_t cur_hex_data_size;
161 size_t hex_pos = 0;
162 uint8_t *hex_data = NULL;
163
164 new = ldns_rr_new();
165
166 owner = LDNS_XMALLOC(char, LDNS_MAX_DOMAINLEN + 1);
167 ttl = LDNS_XMALLOC(char, LDNS_TTL_DATALEN);
168 clas = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN);
169 rdata = LDNS_XMALLOC(char, LDNS_MAX_PACKETLEN + 1);
170 rr_buf = LDNS_MALLOC(ldns_buffer);
171 rd_buf = LDNS_MALLOC(ldns_buffer);
172 rd = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
173 xtok = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
174 if (rr_buf) {
175 rr_buf->_data = NULL;
176 }
177 if (rd_buf) {
178 rd_buf->_data = NULL;
179 }
180 if (!new || !owner || !ttl || !clas || !rdata ||
181 !rr_buf || !rd_buf || !rd || !xtok) {
182
183 goto memerror;
184 }
185
186 ldns_buffer_new_frm_data(rr_buf, (char*)str, strlen(str));
187
188 /* split the rr in its parts -1 signals trouble */
189 if (ldns_bget_token(rr_buf, owner, "\t\n ", LDNS_MAX_DOMAINLEN) == -1){
190
191 status = LDNS_STATUS_SYNTAX_ERR;
192 goto error;
193 }
194
195 if (ldns_bget_token(rr_buf, ttl, "\t\n ", LDNS_TTL_DATALEN) == -1) {
196
197 status = LDNS_STATUS_SYNTAX_TTL_ERR;
198 goto error;
199 }
200 ttl_val = (uint32_t) ldns_str2period(ttl, &endptr);
201
202 if (strlen(ttl) > 0 && !isdigit((int) ttl[0])) {
203 /* ah, it's not there or something */
204 if (default_ttl == 0) {
205 ttl_val = LDNS_DEFAULT_TTL;
206 } else {
207 ttl_val = default_ttl;
208 }
209 if (explicit_ttl)
210 *explicit_ttl = false;
211
212 /* we not ASSUMING the TTL is missing and that
213 * the rest of the RR is still there. That is
214 * CLASS TYPE RDATA
215 * so ttl value we read is actually the class
216 */
217 clas_val = ldns_get_rr_class_by_name(ttl);
218 /* class can be left out too, assume IN, current
219 * token must be type
220 */
221 if (clas_val == 0) {
222 clas_val = LDNS_RR_CLASS_IN;
223 type_sz = strlen(ttl) + 1;
224 type = LDNS_XMALLOC(char, type_sz);
225 if (!type) {
226 goto memerror;
227 }
228 strlcpy(type, ttl, type_sz);
229 }
230 } else {
231 if (explicit_ttl)
232 *explicit_ttl = true;
233
234 if (-1 == ldns_bget_token(
235 rr_buf, clas, "\t\n ", LDNS_SYNTAX_DATALEN)) {
236
237 status = LDNS_STATUS_SYNTAX_CLASS_ERR;
238 goto error;
239 }
240 clas_val = ldns_get_rr_class_by_name(clas);
241 /* class can be left out too, assume IN, current
242 * token must be type
243 */
244 if (clas_val == 0) {
245 clas_val = LDNS_RR_CLASS_IN;
246 type_sz = strlen(clas) + 1;
247 type = LDNS_XMALLOC(char, type_sz);
248 if (!type) {
249 goto memerror;
250 }
251 strlcpy(type, clas, type_sz);
252 }
253 }
254 /* the rest should still be waiting for us */
255
256 if (!type) {
257 type = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN);
258 if (!type) {
259 goto memerror;
260 }
261 if (-1 == ldns_bget_token(
262 rr_buf, type, "\t\n ", LDNS_SYNTAX_DATALEN)) {
263
264 status = LDNS_STATUS_SYNTAX_TYPE_ERR;
265 goto error;
266 }
267 }
268
269 if (ldns_bget_token(rr_buf, rdata, "\0", LDNS_MAX_PACKETLEN) == -1) {
270 /* apparently we are done, and it's only a question RR
271 * so do not set status and go to ldnserror here
272 */
273 }
274 ldns_buffer_new_frm_data(rd_buf, rdata, strlen(rdata));
275
276 if (strncmp(owner, "@", 1) == 0) {
277 if (origin) {
278 ldns_rr_set_owner(new, ldns_rdf_clone(origin));
279 } else if (prev && *prev) {
280 ldns_rr_set_owner(new, ldns_rdf_clone(*prev));
281 } else {
282 /* default to root */
283 ldns_rr_set_owner(new, ldns_dname_new_frm_str("."));
284 }
285
286 /* @ also overrides prev */
287 if (prev) {
288 ldns_rdf_deep_free(*prev);
289 *prev = ldns_rdf_clone(ldns_rr_owner(new));
290 if (!*prev) {
291 goto memerror;
292 }
293 }
294 } else {
295 if (strlen(owner) == 0) {
296 /* no ownername was given, try prev, if that fails
297 * origin, else default to root */
298 if (prev && *prev) {
299 ldns_rr_set_owner(new, ldns_rdf_clone(*prev));
300 } else if (origin) {
301 ldns_rr_set_owner(new, ldns_rdf_clone(origin));
302 } else {
303 ldns_rr_set_owner(new,
304 ldns_dname_new_frm_str("."));
305 }
306 if(!ldns_rr_owner(new)) {
307 goto memerror;
308 }
309 } else {
310 owner_dname = ldns_dname_new_frm_str(owner);
311 if (!owner_dname) {
312 status = LDNS_STATUS_SYNTAX_ERR;
313 goto error;
314 }
315
316 ldns_rr_set_owner(new, owner_dname);
317 if (!ldns_dname_str_absolute(owner) && origin) {
318 if(ldns_dname_cat(ldns_rr_owner(new), origin)
319 != LDNS_STATUS_OK) {
320
321 status = LDNS_STATUS_SYNTAX_ERR;
322 goto error;
323 }
324 }
325 if (prev) {
326 ldns_rdf_deep_free(*prev);
327 *prev = ldns_rdf_clone(ldns_rr_owner(new));
328 if (!*prev) {
329 goto error;
330 }
331 }
332 }
333 }
334 LDNS_FREE(owner);
335
336 ldns_rr_set_question(new, question);
337
338 ldns_rr_set_ttl(new, ttl_val);
339 LDNS_FREE(ttl);
340
341 ldns_rr_set_class(new, clas_val);
342 LDNS_FREE(clas);
343
344 rr_type = ldns_get_rr_type_by_name(type);
345 LDNS_FREE(type);
346
347 desc = ldns_rr_descript((uint16_t)rr_type);
348 ldns_rr_set_type(new, rr_type);
349 if (desc) {
350 /* only the rdata remains */
351 r_max = ldns_rr_descriptor_maximum(desc);
352 r_min = ldns_rr_descriptor_minimum(desc);
353 } else {
354 r_min = 0;
355 r_max = 1;
356 }
357
358 for (done = false, r_cnt = 0; !done && r_cnt < r_max; r_cnt++) {
359 quoted = false;
360
361 switch (ldns_rr_descriptor_field_type(desc, r_cnt)) {
362 case LDNS_RDF_TYPE_B64 :
363 case LDNS_RDF_TYPE_HEX : /* These rdf types may con- */
364 case LDNS_RDF_TYPE_NSEC : /* tain whitespace, only if */
365 case LDNS_RDF_TYPE_LOC : /* it is the last rd field. */
366 case LDNS_RDF_TYPE_WKS :
367 case LDNS_RDF_TYPE_IPSECKEY :
368 case LDNS_RDF_TYPE_AMTRELAY :
369 case LDNS_RDF_TYPE_SVCPARAMS : if (r_cnt == r_max - 1) {
370 delimiters = "\n";
371 break;
372 }
373 /* fallthrough */
374 default : delimiters = "\n\t ";
375 }
376
377 if (ldns_rdf_type_maybe_quoted(
378 ldns_rr_descriptor_field_type(
379 desc, r_cnt)) &&
380 ldns_buffer_remaining(rd_buf) > 0){
381
382 /* skip whitespace */
383 while (ldns_buffer_remaining(rd_buf) > 0 &&
384 _BUFFER_IS_AT_WHITESPACE(rd_buf)) {
385 ldns_buffer_skip(rd_buf, 1);
386 }
387
388 if (ldns_buffer_remaining(rd_buf) > 0 &&
389 *(ldns_buffer_current(rd_buf)) == '\"') {
390 delimiters = "\"\0";
391 ldns_buffer_skip(rd_buf, 1);
392 quoted = true;
393 }
394 }
395
396 /* because number of fields can be variable, we can't rely on
397 * _maximum() only
398 */
399
400 /* skip whitespace */
401 while (ldns_buffer_position(rd_buf) < ldns_buffer_limit(rd_buf)
402 && _BUFFER_IS_AT_WHITESPACE(rd_buf)
403 && !quoted) {
404
405 ldns_buffer_skip(rd_buf, 1);
406 }
407
408 pre_data_pos = ldns_buffer_position(rd_buf);
409 if (-1 == ldns_bget_token(
410 rd_buf, rd, delimiters, LDNS_MAX_RDFLEN)) {
411
412 done = true;
413 (void)done; /* we're breaking, so done not read anymore */
414 break;
415 }
416 /* hmmz, rfc3597 specifies that any type can be represented
417 * with \# method, which can contain spaces...
418 * it does specify size though...
419 */
420 rd_strlen = strlen(rd);
421
422 /* unknown RR data */
423 if (strncmp(rd, "\\#", 2) == 0 && !quoted &&
424 (rd_strlen == 2 || _IS_WHITESPACE(rd[2]))) {
425
426 was_unknown_rr_format = 1;
427 /* go back to before \#
428 * and skip it while setting delimiters better
429 */
430 ldns_buffer_set_position(rd_buf, pre_data_pos);
431 delimiters = "\n\t ";
432 (void)ldns_bget_token(rd_buf, rd,
433 delimiters, LDNS_MAX_RDFLEN);
434 /* read rdata octet length */
435 c = ldns_bget_token(rd_buf, rd,
436 delimiters, LDNS_MAX_RDFLEN);
437 if (c == -1) {
438 /* something goes very wrong here */
439 status = LDNS_STATUS_SYNTAX_RDATA_ERR;
440 goto error;
441 }
442 hex_data_size = (uint16_t) atoi(rd);
443 /* copy hex chars into hex str (2 chars per byte) */
444 hex_data_str = LDNS_XMALLOC(char, 2*hex_data_size + 1);
445 if (!hex_data_str) {
446 /* malloc error */
447 goto memerror;
448 }
449 cur_hex_data_size = 0;
450 while(cur_hex_data_size < 2 * hex_data_size) {
451 c = ldns_bget_token(rd_buf, rd,
452 delimiters, LDNS_MAX_RDFLEN);
453 if (c == -1) {
454 status = LDNS_STATUS_SYNTAX_RDATA_ERR;
455 goto error;
456 }
457 rd_strlen = strlen(rd);
458 if ((size_t)cur_hex_data_size + rd_strlen >
459 2 * (size_t)hex_data_size) {
460 status = LDNS_STATUS_SYNTAX_RDATA_ERR;
461 goto error;
462 }
463 strlcpy(hex_data_str + cur_hex_data_size, rd,
464 rd_strlen + 1);
465
466 cur_hex_data_size += rd_strlen;
467 }
468 hex_data_str[cur_hex_data_size] = '\0';
469
470 /* correct the rdf type */
471 /* if *we* know the type, interpret it as wireformat */
472 if (desc) {
473 hex_pos = 0;
474 hex_data =
475 LDNS_XMALLOC(uint8_t, hex_data_size+2);
476
477 if (!hex_data) {
478 goto memerror;
479 }
480 ldns_write_uint16(hex_data, hex_data_size);
481 ldns_hexstring_to_data(
482 hex_data + 2, hex_data_str);
483 status = ldns_wire2rdf(new, hex_data,
484 hex_data_size + 2, &hex_pos);
485 if (status != LDNS_STATUS_OK) {
486 goto error;
487 }
488 LDNS_FREE(hex_data);
489 } else {
490 r = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_HEX,
491 hex_data_str);
492 if (!r) {
493 goto memerror;
494 }
495 ldns_rdf_set_type(r, LDNS_RDF_TYPE_UNKNOWN);
496 if (!ldns_rr_push_rdf(new, r)) {
497 goto memerror;
498 }
499 }
500 LDNS_FREE(hex_data_str);
501
502 } else if(rd_strlen > 0 || quoted) {
503 /* Normal RR */
504 switch(ldns_rr_descriptor_field_type(desc, r_cnt)) {
505
506 case LDNS_RDF_TYPE_HEX:
507 case LDNS_RDF_TYPE_B64:
508 /* When this is the last rdata field, then the
509 * rest should be read in (cause then these
510 * rdf types may contain spaces).
511 */
512 if (r_cnt == r_max - 1) {
513 c = ldns_bget_token(rd_buf, xtok,
514 "\n", LDNS_MAX_RDFLEN);
515 if (c != -1) {
516 (void) strncat(rd, xtok,
517 LDNS_MAX_RDFLEN -
518 strlen(rd) - 1);
519 }
520 }
521 r = ldns_rdf_new_frm_str(
522 ldns_rr_descriptor_field_type(
523 desc, r_cnt), rd);
524 break;
525
526 case LDNS_RDF_TYPE_HIP:
527 /*
528 * In presentation format this RDATA type has
529 * three tokens: An algorithm byte, then a
530 * variable length HIT (in hexbytes) and then
531 * a variable length Public Key (in base64).
532 *
533 * We have just read the algorithm, so we need
534 * two more tokens: HIT and Public Key.
535 */
536 do {
537 /* Read and append HIT */
538 if (ldns_bget_token(rd_buf,
539 xtok, delimiters,
540 LDNS_MAX_RDFLEN) == -1)
541 break;
542
543 (void) strncat(rd, " ",
544 LDNS_MAX_RDFLEN -
545 strlen(rd) - 1);
546 (void) strncat(rd, xtok,
547 LDNS_MAX_RDFLEN -
548 strlen(rd) - 1);
549
550 /* Read and append Public Key*/
551 if (ldns_bget_token(rd_buf,
552 xtok, delimiters,
553 LDNS_MAX_RDFLEN) == -1)
554 break;
555
556 (void) strncat(rd, " ",
557 LDNS_MAX_RDFLEN -
558 strlen(rd) - 1);
559 (void) strncat(rd, xtok,
560 LDNS_MAX_RDFLEN -
561 strlen(rd) - 1);
562 } while (false);
563
564 r = ldns_rdf_new_frm_str(
565 ldns_rr_descriptor_field_type(
566 desc, r_cnt), rd);
567 break;
568
569 case LDNS_RDF_TYPE_DNAME:
570 r = ldns_rdf_new_frm_str(
571 ldns_rr_descriptor_field_type(
572 desc, r_cnt), rd);
573
574 /* check if the origin should be used
575 * or concatenated
576 */
577 if (r && ldns_rdf_size(r) > 1 &&
578 ldns_rdf_data(r)[0] == 1 &&
579 ldns_rdf_data(r)[1] == '@') {
580
581 ldns_rdf_deep_free(r);
582
583 r = origin ? ldns_rdf_clone(origin)
584
585 : ( rr_type == LDNS_RR_TYPE_SOA ?
586
587 ldns_rdf_clone(
588 ldns_rr_owner(new))
589
590 : ldns_rdf_new_frm_str(
591 LDNS_RDF_TYPE_DNAME, ".")
592 );
593
594 } else if (r && rd_strlen >= 1
595 && (origin || rr_type == LDNS_RR_TYPE_SOA)
596 && !ldns_dname_str_absolute(rd)) {
597
598 status = ldns_dname_cat(r, origin
599 ? origin : ldns_rr_owner(new));
600 if (status != LDNS_STATUS_OK) {
601 goto error;
602 }
603 }
604 break;
605 default:
606 r = ldns_rdf_new_frm_str(
607 ldns_rr_descriptor_field_type(
608 desc, r_cnt), rd);
609 break;
610 }
611 if (!r) {
612 status = LDNS_STATUS_SYNTAX_RDATA_ERR;
613 goto error;
614 }
615 ldns_rr_push_rdf(new, r);
616 }
617 } /* for (done = false, r_cnt = 0; !done && r_cnt < r_max; r_cnt++) */
618 LDNS_FREE(rd);
619 LDNS_FREE(xtok);
620 ldns_buffer_free(rr_buf);
621 LDNS_FREE(rdata);
622 if (ldns_buffer_remaining(rd_buf) > 0) {
623 ldns_buffer_free(rd_buf);
624 ldns_rr_free(new);
625 return LDNS_STATUS_SYNTAX_SUPERFLUOUS_TEXT_ERR;
626 }
627 ldns_buffer_free(rd_buf);
628
629 if (!question && desc && !was_unknown_rr_format &&
630 ldns_rr_rd_count(new) < r_min) {
631
632 ldns_rr_free(new);
633 return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR;
634 }
635
636 if (newrr) {
637 *newrr = new;
638 } else {
639 /* Maybe the caller just wanted to see if it would parse? */
640 ldns_rr_free(new);
641 }
642 return LDNS_STATUS_OK;
643
644 memerror:
645 status = LDNS_STATUS_MEM_ERR;
646 error:
647 if (rd_buf && rd_buf->_data) {
648 ldns_buffer_free(rd_buf);
649 } else {
650 LDNS_FREE(rd_buf);
651 }
652 if (rr_buf && rr_buf->_data) {
653 ldns_buffer_free(rr_buf);
654 } else {
655 LDNS_FREE(rr_buf);
656 }
657 LDNS_FREE(type);
658 LDNS_FREE(owner);
659 LDNS_FREE(ttl);
660 LDNS_FREE(clas);
661 LDNS_FREE(hex_data);
662 LDNS_FREE(hex_data_str);
663 LDNS_FREE(xtok);
664 LDNS_FREE(rd);
665 LDNS_FREE(rdata);
666 ldns_rr_free(new);
667 return status;
668 }
669
670 ldns_status
ldns_rr_new_frm_str(ldns_rr ** newrr,const char * str,uint32_t default_ttl,const ldns_rdf * origin,ldns_rdf ** prev)671 ldns_rr_new_frm_str(ldns_rr **newrr, const char *str,
672 uint32_t default_ttl, const ldns_rdf *origin,
673 ldns_rdf **prev)
674 {
675 return ldns_rr_new_frm_str_internal(newrr,
676 str,
677 default_ttl,
678 origin,
679 prev,
680 false,
681 NULL);
682 }
683
684 ldns_status
ldns_rr_new_question_frm_str(ldns_rr ** newrr,const char * str,const ldns_rdf * origin,ldns_rdf ** prev)685 ldns_rr_new_question_frm_str(ldns_rr **newrr, const char *str,
686 const ldns_rdf *origin, ldns_rdf **prev)
687 {
688 return ldns_rr_new_frm_str_internal(newrr,
689 str,
690 0,
691 origin,
692 prev,
693 true,
694 NULL);
695 }
696
697 /* Strip whitespace from the start and the end of <line>. */
698 static char *
ldns_strip_ws(char * line)699 ldns_strip_ws(char *line)
700 {
701 char *s = line, *e;
702
703 for (s = line; *s && isspace((unsigned char)*s); s++)
704 ;
705
706 for (e = strchr(s, 0); e > s+2 && isspace((unsigned char)e[-1]) && e[-2] != '\\'; e--)
707 ;
708 *e = 0;
709
710 return s;
711 }
712
713 ldns_status
ldns_rr_new_frm_fp(ldns_rr ** newrr,FILE * fp,uint32_t * ttl,ldns_rdf ** origin,ldns_rdf ** prev)714 ldns_rr_new_frm_fp(ldns_rr **newrr, FILE *fp, uint32_t *ttl, ldns_rdf **origin, ldns_rdf **prev)
715 {
716 return ldns_rr_new_frm_fp_l(newrr, fp, ttl, origin, prev, NULL);
717 }
718
719 ldns_status
720 _ldns_rr_new_frm_fp_l_internal(ldns_rr **newrr, FILE *fp,
721 uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev,
722 int *line_nr, bool *explicit_ttl);
723 ldns_status
_ldns_rr_new_frm_fp_l_internal(ldns_rr ** newrr,FILE * fp,uint32_t * default_ttl,ldns_rdf ** origin,ldns_rdf ** prev,int * line_nr,bool * explicit_ttl)724 _ldns_rr_new_frm_fp_l_internal(ldns_rr **newrr, FILE *fp,
725 uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev,
726 int *line_nr, bool *explicit_ttl)
727 {
728 char *line = NULL;
729 size_t limit = 0;
730 const char *endptr; /* unused */
731 ldns_rr *rr;
732 uint32_t ttl;
733 ldns_rdf *tmp;
734 ldns_status s;
735
736 if (default_ttl) {
737 ttl = *default_ttl;
738 } else {
739 ttl = 0;
740 }
741 /* read an entire line in from the file */
742 if ((s = ldns_fget_token_l_st( fp, &line, &limit, false
743 , LDNS_PARSE_SKIP_SPACE, line_nr))) {
744 LDNS_FREE(line);
745 return s;
746 }
747
748 if (strncmp(line, "$ORIGIN", 7) == 0 && isspace((unsigned char)line[7])) {
749 if (*origin) {
750 ldns_rdf_deep_free(*origin);
751 *origin = NULL;
752 }
753 tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME,
754 ldns_strip_ws(line + 8));
755 if (!tmp) {
756 /* could not parse what next to $ORIGIN */
757 LDNS_FREE(line);
758 return LDNS_STATUS_SYNTAX_DNAME_ERR;
759 }
760 *origin = tmp;
761 s = LDNS_STATUS_SYNTAX_ORIGIN;
762 } else if (strncmp(line, "$TTL", 4) == 0 && isspace((unsigned char)line[4])) {
763 if (default_ttl) {
764 *default_ttl = ldns_str2period(
765 ldns_strip_ws(line + 5), &endptr);
766 }
767 s = LDNS_STATUS_SYNTAX_TTL;
768 } else if (strncmp(line, "$INCLUDE", 8) == 0) {
769 s = LDNS_STATUS_SYNTAX_INCLUDE;
770 } else if (!*ldns_strip_ws(line)) {
771 LDNS_FREE(line);
772 return LDNS_STATUS_SYNTAX_EMPTY;
773 } else {
774 if (origin && *origin) {
775 s = ldns_rr_new_frm_str_internal(&rr, (const char*)line,
776 ttl, *origin, prev, false, explicit_ttl);
777 } else {
778 s = ldns_rr_new_frm_str_internal(&rr, (const char*)line,
779 ttl, NULL, prev, false, explicit_ttl);
780 }
781 }
782 LDNS_FREE(line);
783 if (s == LDNS_STATUS_OK) {
784 if (newrr) {
785 *newrr = rr;
786 } else {
787 /* Just testing if it would parse? */
788 ldns_rr_free(rr);
789 }
790 }
791 return s;
792 }
793
794 ldns_status
ldns_rr_new_frm_fp_l(ldns_rr ** newrr,FILE * fp,uint32_t * default_ttl,ldns_rdf ** origin,ldns_rdf ** prev,int * line_nr)795 ldns_rr_new_frm_fp_l(ldns_rr **newrr, FILE *fp, uint32_t *default_ttl,
796 ldns_rdf **origin, ldns_rdf **prev, int *line_nr)
797 {
798 return _ldns_rr_new_frm_fp_l_internal(newrr, fp, default_ttl, origin,
799 prev, line_nr, NULL);
800 }
801
802 void
ldns_rr_set_owner(ldns_rr * rr,ldns_rdf * owner)803 ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner)
804 {
805 rr->_owner = owner;
806 }
807
808 void
ldns_rr_set_question(ldns_rr * rr,bool question)809 ldns_rr_set_question(ldns_rr *rr, bool question)
810 {
811 rr->_rr_question = question;
812 }
813
814 void
ldns_rr_set_ttl(ldns_rr * rr,uint32_t ttl)815 ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl)
816 {
817 rr->_ttl = ttl;
818 }
819
820 void
ldns_rr_set_rd_count(ldns_rr * rr,size_t count)821 ldns_rr_set_rd_count(ldns_rr *rr, size_t count)
822 {
823 rr->_rd_count = count;
824 }
825
826 void
ldns_rr_set_type(ldns_rr * rr,ldns_rr_type rr_type)827 ldns_rr_set_type(ldns_rr *rr, ldns_rr_type rr_type)
828 {
829 rr->_rr_type = rr_type;
830 }
831
832 void
ldns_rr_set_class(ldns_rr * rr,ldns_rr_class rr_class)833 ldns_rr_set_class(ldns_rr *rr, ldns_rr_class rr_class)
834 {
835 rr->_rr_class = rr_class;
836 }
837
838 ldns_rdf *
ldns_rr_set_rdf(ldns_rr * rr,const ldns_rdf * f,size_t position)839 ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position)
840 {
841 size_t rd_count;
842 ldns_rdf *pop;
843
844 rd_count = ldns_rr_rd_count(rr);
845 if (position < rd_count) {
846 /* discard the old one */
847 pop = rr->_rdata_fields[position];
848 rr->_rdata_fields[position] = (ldns_rdf*)f;
849 return pop;
850 } else {
851 return NULL;
852 }
853 }
854
855 bool
ldns_rr_push_rdf(ldns_rr * rr,const ldns_rdf * f)856 ldns_rr_push_rdf(ldns_rr *rr, const ldns_rdf *f)
857 {
858 size_t rd_count;
859 ldns_rdf **rdata_fields;
860
861 rd_count = ldns_rr_rd_count(rr);
862
863 /* grow the array */
864 rdata_fields = LDNS_XREALLOC(
865 rr->_rdata_fields, ldns_rdf *, rd_count + 1);
866 if (!rdata_fields) {
867 return false;
868 }
869
870 /* add the new member */
871 rr->_rdata_fields = rdata_fields;
872 rr->_rdata_fields[rd_count] = (ldns_rdf*)f;
873
874 ldns_rr_set_rd_count(rr, rd_count + 1);
875 return true;
876 }
877
878 ldns_rdf *
ldns_rr_pop_rdf(ldns_rr * rr)879 ldns_rr_pop_rdf(ldns_rr *rr)
880 {
881 size_t rd_count;
882 ldns_rdf *pop;
883 ldns_rdf** newrd;
884
885 rd_count = ldns_rr_rd_count(rr);
886
887 if (rd_count == 0) {
888 return NULL;
889 }
890
891 pop = rr->_rdata_fields[rd_count - 1];
892
893 /* try to shrink the array */
894 if(rd_count > 1) {
895 newrd = LDNS_XREALLOC(
896 rr->_rdata_fields, ldns_rdf *, rd_count - 1);
897 if(newrd)
898 rr->_rdata_fields = newrd;
899 } else {
900 LDNS_FREE(rr->_rdata_fields);
901 }
902
903 ldns_rr_set_rd_count(rr, rd_count - 1);
904 return pop;
905 }
906
907 ldns_rdf *
ldns_rr_rdf(const ldns_rr * rr,size_t nr)908 ldns_rr_rdf(const ldns_rr *rr, size_t nr)
909 {
910 if (rr && nr < ldns_rr_rd_count(rr)) {
911 return rr->_rdata_fields[nr];
912 } else {
913 return NULL;
914 }
915 }
916
917 ldns_rdf *
ldns_rr_owner(const ldns_rr * rr)918 ldns_rr_owner(const ldns_rr *rr)
919 {
920 return rr->_owner;
921 }
922
923 bool
ldns_rr_is_question(const ldns_rr * rr)924 ldns_rr_is_question(const ldns_rr *rr)
925 {
926 return rr->_rr_question;
927 }
928
929 uint32_t
ldns_rr_ttl(const ldns_rr * rr)930 ldns_rr_ttl(const ldns_rr *rr)
931 {
932 return rr->_ttl;
933 }
934
935 size_t
ldns_rr_rd_count(const ldns_rr * rr)936 ldns_rr_rd_count(const ldns_rr *rr)
937 {
938 return rr->_rd_count;
939 }
940
941 ldns_rr_type
ldns_rr_get_type(const ldns_rr * rr)942 ldns_rr_get_type(const ldns_rr *rr)
943 {
944 return rr->_rr_type;
945 }
946
947 ldns_rr_class
ldns_rr_get_class(const ldns_rr * rr)948 ldns_rr_get_class(const ldns_rr *rr)
949 {
950 return rr->_rr_class;
951 }
952
953 /* rr_lists */
954
955 size_t
ldns_rr_list_rr_count(const ldns_rr_list * rr_list)956 ldns_rr_list_rr_count(const ldns_rr_list *rr_list)
957 {
958 if (rr_list) {
959 return rr_list->_rr_count;
960 } else {
961 return 0;
962 }
963 }
964
965 ldns_rr *
ldns_rr_list_set_rr(ldns_rr_list * rr_list,const ldns_rr * r,size_t count)966 ldns_rr_list_set_rr(ldns_rr_list *rr_list, const ldns_rr *r, size_t count)
967 {
968 ldns_rr *old;
969
970 if (count > ldns_rr_list_rr_count(rr_list)) {
971 return NULL;
972 }
973
974 old = ldns_rr_list_rr(rr_list, count);
975
976 /* overwrite old's pointer */
977 rr_list->_rrs[count] = (ldns_rr*)r;
978 return old;
979 }
980
981 void
ldns_rr_list_set_rr_count(ldns_rr_list * rr_list,size_t count)982 ldns_rr_list_set_rr_count(ldns_rr_list *rr_list, size_t count)
983 {
984 assert(count <= rr_list->_rr_capacity);
985 rr_list->_rr_count = count;
986 }
987
988 ldns_rr *
ldns_rr_list_rr(const ldns_rr_list * rr_list,size_t nr)989 ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr)
990 {
991 if (nr < ldns_rr_list_rr_count(rr_list)) {
992 return rr_list->_rrs[nr];
993 } else {
994 return NULL;
995 }
996 }
997
998 ldns_rr_list *
ldns_rr_list_new(void)999 ldns_rr_list_new(void)
1000 {
1001 ldns_rr_list *rr_list = LDNS_MALLOC(ldns_rr_list);
1002 if(!rr_list) return NULL;
1003 rr_list->_rr_count = 0;
1004 rr_list->_rr_capacity = 0;
1005 rr_list->_rrs = NULL;
1006 return rr_list;
1007 }
1008
1009 void
ldns_rr_list_free(ldns_rr_list * rr_list)1010 ldns_rr_list_free(ldns_rr_list *rr_list)
1011 {
1012 if (rr_list) {
1013 LDNS_FREE(rr_list->_rrs);
1014 LDNS_FREE(rr_list);
1015 }
1016 }
1017
1018 void
ldns_rr_list_deep_free(ldns_rr_list * rr_list)1019 ldns_rr_list_deep_free(ldns_rr_list *rr_list)
1020 {
1021 size_t i;
1022
1023 if (rr_list) {
1024 for (i=0; i < ldns_rr_list_rr_count(rr_list); i++) {
1025 ldns_rr_free(ldns_rr_list_rr(rr_list, i));
1026 }
1027 LDNS_FREE(rr_list->_rrs);
1028 LDNS_FREE(rr_list);
1029 }
1030 }
1031
1032
1033 /* add right to left. So we modify *left! */
1034 bool
ldns_rr_list_cat(ldns_rr_list * left,const ldns_rr_list * right)1035 ldns_rr_list_cat(ldns_rr_list *left, const ldns_rr_list *right)
1036 {
1037 size_t r_rr_count;
1038 size_t i;
1039
1040 if (!left) {
1041 return false;
1042 }
1043
1044 if (right) {
1045 r_rr_count = ldns_rr_list_rr_count(right);
1046 } else {
1047 r_rr_count = 0;
1048 }
1049
1050 /* push right to left */
1051 for(i = 0; i < r_rr_count; i++) {
1052 ldns_rr_list_push_rr(left, ldns_rr_list_rr(right, i));
1053 }
1054 return true;
1055 }
1056
1057 ldns_rr_list *
ldns_rr_list_cat_clone(const ldns_rr_list * left,const ldns_rr_list * right)1058 ldns_rr_list_cat_clone(const ldns_rr_list *left, const ldns_rr_list *right)
1059 {
1060 size_t l_rr_count;
1061 size_t r_rr_count;
1062 size_t i;
1063 ldns_rr_list *cat;
1064
1065 if (left) {
1066 l_rr_count = ldns_rr_list_rr_count(left);
1067 } else {
1068 return ldns_rr_list_clone(right);
1069 }
1070
1071 if (right) {
1072 r_rr_count = ldns_rr_list_rr_count(right);
1073 } else {
1074 r_rr_count = 0;
1075 }
1076
1077 cat = ldns_rr_list_new();
1078
1079 if (!cat) {
1080 return NULL;
1081 }
1082
1083 /* left */
1084 for(i = 0; i < l_rr_count; i++) {
1085 ldns_rr_list_push_rr(cat,
1086 ldns_rr_clone(ldns_rr_list_rr(left, i)));
1087 }
1088 /* right */
1089 for(i = 0; i < r_rr_count; i++) {
1090 ldns_rr_list_push_rr(cat,
1091 ldns_rr_clone(ldns_rr_list_rr(right, i)));
1092 }
1093 return cat;
1094 }
1095
1096 ldns_rr_list *
ldns_rr_list_subtype_by_rdf(const ldns_rr_list * l,const ldns_rdf * r,size_t pos)1097 ldns_rr_list_subtype_by_rdf(const ldns_rr_list *l, const ldns_rdf *r, size_t pos)
1098 {
1099 size_t i;
1100 ldns_rr_list *subtyped;
1101 ldns_rdf *list_rdf;
1102
1103 subtyped = ldns_rr_list_new();
1104
1105 for(i = 0; i < ldns_rr_list_rr_count(l); i++) {
1106 list_rdf = ldns_rr_rdf(
1107 ldns_rr_list_rr(l, i),
1108 pos);
1109 if (!list_rdf) {
1110 /* pos is too large or any other error */
1111 ldns_rr_list_deep_free(subtyped);
1112 return NULL;
1113 }
1114
1115 if (ldns_rdf_compare(list_rdf, r) == 0) {
1116 /* a match */
1117 ldns_rr_list_push_rr(subtyped,
1118 ldns_rr_clone(ldns_rr_list_rr(l, i)));
1119 }
1120 }
1121
1122 if (ldns_rr_list_rr_count(subtyped) > 0) {
1123 return subtyped;
1124 } else {
1125 ldns_rr_list_free(subtyped);
1126 return NULL;
1127 }
1128 }
1129
1130 bool
ldns_rr_list_push_rr(ldns_rr_list * rr_list,const ldns_rr * rr)1131 ldns_rr_list_push_rr(ldns_rr_list *rr_list, const ldns_rr *rr)
1132 {
1133 size_t rr_count;
1134 size_t cap;
1135
1136 rr_count = ldns_rr_list_rr_count(rr_list);
1137 cap = rr_list->_rr_capacity;
1138
1139 /* grow the array */
1140 if(rr_count+1 > cap) {
1141 ldns_rr **rrs;
1142
1143 if(cap == 0)
1144 cap = LDNS_RRLIST_INIT; /* initial list size */
1145 else cap *= 2;
1146 rrs = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap);
1147 if (!rrs) {
1148 return false;
1149 }
1150 rr_list->_rrs = rrs;
1151 rr_list->_rr_capacity = cap;
1152 }
1153
1154 /* add the new member */
1155 rr_list->_rrs[rr_count] = (ldns_rr*)rr;
1156
1157 ldns_rr_list_set_rr_count(rr_list, rr_count + 1);
1158 return true;
1159 }
1160
1161 bool
ldns_rr_list_push_rr_list(ldns_rr_list * rr_list,const ldns_rr_list * push_list)1162 ldns_rr_list_push_rr_list(ldns_rr_list *rr_list, const ldns_rr_list *push_list)
1163 {
1164 size_t i;
1165
1166 for(i = 0; i < ldns_rr_list_rr_count(push_list); i++) {
1167 if (!ldns_rr_list_push_rr(rr_list,
1168 ldns_rr_list_rr(push_list, i))) {
1169 return false;
1170 }
1171 }
1172 return true;
1173 }
1174
1175 ldns_rr *
ldns_rr_list_pop_rr(ldns_rr_list * rr_list)1176 ldns_rr_list_pop_rr(ldns_rr_list *rr_list)
1177 {
1178 size_t rr_count;
1179 size_t cap;
1180 ldns_rr *pop;
1181
1182 rr_count = ldns_rr_list_rr_count(rr_list);
1183
1184 if (rr_count == 0) {
1185 return NULL;
1186 }
1187
1188 cap = rr_list->_rr_capacity;
1189 pop = ldns_rr_list_rr(rr_list, rr_count - 1);
1190
1191 /* shrink the array */
1192 if(cap > LDNS_RRLIST_INIT && rr_count-1 <= cap/2) {
1193 ldns_rr** a;
1194 cap /= 2;
1195 a = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap);
1196 if(a) {
1197 rr_list->_rrs = a;
1198 rr_list->_rr_capacity = cap;
1199 }
1200 /* if the realloc fails, the capacity for the list remains unchanged */
1201 }
1202
1203 ldns_rr_list_set_rr_count(rr_list, rr_count - 1);
1204
1205 return pop;
1206 }
1207
1208 ldns_rr_list *
ldns_rr_list_pop_rr_list(ldns_rr_list * rr_list,size_t howmany)1209 ldns_rr_list_pop_rr_list(ldns_rr_list *rr_list, size_t howmany)
1210 {
1211 /* pop a number of rr's and put them in a rr_list */
1212 ldns_rr_list *popped;
1213 ldns_rr *p;
1214 size_t i = howmany;
1215
1216 popped = ldns_rr_list_new();
1217
1218 if (!popped) {
1219 return NULL;
1220 }
1221
1222
1223 while(i > 0 &&
1224 (p = ldns_rr_list_pop_rr(rr_list)) != NULL) {
1225 ldns_rr_list_push_rr(popped, p);
1226 i--;
1227 }
1228
1229 if (i == howmany) { /* so i <= 0 */
1230 ldns_rr_list_free(popped);
1231 return NULL;
1232 } else {
1233 return popped;
1234 }
1235 }
1236
1237
1238 bool
ldns_rr_list_contains_rr(const ldns_rr_list * rr_list,const ldns_rr * rr)1239 ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, const ldns_rr *rr)
1240 {
1241 size_t i;
1242
1243 if (!rr_list || !rr || ldns_rr_list_rr_count(rr_list) == 0) {
1244 return false;
1245 }
1246
1247 for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
1248 if (rr == ldns_rr_list_rr(rr_list, i)) {
1249 return true;
1250 } else if (ldns_rr_compare(rr, ldns_rr_list_rr(rr_list, i)) == 0) {
1251 return true;
1252 }
1253 }
1254 return false;
1255 }
1256
1257 bool
ldns_is_rrset(const ldns_rr_list * rr_list)1258 ldns_is_rrset(const ldns_rr_list *rr_list)
1259 {
1260 ldns_rr_type t;
1261 ldns_rr_class c;
1262 ldns_rdf *o;
1263 ldns_rr *tmp;
1264 size_t i;
1265
1266 if (!rr_list || ldns_rr_list_rr_count(rr_list) == 0) {
1267 return false;
1268 }
1269
1270 tmp = ldns_rr_list_rr(rr_list, 0);
1271
1272 t = ldns_rr_get_type(tmp);
1273 c = ldns_rr_get_class(tmp);
1274 o = ldns_rr_owner(tmp);
1275
1276 /* compare these with the rest of the rr_list, start with 1 */
1277 for (i = 1; i < ldns_rr_list_rr_count(rr_list); i++) {
1278 tmp = ldns_rr_list_rr(rr_list, i);
1279 if (t != ldns_rr_get_type(tmp)) {
1280 return false;
1281 }
1282 if (c != ldns_rr_get_class(tmp)) {
1283 return false;
1284 }
1285 if (ldns_dname_compare(o, ldns_rr_owner(tmp)) != 0) {
1286 return false;
1287 }
1288 }
1289 return true;
1290 }
1291
1292 bool
ldns_is_rrset_strict(const ldns_rr_list * rr_list)1293 ldns_is_rrset_strict(const ldns_rr_list *rr_list)
1294 {
1295 ldns_rr_type t;
1296 ldns_rr_class c;
1297 uint32_t l;
1298 ldns_rdf *o;
1299 ldns_rr *tmp;
1300 size_t i;
1301
1302 if (!rr_list || ldns_rr_list_rr_count(rr_list) == 0) {
1303 return false;
1304 }
1305
1306 tmp = ldns_rr_list_rr(rr_list, 0);
1307
1308 t = ldns_rr_get_type(tmp);
1309 c = ldns_rr_get_class(tmp);
1310 l = ldns_rr_ttl(tmp);
1311 o = ldns_rr_owner(tmp);
1312
1313 /* compare these with the rest of the rr_list, start with 1 */
1314 for (i = 1; i < ldns_rr_list_rr_count(rr_list); i++) {
1315 tmp = ldns_rr_list_rr(rr_list, i);
1316 if (t != ldns_rr_get_type(tmp)) {
1317 return false;
1318 }
1319 if (c != ldns_rr_get_class(tmp)) {
1320 return false;
1321 }
1322 if (l != ldns_rr_ttl(tmp)) {
1323 return false;
1324 }
1325 if (ldns_dname_compare(o, ldns_rr_owner(tmp)) != 0) {
1326 return false;
1327 }
1328 }
1329 return true;
1330 }
1331
1332 bool
ldns_rr_set_push_rr(ldns_rr_list * rr_list,ldns_rr * rr)1333 ldns_rr_set_push_rr(ldns_rr_list *rr_list, ldns_rr *rr)
1334 {
1335 size_t rr_count;
1336 size_t i;
1337 ldns_rr *last;
1338
1339 assert(rr != NULL);
1340
1341 rr_count = ldns_rr_list_rr_count(rr_list);
1342
1343 if (rr_count == 0) {
1344 /* nothing there, so checking it is
1345 * not needed */
1346 return ldns_rr_list_push_rr(rr_list, rr);
1347 } else {
1348 /* check with the final rr in the rr_list */
1349 last = ldns_rr_list_rr(rr_list, rr_count - 1);
1350
1351 if (ldns_rr_get_class(last) != ldns_rr_get_class(rr)) {
1352 return false;
1353 }
1354 if (ldns_rr_get_type(last) != ldns_rr_get_type(rr)) {
1355 return false;
1356 }
1357 /* only check if not equal to RRSIG */
1358 if (ldns_rr_get_type(rr) != LDNS_RR_TYPE_RRSIG) {
1359 if (ldns_rr_ttl(last) != ldns_rr_ttl(rr)) {
1360 return false;
1361 }
1362 }
1363 if (ldns_rdf_compare(ldns_rr_owner(last),
1364 ldns_rr_owner(rr)) != 0) {
1365 return false;
1366 }
1367 /* ok, still alive - check if the rr already
1368 * exists - if so, don't add it */
1369 for(i = 0; i < rr_count; i++) {
1370 if(ldns_rr_compare(
1371 ldns_rr_list_rr(rr_list, i), rr) == 0) {
1372 return false;
1373 }
1374 }
1375 /* it's safe, push it */
1376 return ldns_rr_list_push_rr(rr_list, rr);
1377 }
1378 }
1379
1380 ldns_rr *
ldns_rr_set_pop_rr(ldns_rr_list * rr_list)1381 ldns_rr_set_pop_rr(ldns_rr_list *rr_list)
1382 {
1383 return ldns_rr_list_pop_rr(rr_list);
1384 }
1385
1386 ldns_rr_list *
ldns_rr_list_pop_rrset(ldns_rr_list * rr_list)1387 ldns_rr_list_pop_rrset(ldns_rr_list *rr_list)
1388 {
1389 ldns_rr_list *rrset;
1390 ldns_rr *last_rr = NULL;
1391 ldns_rr *next_rr;
1392
1393 if (!rr_list) {
1394 return NULL;
1395 }
1396
1397 rrset = ldns_rr_list_new();
1398 if (!last_rr) {
1399 last_rr = ldns_rr_list_pop_rr(rr_list);
1400 if (!last_rr) {
1401 ldns_rr_list_free(rrset);
1402 return NULL;
1403 } else {
1404 ldns_rr_list_push_rr(rrset, last_rr);
1405 }
1406 }
1407
1408 if (ldns_rr_list_rr_count(rr_list) > 0) {
1409 next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1);
1410 } else {
1411 next_rr = NULL;
1412 }
1413
1414 while (next_rr) {
1415 if (
1416 ldns_rdf_compare(ldns_rr_owner(next_rr),
1417 ldns_rr_owner(last_rr)) == 0
1418 &&
1419 ldns_rr_get_type(next_rr) == ldns_rr_get_type(last_rr)
1420 &&
1421 ldns_rr_get_class(next_rr) == ldns_rr_get_class(last_rr)
1422 ) {
1423 ldns_rr_list_push_rr(rrset, ldns_rr_list_pop_rr(rr_list));
1424 if (ldns_rr_list_rr_count(rr_list) > 0) {
1425 last_rr = next_rr;
1426 next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1);
1427 } else {
1428 next_rr = NULL;
1429 }
1430 } else {
1431 next_rr = NULL;
1432 }
1433 }
1434
1435 return rrset;
1436 }
1437
1438 ldns_rr *
ldns_rr_clone(const ldns_rr * rr)1439 ldns_rr_clone(const ldns_rr *rr)
1440 {
1441 size_t i;
1442 ldns_rr *new_rr;
1443
1444 if (!rr) {
1445 return NULL;
1446 }
1447
1448 new_rr = ldns_rr_new();
1449 if (!new_rr) {
1450 return NULL;
1451 }
1452 if (ldns_rr_owner(rr)) {
1453 ldns_rr_set_owner(new_rr, ldns_rdf_clone(ldns_rr_owner(rr)));
1454 }
1455 ldns_rr_set_ttl(new_rr, ldns_rr_ttl(rr));
1456 ldns_rr_set_type(new_rr, ldns_rr_get_type(rr));
1457 ldns_rr_set_class(new_rr, ldns_rr_get_class(rr));
1458 ldns_rr_set_question(new_rr, ldns_rr_is_question(rr));
1459
1460 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1461 if (ldns_rr_rdf(rr,i)) {
1462 ldns_rr_push_rdf(new_rr, ldns_rdf_clone(ldns_rr_rdf(rr, i)));
1463 }
1464 }
1465
1466 return new_rr;
1467 }
1468
1469 ldns_rr_list *
ldns_rr_list_clone(const ldns_rr_list * rrlist)1470 ldns_rr_list_clone(const ldns_rr_list *rrlist)
1471 {
1472 size_t i;
1473 ldns_rr_list *new_list;
1474 ldns_rr *r;
1475
1476 if (!rrlist) {
1477 return NULL;
1478 }
1479
1480 new_list = ldns_rr_list_new();
1481 if (!new_list) {
1482 return NULL;
1483 }
1484 for (i = 0; i < ldns_rr_list_rr_count(rrlist); i++) {
1485 r = ldns_rr_clone(
1486 ldns_rr_list_rr(rrlist, i)
1487 );
1488 if (!r) {
1489 /* huh, failure in cloning */
1490 ldns_rr_list_deep_free(new_list);
1491 return NULL;
1492 }
1493 ldns_rr_list_push_rr(new_list, r);
1494 }
1495 return new_list;
1496 }
1497
1498
1499 static int
qsort_schwartz_rr_compare(const void * a,const void * b)1500 qsort_schwartz_rr_compare(const void *a, const void *b)
1501 {
1502 int result = 0;
1503 ldns_rr *rr1, *rr2;
1504 ldns_buffer *rr1_buf, *rr2_buf;
1505 struct ldns_schwartzian_compare_struct *sa = *(struct ldns_schwartzian_compare_struct **) a;
1506 struct ldns_schwartzian_compare_struct *sb = *(struct ldns_schwartzian_compare_struct **) b;
1507 /* if we are doing 2wire, we need to do lowercasing on the dname (and maybe on the rdata)
1508 * this must be done for comparison only, so we need to have a temp var for both buffers,
1509 * which is only used when the transformed object value isn't there yet
1510 */
1511 ldns_rr *canonical_a, *canonical_b;
1512
1513 rr1 = (ldns_rr *) sa->original_object;
1514 rr2 = (ldns_rr *) sb->original_object;
1515
1516 result = ldns_rr_compare_no_rdata(rr1, rr2);
1517
1518 if (result == 0) {
1519 if (!sa->transformed_object) {
1520 canonical_a = ldns_rr_clone(sa->original_object);
1521 ldns_rr2canonical(canonical_a);
1522 sa->transformed_object = ldns_buffer_new(ldns_rr_uncompressed_size(canonical_a));
1523 if (ldns_rr2buffer_wire(sa->transformed_object, canonical_a, LDNS_SECTION_ANY) != LDNS_STATUS_OK) {
1524 ldns_buffer_free((ldns_buffer *)sa->transformed_object);
1525 sa->transformed_object = NULL;
1526 ldns_rr_free(canonical_a);
1527 return 0;
1528 }
1529 ldns_rr_free(canonical_a);
1530 }
1531 if (!sb->transformed_object) {
1532 canonical_b = ldns_rr_clone(sb->original_object);
1533 ldns_rr2canonical(canonical_b);
1534 sb->transformed_object = ldns_buffer_new(ldns_rr_uncompressed_size(canonical_b));
1535 if (ldns_rr2buffer_wire(sb->transformed_object, canonical_b, LDNS_SECTION_ANY) != LDNS_STATUS_OK) {
1536 ldns_buffer_free((ldns_buffer *)sa->transformed_object);
1537 ldns_buffer_free((ldns_buffer *)sb->transformed_object);
1538 sa->transformed_object = NULL;
1539 sb->transformed_object = NULL;
1540 ldns_rr_free(canonical_b);
1541 return 0;
1542 }
1543 ldns_rr_free(canonical_b);
1544 }
1545 rr1_buf = (ldns_buffer *) sa->transformed_object;
1546 rr2_buf = (ldns_buffer *) sb->transformed_object;
1547
1548 result = ldns_rr_compare_wire(rr1_buf, rr2_buf);
1549 }
1550
1551 return result;
1552 }
1553
1554 void
ldns_rr_list_sort(ldns_rr_list * unsorted)1555 ldns_rr_list_sort(ldns_rr_list *unsorted)
1556 {
1557 struct ldns_schwartzian_compare_struct **sortables;
1558 size_t item_count;
1559 size_t i;
1560
1561 if (unsorted) {
1562 item_count = ldns_rr_list_rr_count(unsorted);
1563
1564 sortables = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct *,
1565 item_count);
1566 if(!sortables) return; /* no way to return error */
1567 for (i = 0; i < item_count; i++) {
1568 sortables[i] = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct, 1);
1569 if(!sortables[i]) {
1570 /* free the allocated parts */
1571 while(i>0) {
1572 i--;
1573 LDNS_FREE(sortables[i]);
1574 }
1575 /* no way to return error */
1576 LDNS_FREE(sortables);
1577 return;
1578 }
1579 sortables[i]->original_object = ldns_rr_list_rr(unsorted, i);
1580 sortables[i]->transformed_object = NULL;
1581 }
1582 qsort(sortables,
1583 item_count,
1584 sizeof(struct ldns_schwartzian_compare_struct *),
1585 qsort_schwartz_rr_compare);
1586 for (i = 0; i < item_count; i++) {
1587 unsorted->_rrs[i] = sortables[i]->original_object;
1588 if (sortables[i]->transformed_object) {
1589 ldns_buffer_free(sortables[i]->transformed_object);
1590 }
1591 LDNS_FREE(sortables[i]);
1592 }
1593 LDNS_FREE(sortables);
1594 }
1595 }
1596
1597 int
ldns_rr_compare_no_rdata(const ldns_rr * rr1,const ldns_rr * rr2)1598 ldns_rr_compare_no_rdata(const ldns_rr *rr1, const ldns_rr *rr2)
1599 {
1600 size_t rr1_len;
1601 size_t rr2_len;
1602 size_t offset;
1603
1604 assert(rr1 != NULL);
1605 assert(rr2 != NULL);
1606
1607 rr1_len = ldns_rr_uncompressed_size(rr1);
1608 rr2_len = ldns_rr_uncompressed_size(rr2);
1609
1610 if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) < 0) {
1611 return -1;
1612 } else if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) > 0) {
1613 return 1;
1614 }
1615
1616 /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */
1617 if (ldns_rr_get_class(rr1) != ldns_rr_get_class(rr2)) {
1618 return ldns_rr_get_class(rr1) - ldns_rr_get_class(rr2);
1619 }
1620
1621 /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */
1622 if (ldns_rr_get_type(rr1) != ldns_rr_get_type(rr2)) {
1623 return ldns_rr_get_type(rr1) - ldns_rr_get_type(rr2);
1624 }
1625
1626 /* offset is the owername length + ttl + type + class + rdlen == start of wire format rdata */
1627 offset = ldns_rdf_size(ldns_rr_owner(rr1)) + 4 + 2 + 2 + 2;
1628 /* if either record doesn't have any RDATA... */
1629 if (offset > rr1_len || offset > rr2_len) {
1630 if (rr1_len == rr2_len) {
1631 return 0;
1632 }
1633 return ((int) rr2_len - (int) rr1_len);
1634 }
1635
1636 return 0;
1637 }
1638
ldns_rr_compare_wire(const ldns_buffer * rr1_buf,const ldns_buffer * rr2_buf)1639 int ldns_rr_compare_wire(const ldns_buffer *rr1_buf, const ldns_buffer *rr2_buf)
1640 {
1641 size_t rr1_len, rr2_len, min_len, i, offset;
1642
1643 rr1_len = ldns_buffer_capacity(rr1_buf);
1644 rr2_len = ldns_buffer_capacity(rr2_buf);
1645
1646 /* jump past dname (checked in earlier part)
1647 * and especially past TTL */
1648 offset = 0;
1649 while (offset < rr1_len && *ldns_buffer_at(rr1_buf, offset) != 0) {
1650 offset += *ldns_buffer_at(rr1_buf, offset) + 1;
1651 }
1652 /* jump to rdata section (PAST the rdata length field, otherwise
1653 rrs with different lengths might be sorted erroneously */
1654 offset += 11;
1655 min_len = (rr1_len < rr2_len) ? rr1_len : rr2_len;
1656 /* Compare RRs RDATA byte for byte. */
1657 for(i = offset; i < min_len; i++) {
1658 if (*ldns_buffer_at(rr1_buf,i) < *ldns_buffer_at(rr2_buf,i)) {
1659 return -1;
1660 } else if (*ldns_buffer_at(rr1_buf,i) > *ldns_buffer_at(rr2_buf,i)) {
1661 return +1;
1662 }
1663 }
1664
1665 /* If both RDATAs are the same up to min_len, then the shorter one sorts first. */
1666 if (rr1_len < rr2_len) {
1667 return -1;
1668 } else if (rr1_len > rr2_len) {
1669 return +1;
1670 }
1671 /* The RDATAs are equal. */
1672 return 0;
1673
1674 }
1675
1676 int
ldns_rr_compare(const ldns_rr * rr1,const ldns_rr * rr2)1677 ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2)
1678 {
1679 int result;
1680 size_t rr1_len, rr2_len;
1681
1682 ldns_buffer *rr1_buf;
1683 ldns_buffer *rr2_buf;
1684
1685 result = ldns_rr_compare_no_rdata(rr1, rr2);
1686 if (result == 0) {
1687 rr1_len = ldns_rr_uncompressed_size(rr1);
1688 rr2_len = ldns_rr_uncompressed_size(rr2);
1689
1690 rr1_buf = ldns_buffer_new(rr1_len);
1691 rr2_buf = ldns_buffer_new(rr2_len);
1692
1693 if (ldns_rr2buffer_wire_canonical(rr1_buf,
1694 rr1,
1695 LDNS_SECTION_ANY)
1696 != LDNS_STATUS_OK) {
1697 ldns_buffer_free(rr1_buf);
1698 ldns_buffer_free(rr2_buf);
1699 return 0;
1700 }
1701 if (ldns_rr2buffer_wire_canonical(rr2_buf,
1702 rr2,
1703 LDNS_SECTION_ANY)
1704 != LDNS_STATUS_OK) {
1705 ldns_buffer_free(rr1_buf);
1706 ldns_buffer_free(rr2_buf);
1707 return 0;
1708 }
1709
1710 result = ldns_rr_compare_wire(rr1_buf, rr2_buf);
1711
1712 ldns_buffer_free(rr1_buf);
1713 ldns_buffer_free(rr2_buf);
1714 }
1715
1716 return result;
1717 }
1718
1719 /* convert (c)dnskey to a (c)ds with the given algorithm,
1720 * then compare the result with the given (c)ds */
1721 static int
ldns_rr_compare_ds_dnskey(ldns_rr * ds,ldns_rr * dnskey)1722 ldns_rr_compare_ds_dnskey(ldns_rr *ds,
1723 ldns_rr *dnskey)
1724 {
1725 ldns_rr *ds_gen;
1726 bool result = false;
1727 ldns_hash algo;
1728
1729 if (!dnskey || !ds ||
1730 (ldns_rr_get_type(ds) != LDNS_RR_TYPE_DS &&
1731 ldns_rr_get_type(ds) != LDNS_RR_TYPE_CDS) ||
1732 (ldns_rr_get_type(dnskey) != LDNS_RR_TYPE_DNSKEY &&
1733 ldns_rr_get_type(dnskey) != LDNS_RR_TYPE_CDNSKEY)) {
1734 return false;
1735 }
1736
1737 if (ldns_rr_rdf(ds, 2) == NULL) {
1738 return false;
1739 }
1740 algo = ldns_rdf2native_int8(ldns_rr_rdf(ds, 2));
1741
1742 ds_gen = ldns_key_rr2ds(dnskey, algo);
1743 if (ds_gen) {
1744 result = ldns_rr_compare(ds, ds_gen) == 0;
1745 ldns_rr_free(ds_gen);
1746 }
1747 return result;
1748 }
1749
1750 bool
ldns_rr_compare_ds(const ldns_rr * orr1,const ldns_rr * orr2)1751 ldns_rr_compare_ds(const ldns_rr *orr1, const ldns_rr *orr2)
1752 {
1753 bool result;
1754 ldns_rr *rr1 = ldns_rr_clone(orr1);
1755 ldns_rr *rr2 = ldns_rr_clone(orr2);
1756
1757 /* set ttls to zero */
1758 ldns_rr_set_ttl(rr1, 0);
1759 ldns_rr_set_ttl(rr2, 0);
1760
1761 if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DS &&
1762 ldns_rr_get_type(rr2) == LDNS_RR_TYPE_DNSKEY) {
1763 result = ldns_rr_compare_ds_dnskey(rr1, rr2);
1764 } else if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DNSKEY &&
1765 ldns_rr_get_type(rr2) == LDNS_RR_TYPE_DS) {
1766 result = ldns_rr_compare_ds_dnskey(rr2, rr1);
1767 } else if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_CDS &&
1768 ldns_rr_get_type(rr2) == LDNS_RR_TYPE_CDNSKEY) {
1769 result = ldns_rr_compare_ds_dnskey(rr1, rr2);
1770 } else if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_CDNSKEY &&
1771 ldns_rr_get_type(rr2) == LDNS_RR_TYPE_CDS) {
1772 result = ldns_rr_compare_ds_dnskey(rr2, rr1);
1773 } else {
1774 result = (ldns_rr_compare(rr1, rr2) == 0);
1775 }
1776
1777 ldns_rr_free(rr1);
1778 ldns_rr_free(rr2);
1779
1780 return result;
1781 }
1782
1783 int
ldns_rr_list_compare(const ldns_rr_list * rrl1,const ldns_rr_list * rrl2)1784 ldns_rr_list_compare(const ldns_rr_list *rrl1, const ldns_rr_list *rrl2)
1785 {
1786 size_t i = 0;
1787 int rr_cmp;
1788
1789 assert(rrl1 != NULL);
1790 assert(rrl2 != NULL);
1791
1792 for (i = 0; i < ldns_rr_list_rr_count(rrl1) && i < ldns_rr_list_rr_count(rrl2); i++) {
1793 rr_cmp = ldns_rr_compare(ldns_rr_list_rr(rrl1, i), ldns_rr_list_rr(rrl2, i));
1794 if (rr_cmp != 0) {
1795 return rr_cmp;
1796 }
1797 }
1798
1799 if (i == ldns_rr_list_rr_count(rrl1) &&
1800 i != ldns_rr_list_rr_count(rrl2)) {
1801 return 1;
1802 } else if (i == ldns_rr_list_rr_count(rrl2) &&
1803 i != ldns_rr_list_rr_count(rrl1)) {
1804 return -1;
1805 } else {
1806 return 0;
1807 }
1808 }
1809
1810 size_t
ldns_rr_uncompressed_size(const ldns_rr * r)1811 ldns_rr_uncompressed_size(const ldns_rr *r)
1812 {
1813 size_t rrsize;
1814 size_t i;
1815
1816 rrsize = 0;
1817 /* add all the rdf sizes */
1818 for(i = 0; i < ldns_rr_rd_count(r); i++) {
1819 rrsize += ldns_rdf_size(ldns_rr_rdf(r, i));
1820 }
1821 /* ownername */
1822 rrsize += ldns_rdf_size(ldns_rr_owner(r));
1823 rrsize += LDNS_RR_OVERHEAD;
1824 return rrsize;
1825 }
1826
1827 void
ldns_rr2canonical(ldns_rr * rr)1828 ldns_rr2canonical(ldns_rr *rr)
1829 {
1830 uint16_t i;
1831
1832 if (!rr) {
1833 return;
1834 }
1835
1836 ldns_dname2canonical(ldns_rr_owner(rr));
1837
1838 /*
1839 * lowercase the rdata dnames if the rr type is one
1840 * of the list in chapter 7 of RFC3597
1841 * Also added RRSIG, because a "Signer's Name" should be canonicalized
1842 * too. See dnssec-bis-updates-16. We can add it to this list because
1843 * the "Signer's Name" is the only dname type rdata field in a RRSIG.
1844 */
1845 switch(ldns_rr_get_type(rr)) {
1846 case LDNS_RR_TYPE_NS:
1847 case LDNS_RR_TYPE_MD:
1848 case LDNS_RR_TYPE_MF:
1849 case LDNS_RR_TYPE_CNAME:
1850 case LDNS_RR_TYPE_SOA:
1851 case LDNS_RR_TYPE_MB:
1852 case LDNS_RR_TYPE_MG:
1853 case LDNS_RR_TYPE_MR:
1854 case LDNS_RR_TYPE_PTR:
1855 case LDNS_RR_TYPE_MINFO:
1856 case LDNS_RR_TYPE_MX:
1857 case LDNS_RR_TYPE_RP:
1858 case LDNS_RR_TYPE_AFSDB:
1859 case LDNS_RR_TYPE_RT:
1860 case LDNS_RR_TYPE_SIG:
1861 case LDNS_RR_TYPE_PX:
1862 case LDNS_RR_TYPE_NXT:
1863 case LDNS_RR_TYPE_NAPTR:
1864 case LDNS_RR_TYPE_KX:
1865 case LDNS_RR_TYPE_SRV:
1866 case LDNS_RR_TYPE_DNAME:
1867 case LDNS_RR_TYPE_A6:
1868 case LDNS_RR_TYPE_RRSIG:
1869 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1870 ldns_dname2canonical(ldns_rr_rdf(rr, i));
1871 }
1872 return;
1873 default:
1874 /* do nothing */
1875 return;
1876 }
1877 }
1878
1879 void
ldns_rr_list2canonical(const ldns_rr_list * rr_list)1880 ldns_rr_list2canonical(const ldns_rr_list *rr_list)
1881 {
1882 size_t i;
1883 for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
1884 ldns_rr2canonical(ldns_rr_list_rr(rr_list, i));
1885 }
1886 }
1887
1888 uint8_t
ldns_rr_label_count(const ldns_rr * rr)1889 ldns_rr_label_count(const ldns_rr *rr)
1890 {
1891 if (!rr) {
1892 return 0;
1893 }
1894 return ldns_dname_label_count(
1895 ldns_rr_owner(rr));
1896 }
1897
1898 /** \cond */
1899 static const ldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
1900 static const ldns_rdf_type type_a_wireformat[] = { LDNS_RDF_TYPE_A };
1901 static const ldns_rdf_type type_ns_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1902 static const ldns_rdf_type type_md_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1903 static const ldns_rdf_type type_mf_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1904 static const ldns_rdf_type type_cname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1905 static const ldns_rdf_type type_soa_wireformat[] = {
1906 LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_INT32,
1907 LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD,
1908 LDNS_RDF_TYPE_PERIOD
1909 };
1910 static const ldns_rdf_type type_mb_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1911 static const ldns_rdf_type type_mg_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1912 static const ldns_rdf_type type_mr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1913 static const ldns_rdf_type type_wks_wireformat[] = {
1914 LDNS_RDF_TYPE_A, LDNS_RDF_TYPE_WKS
1915 };
1916 static const ldns_rdf_type type_ptr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1917 static const ldns_rdf_type type_hinfo_wireformat[] = {
1918 LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR
1919 };
1920 static const ldns_rdf_type type_minfo_wireformat[] = {
1921 LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
1922 };
1923 static const ldns_rdf_type type_mx_wireformat[] = {
1924 LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
1925 };
1926 static const ldns_rdf_type type_rp_wireformat[] = {
1927 LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
1928 };
1929 static const ldns_rdf_type type_afsdb_wireformat[] = {
1930 LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
1931 };
1932 static const ldns_rdf_type type_x25_wireformat[] = { LDNS_RDF_TYPE_STR };
1933 static const ldns_rdf_type type_isdn_wireformat[] = {
1934 LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR
1935 };
1936 static const ldns_rdf_type type_rt_wireformat[] = {
1937 LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
1938 };
1939 static const ldns_rdf_type type_nsap_wireformat[] = {
1940 LDNS_RDF_TYPE_NSAP
1941 };
1942 static const ldns_rdf_type type_nsap_ptr_wireformat[] = {
1943 LDNS_RDF_TYPE_UNQUOTED
1944 };
1945 static const ldns_rdf_type type_sig_wireformat[] = {
1946 LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32,
1947 LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16,
1948 LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64
1949 };
1950 static const ldns_rdf_type type_key_wireformat[] = {
1951 LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64
1952 };
1953 static const ldns_rdf_type type_px_wireformat[] = {
1954 LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
1955 };
1956 static const ldns_rdf_type type_gpos_wireformat[] = {
1957 LDNS_RDF_TYPE_UNQUOTED, LDNS_RDF_TYPE_UNQUOTED, LDNS_RDF_TYPE_UNQUOTED
1958 };
1959 static const ldns_rdf_type type_aaaa_wireformat[] = { LDNS_RDF_TYPE_AAAA };
1960 static const ldns_rdf_type type_loc_wireformat[] = { LDNS_RDF_TYPE_LOC };
1961 static const ldns_rdf_type type_nxt_wireformat[] = {
1962 LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_UNKNOWN
1963 };
1964 static const ldns_rdf_type type_eid_wireformat[] = {
1965 LDNS_RDF_TYPE_HEX
1966 };
1967 static const ldns_rdf_type type_nimloc_wireformat[] = {
1968 LDNS_RDF_TYPE_HEX
1969 };
1970 static const ldns_rdf_type type_srv_wireformat[] = {
1971 LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
1972 };
1973 static const ldns_rdf_type type_atma_wireformat[] = {
1974 LDNS_RDF_TYPE_ATMA
1975 };
1976 static const ldns_rdf_type type_naptr_wireformat[] = {
1977 LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_DNAME
1978 };
1979 static const ldns_rdf_type type_kx_wireformat[] = {
1980 LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
1981 };
1982 static const ldns_rdf_type type_cert_wireformat[] = {
1983 LDNS_RDF_TYPE_CERT_ALG, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_B64
1984 };
1985 static const ldns_rdf_type type_a6_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
1986 static const ldns_rdf_type type_dname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1987 static const ldns_rdf_type type_sink_wireformat[] = { LDNS_RDF_TYPE_INT8,
1988 LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64
1989 };
1990 static const ldns_rdf_type type_apl_wireformat[] = {
1991 LDNS_RDF_TYPE_APL
1992 };
1993 static const ldns_rdf_type type_ds_wireformat[] = {
1994 LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX
1995 };
1996 static const ldns_rdf_type type_sshfp_wireformat[] = {
1997 LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX
1998 };
1999 static const ldns_rdf_type type_ipseckey_wireformat[] = {
2000 LDNS_RDF_TYPE_IPSECKEY
2001 };
2002 static const ldns_rdf_type type_rrsig_wireformat[] = {
2003 LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32,
2004 LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64
2005 };
2006 static const ldns_rdf_type type_nsec_wireformat[] = {
2007 LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_NSEC
2008 };
2009 static const ldns_rdf_type type_dhcid_wireformat[] = {
2010 LDNS_RDF_TYPE_B64
2011 };
2012 static const ldns_rdf_type type_talink_wireformat[] = {
2013 LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
2014 };
2015 #ifdef RRTYPE_OPENPGPKEY
2016 static const ldns_rdf_type type_openpgpkey_wireformat[] = {
2017 LDNS_RDF_TYPE_B64
2018 };
2019 #endif
2020 static const ldns_rdf_type type_csync_wireformat[] = {
2021 LDNS_RDF_TYPE_INT32, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_NSEC
2022 };
2023 static const ldns_rdf_type type_zonemd_wireformat[] = {
2024 LDNS_RDF_TYPE_INT32,
2025 LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX
2026 };
2027 #ifdef RRTYPE_SVCB_HTTPS
2028 static const ldns_rdf_type type_svcb_wireformat[] = {
2029 LDNS_RDF_TYPE_INT16,
2030 LDNS_RDF_TYPE_DNAME,
2031 LDNS_RDF_TYPE_SVCPARAMS
2032 };
2033 #endif
2034 #ifdef RRTYPE_DSYNC
2035 static const ldns_rdf_type type_dsync_wireformat[] = {
2036 LDNS_RDF_TYPE_TYPE,
2037 LDNS_RDF_TYPE_INT8,
2038 LDNS_RDF_TYPE_INT16,
2039 LDNS_RDF_TYPE_DNAME
2040 };
2041 #endif
2042 #ifdef RRTYPE_HHIT_BRID
2043 static const ldns_rdf_type type_hhit_wireformat[] = {
2044 LDNS_RDF_TYPE_B64
2045 };
2046 static const ldns_rdf_type type_brid_wireformat[] = {
2047 LDNS_RDF_TYPE_B64
2048 };
2049 #endif
2050
2051 /* nsec3 is some vars, followed by same type of data of nsec */
2052 static const ldns_rdf_type type_nsec3_wireformat[] = {
2053 /* LDNS_RDF_TYPE_NSEC3_VARS, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC*/
2054 LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_NSEC3_SALT, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC
2055 };
2056
2057 static const ldns_rdf_type type_nsec3param_wireformat[] = {
2058 /* LDNS_RDF_TYPE_NSEC3_PARAMS_VARS*/
2059 LDNS_RDF_TYPE_INT8,
2060 LDNS_RDF_TYPE_INT8,
2061 LDNS_RDF_TYPE_INT16,
2062 LDNS_RDF_TYPE_NSEC3_SALT
2063 };
2064
2065 static const ldns_rdf_type type_dnskey_wireformat[] = {
2066 LDNS_RDF_TYPE_INT16,
2067 LDNS_RDF_TYPE_INT8,
2068 LDNS_RDF_TYPE_ALG,
2069 LDNS_RDF_TYPE_B64
2070 };
2071 static const ldns_rdf_type type_tkey_wireformat[] = {
2072 LDNS_RDF_TYPE_DNAME,
2073 LDNS_RDF_TYPE_TIME,
2074 LDNS_RDF_TYPE_TIME,
2075 LDNS_RDF_TYPE_INT16,
2076 LDNS_RDF_TYPE_INT16,
2077 LDNS_RDF_TYPE_INT16_DATA,
2078 LDNS_RDF_TYPE_INT16_DATA,
2079 };
2080 static const ldns_rdf_type type_tsig_wireformat[] = {
2081 LDNS_RDF_TYPE_DNAME,
2082 LDNS_RDF_TYPE_TSIGTIME,
2083 LDNS_RDF_TYPE_INT16,
2084 LDNS_RDF_TYPE_INT16_DATA,
2085 LDNS_RDF_TYPE_INT16,
2086 LDNS_RDF_TYPE_INT16,
2087 LDNS_RDF_TYPE_INT16_DATA
2088 };
2089 static const ldns_rdf_type type_tlsa_wireformat[] = {
2090 LDNS_RDF_TYPE_CERTIFICATE_USAGE,
2091 LDNS_RDF_TYPE_SELECTOR,
2092 LDNS_RDF_TYPE_MATCHING_TYPE,
2093 LDNS_RDF_TYPE_HEX
2094 };
2095 static const ldns_rdf_type type_hip_wireformat[] = {
2096 LDNS_RDF_TYPE_HIP
2097 };
2098 static const ldns_rdf_type type_nid_wireformat[] = {
2099 LDNS_RDF_TYPE_INT16,
2100 LDNS_RDF_TYPE_ILNP64
2101 };
2102 static const ldns_rdf_type type_l32_wireformat[] = {
2103 LDNS_RDF_TYPE_INT16,
2104 LDNS_RDF_TYPE_A
2105 };
2106 static const ldns_rdf_type type_l64_wireformat[] = {
2107 LDNS_RDF_TYPE_INT16,
2108 LDNS_RDF_TYPE_ILNP64
2109 };
2110 static const ldns_rdf_type type_lp_wireformat[] = {
2111 LDNS_RDF_TYPE_INT16,
2112 LDNS_RDF_TYPE_DNAME
2113 };
2114 static const ldns_rdf_type type_eui48_wireformat[] = {
2115 LDNS_RDF_TYPE_EUI48
2116 };
2117 static const ldns_rdf_type type_eui64_wireformat[] = {
2118 LDNS_RDF_TYPE_EUI64
2119 };
2120 static const ldns_rdf_type type_uri_wireformat[] = {
2121 LDNS_RDF_TYPE_INT16,
2122 LDNS_RDF_TYPE_INT16,
2123 LDNS_RDF_TYPE_LONG_STR
2124 };
2125 static const ldns_rdf_type type_caa_wireformat[] = {
2126 LDNS_RDF_TYPE_INT8,
2127 LDNS_RDF_TYPE_TAG,
2128 LDNS_RDF_TYPE_LONG_STR
2129 };
2130 #ifdef RRTYPE_DOA
2131 static const ldns_rdf_type type_doa_wireformat[] = {
2132 LDNS_RDF_TYPE_INT32,
2133 LDNS_RDF_TYPE_INT32,
2134 LDNS_RDF_TYPE_INT8,
2135 LDNS_RDF_TYPE_STR,
2136 LDNS_RDF_TYPE_B64
2137 };
2138 #endif
2139 #ifdef RRTYPE_AMTRELAY
2140 static const ldns_rdf_type type_amtrelay_wireformat[] = {
2141 LDNS_RDF_TYPE_AMTRELAY
2142 };
2143 #endif
2144 #ifdef RRTYPE_CLA_IPN
2145 static const ldns_rdf_type type_ipn_wireformat[] = {
2146 LDNS_RDF_TYPE_IPN
2147 };
2148 #endif
2149
2150
2151
2152 /** \endcond */
2153
2154 /** \cond */
2155 /* All RR's defined in 1035 are well known and can thus
2156 * be compressed. See RFC3597. These RR's are:
2157 * CNAME HINFO MB MD MF MG MINFO MR MX NULL NS PTR SOA TXT
2158 */
2159 static ldns_rr_descriptor rdata_field_descriptors[] = {
2160 /* 0 */
2161 { 0, NULL, 0, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2162 /* 1 */
2163 {LDNS_RR_TYPE_A, "A", 1, 1, type_a_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2164 /* 2 */
2165 {LDNS_RR_TYPE_NS, "NS", 1, 1, type_ns_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2166 /* 3 */
2167 {LDNS_RR_TYPE_MD, "MD", 1, 1, type_md_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2168 /* 4 */
2169 {LDNS_RR_TYPE_MF, "MF", 1, 1, type_mf_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2170 /* 5 */
2171 {LDNS_RR_TYPE_CNAME, "CNAME", 1, 1, type_cname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2172 /* 6 */
2173 {LDNS_RR_TYPE_SOA, "SOA", 7, 7, type_soa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 },
2174 /* 7 */
2175 {LDNS_RR_TYPE_MB, "MB", 1, 1, type_mb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2176 /* 8 */
2177 {LDNS_RR_TYPE_MG, "MG", 1, 1, type_mg_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2178 /* 9 */
2179 {LDNS_RR_TYPE_MR, "MR", 1, 1, type_mr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2180 /* 10 */
2181 {LDNS_RR_TYPE_NULL, "NULL", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2182 /* 11 */
2183 {LDNS_RR_TYPE_WKS, "WKS", 2, 2, type_wks_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2184 /* 12 */
2185 {LDNS_RR_TYPE_PTR, "PTR", 1, 1, type_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2186 /* 13 */
2187 {LDNS_RR_TYPE_HINFO, "HINFO", 2, 2, type_hinfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2188 /* 14 */
2189 {LDNS_RR_TYPE_MINFO, "MINFO", 2, 2, type_minfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 },
2190 /* 15 */
2191 {LDNS_RR_TYPE_MX, "MX", 2, 2, type_mx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
2192 /* 16 */
2193 {LDNS_RR_TYPE_TXT, "TXT", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
2194 /* 17 */
2195 {LDNS_RR_TYPE_RP, "RP", 2, 2, type_rp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
2196 /* 18 */
2197 {LDNS_RR_TYPE_AFSDB, "AFSDB", 2, 2, type_afsdb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2198 /* 19 */
2199 {LDNS_RR_TYPE_X25, "X25", 1, 1, type_x25_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2200 /* 20 */
2201 {LDNS_RR_TYPE_ISDN, "ISDN", 1, 2, type_isdn_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2202 /* 21 */
2203 {LDNS_RR_TYPE_RT, "RT", 2, 2, type_rt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2204 /* 22 */
2205 {LDNS_RR_TYPE_NSAP, "NSAP", 1, 1, type_nsap_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2206 /* 23 */
2207 {LDNS_RR_TYPE_NSAP_PTR, "NSAP-PTR", 1, 1, type_nsap_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2208 /* 24 */
2209 {LDNS_RR_TYPE_SIG, "SIG", 9, 9, type_sig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2210 /* 25 */
2211 {LDNS_RR_TYPE_KEY, "KEY", 4, 4, type_key_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2212 /* 26 */
2213 {LDNS_RR_TYPE_PX, "PX", 3, 3, type_px_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
2214 /* 27 */
2215 {LDNS_RR_TYPE_GPOS, "GPOS", 3, 3, type_gpos_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2216 /* 28 */
2217 {LDNS_RR_TYPE_AAAA, "AAAA", 1, 1, type_aaaa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2218 /* 29 */
2219 {LDNS_RR_TYPE_LOC, "LOC", 1, 1, type_loc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2220 /* 30 */
2221 {LDNS_RR_TYPE_NXT, "NXT", 2, 2, type_nxt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2222 /* 31 */
2223 {LDNS_RR_TYPE_EID, "EID", 1, 1, type_eid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2224 /* 32 */
2225 {LDNS_RR_TYPE_NIMLOC, "NIMLOC", 1, 1, type_nimloc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2226 /* 33 */
2227 {LDNS_RR_TYPE_SRV, "SRV", 4, 4, type_srv_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2228 /* 34 */
2229 {LDNS_RR_TYPE_ATMA, "ATMA", 1, 1, type_atma_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2230 /* 35 */
2231 {LDNS_RR_TYPE_NAPTR, "NAPTR", 6, 6, type_naptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2232 /* 36 */
2233 {LDNS_RR_TYPE_KX, "KX", 2, 2, type_kx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2234 /* 37 */
2235 {LDNS_RR_TYPE_CERT, "CERT", 4, 4, type_cert_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2236 /* 38 */
2237 {LDNS_RR_TYPE_A6, "A6", 1, 1, type_a6_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2238 /* 39 */
2239 {LDNS_RR_TYPE_DNAME, "DNAME", 1, 1, type_dname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2240 /* 40 */
2241 {LDNS_RR_TYPE_SINK, "SINK", 1, 1, type_sink_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2242 /* 41 */
2243 {LDNS_RR_TYPE_OPT, "OPT", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2244 /* 42 */
2245 {LDNS_RR_TYPE_APL, "APL", 0, 0, type_apl_wireformat, LDNS_RDF_TYPE_APL, LDNS_RR_NO_COMPRESS, 0 },
2246 /* 43 */
2247 {LDNS_RR_TYPE_DS, "DS", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2248 /* 44 */
2249 {LDNS_RR_TYPE_SSHFP, "SSHFP", 3, 3, type_sshfp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2250 /* 45 */
2251 {LDNS_RR_TYPE_IPSECKEY, "IPSECKEY", 1, 1, type_ipseckey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2252 /* 46 */
2253 {LDNS_RR_TYPE_RRSIG, "RRSIG", 9, 9, type_rrsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2254 /* 47 */
2255 {LDNS_RR_TYPE_NSEC, "NSEC", 1, 2, type_nsec_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2256 /* 48 */
2257 {LDNS_RR_TYPE_DNSKEY, "DNSKEY", 4, 4, type_dnskey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2258 /* 49 */
2259 {LDNS_RR_TYPE_DHCID, "DHCID", 1, 1, type_dhcid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2260 /* 50 */
2261 {LDNS_RR_TYPE_NSEC3, "NSEC3", 5, 6, type_nsec3_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2262 /* 51 */
2263 {LDNS_RR_TYPE_NSEC3PARAM, "NSEC3PARAM", 4, 4, type_nsec3param_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2264 /* 52 */
2265 {LDNS_RR_TYPE_TLSA, "TLSA", 4, 4, type_tlsa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2266
2267 {LDNS_RR_TYPE_SMIMEA, "SMIMEA", 4, 4, type_tlsa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2268 {LDNS_RR_TYPE_NULL, "TYPE54", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2269
2270 /* 55
2271 * Hip ends with 0 or more Rendezvous Servers represented as dname's.
2272 * Hence the LDNS_RDF_TYPE_DNAME _variable field and the _maximum field
2273 * set to 0.
2274 */
2275 {LDNS_RR_TYPE_HIP, "HIP", 1, 1, type_hip_wireformat, LDNS_RDF_TYPE_DNAME, LDNS_RR_NO_COMPRESS, 0 },
2276
2277 #ifdef RRTYPE_NINFO
2278 /* 56 */
2279 {LDNS_RR_TYPE_NINFO, "NINFO", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
2280 #else
2281 {LDNS_RR_TYPE_NULL, "TYPE56", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2282 #endif
2283 #ifdef RRTYPE_RKEY
2284 /* 57 */
2285 {LDNS_RR_TYPE_RKEY, "RKEY", 4, 4, type_key_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2286 #else
2287 {LDNS_RR_TYPE_NULL, "TYPE57", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2288 #endif
2289 /* 58 */
2290 {LDNS_RR_TYPE_TALINK, "TALINK", 2, 2, type_talink_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
2291
2292 /* 59 */
2293 {LDNS_RR_TYPE_CDS, "CDS", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2294 /* 60 */
2295 {LDNS_RR_TYPE_CDNSKEY, "CDNSKEY", 4, 4, type_dnskey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2296
2297 #ifdef RRTYPE_OPENPGPKEY
2298 /* 61 */
2299 {LDNS_RR_TYPE_OPENPGPKEY, "OPENPGPKEY", 1, 1, type_openpgpkey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2300 #else
2301 {LDNS_RR_TYPE_NULL, "TYPE61", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2302 #endif
2303 /* 62 */
2304 {LDNS_RR_TYPE_CSYNC, "CSYNC", 3, 3, type_csync_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2305 /* 63 */
2306 {LDNS_RR_TYPE_ZONEMD, "ZONEMD", 4, 4, type_zonemd_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2307 #ifdef RRTYPE_SVCB_HTTPS
2308 /* 64 */
2309 {LDNS_RR_TYPE_SVCB, "SVCB", 2, 3, type_svcb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2310 /* 65 */
2311 {LDNS_RR_TYPE_HTTPS, "HTTPS", 2, 3, type_svcb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2312
2313 #else
2314 {LDNS_RR_TYPE_NULL, "TYPE64", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2315 {LDNS_RR_TYPE_NULL, "TYPE65", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2316 #endif
2317 #ifdef RRTYPE_DSYNC
2318 /* 66 */
2319 {LDNS_RR_TYPE_DSYNC, "DSYNC", 4, 4, type_dsync_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2320 #else
2321 {LDNS_RR_TYPE_NULL, "TYPE66", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2322 #endif
2323 #ifdef RRTYPE_HHIT_BRID
2324 /* 67 */
2325 {LDNS_RR_TYPE_HHIT, "HHIT", 1, 1, type_hhit_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2326 /* 68 */
2327 {LDNS_RR_TYPE_BRID, "BRID", 1, 1, type_brid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2328 #else
2329 {LDNS_RR_TYPE_NULL, "TYPE67", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2330 {LDNS_RR_TYPE_NULL, "TYPE68", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2331 #endif
2332 {LDNS_RR_TYPE_NULL, "TYPE69", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2333 {LDNS_RR_TYPE_NULL, "TYPE70", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2334 {LDNS_RR_TYPE_NULL, "TYPE71", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2335 {LDNS_RR_TYPE_NULL, "TYPE72", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2336 {LDNS_RR_TYPE_NULL, "TYPE73", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2337 {LDNS_RR_TYPE_NULL, "TYPE74", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2338 {LDNS_RR_TYPE_NULL, "TYPE75", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2339 {LDNS_RR_TYPE_NULL, "TYPE76", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2340 {LDNS_RR_TYPE_NULL, "TYPE77", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2341 {LDNS_RR_TYPE_NULL, "TYPE78", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2342 {LDNS_RR_TYPE_NULL, "TYPE79", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2343 {LDNS_RR_TYPE_NULL, "TYPE80", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2344 {LDNS_RR_TYPE_NULL, "TYPE81", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2345 {LDNS_RR_TYPE_NULL, "TYPE82", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2346 {LDNS_RR_TYPE_NULL, "TYPE83", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2347 {LDNS_RR_TYPE_NULL, "TYPE84", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2348 {LDNS_RR_TYPE_NULL, "TYPE85", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2349 {LDNS_RR_TYPE_NULL, "TYPE86", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2350 {LDNS_RR_TYPE_NULL, "TYPE87", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2351 {LDNS_RR_TYPE_NULL, "TYPE88", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2352 {LDNS_RR_TYPE_NULL, "TYPE89", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2353 {LDNS_RR_TYPE_NULL, "TYPE90", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2354 {LDNS_RR_TYPE_NULL, "TYPE91", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2355 {LDNS_RR_TYPE_NULL, "TYPE92", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2356 {LDNS_RR_TYPE_NULL, "TYPE93", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2357 {LDNS_RR_TYPE_NULL, "TYPE94", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2358 {LDNS_RR_TYPE_NULL, "TYPE95", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2359 {LDNS_RR_TYPE_NULL, "TYPE96", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2360 {LDNS_RR_TYPE_NULL, "TYPE97", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2361 {LDNS_RR_TYPE_NULL, "TYPE98", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2362
2363 /* 99 */
2364 {LDNS_RR_TYPE_SPF, "SPF", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
2365
2366 /* UINFO [IANA-Reserved] */
2367 {LDNS_RR_TYPE_NULL, "TYPE100", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2368 /* UID [IANA-Reserved] */
2369 {LDNS_RR_TYPE_NULL, "TYPE101", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2370 /* GID [IANA-Reserved] */
2371 {LDNS_RR_TYPE_NULL, "TYPE102", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2372 /* UNSPEC [IANA-Reserved] */
2373 {LDNS_RR_TYPE_NULL, "TYPE103", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2374
2375 /* 104 */
2376 {LDNS_RR_TYPE_NID, "NID", 2, 2, type_nid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2377 /* 105 */
2378 {LDNS_RR_TYPE_L32, "L32", 2, 2, type_l32_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2379 /* 106 */
2380 {LDNS_RR_TYPE_L64, "L64", 2, 2, type_l64_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2381 /* 107 */
2382 {LDNS_RR_TYPE_LP, "LP", 2, 2, type_lp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2383 /* 108 */
2384 {LDNS_RR_TYPE_EUI48, "EUI48", 1, 1, type_eui48_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2385 /* 109 */
2386 {LDNS_RR_TYPE_EUI64, "EUI64", 1, 1, type_eui64_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2387
2388 {LDNS_RR_TYPE_NULL, "TYPE110", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2389 {LDNS_RR_TYPE_NULL, "TYPE111", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2390 {LDNS_RR_TYPE_NULL, "TYPE112", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2391 {LDNS_RR_TYPE_NULL, "TYPE113", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2392 {LDNS_RR_TYPE_NULL, "TYPE114", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2393 {LDNS_RR_TYPE_NULL, "TYPE115", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2394 {LDNS_RR_TYPE_NULL, "TYPE116", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2395 {LDNS_RR_TYPE_NULL, "TYPE117", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2396 {LDNS_RR_TYPE_NULL, "TYPE118", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2397 {LDNS_RR_TYPE_NULL, "TYPE119", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2398 {LDNS_RR_TYPE_NULL, "TYPE120", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2399 {LDNS_RR_TYPE_NULL, "TYPE121", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2400 {LDNS_RR_TYPE_NULL, "TYPE122", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2401 {LDNS_RR_TYPE_NULL, "TYPE123", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2402 {LDNS_RR_TYPE_NULL, "TYPE124", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2403 {LDNS_RR_TYPE_NULL, "TYPE125", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2404 {LDNS_RR_TYPE_NULL, "TYPE126", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2405 {LDNS_RR_TYPE_NULL, "TYPE127", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2406 {LDNS_RR_TYPE_NXNAME, "NXNAME", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2407 {LDNS_RR_TYPE_NULL, "TYPE129", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2408 {LDNS_RR_TYPE_NULL, "TYPE130", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2409 {LDNS_RR_TYPE_NULL, "TYPE131", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2410 {LDNS_RR_TYPE_NULL, "TYPE132", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2411 {LDNS_RR_TYPE_NULL, "TYPE133", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2412 {LDNS_RR_TYPE_NULL, "TYPE134", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2413 {LDNS_RR_TYPE_NULL, "TYPE135", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2414 {LDNS_RR_TYPE_NULL, "TYPE136", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2415 {LDNS_RR_TYPE_NULL, "TYPE137", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2416 {LDNS_RR_TYPE_NULL, "TYPE138", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2417 {LDNS_RR_TYPE_NULL, "TYPE139", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2418 {LDNS_RR_TYPE_NULL, "TYPE140", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2419 {LDNS_RR_TYPE_NULL, "TYPE141", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2420 {LDNS_RR_TYPE_NULL, "TYPE142", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2421 {LDNS_RR_TYPE_NULL, "TYPE143", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2422 {LDNS_RR_TYPE_NULL, "TYPE144", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2423 {LDNS_RR_TYPE_NULL, "TYPE145", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2424 {LDNS_RR_TYPE_NULL, "TYPE146", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2425 {LDNS_RR_TYPE_NULL, "TYPE147", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2426 {LDNS_RR_TYPE_NULL, "TYPE148", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2427 {LDNS_RR_TYPE_NULL, "TYPE149", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2428 {LDNS_RR_TYPE_NULL, "TYPE150", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2429 {LDNS_RR_TYPE_NULL, "TYPE151", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2430 {LDNS_RR_TYPE_NULL, "TYPE152", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2431 {LDNS_RR_TYPE_NULL, "TYPE153", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2432 {LDNS_RR_TYPE_NULL, "TYPE154", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2433 {LDNS_RR_TYPE_NULL, "TYPE155", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2434 {LDNS_RR_TYPE_NULL, "TYPE156", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2435 {LDNS_RR_TYPE_NULL, "TYPE157", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2436 {LDNS_RR_TYPE_NULL, "TYPE158", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2437 {LDNS_RR_TYPE_NULL, "TYPE159", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2438 {LDNS_RR_TYPE_NULL, "TYPE160", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2439 {LDNS_RR_TYPE_NULL, "TYPE161", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2440 {LDNS_RR_TYPE_NULL, "TYPE162", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2441 {LDNS_RR_TYPE_NULL, "TYPE163", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2442 {LDNS_RR_TYPE_NULL, "TYPE164", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2443 {LDNS_RR_TYPE_NULL, "TYPE165", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2444 {LDNS_RR_TYPE_NULL, "TYPE166", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2445 {LDNS_RR_TYPE_NULL, "TYPE167", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2446 {LDNS_RR_TYPE_NULL, "TYPE168", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2447 {LDNS_RR_TYPE_NULL, "TYPE169", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2448 {LDNS_RR_TYPE_NULL, "TYPE170", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2449 {LDNS_RR_TYPE_NULL, "TYPE171", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2450 {LDNS_RR_TYPE_NULL, "TYPE172", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2451 {LDNS_RR_TYPE_NULL, "TYPE173", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2452 {LDNS_RR_TYPE_NULL, "TYPE174", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2453 {LDNS_RR_TYPE_NULL, "TYPE175", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2454 {LDNS_RR_TYPE_NULL, "TYPE176", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2455 {LDNS_RR_TYPE_NULL, "TYPE177", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2456 {LDNS_RR_TYPE_NULL, "TYPE178", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2457 {LDNS_RR_TYPE_NULL, "TYPE179", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2458 {LDNS_RR_TYPE_NULL, "TYPE180", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2459 {LDNS_RR_TYPE_NULL, "TYPE181", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2460 {LDNS_RR_TYPE_NULL, "TYPE182", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2461 {LDNS_RR_TYPE_NULL, "TYPE183", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2462 {LDNS_RR_TYPE_NULL, "TYPE184", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2463 {LDNS_RR_TYPE_NULL, "TYPE185", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2464 {LDNS_RR_TYPE_NULL, "TYPE186", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2465 {LDNS_RR_TYPE_NULL, "TYPE187", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2466 {LDNS_RR_TYPE_NULL, "TYPE188", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2467 {LDNS_RR_TYPE_NULL, "TYPE189", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2468 {LDNS_RR_TYPE_NULL, "TYPE190", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2469 {LDNS_RR_TYPE_NULL, "TYPE191", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2470 {LDNS_RR_TYPE_NULL, "TYPE192", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2471 {LDNS_RR_TYPE_NULL, "TYPE193", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2472 {LDNS_RR_TYPE_NULL, "TYPE194", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2473 {LDNS_RR_TYPE_NULL, "TYPE195", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2474 {LDNS_RR_TYPE_NULL, "TYPE196", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2475 {LDNS_RR_TYPE_NULL, "TYPE197", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2476 {LDNS_RR_TYPE_NULL, "TYPE198", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2477 {LDNS_RR_TYPE_NULL, "TYPE199", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2478 {LDNS_RR_TYPE_NULL, "TYPE200", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2479 {LDNS_RR_TYPE_NULL, "TYPE201", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2480 {LDNS_RR_TYPE_NULL, "TYPE202", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2481 {LDNS_RR_TYPE_NULL, "TYPE203", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2482 {LDNS_RR_TYPE_NULL, "TYPE204", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2483 {LDNS_RR_TYPE_NULL, "TYPE205", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2484 {LDNS_RR_TYPE_NULL, "TYPE206", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2485 {LDNS_RR_TYPE_NULL, "TYPE207", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2486 {LDNS_RR_TYPE_NULL, "TYPE208", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2487 {LDNS_RR_TYPE_NULL, "TYPE209", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2488 {LDNS_RR_TYPE_NULL, "TYPE210", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2489 {LDNS_RR_TYPE_NULL, "TYPE211", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2490 {LDNS_RR_TYPE_NULL, "TYPE212", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2491 {LDNS_RR_TYPE_NULL, "TYPE213", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2492 {LDNS_RR_TYPE_NULL, "TYPE214", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2493 {LDNS_RR_TYPE_NULL, "TYPE215", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2494 {LDNS_RR_TYPE_NULL, "TYPE216", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2495 {LDNS_RR_TYPE_NULL, "TYPE217", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2496 {LDNS_RR_TYPE_NULL, "TYPE218", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2497 {LDNS_RR_TYPE_NULL, "TYPE219", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2498 {LDNS_RR_TYPE_NULL, "TYPE220", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2499 {LDNS_RR_TYPE_NULL, "TYPE221", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2500 {LDNS_RR_TYPE_NULL, "TYPE222", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2501 {LDNS_RR_TYPE_NULL, "TYPE223", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2502 {LDNS_RR_TYPE_NULL, "TYPE224", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2503 {LDNS_RR_TYPE_NULL, "TYPE225", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2504 {LDNS_RR_TYPE_NULL, "TYPE226", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2505 {LDNS_RR_TYPE_NULL, "TYPE227", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2506 {LDNS_RR_TYPE_NULL, "TYPE228", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2507 {LDNS_RR_TYPE_NULL, "TYPE229", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2508 {LDNS_RR_TYPE_NULL, "TYPE230", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2509 {LDNS_RR_TYPE_NULL, "TYPE231", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2510 {LDNS_RR_TYPE_NULL, "TYPE232", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2511 {LDNS_RR_TYPE_NULL, "TYPE233", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2512 {LDNS_RR_TYPE_NULL, "TYPE234", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2513 {LDNS_RR_TYPE_NULL, "TYPE235", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2514 {LDNS_RR_TYPE_NULL, "TYPE236", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2515 {LDNS_RR_TYPE_NULL, "TYPE237", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2516 {LDNS_RR_TYPE_NULL, "TYPE238", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2517 {LDNS_RR_TYPE_NULL, "TYPE239", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2518 {LDNS_RR_TYPE_NULL, "TYPE240", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2519 {LDNS_RR_TYPE_NULL, "TYPE241", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2520 {LDNS_RR_TYPE_NULL, "TYPE242", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2521 {LDNS_RR_TYPE_NULL, "TYPE243", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2522 {LDNS_RR_TYPE_NULL, "TYPE244", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2523 {LDNS_RR_TYPE_NULL, "TYPE245", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2524 {LDNS_RR_TYPE_NULL, "TYPE246", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2525 {LDNS_RR_TYPE_NULL, "TYPE247", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2526 {LDNS_RR_TYPE_NULL, "TYPE248", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2527
2528 /* LDNS_RDF_TYPE_INT16_DATA takes two fields (length and data) as one.
2529 * So, unlike RFC 2930 spec, we have 7 min/max rdf's i.s.o. 8/9.
2530 */
2531 /* 249 */
2532 {LDNS_RR_TYPE_TKEY, "TKEY", 7, 7, type_tkey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2533 /* LDNS_RDF_TYPE_INT16_DATA takes two fields (length and data) as one.
2534 * So, unlike RFC 2930 spec, we have 7 min/max rdf's i.s.o. 8/9.
2535 */
2536 /* 250 */
2537 {LDNS_RR_TYPE_TSIG, "TSIG", 7, 7, type_tsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
2538
2539 /* IXFR: A request for a transfer of an incremental zone transfer */
2540 {LDNS_RR_TYPE_NULL, "TYPE251", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2541 /* AXFR: A request for a transfer of an entire zone */
2542 {LDNS_RR_TYPE_NULL, "TYPE252", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2543 /* MAILB: A request for mailbox-related records (MB, MG or MR) */
2544 {LDNS_RR_TYPE_NULL, "TYPE253", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2545 /* MAILA: A request for mail agent RRs (Obsolete - see MX) */
2546 {LDNS_RR_TYPE_NULL, "TYPE254", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2547 /* ANY: A request for all (available) records */
2548 {LDNS_RR_TYPE_NULL, "TYPE255", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2549
2550 /* 256 */
2551 {LDNS_RR_TYPE_URI, "URI", 3, 3, type_uri_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2552 /* 257 */
2553 {LDNS_RR_TYPE_CAA, "CAA", 3, 3, type_caa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2554
2555 #ifdef RRTYPE_AVC
2556 /* 258 */
2557 {LDNS_RR_TYPE_AVC, "AVC", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
2558 #else
2559 {LDNS_RR_TYPE_NULL, "TYPE258", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2560 #endif
2561 #ifdef RRTYPE_DOA
2562 /* 259 */
2563 {LDNS_RR_TYPE_DOA, "DOA", 5, 5, type_doa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2564 #else
2565 {LDNS_RR_TYPE_NULL, "TYPE259", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2566 #endif
2567 #ifdef RRTYPE_AMTRELAY
2568 /* 260 */
2569 {LDNS_RR_TYPE_AMTRELAY, "AMTRELAY", 1, 1, type_amtrelay_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2570 #else
2571 {LDNS_RR_TYPE_NULL, "TYPE260", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2572 #endif
2573 #ifdef RRTYPE_RESINFO
2574 /* 261 */
2575 {LDNS_RR_TYPE_RESINFO, "RESINFO", 1, 0, NULL, LDNS_RDF_TYPE_UNQUOTED, LDNS_RR_NO_COMPRESS, 0 },
2576 #else
2577 {LDNS_RR_TYPE_NULL, "TYPE261", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2578 #endif
2579 /* 262 */
2580 {LDNS_RR_TYPE_WALLET, "WALLET", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
2581 #ifdef RRTYPE_CLA_IPN
2582 /* 263 */
2583 {LDNS_RR_TYPE_CLA, "CLA", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
2584 /* 264 */
2585 {LDNS_RR_TYPE_IPN, "IPN", 1, 1, type_ipn_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2586 #else
2587 {LDNS_RR_TYPE_NULL, "TYPE263", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2588 {LDNS_RR_TYPE_NULL, "TYPE264", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2589 #endif
2590 /* split in array, no longer contiguous */
2591
2592 #ifdef RRTYPE_TA
2593 /* 32768 */
2594 {LDNS_RR_TYPE_TA, "TA", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2595 #else
2596 {LDNS_RR_TYPE_NULL, "TYPE32768", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2597 #endif
2598 /* 32769 */
2599 {LDNS_RR_TYPE_DLV, "DLV", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }
2600 };
2601 /** \endcond */
2602
2603 /**
2604 * \def LDNS_RDATA_FIELD_DESCRIPTORS_COUNT
2605 * computes the number of rdata fields
2606 */
2607 #define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \
2608 (sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0]))
2609
2610
2611 /*---------------------------------------------------------------------------*
2612 * The functions below return an bitmap RDF with the space required to set
2613 * or unset all known RR types. Arguably these functions are better situated
2614 * in rdata.c, however for the space calculation it is necessary to walk
2615 * through rdata_field_descriptors which is not easily possible from anywhere
2616 * other than rr.c where it is declared static.
2617 *
2618 * Alternatively rr.c could have provided an iterator for rr_type or
2619 * rdf_descriptors, but this seemed overkill for internal use only.
2620 */
2621 static ldns_rr_descriptor* rdata_field_descriptors_end =
2622 &rdata_field_descriptors[LDNS_RDATA_FIELD_DESCRIPTORS_COUNT];
2623
2624 /* From RFC3845:
2625 *
2626 * 2.1.2. The List of Type Bit Map(s) Field
2627 *
2628 * The RR type space is split into 256 window blocks, each representing
2629 * the low-order 8 bits of the 16-bit RR type space. Each block that
2630 * has at least one active RR type is encoded using a single octet
2631 * window number (from 0 to 255), a single octet bitmap length (from 1
2632 * to 32) indicating the number of octets used for the window block's
2633 * bitmap, and up to 32 octets (256 bits) of bitmap.
2634 *
2635 * Window blocks are present in the NSEC RR RDATA in increasing
2636 * numerical order.
2637 *
2638 * "|" denotes concatenation
2639 *
2640 * Type Bit Map(s) Field = ( Window Block # | Bitmap Length | Bitmap ) +
2641 *
2642 * <cut>
2643 *
2644 * Blocks with no types present MUST NOT be included. Trailing zero
2645 * octets in the bitmap MUST be omitted. The length of each block's
2646 * bitmap is determined by the type code with the largest numerical
2647 * value within that block, among the set of RR types present at the
2648 * NSEC RR's owner name. Trailing zero octets not specified MUST be
2649 * interpreted as zero octets.
2650 */
2651 static ldns_status
ldns_rdf_bitmap_known_rr_types_set(ldns_rdf ** rdf,int value)2652 ldns_rdf_bitmap_known_rr_types_set(ldns_rdf** rdf, int value)
2653 {
2654 uint8_t window; /* most significant octet of type */
2655 uint8_t subtype; /* least significant octet of type */
2656 uint16_t windows[256] /* Max subtype per window */
2657 #ifndef S_SPLINT_S
2658 = { 0 }
2659 #endif
2660 ;
2661 ldns_rr_descriptor* d; /* used to traverse rdata_field_descriptors */
2662 size_t i; /* used to traverse windows array */
2663
2664 size_t sz; /* size needed for type bitmap rdf */
2665 uint8_t* data = NULL; /* rdf data */
2666 uint8_t* dptr; /* used to itraverse rdf data */
2667
2668 assert(rdf != NULL);
2669
2670 /* Which windows need to be in the bitmap rdf?
2671 */
2672 for (d=rdata_field_descriptors; d < rdata_field_descriptors_end; d++) {
2673 window = d->_type >> 8;
2674 subtype = d->_type & 0xff;
2675
2676 /* In the code below, windows[window] == 0 means that the
2677 * window is not in use. So subtype == 0 is a problem. The
2678 * easiest solution is to set subtype to 1, that marks the
2679 * window as in use and doesn't have negative effects.
2680 */
2681 if (subtype == 0)
2682 subtype = 1;
2683 if (windows[window] < subtype) {
2684 windows[window] = subtype;
2685 }
2686 }
2687
2688 /* How much space do we need in the rdf for those windows?
2689 */
2690 sz = 0;
2691 for (i = 0; i < 256; i++) {
2692 if (windows[i]) {
2693 sz += windows[i] / 8 + 3;
2694 }
2695 }
2696 if (sz > 0) {
2697 /* Format rdf data according RFC3845 Section 2.1.2 (see above)
2698 */
2699 dptr = data = LDNS_XMALLOC(uint8_t, sz);
2700 if (!data) {
2701 return LDNS_STATUS_MEM_ERR;
2702 }
2703 memset(data, value, sz);
2704 for (i = 0; i < 256; i++) {
2705 if (windows[i]) {
2706 *dptr++ = (uint8_t)i;
2707 *dptr++ = (uint8_t)(windows[i] / 8 + 1);
2708 dptr += dptr[-1];
2709 }
2710 }
2711 }
2712 /* Allocate and return rdf structure for the data
2713 */
2714 *rdf = ldns_rdf_new(LDNS_RDF_TYPE_BITMAP, sz, data);
2715 if (!*rdf) {
2716 LDNS_FREE(data);
2717 return LDNS_STATUS_MEM_ERR;
2718 }
2719 return LDNS_STATUS_OK;
2720 }
2721
2722 ldns_status
ldns_rdf_bitmap_known_rr_types_space(ldns_rdf ** rdf)2723 ldns_rdf_bitmap_known_rr_types_space(ldns_rdf** rdf)
2724 {
2725 return ldns_rdf_bitmap_known_rr_types_set(rdf, 0);
2726 }
2727
2728 ldns_status
ldns_rdf_bitmap_known_rr_types(ldns_rdf ** rdf)2729 ldns_rdf_bitmap_known_rr_types(ldns_rdf** rdf)
2730 {
2731 return ldns_rdf_bitmap_known_rr_types_set(rdf, 255);
2732 }
2733 /* End of RDF bitmap functions
2734 *---------------------------------------------------------------------------*/
2735
2736
2737 const ldns_rr_descriptor *
ldns_rr_descript(uint16_t type)2738 ldns_rr_descript(uint16_t type)
2739 {
2740 size_t i;
2741 if (type < LDNS_RDATA_FIELD_DESCRIPTORS_COMMON) {
2742 return &rdata_field_descriptors[type];
2743 } else {
2744 /* because not all array index equals type code */
2745 for (i = LDNS_RDATA_FIELD_DESCRIPTORS_COMMON;
2746 i < LDNS_RDATA_FIELD_DESCRIPTORS_COUNT;
2747 i++) {
2748 if (rdata_field_descriptors[i]._type == type) {
2749 return &rdata_field_descriptors[i];
2750 }
2751 }
2752 return &rdata_field_descriptors[0];
2753 }
2754 }
2755
2756 size_t
ldns_rr_descriptor_minimum(const ldns_rr_descriptor * descriptor)2757 ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor)
2758 {
2759 if (descriptor) {
2760 return descriptor->_minimum;
2761 } else {
2762 return 0;
2763 }
2764 }
2765
2766 size_t
ldns_rr_descriptor_maximum(const ldns_rr_descriptor * descriptor)2767 ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor)
2768 {
2769 if (descriptor) {
2770 if (descriptor->_variable != LDNS_RDF_TYPE_NONE) {
2771 /* Should really be SIZE_MAX... bad FreeBSD. */
2772 return UINT_MAX;
2773 } else {
2774 return descriptor->_maximum;
2775 }
2776 } else {
2777 return 0;
2778 }
2779 }
2780
2781 ldns_rdf_type
ldns_rr_descriptor_field_type(const ldns_rr_descriptor * descriptor,size_t index)2782 ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor,
2783 size_t index)
2784 {
2785 assert(descriptor != NULL);
2786 assert(index < descriptor->_maximum
2787 || descriptor->_variable != LDNS_RDF_TYPE_NONE);
2788 if (index < descriptor->_maximum) {
2789 return descriptor->_wireformat[index];
2790 } else {
2791 return descriptor->_variable;
2792 }
2793 }
2794
2795 ldns_rr_type
ldns_get_rr_type_by_name(const char * name)2796 ldns_get_rr_type_by_name(const char *name)
2797 {
2798 unsigned int i;
2799 const char *desc_name;
2800 const ldns_rr_descriptor *desc;
2801
2802 /* TYPEXX representation */
2803 if (strlen(name) > 4 && strncasecmp(name, "TYPE", 4) == 0) {
2804 return atoi(name + 4);
2805 }
2806
2807 /* Normal types */
2808 for (i = 0; i < (unsigned int) LDNS_RDATA_FIELD_DESCRIPTORS_COUNT; i++) {
2809 desc = &rdata_field_descriptors[i];
2810 desc_name = desc->_name;
2811 if(desc_name &&
2812 strlen(name) == strlen(desc_name) &&
2813 strncasecmp(name, desc_name, strlen(desc_name)) == 0) {
2814 /* because not all array index equals type code */
2815 return desc->_type;
2816 }
2817 }
2818
2819 /* special cases for query types */
2820 if (strlen(name) == 4 && strncasecmp(name, "IXFR", 4) == 0) {
2821 return 251;
2822 } else if (strlen(name) == 4 && strncasecmp(name, "AXFR", 4) == 0) {
2823 return 252;
2824 } else if (strlen(name) == 5 && strncasecmp(name, "MAILB", 5) == 0) {
2825 return 253;
2826 } else if (strlen(name) == 5 && strncasecmp(name, "MAILA", 5) == 0) {
2827 return 254;
2828 } else if (strlen(name) == 3 && strncasecmp(name, "ANY", 3) == 0) {
2829 return 255;
2830 }
2831
2832 return 0;
2833 }
2834
2835 ldns_rr_class
ldns_get_rr_class_by_name(const char * name)2836 ldns_get_rr_class_by_name(const char *name)
2837 {
2838 ldns_lookup_table *lt;
2839
2840 /* CLASSXX representation */
2841 if (strlen(name) > 5 && strncasecmp(name, "CLASS", 5) == 0) {
2842 return atoi(name + 5);
2843 }
2844
2845 /* Normal types */
2846 lt = ldns_lookup_by_name(ldns_rr_classes, name);
2847
2848 if (lt) {
2849 return lt->id;
2850 }
2851 return 0;
2852 }
2853
2854
2855 ldns_rr_type
ldns_rdf2rr_type(const ldns_rdf * rd)2856 ldns_rdf2rr_type(const ldns_rdf *rd)
2857 {
2858 ldns_rr_type r;
2859
2860 if (!rd) {
2861 return 0;
2862 }
2863
2864 if (ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_TYPE) {
2865 return 0;
2866 }
2867
2868 r = (ldns_rr_type) ldns_rdf2native_int16(rd);
2869 return r;
2870 }
2871
2872 ldns_rr_type
ldns_rr_list_type(const ldns_rr_list * rr_list)2873 ldns_rr_list_type(const ldns_rr_list *rr_list)
2874 {
2875 if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) {
2876 return ldns_rr_get_type(ldns_rr_list_rr(rr_list, 0));
2877 } else {
2878 return 0;
2879 }
2880 }
2881
2882 ldns_rdf *
ldns_rr_list_owner(const ldns_rr_list * rr_list)2883 ldns_rr_list_owner(const ldns_rr_list *rr_list)
2884 {
2885 if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) {
2886 return ldns_rr_owner(ldns_rr_list_rr(rr_list, 0));
2887 } else {
2888 return NULL;
2889 }
2890 }
2891