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