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 "resolved-dns-domain.h"
  23 #include "resolved-dns-rr.h"
  24
  25 DnsResourceKey* dns_resource_key_new(uint16_t class, uint16_t type, const char *name) {
  26         DnsResourceKey *k;
  27         size_t l;
  28
  29         assert(name);
  30
  31         l = strlen(name);
  32         k = malloc0(sizeof(DnsResourceKey) + l + 1);
  33         if (!k)
  34                 return NULL;
  35
  36         k->n_ref = 1;
  37         k->class = class;
  38         k->type = type;
  39
  40         strcpy((char*) k + sizeof(DnsResourceKey), name);
  41
  42         return k;
  43 }
  44
  45 DnsResourceKey* dns_resource_key_new_consume(uint16_t class, uint16_t type, char *name) {
  46         DnsResourceKey *k;
  47
  48         assert(name);
  49
  50         k = new0(DnsResourceKey, 1);
  51         if (!k)
  52                 return NULL;
  53
  54         k->n_ref = 1;
  55         k->class = class;
  56         k->type = type;
  57         k->_name = name;
  58
  59         return k;
  60 }
  61
  62 DnsResourceKey* dns_resource_key_ref(DnsResourceKey *k) {
  63
  64         if (!k)
  65                 return NULL;
  66
  67         assert(k->n_ref > 0);
  68         k->n_ref++;
  69
  70         return k;
  71 }
  72
  73 DnsResourceKey* dns_resource_key_unref(DnsResourceKey *k) {
  74         if (!k)
  75                 return NULL;
  76
  77         assert(k->n_ref > 0);
  78
  79         if (k->n_ref == 1) {
  80                 free(k->_name);
  81                 free(k);
  82         } else
  83                 k->n_ref--;
  84
  85         return NULL;
  86 }
  87
  88 int dns_resource_key_equal(const DnsResourceKey *a, const DnsResourceKey *b) {
  89         int r;
  90
  91         r = dns_name_equal(DNS_RESOURCE_KEY_NAME(a), DNS_RESOURCE_KEY_NAME(b));
  92         if (r <= 0)
  93                 return r;
  94
  95         if (a->class != b->class)
  96                 return 0;
  97
  98         if (a->type != b->type)
  99                 return 0;
 100
 101         return 1;
 102 }
 103
 104 int dns_resource_key_match_rr(const DnsResourceKey *key, const DnsResourceRecord *rr) {
 105         assert(key);
 106         assert(rr);
 107
 108         if (rr->key->class != key->class && key->class != DNS_CLASS_ANY)
 109                 return 0;
 110
 111         if (rr->key->type != key->type && key->type != DNS_TYPE_ANY)
 112                 return 0;
 113
 114         return dns_name_equal(DNS_RESOURCE_KEY_NAME(rr->key), DNS_RESOURCE_KEY_NAME(key));
 115 }
 116
 117 int dns_resource_key_match_cname(const DnsResourceKey *key, const DnsResourceRecord *rr) {
 118         assert(key);
 119         assert(rr);
 120
 121         if (rr->key->class != key->class && key->class != DNS_CLASS_ANY)
 122                 return 0;
 123
 124         if (rr->key->type != DNS_TYPE_CNAME)
 125                 return 0;
 126
 127         return dns_name_equal(DNS_RESOURCE_KEY_NAME(rr->key), DNS_RESOURCE_KEY_NAME(key));
 128 }
 129
 130 unsigned long dns_resource_key_hash_func(const void *i, const uint8_t hash_key[HASH_KEY_SIZE]) {
 131         const DnsResourceKey *k = i;
 132         unsigned long ul;
 133
 134         ul = dns_name_hash_func(DNS_RESOURCE_KEY_NAME(k), hash_key);
 135         ul = ul * hash_key[0] + ul + k->class;
 136         ul = ul * hash_key[1] + ul + k->type;
 137
 138         return ul;
 139 }
 140
 141 int dns_resource_key_compare_func(const void *a, const void *b) {
 142         const DnsResourceKey *x = a, *y = b;
 143         int ret;
 144
 145         ret = dns_name_compare_func(DNS_RESOURCE_KEY_NAME(x), DNS_RESOURCE_KEY_NAME(y));
 146         if (ret != 0)
 147                 return ret;
 148
 149         if (x->type < y->type)
 150                 return -1;
 151         if (x->type > y->type)
 152                 return 1;
 153
 154         if (x->class < y->class)
 155                 return -1;
 156         if (x->class > y->class)
 157                 return 1;
 158
 159         return 0;
 160 }
 161
 162 DnsResourceRecord* dns_resource_record_new(DnsResourceKey *key) {
 163         DnsResourceRecord *rr;
 164
 165         rr = new0(DnsResourceRecord, 1);
 166         if (!rr)
 167                 return NULL;
 168
 169         rr->n_ref = 1;
 170         rr->key = dns_resource_key_ref(key);
 171
 172         return rr;
 173 }
 174
 175 DnsResourceRecord* dns_resource_record_ref(DnsResourceRecord *rr) {
 176         if (!rr)
 177                 return NULL;
 178
 179         assert(rr->n_ref > 0);
 180         rr->n_ref++;
 181
 182         return rr;
 183 }
 184
 185 DnsResourceRecord* dns_resource_record_unref(DnsResourceRecord *rr) {
 186         if (!rr)
 187                 return NULL;
 188
 189         assert(rr->n_ref > 0);
 190
 191         if (rr->n_ref > 1) {
 192                 rr->n_ref--;
 193                 return NULL;
 194         }
 195
 196         if (rr->key) {
 197                 if (IN_SET(rr->key->type, DNS_TYPE_PTR, DNS_TYPE_NS, DNS_TYPE_CNAME))
 198                         free(rr->ptr.name);
 199                 else if (rr->key->type == DNS_TYPE_HINFO) {
 200                         free(rr->hinfo.cpu);
 201                         free(rr->hinfo.os);
 202                 } else if (rr->key->type == DNS_TYPE_SOA) {
 203                         free(rr->soa.mname);
 204                         free(rr->soa.rname);
 205                 } else if (!IN_SET(rr->key->type, DNS_TYPE_A, DNS_TYPE_AAAA))
 206                         free(rr->generic.data);
 207
 208                 dns_resource_key_unref(rr->key);
 209         }
 210
 211         free(rr);
 212
 213         return NULL;
 214 }
 215
 216 int dns_resource_record_new_reverse(DnsResourceRecord **ret, int family, const union in_addr_union *address, const char *hostname) {
 217         _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
 218         _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
 219         _cleanup_free_ char *ptr = NULL;
 220         int r;
 221
 222         assert(ret);
 223         assert(address);
 224         assert(hostname);
 225
 226         r = dns_name_reverse(family, address, &ptr);
 227         if (r < 0)
 228                 return r;
 229
 230         key = dns_resource_key_new_consume(DNS_CLASS_IN, DNS_TYPE_PTR, ptr);
 231         if (!key)
 232                 return -ENOMEM;
 233
 234         ptr = NULL;
 235
 236         rr = dns_resource_record_new(key);
 237         if (!rr)
 238                 return -ENOMEM;
 239
 240         rr->ptr.name = strdup(hostname);
 241         if (!rr->ptr.name)
 242                 return -ENOMEM;
 243
 244         *ret = rr;
 245         rr = NULL;
 246
 247         return 0;
 248 }
 249
 250 int dns_resource_record_equal(const DnsResourceRecord *a, const DnsResourceRecord *b) {
 251         int r;
 252
 253         assert(a);
 254         assert(b);
 255
 256         r = dns_resource_key_equal(a->key, b->key);
 257         if (r <= 0)
 258                 return r;
 259
 260         if (IN_SET(a->key->type, DNS_TYPE_PTR, DNS_TYPE_NS, DNS_TYPE_CNAME))
 261                 return dns_name_equal(a->ptr.name, b->ptr.name);
 262         else if (a->key->type == DNS_TYPE_HINFO)
 263                 return strcasecmp(a->hinfo.cpu, b->hinfo.cpu) == 0 &&
 264                        strcasecmp(a->hinfo.os, b->hinfo.os) == 0;
 265         else if (a->key->type == DNS_TYPE_A)
 266                 return memcmp(&a->a.in_addr, &b->a.in_addr, sizeof(struct in_addr)) == 0;
 267         else if (a->key->type == DNS_TYPE_AAAA)
 268                 return memcmp(&a->aaaa.in6_addr, &b->aaaa.in6_addr, sizeof(struct in6_addr)) == 0;
 269         else if (a->key->type == DNS_TYPE_SOA) {
 270                 r = dns_name_equal(a->soa.mname, b->soa.mname);
 271                 if (r <= 0)
 272                         return r;
 273                 r = dns_name_equal(a->soa.rname, b->soa.rname);
 274                 if (r <= 0)
 275                         return r;
 276
 277                 return a->soa.serial  == b->soa.serial &&
 278                        a->soa.refresh == b->soa.refresh &&
 279                        a->soa.retry   == b->soa.retry &&
 280                        a->soa.expire  == b->soa.expire &&
 281                        a->soa.minimum == b->soa.minimum;
 282         } else
 283                 return a->generic.size == b->generic.size &&
 284                         memcmp(a->generic.data, b->generic.data, a->generic.size) == 0;
 285 }
 286
 287 const char *dns_class_to_string(uint16_t class) {
 288
 289         switch (class) {
 290
 291         case DNS_CLASS_IN:
 292                 return "IN";
 293
 294         case DNS_CLASS_ANY:
 295                 return "ANY";
 296         }
 297
 298         return NULL;
 299 }
 300
 301 const char *dns_type_to_string(uint16_t type) {
 302
 303         switch (type) {
 304
 305         case DNS_TYPE_A:
 306                 return "A";
 307
 308         case DNS_TYPE_NS:
 309                 return "NS";
 310
 311         case DNS_TYPE_CNAME:
 312                 return "CNAME";
 313
 314         case DNS_TYPE_SOA:
 315                 return "SOA";
 316
 317         case DNS_TYPE_PTR:
 318                 return "PTR";
 319
 320         case DNS_TYPE_HINFO:
 321                 return "HINFO";
 322
 323         case DNS_TYPE_MX:
 324                 return "MX";
 325
 326         case DNS_TYPE_TXT:
 327                 return "TXT";
 328
 329         case DNS_TYPE_AAAA:
 330                 return "AAAA";
 331
 332         case DNS_TYPE_SRV:
 333                 return "SRV";
 334
 335         case DNS_TYPE_SSHFP:
 336                 return "SSHFP";
 337
 338         case DNS_TYPE_DNAME:
 339                 return "DNAME";
 340
 341         case DNS_TYPE_ANY:
 342                 return "ANY";
 343
 344         case DNS_TYPE_OPT:
 345                 return "OPT";
 346
 347         case DNS_TYPE_TKEY:
 348                 return "TKEY";
 349
 350         case DNS_TYPE_TSIG:
 351                 return "TSIG";
 352
 353         case DNS_TYPE_IXFR:
 354                 return "IXFR";
 355
 356         case DNS_TYPE_AXFR:
 357                 return "AXFR";
 358         }
 359
 360         return NULL;
 361 }