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