?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
inet6: require RTF_ANNOUNCE to proxy NS
[dragonfly.git] / contrib / ldns / host2str.c
blob7282db9ee2efed6ba40477e8c7566e766237cf67
1 /*
2 * host2str.c
3 *
4 * conversion routines from the host format
5 * to the presentation format (strings)
6 *
7 * a Net::DNS like library for C
8 *
9 * (c) NLnet Labs, 2004-2006
10 *
11 * See the file LICENSE for the license
12 */
13 #include <ldns/config.h>
14
15 #include <ldns/ldns.h>
16
17 #include <limits.h>
18
19 #ifdef HAVE_SYS_SOCKET_H
20 #include <sys/socket.h>
21 #endif
22 #ifdef HAVE_ARPA_INET_H
23 #include <arpa/inet.h>
24 #endif
25 #ifdef HAVE_NETDB_H
26 #include <netdb.h>
27 #endif
28 #include <time.h>
29 #include <sys/time.h>
30
31 #ifdef HAVE_SSL
32 #include <openssl/bn.h>
33 #include <openssl/rsa.h>
34 #ifdef USE_DSA
35 #include <openssl/dsa.h>
36 #endif
37 #endif
38
39 #ifndef INET_ADDRSTRLEN
40 #define INET_ADDRSTRLEN 16
41 #endif
42 #ifndef INET6_ADDRSTRLEN
43 #define INET6_ADDRSTRLEN 46
44 #endif
45
46 /* Internal helper function */
47 ldns_edns_option_list*
48 pkt_edns_data2edns_option_list(const ldns_rdf *edns_data);
49
50 /* lookup tables for standard DNS stuff */
51
52 /* Taken from RFC 2535, section 7. */
53 ldns_lookup_table ldns_algorithms[] = {
54 { LDNS_RSAMD5, "RSAMD5" },
55 { LDNS_DH, "DH" },
56 { LDNS_DSA, "DSA" },
57 { LDNS_ECC, "ECC" },
58 { LDNS_RSASHA1, "RSASHA1" },
59 { LDNS_DSA_NSEC3, "DSA-NSEC3-SHA1" },
60 { LDNS_RSASHA1_NSEC3, "RSASHA1-NSEC3-SHA1" },
61 { LDNS_RSASHA256, "RSASHA256"},
62 { LDNS_RSASHA512, "RSASHA512"},
63 { LDNS_ECC_GOST, "ECC-GOST"},
64 { LDNS_ECDSAP256SHA256, "ECDSAP256SHA256"},
65 { LDNS_ECDSAP384SHA384, "ECDSAP384SHA384"},
66 { LDNS_ED25519, "ED25519"},
67 { LDNS_ED448, "ED448"},
68 { LDNS_INDIRECT, "INDIRECT" },
69 { LDNS_PRIVATEDNS, "PRIVATEDNS" },
70 { LDNS_PRIVATEOID, "PRIVATEOID" },
71 { 0, NULL }
72 };
73
74 /* Hashing algorithms used in the DS record */
75 ldns_lookup_table ldns_hashes[] = {
76 {LDNS_SHA1 , "SHA1" }, /* RFC 4034 */
77 {LDNS_SHA256 , "SHA256" }, /* RFC 4509 */
78 {LDNS_HASH_GOST, "HASH-GOST" }, /* RFC 5933 */
79 {LDNS_SHA384 , "SHA384" }, /* RFC 6605 */
80 { 0, NULL }
81 };
82
83 /* Taken from RFC 4398 */
84 ldns_lookup_table ldns_cert_algorithms[] = {
85 { LDNS_CERT_PKIX, "PKIX" },
86 { LDNS_CERT_SPKI, "SPKI" },
87 { LDNS_CERT_PGP, "PGP" },
88 { LDNS_CERT_IPKIX, "IPKIX" },
89 { LDNS_CERT_ISPKI, "ISPKI" },
90 { LDNS_CERT_IPGP, "IPGP" },
91 { LDNS_CERT_ACPKIX, "ACPKIX" },
92 { LDNS_CERT_IACPKIX, "IACPKIX" },
93 { LDNS_CERT_URI, "URI" },
94 { LDNS_CERT_OID, "OID" },
95 { 0, NULL }
96 };
97
98 /* classes */
99 ldns_lookup_table ldns_rr_classes[] = {
100 { LDNS_RR_CLASS_IN, "IN" },
101 { LDNS_RR_CLASS_CH, "CH" },
102 { LDNS_RR_CLASS_HS, "HS" },
103 { LDNS_RR_CLASS_NONE, "NONE" },
104 { LDNS_RR_CLASS_ANY, "ANY" },
105 { 0, NULL }
106 };
107
108 /* if these are used elsewhere */
109 ldns_lookup_table ldns_rcodes[] = {
110 { LDNS_RCODE_NOERROR, "NOERROR" },
111 { LDNS_RCODE_FORMERR, "FORMERR" },
112 { LDNS_RCODE_SERVFAIL, "SERVFAIL" },
113 { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" },
114 { LDNS_RCODE_NOTIMPL, "NOTIMPL" },
115 { LDNS_RCODE_REFUSED, "REFUSED" },
116 { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" },
117 { LDNS_RCODE_YXRRSET, "YXRRSET" },
118 { LDNS_RCODE_NXRRSET, "NXRRSET" },
119 { LDNS_RCODE_NOTAUTH, "NOTAUTH" },
120 { LDNS_RCODE_NOTZONE, "NOTZONE" },
121 { 0, NULL }
122 };
123
124 ldns_lookup_table ldns_opcodes[] = {
125 { LDNS_PACKET_QUERY, "QUERY" },
126 { LDNS_PACKET_IQUERY, "IQUERY" },
127 { LDNS_PACKET_STATUS, "STATUS" },
128 { LDNS_PACKET_NOTIFY, "NOTIFY" },
129 { LDNS_PACKET_UPDATE, "UPDATE" },
130 { 0, NULL }
131 };
132
133 const ldns_output_format ldns_output_format_nocomments_record = { 0, NULL };
134 const ldns_output_format *ldns_output_format_nocomments
135 = &ldns_output_format_nocomments_record;
136 const ldns_output_format ldns_output_format_onlykeyids_record = {
137 LDNS_COMMENT_KEY, NULL
138 };
139 const ldns_output_format *ldns_output_format_onlykeyids
140 = &ldns_output_format_onlykeyids_record;
141 const ldns_output_format *ldns_output_format_default
142 = &ldns_output_format_onlykeyids_record;
143
144 const ldns_output_format ldns_output_format_bubblebabble_record = {
145 LDNS_COMMENT_KEY | LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS, NULL
146 };
147 const ldns_output_format *ldns_output_format_bubblebabble
148 = &ldns_output_format_bubblebabble_record;
149
150 static bool
151 ldns_output_format_covers_type(const ldns_output_format* fmt, ldns_rr_type t)
152 {
153 return fmt && (fmt->flags & LDNS_FMT_RFC3597) &&
154 ((ldns_output_format_storage*)fmt)->bitmap &&
155 ldns_nsec_bitmap_covers_type(
156 ((ldns_output_format_storage*)fmt)->bitmap, t);
157 }
158
159 ldns_status
160 ldns_output_format_set_type(ldns_output_format* fmt, ldns_rr_type t)
161 {
162 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
163 ldns_status s;
164
165 assert(fmt != NULL);
166
167 if (!(fmt_st->flags & LDNS_FMT_RFC3597)) {
168 ldns_output_format_set(fmt, LDNS_FMT_RFC3597);
169 }
170 if (! fmt_st->bitmap) {
171 s = ldns_rdf_bitmap_known_rr_types_space(&fmt_st->bitmap);
172 if (s != LDNS_STATUS_OK) {
173 return s;
174 }
175 }
176 return ldns_nsec_bitmap_set_type(fmt_st->bitmap, t);
177 }
178
179 ldns_status
180 ldns_output_format_clear_type(ldns_output_format* fmt, ldns_rr_type t)
181 {
182 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
183 ldns_status s;
184
185 assert(fmt != NULL);
186
187 if (!(fmt_st->flags & LDNS_FMT_RFC3597)) {
188 ldns_output_format_set(fmt, LDNS_FMT_RFC3597);
189 }
190 if (! fmt_st->bitmap) {
191 s = ldns_rdf_bitmap_known_rr_types(&fmt_st->bitmap);
192 if (s != LDNS_STATUS_OK) {
193 return s;
194 }
195 }
196 return ldns_nsec_bitmap_clear_type(fmt_st->bitmap, t);
197 }
198
199 ldns_status
200 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode)
201 {
202 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode);
203 if (lt && lt->name) {
204 ldns_buffer_printf(output, "%s", lt->name);
205 } else {
206 ldns_buffer_printf(output, "OPCODE%u", opcode);
207 }
208 return ldns_buffer_status(output);
209 }
210
211 ldns_status
212 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode)
213 {
214 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode);
215 if (lt && lt->name) {
216 ldns_buffer_printf(output, "%s", lt->name);
217 } else {
218 ldns_buffer_printf(output, "RCODE%u", rcode);
219 }
220 return ldns_buffer_status(output);
221 }
222
223 ldns_status
224 ldns_algorithm2buffer_str(ldns_buffer *output,
225 ldns_algorithm algorithm)
226 {
227 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_algorithms,
228 algorithm);
229 if (lt && lt->name) {
230 ldns_buffer_printf(output, "%s", lt->name);
231 } else {
232 ldns_buffer_printf(output, "ALG%u", algorithm);
233 }
234 return ldns_buffer_status(output);
235 }
236
237 ldns_status
238 ldns_cert_algorithm2buffer_str(ldns_buffer *output,
239 ldns_cert_algorithm cert_algorithm)
240 {
241 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_cert_algorithms,
242 cert_algorithm);
243 if (lt && lt->name) {
244 ldns_buffer_printf(output, "%s", lt->name);
245 } else {
246 ldns_buffer_printf(output, "CERT_ALG%u",
247 cert_algorithm);
248 }
249 return ldns_buffer_status(output);
250 }
251
252 char *
253 ldns_pkt_opcode2str(ldns_pkt_opcode opcode)
254 {
255 char *str;
256 ldns_buffer *buf;
257
258 buf = ldns_buffer_new(12);
259 if (!buf) {
260 return NULL;
261 }
262
263 str = NULL;
264 if (ldns_pkt_opcode2buffer_str(buf, opcode) == LDNS_STATUS_OK) {
265 str = ldns_buffer_export2str(buf);
266 }
267
268 ldns_buffer_free(buf);
269 return str;
270 }
271
272 char *
273 ldns_pkt_rcode2str(ldns_pkt_rcode rcode)
274 {
275 char *str;
276 ldns_buffer *buf;
277
278 buf = ldns_buffer_new(10);
279 if (!buf) {
280 return NULL;
281 }
282
283 str = NULL;
284 if (ldns_pkt_rcode2buffer_str(buf, rcode) == LDNS_STATUS_OK) {
285 str = ldns_buffer_export2str(buf);
286 }
287
288 ldns_buffer_free(buf);
289 return str;
290 }
291
292 char *
293 ldns_pkt_algorithm2str(ldns_algorithm algorithm)
294 {
295 char *str;
296 ldns_buffer *buf;
297
298 buf = ldns_buffer_new(10);
299 if (!buf) {
300 return NULL;
301 }
302
303 str = NULL;
304 if (ldns_algorithm2buffer_str(buf, algorithm)
305 == LDNS_STATUS_OK) {
306 str = ldns_buffer_export2str(buf);
307 }
308
309 ldns_buffer_free(buf);
310 return str;
311 }
312
313 char *
314 ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm)
315 {
316 char *str;
317 ldns_buffer *buf;
318
319 buf = ldns_buffer_new(10);
320 if (!buf) {
321 return NULL;
322 }
323
324 str = NULL;
325 if (ldns_cert_algorithm2buffer_str(buf, cert_algorithm)
326 == LDNS_STATUS_OK) {
327 str = ldns_buffer_export2str(buf);
328 }
329
330 ldns_buffer_free(buf);
331 return str;
332 }
333
334
335 /* do NOT pass compressed data here :p */
336 ldns_status
337 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
338 {
339 /* can we do with 1 pos var? or without at all? */
340 uint8_t src_pos = 0;
341 uint8_t len;
342 uint8_t *data;
343 uint8_t i;
344 unsigned char c;
345
346 data = (uint8_t*)ldns_rdf_data(dname);
347 len = data[src_pos];
348
349 if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) {
350 /* too large, return */
351 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
352 }
353
354 /* special case: root label */
355 if (1 == ldns_rdf_size(dname)) {
356 ldns_buffer_printf(output, ".");
357 } else {
358 while ((len > 0) && src_pos < ldns_rdf_size(dname)) {
359 src_pos++;
360 for(i = 0; i < len; i++) {
361 /* paranoia check for various 'strange'
362 characters in dnames
363 */
364 c = (unsigned char) data[src_pos];
365 if(c == '.' || c == ';' ||
366 c == '(' || c == ')' ||
367 c == '\\') {
368 ldns_buffer_printf(output, "\\%c",
369 data[src_pos]);
370 } else if (!(isascii(c) && isgraph(c))) {
371 ldns_buffer_printf(output, "\\%03u",
372 data[src_pos]);
373 } else {
374 ldns_buffer_printf(output, "%c", data[src_pos]);
375 }
376 src_pos++;
377 }
378
379 if (src_pos < ldns_rdf_size(dname)) {
380 ldns_buffer_printf(output, ".");
381 }
382 len = data[src_pos];
383 }
384 }
385 return ldns_buffer_status(output);
386 }
387
388 ldns_status
389 ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
390 {
391 uint8_t data = ldns_rdf_data(rdf)[0];
392 ldns_buffer_printf(output, "%lu", (unsigned long) data);
393 return ldns_buffer_status(output);
394 }
395
396 ldns_status
397 ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
398 {
399 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
400 ldns_buffer_printf(output, "%lu", (unsigned long) data);
401 return ldns_buffer_status(output);
402 }
403
404 ldns_status
405 ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
406 {
407 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
408 ldns_buffer_printf(output, "%lu", (unsigned long) data);
409 return ldns_buffer_status(output);
410 }
411
412 ldns_status
413 ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
414 {
415 /* create a YYYYMMDDHHMMSS string if possible */
416 struct tm tm;
417 char date_buf[16];
418
419 memset(&tm, 0, sizeof(tm));
420 if (ldns_serial_arithmetics_gmtime_r(ldns_rdf2native_int32(rdf), time(NULL), &tm)
421 && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
422 ldns_buffer_printf(output, "%s", date_buf);
423 }
424 return ldns_buffer_status(output);
425 }
426
427 ldns_status
428 ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
429 {
430 char str[INET_ADDRSTRLEN];
431
432 if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) {
433 ldns_buffer_printf(output, "%s", str);
434 }
435 return ldns_buffer_status(output);
436 }
437
438 ldns_status
439 ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
440 {
441 char str[INET6_ADDRSTRLEN];
442
443 if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) {
444 ldns_buffer_printf(output, "%s", str);
445 }
446
447 return ldns_buffer_status(output);
448 }
449
450 static void
451 ldns_characters2buffer_str(ldns_buffer* output,
452 size_t amount, const uint8_t* characters)
453 {
454 uint8_t ch;
455 while (amount > 0) {
456 ch = *characters++;
457 if (isprint((int)ch) || ch == '\t') {
458 if (ch == '\"' || ch == '\\')
459 ldns_buffer_printf(output, "\\%c", ch);
460 else
461 ldns_buffer_printf(output, "%c", ch);
462 } else {
463 ldns_buffer_printf(output, "\\%03u",
464 (unsigned)(uint8_t) ch);
465 }
466 amount--;
467 }
468 }
469
470 ldns_status
471 ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
472 {
473 if(ldns_rdf_size(rdf) < 1) {
474 return LDNS_STATUS_WIRE_RDATA_ERR;
475 }
476 if((int)ldns_rdf_size(rdf) < (int)ldns_rdf_data(rdf)[0] + 1) {
477 return LDNS_STATUS_WIRE_RDATA_ERR;
478 }
479 ldns_buffer_printf(output, "\"");
480 ldns_characters2buffer_str(output,
481 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf) + 1);
482 ldns_buffer_printf(output, "\"");
483 return ldns_buffer_status(output);
484 }
485
486 ldns_status
487 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
488 {
489 size_t size;
490 char *b64;
491
492 if (ldns_rdf_size(rdf) == 0) {
493 ldns_buffer_printf(output, "0");
494 return ldns_buffer_status(output);
495 } else
496 size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf));
497
498 if (!(b64 = LDNS_XMALLOC(char, size)))
499 return LDNS_STATUS_MEM_ERR;
500
501 if (ldns_b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) {
502 ldns_buffer_printf(output, "%s", b64);
503 }
504 LDNS_FREE(b64);
505 return ldns_buffer_status(output);
506 }
507
508 ldns_status
509 ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf)
510 {
511 size_t size;
512 char *b32;
513 if(ldns_rdf_size(rdf) == 0)
514 return LDNS_STATUS_OK;
515 /* remove -1 for the b32-hash-len octet */
516 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
517 /* add one for the end nul for the string */
518 b32 = LDNS_XMALLOC(char, size + 1);
519 if(!b32) return LDNS_STATUS_MEM_ERR;
520 size = (size_t) ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
521 ldns_rdf_size(rdf) - 1, b32, size+1);
522 if (size > 0) {
523 ldns_buffer_printf(output, "%s", b32);
524 }
525 LDNS_FREE(b32);
526 return ldns_buffer_status(output);
527 }
528
529 ldns_status
530 ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
531 {
532 size_t i;
533 for (i = 0; i < ldns_rdf_size(rdf); i++) {
534 ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]);
535 }
536
537 return ldns_buffer_status(output);
538 }
539
540 static ldns_status
541 ldns_rdf2buffer_str_type_fmt(ldns_buffer *output,
542 const ldns_output_format* fmt, const ldns_rdf *rdf)
543 {
544 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
545
546 if (! ldns_output_format_covers_type(fmt, data) &&
547 ldns_rr_descript(data) &&
548 ldns_rr_descript(data)->_name) {
549
550 ldns_buffer_printf(output, "%s",ldns_rr_descript(data)->_name);
551 } else {
552 ldns_buffer_printf(output, "TYPE%u", data);
553 }
554 return ldns_buffer_status(output);
555 }
556
557 ldns_status
558 ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
559 {
560 return ldns_rdf2buffer_str_type_fmt(output,
561 ldns_output_format_default, rdf);
562 }
563
564 ldns_status
565 ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
566 {
567 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
568 ldns_lookup_table *lt;
569
570 lt = ldns_lookup_by_id(ldns_rr_classes, (int) data);
571 if (lt) {
572 ldns_buffer_printf(output, "\t%s", lt->name);
573 } else {
574 ldns_buffer_printf(output, "\tCLASS%d", data);
575 }
576 return ldns_buffer_status(output);
577 }
578
579 ldns_status
580 ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
581 {
582 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
583 ldns_lookup_table *lt;
584 lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data);
585 if (lt) {
586 ldns_buffer_printf(output, "%s", lt->name);
587 } else {
588 ldns_buffer_printf(output, "%d", data);
589 }
590 return ldns_buffer_status(output);
591 }
592
593 ldns_status
594 ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
595 {
596 return ldns_rdf2buffer_str_int8(output, rdf);
597 }
598
599 static void
600 loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
601 {
602 uint8_t i;
603 /* is it 0.<two digits> ? */
604 if(exponent < 2) {
605 if(exponent == 1)
606 mantissa *= 10;
607 ldns_buffer_printf(output, "0.%02ld", (long)mantissa);
608 return;
609 }
610 /* always <digit><string of zeros> */
611 ldns_buffer_printf(output, "%d", (int)mantissa);
612 for(i=0; i<exponent-2; i++)
613 ldns_buffer_printf(output, "0");
614 }
615
616 ldns_status
617 ldns_rr_type2buffer_str(ldns_buffer *output, const ldns_rr_type type)
618 {
619 const ldns_rr_descriptor *descriptor;
620
621 descriptor = ldns_rr_descript(type);
622
623 switch (type) {
624 case LDNS_RR_TYPE_IXFR:
625 ldns_buffer_printf(output, "IXFR");
626 break;
627 case LDNS_RR_TYPE_AXFR:
628 ldns_buffer_printf(output, "AXFR");
629 break;
630 case LDNS_RR_TYPE_MAILA:
631 ldns_buffer_printf(output, "MAILA");
632 break;
633 case LDNS_RR_TYPE_MAILB:
634 ldns_buffer_printf(output, "MAILB");
635 break;
636 case LDNS_RR_TYPE_ANY:
637 ldns_buffer_printf(output, "ANY");
638 break;
639 default:
640 if (descriptor && descriptor->_name) {
641 ldns_buffer_printf(output, "%s", descriptor->_name);
642 } else {
643 ldns_buffer_printf(output, "TYPE%u", type);
644 }
645 }
646 return ldns_buffer_status(output);
647 }
648
649 char *
650 ldns_rr_type2str(const ldns_rr_type type)
651 {
652 char *str;
653 ldns_buffer *buf;
654
655 buf = ldns_buffer_new(10);
656 if (!buf) {
657 return NULL;
658 }
659
660 str = NULL;
661 if (ldns_rr_type2buffer_str(buf, type) == LDNS_STATUS_OK) {
662 str = ldns_buffer_export2str(buf);
663 }
664
665 ldns_buffer_free(buf);
666 return str;
667 }
668
669
670 ldns_status
671 ldns_rr_class2buffer_str(ldns_buffer *output,
672 const ldns_rr_class klass)
673 {
674 ldns_lookup_table *lt;
675
676 lt = ldns_lookup_by_id(ldns_rr_classes, klass);
677 if (lt) {
678 ldns_buffer_printf(output, "%s", lt->name);
679 } else {
680 ldns_buffer_printf(output, "CLASS%d", klass);
681 }
682 return ldns_buffer_status(output);
683 }
684
685 char *
686 ldns_rr_class2str(const ldns_rr_class klass)
687 {
688 ldns_buffer *buf;
689 char *str;
690
691 buf = ldns_buffer_new(10);
692 if (!buf) {
693 return NULL;
694 }
695
696 str = NULL;
697 if (ldns_rr_class2buffer_str(buf, klass) == LDNS_STATUS_OK) {
698 str = ldns_buffer_export2str(buf);
699 }
700 ldns_buffer_free(buf);
701 return str;
702 }
703
704 ldns_status
705 ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
706 {
707 /* we could do checking (ie degrees < 90 etc)? */
708 uint8_t version;
709 uint8_t size;
710 uint8_t horizontal_precision;
711 uint8_t vertical_precision;
712 uint32_t longitude;
713 uint32_t latitude;
714 uint32_t altitude;
715 char latitude_hemisphere;
716 char longitude_hemisphere;
717 uint32_t h;
718 uint32_t m;
719 double s;
720
721 uint32_t equator = (uint32_t) ldns_power(2, 31);
722
723 if(ldns_rdf_size(rdf) < 1) {
724 return LDNS_STATUS_WIRE_RDATA_ERR;
725 }
726 version = ldns_rdf_data(rdf)[0];
727 if (version == 0) {
728 if(ldns_rdf_size(rdf) < 16) {
729 return LDNS_STATUS_WIRE_RDATA_ERR;
730 }
731 size = ldns_rdf_data(rdf)[1];
732 horizontal_precision = ldns_rdf_data(rdf)[2];
733 vertical_precision = ldns_rdf_data(rdf)[3];
734
735 latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]);
736 longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]);
737 altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]);
738
739 if (latitude > equator) {
740 latitude_hemisphere = 'N';
741 latitude = latitude - equator;
742 } else {
743 latitude_hemisphere = 'S';
744 latitude = equator - latitude;
745 }
746 h = latitude / (1000 * 60 * 60);
747 latitude = latitude % (1000 * 60 * 60);
748 m = latitude / (1000 * 60);
749 latitude = latitude % (1000 * 60);
750 s = (double) latitude / 1000.0;
751 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
752 h, m, s, latitude_hemisphere);
753
754 if (longitude > equator) {
755 longitude_hemisphere = 'E';
756 longitude = longitude - equator;
757 } else {
758 longitude_hemisphere = 'W';
759 longitude = equator - longitude;
760 }
761 h = longitude / (1000 * 60 * 60);
762 longitude = longitude % (1000 * 60 * 60);
763 m = longitude / (1000 * 60);
764 longitude = longitude % (1000 * 60);
765 s = (double) longitude / (1000.0);
766 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
767 h, m, s, longitude_hemisphere);
768
769 s = ((double) altitude) / 100;
770 s -= 100000;
771
772 if(altitude%100 != 0)
773 ldns_buffer_printf(output, "%.2f", s);
774 else
775 ldns_buffer_printf(output, "%.0f", s);
776
777 ldns_buffer_printf(output, "m ");
778
779 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
780 ldns_buffer_printf(output, "m ");
781
782 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
783 horizontal_precision & 0x0f);
784 ldns_buffer_printf(output, "m ");
785
786 loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
787 vertical_precision & 0x0f);
788 ldns_buffer_printf(output, "m");
789
790 return ldns_buffer_status(output);
791 } else {
792 return ldns_rdf2buffer_str_hex(output, rdf);
793 }
794 }
795
796 ldns_status
797 ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
798 {
799 ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
800 return ldns_rdf2buffer_str_hex(output, rdf);
801 }
802
803 ldns_status
804 ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
805 {
806 ldns_buffer_printf(output, "0x");
807 return ldns_rdf2buffer_str_hex(output, rdf);
808 }
809
810 ldns_status
811 ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf)
812 {
813 return ldns_rdf2buffer_str_hex(output, rdf);
814 }
815
816 ldns_status
817 ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
818 {
819 /* protocol, followed by bitmap of services */
820 struct protoent *protocol;
821 char *proto_name = NULL;
822 uint8_t protocol_nr;
823 struct servent *service;
824 uint16_t current_service;
825
826 if(ldns_rdf_size(rdf) < 1) {
827 return LDNS_STATUS_WIRE_RDATA_ERR;
828 }
829 protocol_nr = ldns_rdf_data(rdf)[0];
830 protocol = getprotobynumber((int) protocol_nr);
831 if (protocol && (protocol->p_name != NULL)) {
832 proto_name = protocol->p_name;
833 ldns_buffer_printf(output, "%s ", protocol->p_name);
834 } else {
835 ldns_buffer_printf(output, "%u ", protocol_nr);
836 }
837
838 #ifdef HAVE_ENDPROTOENT
839 endprotoent();
840 #endif
841
842 for (current_service = 0;
843 current_service < (ldns_rdf_size(rdf)-1)*8; current_service++) {
844 if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) {
845 service = getservbyport((int) htons(current_service),
846 proto_name);
847 if (service && service->s_name) {
848 ldns_buffer_printf(output, "%s ", service->s_name);
849 } else {
850 ldns_buffer_printf(output, "%u ", current_service);
851 }
852 #ifdef HAVE_ENDSERVENT
853 endservent();
854 #endif
855 }
856 /* exit from loop before integer overflow */
857 if(current_service == 65535) { break; }
858 }
859 return ldns_buffer_status(output);
860 }
861
862 static ldns_status
863 ldns_rdf2buffer_str_nsec_fmt(ldns_buffer *output,
864 const ldns_output_format* fmt, const ldns_rdf *rdf)
865 {
866 /* Note: this code is duplicated in higher.c in
867 * ldns_nsec_type_check() function
868 */
869 uint8_t window_block_nr;
870 uint8_t bitmap_length;
871 uint16_t type;
872 uint16_t pos = 0;
873 uint16_t bit_pos;
874 uint8_t *data = ldns_rdf_data(rdf);
875
876 while((size_t)(pos + 2) < ldns_rdf_size(rdf)) {
877 window_block_nr = data[pos];
878 bitmap_length = data[pos + 1];
879 pos += 2;
880 if (ldns_rdf_size(rdf) < pos + bitmap_length) {
881 return LDNS_STATUS_WIRE_RDATA_ERR;
882 }
883 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
884 if (! ldns_get_bit(&data[pos], bit_pos)) {
885 continue;
886 }
887 type = 256 * (uint16_t) window_block_nr + bit_pos;
888
889 if (! ldns_output_format_covers_type(fmt, type) &&
890 ldns_rr_descript(type) &&
891 ldns_rr_descript(type)->_name){
892
893 ldns_buffer_printf(output, "%s ",
894 ldns_rr_descript(type)->_name);
895 } else {
896 ldns_buffer_printf(output, "TYPE%u ", type);
897 }
898 }
899 pos += (uint16_t) bitmap_length;
900 }
901 return ldns_buffer_status(output);
902 }
903
904 ldns_status
905 ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
906 {
907 return ldns_rdf2buffer_str_nsec_fmt(output,
908 ldns_output_format_default, rdf);
909 }
910
911 ldns_status
912 ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf)
913 {
914 uint8_t salt_length;
915 uint8_t salt_pos;
916
917 uint8_t *data = ldns_rdf_data(rdf);
918
919 if(ldns_rdf_size(rdf) < 1) {
920 return LDNS_STATUS_WIRE_RDATA_ERR;
921 }
922 salt_length = data[0];
923 /* from now there are variable length entries so remember pos */
924 if (salt_length == 0 || ((size_t)salt_length)+1 > ldns_rdf_size(rdf)) {
925 ldns_buffer_printf(output, "- ");
926 } else {
927 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) {
928 ldns_buffer_printf(output, "%02x", data[1 + salt_pos]);
929 }
930 ldns_buffer_printf(output, " ");
931 }
932
933 return ldns_buffer_status(output);
934 }
935
936 ldns_status
937 ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
938 {
939 /* period is the number of seconds */
940 if (ldns_rdf_size(rdf) != 4) {
941 return LDNS_STATUS_WIRE_RDATA_ERR;
942 }
943 ldns_buffer_printf(output, "%u", ldns_read_uint32(ldns_rdf_data(rdf)));
944 return ldns_buffer_status(output);
945 }
946
947 ldns_status
948 ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf)
949 {
950 /* tsigtime is 48 bits network order unsigned integer */
951 uint64_t tsigtime = 0;
952 uint8_t *data = ldns_rdf_data(rdf);
953 uint64_t d0, d1, d2, d3, d4, d5;
954
955 if (ldns_rdf_size(rdf) < 6) {
956 return LDNS_STATUS_WIRE_RDATA_ERR;
957 }
958 d0 = data[0]; /* cast to uint64 for shift operations */
959 d1 = data[1];
960 d2 = data[2];
961 d3 = data[3];
962 d4 = data[4];
963 d5 = data[5];
964 tsigtime = (d0<<40) | (d1<<32) | (d2<<24) | (d3<<16) | (d4<<8) | d5;
965
966 ldns_buffer_printf(output, "%llu ", (long long)tsigtime);
967
968 return ldns_buffer_status(output);
969 }
970
971 ldns_status
972 ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
973 {
974 uint8_t *data = ldns_rdf_data(rdf);
975 uint16_t address_family;
976 uint8_t prefix;
977 bool negation;
978 uint8_t adf_length;
979 size_t i;
980 size_t pos = 0;
981
982 while (pos < (unsigned int) ldns_rdf_size(rdf)) {
983 if(pos + 3 >= (unsigned)ldns_rdf_size(rdf))
984 return LDNS_STATUS_WIRE_RDATA_ERR;
985 address_family = ldns_read_uint16(&data[pos]);
986 prefix = data[pos + 2];
987 negation = data[pos + 3] & LDNS_APL_NEGATION;
988 adf_length = data[pos + 3] & LDNS_APL_MASK;
989 if (address_family == LDNS_APL_IP4) {
990 /* check if prefix < 32? */
991 if (negation) {
992 ldns_buffer_printf(output, "!");
993 }
994 ldns_buffer_printf(output, "%u:", address_family);
995 /* address is variable length 0 - 4 */
996 for (i = 0; i < 4; i++) {
997 if (i > 0) {
998 ldns_buffer_printf(output, ".");
999 }
1000 if (i < (unsigned short) adf_length) {
1001 if(pos+i+4 >= ldns_rdf_size(rdf))
1002 return LDNS_STATUS_WIRE_RDATA_ERR;
1003 ldns_buffer_printf(output, "%d",
1004 data[pos + i + 4]);
1005 } else {
1006 ldns_buffer_printf(output, "0");
1007 }
1008 }
1009 ldns_buffer_printf(output, "/%u ", prefix);
1010 } else if (address_family == LDNS_APL_IP6) {
1011 /* check if prefix < 128? */
1012 if (negation) {
1013 ldns_buffer_printf(output, "!");
1014 }
1015 ldns_buffer_printf(output, "%u:", address_family);
1016 /* address is variable length 0 - 16 */
1017 for (i = 0; i < 16; i++) {
1018 if (i % 2 == 0 && i > 0) {
1019 ldns_buffer_printf(output, ":");
1020 }
1021 if (i < (unsigned short) adf_length) {
1022 if(pos+i+4 >= ldns_rdf_size(rdf))
1023 return LDNS_STATUS_WIRE_RDATA_ERR;
1024 ldns_buffer_printf(output, "%02x",
1025 data[pos + i + 4]);
1026 } else {
1027 ldns_buffer_printf(output, "00");
1028 }
1029 }
1030 ldns_buffer_printf(output, "/%u ", prefix);
1031
1032 } else {
1033 /* unknown address family */
1034 ldns_buffer_printf(output,
1035 "Unknown address family: %u data: ",
1036 address_family);
1037 for (i = 1; i < (unsigned short) (4 + adf_length); i++) {
1038 if(pos+i >= ldns_rdf_size(rdf))
1039 return LDNS_STATUS_WIRE_RDATA_ERR;
1040 ldns_buffer_printf(output, "%02x", data[i]);
1041 }
1042 }
1043 pos += 4 + adf_length;
1044 }
1045 return ldns_buffer_status(output);
1046 }
1047
1048 ldns_status
1049 ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
1050 {
1051 size_t size;
1052 char *b64;
1053 if (ldns_rdf_size(rdf) < 2) {
1054 return LDNS_STATUS_WIRE_RDATA_ERR;
1055 }
1056 /* Subtract the size (2) of the number that specifies the length */
1057 size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
1058 ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
1059 if (ldns_rdf_size(rdf) > 2) {
1060 b64 = LDNS_XMALLOC(char, size);
1061 if(!b64)
1062 return LDNS_STATUS_MEM_ERR;
1063
1064 if (ldns_rdf_size(rdf) > 2 &&
1065 ldns_b64_ntop(ldns_rdf_data(rdf) + 2,
1066 ldns_rdf_size(rdf) - 2,
1067 b64, size)) {
1068 ldns_buffer_printf(output, "%s", b64);
1069 }
1070 LDNS_FREE(b64);
1071 }
1072 return ldns_buffer_status(output);
1073 }
1074
1075 ldns_status
1076 ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
1077 {
1078 /* wire format from
1079 http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt
1080 */
1081 uint8_t *data = ldns_rdf_data(rdf);
1082 uint8_t precedence;
1083 uint8_t gateway_type;
1084 uint8_t algorithm;
1085
1086 ldns_rdf *gateway = NULL;
1087 uint8_t *gateway_data;
1088
1089 size_t public_key_size;
1090 uint8_t *public_key_data;
1091 ldns_rdf *public_key;
1092
1093 size_t offset = 0;
1094 ldns_status status;
1095
1096 if (ldns_rdf_size(rdf) < 3) {
1097 return LDNS_STATUS_WIRE_RDATA_ERR;
1098 }
1099 precedence = data[0];
1100 gateway_type = data[1];
1101 algorithm = data[2];
1102 offset = 3;
1103
1104 switch (gateway_type) {
1105 case 0:
1106 /* no gateway */
1107 break;
1108 case 1:
1109 if (ldns_rdf_size(rdf) < offset + LDNS_IP4ADDRLEN) {
1110 return LDNS_STATUS_ERR;
1111 }
1112 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
1113 if(!gateway_data)
1114 return LDNS_STATUS_MEM_ERR;
1115 memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
1116 gateway = ldns_rdf_new(LDNS_RDF_TYPE_A,
1117 LDNS_IP4ADDRLEN , gateway_data);
1118 offset += LDNS_IP4ADDRLEN;
1119 if(!gateway) {
1120 LDNS_FREE(gateway_data);
1121 return LDNS_STATUS_MEM_ERR;
1122 }
1123 break;
1124 case 2:
1125 if (ldns_rdf_size(rdf) < offset + LDNS_IP6ADDRLEN) {
1126 return LDNS_STATUS_ERR;
1127 }
1128 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
1129 if(!gateway_data)
1130 return LDNS_STATUS_MEM_ERR;
1131 memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
1132 offset += LDNS_IP6ADDRLEN;
1133 gateway =
1134 ldns_rdf_new(LDNS_RDF_TYPE_AAAA,
1135 LDNS_IP6ADDRLEN, gateway_data);
1136 if(!gateway) {
1137 LDNS_FREE(gateway_data);
1138 return LDNS_STATUS_MEM_ERR;
1139 }
1140 break;
1141 case 3:
1142 status = ldns_wire2dname(&gateway, data,
1143 ldns_rdf_size(rdf), &offset);
1144 if(status != LDNS_STATUS_OK)
1145 return status;
1146 break;
1147 default:
1148 /* error? */
1149 break;
1150 }
1151
1152 if (ldns_rdf_size(rdf) <= offset) {
1153 ldns_rdf_deep_free(gateway);
1154 return LDNS_STATUS_ERR;
1155 }
1156 public_key_size = ldns_rdf_size(rdf) - offset;
1157 public_key_data = LDNS_XMALLOC(uint8_t, public_key_size);
1158 if(!public_key_data) {
1159 ldns_rdf_deep_free(gateway);
1160 return LDNS_STATUS_MEM_ERR;
1161 }
1162 memcpy(public_key_data, &data[offset], public_key_size);
1163 public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64,
1164 public_key_size, public_key_data);
1165 if(!public_key) {
1166 LDNS_FREE(public_key_data);
1167 ldns_rdf_deep_free(gateway);
1168 return LDNS_STATUS_MEM_ERR;
1169 }
1170
1171 ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm);
1172 if (gateway)
1173 (void) ldns_rdf2buffer_str(output, gateway);
1174 else
1175 ldns_buffer_printf(output, ".");
1176 ldns_buffer_printf(output, " ");
1177 (void) ldns_rdf2buffer_str(output, public_key);
1178
1179 ldns_rdf_deep_free(gateway);
1180 ldns_rdf_deep_free(public_key);
1181
1182 return ldns_buffer_status(output);
1183 }
1184
1185 ldns_status
1186 ldns_rdf2buffer_str_ilnp64(ldns_buffer *output, const ldns_rdf *rdf)
1187 {
1188 if (ldns_rdf_size(rdf) != 8) {
1189 return LDNS_STATUS_WIRE_RDATA_ERR;
1190 }
1191 ldns_buffer_printf(output,"%.4x:%.4x:%.4x:%.4x",
1192 ldns_read_uint16(ldns_rdf_data(rdf)),
1193 ldns_read_uint16(ldns_rdf_data(rdf)+2),
1194 ldns_read_uint16(ldns_rdf_data(rdf)+4),
1195 ldns_read_uint16(ldns_rdf_data(rdf)+6));
1196 return ldns_buffer_status(output);
1197 }
1198
1199 ldns_status
1200 ldns_rdf2buffer_str_eui48(ldns_buffer *output, const ldns_rdf *rdf)
1201 {
1202 if (ldns_rdf_size(rdf) != 6) {
1203 return LDNS_STATUS_WIRE_RDATA_ERR;
1204 }
1205 ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
1206 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1],
1207 ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3],
1208 ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5]);
1209 return ldns_buffer_status(output);
1210 }
1211
1212 ldns_status
1213 ldns_rdf2buffer_str_eui64(ldns_buffer *output, const ldns_rdf *rdf)
1214 {
1215 if (ldns_rdf_size(rdf) != 8) {
1216 return LDNS_STATUS_WIRE_RDATA_ERR;
1217 }
1218 ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
1219 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1],
1220 ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3],
1221 ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5],
1222 ldns_rdf_data(rdf)[6], ldns_rdf_data(rdf)[7]);
1223 return ldns_buffer_status(output);
1224 }
1225
1226 ldns_status
1227 ldns_rdf2buffer_str_tag(ldns_buffer *output, const ldns_rdf *rdf)
1228 {
1229 size_t nchars;
1230 const uint8_t* chars;
1231 char ch;
1232 if (ldns_rdf_size(rdf) < 2) {
1233 return LDNS_STATUS_WIRE_RDATA_ERR;
1234 }
1235 nchars = ldns_rdf_data(rdf)[0];
1236 if (nchars >= ldns_rdf_size(rdf) || /* should be rdf_size - 1 */
1237 nchars < 1) {
1238 return LDNS_STATUS_WIRE_RDATA_ERR;
1239 }
1240 chars = ldns_rdf_data(rdf) + 1;
1241 while (nchars > 0) {
1242 ch = (char)*chars++;
1243 if (! isalnum((unsigned char)ch)) {
1244 return LDNS_STATUS_WIRE_RDATA_ERR;
1245 }
1246 ldns_buffer_printf(output, "%c", ch);
1247 nchars--;
1248 }
1249 return ldns_buffer_status(output);
1250 }
1251
1252 ldns_status
1253 ldns_rdf2buffer_str_long_str(ldns_buffer *output, const ldns_rdf *rdf)
1254 {
1255
1256 ldns_buffer_printf(output, "\"");
1257 ldns_characters2buffer_str(output,
1258 ldns_rdf_size(rdf), ldns_rdf_data(rdf));
1259 ldns_buffer_printf(output, "\"");
1260 return ldns_buffer_status(output);
1261 }
1262
1263 ldns_status
1264 ldns_rdf2buffer_str_hip(ldns_buffer *output, const ldns_rdf *rdf)
1265 {
1266 uint8_t *data = ldns_rdf_data(rdf);
1267 size_t rdf_size = ldns_rdf_size(rdf);
1268 uint8_t hit_size;
1269 uint16_t pk_size;
1270 int written;
1271
1272 if (rdf_size < 6) {
1273 return LDNS_STATUS_WIRE_RDATA_ERR;
1274 }
1275 if ((hit_size = data[0]) == 0 ||
1276 (pk_size = ldns_read_uint16(data + 2)) == 0 ||
1277 rdf_size < (size_t) hit_size + pk_size + 4) {
1278
1279 return LDNS_STATUS_WIRE_RDATA_ERR;
1280 }
1281
1282 ldns_buffer_printf(output, "%d ", (int) data[1]);
1283
1284 for (data += 4; hit_size > 0; hit_size--, data++) {
1285
1286 ldns_buffer_printf(output, "%02x", (int) *data);
1287 }
1288 ldns_buffer_write_char(output, (uint8_t) ' ');
1289
1290 if (ldns_buffer_reserve(output,
1291 ldns_b64_ntop_calculate_size(pk_size))) {
1292
1293 written = ldns_b64_ntop(data, pk_size,
1294 (char *) ldns_buffer_current(output),
1295 ldns_buffer_remaining(output));
1296
1297 if (written > 0 &&
1298 written < (int) ldns_buffer_remaining(output)) {
1299
1300 output->_position += written;
1301 }
1302 }
1303 return ldns_buffer_status(output);
1304 }
1305
1306 /* implementation mimicked from ldns_rdf2buffer_str_ipseckey */
1307 ldns_status
1308 ldns_rdf2buffer_str_amtrelay(ldns_buffer *output, const ldns_rdf *rdf)
1309 {
1310 /* wire format from
1311 * draft-ietf-mboned-driad-amt-discovery Section 4.2
1312 */
1313 uint8_t *data = ldns_rdf_data(rdf);
1314 uint8_t precedence;
1315 uint8_t discovery_optional;
1316 uint8_t relay_type;
1317
1318 ldns_rdf *relay = NULL;
1319 uint8_t *relay_data;
1320
1321 size_t offset = 0;
1322 ldns_status status;
1323
1324 if (ldns_rdf_size(rdf) < 2) {
1325 return LDNS_STATUS_WIRE_RDATA_ERR;
1326 }
1327 precedence = data[0];
1328 discovery_optional = ((data[1] & 0x80) >> 7);
1329 relay_type = data[1] & 0x7F;
1330 offset = 2;
1331
1332 switch (relay_type) {
1333 case 0:
1334 /* no relay */
1335 break;
1336 case 1:
1337 if (ldns_rdf_size(rdf) < offset + LDNS_IP4ADDRLEN) {
1338 return LDNS_STATUS_ERR;
1339 }
1340 relay_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
1341 if(!relay_data)
1342 return LDNS_STATUS_MEM_ERR;
1343 memcpy(relay_data, &data[offset], LDNS_IP4ADDRLEN);
1344 relay = ldns_rdf_new(LDNS_RDF_TYPE_A,
1345 LDNS_IP4ADDRLEN , relay_data);
1346 offset += LDNS_IP4ADDRLEN;
1347 if(!relay) {
1348 LDNS_FREE(relay_data);
1349 return LDNS_STATUS_MEM_ERR;
1350 }
1351 break;
1352 case 2:
1353 if (ldns_rdf_size(rdf) < offset + LDNS_IP6ADDRLEN) {
1354 return LDNS_STATUS_ERR;
1355 }
1356 relay_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
1357 if(!relay_data)
1358 return LDNS_STATUS_MEM_ERR;
1359 memcpy(relay_data, &data[offset], LDNS_IP6ADDRLEN);
1360 offset += LDNS_IP6ADDRLEN;
1361 relay =
1362 ldns_rdf_new(LDNS_RDF_TYPE_AAAA,
1363 LDNS_IP6ADDRLEN, relay_data);
1364 if(!relay) {
1365 LDNS_FREE(relay_data);
1366 return LDNS_STATUS_MEM_ERR;
1367 }
1368 break;
1369 case 3:
1370 status = ldns_wire2dname(&relay, data,
1371 ldns_rdf_size(rdf), &offset);
1372 if(status != LDNS_STATUS_OK)
1373 return status;
1374 break;
1375 default:
1376 /* error? */
1377 break;
1378 }
1379
1380 if (ldns_rdf_size(rdf) != offset) {
1381 ldns_rdf_deep_free(relay);
1382 return LDNS_STATUS_ERR;
1383 }
1384 ldns_buffer_printf(output, "%u %u %u ",
1385 precedence, discovery_optional, relay_type);
1386 if (relay)
1387 (void) ldns_rdf2buffer_str(output, relay);
1388
1389 ldns_rdf_deep_free(relay);
1390 return ldns_buffer_status(output);
1391 }
1392
1393 #ifdef RRTYPE_SVCB_HTTPS
1394 ldns_status svcparam_key2buffer_str(ldns_buffer *output, uint16_t key);
1395
1396 static ldns_status
1397 svcparam_mandatory2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1398 {
1399 if (sz % 2)
1400 return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1401
1402 svcparam_key2buffer_str(output, ldns_read_uint16(data));
1403 for (data += 2, sz -= 2; sz; data += 2, sz -= 2) {
1404 ldns_buffer_write_char(output, ',');
1405 svcparam_key2buffer_str(output, ldns_read_uint16(data));
1406 }
1407 return ldns_buffer_status(output);
1408 }
1409
1410 static ldns_status
1411 svcparam_alpn2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1412 {
1413 uint8_t *eod = data + sz, *dp;
1414 bool quote = false;
1415 size_t i;
1416
1417 for (dp = data; dp < eod && !quote; dp += 1 + *dp) {
1418 if (dp + 1 + *dp > eod)
1419 return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1420
1421 for (i = 0; i < *dp; i++)
1422 if (isspace(dp[i + 1]))
1423 break;
1424 quote = i < *dp;
1425 }
1426 if (quote)
1427 ldns_buffer_write_char(output, '"');
1428 while (data < eod) {
1429 uint8_t *eot = data + 1 + *data;
1430
1431 if (eot > eod)
1432 return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1433
1434 if (eod - data < (int)sz)
1435 ldns_buffer_write_char(output, ',');
1436
1437 for (data += 1; data < eot; data += 1) {
1438 uint8_t ch = *data;
1439
1440 if (isprint(ch) || ch == '\t') {
1441 if (ch == '"' || ch == ',' || ch == '\\')
1442 ldns_buffer_write_char(output, '\\');
1443 ldns_buffer_write_char(output, ch);
1444 } else
1445 ldns_buffer_printf(output, "\\%03u"
1446 , (unsigned)ch);
1447 }
1448 }
1449 if (quote)
1450 ldns_buffer_write_char(output, '"');
1451 return ldns_buffer_status(output);
1452 }
1453
1454 static ldns_status
1455 svcparam_port2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1456 {
1457 if (sz != 2)
1458 return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1459 ldns_buffer_printf(output, "%d", (int)ldns_read_uint16(data));
1460 return ldns_buffer_status(output);
1461 }
1462
1463 static ldns_status
1464 svcparam_ipv4hint2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1465 {
1466 char str[INET_ADDRSTRLEN];
1467
1468 if (sz % 4 || !inet_ntop(AF_INET, data, str, INET_ADDRSTRLEN))
1469 return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1470
1471 ldns_buffer_write_chars(output, str);
1472
1473 for (data += 4, sz -= 4; sz ; data += 4, sz -= 4 ) {
1474 ldns_buffer_write_char(output, ',');
1475 if (!inet_ntop(AF_INET, data, str, INET_ADDRSTRLEN))
1476 return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1477
1478 ldns_buffer_write_chars(output, str);
1479 }
1480 return ldns_buffer_status(output);
1481 }
1482
1483 static ldns_status
1484 svcparam_ech2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1485 {
1486 size_t str_sz = ldns_b64_ntop_calculate_size(sz);
1487 int written;
1488
1489 if (!ldns_buffer_reserve(output, str_sz))
1490 return LDNS_STATUS_MEM_ERR;
1491
1492 written = ldns_b64_ntop( data, sz
1493 , (char *)ldns_buffer_current(output), str_sz);
1494 if (written > 0)
1495 ldns_buffer_skip(output, written);
1496 else
1497 return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1498
1499 return ldns_buffer_status(output);
1500 }
1501
1502 static ldns_status
1503 svcparam_ipv6hint2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1504 {
1505 char str[INET6_ADDRSTRLEN];
1506
1507 if (sz % 16 || !inet_ntop(AF_INET6, data, str, INET6_ADDRSTRLEN))
1508 return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1509
1510 ldns_buffer_write_chars(output, str);
1511
1512 for (data += 16, sz -= 16; sz ; data += 16, sz -= 16) {
1513 ldns_buffer_write_char(output, ',');
1514 if (!inet_ntop(AF_INET6, data, str, INET6_ADDRSTRLEN))
1515 return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1516
1517 ldns_buffer_write_chars(output, str);
1518 }
1519 return ldns_buffer_status(output);
1520 }
1521
1522 static ldns_status
1523 svcparam_value2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1524 {
1525 uint8_t *eod = data + sz, *dp;
1526 bool quote = false;
1527
1528 for (dp = data; dp < eod && !isspace(*dp); dp++)
1529 ; /* pass */
1530
1531 if ((quote = dp < eod))
1532 ldns_buffer_write_char(output, '"');
1533
1534 for (dp = data; dp < eod; dp++) {
1535 uint8_t ch = *dp;
1536
1537 if (isprint(ch) || ch == '\t') {
1538 if (ch == '"' || ch == '\\')
1539 ldns_buffer_write_char(output, '\\');
1540 ldns_buffer_write_char(output, ch);
1541 } else
1542 ldns_buffer_printf(output, "\\%03u", (unsigned)ch);
1543 }
1544 if (quote)
1545 ldns_buffer_write_char(output, '"');
1546 return ldns_buffer_status(output);
1547 }
1548
1549 ldns_status
1550 ldns_rdf2buffer_str_svcparams(ldns_buffer *output, const ldns_rdf *rdf)
1551 {
1552 uint8_t *data, *dp, *next_dp = NULL;
1553 size_t sz;
1554 ldns_status st;
1555
1556 if (!output)
1557 return LDNS_STATUS_NULL;
1558
1559 if (!rdf || !(data = ldns_rdf_data(rdf)) || !(sz = ldns_rdf_size(rdf)))
1560 /* No svcparams is just fine. Just nothing to print. */
1561 return LDNS_STATUS_OK;
1562
1563 for (dp = data; dp + 4 <= data + sz; dp = next_dp) {
1564 ldns_svcparam_key key = ldns_read_uint16(dp);
1565 uint16_t val_sz = ldns_read_uint16(dp + 2);
1566
1567 if ((next_dp = dp + 4 + val_sz) > data + sz)
1568 return LDNS_STATUS_RDATA_OVERFLOW;
1569
1570 if (dp > data)
1571 ldns_buffer_write_char(output, ' ');
1572
1573 if ((st = svcparam_key2buffer_str(output, key)))
1574 return st;
1575
1576 if (val_sz == 0)
1577 continue;
1578 dp += 4;
1579 ldns_buffer_write_char(output, '=');
1580 switch (key) {
1581 case LDNS_SVCPARAM_KEY_MANDATORY:
1582 st = svcparam_mandatory2buffer_str(output, val_sz, dp);
1583 break;
1584 case LDNS_SVCPARAM_KEY_ALPN:
1585 st = svcparam_alpn2buffer_str(output, val_sz, dp);
1586 break;
1587 case LDNS_SVCPARAM_KEY_NO_DEFAULT_ALPN:
1588 return LDNS_STATUS_NO_SVCPARAM_VALUE_EXPECTED;
1589 case LDNS_SVCPARAM_KEY_PORT:
1590 st = svcparam_port2buffer_str(output, val_sz, dp);
1591 break;
1592 case LDNS_SVCPARAM_KEY_IPV4HINT:
1593 st = svcparam_ipv4hint2buffer_str(output, val_sz, dp);
1594 break;
1595 case LDNS_SVCPARAM_KEY_ECH:
1596 st = svcparam_ech2buffer_str(output, val_sz, dp);
1597 break;
1598 case LDNS_SVCPARAM_KEY_IPV6HINT:
1599 st = svcparam_ipv6hint2buffer_str(output, val_sz, dp);
1600 break;
1601 default:
1602 st = svcparam_value2buffer_str(output, val_sz, dp);
1603 break;
1604 }
1605 if (st)
1606 return st;
1607 }
1608 return ldns_buffer_status(output);
1609 }
1610 #else /* #ifdef RRTYPE_SVCB_HTTPS */
1611 ldns_status
1612 ldns_rdf2buffer_str_svcparams(ldns_buffer *output, const ldns_rdf *rdf)
1613 {
1614 (void)output; (void)rdf;
1615 return LDNS_STATUS_NOT_IMPL;
1616 }
1617 #endif /* #ifdef RRTYPE_SVCB_HTTPS */
1618
1619 static ldns_status
1620 ldns_rdf2buffer_str_fmt(ldns_buffer *buffer,
1621 const ldns_output_format* fmt, const ldns_rdf *rdf)
1622 {
1623 ldns_status res = LDNS_STATUS_OK;
1624
1625 /*ldns_buffer_printf(buffer, "%u:", ldns_rdf_get_type(rdf));*/
1626 if (rdf) {
1627 switch(ldns_rdf_get_type(rdf)) {
1628 case LDNS_RDF_TYPE_NONE:
1629 break;
1630 case LDNS_RDF_TYPE_DNAME:
1631 res = ldns_rdf2buffer_str_dname(buffer, rdf);
1632 break;
1633 case LDNS_RDF_TYPE_INT8: /* Don't output mnemonics for these */
1634 case LDNS_RDF_TYPE_ALG:
1635 case LDNS_RDF_TYPE_CERTIFICATE_USAGE:
1636 case LDNS_RDF_TYPE_SELECTOR:
1637 case LDNS_RDF_TYPE_MATCHING_TYPE:
1638 res = ldns_rdf2buffer_str_int8(buffer, rdf);
1639 break;
1640 case LDNS_RDF_TYPE_INT16:
1641 res = ldns_rdf2buffer_str_int16(buffer, rdf);
1642 break;
1643 case LDNS_RDF_TYPE_INT32:
1644 res = ldns_rdf2buffer_str_int32(buffer, rdf);
1645 break;
1646 case LDNS_RDF_TYPE_PERIOD:
1647 res = ldns_rdf2buffer_str_period(buffer, rdf);
1648 break;
1649 case LDNS_RDF_TYPE_TSIGTIME:
1650 res = ldns_rdf2buffer_str_tsigtime(buffer, rdf);
1651 break;
1652 case LDNS_RDF_TYPE_A:
1653 res = ldns_rdf2buffer_str_a(buffer, rdf);
1654 break;
1655 case LDNS_RDF_TYPE_AAAA:
1656 res = ldns_rdf2buffer_str_aaaa(buffer, rdf);
1657 break;
1658 case LDNS_RDF_TYPE_STR:
1659 res = ldns_rdf2buffer_str_str(buffer, rdf);
1660 break;
1661 case LDNS_RDF_TYPE_APL:
1662 res = ldns_rdf2buffer_str_apl(buffer, rdf);
1663 break;
1664 case LDNS_RDF_TYPE_B32_EXT:
1665 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1666 break;
1667 case LDNS_RDF_TYPE_B64:
1668 res = ldns_rdf2buffer_str_b64(buffer, rdf);
1669 break;
1670 case LDNS_RDF_TYPE_HEX:
1671 res = ldns_rdf2buffer_str_hex(buffer, rdf);
1672 break;
1673 case LDNS_RDF_TYPE_NSEC:
1674 res = ldns_rdf2buffer_str_nsec_fmt(buffer, fmt, rdf);
1675 break;
1676 case LDNS_RDF_TYPE_NSEC3_SALT:
1677 res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf);
1678 break;
1679 case LDNS_RDF_TYPE_TYPE:
1680 res = ldns_rdf2buffer_str_type_fmt(buffer, fmt, rdf);
1681 break;
1682 case LDNS_RDF_TYPE_CLASS:
1683 res = ldns_rdf2buffer_str_class(buffer, rdf);
1684 break;
1685 case LDNS_RDF_TYPE_CERT_ALG:
1686 res = ldns_rdf2buffer_str_cert_alg(buffer, rdf);
1687 break;
1688 case LDNS_RDF_TYPE_UNKNOWN:
1689 res = ldns_rdf2buffer_str_unknown(buffer, rdf);
1690 break;
1691 case LDNS_RDF_TYPE_TIME:
1692 res = ldns_rdf2buffer_str_time(buffer, rdf);
1693 break;
1694 case LDNS_RDF_TYPE_HIP:
1695 res = ldns_rdf2buffer_str_hip(buffer, rdf);
1696 break;
1697 case LDNS_RDF_TYPE_LOC:
1698 res = ldns_rdf2buffer_str_loc(buffer, rdf);
1699 break;
1700 case LDNS_RDF_TYPE_WKS:
1701 case LDNS_RDF_TYPE_SERVICE:
1702 res = ldns_rdf2buffer_str_wks(buffer, rdf);
1703 break;
1704 case LDNS_RDF_TYPE_NSAP:
1705 res = ldns_rdf2buffer_str_nsap(buffer, rdf);
1706 break;
1707 case LDNS_RDF_TYPE_ATMA:
1708 res = ldns_rdf2buffer_str_atma(buffer, rdf);
1709 break;
1710 case LDNS_RDF_TYPE_IPSECKEY:
1711 res = ldns_rdf2buffer_str_ipseckey(buffer, rdf);
1712 break;
1713 case LDNS_RDF_TYPE_INT16_DATA:
1714 res = ldns_rdf2buffer_str_int16_data(buffer, rdf);
1715 break;
1716 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
1717 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1718 break;
1719 case LDNS_RDF_TYPE_ILNP64:
1720 res = ldns_rdf2buffer_str_ilnp64(buffer, rdf);
1721 break;
1722 case LDNS_RDF_TYPE_EUI48:
1723 res = ldns_rdf2buffer_str_eui48(buffer, rdf);
1724 break;
1725 case LDNS_RDF_TYPE_EUI64:
1726 res = ldns_rdf2buffer_str_eui64(buffer, rdf);
1727 break;
1728 case LDNS_RDF_TYPE_TAG:
1729 res = ldns_rdf2buffer_str_tag(buffer, rdf);
1730 break;
1731 case LDNS_RDF_TYPE_LONG_STR:
1732 res = ldns_rdf2buffer_str_long_str(buffer, rdf);
1733 break;
1734 case LDNS_RDF_TYPE_AMTRELAY:
1735 res = ldns_rdf2buffer_str_amtrelay(buffer, rdf);
1736 break;
1737 case LDNS_RDF_TYPE_SVCPARAMS:
1738 res = ldns_rdf2buffer_str_svcparams(buffer, rdf);
1739 break;
1740 }
1741 } else {
1742 /** This will write mangled RRs */
1743 ldns_buffer_printf(buffer, "(null) ");
1744 res = LDNS_STATUS_ERR;
1745 }
1746 return res;
1747 }
1748
1749 ldns_status
1750 ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
1751 {
1752 return ldns_rdf2buffer_str_fmt(buffer,ldns_output_format_default,rdf);
1753 }
1754
1755 static ldns_rdf *
1756 ldns_b32_ext2dname(const ldns_rdf *rdf)
1757 {
1758 size_t size;
1759 char *b32;
1760 ldns_rdf *out;
1761 if(ldns_rdf_size(rdf) == 0)
1762 return NULL;
1763 /* remove -1 for the b32-hash-len octet */
1764 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
1765 /* add one for the end nul for the string */
1766 b32 = LDNS_XMALLOC(char, size + 2);
1767 if (b32) {
1768 if (ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
1769 ldns_rdf_size(rdf) - 1, b32, size+1) > 0) {
1770 b32[size] = '.';
1771 b32[size+1] = '\0';
1772 if (ldns_str2rdf_dname(&out, b32) == LDNS_STATUS_OK) {
1773 LDNS_FREE(b32);
1774 return out;
1775 }
1776 }
1777 LDNS_FREE(b32);
1778 }
1779 return NULL;
1780 }
1781
1782 static ldns_status
1783 ldns_rr2buffer_str_rfc3597(ldns_buffer *output, const ldns_rr *rr)
1784 {
1785 size_t total_rdfsize = 0;
1786 size_t i, j;
1787
1788 ldns_buffer_printf(output, "TYPE%u\t", ldns_rr_get_type(rr));
1789 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1790 total_rdfsize += ldns_rdf_size(ldns_rr_rdf(rr, i));
1791 }
1792 if (total_rdfsize == 0) {
1793 ldns_buffer_printf(output, "\\# 0\n");
1794 return ldns_buffer_status(output);
1795 }
1796 ldns_buffer_printf(output, "\\# %d ", total_rdfsize);
1797 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1798 for (j = 0; j < ldns_rdf_size(ldns_rr_rdf(rr, i)); j++) {
1799 ldns_buffer_printf(output, "%.2x",
1800 ldns_rdf_data(ldns_rr_rdf(rr, i))[j]);
1801 }
1802 }
1803 ldns_buffer_printf(output, "\n");
1804 return ldns_buffer_status(output);
1805 }
1806
1807 ldns_status
1808 ldns_rr2buffer_str_fmt(ldns_buffer *output,
1809 const ldns_output_format *fmt, const ldns_rr *rr)
1810 {
1811 uint16_t i, flags;
1812 ldns_status status = LDNS_STATUS_OK;
1813 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
1814
1815 if (fmt_st == NULL) {
1816 fmt_st = (ldns_output_format_storage*)
1817 ldns_output_format_default;
1818 }
1819 if (!(fmt_st->flags & LDNS_FMT_SHORT)) {
1820 if (!rr) {
1821 if (LDNS_COMMENT_NULLS & fmt_st->flags) {
1822 ldns_buffer_printf(output, "; (null)\n");
1823 }
1824 return ldns_buffer_status(output);
1825 }
1826 if (ldns_rr_owner(rr)) {
1827 status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr));
1828 }
1829 if (status != LDNS_STATUS_OK) {
1830 return status;
1831 }
1832
1833 /* TTL should NOT be printed if it is a question */
1834 if (!ldns_rr_is_question(rr)) {
1835 ldns_buffer_printf(output, "\t%u", (unsigned)ldns_rr_ttl(rr));
1836 }
1837
1838 ldns_buffer_printf(output, "\t");
1839 status = ldns_rr_class2buffer_str(output, ldns_rr_get_class(rr));
1840 if (status != LDNS_STATUS_OK) {
1841 return status;
1842 }
1843 ldns_buffer_printf(output, "\t");
1844
1845 if (ldns_output_format_covers_type(fmt, ldns_rr_get_type(rr))) {
1846 return ldns_rr2buffer_str_rfc3597(output, rr);
1847 }
1848 status = ldns_rr_type2buffer_str(output, ldns_rr_get_type(rr));
1849 if (status != LDNS_STATUS_OK) {
1850 return status;
1851 }
1852
1853 if (ldns_rr_rd_count(rr) > 0) {
1854 ldns_buffer_printf(output, "\t");
1855 } else if (!ldns_rr_is_question(rr)) {
1856 ldns_buffer_printf(output, "\t\\# 0");
1857 }
1858 } else if (ldns_rr_rd_count(rr) == 0) {
1859 /* assert(fmt_st->flags & LDNS_FMT_SHORT); */
1860
1861 ldns_buffer_printf(output, "# 0");
1862 }
1863 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1864 /* ldns_rdf2buffer_str handles NULL input fine! */
1865 if ((fmt_st->flags & LDNS_FMT_ZEROIZE_RRSIGS) &&
1866 (ldns_rr_get_type(rr) == LDNS_RR_TYPE_RRSIG) &&
1867 ((/* inception */ i == 4 &&
1868 ldns_rdf_get_type(ldns_rr_rdf(rr, 4)) ==
1869 LDNS_RDF_TYPE_TIME) ||
1870 (/* expiration */ i == 5 &&
1871 ldns_rdf_get_type(ldns_rr_rdf(rr, 5)) ==
1872 LDNS_RDF_TYPE_TIME) ||
1873 (/* signature */ i == 8 &&
1874 ldns_rdf_get_type(ldns_rr_rdf(rr, 8)) ==
1875 LDNS_RDF_TYPE_B64))) {
1876
1877 ldns_buffer_printf(output, "(null)");
1878 status = ldns_buffer_status(output);
1879 } else if ((fmt_st->flags & LDNS_FMT_PAD_SOA_SERIAL) &&
1880 (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) &&
1881 /* serial */ i == 2 &&
1882 ldns_rdf_get_type(ldns_rr_rdf(rr, 2)) ==
1883 LDNS_RDF_TYPE_INT32) {
1884 ldns_buffer_printf(output, "%10lu",
1885 (unsigned long) ldns_read_uint32(
1886 ldns_rdf_data(ldns_rr_rdf(rr, 2))));
1887 status = ldns_buffer_status(output);
1888 } else {
1889 status = ldns_rdf2buffer_str_fmt(output,
1890 fmt, ldns_rr_rdf(rr, i));
1891 }
1892 if(status != LDNS_STATUS_OK)
1893 return status;
1894 if (i < ldns_rr_rd_count(rr) - 1) {
1895 ldns_buffer_printf(output, " ");
1896 }
1897 }
1898 /* per RR special comments - handy for DNSSEC types */
1899 /* check to prevent question sec. rr from
1900 * getting here */
1901 if (ldns_rr_rd_count(rr) > 0) {
1902 switch (ldns_rr_get_type(rr)) {
1903 case LDNS_RR_TYPE_DNSKEY:
1904 /* if ldns_rr_rd_count(rr) > 0
1905 then ldns_rr_rdf(rr, 0) exists! */
1906 if (! (fmt_st->flags & LDNS_COMMENT_KEY)) {
1907 break;
1908 }
1909 flags = ldns_rdf2native_int16(ldns_rr_rdf(rr, 0));
1910 ldns_buffer_printf(output, " ;{");
1911 if (fmt_st->flags & LDNS_COMMENT_KEY_ID) {
1912 ldns_buffer_printf(output, "id = %u",
1913 (unsigned int) ldns_calc_keytag(rr));
1914 }
1915 if ((fmt_st->flags & LDNS_COMMENT_KEY_TYPE) &&
1916 (flags & LDNS_KEY_ZONE_KEY)){
1917
1918 if (flags & LDNS_KEY_SEP_KEY) {
1919 ldns_buffer_printf(output, " (ksk)");
1920 } else {
1921 ldns_buffer_printf(output, " (zsk)");
1922 }
1923 if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE){
1924 ldns_buffer_printf(output, ", ");
1925 }
1926 } else if (fmt_st->flags
1927 & (LDNS_COMMENT_KEY_ID
1928 |LDNS_COMMENT_KEY_SIZE)) {
1929 ldns_buffer_printf( output, ", ");
1930 }
1931 if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE) {
1932 ldns_buffer_printf(output, "size = %db",
1933 ldns_rr_dnskey_key_size(rr));
1934 }
1935 ldns_buffer_printf(output, "}");
1936 break;
1937 case LDNS_RR_TYPE_RRSIG:
1938 if ((fmt_st->flags & LDNS_COMMENT_KEY)
1939 && (fmt_st->flags& LDNS_COMMENT_RRSIGS)
1940 && ldns_rr_rdf(rr, 6) != NULL) {
1941 ldns_buffer_printf(output, " ;{id = %d}",
1942 ldns_rdf2native_int16(
1943 ldns_rr_rdf(rr, 6)));
1944 }
1945 break;
1946 case LDNS_RR_TYPE_DS:
1947 if ((fmt_st->flags & LDNS_COMMENT_BUBBLEBABBLE) &&
1948 ldns_rr_rdf(rr, 3) != NULL) {
1949
1950 uint8_t *data = ldns_rdf_data(
1951 ldns_rr_rdf(rr, 3));
1952 size_t len = ldns_rdf_size(ldns_rr_rdf(rr, 3));
1953 char *babble = ldns_bubblebabble(data, len);
1954 if(babble) {
1955 ldns_buffer_printf(output,
1956 " ;{%s}", babble);
1957 }
1958 LDNS_FREE(babble);
1959 }
1960 break;
1961 case LDNS_RR_TYPE_NSEC3:
1962 if (! (fmt_st->flags & LDNS_COMMENT_FLAGS) &&
1963 ! (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN)) {
1964 break;
1965 }
1966 ldns_buffer_printf(output, " ;{");
1967 if ((fmt_st->flags & LDNS_COMMENT_FLAGS)) {
1968 if (ldns_nsec3_optout(rr)) {
1969 ldns_buffer_printf(output,
1970 " flags: optout");
1971 } else {
1972 ldns_buffer_printf(output," flags: -");
1973 }
1974 if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN &&
1975 fmt_st->hashmap != NULL) {
1976 ldns_buffer_printf(output, ", ");
1977 }
1978 }
1979 if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN &&
1980 fmt_st->hashmap != NULL) {
1981 ldns_rbnode_t *node;
1982 ldns_rdf *key = ldns_dname_label(
1983 ldns_rr_owner(rr), 0);
1984 if (key) {
1985 node = ldns_rbtree_search(
1986 fmt_st->hashmap,
1987 (void *) key);
1988 if (node->data) {
1989 ldns_buffer_printf(output,
1990 "from: ");
1991 (void) ldns_rdf2buffer_str(
1992 output,
1993 ldns_dnssec_name_name(
1994 (ldns_dnssec_name*)
1995 node->data
1996 ));
1997 }
1998 ldns_rdf_deep_free(key);
1999 }
2000 key = ldns_b32_ext2dname(
2001 ldns_nsec3_next_owner(rr));
2002 if (key) {
2003 node = ldns_rbtree_search(
2004 fmt_st->hashmap,
2005 (void *) key);
2006 if (node->data) {
2007 ldns_buffer_printf(output,
2008 " to: ");
2009 (void) ldns_rdf2buffer_str(
2010 output,
2011 ldns_dnssec_name_name(
2012 (ldns_dnssec_name*)
2013 node->data
2014 ));
2015 }
2016 ldns_rdf_deep_free(key);
2017 }
2018 }
2019 ldns_buffer_printf(output, "}");
2020 break;
2021 default:
2022 break;
2023
2024 }
2025 }
2026 /* last */
2027 ldns_buffer_printf(output, "\n");
2028 return ldns_buffer_status(output);
2029 }
2030
2031 ldns_status
2032 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
2033 {
2034 return ldns_rr2buffer_str_fmt(output, ldns_output_format_default, rr);
2035 }
2036
2037 ldns_status
2038 ldns_rr_list2buffer_str_fmt(ldns_buffer *output,
2039 const ldns_output_format *fmt, const ldns_rr_list *list)
2040 {
2041 uint16_t i;
2042
2043 for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
2044 (void) ldns_rr2buffer_str_fmt(output, fmt,
2045 ldns_rr_list_rr(list, i));
2046 }
2047 return ldns_buffer_status(output);
2048 }
2049
2050 ldns_status
2051 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
2052 {
2053 return ldns_rr_list2buffer_str_fmt(
2054 output, ldns_output_format_default, list);
2055 }
2056
2057 ldns_status
2058 ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
2059 {
2060 ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
2061 (int) ldns_pkt_get_opcode(pkt));
2062 ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes,
2063 (int) ldns_pkt_get_rcode(pkt));
2064
2065 ldns_buffer_printf(output, ";; ->>HEADER<<- ");
2066 if (opcode) {
2067 ldns_buffer_printf(output, "opcode: %s, ", opcode->name);
2068 } else {
2069 ldns_buffer_printf(output, "opcode: ?? (%u), ",
2070 ldns_pkt_get_opcode(pkt));
2071 }
2072 if (rcode) {
2073 ldns_buffer_printf(output, "rcode: %s, ", rcode->name);
2074 } else {
2075 ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt));
2076 }
2077 ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt));
2078 ldns_buffer_printf(output, ";; flags: ");
2079
2080 if (ldns_pkt_qr(pkt)) {
2081 ldns_buffer_printf(output, "qr ");
2082 }
2083 if (ldns_pkt_aa(pkt)) {
2084 ldns_buffer_printf(output, "aa ");
2085 }
2086 if (ldns_pkt_tc(pkt)) {
2087 ldns_buffer_printf(output, "tc ");
2088 }
2089 if (ldns_pkt_rd(pkt)) {
2090 ldns_buffer_printf(output, "rd ");
2091 }
2092 if (ldns_pkt_cd(pkt)) {
2093 ldns_buffer_printf(output, "cd ");
2094 }
2095 if (ldns_pkt_ra(pkt)) {
2096 ldns_buffer_printf(output, "ra ");
2097 }
2098 if (ldns_pkt_ad(pkt)) {
2099 ldns_buffer_printf(output, "ad ");
2100 }
2101 ldns_buffer_printf(output, "; ");
2102 ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt));
2103 ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt));
2104 ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt));
2105 ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt));
2106 return ldns_buffer_status(output);
2107 }
2108
2109
2110 /* print EDNS option data in the Dig format: 76 61 6c 69 ... */
2111 static void
2112 ldns_edns_hex_data2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2113 {
2114 size_t j;
2115 for (j = 0; j < len; j++) {
2116 ldns_buffer_printf(output, " %02x", data[j]);
2117 }
2118 }
2119
2120 static ldns_status
2121 ldns_edns_llq2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2122 {
2123 /* LLQ constants */
2124 const char* llq_errors[] = {"NO-ERROR", "SERV-FULL", "STATIC",
2125 "FORMAT-ERR", "NO-SUCH-LLQ", "BAD-VERS", "UNKNOWN_ERR"};
2126 const unsigned int llq_errors_num = 7;
2127 const char* llq_opcodes[] = {"LLQ-SETUP", "LLQ-REFRESH", "LLQ-EVENT"};
2128 const unsigned int llq_opcodes_num = 3;
2129
2130 uint16_t version, llq_opcode, error_code;
2131 uint64_t llq_id;
2132 uint32_t lease_life; /* Requested or granted life of LLQ, in seconds */
2133
2134 ldns_buffer_printf(output, "; Long-Lived Query:");
2135
2136 /* read the record */
2137 if(len != 18) {
2138 ldns_buffer_printf(output, " malformed LLQ ");
2139 ldns_edns_hex_data2buffer_str(output, data, len);
2140
2141 return ldns_buffer_status(output);
2142 }
2143 version = ldns_read_uint16(data);
2144 llq_opcode = ldns_read_uint16(data+2);
2145 error_code = ldns_read_uint16(data+4);
2146 memmove(&llq_id, data+6, sizeof(uint64_t));
2147 lease_life = ldns_read_uint32(data+14);
2148
2149 /* print option field entires */
2150 ldns_buffer_printf(output, "v%d ", (int)version);
2151
2152 if(llq_opcode < llq_opcodes_num) {
2153 ldns_buffer_printf(output, "%s", llq_opcodes[llq_opcode]);
2154 } else {
2155 ldns_buffer_printf(output, "opcode %d", (int)llq_opcode);
2156 }
2157
2158 if(error_code < llq_errors_num)
2159 ldns_buffer_printf(output, " %s", llq_errors[error_code]);
2160 else {
2161 ldns_buffer_printf(output, " error %d", (int)error_code);
2162 }
2163
2164 #ifndef USE_WINSOCK
2165 ldns_buffer_printf(output, " id %llx lease-life %lu",
2166 (unsigned long long)llq_id, (unsigned long)lease_life);
2167 #else
2168 ldns_buffer_printf(output, " id %I64x lease-life %lu",
2169 (unsigned long long)llq_id, (unsigned long)lease_life);
2170 #endif
2171 return ldns_buffer_status(output);
2172 }
2173
2174
2175 static ldns_status
2176 ldns_edns_ul2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2177 {
2178 uint32_t lease;
2179
2180 ldns_buffer_printf(output, "; Update Lease:");
2181
2182 if(len != 4) {
2183 ldns_buffer_printf(output, " malformed UL ");
2184 ldns_edns_hex_data2buffer_str(output, data, len);
2185 return ldns_buffer_status(output);
2186 }
2187 lease = ldns_read_uint32(data);
2188 ldns_buffer_printf(output, "lease %lu", (unsigned long)lease);
2189
2190 return ldns_buffer_status(output);
2191 }
2192
2193 static ldns_status
2194 ldns_edns_nsid2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2195 {
2196 size_t i, printed=0;
2197
2198 ldns_buffer_printf(output, "; NSID:");
2199 ldns_edns_hex_data2buffer_str(output, data, len);
2200
2201 /* print the human-readable text string */
2202 for(i = 0; i < len; i++) {
2203 if(isprint((unsigned char)data[i]) || data[i] == '\t') {
2204 if(!printed) {
2205 ldns_buffer_printf(output, " (");
2206 printed = 1;
2207 }
2208 ldns_buffer_printf(output, "%c", (char)data[i]);
2209 }
2210 }
2211 if(printed)
2212 ldns_buffer_printf(output, ")");
2213 return ldns_buffer_status(output);
2214 }
2215
2216
2217 static ldns_status
2218 ldns_edns_dau2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2219 {
2220 size_t i;
2221 ldns_lookup_table *lt;
2222
2223 ldns_buffer_printf(output, "; DNSSEC Algorithm Understood (DAU):");
2224
2225 for(i = 0; i <len; i++) {
2226 lt = ldns_lookup_by_id(ldns_algorithms, data[i]);
2227 if (lt && lt->name) {
2228 ldns_buffer_printf(output, " %s", lt->name);
2229 } else {
2230 ldns_buffer_printf(output, " ALG%u", data[i]);
2231 }
2232 }
2233 return ldns_buffer_status(output);
2234 }
2235
2236 static ldns_status
2237 ldns_edns_dhu2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2238 {
2239 size_t i;
2240 ldns_lookup_table *lt;
2241
2242 ldns_buffer_printf(output, "; DS Hash Understood (DHU):");
2243
2244 for(i = 0; i < len; i++) {
2245 lt = ldns_lookup_by_id(ldns_hashes, data[i]);
2246 if (lt && lt->name) {
2247 ldns_buffer_printf(output, " %s", lt->name);
2248 } else {
2249 ldns_buffer_printf(output, " ALG%u", data[i]);
2250 }
2251 }
2252 return ldns_buffer_status(output);
2253 }
2254
2255 static ldns_status
2256 ldns_edns_d3u2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2257 {
2258 size_t i;
2259
2260 ldns_buffer_printf(output, "; NSEC3 Hash Understood (N3U):");
2261
2262 for(i=0; i<len; i++) {
2263 if(data[i] == 1) {
2264 ldns_buffer_printf(output, " SHA1");
2265 } else {
2266 ldns_buffer_printf(output, " %d", (int)data[i]);
2267 }
2268 }
2269 return ldns_buffer_status(output);
2270 }
2271
2272 static ldns_status
2273 ldns_edns_subnet2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2274 {
2275 uint16_t family;
2276 uint8_t source, scope;
2277 if(len < 4) {
2278 ldns_buffer_printf(output, "malformed subnet ");
2279 ldns_edns_hex_data2buffer_str(output, data, len);
2280 return ldns_buffer_status(output);
2281 }
2282 family = ldns_read_uint16(data);
2283 source = data[2];
2284 scope = data[3];
2285 if(family == 1) {
2286 /* IPv4 */
2287 char buf[64];
2288 uint8_t ip4[4];
2289 memset(ip4, 0, sizeof(ip4));
2290 if(len-4 > 4) {
2291 ldns_buffer_printf(output, "trailingdata:");
2292 ldns_edns_hex_data2buffer_str(output, data+4+4, len-4-4);
2293 ldns_buffer_printf(output, " ");
2294 len = 4+4;
2295 }
2296 memmove(ip4, data+4, len-4);
2297 if(!inet_ntop(AF_INET, ip4, buf, (socklen_t) sizeof(buf))) {
2298 ldns_buffer_printf(output, "ip4ntoperror ");
2299 ldns_edns_hex_data2buffer_str(output, data+4+4, len-4-4);
2300 } else {
2301 ldns_buffer_printf(output, "%s", buf);
2302 }
2303 } else if(family == 2) {
2304 /* IPv6 */
2305 char buf[64];
2306 uint8_t ip6[16];
2307 memset(ip6, 0, sizeof(ip6));
2308 if(len-4 > 16) {
2309 ldns_buffer_printf(output, "trailingdata:");
2310 ldns_edns_hex_data2buffer_str(output, data+4+16, len-4-16);
2311 ldns_buffer_printf(output, " ");
2312 len = 4+16;
2313 }
2314 memmove(ip6, data+4, len-4);
2315 #ifdef AF_INET6
2316 if(!inet_ntop(AF_INET6, ip6, buf, (socklen_t) sizeof(buf))) {
2317 ldns_buffer_printf(output, "ip6ntoperror ");
2318 ldns_edns_hex_data2buffer_str(output, data+4+4, len-4-4);
2319 } else {
2320 ldns_buffer_printf(output, "%s", buf);
2321 }
2322 #else
2323 ldns_edns_hex_data2buffer_str(output, data+4+4, len-4-4);
2324 #endif
2325 } else {
2326 /* unknown */
2327 ldns_buffer_printf(output, "family %d ", (int)family);
2328 ldns_edns_hex_data2buffer_str(output, data, len);
2329 }
2330 ldns_buffer_printf(output, "/%d scope /%d", (int)source, (int)scope);
2331
2332 return ldns_buffer_status(output);
2333 }
2334
2335 static ldns_status
2336 ldns_edns_expire2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2337 {
2338
2339 ldns_buffer_printf(output, "; EXPIRE:");
2340
2341 if (!(len == 0) || len == 4) {
2342 ldns_buffer_printf(output, "malformed expire ");
2343 ldns_edns_hex_data2buffer_str(output, data, len);
2344
2345 return ldns_buffer_status(output);
2346 }
2347
2348 // TODO can this output be more accurate?
2349 ldns_edns_hex_data2buffer_str(output, data, len);
2350
2351 return ldns_buffer_status(output);
2352 }
2353
2354
2355 static ldns_status
2356 ldns_edns_cookie2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2357 {
2358 ldns_buffer_printf(output, "; COOKIE:");
2359
2360 /* the size of an EDNS cookie is restricted by RFC 7873 */
2361 if (!(len == 8 || (len >= 16 && len < 40))) {
2362 ldns_buffer_printf(output, "malformed cookie ");
2363 ldns_edns_hex_data2buffer_str(output, data, len);
2364 }
2365 ldns_edns_hex_data2buffer_str(output, data, len);
2366
2367 return ldns_buffer_status(output);
2368 }
2369
2370 static ldns_status
2371 ldns_edns_keepalive2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2372 {
2373 uint16_t timeout;
2374
2375 ldns_buffer_printf(output, "; KEEPALIVE:");
2376
2377 if(!(len == 0 || len == 2)) {
2378 ldns_buffer_printf(output, "malformed keepalive ");
2379 ldns_edns_hex_data2buffer_str(output, data, len);
2380
2381 return ldns_buffer_status(output);
2382 }
2383
2384 if(len == 0) {
2385 ldns_buffer_printf(output, "no timeout value (only valid for client option)");
2386 } else {
2387 timeout = ldns_read_uint16(data);
2388 ldns_buffer_printf(output, "timeout value in units of 100ms %u", (int)timeout);
2389 }
2390 return ldns_buffer_status(output);
2391 }
2392
2393 static ldns_status
2394 ldns_edns_padding2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2395 {
2396 ldns_buffer_printf(output, "; PADDING: ");
2397 ldns_edns_hex_data2buffer_str(output, data, len);
2398
2399 return ldns_buffer_status(output);
2400 }
2401
2402 static ldns_status
2403 ldns_edns_chain2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2404 {
2405 ldns_rdf** temp = NULL;
2406
2407 ldns_buffer_printf(output, "; CHAIN: ");
2408
2409 if (ldns_str2rdf_dname(temp, (char*) data) != LDNS_STATUS_OK) {
2410 ldns_buffer_printf(output, "malformed chain ");
2411 ldns_edns_hex_data2buffer_str(output, data, len);
2412
2413 return ldns_buffer_status(output);
2414 }
2415
2416 ldns_characters2buffer_str(output, len, data);
2417
2418 return ldns_buffer_status(output);
2419 }
2420
2421 static ldns_status
2422 ldns_edns_key_tag2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2423 {
2424 size_t i;
2425
2426 ldns_buffer_printf(output, "; KEY TAG: ");
2427
2428 if(len < 2 || len % 2 != 0) {
2429 ldns_buffer_printf(output, "malformed key tag ");
2430 ldns_edns_hex_data2buffer_str(output, data, len);
2431
2432 return ldns_buffer_status(output);
2433 }
2434
2435 for (i = 0; i < len; i += 2) {
2436 uint16_t tag = ldns_read_uint16(data);
2437
2438 ldns_buffer_printf(output, " %hu", tag);
2439 }
2440
2441 return ldns_buffer_status(output);
2442 }
2443
2444 static ldns_status
2445 ldns_edns_ede2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2446 {
2447 size_t i;
2448 uint16_t ede;
2449 ldns_buffer_printf(output, "; EDE:");
2450
2451 if(len < 2) {
2452 ldns_buffer_printf(output, "malformed ede ");
2453 ldns_edns_hex_data2buffer_str(output, data, len);
2454
2455 return ldns_buffer_status(output);
2456 }
2457
2458 ede = ldns_read_uint16(data);
2459
2460 switch (ede) {
2461 case LDNS_EDE_OTHER:
2462 ldns_buffer_printf(output, " 0 (Other): ");
2463 break;
2464 case LDNS_EDE_UNSUPPORTED_DNSKEY_ALG:
2465 ldns_buffer_printf(output, " 1 (Unsupported DNSKEY Algorithm)");
2466 break;
2467 case LDNS_EDE_UNSUPPORTED_DS_DIGEST:
2468 ldns_buffer_printf(output, " 2 (Unsupported DS Digest type)");
2469 break;
2470 case LDNS_EDE_STALE_ANSWER:
2471 ldns_buffer_printf(output, " 3 (Stale Answer)");
2472 break;
2473 case LDNS_EDE_FORGED_ANSWER:
2474 ldns_buffer_printf(output, " 4 (Forged Answer)");
2475 break;
2476 case LDNS_EDE_DNSSEC_INDETERMINATE:
2477 ldns_buffer_printf(output, " 5 (DNSSEC Indeterminate)");
2478 break;
2479 case LDNS_EDE_DNSSEC_BOGUS:
2480 ldns_buffer_printf(output, " 6 (DNSSEC Bogus)");
2481 break;
2482 case LDNS_EDE_SIGNATURE_EXPIRED:
2483 ldns_buffer_printf(output, " 7 (Signature Expired)");
2484 break;
2485 case LDNS_EDE_SIGNATURE_NOT_YET_VALID:
2486 ldns_buffer_printf(output, " 8 (Signature Not Yet Valid)");
2487 break;
2488 case LDNS_EDE_DNSKEY_MISSING:
2489 ldns_buffer_printf(output, " 9 (DNSKEY Missing)");
2490 break;
2491 case LDNS_EDE_RRSIGS_MISSING:
2492 ldns_buffer_printf(output, " 10 (RRSIGs Missing)");
2493 break;
2494 case LDNS_EDE_NO_ZONE_KEY_BIT_SET:
2495 ldns_buffer_printf(output, " 11 (No Zone Key Bit Set)");
2496 break;
2497 case LDNS_EDE_NSEC_MISSING:
2498 ldns_buffer_printf(output, " 12 (NSEC Missing)");
2499 break;
2500 case LDNS_EDE_CACHED_ERROR:
2501 ldns_buffer_printf(output, " 13 (Cached Error)");
2502 break;
2503 case LDNS_EDE_NOT_READY:
2504 ldns_buffer_printf(output, " 14 (Not Ready)");
2505 break;
2506 case LDNS_EDE_BLOCKED:
2507 ldns_buffer_printf(output, " 15 (Blocked)");
2508 break;
2509 case LDNS_EDE_CENSORED:
2510 ldns_buffer_printf(output, " 16 (Censored)");
2511 break;
2512 case LDNS_EDE_FILTERED:
2513 ldns_buffer_printf(output, " 17 (Filtered)");
2514 break;
2515 case LDNS_EDE_PROHIBITED:
2516 ldns_buffer_printf(output, " 18 (Prohibited)");
2517 break;
2518 case LDNS_EDE_STALE_NXDOMAIN_ANSWER:
2519 ldns_buffer_printf(output, " 19 (NXDOMAIN Answer)");
2520 break;
2521 case LDNS_EDE_NOT_AUTHORITATIVE:
2522 ldns_buffer_printf(output, " 20 (Not Authoritative)");
2523 break;
2524 case LDNS_EDE_NOT_SUPPORTED:
2525 ldns_buffer_printf(output, " 21 (Not Supported)");
2526 break;
2527 case LDNS_EDE_NO_REACHABLE_AUTHORITY:
2528 ldns_buffer_printf(output, " 22 (No Reachable Authority)");
2529 break;
2530 case LDNS_EDE_NETWORK_ERROR:
2531 ldns_buffer_printf(output, " 23 (Network Error)");
2532 break;
2533 case LDNS_EDE_INVALID_DATA:
2534 ldns_buffer_printf(output, " 24 (Invalid Data)");
2535 break;
2536 case LDNS_EDE_SIGNATURE_EXPIRED_BEFORE_VALID:
2537 ldns_buffer_printf(output, " 25 (Signature Expired Before Valid)");
2538 break;
2539 case LDNS_EDE_TOO_EARLY:
2540 ldns_buffer_printf(output, " 26 (Too Early)");
2541 break;
2542 default:
2543 ldns_buffer_printf(output, " %02x", data[0]);
2544 ldns_buffer_printf(output, " %02x", data[1]);
2545 break;
2546 }
2547
2548 /* skip the EDE code in the output */
2549 data += 2;
2550 len -= 2;
2551
2552 if (len > 2) {
2553 /* format the hex bytes */
2554 ldns_buffer_printf(output, ":");
2555 for (i = 0; i < len; i++) {
2556 ldns_buffer_printf(output, " %02x", data[i]);
2557 }
2558
2559 /* format the human-readable string */
2560 ldns_buffer_printf(output, " (");
2561 ldns_characters2buffer_str(output, len, data);
2562 ldns_buffer_printf(output, ")");
2563 }
2564
2565 return ldns_buffer_status(output);
2566 }
2567
2568 static ldns_status
2569 ldns_edns_client_tag2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2570 {
2571 ldns_buffer_printf(output, "; CLIENT-TAG:");
2572
2573 if (len > 2) {
2574 ldns_buffer_printf(output, "malformed client-tag ");
2575 ldns_edns_hex_data2buffer_str(output, data, len);
2576
2577 return ldns_buffer_status(output);
2578 }
2579
2580 ldns_edns_hex_data2buffer_str(output, data, len);
2581
2582 return ldns_buffer_status(output);
2583 }
2584
2585 static ldns_status
2586 ldns_edns_server_tag2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2587 {
2588 ldns_buffer_printf(output, "; SERVER-TAG:");
2589
2590 if (len > 2) {
2591 ldns_buffer_printf(output, "malformed server-tag ");
2592 ldns_edns_hex_data2buffer_str(output, data, len);
2593
2594 return ldns_buffer_status(output);
2595 }
2596
2597 ldns_edns_hex_data2buffer_str(output, data, len);
2598
2599 return ldns_buffer_status(output);
2600 }
2601
2602 ldns_status
2603 ldns_edns_option_list2buffer_str(ldns_buffer *output, ldns_edns_option_list* edns_list)
2604 {
2605 size_t count = ldns_edns_option_list_get_count(edns_list);
2606 size_t i, size;
2607 uint8_t* data;
2608
2609 for (i = 0; i < count; i++) {
2610 ldns_edns_option_code code;
2611 ldns_edns_option* edns = ldns_edns_option_list_get_option(edns_list, i);
2612
2613 if (!edns) {
2614 break;
2615 }
2616
2617 code = ldns_edns_get_code(edns);
2618 size = ldns_edns_get_size(edns);
2619 data = ldns_edns_get_data(edns);
2620
2621 switch(code) {
2622 case LDNS_EDNS_LLQ:
2623 ldns_edns_llq2buffer_str(output, data, size);
2624 break;
2625 case LDNS_EDNS_UL:
2626 ldns_edns_ul2buffer_str(output, data, size);
2627 break;
2628 case LDNS_EDNS_NSID:
2629 ldns_edns_nsid2buffer_str(output, data, size);
2630 break;
2631 case LDNS_EDNS_DAU:
2632 ldns_edns_dau2buffer_str(output, data, size);
2633 break;
2634 case LDNS_EDNS_DHU:
2635 ldns_edns_dhu2buffer_str(output, data, size);
2636 break;
2637 case LDNS_EDNS_N3U:
2638 ldns_edns_d3u2buffer_str(output, data, size);
2639 break;
2640 case LDNS_EDNS_CLIENT_SUBNET:
2641 ldns_edns_subnet2buffer_str(output, data, size);
2642 break;
2643 case LDNS_EDNS_EXPIRE:
2644 ldns_edns_expire2buffer_str(output, data, size);
2645 break;
2646 case LDNS_EDNS_COOKIE:
2647 ldns_edns_cookie2buffer_str(output, data, size);
2648 break;
2649 case LDNS_EDNS_KEEPALIVE:
2650 ldns_edns_keepalive2buffer_str(output, data, size);
2651 break;
2652 case LDNS_EDNS_PADDING:
2653 ldns_edns_padding2buffer_str(output, data, size);
2654 break;
2655 case LDNS_EDNS_CHAIN:
2656 ldns_edns_chain2buffer_str(output, data, size);
2657 break;
2658 case LDNS_EDNS_KEY_TAG:
2659 ldns_edns_key_tag2buffer_str(output, data, size);
2660 break;
2661 case LDNS_EDNS_EDE:
2662 ldns_edns_ede2buffer_str(output, data, size);
2663 break;
2664 case LDNS_EDNS_CLIENT_TAG:
2665 ldns_edns_client_tag2buffer_str(output, data, size);
2666 break;
2667 case LDNS_EDNS_SERVER_TAG:
2668 ldns_edns_server_tag2buffer_str(output, data, size);
2669 break;
2670 default:
2671 ldns_buffer_printf(output, "; OPT=%d:", code);
2672 ldns_edns_hex_data2buffer_str(output, data, size);
2673 break;
2674 }
2675 ldns_buffer_printf(output, "\n");
2676 }
2677
2678 return ldns_buffer_status(output);
2679 }
2680
2681
2682 ldns_status
2683 ldns_pkt2buffer_str_fmt(ldns_buffer *output,
2684 const ldns_output_format *fmt, const ldns_pkt *pkt)
2685 {
2686 uint16_t i;
2687 ldns_status status = LDNS_STATUS_OK;
2688 char *tmp;
2689 struct timeval time;
2690 time_t time_tt;
2691 int short_fmt = fmt && (fmt->flags & LDNS_FMT_SHORT);
2692
2693 if (!pkt) {
2694 ldns_buffer_printf(output, "null");
2695 return LDNS_STATUS_OK;
2696 }
2697
2698 if (!ldns_buffer_status_ok(output)) {
2699 return ldns_buffer_status(output);
2700 }
2701
2702 if (!short_fmt) {
2703 status = ldns_pktheader2buffer_str(output, pkt);
2704 if (status != LDNS_STATUS_OK) {
2705 return status;
2706 }
2707
2708 ldns_buffer_printf(output, "\n");
2709
2710 ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
2711
2712
2713 for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
2714 status = ldns_rr2buffer_str_fmt(output, fmt,
2715 ldns_rr_list_rr(
2716 ldns_pkt_question(pkt), i));
2717 if (status != LDNS_STATUS_OK) {
2718 return status;
2719 }
2720 }
2721 ldns_buffer_printf(output, "\n");
2722
2723 ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
2724 }
2725 for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
2726 status = ldns_rr2buffer_str_fmt(output, fmt,
2727 ldns_rr_list_rr(
2728 ldns_pkt_answer(pkt), i));
2729 if (status != LDNS_STATUS_OK) {
2730 return status;
2731 }
2732 }
2733 if (!short_fmt) {
2734 ldns_buffer_printf(output, "\n");
2735
2736 ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
2737
2738 for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
2739 status = ldns_rr2buffer_str_fmt(output, fmt,
2740 ldns_rr_list_rr(
2741 ldns_pkt_authority(pkt), i));
2742 if (status != LDNS_STATUS_OK) {
2743 return status;
2744 }
2745 }
2746 ldns_buffer_printf(output, "\n");
2747
2748 ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
2749 for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
2750 status = ldns_rr2buffer_str_fmt(output, fmt,
2751 ldns_rr_list_rr(
2752 ldns_pkt_additional(pkt), i));
2753 if (status != LDNS_STATUS_OK) {
2754 return status;
2755 }
2756
2757 }
2758 ldns_buffer_printf(output, "\n");
2759 /* add some further fields */
2760 ldns_buffer_printf(output, ";; Query time: %d msec\n",
2761 ldns_pkt_querytime(pkt));
2762 if (ldns_pkt_edns(pkt)) {
2763 ldns_buffer_printf(output,
2764 ";; EDNS: version %u; flags:",
2765 ldns_pkt_edns_version(pkt));
2766 if (ldns_pkt_edns_do(pkt)) {
2767 ldns_buffer_printf(output, " do");
2768 }
2769 /* the extended rcode is the value set, shifted four bits,
2770 * and or'd with the original rcode */
2771 if (ldns_pkt_edns_extended_rcode(pkt)) {
2772 ldns_buffer_printf(output, " ; ext-rcode: %d",
2773 (ldns_pkt_edns_extended_rcode(pkt) << 4 | ldns_pkt_get_rcode(pkt)));
2774 }
2775 ldns_buffer_printf(output, " ; udp: %u\n",
2776 ldns_pkt_edns_udp_size(pkt));
2777
2778 if (pkt->_edns_list)
2779 ldns_edns_option_list2buffer_str(output, pkt->_edns_list);
2780
2781 else if (ldns_pkt_edns_data(pkt)) {
2782 ldns_edns_option_list* edns_list;
2783 /* parse the EDNS data into separate EDNS options
2784 * and add them to the list */
2785 if ((edns_list = pkt_edns_data2edns_option_list(ldns_pkt_edns_data(pkt)))) {
2786 ldns_edns_option_list2buffer_str(output, edns_list);
2787 ldns_edns_option_list_deep_free(edns_list);
2788 } else {
2789 ldns_buffer_printf(output, ";; Data: ");
2790 (void)ldns_rdf2buffer_str(output, ldns_pkt_edns_data(pkt));
2791 }
2792 }
2793 }
2794 if (ldns_pkt_tsig(pkt)) {
2795 ldns_buffer_printf(output, ";; TSIG:\n;; ");
2796 (void) ldns_rr2buffer_str_fmt(
2797 output, fmt, ldns_pkt_tsig(pkt));
2798 ldns_buffer_printf(output, "\n");
2799 }
2800 if (ldns_pkt_answerfrom(pkt)) {
2801 tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
2802 ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
2803 LDNS_FREE(tmp);
2804 }
2805 time = ldns_pkt_timestamp(pkt);
2806 time_tt = (time_t)time.tv_sec;
2807 ldns_buffer_printf(output, ";; WHEN: %s",
2808 (char*)ctime(&time_tt));
2809
2810 ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n",
2811 (int)ldns_pkt_size(pkt));
2812 }
2813 return status;
2814 }
2815
2816 ldns_status
2817 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
2818 {
2819 return ldns_pkt2buffer_str_fmt(output, ldns_output_format_default, pkt);
2820 }
2821
2822
2823 #ifdef HAVE_SSL
2824 static ldns_status
2825 ldns_hmac_key2buffer_str(ldns_buffer *output, const ldns_key *k)
2826 {
2827 ldns_status status;
2828 size_t i;
2829 ldns_rdf *b64_bignum;
2830
2831 ldns_buffer_printf(output, "Key: ");
2832
2833 i = ldns_key_hmac_size(k);
2834 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k));
2835 status = ldns_rdf2buffer_str(output, b64_bignum);
2836 ldns_rdf_deep_free(b64_bignum);
2837 ldns_buffer_printf(output, "\n");
2838 return status;
2839 }
2840 #endif
2841
2842 #if defined(HAVE_SSL) && defined(USE_GOST)
2843 static ldns_status
2844 ldns_gost_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
2845 {
2846 unsigned char* pp = NULL;
2847 int ret;
2848 ldns_rdf *b64_bignum;
2849 ldns_status status;
2850
2851 ldns_buffer_printf(output, "GostAsn1: ");
2852
2853 ret = i2d_PrivateKey(p, &pp);
2854 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, (size_t)ret, pp);
2855 status = ldns_rdf2buffer_str(output, b64_bignum);
2856
2857 ldns_rdf_deep_free(b64_bignum);
2858 OPENSSL_free(pp);
2859 ldns_buffer_printf(output, "\n");
2860 return status;
2861 }
2862 #endif
2863
2864 #if defined(HAVE_SSL) && defined(USE_ED25519)
2865 static ldns_status
2866 ldns_ed25519_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
2867 {
2868 unsigned char* pp = NULL;
2869 int ret;
2870 ldns_rdf *b64_bignum;
2871 ldns_status status;
2872
2873 ldns_buffer_printf(output, "PrivateKey: ");
2874
2875 ret = i2d_PrivateKey(p, &pp);
2876 /* 16 byte asn (302e020100300506032b657004220420) + 32byte key */
2877 if(ret != 16 + 32) {
2878 OPENSSL_free(pp);
2879 return LDNS_STATUS_ERR;
2880 }
2881 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64,
2882 (size_t)ret-16, pp+16);
2883 status = ldns_rdf2buffer_str(output, b64_bignum);
2884
2885 ldns_rdf_deep_free(b64_bignum);
2886 OPENSSL_free(pp);
2887 ldns_buffer_printf(output, "\n");
2888 return status;
2889 }
2890 #endif
2891
2892 #if defined(HAVE_SSL) && defined(USE_ED448)
2893 static ldns_status
2894 ldns_ed448_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
2895 {
2896 unsigned char* pp = NULL;
2897 int ret;
2898 ldns_rdf *b64_bignum;
2899 ldns_status status;
2900
2901 ldns_buffer_printf(output, "PrivateKey: ");
2902
2903 ret = i2d_PrivateKey(p, &pp);
2904 /* some-ASN + 57byte key */
2905 if(ret != 16 + 57) {
2906 OPENSSL_free(pp);
2907 return LDNS_STATUS_ERR;
2908 }
2909 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64,
2910 (size_t)ret-16, pp+16);
2911 status = ldns_rdf2buffer_str(output, b64_bignum);
2912
2913 ldns_rdf_deep_free(b64_bignum);
2914 OPENSSL_free(pp);
2915 ldns_buffer_printf(output, "\n");
2916 return status;
2917 }
2918 #endif
2919
2920 #if defined(HAVE_SSL)
2921 /** print one b64 encoded bignum to a line in the keybuffer */
2922 static int
2923 ldns_print_bignum_b64_line(ldns_buffer* output, const char* label, const BIGNUM* num)
2924 {
2925 unsigned char *bignumbuf = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
2926 if(!bignumbuf) return 0;
2927
2928 ldns_buffer_printf(output, "%s: ", label);
2929 if(num) {
2930 ldns_rdf *b64_bignum = NULL;
2931 int i = BN_bn2bin(num, bignumbuf);
2932 if (i > LDNS_MAX_KEYLEN) {
2933 LDNS_FREE(bignumbuf);
2934 return 0;
2935 }
2936 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, (size_t)i, bignumbuf);
2937 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2938 ldns_rdf_deep_free(b64_bignum);
2939 LDNS_FREE(bignumbuf);
2940 return 0;
2941 }
2942 ldns_rdf_deep_free(b64_bignum);
2943 ldns_buffer_printf(output, "\n");
2944 } else {
2945 ldns_buffer_printf(output, "(Not available)\n");
2946 }
2947 LDNS_FREE(bignumbuf);
2948 return 1;
2949 }
2950 #endif
2951
2952 ldns_status
2953 ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
2954 {
2955 ldns_status status = LDNS_STATUS_OK;
2956 unsigned char *bignum;
2957 #ifdef HAVE_SSL
2958 RSA *rsa;
2959 #ifdef USE_DSA
2960 DSA *dsa;
2961 #endif /* USE_DSA */
2962 #endif /* HAVE_SSL */
2963
2964 if (!k) {
2965 return LDNS_STATUS_ERR;
2966 }
2967
2968 bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
2969 if (!bignum) {
2970 return LDNS_STATUS_ERR;
2971 }
2972
2973 if (ldns_buffer_status_ok(output)) {
2974 #ifdef HAVE_SSL
2975 switch(ldns_key_algorithm(k)) {
2976 case LDNS_SIGN_RSASHA1:
2977 case LDNS_SIGN_RSASHA1_NSEC3:
2978 case LDNS_SIGN_RSASHA256:
2979 case LDNS_SIGN_RSASHA512:
2980 case LDNS_SIGN_RSAMD5:
2981 /* copied by looking at dnssec-keygen output */
2982 /* header */
2983 rsa = ldns_key_rsa_key(k);
2984
2985 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
2986 switch(ldns_key_algorithm(k)) {
2987 case LDNS_SIGN_RSAMD5:
2988 ldns_buffer_printf(output,
2989 "Algorithm: %u (RSA)\n",
2990 LDNS_RSAMD5);
2991 break;
2992 case LDNS_SIGN_RSASHA1:
2993 ldns_buffer_printf(output,
2994 "Algorithm: %u (RSASHA1)\n",
2995 LDNS_RSASHA1);
2996 break;
2997 case LDNS_SIGN_RSASHA1_NSEC3:
2998 ldns_buffer_printf(output,
2999 "Algorithm: %u (RSASHA1_NSEC3)\n",
3000 LDNS_RSASHA1_NSEC3);
3001 break;
3002 #ifdef USE_SHA2
3003 case LDNS_SIGN_RSASHA256:
3004 ldns_buffer_printf(output,
3005 "Algorithm: %u (RSASHA256)\n",
3006 LDNS_RSASHA256);
3007 break;
3008 case LDNS_SIGN_RSASHA512:
3009 ldns_buffer_printf(output,
3010 "Algorithm: %u (RSASHA512)\n",
3011 LDNS_RSASHA512);
3012 break;
3013 #endif
3014 default:
3015 #ifdef STDERR_MSGS
3016 fprintf(stderr, "Warning: unknown signature ");
3017 fprintf(stderr,
3018 "algorithm type %u\n",
3019 ldns_key_algorithm(k));
3020 #endif
3021 ldns_buffer_printf(output,
3022 "Algorithm: %u (Unknown)\n",
3023 ldns_key_algorithm(k));
3024 break;
3025 }
3026
3027 /* print to buf, convert to bin, convert to b64,
3028 * print to buf */
3029
3030 #ifndef S_SPLINT_S
3031 if(1) {
3032 const BIGNUM *n=NULL, *e=NULL, *d=NULL,
3033 *p=NULL, *q=NULL, *dmp1=NULL,
3034 *dmq1=NULL, *iqmp=NULL;
3035 #if OPENSSL_VERSION_NUMBER < 0x10100000 || (defined(HAVE_LIBRESSL) && LIBRESSL_VERSION_NUMBER < 0x20700000)
3036 n = rsa->n;
3037 e = rsa->e;
3038 d = rsa->d;
3039 p = rsa->p;
3040 q = rsa->q;
3041 dmp1 = rsa->dmp1;
3042 dmq1 = rsa->dmq1;
3043 iqmp = rsa->iqmp;
3044 #else
3045 RSA_get0_key(rsa, &n, &e, &d);
3046 RSA_get0_factors(rsa, &p, &q);
3047 RSA_get0_crt_params(rsa, &dmp1,
3048 &dmq1, &iqmp);
3049 #endif
3050 if(!ldns_print_bignum_b64_line(output, "Modulus", n))
3051 goto error;
3052 if(!ldns_print_bignum_b64_line(output, "PublicExponent", e))
3053 goto error;
3054 if(!ldns_print_bignum_b64_line(output, "PrivateExponent", d))
3055 goto error;
3056 if(!ldns_print_bignum_b64_line(output, "Prime1", p))
3057 goto error;
3058 if(!ldns_print_bignum_b64_line(output, "Prime2", q))
3059 goto error;
3060 if(!ldns_print_bignum_b64_line(output, "Exponent1", dmp1))
3061 goto error;
3062 if(!ldns_print_bignum_b64_line(output, "Exponent2", dmq1))
3063 goto error;
3064 if(!ldns_print_bignum_b64_line(output, "Coefficient", iqmp))
3065 goto error;
3066 }
3067 #endif /* splint */
3068
3069 RSA_free(rsa);
3070 break;
3071 #ifdef USE_DSA
3072 case LDNS_SIGN_DSA:
3073 case LDNS_SIGN_DSA_NSEC3:
3074 dsa = ldns_key_dsa_key(k);
3075
3076 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
3077 if (ldns_key_algorithm(k) == LDNS_SIGN_DSA) {
3078 ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n");
3079 } else if (ldns_key_algorithm(k) == LDNS_SIGN_DSA_NSEC3) {
3080 ldns_buffer_printf(output,"Algorithm: 6 (DSA_NSEC3)\n");
3081 }
3082
3083 /* print to buf, convert to bin, convert to b64,
3084 * print to buf */
3085 if(1) {
3086 const BIGNUM *p=NULL, *q=NULL, *g=NULL,
3087 *priv_key=NULL, *pub_key=NULL;
3088 #if OPENSSL_VERSION_NUMBER < 0x10100000 || (defined(HAVE_LIBRESSL) && LIBRESSL_VERSION_NUMBER < 0x20700000)
3089 #ifndef S_SPLINT_S
3090 p = dsa->p;
3091 q = dsa->q;
3092 g = dsa->g;
3093 priv_key = dsa->priv_key;
3094 pub_key = dsa->pub_key;
3095 #endif /* splint */
3096 #else
3097 DSA_get0_pqg(dsa, &p, &q, &g);
3098 DSA_get0_key(dsa, &pub_key, &priv_key);
3099 #endif
3100 if(!ldns_print_bignum_b64_line(output, "Prime(p)", p))
3101 goto error;
3102 if(!ldns_print_bignum_b64_line(output, "Subprime(q)", q))
3103 goto error;
3104 if(!ldns_print_bignum_b64_line(output, "Base(g)", g))
3105 goto error;
3106 if(!ldns_print_bignum_b64_line(output, "Private_value(x)", priv_key))
3107 goto error;
3108 if(!ldns_print_bignum_b64_line(output, "Public_value(y)", pub_key))
3109 goto error;
3110 }
3111 break;
3112 #endif /* USE_DSA */
3113 case LDNS_SIGN_ECC_GOST:
3114 /* no format defined, use blob */
3115 #if defined(HAVE_SSL) && defined(USE_GOST)
3116 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3117 ldns_buffer_printf(output, "Algorithm: %d (ECC-GOST)\n", LDNS_SIGN_ECC_GOST);
3118 status = ldns_gost_key2buffer_str(output,
3119 #ifndef S_SPLINT_S
3120 k->_key.key
3121 #else
3122 NULL
3123 #endif
3124 );
3125 #else
3126 goto error;
3127 #endif /* GOST */
3128 break;
3129 case LDNS_SIGN_ECDSAP256SHA256:
3130 case LDNS_SIGN_ECDSAP384SHA384:
3131 #ifdef USE_ECDSA
3132 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3133 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
3134 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
3135 #ifndef S_SPLINT_S
3136 ldns_buffer_printf(output, ")\n");
3137 if(k->_key.key) {
3138 EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->_key.key);
3139 const BIGNUM* b = EC_KEY_get0_private_key(ec);
3140 if(!ldns_print_bignum_b64_line(output, "PrivateKey", b))
3141 goto error;
3142 /* down reference count in EC_KEY
3143 * its still assigned to the PKEY */
3144 EC_KEY_free(ec);
3145 }
3146 #endif /* splint */
3147 #else
3148 goto error;
3149 #endif /* ECDSA */
3150 break;
3151 #ifdef USE_ED25519
3152 case LDNS_SIGN_ED25519:
3153 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3154 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
3155 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
3156 ldns_buffer_printf(output, ")\n");
3157 if (status) break;
3158 status = ldns_ed25519_key2buffer_str(output,
3159 k->_key.key);
3160 break;
3161 #endif /* USE_ED25519 */
3162 #ifdef USE_ED448
3163 case LDNS_SIGN_ED448:
3164 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3165 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
3166 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
3167 ldns_buffer_printf(output, ")\n");
3168 if (status) break;
3169 status = ldns_ed448_key2buffer_str(output,
3170 k->_key.key);
3171 break;
3172 #endif /* USE_ED448 */
3173 case LDNS_SIGN_HMACMD5:
3174 /* there's not much of a format defined for TSIG */
3175 /* It's just a binary blob, Same for all algorithms */
3176 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3177 ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n");
3178 status = ldns_hmac_key2buffer_str(output, k);
3179 break;
3180 case LDNS_SIGN_HMACSHA1:
3181 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3182 ldns_buffer_printf(output, "Algorithm: 158 (HMAC_SHA1)\n");
3183 status = ldns_hmac_key2buffer_str(output, k);
3184 break;
3185 case LDNS_SIGN_HMACSHA224:
3186 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3187 ldns_buffer_printf(output, "Algorithm: 162 (HMAC_SHA224)\n");
3188 status = ldns_hmac_key2buffer_str(output, k);
3189 break;
3190 case LDNS_SIGN_HMACSHA256:
3191 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3192 ldns_buffer_printf(output, "Algorithm: 159 (HMAC_SHA256)\n");
3193 status = ldns_hmac_key2buffer_str(output, k);
3194 break;
3195 case LDNS_SIGN_HMACSHA384:
3196 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3197 ldns_buffer_printf(output, "Algorithm: 164 (HMAC_SHA384)\n");
3198 status = ldns_hmac_key2buffer_str(output, k);
3199 break;
3200 case LDNS_SIGN_HMACSHA512:
3201 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3202 ldns_buffer_printf(output, "Algorithm: 165 (HMAC_SHA512)\n");
3203 status = ldns_hmac_key2buffer_str(output, k);
3204 break;
3205 }
3206 #endif /* HAVE_SSL */
3207 } else {
3208 LDNS_FREE(bignum);
3209 return ldns_buffer_status(output);
3210 }
3211 LDNS_FREE(bignum);
3212 return status;
3213
3214 #ifdef HAVE_SSL
3215 /* compiles warn the label isn't used */
3216 error:
3217 LDNS_FREE(bignum);
3218 return LDNS_STATUS_ERR;
3219 #endif /* HAVE_SSL */
3220
3221 }
3222
3223 /*
3224 * Zero terminate the buffer and copy data.
3225 */
3226 char *
3227 ldns_buffer2str(ldns_buffer *buffer)
3228 {
3229 char *str;
3230
3231 /* check if buffer ends with \0, if not, and
3232 if there is space, add it */
3233 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
3234 if (!ldns_buffer_reserve(buffer, 1)) {
3235 return NULL;
3236 }
3237 ldns_buffer_write_char(buffer, (uint8_t) '\0');
3238 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
3239 return NULL;
3240 }
3241 }
3242
3243 str = strdup((const char *)ldns_buffer_begin(buffer));
3244 if(!str) {
3245 return NULL;
3246 }
3247 return str;
3248 }
3249
3250 /*
3251 * Zero terminate the buffer and export data.
3252 */
3253 char *
3254 ldns_buffer_export2str(ldns_buffer *buffer)
3255 {
3256 /* Append '\0' as string terminator */
3257 if (! ldns_buffer_reserve(buffer, 1)) {
3258 return NULL;
3259 }
3260 ldns_buffer_write_char(buffer, 0);
3261
3262 /* reallocate memory to the size of the string and export */
3263 ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer));
3264 return ldns_buffer_export(buffer);
3265 }
3266
3267 char *
3268 ldns_rdf2str(const ldns_rdf *rdf)
3269 {
3270 char *result = NULL;
3271 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
3272
3273 if (!tmp_buffer) {
3274 return NULL;
3275 }
3276 if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
3277 /* export and return string, destroy rest */
3278 result = ldns_buffer_export2str(tmp_buffer);
3279 }
3280 ldns_buffer_free(tmp_buffer);
3281 return result;
3282 }
3283
3284 char *
3285 ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr)
3286 {
3287 char *result = NULL;
3288 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
3289
3290 if (!tmp_buffer) {
3291 return NULL;
3292 }
3293 if (ldns_rr2buffer_str_fmt(tmp_buffer, fmt, rr)
3294 == LDNS_STATUS_OK) {
3295 /* export and return string, destroy rest */
3296 result = ldns_buffer_export2str(tmp_buffer);
3297 }
3298 ldns_buffer_free(tmp_buffer);
3299 return result;
3300 }
3301
3302 char *
3303 ldns_rr2str(const ldns_rr *rr)
3304 {
3305 return ldns_rr2str_fmt(ldns_output_format_default, rr);
3306 }
3307
3308 char *
3309 ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt)
3310 {
3311 char *result = NULL;
3312 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
3313
3314 if (!tmp_buffer) {
3315 return NULL;
3316 }
3317 if (ldns_pkt2buffer_str_fmt(tmp_buffer, fmt, pkt)
3318 == LDNS_STATUS_OK) {
3319 /* export and return string, destroy rest */
3320 result = ldns_buffer_export2str(tmp_buffer);
3321 }
3322
3323 ldns_buffer_free(tmp_buffer);
3324 return result;
3325 }
3326
3327 char *
3328 ldns_pkt2str(const ldns_pkt *pkt)
3329 {
3330 return ldns_pkt2str_fmt(ldns_output_format_default, pkt);
3331 }
3332
3333 char *
3334 ldns_key2str(const ldns_key *k)
3335 {
3336 char *result = NULL;
3337 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
3338
3339 if (!tmp_buffer) {
3340 return NULL;
3341 }
3342 if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) {
3343 /* export and return string, destroy rest */
3344 result = ldns_buffer_export2str(tmp_buffer);
3345 }
3346 ldns_buffer_free(tmp_buffer);
3347 return result;
3348 }
3349
3350 char *
3351 ldns_rr_list2str_fmt(const ldns_output_format *fmt, const ldns_rr_list *list)
3352 {
3353 char *result = NULL;
3354 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
3355
3356 if (!tmp_buffer) {
3357 return NULL;
3358 }
3359 if (list) {
3360 if (ldns_rr_list2buffer_str_fmt(
3361 tmp_buffer, fmt, list)
3362 == LDNS_STATUS_OK) {
3363 }
3364 } else {
3365 if (fmt == NULL) {
3366 fmt = ldns_output_format_default;
3367 }
3368 if (fmt->flags & LDNS_COMMENT_NULLS) {
3369 ldns_buffer_printf(tmp_buffer, "; (null)\n");
3370 }
3371 }
3372
3373 /* export and return string, destroy rest */
3374 result = ldns_buffer_export2str(tmp_buffer);
3375 ldns_buffer_free(tmp_buffer);
3376 return result;
3377 }
3378
3379 char *
3380 ldns_rr_list2str(const ldns_rr_list *list)
3381 {
3382 return ldns_rr_list2str_fmt(ldns_output_format_default, list);
3383 }
3384
3385 void
3386 ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
3387 {
3388 char *str = ldns_rdf2str(rdf);
3389 if (str) {
3390 fprintf(output, "%s", str);
3391 } else {
3392 fprintf(output, ";Unable to convert rdf to string\n");
3393 }
3394 LDNS_FREE(str);
3395 }
3396
3397 void
3398 ldns_rr_print_fmt(FILE *output,
3399 const ldns_output_format *fmt, const ldns_rr *rr)
3400 {
3401 char *str = ldns_rr2str_fmt(fmt, rr);
3402 if (str) {
3403 fprintf(output, "%s", str);
3404 } else {
3405 fprintf(output, ";Unable to convert rr to string\n");
3406 }
3407 LDNS_FREE(str);
3408 }
3409
3410 void
3411 ldns_rr_print(FILE *output, const ldns_rr *rr)
3412 {
3413 ldns_rr_print_fmt(output, ldns_output_format_default, rr);
3414 }
3415
3416 void
3417 ldns_pkt_print_fmt(FILE *output,
3418 const ldns_output_format *fmt, const ldns_pkt *pkt)
3419 {
3420 char *str = ldns_pkt2str_fmt(fmt, pkt);
3421 if (str) {
3422 fprintf(output, "%s", str);
3423 } else {
3424 fprintf(output, ";Unable to convert packet to string\n");
3425 }
3426 LDNS_FREE(str);
3427 }
3428
3429 void
3430 ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
3431 {
3432 ldns_pkt_print_fmt(output, ldns_output_format_default, pkt);
3433 }
3434
3435 void
3436 ldns_rr_list_print_fmt(FILE *output,
3437 const ldns_output_format *fmt, const ldns_rr_list *lst)
3438 {
3439 size_t i;
3440 for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
3441 ldns_rr_print_fmt(output, fmt, ldns_rr_list_rr(lst, i));
3442 }
3443 }
3444
3445 void
3446 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
3447 {
3448 ldns_rr_list_print_fmt(output, ldns_output_format_default, lst);
3449 }
3450
3451 void
3452 ldns_resolver_print_fmt(FILE *output,
3453 const ldns_output_format *fmt, const ldns_resolver *r)
3454 {
3455 uint16_t i;
3456 ldns_rdf **n;
3457 ldns_rdf **s;
3458 size_t *rtt;
3459 if (!r) {
3460 return;
3461 }
3462 n = ldns_resolver_nameservers(r);
3463 s = ldns_resolver_searchlist(r);
3464 rtt = ldns_resolver_rtt(r);
3465
3466 fprintf(output, "port: %d\n", (int)ldns_resolver_port(r));
3467 fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r));
3468 fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r));
3469
3470 fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r));
3471 fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r));
3472 fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r));
3473 fprintf(output, "fail: %d\n", ldns_resolver_fail(r));
3474 fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r));
3475 fprintf(output, "retrans: %d\n", (int)ldns_resolver_retrans(r));
3476 fprintf(output, "fallback: %d\n", ldns_resolver_fallback(r));
3477 fprintf(output, "random: %d\n", ldns_resolver_random(r));
3478 fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
3479 fprintf(output, "dnssec: %d\n", ldns_resolver_dnssec(r));
3480 fprintf(output, "dnssec cd: %d\n", ldns_resolver_dnssec_cd(r));
3481 fprintf(output, "trust anchors (%d listed):\n",
3482 (int)ldns_rr_list_rr_count(ldns_resolver_dnssec_anchors(r)));
3483 ldns_rr_list_print_fmt(output, fmt, ldns_resolver_dnssec_anchors(r));
3484 fprintf(output, "tsig: %s %s\n",
3485 ldns_resolver_tsig_keyname(r)?ldns_resolver_tsig_keyname(r):"-",
3486 ldns_resolver_tsig_algorithm(r)?ldns_resolver_tsig_algorithm(r):"-");
3487 fprintf(output, "debug: %d\n", ldns_resolver_debug(r));
3488
3489 fprintf(output, "default domain: ");
3490 ldns_rdf_print(output, ldns_resolver_domain(r));
3491 fprintf(output, "\n");
3492 fprintf(output, "apply default domain: %d\n", ldns_resolver_defnames(r));
3493
3494 fprintf(output, "searchlist (%d listed):\n", (int)ldns_resolver_searchlist_count(r));
3495 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
3496 fprintf(output, "\t");
3497 ldns_rdf_print(output, s[i]);
3498 fprintf(output, "\n");
3499 }
3500 fprintf(output, "apply search list: %d\n", ldns_resolver_dnsrch(r));
3501
3502 fprintf(output, "nameservers (%d listed):\n", (int)ldns_resolver_nameserver_count(r));
3503 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
3504 fprintf(output, "\t");
3505 ldns_rdf_print(output, n[i]);
3506
3507 switch ((int)rtt[i]) {
3508 case LDNS_RESOLV_RTT_MIN:
3509 fprintf(output, " - reachable\n");
3510 break;
3511 case LDNS_RESOLV_RTT_INF:
3512 fprintf(output, " - unreachable\n");
3513 break;
3514 }
3515 }
3516 }
3517
3518 void
3519 ldns_resolver_print(FILE *output, const ldns_resolver *r)
3520 {
3521 ldns_resolver_print_fmt(output, ldns_output_format_default, r);
3522 }
3523
3524 void
3525 ldns_zone_print_fmt(FILE *output,
3526 const ldns_output_format *fmt, const ldns_zone *z)
3527 {
3528 if(ldns_zone_soa(z))
3529 ldns_rr_print_fmt(output, fmt, ldns_zone_soa(z));
3530 ldns_rr_list_print_fmt(output, fmt, ldns_zone_rrs(z));
3531 }
3532 void
3533 ldns_zone_print(FILE *output, const ldns_zone *z)
3534 {
3535 ldns_zone_print_fmt(output, ldns_output_format_default, z);
3536 }
DragonFly BSD