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