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 "libudev-private.h"
27 #include "udev-util.h"
31 #include "network-internal.h"
33 #include "network-util.h"
34 #include "dhcp-lease-internal.h"
36 static int ipv4ll_address_update(Link *link, bool deprecate);
37 static bool ipv4ll_is_bound(sd_ipv4ll *ll);
39 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
40 _cleanup_link_unref_ Link *link = NULL;
46 assert(manager->links);
50 r = sd_rtnl_message_get_type(message, &type);
53 else if (type != RTM_NEWLINK)
56 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
59 else if (ifindex <= 0)
62 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
71 link->manager = manager;
72 link->state = LINK_STATE_INITIALIZING;
73 link->ifindex = ifindex;
74 link->ifname = strdup(ifname);
78 r = asprintf(&link->state_file, "/run/systemd/network/links/%"PRIu64,
83 r = asprintf(&link->lease_file, "/run/systemd/network/leases/%"PRIu64,
88 r = hashmap_put(manager->links, &link->ifindex, link);
98 static void link_free(Link *link) {
104 assert(link->manager);
106 while ((address = link->addresses)) {
107 LIST_REMOVE(addresses, link->addresses, address);
108 address_free(address);
111 sd_dhcp_client_unref(link->dhcp_client);
112 sd_dhcp_lease_unref(link->dhcp_lease);
114 unlink(link->lease_file);
115 free(link->lease_file);
117 sd_ipv4ll_unref(link->ipv4ll);
119 hashmap_remove(link->manager->links, &link->ifindex);
123 unlink(link->state_file);
124 free(link->state_file);
126 udev_device_unref(link->udev_device);
131 Link *link_unref(Link *link) {
132 if (link && (-- link->n_ref <= 0))
138 Link *link_ref(Link *link) {
140 assert_se(++ link->n_ref >= 2);
145 int link_get(Manager *m, int ifindex, Link **ret) {
154 ifindex_64 = ifindex;
155 link = hashmap_get(m->links, &ifindex_64);
164 void link_drop(Link *link) {
165 if (!link || link->state == LINK_STATE_LINGER)
168 link->state = LINK_STATE_LINGER;
170 log_debug_link(link, "link removed");
177 static int link_enter_configured(Link *link) {
179 assert(link->state == LINK_STATE_SETTING_ROUTES);
181 log_info_link(link, "link configured");
183 link->state = LINK_STATE_CONFIGURED;
190 static void link_enter_unmanaged(Link *link) {
193 log_debug_link(link, "unmanaged");
195 link->state = LINK_STATE_UNMANAGED;
200 static int link_stop_clients(Link *link) {
204 assert(link->manager);
205 assert(link->manager->event);
210 if (link->network->dhcp) {
211 assert(link->dhcp_client);
213 k = sd_dhcp_client_stop(link->dhcp_client);
215 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
220 if (link->network->ipv4ll) {
221 assert(link->ipv4ll);
223 k = sd_ipv4ll_stop(link->ipv4ll);
225 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
233 static void link_enter_failed(Link *link) {
236 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
239 log_warning_link(link, "failed");
241 link->state = LINK_STATE_FAILED;
243 link_stop_clients(link);
248 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
249 Link *link = userdata;
252 assert(link->route_messages > 0);
253 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
254 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
257 link->route_messages --;
259 if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER)) {
264 r = sd_rtnl_message_get_errno(m);
265 if (r < 0 && r != -EEXIST)
266 log_struct_link(LOG_WARNING, link,
267 "MESSAGE=%*s: could not set route: %s",
269 link->ifname, strerror(-r),
273 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
275 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
276 log_debug_link(link, "routes set");
277 link_enter_configured(link);
285 static int link_enter_set_routes(Link *link) {
290 assert(link->network);
291 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
293 link->state = LINK_STATE_SETTING_ROUTES;
295 if (!link->network->static_routes && !link->dhcp_lease &&
296 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
297 return link_enter_configured(link);
299 log_debug_link(link, "setting routes");
301 LIST_FOREACH(routes, rt, link->network->static_routes) {
302 r = route_configure(rt, link, &route_handler);
304 log_warning_link(link,
305 "could not set routes: %s", strerror(-r));
306 link_enter_failed(link);
311 link->route_messages ++;
314 if (link->ipv4ll && !link->dhcp_lease) {
315 _cleanup_route_free_ Route *route = NULL;
318 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
319 if (r < 0 && r != -ENOENT) {
320 log_warning_link(link, "IPV4LL error: no address: %s",
326 r = route_new_dynamic(&route);
328 log_error_link(link, "Could not allocate route: %s",
333 route->family = AF_INET;
334 route->scope = RT_SCOPE_LINK;
337 r = route_configure(route, link, &route_handler);
339 log_warning_link(link,
340 "could not set routes: %s", strerror(-r));
341 link_enter_failed(link);
346 link->route_messages ++;
350 if (link->dhcp_lease) {
351 _cleanup_route_free_ Route *route = NULL;
352 _cleanup_route_free_ Route *route_gw = NULL;
353 struct in_addr gateway;
355 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
356 if (r < 0 && r != -ENOENT) {
357 log_warning_link(link, "DHCP error: %s", strerror(-r));
362 r = route_new_dynamic(&route);
364 log_error_link(link, "Could not allocate route: %s",
369 r = route_new_dynamic(&route_gw);
371 log_error_link(link, "Could not allocate route: %s",
376 /* The dhcp netmask may mask out the gateway. Add an explicit
377 * route for the gw host so that we can route no matter the
378 * netmask or existing kernel route tables. */
379 route_gw->family = AF_INET;
380 route_gw->dst_addr.in = gateway;
381 route_gw->dst_prefixlen = 32;
382 route_gw->scope = RT_SCOPE_LINK;
384 r = route_configure(route_gw, link, &route_handler);
386 log_warning_link(link,
387 "could not set host route: %s", strerror(-r));
392 link->route_messages ++;
394 route->family = AF_INET;
395 route->in_addr.in = gateway;
397 r = route_configure(route, link, &route_handler);
399 log_warning_link(link,
400 "could not set routes: %s", strerror(-r));
401 link_enter_failed(link);
406 link->route_messages ++;
410 if (link->route_messages == 0) {
411 link_enter_configured(link);
417 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
418 Link *link = userdata;
423 assert(link->ifname);
425 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
430 r = sd_rtnl_message_get_errno(m);
431 if (r < 0 && r != -ESRCH)
432 log_struct_link(LOG_WARNING, link,
433 "MESSAGE=%*s: could not drop route: %s",
435 link->ifname, strerror(-r),
444 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
445 Link *link = userdata;
450 assert(link->ifname);
451 assert(link->addr_messages > 0);
452 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
453 LINK_STATE_FAILED, LINK_STATE_LINGER));
455 link->addr_messages --;
457 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
462 r = sd_rtnl_message_get_errno(m);
463 if (r < 0 && r != -EEXIST)
464 log_struct_link(LOG_WARNING, link,
465 "MESSAGE=%*s: could not set address: %s",
467 link->ifname, strerror(-r),
471 if (link->addr_messages == 0) {
472 log_debug_link(link, "addresses set");
473 link_enter_set_routes(link);
481 static int link_enter_set_addresses(Link *link) {
486 assert(link->network);
487 assert(link->state != _LINK_STATE_INVALID);
489 link->state = LINK_STATE_SETTING_ADDRESSES;
491 if (!link->network->static_addresses && !link->dhcp_lease &&
492 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
493 return link_enter_set_routes(link);
495 log_debug_link(link, "setting addresses");
497 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
498 r = address_configure(ad, link, &address_handler);
500 log_warning_link(link,
501 "could not set addresses: %s", strerror(-r));
502 link_enter_failed(link);
507 link->addr_messages ++;
510 if (link->ipv4ll && !link->dhcp_lease) {
511 _cleanup_address_free_ Address *ll_addr = NULL;
514 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
515 if (r < 0 && r != -ENOENT) {
516 log_warning_link(link, "IPV4LL error: no address: %s",
522 r = address_new_dynamic(&ll_addr);
524 log_error_link(link, "Could not allocate address: %s", strerror(-r));
528 ll_addr->family = AF_INET;
529 ll_addr->in_addr.in = addr;
530 ll_addr->prefixlen = 16;
531 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
532 ll_addr->scope = RT_SCOPE_LINK;
534 r = address_configure(ll_addr, link, &address_handler);
536 log_warning_link(link,
537 "could not set addresses: %s", strerror(-r));
538 link_enter_failed(link);
543 link->addr_messages ++;
547 if (link->dhcp_lease) {
548 _cleanup_address_free_ Address *address = NULL;
550 struct in_addr netmask;
553 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
555 log_warning_link(link, "DHCP error: no address: %s",
560 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
562 log_warning_link(link, "DHCP error: no netmask: %s",
567 prefixlen = net_netmask_to_prefixlen(&netmask);
569 r = address_new_dynamic(&address);
571 log_error_link(link, "Could not allocate address: %s",
576 address->family = AF_INET;
577 address->in_addr.in = addr;
578 address->prefixlen = prefixlen;
579 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
581 r = address_configure(address, link, &address_handler);
583 log_warning_link(link,
584 "could not set addresses: %s", strerror(-r));
585 link_enter_failed(link);
590 link->addr_messages ++;
596 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
597 Link *link = userdata;
602 assert(link->ifname);
604 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
609 r = sd_rtnl_message_get_errno(m);
610 if (r < 0 && r != -ENOENT)
611 log_struct_link(LOG_WARNING, link,
612 "MESSAGE=%*s: could not update address: %s",
614 link->ifname, strerror(-r),
623 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
624 Link *link = userdata;
629 assert(link->ifname);
631 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
636 r = sd_rtnl_message_get_errno(m);
637 if (r < 0 && r != -EADDRNOTAVAIL)
638 log_struct_link(LOG_WARNING, link,
639 "MESSAGE=%*s: could not drop address: %s",
641 link->ifname, strerror(-r),
650 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
651 Link *link = userdata;
656 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
661 r = sd_bus_message_get_errno(m);
663 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
670 static int link_set_hostname(Link *link, const char *hostname) {
671 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
675 assert(link->manager);
678 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
680 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
681 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
685 r = sd_bus_message_new_method_call(
688 "org.freedesktop.hostname1",
689 "/org/freedesktop/hostname1",
690 "org.freedesktop.hostname1",
695 r = sd_bus_message_append(m, "sb", hostname, false);
699 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
701 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
708 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
709 Link *link = userdata;
714 assert(link->ifname);
716 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
721 r = sd_rtnl_message_get_errno(m);
723 log_struct_link(LOG_WARNING, link,
724 "MESSAGE=%s: could not set MTU: %s",
725 link->ifname, strerror(-r),
734 static int link_set_mtu(Link *link, uint32_t mtu) {
735 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
739 assert(link->manager);
740 assert(link->manager->rtnl);
742 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
744 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
745 RTM_SETLINK, link->ifindex);
747 log_error_link(link, "Could not allocate RTM_SETLINK message");
751 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
753 log_error_link(link, "Could not append MTU: %s", strerror(-r));
757 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
760 "Could not send rtnetlink message: %s", strerror(-r));
769 static int dhcp_lease_lost(Link *link) {
770 _cleanup_address_free_ Address *address = NULL;
771 _cleanup_route_free_ Route *route_gw = NULL;
772 _cleanup_route_free_ Route *route = NULL;
774 struct in_addr netmask;
775 struct in_addr gateway;
780 assert(link->dhcp_lease);
782 log_warning_link(link, "DHCP lease lost");
784 r = address_new_dynamic(&address);
786 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
788 r = route_new_dynamic(&route_gw);
790 route_gw->family = AF_INET;
791 route_gw->dst_addr.in = gateway;
792 route_gw->dst_prefixlen = 32;
793 route_gw->scope = RT_SCOPE_LINK;
795 route_drop(route_gw, link, &route_drop_handler);
799 r = route_new_dynamic(&route);
801 route->family = AF_INET;
802 route->in_addr.in = gateway;
804 route_drop(route, link, &route_drop_handler);
809 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
810 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
811 prefixlen = net_netmask_to_prefixlen(&netmask);
813 address->family = AF_INET;
814 address->in_addr.in = addr;
815 address->prefixlen = prefixlen;
817 address_drop(address, link, &address_drop_handler);
821 if (link->network->dhcp_mtu) {
824 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
825 if (r >= 0 && link->original_mtu != mtu) {
826 r = link_set_mtu(link, link->original_mtu);
828 log_warning_link(link, "DHCP error: could not reset MTU");
829 link_enter_failed(link);
835 if (link->network->dhcp_hostname) {
836 const char *hostname = NULL;
838 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
839 if (r >= 0 && hostname) {
840 r = link_set_hostname(link, "");
842 log_error_link(link, "Failed to reset transient hostname");
846 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
851 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
852 sd_dhcp_lease *lease;
853 struct in_addr address;
854 struct in_addr netmask;
855 struct in_addr gateway;
862 r = sd_dhcp_client_get_lease(client, &lease);
864 log_warning_link(link, "DHCP error: no lease: %s",
869 r = sd_dhcp_lease_get_address(lease, &address);
871 log_warning_link(link, "DHCP error: no address: %s",
876 r = sd_dhcp_lease_get_netmask(lease, &netmask);
878 log_warning_link(link, "DHCP error: no netmask: %s",
883 prefixlen = net_netmask_to_prefixlen(&netmask);
885 r = sd_dhcp_lease_get_router(lease, &gateway);
886 if (r < 0 && r != -ENOENT) {
887 log_warning_link(link, "DHCP error: %s", strerror(-r));
892 log_struct_link(LOG_INFO, link,
893 "MESSAGE=%*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
896 ADDRESS_FMT_VAL(address),
898 ADDRESS_FMT_VAL(gateway),
899 "ADDRESS=%u.%u.%u.%u",
900 ADDRESS_FMT_VAL(address),
903 "GATEWAY=%u.%u.%u.%u",
904 ADDRESS_FMT_VAL(gateway),
907 log_struct_link(LOG_INFO, link,
908 "MESSAGE=%*s: DHCPv4 address %u.%u.%u.%u/%u",
911 ADDRESS_FMT_VAL(address),
913 "ADDRESS=%u.%u.%u.%u",
914 ADDRESS_FMT_VAL(address),
919 link->dhcp_lease = lease;
921 if (link->network->dhcp_mtu) {
924 r = sd_dhcp_lease_get_mtu(lease, &mtu);
926 r = link_set_mtu(link, mtu);
928 log_error_link(link, "Failed to set MTU "
933 if (link->network->dhcp_hostname) {
934 const char *hostname;
936 r = sd_dhcp_lease_get_hostname(lease, &hostname);
938 r = link_set_hostname(link, hostname);
940 log_error_link(link, "Failed to set transient hostname "
941 "to '%s'", hostname);
945 link_enter_set_addresses(link);
950 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
951 Link *link = userdata;
955 assert(link->network);
956 assert(link->manager);
958 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
962 case DHCP_EVENT_NO_LEASE:
963 log_debug_link(link, "IP address in use.");
965 case DHCP_EVENT_EXPIRED:
966 case DHCP_EVENT_STOP:
967 case DHCP_EVENT_IP_CHANGE:
968 if (link->network->dhcp_critical) {
969 log_error_link(link, "DHCPv4 connection considered system critical, "
970 "ignoring request to reconfigure it.");
974 if (link->dhcp_lease) {
975 r = dhcp_lease_lost(link);
977 link_enter_failed(link);
982 if (event == DHCP_EVENT_IP_CHANGE) {
983 r = dhcp_lease_acquired(client, link);
985 link_enter_failed(link);
990 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
991 if (!sd_ipv4ll_is_running(link->ipv4ll))
992 r = sd_ipv4ll_start(link->ipv4ll);
993 else if (ipv4ll_is_bound(link->ipv4ll))
994 r = ipv4ll_address_update(link, false);
996 link_enter_failed(link);
1002 case DHCP_EVENT_IP_ACQUIRE:
1003 r = dhcp_lease_acquired(client, link);
1005 link_enter_failed(link);
1009 if (ipv4ll_is_bound(link->ipv4ll))
1010 r = ipv4ll_address_update(link, true);
1012 r = sd_ipv4ll_stop(link->ipv4ll);
1014 link_enter_failed(link);
1021 log_warning_link(link, "DHCP error: %s", strerror(-event));
1023 log_warning_link(link, "DHCP unknown event: %d", event);
1030 static int ipv4ll_address_update(Link *link, bool deprecate) {
1032 struct in_addr addr;
1036 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1038 _cleanup_address_free_ Address *address = NULL;
1040 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1041 deprecate ? "deprecate" : "approve",
1042 ADDRESS_FMT_VAL(addr));
1044 r = address_new_dynamic(&address);
1046 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1050 address->family = AF_INET;
1051 address->in_addr.in = addr;
1052 address->prefixlen = 16;
1053 address->scope = RT_SCOPE_LINK;
1054 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1055 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1057 address_update(address, link, &address_update_handler);
1065 static int ipv4ll_address_lost(Link *link) {
1067 struct in_addr addr;
1071 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1073 _cleanup_address_free_ Address *address = NULL;
1074 _cleanup_route_free_ Route *route = NULL;
1076 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1077 ADDRESS_FMT_VAL(addr));
1079 r = address_new_dynamic(&address);
1081 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1085 address->family = AF_INET;
1086 address->in_addr.in = addr;
1087 address->prefixlen = 16;
1088 address->scope = RT_SCOPE_LINK;
1090 address_drop(address, link, &address_drop_handler);
1093 r = route_new_dynamic(&route);
1095 log_error_link(link, "Could not allocate route: %s",
1100 route->family = AF_INET;
1101 route->scope = RT_SCOPE_LINK;
1102 route->metrics = 99;
1104 route_drop(route, link, &route_drop_handler);
1111 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1113 struct in_addr addr;
1117 r = sd_ipv4ll_get_address(ll, &addr);
1123 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1124 struct in_addr address;
1130 r = sd_ipv4ll_get_address(ll, &address);
1134 log_struct_link(LOG_INFO, link,
1135 "MESSAGE=%*s: IPv4 link-local address %u.%u.%u.%u",
1138 ADDRESS_FMT_VAL(address),
1141 link_enter_set_addresses(link);
1146 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1147 Link *link = userdata;
1151 assert(link->network);
1152 assert(link->manager);
1154 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1158 case IPV4LL_EVENT_STOP:
1159 case IPV4LL_EVENT_CONFLICT:
1160 r = ipv4ll_address_lost(link);
1162 link_enter_failed(link);
1166 case IPV4LL_EVENT_BIND:
1167 r = ipv4ll_address_claimed(ll, link);
1169 link_enter_failed(link);
1175 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1177 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1182 static int link_acquire_conf(Link *link) {
1186 assert(link->network);
1187 assert(link->manager);
1188 assert(link->manager->event);
1190 if (link->network->ipv4ll) {
1191 assert(link->ipv4ll);
1193 log_debug_link(link, "acquiring IPv4 link-local address");
1195 r = sd_ipv4ll_start(link->ipv4ll);
1197 log_warning_link(link, "could not acquire IPv4 "
1198 "link-local address");
1203 if (link->network->dhcp) {
1204 assert(link->dhcp_client);
1206 log_debug_link(link, "acquiring DHCPv4 lease");
1208 r = sd_dhcp_client_start(link->dhcp_client);
1210 log_warning_link(link, "could not acquire DHCPv4 "
1219 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1220 /* see Documentation/networking/operstates.txt in the kernel sources */
1222 if (operstate == IF_OPER_UP)
1225 if (operstate == IF_OPER_UNKNOWN)
1226 /* operstate may not be implemented, so fall back to flags */
1227 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1233 #define FLAG_STRING(string, flag, old, new) \
1234 (((old ^ new) & flag) \
1235 ? ((old & flag) ? (" -" string) : (" +" string)) \
1238 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1239 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1241 bool carrier_gained = false, carrier_lost = false;
1246 r = sd_rtnl_message_link_get_flags(m, &flags);
1248 log_warning_link(link, "Could not get link flags");
1252 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1254 /* if we got a message without operstate, take it to mean
1255 the state was unchanged */
1256 operstate = link->kernel_operstate;
1258 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1261 if (link->flags != flags) {
1262 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",
1263 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1264 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1265 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1266 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1267 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1268 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1269 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1270 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1271 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1272 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1273 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1274 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1275 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1276 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1277 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1278 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1279 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1280 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1281 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1283 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1284 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1285 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1286 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1287 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1288 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1289 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1290 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1292 /* link flags are currently at most 18 bits, let's align to printing 20 */
1293 if (unknown_flags_added)
1294 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1295 unknown_flags_added);
1297 if (unknown_flags_removed)
1298 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1299 unknown_flags_removed);
1302 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1303 link_has_carrier(flags, operstate);
1304 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1305 !link_has_carrier(flags, operstate);
1307 link->flags = flags;
1308 link->kernel_operstate = operstate;
1312 if (link->state == LINK_STATE_FAILED ||
1313 link->state == LINK_STATE_UNMANAGED)
1316 if (carrier_gained) {
1317 log_info_link(link, "gained carrier");
1319 if (link->network) {
1320 r = link_acquire_conf(link);
1322 link_enter_failed(link);
1326 } else if (carrier_lost) {
1327 log_info_link(link, "lost carrier");
1329 r = link_stop_clients(link);
1331 link_enter_failed(link);
1339 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1340 Link *link = userdata;
1345 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1350 r = sd_rtnl_message_get_errno(m);
1352 /* we warn but don't fail the link, as it may
1353 be brought up later */
1354 log_struct_link(LOG_WARNING, link,
1355 "MESSAGE=%*s: could not bring up interface: %s",
1357 link->ifname, strerror(-r),
1367 static int link_up(Link *link) {
1368 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1372 assert(link->manager);
1373 assert(link->manager->rtnl);
1375 log_debug_link(link, "bringing link up");
1377 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1378 RTM_SETLINK, link->ifindex);
1380 log_error_link(link, "Could not allocate RTM_SETLINK message");
1384 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1386 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1390 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1392 log_error_link(link,
1393 "Could not send rtnetlink message: %s", strerror(-r));
1402 static int link_enslaved(Link *link) {
1406 assert(link->state == LINK_STATE_ENSLAVING);
1407 assert(link->network);
1409 if (!(link->flags & IFF_UP)) {
1412 link_enter_failed(link);
1417 if (!link->network->dhcp && !link->network->ipv4ll)
1418 return link_enter_set_addresses(link);
1423 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1424 Link *link = userdata;
1428 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1429 LINK_STATE_LINGER));
1430 assert(link->network);
1434 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1439 r = sd_rtnl_message_get_errno(m);
1441 log_struct_link(LOG_ERR, link,
1442 "MESSAGE=%*s: could not enslave: %s",
1444 link->ifname, strerror(-r),
1447 link_enter_failed(link);
1452 log_debug_link(link, "enslaved");
1454 if (link->enslaving == 0)
1455 link_enslaved(link);
1462 static int link_enter_enslave(Link *link) {
1463 NetDev *vlan, *macvlan;
1468 assert(link->network);
1469 assert(link->state == LINK_STATE_INITIALIZING);
1471 link->state = LINK_STATE_ENSLAVING;
1475 if (!link->network->bridge &&
1476 !link->network->bond &&
1477 !link->network->tunnel &&
1478 hashmap_isempty(link->network->vlans) &&
1479 hashmap_isempty(link->network->macvlans))
1480 return link_enslaved(link);
1482 if (link->network->bond) {
1483 log_struct_link(LOG_DEBUG, link,
1484 "MESSAGE=%*s: enslaving by '%s'",
1486 link->ifname, link->network->bond->ifname,
1487 NETDEV(link->network->bond),
1490 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1492 log_struct_link(LOG_WARNING, link,
1493 "MESSAGE=%*s: could not enslave by '%s': %s",
1495 link->ifname, link->network->bond->ifname, strerror(-r),
1496 NETDEV(link->network->bond),
1498 link_enter_failed(link);
1506 if (link->network->bridge) {
1507 log_struct_link(LOG_DEBUG, link,
1508 "MESSAGE=%*s: enslaving by '%s'",
1510 link->ifname, link->network->bridge->ifname,
1511 NETDEV(link->network->bridge),
1514 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1516 log_struct_link(LOG_WARNING, link,
1517 "MESSAGE=%*s: could not enslave by '%s': %s",
1519 link->ifname, link->network->bridge->ifname, strerror(-r),
1520 NETDEV(link->network->bridge),
1522 link_enter_failed(link);
1530 if (link->network->tunnel) {
1531 log_struct_link(LOG_DEBUG, link,
1532 "MESSAGE=%*s: enslaving by '%s'",
1534 link->ifname, link->network->tunnel->ifname,
1535 NETDEV(link->network->tunnel),
1538 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1540 log_struct_link(LOG_WARNING, link,
1541 "MESSAGE=%*s: could not enslave by '%s': %s",
1543 link->ifname, link->network->tunnel->ifname, strerror(-r),
1544 NETDEV(link->network->tunnel),
1546 link_enter_failed(link);
1554 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1555 log_struct_link(LOG_DEBUG, link,
1556 "MESSAGE=%*s: enslaving by '%s'",
1558 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1560 r = netdev_enslave(vlan, link, &enslave_handler);
1562 log_struct_link(LOG_WARNING, link,
1563 "MESSAGE=%*s: could not enslave by '%s': %s",
1565 link->ifname, vlan->ifname, strerror(-r),
1566 NETDEV(vlan), NULL);
1567 link_enter_failed(link);
1575 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1576 log_struct_link(LOG_DEBUG, link,
1577 "MESSAGE=%*s: enslaving by '%s'",
1579 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1581 r = netdev_enslave(macvlan, link, &enslave_handler);
1583 log_struct_link(LOG_WARNING, link,
1584 "MESSAGE=%*s: could not enslave by '%s': %s",
1586 link->ifname, macvlan->ifname, strerror(-r),
1587 NETDEV(macvlan), NULL);
1588 link_enter_failed(link);
1599 static int link_configure(Link *link) {
1603 assert(link->state == LINK_STATE_INITIALIZING);
1605 if (link->network->ipv4ll) {
1608 r = sd_ipv4ll_new(&link->ipv4ll);
1612 if (link->udev_device) {
1613 r = net_get_unique_predictable_data(link->udev_device, seed);
1615 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1621 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1625 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1629 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1633 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1638 if (link->network->dhcp) {
1639 r = sd_dhcp_client_new(&link->dhcp_client);
1643 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1647 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1651 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1655 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1659 if (link->network->dhcp_mtu) {
1660 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1666 if (link_has_carrier(link->flags, link->kernel_operstate)) {
1667 r = link_acquire_conf(link);
1672 return link_enter_enslave(link);
1675 int link_initialized(Link *link, struct udev_device *device) {
1680 assert(link->ifname);
1681 assert(link->manager);
1683 if (link->state != LINK_STATE_INITIALIZING)
1687 link->udev_device = udev_device_ref(device);
1689 log_debug_link(link, "udev initialized link");
1691 r = network_get(link->manager, device, link->ifname, &link->mac, &network);
1693 link_enter_unmanaged(link);
1698 r = network_apply(link->manager, network, link);
1702 r = link_configure(link);
1709 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1710 Manager *m = userdata;
1713 _cleanup_address_free_ Address *address = NULL;
1715 char buf[INET6_ADDRSTRLEN];
1716 bool address_dropped = false;
1723 r = sd_rtnl_message_get_type(message, &type);
1725 log_warning("rtnl: could not get message type");
1729 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1730 if (r < 0 || ifindex <= 0) {
1731 log_warning("rtnl: received address message without valid ifindex, ignoring");
1734 r = link_get(m, ifindex, &link);
1735 if (r < 0 || !link) {
1736 log_warning("rtnl: received address for a nonexistent link, ignoring");
1741 r = address_new_dynamic(&address);
1745 r = sd_rtnl_message_addr_get_family(message, &address->family);
1746 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1747 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
1751 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1753 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
1757 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1759 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
1763 switch (address->family) {
1765 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1767 log_warning_link(link, "rtnl: received address without valid address, ignoring");
1774 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1776 log_warning_link(link, "rtnl: received address without valid address, ignoring");
1783 assert_not_reached("invalid address family");
1786 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1787 log_warning_link(link, "could not print address");
1791 LIST_FOREACH(addresses, ad, link->addresses) {
1792 if (address_equal(ad, address)) {
1793 LIST_REMOVE(addresses, link->addresses, ad);
1797 address_dropped = true;
1805 if (!address_dropped)
1806 log_debug_link(link, "added address: %s/%u", buf,
1807 address->prefixlen);
1809 LIST_PREPEND(addresses, link->addresses, address);
1816 if (address_dropped) {
1817 log_debug_link(link, "removed address: %s/%u", buf,
1818 address->prefixlen);
1825 assert_not_reached("Received invalid RTNL message type");
1831 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1832 Link *link = userdata;
1839 for (; m; m = sd_rtnl_message_next(m)) {
1840 r = sd_rtnl_message_get_errno(m);
1842 log_debug_link(link, "getting address failed: %s", strerror(-r));
1846 r = link_rtnl_process_address(rtnl, m, link->manager);
1848 log_warning_link(link, "could not process address: %s", strerror(-r));
1854 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1856 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1857 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1858 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1866 r = link_new(m, message, ret);
1872 log_debug_link(link, "link %"PRIu64" added", link->ifindex);
1874 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
1878 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
1882 if (detect_container(NULL) <= 0) {
1883 /* not in a container, udev will be around */
1884 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
1885 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1887 log_warning_link(link, "could not find udev device");
1891 if (udev_device_get_is_initialized(device) <= 0) {
1893 log_debug_link(link, "udev initializing link...");
1898 r = link_initialized(link, device);
1905 int link_update(Link *link, sd_rtnl_message *m) {
1906 struct ether_addr mac;
1911 assert(link->ifname);
1914 if (link->state == LINK_STATE_LINGER) {
1916 log_info_link(link, "link readded");
1917 link->state = LINK_STATE_ENSLAVING;
1920 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1921 if (r >= 0 && !streq(ifname, link->ifname)) {
1922 log_info_link(link, "renamed to %s", ifname);
1925 link->ifname = strdup(ifname);
1930 if (!link->original_mtu) {
1931 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
1933 log_debug_link(link, "saved original MTU: %"
1934 PRIu16, link->original_mtu);
1937 /* The kernel may broadcast NEWLINK messages without the MAC address
1938 set, simply ignore them. */
1939 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1941 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
1943 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
1945 log_debug_link(link, "MAC address: "
1946 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1947 mac.ether_addr_octet[0],
1948 mac.ether_addr_octet[1],
1949 mac.ether_addr_octet[2],
1950 mac.ether_addr_octet[3],
1951 mac.ether_addr_octet[4],
1952 mac.ether_addr_octet[5]);
1955 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1957 log_warning_link(link, "Could not update MAC "
1958 "address in IPv4LL client: %s",
1964 if (link->dhcp_client) {
1965 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1967 log_warning_link(link, "Could not update MAC "
1968 "address in DHCP client: %s",
1976 return link_update_flags(link, m);
1979 static void serialize_addresses(FILE *f, const char *key, Address *address) {
1988 fprintf(f, "%s=", key);
1990 LIST_FOREACH(addresses, ad, address) {
1991 char buf[INET6_ADDRSTRLEN];
1993 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
1994 fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2000 static void link_update_operstate(Link *link) {
2004 if (link->kernel_operstate == IF_OPER_DORMANT)
2005 link->operstate = LINK_OPERSTATE_DORMANT;
2006 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2008 uint8_t scope = RT_SCOPE_NOWHERE;
2010 /* if we have carrier, check what addresses we have */
2011 LIST_FOREACH(addresses, address, link->addresses) {
2012 if (address->scope < scope)
2013 scope = address->scope;
2016 if (scope < RT_SCOPE_SITE)
2017 /* universally accessible addresses found */
2018 link->operstate = LINK_OPERSTATE_ROUTABLE;
2019 else if (scope < RT_SCOPE_HOST)
2020 /* only link or site local addresses found */
2021 link->operstate = LINK_OPERSTATE_DEGRADED;
2023 /* no useful addresses found */
2024 link->operstate = LINK_OPERSTATE_CARRIER;
2026 link->operstate = LINK_OPERSTATE_UNKNOWN;
2029 int link_save(Link *link) {
2030 _cleanup_free_ char *temp_path = NULL;
2031 _cleanup_fclose_ FILE *f = NULL;
2032 const char *admin_state, *oper_state;
2036 assert(link->state_file);
2037 assert(link->lease_file);
2038 assert(link->manager);
2040 link_update_operstate(link);
2042 r = manager_save(link->manager);
2046 if (link->state == LINK_STATE_LINGER) {
2047 unlink(link->state_file);
2051 admin_state = link_state_to_string(link->state);
2052 assert(admin_state);
2054 oper_state = link_operstate_to_string(link->operstate);
2057 r = fopen_temporary(link->state_file, &f, &temp_path);
2061 fchmod(fileno(f), 0644);
2064 "# This is private data. Do not parse.\n"
2068 admin_state, oper_state, link->flags);
2070 if (link->network) {
2071 serialize_addresses(f, "DNS", link->network->dns);
2072 serialize_addresses(f, "NTP", link->network->ntp);
2075 if (link->dhcp_lease) {
2076 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2083 "DHCP_USE_NTP=%s\n",
2085 yes_no(link->network->dhcp_dns),
2086 yes_no(link->network->dhcp_ntp));
2088 unlink(link->lease_file);
2092 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2094 unlink(link->state_file);
2100 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2105 static const char* const link_state_table[_LINK_STATE_MAX] = {
2106 [LINK_STATE_INITIALIZING] = "initializing",
2107 [LINK_STATE_ENSLAVING] = "configuring",
2108 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2109 [LINK_STATE_SETTING_ROUTES] = "configuring",
2110 [LINK_STATE_CONFIGURED] = "configured",
2111 [LINK_STATE_UNMANAGED] = "unmanaged",
2112 [LINK_STATE_FAILED] = "failed",
2113 [LINK_STATE_LINGER] = "linger",
2116 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2118 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2119 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2120 [LINK_OPERSTATE_DORMANT] = "dormant",
2121 [LINK_OPERSTATE_CARRIER] = "carrier",
2122 [LINK_OPERSTATE_DEGRADED] = "degraded",
2123 [LINK_OPERSTATE_ROUTABLE] = "routable",
2126 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);