ldns  1.8.3
/build/ldns-i1uE47/ldns-1.8.3/host2str.c
Go to the documentation of this file.
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 */
47ldns_edns_option_list*
48pkt_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. */
53ldns_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 */
75ldns_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 */
84ldns_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 */
99ldns_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 */
109ldns_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
124ldns_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
133const ldns_output_format ldns_output_format_nocomments_record = { 0, NULL };
134const ldns_output_format *ldns_output_format_nocomments
135 = &ldns_output_format_nocomments_record;
136const ldns_output_format ldns_output_format_onlykeyids_record = {
137 LDNS_COMMENT_KEY, NULL
138};
139const ldns_output_format *ldns_output_format_onlykeyids
140 = &ldns_output_format_onlykeyids_record;
141const ldns_output_format *ldns_output_format_default
142 = &ldns_output_format_onlykeyids_record;
143
144const ldns_output_format ldns_output_format_bubblebabble_record = {
145 LDNS_COMMENT_KEY | LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS, NULL
146};
147const ldns_output_format *ldns_output_format_bubblebabble
148 = &ldns_output_format_bubblebabble_record;
149
150static bool
151ldns_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
159ldns_status
160ldns_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
179ldns_status
180ldns_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
199ldns_status
200ldns_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
211ldns_status
212ldns_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
223ldns_status
224ldns_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
237ldns_status
238ldns_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
252char *
253ldns_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
272char *
273ldns_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
292char *
293ldns_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
313char *
314ldns_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 */
336ldns_status
337ldns_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
388ldns_status
389ldns_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
396ldns_status
397ldns_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
404ldns_status
405ldns_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
412ldns_status
413ldns_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
427ldns_status
428ldns_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
438ldns_status
439ldns_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
450static void
451ldns_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
470ldns_status
471ldns_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
486ldns_status
487ldns_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
508ldns_status
509ldns_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
529ldns_status
530ldns_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
540static ldns_status
541ldns_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
557ldns_status
558ldns_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
564ldns_status
565ldns_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
579ldns_status
580ldns_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
593ldns_status
594ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
595{
596 return ldns_rdf2buffer_str_int8(output, rdf);
597}
598
599static void
600loc_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
616ldns_status
617ldns_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
649char *
650ldns_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
670ldns_status
671ldns_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
685char *
686ldns_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
704ldns_status
705ldns_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
796ldns_status
797ldns_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
803ldns_status
804ldns_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
810ldns_status
811ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf)
812{
813 return ldns_rdf2buffer_str_hex(output, rdf);
814}
815
816ldns_status
817ldns_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
862static ldns_status
863ldns_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
904ldns_status
905ldns_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
911ldns_status
912ldns_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
936ldns_status
937ldns_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
947ldns_status
948ldns_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
971ldns_status
972ldns_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
1048ldns_status
1049ldns_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
1075ldns_status
1076ldns_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
1185ldns_status
1186ldns_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
1199ldns_status
1200ldns_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
1212ldns_status
1213ldns_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
1226ldns_status
1227ldns_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
1252ldns_status
1253ldns_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
1263ldns_status
1264ldns_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 */
1307ldns_status
1308ldns_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
1394ldns_status svcparam_key2buffer_str(ldns_buffer *output, uint16_t key);
1395
1396static ldns_status
1397svcparam_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
1410static ldns_status
1411svcparam_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
1454static ldns_status
1455svcparam_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
1463static ldns_status
1464svcparam_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
1483static ldns_status
1484svcparam_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
1502static ldns_status
1503svcparam_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
1522static ldns_status
1523svcparam_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
1549ldns_status
1550ldns_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 */
1611ldns_status
1612ldns_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
1619static ldns_status
1620ldns_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 {
1743 ldns_buffer_printf(buffer, "(null) ");
1744 res = LDNS_STATUS_ERR;
1745 }
1746 return res;
1747}
1748
1749ldns_status
1750ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
1751{
1752 return ldns_rdf2buffer_str_fmt(buffer,ldns_output_format_default,rdf);
1753}
1754
1755static ldns_rdf *
1756ldns_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 en