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