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