1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Tom Gundersen <teg@jklm.no>
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <netinet/ether.h>
29 #include "socket-util.h"
31 #include "udev-util.h"
32 #include "network-internal.h"
33 #include "networkd-link.h"
34 #include "networkd-netdev.h"
36 bool link_dhcp6_enabled(Link
*link
) {
37 if (link
->flags
& IFF_LOOPBACK
)
43 return link
->network
->dhcp
& ADDRESS_FAMILY_IPV6
;
46 bool link_dhcp4_enabled(Link
*link
) {
47 if (link
->flags
& IFF_LOOPBACK
)
53 return link
->network
->dhcp
& ADDRESS_FAMILY_IPV4
;
56 bool link_dhcp4_server_enabled(Link
*link
) {
57 if (link
->flags
& IFF_LOOPBACK
)
63 return link
->network
->dhcp_server
;
66 bool link_ipv4ll_enabled(Link
*link
) {
67 if (link
->flags
& IFF_LOOPBACK
)
73 return link
->network
->link_local
& ADDRESS_FAMILY_IPV4
;
76 bool link_ipv6ll_enabled(Link
*link
) {
77 if (link
->flags
& IFF_LOOPBACK
)
83 return link
->network
->link_local
& ADDRESS_FAMILY_IPV6
;
86 bool link_lldp_enabled(Link
*link
) {
87 if (link
->flags
& IFF_LOOPBACK
)
93 if (link
->network
->bridge
)
96 return link
->network
->lldp
;
99 static bool link_ipv4_forward_enabled(Link
*link
) {
100 if (link
->flags
& IFF_LOOPBACK
)
106 return link
->network
->ip_forward
& ADDRESS_FAMILY_IPV4
;
109 static bool link_ipv6_forward_enabled(Link
*link
) {
110 if (link
->flags
& IFF_LOOPBACK
)
116 return link
->network
->ip_forward
& ADDRESS_FAMILY_IPV6
;
119 static IPv6PrivacyExtensions
link_ipv6_privacy_extensions(Link
*link
) {
120 if (link
->flags
& IFF_LOOPBACK
)
121 return _IPV6_PRIVACY_EXTENSIONS_INVALID
;
124 return _IPV6_PRIVACY_EXTENSIONS_INVALID
;
126 return link
->network
->ipv6_privacy_extensions
;
129 #define FLAG_STRING(string, flag, old, new) \
130 (((old ^ new) & flag) \
131 ? ((old & flag) ? (" -" string) : (" +" string)) \
134 static int link_update_flags(Link
*link
, sd_netlink_message
*m
) {
135 unsigned flags
, unknown_flags_added
, unknown_flags_removed
, unknown_flags
;
141 r
= sd_rtnl_message_link_get_flags(m
, &flags
);
143 return log_link_warning_errno(link
, r
, "Could not get link flags: %m");
145 r
= sd_netlink_message_read_u8(m
, IFLA_OPERSTATE
, &operstate
);
147 /* if we got a message without operstate, take it to mean
148 the state was unchanged */
149 operstate
= link
->kernel_operstate
;
151 if ((link
->flags
== flags
) && (link
->kernel_operstate
== operstate
))
154 if (link
->flags
!= flags
) {
155 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",
156 FLAG_STRING("LOOPBACK", IFF_LOOPBACK
, link
->flags
, flags
),
157 FLAG_STRING("MASTER", IFF_MASTER
, link
->flags
, flags
),
158 FLAG_STRING("SLAVE", IFF_SLAVE
, link
->flags
, flags
),
159 FLAG_STRING("UP", IFF_UP
, link
->flags
, flags
),
160 FLAG_STRING("DORMANT", IFF_DORMANT
, link
->flags
, flags
),
161 FLAG_STRING("LOWER_UP", IFF_LOWER_UP
, link
->flags
, flags
),
162 FLAG_STRING("RUNNING", IFF_RUNNING
, link
->flags
, flags
),
163 FLAG_STRING("MULTICAST", IFF_MULTICAST
, link
->flags
, flags
),
164 FLAG_STRING("BROADCAST", IFF_BROADCAST
, link
->flags
, flags
),
165 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT
, link
->flags
, flags
),
166 FLAG_STRING("PROMISC", IFF_PROMISC
, link
->flags
, flags
),
167 FLAG_STRING("ALLMULTI", IFF_ALLMULTI
, link
->flags
, flags
),
168 FLAG_STRING("PORTSEL", IFF_PORTSEL
, link
->flags
, flags
),
169 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA
, link
->flags
, flags
),
170 FLAG_STRING("DYNAMIC", IFF_DYNAMIC
, link
->flags
, flags
),
171 FLAG_STRING("NOARP", IFF_NOARP
, link
->flags
, flags
),
172 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS
, link
->flags
, flags
),
173 FLAG_STRING("DEBUG", IFF_DEBUG
, link
->flags
, flags
),
174 FLAG_STRING("ECHO", IFF_ECHO
, link
->flags
, flags
));
176 unknown_flags
= ~(IFF_LOOPBACK
| IFF_MASTER
| IFF_SLAVE
| IFF_UP
|
177 IFF_DORMANT
| IFF_LOWER_UP
| IFF_RUNNING
|
178 IFF_MULTICAST
| IFF_BROADCAST
| IFF_POINTOPOINT
|
179 IFF_PROMISC
| IFF_ALLMULTI
| IFF_PORTSEL
|
180 IFF_AUTOMEDIA
| IFF_DYNAMIC
| IFF_NOARP
|
181 IFF_NOTRAILERS
| IFF_DEBUG
| IFF_ECHO
);
182 unknown_flags_added
= ((link
->flags
^ flags
) & flags
& unknown_flags
);
183 unknown_flags_removed
= ((link
->flags
^ flags
) & link
->flags
& unknown_flags
);
185 /* link flags are currently at most 18 bits, let's align to
187 if (unknown_flags_added
)
189 "Unknown link flags gained: %#.5x (ignoring)",
190 unknown_flags_added
);
192 if (unknown_flags_removed
)
194 "Unknown link flags lost: %#.5x (ignoring)",
195 unknown_flags_removed
);
199 link
->kernel_operstate
= operstate
;
206 static int link_new(Manager
*manager
, sd_netlink_message
*message
, Link
**ret
) {
207 _cleanup_link_unref_ Link
*link
= NULL
;
216 r
= sd_netlink_message_get_type(message
, &type
);
219 else if (type
!= RTM_NEWLINK
)
222 r
= sd_rtnl_message_link_get_ifindex(message
, &ifindex
);
225 else if (ifindex
<= 0)
228 r
= sd_netlink_message_read_string(message
, IFLA_IFNAME
, &ifname
);
232 link
= new0(Link
, 1);
237 link
->manager
= manager
;
238 link
->state
= LINK_STATE_PENDING
;
239 link
->rtnl_extended_attrs
= true;
240 link
->ifindex
= ifindex
;
241 link
->ifname
= strdup(ifname
);
245 r
= sd_netlink_message_read_ether_addr(message
, IFLA_ADDRESS
, &link
->mac
);
247 log_link_debug(link
, "MAC address not found for new device, continuing without");
249 r
= asprintf(&link
->state_file
, "/run/systemd/netif/links/%d",
254 r
= asprintf(&link
->lease_file
, "/run/systemd/netif/leases/%d",
259 r
= asprintf(&link
->lldp_file
, "/run/systemd/netif/lldp/%d",
265 r
= hashmap_ensure_allocated(&manager
->links
, NULL
);
269 r
= hashmap_put(manager
->links
, INT_TO_PTR(link
->ifindex
), link
);
273 r
= link_update_flags(link
, message
);
283 static void link_free(Link
*link
) {
291 while ((address
= link
->addresses
)) {
292 LIST_REMOVE(addresses
, link
->addresses
, address
);
293 address_free(address
);
296 while ((address
= link
->pool_addresses
)) {
297 LIST_REMOVE(addresses
, link
->pool_addresses
, address
);
298 address_free(address
);
301 sd_dhcp_server_unref(link
->dhcp_server
);
302 sd_dhcp_client_unref(link
->dhcp_client
);
303 sd_dhcp_lease_unref(link
->dhcp_lease
);
305 free(link
->lease_file
);
307 sd_lldp_free(link
->lldp
);
309 free(link
->lldp_file
);
311 sd_ipv4ll_unref(link
->ipv4ll
);
312 sd_dhcp6_client_unref(link
->dhcp6_client
);
313 sd_icmp6_nd_unref(link
->icmp6_router_discovery
);
316 hashmap_remove(link
->manager
->links
, INT_TO_PTR(link
->ifindex
));
320 free(link
->state_file
);
322 udev_device_unref(link
->udev_device
);
324 HASHMAP_FOREACH (carrier
, link
->bound_to_links
, i
)
325 hashmap_remove(link
->bound_to_links
, INT_TO_PTR(carrier
->ifindex
));
326 hashmap_free(link
->bound_to_links
);
328 HASHMAP_FOREACH (carrier
, link
->bound_by_links
, i
)
329 hashmap_remove(link
->bound_by_links
, INT_TO_PTR(carrier
->ifindex
));
330 hashmap_free(link
->bound_by_links
);
335 Link
*link_unref(Link
*link
) {
336 if (link
&& (-- link
->n_ref
<= 0))
342 Link
*link_ref(Link
*link
) {
344 assert_se(++ link
->n_ref
>= 2);
349 int link_get(Manager
*m
, int ifindex
, Link
**ret
) {
356 link
= hashmap_get(m
->links
, INT_TO_PTR(ifindex
));
365 static void link_set_state(Link
*link
, LinkState state
) {
368 if (link
->state
== state
)
373 link_send_changed(link
, "AdministrativeState", NULL
);
378 static void link_enter_unmanaged(Link
*link
) {
381 log_link_debug(link
, "Unmanaged");
383 link_set_state(link
, LINK_STATE_UNMANAGED
);
388 static int link_stop_clients(Link
*link
) {
392 assert(link
->manager
);
393 assert(link
->manager
->event
);
398 if (link
->dhcp_client
) {
399 k
= sd_dhcp_client_stop(link
->dhcp_client
);
401 r
= log_link_warning_errno(link
, r
, "Could not stop DHCPv4 client: %m");
405 k
= sd_ipv4ll_stop(link
->ipv4ll
);
407 r
= log_link_warning_errno(link
, r
, "Could not stop IPv4 link-local: %m");
410 if(link
->icmp6_router_discovery
) {
411 if (link
->dhcp6_client
) {
412 k
= sd_dhcp6_client_stop(link
->dhcp6_client
);
414 r
= log_link_warning_errno(link
, r
, "Could not stop DHCPv6 client: %m");
417 k
= sd_icmp6_nd_stop(link
->icmp6_router_discovery
);
419 r
= log_link_warning_errno(link
, r
, "Could not stop ICMPv6 router discovery: %m");
423 k
= sd_lldp_stop(link
->lldp
);
425 r
= log_link_warning_errno(link
, r
, "Could not stop LLDP: %m");
431 void link_enter_failed(Link
*link
) {
434 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
437 log_link_warning(link
, "Failed");
439 link_set_state(link
, LINK_STATE_FAILED
);
441 link_stop_clients(link
);
446 static Address
* link_find_dhcp_server_address(Link
*link
) {
450 assert(link
->network
);
452 /* The first statically configured address if there is any */
453 LIST_FOREACH(addresses
, address
, link
->network
->static_addresses
) {
455 if (address
->family
!= AF_INET
)
458 if (in_addr_is_null(address
->family
, &address
->in_addr
))
464 /* If that didn't work, find a suitable address we got from the pool */
465 LIST_FOREACH(addresses
, address
, link
->pool_addresses
) {
466 if (address
->family
!= AF_INET
)
475 static int link_enter_configured(Link
*link
) {
477 assert(link
->network
);
478 assert(link
->state
== LINK_STATE_SETTING_ROUTES
);
480 log_link_info(link
, "Configured");
482 link_set_state(link
, LINK_STATE_CONFIGURED
);
489 void link_client_handler(Link
*link
) {
491 assert(link
->network
);
493 if (!link
->static_configured
)
496 if (link_ipv4ll_enabled(link
))
497 if (!link
->ipv4ll_address
||
501 if (link_dhcp4_enabled(link
) && !link
->dhcp4_configured
)
504 if (link
->state
!= LINK_STATE_CONFIGURED
)
505 link_enter_configured(link
);
510 static int route_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
511 _cleanup_link_unref_ Link
*link
= userdata
;
514 assert(link
->link_messages
> 0);
515 assert(IN_SET(link
->state
, LINK_STATE_SETTING_ADDRESSES
,
516 LINK_STATE_SETTING_ROUTES
, LINK_STATE_FAILED
,
519 link
->link_messages
--;
521 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
524 r
= sd_netlink_message_get_errno(m
);
525 if (r
< 0 && r
!= -EEXIST
)
526 log_link_warning_errno(link
, r
, "%-*s: could not set route: %m", IFNAMSIZ
, link
->ifname
);
528 if (link
->link_messages
== 0) {
529 log_link_debug(link
, "Routes set");
530 link
->static_configured
= true;
531 link_client_handler(link
);
537 static int link_enter_set_routes(Link
*link
) {
542 assert(link
->network
);
543 assert(link
->state
== LINK_STATE_SETTING_ADDRESSES
);
545 link_set_state(link
, LINK_STATE_SETTING_ROUTES
);
547 LIST_FOREACH(routes
, rt
, link
->network
->static_routes
) {
548 r
= route_configure(rt
, link
, &route_handler
);
550 log_link_warning_errno(link
, r
, "Could not set routes: %m");
551 link_enter_failed(link
);
555 link
->link_messages
++;
558 if (link
->link_messages
== 0) {
559 link
->static_configured
= true;
560 link_client_handler(link
);
562 log_link_debug(link
, "Setting routes");
567 int link_route_drop_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
568 _cleanup_link_unref_ Link
*link
= userdata
;
573 assert(link
->ifname
);
575 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
578 r
= sd_netlink_message_get_errno(m
);
579 if (r
< 0 && r
!= -ESRCH
)
580 log_link_warning_errno(link
, r
, "%-*s: could not drop route: %m", IFNAMSIZ
, link
->ifname
);
585 static int address_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
586 _cleanup_link_unref_ Link
*link
= userdata
;
592 assert(link
->ifname
);
593 assert(link
->link_messages
> 0);
594 assert(IN_SET(link
->state
, LINK_STATE_SETTING_ADDRESSES
,
595 LINK_STATE_FAILED
, LINK_STATE_LINGER
));
597 link
->link_messages
--;
599 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
602 r
= sd_netlink_message_get_errno(m
);
603 if (r
< 0 && r
!= -EEXIST
)
604 log_link_warning_errno(link
, r
, "%-*s: could not set address: %m", IFNAMSIZ
, link
->ifname
);
606 link_rtnl_process_address(rtnl
, m
, link
->manager
);
608 if (link
->link_messages
== 0) {
609 log_link_debug(link
, "Addresses set");
610 link_enter_set_routes(link
);
616 static int link_enter_set_addresses(Link
*link
) {
621 assert(link
->network
);
622 assert(link
->state
!= _LINK_STATE_INVALID
);
624 link_set_state(link
, LINK_STATE_SETTING_ADDRESSES
);
626 LIST_FOREACH(addresses
, ad
, link
->network
->static_addresses
) {
627 r
= address_configure(ad
, link
, &address_handler
);
629 log_link_warning_errno(link
, r
, "Could not set addresses: %m");
630 link_enter_failed(link
);
634 link
->link_messages
++;
637 /* now that we can figure out a default address for the dhcp server,
639 if (link_dhcp4_server_enabled(link
)) {
640 struct in_addr pool_start
;
643 address
= link_find_dhcp_server_address(link
);
645 log_link_warning(link
, "Failed to find suitable address for DHCPv4 server instance.");
646 link_enter_failed(link
);
650 r
= sd_dhcp_server_set_address(link
->dhcp_server
,
651 &address
->in_addr
.in
,
656 /* offer 32 addresses starting from the address following the server address */
657 pool_start
.s_addr
= htobe32(be32toh(address
->in_addr
.in
.s_addr
) + 1);
658 r
= sd_dhcp_server_set_lease_pool(link
->dhcp_server
,
664 r = sd_dhcp_server_set_router(link->dhcp_server,
665 &main_address->in_addr.in);
669 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
670 main_address->prefixlen);
675 r
= sd_dhcp_server_start(link
->dhcp_server
);
677 log_link_warning_errno(link
, r
, "Could not start DHCPv4 server instance: %m");
679 link_enter_failed(link
);
684 log_link_debug(link
, "Offering DHCPv4 leases");
687 if (link
->link_messages
== 0)
688 link_enter_set_routes(link
);
690 log_link_debug(link
, "Setting addresses");
695 int link_address_drop_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
696 _cleanup_link_unref_ Link
*link
= userdata
;
701 assert(link
->ifname
);
703 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
706 r
= sd_netlink_message_get_errno(m
);
707 if (r
< 0 && r
!= -EADDRNOTAVAIL
)
708 log_link_warning_errno(link
, r
, "%-*s: could not drop address: %m", IFNAMSIZ
, link
->ifname
);
713 static int link_set_bridge_fdb(Link
*const link
) {
717 LIST_FOREACH(static_fdb_entries
, fdb_entry
, link
->network
->static_fdb_entries
) {
718 r
= fdb_entry_configure(link
, fdb_entry
);
720 log_link_error_errno(link
, r
, "Failed to add MAC entry to static MAC table: %m");
728 static int link_set_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
729 _cleanup_link_unref_ Link
*link
= userdata
;
732 log_link_debug(link
, "Set link");
734 r
= sd_netlink_message_get_errno(m
);
735 if (r
< 0 && r
!= -EEXIST
) {
736 log_link_error_errno(link
, r
, "Could not join netdev: %m");
737 link_enter_failed(link
);
744 static int set_hostname_handler(sd_bus_message
*m
, void *userdata
, sd_bus_error
*ret_error
) {
745 _cleanup_link_unref_ Link
*link
= userdata
;
751 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
754 r
= sd_bus_message_get_errno(m
);
756 log_link_warning_errno(link
, r
, "Could not set hostname: %m");
761 int link_set_hostname(Link
*link
, const char *hostname
) {
765 assert(link
->manager
);
768 log_link_debug(link
, "Setting transient hostname: '%s'", hostname
);
770 if (!link
->manager
->bus
) {
771 /* TODO: replace by assert when we can rely on kdbus */
772 log_link_info(link
, "Not connected to system bus, ignoring transient hostname.");
776 r
= sd_bus_call_method_async(
779 "org.freedesktop.hostname1",
780 "/org/freedesktop/hostname1",
781 "org.freedesktop.hostname1",
783 set_hostname_handler
,
790 return log_link_error_errno(link
, r
, "Could not set transient hostname: %m");
797 static int set_mtu_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
798 _cleanup_link_unref_ Link
*link
= userdata
;
803 assert(link
->ifname
);
805 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
808 r
= sd_netlink_message_get_errno(m
);
810 log_link_warning_errno(link
, r
, "%-*s: could not set MTU: %m", IFNAMSIZ
, link
->ifname
);
815 int link_set_mtu(Link
*link
, uint32_t mtu
) {
816 _cleanup_netlink_message_unref_ sd_netlink_message
*req
= NULL
;
820 assert(link
->manager
);
821 assert(link
->manager
->rtnl
);
823 log_link_debug(link
, "Setting MTU: %" PRIu32
, mtu
);
825 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
827 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
829 r
= sd_netlink_message_append_u32(req
, IFLA_MTU
, mtu
);
831 return log_link_error_errno(link
, r
, "Could not append MTU: %m");
833 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, set_mtu_handler
, link
, 0, NULL
);
835 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
842 static int link_set_bridge(Link
*link
) {
843 _cleanup_netlink_message_unref_ sd_netlink_message
*req
= NULL
;
847 assert(link
->network
);
849 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
851 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
853 r
= sd_rtnl_message_link_set_family(req
, PF_BRIDGE
);
855 return log_link_error_errno(link
, r
, "Could not set message family: %m");
857 r
= sd_netlink_message_open_container(req
, IFLA_PROTINFO
);
859 return log_link_error_errno(link
, r
, "Could not append IFLA_PROTINFO attribute: %m");
861 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_GUARD
, !link
->network
->use_bpdu
);
863 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_GUARD attribute: %m");
865 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_MODE
, link
->network
->hairpin
);
867 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_MODE attribute: %m");
869 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_FAST_LEAVE
, link
->network
->fast_leave
);
871 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_FAST_LEAVE attribute: %m");
873 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_PROTECT
, !link
->network
->allow_port_to_be_root
);
875 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_PROTECT attribute: %m");
877 r
= sd_netlink_message_append_u8(req
, IFLA_BRPORT_UNICAST_FLOOD
, link
->network
->unicast_flood
);
879 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_UNICAST_FLOOD attribute: %m");
881 if(link
->network
->cost
!= 0) {
882 r
= sd_netlink_message_append_u32(req
, IFLA_BRPORT_COST
, link
->network
->cost
);
884 return log_link_error_errno(link
, r
, "Could not append IFLA_BRPORT_COST attribute: %m");
887 r
= sd_netlink_message_close_container(req
);
889 return log_link_error_errno(link
, r
, "Could not append IFLA_LINKINFO attribute: %m");
891 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, link_set_handler
, link
, 0, NULL
);
893 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
900 static void lldp_handler(sd_lldp
*lldp
, int event
, void *userdata
) {
901 Link
*link
= userdata
;
905 assert(link
->network
);
906 assert(link
->manager
);
908 if (event
!= UPDATE_INFO
)
911 r
= sd_lldp_save(link
->lldp
, link
->lldp_file
);
913 log_link_warning_errno(link
, r
, "Could not save LLDP: %m");
917 static int link_acquire_conf(Link
*link
) {
921 assert(link
->network
);
922 assert(link
->manager
);
923 assert(link
->manager
->event
);
925 if (link_ipv4ll_enabled(link
)) {
926 assert(link
->ipv4ll
);
928 log_link_debug(link
, "Acquiring IPv4 link-local address");
930 r
= sd_ipv4ll_start(link
->ipv4ll
);
932 return log_link_warning_errno(link
, r
, "Could not acquire IPv4 link-local address: %m");
935 if (link_dhcp4_enabled(link
)) {
936 assert(link
->dhcp_client
);
938 log_link_debug(link
, "Acquiring DHCPv4 lease");
940 r
= sd_dhcp_client_start(link
->dhcp_client
);
942 return log_link_warning_errno(link
, r
, "Could not acquire DHCPv4 lease: %m");
945 if (link_dhcp6_enabled(link
)) {
946 assert(link
->icmp6_router_discovery
);
948 log_link_debug(link
, "Discovering IPv6 routers");
950 r
= sd_icmp6_router_solicitation_start(link
->icmp6_router_discovery
);
952 return log_link_warning_errno(link
, r
, "Could not start IPv6 router discovery: %m");
955 if (link_lldp_enabled(link
)) {
958 log_link_debug(link
, "Starting LLDP");
960 r
= sd_lldp_start(link
->lldp
);
962 return log_link_warning_errno(link
, r
, "Could not start LLDP: %m");
968 bool link_has_carrier(Link
*link
) {
969 /* see Documentation/networking/operstates.txt in the kernel sources */
971 if (link
->kernel_operstate
== IF_OPER_UP
)
974 if (link
->kernel_operstate
== IF_OPER_UNKNOWN
)
975 /* operstate may not be implemented, so fall back to flags */
976 if ((link
->flags
& IFF_LOWER_UP
) && !(link
->flags
& IFF_DORMANT
))
982 static int link_up_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
983 _cleanup_link_unref_ Link
*link
= userdata
;
988 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
991 r
= sd_netlink_message_get_errno(m
);
993 /* we warn but don't fail the link, as it may be
995 log_link_warning_errno(link
, r
, "%-*s: could not bring up interface: %m", IFNAMSIZ
, link
->ifname
);
1000 static int link_up(Link
*link
) {
1001 _cleanup_netlink_message_unref_ sd_netlink_message
*req
= NULL
;
1002 uint8_t ipv6ll_mode
;
1006 assert(link
->network
);
1007 assert(link
->manager
);
1008 assert(link
->manager
->rtnl
);
1010 log_link_debug(link
, "Bringing link up");
1012 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_SETLINK
, link
->ifindex
);
1014 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1016 r
= sd_rtnl_message_link_set_flags(req
, IFF_UP
, IFF_UP
);
1018 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1020 if (link
->network
->mac
) {
1021 r
= sd_netlink_message_append_ether_addr(req
, IFLA_ADDRESS
, link
->network
->mac
);
1023 return log_link_error_errno(link
, r
, "Could not set MAC address: %m");
1026 if (link
->network
->mtu
) {
1027 r
= sd_netlink_message_append_u32(req
, IFLA_MTU
, link
->network
->mtu
);
1029 return log_link_error_errno(link
, r
, "Could not set MTU: %m");
1032 r
= sd_netlink_message_open_container(req
, IFLA_AF_SPEC
);
1034 return log_link_error_errno(link
, r
, "Could not open IFLA_AF_SPEC container: %m");
1036 if (socket_ipv6_is_supported()) {
1037 /* if the kernel lacks ipv6 support setting IFF_UP fails if any ipv6 options are passed */
1038 r
= sd_netlink_message_open_container(req
, AF_INET6
);
1040 return log_link_error_errno(link
, r
, "Could not open AF_INET6 container: %m");
1042 ipv6ll_mode
= link_ipv6ll_enabled(link
) ? IN6_ADDR_GEN_MODE_EUI64
: IN6_ADDR_GEN_MODE_NONE
;
1043 r
= sd_netlink_message_append_u8(req
, IFLA_INET6_ADDR_GEN_MODE
, ipv6ll_mode
);
1045 return log_link_error_errno(link
, r
, "Could not append IFLA_INET6_ADDR_GEN_MODE: %m");
1047 if (!in_addr_is_null(AF_INET6
, &link
->network
->ipv6_token
)) {
1048 r
= sd_netlink_message_append_in6_addr(req
, IFLA_INET6_TOKEN
, &link
->network
->ipv6_token
.in6
);
1050 return log_link_error_errno(link
, r
, "Could not append IFLA_INET6_TOKEN: %m");
1053 r
= sd_netlink_message_close_container(req
);
1055 return log_link_error_errno(link
, r
, "Could not close AF_INET6 container: %m");
1058 r
= sd_netlink_message_close_container(req
);
1060 return log_link_error_errno(link
, r
, "Could not close IFLA_AF_SPEC container: %m");
1062 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, link_up_handler
, link
, 0, NULL
);
1064 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1071 static int link_down_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1072 _cleanup_link_unref_ Link
*link
= userdata
;
1077 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1080 r
= sd_netlink_message_get_errno(m
);
1082 log_link_warning_errno(link
, r
, "%-*s: could not bring down interface: %m", IFNAMSIZ
, link
->ifname
);
1087 static int link_down(Link
*link
) {
1088 _cleanup_netlink_message_unref_ sd_netlink_message
*req
= NULL
;
1092 assert(link
->manager
);
1093 assert(link
->manager
->rtnl
);
1095 log_link_debug(link
, "Bringing link down");
1097 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
,
1098 RTM_SETLINK
, link
->ifindex
);
1100 return log_link_error_errno(link
, r
, "Could not allocate RTM_SETLINK message: %m");
1102 r
= sd_rtnl_message_link_set_flags(req
, 0, IFF_UP
);
1104 return log_link_error_errno(link
, r
, "Could not set link flags: %m");
1106 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
, link_down_handler
, link
, 0, NULL
);
1108 return log_link_error_errno(link
, r
, "Could not send rtnetlink message: %m");
1115 static int link_handle_bound_to_list(Link
*link
) {
1119 bool required_up
= false;
1120 bool link_is_up
= false;
1124 if (hashmap_isempty(link
->bound_to_links
))
1127 if (link
->flags
& IFF_UP
)
1130 HASHMAP_FOREACH (l
, link
->bound_to_links
, i
)
1131 if (link_has_carrier(l
)) {
1136 if (!required_up
&& link_is_up
) {
1137 r
= link_down(link
);
1140 } else if (required_up
&& !link_is_up
) {
1149 static int link_handle_bound_by_list(Link
*link
) {
1156 if (hashmap_isempty(link
->bound_by_links
))
1159 HASHMAP_FOREACH (l
, link
->bound_by_links
, i
) {
1160 r
= link_handle_bound_to_list(l
);
1168 static int link_put_carrier(Link
*link
, Link
*carrier
, Hashmap
**h
) {
1174 if (link
== carrier
)
1177 if (hashmap_get(*h
, INT_TO_PTR(carrier
->ifindex
)))
1180 r
= hashmap_ensure_allocated(h
, NULL
);
1184 r
= hashmap_put(*h
, INT_TO_PTR(carrier
->ifindex
), carrier
);
1191 static int link_new_bound_by_list(Link
*link
) {
1196 bool list_updated
= false;
1199 assert(link
->manager
);
1203 HASHMAP_FOREACH (carrier
, m
->links
, i
) {
1204 if (!carrier
->network
)
1207 if (strv_isempty(carrier
->network
->bind_carrier
))
1210 if (strv_fnmatch(carrier
->network
->bind_carrier
, link
->ifname
, 0)) {
1211 r
= link_put_carrier(link
, carrier
, &link
->bound_by_links
);
1215 list_updated
= true;
1222 HASHMAP_FOREACH (carrier
, link
->bound_by_links
, i
) {
1223 r
= link_put_carrier(carrier
, link
, &carrier
->bound_to_links
);
1233 static int link_new_bound_to_list(Link
*link
) {
1238 bool list_updated
= false;
1241 assert(link
->manager
);
1246 if (strv_isempty(link
->network
->bind_carrier
))
1251 HASHMAP_FOREACH (carrier
, m
->links
, i
) {
1252 if (strv_fnmatch(link
->network
->bind_carrier
, carrier
->ifname
, 0)) {
1253 r
= link_put_carrier(link
, carrier
, &link
->bound_to_links
);
1257 list_updated
= true;
1264 HASHMAP_FOREACH (carrier
, link
->bound_to_links
, i
) {
1265 r
= link_put_carrier(carrier
, link
, &carrier
->bound_by_links
);
1275 static int link_new_carrier_maps(Link
*link
) {
1278 r
= link_new_bound_by_list(link
);
1282 r
= link_handle_bound_by_list(link
);
1286 r
= link_new_bound_to_list(link
);
1290 r
= link_handle_bound_to_list(link
);
1297 static void link_free_bound_to_list(Link
*link
) {
1301 HASHMAP_FOREACH (bound_to
, link
->bound_to_links
, i
) {
1302 hashmap_remove(link
->bound_to_links
, INT_TO_PTR(bound_to
->ifindex
));
1304 if (hashmap_remove(bound_to
->bound_by_links
, INT_TO_PTR(link
->ifindex
)))
1305 link_save(bound_to
);
1311 static void link_free_bound_by_list(Link
*link
) {
1315 HASHMAP_FOREACH (bound_by
, link
->bound_by_links
, i
) {
1316 hashmap_remove(link
->bound_by_links
, INT_TO_PTR(bound_by
->ifindex
));
1318 if (hashmap_remove(bound_by
->bound_to_links
, INT_TO_PTR(link
->ifindex
))) {
1319 link_save(bound_by
);
1320 link_handle_bound_to_list(bound_by
);
1327 static void link_free_carrier_maps(Link
*link
) {
1328 bool list_updated
= false;
1332 if (!hashmap_isempty(link
->bound_to_links
)) {
1333 link_free_bound_to_list(link
);
1334 list_updated
= true;
1337 if (!hashmap_isempty(link
->bound_by_links
)) {
1338 link_free_bound_by_list(link
);
1339 list_updated
= true;
1348 void link_drop(Link
*link
) {
1349 if (!link
|| link
->state
== LINK_STATE_LINGER
)
1352 link_set_state(link
, LINK_STATE_LINGER
);
1354 link_free_carrier_maps(link
);
1356 log_link_debug(link
, "Link removed");
1363 static int link_joined(Link
*link
) {
1367 assert(link
->network
);
1369 if (!hashmap_isempty(link
->bound_to_links
)) {
1370 r
= link_handle_bound_to_list(link
);
1373 } else if (!(link
->flags
& IFF_UP
)) {
1376 link_enter_failed(link
);
1381 if(link
->network
->bridge
) {
1382 r
= link_set_bridge(link
);
1384 log_link_error_errno(link
, r
, "Could not set bridge message: %m");
1387 return link_enter_set_addresses(link
);
1390 static int netdev_join_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, void *userdata
) {
1391 _cleanup_link_unref_ Link
*link
= userdata
;
1395 assert(link
->network
);
1399 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1402 r
= sd_netlink_message_get_errno(m
);
1403 if (r
< 0 && r
!= -EEXIST
) {
1404 log_link_error_errno(link
, r
, "%-*s: could not join netdev: %m", IFNAMSIZ
, link
->ifname
);
1405 link_enter_failed(link
);
1408 log_link_debug(link
, "Joined netdev");
1410 if (link
->enslaving
<= 0)
1416 static int link_enter_join_netdev(Link
*link
) {
1422 assert(link
->network
);
1423 assert(link
->state
== LINK_STATE_PENDING
);
1425 link_set_state(link
, LINK_STATE_ENSLAVING
);
1429 if (!link
->network
->bridge
&&
1430 !link
->network
->bond
&&
1431 hashmap_isempty(link
->network
->stacked_netdevs
))
1432 return link_joined(link
);
1434 if (link
->network
->bond
) {
1435 log_struct(LOG_DEBUG
,
1436 LOG_LINK_INTERFACE(link
),
1437 LOG_NETDEV_INTERFACE(link
->network
->bond
),
1438 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->bond
->ifname
),
1441 r
= netdev_join(link
->network
->bond
, link
, netdev_join_handler
);
1443 log_struct_errno(LOG_WARNING
, r
,
1444 LOG_LINK_INTERFACE(link
),
1445 LOG_NETDEV_INTERFACE(link
->network
->bond
),
1446 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->bond
->ifname
),
1449 link_enter_failed(link
);
1456 if (link
->network
->bridge
) {
1457 log_struct(LOG_DEBUG
,
1458 LOG_LINK_INTERFACE(link
),
1459 LOG_NETDEV_INTERFACE(link
->network
->bridge
),
1460 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", link
->network
->bridge
->ifname
),
1463 r
= netdev_join(link
->network
->bridge
, link
, netdev_join_handler
);
1465 log_struct_errno(LOG_WARNING
, r
,
1466 LOG_LINK_INTERFACE(link
),
1467 LOG_NETDEV_INTERFACE(link
->network
->bridge
),
1468 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", link
->network
->bridge
->ifname
),
1470 link_enter_failed(link
);
1477 HASHMAP_FOREACH(netdev
, link
->network
->stacked_netdevs
, i
) {
1479 log_struct(LOG_DEBUG
,
1480 LOG_LINK_INTERFACE(link
),
1481 LOG_NETDEV_INTERFACE(netdev
),
1482 LOG_LINK_MESSAGE(link
, "Enslaving by '%s'", netdev
->ifname
),
1485 r
= netdev_join(netdev
, link
, netdev_join_handler
);
1487 log_struct_errno(LOG_WARNING
, r
,
1488 LOG_LINK_INTERFACE(link
),
1489 LOG_NETDEV_INTERFACE(netdev
),
1490 LOG_LINK_MESSAGE(link
, "Could not join netdev '%s': %m", netdev
->ifname
),
1492 link_enter_failed(link
);
1502 static int link_set_ipv4_forward(Link
*link
) {
1503 const char *p
= NULL
, *v
;
1506 if (link
->flags
& IFF_LOOPBACK
)
1509 if (link
->network
->ip_forward
== _ADDRESS_FAMILY_BOOLEAN_INVALID
)
1512 p
= strjoina("/proc/sys/net/ipv4/conf/", link
->ifname
, "/forwarding");
1513 v
= one_zero(link_ipv4_forward_enabled(link
));
1515 r
= write_string_file(p
, v
, 0);
1517 /* If the right value is set anyway, don't complain */
1518 if (verify_one_line_file(p
, v
) > 0)
1521 log_link_warning_errno(link
, r
, "Cannot configure IPv4 forwarding for interface %s: %m", link
->ifname
);
1527 static int link_set_ipv6_forward(Link
*link
) {
1528 const char *p
= NULL
, *v
= NULL
;
1531 /* Make this a NOP if IPv6 is not available */
1532 if (!socket_ipv6_is_supported())
1535 if (link
->flags
& IFF_LOOPBACK
)
1538 if (link
->network
->ip_forward
== _ADDRESS_FAMILY_BOOLEAN_INVALID
)
1541 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/forwarding");
1542 v
= one_zero(link_ipv6_forward_enabled(link
));
1544 r
= write_string_file(p
, v
, 0);
1546 /* If the right value is set anyway, don't complain */
1547 if (verify_one_line_file(p
, v
) > 0)
1550 log_link_warning_errno(link
, r
, "Cannot configure IPv6 forwarding for interface: %m");
1556 static int link_set_ipv6_privacy_extensions(Link
*link
) {
1557 char buf
[DECIMAL_STR_MAX(unsigned) + 1];
1558 IPv6PrivacyExtensions s
;
1559 const char *p
= NULL
;
1562 /* Make this a NOP if IPv6 is not available */
1563 if (!socket_ipv6_is_supported())
1566 s
= link_ipv6_privacy_extensions(link
);
1567 if (s
== _IPV6_PRIVACY_EXTENSIONS_INVALID
)
1570 p
= strjoina("/proc/sys/net/ipv6/conf/", link
->ifname
, "/use_tempaddr");
1571 xsprintf(buf
, "%u", link
->network
->ipv6_privacy_extensions
);
1573 r
= write_string_file(p
, buf
, 0);
1575 /* If the right value is set anyway, don't complain */
1576 if (verify_one_line_file(p
, buf
) > 0)
1579 log_link_warning_errno(link
, r
, "Cannot configure IPv6 privacy extension for interface: %m");
1585 static int link_configure(Link
*link
) {
1589 assert(link
->network
);
1590 assert(link
->state
== LINK_STATE_PENDING
);
1592 r
= link_set_bridge_fdb(link
);
1596 r
= link_set_ipv4_forward(link
);
1600 r
= link_set_ipv6_forward(link
);
1604 r
= link_set_ipv6_privacy_extensions(link
);
1608 if (link_ipv4ll_enabled(link
)) {
1609 r
= ipv4ll_configure(link
);
1614 if (link_dhcp4_enabled(link
)) {
1615 r
= dhcp4_configure(link
);
1620 if (link_dhcp4_server_enabled(link
)) {
1621 r
= sd_dhcp_server_new(&link
->dhcp_server
, link
->ifindex
);
1625 r
= sd_dhcp_server_attach_event(link
->dhcp_server
, NULL
, 0);
1630 if (link_dhcp6_enabled(link
)) {
1631 r
= icmp6_configure(link
);
1636 if (link_lldp_enabled(link
)) {
1637 r
= sd_lldp_new(link
->ifindex
, link
->ifname
, &link
->mac
, &link
->lldp
);
1641 r
= sd_lldp_attach_event(link
->lldp
, NULL
, 0);
1645 r
= sd_lldp_set_callback(link
->lldp
,
1646 lldp_handler
, link
);
1651 if (link_has_carrier(link
)) {
1652 r
= link_acquire_conf(link
);
1657 return link_enter_join_netdev(link
);
1660 static int link_initialized_and_synced(sd_netlink
*rtnl
, sd_netlink_message
*m
,
1662 _cleanup_link_unref_ Link
*link
= userdata
;
1667 assert(link
->ifname
);
1668 assert(link
->manager
);
1670 if (link
->state
!= LINK_STATE_PENDING
)
1673 log_link_debug(link
, "Link state is up-to-date");
1675 r
= link_new_bound_by_list(link
);
1679 r
= link_handle_bound_by_list(link
);
1683 r
= network_get(link
->manager
, link
->udev_device
, link
->ifname
,
1684 &link
->mac
, &network
);
1686 link_enter_unmanaged(link
);
1691 if (link
->flags
& IFF_LOOPBACK
) {
1692 if (network
->link_local
!= ADDRESS_FAMILY_NO
)
1693 log_link_debug(link
, "Ignoring link-local autoconfiguration for loopback link");
1695 if (network
->dhcp
!= ADDRESS_FAMILY_NO
)
1696 log_link_debug(link
, "Ignoring DHCP clients for loopback link");
1698 if (network
->dhcp_server
)
1699 log_link_debug(link
, "Ignoring DHCP server for loopback link");
1702 r
= network_apply(link
->manager
, network
, link
);
1706 r
= link_new_bound_to_list(link
);
1710 r
= link_configure(link
);
1717 int link_initialized(Link
*link
, struct udev_device
*device
) {
1718 _cleanup_netlink_message_unref_ sd_netlink_message
*req
= NULL
;
1722 assert(link
->manager
);
1723 assert(link
->manager
->rtnl
);
1726 if (link
->state
!= LINK_STATE_PENDING
)
1729 if (link
->udev_device
)
1732 log_link_debug(link
, "udev initialized link");
1734 link
->udev_device
= udev_device_ref(device
);
1736 /* udev has initialized the link, but we don't know if we have yet
1737 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1738 * when it returns we know that the pending NEWLINKs have already been
1739 * processed and that we are up-to-date */
1741 r
= sd_rtnl_message_new_link(link
->manager
->rtnl
, &req
, RTM_GETLINK
,
1746 r
= sd_netlink_call_async(link
->manager
->rtnl
, req
,
1747 link_initialized_and_synced
, link
, 0, NULL
);
1756 static Address
* link_get_equal_address(Link
*link
, Address
*needle
) {
1762 LIST_FOREACH(addresses
, i
, link
->addresses
)
1763 if (address_equal(i
, needle
))
1769 int link_rtnl_process_address(sd_netlink
*rtnl
, sd_netlink_message
*message
, void *userdata
) {
1770 Manager
*m
= userdata
;
1773 _cleanup_address_free_ Address
*address
= NULL
;
1774 unsigned char flags
;
1776 char buf
[INET6_ADDRSTRLEN
], valid_buf
[FORMAT_TIMESPAN_MAX
];
1777 const char *valid_str
= NULL
;
1784 if (sd_netlink_message_is_error(message
)) {
1785 r
= sd_netlink_message_get_errno(message
);
1787 log_warning_errno(r
, "rtnl: failed to receive address: %m");
1792 r
= sd_netlink_message_get_type(message
, &type
);
1794 log_warning_errno(r
, "rtnl: could not get message type: %m");
1796 } else if (type
!= RTM_NEWADDR
&& type
!= RTM_DELADDR
) {
1797 log_warning("rtnl: received unexpected message type when processing address");
1801 r
= sd_rtnl_message_addr_get_ifindex(message
, &ifindex
);
1803 log_warning_errno(r
, "rtnl: could not get ifindex from address: %m");
1805 } else if (ifindex
<= 0) {
1806 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex
);
1809 r
= link_get(m
, ifindex
, &link
);
1810 if (r
< 0 || !link
) {
1811 /* when enumerating we might be out of sync, but we will
1812 * get the address again, so just ignore it */
1813 if (!m
->enumerating
)
1814 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex
);
1819 r
= address_new_dynamic(&address
);
1823 r
= sd_rtnl_message_addr_get_family(message
, &address
->family
);
1824 if (r
< 0 || !IN_SET(address
->family
, AF_INET
, AF_INET6
)) {
1825 log_link_warning(link
, "rtnl: received address with invalid family, ignoring.");
1829 r
= sd_rtnl_message_addr_get_prefixlen(message
, &address
->prefixlen
);
1831 log_link_warning_errno(link
, r
, "rtnl: received address with invalid prefixlen, ignoring: %m");
1835 r
= sd_rtnl_message_addr_get_scope(message
, &address
->scope
);
1837 log_link_warning_errno(link
, r
, "rtnl: received address with invalid scope, ignoring: %m");
1841 r
= sd_rtnl_message_addr_get_flags(message
, &flags
);
1843 log_link_warning_errno(link
, r
, "rtnl: received address with invalid flags, ignoring: %m");
1846 address
->flags
= flags
;
1848 switch (address
->family
) {
1850 r
= sd_netlink_message_read_in_addr(message
, IFA_LOCAL
, &address
->in_addr
.in
);
1852 log_link_warning_errno(link
, r
, "rtnl: received address without valid address, ignoring: %m");
1859 r
= sd_netlink_message_read_in6_addr(message
, IFA_ADDRESS
, &address
->in_addr
.in6
);
1861 log_link_warning_errno(link
, r
, "rtnl: received address without valid address, ignoring: %m");
1868 assert_not_reached("invalid address family");
1871 if (!inet_ntop(address
->family
, &address
->in_addr
, buf
, INET6_ADDRSTRLEN
)) {
1872 log_link_warning(link
, "Could not print address");
1876 r
= sd_netlink_message_read_cache_info(message
, IFA_CACHEINFO
, &address
->cinfo
);
1878 if (address
->cinfo
.ifa_valid
== CACHE_INFO_INFINITY_LIFE_TIME
)
1881 valid_str
= format_timespan(valid_buf
, FORMAT_TIMESPAN_MAX
,
1882 address
->cinfo
.ifa_valid
* USEC_PER_SEC
,
1886 existing
= link_get_equal_address(link
, address
);
1891 log_link_debug(link
, "Updating address: %s/%u (valid for %s)", buf
, address
->prefixlen
, valid_str
);
1894 existing
->scope
= address
->scope
;
1895 existing
->flags
= address
->flags
;
1896 existing
->cinfo
= address
->cinfo
;
1899 log_link_debug(link
, "Adding address: %s/%u (valid for %s)", buf
, address
->prefixlen
, valid_str
);
1901 LIST_PREPEND(addresses
, link
->addresses
, address
);
1902 address_establish(address
, link
);
1914 log_link_debug(link
, "Removing address: %s/%u (valid for %s)", buf
, address
->prefixlen
, valid_str
);
1915 address_release(existing
, link
);
1916 LIST_REMOVE(addresses
, link
->addresses
, existing
);
1917 address_free(existing
);
1919 log_link_warning(link
, "Removing non-existent address: %s/%u (valid for %s)", buf
, address
->prefixlen
, valid_str
);
1923 assert_not_reached("Received invalid RTNL message type");
1929 int link_add(Manager
*m
, sd_netlink_message
*message
, Link
**ret
) {
1931 _cleanup_udev_device_unref_
struct udev_device
*device
= NULL
;
1932 char ifindex_str
[2 + DECIMAL_STR_MAX(int)];
1940 r
= link_new(m
, message
, ret
);
1946 log_link_debug(link
, "Link %d added", link
->ifindex
);
1948 if (detect_container(NULL
) <= 0) {
1949 /* not in a container, udev will be around */
1950 sprintf(ifindex_str
, "n%d", link
->ifindex
);
1951 device
= udev_device_new_from_device_id(m
->udev
, ifindex_str
);
1953 return log_link_warning_errno(link
, errno
, "Could not find udev device: %m");
1955 if (udev_device_get_is_initialized(device
) <= 0) {
1957 log_link_debug(link
, "link pending udev initialization...");
1961 r
= link_initialized(link
, device
);
1965 /* we are calling a callback directly, so must take a ref */
1968 r
= link_initialized_and_synced(m
->rtnl
, NULL
, link
);
1976 static int link_carrier_gained(Link
*link
) {
1981 if (link
->network
) {
1982 r
= link_acquire_conf(link
);
1984 link_enter_failed(link
);
1989 r
= link_handle_bound_by_list(link
);
1996 static int link_carrier_lost(Link
*link
) {
2001 r
= link_stop_clients(link
);
2003 link_enter_failed(link
);
2007 r
= link_handle_bound_by_list(link
);
2014 int link_carrier_reset(Link
*link
) {
2019 if (link_has_carrier(link
)) {
2020 r
= link_carrier_lost(link
);
2024 r
= link_carrier_gained(link
);
2028 log_link_info(link
, "Reset carrier");
2035 int link_update(Link
*link
, sd_netlink_message
*m
) {
2036 struct ether_addr mac
;
2039 bool had_carrier
, carrier_gained
, carrier_lost
;
2043 assert(link
->ifname
);
2046 if (link
->state
== LINK_STATE_LINGER
) {
2048 log_link_info(link
, "Link readded");
2049 link_set_state(link
, LINK_STATE_ENSLAVING
);
2051 r
= link_new_carrier_maps(link
);
2056 r
= sd_netlink_message_read_string(m
, IFLA_IFNAME
, &ifname
);
2057 if (r
>= 0 && !streq(ifname
, link
->ifname
)) {
2058 log_link_info(link
, "Renamed to %s", ifname
);
2060 link_free_carrier_maps(link
);
2063 link
->ifname
= strdup(ifname
);
2067 r
= link_new_carrier_maps(link
);
2072 r
= sd_netlink_message_read_u32(m
, IFLA_MTU
, &mtu
);
2073 if (r
>= 0 && mtu
> 0) {
2075 if (!link
->original_mtu
) {
2076 link
->original_mtu
= mtu
;
2077 log_link_debug(link
, "Saved original MTU: %" PRIu32
, link
->original_mtu
);
2080 if (link
->dhcp_client
) {
2081 r
= sd_dhcp_client_set_mtu(link
->dhcp_client
,
2084 log_link_warning_errno(link
, r
, "Could not update MTU in DHCP client: %m");
2090 /* The kernel may broadcast NEWLINK messages without the MAC address
2091 set, simply ignore them. */
2092 r
= sd_netlink_message_read_ether_addr(m
, IFLA_ADDRESS
, &mac
);
2094 if (memcmp(link
->mac
.ether_addr_octet
, mac
.ether_addr_octet
,
2097 memcpy(link
->mac
.ether_addr_octet
, mac
.ether_addr_octet
,
2100 log_link_debug(link
, "MAC address: "
2101 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2102 mac
.ether_addr_octet
[0],
2103 mac
.ether_addr_octet
[1],
2104 mac
.ether_addr_octet
[2],
2105 mac
.ether_addr_octet
[3],
2106 mac
.ether_addr_octet
[4],
2107 mac
.ether_addr_octet
[5]);
2110 r
= sd_ipv4ll_set_mac(link
->ipv4ll
, &link
->mac
);
2112 return log_link_warning_errno(link
, r
, "Could not update MAC address in IPv4LL client: %m");
2115 if (link
->dhcp_client
) {
2116 r
= sd_dhcp_client_set_mac(link
->dhcp_client
,
2117 (const uint8_t *) &link
->mac
,
2121 return log_link_warning_errno(link
, r
, "Could not update MAC address in DHCP client: %m");
2124 if (link
->dhcp6_client
) {
2125 r
= sd_dhcp6_client_set_mac(link
->dhcp6_client
,
2126 (const uint8_t *) &link
->mac
,
2130 return log_link_warning_errno(link
, r
, "Could not update MAC address in DHCPv6 client: %m");
2135 had_carrier
= link_has_carrier(link
);
2137 r
= link_update_flags(link
, m
);
2141 carrier_gained
= !had_carrier
&& link_has_carrier(link
);
2142 carrier_lost
= had_carrier
&& !link_has_carrier(link
);
2144 if (carrier_gained
) {
2145 log_link_info(link
, "Gained carrier");
2147 r
= link_carrier_gained(link
);
2150 } else if (carrier_lost
) {
2151 log_link_info(link
, "Lost carrier");
2153 r
= link_carrier_lost(link
);
2162 static void link_update_operstate(Link
*link
) {
2163 LinkOperationalState operstate
;
2166 if (link
->kernel_operstate
== IF_OPER_DORMANT
)
2167 operstate
= LINK_OPERSTATE_DORMANT
;
2168 else if (link_has_carrier(link
)) {
2170 uint8_t scope
= RT_SCOPE_NOWHERE
;
2172 /* if we have carrier, check what addresses we have */
2173 LIST_FOREACH(addresses
, address
, link
->addresses
) {
2174 if (address
->flags
& (IFA_F_TENTATIVE
| IFA_F_DEPRECATED
))
2177 if (address
->scope
< scope
)
2178 scope
= address
->scope
;
2181 if (scope
< RT_SCOPE_SITE
)
2182 /* universally accessible addresses found */
2183 operstate
= LINK_OPERSTATE_ROUTABLE
;
2184 else if (scope
< RT_SCOPE_HOST
)
2185 /* only link or site local addresses found */
2186 operstate
= LINK_OPERSTATE_DEGRADED
;
2188 /* no useful addresses found */
2189 operstate
= LINK_OPERSTATE_CARRIER
;
2190 } else if (link
->flags
& IFF_UP
)
2191 operstate
= LINK_OPERSTATE_NO_CARRIER
;
2193 operstate
= LINK_OPERSTATE_OFF
;
2195 if (link
->operstate
!= operstate
) {
2196 link
->operstate
= operstate
;
2197 link_send_changed(link
, "OperationalState", NULL
);
2201 int link_save(Link
*link
) {
2202 _cleanup_free_
char *temp_path
= NULL
;
2203 _cleanup_fclose_
FILE *f
= NULL
;
2204 const char *admin_state
, *oper_state
;
2208 assert(link
->state_file
);
2209 assert(link
->lease_file
);
2210 assert(link
->manager
);
2212 link_update_operstate(link
);
2214 r
= manager_save(link
->manager
);
2218 if (link
->state
== LINK_STATE_LINGER
) {
2219 unlink(link
->state_file
);
2223 admin_state
= link_state_to_string(link
->state
);
2224 assert(admin_state
);
2226 oper_state
= link_operstate_to_string(link
->operstate
);
2229 r
= fopen_temporary(link
->state_file
, &f
, &temp_path
);
2233 fchmod(fileno(f
), 0644);
2236 "# This is private data. Do not parse.\n"
2239 admin_state
, oper_state
);
2241 if (link
->network
) {
2242 char **address
, **domain
;
2245 fprintf(f
, "NETWORK_FILE=%s\n", link
->network
->filename
);
2249 STRV_FOREACH(address
, link
->network
->dns
) {
2256 if (link
->network
->dhcp_dns
&&
2258 const struct in_addr
*addresses
;
2260 r
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &addresses
);
2264 serialize_in_addrs(f
, addresses
, r
);
2272 STRV_FOREACH(address
, link
->network
->ntp
) {
2279 if (link
->network
->dhcp_ntp
&&
2281 const struct in_addr
*addresses
;
2283 r
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &addresses
);
2287 serialize_in_addrs(f
, addresses
, r
);
2293 fprintf(f
, "DOMAINS=");
2295 STRV_FOREACH(domain
, link
->network
->domains
) {
2302 if (link
->network
->dhcp_domains
&&
2304 const char *domainname
;
2306 r
= sd_dhcp_lease_get_domainname(link
->dhcp_lease
, &domainname
);
2310 fputs(domainname
, f
);
2316 fprintf(f
, "WILDCARD_DOMAIN=%s\n",
2317 yes_no(link
->network
->wildcard_domain
));
2319 fprintf(f
, "LLMNR=%s\n",
2320 llmnr_support_to_string(link
->network
->llmnr
));
2323 if (!hashmap_isempty(link
->bound_to_links
)) {
2328 fputs("CARRIER_BOUND_TO=", f
);
2329 HASHMAP_FOREACH(carrier
, link
->bound_to_links
, i
) {
2332 fputs(carrier
->ifname
, f
);
2339 if (!hashmap_isempty(link
->bound_by_links
)) {
2344 fputs("CARRIER_BOUND_BY=", f
);
2345 HASHMAP_FOREACH(carrier
, link
->bound_by_links
, i
) {
2348 fputs(carrier
->ifname
, f
);
2355 if (link
->dhcp_lease
) {
2356 assert(link
->network
);
2358 r
= sd_dhcp_lease_save(link
->dhcp_lease
, link
->lease_file
);
2366 unlink(link
->lease_file
);
2369 assert(link
->network
);
2371 r
= sd_lldp_save(link
->lldp
, link
->lldp_file
);
2379 unlink(link
->lldp_file
);
2381 r
= fflush_and_check(f
);
2385 if (rename(temp_path
, link
->state_file
) < 0) {
2393 (void) unlink(link
->state_file
);
2395 (void) unlink(temp_path
);
2397 return log_link_error_errno(link
, r
, "Failed to save link data to %s: %m", link
->state_file
);
2400 static const char* const link_state_table
[_LINK_STATE_MAX
] = {
2401 [LINK_STATE_PENDING
] = "pending",
2402 [LINK_STATE_ENSLAVING
] = "configuring",
2403 [LINK_STATE_SETTING_ADDRESSES
] = "configuring",
2404 [LINK_STATE_SETTING_ROUTES
] = "configuring",
2405 [LINK_STATE_CONFIGURED
] = "configured",
2406 [LINK_STATE_UNMANAGED
] = "unmanaged",
2407 [LINK_STATE_FAILED
] = "failed",
2408 [LINK_STATE_LINGER
] = "linger",
2411 DEFINE_STRING_TABLE_LOOKUP(link_state
, LinkState
);
2413 static const char* const link_operstate_table
[_LINK_OPERSTATE_MAX
] = {
2414 [LINK_OPERSTATE_OFF
] = "off",
2415 [LINK_OPERSTATE_NO_CARRIER
] = "no-carrier",
2416 [LINK_OPERSTATE_DORMANT
] = "dormant",
2417 [LINK_OPERSTATE_CARRIER
] = "carrier",
2418 [LINK_OPERSTATE_DEGRADED
] = "degraded",
2419 [LINK_OPERSTATE_ROUTABLE
] = "routable",
2422 DEFINE_STRING_TABLE_LOOKUP(link_operstate
, LinkOperationalState
);