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"},
56 { LDNS_INDIRECT, "INDIRECT" },
57 { LDNS_PRIVATEDNS, "PRIVATEDNS" },
58 { LDNS_PRIVATEOID, "PRIVATEOID" },
62 /* Taken from RFC 2538 */
63 ldns_lookup_table ldns_cert_algorithms[] = {
64 { LDNS_CERT_PKIX, "PKIX" },
65 { LDNS_CERT_SPKI, "SPKI" },
66 { LDNS_CERT_PGP, "PGP" },
67 { LDNS_CERT_URI, "URI" },
68 { LDNS_CERT_OID, "OID" },
73 ldns_lookup_table ldns_rr_classes[] = {
74 { LDNS_RR_CLASS_IN, "IN" },
75 { LDNS_RR_CLASS_CH, "CH" },
76 { LDNS_RR_CLASS_HS, "HS" },
77 { LDNS_RR_CLASS_NONE, "NONE" },
78 { LDNS_RR_CLASS_ANY, "ANY" },
82 /* if these are used elsewhere */
83 ldns_lookup_table ldns_rcodes[] = {
84 { LDNS_RCODE_NOERROR, "NOERROR" },
85 { LDNS_RCODE_FORMERR, "FORMERR" },
86 { LDNS_RCODE_SERVFAIL, "SERVFAIL" },
87 { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" },
88 { LDNS_RCODE_NOTIMPL, "NOTIMPL" },
89 { LDNS_RCODE_REFUSED, "REFUSED" },
90 { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" },
91 { LDNS_RCODE_YXRRSET, "YXRRSET" },
92 { LDNS_RCODE_NXRRSET, "NXRRSET" },
93 { LDNS_RCODE_NOTAUTH, "NOTAUTH" },
94 { LDNS_RCODE_NOTZONE, "NOTZONE" },
98 ldns_lookup_table ldns_opcodes[] = {
99 { LDNS_PACKET_QUERY, "QUERY" },
100 { LDNS_PACKET_IQUERY, "IQUERY" },
101 { LDNS_PACKET_STATUS, "STATUS" },
102 { LDNS_PACKET_NOTIFY, "NOTIFY" },
103 { LDNS_PACKET_UPDATE, "UPDATE" },
108 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode)
110 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode);
111 if (lt && lt->name) {
112 ldns_buffer_printf(output, "%s", lt->name);
114 ldns_buffer_printf(output, "OPCODE%u", opcode);
116 return ldns_buffer_status(output);
120 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode)
122 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode);
123 if (lt && lt->name) {
124 ldns_buffer_printf(output, "%s", lt->name);
126 ldns_buffer_printf(output, "RCODE%u", rcode);
128 return ldns_buffer_status(output);
132 ldns_algorithm2buffer_str(ldns_buffer *output,
133 ldns_algorithm algorithm)
135 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_algorithms,
137 if (lt && lt->name) {
138 ldns_buffer_printf(output, "%s", lt->name);
140 ldns_buffer_printf(output, "ALG%u", algorithm);
142 return ldns_buffer_status(output);
146 ldns_cert_algorithm2buffer_str(ldns_buffer *output,
147 ldns_cert_algorithm cert_algorithm)
149 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_cert_algorithms,
151 if (lt && lt->name) {
152 ldns_buffer_printf(output, "%s", lt->name);
154 ldns_buffer_printf(output, "CERT_ALG%u",
157 return ldns_buffer_status(output);
161 ldns_pkt_opcode2str(ldns_pkt_opcode opcode)
166 buf = ldns_buffer_new(12);
169 if (ldns_pkt_opcode2buffer_str(buf, opcode) == LDNS_STATUS_OK) {
170 str = ldns_buffer2str(buf);
173 ldns_buffer_free(buf);
178 ldns_pkt_rcode2str(ldns_pkt_rcode rcode)
183 buf = ldns_buffer_new(10);
186 if (ldns_pkt_rcode2buffer_str(buf, rcode) == LDNS_STATUS_OK) {
187 str = ldns_buffer2str(buf);
190 ldns_buffer_free(buf);
195 ldns_pkt_algorithm2str(ldns_algorithm algorithm)
200 buf = ldns_buffer_new(10);
203 if (ldns_algorithm2buffer_str(buf, algorithm)
205 str = ldns_buffer2str(buf);
208 ldns_buffer_free(buf);
213 ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm)
218 buf = ldns_buffer_new(10);
221 if (ldns_cert_algorithm2buffer_str(buf, cert_algorithm)
223 str = ldns_buffer2str(buf);
226 ldns_buffer_free(buf);
231 /* do NOT pass compressed data here :p */
233 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
235 /* can we do with 1 pos var? or without at all? */
241 data = (uint8_t*)ldns_rdf_data(dname);
244 if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) {
245 /* too large, return */
246 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
249 /* special case: root label */
250 if (1 == ldns_rdf_size(dname)) {
251 ldns_buffer_printf(output, ".");
253 while ((len > 0) && src_pos < ldns_rdf_size(dname)) {
255 for(i = 0; i < len; i++) {
256 /* paranoia check for various 'strange'
259 if(data[src_pos]=='.' || data[src_pos]==';' ||
260 data[src_pos]=='(' || data[src_pos]==')' ||
261 data[src_pos]=='\\') {
262 ldns_buffer_printf(output, "\\%c",
264 } else if (!isgraph((int) data[src_pos])) {
265 ldns_buffer_printf(output, "\\%03u",
268 ldns_buffer_printf(output, "%c", data[src_pos]);
274 ldns_buffer_printf(output, ".");
277 return ldns_buffer_status(output);
281 ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
283 uint8_t data = ldns_rdf_data(rdf)[0];
284 ldns_buffer_printf(output, "%lu", (unsigned long) data);
285 return ldns_buffer_status(output);
289 ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
291 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
292 ldns_buffer_printf(output, "%lu", (unsigned long) data);
293 return ldns_buffer_status(output);
297 ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
299 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
300 ldns_buffer_printf(output, "%lu", (unsigned long) data);
301 return ldns_buffer_status(output);
305 ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
307 /* create a YYYYMMDDHHMMSS string if possible */
308 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
314 memcpy(&data_time, &data, sizeof(uint32_t));
316 memset(&tm, 0, sizeof(tm));
318 if (gmtime_r(&data_time, &tm) && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
319 ldns_buffer_printf(output, "%s", date_buf);
321 return ldns_buffer_status(output);
325 ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
327 char str[INET_ADDRSTRLEN];
329 if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) {
330 ldns_buffer_printf(output, "%s", str);
332 return ldns_buffer_status(output);
336 ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
338 char str[INET6_ADDRSTRLEN];
340 if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) {
341 ldns_buffer_printf(output, "%s", str);
344 return ldns_buffer_status(output);
348 ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
350 const uint8_t *data = ldns_rdf_data(rdf);
351 uint8_t length = data[0];
354 ldns_buffer_printf(output, "\"");
355 for (i = 1; i <= length; ++i) {
356 char ch = (char) data[i];
357 if (isprint((int)ch) || ch=='\t') {
358 if (ch=='\"'||ch=='\\')
359 ldns_buffer_printf(output, "\\%c", ch);
361 ldns_buffer_printf(output, "%c", ch);
363 ldns_buffer_printf(output, "\\%03u", (unsigned) ch);
366 ldns_buffer_printf(output, "\"");
367 return ldns_buffer_status(output);
371 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
373 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf));
374 char *b64 = LDNS_XMALLOC(char, size);
375 if (ldns_b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) {
376 ldns_buffer_printf(output, "%s", b64);
379 return ldns_buffer_status(output);
383 ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf)
385 size_t size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
386 char *b32 = LDNS_XMALLOC(char, size + 1);
387 size = (size_t) ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
388 ldns_rdf_size(rdf) - 1,
391 ldns_buffer_printf(output, "%s", b32);
394 return ldns_buffer_status(output);
398 ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
401 for (i = 0; i < ldns_rdf_size(rdf); i++) {
402 ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]);
405 return ldns_buffer_status(output);
409 ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
411 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
412 const ldns_rr_descriptor *descriptor;
414 descriptor = ldns_rr_descript(data);
415 if (descriptor && descriptor->_name) {
416 ldns_buffer_printf(output, "%s", descriptor->_name);
418 ldns_buffer_printf(output, "TYPE%u", data);
420 return ldns_buffer_status(output);
424 ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
426 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
427 ldns_lookup_table *lt;
429 lt = ldns_lookup_by_id(ldns_rr_classes, (int) data);
431 ldns_buffer_printf(output, "\t%s", lt->name);
433 ldns_buffer_printf(output, "\tCLASS%d", data);
435 return ldns_buffer_status(output);
439 ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
441 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
442 ldns_lookup_table *lt;
443 lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data);
445 ldns_buffer_printf(output, "%s", lt->name);
447 ldns_buffer_printf(output, "%d", data);
449 return ldns_buffer_status(output);
453 ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
455 /* don't use algorithm mnemonics in the presentation format
456 this kind of got sneaked into the rfc's */
457 uint8_t data = ldns_rdf_data(rdf)[0];
460 ldns_lookup_table *lt;
462 lt = ldns_lookup_by_id(ldns_algorithms, (int) data);
464 ldns_buffer_printf(output, "%s", lt->name);
467 ldns_buffer_printf(output, "%d", data);
471 return ldns_buffer_status(output);
475 loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
478 /* is it 0.<two digits> ? */
482 ldns_buffer_printf(output, "0.%02ld", (long)mantissa);
485 /* always <digit><string of zeros> */
486 ldns_buffer_printf(output, "%d", (int)mantissa);
487 for(i=0; i<exponent-2; i++)
488 ldns_buffer_printf(output, "0");
492 ldns_rr_type2buffer_str(ldns_buffer *output, const ldns_rr_type type)
494 const ldns_rr_descriptor *descriptor;
496 descriptor = ldns_rr_descript(type);
498 if (descriptor && descriptor->_name) {
499 ldns_buffer_printf(output, "%s", descriptor->_name);
501 /* exceptions for pseudotypes */
503 case LDNS_RR_TYPE_IXFR:
504 ldns_buffer_printf(output, "IXFR");
506 case LDNS_RR_TYPE_AXFR:
507 ldns_buffer_printf(output, "AXFR");
509 case LDNS_RR_TYPE_MAILA:
510 ldns_buffer_printf(output, "MAILA");
512 case LDNS_RR_TYPE_MAILB:
513 ldns_buffer_printf(output, "MAILB");
515 case LDNS_RR_TYPE_ANY:
516 ldns_buffer_printf(output, "ANY");
519 ldns_buffer_printf(output, "TYPE%u", type);
522 return ldns_buffer_status(output);
526 ldns_rr_type2str(const ldns_rr_type type)
531 buf = ldns_buffer_new(10);
534 if (ldns_rr_type2buffer_str(buf, type) == LDNS_STATUS_OK) {
535 str = ldns_buffer2str(buf);
538 ldns_buffer_free(buf);
544 ldns_rr_class2buffer_str(ldns_buffer *output,
545 const ldns_rr_class klass)
547 ldns_lookup_table *lt;
549 lt = ldns_lookup_by_id(ldns_rr_classes, klass);
551 ldns_buffer_printf(output, "%s", lt->name);
553 ldns_buffer_printf(output, "CLASS%d", klass);
555 return ldns_buffer_status(output);
559 ldns_rr_class2str(const ldns_rr_class klass)
565 buf = ldns_buffer_new(10);
566 if (ldns_rr_class2buffer_str(buf, klass) == LDNS_STATUS_OK) {
567 str = ldns_buffer2str(buf);
569 ldns_buffer_free(buf);
574 ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
576 /* we could do checking (ie degrees < 90 etc)? */
577 uint8_t version = ldns_rdf_data(rdf)[0];
579 uint8_t horizontal_precision;
580 uint8_t vertical_precision;
590 uint32_t equator = (uint32_t) ldns_power(2, 31);
593 size = ldns_rdf_data(rdf)[1];
594 horizontal_precision = ldns_rdf_data(rdf)[2];
595 vertical_precision = ldns_rdf_data(rdf)[3];
597 latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]);
598 longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]);
599 altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]);
601 if (latitude > equator) {
603 latitude = latitude - equator;
606 latitude = equator - latitude;
608 h = latitude / (1000 * 60 * 60);
609 latitude = latitude % (1000 * 60 * 60);
610 m = latitude / (1000 * 60);
611 latitude = latitude % (1000 * 60);
612 s = (double) latitude / 1000.0;
613 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
614 h, m, s, northerness);
616 if (longitude > equator) {
618 longitude = longitude - equator;
621 longitude = equator - longitude;
623 h = longitude / (1000 * 60 * 60);
624 longitude = longitude % (1000 * 60 * 60);
625 m = longitude / (1000 * 60);
626 longitude = longitude % (1000 * 60);
627 s = (double) longitude / (1000.0);
628 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
629 h, m, s, easterness);
632 s = ((double) altitude) / 100;
635 if(altitude%100 != 0)
636 ldns_buffer_printf(output, "%.2f", s);
638 ldns_buffer_printf(output, "%.0f", s);
640 ldns_buffer_printf(output, "m ");
642 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
643 ldns_buffer_printf(output, "m ");
645 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
646 horizontal_precision & 0x0f);
647 ldns_buffer_printf(output, "m ");
649 loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
650 vertical_precision & 0x0f);
651 ldns_buffer_printf(output, "m ");
653 return ldns_buffer_status(output);
655 return ldns_rdf2buffer_str_hex(output, rdf);
660 ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
662 ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
663 return ldns_rdf2buffer_str_hex(output, rdf);
667 ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
669 ldns_buffer_printf(output, "0x");
670 return ldns_rdf2buffer_str_hex(output, rdf);
674 ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf)
676 return ldns_rdf2buffer_str_hex(output, rdf);
680 ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
682 /* protocol, followed by bitmap of services */
683 struct protoent *protocol;
684 char *proto_name = NULL;
686 struct servent *service;
687 uint16_t current_service;
689 protocol_nr = ldns_rdf_data(rdf)[0];
690 protocol = getprotobynumber((int) protocol_nr);
691 if (protocol && (protocol->p_name != NULL)) {
692 proto_name = protocol->p_name;
693 ldns_buffer_printf(output, "%s ", protocol->p_name);
695 ldns_buffer_printf(output, "%u ", protocol_nr);
698 #ifdef HAVE_ENDPROTOENT
702 for (current_service = 0;
703 current_service < ldns_rdf_size(rdf) * 7; current_service++) {
704 if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) {
705 service = getservbyport((int) htons(current_service),
707 if (service && service->s_name) {
708 ldns_buffer_printf(output, "%s ", service->s_name);
710 ldns_buffer_printf(output, "%u ", current_service);
712 #ifdef HAVE_ENDSERVENT
717 return ldns_buffer_status(output);
721 ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
723 /* Note: this code is duplicated in higher.c in
724 * ldns_nsec_type_check() function
726 uint8_t window_block_nr;
727 uint8_t bitmap_length;
731 uint8_t *data = ldns_rdf_data(rdf);
732 const ldns_rr_descriptor *descriptor;
734 while(pos < ldns_rdf_size(rdf)) {
735 window_block_nr = data[pos];
736 bitmap_length = data[pos + 1];
739 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
740 if (ldns_get_bit(&data[pos], bit_pos)) {
741 type = 256 * (uint16_t) window_block_nr + bit_pos;
742 descriptor = ldns_rr_descript(type);
744 if (descriptor && descriptor->_name) {
745 ldns_buffer_printf(output, "%s ",
748 ldns_buffer_printf(output, "TYPE%u ", type);
753 pos += (uint16_t) bitmap_length;
756 return ldns_buffer_status(output);
760 ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf)
765 uint8_t *data = ldns_rdf_data(rdf);
768 salt_length = data[0];
769 /* todo: length check needed/possible? */
770 /* from now there are variable length entries so remember pos */
772 if (salt_length == 0) {
773 ldns_buffer_printf(output, "- ");
775 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) {
776 ldns_buffer_printf(output, "%02x", data[1 + salt_pos]);
779 ldns_buffer_printf(output, " ");
782 return ldns_buffer_status(output);
786 ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
788 /* period is the number of seconds */
789 uint32_t p = ldns_read_uint32(ldns_rdf_data(rdf));
790 ldns_buffer_printf(output, "%u", p);
791 return ldns_buffer_status(output);
795 ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf)
797 /* tsigtime is 48 bits network order unsigned integer */
798 uint64_t tsigtime = 0;
799 uint8_t *data = ldns_rdf_data(rdf);
801 if (ldns_rdf_size(rdf) != 6) {
802 return LDNS_STATUS_ERR;
805 tsigtime = ldns_read_uint16(data);
807 tsigtime += ldns_read_uint16(data+2);
810 ldns_buffer_printf(output, "%llu ", tsigtime);
812 return ldns_buffer_status(output);
816 ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
818 uint8_t *data = ldns_rdf_data(rdf);
819 uint16_t address_family = ldns_read_uint16(data);
820 uint8_t prefix = data[2];
824 unsigned int pos = 0;
826 while (pos < (unsigned int) ldns_rdf_size(rdf)) {
827 address_family = ldns_read_uint16(&data[pos]);
828 prefix = data[pos + 2];
829 negation = data[pos + 3] & LDNS_APL_NEGATION;
830 adf_length = data[pos + 3] & LDNS_APL_MASK;
831 if (address_family == LDNS_APL_IP4) {
832 /* check if prefix < 32? */
834 ldns_buffer_printf(output, "!");
836 ldns_buffer_printf(output, "%u:", address_family);
837 /* address is variable length 0 - 4 */
838 for (i = 0; i < 4; i++) {
840 ldns_buffer_printf(output, ".");
842 if (i < (unsigned short) adf_length) {
843 ldns_buffer_printf(output, "%d",
846 ldns_buffer_printf(output, "0");
849 ldns_buffer_printf(output, "/%u ", prefix);
850 } else if (address_family == LDNS_APL_IP6) {
851 /* check if prefix < 128? */
853 ldns_buffer_printf(output, "!");
855 ldns_buffer_printf(output, "%u:", address_family);
856 /* address is variable length 0 - 16 */
857 for (i = 0; i < 16; i++) {
858 if (i % 2 == 0 && i > 0) {
859 ldns_buffer_printf(output, ":");
861 if (i < (unsigned short) adf_length) {
862 ldns_buffer_printf(output, "%02x",
865 ldns_buffer_printf(output, "00");
868 ldns_buffer_printf(output, "/%u ", prefix);
871 /* unknown address family */
872 ldns_buffer_printf(output, "Unknown address family: %u data: ",
874 for (i = 1; i < (unsigned short) (4 + adf_length); i++) {
875 ldns_buffer_printf(output, "%02x", data[i]);
878 pos += 4 + adf_length;
880 return ldns_buffer_status(output);
884 ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
886 /* Subtract the size (2) of the number that specifies the length */
887 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
888 char *b64 = LDNS_XMALLOC(char, size);
890 ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
892 if (ldns_rdf_size(rdf) > 2 &&
893 ldns_b64_ntop(ldns_rdf_data(rdf) + 2,
894 ldns_rdf_size(rdf) - 2,
896 ldns_buffer_printf(output, "%s", b64);
899 return ldns_buffer_status(output);
903 ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
906 http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt
908 uint8_t *data = ldns_rdf_data(rdf);
910 uint8_t gateway_type;
913 ldns_rdf *gateway = NULL;
914 uint8_t *gateway_data;
916 size_t public_key_size;
917 uint8_t *public_key_data;
918 ldns_rdf *public_key;
923 precedence = data[0];
924 gateway_type = data[1];
928 switch (gateway_type) {
933 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
934 memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
935 gateway = ldns_rdf_new(LDNS_RDF_TYPE_A, LDNS_IP4ADDRLEN , gateway_data);
936 offset += LDNS_IP4ADDRLEN;
939 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
940 memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
941 offset += LDNS_IP6ADDRLEN;
943 ldns_rdf_new(LDNS_RDF_TYPE_AAAA, LDNS_IP6ADDRLEN, gateway_data);
946 status = ldns_wire2dname(&gateway, data, ldns_rdf_size(rdf), &offset);
953 public_key_size = ldns_rdf_size(rdf) - offset;
954 public_key_data = LDNS_XMALLOC(uint8_t, public_key_size);
955 memcpy(public_key_data, &data[offset], public_key_size);
956 public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64, public_key_size, public_key_data);
958 ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm);
960 (void) ldns_rdf2buffer_str(output, gateway);
962 ldns_buffer_printf(output, ".");
963 ldns_buffer_printf(output, " ");
964 (void) ldns_rdf2buffer_str(output, public_key);
966 ldns_rdf_free(gateway);
967 ldns_rdf_free(public_key);
969 return ldns_buffer_status(output);
973 ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf)
975 /* TSIG RRs have no presentation format, make them #size <data> */
976 return ldns_rdf2buffer_str_unknown(output, rdf);
981 ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
985 /*ldns_buffer_printf(buffer, "%u:", ldns_rdf_get_type(rdf));*/
987 switch(ldns_rdf_get_type(rdf)) {
988 case LDNS_RDF_TYPE_NONE:
990 case LDNS_RDF_TYPE_DNAME:
991 res = ldns_rdf2buffer_str_dname(buffer, rdf);
993 case LDNS_RDF_TYPE_INT8:
994 res = ldns_rdf2buffer_str_int8(buffer, rdf);
996 case LDNS_RDF_TYPE_INT16:
997 res = ldns_rdf2buffer_str_int16(buffer, rdf);
999 case LDNS_RDF_TYPE_INT32:
1000 res = ldns_rdf2buffer_str_int32(buffer, rdf);
1002 case LDNS_RDF_TYPE_PERIOD:
1003 res = ldns_rdf2buffer_str_period(buffer, rdf);
1005 case LDNS_RDF_TYPE_TSIGTIME:
1006 res = ldns_rdf2buffer_str_tsigtime(buffer, rdf);
1008 case LDNS_RDF_TYPE_A:
1009 res = ldns_rdf2buffer_str_a(buffer, rdf);
1011 case LDNS_RDF_TYPE_AAAA:
1012 res = ldns_rdf2buffer_str_aaaa(buffer, rdf);
1014 case LDNS_RDF_TYPE_STR:
1015 res = ldns_rdf2buffer_str_str(buffer, rdf);
1017 case LDNS_RDF_TYPE_APL:
1018 res = ldns_rdf2buffer_str_apl(buffer, rdf);
1020 case LDNS_RDF_TYPE_B32_EXT:
1021 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1023 case LDNS_RDF_TYPE_B64:
1024 res = ldns_rdf2buffer_str_b64(buffer, rdf);
1026 case LDNS_RDF_TYPE_HEX:
1027 res = ldns_rdf2buffer_str_hex(buffer, rdf);
1029 case LDNS_RDF_TYPE_NSEC:
1030 res = ldns_rdf2buffer_str_nsec(buffer, rdf);
1032 case LDNS_RDF_TYPE_NSEC3_SALT:
1033 res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf);
1035 case LDNS_RDF_TYPE_TYPE:
1036 res = ldns_rdf2buffer_str_type(buffer, rdf);
1038 case LDNS_RDF_TYPE_CLASS:
1039 res = ldns_rdf2buffer_str_class(buffer, rdf);
1041 case LDNS_RDF_TYPE_CERT_ALG:
1042 res = ldns_rdf2buffer_str_cert_alg(buffer, rdf);
1044 case LDNS_RDF_TYPE_ALG:
1045 res = ldns_rdf2buffer_str_alg(buffer, rdf);
1047 case LDNS_RDF_TYPE_UNKNOWN:
1048 res = ldns_rdf2buffer_str_unknown(buffer, rdf);
1050 case LDNS_RDF_TYPE_TIME:
1051 res = ldns_rdf2buffer_str_time(buffer, rdf);
1053 case LDNS_RDF_TYPE_LOC:
1054 res = ldns_rdf2buffer_str_loc(buffer, rdf);
1056 case LDNS_RDF_TYPE_WKS:
1057 case LDNS_RDF_TYPE_SERVICE:
1058 res = ldns_rdf2buffer_str_wks(buffer, rdf);
1060 case LDNS_RDF_TYPE_NSAP:
1061 res = ldns_rdf2buffer_str_nsap(buffer, rdf);
1063 case LDNS_RDF_TYPE_ATMA:
1064 res = ldns_rdf2buffer_str_atma(buffer, rdf);
1066 case LDNS_RDF_TYPE_IPSECKEY:
1067 res = ldns_rdf2buffer_str_ipseckey(buffer, rdf);
1069 case LDNS_RDF_TYPE_TSIG:
1070 res = ldns_rdf2buffer_str_tsig(buffer, rdf);
1072 case LDNS_RDF_TYPE_INT16_DATA:
1073 res = ldns_rdf2buffer_str_int16_data(buffer, rdf);
1075 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
1076 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1080 ldns_buffer_printf(buffer, "(null) ");
1082 return LDNS_STATUS_OK;
1086 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
1089 ldns_status status = LDNS_STATUS_OK;
1091 ldns_buffer_printf(output, "(null)\n");
1093 if (ldns_rr_owner(rr)) {
1094 status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr));
1096 if (status != LDNS_STATUS_OK) {
1100 /* TTL should NOT be printed if it is a question */
1101 if (!ldns_rr_is_question(rr)) {
1102 ldns_buffer_printf(output, "\t%d", ldns_rr_ttl(rr));
1105 ldns_buffer_printf(output, "\t");
1106 status = ldns_rr_class2buffer_str(output, ldns_rr_get_class(rr));
1107 if (status != LDNS_STATUS_OK) {
1110 ldns_buffer_printf(output, "\t");
1112 status = ldns_rr_type2buffer_str(output, ldns_rr_get_type(rr));
1113 if (status != LDNS_STATUS_OK) {
1117 if (ldns_rr_rd_count(rr) > 0) {
1118 ldns_buffer_printf(output, "\t");
1119 } else if (!ldns_rr_is_question(rr)) {
1120 ldns_buffer_printf(output, "\t\\# 0");
1123 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1124 status = ldns_rdf2buffer_str(output, ldns_rr_rdf(rr, i));
1125 if (i < ldns_rr_rd_count(rr) - 1) {
1126 ldns_buffer_printf(output, " ");
1129 /* per RR special comments - handy for DNSSEC types */
1130 /* check to prevent question sec. rr from
1132 if (ldns_rr_rd_count(rr) > 0) {
1133 switch (ldns_rr_get_type(rr)) {
1134 case LDNS_RR_TYPE_DNSKEY:
1135 if (ldns_rr_rdf(rr, 0)) {
1136 flags = ldns_rdf2native_int16(ldns_rr_rdf(rr, 0));
1137 if (flags == 256 || flags == 384) {
1138 ldns_buffer_printf(output,
1139 " ;{id = %d (zsk), size = %db}",
1140 ldns_calc_keytag(rr),
1141 ldns_rr_dnskey_key_size(rr));
1144 if (flags == 257 || flags == 385) {
1145 ldns_buffer_printf(output,
1146 " ;{id = %d (ksk), size = %db}",
1147 ldns_calc_keytag(rr),
1148 ldns_rr_dnskey_key_size(rr));
1151 ldns_buffer_printf(output, " ;{id = %d, size = %db}",
1152 ldns_calc_keytag(rr),
1153 ldns_rr_dnskey_key_size(rr));
1156 case LDNS_RR_TYPE_RRSIG:
1157 ldns_buffer_printf(output, " ;{id = %d}",
1158 ldns_rdf2native_int16(ldns_rr_rdf(rr, 6)));
1160 case LDNS_RR_TYPE_DS:
1162 uint8_t *data = ldns_rdf_data(ldns_rr_rdf(rr, 3));
1163 size_t len = ldns_rdf_size(ldns_rr_rdf(rr, 3));
1164 char *babble = ldns_bubblebabble(data, len);
1165 ldns_buffer_printf(output, " ; %s", babble);
1169 case LDNS_RR_TYPE_NSEC3:
1170 if (ldns_nsec3_optout(rr)) {
1171 ldns_buffer_printf(output, " ; flags: optout");
1180 ldns_buffer_printf(output, "\n");
1182 return ldns_buffer_status(output);
1186 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
1190 for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
1191 (void) ldns_rr2buffer_str(output, ldns_rr_list_rr(list, i));
1193 return ldns_buffer_status(output);
1197 ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
1199 ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
1200 (int) ldns_pkt_get_opcode(pkt));
1201 ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes,
1202 (int) ldns_pkt_get_rcode(pkt));
1204 ldns_buffer_printf(output, ";; ->>HEADER<<- ");
1206 ldns_buffer_printf(output, "opcode: %s, ", opcode->name);
1208 ldns_buffer_printf(output, "opcode: ?? (%u), ",
1209 ldns_pkt_get_opcode(pkt));
1212 ldns_buffer_printf(output, "rcode: %s, ", rcode->name);
1214 ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt));
1216 ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt));
1217 ldns_buffer_printf(output, ";; flags: ");
1219 if (ldns_pkt_qr(pkt)) {
1220 ldns_buffer_printf(output, "qr ");
1222 if (ldns_pkt_aa(pkt)) {
1223 ldns_buffer_printf(output, "aa ");
1225 if (ldns_pkt_tc(pkt)) {
1226 ldns_buffer_printf(output, "tc ");
1228 if (ldns_pkt_rd(pkt)) {
1229 ldns_buffer_printf(output, "rd ");
1231 if (ldns_pkt_cd(pkt)) {
1232 ldns_buffer_printf(output, "cd ");
1234 if (ldns_pkt_ra(pkt)) {
1235 ldns_buffer_printf(output, "ra ");
1237 if (ldns_pkt_ad(pkt)) {
1238 ldns_buffer_printf(output, "ad ");
1240 ldns_buffer_printf(output, "; ");
1241 ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt));
1242 ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt));
1243 ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt));
1244 ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt));
1245 return ldns_buffer_status(output);
1249 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
1252 ldns_status status = LDNS_STATUS_OK;
1254 struct timeval time;
1258 ldns_buffer_printf(output, "null");
1259 return LDNS_STATUS_OK;
1262 if (ldns_buffer_status_ok(output)) {
1263 status = ldns_pktheader2buffer_str(output, pkt);
1264 if (status != LDNS_STATUS_OK) {
1268 ldns_buffer_printf(output, "\n");
1270 ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
1273 for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
1274 status = ldns_rr2buffer_str(output,
1275 ldns_rr_list_rr(ldns_pkt_question(pkt), i));
1276 if (status != LDNS_STATUS_OK) {
1280 ldns_buffer_printf(output, "\n");
1282 ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
1283 for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
1284 status = ldns_rr2buffer_str(output,
1285 ldns_rr_list_rr(ldns_pkt_answer(pkt), i));
1286 if (status != LDNS_STATUS_OK) {
1291 ldns_buffer_printf(output, "\n");
1293 ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
1295 for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
1296 status = ldns_rr2buffer_str(output,
1297 ldns_rr_list_rr(ldns_pkt_authority(pkt), i));
1298 if (status != LDNS_STATUS_OK) {
1302 ldns_buffer_printf(output, "\n");
1304 ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
1305 for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
1306 status = ldns_rr2buffer_str(output,
1307 ldns_rr_list_rr(ldns_pkt_additional(pkt), i));
1308 if (status != LDNS_STATUS_OK) {
1313 ldns_buffer_printf(output, "\n");
1314 /* add some futher fields */
1315 ldns_buffer_printf(output, ";; Query time: %d msec\n",
1316 ldns_pkt_querytime(pkt));
1317 if (ldns_pkt_edns(pkt)) {
1318 ldns_buffer_printf(output,
1319 ";; EDNS: version %u; flags:",
1320 ldns_pkt_edns_version(pkt));
1321 if (ldns_pkt_edns_do(pkt)) {
1322 ldns_buffer_printf(output, " do");
1324 /* the extended rcode is the value set, shifted four bits,
1325 * and or'd with the original rcode */
1326 if (ldns_pkt_edns_extended_rcode(pkt)) {
1327 ldns_buffer_printf(output, " ; ext-rcode: %d",
1328 (ldns_pkt_edns_extended_rcode(pkt) << 4 | ldns_pkt_get_rcode(pkt)));
1330 ldns_buffer_printf(output, " ; udp: %u\n",
1331 ldns_pkt_edns_udp_size(pkt));
1333 if (ldns_pkt_edns_data(pkt)) {
1334 ldns_buffer_printf(output, ";; Data: ");
1335 (void)ldns_rdf2buffer_str(output,
1336 ldns_pkt_edns_data(pkt));
1337 ldns_buffer_printf(output, "\n");
1340 if (ldns_pkt_tsig(pkt)) {
1341 ldns_buffer_printf(output, ";; TSIG:\n;; ");
1342 (void) ldns_rr2buffer_str(output, ldns_pkt_tsig(pkt));
1343 ldns_buffer_printf(output, "\n");
1345 if (ldns_pkt_answerfrom(pkt)) {
1346 tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
1347 ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
1350 time = ldns_pkt_timestamp(pkt);
1351 time_tt = (time_t)time.tv_sec;
1352 ldns_buffer_printf(output, ";; WHEN: %s",
1353 (char*)ctime(&time_tt));
1355 ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n",
1356 (int)ldns_pkt_size(pkt));
1358 return ldns_buffer_status(output);
1365 ldns_hmac_key2buffer_str(ldns_buffer *output, const ldns_key *k)
1369 ldns_rdf *b64_bignum;
1371 ldns_buffer_printf(output, "Key: ");
1373 i = ldns_key_hmac_size(k);
1374 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k));
1375 status = ldns_rdf2buffer_str(output, b64_bignum);
1376 ldns_rdf_deep_free(b64_bignum);
1377 ldns_buffer_printf(output, "\n");
1382 #if defined(HAVE_SSL) && defined(USE_GOST)
1384 ldns_gost_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
1386 unsigned char* pp = NULL;
1388 ldns_rdf *b64_bignum;
1391 ldns_buffer_printf(output, "GostAsn1: ");
1393 ret = i2d_PrivateKey(p, &pp);
1394 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, ret, pp);
1395 status = ldns_rdf2buffer_str(output, b64_bignum);
1397 ldns_rdf_deep_free(b64_bignum);
1399 ldns_buffer_printf(output, "\n");
1405 ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
1407 ldns_status status = LDNS_STATUS_OK;
1408 unsigned char *bignum;
1411 /* not used when ssl is not defined */
1412 ldns_rdf *b64_bignum = NULL;
1417 #endif /* HAVE_SSL */
1420 return LDNS_STATUS_ERR;
1423 bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
1425 return LDNS_STATUS_ERR;
1428 if (ldns_buffer_status_ok(output)) {
1430 switch(ldns_key_algorithm(k)) {
1431 case LDNS_SIGN_RSASHA1:
1432 case LDNS_SIGN_RSASHA1_NSEC3:
1433 case LDNS_SIGN_RSASHA256:
1434 case LDNS_SIGN_RSASHA512:
1435 case LDNS_SIGN_RSAMD5:
1436 /* copied by looking at dnssec-keygen output */
1438 rsa = ldns_key_rsa_key(k);
1440 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
1441 switch(ldns_key_algorithm(k)) {
1442 case LDNS_SIGN_RSAMD5:
1443 ldns_buffer_printf(output,
1444 "Algorithm: %u (RSA)\n",
1447 case LDNS_SIGN_RSASHA1:
1448 ldns_buffer_printf(output,
1449 "Algorithm: %u (RSASHA1)\n",
1452 case LDNS_SIGN_RSASHA1_NSEC3:
1453 ldns_buffer_printf(output,
1454 "Algorithm: %u (RSASHA1_NSEC3)\n",
1455 LDNS_RSASHA1_NSEC3);
1458 case LDNS_SIGN_RSASHA256:
1459 ldns_buffer_printf(output,
1460 "Algorithm: %u (RSASHA256)\n",
1463 case LDNS_SIGN_RSASHA512:
1464 ldns_buffer_printf(output,
1465 "Algorithm: %u (RSASHA512)\n",
1470 fprintf(stderr, "Warning: unknown signature ");
1472 "algorithm type %u\n",
1473 ldns_key_algorithm(k));
1474 ldns_buffer_printf(output,
1475 "Algorithm: %u (Unknown)\n",
1476 ldns_key_algorithm(k));
1480 /* print to buf, convert to bin, convert to b64,
1482 ldns_buffer_printf(output, "Modulus: ");
1483 i = (uint16_t)BN_bn2bin(rsa->n, bignum);
1484 if (i > LDNS_MAX_KEYLEN) {
1487 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1488 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1491 ldns_rdf_deep_free(b64_bignum);
1492 ldns_buffer_printf(output, "\n");
1493 ldns_buffer_printf(output, "PublicExponent: ");
1494 i = (uint16_t)BN_bn2bin(rsa->e, bignum);
1495 if (i > LDNS_MAX_KEYLEN) {
1498 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1499 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1502 ldns_rdf_deep_free(b64_bignum);
1503 ldns_buffer_printf(output, "\n");
1505 ldns_buffer_printf(output, "PrivateExponent: ");
1507 i = (uint16_t)BN_bn2bin(rsa->d, bignum);
1508 if (i > LDNS_MAX_KEYLEN) {
1511 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1512 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1515 ldns_rdf_deep_free(b64_bignum);
1516 ldns_buffer_printf(output, "\n");
1518 ldns_buffer_printf(output, "(Not available)\n");
1521 ldns_buffer_printf(output, "Prime1: ");
1523 i = (uint16_t)BN_bn2bin(rsa->p, bignum);
1524 if (i > LDNS_MAX_KEYLEN) {
1527 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1528 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1531 ldns_rdf_deep_free(b64_bignum);
1532 ldns_buffer_printf(output, "\n");
1534 ldns_buffer_printf(output, "(Not available)\n");
1537 ldns_buffer_printf(output, "Prime2: ");
1539 i = (uint16_t)BN_bn2bin(rsa->q, bignum);
1540 if (i > LDNS_MAX_KEYLEN) {
1543 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1544 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1547 ldns_rdf_deep_free(b64_bignum);
1548 ldns_buffer_printf(output, "\n");
1550 ldns_buffer_printf(output, "(Not available)\n");
1553 ldns_buffer_printf(output, "Exponent1: ");
1555 i = (uint16_t)BN_bn2bin(rsa->dmp1, bignum);
1556 if (i > LDNS_MAX_KEYLEN) {
1559 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1560 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1563 ldns_rdf_deep_free(b64_bignum);
1564 ldns_buffer_printf(output, "\n");
1566 ldns_buffer_printf(output, "(Not available)\n");
1569 ldns_buffer_printf(output, "Exponent2: ");
1571 i = (uint16_t)BN_bn2bin(rsa->dmq1, bignum);
1572 if (i > LDNS_MAX_KEYLEN) {
1575 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1576 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1579 ldns_rdf_deep_free(b64_bignum);
1580 ldns_buffer_printf(output, "\n");
1582 ldns_buffer_printf(output, "(Not available)\n");
1585 ldns_buffer_printf(output, "Coefficient: ");
1587 i = (uint16_t)BN_bn2bin(rsa->iqmp, bignum);
1588 if (i > LDNS_MAX_KEYLEN) {
1591 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1592 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1595 ldns_rdf_deep_free(b64_bignum);
1596 ldns_buffer_printf(output, "\n");
1598 ldns_buffer_printf(output, "(Not available)\n");
1604 case LDNS_SIGN_DSA_NSEC3:
1605 dsa = ldns_key_dsa_key(k);
1607 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
1608 if (ldns_key_algorithm(k) == LDNS_SIGN_DSA) {
1609 ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n");
1610 } else if (ldns_key_algorithm(k) == LDNS_SIGN_DSA_NSEC3) {
1611 ldns_buffer_printf(output,"Algorithm: 6 (DSA_NSEC3)\n");
1614 /* print to buf, convert to bin, convert to b64,
1616 ldns_buffer_printf(output, "Prime(p): ");
1618 i = (uint16_t)BN_bn2bin(dsa->p, bignum);
1619 if (i > LDNS_MAX_KEYLEN) {
1622 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1623 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1626 ldns_rdf_deep_free(b64_bignum);
1627 ldns_buffer_printf(output, "\n");
1629 printf("(Not available)\n");
1632 ldns_buffer_printf(output, "Subprime(q): ");
1634 i = (uint16_t)BN_bn2bin(dsa->q, bignum);
1635 if (i > LDNS_MAX_KEYLEN) {
1638 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1639 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1642 ldns_rdf_deep_free(b64_bignum);
1643 ldns_buffer_printf(output, "\n");
1645 printf("(Not available)\n");
1648 ldns_buffer_printf(output, "Base(g): ");
1650 i = (uint16_t)BN_bn2bin(dsa->g, bignum);
1651 if (i > LDNS_MAX_KEYLEN) {
1654 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1655 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1658 ldns_rdf_deep_free(b64_bignum);
1659 ldns_buffer_printf(output, "\n");
1661 printf("(Not available)\n");
1664 ldns_buffer_printf(output, "Private_value(x): ");
1665 if (dsa->priv_key) {
1666 i = (uint16_t)BN_bn2bin(dsa->priv_key, bignum);
1667 if (i > LDNS_MAX_KEYLEN) {
1670 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1671 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1674 ldns_rdf_deep_free(b64_bignum);
1675 ldns_buffer_printf(output, "\n");
1677 printf("(Not available)\n");
1680 ldns_buffer_printf(output, "Public_value(y): ");
1682 i = (uint16_t)BN_bn2bin(dsa->pub_key, bignum);
1683 if (i > LDNS_MAX_KEYLEN) {
1686 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
1687 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
1690 ldns_rdf_deep_free(b64_bignum);
1691 ldns_buffer_printf(output, "\n");
1693 printf("(Not available)\n");
1696 case LDNS_SIGN_GOST:
1697 /* no format defined, use blob */
1698 #if defined(HAVE_SSL) && defined(USE_GOST)
1699 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1700 ldns_buffer_printf(output, "Algorithm: %d (GOST)\n", LDNS_SIGN_GOST);
1701 status = ldns_gost_key2buffer_str(output, k->_key.key);
1704 case LDNS_SIGN_HMACMD5:
1705 /* there's not much of a format defined for TSIG */
1706 /* It's just a binary blob, Same for all algorithms */
1707 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1708 ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n");
1709 status = ldns_hmac_key2buffer_str(output, k);
1711 case LDNS_SIGN_HMACSHA1:
1712 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1713 ldns_buffer_printf(output, "Algorithm: 158 (HMAC_SHA1)\n");
1714 status = ldns_hmac_key2buffer_str(output, k);
1716 case LDNS_SIGN_HMACSHA256:
1717 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
1718 ldns_buffer_printf(output, "Algorithm: 159 (HMAC_SHA256)\n");
1719 status = ldns_hmac_key2buffer_str(output, k);
1722 #endif /* HAVE_SSL */
1725 LDNS_FREE(b64_bignum);
1728 return ldns_buffer_status(output);
1734 /* compiles warn the label isn't used */
1737 return LDNS_STATUS_ERR;
1738 #endif /* HAVE_SSL */
1743 * Zero terminate the buffer and fix it to the size of the string.
1746 ldns_buffer2str(ldns_buffer *buffer)
1751 /* check if buffer ends with \0, if not, and
1752 if there is space, add it */
1753 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
1754 if (!ldns_buffer_reserve(buffer, 1)) {
1757 ldns_buffer_write_u8(buffer, (uint8_t) '\0');
1758 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
1763 tmp_str = ldns_buffer_export(buffer);
1764 str = LDNS_XMALLOC(char, strlen(tmp_str) + 1);
1765 memcpy(str, tmp_str, strlen(tmp_str) + 1);
1771 ldns_rdf2str(const ldns_rdf *rdf)
1773 char *result = NULL;
1774 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
1776 if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
1777 /* export and return string, destroy rest */
1778 result = ldns_buffer2str(tmp_buffer);
1781 ldns_buffer_free(tmp_buffer);
1786 ldns_rr2str(const ldns_rr *rr)
1788 char *result = NULL;
1789 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
1791 if (ldns_rr2buffer_str(tmp_buffer, rr) == LDNS_STATUS_OK) {
1792 /* export and return string, destroy rest */
1793 result = ldns_buffer2str(tmp_buffer);
1795 ldns_buffer_free(tmp_buffer);
1800 ldns_pkt2str(const ldns_pkt *pkt)
1802 char *result = NULL;
1803 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
1805 if (ldns_pkt2buffer_str(tmp_buffer, pkt) == LDNS_STATUS_OK) {
1806 /* export and return string, destroy rest */
1807 result = ldns_buffer2str(tmp_buffer);
1810 ldns_buffer_free(tmp_buffer);
1815 ldns_key2str(const ldns_key *k)
1817 char *result = NULL;
1818 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
1819 if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) {
1820 /* export and return string, destroy rest */
1821 result = ldns_buffer2str(tmp_buffer);
1823 ldns_buffer_free(tmp_buffer);
1828 ldns_rr_list2str(const ldns_rr_list *list)
1830 char *result = NULL;
1831 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
1834 if (ldns_rr_list2buffer_str(tmp_buffer, list) == LDNS_STATUS_OK) {
1837 ldns_buffer_printf(tmp_buffer, "(null)\n");
1840 /* export and return string, destroy rest */
1841 result = ldns_buffer2str(tmp_buffer);
1842 ldns_buffer_free(tmp_buffer);
1847 ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
1849 char *str = ldns_rdf2str(rdf);
1851 fprintf(output, "%s", str);
1853 fprintf(output, "Unable to convert rdf to string\n");
1859 ldns_rr_print(FILE *output, const ldns_rr *rr)
1861 char *str = ldns_rr2str(rr);
1863 fprintf(output, "%s", str);
1865 fprintf(output, "Unable to convert rr to string\n");
1871 ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
1873 char *str = ldns_pkt2str(pkt);
1875 fprintf(output, "%s", str);
1877 fprintf(output, "Unable to convert packet to string\n");
1883 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
1886 for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
1887 ldns_rr_print(output, ldns_rr_list_rr(lst, i));
1892 ldns_resolver_print(FILE *output, const ldns_resolver *r)
1901 n = ldns_resolver_nameservers(r);
1902 s = ldns_resolver_searchlist(r);
1903 rtt = ldns_resolver_rtt(r);
1905 fprintf(output, "port: %d\n", (int)ldns_resolver_port(r));
1906 fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r));
1907 fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r));
1909 fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r));
1910 fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r));
1911 fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r));
1912 fprintf(output, "fail: %d\n", ldns_resolver_fail(r));
1913 fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r));
1914 fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
1916 fprintf(output, "default domain: ");
1917 ldns_rdf_print(output, ldns_resolver_domain(r));
1918 fprintf(output, "\n");
1920 fprintf(output, "searchlist:\n");
1921 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
1922 fprintf(output, "\t");
1923 ldns_rdf_print(output, s[i]);
1924 fprintf(output, "\n");
1927 fprintf(output, "nameservers:\n");
1928 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
1929 fprintf(output, "\t");
1930 ldns_rdf_print(output, n[i]);
1932 switch ((int)rtt[i]) {
1933 case LDNS_RESOLV_RTT_MIN:
1934 fprintf(output, " - reachable\n");
1936 case LDNS_RESOLV_RTT_INF:
1937 fprintf(output, " - unreachable\n");
1944 ldns_zone_print(FILE *output, const ldns_zone *z)
1946 if(ldns_zone_soa(z))
1947 ldns_rr_print(output, ldns_zone_soa(z));
1948 ldns_rr_list_print(output, ldns_zone_rrs(z));