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->icmp6_router_discovery) {
349 if (link->dhcp6_client) {
350 k = sd_dhcp6_client_stop(link->dhcp6_client);
352 log_warning_link(link, "Could not stop DHCPv6 client: %s",
358 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
360 log_warning_link(link,
361 "Could not stop ICMPv6 router discovery: %s",
370 void link_enter_failed(Link *link) {
373 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
376 log_warning_link(link, "failed");
378 link->state = LINK_STATE_FAILED;
380 link_stop_clients(link);
385 static Address* link_find_dhcp_server_address(Link *link) {
389 assert(link->network);
391 /* The the first statically configured address if there is any */
392 LIST_FOREACH(addresses, address, link->network->static_addresses) {
394 if (address->family != AF_INET)
397 if (in_addr_is_null(address->family, &address->in_addr))
403 /* If that didn't work, find a suitable address we got from the pool */
404 LIST_FOREACH(addresses, address, link->pool_addresses) {
405 if (address->family != AF_INET)
414 static int link_enter_configured(Link *link) {
418 assert(link->network);
419 assert(link->state == LINK_STATE_SETTING_ROUTES);
421 if (link_dhcp4_server_enabled(link) &&
422 !sd_dhcp_server_is_running(link->dhcp_server)) {
423 struct in_addr pool_start;
426 address = link_find_dhcp_server_address(link);
428 log_warning_link(link,
429 "Failed to find suitable address for DHCPv4 server instance.");
430 link_enter_failed(link);
434 log_debug_link(link, "offering DHCPv4 leases");
436 r = sd_dhcp_server_set_address(link->dhcp_server,
437 &address->in_addr.in,
442 /* offer 32 addresses starting from the address following the server address */
443 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
444 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
450 r = sd_dhcp_server_set_router(link->dhcp_server,
451 &main_address->in_addr.in);
455 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
456 main_address->prefixlen);
461 r = sd_dhcp_server_start(link->dhcp_server);
463 log_warning_link(link, "could not start DHCPv4 server "
464 "instance: %s", strerror(-r));
466 link_enter_failed(link);
472 log_info_link(link, "link configured");
474 link->state = LINK_STATE_CONFIGURED;
481 void link_client_handler(Link *link) {
483 assert(link->network);
485 if (!link->static_configured)
488 if (link_ipv4ll_enabled(link))
489 if (!link->ipv4ll_address ||
493 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
496 if (link->state != LINK_STATE_CONFIGURED)
497 link_enter_configured(link);
502 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
503 _cleanup_link_unref_ Link *link = userdata;
506 assert(link->link_messages > 0);
507 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
508 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
511 link->link_messages --;
513 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
516 r = sd_rtnl_message_get_errno(m);
517 if (r < 0 && r != -EEXIST)
518 log_struct_link(LOG_WARNING, link,
519 "MESSAGE=%-*s: could not set route: %s",
521 link->ifname, strerror(-r),
525 if (link->link_messages == 0) {
526 log_debug_link(link, "routes set");
527 link->static_configured = true;
528 link_client_handler(link);
534 static int link_enter_set_routes(Link *link) {
539 assert(link->network);
540 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
542 link->state = LINK_STATE_SETTING_ROUTES;
544 LIST_FOREACH(routes, rt, link->network->static_routes) {
545 r = route_configure(rt, link, &route_handler);
547 log_warning_link(link,
548 "could not set routes: %s",
550 link_enter_failed(link);
554 link->link_messages ++;
557 if (link->link_messages == 0) {
558 link->static_configured = true;
559 link_client_handler(link);
561 log_debug_link(link, "setting routes");
566 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
567 _cleanup_link_unref_ Link *link = userdata;
572 assert(link->ifname);
574 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
577 r = sd_rtnl_message_get_errno(m);
578 if (r < 0 && r != -ESRCH)
579 log_struct_link(LOG_WARNING, link,
580 "MESSAGE=%-*s: could not drop route: %s",
582 link->ifname, strerror(-r),
589 int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
590 _cleanup_link_unref_ Link *link = userdata;
596 assert(link->manager);
598 for (; m; m = sd_rtnl_message_next(m)) {
599 r = sd_rtnl_message_get_errno(m);
601 log_debug_link(link, "getting address failed: %s",
606 r = link_rtnl_process_address(rtnl, m, link->manager);
608 log_warning_link(link, "could not process address: %s",
615 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
616 _cleanup_link_unref_ Link *link = userdata;
622 assert(link->ifname);
623 assert(link->link_messages > 0);
624 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
625 LINK_STATE_FAILED, LINK_STATE_LINGER));
627 link->link_messages --;
629 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
632 r = sd_rtnl_message_get_errno(m);
633 if (r < 0 && r != -EEXIST)
634 log_struct_link(LOG_WARNING, link,
635 "MESSAGE=%-*s: could not set address: %s",
637 link->ifname, strerror(-r),
641 /* calling handler directly so take a ref */
643 link_get_address_handler(rtnl, m, link);
646 if (link->link_messages == 0) {
647 log_debug_link(link, "addresses set");
648 link_enter_set_routes(link);
654 static int link_enter_set_addresses(Link *link) {
659 assert(link->network);
660 assert(link->state != _LINK_STATE_INVALID);
662 link->state = LINK_STATE_SETTING_ADDRESSES;
664 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
665 r = address_configure(ad, link, &address_handler);
667 log_warning_link(link,
668 "could not set addresses: %s",
670 link_enter_failed(link);
674 link->link_messages ++;
677 if (link->link_messages == 0) {
678 link_enter_set_routes(link);
680 log_debug_link(link, "setting addresses");
685 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
686 _cleanup_link_unref_ Link *link = userdata;
691 assert(link->ifname);
693 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
696 r = sd_rtnl_message_get_errno(m);
697 if (r < 0 && r != -EADDRNOTAVAIL)
698 log_struct_link(LOG_WARNING, link,
699 "MESSAGE=%-*s: could not drop address: %s",
701 link->ifname, strerror(-r),
708 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
709 sd_bus_error *ret_error) {
710 _cleanup_link_unref_ Link *link = userdata;
715 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
718 r = sd_bus_message_get_errno(m);
720 log_warning_link(link, "Could not set hostname: %s",
726 int link_set_hostname(Link *link, const char *hostname) {
727 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
731 assert(link->manager);
734 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
736 if (!link->manager->bus) {
737 /* TODO: replace by assert when we can rely on kdbus */
739 "Not connected to system bus, ignoring transient hostname.");
743 r = sd_bus_message_new_method_call(
746 "org.freedesktop.hostname1",
747 "/org/freedesktop/hostname1",
748 "org.freedesktop.hostname1",
753 r = sd_bus_message_append(m, "sb", hostname, false);
757 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
760 log_error_link(link, "Could not set transient hostname: %s",
770 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
771 _cleanup_link_unref_ Link *link = userdata;
776 assert(link->ifname);
778 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
781 r = sd_rtnl_message_get_errno(m);
783 log_struct_link(LOG_WARNING, link,
784 "MESSAGE=%-*s: could not set MTU: %s",
785 IFNAMSIZ, link->ifname, strerror(-r),
792 int link_set_mtu(Link *link, uint32_t mtu) {
793 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
797 assert(link->manager);
798 assert(link->manager->rtnl);
800 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
802 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
803 RTM_SETLINK, link->ifindex);
805 log_error_link(link, "Could not allocate RTM_SETLINK message");
809 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
811 log_error_link(link, "Could not append MTU: %s", strerror(-r));
815 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
819 "Could not send rtnetlink message: %s",
829 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
830 Link *link = userdata;
833 assert(link->network);
834 assert(link->manager);
836 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
840 case DHCP6_EVENT_STOP:
841 case DHCP6_EVENT_RESEND_EXPIRE:
842 case DHCP6_EVENT_RETRANS_MAX:
843 case DHCP6_EVENT_IP_ACQUIRE:
844 log_debug_link(link, "DHCPv6 event %d", event);
850 log_warning_link(link, "DHCPv6 error: %s",
853 log_warning_link(link, "DHCPv6 unknown event: %d",
859 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
860 Link *link = userdata;
864 assert(link->network);
865 assert(link->manager);
867 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
871 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
872 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
875 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
876 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
881 log_warning_link(link, "ICMPv6 error: %s",
884 log_warning_link(link, "ICMPv6 unknown event: %d",
890 if (link->dhcp6_client)
893 r = sd_dhcp6_client_new(&link->dhcp6_client);
897 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
899 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
903 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
904 (const uint8_t *) &link->mac,
905 sizeof (link->mac), ARPHRD_ETHER);
907 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
911 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
913 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
917 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
920 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
924 r = sd_dhcp6_client_start(link->dhcp6_client);
926 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
929 static int link_acquire_conf(Link *link) {
933 assert(link->network);
934 assert(link->manager);
935 assert(link->manager->event);
937 if (link_ipv4ll_enabled(link)) {
938 assert(link->ipv4ll);
940 log_debug_link(link, "acquiring IPv4 link-local address");
942 r = sd_ipv4ll_start(link->ipv4ll);
944 log_warning_link(link, "could not acquire IPv4 "
945 "link-local address");
950 if (link_dhcp4_enabled(link)) {
951 assert(link->dhcp_client);
953 log_debug_link(link, "acquiring DHCPv4 lease");
955 r = sd_dhcp_client_start(link->dhcp_client);
957 log_warning_link(link, "could not acquire DHCPv4 "
963 if (link_dhcp6_enabled(link)) {
964 assert(link->icmp6_router_discovery);
966 log_debug_link(link, "discovering IPv6 routers");
968 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
970 log_warning_link(link,
971 "could not start IPv6 router discovery");
979 bool link_has_carrier(Link *link) {
980 /* see Documentation/networking/operstates.txt in the kernel sources */
982 if (link->kernel_operstate == IF_OPER_UP)
985 if (link->kernel_operstate == IF_OPER_UNKNOWN)
986 /* operstate may not be implemented, so fall back to flags */
987 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
993 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
994 _cleanup_link_unref_ Link *link = userdata;
999 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1002 r = sd_rtnl_message_get_errno(m);
1004 /* we warn but don't fail the link, as it may
1005 be brought up later */
1006 log_struct_link(LOG_WARNING, link,
1007 "MESSAGE=%-*s: could not bring up interface: %s",
1009 link->ifname, strerror(-r),
1017 static int link_up(Link *link) {
1018 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1022 assert(link->manager);
1023 assert(link->manager->rtnl);
1025 log_debug_link(link, "bringing link up");
1027 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1028 RTM_SETLINK, link->ifindex);
1030 log_error_link(link, "Could not allocate RTM_SETLINK message");
1034 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1036 log_error_link(link, "Could not set link flags: %s",
1041 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1044 log_error_link(link,
1045 "Could not send rtnetlink message: %s",
1055 static int link_joined(Link *link) {
1059 assert(link->network);
1061 if (!(link->flags & IFF_UP)) {
1064 link_enter_failed(link);
1069 return link_enter_set_addresses(link);
1072 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1074 _cleanup_link_unref_ Link *link = userdata;
1078 assert(link->network);
1082 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1085 r = sd_rtnl_message_get_errno(m);
1086 if (r < 0 && r != -EEXIST) {
1087 log_struct_link(LOG_ERR, link,
1088 "MESSAGE=%-*s: could not join netdev: %s",
1090 link->ifname, strerror(-r),
1093 link_enter_failed(link);
1096 log_debug_link(link, "joined netdev");
1098 if (link->enslaving <= 0)
1104 static int link_enter_join_netdev(Link *link) {
1110 assert(link->network);
1111 assert(link->state == LINK_STATE_PENDING);
1113 link->state = LINK_STATE_ENSLAVING;
1117 if (!link->network->bridge &&
1118 !link->network->bond &&
1119 hashmap_isempty(link->network->stacked_netdevs))
1120 return link_joined(link);
1122 if (link->network->bond) {
1123 log_struct_link(LOG_DEBUG, link,
1124 "MESSAGE=%-*s: enslaving by '%s'",
1126 link->ifname, link->network->bond->ifname,
1127 NETDEVIF(link->network->bond),
1130 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1132 log_struct_link(LOG_WARNING, link,
1133 "MESSAGE=%-*s: could not join netdev '%s': %s",
1135 link->ifname, link->network->bond->ifname,
1137 NETDEVIF(link->network->bond),
1139 link_enter_failed(link);
1146 if (link->network->bridge) {
1147 log_struct_link(LOG_DEBUG, link,
1148 "MESSAGE=%-*s: enslaving by '%s'",
1150 link->ifname, link->network->bridge->ifname,
1151 NETDEVIF(link->network->bridge),
1154 r = netdev_join(link->network->bridge, link,
1155 &netdev_join_handler);
1157 log_struct_link(LOG_WARNING, link,
1158 "MESSAGE=%-*s: could not join netdev '%s': %s",
1160 link->ifname, link->network->bridge->ifname,
1162 NETDEVIF(link->network->bridge),
1164 link_enter_failed(link);
1171 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1172 log_struct_link(LOG_DEBUG, link,
1173 "MESSAGE=%-*s: enslaving by '%s'",
1175 link->ifname, netdev->ifname, NETDEVIF(netdev),
1178 r = netdev_join(netdev, link, &netdev_join_handler);
1180 log_struct_link(LOG_WARNING, link,
1181 "MESSAGE=%-*s: could not join netdev '%s': %s",
1183 link->ifname, netdev->ifname,
1185 NETDEVIF(netdev), NULL);
1186 link_enter_failed(link);
1196 static int link_configure(Link *link) {
1200 assert(link->network);
1201 assert(link->state == LINK_STATE_PENDING);
1203 if (link_ipv4ll_enabled(link)) {
1204 r = ipv4ll_configure(link);
1209 if (link_dhcp4_enabled(link)) {
1210 r = dhcp4_configure(link);
1215 if (link_dhcp4_server_enabled(link)) {
1216 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1220 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1225 if (link_dhcp6_enabled(link)) {
1226 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1230 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1235 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1240 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1245 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1246 icmp6_router_handler, link);
1251 if (link_has_carrier(link)) {
1252 r = link_acquire_conf(link);
1257 return link_enter_join_netdev(link);
1260 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1262 _cleanup_link_unref_ Link *link = userdata;
1267 assert(link->ifname);
1268 assert(link->manager);
1270 if (link->state != LINK_STATE_PENDING)
1273 log_debug_link(link, "link state is up-to-date");
1275 r = network_get(link->manager, link->udev_device, link->ifname,
1276 &link->mac, &network);
1278 link_enter_unmanaged(link);
1283 if (link->flags & IFF_LOOPBACK) {
1284 if (network->ipv4ll)
1285 log_debug_link(link, "ignoring IPv4LL for loopback link");
1287 if (network->dhcp != DHCP_SUPPORT_NONE)
1288 log_debug_link(link, "ignoring DHCP clients for loopback link");
1290 if (network->dhcp_server)
1291 log_debug_link(link, "ignoring DHCP server for loopback link");
1294 r = network_apply(link->manager, network, link);
1298 r = link_configure(link);
1305 int link_initialized(Link *link, struct udev_device *device) {
1306 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1310 assert(link->manager);
1311 assert(link->manager->rtnl);
1314 if (link->state != LINK_STATE_PENDING)
1317 if (link->udev_device)
1320 log_debug_link(link, "udev initialized link");
1322 link->udev_device = udev_device_ref(device);
1324 /* udev has initialized the link, but we don't know if we have yet
1325 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1326 * when it returns we know that the pending NEWLINKs have already been
1327 * processed and that we are up-to-date */
1329 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1334 r = sd_rtnl_call_async(link->manager->rtnl, req,
1335 link_initialized_and_synced, link, 0, NULL);
1344 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message,
1346 Manager *m = userdata;
1349 _cleanup_address_free_ Address *address = NULL;
1351 char buf[INET6_ADDRSTRLEN];
1352 char valid_buf[FORMAT_TIMESPAN_MAX];
1353 const char *valid_str = NULL;
1354 bool address_dropped = false;
1361 r = sd_rtnl_message_get_type(message, &type);
1363 log_warning("rtnl: could not get message type");
1367 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1368 if (r < 0 || ifindex <= 0) {
1369 log_warning("rtnl: received address message without valid ifindex, ignoring");
1372 r = link_get(m, ifindex, &link);
1373 if (r < 0 || !link) {
1374 log_warning("rtnl: received address for a nonexistent link (%d), ignoring", ifindex);
1379 r = address_new_dynamic(&address);
1383 r = sd_rtnl_message_addr_get_family(message, &address->family);
1384 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1385 log_warning_link(link,
1386 "rtnl: received address with invalid family, ignoring");
1390 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1392 log_warning_link(link,
1393 "rtnl: received address with invalid prefixlen, ignoring");
1397 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1399 log_warning_link(link,
1400 "rtnl: received address with invalid scope, ignoring");
1404 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1406 log_warning_link(link,
1407 "rtnl: received address with invalid flags, ignoring");
1411 switch (address->family) {
1413 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
1414 &address->in_addr.in);
1416 log_warning_link(link,
1417 "rtnl: received address without valid address, ignoring");
1424 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
1425 &address->in_addr.in6);
1427 log_warning_link(link,
1428 "rtnl: received address without valid address, ignoring");
1435 assert_not_reached("invalid address family");
1438 if (!inet_ntop(address->family, &address->in_addr, buf,
1439 INET6_ADDRSTRLEN)) {
1440 log_warning_link(link, "could not print address");
1444 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO,
1447 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1450 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1451 address->cinfo.ifa_valid * USEC_PER_SEC,
1455 LIST_FOREACH(addresses, ad, link->addresses) {
1456 if (address_equal(ad, address)) {
1457 LIST_REMOVE(addresses, link->addresses, ad);
1461 address_dropped = true;
1469 if (!address_dropped)
1470 log_debug_link(link, "added address: %s/%u (valid for %s)",
1471 buf, address->prefixlen, valid_str);
1473 log_debug_link(link, "updated address: %s/%u (valid for %s)",
1474 buf, address->prefixlen, valid_str);
1476 LIST_PREPEND(addresses, link->addresses, address);
1483 if (address_dropped) {
1484 log_debug_link(link, "removed address: %s/%u (valid for %s)",
1485 buf, address->prefixlen, valid_str);
1489 log_warning_link(link,
1490 "removing non-existent address: %s/%u (valid for %s)",
1491 buf, address->prefixlen, valid_str);
1495 assert_not_reached("Received invalid RTNL message type");
1501 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1503 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1504 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1505 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1513 r = link_new(m, message, ret);
1519 log_debug_link(link, "link %d added", link->ifindex);
1521 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex,
1526 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0,
1533 if (detect_container(NULL) <= 0) {
1534 /* not in a container, udev will be around */
1535 sprintf(ifindex_str, "n%d", link->ifindex);
1536 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1538 log_warning_link(link,
1539 "could not find udev device: %m");
1543 if (udev_device_get_is_initialized(device) <= 0) {
1545 log_debug_link(link, "link pending udev initialization...");
1549 r = link_initialized(link, device);
1553 /* we are calling a callback directly, so must take a ref */
1556 r = link_initialized_and_synced(m->rtnl, NULL, link);
1564 int link_update(Link *link, sd_rtnl_message *m) {
1565 struct ether_addr mac;
1568 bool had_carrier, carrier_gained, carrier_lost;
1572 assert(link->ifname);
1575 if (link->state == LINK_STATE_LINGER) {
1577 log_info_link(link, "link readded");
1578 link->state = LINK_STATE_ENSLAVING;
1581 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1582 if (r >= 0 && !streq(ifname, link->ifname)) {
1583 log_info_link(link, "renamed to %s", ifname);
1586 link->ifname = strdup(ifname);
1591 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1592 if (r >= 0 && mtu > 0) {
1594 if (!link->original_mtu) {
1595 link->original_mtu = mtu;
1596 log_debug_link(link, "saved original MTU: %"
1597 PRIu32, link->original_mtu);
1600 if (link->dhcp_client) {
1601 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1604 log_warning_link(link,
1605 "Could not update MTU in DHCP client: %s",
1612 /* The kernel may broadcast NEWLINK messages without the MAC address
1613 set, simply ignore them. */
1614 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1616 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1619 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1622 log_debug_link(link, "MAC address: "
1623 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1624 mac.ether_addr_octet[0],
1625 mac.ether_addr_octet[1],
1626 mac.ether_addr_octet[2],
1627 mac.ether_addr_octet[3],
1628 mac.ether_addr_octet[4],
1629 mac.ether_addr_octet[5]);
1632 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1634 log_warning_link(link,
1635 "Could not update MAC address in IPv4LL client: %s",
1641 if (link->dhcp_client) {
1642 r = sd_dhcp_client_set_mac(link->dhcp_client,
1643 (const uint8_t *) &link->mac,
1647 log_warning_link(link,
1648 "Could not update MAC address in DHCP client: %s",
1654 if (link->dhcp6_client) {
1655 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1656 (const uint8_t *) &link->mac,
1660 log_warning_link(link,
1661 "Could not update MAC address in DHCPv6 client: %s",
1669 had_carrier = link_has_carrier(link);
1671 r = link_update_flags(link, m);
1675 carrier_gained = !had_carrier && link_has_carrier(link);
1676 carrier_lost = had_carrier && !link_has_carrier(link);
1678 if (carrier_gained) {
1679 log_info_link(link, "gained carrier");
1681 if (link->network) {
1682 r = link_acquire_conf(link);
1684 link_enter_failed(link);
1688 } else if (carrier_lost) {
1689 log_info_link(link, "lost carrier");
1691 r = link_stop_clients(link);
1693 link_enter_failed(link);
1701 static void link_update_operstate(Link *link) {
1705 if (link->kernel_operstate == IF_OPER_DORMANT)
1706 link->operstate = LINK_OPERSTATE_DORMANT;
1707 else if (link_has_carrier(link)) {
1709 uint8_t scope = RT_SCOPE_NOWHERE;
1711 /* if we have carrier, check what addresses we have */
1712 LIST_FOREACH(addresses, address, link->addresses) {
1713 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1716 if (address->scope < scope)
1717 scope = address->scope;
1720 if (scope < RT_SCOPE_SITE)
1721 /* universally accessible addresses found */
1722 link->operstate = LINK_OPERSTATE_ROUTABLE;
1723 else if (scope < RT_SCOPE_HOST)
1724 /* only link or site local addresses found */
1725 link->operstate = LINK_OPERSTATE_DEGRADED;
1727 /* no useful addresses found */
1728 link->operstate = LINK_OPERSTATE_CARRIER;
1729 } else if (link->flags & IFF_UP)
1730 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1732 link->operstate = LINK_OPERSTATE_OFF;
1735 int link_save(Link *link) {
1736 _cleanup_free_ char *temp_path = NULL;
1737 _cleanup_fclose_ FILE *f = NULL;
1738 const char *admin_state, *oper_state;
1742 assert(link->state_file);
1743 assert(link->lease_file);
1744 assert(link->manager);
1746 link_update_operstate(link);
1748 r = manager_save(link->manager);
1752 if (link->state == LINK_STATE_LINGER) {
1753 unlink(link->state_file);
1757 admin_state = link_state_to_string(link->state);
1758 assert(admin_state);
1760 oper_state = link_operstate_to_string(link->operstate);
1763 r = fopen_temporary(link->state_file, &f, &temp_path);
1767 fchmod(fileno(f), 0644);
1770 "# This is private data. Do not parse.\n"
1773 admin_state, oper_state);
1775 if (link->network) {
1776 char **address, **domain;
1779 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1783 STRV_FOREACH(address, link->network->dns) {
1790 if (link->network->dhcp_dns &&
1792 const struct in_addr *addresses;
1794 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1798 serialize_in_addrs(f, addresses, r);
1806 STRV_FOREACH(address, link->network->ntp) {
1813 if (link->network->dhcp_ntp &&
1815 const struct in_addr *addresses;
1817 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1821 serialize_in_addrs(f, addresses, r);
1827 fprintf(f, "DOMAINS=");
1829 STRV_FOREACH(domain, link->network->domains) {
1836 if (link->network->dhcp_domains &&
1838 const char *domainname;
1840 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1844 fputs(domainname, f);
1850 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1851 yes_no(link->network->wildcard_domain));
1853 fprintf(f, "LLMNR=%s\n",
1854 llmnr_support_to_string(link->network->llmnr));
1857 if (link->dhcp_lease) {
1858 assert(link->network);
1860 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1868 unlink(link->lease_file);
1870 r = fflush_and_check(f);
1874 if (rename(temp_path, link->state_file) < 0) {
1881 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1882 unlink(link->state_file);
1887 static const char* const link_state_table[_LINK_STATE_MAX] = {
1888 [LINK_STATE_PENDING] = "pending",
1889 [LINK_STATE_ENSLAVING] = "configuring",
1890 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1891 [LINK_STATE_SETTING_ROUTES] = "configuring",
1892 [LINK_STATE_CONFIGURED] = "configured",
1893 [LINK_STATE_UNMANAGED] = "unmanaged",
1894 [LINK_STATE_FAILED] = "failed",
1895 [LINK_STATE_LINGER] = "linger",
1898 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1900 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1901 [LINK_OPERSTATE_OFF] = "off",
1902 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1903 [LINK_OPERSTATE_DORMANT] = "dormant",
1904 [LINK_OPERSTATE_CARRIER] = "carrier",
1905 [LINK_OPERSTATE_DEGRADED] = "degraded",
1906 [LINK_OPERSTATE_ROUTABLE] = "routable",
1909 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);