1 /* SPDX-License-Identifier: LGPL-2.1+ */
4 #include <netinet/in.h>
5 #include <sys/capability.h>
7 #include "alloc-util.h"
8 #include "bus-common-errors.h"
10 #include "dns-domain.h"
11 #include "networkd-link-bus.h"
12 #include "networkd-link.h"
13 #include "networkd-manager.h"
14 #include "parse-util.h"
15 #include "resolve-util.h"
17 #include "user-util.h"
19 BUS_DEFINE_PROPERTY_GET_ENUM(property_get_operational_state
, link_operstate
, LinkOperationalState
);
20 BUS_DEFINE_PROPERTY_GET_ENUM(property_get_carrier_state
, link_carrier_state
, LinkCarrierState
);
21 BUS_DEFINE_PROPERTY_GET_ENUM(property_get_address_state
, link_address_state
, LinkAddressState
);
22 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_administrative_state
, link_state
, LinkState
);
24 static int property_get_bit_rates(
27 const char *interface
,
29 sd_bus_message
*reply
,
31 sd_bus_error
*error
) {
33 Link
*link
= userdata
;
42 manager
= link
->manager
;
44 if (!manager
->use_speed_meter
)
45 return sd_bus_error_set(error
, BUS_ERROR_SPEED_METER_INACTIVE
, "Speed meter is disabled.");
47 if (manager
->speed_meter_usec_old
== 0)
48 return sd_bus_error_set(error
, BUS_ERROR_SPEED_METER_INACTIVE
, "Speed meter is not active.");
50 if (!link
->stats_updated
)
51 return sd_bus_error_set(error
, BUS_ERROR_SPEED_METER_INACTIVE
, "Failed to measure bit-rates.");
53 assert(manager
->speed_meter_usec_new
> manager
->speed_meter_usec_old
);
54 interval_sec
= (manager
->speed_meter_usec_new
- manager
->speed_meter_usec_old
) / USEC_PER_SEC
;
56 if (link
->stats_new
.tx_bytes
> link
->stats_old
.tx_bytes
)
57 tx
= (uint64_t) ((link
->stats_new
.tx_bytes
- link
->stats_old
.tx_bytes
) / interval_sec
);
59 tx
= (uint64_t) ((UINT64_MAX
- (link
->stats_old
.tx_bytes
- link
->stats_new
.tx_bytes
)) / interval_sec
);
61 if (link
->stats_new
.rx_bytes
> link
->stats_old
.rx_bytes
)
62 rx
= (uint64_t) ((link
->stats_new
.rx_bytes
- link
->stats_old
.rx_bytes
) / interval_sec
);
64 rx
= (uint64_t) ((UINT64_MAX
- (link
->stats_old
.rx_bytes
- link
->stats_new
.rx_bytes
)) / interval_sec
);
66 return sd_bus_message_append(reply
, "(tt)", tx
, rx
);
69 static int verify_managed_link(Link
*l
, sd_bus_error
*error
) {
72 if (l
->flags
& IFF_LOOPBACK
)
73 return sd_bus_error_setf(error
, BUS_ERROR_LINK_BUSY
, "Link %s is loopback device.", l
->ifname
);
78 int bus_link_method_set_ntp_servers(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
79 _cleanup_strv_free_
char **ntp
= NULL
;
87 r
= verify_managed_link(l
, error
);
91 r
= sd_bus_message_read_strv(message
, &ntp
);
95 STRV_FOREACH(i
, ntp
) {
96 r
= dns_name_is_valid_or_address(*i
);
100 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid NTP server: %s", *i
);
103 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
104 "org.freedesktop.network1.set-ntp-servers",
105 NULL
, true, UID_INVALID
,
106 &l
->manager
->polkit_registry
, error
);
110 return 1; /* Polkit will call us back */
112 strv_free_and_replace(l
->ntp
, ntp
);
114 (void) link_dirty(l
);
116 return sd_bus_reply_method_return(message
, NULL
);
119 int bus_link_method_set_dns_servers(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
120 _cleanup_free_
struct in_addr_data
*dns
= NULL
;
121 size_t allocated
= 0, n
= 0;
128 r
= verify_managed_link(l
, error
);
132 r
= sd_bus_message_enter_container(message
, 'a', "(iay)");
141 assert_cc(sizeof(int) == sizeof(int32_t));
143 r
= sd_bus_message_enter_container(message
, 'r', "iay");
149 r
= sd_bus_message_read(message
, "i", &family
);
153 if (!IN_SET(family
, AF_INET
, AF_INET6
))
154 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Unknown address family %i", family
);
156 r
= sd_bus_message_read_array(message
, 'y', &d
, &sz
);
159 if (sz
!= FAMILY_ADDRESS_SIZE(family
))
160 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid address size");
162 if (!dns_server_address_valid(family
, d
))
163 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid DNS server address");
165 r
= sd_bus_message_exit_container(message
);
169 if (!GREEDY_REALLOC(dns
, allocated
, n
+1))
172 dns
[n
].family
= family
;
173 memcpy(&dns
[n
].address
, d
, sz
);
177 r
= sd_bus_message_exit_container(message
);
181 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
182 "org.freedesktop.network1.set-dns-servers",
183 NULL
, true, UID_INVALID
,
184 &l
->manager
->polkit_registry
, error
);
188 return 1; /* Polkit will call us back */
190 free_and_replace(l
->dns
, dns
);
193 (void) link_dirty(l
);
195 return sd_bus_reply_method_return(message
, NULL
);
198 int bus_link_method_set_domains(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
199 _cleanup_(ordered_set_freep
) OrderedSet
*search_domains
= NULL
, *route_domains
= NULL
;
206 r
= verify_managed_link(l
, error
);
210 r
= sd_bus_message_enter_container(message
, 'a', "(sb)");
215 _cleanup_free_
char *str
= NULL
;
216 OrderedSet
**domains
;
220 r
= sd_bus_message_read(message
, "(sb)", &name
, &route_only
);
226 r
= dns_name_is_valid(name
);
230 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid search domain %s", name
);
231 if (!route_only
&& dns_name_is_root(name
))
232 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Root domain is not suitable as search domain");
234 r
= dns_name_normalize(name
, 0, &str
);
236 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid search domain %s", name
);
238 domains
= route_only
? &route_domains
: &search_domains
;
239 r
= ordered_set_ensure_allocated(domains
, &string_hash_ops
);
243 r
= ordered_set_put(*domains
, str
);
250 r
= sd_bus_message_exit_container(message
);
254 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
255 "org.freedesktop.network1.set-domains",
256 NULL
, true, UID_INVALID
,
257 &l
->manager
->polkit_registry
, error
);
261 return 1; /* Polkit will call us back */
263 ordered_set_free_free(l
->search_domains
);
264 ordered_set_free_free(l
->route_domains
);
265 l
->search_domains
= TAKE_PTR(search_domains
);
266 l
->route_domains
= TAKE_PTR(route_domains
);
268 (void) link_dirty(l
);
270 return sd_bus_reply_method_return(message
, NULL
);
273 int bus_link_method_set_default_route(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
280 r
= verify_managed_link(l
, error
);
284 r
= sd_bus_message_read(message
, "b", &b
);
288 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
289 "org.freedesktop.network1.set-default-route",
290 NULL
, true, UID_INVALID
,
291 &l
->manager
->polkit_registry
, error
);
295 return 1; /* Polkit will call us back */
297 if (l
->dns_default_route
!= b
) {
298 l
->dns_default_route
= b
;
299 (void) link_dirty(l
);
302 return sd_bus_reply_method_return(message
, NULL
);
305 int bus_link_method_set_llmnr(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
314 r
= verify_managed_link(l
, error
);
318 r
= sd_bus_message_read(message
, "s", &llmnr
);
323 mode
= RESOLVE_SUPPORT_YES
;
325 mode
= resolve_support_from_string(llmnr
);
327 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid LLMNR setting: %s", llmnr
);
330 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
331 "org.freedesktop.network1.set-llmnr",
332 NULL
, true, UID_INVALID
,
333 &l
->manager
->polkit_registry
, error
);
337 return 1; /* Polkit will call us back */
339 if (l
->llmnr
!= mode
) {
341 (void) link_dirty(l
);
344 return sd_bus_reply_method_return(message
, NULL
);
347 int bus_link_method_set_mdns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
356 r
= verify_managed_link(l
, error
);
360 r
= sd_bus_message_read(message
, "s", &mdns
);
365 mode
= RESOLVE_SUPPORT_NO
;
367 mode
= resolve_support_from_string(mdns
);
369 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid MulticastDNS setting: %s", mdns
);
372 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
373 "org.freedesktop.network1.set-mdns",
374 NULL
, true, UID_INVALID
,
375 &l
->manager
->polkit_registry
, error
);
379 return 1; /* Polkit will call us back */
381 if (l
->mdns
!= mode
) {
383 (void) link_dirty(l
);
386 return sd_bus_reply_method_return(message
, NULL
);
389 int bus_link_method_set_dns_over_tls(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
391 const char *dns_over_tls
;
398 r
= verify_managed_link(l
, error
);
402 r
= sd_bus_message_read(message
, "s", &dns_over_tls
);
406 if (isempty(dns_over_tls
))
407 mode
= _DNS_OVER_TLS_MODE_INVALID
;
409 mode
= dns_over_tls_mode_from_string(dns_over_tls
);
411 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid DNSOverTLS setting: %s", dns_over_tls
);
414 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
415 "org.freedesktop.network1.set-dns-over-tls",
416 NULL
, true, UID_INVALID
,
417 &l
->manager
->polkit_registry
, error
);
421 return 1; /* Polkit will call us back */
423 if (l
->dns_over_tls_mode
!= mode
) {
424 l
->dns_over_tls_mode
= mode
;
425 (void) link_dirty(l
);
428 return sd_bus_reply_method_return(message
, NULL
);
431 int bus_link_method_set_dnssec(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
440 r
= verify_managed_link(l
, error
);
444 r
= sd_bus_message_read(message
, "s", &dnssec
);
449 mode
= _DNSSEC_MODE_INVALID
;
451 mode
= dnssec_mode_from_string(dnssec
);
453 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid DNSSEC setting: %s", dnssec
);
456 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
457 "org.freedesktop.network1.set-dnssec",
458 NULL
, true, UID_INVALID
,
459 &l
->manager
->polkit_registry
, error
);
463 return 1; /* Polkit will call us back */
465 if (l
->dnssec_mode
!= mode
) {
466 l
->dnssec_mode
= mode
;
467 (void) link_dirty(l
);
470 return sd_bus_reply_method_return(message
, NULL
);
473 int bus_link_method_set_dnssec_negative_trust_anchors(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
474 _cleanup_set_free_free_ Set
*ns
= NULL
;
475 _cleanup_strv_free_
char **ntas
= NULL
;
483 r
= verify_managed_link(l
, error
);
487 r
= sd_bus_message_read_strv(message
, &ntas
);
491 STRV_FOREACH(i
, ntas
) {
492 r
= dns_name_is_valid(*i
);
496 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid negative trust anchor domain: %s", *i
);
499 ns
= set_new(&dns_name_hash_ops
);
503 STRV_FOREACH(i
, ntas
) {
504 r
= set_put_strdup(ns
, *i
);
509 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
510 "org.freedesktop.network1.set-dnssec-negative-trust-anchors",
511 NULL
, true, UID_INVALID
,
512 &l
->manager
->polkit_registry
, error
);
516 return 1; /* Polkit will call us back */
518 set_free_free(l
->dnssec_negative_trust_anchors
);
519 l
->dnssec_negative_trust_anchors
= TAKE_PTR(ns
);
521 (void) link_dirty(l
);
523 return sd_bus_reply_method_return(message
, NULL
);
526 int bus_link_method_revert_ntp(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
533 r
= verify_managed_link(l
, error
);
537 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
538 "org.freedesktop.network1.revert-ntp",
539 NULL
, true, UID_INVALID
,
540 &l
->manager
->polkit_registry
, error
);
544 return 1; /* Polkit will call us back */
546 link_ntp_settings_clear(l
);
547 (void) link_dirty(l
);
549 return sd_bus_reply_method_return(message
, NULL
);
552 int bus_link_method_revert_dns(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
559 r
= verify_managed_link(l
, error
);
563 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
564 "org.freedesktop.network1.revert-dns",
565 NULL
, true, UID_INVALID
,
566 &l
->manager
->polkit_registry
, error
);
570 return 1; /* Polkit will call us back */
572 link_dns_settings_clear(l
);
573 (void) link_dirty(l
);
575 return sd_bus_reply_method_return(message
, NULL
);
578 int bus_link_method_renew(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
585 return sd_bus_error_setf(error
, BUS_ERROR_UNMANAGED_INTERFACE
,
586 "Interface %s is not managed by systemd-networkd",
589 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
590 "org.freedesktop.network1.renew",
591 NULL
, true, UID_INVALID
,
592 &l
->manager
->polkit_registry
, error
);
596 return 1; /* Polkit will call us back */
598 if (l
->dhcp_client
) {
599 r
= sd_dhcp_client_send_renew(l
->dhcp_client
);
604 return sd_bus_reply_method_return(message
, NULL
);
607 int bus_link_method_reconfigure(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
614 r
= bus_verify_polkit_async(message
, CAP_NET_ADMIN
,
615 "org.freedesktop.network1.reconfigure",
616 NULL
, true, UID_INVALID
,
617 &l
->manager
->polkit_registry
, error
);
621 return 1; /* Polkit will call us back */
623 r
= link_reconfigure(l
, true);
627 return sd_bus_reply_method_return(message
, NULL
);
630 const sd_bus_vtable link_vtable
[] = {
631 SD_BUS_VTABLE_START(0),
633 SD_BUS_PROPERTY("OperationalState", "s", property_get_operational_state
, offsetof(Link
, operstate
), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
634 SD_BUS_PROPERTY("CarrierState", "s", property_get_carrier_state
, offsetof(Link
, carrier_state
), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
635 SD_BUS_PROPERTY("AddressState", "s", property_get_address_state
, offsetof(Link
, address_state
), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
636 SD_BUS_PROPERTY("AdministrativeState", "s", property_get_administrative_state
, offsetof(Link
, state
), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
637 SD_BUS_PROPERTY("BitRates", "(tt)", property_get_bit_rates
, 0, 0),
639 SD_BUS_METHOD("SetNTP", "as", NULL
, bus_link_method_set_ntp_servers
, SD_BUS_VTABLE_UNPRIVILEGED
),
640 SD_BUS_METHOD("SetDNS", "a(iay)", NULL
, bus_link_method_set_dns_servers
, SD_BUS_VTABLE_UNPRIVILEGED
),
641 SD_BUS_METHOD("SetDomains", "a(sb)", NULL
, bus_link_method_set_domains
, SD_BUS_VTABLE_UNPRIVILEGED
),
642 SD_BUS_METHOD("SetDefaultRoute", "b", NULL
, bus_link_method_set_default_route
, SD_BUS_VTABLE_UNPRIVILEGED
),
643 SD_BUS_METHOD("SetLLMNR", "s", NULL
, bus_link_method_set_llmnr
, SD_BUS_VTABLE_UNPRIVILEGED
),
644 SD_BUS_METHOD("SetMulticastDNS", "s", NULL
, bus_link_method_set_mdns
, SD_BUS_VTABLE_UNPRIVILEGED
),
645 SD_BUS_METHOD("SetDNSOverTLS", "s", NULL
, bus_link_method_set_dns_over_tls
, SD_BUS_VTABLE_UNPRIVILEGED
),
646 SD_BUS_METHOD("SetDNSSEC", "s", NULL
, bus_link_method_set_dnssec
, SD_BUS_VTABLE_UNPRIVILEGED
),
647 SD_BUS_METHOD("SetDNSSECNegativeTrustAnchors", "as", NULL
, bus_link_method_set_dnssec_negative_trust_anchors
, SD_BUS_VTABLE_UNPRIVILEGED
),
648 SD_BUS_METHOD("RevertNTP", NULL
, NULL
, bus_link_method_revert_ntp
, SD_BUS_VTABLE_UNPRIVILEGED
),
649 SD_BUS_METHOD("RevertDNS", NULL
, NULL
, bus_link_method_revert_dns
, SD_BUS_VTABLE_UNPRIVILEGED
),
650 SD_BUS_METHOD("Renew", NULL
, NULL
, bus_link_method_renew
, SD_BUS_VTABLE_UNPRIVILEGED
),
651 SD_BUS_METHOD("Reconfigure", NULL
, NULL
, bus_link_method_reconfigure
, SD_BUS_VTABLE_UNPRIVILEGED
),
656 char *link_bus_path(Link
*link
) {
657 _cleanup_free_
char *ifindex
= NULL
;
662 assert(link
->ifindex
> 0);
664 if (asprintf(&ifindex
, "%d", link
->ifindex
) < 0)
667 r
= sd_bus_path_encode("/org/freedesktop/network1/link", ifindex
, &p
);
674 int link_node_enumerator(sd_bus
*bus
, const char *path
, void *userdata
, char ***nodes
, sd_bus_error
*error
) {
675 _cleanup_strv_free_
char **l
= NULL
;
676 Manager
*m
= userdata
;
686 l
= new0(char*, hashmap_size(m
->links
) + 1);
690 HASHMAP_FOREACH(link
, m
->links
, i
) {
693 p
= link_bus_path(link
);
701 *nodes
= TAKE_PTR(l
);
706 int link_object_find(sd_bus
*bus
, const char *path
, const char *interface
, void *userdata
, void **found
, sd_bus_error
*error
) {
707 _cleanup_free_
char *identifier
= NULL
;
708 Manager
*m
= userdata
;
718 r
= sd_bus_path_decode(path
, "/org/freedesktop/network1/link", &identifier
);
722 r
= parse_ifindex(identifier
, &ifindex
);
726 r
= link_get(m
, ifindex
, &link
);
735 int link_send_changed_strv(Link
*link
, char **properties
) {
736 _cleanup_free_
char *p
= NULL
;
739 assert(link
->manager
);
742 if (!link
->manager
->bus
)
745 p
= link_bus_path(link
);
749 return sd_bus_emit_properties_changed_strv(
752 "org.freedesktop.network1.Link",
756 int link_send_changed(Link
*link
, const char *property
, ...) {
759 properties
= strv_from_stdarg_alloca(property
);
761 return link_send_changed_strv(link
, properties
);