1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Tom Gundersen <teg@jklm.no>
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <netinet/ether.h>
26 #include "libudev-private.h"
27 #include "udev-util.h"
31 #include "network-internal.h"
32 #include "conf-parser.h"
34 #include "network-util.h"
35 #include "dhcp-lease-internal.h"
37 static int ipv4ll_address_update(Link *link, bool deprecate);
38 static bool ipv4ll_is_bound(sd_ipv4ll *ll);
40 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
41 _cleanup_link_unref_ Link *link = NULL;
47 assert(manager->links);
51 r = sd_rtnl_message_get_type(message, &type);
54 else if (type != RTM_NEWLINK)
57 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
60 else if (ifindex <= 0)
63 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
72 link->manager = manager;
73 link->state = LINK_STATE_INITIALIZING;
74 link->ifindex = ifindex;
75 link->ifname = strdup(ifname);
79 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
83 r = asprintf(&link->state_file, "/run/systemd/netif/links/%"PRIu64,
88 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%"PRIu64,
93 r = hashmap_put(manager->links, &link->ifindex, link);
103 static void link_free(Link *link) {
109 while ((address = link->addresses)) {
110 LIST_REMOVE(addresses, link->addresses, address);
111 address_free(address);
114 while ((address = link->pool_addresses)) {
115 LIST_REMOVE(addresses, link->pool_addresses, address);
116 address_free(address);
119 sd_dhcp_client_unref(link->dhcp_client);
120 sd_dhcp_lease_unref(link->dhcp_lease);
122 unlink(link->lease_file);
123 free(link->lease_file);
125 sd_ipv4ll_unref(link->ipv4ll);
126 sd_dhcp6_client_unref(link->dhcp6_client);
127 sd_icmp6_nd_unref(link->icmp6_router_discovery);
130 hashmap_remove(link->manager->links, &link->ifindex);
134 unlink(link->state_file);
135 free(link->state_file);
137 udev_device_unref(link->udev_device);
142 Link *link_unref(Link *link) {
143 if (link && (-- link->n_ref <= 0))
149 Link *link_ref(Link *link) {
151 assert_se(++ link->n_ref >= 2);
156 int link_get(Manager *m, int ifindex, Link **ret) {
165 ifindex_64 = ifindex;
166 link = hashmap_get(m->links, &ifindex_64);
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;
402 size_t static_routes_size;
408 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes, &static_routes_size);
411 log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-r));
415 for (i = 0; i < static_routes_size; i++) {
416 _cleanup_route_free_ Route *route = NULL;
418 r = route_new_dynamic(&route);
420 log_error_link(link, "Could not allocate route: %s",
425 route->family = AF_INET;
426 route->in_addr.in = static_routes[i].gw_addr;
427 route->dst_addr.in = static_routes[i].dst_addr;
428 route->dst_prefixlen = static_routes[i].dst_prefixlen;
429 route->metrics = DHCP_STATIC_ROUTE_METRIC;
431 r = route_configure(route, link, &route_handler);
433 log_warning_link(link,
434 "could not set host route: %s", strerror(-r));
439 link->route_messages ++;
445 static int link_enter_set_routes(Link *link) {
450 assert(link->network);
451 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
453 link->state = LINK_STATE_SETTING_ROUTES;
455 if (!link->network->static_routes && !link->dhcp_lease &&
456 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
457 return link_enter_configured(link);
459 log_debug_link(link, "setting routes");
461 LIST_FOREACH(routes, rt, link->network->static_routes) {
462 r = route_configure(rt, link, &route_handler);
464 log_warning_link(link,
465 "could not set routes: %s", strerror(-r));
466 link_enter_failed(link);
471 link->route_messages ++;
474 if (link->ipv4ll && !link->dhcp_lease) {
475 _cleanup_route_free_ Route *route = NULL;
478 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
479 if (r < 0 && r != -ENOENT) {
480 log_warning_link(link, "IPV4LL error: no address: %s",
486 r = route_new_dynamic(&route);
488 log_error_link(link, "Could not allocate route: %s",
493 route->family = AF_INET;
494 route->scope = RT_SCOPE_LINK;
497 r = route_configure(route, link, &route_handler);
499 log_warning_link(link,
500 "could not set routes: %s", strerror(-r));
501 link_enter_failed(link);
506 link->route_messages ++;
510 if (link->dhcp_lease) {
511 _cleanup_route_free_ Route *route = NULL;
512 _cleanup_route_free_ Route *route_gw = NULL;
513 struct in_addr gateway;
515 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
516 if (r < 0 && r != -ENOENT) {
517 log_warning_link(link, "DHCP error: could not get gateway: %s",
523 r = route_new_dynamic(&route);
525 log_error_link(link, "Could not allocate route: %s",
530 r = route_new_dynamic(&route_gw);
532 log_error_link(link, "Could not allocate route: %s",
537 /* The dhcp netmask may mask out the gateway. Add an explicit
538 * route for the gw host so that we can route no matter the
539 * netmask or existing kernel route tables. */
540 route_gw->family = AF_INET;
541 route_gw->dst_addr.in = gateway;
542 route_gw->dst_prefixlen = 32;
543 route_gw->scope = RT_SCOPE_LINK;
544 route_gw->metrics = DHCP_STATIC_ROUTE_METRIC;
546 r = route_configure(route_gw, link, &route_handler);
548 log_warning_link(link,
549 "could not set host route: %s", strerror(-r));
554 link->route_messages ++;
556 route->family = AF_INET;
557 route->in_addr.in = gateway;
558 route->metrics = DHCP_STATIC_ROUTE_METRIC;
560 r = route_configure(route, link, &route_handler);
562 log_warning_link(link,
563 "could not set routes: %s", strerror(-r));
564 link_enter_failed(link);
569 link->route_messages ++;
572 if (link->network->dhcp_routes)
573 link_set_dhcp_routes(link);
576 if (link->route_messages == 0) {
577 link_enter_configured(link);
583 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
584 _cleanup_link_unref_ Link *link = userdata;
589 assert(link->ifname);
591 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
594 r = sd_rtnl_message_get_errno(m);
595 if (r < 0 && r != -ESRCH)
596 log_struct_link(LOG_WARNING, link,
597 "MESSAGE=%-*s: could not drop route: %s",
599 link->ifname, strerror(-r),
606 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
607 _cleanup_link_unref_ Link *link = userdata;
612 assert(link->ifname);
613 assert(link->addr_messages > 0);
614 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
615 LINK_STATE_FAILED, LINK_STATE_LINGER));
617 link->addr_messages --;
619 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
622 r = sd_rtnl_message_get_errno(m);
623 if (r < 0 && r != -EEXIST)
624 log_struct_link(LOG_WARNING, link,
625 "MESSAGE=%-*s: could not set address: %s",
627 link->ifname, strerror(-r),
631 if (link->addr_messages == 0) {
632 log_debug_link(link, "addresses set");
633 link_enter_set_routes(link);
639 static int link_enter_set_addresses(Link *link) {
642 uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
645 assert(link->network);
646 assert(link->state != _LINK_STATE_INVALID);
648 link->state = LINK_STATE_SETTING_ADDRESSES;
650 if (!link->network->static_addresses && !link->dhcp_lease &&
651 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
652 return link_enter_set_routes(link);
654 log_debug_link(link, "setting addresses");
656 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
657 r = address_configure(ad, link, &address_handler);
659 log_warning_link(link,
660 "could not set addresses: %s", strerror(-r));
661 link_enter_failed(link);
666 link->addr_messages ++;
669 if (link->ipv4ll && !link->dhcp_lease) {
670 _cleanup_address_free_ Address *ll_addr = NULL;
673 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
674 if (r < 0 && r != -ENOENT) {
675 log_warning_link(link, "IPV4LL error: no address: %s",
681 r = address_new_dynamic(&ll_addr);
683 log_error_link(link, "Could not allocate address: %s", strerror(-r));
687 ll_addr->family = AF_INET;
688 ll_addr->in_addr.in = addr;
689 ll_addr->prefixlen = 16;
690 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
691 ll_addr->scope = RT_SCOPE_LINK;
693 r = address_configure(ll_addr, link, &address_handler);
695 log_warning_link(link,
696 "could not set addresses: %s", strerror(-r));
697 link_enter_failed(link);
702 link->addr_messages ++;
706 if (link->dhcp_lease) {
707 _cleanup_address_free_ Address *address = NULL;
709 struct in_addr netmask;
712 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
714 log_warning_link(link, "DHCP error: no address: %s",
719 if (!link->network->dhcp_critical) {
720 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
723 log_warning_link(link, "DHCP error: no lifetime: %s",
729 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
731 log_warning_link(link, "DHCP error: no netmask: %s",
736 prefixlen = net_netmask_to_prefixlen(&netmask);
738 r = address_new_dynamic(&address);
740 log_error_link(link, "Could not allocate address: %s",
745 address->family = AF_INET;
746 address->in_addr.in = addr;
747 address->cinfo.ifa_prefered = lifetime;
748 address->cinfo.ifa_valid = lifetime;
749 address->prefixlen = prefixlen;
750 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
752 /* use update rather than configure so that we will update the lifetime
753 of an existing address if it has already been configured */
754 r = address_update(address, link, &address_handler);
756 log_warning_link(link,
757 "could not set addresses: %s", strerror(-r));
758 link_enter_failed(link);
763 link->addr_messages ++;
769 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
770 _cleanup_link_unref_ Link *link = userdata;
775 assert(link->ifname);
777 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
780 r = sd_rtnl_message_get_errno(m);
781 if (r < 0 && r != -ENOENT)
782 log_struct_link(LOG_WARNING, link,
783 "MESSAGE=%-*s: could not update address: %s",
785 link->ifname, strerror(-r),
792 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
793 _cleanup_link_unref_ Link *link = userdata;
798 assert(link->ifname);
800 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
803 r = sd_rtnl_message_get_errno(m);
804 if (r < 0 && r != -EADDRNOTAVAIL)
805 log_struct_link(LOG_WARNING, link,
806 "MESSAGE=%-*s: could not drop address: %s",
808 link->ifname, strerror(-r),
815 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
816 _cleanup_link_unref_ Link *link = userdata;
821 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
824 r = sd_bus_message_get_errno(m);
826 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
831 static int link_set_hostname(Link *link, const char *hostname) {
832 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
836 assert(link->manager);
839 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
841 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
842 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
846 r = sd_bus_message_new_method_call(
849 "org.freedesktop.hostname1",
850 "/org/freedesktop/hostname1",
851 "org.freedesktop.hostname1",
856 r = sd_bus_message_append(m, "sb", hostname, false);
860 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
862 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
871 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
872 _cleanup_link_unref_ Link *link = userdata;
877 assert(link->ifname);
879 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
882 r = sd_rtnl_message_get_errno(m);
884 log_struct_link(LOG_WARNING, link,
885 "MESSAGE=%-*s: could not set MTU: %s",
886 IFNAMSIZ, link->ifname, strerror(-r),
893 static int link_set_mtu(Link *link, uint32_t mtu) {
894 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
898 assert(link->manager);
899 assert(link->manager->rtnl);
901 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
903 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
904 RTM_SETLINK, link->ifindex);
906 log_error_link(link, "Could not allocate RTM_SETLINK message");
910 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
912 log_error_link(link, "Could not append MTU: %s", strerror(-r));
916 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
919 "Could not send rtnetlink message: %s", strerror(-r));
928 static int dhcp_lease_lost(Link *link) {
929 _cleanup_address_free_ Address *address = NULL;
931 struct in_addr netmask;
932 struct in_addr gateway;
938 assert(link->dhcp_lease);
940 log_warning_link(link, "DHCP lease lost");
942 if (link->network->dhcp_routes) {
943 struct sd_dhcp_route *routes;
946 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes, &routes_size);
948 for (i = 0; i < routes_size; i++) {
949 _cleanup_route_free_ Route *route = NULL;
951 r = route_new_dynamic(&route);
953 route->family = AF_INET;
954 route->in_addr.in = routes[i].gw_addr;
955 route->dst_addr.in = routes[i].dst_addr;
956 route->dst_prefixlen = routes[i].dst_prefixlen;
958 route_drop(route, link, &route_drop_handler);
965 r = address_new_dynamic(&address);
967 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
969 _cleanup_route_free_ Route *route_gw = NULL;
970 _cleanup_route_free_ Route *route = NULL;
972 r = route_new_dynamic(&route_gw);
974 route_gw->family = AF_INET;
975 route_gw->dst_addr.in = gateway;
976 route_gw->dst_prefixlen = 32;
977 route_gw->scope = RT_SCOPE_LINK;
979 route_drop(route_gw, link, &route_drop_handler);
983 r = route_new_dynamic(&route);
985 route->family = AF_INET;
986 route->in_addr.in = gateway;
988 route_drop(route, link, &route_drop_handler);
993 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
994 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
995 prefixlen = net_netmask_to_prefixlen(&netmask);
997 address->family = AF_INET;
998 address->in_addr.in = addr;
999 address->prefixlen = prefixlen;
1001 address_drop(address, link, &address_drop_handler);
1005 if (link->network->dhcp_mtu) {
1008 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1009 if (r >= 0 && link->original_mtu != mtu) {
1010 r = link_set_mtu(link, link->original_mtu);
1012 log_warning_link(link, "DHCP error: could not reset MTU");
1013 link_enter_failed(link);
1019 if (link->network->dhcp_hostname) {
1020 const char *hostname = NULL;
1022 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1023 if (r >= 0 && hostname) {
1024 r = link_set_hostname(link, "");
1026 log_error_link(link, "Failed to reset transient hostname");
1030 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1035 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1036 sd_dhcp_lease *lease;
1039 r = sd_dhcp_client_get_lease(client, &lease);
1041 log_warning_link(link, "DHCP error: no lease %s",
1046 sd_dhcp_lease_unref(link->dhcp_lease);
1047 link->dhcp_lease = lease;
1049 link_enter_set_addresses(link);
1054 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1055 sd_dhcp_lease *lease;
1056 struct in_addr address;
1057 struct in_addr netmask;
1058 struct in_addr gateway;
1065 r = sd_dhcp_client_get_lease(client, &lease);
1067 log_warning_link(link, "DHCP error: no lease: %s",
1072 r = sd_dhcp_lease_get_address(lease, &address);
1074 log_warning_link(link, "DHCP error: no address: %s",
1079 r = sd_dhcp_lease_get_netmask(lease, &netmask);
1081 log_warning_link(link, "DHCP error: no netmask: %s",
1086 prefixlen = net_netmask_to_prefixlen(&netmask);
1088 r = sd_dhcp_lease_get_router(lease, &gateway);
1089 if (r < 0 && r != -ENOENT) {
1090 log_warning_link(link, "DHCP error: could not get gateway: %s",
1096 log_struct_link(LOG_INFO, link,
1097 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1100 ADDRESS_FMT_VAL(address),
1102 ADDRESS_FMT_VAL(gateway),
1103 "ADDRESS=%u.%u.%u.%u",
1104 ADDRESS_FMT_VAL(address),
1107 "GATEWAY=%u.%u.%u.%u",
1108 ADDRESS_FMT_VAL(gateway),
1111 log_struct_link(LOG_INFO, link,
1112 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1115 ADDRESS_FMT_VAL(address),
1117 "ADDRESS=%u.%u.%u.%u",
1118 ADDRESS_FMT_VAL(address),
1123 link->dhcp_lease = lease;
1125 if (link->network->dhcp_mtu) {
1128 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1130 r = link_set_mtu(link, mtu);
1132 log_error_link(link, "Failed to set MTU "
1133 "to %" PRIu16, mtu);
1137 if (link->network->dhcp_hostname) {
1138 const char *hostname;
1140 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1142 r = link_set_hostname(link, hostname);
1144 log_error_link(link, "Failed to set transient hostname "
1145 "to '%s'", hostname);
1149 link_enter_set_addresses(link);
1154 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1155 Link *link = userdata;
1159 assert(link->network);
1160 assert(link->manager);
1162 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1166 case DHCP_EVENT_NO_LEASE:
1167 log_debug_link(link, "IP address in use.");
1169 case DHCP_EVENT_EXPIRED:
1170 case DHCP_EVENT_STOP:
1171 case DHCP_EVENT_IP_CHANGE:
1172 if (link->network->dhcp_critical) {
1173 log_error_link(link, "DHCPv4 connection considered system critical, "
1174 "ignoring request to reconfigure it.");
1178 if (link->dhcp_lease) {
1179 r = dhcp_lease_lost(link);
1181 link_enter_failed(link);
1186 if (event == DHCP_EVENT_IP_CHANGE) {
1187 r = dhcp_lease_acquired(client, link);
1189 link_enter_failed(link);
1194 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1195 if (!sd_ipv4ll_is_running(link->ipv4ll))
1196 r = sd_ipv4ll_start(link->ipv4ll);
1197 else if (ipv4ll_is_bound(link->ipv4ll))
1198 r = ipv4ll_address_update(link, false);
1200 link_enter_failed(link);
1206 case DHCP_EVENT_RENEW:
1207 r = dhcp_lease_renew(client, link);
1209 link_enter_failed(link);
1213 case DHCP_EVENT_IP_ACQUIRE:
1214 r = dhcp_lease_acquired(client, link);
1216 link_enter_failed(link);
1220 if (ipv4ll_is_bound(link->ipv4ll))
1221 r = ipv4ll_address_update(link, true);
1223 r = sd_ipv4ll_stop(link->ipv4ll);
1225 link_enter_failed(link);
1232 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1234 log_warning_link(link, "DHCP unknown event: %d", event);
1241 static int ipv4ll_address_update(Link *link, bool deprecate) {
1243 struct in_addr addr;
1247 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1249 _cleanup_address_free_ Address *address = NULL;
1251 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1252 deprecate ? "deprecate" : "approve",
1253 ADDRESS_FMT_VAL(addr));
1255 r = address_new_dynamic(&address);
1257 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1261 address->family = AF_INET;
1262 address->in_addr.in = addr;
1263 address->prefixlen = 16;
1264 address->scope = RT_SCOPE_LINK;
1265 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1266 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1268 address_update(address, link, &address_update_handler);
1276 static int ipv4ll_address_lost(Link *link) {
1278 struct in_addr addr;
1282 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1284 _cleanup_address_free_ Address *address = NULL;
1285 _cleanup_route_free_ Route *route = NULL;
1287 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1288 ADDRESS_FMT_VAL(addr));
1290 r = address_new_dynamic(&address);
1292 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1296 address->family = AF_INET;
1297 address->in_addr.in = addr;
1298 address->prefixlen = 16;
1299 address->scope = RT_SCOPE_LINK;
1301 address_drop(address, link, &address_drop_handler);
1304 r = route_new_dynamic(&route);
1306 log_error_link(link, "Could not allocate route: %s",
1311 route->family = AF_INET;
1312 route->scope = RT_SCOPE_LINK;
1313 route->metrics = 99;
1315 route_drop(route, link, &route_drop_handler);
1322 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1324 struct in_addr addr;
1328 r = sd_ipv4ll_get_address(ll, &addr);
1334 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1335 struct in_addr address;
1341 r = sd_ipv4ll_get_address(ll, &address);
1345 log_struct_link(LOG_INFO, link,
1346 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1349 ADDRESS_FMT_VAL(address),
1352 link_enter_set_addresses(link);
1357 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1358 Link *link = userdata;
1362 assert(link->network);
1363 assert(link->manager);
1365 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1369 case IPV4LL_EVENT_STOP:
1370 case IPV4LL_EVENT_CONFLICT:
1371 r = ipv4ll_address_lost(link);
1373 link_enter_failed(link);
1377 case IPV4LL_EVENT_BIND:
1378 r = ipv4ll_address_claimed(ll, link);
1380 link_enter_failed(link);
1386 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1388 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1393 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1394 Link *link = userdata;
1397 assert(link->network);
1398 assert(link->manager);
1400 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1404 case DHCP6_EVENT_STOP:
1405 case DHCP6_EVENT_RESEND_EXPIRE:
1406 case DHCP6_EVENT_RETRANS_MAX:
1407 case DHCP6_EVENT_IP_ACQUIRE:
1408 log_debug_link(link, "DHCPv6 event %d", event);
1414 log_warning_link(link, "DHCPv6 error: %s",
1417 log_warning_link(link, "DHCPv6 unknown event: %d",
1423 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1424 Link *link = userdata;
1428 assert(link->network);
1429 assert(link->manager);
1431 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1435 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1436 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1439 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1440 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1445 log_warning_link(link, "ICMPv6 error: %s",
1448 log_warning_link(link, "ICMPv6 unknown event: %d",
1454 if (link->dhcp6_client)
1457 r = sd_dhcp6_client_new(&link->dhcp6_client);
1461 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1463 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1467 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1469 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1473 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1475 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1479 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1482 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1486 r = sd_dhcp6_client_start(link->dhcp6_client);
1488 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1491 static int link_acquire_conf(Link *link) {
1495 assert(link->network);
1496 assert(link->manager);
1497 assert(link->manager->event);
1499 if (link->network->ipv4ll) {
1500 assert(link->ipv4ll);
1502 log_debug_link(link, "acquiring IPv4 link-local address");
1504 r = sd_ipv4ll_start(link->ipv4ll);
1506 log_warning_link(link, "could not acquire IPv4 "
1507 "link-local address");
1512 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1513 assert(link->dhcp_client);
1515 log_debug_link(link, "acquiring DHCPv4 lease");
1517 r = sd_dhcp_client_start(link->dhcp_client);
1519 log_warning_link(link, "could not acquire DHCPv4 "
1525 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1526 assert(link->icmp6_router_discovery);
1528 log_debug_link(link, "discovering IPv6 routers");
1530 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1532 log_warning_link(link, "could not start IPv6 router discovery");
1540 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1541 /* see Documentation/networking/operstates.txt in the kernel sources */
1543 if (operstate == IF_OPER_UP)
1546 if (operstate == IF_OPER_UNKNOWN)
1547 /* operstate may not be implemented, so fall back to flags */
1548 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1554 #define FLAG_STRING(string, flag, old, new) \
1555 (((old ^ new) & flag) \
1556 ? ((old & flag) ? (" -" string) : (" +" string)) \
1559 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1560 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1562 bool carrier_gained = false, carrier_lost = false;
1567 r = sd_rtnl_message_link_get_flags(m, &flags);
1569 log_warning_link(link, "Could not get link flags");
1573 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1575 /* if we got a message without operstate, take it to mean
1576 the state was unchanged */
1577 operstate = link->kernel_operstate;
1579 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1582 if (link->flags != flags) {
1583 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",
1584 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1585 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1586 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1587 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1588 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1589 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1590 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1591 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1592 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1593 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1594 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1595 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1596 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1597 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1598 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1599 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1600 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1601 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1602 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1604 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1605 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1606 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1607 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1608 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1609 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1610 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1611 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1613 /* link flags are currently at most 18 bits, let's align to printing 20 */
1614 if (unknown_flags_added)
1615 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1616 unknown_flags_added);
1618 if (unknown_flags_removed)
1619 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1620 unknown_flags_removed);
1623 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1624 link_has_carrier(flags, operstate);
1625 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1626 !link_has_carrier(flags, operstate);
1628 link->flags = flags;
1629 link->kernel_operstate = operstate;
1633 if (link->state == LINK_STATE_FAILED ||
1634 link->state == LINK_STATE_UNMANAGED)
1637 if (carrier_gained) {
1638 log_info_link(link, "gained carrier");
1640 if (link->network) {
1641 r = link_acquire_conf(link);
1643 link_enter_failed(link);
1647 } else if (carrier_lost) {
1648 log_info_link(link, "lost carrier");
1650 r = link_stop_clients(link);
1652 link_enter_failed(link);
1660 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1661 _cleanup_link_unref_ Link *link = userdata;
1666 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1669 r = sd_rtnl_message_get_errno(m);
1671 /* we warn but don't fail the link, as it may
1672 be brought up later */
1673 log_struct_link(LOG_WARNING, link,
1674 "MESSAGE=%-*s: could not bring up interface: %s",
1676 link->ifname, strerror(-r),
1684 static int link_up(Link *link) {
1685 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1689 assert(link->manager);
1690 assert(link->manager->rtnl);
1692 log_debug_link(link, "bringing link up");
1694 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1695 RTM_SETLINK, link->ifindex);
1697 log_error_link(link, "Could not allocate RTM_SETLINK message");
1701 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1703 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1707 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1709 log_error_link(link,
1710 "Could not send rtnetlink message: %s", strerror(-r));
1719 static int link_enslaved(Link *link) {
1723 assert(link->state == LINK_STATE_ENSLAVING);
1724 assert(link->network);
1726 if (!(link->flags & IFF_UP)) {
1729 link_enter_failed(link);
1734 return link_enter_set_addresses(link);
1737 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1738 _cleanup_link_unref_ Link *link = userdata;
1742 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1743 LINK_STATE_LINGER));
1744 assert(link->network);
1748 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1751 r = sd_rtnl_message_get_errno(m);
1753 log_struct_link(LOG_ERR, link,
1754 "MESSAGE=%-*s: could not enslave: %s",
1756 link->ifname, strerror(-r),
1759 link_enter_failed(link);
1763 log_debug_link(link, "enslaved");
1765 if (link->enslaving == 0)
1766 link_enslaved(link);
1771 static int link_enter_enslave(Link *link) {
1772 NetDev *vlan, *macvlan, *vxlan;
1777 assert(link->network);
1778 assert(link->state == LINK_STATE_INITIALIZING);
1780 link->state = LINK_STATE_ENSLAVING;
1784 if (!link->network->bridge &&
1785 !link->network->bond &&
1786 !link->network->tunnel &&
1787 hashmap_isempty(link->network->vlans) &&
1788 hashmap_isempty(link->network->macvlans) &&
1789 hashmap_isempty(link->network->vxlans))
1790 return link_enslaved(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 NETDEV(link->network->bond),
1800 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1802 log_struct_link(LOG_WARNING, link,
1803 "MESSAGE=%-*s: could not enslave by '%s': %s",
1805 link->ifname, link->network->bond->ifname, strerror(-r),
1806 NETDEV(link->network->bond),
1808 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 NETDEV(link->network->bridge),
1824 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1826 log_struct_link(LOG_WARNING, link,
1827 "MESSAGE=%-*s: could not enslave by '%s': %s",
1829 link->ifname, link->network->bridge->ifname, strerror(-r),
1830 NETDEV(link->network->bridge),
1832 link_enter_failed(link);
1840 if (link->network->tunnel) {
1841 log_struct_link(LOG_DEBUG, link,
1842 "MESSAGE=%-*s: enslaving by '%s'",
1844 link->ifname, link->network->tunnel->ifname,
1845 NETDEV(link->network->tunnel),
1848 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1850 log_struct_link(LOG_WARNING, link,
1851 "MESSAGE=%-*s: could not enslave by '%s': %s",
1853 link->ifname, link->network->tunnel->ifname, strerror(-r),
1854 NETDEV(link->network->tunnel),
1856 link_enter_failed(link);
1864 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1865 log_struct_link(LOG_DEBUG, link,
1866 "MESSAGE=%-*s: enslaving by '%s'",
1868 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1870 r = netdev_enslave(vlan, link, &enslave_handler);
1872 log_struct_link(LOG_WARNING, link,
1873 "MESSAGE=%-*s: could not enslave by '%s': %s",
1875 link->ifname, vlan->ifname, strerror(-r),
1876 NETDEV(vlan), NULL);
1877 link_enter_failed(link);
1885 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1886 log_struct_link(LOG_DEBUG, link,
1887 "MESSAGE=%-*s: enslaving by '%s'",
1889 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1891 r = netdev_enslave(macvlan, link, &enslave_handler);
1893 log_struct_link(LOG_WARNING, link,
1894 "MESSAGE=%-*s: could not enslave by '%s': %s",
1896 link->ifname, macvlan->ifname, strerror(-r),
1897 NETDEV(macvlan), NULL);
1898 link_enter_failed(link);
1906 HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1907 log_struct_link(LOG_DEBUG, link,
1908 "MESSAGE=%*s: enslaving by '%s'",
1910 link->ifname, vxlan->ifname, NETDEV(vxlan), NULL);
1912 r = netdev_enslave(vxlan, link, &enslave_handler);
1914 log_struct_link(LOG_WARNING, link,
1915 "MESSAGE=%*s: could not enslave by '%s': %s",
1917 link->ifname, vxlan->ifname, strerror(-r),
1918 NETDEV(vxlan), NULL);
1919 link_enter_failed(link);
1930 static int link_configure(Link *link) {
1934 assert(link->state == LINK_STATE_INITIALIZING);
1936 if (link->network->ipv4ll) {
1939 r = sd_ipv4ll_new(&link->ipv4ll);
1943 if (link->udev_device) {
1944 r = net_get_unique_predictable_data(link->udev_device, seed);
1946 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1952 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1956 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1960 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1964 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1969 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1970 r = sd_dhcp_client_new(&link->dhcp_client);
1974 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1978 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1982 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1986 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1990 if (link->network->dhcp_mtu) {
1991 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);
2005 if (link->network->dhcp_server) {
2006 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2010 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2015 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
2016 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
2020 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
2025 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
2030 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
2035 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
2036 icmp6_router_handler, link);
2041 if (link_has_carrier(link->flags, link->kernel_operstate)) {
2042 r = link_acquire_conf(link);
2047 return link_enter_enslave(link);
2050 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2051 _cleanup_link_unref_ Link *link = userdata;
2056 assert(link->ifname);
2057 assert(link->manager);
2059 if (link->state != LINK_STATE_INITIALIZING)
2062 log_debug_link(link, "link state is up-to-date");
2064 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2066 link_enter_unmanaged(link);
2071 r = network_apply(link->manager, network, link);
2075 r = link_configure(link);
2082 int link_initialized(Link *link, struct udev_device *device) {
2083 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2087 assert(link->manager);
2088 assert(link->manager->rtnl);
2091 if (link->state != LINK_STATE_INITIALIZING)
2094 log_debug_link(link, "udev initialized link");
2096 link->udev_device = udev_device_ref(device);
2098 /* udev has initialized the link, but we don't know if we have yet processed
2099 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2100 we know that the pending NEWLINKs have already been processed and that we
2103 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2107 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2116 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2117 Manager *m = userdata;
2120 _cleanup_address_free_ Address *address = NULL;
2122 char buf[INET6_ADDRSTRLEN];
2123 bool address_dropped = false;
2130 r = sd_rtnl_message_get_type(message, &type);
2132 log_warning("rtnl: could not get message type");
2136 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2137 if (r < 0 || ifindex <= 0) {
2138 log_warning("rtnl: received address message without valid ifindex, ignoring");
2141 r = link_get(m, ifindex, &link);
2142 if (r < 0 || !link) {
2143 log_warning("rtnl: received address for a nonexistent link, ignoring");
2148 r = address_new_dynamic(&address);
2152 r = sd_rtnl_message_addr_get_family(message, &address->family);
2153 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2154 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2158 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2160 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2164 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2166 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2170 switch (address->family) {
2172 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2174 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2181 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2183 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2190 assert_not_reached("invalid address family");
2193 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2194 log_warning_link(link, "could not print address");
2198 LIST_FOREACH(addresses, ad, link->addresses) {
2199 if (address_equal(ad, address)) {
2200 LIST_REMOVE(addresses, link->addresses, ad);
2204 address_dropped = true;
2212 if (!address_dropped)
2213 log_debug_link(link, "added address: %s/%u", buf,
2214 address->prefixlen);
2216 LIST_PREPEND(addresses, link->addresses, address);
2223 if (address_dropped) {
2224 log_debug_link(link, "removed address: %s/%u", buf,
2225 address->prefixlen);
2232 assert_not_reached("Received invalid RTNL message type");
2238 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2239 _cleanup_link_unref_ Link *link = userdata;
2245 assert(link->manager);
2247 for (; m; m = sd_rtnl_message_next(m)) {
2248 r = sd_rtnl_message_get_errno(m);
2250 log_debug_link(link, "getting address failed: %s", strerror(-r));
2254 r = link_rtnl_process_address(rtnl, m, link->manager);
2256 log_warning_link(link, "could not process address: %s", strerror(-r));
2262 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2264 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2265 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2266 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2274 r = link_new(m, message, ret);
2280 log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2282 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2286 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2292 if (detect_container(NULL) <= 0) {
2293 /* not in a container, udev will be around */
2294 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2295 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2297 log_warning_link(link, "could not find udev device");
2301 if (udev_device_get_is_initialized(device) <= 0) {
2303 log_debug_link(link, "udev initializing link...");
2307 r = link_initialized(link, device);
2311 /* we are calling a callback directly, so must take a ref */
2314 r = link_initialized_and_synced(m->rtnl, NULL, link);
2322 int link_update(Link *link, sd_rtnl_message *m) {
2323 struct ether_addr mac;
2328 assert(link->ifname);
2331 if (link->state == LINK_STATE_LINGER) {
2333 log_info_link(link, "link readded");
2334 link->state = LINK_STATE_ENSLAVING;
2337 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2338 if (r >= 0 && !streq(ifname, link->ifname)) {
2339 log_info_link(link, "renamed to %s", ifname);
2342 link->ifname = strdup(ifname);
2347 if (!link->original_mtu) {
2348 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2350 log_debug_link(link, "saved original MTU: %"
2351 PRIu16, link->original_mtu);
2354 /* The kernel may broadcast NEWLINK messages without the MAC address
2355 set, simply ignore them. */
2356 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2358 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2360 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2362 log_debug_link(link, "MAC address: "
2363 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2364 mac.ether_addr_octet[0],
2365 mac.ether_addr_octet[1],
2366 mac.ether_addr_octet[2],
2367 mac.ether_addr_octet[3],
2368 mac.ether_addr_octet[4],
2369 mac.ether_addr_octet[5]);
2372 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2374 log_warning_link(link, "Could not update MAC "
2375 "address in IPv4LL client: %s",
2381 if (link->dhcp_client) {
2382 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2384 log_warning_link(link, "Could not update MAC "
2385 "address in DHCP client: %s",
2391 if (link->dhcp6_client) {
2392 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2395 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2403 return link_update_flags(link, m);
2406 static void serialize_addresses(FILE *f, const char *key, Address *address) {
2415 fprintf(f, "%s=", key);
2417 LIST_FOREACH(addresses, ad, address) {
2418 char buf[INET6_ADDRSTRLEN];
2420 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
2421 fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2427 static void link_update_operstate(Link *link) {
2431 if (link->kernel_operstate == IF_OPER_DORMANT)
2432 link->operstate = LINK_OPERSTATE_DORMANT;
2433 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2435 uint8_t scope = RT_SCOPE_NOWHERE;
2437 /* if we have carrier, check what addresses we have */
2438 LIST_FOREACH(addresses, address, link->addresses) {
2439 if (address->scope < scope)
2440 scope = address->scope;
2443 if (scope < RT_SCOPE_SITE)
2444 /* universally accessible addresses found */
2445 link->operstate = LINK_OPERSTATE_ROUTABLE;
2446 else if (scope < RT_SCOPE_HOST)
2447 /* only link or site local addresses found */
2448 link->operstate = LINK_OPERSTATE_DEGRADED;
2450 /* no useful addresses found */
2451 link->operstate = LINK_OPERSTATE_CARRIER;
2453 link->operstate = LINK_OPERSTATE_UNKNOWN;
2456 int link_save(Link *link) {
2457 _cleanup_free_ char *temp_path = NULL;
2458 _cleanup_fclose_ FILE *f = NULL;
2459 const char *admin_state, *oper_state;
2463 assert(link->state_file);
2464 assert(link->lease_file);
2465 assert(link->manager);
2467 link_update_operstate(link);
2469 r = manager_save(link->manager);
2473 if (link->state == LINK_STATE_LINGER) {
2474 unlink(link->state_file);
2478 admin_state = link_state_to_string(link->state);
2479 assert(admin_state);
2481 oper_state = link_operstate_to_string(link->operstate);
2484 r = fopen_temporary(link->state_file, &f, &temp_path);
2488 fchmod(fileno(f), 0644);
2491 "# This is private data. Do not parse.\n"
2495 admin_state, oper_state, link->flags);
2497 if (link->network) {
2498 serialize_addresses(f, "DNS", link->network->dns);
2499 serialize_addresses(f, "NTP", link->network->ntp);
2502 if (link->dhcp_lease) {
2503 assert(link->network);
2505 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2512 "DHCP_USE_NTP=%s\n",
2514 yes_no(link->network->dhcp_dns),
2515 yes_no(link->network->dhcp_ntp));
2517 unlink(link->lease_file);
2521 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2523 unlink(link->state_file);
2529 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2534 static const char* const link_state_table[_LINK_STATE_MAX] = {
2535 [LINK_STATE_INITIALIZING] = "initializing",
2536 [LINK_STATE_ENSLAVING] = "configuring",
2537 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2538 [LINK_STATE_SETTING_ROUTES] = "configuring",
2539 [LINK_STATE_CONFIGURED] = "configured",
2540 [LINK_STATE_UNMANAGED] = "unmanaged",
2541 [LINK_STATE_FAILED] = "failed",
2542 [LINK_STATE_LINGER] = "linger",
2545 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2547 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2548 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2549 [LINK_OPERSTATE_DORMANT] = "dormant",
2550 [LINK_OPERSTATE_CARRIER] = "carrier",
2551 [LINK_OPERSTATE_DEGRADED] = "degraded",
2552 [LINK_OPERSTATE_ROUTABLE] = "routable",
2555 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2557 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2558 [DHCP_SUPPORT_NONE] = "none",
2559 [DHCP_SUPPORT_BOTH] = "both",
2560 [DHCP_SUPPORT_V4] = "v4",
2561 [DHCP_SUPPORT_V6] = "v6",
2564 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2566 int config_parse_dhcp(
2568 const char *filename,
2570 const char *section,
2571 unsigned section_line,
2578 DHCPSupport *dhcp = data;
2586 /* Our enum shall be a superset of booleans, hence first try
2587 * to parse as boolean, and then as enum */
2589 k = parse_boolean(rvalue);
2591 *dhcp = DHCP_SUPPORT_BOTH;
2593 *dhcp = DHCP_SUPPORT_NONE;
2597 s = dhcp_support_from_string(rvalue);
2599 log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);