resolved: rr - print DNSKEY and RRSIG in base64
[thirdparty/systemd.git] / src / resolve / resolved-dns-rr.c
CommitLineData
74b2466e
LP
1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3/***
4 This file is part of systemd.
5
6 Copyright 2014 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
0dae31d4
ZJS
22#include <math.h>
23
2e276efc
ZJS
24#include "strv.h"
25
4ad7f276 26#include "dns-domain.h"
74b2466e 27#include "resolved-dns-rr.h"
8db0d2f5 28#include "resolved-dns-packet.h"
7263f724 29#include "dns-type.h"
74b2466e 30
faa133f3
LP
31DnsResourceKey* dns_resource_key_new(uint16_t class, uint16_t type, const char *name) {
32 DnsResourceKey *k;
33 size_t l;
74b2466e 34
faa133f3
LP
35 assert(name);
36
37 l = strlen(name);
38 k = malloc0(sizeof(DnsResourceKey) + l + 1);
39 if (!k)
40 return NULL;
41
42 k->n_ref = 1;
43 k->class = class;
44 k->type = type;
45
46 strcpy((char*) k + sizeof(DnsResourceKey), name);
47
48 return k;
49}
50
51DnsResourceKey* dns_resource_key_new_consume(uint16_t class, uint16_t type, char *name) {
52 DnsResourceKey *k;
53
54 assert(name);
55
56 k = new0(DnsResourceKey, 1);
57 if (!k)
58 return NULL;
59
60 k->n_ref = 1;
61 k->class = class;
62 k->type = type;
63 k->_name = name;
64
65 return k;
66}
67
68DnsResourceKey* dns_resource_key_ref(DnsResourceKey *k) {
69
70 if (!k)
71 return NULL;
72
73 assert(k->n_ref > 0);
74 k->n_ref++;
75
76 return k;
77}
78
79DnsResourceKey* dns_resource_key_unref(DnsResourceKey *k) {
80 if (!k)
81 return NULL;
82
83 assert(k->n_ref > 0);
84
85 if (k->n_ref == 1) {
86 free(k->_name);
87 free(k);
88 } else
89 k->n_ref--;
90
91 return NULL;
92}
93
94int dns_resource_key_equal(const DnsResourceKey *a, const DnsResourceKey *b) {
95 int r;
96
97 r = dns_name_equal(DNS_RESOURCE_KEY_NAME(a), DNS_RESOURCE_KEY_NAME(b));
98 if (r <= 0)
99 return r;
100
101 if (a->class != b->class)
102 return 0;
103
104 if (a->type != b->type)
105 return 0;
106
107 return 1;
108}
109
110int dns_resource_key_match_rr(const DnsResourceKey *key, const DnsResourceRecord *rr) {
111 assert(key);
112 assert(rr);
113
114 if (rr->key->class != key->class && key->class != DNS_CLASS_ANY)
115 return 0;
116
117 if (rr->key->type != key->type && key->type != DNS_TYPE_ANY)
118 return 0;
119
120 return dns_name_equal(DNS_RESOURCE_KEY_NAME(rr->key), DNS_RESOURCE_KEY_NAME(key));
121}
122
123int dns_resource_key_match_cname(const DnsResourceKey *key, const DnsResourceRecord *rr) {
124 assert(key);
125 assert(rr);
126
127 if (rr->key->class != key->class && key->class != DNS_CLASS_ANY)
128 return 0;
129
130 if (rr->key->type != DNS_TYPE_CNAME)
131 return 0;
132
133 return dns_name_equal(DNS_RESOURCE_KEY_NAME(rr->key), DNS_RESOURCE_KEY_NAME(key));
74b2466e
LP
134}
135
d5099efc 136static unsigned long dns_resource_key_hash_func(const void *i, const uint8_t hash_key[HASH_KEY_SIZE]) {
322345fd
LP
137 const DnsResourceKey *k = i;
138 unsigned long ul;
139
faa133f3 140 ul = dns_name_hash_func(DNS_RESOURCE_KEY_NAME(k), hash_key);
322345fd
LP
141 ul = ul * hash_key[0] + ul + k->class;
142 ul = ul * hash_key[1] + ul + k->type;
143
144 return ul;
145}
146
d5099efc 147static int dns_resource_key_compare_func(const void *a, const void *b) {
322345fd
LP
148 const DnsResourceKey *x = a, *y = b;
149 int ret;
150
faa133f3 151 ret = dns_name_compare_func(DNS_RESOURCE_KEY_NAME(x), DNS_RESOURCE_KEY_NAME(y));
322345fd
LP
152 if (ret != 0)
153 return ret;
154
155 if (x->type < y->type)
156 return -1;
157 if (x->type > y->type)
158 return 1;
159
160 if (x->class < y->class)
161 return -1;
162 if (x->class > y->class)
163 return 1;
164
165 return 0;
166}
167
d5099efc
MS
168const struct hash_ops dns_resource_key_hash_ops = {
169 .hash = dns_resource_key_hash_func,
170 .compare = dns_resource_key_compare_func
171};
172
2d4c5cbc
LP
173int dns_resource_key_to_string(const DnsResourceKey *key, char **ret) {
174 char cbuf[DECIMAL_STR_MAX(uint16_t)], tbuf[DECIMAL_STR_MAX(uint16_t)];
175 const char *c, *t;
176 char *s;
177
178 c = dns_class_to_string(key->class);
179 if (!c) {
180 sprintf(cbuf, "%i", key->class);
181 c = cbuf;
182 }
183
184 t = dns_type_to_string(key->type);
185 if (!t){
186 sprintf(tbuf, "%i", key->type);
187 t = tbuf;
188 }
189
23432a1c 190 if (asprintf(&s, "%s %s %-5s", DNS_RESOURCE_KEY_NAME(key), c, t) < 0)
2d4c5cbc
LP
191 return -ENOMEM;
192
193 *ret = s;
194 return 0;
195}
196
faa133f3 197DnsResourceRecord* dns_resource_record_new(DnsResourceKey *key) {
74b2466e
LP
198 DnsResourceRecord *rr;
199
200 rr = new0(DnsResourceRecord, 1);
201 if (!rr)
202 return NULL;
203
204 rr->n_ref = 1;
faa133f3
LP
205 rr->key = dns_resource_key_ref(key);
206
74b2466e
LP
207 return rr;
208}
209
8bf52d3d
LP
210DnsResourceRecord* dns_resource_record_new_full(uint16_t class, uint16_t type, const char *name) {
211 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
212
213 key = dns_resource_key_new(class, type, name);
214 if (!key)
215 return NULL;
216
217 return dns_resource_record_new(key);
218}
219
74b2466e
LP
220DnsResourceRecord* dns_resource_record_ref(DnsResourceRecord *rr) {
221 if (!rr)
222 return NULL;
223
224 assert(rr->n_ref > 0);
225 rr->n_ref++;
226
227 return rr;
228}
229
230DnsResourceRecord* dns_resource_record_unref(DnsResourceRecord *rr) {
231 if (!rr)
232 return NULL;
233
234 assert(rr->n_ref > 0);
235
236 if (rr->n_ref > 1) {
237 rr->n_ref--;
238 return NULL;
239 }
240
faa133f3 241 if (rr->key) {
9de3e329 242 switch(rr->key->type) {
9c92ce6d
LP
243
244 case DNS_TYPE_SRV:
245 free(rr->srv.name);
246 break;
247
9de3e329
ZJS
248 case DNS_TYPE_PTR:
249 case DNS_TYPE_NS:
250 case DNS_TYPE_CNAME:
8ac4e9e1 251 case DNS_TYPE_DNAME:
faa133f3 252 free(rr->ptr.name);
9de3e329 253 break;
9c92ce6d 254
9de3e329 255 case DNS_TYPE_HINFO:
faa133f3
LP
256 free(rr->hinfo.cpu);
257 free(rr->hinfo.os);
9de3e329 258 break;
9c92ce6d 259
9de3e329 260 case DNS_TYPE_TXT:
9c92ce6d 261 case DNS_TYPE_SPF:
2e276efc 262 strv_free(rr->txt.strings);
9de3e329 263 break;
9c92ce6d 264
9de3e329 265 case DNS_TYPE_SOA:
7e8e0422
LP
266 free(rr->soa.mname);
267 free(rr->soa.rname);
9de3e329 268 break;
9c92ce6d 269
9de3e329 270 case DNS_TYPE_MX:
946c7094 271 free(rr->mx.exchange);
9de3e329 272 break;
9c92ce6d 273
42cc2eeb
LP
274 case DNS_TYPE_SSHFP:
275 free(rr->sshfp.key);
276 break;
277
8db0d2f5
ZJS
278 case DNS_TYPE_DNSKEY:
279 free(rr->dnskey.key);
280 break;
281
151226ab
ZJS
282 case DNS_TYPE_RRSIG:
283 free(rr->rrsig.signer);
284 free(rr->rrsig.signature);
285 break;
286
0dae31d4 287 case DNS_TYPE_LOC:
9de3e329
ZJS
288 case DNS_TYPE_A:
289 case DNS_TYPE_AAAA:
290 break;
9c92ce6d 291
9de3e329 292 default:
faa133f3 293 free(rr->generic.data);
9de3e329 294 }
322345fd 295
faa133f3
LP
296 dns_resource_key_unref(rr->key);
297 }
322345fd 298
faa133f3 299 free(rr);
322345fd 300
322345fd
LP
301 return NULL;
302}
303
623a4c97
LP
304int dns_resource_record_new_reverse(DnsResourceRecord **ret, int family, const union in_addr_union *address, const char *hostname) {
305 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
306 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
307 _cleanup_free_ char *ptr = NULL;
308 int r;
309
310 assert(ret);
311 assert(address);
312 assert(hostname);
313
314 r = dns_name_reverse(family, address, &ptr);
315 if (r < 0)
316 return r;
317
318 key = dns_resource_key_new_consume(DNS_CLASS_IN, DNS_TYPE_PTR, ptr);
319 if (!key)
320 return -ENOMEM;
321
322 ptr = NULL;
323
324 rr = dns_resource_record_new(key);
325 if (!rr)
326 return -ENOMEM;
327
328 rr->ptr.name = strdup(hostname);
329 if (!rr->ptr.name)
330 return -ENOMEM;
331
332 *ret = rr;
333 rr = NULL;
334
335 return 0;
336}
337
322345fd
LP
338int dns_resource_record_equal(const DnsResourceRecord *a, const DnsResourceRecord *b) {
339 int r;
340
341 assert(a);
342 assert(b);
343
faa133f3 344 r = dns_resource_key_equal(a->key, b->key);
322345fd
LP
345 if (r <= 0)
346 return r;
347
fd0b4602
LP
348 if (a->unparseable != b->unparseable)
349 return 0;
350
351 switch (a->unparseable ? _DNS_TYPE_INVALID : a->key->type) {
2d4c5cbc 352
9c92ce6d
LP
353 case DNS_TYPE_SRV:
354 r = dns_name_equal(a->srv.name, b->srv.name);
355 if (r <= 0)
356 return r;
357
358 return a->srv.priority == b->srv.priority &&
359 a->srv.weight == b->srv.weight &&
360 a->srv.port == b->srv.port;
361
2d4c5cbc
LP
362 case DNS_TYPE_PTR:
363 case DNS_TYPE_NS:
364 case DNS_TYPE_CNAME:
8ac4e9e1 365 case DNS_TYPE_DNAME:
322345fd 366 return dns_name_equal(a->ptr.name, b->ptr.name);
2d4c5cbc
LP
367
368 case DNS_TYPE_HINFO:
369 return strcaseeq(a->hinfo.cpu, b->hinfo.cpu) &&
370 strcaseeq(a->hinfo.os, b->hinfo.os);
371
9de3e329 372 case DNS_TYPE_SPF: /* exactly the same as TXT */
0f84a72e
DH
373 case DNS_TYPE_TXT:
374 return strv_equal(a->txt.strings, b->txt.strings);
2e276efc 375
2d4c5cbc 376 case DNS_TYPE_A:
322345fd 377 return memcmp(&a->a.in_addr, &b->a.in_addr, sizeof(struct in_addr)) == 0;
2d4c5cbc
LP
378
379 case DNS_TYPE_AAAA:
322345fd 380 return memcmp(&a->aaaa.in6_addr, &b->aaaa.in6_addr, sizeof(struct in6_addr)) == 0;
2d4c5cbc
LP
381
382 case DNS_TYPE_SOA:
7e8e0422
LP
383 r = dns_name_equal(a->soa.mname, b->soa.mname);
384 if (r <= 0)
385 return r;
386 r = dns_name_equal(a->soa.rname, b->soa.rname);
387 if (r <= 0)
388 return r;
389
390 return a->soa.serial == b->soa.serial &&
391 a->soa.refresh == b->soa.refresh &&
392 a->soa.retry == b->soa.retry &&
393 a->soa.expire == b->soa.expire &&
394 a->soa.minimum == b->soa.minimum;
9c92ce6d 395
946c7094
ZJS
396 case DNS_TYPE_MX:
397 if (a->mx.priority != b->mx.priority)
398 return 0;
399
400 return dns_name_equal(a->mx.exchange, b->mx.exchange);
401
0dae31d4
ZJS
402 case DNS_TYPE_LOC:
403 assert(a->loc.version == b->loc.version);
404
405 return a->loc.size == b->loc.size &&
406 a->loc.horiz_pre == b->loc.horiz_pre &&
407 a->loc.vert_pre == b->loc.vert_pre &&
408 a->loc.latitude == b->loc.latitude &&
409 a->loc.longitude == b->loc.longitude &&
410 a->loc.altitude == b->loc.altitude;
411
42cc2eeb
LP
412 case DNS_TYPE_SSHFP:
413 return a->sshfp.algorithm == b->sshfp.algorithm &&
414 a->sshfp.fptype == b->sshfp.fptype &&
415 a->sshfp.key_size == b->sshfp.key_size &&
416 memcmp(a->sshfp.key, b->sshfp.key, a->sshfp.key_size) == 0;
417
8db0d2f5
ZJS
418 case DNS_TYPE_DNSKEY:
419 return a->dnskey.zone_key_flag == b->dnskey.zone_key_flag &&
420 a->dnskey.sep_flag == b->dnskey.sep_flag &&
421 a->dnskey.algorithm == b->dnskey.algorithm &&
422 a->dnskey.key_size == b->dnskey.key_size &&
423 memcmp(a->dnskey.key, b->dnskey.key, a->dnskey.key_size) == 0;
424
151226ab
ZJS
425 case DNS_TYPE_RRSIG:
426 /* do the fast comparisons first */
03664a62
LN
427 if (a->rrsig.type_covered != b->rrsig.type_covered ||
428 a->rrsig.algorithm != b->rrsig.algorithm ||
429 a->rrsig.labels != b->rrsig.labels ||
430 a->rrsig.original_ttl != b->rrsig.original_ttl ||
431 a->rrsig.expiration != b->rrsig.expiration ||
432 a->rrsig.inception != b->rrsig.inception ||
433 a->rrsig.key_tag != b->rrsig.key_tag ||
151226ab
ZJS
434 a->rrsig.signature_size != b->rrsig.signature_size ||
435 memcmp(a->rrsig.signature, b->rrsig.signature, a->rrsig.signature_size) != 0)
436 return false;
437
438 return dns_name_equal(a->rrsig.signer, b->rrsig.signer);
439
2d4c5cbc 440 default:
322345fd
LP
441 return a->generic.size == b->generic.size &&
442 memcmp(a->generic.data, b->generic.data, a->generic.size) == 0;
2d4c5cbc 443 }
322345fd
LP
444}
445
0dae31d4
ZJS
446static char* format_location(uint32_t latitude, uint32_t longitude, uint32_t altitude,
447 uint8_t size, uint8_t horiz_pre, uint8_t vert_pre) {
448 char *s;
449 char NS = latitude >= 1U<<31 ? 'N' : 'S';
450 char EW = longitude >= 1U<<31 ? 'E' : 'W';
451
452 int lat = latitude >= 1U<<31 ? (int) (latitude - (1U<<31)) : (int) ((1U<<31) - latitude);
453 int lon = longitude >= 1U<<31 ? (int) (longitude - (1U<<31)) : (int) ((1U<<31) - longitude);
454 double alt = altitude >= 10000000u ? altitude - 10000000u : -(double)(10000000u - altitude);
455 double siz = (size >> 4) * exp10((double) (size & 0xF));
456 double hor = (horiz_pre >> 4) * exp10((double) (horiz_pre & 0xF));
457 double ver = (vert_pre >> 4) * exp10((double) (vert_pre & 0xF));
458
459 if (asprintf(&s, "%d %d %.3f %c %d %d %.3f %c %.2fm %.2fm %.2fm %.2fm",
460 (lat / 60000 / 60),
461 (lat / 60000) % 60,
462 (lat % 60000) / 1000.,
463 NS,
464 (lon / 60000 / 60),
465 (lon / 60000) % 60,
466 (lon % 60000) / 1000.,
467 EW,
468 alt / 100.,
469 siz / 100.,
470 hor / 100.,
471 ver / 100.) < 0)
472 return NULL;
473
474 return s;
475}
476
2d4c5cbc 477int dns_resource_record_to_string(const DnsResourceRecord *rr, char **ret) {
8db0d2f5 478 _cleanup_free_ char *k = NULL, *t = NULL;
2d4c5cbc
LP
479 char *s;
480 int r;
322345fd 481
2d4c5cbc 482 assert(rr);
322345fd 483
2d4c5cbc
LP
484 r = dns_resource_key_to_string(rr->key, &k);
485 if (r < 0)
486 return r;
322345fd 487
0dae31d4 488 switch (rr->unparseable ? _DNS_TYPE_INVALID : rr->key->type) {
322345fd 489
9c92ce6d
LP
490 case DNS_TYPE_SRV:
491 r = asprintf(&s, "%s %u %u %u %s",
492 k,
493 rr->srv.priority,
494 rr->srv.weight,
495 rr->srv.port,
496 strna(rr->srv.name));
497 if (r < 0)
498 return -ENOMEM;
499 break;
500
2d4c5cbc
LP
501 case DNS_TYPE_PTR:
502 case DNS_TYPE_NS:
503 case DNS_TYPE_CNAME:
8ac4e9e1 504 case DNS_TYPE_DNAME:
2d4c5cbc
LP
505 s = strjoin(k, " ", rr->ptr.name, NULL);
506 if (!s)
507 return -ENOMEM;
322345fd 508
2d4c5cbc 509 break;
322345fd 510
2d4c5cbc
LP
511 case DNS_TYPE_HINFO:
512 s = strjoin(k, " ", rr->hinfo.cpu, " ", rr->hinfo.os, NULL);
513 if (!s)
514 return -ENOMEM;
515 break;
322345fd 516
9de3e329 517 case DNS_TYPE_SPF: /* exactly the same as TXT */
8db0d2f5 518 case DNS_TYPE_TXT:
2e276efc
ZJS
519 t = strv_join_quoted(rr->txt.strings);
520 if (!t)
521 return -ENOMEM;
522
523 s = strjoin(k, " ", t, NULL);
524 if (!s)
525 return -ENOMEM;
526
527 break;
2e276efc 528
2d4c5cbc
LP
529 case DNS_TYPE_A: {
530 _cleanup_free_ char *x = NULL;
322345fd 531
2d4c5cbc
LP
532 r = in_addr_to_string(AF_INET, (const union in_addr_union*) &rr->a.in_addr, &x);
533 if (r < 0)
534 return r;
322345fd 535
2d4c5cbc
LP
536 s = strjoin(k, " ", x, NULL);
537 if (!s)
538 return -ENOMEM;
539 break;
540 }
322345fd 541
8db0d2f5
ZJS
542 case DNS_TYPE_AAAA:
543 r = in_addr_to_string(AF_INET6, (const union in_addr_union*) &rr->aaaa.in6_addr, &t);
2d4c5cbc
LP
544 if (r < 0)
545 return r;
322345fd 546
8db0d2f5 547 s = strjoin(k, " ", t, NULL);
2d4c5cbc
LP
548 if (!s)
549 return -ENOMEM;
550 break;
322345fd 551
2d4c5cbc
LP
552 case DNS_TYPE_SOA:
553 r = asprintf(&s, "%s %s %s %u %u %u %u %u",
554 k,
555 strna(rr->soa.mname),
556 strna(rr->soa.rname),
557 rr->soa.serial,
558 rr->soa.refresh,
559 rr->soa.retry,
560 rr->soa.expire,
561 rr->soa.minimum);
562 if (r < 0)
563 return -ENOMEM;
564 break;
565
946c7094
ZJS
566 case DNS_TYPE_MX:
567 r = asprintf(&s, "%s %u %s",
568 k,
569 rr->mx.priority,
570 rr->mx.exchange);
571 if (r < 0)
572 return -ENOMEM;
573 break;
574
8db0d2f5 575 case DNS_TYPE_LOC:
0dae31d4
ZJS
576 assert(rr->loc.version == 0);
577
8db0d2f5
ZJS
578 t = format_location(rr->loc.latitude,
579 rr->loc.longitude,
580 rr->loc.altitude,
581 rr->loc.size,
582 rr->loc.horiz_pre,
583 rr->loc.vert_pre);
584 if (!t)
0dae31d4
ZJS
585 return -ENOMEM;
586
8db0d2f5 587 s = strjoin(k, " ", t, NULL);
0dae31d4
ZJS
588 if (!s)
589 return -ENOMEM;
0dae31d4 590 break;
0dae31d4 591
8db0d2f5
ZJS
592 case DNS_TYPE_SSHFP:
593 t = hexmem(rr->sshfp.key, rr->sshfp.key_size);
594 if (!t)
42cc2eeb
LP
595 return -ENOMEM;
596
597 r = asprintf(&s, "%s %u %u %s",
598 k,
599 rr->sshfp.algorithm,
600 rr->sshfp.fptype,
8db0d2f5 601 t);
42cc2eeb
LP
602 if (r < 0)
603 return -ENOMEM;
604 break;
42cc2eeb 605
ff3d6560
ZJS
606 case DNS_TYPE_DNSKEY: {
607 const char *alg;
608
609 alg = dnssec_algorithm_to_string(rr->dnskey.algorithm);
610
1bf968f3 611 t = base64mem(rr->dnskey.key, rr->dnskey.key_size);
8db0d2f5
ZJS
612 if (!t)
613 return -ENOMEM;
2d4c5cbc 614
ff3d6560 615 r = asprintf(&s, "%s %u 3 %.*s%.*u %s",
8db0d2f5
ZJS
616 k,
617 dnskey_to_flags(rr),
ff3d6560
ZJS
618 alg ? -1 : 0, alg,
619 alg ? 0 : 1, alg ? 0u : (unsigned) rr->dnskey.algorithm,
8db0d2f5
ZJS
620 t);
621 if (r < 0)
2d4c5cbc 622 return -ENOMEM;
8db0d2f5 623 break;
ff3d6560 624 }
2d4c5cbc 625
151226ab
ZJS
626 case DNS_TYPE_RRSIG: {
627 const char *type, *alg;
628
629 type = dns_type_to_string(rr->rrsig.type_covered);
630 alg = dnssec_algorithm_to_string(rr->rrsig.algorithm);
631
1bf968f3 632 t = base64mem(rr->rrsig.signature, rr->rrsig.signature_size);
151226ab
ZJS
633 if (!t)
634 return -ENOMEM;
635
636 /* TYPE?? follows
637 * http://tools.ietf.org/html/rfc3597#section-5 */
638
639 r = asprintf(&s, "%s %s%.*u %.*s%.*u %u %u %u %u %u %s %s",
640 k,
641 type ?: "TYPE",
642 type ? 0 : 1, type ? 0u : (unsigned) rr->rrsig.type_covered,
643 alg ? -1 : 0, alg,
644 alg ? 0 : 1, alg ? 0u : (unsigned) rr->rrsig.algorithm,
645 rr->rrsig.labels,
646 rr->rrsig.original_ttl,
647 rr->rrsig.expiration,
648 rr->rrsig.inception,
649 rr->rrsig.key_tag,
650 rr->rrsig.signer,
651 t);
652 if (r < 0)
653 return -ENOMEM;
654 break;
655 }
656
8db0d2f5
ZJS
657 default:
658 t = hexmem(rr->generic.data, rr->generic.size);
659 if (!t)
660 return -ENOMEM;
661
662 s = strjoin(k, " ", t, NULL);
2d4c5cbc
LP
663 if (!s)
664 return -ENOMEM;
665 break;
8db0d2f5 666 }
2d4c5cbc
LP
667
668 *ret = s;
669 return 0;
670}
322345fd 671
2d4c5cbc 672const char *dns_class_to_string(uint16_t class) {
322345fd 673
2d4c5cbc 674 switch (class) {
322345fd 675
2d4c5cbc
LP
676 case DNS_CLASS_IN:
677 return "IN";
322345fd 678
2d4c5cbc
LP
679 case DNS_CLASS_ANY:
680 return "ANY";
681 }
322345fd 682
2d4c5cbc
LP
683 return NULL;
684}
322345fd 685
2d4c5cbc
LP
686int dns_class_from_string(const char *s, uint16_t *class) {
687 assert(s);
688 assert(class);
689
690 if (strcaseeq(s, "IN"))
691 *class = DNS_CLASS_IN;
692 else if (strcaseeq(s, "ANY"))
693 *class = DNS_TYPE_ANY;
694 else
695 return -EINVAL;
322345fd 696
2d4c5cbc
LP
697 return 0;
698}