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

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <stdio.h>

#include "alloc-util.h"
#include "dns-domain.h"
#include "dns-type.h"
#include "resolved-dns-question.h"
#include "resolved-dns-rr.h"
#include "socket-util.h"
#include "string-util.h"

DnsQuestion *dns_question_new(size_t n) {
        DnsQuestion *q;

        if (n > UINT16_MAX) /* We can only place 64K key in an question section at max */
                n = UINT16_MAX;

        q = malloc0(offsetof(DnsQuestion, items) + sizeof(DnsQuestionItem) * n);
        if (!q)
                return NULL;

        q->n_ref = 1;
        q->n_allocated = n;

        return q;
}

static DnsQuestion *dns_question_free(DnsQuestion *q) {
        DnsResourceKey *key;

        assert(q);

        DNS_QUESTION_FOREACH(key, q)
                dns_resource_key_unref(key);

        return mfree(q);
}

DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsQuestion, dns_question, dns_question_free);

int dns_question_add_raw(DnsQuestion *q, DnsResourceKey *key, DnsQuestionFlags flags) {
        /* Insert without checking for duplicates. */

        assert(key);
        assert(q);

        if (q->n_keys >= q->n_allocated)
                return -ENOSPC;

        q->items[q->n_keys++] = (DnsQuestionItem) {
                .key = dns_resource_key_ref(key),
                .flags = flags,
        };
        return 0;
}

static int dns_question_add_raw_all(DnsQuestion *a, DnsQuestion *b) {
        DnsQuestionItem *item;
        int r;

        DNS_QUESTION_FOREACH_ITEM(item, b) {
                r = dns_question_add_raw(a, item->key, item->flags);
                if (r < 0)
                        return r;
        }

        return 0;
}

int dns_question_add(DnsQuestion *q, DnsResourceKey *key, DnsQuestionFlags flags) {
        DnsQuestionItem *item;
        int r;

        assert(key);

        if (!q)
                return -ENOSPC;

        DNS_QUESTION_FOREACH_ITEM(item, q) {
                r = dns_resource_key_equal(item->key, key);
                if (r < 0)
                        return r;
                if (r > 0 && item->flags == flags)
                        return 0;
        }

        return dns_question_add_raw(q, key, flags);
}

static int dns_question_add_all(DnsQuestion *a, DnsQuestion *b) {
        DnsQuestionItem *item;
        int r;

        DNS_QUESTION_FOREACH_ITEM(item, b) {
                r = dns_question_add(a, item->key, item->flags);
                if (r < 0)
                        return r;
        }

        return 0;
}

int dns_question_matches_rr(DnsQuestion *q, DnsResourceRecord *rr, const char *search_domain) {
        DnsResourceKey *key;
        int r;

        assert(rr);

        if (!q)
                return 0;

        DNS_QUESTION_FOREACH(key, q) {
                r = dns_resource_key_match_rr(key, rr, search_domain);
                if (r != 0)
                        return r;
        }

        return 0;
}

int dns_question_matches_cname_or_dname(DnsQuestion *q, DnsResourceRecord *rr, const char *search_domain) {
        DnsResourceKey *key;
        int r;

        assert(rr);

        if (!q)
                return 0;

        if (!IN_SET(rr->key->type, DNS_TYPE_CNAME, DNS_TYPE_DNAME))
                return 0;

        DNS_QUESTION_FOREACH(key, q) {
                /* For a {C,D}NAME record we can never find a matching {C,D}NAME record */
                if (!dns_type_may_redirect(key->type))
                        return 0;

                r = dns_resource_key_match_cname_or_dname(key, rr->key, search_domain);
                if (r != 0)
                        return r;
        }

        return 0;
}

int dns_question_is_valid_for_query(DnsQuestion *q) {
        const char *name;
        size_t i;
        int r;

        if (!q)
                return 0;

        if (q->n_keys <= 0)
                return 0;

        if (q->n_keys > 65535)
                return 0;

        name = dns_resource_key_name(q->items[0].key);
        if (!name)
                return 0;

        /* Check that all keys in this question bear the same name */
        for (i = 0; i < q->n_keys; i++) {
                assert(q->items[i].key);

                if (i > 0) {
                        r = dns_name_equal(dns_resource_key_name(q->items[i].key), name);
                        if (r <= 0)
                                return r;
                }

                if (!dns_type_is_valid_query(q->items[i].key->type))
                        return 0;
        }

        return 1;
}

int dns_question_contains_key(DnsQuestion *q, const DnsResourceKey *k) {
        size_t j;
        int r;

        assert(k);

        if (!q)
                return 0;

        for (j = 0; j < q->n_keys; j++) {
                r = dns_resource_key_equal(q->items[j].key, k);
                if (r != 0)
                        return r;
        }

        return 0;
}

static int dns_question_contains_item(DnsQuestion *q, const DnsQuestionItem *i) {
        DnsQuestionItem *item;
        int r;

        assert(i);

        DNS_QUESTION_FOREACH_ITEM(item, q) {
                if (item->flags != i->flags)
                        continue;
                r = dns_resource_key_equal(item->key, i->key);
                if (r != 0)
                        return r;
        }

        return false;
}

int dns_question_is_equal(DnsQuestion *a, DnsQuestion *b) {
        DnsQuestionItem *item;
        int r;

        if (a == b)
                return 1;

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

        /* Checks if all items in a are also contained b, and vice versa */

        DNS_QUESTION_FOREACH_ITEM(item, a) {
                r = dns_question_contains_item(b, item);
                if (r <= 0)
                        return r;
        }
        DNS_QUESTION_FOREACH_ITEM(item, b) {
                r = dns_question_contains_item(a, item);
                if (r <= 0)
                        return r;
        }

        return 1;
}

int dns_question_cname_redirect(DnsQuestion *q, const DnsResourceRecord *cname, DnsQuestion **ret) {
        _cleanup_(dns_question_unrefp) DnsQuestion *n = NULL;
        DnsResourceKey *key;
        bool same = true;
        int r;

        assert(cname);
        assert(ret);
        assert(IN_SET(cname->key->type, DNS_TYPE_CNAME, DNS_TYPE_DNAME));

        if (dns_question_size(q) <= 0) {
                *ret = NULL;
                return 0;
        }

        DNS_QUESTION_FOREACH(key, q) {
                _cleanup_free_ char *destination = NULL;
                const char *d;

                if (cname->key->type == DNS_TYPE_CNAME)
                        d = cname->cname.name;
                else {
                        r = dns_name_change_suffix(dns_resource_key_name(key), dns_resource_key_name(cname->key), cname->dname.name, &destination);
                        if (r < 0)
                                return r;
                        if (r == 0)
                                continue;

                        d = destination;
                }

                r = dns_name_equal(dns_resource_key_name(key), d);
                if (r < 0)
                        return r;

                if (r == 0) {
                        same = false;
                        break;
                }
        }

        /* Fully the same, indicate we didn't do a thing */
        if (same) {
                *ret = NULL;
                return 0;
        }

        n = dns_question_new(q->n_keys);
        if (!n)
                return -ENOMEM;

        /* Create a new question, and patch in the new name */
        DNS_QUESTION_FOREACH(key, q) {
                _cleanup_(dns_resource_key_unrefp) DnsResourceKey *k = NULL;

                k = dns_resource_key_new_redirect(key, cname);
                if (!k)
                        return -ENOMEM;

                r = dns_question_add(n, k, 0);
                if (r < 0)
                        return r;
        }

        *ret = TAKE_PTR(n);

        return 1;
}

const char* dns_question_first_name(DnsQuestion *q) {

        if (!q)
                return NULL;

        if (q->n_keys < 1)
                return NULL;

        return dns_resource_key_name(q->items[0].key);
}

int dns_question_new_address(DnsQuestion **ret, int family, const char *name, bool convert_idna) {
        _cleanup_(dns_question_unrefp) DnsQuestion *q = NULL;
        _cleanup_free_ char *buf = NULL;
        int r;

        assert(ret);
        assert(name);

        if (!IN_SET(family, AF_INET, AF_INET6, AF_UNSPEC))
                return -EAFNOSUPPORT;

        /* If IPv6 is off and the request has an unspecified lookup family, restrict it automatically to
         * IPv4. */
        if (family == AF_UNSPEC && !socket_ipv6_is_enabled())
                family = AF_INET;

        if (convert_idna) {
                r = dns_name_apply_idna(name, &buf);
                if (r < 0)
                        return r;
                if (r > 0 && !streq(name, buf))
                        name = buf;
                else
                        /* We did not manage to create convert the idna name, or it's
                         * the same as the original name. We assume the caller already
                         * created an unconverted question, so let's not repeat work
                         * unnecessarily. */
                        return -EALREADY;
        }

        q = dns_question_new(family == AF_UNSPEC ? 2 : 1);
        if (!q)
                return -ENOMEM;

        if (family != AF_INET6) {
                _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;

                key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, name);
                if (!key)
                        return -ENOMEM;

                r = dns_question_add(q, key, 0);
                if (r < 0)
                        return r;
        }

        if (family != AF_INET) {
                _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;

                key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_AAAA, name);
                if (!key)
                        return -ENOMEM;

                r = dns_question_add(q, key, 0);
                if (r < 0)
                        return r;
        }

        *ret = TAKE_PTR(q);

        return 0;
}

int dns_question_new_reverse(DnsQuestion **ret, int family, const union in_addr_union *a) {
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
        _cleanup_(dns_question_unrefp) DnsQuestion *q = NULL;
        _cleanup_free_ char *reverse = NULL;
        int r;

        assert(ret);
        assert(a);

        if (!IN_SET(family, AF_INET, AF_INET6, AF_UNSPEC))
                return -EAFNOSUPPORT;

        r = dns_name_reverse(family, a, &reverse);
        if (r < 0)
                return r;

        q = dns_question_new(1);
        if (!q)
                return -ENOMEM;

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

        reverse = NULL;

        r = dns_question_add(q, key, 0);
        if (r < 0)
                return r;

        *ret = TAKE_PTR(q);

        return 0;
}

int dns_question_new_service(
                DnsQuestion **ret,
                const char *service,
                const char *type,
                const char *domain,
                bool with_txt,
                bool convert_idna) {

        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
        _cleanup_(dns_question_unrefp) DnsQuestion *q = NULL;
        _cleanup_free_ char *buf = NULL, *joined = NULL;
        const char *name;
        int r;

        assert(ret);

        /* We support three modes of invocation:
         *
         * 1. Only a domain is specified, in which case we assume a properly encoded SRV RR name, including service
         *    type and possibly a service name. If specified in this way we assume it's already IDNA converted if
         *    that's necessary.
         *
         * 2. Both service type and a domain specified, in which case a normal SRV RR is assumed, without a DNS-SD
         *    style prefix. In this case we'll IDNA convert the domain, if that's requested.
         *
         * 3. All three of service name, type and domain are specified, in which case a DNS-SD service is put
         *    together. The service name is never IDNA converted, and the domain is if requested.
         *
         * It's not supported to specify a service name without a type, or no domain name.
         */

        if (!domain)
                return -EINVAL;

        if (type) {
                if (convert_idna) {
                        r = dns_name_apply_idna(domain, &buf);
                        if (r < 0)
                                return r;
                        if (r > 0)
                                domain = buf;
                }

                r = dns_service_join(service, type, domain, &joined);
                if (r < 0)
                        return r;

                name = joined;
        } else {
                if (service)
                        return -EINVAL;

                name = domain;
        }

        q = dns_question_new(1 + with_txt);
        if (!q)
                return -ENOMEM;

        key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_SRV, name);
        if (!key)
                return -ENOMEM;

        r = dns_question_add(q, key, 0);
        if (r < 0)
                return r;

        if (with_txt) {
                dns_resource_key_unref(key);
                key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_TXT, name);
                if (!key)
                        return -ENOMEM;

                r = dns_question_add(q, key, 0);
                if (r < 0)
                        return r;
        }

        *ret = TAKE_PTR(q);

        return 0;
}

/*
 * This function is not used in the code base, but is useful when debugging. Do not delete.
 */
void dns_question_dump(DnsQuestion *question, FILE *f) {
        DnsResourceKey *k;

        if (!f)
                f = stdout;

        DNS_QUESTION_FOREACH(k, question) {
                char buf[DNS_RESOURCE_KEY_STRING_MAX];

                fputc('\t', f);
                fputs(dns_resource_key_to_string(k, buf, sizeof(buf)), f);
                fputc('\n', f);
        }
}

int dns_question_merge(DnsQuestion *a, DnsQuestion *b, DnsQuestion **ret) {
        _cleanup_(dns_question_unrefp) DnsQuestion *k = NULL;
        int r;

        assert(ret);

        if (a == b || dns_question_size(b) <= 0) {
                *ret = dns_question_ref(a);
                return 0;
        }

        if (dns_question_size(a) <= 0) {
                *ret = dns_question_ref(b);
                return 0;
        }

        k = dns_question_new(dns_question_size(a) + dns_question_size(b));
        if (!k)
                return -ENOMEM;

        r = dns_question_add_raw_all(k, a);
        if (r < 0)
                return r;

        r = dns_question_add_all(k, b);
        if (r < 0)
                return r;

        *ret = TAKE_PTR(k);
        return 0;
}

bool dns_question_contains_key_type(DnsQuestion *q, uint16_t type) {
        DnsResourceKey *t;
        DNS_QUESTION_FOREACH(t, q)
                if (t->type == type)
                        return true;

        return false;
}
Commit	Line	Data
	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
	2
	3	#include <stdio.h>
	4
	5	#include "alloc-util.h"
	6	#include "dns-domain.h"
	7	#include "dns-type.h"
	8	#include "resolved-dns-question.h"
	9	#include "resolved-dns-rr.h"
	10	#include "socket-util.h"
	11	#include "string-util.h"
	12
	13	DnsQuestion *dns_question_new(size_t n) {
	14	DnsQuestion *q;
	15
	16	if (n > UINT16_MAX) /* We can only place 64K key in an question section at max */
	17	n = UINT16_MAX;
	18
	19	q = malloc0(offsetof(DnsQuestion, items) + sizeof(DnsQuestionItem) * n);
	20	if (!q)
	21	return NULL;
	22
	23	q->n_ref = 1;
	24	q->n_allocated = n;
	25
	26	return q;
	27	}
	28
	29	static DnsQuestion dns_question_free(DnsQuestion q) {
	30	DnsResourceKey *key;
	31
	32	assert(q);
	33
	34	DNS_QUESTION_FOREACH(key, q)
	35	dns_resource_key_unref(key);
	36
	37	return mfree(q);
	38	}
	39
	40	DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsQuestion, dns_question, dns_question_free);
	41
	42	int dns_question_add_raw(DnsQuestion q, DnsResourceKey key, DnsQuestionFlags flags) {
	43	/* Insert without checking for duplicates. */
	44
	45	assert(key);
	46	assert(q);
	47
	48	if (q->n_keys >= q->n_allocated)
	49	return -ENOSPC;
	50
	51	q->items[q->n_keys++] = (DnsQuestionItem) {
	52	.key = dns_resource_key_ref(key),
	53	.flags = flags,
	54	};
	55	return 0;
	56	}
	57
	58	static int dns_question_add_raw_all(DnsQuestion a, DnsQuestion b) {
	59	DnsQuestionItem *item;
	60	int r;
	61
	62	DNS_QUESTION_FOREACH_ITEM(item, b) {
	63	r = dns_question_add_raw(a, item->key, item->flags);
	64	if (r < 0)
	65	return r;
	66	}
	67
	68	return 0;
	69	}
	70
	71	int dns_question_add(DnsQuestion q, DnsResourceKey key, DnsQuestionFlags flags) {
	72	DnsQuestionItem *item;
	73	int r;
	74
	75	assert(key);
	76
	77	if (!q)
	78	return -ENOSPC;
	79
	80	DNS_QUESTION_FOREACH_ITEM(item, q) {
	81	r = dns_resource_key_equal(item->key, key);
	82	if (r < 0)
	83	return r;
	84	if (r > 0 && item->flags == flags)
	85	return 0;
	86	}
	87
	88	return dns_question_add_raw(q, key, flags);
	89	}
	90
	91	static int dns_question_add_all(DnsQuestion a, DnsQuestion b) {
	92	DnsQuestionItem *item;
	93	int r;
	94
	95	DNS_QUESTION_FOREACH_ITEM(item, b) {
	96	r = dns_question_add(a, item->key, item->flags);
	97	if (r < 0)
	98	return r;
	99	}
	100
	101	return 0;
	102	}
	103
	104	int dns_question_matches_rr(DnsQuestion q, DnsResourceRecord rr, const char *search_domain) {
	105	DnsResourceKey *key;
	106	int r;
	107
	108	assert(rr);
	109
	110	if (!q)
	111	return 0;
	112
	113	DNS_QUESTION_FOREACH(key, q) {
	114	r = dns_resource_key_match_rr(key, rr, search_domain);
	115	if (r != 0)
	116	return r;
	117	}
	118
	119	return 0;
	120	}
	121
	122	int dns_question_matches_cname_or_dname(DnsQuestion q, DnsResourceRecord rr, const char *search_domain) {
	123	DnsResourceKey *key;
	124	int r;
	125
	126	assert(rr);
	127
	128	if (!q)
	129	return 0;
	130
	131	if (!IN_SET(rr->key->type, DNS_TYPE_CNAME, DNS_TYPE_DNAME))
	132	return 0;
	133
	134	DNS_QUESTION_FOREACH(key, q) {
	135	/* For a {C,D}NAME record we can never find a matching {C,D}NAME record */
	136	if (!dns_type_may_redirect(key->type))
	137	return 0;
	138
	139	r = dns_resource_key_match_cname_or_dname(key, rr->key, search_domain);
	140	if (r != 0)
	141	return r;
	142	}
	143
	144	return 0;
	145	}
	146
	147	int dns_question_is_valid_for_query(DnsQuestion *q) {
	148	const char *name;
	149	size_t i;
	150	int r;
	151
	152	if (!q)
	153	return 0;
	154
	155	if (q->n_keys <= 0)
	156	return 0;
	157
	158	if (q->n_keys > 65535)
	159	return 0;
	160
	161	name = dns_resource_key_name(q->items[0].key);
	162	if (!name)
	163	return 0;
	164
	165	/* Check that all keys in this question bear the same name */
	166	for (i = 0; i < q->n_keys; i++) {
	167	assert(q->items[i].key);
	168
	169	if (i > 0) {
	170	r = dns_name_equal(dns_resource_key_name(q->items[i].key), name);
	171	if (r <= 0)
	172	return r;
	173	}
	174
	175	if (!dns_type_is_valid_query(q->items[i].key->type))
	176	return 0;
	177	}
	178
	179	return 1;
	180	}
	181
	182	int dns_question_contains_key(DnsQuestion q, const DnsResourceKey k) {
	183	size_t j;
	184	int r;
	185
	186	assert(k);
	187
	188	if (!q)
	189	return 0;
	190
	191	for (j = 0; j < q->n_keys; j++) {
	192	r = dns_resource_key_equal(q->items[j].key, k);
	193	if (r != 0)
	194	return r;
	195	}
	196
	197	return 0;
	198	}
	199
	200	static int dns_question_contains_item(DnsQuestion q, const DnsQuestionItem i) {
	201	DnsQuestionItem *item;
	202	int r;
	203
	204	assert(i);
	205
	206	DNS_QUESTION_FOREACH_ITEM(item, q) {
	207	if (item->flags != i->flags)
	208	continue;
	209	r = dns_resource_key_equal(item->key, i->key);
	210	if (r != 0)
	211	return r;
	212	}
	213
	214	return false;
	215	}
	216
	217	int dns_question_is_equal(DnsQuestion a, DnsQuestion b) {
	218	DnsQuestionItem *item;
	219	int r;
	220
	221	if (a == b)
	222	return 1;
	223
	224	if (!a)
	225	return !b \|\| b->n_keys == 0;
	226	if (!b)
	227	return a->n_keys == 0;
	228
	229	/* Checks if all items in a are also contained b, and vice versa */
	230
	231	DNS_QUESTION_FOREACH_ITEM(item, a) {
	232	r = dns_question_contains_item(b, item);
	233	if (r <= 0)
	234	return r;
	235	}
	236	DNS_QUESTION_FOREACH_ITEM(item, b) {
	237	r = dns_question_contains_item(a, item);
	238	if (r <= 0)
	239	return r;
	240	}
	241
	242	return 1;
	243	}
	244
	245	int dns_question_cname_redirect(DnsQuestion q, const DnsResourceRecord cname, DnsQuestion **ret) {
	246	_cleanup_(dns_question_unrefp) DnsQuestion *n = NULL;
	247	DnsResourceKey *key;
	248	bool same = true;
	249	int r;
	250
	251	assert(cname);
	252	assert(ret);
	253	assert(IN_SET(cname->key->type, DNS_TYPE_CNAME, DNS_TYPE_DNAME));
	254
	255	if (dns_question_size(q) <= 0) {
	256	*ret = NULL;
	257	return 0;
	258	}
	259
	260	DNS_QUESTION_FOREACH(key, q) {
	261	_cleanup_free_ char *destination = NULL;
	262	const char *d;
	263
	264	if (cname->key->type == DNS_TYPE_CNAME)
	265	d = cname->cname.name;
	266	else {
	267	r = dns_name_change_suffix(dns_resource_key_name(key), dns_resource_key_name(cname->key), cname->dname.name, &destination);
	268	if (r < 0)
	269	return r;
	270	if (r == 0)
	271	continue;
	272
	273	d = destination;
	274	}
	275
	276	r = dns_name_equal(dns_resource_key_name(key), d);
	277	if (r < 0)
	278	return r;
	279
	280	if (r == 0) {
	281	same = false;
	282	break;
	283	}
	284	}
	285
	286	/* Fully the same, indicate we didn't do a thing */
	287	if (same) {
	288	*ret = NULL;
	289	return 0;
	290	}
	291
	292	n = dns_question_new(q->n_keys);
	293	if (!n)
	294	return -ENOMEM;
	295
	296	/* Create a new question, and patch in the new name */
	297	DNS_QUESTION_FOREACH(key, q) {
	298	_cleanup_(dns_resource_key_unrefp) DnsResourceKey *k = NULL;
	299
	300	k = dns_resource_key_new_redirect(key, cname);
	301	if (!k)
	302	return -ENOMEM;
	303
	304	r = dns_question_add(n, k, 0);
	305	if (r < 0)
	306	return r;
	307	}
	308
	309	*ret = TAKE_PTR(n);
	310
	311	return 1;
	312	}
	313
	314	const char* dns_question_first_name(DnsQuestion *q) {
	315
	316	if (!q)
	317	return NULL;
	318
	319	if (q->n_keys < 1)
	320	return NULL;
	321
	322	return dns_resource_key_name(q->items[0].key);
	323	}
	324
	325	int dns_question_new_address(DnsQuestion *ret, int family, const char name, bool convert_idna) {
	326	_cleanup_(dns_question_unrefp) DnsQuestion *q = NULL;
	327	_cleanup_free_ char *buf = NULL;
	328	int r;
	329
	330	assert(ret);
	331	assert(name);
	332
	333	if (!IN_SET(family, AF_INET, AF_INET6, AF_UNSPEC))
	334	return -EAFNOSUPPORT;
	335
	336	/* If IPv6 is off and the request has an unspecified lookup family, restrict it automatically to
	337	* IPv4. */
	338	if (family == AF_UNSPEC && !socket_ipv6_is_enabled())
	339	family = AF_INET;
	340
	341	if (convert_idna) {
	342	r = dns_name_apply_idna(name, &buf);
	343	if (r < 0)
	344	return r;
	345	if (r > 0 && !streq(name, buf))
	346	name = buf;
	347	else
	348	/* We did not manage to create convert the idna name, or it's
	349	* the same as the original name. We assume the caller already
	350	* created an unconverted question, so let's not repeat work
	351	* unnecessarily. */
	352	return -EALREADY;
	353	}
	354
	355	q = dns_question_new(family == AF_UNSPEC ? 2 : 1);
	356	if (!q)
	357	return -ENOMEM;
	358
	359	if (family != AF_INET6) {
	360	_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
	361
	362	key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, name);
	363	if (!key)
	364	return -ENOMEM;
	365
	366	r = dns_question_add(q, key, 0);
	367	if (r < 0)
	368	return r;
	369	}
	370
	371	if (family != AF_INET) {
	372	_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
	373
	374	key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_AAAA, name);
	375	if (!key)
	376	return -ENOMEM;
	377
	378	r = dns_question_add(q, key, 0);
	379	if (r < 0)
	380	return r;
	381	}
	382
	383	*ret = TAKE_PTR(q);
	384
	385	return 0;
	386	}
	387
	388	int dns_question_new_reverse(DnsQuestion *ret, int family, const union in_addr_union a) {
	389	_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
	390	_cleanup_(dns_question_unrefp) DnsQuestion *q = NULL;
	391	_cleanup_free_ char *reverse = NULL;
	392	int r;
	393
	394	assert(ret);
	395	assert(a);
	396
	397	if (!IN_SET(family, AF_INET, AF_INET6, AF_UNSPEC))
	398	return -EAFNOSUPPORT;
	399
	400	r = dns_name_reverse(family, a, &reverse);
	401	if (r < 0)
	402	return r;
	403
	404	q = dns_question_new(1);
	405	if (!q)
	406	return -ENOMEM;
	407
	408	key = dns_resource_key_new_consume(DNS_CLASS_IN, DNS_TYPE_PTR, reverse);
	409	if (!key)
	410	return -ENOMEM;
	411
	412	reverse = NULL;
	413
	414	r = dns_question_add(q, key, 0);
	415	if (r < 0)
	416	return r;
	417
	418	*ret = TAKE_PTR(q);
	419
	420	return 0;
	421	}
	422
	423	int dns_question_new_service(
	424	DnsQuestion **ret,
	425	const char *service,
	426	const char *type,
	427	const char *domain,
	428	bool with_txt,
	429	bool convert_idna) {
	430
	431	_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
	432	_cleanup_(dns_question_unrefp) DnsQuestion *q = NULL;
	433	_cleanup_free_ char buf = NULL, joined = NULL;
	434	const char *name;
	435	int r;
	436
	437	assert(ret);
	438
	439	/* We support three modes of invocation:
	440	*
	441	* 1. Only a domain is specified, in which case we assume a properly encoded SRV RR name, including service
	442	* type and possibly a service name. If specified in this way we assume it's already IDNA converted if
	443	* that's necessary.
	444	*
	445	* 2. Both service type and a domain specified, in which case a normal SRV RR is assumed, without a DNS-SD
	446	* style prefix. In this case we'll IDNA convert the domain, if that's requested.
	447	*
	448	* 3. All three of service name, type and domain are specified, in which case a DNS-SD service is put
	449	* together. The service name is never IDNA converted, and the domain is if requested.
	450	*
	451	* It's not supported to specify a service name without a type, or no domain name.
	452	*/
	453
	454	if (!domain)
	455	return -EINVAL;
	456
	457	if (type) {
	458	if (convert_idna) {
	459	r = dns_name_apply_idna(domain, &buf);
	460	if (r < 0)
	461	return r;
	462	if (r > 0)
	463	domain = buf;
	464	}
	465
	466	r = dns_service_join(service, type, domain, &joined);
	467	if (r < 0)
	468	return r;
	469
	470	name = joined;
	471	} else {
	472	if (service)
	473	return -EINVAL;
	474
	475	name = domain;
	476	}
	477
	478	q = dns_question_new(1 + with_txt);
	479	if (!q)
	480	return -ENOMEM;
	481
	482	key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_SRV, name);
	483	if (!key)
	484	return -ENOMEM;
	485
	486	r = dns_question_add(q, key, 0);
	487	if (r < 0)
	488	return r;
	489
	490	if (with_txt) {
	491	dns_resource_key_unref(key);
	492	key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_TXT, name);
	493	if (!key)
	494	return -ENOMEM;
	495
	496	r = dns_question_add(q, key, 0);
	497	if (r < 0)
	498	return r;
	499	}
	500
	501	*ret = TAKE_PTR(q);
	502
	503	return 0;
	504	}
	505
	506	/*
	507	* This function is not used in the code base, but is useful when debugging. Do not delete.
	508	*/
	509	void dns_question_dump(DnsQuestion question, FILE f) {
	510	DnsResourceKey *k;
	511
	512	if (!f)
	513	f = stdout;
	514
	515	DNS_QUESTION_FOREACH(k, question) {
	516	char buf[DNS_RESOURCE_KEY_STRING_MAX];
	517
	518	fputc('\t', f);
	519	fputs(dns_resource_key_to_string(k, buf, sizeof(buf)), f);
	520	fputc('\n', f);
	521	}
	522	}
	523
	524	int dns_question_merge(DnsQuestion a, DnsQuestion b, DnsQuestion **ret) {
	525	_cleanup_(dns_question_unrefp) DnsQuestion *k = NULL;
	526	int r;
	527
	528	assert(ret);
	529
	530	if (a == b \|\| dns_question_size(b) <= 0) {
	531	*ret = dns_question_ref(a);
	532	return 0;
	533	}
	534
	535	if (dns_question_size(a) <= 0) {
	536	*ret = dns_question_ref(b);
	537	return 0;
	538	}
	539
	540	k = dns_question_new(dns_question_size(a) + dns_question_size(b));
	541	if (!k)
	542	return -ENOMEM;
	543
	544	r = dns_question_add_raw_all(k, a);
	545	if (r < 0)
	546	return r;
	547
	548	r = dns_question_add_all(k, b);
	549	if (r < 0)
	550	return r;
	551
	552	*ret = TAKE_PTR(k);
	553	return 0;
	554	}
	555
	556	bool dns_question_contains_key_type(DnsQuestion *q, uint16_t type) {
	557	DnsResourceKey *t;
	558	DNS_QUESTION_FOREACH(t, q)
	559	if (t->type == type)
	560	return true;
	561
	562	return false;
	563	}