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_free_ 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);
70 link->manager = manager;
71 link->state = LINK_STATE_INITIALIZING;
72 link->ifindex = ifindex;
73 link->ifname = strdup(ifname);
77 r = asprintf(&link->state_file, "/run/systemd/network/links/%"PRIu64,
82 r = asprintf(&link->lease_file, "/run/systemd/network/leases/%"PRIu64,
87 r = hashmap_put(manager->links, &link->ifindex, link);
97 void link_free(Link *link) {
101 assert(link->manager);
103 sd_dhcp_client_unref(link->dhcp_client);
104 sd_dhcp_lease_unref(link->dhcp_lease);
106 unlink(link->lease_file);
107 free(link->lease_file);
109 sd_ipv4ll_unref(link->ipv4ll);
111 hashmap_remove(link->manager->links, &link->ifindex);
115 unlink(link->state_file);
116 free(link->state_file);
118 udev_device_unref(link->udev_device);
123 int link_get(Manager *m, int ifindex, Link **ret) {
132 ifindex_64 = ifindex;
133 link = hashmap_get(m->links, &ifindex_64);
142 static int link_enter_configured(Link *link) {
144 assert(link->state == LINK_STATE_SETTING_ROUTES);
146 log_info_link(link, "link configured");
148 link->state = LINK_STATE_CONFIGURED;
155 static void link_enter_unmanaged(Link *link) {
158 log_debug_link(link, "unmanaged");
160 link->state = LINK_STATE_UNMANAGED;
165 static int link_stop_clients(Link *link) {
169 assert(link->manager);
170 assert(link->manager->event);
175 if (link->network->dhcp) {
176 assert(link->dhcp_client);
178 k = sd_dhcp_client_stop(link->dhcp_client);
180 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
185 if (link->network->ipv4ll) {
186 assert(link->ipv4ll);
188 k = sd_ipv4ll_stop(link->ipv4ll);
190 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
198 static void link_enter_failed(Link *link) {
201 if (link->state == LINK_STATE_FAILED)
204 log_warning_link(link, "failed");
206 link->state = LINK_STATE_FAILED;
208 link_stop_clients(link);
213 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
214 Link *link = userdata;
217 assert(link->route_messages > 0);
218 assert(link->state == LINK_STATE_SETTING_ADDRESSES ||
219 link->state == LINK_STATE_SETTING_ROUTES ||
220 link->state == LINK_STATE_FAILED);
222 link->route_messages --;
224 if (link->state == LINK_STATE_FAILED)
227 r = sd_rtnl_message_get_errno(m);
228 if (r < 0 && r != -EEXIST)
229 log_struct_link(LOG_WARNING, link,
230 "MESSAGE=%s: could not set route: %s",
231 link->ifname, strerror(-r),
235 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
237 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
238 log_debug_link(link, "routes set");
239 link_enter_configured(link);
245 static int link_enter_set_routes(Link *link) {
250 assert(link->network);
251 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
253 link->state = LINK_STATE_SETTING_ROUTES;
255 if (!link->network->static_routes && !link->dhcp_lease &&
256 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
257 return link_enter_configured(link);
259 log_debug_link(link, "setting routes");
261 LIST_FOREACH(static_routes, rt, link->network->static_routes) {
262 r = route_configure(rt, link, &route_handler);
264 log_warning_link(link,
265 "could not set routes: %s", strerror(-r));
266 link_enter_failed(link);
270 link->route_messages ++;
273 if (link->ipv4ll && !link->dhcp_lease) {
274 _cleanup_route_free_ Route *route = NULL;
277 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
278 if (r < 0 && r != -ENOENT) {
279 log_warning_link(link, "IPV4LL error: no address: %s",
285 r = route_new_dynamic(&route);
287 log_error_link(link, "Could not allocate route: %s",
292 route->family = AF_INET;
293 route->scope = RT_SCOPE_LINK;
296 r = route_configure(route, link, &route_handler);
298 log_warning_link(link,
299 "could not set routes: %s", strerror(-r));
300 link_enter_failed(link);
304 link->route_messages ++;
308 if (link->dhcp_lease) {
309 _cleanup_route_free_ Route *route = NULL;
310 _cleanup_route_free_ Route *route_gw = NULL;
311 struct in_addr gateway;
313 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
314 if (r < 0 && r != -ENOENT) {
315 log_warning_link(link, "DHCP error: %s", strerror(-r));
320 r = route_new_dynamic(&route);
322 log_error_link(link, "Could not allocate route: %s",
327 r = route_new_dynamic(&route_gw);
329 log_error_link(link, "Could not allocate route: %s",
334 /* The dhcp netmask may mask out the gateway. Add an explicit
335 * route for the gw host so that we can route no matter the
336 * netmask or existing kernel route tables. */
337 route_gw->family = AF_INET;
338 route_gw->dst_addr.in = gateway;
339 route_gw->dst_prefixlen = 32;
340 route_gw->scope = RT_SCOPE_LINK;
342 r = route_configure(route_gw, link, &route_handler);
344 log_warning_link(link,
345 "could not set host route: %s", strerror(-r));
349 link->route_messages ++;
351 route->family = AF_INET;
352 route->in_addr.in = gateway;
354 r = route_configure(route, link, &route_handler);
356 log_warning_link(link,
357 "could not set routes: %s", strerror(-r));
358 link_enter_failed(link);
362 link->route_messages ++;
366 if (link->route_messages == 0) {
367 link_enter_configured(link);
373 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
374 Link *link = userdata;
379 assert(link->ifname);
381 if (link->state == LINK_STATE_FAILED)
384 r = sd_rtnl_message_get_errno(m);
385 if (r < 0 && r != -ENOENT)
386 log_struct_link(LOG_WARNING, link,
387 "MESSAGE=%s: could not drop route: %s",
388 link->ifname, strerror(-r),
395 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
396 Link *link = userdata;
401 assert(link->ifname);
402 assert(link->addr_messages > 0);
403 assert(link->state == LINK_STATE_SETTING_ADDRESSES || link->state == LINK_STATE_FAILED);
405 link->addr_messages --;
407 if (link->state == LINK_STATE_FAILED)
410 r = sd_rtnl_message_get_errno(m);
411 if (r < 0 && r != -EEXIST)
412 log_struct_link(LOG_WARNING, link,
413 "MESSAGE=%s: could not set address: %s",
414 link->ifname, strerror(-r),
418 if (link->addr_messages == 0) {
419 log_debug_link(link, "addresses set");
420 link_enter_set_routes(link);
426 static int link_enter_set_addresses(Link *link) {
431 assert(link->network);
432 assert(link->state != _LINK_STATE_INVALID);
434 link->state = LINK_STATE_SETTING_ADDRESSES;
436 if (!link->network->static_addresses && !link->dhcp_lease &&
437 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
438 return link_enter_set_routes(link);
440 log_debug_link(link, "setting addresses");
442 LIST_FOREACH(static_addresses, ad, link->network->static_addresses) {
443 r = address_configure(ad, link, &address_handler);
445 log_warning_link(link,
446 "could not set addresses: %s", strerror(-r));
447 link_enter_failed(link);
451 link->addr_messages ++;
454 if (link->ipv4ll && !link->dhcp_lease) {
455 _cleanup_address_free_ Address *ll_addr = NULL;
458 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
459 if (r < 0 && r != -ENOENT) {
460 log_warning_link(link, "IPV4LL error: no address: %s",
466 r = address_new_dynamic(&ll_addr);
468 log_error_link(link, "Could not allocate address: %s", strerror(-r));
472 ll_addr->family = AF_INET;
473 ll_addr->in_addr.in = addr;
474 ll_addr->prefixlen = 16;
475 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
476 ll_addr->scope = RT_SCOPE_LINK;
478 r = address_configure(ll_addr, link, &address_handler);
480 log_warning_link(link,
481 "could not set addresses: %s", strerror(-r));
482 link_enter_failed(link);
486 link->addr_messages ++;
490 if (link->dhcp_lease) {
491 _cleanup_address_free_ Address *address = NULL;
493 struct in_addr netmask;
496 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
498 log_warning_link(link, "DHCP error: no address: %s",
503 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
505 log_warning_link(link, "DHCP error: no netmask: %s",
510 prefixlen = net_netmask_to_prefixlen(&netmask);
512 r = address_new_dynamic(&address);
514 log_error_link(link, "Could not allocate address: %s",
519 address->family = AF_INET;
520 address->in_addr.in = addr;
521 address->prefixlen = prefixlen;
522 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
524 r = address_configure(address, link, &address_handler);
526 log_warning_link(link,
527 "could not set addresses: %s", strerror(-r));
528 link_enter_failed(link);
532 link->addr_messages ++;
538 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
539 Link *link = userdata;
544 assert(link->ifname);
546 if (link->state == LINK_STATE_FAILED)
549 r = sd_rtnl_message_get_errno(m);
550 if (r < 0 && r != -ENOENT)
551 log_struct_link(LOG_WARNING, link,
552 "MESSAGE=%s: could not update address: %s",
553 link->ifname, strerror(-r),
560 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
561 Link *link = userdata;
566 assert(link->ifname);
568 if (link->state == LINK_STATE_FAILED)
571 r = sd_rtnl_message_get_errno(m);
572 if (r < 0 && r != -ENOENT)
573 log_struct_link(LOG_WARNING, link,
574 "MESSAGE=%s: could not drop address: %s",
575 link->ifname, strerror(-r),
582 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
585 r = sd_bus_message_get_errno(m);
587 log_warning("Could not set hostname: %s", strerror(-r));
592 static int set_hostname(sd_bus *bus, const char *hostname) {
593 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
598 log_debug("Setting transient hostname: '%s'", hostname);
600 if (!bus) { /* TODO: replace by assert when we can rely on kdbus */
601 log_info("Not connected to system bus, ignoring transient hostname.");
605 r = sd_bus_message_new_method_call(
608 "org.freedesktop.hostname1",
609 "/org/freedesktop/hostname1",
610 "org.freedesktop.hostname1",
615 r = sd_bus_message_append(m, "sb", hostname, false);
619 r = sd_bus_call_async(bus, m, set_hostname_handler, NULL, 0, NULL);
621 log_error("Could not set transient hostname: %s", strerror(-r));
626 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
627 Link *link = userdata;
632 assert(link->ifname);
634 if (link->state == LINK_STATE_FAILED)
637 r = sd_rtnl_message_get_errno(m);
639 log_struct_link(LOG_WARNING, link,
640 "MESSAGE=%s: could not set MTU: %s",
641 link->ifname, strerror(-r),
648 static int link_set_mtu(Link *link, uint32_t mtu) {
649 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
653 assert(link->manager);
654 assert(link->manager->rtnl);
656 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
658 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
659 RTM_SETLINK, link->ifindex);
661 log_error_link(link, "Could not allocate RTM_SETLINK message");
665 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
667 log_error_link(link, "Could not append MTU: %s", strerror(-r));
671 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
674 "Could not send rtnetlink message: %s", strerror(-r));
681 static int dhcp_lease_lost(Link *link) {
682 _cleanup_address_free_ Address *address = NULL;
683 _cleanup_route_free_ Route *route_gw = NULL;
684 _cleanup_route_free_ Route *route = NULL;
686 struct in_addr netmask;
687 struct in_addr gateway;
692 assert(link->dhcp_lease);
694 log_warning_link(link, "DHCP lease lost");
696 r = address_new_dynamic(&address);
698 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
700 r = route_new_dynamic(&route_gw);
702 route_gw->family = AF_INET;
703 route_gw->dst_addr.in = gateway;
704 route_gw->dst_prefixlen = 32;
705 route_gw->scope = RT_SCOPE_LINK;
707 route_drop(route_gw, link, &route_drop_handler);
710 r = route_new_dynamic(&route);
712 route->family = AF_INET;
713 route->in_addr.in = gateway;
715 route_drop(route, link, &route_drop_handler);
719 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
720 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
721 prefixlen = net_netmask_to_prefixlen(&netmask);
723 address->family = AF_INET;
724 address->in_addr.in = addr;
725 address->prefixlen = prefixlen;
727 address_drop(address, link, &address_drop_handler);
730 if (link->network->dhcp_mtu) {
733 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
734 if (r >= 0 && link->original_mtu != mtu) {
735 r = link_set_mtu(link, link->original_mtu);
737 log_warning_link(link, "DHCP error: could not reset MTU");
738 link_enter_failed(link);
744 if (link->network->dhcp_hostname) {
745 const char *hostname = NULL;
747 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
748 if (r >= 0 && hostname) {
749 r = set_hostname(link->manager->bus, "");
751 log_error("Failed to reset transient hostname");
755 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
760 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
761 sd_dhcp_lease *lease;
762 struct in_addr address;
763 struct in_addr netmask;
764 struct in_addr gateway;
766 struct in_addr *nameservers;
767 size_t nameservers_size;
773 r = sd_dhcp_client_get_lease(client, &lease);
775 log_warning_link(link, "DHCP error: no lease: %s",
780 r = sd_dhcp_lease_get_address(lease, &address);
782 log_warning_link(link, "DHCP error: no address: %s",
787 r = sd_dhcp_lease_get_netmask(lease, &netmask);
789 log_warning_link(link, "DHCP error: no netmask: %s",
794 prefixlen = net_netmask_to_prefixlen(&netmask);
796 r = sd_dhcp_lease_get_router(lease, &gateway);
797 if (r < 0 && r != -ENOENT) {
798 log_warning_link(link, "DHCP error: %s", strerror(-r));
803 log_struct_link(LOG_INFO, link,
804 "MESSAGE=%s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
806 ADDRESS_FMT_VAL(address),
808 ADDRESS_FMT_VAL(gateway),
809 "ADDRESS=%u.%u.%u.%u",
810 ADDRESS_FMT_VAL(address),
813 "GATEWAY=%u.%u.%u.%u",
814 ADDRESS_FMT_VAL(gateway),
817 log_struct_link(LOG_INFO, link,
818 "MESSAGE=%s: DHCPv4 address %u.%u.%u.%u/%u",
820 ADDRESS_FMT_VAL(address),
822 "ADDRESS=%u.%u.%u.%u",
823 ADDRESS_FMT_VAL(address),
828 link->dhcp_lease = lease;
830 if (link->network->dhcp_dns) {
831 r = sd_dhcp_lease_get_dns(lease, &nameservers, &nameservers_size);
833 r = manager_update_resolv_conf(link->manager);
835 log_error("Failed to update resolv.conf");
839 if (link->network->dhcp_mtu) {
842 r = sd_dhcp_lease_get_mtu(lease, &mtu);
844 r = link_set_mtu(link, mtu);
846 log_error_link(link, "Failed to set MTU "
851 if (link->network->dhcp_hostname) {
852 const char *hostname;
854 r = sd_dhcp_lease_get_hostname(lease, &hostname);
856 r = set_hostname(link->manager->bus, hostname);
858 log_error("Failed to set transient hostname "
859 "to '%s'", hostname);
863 link_enter_set_addresses(link);
868 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
869 Link *link = userdata;
873 assert(link->network);
874 assert(link->manager);
876 if (link->state == LINK_STATE_FAILED)
880 case DHCP_EVENT_NO_LEASE:
881 log_debug_link(link, "IP address in use.");
883 case DHCP_EVENT_EXPIRED:
884 case DHCP_EVENT_STOP:
885 case DHCP_EVENT_IP_CHANGE:
886 if (link->network->dhcp_critical) {
887 log_error_link(link, "DHCPv4 connection considered system critical, "
888 "ignoring request to reconfigure it.");
892 if (link->dhcp_lease) {
893 r = dhcp_lease_lost(link);
895 link_enter_failed(link);
900 if (event == DHCP_EVENT_IP_CHANGE) {
901 r = dhcp_lease_acquired(client, link);
903 link_enter_failed(link);
908 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
909 if (!sd_ipv4ll_is_running(link->ipv4ll))
910 r = sd_ipv4ll_start(link->ipv4ll);
911 else if (ipv4ll_is_bound(link->ipv4ll))
912 r = ipv4ll_address_update(link, false);
914 link_enter_failed(link);
920 case DHCP_EVENT_IP_ACQUIRE:
921 r = dhcp_lease_acquired(client, link);
923 link_enter_failed(link);
927 if (ipv4ll_is_bound(link->ipv4ll))
928 r = ipv4ll_address_update(link, true);
930 r = sd_ipv4ll_stop(link->ipv4ll);
932 link_enter_failed(link);
939 log_warning_link(link, "DHCP error: %s", strerror(-event));
941 log_warning_link(link, "DHCP unknown event: %d", event);
948 static int ipv4ll_address_update(Link *link, bool deprecate) {
954 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
956 _cleanup_address_free_ Address *address = NULL;
958 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
959 deprecate ? "deprecate" : "approve",
960 ADDRESS_FMT_VAL(addr));
962 r = address_new_dynamic(&address);
964 log_error_link(link, "Could not allocate address: %s", strerror(-r));
968 address->family = AF_INET;
969 address->in_addr.in = addr;
970 address->prefixlen = 16;
971 address->scope = RT_SCOPE_LINK;
972 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
973 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
975 address_update(address, link, &address_update_handler);
982 static int ipv4ll_address_lost(Link *link) {
988 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
990 _cleanup_address_free_ Address *address = NULL;
991 _cleanup_route_free_ Route *route = NULL;
993 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
994 ADDRESS_FMT_VAL(addr));
996 r = address_new_dynamic(&address);
998 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1002 address->family = AF_INET;
1003 address->in_addr.in = addr;
1004 address->prefixlen = 16;
1005 address->scope = RT_SCOPE_LINK;
1007 address_drop(address, link, &address_drop_handler);
1009 r = route_new_dynamic(&route);
1011 log_error_link(link, "Could not allocate route: %s",
1016 route->family = AF_INET;
1017 route->scope = RT_SCOPE_LINK;
1018 route->metrics = 99;
1020 route_drop(route, link, &route_drop_handler);
1026 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1028 struct in_addr addr;
1032 r = sd_ipv4ll_get_address(ll, &addr);
1038 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1039 struct in_addr address;
1045 r = sd_ipv4ll_get_address(ll, &address);
1049 log_struct_link(LOG_INFO, link,
1050 "MESSAGE=%s: IPv4 link-local address %u.%u.%u.%u",
1052 ADDRESS_FMT_VAL(address),
1055 link_enter_set_addresses(link);
1060 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1061 Link *link = userdata;
1065 assert(link->network);
1066 assert(link->manager);
1069 case IPV4LL_EVENT_STOP:
1070 case IPV4LL_EVENT_CONFLICT:
1071 r = ipv4ll_address_lost(link);
1073 link_enter_failed(link);
1077 case IPV4LL_EVENT_BIND:
1078 r = ipv4ll_address_claimed(ll, link);
1080 link_enter_failed(link);
1086 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1088 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1093 static int link_acquire_conf(Link *link) {
1097 assert(link->network);
1098 assert(link->manager);
1099 assert(link->manager->event);
1101 if (link->network->ipv4ll) {
1102 assert(link->ipv4ll);
1104 log_debug_link(link, "acquiring IPv4 link-local address");
1106 r = sd_ipv4ll_start(link->ipv4ll);
1108 log_warning_link(link, "could not acquire IPv4 "
1109 "link-local address");
1114 if (link->network->dhcp) {
1115 assert(link->dhcp_client);
1117 log_debug_link(link, "acquiring DHCPv4 lease");
1119 r = sd_dhcp_client_start(link->dhcp_client);
1121 log_warning_link(link, "could not acquire DHCPv4 "
1130 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1131 /* see Documentation/networking/operstates.txt in the kernel sources */
1133 if (operstate == IF_OPER_UP)
1136 if (operstate == IF_OPER_UNKNOWN)
1137 /* operstate may not be implemented, so fall back to flags */
1138 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1144 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1145 unsigned flags, flags_added, flags_removed, generic_flags;
1147 bool carrier_gained = false, carrier_lost = false;
1152 r = sd_rtnl_message_link_get_flags(m, &flags);
1154 log_warning_link(link, "Could not get link flags");
1158 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1160 /* if we got a message without operstate, take it to mean
1161 the state was unchanged */
1162 operstate = link->operstate;
1164 if ((link->flags == flags) && (link->operstate == operstate))
1167 flags_added = (link->flags ^ flags) & flags;
1168 flags_removed = (link->flags ^ flags) & link->flags;
1169 generic_flags = ~(IFF_UP | IFF_LOWER_UP | IFF_DORMANT | IFF_DEBUG |
1170 IFF_MULTICAST | IFF_BROADCAST | IFF_PROMISC |
1171 IFF_NOARP | IFF_MASTER | IFF_SLAVE | IFF_RUNNING);
1173 if (flags_added & IFF_UP)
1174 log_debug_link(link, "link is up");
1175 else if (flags_removed & IFF_UP)
1176 log_debug_link(link, "link is down");
1178 if (flags_added & IFF_LOWER_UP)
1179 log_debug_link(link, "link is lower up");
1180 else if (flags_removed & IFF_LOWER_UP)
1181 log_debug_link(link, "link is lower down");
1183 if (flags_added & IFF_DORMANT)
1184 log_debug_link(link, "link is dormant");
1185 else if (flags_removed & IFF_DORMANT)
1186 log_debug_link(link, "link is not dormant");
1188 if (flags_added & IFF_DEBUG)
1189 log_debug_link(link, "debugging enabled in the kernel");
1190 else if (flags_removed & IFF_DEBUG)
1191 log_debug_link(link, "debugging disabled in the kernel");
1193 if (flags_added & IFF_MULTICAST)
1194 log_debug_link(link, "multicast enabled");
1195 else if (flags_removed & IFF_MULTICAST)
1196 log_debug_link(link, "multicast disabled");
1198 if (flags_added & IFF_BROADCAST)
1199 log_debug_link(link, "broadcast enabled");
1200 else if (flags_removed & IFF_BROADCAST)
1201 log_debug_link(link, "broadcast disabled");
1203 if (flags_added & IFF_PROMISC)
1204 log_debug_link(link, "promiscuous mode enabled");
1205 else if (flags_removed & IFF_PROMISC)
1206 log_debug_link(link, "promiscuous mode disabled");
1208 if (flags_added & IFF_NOARP)
1209 log_debug_link(link, "ARP protocol disabled");
1210 else if (flags_removed & IFF_NOARP)
1211 log_debug_link(link, "ARP protocol enabled");
1213 if (flags_added & IFF_MASTER)
1214 log_debug_link(link, "link is master");
1215 else if (flags_removed & IFF_MASTER)
1216 log_debug_link(link, "link is no longer master");
1218 if (flags_added & IFF_SLAVE)
1219 log_debug_link(link, "link is slave");
1220 else if (flags_removed & IFF_SLAVE)
1221 log_debug_link(link, "link is no longer slave");
1223 /* link flags are currently at most 18 bits, let's default to printing 20 */
1224 if (flags_added & generic_flags)
1225 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1226 flags_added & generic_flags);
1228 if (flags_removed & generic_flags)
1229 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1230 flags_removed & generic_flags);
1232 carrier_gained = !link_has_carrier(link->flags, link->operstate) &&
1233 link_has_carrier(flags, operstate);
1234 carrier_lost = link_has_carrier(link->flags, link->operstate) &&
1235 !link_has_carrier(flags, operstate);
1237 link->flags = flags;
1238 link->operstate = operstate;
1242 if (link->state == LINK_STATE_FAILED ||
1243 link->state == LINK_STATE_UNMANAGED)
1246 if (carrier_gained) {
1247 log_info_link(link, "gained carrier");
1249 if (link->network) {
1250 r = link_acquire_conf(link);
1252 link_enter_failed(link);
1256 } else if (carrier_lost) {
1257 log_info_link(link, "lost carrier");
1259 r = link_stop_clients(link);
1261 link_enter_failed(link);
1269 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1270 Link *link = userdata;
1275 if (link->state == LINK_STATE_FAILED)
1278 r = sd_rtnl_message_get_errno(m);
1280 /* we warn but don't fail the link, as it may
1281 be brought up later */
1282 log_struct_link(LOG_WARNING, link,
1283 "MESSAGE=%s: could not bring up interface: %s",
1284 link->ifname, strerror(-r),
1292 static int link_up(Link *link) {
1293 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1297 assert(link->manager);
1298 assert(link->manager->rtnl);
1300 log_debug_link(link, "bringing link up");
1302 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1303 RTM_SETLINK, link->ifindex);
1305 log_error_link(link, "Could not allocate RTM_SETLINK message");
1309 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1311 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1315 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1317 log_error_link(link,
1318 "Could not send rtnetlink message: %s", strerror(-r));
1325 static int link_enslaved(Link *link) {
1329 assert(link->state == LINK_STATE_ENSLAVING);
1330 assert(link->network);
1332 if (!(link->flags & IFF_UP)) {
1335 link_enter_failed(link);
1340 if (!link->network->dhcp && !link->network->ipv4ll)
1341 return link_enter_set_addresses(link);
1346 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1347 Link *link = userdata;
1351 assert(link->state == LINK_STATE_ENSLAVING || link->state == LINK_STATE_FAILED);
1352 assert(link->network);
1356 if (link->state == LINK_STATE_FAILED)
1359 r = sd_rtnl_message_get_errno(m);
1361 log_struct_link(LOG_ERR, link,
1362 "MESSAGE=%s: could not enslave: %s",
1363 link->ifname, strerror(-r),
1366 link_enter_failed(link);
1370 log_debug_link(link, "enslaved");
1372 if (link->enslaving == 0)
1373 link_enslaved(link);
1378 static int link_enter_enslave(Link *link) {
1379 NetDev *vlan, *macvlan;
1384 assert(link->network);
1385 assert(link->state == LINK_STATE_INITIALIZING);
1387 link->state = LINK_STATE_ENSLAVING;
1391 if (!link->network->bridge && !link->network->bond &&
1392 hashmap_isempty(link->network->vlans) &&
1393 hashmap_isempty(link->network->macvlans))
1394 return link_enslaved(link);
1396 if (link->network->bridge) {
1397 log_struct_link(LOG_DEBUG, link,
1398 "MESSAGE=%s: enslaving by '%s'",
1399 link->ifname, link->network->bridge->name,
1400 NETDEV(link->network->bridge),
1403 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1405 log_struct_link(LOG_WARNING, link,
1406 "MESSAGE=%s: could not enslave by '%s': %s",
1407 link->ifname, link->network->bridge->name, strerror(-r),
1408 NETDEV(link->network->bridge),
1410 link_enter_failed(link);
1417 if (link->network->bond) {
1418 log_struct_link(LOG_DEBUG, link,
1419 "MESSAGE=%s: enslaving by '%s'",
1420 link->ifname, link->network->bond->name,
1421 NETDEV(link->network->bond),
1424 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1426 log_struct_link(LOG_WARNING, link,
1427 "MESSAGE=%s: could not enslave by '%s': %s",
1428 link->ifname, link->network->bond->name, strerror(-r),
1429 NETDEV(link->network->bond),
1431 link_enter_failed(link);
1438 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1439 log_struct_link(LOG_DEBUG, link,
1440 "MESSAGE=%s: enslaving by '%s'",
1441 link->ifname, vlan->name, NETDEV(vlan), NULL);
1443 r = netdev_enslave(vlan, link, &enslave_handler);
1445 log_struct_link(LOG_WARNING, link,
1446 "MESSAGE=%s: could not enslave by '%s': %s",
1447 link->ifname, vlan->name, strerror(-r),
1448 NETDEV(vlan), NULL);
1449 link_enter_failed(link);
1456 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1457 log_struct_link(LOG_DEBUG, link,
1458 "MESSAGE=%s: enslaving by '%s'",
1459 link->ifname, macvlan->name, NETDEV(macvlan), NULL);
1461 r = netdev_enslave(macvlan, link, &enslave_handler);
1463 log_struct_link(LOG_WARNING, link,
1464 "MESSAGE=%s: could not enslave by '%s': %s",
1465 link->ifname, macvlan->name, strerror(-r),
1466 NETDEV(macvlan), NULL);
1467 link_enter_failed(link);
1477 static int link_configure(Link *link) {
1481 assert(link->state == LINK_STATE_INITIALIZING);
1483 if (link->network->ipv4ll) {
1486 r = sd_ipv4ll_new(&link->ipv4ll);
1490 if (link->udev_device) {
1491 r = net_get_unique_predictable_data(link->udev_device, seed);
1493 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1499 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1503 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1507 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1511 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1516 if (link->network->dhcp) {
1517 r = sd_dhcp_client_new(&link->dhcp_client);
1521 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1525 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1529 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1533 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1537 if (link->network->dhcp_mtu) {
1538 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1544 if (link_has_carrier(link->flags, link->operstate)) {
1545 r = link_acquire_conf(link);
1550 return link_enter_enslave(link);
1553 int link_initialized(Link *link, struct udev_device *device) {
1558 assert(link->ifname);
1559 assert(link->manager);
1561 if (link->state != LINK_STATE_INITIALIZING)
1565 link->udev_device = udev_device_ref(device);
1567 log_debug_link(link, "link initialized");
1569 r = network_get(link->manager, device, link->ifname, &link->mac, &network);
1571 link_enter_unmanaged(link);
1576 r = network_apply(link->manager, network, link);
1580 r = link_configure(link);
1587 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1589 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1590 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1597 r = link_new(m, message, ret);
1603 log_debug_link(link, "link added");
1605 if (detect_container(NULL) <= 0) {
1606 /* not in a container, udev will be around */
1607 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
1608 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1610 log_warning_link(link, "could not find udev device");
1614 if (udev_device_get_is_initialized(device) <= 0)
1619 r = link_initialized(link, device);
1626 int link_update(Link *link, sd_rtnl_message *m) {
1627 struct ether_addr mac;
1632 assert(link->ifname);
1635 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1636 if (r >= 0 && !streq(ifname, link->ifname)) {
1637 log_info_link(link, "renamed to %s", ifname);
1640 link->ifname = strdup(ifname);
1645 if (!link->original_mtu) {
1646 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
1648 log_debug_link(link, "saved original MTU: %"
1649 PRIu16, link->original_mtu);
1652 /* The kernel may broadcast NEWLINK messages without the MAC address
1653 set, simply ignore them. */
1654 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1656 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
1658 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
1660 log_debug_link(link, "MAC address: "
1661 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1662 mac.ether_addr_octet[0],
1663 mac.ether_addr_octet[1],
1664 mac.ether_addr_octet[2],
1665 mac.ether_addr_octet[3],
1666 mac.ether_addr_octet[4],
1667 mac.ether_addr_octet[5]);
1670 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1672 log_warning_link(link, "Could not update MAC "
1673 "address in IPv4LL client: %s",
1679 if (link->dhcp_client) {
1680 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1682 log_warning_link(link, "Could not update MAC "
1683 "address in DHCP client: %s",
1691 return link_update_flags(link, m);
1694 int link_save(Link *link) {
1695 _cleanup_free_ char *temp_path = NULL;
1696 _cleanup_fclose_ FILE *f = NULL;
1697 const char *admin_state, *oper_state = "unknown";
1701 assert(link->state_file);
1702 assert(link->lease_file);
1703 assert(link->manager);
1705 r = manager_save(link->manager);
1709 admin_state = link_state_to_string(link->state);
1710 assert(admin_state);
1712 if (link->operstate == IF_OPER_DORMANT)
1713 oper_state = "dormant";
1714 else if (link_has_carrier(link->flags, link->operstate))
1715 oper_state = "carrier";
1717 r = fopen_temporary(link->state_file, &f, &temp_path);
1721 fchmod(fileno(f), 0644);
1724 "# This is private data. Do not parse.\n"
1728 admin_state, oper_state, link->flags);
1730 if (link->dhcp_lease) {
1731 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
1735 fprintf(f, "DHCP_LEASE=%s\n", link->lease_file);
1737 unlink(link->lease_file);
1741 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
1743 unlink(link->state_file);
1749 log_error("Failed to save link data to %s: %s", link->state_file, strerror(-r));
1754 static const char* const link_state_table[_LINK_STATE_MAX] = {
1755 [LINK_STATE_INITIALIZING] = "initializing",
1756 [LINK_STATE_ENSLAVING] = "configuring",
1757 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1758 [LINK_STATE_SETTING_ROUTES] = "configuring",
1759 [LINK_STATE_CONFIGURED] = "configured",
1760 [LINK_STATE_UNMANAGED] = "unmanaged",
1761 [LINK_STATE_FAILED] = "failed",
1764 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);