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) {
102 assert(link->manager);
104 sd_dhcp_client_unref(link->dhcp_client);
105 sd_dhcp_lease_unref(link->dhcp_lease);
107 unlink(link->lease_file);
108 free(link->lease_file);
110 sd_ipv4ll_unref(link->ipv4ll);
112 hashmap_remove(link->manager->links, &link->ifindex);
116 unlink(link->state_file);
117 free(link->state_file);
119 udev_device_unref(link->udev_device);
124 Link *link_unref(Link *link) {
125 if (link && (-- link->n_ref <= 0))
131 Link *link_ref(Link *link) {
133 assert_se(++ link->n_ref >= 2);
138 int link_get(Manager *m, int ifindex, Link **ret) {
147 ifindex_64 = ifindex;
148 link = hashmap_get(m->links, &ifindex_64);
157 void link_drop(Link *link) {
158 if (!link || link->state == LINK_STATE_LINGER)
161 link->state = LINK_STATE_LINGER;
163 log_debug_link(link, "link removed");
170 static int link_enter_configured(Link *link) {
172 assert(link->state == LINK_STATE_SETTING_ROUTES);
174 log_info_link(link, "link configured");
176 link->state = LINK_STATE_CONFIGURED;
183 static void link_enter_unmanaged(Link *link) {
186 log_debug_link(link, "unmanaged");
188 link->state = LINK_STATE_UNMANAGED;
193 static int link_stop_clients(Link *link) {
197 assert(link->manager);
198 assert(link->manager->event);
203 if (link->network->dhcp) {
204 assert(link->dhcp_client);
206 k = sd_dhcp_client_stop(link->dhcp_client);
208 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
213 if (link->network->ipv4ll) {
214 assert(link->ipv4ll);
216 k = sd_ipv4ll_stop(link->ipv4ll);
218 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
226 static void link_enter_failed(Link *link) {
229 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
232 log_warning_link(link, "failed");
234 link->state = LINK_STATE_FAILED;
236 link_stop_clients(link);
241 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
242 Link *link = userdata;
245 assert(link->route_messages > 0);
246 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
247 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
250 link->route_messages --;
252 if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER)) {
257 r = sd_rtnl_message_get_errno(m);
258 if (r < 0 && r != -EEXIST)
259 log_struct_link(LOG_WARNING, link,
260 "MESSAGE=%*s: could not set route: %s",
262 link->ifname, strerror(-r),
266 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
268 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
269 log_debug_link(link, "routes set");
270 link_enter_configured(link);
278 static int link_enter_set_routes(Link *link) {
283 assert(link->network);
284 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
286 link->state = LINK_STATE_SETTING_ROUTES;
288 if (!link->network->static_routes && !link->dhcp_lease &&
289 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
290 return link_enter_configured(link);
292 log_debug_link(link, "setting routes");
294 LIST_FOREACH(routes, rt, link->network->static_routes) {
295 r = route_configure(rt, link, &route_handler);
297 log_warning_link(link,
298 "could not set routes: %s", strerror(-r));
299 link_enter_failed(link);
304 link->route_messages ++;
307 if (link->ipv4ll && !link->dhcp_lease) {
308 _cleanup_route_free_ Route *route = NULL;
311 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
312 if (r < 0 && r != -ENOENT) {
313 log_warning_link(link, "IPV4LL error: no address: %s",
319 r = route_new_dynamic(&route);
321 log_error_link(link, "Could not allocate route: %s",
326 route->family = AF_INET;
327 route->scope = RT_SCOPE_LINK;
330 r = route_configure(route, link, &route_handler);
332 log_warning_link(link,
333 "could not set routes: %s", strerror(-r));
334 link_enter_failed(link);
339 link->route_messages ++;
343 if (link->dhcp_lease) {
344 _cleanup_route_free_ Route *route = NULL;
345 _cleanup_route_free_ Route *route_gw = NULL;
346 struct in_addr gateway;
348 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
349 if (r < 0 && r != -ENOENT) {
350 log_warning_link(link, "DHCP error: %s", strerror(-r));
355 r = route_new_dynamic(&route);
357 log_error_link(link, "Could not allocate route: %s",
362 r = route_new_dynamic(&route_gw);
364 log_error_link(link, "Could not allocate route: %s",
369 /* The dhcp netmask may mask out the gateway. Add an explicit
370 * route for the gw host so that we can route no matter the
371 * netmask or existing kernel route tables. */
372 route_gw->family = AF_INET;
373 route_gw->dst_addr.in = gateway;
374 route_gw->dst_prefixlen = 32;
375 route_gw->scope = RT_SCOPE_LINK;
377 r = route_configure(route_gw, link, &route_handler);
379 log_warning_link(link,
380 "could not set host route: %s", strerror(-r));
385 link->route_messages ++;
387 route->family = AF_INET;
388 route->in_addr.in = gateway;
390 r = route_configure(route, link, &route_handler);
392 log_warning_link(link,
393 "could not set routes: %s", strerror(-r));
394 link_enter_failed(link);
399 link->route_messages ++;
403 if (link->route_messages == 0) {
404 link_enter_configured(link);
410 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
411 Link *link = userdata;
416 assert(link->ifname);
418 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
423 r = sd_rtnl_message_get_errno(m);
424 if (r < 0 && r != -ESRCH)
425 log_struct_link(LOG_WARNING, link,
426 "MESSAGE=%*s: could not drop route: %s",
428 link->ifname, strerror(-r),
437 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
438 Link *link = userdata;
443 assert(link->ifname);
444 assert(link->addr_messages > 0);
445 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
446 LINK_STATE_FAILED, LINK_STATE_LINGER));
448 link->addr_messages --;
450 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
455 r = sd_rtnl_message_get_errno(m);
456 if (r < 0 && r != -EEXIST)
457 log_struct_link(LOG_WARNING, link,
458 "MESSAGE=%*s: could not set address: %s",
460 link->ifname, strerror(-r),
464 if (link->addr_messages == 0) {
465 log_debug_link(link, "addresses set");
466 link_enter_set_routes(link);
474 static int link_enter_set_addresses(Link *link) {
479 assert(link->network);
480 assert(link->state != _LINK_STATE_INVALID);
482 link->state = LINK_STATE_SETTING_ADDRESSES;
484 if (!link->network->static_addresses && !link->dhcp_lease &&
485 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
486 return link_enter_set_routes(link);
488 log_debug_link(link, "setting addresses");
490 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
491 r = address_configure(ad, link, &address_handler);
493 log_warning_link(link,
494 "could not set addresses: %s", strerror(-r));
495 link_enter_failed(link);
500 link->addr_messages ++;
503 if (link->ipv4ll && !link->dhcp_lease) {
504 _cleanup_address_free_ Address *ll_addr = NULL;
507 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
508 if (r < 0 && r != -ENOENT) {
509 log_warning_link(link, "IPV4LL error: no address: %s",
515 r = address_new_dynamic(&ll_addr);
517 log_error_link(link, "Could not allocate address: %s", strerror(-r));
521 ll_addr->family = AF_INET;
522 ll_addr->in_addr.in = addr;
523 ll_addr->prefixlen = 16;
524 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
525 ll_addr->scope = RT_SCOPE_LINK;
527 r = address_configure(ll_addr, link, &address_handler);
529 log_warning_link(link,
530 "could not set addresses: %s", strerror(-r));
531 link_enter_failed(link);
536 link->addr_messages ++;
540 if (link->dhcp_lease) {
541 _cleanup_address_free_ Address *address = NULL;
543 struct in_addr netmask;
546 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
548 log_warning_link(link, "DHCP error: no address: %s",
553 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
555 log_warning_link(link, "DHCP error: no netmask: %s",
560 prefixlen = net_netmask_to_prefixlen(&netmask);
562 r = address_new_dynamic(&address);
564 log_error_link(link, "Could not allocate address: %s",
569 address->family = AF_INET;
570 address->in_addr.in = addr;
571 address->prefixlen = prefixlen;
572 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
574 r = address_configure(address, link, &address_handler);
576 log_warning_link(link,
577 "could not set addresses: %s", strerror(-r));
578 link_enter_failed(link);
583 link->addr_messages ++;
589 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
590 Link *link = userdata;
595 assert(link->ifname);
597 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
602 r = sd_rtnl_message_get_errno(m);
603 if (r < 0 && r != -ENOENT)
604 log_struct_link(LOG_WARNING, link,
605 "MESSAGE=%*s: could not update address: %s",
607 link->ifname, strerror(-r),
616 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
617 Link *link = userdata;
622 assert(link->ifname);
624 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
629 r = sd_rtnl_message_get_errno(m);
630 if (r < 0 && r != -EADDRNOTAVAIL)
631 log_struct_link(LOG_WARNING, link,
632 "MESSAGE=%*s: could not drop address: %s",
634 link->ifname, strerror(-r),
643 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
644 Link *link = userdata;
649 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
654 r = sd_bus_message_get_errno(m);
656 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
663 static int link_set_hostname(Link *link, const char *hostname) {
664 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
668 assert(link->manager);
671 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
673 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
674 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
678 r = sd_bus_message_new_method_call(
681 "org.freedesktop.hostname1",
682 "/org/freedesktop/hostname1",
683 "org.freedesktop.hostname1",
688 r = sd_bus_message_append(m, "sb", hostname, false);
692 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
694 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
701 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
702 Link *link = userdata;
707 assert(link->ifname);
709 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
714 r = sd_rtnl_message_get_errno(m);
716 log_struct_link(LOG_WARNING, link,
717 "MESSAGE=%s: could not set MTU: %s",
718 link->ifname, strerror(-r),
727 static int link_set_mtu(Link *link, uint32_t mtu) {
728 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
732 assert(link->manager);
733 assert(link->manager->rtnl);
735 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
737 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
738 RTM_SETLINK, link->ifindex);
740 log_error_link(link, "Could not allocate RTM_SETLINK message");
744 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
746 log_error_link(link, "Could not append MTU: %s", strerror(-r));
750 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
753 "Could not send rtnetlink message: %s", strerror(-r));
762 static int dhcp_lease_lost(Link *link) {
763 _cleanup_address_free_ Address *address = NULL;
764 _cleanup_route_free_ Route *route_gw = NULL;
765 _cleanup_route_free_ Route *route = NULL;
767 struct in_addr netmask;
768 struct in_addr gateway;
773 assert(link->dhcp_lease);
775 log_warning_link(link, "DHCP lease lost");
777 r = address_new_dynamic(&address);
779 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
781 r = route_new_dynamic(&route_gw);
783 route_gw->family = AF_INET;
784 route_gw->dst_addr.in = gateway;
785 route_gw->dst_prefixlen = 32;
786 route_gw->scope = RT_SCOPE_LINK;
788 route_drop(route_gw, link, &route_drop_handler);
792 r = route_new_dynamic(&route);
794 route->family = AF_INET;
795 route->in_addr.in = gateway;
797 route_drop(route, link, &route_drop_handler);
802 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
803 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
804 prefixlen = net_netmask_to_prefixlen(&netmask);
806 address->family = AF_INET;
807 address->in_addr.in = addr;
808 address->prefixlen = prefixlen;
810 address_drop(address, link, &address_drop_handler);
814 if (link->network->dhcp_mtu) {
817 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
818 if (r >= 0 && link->original_mtu != mtu) {
819 r = link_set_mtu(link, link->original_mtu);
821 log_warning_link(link, "DHCP error: could not reset MTU");
822 link_enter_failed(link);
828 if (link->network->dhcp_hostname) {
829 const char *hostname = NULL;
831 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
832 if (r >= 0 && hostname) {
833 r = link_set_hostname(link, "");
835 log_error_link(link, "Failed to reset transient hostname");
839 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
844 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
845 sd_dhcp_lease *lease;
846 struct in_addr address;
847 struct in_addr netmask;
848 struct in_addr gateway;
850 struct in_addr *nameservers;
851 size_t nameservers_size;
857 r = sd_dhcp_client_get_lease(client, &lease);
859 log_warning_link(link, "DHCP error: no lease: %s",
864 r = sd_dhcp_lease_get_address(lease, &address);
866 log_warning_link(link, "DHCP error: no address: %s",
871 r = sd_dhcp_lease_get_netmask(lease, &netmask);
873 log_warning_link(link, "DHCP error: no netmask: %s",
878 prefixlen = net_netmask_to_prefixlen(&netmask);
880 r = sd_dhcp_lease_get_router(lease, &gateway);
881 if (r < 0 && r != -ENOENT) {
882 log_warning_link(link, "DHCP error: %s", strerror(-r));
887 log_struct_link(LOG_INFO, link,
888 "MESSAGE=%*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
891 ADDRESS_FMT_VAL(address),
893 ADDRESS_FMT_VAL(gateway),
894 "ADDRESS=%u.%u.%u.%u",
895 ADDRESS_FMT_VAL(address),
898 "GATEWAY=%u.%u.%u.%u",
899 ADDRESS_FMT_VAL(gateway),
902 log_struct_link(LOG_INFO, link,
903 "MESSAGE=%*s: DHCPv4 address %u.%u.%u.%u/%u",
906 ADDRESS_FMT_VAL(address),
908 "ADDRESS=%u.%u.%u.%u",
909 ADDRESS_FMT_VAL(address),
914 link->dhcp_lease = lease;
916 if (link->network->dhcp_dns) {
917 r = sd_dhcp_lease_get_dns(lease, &nameservers, &nameservers_size);
919 r = manager_update_resolv_conf(link->manager);
921 log_error_link(link, "Failed to update resolv.conf");
925 if (link->network->dhcp_mtu) {
928 r = sd_dhcp_lease_get_mtu(lease, &mtu);
930 r = link_set_mtu(link, mtu);
932 log_error_link(link, "Failed to set MTU "
937 if (link->network->dhcp_hostname) {
938 const char *hostname;
940 r = sd_dhcp_lease_get_hostname(lease, &hostname);
942 r = link_set_hostname(link, hostname);
944 log_error_link(link, "Failed to set transient hostname "
945 "to '%s'", hostname);
949 link_enter_set_addresses(link);
954 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
955 Link *link = userdata;
959 assert(link->network);
960 assert(link->manager);
962 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
966 case DHCP_EVENT_NO_LEASE:
967 log_debug_link(link, "IP address in use.");
969 case DHCP_EVENT_EXPIRED:
970 case DHCP_EVENT_STOP:
971 case DHCP_EVENT_IP_CHANGE:
972 if (link->network->dhcp_critical) {
973 log_error_link(link, "DHCPv4 connection considered system critical, "
974 "ignoring request to reconfigure it.");
978 if (link->dhcp_lease) {
979 r = dhcp_lease_lost(link);
981 link_enter_failed(link);
986 if (event == DHCP_EVENT_IP_CHANGE) {
987 r = dhcp_lease_acquired(client, link);
989 link_enter_failed(link);
994 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
995 if (!sd_ipv4ll_is_running(link->ipv4ll))
996 r = sd_ipv4ll_start(link->ipv4ll);
997 else if (ipv4ll_is_bound(link->ipv4ll))
998 r = ipv4ll_address_update(link, false);
1000 link_enter_failed(link);
1006 case DHCP_EVENT_IP_ACQUIRE:
1007 r = dhcp_lease_acquired(client, link);
1009 link_enter_failed(link);
1013 if (ipv4ll_is_bound(link->ipv4ll))
1014 r = ipv4ll_address_update(link, true);
1016 r = sd_ipv4ll_stop(link->ipv4ll);
1018 link_enter_failed(link);
1025 log_warning_link(link, "DHCP error: %s", strerror(-event));
1027 log_warning_link(link, "DHCP unknown event: %d", event);
1034 static int ipv4ll_address_update(Link *link, bool deprecate) {
1036 struct in_addr addr;
1040 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1042 _cleanup_address_free_ Address *address = NULL;
1044 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1045 deprecate ? "deprecate" : "approve",
1046 ADDRESS_FMT_VAL(addr));
1048 r = address_new_dynamic(&address);
1050 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1054 address->family = AF_INET;
1055 address->in_addr.in = addr;
1056 address->prefixlen = 16;
1057 address->scope = RT_SCOPE_LINK;
1058 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1059 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1061 address_update(address, link, &address_update_handler);
1069 static int ipv4ll_address_lost(Link *link) {
1071 struct in_addr addr;
1075 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1077 _cleanup_address_free_ Address *address = NULL;
1078 _cleanup_route_free_ Route *route = NULL;
1080 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1081 ADDRESS_FMT_VAL(addr));
1083 r = address_new_dynamic(&address);
1085 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1089 address->family = AF_INET;
1090 address->in_addr.in = addr;
1091 address->prefixlen = 16;
1092 address->scope = RT_SCOPE_LINK;
1094 address_drop(address, link, &address_drop_handler);
1097 r = route_new_dynamic(&route);
1099 log_error_link(link, "Could not allocate route: %s",
1104 route->family = AF_INET;
1105 route->scope = RT_SCOPE_LINK;
1106 route->metrics = 99;
1108 route_drop(route, link, &route_drop_handler);
1115 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1117 struct in_addr addr;
1121 r = sd_ipv4ll_get_address(ll, &addr);
1127 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1128 struct in_addr address;
1134 r = sd_ipv4ll_get_address(ll, &address);
1138 log_struct_link(LOG_INFO, link,
1139 "MESSAGE=%*s: IPv4 link-local address %u.%u.%u.%u",
1142 ADDRESS_FMT_VAL(address),
1145 link_enter_set_addresses(link);
1150 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1151 Link *link = userdata;
1155 assert(link->network);
1156 assert(link->manager);
1158 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1162 case IPV4LL_EVENT_STOP:
1163 case IPV4LL_EVENT_CONFLICT:
1164 r = ipv4ll_address_lost(link);
1166 link_enter_failed(link);
1170 case IPV4LL_EVENT_BIND:
1171 r = ipv4ll_address_claimed(ll, link);
1173 link_enter_failed(link);
1179 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1181 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1186 static int link_acquire_conf(Link *link) {
1190 assert(link->network);
1191 assert(link->manager);
1192 assert(link->manager->event);
1194 if (link->network->ipv4ll) {
1195 assert(link->ipv4ll);
1197 log_debug_link(link, "acquiring IPv4 link-local address");
1199 r = sd_ipv4ll_start(link->ipv4ll);
1201 log_warning_link(link, "could not acquire IPv4 "
1202 "link-local address");
1207 if (link->network->dhcp) {
1208 assert(link->dhcp_client);
1210 log_debug_link(link, "acquiring DHCPv4 lease");
1212 r = sd_dhcp_client_start(link->dhcp_client);
1214 log_warning_link(link, "could not acquire DHCPv4 "
1223 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1224 /* see Documentation/networking/operstates.txt in the kernel sources */
1226 if (operstate == IF_OPER_UP)
1229 if (operstate == IF_OPER_UNKNOWN)
1230 /* operstate may not be implemented, so fall back to flags */
1231 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1237 #define FLAG_STRING(string, flag, old, new) \
1238 (((old ^ new) & flag) \
1239 ? ((old & flag) ? (" -" string) : (" +" string)) \
1242 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1243 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1245 bool carrier_gained = false, carrier_lost = false;
1250 r = sd_rtnl_message_link_get_flags(m, &flags);
1252 log_warning_link(link, "Could not get link flags");
1256 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1258 /* if we got a message without operstate, take it to mean
1259 the state was unchanged */
1260 operstate = link->operstate;
1262 if ((link->flags == flags) && (link->operstate == operstate))
1265 if (link->flags != flags) {
1266 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",
1267 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1268 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1269 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1270 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1271 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1272 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1273 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1274 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1275 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1276 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1277 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1278 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1279 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1280 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1281 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1282 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1283 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1284 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1285 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1287 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1288 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1289 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1290 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1291 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1292 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1293 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1294 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1296 /* link flags are currently at most 18 bits, let's align to printing 20 */
1297 if (unknown_flags_added)
1298 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1299 unknown_flags_added);
1301 if (unknown_flags_removed)
1302 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1303 unknown_flags_removed);
1306 carrier_gained = !link_has_carrier(link->flags, link->operstate) &&
1307 link_has_carrier(flags, operstate);
1308 carrier_lost = link_has_carrier(link->flags, link->operstate) &&
1309 !link_has_carrier(flags, operstate);
1311 link->flags = flags;
1312 link->operstate = operstate;
1316 if (link->state == LINK_STATE_FAILED ||
1317 link->state == LINK_STATE_UNMANAGED)
1320 if (carrier_gained) {
1321 log_info_link(link, "gained carrier");
1323 if (link->network) {
1324 r = link_acquire_conf(link);
1326 link_enter_failed(link);
1330 } else if (carrier_lost) {
1331 log_info_link(link, "lost carrier");
1333 r = link_stop_clients(link);
1335 link_enter_failed(link);
1343 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1344 Link *link = userdata;
1349 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1354 r = sd_rtnl_message_get_errno(m);
1356 /* we warn but don't fail the link, as it may
1357 be brought up later */
1358 log_struct_link(LOG_WARNING, link,
1359 "MESSAGE=%*s: could not bring up interface: %s",
1361 link->ifname, strerror(-r),
1371 static int link_up(Link *link) {
1372 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1376 assert(link->manager);
1377 assert(link->manager->rtnl);
1379 log_debug_link(link, "bringing link up");
1381 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1382 RTM_SETLINK, link->ifindex);
1384 log_error_link(link, "Could not allocate RTM_SETLINK message");
1388 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1390 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1394 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1396 log_error_link(link,
1397 "Could not send rtnetlink message: %s", strerror(-r));
1406 static int link_enslaved(Link *link) {
1410 assert(link->state == LINK_STATE_ENSLAVING);
1411 assert(link->network);
1413 if (!(link->flags & IFF_UP)) {
1416 link_enter_failed(link);
1421 if (!link->network->dhcp && !link->network->ipv4ll)
1422 return link_enter_set_addresses(link);
1427 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1428 Link *link = userdata;
1432 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1433 LINK_STATE_LINGER));
1434 assert(link->network);
1438 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1443 r = sd_rtnl_message_get_errno(m);
1445 log_struct_link(LOG_ERR, link,
1446 "MESSAGE=%*s: could not enslave: %s",
1448 link->ifname, strerror(-r),
1451 link_enter_failed(link);
1456 log_debug_link(link, "enslaved");
1458 if (link->enslaving == 0)
1459 link_enslaved(link);
1466 static int link_enter_enslave(Link *link) {
1467 NetDev *vlan, *macvlan;
1472 assert(link->network);
1473 assert(link->state == LINK_STATE_INITIALIZING);
1475 link->state = LINK_STATE_ENSLAVING;
1479 if (!link->network->bridge &&
1480 !link->network->bond &&
1481 !link->network->tunnel &&
1482 hashmap_isempty(link->network->vlans) &&
1483 hashmap_isempty(link->network->macvlans))
1484 return link_enslaved(link);
1486 if (link->network->bond) {
1487 log_struct_link(LOG_DEBUG, link,
1488 "MESSAGE=%*s: enslaving by '%s'",
1490 link->ifname, link->network->bond->ifname,
1491 NETDEV(link->network->bond),
1494 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1496 log_struct_link(LOG_WARNING, link,
1497 "MESSAGE=%*s: could not enslave by '%s': %s",
1499 link->ifname, link->network->bond->ifname, strerror(-r),
1500 NETDEV(link->network->bond),
1502 link_enter_failed(link);
1510 if (link->network->bridge) {
1511 log_struct_link(LOG_DEBUG, link,
1512 "MESSAGE=%*s: enslaving by '%s'",
1514 link->ifname, link->network->bridge->ifname,
1515 NETDEV(link->network->bridge),
1518 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1520 log_struct_link(LOG_WARNING, link,
1521 "MESSAGE=%*s: could not enslave by '%s': %s",
1523 link->ifname, link->network->bridge->ifname, strerror(-r),
1524 NETDEV(link->network->bridge),
1526 link_enter_failed(link);
1534 if (link->network->tunnel) {
1535 log_struct_link(LOG_DEBUG, link,
1536 "MESSAGE=%*s: enslaving by '%s'",
1538 link->ifname, link->network->tunnel->ifname,
1539 NETDEV(link->network->tunnel),
1542 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1544 log_struct_link(LOG_WARNING, link,
1545 "MESSAGE=%*s: could not enslave by '%s': %s",
1547 link->ifname, link->network->tunnel->ifname, strerror(-r),
1548 NETDEV(link->network->tunnel),
1550 link_enter_failed(link);
1558 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1559 log_struct_link(LOG_DEBUG, link,
1560 "MESSAGE=%*s: enslaving by '%s'",
1562 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1564 r = netdev_enslave(vlan, link, &enslave_handler);
1566 log_struct_link(LOG_WARNING, link,
1567 "MESSAGE=%*s: could not enslave by '%s': %s",
1569 link->ifname, vlan->ifname, strerror(-r),
1570 NETDEV(vlan), NULL);
1571 link_enter_failed(link);
1579 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1580 log_struct_link(LOG_DEBUG, link,
1581 "MESSAGE=%*s: enslaving by '%s'",
1583 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1585 r = netdev_enslave(macvlan, link, &enslave_handler);
1587 log_struct_link(LOG_WARNING, link,
1588 "MESSAGE=%*s: could not enslave by '%s': %s",
1590 link->ifname, macvlan->ifname, strerror(-r),
1591 NETDEV(macvlan), NULL);
1592 link_enter_failed(link);
1603 static int link_configure(Link *link) {
1607 assert(link->state == LINK_STATE_INITIALIZING);
1609 if (link->network->ipv4ll) {
1612 r = sd_ipv4ll_new(&link->ipv4ll);
1616 if (link->udev_device) {
1617 r = net_get_unique_predictable_data(link->udev_device, seed);
1619 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1625 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1629 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1633 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1637 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1642 if (link->network->dhcp) {
1643 r = sd_dhcp_client_new(&link->dhcp_client);
1647 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1651 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1655 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1659 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1663 if (link->network->dhcp_mtu) {
1664 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1670 if (link_has_carrier(link->flags, link->operstate)) {
1671 r = link_acquire_conf(link);
1676 return link_enter_enslave(link);
1679 int link_initialized(Link *link, struct udev_device *device) {
1684 assert(link->ifname);
1685 assert(link->manager);
1687 if (link->state != LINK_STATE_INITIALIZING)
1691 link->udev_device = udev_device_ref(device);
1693 log_debug_link(link, "link initialized");
1695 r = network_get(link->manager, device, link->ifname, &link->mac, &network);
1697 link_enter_unmanaged(link);
1702 r = network_apply(link->manager, network, link);
1706 r = link_configure(link);
1713 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1714 Manager *m = userdata;
1717 _cleanup_address_free_ Address *address = NULL;
1718 char buf[INET6_ADDRSTRLEN];
1725 r = sd_rtnl_message_get_type(message, &type);
1727 log_warning("rtnl: could not get message type");
1731 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1732 if (r < 0 || ifindex <= 0) {
1733 log_warning("rtnl: received address message without valid ifindex, ignoring");
1736 r = link_get(m, ifindex, &link);
1737 if (r < 0 || !link) {
1738 log_warning("rtnl: received address for a nonexistent link, ignoring");
1743 r = address_new_dynamic(&address);
1747 r = sd_rtnl_message_addr_get_family(message, &address->family);
1748 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1749 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
1753 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1755 log_warning_link(link, "rtnl: recevied address with invalid prefixlen, ignoring");
1759 switch (address->family) {
1761 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1763 log_warning_link(link, "rtnl: received address without valid address, ignoring");
1770 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1772 log_warning_link(link, "rtnl: received address without valid address, ignoring");
1779 assert_not_reached("invalid address family");
1782 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1783 log_warning_link(link, "could not print address");
1789 log_info_link(link, "added address: %s/%u", buf,
1790 address->prefixlen);
1794 log_info_link(link, "removed address: %s/%u", buf,
1795 address->prefixlen);
1798 assert_not_reached("Received invalid RTNL message type");
1804 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1805 Link *link = userdata;
1812 for (; m; m = sd_rtnl_message_next(m)) {
1813 r = sd_rtnl_message_get_errno(m);
1815 log_debug_link(link, "getting address failed: %s", strerror(-r));
1819 r = link_rtnl_process_address(rtnl, m, link->manager);
1821 log_warning_link(link, "could not process address: %s", strerror(-r));
1827 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1829 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1830 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1831 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1839 r = link_new(m, message, ret);
1845 log_debug_link(link, "link %"PRIu64" added", link->ifindex);
1847 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
1851 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
1855 if (detect_container(NULL) <= 0) {
1856 /* not in a container, udev will be around */
1857 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
1858 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1860 log_warning_link(link, "could not find udev device");
1864 if (udev_device_get_is_initialized(device) <= 0)
1869 r = link_initialized(link, device);
1876 int link_update(Link *link, sd_rtnl_message *m) {
1877 struct ether_addr mac;
1882 assert(link->ifname);
1885 if (link->state == LINK_STATE_LINGER) {
1887 log_info_link(link, "link readded");
1888 link->state = LINK_STATE_ENSLAVING;
1891 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1892 if (r >= 0 && !streq(ifname, link->ifname)) {
1893 log_info_link(link, "renamed to %s", ifname);
1896 link->ifname = strdup(ifname);
1901 if (!link->original_mtu) {
1902 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
1904 log_debug_link(link, "saved original MTU: %"
1905 PRIu16, link->original_mtu);
1908 /* The kernel may broadcast NEWLINK messages without the MAC address
1909 set, simply ignore them. */
1910 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1912 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
1914 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
1916 log_debug_link(link, "MAC address: "
1917 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1918 mac.ether_addr_octet[0],
1919 mac.ether_addr_octet[1],
1920 mac.ether_addr_octet[2],
1921 mac.ether_addr_octet[3],
1922 mac.ether_addr_octet[4],
1923 mac.ether_addr_octet[5]);
1926 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1928 log_warning_link(link, "Could not update MAC "
1929 "address in IPv4LL client: %s",
1935 if (link->dhcp_client) {
1936 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1938 log_warning_link(link, "Could not update MAC "
1939 "address in DHCP client: %s",
1947 return link_update_flags(link, m);
1950 int link_save(Link *link) {
1951 _cleanup_free_ char *temp_path = NULL;
1952 _cleanup_fclose_ FILE *f = NULL;
1953 const char *admin_state, *oper_state = "unknown";
1957 assert(link->state_file);
1958 assert(link->lease_file);
1959 assert(link->manager);
1961 r = manager_save(link->manager);
1965 if (link->state == LINK_STATE_LINGER) {
1966 unlink(link->state_file);
1970 admin_state = link_state_to_string(link->state);
1971 assert(admin_state);
1973 if (link->operstate == IF_OPER_DORMANT)
1974 oper_state = "dormant";
1975 else if (link_has_carrier(link->flags, link->operstate))
1976 oper_state = "carrier";
1978 r = fopen_temporary(link->state_file, &f, &temp_path);
1982 fchmod(fileno(f), 0644);
1985 "# This is private data. Do not parse.\n"
1989 admin_state, oper_state, link->flags);
1991 if (link->dhcp_lease) {
1992 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
1996 fprintf(f, "DHCP_LEASE=%s\n", link->lease_file);
1998 unlink(link->lease_file);
2002 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2004 unlink(link->state_file);
2010 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2015 static const char* const link_state_table[_LINK_STATE_MAX] = {
2016 [LINK_STATE_INITIALIZING] = "initializing",
2017 [LINK_STATE_ENSLAVING] = "configuring",
2018 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2019 [LINK_STATE_SETTING_ROUTES] = "configuring",
2020 [LINK_STATE_CONFIGURED] = "configured",
2021 [LINK_STATE_UNMANAGED] = "unmanaged",
2022 [LINK_STATE_FAILED] = "failed",
2023 [LINK_STATE_LINGER] = "linger",
2026 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);