[thirdparty/systemd.git] / src / resolve / resolved-link-bus.c

/* SPDX-License-Identifier: LGPL-2.1+ */

#include "alloc-util.h"
#include "bus-common-errors.h"
#include "bus-util.h"
#include "parse-util.h"
#include "resolve-util.h"
#include "resolved-bus.h"
#include "resolved-link-bus.h"
#include "resolved-resolv-conf.h"
#include "strv.h"

static BUS_DEFINE_PROPERTY_GET(property_get_dnssec_supported, "b", Link, link_dnssec_supported);
static BUS_DEFINE_PROPERTY_GET2(property_get_dnssec_mode, "s", Link, link_get_dnssec_mode, dnssec_mode_to_string);

static int property_get_dns_over_tls_mode(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        Link *l = userdata;

        assert(reply);
        assert(l);

        return sd_bus_message_append(reply, "s", dns_over_tls_mode_to_string(link_get_dns_over_tls_mode(l)));
}

static int property_get_dns(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        Link *l = userdata;
        DnsServer *s;
        int r;

        assert(reply);
        assert(l);

        r = sd_bus_message_open_container(reply, 'a', "(iay)");
        if (r < 0)
                return r;

        LIST_FOREACH(servers, s, l->dns_servers) {
                r = bus_dns_server_append(reply, s, false);
                if (r < 0)
                        return r;
        }

        return sd_bus_message_close_container(reply);
}

static int property_get_current_dns_server(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        DnsServer *s;

        assert(reply);
        assert(userdata);

        s = *(DnsServer **) userdata;

        return bus_dns_server_append(reply, s, false);
}

static int property_get_domains(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        Link *l = userdata;
        DnsSearchDomain *d;
        int r;

        assert(reply);
        assert(l);

        r = sd_bus_message_open_container(reply, 'a', "(sb)");
        if (r < 0)
                return r;

        LIST_FOREACH(domains, d, l->search_domains) {
                r = sd_bus_message_append(reply, "(sb)", d->name, d->route_only);
                if (r < 0)
                        return r;
        }

        return sd_bus_message_close_container(reply);
}

static int property_get_scopes_mask(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        Link *l = userdata;
        uint64_t mask;

        assert(reply);
        assert(l);

        mask =  (l->unicast_scope ? SD_RESOLVED_DNS : 0) |
                (l->llmnr_ipv4_scope ? SD_RESOLVED_LLMNR_IPV4 : 0) |
                (l->llmnr_ipv6_scope ? SD_RESOLVED_LLMNR_IPV6 : 0) |
                (l->mdns_ipv4_scope ? SD_RESOLVED_MDNS_IPV4 : 0) |
                (l->mdns_ipv6_scope ? SD_RESOLVED_MDNS_IPV6 : 0);

        return sd_bus_message_append(reply, "t", mask);
}

static int property_get_ntas(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        Link *l = userdata;
        const char *name;
        Iterator i;
        int r;

        assert(reply);
        assert(l);

        r = sd_bus_message_open_container(reply, 'a', "s");
        if (r < 0)
                return r;

        SET_FOREACH(name, l->dnssec_negative_trust_anchors, i) {
                r = sd_bus_message_append(reply, "s", name);
                if (r < 0)
                        return r;
        }

        return sd_bus_message_close_container(reply);
}

static int verify_unmanaged_link(Link *l, sd_bus_error *error) {
        assert(l);

        if (l->flags & IFF_LOOPBACK)
                return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is loopback device.", l->name);
        if (l->is_managed)
                return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is managed.", l->name);

        return 0;
}

int bus_link_method_set_dns_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        _cleanup_free_ struct in_addr_data *dns = NULL;
        size_t allocated = 0, n = 0;
        Link *l = userdata;
        unsigned i;
        int r;

        assert(message);
        assert(l);

        r = verify_unmanaged_link(l, error);
        if (r < 0)
                return r;

        r = sd_bus_message_enter_container(message, 'a', "(iay)");
        if (r < 0)
                return r;

        for (;;) {
                int family;
                size_t sz;
                const void *d;

                assert_cc(sizeof(int) == sizeof(int32_t));

                r = sd_bus_message_enter_container(message, 'r', "iay");
                if (r < 0)
                        return r;
                if (r == 0)
                        break;

                r = sd_bus_message_read(message, "i", &family);
                if (r < 0)
                        return r;

                if (!IN_SET(family, AF_INET, AF_INET6))
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);

                r = sd_bus_message_read_array(message, 'y', &d, &sz);
                if (r < 0)
                        return r;
                if (sz != FAMILY_ADDRESS_SIZE(family))
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address size");

                if (!dns_server_address_valid(family, d))
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNS server address");

                r = sd_bus_message_exit_container(message);
                if (r < 0)
                        return r;

                if (!GREEDY_REALLOC(dns, allocated, n+1))
                        return -ENOMEM;

                dns[n].family = family;
                memcpy(&dns[n].address, d, sz);
                n++;
        }

        r = sd_bus_message_exit_container(message);
        if (r < 0)
                return r;

        dns_server_mark_all(l->dns_servers);

        for (i = 0; i < n; i++) {
                DnsServer *s;

                s = dns_server_find(l->dns_servers, dns[i].family, &dns[i].address, 0);
                if (s)
                        dns_server_move_back_and_unmark(s);
                else {
                        r = dns_server_new(l->manager, NULL, DNS_SERVER_LINK, l, dns[i].family, &dns[i].address, 0);
                        if (r < 0)
                                goto clear;
                }

        }

        dns_server_unlink_marked(l->dns_servers);
        link_allocate_scopes(l);

        (void) link_save_user(l);
        (void) manager_write_resolv_conf(l->manager);

        return sd_bus_reply_method_return(message, NULL);

clear:
        dns_server_unlink_all(l->dns_servers);
        return r;
}

int bus_link_method_set_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Link *l = userdata;
        int r;

        assert(message);
        assert(l);

        r = verify_unmanaged_link(l, error);
        if (r < 0)
                return r;

        r = sd_bus_message_enter_container(message, 'a', "(sb)");
        if (r < 0)
                return r;

        for (;;) {
                const char *name;
                int route_only;

                r = sd_bus_message_read(message, "(sb)", &name, &route_only);
                if (r < 0)
                        return r;
                if (r == 0)
                        break;

                r = dns_name_is_valid(name);
                if (r < 0)
                        return r;
                if (r == 0)
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid search domain %s", name);
                if (!route_only && dns_name_is_root(name))
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Root domain is not suitable as search domain");
        }

        dns_search_domain_mark_all(l->search_domains);

        r = sd_bus_message_rewind(message, false);
        if (r < 0)
                return r;

        for (;;) {
                DnsSearchDomain *d;
                const char *name;
                int route_only;

                r = sd_bus_message_read(message, "(sb)", &name, &route_only);
                if (r < 0)
                        goto clear;
                if (r == 0)
                        break;

                r = dns_search_domain_find(l->search_domains, name, &d);
                if (r < 0)
                        goto clear;

                if (r > 0)
                        dns_search_domain_move_back_and_unmark(d);
                else {
                        r = dns_search_domain_new(l->manager, &d, DNS_SEARCH_DOMAIN_LINK, l, name);
                        if (r < 0)
                                goto clear;
                }

                d->route_only = route_only;
        }

        r = sd_bus_message_exit_container(message);
        if (r < 0)
                goto clear;

        dns_search_domain_unlink_marked(l->search_domains);

        (void) link_save_user(l);
        (void) manager_write_resolv_conf(l->manager);

        return sd_bus_reply_method_return(message, NULL);

clear:
        dns_search_domain_unlink_all(l->search_domains);
        return r;
}

int bus_link_method_set_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Link *l = userdata;
        ResolveSupport mode;
        const char *llmnr;
        int r;

        assert(message);
        assert(l);

        r = verify_unmanaged_link(l, error);
        if (r < 0)
                return r;

        r = sd_bus_message_read(message, "s", &llmnr);
        if (r < 0)
                return r;

        if (isempty(llmnr))
                mode = RESOLVE_SUPPORT_YES;
        else {
                mode = resolve_support_from_string(llmnr);
                if (mode < 0)
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid LLMNR setting: %s", llmnr);
        }

        l->llmnr_support = mode;
        link_allocate_scopes(l);
        link_add_rrs(l, false);

        (void) link_save_user(l);

        return sd_bus_reply_method_return(message, NULL);
}

int bus_link_method_set_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Link *l = userdata;
        ResolveSupport mode;
        const char *mdns;
        int r;

        assert(message);
        assert(l);

        r = verify_unmanaged_link(l, error);
        if (r < 0)
                return r;

        r = sd_bus_message_read(message, "s", &mdns);
        if (r < 0)
                return r;

        if (isempty(mdns))
                mode = RESOLVE_SUPPORT_NO;
        else {
                mode = resolve_support_from_string(mdns);
                if (mode < 0)
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid MulticastDNS setting: %s", mdns);
        }

        l->mdns_support = mode;
        link_allocate_scopes(l);
        link_add_rrs(l, false);

        (void) link_save_user(l);

        return sd_bus_reply_method_return(message, NULL);
}

int bus_link_method_set_dns_over_tls(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Link *l = userdata;
        const char *dns_over_tls;
        DnsOverTlsMode mode;
        int r;

        assert(message);
        assert(l);

        r = verify_unmanaged_link(l, error);
        if (r < 0)
                return r;

        r = sd_bus_message_read(message, "s", &dns_over_tls);
        if (r < 0)
                return r;

        if (isempty(dns_over_tls))
                mode = _DNS_OVER_TLS_MODE_INVALID;
        else {
                mode = dns_over_tls_mode_from_string(dns_over_tls);
                if (mode < 0)
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSOverTLS setting: %s", dns_over_tls);
        }

        link_set_dns_over_tls_mode(l, mode);

        (void) link_save_user(l);

        return sd_bus_reply_method_return(message, NULL);
}

int bus_link_method_set_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Link *l = userdata;
        const char *dnssec;
        DnssecMode mode;
        int r;

        assert(message);
        assert(l);

        r = verify_unmanaged_link(l, error);
        if (r < 0)
                return r;

        r = sd_bus_message_read(message, "s", &dnssec);
        if (r < 0)
                return r;

        if (isempty(dnssec))
                mode = _DNSSEC_MODE_INVALID;
        else {
                mode = dnssec_mode_from_string(dnssec);
                if (mode < 0)
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSSEC setting: %s", dnssec);
        }

        link_set_dnssec_mode(l, mode);

        (void) link_save_user(l);

        return sd_bus_reply_method_return(message, NULL);
}

int bus_link_method_set_dnssec_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        _cleanup_set_free_free_ Set *ns = NULL;
        _cleanup_strv_free_ char **ntas = NULL;
        Link *l = userdata;
        int r;
        char **i;

        assert(message);
        assert(l);

        r = verify_unmanaged_link(l, error);
        if (r < 0)
                return r;

        r = sd_bus_message_read_strv(message, &ntas);
        if (r < 0)
                return r;

        STRV_FOREACH(i, ntas) {
                r = dns_name_is_valid(*i);
                if (r < 0)
                        return r;
                if (r == 0)
                        return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid negative trust anchor domain: %s", *i);
        }

        ns = set_new(&dns_name_hash_ops);
        if (!ns)
                return -ENOMEM;

        STRV_FOREACH(i, ntas) {
                r = set_put_strdup(ns, *i);
                if (r < 0)
                        return r;
        }

        set_free_free(l->dnssec_negative_trust_anchors);
        l->dnssec_negative_trust_anchors = TAKE_PTR(ns);

        (void) link_save_user(l);

        return sd_bus_reply_method_return(message, NULL);
}

int bus_link_method_revert(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Link *l = userdata;
        int r;

        assert(message);
        assert(l);

        r = verify_unmanaged_link(l, error);
        if (r < 0)
                return r;

        link_flush_settings(l);
        link_allocate_scopes(l);
        link_add_rrs(l, false);

        (void) link_save_user(l);
        (void) manager_write_resolv_conf(l->manager);

        return sd_bus_reply_method_return(message, NULL);
}

const sd_bus_vtable link_vtable[] = {
        SD_BUS_VTABLE_START(0),

        SD_BUS_PROPERTY("ScopesMask", "t", property_get_scopes_mask, 0, 0),
        SD_BUS_PROPERTY("DNS", "a(iay)", property_get_dns, 0, 0),
        SD_BUS_PROPERTY("CurrentDNSServer", "(iay)", property_get_current_dns_server, offsetof(Link, current_dns_server), 0),
        SD_BUS_PROPERTY("Domains", "a(sb)", property_get_domains, 0, 0),
        SD_BUS_PROPERTY("LLMNR", "s", bus_property_get_resolve_support, offsetof(Link, llmnr_support), 0),
        SD_BUS_PROPERTY("MulticastDNS", "s", bus_property_get_resolve_support, offsetof(Link, mdns_support), 0),
        SD_BUS_PROPERTY("DNSOverTLS", "s", property_get_dns_over_tls_mode, 0, 0),
        SD_BUS_PROPERTY("DNSSEC", "s", property_get_dnssec_mode, 0, 0),
        SD_BUS_PROPERTY("DNSSECNegativeTrustAnchors", "as", property_get_ntas, 0, 0),
        SD_BUS_PROPERTY("DNSSECSupported", "b", property_get_dnssec_supported, 0, 0),

        SD_BUS_METHOD("SetDNS", "a(iay)", NULL, bus_link_method_set_dns_servers, 0),
        SD_BUS_METHOD("SetDomains", "a(sb)", NULL, bus_link_method_set_domains, 0),
        SD_BUS_METHOD("SetLLMNR", "s", NULL, bus_link_method_set_llmnr, 0),
        SD_BUS_METHOD("SetMulticastDNS", "s", NULL, bus_link_method_set_mdns, 0),
        SD_BUS_METHOD("SetDNSOverTLS", "s", NULL, bus_link_method_set_dns_over_tls, 0),
        SD_BUS_METHOD("SetDNSSEC", "s", NULL, bus_link_method_set_dnssec, 0),
        SD_BUS_METHOD("SetDNSSECNegativeTrustAnchors", "as", NULL, bus_link_method_set_dnssec_negative_trust_anchors, 0),
        SD_BUS_METHOD("Revert", NULL, NULL, bus_link_method_revert, 0),

        SD_BUS_VTABLE_END
};

int link_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
        _cleanup_free_ char *e = NULL;
        Manager *m = userdata;
        int ifindex;
        Link *link;
        int r;

        assert(bus);
        assert(path);
        assert(interface);
        assert(found);
        assert(m);

        r = sd_bus_path_decode(path, "/org/freedesktop/resolve1/link", &e);
        if (r <= 0)
                return 0;

        r = parse_ifindex(e, &ifindex);
        if (r < 0)
                return 0;

        link = hashmap_get(m->links, INT_TO_PTR(ifindex));
        if (!link)
                return 0;

        *found = link;
        return 1;
}

char *link_bus_path(Link *link) {
        _cleanup_free_ char *ifindex = NULL;
        char *p;
        int r;

        assert(link);

        if (asprintf(&ifindex, "%i", link->ifindex) < 0)
                return NULL;

        r = sd_bus_path_encode("/org/freedesktop/resolve1/link", ifindex, &p);
        if (r < 0)
                return NULL;

        return p;
}

int link_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
        _cleanup_strv_free_ char **l = NULL;
        Manager *m = userdata;
        Link *link;
        Iterator i;
        unsigned c = 0;

        assert(bus);
        assert(path);
        assert(m);
        assert(nodes);

        l = new0(char*, hashmap_size(m->links) + 1);
        if (!l)
                return -ENOMEM;

        HASHMAP_FOREACH(link, m->links, i) {
                char *p;

                p = link_bus_path(link);
                if (!p)
                        return -ENOMEM;

                l[c++] = p;
        }

        l[c] = NULL;
        *nodes = TAKE_PTR(l);

        return 1;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
3abaabda LP	2
3abaabda LP	3	#include "alloc-util.h"
04b764bf	4	#include "bus-common-errors.h"
3abaabda LP	5	#include "bus-util.h"
	6	#include "parse-util.h"
	7	#include "resolve-util.h"
	8	#include "resolved-bus.h"
	9	#include "resolved-link-bus.h"
7207052d	10	#include "resolved-resolv-conf.h"
3abaabda LP	11	#include "strv.h"
3abaabda LP	12
acd380c4 YW	13	static BUS_DEFINE_PROPERTY_GET(property_get_dnssec_supported, "b", Link, link_dnssec_supported);
acd380c4 YW	14	static BUS_DEFINE_PROPERTY_GET2(property_get_dnssec_mode, "s", Link, link_get_dnssec_mode, dnssec_mode_to_string);
3abaabda	15
c9299be2	16	static int property_get_dns_over_tls_mode(
d050561a IT	17	sd_bus *bus,
	18	const char *path,
	19	const char *interface,
	20	const char *property,
	21	sd_bus_message *reply,
	22	void *userdata,
	23	sd_bus_error *error) {
	24
	25	Link *l = userdata;
	26
	27	assert(reply);
	28	assert(l);
	29
c9299be2	30	return sd_bus_message_append(reply, "s", dns_over_tls_mode_to_string(link_get_dns_over_tls_mode(l)));
d050561a IT	31	}
d050561a IT	32
3abaabda LP	33	static int property_get_dns(
	34	sd_bus *bus,
	35	const char *path,
	36	const char *interface,
	37	const char *property,
	38	sd_bus_message *reply,
	39	void *userdata,
	40	sd_bus_error *error) {
	41
	42	Link *l = userdata;
	43	DnsServer *s;
	44	int r;
	45
	46	assert(reply);
	47	assert(l);
	48
	49	r = sd_bus_message_open_container(reply, 'a', "(iay)");
	50	if (r < 0)
	51	return r;
	52
	53	LIST_FOREACH(servers, s, l->dns_servers) {
	54	r = bus_dns_server_append(reply, s, false);
	55	if (r < 0)
	56	return r;
	57	}
	58
	59	return sd_bus_message_close_container(reply);
	60	}
	61
b7ac92cd YW	62	static int property_get_current_dns_server(
	63	sd_bus *bus,
	64	const char *path,
	65	const char *interface,
	66	const char *property,
	67	sd_bus_message *reply,
	68	void *userdata,
	69	sd_bus_error *error) {
	70
	71	DnsServer *s;
	72
	73	assert(reply);
	74	assert(userdata);
	75
	76	s = (DnsServer *) userdata;
	77
	78	return bus_dns_server_append(reply, s, false);
	79	}
	80
3abaabda LP	81	static int property_get_domains(
	82	sd_bus *bus,
	83	const char *path,
	84	const char *interface,
	85	const char *property,
	86	sd_bus_message *reply,
	87	void *userdata,
	88	sd_bus_error *error) {
	89
	90	Link *l = userdata;
	91	DnsSearchDomain *d;
	92	int r;
	93
	94	assert(reply);
	95	assert(l);
	96
ad44b56b	97	r = sd_bus_message_open_container(reply, 'a', "(sb)");
3abaabda LP	98	if (r < 0)
	99	return r;
	100
	101	LIST_FOREACH(domains, d, l->search_domains) {
ad44b56b	102	r = sd_bus_message_append(reply, "(sb)", d->name, d->route_only);
3abaabda LP	103	if (r < 0)
	104	return r;
	105	}
	106
	107	return sd_bus_message_close_container(reply);
	108	}
	109
	110	static int property_get_scopes_mask(
	111	sd_bus *bus,
	112	const char *path,
	113	const char *interface,
	114	const char *property,
	115	sd_bus_message *reply,
	116	void *userdata,
	117	sd_bus_error *error) {
	118
	119	Link *l = userdata;
	120	uint64_t mask;
	121
	122	assert(reply);
	123	assert(l);
	124
	125	mask = (l->unicast_scope ? SD_RESOLVED_DNS : 0) \|
	126	(l->llmnr_ipv4_scope ? SD_RESOLVED_LLMNR_IPV4 : 0) \|
	127	(l->llmnr_ipv6_scope ? SD_RESOLVED_LLMNR_IPV6 : 0) \|
	128	(l->mdns_ipv4_scope ? SD_RESOLVED_MDNS_IPV4 : 0) \|
	129	(l->mdns_ipv6_scope ? SD_RESOLVED_MDNS_IPV6 : 0);
	130
	131	return sd_bus_message_append(reply, "t", mask);
	132	}
	133
	134	static int property_get_ntas(
	135	sd_bus *bus,
	136	const char *path,
	137	const char *interface,
	138	const char *property,
	139	sd_bus_message *reply,
	140	void *userdata,
	141	sd_bus_error *error) {
	142
	143	Link *l = userdata;
	144	const char *name;
	145	Iterator i;
	146	int r;
	147
	148	assert(reply);
	149	assert(l);
	150
	151	r = sd_bus_message_open_container(reply, 'a', "s");
	152	if (r < 0)
	153	return r;
	154
	155	SET_FOREACH(name, l->dnssec_negative_trust_anchors, i) {
	156	r = sd_bus_message_append(reply, "s", name);
	157	if (r < 0)
	158	return r;
	159	}
	160
	161	return sd_bus_message_close_container(reply);
	162	}
	163
04b764bf LP	164	static int verify_unmanaged_link(Link l, sd_bus_error error) {
	165	assert(l);
	166
	167	if (l->flags & IFF_LOOPBACK)
	168	return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is loopback device.", l->name);
	169	if (l->is_managed)
	170	return sd_bus_error_setf(error, BUS_ERROR_LINK_BUSY, "Link %s is managed.", l->name);
	171
	172	return 0;
	173	}
	174
d2ec6608 LP	175	int bus_link_method_set_dns_servers(sd_bus_message message, void userdata, sd_bus_error *error) {
	176	_cleanup_free_ struct in_addr_data *dns = NULL;
	177	size_t allocated = 0, n = 0;
	178	Link *l = userdata;
	179	unsigned i;
	180	int r;
	181
	182	assert(message);
	183	assert(l);
	184
04b764bf LP	185	r = verify_unmanaged_link(l, error);
	186	if (r < 0)
	187	return r;
	188
d2ec6608 LP	189	r = sd_bus_message_enter_container(message, 'a', "(iay)");
	190	if (r < 0)
	191	return r;
	192
	193	for (;;) {
	194	int family;
	195	size_t sz;
	196	const void *d;
	197
	198	assert_cc(sizeof(int) == sizeof(int32_t));
	199
	200	r = sd_bus_message_enter_container(message, 'r', "iay");
	201	if (r < 0)
	202	return r;
	203	if (r == 0)
	204	break;
	205
	206	r = sd_bus_message_read(message, "i", &family);
	207	if (r < 0)
	208	return r;
	209
	210	if (!IN_SET(family, AF_INET, AF_INET6))
	211	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);
	212
	213	r = sd_bus_message_read_array(message, 'y', &d, &sz);
	214	if (r < 0)
	215	return r;
	216	if (sz != FAMILY_ADDRESS_SIZE(family))
	217	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address size");
	218
b30bf55d LP	219	if (!dns_server_address_valid(family, d))
	220	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNS server address");
	221
d2ec6608 LP	222	r = sd_bus_message_exit_container(message);
	223	if (r < 0)
	224	return r;
	225
	226	if (!GREEDY_REALLOC(dns, allocated, n+1))
	227	return -ENOMEM;
	228
	229	dns[n].family = family;
	230	memcpy(&dns[n].address, d, sz);
	231	n++;
	232	}
	233
	234	r = sd_bus_message_exit_container(message);
	235	if (r < 0)
	236	return r;
	237
	238	dns_server_mark_all(l->dns_servers);
	239
	240	for (i = 0; i < n; i++) {
	241	DnsServer *s;
	242
2817157b	243	s = dns_server_find(l->dns_servers, dns[i].family, &dns[i].address, 0);
d2ec6608 LP	244	if (s)
	245	dns_server_move_back_and_unmark(s);
	246	else {
2817157b	247	r = dns_server_new(l->manager, NULL, DNS_SERVER_LINK, l, dns[i].family, &dns[i].address, 0);
d2ec6608 LP	248	if (r < 0)
	249	goto clear;
	250	}
	251
	252	}
	253
	254	dns_server_unlink_marked(l->dns_servers);
	255	link_allocate_scopes(l);
	256
943ef07c	257	(void) link_save_user(l);
7207052d LP	258	(void) manager_write_resolv_conf(l->manager);
7207052d LP	259
d2ec6608 LP	260	return sd_bus_reply_method_return(message, NULL);
	261
	262	clear:
	263	dns_server_unlink_all(l->dns_servers);
	264	return r;
	265	}
	266
ee116b54	267	int bus_link_method_set_domains(sd_bus_message message, void userdata, sd_bus_error *error) {
d2ec6608	268	Link *l = userdata;
d2ec6608 LP	269	int r;
	270
	271	assert(message);
	272	assert(l);
	273
04b764bf LP	274	r = verify_unmanaged_link(l, error);
	275	if (r < 0)
	276	return r;
	277
ad44b56b	278	r = sd_bus_message_enter_container(message, 'a', "(sb)");
d2ec6608 LP	279	if (r < 0)
	280	return r;
	281
ad44b56b LP	282	for (;;) {
	283	const char *name;
	284	int route_only;
d2ec6608	285
ad44b56b	286	r = sd_bus_message_read(message, "(sb)", &name, &route_only);
d2ec6608 LP	287	if (r < 0)
	288	return r;
	289	if (r == 0)
ad44b56b LP	290	break;
	291
	292	r = dns_name_is_valid(name);
	293	if (r < 0)
	294	return r;
	295	if (r == 0)
	296	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid search domain %s", name);
	297	if (!route_only && dns_name_is_root(name))
d2ec6608 LP	298	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Root domain is not suitable as search domain");
	299	}
	300
	301	dns_search_domain_mark_all(l->search_domains);
	302
ad44b56b LP	303	r = sd_bus_message_rewind(message, false);
	304	if (r < 0)
	305	return r;
	306
	307	for (;;) {
d2ec6608	308	DnsSearchDomain *d;
ad44b56b LP	309	const char *name;
ad44b56b LP	310	int route_only;
d2ec6608	311
ad44b56b LP	312	r = sd_bus_message_read(message, "(sb)", &name, &route_only);
	313	if (r < 0)
	314	goto clear;
	315	if (r == 0)
	316	break;
	317
	318	r = dns_search_domain_find(l->search_domains, name, &d);
d2ec6608 LP	319	if (r < 0)
	320	goto clear;
	321
	322	if (r > 0)
	323	dns_search_domain_move_back_and_unmark(d);
	324	else {
ad44b56b	325	r = dns_search_domain_new(l->manager, &d, DNS_SEARCH_DOMAIN_LINK, l, name);
d2ec6608 LP	326	if (r < 0)
	327	goto clear;
	328	}
ad44b56b LP	329
ad44b56b LP	330	d->route_only = route_only;
d2ec6608 LP	331	}
d2ec6608 LP	332
ad44b56b LP	333	r = sd_bus_message_exit_container(message);
	334	if (r < 0)
	335	goto clear;
	336
d2ec6608	337	dns_search_domain_unlink_marked(l->search_domains);
7207052d	338
943ef07c	339	(void) link_save_user(l);
7207052d LP	340	(void) manager_write_resolv_conf(l->manager);
7207052d LP	341
d2ec6608 LP	342	return sd_bus_reply_method_return(message, NULL);
	343
	344	clear:
	345	dns_search_domain_unlink_all(l->search_domains);
	346	return r;
	347	}
	348
	349	int bus_link_method_set_llmnr(sd_bus_message message, void userdata, sd_bus_error *error) {
	350	Link *l = userdata;
	351	ResolveSupport mode;
	352	const char *llmnr;
	353	int r;
	354
	355	assert(message);
	356	assert(l);
	357
04b764bf LP	358	r = verify_unmanaged_link(l, error);
	359	if (r < 0)
	360	return r;
	361
d2ec6608 LP	362	r = sd_bus_message_read(message, "s", &llmnr);
	363	if (r < 0)
	364	return r;
	365
	366	if (isempty(llmnr))
	367	mode = RESOLVE_SUPPORT_YES;
	368	else {
	369	mode = resolve_support_from_string(llmnr);
	370	if (mode < 0)
	371	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid LLMNR setting: %s", llmnr);
	372	}
	373
	374	l->llmnr_support = mode;
	375	link_allocate_scopes(l);
	376	link_add_rrs(l, false);
	377
943ef07c LP	378	(void) link_save_user(l);
943ef07c LP	379
d2ec6608 LP	380	return sd_bus_reply_method_return(message, NULL);
	381	}
	382
	383	int bus_link_method_set_mdns(sd_bus_message message, void userdata, sd_bus_error *error) {
	384	Link *l = userdata;
	385	ResolveSupport mode;
	386	const char *mdns;
	387	int r;
	388
	389	assert(message);
	390	assert(l);
	391
04b764bf LP	392	r = verify_unmanaged_link(l, error);
	393	if (r < 0)
	394	return r;
	395
d2ec6608 LP	396	r = sd_bus_message_read(message, "s", &mdns);
	397	if (r < 0)
	398	return r;
	399
	400	if (isempty(mdns))
	401	mode = RESOLVE_SUPPORT_NO;
	402	else {
	403	mode = resolve_support_from_string(mdns);
	404	if (mode < 0)
	405	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid MulticastDNS setting: %s", mdns);
	406	}
	407
	408	l->mdns_support = mode;
	409	link_allocate_scopes(l);
	410	link_add_rrs(l, false);
	411
943ef07c LP	412	(void) link_save_user(l);
943ef07c LP	413
d2ec6608 LP	414	return sd_bus_reply_method_return(message, NULL);
	415	}
	416
c9299be2	417	int bus_link_method_set_dns_over_tls(sd_bus_message message, void userdata, sd_bus_error *error) {
d050561a	418	Link *l = userdata;
c9299be2 IT	419	const char *dns_over_tls;
c9299be2 IT	420	DnsOverTlsMode mode;
d050561a IT	421	int r;
	422
	423	assert(message);
	424	assert(l);
	425
	426	r = verify_unmanaged_link(l, error);
	427	if (r < 0)
	428	return r;
	429
c9299be2	430	r = sd_bus_message_read(message, "s", &dns_over_tls);
d050561a IT	431	if (r < 0)
	432	return r;
	433
c9299be2 IT	434	if (isempty(dns_over_tls))
c9299be2 IT	435	mode = _DNS_OVER_TLS_MODE_INVALID;
d050561a	436	else {
c9299be2	437	mode = dns_over_tls_mode_from_string(dns_over_tls);
d050561a	438	if (mode < 0)
c9299be2	439	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSOverTLS setting: %s", dns_over_tls);
d050561a IT	440	}
d050561a IT	441
c9299be2	442	link_set_dns_over_tls_mode(l, mode);
d050561a IT	443
	444	(void) link_save_user(l);
	445
	446	return sd_bus_reply_method_return(message, NULL);
	447	}
	448
d2ec6608 LP	449	int bus_link_method_set_dnssec(sd_bus_message message, void userdata, sd_bus_error *error) {
	450	Link *l = userdata;
	451	const char *dnssec;
	452	DnssecMode mode;
	453	int r;
	454
	455	assert(message);
	456	assert(l);
	457
04b764bf LP	458	r = verify_unmanaged_link(l, error);
	459	if (r < 0)
	460	return r;
	461
d2ec6608 LP	462	r = sd_bus_message_read(message, "s", &dnssec);
	463	if (r < 0)
	464	return r;
	465
	466	if (isempty(dnssec))
	467	mode = _DNSSEC_MODE_INVALID;
	468	else {
	469	mode = dnssec_mode_from_string(dnssec);
	470	if (mode < 0)
	471	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNSSEC setting: %s", dnssec);
	472	}
	473
	474	link_set_dnssec_mode(l, mode);
	475
943ef07c LP	476	(void) link_save_user(l);
943ef07c LP	477
d2ec6608 LP	478	return sd_bus_reply_method_return(message, NULL);
	479	}
	480
	481	int bus_link_method_set_dnssec_negative_trust_anchors(sd_bus_message message, void userdata, sd_bus_error *error) {
	482	_cleanup_set_free_free_ Set *ns = NULL;
c6d92582	483	_cleanup_strv_free_ char **ntas = NULL;
d2ec6608 LP	484	Link *l = userdata;
	485	int r;
	486	char **i;
	487
	488	assert(message);
	489	assert(l);
	490
04b764bf LP	491	r = verify_unmanaged_link(l, error);
	492	if (r < 0)
	493	return r;
	494
d2ec6608 LP	495	r = sd_bus_message_read_strv(message, &ntas);
	496	if (r < 0)
	497	return r;
	498
	499	STRV_FOREACH(i, ntas) {
	500	r = dns_name_is_valid(*i);
	501	if (r < 0)
	502	return r;
	503	if (r == 0)
55abd6da	504	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid negative trust anchor domain: %s", *i);
d2ec6608 LP	505	}
	506
	507	ns = set_new(&dns_name_hash_ops);
	508	if (!ns)
	509	return -ENOMEM;
	510
	511	STRV_FOREACH(i, ntas) {
	512	r = set_put_strdup(ns, *i);
	513	if (r < 0)
	514	return r;
	515	}
	516
	517	set_free_free(l->dnssec_negative_trust_anchors);
ae2a15bc	518	l->dnssec_negative_trust_anchors = TAKE_PTR(ns);
d2ec6608	519
943ef07c LP	520	(void) link_save_user(l);
943ef07c LP	521
d2ec6608 LP	522	return sd_bus_reply_method_return(message, NULL);
	523	}
	524
	525	int bus_link_method_revert(sd_bus_message message, void userdata, sd_bus_error *error) {
	526	Link *l = userdata;
04b764bf	527	int r;
d2ec6608 LP	528
	529	assert(message);
	530	assert(l);
	531
04b764bf LP	532	r = verify_unmanaged_link(l, error);
	533	if (r < 0)
	534	return r;
	535
d2ec6608 LP	536	link_flush_settings(l);
	537	link_allocate_scopes(l);
	538	link_add_rrs(l, false);
	539
943ef07c	540	(void) link_save_user(l);
7207052d LP	541	(void) manager_write_resolv_conf(l->manager);
7207052d LP	542
d2ec6608 LP	543	return sd_bus_reply_method_return(message, NULL);
	544	}
	545
3abaabda LP	546	const sd_bus_vtable link_vtable[] = {
	547	SD_BUS_VTABLE_START(0),
	548
	549	SD_BUS_PROPERTY("ScopesMask", "t", property_get_scopes_mask, 0, 0),
	550	SD_BUS_PROPERTY("DNS", "a(iay)", property_get_dns, 0, 0),
b7ac92cd	551	SD_BUS_PROPERTY("CurrentDNSServer", "(iay)", property_get_current_dns_server, offsetof(Link, current_dns_server), 0),
ad44b56b	552	SD_BUS_PROPERTY("Domains", "a(sb)", property_get_domains, 0, 0),
bf4e5c4c YW	553	SD_BUS_PROPERTY("LLMNR", "s", bus_property_get_resolve_support, offsetof(Link, llmnr_support), 0),
bf4e5c4c YW	554	SD_BUS_PROPERTY("MulticastDNS", "s", bus_property_get_resolve_support, offsetof(Link, mdns_support), 0),
c9299be2	555	SD_BUS_PROPERTY("DNSOverTLS", "s", property_get_dns_over_tls_mode, 0, 0),
a3712979	556	SD_BUS_PROPERTY("DNSSEC", "s", property_get_dnssec_mode, 0, 0),
3abaabda	557	SD_BUS_PROPERTY("DNSSECNegativeTrustAnchors", "as", property_get_ntas, 0, 0),
c2cf6e0b	558	SD_BUS_PROPERTY("DNSSECSupported", "b", property_get_dnssec_supported, 0, 0),
3abaabda	559
d2ec6608	560	SD_BUS_METHOD("SetDNS", "a(iay)", NULL, bus_link_method_set_dns_servers, 0),
ee116b54	561	SD_BUS_METHOD("SetDomains", "a(sb)", NULL, bus_link_method_set_domains, 0),
d2ec6608 LP	562	SD_BUS_METHOD("SetLLMNR", "s", NULL, bus_link_method_set_llmnr, 0),
d2ec6608 LP	563	SD_BUS_METHOD("SetMulticastDNS", "s", NULL, bus_link_method_set_mdns, 0),
c9299be2	564	SD_BUS_METHOD("SetDNSOverTLS", "s", NULL, bus_link_method_set_dns_over_tls, 0),
d2ec6608 LP	565	SD_BUS_METHOD("SetDNSSEC", "s", NULL, bus_link_method_set_dnssec, 0),
	566	SD_BUS_METHOD("SetDNSSECNegativeTrustAnchors", "as", NULL, bus_link_method_set_dnssec_negative_trust_anchors, 0),
	567	SD_BUS_METHOD("Revert", NULL, NULL, bus_link_method_revert, 0),
	568
3abaabda LP	569	SD_BUS_VTABLE_END
	570	};
	571
	572	int link_object_find(sd_bus bus, const char path, const char interface, void userdata, void *found, sd_bus_error error) {
	573	_cleanup_free_ char *e = NULL;
	574	Manager *m = userdata;
	575	int ifindex;
	576	Link *link;
	577	int r;
	578
	579	assert(bus);
	580	assert(path);
	581	assert(interface);
	582	assert(found);
	583	assert(m);
	584
	585	r = sd_bus_path_decode(path, "/org/freedesktop/resolve1/link", &e);
	586	if (r <= 0)
	587	return 0;
	588
	589	r = parse_ifindex(e, &ifindex);
	590	if (r < 0)
	591	return 0;
	592
	593	link = hashmap_get(m->links, INT_TO_PTR(ifindex));
	594	if (!link)
	595	return 0;
	596
	597	*found = link;
	598	return 1;
	599	}
	600
	601	char link_bus_path(Link link) {
	602	_cleanup_free_ char *ifindex = NULL;
	603	char *p;
	604	int r;
	605
	606	assert(link);
	607
	608	if (asprintf(&ifindex, "%i", link->ifindex) < 0)
	609	return NULL;
	610
	611	r = sd_bus_path_encode("/org/freedesktop/resolve1/link", ifindex, &p);
	612	if (r < 0)
	613	return NULL;
	614
	615	return p;
	616	}
	617
	618	int link_node_enumerator(sd_bus bus, const char path, void userdata, char *nodes, sd_bus_error error) {
	619	_cleanup_strv_free_ char **l = NULL;
	620	Manager *m = userdata;
	621	Link *link;
	622	Iterator i;
	623	unsigned c = 0;
	624
	625	assert(bus);
	626	assert(path);
	627	assert(m);
	628	assert(nodes);
	629
	630	l = new0(char*, hashmap_size(m->links) + 1);
	631	if (!l)
	632	return -ENOMEM;
633
634	HASHMAP_FOREACH(link, m->links, i) {
635	char *p;
636
637	p = link_bus_path(link);
638	if (!p)
639	return -ENOMEM;
640
641	l[c++] = p;
642	}
643
644	l[c] = NULL;
ae2a15bc	645	*nodes = TAKE_PTR(l);
3abaabda LP	646
	647	return 1;
	648	}