contrib/ldns/host2str.c

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