CoCalc -- host2str.c

GitHub Repository: freebsd/freebsd-src
Path: blob/main/contrib/ldns/host2str.c
³⁹⁴⁷⁵ views
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
#include <ldns/internal.h>
17

18
#include <limits.h>
19

20
#ifdef HAVE_SYS_SOCKET_H
21
#include <sys/socket.h>
22
#endif
23
#ifdef HAVE_ARPA_INET_H
24
#include <arpa/inet.h>
25
#endif
26
#ifdef HAVE_NETDB_H
27
#include <netdb.h>
28
#endif
29
#include <time.h>
30
#include <sys/time.h>
31

32
#ifdef HAVE_SSL
33
#include <openssl/bn.h>
34
#include <openssl/rsa.h>
35
#ifdef USE_DSA
36
#include <openssl/dsa.h>
37
#endif
38
#endif
39

40
#ifndef INET_ADDRSTRLEN
41
#define INET_ADDRSTRLEN 16
42
#endif
43
#ifndef INET6_ADDRSTRLEN
44
#define INET6_ADDRSTRLEN 46
45
#endif
46

47
/* lookup tables for standard DNS stuff  */
48

49
/* Taken from RFC 2535, section 7.  */
50
ldns_lookup_table ldns_algorithms[] = {
51
        { LDNS_RSAMD5, "RSAMD5" },
52
        { LDNS_DH, "DH" },
53
        { LDNS_DSA, "DSA" },
54
        { LDNS_ECC, "ECC" },
55
        { LDNS_RSASHA1, "RSASHA1" },
56
        { LDNS_DSA_NSEC3, "DSA-NSEC3-SHA1" },
57
        { LDNS_RSASHA1_NSEC3, "RSASHA1-NSEC3-SHA1" },
58
	{ LDNS_RSASHA256, "RSASHA256"},
59
	{ LDNS_RSASHA512, "RSASHA512"},
60
	{ LDNS_ECC_GOST, "ECC-GOST"},
61
        { LDNS_ECDSAP256SHA256, "ECDSAP256SHA256"},
62
        { LDNS_ECDSAP384SHA384, "ECDSAP384SHA384"},
63
	{ LDNS_ED25519, "ED25519"},
64
	{ LDNS_ED448, "ED448"},
65
        { LDNS_INDIRECT, "INDIRECT" },
66
        { LDNS_PRIVATEDNS, "PRIVATEDNS" },
67
        { LDNS_PRIVATEOID, "PRIVATEOID" },
68
        { 0, NULL }
69
};
70

71
/* Hashing algorithms used in the DS record */
72
ldns_lookup_table ldns_hashes[] = {
73
        {LDNS_SHA1     , "SHA1" },      /* RFC 4034 */
74
        {LDNS_SHA256   , "SHA256" },    /* RFC 4509 */
75
        {LDNS_HASH_GOST, "HASH-GOST" }, /* RFC 5933 */
76
        {LDNS_SHA384   , "SHA384" },    /* RFC 6605 */
77
        { 0, NULL }
78
};
79

80
/* Taken from RFC 4398  */
81
ldns_lookup_table ldns_cert_algorithms[] = {
82
        { LDNS_CERT_PKIX, "PKIX" },
83
        { LDNS_CERT_SPKI, "SPKI" },
84
        { LDNS_CERT_PGP, "PGP" },
85
        { LDNS_CERT_IPKIX, "IPKIX" },
86
        { LDNS_CERT_ISPKI, "ISPKI" },
87
        { LDNS_CERT_IPGP, "IPGP" },
88
        { LDNS_CERT_ACPKIX, "ACPKIX" },
89
        { LDNS_CERT_IACPKIX, "IACPKIX" },
90
        { LDNS_CERT_URI, "URI" },
91
        { LDNS_CERT_OID, "OID" },
92
        { 0, NULL }
93
};
94

95
/* classes  */
96
ldns_lookup_table ldns_rr_classes[] = {
97
        { LDNS_RR_CLASS_IN, "IN" },
98
        { LDNS_RR_CLASS_CH, "CH" },
99
        { LDNS_RR_CLASS_HS, "HS" },
100
        { LDNS_RR_CLASS_NONE, "NONE" },
101
        { LDNS_RR_CLASS_ANY, "ANY" },
102
        { 0, NULL }
103
};
104

105
/* if these are used elsewhere */
106
ldns_lookup_table ldns_rcodes[] = {
107
        { LDNS_RCODE_NOERROR, "NOERROR" },
108
        { LDNS_RCODE_FORMERR, "FORMERR" },
109
        { LDNS_RCODE_SERVFAIL, "SERVFAIL" },
110
        { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" },
111
        { LDNS_RCODE_NOTIMPL, "NOTIMPL" },
112
        { LDNS_RCODE_REFUSED, "REFUSED" },
113
        { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" },
114
        { LDNS_RCODE_YXRRSET, "YXRRSET" },
115
        { LDNS_RCODE_NXRRSET, "NXRRSET" },
116
        { LDNS_RCODE_NOTAUTH, "NOTAUTH" },
117
        { LDNS_RCODE_NOTZONE, "NOTZONE" },
118
        { 0, NULL }
119
};
120

121
ldns_lookup_table ldns_opcodes[] = {
122
        { LDNS_PACKET_QUERY, "QUERY" },
123
        { LDNS_PACKET_IQUERY, "IQUERY" },
124
        { LDNS_PACKET_STATUS, "STATUS" },
125
	{ LDNS_PACKET_NOTIFY, "NOTIFY" },
126
	{ LDNS_PACKET_UPDATE, "UPDATE" },
127
        { 0, NULL }
128
};
129

130
const ldns_output_format   ldns_output_format_nocomments_record = { 0, NULL };
131
const ldns_output_format  *ldns_output_format_nocomments 
132
			= &ldns_output_format_nocomments_record;
133
const ldns_output_format   ldns_output_format_onlykeyids_record = {
134
	LDNS_COMMENT_KEY, NULL
135
};
136
const ldns_output_format  *ldns_output_format_onlykeyids
137
			= &ldns_output_format_onlykeyids_record;
138
const ldns_output_format  *ldns_output_format_default
139
			= &ldns_output_format_onlykeyids_record;
140

141
const ldns_output_format   ldns_output_format_bubblebabble_record = { 
142
	LDNS_COMMENT_KEY | LDNS_COMMENT_BUBBLEBABBLE | LDNS_COMMENT_FLAGS, NULL
143
};
144
const ldns_output_format  *ldns_output_format_bubblebabble 
145
			= &ldns_output_format_bubblebabble_record;
146

147
static bool
148
ldns_output_format_covers_type(const ldns_output_format* fmt, ldns_rr_type t)
149
{
150
	return fmt && (fmt->flags & LDNS_FMT_RFC3597) &&
151
		((ldns_output_format_storage*)fmt)->bitmap &&
152
		ldns_nsec_bitmap_covers_type(
153
				((ldns_output_format_storage*)fmt)->bitmap, t);
154
}
155

156
ldns_status
157
ldns_output_format_set_type(ldns_output_format* fmt, ldns_rr_type t)
158
{
159
	ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
160
	ldns_status s;
161
	
162
	assert(fmt != NULL);
163
	
164
	if (!(fmt_st->flags & LDNS_FMT_RFC3597)) {
165
		ldns_output_format_set(fmt, LDNS_FMT_RFC3597);
166
	}
167
	if (! fmt_st->bitmap) {
168
		s = ldns_rdf_bitmap_known_rr_types_space(&fmt_st->bitmap);
169
		if (s != LDNS_STATUS_OK) {
170
			return s;
171
		}
172
	}
173
	return ldns_nsec_bitmap_set_type(fmt_st->bitmap, t);
174
}
175

176
ldns_status
177
ldns_output_format_clear_type(ldns_output_format* fmt, ldns_rr_type t)
178
{
179
	ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
180
	ldns_status s;
181
	
182
	assert(fmt != NULL);
183

184
	if (!(fmt_st->flags & LDNS_FMT_RFC3597)) {
185
		ldns_output_format_set(fmt, LDNS_FMT_RFC3597);
186
	}
187
	if (! fmt_st->bitmap) {
188
		s = ldns_rdf_bitmap_known_rr_types(&fmt_st->bitmap);
189
		if (s != LDNS_STATUS_OK) {
190
			return s;
191
		}
192
	}
193
	return ldns_nsec_bitmap_clear_type(fmt_st->bitmap, t);
194
}
195

196
ldns_status
197
ldns_pkt_opcode2buffer_str(ldns_buffer *output, ldns_pkt_opcode opcode)
198
{
199
	ldns_lookup_table *lt = ldns_lookup_by_id(ldns_opcodes, opcode);
200
	if (lt && lt->name) {
201
		ldns_buffer_printf(output, "%s", lt->name);
202
	} else {
203
		ldns_buffer_printf(output, "OPCODE%u", opcode);
204
	}
205
	return ldns_buffer_status(output);
206
}
207

208
ldns_status
209
ldns_pkt_rcode2buffer_str(ldns_buffer *output, ldns_pkt_rcode rcode)
210
{
211
	ldns_lookup_table *lt = ldns_lookup_by_id(ldns_rcodes, rcode);
212
	if (lt && lt->name) {
213
		ldns_buffer_printf(output, "%s", lt->name);
214
	} else {
215
		ldns_buffer_printf(output, "RCODE%u", rcode);
216
	}
217
	return ldns_buffer_status(output);
218
}
219

220
ldns_status
221
ldns_algorithm2buffer_str(ldns_buffer *output,
222
                          ldns_algorithm algorithm)
223
{
224
	ldns_lookup_table *lt = ldns_lookup_by_id(ldns_algorithms,
225
	                                          algorithm);
226
	if (lt && lt->name) {
227
		ldns_buffer_printf(output, "%s", lt->name);
228
	} else {
229
		ldns_buffer_printf(output, "ALG%u", algorithm);
230
	}
231
	return ldns_buffer_status(output);
232
}
233

234
ldns_status
235
ldns_cert_algorithm2buffer_str(ldns_buffer *output,
236
                               ldns_cert_algorithm cert_algorithm)
237
{
238
	ldns_lookup_table *lt = ldns_lookup_by_id(ldns_cert_algorithms,
239
	                                          cert_algorithm);
240
	if (lt && lt->name) {
241
		ldns_buffer_printf(output, "%s", lt->name);
242
	} else {
243
		ldns_buffer_printf(output, "CERT_ALG%u",
244
		                   cert_algorithm);
245
	}
246
	return ldns_buffer_status(output);
247
}
248

249
char *
250
ldns_pkt_opcode2str(ldns_pkt_opcode opcode)
251
{
252
	char *str;
253
	ldns_buffer *buf;
254

255
	buf = ldns_buffer_new(12);
256
	if (!buf) {
257
		return NULL;
258
	}
259

260
	str = NULL;
261
	if (ldns_pkt_opcode2buffer_str(buf, opcode) == LDNS_STATUS_OK) {
262
		str = ldns_buffer_export2str(buf);
263
	}
264

265
	ldns_buffer_free(buf);
266
	return str;
267
}
268

269
char *
270
ldns_pkt_rcode2str(ldns_pkt_rcode rcode)
271
{
272
	char *str;
273
	ldns_buffer *buf;
274

275
	buf = ldns_buffer_new(10);
276
	if (!buf) {
277
		return NULL;
278
	}
279

280
	str = NULL;
281
	if (ldns_pkt_rcode2buffer_str(buf, rcode) == LDNS_STATUS_OK) {
282
		str = ldns_buffer_export2str(buf);
283
	}
284

285
	ldns_buffer_free(buf);
286
	return str;
287
}
288

289
char *
290
ldns_pkt_algorithm2str(ldns_algorithm algorithm)
291
{
292
	char *str;
293
	ldns_buffer *buf;
294

295
	buf = ldns_buffer_new(10);
296
	if (!buf) {
297
		return NULL;
298
	}
299

300
	str = NULL;
301
	if (ldns_algorithm2buffer_str(buf, algorithm)
302
	    == LDNS_STATUS_OK) {
303
		str = ldns_buffer_export2str(buf);
304
	}
305

306
	ldns_buffer_free(buf);
307
	return str;
308
}
309

310
char *
311
ldns_pkt_cert_algorithm2str(ldns_cert_algorithm cert_algorithm)
312
{
313
	char *str;
314
	ldns_buffer *buf;
315

316
	buf = ldns_buffer_new(10);
317
	if (!buf) {
318
		return NULL;
319
	}
320

321
	str = NULL;
322
	if (ldns_cert_algorithm2buffer_str(buf, cert_algorithm)
323
	    == LDNS_STATUS_OK) {
324
		str = ldns_buffer_export2str(buf);
325
	}
326

327
	ldns_buffer_free(buf);
328
	return str;
329
}
330

331

332
/* do NOT pass compressed data here :p */
333
ldns_status
334
ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
335
{
336
	/* can we do with 1 pos var? or without at all? */
337
	uint8_t src_pos = 0;
338
	uint8_t len;
339
	uint8_t *data;
340
	uint8_t i;
341
	unsigned char c;
342

343
	data = (uint8_t*)ldns_rdf_data(dname);
344
	len = data[src_pos];
345

346
	if (ldns_rdf_size(dname) > LDNS_MAX_DOMAINLEN) {
347
		/* too large, return */
348
		return LDNS_STATUS_DOMAINNAME_OVERFLOW;
349
	}
350

351
	/* special case: root label */
352
	if (1 == ldns_rdf_size(dname)) {
353
		ldns_buffer_printf(output, ".");
354
	} else {
355
		while ((len > 0) && src_pos < ldns_rdf_size(dname)) {
356
			src_pos++;
357
			for(i = 0; i < len; i++) {
358
				/* paranoia check for various 'strange'
359
				   characters in dnames
360
				*/
361
				c = (unsigned char) data[src_pos];
362
				if(c == '.' || c == ';' ||
363
				   c == '(' || c == ')' ||
364
				   c == '\\') {
365
					ldns_buffer_printf(output, "\\%c",
366
							data[src_pos]);
367
				} else if (!(isascii(c) && isgraph(c))) {
368
					ldns_buffer_printf(output, "\\%03u",
369
						        data[src_pos]);
370
				} else {
371
					ldns_buffer_printf(output, "%c", data[src_pos]);
372
				}
373
				src_pos++;
374
			}
375

376
			if (src_pos < ldns_rdf_size(dname)) {
377
				ldns_buffer_printf(output, ".");
378
			}
379
			len = data[src_pos];
380
		}
381
	}
382
	return ldns_buffer_status(output);
383
}
384

385
ldns_status
386
ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
387
{
388
	uint8_t data = ldns_rdf_data(rdf)[0];
389
	ldns_buffer_printf(output, "%lu", (unsigned long) data);
390
	return ldns_buffer_status(output);
391
}
392

393
ldns_status
394
ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
395
{
396
	uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
397
	ldns_buffer_printf(output, "%lu", (unsigned long) data);
398
	return ldns_buffer_status(output);
399
}
400

401
ldns_status
402
ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
403
{
404
	uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
405
	ldns_buffer_printf(output, "%lu", (unsigned long) data);
406
	return ldns_buffer_status(output);
407
}
408

409
ldns_status
410
ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
411
{
412
	/* create a YYYYMMDDHHMMSS string if possible */
413
	struct tm tm;
414
	char date_buf[16];
415

416
	memset(&tm, 0, sizeof(tm));
417
	if (ldns_serial_arithmetics_gmtime_r(ldns_rdf2native_int32(rdf), time(NULL), &tm)
418
	    && strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
419
		ldns_buffer_printf(output, "%s", date_buf);
420
	}
421
	return ldns_buffer_status(output);
422
}
423

424
ldns_status
425
ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
426
{
427
	char str[INET_ADDRSTRLEN];
428

429
	if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) {
430
		ldns_buffer_printf(output, "%s", str);
431
	}
432
	return ldns_buffer_status(output);
433
}
434

435
ldns_status
436
ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
437
{
438
	char str[INET6_ADDRSTRLEN];
439

440
	if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, INET6_ADDRSTRLEN)) {
441
		ldns_buffer_printf(output, "%s", str);
442
	}
443

444
	return ldns_buffer_status(output);
445
}
446

447
static void 
448
ldns_characters2buffer_str(ldns_buffer* output,
449
		size_t amount, const uint8_t* characters)
450
{
451
	uint8_t ch;
452
	while (amount > 0) {
453
		ch = *characters++;
454
		if (isprint((int)ch) || ch == '\t') {
455
			if (ch == '\"' || ch == '\\')
456
				ldns_buffer_printf(output, "\\%c", ch);
457
			else
458
				ldns_buffer_printf(output, "%c", ch);
459
		} else {
460
			ldns_buffer_printf(output, "\\%03u",
461
                                (unsigned)(uint8_t) ch);
462
		}
463
		amount--;
464
	}
465
}
466

467
ldns_status
468
ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
469
{
470
        if(ldns_rdf_size(rdf) < 1) {
471
                return LDNS_STATUS_WIRE_RDATA_ERR;
472
        }
473
        if((int)ldns_rdf_size(rdf) < (int)ldns_rdf_data(rdf)[0] + 1) {
474
                return LDNS_STATUS_WIRE_RDATA_ERR;
475
        }
476
	ldns_buffer_printf(output, "\"");
477
	ldns_characters2buffer_str(output, 
478
			ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf) + 1);
479
	ldns_buffer_printf(output, "\"");
480
	return ldns_buffer_status(output);
481
}
482

483
ldns_status
484
ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
485
{
486
	size_t size;
487
	char *b64;
488

489
	if (ldns_rdf_size(rdf) == 0) {
490
		ldns_buffer_printf(output, "0");
491
		return ldns_buffer_status(output);
492
	} else
493
		size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf));
494

495
	if (!(b64 = LDNS_XMALLOC(char, size)))
496
		return LDNS_STATUS_MEM_ERR;
497

498
	if (ldns_b64_ntop(ldns_rdf_data(rdf), ldns_rdf_size(rdf), b64, size)) {
499
		ldns_buffer_printf(output, "%s", b64);
500
	}
501
	LDNS_FREE(b64);
502
	return ldns_buffer_status(output);
503
}
504

505
ldns_status
506
ldns_rdf2buffer_str_b32_ext(ldns_buffer *output, const ldns_rdf *rdf)
507
{
508
	size_t size;
509
	char *b32;
510
	if(ldns_rdf_size(rdf) == 0)
511
		return LDNS_STATUS_OK;
512
        /* remove -1 for the b32-hash-len octet */
513
	size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
514
        /* add one for the end nul for the string */
515
	b32 = LDNS_XMALLOC(char, size + 1);
516
	if(!b32) return LDNS_STATUS_MEM_ERR;
517
	size = (size_t) ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1,
518
		ldns_rdf_size(rdf) - 1, b32, size+1);
519
	if (size > 0) {
520
		ldns_buffer_printf(output, "%s", b32);
521
	}
522
	LDNS_FREE(b32);
523
	return ldns_buffer_status(output);
524
}
525

526
ldns_status
527
ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
528
{
529
	size_t i;
530
	for (i = 0; i < ldns_rdf_size(rdf); i++) {
531
		ldns_buffer_printf(output, "%02x", ldns_rdf_data(rdf)[i]);
532
	}
533

534
	return ldns_buffer_status(output);
535
}
536

537
static ldns_status
538
ldns_rdf2buffer_str_type_fmt(ldns_buffer *output,
539
		const ldns_output_format* fmt, const ldns_rdf *rdf)
540
{
541
        uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
542

543
	if (! ldns_output_format_covers_type(fmt, data) &&
544
			ldns_rr_descript(data) &&
545
			ldns_rr_descript(data)->_name) {
546

547
		ldns_buffer_printf(output, "%s",ldns_rr_descript(data)->_name);
548
	} else {
549
		ldns_buffer_printf(output, "TYPE%u", data);
550
	}
551
	return  ldns_buffer_status(output);
552
}
553

554
ldns_status
555
ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
556
{
557
	return ldns_rdf2buffer_str_type_fmt(output,
558
			ldns_output_format_default, rdf);
559
}
560

561
ldns_status
562
ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
563
{
564
	uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
565
	ldns_lookup_table *lt;
566

567
 	lt = ldns_lookup_by_id(ldns_rr_classes, (int) data);
568
	if (lt) {
569
		ldns_buffer_printf(output, "\t%s", lt->name);
570
	} else {
571
		ldns_buffer_printf(output, "\tCLASS%d", data);
572
	}
573
	return ldns_buffer_status(output);
574
}
575

576
ldns_status
577
ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
578
{
579
        uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
580
	ldns_lookup_table *lt;
581
 	lt = ldns_lookup_by_id(ldns_cert_algorithms, (int) data);
582
	if (lt) {
583
		ldns_buffer_printf(output, "%s", lt->name);
584
	} else {
585
		ldns_buffer_printf(output, "%d", data);
586
	}
587
	return ldns_buffer_status(output);
588
}
589

590
ldns_status
591
ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
592
{
593
	return ldns_rdf2buffer_str_int8(output, rdf);
594
}
595

596
static void
597
loc_cm_print(ldns_buffer *output, uint8_t mantissa, uint8_t exponent)
598
{
599
	uint8_t i;
600
	/* is it 0.<two digits> ? */
601
	if(exponent < 2) {
602
		if(exponent == 1)
603
			mantissa *= 10;
604
		ldns_buffer_printf(output, "0.%02ld", (long)mantissa);
605
		return;
606
	}
607
	/* always <digit><string of zeros> */
608
	ldns_buffer_printf(output, "%d", (int)mantissa);
609
	for(i=0; i<exponent-2; i++)
610
		ldns_buffer_printf(output, "0");
611
}
612

613
ldns_status
614
ldns_rr_type2buffer_str(ldns_buffer *output, const ldns_rr_type type)
615
{
616
	const ldns_rr_descriptor *descriptor;
617

618
	descriptor = ldns_rr_descript(type);
619

620
	switch (type) {
621
		case LDNS_RR_TYPE_IXFR:
622
			ldns_buffer_printf(output, "IXFR");
623
			break;
624
		case LDNS_RR_TYPE_AXFR:
625
			ldns_buffer_printf(output, "AXFR");
626
			break;
627
		case LDNS_RR_TYPE_MAILA:
628
			ldns_buffer_printf(output, "MAILA");
629
			break;
630
		case LDNS_RR_TYPE_MAILB:
631
			ldns_buffer_printf(output, "MAILB");
632
			break;
633
		case LDNS_RR_TYPE_ANY:
634
			ldns_buffer_printf(output, "ANY");
635
			break;
636
		default:
637
			if (descriptor && descriptor->_name) {
638
				ldns_buffer_printf(output, "%s", descriptor->_name);
639
			} else {
640
				ldns_buffer_printf(output, "TYPE%u", type);
641
			}
642
	}
643
	return ldns_buffer_status(output);
644
}
645

646
char *
647
ldns_rr_type2str(const ldns_rr_type type)
648
{
649
	char *str;
650
	ldns_buffer *buf;
651

652
	buf = ldns_buffer_new(10);
653
	if (!buf) {
654
		return NULL;
655
	}
656

657
	str = NULL;
658
	if (ldns_rr_type2buffer_str(buf, type) == LDNS_STATUS_OK) {
659
		str = ldns_buffer_export2str(buf);
660
	}
661

662
	ldns_buffer_free(buf);
663
	return str;
664
}
665

666

667
ldns_status
668
ldns_rr_class2buffer_str(ldns_buffer *output,
669
                         const ldns_rr_class klass)
670
{
671
	ldns_lookup_table *lt;
672

673
	lt = ldns_lookup_by_id(ldns_rr_classes, klass);
674
	if (lt) {
675
		ldns_buffer_printf(output, "%s", lt->name);
676
	} else {
677
		ldns_buffer_printf(output, "CLASS%d", klass);
678
	}
679
	return ldns_buffer_status(output);
680
}
681

682
char *
683
ldns_rr_class2str(const ldns_rr_class klass)
684
{
685
	ldns_buffer *buf;
686
	char *str;
687

688
	buf = ldns_buffer_new(10);
689
	if (!buf) {
690
		return NULL;
691
	}
692

693
	str = NULL;
694
	if (ldns_rr_class2buffer_str(buf, klass) == LDNS_STATUS_OK) {
695
		str = ldns_buffer_export2str(buf);
696
	}
697
	ldns_buffer_free(buf);
698
	return str;
699
}
700

701
ldns_status
702
ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
703
{
704
	/* we could do checking (ie degrees < 90 etc)? */
705
	uint8_t version;
706
	uint8_t size;
707
	uint8_t horizontal_precision;
708
	uint8_t vertical_precision;
709
	uint32_t longitude;
710
	uint32_t latitude;
711
	uint32_t altitude;
712
	char latitude_hemisphere;
713
	char longitude_hemisphere;
714
	uint32_t h;
715
	uint32_t m;
716
	double s;
717

718
	uint32_t equator = (uint32_t) ldns_power(2, 31);
719

720
        if(ldns_rdf_size(rdf) < 1) {
721
                return LDNS_STATUS_WIRE_RDATA_ERR;
722
        }
723
       	version = ldns_rdf_data(rdf)[0];
724
	if (version == 0) {
725
		if(ldns_rdf_size(rdf) < 16) {
726
			return LDNS_STATUS_WIRE_RDATA_ERR;
727
		}
728
		size = ldns_rdf_data(rdf)[1];
729
		horizontal_precision = ldns_rdf_data(rdf)[2];
730
		vertical_precision = ldns_rdf_data(rdf)[3];
731

732
		latitude = ldns_read_uint32(&ldns_rdf_data(rdf)[4]);
733
		longitude = ldns_read_uint32(&ldns_rdf_data(rdf)[8]);
734
		altitude = ldns_read_uint32(&ldns_rdf_data(rdf)[12]);
735

736
		if (latitude > equator) {
737
			latitude_hemisphere = 'N';
738
			latitude = latitude - equator;
739
		} else {
740
			latitude_hemisphere = 'S';
741
			latitude = equator - latitude;
742
		}
743
		h = latitude / (1000 * 60 * 60);
744
		latitude = latitude % (1000 * 60 * 60);
745
		m = latitude / (1000 * 60);
746
		latitude = latitude % (1000 * 60);
747
		s = (double) latitude / 1000.0;
748
		ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
749
			h, m, s, latitude_hemisphere);
750

751
		if (longitude > equator) {
752
			longitude_hemisphere = 'E';
753
			longitude = longitude - equator;
754
		} else {
755
			longitude_hemisphere = 'W';
756
			longitude = equator - longitude;
757
		}
758
		h = longitude / (1000 * 60 * 60);
759
		longitude = longitude % (1000 * 60 * 60);
760
		m = longitude / (1000 * 60);
761
		longitude = longitude % (1000 * 60);
762
		s = (double) longitude / (1000.0);
763
		ldns_buffer_printf(output, "%02u %02u %0.3f %c ",
764
			h, m, s, longitude_hemisphere);
765

766
		s = ((double) altitude) / 100;
767
		s -= 100000;
768

769
		if(altitude%100 != 0)
770
			ldns_buffer_printf(output, "%.2f", s);
771
		else
772
			ldns_buffer_printf(output, "%.0f", s);
773

774
		ldns_buffer_printf(output, "m ");
775

776
		loc_cm_print(output, (size & 0xf0) >> 4, size & 0x0f);
777
		ldns_buffer_printf(output, "m ");
778

779
		loc_cm_print(output, (horizontal_precision & 0xf0) >> 4,
780
			horizontal_precision & 0x0f);
781
		ldns_buffer_printf(output, "m ");
782

783
		loc_cm_print(output, (vertical_precision & 0xf0) >> 4,
784
			vertical_precision & 0x0f);
785
		ldns_buffer_printf(output, "m");
786

787
		return ldns_buffer_status(output);
788
	} else {
789
		return ldns_rdf2buffer_str_hex(output, rdf);
790
	}
791
}
792

793
ldns_status
794
ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
795
{
796
	ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
797
	return ldns_rdf2buffer_str_hex(output, rdf);
798
}
799

800
ldns_status
801
ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
802
{
803
	ldns_buffer_printf(output, "0x");
804
	return ldns_rdf2buffer_str_hex(output, rdf);
805
}
806

807
ldns_status
808
ldns_rdf2buffer_str_atma(ldns_buffer *output, const ldns_rdf *rdf)
809
{
810
	return ldns_rdf2buffer_str_hex(output, rdf);
811
}
812

813
ldns_status
814
ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
815
{
816
	/* protocol, followed by bitmap of services */
817
	struct protoent *protocol;
818
	char *proto_name = NULL;
819
	uint8_t protocol_nr;
820
	struct servent *service;
821
	uint16_t current_service;
822

823
        if(ldns_rdf_size(rdf) < 1) {
824
                return LDNS_STATUS_WIRE_RDATA_ERR;
825
        }
826
	protocol_nr = ldns_rdf_data(rdf)[0];
827
	protocol = getprotobynumber((int) protocol_nr);
828
	if (protocol && (protocol->p_name != NULL)) {
829
		proto_name = protocol->p_name;
830
		ldns_buffer_printf(output, "%s ", protocol->p_name);
831
	} else {
832
		ldns_buffer_printf(output, "%u ", protocol_nr);
833
	}
834

835
#ifdef HAVE_ENDPROTOENT
836
	endprotoent();
837
#endif
838

839
	for (current_service = 0;
840
	     current_service < (ldns_rdf_size(rdf)-1)*8; current_service++) {
841
		if (ldns_get_bit(&(ldns_rdf_data(rdf)[1]), current_service)) {
842
			service = getservbyport((int) htons(current_service),
843
			                        proto_name);
844
			if (service && service->s_name) {
845
				ldns_buffer_printf(output, "%s ", service->s_name);
846
			} else {
847
				ldns_buffer_printf(output, "%u ", current_service);
848
			}
849
#ifdef HAVE_ENDSERVENT
850
			endservent();
851
#endif
852
		}
853
		/* exit from loop before integer overflow */
854
		if(current_service == 65535) { break; }
855
	}
856
	return ldns_buffer_status(output);
857
}
858

859
static ldns_status
860
ldns_rdf2buffer_str_nsec_fmt(ldns_buffer *output,
861
		const ldns_output_format* fmt, const ldns_rdf *rdf)
862
{
863
	/* Note: this code is duplicated in higher.c in
864
	 * ldns_nsec_type_check() function
865
	 */
866
	uint8_t window_block_nr;
867
	uint8_t bitmap_length;
868
	uint16_t type;
869
	uint16_t pos = 0;
870
	uint16_t bit_pos;
871
	uint8_t *data = ldns_rdf_data(rdf);
872

873
	while((size_t)(pos + 2) < ldns_rdf_size(rdf)) {
874
		window_block_nr = data[pos];
875
		bitmap_length = data[pos + 1];
876
		pos += 2;
877
		if (ldns_rdf_size(rdf) < pos + bitmap_length) {
878
			return LDNS_STATUS_WIRE_RDATA_ERR;
879
		}
880
		for (bit_pos = 0; bit_pos < (bitmap_length) * 8; bit_pos++) {
881
			if (! ldns_get_bit(&data[pos], bit_pos)) {
882
				continue;
883
			}
884
			type = 256 * (uint16_t) window_block_nr + bit_pos;
885

886
			if (! ldns_output_format_covers_type(fmt, type) &&
887
					ldns_rr_descript(type) &&
888
					ldns_rr_descript(type)->_name){
889

890
				ldns_buffer_printf(output, "%s ",
891
						ldns_rr_descript(type)->_name);
892
			} else {
893
				ldns_buffer_printf(output, "TYPE%u ", type);
894
			}
895
		}
896
		pos += (uint16_t) bitmap_length;
897
	}
898
	return ldns_buffer_status(output);
899
}
900

901
ldns_status
902
ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
903
{
904
	return ldns_rdf2buffer_str_nsec_fmt(output,
905
			ldns_output_format_default, rdf);
906
}
907

908
ldns_status
909
ldns_rdf2buffer_str_nsec3_salt(ldns_buffer *output, const ldns_rdf *rdf)
910
{
911
	uint8_t salt_length;
912
	uint8_t salt_pos;
913

914
	uint8_t *data = ldns_rdf_data(rdf);
915

916
        if(ldns_rdf_size(rdf) < 1) {
917
                return LDNS_STATUS_WIRE_RDATA_ERR;
918
        }
919
	salt_length = data[0];
920
	/* from now there are variable length entries so remember pos */
921
	if (salt_length == 0 || ((size_t)salt_length)+1 > ldns_rdf_size(rdf)) {
922
		ldns_buffer_printf(output, "- ");
923
	} else {
924
		for (salt_pos = 0; salt_pos < salt_length; salt_pos++) {
925
			ldns_buffer_printf(output, "%02x", data[1 + salt_pos]);
926
		}
927
		ldns_buffer_printf(output, " ");
928
	}
929

930
	return ldns_buffer_status(output);
931
}
932

933
ldns_status
934
ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
935
{
936
	/* period is the number of seconds */
937
	if (ldns_rdf_size(rdf) != 4) {
938
		return LDNS_STATUS_WIRE_RDATA_ERR;
939
	}
940
	ldns_buffer_printf(output, "%u", ldns_read_uint32(ldns_rdf_data(rdf)));
941
	return ldns_buffer_status(output);
942
}
943

944
ldns_status
945
ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const  ldns_rdf *rdf)
946
{
947
	/* tsigtime is 48 bits network order unsigned integer */
948
	uint64_t tsigtime = 0;
949
	uint8_t *data = ldns_rdf_data(rdf);
950
	uint64_t d0, d1, d2, d3, d4, d5;
951

952
	if (ldns_rdf_size(rdf) < 6) {
953
		return LDNS_STATUS_WIRE_RDATA_ERR;
954
	}
955
	d0 = data[0]; /* cast to uint64 for shift operations */
956
	d1 = data[1];
957
	d2 = data[2];
958
	d3 = data[3];
959
	d4 = data[4];
960
	d5 = data[5];
961
	tsigtime = (d0<<40) | (d1<<32) | (d2<<24) | (d3<<16) | (d4<<8) | d5;
962

963
	ldns_buffer_printf(output, "%llu ", (long long)tsigtime);
964

965
	return ldns_buffer_status(output);
966
}
967

968
ldns_status
969
ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
970
{
971
	uint8_t *data = ldns_rdf_data(rdf);
972
	uint16_t address_family;
973
	uint8_t prefix;
974
	bool negation;
975
	uint8_t adf_length;
976
	size_t i;
977
	size_t pos = 0;
978

979
	while (pos < (unsigned int) ldns_rdf_size(rdf)) {
980
                if(pos + 3 >= (unsigned)ldns_rdf_size(rdf))
981
                        return LDNS_STATUS_WIRE_RDATA_ERR;
982
		address_family = ldns_read_uint16(&data[pos]);
983
		prefix = data[pos + 2];
984
		negation = data[pos + 3] & LDNS_APL_NEGATION;
985
		adf_length = data[pos + 3] & LDNS_APL_MASK;
986
		if (address_family == LDNS_APL_IP4) {
987
			/* check if prefix < 32? */
988
			if (negation) {
989
				ldns_buffer_printf(output, "!");
990
			}
991
			ldns_buffer_printf(output, "%u:", address_family);
992
			/* address is variable length 0 - 4 */
993
			for (i = 0; i < 4; i++) {
994
				if (i > 0) {
995
					ldns_buffer_printf(output, ".");
996
				}
997
				if (i < (unsigned short) adf_length) {
998
                                        if(pos+i+4 >= ldns_rdf_size(rdf))
999
					    return LDNS_STATUS_WIRE_RDATA_ERR;
1000
					ldns_buffer_printf(output, "%d",
1001
					                   data[pos + i + 4]);
1002
				} else {
1003
					ldns_buffer_printf(output, "0");
1004
				}
1005
			}
1006
			ldns_buffer_printf(output, "/%u ", prefix);
1007
		} else if (address_family == LDNS_APL_IP6) {
1008
			/* check if prefix < 128? */
1009
			if (negation) {
1010
				ldns_buffer_printf(output, "!");
1011
			}
1012
			ldns_buffer_printf(output, "%u:", address_family);
1013
			/* address is variable length 0 - 16 */
1014
			for (i = 0; i < 16; i++) {
1015
				if (i % 2 == 0 && i > 0) {
1016
					ldns_buffer_printf(output, ":");
1017
				}
1018
				if (i < (unsigned short) adf_length) {
1019
                                        if(pos+i+4 >= ldns_rdf_size(rdf))
1020
					    return LDNS_STATUS_WIRE_RDATA_ERR;
1021
					ldns_buffer_printf(output, "%02x",
1022
					                   data[pos + i + 4]);
1023
				} else {
1024
					ldns_buffer_printf(output, "00");
1025
				}
1026
			}
1027
			ldns_buffer_printf(output, "/%u ", prefix);
1028

1029
		} else {
1030
			/* unknown address family */
1031
			ldns_buffer_printf(output,
1032
					"Unknown address family: %u data: ",
1033
					address_family);
1034
			for (i = 1; i < (unsigned short) (4 + adf_length); i++) {
1035
                                if(pos+i >= ldns_rdf_size(rdf))
1036
                                        return LDNS_STATUS_WIRE_RDATA_ERR;
1037
				ldns_buffer_printf(output, "%02x", data[i]);
1038
			}
1039
		}
1040
		pos += 4 + adf_length;
1041
	}
1042
	return ldns_buffer_status(output);
1043
}
1044

1045
ldns_status
1046
ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
1047
{
1048
	size_t size;
1049
	char *b64;
1050
	if (ldns_rdf_size(rdf) < 2) {
1051
		return LDNS_STATUS_WIRE_RDATA_ERR;
1052
	}
1053
	/* Subtract the size (2) of the number that specifies the length */
1054
	size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
1055
	ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
1056
	if (ldns_rdf_size(rdf) > 2) {
1057
		b64 = LDNS_XMALLOC(char, size);
1058
		if(!b64)
1059
			return LDNS_STATUS_MEM_ERR;
1060

1061
		if (ldns_rdf_size(rdf) > 2 &&
1062
		ldns_b64_ntop(ldns_rdf_data(rdf) + 2,
1063
					ldns_rdf_size(rdf) - 2,
1064
					b64, size)) {
1065
			ldns_buffer_printf(output, "%s", b64);
1066
		}
1067
		LDNS_FREE(b64);
1068
	}
1069
	return ldns_buffer_status(output);
1070
}
1071

1072
ldns_status
1073
ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
1074
{
1075
	/* wire format from
1076
	   http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt
1077
	*/
1078
	uint8_t *data = ldns_rdf_data(rdf);
1079
	uint8_t precedence;
1080
	uint8_t gateway_type;
1081
	uint8_t algorithm;
1082

1083
	ldns_rdf *gateway = NULL;
1084
	uint8_t *gateway_data;
1085

1086
	size_t public_key_size;
1087
	uint8_t *public_key_data;
1088
	ldns_rdf *public_key;
1089

1090
	size_t offset = 0;
1091
	ldns_status status;
1092

1093
	if (ldns_rdf_size(rdf) < 3) {
1094
		return LDNS_STATUS_WIRE_RDATA_ERR;
1095
	}
1096
	precedence = data[0];
1097
	gateway_type = data[1];
1098
	algorithm = data[2];
1099
	offset = 3;
1100

1101
	switch (gateway_type) {
1102
		case 0:
1103
			/* no gateway */
1104
			break;
1105
		case 1:
1106
			if (ldns_rdf_size(rdf) < offset + LDNS_IP4ADDRLEN) {
1107
				return LDNS_STATUS_ERR;
1108
			}
1109
			gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
1110
                        if(!gateway_data)
1111
                                return LDNS_STATUS_MEM_ERR;
1112
			memcpy(gateway_data, &data[offset], LDNS_IP4ADDRLEN);
1113
			gateway = ldns_rdf_new(LDNS_RDF_TYPE_A,
1114
					LDNS_IP4ADDRLEN , gateway_data);
1115
			offset += LDNS_IP4ADDRLEN;
1116
                        if(!gateway) {
1117
                                LDNS_FREE(gateway_data);
1118
                                return LDNS_STATUS_MEM_ERR;
1119
                        }
1120
			break;
1121
		case 2:
1122
			if (ldns_rdf_size(rdf) < offset + LDNS_IP6ADDRLEN) {
1123
				return LDNS_STATUS_ERR;
1124
			}
1125
			gateway_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
1126
                        if(!gateway_data)
1127
                                return LDNS_STATUS_MEM_ERR;
1128
			memcpy(gateway_data, &data[offset], LDNS_IP6ADDRLEN);
1129
			offset += LDNS_IP6ADDRLEN;
1130
			gateway =
1131
				ldns_rdf_new(LDNS_RDF_TYPE_AAAA,
1132
						LDNS_IP6ADDRLEN, gateway_data);
1133
                        if(!gateway) {
1134
                                LDNS_FREE(gateway_data);
1135
                                return LDNS_STATUS_MEM_ERR;
1136
                        }
1137
			break;
1138
		case 3:
1139
			status = ldns_wire2dname(&gateway, data,
1140
					ldns_rdf_size(rdf), &offset);
1141
                        if(status != LDNS_STATUS_OK)
1142
                                return status;
1143
			break;
1144
		default:
1145
			/* error? */
1146
			break;
1147
	}
1148

1149
	if (ldns_rdf_size(rdf) <= offset) {
1150
                ldns_rdf_deep_free(gateway);
1151
		return LDNS_STATUS_ERR;
1152
	}
1153
	public_key_size = ldns_rdf_size(rdf) - offset;
1154
	public_key_data = LDNS_XMALLOC(uint8_t, public_key_size);
1155
        if(!public_key_data) {
1156
                ldns_rdf_deep_free(gateway);
1157
                return LDNS_STATUS_MEM_ERR;
1158
        }
1159
	memcpy(public_key_data, &data[offset], public_key_size);
1160
	public_key = ldns_rdf_new(LDNS_RDF_TYPE_B64,
1161
			public_key_size, public_key_data);
1162
        if(!public_key) {
1163
                LDNS_FREE(public_key_data);
1164
                ldns_rdf_deep_free(gateway);
1165
                return LDNS_STATUS_MEM_ERR;
1166
        }
1167

1168
	ldns_buffer_printf(output, "%u %u %u ", precedence, gateway_type, algorithm);
1169
	if (gateway)
1170
	  	(void) ldns_rdf2buffer_str(output, gateway);
1171
	else
1172
		ldns_buffer_printf(output, ".");
1173
	ldns_buffer_printf(output, " ");
1174
	(void) ldns_rdf2buffer_str(output, public_key);
1175

1176
	ldns_rdf_deep_free(gateway);
1177
	ldns_rdf_deep_free(public_key);
1178

1179
	return ldns_buffer_status(output);
1180
}
1181

1182
ldns_status
1183
ldns_rdf2buffer_str_ilnp64(ldns_buffer *output, const ldns_rdf *rdf)
1184
{
1185
	if (ldns_rdf_size(rdf) != 8) {
1186
		return LDNS_STATUS_WIRE_RDATA_ERR;
1187
	}
1188
	ldns_buffer_printf(output,"%.4x:%.4x:%.4x:%.4x",
1189
				ldns_read_uint16(ldns_rdf_data(rdf)),
1190
				ldns_read_uint16(ldns_rdf_data(rdf)+2),
1191
				ldns_read_uint16(ldns_rdf_data(rdf)+4),
1192
				ldns_read_uint16(ldns_rdf_data(rdf)+6));
1193
	return ldns_buffer_status(output);
1194
}
1195

1196
ldns_status
1197
ldns_rdf2buffer_str_eui48(ldns_buffer *output, const ldns_rdf *rdf)
1198
{
1199
	if (ldns_rdf_size(rdf) != 6) {
1200
		return LDNS_STATUS_WIRE_RDATA_ERR;
1201
	}
1202
	ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
1203
				ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1],
1204
				ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3],
1205
				ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5]);
1206
	return ldns_buffer_status(output);
1207
}
1208

1209
ldns_status
1210
ldns_rdf2buffer_str_eui64(ldns_buffer *output, const ldns_rdf *rdf)
1211
{
1212
	if (ldns_rdf_size(rdf) != 8) {
1213
		return LDNS_STATUS_WIRE_RDATA_ERR;
1214
	}
1215
	ldns_buffer_printf(output,"%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
1216
				ldns_rdf_data(rdf)[0], ldns_rdf_data(rdf)[1],
1217
				ldns_rdf_data(rdf)[2], ldns_rdf_data(rdf)[3],
1218
				ldns_rdf_data(rdf)[4], ldns_rdf_data(rdf)[5],
1219
				ldns_rdf_data(rdf)[6], ldns_rdf_data(rdf)[7]);
1220
	return ldns_buffer_status(output);
1221
}
1222

1223
ldns_status
1224
ldns_rdf2buffer_str_tag(ldns_buffer *output, const ldns_rdf *rdf)
1225
{
1226
	size_t nchars;
1227
	const uint8_t* chars;
1228
	char ch;
1229
	if (ldns_rdf_size(rdf) < 2) {
1230
		return LDNS_STATUS_WIRE_RDATA_ERR;
1231
	}
1232
	nchars = ldns_rdf_data(rdf)[0];
1233
	if (nchars >= ldns_rdf_size(rdf) || /* should be rdf_size - 1 */
1234
			nchars < 1) {
1235
		return LDNS_STATUS_WIRE_RDATA_ERR;
1236
	}
1237
	chars = ldns_rdf_data(rdf) + 1;
1238
	while (nchars > 0) {
1239
		ch = (char)*chars++;
1240
		if (! isalnum((unsigned char)ch)) {
1241
			return LDNS_STATUS_WIRE_RDATA_ERR;
1242
		}
1243
		ldns_buffer_printf(output, "%c", ch);
1244
		nchars--;
1245
	}
1246
	return ldns_buffer_status(output);
1247
}
1248

1249
ldns_status
1250
ldns_rdf2buffer_str_long_str(ldns_buffer *output, const ldns_rdf *rdf)
1251
{
1252

1253
	ldns_buffer_printf(output, "\"");
1254
	ldns_characters2buffer_str(output,
1255
			ldns_rdf_size(rdf), ldns_rdf_data(rdf));
1256
	ldns_buffer_printf(output, "\"");
1257
	return ldns_buffer_status(output);
1258
}
1259

1260
ldns_status
1261
ldns_rdf2buffer_str_hip(ldns_buffer *output, const ldns_rdf *rdf)
1262
{
1263
	uint8_t *data = ldns_rdf_data(rdf);
1264
	size_t rdf_size = ldns_rdf_size(rdf);
1265
	uint8_t hit_size;
1266
	uint16_t pk_size;
1267
	int written;
1268
	
1269
	if (rdf_size < 6) {
1270
		return LDNS_STATUS_WIRE_RDATA_ERR;
1271
	}
1272
	if ((hit_size = data[0]) == 0 ||
1273
			(pk_size = ldns_read_uint16(data + 2)) == 0 ||
1274
			rdf_size < (size_t) hit_size + pk_size + 4) {
1275

1276
		return LDNS_STATUS_WIRE_RDATA_ERR;
1277
	}
1278

1279
	ldns_buffer_printf(output, "%d ", (int) data[1]);
1280

1281
	for (data += 4; hit_size > 0; hit_size--, data++) {
1282

1283
		ldns_buffer_printf(output, "%02x", (int) *data);
1284
	}
1285
	ldns_buffer_write_char(output, (uint8_t) ' ');
1286

1287
	if (ldns_buffer_reserve(output,
1288
				ldns_b64_ntop_calculate_size(pk_size))) {
1289

1290
		written = ldns_b64_ntop(data, pk_size,
1291
				(char *) ldns_buffer_current(output),
1292
				ldns_buffer_remaining(output));
1293

1294
		if (written > 0 &&
1295
				written < (int) ldns_buffer_remaining(output)) {
1296

1297
			output->_position += written;
1298
		}
1299
	}
1300
	return ldns_buffer_status(output);
1301
}
1302

1303
/* implementation mimicked from ldns_rdf2buffer_str_ipseckey */
1304
ldns_status
1305
ldns_rdf2buffer_str_amtrelay(ldns_buffer *output, const ldns_rdf *rdf)
1306
{
1307
	/* wire format from
1308
	 * draft-ietf-mboned-driad-amt-discovery Section 4.2  
1309
	 */
1310
	uint8_t *data = ldns_rdf_data(rdf);
1311
	uint8_t precedence;
1312
	uint8_t discovery_optional;
1313
	uint8_t relay_type;
1314

1315
	ldns_rdf *relay = NULL;
1316
	uint8_t *relay_data;
1317

1318
	size_t offset = 0;
1319
	ldns_status status;
1320

1321
	if (ldns_rdf_size(rdf) < 2) {
1322
		return LDNS_STATUS_WIRE_RDATA_ERR;
1323
	}
1324
	precedence = data[0];
1325
	discovery_optional = ((data[1] & 0x80) >> 7);
1326
	relay_type = data[1] & 0x7F;
1327
	offset = 2;
1328

1329
	switch (relay_type) {
1330
		case 0:
1331
			/* no relay */
1332
			break;
1333
		case 1:
1334
			if (ldns_rdf_size(rdf) < offset + LDNS_IP4ADDRLEN) {
1335
				return LDNS_STATUS_ERR;
1336
			}
1337
			relay_data = LDNS_XMALLOC(uint8_t, LDNS_IP4ADDRLEN);
1338
                        if(!relay_data)
1339
                                return LDNS_STATUS_MEM_ERR;
1340
			memcpy(relay_data, &data[offset], LDNS_IP4ADDRLEN);
1341
			relay = ldns_rdf_new(LDNS_RDF_TYPE_A,
1342
					LDNS_IP4ADDRLEN , relay_data);
1343
			offset += LDNS_IP4ADDRLEN;
1344
                        if(!relay) {
1345
                                LDNS_FREE(relay_data);
1346
                                return LDNS_STATUS_MEM_ERR;
1347
                        }
1348
			break;
1349
		case 2:
1350
			if (ldns_rdf_size(rdf) < offset + LDNS_IP6ADDRLEN) {
1351
				return LDNS_STATUS_ERR;
1352
			}
1353
			relay_data = LDNS_XMALLOC(uint8_t, LDNS_IP6ADDRLEN);
1354
                        if(!relay_data)
1355
                                return LDNS_STATUS_MEM_ERR;
1356
			memcpy(relay_data, &data[offset], LDNS_IP6ADDRLEN);
1357
			offset += LDNS_IP6ADDRLEN;
1358
			relay =
1359
				ldns_rdf_new(LDNS_RDF_TYPE_AAAA,
1360
						LDNS_IP6ADDRLEN, relay_data);
1361
                        if(!relay) {
1362
                                LDNS_FREE(relay_data);
1363
                                return LDNS_STATUS_MEM_ERR;
1364
                        }
1365
			break;
1366
		case 3:
1367
			status = ldns_wire2dname(&relay, data,
1368
					ldns_rdf_size(rdf), &offset);
1369
                        if(status != LDNS_STATUS_OK)
1370
                                return status;
1371
			break;
1372
		default:
1373
			/* error? */
1374
			break;
1375
	}
1376

1377
	if (ldns_rdf_size(rdf) != offset) {
1378
                ldns_rdf_deep_free(relay);
1379
		return LDNS_STATUS_ERR;
1380
	}
1381
	ldns_buffer_printf(output, "%u %u %u ",
1382
			precedence, discovery_optional, relay_type);
1383
	if (relay)
1384
	  	(void) ldns_rdf2buffer_str(output, relay);
1385

1386
	ldns_rdf_deep_free(relay);
1387
	return ldns_buffer_status(output);
1388
}
1389

1390
#ifdef RRTYPE_SVCB_HTTPS
1391
ldns_status svcparam_key2buffer_str(ldns_buffer *output, uint16_t key);
1392

1393
static ldns_status
1394
svcparam_mandatory2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1395
{
1396
	if (sz % 2)
1397
		return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1398

1399
	svcparam_key2buffer_str(output, ldns_read_uint16(data));
1400
	for (data += 2, sz -= 2; sz; data += 2, sz -= 2) {
1401
		ldns_buffer_write_char(output, ',');
1402
		svcparam_key2buffer_str(output, ldns_read_uint16(data));
1403
	}
1404
	return ldns_buffer_status(output);
1405
}
1406

1407
static ldns_status
1408
svcparam_alpn2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1409
{
1410
	uint8_t *eod = data + sz, *dp;
1411
	bool quote = false;
1412
	size_t i;
1413

1414
	for (dp = data; dp < eod && !quote; dp += 1 + *dp) {
1415
		if (dp + 1 + *dp > eod)
1416
			return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1417

1418
		for (i = 0; i < *dp; i++)
1419
			if (isspace(dp[i + 1]))
1420
				break;
1421
		quote = i < *dp;
1422
	}
1423
	if (quote)
1424
		ldns_buffer_write_char(output, '"');
1425
	while (data < eod) {
1426
		uint8_t *eot = data + 1 + *data;
1427

1428
		if (eot > eod)
1429
			return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1430

1431
		if (eod - data < (int)sz)
1432
			ldns_buffer_write_char(output, ',');
1433

1434
		for (data += 1; data < eot; data += 1) {
1435
			uint8_t ch = *data;
1436

1437
			if (isprint(ch) || ch == '\t') {
1438
				if (ch == '"' ||  ch == ',' || ch == '\\')
1439
					ldns_buffer_write_char(output, '\\');
1440
				ldns_buffer_write_char(output, ch);
1441
			} else
1442
				ldns_buffer_printf(output, "\\%03u"
1443
				                         , (unsigned)ch);
1444
		}
1445
	}
1446
	if (quote)
1447
		ldns_buffer_write_char(output, '"');
1448
	return ldns_buffer_status(output);
1449
}
1450

1451
static ldns_status
1452
svcparam_port2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1453
{
1454
	if (sz != 2)
1455
		return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1456
	ldns_buffer_printf(output, "%d", (int)ldns_read_uint16(data));
1457
	return ldns_buffer_status(output);
1458
}
1459

1460
static ldns_status
1461
svcparam_ipv4hint2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1462
{
1463
	char str[INET_ADDRSTRLEN];
1464

1465
	if (sz % 4 || !inet_ntop(AF_INET, data, str, INET_ADDRSTRLEN))
1466
		return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1467

1468
	ldns_buffer_write_chars(output, str);
1469

1470
	for (data += 4, sz -= 4; sz ; data += 4, sz -= 4 ) {
1471
		ldns_buffer_write_char(output, ',');
1472
		if (!inet_ntop(AF_INET, data, str, INET_ADDRSTRLEN))
1473
			return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1474

1475
		ldns_buffer_write_chars(output, str);
1476
	}
1477
	return ldns_buffer_status(output);
1478
}
1479

1480
static ldns_status
1481
svcparam_ech2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1482
{
1483
	size_t str_sz = ldns_b64_ntop_calculate_size(sz);
1484
	int written;
1485

1486
	if (!ldns_buffer_reserve(output, str_sz))
1487
		return LDNS_STATUS_MEM_ERR;
1488

1489
	written = ldns_b64_ntop( data, sz
1490
	                       , (char *)ldns_buffer_current(output), str_sz);
1491
	if (written > 0)
1492
		ldns_buffer_skip(output, written);
1493
	else
1494
		return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1495

1496
	return ldns_buffer_status(output);
1497
}
1498

1499
static ldns_status
1500
svcparam_ipv6hint2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1501
{
1502
	char str[INET6_ADDRSTRLEN];
1503

1504
	if (sz % 16 || !inet_ntop(AF_INET6, data, str, INET6_ADDRSTRLEN))
1505
		return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1506

1507
	ldns_buffer_write_chars(output, str);
1508

1509
	for (data += 16, sz -= 16; sz ; data += 16, sz -= 16) {
1510
		ldns_buffer_write_char(output, ',');
1511
		if (!inet_ntop(AF_INET6, data, str, INET6_ADDRSTRLEN))
1512
			return LDNS_STATUS_INVALID_SVCPARAM_VALUE;
1513

1514
		ldns_buffer_write_chars(output, str);
1515
	}
1516
	return ldns_buffer_status(output);
1517
}
1518

1519
static ldns_status
1520
svcparam_value2buffer_str(ldns_buffer *output, size_t sz, uint8_t *data)
1521
{
1522
	uint8_t *eod = data + sz, *dp;
1523
	bool quote = false;
1524

1525
	for (dp = data; dp < eod && !isspace(*dp); dp++)
1526
		; /* pass */
1527

1528
	if ((quote = dp < eod))
1529
		ldns_buffer_write_char(output, '"');
1530

1531
	for (dp = data; dp < eod; dp++) {
1532
		uint8_t ch = *dp;
1533

1534
		if (isprint(ch) || ch == '\t') {
1535
			if (ch == '"' ||  ch == '\\')
1536
				ldns_buffer_write_char(output, '\\');
1537
			ldns_buffer_write_char(output, ch);
1538
		} else
1539
			ldns_buffer_printf(output, "\\%03u", (unsigned)ch);
1540
	}
1541
	if (quote)
1542
		ldns_buffer_write_char(output, '"');
1543
	return ldns_buffer_status(output);
1544
}
1545

1546
ldns_status
1547
ldns_rdf2buffer_str_svcparams(ldns_buffer *output, const ldns_rdf *rdf)
1548
{
1549
	uint8_t    *data, *dp, *next_dp = NULL;
1550
	size_t      sz;
1551
	ldns_status st;
1552

1553
	if (!output)
1554
		return LDNS_STATUS_NULL;
1555

1556
	if (!rdf || !(data = ldns_rdf_data(rdf)) || !(sz = ldns_rdf_size(rdf)))
1557
		/* No svcparams is just fine. Just nothing to print. */
1558
		return LDNS_STATUS_OK;
1559
	
1560
	for (dp = data; dp + 4 <= data + sz; dp = next_dp) {
1561
		ldns_svcparam_key key    = ldns_read_uint16(dp);
1562
		uint16_t          val_sz = ldns_read_uint16(dp + 2);
1563

1564
		if ((next_dp = dp + 4 + val_sz) > data + sz)
1565
			return LDNS_STATUS_RDATA_OVERFLOW;
1566

1567
		if (dp > data)
1568
			ldns_buffer_write_char(output, ' ');
1569

1570
		if ((st = svcparam_key2buffer_str(output, key)))
1571
			return st;
1572

1573
		if (val_sz == 0)
1574
			continue;
1575
		dp += 4;
1576
		ldns_buffer_write_char(output, '=');
1577
		switch (key) {
1578
		case LDNS_SVCPARAM_KEY_MANDATORY:
1579
			st = svcparam_mandatory2buffer_str(output, val_sz, dp);
1580
			break;
1581
		case LDNS_SVCPARAM_KEY_ALPN:
1582
			st = svcparam_alpn2buffer_str(output, val_sz, dp);
1583
			break;
1584
		case LDNS_SVCPARAM_KEY_NO_DEFAULT_ALPN:
1585
			return LDNS_STATUS_NO_SVCPARAM_VALUE_EXPECTED;
1586
		case LDNS_SVCPARAM_KEY_PORT:
1587
			st = svcparam_port2buffer_str(output, val_sz, dp);
1588
			break;
1589
		case LDNS_SVCPARAM_KEY_IPV4HINT:
1590
			st = svcparam_ipv4hint2buffer_str(output, val_sz, dp);
1591
			break;
1592
		case LDNS_SVCPARAM_KEY_ECH:
1593
			st = svcparam_ech2buffer_str(output, val_sz, dp);
1594
			break;
1595
		case LDNS_SVCPARAM_KEY_IPV6HINT:
1596
			st = svcparam_ipv6hint2buffer_str(output, val_sz, dp);
1597
			break;
1598
		default:
1599
			st = svcparam_value2buffer_str(output, val_sz, dp);
1600
			break;
1601
		}
1602
		if (st)
1603
			return st;
1604
	}
1605
	return ldns_buffer_status(output);
1606
}
1607
#else	/* #ifdef RRTYPE_SVCB_HTTPS */
1608
ldns_status
1609
ldns_rdf2buffer_str_svcparams(ldns_buffer *output, const ldns_rdf *rdf)
1610
{
1611
	(void)output; (void)rdf;
1612
	return LDNS_STATUS_NOT_IMPL;
1613
}
1614
#endif	/* #ifdef RRTYPE_SVCB_HTTPS */
1615

1616
static ldns_status
1617
ldns_rdf2buffer_str_fmt(ldns_buffer *buffer,
1618
		const ldns_output_format* fmt, const ldns_rdf *rdf)
1619
{
1620
	ldns_status res = LDNS_STATUS_OK;
1621

1622
	/*ldns_buffer_printf(buffer, "%u:", ldns_rdf_get_type(rdf));*/
1623
	if (rdf) {
1624
		switch(ldns_rdf_get_type(rdf)) {
1625
		case LDNS_RDF_TYPE_NONE:
1626
			break;
1627
		case LDNS_RDF_TYPE_DNAME:
1628
			res = ldns_rdf2buffer_str_dname(buffer, rdf);
1629
			break;
1630
		case LDNS_RDF_TYPE_INT8: /* Don't output mnemonics for these */
1631
		case LDNS_RDF_TYPE_ALG:
1632
		case LDNS_RDF_TYPE_CERTIFICATE_USAGE:
1633
		case LDNS_RDF_TYPE_SELECTOR:
1634
		case LDNS_RDF_TYPE_MATCHING_TYPE:
1635
			res = ldns_rdf2buffer_str_int8(buffer, rdf);
1636
			break;
1637
		case LDNS_RDF_TYPE_INT16:
1638
			res = ldns_rdf2buffer_str_int16(buffer, rdf);
1639
			break;
1640
		case LDNS_RDF_TYPE_INT32:
1641
			res = ldns_rdf2buffer_str_int32(buffer, rdf);
1642
			break;
1643
		case LDNS_RDF_TYPE_PERIOD:
1644
			res = ldns_rdf2buffer_str_period(buffer, rdf);
1645
			break;
1646
		case LDNS_RDF_TYPE_TSIGTIME:
1647
			res = ldns_rdf2buffer_str_tsigtime(buffer, rdf);
1648
			break;
1649
		case LDNS_RDF_TYPE_A:
1650
			res = ldns_rdf2buffer_str_a(buffer, rdf);
1651
			break;
1652
		case LDNS_RDF_TYPE_AAAA:
1653
			res = ldns_rdf2buffer_str_aaaa(buffer, rdf);
1654
			break;
1655
		case LDNS_RDF_TYPE_STR:
1656
			res = ldns_rdf2buffer_str_str(buffer, rdf);
1657
			break;
1658
		case LDNS_RDF_TYPE_APL:
1659
			res = ldns_rdf2buffer_str_apl(buffer, rdf);
1660
			break;
1661
		case LDNS_RDF_TYPE_B32_EXT:
1662
			res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1663
			break;
1664
		case LDNS_RDF_TYPE_B64:
1665
			res = ldns_rdf2buffer_str_b64(buffer, rdf);
1666
			break;
1667
		case LDNS_RDF_TYPE_HEX:
1668
			res = ldns_rdf2buffer_str_hex(buffer, rdf);
1669
			break;
1670
		case LDNS_RDF_TYPE_NSEC:
1671
			res = ldns_rdf2buffer_str_nsec_fmt(buffer, fmt, rdf);
1672
			break;
1673
		case LDNS_RDF_TYPE_NSEC3_SALT:
1674
			res = ldns_rdf2buffer_str_nsec3_salt(buffer, rdf);
1675
			break;
1676
		case LDNS_RDF_TYPE_TYPE:
1677
			res = ldns_rdf2buffer_str_type_fmt(buffer, fmt, rdf);
1678
			break;
1679
		case LDNS_RDF_TYPE_CLASS:
1680
			res = ldns_rdf2buffer_str_class(buffer, rdf);
1681
			break;
1682
		case LDNS_RDF_TYPE_CERT_ALG:
1683
			res = ldns_rdf2buffer_str_cert_alg(buffer, rdf);
1684
			break;
1685
		case LDNS_RDF_TYPE_UNKNOWN:
1686
			res = ldns_rdf2buffer_str_unknown(buffer, rdf);
1687
			break;
1688
		case LDNS_RDF_TYPE_TIME:
1689
			res = ldns_rdf2buffer_str_time(buffer, rdf);
1690
			break;
1691
		case LDNS_RDF_TYPE_HIP:
1692
			res = ldns_rdf2buffer_str_hip(buffer, rdf);
1693
			break;
1694
		case LDNS_RDF_TYPE_LOC:
1695
			res = ldns_rdf2buffer_str_loc(buffer, rdf);
1696
			break;
1697
		case LDNS_RDF_TYPE_WKS:
1698
		case LDNS_RDF_TYPE_SERVICE:
1699
			res = ldns_rdf2buffer_str_wks(buffer, rdf);
1700
			break;
1701
		case LDNS_RDF_TYPE_NSAP:
1702
			res = ldns_rdf2buffer_str_nsap(buffer, rdf);
1703
			break;
1704
		case LDNS_RDF_TYPE_ATMA:
1705
			res = ldns_rdf2buffer_str_atma(buffer, rdf);
1706
			break;
1707
		case LDNS_RDF_TYPE_IPSECKEY:
1708
			res = ldns_rdf2buffer_str_ipseckey(buffer, rdf);
1709
			break;
1710
		case LDNS_RDF_TYPE_INT16_DATA:
1711
			res = ldns_rdf2buffer_str_int16_data(buffer, rdf);
1712
			break;
1713
		case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
1714
			res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
1715
			break;
1716
		case LDNS_RDF_TYPE_ILNP64:
1717
			res = ldns_rdf2buffer_str_ilnp64(buffer, rdf);
1718
			break;
1719
		case LDNS_RDF_TYPE_EUI48:
1720
			res = ldns_rdf2buffer_str_eui48(buffer, rdf);
1721
			break;
1722
		case LDNS_RDF_TYPE_EUI64:
1723
			res = ldns_rdf2buffer_str_eui64(buffer, rdf);
1724
			break;
1725
		case LDNS_RDF_TYPE_TAG:
1726
			res = ldns_rdf2buffer_str_tag(buffer, rdf);
1727
			break;
1728
		case LDNS_RDF_TYPE_LONG_STR:
1729
			res = ldns_rdf2buffer_str_long_str(buffer, rdf);
1730
			break;
1731
		case LDNS_RDF_TYPE_AMTRELAY:
1732
			res = ldns_rdf2buffer_str_amtrelay(buffer, rdf);
1733
			break;
1734
		case LDNS_RDF_TYPE_SVCPARAMS:
1735
			res = ldns_rdf2buffer_str_svcparams(buffer, rdf);
1736
			break;
1737
		}
1738
	} else {
1739
		/** This will write mangled RRs */
1740
		ldns_buffer_printf(buffer, "(null) ");
1741
		res = LDNS_STATUS_ERR;
1742
	}
1743
	return res;
1744
}
1745

1746
ldns_status
1747
ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
1748
{
1749
	return ldns_rdf2buffer_str_fmt(buffer,ldns_output_format_default,rdf);
1750
}
1751

1752
static ldns_rdf *
1753
ldns_b32_ext2dname(const ldns_rdf *rdf)
1754
{
1755
	size_t size;
1756
	char *b32;
1757
	ldns_rdf *out;
1758
	if(ldns_rdf_size(rdf) == 0)
1759
		return NULL;
1760
        /* remove -1 for the b32-hash-len octet */
1761
	size = ldns_b32_ntop_calculate_size(ldns_rdf_size(rdf) - 1);
1762
        /* add one for the end nul for the string */
1763
	b32 = LDNS_XMALLOC(char, size + 2);
1764
	if (b32) {
1765
		if (ldns_b32_ntop_extended_hex(ldns_rdf_data(rdf) + 1, 
1766
				ldns_rdf_size(rdf) - 1, b32, size+1) > 0) {
1767
			b32[size] = '.';
1768
			b32[size+1] = '\0';
1769
			if (ldns_str2rdf_dname(&out, b32) == LDNS_STATUS_OK) {
1770
				LDNS_FREE(b32);
1771
				return out;
1772
			}
1773
		}
1774
		LDNS_FREE(b32);
1775
	}
1776
	return NULL;
1777
}
1778

1779
static ldns_status
1780
ldns_rr2buffer_str_rfc3597(ldns_buffer *output, const ldns_rr *rr)
1781
{
1782
	size_t total_rdfsize = 0;
1783
	size_t i, j;
1784

1785
	ldns_buffer_printf(output, "TYPE%u\t", ldns_rr_get_type(rr));
1786
	for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1787
		total_rdfsize += ldns_rdf_size(ldns_rr_rdf(rr, i));
1788
	}
1789
	if (total_rdfsize == 0) {
1790
		ldns_buffer_printf(output, "\\# 0\n");
1791
		return ldns_buffer_status(output);
1792
	}
1793
	ldns_buffer_printf(output, "\\# %d ", total_rdfsize);
1794
	for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1795
		for (j = 0; j < ldns_rdf_size(ldns_rr_rdf(rr, i)); j++) {
1796
			ldns_buffer_printf(output, "%.2x",
1797
					ldns_rdf_data(ldns_rr_rdf(rr, i))[j]);
1798
		}
1799
	}
1800
	ldns_buffer_printf(output, "\n");
1801
	return ldns_buffer_status(output);
1802
}
1803

1804
ldns_status
1805
ldns_rr2buffer_str_fmt(ldns_buffer *output, 
1806
		const ldns_output_format *fmt, const ldns_rr *rr)
1807
{
1808
	uint16_t i, flags;
1809
	ldns_status status = LDNS_STATUS_OK;
1810
	ldns_output_format_storage* fmt_st = (ldns_output_format_storage*)fmt;
1811

1812
	if (fmt_st == NULL) {
1813
		fmt_st = (ldns_output_format_storage*)
1814
			  ldns_output_format_default;
1815
	}
1816
	if (!(fmt_st->flags & LDNS_FMT_SHORT)) {
1817
		if (!rr) {
1818
			if (LDNS_COMMENT_NULLS & fmt_st->flags) {
1819
				ldns_buffer_printf(output, "; (null)\n");
1820
			}
1821
			return ldns_buffer_status(output);
1822
		}
1823
		if (ldns_rr_owner(rr)) {
1824
			status = ldns_rdf2buffer_str_dname(output, ldns_rr_owner(rr));
1825
		}
1826
		if (status != LDNS_STATUS_OK) {
1827
			return status;
1828
		}
1829

1830
		/* TTL should NOT be printed if it is a question */
1831
		if (!ldns_rr_is_question(rr)) {
1832
			ldns_buffer_printf(output, "\t%u", (unsigned)ldns_rr_ttl(rr));
1833
		}
1834

1835
		ldns_buffer_printf(output, "\t");
1836
		status = ldns_rr_class2buffer_str(output, ldns_rr_get_class(rr));
1837
		if (status != LDNS_STATUS_OK) {
1838
			return status;
1839
		}
1840
		ldns_buffer_printf(output, "\t");
1841

1842
		if (ldns_output_format_covers_type(fmt, ldns_rr_get_type(rr))) {
1843
			return ldns_rr2buffer_str_rfc3597(output, rr);
1844
		}
1845
		status = ldns_rr_type2buffer_str(output, ldns_rr_get_type(rr));
1846
		if (status != LDNS_STATUS_OK) {
1847
			return status;
1848
		}
1849

1850
		if (ldns_rr_rd_count(rr) > 0) {
1851
			ldns_buffer_printf(output, "\t");
1852
		} else if (!ldns_rr_is_question(rr)) {
1853
			ldns_buffer_printf(output, "\t\\# 0");
1854
		}
1855
	} else if (ldns_rr_rd_count(rr) == 0) {
1856
		/* assert(fmt_st->flags & LDNS_FMT_SHORT); */
1857

1858
		ldns_buffer_printf(output, "# 0");
1859
	}
1860
	for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1861
		/* ldns_rdf2buffer_str handles NULL input fine! */
1862
		if ((fmt_st->flags & LDNS_FMT_ZEROIZE_RRSIGS) &&
1863
				(ldns_rr_get_type(rr) == LDNS_RR_TYPE_RRSIG) &&
1864
				((/* inception  */ i == 4 &&
1865
				  ldns_rdf_get_type(ldns_rr_rdf(rr, 4)) == 
1866
							LDNS_RDF_TYPE_TIME) ||
1867
				  (/* expiration */ i == 5 &&
1868
				   ldns_rdf_get_type(ldns_rr_rdf(rr, 5)) ==
1869
				   			LDNS_RDF_TYPE_TIME) ||
1870
				  (/* signature  */ i == 8 &&
1871
				   ldns_rdf_get_type(ldns_rr_rdf(rr, 8)) ==
1872
				   			LDNS_RDF_TYPE_B64))) {
1873

1874
			ldns_buffer_printf(output, "(null)");
1875
			status = ldns_buffer_status(output);
1876
		} else if ((fmt_st->flags & LDNS_FMT_PAD_SOA_SERIAL) &&
1877
				(ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) &&
1878
				/* serial */ i == 2 &&
1879
			 	ldns_rdf_get_type(ldns_rr_rdf(rr, 2)) ==
1880
			 				LDNS_RDF_TYPE_INT32) {
1881
			ldns_buffer_printf(output, "%10lu",
1882
				(unsigned long) ldns_read_uint32(
1883
					ldns_rdf_data(ldns_rr_rdf(rr, 2))));
1884
			status = ldns_buffer_status(output);
1885
		} else {
1886
			status = ldns_rdf2buffer_str_fmt(output,
1887
					fmt, ldns_rr_rdf(rr, i));
1888
		}
1889
		if(status != LDNS_STATUS_OK)
1890
			return status;
1891
		if (i < ldns_rr_rd_count(rr) - 1) {
1892
			ldns_buffer_printf(output, " ");
1893
		}
1894
	}
1895
	/* per RR special comments - handy for DNSSEC types */
1896
	/* check to prevent question sec. rr from
1897
	 * getting here */
1898
	if (ldns_rr_rd_count(rr) > 0) {
1899
		switch (ldns_rr_get_type(rr)) {
1900
		case LDNS_RR_TYPE_DNSKEY:
1901
			/* if ldns_rr_rd_count(rr) > 0
1902
				then ldns_rr_rdf(rr, 0) exists! */
1903
			if (! (fmt_st->flags & LDNS_COMMENT_KEY)) {
1904
				break;
1905
			}
1906
			flags = ldns_rdf2native_int16(ldns_rr_rdf(rr, 0));
1907
			ldns_buffer_printf(output, " ;{");
1908
			if (fmt_st->flags & LDNS_COMMENT_KEY_ID) {
1909
				ldns_buffer_printf(output, "id = %u",
1910
					(unsigned int) ldns_calc_keytag(rr));
1911
			}
1912
			if ((fmt_st->flags & LDNS_COMMENT_KEY_TYPE) &&
1913
					(flags & LDNS_KEY_ZONE_KEY)){
1914

1915
				if (flags & LDNS_KEY_SEP_KEY) {
1916
					ldns_buffer_printf(output, " (ksk)");
1917
				} else {
1918
					ldns_buffer_printf(output, " (zsk)");
1919
				}
1920
				if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE){
1921
					ldns_buffer_printf(output, ", ");
1922
				}
1923
			} else if (fmt_st->flags
1924
					& (LDNS_COMMENT_KEY_ID
1925
						|LDNS_COMMENT_KEY_SIZE)) {
1926
				ldns_buffer_printf( output, ", ");
1927
			}
1928
			if (fmt_st->flags & LDNS_COMMENT_KEY_SIZE) {
1929
				ldns_buffer_printf(output, "size = %db",
1930
					ldns_rr_dnskey_key_size(rr));
1931
			}
1932
			ldns_buffer_printf(output, "}");
1933
			break;
1934
		case LDNS_RR_TYPE_RRSIG:
1935
			if ((fmt_st->flags & LDNS_COMMENT_KEY)
1936
					&& (fmt_st->flags& LDNS_COMMENT_RRSIGS)
1937
					&& ldns_rr_rdf(rr, 6) != NULL) {
1938
				ldns_buffer_printf(output, " ;{id = %d}",
1939
						ldns_rdf2native_int16(
1940
							ldns_rr_rdf(rr, 6)));
1941
			}
1942
			break;
1943
		case LDNS_RR_TYPE_DS:
1944
			if ((fmt_st->flags & LDNS_COMMENT_BUBBLEBABBLE) &&
1945
					ldns_rr_rdf(rr, 3) != NULL) {
1946

1947
				uint8_t *data = ldns_rdf_data(
1948
						ldns_rr_rdf(rr, 3));
1949
				size_t len = ldns_rdf_size(ldns_rr_rdf(rr, 3));
1950
				char *babble = ldns_bubblebabble(data, len);
1951
				if(babble) {
1952
					ldns_buffer_printf(output,
1953
							" ;{%s}", babble);
1954
				}
1955
				LDNS_FREE(babble);
1956
			}
1957
			break;
1958
		case LDNS_RR_TYPE_NSEC3:
1959
			if (! (fmt_st->flags & LDNS_COMMENT_FLAGS) &&
1960
				! (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN)) {
1961
				break;
1962
			}
1963
			ldns_buffer_printf(output, " ;{");
1964
			if ((fmt_st->flags & LDNS_COMMENT_FLAGS)) {
1965
				if (ldns_nsec3_optout(rr)) {
1966
					ldns_buffer_printf(output,
1967
						" flags: optout");
1968
				} else {
1969
					ldns_buffer_printf(output," flags: -");
1970
				}
1971
				if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN &&
1972
						fmt_st->hashmap != NULL) {
1973
					ldns_buffer_printf(output, ", ");
1974
				}
1975
			}
1976
			if (fmt_st->flags & LDNS_COMMENT_NSEC3_CHAIN &&
1977
					fmt_st->hashmap != NULL) {
1978
				ldns_rbnode_t *node;
1979
				ldns_rdf *key = ldns_dname_label(
1980
						ldns_rr_owner(rr), 0);
1981
				if (key) {
1982
					node = ldns_rbtree_search(
1983
						fmt_st->hashmap,
1984
						(void *) key);
1985
					if (node->data) {
1986
						ldns_buffer_printf(output,
1987
							"from: ");
1988
						(void) ldns_rdf2buffer_str(
1989
							output,
1990
							ldns_dnssec_name_name(
1991
							   (ldns_dnssec_name*)
1992
							   node->data
1993
							));
1994
					}
1995
					ldns_rdf_deep_free(key);
1996
				}
1997
				key = ldns_b32_ext2dname(
1998
						ldns_nsec3_next_owner(rr));
1999
				if (key) {
2000
					node = ldns_rbtree_search(
2001
						fmt_st->hashmap,
2002
						(void *) key);
2003
					if (node->data) {
2004
						ldns_buffer_printf(output,
2005
							" to: ");
2006
						(void) ldns_rdf2buffer_str(
2007
							output,
2008
							ldns_dnssec_name_name(
2009
							   (ldns_dnssec_name*)
2010
							   node->data
2011
							));
2012
					}
2013
					ldns_rdf_deep_free(key);
2014
				}
2015
			}
2016
			ldns_buffer_printf(output, "}");
2017
			break;
2018
		default:
2019
			break;
2020

2021
		}
2022
	}
2023
	/* last */
2024
	ldns_buffer_printf(output, "\n");
2025
	return ldns_buffer_status(output);
2026
}
2027

2028
ldns_status
2029
ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
2030
{
2031
	return ldns_rr2buffer_str_fmt(output, ldns_output_format_default, rr);
2032
}
2033

2034
ldns_status
2035
ldns_rr_list2buffer_str_fmt(ldns_buffer *output, 
2036
		const ldns_output_format *fmt, const ldns_rr_list *list)
2037
{
2038
	uint16_t i;
2039

2040
	for(i = 0; i < ldns_rr_list_rr_count(list); i++) {
2041
		(void) ldns_rr2buffer_str_fmt(output, fmt, 
2042
				ldns_rr_list_rr(list, i));
2043
	}
2044
	return ldns_buffer_status(output);
2045
}
2046

2047
ldns_status
2048
ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
2049
{
2050
	return ldns_rr_list2buffer_str_fmt(
2051
			output, ldns_output_format_default, list);
2052
}
2053

2054
ldns_status
2055
ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
2056
{
2057
	ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
2058
			                    (int) ldns_pkt_get_opcode(pkt));
2059
	ldns_lookup_table *rcode = ldns_lookup_by_id(ldns_rcodes,
2060
			                    (int) ldns_pkt_get_rcode(pkt));
2061

2062
	ldns_buffer_printf(output, ";; ->>HEADER<<- ");
2063
	if (opcode) {
2064
		ldns_buffer_printf(output, "opcode: %s, ", opcode->name);
2065
	} else {
2066
		ldns_buffer_printf(output, "opcode: ?? (%u), ",
2067
				ldns_pkt_get_opcode(pkt));
2068
	}
2069
	if (rcode) {
2070
		ldns_buffer_printf(output, "rcode: %s, ", rcode->name);
2071
	} else {
2072
		ldns_buffer_printf(output, "rcode: ?? (%u), ", ldns_pkt_get_rcode(pkt));
2073
	}
2074
	ldns_buffer_printf(output, "id: %d\n", ldns_pkt_id(pkt));
2075
	ldns_buffer_printf(output, ";; flags: ");
2076

2077
	if (ldns_pkt_qr(pkt)) {
2078
		ldns_buffer_printf(output, "qr ");
2079
	}
2080
	if (ldns_pkt_aa(pkt)) {
2081
		ldns_buffer_printf(output, "aa ");
2082
	}
2083
	if (ldns_pkt_tc(pkt)) {
2084
		ldns_buffer_printf(output, "tc ");
2085
	}
2086
	if (ldns_pkt_rd(pkt)) {
2087
		ldns_buffer_printf(output, "rd ");
2088
	}
2089
	if (ldns_pkt_cd(pkt)) {
2090
		ldns_buffer_printf(output, "cd ");
2091
	}
2092
	if (ldns_pkt_ra(pkt)) {
2093
		ldns_buffer_printf(output, "ra ");
2094
	}
2095
	if (ldns_pkt_ad(pkt)) {
2096
		ldns_buffer_printf(output, "ad ");
2097
	}
2098
	ldns_buffer_printf(output, "; ");
2099
	ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt));
2100
	ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt));
2101
	ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt));
2102
	ldns_buffer_printf(output, "ADDITIONAL: %u ", ldns_pkt_arcount(pkt));
2103
	return ldns_buffer_status(output);
2104
}
2105

2106

2107
/* print EDNS option data in the Dig format: 76 61 6c 69 ... */
2108
static void
2109
ldns_edns_hex_data2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2110
{
2111
	size_t j;
2112
	for (j = 0; j < len; j++) {
2113
		ldns_buffer_printf(output, " %02x", data[j]);
2114
	}
2115
}
2116

2117
static ldns_status
2118
ldns_edns_llq2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2119
{
2120
	/* LLQ constants */
2121
	const char* llq_errors[] = {"NO-ERROR", "SERV-FULL", "STATIC",
2122
		"FORMAT-ERR", "NO-SUCH-LLQ", "BAD-VERS", "UNKNOWN_ERR"};
2123
	const unsigned int llq_errors_num = 7;
2124
	const char* llq_opcodes[] = {"LLQ-SETUP", "LLQ-REFRESH", "LLQ-EVENT"};
2125
	const unsigned int llq_opcodes_num = 3;
2126

2127
	uint16_t version, llq_opcode, error_code;
2128
	uint64_t llq_id;
2129
	uint32_t lease_life; /* Requested or granted life of LLQ, in seconds */
2130

2131
	ldns_buffer_printf(output, "; Long-Lived Query:");
2132

2133
	/* read the record */
2134
	if(len != 18) {
2135
		ldns_buffer_printf(output, " malformed LLQ ");
2136
		ldns_edns_hex_data2buffer_str(output, data, len);
2137

2138
		return ldns_buffer_status(output);
2139
	}
2140
	version = ldns_read_uint16(data);
2141
	llq_opcode = ldns_read_uint16(data+2);
2142
	error_code = ldns_read_uint16(data+4);
2143
	memmove(&llq_id, data+6, sizeof(uint64_t));
2144
	lease_life = ldns_read_uint32(data+14);
2145

2146
	/* print option field entires */
2147
	ldns_buffer_printf(output, "v%d ", (int)version);
2148

2149
	if(llq_opcode < llq_opcodes_num) {
2150
		ldns_buffer_printf(output, "%s", llq_opcodes[llq_opcode]);
2151
	} else {
2152
		ldns_buffer_printf(output, "opcode %d", (int)llq_opcode);
2153
	}
2154

2155
	if(error_code < llq_errors_num)
2156
		ldns_buffer_printf(output, " %s", llq_errors[error_code]);
2157
	else {
2158
		ldns_buffer_printf(output, " error %d", (int)error_code);
2159
	}
2160

2161
#ifndef USE_WINSOCK
2162
	ldns_buffer_printf(output, " id %llx lease-life %lu",
2163
		(unsigned long long)llq_id, (unsigned long)lease_life);
2164
#else
2165
	ldns_buffer_printf(output, " id %I64x lease-life %lu",
2166
		(unsigned long long)llq_id, (unsigned long)lease_life);
2167
#endif
2168
	return ldns_buffer_status(output);
2169
}
2170

2171

2172
static ldns_status
2173
ldns_edns_ul2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2174
{
2175
	uint32_t lease;
2176

2177
	ldns_buffer_printf(output, "; Update Lease:");
2178

2179
	if(len != 4) {
2180
		ldns_buffer_printf(output, " malformed UL ");
2181
		ldns_edns_hex_data2buffer_str(output, data, len);
2182
		return ldns_buffer_status(output);
2183
	}
2184
	lease = ldns_read_uint32(data);
2185
	ldns_buffer_printf(output, "lease %lu", (unsigned long)lease);
2186

2187
	return ldns_buffer_status(output);
2188
}
2189

2190
static ldns_status
2191
ldns_edns_nsid2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2192
{
2193
	size_t i, printed=0;
2194

2195
	ldns_buffer_printf(output, "; NSID:");
2196
	ldns_edns_hex_data2buffer_str(output, data, len);
2197

2198
	/* print the human-readable text string */
2199
	for(i = 0; i < len; i++) {
2200
		if(isprint((unsigned char)data[i]) || data[i] == '\t') {
2201
			if(!printed) {
2202
				ldns_buffer_printf(output, " (");
2203
				printed = 1;
2204
			}
2205
			ldns_buffer_printf(output, "%c", (char)data[i]);
2206
		}
2207
	}
2208
	if(printed)
2209
		ldns_buffer_printf(output, ")");
2210
	return ldns_buffer_status(output);
2211
}
2212

2213

2214
static ldns_status
2215
ldns_edns_dau2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2216
{
2217
	size_t i;
2218
	ldns_lookup_table *lt;
2219

2220
	ldns_buffer_printf(output, "; DNSSEC Algorithm Understood (DAU):");
2221

2222
	for(i = 0; i <len; i++) {
2223
		lt = ldns_lookup_by_id(ldns_algorithms, data[i]);
2224
		if (lt && lt->name) {
2225
			ldns_buffer_printf(output, " %s", lt->name);
2226
		} else {
2227
			ldns_buffer_printf(output, " ALG%u", data[i]);
2228
		}
2229
	}
2230
	return ldns_buffer_status(output);
2231
}
2232

2233
static ldns_status
2234
ldns_edns_dhu2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2235
{
2236
	size_t i;
2237
	ldns_lookup_table *lt;
2238

2239
	ldns_buffer_printf(output, "; DS Hash Understood (DHU):");
2240

2241
	for(i = 0; i < len; i++) {
2242
		lt = ldns_lookup_by_id(ldns_hashes, data[i]);
2243
		if (lt && lt->name) {
2244
			ldns_buffer_printf(output, " %s", lt->name);
2245
		} else {
2246
			ldns_buffer_printf(output, " ALG%u", data[i]);
2247
		}
2248
	}
2249
	return ldns_buffer_status(output);
2250
}
2251

2252
static ldns_status
2253
ldns_edns_d3u2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2254
{
2255
	size_t i;
2256

2257
	ldns_buffer_printf(output, "; NSEC3 Hash Understood (N3U):");
2258

2259
	for(i=0; i<len; i++) {
2260
		if(data[i] == 1) {
2261
			ldns_buffer_printf(output, " SHA1");
2262
		} else {
2263
			ldns_buffer_printf(output, " %d", (int)data[i]);
2264
		}
2265
	}
2266
	return ldns_buffer_status(output);
2267
}
2268

2269
static ldns_status
2270
ldns_edns_subnet2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2271
{
2272
	uint16_t family;
2273
	uint8_t source, scope;
2274
	if(len < 4) {
2275
		ldns_buffer_printf(output, "malformed subnet ");
2276
		ldns_edns_hex_data2buffer_str(output, data, len);
2277
		return ldns_buffer_status(output);
2278
	}
2279
	family = ldns_read_uint16(data);
2280
	source = data[2];
2281
	scope = data[3];
2282
	if(family == 1) {
2283
		/* IPv4 */
2284
		char buf[64];
2285
		uint8_t ip4[4];
2286
		memset(ip4, 0, sizeof(ip4));
2287
		if(len-4 > 4) {
2288
			ldns_buffer_printf(output, "trailingdata:");
2289
			ldns_edns_hex_data2buffer_str(output, data+4+4, len-4-4);
2290
			ldns_buffer_printf(output, " ");
2291
			len = 4+4;
2292
		}
2293
		memmove(ip4, data+4, len-4);
2294
		if(!inet_ntop(AF_INET, ip4, buf, (socklen_t) sizeof(buf))) {
2295
			ldns_buffer_printf(output, "ip4ntoperror ");
2296
			ldns_edns_hex_data2buffer_str(output, data+4+4, len-4-4);
2297
		} else {
2298
			ldns_buffer_printf(output, "%s", buf);
2299
		}
2300
	} else if(family == 2) {
2301
		/* IPv6 */
2302
		char buf[64];
2303
		uint8_t ip6[16];
2304
		memset(ip6, 0, sizeof(ip6));
2305
		if(len-4 > 16) {
2306
			ldns_buffer_printf(output, "trailingdata:");
2307
			ldns_edns_hex_data2buffer_str(output, data+4+16, len-4-16);
2308
			ldns_buffer_printf(output, " ");
2309
			len = 4+16;
2310
		}
2311
		memmove(ip6, data+4, len-4);
2312
#ifdef AF_INET6
2313
		if(!inet_ntop(AF_INET6, ip6, buf, (socklen_t) sizeof(buf))) {
2314
			ldns_buffer_printf(output, "ip6ntoperror ");
2315
			ldns_edns_hex_data2buffer_str(output, data+4+4, len-4-4);
2316
		} else {
2317
			ldns_buffer_printf(output, "%s", buf);
2318
		}
2319
#else
2320
		ldns_edns_hex_data2buffer_str(output,  data+4+4, len-4-4);
2321
#endif
2322
	} else {
2323
		/* unknown */
2324
		ldns_buffer_printf(output, "family %d ", (int)family);
2325
		ldns_edns_hex_data2buffer_str(output, data, len);
2326
	}
2327
	ldns_buffer_printf(output, "/%d scope /%d", (int)source, (int)scope);
2328

2329
	return ldns_buffer_status(output);
2330
}
2331

2332
static ldns_status
2333
ldns_edns_expire2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2334
{
2335

2336
	ldns_buffer_printf(output, "; EXPIRE:");
2337

2338
	if (!(len == 0) || len == 4) {
2339
		ldns_buffer_printf(output, "malformed expire ");
2340
		ldns_edns_hex_data2buffer_str(output, data, len);
2341

2342
		return ldns_buffer_status(output);
2343
	}
2344

2345
	// TODO can this output be more accurate?
2346
	ldns_edns_hex_data2buffer_str(output, data, len);
2347

2348
	return ldns_buffer_status(output);
2349
}
2350

2351

2352
static ldns_status
2353
ldns_edns_cookie2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2354
{
2355
	ldns_buffer_printf(output, "; COOKIE:");
2356

2357
	/* the size of an EDNS cookie is restricted by RFC 7873 */
2358
	if (!(len == 8 || (len >= 16 && len < 40))) {
2359
		ldns_buffer_printf(output, "malformed cookie ");
2360
		ldns_edns_hex_data2buffer_str(output, data, len);
2361
	}
2362
	ldns_edns_hex_data2buffer_str(output, data, len);
2363

2364
	return ldns_buffer_status(output);
2365
}
2366

2367
static ldns_status
2368
ldns_edns_keepalive2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2369
{
2370
	uint16_t timeout;
2371

2372
	ldns_buffer_printf(output, "; KEEPALIVE:");
2373

2374
	if(!(len == 0 || len == 2)) {
2375
		ldns_buffer_printf(output, "malformed keepalive ");
2376
		ldns_edns_hex_data2buffer_str(output, data, len);
2377

2378
		return ldns_buffer_status(output);
2379
	}
2380

2381
	if(len == 0) {
2382
		ldns_buffer_printf(output, "no timeout value (only valid for client option)");
2383
	} else {
2384
		timeout = ldns_read_uint16(data);
2385
		ldns_buffer_printf(output, "timeout value in units of 100ms %u", (int)timeout);
2386
	}
2387
	return ldns_buffer_status(output);
2388
}
2389

2390
static ldns_status
2391
ldns_edns_padding2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2392
{
2393
	ldns_buffer_printf(output, "; PADDING: ");
2394
	ldns_edns_hex_data2buffer_str(output, data, len);
2395

2396
	return ldns_buffer_status(output);
2397
}
2398

2399
static ldns_status
2400
ldns_edns_chain2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2401
{
2402
	ldns_rdf** temp = NULL;
2403

2404
	ldns_buffer_printf(output, "; CHAIN: ");
2405

2406
	if (ldns_str2rdf_dname(temp, (char*) data) != LDNS_STATUS_OK) {
2407
		ldns_buffer_printf(output, "malformed chain ");
2408
		ldns_edns_hex_data2buffer_str(output, data, len);
2409

2410
		return ldns_buffer_status(output);
2411
	}
2412

2413
	ldns_characters2buffer_str(output, len, data);
2414

2415
	return ldns_buffer_status(output);
2416
}
2417

2418
static ldns_status
2419
ldns_edns_key_tag2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2420
{
2421
	size_t i;
2422

2423
	ldns_buffer_printf(output, "; KEY TAG: ");
2424

2425
	if(len < 2 || len % 2 != 0) {
2426
		ldns_buffer_printf(output, "malformed key tag ");
2427
		ldns_edns_hex_data2buffer_str(output, data, len);
2428

2429
		return ldns_buffer_status(output);
2430
	}
2431

2432
	for (i = 0; i < len; i += 2) {
2433
		uint16_t tag = ldns_read_uint16(data);
2434

2435
		ldns_buffer_printf(output, " %hu", tag);
2436
	}
2437

2438
	return ldns_buffer_status(output);
2439
}
2440

2441
static ldns_status
2442
ldns_edns_ede2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2443
{
2444
	size_t i;
2445
	uint16_t ede;
2446
	ldns_buffer_printf(output, "; EDE:");
2447

2448
	if(len < 2) {
2449
		ldns_buffer_printf(output, "malformed ede ");
2450
		ldns_edns_hex_data2buffer_str(output, data, len);
2451

2452
		return ldns_buffer_status(output);
2453
	}
2454

2455
	ede = ldns_read_uint16(data);
2456

2457
	switch (ede) {
2458
	case LDNS_EDE_OTHER:
2459
		ldns_buffer_printf(output, " 0 (Other): ");
2460
		break;
2461
	case LDNS_EDE_UNSUPPORTED_DNSKEY_ALG:
2462
		ldns_buffer_printf(output, " 1 (Unsupported DNSKEY Algorithm)");
2463
		break;
2464
	case LDNS_EDE_UNSUPPORTED_DS_DIGEST:
2465
		ldns_buffer_printf(output, " 2 (Unsupported DS Digest type)");
2466
		break;
2467
	case LDNS_EDE_STALE_ANSWER:
2468
		ldns_buffer_printf(output, " 3 (Stale Answer)");
2469
		break;
2470
	case LDNS_EDE_FORGED_ANSWER:
2471
		ldns_buffer_printf(output, " 4 (Forged Answer)");
2472
		break;
2473
	case LDNS_EDE_DNSSEC_INDETERMINATE:
2474
		ldns_buffer_printf(output, " 5 (DNSSEC Indeterminate)");
2475
		break;
2476
	case LDNS_EDE_DNSSEC_BOGUS:
2477
		ldns_buffer_printf(output, " 6 (DNSSEC Bogus)");
2478
		break;
2479
	case LDNS_EDE_SIGNATURE_EXPIRED:
2480
		ldns_buffer_printf(output, " 7 (Signature Expired)");
2481
		break;
2482
	case LDNS_EDE_SIGNATURE_NOT_YET_VALID:
2483
		ldns_buffer_printf(output, " 8 (Signature Not Yet Valid)");
2484
		break;
2485
	case LDNS_EDE_DNSKEY_MISSING:
2486
		ldns_buffer_printf(output, " 9 (DNSKEY Missing)");
2487
		break;
2488
	case LDNS_EDE_RRSIGS_MISSING:
2489
		ldns_buffer_printf(output, " 10 (RRSIGs Missing)");
2490
		break;
2491
	case LDNS_EDE_NO_ZONE_KEY_BIT_SET:
2492
		ldns_buffer_printf(output, " 11 (No Zone Key Bit Set)");
2493
		break;
2494
	case LDNS_EDE_NSEC_MISSING:
2495
		ldns_buffer_printf(output, " 12 (NSEC Missing)");
2496
		break;
2497
	case LDNS_EDE_CACHED_ERROR:
2498
		ldns_buffer_printf(output, " 13 (Cached Error)");
2499
		break;
2500
	case LDNS_EDE_NOT_READY:
2501
		ldns_buffer_printf(output, " 14 (Not Ready)");
2502
		break;
2503
	case LDNS_EDE_BLOCKED:
2504
		ldns_buffer_printf(output, " 15 (Blocked)");
2505
		break;
2506
	case LDNS_EDE_CENSORED:
2507
		ldns_buffer_printf(output, " 16 (Censored)");
2508
		break;
2509
	case LDNS_EDE_FILTERED:
2510
		ldns_buffer_printf(output, " 17 (Filtered)");
2511
		break;
2512
	case LDNS_EDE_PROHIBITED:
2513
		ldns_buffer_printf(output, " 18 (Prohibited)");
2514
		break;
2515
	case LDNS_EDE_STALE_NXDOMAIN_ANSWER:
2516
		ldns_buffer_printf(output, " 19 (NXDOMAIN Answer)");
2517
		break;
2518
	case LDNS_EDE_NOT_AUTHORITATIVE:
2519
		ldns_buffer_printf(output, " 20 (Not Authoritative)");
2520
		break;
2521
	case LDNS_EDE_NOT_SUPPORTED:
2522
		ldns_buffer_printf(output, " 21 (Not Supported)");
2523
		break;
2524
	case LDNS_EDE_NO_REACHABLE_AUTHORITY:
2525
		ldns_buffer_printf(output, " 22 (No Reachable Authority)");
2526
		break;
2527
	case LDNS_EDE_NETWORK_ERROR:
2528
		ldns_buffer_printf(output, " 23 (Network Error)");
2529
		break;
2530
	case LDNS_EDE_INVALID_DATA:
2531
		ldns_buffer_printf(output, " 24 (Invalid Data)");
2532
		break;
2533
	case LDNS_EDE_SIGNATURE_EXPIRED_BEFORE_VALID:
2534
		ldns_buffer_printf(output, " 25 (Signature Expired Before Valid)");
2535
		break;
2536
	case LDNS_EDE_TOO_EARLY:
2537
		ldns_buffer_printf(output, " 26 (Too Early)");
2538
		break;
2539
	default:
2540
		ldns_buffer_printf(output, " %02x", data[0]);
2541
		ldns_buffer_printf(output, " %02x", data[1]);
2542
		break;
2543
	}
2544

2545
	/* skip the EDE code in the output */
2546
	data += 2;
2547
	len -= 2;
2548

2549
	if (len > 2) {
2550
		/* format the hex bytes */
2551
		ldns_buffer_printf(output, ":");
2552
		for (i = 0; i < len; i++) {
2553
			ldns_buffer_printf(output, " %02x", data[i]);
2554
		}
2555

2556
		/* format the human-readable string */
2557
		ldns_buffer_printf(output, " (");
2558
		ldns_characters2buffer_str(output, len, data);
2559
		ldns_buffer_printf(output, ")");
2560
	}
2561

2562
	return ldns_buffer_status(output);
2563
}
2564

2565
static ldns_status
2566
ldns_edns_client_tag2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2567
{
2568
	ldns_buffer_printf(output, "; CLIENT-TAG:");
2569

2570
	if (len > 2) {
2571
		ldns_buffer_printf(output, "malformed client-tag ");
2572
		ldns_edns_hex_data2buffer_str(output, data, len);
2573

2574
		return ldns_buffer_status(output);
2575
	}
2576

2577
	ldns_edns_hex_data2buffer_str(output, data, len);
2578

2579
	return ldns_buffer_status(output);
2580
}
2581

2582
static ldns_status
2583
ldns_edns_server_tag2buffer_str(ldns_buffer* output, uint8_t* data, size_t len)
2584
{
2585
	ldns_buffer_printf(output, "; SERVER-TAG:");
2586

2587
	if (len > 2) {
2588
		ldns_buffer_printf(output, "malformed server-tag ");
2589
		ldns_edns_hex_data2buffer_str(output, data, len);
2590

2591
		return ldns_buffer_status(output);
2592
	}
2593

2594
	ldns_edns_hex_data2buffer_str(output, data, len);
2595

2596
	return ldns_buffer_status(output);
2597
}
2598

2599
ldns_status
2600
ldns_edns_option_list2buffer_str(ldns_buffer *output, ldns_edns_option_list* edns_list)
2601
{
2602
	size_t count = ldns_edns_option_list_get_count(edns_list);
2603
	size_t i, size;
2604
	uint8_t* data;
2605

2606
	for (i = 0; i < count; i++) {
2607
		ldns_edns_option_code code;
2608
		ldns_edns_option* edns = ldns_edns_option_list_get_option(edns_list, i);
2609

2610
		if (!edns) {
2611
			break;
2612
		}
2613

2614
		code = ldns_edns_get_code(edns);
2615
		size = ldns_edns_get_size(edns);
2616
		data = ldns_edns_get_data(edns);
2617

2618
		switch(code) {
2619
		case LDNS_EDNS_LLQ:
2620
			ldns_edns_llq2buffer_str(output, data, size);
2621
			break;
2622
		case LDNS_EDNS_UL:
2623
			ldns_edns_ul2buffer_str(output, data, size);
2624
			break;
2625
		case LDNS_EDNS_NSID:
2626
			ldns_edns_nsid2buffer_str(output, data, size);
2627
			break;
2628
		case LDNS_EDNS_DAU:
2629
			ldns_edns_dau2buffer_str(output, data, size);
2630
			break;
2631
		case LDNS_EDNS_DHU:
2632
			ldns_edns_dhu2buffer_str(output, data, size);
2633
			break;
2634
		case LDNS_EDNS_N3U:
2635
			ldns_edns_d3u2buffer_str(output, data, size);
2636
			break;
2637
		case LDNS_EDNS_CLIENT_SUBNET:
2638
			ldns_edns_subnet2buffer_str(output, data, size);
2639
			break;
2640
		case LDNS_EDNS_EXPIRE:
2641
			ldns_edns_expire2buffer_str(output, data, size);
2642
			break;
2643
		case LDNS_EDNS_COOKIE:
2644
			ldns_edns_cookie2buffer_str(output, data, size);
2645
			break;
2646
		case LDNS_EDNS_KEEPALIVE:
2647
			ldns_edns_keepalive2buffer_str(output, data, size);
2648
			break;
2649
		case LDNS_EDNS_PADDING:
2650
			ldns_edns_padding2buffer_str(output, data, size);
2651
			break;
2652
		case LDNS_EDNS_CHAIN:
2653
			ldns_edns_chain2buffer_str(output, data, size);
2654
			break;
2655
		case LDNS_EDNS_KEY_TAG:
2656
			ldns_edns_key_tag2buffer_str(output, data, size);
2657
			break;
2658
		case LDNS_EDNS_EDE:
2659
			ldns_edns_ede2buffer_str(output, data, size);
2660
			break;
2661
		case LDNS_EDNS_CLIENT_TAG:
2662
			ldns_edns_client_tag2buffer_str(output, data, size);
2663
			break;
2664
		case LDNS_EDNS_SERVER_TAG:
2665
			ldns_edns_server_tag2buffer_str(output, data, size);
2666
			break;
2667
		default:
2668
			ldns_buffer_printf(output, "; OPT=%d:", code);
2669
			ldns_edns_hex_data2buffer_str(output, data, size);
2670
			break;
2671
		}
2672
		ldns_buffer_printf(output, "\n");
2673
	}
2674

2675
	return ldns_buffer_status(output);
2676
}
2677

2678

2679
ldns_status
2680
ldns_pkt2buffer_str_fmt(ldns_buffer *output, 
2681
		const ldns_output_format *fmt, const ldns_pkt *pkt)
2682
{
2683
	uint16_t i;
2684
	ldns_status status = LDNS_STATUS_OK;
2685
	char *tmp;
2686
	struct timeval time;
2687
	time_t time_tt;
2688
	int short_fmt = fmt && (fmt->flags & LDNS_FMT_SHORT);
2689

2690
	if (!pkt) {
2691
		ldns_buffer_printf(output, "null");
2692
		return LDNS_STATUS_OK;
2693
	}
2694

2695
	if (!ldns_buffer_status_ok(output)) {
2696
		return ldns_buffer_status(output);
2697
	}
2698

2699
	if (!short_fmt) {
2700
		status = ldns_pktheader2buffer_str(output, pkt);
2701
		if (status != LDNS_STATUS_OK) {
2702
			return status;
2703
		}
2704

2705
		ldns_buffer_printf(output, "\n");
2706

2707
		ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
2708

2709

2710
		for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
2711
			status = ldns_rr2buffer_str_fmt(output, fmt,
2712
				       ldns_rr_list_rr(
2713
					       ldns_pkt_question(pkt), i));
2714
			if (status != LDNS_STATUS_OK) {
2715
				return status;
2716
			}
2717
		}
2718
		ldns_buffer_printf(output, "\n");
2719

2720
		ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
2721
	}
2722
	for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
2723
		status = ldns_rr2buffer_str_fmt(output, fmt,
2724
			       ldns_rr_list_rr(
2725
				       ldns_pkt_answer(pkt), i));
2726
		if (status != LDNS_STATUS_OK) {
2727
			return status;
2728
		}
2729
	}
2730
	if (!short_fmt) {
2731
		ldns_buffer_printf(output, "\n");
2732

2733
		ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
2734

2735
		for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
2736
			status = ldns_rr2buffer_str_fmt(output, fmt,
2737
				       ldns_rr_list_rr(
2738
					       ldns_pkt_authority(pkt), i));
2739
			if (status != LDNS_STATUS_OK) {
2740
				return status;
2741
			}
2742
		}
2743
		ldns_buffer_printf(output, "\n");
2744

2745
		ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
2746
		for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
2747
			status = ldns_rr2buffer_str_fmt(output, fmt,
2748
				       ldns_rr_list_rr(
2749
					       ldns_pkt_additional(pkt), i));
2750
			if (status != LDNS_STATUS_OK) {
2751
				return status;
2752
			}
2753

2754
		}
2755
		ldns_buffer_printf(output, "\n");
2756
		/* add some further fields */
2757
		ldns_buffer_printf(output, ";; Query time: %d msec\n",
2758
				ldns_pkt_querytime(pkt));
2759
		if (ldns_pkt_edns(pkt)) {
2760
			ldns_buffer_printf(output,
2761
				   ";; EDNS: version %u; flags:",
2762
				   ldns_pkt_edns_version(pkt));
2763
			if (ldns_pkt_edns_do(pkt)) {
2764
				ldns_buffer_printf(output, " do");
2765
			}
2766
			/* the extended rcode is the value set, shifted four bits,
2767
			 * and or'd with the original rcode */
2768
			if (ldns_pkt_edns_extended_rcode(pkt)) {
2769
				ldns_buffer_printf(output, " ; ext-rcode: %d",
2770
					(ldns_pkt_edns_extended_rcode(pkt) << 4 | ldns_pkt_get_rcode(pkt)));
2771
			}
2772
			ldns_buffer_printf(output, " ; udp: %u\n",
2773
					   ldns_pkt_edns_udp_size(pkt));
2774

2775
			if (pkt->_edns_list)
2776
				ldns_edns_option_list2buffer_str(output, pkt->_edns_list);
2777

2778
			else if (ldns_pkt_edns_data(pkt)) {
2779
				ldns_edns_option_list* edns_list;
2780
				/* parse the EDNS data into separate EDNS options
2781
				 * and add them to the list */
2782
				if ((edns_list = pkt_edns_data2edns_option_list(ldns_pkt_edns_data(pkt)))) {
2783
					ldns_edns_option_list2buffer_str(output, edns_list);
2784
					ldns_edns_option_list_deep_free(edns_list);
2785
				} else {
2786
					ldns_buffer_printf(output, ";; Data: ");
2787
					(void)ldns_rdf2buffer_str(output, ldns_pkt_edns_data(pkt));
2788
				}
2789
			}
2790
		}
2791
		if (ldns_pkt_tsig(pkt)) {
2792
			ldns_buffer_printf(output, ";; TSIG:\n;; ");
2793
			(void) ldns_rr2buffer_str_fmt(
2794
					output, fmt, ldns_pkt_tsig(pkt));
2795
			ldns_buffer_printf(output, "\n");
2796
		}
2797
		if (ldns_pkt_answerfrom(pkt)) {
2798
			tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
2799
			ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
2800
			LDNS_FREE(tmp);
2801
		}
2802
		time = ldns_pkt_timestamp(pkt);
2803
		time_tt = (time_t)time.tv_sec;
2804
		ldns_buffer_printf(output, ";; WHEN: %s",
2805
				(char*)ctime(&time_tt));
2806

2807
		ldns_buffer_printf(output, ";; MSG SIZE  rcvd: %d\n",
2808
				(int)ldns_pkt_size(pkt));
2809
	}
2810
	return status;
2811
}
2812

2813
ldns_status
2814
ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
2815
{
2816
	return ldns_pkt2buffer_str_fmt(output, ldns_output_format_default, pkt);
2817
}
2818

2819

2820
#ifdef HAVE_SSL
2821
static ldns_status
2822
ldns_hmac_key2buffer_str(ldns_buffer *output, const ldns_key *k)
2823
{
2824
	ldns_status status;
2825
	size_t i;
2826
	ldns_rdf *b64_bignum;
2827

2828
	ldns_buffer_printf(output, "Key: ");
2829

2830
 	i = ldns_key_hmac_size(k);
2831
	b64_bignum =  ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, i, ldns_key_hmac_key(k));
2832
	status = ldns_rdf2buffer_str(output, b64_bignum);
2833
	ldns_rdf_deep_free(b64_bignum);
2834
	ldns_buffer_printf(output, "\n");
2835
	return status;
2836
}
2837
#endif
2838

2839
#if defined(HAVE_SSL) && defined(USE_GOST)
2840
static ldns_status
2841
ldns_gost_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
2842
{
2843
	unsigned char* pp = NULL;
2844
	int ret;
2845
	ldns_rdf *b64_bignum;
2846
	ldns_status status;
2847

2848
	ldns_buffer_printf(output, "GostAsn1: ");
2849

2850
	ret = i2d_PrivateKey(p, &pp);
2851
	b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, (size_t)ret, pp);
2852
	status = ldns_rdf2buffer_str(output, b64_bignum);
2853

2854
	ldns_rdf_deep_free(b64_bignum);
2855
	OPENSSL_free(pp);
2856
	ldns_buffer_printf(output, "\n");
2857
	return status;
2858
}
2859
#endif
2860

2861
#if defined(HAVE_SSL) && defined(USE_ED25519)
2862
static ldns_status
2863
ldns_ed25519_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
2864
{
2865
	unsigned char* pp = NULL;
2866
	int ret;
2867
	ldns_rdf *b64_bignum;
2868
	ldns_status status;
2869

2870
	ldns_buffer_printf(output, "PrivateKey: ");
2871

2872
	ret = i2d_PrivateKey(p, &pp);
2873
	/* 16 byte asn (302e020100300506032b657004220420) + 32byte key */
2874
	if(ret != 16 + 32) {
2875
		OPENSSL_free(pp);
2876
		return LDNS_STATUS_ERR;
2877
	}
2878
	b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64,
2879
		(size_t)ret-16, pp+16);
2880
	status = ldns_rdf2buffer_str(output, b64_bignum);
2881

2882
	ldns_rdf_deep_free(b64_bignum);
2883
	OPENSSL_free(pp);
2884
	ldns_buffer_printf(output, "\n");
2885
	return status;
2886
}
2887
#endif
2888

2889
#if defined(HAVE_SSL) && defined(USE_ED448)
2890
static ldns_status
2891
ldns_ed448_key2buffer_str(ldns_buffer *output, EVP_PKEY *p)
2892
{
2893
	unsigned char* pp = NULL;
2894
	int ret;
2895
	ldns_rdf *b64_bignum;
2896
	ldns_status status;
2897

2898
	ldns_buffer_printf(output, "PrivateKey: ");
2899

2900
	ret = i2d_PrivateKey(p, &pp);
2901
	/* some-ASN + 57byte key */
2902
	if(ret != 16 + 57) {
2903
		OPENSSL_free(pp);
2904
		return LDNS_STATUS_ERR;
2905
	}
2906
	b64_bignum = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64,
2907
		(size_t)ret-16, pp+16);
2908
	status = ldns_rdf2buffer_str(output, b64_bignum);
2909

2910
	ldns_rdf_deep_free(b64_bignum);
2911
	OPENSSL_free(pp);
2912
	ldns_buffer_printf(output, "\n");
2913
	return status;
2914
}
2915
#endif
2916

2917
#if defined(HAVE_SSL)
2918
/** print one b64 encoded bignum to a line in the keybuffer */
2919
static int
2920
ldns_print_bignum_b64_line(ldns_buffer* output, const char* label, const BIGNUM* num)
2921
{
2922
	unsigned char  *bignumbuf = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
2923
	if(!bignumbuf) return 0;
2924

2925
	ldns_buffer_printf(output, "%s: ", label);
2926
	if(num) {
2927
		ldns_rdf *b64_bignum = NULL;
2928
		int i = BN_bn2bin(num, bignumbuf);
2929
		if (i > LDNS_MAX_KEYLEN) {
2930
			LDNS_FREE(bignumbuf);
2931
			return 0;
2932
		}
2933
		b64_bignum =  ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, (size_t)i, bignumbuf);
2934
		if (ldns_rdf2buffer_str(output, b64_bignum) != LDNS_STATUS_OK) {
2935
			ldns_rdf_deep_free(b64_bignum);
2936
			LDNS_FREE(bignumbuf);
2937
			return 0;
2938
		}
2939
		ldns_rdf_deep_free(b64_bignum);
2940
		ldns_buffer_printf(output, "\n");
2941
	} else {
2942
		ldns_buffer_printf(output, "(Not available)\n");
2943
	}
2944
	LDNS_FREE(bignumbuf);
2945
	return 1;
2946
}
2947
#endif
2948

2949
ldns_status
2950
ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
2951
{
2952
	ldns_status status = LDNS_STATUS_OK;
2953
	unsigned char  *bignum;
2954
#ifdef HAVE_SSL
2955
	RSA *rsa;
2956
#ifdef USE_DSA
2957
	DSA *dsa;
2958
#endif /* USE_DSA */
2959
#endif /* HAVE_SSL */
2960

2961
	if (!k) {
2962
		return LDNS_STATUS_ERR;
2963
	}
2964

2965
	bignum = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
2966
	if (!bignum) {
2967
		return LDNS_STATUS_ERR;
2968
	}
2969

2970
	if (ldns_buffer_status_ok(output)) {
2971
#ifdef HAVE_SSL
2972
		switch(ldns_key_algorithm(k)) {
2973
			case LDNS_SIGN_RSASHA1:
2974
			case LDNS_SIGN_RSASHA1_NSEC3:
2975
			case LDNS_SIGN_RSASHA256:
2976
			case LDNS_SIGN_RSASHA512:
2977
			case LDNS_SIGN_RSAMD5:
2978
				/* copied by looking at dnssec-keygen output */
2979
				/* header */
2980
				rsa = ldns_key_rsa_key(k);
2981

2982
				ldns_buffer_printf(output,"Private-key-format: v1.2\n");
2983
				switch(ldns_key_algorithm(k)) {
2984
				case LDNS_SIGN_RSAMD5:
2985
					ldns_buffer_printf(output,
2986
								    "Algorithm: %u (RSA)\n",
2987
								    LDNS_RSAMD5);
2988
					break;
2989
				case LDNS_SIGN_RSASHA1:
2990
					ldns_buffer_printf(output,
2991
								    "Algorithm: %u (RSASHA1)\n",
2992
								    LDNS_RSASHA1);
2993
					break;
2994
				case LDNS_SIGN_RSASHA1_NSEC3:
2995
					ldns_buffer_printf(output,
2996
								    "Algorithm: %u (RSASHA1_NSEC3)\n",
2997
								    LDNS_RSASHA1_NSEC3);
2998
					break;
2999
#ifdef USE_SHA2
3000
				case LDNS_SIGN_RSASHA256:
3001
					ldns_buffer_printf(output,
3002
								    "Algorithm: %u (RSASHA256)\n",
3003
								    LDNS_RSASHA256);
3004
					break;
3005
				case LDNS_SIGN_RSASHA512:
3006
					ldns_buffer_printf(output,
3007
								    "Algorithm: %u (RSASHA512)\n",
3008
								    LDNS_RSASHA512);
3009
					break;
3010
#endif
3011
				default:
3012
#ifdef STDERR_MSGS
3013
					fprintf(stderr, "Warning: unknown signature ");
3014
					fprintf(stderr,
3015
						   "algorithm type %u\n",
3016
						   ldns_key_algorithm(k));
3017
#endif
3018
					ldns_buffer_printf(output,
3019
								    "Algorithm: %u (Unknown)\n",
3020
								    ldns_key_algorithm(k));
3021
					break;
3022
				}
3023

3024
				/* print to buf, convert to bin, convert to b64,
3025
				 * print to buf */
3026

3027
#ifndef S_SPLINT_S
3028
				if(1) {
3029
					const BIGNUM *n=NULL, *e=NULL, *d=NULL,
3030
						*p=NULL, *q=NULL, *dmp1=NULL,
3031
						*dmq1=NULL, *iqmp=NULL;
3032
#if OPENSSL_VERSION_NUMBER < 0x10100000 || (defined(HAVE_LIBRESSL) && LIBRESSL_VERSION_NUMBER < 0x20700000)
3033
					n = rsa->n;
3034
					e = rsa->e;
3035
					d = rsa->d;
3036
					p = rsa->p;
3037
					q = rsa->q;
3038
					dmp1 = rsa->dmp1;
3039
					dmq1 = rsa->dmq1;
3040
					iqmp = rsa->iqmp;
3041
#else
3042
					RSA_get0_key(rsa, &n, &e, &d);
3043
					RSA_get0_factors(rsa, &p, &q);
3044
					RSA_get0_crt_params(rsa, &dmp1,
3045
						&dmq1, &iqmp);
3046
#endif
3047
					if(!ldns_print_bignum_b64_line(output, "Modulus", n))
3048
						goto error;
3049
					if(!ldns_print_bignum_b64_line(output, "PublicExponent", e))
3050
						goto error;
3051
					if(!ldns_print_bignum_b64_line(output, "PrivateExponent", d))
3052
						goto error;
3053
					if(!ldns_print_bignum_b64_line(output, "Prime1", p))
3054
						goto error;
3055
					if(!ldns_print_bignum_b64_line(output, "Prime2", q))
3056
						goto error;
3057
					if(!ldns_print_bignum_b64_line(output, "Exponent1", dmp1))
3058
						goto error;
3059
					if(!ldns_print_bignum_b64_line(output, "Exponent2", dmq1))
3060
						goto error;
3061
					if(!ldns_print_bignum_b64_line(output, "Coefficient", iqmp))
3062
						goto error;
3063
				}
3064
#endif /* splint */
3065

3066
				RSA_free(rsa);
3067
				break;
3068
#ifdef USE_DSA
3069
			case LDNS_SIGN_DSA:
3070
			case LDNS_SIGN_DSA_NSEC3:
3071
				dsa = ldns_key_dsa_key(k);
3072

3073
				ldns_buffer_printf(output,"Private-key-format: v1.2\n");
3074
				if (ldns_key_algorithm(k) == LDNS_SIGN_DSA) {
3075
					ldns_buffer_printf(output,"Algorithm: 3 (DSA)\n");
3076
				} else if (ldns_key_algorithm(k) == LDNS_SIGN_DSA_NSEC3) {
3077
					ldns_buffer_printf(output,"Algorithm: 6 (DSA_NSEC3)\n");
3078
				}
3079

3080
				/* print to buf, convert to bin, convert to b64,
3081
				 * print to buf */
3082
				if(1) {
3083
					const BIGNUM *p=NULL, *q=NULL, *g=NULL,
3084
						*priv_key=NULL, *pub_key=NULL;
3085
#if OPENSSL_VERSION_NUMBER < 0x10100000 || (defined(HAVE_LIBRESSL) && LIBRESSL_VERSION_NUMBER < 0x20700000)
3086
#ifndef S_SPLINT_S
3087
					p = dsa->p;
3088
					q = dsa->q;
3089
					g = dsa->g;
3090
					priv_key = dsa->priv_key;
3091
					pub_key = dsa->pub_key;
3092
#endif /* splint */
3093
#else
3094
					DSA_get0_pqg(dsa, &p, &q, &g);
3095
					DSA_get0_key(dsa, &pub_key, &priv_key);
3096
#endif
3097
					if(!ldns_print_bignum_b64_line(output, "Prime(p)", p))
3098
						goto error;
3099
					if(!ldns_print_bignum_b64_line(output, "Subprime(q)", q))
3100
						goto error;
3101
					if(!ldns_print_bignum_b64_line(output, "Base(g)", g))
3102
						goto error;
3103
					if(!ldns_print_bignum_b64_line(output, "Private_value(x)", priv_key))
3104
						goto error;
3105
					if(!ldns_print_bignum_b64_line(output, "Public_value(y)", pub_key))
3106
						goto error;
3107
				}
3108
				break;
3109
#endif /* USE_DSA */
3110
			case LDNS_SIGN_ECC_GOST:
3111
				/* no format defined, use blob */
3112
#if defined(HAVE_SSL) && defined(USE_GOST)
3113
				ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3114
				ldns_buffer_printf(output, "Algorithm: %d (ECC-GOST)\n", LDNS_SIGN_ECC_GOST);
3115
				status = ldns_gost_key2buffer_str(output, 
3116
#ifndef S_SPLINT_S
3117
					k->_key.key
3118
#else
3119
					NULL
3120
#endif
3121
				);
3122
#else
3123
				goto error;
3124
#endif /* GOST */
3125
				break;
3126
			case LDNS_SIGN_ECDSAP256SHA256:
3127
			case LDNS_SIGN_ECDSAP384SHA384:
3128
#ifdef USE_ECDSA
3129
                                ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3130
				ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
3131
                                status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
3132
#ifndef S_SPLINT_S
3133
				ldns_buffer_printf(output, ")\n");
3134
                                if(k->_key.key) {
3135
                                        EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->_key.key);
3136
                                        const BIGNUM* b = EC_KEY_get0_private_key(ec);
3137
					if(!ldns_print_bignum_b64_line(output, "PrivateKey", b))
3138
						goto error;
3139
                                        /* down reference count in EC_KEY
3140
                                         * its still assigned to the PKEY */
3141
                                        EC_KEY_free(ec);
3142
                                }
3143
#endif /* splint */
3144
#else
3145
				goto error;
3146
#endif /* ECDSA */
3147
                                break;
3148
#ifdef USE_ED25519
3149
			case LDNS_SIGN_ED25519:
3150
                                ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3151
				ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
3152
                                status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
3153
				ldns_buffer_printf(output, ")\n");
3154
				if (status) break;
3155
				status = ldns_ed25519_key2buffer_str(output,
3156
					k->_key.key);
3157
				break;
3158
#endif /* USE_ED25519 */
3159
#ifdef USE_ED448
3160
			case LDNS_SIGN_ED448:
3161
                                ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3162
				ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
3163
                                status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
3164
				ldns_buffer_printf(output, ")\n");
3165
				if (status) break;
3166
				status = ldns_ed448_key2buffer_str(output,
3167
					k->_key.key);
3168
				break;
3169
#endif /* USE_ED448 */
3170
			case LDNS_SIGN_HMACMD5:
3171
				/* there's not much of a format defined for TSIG */
3172
				/* It's just a binary blob, Same for all algorithms */
3173
                ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3174
                ldns_buffer_printf(output, "Algorithm: 157 (HMAC_MD5)\n");
3175
				status = ldns_hmac_key2buffer_str(output, k);
3176
				break;
3177
			case LDNS_SIGN_HMACSHA1:
3178
		        ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3179
		        ldns_buffer_printf(output, "Algorithm: 158 (HMAC_SHA1)\n");
3180
				status = ldns_hmac_key2buffer_str(output, k);
3181
				break;
3182
			case LDNS_SIGN_HMACSHA224:
3183
		        ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3184
		        ldns_buffer_printf(output, "Algorithm: 162 (HMAC_SHA224)\n");
3185
				status = ldns_hmac_key2buffer_str(output, k);
3186
				break;
3187
			case LDNS_SIGN_HMACSHA256:
3188
		        ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3189
		        ldns_buffer_printf(output, "Algorithm: 159 (HMAC_SHA256)\n");
3190
				status = ldns_hmac_key2buffer_str(output, k);
3191
				break;
3192
			case LDNS_SIGN_HMACSHA384:
3193
		        ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3194
		        ldns_buffer_printf(output, "Algorithm: 164 (HMAC_SHA384)\n");
3195
				status = ldns_hmac_key2buffer_str(output, k);
3196
				break;
3197
			case LDNS_SIGN_HMACSHA512:
3198
		        ldns_buffer_printf(output, "Private-key-format: v1.2\n");
3199
		        ldns_buffer_printf(output, "Algorithm: 165 (HMAC_SHA512)\n");
3200
				status = ldns_hmac_key2buffer_str(output, k);
3201
				break;
3202
		}
3203
#endif /* HAVE_SSL */
3204
	} else {
3205
		LDNS_FREE(bignum);
3206
		return ldns_buffer_status(output);
3207
	}
3208
	LDNS_FREE(bignum);
3209
	return status;
3210

3211
#ifdef HAVE_SSL
3212
	/* compiles warn the label isn't used */
3213
error:
3214
	LDNS_FREE(bignum);
3215
	return LDNS_STATUS_ERR;
3216
#endif /* HAVE_SSL */
3217

3218
}
3219

3220
/*
3221
 * Zero terminate the buffer and copy data.
3222
 */
3223
char *
3224
ldns_buffer2str(ldns_buffer *buffer)
3225
{
3226
	char *str;
3227

3228
	/* check if buffer ends with \0, if not, and
3229
	   if there is space, add it */
3230
	if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
3231
		if (!ldns_buffer_reserve(buffer, 1)) {
3232
			return NULL;
3233
		}
3234
		ldns_buffer_write_char(buffer, (uint8_t) '\0');
3235
		if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
3236
			return NULL;
3237
		}
3238
	}
3239

3240
	str = strdup((const char *)ldns_buffer_begin(buffer));
3241
        if(!str) {
3242
                return NULL;
3243
        }
3244
	return str;
3245
}
3246

3247
/*
3248
 * Zero terminate the buffer and export data.
3249
 */
3250
char *
3251
ldns_buffer_export2str(ldns_buffer *buffer)
3252
{
3253
	/* Append '\0' as string terminator */
3254
	if (! ldns_buffer_reserve(buffer, 1)) {
3255
		return NULL;
3256
	}
3257
	ldns_buffer_write_char(buffer, 0);
3258

3259
	/* reallocate memory to the size of the string and export */
3260
	ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer));
3261
	return ldns_buffer_export(buffer);
3262
}
3263

3264
char *
3265
ldns_rdf2str(const ldns_rdf *rdf)
3266
{
3267
	char *result = NULL;
3268
	ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
3269

3270
	if (!tmp_buffer) {
3271
		return NULL;
3272
	}
3273
	if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
3274
		/* export and return string, destroy rest */
3275
		result = ldns_buffer_export2str(tmp_buffer);
3276
	}
3277
	ldns_buffer_free(tmp_buffer);
3278
	return result;
3279
}
3280

3281
char *
3282
ldns_rr2str_fmt(const ldns_output_format *fmt, const ldns_rr *rr)
3283
{
3284
	char *result = NULL;
3285
	ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
3286

3287
	if (!tmp_buffer) {
3288
		return NULL;
3289
	}
3290
	if (ldns_rr2buffer_str_fmt(tmp_buffer, fmt, rr)
3291
		       	== LDNS_STATUS_OK) {
3292
		/* export and return string, destroy rest */
3293
		result = ldns_buffer_export2str(tmp_buffer);
3294
	}
3295
	ldns_buffer_free(tmp_buffer);
3296
	return result;
3297
}
3298

3299
char *
3300
ldns_rr2str(const ldns_rr *rr)
3301
{
3302
	return ldns_rr2str_fmt(ldns_output_format_default, rr);
3303
}
3304

3305
char *
3306
ldns_pkt2str_fmt(const ldns_output_format *fmt, const ldns_pkt *pkt)
3307
{
3308
	char *result = NULL;
3309
	ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
3310

3311
	if (!tmp_buffer) {
3312
		return NULL;
3313
	}
3314
	if (ldns_pkt2buffer_str_fmt(tmp_buffer, fmt, pkt)
3315
		       	== LDNS_STATUS_OK) {
3316
		/* export and return string, destroy rest */
3317
		result = ldns_buffer_export2str(tmp_buffer);
3318
	}
3319

3320
	ldns_buffer_free(tmp_buffer);
3321
	return result;
3322
}
3323

3324
char *
3325
ldns_pkt2str(const ldns_pkt *pkt)
3326
{
3327
	return ldns_pkt2str_fmt(ldns_output_format_default, pkt);
3328
}
3329

3330
char *
3331
ldns_key2str(const ldns_key *k)
3332
{
3333
	char *result = NULL;
3334
	ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
3335

3336
	if (!tmp_buffer) {
3337
		return NULL;
3338
	}
3339
	if (ldns_key2buffer_str(tmp_buffer, k) == LDNS_STATUS_OK) {
3340
		/* export and return string, destroy rest */
3341
		result = ldns_buffer_export2str(tmp_buffer);
3342
	}
3343
	ldns_buffer_free(tmp_buffer);
3344
	return result;
3345
}
3346

3347
char *
3348
ldns_rr_list2str_fmt(const ldns_output_format *fmt, const ldns_rr_list *list)
3349
{
3350
	char *result = NULL;
3351
	ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
3352

3353
	if (!tmp_buffer) {
3354
		return NULL;
3355
	}
3356
	if (list) {
3357
		if (ldns_rr_list2buffer_str_fmt(
3358
				   tmp_buffer, fmt, list)
3359
			       	== LDNS_STATUS_OK) {
3360
		}
3361
	} else {
3362
		if (fmt == NULL) {
3363
			fmt = ldns_output_format_default;
3364
		}
3365
		if (fmt->flags & LDNS_COMMENT_NULLS) {
3366
			ldns_buffer_printf(tmp_buffer, "; (null)\n");
3367
		}
3368
	}
3369

3370
	/* export and return string, destroy rest */
3371
	result = ldns_buffer_export2str(tmp_buffer);
3372
	ldns_buffer_free(tmp_buffer);
3373
	return result;
3374
}
3375

3376
char *
3377
ldns_rr_list2str(const ldns_rr_list *list)
3378
{
3379
	return ldns_rr_list2str_fmt(ldns_output_format_default, list);
3380
}
3381

3382
void
3383
ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
3384
{
3385
	char *str = ldns_rdf2str(rdf);
3386
	if (str) {
3387
		fprintf(output, "%s", str);
3388
	} else {
3389
		fprintf(output, ";Unable to convert rdf to string\n");
3390
	}
3391
	LDNS_FREE(str);
3392
}
3393

3394
void
3395
ldns_rr_print_fmt(FILE *output,
3396
		const ldns_output_format *fmt, const ldns_rr *rr)
3397
{
3398
	char *str = ldns_rr2str_fmt(fmt, rr);
3399
	if (str) {
3400
		fprintf(output, "%s", str);
3401
	} else {
3402
		fprintf(output, ";Unable to convert rr to string\n");
3403
	}
3404
	LDNS_FREE(str);
3405
}
3406

3407
void
3408
ldns_rr_print(FILE *output, const ldns_rr *rr)
3409
{
3410
	ldns_rr_print_fmt(output, ldns_output_format_default, rr);
3411
}
3412

3413
void
3414
ldns_pkt_print_fmt(FILE *output, 
3415
		const ldns_output_format *fmt, const ldns_pkt *pkt)
3416
{
3417
	char *str = ldns_pkt2str_fmt(fmt, pkt);
3418
	if (str) {
3419
		fprintf(output, "%s", str);
3420
	} else {
3421
		fprintf(output, ";Unable to convert packet to string\n");
3422
	}
3423
	LDNS_FREE(str);
3424
}
3425

3426
void
3427
ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
3428
{
3429
	ldns_pkt_print_fmt(output, ldns_output_format_default, pkt);
3430
}
3431

3432
void
3433
ldns_rr_list_print_fmt(FILE *output, 
3434
		const ldns_output_format *fmt, const ldns_rr_list *lst)
3435
{
3436
	size_t i;
3437
	for (i = 0; i < ldns_rr_list_rr_count(lst); i++) {
3438
		ldns_rr_print_fmt(output, fmt, ldns_rr_list_rr(lst, i));
3439
	}
3440
}
3441

3442
void
3443
ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
3444
{
3445
	ldns_rr_list_print_fmt(output, ldns_output_format_default, lst);
3446
}
3447

3448
void
3449
ldns_resolver_print_fmt(FILE *output, 
3450
		const ldns_output_format *fmt, const ldns_resolver *r)
3451
{
3452
	uint16_t i;
3453
	ldns_rdf **n;
3454
	ldns_rdf **s;
3455
	size_t *rtt;
3456
	if (!r) {
3457
		return;
3458
	}
3459
	n = ldns_resolver_nameservers(r);
3460
	s = ldns_resolver_searchlist(r);
3461
	rtt = ldns_resolver_rtt(r);
3462

3463
	fprintf(output, "port: %d\n", (int)ldns_resolver_port(r));
3464
	fprintf(output, "edns0 size: %d\n", (int)ldns_resolver_edns_udp_size(r));
3465
	fprintf(output, "use ip6: %d\n", (int)ldns_resolver_ip6(r));
3466

3467
	fprintf(output, "recursive: %d\n", ldns_resolver_recursive(r));
3468
	fprintf(output, "usevc: %d\n", ldns_resolver_usevc(r));
3469
	fprintf(output, "igntc: %d\n", ldns_resolver_igntc(r));
3470
	fprintf(output, "fail: %d\n", ldns_resolver_fail(r));
3471
	fprintf(output, "retry: %d\n", (int)ldns_resolver_retry(r));
3472
	fprintf(output, "retrans: %d\n", (int)ldns_resolver_retrans(r));
3473
	fprintf(output, "fallback: %d\n", ldns_resolver_fallback(r));
3474
	fprintf(output, "random: %d\n", ldns_resolver_random(r));
3475
	fprintf(output, "timeout: %d\n", (int)ldns_resolver_timeout(r).tv_sec);
3476
	fprintf(output, "dnssec: %d\n", ldns_resolver_dnssec(r));
3477
	fprintf(output, "dnssec cd: %d\n", ldns_resolver_dnssec_cd(r));
3478
	fprintf(output, "trust anchors (%d listed):\n",
3479
		(int)ldns_rr_list_rr_count(ldns_resolver_dnssec_anchors(r)));
3480
	ldns_rr_list_print_fmt(output, fmt, ldns_resolver_dnssec_anchors(r));
3481
	fprintf(output, "tsig: %s %s\n",
3482
                ldns_resolver_tsig_keyname(r)?ldns_resolver_tsig_keyname(r):"-",
3483
                ldns_resolver_tsig_algorithm(r)?ldns_resolver_tsig_algorithm(r):"-");
3484
	fprintf(output, "debug: %d\n", ldns_resolver_debug(r));
3485

3486
	fprintf(output, "default domain: ");
3487
	ldns_rdf_print(output, ldns_resolver_domain(r));
3488
	fprintf(output, "\n");
3489
	fprintf(output, "apply default domain: %d\n", ldns_resolver_defnames(r));
3490

3491
	fprintf(output, "searchlist (%d listed):\n",  (int)ldns_resolver_searchlist_count(r));
3492
	for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
3493
		fprintf(output, "\t");
3494
		ldns_rdf_print(output, s[i]);
3495
		fprintf(output, "\n");
3496
	}
3497
	fprintf(output, "apply search list: %d\n", ldns_resolver_dnsrch(r));
3498

3499
	fprintf(output, "nameservers (%d listed):\n", (int)ldns_resolver_nameserver_count(r));
3500
	for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
3501
		fprintf(output, "\t");
3502
		ldns_rdf_print(output, n[i]);
3503

3504
		switch ((int)rtt[i]) {
3505
			case LDNS_RESOLV_RTT_MIN:
3506
			fprintf(output, " - reachable\n");
3507
			break;
3508
			case LDNS_RESOLV_RTT_INF:
3509
			fprintf(output, " - unreachable\n");
3510
			break;
3511
		}
3512
	}
3513
}
3514

3515
void
3516
ldns_resolver_print(FILE *output, const ldns_resolver *r)
3517
{
3518
	ldns_resolver_print_fmt(output, ldns_output_format_default, r);
3519
}
3520

3521
void
3522
ldns_zone_print_fmt(FILE *output, 
3523
		const ldns_output_format *fmt, const ldns_zone *z)
3524
{
3525
	if(ldns_zone_soa(z))
3526
		ldns_rr_print_fmt(output, fmt, ldns_zone_soa(z));
3527
	ldns_rr_list_print_fmt(output, fmt, ldns_zone_rrs(z));
3528
}
3529
void
3530
ldns_zone_print(FILE *output, const ldns_zone *z)
3531
{
3532
	ldns_zone_print_fmt(output, ldns_output_format_default, z);
3533
}
3534

3535
Product

Resources

Company
