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