src/resolve/resolved-dns-rr.c

   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
  22 #include <math.h>
  23
  24 #include "strv.h"
  25
  26 #include "dns-domain.h"
  27 #include "resolved-dns-rr.h"
  28 #include "resolved-dns-packet.h"
  29 #include "dns-type.h"
  30
  31 DnsResourceKey* dns_resource_key_new(uint16_t class, uint16_t type, const char *name) {
  32         DnsResourceKey *k;
  33         size_t l;
  34
  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
  51 DnsResourceKey* 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
  68 DnsResourceKey* 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
  79 DnsResourceKey* 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
  94 int 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
 110 int 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
 123 int 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));
 134 }
 135
 136 static unsigned long dns_resource_key_hash_func(const void *i, const uint8_t hash_key[HASH_KEY_SIZE]) {
 137         const DnsResourceKey *k = i;
 138         unsigned long ul;
 139
 140         ul = dns_name_hash_func(DNS_RESOURCE_KEY_NAME(k), hash_key);
 141         ul = ul * hash_key[0] + ul + k->class;
 142         ul = ul * hash_key[1] + ul + k->type;
 143
 144         return ul;
 145 }
 146
 147 static int dns_resource_key_compare_func(const void *a, const void *b) {
 148         const DnsResourceKey *x = a, *y = b;
 149         int ret;
 150
 151         ret = dns_name_compare_func(DNS_RESOURCE_KEY_NAME(x), DNS_RESOURCE_KEY_NAME(y));
 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
 168 const struct hash_ops dns_resource_key_hash_ops = {
 169         .hash = dns_resource_key_hash_func,
 170         .compare = dns_resource_key_compare_func
 171 };
 172
 173 int dns_resource_key_to_string(const DnsResourceKey *key, char **ret) {
 174         char cbuf[strlen("CLASS") + DECIMAL_STR_MAX(uint16_t)], tbuf[strlen("TYPE") + 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, "CLASS%u", key->class);
 181                 c = cbuf;
 182         }
 183
 184         t = dns_type_to_string(key->type);
 185         if (!t){
 186                 sprintf(tbuf, "TYPE%u", key->type);
 187                 t = tbuf;
 188         }
 189
 190         if (asprintf(&s, "%s %s %-5s", DNS_RESOURCE_KEY_NAME(key), c, t) < 0)
 191                 return -ENOMEM;
 192
 193         *ret = s;
 194         return 0;
 195 }
 196
 197 DnsResourceRecord* dns_resource_record_new(DnsResourceKey *key) {
 198         DnsResourceRecord *rr;
 199
 200         rr = new0(DnsResourceRecord, 1);
 201         if (!rr)
 202                 return NULL;
 203
 204         rr->n_ref = 1;
 205         rr->key = dns_resource_key_ref(key);
 206
 207         return rr;
 208 }
 209
 210 DnsResourceRecord* 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
 220 DnsResourceRecord* 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
 230 DnsResourceRecord* 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
 241         if (rr->key) {
 242                 switch(rr->key->type) {
 243
 244                 case DNS_TYPE_SRV:
 245                         free(rr->srv.name);
 246                         break;
 247
 248                 case DNS_TYPE_PTR:
 249                 case DNS_TYPE_NS:
 250                 case DNS_TYPE_CNAME:
 251                 case DNS_TYPE_DNAME:
 252                         free(rr->ptr.name);
 253                         break;
 254
 255                 case DNS_TYPE_HINFO:
 256                         free(rr->hinfo.cpu);
 257                         free(rr->hinfo.os);
 258                         break;
 259
 260                 case DNS_TYPE_TXT:
 261                 case DNS_TYPE_SPF:
 262                         strv_free(rr->txt.strings);
 263                         break;
 264
 265                 case DNS_TYPE_SOA:
 266                         free(rr->soa.mname);
 267                         free(rr->soa.rname);
 268                         break;
 269
 270                 case DNS_TYPE_MX:
 271                         free(rr->mx.exchange);
 272                         break;
 273
 274                 case DNS_TYPE_DS:
 275                         free(rr->ds.digest);
 276                         break;
 277
 278                 case DNS_TYPE_SSHFP:
 279                         free(rr->sshfp.fingerprint);
 280                         break;
 281
 282                 case DNS_TYPE_DNSKEY:
 283                         free(rr->dnskey.key);
 284                         break;
 285
 286                 case DNS_TYPE_RRSIG:
 287                         free(rr->rrsig.signer);
 288                         free(rr->rrsig.signature);
 289                         break;
 290
 291                 case DNS_TYPE_NSEC:
 292                         free(rr->nsec.next_domain_name);
 293                         bitmap_free(rr->nsec.types);
 294                         break;
 295
 296                 case DNS_TYPE_NSEC3:
 297                         free(rr->nsec3.next_hashed_name);
 298                         free(rr->nsec3.salt);
 299                         bitmap_free(rr->nsec3.types);
 300                         break;
 301
 302                 case DNS_TYPE_LOC:
 303                 case DNS_TYPE_A:
 304                 case DNS_TYPE_AAAA:
 305                         break;
 306
 307                 default:
 308                         free(rr->generic.data);
 309                 }
 310
 311                 dns_resource_key_unref(rr->key);
 312         }
 313
 314         free(rr);
 315
 316         return NULL;
 317 }
 318
 319 int dns_resource_record_new_reverse(DnsResourceRecord **ret, int family, const union in_addr_union *address, const char *hostname) {
 320         _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
 321         _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
 322         _cleanup_free_ char *ptr = NULL;
 323         int r;
 324
 325         assert(ret);
 326         assert(address);
 327         assert(hostname);
 328
 329         r = dns_name_reverse(family, address, &ptr);
 330         if (r < 0)
 331                 return r;
 332
 333         key = dns_resource_key_new_consume(DNS_CLASS_IN, DNS_TYPE_PTR, ptr);
 334         if (!key)
 335                 return -ENOMEM;
 336
 337         ptr = NULL;
 338
 339         rr = dns_resource_record_new(key);
 340         if (!rr)
 341                 return -ENOMEM;
 342
 343         rr->ptr.name = strdup(hostname);
 344         if (!rr->ptr.name)
 345                 return -ENOMEM;
 346
 347         *ret = rr;
 348         rr = NULL;
 349
 350         return 0;
 351 }
 352
 353 int dns_resource_record_new_address(DnsResourceRecord **ret, int family, const union in_addr_union *address, const char *name) {
 354         DnsResourceRecord *rr;
 355
 356         assert(ret);
 357         assert(address);
 358         assert(family);
 359
 360         if (family == AF_INET) {
 361
 362                 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, name);
 363                 if (!rr)
 364                         return -ENOMEM;
 365
 366                 rr->a.in_addr = address->in;
 367
 368         } else if (family == AF_INET6) {
 369
 370                 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_AAAA, name);
 371                 if (!rr)
 372                         return -ENOMEM;
 373
 374                 rr->aaaa.in6_addr = address->in6;
 375         } else
 376                 return -EAFNOSUPPORT;
 377
 378         *ret = rr;
 379
 380         return 0;
 381 }
 382
 383 int dns_resource_record_equal(const DnsResourceRecord *a, const DnsResourceRecord *b) {
 384         int r;
 385
 386         assert(a);
 387         assert(b);
 388
 389         r = dns_resource_key_equal(a->key, b->key);
 390         if (r <= 0)
 391                 return r;
 392
 393         if (a->unparseable != b->unparseable)
 394                 return 0;
 395
 396         switch (a->unparseable ? _DNS_TYPE_INVALID : a->key->type) {
 397
 398         case DNS_TYPE_SRV:
 399                 r = dns_name_equal(a->srv.name, b->srv.name);
 400                 if (r <= 0)
 401                         return r;
 402
 403                 return a->srv.priority == b->srv.priority &&
 404                        a->srv.weight == b->srv.weight &&
 405                        a->srv.port == b->srv.port;
 406
 407         case DNS_TYPE_PTR:
 408         case DNS_TYPE_NS:
 409         case DNS_TYPE_CNAME:
 410         case DNS_TYPE_DNAME:
 411                 return dns_name_equal(a->ptr.name, b->ptr.name);
 412
 413         case DNS_TYPE_HINFO:
 414                 return strcaseeq(a->hinfo.cpu, b->hinfo.cpu) &&
 415                        strcaseeq(a->hinfo.os, b->hinfo.os);
 416
 417         case DNS_TYPE_SPF: /* exactly the same as TXT */
 418         case DNS_TYPE_TXT:
 419                 return strv_equal(a->txt.strings, b->txt.strings);
 420
 421         case DNS_TYPE_A:
 422                 return memcmp(&a->a.in_addr, &b->a.in_addr, sizeof(struct in_addr)) == 0;
 423
 424         case DNS_TYPE_AAAA:
 425                 return memcmp(&a->aaaa.in6_addr, &b->aaaa.in6_addr, sizeof(struct in6_addr)) == 0;
 426
 427         case DNS_TYPE_SOA:
 428                 r = dns_name_equal(a->soa.mname, b->soa.mname);
 429                 if (r <= 0)
 430                         return r;
 431                 r = dns_name_equal(a->soa.rname, b->soa.rname);
 432                 if (r <= 0)
 433                         return r;
 434
 435                 return a->soa.serial  == b->soa.serial &&
 436                        a->soa.refresh == b->soa.refresh &&
 437                        a->soa.retry   == b->soa.retry &&
 438                        a->soa.expire  == b->soa.expire &&
 439                        a->soa.minimum == b->soa.minimum;
 440
 441         case DNS_TYPE_MX:
 442                 if (a->mx.priority != b->mx.priority)
 443                         return 0;
 444
 445                 return dns_name_equal(a->mx.exchange, b->mx.exchange);
 446
 447         case DNS_TYPE_LOC:
 448                 assert(a->loc.version == b->loc.version);
 449
 450                 return a->loc.size == b->loc.size &&
 451                        a->loc.horiz_pre == b->loc.horiz_pre &&
 452                        a->loc.vert_pre == b->loc.vert_pre &&
 453                        a->loc.latitude == b->loc.latitude &&
 454                        a->loc.longitude == b->loc.longitude &&
 455                        a->loc.altitude == b->loc.altitude;
 456
 457         case DNS_TYPE_DS:
 458                 return a->ds.key_tag == b->ds.key_tag &&
 459                        a->ds.algorithm == b->ds.algorithm &&
 460                        a->ds.digest_type == b->ds.digest_type &&
 461                        a->ds.digest_size == b->ds.digest_size &&
 462                        memcmp(a->ds.digest, b->ds.digest, a->ds.digest_size) == 0;
 463
 464         case DNS_TYPE_SSHFP:
 465                 return a->sshfp.algorithm == b->sshfp.algorithm &&
 466                        a->sshfp.fptype == b->sshfp.fptype &&
 467                        a->sshfp.fingerprint_size == b->sshfp.fingerprint_size &&
 468                        memcmp(a->sshfp.fingerprint, b->sshfp.fingerprint, a->sshfp.fingerprint_size) == 0;
 469
 470         case DNS_TYPE_DNSKEY:
 471                 return a->dnskey.zone_key_flag == b->dnskey.zone_key_flag &&
 472                        a->dnskey.sep_flag == b->dnskey.sep_flag &&
 473                        a->dnskey.algorithm == b->dnskey.algorithm &&
 474                        a->dnskey.key_size == b->dnskey.key_size &&
 475                        memcmp(a->dnskey.key, b->dnskey.key, a->dnskey.key_size) == 0;
 476
 477         case DNS_TYPE_RRSIG:
 478                 /* do the fast comparisons first */
 479                 if (a->rrsig.type_covered != b->rrsig.type_covered ||
 480                     a->rrsig.algorithm != b->rrsig.algorithm ||
 481                     a->rrsig.labels != b->rrsig.labels ||
 482                     a->rrsig.original_ttl != b->rrsig.original_ttl ||
 483                     a->rrsig.expiration != b->rrsig.expiration ||
 484                     a->rrsig.inception != b->rrsig.inception ||
 485                     a->rrsig.key_tag != b->rrsig.key_tag ||
 486                     a->rrsig.signature_size != b->rrsig.signature_size ||
 487                     memcmp(a->rrsig.signature, b->rrsig.signature, a->rrsig.signature_size) != 0)
 488                         return false;
 489
 490                 return dns_name_equal(a->rrsig.signer, b->rrsig.signer);
 491
 492         case DNS_TYPE_NSEC:
 493                 return dns_name_equal(a->nsec.next_domain_name, b->nsec.next_domain_name) &&
 494                        bitmap_equal(a->nsec.types, b->nsec.types);
 495
 496         case DNS_TYPE_NSEC3:
 497                 return a->nsec3.algorithm == b->nsec3.algorithm &&
 498                     a->nsec3.flags == b->nsec3.flags &&
 499                     a->nsec3.iterations == b->nsec3.iterations &&
 500                     a->nsec3.salt_size == b->nsec3.salt_size &&
 501                     memcmp(a->nsec3.salt, b->nsec3.salt, a->nsec3.salt_size) == 0 &&
 502                     memcmp(a->nsec3.next_hashed_name, b->nsec3.next_hashed_name, a->nsec3.next_hashed_name_size) == 0 &&
 503                     bitmap_equal(a->nsec3.types, b->nsec3.types);
 504
 505         default:
 506                 return a->generic.size == b->generic.size &&
 507                         memcmp(a->generic.data, b->generic.data, a->generic.size) == 0;
 508         }
 509 }
 510
 511 static char* format_location(uint32_t latitude, uint32_t longitude, uint32_t altitude,
 512                              uint8_t size, uint8_t horiz_pre, uint8_t vert_pre) {
 513         char *s;
 514         char NS = latitude >= 1U<<31 ? 'N' : 'S';
 515         char EW = longitude >= 1U<<31 ? 'E' : 'W';
 516
 517         int lat = latitude >= 1U<<31 ? (int) (latitude - (1U<<31)) : (int) ((1U<<31) - latitude);
 518         int lon = longitude >= 1U<<31 ? (int) (longitude - (1U<<31)) : (int) ((1U<<31) - longitude);
 519         double alt = altitude >= 10000000u ? altitude - 10000000u : -(double)(10000000u - altitude);
 520         double siz = (size >> 4) * exp10((double) (size & 0xF));
 521         double hor = (horiz_pre >> 4) * exp10((double) (horiz_pre & 0xF));
 522         double ver = (vert_pre >> 4) * exp10((double) (vert_pre & 0xF));
 523
 524         if (asprintf(&s, "%d %d %.3f %c %d %d %.3f %c %.2fm %.2fm %.2fm %.2fm",
 525                      (lat / 60000 / 60),
 526                      (lat / 60000) % 60,
 527                      (lat % 60000) / 1000.,
 528                      NS,
 529                      (lon / 60000 / 60),
 530                      (lon / 60000) % 60,
 531                      (lon % 60000) / 1000.,
 532                      EW,
 533                      alt / 100.,
 534                      siz / 100.,
 535                      hor / 100.,
 536                      ver / 100.) < 0)
 537                 return NULL;
 538
 539         return s;
 540 }
 541
 542 static int format_timestamp_dns(char *buf, size_t l, time_t sec) {
 543         struct tm tm;
 544
 545         assert(buf);
 546         assert(l > strlen("YYYYMMDDHHmmSS"));
 547
 548         if (!gmtime_r(&sec, &tm))
 549                 return -EINVAL;
 550
 551         if (strftime(buf, l, "%Y%m%d%H%M%S", &tm) <= 0)
 552                 return -EINVAL;
 553
 554         return 0;
 555 }
 556
 557 static char *format_types(Bitmap *types) {
 558         _cleanup_strv_free_ char **strv = NULL;
 559         _cleanup_free_ char *str = NULL;
 560         Iterator i;
 561         unsigned type;
 562         int r;
 563
 564         BITMAP_FOREACH(type, types, i) {
 565                 if (dns_type_to_string(type)) {
 566                         r = strv_extend(&strv, dns_type_to_string(type));
 567                         if (r < 0)
 568                                 return NULL;
 569                 } else {
 570                         char *t;
 571
 572                         r = asprintf(&t, "TYPE%u", type);
 573                         if (r < 0)
 574                                 return NULL;
 575
 576                         r = strv_consume(&strv, t);
 577                         if (r < 0)
 578                                 return NULL;
 579                 }
 580         }
 581
 582         str = strv_join(strv, " ");
 583         if (!str)
 584                 return NULL;
 585
 586         return strjoin("( ", str, " )", NULL);
 587 }
 588
 589 int dns_resource_record_to_string(const DnsResourceRecord *rr, char **ret) {
 590         _cleanup_free_ char *k = NULL, *t = NULL;
 591         char *s;
 592         int r;
 593
 594         assert(rr);
 595
 596         r = dns_resource_key_to_string(rr->key, &k);
 597         if (r < 0)
 598                 return r;
 599
 600         switch (rr->unparseable ? _DNS_TYPE_INVALID : rr->key->type) {
 601
 602         case DNS_TYPE_SRV:
 603                 r = asprintf(&s, "%s %u %u %u %s",
 604                              k,
 605                              rr->srv.priority,
 606                              rr->srv.weight,
 607                              rr->srv.port,
 608                              strna(rr->srv.name));
 609                 if (r < 0)
 610                         return -ENOMEM;
 611                 break;
 612
 613         case DNS_TYPE_PTR:
 614         case DNS_TYPE_NS:
 615         case DNS_TYPE_CNAME:
 616         case DNS_TYPE_DNAME:
 617                 s = strjoin(k, " ", rr->ptr.name, NULL);
 618                 if (!s)
 619                         return -ENOMEM;
 620
 621                 break;
 622
 623         case DNS_TYPE_HINFO:
 624                 s = strjoin(k, " ", rr->hinfo.cpu, " ", rr->hinfo.os, NULL);
 625                 if (!s)
 626                         return -ENOMEM;
 627                 break;
 628
 629         case DNS_TYPE_SPF: /* exactly the same as TXT */
 630         case DNS_TYPE_TXT:
 631                 t = strv_join_quoted(rr->txt.strings);
 632                 if (!t)
 633                         return -ENOMEM;
 634
 635                 s = strjoin(k, " ", t, NULL);
 636                 if (!s)
 637                         return -ENOMEM;
 638
 639                 break;
 640
 641         case DNS_TYPE_A: {
 642                 _cleanup_free_ char *x = NULL;
 643
 644                 r = in_addr_to_string(AF_INET, (const union in_addr_union*) &rr->a.in_addr, &x);
 645                 if (r < 0)
 646                         return r;
 647
 648                 s = strjoin(k, " ", x, NULL);
 649                 if (!s)
 650                         return -ENOMEM;
 651                 break;
 652         }
 653
 654         case DNS_TYPE_AAAA:
 655                 r = in_addr_to_string(AF_INET6, (const union in_addr_union*) &rr->aaaa.in6_addr, &t);
 656                 if (r < 0)
 657                         return r;
 658
 659                 s = strjoin(k, " ", t, NULL);
 660                 if (!s)
 661                         return -ENOMEM;
 662                 break;
 663
 664         case DNS_TYPE_SOA:
 665                 r = asprintf(&s, "%s %s %s %u %u %u %u %u",
 666                              k,
 667                              strna(rr->soa.mname),
 668                              strna(rr->soa.rname),
 669                              rr->soa.serial,
 670                              rr->soa.refresh,
 671                              rr->soa.retry,
 672                              rr->soa.expire,
 673                              rr->soa.minimum);
 674                 if (r < 0)
 675                         return -ENOMEM;
 676                 break;
 677
 678         case DNS_TYPE_MX:
 679                 r = asprintf(&s, "%s %u %s",
 680                              k,
 681                              rr->mx.priority,
 682                              rr->mx.exchange);
 683                 if (r < 0)
 684                         return -ENOMEM;
 685                 break;
 686
 687         case DNS_TYPE_LOC:
 688                 assert(rr->loc.version == 0);
 689
 690                 t = format_location(rr->loc.latitude,
 691                                     rr->loc.longitude,
 692                                     rr->loc.altitude,
 693                                     rr->loc.size,
 694                                     rr->loc.horiz_pre,
 695                                     rr->loc.vert_pre);
 696                 if (!t)
 697                         return -ENOMEM;
 698
 699                 s = strjoin(k, " ", t, NULL);
 700                 if (!s)
 701                         return -ENOMEM;
 702                 break;
 703
 704         case DNS_TYPE_DS:
 705                 t = hexmem(rr->ds.digest, rr->ds.digest_size);
 706                 if (!t)
 707                         return -ENOMEM;
 708
 709                 r = asprintf(&s, "%s %u %u %u %s",
 710                              k,
 711                              rr->ds.key_tag,
 712                              rr->ds.algorithm,
 713                              rr->ds.digest_type,
 714                              t);
 715                 if (r < 0)
 716                         return -ENOMEM;
 717                 break;
 718
 719         case DNS_TYPE_SSHFP:
 720                 t = hexmem(rr->sshfp.fingerprint, rr->sshfp.fingerprint_size);
 721                 if (!t)
 722                         return -ENOMEM;
 723
 724                 r = asprintf(&s, "%s %u %u %s",
 725                              k,
 726                              rr->sshfp.algorithm,
 727                              rr->sshfp.fptype,
 728                              t);
 729                 if (r < 0)
 730                         return -ENOMEM;
 731                 break;
 732
 733         case DNS_TYPE_DNSKEY: {
 734                 const char *alg;
 735
 736                 alg = dnssec_algorithm_to_string(rr->dnskey.algorithm);
 737
 738                 t = base64mem(rr->dnskey.key, rr->dnskey.key_size);
 739                 if (!t)
 740                         return -ENOMEM;
 741
 742                 r = asprintf(&s, "%s %u 3 %.*s%.*u %s",
 743                              k,
 744                              dnskey_to_flags(rr),
 745                              alg ? -1 : 0, alg,
 746                              alg ? 0 : 1, alg ? 0u : (unsigned) rr->dnskey.algorithm,
 747                              t);
 748                 if (r < 0)
 749                         return -ENOMEM;
 750                 break;
 751         }
 752
 753         case DNS_TYPE_RRSIG: {
 754                 const char *type, *alg;
 755                 char expiration[strlen("YYYYMMDDHHmmSS") + 1], inception[strlen("YYYYMMDDHHmmSS") + 1];
 756
 757                 type = dns_type_to_string(rr->rrsig.type_covered);
 758                 alg = dnssec_algorithm_to_string(rr->rrsig.algorithm);
 759
 760                 t = base64mem(rr->rrsig.signature, rr->rrsig.signature_size);
 761                 if (!t)
 762                         return -ENOMEM;
 763
 764                 r = format_timestamp_dns(expiration, sizeof(expiration), rr->rrsig.expiration);
 765                 if (r < 0)
 766                         return r;
 767
 768                 r = format_timestamp_dns(inception, sizeof(inception), rr->rrsig.inception);
 769                 if (r < 0)
 770                         return r;
 771
 772                 /* TYPE?? follows
 773                  * http://tools.ietf.org/html/rfc3597#section-5 */
 774
 775                 r = asprintf(&s, "%s %s%.*u %.*s%.*u %u %u %s %s %u %s %s",
 776                              k,
 777                              type ?: "TYPE",
 778                              type ? 0 : 1, type ? 0u : (unsigned) rr->rrsig.type_covered,
 779                              alg ? -1 : 0, alg,
 780                              alg ? 0 : 1, alg ? 0u : (unsigned) rr->rrsig.algorithm,
 781                              rr->rrsig.labels,
 782                              rr->rrsig.original_ttl,
 783                              expiration,
 784                              inception,
 785                              rr->rrsig.key_tag,
 786                              rr->rrsig.signer,
 787                              t);
 788                 if (r < 0)
 789                         return -ENOMEM;
 790                 break;
 791         }
 792
 793         case DNS_TYPE_NSEC:
 794                 t = format_types(rr->nsec.types);
 795                 if (!t)
 796                         return -ENOMEM;
 797
 798                 r = asprintf(&s, "%s %s %s",
 799                              k,
 800                              rr->nsec.next_domain_name,
 801                              t);
 802                 if (r < 0)
 803                         return -ENOMEM;
 804                 break;
 805
 806         case DNS_TYPE_NSEC3: {
 807                 _cleanup_free_ char *salt = NULL, *hash = NULL;
 808
 809                 if (rr->nsec3.salt_size > 0) {
 810                         salt = hexmem(rr->nsec3.salt, rr->nsec3.salt_size);
 811                         if (!salt)
 812                                 return -ENOMEM;
 813                 }
 814
 815                 hash = base32hexmem(rr->nsec3.next_hashed_name, rr->nsec3.next_hashed_name_size, false);
 816                 if (!hash)
 817                         return -ENOMEM;
 818
 819                 t = format_types(rr->nsec3.types);
 820                 if (!t)
 821                         return -ENOMEM;
 822
 823                 r = asprintf(&s, "%s %"PRIu8" %"PRIu8" %"PRIu16" %s %s %s",
 824                              k,
 825                              rr->nsec3.algorithm,
 826                              rr->nsec3.flags,
 827                              rr->nsec3.iterations,
 828                              rr->nsec3.salt_size > 0 ? salt : "-",
 829                              hash,
 830                              t);
 831                 if (r < 0)
 832                         return -ENOMEM;
 833
 834                 break;
 835         }
 836
 837         default:
 838                 t = hexmem(rr->generic.data, rr->generic.size);
 839                 if (!t)
 840                         return -ENOMEM;
 841
 842                 r = asprintf(&s, "%s \\# %zu %s", k, rr->generic.size, t);
 843                 if (r < 0)
 844                         return -ENOMEM;
 845                 break;
 846         }
 847
 848         *ret = s;
 849         return 0;
 850 }
 851
 852 const char *dns_class_to_string(uint16_t class) {
 853
 854         switch (class) {
 855
 856         case DNS_CLASS_IN:
 857                 return "IN";
 858
 859         case DNS_CLASS_ANY:
 860                 return "ANY";
 861         }
 862
 863         return NULL;
 864 }
 865
 866 int dns_class_from_string(const char *s, uint16_t *class) {
 867         assert(s);
 868         assert(class);
 869
 870         if (strcaseeq(s, "IN"))
 871                 *class = DNS_CLASS_IN;
 872         else if (strcaseeq(s, "ANY"))
 873                 *class = DNS_CLASS_ANY;
 874         else
 875                 return -EINVAL;
 876
 877         return 0;
 878 }