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_unmanaged(Link *link) {
147 log_info_link(link, "unmanaged");
149 link->state = LINK_STATE_UNMANAGED;
154 static void link_enter_failed(Link *link) {
157 log_warning_link(link, "failed");
159 link->state = LINK_STATE_FAILED;
164 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
165 Link *link = userdata;
168 assert(link->route_messages > 0);
169 assert(link->state == LINK_STATE_SETTING_ADDRESSES ||
170 link->state == LINK_STATE_SETTING_ROUTES ||
171 link->state == LINK_STATE_FAILED);
173 link->route_messages --;
175 if (link->state == LINK_STATE_FAILED)
178 r = sd_rtnl_message_get_errno(m);
179 if (r < 0 && r != -EEXIST)
180 log_struct_link(LOG_WARNING, link,
181 "MESSAGE=%s: could not set route: %s",
182 link->ifname, strerror(-r),
186 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
188 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
189 log_debug_link(link, "routes set");
190 link_enter_configured(link);
196 static int link_enter_set_routes(Link *link) {
201 assert(link->network);
202 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
204 link->state = LINK_STATE_SETTING_ROUTES;
206 if (!link->network->static_routes && !link->dhcp_lease &&
207 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
208 return link_enter_configured(link);
210 log_debug_link(link, "setting routes");
212 LIST_FOREACH(static_routes, rt, link->network->static_routes) {
213 r = route_configure(rt, link, &route_handler);
215 log_warning_link(link,
216 "could not set routes: %s", strerror(-r));
217 link_enter_failed(link);
221 link->route_messages ++;
224 if (link->ipv4ll && !link->dhcp_lease) {
225 _cleanup_route_free_ Route *route = NULL;
228 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
229 if (r < 0 && r != -ENOENT) {
230 log_warning_link(link, "IPV4LL error: no address: %s",
236 r = route_new_dynamic(&route);
238 log_error_link(link, "Could not allocate route: %s",
243 route->family = AF_INET;
244 route->scope = RT_SCOPE_LINK;
247 r = route_configure(route, link, &route_handler);
249 log_warning_link(link,
250 "could not set routes: %s", strerror(-r));
251 link_enter_failed(link);
255 link->route_messages ++;
259 if (link->dhcp_lease) {
260 _cleanup_route_free_ Route *route = NULL;
261 _cleanup_route_free_ Route *route_gw = NULL;
262 struct in_addr gateway;
264 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
266 log_warning_link(link, "DHCP error: no router: %s",
271 r = route_new_dynamic(&route);
273 log_error_link(link, "Could not allocate route: %s",
278 r = route_new_dynamic(&route_gw);
280 log_error_link(link, "Could not allocate route: %s",
285 /* The dhcp netmask may mask out the gateway. Add an explicit
286 * route for the gw host so that we can route no matter the
287 * netmask or existing kernel route tables. */
288 route_gw->family = AF_INET;
289 route_gw->dst_addr.in = gateway;
290 route_gw->dst_prefixlen = 32;
291 route_gw->scope = RT_SCOPE_LINK;
293 r = route_configure(route_gw, link, &route_handler);
295 log_warning_link(link,
296 "could not set host route: %s", strerror(-r));
300 link->route_messages ++;
302 route->family = AF_INET;
303 route->in_addr.in = gateway;
305 r = route_configure(route, link, &route_handler);
307 log_warning_link(link,
308 "could not set routes: %s", strerror(-r));
309 link_enter_failed(link);
313 link->route_messages ++;
319 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
320 Link *link = userdata;
325 assert(link->ifname);
327 if (link->state == LINK_STATE_FAILED)
330 r = sd_rtnl_message_get_errno(m);
331 if (r < 0 && r != -ENOENT)
332 log_struct_link(LOG_WARNING, link,
333 "MESSAGE=%s: could not drop route: %s",
334 link->ifname, strerror(-r),
341 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
342 Link *link = userdata;
347 assert(link->ifname);
348 assert(link->addr_messages > 0);
349 assert(link->state == LINK_STATE_SETTING_ADDRESSES || link->state == LINK_STATE_FAILED);
351 link->addr_messages --;
353 if (link->state == LINK_STATE_FAILED)
356 r = sd_rtnl_message_get_errno(m);
357 if (r < 0 && r != -EEXIST)
358 log_struct_link(LOG_WARNING, link,
359 "MESSAGE=%s: could not set address: %s",
360 link->ifname, strerror(-r),
364 if (link->addr_messages == 0) {
365 log_debug_link(link, "addresses set");
366 link_enter_set_routes(link);
372 static int link_enter_set_addresses(Link *link) {
377 assert(link->network);
378 assert(link->state != _LINK_STATE_INVALID);
380 link->state = LINK_STATE_SETTING_ADDRESSES;
382 if (!link->network->static_addresses && !link->dhcp_lease &&
383 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
384 return link_enter_set_routes(link);
386 log_debug_link(link, "setting addresses");
388 LIST_FOREACH(static_addresses, ad, link->network->static_addresses) {
389 r = address_configure(ad, link, &address_handler);
391 log_warning_link(link,
392 "could not set addresses: %s", strerror(-r));
393 link_enter_failed(link);
397 link->addr_messages ++;
400 if (link->ipv4ll && !link->dhcp_lease) {
401 _cleanup_address_free_ Address *ll_addr = NULL;
404 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
405 if (r < 0 && r != -ENOENT) {
406 log_warning_link(link, "IPV4LL error: no address: %s",
412 r = address_new_dynamic(&ll_addr);
414 log_error_link(link, "Could not allocate address: %s", strerror(-r));
418 ll_addr->family = AF_INET;
419 ll_addr->in_addr.in = addr;
420 ll_addr->prefixlen = 16;
421 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
422 ll_addr->scope = RT_SCOPE_LINK;
424 r = address_configure(ll_addr, link, &address_handler);
426 log_warning_link(link,
427 "could not set addresses: %s", strerror(-r));
428 link_enter_failed(link);
432 link->addr_messages ++;
436 if (link->dhcp_lease) {
437 _cleanup_address_free_ Address *address = NULL;
439 struct in_addr netmask;
442 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
444 log_warning_link(link, "DHCP error: no address: %s",
449 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
451 log_warning_link(link, "DHCP error: no netmask: %s",
456 prefixlen = net_netmask_to_prefixlen(&netmask);
458 r = address_new_dynamic(&address);
460 log_error_link(link, "Could not allocate address: %s",
465 address->family = AF_INET;
466 address->in_addr.in = addr;
467 address->prefixlen = prefixlen;
468 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
470 r = address_configure(address, link, &address_handler);
472 log_warning_link(link,
473 "could not set addresses: %s", strerror(-r));
474 link_enter_failed(link);
478 link->addr_messages ++;
484 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
485 Link *link = userdata;
490 assert(link->ifname);
492 if (link->state == LINK_STATE_FAILED)
495 r = sd_rtnl_message_get_errno(m);
496 if (r < 0 && r != -ENOENT)
497 log_struct_link(LOG_WARNING, link,
498 "MESSAGE=%s: could not update address: %s",
499 link->ifname, strerror(-r),
506 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
507 Link *link = userdata;
512 assert(link->ifname);
514 if (link->state == LINK_STATE_FAILED)
517 r = sd_rtnl_message_get_errno(m);
518 if (r < 0 && r != -ENOENT)
519 log_struct_link(LOG_WARNING, link,
520 "MESSAGE=%s: could not drop address: %s",
521 link->ifname, strerror(-r),
528 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
531 r = sd_bus_message_get_errno(m);
533 log_warning("Could not set hostname: %s", strerror(-r));
538 static int set_hostname(sd_bus *bus, const char *hostname) {
539 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
544 log_debug("Setting transient hostname: '%s'", hostname);
546 if (!bus) { /* TODO: replace by assert when we can rely on kdbus */
547 log_info("Not connected to system bus, ignoring transient hostname.");
551 r = sd_bus_message_new_method_call(
554 "org.freedesktop.hostname1",
555 "/org/freedesktop/hostname1",
556 "org.freedesktop.hostname1",
561 r = sd_bus_message_append(m, "sb", hostname, false);
565 r = sd_bus_call_async(bus, m, set_hostname_handler, NULL, 0, NULL);
567 log_error("Could not set transient hostname: %s", strerror(-r));
572 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
573 Link *link = userdata;
578 assert(link->ifname);
580 if (link->state == LINK_STATE_FAILED)
583 r = sd_rtnl_message_get_errno(m);
585 log_struct_link(LOG_WARNING, link,
586 "MESSAGE=%s: could not set MTU: %s",
587 link->ifname, strerror(-r),
594 static int link_set_mtu(Link *link, uint32_t mtu) {
595 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
599 assert(link->manager);
600 assert(link->manager->rtnl);
602 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
604 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
605 RTM_SETLINK, link->ifindex);
607 log_error_link(link, "Could not allocate RTM_SETLINK message");
611 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
613 log_error_link(link, "Could not append MTU: %s", strerror(-r));
617 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
620 "Could not send rtnetlink message: %s", strerror(-r));
627 static int dhcp_lease_lost(Link *link) {
628 _cleanup_address_free_ Address *address = NULL;
629 _cleanup_route_free_ Route *route_gw = NULL;
630 _cleanup_route_free_ Route *route = NULL;
632 struct in_addr netmask;
633 struct in_addr gateway;
638 assert(link->dhcp_lease);
640 log_warning_link(link, "DHCP lease lost");
642 r = address_new_dynamic(&address);
644 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
645 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
646 sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
647 prefixlen = net_netmask_to_prefixlen(&netmask);
649 r = route_new_dynamic(&route_gw);
651 route_gw->family = AF_INET;
652 route_gw->dst_addr.in = gateway;
653 route_gw->dst_prefixlen = 32;
654 route_gw->scope = RT_SCOPE_LINK;
656 route_drop(route_gw, link, &route_drop_handler);
659 r = route_new_dynamic(&route);
661 route->family = AF_INET;
662 route->in_addr.in = gateway;
664 route_drop(route, link, &route_drop_handler);
667 address->family = AF_INET;
668 address->in_addr.in = addr;
669 address->prefixlen = prefixlen;
671 address_drop(address, link, &address_drop_handler);
674 if (link->network->dhcp_mtu) {
677 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
678 if (r >= 0 && link->original_mtu != mtu) {
679 r = link_set_mtu(link, link->original_mtu);
681 log_warning_link(link, "DHCP error: could not reset MTU");
682 link_enter_failed(link);
688 if (link->network->dhcp_hostname) {
689 const char *hostname = NULL;
691 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
692 if (r >= 0 && hostname) {
693 r = set_hostname(link->manager->bus, "");
695 log_error("Failed to reset transient hostname");
699 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
704 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
705 sd_dhcp_lease *lease;
706 struct in_addr address;
707 struct in_addr netmask;
708 struct in_addr gateway;
710 struct in_addr *nameservers;
711 size_t nameservers_size;
717 r = sd_dhcp_client_get_lease(client, &lease);
719 log_warning_link(link, "DHCP error: no lease: %s",
724 r = sd_dhcp_lease_get_address(lease, &address);
726 log_warning_link(link, "DHCP error: no address: %s",
731 r = sd_dhcp_lease_get_netmask(lease, &netmask);
733 log_warning_link(link, "DHCP error: no netmask: %s",
738 prefixlen = net_netmask_to_prefixlen(&netmask);
740 r = sd_dhcp_lease_get_router(lease, &gateway);
742 log_warning_link(link, "DHCP error: no router: %s",
747 log_struct_link(LOG_INFO, link,
748 "MESSAGE=%s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
750 ADDRESS_FMT_VAL(address),
752 ADDRESS_FMT_VAL(gateway),
753 "ADDRESS=%u.%u.%u.%u",
754 ADDRESS_FMT_VAL(address),
757 "GATEWAY=%u.%u.%u.%u",
758 ADDRESS_FMT_VAL(gateway),
761 link->dhcp_lease = lease;
763 if (link->network->dhcp_dns) {
764 r = sd_dhcp_lease_get_dns(lease, &nameservers, &nameservers_size);
766 r = manager_update_resolv_conf(link->manager);
768 log_error("Failed to update resolv.conf");
772 if (link->network->dhcp_mtu) {
775 r = sd_dhcp_lease_get_mtu(lease, &mtu);
777 r = link_set_mtu(link, mtu);
779 log_error_link(link, "Failed to set MTU "
784 if (link->network->dhcp_hostname) {
785 const char *hostname;
787 r = sd_dhcp_lease_get_hostname(lease, &hostname);
789 r = set_hostname(link->manager->bus, hostname);
791 log_error("Failed to set transient hostname "
792 "to '%s'", hostname);
796 link_enter_set_addresses(link);
801 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
802 Link *link = userdata;
806 assert(link->network);
807 assert(link->manager);
809 if (link->state == LINK_STATE_FAILED)
813 case DHCP_EVENT_NO_LEASE:
814 log_debug_link(link, "IP address in use.");
816 case DHCP_EVENT_EXPIRED:
817 case DHCP_EVENT_STOP:
818 case DHCP_EVENT_IP_CHANGE:
819 if (link->network->dhcp_critical) {
820 log_error_link(link, "DHCPv4 connection considered system critical, "
821 "ignoring request to reconfigure it.");
825 if (link->dhcp_lease) {
826 r = dhcp_lease_lost(link);
828 link_enter_failed(link);
833 if (event == DHCP_EVENT_IP_CHANGE) {
834 r = dhcp_lease_acquired(client, link);
836 link_enter_failed(link);
841 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
842 if (!sd_ipv4ll_is_running(link->ipv4ll))
843 r = sd_ipv4ll_start(link->ipv4ll);
844 else if (ipv4ll_is_bound(link->ipv4ll))
845 r = ipv4ll_address_update(link, false);
847 link_enter_failed(link);
853 case DHCP_EVENT_IP_ACQUIRE:
854 r = dhcp_lease_acquired(client, link);
856 link_enter_failed(link);
860 if (ipv4ll_is_bound(link->ipv4ll))
861 r = ipv4ll_address_update(link, true);
863 r = sd_ipv4ll_stop(link->ipv4ll);
865 link_enter_failed(link);
872 log_warning_link(link, "DHCP error: %s", strerror(-event));
874 log_warning_link(link, "DHCP unknown event: %d", event);
881 static int ipv4ll_address_update(Link *link, bool deprecate) {
887 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
889 _cleanup_address_free_ Address *address = NULL;
891 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
892 deprecate ? "deprecate" : "approve",
893 ADDRESS_FMT_VAL(addr));
895 r = address_new_dynamic(&address);
897 log_error_link(link, "Could not allocate address: %s", strerror(-r));
901 address->family = AF_INET;
902 address->in_addr.in = addr;
903 address->prefixlen = 16;
904 address->scope = RT_SCOPE_LINK;
905 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
906 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
908 address_update(address, link, &address_update_handler);
915 static int ipv4ll_address_lost(Link *link) {
921 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
923 _cleanup_address_free_ Address *address = NULL;
924 _cleanup_route_free_ Route *route = NULL;
926 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
927 ADDRESS_FMT_VAL(addr));
929 r = address_new_dynamic(&address);
931 log_error_link(link, "Could not allocate address: %s", strerror(-r));
935 address->family = AF_INET;
936 address->in_addr.in = addr;
937 address->prefixlen = 16;
938 address->scope = RT_SCOPE_LINK;
940 address_drop(address, link, &address_drop_handler);
942 r = route_new_dynamic(&route);
944 log_error_link(link, "Could not allocate route: %s",
949 route->family = AF_INET;
950 route->scope = RT_SCOPE_LINK;
953 route_drop(route, link, &route_drop_handler);
959 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
965 r = sd_ipv4ll_get_address(ll, &addr);
971 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
972 struct in_addr address;
978 r = sd_ipv4ll_get_address(ll, &address);
982 log_struct_link(LOG_INFO, link,
983 "MESSAGE=%s: IPv4 link-local address %u.%u.%u.%u",
985 ADDRESS_FMT_VAL(address),
988 link_enter_set_addresses(link);
993 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
994 Link *link = userdata;
998 assert(link->network);
999 assert(link->manager);
1002 case IPV4LL_EVENT_STOP:
1003 case IPV4LL_EVENT_CONFLICT:
1004 r = ipv4ll_address_lost(link);
1006 link_enter_failed(link);
1010 case IPV4LL_EVENT_BIND:
1011 r = ipv4ll_address_claimed(ll, link);
1013 link_enter_failed(link);
1019 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1021 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1026 static int link_acquire_conf(Link *link) {
1030 assert(link->network);
1031 assert(link->manager);
1032 assert(link->manager->event);
1034 if (link->network->ipv4ll) {
1035 assert(link->ipv4ll);
1037 log_debug_link(link, "acquiring IPv4 link-local address");
1039 r = sd_ipv4ll_start(link->ipv4ll);
1044 if (link->network->dhcp) {
1045 assert(link->dhcp_client);
1047 log_debug_link(link, "acquiring DHCPv4 lease");
1049 r = sd_dhcp_client_start(link->dhcp_client);
1057 static int link_update_flags(Link *link, unsigned flags) {
1058 unsigned flags_added, flags_removed, generic_flags;
1059 bool carrier_gained, carrier_lost;
1064 if (link->state == LINK_STATE_FAILED)
1067 if (link->flags == flags)
1070 flags_added = (link->flags ^ flags) & flags;
1071 flags_removed = (link->flags ^ flags) & link->flags;
1072 generic_flags = ~(IFF_UP | IFF_LOWER_UP | IFF_DORMANT | IFF_DEBUG |
1073 IFF_MULTICAST | IFF_BROADCAST | IFF_PROMISC |
1074 IFF_NOARP | IFF_MASTER | IFF_SLAVE);
1076 /* consider link to have carrier when LOWER_UP and !DORMANT
1078 TODO: use proper operstates once we start supporting 802.1X
1080 see Documentation/networking/operstates.txt in the kernel sources
1082 carrier_gained = (((flags_added & IFF_LOWER_UP) && !(flags & IFF_DORMANT)) ||
1083 ((flags_removed & IFF_DORMANT) && (flags & IFF_LOWER_UP)));
1084 carrier_lost = ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT)) &&
1085 ((flags_removed & IFF_LOWER_UP) || (flags_added & IFF_DORMANT));
1087 link->flags = flags;
1090 /* not currently managing this link
1091 we track state changes, but don't log them
1092 they will be logged if and when a network is
1096 if (flags_added & IFF_UP)
1097 log_info_link(link, "link is up");
1098 else if (flags_removed & IFF_UP)
1099 log_info_link(link, "link is down");
1101 if (flags_added & IFF_LOWER_UP)
1102 log_debug_link(link, "link is lower up");
1103 else if (flags_removed & IFF_LOWER_UP)
1104 log_debug_link(link, "link is lower down");
1106 if (flags_added & IFF_DORMANT)
1107 log_debug_link(link, "link is dormant");
1108 else if (flags_removed & IFF_DORMANT)
1109 log_debug_link(link, "link is not dormant");
1111 if (flags_added & IFF_DEBUG)
1112 log_debug_link(link, "debugging enabled in the kernel");
1113 else if (flags_removed & IFF_DEBUG)
1114 log_debug_link(link, "debugging disabled in the kernel");
1116 if (flags_added & IFF_MULTICAST)
1117 log_debug_link(link, "multicast enabled");
1118 else if (flags_removed & IFF_MULTICAST)
1119 log_debug_link(link, "multicast disabled");
1121 if (flags_added & IFF_BROADCAST)
1122 log_debug_link(link, "broadcast enabled");
1123 else if (flags_removed & IFF_BROADCAST)
1124 log_debug_link(link, "broadcast disabled");
1126 if (flags_added & IFF_PROMISC)
1127 log_debug_link(link, "promiscuous mode enabled");
1128 else if (flags_removed & IFF_PROMISC)
1129 log_debug_link(link, "promiscuous mode disabled");
1131 if (flags_added & IFF_NOARP)
1132 log_debug_link(link, "ARP protocol disabled");
1133 else if (flags_removed & IFF_NOARP)
1134 log_debug_link(link, "ARP protocol enabled");
1136 if (flags_added & IFF_MASTER)
1137 log_debug_link(link, "link is master");
1138 else if (flags_removed & IFF_MASTER)
1139 log_debug_link(link, "link is no longer master");
1141 if (flags_added & IFF_SLAVE)
1142 log_debug_link(link, "link is slave");
1143 else if (flags_removed & IFF_SLAVE)
1144 log_debug_link(link, "link is no longer slave");
1146 /* link flags are currently at most 18 bits, let's default to printing 20 */
1147 if (flags_added & generic_flags)
1148 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1149 flags_added & generic_flags);
1151 if (flags_removed & generic_flags)
1152 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1153 flags_removed & generic_flags);
1155 if (carrier_gained) {
1156 log_info_link(link, "gained carrier");
1158 if (link->network->dhcp || link->network->ipv4ll) {
1159 r = link_acquire_conf(link);
1161 log_warning_link(link, "Could not acquire configuration: %s", strerror(-r));
1162 link_enter_failed(link);
1166 } else if (carrier_lost) {
1167 log_info_link(link, "lost carrier");
1169 if (link->network->dhcp) {
1170 r = sd_dhcp_client_stop(link->dhcp_client);
1172 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
1173 link_enter_failed(link);
1178 if (link->network->ipv4ll) {
1179 r = sd_ipv4ll_stop(link->ipv4ll);
1181 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
1182 link_enter_failed(link);
1191 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1192 Link *link = userdata;
1197 if (link->state == LINK_STATE_FAILED)
1200 r = sd_rtnl_message_get_errno(m);
1202 link_update_flags(link, link->flags | IFF_UP);
1204 log_struct_link(LOG_WARNING, link,
1205 "MESSAGE=%s: could not bring up interface: %s",
1206 link->ifname, strerror(-r),
1212 static int link_up(Link *link) {
1213 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1217 assert(link->manager);
1218 assert(link->manager->rtnl);
1220 log_debug_link(link, "bringing link up");
1222 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1223 RTM_SETLINK, link->ifindex);
1225 log_error_link(link, "Could not allocate RTM_SETLINK message");
1229 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1231 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1235 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1237 log_error_link(link,
1238 "Could not send rtnetlink message: %s", strerror(-r));
1245 static int link_enslaved(Link *link) {
1249 assert(link->state == LINK_STATE_ENSLAVING);
1250 assert(link->network);
1252 if (!(link->flags & IFF_UP)) {
1255 link_enter_failed(link);
1260 if (!link->network->dhcp && !link->network->ipv4ll)
1261 return link_enter_set_addresses(link);
1266 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1267 Link *link = userdata;
1271 assert(link->state == LINK_STATE_ENSLAVING || link->state == LINK_STATE_FAILED);
1272 assert(link->network);
1276 if (link->state == LINK_STATE_FAILED)
1279 r = sd_rtnl_message_get_errno(m);
1281 log_struct_link(LOG_ERR, link,
1282 "MESSAGE=%s: could not enslave: %s",
1283 link->ifname, strerror(-r),
1286 link_enter_failed(link);
1290 log_debug_link(link, "enslaved");
1292 if (link->enslaving == 0)
1293 link_enslaved(link);
1298 static int link_enter_enslave(Link *link) {
1299 NetDev *vlan, *macvlan;
1304 assert(link->network);
1305 assert(link->state == LINK_STATE_INITIALIZING);
1307 link->state = LINK_STATE_ENSLAVING;
1311 if (!link->network->bridge && !link->network->bond &&
1312 hashmap_isempty(link->network->vlans) &&
1313 hashmap_isempty(link->network->macvlans))
1314 return link_enslaved(link);
1316 if (link->network->bridge) {
1317 log_struct_link(LOG_DEBUG, link,
1318 "MESSAGE=%s: enslaving by '%s'",
1319 link->ifname, link->network->bridge->name,
1320 NETDEV(link->network->bridge),
1323 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1325 log_struct_link(LOG_WARNING, link,
1326 "MESSAGE=%s: could not enslave by '%s': %s",
1327 link->ifname, link->network->bridge->name, strerror(-r),
1328 NETDEV(link->network->bridge),
1330 link_enter_failed(link);
1337 if (link->network->bond) {
1338 log_struct_link(LOG_DEBUG, link,
1339 "MESSAGE=%s: enslaving by '%s'",
1340 link->ifname, link->network->bond->name,
1341 NETDEV(link->network->bond),
1344 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1346 log_struct_link(LOG_WARNING, link,
1347 "MESSAGE=%s: could not enslave by '%s': %s",
1348 link->ifname, link->network->bond->name, strerror(-r),
1349 NETDEV(link->network->bond),
1351 link_enter_failed(link);
1358 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1359 log_struct_link(LOG_DEBUG, link,
1360 "MESSAGE=%s: enslaving by '%s'",
1361 link->ifname, vlan->name, NETDEV(vlan), NULL);
1363 r = netdev_enslave(vlan, link, &enslave_handler);
1365 log_struct_link(LOG_WARNING, link,
1366 "MESSAGE=%s: could not enslave by '%s': %s",
1367 link->ifname, vlan->name, strerror(-r),
1368 NETDEV(vlan), NULL);
1369 link_enter_failed(link);
1376 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1377 log_struct_link(LOG_DEBUG, link,
1378 "MESSAGE=%s: enslaving by '%s'",
1379 link->ifname, macvlan->name, NETDEV(macvlan), NULL);
1381 r = netdev_enslave(macvlan, link, &enslave_handler);
1383 log_struct_link(LOG_WARNING, link,
1384 "MESSAGE=%s: could not enslave by '%s': %s",
1385 link->ifname, macvlan->name, strerror(-r),
1386 NETDEV(macvlan), NULL);
1387 link_enter_failed(link);
1397 static int link_configure(Link *link) {
1401 assert(link->state == LINK_STATE_INITIALIZING);
1403 if (link->network->ipv4ll) {
1405 r = sd_ipv4ll_new(&link->ipv4ll);
1409 if (link->udev_device) {
1410 r = net_get_unique_predictable_data(link->udev_device, seed);
1412 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1418 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1422 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1426 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1430 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1435 if (link->network->dhcp) {
1436 r = sd_dhcp_client_new(&link->dhcp_client);
1440 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1444 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1448 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1452 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1456 if (link->network->dhcp_mtu) {
1457 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1463 return link_enter_enslave(link);
1466 int link_initialized(Link *link, struct udev_device *device) {
1472 assert(link->ifname);
1473 assert(link->manager);
1475 if (link->state != LINK_STATE_INITIALIZING)
1479 link->udev_device = udev_device_ref(device);
1481 log_debug_link(link, "link initialized");
1483 r = network_get(link->manager, device, link->ifname, &link->mac, &network);
1485 link_enter_unmanaged(link);
1490 r = network_apply(link->manager, network, link);
1494 r = link_configure(link);
1498 /* re-trigger all state updates */
1499 flags = link->flags;
1501 r = link_update_flags(link, flags);
1508 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1510 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1511 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1518 r = link_new(m, message, ret);
1524 log_info_link(link, "link added");
1526 if (detect_container(NULL) <= 0) {
1527 /* not in a container, udev will be around */
1528 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
1529 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1531 log_warning_link(link, "could not find udev device");
1535 if (udev_device_get_is_initialized(device) <= 0)
1540 r = link_initialized(link, device);
1547 int link_update(Link *link, sd_rtnl_message *m) {
1549 struct ether_addr mac;
1554 assert(link->ifname);
1557 if (link->state == LINK_STATE_FAILED || link->state == LINK_STATE_UNMANAGED)
1560 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1561 if (r >= 0 && !streq(ifname, link->ifname)) {
1562 log_info_link(link, "renamed to %s", ifname);
1565 link->ifname = strdup(ifname);
1570 if (!link->original_mtu) {
1571 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
1573 log_debug_link(link, "saved original MTU: %"
1574 PRIu16, link->original_mtu);
1577 /* The kernel may broadcast NEWLINK messages without the MAC address
1578 set, simply ignore them. */
1579 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1581 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
1583 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
1585 log_debug_link(link, "MAC address: "
1586 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1587 mac.ether_addr_octet[0],
1588 mac.ether_addr_octet[1],
1589 mac.ether_addr_octet[2],
1590 mac.ether_addr_octet[3],
1591 mac.ether_addr_octet[4],
1592 mac.ether_addr_octet[5]);
1595 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1597 log_warning_link(link, "Could not update MAC "
1598 "address in IPv4LL client: %s",
1604 if (link->dhcp_client) {
1605 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1607 log_warning_link(link, "Could not update MAC "
1608 "address in DHCP client: %s",
1616 r = sd_rtnl_message_link_get_flags(m, &flags);
1618 log_warning_link(link, "Could not get link flags");
1622 return link_update_flags(link, flags);
1625 int link_save(Link *link) {
1626 _cleanup_free_ char *temp_path = NULL;
1627 _cleanup_fclose_ FILE *f = NULL;
1632 assert(link->state_file);
1634 state = link_state_to_string(link->state);
1637 r = fopen_temporary(link->state_file, &f, &temp_path);
1641 fchmod(fileno(f), 0644);
1644 "# This is private data. Do not parse.\n"
1645 "STATE=%s\n", state);
1647 if (link->dhcp_lease) {
1648 _cleanup_free_ char *lease_file = NULL;
1650 r = asprintf(&lease_file, "/run/systemd/network/leases/%"PRIu64,
1655 r = dhcp_lease_save(link->dhcp_lease, lease_file);
1659 fprintf(f, "DHCP_LEASE=%s\n", lease_file);
1664 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
1666 unlink(link->state_file);
1672 log_error("Failed to save link data %s: %s", link->state_file, strerror(-r));
1677 static const char* const link_state_table[_LINK_STATE_MAX] = {
1678 [LINK_STATE_INITIALIZING] = "configuring",
1679 [LINK_STATE_ENSLAVING] = "configuring",
1680 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1681 [LINK_STATE_SETTING_ROUTES] = "configuring",
1682 [LINK_STATE_CONFIGURED] = "configured",
1683 [LINK_STATE_UNMANAGED] = "unmanaged",
1684 [LINK_STATE_FAILED] = "failed",
1687 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);