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_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);
838 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
843 static int link_set_hostname(Link *link, const char *hostname) {
844 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
848 assert(link->manager);
851 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
853 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
854 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
858 r = sd_bus_message_new_method_call(
861 "org.freedesktop.hostname1",
862 "/org/freedesktop/hostname1",
863 "org.freedesktop.hostname1",
868 r = sd_bus_message_append(m, "sb", hostname, false);
872 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
874 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
883 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
884 _cleanup_link_unref_ Link *link = userdata;
889 assert(link->ifname);
891 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
894 r = sd_rtnl_message_get_errno(m);
896 log_struct_link(LOG_WARNING, link,
897 "MESSAGE=%-*s: could not set MTU: %s",
898 IFNAMSIZ, link->ifname, strerror(-r),
905 static int link_set_mtu(Link *link, uint32_t mtu) {
906 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
910 assert(link->manager);
911 assert(link->manager->rtnl);
913 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
915 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
916 RTM_SETLINK, link->ifindex);
918 log_error_link(link, "Could not allocate RTM_SETLINK message");
922 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
924 log_error_link(link, "Could not append MTU: %s", strerror(-r));
928 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
931 "Could not send rtnetlink message: %s", strerror(-r));
940 static int dhcp_lease_lost(Link *link) {
941 _cleanup_address_free_ Address *address = NULL;
943 struct in_addr netmask;
944 struct in_addr gateway;
949 assert(link->dhcp_lease);
951 log_warning_link(link, "DHCP lease lost");
953 if (link->network->dhcp_routes) {
954 struct sd_dhcp_route *routes;
957 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes);
959 for (i = 0; i < n; i++) {
960 _cleanup_route_free_ Route *route = NULL;
962 r = route_new_dynamic(&route, RTPROT_UNSPEC);
964 route->family = AF_INET;
965 route->in_addr.in = routes[i].gw_addr;
966 route->dst_addr.in = routes[i].dst_addr;
967 route->dst_prefixlen = routes[i].dst_prefixlen;
969 route_drop(route, link, &route_drop_handler);
975 r = address_new_dynamic(&address);
977 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
979 _cleanup_route_free_ Route *route_gw = NULL;
980 _cleanup_route_free_ Route *route = NULL;
982 r = route_new_dynamic(&route_gw, RTPROT_UNSPEC);
984 route_gw->family = AF_INET;
985 route_gw->dst_addr.in = gateway;
986 route_gw->dst_prefixlen = 32;
987 route_gw->scope = RT_SCOPE_LINK;
989 route_drop(route_gw, link, &route_drop_handler);
992 r = route_new_dynamic(&route, RTPROT_UNSPEC);
994 route->family = AF_INET;
995 route->in_addr.in = gateway;
997 route_drop(route, link, &route_drop_handler);
1001 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
1002 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
1003 prefixlen = net_netmask_to_prefixlen(&netmask);
1005 address->family = AF_INET;
1006 address->in_addr.in = addr;
1007 address->prefixlen = prefixlen;
1009 address_drop(address, link, &address_drop_handler);
1012 if (link->network->dhcp_mtu) {
1015 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1016 if (r >= 0 && link->original_mtu != mtu) {
1017 r = link_set_mtu(link, link->original_mtu);
1019 log_warning_link(link, "DHCP error: could not reset MTU");
1020 link_enter_failed(link);
1026 if (link->network->dhcp_hostname) {
1027 const char *hostname = NULL;
1029 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1030 if (r >= 0 && hostname) {
1031 r = link_set_hostname(link, "");
1033 log_error_link(link, "Failed to reset transient hostname");
1037 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1042 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1043 sd_dhcp_lease *lease;
1046 r = sd_dhcp_client_get_lease(client, &lease);
1048 log_warning_link(link, "DHCP error: no lease %s",
1053 sd_dhcp_lease_unref(link->dhcp_lease);
1054 link->dhcp_lease = lease;
1056 link_enter_set_addresses(link);
1061 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1062 sd_dhcp_lease *lease;
1063 struct in_addr address;
1064 struct in_addr netmask;
1065 struct in_addr gateway;
1072 r = sd_dhcp_client_get_lease(client, &lease);
1074 log_warning_link(link, "DHCP error: no lease: %s",
1079 r = sd_dhcp_lease_get_address(lease, &address);
1081 log_warning_link(link, "DHCP error: no address: %s",
1086 r = sd_dhcp_lease_get_netmask(lease, &netmask);
1088 log_warning_link(link, "DHCP error: no netmask: %s",
1093 prefixlen = net_netmask_to_prefixlen(&netmask);
1095 r = sd_dhcp_lease_get_router(lease, &gateway);
1096 if (r < 0 && r != -ENOENT) {
1097 log_warning_link(link, "DHCP error: could not get gateway: %s",
1103 log_struct_link(LOG_INFO, link,
1104 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1107 ADDRESS_FMT_VAL(address),
1109 ADDRESS_FMT_VAL(gateway),
1110 "ADDRESS=%u.%u.%u.%u",
1111 ADDRESS_FMT_VAL(address),
1114 "GATEWAY=%u.%u.%u.%u",
1115 ADDRESS_FMT_VAL(gateway),
1118 log_struct_link(LOG_INFO, link,
1119 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1122 ADDRESS_FMT_VAL(address),
1124 "ADDRESS=%u.%u.%u.%u",
1125 ADDRESS_FMT_VAL(address),
1130 link->dhcp_lease = lease;
1132 if (link->network->dhcp_mtu) {
1135 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1137 r = link_set_mtu(link, mtu);
1139 log_error_link(link, "Failed to set MTU "
1140 "to %" PRIu16, mtu);
1144 if (link->network->dhcp_hostname) {
1145 const char *hostname;
1147 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1149 r = link_set_hostname(link, hostname);
1151 log_error_link(link, "Failed to set transient hostname "
1152 "to '%s'", hostname);
1156 link_enter_set_addresses(link);
1161 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1162 Link *link = userdata;
1166 assert(link->network);
1167 assert(link->manager);
1169 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1173 case DHCP_EVENT_EXPIRED:
1174 case DHCP_EVENT_STOP:
1175 case DHCP_EVENT_IP_CHANGE:
1176 if (link->network->dhcp_critical) {
1177 log_error_link(link, "DHCPv4 connection considered system critical, "
1178 "ignoring request to reconfigure it.");
1182 if (link->dhcp_lease) {
1183 r = dhcp_lease_lost(link);
1185 link_enter_failed(link);
1190 if (event == DHCP_EVENT_IP_CHANGE) {
1191 r = dhcp_lease_acquired(client, link);
1193 link_enter_failed(link);
1198 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1199 if (!sd_ipv4ll_is_running(link->ipv4ll))
1200 r = sd_ipv4ll_start(link->ipv4ll);
1201 else if (ipv4ll_is_bound(link->ipv4ll))
1202 r = ipv4ll_address_update(link, false);
1204 link_enter_failed(link);
1210 case DHCP_EVENT_RENEW:
1211 r = dhcp_lease_renew(client, link);
1213 link_enter_failed(link);
1217 case DHCP_EVENT_IP_ACQUIRE:
1218 r = dhcp_lease_acquired(client, link);
1220 link_enter_failed(link);
1224 if (ipv4ll_is_bound(link->ipv4ll))
1225 r = ipv4ll_address_update(link, true);
1227 r = sd_ipv4ll_stop(link->ipv4ll);
1229 link_enter_failed(link);
1236 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1238 log_warning_link(link, "DHCP unknown event: %d", event);
1245 static int ipv4ll_address_update(Link *link, bool deprecate) {
1247 struct in_addr addr;
1251 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1253 _cleanup_address_free_ Address *address = NULL;
1255 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1256 deprecate ? "deprecate" : "approve",
1257 ADDRESS_FMT_VAL(addr));
1259 r = address_new_dynamic(&address);
1261 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1265 address->family = AF_INET;
1266 address->in_addr.in = addr;
1267 address->prefixlen = 16;
1268 address->scope = RT_SCOPE_LINK;
1269 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1270 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1272 address_update(address, link, &address_update_handler);
1279 static int ipv4ll_address_lost(Link *link) {
1281 struct in_addr addr;
1285 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1287 _cleanup_address_free_ Address *address = NULL;
1288 _cleanup_route_free_ Route *route = NULL;
1290 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1291 ADDRESS_FMT_VAL(addr));
1293 r = address_new_dynamic(&address);
1295 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1299 address->family = AF_INET;
1300 address->in_addr.in = addr;
1301 address->prefixlen = 16;
1302 address->scope = RT_SCOPE_LINK;
1304 address_drop(address, link, &address_drop_handler);
1306 r = route_new_dynamic(&route, RTPROT_UNSPEC);
1308 log_error_link(link, "Could not allocate route: %s",
1313 route->family = AF_INET;
1314 route->scope = RT_SCOPE_LINK;
1315 route->metrics = 99;
1317 route_drop(route, link, &route_drop_handler);
1323 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1325 struct in_addr addr;
1329 r = sd_ipv4ll_get_address(ll, &addr);
1335 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1336 struct in_addr address;
1342 r = sd_ipv4ll_get_address(ll, &address);
1346 log_struct_link(LOG_INFO, link,
1347 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1350 ADDRESS_FMT_VAL(address),
1353 link_enter_set_addresses(link);
1358 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1359 Link *link = userdata;
1363 assert(link->network);
1364 assert(link->manager);
1366 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1370 case IPV4LL_EVENT_STOP:
1371 case IPV4LL_EVENT_CONFLICT:
1372 r = ipv4ll_address_lost(link);
1374 link_enter_failed(link);
1378 case IPV4LL_EVENT_BIND:
1379 r = ipv4ll_address_claimed(ll, link);
1381 link_enter_failed(link);
1387 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1389 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1394 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1395 Link *link = userdata;
1398 assert(link->network);
1399 assert(link->manager);
1401 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1405 case DHCP6_EVENT_STOP:
1406 case DHCP6_EVENT_RESEND_EXPIRE:
1407 case DHCP6_EVENT_RETRANS_MAX:
1408 case DHCP6_EVENT_IP_ACQUIRE:
1409 log_debug_link(link, "DHCPv6 event %d", event);
1415 log_warning_link(link, "DHCPv6 error: %s",
1418 log_warning_link(link, "DHCPv6 unknown event: %d",
1424 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1425 Link *link = userdata;
1429 assert(link->network);
1430 assert(link->manager);
1432 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1436 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1437 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1440 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1441 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1446 log_warning_link(link, "ICMPv6 error: %s",
1449 log_warning_link(link, "ICMPv6 unknown event: %d",
1455 if (link->dhcp6_client)
1458 r = sd_dhcp6_client_new(&link->dhcp6_client);
1462 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1464 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1468 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1470 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1474 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1476 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1480 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1483 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1487 r = sd_dhcp6_client_start(link->dhcp6_client);
1489 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1492 static int link_acquire_conf(Link *link) {
1496 assert(link->network);
1497 assert(link->manager);
1498 assert(link->manager->event);
1500 if (link->network->ipv4ll) {
1501 assert(link->ipv4ll);
1503 log_debug_link(link, "acquiring IPv4 link-local address");
1505 r = sd_ipv4ll_start(link->ipv4ll);
1507 log_warning_link(link, "could not acquire IPv4 "
1508 "link-local address");
1513 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1514 assert(link->dhcp_client);
1516 log_debug_link(link, "acquiring DHCPv4 lease");
1518 r = sd_dhcp_client_start(link->dhcp_client);
1520 log_warning_link(link, "could not acquire DHCPv4 "
1526 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1527 assert(link->icmp6_router_discovery);
1529 log_debug_link(link, "discovering IPv6 routers");
1531 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1533 log_warning_link(link, "could not start IPv6 router discovery");
1541 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1542 /* see Documentation/networking/operstates.txt in the kernel sources */
1544 if (operstate == IF_OPER_UP)
1547 if (operstate == IF_OPER_UNKNOWN)
1548 /* operstate may not be implemented, so fall back to flags */
1549 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1555 #define FLAG_STRING(string, flag, old, new) \
1556 (((old ^ new) & flag) \
1557 ? ((old & flag) ? (" -" string) : (" +" string)) \
1560 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1561 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1563 bool carrier_gained = false, carrier_lost = false;
1568 r = sd_rtnl_message_link_get_flags(m, &flags);
1570 log_warning_link(link, "Could not get link flags");
1574 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1576 /* if we got a message without operstate, take it to mean
1577 the state was unchanged */
1578 operstate = link->kernel_operstate;
1580 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1583 if (link->flags != flags) {
1584 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",
1585 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1586 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1587 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1588 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1589 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1590 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1591 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1592 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1593 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1594 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1595 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1596 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1597 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1598 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1599 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1600 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1601 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1602 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1603 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1605 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1606 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1607 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1608 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1609 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1610 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1611 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1612 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1614 /* link flags are currently at most 18 bits, let's align to printing 20 */
1615 if (unknown_flags_added)
1616 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1617 unknown_flags_added);
1619 if (unknown_flags_removed)
1620 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1621 unknown_flags_removed);
1624 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1625 link_has_carrier(flags, operstate);
1626 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1627 !link_has_carrier(flags, operstate);
1629 link->flags = flags;
1630 link->kernel_operstate = operstate;
1634 if (link->state == LINK_STATE_FAILED ||
1635 link->state == LINK_STATE_UNMANAGED)
1638 if (carrier_gained) {
1639 log_info_link(link, "gained carrier");
1641 if (link->network) {
1642 r = link_acquire_conf(link);
1644 link_enter_failed(link);
1648 } else if (carrier_lost) {
1649 log_info_link(link, "lost carrier");
1651 r = link_stop_clients(link);
1653 link_enter_failed(link);
1661 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1662 _cleanup_link_unref_ Link *link = userdata;
1667 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1670 r = sd_rtnl_message_get_errno(m);
1672 /* we warn but don't fail the link, as it may
1673 be brought up later */
1674 log_struct_link(LOG_WARNING, link,
1675 "MESSAGE=%-*s: could not bring up interface: %s",
1677 link->ifname, strerror(-r),
1685 static int link_up(Link *link) {
1686 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1690 assert(link->manager);
1691 assert(link->manager->rtnl);
1693 log_debug_link(link, "bringing link up");
1695 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1696 RTM_SETLINK, link->ifindex);
1698 log_error_link(link, "Could not allocate RTM_SETLINK message");
1702 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1704 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1708 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1710 log_error_link(link,
1711 "Could not send rtnetlink message: %s", strerror(-r));
1720 static int link_joined(Link *link) {
1724 assert(link->state == LINK_STATE_ENSLAVING);
1725 assert(link->network);
1727 log_debug_link(link, "joined netdev");
1729 if (!(link->flags & IFF_UP)) {
1732 link_enter_failed(link);
1737 return link_enter_set_addresses(link);
1740 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1741 _cleanup_link_unref_ Link *link = userdata;
1745 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1746 LINK_STATE_LINGER));
1747 assert(link->network);
1751 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1754 r = sd_rtnl_message_get_errno(m);
1755 if (r < 0 && r != -EEXIST) {
1756 log_struct_link(LOG_ERR, link,
1757 "MESSAGE=%-*s: could not join netdev: %s",
1759 link->ifname, strerror(-r),
1762 link_enter_failed(link);
1766 if (link->enslaving <= 0)
1772 static int link_enter_join_netdev(Link *link) {
1773 NetDev *vlan, *macvlan, *vxlan;
1778 assert(link->network);
1779 assert(link->state == LINK_STATE_INITIALIZING);
1781 link->state = LINK_STATE_ENSLAVING;
1785 if (!link->network->bridge &&
1786 !link->network->bond &&
1787 !link->network->tunnel &&
1788 hashmap_isempty(link->network->vlans) &&
1789 hashmap_isempty(link->network->macvlans) &&
1790 hashmap_isempty(link->network->vxlans))
1791 return link_joined(link);
1793 if (link->network->bond) {
1794 log_struct_link(LOG_DEBUG, link,
1795 "MESSAGE=%-*s: enslaving by '%s'",
1797 link->ifname, link->network->bond->ifname,
1798 NETDEVIF(link->network->bond),
1801 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1803 log_struct_link(LOG_WARNING, link,
1804 "MESSAGE=%-*s: could not join netdev '%s': %s",
1806 link->ifname, link->network->bond->ifname, strerror(-r),
1807 NETDEVIF(link->network->bond),
1809 link_enter_failed(link);
1816 if (link->network->bridge) {
1817 log_struct_link(LOG_DEBUG, link,
1818 "MESSAGE=%-*s: enslaving by '%s'",
1820 link->ifname, link->network->bridge->ifname,
1821 NETDEVIF(link->network->bridge),
1824 r = netdev_join(link->network->bridge, link, &netdev_join_handler);
1826 log_struct_link(LOG_WARNING, link,
1827 "MESSAGE=%-*s: could not join netdev '%s': %s",
1829 link->ifname, link->network->bridge->ifname, strerror(-r),
1830 NETDEVIF(link->network->bridge),
1832 link_enter_failed(link);
1839 if (link->network->tunnel) {
1840 log_struct_link(LOG_DEBUG, link,
1841 "MESSAGE=%-*s: enslaving by '%s'",
1843 link->ifname, link->network->tunnel->ifname,
1844 NETDEVIF(link->network->tunnel),
1847 r = netdev_join(link->network->tunnel, link, &netdev_join_handler);
1849 log_struct_link(LOG_WARNING, link,
1850 "MESSAGE=%-*s: could not join netdev '%s': %s",
1852 link->ifname, link->network->tunnel->ifname, strerror(-r),
1853 NETDEVIF(link->network->tunnel),
1855 link_enter_failed(link);
1862 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1863 log_struct_link(LOG_DEBUG, link,
1864 "MESSAGE=%-*s: enslaving by '%s'",
1866 link->ifname, vlan->ifname, NETDEVIF(vlan), NULL);
1868 r = netdev_join(vlan, link, &netdev_join_handler);
1870 log_struct_link(LOG_WARNING, link,
1871 "MESSAGE=%-*s: could not join netdev '%s': %s",
1873 link->ifname, vlan->ifname, strerror(-r),
1874 NETDEVIF(vlan), NULL);
1875 link_enter_failed(link);
1882 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1883 log_struct_link(LOG_DEBUG, link,
1884 "MESSAGE=%-*s: enslaving by '%s'",
1886 link->ifname, macvlan->ifname, NETDEVIF(macvlan), NULL);
1888 r = netdev_join(macvlan, link, &netdev_join_handler);
1890 log_struct_link(LOG_WARNING, link,
1891 "MESSAGE=%-*s: could not join netdev '%s': %s",
1893 link->ifname, macvlan->ifname, strerror(-r),
1894 NETDEVIF(macvlan), NULL);
1895 link_enter_failed(link);
1902 HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1903 log_struct_link(LOG_DEBUG, link,
1904 "MESSAGE=%*s: enslaving by '%s'",
1906 link->ifname, vxlan->ifname, NETDEVIF(vxlan), NULL);
1908 r = netdev_join(vxlan, link, &netdev_join_handler);
1910 log_struct_link(LOG_WARNING, link,
1911 "MESSAGE=%*s: could not join netdev '%s': %s",
1913 link->ifname, vxlan->ifname, strerror(-r),
1914 NETDEVIF(vxlan), NULL);
1915 link_enter_failed(link);
1925 static int link_configure(Link *link) {
1929 assert(link->state == LINK_STATE_INITIALIZING);
1931 if (link->network->ipv4ll) {
1934 r = sd_ipv4ll_new(&link->ipv4ll);
1938 if (link->udev_device) {
1939 r = net_get_unique_predictable_data(link->udev_device, seed);
1941 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1947 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1951 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1955 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1959 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1964 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1965 r = sd_dhcp_client_new(&link->dhcp_client);
1969 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1973 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1977 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1981 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1985 r = sd_dhcp_client_set_request_broadcast(link->dhcp_client, link->network->dhcp_broadcast);
1989 if (link->network->dhcp_mtu) {
1990 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1995 if (link->network->dhcp_routes) {
1996 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
1999 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
2004 if (link->network->dhcp_sendhost) {
2005 _cleanup_free_ char *hostname = gethostname_malloc();
2009 if (!is_localhost(hostname)) {
2010 r = sd_dhcp_client_set_hostname(link->dhcp_client, hostname);
2016 if (link->network->dhcp_vendor_class_identifier) {
2017 r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
2018 link->network->dhcp_vendor_class_identifier);
2024 if (link->network->dhcp_server) {
2025 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2029 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2034 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
2035 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
2039 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
2044 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
2049 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
2054 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
2055 icmp6_router_handler, link);
2060 if (link_has_carrier(link->flags, link->kernel_operstate)) {
2061 r = link_acquire_conf(link);
2066 return link_enter_join_netdev(link);
2069 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2070 _cleanup_link_unref_ Link *link = userdata;
2075 assert(link->ifname);
2076 assert(link->manager);
2078 if (link->state != LINK_STATE_INITIALIZING)
2081 log_debug_link(link, "link state is up-to-date");
2083 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2085 link_enter_unmanaged(link);
2090 r = network_apply(link->manager, network, link);
2094 r = link_configure(link);
2101 int link_initialized(Link *link, struct udev_device *device) {
2102 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2106 assert(link->manager);
2107 assert(link->manager->rtnl);
2110 if (link->state != LINK_STATE_INITIALIZING)
2113 if (link->udev_device)
2116 log_debug_link(link, "udev initialized link");
2118 link->udev_device = udev_device_ref(device);
2120 /* udev has initialized the link, but we don't know if we have yet processed
2121 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2122 we know that the pending NEWLINKs have already been processed and that we
2125 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2129 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2138 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2139 Manager *m = userdata;
2142 _cleanup_address_free_ Address *address = NULL;
2144 char buf[INET6_ADDRSTRLEN];
2145 bool address_dropped = false;
2152 r = sd_rtnl_message_get_type(message, &type);
2154 log_warning("rtnl: could not get message type");
2158 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2159 if (r < 0 || ifindex <= 0) {
2160 log_warning("rtnl: received address message without valid ifindex, ignoring");
2163 r = link_get(m, ifindex, &link);
2164 if (r < 0 || !link) {
2165 log_warning("rtnl: received address for a nonexistent link, ignoring");
2170 r = address_new_dynamic(&address);
2174 r = sd_rtnl_message_addr_get_family(message, &address->family);
2175 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2176 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2180 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2182 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2186 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2188 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2192 switch (address->family) {
2194 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2196 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2203 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2205 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2212 assert_not_reached("invalid address family");
2215 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2216 log_warning_link(link, "could not print address");
2220 LIST_FOREACH(addresses, ad, link->addresses) {
2221 if (address_equal(ad, address)) {
2222 LIST_REMOVE(addresses, link->addresses, ad);
2226 address_dropped = true;
2234 if (!address_dropped)
2235 log_debug_link(link, "added address: %s/%u", buf,
2236 address->prefixlen);
2238 log_debug_link(link, "updated address: %s/%u", buf,
2239 address->prefixlen);
2241 LIST_PREPEND(addresses, link->addresses, address);
2248 if (address_dropped) {
2249 log_debug_link(link, "removed address: %s/%u", buf,
2250 address->prefixlen);
2254 log_warning_link(link, "removing non-existent address: %s/%u",
2255 buf, address->prefixlen);
2259 assert_not_reached("Received invalid RTNL message type");
2265 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2267 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2268 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2269 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2277 r = link_new(m, message, ret);
2283 log_debug_link(link, "link %d added", link->ifindex);
2285 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2289 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2295 if (detect_container(NULL) <= 0) {
2296 /* not in a container, udev will be around */
2297 sprintf(ifindex_str, "n%d", link->ifindex);
2298 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2300 log_warning_link(link, "could not find udev device");
2304 if (udev_device_get_is_initialized(device) <= 0) {
2306 log_debug_link(link, "udev initializing link...");
2310 r = link_initialized(link, device);
2314 /* we are calling a callback directly, so must take a ref */
2317 r = link_initialized_and_synced(m->rtnl, NULL, link);
2325 int link_update(Link *link, sd_rtnl_message *m) {
2326 struct ether_addr mac;
2331 assert(link->ifname);
2334 if (link->state == LINK_STATE_LINGER) {
2336 log_info_link(link, "link readded");
2337 link->state = LINK_STATE_ENSLAVING;
2340 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2341 if (r >= 0 && !streq(ifname, link->ifname)) {
2342 log_info_link(link, "renamed to %s", ifname);
2345 link->ifname = strdup(ifname);
2350 if (!link->original_mtu) {
2351 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2353 log_debug_link(link, "saved original MTU: %"
2354 PRIu16, link->original_mtu);
2357 /* The kernel may broadcast NEWLINK messages without the MAC address
2358 set, simply ignore them. */
2359 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2361 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2363 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2365 log_debug_link(link, "MAC address: "
2366 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2367 mac.ether_addr_octet[0],
2368 mac.ether_addr_octet[1],
2369 mac.ether_addr_octet[2],
2370 mac.ether_addr_octet[3],
2371 mac.ether_addr_octet[4],
2372 mac.ether_addr_octet[5]);
2375 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2377 log_warning_link(link, "Could not update MAC "
2378 "address in IPv4LL client: %s",
2384 if (link->dhcp_client) {
2385 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2387 log_warning_link(link, "Could not update MAC "
2388 "address in DHCP client: %s",
2394 if (link->dhcp6_client) {
2395 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2398 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2406 return link_update_flags(link, m);
2409 static void link_update_operstate(Link *link) {
2413 if (link->kernel_operstate == IF_OPER_DORMANT)
2414 link->operstate = LINK_OPERSTATE_DORMANT;
2415 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2417 uint8_t scope = RT_SCOPE_NOWHERE;
2419 /* if we have carrier, check what addresses we have */
2420 LIST_FOREACH(addresses, address, link->addresses) {
2421 if (address->scope < scope)
2422 scope = address->scope;
2425 if (scope < RT_SCOPE_SITE)
2426 /* universally accessible addresses found */
2427 link->operstate = LINK_OPERSTATE_ROUTABLE;
2428 else if (scope < RT_SCOPE_HOST)
2429 /* only link or site local addresses found */
2430 link->operstate = LINK_OPERSTATE_DEGRADED;
2432 /* no useful addresses found */
2433 link->operstate = LINK_OPERSTATE_CARRIER;
2435 link->operstate = LINK_OPERSTATE_UNKNOWN;
2438 int link_save(Link *link) {
2439 _cleanup_free_ char *temp_path = NULL;
2440 _cleanup_fclose_ FILE *f = NULL;
2441 const char *admin_state, *oper_state;
2445 assert(link->state_file);
2446 assert(link->lease_file);
2447 assert(link->manager);
2449 link_update_operstate(link);
2451 r = manager_save(link->manager);
2455 if (link->state == LINK_STATE_LINGER) {
2456 unlink(link->state_file);
2460 admin_state = link_state_to_string(link->state);
2461 assert(admin_state);
2463 oper_state = link_operstate_to_string(link->operstate);
2466 r = fopen_temporary(link->state_file, &f, &temp_path);
2470 fchmod(fileno(f), 0644);
2473 "# This is private data. Do not parse.\n"
2476 admin_state, oper_state);
2478 if (link->network) {
2483 if (link->network->dhcp_dns &&
2485 const struct in_addr *addresses;
2487 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2489 serialize_in_addrs(f, addresses, r);
2490 if (link->network->dns)
2495 STRV_FOREACH(address, link->network->dns)
2496 fprintf(f, "%s%s", *address,
2497 (address + 1 ? " " : ""));
2503 if (link->network->dhcp_ntp &&
2505 const struct in_addr *addresses;
2507 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2509 serialize_in_addrs(f, addresses, r);
2510 if (link->network->ntp)
2515 STRV_FOREACH(address, link->network->ntp)
2516 fprintf(f, "%s%s", *address,
2517 (address + 1 ? " " : ""));
2522 if (link->dhcp_lease) {
2523 assert(link->network);
2525 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2533 unlink(link->lease_file);
2537 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2539 unlink(link->state_file);
2545 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2550 static const char* const link_state_table[_LINK_STATE_MAX] = {
2551 [LINK_STATE_INITIALIZING] = "initializing",
2552 [LINK_STATE_ENSLAVING] = "configuring",
2553 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2554 [LINK_STATE_SETTING_ROUTES] = "configuring",
2555 [LINK_STATE_CONFIGURED] = "configured",
2556 [LINK_STATE_UNMANAGED] = "unmanaged",
2557 [LINK_STATE_FAILED] = "failed",
2558 [LINK_STATE_LINGER] = "linger",
2561 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2563 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2564 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2565 [LINK_OPERSTATE_DORMANT] = "dormant",
2566 [LINK_OPERSTATE_CARRIER] = "carrier",
2567 [LINK_OPERSTATE_DEGRADED] = "degraded",
2568 [LINK_OPERSTATE_ROUTABLE] = "routable",
2571 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2573 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2574 [DHCP_SUPPORT_NONE] = "none",
2575 [DHCP_SUPPORT_BOTH] = "both",
2576 [DHCP_SUPPORT_V4] = "v4",
2577 [DHCP_SUPPORT_V6] = "v6",
2580 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2582 int config_parse_dhcp(
2584 const char *filename,
2586 const char *section,
2587 unsigned section_line,
2594 DHCPSupport *dhcp = data;
2602 /* Our enum shall be a superset of booleans, hence first try
2603 * to parse as boolean, and then as enum */
2605 k = parse_boolean(rvalue);
2607 *dhcp = DHCP_SUPPORT_BOTH;
2609 *dhcp = DHCP_SUPPORT_NONE;
2613 s = dhcp_support_from_string(rvalue);
2615 log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);