[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 "strv.h"

#include "resolved-dns-domain.h"
#include "resolved-dns-rr.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;
        }

        s = strjoin(DNS_RESOURCE_KEY_NAME(key), " ", c, " ", t, NULL);
        if (!s)
                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_PTR:
                case DNS_TYPE_NS:
                case DNS_TYPE_CNAME:
                        free(rr->ptr.name);
                        break;
                case DNS_TYPE_HINFO:
                        free(rr->hinfo.cpu);
                        free(rr->hinfo.os);
                        break;
                case DNS_TYPE_SPF:
                case DNS_TYPE_TXT:
                        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_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;

        switch (a->key->type) {

        case DNS_TYPE_PTR:
        case DNS_TYPE_NS:
        case DNS_TYPE_CNAME:
                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);

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

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

        assert(rr);

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

        switch (rr->key->type) {

        case DNS_TYPE_PTR:
        case DNS_TYPE_NS:
        case DNS_TYPE_CNAME:
                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: {
                _cleanup_free_ char *t;

                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: {
                _cleanup_free_ char *x = NULL;

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

                s = strjoin(k, " ", x, 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;

        default: {
                _cleanup_free_ char *x = NULL;

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

                s = strjoin(k, " ", x, 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;
}

static const struct {
        uint16_t type;
        const char *name;
} dns_types[] = {
        { DNS_TYPE_A,     "A"     },
        { DNS_TYPE_NS,    "NS"    },
        { DNS_TYPE_CNAME, "CNAME" },
        { DNS_TYPE_SOA,   "SOA"   },
        { DNS_TYPE_PTR,   "PTR"   },
        { DNS_TYPE_HINFO, "HINFO" },
        { DNS_TYPE_MX,    "MX"    },
        { DNS_TYPE_TXT,   "TXT"   },
        { DNS_TYPE_AAAA,  "AAAA"  },
        { DNS_TYPE_SRV,   "SRV"   },
        { DNS_TYPE_SSHFP, "SSHFP" },
        { DNS_TYPE_SPF,   "SPF"   },
        { DNS_TYPE_DNAME, "DNAME" },
        { DNS_TYPE_ANY,   "ANY"   },
        { DNS_TYPE_OPT,   "OPT"   },
        { DNS_TYPE_TKEY,  "TKEY"  },
        { DNS_TYPE_TSIG,  "TSIG"  },
        { DNS_TYPE_IXFR,  "IXFR"  },
        { DNS_TYPE_AXFR,  "AXFR"  },
};


const char *dns_type_to_string(uint16_t type) {
        unsigned i;

        for (i = 0; i < ELEMENTSOF(dns_types); i++)
                if (dns_types[i].type == type)
                        return dns_types[i].name;

        return NULL;
}

int dns_type_from_string(const char *s, uint16_t *type) {
        unsigned i;

        assert(s);
        assert(type);

        for (i = 0; i < ELEMENTSOF(dns_types); i++)
                if (strcaseeq(dns_types[i].name, s)) {
                        *type = dns_types[i].type;
                        return 0;
                }

        return -EINVAL;
}
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
2e276efc ZJS	22	#include "strv.h"
2e276efc ZJS	23
322345fd	24	#include "resolved-dns-domain.h"
74b2466e LP	25	#include "resolved-dns-rr.h"
74b2466e LP	26
faa133f3 LP	27	DnsResourceKey* dns_resource_key_new(uint16_t class, uint16_t type, const char *name) {
	28	DnsResourceKey *k;
	29	size_t l;
74b2466e	30
faa133f3 LP	31	assert(name);
	32
	33	l = strlen(name);
	34	k = malloc0(sizeof(DnsResourceKey) + l + 1);
	35	if (!k)
	36	return NULL;
	37
	38	k->n_ref = 1;
	39	k->class = class;
	40	k->type = type;
	41
	42	strcpy((char*) k + sizeof(DnsResourceKey), name);
	43
	44	return k;
	45	}
	46
	47	DnsResourceKey* dns_resource_key_new_consume(uint16_t class, uint16_t type, char *name) {
	48	DnsResourceKey *k;
	49
	50	assert(name);
	51
	52	k = new0(DnsResourceKey, 1);
	53	if (!k)
	54	return NULL;
	55
	56	k->n_ref = 1;
	57	k->class = class;
	58	k->type = type;
	59	k->_name = name;
	60
	61	return k;
	62	}
	63
	64	DnsResourceKey* dns_resource_key_ref(DnsResourceKey *k) {
	65
	66	if (!k)
	67	return NULL;
	68
	69	assert(k->n_ref > 0);
	70	k->n_ref++;
	71
	72	return k;
	73	}
	74
	75	DnsResourceKey* dns_resource_key_unref(DnsResourceKey *k) {
	76	if (!k)
	77	return NULL;
	78
	79	assert(k->n_ref > 0);
	80
	81	if (k->n_ref == 1) {
	82	free(k->_name);
	83	free(k);
	84	} else
	85	k->n_ref--;
	86
	87	return NULL;
	88	}
	89
	90	int dns_resource_key_equal(const DnsResourceKey a, const DnsResourceKey b) {
	91	int r;
	92
	93	r = dns_name_equal(DNS_RESOURCE_KEY_NAME(a), DNS_RESOURCE_KEY_NAME(b));
	94	if (r <= 0)
95	return r;
96
97	if (a->class != b->class)
98	return 0;
99
100	if (a->type != b->type)
101	return 0;
102
103	return 1;
104	}
105
106	int dns_resource_key_match_rr(const DnsResourceKey key, const DnsResourceRecord rr) {
107	assert(key);
108	assert(rr);
109
110	if (rr->key->class != key->class && key->class != DNS_CLASS_ANY)
111	return 0;
112
113	if (rr->key->type != key->type && key->type != DNS_TYPE_ANY)
114	return 0;
115
116	return dns_name_equal(DNS_RESOURCE_KEY_NAME(rr->key), DNS_RESOURCE_KEY_NAME(key));
117	}
118
119	int dns_resource_key_match_cname(const DnsResourceKey key, const DnsResourceRecord rr) {
120	assert(key);
121	assert(rr);
122
123	if (rr->key->class != key->class && key->class != DNS_CLASS_ANY)
124	return 0;
125
126	if (rr->key->type != DNS_TYPE_CNAME)
127	return 0;
128
129	return dns_name_equal(DNS_RESOURCE_KEY_NAME(rr->key), DNS_RESOURCE_KEY_NAME(key));
74b2466e LP	130	}
74b2466e LP	131
322345fd LP	132	unsigned long dns_resource_key_hash_func(const void *i, const uint8_t hash_key[HASH_KEY_SIZE]) {
	133	const DnsResourceKey *k = i;
	134	unsigned long ul;
	135
faa133f3	136	ul = dns_name_hash_func(DNS_RESOURCE_KEY_NAME(k), hash_key);
322345fd LP	137	ul = ul * hash_key[0] + ul + k->class;
	138	ul = ul * hash_key[1] + ul + k->type;
	139
	140	return ul;
	141	}
	142
	143	int dns_resource_key_compare_func(const void a, const void b) {
	144	const DnsResourceKey x = a, y = b;
	145	int ret;
	146
faa133f3	147	ret = dns_name_compare_func(DNS_RESOURCE_KEY_NAME(x), DNS_RESOURCE_KEY_NAME(y));
322345fd LP	148	if (ret != 0)
	149	return ret;
	150
	151	if (x->type < y->type)
	152	return -1;
	153	if (x->type > y->type)
	154	return 1;
	155
	156	if (x->class < y->class)
	157	return -1;
	158	if (x->class > y->class)
	159	return 1;
	160
	161	return 0;
	162	}
	163
2d4c5cbc LP	164	int dns_resource_key_to_string(const DnsResourceKey key, char *ret) {
	165	char cbuf[DECIMAL_STR_MAX(uint16_t)], tbuf[DECIMAL_STR_MAX(uint16_t)];
	166	const char c, t;
	167	char *s;
	168
	169	c = dns_class_to_string(key->class);
	170	if (!c) {
	171	sprintf(cbuf, "%i", key->class);
	172	c = cbuf;
	173	}
	174
	175	t = dns_type_to_string(key->type);
	176	if (!t){
	177	sprintf(tbuf, "%i", key->type);
	178	t = tbuf;
	179	}
	180
	181	s = strjoin(DNS_RESOURCE_KEY_NAME(key), " ", c, " ", t, NULL);
	182	if (!s)
	183	return -ENOMEM;
	184
	185	*ret = s;
	186	return 0;
	187	}
	188
faa133f3	189	DnsResourceRecord* dns_resource_record_new(DnsResourceKey *key) {
74b2466e LP	190	DnsResourceRecord *rr;
	191
	192	rr = new0(DnsResourceRecord, 1);
	193	if (!rr)
	194	return NULL;
	195
	196	rr->n_ref = 1;
faa133f3 LP	197	rr->key = dns_resource_key_ref(key);
faa133f3 LP	198
74b2466e LP	199	return rr;
	200	}
	201
8bf52d3d LP	202	DnsResourceRecord* dns_resource_record_new_full(uint16_t class, uint16_t type, const char *name) {
	203	_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
	204
	205	key = dns_resource_key_new(class, type, name);
	206	if (!key)
	207	return NULL;
	208
	209	return dns_resource_record_new(key);
	210	}
	211
74b2466e LP	212	DnsResourceRecord* dns_resource_record_ref(DnsResourceRecord *rr) {
	213	if (!rr)
	214	return NULL;
	215
	216	assert(rr->n_ref > 0);
	217	rr->n_ref++;
	218
	219	return rr;
	220	}
	221
	222	DnsResourceRecord* dns_resource_record_unref(DnsResourceRecord *rr) {
	223	if (!rr)
	224	return NULL;
	225
	226	assert(rr->n_ref > 0);
	227
	228	if (rr->n_ref > 1) {
	229	rr->n_ref--;
	230	return NULL;
	231	}
	232
faa133f3	233	if (rr->key) {
9de3e329 ZJS	234	switch(rr->key->type) {
	235	case DNS_TYPE_PTR:
	236	case DNS_TYPE_NS:
	237	case DNS_TYPE_CNAME:
faa133f3	238	free(rr->ptr.name);
9de3e329 ZJS	239	break;
9de3e329 ZJS	240	case DNS_TYPE_HINFO:
faa133f3 LP	241	free(rr->hinfo.cpu);
faa133f3 LP	242	free(rr->hinfo.os);
9de3e329 ZJS	243	break;
	244	case DNS_TYPE_SPF:
	245	case DNS_TYPE_TXT:
2e276efc	246	strv_free(rr->txt.strings);
9de3e329 ZJS	247	break;
9de3e329 ZJS	248	case DNS_TYPE_SOA:
7e8e0422 LP	249	free(rr->soa.mname);
7e8e0422 LP	250	free(rr->soa.rname);
9de3e329 ZJS	251	break;
9de3e329 ZJS	252	case DNS_TYPE_MX:
946c7094	253	free(rr->mx.exchange);
9de3e329 ZJS	254	break;
	255	case DNS_TYPE_A:
	256	case DNS_TYPE_AAAA:
	257	break;
	258	default:
faa133f3	259	free(rr->generic.data);
9de3e329	260	}
322345fd	261
faa133f3 LP	262	dns_resource_key_unref(rr->key);
faa133f3 LP	263	}
322345fd	264
faa133f3	265	free(rr);
322345fd	266
322345fd LP	267	return NULL;
	268	}
	269
623a4c97 LP	270	int dns_resource_record_new_reverse(DnsResourceRecord *ret, int family, const union in_addr_union address, const char *hostname) {
	271	_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
	272	_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
	273	_cleanup_free_ char *ptr = NULL;
	274	int r;
	275
	276	assert(ret);
	277	assert(address);
	278	assert(hostname);
	279
	280	r = dns_name_reverse(family, address, &ptr);
	281	if (r < 0)
	282	return r;
	283
	284	key = dns_resource_key_new_consume(DNS_CLASS_IN, DNS_TYPE_PTR, ptr);
	285	if (!key)
	286	return -ENOMEM;
	287
	288	ptr = NULL;
	289
	290	rr = dns_resource_record_new(key);
	291	if (!rr)
	292	return -ENOMEM;
	293
	294	rr->ptr.name = strdup(hostname);
	295	if (!rr->ptr.name)
	296	return -ENOMEM;
	297
	298	*ret = rr;
	299	rr = NULL;
	300
	301	return 0;
	302	}
	303
322345fd LP	304	int dns_resource_record_equal(const DnsResourceRecord a, const DnsResourceRecord b) {
	305	int r;
	306
	307	assert(a);
	308	assert(b);
	309
faa133f3	310	r = dns_resource_key_equal(a->key, b->key);
322345fd LP	311	if (r <= 0)
	312	return r;
	313
2d4c5cbc LP	314	switch (a->key->type) {
	315
	316	case DNS_TYPE_PTR:
	317	case DNS_TYPE_NS:
	318	case DNS_TYPE_CNAME:
322345fd	319	return dns_name_equal(a->ptr.name, b->ptr.name);
2d4c5cbc LP	320
	321	case DNS_TYPE_HINFO:
	322	return strcaseeq(a->hinfo.cpu, b->hinfo.cpu) &&
	323	strcaseeq(a->hinfo.os, b->hinfo.os);
	324
9de3e329	325	case DNS_TYPE_SPF: /* exactly the same as TXT */
2e276efc ZJS	326	case DNS_TYPE_TXT: {
	327	int i;
	328
	329	for (i = 0; a->txt.strings[i] \|\| b->txt.strings[i]; i++)
	330	if (!streq_ptr(a->txt.strings[i], b->txt.strings[i]))
	331	return false;
	332	return true;
	333	}
	334
2d4c5cbc	335	case DNS_TYPE_A:
322345fd	336	return memcmp(&a->a.in_addr, &b->a.in_addr, sizeof(struct in_addr)) == 0;
2d4c5cbc LP	337
2d4c5cbc LP	338	case DNS_TYPE_AAAA:
322345fd	339	return memcmp(&a->aaaa.in6_addr, &b->aaaa.in6_addr, sizeof(struct in6_addr)) == 0;
2d4c5cbc LP	340
2d4c5cbc LP	341	case DNS_TYPE_SOA:
7e8e0422 LP	342	r = dns_name_equal(a->soa.mname, b->soa.mname);
	343	if (r <= 0)
	344	return r;
	345	r = dns_name_equal(a->soa.rname, b->soa.rname);
	346	if (r <= 0)
	347	return r;
	348
	349	return a->soa.serial == b->soa.serial &&
	350	a->soa.refresh == b->soa.refresh &&
	351	a->soa.retry == b->soa.retry &&
	352	a->soa.expire == b->soa.expire &&
	353	a->soa.minimum == b->soa.minimum;
946c7094 ZJS	354	case DNS_TYPE_MX:
	355	if (a->mx.priority != b->mx.priority)
	356	return 0;
	357
	358	return dns_name_equal(a->mx.exchange, b->mx.exchange);
	359
2d4c5cbc	360	default:
322345fd LP	361	return a->generic.size == b->generic.size &&
322345fd LP	362	memcmp(a->generic.data, b->generic.data, a->generic.size) == 0;
2d4c5cbc	363	}
322345fd LP	364	}
322345fd LP	365
2d4c5cbc LP	366	int dns_resource_record_to_string(const DnsResourceRecord rr, char *ret) {
	367	_cleanup_free_ char *k = NULL;
	368	char *s;
	369	int r;
322345fd	370
2d4c5cbc	371	assert(rr);
322345fd	372
2d4c5cbc LP	373	r = dns_resource_key_to_string(rr->key, &k);
	374	if (r < 0)
	375	return r;
322345fd	376
2d4c5cbc	377	switch (rr->key->type) {
322345fd	378
2d4c5cbc LP	379	case DNS_TYPE_PTR:
	380	case DNS_TYPE_NS:
	381	case DNS_TYPE_CNAME:
	382	s = strjoin(k, " ", rr->ptr.name, NULL);
	383	if (!s)
	384	return -ENOMEM;
322345fd	385
2d4c5cbc	386	break;
322345fd	387
2d4c5cbc LP	388	case DNS_TYPE_HINFO:
	389	s = strjoin(k, " ", rr->hinfo.cpu, " ", rr->hinfo.os, NULL);
	390	if (!s)
	391	return -ENOMEM;
	392	break;
322345fd	393
9de3e329	394	case DNS_TYPE_SPF: /* exactly the same as TXT */
2e276efc ZJS	395	case DNS_TYPE_TXT: {
	396	_cleanup_free_ char *t;
	397
	398	t = strv_join_quoted(rr->txt.strings);
	399	if (!t)
	400	return -ENOMEM;
	401
	402	s = strjoin(k, " ", t, NULL);
	403	if (!s)
	404	return -ENOMEM;
	405
	406	break;
	407	}
	408
2d4c5cbc LP	409	case DNS_TYPE_A: {
2d4c5cbc LP	410	_cleanup_free_ char *x = NULL;
322345fd	411
2d4c5cbc LP	412	r = in_addr_to_string(AF_INET, (const union in_addr_union*) &rr->a.in_addr, &x);
	413	if (r < 0)
	414	return r;
322345fd	415
2d4c5cbc LP	416	s = strjoin(k, " ", x, NULL);
	417	if (!s)
	418	return -ENOMEM;
	419	break;
	420	}
322345fd	421
2d4c5cbc LP	422	case DNS_TYPE_AAAA: {
2d4c5cbc LP	423	_cleanup_free_ char *x = NULL;
322345fd	424
2d4c5cbc LP	425	r = in_addr_to_string(AF_INET6, (const union in_addr_union*) &rr->aaaa.in6_addr, &x);
	426	if (r < 0)
	427	return r;
322345fd	428
2d4c5cbc LP	429	s = strjoin(k, " ", x, NULL);
	430	if (!s)
	431	return -ENOMEM;
	432	break;
	433	}
322345fd	434
2d4c5cbc LP	435	case DNS_TYPE_SOA:
	436	r = asprintf(&s, "%s %s %s %u %u %u %u %u",
	437	k,
	438	strna(rr->soa.mname),
	439	strna(rr->soa.rname),
	440	rr->soa.serial,
	441	rr->soa.refresh,
	442	rr->soa.retry,
	443	rr->soa.expire,
	444	rr->soa.minimum);
	445	if (r < 0)
	446	return -ENOMEM;
	447	break;
	448
946c7094 ZJS	449	case DNS_TYPE_MX:
	450	r = asprintf(&s, "%s %u %s",
	451	k,
	452	rr->mx.priority,
	453	rr->mx.exchange);
	454	if (r < 0)
	455	return -ENOMEM;
	456	break;
	457
2d4c5cbc LP	458	default: {
	459	_cleanup_free_ char *x = NULL;
	460
	461	x = hexmem(rr->generic.data, rr->generic.size);
	462	if (!x)
	463	return -ENOMEM;
	464
	465	s = strjoin(k, " ", x, NULL);
	466	if (!s)
	467	return -ENOMEM;
	468	break;
	469	}}
	470
	471	*ret = s;
	472	return 0;
	473	}
322345fd	474
2d4c5cbc	475	const char *dns_class_to_string(uint16_t class) {
322345fd	476
2d4c5cbc	477	switch (class) {
322345fd	478
2d4c5cbc LP	479	case DNS_CLASS_IN:
2d4c5cbc LP	480	return "IN";
322345fd	481
2d4c5cbc LP	482	case DNS_CLASS_ANY:
	483	return "ANY";
	484	}
322345fd	485
2d4c5cbc LP	486	return NULL;
2d4c5cbc LP	487	}
322345fd	488
2d4c5cbc LP	489	int dns_class_from_string(const char s, uint16_t class) {
	490	assert(s);
	491	assert(class);
	492
	493	if (strcaseeq(s, "IN"))
	494	*class = DNS_CLASS_IN;
	495	else if (strcaseeq(s, "ANY"))
	496	*class = DNS_TYPE_ANY;
	497	else
	498	return -EINVAL;
322345fd	499
2d4c5cbc LP	500	return 0;
2d4c5cbc LP	501	}
322345fd	502
2d4c5cbc LP	503	static const struct {
	504	uint16_t type;
	505	const char *name;
	506	} dns_types[] = {
	507	{ DNS_TYPE_A, "A" },
	508	{ DNS_TYPE_NS, "NS" },
	509	{ DNS_TYPE_CNAME, "CNAME" },
	510	{ DNS_TYPE_SOA, "SOA" },
	511	{ DNS_TYPE_PTR, "PTR" },
	512	{ DNS_TYPE_HINFO, "HINFO" },
	513	{ DNS_TYPE_MX, "MX" },
	514	{ DNS_TYPE_TXT, "TXT" },
	515	{ DNS_TYPE_AAAA, "AAAA" },
	516	{ DNS_TYPE_SRV, "SRV" },
	517	{ DNS_TYPE_SSHFP, "SSHFP" },
9de3e329	518	{ DNS_TYPE_SPF, "SPF" },
2d4c5cbc LP	519	{ DNS_TYPE_DNAME, "DNAME" },
	520	{ DNS_TYPE_ANY, "ANY" },
	521	{ DNS_TYPE_OPT, "OPT" },
	522	{ DNS_TYPE_TKEY, "TKEY" },
	523	{ DNS_TYPE_TSIG, "TSIG" },
	524	{ DNS_TYPE_IXFR, "IXFR" },
	525	{ DNS_TYPE_AXFR, "AXFR" },
	526	};
322345fd	527
322345fd	528
2d4c5cbc LP	529	const char *dns_type_to_string(uint16_t type) {
2d4c5cbc LP	530	unsigned i;
322345fd	531
2d4c5cbc LP	532	for (i = 0; i < ELEMENTSOF(dns_types); i++)
	533	if (dns_types[i].type == type)
	534	return dns_types[i].name;
322345fd LP	535
	536	return NULL;
	537	}
2d4c5cbc LP	538
	539	int dns_type_from_string(const char s, uint16_t type) {
	540	unsigned i;
	541
	542	assert(s);
	543	assert(type);
	544
	545	for (i = 0; i < ELEMENTSOF(dns_types); i++)
	546	if (strcaseeq(dns_types[i].name, s)) {
	547	*type = dns_types[i].type;
	548	return 0;
	549	}
	550
	551	return -EINVAL;
	552	}