[thirdparty/systemd.git] / src / network / networkd-manager-bus.c

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

#include <net/if.h>
#include <netinet/in.h>
#include <sys/capability.h>

#include "alloc-util.h"
#include "bus-common-errors.h"
#include "bus-message-util.h"
#include "bus-polkit.h"
#include "networkd-json.h"
#include "networkd-link-bus.h"
#include "networkd-link.h"
#include "networkd-manager-bus.h"
#include "networkd-manager.h"
#include "path-util.h"
#include "socket-netlink.h"
#include "strv.h"
#include "user-util.h"

static int method_list_links(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        Manager *manager = userdata;
        Link *link;
        int r;

        r = sd_bus_message_new_method_return(message, &reply);
        if (r < 0)
                return r;

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

        HASHMAP_FOREACH(link, manager->links) {
                _cleanup_free_ char *path = NULL;

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

                r = sd_bus_message_append(
                        reply, "(iso)",
                        link->ifindex,
                        link->ifname,
                        empty_to_root(path));
                if (r < 0)
                        return r;
        }

        r = sd_bus_message_close_container(reply);
        if (r < 0)
                return r;

        return sd_bus_send(NULL, reply, NULL);
}

static int method_get_link_by_name(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        _cleanup_free_ char *path = NULL;
        Manager *manager = userdata;
        const char *name;
        int index, r;
        Link *link;

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

        index = resolve_ifname(&manager->rtnl, name);
        if (index < 0)
                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %s cannot be resolved", name);

        link = hashmap_get(manager->links, INT_TO_PTR(index));
        if (!link)
                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %s not known", name);

        r = sd_bus_message_new_method_return(message, &reply);
        if (r < 0)
                return r;

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

        r = sd_bus_message_append(reply, "io", link->ifindex, empty_to_root(path));
        if (r < 0)
                return r;

        return sd_bus_send(NULL, reply, NULL);
}

static int method_get_link_by_index(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        _cleanup_free_ char *path = NULL;
        Manager *manager = userdata;
        int ifindex, r;
        Link *link;

        r = bus_message_read_ifindex(message, error, &ifindex);
        if (r < 0)
                return r;

        link = hashmap_get(manager->links, INT_TO_PTR(ifindex));
        if (!link)
                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %i not known", ifindex);

        r = sd_bus_message_new_method_return(message, &reply);
        if (r < 0)
                return r;

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

        r = sd_bus_message_append(reply, "so", link->ifname, empty_to_root(path));
        if (r < 0)
                return r;

        return sd_bus_send(NULL, reply, NULL);
}

static int call_link_method(Manager *m, sd_bus_message *message, sd_bus_message_handler_t handler, sd_bus_error *error) {
        int ifindex, r;
        Link *l;

        assert(m);
        assert(message);
        assert(handler);

        r = bus_message_read_ifindex(message, error, &ifindex);
        if (r < 0)
                return r;

        l = hashmap_get(m->links, INT_TO_PTR(ifindex));
        if (!l)
                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %i not known", ifindex);

        return handler(message, l, error);
}

static int bus_method_set_link_ntp_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_ntp_servers, error);
}

static int bus_method_set_link_dns_servers(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_dns_servers, error);
}

static int bus_method_set_link_dns_servers_ex(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_dns_servers_ex, error);
}

static int bus_method_set_link_domains(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_domains, error);
}

static int bus_method_set_link_default_route(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_default_route, error);
}

static int bus_method_set_link_llmnr(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_llmnr, error);
}

static int bus_method_set_link_mdns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_mdns, error);
}

static int bus_method_set_link_dns_over_tls(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_dns_over_tls, error);
}

static int bus_method_set_link_dnssec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_dnssec, error);
}

static int bus_method_set_link_dnssec_negative_trust_anchors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_set_dnssec_negative_trust_anchors, error);
}

static int bus_method_revert_link_ntp(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_revert_ntp, error);
}

static int bus_method_revert_link_dns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_revert_dns, error);
}

static int bus_method_renew_link(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_renew, error);
}

static int bus_method_force_renew_link(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_force_renew, error);
}

static int bus_method_reconfigure_link(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_reconfigure, error);
}

static int bus_method_reload(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Manager *manager = userdata;
        Link *link;
        int r;

        r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
                                    "org.freedesktop.network1.reload",
                                    NULL, true, UID_INVALID,
                                    &manager->polkit_registry, error);
        if (r < 0)
                return r;
        if (r == 0)
                return 1; /* Polkit will call us back */

        r = netdev_load(manager, true);
        if (r < 0)
                return r;

        r = network_reload(manager);
        if (r < 0)
                return r;

        HASHMAP_FOREACH(link, manager->links) {
                r = link_reconfigure(link, false);
                if (r < 0)
                        return r;
        }

        return sd_bus_reply_method_return(message, NULL);
}

static int bus_method_describe_link(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        return call_link_method(userdata, message, bus_link_method_describe, error);
}

static int bus_method_describe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
        _cleanup_free_ char *text = NULL;
        Manager *manager = userdata;
        int r;

        assert(message);
        assert(manager);

        r = manager_build_json(manager, &v);
        if (r < 0)
                return log_error_errno(r, "Failed to build JSON data: %m");

        r = json_variant_format(v, 0, &text);
        if (r < 0)
                return log_error_errno(r, "Failed to format JSON data: %m");

        r = sd_bus_message_new_method_return(message, &reply);
        if (r < 0)
                return r;

        r = sd_bus_message_append(reply, "s", text);
        if (r < 0)
                return r;

        return sd_bus_send(NULL, reply, NULL);
}

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

        SD_BUS_PROPERTY("OperationalState", "s", property_get_operational_state, offsetof(Manager, operational_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("CarrierState", "s", property_get_carrier_state, offsetof(Manager, carrier_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("AddressState", "s", property_get_address_state, offsetof(Manager, address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("IPv4AddressState", "s", property_get_address_state, offsetof(Manager, ipv4_address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("IPv6AddressState", "s", property_get_address_state, offsetof(Manager, ipv6_address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),

        SD_BUS_METHOD_WITH_ARGS("ListLinks",
                                SD_BUS_NO_ARGS,
                                SD_BUS_RESULT("a(iso)", links),
                                method_list_links,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("GetLinkByName",
                                SD_BUS_ARGS("s", name),
                                SD_BUS_RESULT("i", ifindex, "o", path),
                                method_get_link_by_name,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("GetLinkByIndex",
                                SD_BUS_ARGS("i", ifindex),
                                SD_BUS_RESULT("s", name, "o", path),
                                method_get_link_by_index,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkNTP",
                                SD_BUS_ARGS("i", ifindex, "as", servers),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_ntp_servers,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDNS",
                                SD_BUS_ARGS("i", ifindex, "a(iay)", addresses),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_dns_servers,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDNSEx",
                                SD_BUS_ARGS("i", ifindex, "a(iayqs)", addresses),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_dns_servers_ex,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDomains",
                                SD_BUS_ARGS("i", ifindex, "a(sb)", domains),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_domains,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDefaultRoute",
                                SD_BUS_ARGS("i", ifindex, "b", enable),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_default_route,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkLLMNR",
                                SD_BUS_ARGS("i", ifindex, "s", mode),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_llmnr,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkMulticastDNS",
                                SD_BUS_ARGS("i", ifindex, "s", mode),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_mdns,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDNSOverTLS",
                                SD_BUS_ARGS("i", ifindex, "s", mode),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_dns_over_tls,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDNSSEC",
                                SD_BUS_ARGS("i", ifindex, "s", mode),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_dnssec,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("SetLinkDNSSECNegativeTrustAnchors",
                                SD_BUS_ARGS("i", ifindex, "as", names),
                                SD_BUS_NO_RESULT,
                                bus_method_set_link_dnssec_negative_trust_anchors,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("RevertLinkNTP",
                                SD_BUS_ARGS("i", ifindex),
                                SD_BUS_NO_RESULT,
                                bus_method_revert_link_ntp,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("RevertLinkDNS",
                                SD_BUS_ARGS("i", ifindex),
                                SD_BUS_NO_RESULT,
                                bus_method_revert_link_dns,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("RenewLink",
                                SD_BUS_ARGS("i", ifindex),
                                SD_BUS_NO_RESULT,
                                bus_method_renew_link,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("ForceRenewLink",
                                SD_BUS_ARGS("i", ifindex),
                                SD_BUS_NO_RESULT,
                                bus_method_force_renew_link,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("ReconfigureLink",
                                SD_BUS_ARGS("i", ifindex),
                                SD_BUS_NO_RESULT,
                                bus_method_reconfigure_link,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("Reload",
                                SD_BUS_NO_ARGS,
                                SD_BUS_NO_RESULT,
                                bus_method_reload,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("DescribeLink",
                                SD_BUS_ARGS("i", ifindex),
                                SD_BUS_RESULT("s", json),
                                bus_method_describe_link,
                                SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD_WITH_ARGS("Describe",
                                SD_BUS_NO_ARGS,
                                SD_BUS_RESULT("s", json),
                                bus_method_describe,
                                SD_BUS_VTABLE_UNPRIVILEGED),

        SD_BUS_VTABLE_END
};

int manager_send_changed_strv(Manager *manager, char **properties) {
        assert(manager);
        assert(properties);

        if (sd_bus_is_ready(manager->bus) <= 0)
                return 0;

        return sd_bus_emit_properties_changed_strv(
                        manager->bus,
                        "/org/freedesktop/network1",
                        "org.freedesktop.network1.Manager",
                        properties);
}
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
e331e246	2
071712b2	3	#include <net/if.h>
f39dbf28	4	#include <netinet/in.h>
7f06b3e1	5	#include <sys/capability.h>
071712b2	6
b5efdb8a	7	#include "alloc-util.h"
071712b2	8	#include "bus-common-errors.h"
7695e2cb	9	#include "bus-message-util.h"
269e4d2d	10	#include "bus-polkit.h"
54a16efe	11	#include "networkd-json.h"
7f3c07ad	12	#include "networkd-link-bus.h"
37d577c8	13	#include "networkd-link.h"
79a59fa5	14	#include "networkd-manager-bus.h"
23f53b99	15	#include "networkd-manager.h"
37d577c8	16	#include "path-util.h"
fc2ea97a	17	#include "socket-netlink.h"
51517f9e	18	#include "strv.h"
7f06b3e1	19	#include "user-util.h"
e331e246	20
37d577c8 YW	21	static int method_list_links(sd_bus_message message, void userdata, sd_bus_error *error) {
	22	_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
	23	Manager *manager = userdata;
37d577c8 YW	24	Link *link;
	25	int r;
	26
	27	r = sd_bus_message_new_method_return(message, &reply);
	28	if (r < 0)
	29	return r;
	30
	31	r = sd_bus_message_open_container(reply, 'a', "(iso)");
	32	if (r < 0)
	33	return r;
	34
90e74a66	35	HASHMAP_FOREACH(link, manager->links) {
37d577c8 YW	36	_cleanup_free_ char *path = NULL;
	37
	38	path = link_bus_path(link);
	39	if (!path)
	40	return -ENOMEM;
	41
	42	r = sd_bus_message_append(
	43	reply, "(iso)",
	44	link->ifindex,
	45	link->ifname,
	46	empty_to_root(path));
	47	if (r < 0)
	48	return r;
	49	}
	50
	51	r = sd_bus_message_close_container(reply);
	52	if (r < 0)
	53	return r;
	54
	55	return sd_bus_send(NULL, reply, NULL);
	56	}
	57
071712b2 YW	58	static int method_get_link_by_name(sd_bus_message message, void userdata, sd_bus_error *error) {
	59	_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
	60	_cleanup_free_ char *path = NULL;
	61	Manager *manager = userdata;
	62	const char *name;
	63	int index, r;
	64	Link *link;
	65
	66	r = sd_bus_message_read(message, "s", &name);
	67	if (r < 0)
	68	return r;
	69
fc2ea97a ZJS	70	index = resolve_ifname(&manager->rtnl, name);
	71	if (index < 0)
	72	return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %s cannot be resolved", name);
071712b2 YW	73
	74	link = hashmap_get(manager->links, INT_TO_PTR(index));
	75	if (!link)
	76	return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %s not known", name);
	77
	78	r = sd_bus_message_new_method_return(message, &reply);
	79	if (r < 0)
	80	return r;
	81
	82	path = link_bus_path(link);
	83	if (!path)
	84	return -ENOMEM;
	85
	86	r = sd_bus_message_append(reply, "io", link->ifindex, empty_to_root(path));
	87	if (r < 0)
	88	return r;
	89
	90	return sd_bus_send(NULL, reply, NULL);
	91	}
	92
	93	static int method_get_link_by_index(sd_bus_message message, void userdata, sd_bus_error *error) {
	94	_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
	95	_cleanup_free_ char *path = NULL;
	96	Manager *manager = userdata;
7695e2cb	97	int ifindex, r;
071712b2	98	Link *link;
071712b2	99
7695e2cb	100	r = bus_message_read_ifindex(message, error, &ifindex);
071712b2 YW	101	if (r < 0)
	102	return r;
	103
7695e2cb	104	link = hashmap_get(manager->links, INT_TO_PTR(ifindex));
071712b2	105	if (!link)
7695e2cb	106	return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %i not known", ifindex);
071712b2 YW	107
	108	r = sd_bus_message_new_method_return(message, &reply);
	109	if (r < 0)
	110	return r;
	111
	112	path = link_bus_path(link);
	113	if (!path)
	114	return -ENOMEM;
	115
	116	r = sd_bus_message_append(reply, "so", link->ifname, empty_to_root(path));
	117	if (r < 0)
	118	return r;
	119
	120	return sd_bus_send(NULL, reply, NULL);
	121	}
	122
15761549 YW	123	static int call_link_method(Manager m, sd_bus_message message, sd_bus_message_handler_t handler, sd_bus_error *error) {
	124	int ifindex, r;
	125	Link *l;
	126
	127	assert(m);
	128	assert(message);
	129	assert(handler);
	130
7695e2cb	131	r = bus_message_read_ifindex(message, error, &ifindex);
15761549 YW	132	if (r < 0)
	133	return r;
	134
15761549 YW	135	l = hashmap_get(m->links, INT_TO_PTR(ifindex));
	136	if (!l)
	137	return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %i not known", ifindex);
	138
	139	return handler(message, l, error);
	140	}
	141
	142	static int bus_method_set_link_ntp_servers(sd_bus_message message, void userdata, sd_bus_error *error) {
	143	return call_link_method(userdata, message, bus_link_method_set_ntp_servers, error);
	144	}
	145
	146	static int bus_method_set_link_dns_servers(sd_bus_message message, void userdata, sd_bus_error *error) {
	147	return call_link_method(userdata, message, bus_link_method_set_dns_servers, error);
	148	}
	149
4e11ddfd YW	150	static int bus_method_set_link_dns_servers_ex(sd_bus_message message, void userdata, sd_bus_error *error) {
	151	return call_link_method(userdata, message, bus_link_method_set_dns_servers_ex, error);
	152	}
	153
15761549 YW	154	static int bus_method_set_link_domains(sd_bus_message message, void userdata, sd_bus_error *error) {
	155	return call_link_method(userdata, message, bus_link_method_set_domains, error);
	156	}
	157
	158	static int bus_method_set_link_default_route(sd_bus_message message, void userdata, sd_bus_error *error) {
	159	return call_link_method(userdata, message, bus_link_method_set_default_route, error);
	160	}
	161
	162	static int bus_method_set_link_llmnr(sd_bus_message message, void userdata, sd_bus_error *error) {
	163	return call_link_method(userdata, message, bus_link_method_set_llmnr, error);
	164	}
	165
	166	static int bus_method_set_link_mdns(sd_bus_message message, void userdata, sd_bus_error *error) {
	167	return call_link_method(userdata, message, bus_link_method_set_mdns, error);
	168	}
	169
	170	static int bus_method_set_link_dns_over_tls(sd_bus_message message, void userdata, sd_bus_error *error) {
	171	return call_link_method(userdata, message, bus_link_method_set_dns_over_tls, error);
	172	}
	173
	174	static int bus_method_set_link_dnssec(sd_bus_message message, void userdata, sd_bus_error *error) {
	175	return call_link_method(userdata, message, bus_link_method_set_dnssec, error);
	176	}
	177
	178	static int bus_method_set_link_dnssec_negative_trust_anchors(sd_bus_message message, void userdata, sd_bus_error *error) {
	179	return call_link_method(userdata, message, bus_link_method_set_dnssec_negative_trust_anchors, error);
	180	}
	181
	182	static int bus_method_revert_link_ntp(sd_bus_message message, void userdata, sd_bus_error *error) {
	183	return call_link_method(userdata, message, bus_link_method_revert_ntp, error);
	184	}
	185
	186	static int bus_method_revert_link_dns(sd_bus_message message, void userdata, sd_bus_error *error) {
	187	return call_link_method(userdata, message, bus_link_method_revert_dns, error);
	188	}
	189
ae65d7db YW	190	static int bus_method_renew_link(sd_bus_message message, void userdata, sd_bus_error *error) {
	191	return call_link_method(userdata, message, bus_link_method_renew, error);
	192	}
	193
90867f6a SS	194	static int bus_method_force_renew_link(sd_bus_message message, void userdata, sd_bus_error *error) {
	195	return call_link_method(userdata, message, bus_link_method_force_renew, error);
	196	}
	197
99b8517c YW	198	static int bus_method_reconfigure_link(sd_bus_message message, void userdata, sd_bus_error *error) {
	199	return call_link_method(userdata, message, bus_link_method_reconfigure, error);
	200	}
	201
7f06b3e1 YW	202	static int bus_method_reload(sd_bus_message message, void userdata, sd_bus_error *error) {
7f06b3e1 YW	203	Manager *manager = userdata;
7f06b3e1 YW	204	Link *link;
	205	int r;
	206
	207	r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
	208	"org.freedesktop.network1.reload",
	209	NULL, true, UID_INVALID,
	210	&manager->polkit_registry, error);
	211	if (r < 0)
	212	return r;
	213	if (r == 0)
	214	return 1; /* Polkit will call us back */
	215
e272b621 YW	216	r = netdev_load(manager, true);
	217	if (r < 0)
	218	return r;
	219
7f06b3e1 YW	220	r = network_reload(manager);
	221	if (r < 0)
	222	return r;
	223
90e74a66	224	HASHMAP_FOREACH(link, manager->links) {
99b8517c	225	r = link_reconfigure(link, false);
7f06b3e1 YW	226	if (r < 0)
	227	return r;
	228	}
	229
	230	return sd_bus_reply_method_return(message, NULL);
	231	}
	232
54a16efe YW	233	static int bus_method_describe_link(sd_bus_message message, void userdata, sd_bus_error *error) {
	234	return call_link_method(userdata, message, bus_link_method_describe, error);
	235	}
	236
	237	static int bus_method_describe(sd_bus_message message, void userdata, sd_bus_error *error) {
	238	_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
	239	_cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
	240	_cleanup_free_ char *text = NULL;
	241	Manager *manager = userdata;
	242	int r;
	243
	244	assert(message);
	245	assert(manager);
	246
	247	r = manager_build_json(manager, &v);
	248	if (r < 0)
	249	return log_error_errno(r, "Failed to build JSON data: %m");
	250
	251	r = json_variant_format(v, 0, &text);
	252	if (r < 0)
	253	return log_error_errno(r, "Failed to format JSON data: %m");
	254
	255	r = sd_bus_message_new_method_return(message, &reply);
	256	if (r < 0)
	257	return r;
	258
	259	r = sd_bus_message_append(reply, "s", text);
	260	if (r < 0)
	261	return r;
	262
	263	return sd_bus_send(NULL, reply, NULL);
	264	}
	265
e331e246 TG	266	const sd_bus_vtable manager_vtable[] = {
	267	SD_BUS_VTABLE_START(0),
	268
	269	SD_BUS_PROPERTY("OperationalState", "s", property_get_operational_state, offsetof(Manager, operational_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
7f3c07ad YW	270	SD_BUS_PROPERTY("CarrierState", "s", property_get_carrier_state, offsetof(Manager, carrier_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
7f3c07ad YW	271	SD_BUS_PROPERTY("AddressState", "s", property_get_address_state, offsetof(Manager, address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
8430841b L	272	SD_BUS_PROPERTY("IPv4AddressState", "s", property_get_address_state, offsetof(Manager, ipv4_address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
8430841b L	273	SD_BUS_PROPERTY("IPv6AddressState", "s", property_get_address_state, offsetof(Manager, ipv6_address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
e331e246	274
23c32ff8 YW	275	SD_BUS_METHOD_WITH_ARGS("ListLinks",
	276	SD_BUS_NO_ARGS,
	277	SD_BUS_RESULT("a(iso)", links),
	278	method_list_links,
	279	SD_BUS_VTABLE_UNPRIVILEGED),
	280	SD_BUS_METHOD_WITH_ARGS("GetLinkByName",
	281	SD_BUS_ARGS("s", name),
	282	SD_BUS_RESULT("i", ifindex, "o", path),
	283	method_get_link_by_name,
	284	SD_BUS_VTABLE_UNPRIVILEGED),
	285	SD_BUS_METHOD_WITH_ARGS("GetLinkByIndex",
	286	SD_BUS_ARGS("i", ifindex),
	287	SD_BUS_RESULT("s", name, "o", path),
	288	method_get_link_by_index,
	289	SD_BUS_VTABLE_UNPRIVILEGED),
	290	SD_BUS_METHOD_WITH_ARGS("SetLinkNTP",
	291	SD_BUS_ARGS("i", ifindex, "as", servers),
	292	SD_BUS_NO_RESULT,
	293	bus_method_set_link_ntp_servers,
	294	SD_BUS_VTABLE_UNPRIVILEGED),
	295	SD_BUS_METHOD_WITH_ARGS("SetLinkDNS",
	296	SD_BUS_ARGS("i", ifindex, "a(iay)", addresses),
	297	SD_BUS_NO_RESULT,
	298	bus_method_set_link_dns_servers,
	299	SD_BUS_VTABLE_UNPRIVILEGED),
	300	SD_BUS_METHOD_WITH_ARGS("SetLinkDNSEx",
	301	SD_BUS_ARGS("i", ifindex, "a(iayqs)", addresses),
	302	SD_BUS_NO_RESULT,
	303	bus_method_set_link_dns_servers_ex,
	304	SD_BUS_VTABLE_UNPRIVILEGED),
	305	SD_BUS_METHOD_WITH_ARGS("SetLinkDomains",
	306	SD_BUS_ARGS("i", ifindex, "a(sb)", domains),
	307	SD_BUS_NO_RESULT,
	308	bus_method_set_link_domains,
	309	SD_BUS_VTABLE_UNPRIVILEGED),
	310	SD_BUS_METHOD_WITH_ARGS("SetLinkDefaultRoute",
	311	SD_BUS_ARGS("i", ifindex, "b", enable),
	312	SD_BUS_NO_RESULT,
	313	bus_method_set_link_default_route,
	314	SD_BUS_VTABLE_UNPRIVILEGED),
	315	SD_BUS_METHOD_WITH_ARGS("SetLinkLLMNR",
	316	SD_BUS_ARGS("i", ifindex, "s", mode),
	317	SD_BUS_NO_RESULT,
	318	bus_method_set_link_llmnr,
	319	SD_BUS_VTABLE_UNPRIVILEGED),
	320	SD_BUS_METHOD_WITH_ARGS("SetLinkMulticastDNS",
	321	SD_BUS_ARGS("i", ifindex, "s", mode),
	322	SD_BUS_NO_RESULT,
	323	bus_method_set_link_mdns,
	324	SD_BUS_VTABLE_UNPRIVILEGED),
	325	SD_BUS_METHOD_WITH_ARGS("SetLinkDNSOverTLS",
	326	SD_BUS_ARGS("i", ifindex, "s", mode),
	327	SD_BUS_NO_RESULT,
	328	bus_method_set_link_dns_over_tls,
	329	SD_BUS_VTABLE_UNPRIVILEGED),
	330	SD_BUS_METHOD_WITH_ARGS("SetLinkDNSSEC",
	331	SD_BUS_ARGS("i", ifindex, "s", mode),
	332	SD_BUS_NO_RESULT,
	333	bus_method_set_link_dnssec,
	334	SD_BUS_VTABLE_UNPRIVILEGED),
	335	SD_BUS_METHOD_WITH_ARGS("SetLinkDNSSECNegativeTrustAnchors",
	336	SD_BUS_ARGS("i", ifindex, "as", names),
	337	SD_BUS_NO_RESULT,
	338	bus_method_set_link_dnssec_negative_trust_anchors,
339	SD_BUS_VTABLE_UNPRIVILEGED),
340	SD_BUS_METHOD_WITH_ARGS("RevertLinkNTP",
341	SD_BUS_ARGS("i", ifindex),
342	SD_BUS_NO_RESULT,
343	bus_method_revert_link_ntp,
344	SD_BUS_VTABLE_UNPRIVILEGED),
345	SD_BUS_METHOD_WITH_ARGS("RevertLinkDNS",
346	SD_BUS_ARGS("i", ifindex),
347	SD_BUS_NO_RESULT,
348	bus_method_revert_link_dns,
349	SD_BUS_VTABLE_UNPRIVILEGED),
350	SD_BUS_METHOD_WITH_ARGS("RenewLink",
351	SD_BUS_ARGS("i", ifindex),
352	SD_BUS_NO_RESULT,
353	bus_method_renew_link,
354	SD_BUS_VTABLE_UNPRIVILEGED),
355	SD_BUS_METHOD_WITH_ARGS("ForceRenewLink",
356	SD_BUS_ARGS("i", ifindex),
357	SD_BUS_NO_RESULT,
358	bus_method_force_renew_link,
359	SD_BUS_VTABLE_UNPRIVILEGED),
360	SD_BUS_METHOD_WITH_ARGS("ReconfigureLink",
361	SD_BUS_ARGS("i", ifindex),
362	SD_BUS_NO_RESULT,
363	bus_method_reconfigure_link,
364	SD_BUS_VTABLE_UNPRIVILEGED),
365	SD_BUS_METHOD_WITH_ARGS("Reload",
366	SD_BUS_NO_ARGS,
367	SD_BUS_NO_RESULT,
368	bus_method_reload,
369	SD_BUS_VTABLE_UNPRIVILEGED),
54a16efe YW	370	SD_BUS_METHOD_WITH_ARGS("DescribeLink",
	371	SD_BUS_ARGS("i", ifindex),
	372	SD_BUS_RESULT("s", json),
	373	bus_method_describe_link,
	374	SD_BUS_VTABLE_UNPRIVILEGED),
	375	SD_BUS_METHOD_WITH_ARGS("Describe",
	376	SD_BUS_NO_ARGS,
	377	SD_BUS_RESULT("s", json),
	378	bus_method_describe,
	379	SD_BUS_VTABLE_UNPRIVILEGED),
37d577c8	380
e331e246 TG	381	SD_BUS_VTABLE_END
	382	};
	383
46606fdd	384	int manager_send_changed_strv(Manager manager, char *properties) {
e331e246	385	assert(manager);
46606fdd	386	assert(properties);
e331e246	387
5dbec9bd	388	if (sd_bus_is_ready(manager->bus) <= 0)
46606fdd	389	return 0;
e331e246 TG	390
	391	return sd_bus_emit_properties_changed_strv(
	392	manager->bus,
	393	"/org/freedesktop/network1",
	394	"org.freedesktop.network1.Manager",
46606fdd YW	395	properties);
46606fdd YW	396	}