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