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

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

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

#include "alloc-util.h"
#include "bus-common-errors.h"
#include "bus-util.h"
#include "networkd-link-bus.h"
#include "networkd-link.h"
#include "networkd-manager-bus.h"
#include "networkd-manager.h"
#include "path-util.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;
        Iterator i;
        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, i) {
                _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 = if_nametoindex(name);
        if (index <= 0)
                return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %s not known", 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;
        int32_t index;
        Link *link;
        int r;

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

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

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

        assert_cc(sizeof(int) == sizeof(int32_t));
        r = sd_bus_message_read(message, "i", &ifindex);
        if (r < 0)
                return r;

        if (ifindex <= 0)
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid interface index");

        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_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_reload(sd_bus_message *message, void *userdata, sd_bus_error *error) {
        Manager *manager = userdata;
        Iterator i;
        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, i) {
                r = link_reconfigure(link);
                if (r < 0)
                        return r;
        }

        return sd_bus_reply_method_return(message, 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_METHOD("ListLinks", NULL, "a(iso)", method_list_links, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("GetLinkByName", "s", "io", method_get_link_by_name, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("GetLinkByIndex", "i", "so", method_get_link_by_index, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("SetLinkNTP", "ias", NULL, bus_method_set_link_ntp_servers, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("SetLinkDNS", "ia(iay)", NULL, bus_method_set_link_dns_servers, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("SetLinkDomains", "ia(sb)", NULL, bus_method_set_link_domains, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("SetLinkDefaultRoute", "ib", NULL, bus_method_set_link_default_route, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("SetLinkLLMNR", "is", NULL, bus_method_set_link_llmnr, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("SetLinkMulticastDNS", "is", NULL, bus_method_set_link_mdns, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("SetLinkDNSOverTLS", "is", NULL, bus_method_set_link_dns_over_tls, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("SetLinkDNSSEC", "is", NULL, bus_method_set_link_dnssec, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("SetLinkDNSSECNegativeTrustAnchors", "ias", NULL, bus_method_set_link_dnssec_negative_trust_anchors, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("RevertLinkNTP", "i", NULL, bus_method_revert_link_ntp, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("RevertLinkDNS", "i", NULL, bus_method_revert_link_dns, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("RenewLink", "i", NULL, bus_method_renew_link, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("Reload", NULL, NULL, bus_method_reload, SD_BUS_VTABLE_UNPRIVILEGED),

        SD_BUS_VTABLE_END
};

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

        if (!manager->bus)
                return 0;

        return sd_bus_emit_properties_changed_strv(
                        manager->bus,
                        "/org/freedesktop/network1",
                        "org.freedesktop.network1.Manager",
                        properties);
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
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"
e331e246	9	#include "bus-util.h"
7f3c07ad	10	#include "networkd-link-bus.h"
37d577c8	11	#include "networkd-link.h"
79a59fa5	12	#include "networkd-manager-bus.h"
23f53b99	13	#include "networkd-manager.h"
37d577c8	14	#include "path-util.h"
51517f9e	15	#include "strv.h"
7f06b3e1	16	#include "user-util.h"
e331e246	17
37d577c8 YW	18	static int method_list_links(sd_bus_message message, void userdata, sd_bus_error *error) {
	19	_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
	20	Manager *manager = userdata;
	21	Iterator i;
	22	Link *link;
	23	int r;
	24
	25	r = sd_bus_message_new_method_return(message, &reply);
	26	if (r < 0)
	27	return r;
	28
	29	r = sd_bus_message_open_container(reply, 'a', "(iso)");
	30	if (r < 0)
	31	return r;
	32
	33	HASHMAP_FOREACH(link, manager->links, i) {
	34	_cleanup_free_ char *path = NULL;
	35
	36	path = link_bus_path(link);
	37	if (!path)
	38	return -ENOMEM;
	39
	40	r = sd_bus_message_append(
	41	reply, "(iso)",
	42	link->ifindex,
	43	link->ifname,
	44	empty_to_root(path));
	45	if (r < 0)
	46	return r;
	47	}
	48
	49	r = sd_bus_message_close_container(reply);
	50	if (r < 0)
	51	return r;
	52
	53	return sd_bus_send(NULL, reply, NULL);
	54	}
	55
071712b2 YW	56	static int method_get_link_by_name(sd_bus_message message, void userdata, sd_bus_error *error) {
	57	_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
	58	_cleanup_free_ char *path = NULL;
	59	Manager *manager = userdata;
	60	const char *name;
	61	int index, r;
	62	Link *link;
	63
	64	r = sd_bus_message_read(message, "s", &name);
	65	if (r < 0)
	66	return r;
	67
	68	index = if_nametoindex(name);
	69	if (index <= 0)
	70	return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %s not known", name);
	71
	72	link = hashmap_get(manager->links, INT_TO_PTR(index));
	73	if (!link)
	74	return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %s not known", name);
	75
	76	r = sd_bus_message_new_method_return(message, &reply);
	77	if (r < 0)
	78	return r;
	79
	80	path = link_bus_path(link);
	81	if (!path)
	82	return -ENOMEM;
	83
	84	r = sd_bus_message_append(reply, "io", link->ifindex, empty_to_root(path));
	85	if (r < 0)
	86	return r;
	87
	88	return sd_bus_send(NULL, reply, NULL);
	89	}
	90
	91	static int method_get_link_by_index(sd_bus_message message, void userdata, sd_bus_error *error) {
	92	_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
	93	_cleanup_free_ char *path = NULL;
	94	Manager *manager = userdata;
	95	int32_t index;
	96	Link *link;
	97	int r;
	98
	99	r = sd_bus_message_read(message, "i", &index);
	100	if (r < 0)
	101	return r;
	102
	103	link = hashmap_get(manager->links, INT_TO_PTR((int) index));
	104	if (!link)
	105	return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %" PRIi32 " not known", index);
	106
	107	r = sd_bus_message_new_method_return(message, &reply);
	108	if (r < 0)
	109	return r;
	110
	111	path = link_bus_path(link);
	112	if (!path)
	113	return -ENOMEM;
	114
	115	r = sd_bus_message_append(reply, "so", link->ifname, empty_to_root(path));
	116	if (r < 0)
	117	return r;
	118
	119	return sd_bus_send(NULL, reply, NULL);
120	}
121
15761549 YW	122	static int call_link_method(Manager m, sd_bus_message message, sd_bus_message_handler_t handler, sd_bus_error *error) {
	123	int ifindex, r;
	124	Link *l;
	125
	126	assert(m);
	127	assert(message);
	128	assert(handler);
	129
	130	assert_cc(sizeof(int) == sizeof(int32_t));
	131	r = sd_bus_message_read(message, "i", &ifindex);
	132	if (r < 0)
	133	return r;
	134
	135	if (ifindex <= 0)
	136	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid interface index");
	137
	138	l = hashmap_get(m->links, INT_TO_PTR(ifindex));
	139	if (!l)
	140	return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_LINK, "Link %i not known", ifindex);
	141
	142	return handler(message, l, error);
	143	}
	144
	145	static int bus_method_set_link_ntp_servers(sd_bus_message message, void userdata, sd_bus_error *error) {
	146	return call_link_method(userdata, message, bus_link_method_set_ntp_servers, error);
	147	}
	148
	149	static int bus_method_set_link_dns_servers(sd_bus_message message, void userdata, sd_bus_error *error) {
	150	return call_link_method(userdata, message, bus_link_method_set_dns_servers, error);
	151	}
	152
	153	static int bus_method_set_link_domains(sd_bus_message message, void userdata, sd_bus_error *error) {
	154	return call_link_method(userdata, message, bus_link_method_set_domains, error);
	155	}
	156
	157	static int bus_method_set_link_default_route(sd_bus_message message, void userdata, sd_bus_error *error) {
	158	return call_link_method(userdata, message, bus_link_method_set_default_route, error);
	159	}
	160
	161	static int bus_method_set_link_llmnr(sd_bus_message message, void userdata, sd_bus_error *error) {
	162	return call_link_method(userdata, message, bus_link_method_set_llmnr, error);
	163	}
	164
	165	static int bus_method_set_link_mdns(sd_bus_message message, void userdata, sd_bus_error *error) {
	166	return call_link_method(userdata, message, bus_link_method_set_mdns, error);
	167	}
	168
	169	static int bus_method_set_link_dns_over_tls(sd_bus_message message, void userdata, sd_bus_error *error) {
	170	return call_link_method(userdata, message, bus_link_method_set_dns_over_tls, error);
	171	}
	172
	173	static int bus_method_set_link_dnssec(sd_bus_message message, void userdata, sd_bus_error *error) {
	174	return call_link_method(userdata, message, bus_link_method_set_dnssec, error);
	175	}
	176
	177	static int bus_method_set_link_dnssec_negative_trust_anchors(sd_bus_message message, void userdata, sd_bus_error *error) {
	178	return call_link_method(userdata, message, bus_link_method_set_dnssec_negative_trust_anchors, error);
	179	}
	180
	181	static int bus_method_revert_link_ntp(sd_bus_message message, void userdata, sd_bus_error *error) {
	182	return call_link_method(userdata, message, bus_link_method_revert_ntp, error);
	183	}
	184
	185	static int bus_method_revert_link_dns(sd_bus_message message, void userdata, sd_bus_error *error) {
186	return call_link_method(userdata, message, bus_link_method_revert_dns, error);
187	}
188
ae65d7db YW	189	static int bus_method_renew_link(sd_bus_message message, void userdata, sd_bus_error *error) {
	190	return call_link_method(userdata, message, bus_link_method_renew, error);
	191	}
	192
7f06b3e1 YW	193	static int bus_method_reload(sd_bus_message message, void userdata, sd_bus_error *error) {
	194	Manager *manager = userdata;
	195	Iterator i;
	196	Link *link;
	197	int r;
	198
	199	r = bus_verify_polkit_async(message, CAP_NET_ADMIN,
	200	"org.freedesktop.network1.reload",
	201	NULL, true, UID_INVALID,
	202	&manager->polkit_registry, error);
	203	if (r < 0)
	204	return r;
	205	if (r == 0)
	206	return 1; /* Polkit will call us back */
	207
e272b621 YW	208	r = netdev_load(manager, true);
	209	if (r < 0)
	210	return r;
	211
7f06b3e1 YW	212	r = network_reload(manager);
	213	if (r < 0)
	214	return r;
	215
	216	HASHMAP_FOREACH(link, manager->links, i) {
	217	r = link_reconfigure(link);
	218	if (r < 0)
	219	return r;
	220	}
	221
	222	return sd_bus_reply_method_return(message, NULL);
	223	}
	224
e331e246 TG	225	const sd_bus_vtable manager_vtable[] = {
	226	SD_BUS_VTABLE_START(0),
	227
	228	SD_BUS_PROPERTY("OperationalState", "s", property_get_operational_state, offsetof(Manager, operational_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
7f3c07ad YW	229	SD_BUS_PROPERTY("CarrierState", "s", property_get_carrier_state, offsetof(Manager, carrier_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
7f3c07ad YW	230	SD_BUS_PROPERTY("AddressState", "s", property_get_address_state, offsetof(Manager, address_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
e331e246	231
37d577c8	232	SD_BUS_METHOD("ListLinks", NULL, "a(iso)", method_list_links, SD_BUS_VTABLE_UNPRIVILEGED),
071712b2 YW	233	SD_BUS_METHOD("GetLinkByName", "s", "io", method_get_link_by_name, SD_BUS_VTABLE_UNPRIVILEGED),
071712b2 YW	234	SD_BUS_METHOD("GetLinkByIndex", "i", "so", method_get_link_by_index, SD_BUS_VTABLE_UNPRIVILEGED),
15761549 YW	235	SD_BUS_METHOD("SetLinkNTP", "ias", NULL, bus_method_set_link_ntp_servers, SD_BUS_VTABLE_UNPRIVILEGED),
	236	SD_BUS_METHOD("SetLinkDNS", "ia(iay)", NULL, bus_method_set_link_dns_servers, SD_BUS_VTABLE_UNPRIVILEGED),
	237	SD_BUS_METHOD("SetLinkDomains", "ia(sb)", NULL, bus_method_set_link_domains, SD_BUS_VTABLE_UNPRIVILEGED),
	238	SD_BUS_METHOD("SetLinkDefaultRoute", "ib", NULL, bus_method_set_link_default_route, SD_BUS_VTABLE_UNPRIVILEGED),
	239	SD_BUS_METHOD("SetLinkLLMNR", "is", NULL, bus_method_set_link_llmnr, SD_BUS_VTABLE_UNPRIVILEGED),
	240	SD_BUS_METHOD("SetLinkMulticastDNS", "is", NULL, bus_method_set_link_mdns, SD_BUS_VTABLE_UNPRIVILEGED),
	241	SD_BUS_METHOD("SetLinkDNSOverTLS", "is", NULL, bus_method_set_link_dns_over_tls, SD_BUS_VTABLE_UNPRIVILEGED),
	242	SD_BUS_METHOD("SetLinkDNSSEC", "is", NULL, bus_method_set_link_dnssec, SD_BUS_VTABLE_UNPRIVILEGED),
	243	SD_BUS_METHOD("SetLinkDNSSECNegativeTrustAnchors", "ias", NULL, bus_method_set_link_dnssec_negative_trust_anchors, SD_BUS_VTABLE_UNPRIVILEGED),
	244	SD_BUS_METHOD("RevertLinkNTP", "i", NULL, bus_method_revert_link_ntp, SD_BUS_VTABLE_UNPRIVILEGED),
	245	SD_BUS_METHOD("RevertLinkDNS", "i", NULL, bus_method_revert_link_dns, SD_BUS_VTABLE_UNPRIVILEGED),
ae65d7db	246	SD_BUS_METHOD("RenewLink", "i", NULL, bus_method_renew_link, SD_BUS_VTABLE_UNPRIVILEGED),
7f06b3e1	247	SD_BUS_METHOD("Reload", NULL, NULL, bus_method_reload, SD_BUS_VTABLE_UNPRIVILEGED),
37d577c8	248
e331e246 TG	249	SD_BUS_VTABLE_END
	250	};
	251
46606fdd	252	int manager_send_changed_strv(Manager manager, char *properties) {
e331e246	253	assert(manager);
46606fdd	254	assert(properties);
e331e246	255
4852e159	256	if (!manager->bus)
46606fdd	257	return 0;
e331e246 TG	258
	259	return sd_bus_emit_properties_changed_strv(
	260	manager->bus,
	261	"/org/freedesktop/network1",
	262	"org.freedesktop.network1.Manager",
46606fdd YW	263	properties);
46606fdd YW	264	}