4 * conversion routines from the host format
5 * to the presentation format (strings)
7 * a Net::DNS like library for C
9 * (c) NLnet Labs, 2004-2006
11 * See the file LICENSE for the license
13 #include <ldns/config.h>
15 #include <ldns/ldns.h>
19 #ifdef HAVE_SYS_SOCKET_H
20 #include <sys/socket.h>
22 #ifdef HAVE_ARPA_INET_H
23 #include <arpa/inet.h>
31 #ifndef INET_ADDRSTRLEN
32 #define INET_ADDRSTRLEN 16
34 #ifndef INET6_ADDRSTRLEN
35 #define INET6_ADDRSTRLEN 46
38 /* lookup tables for standard DNS stuff */
40 /* Taken from RFC 2535, section 7. */
41 ldns_lookup_table ldns_algorithms[] = {
42 { LDNS_RSAMD5, "RSAMD5" },
46 { LDNS_RSASHA1, "RSASHA1" },
47 { LDNS_DSA_NSEC3, "DSA-NSEC3-SHA1" },
48 { LDNS_RSASHA1_NSEC3, "RSASHA1-NSEC3-SHA1" },
50 { LDNS_RSASHA256, "RSASHA256"},
51 { LDNS_RSASHA512, "RSASHA512"},
54 { LDNS_ECC_GOST, "ECC-GOST"},
57 { LDNS_ECDSAP256SHA256, "ECDSAP256SHA256"},
58 { LDNS_ECDSAP384SHA384, "ECDSAP384SHA384"},
60 { LDNS_INDIRECT, "INDIRECT" },
61 { LDNS_PRIVATEDNS, "PRIVATEDNS" },
62 { LDNS_PRIVATEOID, "PRIVATEOID" },
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" },
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" },
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" },
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" },
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
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;
127 const ldns_output_format ldns_output_format_bubblebabble_record = {
128 LDNS_COMMENT_KEY | LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS, NULL
130 const ldns_output_format *ldns_output_format_bubblebabble
131 = &ldns_output_format_bubblebabble_record;
134 ldns_output_format_covers_type(const ldns_output_format* fmt, ldns_rr_type t)
136 return fmt && (fmt->flags & LDNS_FMT_RFC3597) &&
137 ((ldns_output_format_storage*)fmt)->bitmap &&
138 ldns_nsec_bitmap_covers_type(
139 ((ldns_output_format_storage*)fmt)->bitmap, t);
143 ldns_output_format_set_type(ldns_output_format* fmt, ldns_rr_type t)
145 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
150 if (!(fmt_st->flags & LDNS_FMT_RFC3597)) {
151 ldns_output_format_set(fmt, LDNS_FMT_RFC3597);
153 if (! fmt_st->bitmap) {
154 s = ldns_rdf_bitmap_known_rr_types_space(&fmt_st->bitmap);
155 if (s != LDNS_STATUS_OK) {
159 return ldns_nsec_bitmap_set_type(fmt_st->bitmap, t);
163 ldns_output_format_clear_type(ldns_output_format* fmt, ldns_rr_type t)
165 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
170 if (!(fmt_st->flags & LDNS_FMT_RFC3597)) {
171 ldns_output_format_set(fmt, LDNS_FMT_RFC3597);
173 if (! fmt_st->bitmap) {
174 s = ldns_rdf_bitmap_known_rr_types(&fmt_st->bitmap);
175 if (s != LDNS_STATUS_OK) {
179 return ldns_nsec_bitmap_clear_type(fmt_st->bitmap, t);
183 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode)
185 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode);
186 if (lt && lt->name) {
187 ldns_buffer_printf(output, "%s", lt->name);
189 ldns_buffer_printf(output, "OPCODE%u", opcode);
191 return ldns_buffer_status(output);
195 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode)
197 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode);
198 if (lt && lt->name) {
199 ldns_buffer_printf(output, "%s", lt->name);
201 ldns_buffer_printf(output, "RCODE%u", rcode);
203 return ldns_buffer_status(output);
207 ldns_algorithm2buffer_str(ldns_buffer *output,
208 ldns_algorithm algorithm)
210 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_algorithms,
212 if (lt && lt->name) {
213 ldns_buffer_printf(output, "%s", lt->name);
215 ldns_buffer_printf(output, "ALG%u", algorithm);
217 return ldns_buffer_status(output);
221 ldns_cert_algorithm2buffer_str(ldns_buffer *output,
222 ldns_cert_algorithm cert_algorithm)
224 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_cert_algorithms,
226 if (lt && lt->name) {
227 ldns_buffer_printf(output, "%s", lt->name);
229 ldns_buffer_printf(output, "CERT_ALG%u",
232 return ldns_buffer_status(output);
236 ldns_pkt_opcode2str(ldns_pkt_opcode opcode)
241 buf = ldns_buffer_new(12);
247 if (ldns_pkt_opcode2buffer_str(buf, opcode) == LDNS_STATUS_OK) {
248 str = ldns_buffer_export2str(buf);
251 ldns_buffer_free(buf);
256 ldns_pkt_rcode2str(ldns_pkt_rcode rcode)
261 buf = ldns_buffer_new(10);
267 if (ldns_pkt_rcode2buffer_str(buf, rcode) == LDNS_STATUS_OK) {
268 str = ldns_buffer_export2str(buf);
271 ldns_buffer_free(buf);
276 ldns_pkt_algorithm2str(ldns_algorithm algorithm)
281 buf = ldns_buffer_new(10);
287 if (ldns_algorithm2buffer_str(buf, algorithm)
289 str = ldns_buffer_export2str(buf);
292 ldns_buffer_free(buf);
297 ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm)
302 buf = ldns_buffer_new(10);
308 if (ldns_cert_algorithm2buffer_str(buf, cert_algorithm)
310 str = ldns_buffer_export2str(buf);
313 ldns_buffer_free(buf);
318 /* do NOT pass compressed data here :p */
320 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
322 /* can we do with 1 pos var? or without at all? */
329 data = (uint8_t*)ldns_rdf_data(dname);
332 if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) {
333 /* too large, return */
334 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
337 /* special case: root label */
338 if (1 == ldns_rdf_size(dname)) {
339 ldns_buffer_printf(output, ".");
341 while ((len > 0) && src_pos < ldns_rdf_size(dname)) {
343 for(i = 0; i < len; i++) {
344 /* paranoia check for various 'strange'
347 c = (unsigned char) data[src_pos];
348 if(c == '.' || c == ';' ||
349 c == '(' || c == ')' ||
351 ldns_buffer_printf(output, "\\%c",
353 } else if (!(isascii(c) && isgraph(c))) {
354 ldns_buffer_printf(output, "\\%03u",
357 ldns_buffer_printf(output, "%c", data[src_pos]);
362 if (src_pos < ldns_rdf_size(dname)) {
363 ldns_buffer_printf(output, ".");
368 return ldns_buffer_status(output);
372 ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
374 uint8_t data = ldns_rdf_data(rdf)[0];
375 ldns_buffer_printf(output, "%lu", (unsigned long) data);
376 return ldns_buffer_status(output);
380 ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
382 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
383 ldns_buffer_printf(output, "%lu", (unsigned long) data);
384 return ldns_buffer_status(output);
388 ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
390 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
391 ldns_buffer_printf(output, "%lu", (unsigned long) data);
392 return ldns_buffer_status(output);
396 ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
398 /* create a YYYYMMDDHHMMSS string if possible */
402 memset(&tm, 0, sizeof(tm));
403 if (ldns_serial_arithmitics_gmtime_r(ldns_rdf2native_int32(rdf), time(NULL), &tm)
404 && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
405 ldns_buffer_printf(output, "%s", date_buf);
407 return ldns_buffer_status(output);
411 ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
413 char str[INET_ADDRSTRLEN];
415 if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) {
416 ldns_buffer_printf(output, "%s", str);
418 return ldns_buffer_status(output);
422 ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
424 char str[INET6_ADDRSTRLEN];
426 if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) {
427 ldns_buffer_printf(output, "%s", str);
430 return ldns_buffer_status(output);
434 ldns_characters2buffer_str(ldns_buffer* output,
435 size_t amount, const uint8_t* characters)
440 if (isprint((int)ch) || ch == '\t') {
441 if (ch == '\"' || ch == '\\')
442 ldns_buffer_printf(output, "\\%c", ch);
444 ldns_buffer_printf(output, "%c", ch);
446 ldns_buffer_printf(output, "\\%03u",
447 (unsigned)(uint8_t) ch);
454 ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
456 if(ldns_rdf_size(rdf) < 1) {
457 return LDNS_STATUS_WIRE_RDATA_ERR;
459 if((int)ldns_rdf_size(rdf) < (int)ldns_rdf_data(rdf)[0] + 1) {
460 return LDNS_STATUS_WIRE_RDATA_ERR;
462 ldns_buffer_printf(output, "\"");
463 ldns_characters2buffer_str(output,
464 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf) + 1);
465 ldns_buffer_printf(output, "\"");
466 return ldns_buffer_status(output);
470 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
472 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf));
473 char *b64 = LDNS_XMALLOC(char, size);
474 if(!b64) return LDNS_STATUS_MEM_ERR;
475 if (ldns_b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) {
476 ldns_buffer_printf(output, "%s", b64);
479 return ldns_buffer_status(output);
483 ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf)
487 if(ldns_rdf_size(rdf) == 0)
488 return LDNS_STATUS_OK;
489 /* remove -1 for the b32-hash-len octet */
490 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
491 /* add one for the end nul for the string */
492 b32 = LDNS_XMALLOC(char, size + 1);
493 if(!b32) return LDNS_STATUS_MEM_ERR;
494 size = (size_t) ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
495 ldns_rdf_size(rdf) - 1, b32, size+1);
497 ldns_buffer_printf(output, "%s", b32);
500 return ldns_buffer_status(output);
504 ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
507 for (i = 0; i < ldns_rdf_size(rdf); i++) {
508 ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]);
511 return ldns_buffer_status(output);
515 ldns_rdf2buffer_str_type_fmt(ldns_buffer *output,
516 const ldns_output_format* fmt, const ldns_rdf *rdf)
518 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
520 if (! ldns_output_format_covers_type(fmt, data) &&
521 ldns_rr_descript(data) &&
522 ldns_rr_descript(data)->_name) {
524 ldns_buffer_printf(output, "%s",ldns_rr_descript(data)->_name);
526 ldns_buffer_printf(output, "TYPE%u", data);
528 return ldns_buffer_status(output);
532 ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
534 return ldns_rdf2buffer_str_type_fmt(output,
535 ldns_output_format_default, rdf);
539 ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
541 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
542 ldns_lookup_table *lt;
544 lt = ldns_lookup_by_id(ldns_rr_classes, (int) data);
546 ldns_buffer_printf(output, "\t%s", lt->name);
548 ldns_buffer_printf(output, "\tCLASS%d", data);
550 return ldns_buffer_status(output);
554 ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
556 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
557 ldns_lookup_table *lt;
558 lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data);
560 ldns_buffer_printf(output, "%s", lt->name);
562 ldns_buffer_printf(output, "%d", data);
564 return ldns_buffer_status(output);
568 ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
570 /* don't use algorithm mnemonics in the presentation format
571 this kind of got sneaked into the rfc's */
572 uint8_t data = ldns_rdf_data(rdf)[0];
573 ldns_buffer_printf(output, "%d", data);
574 return ldns_buffer_status(output);
578 loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
581 /* is it 0.<two digits> ? */
585 ldns_buffer_printf(output, "0.%02ld", (long)mantissa);
588 /* always <digit><string of zeros> */
589 ldns_buffer_printf(output, "%d", (int)mantissa);
590 for(i=0; i<exponent-2; i++)
591 ldns_buffer_printf(output, "0");
595 ldns_rr_type2buffer_str(ldns_buffer *output, const ldns_rr_type type)
597 const ldns_rr_descriptor *descriptor;
599 descriptor = ldns_rr_descript(type);
601 if (descriptor && descriptor->_name) {
602 ldns_buffer_printf(output, "%s", descriptor->_name);
604 /* exceptions for pseudotypes */
606 case LDNS_RR_TYPE_IXFR:
607 ldns_buffer_printf(output, "IXFR");
609 case LDNS_RR_TYPE_AXFR:
610 ldns_buffer_printf(output, "AXFR");
612 case LDNS_RR_TYPE_MAILA:
613 ldns_buffer_printf(output, "MAILA");
615 case LDNS_RR_TYPE_MAILB:
616 ldns_buffer_printf(output, "MAILB");
618 case LDNS_RR_TYPE_ANY:
619 ldns_buffer_printf(output, "ANY");
622 ldns_buffer_printf(output, "TYPE%u", type);
625 return ldns_buffer_status(output);
629 ldns_rr_type2str(const ldns_rr_type type)
634 buf = ldns_buffer_new(10);
640 if (ldns_rr_type2buffer_str(buf, type) == LDNS_STATUS_OK) {
641 str = ldns_buffer_export2str(buf);
644 ldns_buffer_free(buf);
650 ldns_rr_class2buffer_str(ldns_buffer *output,
651 const ldns_rr_class klass)
653 ldns_lookup_table *lt;
655 lt = ldns_lookup_by_id(ldns_rr_classes, klass);
657 ldns_buffer_printf(output, "%s", lt->name);
659 ldns_buffer_printf(output, "CLASS%d", klass);
661 return ldns_buffer_status(output);
665 ldns_rr_class2str(const ldns_rr_class klass)
670 buf = ldns_buffer_new(10);
676 if (ldns_rr_class2buffer_str(buf, klass) == LDNS_STATUS_OK) {
677 str = ldns_buffer_export2str(buf);
679 ldns_buffer_free(buf);
684 ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
686 /* we could do checking (ie degrees < 90 etc)? */
689 uint8_t horizontal_precision;
690 uint8_t vertical_precision;
700 uint32_t equator = (uint32_t) ldns_power(2, 31);
702 if(ldns_rdf_size(rdf) < 1) {
703 return LDNS_STATUS_WIRE_RDATA_ERR;
705 version = ldns_rdf_data(rdf)[0];
707 if(ldns_rdf_size(rdf) < 16) {
708 return LDNS_STATUS_WIRE_RDATA_ERR;
710 size = ldns_rdf_data(rdf)[1];
711 horizontal_precision = ldns_rdf_data(rdf)[2];
712 vertical_precision = ldns_rdf_data(rdf)[3];
714 latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]);
715 longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]);
716 altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]);
718 if (latitude > equator) {
720 latitude = latitude - equator;
723 latitude = equator - latitude;
725 h = latitude / (1000 * 60 * 60);
726 latitude = latitude % (1000 * 60 * 60);
727 m = latitude / (1000 * 60);
728 latitude = latitude % (1000 * 60);
729 s = (double) latitude / 1000.0;
730 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
731 h, m, s, northerness);
733 if (longitude > equator) {
735 longitude = longitude - equator;
738 longitude = equator - longitude;
740 h = longitude / (1000 * 60 * 60);
741 longitude = longitude % (1000 * 60 * 60);
742 m = longitude / (1000 * 60);
743 longitude = longitude % (1000 * 60);
744 s = (double) longitude / (1000.0);
745 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
746 h, m, s, easterness);
749 s = ((double) altitude) / 100;
752 if(altitude%100 != 0)
753 ldns_buffer_printf(output, "%.2f", s);
755 ldns_buffer_printf(output, "%.0f", s);
757 ldns_buffer_printf(output, "m ");
759 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
760 ldns_buffer_printf(output, "m ");
762 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
763 horizontal_precision & 0x0f);
764 ldns_buffer_printf(output, "m ");
766 loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
767 vertical_precision & 0x0f);
768 ldns_buffer_printf(output, "m");
770 return ldns_buffer_status(output);
772 return ldns_rdf2buffer_str_hex(output, rdf);
777 ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
779 ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
780 return ldns_rdf2buffer_str_hex(output, rdf);
784 ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
786 ldns_buffer_printf(output, "0x");
787 return ldns_rdf2buffer_str_hex(output, rdf);
791 ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf)
793 return ldns_rdf2buffer_str_hex(output, rdf);
797 ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
799 /* protocol, followed by bitmap of services */
800 struct protoent *protocol;
801 char *proto_name = NULL;
803 struct servent *service;
804 uint16_t current_service;
806 if(ldns_rdf_size(rdf) < 1) {
807 return LDNS_STATUS_WIRE_RDATA_ERR;
809 protocol_nr = ldns_rdf_data(rdf)[0];
810 protocol = getprotobynumber((int) protocol_nr);
811 if (protocol && (protocol->p_name != NULL)) {
812 proto_name = protocol->p_name;
813 ldns_buffer_printf(output, "%s ", protocol->p_name);
815 ldns_buffer_printf(output, "%u ", protocol_nr);
818 #ifdef HAVE_ENDPROTOENT
822 for (current_service = 0;
823 current_service < ldns_rdf_size(rdf) * 7; current_service++) {
824 if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) {
825 service = getservbyport((int) htons(current_service),
827 if (service && service->s_name) {
828 ldns_buffer_printf(output, "%s ", service->s_name);
830 ldns_buffer_printf(output, "%u ", current_service);
832 #ifdef HAVE_ENDSERVENT
837 return ldns_buffer_status(output);
841 ldns_rdf2buffer_str_nsec_fmt(ldns_buffer *output,
842 const ldns_output_format* fmt, const ldns_rdf *rdf)
844 /* Note: this code is duplicated in higher.c in
845 * ldns_nsec_type_check() function
847 uint8_t window_block_nr;
848 uint8_t bitmap_length;
852 uint8_t *data = ldns_rdf_data(rdf);
854 while((size_t)(pos + 2) < ldns_rdf_size(rdf)) {
855 window_block_nr = data[pos];
856 bitmap_length = data[pos + 1];
858 if (ldns_rdf_size(rdf) < pos + bitmap_length) {
859 return LDNS_STATUS_WIRE_RDATA_ERR;
861 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
862 if (! ldns_get_bit(&data[pos], bit_pos)) {
865 type = 256 * (uint16_t) window_block_nr + bit_pos;
867 if (! ldns_output_format_covers_type(fmt, type) &&
868 ldns_rr_descript(type) &&
869 ldns_rr_descript(type)->_name){
871 ldns_buffer_printf(output, "%s ",
872 ldns_rr_descript(type)->_name);
874 ldns_buffer_printf(output, "TYPE%u ", type);
877 pos += (uint16_t) bitmap_length;
879 return ldns_buffer_status(output);
883 ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
885 return ldns_rdf2buffer_str_nsec_fmt(output,
886 ldns_output_format_default, rdf);
890 ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf)
895 uint8_t *data = ldns_rdf_data(rdf);
897 if(ldns_rdf_size(rdf) < 1) {
898 return LDNS_STATUS_WIRE_RDATA_ERR;
900 salt_length = data[0];
901 /* from now there are variable length entries so remember pos */
902 if (salt_length == 0 || ((size_t)salt_length)+1 > ldns_rdf_size(rdf)) {
903 ldns_buffer_printf(output, "- ");
905 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) {
906 ldns_buffer_printf(output, "%02x", data[1 + salt_pos]);
908 ldns_buffer_printf(output, " ");
911 return ldns_buffer_status(output);
915 ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
917 /* period is the number of seconds */
918 if (ldns_rdf_size(rdf) != 4) {
919 return LDNS_STATUS_WIRE_RDATA_ERR;
921 ldns_buffer_printf(output, "%u", ldns_read_uint32(ldns_rdf_data(rdf)));
922 return ldns_buffer_status(output);
926 ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf)
928 /* tsigtime is 48 bits network order unsigned integer */
929 uint64_t tsigtime = 0;
930 uint8_t *data = ldns_rdf_data(rdf);
931 uint64_t d0, d1, d2, d3, d4, d5;
933 if (ldns_rdf_size(rdf) < 6) {
934 return LDNS_STATUS_WIRE_RDATA_ERR;
936 d0 = data[0]; /* cast to uint64 for shift operations */
942 tsigtime = (d0<<40) | (d1<<32) | (d2<<24) | (d3<<16) | (d4<<8) | d5;
944 ldns_buffer_printf(output, "%llu ", (long long)tsigtime);
946 return ldns_buffer_status(output);
950 ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
952 uint8_t *data = ldns_rdf_data(rdf);
953 uint16_t address_family;
960 while (pos < (unsigned int) ldns_rdf_size(rdf)) {
961 if(pos + 3 >= (unsigned)ldns_rdf_size(rdf))
962 return LDNS_STATUS_WIRE_RDATA_ERR;
963 address_family = ldns_read_uint16(&data[pos]);
964 prefix = data[pos + 2];
965 negation = data[pos + 3] & LDNS_APL_NEGATION;
966 adf_length = data[pos + 3] & LDNS_APL_MASK;
967 if (address_family == LDNS_APL_IP4) {
968 /* check if prefix < 32? */
970 ldns_buffer_printf(output, "!");
972 ldns_buffer_printf(output, "%u:", address_family);
973 /* address is variable length 0 - 4 */
974 for (i = 0; i < 4; i++) {
976 ldns_buffer_printf(output, ".");
978 if (i < (unsigned short) adf_length) {
979 if(pos+i+4 >= ldns_rdf_size(rdf))
980 return LDNS_STATUS_WIRE_RDATA_ERR;
981 ldns_buffer_printf(output, "%d",
984 ldns_buffer_printf(output, "0");
987 ldns_buffer_printf(output, "/%u ", prefix);
988 } else if (address_family == LDNS_APL_IP6) {
989 /* check if prefix < 128? */
991 ldns_buffer_printf(output, "!");
993 ldns_buffer_printf(output, "%u:", address_family);
994 /* address is variable length 0 - 16 */
995 for (i = 0; i < 16; i++) {
996 if (i % 2 == 0 && i > 0) {
997 ldns_buffer_printf(output, ":");
999 if (i < (unsigned short) adf_length) {
1000 if(pos+i+4 >= ldns_rdf_size(rdf))
1001 return LDNS_STATUS_WIRE_RDATA_ERR;
1002 ldns_buffer_printf(output, "%02x",
1005 ldns_buffer_printf(output, "00");
1008 ldns_buffer_printf(output, "/%u ", prefix);
1011 /* unknown address family */
1012 ldns_buffer_printf(output,
1013 "Unknown address family: %u data: ",
1015 for (i = 1; i < (unsigned short) (4 + adf_length); i++) {
1016 if(pos+i >= ldns_rdf_size(rdf))
1017 return LDNS_STATUS_WIRE_RDATA_ERR;
1018 ldns_buffer_printf(output, "%02x", data[i]);
1021 pos += 4 + adf_length;
1023 return ldns_buffer_status(output);
1027 ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
1031 if (ldns_rdf_size(rdf) < 2) {
1032 return LDNS_STATUS_WIRE_RDATA_ERR;
1034 /* Subtract the size (2) of the number that specifies the length */
1035 size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
1036 ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
1037 if (ldns_rdf_size(rdf) > 2) {
1038 b64 = LDNS_XMALLOC(char, size);
1040 return LDNS_STATUS_MEM_ERR;
1042 if (ldns_rdf_size(rdf) > 2 &&
1043 ldns_b64_ntop(ldns_rdf_data(rdf) + 2,
1044 ldns_rdf_size(rdf) - 2,
1046 ldns_buffer_printf(output, "%s", b64);
1050 return ldns_buffer_status(output);
1054 ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
1057 http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt
1059 uint8_t *data = ldns_rdf_data(rdf);
1061 uint8_t gateway_type;
1064 ldns_rdf *gateway = NULL;
1065 uint8_t *gateway_data;
1067 size_t public_key_size;
1068 uint8_t *public_key_data;
1069 ldns_rdf *public_key;
1074 if (ldns_rdf_size(rdf) < 3) {
1075 return LDNS_STATUS_WIRE_RDATA_ERR;
1077 precedence = data[0];
1078 gateway_type = data[1];
1079 algorithm = data[2];
1082 switch (gateway_type) {
1087 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
1089 return LDNS_STATUS_MEM_ERR;
1090 if (ldns_rdf_size(rdf) < offset + LDNS_IP4ADDRLEN) {
1091 return LDNS_STATUS_ERR;
1093 memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
1094 gateway = ldns_rdf_new(LDNS_RDF_TYPE_A,
1095 LDNS_IP4ADDRLEN , gateway_data);
1096 offset += LDNS_IP4ADDRLEN;
1098 LDNS_FREE(gateway_data);
1099 return LDNS_STATUS_MEM_ERR;
1103 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
1105 return LDNS_STATUS_MEM_ERR;
1106 if (ldns_rdf_size(rdf) < offset + LDNS_IP6ADDRLEN) {
1107 return LDNS_STATUS_ERR;
1109 memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
1110 offset += LDNS_IP6ADDRLEN;
1112 ldns_rdf_new(LDNS_RDF_TYPE_AAAA,
1113 LDNS_IP6ADDRLEN, gateway_data);
1115 LDNS_FREE(gateway_data);
1116 return LDNS_STATUS_MEM_ERR;
1120 status = ldns_wire2dname(&gateway, data,
1121 ldns_rdf_size(rdf), &offset);
1122 if(status != LDNS_STATUS_OK)
1130 if (ldns_rdf_size(rdf) <= offset) {
1131 return LDNS_STATUS_ERR;
1133 public_key_size = ldns_rdf_size(rdf) - offset;
1134 public_key_data = LDNS_XMALLOC(uint8_t, public_key_size);
1135 if(!public_key_data) {
1136 ldns_rdf_free(gateway);
1137 return LDNS_STATUS_MEM_ERR;
1139 memcpy(public_key_data, &data[offset], public_key_size);
1140 public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64,
1141 public_key_size, public_key_data);
1143 LDNS_FREE(public_key_data);
1144 ldns_rdf_free(gateway);
1145 return LDNS_STATUS_MEM_ERR;
1148 ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm);
1150 (void) ldns_rdf2buffer_str(output, gateway);
1152 ldns_buffer_printf(output, ".");
1153 ldns_buffer_printf(output, " ");
1154 (void) ldns_rdf2buffer_str(output, public_key);
1156 ldns_rdf_free(gateway);
1157 ldns_rdf_free(public_key);
1159 return ldns_buffer_status(output);
1163 ldns_rdf2buffer_str_ilnp64(ldns_buffer *output, const ldns_rdf *rdf)
1165 if (ldns_rdf_size(rdf) != 8) {
1166 return LDNS_STATUS_WIRE_RDATA_ERR;
1168 ldns_buffer_printf(output,"%.4x:%.4x:%.4x:%.4x",
1169 ldns_read_uint16(ldns_rdf_data(rdf)),
1170 ldns_read_uint16(ldns_rdf_data(rdf)+2),
1171 ldns_read_uint16(ldns_rdf_data(rdf)+4),
1172 ldns_read_uint16(ldns_rdf_data(rdf)+6));
1173 return ldns_buffer_status(output);
1177 ldns_rdf2buffer_str_eui48(ldns_buffer *output, const ldns_rdf *rdf)
1179 if (ldns_rdf_size(rdf) != 6) {
1180 return LDNS_STATUS_WIRE_RDATA_ERR;
1182 ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
1183 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1],
1184 ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3],
1185 ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5]);
1186 return ldns_buffer_status(output);
1190 ldns_rdf2buffer_str_eui64(ldns_buffer *output, const ldns_rdf *rdf)
1192 if (ldns_rdf_size(rdf) != 8) {
1193 return LDNS_STATUS_WIRE_RDATA_ERR;
1195 ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
1196 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1],
1197 ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3],
1198 ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5],
1199 ldns_rdf_data(rdf)[6], ldns_rdf_data(rdf)[7]);
1200 return ldns_buffer_status(output);
1204 ldns_rdf2buffer_str_tag(ldns_buffer *output, const ldns_rdf *rdf)
1207 const uint8_t* chars;
1209 if (ldns_rdf_size(rdf) < 2) {
1210 return LDNS_STATUS_WIRE_RDATA_ERR;
1212 nchars = ldns_rdf_data(rdf)[0];
1213 if (nchars >= ldns_rdf_size(rdf) || /* should be rdf_size - 1 */
1215 return LDNS_STATUS_WIRE_RDATA_ERR;
1217 chars = ldns_rdf_data(rdf) + 1;
1218 while (nchars > 0) {
1219 ch = (char)*chars++;
1220 if (! isalnum(ch)) {
1221 return LDNS_STATUS_WIRE_RDATA_ERR;
1223 ldns_buffer_printf(output, "%c", ch);
1226 return ldns_buffer_status(output);
1230 ldns_rdf2buffer_str_long_str(ldns_buffer *output, const ldns_rdf *rdf)
1233 ldns_buffer_printf(output, "\"");
1234 ldns_characters2buffer_str(output,
1235 ldns_rdf_size(rdf), ldns_rdf_data(rdf));
1236 ldns_buffer_printf(output, "\"");
1237 return ldns_buffer_status(output);
1241 ldns_rdf2buffer_str_hip(ldns_buffer *output, const ldns_rdf *rdf)
1243 uint8_t *data = ldns_rdf_data(rdf);
1244 size_t rdf_size = ldns_rdf_size(rdf);
1250 return LDNS_STATUS_WIRE_RDATA_ERR;
1252 if ((hit_size = data[0]) == 0 ||
1253 (pk_size = ldns_read_uint16(data + 2)) == 0 ||
1254 rdf_size < (size_t) hit_size + pk_size + 4) {
1256 return LDNS_STATUS_WIRE_RDATA_ERR;
1259 ldns_buffer_printf(output, "%d ", (int) data[1]);
1261 for (data += 4; hit_size > 0; hit_size--, data++) {
1263 ldns_buffer_printf(output, "%02x", (int) *data);
1265 ldns_buffer_write_u8(output, (uint8_t) ' ');
1267 if (ldns_buffer_reserve(output,
1268 ldns_b64_ntop_calculate_size(pk_size))) {
1270 written = ldns_b64_ntop(data, pk_size,
1271 (char *) ldns_buffer_current(output),
1272 ldns_buffer_remaining(output));
1275 written < (int) ldns_buffer_remaining(output)) {
1277 output->_position += written;
1280 return ldns_buffer_status(output);
1284 ldns_rdf2buffer_str_fmt(ldns_buffer *buffer,
1285 const ldns_output_format* fmt, const ldns_rdf *rdf)
1287 ldns_status res = LDNS_STATUS_OK;
1289 /*ldns_buffer_printf(buffer, "%u:", ldns_rdf_get_type(rdf));*/
1291 switch(ldns_rdf_get_type(rdf)) {
1292 case LDNS_RDF_TYPE_NONE:
1294 case LDNS_RDF_TYPE_DNAME:
1295 res = ldns_rdf2buffer_str_dname(buffer, rdf);
1297 case LDNS_RDF_TYPE_INT8:
1298 res = ldns_rdf2buffer_str_int8(buffer, rdf);
1300 case LDNS_RDF_TYPE_INT16:
1301 res = ldns_rdf2buffer_str_int16(buffer, rdf);
1303 case LDNS_RDF_TYPE_INT32:
1304 res = ldns_rdf2buffer_str_int32(buffer, rdf);
1306 case LDNS_RDF_TYPE_PERIOD:
1307 res = ldns_rdf2buffer_str_period(buffer, rdf);
1309 case LDNS_RDF_TYPE_TSIGTIME:
1310 res = ldns_rdf2buffer_str_tsigtime(buffer, rdf);
1312 case LDNS_RDF_TYPE_A:
1313 res = ldns_rdf2buffer_str_a(buffer, rdf);
1315 case LDNS_RDF_TYPE_AAAA:
1316 res = ldns_rdf2buffer_str_aaaa(buffer, rdf);
1318 case LDNS_RDF_TYPE_STR:
1319 res = ldns_rdf2buffer_str_str(buffer, rdf);
1321 case LDNS_RDF_TYPE_APL:
1322 res = ldns_rdf2buffer_str_apl(buffer, rdf);
1324 case LDNS_RDF_TYPE_B32_EXT:
1325 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1327 case LDNS_RDF_TYPE_B64:
1328 res = ldns_rdf2buffer_str_b64(buffer, rdf);
1330 case LDNS_RDF_TYPE_HEX:
1331 res = ldns_rdf2buffer_str_hex(buffer, rdf);
1333 case LDNS_RDF_TYPE_NSEC:
1334 res = ldns_rdf2buffer_str_nsec_fmt(buffer, fmt, rdf);
1336 case LDNS_RDF_TYPE_NSEC3_SALT:
1337 res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf);
1339 case LDNS_RDF_TYPE_TYPE:
1340 res = ldns_rdf2buffer_str_type_fmt(buffer, fmt, rdf);
1342 case LDNS_RDF_TYPE_CLASS:
1343 res = ldns_rdf2buffer_str_class(buffer, rdf);
1345 case LDNS_RDF_TYPE_CERT_ALG:
1346 res = ldns_rdf2buffer_str_cert_alg(buffer, rdf);
1348 case LDNS_RDF_TYPE_ALG:
1349 res = ldns_rdf2buffer_str_alg(buffer, rdf);
1351 case LDNS_RDF_TYPE_UNKNOWN:
1352 res = ldns_rdf2buffer_str_unknown(buffer, rdf);
1354 case LDNS_RDF_TYPE_TIME:
1355 res = ldns_rdf2buffer_str_time(buffer, rdf);
1357 case LDNS_RDF_TYPE_HIP:
1358 res = ldns_rdf2buffer_str_hip(buffer, rdf);
1360 case LDNS_RDF_TYPE_LOC:
1361 res = ldns_rdf2buffer_str_loc(buffer, rdf);
1363 case LDNS_RDF_TYPE_WKS:
1364 case LDNS_RDF_TYPE_SERVICE:
1365 res = ldns_rdf2buffer_str_wks(buffer, rdf);
1367 case LDNS_RDF_TYPE_NSAP:
1368 res = ldns_rdf2buffer_str_nsap(buffer, rdf);
1370 case LDNS_RDF_TYPE_ATMA:
1371 res = ldns_rdf2buffer_str_atma(buffer, rdf);
1373 case LDNS_RDF_TYPE_IPSECKEY:
1374 res = ldns_rdf2buffer_str_ipseckey(buffer, rdf);
1376 case LDNS_RDF_TYPE_INT16_DATA:
1377 res = ldns_rdf2buffer_str_int16_data(buffer, rdf);
1379 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
1380 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1382 case LDNS_RDF_TYPE_ILNP64:
1383 res = ldns_rdf2buffer_str_ilnp64(buffer, rdf);
1385 case LDNS_RDF_TYPE_EUI48:
1386 res = ldns_rdf2buffer_str_eui48(buffer, rdf);
1388 case LDNS_RDF_TYPE_EUI64:
1389 res = ldns_rdf2buffer_str_eui64(buffer, rdf);
1391 case LDNS_RDF_TYPE_TAG:
1392 res = ldns_rdf2buffer_str_tag(buffer, rdf);
1394 case LDNS_RDF_TYPE_LONG_STR:
1395 res = ldns_rdf2buffer_str_long_str(buffer, rdf);
1399 /** This will write mangled RRs */
1400 ldns_buffer_printf(buffer, "(null) ");
1401 res = LDNS_STATUS_ERR;
1407 ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
1409 return ldns_rdf2buffer_str_fmt(buffer,ldns_output_format_default,rdf);
1413 ldns_b32_ext2dname(const ldns_rdf *rdf)
1418 if(ldns_rdf_size(rdf) == 0)
1420 /* remove -1 for the b32-hash-len octet */
1421 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
1422 /* add one for the end nul for the string */
1423 b32 = LDNS_XMALLOC(char, size + 2);
1425 if (ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
1426 ldns_rdf_size(rdf) - 1, b32, size+1) > 0) {
1429 if (ldns_str2rdf_dname(&out, b32) == LDNS_STATUS_OK) {
1440 ldns_rr2buffer_str_rfc3597(ldns_buffer *output, const ldns_rr *rr)
1442 size_t total_rdfsize = 0;
1445 ldns_buffer_printf(output, "TYPE%u\t", ldns_rr_get_type(rr));
1446 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1447 total_rdfsize += ldns_rdf_size(ldns_rr_rdf(rr, i));
1449 if (total_rdfsize == 0) {
1450 ldns_buffer_printf(output, "\\# 0\n");
1451 return ldns_buffer_status(output);
1453 ldns_buffer_printf(output, "\\# %d ", total_rdfsize);
1454 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1455 for (j = 0; j < ldns_rdf_size(ldns_rr_rdf(rr, i)); j++) {
1456 ldns_buffer_printf(output, "%.2x",
1457 ldns_rdf_data(ldns_rr_rdf(rr, i))[j]);
1460 ldns_buffer_printf(output, "\n");
1461 return ldns_buffer_status(output);
1465 ldns_rr2buffer_str_fmt(ldns_buffer *output,
1466 const ldns_output_format *fmt, const ldns_rr *rr)
1469 ldns_status status = LDNS_STATUS_OK;
1470 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
1472 if (fmt_st == NULL) {
1473 fmt_st = (ldns_output_format_storage*)
1474 ldns_output_format_default;
1477 if (LDNS_COMMENT_NULLS & fmt_st->flags) {
1478 ldns_buffer_printf(output, "; (null)\n");
1480 return ldns_buffer_status(output);
1482 if (ldns_rr_owner(rr)) {
1483 status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr));
1485 if (status != LDNS_STATUS_OK) {
1489 /* TTL should NOT be printed if it is a question */
1490 if (!ldns_rr_is_question(rr)) {
1491 ldns_buffer_printf(output, "\t%d", ldns_rr_ttl(rr));
1494 ldns_buffer_printf(output, "\t");
1495 status = ldns_rr_class2buffer_str(output, ldns_rr_get_class(rr));
1496 if (status != LDNS_STATUS_OK) {
1499 ldns_buffer_printf(output, "\t");
1501 if (ldns_output_format_covers_type(fmt, ldns_rr_get_type(rr))) {
1502 return ldns_rr2buffer_str_rfc3597(output, rr);
1504 status = ldns_rr_type2buffer_str(output, ldns_rr_get_type(rr));
1505 if (status != LDNS_STATUS_OK) {
1509 if (ldns_rr_rd_count(rr) > 0) {
1510 ldns_buffer_printf(output, "\t");
1511 } else if (!ldns_rr_is_question(rr)) {
1512 ldns_buffer_printf(output, "\t\\# 0");
1515 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1516 /* ldns_rdf2buffer_str handles NULL input fine! */
1517 if ((fmt_st->flags & LDNS_FMT_ZEROIZE_RRSIGS) &&
1518 (ldns_rr_get_type(rr) == LDNS_RR_TYPE_RRSIG) &&
1519 ((/* inception */ i == 4 &&
1520 ldns_rdf_get_type(ldns_rr_rdf(rr, 4)) ==
1521 LDNS_RDF_TYPE_TIME) ||
1522 (/* expiration */ i == 5 &&
1523 ldns_rdf_get_type(ldns_rr_rdf(rr, 5)) ==
1524 LDNS_RDF_TYPE_TIME) ||
1525 (/* signature */ i == 8 &&
1526 ldns_rdf_get_type(ldns_rr_rdf(rr, 8)) ==
1527 LDNS_RDF_TYPE_B64))) {
1529 ldns_buffer_printf(output, "(null)");
1530 status = ldns_buffer_status(output);
1531 } else if ((fmt_st->flags & LDNS_FMT_PAD_SOA_SERIAL) &&
1532 (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) &&
1533 /* serial */ i == 2 &&
1534 ldns_rdf_get_type(ldns_rr_rdf(rr, 2)) ==
1535 LDNS_RDF_TYPE_INT32) {
1536 ldns_buffer_printf(output, "%10lu",
1537 (unsigned long) ldns_read_uint32(
1538 ldns_rdf_data(ldns_rr_rdf(rr, 2))));
1539 status = ldns_buffer_status(output);
1541 status = ldns_rdf2buffer_str_fmt(output,
1542 fmt, ldns_rr_rdf(rr, i));
1544 if(status != LDNS_STATUS_OK)
1546 if (i < ldns_rr_rd_count(rr) - 1) {
1547 ldns_buffer_printf(output, " ");
1550 /* per RR special comments - handy for DNSSEC types */
1551 /* check to prevent question sec. rr from
1553 if (ldns_rr_rd_count(rr) > 0) {
1554 switch (ldns_rr_get_type(rr)) {
1555 case LDNS_RR_TYPE_DNSKEY:
1556 /* if ldns_rr_rd_count(rr) > 0
1557 then ldns_rr_rdf(rr, 0) exists! */
1558 if (! (fmt_st->flags & LDNS_COMMENT_KEY)) {
1561 flags = ldns_rdf2native_int16(ldns_rr_rdf(rr, 0));
1562 ldns_buffer_printf(output, " ;{");
1563 if (fmt_st->flags & LDNS_COMMENT_KEY_ID) {
1564 ldns_buffer_printf(output, "id = %u",
1565 (unsigned int) ldns_calc_keytag(rr));
1567 if ((fmt_st->flags & LDNS_COMMENT_KEY_TYPE) &&
1568 (flags & LDNS_KEY_ZONE_KEY)){
1570 if (flags & LDNS_KEY_SEP_KEY) {
1571 ldns_buffer_printf(output, " (ksk)");
1573 ldns_buffer_printf(output, " (zsk)");
1575 if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE){
1576 ldns_buffer_printf(output, ", ");
1578 } else if (fmt_st->flags
1579 & (LDNS_COMMENT_KEY_ID
1580 |LDNS_COMMENT_KEY_SIZE)) {
1581 ldns_buffer_printf( output, ", ");
1583 if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE) {
1584 ldns_buffer_printf(output, "size = %db",
1585 ldns_rr_dnskey_key_size(rr));
1587 ldns_buffer_printf(output, "}");
1589 case LDNS_RR_TYPE_RRSIG:
1590 if ((fmt_st->flags & LDNS_COMMENT_KEY)
1591 && (fmt_st->flags& LDNS_COMMENT_RRSIGS)
1592 && ldns_rr_rdf(rr, 6) != NULL) {
1593 ldns_buffer_printf(output, " ;{id = %d}",
1594 ldns_rdf2native_int16(
1595 ldns_rr_rdf(rr, 6)));
1598 case LDNS_RR_TYPE_DS:
1599 if ((fmt_st->flags & LDNS_COMMENT_BUBBLEBABBLE) &&
1600 ldns_rr_rdf(rr, 3) != NULL) {
1602 uint8_t *data = ldns_rdf_data(
1603 ldns_rr_rdf(rr, 3));
1604 size_t len = ldns_rdf_size(ldns_rr_rdf(rr, 3));
1605 char *babble = ldns_bubblebabble(data, len);
1607 ldns_buffer_printf(output,
1613 case LDNS_RR_TYPE_NSEC3:
1614 if (! (fmt_st->flags & LDNS_COMMENT_FLAGS) &&
1615 ! (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN)) {
1618 ldns_buffer_printf(output, " ;{");
1619 if ((fmt_st->flags & LDNS_COMMENT_FLAGS)) {
1620 if (ldns_nsec3_optout(rr)) {
1621 ldns_buffer_printf(output,
1624 ldns_buffer_printf(output," flags: -");
1626 if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN &&
1627 fmt_st->hashmap != NULL) {
1628 ldns_buffer_printf(output, ", ");
1631 if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN &&
1632 fmt_st->hashmap != NULL) {
1633 ldns_rbnode_t *node;
1634 ldns_rdf *key = ldns_dname_label(
1635 ldns_rr_owner(rr), 0);
1637 node = ldns_rbtree_search(
1641 ldns_buffer_printf(output,
1643 (void) ldns_rdf2buffer_str(
1645 ldns_dnssec_name_name(
1652 key = ldns_b32_ext2dname(
1653 ldns_nsec3_next_owner(rr));
1655 node = ldns_rbtree_search(
1659 ldns_buffer_printf(output,
1661 (void) ldns_rdf2buffer_str(
1663 ldns_dnssec_name_name(
1671 ldns_buffer_printf(output, "}");
1679 ldns_buffer_printf(output, "\n");
1680 return ldns_buffer_status(output);
1684 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
1686 return ldns_rr2buffer_str_fmt(output, ldns_output_format_default, rr);
1690 ldns_rr_list2buffer_str_fmt(ldns_buffer *output,
1691 const ldns_output_format *fmt, const ldns_rr_list *list)
1695 for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
1696 (void) ldns_rr2buffer_str_fmt(output, fmt,
1697 ldns_rr_list_rr(list, i));
1699 return ldns_buffer_status(output);
1703 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
1705 return ldns_rr_list2buffer_str_fmt(
1706 output, ldns_output_format_default, list);
1710 ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
1712 ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
1713 (int) ldns_pkt_get_opcode(pkt));
1714 ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes,
1715 (int) ldns_pkt_get_rcode(pkt));
1717 ldns_buffer_printf(output, ";; ->>HEADER<<- ");
1719 ldns_buffer_printf(output, "opcode: %s, ", opcode->name);
1721 ldns_buffer_printf(output, "opcode: ?? (%u), ",
1722 ldns_pkt_get_opcode(pkt));
1725 ldns_buffer_printf(output, "rcode: %s, ", rcode->name);
1727 ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt));
1729 ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt));
1730 ldns_buffer_printf(output, ";; flags: ");
1732 if (ldns_pkt_qr(pkt)) {
1733 ldns_buffer_printf(output, "qr ");
1735 if (ldns_pkt_aa(pkt)) {
1736 ldns_buffer_printf(output, "aa ");
1738 if (ldns_pkt_tc(pkt)) {
1739 ldns_buffer_printf(output, "tc ");
1741 if (ldns_pkt_rd(pkt)) {
1742 ldns_buffer_printf(output, "rd ");
1744 if (ldns_pkt_cd(pkt)) {
1745 ldns_buffer_printf(output, "cd ");
1747 if (ldns_pkt_ra(pkt)) {
1748 ldns_buffer_printf(output, "ra ");
1750 if (ldns_pkt_ad(pkt)) {
1751 ldns_buffer_printf(output, "ad ");
1753 ldns_buffer_printf(output, "; ");
1754 ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt));
1755 ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt));
1756 ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt));
1757 ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt));
1758 return ldns_buffer_status(output);
1762 ldns_pkt2buffer_str_fmt(ldns_buffer *output,
1763 const ldns_output_format *fmt, const ldns_pkt *pkt)
1766 ldns_status status = LDNS_STATUS_OK;
1768 struct timeval time;
1772 ldns_buffer_printf(output, "null");
1773 return LDNS_STATUS_OK;
1776 if (ldns_buffer_status_ok(output)) {
1777 status = ldns_pktheader2buffer_str(output, pkt);
1778 if (status != LDNS_STATUS_OK) {
1782 ldns_buffer_printf(output, "\n");
1784 ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
1787 for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
1788 status = ldns_rr2buffer_str_fmt(output, fmt,
1790 ldns_pkt_question(pkt), i));
1791 if (status != LDNS_STATUS_OK) {
1795 ldns_buffer_printf(output, "\n");
1797 ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
1798 for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
1799 status = ldns_rr2buffer_str_fmt(output, fmt,
1801 ldns_pkt_answer(pkt), i));
1802 if (status != LDNS_STATUS_OK) {
1807 ldns_buffer_printf(output, "\n");
1809 ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
1811 for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
1812 status = ldns_rr2buffer_str_fmt(output, fmt,
1814 ldns_pkt_authority(pkt), i));
1815 if (status != LDNS_STATUS_OK) {
1819 ldns_buffer_printf(output, "\n");
1821 ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
1822 for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
1823 status = ldns_rr2buffer_str_fmt(output, fmt,
1825 ldns_pkt_additional(pkt), i));
1826 if (status != LDNS_STATUS_OK) {
1831 ldns_buffer_printf(output, "\n");
1832 /* add some futher fields */
1833 ldns_buffer_printf(output, ";; Query time: %d msec\n",
1834 ldns_pkt_querytime(pkt));
1835 if (ldns_pkt_edns(pkt)) {
1836 ldns_buffer_printf(output,
1837 ";; EDNS: version %u; flags:",
1838 ldns_pkt_edns_version(pkt));
1839 if (ldns_pkt_edns_do(pkt)) {
1840 ldns_buffer_printf(output, " do");
1842 /* the extended rcode is the value set, shifted four bits,
1843 * and or'd with the original rcode */
1844 if (ldns_pkt_edns_extended_rcode(pkt)) {
1845 ldns_buffer_printf(output, " ; ext-rcode: %d",
1846 (ldns_pkt_edns_extended_rcode(pkt) << 4 | ldns_pkt_get_rcode(pkt)));
1848 ldns_buffer_printf(output, " ; udp: %u\n",
1849 ldns_pkt_edns_udp_size(pkt));
1851 if (ldns_pkt_edns_data(pkt)) {
1852 ldns_buffer_printf(output, ";; Data: ");
1853 (void)ldns_rdf2buffer_str(output,
1854 ldns_pkt_edns_data(pkt));
1855 ldns_buffer_printf(output, "\n");
1858 if (ldns_pkt_tsig(pkt)) {
1859 ldns_buffer_printf(output, ";; TSIG:\n;; ");
1860 (void) ldns_rr2buffer_str_fmt(
1861 output, fmt, ldns_pkt_tsig(pkt));
1862 ldns_buffer_printf(output, "\n");
1864 if (ldns_pkt_answerfrom(pkt)) {
1865 tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
1866 ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
1869 time = ldns_pkt_timestamp(pkt);
1870 time_tt = (time_t)time.tv_sec;
1871 ldns_buffer_printf(output, ";; WHEN: %s",
1872 (char*)ctime(&time_tt));
1874 ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n",
1875 (int)ldns_pkt_size(pkt));
1877 return ldns_buffer_status(output);
1883 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
1885 return ldns_pkt2buffer_str_fmt(output, ldns_output_format_default, pkt);
1891 ldns_hmac_key2buffer_str(ldns_buffer *output, const ldns_key *k)
1895 ldns_rdf *b64_bignum;
1897 ldns_buffer_printf(output, "Key: ");
1899 i = ldns_key_hmac_size(k);
1900 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k));
1901 status = ldns_rdf2buffer_str(output, b64_bignum);
1902 ldns_rdf_deep_free(b64_bignum);
1903 ldns_buffer_printf(output, "\n");
1908 #if defined(HAVE_SSL) && defined(USE_GOST)
1910 ldns_gost_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
1912 unsigned char* pp = NULL;
1914 ldns_rdf *b64_bignum;
1917 ldns_buffer_printf(output, "GostAsn1: ");
1919 ret = i2d_PrivateKey(p, &pp);
1920 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, (size_t)ret, pp);
1921 status = ldns_rdf2buffer_str(output, b64_bignum);
1923 ldns_rdf_deep_free(b64_bignum);
1925 ldns_buffer_printf(output, "\n");
1931 ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
1933 ldns_status status = LDNS_STATUS_OK;
1934 unsigned char *bignum;
1939 /* not used when ssl is not defined */
1941 ldns_rdf *b64_bignum = NULL;
1945 #endif /* HAVE_SSL */
1948 return LDNS_STATUS_ERR;
1951 bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
1953 return LDNS_STATUS_ERR;
1956 if (ldns_buffer_status_ok(output)) {
1958 switch(ldns_key_algorithm(k)) {
1959 case LDNS_SIGN_RSASHA1:
1960 case LDNS_SIGN_RSASHA1_NSEC3:
1961 case LDNS_SIGN_RSASHA256:
1962 case LDNS_SIGN_RSASHA512:
1963 case LDNS_SIGN_RSAMD5:
1964 /* copied by looking at dnssec-keygen output */
1966 rsa = ldns_key_rsa_key(k);
1968 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
1969 switch(ldns_key_algorithm(k)) {
1970 case LDNS_SIGN_RSAMD5:
1971 ldns_buffer_printf(output,
1972 "Algorithm: %u (RSA)\n",
1975 case LDNS_SIGN_RSASHA1:
1976 ldns_buffer_printf(output,
1977 "Algorithm: %u (RSASHA1)\n",
1980 case LDNS_SIGN_RSASHA1_NSEC3:
1981 ldns_buffer_printf(output,
1982 "Algorithm: %u (RSASHA1_NSEC3)\n",
1983 LDNS_RSASHA1_NSEC3);
1986 case LDNS_SIGN_RSASHA256:
1987 ldns_buffer_printf(output,
1988 "Algorithm: %u (RSASHA256)\n",
1991 case LDNS_SIGN_RSASHA512:
1992 ldns_buffer_printf(output,
1993 "Algorithm: %u (RSASHA512)\n",
1999 fprintf(stderr, "Warning: unknown signature ");
2001 "algorithm type %u\n",
2002 ldns_key_algorithm(k));
2004 ldns_buffer_printf(output,
2005 "Algorithm: %u (Unknown)\n",
2006 ldns_key_algorithm(k));
2010 /* print to buf, convert to bin, convert to b64,
2012 ldns_buffer_printf(output, "Modulus: ");
2014 i = (uint16_t)BN_bn2bin(rsa->n, bignum);
2015 if (i > LDNS_MAX_KEYLEN) {
2018 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2019 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2020 ldns_rdf_deep_free(b64_bignum);
2023 ldns_rdf_deep_free(b64_bignum);
2024 ldns_buffer_printf(output, "\n");
2025 ldns_buffer_printf(output, "PublicExponent: ");
2026 i = (uint16_t)BN_bn2bin(rsa->e, bignum);
2027 if (i > LDNS_MAX_KEYLEN) {
2030 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2031 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2032 ldns_rdf_deep_free(b64_bignum);
2035 ldns_rdf_deep_free(b64_bignum);
2036 ldns_buffer_printf(output, "\n");
2038 ldns_buffer_printf(output, "PrivateExponent: ");
2040 i = (uint16_t)BN_bn2bin(rsa->d, bignum);
2041 if (i > LDNS_MAX_KEYLEN) {
2044 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2045 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2046 ldns_rdf_deep_free(b64_bignum);
2049 ldns_rdf_deep_free(b64_bignum);
2050 ldns_buffer_printf(output, "\n");
2052 ldns_buffer_printf(output, "(Not available)\n");
2055 ldns_buffer_printf(output, "Prime1: ");
2057 i = (uint16_t)BN_bn2bin(rsa->p, bignum);
2058 if (i > LDNS_MAX_KEYLEN) {
2061 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2062 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2063 ldns_rdf_deep_free(b64_bignum);
2066 ldns_rdf_deep_free(b64_bignum);
2067 ldns_buffer_printf(output, "\n");
2069 ldns_buffer_printf(output, "(Not available)\n");
2072 ldns_buffer_printf(output, "Prime2: ");
2074 i = (uint16_t)BN_bn2bin(rsa->q, bignum);
2075 if (i > LDNS_MAX_KEYLEN) {
2078 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2079 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2080 ldns_rdf_deep_free(b64_bignum);
2083 ldns_rdf_deep_free(b64_bignum);
2084 ldns_buffer_printf(output, "\n");
2086 ldns_buffer_printf(output, "(Not available)\n");
2089 ldns_buffer_printf(output, "Exponent1: ");
2091 i = (uint16_t)BN_bn2bin(rsa->dmp1, bignum);
2092 if (i > LDNS_MAX_KEYLEN) {
2095 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2096 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2097 ldns_rdf_deep_free(b64_bignum);
2100 ldns_rdf_deep_free(b64_bignum);
2101 ldns_buffer_printf(output, "\n");
2103 ldns_buffer_printf(output, "(Not available)\n");
2106 ldns_buffer_printf(output, "Exponent2: ");
2108 i = (uint16_t)BN_bn2bin(rsa->dmq1, bignum);
2109 if (i > LDNS_MAX_KEYLEN) {
2112 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2113 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2114 ldns_rdf_deep_free(b64_bignum);
2117 ldns_rdf_deep_free(b64_bignum);
2118 ldns_buffer_printf(output, "\n");
2120 ldns_buffer_printf(output, "(Not available)\n");
2123 ldns_buffer_printf(output, "Coefficient: ");
2125 i = (uint16_t)BN_bn2bin(rsa->iqmp, bignum);
2126 if (i > LDNS_MAX_KEYLEN) {
2129 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2130 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2131 ldns_rdf_deep_free(b64_bignum);
2134 ldns_rdf_deep_free(b64_bignum);
2135 ldns_buffer_printf(output, "\n");
2137 ldns_buffer_printf(output, "(Not available)\n");
2144 case LDNS_SIGN_DSA_NSEC3:
2145 dsa = ldns_key_dsa_key(k);
2147 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
2148 if (ldns_key_algorithm(k) == LDNS_SIGN_DSA) {
2149 ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n");
2150 } else if (ldns_key_algorithm(k) == LDNS_SIGN_DSA_NSEC3) {
2151 ldns_buffer_printf(output,"Algorithm: 6 (DSA_NSEC3)\n");
2154 /* print to buf, convert to bin, convert to b64,
2156 ldns_buffer_printf(output, "Prime(p): ");
2159 i = (uint16_t)BN_bn2bin(dsa->p, bignum);
2160 if (i > LDNS_MAX_KEYLEN) {
2163 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2164 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2165 ldns_rdf_deep_free(b64_bignum);
2168 ldns_rdf_deep_free(b64_bignum);
2169 ldns_buffer_printf(output, "\n");
2171 printf("(Not available)\n");
2174 ldns_buffer_printf(output, "Subprime(q): ");
2176 i = (uint16_t)BN_bn2bin(dsa->q, bignum);
2177 if (i > LDNS_MAX_KEYLEN) {
2180 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2181 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2182 ldns_rdf_deep_free(b64_bignum);
2185 ldns_rdf_deep_free(b64_bignum);
2186 ldns_buffer_printf(output, "\n");
2188 printf("(Not available)\n");
2191 ldns_buffer_printf(output, "Base(g): ");
2193 i = (uint16_t)BN_bn2bin(dsa->g, bignum);
2194 if (i > LDNS_MAX_KEYLEN) {
2197 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2198 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2199 ldns_rdf_deep_free(b64_bignum);
2202 ldns_rdf_deep_free(b64_bignum);
2203 ldns_buffer_printf(output, "\n");
2205 printf("(Not available)\n");
2208 ldns_buffer_printf(output, "Private_value(x): ");
2209 if (dsa->priv_key) {
2210 i = (uint16_t)BN_bn2bin(dsa->priv_key, bignum);
2211 if (i > LDNS_MAX_KEYLEN) {
2214 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2215 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2216 ldns_rdf_deep_free(b64_bignum);
2219 ldns_rdf_deep_free(b64_bignum);
2220 ldns_buffer_printf(output, "\n");
2222 printf("(Not available)\n");
2225 ldns_buffer_printf(output, "Public_value(y): ");
2227 i = (uint16_t)BN_bn2bin(dsa->pub_key, bignum);
2228 if (i > LDNS_MAX_KEYLEN) {
2231 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2232 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2233 ldns_rdf_deep_free(b64_bignum);
2236 ldns_rdf_deep_free(b64_bignum);
2237 ldns_buffer_printf(output, "\n");
2239 printf("(Not available)\n");
2243 case LDNS_SIGN_ECC_GOST:
2244 /* no format defined, use blob */
2245 #if defined(HAVE_SSL) && defined(USE_GOST)
2246 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
2247 ldns_buffer_printf(output, "Algorithm: %d (ECC-GOST)\n", LDNS_SIGN_ECC_GOST);
2248 status = ldns_gost_key2buffer_str(output,
2259 case LDNS_SIGN_ECDSAP256SHA256:
2260 case LDNS_SIGN_ECDSAP384SHA384:
2262 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
2263 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
2264 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
2266 ldns_buffer_printf(output, ")\n");
2268 EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->_key.key);
2269 const BIGNUM* b = EC_KEY_get0_private_key(ec);
2270 ldns_buffer_printf(output, "PrivateKey: ");
2271 i = (uint16_t)BN_bn2bin(b, bignum);
2272 if (i > LDNS_MAX_KEYLEN) {
2275 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2276 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2277 ldns_rdf_deep_free(b64_bignum);
2280 ldns_rdf_deep_free(b64_bignum);
2281 ldns_buffer_printf(output, "\n");
2282 /* down reference count in EC_KEY
2283 * its still assigned to the PKEY */
2291 case LDNS_SIGN_HMACMD5:
2292 /* there's not much of a format defined for TSIG */
2293 /* It's just a binary blob, Same for all algorithms */
2294 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
2295 ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n");
2296 status = ldns_hmac_key2buffer_str(output, k);
2298 case LDNS_SIGN_HMACSHA1:
2299 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
2300 ldns_buffer_printf(output, "Algorithm: 158 (HMAC_SHA1)\n");
2301 status = ldns_hmac_key2buffer_str(output, k);
2303 case LDNS_SIGN_HMACSHA256:
2304 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
2305 ldns_buffer_printf(output, "Algorithm: 159 (HMAC_SHA256)\n");
2306 status = ldns_hmac_key2buffer_str(output, k);
2309 #endif /* HAVE_SSL */
2312 return ldns_buffer_status(output);
2318 /* compiles warn the label isn't used */
2321 return LDNS_STATUS_ERR;
2322 #endif /* HAVE_SSL */
2327 * Zero terminate the buffer and copy data.
2330 ldns_buffer2str(ldns_buffer *buffer)
2334 /* check if buffer ends with \0, if not, and
2335 if there is space, add it */
2336 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
2337 if (!ldns_buffer_reserve(buffer, 1)) {
2340 ldns_buffer_write_u8(buffer, (uint8_t) '\0');
2341 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
2346 str = strdup((const char *)ldns_buffer_begin(buffer));
2354 * Zero terminate the buffer and export data.
2357 ldns_buffer_export2str(ldns_buffer *buffer)
2359 /* Append '\0' as string terminator */
2360 if (! ldns_buffer_reserve(buffer, 1)) {
2363 ldns_buffer_write_u8(buffer, 0);
2365 /* reallocate memory to the size of the string and export */
2366 ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer));
2367 return ldns_buffer_export(buffer);
2371 ldns_rdf2str(const ldns_rdf *rdf)
2373 char *result = NULL;
2374 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2379 if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
2380 /* export and return string, destroy rest */
2381 result = ldns_buffer_export2str(tmp_buffer);
2383 ldns_buffer_free(tmp_buffer);
2388 ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr)
2390 char *result = NULL;
2391 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2396 if (ldns_rr2buffer_str_fmt(tmp_buffer, fmt, rr)
2397 == LDNS_STATUS_OK) {
2398 /* export and return string, destroy rest */
2399 result = ldns_buffer_export2str(tmp_buffer);
2401 ldns_buffer_free(tmp_buffer);
2406 ldns_rr2str(const ldns_rr *rr)
2408 return ldns_rr2str_fmt(ldns_output_format_default, rr);
2412 ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt)
2414 char *result = NULL;
2415 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2420 if (ldns_pkt2buffer_str_fmt(tmp_buffer, fmt, pkt)
2421 == LDNS_STATUS_OK) {
2422 /* export and return string, destroy rest */
2423 result = ldns_buffer_export2str(tmp_buffer);
2426 ldns_buffer_free(tmp_buffer);
2431 ldns_pkt2str(const ldns_pkt *pkt)
2433 return ldns_pkt2str_fmt(ldns_output_format_default, pkt);
2437 ldns_key2str(const ldns_key *k)
2439 char *result = NULL;
2440 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2445 if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) {
2446 /* export and return string, destroy rest */
2447 result = ldns_buffer_export2str(tmp_buffer);
2449 ldns_buffer_free(tmp_buffer);
2454 ldns_rr_list2str_fmt(const ldns_output_format *fmt, const ldns_rr_list *list)
2456 char *result = NULL;
2457 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2463 if (ldns_rr_list2buffer_str_fmt(
2464 tmp_buffer, fmt, list)
2465 == LDNS_STATUS_OK) {
2469 fmt = ldns_output_format_default;
2471 if (fmt->flags & LDNS_COMMENT_NULLS) {
2472 ldns_buffer_printf(tmp_buffer, "; (null)\n");
2476 /* export and return string, destroy rest */
2477 result = ldns_buffer_export2str(tmp_buffer);
2478 ldns_buffer_free(tmp_buffer);
2483 ldns_rr_list2str(const ldns_rr_list *list)
2485 return ldns_rr_list2str_fmt(ldns_output_format_default, list);
2489 ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
2491 char *str = ldns_rdf2str(rdf);
2493 fprintf(output, "%s", str);
2495 fprintf(output, ";Unable to convert rdf to string\n");
2501 ldns_rr_print_fmt(FILE *output,
2502 const ldns_output_format *fmt, const ldns_rr *rr)
2504 char *str = ldns_rr2str_fmt(fmt, rr);
2506 fprintf(output, "%s", str);
2508 fprintf(output, ";Unable to convert rr to string\n");
2514 ldns_rr_print(FILE *output, const ldns_rr *rr)
2516 ldns_rr_print_fmt(output, ldns_output_format_default, rr);
2520 ldns_pkt_print_fmt(FILE *output,
2521 const ldns_output_format *fmt, const ldns_pkt *pkt)
2523 char *str = ldns_pkt2str_fmt(fmt, pkt);
2525 fprintf(output, "%s", str);
2527 fprintf(output, ";Unable to convert packet to string\n");
2533 ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
2535 ldns_pkt_print_fmt(output, ldns_output_format_default, pkt);
2539 ldns_rr_list_print_fmt(FILE *output,
2540 const ldns_output_format *fmt, const ldns_rr_list *lst)
2543 for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
2544 ldns_rr_print_fmt(output, fmt, ldns_rr_list_rr(lst, i));
2549 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
2551 ldns_rr_list_print_fmt(output, ldns_output_format_default, lst);
2555 ldns_resolver_print_fmt(FILE *output,
2556 const ldns_output_format *fmt, const ldns_resolver *r)
2565 n = ldns_resolver_nameservers(r);
2566 s = ldns_resolver_searchlist(r);
2567 rtt = ldns_resolver_rtt(r);
2569 fprintf(output, "port: %d\n", (int)ldns_resolver_port(r));
2570 fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r));
2571 fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r));
2573 fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r));
2574 fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r));
2575 fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r));
2576 fprintf(output, "fail: %d\n", ldns_resolver_fail(r));
2577 fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r));
2578 fprintf(output, "retrans: %d\n", (int)ldns_resolver_retrans(r));
2579 fprintf(output, "fallback: %d\n", ldns_resolver_fallback(r));
2580 fprintf(output, "random: %d\n", ldns_resolver_random(r));
2581 fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
2582 fprintf(output, "dnssec: %d\n", ldns_resolver_dnssec(r));
2583 fprintf(output, "dnssec cd: %d\n", ldns_resolver_dnssec_cd(r));
2584 fprintf(output, "trust anchors (%d listed):\n",
2585 (int)ldns_rr_list_rr_count(ldns_resolver_dnssec_anchors(r)));
2586 ldns_rr_list_print_fmt(output, fmt, ldns_resolver_dnssec_anchors(r));
2587 fprintf(output, "tsig: %s %s\n",
2588 ldns_resolver_tsig_keyname(r)?ldns_resolver_tsig_keyname(r):"-",
2589 ldns_resolver_tsig_algorithm(r)?ldns_resolver_tsig_algorithm(r):"-");
2590 fprintf(output, "debug: %d\n", ldns_resolver_debug(r));
2592 fprintf(output, "default domain: ");
2593 ldns_rdf_print(output, ldns_resolver_domain(r));
2594 fprintf(output, "\n");
2595 fprintf(output, "apply default domain: %d\n", ldns_resolver_defnames(r));
2597 fprintf(output, "searchlist (%d listed):\n", (int)ldns_resolver_searchlist_count(r));
2598 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
2599 fprintf(output, "\t");
2600 ldns_rdf_print(output, s[i]);
2601 fprintf(output, "\n");
2603 fprintf(output, "apply search list: %d\n", ldns_resolver_dnsrch(r));
2605 fprintf(output, "nameservers (%d listed):\n", (int)ldns_resolver_nameserver_count(r));
2606 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
2607 fprintf(output, "\t");
2608 ldns_rdf_print(output, n[i]);
2610 switch ((int)rtt[i]) {
2611 case LDNS_RESOLV_RTT_MIN:
2612 fprintf(output, " - reachable\n");
2614 case LDNS_RESOLV_RTT_INF:
2615 fprintf(output, " - unreachable\n");
2622 ldns_resolver_print(FILE *output, const ldns_resolver *r)
2624 ldns_resolver_print_fmt(output, ldns_output_format_default, r);
2628 ldns_zone_print_fmt(FILE *output,
2629 const ldns_output_format *fmt, const ldns_zone *z)
2631 if(ldns_zone_soa(z))
2632 ldns_rr_print_fmt(output, fmt, ldns_zone_soa(z));
2633 ldns_rr_list_print_fmt(output, fmt, ldns_zone_rrs(z));
2636 ldns_zone_print(FILE *output, const ldns_zone *z)
2638 ldns_zone_print_fmt(output, ldns_output_format_default, z);