contrib/ldns/host2str.c

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