1 /* 2 * host2str.c 3 * 4 * conversion routines from the host format 5 * to the presentation format (strings) 6 * 7 * a Net::DNS like library for C 8 * 9 * (c) NLnet Labs, 2004-2006 10 * 11 * See the file LICENSE for the license 12 */ 13 #include <ldns/config.h> 14 15 #include <ldns/ldns.h> 16 #include <ldns/internal.h> 17 18 #include <limits.h> 19 20 #ifdef HAVE_SYS_SOCKET_H 21 #include <sys/socket.h> 22 #endif 23 #ifdef HAVE_ARPA_INET_H 24 #include <arpa/inet.h> 25 #endif 26 #ifdef HAVE_NETDB_H 27 #include <netdb.h> 28 #endif 29 #include <time.h> 30 #include <sys/time.h> 31 32 #ifdef HAVE_SSL 33 #include <openssl/bn.h> 34 #include <openssl/rsa.h> 35 #ifdef USE_DSA 36 #include <openssl/dsa.h> 37 #endif 38 #endif 39 40 #ifndef INET_ADDRSTRLEN 41 #define INET_ADDRSTRLEN 16 42 #endif 43 #ifndef INET6_ADDRSTRLEN 44 #define INET6_ADDRSTRLEN 46 45 #endif 46 47 /* lookup tables for standard DNS stuff */ 48 49 /* Taken from RFC 2535, section 7. */ 50 ldns_lookup_table ldns_algorithms[] = { 51 { LDNS_RSAMD5, "RSAMD5" }, 52 { LDNS_DH, "DH" }, 53 { LDNS_DSA, "DSA" }, 54 { LDNS_ECC, "ECC" }, 55 { LDNS_RSASHA1, "RSASHA1" }, 56 { LDNS_DSA_NSEC3, "DSA-NSEC3-SHA1" }, 57 { LDNS_RSASHA1_NSEC3, "RSASHA1-NSEC3-SHA1" }, 58 { LDNS_RSASHA256, "RSASHA256"}, 59 { LDNS_RSASHA512, "RSASHA512"}, 60 { LDNS_ECC_GOST, "ECC-GOST"}, 61 { LDNS_ECDSAP256SHA256, "ECDSAP256SHA256"}, 62 { LDNS_ECDSAP384SHA384, "ECDSAP384SHA384"}, 63 { LDNS_ED25519, "ED25519"}, 64 { LDNS_ED448, "ED448"}, 65 { LDNS_INDIRECT, "INDIRECT" }, 66 { LDNS_PRIVATEDNS, "PRIVATEDNS" }, 67 { LDNS_PRIVATEOID, "PRIVATEOID" }, 68 { 0, NULL } 69 }; 70 71 /* Hashing algorithms used in the DS record */ 72 ldns_lookup_table ldns_hashes[] = { 73 {LDNS_SHA1 , "SHA1" }, /* RFC 4034 */ 74 {LDNS_SHA256 , "SHA256" }, /* RFC 4509 */ 75 {LDNS_HASH_GOST, "HASH-GOST" }, /* RFC 5933 */ 76 {LDNS_SHA384 , "SHA384" }, /* RFC 6605 */ 77 { 0, NULL } 78 }; 79 80 /* Taken from RFC 4398 */ 81 ldns_lookup_table ldns_cert_algorithms[] = { 82 { LDNS_CERT_PKIX, "PKIX" }, 83 { LDNS_CERT_SPKI, "SPKI" }, 84 { LDNS_CERT_PGP, "PGP" }, 85 { LDNS_CERT_IPKIX, "IPKIX" }, 86 { LDNS_CERT_ISPKI, "ISPKI" }, 87 { LDNS_CERT_IPGP, "IPGP" }, 88 { LDNS_CERT_ACPKIX, "ACPKIX" }, 89 { LDNS_CERT_IACPKIX, "IACPKIX" }, 90 { LDNS_CERT_URI, "URI" }, 91 { LDNS_CERT_OID, "OID" }, 92 { 0, NULL } 93 }; 94 95 /* classes */ 96 ldns_lookup_table ldns_rr_classes[] = { 97 { LDNS_RR_CLASS_IN, "IN" }, 98 { LDNS_RR_CLASS_CH, "CH" }, 99 { LDNS_RR_CLASS_HS, "HS" }, 100 { LDNS_RR_CLASS_NONE, "NONE" }, 101 { LDNS_RR_CLASS_ANY, "ANY" }, 102 { 0, NULL } 103 }; 104 105 /* if these are used elsewhere */ 106 ldns_lookup_table ldns_rcodes[] = { 107 { LDNS_RCODE_NOERROR, "NOERROR" }, 108 { LDNS_RCODE_FORMERR, "FORMERR" }, 109 { LDNS_RCODE_SERVFAIL, "SERVFAIL" }, 110 { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" }, 111 { LDNS_RCODE_NOTIMPL, "NOTIMPL" }, 112 { LDNS_RCODE_REFUSED, "REFUSED" }, 113 { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" }, 114 { LDNS_RCODE_YXRRSET, "YXRRSET" }, 115 { LDNS_RCODE_NXRRSET, "NXRRSET" }, 116 { LDNS_RCODE_NOTAUTH, "NOTAUTH" }, 117 { LDNS_RCODE_NOTZONE, "NOTZONE" }, 118 { 0, NULL } 119 }; 120 121 ldns_lookup_table ldns_opcodes[] = { 122 { LDNS_PACKET_QUERY, "QUERY" }, 123 { LDNS_PACKET_IQUERY, "IQUERY" }, 124 { LDNS_PACKET_STATUS, "STATUS" }, 125 { LDNS_PACKET_NOTIFY, "NOTIFY" }, 126 { LDNS_PACKET_UPDATE, "UPDATE" }, 127 { 0, NULL } 128 }; 129 130 const ldns_output_format ldns_output_format_nocomments_record = { 0, NULL }; 131 const ldns_output_format *ldns_output_format_nocomments 132 = &ldns_output_format_nocomments_record; 133 const ldns_output_format ldns_output_format_onlykeyids_record = { 134 LDNS_COMMENT_KEY, NULL 135 }; 136 const ldns_output_format *ldns_output_format_onlykeyids 137 = &ldns_output_format_onlykeyids_record; 138 const ldns_output_format *ldns_output_format_default 139 = &ldns_output_format_onlykeyids_record; 140 141 const ldns_output_format ldns_output_format_bubblebabble_record = { 142 LDNS_COMMENT_KEY | LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS, NULL 143 }; 144 const ldns_output_format *ldns_output_format_bubblebabble 145 = &ldns_output_format_bubblebabble_record; 146 147 static bool 148 ldns_output_format_covers_type(const ldns_output_format* fmt, ldns_rr_type t) 149 { 150 return fmt && (fmt->flags & LDNS_FMT_RFC3597) && 151 ((ldns_output_format_storage*)fmt)->bitmap && 152 ldns_nsec_bitmap_covers_type( 153 ((ldns_output_format_storage*)fmt)->bitmap, t); 154 } 155 156 ldns_status 157 ldns_output_format_set_type(ldns_output_format* fmt, ldns_rr_type t) 158 { 159 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt; 160 ldns_status s; 161 162 assert(fmt != NULL); 163 164 if (!(fmt_st->flags & LDNS_FMT_RFC3597)) { 165 ldns_output_format_set(fmt, LDNS_FMT_RFC3597); 166 } 167 if (! fmt_st->bitmap) { 168 s = ldns_rdf_bitmap_known_rr_types_space(&fmt_st->bitmap); 169 if (s != LDNS_STATUS_OK) { 170 return s; 171 } 172 } 173 return ldns_nsec_bitmap_set_type(fmt_st->bitmap, t); 174 } 175 176 ldns_status 177 ldns_output_format_clear_type(ldns_output_format* fmt, ldns_rr_type t) 178 { 179 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt; 180 ldns_status s; 181 182 assert(fmt != NULL); 183 184 if (!(fmt_st->flags & LDNS_FMT_RFC3597)) { 185 ldns_output_format_set(fmt, LDNS_FMT_RFC3597); 186 } 187 if (! fmt_st->bitmap) { 188 s = ldns_rdf_bitmap_known_rr_types(&fmt_st->bitmap); 189 if (s != LDNS_STATUS_OK) { 190 return s; 191 } 192 } 193 return ldns_nsec_bitmap_clear_type(fmt_st->bitmap, t); 194 } 195 196 ldns_status 197 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode) 198 { 199 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode); 200 if (lt && lt->name) { 201 ldns_buffer_printf(output, "%s", lt->name); 202 } else { 203 ldns_buffer_printf(output, "OPCODE%u", opcode); 204 } 205 return ldns_buffer_status(output); 206 } 207 208 ldns_status 209 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode) 210 { 211 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode); 212 if (lt && lt->name) { 213 ldns_buffer_printf(output, "%s", lt->name); 214 } else { 215 ldns_buffer_printf(output, "RCODE%u", rcode); 216 } 217 return ldns_buffer_status(output); 218 } 219 220 ldns_status 221 ldns_algorithm2buffer_str(ldns_buffer *output, 222 ldns_algorithm algorithm) 223 { 224 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_algorithms, 225 algorithm); 226 if (lt && lt->name) { 227 ldns_buffer_printf(output, "%s", lt->name); 228 } else { 229 ldns_buffer_printf(output, "ALG%u", algorithm); 230 } 231 return ldns_buffer_status(output); 232 } 233 234 ldns_status 235 ldns_cert_algorithm2buffer_str(ldns_buffer *output, 236 ldns_cert_algorithm cert_algorithm) 237 { 238 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_cert_algorithms, 239 cert_algorithm); 240 if (lt && lt->name) { 241 ldns_buffer_printf(output, "%s", lt->name); 242 } else { 243 ldns_buffer_printf(output, "CERT_ALG%u", 244 cert_algorithm); 245 } 246 return ldns_buffer_status(output); 247 } 248 249 char * 250 ldns_pkt_opcode2str(ldns_pkt_opcode opcode) 251 { 252 char *str; 253 ldns_buffer *buf; 254 255 buf = ldns_buffer_new(12); 256 if (!buf) { 257 return NULL; 258 } 259 260 str = NULL; 261 if (ldns_pkt_opcode2buffer_str(buf, opcode) == LDNS_STATUS_OK) { 262 str = ldns_buffer_export2str(buf); 263 } 264 265 ldns_buffer_free(buf); 266 return str; 267 } 268 269 char * 270 ldns_pkt_rcode2str(ldns_pkt_rcode rcode) 271 { 272 char *str; 273 ldns_buffer *buf; 274 275 buf = ldns_buffer_new(10); 276 if (!buf) { 277 return NULL; 278 } 279 280 str = NULL; 281 if (ldns_pkt_rcode2buffer_str(buf, rcode) == LDNS_STATUS_OK) { 282 str = ldns_buffer_export2str(buf); 283 } 284 285 ldns_buffer_free(buf); 286 return str; 287 } 288 289 char * 290 ldns_pkt_algorithm2str(ldns_algorithm algorithm) 291 { 292 char *str; 293 ldns_buffer *buf; 294 295 buf = ldns_buffer_new(10); 296 if (!buf) { 297 return NULL; 298 } 299 300 str = NULL; 301 if (ldns_algorithm2buffer_str(buf, algorithm) 302 == LDNS_STATUS_OK) { 303 str = ldns_buffer_export2str(buf); 304 } 305 306 ldns_buffer_free(buf); 307 return str; 308 } 309 310 char * 311 ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm) 312 { 313 char *str; 314 ldns_buffer *buf; 315 316 buf = ldns_buffer_new(10); 317 if (!buf) { 318 return NULL; 319 } 320 321 str = NULL; 322 if (ldns_cert_algorithm2buffer_str(buf, cert_algorithm) 323 == LDNS_STATUS_OK) { 324 str = ldns_buffer_export2str(buf); 325 } 326 327 ldns_buffer_free(buf); 328 return str; 329 } 330 331 332 /* do NOT pass compressed data here :p */ 333 ldns_status 334 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname) 335 { 336 /* can we do with 1 pos var? or without at all? */ 337 uint8_t src_pos = 0; 338 uint8_t len; 339 uint8_t *data; 340 uint8_t i; 341 unsigned char c; 342 343 data = (uint8_t*)ldns_rdf_data(dname); 344 len = data[src_pos]; 345 346 if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) { 347 /* too large, return */ 348 return LDNS_STATUS_DOMAINNAME_OVERFLOW; 349 } 350 351 /* special case: root label */ 352 if (1 == ldns_rdf_size(dname)) { 353 ldns_buffer_printf(output, "."); 354 } else { 355 while ((len > 0) && src_pos < ldns_rdf_size(dname)) { 356 src_pos++; 357 for(i = 0; i < len; i++) { 358 /* paranoia check for various 'strange' 359 characters in dnames 360 */ 361 c = (unsigned char) data[src_pos]; 362 if(c == '.' || c == ';' || 363 c == '(' || c == ')' || 364 c == '\\') { 365 ldns_buffer_printf(output, "\\%c", 366 data[src_pos]); 367 } else if (!(isascii(c) && isgraph(c))) { 368 ldns_buffer_printf(output, "\\%03u", 369 data[src_pos]); 370 } else { 371 ldns_buffer_printf(output, "%c", data[src_pos]); 372 } 373 src_pos++; 374 } 375 376 if (src_pos < ldns_rdf_size(dname)) { 377 ldns_buffer_printf(output, "."); 378 } 379 len = data[src_pos]; 380 } 381 } 382 return ldns_buffer_status(output); 383 } 384 385 ldns_status 386 ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf) 387 { 388 uint8_t data = ldns_rdf_data(rdf)[0]; 389 ldns_buffer_printf(output, "%lu", (unsigned long) data); 390 return ldns_buffer_status(output); 391 } 392 393 ldns_status 394 ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf) 395 { 396 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); 397 ldns_buffer_printf(output, "%lu", (unsigned long) data); 398 return ldns_buffer_status(output); 399 } 400 401 ldns_status 402 ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf) 403 { 404 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf)); 405 ldns_buffer_printf(output, "%lu", (unsigned long) data); 406 return ldns_buffer_status(output); 407 } 408 409 ldns_status 410 ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf) 411 { 412 /* create a YYYYMMDDHHMMSS string if possible */ 413 struct tm tm; 414 char date_buf[16]; 415 416 memset(&tm, 0, sizeof(tm)); 417 if (ldns_serial_arithmetics_gmtime_r(ldns_rdf2native_int32(rdf), time(NULL), &tm) 418 && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) { 419 ldns_buffer_printf(output, "%s", date_buf); 420 } 421 return ldns_buffer_status(output); 422 } 423 424 ldns_status 425 ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf) 426 { 427 char str[INET_ADDRSTRLEN]; 428 429 if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) { 430 ldns_buffer_printf(output, "%s", str); 431 } 432 return ldns_buffer_status(output); 433 } 434 435 ldns_status 436 ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf) 437 { 438 char str[INET6_ADDRSTRLEN]; 439 440 if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) { 441 ldns_buffer_printf(output, "%s", str); 442 } 443 444 return ldns_buffer_status(output); 445 } 446 447 static void 448 ldns_characters2buffer_str(ldns_buffer* output, 449 size_t amount, const uint8_t* characters) 450 { 451 uint8_t ch; 452 while (amount > 0) { 453 ch = *characters++; 454 if (isprint((int)ch) || ch == '\t') { 455 if (ch == '\"' || ch == '\\') 456 ldns_buffer_printf(output, "\\%c", ch); 457 else 458 ldns_buffer_printf(output, "%c", ch); 459 } else { 460 ldns_buffer_printf(output, "\\%03u", 461 (unsigned)(uint8_t) ch); 462 } 463 amount--; 464 } 465 } 466 467 ldns_status 468 ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf) 469 { 470 if(ldns_rdf_size(rdf) < 1) { 471 return LDNS_STATUS_WIRE_RDATA_ERR; 472 } 473 if((int)ldns_rdf_size(rdf) < (int)ldns_rdf_data(rdf)[0] + 1) { 474 return LDNS_STATUS_WIRE_RDATA_ERR; 475 } 476 ldns_buffer_printf(output, "\""); 477 ldns_characters2buffer_str(output, 478 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf) + 1); 479 ldns_buffer_printf(output, "\""); 480 return ldns_buffer_status(output); 481 } 482 483 ldns_status 484 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf) 485 { 486 size_t size; 487 char *b64; 488 489 if (ldns_rdf_size(rdf) == 0) { 490 ldns_buffer_printf(output, "0"); 491 return ldns_buffer_status(output); 492 } else 493 size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf)); 494 495 if (!(b64 = LDNS_XMALLOC(char, size))) 496 return LDNS_STATUS_MEM_ERR; 497 498 if (ldns_b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) { 499 ldns_buffer_printf(output, "%s", b64); 500 } 501 LDNS_FREE(b64); 502 return ldns_buffer_status(output); 503 } 504 505 ldns_status 506 ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf) 507 { 508 size_t size; 509 char *b32; 510 if(ldns_rdf_size(rdf) == 0) 511 return LDNS_STATUS_OK; 512 /* remove -1 for the b32-hash-len octet */ 513 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1); 514 /* add one for the end nul for the string */ 515 b32 = LDNS_XMALLOC(char, size + 1); 516 if(!b32) return LDNS_STATUS_MEM_ERR; 517 size = (size_t) ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1, 518 ldns_rdf_size(rdf) - 1, b32, size+1); 519 if (size > 0) { 520 ldns_buffer_printf(output, "%s", b32); 521 } 522 LDNS_FREE(b32); 523 return ldns_buffer_status(output); 524 } 525 526 ldns_status 527 ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf) 528 { 529 size_t i; 530 for (i = 0; i < ldns_rdf_size(rdf); i++) { 531 ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]); 532 } 533 534 return ldns_buffer_status(output); 535 } 536 537 static ldns_status 538 ldns_rdf2buffer_str_type_fmt(ldns_buffer *output, 539 const ldns_output_format* fmt, const ldns_rdf *rdf) 540 { 541 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); 542 543 if (! ldns_output_format_covers_type(fmt, data) && 544 ldns_rr_descript(data) && 545 ldns_rr_descript(data)->_name) { 546 547 ldns_buffer_printf(output, "%s",ldns_rr_descript(data)->_name); 548 } else { 549 ldns_buffer_printf(output, "TYPE%u", data); 550 } 551 return ldns_buffer_status(output); 552 } 553 554 ldns_status 555 ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf) 556 { 557 return ldns_rdf2buffer_str_type_fmt(output, 558 ldns_output_format_default, rdf); 559 } 560 561 ldns_status 562 ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf) 563 { 564 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); 565 ldns_lookup_table *lt; 566 567 lt = ldns_lookup_by_id(ldns_rr_classes, (int) data); 568 if (lt) { 569 ldns_buffer_printf(output, "\t%s", lt->name); 570 } else { 571 ldns_buffer_printf(output, "\tCLASS%d", data); 572 } 573 return ldns_buffer_status(output); 574 } 575 576 ldns_status 577 ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf) 578 { 579 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); 580 ldns_lookup_table *lt; 581 lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data); 582 if (lt) { 583 ldns_buffer_printf(output, "%s", lt->name); 584 } else { 585 ldns_buffer_printf(output, "%d", data); 586 } 587 return ldns_buffer_status(output); 588 } 589 590 ldns_status 591 ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf) 592 { 593 return ldns_rdf2buffer_str_int8(output, rdf); 594 } 595 596 static void 597 loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent) 598 { 599 uint8_t i; 600 /* is it 0.<two digits> ? */ 601 if(exponent < 2) { 602 if(exponent == 1) 603 mantissa *= 10; 604 ldns_buffer_printf(output, "0.%02ld", (long)mantissa); 605 return; 606 } 607 /* always <digit><string of zeros> */ 608 ldns_buffer_printf(output, "%d", (int)mantissa); 609 for(i=0; i<exponent-2; i++) 610 ldns_buffer_printf(output, "0"); 611 } 612 613 ldns_status 614 ldns_rr_type2buffer_str(ldns_buffer *output, const ldns_rr_type type) 615 { 616 const ldns_rr_descriptor *descriptor; 617 618 descriptor = ldns_rr_descript(type); 619 620 switch (type) { 621 case LDNS_RR_TYPE_IXFR: 622 ldns_buffer_printf(output, "IXFR"); 623 break; 624 case LDNS_RR_TYPE_AXFR: 625 ldns_buffer_printf(output, "AXFR"); 626 break; 627 case LDNS_RR_TYPE_MAILA: 628 ldns_buffer_printf(output, "MAILA"); 629 break; 630 case LDNS_RR_TYPE_MAILB: 631 ldns_buffer_printf(output, "MAILB"); 632 break; 633 case LDNS_RR_TYPE_ANY: 634 ldns_buffer_printf(output, "ANY"); 635 break; 636 default: 637 if (descriptor && descriptor->_name) { 638 ldns_buffer_printf(output, "%s", descriptor->_name); 639 } else { 640 ldns_buffer_printf(output, "TYPE%u", type); 641 } 642 } 643 return ldns_buffer_status(output); 644 } 645 646 char * 647 ldns_rr_type2str(const ldns_rr_type type) 648 { 649 char *str; 650 ldns_buffer *buf; 651 652 buf = ldns_buffer_new(10); 653 if (!buf) { 654 return NULL; 655 } 656 657 str = NULL; 658 if (ldns_rr_type2buffer_str(buf, type) == LDNS_STATUS_OK) { 659 str = ldns_buffer_export2str(buf); 660 } 661 662 ldns_buffer_free(buf); 663 return str; 664 } 665 666 667 ldns_status 668 ldns_rr_class2buffer_str(ldns_buffer *output, 669 const ldns_rr_class klass) 670 { 671 ldns_lookup_table *lt; 672 673 lt = ldns_lookup_by_id(ldns_rr_classes, klass); 674 if (lt) { 675 ldns_buffer_printf(output, "%s", lt->name); 676 } else { 677 ldns_buffer_printf(output, "CLASS%d", klass); 678 } 679 return ldns_buffer_status(output); 680 } 681 682 char * 683 ldns_rr_class2str(const ldns_rr_class klass) 684 { 685 ldns_buffer *buf; 686 char *str; 687 688 buf = ldns_buffer_new(10); 689 if (!buf) { 690 return NULL; 691 } 692 693 str = NULL; 694 if (ldns_rr_class2buffer_str(buf, klass) == LDNS_STATUS_OK) { 695 str = ldns_buffer_export2str(buf); 696 } 697 ldns_buffer_free(buf); 698 return str; 699 } 700 701 ldns_status 702 ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf) 703 { 704 /* we could do checking (ie degrees < 90 etc)? */ 705 uint8_t version; 706 uint8_t size; 707 uint8_t horizontal_precision; 708 uint8_t vertical_precision; 709 uint32_t longitude; 710 uint32_t latitude; 711 uint32_t altitude; 712 char latitude_hemisphere; 713 char longitude_hemisphere; 714 uint32_t h; 715 uint32_t m; 716 double s; 717 718 uint32_t equator = (uint32_t) ldns_power(2, 31); 719 720 if(ldns_rdf_size(rdf) < 1) { 721 return LDNS_STATUS_WIRE_RDATA_ERR; 722 } 723 version = ldns_rdf_data(rdf)[0]; 724 if (version == 0) { 725 if(ldns_rdf_size(rdf) < 16) { 726 return LDNS_STATUS_WIRE_RDATA_ERR; 727 } 728 size = ldns_rdf_data(rdf)[1]; 729 horizontal_precision = ldns_rdf_data(rdf)[2]; 730 vertical_precision = ldns_rdf_data(rdf)[3]; 731 732 latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]); 733 longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]); 734 altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]); 735 736 if (latitude > equator) { 737 latitude_hemisphere = 'N'; 738 latitude = latitude - equator; 739 } else { 740 latitude_hemisphere = 'S'; 741 latitude = equator - latitude; 742 } 743 h = latitude / (1000 * 60 * 60); 744 latitude = latitude % (1000 * 60 * 60); 745 m = latitude / (1000 * 60); 746 latitude = latitude % (1000 * 60); 747 s = (double) latitude / 1000.0; 748 ldns_buffer_printf(output, "%02u %02u %0.3f %c ", 749 h, m, s, latitude_hemisphere); 750 751 if (longitude > equator) { 752 longitude_hemisphere = 'E'; 753 longitude = longitude - equator; 754 } else { 755 longitude_hemisphere = 'W'; 756 longitude = equator - longitude; 757 } 758 h = longitude / (1000 * 60 * 60); 759 longitude = longitude % (1000 * 60 * 60); 760 m = longitude / (1000 * 60); 761 longitude = longitude % (1000 * 60); 762 s = (double) longitude / (1000.0); 763 ldns_buffer_printf(output, "%02u %02u %0.3f %c ", 764 h, m, s, longitude_hemisphere); 765 766 s = ((double) altitude) / 100; 767 s -= 100000; 768 769 if(altitude%100 != 0) 770 ldns_buffer_printf(output, "%.2f", s); 771 else 772 ldns_buffer_printf(output, "%.0f", s); 773 774 ldns_buffer_printf(output, "m "); 775 776 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f); 777 ldns_buffer_printf(output, "m "); 778 779 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4, 780 horizontal_precision & 0x0f); 781 ldns_buffer_printf(output, "m "); 782 783 loc_cm_print(output, (vertical_precision & 0xf0) >> 4, 784 vertical_precision & 0x0f); 785 ldns_buffer_printf(output, "m"); 786 787 return ldns_buffer_status(output); 788 } else { 789 return ldns_rdf2buffer_str_hex(output, rdf); 790 } 791 } 792 793 ldns_status 794 ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf) 795 { 796 ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf)); 797 return ldns_rdf2buffer_str_hex(output, rdf); 798 } 799 800 ldns_status 801 ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf) 802 { 803 ldns_buffer_printf(output, "0x"); 804 return ldns_rdf2buffer_str_hex(output, rdf); 805 } 806 807 ldns_status 808 ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf) 809 { 810 return ldns_rdf2buffer_str_hex(output, rdf); 811 } 812 813 ldns_status 814 ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf) 815 { 816 /* protocol, followed by bitmap of services */ 817 struct protoent *protocol; 818 char *proto_name = NULL; 819 uint8_t protocol_nr; 820 struct servent *service; 821 uint16_t current_service; 822 823 if(ldns_rdf_size(rdf) < 1) { 824 return LDNS_STATUS_WIRE_RDATA_ERR; 825 } 826 protocol_nr = ldns_rdf_data(rdf)[0]; 827 protocol = getprotobynumber((int) protocol_nr); 828 if (protocol && (protocol->p_name != NULL)) { 829 proto_name = protocol->p_name; 830 ldns_buffer_printf(output, "%s ", protocol->p_name); 831 } else { 832 ldns_buffer_printf(output, "%u ", protocol_nr); 833 } 834 835 #ifdef HAVE_ENDPROTOENT 836 endprotoent(); 837 #endif 838 839 for (current_service = 0; 840 current_service < (ldns_rdf_size(rdf)-1)*8; current_service++) { 841 if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) { 842 service = getservbyport((int) htons(current_service), 843 proto_name); 844 if (service && service->s_name) { 845 ldns_buffer_printf(output, "%s ", service->s_name); 846 } else { 847 ldns_buffer_printf(output, "%u ", current_service); 848 } 849 #ifdef HAVE_ENDSERVENT 850 endservent(); 851 #endif 852 } 853 /* exit from loop before integer overflow */ 854 if(current_service == 65535) { break; } 855 } 856 return ldns_buffer_status(output); 857 } 858 859 static ldns_status 860 ldns_rdf2buffer_str_nsec_fmt(ldns_buffer *output, 861 const ldns_output_format* fmt, const ldns_rdf *rdf) 862 { 863 /* Note: this code is duplicated in higher.c in 864 * ldns_nsec_type_check() function 865 */ 866 uint8_t window_block_nr; 867 uint8_t bitmap_length; 868 uint16_t type; 869 uint16_t pos = 0; 870 uint16_t bit_pos; 871 uint8_t *data = ldns_rdf_data(rdf); 872 873 while((size_t)(pos + 2) < ldns_rdf_size(rdf)) { 874 window_block_nr = data[pos]; 875 bitmap_length = data[pos + 1]; 876 pos += 2; 877 if (ldns_rdf_size(rdf) < pos + bitmap_length) { 878 return LDNS_STATUS_WIRE_RDATA_ERR; 879 } 880 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) { 881 if (! ldns_get_bit(&data[pos], bit_pos)) { 882 continue; 883 } 884 type = 256 * (uint16_t) window_block_nr + bit_pos; 885 886 if (! ldns_output_format_covers_type(fmt, type) && 887 ldns_rr_descript(type) && 888 ldns_rr_descript(type)->_name){ 889 890 ldns_buffer_printf(output, "%s ", 891 ldns_rr_descript(type)->_name); 892 } else { 893 ldns_buffer_printf(output, "TYPE%u ", type); 894 } 895 } 896 pos += (uint16_t) bitmap_length; 897 } 898 return ldns_buffer_status(output); 899 } 900 901 ldns_status 902 ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf) 903 { 904 return ldns_rdf2buffer_str_nsec_fmt(output, 905 ldns_output_format_default, rdf); 906 } 907 908 ldns_status 909 ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf) 910 { 911 uint8_t salt_length; 912 uint8_t salt_pos; 913 914 uint8_t *data = ldns_rdf_data(rdf); 915 916 if(ldns_rdf_size(rdf) < 1) { 917 return LDNS_STATUS_WIRE_RDATA_ERR; 918 } 919 salt_length = data[0]; 920 /* from now there are variable length entries so remember pos */ 921 if (salt_length == 0 || ((size_t)salt_length)+1 > ldns_rdf_size(rdf)) { 922 ldns_buffer_printf(output, "- "); 923 } else { 924 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) { 925 ldns_buffer_printf(output, "%02x", data[1 + salt_pos]); 926 } 927 ldns_buffer_printf(output, " "); 928 } 929 930 return ldns_buffer_status(output); 931 } 932 933 ldns_status 934 ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf) 935 { 936 /* period is the number of seconds */ 937 if (ldns_rdf_size(rdf) != 4) { 938 return LDNS_STATUS_WIRE_RDATA_ERR; 939 } 940 ldns_buffer_printf(output, "%u", ldns_read_uint32(ldns_rdf_data(rdf))); 941 return ldns_buffer_status(output); 942 } 943 944 ldns_status 945 ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf) 946 { 947 /* tsigtime is 48 bits network order unsigned integer */ 948 uint64_t tsigtime = 0; 949 uint8_t *data = ldns_rdf_data(rdf); 950 uint64_t d0, d1, d2, d3, d4, d5; 951 952 if (ldns_rdf_size(rdf) < 6) { 953 return LDNS_STATUS_WIRE_RDATA_ERR; 954 } 955 d0 = data[0]; /* cast to uint64 for shift operations */ 956 d1 = data[1]; 957 d2 = data[2]; 958 d3 = data[3]; 959 d4 = data[4]; 960 d5 = data[5]; 961 tsigtime = (d0<<40) | (d1<<32) | (d2<<24) | (d3<<16) | (d4<<8) | d5; 962 963 ldns_buffer_printf(output, "%llu ", (long long)tsigtime); 964 965 return ldns_buffer_status(output); 966 } 967 968 ldns_status 969 ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf) 970 { 971 uint8_t *data = ldns_rdf_data(rdf); 972 uint16_t address_family; 973 uint8_t prefix; 974 bool negation; 975 uint8_t adf_length; 976 size_t i; 977 size_t pos = 0; 978 979 while (pos < (unsigned int) ldns_rdf_size(rdf)) { 980 if(pos + 3 >= (unsigned)ldns_rdf_size(rdf)) 981 return LDNS_STATUS_WIRE_RDATA_ERR; 982 address_family = ldns_read_uint16(&data[pos]); 983 prefix = data[pos + 2]; 984 negation = data[pos + 3] & LDNS_APL_NEGATION; 985 adf_length = data[pos + 3] & LDNS_APL_MASK; 986 if (address_family == LDNS_APL_IP4) { 987 /* check if prefix < 32? */ 988 if (negation) { 989 ldns_buffer_printf(output, "!"); 990 } 991 ldns_buffer_printf(output, "%u:", address_family); 992 /* address is variable length 0 - 4 */ 993 for (i = 0; i < 4; i++) { 994 if (i > 0) { 995 ldns_buffer_printf(output, "."); 996 } 997 if (i < (unsigned short) adf_length) { 998 if(pos+i+4 >= ldns_rdf_size(rdf)) 999 return LDNS_STATUS_WIRE_RDATA_ERR; 1000 ldns_buffer_printf(output, "%d", 1001 data[pos + i + 4]); 1002 } else { 1003 ldns_buffer_printf(output, "0"); 1004 } 1005 } 1006 ldns_buffer_printf(output, "/%u ", prefix); 1007 } else if (address_family == LDNS_APL_IP6) { 1008 /* check if prefix < 128? */ 1009 if (negation) { 1010 ldns_buffer_printf(output, "!"); 1011 } 1012 ldns_buffer_printf(output, "%u:", address_family); 1013 /* address is variable length 0 - 16 */ 1014 for (i = 0; i < 16; i++) { 1015 if (i % 2 == 0 && i > 0) { 1016 ldns_buffer_printf(output, ":"); 1017 } 1018 if (i < (unsigned short) adf_length) { 1019 if(pos+i+4 >= ldns_rdf_size(rdf)) 1020 return LDNS_STATUS_WIRE_RDATA_ERR; 1021 ldns_buffer_printf(output, "%02x", 1022 data[pos + i + 4]); 1023 } else { 1024 ldns_buffer_printf(output, "00"); 1025 } 1026 } 1027 ldns_buffer_printf(output, "/%u ", prefix); 1028 1029 } else { 1030 /* unknown address family */ 1031 ldns_buffer_printf(output, 1032 "Unknown address family: %u data: ", 1033 address_family); 1034 for (i = 1; i < (unsigned short) (4 + adf_length); i++) { 1035 if(pos+i >= ldns_rdf_size(rdf)) 1036 return LDNS_STATUS_WIRE_RDATA_ERR; 1037 ldns_buffer_printf(output, "%02x", data[i]); 1038 } 1039 } 1040 pos += 4 + adf_length; 1041 } 1042 return ldns_buffer_status(output); 1043 } 1044 1045 ldns_status 1046 ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf) 1047 { 1048 size_t size; 1049 char *b64; 1050 if (ldns_rdf_size(rdf) < 2) { 1051 return LDNS_STATUS_WIRE_RDATA_ERR; 1052 } 1053 /* Subtract the size (2) of the number that specifies the length */ 1054 size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2); 1055 ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2); 1056 if (ldns_rdf_size(rdf) > 2) { 1057 b64 = LDNS_XMALLOC(char, size); 1058 if(!b64) 1059 return LDNS_STATUS_MEM_ERR; 1060 1061 if (ldns_rdf_size(rdf) > 2 && 1062 ldns_b64_ntop(ldns_rdf_data(rdf) + 2, 1063 ldns_rdf_size(rdf) - 2, 1064 b64, size)) { 1065 ldns_buffer_printf(output, "%s", b64); 1066 } 1067 LDNS_FREE(b64); 1068 } 1069 return ldns_buffer_status(output); 1070 } 1071 1072 ldns_status 1073 ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf) 1074 { 1075 /* wire format from 1076 http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt 1077 */ 1078 uint8_t *data = ldns_rdf_data(rdf); 1079 uint8_t precedence; 1080 uint8_t gateway_type; 1081 uint8_t algorithm; 1082 1083 ldns_rdf *gateway = NULL; 1084 uint8_t *gateway_data; 1085 1086 size_t public_key_size; 1087 uint8_t *public_key_data; 1088 ldns_rdf *public_key; 1089 1090 size_t offset = 0; 1091 ldns_status status; 1092 1093 if (ldns_rdf_size(rdf) < 3) { 1094 return LDNS_STATUS_WIRE_RDATA_ERR; 1095 } 1096 precedence = data[0]; 1097 gateway_type = data[1]; 1098 algorithm = data[2]; 1099 offset = 3; 1100 1101 switch (gateway_type) { 1102 case 0: 1103 /* no gateway */ 1104 break; 1105 case 1: 1106 if (ldns_rdf_size(rdf) < offset + LDNS_IP4ADDRLEN) { 1107 return LDNS_STATUS_ERR; 1108 } 1109 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN); 1110 if(!gateway_data) 1111 return LDNS_STATUS_MEM_ERR; 1112 memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN); 1113 gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, 1114 LDNS_IP4ADDRLEN , gateway_data); 1115 offset += LDNS_IP4ADDRLEN; 1116 if(!gateway) { 1117 LDNS_FREE(gateway_data); 1118 return LDNS_STATUS_MEM_ERR; 1119 } 1120 break; 1121 case 2: 1122 if (ldns_rdf_size(rdf) < offset + LDNS_IP6ADDRLEN) { 1123 return LDNS_STATUS_ERR; 1124 } 1125 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN); 1126 if(!gateway_data) 1127 return LDNS_STATUS_MEM_ERR; 1128 memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN); 1129 offset += LDNS_IP6ADDRLEN; 1130 gateway = 1131 ldns_rdf_new(LDNS_RDF_TYPE_AAAA, 1132 LDNS_IP6ADDRLEN, gateway_data); 1133 if(!gateway) { 1134 LDNS_FREE(gateway_data); 1135 return LDNS_STATUS_MEM_ERR; 1136 } 1137 break; 1138 case 3: 1139 status = ldns_wire2dname(&gateway, data, 1140 ldns_rdf_size(rdf), &offset); 1141 if(status != LDNS_STATUS_OK) 1142 return status; 1143 break; 1144 default: 1145 /* error? */ 1146 break; 1147 } 1148 1149 if (ldns_rdf_size(rdf) <= offset) { 1150 ldns_rdf_deep_free(gateway); 1151 return LDNS_STATUS_ERR; 1152 } 1153 public_key_size = ldns_rdf_size(rdf) - offset; 1154 public_key_data = LDNS_XMALLOC(uint8_t, public_key_size); 1155 if(!public_key_data) { 1156 ldns_rdf_deep_free(gateway); 1157 return LDNS_STATUS_MEM_ERR; 1158 } 1159 memcpy(public_key_data, &data[offset], public_key_size); 1160 public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, 1161 public_key_size, public_key_data); 1162 if(!public_key) { 1163 LDNS_FREE(public_key_data); 1164 ldns_rdf_deep_free(gateway); 1165 return LDNS_STATUS_MEM_ERR; 1166 } 1167 1168 ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm); 1169 if (gateway) 1170 (void) ldns_rdf2buffer_str(output, gateway); 1171 else 1172 ldns_buffer_printf(output, "."); 1173 ldns_buffer_printf(output, " "); 1174 (void) ldns_rdf2buffer_str(output, public_key); 1175 1176 ldns_rdf_deep_free(gateway); 1177 ldns_rdf_deep_free(public_key); 1178 1179 return ldns_buffer_status(output); 1180 } 1181 1182 ldns_status 1183 ldns_rdf2buffer_str_ilnp64(ldns_buffer *output, const ldns_rdf *rdf) 1184 { 1185 if (ldns_rdf_size(rdf) != 8) { 1186 return LDNS_STATUS_WIRE_RDATA_ERR; 1187 } 1188 ldns_buffer_printf(output,"%.4x:%.4x:%.4x:%.4x", 1189 ldns_read_uint16(ldns_rdf_data(rdf)), 1190 ldns_read_uint16(ldns_rdf_data(rdf)+2), 1191 ldns_read_uint16(ldns_rdf_data(rdf)+4), 1192 ldns_read_uint16(ldns_rdf_data(rdf)+6)); 1193 return ldns_buffer_status(output); 1194 } 1195 1196 ldns_status 1197 ldns_rdf2buffer_str_eui48(ldns_buffer *output, const ldns_rdf *rdf) 1198 { 1199 if (ldns_rdf_size(rdf) != 6) { 1200 return LDNS_STATUS_WIRE_RDATA_ERR; 1201 } 1202 ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x", 1203 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1], 1204 ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3], 1205 ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5]); 1206 return ldns_buffer_status(output); 1207 } 1208 1209 ldns_status 1210 ldns_rdf2buffer_str_eui64(ldns_buffer *output, const ldns_rdf *rdf) 1211 { 1212 if (ldns_rdf_size(rdf) != 8) { 1213 return LDNS_STATUS_WIRE_RDATA_ERR; 1214 } 1215 ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x", 1216 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1], 1217 ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3], 1218 ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5], 1219 ldns_rdf_data(rdf)[6], ldns_rdf_data(rdf)[7]); 1220 return ldns_buffer_status(output); 1221 } 1222 1223 ldns_status 1224 ldns_rdf2buffer_str_tag(ldns_buffer *output, const ldns_rdf *rdf) 1225 { 1226 size_t nchars; 1227 const uint8_t* chars; 1228 char ch; 1229 if (ldns_rdf_size(rdf) < 2) { 1230 return LDNS_STATUS_WIRE_RDATA_ERR; 1231 } 1232 nchars = ldns_rdf_data(rdf)[0]; 1233 if (nchars >= ldns_rdf_size(rdf) || /* should be rdf_size - 1 */ 1234 nchars < 1) { 1235 return LDNS_STATUS_WIRE_RDATA_ERR; 1236 } 1237 chars = ldns_rdf_data(rdf) + 1; 1238 while (nchars > 0) { 1239 ch = (char)*chars++; 1240 if (! isalnum((unsigned char)ch)) { 1241 return LDNS_STATUS_WIRE_RDATA_ERR; 1242 } 1243 ldns_buffer_printf(output, "%c", ch); 1244 nchars--; 1245 } 1246 return ldns_buffer_status(output); 1247 } 1248 1249 ldns_status 1250 ldns_rdf2buffer_str_long_str(ldns_buffer *output, const ldns_rdf *rdf) 1251 { 1252 1253 ldns_buffer_printf(output, "\""); 1254 ldns_characters2buffer_str(output, 1255 ldns_rdf_size(rdf), ldns_rdf_data(rdf)); 1256 ldns_buffer_printf(output, "\""); 1257 return ldns_buffer_status(output); 1258 } 1259 1260 ldns_status 1261 ldns_rdf2buffer_str_hip(ldns_buffer *output, const ldns_rdf *rdf) 1262 { 1263 uint8_t *data = ldns_rdf_data(rdf); 1264 size_t rdf_size = ldns_rdf_size(rdf); 1265 uint8_t hit_size; 1266 uint16_t pk_size; 1267 int written; 1268 1269 if (rdf_size < 6) { 1270 return LDNS_STATUS_WIRE_RDATA_ERR; 1271 } 1272 if ((hit_size = data[0]) == 0 || 1273 (pk_size = ldns_read_uint16(data + 2)) == 0 || 1274 rdf_size < (size_t) hit_size + pk_size + 4) { 1275 1276 return LDNS_STATUS_WIRE_RDATA_ERR; 1277 } 1278 1279 ldns_buffer_printf(output, "%d ", (int) data[1]); 1280 1281 for (data += 4; hit_size > 0; hit_size--, data++) { 1282 1283 ldns_buffer_printf(output, "%02x", (int) *data); 1284 } 1285 ldns_buffer_write_char(output, (uint8_t) ' '); 1286 1287 if (ldns_buffer_reserve(output, 1288 ldns_b64_ntop_calculate_size(pk_size))) { 1289 1290 written = ldns_b64_ntop(data, pk_size, 1291 (char *) ldns_buffer_current(output), 1292 ldns_buffer_remaining(output)); 1293 1294 if (written > 0 && 1295 written < (int) ldns_buffer_remaining(output)) { 1296 1297 output->_position += written; 1298 } 1299 } 1300 return ldns_buffer_status(output); 1301 } 1302 1303 /* implementation mimicked from ldns_rdf2buffer_str_ipseckey */ 1304 ldns_status 1305 ldns_rdf2buffer_str_amtrelay(ldns_buffer *output, const ldns_rdf *rdf) 1306 { 1307 /* wire format from 1308 * draft-ietf-mboned-driad-amt-discovery Section 4.2 1309 */ 1310 uint8_t *data = ldns_rdf_data(rdf); 1311 uint8_t precedence; 1312 uint8_t discovery_optional; 1313 uint8_t relay_type; 1314 1315 ldns_rdf *relay = NULL; 1316 uint8_t *relay_data; 1317 1318 size_t offset = 0; 1319 ldns_status status; 1320 1321 if (ldns_rdf_size(rdf) < 2) { 1322 return LDNS_STATUS_WIRE_RDATA_ERR; 1323 } 1324 precedence = data[0]; 1325 discovery_optional = ((data[1] & 0x80) >> 7); 1326 relay_type = data[1] & 0x7F; 1327 offset = 2; 1328 1329 switch (relay_type) { 1330 case 0: 1331 /* no relay */ 1332 break; 1333 case 1: 1334 if (ldns_rdf_size(rdf) < offset + LDNS_IP4ADDRLEN) { 1335 return LDNS_STATUS_ERR; 1336 } 1337 relay_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN); 1338 if(!relay_data) 1339 return LDNS_STATUS_MEM_ERR; 1340 memcpy(relay_data, &data[offset], LDNS_IP4ADDRLEN); 1341 relay = ldns_rdf_new(LDNS_RDF_TYPE_A, 1342 LDNS_IP4ADDRLEN , relay_data); 1343 offset += LDNS_IP4ADDRLEN; 1344 if(!relay) { 1345 LDNS_FREE(relay_data); 1346 return LDNS_STATUS_MEM_ERR; 1347 } 1348 break; 1349 case 2: 1350 if (ldns_rdf_size(rdf) < offset + LDNS_IP6ADDRLEN) { 1351 return LDNS_STATUS_ERR; 1352 } 1353 relay_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN); 1354 if(!relay_data) 1355 return LDNS_STATUS_MEM_ERR; 1356 memcpy(relay_data, &data[offset], LDNS_IP6ADDRLEN); 1357 offset += LDNS_IP6ADDRLEN; 1358 relay = 1359 ldns_rdf_new(LDNS_RDF_TYPE_AAAA, 1360 LDNS_IP6ADDRLEN, relay_data); 1361 if(!relay) { 1362 LDNS_FREE(relay_data); 1363 return LDNS_STATUS_MEM_ERR; 1364 } 1365 break; 1366 case 3: 1367 status = ldns_wire2dname(&relay, data, 1368 ldns_rdf_size(rdf), &offset); 1369 if(status != LDNS_STATUS_OK) 1370 return status; 1371 break; 1372 default: 1373 /* error? */ 1374 break; 1375 } 1376 1377 if (ldns_rdf_size(rdf) != offset) { 1378 ldns_rdf_deep_free(relay); 1379 return LDNS_STATUS_ERR; 1380 } 1381 ldns_buffer_printf(output, "%u %u %u ", 1382 precedence, discovery_optional, relay_type); 1383 if (relay) 1384 (void) ldns_rdf2buffer_str(output, relay); 1385 1386 ldns_rdf_deep_free(relay); 1387 return ldns_buffer_status(output); 1388 } 1389 1390 #ifdef RRTYPE_SVCB_HTTPS 1391 ldns_status svcparam_key2buffer_str(ldns_buffer *output, uint16_t key); 1392 1393 static ldns_status 1394 svcparam_mandatory2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data) 1395 { 1396 if (sz % 2) 1397 return LDNS_STATUS_INVALID_SVCPARAM_VALUE; 1398 1399 svcparam_key2buffer_str(output, ldns_read_uint16(data)); 1400 for (data += 2, sz -= 2; sz; data += 2, sz -= 2) { 1401 ldns_buffer_write_char(output, ','); 1402 svcparam_key2buffer_str(output, ldns_read_uint16(data)); 1403 } 1404 return ldns_buffer_status(output); 1405 } 1406 1407 static ldns_status 1408 svcparam_alpn2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data) 1409 { 1410 uint8_t *eod = data + sz, *dp; 1411 bool quote = false; 1412 size_t i; 1413 1414 for (dp = data; dp < eod && !quote; dp += 1 + *dp) { 1415 if (dp + 1 + *dp > eod) 1416 return LDNS_STATUS_INVALID_SVCPARAM_VALUE; 1417 1418 for (i = 0; i < *dp; i++) 1419 if (isspace(dp[i + 1])) 1420 break; 1421 quote = i < *dp; 1422 } 1423 if (quote) 1424 ldns_buffer_write_char(output, '"'); 1425 while (data < eod) { 1426 uint8_t *eot = data + 1 + *data; 1427 1428 if (eot > eod) 1429 return LDNS_STATUS_INVALID_SVCPARAM_VALUE; 1430 1431 if (eod - data < (int)sz) 1432 ldns_buffer_write_char(output, ','); 1433 1434 for (data += 1; data < eot; data += 1) { 1435 uint8_t ch = *data; 1436 1437 if (isprint(ch) || ch == '\t') { 1438 if (ch == '"' || ch == ',' || ch == '\\') 1439 ldns_buffer_write_char(output, '\\'); 1440 ldns_buffer_write_char(output, ch); 1441 } else 1442 ldns_buffer_printf(output, "\\%03u" 1443 , (unsigned)ch); 1444 } 1445 } 1446 if (quote) 1447 ldns_buffer_write_char(output, '"'); 1448 return ldns_buffer_status(output); 1449 } 1450 1451 static ldns_status 1452 svcparam_port2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data) 1453 { 1454 if (sz != 2) 1455 return LDNS_STATUS_INVALID_SVCPARAM_VALUE; 1456 ldns_buffer_printf(output, "%d", (int)ldns_read_uint16(data)); 1457 return ldns_buffer_status(output); 1458 } 1459 1460 static ldns_status 1461 svcparam_ipv4hint2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data) 1462 { 1463 char str[INET_ADDRSTRLEN]; 1464 1465 if (sz % 4 || !inet_ntop(AF_INET, data, str, INET_ADDRSTRLEN)) 1466 return LDNS_STATUS_INVALID_SVCPARAM_VALUE; 1467 1468 ldns_buffer_write_chars(output, str); 1469 1470 for (data += 4, sz -= 4; sz ; data += 4, sz -= 4 ) { 1471 ldns_buffer_write_char(output, ','); 1472 if (!inet_ntop(AF_INET, data, str, INET_ADDRSTRLEN)) 1473 return LDNS_STATUS_INVALID_SVCPARAM_VALUE; 1474 1475 ldns_buffer_write_chars(output, str); 1476 } 1477 return ldns_buffer_status(output); 1478 } 1479 1480 static ldns_status 1481 svcparam_ech2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data) 1482 { 1483 size_t str_sz = ldns_b64_ntop_calculate_size(sz); 1484 int written; 1485 1486 if (!ldns_buffer_reserve(output, str_sz)) 1487 return LDNS_STATUS_MEM_ERR; 1488 1489 written = ldns_b64_ntop( data, sz 1490 , (char *)ldns_buffer_current(output), str_sz); 1491 if (written > 0) 1492 ldns_buffer_skip(output, written); 1493 else 1494 return LDNS_STATUS_INVALID_SVCPARAM_VALUE; 1495 1496 return ldns_buffer_status(output); 1497 } 1498 1499 static ldns_status 1500 svcparam_ipv6hint2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data) 1501 { 1502 char str[INET6_ADDRSTRLEN]; 1503 1504 if (sz % 16 || !inet_ntop(AF_INET6, data, str, INET6_ADDRSTRLEN)) 1505 return LDNS_STATUS_INVALID_SVCPARAM_VALUE; 1506 1507 ldns_buffer_write_chars(output, str); 1508 1509 for (data += 16, sz -= 16; sz ; data += 16, sz -= 16) { 1510 ldns_buffer_write_char(output, ','); 1511 if (!inet_ntop(AF_INET6, data, str, INET6_ADDRSTRLEN)) 1512 return LDNS_STATUS_INVALID_SVCPARAM_VALUE; 1513 1514 ldns_buffer_write_chars(output, str); 1515 } 1516 return ldns_buffer_status(output); 1517 } 1518 1519 static ldns_status 1520 svcparam_value2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data) 1521 { 1522 uint8_t *eod = data + sz, *dp; 1523 bool quote = false; 1524 1525 for (dp = data; dp < eod && !isspace(*dp); dp++) 1526 ; /* pass */ 1527 1528 if ((quote = dp < eod)) 1529 ldns_buffer_write_char(output, '"'); 1530 1531 for (dp = data; dp < eod; dp++) { 1532 uint8_t ch = *dp; 1533 1534 if (isprint(ch) || ch == '\t') { 1535 if (ch == '"' || ch == '\\') 1536 ldns_buffer_write_char(output, '\\'); 1537 ldns_buffer_write_char(output, ch); 1538 } else 1539 ldns_buffer_printf(output, "\\%03u", (unsigned)ch); 1540 } 1541 if (quote) 1542 ldns_buffer_write_char(output, '"'); 1543 return ldns_buffer_status(output); 1544 } 1545 1546 ldns_status 1547 ldns_rdf2buffer_str_svcparams(ldns_buffer *output, const ldns_rdf *rdf) 1548 { 1549 uint8_t *data, *dp, *next_dp = NULL; 1550 size_t sz; 1551 ldns_status st; 1552 1553 if (!output) 1554 return LDNS_STATUS_NULL; 1555 1556 if (!rdf || !(data = ldns_rdf_data(rdf)) || !(sz = ldns_rdf_size(rdf))) 1557 /* No svcparams is just fine. Just nothing to print. */ 1558 return LDNS_STATUS_OK; 1559 1560 for (dp = data; dp + 4 <= data + sz; dp = next_dp) { 1561 ldns_svcparam_key key = ldns_read_uint16(dp); 1562 uint16_t val_sz = ldns_read_uint16(dp + 2); 1563 1564 if ((next_dp = dp + 4 + val_sz) > data + sz) 1565 return LDNS_STATUS_RDATA_OVERFLOW; 1566 1567 if (dp > data) 1568 ldns_buffer_write_char(output, ' '); 1569 1570 if ((st = svcparam_key2buffer_str(output, key))) 1571 return st; 1572 1573 if (val_sz == 0) 1574 continue; 1575 dp += 4; 1576 ldns_buffer_write_char(output, '='); 1577 switch (key) { 1578 case LDNS_SVCPARAM_KEY_MANDATORY: 1579 st = svcparam_mandatory2buffer_str(output, val_sz, dp); 1580 break; 1581 case LDNS_SVCPARAM_KEY_ALPN: 1582 st = svcparam_alpn2buffer_str(output, val_sz, dp); 1583 break; 1584 case LDNS_SVCPARAM_KEY_NO_DEFAULT_ALPN: 1585 return LDNS_STATUS_NO_SVCPARAM_VALUE_EXPECTED; 1586 case LDNS_SVCPARAM_KEY_PORT: 1587 st = svcparam_port2buffer_str(output, val_sz, dp); 1588 break; 1589 case LDNS_SVCPARAM_KEY_IPV4HINT: 1590 st = svcparam_ipv4hint2buffer_str(output, val_sz, dp); 1591 break; 1592 case LDNS_SVCPARAM_KEY_ECH: 1593 st = svcparam_ech2buffer_str(output, val_sz, dp); 1594 break; 1595 case LDNS_SVCPARAM_KEY_IPV6HINT: 1596 st = svcparam_ipv6hint2buffer_str(output, val_sz, dp); 1597 break; 1598 default: 1599 st = svcparam_value2buffer_str(output, val_sz, dp); 1600 break; 1601 } 1602 if (st) 1603 return st; 1604 } 1605 return ldns_buffer_status(output); 1606 } 1607 #else /* #ifdef RRTYPE_SVCB_HTTPS */ 1608 ldns_status 1609 ldns_rdf2buffer_str_svcparams(ldns_buffer *output, const ldns_rdf *rdf) 1610 { 1611 (void)output; (void)rdf; 1612 return LDNS_STATUS_NOT_IMPL; 1613 } 1614 #endif /* #ifdef RRTYPE_SVCB_HTTPS */ 1615 1616 static ldns_status 1617 ldns_rdf2buffer_str_fmt(ldns_buffer *buffer, 1618 const ldns_output_format* fmt, const ldns_rdf *rdf) 1619 { 1620 ldns_status res = LDNS_STATUS_OK; 1621 1622 /*ldns_buffer_printf(buffer, "%u:", ldns_rdf_get_type(rdf));*/ 1623 if (rdf) { 1624 switch(ldns_rdf_get_type(rdf)) { 1625 case LDNS_RDF_TYPE_NONE: 1626 break; 1627 case LDNS_RDF_TYPE_DNAME: 1628 res = ldns_rdf2buffer_str_dname(buffer, rdf); 1629 break; 1630 case LDNS_RDF_TYPE_INT8: /* Don't output mnemonics for these */ 1631 case LDNS_RDF_TYPE_ALG: 1632 case LDNS_RDF_TYPE_CERTIFICATE_USAGE: 1633 case LDNS_RDF_TYPE_SELECTOR: 1634 case LDNS_RDF_TYPE_MATCHING_TYPE: 1635 res = ldns_rdf2buffer_str_int8(buffer, rdf); 1636 break; 1637 case LDNS_RDF_TYPE_INT16: 1638 res = ldns_rdf2buffer_str_int16(buffer, rdf); 1639 break; 1640 case LDNS_RDF_TYPE_INT32: 1641 res = ldns_rdf2buffer_str_int32(buffer, rdf); 1642 break; 1643 case LDNS_RDF_TYPE_PERIOD: 1644 res = ldns_rdf2buffer_str_period(buffer, rdf); 1645 break; 1646 case LDNS_RDF_TYPE_TSIGTIME: 1647 res = ldns_rdf2buffer_str_tsigtime(buffer, rdf); 1648 break; 1649 case LDNS_RDF_TYPE_A: 1650 res = ldns_rdf2buffer_str_a(buffer, rdf); 1651 break; 1652 case LDNS_RDF_TYPE_AAAA: 1653 res = ldns_rdf2buffer_str_aaaa(buffer, rdf); 1654 break; 1655 case LDNS_RDF_TYPE_STR: 1656 res = ldns_rdf2buffer_str_str(buffer, rdf); 1657 break; 1658 case LDNS_RDF_TYPE_APL: 1659 res = ldns_rdf2buffer_str_apl(buffer, rdf); 1660 break; 1661 case LDNS_RDF_TYPE_B32_EXT: 1662 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf); 1663 break; 1664 case LDNS_RDF_TYPE_B64: 1665 res = ldns_rdf2buffer_str_b64(buffer, rdf); 1666 break; 1667 case LDNS_RDF_TYPE_HEX: 1668 res = ldns_rdf2buffer_str_hex(buffer, rdf); 1669 break; 1670 case LDNS_RDF_TYPE_NSEC: 1671 res = ldns_rdf2buffer_str_nsec_fmt(buffer, fmt, rdf); 1672 break; 1673 case LDNS_RDF_TYPE_NSEC3_SALT: 1674 res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf); 1675 break; 1676 case LDNS_RDF_TYPE_TYPE: 1677 res = ldns_rdf2buffer_str_type_fmt(buffer, fmt, rdf); 1678 break; 1679 case LDNS_RDF_TYPE_CLASS: 1680 res = ldns_rdf2buffer_str_class(buffer, rdf); 1681 break; 1682 case LDNS_RDF_TYPE_CERT_ALG: 1683 res = ldns_rdf2buffer_str_cert_alg(buffer, rdf); 1684 break; 1685 case LDNS_RDF_TYPE_UNKNOWN: 1686 res = ldns_rdf2buffer_str_unknown(buffer, rdf); 1687 break; 1688 case LDNS_RDF_TYPE_TIME: 1689 res = ldns_rdf2buffer_str_time(buffer, rdf); 1690 break; 1691 case LDNS_RDF_TYPE_HIP: 1692 res = ldns_rdf2buffer_str_hip(buffer, rdf); 1693 break; 1694 case LDNS_RDF_TYPE_LOC: 1695 res = ldns_rdf2buffer_str_loc(buffer, rdf); 1696 break; 1697 case LDNS_RDF_TYPE_WKS: 1698 case LDNS_RDF_TYPE_SERVICE: 1699 res = ldns_rdf2buffer_str_wks(buffer, rdf); 1700 break; 1701 case LDNS_RDF_TYPE_NSAP: 1702 res = ldns_rdf2buffer_str_nsap(buffer, rdf); 1703 break; 1704 case LDNS_RDF_TYPE_ATMA: 1705 res = ldns_rdf2buffer_str_atma(buffer, rdf); 1706 break; 1707 case LDNS_RDF_TYPE_IPSECKEY: 1708 res = ldns_rdf2buffer_str_ipseckey(buffer, rdf); 1709 break; 1710 case LDNS_RDF_TYPE_INT16_DATA: 1711 res = ldns_rdf2buffer_str_int16_data(buffer, rdf); 1712 break; 1713 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER: 1714 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf); 1715 break; 1716 case LDNS_RDF_TYPE_ILNP64: 1717 res = ldns_rdf2buffer_str_ilnp64(buffer, rdf); 1718 break; 1719 case LDNS_RDF_TYPE_EUI48: 1720 res = ldns_rdf2buffer_str_eui48(buffer, rdf); 1721 break; 1722 case LDNS_RDF_TYPE_EUI64: 1723 res = ldns_rdf2buffer_str_eui64(buffer, rdf); 1724 break; 1725 case LDNS_RDF_TYPE_TAG: 1726 res = ldns_rdf2buffer_str_tag(buffer, rdf); 1727 break; 1728 case LDNS_RDF_TYPE_LONG_STR: 1729 res = ldns_rdf2buffer_str_long_str(buffer, rdf); 1730 break; 1731 case LDNS_RDF_TYPE_AMTRELAY: 1732 res = ldns_rdf2buffer_str_amtrelay(buffer, rdf); 1733 break; 1734 case LDNS_RDF_TYPE_SVCPARAMS: 1735 res = ldns_rdf2buffer_str_svcparams(buffer, rdf); 1736 break; 1737 } 1738 } else { 1739 /** This will write mangled RRs */ 1740 ldns_buffer_printf(buffer, "(null) "); 1741 res = LDNS_STATUS_ERR; 1742 } 1743 return res; 1744 } 1745 1746 ldns_status 1747 ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf) 1748 { 1749 return ldns_rdf2buffer_str_fmt(buffer,ldns_output_format_default,rdf); 1750 } 1751 1752 static ldns_rdf * 1753 ldns_b32_ext2dname(const ldns_rdf *rdf) 1754 { 1755 size_t size; 1756 char *b32; 1757 ldns_rdf *out; 1758 if(ldns_rdf_size(rdf) == 0) 1759 return NULL; 1760 /* remove -1 for the b32-hash-len octet */ 1761 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1); 1762 /* add one for the end nul for the string */ 1763 b32 = LDNS_XMALLOC(char, size + 2); 1764 if (b32) { 1765 if (ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1, 1766 ldns_rdf_size(rdf) - 1, b32, size+1) > 0) { 1767 b32[size] = '.'; 1768 b32[size+1] = '\0'; 1769 if (ldns_str2rdf_dname(&out, b32) == LDNS_STATUS_OK) { 1770 LDNS_FREE(b32); 1771 return out; 1772 } 1773 } 1774 LDNS_FREE(b32); 1775 } 1776 return NULL; 1777 } 1778 1779 static ldns_status 1780 ldns_rr2buffer_str_rfc3597(ldns_buffer *output, const ldns_rr *rr) 1781 { 1782 size_t total_rdfsize = 0; 1783 size_t i, j; 1784 1785 ldns_buffer_printf(output, "TYPE%u\t", ldns_rr_get_type(rr)); 1786 for (i = 0; i < ldns_rr_rd_count(rr); i++) { 1787 total_rdfsize += ldns_rdf_size(ldns_rr_rdf(rr, i)); 1788 } 1789 if (total_rdfsize == 0) { 1790 ldns_buffer_printf(output, "\\# 0\n"); 1791 return ldns_buffer_status(output); 1792 } 1793 ldns_buffer_printf(output, "\\# %d ", total_rdfsize); 1794 for (i = 0; i < ldns_rr_rd_count(rr); i++) { 1795 for (j = 0; j < ldns_rdf_size(ldns_rr_rdf(rr, i)); j++) { 1796 ldns_buffer_printf(output, "%.2x", 1797 ldns_rdf_data(ldns_rr_rdf(rr, i))[j]); 1798 } 1799 } 1800 ldns_buffer_printf(output, "\n"); 1801 return ldns_buffer_status(output); 1802 } 1803 1804 ldns_status 1805 ldns_rr2buffer_str_fmt(ldns_buffer *output, 1806 const ldns_output_format *fmt, const ldns_rr *rr) 1807 { 1808 uint16_t i, flags; 1809 ldns_status status = LDNS_STATUS_OK; 1810 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt; 1811 1812 if (fmt_st == NULL) { 1813 fmt_st = (ldns_output_format_storage*) 1814 ldns_output_format_default; 1815 } 1816 if (!(fmt_st->flags & LDNS_FMT_SHORT)) { 1817 if (!rr) { 1818 if (LDNS_COMMENT_NULLS & fmt_st->flags) { 1819 ldns_buffer_printf(output, "; (null)\n"); 1820 } 1821 return ldns_buffer_status(output); 1822 } 1823 if (ldns_rr_owner(rr)) { 1824 status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr)); 1825 } 1826 if (status != LDNS_STATUS_OK) { 1827 return status; 1828 } 1829 1830 /* TTL should NOT be printed if it is a question */ 1831 if (!ldns_rr_is_question(rr)) { 1832 ldns_buffer_printf(output, "\t%u", (unsigned)ldns_rr_ttl(rr)); 1833 } 1834 1835 ldns_buffer_printf(output, "\t"); 1836 status = ldns_rr_class2buffer_str(output, ldns_rr_get_class(rr)); 1837 if (status != LDNS_STATUS_OK) { 1838 return status; 1839 } 1840 ldns_buffer_printf(output, "\t"); 1841 1842 if (ldns_output_format_covers_type(fmt, ldns_rr_get_type(rr))) { 1843 return ldns_rr2buffer_str_rfc3597(output, rr); 1844 } 1845 status = ldns_rr_type2buffer_str(output, ldns_rr_get_type(rr)); 1846 if (status != LDNS_STATUS_OK) { 1847 return status; 1848 } 1849 1850 if (ldns_rr_rd_count(rr) > 0) { 1851 ldns_buffer_printf(output, "\t"); 1852 } else if (!ldns_rr_is_question(rr)) { 1853 ldns_buffer_printf(output, "\t\\# 0"); 1854 } 1855 } else if (ldns_rr_rd_count(rr) == 0) { 1856 /* assert(fmt_st->flags & LDNS_FMT_SHORT); */ 1857 1858 ldns_buffer_printf(output, "# 0"); 1859 } 1860 for (i = 0; i < ldns_rr_rd_count(rr); i++) { 1861 /* ldns_rdf2buffer_str handles NULL input fine! */ 1862 if ((fmt_st->flags & LDNS_FMT_ZEROIZE_RRSIGS) && 1863 (ldns_rr_get_type(rr) == LDNS_RR_TYPE_RRSIG) && 1864 ((/* inception */ i == 4 && 1865 ldns_rdf_get_type(ldns_rr_rdf(rr, 4)) == 1866 LDNS_RDF_TYPE_TIME) || 1867 (/* expiration */ i == 5 && 1868 ldns_rdf_get_type(ldns_rr_rdf(rr, 5)) == 1869 LDNS_RDF_TYPE_TIME) || 1870 (/* signature */ i == 8 && 1871 ldns_rdf_get_type(ldns_rr_rdf(rr, 8)) == 1872 LDNS_RDF_TYPE_B64))) { 1873 1874 ldns_buffer_printf(output, "(null)"); 1875 status = ldns_buffer_status(output); 1876 } else if ((fmt_st->flags & LDNS_FMT_PAD_SOA_SERIAL) && 1877 (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) && 1878 /* serial */ i == 2 && 1879 ldns_rdf_get_type(ldns_rr_rdf(rr, 2)) == 1880 LDNS_RDF_TYPE_INT32) { 1881 ldns_buffer_printf(output, "%10lu", 1882 (unsigned long) ldns_read_uint32( 1883 ldns_rdf_data(ldns_rr_rdf(rr, 2)))); 1884 status = ldns_buffer_status(output); 1885 } else { 1886 status = ldns_rdf2buffer_str_fmt(output, 1887 fmt, ldns_rr_rdf(rr, i)); 1888 } 1889 if(status != LDNS_STATUS_OK) 1890 return status; 1891 if (i < ldns_rr_rd_count(rr) - 1) { 1892 ldns_buffer_printf(output, " "); 1893 } 1894 } 1895 /* per RR special comments - handy for DNSSEC types */ 1896 /* check to prevent question sec. rr from 1897 * getting here */ 1898 if (ldns_rr_rd_count(rr) > 0) { 1899 switch (ldns_rr_get_type(rr)) { 1900 case LDNS_RR_TYPE_DNSKEY: 1901 /* if ldns_rr_rd_count(rr) > 0 1902 then ldns_rr_rdf(rr, 0) exists! */ 1903 if (! (fmt_st->flags & LDNS_COMMENT_KEY)) { 1904 break; 1905 } 1906 flags = ldns_rdf2native_int16(ldns_rr_rdf(rr, 0)); 1907 ldns_buffer_printf(output, " ;{"); 1908 if (fmt_st->flags & LDNS_COMMENT_KEY_ID) { 1909 ldns_buffer_printf(output, "id = %u", 1910 (unsigned int) ldns_calc_keytag(rr)); 1911 } 1912 if ((fmt_st->flags & LDNS_COMMENT_KEY_TYPE) && 1913 (flags & LDNS_KEY_ZONE_KEY)){ 1914 1915 if (flags & LDNS_KEY_SEP_KEY) { 1916 ldns_buffer_printf(output, " (ksk)"); 1917 } else { 1918 ldns_buffer_printf(output, " (zsk)"); 1919 } 1920 if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE){ 1921 ldns_buffer_printf(output, ", "); 1922 } 1923 } else if (fmt_st->flags 1924 & (LDNS_COMMENT_KEY_ID 1925 |LDNS_COMMENT_KEY_SIZE)) { 1926 ldns_buffer_printf( output, ", "); 1927 } 1928 if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE) { 1929 ldns_buffer_printf(output, "size = %db", 1930 ldns_rr_dnskey_key_size(rr)); 1931 } 1932 ldns_buffer_printf(output, "}"); 1933 break; 1934 case LDNS_RR_TYPE_RRSIG: 1935 if ((fmt_st->flags & LDNS_COMMENT_KEY) 1936 && (fmt_st->flags& LDNS_COMMENT_RRSIGS) 1937 && ldns_rr_rdf(rr, 6) != NULL) { 1938 ldns_buffer_printf(output, " ;{id = %d}", 1939 ldns_rdf2native_int16( 1940 ldns_rr_rdf(rr, 6))); 1941 } 1942 break; 1943 case LDNS_RR_TYPE_DS: 1944 if ((fmt_st->flags & LDNS_COMMENT_BUBBLEBABBLE) && 1945 ldns_rr_rdf(rr, 3) != NULL) { 1946 1947 uint8_t *data = ldns_rdf_data( 1948 ldns_rr_rdf(rr, 3)); 1949 size_t len = ldns_rdf_size(ldns_rr_rdf(rr, 3)); 1950 char *babble = ldns_bubblebabble(data, len); 1951 if(babble) { 1952 ldns_buffer_printf(output, 1953 " ;{%s}", babble); 1954 } 1955 LDNS_FREE(babble); 1956 } 1957 break; 1958 case LDNS_RR_TYPE_NSEC3: 1959 if (! (fmt_st->flags & LDNS_COMMENT_FLAGS) && 1960 ! (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN)) { 1961 break; 1962 } 1963 ldns_buffer_printf(output, " ;{"); 1964 if ((fmt_st->flags & LDNS_COMMENT_FLAGS)) { 1965 if (ldns_nsec3_optout(rr)) { 1966 ldns_buffer_printf(output, 1967 " flags: optout"); 1968 } else { 1969 ldns_buffer_printf(output," flags: -"); 1970 } 1971 if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN && 1972 fmt_st->hashmap != NULL) { 1973 ldns_buffer_printf(output, ", "); 1974 } 1975 } 1976 if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN && 1977 fmt_st->hashmap != NULL) { 1978 ldns_rbnode_t *node; 1979 ldns_rdf *key = ldns_dname_label( 1980 ldns_rr_owner(rr), 0); 1981 if (key) { 1982 node = ldns_rbtree_search( 1983 fmt_st->hashmap, 1984 (void *) key); 1985 if (node->data) { 1986 ldns_buffer_printf(output, 1987 "from: "); 1988 (void) ldns_rdf2buffer_str( 1989 output, 1990 ldns_dnssec_name_name( 1991 (ldns_dnssec_name*) 1992 node->data 1993 )); 1994 } 1995 ldns_rdf_deep_free(key); 1996 } 1997 key = ldns_b32_ext2dname( 1998 ldns_nsec3_next_owner(rr)); 1999 if (key) { 2000 node = ldns_rbtree_search( 2001 fmt_st->hashmap, 2002 (void *) key); 2003 if (node->data) { 2004 ldns_buffer_printf(output, 2005 " to: "); 2006 (void) ldns_rdf2buffer_str( 2007 output, 2008 ldns_dnssec_name_name( 2009 (ldns_dnssec_name*) 2010 node->data 2011 )); 2012 } 2013 ldns_rdf_deep_free(key); 2014 } 2015 } 2016 ldns_buffer_printf(output, "}"); 2017 break; 2018 default: 2019 break; 2020 2021 } 2022 } 2023 /* last */ 2024 ldns_buffer_printf(output, "\n"); 2025 return ldns_buffer_status(output); 2026 } 2027 2028 ldns_status 2029 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr) 2030 { 2031 return ldns_rr2buffer_str_fmt(output, ldns_output_format_default, rr); 2032 } 2033 2034 ldns_status 2035 ldns_rr_list2buffer_str_fmt(ldns_buffer *output, 2036 const ldns_output_format *fmt, const ldns_rr_list *list) 2037 { 2038 uint16_t i; 2039 2040 for(i = 0; i < ldns_rr_list_rr_count(list); i++) { 2041 (void) ldns_rr2buffer_str_fmt(output, fmt, 2042 ldns_rr_list_rr(list, i)); 2043 } 2044 return ldns_buffer_status(output); 2045 } 2046 2047 ldns_status 2048 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list) 2049 { 2050 return ldns_rr_list2buffer_str_fmt( 2051 output, ldns_output_format_default, list); 2052 } 2053 2054 ldns_status 2055 ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt) 2056 { 2057 ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes, 2058 (int) ldns_pkt_get_opcode(pkt)); 2059 ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes, 2060 (int) ldns_pkt_get_rcode(pkt)); 2061 2062 ldns_buffer_printf(output, ";; ->>HEADER<<- "); 2063 if (opcode) { 2064 ldns_buffer_printf(output, "opcode: %s, ", opcode->name); 2065 } else { 2066 ldns_buffer_printf(output, "opcode: ?? (%u), ", 2067 ldns_pkt_get_opcode(pkt)); 2068 } 2069 if (rcode) { 2070 ldns_buffer_printf(output, "rcode: %s, ", rcode->name); 2071 } else { 2072 ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt)); 2073 } 2074 ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt)); 2075 ldns_buffer_printf(output, ";; flags: "); 2076 2077 if (ldns_pkt_qr(pkt)) { 2078 ldns_buffer_printf(output, "qr "); 2079 } 2080 if (ldns_pkt_aa(pkt)) { 2081 ldns_buffer_printf(output, "aa "); 2082 } 2083 if (ldns_pkt_tc(pkt)) { 2084 ldns_buffer_printf(output, "tc "); 2085 } 2086 if (ldns_pkt_rd(pkt)) { 2087 ldns_buffer_printf(output, "rd "); 2088 } 2089 if (ldns_pkt_cd(pkt)) { 2090 ldns_buffer_printf(output, "cd "); 2091 } 2092 if (ldns_pkt_ra(pkt)) { 2093 ldns_buffer_printf(output, "ra "); 2094 } 2095 if (ldns_pkt_ad(pkt)) { 2096 ldns_buffer_printf(output, "ad "); 2097 } 2098 ldns_buffer_printf(output, "; "); 2099 ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt)); 2100 ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt)); 2101 ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt)); 2102 ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt)); 2103 return ldns_buffer_status(output); 2104 } 2105 2106 2107 /* print EDNS option data in the Dig format: 76 61 6c 69 ... */ 2108 static void 2109 ldns_edns_hex_data2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2110 { 2111 size_t j; 2112 for (j = 0; j < len; j++) { 2113 ldns_buffer_printf(output, " %02x", data[j]); 2114 } 2115 } 2116 2117 static ldns_status 2118 ldns_edns_llq2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2119 { 2120 /* LLQ constants */ 2121 const char* llq_errors[] = {"NO-ERROR", "SERV-FULL", "STATIC", 2122 "FORMAT-ERR", "NO-SUCH-LLQ", "BAD-VERS", "UNKNOWN_ERR"}; 2123 const unsigned int llq_errors_num = 7; 2124 const char* llq_opcodes[] = {"LLQ-SETUP", "LLQ-REFRESH", "LLQ-EVENT"}; 2125 const unsigned int llq_opcodes_num = 3; 2126 2127 uint16_t version, llq_opcode, error_code; 2128 uint64_t llq_id; 2129 uint32_t lease_life; /* Requested or granted life of LLQ, in seconds */ 2130 2131 ldns_buffer_printf(output, "; Long-Lived Query:"); 2132 2133 /* read the record */ 2134 if(len != 18) { 2135 ldns_buffer_printf(output, " malformed LLQ "); 2136 ldns_edns_hex_data2buffer_str(output, data, len); 2137 2138 return ldns_buffer_status(output); 2139 } 2140 version = ldns_read_uint16(data); 2141 llq_opcode = ldns_read_uint16(data+2); 2142 error_code = ldns_read_uint16(data+4); 2143 memmove(&llq_id, data+6, sizeof(uint64_t)); 2144 lease_life = ldns_read_uint32(data+14); 2145 2146 /* print option field entires */ 2147 ldns_buffer_printf(output, "v%d ", (int)version); 2148 2149 if(llq_opcode < llq_opcodes_num) { 2150 ldns_buffer_printf(output, "%s", llq_opcodes[llq_opcode]); 2151 } else { 2152 ldns_buffer_printf(output, "opcode %d", (int)llq_opcode); 2153 } 2154 2155 if(error_code < llq_errors_num) 2156 ldns_buffer_printf(output, " %s", llq_errors[error_code]); 2157 else { 2158 ldns_buffer_printf(output, " error %d", (int)error_code); 2159 } 2160 2161 #ifndef USE_WINSOCK 2162 ldns_buffer_printf(output, " id %llx lease-life %lu", 2163 (unsigned long long)llq_id, (unsigned long)lease_life); 2164 #else 2165 ldns_buffer_printf(output, " id %I64x lease-life %lu", 2166 (unsigned long long)llq_id, (unsigned long)lease_life); 2167 #endif 2168 return ldns_buffer_status(output); 2169 } 2170 2171 2172 static ldns_status 2173 ldns_edns_ul2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2174 { 2175 uint32_t lease; 2176 2177 ldns_buffer_printf(output, "; Update Lease:"); 2178 2179 if(len != 4) { 2180 ldns_buffer_printf(output, " malformed UL "); 2181 ldns_edns_hex_data2buffer_str(output, data, len); 2182 return ldns_buffer_status(output); 2183 } 2184 lease = ldns_read_uint32(data); 2185 ldns_buffer_printf(output, "lease %lu", (unsigned long)lease); 2186 2187 return ldns_buffer_status(output); 2188 } 2189 2190 static ldns_status 2191 ldns_edns_nsid2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2192 { 2193 size_t i, printed=0; 2194 2195 ldns_buffer_printf(output, "; NSID:"); 2196 ldns_edns_hex_data2buffer_str(output, data, len); 2197 2198 /* print the human-readable text string */ 2199 for(i = 0; i < len; i++) { 2200 if(isprint((unsigned char)data[i]) || data[i] == '\t') { 2201 if(!printed) { 2202 ldns_buffer_printf(output, " ("); 2203 printed = 1; 2204 } 2205 ldns_buffer_printf(output, "%c", (char)data[i]); 2206 } 2207 } 2208 if(printed) 2209 ldns_buffer_printf(output, ")"); 2210 return ldns_buffer_status(output); 2211 } 2212 2213 2214 static ldns_status 2215 ldns_edns_dau2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2216 { 2217 size_t i; 2218 ldns_lookup_table *lt; 2219 2220 ldns_buffer_printf(output, "; DNSSEC Algorithm Understood (DAU):"); 2221 2222 for(i = 0; i <len; i++) { 2223 lt = ldns_lookup_by_id(ldns_algorithms, data[i]); 2224 if (lt && lt->name) { 2225 ldns_buffer_printf(output, " %s", lt->name); 2226 } else { 2227 ldns_buffer_printf(output, " ALG%u", data[i]); 2228 } 2229 } 2230 return ldns_buffer_status(output); 2231 } 2232 2233 static ldns_status 2234 ldns_edns_dhu2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2235 { 2236 size_t i; 2237 ldns_lookup_table *lt; 2238 2239 ldns_buffer_printf(output, "; DS Hash Understood (DHU):"); 2240 2241 for(i = 0; i < len; i++) { 2242 lt = ldns_lookup_by_id(ldns_hashes, data[i]); 2243 if (lt && lt->name) { 2244 ldns_buffer_printf(output, " %s", lt->name); 2245 } else { 2246 ldns_buffer_printf(output, " ALG%u", data[i]); 2247 } 2248 } 2249 return ldns_buffer_status(output); 2250 } 2251 2252 static ldns_status 2253 ldns_edns_d3u2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2254 { 2255 size_t i; 2256 2257 ldns_buffer_printf(output, "; NSEC3 Hash Understood (N3U):"); 2258 2259 for(i=0; i<len; i++) { 2260 if(data[i] == 1) { 2261 ldns_buffer_printf(output, " SHA1"); 2262 } else { 2263 ldns_buffer_printf(output, " %d", (int)data[i]); 2264 } 2265 } 2266 return ldns_buffer_status(output); 2267 } 2268 2269 static ldns_status 2270 ldns_edns_subnet2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2271 { 2272 uint16_t family; 2273 uint8_t source, scope; 2274 if(len < 4) { 2275 ldns_buffer_printf(output, "malformed subnet "); 2276 ldns_edns_hex_data2buffer_str(output, data, len); 2277 return ldns_buffer_status(output); 2278 } 2279 family = ldns_read_uint16(data); 2280 source = data[2]; 2281 scope = data[3]; 2282 if(family == 1) { 2283 /* IPv4 */ 2284 char buf[64]; 2285 uint8_t ip4[4]; 2286 memset(ip4, 0, sizeof(ip4)); 2287 if(len-4 > 4) { 2288 ldns_buffer_printf(output, "trailingdata:"); 2289 ldns_edns_hex_data2buffer_str(output, data+4+4, len-4-4); 2290 ldns_buffer_printf(output, " "); 2291 len = 4+4; 2292 } 2293 memmove(ip4, data+4, len-4); 2294 if(!inet_ntop(AF_INET, ip4, buf, (socklen_t) sizeof(buf))) { 2295 ldns_buffer_printf(output, "ip4ntoperror "); 2296 ldns_edns_hex_data2buffer_str(output, data+4+4, len-4-4); 2297 } else { 2298 ldns_buffer_printf(output, "%s", buf); 2299 } 2300 } else if(family == 2) { 2301 /* IPv6 */ 2302 char buf[64]; 2303 uint8_t ip6[16]; 2304 memset(ip6, 0, sizeof(ip6)); 2305 if(len-4 > 16) { 2306 ldns_buffer_printf(output, "trailingdata:"); 2307 ldns_edns_hex_data2buffer_str(output, data+4+16, len-4-16); 2308 ldns_buffer_printf(output, " "); 2309 len = 4+16; 2310 } 2311 memmove(ip6, data+4, len-4); 2312 #ifdef AF_INET6 2313 if(!inet_ntop(AF_INET6, ip6, buf, (socklen_t) sizeof(buf))) { 2314 ldns_buffer_printf(output, "ip6ntoperror "); 2315 ldns_edns_hex_data2buffer_str(output, data+4+4, len-4-4); 2316 } else { 2317 ldns_buffer_printf(output, "%s", buf); 2318 } 2319 #else 2320 ldns_edns_hex_data2buffer_str(output, data+4+4, len-4-4); 2321 #endif 2322 } else { 2323 /* unknown */ 2324 ldns_buffer_printf(output, "family %d ", (int)family); 2325 ldns_edns_hex_data2buffer_str(output, data, len); 2326 } 2327 ldns_buffer_printf(output, "/%d scope /%d", (int)source, (int)scope); 2328 2329 return ldns_buffer_status(output); 2330 } 2331 2332 static ldns_status 2333 ldns_edns_expire2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2334 { 2335 2336 ldns_buffer_printf(output, "; EXPIRE:"); 2337 2338 if (!(len == 0) || len == 4) { 2339 ldns_buffer_printf(output, "malformed expire "); 2340 ldns_edns_hex_data2buffer_str(output, data, len); 2341 2342 return ldns_buffer_status(output); 2343 } 2344 2345 // TODO can this output be more accurate? 2346 ldns_edns_hex_data2buffer_str(output, data, len); 2347 2348 return ldns_buffer_status(output); 2349 } 2350 2351 2352 static ldns_status 2353 ldns_edns_cookie2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2354 { 2355 ldns_buffer_printf(output, "; COOKIE:"); 2356 2357 /* the size of an EDNS cookie is restricted by RFC 7873 */ 2358 if (!(len == 8 || (len >= 16 && len < 40))) { 2359 ldns_buffer_printf(output, "malformed cookie "); 2360 ldns_edns_hex_data2buffer_str(output, data, len); 2361 } 2362 ldns_edns_hex_data2buffer_str(output, data, len); 2363 2364 return ldns_buffer_status(output); 2365 } 2366 2367 static ldns_status 2368 ldns_edns_keepalive2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2369 { 2370 uint16_t timeout; 2371 2372 ldns_buffer_printf(output, "; KEEPALIVE:"); 2373 2374 if(!(len == 0 || len == 2)) { 2375 ldns_buffer_printf(output, "malformed keepalive "); 2376 ldns_edns_hex_data2buffer_str(output, data, len); 2377 2378 return ldns_buffer_status(output); 2379 } 2380 2381 if(len == 0) { 2382 ldns_buffer_printf(output, "no timeout value (only valid for client option)"); 2383 } else { 2384 timeout = ldns_read_uint16(data); 2385 ldns_buffer_printf(output, "timeout value in units of 100ms %u", (int)timeout); 2386 } 2387 return ldns_buffer_status(output); 2388 } 2389 2390 static ldns_status 2391 ldns_edns_padding2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2392 { 2393 ldns_buffer_printf(output, "; PADDING: "); 2394 ldns_edns_hex_data2buffer_str(output, data, len); 2395 2396 return ldns_buffer_status(output); 2397 } 2398 2399 static ldns_status 2400 ldns_edns_chain2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2401 { 2402 ldns_rdf** temp = NULL; 2403 2404 ldns_buffer_printf(output, "; CHAIN: "); 2405 2406 if (ldns_str2rdf_dname(temp, (char*) data) != LDNS_STATUS_OK) { 2407 ldns_buffer_printf(output, "malformed chain "); 2408 ldns_edns_hex_data2buffer_str(output, data, len); 2409 2410 return ldns_buffer_status(output); 2411 } 2412 2413 ldns_characters2buffer_str(output, len, data); 2414 2415 return ldns_buffer_status(output); 2416 } 2417 2418 static ldns_status 2419 ldns_edns_key_tag2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2420 { 2421 size_t i; 2422 2423 ldns_buffer_printf(output, "; KEY TAG: "); 2424 2425 if(len < 2 || len % 2 != 0) { 2426 ldns_buffer_printf(output, "malformed key tag "); 2427 ldns_edns_hex_data2buffer_str(output, data, len); 2428 2429 return ldns_buffer_status(output); 2430 } 2431 2432 for (i = 0; i < len; i += 2) { 2433 uint16_t tag = ldns_read_uint16(data); 2434 2435 ldns_buffer_printf(output, " %hu", tag); 2436 } 2437 2438 return ldns_buffer_status(output); 2439 } 2440 2441 static ldns_status 2442 ldns_edns_ede2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2443 { 2444 size_t i; 2445 uint16_t ede; 2446 ldns_buffer_printf(output, "; EDE:"); 2447 2448 if(len < 2) { 2449 ldns_buffer_printf(output, "malformed ede "); 2450 ldns_edns_hex_data2buffer_str(output, data, len); 2451 2452 return ldns_buffer_status(output); 2453 } 2454 2455 ede = ldns_read_uint16(data); 2456 2457 switch (ede) { 2458 case LDNS_EDE_OTHER: 2459 ldns_buffer_printf(output, " 0 (Other): "); 2460 break; 2461 case LDNS_EDE_UNSUPPORTED_DNSKEY_ALG: 2462 ldns_buffer_printf(output, " 1 (Unsupported DNSKEY Algorithm)"); 2463 break; 2464 case LDNS_EDE_UNSUPPORTED_DS_DIGEST: 2465 ldns_buffer_printf(output, " 2 (Unsupported DS Digest type)"); 2466 break; 2467 case LDNS_EDE_STALE_ANSWER: 2468 ldns_buffer_printf(output, " 3 (Stale Answer)"); 2469 break; 2470 case LDNS_EDE_FORGED_ANSWER: 2471 ldns_buffer_printf(output, " 4 (Forged Answer)"); 2472 break; 2473 case LDNS_EDE_DNSSEC_INDETERMINATE: 2474 ldns_buffer_printf(output, " 5 (DNSSEC Indeterminate)"); 2475 break; 2476 case LDNS_EDE_DNSSEC_BOGUS: 2477 ldns_buffer_printf(output, " 6 (DNSSEC Bogus)"); 2478 break; 2479 case LDNS_EDE_SIGNATURE_EXPIRED: 2480 ldns_buffer_printf(output, " 7 (Signature Expired)"); 2481 break; 2482 case LDNS_EDE_SIGNATURE_NOT_YET_VALID: 2483 ldns_buffer_printf(output, " 8 (Signature Not Yet Valid)"); 2484 break; 2485 case LDNS_EDE_DNSKEY_MISSING: 2486 ldns_buffer_printf(output, " 9 (DNSKEY Missing)"); 2487 break; 2488 case LDNS_EDE_RRSIGS_MISSING: 2489 ldns_buffer_printf(output, " 10 (RRSIGs Missing)"); 2490 break; 2491 case LDNS_EDE_NO_ZONE_KEY_BIT_SET: 2492 ldns_buffer_printf(output, " 11 (No Zone Key Bit Set)"); 2493 break; 2494 case LDNS_EDE_NSEC_MISSING: 2495 ldns_buffer_printf(output, " 12 (NSEC Missing)"); 2496 break; 2497 case LDNS_EDE_CACHED_ERROR: 2498 ldns_buffer_printf(output, " 13 (Cached Error)"); 2499 break; 2500 case LDNS_EDE_NOT_READY: 2501 ldns_buffer_printf(output, " 14 (Not Ready)"); 2502 break; 2503 case LDNS_EDE_BLOCKED: 2504 ldns_buffer_printf(output, " 15 (Blocked)"); 2505 break; 2506 case LDNS_EDE_CENSORED: 2507 ldns_buffer_printf(output, " 16 (Censored)"); 2508 break; 2509 case LDNS_EDE_FILTERED: 2510 ldns_buffer_printf(output, " 17 (Filtered)"); 2511 break; 2512 case LDNS_EDE_PROHIBITED: 2513 ldns_buffer_printf(output, " 18 (Prohibited)"); 2514 break; 2515 case LDNS_EDE_STALE_NXDOMAIN_ANSWER: 2516 ldns_buffer_printf(output, " 19 (NXDOMAIN Answer)"); 2517 break; 2518 case LDNS_EDE_NOT_AUTHORITATIVE: 2519 ldns_buffer_printf(output, " 20 (Not Authoritative)"); 2520 break; 2521 case LDNS_EDE_NOT_SUPPORTED: 2522 ldns_buffer_printf(output, " 21 (Not Supported)"); 2523 break; 2524 case LDNS_EDE_NO_REACHABLE_AUTHORITY: 2525 ldns_buffer_printf(output, " 22 (No Reachable Authority)"); 2526 break; 2527 case LDNS_EDE_NETWORK_ERROR: 2528 ldns_buffer_printf(output, " 23 (Network Error)"); 2529 break; 2530 case LDNS_EDE_INVALID_DATA: 2531 ldns_buffer_printf(output, " 24 (Invalid Data)"); 2532 break; 2533 case LDNS_EDE_SIGNATURE_EXPIRED_BEFORE_VALID: 2534 ldns_buffer_printf(output, " 25 (Signature Expired Before Valid)"); 2535 break; 2536 case LDNS_EDE_TOO_EARLY: 2537 ldns_buffer_printf(output, " 26 (Too Early)"); 2538 break; 2539 default: 2540 ldns_buffer_printf(output, " %02x", data[0]); 2541 ldns_buffer_printf(output, " %02x", data[1]); 2542 break; 2543 } 2544 2545 /* skip the EDE code in the output */ 2546 data += 2; 2547 len -= 2; 2548 2549 if (len > 2) { 2550 /* format the hex bytes */ 2551 ldns_buffer_printf(output, ":"); 2552 for (i = 0; i < len; i++) { 2553 ldns_buffer_printf(output, " %02x", data[i]); 2554 } 2555 2556 /* format the human-readable string */ 2557 ldns_buffer_printf(output, " ("); 2558 ldns_characters2buffer_str(output, len, data); 2559 ldns_buffer_printf(output, ")"); 2560 } 2561 2562 return ldns_buffer_status(output); 2563 } 2564 2565 static ldns_status 2566 ldns_edns_client_tag2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2567 { 2568 ldns_buffer_printf(output, "; CLIENT-TAG:"); 2569 2570 if (len > 2) { 2571 ldns_buffer_printf(output, "malformed client-tag "); 2572 ldns_edns_hex_data2buffer_str(output, data, len); 2573 2574 return ldns_buffer_status(output); 2575 } 2576 2577 ldns_edns_hex_data2buffer_str(output, data, len); 2578 2579 return ldns_buffer_status(output); 2580 } 2581 2582 static ldns_status 2583 ldns_edns_server_tag2buffer_str(ldns_buffer* output, uint8_t* data, size_t len) 2584 { 2585 ldns_buffer_printf(output, "; SERVER-TAG:"); 2586 2587 if (len > 2) { 2588 ldns_buffer_printf(output, "malformed server-tag "); 2589 ldns_edns_hex_data2buffer_str(output, data, len); 2590 2591 return ldns_buffer_status(output); 2592 } 2593 2594 ldns_edns_hex_data2buffer_str(output, data, len); 2595 2596 return ldns_buffer_status(output); 2597 } 2598 2599 ldns_status 2600 ldns_edns_option_list2buffer_str(ldns_buffer *output, ldns_edns_option_list* edns_list) 2601 { 2602 size_t count = ldns_edns_option_list_get_count(edns_list); 2603 size_t i, size; 2604 uint8_t* data; 2605 2606 for (i = 0; i < count; i++) { 2607 ldns_edns_option_code code; 2608 ldns_edns_option* edns = ldns_edns_option_list_get_option(edns_list, i); 2609 2610 if (!edns) { 2611 break; 2612 } 2613 2614 code = ldns_edns_get_code(edns); 2615 size = ldns_edns_get_size(edns); 2616 data = ldns_edns_get_data(edns); 2617 2618 switch(code) { 2619 case LDNS_EDNS_LLQ: 2620 ldns_edns_llq2buffer_str(output, data, size); 2621 break; 2622 case LDNS_EDNS_UL: 2623 ldns_edns_ul2buffer_str(output, data, size); 2624 break; 2625 case LDNS_EDNS_NSID: 2626 ldns_edns_nsid2buffer_str(output, data, size); 2627 break; 2628 case LDNS_EDNS_DAU: 2629 ldns_edns_dau2buffer_str(output, data, size); 2630 break; 2631 case LDNS_EDNS_DHU: 2632 ldns_edns_dhu2buffer_str(output, data, size); 2633 break; 2634 case LDNS_EDNS_N3U: 2635 ldns_edns_d3u2buffer_str(output, data, size); 2636 break; 2637 case LDNS_EDNS_CLIENT_SUBNET: 2638 ldns_edns_subnet2buffer_str(output, data, size); 2639 break; 2640 case LDNS_EDNS_EXPIRE: 2641 ldns_edns_expire2buffer_str(output, data, size); 2642 break; 2643 case LDNS_EDNS_COOKIE: 2644 ldns_edns_cookie2buffer_str(output, data, size); 2645 break; 2646 case LDNS_EDNS_KEEPALIVE: 2647 ldns_edns_keepalive2buffer_str(output, data, size); 2648 break; 2649 case LDNS_EDNS_PADDING: 2650 ldns_edns_padding2buffer_str(output, data, size); 2651 break; 2652 case LDNS_EDNS_CHAIN: 2653 ldns_edns_chain2buffer_str(output, data, size); 2654 break; 2655 case LDNS_EDNS_KEY_TAG: 2656 ldns_edns_key_tag2buffer_str(output, data, size); 2657 break; 2658 case LDNS_EDNS_EDE: 2659 ldns_edns_ede2buffer_str(output, data, size); 2660 break; 2661 case LDNS_EDNS_CLIENT_TAG: 2662 ldns_edns_client_tag2buffer_str(output, data, size); 2663 break; 2664 case LDNS_EDNS_SERVER_TAG: 2665 ldns_edns_server_tag2buffer_str(output, data, size); 2666 break; 2667 default: 2668 ldns_buffer_printf(output, "; OPT=%d:", code); 2669 ldns_edns_hex_data2buffer_str(output, data, size); 2670 break; 2671 } 2672 ldns_buffer_printf(output, "\n"); 2673 } 2674 2675 return ldns_buffer_status(output); 2676 } 2677 2678 2679 ldns_status 2680 ldns_pkt2buffer_str_fmt(ldns_buffer *output, 2681 const ldns_output_format *fmt, const ldns_pkt *pkt) 2682 { 2683 uint16_t i; 2684 ldns_status status = LDNS_STATUS_OK; 2685 char *tmp; 2686 struct timeval time; 2687 time_t time_tt; 2688 int short_fmt = fmt && (fmt->flags & LDNS_FMT_SHORT); 2689 2690 if (!pkt) { 2691 ldns_buffer_printf(output, "null"); 2692 return LDNS_STATUS_OK; 2693 } 2694 2695 if (!ldns_buffer_status_ok(output)) { 2696 return ldns_buffer_status(output); 2697 } 2698 2699 if (!short_fmt) { 2700 status = ldns_pktheader2buffer_str(output, pkt); 2701 if (status != LDNS_STATUS_OK) { 2702 return status; 2703 } 2704 2705 ldns_buffer_printf(output, "\n"); 2706 2707 ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; "); 2708 2709 2710 for (i = 0; i < ldns_pkt_qdcount(pkt); i++) { 2711 status = ldns_rr2buffer_str_fmt(output, fmt, 2712 ldns_rr_list_rr( 2713 ldns_pkt_question(pkt), i)); 2714 if (status != LDNS_STATUS_OK) { 2715 return status; 2716 } 2717 } 2718 ldns_buffer_printf(output, "\n"); 2719 2720 ldns_buffer_printf(output, ";; ANSWER SECTION:\n"); 2721 } 2722 for (i = 0; i < ldns_pkt_ancount(pkt); i++) { 2723 status = ldns_rr2buffer_str_fmt(output, fmt, 2724 ldns_rr_list_rr( 2725 ldns_pkt_answer(pkt), i)); 2726 if (status != LDNS_STATUS_OK) { 2727 return status; 2728 } 2729 } 2730 if (!short_fmt) { 2731 ldns_buffer_printf(output, "\n"); 2732 2733 ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n"); 2734 2735 for (i = 0; i < ldns_pkt_nscount(pkt); i++) { 2736 status = ldns_rr2buffer_str_fmt(output, fmt, 2737 ldns_rr_list_rr( 2738 ldns_pkt_authority(pkt), i)); 2739 if (status != LDNS_STATUS_OK) { 2740 return status; 2741 } 2742 } 2743 ldns_buffer_printf(output, "\n"); 2744 2745 ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n"); 2746 for (i = 0; i < ldns_pkt_arcount(pkt); i++) { 2747 status = ldns_rr2buffer_str_fmt(output, fmt, 2748 ldns_rr_list_rr( 2749 ldns_pkt_additional(pkt), i)); 2750 if (status != LDNS_STATUS_OK) { 2751 return status; 2752 } 2753 2754 } 2755 ldns_buffer_printf(output, "\n"); 2756 /* add some further fields */ 2757 ldns_buffer_printf(output, ";; Query time: %d msec\n", 2758 ldns_pkt_querytime(pkt)); 2759 if (ldns_pkt_edns(pkt)) { 2760 ldns_buffer_printf(output, 2761 ";; EDNS: version %u; flags:", 2762 ldns_pkt_edns_version(pkt)); 2763 if (ldns_pkt_edns_do(pkt)) { 2764 ldns_buffer_printf(output, " do"); 2765 } 2766 /* the extended rcode is the value set, shifted four bits, 2767 * and or'd with the original rcode */ 2768 if (ldns_pkt_edns_extended_rcode(pkt)) { 2769 ldns_buffer_printf(output, " ; ext-rcode: %d", 2770 (ldns_pkt_edns_extended_rcode(pkt) << 4 | ldns_pkt_get_rcode(pkt))); 2771 } 2772 ldns_buffer_printf(output, " ; udp: %u\n", 2773 ldns_pkt_edns_udp_size(pkt)); 2774 2775 if (pkt->_edns_list) 2776 ldns_edns_option_list2buffer_str(output, pkt->_edns_list); 2777 2778 else if (ldns_pkt_edns_data(pkt)) { 2779 ldns_edns_option_list* edns_list; 2780 /* parse the EDNS data into separate EDNS options 2781 * and add them to the list */ 2782 if ((edns_list = pkt_edns_data2edns_option_list(ldns_pkt_edns_data(pkt)))) { 2783 ldns_edns_option_list2buffer_str(output, edns_list); 2784 ldns_edns_option_list_deep_free(edns_list); 2785 } else { 2786 ldns_buffer_printf(output, ";; Data: "); 2787 (void)ldns_rdf2buffer_str(output, ldns_pkt_edns_data(pkt)); 2788 } 2789 } 2790 } 2791 if (ldns_pkt_tsig(pkt)) { 2792 ldns_buffer_printf(output, ";; TSIG:\n;; "); 2793 (void) ldns_rr2buffer_str_fmt( 2794 output, fmt, ldns_pkt_tsig(pkt)); 2795 ldns_buffer_printf(output, "\n"); 2796 } 2797 if (ldns_pkt_answerfrom(pkt)) { 2798 tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt)); 2799 ldns_buffer_printf(output, ";; SERVER: %s\n", tmp); 2800 LDNS_FREE(tmp); 2801 } 2802 time = ldns_pkt_timestamp(pkt); 2803 time_tt = (time_t)time.tv_sec; 2804 ldns_buffer_printf(output, ";; WHEN: %s", 2805 (char*)ctime(&time_tt)); 2806 2807 ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n", 2808 (int)ldns_pkt_size(pkt)); 2809 } 2810 return status; 2811 } 2812 2813 ldns_status 2814 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt) 2815 { 2816 return ldns_pkt2buffer_str_fmt(output, ldns_output_format_default, pkt); 2817 } 2818 2819 2820 #ifdef HAVE_SSL 2821 static ldns_status 2822 ldns_hmac_key2buffer_str(ldns_buffer *output, const ldns_key *k) 2823 { 2824 ldns_status status; 2825 size_t i; 2826 ldns_rdf *b64_bignum; 2827 2828 ldns_buffer_printf(output, "Key: "); 2829 2830 i = ldns_key_hmac_size(k); 2831 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k)); 2832 status = ldns_rdf2buffer_str(output, b64_bignum); 2833 ldns_rdf_deep_free(b64_bignum); 2834 ldns_buffer_printf(output, "\n"); 2835 return status; 2836 } 2837 #endif 2838 2839 #if defined(HAVE_SSL) && defined(USE_GOST) 2840 static ldns_status 2841 ldns_gost_key2buffer_str(ldns_buffer *output, EVP_PKEY *p) 2842 { 2843 unsigned char* pp = NULL; 2844 int ret; 2845 ldns_rdf *b64_bignum; 2846 ldns_status status; 2847 2848 ldns_buffer_printf(output, "GostAsn1: "); 2849 2850 ret = i2d_PrivateKey(p, &pp); 2851 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, (size_t)ret, pp); 2852 status = ldns_rdf2buffer_str(output, b64_bignum); 2853 2854 ldns_rdf_deep_free(b64_bignum); 2855 OPENSSL_free(pp); 2856 ldns_buffer_printf(output, "\n"); 2857 return status; 2858 } 2859 #endif 2860 2861 #if defined(HAVE_SSL) && defined(USE_ED25519) 2862 static ldns_status 2863 ldns_ed25519_key2buffer_str(ldns_buffer *output, EVP_PKEY *p) 2864 { 2865 unsigned char* pp = NULL; 2866 int ret; 2867 ldns_rdf *b64_bignum; 2868 ldns_status status; 2869 2870 ldns_buffer_printf(output, "PrivateKey: "); 2871 2872 ret = i2d_PrivateKey(p, &pp); 2873 /* 16 byte asn (302e020100300506032b657004220420) + 32byte key */ 2874 if(ret != 16 + 32) { 2875 OPENSSL_free(pp); 2876 return LDNS_STATUS_ERR; 2877 } 2878 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, 2879 (size_t)ret-16, pp+16); 2880 status = ldns_rdf2buffer_str(output, b64_bignum); 2881 2882 ldns_rdf_deep_free(b64_bignum); 2883 OPENSSL_free(pp); 2884 ldns_buffer_printf(output, "\n"); 2885 return status; 2886 } 2887 #endif 2888 2889 #if defined(HAVE_SSL) && defined(USE_ED448) 2890 static ldns_status 2891 ldns_ed448_key2buffer_str(ldns_buffer *output, EVP_PKEY *p) 2892 { 2893 unsigned char* pp = NULL; 2894 int ret; 2895 ldns_rdf *b64_bignum; 2896 ldns_status status; 2897 2898 ldns_buffer_printf(output, "PrivateKey: "); 2899 2900 ret = i2d_PrivateKey(p, &pp); 2901 /* some-ASN + 57byte key */ 2902 if(ret != 16 + 57) { 2903 OPENSSL_free(pp); 2904 return LDNS_STATUS_ERR; 2905 } 2906 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, 2907 (size_t)ret-16, pp+16); 2908 status = ldns_rdf2buffer_str(output, b64_bignum); 2909 2910 ldns_rdf_deep_free(b64_bignum); 2911 OPENSSL_free(pp); 2912 ldns_buffer_printf(output, "\n"); 2913 return status; 2914 } 2915 #endif 2916 2917 #if defined(HAVE_SSL) 2918 /** print one b64 encoded bignum to a line in the keybuffer */ 2919 static int 2920 ldns_print_bignum_b64_line(ldns_buffer* output, const char* label, const BIGNUM* num) 2921 { 2922 unsigned char *bignumbuf = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN); 2923 if(!bignumbuf) return 0; 2924 2925 ldns_buffer_printf(output, "%s: ", label); 2926 if(num) { 2927 ldns_rdf *b64_bignum = NULL; 2928 int i = BN_bn2bin(num, bignumbuf); 2929 if (i > LDNS_MAX_KEYLEN) { 2930 LDNS_FREE(bignumbuf); 2931 return 0; 2932 } 2933 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, (size_t)i, bignumbuf); 2934 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 2935 ldns_rdf_deep_free(b64_bignum); 2936 LDNS_FREE(bignumbuf); 2937 return 0; 2938 } 2939 ldns_rdf_deep_free(b64_bignum); 2940 ldns_buffer_printf(output, "\n"); 2941 } else { 2942 ldns_buffer_printf(output, "(Not available)\n"); 2943 } 2944 LDNS_FREE(bignumbuf); 2945 return 1; 2946 } 2947 #endif 2948 2949 ldns_status 2950 ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k) 2951 { 2952 ldns_status status = LDNS_STATUS_OK; 2953 unsigned char *bignum; 2954 #ifdef HAVE_SSL 2955 RSA *rsa; 2956 #ifdef USE_DSA 2957 DSA *dsa; 2958 #endif /* USE_DSA */ 2959 #endif /* HAVE_SSL */ 2960 2961 if (!k) { 2962 return LDNS_STATUS_ERR; 2963 } 2964 2965 bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN); 2966 if (!bignum) { 2967 return LDNS_STATUS_ERR; 2968 } 2969 2970 if (ldns_buffer_status_ok(output)) { 2971 #ifdef HAVE_SSL 2972 switch(ldns_key_algorithm(k)) { 2973 case LDNS_SIGN_RSASHA1: 2974 case LDNS_SIGN_RSASHA1_NSEC3: 2975 case LDNS_SIGN_RSASHA256: 2976 case LDNS_SIGN_RSASHA512: 2977 case LDNS_SIGN_RSAMD5: 2978 /* copied by looking at dnssec-keygen output */ 2979 /* header */ 2980 rsa = ldns_key_rsa_key(k); 2981 2982 ldns_buffer_printf(output,"Private-key-format: v1.2\n"); 2983 switch(ldns_key_algorithm(k)) { 2984 case LDNS_SIGN_RSAMD5: 2985 ldns_buffer_printf(output, 2986 "Algorithm: %u (RSA)\n", 2987 LDNS_RSAMD5); 2988 break; 2989 case LDNS_SIGN_RSASHA1: 2990 ldns_buffer_printf(output, 2991 "Algorithm: %u (RSASHA1)\n", 2992 LDNS_RSASHA1); 2993 break; 2994 case LDNS_SIGN_RSASHA1_NSEC3: 2995 ldns_buffer_printf(output, 2996 "Algorithm: %u (RSASHA1_NSEC3)\n", 2997 LDNS_RSASHA1_NSEC3); 2998 break; 2999 #ifdef USE_SHA2 3000 case LDNS_SIGN_RSASHA256: 3001 ldns_buffer_printf(output, 3002 "Algorithm: %u (RSASHA256)\n", 3003 LDNS_RSASHA256); 3004 break; 3005 case LDNS_SIGN_RSASHA512: 3006 ldns_buffer_printf(output, 3007 "Algorithm: %u (RSASHA512)\n", 3008 LDNS_RSASHA512); 3009 break; 3010 #endif 3011 default: 3012 #ifdef STDERR_MSGS 3013 fprintf(stderr, "Warning: unknown signature "); 3014 fprintf(stderr, 3015 "algorithm type %u\n", 3016 ldns_key_algorithm(k)); 3017 #endif 3018 ldns_buffer_printf(output, 3019 "Algorithm: %u (Unknown)\n", 3020 ldns_key_algorithm(k)); 3021 break; 3022 } 3023 3024 /* print to buf, convert to bin, convert to b64, 3025 * print to buf */ 3026 3027 #ifndef S_SPLINT_S 3028 if(1) { 3029 const BIGNUM *n=NULL, *e=NULL, *d=NULL, 3030 *p=NULL, *q=NULL, *dmp1=NULL, 3031 *dmq1=NULL, *iqmp=NULL; 3032 #if OPENSSL_VERSION_NUMBER < 0x10100000 || (defined(HAVE_LIBRESSL) && LIBRESSL_VERSION_NUMBER < 0x20700000) 3033 n = rsa->n; 3034 e = rsa->e; 3035 d = rsa->d; 3036 p = rsa->p; 3037 q = rsa->q; 3038 dmp1 = rsa->dmp1; 3039 dmq1 = rsa->dmq1; 3040 iqmp = rsa->iqmp; 3041 #else 3042 RSA_get0_key(rsa, &n, &e, &d); 3043 RSA_get0_factors(rsa, &p, &q); 3044 RSA_get0_crt_params(rsa, &dmp1, 3045 &dmq1, &iqmp); 3046 #endif 3047 if(!ldns_print_bignum_b64_line(output, "Modulus", n)) 3048 goto error; 3049 if(!ldns_print_bignum_b64_line(output, "PublicExponent", e)) 3050 goto error; 3051 if(!ldns_print_bignum_b64_line(output, "PrivateExponent", d)) 3052 goto error; 3053 if(!ldns_print_bignum_b64_line(output, "Prime1", p)) 3054 goto error; 3055 if(!ldns_print_bignum_b64_line(output, "Prime2", q)) 3056 goto error; 3057 if(!ldns_print_bignum_b64_line(output, "Exponent1", dmp1)) 3058 goto error; 3059 if(!ldns_print_bignum_b64_line(output, "Exponent2", dmq1)) 3060 goto error; 3061 if(!ldns_print_bignum_b64_line(output, "Coefficient", iqmp)) 3062 goto error; 3063 } 3064 #endif /* splint */ 3065 3066 RSA_free(rsa); 3067 break; 3068 #ifdef USE_DSA 3069 case LDNS_SIGN_DSA: 3070 case LDNS_SIGN_DSA_NSEC3: 3071 dsa = ldns_key_dsa_key(k); 3072 3073 ldns_buffer_printf(output,"Private-key-format: v1.2\n"); 3074 if (ldns_key_algorithm(k) == LDNS_SIGN_DSA) { 3075 ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n"); 3076 } else if (ldns_key_algorithm(k) == LDNS_SIGN_DSA_NSEC3) { 3077 ldns_buffer_printf(output,"Algorithm: 6 (DSA_NSEC3)\n"); 3078 } 3079 3080 /* print to buf, convert to bin, convert to b64, 3081 * print to buf */ 3082 if(1) { 3083 const BIGNUM *p=NULL, *q=NULL, *g=NULL, 3084 *priv_key=NULL, *pub_key=NULL; 3085 #if OPENSSL_VERSION_NUMBER < 0x10100000 || (defined(HAVE_LIBRESSL) && LIBRESSL_VERSION_NUMBER < 0x20700000) 3086 #ifndef S_SPLINT_S 3087 p = dsa->p; 3088 q = dsa->q; 3089 g = dsa->g; 3090 priv_key = dsa->priv_key; 3091 pub_key = dsa->pub_key; 3092 #endif /* splint */ 3093 #else 3094 DSA_get0_pqg(dsa, &p, &q, &g); 3095 DSA_get0_key(dsa, &pub_key, &priv_key); 3096 #endif 3097 if(!ldns_print_bignum_b64_line(output, "Prime(p)", p)) 3098 goto error; 3099 if(!ldns_print_bignum_b64_line(output, "Subprime(q)", q)) 3100 goto error; 3101 if(!ldns_print_bignum_b64_line(output, "Base(g)", g)) 3102 goto error; 3103 if(!ldns_print_bignum_b64_line(output, "Private_value(x)", priv_key)) 3104 goto error; 3105 if(!ldns_print_bignum_b64_line(output, "Public_value(y)", pub_key)) 3106 goto error; 3107 } 3108 break; 3109 #endif /* USE_DSA */ 3110 case LDNS_SIGN_ECC_GOST: 3111 /* no format defined, use blob */ 3112 #if defined(HAVE_SSL) && defined(USE_GOST) 3113 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 3114 ldns_buffer_printf(output, "Algorithm: %d (ECC-GOST)\n", LDNS_SIGN_ECC_GOST); 3115 status = ldns_gost_key2buffer_str(output, 3116 #ifndef S_SPLINT_S 3117 k->_key.key 3118 #else 3119 NULL 3120 #endif 3121 ); 3122 #else 3123 goto error; 3124 #endif /* GOST */ 3125 break; 3126 case LDNS_SIGN_ECDSAP256SHA256: 3127 case LDNS_SIGN_ECDSAP384SHA384: 3128 #ifdef USE_ECDSA 3129 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 3130 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k)); 3131 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k)); 3132 #ifndef S_SPLINT_S 3133 ldns_buffer_printf(output, ")\n"); 3134 if(k->_key.key) { 3135 EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->_key.key); 3136 const BIGNUM* b = EC_KEY_get0_private_key(ec); 3137 if(!ldns_print_bignum_b64_line(output, "PrivateKey", b)) 3138 goto error; 3139 /* down reference count in EC_KEY 3140 * its still assigned to the PKEY */ 3141 EC_KEY_free(ec); 3142 } 3143 #endif /* splint */ 3144 #else 3145 goto error; 3146 #endif /* ECDSA */ 3147 break; 3148 #ifdef USE_ED25519 3149 case LDNS_SIGN_ED25519: 3150 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 3151 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k)); 3152 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k)); 3153 ldns_buffer_printf(output, ")\n"); 3154 if (status) break; 3155 status = ldns_ed25519_key2buffer_str(output, 3156 k->_key.key); 3157 break; 3158 #endif /* USE_ED25519 */ 3159 #ifdef USE_ED448 3160 case LDNS_SIGN_ED448: 3161 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 3162 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k)); 3163 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k)); 3164 ldns_buffer_printf(output, ")\n"); 3165 if (status) break; 3166 status = ldns_ed448_key2buffer_str(output, 3167 k->_key.key); 3168 break; 3169 #endif /* USE_ED448 */ 3170 case LDNS_SIGN_HMACMD5: 3171 /* there's not much of a format defined for TSIG */ 3172 /* It's just a binary blob, Same for all algorithms */ 3173 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 3174 ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n"); 3175 status = ldns_hmac_key2buffer_str(output, k); 3176 break; 3177 case LDNS_SIGN_HMACSHA1: 3178 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 3179 ldns_buffer_printf(output, "Algorithm: 158 (HMAC_SHA1)\n"); 3180 status = ldns_hmac_key2buffer_str(output, k); 3181 break; 3182 case LDNS_SIGN_HMACSHA224: 3183 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 3184 ldns_buffer_printf(output, "Algorithm: 162 (HMAC_SHA224)\n"); 3185 status = ldns_hmac_key2buffer_str(output, k); 3186 break; 3187 case LDNS_SIGN_HMACSHA256: 3188 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 3189 ldns_buffer_printf(output, "Algorithm: 159 (HMAC_SHA256)\n"); 3190 status = ldns_hmac_key2buffer_str(output, k); 3191 break; 3192 case LDNS_SIGN_HMACSHA384: 3193 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 3194 ldns_buffer_printf(output, "Algorithm: 164 (HMAC_SHA384)\n"); 3195 status = ldns_hmac_key2buffer_str(output, k); 3196 break; 3197 case LDNS_SIGN_HMACSHA512: 3198 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 3199 ldns_buffer_printf(output, "Algorithm: 165 (HMAC_SHA512)\n"); 3200 status = ldns_hmac_key2buffer_str(output, k); 3201 break; 3202 } 3203 #endif /* HAVE_SSL */ 3204 } else { 3205 LDNS_FREE(bignum); 3206 return ldns_buffer_status(output); 3207 } 3208 LDNS_FREE(bignum); 3209 return status; 3210 3211 #ifdef HAVE_SSL 3212 /* compiles warn the label isn't used */ 3213 error: 3214 LDNS_FREE(bignum); 3215 return LDNS_STATUS_ERR; 3216 #endif /* HAVE_SSL */ 3217 3218 } 3219 3220 /* 3221 * Zero terminate the buffer and copy data. 3222 */ 3223 char * 3224 ldns_buffer2str(ldns_buffer *buffer) 3225 { 3226 char *str; 3227 3228 /* check if buffer ends with \0, if not, and 3229 if there is space, add it */ 3230 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) { 3231 if (!ldns_buffer_reserve(buffer, 1)) { 3232 return NULL; 3233 } 3234 ldns_buffer_write_char(buffer, (uint8_t) '\0'); 3235 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) { 3236 return NULL; 3237 } 3238 } 3239 3240 str = strdup((const char *)ldns_buffer_begin(buffer)); 3241 if(!str) { 3242 return NULL; 3243 } 3244 return str; 3245 } 3246 3247 /* 3248 * Zero terminate the buffer and export data. 3249 */ 3250 char * 3251 ldns_buffer_export2str(ldns_buffer *buffer) 3252 { 3253 /* Append '\0' as string terminator */ 3254 if (! ldns_buffer_reserve(buffer, 1)) { 3255 return NULL; 3256 } 3257 ldns_buffer_write_char(buffer, 0); 3258 3259 /* reallocate memory to the size of the string and export */ 3260 ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer)); 3261 return ldns_buffer_export(buffer); 3262 } 3263 3264 char * 3265 ldns_rdf2str(const ldns_rdf *rdf) 3266 { 3267 char *result = NULL; 3268 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); 3269 3270 if (!tmp_buffer) { 3271 return NULL; 3272 } 3273 if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) { 3274 /* export and return string, destroy rest */ 3275 result = ldns_buffer_export2str(tmp_buffer); 3276 } 3277 ldns_buffer_free(tmp_buffer); 3278 return result; 3279 } 3280 3281 char * 3282 ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr) 3283 { 3284 char *result = NULL; 3285 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); 3286 3287 if (!tmp_buffer) { 3288 return NULL; 3289 } 3290 if (ldns_rr2buffer_str_fmt(tmp_buffer, fmt, rr) 3291 == LDNS_STATUS_OK) { 3292 /* export and return string, destroy rest */ 3293 result = ldns_buffer_export2str(tmp_buffer); 3294 } 3295 ldns_buffer_free(tmp_buffer); 3296 return result; 3297 } 3298 3299 char * 3300 ldns_rr2str(const ldns_rr *rr) 3301 { 3302 return ldns_rr2str_fmt(ldns_output_format_default, rr); 3303 } 3304 3305 char * 3306 ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt) 3307 { 3308 char *result = NULL; 3309 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); 3310 3311 if (!tmp_buffer) { 3312 return NULL; 3313 } 3314 if (ldns_pkt2buffer_str_fmt(tmp_buffer, fmt, pkt) 3315 == LDNS_STATUS_OK) { 3316 /* export and return string, destroy rest */ 3317 result = ldns_buffer_export2str(tmp_buffer); 3318 } 3319 3320 ldns_buffer_free(tmp_buffer); 3321 return result; 3322 } 3323 3324 char * 3325 ldns_pkt2str(const ldns_pkt *pkt) 3326 { 3327 return ldns_pkt2str_fmt(ldns_output_format_default, pkt); 3328 } 3329 3330 char * 3331 ldns_key2str(const ldns_key *k) 3332 { 3333 char *result = NULL; 3334 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); 3335 3336 if (!tmp_buffer) { 3337 return NULL; 3338 } 3339 if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) { 3340 /* export and return string, destroy rest */ 3341 result = ldns_buffer_export2str(tmp_buffer); 3342 } 3343 ldns_buffer_free(tmp_buffer); 3344 return result; 3345 } 3346 3347 char * 3348 ldns_rr_list2str_fmt(const ldns_output_format *fmt, const ldns_rr_list *list) 3349 { 3350 char *result = NULL; 3351 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); 3352 3353 if (!tmp_buffer) { 3354 return NULL; 3355 } 3356 if (list) { 3357 if (ldns_rr_list2buffer_str_fmt( 3358 tmp_buffer, fmt, list) 3359 == LDNS_STATUS_OK) { 3360 } 3361 } else { 3362 if (fmt == NULL) { 3363 fmt = ldns_output_format_default; 3364 } 3365 if (fmt->flags & LDNS_COMMENT_NULLS) { 3366 ldns_buffer_printf(tmp_buffer, "; (null)\n"); 3367 } 3368 } 3369 3370 /* export and return string, destroy rest */ 3371 result = ldns_buffer_export2str(tmp_buffer); 3372 ldns_buffer_free(tmp_buffer); 3373 return result; 3374 } 3375 3376 char * 3377 ldns_rr_list2str(const ldns_rr_list *list) 3378 { 3379 return ldns_rr_list2str_fmt(ldns_output_format_default, list); 3380 } 3381 3382 void 3383 ldns_rdf_print(FILE *output, const ldns_rdf *rdf) 3384 { 3385 char *str = ldns_rdf2str(rdf); 3386 if (str) { 3387 fprintf(output, "%s", str); 3388 } else { 3389 fprintf(output, ";Unable to convert rdf to string\n"); 3390 } 3391 LDNS_FREE(str); 3392 } 3393 3394 void 3395 ldns_rr_print_fmt(FILE *output, 3396 const ldns_output_format *fmt, const ldns_rr *rr) 3397 { 3398 char *str = ldns_rr2str_fmt(fmt, rr); 3399 if (str) { 3400 fprintf(output, "%s", str); 3401 } else { 3402 fprintf(output, ";Unable to convert rr to string\n"); 3403 } 3404 LDNS_FREE(str); 3405 } 3406 3407 void 3408 ldns_rr_print(FILE *output, const ldns_rr *rr) 3409 { 3410 ldns_rr_print_fmt(output, ldns_output_format_default, rr); 3411 } 3412 3413 void 3414 ldns_pkt_print_fmt(FILE *output, 3415 const ldns_output_format *fmt, const ldns_pkt *pkt) 3416 { 3417 char *str = ldns_pkt2str_fmt(fmt, pkt); 3418 if (str) { 3419 fprintf(output, "%s", str); 3420 } else { 3421 fprintf(output, ";Unable to convert packet to string\n"); 3422 } 3423 LDNS_FREE(str); 3424 } 3425 3426 void 3427 ldns_pkt_print(FILE *output, const ldns_pkt *pkt) 3428 { 3429 ldns_pkt_print_fmt(output, ldns_output_format_default, pkt); 3430 } 3431 3432 void 3433 ldns_rr_list_print_fmt(FILE *output, 3434 const ldns_output_format *fmt, const ldns_rr_list *lst) 3435 { 3436 size_t i; 3437 for (i = 0; i < ldns_rr_list_rr_count(lst); i++) { 3438 ldns_rr_print_fmt(output, fmt, ldns_rr_list_rr(lst, i)); 3439 } 3440 } 3441 3442 void 3443 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst) 3444 { 3445 ldns_rr_list_print_fmt(output, ldns_output_format_default, lst); 3446 } 3447 3448 void 3449 ldns_resolver_print_fmt(FILE *output, 3450 const ldns_output_format *fmt, const ldns_resolver *r) 3451 { 3452 uint16_t i; 3453 ldns_rdf **n; 3454 ldns_rdf **s; 3455 size_t *rtt; 3456 if (!r) { 3457 return; 3458 } 3459 n = ldns_resolver_nameservers(r); 3460 s = ldns_resolver_searchlist(r); 3461 rtt = ldns_resolver_rtt(r); 3462 3463 fprintf(output, "port: %d\n", (int)ldns_resolver_port(r)); 3464 fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r)); 3465 fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r)); 3466 3467 fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r)); 3468 fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r)); 3469 fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r)); 3470 fprintf(output, "fail: %d\n", ldns_resolver_fail(r)); 3471 fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r)); 3472 fprintf(output, "retrans: %d\n", (int)ldns_resolver_retrans(r)); 3473 fprintf(output, "fallback: %d\n", ldns_resolver_fallback(r)); 3474 fprintf(output, "random: %d\n", ldns_resolver_random(r)); 3475 fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec); 3476 fprintf(output, "dnssec: %d\n", ldns_resolver_dnssec(r)); 3477 fprintf(output, "dnssec cd: %d\n", ldns_resolver_dnssec_cd(r)); 3478 fprintf(output, "trust anchors (%d listed):\n", 3479 (int)ldns_rr_list_rr_count(ldns_resolver_dnssec_anchors(r))); 3480 ldns_rr_list_print_fmt(output, fmt, ldns_resolver_dnssec_anchors(r)); 3481 fprintf(output, "tsig: %s %s\n", 3482 ldns_resolver_tsig_keyname(r)?ldns_resolver_tsig_keyname(r):"-", 3483 ldns_resolver_tsig_algorithm(r)?ldns_resolver_tsig_algorithm(r):"-"); 3484 fprintf(output, "debug: %d\n", ldns_resolver_debug(r)); 3485 3486 fprintf(output, "default domain: "); 3487 ldns_rdf_print(output, ldns_resolver_domain(r)); 3488 fprintf(output, "\n"); 3489 fprintf(output, "apply default domain: %d\n", ldns_resolver_defnames(r)); 3490 3491 fprintf(output, "searchlist (%d listed):\n", (int)ldns_resolver_searchlist_count(r)); 3492 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) { 3493 fprintf(output, "\t"); 3494 ldns_rdf_print(output, s[i]); 3495 fprintf(output, "\n"); 3496 } 3497 fprintf(output, "apply search list: %d\n", ldns_resolver_dnsrch(r)); 3498 3499 fprintf(output, "nameservers (%d listed):\n", (int)ldns_resolver_nameserver_count(r)); 3500 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) { 3501 fprintf(output, "\t"); 3502 ldns_rdf_print(output, n[i]); 3503 3504 switch ((int)rtt[i]) { 3505 case LDNS_RESOLV_RTT_MIN: 3506 fprintf(output, " - reachable\n"); 3507 break; 3508 case LDNS_RESOLV_RTT_INF: 3509 fprintf(output, " - unreachable\n"); 3510 break; 3511 } 3512 } 3513 } 3514 3515 void 3516 ldns_resolver_print(FILE *output, const ldns_resolver *r) 3517 { 3518 ldns_resolver_print_fmt(output, ldns_output_format_default, r); 3519 } 3520 3521 void 3522 ldns_zone_print_fmt(FILE *output, 3523 const ldns_output_format *fmt, const ldns_zone *z) 3524 { 3525 if(ldns_zone_soa(z)) 3526 ldns_rr_print_fmt(output, fmt, ldns_zone_soa(z)); 3527 ldns_rr_list_print_fmt(output, fmt, ldns_zone_rrs(z)); 3528 } 3529 void 3530 ldns_zone_print(FILE *output, const ldns_zone *z) 3531 { 3532 ldns_zone_print_fmt(output, ldns_output_format_default, z); 3533 } 3534