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