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 if (streq_ptr(link
->kind
, "wireguard"))
98 return link
->network
->link_local
& ADDRESS_FAMILY_IPV4
;
101 static bool link_ipv6ll_enabled(Link
*link
) {
104 if (!socket_ipv6_is_supported())
107 if (link
->flags
& IFF_LOOPBACK
)
113 if (streq_ptr(link
->kind
, "wireguard"))
116 return link
->network
->link_local
& ADDRESS_FAMILY_IPV6
;
119 static bool link_ipv6_enabled(Link
*link
) {
122 if (!socket_ipv6_is_supported())
125 if (link
->network
->bridge
)
128 /* DHCPv6 client will not be started if no IPv6 link-local address is configured. */
129 return link_ipv6ll_enabled(link
) || network_has_static_ipv6_addresses(link
->network
);
132 static bool link_radv_enabled(Link
*link
) {
135 if (!link_ipv6ll_enabled(link
))
138 return link
->network
->router_prefix_delegation
!= RADV_PREFIX_DELEGATION_NONE
;
141 static bool link_lldp_rx_enabled(Link
*link
) {
144 if (link
->flags
& IFF_LOOPBACK
)
147 if (link
->iftype
!= ARPHRD_ETHER
)
153 /* LLDP should be handled on bridge slaves as those have a direct
154 * connection to their peers not on the bridge master. Linux doesn't
155 * even (by default) forward lldp packets to the bridge master.*/
156 if (streq_ptr("bridge", link
->kind
))
159 return link
->network
->lldp_mode
!= LLDP_MODE_NO
;
162 static bool link_lldp_emit_enabled(Link
*link
) {
165 if (link
->flags
& IFF_LOOPBACK
)
168 if (link
->iftype
!= ARPHRD_ETHER
)
174 return link
->network
->lldp_emit
!= LLDP_EMIT_NO
;
177 static bool link_ipv4_forward_enabled(Link
*link
) {
180 if (link
->flags
& IFF_LOOPBACK
)
186 if (link
->network
->ip_forward
== _ADDRESS_FAMILY_BOOLEAN_INVALID
)
189 return link
->network
->ip_forward
& ADDRESS_FAMILY_IPV4
;
192 static bool link_ipv6_forward_enabled(Link
*link
) {
195 if (!socket_ipv6_is_supported())
198 if (link
->flags
& IFF_LOOPBACK
)
204 if (link
->network
->ip_forward
== _ADDRESS_FAMILY_BOOLEAN_INVALID
)
207 return link
->network
->ip_forward
& ADDRESS_FAMILY_IPV6
;
210 static bool link_proxy_arp_enabled(Link
*link
) {
213 if (link
->flags
& IFF_LOOPBACK
)
219 if (link
->network
->proxy_arp
< 0)
225 static bool link_ipv6_accept_ra_enabled(Link
*link
) {
228 if (!socket_ipv6_is_supported())
231 if (link
->flags
& IFF_LOOPBACK
)
237 if (!link_ipv6ll_enabled(link
))
240 /* If unset use system default (enabled if local forwarding is disabled.
241 * disabled if local forwarding is enabled).
242 * If set, ignore or enforce RA independent of local forwarding state.
244 if (link
->network
->ipv6_accept_ra
< 0)
245 /* default to accept RA if ip_forward is disabled and ignore RA if ip_forward is enabled */
246 return !link_ipv6_forward_enabled(link
);
247 else if (link
->network
->ipv6_accept_ra
> 0)
248 /* accept RA even if ip_forward is enabled */
255 static IPv6PrivacyExtensions
link_ipv6_privacy_extensions(Link
*link
) {
258 if (!socket_ipv6_is_supported())
259 return _IPV6_PRIVACY_EXTENSIONS_INVALID
;
261 if (link
->flags
& IFF_LOOPBACK
)
262 return _IPV6_PRIVACY_EXTENSIONS_INVALID
;
265 return _IPV6_PRIVACY_EXTENSIONS_INVALID
;
267 return link
->network
->ipv6_privacy_extensions
;
270 static int link_enable_ipv6(Link
*link
) {
271 const char *p
= NULL
;
275 if (link
->flags
& IFF_LOOPBACK
)
278 disabled
= !link_ipv6_enabled(link
);
280 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/disable_ipv6");
282 r
= write_string_file(p
, one_zero(disabled
), WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
284 log_link_warning_errno(link
, r
, "Cannot %s IPv6 for interface %s: %m",
285 enable_disable(!disabled
), link
->ifname
);
287 log_link_info(link
, "IPv6 successfully %sd", enable_disable(!disabled
));
292 void link_update_operstate(Link
*link
) {
293 LinkOperationalState operstate
;
296 if (link
->kernel_operstate
== IF_OPER_DORMANT
)
297 operstate
= LINK_OPERSTATE_DORMANT
;
298 else if (link_has_carrier(link
)) {
300 uint8_t scope
= RT_SCOPE_NOWHERE
;
303 /* if we have carrier, check what addresses we have */
304 SET_FOREACH(address
, link
->addresses
, i
) {
305 if (!address_is_ready(address
))
308 if (address
->scope
< scope
)
309 scope
= address
->scope
;
312 /* for operstate we also take foreign addresses into account */
313 SET_FOREACH(address
, link
->addresses_foreign
, i
) {
314 if (!address_is_ready(address
))
317 if (address
->scope
< scope
)
318 scope
= address
->scope
;
321 if (scope
< RT_SCOPE_SITE
)
322 /* universally accessible addresses found */
323 operstate
= LINK_OPERSTATE_ROUTABLE
;
324 else if (scope
< RT_SCOPE_HOST
)
325 /* only link or site local addresses found */
326 operstate
= LINK_OPERSTATE_DEGRADED
;
328 /* no useful addresses found */
329 operstate
= LINK_OPERSTATE_CARRIER
;
330 } else if (link
->flags
& IFF_UP
)
331 operstate
= LINK_OPERSTATE_NO_CARRIER
;
333 operstate
= LINK_OPERSTATE_OFF
;
335 if (link
->operstate
!= operstate
) {
336 link
->operstate
= operstate
;
337 link_send_changed(link
, "OperationalState", NULL
);
342 #define FLAG_STRING(string, flag, old, new) \
343 (((old ^ new) & flag) \
344 ? ((old & flag) ? (" -" string) : (" +" string)) \
347 static int link_update_flags(Link
*link
, sd_netlink_message
*m
) {
348 unsigned flags
, unknown_flags_added
, unknown_flags_removed
, unknown_flags
;
354 r
= sd_rtnl_message_link_get_flags(m
, &flags
);
356 return log_link_warning_errno(link
, r
, "Could not get link flags: %m");
358 r
= sd_netlink_message_read_u8(m
, IFLA_OPERSTATE
, &operstate
);
360 /* if we got a message without operstate, take it to mean
361 the state was unchanged */
362 operstate
= link
->kernel_operstate
;
364 if ((link
->flags
== flags
) && (link
->kernel_operstate
== operstate
))
367 if (link
->flags
!= flags
) {
368 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",
369 FLAG_STRING("LOOPBACK", IFF_LOOPBACK
, link
->flags
, flags
),
370 FLAG_STRING("MASTER", IFF_MASTER
, link
->flags
, flags
),
371 FLAG_STRING("SLAVE", IFF_SLAVE
, link
->flags
, flags
),
372 FLAG_STRING("UP", IFF_UP
, link
->flags
, flags
),
373 FLAG_STRING("DORMANT", IFF_DORMANT
, link
->flags
, flags
),
374 FLAG_STRING("LOWER_UP", IFF_LOWER_UP
, link
->flags
, flags
),
375 FLAG_STRING("RUNNING", IFF_RUNNING
, link
->flags
, flags
),
376 FLAG_STRING("MULTICAST", IFF_MULTICAST
, link
->flags
, flags
),
377 FLAG_STRING("BROADCAST", IFF_BROADCAST
, link
->flags
, flags
),
378 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT
, link
->flags
, flags
),
379 FLAG_STRING("PROMISC", IFF_PROMISC
, link
->flags
, flags
),
380 FLAG_STRING("ALLMULTI", IFF_ALLMULTI
, link
->flags
, flags
),
381 FLAG_STRING("PORTSEL", IFF_PORTSEL
, link
->flags
, flags
),
382 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA
, link
->flags
, flags
),
383 FLAG_STRING("DYNAMIC", IFF_DYNAMIC
, link
->flags
, flags
),
384 FLAG_STRING("NOARP", IFF_NOARP
, link
->flags
, flags
),
385 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS
, link
->flags
, flags
),
386 FLAG_STRING("DEBUG", IFF_DEBUG
, link
->flags
, flags
),
387 FLAG_STRING("ECHO", IFF_ECHO
, link
->flags
, flags
));
389 unknown_flags
= ~(IFF_LOOPBACK
| IFF_MASTER
| IFF_SLAVE
| IFF_UP
|
390 IFF_DORMANT
| IFF_LOWER_UP
| IFF_RUNNING
|
391 IFF_MULTICAST
| IFF_BROADCAST
| IFF_POINTOPOINT
|
392 IFF_PROMISC
| IFF_ALLMULTI
| IFF_PORTSEL
|
393 IFF_AUTOMEDIA
| IFF_DYNAMIC
| IFF_NOARP
|
394 IFF_NOTRAILERS
| IFF_DEBUG
| IFF_ECHO
);
395 unknown_flags_added
= ((link
->flags
^ flags
) & flags
& unknown_flags
);
396 unknown_flags_removed
= ((link
->flags
^ flags
) & link
->flags
& unknown_flags
);
398 /* link flags are currently at most 18 bits, let's align to
400 if (unknown_flags_added
)
402 "Unknown link flags gained: %#.5x (ignoring)",
403 unknown_flags_added
);
405 if (unknown_flags_removed
)
407 "Unknown link flags lost: %#.5x (ignoring)",
408 unknown_flags_removed
);
412 link
->kernel_operstate
= operstate
;
414 link_update_operstate(link
);
419 static int link_new(Manager
*manager
, sd_netlink_message
*message
, Link
**ret
) {
420 _cleanup_link_unref_ Link
*link
= NULL
;
422 const char *ifname
, *kind
= NULL
;
424 unsigned short iftype
;
430 /* check for link kind */
431 r
= sd_netlink_message_enter_container(message
, IFLA_LINKINFO
);
433 (void)sd_netlink_message_read_string(message
, IFLA_INFO_KIND
, &kind
);
434 r
= sd_netlink_message_exit_container(message
);
439 r
= sd_netlink_message_get_type(message
, &type
);
442 else if (type
!= RTM_NEWLINK
)
445 r
= sd_rtnl_message_link_get_ifindex(message
, &ifindex
);
448 else if (ifindex
<= 0)
451 r
= sd_rtnl_message_link_get_type(message
, &iftype
);
455 r
= sd_netlink_message_read_string(message
, IFLA_IFNAME
, &ifname
);
459 link
= new0(Link
, 1);
464 link
->manager
= manager
;
465 link
->state
= LINK_STATE_PENDING
;
466 link
->rtnl_extended_attrs
= true;
467 link
->ifindex
= ifindex
;
468 link
->iftype
= iftype
;
469 link
->ifname
= strdup(ifname
);
474 link
->kind
= strdup(kind
);
479 r
= sd_netlink_message_read_ether_addr(message
, IFLA_ADDRESS
, &link
->mac
);
481 log_link_debug_errno(link
, r
, "MAC address not found for new device, continuing without");
483 if (asprintf(&link
->state_file
, "/run/systemd/netif/links/%d", link
->ifindex
) < 0)
486 if (asprintf(&link
->lease_file
, "/run/systemd/netif/leases/%d", link
->ifindex
) < 0)
489 if (asprintf(&link
->lldp_file
, "/run/systemd/netif/lldp/%d", link
->ifindex
) < 0)
492 r
= hashmap_ensure_allocated(&manager
->links
, NULL
);
496 r
= hashmap_put(manager
->links
, INT_TO_PTR(link
->ifindex
), link
);
500 r
= link_update_flags(link
, message
);
510 static void link_free(Link
*link
) {
518 while (!set_isempty(link
->addresses
))
519 address_free(set_first(link
->addresses
));
521 while (!set_isempty(link
->addresses_foreign
))
522 address_free(set_first(link
->addresses_foreign
));
524 link
->addresses
= set_free(link
->addresses
);
526 link
->addresses_foreign
= set_free(link
->addresses_foreign
);
528 while ((address
= link
->pool_addresses
)) {
529 LIST_REMOVE(addresses
, link
->pool_addresses
, address
);
530 address_free(address
);
533 sd_dhcp_server_unref(link
->dhcp_server
);
534 sd_dhcp_client_unref(link
->dhcp_client
);
535 sd_dhcp_lease_unref(link
->dhcp_lease
);
537 link_lldp_emit_stop(link
);
539 free(link
->lease_file
);
541 sd_lldp_unref(link
->lldp
);
542 free(link
->lldp_file
);
546 sd_ipv4ll_unref(link
->ipv4ll
);
547 sd_dhcp6_client_unref(link
->dhcp6_client
);
548 sd_ndisc_unref(link
->ndisc
);
549 sd_radv_unref(link
->radv
);
552 hashmap_remove(link
->manager
->links
, INT_TO_PTR(link
->ifindex
));
558 (void)unlink(link
->state_file
);
559 free(link
->state_file
);
561 udev_device_unref(link
->udev_device
);
563 HASHMAP_FOREACH (carrier
, link
->bound_to_links
, i
)
564 hashmap_remove(link
->bound_to_links
, INT_TO_PTR(carrier
->ifindex
));
565 hashmap_free(link
->bound_to_links
);
567 HASHMAP_FOREACH (carrier
, link
->bound_by_links
, i
)
568 hashmap_remove(link
->bound_by_links
, INT_TO_PTR(carrier
->ifindex
));
569 hashmap_free(link
->bound_by_links
);
574 Link
*link_unref(Link
*link
) {
578 assert(link
->n_ref
> 0);
590 Link
*link_ref(Link
*link
) {
594 assert(link
->n_ref
> 0);
601 int link_get(Manager
*m
, int ifindex
, Link
**ret
) {
608 link
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
617 static void link_set_state(Link
*link
, LinkState state
) {
620 if (link
->state
== state
)
625 link_send_changed(link
, "AdministrativeState", NULL
);
628 static void link_enter_unmanaged(Link
*link
) {
631 log_link_debug(link
, "Unmanaged");
633 link_set_state(link
, LINK_STATE_UNMANAGED
);
638 static int link_stop_clients(Link
*link
) {
642 assert(link
->manager
);
643 assert(link
->manager
->event
);
645 if (link
->dhcp_client
) {
646 k
= sd_dhcp_client_stop(link
->dhcp_client
);
648 r
= log_link_warning_errno(link
, k
, "Could not stop DHCPv4 client: %m");
652 k
= sd_ipv4ll_stop(link
->ipv4ll
);
654 r
= log_link_warning_errno(link
, k
, "Could not stop IPv4 link-local: %m");
657 if (link
->dhcp6_client
) {
658 k
= sd_dhcp6_client_stop(link
->dhcp6_client
);
660 r
= log_link_warning_errno(link
, k
, "Could not stop DHCPv6 client: %m");
664 k
= sd_ndisc_stop(link
->ndisc
);
666 r
= log_link_warning_errno(link
, k
, "Could not stop IPv6 Router Discovery: %m");
670 k
= sd_radv_stop(link
->radv
);
672 r
= log_link_warning_errno(link
, k
, "Could not stop IPv6 Router Advertisement: %m");
675 link_lldp_emit_stop(link
);
679 void link_enter_failed(Link
*link
) {
682 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
685 log_link_warning(link
, "Failed");
687 link_set_state(link
, LINK_STATE_FAILED
);
689 link_stop_clients(link
);
694 static Address
* link_find_dhcp_server_address(Link
*link
) {
698 assert(link
->network
);
700 /* The first statically configured address if there is any */
701 LIST_FOREACH(addresses
, address
, link
->network
->static_addresses
) {
703 if (address
->family
!= AF_INET
)
706 if (in_addr_is_null(address
->family
, &address
->in_addr
))
712 /* If that didn't work, find a suitable address we got from the pool */
713 LIST_FOREACH(addresses
, address
, link
->pool_addresses
) {
714 if (address
->family
!= AF_INET
)
723 static void link_enter_configured(Link
*link
) {
725 assert(link
->network
);
727 if (link
->state
!= LINK_STATE_SETTING_ROUTES
)
730 log_link_info(link
, "Configured");
732 link_set_state(link
, LINK_STATE_CONFIGURED
);
737 void link_check_ready(Link
*link
) {
743 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
749 if (!link
->static_routes_configured
)
752 if (!link
->routing_policy_rules_configured
)
755 if (link_ipv4ll_enabled(link
))
756 if (!link
->ipv4ll_address
||
760 if (!link
->network
->bridge
) {
762 if (link_ipv6ll_enabled(link
))
763 if (in_addr_is_null(AF_INET6
, (const union in_addr_union
*) &link
->ipv6ll_address
) > 0)
766 if ((link_dhcp4_enabled(link
) && !link_dhcp6_enabled(link
) &&
767 !link
->dhcp4_configured
) ||
768 (link_dhcp6_enabled(link
) && !link_dhcp4_enabled(link
) &&
769 !link
->dhcp6_configured
) ||
770 (link_dhcp4_enabled(link
) && link_dhcp6_enabled(link
) &&
771 !link
->dhcp4_configured
&& !link
->dhcp6_configured
))
774 if (link_ipv6_accept_ra_enabled(link
) && !link
->ndisc_configured
)
778 SET_FOREACH(a
, link
->addresses
, i
)
779 if (!address_is_ready(a
))
782 if (link
->state
!= LINK_STATE_CONFIGURED
)
783 link_enter_configured(link
);
788 static int link_set_routing_policy_rule(Link
*link
) {
789 RoutingPolicyRule
*rule
, *rrule
= NULL
;
793 assert(link
->network
);
795 LIST_FOREACH(rules
, rule
, link
->network
->rules
) {
796 r
= routing_policy_rule_get(link
->manager
, rule
->family
, &rule
->from
, rule
->from_prefixlen
, &rule
->to
,
797 rule
->to_prefixlen
, rule
->tos
, rule
->fwmark
, rule
->table
, rule
->iif
, rule
->oif
, &rrule
);
799 (void) routing_policy_rule_make_local(link
->manager
, rrule
);
803 r
= routing_policy_rule_configure(rule
, link
, link_routing_policy_rule_handler
, false);
805 log_link_warning_errno(link
, r
, "Could not set routing policy rules: %m");
806 link_enter_failed(link
);
810 link
->routing_policy_rule_messages
++;
813 routing_policy_rule_purge(link
->manager
, link
);
814 if (link
->routing_policy_rule_messages
== 0) {
815 link
->routing_policy_rules_configured
= true;
816 link_check_ready(link
);
818 log_link_debug(link
, "Setting routing policy rules");
823 static int route_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
824 _cleanup_link_unref_ Link
*link
= userdata
;
827 assert(link
->route_messages
> 0);
828 assert(IN_SET(link
->state
, LINK_STATE_SETTING_ADDRESSES
,
829 LINK_STATE_SETTING_ROUTES
, LINK_STATE_FAILED
,
832 link
->route_messages
--;
834 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
837 r
= sd_netlink_message_get_errno(m
);
838 if (r
< 0 && r
!= -EEXIST
)
839 log_link_warning_errno(link
, r
, "Could not set route: %m");
841 if (link
->route_messages
== 0) {
842 log_link_debug(link
, "Routes set");
843 link
->static_routes_configured
= true;
844 link_check_ready(link
);
850 static int link_enter_set_routes(Link
*link
) {
855 assert(link
->network
);
856 assert(link
->state
== LINK_STATE_SETTING_ADDRESSES
);
858 (void) link_set_routing_policy_rule(link
);
860 link_set_state(link
, LINK_STATE_SETTING_ROUTES
);
862 LIST_FOREACH(routes
, rt
, link
->network
->static_routes
) {
863 r
= route_configure(rt
, link
, route_handler
);
865 log_link_warning_errno(link
, r
, "Could not set routes: %m");
866 link_enter_failed(link
);
870 link
->route_messages
++;
873 if (link
->route_messages
== 0) {
874 link
->static_routes_configured
= true;
875 link_check_ready(link
);
877 log_link_debug(link
, "Setting routes");
882 int link_route_remove_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
883 _cleanup_link_unref_ Link
*link
= userdata
;
888 assert(link
->ifname
);
890 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
893 r
= sd_netlink_message_get_errno(m
);
894 if (r
< 0 && r
!= -ESRCH
)
895 log_link_warning_errno(link
, r
, "Could not drop route: %m");
900 static int address_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
901 _cleanup_link_unref_ Link
*link
= userdata
;
907 assert(link
->ifname
);
908 assert(link
->address_messages
> 0);
909 assert(IN_SET(link
->state
, LINK_STATE_SETTING_ADDRESSES
,
910 LINK_STATE_FAILED
, LINK_STATE_LINGER
));
912 link
->address_messages
--;
914 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
917 r
= sd_netlink_message_get_errno(m
);
918 if (r
< 0 && r
!= -EEXIST
)
919 log_link_warning_errno(link
, r
, "could not set address: %m");
921 manager_rtnl_process_address(rtnl
, m
, link
->manager
);
923 if (link
->address_messages
== 0) {
924 log_link_debug(link
, "Addresses set");
925 link_enter_set_routes(link
);
931 static int address_label_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
932 _cleanup_link_unref_ Link
*link
= userdata
;
938 assert(link
->ifname
);
939 assert(link
->address_label_messages
> 0);
941 link
->address_label_messages
--;
943 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
946 r
= sd_netlink_message_get_errno(m
);
947 if (r
< 0 && r
!= -EEXIST
)
948 log_link_warning_errno(link
, r
, "could not set address label: %m");
950 manager_rtnl_process_address(rtnl
, m
, link
->manager
);
952 if (link
->address_label_messages
== 0)
953 log_link_debug(link
, "Addresses label set");
958 static int link_push_uplink_dns_to_dhcp_server(Link
*link
, sd_dhcp_server
*s
) {
959 _cleanup_free_
struct in_addr
*addresses
= NULL
;
960 size_t n_addresses
= 0, n_allocated
= 0;
963 log_debug("Copying DNS server information from %s", link
->ifname
);
968 for (i
= 0; i
< link
->network
->n_dns
; i
++) {
971 /* Only look for IPv4 addresses */
972 if (link
->network
->dns
[i
].family
!= AF_INET
)
975 ia
= link
->network
->dns
[i
].address
.in
;
977 /* Never propagate obviously borked data */
978 if (in4_addr_is_null(&ia
) || in4_addr_is_localhost(&ia
))
981 if (!GREEDY_REALLOC(addresses
, n_allocated
, n_addresses
+ 1))
984 addresses
[n_addresses
++] = ia
;
987 if (link
->network
->dhcp_use_dns
&& link
->dhcp_lease
) {
988 const struct in_addr
*da
= NULL
;
991 n
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &da
);
994 if (!GREEDY_REALLOC(addresses
, n_allocated
, n_addresses
+ n
))
997 memcpy(addresses
+ n_addresses
, da
, n
* sizeof(struct in_addr
));
1002 if (n_addresses
<= 0)
1005 return sd_dhcp_server_set_dns(s
, addresses
, n_addresses
);
1008 static int link_push_uplink_ntp_to_dhcp_server(Link
*link
, sd_dhcp_server
*s
) {
1009 _cleanup_free_
struct in_addr
*addresses
= NULL
;
1010 size_t n_addresses
= 0, n_allocated
= 0;
1016 log_debug("Copying NTP server information from %s", link
->ifname
);
1018 STRV_FOREACH(a
, link
->network
->ntp
) {
1021 /* Only look for IPv4 addresses */
1022 if (inet_pton(AF_INET
, *a
, &ia
) <= 0)
1025 /* Never propagate obviously borked data */
1026 if (in4_addr_is_null(&ia
) || in4_addr_is_localhost(&ia
))
1029 if (!GREEDY_REALLOC(addresses
, n_allocated
, n_addresses
+ 1))
1032 addresses
[n_addresses
++] = ia
;
1035 if (link
->network
->dhcp_use_ntp
&& link
->dhcp_lease
) {
1036 const struct in_addr
*da
= NULL
;
1039 n
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &da
);
1042 if (!GREEDY_REALLOC(addresses
, n_allocated
, n_addresses
+ n
))
1045 memcpy(addresses
+ n_addresses
, da
, n
* sizeof(struct in_addr
));
1050 if (n_addresses
<= 0)
1053 return sd_dhcp_server_set_ntp(s
, addresses
, n_addresses
);
1056 static int link_set_bridge_fdb(Link
*link
) {
1057 FdbEntry
*fdb_entry
;
1060 LIST_FOREACH(static_fdb_entries
, fdb_entry
, link
->network
->static_fdb_entries
) {
1061 r
= fdb_entry_configure(link
, fdb_entry
);
1063 return log_link_error_errno(link
, r
, "Failed to add MAC entry to static MAC table: %m");
1069 static int link_enter_set_addresses(Link
*link
) {
1070 AddressLabel
*label
;
1075 assert(link
->network
);
1076 assert(link
->state
!= _LINK_STATE_INVALID
);
1078 r
= link_set_bridge_fdb(link
);
1082 link_set_state(link
, LINK_STATE_SETTING_ADDRESSES
);
1084 LIST_FOREACH(addresses
, ad
, link
->network
->static_addresses
) {
1085 r
= address_configure(ad
, link
, address_handler
, false);
1087 log_link_warning_errno(link
, r
, "Could not set addresses: %m");
1088 link_enter_failed(link
);
1092 link
->address_messages
++;
1095 LIST_FOREACH(labels
, label
, link
->network
->address_labels
) {
1096 r
= address_label_configure(label
, link
, address_label_handler
, false);
1098 log_link_warning_errno(link
, r
, "Could not set address label: %m");
1099 link_enter_failed(link
);
1103 link
->address_label_messages
++;
1106 /* now that we can figure out a default address for the dhcp server,
1108 if (link_dhcp4_server_enabled(link
)) {
1110 Link
*uplink
= NULL
;
1111 bool acquired_uplink
= false;
1113 address
= link_find_dhcp_server_address(link
);
1115 log_link_warning(link
, "Failed to find suitable address for DHCPv4 server instance.");
1116 link_enter_failed(link
);
1120 /* use the server address' subnet as the pool */
1121 r
= sd_dhcp_server_configure_pool(link
->dhcp_server
, &address
->in_addr
.in
, address
->prefixlen
,
1122 link
->network
->dhcp_server_pool_offset
, link
->network
->dhcp_server_pool_size
);
1127 r = sd_dhcp_server_set_router(link->dhcp_server,
1128 &main_address->in_addr.in);
1133 if (link
->network
->dhcp_server_max_lease_time_usec
> 0) {
1134 r
= sd_dhcp_server_set_max_lease_time(
1136 DIV_ROUND_UP(link
->network
->dhcp_server_max_lease_time_usec
, USEC_PER_SEC
));
1141 if (link
->network
->dhcp_server_default_lease_time_usec
> 0) {
1142 r
= sd_dhcp_server_set_default_lease_time(
1144 DIV_ROUND_UP(link
->network
->dhcp_server_default_lease_time_usec
, USEC_PER_SEC
));
1149 if (link
->network
->dhcp_server_emit_dns
) {
1151 if (link
->network
->n_dhcp_server_dns
> 0)
1152 r
= sd_dhcp_server_set_dns(link
->dhcp_server
, link
->network
->dhcp_server_dns
, link
->network
->n_dhcp_server_dns
);
1154 uplink
= manager_find_uplink(link
->manager
, link
);
1155 acquired_uplink
= true;
1158 log_link_debug(link
, "Not emitting DNS server information on link, couldn't find suitable uplink.");
1161 r
= link_push_uplink_dns_to_dhcp_server(uplink
, link
->dhcp_server
);
1164 log_link_warning_errno(link
, r
, "Failed to set DNS server for DHCP server, ignoring: %m");
1168 if (link
->network
->dhcp_server_emit_ntp
) {
1170 if (link
->network
->n_dhcp_server_ntp
> 0)
1171 r
= sd_dhcp_server_set_ntp(link
->dhcp_server
, link
->network
->dhcp_server_ntp
, link
->network
->n_dhcp_server_ntp
);
1173 if (!acquired_uplink
)
1174 uplink
= manager_find_uplink(link
->manager
, link
);
1177 log_link_debug(link
, "Not emitting NTP server information on link, couldn't find suitable uplink.");
1180 r
= link_push_uplink_ntp_to_dhcp_server(uplink
, link
->dhcp_server
);
1184 log_link_warning_errno(link
, r
, "Failed to set NTP server for DHCP server, ignoring: %m");
1187 r
= sd_dhcp_server_set_emit_router(link
->dhcp_server
, link
->network
->dhcp_server_emit_router
);
1189 log_link_warning_errno(link
, r
, "Failed to set router emission for DHCP server: %m");
1193 if (link
->network
->dhcp_server_emit_timezone
) {
1194 _cleanup_free_
char *buffer
= NULL
;
1195 const char *tz
= NULL
;
1197 if (link
->network
->dhcp_server_timezone
)
1198 tz
= link
->network
->dhcp_server_timezone
;
1200 r
= get_timezone(&buffer
);
1202 log_warning_errno(r
, "Failed to determine timezone: %m");
1208 r
= sd_dhcp_server_set_timezone(link
->dhcp_server
, tz
);
1214 r
= sd_dhcp_server_start(link
->dhcp_server
);
1216 log_link_warning_errno(link
, r
, "Could not start DHCPv4 server instance: %m");
1218 link_enter_failed(link
);
1223 log_link_debug(link
, "Offering DHCPv4 leases");
1226 if (link
->address_messages
== 0)
1227 link_enter_set_routes(link
);
1229 log_link_debug(link
, "Setting addresses");
1234 int link_address_remove_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1235 _cleanup_link_unref_ Link
*link
= userdata
;
1240 assert(link
->ifname
);
1242 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1245 r
= sd_netlink_message_get_errno(m
);
1246 if (r
< 0 && r
!= -EADDRNOTAVAIL
)
1247 log_link_warning_errno(link
, r
, "Could not drop address: %m");
1252 static int link_set_bridge_vlan(Link
*link
) {
1255 r
= br_vlan_configure(link
, link
->network
->pvid
, link
->network
->br_vid_bitmap
, link
->network
->br_untagged_bitmap
);
1257 log_link_error_errno(link
, r
, "Failed to assign VLANs to bridge port: %m");
1262 static int link_set_proxy_arp(Link
*link
) {
1263 const char *p
= NULL
;
1266 if (!link_proxy_arp_enabled(link
))
1269 p
= strjoina("/proc/sys/net/ipv4/conf/", link
->ifname
, "/proxy_arp");
1271 r
= write_string_file(p
, one_zero(link
->network
->proxy_arp
), WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
1273 log_link_warning_errno(link
, r
, "Cannot configure proxy ARP for interface: %m");
1278 static int link_set_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1279 _cleanup_link_unref_ Link
*link
= userdata
;
1282 log_link_debug(link
, "Set link");
1284 r
= sd_netlink_message_get_errno(m
);
1285 if (r
< 0 && r
!= -EEXIST
) {
1286 log_link_error_errno(link
, r
, "Could not join netdev: %m");
1287 link_enter_failed(link
);
1294 static int set_mtu_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1295 _cleanup_link_unref_ Link
*link
= userdata
;
1300 assert(link
->ifname
);
1302 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1305 r
= sd_netlink_message_get_errno(m
);
1307 log_link_warning_errno(link
, r
, "Could not set MTU: %m");
1312 int link_set_mtu(Link
*link
, uint32_t mtu
) {
1313 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1317 assert(link
->manager
);
1318 assert(link
->manager
->rtnl
);
1320 log_link_debug(link
, "Setting MTU: %" PRIu32
, mtu
);
1322 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1324 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1326 r
= sd_netlink_message_append_u32(req
, IFLA_MTU
, mtu
);
1328 return log_link_error_errno(link
, r
, "Could not append MTU: %m");
1330 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, set_mtu_handler
, link
, 0, NULL
);
1332 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1334 link
->setting_mtu
= true;
1341 static int set_flags_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1342 _cleanup_link_unref_ Link
*link
= userdata
;
1347 assert(link
->ifname
);
1349 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1352 r
= sd_netlink_message_get_errno(m
);
1354 log_link_warning_errno(link
, r
, "Could not set link flags: %m");
1359 static int link_set_flags(Link
*link
) {
1360 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1361 unsigned ifi_change
= 0;
1362 unsigned ifi_flags
= 0;
1366 assert(link
->manager
);
1367 assert(link
->manager
->rtnl
);
1369 if (link
->flags
& IFF_LOOPBACK
)
1375 if (link
->network
->arp
< 0)
1378 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1380 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1382 if (link
->network
->arp
>= 0) {
1383 ifi_change
|= IFF_NOARP
;
1384 ifi_flags
|= link
->network
->arp
? 0 : IFF_NOARP
;
1387 r
= sd_rtnl_message_link_set_flags(req
, ifi_flags
, ifi_change
);
1389 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1391 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, set_flags_handler
, link
, 0, NULL
);
1393 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1400 static int link_set_bridge(Link
*link
) {
1401 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1405 assert(link
->network
);
1407 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1409 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1411 r
= sd_rtnl_message_link_set_family(req
, PF_BRIDGE
);
1413 return log_link_error_errno(link
, r
, "Could not set message family: %m");
1415 r
= sd_netlink_message_open_container(req
, IFLA_PROTINFO
);
1417 return log_link_error_errno(link
, r
, "Could not append IFLA_PROTINFO attribute: %m");
1419 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_GUARD
, !link
->network
->use_bpdu
);
1421 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_GUARD attribute: %m");
1423 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_MODE
, link
->network
->hairpin
);
1425 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_MODE attribute: %m");
1427 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_FAST_LEAVE
, link
->network
->fast_leave
);
1429 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_FAST_LEAVE attribute: %m");
1431 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_PROTECT
, !link
->network
->allow_port_to_be_root
);
1433 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_PROTECT attribute: %m");
1435 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_UNICAST_FLOOD
, link
->network
->unicast_flood
);
1437 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_UNICAST_FLOOD attribute: %m");
1439 if (link
->network
->cost
!= 0) {
1440 r
= sd_netlink_message_append_u32(req
, IFLA_BRPORT_COST
, link
->network
->cost
);
1442 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_COST attribute: %m");
1444 if (link
->network
->priority
!= LINK_BRIDGE_PORT_PRIORITY_INVALID
) {
1445 r
= sd_netlink_message_append_u16(req
, IFLA_BRPORT_PRIORITY
, link
->network
->priority
);
1447 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_PRIORITY attribute: %m");
1450 r
= sd_netlink_message_close_container(req
);
1452 return log_link_error_errno(link
, r
, "Could not append IFLA_LINKINFO attribute: %m");
1454 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, link_set_handler
, link
, 0, NULL
);
1456 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1463 static int link_bond_set(Link
*link
) {
1464 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1468 assert(link
->network
);
1470 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_NEWLINK
, link
->network
->bond
->ifindex
);
1472 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1474 r
= sd_netlink_message_set_flags(req
, NLM_F_REQUEST
| NLM_F_ACK
);
1476 return log_link_error_errno(link
, r
, "Could not set netlink flags: %m");
1478 r
= sd_netlink_message_open_container(req
, IFLA_LINKINFO
);
1480 return log_link_error_errno(link
, r
, "Could not append IFLA_PROTINFO attribute: %m");
1482 r
= sd_netlink_message_open_container_union(req
, IFLA_INFO_DATA
, "bond");
1484 return log_link_error_errno(link
, r
, "Could not append IFLA_INFO_DATA attribute: %m");
1486 if (link
->network
->active_slave
) {
1487 r
= sd_netlink_message_append_u32(req
, IFLA_BOND_ACTIVE_SLAVE
, link
->ifindex
);
1489 return log_link_error_errno(link
, r
, "Could not append IFLA_BOND_ACTIVE_SLAVE attribute: %m");
1492 if (link
->network
->primary_slave
) {
1493 r
= sd_netlink_message_append_u32(req
, IFLA_BOND_PRIMARY
, link
->ifindex
);
1495 return log_link_error_errno(link
, r
, "Could not append IFLA_BOND_PRIMARY attribute: %m");
1498 r
= sd_netlink_message_close_container(req
);
1500 return log_link_error_errno(link
, r
, "Could not append IFLA_LINKINFO attribute: %m");
1502 r
= sd_netlink_message_close_container(req
);
1504 return log_link_error_errno(link
, r
, "Could not append IFLA_INFO_DATA attribute: %m");
1506 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, set_flags_handler
, link
, 0, NULL
);
1508 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1515 static int link_lldp_save(Link
*link
) {
1516 _cleanup_free_
char *temp_path
= NULL
;
1517 _cleanup_fclose_
FILE *f
= NULL
;
1518 sd_lldp_neighbor
**l
= NULL
;
1522 assert(link
->lldp_file
);
1525 (void) unlink(link
->lldp_file
);
1529 r
= sd_lldp_get_neighbors(link
->lldp
, &l
);
1533 (void) unlink(link
->lldp_file
);
1539 r
= fopen_temporary(link
->lldp_file
, &f
, &temp_path
);
1543 fchmod(fileno(f
), 0644);
1545 for (i
= 0; i
< n
; i
++) {
1550 r
= sd_lldp_neighbor_get_raw(l
[i
], &p
, &sz
);
1555 (void) fwrite(&u
, 1, sizeof(u
), f
);
1556 (void) fwrite(p
, 1, sz
, f
);
1559 r
= fflush_and_check(f
);
1563 if (rename(temp_path
, link
->lldp_file
) < 0) {
1570 (void) unlink(link
->lldp_file
);
1572 (void) unlink(temp_path
);
1574 log_link_error_errno(link
, r
, "Failed to save LLDP data to %s: %m", link
->lldp_file
);
1578 for (i
= 0; i
< n
; i
++)
1579 sd_lldp_neighbor_unref(l
[i
]);
1586 static void lldp_handler(sd_lldp
*lldp
, sd_lldp_event event
, sd_lldp_neighbor
*n
, void *userdata
) {
1587 Link
*link
= userdata
;
1592 (void) link_lldp_save(link
);
1594 if (link_lldp_emit_enabled(link
) && event
== SD_LLDP_EVENT_ADDED
) {
1595 /* If we received information about a new neighbor, restart the LLDP "fast" logic */
1597 log_link_debug(link
, "Received LLDP datagram from previously unknown neighbor, restarting 'fast' LLDP transmission.");
1599 r
= link_lldp_emit_start(link
);
1601 log_link_warning_errno(link
, r
, "Failed to restart LLDP transmission: %m");
1605 static int link_acquire_ipv6_conf(Link
*link
) {
1610 if (link_dhcp6_enabled(link
)) {
1611 assert(link
->dhcp6_client
);
1612 assert(in_addr_is_link_local(AF_INET6
, (const union in_addr_union
*)&link
->ipv6ll_address
) > 0);
1614 /* start DHCPv6 client in stateless mode */
1615 r
= dhcp6_request_address(link
, true);
1616 if (r
< 0 && r
!= -EBUSY
)
1617 return log_link_warning_errno(link
, r
, "Could not acquire DHCPv6 lease: %m");
1619 log_link_debug(link
, "Acquiring DHCPv6 lease");
1622 if (link_ipv6_accept_ra_enabled(link
)) {
1623 assert(link
->ndisc
);
1625 log_link_debug(link
, "Discovering IPv6 routers");
1627 r
= sd_ndisc_start(link
->ndisc
);
1628 if (r
< 0 && r
!= -EBUSY
)
1629 return log_link_warning_errno(link
, r
, "Could not start IPv6 Router Discovery: %m");
1632 if (link_radv_enabled(link
)) {
1634 assert(in_addr_is_link_local(AF_INET6
, (const union in_addr_union
*)&link
->ipv6ll_address
) > 0);
1636 log_link_debug(link
, "Starting IPv6 Router Advertisements");
1638 r
= sd_radv_start(link
->radv
);
1639 if (r
< 0 && r
!= -EBUSY
)
1640 return log_link_warning_errno(link
, r
, "Could not start IPv6 Router Advertisement: %m");
1646 static int link_acquire_ipv4_conf(Link
*link
) {
1650 assert(link
->network
);
1651 assert(link
->manager
);
1652 assert(link
->manager
->event
);
1654 if (link_ipv4ll_enabled(link
)) {
1655 assert(link
->ipv4ll
);
1657 log_link_debug(link
, "Acquiring IPv4 link-local address");
1659 r
= sd_ipv4ll_start(link
->ipv4ll
);
1661 return log_link_warning_errno(link
, r
, "Could not acquire IPv4 link-local address: %m");
1664 if (link_dhcp4_enabled(link
)) {
1665 assert(link
->dhcp_client
);
1667 log_link_debug(link
, "Acquiring DHCPv4 lease");
1669 r
= sd_dhcp_client_start(link
->dhcp_client
);
1671 return log_link_warning_errno(link
, r
, "Could not acquire DHCPv4 lease: %m");
1677 static int link_acquire_conf(Link
*link
) {
1682 if (link
->setting_mtu
) {
1683 link
->setting_mtu
= false;
1687 r
= link_acquire_ipv4_conf(link
);
1691 if (in_addr_is_null(AF_INET6
, (const union in_addr_union
*) &link
->ipv6ll_address
) == 0) {
1692 r
= link_acquire_ipv6_conf(link
);
1697 if (link_lldp_emit_enabled(link
)) {
1698 r
= link_lldp_emit_start(link
);
1700 return log_link_warning_errno(link
, r
, "Failed to start LLDP transmission: %m");
1706 bool link_has_carrier(Link
*link
) {
1707 /* see Documentation/networking/operstates.txt in the kernel sources */
1709 if (link
->kernel_operstate
== IF_OPER_UP
)
1712 if (link
->kernel_operstate
== IF_OPER_UNKNOWN
)
1713 /* operstate may not be implemented, so fall back to flags */
1714 if ((link
->flags
& IFF_LOWER_UP
) && !(link
->flags
& IFF_DORMANT
))
1720 static int link_up_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1721 _cleanup_link_unref_ Link
*link
= userdata
;
1726 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1729 r
= sd_netlink_message_get_errno(m
);
1731 /* we warn but don't fail the link, as it may be
1733 log_link_warning_errno(link
, r
, "Could not bring up interface: %m");
1738 int link_up(Link
*link
) {
1739 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1740 uint8_t ipv6ll_mode
;
1744 assert(link
->network
);
1745 assert(link
->manager
);
1746 assert(link
->manager
->rtnl
);
1748 log_link_debug(link
, "Bringing link up");
1750 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1752 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1754 /* set it free if not enslaved with networkd */
1755 if (!link
->network
->bridge
&& !link
->network
->bond
&& !link
->network
->vrf
) {
1756 r
= sd_netlink_message_append_u32(req
, IFLA_MASTER
, 0);
1758 return log_link_error_errno(link
, r
, "Could not append IFLA_MASTER attribute: %m");
1761 r
= sd_rtnl_message_link_set_flags(req
, IFF_UP
, IFF_UP
);
1763 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1765 if (link
->network
->mac
) {
1766 r
= sd_netlink_message_append_ether_addr(req
, IFLA_ADDRESS
, link
->network
->mac
);
1768 return log_link_error_errno(link
, r
, "Could not set MAC address: %m");
1771 /* If IPv6 not configured (no static IPv6 address and IPv6LL autoconfiguration is disabled)
1772 for this interface, or if it is a bridge slave, then disable IPv6 else enable it. */
1773 (void) link_enable_ipv6(link
);
1775 if (link
->network
->mtu
) {
1776 /* IPv6 protocol requires a minimum MTU of IPV6_MTU_MIN(1280) bytes
1777 on the interface. Bump up MTU bytes to IPV6_MTU_MIN. */
1778 if (link_ipv6_enabled(link
) && link
->network
->mtu
< IPV6_MIN_MTU
) {
1780 log_link_warning(link
, "Bumping MTU to " STRINGIFY(IPV6_MIN_MTU
) ", as "
1781 "IPv6 is requested and requires a minimum MTU of " STRINGIFY(IPV6_MIN_MTU
) " bytes: %m");
1783 link
->network
->mtu
= IPV6_MIN_MTU
;
1786 r
= sd_netlink_message_append_u32(req
, IFLA_MTU
, link
->network
->mtu
);
1788 return log_link_error_errno(link
, r
, "Could not set MTU: %m");
1791 r
= sd_netlink_message_open_container(req
, IFLA_AF_SPEC
);
1793 return log_link_error_errno(link
, r
, "Could not open IFLA_AF_SPEC container: %m");
1795 if (link_ipv6_enabled(link
)) {
1796 /* if the kernel lacks ipv6 support setting IFF_UP fails if any ipv6 options are passed */
1797 r
= sd_netlink_message_open_container(req
, AF_INET6
);
1799 return log_link_error_errno(link
, r
, "Could not open AF_INET6 container: %m");
1801 if (!link_ipv6ll_enabled(link
))
1802 ipv6ll_mode
= IN6_ADDR_GEN_MODE_NONE
;
1804 const char *p
= NULL
;
1805 _cleanup_free_
char *stable_secret
= NULL
;
1807 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/stable_secret");
1808 r
= read_one_line_file(p
, &stable_secret
);
1811 ipv6ll_mode
= IN6_ADDR_GEN_MODE_EUI64
;
1813 ipv6ll_mode
= IN6_ADDR_GEN_MODE_STABLE_PRIVACY
;
1815 r
= sd_netlink_message_append_u8(req
, IFLA_INET6_ADDR_GEN_MODE
, ipv6ll_mode
);
1817 return log_link_error_errno(link
, r
, "Could not append IFLA_INET6_ADDR_GEN_MODE: %m");
1819 if (!in_addr_is_null(AF_INET6
, &link
->network
->ipv6_token
)) {
1820 r
= sd_netlink_message_append_in6_addr(req
, IFLA_INET6_TOKEN
, &link
->network
->ipv6_token
.in6
);
1822 return log_link_error_errno(link
, r
, "Could not append IFLA_INET6_TOKEN: %m");
1825 r
= sd_netlink_message_close_container(req
);
1827 return log_link_error_errno(link
, r
, "Could not close AF_INET6 container: %m");
1830 r
= sd_netlink_message_close_container(req
);
1832 return log_link_error_errno(link
, r
, "Could not close IFLA_AF_SPEC container: %m");
1834 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, link_up_handler
, link
, 0, NULL
);
1836 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1843 static int link_down_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1844 _cleanup_link_unref_ Link
*link
= userdata
;
1849 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1852 r
= sd_netlink_message_get_errno(m
);
1854 log_link_warning_errno(link
, r
, "Could not bring down interface: %m");
1859 int link_down(Link
*link
) {
1860 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1864 assert(link
->manager
);
1865 assert(link
->manager
->rtnl
);
1867 log_link_debug(link
, "Bringing link down");
1869 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
,
1870 RTM_SETLINK
, link
->ifindex
);
1872 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1874 r
= sd_rtnl_message_link_set_flags(req
, 0, IFF_UP
);
1876 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1878 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, link_down_handler
, link
, 0, NULL
);
1880 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1887 static int link_up_can(Link
*link
) {
1888 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
1893 log_link_debug(link
, "Bringing CAN link up");
1895 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1897 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1899 r
= sd_rtnl_message_link_set_flags(req
, IFF_UP
, IFF_UP
);
1901 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1903 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, link_up_handler
, link
, 0, NULL
);
1905 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1912 static int link_handle_bound_to_list(Link
*link
) {
1916 bool required_up
= false;
1917 bool link_is_up
= false;
1921 if (hashmap_isempty(link
->bound_to_links
))
1924 if (link
->flags
& IFF_UP
)
1927 HASHMAP_FOREACH (l
, link
->bound_to_links
, i
)
1928 if (link_has_carrier(l
)) {
1933 if (!required_up
&& link_is_up
) {
1934 r
= link_down(link
);
1937 } else if (required_up
&& !link_is_up
) {
1946 static int link_handle_bound_by_list(Link
*link
) {
1953 if (hashmap_isempty(link
->bound_by_links
))
1956 HASHMAP_FOREACH (l
, link
->bound_by_links
, i
) {
1957 r
= link_handle_bound_to_list(l
);
1965 static int link_put_carrier(Link
*link
, Link
*carrier
, Hashmap
**h
) {
1971 if (link
== carrier
)
1974 if (hashmap_get(*h
, INT_TO_PTR(carrier
->ifindex
)))
1977 r
= hashmap_ensure_allocated(h
, NULL
);
1981 r
= hashmap_put(*h
, INT_TO_PTR(carrier
->ifindex
), carrier
);
1988 static int link_new_bound_by_list(Link
*link
) {
1993 bool list_updated
= false;
1996 assert(link
->manager
);
2000 HASHMAP_FOREACH(carrier
, m
->links
, i
) {
2001 if (!carrier
->network
)
2004 if (strv_isempty(carrier
->network
->bind_carrier
))
2007 if (strv_fnmatch(carrier
->network
->bind_carrier
, link
->ifname
, 0)) {
2008 r
= link_put_carrier(link
, carrier
, &link
->bound_by_links
);
2012 list_updated
= true;
2019 HASHMAP_FOREACH(carrier
, link
->bound_by_links
, i
) {
2020 r
= link_put_carrier(carrier
, link
, &carrier
->bound_to_links
);
2024 link_dirty(carrier
);
2030 static int link_new_bound_to_list(Link
*link
) {
2035 bool list_updated
= false;
2038 assert(link
->manager
);
2043 if (strv_isempty(link
->network
->bind_carrier
))
2048 HASHMAP_FOREACH (carrier
, m
->links
, i
) {
2049 if (strv_fnmatch(link
->network
->bind_carrier
, carrier
->ifname
, 0)) {
2050 r
= link_put_carrier(link
, carrier
, &link
->bound_to_links
);
2054 list_updated
= true;
2061 HASHMAP_FOREACH (carrier
, link
->bound_to_links
, i
) {
2062 r
= link_put_carrier(carrier
, link
, &carrier
->bound_by_links
);
2066 link_dirty(carrier
);
2072 static int link_new_carrier_maps(Link
*link
) {
2075 r
= link_new_bound_by_list(link
);
2079 r
= link_handle_bound_by_list(link
);
2083 r
= link_new_bound_to_list(link
);
2087 r
= link_handle_bound_to_list(link
);
2094 static void link_free_bound_to_list(Link
*link
) {
2098 HASHMAP_FOREACH (bound_to
, link
->bound_to_links
, i
) {
2099 hashmap_remove(link
->bound_to_links
, INT_TO_PTR(bound_to
->ifindex
));
2101 if (hashmap_remove(bound_to
->bound_by_links
, INT_TO_PTR(link
->ifindex
)))
2102 link_dirty(bound_to
);
2108 static void link_free_bound_by_list(Link
*link
) {
2112 HASHMAP_FOREACH (bound_by
, link
->bound_by_links
, i
) {
2113 hashmap_remove(link
->bound_by_links
, INT_TO_PTR(bound_by
->ifindex
));
2115 if (hashmap_remove(bound_by
->bound_to_links
, INT_TO_PTR(link
->ifindex
))) {
2116 link_dirty(bound_by
);
2117 link_handle_bound_to_list(bound_by
);
2124 static void link_free_carrier_maps(Link
*link
) {
2125 bool list_updated
= false;
2129 if (!hashmap_isempty(link
->bound_to_links
)) {
2130 link_free_bound_to_list(link
);
2131 list_updated
= true;
2134 if (!hashmap_isempty(link
->bound_by_links
)) {
2135 link_free_bound_by_list(link
);
2136 list_updated
= true;
2145 void link_drop(Link
*link
) {
2146 if (!link
|| link
->state
== LINK_STATE_LINGER
)
2149 link_set_state(link
, LINK_STATE_LINGER
);
2151 link_free_carrier_maps(link
);
2153 log_link_debug(link
, "Link removed");
2155 (void)unlink(link
->state_file
);
2161 static int link_joined(Link
*link
) {
2165 assert(link
->network
);
2167 if (!hashmap_isempty(link
->bound_to_links
)) {
2168 r
= link_handle_bound_to_list(link
);
2171 } else if (!(link
->flags
& IFF_UP
)) {
2174 link_enter_failed(link
);
2179 if (link
->network
->bridge
) {
2180 r
= link_set_bridge(link
);
2182 log_link_error_errno(link
, r
, "Could not set bridge message: %m");
2185 if (link
->network
->bond
) {
2186 r
= link_bond_set(link
);
2188 log_link_error_errno(link
, r
, "Could not set bond message: %m");
2191 if (link
->network
->use_br_vlan
&&
2192 (link
->network
->bridge
|| streq_ptr("bridge", link
->kind
))) {
2193 r
= link_set_bridge_vlan(link
);
2195 log_link_error_errno(link
, r
, "Could not set bridge vlan: %m");
2198 /* Skip setting up addresses until it gets carrier,
2199 or it would try to set addresses twice,
2200 which is bad for non-idempotent steps. */
2201 if (!link_has_carrier(link
) && !link
->network
->configure_without_carrier
)
2204 return link_enter_set_addresses(link
);
2207 static int netdev_join_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
2208 _cleanup_link_unref_ Link
*link
= userdata
;
2212 assert(link
->network
);
2216 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
2219 r
= sd_netlink_message_get_errno(m
);
2220 if (r
< 0 && r
!= -EEXIST
) {
2221 log_link_error_errno(link
, r
, "Could not join netdev: %m");
2222 link_enter_failed(link
);
2225 log_link_debug(link
, "Joined netdev");
2227 if (link
->enslaving
<= 0)
2233 static int link_enter_join_netdev(Link
*link
) {
2239 assert(link
->network
);
2240 assert(link
->state
== LINK_STATE_PENDING
);
2242 link_set_state(link
, LINK_STATE_ENSLAVING
);
2246 if (!link
->network
->bridge
&&
2247 !link
->network
->bond
&&
2248 !link
->network
->vrf
&&
2249 hashmap_isempty(link
->network
->stacked_netdevs
))
2250 return link_joined(link
);
2252 if (link
->network
->bond
) {
2253 log_struct(LOG_DEBUG
,
2254 LOG_LINK_INTERFACE(link
),
2255 LOG_NETDEV_INTERFACE(link
->network
->bond
),
2256 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->bond
->ifname
),
2259 r
= netdev_join(link
->network
->bond
, link
, netdev_join_handler
);
2261 log_struct_errno(LOG_WARNING
, r
,
2262 LOG_LINK_INTERFACE(link
),
2263 LOG_NETDEV_INTERFACE(link
->network
->bond
),
2264 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->bond
->ifname
),
2267 link_enter_failed(link
);
2274 if (link
->network
->bridge
) {
2275 log_struct(LOG_DEBUG
,
2276 LOG_LINK_INTERFACE(link
),
2277 LOG_NETDEV_INTERFACE(link
->network
->bridge
),
2278 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->bridge
->ifname
),
2281 r
= netdev_join(link
->network
->bridge
, link
, netdev_join_handler
);
2283 log_struct_errno(LOG_WARNING
, r
,
2284 LOG_LINK_INTERFACE(link
),
2285 LOG_NETDEV_INTERFACE(link
->network
->bridge
),
2286 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->bridge
->ifname
),
2288 link_enter_failed(link
);
2295 if (link
->network
->vrf
) {
2296 log_struct(LOG_DEBUG
,
2297 LOG_LINK_INTERFACE(link
),
2298 LOG_NETDEV_INTERFACE(link
->network
->vrf
),
2299 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->vrf
->ifname
),
2301 r
= netdev_join(link
->network
->vrf
, link
, netdev_join_handler
);
2303 log_struct_errno(LOG_WARNING
, r
,
2304 LOG_LINK_INTERFACE(link
),
2305 LOG_NETDEV_INTERFACE(link
->network
->vrf
),
2306 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->vrf
->ifname
),
2308 link_enter_failed(link
);
2315 HASHMAP_FOREACH(netdev
, link
->network
->stacked_netdevs
, i
) {
2317 if (netdev
->ifindex
> 0) {
2322 log_struct(LOG_DEBUG
,
2323 LOG_LINK_INTERFACE(link
),
2324 LOG_NETDEV_INTERFACE(netdev
),
2325 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", netdev
->ifname
),
2328 r
= netdev_join(netdev
, link
, netdev_join_handler
);
2330 log_struct_errno(LOG_WARNING
, r
,
2331 LOG_LINK_INTERFACE(link
),
2332 LOG_NETDEV_INTERFACE(netdev
),
2333 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", netdev
->ifname
),
2335 link_enter_failed(link
);
2345 static int link_set_ipv4_forward(Link
*link
) {
2348 if (!link_ipv4_forward_enabled(link
))
2351 /* We propagate the forwarding flag from one interface to the
2352 * global setting one way. This means: as long as at least one
2353 * interface was configured at any time that had IP forwarding
2354 * enabled the setting will stay on for good. We do this
2355 * primarily to keep IPv4 and IPv6 packet forwarding behaviour
2356 * somewhat in sync (see below). */
2358 r
= write_string_file("/proc/sys/net/ipv4/ip_forward", "1", WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2360 log_link_warning_errno(link
, r
, "Cannot turn on IPv4 packet forwarding, ignoring: %m");
2365 static int link_set_ipv6_forward(Link
*link
) {
2368 if (!link_ipv6_forward_enabled(link
))
2371 /* On Linux, the IPv6 stack does not know a per-interface
2372 * packet forwarding setting: either packet forwarding is on
2373 * for all, or off for all. We hence don't bother with a
2374 * per-interface setting, but simply propagate the interface
2375 * flag, if it is set, to the global flag, one-way. Note that
2376 * while IPv4 would allow a per-interface flag, we expose the
2377 * same behaviour there and also propagate the setting from
2378 * one to all, to keep things simple (see above). */
2380 r
= write_string_file("/proc/sys/net/ipv6/conf/all/forwarding", "1", WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2382 log_link_warning_errno(link
, r
, "Cannot configure IPv6 packet forwarding, ignoring: %m");
2387 static int link_set_ipv6_privacy_extensions(Link
*link
) {
2388 char buf
[DECIMAL_STR_MAX(unsigned) + 1];
2389 IPv6PrivacyExtensions s
;
2390 const char *p
= NULL
;
2393 s
= link_ipv6_privacy_extensions(link
);
2397 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/use_tempaddr");
2398 xsprintf(buf
, "%u", (unsigned) link
->network
->ipv6_privacy_extensions
);
2400 r
= write_string_file(p
, buf
, WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2402 log_link_warning_errno(link
, r
, "Cannot configure IPv6 privacy extension for interface: %m");
2407 static int link_set_ipv6_accept_ra(Link
*link
) {
2408 const char *p
= NULL
;
2411 /* Make this a NOP if IPv6 is not available */
2412 if (!socket_ipv6_is_supported())
2415 if (link
->flags
& IFF_LOOPBACK
)
2421 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/accept_ra");
2423 /* We handle router advertisements ourselves, tell the kernel to GTFO */
2424 r
= write_string_file(p
, "0", WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2426 log_link_warning_errno(link
, r
, "Cannot disable kernel IPv6 accept_ra for interface: %m");
2431 static int link_set_ipv6_dad_transmits(Link
*link
) {
2432 char buf
[DECIMAL_STR_MAX(int) + 1];
2433 const char *p
= NULL
;
2436 /* Make this a NOP if IPv6 is not available */
2437 if (!socket_ipv6_is_supported())
2440 if (link
->flags
& IFF_LOOPBACK
)
2446 if (link
->network
->ipv6_dad_transmits
< 0)
2449 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/dad_transmits");
2450 xsprintf(buf
, "%i", link
->network
->ipv6_dad_transmits
);
2452 r
= write_string_file(p
, buf
, WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2454 log_link_warning_errno(link
, r
, "Cannot set IPv6 dad transmits for interface: %m");
2459 static int link_set_ipv6_hop_limit(Link
*link
) {
2460 char buf
[DECIMAL_STR_MAX(int) + 1];
2461 const char *p
= NULL
;
2464 /* Make this a NOP if IPv6 is not available */
2465 if (!socket_ipv6_is_supported())
2468 if (link
->flags
& IFF_LOOPBACK
)
2474 if (link
->network
->ipv6_hop_limit
< 0)
2477 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/hop_limit");
2478 xsprintf(buf
, "%i", link
->network
->ipv6_hop_limit
);
2480 r
= write_string_file(p
, buf
, WRITE_STRING_FILE_VERIFY_ON_FAILURE
);
2482 log_link_warning_errno(link
, r
, "Cannot set IPv6 hop limit for interface: %m");
2487 static int link_drop_foreign_config(Link
*link
) {
2493 SET_FOREACH(address
, link
->addresses_foreign
, i
) {
2494 /* we consider IPv6LL addresses to be managed by the kernel */
2495 if (address
->family
== AF_INET6
&& in_addr_is_link_local(AF_INET6
, &address
->in_addr
) == 1)
2498 r
= address_remove(address
, link
, link_address_remove_handler
);
2503 SET_FOREACH(route
, link
->routes_foreign
, i
) {
2504 /* do not touch routes managed by the kernel */
2505 if (route
->protocol
== RTPROT_KERNEL
)
2508 r
= route_remove(route
, link
, link_route_remove_handler
);
2516 static int link_drop_config(Link
*link
) {
2517 Address
*address
, *pool_address
;
2522 SET_FOREACH(address
, link
->addresses
, i
) {
2523 /* we consider IPv6LL addresses to be managed by the kernel */
2524 if (address
->family
== AF_INET6
&& in_addr_is_link_local(AF_INET6
, &address
->in_addr
) == 1)
2527 r
= address_remove(address
, link
, link_address_remove_handler
);
2531 /* If this address came from an address pool, clean up the pool */
2532 LIST_FOREACH(addresses
, pool_address
, link
->pool_addresses
) {
2533 if (address_equal(address
, pool_address
)) {
2534 LIST_REMOVE(addresses
, link
->pool_addresses
, pool_address
);
2535 address_free(pool_address
);
2541 SET_FOREACH(route
, link
->routes
, i
) {
2542 /* do not touch routes managed by the kernel */
2543 if (route
->protocol
== RTPROT_KERNEL
)
2546 r
= route_remove(route
, link
, link_route_remove_handler
);
2556 static int link_update_lldp(Link
*link
) {
2564 if (link
->flags
& IFF_UP
) {
2565 r
= sd_lldp_start(link
->lldp
);
2567 log_link_debug(link
, "Started LLDP.");
2569 r
= sd_lldp_stop(link
->lldp
);
2571 log_link_debug(link
, "Stopped LLDP.");
2577 static int link_configure(Link
*link
) {
2581 assert(link
->network
);
2582 assert(link
->state
== LINK_STATE_PENDING
);
2584 if (streq_ptr(link
->kind
, "vcan")) {
2586 if (!(link
->flags
& IFF_UP
)) {
2587 r
= link_up_can(link
);
2589 link_enter_failed(link
);
2597 /* Drop foreign config, but ignore loopback or critical devices.
2598 * We do not want to remove loopback address or addresses used for root NFS. */
2599 if (!(link
->flags
& IFF_LOOPBACK
) && !(link
->network
->dhcp_critical
)) {
2600 r
= link_drop_foreign_config(link
);
2605 r
= link_set_proxy_arp(link
);
2609 r
= ipv6_proxy_ndp_addresses_configure(link
);
2613 r
= link_set_ipv4_forward(link
);
2617 r
= link_set_ipv6_forward(link
);
2621 r
= link_set_ipv6_privacy_extensions(link
);
2625 r
= link_set_ipv6_accept_ra(link
);
2629 r
= link_set_ipv6_dad_transmits(link
);
2633 r
= link_set_ipv6_hop_limit(link
);
2637 r
= link_set_flags(link
);
2641 if (link_ipv4ll_enabled(link
)) {
2642 r
= ipv4ll_configure(link
);
2647 if (link_dhcp4_enabled(link
)) {
2648 r
= dhcp4_set_promote_secondaries(link
);
2652 r
= dhcp4_configure(link
);
2657 if (link_dhcp4_server_enabled(link
)) {
2658 r
= sd_dhcp_server_new(&link
->dhcp_server
, link
->ifindex
);
2662 r
= sd_dhcp_server_attach_event(link
->dhcp_server
, NULL
, 0);
2667 if (link_dhcp6_enabled(link
) ||
2668 link_ipv6_accept_ra_enabled(link
)) {
2669 r
= dhcp6_configure(link
);
2674 if (link_ipv6_accept_ra_enabled(link
)) {
2675 r
= ndisc_configure(link
);
2680 if (link_radv_enabled(link
)) {
2681 r
= radv_configure(link
);
2686 if (link_lldp_rx_enabled(link
)) {
2687 r
= sd_lldp_new(&link
->lldp
);
2691 r
= sd_lldp_set_ifindex(link
->lldp
, link
->ifindex
);
2695 r
= sd_lldp_match_capabilities(link
->lldp
,
2696 link
->network
->lldp_mode
== LLDP_MODE_ROUTERS_ONLY
?
2697 SD_LLDP_SYSTEM_CAPABILITIES_ALL_ROUTERS
:
2698 SD_LLDP_SYSTEM_CAPABILITIES_ALL
);
2702 r
= sd_lldp_set_filter_address(link
->lldp
, &link
->mac
);
2706 r
= sd_lldp_attach_event(link
->lldp
, NULL
, 0);
2710 r
= sd_lldp_set_callback(link
->lldp
, lldp_handler
, link
);
2714 r
= link_update_lldp(link
);
2719 if (link_has_carrier(link
) || link
->network
->configure_without_carrier
) {
2720 r
= link_acquire_conf(link
);
2725 return link_enter_join_netdev(link
);
2728 static int link_initialized_and_synced(sd_netlink
*rtnl
, sd_netlink_message
*m
,
2730 _cleanup_link_unref_ Link
*link
= userdata
;
2735 assert(link
->ifname
);
2736 assert(link
->manager
);
2738 if (link
->state
!= LINK_STATE_PENDING
)
2741 log_link_debug(link
, "Link state is up-to-date");
2743 r
= link_new_bound_by_list(link
);
2747 r
= link_handle_bound_by_list(link
);
2751 if (!link
->network
) {
2752 r
= network_get(link
->manager
, link
->udev_device
, link
->ifname
,
2753 &link
->mac
, &network
);
2755 link_enter_unmanaged(link
);
2757 } else if (r
== 0 && network
->unmanaged
) {
2758 link_enter_unmanaged(link
);
2763 if (link
->flags
& IFF_LOOPBACK
) {
2764 if (network
->link_local
!= ADDRESS_FAMILY_NO
)
2765 log_link_debug(link
, "Ignoring link-local autoconfiguration for loopback link");
2767 if (network
->dhcp
!= ADDRESS_FAMILY_NO
)
2768 log_link_debug(link
, "Ignoring DHCP clients for loopback link");
2770 if (network
->dhcp_server
)
2771 log_link_debug(link
, "Ignoring DHCP server for loopback link");
2774 r
= network_apply(network
, link
);
2779 r
= link_new_bound_to_list(link
);
2783 r
= link_configure(link
);
2790 int link_initialized(Link
*link
, struct udev_device
*device
) {
2791 _cleanup_(sd_netlink_message_unrefp
) sd_netlink_message
*req
= NULL
;
2795 assert(link
->manager
);
2796 assert(link
->manager
->rtnl
);
2799 if (link
->state
!= LINK_STATE_PENDING
)
2802 if (link
->udev_device
)
2805 log_link_debug(link
, "udev initialized link");
2807 link
->udev_device
= udev_device_ref(device
);
2809 /* udev has initialized the link, but we don't know if we have yet
2810 * processed the NEWLINK messages with the latest state. Do a GETLINK,
2811 * when it returns we know that the pending NEWLINKs have already been
2812 * processed and that we are up-to-date */
2814 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_GETLINK
,
2819 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
,
2820 link_initialized_and_synced
, link
, 0, NULL
);
2829 static int link_load(Link
*link
) {
2830 _cleanup_free_
char *network_file
= NULL
,
2833 *dhcp4_address
= NULL
,
2834 *ipv4ll_address
= NULL
;
2835 union in_addr_union address
;
2836 union in_addr_union route_dst
;
2842 r
= parse_env_file(link
->state_file
, NEWLINE
,
2843 "NETWORK_FILE", &network_file
,
2844 "ADDRESSES", &addresses
,
2846 "DHCP4_ADDRESS", &dhcp4_address
,
2847 "IPV4LL_ADDRESS", &ipv4ll_address
,
2849 if (r
< 0 && r
!= -ENOENT
)
2850 return log_link_error_errno(link
, r
, "Failed to read %s: %m", link
->state_file
);
2857 suffix
= strrchr(network_file
, '.');
2859 log_link_debug(link
, "Failed to get network name from %s", network_file
);
2860 goto network_file_fail
;
2864 r
= network_get_by_name(link
->manager
, basename(network_file
), &network
);
2866 log_link_debug_errno(link
, r
, "Failed to get network %s: %m", basename(network_file
));
2867 goto network_file_fail
;
2870 r
= network_apply(network
, link
);
2872 return log_link_error_errno(link
, r
, "Failed to apply network %s: %m", basename(network_file
));
2881 _cleanup_free_
char *address_str
= NULL
;
2882 char *prefixlen_str
;
2884 unsigned char prefixlen
;
2886 r
= extract_first_word(&p
, &address_str
, NULL
, 0);
2888 log_link_debug_errno(link
, r
, "Failed to extract next address string: %m");
2894 prefixlen_str
= strchr(address_str
, '/');
2895 if (!prefixlen_str
) {
2896 log_link_debug(link
, "Failed to parse address and prefix length %s", address_str
);
2900 *prefixlen_str
++ = '\0';
2902 r
= sscanf(prefixlen_str
, "%hhu", &prefixlen
);
2904 log_link_error(link
, "Failed to parse prefixlen %s", prefixlen_str
);
2908 r
= in_addr_from_string_auto(address_str
, &family
, &address
);
2910 log_link_debug_errno(link
, r
, "Failed to parse address %s: %m", address_str
);
2914 r
= address_add(link
, family
, &address
, prefixlen
, NULL
);
2916 return log_link_error_errno(link
, r
, "Failed to add address: %m");
2925 _cleanup_free_
char *route_str
= NULL
;
2926 _cleanup_(sd_event_source_unrefp
) sd_event_source
*expire
= NULL
;
2928 char *prefixlen_str
;
2930 unsigned char prefixlen
, tos
, table
;
2933 r
= extract_first_word(&p
, &route_str
, NULL
, 0);
2935 log_link_debug_errno(link
, r
, "Failed to extract next route string: %m");
2941 prefixlen_str
= strchr(route_str
, '/');
2942 if (!prefixlen_str
) {
2943 log_link_debug(link
, "Failed to parse route %s", route_str
);
2947 *prefixlen_str
++ = '\0';
2949 r
= sscanf(prefixlen_str
, "%hhu/%hhu/%"SCNu32
"/%hhu/"USEC_FMT
, &prefixlen
, &tos
, &priority
, &table
, &lifetime
);
2951 log_link_debug(link
,
2952 "Failed to parse destination prefix length, tos, priority, table or expiration %s",
2957 r
= in_addr_from_string_auto(route_str
, &family
, &route_dst
);
2959 log_link_debug_errno(link
, r
, "Failed to parse route destination %s: %m", route_str
);
2963 r
= route_add(link
, family
, &route_dst
, prefixlen
, tos
, priority
, table
, &route
);
2965 return log_link_error_errno(link
, r
, "Failed to add route: %m");
2967 if (lifetime
!= USEC_INFINITY
) {
2968 r
= sd_event_add_time(link
->manager
->event
, &expire
, clock_boottime_or_monotonic(), lifetime
,
2969 0, route_expire_handler
, route
);
2971 log_link_warning_errno(link
, r
, "Could not arm route expiration handler: %m");
2974 route
->lifetime
= lifetime
;
2975 sd_event_source_unref(route
->expire
);
2976 route
->expire
= expire
;
2981 if (dhcp4_address
) {
2982 r
= in_addr_from_string(AF_INET
, dhcp4_address
, &address
);
2984 log_link_debug_errno(link
, r
, "Failed to parse DHCPv4 address %s: %m", dhcp4_address
);
2985 goto dhcp4_address_fail
;
2988 r
= sd_dhcp_client_new(&link
->dhcp_client
, link
->network
->dhcp_anonymize
);
2990 return log_link_error_errno(link
, r
, "Failed to create DHCPv4 client: %m");
2992 r
= sd_dhcp_client_set_request_address(link
->dhcp_client
, &address
.in
);
2994 return log_link_error_errno(link
, r
, "Failed to set initial DHCPv4 address %s: %m", dhcp4_address
);
2999 if (ipv4ll_address
) {
3000 r
= in_addr_from_string(AF_INET
, ipv4ll_address
, &address
);
3002 log_link_debug_errno(link
, r
, "Failed to parse IPv4LL address %s: %m", ipv4ll_address
);
3003 goto ipv4ll_address_fail
;
3006 r
= sd_ipv4ll_new(&link
->ipv4ll
);
3008 return log_link_error_errno(link
, r
, "Failed to create IPv4LL client: %m");
3010 r
= sd_ipv4ll_set_address(link
->ipv4ll
, &address
.in
);
3012 return log_link_error_errno(link
, r
, "Failed to set initial IPv4LL address %s: %m", ipv4ll_address
);
3015 ipv4ll_address_fail
:
3020 int link_add(Manager
*m
, sd_netlink_message
*message
, Link
**ret
) {
3022 _cleanup_udev_device_unref_
struct udev_device
*device
= NULL
;
3023 char ifindex_str
[2 + DECIMAL_STR_MAX(int)];
3031 r
= link_new(m
, message
, ret
);
3037 log_link_debug(link
, "Link %d added", link
->ifindex
);
3039 r
= link_load(link
);
3043 if (detect_container() <= 0) {
3044 /* not in a container, udev will be around */
3045 sprintf(ifindex_str
, "n%d", link
->ifindex
);
3046 device
= udev_device_new_from_device_id(m
->udev
, ifindex_str
);
3048 r
= log_link_warning_errno(link
, errno
, "Could not find udev device: %m");
3052 if (udev_device_get_is_initialized(device
) <= 0) {
3054 log_link_debug(link
, "link pending udev initialization...");
3058 r
= link_initialized(link
, device
);
3062 /* we are calling a callback directly, so must take a ref */
3065 r
= link_initialized_and_synced(m
->rtnl
, NULL
, link
);
3072 link_enter_failed(link
);
3076 int link_ipv6ll_gained(Link
*link
, const struct in6_addr
*address
) {
3081 log_link_info(link
, "Gained IPv6LL");
3083 link
->ipv6ll_address
= *address
;
3084 link_check_ready(link
);
3086 if (!IN_SET(link
->state
, LINK_STATE_PENDING
, LINK_STATE_UNMANAGED
, LINK_STATE_FAILED
)) {
3087 r
= link_acquire_ipv6_conf(link
);
3089 link_enter_failed(link
);
3097 static int link_carrier_gained(Link
*link
) {
3102 if (!IN_SET(link
->state
, LINK_STATE_PENDING
, LINK_STATE_UNMANAGED
, LINK_STATE_FAILED
)) {
3103 r
= link_acquire_conf(link
);
3105 link_enter_failed(link
);
3109 r
= link_enter_set_addresses(link
);
3114 r
= link_handle_bound_by_list(link
);
3121 static int link_carrier_lost(Link
*link
) {
3126 /* Some devices reset itself while setting the MTU. This causes the DHCP client fall into a loop.
3127 setting_mtu keep track whether the device got reset because of setting MTU and does not drop the
3128 configuration and stop the clients as well. */
3129 if (link
->setting_mtu
)
3132 r
= link_stop_clients(link
);
3134 link_enter_failed(link
);
3138 if (link_dhcp4_server_enabled(link
))
3139 (void) sd_dhcp_server_stop(link
->dhcp_server
);
3141 r
= link_drop_config(link
);
3145 if (!IN_SET(link
->state
, LINK_STATE_UNMANAGED
, LINK_STATE_PENDING
)) {
3146 log_link_debug(link
, "State is %s, dropping config", link_state_to_string(link
->state
));
3147 r
= link_drop_foreign_config(link
);
3152 r
= link_handle_bound_by_list(link
);
3159 int link_carrier_reset(Link
*link
) {
3164 if (link_has_carrier(link
)) {
3165 r
= link_carrier_lost(link
);
3169 r
= link_carrier_gained(link
);
3173 log_link_info(link
, "Reset carrier");
3179 int link_update(Link
*link
, sd_netlink_message
*m
) {
3180 struct ether_addr mac
;
3183 bool had_carrier
, carrier_gained
, carrier_lost
;
3187 assert(link
->ifname
);
3190 if (link
->state
== LINK_STATE_LINGER
) {
3192 log_link_info(link
, "Link readded");
3193 link_set_state(link
, LINK_STATE_ENSLAVING
);
3195 r
= link_new_carrier_maps(link
);
3200 r
= sd_netlink_message_read_string(m
, IFLA_IFNAME
, &ifname
);
3201 if (r
>= 0 && !streq(ifname
, link
->ifname
)) {
3202 log_link_info(link
, "Interface name change detected, %s has been renamed to %s.", link
->ifname
, ifname
);
3204 link_free_carrier_maps(link
);
3206 r
= free_and_strdup(&link
->ifname
, ifname
);
3210 r
= link_new_carrier_maps(link
);
3215 r
= sd_netlink_message_read_u32(m
, IFLA_MTU
, &mtu
);
3216 if (r
>= 0 && mtu
> 0) {
3218 if (!link
->original_mtu
) {
3219 link
->original_mtu
= mtu
;
3220 log_link_debug(link
, "Saved original MTU: %" PRIu32
, link
->original_mtu
);
3223 if (link
->dhcp_client
) {
3224 r
= sd_dhcp_client_set_mtu(link
->dhcp_client
,
3227 log_link_warning_errno(link
, r
, "Could not update MTU in DHCP client: %m");
3233 r
= sd_radv_set_mtu(link
->radv
, link
->mtu
);
3235 return log_link_warning_errno(link
, r
, "Could not set MTU for Router Advertisement: %m");
3239 /* The kernel may broadcast NEWLINK messages without the MAC address
3240 set, simply ignore them. */
3241 r
= sd_netlink_message_read_ether_addr(m
, IFLA_ADDRESS
, &mac
);
3243 if (memcmp(link
->mac
.ether_addr_octet
, mac
.ether_addr_octet
,
3246 memcpy(link
->mac
.ether_addr_octet
, mac
.ether_addr_octet
,
3249 log_link_debug(link
, "MAC address: "
3250 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
3251 mac
.ether_addr_octet
[0],
3252 mac
.ether_addr_octet
[1],
3253 mac
.ether_addr_octet
[2],
3254 mac
.ether_addr_octet
[3],
3255 mac
.ether_addr_octet
[4],
3256 mac
.ether_addr_octet
[5]);
3259 r
= sd_ipv4ll_set_mac(link
->ipv4ll
, &link
->mac
);
3261 return log_link_warning_errno(link
, r
, "Could not update MAC address in IPv4LL client: %m");
3264 if (link
->dhcp_client
) {
3265 r
= sd_dhcp_client_set_mac(link
->dhcp_client
,
3266 (const uint8_t *) &link
->mac
,
3270 return log_link_warning_errno(link
, r
, "Could not update MAC address in DHCP client: %m");
3272 switch (link
->network
->dhcp_client_identifier
) {
3273 case DHCP_CLIENT_ID_DUID
: {
3274 const DUID
*duid
= link_duid(link
);
3276 r
= sd_dhcp_client_set_iaid_duid(link
->dhcp_client
,
3277 link
->network
->iaid
,
3279 duid
->raw_data_len
> 0 ? duid
->raw_data
: NULL
,
3280 duid
->raw_data_len
);
3282 return log_link_warning_errno(link
, r
, "Could not update DUID/IAID in DHCP client: %m");
3285 case DHCP_CLIENT_ID_MAC
:
3286 r
= sd_dhcp_client_set_client_id(link
->dhcp_client
,
3288 (const uint8_t *)&link
->mac
,
3291 return log_link_warning_errno(link
, r
, "Could not update MAC client id in DHCP client: %m");
3294 assert_not_reached("Unknown client identifier type.");
3298 if (link
->dhcp6_client
) {
3299 const DUID
* duid
= link_duid(link
);
3301 r
= sd_dhcp6_client_set_mac(link
->dhcp6_client
,
3302 (const uint8_t *) &link
->mac
,
3306 return log_link_warning_errno(link
, r
, "Could not update MAC address in DHCPv6 client: %m");
3308 r
= sd_dhcp6_client_set_iaid(link
->dhcp6_client
,
3309 link
->network
->iaid
);
3311 return log_link_warning_errno(link
, r
, "Could not update DHCPv6 IAID: %m");
3313 r
= sd_dhcp6_client_set_duid(link
->dhcp6_client
,
3315 duid
->raw_data_len
> 0 ? duid
->raw_data
: NULL
,
3316 duid
->raw_data_len
);
3318 return log_link_warning_errno(link
, r
, "Could not update DHCPv6 DUID: %m");
3322 r
= sd_radv_set_mac(link
->radv
, &link
->mac
);
3324 return log_link_warning_errno(link
, r
, "Could not update MAC for Router Advertisement: %m");
3328 r
= sd_ndisc_set_mac(link
->ndisc
, &link
->mac
);
3330 return log_link_warning_errno(link
, r
, "Could not update MAC for ndisc: %m");
3335 had_carrier
= link_has_carrier(link
);
3337 r
= link_update_flags(link
, m
);
3341 r
= link_update_lldp(link
);
3345 carrier_gained
= !had_carrier
&& link_has_carrier(link
);
3346 carrier_lost
= had_carrier
&& !link_has_carrier(link
);
3348 if (carrier_gained
) {
3349 log_link_info(link
, "Gained carrier");
3351 r
= link_carrier_gained(link
);
3354 } else if (carrier_lost
) {
3355 log_link_info(link
, "Lost carrier");
3357 r
= link_carrier_lost(link
);
3365 static void print_link_hashmap(FILE *f
, const char *prefix
, Hashmap
* h
) {
3373 if (hashmap_isempty(h
))
3377 HASHMAP_FOREACH(link
, h
, i
) {
3381 fprintf(f
, "%i", link
->ifindex
);
3388 int link_save(Link
*link
) {
3389 _cleanup_free_
char *temp_path
= NULL
;
3390 _cleanup_fclose_
FILE *f
= NULL
;
3391 const char *admin_state
, *oper_state
;
3398 assert(link
->state_file
);
3399 assert(link
->lease_file
);
3400 assert(link
->manager
);
3402 if (link
->state
== LINK_STATE_LINGER
) {
3403 unlink(link
->state_file
);
3407 link_lldp_save(link
);
3409 admin_state
= link_state_to_string(link
->state
);
3410 assert(admin_state
);
3412 oper_state
= link_operstate_to_string(link
->operstate
);
3415 r
= fopen_temporary(link
->state_file
, &f
, &temp_path
);
3419 (void) __fsetlocking(f
, FSETLOCKING_BYCALLER
);
3420 (void) fchmod(fileno(f
), 0644);
3423 "# This is private data. Do not parse.\n"
3426 admin_state
, oper_state
);
3428 if (link
->network
) {
3430 sd_dhcp6_lease
*dhcp6_lease
= NULL
;
3431 const char *dhcp_domainname
= NULL
;
3432 char **dhcp6_domains
= NULL
;
3433 char **dhcp_domains
= NULL
;
3436 fprintf(f
, "REQUIRED_FOR_ONLINE=%s\n",
3437 yes_no(link
->network
->required_for_online
));
3439 if (link
->dhcp6_client
) {
3440 r
= sd_dhcp6_client_get_lease(link
->dhcp6_client
, &dhcp6_lease
);
3441 if (r
< 0 && r
!= -ENOMSG
)
3442 log_link_debug(link
, "No DHCPv6 lease");
3445 fprintf(f
, "NETWORK_FILE=%s\n", link
->network
->filename
);
3450 for (j
= 0; j
< link
->network
->n_dns
; j
++) {
3451 _cleanup_free_
char *b
= NULL
;
3453 r
= in_addr_to_string(link
->network
->dns
[j
].family
,
3454 &link
->network
->dns
[j
].address
, &b
);
3456 log_debug_errno(r
, "Failed to format address, ignoring: %m");
3466 if (link
->network
->dhcp_use_dns
&&
3468 const struct in_addr
*addresses
;
3470 r
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &addresses
);
3474 serialize_in_addrs(f
, addresses
, r
);
3479 if (link
->network
->dhcp_use_dns
&& dhcp6_lease
) {
3480 struct in6_addr
*in6_addrs
;
3482 r
= sd_dhcp6_lease_get_dns(dhcp6_lease
, &in6_addrs
);
3486 serialize_in6_addrs(f
, in6_addrs
, r
);
3491 /* Make sure to flush out old entries before we use the NDISC data */
3494 if (link
->network
->dhcp_use_dns
&& link
->ndisc_rdnss
) {
3497 SET_FOREACH(dd
, link
->ndisc_rdnss
, i
) {
3501 serialize_in6_addrs(f
, &dd
->address
, 1);
3510 fputstrv(f
, link
->network
->ntp
, NULL
, &space
);
3512 if (link
->network
->dhcp_use_ntp
&&
3514 const struct in_addr
*addresses
;
3516 r
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &addresses
);
3520 serialize_in_addrs(f
, addresses
, r
);
3525 if (link
->network
->dhcp_use_ntp
&& dhcp6_lease
) {
3526 struct in6_addr
*in6_addrs
;
3529 r
= sd_dhcp6_lease_get_ntp_addrs(dhcp6_lease
,
3534 serialize_in6_addrs(f
, in6_addrs
, r
);
3538 r
= sd_dhcp6_lease_get_ntp_fqdn(dhcp6_lease
, &hosts
);
3540 fputstrv(f
, hosts
, NULL
, &space
);
3545 if (link
->network
->dhcp_use_domains
!= DHCP_USE_DOMAINS_NO
) {
3546 if (link
->dhcp_lease
) {
3547 (void) sd_dhcp_lease_get_domainname(link
->dhcp_lease
, &dhcp_domainname
);
3548 (void) sd_dhcp_lease_get_search_domains(link
->dhcp_lease
, &dhcp_domains
);
3551 (void) sd_dhcp6_lease_get_domains(dhcp6_lease
, &dhcp6_domains
);
3554 fputs("DOMAINS=", f
);
3556 fputstrv(f
, link
->network
->search_domains
, NULL
, &space
);
3558 if (link
->network
->dhcp_use_domains
== DHCP_USE_DOMAINS_YES
) {
3561 if (dhcp_domainname
)
3562 fputs_with_space(f
, dhcp_domainname
, NULL
, &space
);
3564 fputstrv(f
, dhcp_domains
, NULL
, &space
);
3566 fputstrv(f
, dhcp6_domains
, NULL
, &space
);
3568 SET_FOREACH(dd
, link
->ndisc_dnssl
, i
)
3569 fputs_with_space(f
, NDISC_DNSSL_DOMAIN(dd
), NULL
, &space
);
3574 fputs("ROUTE_DOMAINS=", f
);
3576 fputstrv(f
, link
->network
->route_domains
, NULL
, &space
);
3578 if (link
->network
->dhcp_use_domains
== DHCP_USE_DOMAINS_ROUTE
) {
3581 if (dhcp_domainname
)
3582 fputs_with_space(f
, dhcp_domainname
, NULL
, &space
);
3584 fputstrv(f
, dhcp_domains
, NULL
, &space
);
3586 fputstrv(f
, dhcp6_domains
, NULL
, &space
);
3588 SET_FOREACH(dd
, link
->ndisc_dnssl
, i
)
3589 fputs_with_space(f
, NDISC_DNSSL_DOMAIN(dd
), NULL
, &space
);
3594 fprintf(f
, "LLMNR=%s\n",
3595 resolve_support_to_string(link
->network
->llmnr
));
3596 fprintf(f
, "MDNS=%s\n",
3597 resolve_support_to_string(link
->network
->mdns
));
3599 if (link
->network
->dnssec_mode
!= _DNSSEC_MODE_INVALID
)
3600 fprintf(f
, "DNSSEC=%s\n",
3601 dnssec_mode_to_string(link
->network
->dnssec_mode
));
3603 if (!set_isempty(link
->network
->dnssec_negative_trust_anchors
)) {
3606 fputs("DNSSEC_NTA=", f
);
3608 SET_FOREACH(n
, link
->network
->dnssec_negative_trust_anchors
, i
)
3609 fputs_with_space(f
, n
, NULL
, &space
);
3613 fputs("ADDRESSES=", f
);
3615 SET_FOREACH(a
, link
->addresses
, i
) {
3616 _cleanup_free_
char *address_str
= NULL
;
3618 r
= in_addr_to_string(a
->family
, &a
->in_addr
, &address_str
);
3622 fprintf(f
, "%s%s/%u", space
? " " : "", address_str
, a
->prefixlen
);
3627 fputs("ROUTES=", f
);
3629 SET_FOREACH(route
, link
->routes
, i
) {
3630 _cleanup_free_
char *route_str
= NULL
;
3632 r
= in_addr_to_string(route
->family
, &route
->dst
, &route_str
);
3636 fprintf(f
, "%s%s/%hhu/%hhu/%"PRIu32
"/%"PRIu32
"/"USEC_FMT
,
3637 space
? " " : "", route_str
,
3638 route
->dst_prefixlen
, route
->tos
, route
->priority
, route
->table
, route
->lifetime
);
3645 print_link_hashmap(f
, "CARRIER_BOUND_TO=", link
->bound_to_links
);
3646 print_link_hashmap(f
, "CARRIER_BOUND_BY=", link
->bound_by_links
);
3648 if (link
->dhcp_lease
) {
3649 struct in_addr address
;
3650 const char *tz
= NULL
;
3652 assert(link
->network
);
3654 r
= sd_dhcp_lease_get_timezone(link
->dhcp_lease
, &tz
);
3656 fprintf(f
, "TIMEZONE=%s\n", tz
);
3658 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &address
);
3660 fputs("DHCP4_ADDRESS=", f
);
3661 serialize_in_addrs(f
, &address
, 1);
3665 r
= dhcp_lease_save(link
->dhcp_lease
, link
->lease_file
);
3673 unlink(link
->lease_file
);
3676 struct in_addr address
;
3678 r
= sd_ipv4ll_get_address(link
->ipv4ll
, &address
);
3680 fputs("IPV4LL_ADDRESS=", f
);
3681 serialize_in_addrs(f
, &address
, 1);
3686 r
= fflush_and_check(f
);
3690 if (rename(temp_path
, link
->state_file
) < 0) {
3698 (void) unlink(link
->state_file
);
3700 (void) unlink(temp_path
);
3702 return log_link_error_errno(link
, r
, "Failed to save link data to %s: %m", link
->state_file
);
3705 /* The serialized state in /run is no longer up-to-date. */
3706 void link_dirty(Link
*link
) {
3711 /* mark manager dirty as link is dirty */
3712 manager_dirty(link
->manager
);
3714 r
= set_ensure_allocated(&link
->manager
->dirty_links
, NULL
);
3716 /* allocation errors are ignored */
3719 r
= set_put(link
->manager
->dirty_links
, link
);
3721 /* don't take another ref if the link was already dirty */
3727 /* The serialized state in /run is up-to-date */
3728 void link_clean(Link
*link
) {
3730 assert(link
->manager
);
3732 set_remove(link
->manager
->dirty_links
, link
);
3736 static const char* const link_state_table
[_LINK_STATE_MAX
] = {
3737 [LINK_STATE_PENDING
] = "pending",
3738 [LINK_STATE_ENSLAVING
] = "configuring",
3739 [LINK_STATE_SETTING_ADDRESSES
] = "configuring",
3740 [LINK_STATE_SETTING_ROUTES
] = "configuring",
3741 [LINK_STATE_CONFIGURED
] = "configured",
3742 [LINK_STATE_UNMANAGED
] = "unmanaged",
3743 [LINK_STATE_FAILED
] = "failed",
3744 [LINK_STATE_LINGER
] = "linger",
3747 DEFINE_STRING_TABLE_LOOKUP(link_state
, LinkState
);
3749 static const char* const link_operstate_table
[_LINK_OPERSTATE_MAX
] = {
3750 [LINK_OPERSTATE_OFF
] = "off",
3751 [LINK_OPERSTATE_NO_CARRIER
] = "no-carrier",
3752 [LINK_OPERSTATE_DORMANT
] = "dormant",
3753 [LINK_OPERSTATE_CARRIER
] = "carrier",
3754 [LINK_OPERSTATE_DEGRADED
] = "degraded",
3755 [LINK_OPERSTATE_ROUTABLE
] = "routable",
3758 DEFINE_STRING_TABLE_LOOKUP(link_operstate
, LinkOperationalState
);