[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));
}

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;
}

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;
}

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: {
                int i;

                for (i = 0; a->txt.strings[i] || b->txt.strings[i]; i++)
                        if (!streq_ptr(a->txt.strings[i], b->txt.strings[i]))
                                return false;
                return true;
        }

        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
322345fd LP	136	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
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
	147	int dns_resource_key_compare_func(const void a, const void b) {
	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
2d4c5cbc LP	168	int dns_resource_key_to_string(const DnsResourceKey key, char *ret) {
	169	char cbuf[DECIMAL_STR_MAX(uint16_t)], tbuf[DECIMAL_STR_MAX(uint16_t)];
	170	const char c, t;
	171	char *s;
	172
	173	c = dns_class_to_string(key->class);
	174	if (!c) {
	175	sprintf(cbuf, "%i", key->class);
	176	c = cbuf;
	177	}
	178
	179	t = dns_type_to_string(key->type);
	180	if (!t){
	181	sprintf(tbuf, "%i", key->type);
	182	t = tbuf;
	183	}
	184
23432a1c	185	if (asprintf(&s, "%s %s %-5s", DNS_RESOURCE_KEY_NAME(key), c, t) < 0)
2d4c5cbc LP	186	return -ENOMEM;
	187
	188	*ret = s;
	189	return 0;
	190	}
	191
faa133f3	192	DnsResourceRecord* dns_resource_record_new(DnsResourceKey *key) {
74b2466e LP	193	DnsResourceRecord *rr;
	194
	195	rr = new0(DnsResourceRecord, 1);
	196	if (!rr)
	197	return NULL;
	198
	199	rr->n_ref = 1;
faa133f3 LP	200	rr->key = dns_resource_key_ref(key);
faa133f3 LP	201
74b2466e LP	202	return rr;
	203	}
	204
8bf52d3d LP	205	DnsResourceRecord* dns_resource_record_new_full(uint16_t class, uint16_t type, const char *name) {
	206	_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
	207
	208	key = dns_resource_key_new(class, type, name);
	209	if (!key)
	210	return NULL;
	211
	212	return dns_resource_record_new(key);
	213	}
	214
74b2466e LP	215	DnsResourceRecord* dns_resource_record_ref(DnsResourceRecord *rr) {
	216	if (!rr)
	217	return NULL;
	218
	219	assert(rr->n_ref > 0);
	220	rr->n_ref++;
	221
	222	return rr;
	223	}
	224
	225	DnsResourceRecord* dns_resource_record_unref(DnsResourceRecord *rr) {
	226	if (!rr)
	227	return NULL;
	228
	229	assert(rr->n_ref > 0);
	230
	231	if (rr->n_ref > 1) {
	232	rr->n_ref--;
	233	return NULL;
	234	}
	235
faa133f3	236	if (rr->key) {
9de3e329	237	switch(rr->key->type) {
9c92ce6d LP	238
	239	case DNS_TYPE_SRV:
	240	free(rr->srv.name);
	241	break;
	242
9de3e329 ZJS	243	case DNS_TYPE_PTR:
	244	case DNS_TYPE_NS:
	245	case DNS_TYPE_CNAME:
8ac4e9e1	246	case DNS_TYPE_DNAME:
faa133f3	247	free(rr->ptr.name);
9de3e329	248	break;
9c92ce6d	249
9de3e329	250	case DNS_TYPE_HINFO:
faa133f3 LP	251	free(rr->hinfo.cpu);
faa133f3 LP	252	free(rr->hinfo.os);
9de3e329	253	break;
9c92ce6d	254
9de3e329	255	case DNS_TYPE_TXT:
9c92ce6d	256	case DNS_TYPE_SPF:
2e276efc	257	strv_free(rr->txt.strings);
9de3e329	258	break;
9c92ce6d	259
9de3e329	260	case DNS_TYPE_SOA:
7e8e0422 LP	261	free(rr->soa.mname);
7e8e0422 LP	262	free(rr->soa.rname);
9de3e329	263	break;
9c92ce6d	264
9de3e329	265	case DNS_TYPE_MX:
946c7094	266	free(rr->mx.exchange);
9de3e329	267	break;
9c92ce6d	268
42cc2eeb LP	269	case DNS_TYPE_SSHFP:
	270	free(rr->sshfp.key);
	271	break;
	272
8db0d2f5 ZJS	273	case DNS_TYPE_DNSKEY:
	274	free(rr->dnskey.key);
	275	break;
	276
151226ab ZJS	277	case DNS_TYPE_RRSIG:
	278	free(rr->rrsig.signer);
	279	free(rr->rrsig.signature);
	280	break;
	281
0dae31d4	282	case DNS_TYPE_LOC:
9de3e329 ZJS	283	case DNS_TYPE_A:
	284	case DNS_TYPE_AAAA:
	285	break;
9c92ce6d	286
9de3e329	287	default:
faa133f3	288	free(rr->generic.data);
9de3e329	289	}
322345fd	290
faa133f3 LP	291	dns_resource_key_unref(rr->key);
faa133f3 LP	292	}
322345fd	293
faa133f3	294	free(rr);
322345fd	295
322345fd LP	296	return NULL;
	297	}
	298
623a4c97 LP	299	int dns_resource_record_new_reverse(DnsResourceRecord *ret, int family, const union in_addr_union address, const char *hostname) {
	300	_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
	301	_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
	302	_cleanup_free_ char *ptr = NULL;
	303	int r;
	304
	305	assert(ret);
	306	assert(address);
	307	assert(hostname);
	308
	309	r = dns_name_reverse(family, address, &ptr);
	310	if (r < 0)
	311	return r;
	312
	313	key = dns_resource_key_new_consume(DNS_CLASS_IN, DNS_TYPE_PTR, ptr);
	314	if (!key)
	315	return -ENOMEM;
	316
	317	ptr = NULL;
	318
	319	rr = dns_resource_record_new(key);
	320	if (!rr)
	321	return -ENOMEM;
	322
	323	rr->ptr.name = strdup(hostname);
	324	if (!rr->ptr.name)
	325	return -ENOMEM;
	326
	327	*ret = rr;
	328	rr = NULL;
	329
	330	return 0;
	331	}
	332
322345fd LP	333	int dns_resource_record_equal(const DnsResourceRecord a, const DnsResourceRecord b) {
	334	int r;
	335
	336	assert(a);
	337	assert(b);
	338
faa133f3	339	r = dns_resource_key_equal(a->key, b->key);
322345fd LP	340	if (r <= 0)
	341	return r;
	342
fd0b4602 LP	343	if (a->unparseable != b->unparseable)
	344	return 0;
	345
	346	switch (a->unparseable ? _DNS_TYPE_INVALID : a->key->type) {
2d4c5cbc	347
9c92ce6d LP	348	case DNS_TYPE_SRV:
	349	r = dns_name_equal(a->srv.name, b->srv.name);
	350	if (r <= 0)
	351	return r;
	352
	353	return a->srv.priority == b->srv.priority &&
	354	a->srv.weight == b->srv.weight &&
	355	a->srv.port == b->srv.port;
	356
2d4c5cbc LP	357	case DNS_TYPE_PTR:
	358	case DNS_TYPE_NS:
	359	case DNS_TYPE_CNAME:
8ac4e9e1	360	case DNS_TYPE_DNAME:
322345fd	361	return dns_name_equal(a->ptr.name, b->ptr.name);
2d4c5cbc LP	362
	363	case DNS_TYPE_HINFO:
	364	return strcaseeq(a->hinfo.cpu, b->hinfo.cpu) &&
	365	strcaseeq(a->hinfo.os, b->hinfo.os);
	366
9de3e329	367	case DNS_TYPE_SPF: /* exactly the same as TXT */
2e276efc ZJS	368	case DNS_TYPE_TXT: {
	369	int i;
	370
	371	for (i = 0; a->txt.strings[i] \|\| b->txt.strings[i]; i++)
	372	if (!streq_ptr(a->txt.strings[i], b->txt.strings[i]))
	373	return false;
	374	return true;
	375	}
	376
2d4c5cbc	377	case DNS_TYPE_A:
322345fd	378	return memcmp(&a->a.in_addr, &b->a.in_addr, sizeof(struct in_addr)) == 0;
2d4c5cbc LP	379
2d4c5cbc LP	380	case DNS_TYPE_AAAA:
322345fd	381	return memcmp(&a->aaaa.in6_addr, &b->aaaa.in6_addr, sizeof(struct in6_addr)) == 0;
2d4c5cbc LP	382
2d4c5cbc LP	383	case DNS_TYPE_SOA:
7e8e0422 LP	384	r = dns_name_equal(a->soa.mname, b->soa.mname);
	385	if (r <= 0)
	386	return r;
	387	r = dns_name_equal(a->soa.rname, b->soa.rname);
	388	if (r <= 0)
	389	return r;
	390
	391	return a->soa.serial == b->soa.serial &&
	392	a->soa.refresh == b->soa.refresh &&
	393	a->soa.retry == b->soa.retry &&
	394	a->soa.expire == b->soa.expire &&
	395	a->soa.minimum == b->soa.minimum;
9c92ce6d	396
946c7094 ZJS	397	case DNS_TYPE_MX:
	398	if (a->mx.priority != b->mx.priority)
	399	return 0;
	400
	401	return dns_name_equal(a->mx.exchange, b->mx.exchange);
	402
0dae31d4 ZJS	403	case DNS_TYPE_LOC:
	404	assert(a->loc.version == b->loc.version);
	405
	406	return a->loc.size == b->loc.size &&
	407	a->loc.horiz_pre == b->loc.horiz_pre &&
	408	a->loc.vert_pre == b->loc.vert_pre &&
	409	a->loc.latitude == b->loc.latitude &&
	410	a->loc.longitude == b->loc.longitude &&
	411	a->loc.altitude == b->loc.altitude;
	412
42cc2eeb LP	413	case DNS_TYPE_SSHFP:
	414	return a->sshfp.algorithm == b->sshfp.algorithm &&
	415	a->sshfp.fptype == b->sshfp.fptype &&
	416	a->sshfp.key_size == b->sshfp.key_size &&
	417	memcmp(a->sshfp.key, b->sshfp.key, a->sshfp.key_size) == 0;
	418
8db0d2f5 ZJS	419	case DNS_TYPE_DNSKEY:
	420	return a->dnskey.zone_key_flag == b->dnskey.zone_key_flag &&
	421	a->dnskey.sep_flag == b->dnskey.sep_flag &&
	422	a->dnskey.algorithm == b->dnskey.algorithm &&
	423	a->dnskey.key_size == b->dnskey.key_size &&
	424	memcmp(a->dnskey.key, b->dnskey.key, a->dnskey.key_size) == 0;
	425
151226ab ZJS	426	case DNS_TYPE_RRSIG:
151226ab ZJS	427	/* do the fast comparisons first */
03664a62 LN	428	if (a->rrsig.type_covered != b->rrsig.type_covered \|\|
	429	a->rrsig.algorithm != b->rrsig.algorithm \|\|
	430	a->rrsig.labels != b->rrsig.labels \|\|
	431	a->rrsig.original_ttl != b->rrsig.original_ttl \|\|
	432	a->rrsig.expiration != b->rrsig.expiration \|\|
	433	a->rrsig.inception != b->rrsig.inception \|\|
	434	a->rrsig.key_tag != b->rrsig.key_tag \|\|
151226ab ZJS	435	a->rrsig.signature_size != b->rrsig.signature_size \|\|
	436	memcmp(a->rrsig.signature, b->rrsig.signature, a->rrsig.signature_size) != 0)
	437	return false;
	438
	439	return dns_name_equal(a->rrsig.signer, b->rrsig.signer);
	440
2d4c5cbc	441	default:
322345fd LP	442	return a->generic.size == b->generic.size &&
322345fd LP	443	memcmp(a->generic.data, b->generic.data, a->generic.size) == 0;
2d4c5cbc	444	}
322345fd LP	445	}
322345fd LP	446
0dae31d4 ZJS	447	static char* format_location(uint32_t latitude, uint32_t longitude, uint32_t altitude,
	448	uint8_t size, uint8_t horiz_pre, uint8_t vert_pre) {
	449	char *s;
	450	char NS = latitude >= 1U<<31 ? 'N' : 'S';
	451	char EW = longitude >= 1U<<31 ? 'E' : 'W';
	452
	453	int lat = latitude >= 1U<<31 ? (int) (latitude - (1U<<31)) : (int) ((1U<<31) - latitude);
	454	int lon = longitude >= 1U<<31 ? (int) (longitude - (1U<<31)) : (int) ((1U<<31) - longitude);
	455	double alt = altitude >= 10000000u ? altitude - 10000000u : -(double)(10000000u - altitude);
	456	double siz = (size >> 4) * exp10((double) (size & 0xF));
	457	double hor = (horiz_pre >> 4) * exp10((double) (horiz_pre & 0xF));
	458	double ver = (vert_pre >> 4) * exp10((double) (vert_pre & 0xF));
	459
	460	if (asprintf(&s, "%d %d %.3f %c %d %d %.3f %c %.2fm %.2fm %.2fm %.2fm",
	461	(lat / 60000 / 60),
	462	(lat / 60000) % 60,
	463	(lat % 60000) / 1000.,
	464	NS,
	465	(lon / 60000 / 60),
	466	(lon / 60000) % 60,
	467	(lon % 60000) / 1000.,
	468	EW,
	469	alt / 100.,
	470	siz / 100.,
	471	hor / 100.,
	472	ver / 100.) < 0)
	473	return NULL;
	474
	475	return s;
	476	}
	477
2d4c5cbc	478	int dns_resource_record_to_string(const DnsResourceRecord rr, char *ret) {
8db0d2f5	479	_cleanup_free_ char k = NULL, t = NULL;
2d4c5cbc LP	480	char *s;
2d4c5cbc LP	481	int r;
322345fd	482
2d4c5cbc	483	assert(rr);
322345fd	484
2d4c5cbc LP	485	r = dns_resource_key_to_string(rr->key, &k);
	486	if (r < 0)
	487	return r;
322345fd	488
0dae31d4	489	switch (rr->unparseable ? _DNS_TYPE_INVALID : rr->key->type) {
322345fd	490
9c92ce6d LP	491	case DNS_TYPE_SRV:
	492	r = asprintf(&s, "%s %u %u %u %s",
	493	k,
	494	rr->srv.priority,
	495	rr->srv.weight,
	496	rr->srv.port,
	497	strna(rr->srv.name));
	498	if (r < 0)
	499	return -ENOMEM;
	500	break;
	501
2d4c5cbc LP	502	case DNS_TYPE_PTR:
	503	case DNS_TYPE_NS:
	504	case DNS_TYPE_CNAME:
8ac4e9e1	505	case DNS_TYPE_DNAME:
2d4c5cbc LP	506	s = strjoin(k, " ", rr->ptr.name, NULL);
	507	if (!s)
	508	return -ENOMEM;
322345fd	509
2d4c5cbc	510	break;
322345fd	511
2d4c5cbc LP	512	case DNS_TYPE_HINFO:
	513	s = strjoin(k, " ", rr->hinfo.cpu, " ", rr->hinfo.os, NULL);
	514	if (!s)
	515	return -ENOMEM;
	516	break;
322345fd	517
9de3e329	518	case DNS_TYPE_SPF: /* exactly the same as TXT */
8db0d2f5	519	case DNS_TYPE_TXT:
2e276efc ZJS	520	t = strv_join_quoted(rr->txt.strings);
	521	if (!t)
	522	return -ENOMEM;
	523
	524	s = strjoin(k, " ", t, NULL);
	525	if (!s)
	526	return -ENOMEM;
	527
	528	break;
2e276efc	529
2d4c5cbc LP	530	case DNS_TYPE_A: {
2d4c5cbc LP	531	_cleanup_free_ char *x = NULL;
322345fd	532
2d4c5cbc LP	533	r = in_addr_to_string(AF_INET, (const union in_addr_union*) &rr->a.in_addr, &x);
	534	if (r < 0)
	535	return r;
322345fd	536
2d4c5cbc LP	537	s = strjoin(k, " ", x, NULL);
	538	if (!s)
	539	return -ENOMEM;
	540	break;
	541	}
322345fd	542
8db0d2f5 ZJS	543	case DNS_TYPE_AAAA:
8db0d2f5 ZJS	544	r = in_addr_to_string(AF_INET6, (const union in_addr_union*) &rr->aaaa.in6_addr, &t);
2d4c5cbc LP	545	if (r < 0)
2d4c5cbc LP	546	return r;
322345fd	547
8db0d2f5	548	s = strjoin(k, " ", t, NULL);
2d4c5cbc LP	549	if (!s)
	550	return -ENOMEM;
	551	break;
322345fd	552
2d4c5cbc LP	553	case DNS_TYPE_SOA:
	554	r = asprintf(&s, "%s %s %s %u %u %u %u %u",
	555	k,
	556	strna(rr->soa.mname),
	557	strna(rr->soa.rname),
	558	rr->soa.serial,
	559	rr->soa.refresh,
	560	rr->soa.retry,
	561	rr->soa.expire,
	562	rr->soa.minimum);
	563	if (r < 0)
	564	return -ENOMEM;
	565	break;
	566
946c7094 ZJS	567	case DNS_TYPE_MX:
	568	r = asprintf(&s, "%s %u %s",
	569	k,
	570	rr->mx.priority,
	571	rr->mx.exchange);
	572	if (r < 0)
	573	return -ENOMEM;
	574	break;
	575
8db0d2f5	576	case DNS_TYPE_LOC:
0dae31d4 ZJS	577	assert(rr->loc.version == 0);
0dae31d4 ZJS	578
8db0d2f5 ZJS	579	t = format_location(rr->loc.latitude,
	580	rr->loc.longitude,
	581	rr->loc.altitude,
	582	rr->loc.size,
	583	rr->loc.horiz_pre,
	584	rr->loc.vert_pre);
	585	if (!t)
0dae31d4 ZJS	586	return -ENOMEM;
0dae31d4 ZJS	587
8db0d2f5	588	s = strjoin(k, " ", t, NULL);
0dae31d4 ZJS	589	if (!s)
0dae31d4 ZJS	590	return -ENOMEM;
0dae31d4	591	break;
0dae31d4	592
8db0d2f5 ZJS	593	case DNS_TYPE_SSHFP:
	594	t = hexmem(rr->sshfp.key, rr->sshfp.key_size);
	595	if (!t)
42cc2eeb LP	596	return -ENOMEM;
	597
	598	r = asprintf(&s, "%s %u %u %s",
	599	k,
	600	rr->sshfp.algorithm,
	601	rr->sshfp.fptype,
8db0d2f5	602	t);
42cc2eeb LP	603	if (r < 0)
	604	return -ENOMEM;
	605	break;
42cc2eeb	606
ff3d6560 ZJS	607	case DNS_TYPE_DNSKEY: {
	608	const char *alg;
	609
	610	alg = dnssec_algorithm_to_string(rr->dnskey.algorithm);
	611
8db0d2f5 ZJS	612	t = hexmem(rr->dnskey.key, rr->dnskey.key_size);
	613	if (!t)
	614	return -ENOMEM;
2d4c5cbc	615
ff3d6560	616	r = asprintf(&s, "%s %u 3 %.s%.u %s",
8db0d2f5 ZJS	617	k,
8db0d2f5 ZJS	618	dnskey_to_flags(rr),
ff3d6560 ZJS	619	alg ? -1 : 0, alg,
ff3d6560 ZJS	620	alg ? 0 : 1, alg ? 0u : (unsigned) rr->dnskey.algorithm,
8db0d2f5 ZJS	621	t);
8db0d2f5 ZJS	622	if (r < 0)
2d4c5cbc	623	return -ENOMEM;
8db0d2f5	624	break;
ff3d6560	625	}
2d4c5cbc	626
151226ab ZJS	627	case DNS_TYPE_RRSIG: {
	628	const char type, alg;
	629
	630	type = dns_type_to_string(rr->rrsig.type_covered);
	631	alg = dnssec_algorithm_to_string(rr->rrsig.algorithm);
	632
	633	t = hexmem(rr->rrsig.signature, rr->rrsig.signature_size);
	634	if (!t)
	635	return -ENOMEM;
	636
	637	/* TYPE?? follows
	638	* http://tools.ietf.org/html/rfc3597#section-5 */
	639
	640	r = asprintf(&s, "%s %s%.u %.s%.*u %u %u %u %u %u %s %s",
	641	k,
	642	type ?: "TYPE",
	643	type ? 0 : 1, type ? 0u : (unsigned) rr->rrsig.type_covered,
	644	alg ? -1 : 0, alg,
	645	alg ? 0 : 1, alg ? 0u : (unsigned) rr->rrsig.algorithm,
	646	rr->rrsig.labels,
	647	rr->rrsig.original_ttl,
	648	rr->rrsig.expiration,
	649	rr->rrsig.inception,
	650	rr->rrsig.key_tag,
	651	rr->rrsig.signer,
	652	t);
	653	if (r < 0)
	654	return -ENOMEM;
	655	break;
	656	}
	657
8db0d2f5 ZJS	658	default:
	659	t = hexmem(rr->generic.data, rr->generic.size);
	660	if (!t)
	661	return -ENOMEM;
	662
	663	s = strjoin(k, " ", t, NULL);
2d4c5cbc LP	664	if (!s)
	665	return -ENOMEM;
	666	break;
8db0d2f5	667	}
2d4c5cbc LP	668
	669	*ret = s;
	670	return 0;
	671	}
322345fd	672
2d4c5cbc	673	const char *dns_class_to_string(uint16_t class) {
322345fd	674
2d4c5cbc	675	switch (class) {
322345fd	676
2d4c5cbc LP	677	case DNS_CLASS_IN:
2d4c5cbc LP	678	return "IN";
322345fd	679
2d4c5cbc LP	680	case DNS_CLASS_ANY:
	681	return "ANY";
	682	}
322345fd	683
2d4c5cbc LP	684	return NULL;
2d4c5cbc LP	685	}
322345fd	686
2d4c5cbc LP	687	int dns_class_from_string(const char s, uint16_t class) {
	688	assert(s);
	689	assert(class);
	690
	691	if (strcaseeq(s, "IN"))
	692	*class = DNS_CLASS_IN;
	693	else if (strcaseeq(s, "ANY"))
	694	*class = DNS_TYPE_ANY;
	695	else
	696	return -EINVAL;
322345fd	697
2d4c5cbc LP	698	return 0;
2d4c5cbc LP	699	}