[thirdparty/systemd.git] / src / resolve / resolved-dns-rr.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2014 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <math.h>

#include "strv.h"

#include "resolved-dns-domain.h"
#include "resolved-dns-rr.h"
#include "resolved-dns-packet.h"
#include "dns-type.h"

DnsResourceKey* dns_resource_key_new(uint16_t class, uint16_t type, const char *name) {
        DnsResourceKey *k;
        size_t l;

        assert(name);

        l = strlen(name);
        k = malloc0(sizeof(DnsResourceKey) + l + 1);
        if (!k)
                return NULL;

        k->n_ref = 1;
        k->class = class;
        k->type = type;

        strcpy((char*) k + sizeof(DnsResourceKey), name);

        return k;
}

DnsResourceKey* dns_resource_key_new_consume(uint16_t class, uint16_t type, char *name) {
        DnsResourceKey *k;

        assert(name);

        k = new0(DnsResourceKey, 1);
        if (!k)
                return NULL;

        k->n_ref = 1;
        k->class = class;
        k->type = type;
        k->_name = name;

        return k;
}

DnsResourceKey* dns_resource_key_ref(DnsResourceKey *k) {

        if (!k)
                return NULL;

        assert(k->n_ref > 0);
        k->n_ref++;

        return k;
}

DnsResourceKey* dns_resource_key_unref(DnsResourceKey *k) {
        if (!k)
                return NULL;

        assert(k->n_ref > 0);

        if (k->n_ref == 1) {
                free(k->_name);
                free(k);
        } else
                k->n_ref--;

        return NULL;
}

int dns_resource_key_equal(const DnsResourceKey *a, const DnsResourceKey *b) {
        int r;

        r = dns_name_equal(DNS_RESOURCE_KEY_NAME(a), DNS_RESOURCE_KEY_NAME(b));
        if (r <= 0)
                return r;

        if (a->class != b->class)
                return 0;

        if (a->type != b->type)
                return 0;

        return 1;
}

int dns_resource_key_match_rr(const DnsResourceKey *key, const DnsResourceRecord *rr) {
        assert(key);
        assert(rr);

        if (rr->key->class != key->class && key->class != DNS_CLASS_ANY)
                return 0;

        if (rr->key->type != key->type && key->type != DNS_TYPE_ANY)
                return 0;

        return dns_name_equal(DNS_RESOURCE_KEY_NAME(rr->key), DNS_RESOURCE_KEY_NAME(key));
}

int dns_resource_key_match_cname(const DnsResourceKey *key, const DnsResourceRecord *rr) {
        assert(key);
        assert(rr);

        if (rr->key->class != key->class && key->class != DNS_CLASS_ANY)
                return 0;

        if (rr->key->type != DNS_TYPE_CNAME)
                return 0;

        return dns_name_equal(DNS_RESOURCE_KEY_NAME(rr->key), DNS_RESOURCE_KEY_NAME(key));
}

static unsigned long dns_resource_key_hash_func(const void *i, const uint8_t hash_key[HASH_KEY_SIZE]) {
        const DnsResourceKey *k = i;
        unsigned long ul;

        ul = dns_name_hash_func(DNS_RESOURCE_KEY_NAME(k), hash_key);
        ul = ul * hash_key[0] + ul + k->class;
        ul = ul * hash_key[1] + ul + k->type;

        return ul;
}

static int dns_resource_key_compare_func(const void *a, const void *b) {
        const DnsResourceKey *x = a, *y = b;
        int ret;

        ret = dns_name_compare_func(DNS_RESOURCE_KEY_NAME(x), DNS_RESOURCE_KEY_NAME(y));
        if (ret != 0)
                return ret;

        if (x->type < y->type)
                return -1;
        if (x->type > y->type)
                return 1;

        if (x->class < y->class)
                return -1;
        if (x->class > y->class)
                return 1;

        return 0;
}

const struct hash_ops dns_resource_key_hash_ops = {
        .hash = dns_resource_key_hash_func,
        .compare = dns_resource_key_compare_func
};

int dns_resource_key_to_string(const DnsResourceKey *key, char **ret) {
        char cbuf[DECIMAL_STR_MAX(uint16_t)], tbuf[DECIMAL_STR_MAX(uint16_t)];
        const char *c, *t;
        char *s;

        c = dns_class_to_string(key->class);
        if (!c) {
                sprintf(cbuf, "%i", key->class);
                c = cbuf;
        }

        t = dns_type_to_string(key->type);
        if (!t){
                sprintf(tbuf, "%i", key->type);
                t = tbuf;
        }

        if (asprintf(&s, "%s %s %-5s", DNS_RESOURCE_KEY_NAME(key), c, t) < 0)
                return -ENOMEM;

        *ret = s;
        return 0;
}

DnsResourceRecord* dns_resource_record_new(DnsResourceKey *key) {
        DnsResourceRecord *rr;

        rr = new0(DnsResourceRecord, 1);
        if (!rr)
                return NULL;

        rr->n_ref = 1;
        rr->key = dns_resource_key_ref(key);

        return rr;
}

DnsResourceRecord* dns_resource_record_new_full(uint16_t class, uint16_t type, const char *name) {
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;

        key = dns_resource_key_new(class, type, name);
        if (!key)
                return NULL;

        return dns_resource_record_new(key);
}

DnsResourceRecord* dns_resource_record_ref(DnsResourceRecord *rr) {
        if (!rr)
                return NULL;

        assert(rr->n_ref > 0);
        rr->n_ref++;

        return rr;
}

DnsResourceRecord* dns_resource_record_unref(DnsResourceRecord *rr) {
        if (!rr)
                return NULL;

        assert(rr->n_ref > 0);

        if (rr->n_ref > 1) {
                rr->n_ref--;
                return NULL;
        }

        if (rr->key) {
                switch(rr->key->type) {

                case DNS_TYPE_SRV:
                        free(rr->srv.name);
                        break;

                case DNS_TYPE_PTR:
                case DNS_TYPE_NS:
                case DNS_TYPE_CNAME:
                case DNS_TYPE_DNAME:
                        free(rr->ptr.name);
                        break;

                case DNS_TYPE_HINFO:
                        free(rr->hinfo.cpu);
                        free(rr->hinfo.os);
                        break;

                case DNS_TYPE_TXT:
                case DNS_TYPE_SPF:
                        strv_free(rr->txt.strings);
                        break;

                case DNS_TYPE_SOA:
                        free(rr->soa.mname);
                        free(rr->soa.rname);
                        break;

                case DNS_TYPE_MX:
                        free(rr->mx.exchange);
                        break;

                case DNS_TYPE_SSHFP:
                        free(rr->sshfp.key);
                        break;

                case DNS_TYPE_DNSKEY:
                        free(rr->dnskey.key);
                        break;

                case DNS_TYPE_RRSIG:
                        free(rr->rrsig.signer);
                        free(rr->rrsig.signature);
                        break;

                case DNS_TYPE_LOC:
                case DNS_TYPE_A:
                case DNS_TYPE_AAAA:
                        break;

                default:
                        free(rr->generic.data);
                }

                dns_resource_key_unref(rr->key);
        }

        free(rr);

        return NULL;
}

int dns_resource_record_new_reverse(DnsResourceRecord **ret, int family, const union in_addr_union *address, const char *hostname) {
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
        _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
        _cleanup_free_ char *ptr = NULL;
        int r;

        assert(ret);
        assert(address);
        assert(hostname);

        r = dns_name_reverse(family, address, &ptr);
        if (r < 0)
                return r;

        key = dns_resource_key_new_consume(DNS_CLASS_IN, DNS_TYPE_PTR, ptr);
        if (!key)
                return -ENOMEM;

        ptr = NULL;

        rr = dns_resource_record_new(key);
        if (!rr)
                return -ENOMEM;

        rr->ptr.name = strdup(hostname);
        if (!rr->ptr.name)
                return -ENOMEM;

        *ret = rr;
        rr = NULL;

        return 0;
}

int dns_resource_record_equal(const DnsResourceRecord *a, const DnsResourceRecord *b) {
        int r;

        assert(a);
        assert(b);

        r = dns_resource_key_equal(a->key, b->key);
        if (r <= 0)
                return r;

        if (a->unparseable != b->unparseable)
                return 0;

        switch (a->unparseable ? _DNS_TYPE_INVALID : a->key->type) {

        case DNS_TYPE_SRV:
                r = dns_name_equal(a->srv.name, b->srv.name);
                if (r <= 0)
                        return r;

                return a->srv.priority == b->srv.priority &&
                       a->srv.weight == b->srv.weight &&
                       a->srv.port == b->srv.port;

        case DNS_TYPE_PTR:
        case DNS_TYPE_NS:
        case DNS_TYPE_CNAME:
        case DNS_TYPE_DNAME:
                return dns_name_equal(a->ptr.name, b->ptr.name);

        case DNS_TYPE_HINFO:
                return strcaseeq(a->hinfo.cpu, b->hinfo.cpu) &&
                       strcaseeq(a->hinfo.os, b->hinfo.os);

        case DNS_TYPE_SPF: /* exactly the same as TXT */
        case DNS_TYPE_TXT:
                return strv_equal(a->txt.strings, b->txt.strings);

        case DNS_TYPE_A:
                return memcmp(&a->a.in_addr, &b->a.in_addr, sizeof(struct in_addr)) == 0;

        case DNS_TYPE_AAAA:
                return memcmp(&a->aaaa.in6_addr, &b->aaaa.in6_addr, sizeof(struct in6_addr)) == 0;

        case DNS_TYPE_SOA:
                r = dns_name_equal(a->soa.mname, b->soa.mname);
                if (r <= 0)
                        return r;
                r = dns_name_equal(a->soa.rname, b->soa.rname);
                if (r <= 0)
                        return r;

                return a->soa.serial  == b->soa.serial &&
                       a->soa.refresh == b->soa.refresh &&
                       a->soa.retry   == b->soa.retry &&
                       a->soa.expire  == b->soa.expire &&
                       a->soa.minimum == b->soa.minimum;

        case DNS_TYPE_MX:
                if (a->mx.priority != b->mx.priority)
                        return 0;

                return dns_name_equal(a->mx.exchange, b->mx.exchange);

        case DNS_TYPE_LOC:
                assert(a->loc.version == b->loc.version);

                return a->loc.size == b->loc.size &&
                       a->loc.horiz_pre == b->loc.horiz_pre &&
                       a->loc.vert_pre == b->loc.vert_pre &&
                       a->loc.latitude == b->loc.latitude &&
                       a->loc.longitude == b->loc.longitude &&
                       a->loc.altitude == b->loc.altitude;

        case DNS_TYPE_SSHFP:
                return a->sshfp.algorithm == b->sshfp.algorithm &&
                       a->sshfp.fptype == b->sshfp.fptype &&
                       a->sshfp.key_size == b->sshfp.key_size &&
                       memcmp(a->sshfp.key, b->sshfp.key, a->sshfp.key_size) == 0;

        case DNS_TYPE_DNSKEY:
                return a->dnskey.zone_key_flag == b->dnskey.zone_key_flag &&
                       a->dnskey.sep_flag == b->dnskey.sep_flag &&
                       a->dnskey.algorithm == b->dnskey.algorithm &&
                       a->dnskey.key_size == b->dnskey.key_size &&
                       memcmp(a->dnskey.key, b->dnskey.key, a->dnskey.key_size) == 0;

        case DNS_TYPE_RRSIG:
                /* do the fast comparisons first */
                if (a->rrsig.type_covered != b->rrsig.type_covered ||
                    a->rrsig.algorithm != b->rrsig.algorithm ||
                    a->rrsig.labels != b->rrsig.labels ||
                    a->rrsig.original_ttl != b->rrsig.original_ttl ||
                    a->rrsig.expiration != b->rrsig.expiration ||
                    a->rrsig.inception != b->rrsig.inception ||
                    a->rrsig.key_tag != b->rrsig.key_tag ||
                    a->rrsig.signature_size != b->rrsig.signature_size ||
                    memcmp(a->rrsig.signature, b->rrsig.signature, a->rrsig.signature_size) != 0)
                        return false;

                return dns_name_equal(a->rrsig.signer, b->rrsig.signer);

        default:
                return a->generic.size == b->generic.size &&
                        memcmp(a->generic.data, b->generic.data, a->generic.size) == 0;
        }
}

static char* format_location(uint32_t latitude, uint32_t longitude, uint32_t altitude,
                             uint8_t size, uint8_t horiz_pre, uint8_t vert_pre) {
        char *s;
        char NS = latitude >= 1U<<31 ? 'N' : 'S';
        char EW = longitude >= 1U<<31 ? 'E' : 'W';

        int lat = latitude >= 1U<<31 ? (int) (latitude - (1U<<31)) : (int) ((1U<<31) - latitude);
        int lon = longitude >= 1U<<31 ? (int) (longitude - (1U<<31)) : (int) ((1U<<31) - longitude);
        double alt = altitude >= 10000000u ? altitude - 10000000u : -(double)(10000000u - altitude);
        double siz = (size >> 4) * exp10((double) (size & 0xF));
        double hor = (horiz_pre >> 4) * exp10((double) (horiz_pre & 0xF));
        double ver = (vert_pre >> 4) * exp10((double) (vert_pre & 0xF));

        if (asprintf(&s, "%d %d %.3f %c %d %d %.3f %c %.2fm %.2fm %.2fm %.2fm",
                     (lat / 60000 / 60),
                     (lat / 60000) % 60,
                     (lat % 60000) / 1000.,
                     NS,
                     (lon / 60000 / 60),
                     (lon / 60000) % 60,
                     (lon % 60000) / 1000.,
                     EW,
                     alt / 100.,
                     siz / 100.,
                     hor / 100.,
                     ver / 100.) < 0)
                return NULL;

        return s;
}

int dns_resource_record_to_string(const DnsResourceRecord *rr, char **ret) {
        _cleanup_free_ char *k = NULL, *t = NULL;
        char *s;
        int r;

        assert(rr);

        r = dns_resource_key_to_string(rr->key, &k);
        if (r < 0)
                return r;

        switch (rr->unparseable ? _DNS_TYPE_INVALID : rr->key->type) {

        case DNS_TYPE_SRV:
                r = asprintf(&s, "%s %u %u %u %s",
                             k,
                             rr->srv.priority,
                             rr->srv.weight,
                             rr->srv.port,
                             strna(rr->srv.name));
                if (r < 0)
                        return -ENOMEM;
                break;

        case DNS_TYPE_PTR:
        case DNS_TYPE_NS:
        case DNS_TYPE_CNAME:
        case DNS_TYPE_DNAME:
                s = strjoin(k, " ", rr->ptr.name, NULL);
                if (!s)
                        return -ENOMEM;

                break;

        case DNS_TYPE_HINFO:
                s = strjoin(k, " ", rr->hinfo.cpu, " ", rr->hinfo.os, NULL);
                if (!s)
                        return -ENOMEM;
                break;

        case DNS_TYPE_SPF: /* exactly the same as TXT */
        case DNS_TYPE_TXT:
                t = strv_join_quoted(rr->txt.strings);
                if (!t)
                        return -ENOMEM;

                s = strjoin(k, " ", t, NULL);
                if (!s)
                        return -ENOMEM;

                break;

        case DNS_TYPE_A: {
                _cleanup_free_ char *x = NULL;

                r = in_addr_to_string(AF_INET, (const union in_addr_union*) &rr->a.in_addr, &x);
                if (r < 0)
                        return r;

                s = strjoin(k, " ", x, NULL);
                if (!s)
                        return -ENOMEM;
                break;
        }

        case DNS_TYPE_AAAA:
                r = in_addr_to_string(AF_INET6, (const union in_addr_union*) &rr->aaaa.in6_addr, &t);
                if (r < 0)
                        return r;

                s = strjoin(k, " ", t, NULL);
                if (!s)
                        return -ENOMEM;
                break;

        case DNS_TYPE_SOA:
                r = asprintf(&s, "%s %s %s %u %u %u %u %u",
                             k,
                             strna(rr->soa.mname),
                             strna(rr->soa.rname),
                             rr->soa.serial,
                             rr->soa.refresh,
                             rr->soa.retry,
                             rr->soa.expire,
                             rr->soa.minimum);
                if (r < 0)
                        return -ENOMEM;
                break;

        case DNS_TYPE_MX:
                r = asprintf(&s, "%s %u %s",
                             k,
                             rr->mx.priority,
                             rr->mx.exchange);
                if (r < 0)
                        return -ENOMEM;
                break;

        case DNS_TYPE_LOC:
                assert(rr->loc.version == 0);

                t = format_location(rr->loc.latitude,
                                    rr->loc.longitude,
                                    rr->loc.altitude,
                                    rr->loc.size,
                                    rr->loc.horiz_pre,
                                    rr->loc.vert_pre);
                if (!t)
                        return -ENOMEM;

                s = strjoin(k, " ", t, NULL);
                if (!s)
                        return -ENOMEM;
                break;

        case DNS_TYPE_SSHFP:
                t = hexmem(rr->sshfp.key, rr->sshfp.key_size);
                if (!t)
                        return -ENOMEM;

                r = asprintf(&s, "%s %u %u %s",
                             k,
                             rr->sshfp.algorithm,
                             rr->sshfp.fptype,
                             t);
                if (r < 0)
                        return -ENOMEM;
                break;

        case DNS_TYPE_DNSKEY: {
                const char *alg;

                alg = dnssec_algorithm_to_string(rr->dnskey.algorithm);

                t = hexmem(rr->dnskey.key, rr->dnskey.key_size);
                if (!t)
                        return -ENOMEM;

                r = asprintf(&s, "%s %u 3 %.*s%.*u %s",
                             k,
                             dnskey_to_flags(rr),
                             alg ? -1 : 0, alg,
                             alg ? 0 : 1, alg ? 0u : (unsigned) rr->dnskey.algorithm,
                             t);
                if (r < 0)
                        return -ENOMEM;
                break;
        }

        case DNS_TYPE_RRSIG: {
                const char *type, *alg;

                type = dns_type_to_string(rr->rrsig.type_covered);
                alg = dnssec_algorithm_to_string(rr->rrsig.algorithm);

                t = hexmem(rr->rrsig.signature, rr->rrsig.signature_size);
                if (!t)
                        return -ENOMEM;

                /* TYPE?? follows
                 * http://tools.ietf.org/html/rfc3597#section-5 */

                r = asprintf(&s, "%s %s%.*u %.*s%.*u %u %u %u %u %u %s %s",
                             k,
                             type ?: "TYPE",
                             type ? 0 : 1, type ? 0u : (unsigned) rr->rrsig.type_covered,
                             alg ? -1 : 0, alg,
                             alg ? 0 : 1, alg ? 0u : (unsigned) rr->rrsig.algorithm,
                             rr->rrsig.labels,
                             rr->rrsig.original_ttl,
                             rr->rrsig.expiration,
                             rr->rrsig.inception,
                             rr->rrsig.key_tag,
                             rr->rrsig.signer,
                             t);
                if (r < 0)
                        return -ENOMEM;
                break;
        }

        default:
                t = hexmem(rr->generic.data, rr->generic.size);
                if (!t)
                        return -ENOMEM;

                s = strjoin(k, " ", t, NULL);
                if (!s)
                        return -ENOMEM;
                break;
        }

        *ret = s;
        return 0;
}

const char *dns_class_to_string(uint16_t class) {

        switch (class) {

        case DNS_CLASS_IN:
                return "IN";

        case DNS_CLASS_ANY:
                return "ANY";
        }

        return NULL;
}

int dns_class_from_string(const char *s, uint16_t *class) {
        assert(s);
        assert(class);

        if (strcaseeq(s, "IN"))
                *class = DNS_CLASS_IN;
        else if (strcaseeq(s, "ANY"))
                *class = DNS_TYPE_ANY;
        else
                return -EINVAL;

        return 0;
}
Commit	Line	Data
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>
0dae31d4 ZJS	23
2e276efc ZJS	24	#include "strv.h"
2e276efc ZJS	25
322345fd	26	#include "resolved-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	31	DnsResourceKey* 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
	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));
74b2466e LP	134	}
74b2466e LP	135
d5099efc	136	static 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	147	static 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	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
2d4c5cbc LP	173	int 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	197	DnsResourceRecord* 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);
faa133f3 LP	206
74b2466e LP	207	return rr;
	208	}
	209
8bf52d3d LP	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
74b2466e LP	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
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);
faa133f3 LP	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);
7e8e0422 LP	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);
faa133f3 LP	297	}
322345fd	298
faa133f3	299	free(rr);
322345fd	300
322345fd LP	301	return NULL;
	302	}
	303
623a4c97 LP	304	int 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	338	int 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:
0f84a72e DH	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
2d4c5cbc LP	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
2d4c5cbc LP	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:
151226ab ZJS	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 &&
322345fd LP	442	memcmp(a->generic.data, b->generic.data, a->generic.size) == 0;
2d4c5cbc	443	}
322345fd LP	444	}
322345fd LP	445
0dae31d4 ZJS	446	static 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	477	int dns_resource_record_to_string(const DnsResourceRecord rr, char *ret) {
8db0d2f5	478	_cleanup_free_ char k = NULL, t = NULL;
2d4c5cbc LP	479	char *s;
2d4c5cbc LP	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: {
2d4c5cbc LP	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:
8db0d2f5 ZJS	543	r = in_addr_to_string(AF_INET6, (const union in_addr_union*) &rr->aaaa.in6_addr, &t);
2d4c5cbc LP	544	if (r < 0)
2d4c5cbc LP	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);
0dae31d4 ZJS	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;
0dae31d4 ZJS	586
8db0d2f5	587	s = strjoin(k, " ", t, NULL);
0dae31d4 ZJS	588	if (!s)
0dae31d4 ZJS	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
8db0d2f5 ZJS	611	t = hexmem(rr->dnskey.key, rr->dnskey.key_size);
	612	if (!t)
	613	return -ENOMEM;
2d4c5cbc	614
ff3d6560	615	r = asprintf(&s, "%s %u 3 %.s%.u %s",
8db0d2f5 ZJS	616	k,
8db0d2f5 ZJS	617	dnskey_to_flags(rr),
ff3d6560 ZJS	618	alg ? -1 : 0, alg,
ff3d6560 ZJS	619	alg ? 0 : 1, alg ? 0u : (unsigned) rr->dnskey.algorithm,
8db0d2f5 ZJS	620	t);
8db0d2f5 ZJS	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
	632	t = hexmem(rr->rrsig.signature, rr->rrsig.signature_size);
	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	672	const char *dns_class_to_string(uint16_t class) {
322345fd	673
2d4c5cbc	674	switch (class) {
322345fd	675
2d4c5cbc LP	676	case DNS_CLASS_IN:
2d4c5cbc LP	677	return "IN";
322345fd	678
2d4c5cbc LP	679	case DNS_CLASS_ANY:
	680	return "ANY";
	681	}
322345fd	682
2d4c5cbc LP	683	return NULL;
2d4c5cbc LP	684	}
322345fd	685
2d4c5cbc LP	686	int 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;
2d4c5cbc LP	698	}