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;
126 const ldns_output_format ldns_output_format_bubblebabble_record = {
127 LDNS_COMMENT_KEY | LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS, NULL
129 const ldns_output_format *ldns_output_format_bubblebabble
130 = &ldns_output_format_bubblebabble_record;
133 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode)
135 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode);
136 if (lt && lt->name) {
137 ldns_buffer_printf(output, "%s", lt->name);
139 ldns_buffer_printf(output, "OPCODE%u", opcode);
141 return ldns_buffer_status(output);
145 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode)
147 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode);
148 if (lt && lt->name) {
149 ldns_buffer_printf(output, "%s", lt->name);
151 ldns_buffer_printf(output, "RCODE%u", rcode);
153 return ldns_buffer_status(output);
157 ldns_algorithm2buffer_str(ldns_buffer *output,
158 ldns_algorithm algorithm)
160 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_algorithms,
162 if (lt && lt->name) {
163 ldns_buffer_printf(output, "%s", lt->name);
165 ldns_buffer_printf(output, "ALG%u", algorithm);
167 return ldns_buffer_status(output);
171 ldns_cert_algorithm2buffer_str(ldns_buffer *output,
172 ldns_cert_algorithm cert_algorithm)
174 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_cert_algorithms,
176 if (lt && lt->name) {
177 ldns_buffer_printf(output, "%s", lt->name);
179 ldns_buffer_printf(output, "CERT_ALG%u",
182 return ldns_buffer_status(output);
186 ldns_pkt_opcode2str(ldns_pkt_opcode opcode)
191 buf = ldns_buffer_new(12);
197 if (ldns_pkt_opcode2buffer_str(buf, opcode) == LDNS_STATUS_OK) {
198 str = ldns_buffer2str(buf);
201 ldns_buffer_free(buf);
206 ldns_pkt_rcode2str(ldns_pkt_rcode rcode)
211 buf = ldns_buffer_new(10);
217 if (ldns_pkt_rcode2buffer_str(buf, rcode) == LDNS_STATUS_OK) {
218 str = ldns_buffer2str(buf);
221 ldns_buffer_free(buf);
226 ldns_pkt_algorithm2str(ldns_algorithm algorithm)
231 buf = ldns_buffer_new(10);
237 if (ldns_algorithm2buffer_str(buf, algorithm)
239 str = ldns_buffer2str(buf);
242 ldns_buffer_free(buf);
247 ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm)
252 buf = ldns_buffer_new(10);
258 if (ldns_cert_algorithm2buffer_str(buf, cert_algorithm)
260 str = ldns_buffer2str(buf);
263 ldns_buffer_free(buf);
268 /* do NOT pass compressed data here :p */
270 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
272 /* can we do with 1 pos var? or without at all? */
279 data = (uint8_t*)ldns_rdf_data(dname);
282 if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) {
283 /* too large, return */
284 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
287 /* special case: root label */
288 if (1 == ldns_rdf_size(dname)) {
289 ldns_buffer_printf(output, ".");
291 while ((len > 0) && src_pos < ldns_rdf_size(dname)) {
293 for(i = 0; i < len; i++) {
294 /* paranoia check for various 'strange'
297 c = (unsigned char) data[src_pos];
298 if(c == '.' || c == ';' ||
299 c == '(' || c == ')' ||
301 ldns_buffer_printf(output, "\\%c",
303 } else if (!(isascii(c) && isgraph(c))) {
304 ldns_buffer_printf(output, "\\%03u",
307 ldns_buffer_printf(output, "%c", data[src_pos]);
312 if (src_pos < ldns_rdf_size(dname)) {
313 ldns_buffer_printf(output, ".");
318 return ldns_buffer_status(output);
322 ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
324 uint8_t data = ldns_rdf_data(rdf)[0];
325 ldns_buffer_printf(output, "%lu", (unsigned long) data);
326 return ldns_buffer_status(output);
330 ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
332 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
333 ldns_buffer_printf(output, "%lu", (unsigned long) data);
334 return ldns_buffer_status(output);
338 ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
340 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
341 ldns_buffer_printf(output, "%lu", (unsigned long) data);
342 return ldns_buffer_status(output);
346 ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
348 /* create a YYYYMMDDHHMMSS string if possible */
352 memset(&tm, 0, sizeof(tm));
353 if (ldns_serial_arithmitics_gmtime_r(ldns_rdf2native_int32(rdf), time(NULL), &tm)
354 && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
355 ldns_buffer_printf(output, "%s", date_buf);
357 return ldns_buffer_status(output);
361 ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
363 char str[INET_ADDRSTRLEN];
365 if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) {
366 ldns_buffer_printf(output, "%s", str);
368 return ldns_buffer_status(output);
372 ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
374 char str[INET6_ADDRSTRLEN];
376 if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) {
377 ldns_buffer_printf(output, "%s", str);
380 return ldns_buffer_status(output);
384 ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
386 const uint8_t *data = ldns_rdf_data(rdf);
387 uint8_t length = data[0];
390 ldns_buffer_printf(output, "\"");
391 for (i = 1; i <= length; ++i) {
392 char ch = (char) data[i];
393 if (isprint((int)ch) || ch=='\t') {
394 if (ch=='\"'||ch=='\\')
395 ldns_buffer_printf(output, "\\%c", ch);
397 ldns_buffer_printf(output, "%c", ch);
399 ldns_buffer_printf(output, "\\%03u",
400 (unsigned)(uint8_t) ch);
403 ldns_buffer_printf(output, "\"");
404 return ldns_buffer_status(output);
408 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
410 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf));
411 char *b64 = LDNS_XMALLOC(char, size);
412 if(!b64) return LDNS_STATUS_MEM_ERR;
413 if (ldns_b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) {
414 ldns_buffer_printf(output, "%s", b64);
417 return ldns_buffer_status(output);
421 ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf)
425 if(ldns_rdf_size(rdf) == 0)
426 return LDNS_STATUS_OK;
427 /* remove -1 for the b32-hash-len octet */
428 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
429 /* add one for the end nul for the string */
430 b32 = LDNS_XMALLOC(char, size + 1);
431 if(!b32) return LDNS_STATUS_MEM_ERR;
432 size = (size_t) ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
433 ldns_rdf_size(rdf) - 1, b32, size+1);
435 ldns_buffer_printf(output, "%s", b32);
438 return ldns_buffer_status(output);
442 ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
445 for (i = 0; i < ldns_rdf_size(rdf); i++) {
446 ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]);
449 return ldns_buffer_status(output);
453 ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
455 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
456 const ldns_rr_descriptor *descriptor;
458 descriptor = ldns_rr_descript(data);
459 if (descriptor && descriptor->_name) {
460 ldns_buffer_printf(output, "%s", descriptor->_name);
462 ldns_buffer_printf(output, "TYPE%u", data);
464 return ldns_buffer_status(output);
468 ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
470 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
471 ldns_lookup_table *lt;
473 lt = ldns_lookup_by_id(ldns_rr_classes, (int) data);
475 ldns_buffer_printf(output, "\t%s", lt->name);
477 ldns_buffer_printf(output, "\tCLASS%d", data);
479 return ldns_buffer_status(output);
483 ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
485 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
486 ldns_lookup_table *lt;
487 lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data);
489 ldns_buffer_printf(output, "%s", lt->name);
491 ldns_buffer_printf(output, "%d", data);
493 return ldns_buffer_status(output);
497 ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
499 /* don't use algorithm mnemonics in the presentation format
500 this kind of got sneaked into the rfc's */
501 uint8_t data = ldns_rdf_data(rdf)[0];
502 ldns_buffer_printf(output, "%d", data);
503 return ldns_buffer_status(output);
507 loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
510 /* is it 0.<two digits> ? */
514 ldns_buffer_printf(output, "0.%02ld", (long)mantissa);
517 /* always <digit><string of zeros> */
518 ldns_buffer_printf(output, "%d", (int)mantissa);
519 for(i=0; i<exponent-2; i++)
520 ldns_buffer_printf(output, "0");
524 ldns_rr_type2buffer_str(ldns_buffer *output, const ldns_rr_type type)
526 const ldns_rr_descriptor *descriptor;
528 descriptor = ldns_rr_descript(type);
530 if (descriptor && descriptor->_name) {
531 ldns_buffer_printf(output, "%s", descriptor->_name);
533 /* exceptions for pseudotypes */
535 case LDNS_RR_TYPE_IXFR:
536 ldns_buffer_printf(output, "IXFR");
538 case LDNS_RR_TYPE_AXFR:
539 ldns_buffer_printf(output, "AXFR");
541 case LDNS_RR_TYPE_MAILA:
542 ldns_buffer_printf(output, "MAILA");
544 case LDNS_RR_TYPE_MAILB:
545 ldns_buffer_printf(output, "MAILB");
547 case LDNS_RR_TYPE_ANY:
548 ldns_buffer_printf(output, "ANY");
551 ldns_buffer_printf(output, "TYPE%u", type);
554 return ldns_buffer_status(output);
558 ldns_rr_type2str(const ldns_rr_type type)
563 buf = ldns_buffer_new(10);
569 if (ldns_rr_type2buffer_str(buf, type) == LDNS_STATUS_OK) {
570 str = ldns_buffer2str(buf);
573 ldns_buffer_free(buf);
579 ldns_rr_class2buffer_str(ldns_buffer *output,
580 const ldns_rr_class klass)
582 ldns_lookup_table *lt;
584 lt = ldns_lookup_by_id(ldns_rr_classes, klass);
586 ldns_buffer_printf(output, "%s", lt->name);
588 ldns_buffer_printf(output, "CLASS%d", klass);
590 return ldns_buffer_status(output);
594 ldns_rr_class2str(const ldns_rr_class klass)
599 buf = ldns_buffer_new(10);
605 if (ldns_rr_class2buffer_str(buf, klass) == LDNS_STATUS_OK) {
606 str = ldns_buffer2str(buf);
608 ldns_buffer_free(buf);
613 ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
615 /* we could do checking (ie degrees < 90 etc)? */
616 uint8_t version = ldns_rdf_data(rdf)[0];
618 uint8_t horizontal_precision;
619 uint8_t vertical_precision;
629 uint32_t equator = (uint32_t) ldns_power(2, 31);
632 size = ldns_rdf_data(rdf)[1];
633 horizontal_precision = ldns_rdf_data(rdf)[2];
634 vertical_precision = ldns_rdf_data(rdf)[3];
636 latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]);
637 longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]);
638 altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]);
640 if (latitude > equator) {
642 latitude = latitude - equator;
645 latitude = equator - latitude;
647 h = latitude / (1000 * 60 * 60);
648 latitude = latitude % (1000 * 60 * 60);
649 m = latitude / (1000 * 60);
650 latitude = latitude % (1000 * 60);
651 s = (double) latitude / 1000.0;
652 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
653 h, m, s, northerness);
655 if (longitude > equator) {
657 longitude = longitude - equator;
660 longitude = equator - longitude;
662 h = longitude / (1000 * 60 * 60);
663 longitude = longitude % (1000 * 60 * 60);
664 m = longitude / (1000 * 60);
665 longitude = longitude % (1000 * 60);
666 s = (double) longitude / (1000.0);
667 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
668 h, m, s, easterness);
671 s = ((double) altitude) / 100;
674 if(altitude%100 != 0)
675 ldns_buffer_printf(output, "%.2f", s);
677 ldns_buffer_printf(output, "%.0f", s);
679 ldns_buffer_printf(output, "m ");
681 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
682 ldns_buffer_printf(output, "m ");
684 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
685 horizontal_precision & 0x0f);
686 ldns_buffer_printf(output, "m ");
688 loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
689 vertical_precision & 0x0f);
690 ldns_buffer_printf(output, "m");
692 return ldns_buffer_status(output);
694 return ldns_rdf2buffer_str_hex(output, rdf);
699 ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
701 ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
702 return ldns_rdf2buffer_str_hex(output, rdf);
706 ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
708 ldns_buffer_printf(output, "0x");
709 return ldns_rdf2buffer_str_hex(output, rdf);
713 ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf)
715 return ldns_rdf2buffer_str_hex(output, rdf);
719 ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
721 /* protocol, followed by bitmap of services */
722 struct protoent *protocol;
723 char *proto_name = NULL;
725 struct servent *service;
726 uint16_t current_service;
728 protocol_nr = ldns_rdf_data(rdf)[0];
729 protocol = getprotobynumber((int) protocol_nr);
730 if (protocol && (protocol->p_name != NULL)) {
731 proto_name = protocol->p_name;
732 ldns_buffer_printf(output, "%s ", protocol->p_name);
734 ldns_buffer_printf(output, "%u ", protocol_nr);
737 #ifdef HAVE_ENDPROTOENT
741 for (current_service = 0;
742 current_service < ldns_rdf_size(rdf) * 7; current_service++) {
743 if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) {
744 service = getservbyport((int) htons(current_service),
746 if (service && service->s_name) {
747 ldns_buffer_printf(output, "%s ", service->s_name);
749 ldns_buffer_printf(output, "%u ", current_service);
751 #ifdef HAVE_ENDSERVENT
756 return ldns_buffer_status(output);
760 ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
762 /* Note: this code is duplicated in higher.c in
763 * ldns_nsec_type_check() function
765 uint8_t window_block_nr;
766 uint8_t bitmap_length;
770 uint8_t *data = ldns_rdf_data(rdf);
771 const ldns_rr_descriptor *descriptor;
773 while(pos < ldns_rdf_size(rdf)) {
774 window_block_nr = data[pos];
775 bitmap_length = data[pos + 1];
778 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
779 if (ldns_get_bit(&data[pos], bit_pos)) {
780 type = 256 * (uint16_t) window_block_nr + bit_pos;
781 descriptor = ldns_rr_descript(type);
783 if (descriptor && descriptor->_name) {
784 ldns_buffer_printf(output, "%s ",
787 ldns_buffer_printf(output, "TYPE%u ", type);
792 pos += (uint16_t) bitmap_length;
795 return ldns_buffer_status(output);
799 ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf)
804 uint8_t *data = ldns_rdf_data(rdf);
806 if(ldns_rdf_size(rdf) == 0) {
807 output->_status = LDNS_STATUS_ERR;
808 return ldns_buffer_status(output);
810 salt_length = data[0];
811 /* from now there are variable length entries so remember pos */
812 if (salt_length == 0 || ((size_t)salt_length)+1 > ldns_rdf_size(rdf)) {
813 ldns_buffer_printf(output, "- ");
815 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) {
816 ldns_buffer_printf(output, "%02x", data[1 + salt_pos]);
818 ldns_buffer_printf(output, " ");
821 return ldns_buffer_status(output);
825 ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
827 /* period is the number of seconds */
828 uint32_t p = ldns_read_uint32(ldns_rdf_data(rdf));
829 ldns_buffer_printf(output, "%u", p);
830 return ldns_buffer_status(output);
834 ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf)
836 /* tsigtime is 48 bits network order unsigned integer */
837 uint64_t tsigtime = 0;
838 uint8_t *data = ldns_rdf_data(rdf);
840 if (ldns_rdf_size(rdf) != 6) {
841 return LDNS_STATUS_ERR;
844 tsigtime = ldns_read_uint16(data);
846 tsigtime += ldns_read_uint16(data+2);
849 ldns_buffer_printf(output, "%llu ", tsigtime);
851 return ldns_buffer_status(output);
855 ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
857 uint8_t *data = ldns_rdf_data(rdf);
858 uint16_t address_family;
865 while (pos < (unsigned int) ldns_rdf_size(rdf)) {
866 if(pos + 3 >= (unsigned)ldns_rdf_size(rdf))
867 return LDNS_STATUS_SYNTAX_RDATA_ERR;
868 address_family = ldns_read_uint16(&data[pos]);
869 prefix = data[pos + 2];
870 negation = data[pos + 3] & LDNS_APL_NEGATION;
871 adf_length = data[pos + 3] & LDNS_APL_MASK;
872 if (address_family == LDNS_APL_IP4) {
873 /* check if prefix < 32? */
875 ldns_buffer_printf(output, "!");
877 ldns_buffer_printf(output, "%u:", address_family);
878 /* address is variable length 0 - 4 */
879 for (i = 0; i < 4; i++) {
881 ldns_buffer_printf(output, ".");
883 if (i < (unsigned short) adf_length) {
884 if(pos+i+4 >= ldns_rdf_size(rdf))
885 return LDNS_STATUS_SYNTAX_RDATA_ERR;
886 ldns_buffer_printf(output, "%d",
889 ldns_buffer_printf(output, "0");
892 ldns_buffer_printf(output, "/%u ", prefix);
893 } else if (address_family == LDNS_APL_IP6) {
894 /* check if prefix < 128? */
896 ldns_buffer_printf(output, "!");
898 ldns_buffer_printf(output, "%u:", address_family);
899 /* address is variable length 0 - 16 */
900 for (i = 0; i < 16; i++) {
901 if (i % 2 == 0 && i > 0) {
902 ldns_buffer_printf(output, ":");
904 if (i < (unsigned short) adf_length) {
905 if(pos+i+4 >= ldns_rdf_size(rdf))
906 return LDNS_STATUS_SYNTAX_RDATA_ERR;
907 ldns_buffer_printf(output, "%02x",
910 ldns_buffer_printf(output, "00");
913 ldns_buffer_printf(output, "/%u ", prefix);
916 /* unknown address family */
917 ldns_buffer_printf(output, "Unknown address family: %u data: ",
919 for (i = 1; i < (unsigned short) (4 + adf_length); i++) {
920 if(pos+i >= ldns_rdf_size(rdf))
921 return LDNS_STATUS_SYNTAX_RDATA_ERR;
922 ldns_buffer_printf(output, "%02x", data[i]);
925 pos += 4 + adf_length;
927 return ldns_buffer_status(output);
931 ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
933 /* Subtract the size (2) of the number that specifies the length */
934 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
935 char *b64 = LDNS_XMALLOC(char, size);
937 return LDNS_STATUS_MEM_ERR;
939 ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
941 if (ldns_rdf_size(rdf) > 2 &&
942 ldns_b64_ntop(ldns_rdf_data(rdf) + 2,
943 ldns_rdf_size(rdf) - 2,
945 ldns_buffer_printf(output, "%s", b64);
948 return ldns_buffer_status(output);
952 ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
955 http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt
957 uint8_t *data = ldns_rdf_data(rdf);
959 uint8_t gateway_type;
962 ldns_rdf *gateway = NULL;
963 uint8_t *gateway_data;
965 size_t public_key_size;
966 uint8_t *public_key_data;
967 ldns_rdf *public_key;
972 precedence = data[0];
973 gateway_type = data[1];
977 switch (gateway_type) {
982 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
984 return LDNS_STATUS_MEM_ERR;
985 memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
986 gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, LDNS_IP4ADDRLEN , gateway_data);
987 offset += LDNS_IP4ADDRLEN;
989 LDNS_FREE(gateway_data);
990 return LDNS_STATUS_MEM_ERR;
994 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
996 return LDNS_STATUS_MEM_ERR;
997 memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
998 offset += LDNS_IP6ADDRLEN;
1000 ldns_rdf_new(LDNS_RDF_TYPE_AAAA, LDNS_IP6ADDRLEN, gateway_data);
1002 LDNS_FREE(gateway_data);
1003 return LDNS_STATUS_MEM_ERR;
1007 status = ldns_wire2dname(&gateway, data, ldns_rdf_size(rdf), &offset);
1008 if(status != LDNS_STATUS_OK)
1016 public_key_size = ldns_rdf_size(rdf) - offset;
1017 public_key_data = LDNS_XMALLOC(uint8_t, public_key_size);
1018 if(!public_key_data) {
1019 ldns_rdf_free(gateway);
1020 return LDNS_STATUS_MEM_ERR;
1022 memcpy(public_key_data, &data[offset], public_key_size);
1023 public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, public_key_size, public_key_data);
1025 LDNS_FREE(public_key_data);
1026 ldns_rdf_free(gateway);
1027 return LDNS_STATUS_MEM_ERR;
1030 ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm);
1032 (void) ldns_rdf2buffer_str(output, gateway);
1034 ldns_buffer_printf(output, ".");
1035 ldns_buffer_printf(output, " ");
1036 (void) ldns_rdf2buffer_str(output, public_key);
1038 ldns_rdf_free(gateway);
1039 ldns_rdf_free(public_key);
1041 return ldns_buffer_status(output);
1045 ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf)
1047 /* TSIG RRs have no presentation format, make them #size <data> */
1048 return ldns_rdf2buffer_str_unknown(output, rdf);
1053 ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
1055 ldns_status res = LDNS_STATUS_OK;
1057 /*ldns_buffer_printf(buffer, "%u:", ldns_rdf_get_type(rdf));*/
1059 switch(ldns_rdf_get_type(rdf)) {
1060 case LDNS_RDF_TYPE_NONE:
1062 case LDNS_RDF_TYPE_DNAME:
1063 res = ldns_rdf2buffer_str_dname(buffer, rdf);
1065 case LDNS_RDF_TYPE_INT8:
1066 res = ldns_rdf2buffer_str_int8(buffer, rdf);
1068 case LDNS_RDF_TYPE_INT16:
1069 res = ldns_rdf2buffer_str_int16(buffer, rdf);
1071 case LDNS_RDF_TYPE_INT32:
1072 res = ldns_rdf2buffer_str_int32(buffer, rdf);
1074 case LDNS_RDF_TYPE_PERIOD:
1075 res = ldns_rdf2buffer_str_period(buffer, rdf);
1077 case LDNS_RDF_TYPE_TSIGTIME:
1078 res = ldns_rdf2buffer_str_tsigtime(buffer, rdf);
1080 case LDNS_RDF_TYPE_A:
1081 res = ldns_rdf2buffer_str_a(buffer, rdf);
1083 case LDNS_RDF_TYPE_AAAA:
1084 res = ldns_rdf2buffer_str_aaaa(buffer, rdf);
1086 case LDNS_RDF_TYPE_STR:
1087 res = ldns_rdf2buffer_str_str(buffer, rdf);
1089 case LDNS_RDF_TYPE_APL:
1090 res = ldns_rdf2buffer_str_apl(buffer, rdf);
1092 case LDNS_RDF_TYPE_B32_EXT:
1093 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1095 case LDNS_RDF_TYPE_B64:
1096 res = ldns_rdf2buffer_str_b64(buffer, rdf);
1098 case LDNS_RDF_TYPE_HEX:
1099 res = ldns_rdf2buffer_str_hex(buffer, rdf);
1101 case LDNS_RDF_TYPE_NSEC:
1102 res = ldns_rdf2buffer_str_nsec(buffer, rdf);
1104 case LDNS_RDF_TYPE_NSEC3_SALT:
1105 res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf);
1107 case LDNS_RDF_TYPE_TYPE:
1108 res = ldns_rdf2buffer_str_type(buffer, rdf);
1110 case LDNS_RDF_TYPE_CLASS:
1111 res = ldns_rdf2buffer_str_class(buffer, rdf);
1113 case LDNS_RDF_TYPE_CERT_ALG:
1114 res = ldns_rdf2buffer_str_cert_alg(buffer, rdf);
1116 case LDNS_RDF_TYPE_ALG:
1117 res = ldns_rdf2buffer_str_alg(buffer, rdf);
1119 case LDNS_RDF_TYPE_UNKNOWN:
1120 res = ldns_rdf2buffer_str_unknown(buffer, rdf);
1122 case LDNS_RDF_TYPE_TIME:
1123 res = ldns_rdf2buffer_str_time(buffer, rdf);
1125 case LDNS_RDF_TYPE_LOC:
1126 res = ldns_rdf2buffer_str_loc(buffer, rdf);
1128 case LDNS_RDF_TYPE_WKS:
1129 case LDNS_RDF_TYPE_SERVICE:
1130 res = ldns_rdf2buffer_str_wks(buffer, rdf);
1132 case LDNS_RDF_TYPE_NSAP:
1133 res = ldns_rdf2buffer_str_nsap(buffer, rdf);
1135 case LDNS_RDF_TYPE_ATMA:
1136 res = ldns_rdf2buffer_str_atma(buffer, rdf);
1138 case LDNS_RDF_TYPE_IPSECKEY:
1139 res = ldns_rdf2buffer_str_ipseckey(buffer, rdf);
1141 case LDNS_RDF_TYPE_TSIG:
1142 res = ldns_rdf2buffer_str_tsig(buffer, rdf);
1144 case LDNS_RDF_TYPE_INT16_DATA:
1145 res = ldns_rdf2buffer_str_int16_data(buffer, rdf);
1147 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
1148 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1152 ldns_buffer_printf(buffer, "(null) ");
1153 res = ldns_buffer_status(buffer);
1159 ldns_b32_ext2dname(const ldns_rdf *rdf)
1164 if(ldns_rdf_size(rdf) == 0)
1166 /* remove -1 for the b32-hash-len octet */
1167 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
1168 /* add one for the end nul for the string */
1169 b32 = LDNS_XMALLOC(char, size + 2);
1171 if (ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
1172 ldns_rdf_size(rdf) - 1, b32, size+1) > 0) {
1175 if (ldns_str2rdf_dname(&out, b32) == LDNS_STATUS_OK) {
1186 ldns_rr2buffer_str_fmt(ldns_buffer *output,
1187 const ldns_output_format *fmt, const ldns_rr *rr)
1190 ldns_status status = LDNS_STATUS_OK;
1193 fmt = ldns_output_format_default;
1196 if (LDNS_COMMENT_NULLS & fmt->flags) {
1197 ldns_buffer_printf(output, "; (null)\n");
1199 return ldns_buffer_status(output);
1201 if (ldns_rr_owner(rr)) {
1202 status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr));
1204 if (status != LDNS_STATUS_OK) {
1208 /* TTL should NOT be printed if it is a question */
1209 if (!ldns_rr_is_question(rr)) {
1210 ldns_buffer_printf(output, "\t%d", ldns_rr_ttl(rr));
1213 ldns_buffer_printf(output, "\t");
1214 status = ldns_rr_class2buffer_str(output, ldns_rr_get_class(rr));
1215 if (status != LDNS_STATUS_OK) {
1218 ldns_buffer_printf(output, "\t");
1220 status = ldns_rr_type2buffer_str(output, ldns_rr_get_type(rr));
1221 if (status != LDNS_STATUS_OK) {
1225 if (ldns_rr_rd_count(rr) > 0) {
1226 ldns_buffer_printf(output, "\t");
1227 } else if (!ldns_rr_is_question(rr)) {
1228 ldns_buffer_printf(output, "\t\\# 0");
1231 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1232 /* ldns_rdf2buffer_str handles NULL input fine! */
1233 status = ldns_rdf2buffer_str(output, ldns_rr_rdf(rr, i));
1234 if(status != LDNS_STATUS_OK)
1236 if (i < ldns_rr_rd_count(rr) - 1) {
1237 ldns_buffer_printf(output, " ");
1240 /* per RR special comments - handy for DNSSEC types */
1241 /* check to prevent question sec. rr from
1243 if (ldns_rr_rd_count(rr) > 0) {
1244 switch (ldns_rr_get_type(rr)) {
1245 case LDNS_RR_TYPE_DNSKEY:
1246 /* if ldns_rr_rd_count(rr) > 0
1247 then ldns_rr_rdf(rr, 0) exists! */
1248 if (! (fmt->flags & LDNS_COMMENT_KEY)) {
1251 flags = ldns_rdf2native_int16(
1252 ldns_rr_rdf(rr, 0));
1253 ldns_buffer_printf(output, " ;{");
1254 if (fmt->flags & LDNS_COMMENT_KEY_ID) {
1255 ldns_buffer_printf(output, "id = %u",
1257 ldns_calc_keytag(rr));
1259 if ((fmt->flags & LDNS_COMMENT_KEY_TYPE)
1260 && (flags & LDNS_KEY_ZONE_KEY)){
1261 if (flags & LDNS_KEY_SEP_KEY) {
1269 if (fmt->flags & LDNS_COMMENT_KEY_SIZE){
1273 } else if (fmt->flags
1274 & (LDNS_COMMENT_KEY_ID
1275 |LDNS_COMMENT_KEY_SIZE)) {
1276 ldns_buffer_printf( output, ", ");
1278 if (fmt->flags & LDNS_COMMENT_KEY_SIZE) {
1279 ldns_buffer_printf(output, "size = %db",
1280 ldns_rr_dnskey_key_size(rr));
1282 ldns_buffer_printf(output, "}");
1284 case LDNS_RR_TYPE_RRSIG:
1285 if ((fmt->flags & LDNS_COMMENT_KEY)
1287 & LDNS_COMMENT_RRSIGS)
1288 && ldns_rr_rdf(rr, 6) != NULL) {
1289 ldns_buffer_printf(output
1291 , ldns_rdf2native_int16(
1292 ldns_rr_rdf(rr, 6)));
1295 case LDNS_RR_TYPE_DS:
1296 if ((fmt->flags & LDNS_COMMENT_BUBBLEBABBLE)
1297 && ldns_rr_rdf(rr, 3) != NULL) {
1298 uint8_t *data = ldns_rdf_data(
1299 ldns_rr_rdf(rr, 3));
1300 size_t len = ldns_rdf_size(
1301 ldns_rr_rdf(rr, 3));
1302 char *babble = ldns_bubblebabble(
1305 ldns_buffer_printf(output
1306 , " ;{%s}", babble);
1311 case LDNS_RR_TYPE_NSEC3:
1312 if (! (fmt->flags & LDNS_COMMENT_FLAGS) &&
1313 ! (fmt->flags & LDNS_COMMENT_NSEC3_CHAIN)) {
1316 ldns_buffer_printf(output, " ;{");
1317 if ((fmt->flags & LDNS_COMMENT_FLAGS)) {
1318 if (ldns_nsec3_optout(rr)) {
1319 ldns_buffer_printf(output,
1322 ldns_buffer_printf(output,
1325 if (fmt->flags & LDNS_COMMENT_NSEC3_CHAIN
1326 && fmt->data != NULL) {
1327 ldns_buffer_printf(output, ", ");
1330 if (fmt->flags & LDNS_COMMENT_NSEC3_CHAIN
1331 && fmt->data != NULL) {
1332 ldns_rbnode_t *node;
1333 ldns_rdf *key = ldns_dname_label(
1334 ldns_rr_owner(rr), 0);
1336 node = ldns_rbtree_search(
1345 ldns_rdf2buffer_str(
1352 key = ldns_b32_ext2dname(
1353 ldns_nsec3_next_owner(rr));
1355 node = ldns_rbtree_search(
1364 ldns_rdf2buffer_str(
1372 ldns_buffer_printf(output, "}");
1380 ldns_buffer_printf(output, "\n");
1381 return ldns_buffer_status(output);
1385 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
1387 return ldns_rr2buffer_str_fmt(output, ldns_output_format_default, rr);
1391 ldns_rr_list2buffer_str_fmt(ldns_buffer *output,
1392 const ldns_output_format *fmt, const ldns_rr_list *list)
1396 for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
1397 (void) ldns_rr2buffer_str_fmt(output, fmt,
1398 ldns_rr_list_rr(list, i));
1400 return ldns_buffer_status(output);
1404 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
1406 return ldns_rr_list2buffer_str_fmt(
1407 output, ldns_output_format_default, list);
1411 ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
1413 ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
1414 (int) ldns_pkt_get_opcode(pkt));
1415 ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes,
1416 (int) ldns_pkt_get_rcode(pkt));
1418 ldns_buffer_printf(output, ";; ->>HEADER<<- ");
1420 ldns_buffer_printf(output, "opcode: %s, ", opcode->name);
1422 ldns_buffer_printf(output, "opcode: ?? (%u), ",
1423 ldns_pkt_get_opcode(pkt));
1426 ldns_buffer_printf(output, "rcode: %s, ", rcode->name);
1428 ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt));
1430 ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt));
1431 ldns_buffer_printf(output, ";; flags: ");
1433 if (ldns_pkt_qr(pkt)) {
1434 ldns_buffer_printf(output, "qr ");
1436 if (ldns_pkt_aa(pkt)) {
1437 ldns_buffer_printf(output, "aa ");
1439 if (ldns_pkt_tc(pkt)) {
1440 ldns_buffer_printf(output, "tc ");
1442 if (ldns_pkt_rd(pkt)) {
1443 ldns_buffer_printf(output, "rd ");
1445 if (ldns_pkt_cd(pkt)) {
1446 ldns_buffer_printf(output, "cd ");
1448 if (ldns_pkt_ra(pkt)) {
1449 ldns_buffer_printf(output, "ra ");
1451 if (ldns_pkt_ad(pkt)) {
1452 ldns_buffer_printf(output, "ad ");
1454 ldns_buffer_printf(output, "; ");
1455 ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt));
1456 ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt));
1457 ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt));
1458 ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt));
1459 return ldns_buffer_status(output);
1463 ldns_pkt2buffer_str_fmt(ldns_buffer *output,
1464 const ldns_output_format *fmt, const ldns_pkt *pkt)
1467 ldns_status status = LDNS_STATUS_OK;
1469 struct timeval time;
1473 ldns_buffer_printf(output, "null");
1474 return LDNS_STATUS_OK;
1477 if (ldns_buffer_status_ok(output)) {
1478 status = ldns_pktheader2buffer_str(output, pkt);
1479 if (status != LDNS_STATUS_OK) {
1483 ldns_buffer_printf(output, "\n");
1485 ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
1488 for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
1489 status = ldns_rr2buffer_str_fmt(output, fmt,
1491 ldns_pkt_question(pkt), i));
1492 if (status != LDNS_STATUS_OK) {
1496 ldns_buffer_printf(output, "\n");
1498 ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
1499 for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
1500 status = ldns_rr2buffer_str_fmt(output, fmt,
1502 ldns_pkt_answer(pkt), i));
1503 if (status != LDNS_STATUS_OK) {
1508 ldns_buffer_printf(output, "\n");
1510 ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
1512 for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
1513 status = ldns_rr2buffer_str_fmt(output, fmt,
1515 ldns_pkt_authority(pkt), i));
1516 if (status != LDNS_STATUS_OK) {
1520 ldns_buffer_printf(output, "\n");
1522 ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
1523 for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
1524 status = ldns_rr2buffer_str_fmt(output, fmt,
1526 ldns_pkt_additional(pkt), i));
1527 if (status != LDNS_STATUS_OK) {
1532 ldns_buffer_printf(output, "\n");
1533 /* add some futher fields */
1534 ldns_buffer_printf(output, ";; Query time: %d msec\n",
1535 ldns_pkt_querytime(pkt));
1536 if (ldns_pkt_edns(pkt)) {
1537 ldns_buffer_printf(output,
1538 ";; EDNS: version %u; flags:",
1539 ldns_pkt_edns_version(pkt));
1540 if (ldns_pkt_edns_do(pkt)) {
1541 ldns_buffer_printf(output, " do");
1543 /* the extended rcode is the value set, shifted four bits,
1544 * and or'd with the original rcode */
1545 if (ldns_pkt_edns_extended_rcode(pkt)) {
1546 ldns_buffer_printf(output, " ; ext-rcode: %d",
1547 (ldns_pkt_edns_extended_rcode(pkt) << 4 | ldns_pkt_get_rcode(pkt)));
1549 ldns_buffer_printf(output, " ; udp: %u\n",
1550 ldns_pkt_edns_udp_size(pkt));
1552 if (ldns_pkt_edns_data(pkt)) {
1553 ldns_buffer_printf(output, ";; Data: ");
1554 (void)ldns_rdf2buffer_str(output,
1555 ldns_pkt_edns_data(pkt));
1556 ldns_buffer_printf(output, "\n");
1559 if (ldns_pkt_tsig(pkt)) {
1560 ldns_buffer_printf(output, ";; TSIG:\n;; ");
1561 (void) ldns_rr2buffer_str_fmt(
1562 output, fmt, ldns_pkt_tsig(pkt));
1563 ldns_buffer_printf(output, "\n");
1565 if (ldns_pkt_answerfrom(pkt)) {
1566 tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
1567 ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
1570 time = ldns_pkt_timestamp(pkt);
1571 time_tt = (time_t)time.tv_sec;
1572 ldns_buffer_printf(output, ";; WHEN: %s",
1573 (char*)ctime(&time_tt));
1575 ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n",
1576 (int)ldns_pkt_size(pkt));
1578 return ldns_buffer_status(output);
1584 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
1586 return ldns_pkt2buffer_str_fmt(output, ldns_output_format_default, pkt);
1592 ldns_hmac_key2buffer_str(ldns_buffer *output, const ldns_key *k)
1596 ldns_rdf *b64_bignum;
1598 ldns_buffer_printf(output, "Key: ");
1600 i = ldns_key_hmac_size(k);
1601 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k));
1602 status = ldns_rdf2buffer_str(output, b64_bignum);
1603 ldns_rdf_deep_free(b64_bignum);
1604 ldns_buffer_printf(output, "\n");
1609 #if defined(HAVE_SSL) && defined(USE_GOST)
1611 ldns_gost_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
1613 unsigned char* pp = NULL;
1615 ldns_rdf *b64_bignum;
1618 ldns_buffer_printf(output, "GostAsn1: ");
1620 ret = i2d_PrivateKey(p, &pp);
1621 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, (size_t)ret, pp);
1622 status = ldns_rdf2buffer_str(output, b64_bignum);
1624 ldns_rdf_deep_free(b64_bignum);
1626 ldns_buffer_printf(output, "\n");
1632 ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
1634 ldns_status status = LDNS_STATUS_OK;
1635 unsigned char *bignum;
1641 /* not used when ssl is not defined */
1642 ldns_rdf *b64_bignum = NULL;
1646 #endif /* HAVE_SSL */
1649 return LDNS_STATUS_ERR;
1652 bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
1654 return LDNS_STATUS_ERR;
1657 if (ldns_buffer_status_ok(output)) {
1659 switch(ldns_key_algorithm(k)) {
1660 case LDNS_SIGN_RSASHA1:
1661 case LDNS_SIGN_RSASHA1_NSEC3:
1662 case LDNS_SIGN_RSASHA256:
1663 case LDNS_SIGN_RSASHA512:
1664 case LDNS_SIGN_RSAMD5:
1665 /* copied by looking at dnssec-keygen output */
1667 rsa = ldns_key_rsa_key(k);
1669 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
1670 switch(ldns_key_algorithm(k)) {
1671 case LDNS_SIGN_RSAMD5:
1672 ldns_buffer_printf(output,
1673 "Algorithm: %u (RSA)\n",
1676 case LDNS_SIGN_RSASHA1:
1677 ldns_buffer_printf(output,
1678 "Algorithm: %u (RSASHA1)\n",
1681 case LDNS_SIGN_RSASHA1_NSEC3:
1682 ldns_buffer_printf(output,
1683 "Algorithm: %u (RSASHA1_NSEC3)\n",
1684 LDNS_RSASHA1_NSEC3);
1687 case LDNS_SIGN_RSASHA256:
1688 ldns_buffer_printf(output,
1689 "Algorithm: %u (RSASHA256)\n",
1692 case LDNS_SIGN_RSASHA512:
1693 ldns_buffer_printf(output,
1694 "Algorithm: %u (RSASHA512)\n",
1699 fprintf(stderr, "Warning: unknown signature ");
1701 "algorithm type %u\n",
1702 ldns_key_algorithm(k));
1703 ldns_buffer_printf(output,
1704 "Algorithm: %u (Unknown)\n",
1705 ldns_key_algorithm(k));
1709 /* print to buf, convert to bin, convert to b64,
1711 ldns_buffer_printf(output, "Modulus: ");
1713 i = (uint16_t)BN_bn2bin(rsa->n, bignum);
1714 if (i > LDNS_MAX_KEYLEN) {
1717 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1718 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1721 ldns_rdf_deep_free(b64_bignum);
1722 ldns_buffer_printf(output, "\n");
1723 ldns_buffer_printf(output, "PublicExponent: ");
1724 i = (uint16_t)BN_bn2bin(rsa->e, bignum);
1725 if (i > LDNS_MAX_KEYLEN) {
1728 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1729 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1732 ldns_rdf_deep_free(b64_bignum);
1733 ldns_buffer_printf(output, "\n");
1735 ldns_buffer_printf(output, "PrivateExponent: ");
1737 i = (uint16_t)BN_bn2bin(rsa->d, bignum);
1738 if (i > LDNS_MAX_KEYLEN) {
1741 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1742 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1745 ldns_rdf_deep_free(b64_bignum);
1746 ldns_buffer_printf(output, "\n");
1748 ldns_buffer_printf(output, "(Not available)\n");
1751 ldns_buffer_printf(output, "Prime1: ");
1753 i = (uint16_t)BN_bn2bin(rsa->p, bignum);
1754 if (i > LDNS_MAX_KEYLEN) {
1757 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1758 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1761 ldns_rdf_deep_free(b64_bignum);
1762 ldns_buffer_printf(output, "\n");
1764 ldns_buffer_printf(output, "(Not available)\n");
1767 ldns_buffer_printf(output, "Prime2: ");
1769 i = (uint16_t)BN_bn2bin(rsa->q, bignum);
1770 if (i > LDNS_MAX_KEYLEN) {
1773 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1774 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1777 ldns_rdf_deep_free(b64_bignum);
1778 ldns_buffer_printf(output, "\n");
1780 ldns_buffer_printf(output, "(Not available)\n");
1783 ldns_buffer_printf(output, "Exponent1: ");
1785 i = (uint16_t)BN_bn2bin(rsa->dmp1, bignum);
1786 if (i > LDNS_MAX_KEYLEN) {
1789 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1790 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1793 ldns_rdf_deep_free(b64_bignum);
1794 ldns_buffer_printf(output, "\n");
1796 ldns_buffer_printf(output, "(Not available)\n");
1799 ldns_buffer_printf(output, "Exponent2: ");
1801 i = (uint16_t)BN_bn2bin(rsa->dmq1, bignum);
1802 if (i > LDNS_MAX_KEYLEN) {
1805 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1806 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1809 ldns_rdf_deep_free(b64_bignum);
1810 ldns_buffer_printf(output, "\n");
1812 ldns_buffer_printf(output, "(Not available)\n");
1815 ldns_buffer_printf(output, "Coefficient: ");
1817 i = (uint16_t)BN_bn2bin(rsa->iqmp, bignum);
1818 if (i > LDNS_MAX_KEYLEN) {
1821 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1822 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1825 ldns_rdf_deep_free(b64_bignum);
1826 ldns_buffer_printf(output, "\n");
1828 ldns_buffer_printf(output, "(Not available)\n");
1835 case LDNS_SIGN_DSA_NSEC3:
1836 dsa = ldns_key_dsa_key(k);
1838 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
1839 if (ldns_key_algorithm(k) == LDNS_SIGN_DSA) {
1840 ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n");
1841 } else if (ldns_key_algorithm(k) == LDNS_SIGN_DSA_NSEC3) {
1842 ldns_buffer_printf(output,"Algorithm: 6 (DSA_NSEC3)\n");
1845 /* print to buf, convert to bin, convert to b64,
1847 ldns_buffer_printf(output, "Prime(p): ");
1850 i = (uint16_t)BN_bn2bin(dsa->p, bignum);
1851 if (i > LDNS_MAX_KEYLEN) {
1854 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1855 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1858 ldns_rdf_deep_free(b64_bignum);
1859 ldns_buffer_printf(output, "\n");
1861 printf("(Not available)\n");
1864 ldns_buffer_printf(output, "Subprime(q): ");
1866 i = (uint16_t)BN_bn2bin(dsa->q, bignum);
1867 if (i > LDNS_MAX_KEYLEN) {
1870 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1871 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1874 ldns_rdf_deep_free(b64_bignum);
1875 ldns_buffer_printf(output, "\n");
1877 printf("(Not available)\n");
1880 ldns_buffer_printf(output, "Base(g): ");
1882 i = (uint16_t)BN_bn2bin(dsa->g, bignum);
1883 if (i > LDNS_MAX_KEYLEN) {
1886 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1887 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1890 ldns_rdf_deep_free(b64_bignum);
1891 ldns_buffer_printf(output, "\n");
1893 printf("(Not available)\n");
1896 ldns_buffer_printf(output, "Private_value(x): ");
1897 if (dsa->priv_key) {
1898 i = (uint16_t)BN_bn2bin(dsa->priv_key, bignum);
1899 if (i > LDNS_MAX_KEYLEN) {
1902 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1903 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1906 ldns_rdf_deep_free(b64_bignum);
1907 ldns_buffer_printf(output, "\n");
1909 printf("(Not available)\n");
1912 ldns_buffer_printf(output, "Public_value(y): ");
1914 i = (uint16_t)BN_bn2bin(dsa->pub_key, bignum);
1915 if (i > LDNS_MAX_KEYLEN) {
1918 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1919 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1922 ldns_rdf_deep_free(b64_bignum);
1923 ldns_buffer_printf(output, "\n");
1925 printf("(Not available)\n");
1929 case LDNS_SIGN_ECC_GOST:
1930 /* no format defined, use blob */
1931 #if defined(HAVE_SSL) && defined(USE_GOST)
1932 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1933 ldns_buffer_printf(output, "Algorithm: %d (ECC-GOST)\n", LDNS_SIGN_ECC_GOST);
1934 status = ldns_gost_key2buffer_str(output,
1945 case LDNS_SIGN_ECDSAP256SHA256:
1946 case LDNS_SIGN_ECDSAP384SHA384:
1947 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1948 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
1949 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
1951 ldns_buffer_printf(output, ")\n");
1953 EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->_key.key);
1954 const BIGNUM* b = EC_KEY_get0_private_key(ec);
1955 ldns_buffer_printf(output, "PrivateKey: ");
1956 i = (uint16_t)BN_bn2bin(b, bignum);
1957 if (i > LDNS_MAX_KEYLEN) {
1960 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1961 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1964 ldns_rdf_deep_free(b64_bignum);
1965 ldns_buffer_printf(output, "\n");
1966 /* down reference count in EC_KEY
1967 * its still assigned to the PKEY */
1973 case LDNS_SIGN_HMACMD5:
1974 /* there's not much of a format defined for TSIG */
1975 /* It's just a binary blob, Same for all algorithms */
1976 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1977 ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n");
1978 status = ldns_hmac_key2buffer_str(output, k);
1980 case LDNS_SIGN_HMACSHA1:
1981 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1982 ldns_buffer_printf(output, "Algorithm: 158 (HMAC_SHA1)\n");
1983 status = ldns_hmac_key2buffer_str(output, k);
1985 case LDNS_SIGN_HMACSHA256:
1986 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1987 ldns_buffer_printf(output, "Algorithm: 159 (HMAC_SHA256)\n");
1988 status = ldns_hmac_key2buffer_str(output, k);
1991 #endif /* HAVE_SSL */
1994 LDNS_FREE(b64_bignum);
1997 return ldns_buffer_status(output);
2003 /* compiles warn the label isn't used */
2006 return LDNS_STATUS_ERR;
2007 #endif /* HAVE_SSL */
2012 * Zero terminate the buffer and fix it to the size of the string.
2015 ldns_buffer2str(ldns_buffer *buffer)
2020 /* check if buffer ends with \0, if not, and
2021 if there is space, add it */
2022 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
2023 if (!ldns_buffer_reserve(buffer, 1)) {
2026 ldns_buffer_write_u8(buffer, (uint8_t) '\0');
2027 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
2032 tmp_str = ldns_buffer_export(buffer);
2033 str = LDNS_XMALLOC(char, strlen(tmp_str) + 1);
2037 memcpy(str, tmp_str, strlen(tmp_str) + 1);
2043 ldns_rdf2str(const ldns_rdf *rdf)
2045 char *result = NULL;
2046 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2051 if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
2052 /* export and return string, destroy rest */
2053 result = ldns_buffer2str(tmp_buffer);
2055 ldns_buffer_free(tmp_buffer);
2060 ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr)
2062 char *result = NULL;
2063 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2068 if (ldns_rr2buffer_str_fmt(tmp_buffer, fmt, rr)
2069 == LDNS_STATUS_OK) {
2070 /* export and return string, destroy rest */
2071 result = ldns_buffer2str(tmp_buffer);
2073 ldns_buffer_free(tmp_buffer);
2078 ldns_rr2str(const ldns_rr *rr)
2080 return ldns_rr2str_fmt(ldns_output_format_default, rr);
2084 ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt)
2086 char *result = NULL;
2087 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2092 if (ldns_pkt2buffer_str_fmt(tmp_buffer, fmt, pkt)
2093 == LDNS_STATUS_OK) {
2094 /* export and return string, destroy rest */
2095 result = ldns_buffer2str(tmp_buffer);
2098 ldns_buffer_free(tmp_buffer);
2103 ldns_pkt2str(const ldns_pkt *pkt)
2105 return ldns_pkt2str_fmt(ldns_output_format_default, pkt);
2109 ldns_key2str(const ldns_key *k)
2111 char *result = NULL;
2112 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2117 if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) {
2118 /* export and return string, destroy rest */
2119 result = ldns_buffer2str(tmp_buffer);
2121 ldns_buffer_free(tmp_buffer);
2126 ldns_rr_list2str_fmt(const ldns_output_format *fmt, const ldns_rr_list *list)
2128 char *result = NULL;
2129 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2135 if (ldns_rr_list2buffer_str_fmt(
2136 tmp_buffer, fmt, list)
2137 == LDNS_STATUS_OK) {
2141 fmt = ldns_output_format_default;
2143 if (fmt->flags & LDNS_COMMENT_NULLS) {
2144 ldns_buffer_printf(tmp_buffer, "; (null)\n");
2148 /* export and return string, destroy rest */
2149 result = ldns_buffer2str(tmp_buffer);
2150 ldns_buffer_free(tmp_buffer);
2155 ldns_rr_list2str(const ldns_rr_list *list)
2157 return ldns_rr_list2str_fmt(ldns_output_format_default, list);
2161 ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
2163 char *str = ldns_rdf2str(rdf);
2165 fprintf(output, "%s", str);
2167 fprintf(output, "Unable to convert rdf to string\n");
2173 ldns_rr_print_fmt(FILE *output,
2174 const ldns_output_format *fmt, const ldns_rr *rr)
2176 char *str = ldns_rr2str_fmt(fmt, rr);
2178 fprintf(output, "%s", str);
2180 fprintf(output, "Unable to convert rr to string\n");
2186 ldns_rr_print(FILE *output, const ldns_rr *rr)
2188 ldns_rr_print_fmt(output, ldns_output_format_default, rr);
2192 ldns_pkt_print_fmt(FILE *output,
2193 const ldns_output_format *fmt, const ldns_pkt *pkt)
2195 char *str = ldns_pkt2str_fmt(fmt, pkt);
2197 fprintf(output, "%s", str);
2199 fprintf(output, "Unable to convert packet to string\n");
2205 ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
2207 ldns_pkt_print_fmt(output, ldns_output_format_default, pkt);
2211 ldns_rr_list_print_fmt(FILE *output,
2212 const ldns_output_format *fmt, const ldns_rr_list *lst)
2215 for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
2216 ldns_rr_print_fmt(output, fmt, ldns_rr_list_rr(lst, i));
2221 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
2223 ldns_rr_list_print_fmt(output, ldns_output_format_default, lst);
2227 ldns_resolver_print_fmt(FILE *output,
2228 const ldns_output_format *fmt, const ldns_resolver *r)
2237 n = ldns_resolver_nameservers(r);
2238 s = ldns_resolver_searchlist(r);
2239 rtt = ldns_resolver_rtt(r);
2241 fprintf(output, "port: %d\n", (int)ldns_resolver_port(r));
2242 fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r));
2243 fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r));
2245 fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r));
2246 fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r));
2247 fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r));
2248 fprintf(output, "fail: %d\n", ldns_resolver_fail(r));
2249 fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r));
2250 fprintf(output, "retrans: %d\n", (int)ldns_resolver_retrans(r));
2251 fprintf(output, "fallback: %d\n", ldns_resolver_fallback(r));
2252 fprintf(output, "random: %d\n", ldns_resolver_random(r));
2253 fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
2254 fprintf(output, "dnssec: %d\n", ldns_resolver_dnssec(r));
2255 fprintf(output, "dnssec cd: %d\n", ldns_resolver_dnssec_cd(r));
2256 fprintf(output, "trust anchors (%d listed):\n",
2257 (int)ldns_rr_list_rr_count(ldns_resolver_dnssec_anchors(r)));
2258 ldns_rr_list_print_fmt(output, fmt, ldns_resolver_dnssec_anchors(r));
2259 fprintf(output, "tsig: %s %s\n",
2260 ldns_resolver_tsig_keyname(r)?ldns_resolver_tsig_keyname(r):"-",
2261 ldns_resolver_tsig_algorithm(r)?ldns_resolver_tsig_algorithm(r):"-");
2262 fprintf(output, "debug: %d\n", ldns_resolver_debug(r));
2264 fprintf(output, "default domain: ");
2265 ldns_rdf_print(output, ldns_resolver_domain(r));
2266 fprintf(output, "\n");
2267 fprintf(output, "apply default domain: %d\n", ldns_resolver_defnames(r));
2269 fprintf(output, "searchlist (%d listed):\n", (int)ldns_resolver_searchlist_count(r));
2270 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
2271 fprintf(output, "\t");
2272 ldns_rdf_print(output, s[i]);
2273 fprintf(output, "\n");
2275 fprintf(output, "apply search list: %d\n", ldns_resolver_dnsrch(r));
2277 fprintf(output, "nameservers (%d listed):\n", (int)ldns_resolver_nameserver_count(r));
2278 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
2279 fprintf(output, "\t");
2280 ldns_rdf_print(output, n[i]);
2282 switch ((int)rtt[i]) {
2283 case LDNS_RESOLV_RTT_MIN:
2284 fprintf(output, " - reachable\n");
2286 case LDNS_RESOLV_RTT_INF:
2287 fprintf(output, " - unreachable\n");
2294 ldns_resolver_print(FILE *output, const ldns_resolver *r)
2296 ldns_resolver_print_fmt(output, ldns_output_format_default, r);
2300 ldns_zone_print_fmt(FILE *output,
2301 const ldns_output_format *fmt, const ldns_zone *z)
2303 if(ldns_zone_soa(z))
2304 ldns_rr_print_fmt(output, fmt, ldns_zone_soa(z));
2305 ldns_rr_list_print_fmt(output, fmt, ldns_zone_rrs(z));
2308 ldns_zone_print(FILE *output, const ldns_zone *z)
2310 ldns_zone_print_fmt(output, ldns_output_format_default, z);