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>
26 #include "networkd-link.h"
27 #include "networkd-netdev.h"
28 #include "libudev-private.h"
29 #include "udev-util.h"
33 #include "network-internal.h"
34 #include "conf-parser.h"
36 #include "dhcp-lease-internal.h"
38 static bool link_dhcp6_enabled(Link *link) {
39 if (link->flags & IFF_LOOPBACK)
45 return IN_SET(link->network->dhcp, DHCP_SUPPORT_V6, DHCP_SUPPORT_BOTH);
48 static bool link_dhcp4_enabled(Link *link) {
49 if (link->flags & IFF_LOOPBACK)
55 return IN_SET(link->network->dhcp, DHCP_SUPPORT_V4, DHCP_SUPPORT_BOTH);
58 static bool link_dhcp4_server_enabled(Link *link) {
59 if (link->flags & IFF_LOOPBACK)
65 return link->network->dhcp_server;
68 static bool link_ipv4ll_enabled(Link *link) {
69 if (link->flags & IFF_LOOPBACK)
75 return link->network->ipv4ll;
78 #define FLAG_STRING(string, flag, old, new) \
79 (((old ^ new) & flag) \
80 ? ((old & flag) ? (" -" string) : (" +" string)) \
83 static int link_update_flags(Link *link, sd_rtnl_message *m) {
84 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
90 r = sd_rtnl_message_link_get_flags(m, &flags);
92 log_warning_link(link, "Could not get link flags");
96 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
98 /* if we got a message without operstate, take it to mean
99 the state was unchanged */
100 operstate = link->kernel_operstate;
102 if ((link->flags == flags) && (link->kernel_operstate == operstate))
105 if (link->flags != flags) {
106 log_debug_link(link, "flags change:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
107 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
108 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
109 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
110 FLAG_STRING("UP", IFF_UP, link->flags, flags),
111 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
112 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
113 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
114 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
115 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
116 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
117 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
118 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
119 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
120 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
121 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
122 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
123 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
124 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
125 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
127 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
128 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
129 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
130 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
131 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
132 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
133 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
134 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
136 /* link flags are currently at most 18 bits, let's align to
138 if (unknown_flags_added)
140 "unknown link flags gained: %#.5x (ignoring)",
141 unknown_flags_added);
143 if (unknown_flags_removed)
145 "unknown link flags lost: %#.5x (ignoring)",
146 unknown_flags_removed);
150 link->kernel_operstate = operstate;
157 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
158 _cleanup_link_unref_ Link *link = NULL;
167 r = sd_rtnl_message_get_type(message, &type);
170 else if (type != RTM_NEWLINK)
173 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
176 else if (ifindex <= 0)
179 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
183 link = new0(Link, 1);
188 link->manager = manager;
189 link->state = LINK_STATE_PENDING;
190 link->ifindex = ifindex;
191 link->ifname = strdup(ifname);
195 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
197 log_debug_link(link, "MAC address not found for new device, continuing without");
199 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
204 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
209 r = hashmap_ensure_allocated(&manager->links, NULL);
213 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
217 r = link_update_flags(link, message);
227 static void link_free(Link *link) {
233 while ((address = link->addresses)) {
234 LIST_REMOVE(addresses, link->addresses, address);
235 address_free(address);
238 while ((address = link->pool_addresses)) {
239 LIST_REMOVE(addresses, link->pool_addresses, address);
240 address_free(address);
243 sd_dhcp_client_unref(link->dhcp_client);
244 sd_dhcp_lease_unref(link->dhcp_lease);
246 unlink(link->lease_file);
247 free(link->lease_file);
249 sd_ipv4ll_unref(link->ipv4ll);
250 sd_dhcp6_client_unref(link->dhcp6_client);
251 sd_icmp6_nd_unref(link->icmp6_router_discovery);
254 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
258 unlink(link->state_file);
259 free(link->state_file);
261 udev_device_unref(link->udev_device);
266 Link *link_unref(Link *link) {
267 if (link && (-- link->n_ref <= 0))
273 Link *link_ref(Link *link) {
275 assert_se(++ link->n_ref >= 2);
280 int link_get(Manager *m, int ifindex, Link **ret) {
287 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
296 void link_drop(Link *link) {
297 if (!link || link->state == LINK_STATE_LINGER)
300 link->state = LINK_STATE_LINGER;
302 log_debug_link(link, "link removed");
309 static void link_enter_unmanaged(Link *link) {
312 log_debug_link(link, "unmanaged");
314 link->state = LINK_STATE_UNMANAGED;
319 static int link_stop_clients(Link *link) {
323 assert(link->manager);
324 assert(link->manager->event);
329 if (link->dhcp_client) {
330 k = sd_dhcp_client_stop(link->dhcp_client);
332 log_warning_link(link, "Could not stop DHCPv4 client: %s",
339 k = sd_ipv4ll_stop(link->ipv4ll);
341 log_warning_link(link, "Could not stop IPv4 link-local: %s",
347 if (link->dhcp_server) {
348 k = sd_dhcp_server_stop(link->dhcp_server);
350 log_warning_link(link, "Could not stop DHCPv4 server: %s",
356 if(link->icmp6_router_discovery) {
358 if (link->dhcp6_client) {
359 k = sd_dhcp6_client_stop(link->dhcp6_client);
361 log_warning_link(link, "Could not stop DHCPv6 client: %s",
367 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
369 log_warning_link(link,
370 "Could not stop ICMPv6 router discovery: %s",
379 void link_enter_failed(Link *link) {
382 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
385 log_warning_link(link, "failed");
387 link->state = LINK_STATE_FAILED;
389 link_stop_clients(link);
394 static Address* link_find_dhcp_server_address(Link *link) {
398 assert(link->network);
400 /* The the first statically configured address if there is any */
401 LIST_FOREACH(addresses, address, link->network->static_addresses) {
403 if (address->family != AF_INET)
406 if (in_addr_is_null(address->family, &address->in_addr))
412 /* If that didn't work, find a suitable address we got from the pool */
413 LIST_FOREACH(addresses, address, link->pool_addresses) {
414 if (address->family != AF_INET)
423 static int link_enter_configured(Link *link) {
427 assert(link->network);
428 assert(link->state == LINK_STATE_SETTING_ROUTES);
430 if (link_dhcp4_server_enabled(link) &&
431 !sd_dhcp_server_is_running(link->dhcp_server)) {
432 struct in_addr pool_start;
435 address = link_find_dhcp_server_address(link);
437 log_warning_link(link,
438 "Failed to find suitable address for DHCPv4 server instance.");
439 link_enter_failed(link);
443 log_debug_link(link, "offering DHCPv4 leases");
445 r = sd_dhcp_server_set_address(link->dhcp_server,
446 &address->in_addr.in,
451 /* offer 32 addresses starting from the address following the server address */
452 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
453 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
459 r = sd_dhcp_server_set_router(link->dhcp_server,
460 &main_address->in_addr.in);
464 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
465 main_address->prefixlen);
470 r = sd_dhcp_server_start(link->dhcp_server);
472 log_warning_link(link, "could not start DHCPv4 server "
473 "instance: %s", strerror(-r));
475 link_enter_failed(link);
481 log_info_link(link, "link configured");
483 link->state = LINK_STATE_CONFIGURED;
490 void link_client_handler(Link *link) {
492 assert(link->network);
494 if (!link->static_configured)
497 if (link_ipv4ll_enabled(link))
498 if (!link->ipv4ll_address ||
502 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
505 if (link->state != LINK_STATE_CONFIGURED)
506 link_enter_configured(link);
511 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
512 _cleanup_link_unref_ Link *link = userdata;
515 assert(link->link_messages > 0);
516 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
517 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
520 link->link_messages --;
522 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
525 r = sd_rtnl_message_get_errno(m);
526 if (r < 0 && r != -EEXIST)
527 log_struct_link(LOG_WARNING, link,
528 "MESSAGE=%-*s: could not set route: %s",
530 link->ifname, strerror(-r),
534 if (link->link_messages == 0) {
535 log_debug_link(link, "routes set");
536 link->static_configured = true;
537 link_client_handler(link);
543 static int link_enter_set_routes(Link *link) {
548 assert(link->network);
549 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
551 link->state = LINK_STATE_SETTING_ROUTES;
553 LIST_FOREACH(routes, rt, link->network->static_routes) {
554 r = route_configure(rt, link, &route_handler);
556 log_warning_link(link,
557 "could not set routes: %s",
559 link_enter_failed(link);
563 link->link_messages ++;
566 if (link->link_messages == 0) {
567 link->static_configured = true;
568 link_client_handler(link);
570 log_debug_link(link, "setting routes");
575 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
576 _cleanup_link_unref_ Link *link = userdata;
581 assert(link->ifname);
583 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
586 r = sd_rtnl_message_get_errno(m);
587 if (r < 0 && r != -ESRCH)
588 log_struct_link(LOG_WARNING, link,
589 "MESSAGE=%-*s: could not drop route: %s",
591 link->ifname, strerror(-r),
598 int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
599 _cleanup_link_unref_ Link *link = userdata;
605 assert(link->manager);
607 for (; m; m = sd_rtnl_message_next(m)) {
608 r = sd_rtnl_message_get_errno(m);
610 log_debug_link(link, "getting address failed: %s",
615 r = link_rtnl_process_address(rtnl, m, link->manager);
617 log_warning_link(link, "could not process address: %s",
624 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
625 _cleanup_link_unref_ Link *link = userdata;
631 assert(link->ifname);
632 assert(link->link_messages > 0);
633 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
634 LINK_STATE_FAILED, LINK_STATE_LINGER));
636 link->link_messages --;
638 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
641 r = sd_rtnl_message_get_errno(m);
642 if (r < 0 && r != -EEXIST)
643 log_struct_link(LOG_WARNING, link,
644 "MESSAGE=%-*s: could not set address: %s",
646 link->ifname, strerror(-r),
650 /* calling handler directly so take a ref */
652 link_get_address_handler(rtnl, m, link);
655 if (link->link_messages == 0) {
656 log_debug_link(link, "addresses set");
657 link_enter_set_routes(link);
663 static int link_enter_set_addresses(Link *link) {
668 assert(link->network);
669 assert(link->state != _LINK_STATE_INVALID);
671 link->state = LINK_STATE_SETTING_ADDRESSES;
673 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
674 r = address_configure(ad, link, &address_handler);
676 log_warning_link(link,
677 "could not set addresses: %s",
679 link_enter_failed(link);
683 link->link_messages ++;
686 if (link->link_messages == 0) {
687 link_enter_set_routes(link);
689 log_debug_link(link, "setting addresses");
694 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
695 _cleanup_link_unref_ Link *link = userdata;
700 assert(link->ifname);
702 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
705 r = sd_rtnl_message_get_errno(m);
706 if (r < 0 && r != -EADDRNOTAVAIL)
707 log_struct_link(LOG_WARNING, link,
708 "MESSAGE=%-*s: could not drop address: %s",
710 link->ifname, strerror(-r),
717 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
718 sd_bus_error *ret_error) {
719 _cleanup_link_unref_ Link *link = userdata;
724 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
727 r = sd_bus_message_get_errno(m);
729 log_warning_link(link, "Could not set hostname: %s",
735 int link_set_hostname(Link *link, const char *hostname) {
736 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
740 assert(link->manager);
743 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
745 if (!link->manager->bus) {
746 /* TODO: replace by assert when we can rely on kdbus */
748 "Not connected to system bus, ignoring transient hostname.");
752 r = sd_bus_message_new_method_call(
755 "org.freedesktop.hostname1",
756 "/org/freedesktop/hostname1",
757 "org.freedesktop.hostname1",
762 r = sd_bus_message_append(m, "sb", hostname, false);
766 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
769 log_error_link(link, "Could not set transient hostname: %s",
779 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
780 _cleanup_link_unref_ Link *link = userdata;
785 assert(link->ifname);
787 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
790 r = sd_rtnl_message_get_errno(m);
792 log_struct_link(LOG_WARNING, link,
793 "MESSAGE=%-*s: could not set MTU: %s",
794 IFNAMSIZ, link->ifname, strerror(-r),
801 int link_set_mtu(Link *link, uint32_t mtu) {
802 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
806 assert(link->manager);
807 assert(link->manager->rtnl);
809 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
811 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
812 RTM_SETLINK, link->ifindex);
814 log_error_link(link, "Could not allocate RTM_SETLINK message");
818 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
820 log_error_link(link, "Could not append MTU: %s", strerror(-r));
824 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
828 "Could not send rtnetlink message: %s",
838 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
839 Link *link = userdata;
842 assert(link->network);
843 assert(link->manager);
845 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
849 case DHCP6_EVENT_STOP:
850 case DHCP6_EVENT_RESEND_EXPIRE:
851 case DHCP6_EVENT_RETRANS_MAX:
852 case DHCP6_EVENT_IP_ACQUIRE:
853 log_debug_link(link, "DHCPv6 event %d", event);
859 log_warning_link(link, "DHCPv6 error: %s",
862 log_warning_link(link, "DHCPv6 unknown event: %d",
868 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
869 Link *link = userdata;
873 assert(link->network);
874 assert(link->manager);
876 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
880 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
881 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
884 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
885 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
890 log_warning_link(link, "ICMPv6 error: %s",
893 log_warning_link(link, "ICMPv6 unknown event: %d",
899 if (link->dhcp6_client)
902 r = sd_dhcp6_client_new(&link->dhcp6_client);
906 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
908 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
912 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
913 (const uint8_t *) &link->mac,
914 sizeof (link->mac), ARPHRD_ETHER);
916 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
920 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
922 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
926 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
929 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
933 r = sd_dhcp6_client_start(link->dhcp6_client);
935 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
938 static int link_acquire_conf(Link *link) {
942 assert(link->network);
943 assert(link->manager);
944 assert(link->manager->event);
946 if (link_ipv4ll_enabled(link)) {
947 assert(link->ipv4ll);
949 log_debug_link(link, "acquiring IPv4 link-local address");
951 r = sd_ipv4ll_start(link->ipv4ll);
953 log_warning_link(link, "could not acquire IPv4 "
954 "link-local address");
959 if (link_dhcp4_enabled(link)) {
960 assert(link->dhcp_client);
962 log_debug_link(link, "acquiring DHCPv4 lease");
964 r = sd_dhcp_client_start(link->dhcp_client);
966 log_warning_link(link, "could not acquire DHCPv4 "
972 if (link_dhcp6_enabled(link)) {
973 assert(link->icmp6_router_discovery);
975 log_debug_link(link, "discovering IPv6 routers");
977 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
979 log_warning_link(link,
980 "could not start IPv6 router discovery");
988 bool link_has_carrier(Link *link) {
989 /* see Documentation/networking/operstates.txt in the kernel sources */
991 if (link->kernel_operstate == IF_OPER_UP)
994 if (link->kernel_operstate == IF_OPER_UNKNOWN)
995 /* operstate may not be implemented, so fall back to flags */
996 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1002 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1003 _cleanup_link_unref_ Link *link = userdata;
1008 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1011 r = sd_rtnl_message_get_errno(m);
1013 /* we warn but don't fail the link, as it may
1014 be brought up later */
1015 log_struct_link(LOG_WARNING, link,
1016 "MESSAGE=%-*s: could not bring up interface: %s",
1018 link->ifname, strerror(-r),
1026 static int link_up(Link *link) {
1027 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1031 assert(link->manager);
1032 assert(link->manager->rtnl);
1034 log_debug_link(link, "bringing link up");
1036 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1037 RTM_SETLINK, link->ifindex);
1039 log_error_link(link, "Could not allocate RTM_SETLINK message");
1043 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1045 log_error_link(link, "Could not set link flags: %s",
1050 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1053 log_error_link(link,
1054 "Could not send rtnetlink message: %s",
1064 static int link_joined(Link *link) {
1068 assert(link->network);
1070 if (!(link->flags & IFF_UP)) {
1073 link_enter_failed(link);
1078 return link_enter_set_addresses(link);
1081 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1083 _cleanup_link_unref_ Link *link = userdata;
1087 assert(link->network);
1091 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1094 r = sd_rtnl_message_get_errno(m);
1095 if (r < 0 && r != -EEXIST) {
1096 log_struct_link(LOG_ERR, link,
1097 "MESSAGE=%-*s: could not join netdev: %s",
1099 link->ifname, strerror(-r),
1102 link_enter_failed(link);
1105 log_debug_link(link, "joined netdev");
1107 if (link->enslaving <= 0)
1113 static int link_enter_join_netdev(Link *link) {
1119 assert(link->network);
1120 assert(link->state == LINK_STATE_PENDING);
1122 link->state = LINK_STATE_ENSLAVING;
1126 if (!link->network->bridge &&
1127 !link->network->bond &&
1128 hashmap_isempty(link->network->stacked_netdevs))
1129 return link_joined(link);
1131 if (link->network->bond) {
1132 log_struct_link(LOG_DEBUG, link,
1133 "MESSAGE=%-*s: enslaving by '%s'",
1135 link->ifname, link->network->bond->ifname,
1136 NETDEVIF(link->network->bond),
1139 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1141 log_struct_link(LOG_WARNING, link,
1142 "MESSAGE=%-*s: could not join netdev '%s': %s",
1144 link->ifname, link->network->bond->ifname,
1146 NETDEVIF(link->network->bond),
1148 link_enter_failed(link);
1155 if (link->network->bridge) {
1156 log_struct_link(LOG_DEBUG, link,
1157 "MESSAGE=%-*s: enslaving by '%s'",
1159 link->ifname, link->network->bridge->ifname,
1160 NETDEVIF(link->network->bridge),
1163 r = netdev_join(link->network->bridge, link,
1164 &netdev_join_handler);
1166 log_struct_link(LOG_WARNING, link,
1167 "MESSAGE=%-*s: could not join netdev '%s': %s",
1169 link->ifname, link->network->bridge->ifname,
1171 NETDEVIF(link->network->bridge),
1173 link_enter_failed(link);
1180 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1181 log_struct_link(LOG_DEBUG, link,
1182 "MESSAGE=%-*s: enslaving by '%s'",
1184 link->ifname, netdev->ifname, NETDEVIF(netdev),
1187 r = netdev_join(netdev, link, &netdev_join_handler);
1189 log_struct_link(LOG_WARNING, link,
1190 "MESSAGE=%-*s: could not join netdev '%s': %s",
1192 link->ifname, netdev->ifname,
1194 NETDEVIF(netdev), NULL);
1195 link_enter_failed(link);
1205 static int link_configure(Link *link) {
1209 assert(link->network);
1210 assert(link->state == LINK_STATE_PENDING);
1212 if (link_ipv4ll_enabled(link)) {
1213 r = ipv4ll_configure(link);
1218 if (link_dhcp4_enabled(link)) {
1219 r = dhcp4_configure(link);
1224 if (link_dhcp4_server_enabled(link)) {
1225 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1229 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1234 if (link_dhcp6_enabled(link)) {
1235 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1239 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1244 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1249 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1254 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1255 icmp6_router_handler, link);
1260 if (link_has_carrier(link)) {
1261 r = link_acquire_conf(link);
1266 return link_enter_join_netdev(link);
1269 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1271 _cleanup_link_unref_ Link *link = userdata;
1276 assert(link->ifname);
1277 assert(link->manager);
1279 if (link->state != LINK_STATE_PENDING)
1282 log_debug_link(link, "link state is up-to-date");
1284 r = network_get(link->manager, link->udev_device, link->ifname,
1285 &link->mac, &network);
1287 link_enter_unmanaged(link);
1292 if (link->flags & IFF_LOOPBACK) {
1293 if (network->ipv4ll)
1294 log_debug_link(link, "ignoring IPv4LL for loopback link");
1296 if (network->dhcp != DHCP_SUPPORT_NONE)
1297 log_debug_link(link, "ignoring DHCP clients for loopback link");
1299 if (network->dhcp_server)
1300 log_debug_link(link, "ignoring DHCP server for loopback link");
1303 r = network_apply(link->manager, network, link);
1307 r = link_configure(link);
1314 int link_initialized(Link *link, struct udev_device *device) {
1315 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1319 assert(link->manager);
1320 assert(link->manager->rtnl);
1323 if (link->state != LINK_STATE_PENDING)
1326 if (link->udev_device)
1329 log_debug_link(link, "udev initialized link");
1331 link->udev_device = udev_device_ref(device);
1333 /* udev has initialized the link, but we don't know if we have yet
1334 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1335 * when it returns we know that the pending NEWLINKs have already been
1336 * processed and that we are up-to-date */
1338 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1343 r = sd_rtnl_call_async(link->manager->rtnl, req,
1344 link_initialized_and_synced, link, 0, NULL);
1353 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message,
1355 Manager *m = userdata;
1358 _cleanup_address_free_ Address *address = NULL;
1360 char buf[INET6_ADDRSTRLEN];
1361 char valid_buf[FORMAT_TIMESPAN_MAX];
1362 const char *valid_str = NULL;
1363 bool address_dropped = false;
1370 r = sd_rtnl_message_get_type(message, &type);
1372 log_warning("rtnl: could not get message type");
1376 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1377 if (r < 0 || ifindex <= 0) {
1378 log_warning("rtnl: received address message without valid ifindex, ignoring");
1381 r = link_get(m, ifindex, &link);
1382 if (r < 0 || !link) {
1383 log_warning("rtnl: received address for a nonexistent link (%d), ignoring", ifindex);
1388 r = address_new_dynamic(&address);
1392 r = sd_rtnl_message_addr_get_family(message, &address->family);
1393 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1394 log_warning_link(link,
1395 "rtnl: received address with invalid family, ignoring");
1399 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1401 log_warning_link(link,
1402 "rtnl: received address with invalid prefixlen, ignoring");
1406 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1408 log_warning_link(link,
1409 "rtnl: received address with invalid scope, ignoring");
1413 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1415 log_warning_link(link,
1416 "rtnl: received address with invalid flags, ignoring");
1420 switch (address->family) {
1422 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
1423 &address->in_addr.in);
1425 log_warning_link(link,
1426 "rtnl: received address without valid address, ignoring");
1433 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
1434 &address->in_addr.in6);
1436 log_warning_link(link,
1437 "rtnl: received address without valid address, ignoring");
1444 assert_not_reached("invalid address family");
1447 if (!inet_ntop(address->family, &address->in_addr, buf,
1448 INET6_ADDRSTRLEN)) {
1449 log_warning_link(link, "could not print address");
1453 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO,
1456 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1459 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1460 address->cinfo.ifa_valid * USEC_PER_SEC,
1464 LIST_FOREACH(addresses, ad, link->addresses) {
1465 if (address_equal(ad, address)) {
1466 LIST_REMOVE(addresses, link->addresses, ad);
1470 address_dropped = true;
1478 if (!address_dropped)
1479 log_debug_link(link, "added address: %s/%u (valid for %s)",
1480 buf, address->prefixlen, valid_str);
1482 log_debug_link(link, "updated address: %s/%u (valid for %s)",
1483 buf, address->prefixlen, valid_str);
1485 LIST_PREPEND(addresses, link->addresses, address);
1492 if (address_dropped) {
1493 log_debug_link(link, "removed address: %s/%u (valid for %s)",
1494 buf, address->prefixlen, valid_str);
1498 log_warning_link(link,
1499 "removing non-existent address: %s/%u (valid for %s)",
1500 buf, address->prefixlen, valid_str);
1504 assert_not_reached("Received invalid RTNL message type");
1510 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1512 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1513 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1514 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1522 r = link_new(m, message, ret);
1528 log_debug_link(link, "link %d added", link->ifindex);
1530 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex,
1535 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0,
1542 if (detect_container(NULL) <= 0) {
1543 /* not in a container, udev will be around */
1544 sprintf(ifindex_str, "n%d", link->ifindex);
1545 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1547 log_warning_link(link,
1548 "could not find udev device: %m");
1552 if (udev_device_get_is_initialized(device) <= 0) {
1554 log_debug_link(link, "link pending udev initialization...");
1558 r = link_initialized(link, device);
1562 /* we are calling a callback directly, so must take a ref */
1565 r = link_initialized_and_synced(m->rtnl, NULL, link);
1573 int link_update(Link *link, sd_rtnl_message *m) {
1574 struct ether_addr mac;
1577 bool had_carrier, carrier_gained, carrier_lost;
1581 assert(link->ifname);
1584 if (link->state == LINK_STATE_LINGER) {
1586 log_info_link(link, "link readded");
1587 link->state = LINK_STATE_ENSLAVING;
1590 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1591 if (r >= 0 && !streq(ifname, link->ifname)) {
1592 log_info_link(link, "renamed to %s", ifname);
1595 link->ifname = strdup(ifname);
1600 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1601 if (r >= 0 && mtu > 0) {
1603 if (!link->original_mtu) {
1604 link->original_mtu = mtu;
1605 log_debug_link(link, "saved original MTU: %"
1606 PRIu32, link->original_mtu);
1609 if (link->dhcp_client) {
1610 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1613 log_warning_link(link,
1614 "Could not update MTU in DHCP client: %s",
1621 /* The kernel may broadcast NEWLINK messages without the MAC address
1622 set, simply ignore them. */
1623 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1625 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1628 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1631 log_debug_link(link, "MAC address: "
1632 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1633 mac.ether_addr_octet[0],
1634 mac.ether_addr_octet[1],
1635 mac.ether_addr_octet[2],
1636 mac.ether_addr_octet[3],
1637 mac.ether_addr_octet[4],
1638 mac.ether_addr_octet[5]);
1641 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1643 log_warning_link(link,
1644 "Could not update MAC address in IPv4LL client: %s",
1650 if (link->dhcp_client) {
1651 r = sd_dhcp_client_set_mac(link->dhcp_client,
1652 (const uint8_t *) &link->mac,
1656 log_warning_link(link,
1657 "Could not update MAC address in DHCP client: %s",
1663 if (link->dhcp6_client) {
1664 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1665 (const uint8_t *) &link->mac,
1669 log_warning_link(link,
1670 "Could not update MAC address in DHCPv6 client: %s",
1678 had_carrier = link_has_carrier(link);
1680 r = link_update_flags(link, m);
1684 carrier_gained = !had_carrier && link_has_carrier(link);
1685 carrier_lost = had_carrier && !link_has_carrier(link);
1687 if (carrier_gained) {
1688 log_info_link(link, "gained carrier");
1690 if (link->network) {
1691 r = link_acquire_conf(link);
1693 link_enter_failed(link);
1697 } else if (carrier_lost) {
1698 log_info_link(link, "lost carrier");
1700 r = link_stop_clients(link);
1702 link_enter_failed(link);
1710 static void link_update_operstate(Link *link) {
1714 if (link->kernel_operstate == IF_OPER_DORMANT)
1715 link->operstate = LINK_OPERSTATE_DORMANT;
1716 else if (link_has_carrier(link)) {
1718 uint8_t scope = RT_SCOPE_NOWHERE;
1720 /* if we have carrier, check what addresses we have */
1721 LIST_FOREACH(addresses, address, link->addresses) {
1722 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1725 if (address->scope < scope)
1726 scope = address->scope;
1729 if (scope < RT_SCOPE_SITE)
1730 /* universally accessible addresses found */
1731 link->operstate = LINK_OPERSTATE_ROUTABLE;
1732 else if (scope < RT_SCOPE_HOST)
1733 /* only link or site local addresses found */
1734 link->operstate = LINK_OPERSTATE_DEGRADED;
1736 /* no useful addresses found */
1737 link->operstate = LINK_OPERSTATE_CARRIER;
1738 } else if (link->flags & IFF_UP)
1739 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1741 link->operstate = LINK_OPERSTATE_OFF;
1744 int link_save(Link *link) {
1745 _cleanup_free_ char *temp_path = NULL;
1746 _cleanup_fclose_ FILE *f = NULL;
1747 const char *admin_state, *oper_state;
1751 assert(link->state_file);
1752 assert(link->lease_file);
1753 assert(link->manager);
1755 link_update_operstate(link);
1757 r = manager_save(link->manager);
1761 if (link->state == LINK_STATE_LINGER) {
1762 unlink(link->state_file);
1766 admin_state = link_state_to_string(link->state);
1767 assert(admin_state);
1769 oper_state = link_operstate_to_string(link->operstate);
1772 r = fopen_temporary(link->state_file, &f, &temp_path);
1776 fchmod(fileno(f), 0644);
1779 "# This is private data. Do not parse.\n"
1782 admin_state, oper_state);
1784 if (link->network) {
1785 char **address, **domain;
1788 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1792 STRV_FOREACH(address, link->network->dns) {
1799 if (link->network->dhcp_dns &&
1801 const struct in_addr *addresses;
1803 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1807 serialize_in_addrs(f, addresses, r);
1815 STRV_FOREACH(address, link->network->ntp) {
1822 if (link->network->dhcp_ntp &&
1824 const struct in_addr *addresses;
1826 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1830 serialize_in_addrs(f, addresses, r);
1836 fprintf(f, "DOMAINS=");
1838 STRV_FOREACH(domain, link->network->domains) {
1845 if (link->network->dhcp_domains &&
1847 const char *domainname;
1849 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1853 fputs(domainname, f);
1859 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1860 yes_no(link->network->wildcard_domain));
1862 fprintf(f, "LLMNR=%s\n",
1863 llmnr_support_to_string(link->network->llmnr));
1866 if (link->dhcp_lease) {
1867 assert(link->network);
1869 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
1877 unlink(link->lease_file);
1879 r = fflush_and_check(f);
1883 if (rename(temp_path, link->state_file) < 0) {
1890 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1891 unlink(link->state_file);
1896 static const char* const link_state_table[_LINK_STATE_MAX] = {
1897 [LINK_STATE_PENDING] = "pending",
1898 [LINK_STATE_ENSLAVING] = "configuring",
1899 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1900 [LINK_STATE_SETTING_ROUTES] = "configuring",
1901 [LINK_STATE_CONFIGURED] = "configured",
1902 [LINK_STATE_UNMANAGED] = "unmanaged",
1903 [LINK_STATE_FAILED] = "failed",
1904 [LINK_STATE_LINGER] = "linger",
1907 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1909 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1910 [LINK_OPERSTATE_OFF] = "off",
1911 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1912 [LINK_OPERSTATE_DORMANT] = "dormant",
1913 [LINK_OPERSTATE_CARRIER] = "carrier",
1914 [LINK_OPERSTATE_DEGRADED] = "degraded",
1915 [LINK_OPERSTATE_ROUTABLE] = "routable",
1918 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);