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, &link->mac);
914 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
918 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
920 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
924 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
927 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
931 r = sd_dhcp6_client_start(link->dhcp6_client);
933 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
936 static int link_acquire_conf(Link *link) {
940 assert(link->network);
941 assert(link->manager);
942 assert(link->manager->event);
944 if (link_ipv4ll_enabled(link)) {
945 assert(link->ipv4ll);
947 log_debug_link(link, "acquiring IPv4 link-local address");
949 r = sd_ipv4ll_start(link->ipv4ll);
951 log_warning_link(link, "could not acquire IPv4 "
952 "link-local address");
957 if (link_dhcp4_enabled(link)) {
958 assert(link->dhcp_client);
960 log_debug_link(link, "acquiring DHCPv4 lease");
962 r = sd_dhcp_client_start(link->dhcp_client);
964 log_warning_link(link, "could not acquire DHCPv4 "
970 if (link_dhcp6_enabled(link)) {
971 assert(link->icmp6_router_discovery);
973 log_debug_link(link, "discovering IPv6 routers");
975 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
977 log_warning_link(link,
978 "could not start IPv6 router discovery");
986 bool link_has_carrier(Link *link) {
987 /* see Documentation/networking/operstates.txt in the kernel sources */
989 if (link->kernel_operstate == IF_OPER_UP)
992 if (link->kernel_operstate == IF_OPER_UNKNOWN)
993 /* operstate may not be implemented, so fall back to flags */
994 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1000 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1001 _cleanup_link_unref_ Link *link = userdata;
1006 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1009 r = sd_rtnl_message_get_errno(m);
1011 /* we warn but don't fail the link, as it may
1012 be brought up later */
1013 log_struct_link(LOG_WARNING, link,
1014 "MESSAGE=%-*s: could not bring up interface: %s",
1016 link->ifname, strerror(-r),
1024 static int link_up(Link *link) {
1025 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1029 assert(link->manager);
1030 assert(link->manager->rtnl);
1032 log_debug_link(link, "bringing link up");
1034 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1035 RTM_SETLINK, link->ifindex);
1037 log_error_link(link, "Could not allocate RTM_SETLINK message");
1041 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1043 log_error_link(link, "Could not set link flags: %s",
1048 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1051 log_error_link(link,
1052 "Could not send rtnetlink message: %s",
1062 static int link_joined(Link *link) {
1066 assert(link->network);
1068 if (!(link->flags & IFF_UP)) {
1071 link_enter_failed(link);
1076 return link_enter_set_addresses(link);
1079 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1081 _cleanup_link_unref_ Link *link = userdata;
1085 assert(link->network);
1089 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1092 r = sd_rtnl_message_get_errno(m);
1093 if (r < 0 && r != -EEXIST) {
1094 log_struct_link(LOG_ERR, link,
1095 "MESSAGE=%-*s: could not join netdev: %s",
1097 link->ifname, strerror(-r),
1100 link_enter_failed(link);
1103 log_debug_link(link, "joined netdev");
1105 if (link->enslaving <= 0)
1111 static int link_enter_join_netdev(Link *link) {
1117 assert(link->network);
1118 assert(link->state == LINK_STATE_PENDING);
1120 link->state = LINK_STATE_ENSLAVING;
1124 if (!link->network->bridge &&
1125 !link->network->bond &&
1126 hashmap_isempty(link->network->stacked_netdevs))
1127 return link_joined(link);
1129 if (link->network->bond) {
1130 log_struct_link(LOG_DEBUG, link,
1131 "MESSAGE=%-*s: enslaving by '%s'",
1133 link->ifname, link->network->bond->ifname,
1134 NETDEVIF(link->network->bond),
1137 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1139 log_struct_link(LOG_WARNING, link,
1140 "MESSAGE=%-*s: could not join netdev '%s': %s",
1142 link->ifname, link->network->bond->ifname,
1144 NETDEVIF(link->network->bond),
1146 link_enter_failed(link);
1153 if (link->network->bridge) {
1154 log_struct_link(LOG_DEBUG, link,
1155 "MESSAGE=%-*s: enslaving by '%s'",
1157 link->ifname, link->network->bridge->ifname,
1158 NETDEVIF(link->network->bridge),
1161 r = netdev_join(link->network->bridge, link,
1162 &netdev_join_handler);
1164 log_struct_link(LOG_WARNING, link,
1165 "MESSAGE=%-*s: could not join netdev '%s': %s",
1167 link->ifname, link->network->bridge->ifname,
1169 NETDEVIF(link->network->bridge),
1171 link_enter_failed(link);
1178 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1179 log_struct_link(LOG_DEBUG, link,
1180 "MESSAGE=%-*s: enslaving by '%s'",
1182 link->ifname, netdev->ifname, NETDEVIF(netdev),
1185 r = netdev_join(netdev, link, &netdev_join_handler);
1187 log_struct_link(LOG_WARNING, link,
1188 "MESSAGE=%-*s: could not join netdev '%s': %s",
1190 link->ifname, netdev->ifname,
1192 NETDEVIF(netdev), NULL);
1193 link_enter_failed(link);
1203 static int link_configure(Link *link) {
1207 assert(link->network);
1208 assert(link->state == LINK_STATE_PENDING);
1210 if (link_ipv4ll_enabled(link)) {
1211 r = ipv4ll_configure(link);
1216 if (link_dhcp4_enabled(link)) {
1217 r = dhcp4_configure(link);
1222 if (link_dhcp4_server_enabled(link)) {
1223 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1227 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1232 if (link_dhcp6_enabled(link)) {
1233 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1237 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1242 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1247 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1252 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1253 icmp6_router_handler, link);
1258 if (link_has_carrier(link)) {
1259 r = link_acquire_conf(link);
1264 return link_enter_join_netdev(link);
1267 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1269 _cleanup_link_unref_ Link *link = userdata;
1274 assert(link->ifname);
1275 assert(link->manager);
1277 if (link->state != LINK_STATE_PENDING)
1280 log_debug_link(link, "link state is up-to-date");
1282 r = network_get(link->manager, link->udev_device, link->ifname,
1283 &link->mac, &network);
1285 link_enter_unmanaged(link);
1290 if (link->flags & IFF_LOOPBACK) {
1291 if (network->ipv4ll)
1292 log_debug_link(link, "ignoring IPv4LL for loopback link");
1294 if (network->dhcp != DHCP_SUPPORT_NONE)
1295 log_debug_link(link, "ignoring DHCP clients for loopback link");
1297 if (network->dhcp_server)
1298 log_debug_link(link, "ignoring DHCP server for loopback link");
1301 r = network_apply(link->manager, network, link);
1305 r = link_configure(link);
1312 int link_initialized(Link *link, struct udev_device *device) {
1313 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1317 assert(link->manager);
1318 assert(link->manager->rtnl);
1321 if (link->state != LINK_STATE_PENDING)
1324 if (link->udev_device)
1327 log_debug_link(link, "udev initialized link");
1329 link->udev_device = udev_device_ref(device);
1331 /* udev has initialized the link, but we don't know if we have yet
1332 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1333 * when it returns we know that the pending NEWLINKs have already been
1334 * processed and that we are up-to-date */
1336 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1341 r = sd_rtnl_call_async(link->manager->rtnl, req,
1342 link_initialized_and_synced, link, 0, NULL);
1351 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message,
1353 Manager *m = userdata;
1356 _cleanup_address_free_ Address *address = NULL;
1358 char buf[INET6_ADDRSTRLEN];
1359 char valid_buf[FORMAT_TIMESPAN_MAX];
1360 const char *valid_str = NULL;
1361 bool address_dropped = false;
1368 r = sd_rtnl_message_get_type(message, &type);
1370 log_warning("rtnl: could not get message type");
1374 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1375 if (r < 0 || ifindex <= 0) {
1376 log_warning("rtnl: received address message without valid ifindex, ignoring");
1379 r = link_get(m, ifindex, &link);
1380 if (r < 0 || !link) {
1381 log_warning("rtnl: received address for a nonexistent link (%d), ignoring", ifindex);
1386 r = address_new_dynamic(&address);
1390 r = sd_rtnl_message_addr_get_family(message, &address->family);
1391 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1392 log_warning_link(link,
1393 "rtnl: received address with invalid family, ignoring");
1397 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1399 log_warning_link(link,
1400 "rtnl: received address with invalid prefixlen, ignoring");
1404 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1406 log_warning_link(link,
1407 "rtnl: received address with invalid scope, ignoring");
1411 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1413 log_warning_link(link,
1414 "rtnl: received address with invalid flags, ignoring");
1418 switch (address->family) {
1420 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
1421 &address->in_addr.in);
1423 log_warning_link(link,
1424 "rtnl: received address without valid address, ignoring");
1431 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
1432 &address->in_addr.in6);
1434 log_warning_link(link,
1435 "rtnl: received address without valid address, ignoring");
1442 assert_not_reached("invalid address family");
1445 if (!inet_ntop(address->family, &address->in_addr, buf,
1446 INET6_ADDRSTRLEN)) {
1447 log_warning_link(link, "could not print address");
1451 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO,
1454 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1457 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1458 address->cinfo.ifa_valid * USEC_PER_SEC,
1462 LIST_FOREACH(addresses, ad, link->addresses) {
1463 if (address_equal(ad, address)) {
1464 LIST_REMOVE(addresses, link->addresses, ad);
1468 address_dropped = true;
1476 if (!address_dropped)
1477 log_debug_link(link, "added address: %s/%u (valid for %s)",
1478 buf, address->prefixlen, valid_str);
1480 log_debug_link(link, "updated address: %s/%u (valid for %s)",
1481 buf, address->prefixlen, valid_str);
1483 LIST_PREPEND(addresses, link->addresses, address);
1490 if (address_dropped) {
1491 log_debug_link(link, "removed address: %s/%u (valid for %s)",
1492 buf, address->prefixlen, valid_str);
1496 log_warning_link(link,
1497 "removing non-existent address: %s/%u (valid for %s)",
1498 buf, address->prefixlen, valid_str);
1502 assert_not_reached("Received invalid RTNL message type");
1508 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1510 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1511 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1512 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1520 r = link_new(m, message, ret);
1526 log_debug_link(link, "link %d added", link->ifindex);
1528 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex,
1533 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0,
1540 if (detect_container(NULL) <= 0) {
1541 /* not in a container, udev will be around */
1542 sprintf(ifindex_str, "n%d", link->ifindex);
1543 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1545 log_warning_link(link,
1546 "could not find udev device: %m");
1550 if (udev_device_get_is_initialized(device) <= 0) {
1552 log_debug_link(link, "link pending udev initialization...");
1556 r = link_initialized(link, device);
1560 /* we are calling a callback directly, so must take a ref */
1563 r = link_initialized_and_synced(m->rtnl, NULL, link);
1571 int link_update(Link *link, sd_rtnl_message *m) {
1572 struct ether_addr mac;
1575 bool had_carrier, carrier_gained, carrier_lost;
1579 assert(link->ifname);
1582 if (link->state == LINK_STATE_LINGER) {
1584 log_info_link(link, "link readded");
1585 link->state = LINK_STATE_ENSLAVING;
1588 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1589 if (r >= 0 && !streq(ifname, link->ifname)) {
1590 log_info_link(link, "renamed to %s", ifname);
1593 link->ifname = strdup(ifname);
1598 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1599 if (r >= 0 && mtu > 0) {
1601 if (!link->original_mtu) {
1602 link->original_mtu = mtu;
1603 log_debug_link(link, "saved original MTU: %"
1604 PRIu32, link->original_mtu);
1607 if (link->dhcp_client) {
1608 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1611 log_warning_link(link,
1612 "Could not update MTU in DHCP client: %s",
1619 /* The kernel may broadcast NEWLINK messages without the MAC address
1620 set, simply ignore them. */
1621 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1623 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1626 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1629 log_debug_link(link, "MAC address: "
1630 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1631 mac.ether_addr_octet[0],
1632 mac.ether_addr_octet[1],
1633 mac.ether_addr_octet[2],
1634 mac.ether_addr_octet[3],
1635 mac.ether_addr_octet[4],
1636 mac.ether_addr_octet[5]);
1639 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1641 log_warning_link(link,
1642 "Could not update MAC address in IPv4LL client: %s",
1648 if (link->dhcp_client) {
1649 r = sd_dhcp_client_set_mac(link->dhcp_client,
1652 log_warning_link(link,
1653 "Could not update MAC address in DHCP client: %s",
1659 if (link->dhcp6_client) {
1660 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1663 log_warning_link(link,
1664 "Could not update MAC address in DHCPv6 client: %s",
1672 had_carrier = link_has_carrier(link);
1674 r = link_update_flags(link, m);
1678 carrier_gained = !had_carrier && link_has_carrier(link);
1679 carrier_lost = had_carrier && !link_has_carrier(link);
1681 if (carrier_gained) {
1682 log_info_link(link, "gained carrier");
1684 if (link->network) {
1685 r = link_acquire_conf(link);
1687 link_enter_failed(link);
1691 } else if (carrier_lost) {
1692 log_info_link(link, "lost carrier");
1694 r = link_stop_clients(link);
1696 link_enter_failed(link);
1704 static void link_update_operstate(Link *link) {
1708 if (link->kernel_operstate == IF_OPER_DORMANT)
1709 link->operstate = LINK_OPERSTATE_DORMANT;
1710 else if (link_has_carrier(link)) {
1712 uint8_t scope = RT_SCOPE_NOWHERE;
1714 /* if we have carrier, check what addresses we have */
1715 LIST_FOREACH(addresses, address, link->addresses) {
1716 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1719 if (address->scope < scope)
1720 scope = address->scope;
1723 if (scope < RT_SCOPE_SITE)
1724 /* universally accessible addresses found */
1725 link->operstate = LINK_OPERSTATE_ROUTABLE;
1726 else if (scope < RT_SCOPE_HOST)
1727 /* only link or site local addresses found */
1728 link->operstate = LINK_OPERSTATE_DEGRADED;
1730 /* no useful addresses found */
1731 link->operstate = LINK_OPERSTATE_CARRIER;
1732 } else if (link->flags & IFF_UP)
1733 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1735 link->operstate = LINK_OPERSTATE_OFF;
1738 int link_save(Link *link) {
1739 _cleanup_free_ char *temp_path = NULL;
1740 _cleanup_fclose_ FILE *f = NULL;
1741 const char *admin_state, *oper_state;
1745 assert(link->state_file);
1746 assert(link->lease_file);
1747 assert(link->manager);
1749 link_update_operstate(link);
1751 r = manager_save(link->manager);
1755 if (link->state == LINK_STATE_LINGER) {
1756 unlink(link->state_file);
1760 admin_state = link_state_to_string(link->state);
1761 assert(admin_state);
1763 oper_state = link_operstate_to_string(link->operstate);
1766 r = fopen_temporary(link->state_file, &f, &temp_path);
1770 fchmod(fileno(f), 0644);
1773 "# This is private data. Do not parse.\n"
1776 admin_state, oper_state);
1778 if (link->network) {
1779 char **address, **domain;
1782 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1786 STRV_FOREACH(address, link->network->dns) {
1793 if (link->network->dhcp_dns &&
1795 const struct in_addr *addresses;
1797 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1801 serialize_in_addrs(f, addresses, r);
1809 STRV_FOREACH(address, link->network->ntp) {
1816 if (link->network->dhcp_ntp &&
1818 const struct in_addr *addresses;
1820 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1824 serialize_in_addrs(f, addresses, r);
1830 fprintf(f, "DOMAINS=");
1832 STRV_FOREACH(domain, link->network->domains) {
1839 if (link->network->dhcp_domains &&
1841 const char *domainname;
1843 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1847 fputs(domainname, f);
1853 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1854 yes_no(link->network->wildcard_domain));
1856 fprintf(f, "LLMNR=%s\n",
1857 llmnr_support_to_string(link->network->llmnr));
1860 if (link->dhcp_lease) {
1861 assert(link->network);
1863 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
1871 unlink(link->lease_file);
1873 r = fflush_and_check(f);
1877 if (rename(temp_path, link->state_file) < 0) {
1884 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1885 unlink(link->state_file);
1890 static const char* const link_state_table[_LINK_STATE_MAX] = {
1891 [LINK_STATE_PENDING] = "pending",
1892 [LINK_STATE_ENSLAVING] = "configuring",
1893 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1894 [LINK_STATE_SETTING_ROUTES] = "configuring",
1895 [LINK_STATE_CONFIGURED] = "configured",
1896 [LINK_STATE_UNMANAGED] = "unmanaged",
1897 [LINK_STATE_FAILED] = "failed",
1898 [LINK_STATE_LINGER] = "linger",
1901 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1903 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1904 [LINK_OPERSTATE_OFF] = "off",
1905 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1906 [LINK_OPERSTATE_DORMANT] = "dormant",
1907 [LINK_OPERSTATE_CARRIER] = "carrier",
1908 [LINK_OPERSTATE_DEGRADED] = "degraded",
1909 [LINK_OPERSTATE_ROUTABLE] = "routable",
1912 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);