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