1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
3 #include <netinet/in.h>
5 #include <linux/if_arp.h>
6 #include <linux/if_link.h>
9 #include "alloc-util.h"
14 #include "device-private.h"
15 #include "device-util.h"
16 #include "dhcp-identifier.h"
17 #include "dhcp-lease-internal.h"
19 #include "ethtool-util.h"
24 #include "missing_network.h"
25 #include "netlink-util.h"
26 #include "network-internal.h"
27 #include "networkd-address-label.h"
28 #include "networkd-address.h"
29 #include "networkd-can.h"
30 #include "networkd-dhcp-server.h"
31 #include "networkd-dhcp4.h"
32 #include "networkd-dhcp6.h"
33 #include "networkd-fdb.h"
34 #include "networkd-ipv4ll.h"
35 #include "networkd-link-bus.h"
36 #include "networkd-link.h"
37 #include "networkd-lldp-tx.h"
38 #include "networkd-manager.h"
39 #include "networkd-mdb.h"
40 #include "networkd-ndisc.h"
41 #include "networkd-neighbor.h"
42 #include "networkd-nexthop.h"
43 #include "networkd-sriov.h"
44 #include "networkd-sysctl.h"
45 #include "networkd-radv.h"
46 #include "networkd-routing-policy-rule.h"
47 #include "networkd-state-file.h"
48 #include "networkd-wifi.h"
50 #include "socket-util.h"
51 #include "stat-util.h"
52 #include "stdio-util.h"
53 #include "string-table.h"
55 #include "sysctl-util.h"
57 #include "tmpfile-util.h"
58 #include "udev-util.h"
62 bool link_ipv4ll_enabled(Link
*link
) {
65 if (link
->flags
& IFF_LOOPBACK
)
71 if (link
->iftype
== ARPHRD_CAN
)
74 if (STRPTR_IN_SET(link
->kind
,
75 "vrf", "wireguard", "ipip", "gre", "ip6gre","ip6tnl", "sit", "vti",
76 "vti6", "nlmon", "xfrm", "bareudp"))
79 /* L3 or L3S mode do not support ARP. */
80 if (IN_SET(link_get_ipvlan_mode(link
), NETDEV_IPVLAN_MODE_L3
, NETDEV_IPVLAN_MODE_L3S
))
83 if (link
->network
->bond
)
86 return link
->network
->link_local
& ADDRESS_FAMILY_IPV4
;
89 bool link_ipv6ll_enabled(Link
*link
) {
92 if (!socket_ipv6_is_supported())
95 if (link
->flags
& IFF_LOOPBACK
)
101 if (link
->iftype
== ARPHRD_CAN
)
104 if (STRPTR_IN_SET(link
->kind
, "vrf", "wireguard", "ipip", "gre", "sit", "vti", "nlmon"))
107 if (link
->network
->bond
)
110 return link
->network
->link_local
& ADDRESS_FAMILY_IPV6
;
113 bool link_ipv6_enabled(Link
*link
) {
116 if (!socket_ipv6_is_supported())
119 if (link
->network
->bond
)
122 if (link
->iftype
== ARPHRD_CAN
)
125 /* DHCPv6 client will not be started if no IPv6 link-local address is configured. */
126 if (link_ipv6ll_enabled(link
))
129 if (network_has_static_ipv6_configurations(link
->network
))
135 static bool link_is_enslaved(Link
*link
) {
136 if (link
->flags
& IFF_SLAVE
)
137 /* Even if the link is not managed by networkd, honor IFF_SLAVE flag. */
143 if (link
->master_ifindex
> 0 && link
->network
->bridge
)
146 /* TODO: add conditions for other netdevs. */
151 static void link_update_master_operstate(Link
*link
, NetDev
*netdev
) {
157 if (netdev
->ifindex
<= 0)
160 if (link_get(link
->manager
, netdev
->ifindex
, &master
) < 0)
163 link_update_operstate(master
, true);
166 void link_update_operstate(Link
*link
, bool also_update_master
) {
167 LinkOperationalState operstate
;
168 LinkCarrierState carrier_state
;
169 LinkAddressState address_state
;
170 _cleanup_strv_free_
char **p
= NULL
;
171 uint8_t scope
= RT_SCOPE_NOWHERE
;
172 bool changed
= false;
177 if (link
->kernel_operstate
== IF_OPER_DORMANT
)
178 carrier_state
= LINK_CARRIER_STATE_DORMANT
;
179 else if (link_has_carrier(link
)) {
180 if (link_is_enslaved(link
))
181 carrier_state
= LINK_CARRIER_STATE_ENSLAVED
;
183 carrier_state
= LINK_CARRIER_STATE_CARRIER
;
184 } else if (link
->flags
& IFF_UP
)
185 carrier_state
= LINK_CARRIER_STATE_NO_CARRIER
;
187 carrier_state
= LINK_CARRIER_STATE_OFF
;
189 if (carrier_state
>= LINK_CARRIER_STATE_CARRIER
) {
192 SET_FOREACH(slave
, link
->slaves
) {
193 link_update_operstate(slave
, false);
195 if (slave
->carrier_state
< LINK_CARRIER_STATE_CARRIER
)
196 carrier_state
= LINK_CARRIER_STATE_DEGRADED_CARRIER
;
200 SET_FOREACH(address
, link
->addresses
) {
201 if (!address_is_ready(address
))
204 if (address
->scope
< scope
)
205 scope
= address
->scope
;
208 /* for operstate we also take foreign addresses into account */
209 SET_FOREACH(address
, link
->addresses_foreign
) {
210 if (!address_is_ready(address
))
213 if (address
->scope
< scope
)
214 scope
= address
->scope
;
217 if (scope
< RT_SCOPE_SITE
)
218 /* universally accessible addresses found */
219 address_state
= LINK_ADDRESS_STATE_ROUTABLE
;
220 else if (scope
< RT_SCOPE_HOST
)
221 /* only link or site local addresses found */
222 address_state
= LINK_ADDRESS_STATE_DEGRADED
;
224 /* no useful addresses found */
225 address_state
= LINK_ADDRESS_STATE_OFF
;
227 /* Mapping of address and carrier state vs operational state
229 * | off | no-carrier | dormant | degraded-carrier | carrier | enslaved
230 * ------------------------------------------------------------------------------
231 * off | off | no-carrier | dormant | degraded-carrier | carrier | enslaved
232 * address_state degraded | off | no-carrier | dormant | degraded-carrier | degraded | enslaved
233 * routable | off | no-carrier | dormant | degraded-carrier | routable | routable
236 if (carrier_state
< LINK_CARRIER_STATE_CARRIER
|| address_state
== LINK_ADDRESS_STATE_OFF
)
237 operstate
= (LinkOperationalState
) carrier_state
;
238 else if (address_state
== LINK_ADDRESS_STATE_ROUTABLE
)
239 operstate
= LINK_OPERSTATE_ROUTABLE
;
240 else if (carrier_state
== LINK_CARRIER_STATE_CARRIER
)
241 operstate
= LINK_OPERSTATE_DEGRADED
;
243 operstate
= LINK_OPERSTATE_ENSLAVED
;
245 if (link
->carrier_state
!= carrier_state
) {
246 link
->carrier_state
= carrier_state
;
248 if (strv_extend(&p
, "CarrierState") < 0)
252 if (link
->address_state
!= address_state
) {
253 link
->address_state
= address_state
;
255 if (strv_extend(&p
, "AddressState") < 0)
259 if (link
->operstate
!= operstate
) {
260 link
->operstate
= operstate
;
262 if (strv_extend(&p
, "OperationalState") < 0)
267 link_send_changed_strv(link
, p
);
271 if (also_update_master
&& link
->network
) {
272 link_update_master_operstate(link
, link
->network
->batadv
);
273 link_update_master_operstate(link
, link
->network
->bond
);
274 link_update_master_operstate(link
, link
->network
->bridge
);
278 #define FLAG_STRING(string, flag, old, new) \
279 (((old ^ new) & flag) \
280 ? ((old & flag) ? (" -" string) : (" +" string)) \
283 static int link_update_flags(Link
*link
, sd_netlink_message
*m
, bool force_update_operstate
) {
284 unsigned flags
, unknown_flags_added
, unknown_flags_removed
, unknown_flags
;
290 r
= sd_rtnl_message_link_get_flags(m
, &flags
);
292 return log_link_warning_errno(link
, r
, "Could not get link flags: %m");
294 r
= sd_netlink_message_read_u8(m
, IFLA_OPERSTATE
, &operstate
);
296 /* if we got a message without operstate, take it to mean
297 the state was unchanged */
298 operstate
= link
->kernel_operstate
;
300 if (!force_update_operstate
&& (link
->flags
== flags
) && (link
->kernel_operstate
== operstate
))
303 if (link
->flags
!= flags
) {
304 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",
305 FLAG_STRING("LOOPBACK", IFF_LOOPBACK
, link
->flags
, flags
),
306 FLAG_STRING("MASTER", IFF_MASTER
, link
->flags
, flags
),
307 FLAG_STRING("SLAVE", IFF_SLAVE
, link
->flags
, flags
),
308 FLAG_STRING("UP", IFF_UP
, link
->flags
, flags
),
309 FLAG_STRING("DORMANT", IFF_DORMANT
, link
->flags
, flags
),
310 FLAG_STRING("LOWER_UP", IFF_LOWER_UP
, link
->flags
, flags
),
311 FLAG_STRING("RUNNING", IFF_RUNNING
, link
->flags
, flags
),
312 FLAG_STRING("MULTICAST", IFF_MULTICAST
, link
->flags
, flags
),
313 FLAG_STRING("BROADCAST", IFF_BROADCAST
, link
->flags
, flags
),
314 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT
, link
->flags
, flags
),
315 FLAG_STRING("PROMISC", IFF_PROMISC
, link
->flags
, flags
),
316 FLAG_STRING("ALLMULTI", IFF_ALLMULTI
, link
->flags
, flags
),
317 FLAG_STRING("PORTSEL", IFF_PORTSEL
, link
->flags
, flags
),
318 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA
, link
->flags
, flags
),
319 FLAG_STRING("DYNAMIC", IFF_DYNAMIC
, link
->flags
, flags
),
320 FLAG_STRING("NOARP", IFF_NOARP
, link
->flags
, flags
),
321 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS
, link
->flags
, flags
),
322 FLAG_STRING("DEBUG", IFF_DEBUG
, link
->flags
, flags
),
323 FLAG_STRING("ECHO", IFF_ECHO
, link
->flags
, flags
));
325 unknown_flags
= ~(IFF_LOOPBACK
| IFF_MASTER
| IFF_SLAVE
| IFF_UP
|
326 IFF_DORMANT
| IFF_LOWER_UP
| IFF_RUNNING
|
327 IFF_MULTICAST
| IFF_BROADCAST
| IFF_POINTOPOINT
|
328 IFF_PROMISC
| IFF_ALLMULTI
| IFF_PORTSEL
|
329 IFF_AUTOMEDIA
| IFF_DYNAMIC
| IFF_NOARP
|
330 IFF_NOTRAILERS
| IFF_DEBUG
| IFF_ECHO
);
331 unknown_flags_added
= ((link
->flags
^ flags
) & flags
& unknown_flags
);
332 unknown_flags_removed
= ((link
->flags
^ flags
) & link
->flags
& unknown_flags
);
334 /* link flags are currently at most 18 bits, let's align to
336 if (unknown_flags_added
)
338 "Unknown link flags gained: %#.5x (ignoring)",
339 unknown_flags_added
);
341 if (unknown_flags_removed
)
343 "Unknown link flags lost: %#.5x (ignoring)",
344 unknown_flags_removed
);
348 link
->kernel_operstate
= operstate
;
350 link_update_operstate(link
, true);
355 static int link_new(Manager
*manager
, sd_netlink_message
*message
, Link
**ret
) {
356 _cleanup_(link_unrefp
) Link
*link
= NULL
;
357 const char *ifname
, *kind
= NULL
;
358 unsigned short iftype
;
366 /* check for link kind */
367 r
= sd_netlink_message_enter_container(message
, IFLA_LINKINFO
);
369 (void) sd_netlink_message_read_string(message
, IFLA_INFO_KIND
, &kind
);
370 r
= sd_netlink_message_exit_container(message
);
375 r
= sd_netlink_message_get_type(message
, &type
);
378 else if (type
!= RTM_NEWLINK
)
381 r
= sd_rtnl_message_link_get_ifindex(message
, &ifindex
);
384 else if (ifindex
<= 0)
387 r
= sd_rtnl_message_link_get_type(message
, &iftype
);
391 r
= sd_netlink_message_read_string(message
, IFLA_IFNAME
, &ifname
);
402 .state
= LINK_STATE_PENDING
,
407 .dns_default_route
= -1,
408 .llmnr
= _RESOLVE_SUPPORT_INVALID
,
409 .mdns
= _RESOLVE_SUPPORT_INVALID
,
410 .dnssec_mode
= _DNSSEC_MODE_INVALID
,
411 .dns_over_tls_mode
= _DNS_OVER_TLS_MODE_INVALID
,
414 link
->ifname
= strdup(ifname
);
419 link
->kind
= strdup(kind
);
424 r
= sd_netlink_message_read_u32(message
, IFLA_MASTER
, (uint32_t *)&link
->master_ifindex
);
426 log_link_debug_errno(link
, r
, "New device has no master, continuing without");
428 r
= netlink_message_read_hw_addr(message
, IFLA_ADDRESS
, &link
->hw_addr
);
430 log_link_debug_errno(link
, r
, "Hardware address not found for new device, continuing without");
432 r
= netlink_message_read_hw_addr(message
, IFLA_BROADCAST
, &link
->bcast_addr
);
434 log_link_debug_errno(link
, r
, "Broadcast address not found for new device, continuing without");
436 r
= ethtool_get_permanent_macaddr(&manager
->ethtool_fd
, link
->ifname
, &link
->permanent_mac
);
438 log_link_debug_errno(link
, r
, "Permanent MAC address not found for new device, continuing without: %m");
440 r
= ethtool_get_driver(&manager
->ethtool_fd
, link
->ifname
, &link
->driver
);
442 log_link_debug_errno(link
, r
, "Failed to get driver, continuing without: %m");
444 r
= sd_netlink_message_read_strv(message
, IFLA_PROP_LIST
, IFLA_ALT_IFNAME
, &link
->alternative_names
);
445 if (r
< 0 && r
!= -ENODATA
)
448 if (asprintf(&link
->state_file
, "/run/systemd/netif/links/%d", link
->ifindex
) < 0)
451 if (asprintf(&link
->lease_file
, "/run/systemd/netif/leases/%d", link
->ifindex
) < 0)
454 if (asprintf(&link
->lldp_file
, "/run/systemd/netif/lldp/%d", link
->ifindex
) < 0)
457 r
= hashmap_ensure_put(&manager
->links
, NULL
, INT_TO_PTR(link
->ifindex
), link
);
461 r
= link_update_flags(link
, message
, false);
465 *ret
= TAKE_PTR(link
);
470 void link_ntp_settings_clear(Link
*link
) {
471 link
->ntp
= strv_free(link
->ntp
);
474 void link_dns_settings_clear(Link
*link
) {
475 if (link
->n_dns
!= UINT_MAX
)
476 for (unsigned i
= 0; i
< link
->n_dns
; i
++)
477 in_addr_full_free(link
->dns
[i
]);
478 link
->dns
= mfree(link
->dns
);
479 link
->n_dns
= UINT_MAX
;
481 link
->search_domains
= ordered_set_free_free(link
->search_domains
);
482 link
->route_domains
= ordered_set_free_free(link
->route_domains
);
484 link
->dns_default_route
= -1;
485 link
->llmnr
= _RESOLVE_SUPPORT_INVALID
;
486 link
->mdns
= _RESOLVE_SUPPORT_INVALID
;
487 link
->dnssec_mode
= _DNSSEC_MODE_INVALID
;
488 link
->dns_over_tls_mode
= _DNS_OVER_TLS_MODE_INVALID
;
490 link
->dnssec_negative_trust_anchors
= set_free_free(link
->dnssec_negative_trust_anchors
);
493 static void link_free_engines(Link
*link
) {
497 link
->dhcp_server
= sd_dhcp_server_unref(link
->dhcp_server
);
498 link
->dhcp_client
= sd_dhcp_client_unref(link
->dhcp_client
);
499 link
->dhcp_lease
= sd_dhcp_lease_unref(link
->dhcp_lease
);
500 link
->dhcp_acd
= sd_ipv4acd_unref(link
->dhcp_acd
);
502 link
->lldp
= sd_lldp_unref(link
->lldp
);
503 link_lldp_emit_stop(link
);
507 link
->ipv4ll
= sd_ipv4ll_unref(link
->ipv4ll
);
508 link
->dhcp6_client
= sd_dhcp6_client_unref(link
->dhcp6_client
);
509 link
->dhcp6_lease
= sd_dhcp6_lease_unref(link
->dhcp6_lease
);
510 link
->ndisc
= sd_ndisc_unref(link
->ndisc
);
511 link
->radv
= sd_radv_unref(link
->radv
);
513 ipv4_dad_unref(link
);
516 static Link
*link_free(Link
*link
) {
519 link_ntp_settings_clear(link
);
520 link_dns_settings_clear(link
);
522 link
->routes
= set_free(link
->routes
);
523 link
->routes_foreign
= set_free(link
->routes_foreign
);
524 link
->dhcp_routes
= set_free(link
->dhcp_routes
);
525 link
->dhcp_routes_old
= set_free(link
->dhcp_routes_old
);
526 link
->dhcp6_routes
= set_free(link
->dhcp6_routes
);
527 link
->dhcp6_routes_old
= set_free(link
->dhcp6_routes_old
);
528 link
->dhcp6_pd_routes
= set_free(link
->dhcp6_pd_routes
);
529 link
->dhcp6_pd_routes_old
= set_free(link
->dhcp6_pd_routes_old
);
530 link
->ndisc_routes
= set_free(link
->ndisc_routes
);
532 link
->nexthops
= set_free(link
->nexthops
);
533 link
->nexthops_foreign
= set_free(link
->nexthops_foreign
);
535 link
->neighbors
= set_free(link
->neighbors
);
536 link
->neighbors_foreign
= set_free(link
->neighbors_foreign
);
538 link
->addresses
= set_free(link
->addresses
);
539 link
->addresses_foreign
= set_free(link
->addresses_foreign
);
540 link
->pool_addresses
= set_free(link
->pool_addresses
);
541 link
->static_addresses
= set_free(link
->static_addresses
);
542 link
->dhcp6_addresses
= set_free(link
->dhcp6_addresses
);
543 link
->dhcp6_addresses_old
= set_free(link
->dhcp6_addresses_old
);
544 link
->dhcp6_pd_addresses
= set_free(link
->dhcp6_pd_addresses
);
545 link
->dhcp6_pd_addresses_old
= set_free(link
->dhcp6_pd_addresses_old
);
546 link
->ndisc_addresses
= set_free(link
->ndisc_addresses
);
548 link_free_engines(link
);
551 strv_free(link
->alternative_names
);
556 unlink_and_free(link
->lease_file
);
557 unlink_and_free(link
->lldp_file
);
558 unlink_and_free(link
->state_file
);
560 sd_device_unref(link
->sd_device
);
562 hashmap_free(link
->bound_to_links
);
563 hashmap_free(link
->bound_by_links
);
565 set_free_with_destructor(link
->slaves
, link_unref
);
567 network_unref(link
->network
);
572 DEFINE_TRIVIAL_REF_UNREF_FUNC(Link
, link
, link_free
);
574 int link_get(Manager
*m
, int ifindex
, Link
**ret
) {
581 link
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
590 void link_set_state(Link
*link
, LinkState state
) {
593 if (link
->state
== state
)
596 log_link_debug(link
, "State changed: %s -> %s",
597 link_state_to_string(link
->state
),
598 link_state_to_string(state
));
602 link_send_changed(link
, "AdministrativeState", NULL
);
606 static void link_enter_unmanaged(Link
*link
) {
609 link_set_state(link
, LINK_STATE_UNMANAGED
);
612 int link_stop_engines(Link
*link
, bool may_keep_dhcp
) {
616 assert(link
->manager
);
617 assert(link
->manager
->event
);
619 bool keep_dhcp
= may_keep_dhcp
&&
621 (link
->manager
->restarting
||
622 FLAGS_SET(link
->network
->keep_configuration
, KEEP_CONFIGURATION_DHCP_ON_STOP
));
625 k
= sd_dhcp_client_stop(link
->dhcp_client
);
627 r
= log_link_warning_errno(link
, k
, "Could not stop DHCPv4 client: %m");
630 k
= sd_ipv4acd_stop(link
->dhcp_acd
);
632 r
= log_link_warning_errno(link
, k
, "Could not stop IPv4 ACD client for DHCPv4: %m");
634 k
= sd_dhcp_server_stop(link
->dhcp_server
);
636 r
= log_link_warning_errno(link
, k
, "Could not stop DHCPv4 server: %m");
638 k
= sd_lldp_stop(link
->lldp
);
640 r
= log_link_warning_errno(link
, k
, "Could not stop LLDP: %m");
642 k
= sd_ipv4ll_stop(link
->ipv4ll
);
644 r
= log_link_warning_errno(link
, k
, "Could not stop IPv4 link-local: %m");
646 k
= ipv4_dad_stop(link
);
648 r
= log_link_warning_errno(link
, k
, "Could not stop IPv4 ACD client: %m");
650 k
= sd_dhcp6_client_stop(link
->dhcp6_client
);
652 r
= log_link_warning_errno(link
, k
, "Could not stop DHCPv6 client: %m");
654 k
= dhcp6_pd_remove(link
);
656 r
= log_link_warning_errno(link
, k
, "Could not remove DHCPv6 PD addresses and routes: %m");
658 k
= sd_ndisc_stop(link
->ndisc
);
660 r
= log_link_warning_errno(link
, k
, "Could not stop IPv6 Router Discovery: %m");
662 k
= sd_radv_stop(link
->radv
);
664 r
= log_link_warning_errno(link
, k
, "Could not stop IPv6 Router Advertisement: %m");
666 link_lldp_emit_stop(link
);
670 void link_enter_failed(Link
*link
) {
673 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
676 log_link_warning(link
, "Failed");
678 link_set_state(link
, LINK_STATE_FAILED
);
680 (void) link_stop_engines(link
, false);
683 static int link_join_netdevs_after_configured(Link
*link
) {
687 HASHMAP_FOREACH(netdev
, link
->network
->stacked_netdevs
) {
688 if (netdev
->ifindex
> 0)
689 /* Assume already enslaved. */
692 if (netdev_get_create_type(netdev
) != NETDEV_CREATE_AFTER_CONFIGURED
)
695 log_struct(LOG_DEBUG
,
696 LOG_LINK_INTERFACE(link
),
697 LOG_NETDEV_INTERFACE(netdev
),
698 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", netdev
->ifname
));
700 r
= netdev_join(netdev
, link
, NULL
);
702 return log_struct_errno(LOG_WARNING
, r
,
703 LOG_LINK_INTERFACE(link
),
704 LOG_NETDEV_INTERFACE(netdev
),
705 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", netdev
->ifname
));
711 static void link_enter_configured(Link
*link
) {
713 assert(link
->network
);
715 if (link
->state
!= LINK_STATE_CONFIGURING
)
718 link_set_state(link
, LINK_STATE_CONFIGURED
);
720 (void) link_join_netdevs_after_configured(link
);
723 void link_check_ready(Link
*link
) {
728 if (link
->state
== LINK_STATE_CONFIGURED
)
731 if (link
->state
!= LINK_STATE_CONFIGURING
)
732 return (void) log_link_debug(link
, "%s(): link is in %s state.", __func__
, link_state_to_string(link
->state
));
737 if (!link
->addresses_configured
)
738 return (void) log_link_debug(link
, "%s(): static addresses are not configured.", __func__
);
740 if (!link
->neighbors_configured
)
741 return (void) log_link_debug(link
, "%s(): static neighbors are not configured.", __func__
);
743 SET_FOREACH(a
, link
->addresses
)
744 if (!address_is_ready(a
)) {
745 _cleanup_free_
char *str
= NULL
;
747 (void) in_addr_prefix_to_string(a
->family
, &a
->in_addr
, a
->prefixlen
, &str
);
748 return (void) log_link_debug(link
, "%s(): an address %s is not ready.", __func__
, strna(str
));
751 if (!link
->static_routes_configured
)
752 return (void) log_link_debug(link
, "%s(): static routes are not configured.", __func__
);
754 if (!link
->static_nexthops_configured
)
755 return (void) log_link_debug(link
, "%s(): static nexthops are not configured.", __func__
);
757 if (!link
->routing_policy_rules_configured
)
758 return (void) log_link_debug(link
, "%s(): static routing policy rules are not configured.", __func__
);
760 if (!link
->tc_configured
)
761 return (void) log_link_debug(link
, "%s(): traffic controls are not configured.", __func__
);
763 if (!link
->sr_iov_configured
)
764 return (void) log_link_debug(link
, "%s(): SR-IOV is not configured.", __func__
);
766 if (!link
->bridge_mdb_configured
)
767 return (void) log_link_debug(link
, "%s(): Bridge MDB is not configured.", __func__
);
769 if (link_has_carrier(link
) || !link
->network
->configure_without_carrier
) {
770 bool has_ndisc_address
= false;
773 if (link_ipv6ll_enabled(link
) && !in6_addr_is_set(&link
->ipv6ll_address
))
774 return (void) log_link_debug(link
, "%s(): IPv6LL is not configured yet.", __func__
);
776 SET_FOREACH(n
, link
->ndisc_addresses
)
778 has_ndisc_address
= true;
782 if ((link_dhcp4_enabled(link
) || link_dhcp6_enabled(link
) || link_ipv4ll_enabled(link
)) &&
783 !link
->dhcp_address
&& set_isempty(link
->dhcp6_addresses
) && !has_ndisc_address
&&
784 !link
->ipv4ll_address_configured
)
785 /* When DHCP[46] or IPv4LL is enabled, at least one address is acquired by them. */
786 return (void) log_link_debug(link
, "%s(): DHCP4, DHCP6 or IPv4LL is enabled but no dynamic address is assigned yet.", __func__
);
788 if (link_dhcp4_enabled(link
) || link_dhcp6_enabled(link
) || link_dhcp6_pd_is_enabled(link
) ||
789 link_ipv6_accept_ra_enabled(link
) || link_ipv4ll_enabled(link
)) {
790 if (!link
->dhcp4_configured
&&
791 !(link
->dhcp6_address_configured
&& link
->dhcp6_route_configured
) &&
792 !(link
->dhcp6_pd_address_configured
&& link
->dhcp6_pd_route_configured
) &&
793 !(link
->ndisc_addresses_configured
&& link
->ndisc_routes_configured
) &&
794 !link
->ipv4ll_address_configured
)
795 /* When DHCP[46], NDisc, or IPv4LL is enabled, at least one protocol must be finished. */
796 return (void) log_link_debug(link
, "%s(): dynamic addresses or routes are not configured.", __func__
);
798 log_link_debug(link
, "%s(): dhcp4:%s ipv4ll:%s dhcp6_addresses:%s dhcp_routes:%s dhcp_pd_addresses:%s dhcp_pd_routes:%s ndisc_addresses:%s ndisc_routes:%s",
800 yes_no(link
->dhcp4_configured
),
801 yes_no(link
->ipv4ll_address_configured
),
802 yes_no(link
->dhcp6_address_configured
),
803 yes_no(link
->dhcp6_route_configured
),
804 yes_no(link
->dhcp6_pd_address_configured
),
805 yes_no(link
->dhcp6_pd_route_configured
),
806 yes_no(link
->ndisc_addresses_configured
),
807 yes_no(link
->ndisc_routes_configured
));
811 link_enter_configured(link
);
814 static int link_set_static_configs(Link
*link
) {
818 assert(link
->network
);
819 assert(link
->state
!= _LINK_STATE_INVALID
);
821 /* Reset all *_configured flags we are configuring. */
822 link
->request_static_addresses
= false;
823 link
->addresses_configured
= false;
824 link
->addresses_ready
= false;
825 link
->neighbors_configured
= false;
826 link
->static_routes_configured
= false;
827 link
->static_nexthops_configured
= false;
828 link
->routing_policy_rules_configured
= false;
830 r
= link_set_bridge_fdb(link
);
834 r
= link_set_bridge_mdb(link
);
838 r
= link_set_neighbors(link
);
842 r
= link_set_addresses(link
);
846 r
= link_set_address_labels(link
);
850 /* now that we can figure out a default address for the dhcp server, start it */
851 r
= dhcp4_server_configure(link
);
858 static int link_configure_continue(Link
*link
);
860 static int link_mac_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
865 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
868 r
= sd_netlink_message_get_errno(m
);
870 log_link_message_warning_errno(link
, m
, r
, "Could not set MAC address, ignoring");
872 log_link_debug(link
, "Setting MAC address done.");
877 static int link_set_mac(Link
*link
) {
878 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
882 assert(link
->network
);
883 assert(link
->manager
);
884 assert(link
->manager
->rtnl
);
886 if (!link
->network
->mac
)
889 log_link_debug(link
, "Setting MAC address");
891 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
893 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
895 r
= sd_netlink_message_append_ether_addr(req
, IFLA_ADDRESS
, link
->network
->mac
);
897 return log_link_error_errno(link
, r
, "Could not set MAC address: %m");
899 r
= netlink_call_async(link
->manager
->rtnl
, NULL
, req
, link_mac_handler
,
900 link_netlink_destroy_callback
, link
);
902 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
909 static int link_nomaster_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
914 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
917 r
= sd_netlink_message_get_errno(m
);
919 log_link_message_warning_errno(link
, m
, r
, "Could not set nomaster, ignoring");
921 log_link_debug(link
, "Setting nomaster done.");
926 static int link_set_nomaster(Link
*link
) {
927 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
931 assert(link
->network
);
932 assert(link
->manager
);
933 assert(link
->manager
->rtnl
);
935 /* set it free if not enslaved with networkd */
936 if (link
->network
->batadv
|| link
->network
->bridge
|| link
->network
->bond
|| link
->network
->vrf
)
939 log_link_debug(link
, "Setting nomaster");
941 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
943 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
945 r
= sd_netlink_message_append_u32(req
, IFLA_MASTER
, 0);
947 return log_link_error_errno(link
, r
, "Could not append IFLA_MASTER attribute: %m");
949 r
= netlink_call_async(link
->manager
->rtnl
, NULL
, req
, link_nomaster_handler
,
950 link_netlink_destroy_callback
, link
);
952 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
959 static int set_mtu_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
964 assert(link
->ifname
);
966 link
->setting_mtu
= false;
968 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
971 r
= sd_netlink_message_get_errno(m
);
973 log_link_message_warning_errno(link
, m
, r
, "Could not set MTU, ignoring");
975 log_link_debug(link
, "Setting MTU done.");
977 if (link
->state
== LINK_STATE_INITIALIZED
) {
978 r
= link_configure_continue(link
);
980 link_enter_failed(link
);
986 int link_set_mtu(Link
*link
, uint32_t mtu
) {
987 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
991 assert(link
->manager
);
992 assert(link
->manager
->rtnl
);
994 if (mtu
== 0 || link
->setting_mtu
)
997 if (link
->mtu
== mtu
)
1000 log_link_debug(link
, "Setting MTU: %" PRIu32
, mtu
);
1002 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1004 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1006 /* IPv6 protocol requires a minimum MTU of IPV6_MTU_MIN(1280) bytes
1007 * on the interface. Bump up MTU bytes to IPV6_MTU_MIN. */
1008 if (link_ipv6_enabled(link
) && mtu
< IPV6_MIN_MTU
) {
1010 log_link_warning(link
, "Bumping MTU to " STRINGIFY(IPV6_MIN_MTU
) ", as "
1011 "IPv6 is requested and requires a minimum MTU of " STRINGIFY(IPV6_MIN_MTU
) " bytes");
1016 r
= sd_netlink_message_append_u32(req
, IFLA_MTU
, mtu
);
1018 return log_link_error_errno(link
, r
, "Could not append MTU: %m");
1020 r
= netlink_call_async(link
->manager
->rtnl
, NULL
, req
, set_mtu_handler
,
1021 link_netlink_destroy_callback
, link
);
1023 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1026 link
->setting_mtu
= true;
1031 static bool link_reduces_vlan_mtu(Link
*link
) {
1032 /* See netif_reduces_vlan_mtu() in kernel. */
1033 return streq_ptr(link
->kind
, "macsec");
1036 static uint32_t link_get_requested_mtu_by_stacked_netdevs(Link
*link
) {
1040 HASHMAP_FOREACH(dev
, link
->network
->stacked_netdevs
)
1041 if (dev
->kind
== NETDEV_KIND_VLAN
&& dev
->mtu
> 0)
1042 /* See vlan_dev_change_mtu() in kernel. */
1043 mtu
= MAX(mtu
, link_reduces_vlan_mtu(link
) ? dev
->mtu
+ 4 : dev
->mtu
);
1045 else if (dev
->kind
== NETDEV_KIND_MACVLAN
&& dev
->mtu
> mtu
)
1046 /* See macvlan_change_mtu() in kernel. */
1052 static int link_configure_mtu(Link
*link
) {
1056 assert(link
->network
);
1058 if (link
->network
->mtu
> 0)
1059 return link_set_mtu(link
, link
->network
->mtu
);
1061 mtu
= link_get_requested_mtu_by_stacked_netdevs(link
);
1062 if (link
->mtu
>= mtu
)
1065 log_link_notice(link
, "Bumping MTU bytes from %"PRIu32
" to %"PRIu32
" because of stacked device. "
1066 "If it is not desired, then please explicitly specify MTUBytes= setting.",
1069 return link_set_mtu(link
, mtu
);
1072 static int set_flags_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
1077 assert(link
->ifname
);
1079 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1082 r
= sd_netlink_message_get_errno(m
);
1084 log_link_message_warning_errno(link
, m
, r
, "Could not set link flags, ignoring");
1089 static int link_set_flags(Link
*link
) {
1090 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1091 unsigned ifi_change
= 0;
1092 unsigned ifi_flags
= 0;
1096 assert(link
->manager
);
1097 assert(link
->manager
->rtnl
);
1099 if (link
->flags
& IFF_LOOPBACK
)
1105 if (link
->network
->arp
< 0 && link
->network
->multicast
< 0 && link
->network
->allmulticast
< 0 &&
1106 link
->network
->promiscuous
< 0)
1109 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1111 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1113 if (link
->network
->arp
>= 0) {
1114 ifi_change
|= IFF_NOARP
;
1115 SET_FLAG(ifi_flags
, IFF_NOARP
, link
->network
->arp
== 0);
1118 if (link
->network
->multicast
>= 0) {
1119 ifi_change
|= IFF_MULTICAST
;
1120 SET_FLAG(ifi_flags
, IFF_MULTICAST
, link
->network
->multicast
);
1123 if (link
->network
->allmulticast
>= 0) {
1124 ifi_change
|= IFF_ALLMULTI
;
1125 SET_FLAG(ifi_flags
, IFF_ALLMULTI
, link
->network
->allmulticast
);
1128 if (link
->network
->promiscuous
>= 0) {
1129 ifi_change
|= IFF_PROMISC
;
1130 SET_FLAG(ifi_flags
, IFF_PROMISC
, link
->network
->promiscuous
);
1133 r
= sd_rtnl_message_link_set_flags(req
, ifi_flags
, ifi_change
);
1135 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1137 r
= netlink_call_async(link
->manager
->rtnl
, NULL
, req
, set_flags_handler
,
1138 link_netlink_destroy_callback
, link
);
1140 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1147 static int link_acquire_ipv6_conf(Link
*link
) {
1153 log_link_debug(link
, "Discovering IPv6 routers");
1155 r
= sd_ndisc_start(link
->ndisc
);
1156 if (r
< 0 && r
!= -EBUSY
)
1157 return log_link_warning_errno(link
, r
, "Could not start IPv6 Router Discovery: %m");
1162 assert(in6_addr_is_link_local(&link
->ipv6ll_address
));
1164 log_link_debug(link
, "Starting IPv6 Router Advertisements");
1166 r
= radv_emit_dns(link
);
1168 return log_link_warning_errno(link
, r
, "Failed to configure DNS or Domains in IPv6 Router Advertisement: %m");
1170 r
= sd_radv_start(link
->radv
);
1171 if (r
< 0 && r
!= -EBUSY
)
1172 return log_link_warning_errno(link
, r
, "Could not start IPv6 Router Advertisement: %m");
1175 if (link_dhcp6_enabled(link
) && IN_SET(link
->network
->dhcp6_without_ra
,
1176 DHCP6_CLIENT_START_MODE_INFORMATION_REQUEST
,
1177 DHCP6_CLIENT_START_MODE_SOLICIT
)) {
1178 assert(link
->dhcp6_client
);
1179 assert(in6_addr_is_link_local(&link
->ipv6ll_address
));
1181 r
= dhcp6_request_address(link
, link
->network
->dhcp6_without_ra
== DHCP6_CLIENT_START_MODE_INFORMATION_REQUEST
);
1182 if (r
< 0 && r
!= -EBUSY
)
1183 return log_link_warning_errno(link
, r
, "Could not acquire DHCPv6 lease: %m");
1185 log_link_debug(link
, "Acquiring DHCPv6 lease");
1188 r
= dhcp6_request_prefix_delegation(link
);
1190 return log_link_warning_errno(link
, r
, "Failed to request DHCPv6 prefix delegation: %m");
1195 static int link_acquire_ipv4_conf(Link
*link
) {
1199 assert(link
->manager
);
1200 assert(link
->manager
->event
);
1202 if (link
->dhcp_client
) {
1203 log_link_debug(link
, "Acquiring DHCPv4 lease");
1205 r
= sd_dhcp_client_start(link
->dhcp_client
);
1207 return log_link_warning_errno(link
, r
, "Could not acquire DHCPv4 lease: %m");
1209 } else if (link
->ipv4ll
) {
1210 log_link_debug(link
, "Acquiring IPv4 link-local address");
1212 r
= sd_ipv4ll_start(link
->ipv4ll
);
1214 return log_link_warning_errno(link
, r
, "Could not acquire IPv4 link-local address: %m");
1220 static int link_acquire_conf(Link
*link
) {
1225 r
= link_acquire_ipv4_conf(link
);
1229 if (in6_addr_is_set(&link
->ipv6ll_address
)) {
1230 r
= link_acquire_ipv6_conf(link
);
1235 r
= link_lldp_emit_start(link
);
1237 return log_link_warning_errno(link
, r
, "Failed to start LLDP transmission: %m");
1242 bool link_has_carrier(Link
*link
) {
1243 /* see Documentation/networking/operstates.txt in the kernel sources */
1245 if (link
->kernel_operstate
== IF_OPER_UP
)
1248 if (link
->kernel_operstate
== IF_OPER_UNKNOWN
)
1249 /* operstate may not be implemented, so fall back to flags */
1250 if (FLAGS_SET(link
->flags
, IFF_LOWER_UP
| IFF_RUNNING
) &&
1251 !FLAGS_SET(link
->flags
, IFF_DORMANT
))
1257 static int link_address_genmode_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
1262 link
->setting_genmode
= false;
1264 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1267 r
= sd_netlink_message_get_errno(m
);
1269 log_link_message_warning_errno(link
, m
, r
, "Could not set address genmode for interface, ignoring");
1271 log_link_debug(link
, "Setting address genmode done.");
1273 if (link
->state
== LINK_STATE_INITIALIZED
) {
1274 r
= link_configure_continue(link
);
1276 link_enter_failed(link
);
1282 static int link_configure_addrgen_mode(Link
*link
) {
1283 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1284 uint8_t ipv6ll_mode
;
1288 assert(link
->network
);
1289 assert(link
->manager
);
1290 assert(link
->manager
->rtnl
);
1292 if (!socket_ipv6_is_supported() || link
->setting_genmode
)
1295 log_link_debug(link
, "Setting address genmode for link");
1297 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1299 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1301 r
= sd_netlink_message_open_container(req
, IFLA_AF_SPEC
);
1303 return log_link_error_errno(link
, r
, "Could not open IFLA_AF_SPEC container: %m");
1305 r
= sd_netlink_message_open_container(req
, AF_INET6
);
1307 return log_link_error_errno(link
, r
, "Could not open AF_INET6 container: %m");
1309 if (!link_ipv6ll_enabled(link
))
1310 ipv6ll_mode
= IN6_ADDR_GEN_MODE_NONE
;
1311 else if (link
->network
->ipv6ll_address_gen_mode
< 0) {
1312 r
= sysctl_read_ip_property(AF_INET6
, link
->ifname
, "stable_secret", NULL
);
1314 /* The file may not exist. And even if it exists, when stable_secret is unset,
1315 * reading the file fails with EIO. */
1316 log_link_debug_errno(link
, r
, "Failed to read sysctl property stable_secret: %m");
1318 ipv6ll_mode
= IN6_ADDR_GEN_MODE_EUI64
;
1320 ipv6ll_mode
= IN6_ADDR_GEN_MODE_STABLE_PRIVACY
;
1322 ipv6ll_mode
= link
->network
->ipv6ll_address_gen_mode
;
1324 r
= sd_netlink_message_append_u8(req
, IFLA_INET6_ADDR_GEN_MODE
, ipv6ll_mode
);
1326 return log_link_error_errno(link
, r
, "Could not append IFLA_INET6_ADDR_GEN_MODE: %m");
1328 r
= sd_netlink_message_close_container(req
);
1330 return log_link_error_errno(link
, r
, "Could not close AF_INET6 container: %m");
1332 r
= sd_netlink_message_close_container(req
);
1334 return log_link_error_errno(link
, r
, "Could not close IFLA_AF_SPEC container: %m");
1336 r
= netlink_call_async(link
->manager
->rtnl
, NULL
, req
, link_address_genmode_handler
,
1337 link_netlink_destroy_callback
, link
);
1339 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1342 link
->setting_genmode
= true;
1347 static int link_up_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
1352 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1355 r
= sd_netlink_message_get_errno(m
);
1357 /* we warn but don't fail the link, as it may be brought up later */
1358 log_link_message_warning_errno(link
, m
, r
, "Could not bring up interface");
1363 static int link_up(Link
*link
) {
1364 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1368 assert(link
->network
);
1369 assert(link
->manager
);
1370 assert(link
->manager
->rtnl
);
1372 log_link_debug(link
, "Bringing link up");
1374 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1376 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1378 r
= sd_rtnl_message_link_set_flags(req
, IFF_UP
, IFF_UP
);
1380 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1382 r
= netlink_call_async(link
->manager
->rtnl
, NULL
, req
, link_up_handler
,
1383 link_netlink_destroy_callback
, link
);
1385 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1392 static int link_down_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
1397 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1400 r
= sd_netlink_message_get_errno(m
);
1402 log_link_message_warning_errno(link
, m
, r
, "Could not bring down interface");
1407 int link_down(Link
*link
, link_netlink_message_handler_t callback
) {
1408 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1412 assert(link
->manager
);
1413 assert(link
->manager
->rtnl
);
1415 log_link_debug(link
, "Bringing link down");
1417 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
,
1418 RTM_SETLINK
, link
->ifindex
);
1420 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1422 r
= sd_rtnl_message_link_set_flags(req
, 0, IFF_UP
);
1424 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1426 r
= netlink_call_async(link
->manager
->rtnl
, NULL
, req
,
1427 callback
?: link_down_handler
,
1428 link_netlink_destroy_callback
, link
);
1430 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1437 static int link_group_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
1442 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1445 r
= sd_netlink_message_get_errno(m
);
1447 log_link_message_warning_errno(link
, m
, r
, "Could not set group for the interface");
1452 static int link_set_group(Link
*link
) {
1453 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1457 assert(link
->network
);
1458 assert(link
->manager
);
1459 assert(link
->manager
->rtnl
);
1461 if (link
->network
->group
<= 0)
1464 log_link_debug(link
, "Setting group");
1466 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1468 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1470 r
= sd_netlink_message_append_u32(req
, IFLA_GROUP
, link
->network
->group
);
1472 return log_link_error_errno(link
, r
, "Could not set link group: %m");
1474 r
= netlink_call_async(link
->manager
->rtnl
, NULL
, req
, link_group_handler
,
1475 link_netlink_destroy_callback
, link
);
1477 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1484 static int link_handle_bound_to_list(Link
*link
) {
1487 bool required_up
= false;
1488 bool link_is_up
= false;
1492 if (hashmap_isempty(link
->bound_to_links
))
1495 if (link
->flags
& IFF_UP
)
1498 HASHMAP_FOREACH (l
, link
->bound_to_links
)
1499 if (link_has_carrier(l
)) {
1504 if (!required_up
&& link_is_up
) {
1505 r
= link_down(link
, NULL
);
1508 } else if (required_up
&& !link_is_up
) {
1517 static int link_handle_bound_by_list(Link
*link
) {
1523 if (hashmap_isempty(link
->bound_by_links
))
1526 HASHMAP_FOREACH (l
, link
->bound_by_links
) {
1527 r
= link_handle_bound_to_list(l
);
1535 static int link_put_carrier(Link
*link
, Link
*carrier
, Hashmap
**h
) {
1541 if (link
== carrier
)
1544 if (hashmap_get(*h
, INT_TO_PTR(carrier
->ifindex
)))
1547 r
= hashmap_ensure_put(h
, NULL
, INT_TO_PTR(carrier
->ifindex
), carrier
);
1556 static int link_new_bound_by_list(Link
*link
) {
1562 assert(link
->manager
);
1566 HASHMAP_FOREACH(carrier
, m
->links
) {
1567 if (!carrier
->network
)
1570 if (strv_isempty(carrier
->network
->bind_carrier
))
1573 if (strv_fnmatch(carrier
->network
->bind_carrier
, link
->ifname
)) {
1574 r
= link_put_carrier(link
, carrier
, &link
->bound_by_links
);
1580 HASHMAP_FOREACH(carrier
, link
->bound_by_links
) {
1581 r
= link_put_carrier(carrier
, link
, &carrier
->bound_to_links
);
1589 static int link_new_bound_to_list(Link
*link
) {
1595 assert(link
->manager
);
1600 if (strv_isempty(link
->network
->bind_carrier
))
1605 HASHMAP_FOREACH (carrier
, m
->links
) {
1606 if (strv_fnmatch(link
->network
->bind_carrier
, carrier
->ifname
)) {
1607 r
= link_put_carrier(link
, carrier
, &link
->bound_to_links
);
1613 HASHMAP_FOREACH (carrier
, link
->bound_to_links
) {
1614 r
= link_put_carrier(carrier
, link
, &carrier
->bound_by_links
);
1622 static int link_new_carrier_maps(Link
*link
) {
1625 r
= link_new_bound_by_list(link
);
1629 r
= link_handle_bound_by_list(link
);
1633 r
= link_new_bound_to_list(link
);
1637 r
= link_handle_bound_to_list(link
);
1644 static void link_free_bound_to_list(Link
*link
) {
1645 bool updated
= false;
1650 while ((bound_to
= hashmap_steal_first(link
->bound_to_links
))) {
1653 if (hashmap_remove(bound_to
->bound_by_links
, INT_TO_PTR(link
->ifindex
)))
1654 link_dirty(bound_to
);
1663 static void link_free_bound_by_list(Link
*link
) {
1664 bool updated
= false;
1669 while ((bound_by
= hashmap_steal_first(link
->bound_by_links
))) {
1672 if (hashmap_remove(bound_by
->bound_to_links
, INT_TO_PTR(link
->ifindex
))) {
1673 link_dirty(bound_by
);
1674 link_handle_bound_to_list(bound_by
);
1684 static void link_free_carrier_maps(Link
*link
) {
1687 link_free_bound_to_list(link
);
1688 link_free_bound_by_list(link
);
1693 static int link_append_to_master(Link
*link
, NetDev
*netdev
) {
1700 r
= link_get(link
->manager
, netdev
->ifindex
, &master
);
1704 r
= set_ensure_put(&master
->slaves
, NULL
, link
);
1712 static void link_drop_from_master(Link
*link
, NetDev
*netdev
) {
1717 if (!link
->manager
|| !netdev
)
1720 if (link_get(link
->manager
, netdev
->ifindex
, &master
) < 0)
1723 link_unref(set_remove(master
->slaves
, link
));
1726 static void link_detach_from_manager(Link
*link
) {
1727 if (!link
|| !link
->manager
)
1730 link_unref(set_remove(link
->manager
->links_requesting_uuid
, link
));
1733 /* The following must be called at last. */
1734 assert_se(hashmap_remove(link
->manager
->links
, INT_TO_PTR(link
->ifindex
)) == link
);
1738 static void link_drop(Link
*link
) {
1739 if (!link
|| link
->state
== LINK_STATE_LINGER
)
1742 link_set_state(link
, LINK_STATE_LINGER
);
1744 link_free_carrier_maps(link
);
1746 if (link
->network
) {
1747 link_drop_from_master(link
, link
->network
->batadv
);
1748 link_drop_from_master(link
, link
->network
->bridge
);
1749 link_drop_from_master(link
, link
->network
->bond
);
1752 log_link_debug(link
, "Link removed");
1754 (void) unlink(link
->state_file
);
1755 link_detach_from_manager(link
);
1758 static int link_joined(Link
*link
) {
1762 assert(link
->network
);
1764 switch (link
->network
->activation_policy
) {
1765 case ACTIVATION_POLICY_BOUND
:
1766 r
= link_handle_bound_to_list(link
);
1770 case ACTIVATION_POLICY_UP
:
1771 if (link
->activated
)
1774 case ACTIVATION_POLICY_ALWAYS_UP
:
1777 link_enter_failed(link
);
1781 case ACTIVATION_POLICY_DOWN
:
1782 if (link
->activated
)
1785 case ACTIVATION_POLICY_ALWAYS_DOWN
:
1786 r
= link_down(link
, NULL
);
1788 link_enter_failed(link
);
1795 link
->activated
= true;
1797 if (link
->network
->bridge
) {
1798 r
= link_set_bridge(link
);
1800 log_link_error_errno(link
, r
, "Could not set bridge message: %m");
1802 r
= link_append_to_master(link
, link
->network
->bridge
);
1804 log_link_error_errno(link
, r
, "Failed to add to bridge master's slave list: %m");
1807 if (link
->network
->bond
) {
1808 r
= link_set_bond(link
);
1810 log_link_error_errno(link
, r
, "Could not set bond message: %m");
1812 r
= link_append_to_master(link
, link
->network
->bond
);
1814 log_link_error_errno(link
, r
, "Failed to add to bond master's slave list: %m");
1817 r
= link_set_bridge_vlan(link
);
1819 log_link_error_errno(link
, r
, "Could not set bridge vlan: %m");
1821 /* Skip setting up addresses until it gets carrier,
1822 or it would try to set addresses twice,
1823 which is bad for non-idempotent steps. */
1824 if (!link_has_carrier(link
) && !link
->network
->configure_without_carrier
)
1827 link_set_state(link
, LINK_STATE_CONFIGURING
);
1829 r
= link_acquire_conf(link
);
1833 return link_set_static_configs(link
);
1836 static int netdev_join_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
1840 assert(link
->network
);
1841 assert(link
->enslaving
> 0);
1845 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1848 r
= sd_netlink_message_get_errno(m
);
1849 if (r
< 0 && r
!= -EEXIST
) {
1850 log_link_message_warning_errno(link
, m
, r
, "Could not join netdev");
1851 link_enter_failed(link
);
1855 log_link_debug(link
, "Joined netdev");
1857 if (link
->enslaving
== 0) {
1858 r
= link_joined(link
);
1860 link_enter_failed(link
);
1866 static int link_enter_join_netdev(Link
*link
) {
1871 assert(link
->network
);
1872 assert(link
->state
== LINK_STATE_INITIALIZED
);
1874 link_set_state(link
, LINK_STATE_CONFIGURING
);
1876 link
->enslaving
= 0;
1878 if (link
->network
->bond
) {
1879 if (link
->network
->bond
->state
== NETDEV_STATE_READY
&&
1880 link
->network
->bond
->ifindex
== link
->master_ifindex
)
1881 return link_joined(link
);
1883 log_struct(LOG_DEBUG
,
1884 LOG_LINK_INTERFACE(link
),
1885 LOG_NETDEV_INTERFACE(link
->network
->bond
),
1886 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->bond
->ifname
));
1890 r
= netdev_join(link
->network
->bond
, link
, netdev_join_handler
);
1892 log_struct_errno(LOG_WARNING
, r
,
1893 LOG_LINK_INTERFACE(link
),
1894 LOG_NETDEV_INTERFACE(link
->network
->bond
),
1895 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->bond
->ifname
));
1896 link_enter_failed(link
);
1901 if (link
->network
->batadv
) {
1902 log_struct(LOG_DEBUG
,
1903 LOG_LINK_INTERFACE(link
),
1904 LOG_NETDEV_INTERFACE(link
->network
->batadv
),
1905 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->batadv
->ifname
));
1909 r
= netdev_join(link
->network
->batadv
, link
, netdev_join_handler
);
1911 log_struct_errno(LOG_WARNING
, r
,
1912 LOG_LINK_INTERFACE(link
),
1913 LOG_NETDEV_INTERFACE(link
->network
->batadv
),
1914 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->batadv
->ifname
));
1915 link_enter_failed(link
);
1920 if (link
->network
->bridge
) {
1921 log_struct(LOG_DEBUG
,
1922 LOG_LINK_INTERFACE(link
),
1923 LOG_NETDEV_INTERFACE(link
->network
->bridge
),
1924 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->bridge
->ifname
));
1928 r
= netdev_join(link
->network
->bridge
, link
, netdev_join_handler
);
1930 log_struct_errno(LOG_WARNING
, r
,
1931 LOG_LINK_INTERFACE(link
),
1932 LOG_NETDEV_INTERFACE(link
->network
->bridge
),
1933 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->bridge
->ifname
));
1934 link_enter_failed(link
);
1939 if (link
->network
->vrf
) {
1940 log_struct(LOG_DEBUG
,
1941 LOG_LINK_INTERFACE(link
),
1942 LOG_NETDEV_INTERFACE(link
->network
->vrf
),
1943 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->vrf
->ifname
));
1947 r
= netdev_join(link
->network
->vrf
, link
, netdev_join_handler
);
1949 log_struct_errno(LOG_WARNING
, r
,
1950 LOG_LINK_INTERFACE(link
),
1951 LOG_NETDEV_INTERFACE(link
->network
->vrf
),
1952 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->vrf
->ifname
));
1953 link_enter_failed(link
);
1958 HASHMAP_FOREACH(netdev
, link
->network
->stacked_netdevs
) {
1960 if (netdev
->ifindex
> 0)
1961 /* Assume already enslaved. */
1964 if (netdev_get_create_type(netdev
) != NETDEV_CREATE_STACKED
)
1967 log_struct(LOG_DEBUG
,
1968 LOG_LINK_INTERFACE(link
),
1969 LOG_NETDEV_INTERFACE(netdev
),
1970 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", netdev
->ifname
));
1974 r
= netdev_join(netdev
, link
, netdev_join_handler
);
1976 log_struct_errno(LOG_WARNING
, r
,
1977 LOG_LINK_INTERFACE(link
),
1978 LOG_NETDEV_INTERFACE(netdev
),
1979 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", netdev
->ifname
));
1980 link_enter_failed(link
);
1985 if (link
->enslaving
== 0)
1986 return link_joined(link
);
1991 static int link_drop_foreign_config(Link
*link
) {
1995 assert(link
->manager
);
1997 r
= link_drop_foreign_addresses(link
);
1999 k
= link_drop_foreign_neighbors(link
);
2000 if (k
< 0 && r
>= 0)
2003 k
= link_drop_foreign_routes(link
);
2004 if (k
< 0 && r
>= 0)
2007 k
= link_drop_foreign_nexthops(link
);
2008 if (k
< 0 && r
>= 0)
2011 k
= manager_drop_foreign_routing_policy_rules(link
->manager
);
2012 if (k
< 0 && r
>= 0)
2018 static int link_drop_config(Link
*link
) {
2022 assert(link
->manager
);
2024 r
= link_drop_addresses(link
);
2026 k
= link_drop_neighbors(link
);
2027 if (k
< 0 && r
>= 0)
2030 k
= link_drop_routes(link
);
2031 if (k
< 0 && r
>= 0)
2034 k
= link_drop_nexthops(link
);
2035 if (k
< 0 && r
>= 0)
2038 k
= manager_drop_routing_policy_rules(link
->manager
, link
);
2039 if (k
< 0 && r
>= 0)
2047 int link_configure(Link
*link
) {
2051 assert(link
->network
);
2052 assert(link
->state
== LINK_STATE_INITIALIZED
);
2054 r
= link_configure_traffic_control(link
);
2058 r
= link_configure_sr_iov(link
);
2062 if (link
->iftype
== ARPHRD_CAN
)
2063 return link_configure_can(link
);
2065 r
= link_set_sysctl(link
);
2069 r
= link_set_mac(link
);
2073 r
= link_set_nomaster(link
);
2077 r
= link_set_flags(link
);
2081 r
= link_set_group(link
);
2085 r
= ipv4ll_configure(link
);
2089 r
= dhcp4_configure(link
);
2093 r
= dhcp6_configure(link
);
2097 r
= ndisc_configure(link
);
2101 r
= radv_configure(link
);
2105 r
= link_lldp_rx_configure(link
);
2109 r
= link_configure_mtu(link
);
2113 r
= link_configure_addrgen_mode(link
);
2117 return link_configure_continue(link
);
2120 /* The configuration continues in this separate function, instead of
2121 * including this in the above link_configure() function, for two
2123 * 1) some devices reset the link when the mtu is set, which caused
2124 * an infinite loop here in networkd; see:
2125 * https://github.com/systemd/systemd/issues/6593
2126 * https://github.com/systemd/systemd/issues/9831
2127 * 2) if ipv6ll is disabled, then bringing the interface up must be
2128 * delayed until after we get confirmation from the kernel that
2129 * the addr_gen_mode parameter has been set (via netlink), see:
2130 * https://github.com/systemd/systemd/issues/13882
2132 static int link_configure_continue(Link
*link
) {
2136 assert(link
->network
);
2137 assert(link
->state
== LINK_STATE_INITIALIZED
);
2139 if (link
->setting_mtu
|| link
->setting_genmode
)
2142 /* Drop foreign config, but ignore loopback or critical devices.
2143 * We do not want to remove loopback address or addresses used for root NFS. */
2144 if (!(link
->flags
& IFF_LOOPBACK
) &&
2145 link
->network
->keep_configuration
!= KEEP_CONFIGURATION_YES
) {
2146 r
= link_drop_foreign_config(link
);
2151 /* The kernel resets ipv6 mtu after changing device mtu;
2152 * we must set this here, after we've set device mtu */
2153 r
= link_set_ipv6_mtu(link
);
2155 log_link_warning_errno(link
, r
, "Cannot set IPv6 MTU for interface, ignoring: %m");
2157 return link_enter_join_netdev(link
);
2160 static int link_reconfigure_internal(Link
*link
, sd_netlink_message
*m
, bool force
) {
2161 _cleanup_strv_free_
char **s
= NULL
;
2167 r
= sd_netlink_message_get_errno(m
);
2171 r
= sd_netlink_message_read_strv(m
, IFLA_PROP_LIST
, IFLA_ALT_IFNAME
, &s
);
2172 if (r
< 0 && r
!= -ENODATA
)
2175 strv_free_and_replace(link
->alternative_names
, s
);
2177 r
= network_get(link
->manager
, link
->iftype
, link
->sd_device
,
2178 link
->ifname
, link
->alternative_names
, link
->driver
,
2179 &link
->hw_addr
.addr
.ether
, &link
->permanent_mac
,
2180 link
->wlan_iftype
, link
->ssid
, &link
->bssid
, &network
);
2182 link_enter_unmanaged(link
);
2184 } else if (r
== 0 && network
->unmanaged
) {
2185 link_enter_unmanaged(link
);
2190 if (link
->network
== network
&& !force
)
2193 log_link_info(link
, "Re-configuring with %s", network
->filename
);
2195 /* Dropping old .network file */
2196 r
= link_stop_engines(link
, false);
2200 r
= link_drop_config(link
);
2204 if (!IN_SET(link
->state
, LINK_STATE_UNMANAGED
, LINK_STATE_PENDING
, LINK_STATE_INITIALIZED
)) {
2205 log_link_debug(link
, "State is %s, dropping config", link_state_to_string(link
->state
));
2206 r
= link_drop_foreign_config(link
);
2211 link_free_carrier_maps(link
);
2212 link_free_engines(link
);
2213 link
->network
= network_unref(link
->network
);
2214 link_unref(set_remove(link
->manager
->links_requesting_uuid
, link
));
2216 /* Then, apply new .network file */
2217 link
->network
= network_ref(network
);
2220 r
= link_new_carrier_maps(link
);
2224 link_set_state(link
, LINK_STATE_INITIALIZED
);
2225 link
->activated
= false;
2227 /* link_configure_duid() returns 0 if it requests product UUID. In that case,
2228 * link_configure() is called later asynchronously. */
2229 r
= link_configure_duid(link
);
2233 r
= link_configure(link
);
2240 static int link_reconfigure_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
2243 r
= link_reconfigure_internal(link
, m
, false);
2245 link_enter_failed(link
);
2250 static int link_force_reconfigure_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
2253 r
= link_reconfigure_internal(link
, m
, true);
2255 link_enter_failed(link
);
2260 int link_reconfigure(Link
*link
, bool force
) {
2261 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
2264 /* When link in pending or initialized state, then link_configure() will be called. To prevent
2265 * the function from being called multiple times simultaneously, refuse to reconfigure the
2266 * interface in these cases. */
2267 if (IN_SET(link
->state
, LINK_STATE_PENDING
, LINK_STATE_INITIALIZED
, LINK_STATE_LINGER
))
2268 return 0; /* 0 means no-op. */
2270 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_GETLINK
,
2275 r
= netlink_call_async(link
->manager
->rtnl
, NULL
, req
,
2276 force
? link_force_reconfigure_handler
: link_reconfigure_handler
,
2277 link_netlink_destroy_callback
, link
);
2283 return 1; /* 1 means the interface will be reconfigured. */
2286 static int link_initialized_and_synced(Link
*link
) {
2291 assert(link
->ifname
);
2292 assert(link
->manager
);
2294 /* We may get called either from the asynchronous netlink callback,
2295 * or directly for link_add() if running in a container. See link_add(). */
2296 if (!IN_SET(link
->state
, LINK_STATE_PENDING
, LINK_STATE_INITIALIZED
))
2299 log_link_debug(link
, "Link state is up-to-date");
2300 link_set_state(link
, LINK_STATE_INITIALIZED
);
2302 r
= link_new_bound_by_list(link
);
2306 r
= link_handle_bound_by_list(link
);
2310 if (!link
->network
) {
2311 r
= wifi_get_info(link
);
2315 r
= network_get(link
->manager
, link
->iftype
, link
->sd_device
,
2316 link
->ifname
, link
->alternative_names
, link
->driver
,
2317 &link
->hw_addr
.addr
.ether
, &link
->permanent_mac
,
2318 link
->wlan_iftype
, link
->ssid
, &link
->bssid
, &network
);
2320 link_enter_unmanaged(link
);
2322 } else if (r
== 0 && network
->unmanaged
) {
2323 link_enter_unmanaged(link
);
2328 if (link
->flags
& IFF_LOOPBACK
) {
2329 if (network
->link_local
!= ADDRESS_FAMILY_NO
)
2330 log_link_debug(link
, "Ignoring link-local autoconfiguration for loopback link");
2332 if (network
->dhcp
!= ADDRESS_FAMILY_NO
)
2333 log_link_debug(link
, "Ignoring DHCP clients for loopback link");
2335 if (network
->dhcp_server
)
2336 log_link_debug(link
, "Ignoring DHCP server for loopback link");
2339 link
->network
= network_ref(network
);
2343 r
= link_new_bound_to_list(link
);
2347 /* link_configure_duid() returns 0 if it requests product UUID. In that case,
2348 * link_configure() is called later asynchronously. */
2349 r
= link_configure_duid(link
);
2353 r
= link_configure(link
);
2360 static int link_initialized_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Link
*link
) {
2361 _cleanup_strv_free_
char **s
= NULL
;
2364 r
= sd_netlink_message_get_errno(m
);
2366 log_link_warning_errno(link
, r
, "Failed to wait for the interface to be initialized: %m");
2367 link_enter_failed(link
);
2371 r
= sd_netlink_message_read_strv(m
, IFLA_PROP_LIST
, IFLA_ALT_IFNAME
, &s
);
2372 if (r
< 0 && r
!= -ENODATA
) {
2373 link_enter_failed(link
);
2377 strv_free_and_replace(link
->alternative_names
, s
);
2379 r
= link_initialized_and_synced(link
);
2381 link_enter_failed(link
);
2385 static int link_initialized(Link
*link
, sd_device
*device
) {
2386 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
2390 assert(link
->manager
);
2391 assert(link
->manager
->rtnl
);
2394 if (link
->state
!= LINK_STATE_PENDING
)
2397 if (link
->sd_device
)
2400 log_link_debug(link
, "udev initialized link");
2401 link_set_state(link
, LINK_STATE_INITIALIZED
);
2403 link
->sd_device
= sd_device_ref(device
);
2405 /* udev has initialized the link, but we don't know if we have yet
2406 * processed the NEWLINK messages with the latest state. Do a GETLINK,
2407 * when it returns we know that the pending NEWLINKs have already been
2408 * processed and that we are up-to-date */
2410 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_GETLINK
,
2415 r
= netlink_call_async(link
->manager
->rtnl
, NULL
, req
, link_initialized_handler
,
2416 link_netlink_destroy_callback
, link
);
2425 static int link_add(Manager
*m
, sd_netlink_message
*message
, Link
**ret
) {
2426 _cleanup_(sd_device_unrefp
) sd_device
*device
= NULL
;
2427 char ifindex_str
[2 + DECIMAL_STR_MAX(int)];
2436 r
= link_new(m
, message
, ret
);
2442 log_link_debug(link
, "Link %d added", link
->ifindex
);
2444 if (path_is_read_only_fs("/sys") <= 0) {
2445 /* udev should be around */
2446 sprintf(ifindex_str
, "n%d", link
->ifindex
);
2447 r
= sd_device_new_from_device_id(&device
, ifindex_str
);
2449 log_link_warning_errno(link
, r
, "Could not find device, waiting for device initialization: %m");
2453 r
= sd_device_get_is_initialized(device
);
2455 log_link_warning_errno(link
, r
, "Could not determine whether the device is initialized: %m");
2460 log_link_debug(link
, "link pending udev initialization...");
2464 r
= device_is_renaming(device
);
2466 log_link_warning_errno(link
, r
, "Failed to determine the device is being renamed: %m");
2470 log_link_debug(link
, "Interface is being renamed, pending initialization.");
2474 r
= link_initialized(link
, device
);
2478 r
= link_initialized_and_synced(link
);
2485 link_enter_failed(link
);
2489 int link_ipv6ll_gained(Link
*link
, const struct in6_addr
*address
) {
2494 log_link_info(link
, "Gained IPv6LL");
2496 link
->ipv6ll_address
= *address
;
2497 link_check_ready(link
);
2499 if (IN_SET(link
->state
, LINK_STATE_CONFIGURING
, LINK_STATE_CONFIGURED
)) {
2500 r
= link_acquire_ipv6_conf(link
);
2502 link_enter_failed(link
);
2510 int manager_udev_process_link(sd_device_monitor
*monitor
, sd_device
*device
, void *userdata
) {
2511 sd_device_action_t action
;
2512 Manager
*m
= userdata
;
2519 r
= sd_device_get_action(device
, &action
);
2521 log_device_debug_errno(device
, r
, "Failed to get udev action, ignoring device: %m");
2525 /* Ignore the "remove" uevent — let's remove a device only if rtnetlink says so. All other uevents
2526 * are "positive" events in some form, i.e. inform us about a changed or new network interface, that
2527 * still exists — and we are interested in that. */
2528 if (action
== SD_DEVICE_REMOVE
)
2531 r
= sd_device_get_ifindex(device
, &ifindex
);
2533 log_device_debug_errno(device
, r
, "Ignoring udev %s event for device without ifindex or with invalid ifindex: %m",
2534 device_action_to_string(action
));
2538 r
= device_is_renaming(device
);
2540 log_device_error_errno(device
, r
, "Failed to determine the device is renamed or not, ignoring '%s' uevent: %m",
2541 device_action_to_string(action
));
2545 log_device_debug(device
, "Interface is under renaming, wait for the interface to be renamed.");
2549 r
= link_get(m
, ifindex
, &link
);
2552 log_debug_errno(r
, "Failed to get link from ifindex %i, ignoring: %m", ifindex
);
2556 (void) link_initialized(link
, device
);
2561 static int link_carrier_gained(Link
*link
) {
2566 r
= wifi_get_info(link
);
2570 r
= link_reconfigure(link
, false);
2572 link_enter_failed(link
);
2577 if (IN_SET(link
->state
, LINK_STATE_CONFIGURING
, LINK_STATE_CONFIGURED
)) {
2578 r
= link_acquire_conf(link
);
2580 link_enter_failed(link
);
2584 link_set_state(link
, LINK_STATE_CONFIGURING
);
2585 r
= link_set_static_configs(link
);
2590 r
= link_handle_bound_by_list(link
);
2594 if (!link
->bridge_mdb_configured
) {
2595 r
= link_set_bridge_mdb(link
);
2600 if (streq_ptr(link
->kind
, "bridge")) {
2603 SET_FOREACH(slave
, link
->slaves
) {
2604 if (slave
->bridge_mdb_configured
)
2607 r
= link_set_bridge_mdb(slave
);
2609 link_enter_failed(slave
);
2616 static int link_carrier_lost(Link
*link
) {
2621 if (link
->network
&& link
->network
->ignore_carrier_loss
)
2624 /* Some devices reset itself while setting the MTU. This causes the DHCP client fall into a loop.
2625 * setting_mtu keep track whether the device got reset because of setting MTU and does not drop the
2626 * configuration and stop the clients as well. */
2627 if (link
->setting_mtu
)
2630 r
= link_stop_engines(link
, false);
2632 link_enter_failed(link
);
2636 r
= link_drop_config(link
);
2640 if (!IN_SET(link
->state
, LINK_STATE_UNMANAGED
, LINK_STATE_PENDING
, LINK_STATE_INITIALIZED
)) {
2641 log_link_debug(link
, "State is %s, dropping config", link_state_to_string(link
->state
));
2642 r
= link_drop_foreign_config(link
);
2647 r
= link_handle_bound_by_list(link
);
2654 int link_carrier_reset(Link
*link
) {
2659 if (link_has_carrier(link
)) {
2660 r
= link_carrier_lost(link
);
2664 r
= link_carrier_gained(link
);
2668 log_link_info(link
, "Reset carrier");
2674 static int link_admin_state_up(Link
*link
) {
2679 /* This is called every time an interface admin state changes to up;
2680 * specifically, when IFF_UP flag changes from unset to set. */
2685 if (link
->network
->activation_policy
== ACTIVATION_POLICY_ALWAYS_DOWN
) {
2686 log_link_info(link
, "ActivationPolicy is \"always-off\", forcing link down");
2687 return link_down(link
, NULL
);
2690 /* We set the ipv6 mtu after the device mtu, but the kernel resets
2691 * ipv6 mtu on NETDEV_UP, so we need to reset it. The check for
2692 * ipv6_mtu_set prevents this from trying to set it too early before
2693 * the link->network has been setup; we only need to reset it
2694 * here if we've already set it during normal initialization. */
2695 if (link
->ipv6_mtu_set
) {
2696 r
= link_set_ipv6_mtu(link
);
2704 static int link_admin_state_down(Link
*link
) {
2710 if (link
->network
->activation_policy
== ACTIVATION_POLICY_ALWAYS_UP
) {
2711 log_link_info(link
, "ActivationPolicy is \"always-on\", forcing link up");
2712 return link_up(link
);
2718 static int link_update(Link
*link
, sd_netlink_message
*m
) {
2719 _cleanup_strv_free_
char **s
= NULL
;
2720 hw_addr_data hw_addr
;
2723 bool had_carrier
, carrier_gained
, carrier_lost
, link_was_admin_up
;
2727 assert(link
->ifname
);
2730 if (link
->state
== LINK_STATE_LINGER
) {
2731 log_link_info(link
, "Link re-added");
2732 link_set_state(link
, LINK_STATE_CONFIGURING
);
2734 r
= link_new_carrier_maps(link
);
2739 r
= sd_netlink_message_read_string(m
, IFLA_IFNAME
, &ifname
);
2740 if (r
>= 0 && !streq(ifname
, link
->ifname
)) {
2741 Manager
*manager
= link
->manager
;
2743 log_link_info(link
, "Interface name change detected, %s has been renamed to %s.", link
->ifname
, ifname
);
2746 r
= link_add(manager
, m
, &link
);
2751 r
= sd_netlink_message_read_strv(m
, IFLA_PROP_LIST
, IFLA_ALT_IFNAME
, &s
);
2753 strv_free_and_replace(link
->alternative_names
, s
);
2755 r
= sd_netlink_message_read_u32(m
, IFLA_MTU
, &mtu
);
2756 if (r
>= 0 && mtu
> 0) {
2758 if (link
->original_mtu
== 0) {
2759 link
->original_mtu
= mtu
;
2760 log_link_debug(link
, "Saved original MTU: %" PRIu32
, link
->original_mtu
);
2763 if (link
->dhcp_client
) {
2764 r
= sd_dhcp_client_set_mtu(link
->dhcp_client
,
2767 return log_link_warning_errno(link
, r
, "Could not update MTU in DHCP client: %m");
2771 r
= sd_radv_set_mtu(link
->radv
, link
->mtu
);
2773 return log_link_warning_errno(link
, r
, "Could not set MTU for Router Advertisement: %m");
2777 /* The kernel may broadcast NEWLINK messages without the MAC address
2778 set, simply ignore them. */
2779 r
= netlink_message_read_hw_addr(m
, IFLA_ADDRESS
, &hw_addr
);
2780 if (r
>= 0 && (link
->hw_addr
.length
!= hw_addr
.length
||
2781 memcmp(link
->hw_addr
.addr
.bytes
, hw_addr
.addr
.bytes
, hw_addr
.length
) != 0)) {
2783 memcpy(link
->hw_addr
.addr
.bytes
, hw_addr
.addr
.bytes
, hw_addr
.length
);
2785 log_link_debug(link
, "Gained new hardware address: %s", HW_ADDR_TO_STR(&hw_addr
));
2787 r
= ipv4ll_update_mac(link
);
2789 return log_link_warning_errno(link
, r
, "Could not update MAC address in IPv4LL client: %m");
2791 r
= dhcp4_update_mac(link
);
2793 return log_link_warning_errno(link
, r
, "Could not update MAC address in DHCP client: %m");
2795 r
= dhcp6_update_mac(link
);
2797 return log_link_warning_errno(link
, r
, "Could not update MAC address in DHCPv6 client: %m");
2799 r
= radv_update_mac(link
);
2801 return log_link_warning_errno(link
, r
, "Could not update MAC address for Router Advertisement: %m");
2804 r
= sd_ndisc_set_mac(link
->ndisc
, &link
->hw_addr
.addr
.ether
);
2806 return log_link_warning_errno(link
, r
, "Could not update MAC for NDisc: %m");
2809 r
= ipv4_dad_update_mac(link
);
2811 return log_link_warning_errno(link
, r
, "Could not update MAC address in IPv4 ACD client: %m");
2814 old_master
= link
->master_ifindex
;
2815 (void) sd_netlink_message_read_u32(m
, IFLA_MASTER
, (uint32_t *) &link
->master_ifindex
);
2817 link_was_admin_up
= link
->flags
& IFF_UP
;
2818 had_carrier
= link_has_carrier(link
);
2820 r
= link_update_flags(link
, m
, old_master
!= link
->master_ifindex
);
2824 if (!link_was_admin_up
&& (link
->flags
& IFF_UP
)) {
2825 log_link_info(link
, "Link UP");
2827 r
= link_admin_state_up(link
);
2830 } else if (link_was_admin_up
&& !(link
->flags
& IFF_UP
)) {
2831 log_link_info(link
, "Link DOWN");
2833 r
= link_admin_state_down(link
);
2838 r
= link_update_lldp(link
);
2842 carrier_gained
= !had_carrier
&& link_has_carrier(link
);
2843 carrier_lost
= had_carrier
&& !link_has_carrier(link
);
2845 if (carrier_gained
) {
2846 log_link_info(link
, "Gained carrier");
2848 r
= link_carrier_gained(link
);
2851 } else if (carrier_lost
) {
2852 log_link_info(link
, "Lost carrier");
2854 r
= link_carrier_lost(link
);
2862 int manager_rtnl_process_link(sd_netlink
*rtnl
, sd_netlink_message
*message
, Manager
*m
) {
2864 NetDev
*netdev
= NULL
;
2873 if (sd_netlink_message_is_error(message
)) {
2874 r
= sd_netlink_message_get_errno(message
);
2876 log_message_warning_errno(message
, r
, "rtnl: Could not receive link message, ignoring");
2881 r
= sd_netlink_message_get_type(message
, &type
);
2883 log_warning_errno(r
, "rtnl: Could not get message type, ignoring: %m");
2885 } else if (!IN_SET(type
, RTM_NEWLINK
, RTM_DELLINK
)) {
2886 log_warning("rtnl: Received unexpected message type %u when processing link, ignoring.", type
);
2890 r
= sd_rtnl_message_link_get_ifindex(message
, &ifindex
);
2892 log_warning_errno(r
, "rtnl: Could not get ifindex from link message, ignoring: %m");
2894 } else if (ifindex
<= 0) {
2895 log_warning("rtnl: received link message with invalid ifindex %d, ignoring.", ifindex
);
2899 r
= sd_netlink_message_read_string(message
, IFLA_IFNAME
, &name
);
2901 log_warning_errno(r
, "rtnl: Received link message without ifname, ignoring: %m");
2905 (void) link_get(m
, ifindex
, &link
);
2906 (void) netdev_get(m
, name
, &netdev
);
2911 /* link is new, so add it */
2912 r
= link_add(m
, message
, &link
);
2914 log_warning_errno(r
, "Could not process new link message, ignoring: %m");
2920 /* netdev exists, so make sure the ifindex matches */
2921 r
= netdev_set_ifindex(netdev
, message
);
2923 log_warning_errno(r
, "Could not process new link message for netdev, ignoring: %m");
2928 r
= link_update(link
, message
);
2930 log_warning_errno(r
, "Could not process link message, ignoring: %m");
2938 netdev_drop(netdev
);
2943 assert_not_reached("Received link message with invalid RTNL message type.");
2949 static const char* const link_state_table
[_LINK_STATE_MAX
] = {
2950 [LINK_STATE_PENDING
] = "pending",
2951 [LINK_STATE_INITIALIZED
] = "initialized",
2952 [LINK_STATE_CONFIGURING
] = "configuring",
2953 [LINK_STATE_CONFIGURED
] = "configured",
2954 [LINK_STATE_UNMANAGED
] = "unmanaged",
2955 [LINK_STATE_FAILED
] = "failed",
2956 [LINK_STATE_LINGER
] = "linger",
2959 DEFINE_STRING_TABLE_LOOKUP(link_state
, LinkState
);
2961 int log_link_message_full_errno(Link
*link
, sd_netlink_message
*m
, int level
, int err
, const char *msg
) {
2962 const char *err_msg
= NULL
;
2964 (void) sd_netlink_message_read_string(m
, NLMSGERR_ATTR_MSG
, &err_msg
);
2965 return log_link_full_errno(link
, level
, err
,
2969 err_msg
&& !endswith(err_msg
, ".") ? "." : "",
2970 err_msg
? " " : "");