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