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;
857 struct in_addr *nameservers;
858 size_t nameservers_size;
864 r = sd_dhcp_client_get_lease(client, &lease);
866 log_warning_link(link, "DHCP error: no lease: %s",
871 r = sd_dhcp_lease_get_address(lease, &address);
873 log_warning_link(link, "DHCP error: no address: %s",
878 r = sd_dhcp_lease_get_netmask(lease, &netmask);
880 log_warning_link(link, "DHCP error: no netmask: %s",
885 prefixlen = net_netmask_to_prefixlen(&netmask);
887 r = sd_dhcp_lease_get_router(lease, &gateway);
888 if (r < 0 && r != -ENOENT) {
889 log_warning_link(link, "DHCP error: %s", strerror(-r));
894 log_struct_link(LOG_INFO, link,
895 "MESSAGE=%*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
898 ADDRESS_FMT_VAL(address),
900 ADDRESS_FMT_VAL(gateway),
901 "ADDRESS=%u.%u.%u.%u",
902 ADDRESS_FMT_VAL(address),
905 "GATEWAY=%u.%u.%u.%u",
906 ADDRESS_FMT_VAL(gateway),
909 log_struct_link(LOG_INFO, link,
910 "MESSAGE=%*s: DHCPv4 address %u.%u.%u.%u/%u",
913 ADDRESS_FMT_VAL(address),
915 "ADDRESS=%u.%u.%u.%u",
916 ADDRESS_FMT_VAL(address),
921 link->dhcp_lease = lease;
923 if (link->network->dhcp_dns) {
924 r = sd_dhcp_lease_get_dns(lease, &nameservers, &nameservers_size);
926 r = manager_update_resolv_conf(link->manager);
928 log_error_link(link, "Failed to update resolv.conf");
932 if (link->network->dhcp_mtu) {
935 r = sd_dhcp_lease_get_mtu(lease, &mtu);
937 r = link_set_mtu(link, mtu);
939 log_error_link(link, "Failed to set MTU "
944 if (link->network->dhcp_hostname) {
945 const char *hostname;
947 r = sd_dhcp_lease_get_hostname(lease, &hostname);
949 r = link_set_hostname(link, hostname);
951 log_error_link(link, "Failed to set transient hostname "
952 "to '%s'", hostname);
956 link_enter_set_addresses(link);
961 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
962 Link *link = userdata;
966 assert(link->network);
967 assert(link->manager);
969 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
973 case DHCP_EVENT_NO_LEASE:
974 log_debug_link(link, "IP address in use.");
976 case DHCP_EVENT_EXPIRED:
977 case DHCP_EVENT_STOP:
978 case DHCP_EVENT_IP_CHANGE:
979 if (link->network->dhcp_critical) {
980 log_error_link(link, "DHCPv4 connection considered system critical, "
981 "ignoring request to reconfigure it.");
985 if (link->dhcp_lease) {
986 r = dhcp_lease_lost(link);
988 link_enter_failed(link);
993 if (event == DHCP_EVENT_IP_CHANGE) {
994 r = dhcp_lease_acquired(client, link);
996 link_enter_failed(link);
1001 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1002 if (!sd_ipv4ll_is_running(link->ipv4ll))
1003 r = sd_ipv4ll_start(link->ipv4ll);
1004 else if (ipv4ll_is_bound(link->ipv4ll))
1005 r = ipv4ll_address_update(link, false);
1007 link_enter_failed(link);
1013 case DHCP_EVENT_IP_ACQUIRE:
1014 r = dhcp_lease_acquired(client, link);
1016 link_enter_failed(link);
1020 if (ipv4ll_is_bound(link->ipv4ll))
1021 r = ipv4ll_address_update(link, true);
1023 r = sd_ipv4ll_stop(link->ipv4ll);
1025 link_enter_failed(link);
1032 log_warning_link(link, "DHCP error: %s", strerror(-event));
1034 log_warning_link(link, "DHCP unknown event: %d", event);
1041 static int ipv4ll_address_update(Link *link, bool deprecate) {
1043 struct in_addr addr;
1047 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1049 _cleanup_address_free_ Address *address = NULL;
1051 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1052 deprecate ? "deprecate" : "approve",
1053 ADDRESS_FMT_VAL(addr));
1055 r = address_new_dynamic(&address);
1057 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1061 address->family = AF_INET;
1062 address->in_addr.in = addr;
1063 address->prefixlen = 16;
1064 address->scope = RT_SCOPE_LINK;
1065 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1066 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1068 address_update(address, link, &address_update_handler);
1076 static int ipv4ll_address_lost(Link *link) {
1078 struct in_addr addr;
1082 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1084 _cleanup_address_free_ Address *address = NULL;
1085 _cleanup_route_free_ Route *route = NULL;
1087 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1088 ADDRESS_FMT_VAL(addr));
1090 r = address_new_dynamic(&address);
1092 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1096 address->family = AF_INET;
1097 address->in_addr.in = addr;
1098 address->prefixlen = 16;
1099 address->scope = RT_SCOPE_LINK;
1101 address_drop(address, link, &address_drop_handler);
1104 r = route_new_dynamic(&route);
1106 log_error_link(link, "Could not allocate route: %s",
1111 route->family = AF_INET;
1112 route->scope = RT_SCOPE_LINK;
1113 route->metrics = 99;
1115 route_drop(route, link, &route_drop_handler);
1122 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1124 struct in_addr addr;
1128 r = sd_ipv4ll_get_address(ll, &addr);
1134 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1135 struct in_addr address;
1141 r = sd_ipv4ll_get_address(ll, &address);
1145 log_struct_link(LOG_INFO, link,
1146 "MESSAGE=%*s: IPv4 link-local address %u.%u.%u.%u",
1149 ADDRESS_FMT_VAL(address),
1152 link_enter_set_addresses(link);
1157 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1158 Link *link = userdata;
1162 assert(link->network);
1163 assert(link->manager);
1165 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1169 case IPV4LL_EVENT_STOP:
1170 case IPV4LL_EVENT_CONFLICT:
1171 r = ipv4ll_address_lost(link);
1173 link_enter_failed(link);
1177 case IPV4LL_EVENT_BIND:
1178 r = ipv4ll_address_claimed(ll, link);
1180 link_enter_failed(link);
1186 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1188 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1193 static int link_acquire_conf(Link *link) {
1197 assert(link->network);
1198 assert(link->manager);
1199 assert(link->manager->event);
1201 if (link->network->ipv4ll) {
1202 assert(link->ipv4ll);
1204 log_debug_link(link, "acquiring IPv4 link-local address");
1206 r = sd_ipv4ll_start(link->ipv4ll);
1208 log_warning_link(link, "could not acquire IPv4 "
1209 "link-local address");
1214 if (link->network->dhcp) {
1215 assert(link->dhcp_client);
1217 log_debug_link(link, "acquiring DHCPv4 lease");
1219 r = sd_dhcp_client_start(link->dhcp_client);
1221 log_warning_link(link, "could not acquire DHCPv4 "
1230 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1231 /* see Documentation/networking/operstates.txt in the kernel sources */
1233 if (operstate == IF_OPER_UP)
1236 if (operstate == IF_OPER_UNKNOWN)
1237 /* operstate may not be implemented, so fall back to flags */
1238 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1244 #define FLAG_STRING(string, flag, old, new) \
1245 (((old ^ new) & flag) \
1246 ? ((old & flag) ? (" -" string) : (" +" string)) \
1249 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1250 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1252 bool carrier_gained = false, carrier_lost = false;
1257 r = sd_rtnl_message_link_get_flags(m, &flags);
1259 log_warning_link(link, "Could not get link flags");
1263 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1265 /* if we got a message without operstate, take it to mean
1266 the state was unchanged */
1267 operstate = link->operstate;
1269 if ((link->flags == flags) && (link->operstate == operstate))
1272 if (link->flags != flags) {
1273 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",
1274 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1275 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1276 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1277 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1278 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1279 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1280 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1281 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1282 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1283 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1284 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1285 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1286 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1287 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1288 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1289 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1290 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1291 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1292 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1294 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1295 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1296 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1297 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1298 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1299 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1300 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1301 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1303 /* link flags are currently at most 18 bits, let's align to printing 20 */
1304 if (unknown_flags_added)
1305 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1306 unknown_flags_added);
1308 if (unknown_flags_removed)
1309 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1310 unknown_flags_removed);
1313 carrier_gained = !link_has_carrier(link->flags, link->operstate) &&
1314 link_has_carrier(flags, operstate);
1315 carrier_lost = link_has_carrier(link->flags, link->operstate) &&
1316 !link_has_carrier(flags, operstate);
1318 link->flags = flags;
1319 link->operstate = operstate;
1323 if (link->state == LINK_STATE_FAILED ||
1324 link->state == LINK_STATE_UNMANAGED)
1327 if (carrier_gained) {
1328 log_info_link(link, "gained carrier");
1330 if (link->network) {
1331 r = link_acquire_conf(link);
1333 link_enter_failed(link);
1337 } else if (carrier_lost) {
1338 log_info_link(link, "lost carrier");
1340 r = link_stop_clients(link);
1342 link_enter_failed(link);
1350 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1351 Link *link = userdata;
1356 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1361 r = sd_rtnl_message_get_errno(m);
1363 /* we warn but don't fail the link, as it may
1364 be brought up later */
1365 log_struct_link(LOG_WARNING, link,
1366 "MESSAGE=%*s: could not bring up interface: %s",
1368 link->ifname, strerror(-r),
1378 static int link_up(Link *link) {
1379 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1383 assert(link->manager);
1384 assert(link->manager->rtnl);
1386 log_debug_link(link, "bringing link up");
1388 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1389 RTM_SETLINK, link->ifindex);
1391 log_error_link(link, "Could not allocate RTM_SETLINK message");
1395 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1397 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1401 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1403 log_error_link(link,
1404 "Could not send rtnetlink message: %s", strerror(-r));
1413 static int link_enslaved(Link *link) {
1417 assert(link->state == LINK_STATE_ENSLAVING);
1418 assert(link->network);
1420 if (!(link->flags & IFF_UP)) {
1423 link_enter_failed(link);
1428 if (!link->network->dhcp && !link->network->ipv4ll)
1429 return link_enter_set_addresses(link);
1434 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1435 Link *link = userdata;
1439 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1440 LINK_STATE_LINGER));
1441 assert(link->network);
1445 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1450 r = sd_rtnl_message_get_errno(m);
1452 log_struct_link(LOG_ERR, link,
1453 "MESSAGE=%*s: could not enslave: %s",
1455 link->ifname, strerror(-r),
1458 link_enter_failed(link);
1463 log_debug_link(link, "enslaved");
1465 if (link->enslaving == 0)
1466 link_enslaved(link);
1473 static int link_enter_enslave(Link *link) {
1474 NetDev *vlan, *macvlan;
1479 assert(link->network);
1480 assert(link->state == LINK_STATE_INITIALIZING);
1482 link->state = LINK_STATE_ENSLAVING;
1486 if (!link->network->bridge &&
1487 !link->network->bond &&
1488 !link->network->tunnel &&
1489 hashmap_isempty(link->network->vlans) &&
1490 hashmap_isempty(link->network->macvlans))
1491 return link_enslaved(link);
1493 if (link->network->bond) {
1494 log_struct_link(LOG_DEBUG, link,
1495 "MESSAGE=%*s: enslaving by '%s'",
1497 link->ifname, link->network->bond->ifname,
1498 NETDEV(link->network->bond),
1501 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1503 log_struct_link(LOG_WARNING, link,
1504 "MESSAGE=%*s: could not enslave by '%s': %s",
1506 link->ifname, link->network->bond->ifname, strerror(-r),
1507 NETDEV(link->network->bond),
1509 link_enter_failed(link);
1517 if (link->network->bridge) {
1518 log_struct_link(LOG_DEBUG, link,
1519 "MESSAGE=%*s: enslaving by '%s'",
1521 link->ifname, link->network->bridge->ifname,
1522 NETDEV(link->network->bridge),
1525 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1527 log_struct_link(LOG_WARNING, link,
1528 "MESSAGE=%*s: could not enslave by '%s': %s",
1530 link->ifname, link->network->bridge->ifname, strerror(-r),
1531 NETDEV(link->network->bridge),
1533 link_enter_failed(link);
1541 if (link->network->tunnel) {
1542 log_struct_link(LOG_DEBUG, link,
1543 "MESSAGE=%*s: enslaving by '%s'",
1545 link->ifname, link->network->tunnel->ifname,
1546 NETDEV(link->network->tunnel),
1549 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1551 log_struct_link(LOG_WARNING, link,
1552 "MESSAGE=%*s: could not enslave by '%s': %s",
1554 link->ifname, link->network->tunnel->ifname, strerror(-r),
1555 NETDEV(link->network->tunnel),
1557 link_enter_failed(link);
1565 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1566 log_struct_link(LOG_DEBUG, link,
1567 "MESSAGE=%*s: enslaving by '%s'",
1569 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1571 r = netdev_enslave(vlan, link, &enslave_handler);
1573 log_struct_link(LOG_WARNING, link,
1574 "MESSAGE=%*s: could not enslave by '%s': %s",
1576 link->ifname, vlan->ifname, strerror(-r),
1577 NETDEV(vlan), NULL);
1578 link_enter_failed(link);
1586 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1587 log_struct_link(LOG_DEBUG, link,
1588 "MESSAGE=%*s: enslaving by '%s'",
1590 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1592 r = netdev_enslave(macvlan, link, &enslave_handler);
1594 log_struct_link(LOG_WARNING, link,
1595 "MESSAGE=%*s: could not enslave by '%s': %s",
1597 link->ifname, macvlan->ifname, strerror(-r),
1598 NETDEV(macvlan), NULL);
1599 link_enter_failed(link);
1610 static int link_configure(Link *link) {
1614 assert(link->state == LINK_STATE_INITIALIZING);
1616 if (link->network->ipv4ll) {
1619 r = sd_ipv4ll_new(&link->ipv4ll);
1623 if (link->udev_device) {
1624 r = net_get_unique_predictable_data(link->udev_device, seed);
1626 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1632 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1636 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1640 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1644 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1649 if (link->network->dhcp) {
1650 r = sd_dhcp_client_new(&link->dhcp_client);
1654 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1658 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1662 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1666 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1670 if (link->network->dhcp_mtu) {
1671 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1677 if (link_has_carrier(link->flags, link->operstate)) {
1678 r = link_acquire_conf(link);
1683 return link_enter_enslave(link);
1686 int link_initialized(Link *link, struct udev_device *device) {
1691 assert(link->ifname);
1692 assert(link->manager);
1694 if (link->state != LINK_STATE_INITIALIZING)
1698 link->udev_device = udev_device_ref(device);
1700 log_debug_link(link, "udev initialized link");
1702 r = network_get(link->manager, device, link->ifname, &link->mac, &network);
1704 link_enter_unmanaged(link);
1709 r = network_apply(link->manager, network, link);
1713 r = link_configure(link);
1720 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1721 Manager *m = userdata;
1724 _cleanup_address_free_ Address *address = NULL;
1726 char buf[INET6_ADDRSTRLEN];
1727 bool address_dropped = false;
1734 r = sd_rtnl_message_get_type(message, &type);
1736 log_warning("rtnl: could not get message type");
1740 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1741 if (r < 0 || ifindex <= 0) {
1742 log_warning("rtnl: received address message without valid ifindex, ignoring");
1745 r = link_get(m, ifindex, &link);
1746 if (r < 0 || !link) {
1747 log_warning("rtnl: received address for a nonexistent link, ignoring");
1752 r = address_new_dynamic(&address);
1756 r = sd_rtnl_message_addr_get_family(message, &address->family);
1757 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1758 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
1762 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1764 log_warning_link(link, "rtnl: recevied address with invalid prefixlen, ignoring");
1768 switch (address->family) {
1770 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1772 log_warning_link(link, "rtnl: received address without valid address, ignoring");
1779 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1781 log_warning_link(link, "rtnl: received address without valid address, ignoring");
1788 assert_not_reached("invalid address family");
1791 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1792 log_warning_link(link, "could not print address");
1796 LIST_FOREACH(addresses, ad, link->addresses) {
1797 if (address_equal(ad, address)) {
1798 LIST_REMOVE(addresses, link->addresses, ad);
1802 address_dropped = true;
1810 if (!address_dropped)
1811 log_debug_link(link, "added address: %s/%u", buf,
1812 address->prefixlen);
1814 LIST_PREPEND(addresses, link->addresses, address);
1819 if (address_dropped)
1820 log_debug_link(link, "removed address: %s/%u", buf,
1821 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(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN))
1994 fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2000 int link_save(Link *link) {
2001 _cleanup_free_ char *temp_path = NULL;
2002 _cleanup_fclose_ FILE *f = NULL;
2003 const char *admin_state, *oper_state = "unknown";
2007 assert(link->state_file);
2008 assert(link->lease_file);
2009 assert(link->manager);
2011 r = manager_save(link->manager);
2015 if (link->state == LINK_STATE_LINGER) {
2016 unlink(link->state_file);
2020 admin_state = link_state_to_string(link->state);
2021 assert(admin_state);
2023 if (link->operstate == IF_OPER_DORMANT)
2024 oper_state = "dormant";
2025 else if (link_has_carrier(link->flags, link->operstate))
2026 oper_state = "carrier";
2028 r = fopen_temporary(link->state_file, &f, &temp_path);
2032 fchmod(fileno(f), 0644);
2035 "# This is private data. Do not parse.\n"
2039 admin_state, oper_state, link->flags);
2042 serialize_addresses(f, "DNS", link->network->dns);
2044 if (link->dhcp_lease) {
2045 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2051 "DHCP_USE_DNS=%s\n",
2052 link->lease_file, yes_no(link->network->dhcp_dns));
2054 unlink(link->lease_file);
2058 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2060 unlink(link->state_file);
2066 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2071 static const char* const link_state_table[_LINK_STATE_MAX] = {
2072 [LINK_STATE_INITIALIZING] = "initializing",
2073 [LINK_STATE_ENSLAVING] = "configuring",
2074 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2075 [LINK_STATE_SETTING_ROUTES] = "configuring",
2076 [LINK_STATE_CONFIGURED] = "configured",
2077 [LINK_STATE_UNMANAGED] = "unmanaged",
2078 [LINK_STATE_FAILED] = "failed",
2079 [LINK_STATE_LINGER] = "linger",
2082 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);