1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2013 Tom Gundersen <teg@jklm.no>
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 #include <netinet/ether.h>
24 #include <stdio_ext.h>
26 #include "alloc-util.h"
28 #include "dhcp-lease-internal.h"
31 #include "netlink-util.h"
32 #include "network-internal.h"
33 #include "networkd-ipv6-proxy-ndp.h"
34 #include "networkd-lldp-tx.h"
35 #include "networkd-manager.h"
36 #include "networkd-ndisc.h"
37 #include "networkd-radv.h"
38 #include "networkd-routing-policy-rule.h"
40 #include "socket-util.h"
41 #include "stdio-util.h"
42 #include "string-table.h"
43 #include "udev-util.h"
47 static bool link_dhcp6_enabled(Link
*link
) {
50 if (!socket_ipv6_is_supported())
53 if (link
->flags
& IFF_LOOPBACK
)
59 return link
->network
->dhcp
& ADDRESS_FAMILY_IPV6
;
62 static bool link_dhcp4_enabled(Link
*link
) {
65 if (link
->flags
& IFF_LOOPBACK
)
71 return link
->network
->dhcp
& ADDRESS_FAMILY_IPV4
;
74 static bool link_dhcp4_server_enabled(Link
*link
) {
77 if (link
->flags
& IFF_LOOPBACK
)
83 return link
->network
->dhcp_server
;
86 static bool link_ipv4ll_enabled(Link
*link
) {
89 if (link
->flags
& IFF_LOOPBACK
)
95 return link
->network
->link_local
& ADDRESS_FAMILY_IPV4
;
98 static bool link_ipv6ll_enabled(Link
*link
) {
101 if (!socket_ipv6_is_supported())
104 if (link
->flags
& IFF_LOOPBACK
)
110 return link
->network
->link_local
& ADDRESS_FAMILY_IPV6
;
113 static bool link_ipv6_enabled(Link
*link
) {
116 if (!socket_ipv6_is_supported())
119 if (link
->network
->bridge
)
122 /* DHCPv6 client will not be started if no IPv6 link-local address is configured. */
123 return link_ipv6ll_enabled(link
) || network_has_static_ipv6_addresses(link
->network
);
126 static bool link_radv_enabled(Link
*link
) {
129 if (!link_ipv6ll_enabled(link
))
132 return link
->network
->router_prefix_delegation
;
135 static bool link_lldp_rx_enabled(Link
*link
) {
138 if (link
->flags
& IFF_LOOPBACK
)
141 if (link
->iftype
!= ARPHRD_ETHER
)
147 /* LLDP should be handled on bridge slaves as those have a direct
148 * connection to their peers not on the bridge master. Linux doesn't
149 * even (by default) forward lldp packets to the bridge master.*/
150 if (streq_ptr("bridge", link
->kind
))
153 return link
->network
->lldp_mode
!= LLDP_MODE_NO
;
156 static bool link_lldp_emit_enabled(Link
*link
) {
159 if (link
->flags
& IFF_LOOPBACK
)
162 if (link
->iftype
!= ARPHRD_ETHER
)
168 return link
->network
->lldp_emit
!= LLDP_EMIT_NO
;
171 static bool link_ipv4_forward_enabled(Link
*link
) {
174 if (link
->flags
& IFF_LOOPBACK
)
180 if (link
->network
->ip_forward
== _ADDRESS_FAMILY_BOOLEAN_INVALID
)
183 return link
->network
->ip_forward
& ADDRESS_FAMILY_IPV4
;
186 static bool link_ipv6_forward_enabled(Link
*link
) {
189 if (!socket_ipv6_is_supported())
192 if (link
->flags
& IFF_LOOPBACK
)
198 if (link
->network
->ip_forward
== _ADDRESS_FAMILY_BOOLEAN_INVALID
)
201 return link
->network
->ip_forward
& ADDRESS_FAMILY_IPV6
;
204 static bool link_proxy_arp_enabled(Link
*link
) {
207 if (link
->flags
& IFF_LOOPBACK
)
213 if (link
->network
->proxy_arp
< 0)
219 static bool link_ipv6_accept_ra_enabled(Link
*link
) {
222 if (!socket_ipv6_is_supported())
225 if (link
->flags
& IFF_LOOPBACK
)
231 if (!link_ipv6ll_enabled(link
))
234 /* If unset use system default (enabled if local forwarding is disabled.
235 * disabled if local forwarding is enabled).
236 * If set, ignore or enforce RA independent of local forwarding state.
238 if (link
->network
->ipv6_accept_ra
< 0)
239 /* default to accept RA if ip_forward is disabled and ignore RA if ip_forward is enabled */
240 return !link_ipv6_forward_enabled(link
);
241 else if (link
->network
->ipv6_accept_ra
> 0)
242 /* accept RA even if ip_forward is enabled */
249 static IPv6PrivacyExtensions
link_ipv6_privacy_extensions(Link
*link
) {
252 if (!socket_ipv6_is_supported())
253 return _IPV6_PRIVACY_EXTENSIONS_INVALID
;
255 if (link
->flags
& IFF_LOOPBACK
)
256 return _IPV6_PRIVACY_EXTENSIONS_INVALID
;
259 return _IPV6_PRIVACY_EXTENSIONS_INVALID
;
261 return link
->network
->ipv6_privacy_extensions
;
264 static int link_enable_ipv6(Link
*link
) {
265 const char *p
= NULL
;
269 if (link
->flags
& IFF_LOOPBACK
)
272 disabled
= !link_ipv6_enabled(link
);
274 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/disable_ipv6");
276 r
= write_string_file(p
, one_zero(disabled
), WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
278 log_link_warning_errno(link
, r
, "Cannot %s IPv6 for interface %s: %m",
279 enable_disable(!disabled
), link
->ifname
);
281 log_link_info(link
, "IPv6 successfully %sd", enable_disable(!disabled
));
286 void link_update_operstate(Link
*link
) {
287 LinkOperationalState operstate
;
290 if (link
->kernel_operstate
== IF_OPER_DORMANT
)
291 operstate
= LINK_OPERSTATE_DORMANT
;
292 else if (link_has_carrier(link
)) {
294 uint8_t scope
= RT_SCOPE_NOWHERE
;
297 /* if we have carrier, check what addresses we have */
298 SET_FOREACH(address
, link
->addresses
, i
) {
299 if (!address_is_ready(address
))
302 if (address
->scope
< scope
)
303 scope
= address
->scope
;
306 /* for operstate we also take foreign addresses into account */
307 SET_FOREACH(address
, link
->addresses_foreign
, i
) {
308 if (!address_is_ready(address
))
311 if (address
->scope
< scope
)
312 scope
= address
->scope
;
315 if (scope
< RT_SCOPE_SITE
)
316 /* universally accessible addresses found */
317 operstate
= LINK_OPERSTATE_ROUTABLE
;
318 else if (scope
< RT_SCOPE_HOST
)
319 /* only link or site local addresses found */
320 operstate
= LINK_OPERSTATE_DEGRADED
;
322 /* no useful addresses found */
323 operstate
= LINK_OPERSTATE_CARRIER
;
324 } else if (link
->flags
& IFF_UP
)
325 operstate
= LINK_OPERSTATE_NO_CARRIER
;
327 operstate
= LINK_OPERSTATE_OFF
;
329 if (link
->operstate
!= operstate
) {
330 link
->operstate
= operstate
;
331 link_send_changed(link
, "OperationalState", NULL
);
336 #define FLAG_STRING(string, flag, old, new) \
337 (((old ^ new) & flag) \
338 ? ((old & flag) ? (" -" string) : (" +" string)) \
341 static int link_update_flags(Link
*link
, sd_netlink_message
*m
) {
342 unsigned flags
, unknown_flags_added
, unknown_flags_removed
, unknown_flags
;
348 r
= sd_rtnl_message_link_get_flags(m
, &flags
);
350 return log_link_warning_errno(link
, r
, "Could not get link flags: %m");
352 r
= sd_netlink_message_read_u8(m
, IFLA_OPERSTATE
, &operstate
);
354 /* if we got a message without operstate, take it to mean
355 the state was unchanged */
356 operstate
= link
->kernel_operstate
;
358 if ((link
->flags
== flags
) && (link
->kernel_operstate
== operstate
))
361 if (link
->flags
!= flags
) {
362 log_link_debug(link
, "Flags change:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
363 FLAG_STRING("LOOPBACK", IFF_LOOPBACK
, link
->flags
, flags
),
364 FLAG_STRING("MASTER", IFF_MASTER
, link
->flags
, flags
),
365 FLAG_STRING("SLAVE", IFF_SLAVE
, link
->flags
, flags
),
366 FLAG_STRING("UP", IFF_UP
, link
->flags
, flags
),
367 FLAG_STRING("DORMANT", IFF_DORMANT
, link
->flags
, flags
),
368 FLAG_STRING("LOWER_UP", IFF_LOWER_UP
, link
->flags
, flags
),
369 FLAG_STRING("RUNNING", IFF_RUNNING
, link
->flags
, flags
),
370 FLAG_STRING("MULTICAST", IFF_MULTICAST
, link
->flags
, flags
),
371 FLAG_STRING("BROADCAST", IFF_BROADCAST
, link
->flags
, flags
),
372 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT
, link
->flags
, flags
),
373 FLAG_STRING("PROMISC", IFF_PROMISC
, link
->flags
, flags
),
374 FLAG_STRING("ALLMULTI", IFF_ALLMULTI
, link
->flags
, flags
),
375 FLAG_STRING("PORTSEL", IFF_PORTSEL
, link
->flags
, flags
),
376 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA
, link
->flags
, flags
),
377 FLAG_STRING("DYNAMIC", IFF_DYNAMIC
, link
->flags
, flags
),
378 FLAG_STRING("NOARP", IFF_NOARP
, link
->flags
, flags
),
379 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS
, link
->flags
, flags
),
380 FLAG_STRING("DEBUG", IFF_DEBUG
, link
->flags
, flags
),
381 FLAG_STRING("ECHO", IFF_ECHO
, link
->flags
, flags
));
383 unknown_flags
= ~(IFF_LOOPBACK
| IFF_MASTER
| IFF_SLAVE
| IFF_UP
|
384 IFF_DORMANT
| IFF_LOWER_UP
| IFF_RUNNING
|
385 IFF_MULTICAST
| IFF_BROADCAST
| IFF_POINTOPOINT
|
386 IFF_PROMISC
| IFF_ALLMULTI
| IFF_PORTSEL
|
387 IFF_AUTOMEDIA
| IFF_DYNAMIC
| IFF_NOARP
|
388 IFF_NOTRAILERS
| IFF_DEBUG
| IFF_ECHO
);
389 unknown_flags_added
= ((link
->flags
^ flags
) & flags
& unknown_flags
);
390 unknown_flags_removed
= ((link
->flags
^ flags
) & link
->flags
& unknown_flags
);
392 /* link flags are currently at most 18 bits, let's align to
394 if (unknown_flags_added
)
396 "Unknown link flags gained: %#.5x (ignoring)",
397 unknown_flags_added
);
399 if (unknown_flags_removed
)
401 "Unknown link flags lost: %#.5x (ignoring)",
402 unknown_flags_removed
);
406 link
->kernel_operstate
= operstate
;
408 link_update_operstate(link
);
413 static int link_new(Manager
*manager
, sd_netlink_message
*message
, Link
**ret
) {
414 _cleanup_link_unref_ Link
*link
= NULL
;
416 const char *ifname
, *kind
= NULL
;
418 unsigned short iftype
;
424 /* check for link kind */
425 r
= sd_netlink_message_enter_container(message
, IFLA_LINKINFO
);
427 (void)sd_netlink_message_read_string(message
, IFLA_INFO_KIND
, &kind
);
428 r
= sd_netlink_message_exit_container(message
);
433 r
= sd_netlink_message_get_type(message
, &type
);
436 else if (type
!= RTM_NEWLINK
)
439 r
= sd_rtnl_message_link_get_ifindex(message
, &ifindex
);
442 else if (ifindex
<= 0)
445 r
= sd_rtnl_message_link_get_type(message
, &iftype
);
449 r
= sd_netlink_message_read_string(message
, IFLA_IFNAME
, &ifname
);
453 link
= new0(Link
, 1);
458 link
->manager
= manager
;
459 link
->state
= LINK_STATE_PENDING
;
460 link
->rtnl_extended_attrs
= true;
461 link
->ifindex
= ifindex
;
462 link
->iftype
= iftype
;
463 link
->ifname
= strdup(ifname
);
468 link
->kind
= strdup(kind
);
473 r
= sd_netlink_message_read_ether_addr(message
, IFLA_ADDRESS
, &link
->mac
);
475 log_link_debug_errno(link
, r
, "MAC address not found for new device, continuing without");
477 if (asprintf(&link
->state_file
, "/run/systemd/netif/links/%d", link
->ifindex
) < 0)
480 if (asprintf(&link
->lease_file
, "/run/systemd/netif/leases/%d", link
->ifindex
) < 0)
483 if (asprintf(&link
->lldp_file
, "/run/systemd/netif/lldp/%d", link
->ifindex
) < 0)
486 r
= hashmap_ensure_allocated(&manager
->links
, NULL
);
490 r
= hashmap_put(manager
->links
, INT_TO_PTR(link
->ifindex
), link
);
494 r
= link_update_flags(link
, message
);
504 static void link_free(Link
*link
) {
512 while (!set_isempty(link
->addresses
))
513 address_free(set_first(link
->addresses
));
515 while (!set_isempty(link
->addresses_foreign
))
516 address_free(set_first(link
->addresses_foreign
));
518 link
->addresses
= set_free(link
->addresses
);
520 link
->addresses_foreign
= set_free(link
->addresses_foreign
);
522 while ((address
= link
->pool_addresses
)) {
523 LIST_REMOVE(addresses
, link
->pool_addresses
, address
);
524 address_free(address
);
527 sd_dhcp_server_unref(link
->dhcp_server
);
528 sd_dhcp_client_unref(link
->dhcp_client
);
529 sd_dhcp_lease_unref(link
->dhcp_lease
);
531 link_lldp_emit_stop(link
);
533 free(link
->lease_file
);
535 sd_lldp_unref(link
->lldp
);
536 free(link
->lldp_file
);
540 sd_ipv4ll_unref(link
->ipv4ll
);
541 sd_dhcp6_client_unref(link
->dhcp6_client
);
542 sd_ndisc_unref(link
->ndisc
);
543 sd_radv_unref(link
->radv
);
546 hashmap_remove(link
->manager
->links
, INT_TO_PTR(link
->ifindex
));
552 (void)unlink(link
->state_file
);
553 free(link
->state_file
);
555 udev_device_unref(link
->udev_device
);
557 HASHMAP_FOREACH (carrier
, link
->bound_to_links
, i
)
558 hashmap_remove(link
->bound_to_links
, INT_TO_PTR(carrier
->ifindex
));
559 hashmap_free(link
->bound_to_links
);
561 HASHMAP_FOREACH (carrier
, link
->bound_by_links
, i
)
562 hashmap_remove(link
->bound_by_links
, INT_TO_PTR(carrier
->ifindex
));
563 hashmap_free(link
->bound_by_links
);
568 Link
*link_unref(Link
*link
) {
572 assert(link
->n_ref
> 0);
584 Link
*link_ref(Link
*link
) {
588 assert(link
->n_ref
> 0);
595 int link_get(Manager
*m
, int ifindex
, Link
**ret
) {
602 link
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
611 static void link_set_state(Link
*link
, LinkState state
) {
614 if (link
->state
== state
)
619 link_send_changed(link
, "AdministrativeState", NULL
);
622 static void link_enter_unmanaged(Link
*link
) {
625 log_link_debug(link
, "Unmanaged");
627 link_set_state(link
, LINK_STATE_UNMANAGED
);
632 static int link_stop_clients(Link
*link
) {
636 assert(link
->manager
);
637 assert(link
->manager
->event
);
639 if (link
->dhcp_client
) {
640 k
= sd_dhcp_client_stop(link
->dhcp_client
);
642 r
= log_link_warning_errno(link
, k
, "Could not stop DHCPv4 client: %m");
646 k
= sd_ipv4ll_stop(link
->ipv4ll
);
648 r
= log_link_warning_errno(link
, k
, "Could not stop IPv4 link-local: %m");
651 if (link
->dhcp6_client
) {
652 k
= sd_dhcp6_client_stop(link
->dhcp6_client
);
654 r
= log_link_warning_errno(link
, k
, "Could not stop DHCPv6 client: %m");
658 k
= sd_ndisc_stop(link
->ndisc
);
660 r
= log_link_warning_errno(link
, k
, "Could not stop IPv6 Router Discovery: %m");
664 k
= sd_radv_stop(link
->radv
);
666 r
= log_link_warning_errno(link
, k
, "Could not stop IPv6 Router Advertisement: %m");
669 link_lldp_emit_stop(link
);
673 void link_enter_failed(Link
*link
) {
676 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
679 log_link_warning(link
, "Failed");
681 link_set_state(link
, LINK_STATE_FAILED
);
683 link_stop_clients(link
);
688 static Address
* link_find_dhcp_server_address(Link
*link
) {
692 assert(link
->network
);
694 /* The first statically configured address if there is any */
695 LIST_FOREACH(addresses
, address
, link
->network
->static_addresses
) {
697 if (address
->family
!= AF_INET
)
700 if (in_addr_is_null(address
->family
, &address
->in_addr
))
706 /* If that didn't work, find a suitable address we got from the pool */
707 LIST_FOREACH(addresses
, address
, link
->pool_addresses
) {
708 if (address
->family
!= AF_INET
)
717 static void link_enter_configured(Link
*link
) {
719 assert(link
->network
);
721 if (link
->state
!= LINK_STATE_SETTING_ROUTES
)
724 log_link_info(link
, "Configured");
726 link_set_state(link
, LINK_STATE_CONFIGURED
);
731 void link_check_ready(Link
*link
) {
737 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
743 if (!link
->static_routes_configured
)
746 if (!link
->routing_policy_rules_configured
)
749 if (link_ipv4ll_enabled(link
))
750 if (!link
->ipv4ll_address
||
754 if (!link
->network
->bridge
) {
756 if (link_ipv6ll_enabled(link
))
757 if (in_addr_is_null(AF_INET6
, (const union in_addr_union
*) &link
->ipv6ll_address
) > 0)
760 if ((link_dhcp4_enabled(link
) && !link_dhcp6_enabled(link
) &&
761 !link
->dhcp4_configured
) ||
762 (link_dhcp6_enabled(link
) && !link_dhcp4_enabled(link
) &&
763 !link
->dhcp6_configured
) ||
764 (link_dhcp4_enabled(link
) && link_dhcp6_enabled(link
) &&
765 !link
->dhcp4_configured
&& !link
->dhcp6_configured
))
768 if (link_ipv6_accept_ra_enabled(link
) && !link
->ndisc_configured
)
772 SET_FOREACH(a
, link
->addresses
, i
)
773 if (!address_is_ready(a
))
776 if (link
->state
!= LINK_STATE_CONFIGURED
)
777 link_enter_configured(link
);
782 static int link_set_routing_policy_rule(Link
*link
) {
783 RoutingPolicyRule
*rule
, *rrule
= NULL
;
787 assert(link
->network
);
789 LIST_FOREACH(rules
, rule
, link
->network
->rules
) {
790 r
= routing_policy_rule_get(link
->manager
, rule
->family
, &rule
->from
, rule
->from_prefixlen
, &rule
->to
,
791 rule
->to_prefixlen
, rule
->tos
, rule
->fwmark
, rule
->table
, rule
->iif
, rule
->oif
, &rrule
);
793 (void) routing_policy_rule_make_local(link
->manager
, rrule
);
797 r
= routing_policy_rule_configure(rule
, link
, link_routing_policy_rule_handler
, false);
799 log_link_warning_errno(link
, r
, "Could not set routing policy rules: %m");
800 link_enter_failed(link
);
804 link
->routing_policy_rule_messages
++;
807 routing_policy_rule_purge(link
->manager
, link
);
808 if (link
->routing_policy_rule_messages
== 0) {
809 link
->routing_policy_rules_configured
= true;
810 link_check_ready(link
);
812 log_link_debug(link
, "Setting routing policy rules");
817 static int route_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
818 _cleanup_link_unref_ Link
*link
= userdata
;
821 assert(link
->route_messages
> 0);
822 assert(IN_SET(link
->state
, LINK_STATE_SETTING_ADDRESSES
,
823 LINK_STATE_SETTING_ROUTES
, LINK_STATE_FAILED
,
826 link
->route_messages
--;
828 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
831 r
= sd_netlink_message_get_errno(m
);
832 if (r
< 0 && r
!= -EEXIST
)
833 log_link_warning_errno(link
, r
, "Could not set route: %m");
835 if (link
->route_messages
== 0) {
836 log_link_debug(link
, "Routes set");
837 link
->static_routes_configured
= true;
838 link_check_ready(link
);
844 static int link_enter_set_routes(Link
*link
) {
849 assert(link
->network
);
850 assert(link
->state
== LINK_STATE_SETTING_ADDRESSES
);
852 link_set_state(link
, LINK_STATE_SETTING_ROUTES
);
854 LIST_FOREACH(routes
, rt
, link
->network
->static_routes
) {
855 r
= route_configure(rt
, link
, route_handler
);
857 log_link_warning_errno(link
, r
, "Could not set routes: %m");
858 link_enter_failed(link
);
862 link
->route_messages
++;
865 (void) link_set_routing_policy_rule(link
);
867 if (link
->route_messages
== 0) {
868 link
->static_routes_configured
= true;
869 link_check_ready(link
);
871 log_link_debug(link
, "Setting routes");
876 int link_route_remove_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
877 _cleanup_link_unref_ Link
*link
= userdata
;
882 assert(link
->ifname
);
884 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
887 r
= sd_netlink_message_get_errno(m
);
888 if (r
< 0 && r
!= -ESRCH
)
889 log_link_warning_errno(link
, r
, "Could not drop route: %m");
894 static int address_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
895 _cleanup_link_unref_ Link
*link
= userdata
;
901 assert(link
->ifname
);
902 assert(link
->address_messages
> 0);
903 assert(IN_SET(link
->state
, LINK_STATE_SETTING_ADDRESSES
,
904 LINK_STATE_FAILED
, LINK_STATE_LINGER
));
906 link
->address_messages
--;
908 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
911 r
= sd_netlink_message_get_errno(m
);
912 if (r
< 0 && r
!= -EEXIST
)
913 log_link_warning_errno(link
, r
, "could not set address: %m");
915 manager_rtnl_process_address(rtnl
, m
, link
->manager
);
917 if (link
->address_messages
== 0) {
918 log_link_debug(link
, "Addresses set");
919 link_enter_set_routes(link
);
925 static int address_label_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
926 _cleanup_link_unref_ Link
*link
= userdata
;
932 assert(link
->ifname
);
933 assert(link
->address_label_messages
> 0);
935 link
->address_label_messages
--;
937 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
940 r
= sd_netlink_message_get_errno(m
);
941 if (r
< 0 && r
!= -EEXIST
)
942 log_link_warning_errno(link
, r
, "could not set address label: %m");
944 manager_rtnl_process_address(rtnl
, m
, link
->manager
);
946 if (link
->address_label_messages
== 0)
947 log_link_debug(link
, "Addresses label set");
952 static int link_push_uplink_dns_to_dhcp_server(Link
*link
, sd_dhcp_server
*s
) {
953 _cleanup_free_
struct in_addr
*addresses
= NULL
;
954 size_t n_addresses
= 0, n_allocated
= 0;
957 log_debug("Copying DNS server information from %s", link
->ifname
);
962 for (i
= 0; i
< link
->network
->n_dns
; i
++) {
965 /* Only look for IPv4 addresses */
966 if (link
->network
->dns
[i
].family
!= AF_INET
)
969 ia
= link
->network
->dns
[i
].address
.in
;
971 /* Never propagate obviously borked data */
972 if (in4_addr_is_null(&ia
) || in4_addr_is_localhost(&ia
))
975 if (!GREEDY_REALLOC(addresses
, n_allocated
, n_addresses
+ 1))
978 addresses
[n_addresses
++] = ia
;
981 if (link
->network
->dhcp_use_dns
&& link
->dhcp_lease
) {
982 const struct in_addr
*da
= NULL
;
985 n
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &da
);
988 if (!GREEDY_REALLOC(addresses
, n_allocated
, n_addresses
+ n
))
991 memcpy(addresses
+ n_addresses
, da
, n
* sizeof(struct in_addr
));
996 if (n_addresses
<= 0)
999 return sd_dhcp_server_set_dns(s
, addresses
, n_addresses
);
1002 static int link_push_uplink_ntp_to_dhcp_server(Link
*link
, sd_dhcp_server
*s
) {
1003 _cleanup_free_
struct in_addr
*addresses
= NULL
;
1004 size_t n_addresses
= 0, n_allocated
= 0;
1010 log_debug("Copying NTP server information from %s", link
->ifname
);
1012 STRV_FOREACH(a
, link
->network
->ntp
) {
1015 /* Only look for IPv4 addresses */
1016 if (inet_pton(AF_INET
, *a
, &ia
) <= 0)
1019 /* Never propagate obviously borked data */
1020 if (in4_addr_is_null(&ia
) || in4_addr_is_localhost(&ia
))
1023 if (!GREEDY_REALLOC(addresses
, n_allocated
, n_addresses
+ 1))
1026 addresses
[n_addresses
++] = ia
;
1029 if (link
->network
->dhcp_use_ntp
&& link
->dhcp_lease
) {
1030 const struct in_addr
*da
= NULL
;
1033 n
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &da
);
1036 if (!GREEDY_REALLOC(addresses
, n_allocated
, n_addresses
+ n
))
1039 memcpy(addresses
+ n_addresses
, da
, n
* sizeof(struct in_addr
));
1044 if (n_addresses
<= 0)
1047 return sd_dhcp_server_set_ntp(s
, addresses
, n_addresses
);
1050 static int link_set_bridge_fdb(Link
*link
) {
1051 FdbEntry
*fdb_entry
;
1054 LIST_FOREACH(static_fdb_entries
, fdb_entry
, link
->network
->static_fdb_entries
) {
1055 r
= fdb_entry_configure(link
, fdb_entry
);
1057 return log_link_error_errno(link
, r
, "Failed to add MAC entry to static MAC table: %m");
1063 static int link_enter_set_addresses(Link
*link
) {
1064 AddressLabel
*label
;
1069 assert(link
->network
);
1070 assert(link
->state
!= _LINK_STATE_INVALID
);
1072 r
= link_set_bridge_fdb(link
);
1076 link_set_state(link
, LINK_STATE_SETTING_ADDRESSES
);
1078 LIST_FOREACH(addresses
, ad
, link
->network
->static_addresses
) {
1079 r
= address_configure(ad
, link
, address_handler
, false);
1081 log_link_warning_errno(link
, r
, "Could not set addresses: %m");
1082 link_enter_failed(link
);
1086 link
->address_messages
++;
1089 LIST_FOREACH(labels
, label
, link
->network
->address_labels
) {
1090 r
= address_label_configure(label
, link
, address_label_handler
, false);
1092 log_link_warning_errno(link
, r
, "Could not set address label: %m");
1093 link_enter_failed(link
);
1097 link
->address_label_messages
++;
1100 /* now that we can figure out a default address for the dhcp server,
1102 if (link_dhcp4_server_enabled(link
)) {
1104 Link
*uplink
= NULL
;
1105 bool acquired_uplink
= false;
1107 address
= link_find_dhcp_server_address(link
);
1109 log_link_warning(link
, "Failed to find suitable address for DHCPv4 server instance.");
1110 link_enter_failed(link
);
1114 /* use the server address' subnet as the pool */
1115 r
= sd_dhcp_server_configure_pool(link
->dhcp_server
, &address
->in_addr
.in
, address
->prefixlen
,
1116 link
->network
->dhcp_server_pool_offset
, link
->network
->dhcp_server_pool_size
);
1121 r = sd_dhcp_server_set_router(link->dhcp_server,
1122 &main_address->in_addr.in);
1127 if (link
->network
->dhcp_server_max_lease_time_usec
> 0) {
1128 r
= sd_dhcp_server_set_max_lease_time(
1130 DIV_ROUND_UP(link
->network
->dhcp_server_max_lease_time_usec
, USEC_PER_SEC
));
1135 if (link
->network
->dhcp_server_default_lease_time_usec
> 0) {
1136 r
= sd_dhcp_server_set_default_lease_time(
1138 DIV_ROUND_UP(link
->network
->dhcp_server_default_lease_time_usec
, USEC_PER_SEC
));
1143 if (link
->network
->dhcp_server_emit_dns
) {
1145 if (link
->network
->n_dhcp_server_dns
> 0)
1146 r
= sd_dhcp_server_set_dns(link
->dhcp_server
, link
->network
->dhcp_server_dns
, link
->network
->n_dhcp_server_dns
);
1148 uplink
= manager_find_uplink(link
->manager
, link
);
1149 acquired_uplink
= true;
1152 log_link_debug(link
, "Not emitting DNS server information on link, couldn't find suitable uplink.");
1155 r
= link_push_uplink_dns_to_dhcp_server(uplink
, link
->dhcp_server
);
1158 log_link_warning_errno(link
, r
, "Failed to set DNS server for DHCP server, ignoring: %m");
1162 if (link
->network
->dhcp_server_emit_ntp
) {
1164 if (link
->network
->n_dhcp_server_ntp
> 0)
1165 r
= sd_dhcp_server_set_ntp(link
->dhcp_server
, link
->network
->dhcp_server_ntp
, link
->network
->n_dhcp_server_ntp
);
1167 if (!acquired_uplink
)
1168 uplink
= manager_find_uplink(link
->manager
, link
);
1171 log_link_debug(link
, "Not emitting NTP server information on link, couldn't find suitable uplink.");
1174 r
= link_push_uplink_ntp_to_dhcp_server(uplink
, link
->dhcp_server
);
1178 log_link_warning_errno(link
, r
, "Failed to set NTP server for DHCP server, ignoring: %m");
1181 r
= sd_dhcp_server_set_emit_router(link
->dhcp_server
, link
->network
->dhcp_server_emit_router
);
1183 log_link_warning_errno(link
, r
, "Failed to set router emission for DHCP server: %m");
1187 if (link
->network
->dhcp_server_emit_timezone
) {
1188 _cleanup_free_
char *buffer
= NULL
;
1189 const char *tz
= NULL
;
1191 if (link
->network
->dhcp_server_timezone
)
1192 tz
= link
->network
->dhcp_server_timezone
;
1194 r
= get_timezone(&buffer
);
1196 log_warning_errno(r
, "Failed to determine timezone: %m");
1202 r
= sd_dhcp_server_set_timezone(link
->dhcp_server
, tz
);
1208 r
= sd_dhcp_server_start(link
->dhcp_server
);
1210 log_link_warning_errno(link
, r
, "Could not start DHCPv4 server instance: %m");
1212 link_enter_failed(link
);
1217 log_link_debug(link
, "Offering DHCPv4 leases");
1220 if (link
->address_messages
== 0)
1221 link_enter_set_routes(link
);
1223 log_link_debug(link
, "Setting addresses");
1228 int link_address_remove_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1229 _cleanup_link_unref_ Link
*link
= userdata
;
1234 assert(link
->ifname
);
1236 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1239 r
= sd_netlink_message_get_errno(m
);
1240 if (r
< 0 && r
!= -EADDRNOTAVAIL
)
1241 log_link_warning_errno(link
, r
, "Could not drop address: %m");
1246 static int link_set_bridge_vlan(Link
*link
) {
1249 r
= br_vlan_configure(link
, link
->network
->pvid
, link
->network
->br_vid_bitmap
, link
->network
->br_untagged_bitmap
);
1251 log_link_error_errno(link
, r
, "Failed to assign VLANs to bridge port: %m");
1256 static int link_set_proxy_arp(Link
*link
) {
1257 const char *p
= NULL
;
1260 if (!link_proxy_arp_enabled(link
))
1263 p
= strjoina("/proc/sys/net/ipv4/conf/", link
->ifname
, "/proxy_arp");
1265 r
= write_string_file(p
, one_zero(link
->network
->proxy_arp
), WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
1267 log_link_warning_errno(link
, r
, "Cannot configure proxy ARP for interface: %m");
1272 static int link_set_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1273 _cleanup_link_unref_ Link
*link
= userdata
;
1276 log_link_debug(link
, "Set link");
1278 r
= sd_netlink_message_get_errno(m
);
1279 if (r
< 0 && r
!= -EEXIST
) {
1280 log_link_error_errno(link
, r
, "Could not join netdev: %m");
1281 link_enter_failed(link
);
1288 static int set_mtu_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1289 _cleanup_link_unref_ Link
*link
= userdata
;
1294 assert(link
->ifname
);
1296 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1299 r
= sd_netlink_message_get_errno(m
);
1301 log_link_warning_errno(link
, r
, "Could not set MTU: %m");
1306 int link_set_mtu(Link
*link
, uint32_t mtu
) {
1307 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1311 assert(link
->manager
);
1312 assert(link
->manager
->rtnl
);
1314 log_link_debug(link
, "Setting MTU: %" PRIu32
, mtu
);
1316 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1318 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1320 r
= sd_netlink_message_append_u32(req
, IFLA_MTU
, mtu
);
1322 return log_link_error_errno(link
, r
, "Could not append MTU: %m");
1324 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, set_mtu_handler
, link
, 0, NULL
);
1326 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1328 link
->setting_mtu
= true;
1335 static int set_flags_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1336 _cleanup_link_unref_ Link
*link
= userdata
;
1341 assert(link
->ifname
);
1343 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1346 r
= sd_netlink_message_get_errno(m
);
1348 log_link_warning_errno(link
, r
, "Could not set link flags: %m");
1353 static int link_set_flags(Link
*link
) {
1354 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1355 unsigned ifi_change
= 0;
1356 unsigned ifi_flags
= 0;
1360 assert(link
->manager
);
1361 assert(link
->manager
->rtnl
);
1363 if (link
->flags
& IFF_LOOPBACK
)
1369 if (link
->network
->arp
< 0)
1372 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1374 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1376 if (link
->network
->arp
>= 0) {
1377 ifi_change
|= IFF_NOARP
;
1378 ifi_flags
|= link
->network
->arp
? 0 : IFF_NOARP
;
1381 r
= sd_rtnl_message_link_set_flags(req
, ifi_flags
, ifi_change
);
1383 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1385 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, set_flags_handler
, link
, 0, NULL
);
1387 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1394 static int link_set_bridge(Link
*link
) {
1395 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1399 assert(link
->network
);
1401 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1403 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1405 r
= sd_rtnl_message_link_set_family(req
, PF_BRIDGE
);
1407 return log_link_error_errno(link
, r
, "Could not set message family: %m");
1409 r
= sd_netlink_message_open_container(req
, IFLA_PROTINFO
);
1411 return log_link_error_errno(link
, r
, "Could not append IFLA_PROTINFO attribute: %m");
1413 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_GUARD
, !link
->network
->use_bpdu
);
1415 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_GUARD attribute: %m");
1417 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_MODE
, link
->network
->hairpin
);
1419 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_MODE attribute: %m");
1421 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_FAST_LEAVE
, link
->network
->fast_leave
);
1423 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_FAST_LEAVE attribute: %m");
1425 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_PROTECT
, !link
->network
->allow_port_to_be_root
);
1427 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_PROTECT attribute: %m");
1429 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_UNICAST_FLOOD
, link
->network
->unicast_flood
);
1431 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_UNICAST_FLOOD attribute: %m");
1433 if (link
->network
->cost
!= 0) {
1434 r
= sd_netlink_message_append_u32(req
, IFLA_BRPORT_COST
, link
->network
->cost
);
1436 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_COST attribute: %m");
1438 if (link
->network
->priority
!= LINK_BRIDGE_PORT_PRIORITY_INVALID
) {
1439 r
= sd_netlink_message_append_u16(req
, IFLA_BRPORT_PRIORITY
, link
->network
->priority
);
1441 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_PRIORITY attribute: %m");
1444 r
= sd_netlink_message_close_container(req
);
1446 return log_link_error_errno(link
, r
, "Could not append IFLA_LINKINFO attribute: %m");
1448 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, link_set_handler
, link
, 0, NULL
);
1450 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1457 static int link_bond_set(Link
*link
) {
1458 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1462 assert(link
->network
);
1464 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_NEWLINK
, link
->network
->bond
->ifindex
);
1466 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1468 r
= sd_netlink_message_set_flags(req
, NLM_F_REQUEST
| NLM_F_ACK
);
1470 return log_link_error_errno(link
, r
, "Could not set netlink flags: %m");
1472 r
= sd_netlink_message_open_container(req
, IFLA_LINKINFO
);
1474 return log_link_error_errno(link
, r
, "Could not append IFLA_PROTINFO attribute: %m");
1476 r
= sd_netlink_message_open_container_union(req
, IFLA_INFO_DATA
, "bond");
1478 return log_link_error_errno(link
, r
, "Could not append IFLA_INFO_DATA attribute: %m");
1480 if (link
->network
->active_slave
) {
1481 r
= sd_netlink_message_append_u32(req
, IFLA_BOND_ACTIVE_SLAVE
, link
->ifindex
);
1483 return log_link_error_errno(link
, r
, "Could not append IFLA_BOND_ACTIVE_SLAVE attribute: %m");
1486 if (link
->network
->primary_slave
) {
1487 r
= sd_netlink_message_append_u32(req
, IFLA_BOND_PRIMARY
, link
->ifindex
);
1489 return log_link_error_errno(link
, r
, "Could not append IFLA_BOND_PRIMARY attribute: %m");
1492 r
= sd_netlink_message_close_container(req
);
1494 return log_link_error_errno(link
, r
, "Could not append IFLA_LINKINFO attribute: %m");
1496 r
= sd_netlink_message_close_container(req
);
1498 return log_link_error_errno(link
, r
, "Could not append IFLA_INFO_DATA attribute: %m");
1500 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, set_flags_handler
, link
, 0, NULL
);
1502 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1509 static int link_lldp_save(Link
*link
) {
1510 _cleanup_free_
char *temp_path
= NULL
;
1511 _cleanup_fclose_
FILE *f
= NULL
;
1512 sd_lldp_neighbor
**l
= NULL
;
1516 assert(link
->lldp_file
);
1519 (void) unlink(link
->lldp_file
);
1523 r
= sd_lldp_get_neighbors(link
->lldp
, &l
);
1527 (void) unlink(link
->lldp_file
);
1533 r
= fopen_temporary(link
->lldp_file
, &f
, &temp_path
);
1537 fchmod(fileno(f
), 0644);
1539 for (i
= 0; i
< n
; i
++) {
1544 r
= sd_lldp_neighbor_get_raw(l
[i
], &p
, &sz
);
1549 (void) fwrite(&u
, 1, sizeof(u
), f
);
1550 (void) fwrite(p
, 1, sz
, f
);
1553 r
= fflush_and_check(f
);
1557 if (rename(temp_path
, link
->lldp_file
) < 0) {
1564 (void) unlink(link
->lldp_file
);
1566 (void) unlink(temp_path
);
1568 log_link_error_errno(link
, r
, "Failed to save LLDP data to %s: %m", link
->lldp_file
);
1572 for (i
= 0; i
< n
; i
++)
1573 sd_lldp_neighbor_unref(l
[i
]);
1580 static void lldp_handler(sd_lldp
*lldp
, sd_lldp_event event
, sd_lldp_neighbor
*n
, void *userdata
) {
1581 Link
*link
= userdata
;
1586 (void) link_lldp_save(link
);
1588 if (link_lldp_emit_enabled(link
) && event
== SD_LLDP_EVENT_ADDED
) {
1589 /* If we received information about a new neighbor, restart the LLDP "fast" logic */
1591 log_link_debug(link
, "Received LLDP datagram from previously unknown neighbor, restarting 'fast' LLDP transmission.");
1593 r
= link_lldp_emit_start(link
);
1595 log_link_warning_errno(link
, r
, "Failed to restart LLDP transmission: %m");
1599 static int link_acquire_ipv6_conf(Link
*link
) {
1604 if (link_dhcp6_enabled(link
)) {
1605 assert(link
->dhcp6_client
);
1606 assert(in_addr_is_link_local(AF_INET6
, (const union in_addr_union
*)&link
->ipv6ll_address
) > 0);
1608 /* start DHCPv6 client in stateless mode */
1609 r
= dhcp6_request_address(link
, true);
1610 if (r
< 0 && r
!= -EBUSY
)
1611 return log_link_warning_errno(link
, r
, "Could not acquire DHCPv6 lease: %m");
1613 log_link_debug(link
, "Acquiring DHCPv6 lease");
1616 if (link_ipv6_accept_ra_enabled(link
)) {
1617 assert(link
->ndisc
);
1619 log_link_debug(link
, "Discovering IPv6 routers");
1621 r
= sd_ndisc_start(link
->ndisc
);
1622 if (r
< 0 && r
!= -EBUSY
)
1623 return log_link_warning_errno(link
, r
, "Could not start IPv6 Router Discovery: %m");
1626 if (link_radv_enabled(link
)) {
1628 assert(in_addr_is_link_local(AF_INET6
, (const union in_addr_union
*)&link
->ipv6ll_address
) > 0);
1630 log_link_debug(link
, "Starting IPv6 Router Advertisements");
1632 r
= sd_radv_start(link
->radv
);
1633 if (r
< 0 && r
!= -EBUSY
)
1634 return log_link_warning_errno(link
, r
, "Could not start IPv6 Router Advertisement: %m");
1640 static int link_acquire_ipv4_conf(Link
*link
) {
1644 assert(link
->network
);
1645 assert(link
->manager
);
1646 assert(link
->manager
->event
);
1648 if (link_ipv4ll_enabled(link
)) {
1649 assert(link
->ipv4ll
);
1651 log_link_debug(link
, "Acquiring IPv4 link-local address");
1653 r
= sd_ipv4ll_start(link
->ipv4ll
);
1655 return log_link_warning_errno(link
, r
, "Could not acquire IPv4 link-local address: %m");
1658 if (link_dhcp4_enabled(link
)) {
1659 assert(link
->dhcp_client
);
1661 log_link_debug(link
, "Acquiring DHCPv4 lease");
1663 r
= sd_dhcp_client_start(link
->dhcp_client
);
1665 return log_link_warning_errno(link
, r
, "Could not acquire DHCPv4 lease: %m");
1671 static int link_acquire_conf(Link
*link
) {
1676 if (link
->setting_mtu
) {
1677 link
->setting_mtu
= false;
1681 r
= link_acquire_ipv4_conf(link
);
1685 if (in_addr_is_null(AF_INET6
, (const union in_addr_union
*) &link
->ipv6ll_address
) == 0) {
1686 r
= link_acquire_ipv6_conf(link
);
1691 if (link_lldp_emit_enabled(link
)) {
1692 r
= link_lldp_emit_start(link
);
1694 return log_link_warning_errno(link
, r
, "Failed to start LLDP transmission: %m");
1700 bool link_has_carrier(Link
*link
) {
1701 /* see Documentation/networking/operstates.txt in the kernel sources */
1703 if (link
->kernel_operstate
== IF_OPER_UP
)
1706 if (link
->kernel_operstate
== IF_OPER_UNKNOWN
)
1707 /* operstate may not be implemented, so fall back to flags */
1708 if ((link
->flags
& IFF_LOWER_UP
) && !(link
->flags
& IFF_DORMANT
))
1714 static int link_up_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1715 _cleanup_link_unref_ Link
*link
= userdata
;
1720 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1723 r
= sd_netlink_message_get_errno(m
);
1725 /* we warn but don't fail the link, as it may be
1727 log_link_warning_errno(link
, r
, "Could not bring up interface: %m");
1732 int link_up(Link
*link
) {
1733 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1734 uint8_t ipv6ll_mode
;
1738 assert(link
->network
);
1739 assert(link
->manager
);
1740 assert(link
->manager
->rtnl
);
1742 log_link_debug(link
, "Bringing link up");
1744 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1746 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1748 /* set it free if not enslaved with networkd */
1749 if (!link
->network
->bridge
&& !link
->network
->bond
&& !link
->network
->vrf
) {
1750 r
= sd_netlink_message_append_u32(req
, IFLA_MASTER
, 0);
1752 return log_link_error_errno(link
, r
, "Could not append IFLA_MASTER attribute: %m");
1755 r
= sd_rtnl_message_link_set_flags(req
, IFF_UP
, IFF_UP
);
1757 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1759 if (link
->network
->mac
) {
1760 r
= sd_netlink_message_append_ether_addr(req
, IFLA_ADDRESS
, link
->network
->mac
);
1762 return log_link_error_errno(link
, r
, "Could not set MAC address: %m");
1765 /* If IPv6 not configured (no static IPv6 address and IPv6LL autoconfiguration is disabled)
1766 for this interface, or if it is a bridge slave, then disable IPv6 else enable it. */
1767 (void) link_enable_ipv6(link
);
1769 if (link
->network
->mtu
) {
1770 /* IPv6 protocol requires a minimum MTU of IPV6_MTU_MIN(1280) bytes
1771 on the interface. Bump up MTU bytes to IPV6_MTU_MIN. */
1772 if (link_ipv6_enabled(link
) && link
->network
->mtu
< IPV6_MIN_MTU
) {
1774 log_link_warning(link
, "Bumping MTU to " STRINGIFY(IPV6_MIN_MTU
) ", as "
1775 "IPv6 is requested and requires a minimum MTU of " STRINGIFY(IPV6_MIN_MTU
) " bytes: %m");
1777 link
->network
->mtu
= IPV6_MIN_MTU
;
1780 r
= sd_netlink_message_append_u32(req
, IFLA_MTU
, link
->network
->mtu
);
1782 return log_link_error_errno(link
, r
, "Could not set MTU: %m");
1785 r
= sd_netlink_message_open_container(req
, IFLA_AF_SPEC
);
1787 return log_link_error_errno(link
, r
, "Could not open IFLA_AF_SPEC container: %m");
1789 if (link_ipv6_enabled(link
)) {
1790 /* if the kernel lacks ipv6 support setting IFF_UP fails if any ipv6 options are passed */
1791 r
= sd_netlink_message_open_container(req
, AF_INET6
);
1793 return log_link_error_errno(link
, r
, "Could not open AF_INET6 container: %m");
1795 if (!link_ipv6ll_enabled(link
))
1796 ipv6ll_mode
= IN6_ADDR_GEN_MODE_NONE
;
1798 const char *p
= NULL
;
1799 _cleanup_free_
char *stable_secret
= NULL
;
1801 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/stable_secret");
1802 r
= read_one_line_file(p
, &stable_secret
);
1805 ipv6ll_mode
= IN6_ADDR_GEN_MODE_EUI64
;
1807 ipv6ll_mode
= IN6_ADDR_GEN_MODE_STABLE_PRIVACY
;
1809 r
= sd_netlink_message_append_u8(req
, IFLA_INET6_ADDR_GEN_MODE
, ipv6ll_mode
);
1811 return log_link_error_errno(link
, r
, "Could not append IFLA_INET6_ADDR_GEN_MODE: %m");
1813 if (!in_addr_is_null(AF_INET6
, &link
->network
->ipv6_token
)) {
1814 r
= sd_netlink_message_append_in6_addr(req
, IFLA_INET6_TOKEN
, &link
->network
->ipv6_token
.in6
);
1816 return log_link_error_errno(link
, r
, "Could not append IFLA_INET6_TOKEN: %m");
1819 r
= sd_netlink_message_close_container(req
);
1821 return log_link_error_errno(link
, r
, "Could not close AF_INET6 container: %m");
1824 r
= sd_netlink_message_close_container(req
);
1826 return log_link_error_errno(link
, r
, "Could not close IFLA_AF_SPEC container: %m");
1828 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, link_up_handler
, link
, 0, NULL
);
1830 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1837 static int link_down_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1838 _cleanup_link_unref_ Link
*link
= userdata
;
1843 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1846 r
= sd_netlink_message_get_errno(m
);
1848 log_link_warning_errno(link
, r
, "Could not bring down interface: %m");
1853 int link_down(Link
*link
) {
1854 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1858 assert(link
->manager
);
1859 assert(link
->manager
->rtnl
);
1861 log_link_debug(link
, "Bringing link down");
1863 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
,
1864 RTM_SETLINK
, link
->ifindex
);
1866 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1868 r
= sd_rtnl_message_link_set_flags(req
, 0, IFF_UP
);
1870 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1872 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, link_down_handler
, link
, 0, NULL
);
1874 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1881 static int link_up_can(Link
*link
) {
1882 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1887 log_link_debug(link
, "Bringing CAN link up");
1889 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1891 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1893 r
= sd_rtnl_message_link_set_flags(req
, IFF_UP
, IFF_UP
);
1895 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1897 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, link_up_handler
, link
, 0, NULL
);
1899 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1906 static int link_handle_bound_to_list(Link
*link
) {
1910 bool required_up
= false;
1911 bool link_is_up
= false;
1915 if (hashmap_isempty(link
->bound_to_links
))
1918 if (link
->flags
& IFF_UP
)
1921 HASHMAP_FOREACH (l
, link
->bound_to_links
, i
)
1922 if (link_has_carrier(l
)) {
1927 if (!required_up
&& link_is_up
) {
1928 r
= link_down(link
);
1931 } else if (required_up
&& !link_is_up
) {
1940 static int link_handle_bound_by_list(Link
*link
) {
1947 if (hashmap_isempty(link
->bound_by_links
))
1950 HASHMAP_FOREACH (l
, link
->bound_by_links
, i
) {
1951 r
= link_handle_bound_to_list(l
);
1959 static int link_put_carrier(Link
*link
, Link
*carrier
, Hashmap
**h
) {
1965 if (link
== carrier
)
1968 if (hashmap_get(*h
, INT_TO_PTR(carrier
->ifindex
)))
1971 r
= hashmap_ensure_allocated(h
, NULL
);
1975 r
= hashmap_put(*h
, INT_TO_PTR(carrier
->ifindex
), carrier
);
1982 static int link_new_bound_by_list(Link
*link
) {
1987 bool list_updated
= false;
1990 assert(link
->manager
);
1994 HASHMAP_FOREACH(carrier
, m
->links
, i
) {
1995 if (!carrier
->network
)
1998 if (strv_isempty(carrier
->network
->bind_carrier
))
2001 if (strv_fnmatch(carrier
->network
->bind_carrier
, link
->ifname
, 0)) {
2002 r
= link_put_carrier(link
, carrier
, &link
->bound_by_links
);
2006 list_updated
= true;
2013 HASHMAP_FOREACH(carrier
, link
->bound_by_links
, i
) {
2014 r
= link_put_carrier(carrier
, link
, &carrier
->bound_to_links
);
2018 link_dirty(carrier
);
2024 static int link_new_bound_to_list(Link
*link
) {
2029 bool list_updated
= false;
2032 assert(link
->manager
);
2037 if (strv_isempty(link
->network
->bind_carrier
))
2042 HASHMAP_FOREACH (carrier
, m
->links
, i
) {
2043 if (strv_fnmatch(link
->network
->bind_carrier
, carrier
->ifname
, 0)) {
2044 r
= link_put_carrier(link
, carrier
, &link
->bound_to_links
);
2048 list_updated
= true;
2055 HASHMAP_FOREACH (carrier
, link
->bound_to_links
, i
) {
2056 r
= link_put_carrier(carrier
, link
, &carrier
->bound_by_links
);
2060 link_dirty(carrier
);
2066 static int link_new_carrier_maps(Link
*link
) {
2069 r
= link_new_bound_by_list(link
);
2073 r
= link_handle_bound_by_list(link
);
2077 r
= link_new_bound_to_list(link
);
2081 r
= link_handle_bound_to_list(link
);
2088 static void link_free_bound_to_list(Link
*link
) {
2092 HASHMAP_FOREACH (bound_to
, link
->bound_to_links
, i
) {
2093 hashmap_remove(link
->bound_to_links
, INT_TO_PTR(bound_to
->ifindex
));
2095 if (hashmap_remove(bound_to
->bound_by_links
, INT_TO_PTR(link
->ifindex
)))
2096 link_dirty(bound_to
);
2102 static void link_free_bound_by_list(Link
*link
) {
2106 HASHMAP_FOREACH (bound_by
, link
->bound_by_links
, i
) {
2107 hashmap_remove(link
->bound_by_links
, INT_TO_PTR(bound_by
->ifindex
));
2109 if (hashmap_remove(bound_by
->bound_to_links
, INT_TO_PTR(link
->ifindex
))) {
2110 link_dirty(bound_by
);
2111 link_handle_bound_to_list(bound_by
);
2118 static void link_free_carrier_maps(Link
*link
) {
2119 bool list_updated
= false;
2123 if (!hashmap_isempty(link
->bound_to_links
)) {
2124 link_free_bound_to_list(link
);
2125 list_updated
= true;
2128 if (!hashmap_isempty(link
->bound_by_links
)) {
2129 link_free_bound_by_list(link
);
2130 list_updated
= true;
2139 void link_drop(Link
*link
) {
2140 if (!link
|| link
->state
== LINK_STATE_LINGER
)
2143 link_set_state(link
, LINK_STATE_LINGER
);
2145 link_free_carrier_maps(link
);
2147 log_link_debug(link
, "Link removed");
2149 (void)unlink(link
->state_file
);
2155 static int link_joined(Link
*link
) {
2159 assert(link
->network
);
2161 if (!hashmap_isempty(link
->bound_to_links
)) {
2162 r
= link_handle_bound_to_list(link
);
2165 } else if (!(link
->flags
& IFF_UP
)) {
2168 link_enter_failed(link
);
2173 if (link
->network
->bridge
) {
2174 r
= link_set_bridge(link
);
2176 log_link_error_errno(link
, r
, "Could not set bridge message: %m");
2179 if (link
->network
->bond
) {
2180 r
= link_bond_set(link
);
2182 log_link_error_errno(link
, r
, "Could not set bond message: %m");
2185 if (link
->network
->use_br_vlan
&&
2186 (link
->network
->bridge
|| streq_ptr("bridge", link
->kind
))) {
2187 r
= link_set_bridge_vlan(link
);
2189 log_link_error_errno(link
, r
, "Could not set bridge vlan: %m");
2192 /* Skip setting up addresses until it gets carrier,
2193 or it would try to set addresses twice,
2194 which is bad for non-idempotent steps. */
2195 if (!link_has_carrier(link
) && !link
->network
->configure_without_carrier
)
2198 return link_enter_set_addresses(link
);
2201 static int netdev_join_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
2202 _cleanup_link_unref_ Link
*link
= userdata
;
2206 assert(link
->network
);
2210 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
2213 r
= sd_netlink_message_get_errno(m
);
2214 if (r
< 0 && r
!= -EEXIST
) {
2215 log_link_error_errno(link
, r
, "Could not join netdev: %m");
2216 link_enter_failed(link
);
2219 log_link_debug(link
, "Joined netdev");
2221 if (link
->enslaving
<= 0)
2227 static int link_enter_join_netdev(Link
*link
) {
2233 assert(link
->network
);
2234 assert(link
->state
== LINK_STATE_PENDING
);
2236 link_set_state(link
, LINK_STATE_ENSLAVING
);
2240 if (!link
->network
->bridge
&&
2241 !link
->network
->bond
&&
2242 !link
->network
->vrf
&&
2243 hashmap_isempty(link
->network
->stacked_netdevs
))
2244 return link_joined(link
);
2246 if (link
->network
->bond
) {
2247 log_struct(LOG_DEBUG
,
2248 LOG_LINK_INTERFACE(link
),
2249 LOG_NETDEV_INTERFACE(link
->network
->bond
),
2250 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->bond
->ifname
),
2253 r
= netdev_join(link
->network
->bond
, link
, netdev_join_handler
);
2255 log_struct_errno(LOG_WARNING
, r
,
2256 LOG_LINK_INTERFACE(link
),
2257 LOG_NETDEV_INTERFACE(link
->network
->bond
),
2258 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->bond
->ifname
),
2261 link_enter_failed(link
);
2268 if (link
->network
->bridge
) {
2269 log_struct(LOG_DEBUG
,
2270 LOG_LINK_INTERFACE(link
),
2271 LOG_NETDEV_INTERFACE(link
->network
->bridge
),
2272 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->bridge
->ifname
),
2275 r
= netdev_join(link
->network
->bridge
, link
, netdev_join_handler
);
2277 log_struct_errno(LOG_WARNING
, r
,
2278 LOG_LINK_INTERFACE(link
),
2279 LOG_NETDEV_INTERFACE(link
->network
->bridge
),
2280 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->bridge
->ifname
),
2282 link_enter_failed(link
);
2289 if (link
->network
->vrf
) {
2290 log_struct(LOG_DEBUG
,
2291 LOG_LINK_INTERFACE(link
),
2292 LOG_NETDEV_INTERFACE(link
->network
->vrf
),
2293 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->vrf
->ifname
),
2295 r
= netdev_join(link
->network
->vrf
, link
, netdev_join_handler
);
2297 log_struct_errno(LOG_WARNING
, r
,
2298 LOG_LINK_INTERFACE(link
),
2299 LOG_NETDEV_INTERFACE(link
->network
->vrf
),
2300 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->vrf
->ifname
),
2302 link_enter_failed(link
);
2309 HASHMAP_FOREACH(netdev
, link
->network
->stacked_netdevs
, i
) {
2311 if (netdev
->ifindex
> 0) {
2316 log_struct(LOG_DEBUG
,
2317 LOG_LINK_INTERFACE(link
),
2318 LOG_NETDEV_INTERFACE(netdev
),
2319 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", netdev
->ifname
),
2322 r
= netdev_join(netdev
, link
, netdev_join_handler
);
2324 log_struct_errno(LOG_WARNING
, r
,
2325 LOG_LINK_INTERFACE(link
),
2326 LOG_NETDEV_INTERFACE(netdev
),
2327 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", netdev
->ifname
),
2329 link_enter_failed(link
);
2339 static int link_set_ipv4_forward(Link
*link
) {
2342 if (!link_ipv4_forward_enabled(link
))
2345 /* We propagate the forwarding flag from one interface to the
2346 * global setting one way. This means: as long as at least one
2347 * interface was configured at any time that had IP forwarding
2348 * enabled the setting will stay on for good. We do this
2349 * primarily to keep IPv4 and IPv6 packet forwarding behaviour
2350 * somewhat in sync (see below). */
2352 r
= write_string_file("/proc/sys/net/ipv4/ip_forward", "1", WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2354 log_link_warning_errno(link
, r
, "Cannot turn on IPv4 packet forwarding, ignoring: %m");
2359 static int link_set_ipv6_forward(Link
*link
) {
2362 if (!link_ipv6_forward_enabled(link
))
2365 /* On Linux, the IPv6 stack does not know a per-interface
2366 * packet forwarding setting: either packet forwarding is on
2367 * for all, or off for all. We hence don't bother with a
2368 * per-interface setting, but simply propagate the interface
2369 * flag, if it is set, to the global flag, one-way. Note that
2370 * while IPv4 would allow a per-interface flag, we expose the
2371 * same behaviour there and also propagate the setting from
2372 * one to all, to keep things simple (see above). */
2374 r
= write_string_file("/proc/sys/net/ipv6/conf/all/forwarding", "1", WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2376 log_link_warning_errno(link
, r
, "Cannot configure IPv6 packet forwarding, ignoring: %m");
2381 static int link_set_ipv6_privacy_extensions(Link
*link
) {
2382 char buf
[DECIMAL_STR_MAX(unsigned) + 1];
2383 IPv6PrivacyExtensions s
;
2384 const char *p
= NULL
;
2387 s
= link_ipv6_privacy_extensions(link
);
2391 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/use_tempaddr");
2392 xsprintf(buf
, "%u", (unsigned) link
->network
->ipv6_privacy_extensions
);
2394 r
= write_string_file(p
, buf
, WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2396 log_link_warning_errno(link
, r
, "Cannot configure IPv6 privacy extension for interface: %m");
2401 static int link_set_ipv6_accept_ra(Link
*link
) {
2402 const char *p
= NULL
;
2405 /* Make this a NOP if IPv6 is not available */
2406 if (!socket_ipv6_is_supported())
2409 if (link
->flags
& IFF_LOOPBACK
)
2415 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/accept_ra");
2417 /* We handle router advertisements ourselves, tell the kernel to GTFO */
2418 r
= write_string_file(p
, "0", WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2420 log_link_warning_errno(link
, r
, "Cannot disable kernel IPv6 accept_ra for interface: %m");
2425 static int link_set_ipv6_dad_transmits(Link
*link
) {
2426 char buf
[DECIMAL_STR_MAX(int) + 1];
2427 const char *p
= NULL
;
2430 /* Make this a NOP if IPv6 is not available */
2431 if (!socket_ipv6_is_supported())
2434 if (link
->flags
& IFF_LOOPBACK
)
2440 if (link
->network
->ipv6_dad_transmits
< 0)
2443 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/dad_transmits");
2444 xsprintf(buf
, "%i", link
->network
->ipv6_dad_transmits
);
2446 r
= write_string_file(p
, buf
, WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2448 log_link_warning_errno(link
, r
, "Cannot set IPv6 dad transmits for interface: %m");
2453 static int link_set_ipv6_hop_limit(Link
*link
) {
2454 char buf
[DECIMAL_STR_MAX(int) + 1];
2455 const char *p
= NULL
;
2458 /* Make this a NOP if IPv6 is not available */
2459 if (!socket_ipv6_is_supported())
2462 if (link
->flags
& IFF_LOOPBACK
)
2468 if (link
->network
->ipv6_hop_limit
< 0)
2471 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/hop_limit");
2472 xsprintf(buf
, "%i", link
->network
->ipv6_hop_limit
);
2474 r
= write_string_file(p
, buf
, WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2476 log_link_warning_errno(link
, r
, "Cannot set IPv6 hop limit for interface: %m");
2481 static int link_drop_foreign_config(Link
*link
) {
2487 SET_FOREACH(address
, link
->addresses_foreign
, i
) {
2488 /* we consider IPv6LL addresses to be managed by the kernel */
2489 if (address
->family
== AF_INET6
&& in_addr_is_link_local(AF_INET6
, &address
->in_addr
) == 1)
2492 r
= address_remove(address
, link
, link_address_remove_handler
);
2497 SET_FOREACH(route
, link
->routes_foreign
, i
) {
2498 /* do not touch routes managed by the kernel */
2499 if (route
->protocol
== RTPROT_KERNEL
)
2502 r
= route_remove(route
, link
, link_route_remove_handler
);
2510 static int link_drop_config(Link
*link
) {
2511 Address
*address
, *pool_address
;
2516 SET_FOREACH(address
, link
->addresses
, i
) {
2517 /* we consider IPv6LL addresses to be managed by the kernel */
2518 if (address
->family
== AF_INET6
&& in_addr_is_link_local(AF_INET6
, &address
->in_addr
) == 1)
2521 r
= address_remove(address
, link
, link_address_remove_handler
);
2525 /* If this address came from an address pool, clean up the pool */
2526 LIST_FOREACH(addresses
, pool_address
, link
->pool_addresses
) {
2527 if (address_equal(address
, pool_address
)) {
2528 LIST_REMOVE(addresses
, link
->pool_addresses
, pool_address
);
2529 address_free(pool_address
);
2535 SET_FOREACH(route
, link
->routes
, i
) {
2536 /* do not touch routes managed by the kernel */
2537 if (route
->protocol
== RTPROT_KERNEL
)
2540 r
= route_remove(route
, link
, link_route_remove_handler
);
2550 static int link_update_lldp(Link
*link
) {
2558 if (link
->flags
& IFF_UP
) {
2559 r
= sd_lldp_start(link
->lldp
);
2561 log_link_debug(link
, "Started LLDP.");
2563 r
= sd_lldp_stop(link
->lldp
);
2565 log_link_debug(link
, "Stopped LLDP.");
2571 static int link_configure(Link
*link
) {
2575 assert(link
->network
);
2576 assert(link
->state
== LINK_STATE_PENDING
);
2578 if (streq_ptr(link
->kind
, "vcan")) {
2580 if (!(link
->flags
& IFF_UP
)) {
2581 r
= link_up_can(link
);
2583 link_enter_failed(link
);
2591 /* Drop foreign config, but ignore loopback or critical devices.
2592 * We do not want to remove loopback address or addresses used for root NFS. */
2593 if (!(link
->flags
& IFF_LOOPBACK
) && !(link
->network
->dhcp_critical
)) {
2594 r
= link_drop_foreign_config(link
);
2599 r
= link_set_proxy_arp(link
);
2603 r
= ipv6_proxy_ndp_addresses_configure(link
);
2607 r
= link_set_ipv4_forward(link
);
2611 r
= link_set_ipv6_forward(link
);
2615 r
= link_set_ipv6_privacy_extensions(link
);
2619 r
= link_set_ipv6_accept_ra(link
);
2623 r
= link_set_ipv6_dad_transmits(link
);
2627 r
= link_set_ipv6_hop_limit(link
);
2631 r
= link_set_flags(link
);
2635 if (link_ipv4ll_enabled(link
)) {
2636 r
= ipv4ll_configure(link
);
2641 if (link_dhcp4_enabled(link
)) {
2642 r
= dhcp4_set_promote_secondaries(link
);
2646 r
= dhcp4_configure(link
);
2651 if (link_dhcp4_server_enabled(link
)) {
2652 r
= sd_dhcp_server_new(&link
->dhcp_server
, link
->ifindex
);
2656 r
= sd_dhcp_server_attach_event(link
->dhcp_server
, NULL
, 0);
2661 if (link_dhcp6_enabled(link
) ||
2662 link_ipv6_accept_ra_enabled(link
)) {
2663 r
= dhcp6_configure(link
);
2668 if (link_ipv6_accept_ra_enabled(link
)) {
2669 r
= ndisc_configure(link
);
2674 if (link_radv_enabled(link
)) {
2675 r
= radv_configure(link
);
2680 if (link_lldp_rx_enabled(link
)) {
2681 r
= sd_lldp_new(&link
->lldp
);
2685 r
= sd_lldp_set_ifindex(link
->lldp
, link
->ifindex
);
2689 r
= sd_lldp_match_capabilities(link
->lldp
,
2690 link
->network
->lldp_mode
== LLDP_MODE_ROUTERS_ONLY
?
2691 SD_LLDP_SYSTEM_CAPABILITIES_ALL_ROUTERS
:
2692 SD_LLDP_SYSTEM_CAPABILITIES_ALL
);
2696 r
= sd_lldp_set_filter_address(link
->lldp
, &link
->mac
);
2700 r
= sd_lldp_attach_event(link
->lldp
, NULL
, 0);
2704 r
= sd_lldp_set_callback(link
->lldp
, lldp_handler
, link
);
2708 r
= link_update_lldp(link
);
2713 if (link_has_carrier(link
) || link
->network
->configure_without_carrier
) {
2714 r
= link_acquire_conf(link
);
2719 return link_enter_join_netdev(link
);
2722 static int link_initialized_and_synced(sd_netlink
*rtnl
, sd_netlink_message
*m
,
2724 _cleanup_link_unref_ Link
*link
= userdata
;
2729 assert(link
->ifname
);
2730 assert(link
->manager
);
2732 if (link
->state
!= LINK_STATE_PENDING
)
2735 log_link_debug(link
, "Link state is up-to-date");
2737 r
= link_new_bound_by_list(link
);
2741 r
= link_handle_bound_by_list(link
);
2745 if (!link
->network
) {
2746 r
= network_get(link
->manager
, link
->udev_device
, link
->ifname
,
2747 &link
->mac
, &network
);
2749 link_enter_unmanaged(link
);
2751 } else if (r
== 0 && network
->unmanaged
) {
2752 link_enter_unmanaged(link
);
2757 if (link
->flags
& IFF_LOOPBACK
) {
2758 if (network
->link_local
!= ADDRESS_FAMILY_NO
)
2759 log_link_debug(link
, "Ignoring link-local autoconfiguration for loopback link");
2761 if (network
->dhcp
!= ADDRESS_FAMILY_NO
)
2762 log_link_debug(link
, "Ignoring DHCP clients for loopback link");
2764 if (network
->dhcp_server
)
2765 log_link_debug(link
, "Ignoring DHCP server for loopback link");
2768 r
= network_apply(network
, link
);
2773 r
= link_new_bound_to_list(link
);
2777 r
= link_configure(link
);
2784 int link_initialized(Link
*link
, struct udev_device
*device
) {
2785 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
2789 assert(link
->manager
);
2790 assert(link
->manager
->rtnl
);
2793 if (link
->state
!= LINK_STATE_PENDING
)
2796 if (link
->udev_device
)
2799 log_link_debug(link
, "udev initialized link");
2801 link
->udev_device
= udev_device_ref(device
);
2803 /* udev has initialized the link, but we don't know if we have yet
2804 * processed the NEWLINK messages with the latest state. Do a GETLINK,
2805 * when it returns we know that the pending NEWLINKs have already been
2806 * processed and that we are up-to-date */
2808 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_GETLINK
,
2813 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
,
2814 link_initialized_and_synced
, link
, 0, NULL
);
2823 static int link_load(Link
*link
) {
2824 _cleanup_free_
char *network_file
= NULL
,
2827 *dhcp4_address
= NULL
,
2828 *ipv4ll_address
= NULL
;
2829 union in_addr_union address
;
2830 union in_addr_union route_dst
;
2836 r
= parse_env_file(link
->state_file
, NEWLINE
,
2837 "NETWORK_FILE", &network_file
,
2838 "ADDRESSES", &addresses
,
2840 "DHCP4_ADDRESS", &dhcp4_address
,
2841 "IPV4LL_ADDRESS", &ipv4ll_address
,
2843 if (r
< 0 && r
!= -ENOENT
)
2844 return log_link_error_errno(link
, r
, "Failed to read %s: %m", link
->state_file
);
2851 suffix
= strrchr(network_file
, '.');
2853 log_link_debug(link
, "Failed to get network name from %s", network_file
);
2854 goto network_file_fail
;
2858 r
= network_get_by_name(link
->manager
, basename(network_file
), &network
);
2860 log_link_debug_errno(link
, r
, "Failed to get network %s: %m", basename(network_file
));
2861 goto network_file_fail
;
2864 r
= network_apply(network
, link
);
2866 return log_link_error_errno(link
, r
, "Failed to apply network %s: %m", basename(network_file
));
2875 _cleanup_free_
char *address_str
= NULL
;
2876 char *prefixlen_str
;
2878 unsigned char prefixlen
;
2880 r
= extract_first_word(&p
, &address_str
, NULL
, 0);
2882 log_link_debug_errno(link
, r
, "Failed to extract next address string: %m");
2888 prefixlen_str
= strchr(address_str
, '/');
2889 if (!prefixlen_str
) {
2890 log_link_debug(link
, "Failed to parse address and prefix length %s", address_str
);
2894 *prefixlen_str
++ = '\0';
2896 r
= sscanf(prefixlen_str
, "%hhu", &prefixlen
);
2898 log_link_error(link
, "Failed to parse prefixlen %s", prefixlen_str
);
2902 r
= in_addr_from_string_auto(address_str
, &family
, &address
);
2904 log_link_debug_errno(link
, r
, "Failed to parse address %s: %m", address_str
);
2908 r
= address_add(link
, family
, &address
, prefixlen
, NULL
);
2910 return log_link_error_errno(link
, r
, "Failed to add address: %m");
2919 _cleanup_free_
char *route_str
= NULL
;
2920 _cleanup_(sd_event_source_unrefp
) sd_event_source
*expire
= NULL
;
2922 char *prefixlen_str
;
2924 unsigned char prefixlen
, tos
, table
;
2927 r
= extract_first_word(&p
, &route_str
, NULL
, 0);
2929 log_link_debug_errno(link
, r
, "Failed to extract next route string: %m");
2935 prefixlen_str
= strchr(route_str
, '/');
2936 if (!prefixlen_str
) {
2937 log_link_debug(link
, "Failed to parse route %s", route_str
);
2941 *prefixlen_str
++ = '\0';
2943 r
= sscanf(prefixlen_str
, "%hhu/%hhu/%"SCNu32
"/%hhu/"USEC_FMT
, &prefixlen
, &tos
, &priority
, &table
, &lifetime
);
2945 log_link_debug(link
,
2946 "Failed to parse destination prefix length, tos, priority, table or expiration %s",
2951 r
= in_addr_from_string_auto(route_str
, &family
, &route_dst
);
2953 log_link_debug_errno(link
, r
, "Failed to parse route destination %s: %m", route_str
);
2957 r
= route_add(link
, family
, &route_dst
, prefixlen
, tos
, priority
, table
, &route
);
2959 return log_link_error_errno(link
, r
, "Failed to add route: %m");
2961 if (lifetime
!= USEC_INFINITY
) {
2962 r
= sd_event_add_time(link
->manager
->event
, &expire
, clock_boottime_or_monotonic(), lifetime
,
2963 0, route_expire_handler
, route
);
2965 log_link_warning_errno(link
, r
, "Could not arm route expiration handler: %m");
2968 route
->lifetime
= lifetime
;
2969 sd_event_source_unref(route
->expire
);
2970 route
->expire
= expire
;
2975 if (dhcp4_address
) {
2976 r
= in_addr_from_string(AF_INET
, dhcp4_address
, &address
);
2978 log_link_debug_errno(link
, r
, "Failed to parse DHCPv4 address %s: %m", dhcp4_address
);
2979 goto dhcp4_address_fail
;
2982 r
= sd_dhcp_client_new(&link
->dhcp_client
, link
->network
->dhcp_anonymize
);
2984 return log_link_error_errno(link
, r
, "Failed to create DHCPv4 client: %m");
2986 r
= sd_dhcp_client_set_request_address(link
->dhcp_client
, &address
.in
);
2988 return log_link_error_errno(link
, r
, "Failed to set initial DHCPv4 address %s: %m", dhcp4_address
);
2993 if (ipv4ll_address
) {
2994 r
= in_addr_from_string(AF_INET
, ipv4ll_address
, &address
);
2996 log_link_debug_errno(link
, r
, "Failed to parse IPv4LL address %s: %m", ipv4ll_address
);
2997 goto ipv4ll_address_fail
;
3000 r
= sd_ipv4ll_new(&link
->ipv4ll
);
3002 return log_link_error_errno(link
, r
, "Failed to create IPv4LL client: %m");
3004 r
= sd_ipv4ll_set_address(link
->ipv4ll
, &address
.in
);
3006 return log_link_error_errno(link
, r
, "Failed to set initial IPv4LL address %s: %m", ipv4ll_address
);
3009 ipv4ll_address_fail
:
3014 int link_add(Manager
*m
, sd_netlink_message
*message
, Link
**ret
) {
3016 _cleanup_udev_device_unref_
struct udev_device
*device
= NULL
;
3017 char ifindex_str
[2 + DECIMAL_STR_MAX(int)];
3025 r
= link_new(m
, message
, ret
);
3031 log_link_debug(link
, "Link %d added", link
->ifindex
);
3033 r
= link_load(link
);
3037 if (detect_container() <= 0) {
3038 /* not in a container, udev will be around */
3039 sprintf(ifindex_str
, "n%d", link
->ifindex
);
3040 device
= udev_device_new_from_device_id(m
->udev
, ifindex_str
);
3042 r
= log_link_warning_errno(link
, errno
, "Could not find udev device: %m");
3046 if (udev_device_get_is_initialized(device
) <= 0) {
3048 log_link_debug(link
, "link pending udev initialization...");
3052 r
= link_initialized(link
, device
);
3056 /* we are calling a callback directly, so must take a ref */
3059 r
= link_initialized_and_synced(m
->rtnl
, NULL
, link
);
3066 link_enter_failed(link
);
3070 int link_ipv6ll_gained(Link
*link
, const struct in6_addr
*address
) {
3075 log_link_info(link
, "Gained IPv6LL");
3077 link
->ipv6ll_address
= *address
;
3078 link_check_ready(link
);
3080 if (!IN_SET(link
->state
, LINK_STATE_PENDING
, LINK_STATE_UNMANAGED
, LINK_STATE_FAILED
)) {
3081 r
= link_acquire_ipv6_conf(link
);
3083 link_enter_failed(link
);
3091 static int link_carrier_gained(Link
*link
) {
3096 if (!IN_SET(link
->state
, LINK_STATE_PENDING
, LINK_STATE_UNMANAGED
, LINK_STATE_FAILED
)) {
3097 r
= link_acquire_conf(link
);
3099 link_enter_failed(link
);
3103 r
= link_enter_set_addresses(link
);
3108 r
= link_handle_bound_by_list(link
);
3115 static int link_carrier_lost(Link
*link
) {
3120 /* Some devices reset itself while setting the MTU. This causes the DHCP client fall into a loop.
3121 setting_mtu keep track whether the device got reset because of setting MTU and does not drop the
3122 configuration and stop the clients as well. */
3123 if (link
->setting_mtu
)
3126 r
= link_stop_clients(link
);
3128 link_enter_failed(link
);
3132 if (link_dhcp4_server_enabled(link
))
3133 (void) sd_dhcp_server_stop(link
->dhcp_server
);
3135 r
= link_drop_config(link
);
3139 if (!IN_SET(link
->state
, LINK_STATE_UNMANAGED
, LINK_STATE_PENDING
)) {
3140 log_link_debug(link
, "State is %s, dropping config", link_state_to_string(link
->state
));
3141 r
= link_drop_foreign_config(link
);
3146 r
= link_handle_bound_by_list(link
);
3153 int link_carrier_reset(Link
*link
) {
3158 if (link_has_carrier(link
)) {
3159 r
= link_carrier_lost(link
);
3163 r
= link_carrier_gained(link
);
3167 log_link_info(link
, "Reset carrier");
3173 int link_update(Link
*link
, sd_netlink_message
*m
) {
3174 struct ether_addr mac
;
3177 bool had_carrier
, carrier_gained
, carrier_lost
;
3181 assert(link
->ifname
);
3184 if (link
->state
== LINK_STATE_LINGER
) {
3186 log_link_info(link
, "Link readded");
3187 link_set_state(link
, LINK_STATE_ENSLAVING
);
3189 r
= link_new_carrier_maps(link
);
3194 r
= sd_netlink_message_read_string(m
, IFLA_IFNAME
, &ifname
);
3195 if (r
>= 0 && !streq(ifname
, link
->ifname
)) {
3196 log_link_info(link
, "Interface name change detected, %s has been renamed to %s.", link
->ifname
, ifname
);
3198 link_free_carrier_maps(link
);
3200 r
= free_and_strdup(&link
->ifname
, ifname
);
3204 r
= link_new_carrier_maps(link
);
3209 r
= sd_netlink_message_read_u32(m
, IFLA_MTU
, &mtu
);
3210 if (r
>= 0 && mtu
> 0) {
3212 if (!link
->original_mtu
) {
3213 link
->original_mtu
= mtu
;
3214 log_link_debug(link
, "Saved original MTU: %" PRIu32
, link
->original_mtu
);
3217 if (link
->dhcp_client
) {
3218 r
= sd_dhcp_client_set_mtu(link
->dhcp_client
,
3221 log_link_warning_errno(link
, r
, "Could not update MTU in DHCP client: %m");
3227 r
= sd_radv_set_mtu(link
->radv
, link
->mtu
);
3229 return log_link_warning_errno(link
, r
, "Could not set MTU for Router Advertisement: %m");
3233 /* The kernel may broadcast NEWLINK messages without the MAC address
3234 set, simply ignore them. */
3235 r
= sd_netlink_message_read_ether_addr(m
, IFLA_ADDRESS
, &mac
);
3237 if (memcmp(link
->mac
.ether_addr_octet
, mac
.ether_addr_octet
,
3240 memcpy(link
->mac
.ether_addr_octet
, mac
.ether_addr_octet
,
3243 log_link_debug(link
, "MAC address: "
3244 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
3245 mac
.ether_addr_octet
[0],
3246 mac
.ether_addr_octet
[1],
3247 mac
.ether_addr_octet
[2],
3248 mac
.ether_addr_octet
[3],
3249 mac
.ether_addr_octet
[4],
3250 mac
.ether_addr_octet
[5]);
3253 r
= sd_ipv4ll_set_mac(link
->ipv4ll
, &link
->mac
);
3255 return log_link_warning_errno(link
, r
, "Could not update MAC address in IPv4LL client: %m");
3258 if (link
->dhcp_client
) {
3259 r
= sd_dhcp_client_set_mac(link
->dhcp_client
,
3260 (const uint8_t *) &link
->mac
,
3264 return log_link_warning_errno(link
, r
, "Could not update MAC address in DHCP client: %m");
3266 switch (link
->network
->dhcp_client_identifier
) {
3267 case DHCP_CLIENT_ID_DUID
: {
3268 const DUID
*duid
= link_duid(link
);
3270 r
= sd_dhcp_client_set_iaid_duid(link
->dhcp_client
,
3271 link
->network
->iaid
,
3273 duid
->raw_data_len
> 0 ? duid
->raw_data
: NULL
,
3274 duid
->raw_data_len
);
3276 return log_link_warning_errno(link
, r
, "Could not update DUID/IAID in DHCP client: %m");
3279 case DHCP_CLIENT_ID_MAC
:
3280 r
= sd_dhcp_client_set_client_id(link
->dhcp_client
,
3282 (const uint8_t *)&link
->mac
,
3285 return log_link_warning_errno(link
, r
, "Could not update MAC client id in DHCP client: %m");
3288 assert_not_reached("Unknown client identifier type.");
3292 if (link
->dhcp6_client
) {
3293 const DUID
* duid
= link_duid(link
);
3295 r
= sd_dhcp6_client_set_mac(link
->dhcp6_client
,
3296 (const uint8_t *) &link
->mac
,
3300 return log_link_warning_errno(link
, r
, "Could not update MAC address in DHCPv6 client: %m");
3302 r
= sd_dhcp6_client_set_iaid(link
->dhcp6_client
,
3303 link
->network
->iaid
);
3305 return log_link_warning_errno(link
, r
, "Could not update DHCPv6 IAID: %m");
3307 r
= sd_dhcp6_client_set_duid(link
->dhcp6_client
,
3309 duid
->raw_data_len
> 0 ? duid
->raw_data
: NULL
,
3310 duid
->raw_data_len
);
3312 return log_link_warning_errno(link
, r
, "Could not update DHCPv6 DUID: %m");
3316 r
= sd_radv_set_mac(link
->radv
, &link
->mac
);
3318 return log_link_warning_errno(link
, r
, "Could not update MAC for Router Advertisement: %m");
3323 had_carrier
= link_has_carrier(link
);
3325 r
= link_update_flags(link
, m
);
3329 r
= link_update_lldp(link
);
3333 carrier_gained
= !had_carrier
&& link_has_carrier(link
);
3334 carrier_lost
= had_carrier
&& !link_has_carrier(link
);
3336 if (carrier_gained
) {
3337 log_link_info(link
, "Gained carrier");
3339 r
= link_carrier_gained(link
);
3342 } else if (carrier_lost
) {
3343 log_link_info(link
, "Lost carrier");
3345 r
= link_carrier_lost(link
);
3353 static void print_link_hashmap(FILE *f
, const char *prefix
, Hashmap
* h
) {
3361 if (hashmap_isempty(h
))
3365 HASHMAP_FOREACH(link
, h
, i
) {
3369 fprintf(f
, "%i", link
->ifindex
);
3376 int link_save(Link
*link
) {
3377 _cleanup_free_
char *temp_path
= NULL
;
3378 _cleanup_fclose_
FILE *f
= NULL
;
3379 const char *admin_state
, *oper_state
;
3386 assert(link
->state_file
);
3387 assert(link
->lease_file
);
3388 assert(link
->manager
);
3390 if (link
->state
== LINK_STATE_LINGER
) {
3391 unlink(link
->state_file
);
3395 link_lldp_save(link
);
3397 admin_state
= link_state_to_string(link
->state
);
3398 assert(admin_state
);
3400 oper_state
= link_operstate_to_string(link
->operstate
);
3403 r
= fopen_temporary(link
->state_file
, &f
, &temp_path
);
3407 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
3408 (void) fchmod(fileno(f
), 0644);
3411 "# This is private data. Do not parse.\n"
3414 admin_state
, oper_state
);
3416 if (link
->network
) {
3418 sd_dhcp6_lease
*dhcp6_lease
= NULL
;
3419 const char *dhcp_domainname
= NULL
;
3420 char **dhcp6_domains
= NULL
;
3421 char **dhcp_domains
= NULL
;
3424 fprintf(f
, "REQUIRED_FOR_ONLINE=%s\n",
3425 yes_no(link
->network
->required_for_online
));
3427 if (link
->dhcp6_client
) {
3428 r
= sd_dhcp6_client_get_lease(link
->dhcp6_client
, &dhcp6_lease
);
3429 if (r
< 0 && r
!= -ENOMSG
)
3430 log_link_debug(link
, "No DHCPv6 lease");
3433 fprintf(f
, "NETWORK_FILE=%s\n", link
->network
->filename
);
3438 for (j
= 0; j
< link
->network
->n_dns
; j
++) {
3439 _cleanup_free_
char *b
= NULL
;
3441 r
= in_addr_to_string(link
->network
->dns
[j
].family
,
3442 &link
->network
->dns
[j
].address
, &b
);
3444 log_debug_errno(r
, "Failed to format address, ignoring: %m");
3454 if (link
->network
->dhcp_use_dns
&&
3456 const struct in_addr
*addresses
;
3458 r
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &addresses
);
3462 serialize_in_addrs(f
, addresses
, r
);
3467 if (link
->network
->dhcp_use_dns
&& dhcp6_lease
) {
3468 struct in6_addr
*in6_addrs
;
3470 r
= sd_dhcp6_lease_get_dns(dhcp6_lease
, &in6_addrs
);
3474 serialize_in6_addrs(f
, in6_addrs
, r
);
3479 /* Make sure to flush out old entries before we use the NDISC data */
3482 if (link
->network
->dhcp_use_dns
&& link
->ndisc_rdnss
) {
3485 SET_FOREACH(dd
, link
->ndisc_rdnss
, i
) {
3489 serialize_in6_addrs(f
, &dd
->address
, 1);
3498 fputstrv(f
, link
->network
->ntp
, NULL
, &space
);
3500 if (link
->network
->dhcp_use_ntp
&&
3502 const struct in_addr
*addresses
;
3504 r
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &addresses
);
3508 serialize_in_addrs(f
, addresses
, r
);
3513 if (link
->network
->dhcp_use_ntp
&& dhcp6_lease
) {
3514 struct in6_addr
*in6_addrs
;
3517 r
= sd_dhcp6_lease_get_ntp_addrs(dhcp6_lease
,
3522 serialize_in6_addrs(f
, in6_addrs
, r
);
3526 r
= sd_dhcp6_lease_get_ntp_fqdn(dhcp6_lease
, &hosts
);
3528 fputstrv(f
, hosts
, NULL
, &space
);
3533 if (link
->network
->dhcp_use_domains
!= DHCP_USE_DOMAINS_NO
) {
3534 if (link
->dhcp_lease
) {
3535 (void) sd_dhcp_lease_get_domainname(link
->dhcp_lease
, &dhcp_domainname
);
3536 (void) sd_dhcp_lease_get_search_domains(link
->dhcp_lease
, &dhcp_domains
);
3539 (void) sd_dhcp6_lease_get_domains(dhcp6_lease
, &dhcp6_domains
);
3542 fputs("DOMAINS=", f
);
3544 fputstrv(f
, link
->network
->search_domains
, NULL
, &space
);
3546 if (link
->network
->dhcp_use_domains
== DHCP_USE_DOMAINS_YES
) {
3549 if (dhcp_domainname
)
3550 fputs_with_space(f
, dhcp_domainname
, NULL
, &space
);
3552 fputstrv(f
, dhcp_domains
, NULL
, &space
);
3554 fputstrv(f
, dhcp6_domains
, NULL
, &space
);
3556 SET_FOREACH(dd
, link
->ndisc_dnssl
, i
)
3557 fputs_with_space(f
, NDISC_DNSSL_DOMAIN(dd
), NULL
, &space
);
3562 fputs("ROUTE_DOMAINS=", f
);
3564 fputstrv(f
, link
->network
->route_domains
, NULL
, &space
);
3566 if (link
->network
->dhcp_use_domains
== DHCP_USE_DOMAINS_ROUTE
) {
3569 if (dhcp_domainname
)
3570 fputs_with_space(f
, dhcp_domainname
, NULL
, &space
);
3572 fputstrv(f
, dhcp_domains
, NULL
, &space
);
3574 fputstrv(f
, dhcp6_domains
, NULL
, &space
);
3576 SET_FOREACH(dd
, link
->ndisc_dnssl
, i
)
3577 fputs_with_space(f
, NDISC_DNSSL_DOMAIN(dd
), NULL
, &space
);
3582 fprintf(f
, "LLMNR=%s\n",
3583 resolve_support_to_string(link
->network
->llmnr
));
3584 fprintf(f
, "MDNS=%s\n",
3585 resolve_support_to_string(link
->network
->mdns
));
3587 if (link
->network
->dnssec_mode
!= _DNSSEC_MODE_INVALID
)
3588 fprintf(f
, "DNSSEC=%s\n",
3589 dnssec_mode_to_string(link
->network
->dnssec_mode
));
3591 if (!set_isempty(link
->network
->dnssec_negative_trust_anchors
)) {
3594 fputs("DNSSEC_NTA=", f
);
3596 SET_FOREACH(n
, link
->network
->dnssec_negative_trust_anchors
, i
)
3597 fputs_with_space(f
, n
, NULL
, &space
);
3601 fputs("ADDRESSES=", f
);
3603 SET_FOREACH(a
, link
->addresses
, i
) {
3604 _cleanup_free_
char *address_str
= NULL
;
3606 r
= in_addr_to_string(a
->family
, &a
->in_addr
, &address_str
);
3610 fprintf(f
, "%s%s/%u", space
? " " : "", address_str
, a
->prefixlen
);
3615 fputs("ROUTES=", f
);
3617 SET_FOREACH(route
, link
->routes
, i
) {
3618 _cleanup_free_
char *route_str
= NULL
;
3620 r
= in_addr_to_string(route
->family
, &route
->dst
, &route_str
);
3624 fprintf(f
, "%s%s/%hhu/%hhu/%"PRIu32
"/%"PRIu32
"/"USEC_FMT
,
3625 space
? " " : "", route_str
,
3626 route
->dst_prefixlen
, route
->tos
, route
->priority
, route
->table
, route
->lifetime
);
3633 print_link_hashmap(f
, "CARRIER_BOUND_TO=", link
->bound_to_links
);
3634 print_link_hashmap(f
, "CARRIER_BOUND_BY=", link
->bound_by_links
);
3636 if (link
->dhcp_lease
) {
3637 struct in_addr address
;
3638 const char *tz
= NULL
;
3640 assert(link
->network
);
3642 r
= sd_dhcp_lease_get_timezone(link
->dhcp_lease
, &tz
);
3644 fprintf(f
, "TIMEZONE=%s\n", tz
);
3646 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &address
);
3648 fputs("DHCP4_ADDRESS=", f
);
3649 serialize_in_addrs(f
, &address
, 1);
3653 r
= dhcp_lease_save(link
->dhcp_lease
, link
->lease_file
);
3661 unlink(link
->lease_file
);
3664 struct in_addr address
;
3666 r
= sd_ipv4ll_get_address(link
->ipv4ll
, &address
);
3668 fputs("IPV4LL_ADDRESS=", f
);
3669 serialize_in_addrs(f
, &address
, 1);
3674 r
= fflush_and_check(f
);
3678 if (rename(temp_path
, link
->state_file
) < 0) {
3686 (void) unlink(link
->state_file
);
3688 (void) unlink(temp_path
);
3690 return log_link_error_errno(link
, r
, "Failed to save link data to %s: %m", link
->state_file
);
3693 /* The serialized state in /run is no longer up-to-date. */
3694 void link_dirty(Link
*link
) {
3699 /* mark manager dirty as link is dirty */
3700 manager_dirty(link
->manager
);
3702 r
= set_ensure_allocated(&link
->manager
->dirty_links
, NULL
);
3704 /* allocation errors are ignored */
3707 r
= set_put(link
->manager
->dirty_links
, link
);
3709 /* don't take another ref if the link was already dirty */
3715 /* The serialized state in /run is up-to-date */
3716 void link_clean(Link
*link
) {
3718 assert(link
->manager
);
3720 set_remove(link
->manager
->dirty_links
, link
);
3724 static const char* const link_state_table
[_LINK_STATE_MAX
] = {
3725 [LINK_STATE_PENDING
] = "pending",
3726 [LINK_STATE_ENSLAVING
] = "configuring",
3727 [LINK_STATE_SETTING_ADDRESSES
] = "configuring",
3728 [LINK_STATE_SETTING_ROUTES
] = "configuring",
3729 [LINK_STATE_CONFIGURED
] = "configured",
3730 [LINK_STATE_UNMANAGED
] = "unmanaged",
3731 [LINK_STATE_FAILED
] = "failed",
3732 [LINK_STATE_LINGER
] = "linger",
3735 DEFINE_STRING_TABLE_LOOKUP(link_state
, LinkState
);
3737 static const char* const link_operstate_table
[_LINK_OPERSTATE_MAX
] = {
3738 [LINK_OPERSTATE_OFF
] = "off",
3739 [LINK_OPERSTATE_NO_CARRIER
] = "no-carrier",
3740 [LINK_OPERSTATE_DORMANT
] = "dormant",
3741 [LINK_OPERSTATE_CARRIER
] = "carrier",
3742 [LINK_OPERSTATE_DEGRADED
] = "degraded",
3743 [LINK_OPERSTATE_ROUTABLE
] = "routable",
3746 DEFINE_STRING_TABLE_LOOKUP(link_operstate
, LinkOperationalState
);