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 17 #include <limits.h> 18 19 #ifdef HAVE_SYS_SOCKET_H 20 #include <sys/socket.h> 21 #endif 22 #ifdef HAVE_ARPA_INET_H 23 #include <arpa/inet.h> 24 #endif 25 #ifdef HAVE_NETDB_H 26 #include <netdb.h> 27 #endif 28 #include <time.h> 29 #include <sys/time.h> 30 31 #ifndef INET_ADDRSTRLEN 32 #define INET_ADDRSTRLEN 16 33 #endif 34 #ifndef INET6_ADDRSTRLEN 35 #define INET6_ADDRSTRLEN 46 36 #endif 37 38 /* lookup tables for standard DNS stuff */ 39 40 /* Taken from RFC 2535, section 7. */ 41 ldns_lookup_table ldns_algorithms[] = { 42 { LDNS_RSAMD5, "RSAMD5" }, 43 { LDNS_DH, "DH" }, 44 { LDNS_DSA, "DSA" }, 45 { LDNS_ECC, "ECC" }, 46 { LDNS_RSASHA1, "RSASHA1" }, 47 { LDNS_DSA_NSEC3, "DSA-NSEC3-SHA1" }, 48 { LDNS_RSASHA1_NSEC3, "RSASHA1-NSEC3-SHA1" }, 49 #ifdef USE_SHA2 50 { LDNS_RSASHA256, "RSASHA256"}, 51 { LDNS_RSASHA512, "RSASHA512"}, 52 #endif 53 #ifdef USE_GOST 54 { LDNS_ECC_GOST, "ECC-GOST"}, 55 #endif 56 #ifdef USE_ECDSA 57 { LDNS_ECDSAP256SHA256, "ECDSAP256SHA256"}, 58 { LDNS_ECDSAP384SHA384, "ECDSAP384SHA384"}, 59 #endif 60 { LDNS_INDIRECT, "INDIRECT" }, 61 { LDNS_PRIVATEDNS, "PRIVATEDNS" }, 62 { LDNS_PRIVATEOID, "PRIVATEOID" }, 63 { 0, NULL } 64 }; 65 66 /* Taken from RFC 2538 */ 67 ldns_lookup_table ldns_cert_algorithms[] = { 68 { LDNS_CERT_PKIX, "PKIX" }, 69 { LDNS_CERT_SPKI, "SPKI" }, 70 { LDNS_CERT_PGP, "PGP" }, 71 { LDNS_CERT_URI, "URI" }, 72 { LDNS_CERT_OID, "OID" }, 73 { 0, NULL } 74 }; 75 76 /* classes */ 77 ldns_lookup_table ldns_rr_classes[] = { 78 { LDNS_RR_CLASS_IN, "IN" }, 79 { LDNS_RR_CLASS_CH, "CH" }, 80 { LDNS_RR_CLASS_HS, "HS" }, 81 { LDNS_RR_CLASS_NONE, "NONE" }, 82 { LDNS_RR_CLASS_ANY, "ANY" }, 83 { 0, NULL } 84 }; 85 86 /* if these are used elsewhere */ 87 ldns_lookup_table ldns_rcodes[] = { 88 { LDNS_RCODE_NOERROR, "NOERROR" }, 89 { LDNS_RCODE_FORMERR, "FORMERR" }, 90 { LDNS_RCODE_SERVFAIL, "SERVFAIL" }, 91 { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" }, 92 { LDNS_RCODE_NOTIMPL, "NOTIMPL" }, 93 { LDNS_RCODE_REFUSED, "REFUSED" }, 94 { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" }, 95 { LDNS_RCODE_YXRRSET, "YXRRSET" }, 96 { LDNS_RCODE_NXRRSET, "NXRRSET" }, 97 { LDNS_RCODE_NOTAUTH, "NOTAUTH" }, 98 { LDNS_RCODE_NOTZONE, "NOTZONE" }, 99 { 0, NULL } 100 }; 101 102 ldns_lookup_table ldns_opcodes[] = { 103 { LDNS_PACKET_QUERY, "QUERY" }, 104 { LDNS_PACKET_IQUERY, "IQUERY" }, 105 { LDNS_PACKET_STATUS, "STATUS" }, 106 { LDNS_PACKET_NOTIFY, "NOTIFY" }, 107 { LDNS_PACKET_UPDATE, "UPDATE" }, 108 { 0, NULL } 109 }; 110 111 ldns_status 112 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode) 113 { 114 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode); 115 if (lt && lt->name) { 116 ldns_buffer_printf(output, "%s", lt->name); 117 } else { 118 ldns_buffer_printf(output, "OPCODE%u", opcode); 119 } 120 return ldns_buffer_status(output); 121 } 122 123 ldns_status 124 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode) 125 { 126 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode); 127 if (lt && lt->name) { 128 ldns_buffer_printf(output, "%s", lt->name); 129 } else { 130 ldns_buffer_printf(output, "RCODE%u", rcode); 131 } 132 return ldns_buffer_status(output); 133 } 134 135 ldns_status 136 ldns_algorithm2buffer_str(ldns_buffer *output, 137 ldns_algorithm algorithm) 138 { 139 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_algorithms, 140 algorithm); 141 if (lt && lt->name) { 142 ldns_buffer_printf(output, "%s", lt->name); 143 } else { 144 ldns_buffer_printf(output, "ALG%u", algorithm); 145 } 146 return ldns_buffer_status(output); 147 } 148 149 ldns_status 150 ldns_cert_algorithm2buffer_str(ldns_buffer *output, 151 ldns_cert_algorithm cert_algorithm) 152 { 153 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_cert_algorithms, 154 cert_algorithm); 155 if (lt && lt->name) { 156 ldns_buffer_printf(output, "%s", lt->name); 157 } else { 158 ldns_buffer_printf(output, "CERT_ALG%u", 159 cert_algorithm); 160 } 161 return ldns_buffer_status(output); 162 } 163 164 char * 165 ldns_pkt_opcode2str(ldns_pkt_opcode opcode) 166 { 167 char *str; 168 ldns_buffer *buf; 169 170 buf = ldns_buffer_new(12); 171 str = NULL; 172 173 if (ldns_pkt_opcode2buffer_str(buf, opcode) == LDNS_STATUS_OK) { 174 str = ldns_buffer2str(buf); 175 } 176 177 ldns_buffer_free(buf); 178 return str; 179 } 180 181 char * 182 ldns_pkt_rcode2str(ldns_pkt_rcode rcode) 183 { 184 char *str; 185 ldns_buffer *buf; 186 187 buf = ldns_buffer_new(10); 188 str = NULL; 189 190 if (ldns_pkt_rcode2buffer_str(buf, rcode) == LDNS_STATUS_OK) { 191 str = ldns_buffer2str(buf); 192 } 193 194 ldns_buffer_free(buf); 195 return str; 196 } 197 198 char * 199 ldns_pkt_algorithm2str(ldns_algorithm algorithm) 200 { 201 char *str; 202 ldns_buffer *buf; 203 204 buf = ldns_buffer_new(10); 205 str = NULL; 206 207 if (ldns_algorithm2buffer_str(buf, algorithm) 208 == LDNS_STATUS_OK) { 209 str = ldns_buffer2str(buf); 210 } 211 212 ldns_buffer_free(buf); 213 return str; 214 } 215 216 char * 217 ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm) 218 { 219 char *str; 220 ldns_buffer *buf; 221 222 buf = ldns_buffer_new(10); 223 str = NULL; 224 225 if (ldns_cert_algorithm2buffer_str(buf, cert_algorithm) 226 == LDNS_STATUS_OK) { 227 str = ldns_buffer2str(buf); 228 } 229 230 ldns_buffer_free(buf); 231 return str; 232 } 233 234 235 /* do NOT pass compressed data here :p */ 236 ldns_status 237 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname) 238 { 239 /* can we do with 1 pos var? or without at all? */ 240 uint8_t src_pos = 0; 241 uint8_t len; 242 uint8_t *data; 243 uint8_t i; 244 245 data = (uint8_t*)ldns_rdf_data(dname); 246 len = data[src_pos]; 247 248 if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) { 249 /* too large, return */ 250 return LDNS_STATUS_DOMAINNAME_OVERFLOW; 251 } 252 253 /* special case: root label */ 254 if (1 == ldns_rdf_size(dname)) { 255 ldns_buffer_printf(output, "."); 256 } else { 257 while ((len > 0) && src_pos < ldns_rdf_size(dname)) { 258 src_pos++; 259 for(i = 0; i < len; i++) { 260 /* paranoia check for various 'strange' 261 characters in dnames 262 */ 263 if(data[src_pos]=='.' || data[src_pos]==';' || 264 data[src_pos]=='(' || data[src_pos]==')' || 265 data[src_pos]=='\\') { 266 ldns_buffer_printf(output, "\\%c", 267 data[src_pos]); 268 } else if (!isgraph((int) data[src_pos])) { 269 ldns_buffer_printf(output, "\\%03u", 270 data[src_pos]); 271 } else { 272 ldns_buffer_printf(output, "%c", data[src_pos]); 273 } 274 src_pos++; 275 } 276 277 if (src_pos < ldns_rdf_size(dname)) { 278 ldns_buffer_printf(output, "."); 279 } 280 len = data[src_pos]; 281 } 282 } 283 return ldns_buffer_status(output); 284 } 285 286 ldns_status 287 ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf) 288 { 289 uint8_t data = ldns_rdf_data(rdf)[0]; 290 ldns_buffer_printf(output, "%lu", (unsigned long) data); 291 return ldns_buffer_status(output); 292 } 293 294 ldns_status 295 ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf) 296 { 297 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); 298 ldns_buffer_printf(output, "%lu", (unsigned long) data); 299 return ldns_buffer_status(output); 300 } 301 302 ldns_status 303 ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf) 304 { 305 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf)); 306 ldns_buffer_printf(output, "%lu", (unsigned long) data); 307 return ldns_buffer_status(output); 308 } 309 310 ldns_status 311 ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf) 312 { 313 /* create a YYYYMMDDHHMMSS string if possible */ 314 time_t data_time = (time_t) ldns_read_uint32(ldns_rdf_data(rdf)); 315 struct tm tm; 316 char date_buf[16]; 317 318 memset(&tm, 0, sizeof(tm)); 319 320 if (gmtime_r(&data_time, &tm) && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) { 321 ldns_buffer_printf(output, "%s", date_buf); 322 } 323 return ldns_buffer_status(output); 324 } 325 326 ldns_status 327 ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf) 328 { 329 char str[INET_ADDRSTRLEN]; 330 331 if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) { 332 ldns_buffer_printf(output, "%s", str); 333 } 334 return ldns_buffer_status(output); 335 } 336 337 ldns_status 338 ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf) 339 { 340 char str[INET6_ADDRSTRLEN]; 341 342 if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) { 343 ldns_buffer_printf(output, "%s", str); 344 } 345 346 return ldns_buffer_status(output); 347 } 348 349 ldns_status 350 ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf) 351 { 352 const uint8_t *data = ldns_rdf_data(rdf); 353 uint8_t length = data[0]; 354 size_t i; 355 356 ldns_buffer_printf(output, "\""); 357 for (i = 1; i <= length; ++i) { 358 char ch = (char) data[i]; 359 if (isprint((int)ch) || ch=='\t') { 360 if (ch=='\"'||ch=='\\') 361 ldns_buffer_printf(output, "\\%c", ch); 362 else 363 ldns_buffer_printf(output, "%c", ch); 364 } else { 365 ldns_buffer_printf(output, "\\%03u", (unsigned) ch); 366 } 367 } 368 ldns_buffer_printf(output, "\""); 369 return ldns_buffer_status(output); 370 } 371 372 ldns_status 373 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf) 374 { 375 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf)); 376 char *b64 = LDNS_XMALLOC(char, size); 377 if(!b64) return LDNS_STATUS_MEM_ERR; 378 if (ldns_b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) { 379 ldns_buffer_printf(output, "%s", b64); 380 } 381 LDNS_FREE(b64); 382 return ldns_buffer_status(output); 383 } 384 385 ldns_status 386 ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf) 387 { 388 size_t size; 389 char *b32; 390 if(ldns_rdf_size(rdf) == 0) 391 return LDNS_STATUS_OK; 392 /* remove -1 for the b32-hash-len octet */ 393 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1); 394 /* add one for the end nul for the string */ 395 b32 = LDNS_XMALLOC(char, size + 1); 396 if(!b32) return LDNS_STATUS_MEM_ERR; 397 size = (size_t) ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1, 398 ldns_rdf_size(rdf) - 1, b32, size+1); 399 if (size > 0) { 400 ldns_buffer_printf(output, "%s", b32); 401 } 402 LDNS_FREE(b32); 403 return ldns_buffer_status(output); 404 } 405 406 ldns_status 407 ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf) 408 { 409 size_t i; 410 for (i = 0; i < ldns_rdf_size(rdf); i++) { 411 ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]); 412 } 413 414 return ldns_buffer_status(output); 415 } 416 417 ldns_status 418 ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf) 419 { 420 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); 421 const ldns_rr_descriptor *descriptor; 422 423 descriptor = ldns_rr_descript(data); 424 if (descriptor && descriptor->_name) { 425 ldns_buffer_printf(output, "%s", descriptor->_name); 426 } else { 427 ldns_buffer_printf(output, "TYPE%u", data); 428 } 429 return ldns_buffer_status(output); 430 } 431 432 ldns_status 433 ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf) 434 { 435 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); 436 ldns_lookup_table *lt; 437 438 lt = ldns_lookup_by_id(ldns_rr_classes, (int) data); 439 if (lt) { 440 ldns_buffer_printf(output, "\t%s", lt->name); 441 } else { 442 ldns_buffer_printf(output, "\tCLASS%d", data); 443 } 444 return ldns_buffer_status(output); 445 } 446 447 ldns_status 448 ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf) 449 { 450 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf)); 451 ldns_lookup_table *lt; 452 lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data); 453 if (lt) { 454 ldns_buffer_printf(output, "%s", lt->name); 455 } else { 456 ldns_buffer_printf(output, "%d", data); 457 } 458 return ldns_buffer_status(output); 459 } 460 461 ldns_status 462 ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf) 463 { 464 /* don't use algorithm mnemonics in the presentation format 465 this kind of got sneaked into the rfc's */ 466 uint8_t data = ldns_rdf_data(rdf)[0]; 467 ldns_buffer_printf(output, "%d", data); 468 return ldns_buffer_status(output); 469 } 470 471 static void 472 loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent) 473 { 474 uint8_t i; 475 /* is it 0.<two digits> ? */ 476 if(exponent < 2) { 477 if(exponent == 1) 478 mantissa *= 10; 479 ldns_buffer_printf(output, "0.%02ld", (long)mantissa); 480 return; 481 } 482 /* always <digit><string of zeros> */ 483 ldns_buffer_printf(output, "%d", (int)mantissa); 484 for(i=0; i<exponent-2; i++) 485 ldns_buffer_printf(output, "0"); 486 } 487 488 ldns_status 489 ldns_rr_type2buffer_str(ldns_buffer *output, const ldns_rr_type type) 490 { 491 const ldns_rr_descriptor *descriptor; 492 493 descriptor = ldns_rr_descript(type); 494 495 if (descriptor && descriptor->_name) { 496 ldns_buffer_printf(output, "%s", descriptor->_name); 497 } else { 498 /* exceptions for pseudotypes */ 499 switch (type) { 500 case LDNS_RR_TYPE_IXFR: 501 ldns_buffer_printf(output, "IXFR"); 502 break; 503 case LDNS_RR_TYPE_AXFR: 504 ldns_buffer_printf(output, "AXFR"); 505 break; 506 case LDNS_RR_TYPE_MAILA: 507 ldns_buffer_printf(output, "MAILA"); 508 break; 509 case LDNS_RR_TYPE_MAILB: 510 ldns_buffer_printf(output, "MAILB"); 511 break; 512 case LDNS_RR_TYPE_ANY: 513 ldns_buffer_printf(output, "ANY"); 514 break; 515 default: 516 ldns_buffer_printf(output, "TYPE%u", type); 517 } 518 } 519 return ldns_buffer_status(output); 520 } 521 522 char * 523 ldns_rr_type2str(const ldns_rr_type type) 524 { 525 char *str; 526 ldns_buffer *buf; 527 528 buf = ldns_buffer_new(10); 529 str = NULL; 530 531 if (ldns_rr_type2buffer_str(buf, type) == LDNS_STATUS_OK) { 532 str = ldns_buffer2str(buf); 533 } 534 535 ldns_buffer_free(buf); 536 return str; 537 } 538 539 540 ldns_status 541 ldns_rr_class2buffer_str(ldns_buffer *output, 542 const ldns_rr_class klass) 543 { 544 ldns_lookup_table *lt; 545 546 lt = ldns_lookup_by_id(ldns_rr_classes, klass); 547 if (lt) { 548 ldns_buffer_printf(output, "%s", lt->name); 549 } else { 550 ldns_buffer_printf(output, "CLASS%d", klass); 551 } 552 return ldns_buffer_status(output); 553 } 554 555 char * 556 ldns_rr_class2str(const ldns_rr_class klass) 557 { 558 ldns_buffer *buf; 559 char *str; 560 561 str = NULL; 562 buf = ldns_buffer_new(10); 563 if (ldns_rr_class2buffer_str(buf, klass) == LDNS_STATUS_OK) { 564 str = ldns_buffer2str(buf); 565 } 566 ldns_buffer_free(buf); 567 return str; 568 } 569 570 ldns_status 571 ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf) 572 { 573 /* we could do checking (ie degrees < 90 etc)? */ 574 uint8_t version = ldns_rdf_data(rdf)[0]; 575 uint8_t size; 576 uint8_t horizontal_precision; 577 uint8_t vertical_precision; 578 uint32_t longitude; 579 uint32_t latitude; 580 uint32_t altitude; 581 char northerness; 582 char easterness; 583 uint32_t h; 584 uint32_t m; 585 double s; 586 587 uint32_t equator = (uint32_t) ldns_power(2, 31); 588 589 if (version == 0) { 590 size = ldns_rdf_data(rdf)[1]; 591 horizontal_precision = ldns_rdf_data(rdf)[2]; 592 vertical_precision = ldns_rdf_data(rdf)[3]; 593 594 latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]); 595 longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]); 596 altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]); 597 598 if (latitude > equator) { 599 northerness = 'N'; 600 latitude = latitude - equator; 601 } else { 602 northerness = 'S'; 603 latitude = equator - latitude; 604 } 605 h = latitude / (1000 * 60 * 60); 606 latitude = latitude % (1000 * 60 * 60); 607 m = latitude / (1000 * 60); 608 latitude = latitude % (1000 * 60); 609 s = (double) latitude / 1000.0; 610 ldns_buffer_printf(output, "%02u %02u %0.3f %c ", 611 h, m, s, northerness); 612 613 if (longitude > equator) { 614 easterness = 'E'; 615 longitude = longitude - equator; 616 } else { 617 easterness = 'W'; 618 longitude = equator - longitude; 619 } 620 h = longitude / (1000 * 60 * 60); 621 longitude = longitude % (1000 * 60 * 60); 622 m = longitude / (1000 * 60); 623 longitude = longitude % (1000 * 60); 624 s = (double) longitude / (1000.0); 625 ldns_buffer_printf(output, "%02u %02u %0.3f %c ", 626 h, m, s, easterness); 627 628 629 s = ((double) altitude) / 100; 630 s -= 100000; 631 632 if(altitude%100 != 0) 633 ldns_buffer_printf(output, "%.2f", s); 634 else 635 ldns_buffer_printf(output, "%.0f", s); 636 637 ldns_buffer_printf(output, "m "); 638 639 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f); 640 ldns_buffer_printf(output, "m "); 641 642 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4, 643 horizontal_precision & 0x0f); 644 ldns_buffer_printf(output, "m "); 645 646 loc_cm_print(output, (vertical_precision & 0xf0) >> 4, 647 vertical_precision & 0x0f); 648 ldns_buffer_printf(output, "m"); 649 650 return ldns_buffer_status(output); 651 } else { 652 return ldns_rdf2buffer_str_hex(output, rdf); 653 } 654 } 655 656 ldns_status 657 ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf) 658 { 659 ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf)); 660 return ldns_rdf2buffer_str_hex(output, rdf); 661 } 662 663 ldns_status 664 ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf) 665 { 666 ldns_buffer_printf(output, "0x"); 667 return ldns_rdf2buffer_str_hex(output, rdf); 668 } 669 670 ldns_status 671 ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf) 672 { 673 return ldns_rdf2buffer_str_hex(output, rdf); 674 } 675 676 ldns_status 677 ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf) 678 { 679 /* protocol, followed by bitmap of services */ 680 struct protoent *protocol; 681 char *proto_name = NULL; 682 uint8_t protocol_nr; 683 struct servent *service; 684 uint16_t current_service; 685 686 protocol_nr = ldns_rdf_data(rdf)[0]; 687 protocol = getprotobynumber((int) protocol_nr); 688 if (protocol && (protocol->p_name != NULL)) { 689 proto_name = protocol->p_name; 690 ldns_buffer_printf(output, "%s ", protocol->p_name); 691 } else { 692 ldns_buffer_printf(output, "%u ", protocol_nr); 693 } 694 695 #ifdef HAVE_ENDPROTOENT 696 endprotoent(); 697 #endif 698 699 for (current_service = 0; 700 current_service < ldns_rdf_size(rdf) * 7; current_service++) { 701 if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) { 702 service = getservbyport((int) htons(current_service), 703 proto_name); 704 if (service && service->s_name) { 705 ldns_buffer_printf(output, "%s ", service->s_name); 706 } else { 707 ldns_buffer_printf(output, "%u ", current_service); 708 } 709 #ifdef HAVE_ENDSERVENT 710 endservent(); 711 #endif 712 } 713 } 714 return ldns_buffer_status(output); 715 } 716 717 ldns_status 718 ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf) 719 { 720 /* Note: this code is duplicated in higher.c in 721 * ldns_nsec_type_check() function 722 */ 723 uint8_t window_block_nr; 724 uint8_t bitmap_length; 725 uint16_t type; 726 uint16_t pos = 0; 727 uint16_t bit_pos; 728 uint8_t *data = ldns_rdf_data(rdf); 729 const ldns_rr_descriptor *descriptor; 730 731 while(pos < ldns_rdf_size(rdf)) { 732 window_block_nr = data[pos]; 733 bitmap_length = data[pos + 1]; 734 pos += 2; 735 736 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) { 737 if (ldns_get_bit(&data[pos], bit_pos)) { 738 type = 256 * (uint16_t) window_block_nr + bit_pos; 739 descriptor = ldns_rr_descript(type); 740 741 if (descriptor && descriptor->_name) { 742 ldns_buffer_printf(output, "%s ", 743 descriptor->_name); 744 } else { 745 ldns_buffer_printf(output, "TYPE%u ", type); 746 } 747 } 748 } 749 750 pos += (uint16_t) bitmap_length; 751 } 752 753 return ldns_buffer_status(output); 754 } 755 756 ldns_status 757 ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf) 758 { 759 uint8_t salt_length; 760 uint8_t salt_pos; 761 762 uint8_t *data = ldns_rdf_data(rdf); 763 764 salt_length = data[0]; 765 /* from now there are variable length entries so remember pos */ 766 if (salt_length == 0 || ((size_t)salt_length)+1 > ldns_rdf_size(rdf)) { 767 ldns_buffer_printf(output, "- "); 768 } else { 769 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) { 770 ldns_buffer_printf(output, "%02x", data[1 + salt_pos]); 771 } 772 ldns_buffer_printf(output, " "); 773 } 774 775 return ldns_buffer_status(output); 776 } 777 778 ldns_status 779 ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf) 780 { 781 /* period is the number of seconds */ 782 uint32_t p = ldns_read_uint32(ldns_rdf_data(rdf)); 783 ldns_buffer_printf(output, "%u", p); 784 return ldns_buffer_status(output); 785 } 786 787 ldns_status 788 ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf) 789 { 790 /* tsigtime is 48 bits network order unsigned integer */ 791 uint64_t tsigtime = 0; 792 uint8_t *data = ldns_rdf_data(rdf); 793 794 if (ldns_rdf_size(rdf) != 6) { 795 return LDNS_STATUS_ERR; 796 } 797 798 tsigtime = ldns_read_uint16(data); 799 tsigtime *= 65536; 800 tsigtime += ldns_read_uint16(data+2); 801 tsigtime *= 65536; 802 803 ldns_buffer_printf(output, "%llu ", tsigtime); 804 805 return ldns_buffer_status(output); 806 } 807 808 ldns_status 809 ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf) 810 { 811 uint8_t *data = ldns_rdf_data(rdf); 812 uint16_t address_family; 813 uint8_t prefix; 814 bool negation; 815 uint8_t adf_length; 816 unsigned short i; 817 unsigned int pos = 0; 818 819 while (pos < (unsigned int) ldns_rdf_size(rdf)) { 820 if(pos + 3 >= ldns_rdf_size(rdf)) 821 return LDNS_STATUS_SYNTAX_RDATA_ERR; 822 address_family = ldns_read_uint16(&data[pos]); 823 prefix = data[pos + 2]; 824 negation = data[pos + 3] & LDNS_APL_NEGATION; 825 adf_length = data[pos + 3] & LDNS_APL_MASK; 826 if (address_family == LDNS_APL_IP4) { 827 /* check if prefix < 32? */ 828 if (negation) { 829 ldns_buffer_printf(output, "!"); 830 } 831 ldns_buffer_printf(output, "%u:", address_family); 832 /* address is variable length 0 - 4 */ 833 for (i = 0; i < 4; i++) { 834 if (i > 0) { 835 ldns_buffer_printf(output, "."); 836 } 837 if (i < (unsigned short) adf_length) { 838 if(pos+i+4 >= ldns_rdf_size(rdf)) 839 return LDNS_STATUS_SYNTAX_RDATA_ERR; 840 ldns_buffer_printf(output, "%d", 841 data[pos + i + 4]); 842 } else { 843 ldns_buffer_printf(output, "0"); 844 } 845 } 846 ldns_buffer_printf(output, "/%u ", prefix); 847 } else if (address_family == LDNS_APL_IP6) { 848 /* check if prefix < 128? */ 849 if (negation) { 850 ldns_buffer_printf(output, "!"); 851 } 852 ldns_buffer_printf(output, "%u:", address_family); 853 /* address is variable length 0 - 16 */ 854 for (i = 0; i < 16; i++) { 855 if (i % 2 == 0 && i > 0) { 856 ldns_buffer_printf(output, ":"); 857 } 858 if (i < (unsigned short) adf_length) { 859 if(pos+i+4 >= ldns_rdf_size(rdf)) 860 return LDNS_STATUS_SYNTAX_RDATA_ERR; 861 ldns_buffer_printf(output, "%02x", 862 data[pos + i + 4]); 863 } else { 864 ldns_buffer_printf(output, "00"); 865 } 866 } 867 ldns_buffer_printf(output, "/%u ", prefix); 868 869 } else { 870 /* unknown address family */ 871 ldns_buffer_printf(output, "Unknown address family: %u data: ", 872 address_family); 873 for (i = 1; i < (unsigned short) (4 + adf_length); i++) { 874 if(pos+i >= ldns_rdf_size(rdf)) 875 return LDNS_STATUS_SYNTAX_RDATA_ERR; 876 ldns_buffer_printf(output, "%02x", data[i]); 877 } 878 } 879 pos += 4 + adf_length; 880 } 881 return ldns_buffer_status(output); 882 } 883 884 ldns_status 885 ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf) 886 { 887 /* Subtract the size (2) of the number that specifies the length */ 888 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2); 889 char *b64 = LDNS_XMALLOC(char, size); 890 891 ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2); 892 893 if (ldns_rdf_size(rdf) > 2 && 894 ldns_b64_ntop(ldns_rdf_data(rdf) + 2, 895 ldns_rdf_size(rdf) - 2, 896 b64, size)) { 897 ldns_buffer_printf(output, "%s", b64); 898 } 899 LDNS_FREE(b64); 900 return ldns_buffer_status(output); 901 } 902 903 ldns_status 904 ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf) 905 { 906 /* wire format from 907 http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt 908 */ 909 uint8_t *data = ldns_rdf_data(rdf); 910 uint8_t precedence; 911 uint8_t gateway_type; 912 uint8_t algorithm; 913 914 ldns_rdf *gateway = NULL; 915 uint8_t *gateway_data; 916 917 size_t public_key_size; 918 uint8_t *public_key_data; 919 ldns_rdf *public_key; 920 921 size_t offset = 0; 922 ldns_status status; 923 924 precedence = data[0]; 925 gateway_type = data[1]; 926 algorithm = data[2]; 927 offset = 3; 928 929 switch (gateway_type) { 930 case 0: 931 /* no gateway */ 932 break; 933 case 1: 934 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN); 935 memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN); 936 gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, LDNS_IP4ADDRLEN , gateway_data); 937 offset += LDNS_IP4ADDRLEN; 938 break; 939 case 2: 940 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN); 941 memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN); 942 offset += LDNS_IP6ADDRLEN; 943 gateway = 944 ldns_rdf_new(LDNS_RDF_TYPE_AAAA, LDNS_IP6ADDRLEN, gateway_data); 945 break; 946 case 3: 947 status = ldns_wire2dname(&gateway, data, ldns_rdf_size(rdf), &offset); 948 if(status != LDNS_STATUS_OK) 949 return status; 950 break; 951 default: 952 /* error? */ 953 break; 954 } 955 956 public_key_size = ldns_rdf_size(rdf) - offset; 957 public_key_data = LDNS_XMALLOC(uint8_t, public_key_size); 958 memcpy(public_key_data, &data[offset], public_key_size); 959 public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, public_key_size, public_key_data); 960 961 ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm); 962 if (gateway) 963 (void) ldns_rdf2buffer_str(output, gateway); 964 else 965 ldns_buffer_printf(output, "."); 966 ldns_buffer_printf(output, " "); 967 (void) ldns_rdf2buffer_str(output, public_key); 968 969 ldns_rdf_free(gateway); 970 ldns_rdf_free(public_key); 971 972 return ldns_buffer_status(output); 973 } 974 975 ldns_status 976 ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf) 977 { 978 /* TSIG RRs have no presentation format, make them #size <data> */ 979 return ldns_rdf2buffer_str_unknown(output, rdf); 980 } 981 982 983 ldns_status 984 ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf) 985 { 986 ldns_status res = LDNS_STATUS_OK; 987 988 /*ldns_buffer_printf(buffer, "%u:", ldns_rdf_get_type(rdf));*/ 989 if (rdf) { 990 switch(ldns_rdf_get_type(rdf)) { 991 case LDNS_RDF_TYPE_NONE: 992 break; 993 case LDNS_RDF_TYPE_DNAME: 994 res = ldns_rdf2buffer_str_dname(buffer, rdf); 995 break; 996 case LDNS_RDF_TYPE_INT8: 997 res = ldns_rdf2buffer_str_int8(buffer, rdf); 998 break; 999 case LDNS_RDF_TYPE_INT16: 1000 res = ldns_rdf2buffer_str_int16(buffer, rdf); 1001 break; 1002 case LDNS_RDF_TYPE_INT32: 1003 res = ldns_rdf2buffer_str_int32(buffer, rdf); 1004 break; 1005 case LDNS_RDF_TYPE_PERIOD: 1006 res = ldns_rdf2buffer_str_period(buffer, rdf); 1007 break; 1008 case LDNS_RDF_TYPE_TSIGTIME: 1009 res = ldns_rdf2buffer_str_tsigtime(buffer, rdf); 1010 break; 1011 case LDNS_RDF_TYPE_A: 1012 res = ldns_rdf2buffer_str_a(buffer, rdf); 1013 break; 1014 case LDNS_RDF_TYPE_AAAA: 1015 res = ldns_rdf2buffer_str_aaaa(buffer, rdf); 1016 break; 1017 case LDNS_RDF_TYPE_STR: 1018 res = ldns_rdf2buffer_str_str(buffer, rdf); 1019 break; 1020 case LDNS_RDF_TYPE_APL: 1021 res = ldns_rdf2buffer_str_apl(buffer, rdf); 1022 break; 1023 case LDNS_RDF_TYPE_B32_EXT: 1024 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf); 1025 break; 1026 case LDNS_RDF_TYPE_B64: 1027 res = ldns_rdf2buffer_str_b64(buffer, rdf); 1028 break; 1029 case LDNS_RDF_TYPE_HEX: 1030 res = ldns_rdf2buffer_str_hex(buffer, rdf); 1031 break; 1032 case LDNS_RDF_TYPE_NSEC: 1033 res = ldns_rdf2buffer_str_nsec(buffer, rdf); 1034 break; 1035 case LDNS_RDF_TYPE_NSEC3_SALT: 1036 res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf); 1037 break; 1038 case LDNS_RDF_TYPE_TYPE: 1039 res = ldns_rdf2buffer_str_type(buffer, rdf); 1040 break; 1041 case LDNS_RDF_TYPE_CLASS: 1042 res = ldns_rdf2buffer_str_class(buffer, rdf); 1043 break; 1044 case LDNS_RDF_TYPE_CERT_ALG: 1045 res = ldns_rdf2buffer_str_cert_alg(buffer, rdf); 1046 break; 1047 case LDNS_RDF_TYPE_ALG: 1048 res = ldns_rdf2buffer_str_alg(buffer, rdf); 1049 break; 1050 case LDNS_RDF_TYPE_UNKNOWN: 1051 res = ldns_rdf2buffer_str_unknown(buffer, rdf); 1052 break; 1053 case LDNS_RDF_TYPE_TIME: 1054 res = ldns_rdf2buffer_str_time(buffer, rdf); 1055 break; 1056 case LDNS_RDF_TYPE_LOC: 1057 res = ldns_rdf2buffer_str_loc(buffer, rdf); 1058 break; 1059 case LDNS_RDF_TYPE_WKS: 1060 case LDNS_RDF_TYPE_SERVICE: 1061 res = ldns_rdf2buffer_str_wks(buffer, rdf); 1062 break; 1063 case LDNS_RDF_TYPE_NSAP: 1064 res = ldns_rdf2buffer_str_nsap(buffer, rdf); 1065 break; 1066 case LDNS_RDF_TYPE_ATMA: 1067 res = ldns_rdf2buffer_str_atma(buffer, rdf); 1068 break; 1069 case LDNS_RDF_TYPE_IPSECKEY: 1070 res = ldns_rdf2buffer_str_ipseckey(buffer, rdf); 1071 break; 1072 case LDNS_RDF_TYPE_TSIG: 1073 res = ldns_rdf2buffer_str_tsig(buffer, rdf); 1074 break; 1075 case LDNS_RDF_TYPE_INT16_DATA: 1076 res = ldns_rdf2buffer_str_int16_data(buffer, rdf); 1077 break; 1078 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER: 1079 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf); 1080 break; 1081 } 1082 } else { 1083 ldns_buffer_printf(buffer, "(null) "); 1084 res = ldns_buffer_status(buffer); 1085 } 1086 return res; 1087 } 1088 1089 ldns_status 1090 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr) 1091 { 1092 uint16_t i, flags; 1093 ldns_status status = LDNS_STATUS_OK; 1094 if (!rr) { 1095 ldns_buffer_printf(output, "(null)\n"); 1096 } else { 1097 if (ldns_rr_owner(rr)) { 1098 status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr)); 1099 } 1100 if (status != LDNS_STATUS_OK) { 1101 return status; 1102 } 1103 1104 /* TTL should NOT be printed if it is a question */ 1105 if (!ldns_rr_is_question(rr)) { 1106 ldns_buffer_printf(output, "\t%d", ldns_rr_ttl(rr)); 1107 } 1108 1109 ldns_buffer_printf(output, "\t"); 1110 status = ldns_rr_class2buffer_str(output, ldns_rr_get_class(rr)); 1111 if (status != LDNS_STATUS_OK) { 1112 return status; 1113 } 1114 ldns_buffer_printf(output, "\t"); 1115 1116 status = ldns_rr_type2buffer_str(output, ldns_rr_get_type(rr)); 1117 if (status != LDNS_STATUS_OK) { 1118 return status; 1119 } 1120 1121 if (ldns_rr_rd_count(rr) > 0) { 1122 ldns_buffer_printf(output, "\t"); 1123 } else if (!ldns_rr_is_question(rr)) { 1124 ldns_buffer_printf(output, "\t\\# 0"); 1125 } 1126 1127 for (i = 0; i < ldns_rr_rd_count(rr); i++) { 1128 status = ldns_rdf2buffer_str(output, ldns_rr_rdf(rr, i)); 1129 if(status != LDNS_STATUS_OK) 1130 return status; 1131 if (i < ldns_rr_rd_count(rr) - 1) { 1132 ldns_buffer_printf(output, " "); 1133 } 1134 } 1135 /* per RR special comments - handy for DNSSEC types */ 1136 /* check to prevent question sec. rr from 1137 * getting here */ 1138 if (ldns_rr_rd_count(rr) > 0) { 1139 switch (ldns_rr_get_type(rr)) { 1140 case LDNS_RR_TYPE_DNSKEY: 1141 if (ldns_rr_rdf(rr, 0)) { 1142 flags = ldns_rdf2native_int16(ldns_rr_rdf(rr, 0)); 1143 if (flags == 256 || flags == 384) { 1144 ldns_buffer_printf(output, 1145 " ;{id = %d (zsk), size = %db}", 1146 ldns_calc_keytag(rr), 1147 ldns_rr_dnskey_key_size(rr)); 1148 break; 1149 } 1150 if (flags == 257 || flags == 385) { 1151 ldns_buffer_printf(output, 1152 " ;{id = %d (ksk), size = %db}", 1153 ldns_calc_keytag(rr), 1154 ldns_rr_dnskey_key_size(rr)); 1155 break; 1156 } 1157 ldns_buffer_printf(output, " ;{id = %d, size = %db}", 1158 ldns_calc_keytag(rr), 1159 ldns_rr_dnskey_key_size(rr)); 1160 } 1161 break; 1162 case LDNS_RR_TYPE_RRSIG: 1163 ldns_buffer_printf(output, " ;{id = %d}", 1164 ldns_rdf2native_int16(ldns_rr_rdf(rr, 6))); 1165 break; 1166 case LDNS_RR_TYPE_DS: 1167 { 1168 uint8_t *data = ldns_rdf_data(ldns_rr_rdf(rr, 3)); 1169 size_t len = ldns_rdf_size(ldns_rr_rdf(rr, 3)); 1170 char *babble = ldns_bubblebabble(data, len); 1171 if(babble) 1172 ldns_buffer_printf(output, " ; %s", babble); 1173 LDNS_FREE(babble); 1174 } 1175 break; 1176 case LDNS_RR_TYPE_NSEC3: 1177 if (ldns_nsec3_optout(rr)) { 1178 ldns_buffer_printf(output, " ; flags: optout"); 1179 } 1180 break; 1181 default: 1182 break; 1183 1184 } 1185 } 1186 /* last */ 1187 ldns_buffer_printf(output, "\n"); 1188 } 1189 return ldns_buffer_status(output); 1190 } 1191 1192 ldns_status 1193 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list) 1194 { 1195 uint16_t i; 1196 1197 for(i = 0; i < ldns_rr_list_rr_count(list); i++) { 1198 (void) ldns_rr2buffer_str(output, ldns_rr_list_rr(list, i)); 1199 } 1200 return ldns_buffer_status(output); 1201 } 1202 1203 ldns_status 1204 ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt) 1205 { 1206 ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes, 1207 (int) ldns_pkt_get_opcode(pkt)); 1208 ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes, 1209 (int) ldns_pkt_get_rcode(pkt)); 1210 1211 ldns_buffer_printf(output, ";; ->>HEADER<<- "); 1212 if (opcode) { 1213 ldns_buffer_printf(output, "opcode: %s, ", opcode->name); 1214 } else { 1215 ldns_buffer_printf(output, "opcode: ?? (%u), ", 1216 ldns_pkt_get_opcode(pkt)); 1217 } 1218 if (rcode) { 1219 ldns_buffer_printf(output, "rcode: %s, ", rcode->name); 1220 } else { 1221 ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt)); 1222 } 1223 ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt)); 1224 ldns_buffer_printf(output, ";; flags: "); 1225 1226 if (ldns_pkt_qr(pkt)) { 1227 ldns_buffer_printf(output, "qr "); 1228 } 1229 if (ldns_pkt_aa(pkt)) { 1230 ldns_buffer_printf(output, "aa "); 1231 } 1232 if (ldns_pkt_tc(pkt)) { 1233 ldns_buffer_printf(output, "tc "); 1234 } 1235 if (ldns_pkt_rd(pkt)) { 1236 ldns_buffer_printf(output, "rd "); 1237 } 1238 if (ldns_pkt_cd(pkt)) { 1239 ldns_buffer_printf(output, "cd "); 1240 } 1241 if (ldns_pkt_ra(pkt)) { 1242 ldns_buffer_printf(output, "ra "); 1243 } 1244 if (ldns_pkt_ad(pkt)) { 1245 ldns_buffer_printf(output, "ad "); 1246 } 1247 ldns_buffer_printf(output, "; "); 1248 ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt)); 1249 ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt)); 1250 ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt)); 1251 ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt)); 1252 return ldns_buffer_status(output); 1253 } 1254 1255 ldns_status 1256 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt) 1257 { 1258 uint16_t i; 1259 ldns_status status = LDNS_STATUS_OK; 1260 char *tmp; 1261 struct timeval time; 1262 time_t time_tt; 1263 1264 if (!pkt) { 1265 ldns_buffer_printf(output, "null"); 1266 return LDNS_STATUS_OK; 1267 } 1268 1269 if (ldns_buffer_status_ok(output)) { 1270 status = ldns_pktheader2buffer_str(output, pkt); 1271 if (status != LDNS_STATUS_OK) { 1272 return status; 1273 } 1274 1275 ldns_buffer_printf(output, "\n"); 1276 1277 ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; "); 1278 1279 1280 for (i = 0; i < ldns_pkt_qdcount(pkt); i++) { 1281 status = ldns_rr2buffer_str(output, 1282 ldns_rr_list_rr(ldns_pkt_question(pkt), i)); 1283 if (status != LDNS_STATUS_OK) { 1284 return status; 1285 } 1286 } 1287 ldns_buffer_printf(output, "\n"); 1288 1289 ldns_buffer_printf(output, ";; ANSWER SECTION:\n"); 1290 for (i = 0; i < ldns_pkt_ancount(pkt); i++) { 1291 status = ldns_rr2buffer_str(output, 1292 ldns_rr_list_rr(ldns_pkt_answer(pkt), i)); 1293 if (status != LDNS_STATUS_OK) { 1294 return status; 1295 } 1296 1297 } 1298 ldns_buffer_printf(output, "\n"); 1299 1300 ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n"); 1301 1302 for (i = 0; i < ldns_pkt_nscount(pkt); i++) { 1303 status = ldns_rr2buffer_str(output, 1304 ldns_rr_list_rr(ldns_pkt_authority(pkt), i)); 1305 if (status != LDNS_STATUS_OK) { 1306 return status; 1307 } 1308 } 1309 ldns_buffer_printf(output, "\n"); 1310 1311 ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n"); 1312 for (i = 0; i < ldns_pkt_arcount(pkt); i++) { 1313 status = ldns_rr2buffer_str(output, 1314 ldns_rr_list_rr(ldns_pkt_additional(pkt), i)); 1315 if (status != LDNS_STATUS_OK) { 1316 return status; 1317 } 1318 1319 } 1320 ldns_buffer_printf(output, "\n"); 1321 /* add some futher fields */ 1322 ldns_buffer_printf(output, ";; Query time: %d msec\n", 1323 ldns_pkt_querytime(pkt)); 1324 if (ldns_pkt_edns(pkt)) { 1325 ldns_buffer_printf(output, 1326 ";; EDNS: version %u; flags:", 1327 ldns_pkt_edns_version(pkt)); 1328 if (ldns_pkt_edns_do(pkt)) { 1329 ldns_buffer_printf(output, " do"); 1330 } 1331 /* the extended rcode is the value set, shifted four bits, 1332 * and or'd with the original rcode */ 1333 if (ldns_pkt_edns_extended_rcode(pkt)) { 1334 ldns_buffer_printf(output, " ; ext-rcode: %d", 1335 (ldns_pkt_edns_extended_rcode(pkt) << 4 | ldns_pkt_get_rcode(pkt))); 1336 } 1337 ldns_buffer_printf(output, " ; udp: %u\n", 1338 ldns_pkt_edns_udp_size(pkt)); 1339 1340 if (ldns_pkt_edns_data(pkt)) { 1341 ldns_buffer_printf(output, ";; Data: "); 1342 (void)ldns_rdf2buffer_str(output, 1343 ldns_pkt_edns_data(pkt)); 1344 ldns_buffer_printf(output, "\n"); 1345 } 1346 } 1347 if (ldns_pkt_tsig(pkt)) { 1348 ldns_buffer_printf(output, ";; TSIG:\n;; "); 1349 (void) ldns_rr2buffer_str(output, ldns_pkt_tsig(pkt)); 1350 ldns_buffer_printf(output, "\n"); 1351 } 1352 if (ldns_pkt_answerfrom(pkt)) { 1353 tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt)); 1354 ldns_buffer_printf(output, ";; SERVER: %s\n", tmp); 1355 LDNS_FREE(tmp); 1356 } 1357 time = ldns_pkt_timestamp(pkt); 1358 time_tt = (time_t)time.tv_sec; 1359 ldns_buffer_printf(output, ";; WHEN: %s", 1360 (char*)ctime(&time_tt)); 1361 1362 ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n", 1363 (int)ldns_pkt_size(pkt)); 1364 } else { 1365 return ldns_buffer_status(output); 1366 } 1367 return status; 1368 } 1369 1370 #ifdef HAVE_SSL 1371 static ldns_status 1372 ldns_hmac_key2buffer_str(ldns_buffer *output, const ldns_key *k) 1373 { 1374 ldns_status status; 1375 size_t i; 1376 ldns_rdf *b64_bignum; 1377 1378 ldns_buffer_printf(output, "Key: "); 1379 1380 i = ldns_key_hmac_size(k); 1381 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k)); 1382 status = ldns_rdf2buffer_str(output, b64_bignum); 1383 ldns_rdf_deep_free(b64_bignum); 1384 ldns_buffer_printf(output, "\n"); 1385 return status; 1386 } 1387 #endif 1388 1389 #if defined(HAVE_SSL) && defined(USE_GOST) 1390 static ldns_status 1391 ldns_gost_key2buffer_str(ldns_buffer *output, EVP_PKEY *p) 1392 { 1393 unsigned char* pp = NULL; 1394 int ret; 1395 ldns_rdf *b64_bignum; 1396 ldns_status status; 1397 1398 ldns_buffer_printf(output, "GostAsn1: "); 1399 1400 ret = i2d_PrivateKey(p, &pp); 1401 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, ret, pp); 1402 status = ldns_rdf2buffer_str(output, b64_bignum); 1403 1404 ldns_rdf_deep_free(b64_bignum); 1405 OPENSSL_free(pp); 1406 ldns_buffer_printf(output, "\n"); 1407 return status; 1408 } 1409 #endif 1410 1411 ldns_status 1412 ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k) 1413 { 1414 ldns_status status = LDNS_STATUS_OK; 1415 unsigned char *bignum; 1416 1417 #ifdef HAVE_SSL 1418 /* not used when ssl is not defined */ 1419 ldns_rdf *b64_bignum = NULL; 1420 uint16_t i; 1421 1422 RSA *rsa; 1423 DSA *dsa; 1424 #endif /* HAVE_SSL */ 1425 1426 if (!k) { 1427 return LDNS_STATUS_ERR; 1428 } 1429 1430 bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN); 1431 if (!bignum) { 1432 return LDNS_STATUS_ERR; 1433 } 1434 1435 if (ldns_buffer_status_ok(output)) { 1436 #ifdef HAVE_SSL 1437 switch(ldns_key_algorithm(k)) { 1438 case LDNS_SIGN_RSASHA1: 1439 case LDNS_SIGN_RSASHA1_NSEC3: 1440 case LDNS_SIGN_RSASHA256: 1441 case LDNS_SIGN_RSASHA512: 1442 case LDNS_SIGN_RSAMD5: 1443 /* copied by looking at dnssec-keygen output */ 1444 /* header */ 1445 rsa = ldns_key_rsa_key(k); 1446 1447 ldns_buffer_printf(output,"Private-key-format: v1.2\n"); 1448 switch(ldns_key_algorithm(k)) { 1449 case LDNS_SIGN_RSAMD5: 1450 ldns_buffer_printf(output, 1451 "Algorithm: %u (RSA)\n", 1452 LDNS_RSAMD5); 1453 break; 1454 case LDNS_SIGN_RSASHA1: 1455 ldns_buffer_printf(output, 1456 "Algorithm: %u (RSASHA1)\n", 1457 LDNS_RSASHA1); 1458 break; 1459 case LDNS_SIGN_RSASHA1_NSEC3: 1460 ldns_buffer_printf(output, 1461 "Algorithm: %u (RSASHA1_NSEC3)\n", 1462 LDNS_RSASHA1_NSEC3); 1463 break; 1464 #ifdef USE_SHA2 1465 case LDNS_SIGN_RSASHA256: 1466 ldns_buffer_printf(output, 1467 "Algorithm: %u (RSASHA256)\n", 1468 LDNS_RSASHA256); 1469 break; 1470 case LDNS_SIGN_RSASHA512: 1471 ldns_buffer_printf(output, 1472 "Algorithm: %u (RSASHA512)\n", 1473 LDNS_RSASHA512); 1474 break; 1475 #endif 1476 default: 1477 fprintf(stderr, "Warning: unknown signature "); 1478 fprintf(stderr, 1479 "algorithm type %u\n", 1480 ldns_key_algorithm(k)); 1481 ldns_buffer_printf(output, 1482 "Algorithm: %u (Unknown)\n", 1483 ldns_key_algorithm(k)); 1484 break; 1485 } 1486 1487 /* print to buf, convert to bin, convert to b64, 1488 * print to buf */ 1489 ldns_buffer_printf(output, "Modulus: "); 1490 i = (uint16_t)BN_bn2bin(rsa->n, bignum); 1491 if (i > LDNS_MAX_KEYLEN) { 1492 goto error; 1493 } 1494 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1495 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1496 goto error; 1497 } 1498 ldns_rdf_deep_free(b64_bignum); 1499 ldns_buffer_printf(output, "\n"); 1500 ldns_buffer_printf(output, "PublicExponent: "); 1501 i = (uint16_t)BN_bn2bin(rsa->e, bignum); 1502 if (i > LDNS_MAX_KEYLEN) { 1503 goto error; 1504 } 1505 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1506 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1507 goto error; 1508 } 1509 ldns_rdf_deep_free(b64_bignum); 1510 ldns_buffer_printf(output, "\n"); 1511 1512 ldns_buffer_printf(output, "PrivateExponent: "); 1513 if (rsa->d) { 1514 i = (uint16_t)BN_bn2bin(rsa->d, bignum); 1515 if (i > LDNS_MAX_KEYLEN) { 1516 goto error; 1517 } 1518 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1519 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1520 goto error; 1521 } 1522 ldns_rdf_deep_free(b64_bignum); 1523 ldns_buffer_printf(output, "\n"); 1524 } else { 1525 ldns_buffer_printf(output, "(Not available)\n"); 1526 } 1527 1528 ldns_buffer_printf(output, "Prime1: "); 1529 if (rsa->p) { 1530 i = (uint16_t)BN_bn2bin(rsa->p, bignum); 1531 if (i > LDNS_MAX_KEYLEN) { 1532 goto error; 1533 } 1534 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1535 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1536 goto error; 1537 } 1538 ldns_rdf_deep_free(b64_bignum); 1539 ldns_buffer_printf(output, "\n"); 1540 } else { 1541 ldns_buffer_printf(output, "(Not available)\n"); 1542 } 1543 1544 ldns_buffer_printf(output, "Prime2: "); 1545 if (rsa->q) { 1546 i = (uint16_t)BN_bn2bin(rsa->q, bignum); 1547 if (i > LDNS_MAX_KEYLEN) { 1548 goto error; 1549 } 1550 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1551 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1552 goto error; 1553 } 1554 ldns_rdf_deep_free(b64_bignum); 1555 ldns_buffer_printf(output, "\n"); 1556 } else { 1557 ldns_buffer_printf(output, "(Not available)\n"); 1558 } 1559 1560 ldns_buffer_printf(output, "Exponent1: "); 1561 if (rsa->dmp1) { 1562 i = (uint16_t)BN_bn2bin(rsa->dmp1, bignum); 1563 if (i > LDNS_MAX_KEYLEN) { 1564 goto error; 1565 } 1566 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1567 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1568 goto error; 1569 } 1570 ldns_rdf_deep_free(b64_bignum); 1571 ldns_buffer_printf(output, "\n"); 1572 } else { 1573 ldns_buffer_printf(output, "(Not available)\n"); 1574 } 1575 1576 ldns_buffer_printf(output, "Exponent2: "); 1577 if (rsa->dmq1) { 1578 i = (uint16_t)BN_bn2bin(rsa->dmq1, bignum); 1579 if (i > LDNS_MAX_KEYLEN) { 1580 goto error; 1581 } 1582 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1583 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1584 goto error; 1585 } 1586 ldns_rdf_deep_free(b64_bignum); 1587 ldns_buffer_printf(output, "\n"); 1588 } else { 1589 ldns_buffer_printf(output, "(Not available)\n"); 1590 } 1591 1592 ldns_buffer_printf(output, "Coefficient: "); 1593 if (rsa->iqmp) { 1594 i = (uint16_t)BN_bn2bin(rsa->iqmp, bignum); 1595 if (i > LDNS_MAX_KEYLEN) { 1596 goto error; 1597 } 1598 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1599 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1600 goto error; 1601 } 1602 ldns_rdf_deep_free(b64_bignum); 1603 ldns_buffer_printf(output, "\n"); 1604 } else { 1605 ldns_buffer_printf(output, "(Not available)\n"); 1606 } 1607 1608 RSA_free(rsa); 1609 break; 1610 case LDNS_SIGN_DSA: 1611 case LDNS_SIGN_DSA_NSEC3: 1612 dsa = ldns_key_dsa_key(k); 1613 1614 ldns_buffer_printf(output,"Private-key-format: v1.2\n"); 1615 if (ldns_key_algorithm(k) == LDNS_SIGN_DSA) { 1616 ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n"); 1617 } else if (ldns_key_algorithm(k) == LDNS_SIGN_DSA_NSEC3) { 1618 ldns_buffer_printf(output,"Algorithm: 6 (DSA_NSEC3)\n"); 1619 } 1620 1621 /* print to buf, convert to bin, convert to b64, 1622 * print to buf */ 1623 ldns_buffer_printf(output, "Prime(p): "); 1624 if (dsa->p) { 1625 i = (uint16_t)BN_bn2bin(dsa->p, bignum); 1626 if (i > LDNS_MAX_KEYLEN) { 1627 goto error; 1628 } 1629 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1630 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1631 goto error; 1632 } 1633 ldns_rdf_deep_free(b64_bignum); 1634 ldns_buffer_printf(output, "\n"); 1635 } else { 1636 printf("(Not available)\n"); 1637 } 1638 1639 ldns_buffer_printf(output, "Subprime(q): "); 1640 if (dsa->q) { 1641 i = (uint16_t)BN_bn2bin(dsa->q, bignum); 1642 if (i > LDNS_MAX_KEYLEN) { 1643 goto error; 1644 } 1645 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1646 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1647 goto error; 1648 } 1649 ldns_rdf_deep_free(b64_bignum); 1650 ldns_buffer_printf(output, "\n"); 1651 } else { 1652 printf("(Not available)\n"); 1653 } 1654 1655 ldns_buffer_printf(output, "Base(g): "); 1656 if (dsa->g) { 1657 i = (uint16_t)BN_bn2bin(dsa->g, bignum); 1658 if (i > LDNS_MAX_KEYLEN) { 1659 goto error; 1660 } 1661 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1662 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1663 goto error; 1664 } 1665 ldns_rdf_deep_free(b64_bignum); 1666 ldns_buffer_printf(output, "\n"); 1667 } else { 1668 printf("(Not available)\n"); 1669 } 1670 1671 ldns_buffer_printf(output, "Private_value(x): "); 1672 if (dsa->priv_key) { 1673 i = (uint16_t)BN_bn2bin(dsa->priv_key, bignum); 1674 if (i > LDNS_MAX_KEYLEN) { 1675 goto error; 1676 } 1677 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1678 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1679 goto error; 1680 } 1681 ldns_rdf_deep_free(b64_bignum); 1682 ldns_buffer_printf(output, "\n"); 1683 } else { 1684 printf("(Not available)\n"); 1685 } 1686 1687 ldns_buffer_printf(output, "Public_value(y): "); 1688 if (dsa->pub_key) { 1689 i = (uint16_t)BN_bn2bin(dsa->pub_key, bignum); 1690 if (i > LDNS_MAX_KEYLEN) { 1691 goto error; 1692 } 1693 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1694 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1695 goto error; 1696 } 1697 ldns_rdf_deep_free(b64_bignum); 1698 ldns_buffer_printf(output, "\n"); 1699 } else { 1700 printf("(Not available)\n"); 1701 } 1702 break; 1703 case LDNS_SIGN_ECC_GOST: 1704 /* no format defined, use blob */ 1705 #if defined(HAVE_SSL) && defined(USE_GOST) 1706 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 1707 ldns_buffer_printf(output, "Algorithm: %d (ECC-GOST)\n", LDNS_SIGN_ECC_GOST); 1708 status = ldns_gost_key2buffer_str(output, k->_key.key); 1709 #endif 1710 break; 1711 #ifdef USE_ECDSA 1712 case LDNS_SIGN_ECDSAP256SHA256: 1713 case LDNS_SIGN_ECDSAP384SHA384: 1714 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 1715 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k)); 1716 ldns_algorithm2buffer_str(output, ldns_key_algorithm(k)); 1717 ldns_buffer_printf(output, ")\n"); 1718 if(k->_key.key) { 1719 EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->_key.key); 1720 const BIGNUM* b = EC_KEY_get0_private_key(ec); 1721 ldns_buffer_printf(output, "PrivateKey: "); 1722 i = (uint16_t)BN_bn2bin(b, bignum); 1723 if (i > LDNS_MAX_KEYLEN) { 1724 goto error; 1725 } 1726 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum); 1727 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) { 1728 goto error; 1729 } 1730 ldns_rdf_deep_free(b64_bignum); 1731 ldns_buffer_printf(output, "\n"); 1732 /* down reference count in EC_KEY 1733 * its still assigned to the PKEY */ 1734 EC_KEY_free(ec); 1735 } 1736 break; 1737 #endif 1738 case LDNS_SIGN_HMACMD5: 1739 /* there's not much of a format defined for TSIG */ 1740 /* It's just a binary blob, Same for all algorithms */ 1741 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 1742 ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n"); 1743 status = ldns_hmac_key2buffer_str(output, k); 1744 break; 1745 case LDNS_SIGN_HMACSHA1: 1746 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 1747 ldns_buffer_printf(output, "Algorithm: 158 (HMAC_SHA1)\n"); 1748 status = ldns_hmac_key2buffer_str(output, k); 1749 break; 1750 case LDNS_SIGN_HMACSHA256: 1751 ldns_buffer_printf(output, "Private-key-format: v1.2\n"); 1752 ldns_buffer_printf(output, "Algorithm: 159 (HMAC_SHA256)\n"); 1753 status = ldns_hmac_key2buffer_str(output, k); 1754 break; 1755 } 1756 #endif /* HAVE_SSL */ 1757 } else { 1758 #ifdef HAVE_SSL 1759 LDNS_FREE(b64_bignum); 1760 #endif 1761 LDNS_FREE(bignum); 1762 return ldns_buffer_status(output); 1763 } 1764 LDNS_FREE(bignum); 1765 return status; 1766 1767 #ifdef HAVE_SSL 1768 /* compiles warn the label isn't used */ 1769 error: 1770 LDNS_FREE(bignum); 1771 return LDNS_STATUS_ERR; 1772 #endif /* HAVE_SSL */ 1773 1774 } 1775 1776 /* 1777 * Zero terminate the buffer and fix it to the size of the string. 1778 */ 1779 char * 1780 ldns_buffer2str(ldns_buffer *buffer) 1781 { 1782 char *tmp_str; 1783 char *str; 1784 1785 /* check if buffer ends with \0, if not, and 1786 if there is space, add it */ 1787 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) { 1788 if (!ldns_buffer_reserve(buffer, 1)) { 1789 return NULL; 1790 } 1791 ldns_buffer_write_u8(buffer, (uint8_t) '\0'); 1792 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) { 1793 return NULL; 1794 } 1795 } 1796 1797 tmp_str = ldns_buffer_export(buffer); 1798 str = LDNS_XMALLOC(char, strlen(tmp_str) + 1); 1799 memcpy(str, tmp_str, strlen(tmp_str) + 1); 1800 1801 return str; 1802 } 1803 1804 char * 1805 ldns_rdf2str(const ldns_rdf *rdf) 1806 { 1807 char *result = NULL; 1808 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); 1809 1810 if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) { 1811 /* export and return string, destroy rest */ 1812 result = ldns_buffer2str(tmp_buffer); 1813 } 1814 1815 ldns_buffer_free(tmp_buffer); 1816 return result; 1817 } 1818 1819 char * 1820 ldns_rr2str(const ldns_rr *rr) 1821 { 1822 char *result = NULL; 1823 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); 1824 1825 if (ldns_rr2buffer_str(tmp_buffer, rr) == LDNS_STATUS_OK) { 1826 /* export and return string, destroy rest */ 1827 result = ldns_buffer2str(tmp_buffer); 1828 } 1829 ldns_buffer_free(tmp_buffer); 1830 return result; 1831 } 1832 1833 char * 1834 ldns_pkt2str(const ldns_pkt *pkt) 1835 { 1836 char *result = NULL; 1837 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); 1838 1839 if (ldns_pkt2buffer_str(tmp_buffer, pkt) == LDNS_STATUS_OK) { 1840 /* export and return string, destroy rest */ 1841 result = ldns_buffer2str(tmp_buffer); 1842 } 1843 1844 ldns_buffer_free(tmp_buffer); 1845 return result; 1846 } 1847 1848 char * 1849 ldns_key2str(const ldns_key *k) 1850 { 1851 char *result = NULL; 1852 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); 1853 if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) { 1854 /* export and return string, destroy rest */ 1855 result = ldns_buffer2str(tmp_buffer); 1856 } 1857 ldns_buffer_free(tmp_buffer); 1858 return result; 1859 } 1860 1861 char * 1862 ldns_rr_list2str(const ldns_rr_list *list) 1863 { 1864 char *result = NULL; 1865 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN); 1866 1867 if (list) { 1868 if (ldns_rr_list2buffer_str(tmp_buffer, list) == LDNS_STATUS_OK) { 1869 } 1870 } else { 1871 ldns_buffer_printf(tmp_buffer, "(null)\n"); 1872 } 1873 1874 /* export and return string, destroy rest */ 1875 result = ldns_buffer2str(tmp_buffer); 1876 ldns_buffer_free(tmp_buffer); 1877 return result; 1878 } 1879 1880 void 1881 ldns_rdf_print(FILE *output, const ldns_rdf *rdf) 1882 { 1883 char *str = ldns_rdf2str(rdf); 1884 if (str) { 1885 fprintf(output, "%s", str); 1886 } else { 1887 fprintf(output, "Unable to convert rdf to string\n"); 1888 } 1889 LDNS_FREE(str); 1890 } 1891 1892 void 1893 ldns_rr_print(FILE *output, const ldns_rr *rr) 1894 { 1895 char *str = ldns_rr2str(rr); 1896 if (str) { 1897 fprintf(output, "%s", str); 1898 } else { 1899 fprintf(output, "Unable to convert rr to string\n"); 1900 } 1901 LDNS_FREE(str); 1902 } 1903 1904 void 1905 ldns_pkt_print(FILE *output, const ldns_pkt *pkt) 1906 { 1907 char *str = ldns_pkt2str(pkt); 1908 if (str) { 1909 fprintf(output, "%s", str); 1910 } else { 1911 fprintf(output, "Unable to convert packet to string\n"); 1912 } 1913 LDNS_FREE(str); 1914 } 1915 1916 void 1917 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst) 1918 { 1919 size_t i; 1920 for (i = 0; i < ldns_rr_list_rr_count(lst); i++) { 1921 ldns_rr_print(output, ldns_rr_list_rr(lst, i)); 1922 } 1923 } 1924 1925 void 1926 ldns_resolver_print(FILE *output, const ldns_resolver *r) 1927 { 1928 uint16_t i; 1929 ldns_rdf **n; 1930 ldns_rdf **s; 1931 size_t *rtt; 1932 if (!r) { 1933 return; 1934 } 1935 n = ldns_resolver_nameservers(r); 1936 s = ldns_resolver_searchlist(r); 1937 rtt = ldns_resolver_rtt(r); 1938 1939 fprintf(output, "port: %d\n", (int)ldns_resolver_port(r)); 1940 fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r)); 1941 fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r)); 1942 1943 fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r)); 1944 fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r)); 1945 fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r)); 1946 fprintf(output, "fail: %d\n", ldns_resolver_fail(r)); 1947 fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r)); 1948 fprintf(output, "retrans: %d\n", (int)ldns_resolver_retrans(r)); 1949 fprintf(output, "fallback: %d\n", ldns_resolver_fallback(r)); 1950 fprintf(output, "random: %d\n", ldns_resolver_random(r)); 1951 fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec); 1952 fprintf(output, "dnssec: %d\n", ldns_resolver_dnssec(r)); 1953 fprintf(output, "dnssec cd: %d\n", ldns_resolver_dnssec_cd(r)); 1954 fprintf(output, "trust anchors (%d listed):\n", 1955 (int)ldns_rr_list_rr_count(ldns_resolver_dnssec_anchors(r))); 1956 ldns_rr_list_print(output, ldns_resolver_dnssec_anchors(r)); 1957 fprintf(output, "tsig: %s %s\n", ldns_resolver_tsig_keyname(r), ldns_resolver_tsig_algorithm(r)); 1958 fprintf(output, "debug: %d\n", ldns_resolver_debug(r)); 1959 1960 fprintf(output, "default domain: "); 1961 ldns_rdf_print(output, ldns_resolver_domain(r)); 1962 fprintf(output, "\n"); 1963 fprintf(output, "apply default domain: %d\n", ldns_resolver_defnames(r)); 1964 1965 fprintf(output, "searchlist (%d listed):\n", (int)ldns_resolver_searchlist_count(r)); 1966 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) { 1967 fprintf(output, "\t"); 1968 ldns_rdf_print(output, s[i]); 1969 fprintf(output, "\n"); 1970 } 1971 fprintf(output, "apply search list: %d\n", ldns_resolver_dnsrch(r)); 1972 1973 fprintf(output, "nameservers (%d listed):\n", (int)ldns_resolver_nameserver_count(r)); 1974 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) { 1975 fprintf(output, "\t"); 1976 ldns_rdf_print(output, n[i]); 1977 1978 switch ((int)rtt[i]) { 1979 case LDNS_RESOLV_RTT_MIN: 1980 fprintf(output, " - reachable\n"); 1981 break; 1982 case LDNS_RESOLV_RTT_INF: 1983 fprintf(output, " - unreachable\n"); 1984 break; 1985 } 1986 } 1987 } 1988 1989 void 1990 ldns_zone_print(FILE *output, const ldns_zone *z) 1991 { 1992 if(ldns_zone_soa(z)) 1993 ldns_rr_print(output, ldns_zone_soa(z)); 1994 ldns_rr_list_print(output, ldns_zone_rrs(z)); 1995 } 1996