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 "dhcp-lease-internal.h"
35 static int ipv4ll_address_update(Link *link, bool deprecate);
36 static bool ipv4ll_is_bound(sd_ipv4ll *ll);
38 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
39 _cleanup_link_free_ Link *link = NULL;
45 assert(manager->links);
49 r = sd_rtnl_message_get_type(message, &type);
52 else if (type != RTM_NEWLINK)
55 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
58 else if (ifindex <= 0)
61 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
69 link->manager = manager;
70 link->state = LINK_STATE_INITIALIZING;
71 link->ifindex = ifindex;
72 link->ifname = strdup(ifname);
76 r = asprintf(&link->state_file, "/run/systemd/network/links/%"PRIu64,
81 r = hashmap_put(manager->links, &link->ifindex, link);
91 void link_free(Link *link) {
95 assert(link->manager);
97 sd_dhcp_client_unref(link->dhcp_client);
98 sd_dhcp_lease_unref(link->dhcp_lease);
100 sd_ipv4ll_unref(link->ipv4ll);
102 hashmap_remove(link->manager->links, &link->ifindex);
105 free(link->state_file);
107 udev_device_unref(link->udev_device);
112 int link_get(Manager *m, int ifindex, Link **ret) {
121 ifindex_64 = ifindex;
122 link = hashmap_get(m->links, &ifindex_64);
131 static int link_enter_configured(Link *link) {
133 assert(link->state == LINK_STATE_SETTING_ROUTES);
135 log_info_link(link, "link configured");
137 link->state = LINK_STATE_CONFIGURED;
144 static void link_enter_failed(Link *link) {
147 log_warning_link(link, "failed");
149 link->state = LINK_STATE_FAILED;
154 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
155 Link *link = userdata;
158 assert(link->route_messages > 0);
159 assert(link->state == LINK_STATE_SETTING_ADDRESSES ||
160 link->state == LINK_STATE_SETTING_ROUTES ||
161 link->state == LINK_STATE_FAILED);
163 link->route_messages --;
165 if (link->state == LINK_STATE_FAILED)
168 r = sd_rtnl_message_get_errno(m);
169 if (r < 0 && r != -EEXIST)
170 log_struct_link(LOG_WARNING, link,
171 "MESSAGE=%s: could not set route: %s",
172 link->ifname, strerror(-r),
176 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
178 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
179 log_debug_link(link, "routes set");
180 link_enter_configured(link);
186 static int link_enter_set_routes(Link *link) {
191 assert(link->network);
192 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
194 link->state = LINK_STATE_SETTING_ROUTES;
196 if (!link->network->static_routes && !link->dhcp_lease &&
197 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
198 return link_enter_configured(link);
200 log_debug_link(link, "setting routes");
202 LIST_FOREACH(static_routes, rt, link->network->static_routes) {
203 r = route_configure(rt, link, &route_handler);
205 log_warning_link(link,
206 "could not set routes: %s", strerror(-r));
207 link_enter_failed(link);
211 link->route_messages ++;
214 if (link->ipv4ll && !link->dhcp_lease) {
215 _cleanup_route_free_ Route *route = NULL;
218 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
219 if (r < 0 && r != -ENOENT) {
220 log_warning_link(link, "IPV4LL error: no address: %s",
226 r = route_new_dynamic(&route);
228 log_error_link(link, "Could not allocate route: %s",
233 route->family = AF_INET;
234 route->scope = RT_SCOPE_LINK;
237 r = route_configure(route, link, &route_handler);
239 log_warning_link(link,
240 "could not set routes: %s", strerror(-r));
241 link_enter_failed(link);
245 link->route_messages ++;
249 if (link->dhcp_lease) {
250 _cleanup_route_free_ Route *route = NULL;
251 _cleanup_route_free_ Route *route_gw = NULL;
252 struct in_addr gateway;
254 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
256 log_warning_link(link, "DHCP error: no router: %s",
261 r = route_new_dynamic(&route);
263 log_error_link(link, "Could not allocate route: %s",
268 r = route_new_dynamic(&route_gw);
270 log_error_link(link, "Could not allocate route: %s",
275 /* The dhcp netmask may mask out the gateway. Add an explicit
276 * route for the gw host so that we can route no matter the
277 * netmask or existing kernel route tables. */
278 route_gw->family = AF_INET;
279 route_gw->dst_addr.in = gateway;
280 route_gw->dst_prefixlen = 32;
281 route_gw->scope = RT_SCOPE_LINK;
283 r = route_configure(route_gw, link, &route_handler);
285 log_warning_link(link,
286 "could not set host route: %s", strerror(-r));
290 link->route_messages ++;
292 route->family = AF_INET;
293 route->in_addr.in = gateway;
295 r = route_configure(route, link, &route_handler);
297 log_warning_link(link,
298 "could not set routes: %s", strerror(-r));
299 link_enter_failed(link);
303 link->route_messages ++;
309 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
310 Link *link = userdata;
315 assert(link->ifname);
317 if (link->state == LINK_STATE_FAILED)
320 r = sd_rtnl_message_get_errno(m);
321 if (r < 0 && r != -ENOENT)
322 log_struct_link(LOG_WARNING, link,
323 "MESSAGE=%s: could not drop route: %s",
324 link->ifname, strerror(-r),
331 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
332 Link *link = userdata;
337 assert(link->ifname);
338 assert(link->addr_messages > 0);
339 assert(link->state == LINK_STATE_SETTING_ADDRESSES || link->state == LINK_STATE_FAILED);
341 link->addr_messages --;
343 if (link->state == LINK_STATE_FAILED)
346 r = sd_rtnl_message_get_errno(m);
347 if (r < 0 && r != -EEXIST)
348 log_struct_link(LOG_WARNING, link,
349 "MESSAGE=%s: could not set address: %s",
350 link->ifname, strerror(-r),
354 if (link->addr_messages == 0) {
355 log_debug_link(link, "addresses set");
356 link_enter_set_routes(link);
362 static int link_enter_set_addresses(Link *link) {
367 assert(link->network);
368 assert(link->state != _LINK_STATE_INVALID);
370 link->state = LINK_STATE_SETTING_ADDRESSES;
372 if (!link->network->static_addresses && !link->dhcp_lease &&
373 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
374 return link_enter_set_routes(link);
376 log_debug_link(link, "setting addresses");
378 LIST_FOREACH(static_addresses, ad, link->network->static_addresses) {
379 r = address_configure(ad, link, &address_handler);
381 log_warning_link(link,
382 "could not set addresses: %s", strerror(-r));
383 link_enter_failed(link);
387 link->addr_messages ++;
390 if (link->ipv4ll && !link->dhcp_lease) {
391 _cleanup_address_free_ Address *ll_addr = NULL;
394 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
395 if (r < 0 && r != -ENOENT) {
396 log_warning_link(link, "IPV4LL error: no address: %s",
402 r = address_new_dynamic(&ll_addr);
404 log_error_link(link, "Could not allocate address: %s", strerror(-r));
408 ll_addr->family = AF_INET;
409 ll_addr->in_addr.in = addr;
410 ll_addr->prefixlen = 16;
411 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
412 ll_addr->scope = RT_SCOPE_LINK;
414 r = address_configure(ll_addr, link, &address_handler);
416 log_warning_link(link,
417 "could not set addresses: %s", strerror(-r));
418 link_enter_failed(link);
422 link->addr_messages ++;
426 if (link->dhcp_lease) {
427 _cleanup_address_free_ Address *address = NULL;
429 struct in_addr netmask;
432 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
434 log_warning_link(link, "DHCP error: no address: %s",
439 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
441 log_warning_link(link, "DHCP error: no netmask: %s",
446 prefixlen = net_netmask_to_prefixlen(&netmask);
448 r = address_new_dynamic(&address);
450 log_error_link(link, "Could not allocate address: %s",
455 address->family = AF_INET;
456 address->in_addr.in = addr;
457 address->prefixlen = prefixlen;
458 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
460 r = address_configure(address, link, &address_handler);
462 log_warning_link(link,
463 "could not set addresses: %s", strerror(-r));
464 link_enter_failed(link);
468 link->addr_messages ++;
474 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
475 Link *link = userdata;
480 assert(link->ifname);
482 if (link->state == LINK_STATE_FAILED)
485 r = sd_rtnl_message_get_errno(m);
486 if (r < 0 && r != -ENOENT)
487 log_struct_link(LOG_WARNING, link,
488 "MESSAGE=%s: could not update address: %s",
489 link->ifname, strerror(-r),
496 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
497 Link *link = userdata;
502 assert(link->ifname);
504 if (link->state == LINK_STATE_FAILED)
507 r = sd_rtnl_message_get_errno(m);
508 if (r < 0 && r != -ENOENT)
509 log_struct_link(LOG_WARNING, link,
510 "MESSAGE=%s: could not drop address: %s",
511 link->ifname, strerror(-r),
518 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
521 r = sd_bus_message_get_errno(m);
523 log_warning("Could not set hostname: %s", strerror(-r));
528 static int set_hostname(sd_bus *bus, const char *hostname) {
529 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
534 log_debug("Setting transient hostname: '%s'", hostname);
536 if (!bus) { /* TODO: replace by assert when we can rely on kdbus */
537 log_info("Not connected to system bus, ignoring transient hostname.");
541 r = sd_bus_message_new_method_call(
544 "org.freedesktop.hostname1",
545 "/org/freedesktop/hostname1",
546 "org.freedesktop.hostname1",
551 r = sd_bus_message_append(m, "sb", hostname, false);
555 r = sd_bus_call_async(bus, m, set_hostname_handler, NULL, 0, NULL);
557 log_error("Could not set transient hostname: %s", strerror(-r));
562 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
563 Link *link = userdata;
568 assert(link->ifname);
570 if (link->state == LINK_STATE_FAILED)
573 r = sd_rtnl_message_get_errno(m);
575 log_struct_link(LOG_WARNING, link,
576 "MESSAGE=%s: could not set MTU: %s",
577 link->ifname, strerror(-r),
584 static int link_set_mtu(Link *link, uint32_t mtu) {
585 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
589 assert(link->manager);
590 assert(link->manager->rtnl);
592 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
594 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
595 RTM_SETLINK, link->ifindex);
597 log_error_link(link, "Could not allocate RTM_SETLINK message");
601 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
603 log_error_link(link, "Could not append MTU: %s", strerror(-r));
607 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
610 "Could not send rtnetlink message: %s", strerror(-r));
617 static int dhcp_lease_lost(Link *link) {
618 _cleanup_address_free_ Address *address = NULL;
619 _cleanup_route_free_ Route *route_gw = NULL;
620 _cleanup_route_free_ Route *route = NULL;
622 struct in_addr netmask;
623 struct in_addr gateway;
628 assert(link->dhcp_lease);
630 log_warning_link(link, "DHCP lease lost");
632 r = address_new_dynamic(&address);
634 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
635 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
636 sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
637 prefixlen = net_netmask_to_prefixlen(&netmask);
639 r = route_new_dynamic(&route_gw);
641 route_gw->family = AF_INET;
642 route_gw->dst_addr.in = gateway;
643 route_gw->dst_prefixlen = 32;
644 route_gw->scope = RT_SCOPE_LINK;
646 route_drop(route_gw, link, &route_drop_handler);
649 r = route_new_dynamic(&route);
651 route->family = AF_INET;
652 route->in_addr.in = gateway;
654 route_drop(route, link, &route_drop_handler);
657 address->family = AF_INET;
658 address->in_addr.in = addr;
659 address->prefixlen = prefixlen;
661 address_drop(address, link, &address_drop_handler);
664 if (link->network->dhcp_mtu) {
667 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
668 if (r >= 0 && link->original_mtu != mtu) {
669 r = link_set_mtu(link, link->original_mtu);
671 log_warning_link(link, "DHCP error: could not reset MTU");
672 link_enter_failed(link);
678 if (link->network->dhcp_hostname) {
679 const char *hostname = NULL;
681 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
682 if (r >= 0 && hostname) {
683 r = set_hostname(link->manager->bus, "");
685 log_error("Failed to reset transient hostname");
689 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
694 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
695 sd_dhcp_lease *lease;
696 struct in_addr address;
697 struct in_addr netmask;
698 struct in_addr gateway;
700 struct in_addr *nameservers;
701 size_t nameservers_size;
707 r = sd_dhcp_client_get_lease(client, &lease);
709 log_warning_link(link, "DHCP error: no lease: %s",
714 r = sd_dhcp_lease_get_address(lease, &address);
716 log_warning_link(link, "DHCP error: no address: %s",
721 r = sd_dhcp_lease_get_netmask(lease, &netmask);
723 log_warning_link(link, "DHCP error: no netmask: %s",
728 prefixlen = net_netmask_to_prefixlen(&netmask);
730 r = sd_dhcp_lease_get_router(lease, &gateway);
732 log_warning_link(link, "DHCP error: no router: %s",
737 log_struct_link(LOG_INFO, link,
738 "MESSAGE=%s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
740 ADDRESS_FMT_VAL(address),
742 ADDRESS_FMT_VAL(gateway),
743 "ADDRESS=%u.%u.%u.%u",
744 ADDRESS_FMT_VAL(address),
747 "GATEWAY=%u.%u.%u.%u",
748 ADDRESS_FMT_VAL(gateway),
751 link->dhcp_lease = lease;
753 if (link->network->dhcp_dns) {
754 r = sd_dhcp_lease_get_dns(lease, &nameservers, &nameservers_size);
756 r = manager_update_resolv_conf(link->manager);
758 log_error("Failed to update resolv.conf");
762 if (link->network->dhcp_mtu) {
765 r = sd_dhcp_lease_get_mtu(lease, &mtu);
767 r = link_set_mtu(link, mtu);
769 log_error_link(link, "Failed to set MTU "
774 if (link->network->dhcp_hostname) {
775 const char *hostname;
777 r = sd_dhcp_lease_get_hostname(lease, &hostname);
779 r = set_hostname(link->manager->bus, hostname);
781 log_error("Failed to set transient hostname "
782 "to '%s'", hostname);
786 link_enter_set_addresses(link);
791 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
792 Link *link = userdata;
796 assert(link->network);
797 assert(link->manager);
799 if (link->state == LINK_STATE_FAILED)
803 case DHCP_EVENT_NO_LEASE:
804 log_debug_link(link, "IP address in use.");
806 case DHCP_EVENT_EXPIRED:
807 case DHCP_EVENT_STOP:
808 case DHCP_EVENT_IP_CHANGE:
809 if (link->network->dhcp_critical) {
810 log_error_link(link, "DHCPv4 connection considered system critical, "
811 "ignoring request to reconfigure it.");
815 if (link->dhcp_lease) {
816 r = dhcp_lease_lost(link);
818 link_enter_failed(link);
823 if (event == DHCP_EVENT_IP_CHANGE) {
824 r = dhcp_lease_acquired(client, link);
826 link_enter_failed(link);
831 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
832 if (!sd_ipv4ll_is_running(link->ipv4ll))
833 r = sd_ipv4ll_start(link->ipv4ll);
834 else if (ipv4ll_is_bound(link->ipv4ll))
835 r = ipv4ll_address_update(link, false);
837 link_enter_failed(link);
843 case DHCP_EVENT_IP_ACQUIRE:
844 r = dhcp_lease_acquired(client, link);
846 link_enter_failed(link);
850 if (ipv4ll_is_bound(link->ipv4ll))
851 r = ipv4ll_address_update(link, true);
853 r = sd_ipv4ll_stop(link->ipv4ll);
855 link_enter_failed(link);
862 log_warning_link(link, "DHCP error: %s", strerror(-event));
864 log_warning_link(link, "DHCP unknown event: %d", event);
871 static int ipv4ll_address_update(Link *link, bool deprecate) {
877 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
879 _cleanup_address_free_ Address *address = NULL;
881 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
882 deprecate ? "deprecate" : "approve",
883 ADDRESS_FMT_VAL(addr));
885 r = address_new_dynamic(&address);
887 log_error_link(link, "Could not allocate address: %s", strerror(-r));
891 address->family = AF_INET;
892 address->in_addr.in = addr;
893 address->prefixlen = 16;
894 address->scope = RT_SCOPE_LINK;
895 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
896 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
898 address_update(address, link, &address_update_handler);
905 static int ipv4ll_address_lost(Link *link) {
911 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
913 _cleanup_address_free_ Address *address = NULL;
914 _cleanup_route_free_ Route *route = NULL;
916 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
917 ADDRESS_FMT_VAL(addr));
919 r = address_new_dynamic(&address);
921 log_error_link(link, "Could not allocate address: %s", strerror(-r));
925 address->family = AF_INET;
926 address->in_addr.in = addr;
927 address->prefixlen = 16;
928 address->scope = RT_SCOPE_LINK;
930 address_drop(address, link, &address_drop_handler);
932 r = route_new_dynamic(&route);
934 log_error_link(link, "Could not allocate route: %s",
939 route->family = AF_INET;
940 route->scope = RT_SCOPE_LINK;
943 route_drop(route, link, &route_drop_handler);
949 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
955 r = sd_ipv4ll_get_address(ll, &addr);
961 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
962 struct in_addr address;
968 r = sd_ipv4ll_get_address(ll, &address);
972 log_struct_link(LOG_INFO, link,
973 "MESSAGE=%s: IPv4 link-local address %u.%u.%u.%u",
975 ADDRESS_FMT_VAL(address),
978 link_enter_set_addresses(link);
983 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
984 Link *link = userdata;
988 assert(link->network);
989 assert(link->manager);
992 case IPV4LL_EVENT_STOP:
993 case IPV4LL_EVENT_CONFLICT:
994 r = ipv4ll_address_lost(link);
996 link_enter_failed(link);
1000 case IPV4LL_EVENT_BIND:
1001 r = ipv4ll_address_claimed(ll, link);
1003 link_enter_failed(link);
1009 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1011 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1016 static int link_acquire_conf(Link *link) {
1020 assert(link->network);
1021 assert(link->manager);
1022 assert(link->manager->event);
1024 if (link->network->ipv4ll) {
1025 assert(link->ipv4ll);
1027 log_debug_link(link, "acquiring IPv4 link-local address");
1029 r = sd_ipv4ll_start(link->ipv4ll);
1034 if (link->network->dhcp) {
1035 assert(link->dhcp_client);
1037 log_debug_link(link, "acquiring DHCPv4 lease");
1039 r = sd_dhcp_client_start(link->dhcp_client);
1047 static int link_update_flags(Link *link, unsigned flags) {
1048 unsigned flags_added, flags_removed, generic_flags;
1049 bool carrier_gained, carrier_lost;
1054 if (link->state == LINK_STATE_FAILED)
1057 if (link->flags == flags)
1060 flags_added = (link->flags ^ flags) & flags;
1061 flags_removed = (link->flags ^ flags) & link->flags;
1062 generic_flags = ~(IFF_UP | IFF_LOWER_UP | IFF_DORMANT | IFF_DEBUG |
1063 IFF_MULTICAST | IFF_BROADCAST | IFF_PROMISC |
1064 IFF_NOARP | IFF_MASTER | IFF_SLAVE);
1066 /* consider link to have carrier when LOWER_UP and !DORMANT
1068 TODO: use proper operstates once we start supporting 802.1X
1070 see Documentation/networking/operstates.txt in the kernel sources
1072 carrier_gained = (((flags_added & IFF_LOWER_UP) && !(flags & IFF_DORMANT)) ||
1073 ((flags_removed & IFF_DORMANT) && (flags & IFF_LOWER_UP)));
1074 carrier_lost = ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT)) &&
1075 ((flags_removed & IFF_LOWER_UP) || (flags_added & IFF_DORMANT));
1077 link->flags = flags;
1080 /* not currently managing this link
1081 we track state changes, but don't log them
1082 they will be logged if and when a network is
1086 if (flags_added & IFF_UP)
1087 log_info_link(link, "link is up");
1088 else if (flags_removed & IFF_UP)
1089 log_info_link(link, "link is down");
1091 if (flags_added & IFF_LOWER_UP)
1092 log_debug_link(link, "link is lower up");
1093 else if (flags_removed & IFF_LOWER_UP)
1094 log_debug_link(link, "link is lower down");
1096 if (flags_added & IFF_DORMANT)
1097 log_debug_link(link, "link is dormant");
1098 else if (flags_removed & IFF_DORMANT)
1099 log_debug_link(link, "link is not dormant");
1101 if (flags_added & IFF_DEBUG)
1102 log_debug_link(link, "debugging enabled in the kernel");
1103 else if (flags_removed & IFF_DEBUG)
1104 log_debug_link(link, "debugging disabled in the kernel");
1106 if (flags_added & IFF_MULTICAST)
1107 log_debug_link(link, "multicast enabled");
1108 else if (flags_removed & IFF_MULTICAST)
1109 log_debug_link(link, "multicast disabled");
1111 if (flags_added & IFF_BROADCAST)
1112 log_debug_link(link, "broadcast enabled");
1113 else if (flags_removed & IFF_BROADCAST)
1114 log_debug_link(link, "broadcast disabled");
1116 if (flags_added & IFF_PROMISC)
1117 log_debug_link(link, "promiscuous mode enabled");
1118 else if (flags_removed & IFF_PROMISC)
1119 log_debug_link(link, "promiscuous mode disabled");
1121 if (flags_added & IFF_NOARP)
1122 log_debug_link(link, "ARP protocol disabled");
1123 else if (flags_removed & IFF_NOARP)
1124 log_debug_link(link, "ARP protocol enabled");
1126 if (flags_added & IFF_MASTER)
1127 log_debug_link(link, "link is master");
1128 else if (flags_removed & IFF_MASTER)
1129 log_debug_link(link, "link is no longer master");
1131 if (flags_added & IFF_SLAVE)
1132 log_debug_link(link, "link is slave");
1133 else if (flags_removed & IFF_SLAVE)
1134 log_debug_link(link, "link is no longer slave");
1136 /* link flags are currently at most 18 bits, let's default to printing 20 */
1137 if (flags_added & generic_flags)
1138 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1139 flags_added & generic_flags);
1141 if (flags_removed & generic_flags)
1142 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1143 flags_removed & generic_flags);
1145 if (carrier_gained) {
1146 log_info_link(link, "gained carrier");
1148 if (link->network->dhcp || link->network->ipv4ll) {
1149 r = link_acquire_conf(link);
1151 log_warning_link(link, "Could not acquire configuration: %s", strerror(-r));
1152 link_enter_failed(link);
1156 } else if (carrier_lost) {
1157 log_info_link(link, "lost carrier");
1159 if (link->network->dhcp) {
1160 r = sd_dhcp_client_stop(link->dhcp_client);
1162 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
1163 link_enter_failed(link);
1168 if (link->network->ipv4ll) {
1169 r = sd_ipv4ll_stop(link->ipv4ll);
1171 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
1172 link_enter_failed(link);
1181 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1182 Link *link = userdata;
1187 if (link->state == LINK_STATE_FAILED)
1190 r = sd_rtnl_message_get_errno(m);
1192 link_update_flags(link, link->flags | IFF_UP);
1194 log_struct_link(LOG_WARNING, link,
1195 "MESSAGE=%s: could not bring up interface: %s",
1196 link->ifname, strerror(-r),
1202 static int link_up(Link *link) {
1203 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1207 assert(link->manager);
1208 assert(link->manager->rtnl);
1210 log_debug_link(link, "bringing link up");
1212 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1213 RTM_SETLINK, link->ifindex);
1215 log_error_link(link, "Could not allocate RTM_SETLINK message");
1219 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1221 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1225 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1227 log_error_link(link,
1228 "Could not send rtnetlink message: %s", strerror(-r));
1235 static int link_enslaved(Link *link) {
1239 assert(link->state == LINK_STATE_ENSLAVING);
1240 assert(link->network);
1242 if (!(link->flags & IFF_UP)) {
1245 link_enter_failed(link);
1250 if (!link->network->dhcp && !link->network->ipv4ll)
1251 return link_enter_set_addresses(link);
1256 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1257 Link *link = userdata;
1261 assert(link->state == LINK_STATE_ENSLAVING || link->state == LINK_STATE_FAILED);
1262 assert(link->network);
1266 if (link->state == LINK_STATE_FAILED)
1269 r = sd_rtnl_message_get_errno(m);
1271 log_struct_link(LOG_ERR, link,
1272 "MESSAGE=%s: could not enslave: %s",
1273 link->ifname, strerror(-r),
1276 link_enter_failed(link);
1280 log_debug_link(link, "enslaved");
1282 if (link->enslaving == 0)
1283 link_enslaved(link);
1288 static int link_enter_enslave(Link *link) {
1289 NetDev *vlan, *macvlan;
1294 assert(link->network);
1295 assert(link->state == LINK_STATE_INITIALIZING);
1297 link->state = LINK_STATE_ENSLAVING;
1301 if (!link->network->bridge && !link->network->bond &&
1302 hashmap_isempty(link->network->vlans) &&
1303 hashmap_isempty(link->network->macvlans))
1304 return link_enslaved(link);
1306 if (link->network->bridge) {
1307 log_struct_link(LOG_DEBUG, link,
1308 "MESSAGE=%s: enslaving by '%s'",
1309 link->ifname, link->network->bridge->name,
1310 NETDEV(link->network->bridge),
1313 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1315 log_struct_link(LOG_WARNING, link,
1316 "MESSAGE=%s: could not enslave by '%s': %s",
1317 link->ifname, link->network->bridge->name, strerror(-r),
1318 NETDEV(link->network->bridge),
1320 link_enter_failed(link);
1327 if (link->network->bond) {
1328 log_struct_link(LOG_DEBUG, link,
1329 "MESSAGE=%s: enslaving by '%s'",
1330 link->ifname, link->network->bond->name,
1331 NETDEV(link->network->bond),
1334 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1336 log_struct_link(LOG_WARNING, link,
1337 "MESSAGE=%s: could not enslave by '%s': %s",
1338 link->ifname, link->network->bond->name, strerror(-r),
1339 NETDEV(link->network->bond),
1341 link_enter_failed(link);
1348 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1349 log_struct_link(LOG_DEBUG, link,
1350 "MESSAGE=%s: enslaving by '%s'",
1351 link->ifname, vlan->name, NETDEV(vlan), NULL);
1353 r = netdev_enslave(vlan, link, &enslave_handler);
1355 log_struct_link(LOG_WARNING, link,
1356 "MESSAGE=%s: could not enslave by '%s': %s",
1357 link->ifname, vlan->name, strerror(-r),
1358 NETDEV(vlan), NULL);
1359 link_enter_failed(link);
1366 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1367 log_struct_link(LOG_DEBUG, link,
1368 "MESSAGE=%s: enslaving by '%s'",
1369 link->ifname, macvlan->name, NETDEV(macvlan), NULL);
1371 r = netdev_enslave(macvlan, link, &enslave_handler);
1373 log_struct_link(LOG_WARNING, link,
1374 "MESSAGE=%s: could not enslave by '%s': %s",
1375 link->ifname, macvlan->name, strerror(-r),
1376 NETDEV(macvlan), NULL);
1377 link_enter_failed(link);
1387 static int link_configure(Link *link) {
1391 assert(link->state == LINK_STATE_INITIALIZING);
1393 if (link->network->ipv4ll) {
1395 r = sd_ipv4ll_new(&link->ipv4ll);
1399 if (link->udev_device) {
1400 r = net_get_unique_predictable_data(link->udev_device, seed);
1402 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1408 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1412 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1416 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1420 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1425 if (link->network->dhcp) {
1426 r = sd_dhcp_client_new(&link->dhcp_client);
1430 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1434 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1438 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1442 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1446 if (link->network->dhcp_mtu) {
1447 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1453 return link_enter_enslave(link);
1456 int link_initialized(Link *link, struct udev_device *device) {
1462 assert(link->ifname);
1463 assert(link->manager);
1465 if (link->state != LINK_STATE_INITIALIZING)
1469 link->udev_device = udev_device_ref(device);
1471 log_debug_link(link, "link initialized");
1473 r = network_get(link->manager, device, link->ifname, &link->mac, &network);
1475 return r == -ENOENT ? 0 : r;
1477 r = network_apply(link->manager, network, link);
1481 r = link_configure(link);
1485 /* re-trigger all state updates */
1486 flags = link->flags;
1488 r = link_update_flags(link, flags);
1495 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1497 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1498 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1505 r = link_new(m, message, ret);
1511 log_info_link(link, "link added");
1513 if (detect_container(NULL) <= 0) {
1514 /* not in a container, udev will be around */
1515 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
1516 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1518 log_warning_link(link, "could not find udev device");
1522 if (udev_device_get_is_initialized(device) <= 0)
1527 r = link_initialized(link, device);
1534 int link_update(Link *link, sd_rtnl_message *m) {
1536 struct ether_addr mac;
1541 assert(link->ifname);
1544 if (link->state == LINK_STATE_FAILED)
1547 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1548 if (r >= 0 && !streq(ifname, link->ifname)) {
1549 log_info_link(link, "renamed to %s", ifname);
1552 link->ifname = strdup(ifname);
1557 if (!link->original_mtu) {
1558 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
1560 log_debug_link(link, "saved original MTU: %"
1561 PRIu16, link->original_mtu);
1564 /* The kernel may broadcast NEWLINK messages without the MAC address
1565 set, simply ignore them. */
1566 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1568 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
1570 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
1572 log_debug_link(link, "MAC address: "
1573 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1574 mac.ether_addr_octet[0],
1575 mac.ether_addr_octet[1],
1576 mac.ether_addr_octet[2],
1577 mac.ether_addr_octet[3],
1578 mac.ether_addr_octet[4],
1579 mac.ether_addr_octet[5]);
1582 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1584 log_warning_link(link, "Could not update MAC "
1585 "address in IPv4LL client: %s",
1591 if (link->dhcp_client) {
1592 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1594 log_warning_link(link, "Could not update MAC "
1595 "address in DHCP client: %s",
1603 r = sd_rtnl_message_link_get_flags(m, &flags);
1605 log_warning_link(link, "Could not get link flags");
1609 return link_update_flags(link, flags);
1612 int link_save(Link *link) {
1613 _cleanup_free_ char *temp_path = NULL;
1614 _cleanup_fclose_ FILE *f = NULL;
1619 assert(link->state_file);
1621 state = link_state_to_string(link->state);
1624 r = fopen_temporary(link->state_file, &f, &temp_path);
1628 fchmod(fileno(f), 0644);
1631 "# This is private data. Do not parse.\n"
1632 "STATE=%s\n", state);
1634 if (link->dhcp_lease) {
1635 _cleanup_free_ char *lease_file = NULL;
1637 r = asprintf(&lease_file, "/run/systemd/network/leases/%"PRIu64,
1642 r = dhcp_lease_save(link->dhcp_lease, lease_file);
1646 fprintf(f, "DHCP_LEASE=%s\n", lease_file);
1651 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
1653 unlink(link->state_file);
1659 log_error("Failed to save link data %s: %s", link->state_file, strerror(-r));
1664 static const char* const link_state_table[_LINK_STATE_MAX] = {
1665 [LINK_STATE_INITIALIZING] = "configuring",
1666 [LINK_STATE_ENSLAVING] = "configuring",
1667 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1668 [LINK_STATE_SETTING_ROUTES] = "configuring",
1669 [LINK_STATE_CONFIGURED] = "configured",
1670 [LINK_STATE_FAILED] = "failed",
1673 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);