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 #ifndef INET_ADDRSTRLEN
32 #define INET_ADDRSTRLEN 16
33 #endif
34 #ifndef INET6_ADDRSTRLEN
35 #define INET6_ADDRSTRLEN 46
36 #endif
37
38 /* lookup tables for standard DNS stuff */
39
40 /* Taken from RFC 2535, section 7. */
41 ldns_lookup_table ldns_algorithms[] = {
42 { LDNS_RSAMD5, "RSAMD5" },
43 { LDNS_DH, "DH" },
44 { LDNS_DSA, "DSA" },
45 { LDNS_ECC, "ECC" },
46 { LDNS_RSASHA1, "RSASHA1" },
47 { LDNS_DSA_NSEC3, "DSA-NSEC3-SHA1" },
48 { LDNS_RSASHA1_NSEC3, "RSASHA1-NSEC3-SHA1" },
49 #ifdef USE_SHA2
50 { LDNS_RSASHA256, "RSASHA256"},
51 { LDNS_RSASHA512, "RSASHA512"},
52 #endif
53 #ifdef USE_GOST
54 { LDNS_ECC_GOST, "ECC-GOST"},
55 #endif
56 #ifdef USE_ECDSA
57 { LDNS_ECDSAP256SHA256, "ECDSAP256SHA256"},
58 { LDNS_ECDSAP384SHA384, "ECDSAP384SHA384"},
59 #endif
60 { LDNS_INDIRECT, "INDIRECT" },
61 { LDNS_PRIVATEDNS, "PRIVATEDNS" },
62 { LDNS_PRIVATEOID, "PRIVATEOID" },
63 { 0, NULL }
64 };
65
66 /* Taken from RFC 4398 */
67 ldns_lookup_table ldns_cert_algorithms[] = {
68 { LDNS_CERT_PKIX, "PKIX" },
69 { LDNS_CERT_SPKI, "SPKI" },
70 { LDNS_CERT_PGP, "PGP" },
71 { LDNS_CERT_IPKIX, "IPKIX" },
72 { LDNS_CERT_ISPKI, "ISPKI" },
73 { LDNS_CERT_IPGP, "IPGP" },
74 { LDNS_CERT_ACPKIX, "ACPKIX" },
75 { LDNS_CERT_IACPKIX, "IACPKIX" },
76 { LDNS_CERT_URI, "URI" },
77 { LDNS_CERT_OID, "OID" },
78 { 0, NULL }
79 };
80
81 /* classes */
82 ldns_lookup_table ldns_rr_classes[] = {
83 { LDNS_RR_CLASS_IN, "IN" },
84 { LDNS_RR_CLASS_CH, "CH" },
85 { LDNS_RR_CLASS_HS, "HS" },
86 { LDNS_RR_CLASS_NONE, "NONE" },
87 { LDNS_RR_CLASS_ANY, "ANY" },
88 { 0, NULL }
89 };
90
91 /* if these are used elsewhere */
92 ldns_lookup_table ldns_rcodes[] = {
93 { LDNS_RCODE_NOERROR, "NOERROR" },
94 { LDNS_RCODE_FORMERR, "FORMERR" },
95 { LDNS_RCODE_SERVFAIL, "SERVFAIL" },
96 { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" },
97 { LDNS_RCODE_NOTIMPL, "NOTIMPL" },
98 { LDNS_RCODE_REFUSED, "REFUSED" },
99 { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" },
100 { LDNS_RCODE_YXRRSET, "YXRRSET" },
101 { LDNS_RCODE_NXRRSET, "NXRRSET" },
102 { LDNS_RCODE_NOTAUTH, "NOTAUTH" },
103 { LDNS_RCODE_NOTZONE, "NOTZONE" },
104 { 0, NULL }
105 };
106
107 ldns_lookup_table ldns_opcodes[] = {
108 { LDNS_PACKET_QUERY, "QUERY" },
109 { LDNS_PACKET_IQUERY, "IQUERY" },
110 { LDNS_PACKET_STATUS, "STATUS" },
111 { LDNS_PACKET_NOTIFY, "NOTIFY" },
112 { LDNS_PACKET_UPDATE, "UPDATE" },
113 { 0, NULL }
114 };
115
116 const ldns_output_format ldns_output_format_nocomments_record = { 0, NULL };
117 const ldns_output_format *ldns_output_format_nocomments
118 = &ldns_output_format_nocomments_record;
119 const ldns_output_format ldns_output_format_onlykeyids_record = {
120 LDNS_COMMENT_KEY, NULL
121 };
122 const ldns_output_format *ldns_output_format_onlykeyids
123 = &ldns_output_format_onlykeyids_record;
124 const ldns_output_format *ldns_output_format_default
125 = &ldns_output_format_onlykeyids_record;
126
127 const ldns_output_format ldns_output_format_bubblebabble_record = {
128 LDNS_COMMENT_KEY | LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS, NULL
129 };
130 const ldns_output_format *ldns_output_format_bubblebabble
131 = &ldns_output_format_bubblebabble_record;
132
133 static bool
ldns_output_format_covers_type(const ldns_output_format * fmt,ldns_rr_type t)134 ldns_output_format_covers_type(const ldns_output_format* fmt, ldns_rr_type t)
135 {
136 return fmt && (fmt->flags & LDNS_FMT_RFC3597) &&
137 ((ldns_output_format_storage*)fmt)->bitmap &&
138 ldns_nsec_bitmap_covers_type(
139 ((ldns_output_format_storage*)fmt)->bitmap, t);
140 }
141
142 ldns_status
ldns_output_format_set_type(ldns_output_format * fmt,ldns_rr_type t)143 ldns_output_format_set_type(ldns_output_format* fmt, ldns_rr_type t)
144 {
145 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
146 ldns_status s;
147
148 assert(fmt != NULL);
149
150 if (!(fmt_st->flags & LDNS_FMT_RFC3597)) {
151 ldns_output_format_set(fmt, LDNS_FMT_RFC3597);
152 }
153 if (! fmt_st->bitmap) {
154 s = ldns_rdf_bitmap_known_rr_types_space(&fmt_st->bitmap);
155 if (s != LDNS_STATUS_OK) {
156 return s;
157 }
158 }
159 return ldns_nsec_bitmap_set_type(fmt_st->bitmap, t);
160 }
161
162 ldns_status
ldns_output_format_clear_type(ldns_output_format * fmt,ldns_rr_type t)163 ldns_output_format_clear_type(ldns_output_format* fmt, ldns_rr_type t)
164 {
165 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
166 ldns_status s;
167
168 assert(fmt != NULL);
169
170 if (!(fmt_st->flags & LDNS_FMT_RFC3597)) {
171 ldns_output_format_set(fmt, LDNS_FMT_RFC3597);
172 }
173 if (! fmt_st->bitmap) {
174 s = ldns_rdf_bitmap_known_rr_types(&fmt_st->bitmap);
175 if (s != LDNS_STATUS_OK) {
176 return s;
177 }
178 }
179 return ldns_nsec_bitmap_clear_type(fmt_st->bitmap, t);
180 }
181
182 ldns_status
ldns_pkt_opcode2buffer_str(ldns_buffer * output,ldns_pkt_opcode opcode)183 ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode)
184 {
185 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode);
186 if (lt && lt->name) {
187 ldns_buffer_printf(output, "%s", lt->name);
188 } else {
189 ldns_buffer_printf(output, "OPCODE%u", opcode);
190 }
191 return ldns_buffer_status(output);
192 }
193
194 ldns_status
ldns_pkt_rcode2buffer_str(ldns_buffer * output,ldns_pkt_rcode rcode)195 ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode)
196 {
197 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode);
198 if (lt && lt->name) {
199 ldns_buffer_printf(output, "%s", lt->name);
200 } else {
201 ldns_buffer_printf(output, "RCODE%u", rcode);
202 }
203 return ldns_buffer_status(output);
204 }
205
206 ldns_status
ldns_algorithm2buffer_str(ldns_buffer * output,ldns_algorithm algorithm)207 ldns_algorithm2buffer_str(ldns_buffer *output,
208 ldns_algorithm algorithm)
209 {
210 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_algorithms,
211 algorithm);
212 if (lt && lt->name) {
213 ldns_buffer_printf(output, "%s", lt->name);
214 } else {
215 ldns_buffer_printf(output, "ALG%u", algorithm);
216 }
217 return ldns_buffer_status(output);
218 }
219
220 ldns_status
ldns_cert_algorithm2buffer_str(ldns_buffer * output,ldns_cert_algorithm cert_algorithm)221 ldns_cert_algorithm2buffer_str(ldns_buffer *output,
222 ldns_cert_algorithm cert_algorithm)
223 {
224 ldns_lookup_table *lt = ldns_lookup_by_id(ldns_cert_algorithms,
225 cert_algorithm);
226 if (lt && lt->name) {
227 ldns_buffer_printf(output, "%s", lt->name);
228 } else {
229 ldns_buffer_printf(output, "CERT_ALG%u",
230 cert_algorithm);
231 }
232 return ldns_buffer_status(output);
233 }
234
235 char *
ldns_pkt_opcode2str(ldns_pkt_opcode opcode)236 ldns_pkt_opcode2str(ldns_pkt_opcode opcode)
237 {
238 char *str;
239 ldns_buffer *buf;
240
241 buf = ldns_buffer_new(12);
242 if (!buf) {
243 return NULL;
244 }
245
246 str = NULL;
247 if (ldns_pkt_opcode2buffer_str(buf, opcode) == LDNS_STATUS_OK) {
248 str = ldns_buffer_export2str(buf);
249 }
250
251 ldns_buffer_free(buf);
252 return str;
253 }
254
255 char *
ldns_pkt_rcode2str(ldns_pkt_rcode rcode)256 ldns_pkt_rcode2str(ldns_pkt_rcode rcode)
257 {
258 char *str;
259 ldns_buffer *buf;
260
261 buf = ldns_buffer_new(10);
262 if (!buf) {
263 return NULL;
264 }
265
266 str = NULL;
267 if (ldns_pkt_rcode2buffer_str(buf, rcode) == LDNS_STATUS_OK) {
268 str = ldns_buffer_export2str(buf);
269 }
270
271 ldns_buffer_free(buf);
272 return str;
273 }
274
275 char *
ldns_pkt_algorithm2str(ldns_algorithm algorithm)276 ldns_pkt_algorithm2str(ldns_algorithm algorithm)
277 {
278 char *str;
279 ldns_buffer *buf;
280
281 buf = ldns_buffer_new(10);
282 if (!buf) {
283 return NULL;
284 }
285
286 str = NULL;
287 if (ldns_algorithm2buffer_str(buf, algorithm)
288 == LDNS_STATUS_OK) {
289 str = ldns_buffer_export2str(buf);
290 }
291
292 ldns_buffer_free(buf);
293 return str;
294 }
295
296 char *
ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm)297 ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm)
298 {
299 char *str;
300 ldns_buffer *buf;
301
302 buf = ldns_buffer_new(10);
303 if (!buf) {
304 return NULL;
305 }
306
307 str = NULL;
308 if (ldns_cert_algorithm2buffer_str(buf, cert_algorithm)
309 == LDNS_STATUS_OK) {
310 str = ldns_buffer_export2str(buf);
311 }
312
313 ldns_buffer_free(buf);
314 return str;
315 }
316
317
318 /* do NOT pass compressed data here :p */
319 ldns_status
ldns_rdf2buffer_str_dname(ldns_buffer * output,const ldns_rdf * dname)320 ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
321 {
322 /* can we do with 1 pos var? or without at all? */
323 uint8_t src_pos = 0;
324 uint8_t len;
325 uint8_t *data;
326 uint8_t i;
327 unsigned char c;
328
329 data = (uint8_t*)ldns_rdf_data(dname);
330 len = data[src_pos];
331
332 if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) {
333 /* too large, return */
334 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
335 }
336
337 /* special case: root label */
338 if (1 == ldns_rdf_size(dname)) {
339 ldns_buffer_printf(output, ".");
340 } else {
341 while ((len > 0) && src_pos < ldns_rdf_size(dname)) {
342 src_pos++;
343 for(i = 0; i < len; i++) {
344 /* paranoia check for various 'strange'
345 characters in dnames
346 */
347 c = (unsigned char) data[src_pos];
348 if(c == '.' || c == ';' ||
349 c == '(' || c == ')' ||
350 c == '\\') {
351 ldns_buffer_printf(output, "\\%c",
352 data[src_pos]);
353 } else if (!(isascii(c) && isgraph(c))) {
354 ldns_buffer_printf(output, "\\%03u",
355 data[src_pos]);
356 } else {
357 ldns_buffer_printf(output, "%c", data[src_pos]);
358 }
359 src_pos++;
360 }
361
362 if (src_pos < ldns_rdf_size(dname)) {
363 ldns_buffer_printf(output, ".");
364 }
365 len = data[src_pos];
366 }
367 }
368 return ldns_buffer_status(output);
369 }
370
371 ldns_status
ldns_rdf2buffer_str_int8(ldns_buffer * output,const ldns_rdf * rdf)372 ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
373 {
374 uint8_t data = ldns_rdf_data(rdf)[0];
375 ldns_buffer_printf(output, "%lu", (unsigned long) data);
376 return ldns_buffer_status(output);
377 }
378
379 ldns_status
ldns_rdf2buffer_str_int16(ldns_buffer * output,const ldns_rdf * rdf)380 ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
381 {
382 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
383 ldns_buffer_printf(output, "%lu", (unsigned long) data);
384 return ldns_buffer_status(output);
385 }
386
387 ldns_status
ldns_rdf2buffer_str_int32(ldns_buffer * output,const ldns_rdf * rdf)388 ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
389 {
390 uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
391 ldns_buffer_printf(output, "%lu", (unsigned long) data);
392 return ldns_buffer_status(output);
393 }
394
395 ldns_status
ldns_rdf2buffer_str_time(ldns_buffer * output,const ldns_rdf * rdf)396 ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
397 {
398 /* create a YYYYMMDDHHMMSS string if possible */
399 struct tm tm;
400 char date_buf[16];
401
402 memset(&tm, 0, sizeof(tm));
403 if (ldns_serial_arithmitics_gmtime_r(ldns_rdf2native_int32(rdf), time(NULL), &tm)
404 && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
405 ldns_buffer_printf(output, "%s", date_buf);
406 }
407 return ldns_buffer_status(output);
408 }
409
410 ldns_status
ldns_rdf2buffer_str_a(ldns_buffer * output,const ldns_rdf * rdf)411 ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
412 {
413 char str[INET_ADDRSTRLEN];
414
415 if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) {
416 ldns_buffer_printf(output, "%s", str);
417 }
418 return ldns_buffer_status(output);
419 }
420
421 ldns_status
ldns_rdf2buffer_str_aaaa(ldns_buffer * output,const ldns_rdf * rdf)422 ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
423 {
424 char str[INET6_ADDRSTRLEN];
425
426 if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) {
427 ldns_buffer_printf(output, "%s", str);
428 }
429
430 return ldns_buffer_status(output);
431 }
432
433 static void
ldns_characters2buffer_str(ldns_buffer * output,size_t amount,const uint8_t * characters)434 ldns_characters2buffer_str(ldns_buffer* output,
435 size_t amount, const uint8_t* characters)
436 {
437 uint8_t ch;
438 while (amount > 0) {
439 ch = *characters++;
440 if (isprint((int)ch) || ch == '\t') {
441 if (ch == '\"' || ch == '\\')
442 ldns_buffer_printf(output, "\\%c", ch);
443 else
444 ldns_buffer_printf(output, "%c", ch);
445 } else {
446 ldns_buffer_printf(output, "\\%03u",
447 (unsigned)(uint8_t) ch);
448 }
449 amount--;
450 }
451 }
452
453 ldns_status
ldns_rdf2buffer_str_str(ldns_buffer * output,const ldns_rdf * rdf)454 ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
455 {
456 if(ldns_rdf_size(rdf) < 1) {
457 return LDNS_STATUS_WIRE_RDATA_ERR;
458 }
459 if((int)ldns_rdf_size(rdf) < (int)ldns_rdf_data(rdf)[0] + 1) {
460 return LDNS_STATUS_WIRE_RDATA_ERR;
461 }
462 ldns_buffer_printf(output, "\"");
463 ldns_characters2buffer_str(output,
464 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf) + 1);
465 ldns_buffer_printf(output, "\"");
466 return ldns_buffer_status(output);
467 }
468
469 ldns_status
ldns_rdf2buffer_str_b64(ldns_buffer * output,const ldns_rdf * rdf)470 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
471 {
472 size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf));
473 char *b64 = LDNS_XMALLOC(char, size);
474 if(!b64) return LDNS_STATUS_MEM_ERR;
475 if (ldns_b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) {
476 ldns_buffer_printf(output, "%s", b64);
477 }
478 LDNS_FREE(b64);
479 return ldns_buffer_status(output);
480 }
481
482 ldns_status
ldns_rdf2buffer_str_b32_ext(ldns_buffer * output,const ldns_rdf * rdf)483 ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf)
484 {
485 size_t size;
486 char *b32;
487 if(ldns_rdf_size(rdf) == 0)
488 return LDNS_STATUS_OK;
489 /* remove -1 for the b32-hash-len octet */
490 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
491 /* add one for the end nul for the string */
492 b32 = LDNS_XMALLOC(char, size + 1);
493 if(!b32) return LDNS_STATUS_MEM_ERR;
494 size = (size_t) ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
495 ldns_rdf_size(rdf) - 1, b32, size+1);
496 if (size > 0) {
497 ldns_buffer_printf(output, "%s", b32);
498 }
499 LDNS_FREE(b32);
500 return ldns_buffer_status(output);
501 }
502
503 ldns_status
ldns_rdf2buffer_str_hex(ldns_buffer * output,const ldns_rdf * rdf)504 ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
505 {
506 size_t i;
507 for (i = 0; i < ldns_rdf_size(rdf); i++) {
508 ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]);
509 }
510
511 return ldns_buffer_status(output);
512 }
513
514 static ldns_status
ldns_rdf2buffer_str_type_fmt(ldns_buffer * output,const ldns_output_format * fmt,const ldns_rdf * rdf)515 ldns_rdf2buffer_str_type_fmt(ldns_buffer *output,
516 const ldns_output_format* fmt, const ldns_rdf *rdf)
517 {
518 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
519
520 if (! ldns_output_format_covers_type(fmt, data) &&
521 ldns_rr_descript(data) &&
522 ldns_rr_descript(data)->_name) {
523
524 ldns_buffer_printf(output, "%s",ldns_rr_descript(data)->_name);
525 } else {
526 ldns_buffer_printf(output, "TYPE%u", data);
527 }
528 return ldns_buffer_status(output);
529 }
530
531 ldns_status
ldns_rdf2buffer_str_type(ldns_buffer * output,const ldns_rdf * rdf)532 ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
533 {
534 return ldns_rdf2buffer_str_type_fmt(output,
535 ldns_output_format_default, rdf);
536 }
537
538 ldns_status
ldns_rdf2buffer_str_class(ldns_buffer * output,const ldns_rdf * rdf)539 ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
540 {
541 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
542 ldns_lookup_table *lt;
543
544 lt = ldns_lookup_by_id(ldns_rr_classes, (int) data);
545 if (lt) {
546 ldns_buffer_printf(output, "\t%s", lt->name);
547 } else {
548 ldns_buffer_printf(output, "\tCLASS%d", data);
549 }
550 return ldns_buffer_status(output);
551 }
552
553 ldns_status
ldns_rdf2buffer_str_cert_alg(ldns_buffer * output,const ldns_rdf * rdf)554 ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
555 {
556 uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
557 ldns_lookup_table *lt;
558 lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data);
559 if (lt) {
560 ldns_buffer_printf(output, "%s", lt->name);
561 } else {
562 ldns_buffer_printf(output, "%d", data);
563 }
564 return ldns_buffer_status(output);
565 }
566
567 ldns_status
ldns_rdf2buffer_str_alg(ldns_buffer * output,const ldns_rdf * rdf)568 ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
569 {
570 /* don't use algorithm mnemonics in the presentation format
571 this kind of got sneaked into the rfc's */
572 uint8_t data = ldns_rdf_data(rdf)[0];
573 ldns_buffer_printf(output, "%d", data);
574 return ldns_buffer_status(output);
575 }
576
577 static void
loc_cm_print(ldns_buffer * output,uint8_t mantissa,uint8_t exponent)578 loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
579 {
580 uint8_t i;
581 /* is it 0.<two digits> ? */
582 if(exponent < 2) {
583 if(exponent == 1)
584 mantissa *= 10;
585 ldns_buffer_printf(output, "0.%02ld", (long)mantissa);
586 return;
587 }
588 /* always <digit><string of zeros> */
589 ldns_buffer_printf(output, "%d", (int)mantissa);
590 for(i=0; i<exponent-2; i++)
591 ldns_buffer_printf(output, "0");
592 }
593
594 ldns_status
ldns_rr_type2buffer_str(ldns_buffer * output,const ldns_rr_type type)595 ldns_rr_type2buffer_str(ldns_buffer *output, const ldns_rr_type type)
596 {
597 const ldns_rr_descriptor *descriptor;
598
599 descriptor = ldns_rr_descript(type);
600
601 if (descriptor && descriptor->_name) {
602 ldns_buffer_printf(output, "%s", descriptor->_name);
603 } else {
604 /* exceptions for pseudotypes */
605 switch (type) {
606 case LDNS_RR_TYPE_IXFR:
607 ldns_buffer_printf(output, "IXFR");
608 break;
609 case LDNS_RR_TYPE_AXFR:
610 ldns_buffer_printf(output, "AXFR");
611 break;
612 case LDNS_RR_TYPE_MAILA:
613 ldns_buffer_printf(output, "MAILA");
614 break;
615 case LDNS_RR_TYPE_MAILB:
616 ldns_buffer_printf(output, "MAILB");
617 break;
618 case LDNS_RR_TYPE_ANY:
619 ldns_buffer_printf(output, "ANY");
620 break;
621 default:
622 ldns_buffer_printf(output, "TYPE%u", type);
623 }
624 }
625 return ldns_buffer_status(output);
626 }
627
628 char *
ldns_rr_type2str(const ldns_rr_type type)629 ldns_rr_type2str(const ldns_rr_type type)
630 {
631 char *str;
632 ldns_buffer *buf;
633
634 buf = ldns_buffer_new(10);
635 if (!buf) {
636 return NULL;
637 }
638
639 str = NULL;
640 if (ldns_rr_type2buffer_str(buf, type) == LDNS_STATUS_OK) {
641 str = ldns_buffer_export2str(buf);
642 }
643
644 ldns_buffer_free(buf);
645 return str;
646 }
647
648
649 ldns_status
ldns_rr_class2buffer_str(ldns_buffer * output,const ldns_rr_class klass)650 ldns_rr_class2buffer_str(ldns_buffer *output,
651 const ldns_rr_class klass)
652 {
653 ldns_lookup_table *lt;
654
655 lt = ldns_lookup_by_id(ldns_rr_classes, klass);
656 if (lt) {
657 ldns_buffer_printf(output, "%s", lt->name);
658 } else {
659 ldns_buffer_printf(output, "CLASS%d", klass);
660 }
661 return ldns_buffer_status(output);
662 }
663
664 char *
ldns_rr_class2str(const ldns_rr_class klass)665 ldns_rr_class2str(const ldns_rr_class klass)
666 {
667 ldns_buffer *buf;
668 char *str;
669
670 buf = ldns_buffer_new(10);
671 if (!buf) {
672 return NULL;
673 }
674
675 str = NULL;
676 if (ldns_rr_class2buffer_str(buf, klass) == LDNS_STATUS_OK) {
677 str = ldns_buffer_export2str(buf);
678 }
679 ldns_buffer_free(buf);
680 return str;
681 }
682
683 ldns_status
ldns_rdf2buffer_str_loc(ldns_buffer * output,const ldns_rdf * rdf)684 ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
685 {
686 /* we could do checking (ie degrees < 90 etc)? */
687 uint8_t version;
688 uint8_t size;
689 uint8_t horizontal_precision;
690 uint8_t vertical_precision;
691 uint32_t longitude;
692 uint32_t latitude;
693 uint32_t altitude;
694 char northerness;
695 char easterness;
696 uint32_t h;
697 uint32_t m;
698 double s;
699
700 uint32_t equator = (uint32_t) ldns_power(2, 31);
701
702 if(ldns_rdf_size(rdf) < 1) {
703 return LDNS_STATUS_WIRE_RDATA_ERR;
704 }
705 version = ldns_rdf_data(rdf)[0];
706 if (version == 0) {
707 if(ldns_rdf_size(rdf) < 16) {
708 return LDNS_STATUS_WIRE_RDATA_ERR;
709 }
710 size = ldns_rdf_data(rdf)[1];
711 horizontal_precision = ldns_rdf_data(rdf)[2];
712 vertical_precision = ldns_rdf_data(rdf)[3];
713
714 latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]);
715 longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]);
716 altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]);
717
718 if (latitude > equator) {
719 northerness = 'N';
720 latitude = latitude - equator;
721 } else {
722 northerness = 'S';
723 latitude = equator - latitude;
724 }
725 h = latitude / (1000 * 60 * 60);
726 latitude = latitude % (1000 * 60 * 60);
727 m = latitude / (1000 * 60);
728 latitude = latitude % (1000 * 60);
729 s = (double) latitude / 1000.0;
730 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
731 h, m, s, northerness);
732
733 if (longitude > equator) {
734 easterness = 'E';
735 longitude = longitude - equator;
736 } else {
737 easterness = 'W';
738 longitude = equator - longitude;
739 }
740 h = longitude / (1000 * 60 * 60);
741 longitude = longitude % (1000 * 60 * 60);
742 m = longitude / (1000 * 60);
743 longitude = longitude % (1000 * 60);
744 s = (double) longitude / (1000.0);
745 ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
746 h, m, s, easterness);
747
748
749 s = ((double) altitude) / 100;
750 s -= 100000;
751
752 if(altitude%100 != 0)
753 ldns_buffer_printf(output, "%.2f", s);
754 else
755 ldns_buffer_printf(output, "%.0f", s);
756
757 ldns_buffer_printf(output, "m ");
758
759 loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
760 ldns_buffer_printf(output, "m ");
761
762 loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
763 horizontal_precision & 0x0f);
764 ldns_buffer_printf(output, "m ");
765
766 loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
767 vertical_precision & 0x0f);
768 ldns_buffer_printf(output, "m");
769
770 return ldns_buffer_status(output);
771 } else {
772 return ldns_rdf2buffer_str_hex(output, rdf);
773 }
774 }
775
776 ldns_status
ldns_rdf2buffer_str_unknown(ldns_buffer * output,const ldns_rdf * rdf)777 ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
778 {
779 ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
780 return ldns_rdf2buffer_str_hex(output, rdf);
781 }
782
783 ldns_status
ldns_rdf2buffer_str_nsap(ldns_buffer * output,const ldns_rdf * rdf)784 ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
785 {
786 ldns_buffer_printf(output, "0x");
787 return ldns_rdf2buffer_str_hex(output, rdf);
788 }
789
790 ldns_status
ldns_rdf2buffer_str_atma(ldns_buffer * output,const ldns_rdf * rdf)791 ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf)
792 {
793 return ldns_rdf2buffer_str_hex(output, rdf);
794 }
795
796 ldns_status
ldns_rdf2buffer_str_wks(ldns_buffer * output,const ldns_rdf * rdf)797 ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
798 {
799 /* protocol, followed by bitmap of services */
800 struct protoent *protocol;
801 char *proto_name = NULL;
802 uint8_t protocol_nr;
803 struct servent *service;
804 uint16_t current_service;
805
806 if(ldns_rdf_size(rdf) < 1) {
807 return LDNS_STATUS_WIRE_RDATA_ERR;
808 }
809 protocol_nr = ldns_rdf_data(rdf)[0];
810 protocol = getprotobynumber((int) protocol_nr);
811 if (protocol && (protocol->p_name != NULL)) {
812 proto_name = protocol->p_name;
813 ldns_buffer_printf(output, "%s ", protocol->p_name);
814 } else {
815 ldns_buffer_printf(output, "%u ", protocol_nr);
816 }
817
818 #ifdef HAVE_ENDPROTOENT
819 endprotoent();
820 #endif
821
822 for (current_service = 0;
823 current_service < ldns_rdf_size(rdf) * 7; current_service++) {
824 if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) {
825 service = getservbyport((int) htons(current_service),
826 proto_name);
827 if (service && service->s_name) {
828 ldns_buffer_printf(output, "%s ", service->s_name);
829 } else {
830 ldns_buffer_printf(output, "%u ", current_service);
831 }
832 #ifdef HAVE_ENDSERVENT
833 endservent();
834 #endif
835 }
836 }
837 return ldns_buffer_status(output);
838 }
839
840 static ldns_status
ldns_rdf2buffer_str_nsec_fmt(ldns_buffer * output,const ldns_output_format * fmt,const ldns_rdf * rdf)841 ldns_rdf2buffer_str_nsec_fmt(ldns_buffer *output,
842 const ldns_output_format* fmt, const ldns_rdf *rdf)
843 {
844 /* Note: this code is duplicated in higher.c in
845 * ldns_nsec_type_check() function
846 */
847 uint8_t window_block_nr;
848 uint8_t bitmap_length;
849 uint16_t type;
850 uint16_t pos = 0;
851 uint16_t bit_pos;
852 uint8_t *data = ldns_rdf_data(rdf);
853
854 while((size_t)(pos + 2) < ldns_rdf_size(rdf)) {
855 window_block_nr = data[pos];
856 bitmap_length = data[pos + 1];
857 pos += 2;
858 if (ldns_rdf_size(rdf) < pos + bitmap_length) {
859 return LDNS_STATUS_WIRE_RDATA_ERR;
860 }
861 for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
862 if (! ldns_get_bit(&data[pos], bit_pos)) {
863 continue;
864 }
865 type = 256 * (uint16_t) window_block_nr + bit_pos;
866
867 if (! ldns_output_format_covers_type(fmt, type) &&
868 ldns_rr_descript(type) &&
869 ldns_rr_descript(type)->_name){
870
871 ldns_buffer_printf(output, "%s ",
872 ldns_rr_descript(type)->_name);
873 } else {
874 ldns_buffer_printf(output, "TYPE%u ", type);
875 }
876 }
877 pos += (uint16_t) bitmap_length;
878 }
879 return ldns_buffer_status(output);
880 }
881
882 ldns_status
ldns_rdf2buffer_str_nsec(ldns_buffer * output,const ldns_rdf * rdf)883 ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
884 {
885 return ldns_rdf2buffer_str_nsec_fmt(output,
886 ldns_output_format_default, rdf);
887 }
888
889 ldns_status
ldns_rdf2buffer_str_nsec3_salt(ldns_buffer * output,const ldns_rdf * rdf)890 ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf)
891 {
892 uint8_t salt_length;
893 uint8_t salt_pos;
894
895 uint8_t *data = ldns_rdf_data(rdf);
896
897 if(ldns_rdf_size(rdf) < 1) {
898 return LDNS_STATUS_WIRE_RDATA_ERR;
899 }
900 salt_length = data[0];
901 /* from now there are variable length entries so remember pos */
902 if (salt_length == 0 || ((size_t)salt_length)+1 > ldns_rdf_size(rdf)) {
903 ldns_buffer_printf(output, "- ");
904 } else {
905 for (salt_pos = 0; salt_pos < salt_length; salt_pos++) {
906 ldns_buffer_printf(output, "%02x", data[1 + salt_pos]);
907 }
908 ldns_buffer_printf(output, " ");
909 }
910
911 return ldns_buffer_status(output);
912 }
913
914 ldns_status
ldns_rdf2buffer_str_period(ldns_buffer * output,const ldns_rdf * rdf)915 ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
916 {
917 /* period is the number of seconds */
918 if (ldns_rdf_size(rdf) != 4) {
919 return LDNS_STATUS_WIRE_RDATA_ERR;
920 }
921 ldns_buffer_printf(output, "%u", ldns_read_uint32(ldns_rdf_data(rdf)));
922 return ldns_buffer_status(output);
923 }
924
925 ldns_status
ldns_rdf2buffer_str_tsigtime(ldns_buffer * output,const ldns_rdf * rdf)926 ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const ldns_rdf *rdf)
927 {
928 /* tsigtime is 48 bits network order unsigned integer */
929 uint64_t tsigtime = 0;
930 uint8_t *data = ldns_rdf_data(rdf);
931 uint64_t d0, d1, d2, d3, d4, d5;
932
933 if (ldns_rdf_size(rdf) < 6) {
934 return LDNS_STATUS_WIRE_RDATA_ERR;
935 }
936 d0 = data[0]; /* cast to uint64 for shift operations */
937 d1 = data[1];
938 d2 = data[2];
939 d3 = data[3];
940 d4 = data[4];
941 d5 = data[5];
942 tsigtime = (d0<<40) | (d1<<32) | (d2<<24) | (d3<<16) | (d4<<8) | d5;
943
944 ldns_buffer_printf(output, "%llu ", (long long)tsigtime);
945
946 return ldns_buffer_status(output);
947 }
948
949 ldns_status
ldns_rdf2buffer_str_apl(ldns_buffer * output,const ldns_rdf * rdf)950 ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
951 {
952 uint8_t *data = ldns_rdf_data(rdf);
953 uint16_t address_family;
954 uint8_t prefix;
955 bool negation;
956 uint8_t adf_length;
957 size_t i;
958 size_t pos = 0;
959
960 while (pos < (unsigned int) ldns_rdf_size(rdf)) {
961 if(pos + 3 >= (unsigned)ldns_rdf_size(rdf))
962 return LDNS_STATUS_WIRE_RDATA_ERR;
963 address_family = ldns_read_uint16(&data[pos]);
964 prefix = data[pos + 2];
965 negation = data[pos + 3] & LDNS_APL_NEGATION;
966 adf_length = data[pos + 3] & LDNS_APL_MASK;
967 if (address_family == LDNS_APL_IP4) {
968 /* check if prefix < 32? */
969 if (negation) {
970 ldns_buffer_printf(output, "!");
971 }
972 ldns_buffer_printf(output, "%u:", address_family);
973 /* address is variable length 0 - 4 */
974 for (i = 0; i < 4; i++) {
975 if (i > 0) {
976 ldns_buffer_printf(output, ".");
977 }
978 if (i < (unsigned short) adf_length) {
979 if(pos+i+4 >= ldns_rdf_size(rdf))
980 return LDNS_STATUS_WIRE_RDATA_ERR;
981 ldns_buffer_printf(output, "%d",
982 data[pos + i + 4]);
983 } else {
984 ldns_buffer_printf(output, "0");
985 }
986 }
987 ldns_buffer_printf(output, "/%u ", prefix);
988 } else if (address_family == LDNS_APL_IP6) {
989 /* check if prefix < 128? */
990 if (negation) {
991 ldns_buffer_printf(output, "!");
992 }
993 ldns_buffer_printf(output, "%u:", address_family);
994 /* address is variable length 0 - 16 */
995 for (i = 0; i < 16; i++) {
996 if (i % 2 == 0 && i > 0) {
997 ldns_buffer_printf(output, ":");
998 }
999 if (i < (unsigned short) adf_length) {
1000 if(pos+i+4 >= ldns_rdf_size(rdf))
1001 return LDNS_STATUS_WIRE_RDATA_ERR;
1002 ldns_buffer_printf(output, "%02x",
1003 data[pos + i + 4]);
1004 } else {
1005 ldns_buffer_printf(output, "00");
1006 }
1007 }
1008 ldns_buffer_printf(output, "/%u ", prefix);
1009
1010 } else {
1011 /* unknown address family */
1012 ldns_buffer_printf(output,
1013 "Unknown address family: %u data: ",
1014 address_family);
1015 for (i = 1; i < (unsigned short) (4 + adf_length); i++) {
1016 if(pos+i >= ldns_rdf_size(rdf))
1017 return LDNS_STATUS_WIRE_RDATA_ERR;
1018 ldns_buffer_printf(output, "%02x", data[i]);
1019 }
1020 }
1021 pos += 4 + adf_length;
1022 }
1023 return ldns_buffer_status(output);
1024 }
1025
1026 ldns_status
ldns_rdf2buffer_str_int16_data(ldns_buffer * output,const ldns_rdf * rdf)1027 ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
1028 {
1029 size_t size;
1030 char *b64;
1031 if (ldns_rdf_size(rdf) < 2) {
1032 return LDNS_STATUS_WIRE_RDATA_ERR;
1033 }
1034 /* Subtract the size (2) of the number that specifies the length */
1035 size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
1036 ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
1037 if (ldns_rdf_size(rdf) > 2) {
1038 b64 = LDNS_XMALLOC(char, size);
1039 if(!b64)
1040 return LDNS_STATUS_MEM_ERR;
1041
1042 if (ldns_rdf_size(rdf) > 2 &&
1043 ldns_b64_ntop(ldns_rdf_data(rdf) + 2,
1044 ldns_rdf_size(rdf) - 2,
1045 b64, size)) {
1046 ldns_buffer_printf(output, "%s", b64);
1047 }
1048 LDNS_FREE(b64);
1049 }
1050 return ldns_buffer_status(output);
1051 }
1052
1053 ldns_status
ldns_rdf2buffer_str_ipseckey(ldns_buffer * output,const ldns_rdf * rdf)1054 ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
1055 {
1056 /* wire format from
1057 http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt
1058 */
1059 uint8_t *data = ldns_rdf_data(rdf);
1060 uint8_t precedence;
1061 uint8_t gateway_type;
1062 uint8_t algorithm;
1063
1064 ldns_rdf *gateway = NULL;
1065 uint8_t *gateway_data;
1066
1067 size_t public_key_size;
1068 uint8_t *public_key_data;
1069 ldns_rdf *public_key;
1070
1071 size_t offset = 0;
1072 ldns_status status;
1073
1074 if (ldns_rdf_size(rdf) < 3) {
1075 return LDNS_STATUS_WIRE_RDATA_ERR;
1076 }
1077 precedence = data[0];
1078 gateway_type = data[1];
1079 algorithm = data[2];
1080 offset = 3;
1081
1082 switch (gateway_type) {
1083 case 0:
1084 /* no gateway */
1085 break;
1086 case 1:
1087 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
1088 if(!gateway_data)
1089 return LDNS_STATUS_MEM_ERR;
1090 if (ldns_rdf_size(rdf) < offset + LDNS_IP4ADDRLEN) {
1091 return LDNS_STATUS_ERR;
1092 }
1093 memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
1094 gateway = ldns_rdf_new(LDNS_RDF_TYPE_A,
1095 LDNS_IP4ADDRLEN , gateway_data);
1096 offset += LDNS_IP4ADDRLEN;
1097 if(!gateway) {
1098 LDNS_FREE(gateway_data);
1099 return LDNS_STATUS_MEM_ERR;
1100 }
1101 break;
1102 case 2:
1103 gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
1104 if(!gateway_data)
1105 return LDNS_STATUS_MEM_ERR;
1106 if (ldns_rdf_size(rdf) < offset + LDNS_IP6ADDRLEN) {
1107 return LDNS_STATUS_ERR;
1108 }
1109 memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
1110 offset += LDNS_IP6ADDRLEN;
1111 gateway =
1112 ldns_rdf_new(LDNS_RDF_TYPE_AAAA,
1113 LDNS_IP6ADDRLEN, gateway_data);
1114 if(!gateway) {
1115 LDNS_FREE(gateway_data);
1116 return LDNS_STATUS_MEM_ERR;
1117 }
1118 break;
1119 case 3:
1120 status = ldns_wire2dname(&gateway, data,
1121 ldns_rdf_size(rdf), &offset);
1122 if(status != LDNS_STATUS_OK)
1123 return status;
1124 break;
1125 default:
1126 /* error? */
1127 break;
1128 }
1129
1130 if (ldns_rdf_size(rdf) <= offset) {
1131 return LDNS_STATUS_ERR;
1132 }
1133 public_key_size = ldns_rdf_size(rdf) - offset;
1134 public_key_data = LDNS_XMALLOC(uint8_t, public_key_size);
1135 if(!public_key_data) {
1136 ldns_rdf_free(gateway);
1137 return LDNS_STATUS_MEM_ERR;
1138 }
1139 memcpy(public_key_data, &data[offset], public_key_size);
1140 public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64,
1141 public_key_size, public_key_data);
1142 if(!public_key) {
1143 LDNS_FREE(public_key_data);
1144 ldns_rdf_free(gateway);
1145 return LDNS_STATUS_MEM_ERR;
1146 }
1147
1148 ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm);
1149 if (gateway)
1150 (void) ldns_rdf2buffer_str(output, gateway);
1151 else
1152 ldns_buffer_printf(output, ".");
1153 ldns_buffer_printf(output, " ");
1154 (void) ldns_rdf2buffer_str(output, public_key);
1155
1156 ldns_rdf_free(gateway);
1157 ldns_rdf_free(public_key);
1158
1159 return ldns_buffer_status(output);
1160 }
1161
1162 ldns_status
ldns_rdf2buffer_str_ilnp64(ldns_buffer * output,const ldns_rdf * rdf)1163 ldns_rdf2buffer_str_ilnp64(ldns_buffer *output, const ldns_rdf *rdf)
1164 {
1165 if (ldns_rdf_size(rdf) != 8) {
1166 return LDNS_STATUS_WIRE_RDATA_ERR;
1167 }
1168 ldns_buffer_printf(output,"%.4x:%.4x:%.4x:%.4x",
1169 ldns_read_uint16(ldns_rdf_data(rdf)),
1170 ldns_read_uint16(ldns_rdf_data(rdf)+2),
1171 ldns_read_uint16(ldns_rdf_data(rdf)+4),
1172 ldns_read_uint16(ldns_rdf_data(rdf)+6));
1173 return ldns_buffer_status(output);
1174 }
1175
1176 ldns_status
ldns_rdf2buffer_str_eui48(ldns_buffer * output,const ldns_rdf * rdf)1177 ldns_rdf2buffer_str_eui48(ldns_buffer *output, const ldns_rdf *rdf)
1178 {
1179 if (ldns_rdf_size(rdf) != 6) {
1180 return LDNS_STATUS_WIRE_RDATA_ERR;
1181 }
1182 ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
1183 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1],
1184 ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3],
1185 ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5]);
1186 return ldns_buffer_status(output);
1187 }
1188
1189 ldns_status
ldns_rdf2buffer_str_eui64(ldns_buffer * output,const ldns_rdf * rdf)1190 ldns_rdf2buffer_str_eui64(ldns_buffer *output, const ldns_rdf *rdf)
1191 {
1192 if (ldns_rdf_size(rdf) != 8) {
1193 return LDNS_STATUS_WIRE_RDATA_ERR;
1194 }
1195 ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
1196 ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1],
1197 ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3],
1198 ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5],
1199 ldns_rdf_data(rdf)[6], ldns_rdf_data(rdf)[7]);
1200 return ldns_buffer_status(output);
1201 }
1202
1203 ldns_status
ldns_rdf2buffer_str_tag(ldns_buffer * output,const ldns_rdf * rdf)1204 ldns_rdf2buffer_str_tag(ldns_buffer *output, const ldns_rdf *rdf)
1205 {
1206 size_t nchars;
1207 const uint8_t* chars;
1208 char ch;
1209 if (ldns_rdf_size(rdf) < 2) {
1210 return LDNS_STATUS_WIRE_RDATA_ERR;
1211 }
1212 nchars = ldns_rdf_data(rdf)[0];
1213 if (nchars >= ldns_rdf_size(rdf) || /* should be rdf_size - 1 */
1214 nchars < 1) {
1215 return LDNS_STATUS_WIRE_RDATA_ERR;
1216 }
1217 chars = ldns_rdf_data(rdf) + 1;
1218 while (nchars > 0) {
1219 ch = (char)*chars++;
1220 if (! isalnum(ch)) {
1221 return LDNS_STATUS_WIRE_RDATA_ERR;
1222 }
1223 ldns_buffer_printf(output, "%c", ch);
1224 nchars--;
1225 }
1226 return ldns_buffer_status(output);
1227 }
1228
1229 ldns_status
ldns_rdf2buffer_str_long_str(ldns_buffer * output,const ldns_rdf * rdf)1230 ldns_rdf2buffer_str_long_str(ldns_buffer *output, const ldns_rdf *rdf)
1231 {
1232
1233 ldns_buffer_printf(output, "\"");
1234 ldns_characters2buffer_str(output,
1235 ldns_rdf_size(rdf), ldns_rdf_data(rdf));
1236 ldns_buffer_printf(output, "\"");
1237 return ldns_buffer_status(output);
1238 }
1239
1240 ldns_status
ldns_rdf2buffer_str_hip(ldns_buffer * output,const ldns_rdf * rdf)1241 ldns_rdf2buffer_str_hip(ldns_buffer *output, const ldns_rdf *rdf)
1242 {
1243 uint8_t *data = ldns_rdf_data(rdf);
1244 size_t rdf_size = ldns_rdf_size(rdf);
1245 uint8_t hit_size;
1246 uint16_t pk_size;
1247 int written;
1248
1249 if (rdf_size < 6) {
1250 return LDNS_STATUS_WIRE_RDATA_ERR;
1251 }
1252 if ((hit_size = data[0]) == 0 ||
1253 (pk_size = ldns_read_uint16(data + 2)) == 0 ||
1254 rdf_size < (size_t) hit_size + pk_size + 4) {
1255
1256 return LDNS_STATUS_WIRE_RDATA_ERR;
1257 }
1258
1259 ldns_buffer_printf(output, "%d ", (int) data[1]);
1260
1261 for (data += 4; hit_size > 0; hit_size--, data++) {
1262
1263 ldns_buffer_printf(output, "%02x", (int) *data);
1264 }
1265 ldns_buffer_write_u8(output, (uint8_t) ' ');
1266
1267 if (ldns_buffer_reserve(output,
1268 ldns_b64_ntop_calculate_size(pk_size))) {
1269
1270 written = ldns_b64_ntop(data, pk_size,
1271 (char *) ldns_buffer_current(output),
1272 ldns_buffer_remaining(output));
1273
1274 if (written > 0 &&
1275 written < (int) ldns_buffer_remaining(output)) {
1276
1277 output->_position += written;
1278 }
1279 }
1280 return ldns_buffer_status(output);
1281 }
1282
1283 static ldns_status
ldns_rdf2buffer_str_fmt(ldns_buffer * buffer,const ldns_output_format * fmt,const ldns_rdf * rdf)1284 ldns_rdf2buffer_str_fmt(ldns_buffer *buffer,
1285 const ldns_output_format* fmt, const ldns_rdf *rdf)
1286 {
1287 ldns_status res = LDNS_STATUS_OK;
1288
1289 /*ldns_buffer_printf(buffer, "%u:", ldns_rdf_get_type(rdf));*/
1290 if (rdf) {
1291 switch(ldns_rdf_get_type(rdf)) {
1292 case LDNS_RDF_TYPE_NONE:
1293 break;
1294 case LDNS_RDF_TYPE_DNAME:
1295 res = ldns_rdf2buffer_str_dname(buffer, rdf);
1296 break;
1297 case LDNS_RDF_TYPE_INT8:
1298 res = ldns_rdf2buffer_str_int8(buffer, rdf);
1299 break;
1300 case LDNS_RDF_TYPE_INT16:
1301 res = ldns_rdf2buffer_str_int16(buffer, rdf);
1302 break;
1303 case LDNS_RDF_TYPE_INT32:
1304 res = ldns_rdf2buffer_str_int32(buffer, rdf);
1305 break;
1306 case LDNS_RDF_TYPE_PERIOD:
1307 res = ldns_rdf2buffer_str_period(buffer, rdf);
1308 break;
1309 case LDNS_RDF_TYPE_TSIGTIME:
1310 res = ldns_rdf2buffer_str_tsigtime(buffer, rdf);
1311 break;
1312 case LDNS_RDF_TYPE_A:
1313 res = ldns_rdf2buffer_str_a(buffer, rdf);
1314 break;
1315 case LDNS_RDF_TYPE_AAAA:
1316 res = ldns_rdf2buffer_str_aaaa(buffer, rdf);
1317 break;
1318 case LDNS_RDF_TYPE_STR:
1319 res = ldns_rdf2buffer_str_str(buffer, rdf);
1320 break;
1321 case LDNS_RDF_TYPE_APL:
1322 res = ldns_rdf2buffer_str_apl(buffer, rdf);
1323 break;
1324 case LDNS_RDF_TYPE_B32_EXT:
1325 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1326 break;
1327 case LDNS_RDF_TYPE_B64:
1328 res = ldns_rdf2buffer_str_b64(buffer, rdf);
1329 break;
1330 case LDNS_RDF_TYPE_HEX:
1331 res = ldns_rdf2buffer_str_hex(buffer, rdf);
1332 break;
1333 case LDNS_RDF_TYPE_NSEC:
1334 res = ldns_rdf2buffer_str_nsec_fmt(buffer, fmt, rdf);
1335 break;
1336 case LDNS_RDF_TYPE_NSEC3_SALT:
1337 res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf);
1338 break;
1339 case LDNS_RDF_TYPE_TYPE:
1340 res = ldns_rdf2buffer_str_type_fmt(buffer, fmt, rdf);
1341 break;
1342 case LDNS_RDF_TYPE_CLASS:
1343 res = ldns_rdf2buffer_str_class(buffer, rdf);
1344 break;
1345 case LDNS_RDF_TYPE_CERT_ALG:
1346 res = ldns_rdf2buffer_str_cert_alg(buffer, rdf);
1347 break;
1348 case LDNS_RDF_TYPE_ALG:
1349 res = ldns_rdf2buffer_str_alg(buffer, rdf);
1350 break;
1351 case LDNS_RDF_TYPE_UNKNOWN:
1352 res = ldns_rdf2buffer_str_unknown(buffer, rdf);
1353 break;
1354 case LDNS_RDF_TYPE_TIME:
1355 res = ldns_rdf2buffer_str_time(buffer, rdf);
1356 break;
1357 case LDNS_RDF_TYPE_HIP:
1358 res = ldns_rdf2buffer_str_hip(buffer, rdf);
1359 break;
1360 case LDNS_RDF_TYPE_LOC:
1361 res = ldns_rdf2buffer_str_loc(buffer, rdf);
1362 break;
1363 case LDNS_RDF_TYPE_WKS:
1364 case LDNS_RDF_TYPE_SERVICE:
1365 res = ldns_rdf2buffer_str_wks(buffer, rdf);
1366 break;
1367 case LDNS_RDF_TYPE_NSAP:
1368 res = ldns_rdf2buffer_str_nsap(buffer, rdf);
1369 break;
1370 case LDNS_RDF_TYPE_ATMA:
1371 res = ldns_rdf2buffer_str_atma(buffer, rdf);
1372 break;
1373 case LDNS_RDF_TYPE_IPSECKEY:
1374 res = ldns_rdf2buffer_str_ipseckey(buffer, rdf);
1375 break;
1376 case LDNS_RDF_TYPE_INT16_DATA:
1377 res = ldns_rdf2buffer_str_int16_data(buffer, rdf);
1378 break;
1379 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
1380 res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1381 break;
1382 case LDNS_RDF_TYPE_ILNP64:
1383 res = ldns_rdf2buffer_str_ilnp64(buffer, rdf);
1384 break;
1385 case LDNS_RDF_TYPE_EUI48:
1386 res = ldns_rdf2buffer_str_eui48(buffer, rdf);
1387 break;
1388 case LDNS_RDF_TYPE_EUI64:
1389 res = ldns_rdf2buffer_str_eui64(buffer, rdf);
1390 break;
1391 case LDNS_RDF_TYPE_TAG:
1392 res = ldns_rdf2buffer_str_tag(buffer, rdf);
1393 break;
1394 case LDNS_RDF_TYPE_LONG_STR:
1395 res = ldns_rdf2buffer_str_long_str(buffer, rdf);
1396 break;
1397 }
1398 } else {
1399 /** This will write mangled RRs */
1400 ldns_buffer_printf(buffer, "(null) ");
1401 res = LDNS_STATUS_ERR;
1402 }
1403 return res;
1404 }
1405
1406 ldns_status
ldns_rdf2buffer_str(ldns_buffer * buffer,const ldns_rdf * rdf)1407 ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
1408 {
1409 return ldns_rdf2buffer_str_fmt(buffer,ldns_output_format_default,rdf);
1410 }
1411
1412 static ldns_rdf *
ldns_b32_ext2dname(const ldns_rdf * rdf)1413 ldns_b32_ext2dname(const ldns_rdf *rdf)
1414 {
1415 size_t size;
1416 char *b32;
1417 ldns_rdf *out;
1418 if(ldns_rdf_size(rdf) == 0)
1419 return NULL;
1420 /* remove -1 for the b32-hash-len octet */
1421 size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
1422 /* add one for the end nul for the string */
1423 b32 = LDNS_XMALLOC(char, size + 2);
1424 if (b32) {
1425 if (ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
1426 ldns_rdf_size(rdf) - 1, b32, size+1) > 0) {
1427 b32[size] = '.';
1428 b32[size+1] = '\0';
1429 if (ldns_str2rdf_dname(&out, b32) == LDNS_STATUS_OK) {
1430 LDNS_FREE(b32);
1431 return out;
1432 }
1433 }
1434 LDNS_FREE(b32);
1435 }
1436 return NULL;
1437 }
1438
1439 static ldns_status
ldns_rr2buffer_str_rfc3597(ldns_buffer * output,const ldns_rr * rr)1440 ldns_rr2buffer_str_rfc3597(ldns_buffer *output, const ldns_rr *rr)
1441 {
1442 size_t total_rdfsize = 0;
1443 size_t i, j;
1444
1445 ldns_buffer_printf(output, "TYPE%u\t", ldns_rr_get_type(rr));
1446 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1447 total_rdfsize += ldns_rdf_size(ldns_rr_rdf(rr, i));
1448 }
1449 if (total_rdfsize == 0) {
1450 ldns_buffer_printf(output, "\\# 0\n");
1451 return ldns_buffer_status(output);
1452 }
1453 ldns_buffer_printf(output, "\\# %d ", total_rdfsize);
1454 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1455 for (j = 0; j < ldns_rdf_size(ldns_rr_rdf(rr, i)); j++) {
1456 ldns_buffer_printf(output, "%.2x",
1457 ldns_rdf_data(ldns_rr_rdf(rr, i))[j]);
1458 }
1459 }
1460 ldns_buffer_printf(output, "\n");
1461 return ldns_buffer_status(output);
1462 }
1463
1464 ldns_status
ldns_rr2buffer_str_fmt(ldns_buffer * output,const ldns_output_format * fmt,const ldns_rr * rr)1465 ldns_rr2buffer_str_fmt(ldns_buffer *output,
1466 const ldns_output_format *fmt, const ldns_rr *rr)
1467 {
1468 uint16_t i, flags;
1469 ldns_status status = LDNS_STATUS_OK;
1470 ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
1471
1472 if (fmt_st == NULL) {
1473 fmt_st = (ldns_output_format_storage*)
1474 ldns_output_format_default;
1475 }
1476 if (!rr) {
1477 if (LDNS_COMMENT_NULLS & fmt_st->flags) {
1478 ldns_buffer_printf(output, "; (null)\n");
1479 }
1480 return ldns_buffer_status(output);
1481 }
1482 if (ldns_rr_owner(rr)) {
1483 status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr));
1484 }
1485 if (status != LDNS_STATUS_OK) {
1486 return status;
1487 }
1488
1489 /* TTL should NOT be printed if it is a question */
1490 if (!ldns_rr_is_question(rr)) {
1491 ldns_buffer_printf(output, "\t%d", ldns_rr_ttl(rr));
1492 }
1493
1494 ldns_buffer_printf(output, "\t");
1495 status = ldns_rr_class2buffer_str(output, ldns_rr_get_class(rr));
1496 if (status != LDNS_STATUS_OK) {
1497 return status;
1498 }
1499 ldns_buffer_printf(output, "\t");
1500
1501 if (ldns_output_format_covers_type(fmt, ldns_rr_get_type(rr))) {
1502 return ldns_rr2buffer_str_rfc3597(output, rr);
1503 }
1504 status = ldns_rr_type2buffer_str(output, ldns_rr_get_type(rr));
1505 if (status != LDNS_STATUS_OK) {
1506 return status;
1507 }
1508
1509 if (ldns_rr_rd_count(rr) > 0) {
1510 ldns_buffer_printf(output, "\t");
1511 } else if (!ldns_rr_is_question(rr)) {
1512 ldns_buffer_printf(output, "\t\\# 0");
1513 }
1514
1515 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1516 /* ldns_rdf2buffer_str handles NULL input fine! */
1517 if ((fmt_st->flags & LDNS_FMT_ZEROIZE_RRSIGS) &&
1518 (ldns_rr_get_type(rr) == LDNS_RR_TYPE_RRSIG) &&
1519 ((/* inception */ i == 4 &&
1520 ldns_rdf_get_type(ldns_rr_rdf(rr, 4)) ==
1521 LDNS_RDF_TYPE_TIME) ||
1522 (/* expiration */ i == 5 &&
1523 ldns_rdf_get_type(ldns_rr_rdf(rr, 5)) ==
1524 LDNS_RDF_TYPE_TIME) ||
1525 (/* signature */ i == 8 &&
1526 ldns_rdf_get_type(ldns_rr_rdf(rr, 8)) ==
1527 LDNS_RDF_TYPE_B64))) {
1528
1529 ldns_buffer_printf(output, "(null)");
1530 status = ldns_buffer_status(output);
1531 } else if ((fmt_st->flags & LDNS_FMT_PAD_SOA_SERIAL) &&
1532 (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) &&
1533 /* serial */ i == 2 &&
1534 ldns_rdf_get_type(ldns_rr_rdf(rr, 2)) ==
1535 LDNS_RDF_TYPE_INT32) {
1536 ldns_buffer_printf(output, "%10lu",
1537 (unsigned long) ldns_read_uint32(
1538 ldns_rdf_data(ldns_rr_rdf(rr, 2))));
1539 status = ldns_buffer_status(output);
1540 } else {
1541 status = ldns_rdf2buffer_str_fmt(output,
1542 fmt, ldns_rr_rdf(rr, i));
1543 }
1544 if(status != LDNS_STATUS_OK)
1545 return status;
1546 if (i < ldns_rr_rd_count(rr) - 1) {
1547 ldns_buffer_printf(output, " ");
1548 }
1549 }
1550 /* per RR special comments - handy for DNSSEC types */
1551 /* check to prevent question sec. rr from
1552 * getting here */
1553 if (ldns_rr_rd_count(rr) > 0) {
1554 switch (ldns_rr_get_type(rr)) {
1555 case LDNS_RR_TYPE_DNSKEY:
1556 /* if ldns_rr_rd_count(rr) > 0
1557 then ldns_rr_rdf(rr, 0) exists! */
1558 if (! (fmt_st->flags & LDNS_COMMENT_KEY)) {
1559 break;
1560 }
1561 flags = ldns_rdf2native_int16(ldns_rr_rdf(rr, 0));
1562 ldns_buffer_printf(output, " ;{");
1563 if (fmt_st->flags & LDNS_COMMENT_KEY_ID) {
1564 ldns_buffer_printf(output, "id = %u",
1565 (unsigned int) ldns_calc_keytag(rr));
1566 }
1567 if ((fmt_st->flags & LDNS_COMMENT_KEY_TYPE) &&
1568 (flags & LDNS_KEY_ZONE_KEY)){
1569
1570 if (flags & LDNS_KEY_SEP_KEY) {
1571 ldns_buffer_printf(output, " (ksk)");
1572 } else {
1573 ldns_buffer_printf(output, " (zsk)");
1574 }
1575 if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE){
1576 ldns_buffer_printf(output, ", ");
1577 }
1578 } else if (fmt_st->flags
1579 & (LDNS_COMMENT_KEY_ID
1580 |LDNS_COMMENT_KEY_SIZE)) {
1581 ldns_buffer_printf( output, ", ");
1582 }
1583 if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE) {
1584 ldns_buffer_printf(output, "size = %db",
1585 ldns_rr_dnskey_key_size(rr));
1586 }
1587 ldns_buffer_printf(output, "}");
1588 break;
1589 case LDNS_RR_TYPE_RRSIG:
1590 if ((fmt_st->flags & LDNS_COMMENT_KEY)
1591 && (fmt_st->flags& LDNS_COMMENT_RRSIGS)
1592 && ldns_rr_rdf(rr, 6) != NULL) {
1593 ldns_buffer_printf(output, " ;{id = %d}",
1594 ldns_rdf2native_int16(
1595 ldns_rr_rdf(rr, 6)));
1596 }
1597 break;
1598 case LDNS_RR_TYPE_DS:
1599 if ((fmt_st->flags & LDNS_COMMENT_BUBBLEBABBLE) &&
1600 ldns_rr_rdf(rr, 3) != NULL) {
1601
1602 uint8_t *data = ldns_rdf_data(
1603 ldns_rr_rdf(rr, 3));
1604 size_t len = ldns_rdf_size(ldns_rr_rdf(rr, 3));
1605 char *babble = ldns_bubblebabble(data, len);
1606 if(babble) {
1607 ldns_buffer_printf(output,
1608 " ;{%s}", babble);
1609 }
1610 LDNS_FREE(babble);
1611 }
1612 break;
1613 case LDNS_RR_TYPE_NSEC3:
1614 if (! (fmt_st->flags & LDNS_COMMENT_FLAGS) &&
1615 ! (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN)) {
1616 break;
1617 }
1618 ldns_buffer_printf(output, " ;{");
1619 if ((fmt_st->flags & LDNS_COMMENT_FLAGS)) {
1620 if (ldns_nsec3_optout(rr)) {
1621 ldns_buffer_printf(output,
1622 " flags: optout");
1623 } else {
1624 ldns_buffer_printf(output," flags: -");
1625 }
1626 if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN &&
1627 fmt_st->hashmap != NULL) {
1628 ldns_buffer_printf(output, ", ");
1629 }
1630 }
1631 if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN &&
1632 fmt_st->hashmap != NULL) {
1633 ldns_rbnode_t *node;
1634 ldns_rdf *key = ldns_dname_label(
1635 ldns_rr_owner(rr), 0);
1636 if (key) {
1637 node = ldns_rbtree_search(
1638 fmt_st->hashmap,
1639 (void *) key);
1640 if (node->data) {
1641 ldns_buffer_printf(output,
1642 "from: ");
1643 (void) ldns_rdf2buffer_str(
1644 output,
1645 ldns_dnssec_name_name(
1646 (ldns_dnssec_name*)
1647 node->data
1648 ));
1649 }
1650 ldns_rdf_free(key);
1651 }
1652 key = ldns_b32_ext2dname(
1653 ldns_nsec3_next_owner(rr));
1654 if (key) {
1655 node = ldns_rbtree_search(
1656 fmt_st->hashmap,
1657 (void *) key);
1658 if (node->data) {
1659 ldns_buffer_printf(output,
1660 " to: ");
1661 (void) ldns_rdf2buffer_str(
1662 output,
1663 ldns_dnssec_name_name(
1664 (ldns_dnssec_name*)
1665 node->data
1666 ));
1667 }
1668 ldns_rdf_free(key);
1669 }
1670 }
1671 ldns_buffer_printf(output, "}");
1672 break;
1673 default:
1674 break;
1675
1676 }
1677 }
1678 /* last */
1679 ldns_buffer_printf(output, "\n");
1680 return ldns_buffer_status(output);
1681 }
1682
1683 ldns_status
ldns_rr2buffer_str(ldns_buffer * output,const ldns_rr * rr)1684 ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
1685 {
1686 return ldns_rr2buffer_str_fmt(output, ldns_output_format_default, rr);
1687 }
1688
1689 ldns_status
ldns_rr_list2buffer_str_fmt(ldns_buffer * output,const ldns_output_format * fmt,const ldns_rr_list * list)1690 ldns_rr_list2buffer_str_fmt(ldns_buffer *output,
1691 const ldns_output_format *fmt, const ldns_rr_list *list)
1692 {
1693 uint16_t i;
1694
1695 for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
1696 (void) ldns_rr2buffer_str_fmt(output, fmt,
1697 ldns_rr_list_rr(list, i));
1698 }
1699 return ldns_buffer_status(output);
1700 }
1701
1702 ldns_status
ldns_rr_list2buffer_str(ldns_buffer * output,const ldns_rr_list * list)1703 ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
1704 {
1705 return ldns_rr_list2buffer_str_fmt(
1706 output, ldns_output_format_default, list);
1707 }
1708
1709 ldns_status
ldns_pktheader2buffer_str(ldns_buffer * output,const ldns_pkt * pkt)1710 ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
1711 {
1712 ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
1713 (int) ldns_pkt_get_opcode(pkt));
1714 ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes,
1715 (int) ldns_pkt_get_rcode(pkt));
1716
1717 ldns_buffer_printf(output, ";; ->>HEADER<<- ");
1718 if (opcode) {
1719 ldns_buffer_printf(output, "opcode: %s, ", opcode->name);
1720 } else {
1721 ldns_buffer_printf(output, "opcode: ?? (%u), ",
1722 ldns_pkt_get_opcode(pkt));
1723 }
1724 if (rcode) {
1725 ldns_buffer_printf(output, "rcode: %s, ", rcode->name);
1726 } else {
1727 ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt));
1728 }
1729 ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt));
1730 ldns_buffer_printf(output, ";; flags: ");
1731
1732 if (ldns_pkt_qr(pkt)) {
1733 ldns_buffer_printf(output, "qr ");
1734 }
1735 if (ldns_pkt_aa(pkt)) {
1736 ldns_buffer_printf(output, "aa ");
1737 }
1738 if (ldns_pkt_tc(pkt)) {
1739 ldns_buffer_printf(output, "tc ");
1740 }
1741 if (ldns_pkt_rd(pkt)) {
1742 ldns_buffer_printf(output, "rd ");
1743 }
1744 if (ldns_pkt_cd(pkt)) {
1745 ldns_buffer_printf(output, "cd ");
1746 }
1747 if (ldns_pkt_ra(pkt)) {
1748 ldns_buffer_printf(output, "ra ");
1749 }
1750 if (ldns_pkt_ad(pkt)) {
1751 ldns_buffer_printf(output, "ad ");
1752 }
1753 ldns_buffer_printf(output, "; ");
1754 ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt));
1755 ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt));
1756 ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt));
1757 ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt));
1758 return ldns_buffer_status(output);
1759 }
1760
1761 ldns_status
ldns_pkt2buffer_str_fmt(ldns_buffer * output,const ldns_output_format * fmt,const ldns_pkt * pkt)1762 ldns_pkt2buffer_str_fmt(ldns_buffer *output,
1763 const ldns_output_format *fmt, const ldns_pkt *pkt)
1764 {
1765 uint16_t i;
1766 ldns_status status = LDNS_STATUS_OK;
1767 char *tmp;
1768 struct timeval time;
1769 time_t time_tt;
1770
1771 if (!pkt) {
1772 ldns_buffer_printf(output, "null");
1773 return LDNS_STATUS_OK;
1774 }
1775
1776 if (ldns_buffer_status_ok(output)) {
1777 status = ldns_pktheader2buffer_str(output, pkt);
1778 if (status != LDNS_STATUS_OK) {
1779 return status;
1780 }
1781
1782 ldns_buffer_printf(output, "\n");
1783
1784 ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
1785
1786
1787 for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
1788 status = ldns_rr2buffer_str_fmt(output, fmt,
1789 ldns_rr_list_rr(
1790 ldns_pkt_question(pkt), i));
1791 if (status != LDNS_STATUS_OK) {
1792 return status;
1793 }
1794 }
1795 ldns_buffer_printf(output, "\n");
1796
1797 ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
1798 for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
1799 status = ldns_rr2buffer_str_fmt(output, fmt,
1800 ldns_rr_list_rr(
1801 ldns_pkt_answer(pkt), i));
1802 if (status != LDNS_STATUS_OK) {
1803 return status;
1804 }
1805
1806 }
1807 ldns_buffer_printf(output, "\n");
1808
1809 ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
1810
1811 for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
1812 status = ldns_rr2buffer_str_fmt(output, fmt,
1813 ldns_rr_list_rr(
1814 ldns_pkt_authority(pkt), i));
1815 if (status != LDNS_STATUS_OK) {
1816 return status;
1817 }
1818 }
1819 ldns_buffer_printf(output, "\n");
1820
1821 ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
1822 for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
1823 status = ldns_rr2buffer_str_fmt(output, fmt,
1824 ldns_rr_list_rr(
1825 ldns_pkt_additional(pkt), i));
1826 if (status != LDNS_STATUS_OK) {
1827 return status;
1828 }
1829
1830 }
1831 ldns_buffer_printf(output, "\n");
1832 /* add some futher fields */
1833 ldns_buffer_printf(output, ";; Query time: %d msec\n",
1834 ldns_pkt_querytime(pkt));
1835 if (ldns_pkt_edns(pkt)) {
1836 ldns_buffer_printf(output,
1837 ";; EDNS: version %u; flags:",
1838 ldns_pkt_edns_version(pkt));
1839 if (ldns_pkt_edns_do(pkt)) {
1840 ldns_buffer_printf(output, " do");
1841 }
1842 /* the extended rcode is the value set, shifted four bits,
1843 * and or'd with the original rcode */
1844 if (ldns_pkt_edns_extended_rcode(pkt)) {
1845 ldns_buffer_printf(output, " ; ext-rcode: %d",
1846 (ldns_pkt_edns_extended_rcode(pkt) << 4 | ldns_pkt_get_rcode(pkt)));
1847 }
1848 ldns_buffer_printf(output, " ; udp: %u\n",
1849 ldns_pkt_edns_udp_size(pkt));
1850
1851 if (ldns_pkt_edns_data(pkt)) {
1852 ldns_buffer_printf(output, ";; Data: ");
1853 (void)ldns_rdf2buffer_str(output,
1854 ldns_pkt_edns_data(pkt));
1855 ldns_buffer_printf(output, "\n");
1856 }
1857 }
1858 if (ldns_pkt_tsig(pkt)) {
1859 ldns_buffer_printf(output, ";; TSIG:\n;; ");
1860 (void) ldns_rr2buffer_str_fmt(
1861 output, fmt, ldns_pkt_tsig(pkt));
1862 ldns_buffer_printf(output, "\n");
1863 }
1864 if (ldns_pkt_answerfrom(pkt)) {
1865 tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
1866 ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
1867 LDNS_FREE(tmp);
1868 }
1869 time = ldns_pkt_timestamp(pkt);
1870 time_tt = (time_t)time.tv_sec;
1871 ldns_buffer_printf(output, ";; WHEN: %s",
1872 (char*)ctime(&time_tt));
1873
1874 ldns_buffer_printf(output, ";; MSG SIZE rcvd: %d\n",
1875 (int)ldns_pkt_size(pkt));
1876 } else {
1877 return ldns_buffer_status(output);
1878 }
1879 return status;
1880 }
1881
1882 ldns_status
ldns_pkt2buffer_str(ldns_buffer * output,const ldns_pkt * pkt)1883 ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
1884 {
1885 return ldns_pkt2buffer_str_fmt(output, ldns_output_format_default, pkt);
1886 }
1887
1888
1889 #ifdef HAVE_SSL
1890 static ldns_status
ldns_hmac_key2buffer_str(ldns_buffer * output,const ldns_key * k)1891 ldns_hmac_key2buffer_str(ldns_buffer *output, const ldns_key *k)
1892 {
1893 ldns_status status;
1894 size_t i;
1895 ldns_rdf *b64_bignum;
1896
1897 ldns_buffer_printf(output, "Key: ");
1898
1899 i = ldns_key_hmac_size(k);
1900 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k));
1901 status = ldns_rdf2buffer_str(output, b64_bignum);
1902 ldns_rdf_deep_free(b64_bignum);
1903 ldns_buffer_printf(output, "\n");
1904 return status;
1905 }
1906 #endif
1907
1908 #if defined(HAVE_SSL) && defined(USE_GOST)
1909 static ldns_status
ldns_gost_key2buffer_str(ldns_buffer * output,EVP_PKEY * p)1910 ldns_gost_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
1911 {
1912 unsigned char* pp = NULL;
1913 int ret;
1914 ldns_rdf *b64_bignum;
1915 ldns_status status;
1916
1917 ldns_buffer_printf(output, "GostAsn1: ");
1918
1919 ret = i2d_PrivateKey(p, &pp);
1920 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, (size_t)ret, pp);
1921 status = ldns_rdf2buffer_str(output, b64_bignum);
1922
1923 ldns_rdf_deep_free(b64_bignum);
1924 OPENSSL_free(pp);
1925 ldns_buffer_printf(output, "\n");
1926 return status;
1927 }
1928 #endif
1929
1930 ldns_status
ldns_key2buffer_str(ldns_buffer * output,const ldns_key * k)1931 ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
1932 {
1933 ldns_status status = LDNS_STATUS_OK;
1934 unsigned char *bignum;
1935 #ifdef HAVE_SSL
1936 # ifndef S_SPLINT_S
1937 uint16_t i;
1938 # endif
1939 /* not used when ssl is not defined */
1940 /*@unused@*/
1941 ldns_rdf *b64_bignum = NULL;
1942
1943 RSA *rsa;
1944 DSA *dsa;
1945 #endif /* HAVE_SSL */
1946
1947 if (!k) {
1948 return LDNS_STATUS_ERR;
1949 }
1950
1951 bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
1952 if (!bignum) {
1953 return LDNS_STATUS_ERR;
1954 }
1955
1956 if (ldns_buffer_status_ok(output)) {
1957 #ifdef HAVE_SSL
1958 switch(ldns_key_algorithm(k)) {
1959 case LDNS_SIGN_RSASHA1:
1960 case LDNS_SIGN_RSASHA1_NSEC3:
1961 case LDNS_SIGN_RSASHA256:
1962 case LDNS_SIGN_RSASHA512:
1963 case LDNS_SIGN_RSAMD5:
1964 /* copied by looking at dnssec-keygen output */
1965 /* header */
1966 rsa = ldns_key_rsa_key(k);
1967
1968 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
1969 switch(ldns_key_algorithm(k)) {
1970 case LDNS_SIGN_RSAMD5:
1971 ldns_buffer_printf(output,
1972 "Algorithm: %u (RSA)\n",
1973 LDNS_RSAMD5);
1974 break;
1975 case LDNS_SIGN_RSASHA1:
1976 ldns_buffer_printf(output,
1977 "Algorithm: %u (RSASHA1)\n",
1978 LDNS_RSASHA1);
1979 break;
1980 case LDNS_SIGN_RSASHA1_NSEC3:
1981 ldns_buffer_printf(output,
1982 "Algorithm: %u (RSASHA1_NSEC3)\n",
1983 LDNS_RSASHA1_NSEC3);
1984 break;
1985 #ifdef USE_SHA2
1986 case LDNS_SIGN_RSASHA256:
1987 ldns_buffer_printf(output,
1988 "Algorithm: %u (RSASHA256)\n",
1989 LDNS_RSASHA256);
1990 break;
1991 case LDNS_SIGN_RSASHA512:
1992 ldns_buffer_printf(output,
1993 "Algorithm: %u (RSASHA512)\n",
1994 LDNS_RSASHA512);
1995 break;
1996 #endif
1997 default:
1998 #ifdef STDERR_MSGS
1999 fprintf(stderr, "Warning: unknown signature ");
2000 fprintf(stderr,
2001 "algorithm type %u\n",
2002 ldns_key_algorithm(k));
2003 #endif
2004 ldns_buffer_printf(output,
2005 "Algorithm: %u (Unknown)\n",
2006 ldns_key_algorithm(k));
2007 break;
2008 }
2009
2010 /* print to buf, convert to bin, convert to b64,
2011 * print to buf */
2012 ldns_buffer_printf(output, "Modulus: ");
2013 #ifndef S_SPLINT_S
2014 i = (uint16_t)BN_bn2bin(rsa->n, bignum);
2015 if (i > LDNS_MAX_KEYLEN) {
2016 goto error;
2017 }
2018 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2019 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2020 ldns_rdf_deep_free(b64_bignum);
2021 goto error;
2022 }
2023 ldns_rdf_deep_free(b64_bignum);
2024 ldns_buffer_printf(output, "\n");
2025 ldns_buffer_printf(output, "PublicExponent: ");
2026 i = (uint16_t)BN_bn2bin(rsa->e, bignum);
2027 if (i > LDNS_MAX_KEYLEN) {
2028 goto error;
2029 }
2030 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2031 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2032 ldns_rdf_deep_free(b64_bignum);
2033 goto error;
2034 }
2035 ldns_rdf_deep_free(b64_bignum);
2036 ldns_buffer_printf(output, "\n");
2037
2038 ldns_buffer_printf(output, "PrivateExponent: ");
2039 if (rsa->d) {
2040 i = (uint16_t)BN_bn2bin(rsa->d, bignum);
2041 if (i > LDNS_MAX_KEYLEN) {
2042 goto error;
2043 }
2044 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2045 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2046 ldns_rdf_deep_free(b64_bignum);
2047 goto error;
2048 }
2049 ldns_rdf_deep_free(b64_bignum);
2050 ldns_buffer_printf(output, "\n");
2051 } else {
2052 ldns_buffer_printf(output, "(Not available)\n");
2053 }
2054
2055 ldns_buffer_printf(output, "Prime1: ");
2056 if (rsa->p) {
2057 i = (uint16_t)BN_bn2bin(rsa->p, bignum);
2058 if (i > LDNS_MAX_KEYLEN) {
2059 goto error;
2060 }
2061 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2062 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2063 ldns_rdf_deep_free(b64_bignum);
2064 goto error;
2065 }
2066 ldns_rdf_deep_free(b64_bignum);
2067 ldns_buffer_printf(output, "\n");
2068 } else {
2069 ldns_buffer_printf(output, "(Not available)\n");
2070 }
2071
2072 ldns_buffer_printf(output, "Prime2: ");
2073 if (rsa->q) {
2074 i = (uint16_t)BN_bn2bin(rsa->q, bignum);
2075 if (i > LDNS_MAX_KEYLEN) {
2076 goto error;
2077 }
2078 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2079 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2080 ldns_rdf_deep_free(b64_bignum);
2081 goto error;
2082 }
2083 ldns_rdf_deep_free(b64_bignum);
2084 ldns_buffer_printf(output, "\n");
2085 } else {
2086 ldns_buffer_printf(output, "(Not available)\n");
2087 }
2088
2089 ldns_buffer_printf(output, "Exponent1: ");
2090 if (rsa->dmp1) {
2091 i = (uint16_t)BN_bn2bin(rsa->dmp1, bignum);
2092 if (i > LDNS_MAX_KEYLEN) {
2093 goto error;
2094 }
2095 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2096 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2097 ldns_rdf_deep_free(b64_bignum);
2098 goto error;
2099 }
2100 ldns_rdf_deep_free(b64_bignum);
2101 ldns_buffer_printf(output, "\n");
2102 } else {
2103 ldns_buffer_printf(output, "(Not available)\n");
2104 }
2105
2106 ldns_buffer_printf(output, "Exponent2: ");
2107 if (rsa->dmq1) {
2108 i = (uint16_t)BN_bn2bin(rsa->dmq1, bignum);
2109 if (i > LDNS_MAX_KEYLEN) {
2110 goto error;
2111 }
2112 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2113 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2114 ldns_rdf_deep_free(b64_bignum);
2115 goto error;
2116 }
2117 ldns_rdf_deep_free(b64_bignum);
2118 ldns_buffer_printf(output, "\n");
2119 } else {
2120 ldns_buffer_printf(output, "(Not available)\n");
2121 }
2122
2123 ldns_buffer_printf(output, "Coefficient: ");
2124 if (rsa->iqmp) {
2125 i = (uint16_t)BN_bn2bin(rsa->iqmp, bignum);
2126 if (i > LDNS_MAX_KEYLEN) {
2127 goto error;
2128 }
2129 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2130 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2131 ldns_rdf_deep_free(b64_bignum);
2132 goto error;
2133 }
2134 ldns_rdf_deep_free(b64_bignum);
2135 ldns_buffer_printf(output, "\n");
2136 } else {
2137 ldns_buffer_printf(output, "(Not available)\n");
2138 }
2139 #endif /* splint */
2140
2141 RSA_free(rsa);
2142 break;
2143 case LDNS_SIGN_DSA:
2144 case LDNS_SIGN_DSA_NSEC3:
2145 dsa = ldns_key_dsa_key(k);
2146
2147 ldns_buffer_printf(output,"Private-key-format: v1.2\n");
2148 if (ldns_key_algorithm(k) == LDNS_SIGN_DSA) {
2149 ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n");
2150 } else if (ldns_key_algorithm(k) == LDNS_SIGN_DSA_NSEC3) {
2151 ldns_buffer_printf(output,"Algorithm: 6 (DSA_NSEC3)\n");
2152 }
2153
2154 /* print to buf, convert to bin, convert to b64,
2155 * print to buf */
2156 ldns_buffer_printf(output, "Prime(p): ");
2157 #ifndef S_SPLINT_S
2158 if (dsa->p) {
2159 i = (uint16_t)BN_bn2bin(dsa->p, bignum);
2160 if (i > LDNS_MAX_KEYLEN) {
2161 goto error;
2162 }
2163 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2164 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2165 ldns_rdf_deep_free(b64_bignum);
2166 goto error;
2167 }
2168 ldns_rdf_deep_free(b64_bignum);
2169 ldns_buffer_printf(output, "\n");
2170 } else {
2171 printf("(Not available)\n");
2172 }
2173
2174 ldns_buffer_printf(output, "Subprime(q): ");
2175 if (dsa->q) {
2176 i = (uint16_t)BN_bn2bin(dsa->q, bignum);
2177 if (i > LDNS_MAX_KEYLEN) {
2178 goto error;
2179 }
2180 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2181 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2182 ldns_rdf_deep_free(b64_bignum);
2183 goto error;
2184 }
2185 ldns_rdf_deep_free(b64_bignum);
2186 ldns_buffer_printf(output, "\n");
2187 } else {
2188 printf("(Not available)\n");
2189 }
2190
2191 ldns_buffer_printf(output, "Base(g): ");
2192 if (dsa->g) {
2193 i = (uint16_t)BN_bn2bin(dsa->g, bignum);
2194 if (i > LDNS_MAX_KEYLEN) {
2195 goto error;
2196 }
2197 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2198 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2199 ldns_rdf_deep_free(b64_bignum);
2200 goto error;
2201 }
2202 ldns_rdf_deep_free(b64_bignum);
2203 ldns_buffer_printf(output, "\n");
2204 } else {
2205 printf("(Not available)\n");
2206 }
2207
2208 ldns_buffer_printf(output, "Private_value(x): ");
2209 if (dsa->priv_key) {
2210 i = (uint16_t)BN_bn2bin(dsa->priv_key, bignum);
2211 if (i > LDNS_MAX_KEYLEN) {
2212 goto error;
2213 }
2214 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2215 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2216 ldns_rdf_deep_free(b64_bignum);
2217 goto error;
2218 }
2219 ldns_rdf_deep_free(b64_bignum);
2220 ldns_buffer_printf(output, "\n");
2221 } else {
2222 printf("(Not available)\n");
2223 }
2224
2225 ldns_buffer_printf(output, "Public_value(y): ");
2226 if (dsa->pub_key) {
2227 i = (uint16_t)BN_bn2bin(dsa->pub_key, bignum);
2228 if (i > LDNS_MAX_KEYLEN) {
2229 goto error;
2230 }
2231 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2232 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2233 ldns_rdf_deep_free(b64_bignum);
2234 goto error;
2235 }
2236 ldns_rdf_deep_free(b64_bignum);
2237 ldns_buffer_printf(output, "\n");
2238 } else {
2239 printf("(Not available)\n");
2240 }
2241 #endif /* splint */
2242 break;
2243 case LDNS_SIGN_ECC_GOST:
2244 /* no format defined, use blob */
2245 #if defined(HAVE_SSL) && defined(USE_GOST)
2246 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
2247 ldns_buffer_printf(output, "Algorithm: %d (ECC-GOST)\n", LDNS_SIGN_ECC_GOST);
2248 status = ldns_gost_key2buffer_str(output,
2249 #ifndef S_SPLINT_S
2250 k->_key.key
2251 #else
2252 NULL
2253 #endif
2254 );
2255 #else
2256 goto error;
2257 #endif /* GOST */
2258 break;
2259 case LDNS_SIGN_ECDSAP256SHA256:
2260 case LDNS_SIGN_ECDSAP384SHA384:
2261 #ifdef USE_ECDSA
2262 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
2263 ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
2264 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
2265 #ifndef S_SPLINT_S
2266 ldns_buffer_printf(output, ")\n");
2267 if(k->_key.key) {
2268 EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->_key.key);
2269 const BIGNUM* b = EC_KEY_get0_private_key(ec);
2270 ldns_buffer_printf(output, "PrivateKey: ");
2271 i = (uint16_t)BN_bn2bin(b, bignum);
2272 if (i > LDNS_MAX_KEYLEN) {
2273 goto error;
2274 }
2275 b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, bignum);
2276 if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2277 ldns_rdf_deep_free(b64_bignum);
2278 goto error;
2279 }
2280 ldns_rdf_deep_free(b64_bignum);
2281 ldns_buffer_printf(output, "\n");
2282 /* down reference count in EC_KEY
2283 * its still assigned to the PKEY */
2284 EC_KEY_free(ec);
2285 }
2286 #endif /* splint */
2287 #else
2288 goto error;
2289 #endif /* ECDSA */
2290 break;
2291 case LDNS_SIGN_HMACMD5:
2292 /* there's not much of a format defined for TSIG */
2293 /* It's just a binary blob, Same for all algorithms */
2294 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
2295 ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n");
2296 status = ldns_hmac_key2buffer_str(output, k);
2297 break;
2298 case LDNS_SIGN_HMACSHA1:
2299 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
2300 ldns_buffer_printf(output, "Algorithm: 158 (HMAC_SHA1)\n");
2301 status = ldns_hmac_key2buffer_str(output, k);
2302 break;
2303 case LDNS_SIGN_HMACSHA256:
2304 ldns_buffer_printf(output, "Private-key-format: v1.2\n");
2305 ldns_buffer_printf(output, "Algorithm: 159 (HMAC_SHA256)\n");
2306 status = ldns_hmac_key2buffer_str(output, k);
2307 break;
2308 }
2309 #endif /* HAVE_SSL */
2310 } else {
2311 LDNS_FREE(bignum);
2312 return ldns_buffer_status(output);
2313 }
2314 LDNS_FREE(bignum);
2315 return status;
2316
2317 #ifdef HAVE_SSL
2318 /* compiles warn the label isn't used */
2319 error:
2320 LDNS_FREE(bignum);
2321 return LDNS_STATUS_ERR;
2322 #endif /* HAVE_SSL */
2323
2324 }
2325
2326 /*
2327 * Zero terminate the buffer and copy data.
2328 */
2329 char *
ldns_buffer2str(ldns_buffer * buffer)2330 ldns_buffer2str(ldns_buffer *buffer)
2331 {
2332 char *str;
2333
2334 /* check if buffer ends with \0, if not, and
2335 if there is space, add it */
2336 if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
2337 if (!ldns_buffer_reserve(buffer, 1)) {
2338 return NULL;
2339 }
2340 ldns_buffer_write_u8(buffer, (uint8_t) '\0');
2341 if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
2342 return NULL;
2343 }
2344 }
2345
2346 str = strdup((const char *)ldns_buffer_begin(buffer));
2347 if(!str) {
2348 return NULL;
2349 }
2350 return str;
2351 }
2352
2353 /*
2354 * Zero terminate the buffer and export data.
2355 */
2356 char *
ldns_buffer_export2str(ldns_buffer * buffer)2357 ldns_buffer_export2str(ldns_buffer *buffer)
2358 {
2359 /* Append '\0' as string terminator */
2360 if (! ldns_buffer_reserve(buffer, 1)) {
2361 return NULL;
2362 }
2363 ldns_buffer_write_u8(buffer, 0);
2364
2365 /* reallocate memory to the size of the string and export */
2366 ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer));
2367 return ldns_buffer_export(buffer);
2368 }
2369
2370 char *
ldns_rdf2str(const ldns_rdf * rdf)2371 ldns_rdf2str(const ldns_rdf *rdf)
2372 {
2373 char *result = NULL;
2374 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2375
2376 if (!tmp_buffer) {
2377 return NULL;
2378 }
2379 if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
2380 /* export and return string, destroy rest */
2381 result = ldns_buffer_export2str(tmp_buffer);
2382 }
2383 ldns_buffer_free(tmp_buffer);
2384 return result;
2385 }
2386
2387 char *
ldns_rr2str_fmt(const ldns_output_format * fmt,const ldns_rr * rr)2388 ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr)
2389 {
2390 char *result = NULL;
2391 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2392
2393 if (!tmp_buffer) {
2394 return NULL;
2395 }
2396 if (ldns_rr2buffer_str_fmt(tmp_buffer, fmt, rr)
2397 == LDNS_STATUS_OK) {
2398 /* export and return string, destroy rest */
2399 result = ldns_buffer_export2str(tmp_buffer);
2400 }
2401 ldns_buffer_free(tmp_buffer);
2402 return result;
2403 }
2404
2405 char *
ldns_rr2str(const ldns_rr * rr)2406 ldns_rr2str(const ldns_rr *rr)
2407 {
2408 return ldns_rr2str_fmt(ldns_output_format_default, rr);
2409 }
2410
2411 char *
ldns_pkt2str_fmt(const ldns_output_format * fmt,const ldns_pkt * pkt)2412 ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt)
2413 {
2414 char *result = NULL;
2415 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2416
2417 if (!tmp_buffer) {
2418 return NULL;
2419 }
2420 if (ldns_pkt2buffer_str_fmt(tmp_buffer, fmt, pkt)
2421 == LDNS_STATUS_OK) {
2422 /* export and return string, destroy rest */
2423 result = ldns_buffer_export2str(tmp_buffer);
2424 }
2425
2426 ldns_buffer_free(tmp_buffer);
2427 return result;
2428 }
2429
2430 char *
ldns_pkt2str(const ldns_pkt * pkt)2431 ldns_pkt2str(const ldns_pkt *pkt)
2432 {
2433 return ldns_pkt2str_fmt(ldns_output_format_default, pkt);
2434 }
2435
2436 char *
ldns_key2str(const ldns_key * k)2437 ldns_key2str(const ldns_key *k)
2438 {
2439 char *result = NULL;
2440 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2441
2442 if (!tmp_buffer) {
2443 return NULL;
2444 }
2445 if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) {
2446 /* export and return string, destroy rest */
2447 result = ldns_buffer_export2str(tmp_buffer);
2448 }
2449 ldns_buffer_free(tmp_buffer);
2450 return result;
2451 }
2452
2453 char *
ldns_rr_list2str_fmt(const ldns_output_format * fmt,const ldns_rr_list * list)2454 ldns_rr_list2str_fmt(const ldns_output_format *fmt, const ldns_rr_list *list)
2455 {
2456 char *result = NULL;
2457 ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
2458
2459 if (!tmp_buffer) {
2460 return NULL;
2461 }
2462 if (list) {
2463 if (ldns_rr_list2buffer_str_fmt(
2464 tmp_buffer, fmt, list)
2465 == LDNS_STATUS_OK) {
2466 }
2467 } else {
2468 if (fmt == NULL) {
2469 fmt = ldns_output_format_default;
2470 }
2471 if (fmt->flags & LDNS_COMMENT_NULLS) {
2472 ldns_buffer_printf(tmp_buffer, "; (null)\n");
2473 }
2474 }
2475
2476 /* export and return string, destroy rest */
2477 result = ldns_buffer_export2str(tmp_buffer);
2478 ldns_buffer_free(tmp_buffer);
2479 return result;
2480 }
2481
2482 char *
ldns_rr_list2str(const ldns_rr_list * list)2483 ldns_rr_list2str(const ldns_rr_list *list)
2484 {
2485 return ldns_rr_list2str_fmt(ldns_output_format_default, list);
2486 }
2487
2488 void
ldns_rdf_print(FILE * output,const ldns_rdf * rdf)2489 ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
2490 {
2491 char *str = ldns_rdf2str(rdf);
2492 if (str) {
2493 fprintf(output, "%s", str);
2494 } else {
2495 fprintf(output, ";Unable to convert rdf to string\n");
2496 }
2497 LDNS_FREE(str);
2498 }
2499
2500 void
ldns_rr_print_fmt(FILE * output,const ldns_output_format * fmt,const ldns_rr * rr)2501 ldns_rr_print_fmt(FILE *output,
2502 const ldns_output_format *fmt, const ldns_rr *rr)
2503 {
2504 char *str = ldns_rr2str_fmt(fmt, rr);
2505 if (str) {
2506 fprintf(output, "%s", str);
2507 } else {
2508 fprintf(output, ";Unable to convert rr to string\n");
2509 }
2510 LDNS_FREE(str);
2511 }
2512
2513 void
ldns_rr_print(FILE * output,const ldns_rr * rr)2514 ldns_rr_print(FILE *output, const ldns_rr *rr)
2515 {
2516 ldns_rr_print_fmt(output, ldns_output_format_default, rr);
2517 }
2518
2519 void
ldns_pkt_print_fmt(FILE * output,const ldns_output_format * fmt,const ldns_pkt * pkt)2520 ldns_pkt_print_fmt(FILE *output,
2521 const ldns_output_format *fmt, const ldns_pkt *pkt)
2522 {
2523 char *str = ldns_pkt2str_fmt(fmt, pkt);
2524 if (str) {
2525 fprintf(output, "%s", str);
2526 } else {
2527 fprintf(output, ";Unable to convert packet to string\n");
2528 }
2529 LDNS_FREE(str);
2530 }
2531
2532 void
ldns_pkt_print(FILE * output,const ldns_pkt * pkt)2533 ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
2534 {
2535 ldns_pkt_print_fmt(output, ldns_output_format_default, pkt);
2536 }
2537
2538 void
ldns_rr_list_print_fmt(FILE * output,const ldns_output_format * fmt,const ldns_rr_list * lst)2539 ldns_rr_list_print_fmt(FILE *output,
2540 const ldns_output_format *fmt, const ldns_rr_list *lst)
2541 {
2542 size_t i;
2543 for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
2544 ldns_rr_print_fmt(output, fmt, ldns_rr_list_rr(lst, i));
2545 }
2546 }
2547
2548 void
ldns_rr_list_print(FILE * output,const ldns_rr_list * lst)2549 ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
2550 {
2551 ldns_rr_list_print_fmt(output, ldns_output_format_default, lst);
2552 }
2553
2554 void
ldns_resolver_print_fmt(FILE * output,const ldns_output_format * fmt,const ldns_resolver * r)2555 ldns_resolver_print_fmt(FILE *output,
2556 const ldns_output_format *fmt, const ldns_resolver *r)
2557 {
2558 uint16_t i;
2559 ldns_rdf **n;
2560 ldns_rdf **s;
2561 size_t *rtt;
2562 if (!r) {
2563 return;
2564 }
2565 n = ldns_resolver_nameservers(r);
2566 s = ldns_resolver_searchlist(r);
2567 rtt = ldns_resolver_rtt(r);
2568
2569 fprintf(output, "port: %d\n", (int)ldns_resolver_port(r));
2570 fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r));
2571 fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r));
2572
2573 fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r));
2574 fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r));
2575 fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r));
2576 fprintf(output, "fail: %d\n", ldns_resolver_fail(r));
2577 fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r));
2578 fprintf(output, "retrans: %d\n", (int)ldns_resolver_retrans(r));
2579 fprintf(output, "fallback: %d\n", ldns_resolver_fallback(r));
2580 fprintf(output, "random: %d\n", ldns_resolver_random(r));
2581 fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
2582 fprintf(output, "dnssec: %d\n", ldns_resolver_dnssec(r));
2583 fprintf(output, "dnssec cd: %d\n", ldns_resolver_dnssec_cd(r));
2584 fprintf(output, "trust anchors (%d listed):\n",
2585 (int)ldns_rr_list_rr_count(ldns_resolver_dnssec_anchors(r)));
2586 ldns_rr_list_print_fmt(output, fmt, ldns_resolver_dnssec_anchors(r));
2587 fprintf(output, "tsig: %s %s\n",
2588 ldns_resolver_tsig_keyname(r)?ldns_resolver_tsig_keyname(r):"-",
2589 ldns_resolver_tsig_algorithm(r)?ldns_resolver_tsig_algorithm(r):"-");
2590 fprintf(output, "debug: %d\n", ldns_resolver_debug(r));
2591
2592 fprintf(output, "default domain: ");
2593 ldns_rdf_print(output, ldns_resolver_domain(r));
2594 fprintf(output, "\n");
2595 fprintf(output, "apply default domain: %d\n", ldns_resolver_defnames(r));
2596
2597 fprintf(output, "searchlist (%d listed):\n", (int)ldns_resolver_searchlist_count(r));
2598 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
2599 fprintf(output, "\t");
2600 ldns_rdf_print(output, s[i]);
2601 fprintf(output, "\n");
2602 }
2603 fprintf(output, "apply search list: %d\n", ldns_resolver_dnsrch(r));
2604
2605 fprintf(output, "nameservers (%d listed):\n", (int)ldns_resolver_nameserver_count(r));
2606 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
2607 fprintf(output, "\t");
2608 ldns_rdf_print(output, n[i]);
2609
2610 switch ((int)rtt[i]) {
2611 case LDNS_RESOLV_RTT_MIN:
2612 fprintf(output, " - reachable\n");
2613 break;
2614 case LDNS_RESOLV_RTT_INF:
2615 fprintf(output, " - unreachable\n");
2616 break;
2617 }
2618 }
2619 }
2620
2621 void
ldns_resolver_print(FILE * output,const ldns_resolver * r)2622 ldns_resolver_print(FILE *output, const ldns_resolver *r)
2623 {
2624 ldns_resolver_print_fmt(output, ldns_output_format_default, r);
2625 }
2626
2627 void
ldns_zone_print_fmt(FILE * output,const ldns_output_format * fmt,const ldns_zone * z)2628 ldns_zone_print_fmt(FILE *output,
2629 const ldns_output_format *fmt, const ldns_zone *z)
2630 {
2631 if(ldns_zone_soa(z))
2632 ldns_rr_print_fmt(output, fmt, ldns_zone_soa(z));
2633 ldns_rr_list_print_fmt(output, fmt, ldns_zone_rrs(z));
2634 }
2635 void
ldns_zone_print(FILE * output,const ldns_zone * z)2636 ldns_zone_print(FILE *output, const ldns_zone *z)
2637 {
2638 ldns_zone_print_fmt(output, ldns_output_format_default, z);
2639 }
2640