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