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 2538 */
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_URI, "URI" },
72 { LDNS_CERT_OID, "OID" },
77 ldns_lookup_table ldns_rr_classes[] = {
78 { LDNS_RR_CLASS_IN, "IN" },
79 { LDNS_RR_CLASS_CH, "CH" },
80 { LDNS_RR_CLASS_HS, "HS" },
81 { LDNS_RR_CLASS_NONE, "NONE" },
82 { LDNS_RR_CLASS_ANY, "ANY" },
86 /* if these are used elsewhere */
87 ldns_lookup_table ldns_rcodes[] = {
88 { LDNS_RCODE_NOERROR, "NOERROR" },
89 { LDNS_RCODE_FORMERR, "FORMERR" },
90 { LDNS_RCODE_SERVFAIL, "SERVFAIL" },
91 { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" },
92 { LDNS_RCODE_NOTIMPL, "NOTIMPL" },
93 { LDNS_RCODE_REFUSED, "REFUSED" },
94 { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" },
95 { LDNS_RCODE_YXRRSET, "YXRRSET" },
96 { LDNS_RCODE_NXRRSET, "NXRRSET" },
97 { LDNS_RCODE_NOTAUTH, "NOTAUTH" },
98 { LDNS_RCODE_NOTZONE, "NOTZONE" },
102 ldns_lookup_table ldns_opcodes[] = {
103 { LDNS_PACKET_QUERY, "QUERY" },
104 { LDNS_PACKET_IQUERY, "IQUERY" },
105 { LDNS_PACKET_STATUS, "STATUS" },
106 { LDNS_PACKET_NOTIFY, "NOTIFY" },
107 { LDNS_PACKET_UPDATE, "UPDATE" },
112 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode)
114 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode);
115 if (lt && lt->name) {
116 ldns_buffer_printf(output, "%s", lt->name);
118 ldns_buffer_printf(output, "OPCODE%u", opcode);
120 return ldns_buffer_status(output);
124 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode)
126 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode);
127 if (lt && lt->name) {
128 ldns_buffer_printf(output, "%s", lt->name);
130 ldns_buffer_printf(output, "RCODE%u", rcode);
132 return ldns_buffer_status(output);
136 ldns_algorithm2buffer_str(ldns_buffer *output,
137 ldns_algorithm algorithm)
139 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_algorithms,
141 if (lt && lt->name) {
142 ldns_buffer_printf(output, "%s", lt->name);
144 ldns_buffer_printf(output, "ALG%u", algorithm);
146 return ldns_buffer_status(output);
150 ldns_cert_algorithm2buffer_str(ldns_buffer *output,
151 ldns_cert_algorithm cert_algorithm)
153 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_cert_algorithms,
155 if (lt && lt->name) {
156 ldns_buffer_printf(output, "%s", lt->name);
158 ldns_buffer_printf(output, "CERT_ALG%u",
161 return ldns_buffer_status(output);
165 ldns_pkt_opcode2str(ldns_pkt_opcode opcode)
170 buf = ldns_buffer_new(12);
173 if (ldns_pkt_opcode2buffer_str(buf, opcode) == LDNS_STATUS_OK) {
174 str = ldns_buffer2str(buf);
177 ldns_buffer_free(buf);
182 ldns_pkt_rcode2str(ldns_pkt_rcode rcode)
187 buf = ldns_buffer_new(10);
190 if (ldns_pkt_rcode2buffer_str(buf, rcode) == LDNS_STATUS_OK) {
191 str = ldns_buffer2str(buf);
194 ldns_buffer_free(buf);
199 ldns_pkt_algorithm2str(ldns_algorithm algorithm)
204 buf = ldns_buffer_new(10);
207 if (ldns_algorithm2buffer_str(buf, algorithm)
209 str = ldns_buffer2str(buf);
212 ldns_buffer_free(buf);
217 ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm)
222 buf = ldns_buffer_new(10);
225 if (ldns_cert_algorithm2buffer_str(buf, cert_algorithm)
227 str = ldns_buffer2str(buf);
230 ldns_buffer_free(buf);
235 /* do NOT pass compressed data here :p */
237 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
239 /* can we do with 1 pos var? or without at all? */
245 data = (uint8_t*)ldns_rdf_data(dname);
248 if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) {
249 /* too large, return */
250 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
253 /* special case: root label */
254 if (1 == ldns_rdf_size(dname)) {
255 ldns_buffer_printf(output, ".");
257 while ((len > 0) && src_pos < ldns_rdf_size(dname)) {
259 for(i = 0; i < len; i++) {
260 /* paranoia check for various 'strange'
263 if(data[src_pos]=='.' || data[src_pos]==';' ||
264 data[src_pos]=='(' || data[src_pos]==')' ||
265 data[src_pos]=='\\') {
266 ldns_buffer_printf(output, "\\%c",
268 } else if (!isgraph((int) data[src_pos])) {
269 ldns_buffer_printf(output, "\\%03u",
272 ldns_buffer_printf(output, "%c", data[src_pos]);
277 if (src_pos < ldns_rdf_size(dname)) {
278 ldns_buffer_printf(output, ".");
283 return ldns_buffer_status(output);
287 ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
289 uint8_t data = ldns_rdf_data(rdf)[0];
290 ldns_buffer_printf(output, "%lu", (unsigned long) data);
291 return ldns_buffer_status(output);
295 ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
297 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
298 ldns_buffer_printf(output, "%lu", (unsigned long) data);
299 return ldns_buffer_status(output);
303 ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
305 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
306 ldns_buffer_printf(output, "%lu", (unsigned long) data);
307 return ldns_buffer_status(output);
311 ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
313 /* create a YYYYMMDDHHMMSS string if possible */
314 time_t data_time = (time_t) ldns_read_uint32(ldns_rdf_data(rdf));
318 memset(&tm, 0, sizeof(tm));
320 if (gmtime_r(&data_time, &tm) && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
321 ldns_buffer_printf(output, "%s", date_buf);
323 return ldns_buffer_status(output);
327 ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
329 char str[INET_ADDRSTRLEN];
331 if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) {
332 ldns_buffer_printf(output, "%s", str);
334 return ldns_buffer_status(output);
338 ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
340 char str[INET6_ADDRSTRLEN];
342 if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) {
343 ldns_buffer_printf(output, "%s", str);
346 return ldns_buffer_status(output);
350 ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
352 const uint8_t *data = ldns_rdf_data(rdf);
353 uint8_t length = data[0];
356 ldns_buffer_printf(output, "\"");
357 for (i = 1; i <= length; ++i) {
358 char ch = (char) data[i];
359 if (isprint((int)ch) || ch=='\t') {
360 if (ch=='\"'||ch=='\\')
361 ldns_buffer_printf(output, "\\%c", ch);
363 ldns_buffer_printf(output, "%c", ch);
365 ldns_buffer_printf(output, "\\%03u", (unsigned) ch);
368 ldns_buffer_printf(output, "\"");
369 return ldns_buffer_status(output);
373 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
375 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf));
376 char *b64 = LDNS_XMALLOC(char, size);
377 if(!b64) return LDNS_STATUS_MEM_ERR;
378 if (ldns_b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) {
379 ldns_buffer_printf(output, "%s", b64);
382 return ldns_buffer_status(output);
386 ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf)
390 if(ldns_rdf_size(rdf) == 0)
391 return LDNS_STATUS_OK;
392 /* remove -1 for the b32-hash-len octet */
393 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
394 /* add one for the end nul for the string */
395 b32 = LDNS_XMALLOC(char, size + 1);
396 if(!b32) return LDNS_STATUS_MEM_ERR;
397 size = (size_t) ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
398 ldns_rdf_size(rdf) - 1, b32, size+1);
400 ldns_buffer_printf(output, "%s", b32);
403 return ldns_buffer_status(output);
407 ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
410 for (i = 0; i < ldns_rdf_size(rdf); i++) {
411 ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]);
414 return ldns_buffer_status(output);
418 ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
420 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
421 const ldns_rr_descriptor *descriptor;
423 descriptor = ldns_rr_descript(data);
424 if (descriptor && descriptor->_name) {
425 ldns_buffer_printf(output, "%s", descriptor->_name);
427 ldns_buffer_printf(output, "TYPE%u", data);
429 return ldns_buffer_status(output);
433 ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
435 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
436 ldns_lookup_table *lt;
438 lt = ldns_lookup_by_id(ldns_rr_classes, (int) data);
440 ldns_buffer_printf(output, "\t%s", lt->name);
442 ldns_buffer_printf(output, "\tCLASS%d", data);
444 return ldns_buffer_status(output);
448 ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
450 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
451 ldns_lookup_table *lt;
452 lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data);
454 ldns_buffer_printf(output, "%s", lt->name);
456 ldns_buffer_printf(output, "%d", data);
458 return ldns_buffer_status(output);
462 ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
464 /* don't use algorithm mnemonics in the presentation format
465 this kind of got sneaked into the rfc's */
466 uint8_t data = ldns_rdf_data(rdf)[0];
467 ldns_buffer_printf(output, "%d", data);
468 return ldns_buffer_status(output);
472 loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
475 /* is it 0.<two digits> ? */
479 ldns_buffer_printf(output, "0.%02ld", (long)mantissa);
482 /* always <digit><string of zeros> */
483 ldns_buffer_printf(output, "%d", (int)mantissa);
484 for(i=0; i<exponent-2; i++)
485 ldns_buffer_printf(output, "0");
489 ldns_rr_type2buffer_str(ldns_buffer *output, const ldns_rr_type type)
491 const ldns_rr_descriptor *descriptor;
493 descriptor = ldns_rr_descript(type);
495 if (descriptor && descriptor->_name) {
496 ldns_buffer_printf(output, "%s", descriptor->_name);
498 /* exceptions for pseudotypes */
500 case LDNS_RR_TYPE_IXFR:
501 ldns_buffer_printf(output, "IXFR");
503 case LDNS_RR_TYPE_AXFR:
504 ldns_buffer_printf(output, "AXFR");
506 case LDNS_RR_TYPE_MAILA:
507 ldns_buffer_printf(output, "MAILA");
509 case LDNS_RR_TYPE_MAILB:
510 ldns_buffer_printf(output, "MAILB");
512 case LDNS_RR_TYPE_ANY:
513 ldns_buffer_printf(output, "ANY");
516 ldns_buffer_printf(output, "TYPE%u", type);
519 return ldns_buffer_status(output);
523 ldns_rr_type2str(const ldns_rr_type type)
528 buf = ldns_buffer_new(10);
531 if (ldns_rr_type2buffer_str(buf, type) == LDNS_STATUS_OK) {
532 str = ldns_buffer2str(buf);
535 ldns_buffer_free(buf);
541 ldns_rr_class2buffer_str(ldns_buffer *output,
542 const ldns_rr_class klass)
544 ldns_lookup_table *lt;
546 lt = ldns_lookup_by_id(ldns_rr_classes, klass);
548 ldns_buffer_printf(output, "%s", lt->name);
550 ldns_buffer_printf(output, "CLASS%d", klass);
552 return ldns_buffer_status(output);
556 ldns_rr_class2str(const ldns_rr_class klass)
562 buf = ldns_buffer_new(10);
563 if (ldns_rr_class2buffer_str(buf, klass) == LDNS_STATUS_OK) {
564 str = ldns_buffer2str(buf);
566 ldns_buffer_free(buf);
571 ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
573 /* we could do checking (ie degrees < 90 etc)? */
574 uint8_t version = ldns_rdf_data(rdf)[0];
576 uint8_t horizontal_precision;
577 uint8_t vertical_precision;
587 uint32_t equator = (uint32_t) ldns_power(2, 31);
590 size = ldns_rdf_data(rdf)[1];
591 horizontal_precision = ldns_rdf_data(rdf)[2];
592 vertical_precision = ldns_rdf_data(rdf)[3];
594 latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]);
595 longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]);
596 altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]);
598 if (latitude > equator) {
600 latitude = latitude - equator;
603 latitude = equator - latitude;
605 h = latitude / (1000 * 60 * 60);
606 latitude = latitude % (1000 * 60 * 60);
607 m = latitude / (1000 * 60);
608 latitude = latitude % (1000 * 60);
609 s = (double) latitude / 1000.0;
610 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
611 h, m, s, northerness);
613 if (longitude > equator) {
615 longitude = longitude - equator;
618 longitude = equator - longitude;
620 h = longitude / (1000 * 60 * 60);
621 longitude = longitude % (1000 * 60 * 60);
622 m = longitude / (1000 * 60);
623 longitude = longitude % (1000 * 60);
624 s = (double) longitude / (1000.0);
625 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
626 h, m, s, easterness);
629 s = ((double) altitude) / 100;
632 if(altitude%100 != 0)
633 ldns_buffer_printf(output, "%.2f", s);
635 ldns_buffer_printf(output, "%.0f", s);
637 ldns_buffer_printf(output, "m ");
639 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
640 ldns_buffer_printf(output, "m ");
642 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
643 horizontal_precision & 0x0f);
644 ldns_buffer_printf(output, "m ");
646 loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
647 vertical_precision & 0x0f);
648 ldns_buffer_printf(output, "m");
650 return ldns_buffer_status(output);
652 return ldns_rdf2buffer_str_hex(output, rdf);
657 ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
659 ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
660 return ldns_rdf2buffer_str_hex(output, rdf);
664 ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
666 ldns_buffer_printf(output, "0x");
667 return ldns_rdf2buffer_str_hex(output, rdf);
671 ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf)
673 return ldns_rdf2buffer_str_hex(output, rdf);
677 ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
679 /* protocol, followed by bitmap of services */
680 struct protoent *protocol;
681 char *proto_name = NULL;
683 struct servent *service;
684 uint16_t current_service;
686 protocol_nr = ldns_rdf_data(rdf)[0];
687 protocol = getprotobynumber((int) protocol_nr);
688 if (protocol && (protocol->p_name != NULL)) {
689 proto_name = protocol->p_name;
690 ldns_buffer_printf(output, "%s ", protocol->p_name);
692 ldns_buffer_printf(output, "%u ", protocol_nr);
695 #ifdef HAVE_ENDPROTOENT
699 for (current_service = 0;
700 current_service < ldns_rdf_size(rdf) * 7; current_service++) {
701 if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) {
702 service = getservbyport((int) htons(current_service),
704 if (service && service->s_name) {
705 ldns_buffer_printf(output, "%s ", service->s_name);
707 ldns_buffer_printf(output, "%u ", current_service);
709 #ifdef HAVE_ENDSERVENT
714 return ldns_buffer_status(output);
718 ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
720 /* Note: this code is duplicated in higher.c in
721 * ldns_nsec_type_check() function
723 uint8_t window_block_nr;
724 uint8_t bitmap_length;
728 uint8_t *data = ldns_rdf_data(rdf);
729 const ldns_rr_descriptor *descriptor;
731 while(pos < ldns_rdf_size(rdf)) {
732 window_block_nr = data[pos];
733 bitmap_length = data[pos + 1];
736 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
737 if (ldns_get_bit(&data[pos], bit_pos)) {
738 type = 256 * (uint16_t) window_block_nr + bit_pos;
739 descriptor = ldns_rr_descript(type);
741 if (descriptor && descriptor->_name) {
742 ldns_buffer_printf(output, "%s ",
745 ldns_buffer_printf(output, "TYPE%u ", type);
750 pos += (uint16_t) bitmap_length;
753 return ldns_buffer_status(output);
757 ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf)
762 uint8_t *data = ldns_rdf_data(rdf);
764 salt_length = data[0];
765 /* from now there are variable length entries so remember pos */
766 if (salt_length == 0 || ((size_t)salt_length)+1 > ldns_rdf_size(rdf)) {
767 ldns_buffer_printf(output, "- ");
769 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) {
770 ldns_buffer_printf(output, "%02x", data[1 + salt_pos]);
772 ldns_buffer_printf(output, " ");
775 return ldns_buffer_status(output);
779 ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
781 /* period is the number of seconds */
782 uint32_t p = ldns_read_uint32(ldns_rdf_data(rdf));
783 ldns_buffer_printf(output, "%u", p);
784 return ldns_buffer_status(output);
788 ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf)
790 /* tsigtime is 48 bits network order unsigned integer */
791 uint64_t tsigtime = 0;
792 uint8_t *data = ldns_rdf_data(rdf);
794 if (ldns_rdf_size(rdf) != 6) {
795 return LDNS_STATUS_ERR;
798 tsigtime = ldns_read_uint16(data);
800 tsigtime += ldns_read_uint16(data+2);
803 ldns_buffer_printf(output, "%llu ", tsigtime);
805 return ldns_buffer_status(output);
809 ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
811 uint8_t *data = ldns_rdf_data(rdf);
812 uint16_t address_family;
817 unsigned int pos = 0;
819 while (pos < (unsigned int) ldns_rdf_size(rdf)) {
820 if(pos + 3 >= ldns_rdf_size(rdf))
821 return LDNS_STATUS_SYNTAX_RDATA_ERR;
822 address_family = ldns_read_uint16(&data[pos]);
823 prefix = data[pos + 2];
824 negation = data[pos + 3] & LDNS_APL_NEGATION;
825 adf_length = data[pos + 3] & LDNS_APL_MASK;
826 if (address_family == LDNS_APL_IP4) {
827 /* check if prefix < 32? */
829 ldns_buffer_printf(output, "!");
831 ldns_buffer_printf(output, "%u:", address_family);
832 /* address is variable length 0 - 4 */
833 for (i = 0; i < 4; i++) {
835 ldns_buffer_printf(output, ".");
837 if (i < (unsigned short) adf_length) {
838 if(pos+i+4 >= ldns_rdf_size(rdf))
839 return LDNS_STATUS_SYNTAX_RDATA_ERR;
840 ldns_buffer_printf(output, "%d",
843 ldns_buffer_printf(output, "0");
846 ldns_buffer_printf(output, "/%u ", prefix);
847 } else if (address_family == LDNS_APL_IP6) {
848 /* check if prefix < 128? */
850 ldns_buffer_printf(output, "!");
852 ldns_buffer_printf(output, "%u:", address_family);
853 /* address is variable length 0 - 16 */
854 for (i = 0; i < 16; i++) {
855 if (i % 2 == 0 && i > 0) {
856 ldns_buffer_printf(output, ":");
858 if (i < (unsigned short) adf_length) {
859 if(pos+i+4 >= ldns_rdf_size(rdf))
860 return LDNS_STATUS_SYNTAX_RDATA_ERR;
861 ldns_buffer_printf(output, "%02x",
864 ldns_buffer_printf(output, "00");
867 ldns_buffer_printf(output, "/%u ", prefix);
870 /* unknown address family */
871 ldns_buffer_printf(output, "Unknown address family: %u data: ",
873 for (i = 1; i < (unsigned short) (4 + adf_length); i++) {
874 if(pos+i >= ldns_rdf_size(rdf))
875 return LDNS_STATUS_SYNTAX_RDATA_ERR;
876 ldns_buffer_printf(output, "%02x", data[i]);
879 pos += 4 + adf_length;
881 return ldns_buffer_status(output);
885 ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
887 /* Subtract the size (2) of the number that specifies the length */
888 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
889 char *b64 = LDNS_XMALLOC(char, size);
891 ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
893 if (ldns_rdf_size(rdf) > 2 &&
894 ldns_b64_ntop(ldns_rdf_data(rdf) + 2,
895 ldns_rdf_size(rdf) - 2,
897 ldns_buffer_printf(output, "%s", b64);
900 return ldns_buffer_status(output);
904 ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
907 http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt
909 uint8_t *data = ldns_rdf_data(rdf);
911 uint8_t gateway_type;
914 ldns_rdf *gateway = NULL;
915 uint8_t *gateway_data;
917 size_t public_key_size;
918 uint8_t *public_key_data;
919 ldns_rdf *public_key;
924 precedence = data[0];
925 gateway_type = data[1];
929 switch (gateway_type) {
934 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
935 memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
936 gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, LDNS_IP4ADDRLEN , gateway_data);
937 offset += LDNS_IP4ADDRLEN;
940 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
941 memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
942 offset += LDNS_IP6ADDRLEN;
944 ldns_rdf_new(LDNS_RDF_TYPE_AAAA, LDNS_IP6ADDRLEN, gateway_data);
947 status = ldns_wire2dname(&gateway, data, ldns_rdf_size(rdf), &offset);
948 if(status != LDNS_STATUS_OK)
956 public_key_size = ldns_rdf_size(rdf) - offset;
957 public_key_data = LDNS_XMALLOC(uint8_t, public_key_size);
958 memcpy(public_key_data, &data[offset], public_key_size);
959 public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, public_key_size, public_key_data);
961 ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm);
963 (void) ldns_rdf2buffer_str(output, gateway);
965 ldns_buffer_printf(output, ".");
966 ldns_buffer_printf(output, " ");
967 (void) ldns_rdf2buffer_str(output, public_key);
969 ldns_rdf_free(gateway);
970 ldns_rdf_free(public_key);
972 return ldns_buffer_status(output);
976 ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf)
978 /* TSIG RRs have no presentation format, make them #size <data> */
979 return ldns_rdf2buffer_str_unknown(output, rdf);
984 ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
986 ldns_status res = LDNS_STATUS_OK;
988 /*ldns_buffer_printf(buffer, "%u:", ldns_rdf_get_type(rdf));*/
990 switch(ldns_rdf_get_type(rdf)) {
991 case LDNS_RDF_TYPE_NONE:
993 case LDNS_RDF_TYPE_DNAME:
994 res = ldns_rdf2buffer_str_dname(buffer, rdf);
996 case LDNS_RDF_TYPE_INT8:
997 res = ldns_rdf2buffer_str_int8(buffer, rdf);
999 case LDNS_RDF_TYPE_INT16:
1000 res = ldns_rdf2buffer_str_int16(buffer, rdf);
1002 case LDNS_RDF_TYPE_INT32:
1003 res = ldns_rdf2buffer_str_int32(buffer, rdf);
1005 case LDNS_RDF_TYPE_PERIOD:
1006 res = ldns_rdf2buffer_str_period(buffer, rdf);
1008 case LDNS_RDF_TYPE_TSIGTIME:
1009 res = ldns_rdf2buffer_str_tsigtime(buffer, rdf);
1011 case LDNS_RDF_TYPE_A:
1012 res = ldns_rdf2buffer_str_a(buffer, rdf);
1014 case LDNS_RDF_TYPE_AAAA:
1015 res = ldns_rdf2buffer_str_aaaa(buffer, rdf);
1017 case LDNS_RDF_TYPE_STR:
1018 res = ldns_rdf2buffer_str_str(buffer, rdf);
1020 case LDNS_RDF_TYPE_APL:
1021 res = ldns_rdf2buffer_str_apl(buffer, rdf);
1023 case LDNS_RDF_TYPE_B32_EXT:
1024 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1026 case LDNS_RDF_TYPE_B64:
1027 res = ldns_rdf2buffer_str_b64(buffer, rdf);
1029 case LDNS_RDF_TYPE_HEX:
1030 res = ldns_rdf2buffer_str_hex(buffer, rdf);
1032 case LDNS_RDF_TYPE_NSEC:
1033 res = ldns_rdf2buffer_str_nsec(buffer, rdf);
1035 case LDNS_RDF_TYPE_NSEC3_SALT:
1036 res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf);
1038 case LDNS_RDF_TYPE_TYPE:
1039 res = ldns_rdf2buffer_str_type(buffer, rdf);
1041 case LDNS_RDF_TYPE_CLASS:
1042 res = ldns_rdf2buffer_str_class(buffer, rdf);
1044 case LDNS_RDF_TYPE_CERT_ALG:
1045 res = ldns_rdf2buffer_str_cert_alg(buffer, rdf);
1047 case LDNS_RDF_TYPE_ALG:
1048 res = ldns_rdf2buffer_str_alg(buffer, rdf);
1050 case LDNS_RDF_TYPE_UNKNOWN:
1051 res = ldns_rdf2buffer_str_unknown(buffer, rdf);
1053 case LDNS_RDF_TYPE_TIME:
1054 res = ldns_rdf2buffer_str_time(buffer, rdf);
1056 case LDNS_RDF_TYPE_LOC:
1057 res = ldns_rdf2buffer_str_loc(buffer, rdf);
1059 case LDNS_RDF_TYPE_WKS:
1060 case LDNS_RDF_TYPE_SERVICE:
1061 res = ldns_rdf2buffer_str_wks(buffer, rdf);
1063 case LDNS_RDF_TYPE_NSAP:
1064 res = ldns_rdf2buffer_str_nsap(buffer, rdf);
1066 case LDNS_RDF_TYPE_ATMA:
1067 res = ldns_rdf2buffer_str_atma(buffer, rdf);
1069 case LDNS_RDF_TYPE_IPSECKEY:
1070 res = ldns_rdf2buffer_str_ipseckey(buffer, rdf);
1072 case LDNS_RDF_TYPE_TSIG:
1073 res = ldns_rdf2buffer_str_tsig(buffer, rdf);
1075 case LDNS_RDF_TYPE_INT16_DATA:
1076 res = ldns_rdf2buffer_str_int16_data(buffer, rdf);
1078 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
1079 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1083 ldns_buffer_printf(buffer, "(null) ");
1084 res = ldns_buffer_status(buffer);
1090 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
1093 ldns_status status = LDNS_STATUS_OK;
1095 ldns_buffer_printf(output, "(null)\n");
1097 if (ldns_rr_owner(rr)) {
1098 status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr));
1100 if (status != LDNS_STATUS_OK) {
1104 /* TTL should NOT be printed if it is a question */
1105 if (!ldns_rr_is_question(rr)) {
1106 ldns_buffer_printf(output, "\t%d", ldns_rr_ttl(rr));
1109 ldns_buffer_printf(output, "\t");
1110 status = ldns_rr_class2buffer_str(output, ldns_rr_get_class(rr));
1111 if (status != LDNS_STATUS_OK) {
1114 ldns_buffer_printf(output, "\t");
1116 status = ldns_rr_type2buffer_str(output, ldns_rr_get_type(rr));
1117 if (status != LDNS_STATUS_OK) {
1121 if (ldns_rr_rd_count(rr) > 0) {
1122 ldns_buffer_printf(output, "\t");
1123 } else if (!ldns_rr_is_question(rr)) {
1124 ldns_buffer_printf(output, "\t\\# 0");
1127 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1128 status = ldns_rdf2buffer_str(output, ldns_rr_rdf(rr, i));
1129 if(status != LDNS_STATUS_OK)
1131 if (i < ldns_rr_rd_count(rr) - 1) {
1132 ldns_buffer_printf(output, " ");
1135 /* per RR special comments - handy for DNSSEC types */
1136 /* check to prevent question sec. rr from
1138 if (ldns_rr_rd_count(rr) > 0) {
1139 switch (ldns_rr_get_type(rr)) {
1140 case LDNS_RR_TYPE_DNSKEY:
1141 if (ldns_rr_rdf(rr, 0)) {
1142 flags = ldns_rdf2native_int16(ldns_rr_rdf(rr, 0));
1143 if (flags == 256 || flags == 384) {
1144 ldns_buffer_printf(output,
1145 " ;{id = %d (zsk), size = %db}",
1146 ldns_calc_keytag(rr),
1147 ldns_rr_dnskey_key_size(rr));
1150 if (flags == 257 || flags == 385) {
1151 ldns_buffer_printf(output,
1152 " ;{id = %d (ksk), size = %db}",
1153 ldns_calc_keytag(rr),
1154 ldns_rr_dnskey_key_size(rr));
1157 ldns_buffer_printf(output, " ;{id = %d, size = %db}",
1158 ldns_calc_keytag(rr),
1159 ldns_rr_dnskey_key_size(rr));
1162 case LDNS_RR_TYPE_RRSIG:
1163 ldns_buffer_printf(output, " ;{id = %d}",
1164 ldns_rdf2native_int16(ldns_rr_rdf(rr, 6)));
1166 case LDNS_RR_TYPE_DS:
1168 uint8_t *data = ldns_rdf_data(ldns_rr_rdf(rr, 3));
1169 size_t len = ldns_rdf_size(ldns_rr_rdf(rr, 3));
1170 char *babble = ldns_bubblebabble(data, len);
1172 ldns_buffer_printf(output, " ; %s", babble);
1176 case LDNS_RR_TYPE_NSEC3:
1177 if (ldns_nsec3_optout(rr)) {
1178 ldns_buffer_printf(output, " ; flags: optout");
1187 ldns_buffer_printf(output, "\n");
1189 return ldns_buffer_status(output);
1193 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
1197 for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
1198 (void) ldns_rr2buffer_str(output, ldns_rr_list_rr(list, i));
1200 return ldns_buffer_status(output);
1204 ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
1206 ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
1207 (int) ldns_pkt_get_opcode(pkt));
1208 ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes,
1209 (int) ldns_pkt_get_rcode(pkt));
1211 ldns_buffer_printf(output, ";; ->>HEADER<<- ");
1213 ldns_buffer_printf(output, "opcode: %s, ", opcode->name);
1215 ldns_buffer_printf(output, "opcode: ?? (%u), ",
1216 ldns_pkt_get_opcode(pkt));
1219 ldns_buffer_printf(output, "rcode: %s, ", rcode->name);
1221 ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt));
1223 ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt));
1224 ldns_buffer_printf(output, ";; flags: ");
1226 if (ldns_pkt_qr(pkt)) {
1227 ldns_buffer_printf(output, "qr ");
1229 if (ldns_pkt_aa(pkt)) {
1230 ldns_buffer_printf(output, "aa ");
1232 if (ldns_pkt_tc(pkt)) {
1233 ldns_buffer_printf(output, "tc ");
1235 if (ldns_pkt_rd(pkt)) {
1236 ldns_buffer_printf(output, "rd ");
1238 if (ldns_pkt_cd(pkt)) {
1239 ldns_buffer_printf(output, "cd ");
1241 if (ldns_pkt_ra(pkt)) {
1242 ldns_buffer_printf(output, "ra ");
1244 if (ldns_pkt_ad(pkt)) {
1245 ldns_buffer_printf(output, "ad ");
1247 ldns_buffer_printf(output, "; ");
1248 ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt));
1249 ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt));
1250 ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt));
1251 ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt));
1252 return ldns_buffer_status(output);
1256 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
1259 ldns_status status = LDNS_STATUS_OK;
1261 struct timeval time;
1265 ldns_buffer_printf(output, "null");
1266 return LDNS_STATUS_OK;
1269 if (ldns_buffer_status_ok(output)) {
1270 status = ldns_pktheader2buffer_str(output, pkt);
1271 if (status != LDNS_STATUS_OK) {
1275 ldns_buffer_printf(output, "\n");
1277 ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
1280 for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
1281 status = ldns_rr2buffer_str(output,
1282 ldns_rr_list_rr(ldns_pkt_question(pkt), i));
1283 if (status != LDNS_STATUS_OK) {
1287 ldns_buffer_printf(output, "\n");
1289 ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
1290 for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
1291 status = ldns_rr2buffer_str(output,
1292 ldns_rr_list_rr(ldns_pkt_answer(pkt), i));
1293 if (status != LDNS_STATUS_OK) {
1298 ldns_buffer_printf(output, "\n");
1300 ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
1302 for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
1303 status = ldns_rr2buffer_str(output,
1304 ldns_rr_list_rr(ldns_pkt_authority(pkt), i));
1305 if (status != LDNS_STATUS_OK) {
1309 ldns_buffer_printf(output, "\n");
1311 ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
1312 for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
1313 status = ldns_rr2buffer_str(output,
1314 ldns_rr_list_rr(ldns_pkt_additional(pkt), i));
1315 if (status != LDNS_STATUS_OK) {
1320 ldns_buffer_printf(output, "\n");
1321 /* add some futher fields */
1322 ldns_buffer_printf(output, ";; Query time: %d msec\n",
1323 ldns_pkt_querytime(pkt));
1324 if (ldns_pkt_edns(pkt)) {
1325 ldns_buffer_printf(output,
1326 ";; EDNS: version %u; flags:",
1327 ldns_pkt_edns_version(pkt));
1328 if (ldns_pkt_edns_do(pkt)) {
1329 ldns_buffer_printf(output, " do");
1331 /* the extended rcode is the value set, shifted four bits,
1332 * and or'd with the original rcode */
1333 if (ldns_pkt_edns_extended_rcode(pkt)) {
1334 ldns_buffer_printf(output, " ; ext-rcode: %d",
1335 (ldns_pkt_edns_extended_rcode(pkt) << 4 | ldns_pkt_get_rcode(pkt)));
1337 ldns_buffer_printf(output, " ; udp: %u\n",
1338 ldns_pkt_edns_udp_size(pkt));
1340 if (ldns_pkt_edns_data(pkt)) {
1341 ldns_buffer_printf(output, ";; Data: ");
1342 (void)ldns_rdf2buffer_str(output,
1343 ldns_pkt_edns_data(pkt));
1344 ldns_buffer_printf(output, "\n");
1347 if (ldns_pkt_tsig(pkt)) {
1348 ldns_buffer_printf(output, ";; TSIG:\n;; ");
1349 (void) ldns_rr2buffer_str(output, ldns_pkt_tsig(pkt));
1350 ldns_buffer_printf(output, "\n");
1352 if (ldns_pkt_answerfrom(pkt)) {
1353 tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
1354 ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
1357 time = ldns_pkt_timestamp(pkt);
1358 time_tt = (time_t)time.tv_sec;
1359 ldns_buffer_printf(output, ";; WHEN: %s",
1360 (char*)ctime(&time_tt));
1362 ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n",
1363 (int)ldns_pkt_size(pkt));
1365 return ldns_buffer_status(output);
1372 ldns_hmac_key2buffer_str(ldns_buffer *output, const ldns_key *k)
1376 ldns_rdf *b64_bignum;
1378 ldns_buffer_printf(output, "Key: ");
1380 i = ldns_key_hmac_size(k);
1381 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k));
1382 status = ldns_rdf2buffer_str(output, b64_bignum);
1383 ldns_rdf_deep_free(b64_bignum);
1384 ldns_buffer_printf(output, "\n");
1389 #if defined(HAVE_SSL) && defined(USE_GOST)
1391 ldns_gost_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
1393 unsigned char* pp = NULL;
1395 ldns_rdf *b64_bignum;
1398 ldns_buffer_printf(output, "GostAsn1: ");
1400 ret = i2d_PrivateKey(p, &pp);
1401 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, ret, pp);
1402 status = ldns_rdf2buffer_str(output, b64_bignum);
1404 ldns_rdf_deep_free(b64_bignum);
1406 ldns_buffer_printf(output, "\n");
1412 ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
1414 ldns_status status = LDNS_STATUS_OK;
1415 unsigned char *bignum;
1418 /* not used when ssl is not defined */
1419 ldns_rdf *b64_bignum = NULL;
1424 #endif /* HAVE_SSL */
1427 return LDNS_STATUS_ERR;
1430 bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
1432 return LDNS_STATUS_ERR;
1435 if (ldns_buffer_status_ok(output)) {
1437 switch(ldns_key_algorithm(k)) {
1438 case LDNS_SIGN_RSASHA1:
1439 case LDNS_SIGN_RSASHA1_NSEC3:
1440 case LDNS_SIGN_RSASHA256:
1441 case LDNS_SIGN_RSASHA512:
1442 case LDNS_SIGN_RSAMD5:
1443 /* copied by looking at dnssec-keygen output */
1445 rsa = ldns_key_rsa_key(k);
1447 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
1448 switch(ldns_key_algorithm(k)) {
1449 case LDNS_SIGN_RSAMD5:
1450 ldns_buffer_printf(output,
1451 "Algorithm: %u (RSA)\n",
1454 case LDNS_SIGN_RSASHA1:
1455 ldns_buffer_printf(output,
1456 "Algorithm: %u (RSASHA1)\n",
1459 case LDNS_SIGN_RSASHA1_NSEC3:
1460 ldns_buffer_printf(output,
1461 "Algorithm: %u (RSASHA1_NSEC3)\n",
1462 LDNS_RSASHA1_NSEC3);
1465 case LDNS_SIGN_RSASHA256:
1466 ldns_buffer_printf(output,
1467 "Algorithm: %u (RSASHA256)\n",
1470 case LDNS_SIGN_RSASHA512:
1471 ldns_buffer_printf(output,
1472 "Algorithm: %u (RSASHA512)\n",
1477 fprintf(stderr, "Warning: unknown signature ");
1479 "algorithm type %u\n",
1480 ldns_key_algorithm(k));
1481 ldns_buffer_printf(output,
1482 "Algorithm: %u (Unknown)\n",
1483 ldns_key_algorithm(k));
1487 /* print to buf, convert to bin, convert to b64,
1489 ldns_buffer_printf(output, "Modulus: ");
1490 i = (uint16_t)BN_bn2bin(rsa->n, bignum);
1491 if (i > LDNS_MAX_KEYLEN) {
1494 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1495 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1498 ldns_rdf_deep_free(b64_bignum);
1499 ldns_buffer_printf(output, "\n");
1500 ldns_buffer_printf(output, "PublicExponent: ");
1501 i = (uint16_t)BN_bn2bin(rsa->e, bignum);
1502 if (i > LDNS_MAX_KEYLEN) {
1505 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1506 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1509 ldns_rdf_deep_free(b64_bignum);
1510 ldns_buffer_printf(output, "\n");
1512 ldns_buffer_printf(output, "PrivateExponent: ");
1514 i = (uint16_t)BN_bn2bin(rsa->d, bignum);
1515 if (i > LDNS_MAX_KEYLEN) {
1518 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1519 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1522 ldns_rdf_deep_free(b64_bignum);
1523 ldns_buffer_printf(output, "\n");
1525 ldns_buffer_printf(output, "(Not available)\n");
1528 ldns_buffer_printf(output, "Prime1: ");
1530 i = (uint16_t)BN_bn2bin(rsa->p, bignum);
1531 if (i > LDNS_MAX_KEYLEN) {
1534 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1535 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1538 ldns_rdf_deep_free(b64_bignum);
1539 ldns_buffer_printf(output, "\n");
1541 ldns_buffer_printf(output, "(Not available)\n");
1544 ldns_buffer_printf(output, "Prime2: ");
1546 i = (uint16_t)BN_bn2bin(rsa->q, bignum);
1547 if (i > LDNS_MAX_KEYLEN) {
1550 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1551 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1554 ldns_rdf_deep_free(b64_bignum);
1555 ldns_buffer_printf(output, "\n");
1557 ldns_buffer_printf(output, "(Not available)\n");
1560 ldns_buffer_printf(output, "Exponent1: ");
1562 i = (uint16_t)BN_bn2bin(rsa->dmp1, bignum);
1563 if (i > LDNS_MAX_KEYLEN) {
1566 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1567 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1570 ldns_rdf_deep_free(b64_bignum);
1571 ldns_buffer_printf(output, "\n");
1573 ldns_buffer_printf(output, "(Not available)\n");
1576 ldns_buffer_printf(output, "Exponent2: ");
1578 i = (uint16_t)BN_bn2bin(rsa->dmq1, bignum);
1579 if (i > LDNS_MAX_KEYLEN) {
1582 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1583 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1586 ldns_rdf_deep_free(b64_bignum);
1587 ldns_buffer_printf(output, "\n");
1589 ldns_buffer_printf(output, "(Not available)\n");
1592 ldns_buffer_printf(output, "Coefficient: ");
1594 i = (uint16_t)BN_bn2bin(rsa->iqmp, bignum);
1595 if (i > LDNS_MAX_KEYLEN) {
1598 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1599 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1602 ldns_rdf_deep_free(b64_bignum);
1603 ldns_buffer_printf(output, "\n");
1605 ldns_buffer_printf(output, "(Not available)\n");
1611 case LDNS_SIGN_DSA_NSEC3:
1612 dsa = ldns_key_dsa_key(k);
1614 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
1615 if (ldns_key_algorithm(k) == LDNS_SIGN_DSA) {
1616 ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n");
1617 } else if (ldns_key_algorithm(k) == LDNS_SIGN_DSA_NSEC3) {
1618 ldns_buffer_printf(output,"Algorithm: 6 (DSA_NSEC3)\n");
1621 /* print to buf, convert to bin, convert to b64,
1623 ldns_buffer_printf(output, "Prime(p): ");
1625 i = (uint16_t)BN_bn2bin(dsa->p, bignum);
1626 if (i > LDNS_MAX_KEYLEN) {
1629 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1630 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1633 ldns_rdf_deep_free(b64_bignum);
1634 ldns_buffer_printf(output, "\n");
1636 printf("(Not available)\n");
1639 ldns_buffer_printf(output, "Subprime(q): ");
1641 i = (uint16_t)BN_bn2bin(dsa->q, bignum);
1642 if (i > LDNS_MAX_KEYLEN) {
1645 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1646 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1649 ldns_rdf_deep_free(b64_bignum);
1650 ldns_buffer_printf(output, "\n");
1652 printf("(Not available)\n");
1655 ldns_buffer_printf(output, "Base(g): ");
1657 i = (uint16_t)BN_bn2bin(dsa->g, bignum);
1658 if (i > LDNS_MAX_KEYLEN) {
1661 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1662 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1665 ldns_rdf_deep_free(b64_bignum);
1666 ldns_buffer_printf(output, "\n");
1668 printf("(Not available)\n");
1671 ldns_buffer_printf(output, "Private_value(x): ");
1672 if (dsa->priv_key) {
1673 i = (uint16_t)BN_bn2bin(dsa->priv_key, bignum);
1674 if (i > LDNS_MAX_KEYLEN) {
1677 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1678 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1681 ldns_rdf_deep_free(b64_bignum);
1682 ldns_buffer_printf(output, "\n");
1684 printf("(Not available)\n");
1687 ldns_buffer_printf(output, "Public_value(y): ");
1689 i = (uint16_t)BN_bn2bin(dsa->pub_key, bignum);
1690 if (i > LDNS_MAX_KEYLEN) {
1693 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1694 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1697 ldns_rdf_deep_free(b64_bignum);
1698 ldns_buffer_printf(output, "\n");
1700 printf("(Not available)\n");
1703 case LDNS_SIGN_ECC_GOST:
1704 /* no format defined, use blob */
1705 #if defined(HAVE_SSL) && defined(USE_GOST)
1706 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1707 ldns_buffer_printf(output, "Algorithm: %d (ECC-GOST)\n", LDNS_SIGN_ECC_GOST);
1708 status = ldns_gost_key2buffer_str(output, k->_key.key);
1712 case LDNS_SIGN_ECDSAP256SHA256:
1713 case LDNS_SIGN_ECDSAP384SHA384:
1714 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1715 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
1716 ldns_algorithm2buffer_str(output, ldns_key_algorithm(k));
1717 ldns_buffer_printf(output, ")\n");
1719 EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->_key.key);
1720 const BIGNUM* b = EC_KEY_get0_private_key(ec);
1721 ldns_buffer_printf(output, "PrivateKey: ");
1722 i = (uint16_t)BN_bn2bin(b, bignum);
1723 if (i > LDNS_MAX_KEYLEN) {
1726 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1727 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1730 ldns_rdf_deep_free(b64_bignum);
1731 ldns_buffer_printf(output, "\n");
1732 /* down reference count in EC_KEY
1733 * its still assigned to the PKEY */
1738 case LDNS_SIGN_HMACMD5:
1739 /* there's not much of a format defined for TSIG */
1740 /* It's just a binary blob, Same for all algorithms */
1741 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1742 ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n");
1743 status = ldns_hmac_key2buffer_str(output, k);
1745 case LDNS_SIGN_HMACSHA1:
1746 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1747 ldns_buffer_printf(output, "Algorithm: 158 (HMAC_SHA1)\n");
1748 status = ldns_hmac_key2buffer_str(output, k);
1750 case LDNS_SIGN_HMACSHA256:
1751 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1752 ldns_buffer_printf(output, "Algorithm: 159 (HMAC_SHA256)\n");
1753 status = ldns_hmac_key2buffer_str(output, k);
1756 #endif /* HAVE_SSL */
1759 LDNS_FREE(b64_bignum);
1762 return ldns_buffer_status(output);
1768 /* compiles warn the label isn't used */
1771 return LDNS_STATUS_ERR;
1772 #endif /* HAVE_SSL */
1777 * Zero terminate the buffer and fix it to the size of the string.
1780 ldns_buffer2str(ldns_buffer *buffer)
1785 /* check if buffer ends with \0, if not, and
1786 if there is space, add it */
1787 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
1788 if (!ldns_buffer_reserve(buffer, 1)) {
1791 ldns_buffer_write_u8(buffer, (uint8_t) '\0');
1792 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
1797 tmp_str = ldns_buffer_export(buffer);
1798 str = LDNS_XMALLOC(char, strlen(tmp_str) + 1);
1799 memcpy(str, tmp_str, strlen(tmp_str) + 1);
1805 ldns_rdf2str(const ldns_rdf *rdf)
1807 char *result = NULL;
1808 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
1810 if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
1811 /* export and return string, destroy rest */
1812 result = ldns_buffer2str(tmp_buffer);
1815 ldns_buffer_free(tmp_buffer);
1820 ldns_rr2str(const ldns_rr *rr)
1822 char *result = NULL;
1823 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
1825 if (ldns_rr2buffer_str(tmp_buffer, rr) == LDNS_STATUS_OK) {
1826 /* export and return string, destroy rest */
1827 result = ldns_buffer2str(tmp_buffer);
1829 ldns_buffer_free(tmp_buffer);
1834 ldns_pkt2str(const ldns_pkt *pkt)
1836 char *result = NULL;
1837 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
1839 if (ldns_pkt2buffer_str(tmp_buffer, pkt) == LDNS_STATUS_OK) {
1840 /* export and return string, destroy rest */
1841 result = ldns_buffer2str(tmp_buffer);
1844 ldns_buffer_free(tmp_buffer);
1849 ldns_key2str(const ldns_key *k)
1851 char *result = NULL;
1852 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
1853 if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) {
1854 /* export and return string, destroy rest */
1855 result = ldns_buffer2str(tmp_buffer);
1857 ldns_buffer_free(tmp_buffer);
1862 ldns_rr_list2str(const ldns_rr_list *list)
1864 char *result = NULL;
1865 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
1868 if (ldns_rr_list2buffer_str(tmp_buffer, list) == LDNS_STATUS_OK) {
1871 ldns_buffer_printf(tmp_buffer, "(null)\n");
1874 /* export and return string, destroy rest */
1875 result = ldns_buffer2str(tmp_buffer);
1876 ldns_buffer_free(tmp_buffer);
1881 ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
1883 char *str = ldns_rdf2str(rdf);
1885 fprintf(output, "%s", str);
1887 fprintf(output, "Unable to convert rdf to string\n");
1893 ldns_rr_print(FILE *output, const ldns_rr *rr)
1895 char *str = ldns_rr2str(rr);
1897 fprintf(output, "%s", str);
1899 fprintf(output, "Unable to convert rr to string\n");
1905 ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
1907 char *str = ldns_pkt2str(pkt);
1909 fprintf(output, "%s", str);
1911 fprintf(output, "Unable to convert packet to string\n");
1917 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
1920 for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
1921 ldns_rr_print(output, ldns_rr_list_rr(lst, i));
1926 ldns_resolver_print(FILE *output, const ldns_resolver *r)
1935 n = ldns_resolver_nameservers(r);
1936 s = ldns_resolver_searchlist(r);
1937 rtt = ldns_resolver_rtt(r);
1939 fprintf(output, "port: %d\n", (int)ldns_resolver_port(r));
1940 fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r));
1941 fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r));
1943 fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r));
1944 fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r));
1945 fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r));
1946 fprintf(output, "fail: %d\n", ldns_resolver_fail(r));
1947 fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r));
1948 fprintf(output, "retrans: %d\n", (int)ldns_resolver_retrans(r));
1949 fprintf(output, "fallback: %d\n", ldns_resolver_fallback(r));
1950 fprintf(output, "random: %d\n", ldns_resolver_random(r));
1951 fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
1952 fprintf(output, "dnssec: %d\n", ldns_resolver_dnssec(r));
1953 fprintf(output, "dnssec cd: %d\n", ldns_resolver_dnssec_cd(r));
1954 fprintf(output, "trust anchors (%d listed):\n",
1955 (int)ldns_rr_list_rr_count(ldns_resolver_dnssec_anchors(r)));
1956 ldns_rr_list_print(output, ldns_resolver_dnssec_anchors(r));
1957 fprintf(output, "tsig: %s %s\n", ldns_resolver_tsig_keyname(r), ldns_resolver_tsig_algorithm(r));
1958 fprintf(output, "debug: %d\n", ldns_resolver_debug(r));
1960 fprintf(output, "default domain: ");
1961 ldns_rdf_print(output, ldns_resolver_domain(r));
1962 fprintf(output, "\n");
1963 fprintf(output, "apply default domain: %d\n", ldns_resolver_defnames(r));
1965 fprintf(output, "searchlist (%d listed):\n", (int)ldns_resolver_searchlist_count(r));
1966 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
1967 fprintf(output, "\t");
1968 ldns_rdf_print(output, s[i]);
1969 fprintf(output, "\n");
1971 fprintf(output, "apply search list: %d\n", ldns_resolver_dnsrch(r));
1973 fprintf(output, "nameservers (%d listed):\n", (int)ldns_resolver_nameserver_count(r));
1974 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
1975 fprintf(output, "\t");
1976 ldns_rdf_print(output, n[i]);
1978 switch ((int)rtt[i]) {
1979 case LDNS_RESOLV_RTT_MIN:
1980 fprintf(output, " - reachable\n");
1982 case LDNS_RESOLV_RTT_INF:
1983 fprintf(output, " - unreachable\n");
1990 ldns_zone_print(FILE *output, const ldns_zone *z)
1992 if(ldns_zone_soa(z))
1993 ldns_rr_print(output, ldns_zone_soa(z));
1994 ldns_rr_list_print(output, ldns_zone_rrs(z));