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>
27 #include "networkd-netdev.h"
28 #include "libudev-private.h"
29 #include "udev-util.h"
33 #include "network-internal.h"
34 #include "conf-parser.h"
36 #include "network-util.h"
37 #include "dhcp-lease-internal.h"
39 static int ipv4ll_address_update(Link *link, bool deprecate);
40 static bool ipv4ll_is_bound(sd_ipv4ll *ll);
42 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
43 _cleanup_link_unref_ Link *link = NULL;
52 r = sd_rtnl_message_get_type(message, &type);
55 else if (type != RTM_NEWLINK)
58 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
61 else if (ifindex <= 0)
64 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
73 link->manager = manager;
74 link->state = LINK_STATE_INITIALIZING;
75 link->ifindex = ifindex;
76 link->ifname = strdup(ifname);
80 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
82 log_debug_link(link, "MAC address not found for new device, continuing without");
84 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d", link->ifindex);
88 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d", link->ifindex);
92 r = hashmap_ensure_allocated(&manager->links, NULL, NULL);
96 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
106 static void link_free(Link *link) {
112 while ((address = link->addresses)) {
113 LIST_REMOVE(addresses, link->addresses, address);
114 address_free(address);
117 while ((address = link->pool_addresses)) {
118 LIST_REMOVE(addresses, link->pool_addresses, address);
119 address_free(address);
122 sd_dhcp_client_unref(link->dhcp_client);
123 sd_dhcp_lease_unref(link->dhcp_lease);
125 unlink(link->lease_file);
126 free(link->lease_file);
128 sd_ipv4ll_unref(link->ipv4ll);
129 sd_dhcp6_client_unref(link->dhcp6_client);
130 sd_icmp6_nd_unref(link->icmp6_router_discovery);
133 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
137 unlink(link->state_file);
138 free(link->state_file);
140 udev_device_unref(link->udev_device);
145 Link *link_unref(Link *link) {
146 if (link && (-- link->n_ref <= 0))
152 Link *link_ref(Link *link) {
154 assert_se(++ link->n_ref >= 2);
159 int link_get(Manager *m, int ifindex, Link **ret) {
166 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
175 void link_drop(Link *link) {
176 if (!link || link->state == LINK_STATE_LINGER)
179 link->state = LINK_STATE_LINGER;
181 log_debug_link(link, "link removed");
188 static void link_enter_unmanaged(Link *link) {
191 log_debug_link(link, "unmanaged");
193 link->state = LINK_STATE_UNMANAGED;
198 static int link_stop_clients(Link *link) {
202 assert(link->manager);
203 assert(link->manager->event);
208 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
209 assert(link->dhcp_client);
211 k = sd_dhcp_client_stop(link->dhcp_client);
213 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
218 if (link->network->ipv4ll) {
219 assert(link->ipv4ll);
221 k = sd_ipv4ll_stop(link->ipv4ll);
223 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
228 if (link->network->dhcp_server) {
229 assert(link->dhcp_server);
231 k = sd_dhcp_server_stop(link->dhcp_server);
233 log_warning_link(link, "Could not stop DHCPv4 server: %s", strerror(-r));
238 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
239 assert(link->icmp6_router_discovery);
241 if (link->dhcp6_client) {
242 k = sd_dhcp6_client_stop(link->dhcp6_client);
244 log_warning_link(link, "Could not stop DHCPv6 client: %s", strerror(-r));
249 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
251 log_warning_link(link, "Could not stop ICMPv6 router discovery: %s", strerror(-r));
259 static void link_enter_failed(Link *link) {
262 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
265 log_warning_link(link, "failed");
267 link->state = LINK_STATE_FAILED;
269 link_stop_clients(link);
274 static Address* link_find_dhcp_server_address(Link *link) {
278 assert(link->network);
280 /* The the first statically configured address if there is any */
281 LIST_FOREACH(addresses, address, link->network->static_addresses) {
283 if (address->family != AF_INET)
286 if (in_addr_is_null(address->family, &address->in_addr))
292 /* If that didn't work, find a suitable address we got from the pool */
293 LIST_FOREACH(addresses, address, link->pool_addresses) {
294 if (address->family != AF_INET)
303 static int link_enter_configured(Link *link) {
307 assert(link->network);
308 assert(link->state == LINK_STATE_SETTING_ROUTES);
310 if (link->network->dhcp_server &&
311 !sd_dhcp_server_is_running(link->dhcp_server)) {
312 struct in_addr pool_start;
315 address = link_find_dhcp_server_address(link);
317 log_warning_link(link, "Failed to find suitable address for DHCPv4 server instance.");
318 link_enter_failed(link);
322 log_debug_link(link, "offering DHCPv4 leases");
324 r = sd_dhcp_server_set_address(link->dhcp_server, &address->in_addr.in);
328 /* offer 32 addresses starting from the address following the server address */
329 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
330 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
336 r = sd_dhcp_server_set_router(link->dhcp_server,
337 &main_address->in_addr.in);
341 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
342 main_address->prefixlen);
347 r = sd_dhcp_server_start(link->dhcp_server);
349 log_warning_link(link, "could not start DHCPv4 server "
350 "instance: %s", strerror(-r));
352 link_enter_failed(link);
358 log_info_link(link, "link configured");
360 link->state = LINK_STATE_CONFIGURED;
367 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
368 _cleanup_link_unref_ Link *link = userdata;
371 assert(link->route_messages > 0);
372 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
373 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
376 link->route_messages --;
378 if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER))
381 r = sd_rtnl_message_get_errno(m);
382 if (r < 0 && r != -EEXIST)
383 log_struct_link(LOG_WARNING, link,
384 "MESSAGE=%-*s: could not set route: %s",
386 link->ifname, strerror(-r),
390 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
392 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
393 log_debug_link(link, "routes set");
394 link_enter_configured(link);
400 static int link_set_dhcp_routes(Link *link) {
401 struct sd_dhcp_route *static_routes;
406 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes);
409 log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-n));
413 for (i = 0; i < n; i++) {
414 _cleanup_route_free_ Route *route = NULL;
416 r = route_new_dynamic(&route, RTPROT_DHCP);
418 log_error_link(link, "Could not allocate route: %s",
423 route->family = AF_INET;
424 route->in_addr.in = static_routes[i].gw_addr;
425 route->dst_addr.in = static_routes[i].dst_addr;
426 route->dst_prefixlen = static_routes[i].dst_prefixlen;
427 route->metrics = DHCP_ROUTE_METRIC;
429 r = route_configure(route, link, &route_handler);
431 log_warning_link(link,
432 "could not set host route: %s", strerror(-r));
436 link->route_messages ++;
442 static int link_enter_set_routes(Link *link) {
447 assert(link->network);
448 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
450 link->state = LINK_STATE_SETTING_ROUTES;
452 if (!link->network->static_routes && !link->dhcp_lease &&
453 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
454 return link_enter_configured(link);
456 log_debug_link(link, "setting routes");
458 LIST_FOREACH(routes, rt, link->network->static_routes) {
459 r = route_configure(rt, link, &route_handler);
461 log_warning_link(link,
462 "could not set routes: %s", strerror(-r));
463 link_enter_failed(link);
467 link->route_messages ++;
470 if (link->ipv4ll && !link->dhcp_lease) {
471 _cleanup_route_free_ Route *route = NULL;
474 r = route_new_dynamic(&route, RTPROT_STATIC);
476 log_error_link(link, "Could not allocate route: %s",
481 route->family = AF_INET;
482 route->scope = RT_SCOPE_LINK;
483 route->metrics = IPV4LL_ROUTE_METRIC;
485 r = route_configure(route, link, &route_handler);
487 log_warning_link(link,
488 "could not set routes: %s", strerror(-r));
489 link_enter_failed(link);
493 link->route_messages ++;
497 if (link->dhcp_lease) {
498 _cleanup_route_free_ Route *route = NULL;
499 _cleanup_route_free_ Route *route_gw = NULL;
500 struct in_addr gateway;
502 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
503 if (r < 0 && r != -ENOENT) {
504 log_warning_link(link, "DHCP error: could not get gateway: %s",
510 r = route_new_dynamic(&route, RTPROT_DHCP);
512 log_error_link(link, "Could not allocate route: %s",
517 r = route_new_dynamic(&route_gw, RTPROT_DHCP);
519 log_error_link(link, "Could not allocate route: %s",
524 /* The dhcp netmask may mask out the gateway. Add an explicit
525 * route for the gw host so that we can route no matter the
526 * netmask or existing kernel route tables. */
527 route_gw->family = AF_INET;
528 route_gw->dst_addr.in = gateway;
529 route_gw->dst_prefixlen = 32;
530 route_gw->scope = RT_SCOPE_LINK;
531 route_gw->metrics = DHCP_ROUTE_METRIC;
533 r = route_configure(route_gw, link, &route_handler);
535 log_warning_link(link,
536 "could not set host route: %s", strerror(-r));
540 link->route_messages ++;
542 route->family = AF_INET;
543 route->in_addr.in = gateway;
544 route->metrics = DHCP_ROUTE_METRIC;
546 r = route_configure(route, link, &route_handler);
548 log_warning_link(link,
549 "could not set routes: %s", strerror(-r));
550 link_enter_failed(link);
554 link->route_messages ++;
557 if (link->network->dhcp_routes)
558 link_set_dhcp_routes(link);
561 if (link->route_messages == 0) {
562 link_enter_configured(link);
568 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
569 _cleanup_link_unref_ Link *link = userdata;
574 assert(link->ifname);
576 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
579 r = sd_rtnl_message_get_errno(m);
580 if (r < 0 && r != -ESRCH)
581 log_struct_link(LOG_WARNING, link,
582 "MESSAGE=%-*s: could not drop route: %s",
584 link->ifname, strerror(-r),
591 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
592 _cleanup_link_unref_ Link *link = userdata;
598 assert(link->manager);
600 for (; m; m = sd_rtnl_message_next(m)) {
601 r = sd_rtnl_message_get_errno(m);
603 log_debug_link(link, "getting address failed: %s", strerror(-r));
607 r = link_rtnl_process_address(rtnl, m, link->manager);
609 log_warning_link(link, "could not process address: %s", strerror(-r));
615 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
616 _cleanup_link_unref_ Link *link = userdata;
622 assert(link->ifname);
623 assert(link->addr_messages > 0);
624 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
625 LINK_STATE_FAILED, LINK_STATE_LINGER));
627 link->addr_messages --;
629 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
632 r = sd_rtnl_message_get_errno(m);
633 if (r < 0 && r != -EEXIST)
634 log_struct_link(LOG_WARNING, link,
635 "MESSAGE=%-*s: could not set address: %s",
637 link->ifname, strerror(-r),
641 /* calling handler directly so take a ref */
643 link_get_address_handler(rtnl, m, link);
646 if (link->addr_messages == 0) {
647 log_debug_link(link, "addresses set");
648 link_enter_set_routes(link);
654 static int link_enter_set_addresses(Link *link) {
657 uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
660 assert(link->network);
661 assert(link->state != _LINK_STATE_INVALID);
663 link->state = LINK_STATE_SETTING_ADDRESSES;
665 if (!link->network->static_addresses && !link->dhcp_lease &&
666 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
667 return link_enter_set_routes(link);
669 log_debug_link(link, "setting addresses");
671 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
672 r = address_configure(ad, link, &address_handler);
674 log_warning_link(link,
675 "could not set addresses: %s", strerror(-r));
676 link_enter_failed(link);
680 link->addr_messages ++;
683 if (link->ipv4ll && !link->dhcp_lease) {
684 _cleanup_address_free_ Address *ll_addr = NULL;
687 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
688 if (r < 0 && r != -ENOENT) {
689 log_warning_link(link, "IPV4LL error: no address: %s",
695 r = address_new_dynamic(&ll_addr);
697 log_error_link(link, "Could not allocate address: %s", strerror(-r));
701 ll_addr->family = AF_INET;
702 ll_addr->in_addr.in = addr;
703 ll_addr->prefixlen = 16;
704 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
705 ll_addr->scope = RT_SCOPE_LINK;
707 r = address_configure(ll_addr, link, &address_handler);
709 log_warning_link(link,
710 "could not set addresses: %s", strerror(-r));
711 link_enter_failed(link);
715 link->addr_messages ++;
719 if (link->dhcp_lease) {
720 _cleanup_address_free_ Address *address = NULL;
722 struct in_addr netmask;
725 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
727 log_warning_link(link, "DHCP error: no address: %s",
732 if (!link->network->dhcp_critical) {
733 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
736 log_warning_link(link, "DHCP error: no lifetime: %s",
742 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
744 log_warning_link(link, "DHCP error: no netmask: %s",
749 prefixlen = net_netmask_to_prefixlen(&netmask);
751 r = address_new_dynamic(&address);
753 log_error_link(link, "Could not allocate address: %s",
758 address->family = AF_INET;
759 address->in_addr.in = addr;
760 address->cinfo.ifa_prefered = lifetime;
761 address->cinfo.ifa_valid = lifetime;
762 address->prefixlen = prefixlen;
763 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
765 /* use update rather than configure so that we will update the lifetime
766 of an existing address if it has already been configured */
767 r = address_update(address, link, &address_handler);
769 log_warning_link(link,
770 "could not set addresses: %s", strerror(-r));
771 link_enter_failed(link);
775 link->addr_messages ++;
781 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
782 _cleanup_link_unref_ Link *link = userdata;
787 assert(link->ifname);
789 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
792 r = sd_rtnl_message_get_errno(m);
793 if (r < 0 && r != -ENOENT)
794 log_struct_link(LOG_WARNING, link,
795 "MESSAGE=%-*s: could not update address: %s",
797 link->ifname, strerror(-r),
804 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
805 _cleanup_link_unref_ Link *link = userdata;
810 assert(link->ifname);
812 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
815 r = sd_rtnl_message_get_errno(m);
816 if (r < 0 && r != -EADDRNOTAVAIL)
817 log_struct_link(LOG_WARNING, link,
818 "MESSAGE=%-*s: could not drop address: %s",
820 link->ifname, strerror(-r),
827 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
828 _cleanup_link_unref_ Link *link = userdata;
833 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
836 r = sd_bus_message_get_errno(m);
840 log_warning_link(link, "Could not set hostname: %s", strerror(r));
845 static int link_set_hostname(Link *link, const char *hostname) {
846 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
850 assert(link->manager);
853 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
855 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
856 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
860 r = sd_bus_message_new_method_call(
863 "org.freedesktop.hostname1",
864 "/org/freedesktop/hostname1",
865 "org.freedesktop.hostname1",
870 r = sd_bus_message_append(m, "sb", hostname, false);
874 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
876 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
885 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
886 _cleanup_link_unref_ Link *link = userdata;
891 assert(link->ifname);
893 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
896 r = sd_rtnl_message_get_errno(m);
898 log_struct_link(LOG_WARNING, link,
899 "MESSAGE=%-*s: could not set MTU: %s",
900 IFNAMSIZ, link->ifname, strerror(-r),
907 static int link_set_mtu(Link *link, uint32_t mtu) {
908 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
912 assert(link->manager);
913 assert(link->manager->rtnl);
915 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
917 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
918 RTM_SETLINK, link->ifindex);
920 log_error_link(link, "Could not allocate RTM_SETLINK message");
924 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
926 log_error_link(link, "Could not append MTU: %s", strerror(-r));
930 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
933 "Could not send rtnetlink message: %s", strerror(-r));
942 static int dhcp_lease_lost(Link *link) {
943 _cleanup_address_free_ Address *address = NULL;
945 struct in_addr netmask;
946 struct in_addr gateway;
951 assert(link->dhcp_lease);
953 log_warning_link(link, "DHCP lease lost");
955 if (link->network->dhcp_routes) {
956 struct sd_dhcp_route *routes;
959 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes);
961 for (i = 0; i < n; i++) {
962 _cleanup_route_free_ Route *route = NULL;
964 r = route_new_dynamic(&route, RTPROT_UNSPEC);
966 route->family = AF_INET;
967 route->in_addr.in = routes[i].gw_addr;
968 route->dst_addr.in = routes[i].dst_addr;
969 route->dst_prefixlen = routes[i].dst_prefixlen;
971 route_drop(route, link, &route_drop_handler);
977 r = address_new_dynamic(&address);
979 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
981 _cleanup_route_free_ Route *route_gw = NULL;
982 _cleanup_route_free_ Route *route = NULL;
984 r = route_new_dynamic(&route_gw, RTPROT_UNSPEC);
986 route_gw->family = AF_INET;
987 route_gw->dst_addr.in = gateway;
988 route_gw->dst_prefixlen = 32;
989 route_gw->scope = RT_SCOPE_LINK;
991 route_drop(route_gw, link, &route_drop_handler);
994 r = route_new_dynamic(&route, RTPROT_UNSPEC);
996 route->family = AF_INET;
997 route->in_addr.in = gateway;
999 route_drop(route, link, &route_drop_handler);
1003 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
1004 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
1005 prefixlen = net_netmask_to_prefixlen(&netmask);
1007 address->family = AF_INET;
1008 address->in_addr.in = addr;
1009 address->prefixlen = prefixlen;
1011 address_drop(address, link, &address_drop_handler);
1014 if (link->network->dhcp_mtu) {
1017 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1018 if (r >= 0 && link->original_mtu != mtu) {
1019 r = link_set_mtu(link, link->original_mtu);
1021 log_warning_link(link, "DHCP error: could not reset MTU");
1022 link_enter_failed(link);
1028 if (link->network->dhcp_hostname) {
1029 const char *hostname = NULL;
1031 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1032 if (r >= 0 && hostname) {
1033 r = link_set_hostname(link, "");
1035 log_error_link(link, "Failed to reset transient hostname");
1039 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1044 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1045 sd_dhcp_lease *lease;
1048 r = sd_dhcp_client_get_lease(client, &lease);
1050 log_warning_link(link, "DHCP error: no lease %s",
1055 sd_dhcp_lease_unref(link->dhcp_lease);
1056 link->dhcp_lease = lease;
1058 link_enter_set_addresses(link);
1063 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1064 sd_dhcp_lease *lease;
1065 struct in_addr address;
1066 struct in_addr netmask;
1067 struct in_addr gateway;
1074 r = sd_dhcp_client_get_lease(client, &lease);
1076 log_warning_link(link, "DHCP error: no lease: %s",
1081 r = sd_dhcp_lease_get_address(lease, &address);
1083 log_warning_link(link, "DHCP error: no address: %s",
1088 r = sd_dhcp_lease_get_netmask(lease, &netmask);
1090 log_warning_link(link, "DHCP error: no netmask: %s",
1095 prefixlen = net_netmask_to_prefixlen(&netmask);
1097 r = sd_dhcp_lease_get_router(lease, &gateway);
1098 if (r < 0 && r != -ENOENT) {
1099 log_warning_link(link, "DHCP error: could not get gateway: %s",
1105 log_struct_link(LOG_INFO, link,
1106 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1109 ADDRESS_FMT_VAL(address),
1111 ADDRESS_FMT_VAL(gateway),
1112 "ADDRESS=%u.%u.%u.%u",
1113 ADDRESS_FMT_VAL(address),
1116 "GATEWAY=%u.%u.%u.%u",
1117 ADDRESS_FMT_VAL(gateway),
1120 log_struct_link(LOG_INFO, link,
1121 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1124 ADDRESS_FMT_VAL(address),
1126 "ADDRESS=%u.%u.%u.%u",
1127 ADDRESS_FMT_VAL(address),
1132 link->dhcp_lease = lease;
1134 if (link->network->dhcp_mtu) {
1137 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1139 r = link_set_mtu(link, mtu);
1141 log_error_link(link, "Failed to set MTU "
1142 "to %" PRIu16, mtu);
1146 if (link->network->dhcp_hostname) {
1147 const char *hostname;
1149 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1151 r = link_set_hostname(link, hostname);
1153 log_error_link(link, "Failed to set transient hostname "
1154 "to '%s'", hostname);
1158 link_enter_set_addresses(link);
1163 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1164 Link *link = userdata;
1168 assert(link->network);
1169 assert(link->manager);
1171 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1175 case DHCP_EVENT_EXPIRED:
1176 case DHCP_EVENT_STOP:
1177 case DHCP_EVENT_IP_CHANGE:
1178 if (link->network->dhcp_critical) {
1179 log_error_link(link, "DHCPv4 connection considered system critical, "
1180 "ignoring request to reconfigure it.");
1184 if (link->dhcp_lease) {
1185 r = dhcp_lease_lost(link);
1187 link_enter_failed(link);
1192 if (event == DHCP_EVENT_IP_CHANGE) {
1193 r = dhcp_lease_acquired(client, link);
1195 link_enter_failed(link);
1200 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1201 if (!sd_ipv4ll_is_running(link->ipv4ll))
1202 r = sd_ipv4ll_start(link->ipv4ll);
1203 else if (ipv4ll_is_bound(link->ipv4ll))
1204 r = ipv4ll_address_update(link, false);
1206 link_enter_failed(link);
1212 case DHCP_EVENT_RENEW:
1213 r = dhcp_lease_renew(client, link);
1215 link_enter_failed(link);
1219 case DHCP_EVENT_IP_ACQUIRE:
1220 r = dhcp_lease_acquired(client, link);
1222 link_enter_failed(link);
1226 if (ipv4ll_is_bound(link->ipv4ll))
1227 r = ipv4ll_address_update(link, true);
1229 r = sd_ipv4ll_stop(link->ipv4ll);
1231 link_enter_failed(link);
1238 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1240 log_warning_link(link, "DHCP unknown event: %d", event);
1247 static int ipv4ll_address_update(Link *link, bool deprecate) {
1249 struct in_addr addr;
1253 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1255 _cleanup_address_free_ Address *address = NULL;
1257 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1258 deprecate ? "deprecate" : "approve",
1259 ADDRESS_FMT_VAL(addr));
1261 r = address_new_dynamic(&address);
1263 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1267 address->family = AF_INET;
1268 address->in_addr.in = addr;
1269 address->prefixlen = 16;
1270 address->scope = RT_SCOPE_LINK;
1271 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1272 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1274 address_update(address, link, &address_update_handler);
1281 static int ipv4ll_address_lost(Link *link) {
1283 struct in_addr addr;
1287 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1289 _cleanup_address_free_ Address *address = NULL;
1290 _cleanup_route_free_ Route *route = NULL;
1292 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1293 ADDRESS_FMT_VAL(addr));
1295 r = address_new_dynamic(&address);
1297 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1301 address->family = AF_INET;
1302 address->in_addr.in = addr;
1303 address->prefixlen = 16;
1304 address->scope = RT_SCOPE_LINK;
1306 address_drop(address, link, &address_drop_handler);
1308 r = route_new_dynamic(&route, RTPROT_UNSPEC);
1310 log_error_link(link, "Could not allocate route: %s",
1315 route->family = AF_INET;
1316 route->scope = RT_SCOPE_LINK;
1317 route->metrics = 99;
1319 route_drop(route, link, &route_drop_handler);
1325 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1327 struct in_addr addr;
1331 r = sd_ipv4ll_get_address(ll, &addr);
1337 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1338 struct in_addr address;
1344 r = sd_ipv4ll_get_address(ll, &address);
1348 log_struct_link(LOG_INFO, link,
1349 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1352 ADDRESS_FMT_VAL(address),
1355 link_enter_set_addresses(link);
1360 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1361 Link *link = userdata;
1365 assert(link->network);
1366 assert(link->manager);
1368 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1372 case IPV4LL_EVENT_STOP:
1373 case IPV4LL_EVENT_CONFLICT:
1374 r = ipv4ll_address_lost(link);
1376 link_enter_failed(link);
1380 case IPV4LL_EVENT_BIND:
1381 r = ipv4ll_address_claimed(ll, link);
1383 link_enter_failed(link);
1389 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1391 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1396 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1397 Link *link = userdata;
1400 assert(link->network);
1401 assert(link->manager);
1403 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1407 case DHCP6_EVENT_STOP:
1408 case DHCP6_EVENT_RESEND_EXPIRE:
1409 case DHCP6_EVENT_RETRANS_MAX:
1410 case DHCP6_EVENT_IP_ACQUIRE:
1411 log_debug_link(link, "DHCPv6 event %d", event);
1417 log_warning_link(link, "DHCPv6 error: %s",
1420 log_warning_link(link, "DHCPv6 unknown event: %d",
1426 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1427 Link *link = userdata;
1431 assert(link->network);
1432 assert(link->manager);
1434 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1438 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1439 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1442 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1443 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1448 log_warning_link(link, "ICMPv6 error: %s",
1451 log_warning_link(link, "ICMPv6 unknown event: %d",
1457 if (link->dhcp6_client)
1460 r = sd_dhcp6_client_new(&link->dhcp6_client);
1464 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1466 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1470 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1472 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1476 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1478 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1482 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1485 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1489 r = sd_dhcp6_client_start(link->dhcp6_client);
1491 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1494 static int link_acquire_conf(Link *link) {
1498 assert(link->network);
1499 assert(link->manager);
1500 assert(link->manager->event);
1502 if (link->network->ipv4ll) {
1503 assert(link->ipv4ll);
1505 log_debug_link(link, "acquiring IPv4 link-local address");
1507 r = sd_ipv4ll_start(link->ipv4ll);
1509 log_warning_link(link, "could not acquire IPv4 "
1510 "link-local address");
1515 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1516 assert(link->dhcp_client);
1518 log_debug_link(link, "acquiring DHCPv4 lease");
1520 r = sd_dhcp_client_start(link->dhcp_client);
1522 log_warning_link(link, "could not acquire DHCPv4 "
1528 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1529 assert(link->icmp6_router_discovery);
1531 log_debug_link(link, "discovering IPv6 routers");
1533 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1535 log_warning_link(link, "could not start IPv6 router discovery");
1543 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1544 /* see Documentation/networking/operstates.txt in the kernel sources */
1546 if (operstate == IF_OPER_UP)
1549 if (operstate == IF_OPER_UNKNOWN)
1550 /* operstate may not be implemented, so fall back to flags */
1551 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1557 #define FLAG_STRING(string, flag, old, new) \
1558 (((old ^ new) & flag) \
1559 ? ((old & flag) ? (" -" string) : (" +" string)) \
1562 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1563 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1565 bool carrier_gained = false, carrier_lost = false;
1570 r = sd_rtnl_message_link_get_flags(m, &flags);
1572 log_warning_link(link, "Could not get link flags");
1576 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1578 /* if we got a message without operstate, take it to mean
1579 the state was unchanged */
1580 operstate = link->kernel_operstate;
1582 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1585 if (link->flags != flags) {
1586 log_debug_link(link, "flags change:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
1587 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1588 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1589 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1590 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1591 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1592 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1593 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1594 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1595 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1596 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1597 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1598 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1599 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1600 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1601 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1602 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1603 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1604 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1605 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1607 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1608 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1609 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1610 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1611 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1612 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1613 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1614 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1616 /* link flags are currently at most 18 bits, let's align to printing 20 */
1617 if (unknown_flags_added)
1618 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1619 unknown_flags_added);
1621 if (unknown_flags_removed)
1622 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1623 unknown_flags_removed);
1626 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1627 link_has_carrier(flags, operstate);
1628 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1629 !link_has_carrier(flags, operstate);
1631 link->flags = flags;
1632 link->kernel_operstate = operstate;
1636 if (link->state == LINK_STATE_FAILED ||
1637 link->state == LINK_STATE_UNMANAGED)
1640 if (carrier_gained) {
1641 log_info_link(link, "gained carrier");
1643 if (link->network) {
1644 r = link_acquire_conf(link);
1646 link_enter_failed(link);
1650 } else if (carrier_lost) {
1651 log_info_link(link, "lost carrier");
1653 r = link_stop_clients(link);
1655 link_enter_failed(link);
1663 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1664 _cleanup_link_unref_ Link *link = userdata;
1669 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1672 r = sd_rtnl_message_get_errno(m);
1674 /* we warn but don't fail the link, as it may
1675 be brought up later */
1676 log_struct_link(LOG_WARNING, link,
1677 "MESSAGE=%-*s: could not bring up interface: %s",
1679 link->ifname, strerror(-r),
1687 static int link_up(Link *link) {
1688 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1692 assert(link->manager);
1693 assert(link->manager->rtnl);
1695 log_debug_link(link, "bringing link up");
1697 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1698 RTM_SETLINK, link->ifindex);
1700 log_error_link(link, "Could not allocate RTM_SETLINK message");
1704 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1706 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1710 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1712 log_error_link(link,
1713 "Could not send rtnetlink message: %s", strerror(-r));
1722 static int link_joined(Link *link) {
1726 assert(link->state == LINK_STATE_ENSLAVING);
1727 assert(link->network);
1729 log_debug_link(link, "joined netdev");
1731 if (!(link->flags & IFF_UP)) {
1734 link_enter_failed(link);
1739 return link_enter_set_addresses(link);
1742 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1743 _cleanup_link_unref_ Link *link = userdata;
1747 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1748 LINK_STATE_LINGER));
1749 assert(link->network);
1753 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1756 r = sd_rtnl_message_get_errno(m);
1757 if (r < 0 && r != -EEXIST) {
1758 log_struct_link(LOG_ERR, link,
1759 "MESSAGE=%-*s: could not join netdev: %s",
1761 link->ifname, strerror(-r),
1764 link_enter_failed(link);
1768 if (link->enslaving <= 0)
1774 static int link_enter_join_netdev(Link *link) {
1780 assert(link->network);
1781 assert(link->state == LINK_STATE_INITIALIZING);
1783 link->state = LINK_STATE_ENSLAVING;
1787 if (!link->network->bridge &&
1788 !link->network->bond &&
1789 hashmap_isempty(link->network->stacked_netdevs))
1790 return link_joined(link);
1792 if (link->network->bond) {
1793 log_struct_link(LOG_DEBUG, link,
1794 "MESSAGE=%-*s: enslaving by '%s'",
1796 link->ifname, link->network->bond->ifname,
1797 NETDEVIF(link->network->bond),
1800 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1802 log_struct_link(LOG_WARNING, link,
1803 "MESSAGE=%-*s: could not join netdev '%s': %s",
1805 link->ifname, link->network->bond->ifname, strerror(-r),
1806 NETDEVIF(link->network->bond),
1808 link_enter_failed(link);
1815 if (link->network->bridge) {
1816 log_struct_link(LOG_DEBUG, link,
1817 "MESSAGE=%-*s: enslaving by '%s'",
1819 link->ifname, link->network->bridge->ifname,
1820 NETDEVIF(link->network->bridge),
1823 r = netdev_join(link->network->bridge, link, &netdev_join_handler);
1825 log_struct_link(LOG_WARNING, link,
1826 "MESSAGE=%-*s: could not join netdev '%s': %s",
1828 link->ifname, link->network->bridge->ifname, strerror(-r),
1829 NETDEVIF(link->network->bridge),
1831 link_enter_failed(link);
1838 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1839 log_struct_link(LOG_DEBUG, link,
1840 "MESSAGE=%-*s: enslaving by '%s'",
1842 link->ifname, netdev->ifname, NETDEVIF(netdev), NULL);
1844 r = netdev_join(netdev, link, &netdev_join_handler);
1846 log_struct_link(LOG_WARNING, link,
1847 "MESSAGE=%-*s: could not join netdev '%s': %s",
1849 link->ifname, netdev->ifname, strerror(-r),
1850 NETDEVIF(netdev), NULL);
1851 link_enter_failed(link);
1861 static int link_configure(Link *link) {
1865 assert(link->state == LINK_STATE_INITIALIZING);
1867 if (link->network->ipv4ll) {
1870 r = sd_ipv4ll_new(&link->ipv4ll);
1874 if (link->udev_device) {
1875 r = net_get_unique_predictable_data(link->udev_device, seed);
1877 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1883 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1887 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1891 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1895 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1900 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1901 r = sd_dhcp_client_new(&link->dhcp_client);
1905 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1909 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1913 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1917 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1921 r = sd_dhcp_client_set_request_broadcast(link->dhcp_client, link->network->dhcp_broadcast);
1925 if (link->network->dhcp_mtu) {
1926 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1931 if (link->network->dhcp_routes) {
1932 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
1935 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
1940 if (link->network->dhcp_sendhost) {
1941 _cleanup_free_ char *hostname = gethostname_malloc();
1945 if (!is_localhost(hostname)) {
1946 r = sd_dhcp_client_set_hostname(link->dhcp_client, hostname);
1952 if (link->network->dhcp_vendor_class_identifier) {
1953 r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
1954 link->network->dhcp_vendor_class_identifier);
1960 if (link->network->dhcp_server) {
1961 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1965 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1970 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1971 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1975 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1980 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1985 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1990 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1991 icmp6_router_handler, link);
1996 if (link_has_carrier(link->flags, link->kernel_operstate)) {
1997 r = link_acquire_conf(link);
2002 return link_enter_join_netdev(link);
2005 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2006 _cleanup_link_unref_ Link *link = userdata;
2011 assert(link->ifname);
2012 assert(link->manager);
2014 if (link->state != LINK_STATE_INITIALIZING)
2017 log_debug_link(link, "link state is up-to-date");
2019 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2021 link_enter_unmanaged(link);
2026 r = network_apply(link->manager, network, link);
2030 r = link_configure(link);
2037 int link_initialized(Link *link, struct udev_device *device) {
2038 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2042 assert(link->manager);
2043 assert(link->manager->rtnl);
2046 if (link->state != LINK_STATE_INITIALIZING)
2049 if (link->udev_device)
2052 log_debug_link(link, "udev initialized link");
2054 link->udev_device = udev_device_ref(device);
2056 /* udev has initialized the link, but we don't know if we have yet processed
2057 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2058 we know that the pending NEWLINKs have already been processed and that we
2061 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2065 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2074 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2075 Manager *m = userdata;
2078 _cleanup_address_free_ Address *address = NULL;
2080 char buf[INET6_ADDRSTRLEN];
2081 bool address_dropped = false;
2088 r = sd_rtnl_message_get_type(message, &type);
2090 log_warning("rtnl: could not get message type");
2094 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2095 if (r < 0 || ifindex <= 0) {
2096 log_warning("rtnl: received address message without valid ifindex, ignoring");
2099 r = link_get(m, ifindex, &link);
2100 if (r < 0 || !link) {
2101 log_warning("rtnl: received address for a nonexistent link, ignoring");
2106 r = address_new_dynamic(&address);
2110 r = sd_rtnl_message_addr_get_family(message, &address->family);
2111 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2112 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2116 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2118 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2122 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2124 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2128 switch (address->family) {
2130 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2132 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2139 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2141 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2148 assert_not_reached("invalid address family");
2151 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2152 log_warning_link(link, "could not print address");
2156 LIST_FOREACH(addresses, ad, link->addresses) {
2157 if (address_equal(ad, address)) {
2158 LIST_REMOVE(addresses, link->addresses, ad);
2162 address_dropped = true;
2170 if (!address_dropped)
2171 log_debug_link(link, "added address: %s/%u", buf,
2172 address->prefixlen);
2174 log_debug_link(link, "updated address: %s/%u", buf,
2175 address->prefixlen);
2177 LIST_PREPEND(addresses, link->addresses, address);
2184 if (address_dropped) {
2185 log_debug_link(link, "removed address: %s/%u", buf,
2186 address->prefixlen);
2190 log_warning_link(link, "removing non-existent address: %s/%u",
2191 buf, address->prefixlen);
2195 assert_not_reached("Received invalid RTNL message type");
2201 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2203 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2204 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2205 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2213 r = link_new(m, message, ret);
2219 log_debug_link(link, "link %d added", link->ifindex);
2221 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2225 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2231 if (detect_container(NULL) <= 0) {
2232 /* not in a container, udev will be around */
2233 sprintf(ifindex_str, "n%d", link->ifindex);
2234 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2236 log_warning_link(link, "could not find udev device");
2240 if (udev_device_get_is_initialized(device) <= 0) {
2242 log_debug_link(link, "udev initializing link...");
2246 r = link_initialized(link, device);
2250 /* we are calling a callback directly, so must take a ref */
2253 r = link_initialized_and_synced(m->rtnl, NULL, link);
2261 int link_update(Link *link, sd_rtnl_message *m) {
2262 struct ether_addr mac;
2267 assert(link->ifname);
2270 if (link->state == LINK_STATE_LINGER) {
2272 log_info_link(link, "link readded");
2273 link->state = LINK_STATE_ENSLAVING;
2276 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2277 if (r >= 0 && !streq(ifname, link->ifname)) {
2278 log_info_link(link, "renamed to %s", ifname);
2281 link->ifname = strdup(ifname);
2286 if (!link->original_mtu) {
2287 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2289 log_debug_link(link, "saved original MTU: %"
2290 PRIu16, link->original_mtu);
2293 /* The kernel may broadcast NEWLINK messages without the MAC address
2294 set, simply ignore them. */
2295 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2297 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2299 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2301 log_debug_link(link, "MAC address: "
2302 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2303 mac.ether_addr_octet[0],
2304 mac.ether_addr_octet[1],
2305 mac.ether_addr_octet[2],
2306 mac.ether_addr_octet[3],
2307 mac.ether_addr_octet[4],
2308 mac.ether_addr_octet[5]);
2311 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2313 log_warning_link(link, "Could not update MAC "
2314 "address in IPv4LL client: %s",
2320 if (link->dhcp_client) {
2321 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2323 log_warning_link(link, "Could not update MAC "
2324 "address in DHCP client: %s",
2330 if (link->dhcp6_client) {
2331 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2334 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2342 return link_update_flags(link, m);
2345 static void link_update_operstate(Link *link) {
2349 if (link->kernel_operstate == IF_OPER_DORMANT)
2350 link->operstate = LINK_OPERSTATE_DORMANT;
2351 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2353 uint8_t scope = RT_SCOPE_NOWHERE;
2355 /* if we have carrier, check what addresses we have */
2356 LIST_FOREACH(addresses, address, link->addresses) {
2357 if (address->scope < scope)
2358 scope = address->scope;
2361 if (scope < RT_SCOPE_SITE)
2362 /* universally accessible addresses found */
2363 link->operstate = LINK_OPERSTATE_ROUTABLE;
2364 else if (scope < RT_SCOPE_HOST)
2365 /* only link or site local addresses found */
2366 link->operstate = LINK_OPERSTATE_DEGRADED;
2368 /* no useful addresses found */
2369 link->operstate = LINK_OPERSTATE_CARRIER;
2371 link->operstate = LINK_OPERSTATE_UNKNOWN;
2374 int link_save(Link *link) {
2375 _cleanup_free_ char *temp_path = NULL;
2376 _cleanup_fclose_ FILE *f = NULL;
2377 const char *admin_state, *oper_state;
2381 assert(link->state_file);
2382 assert(link->lease_file);
2383 assert(link->manager);
2385 link_update_operstate(link);
2387 r = manager_save(link->manager);
2391 if (link->state == LINK_STATE_LINGER) {
2392 unlink(link->state_file);
2396 admin_state = link_state_to_string(link->state);
2397 assert(admin_state);
2399 oper_state = link_operstate_to_string(link->operstate);
2402 r = fopen_temporary(link->state_file, &f, &temp_path);
2406 fchmod(fileno(f), 0644);
2409 "# This is private data. Do not parse.\n"
2412 admin_state, oper_state);
2414 if (link->network) {
2419 if (link->network->dhcp_dns &&
2421 const struct in_addr *addresses;
2423 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2425 serialize_in_addrs(f, addresses, r);
2426 if (link->network->dns)
2431 STRV_FOREACH(address, link->network->dns)
2432 fprintf(f, "%s%s", *address,
2433 (address + 1 ? " " : ""));
2439 if (link->network->dhcp_ntp &&
2441 const struct in_addr *addresses;
2443 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2445 serialize_in_addrs(f, addresses, r);
2446 if (link->network->ntp)
2451 STRV_FOREACH(address, link->network->ntp)
2452 fprintf(f, "%s%s", *address,
2453 (address + 1 ? " " : ""));
2458 if (link->dhcp_lease) {
2459 assert(link->network);
2461 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2469 unlink(link->lease_file);
2473 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2475 unlink(link->state_file);
2481 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2486 static const char* const link_state_table[_LINK_STATE_MAX] = {
2487 [LINK_STATE_INITIALIZING] = "initializing",
2488 [LINK_STATE_ENSLAVING] = "configuring",
2489 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2490 [LINK_STATE_SETTING_ROUTES] = "configuring",
2491 [LINK_STATE_CONFIGURED] = "configured",
2492 [LINK_STATE_UNMANAGED] = "unmanaged",
2493 [LINK_STATE_FAILED] = "failed",
2494 [LINK_STATE_LINGER] = "linger",
2497 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2499 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2500 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2501 [LINK_OPERSTATE_DORMANT] = "dormant",
2502 [LINK_OPERSTATE_CARRIER] = "carrier",
2503 [LINK_OPERSTATE_DEGRADED] = "degraded",
2504 [LINK_OPERSTATE_ROUTABLE] = "routable",
2507 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2509 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2510 [DHCP_SUPPORT_NONE] = "none",
2511 [DHCP_SUPPORT_BOTH] = "both",
2512 [DHCP_SUPPORT_V4] = "v4",
2513 [DHCP_SUPPORT_V6] = "v6",
2516 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2518 int config_parse_dhcp(
2520 const char *filename,
2522 const char *section,
2523 unsigned section_line,
2530 DHCPSupport *dhcp = data;
2538 /* Our enum shall be a superset of booleans, hence first try
2539 * to parse as boolean, and then as enum */
2541 k = parse_boolean(rvalue);
2543 *dhcp = DHCP_SUPPORT_BOTH;
2545 *dhcp = DHCP_SUPPORT_NONE;
2549 s = dhcp_support_from_string(rvalue);
2551 log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);