[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 "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;
        Link *link;
        int r;

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

        if (link_get_by_name(manager, name, &link) < 0)
                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);
}

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

        uint64_t id = 0;
        struct stat st;

        assert(bus);
        assert(reply);

        /* Returns our own network namespace ID, i.e. the inode number of /proc/self/ns/net. This allows
         * unprivileged clients to determine whether they are in the same network namespace as us (note that
         * access to that path is restricted, thus they can't check directly unless privileged). */

        if (stat("/proc/self/ns/net", &st) < 0) {
                log_warning_errno(errno, "Failed to stat network namespace, ignoring: %m");
                id = 0;
        } else
                id = st.st_ino;

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

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_PROPERTY("OnlineState", "s", property_get_online_state, offsetof(Manager, online_state), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("NamespaceId", "t", property_get_namespace_id, 0, SD_BUS_VTABLE_PROPERTY_CONST),

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