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 assert(link->manager);
111 while ((address = link->addresses)) {
112 LIST_REMOVE(addresses, link->addresses, address);
113 address_free(address);
116 while ((address = link->pool_addresses)) {
117 LIST_REMOVE(addresses, link->pool_addresses, address);
118 address_free(address);
121 sd_dhcp_client_unref(link->dhcp_client);
122 sd_dhcp_lease_unref(link->dhcp_lease);
124 unlink(link->lease_file);
125 free(link->lease_file);
127 sd_ipv4ll_unref(link->ipv4ll);
128 sd_dhcp6_client_unref(link->dhcp6_client);
129 sd_icmp6_nd_unref(link->icmp6_router_discovery);
131 hashmap_remove(link->manager->links, &link->ifindex);
135 unlink(link->state_file);
136 free(link->state_file);
138 udev_device_unref(link->udev_device);
143 Link *link_unref(Link *link) {
144 if (link && (-- link->n_ref <= 0))
150 Link *link_ref(Link *link) {
152 assert_se(++ link->n_ref >= 2);
157 int link_get(Manager *m, int ifindex, Link **ret) {
166 ifindex_64 = ifindex;
167 link = hashmap_get(m->links, &ifindex_64);
176 void link_drop(Link *link) {
177 if (!link || link->state == LINK_STATE_LINGER)
180 link->state = LINK_STATE_LINGER;
182 log_debug_link(link, "link removed");
189 static void link_enter_unmanaged(Link *link) {
192 log_debug_link(link, "unmanaged");
194 link->state = LINK_STATE_UNMANAGED;
199 static int link_stop_clients(Link *link) {
203 assert(link->manager);
204 assert(link->manager->event);
209 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
210 assert(link->dhcp_client);
212 k = sd_dhcp_client_stop(link->dhcp_client);
214 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
219 if (link->network->ipv4ll) {
220 assert(link->ipv4ll);
222 k = sd_ipv4ll_stop(link->ipv4ll);
224 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
229 if (link->network->dhcp_server) {
230 assert(link->dhcp_server);
232 k = sd_dhcp_server_stop(link->dhcp_server);
234 log_warning_link(link, "Could not stop DHCPv4 server: %s", strerror(-r));
239 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
240 assert(link->icmp6_router_discovery);
242 if (link->dhcp6_client) {
243 k = sd_dhcp6_client_stop(link->dhcp6_client);
245 log_warning_link(link, "Could not stop DHCPv6 client: %s", strerror(-r));
250 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
252 log_warning_link(link, "Could not stop ICMPv6 router discovery: %s", strerror(-r));
260 static void link_enter_failed(Link *link) {
263 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
266 log_warning_link(link, "failed");
268 link->state = LINK_STATE_FAILED;
270 link_stop_clients(link);
275 static Address* link_find_dhcp_server_address(Link *link) {
279 assert(link->network);
281 /* The the first statically configured address if there is any */
282 LIST_FOREACH(addresses, address, link->network->static_addresses) {
284 if (address->family != AF_INET)
287 if (in_addr_null(address->family, &address->in_addr))
293 /* If that didn't work, find a suitable address we got from the pool */
294 LIST_FOREACH(addresses, address, link->pool_addresses) {
295 if (address->family != AF_INET)
304 static int link_enter_configured(Link *link) {
308 assert(link->network);
309 assert(link->state == LINK_STATE_SETTING_ROUTES);
311 if (link->network->dhcp_server &&
312 !sd_dhcp_server_is_running(link->dhcp_server)) {
313 struct in_addr pool_start;
316 address = link_find_dhcp_server_address(link);
318 log_warning_link(link, "Failed to find suitable address for DHCPv4 server instance.");
319 link_enter_failed(link);
323 log_debug_link(link, "offering DHCPv4 leases");
325 r = sd_dhcp_server_set_address(link->dhcp_server, &address->in_addr.in);
329 /* offer 32 addresses starting from the address following the server address */
330 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
331 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
337 r = sd_dhcp_server_set_router(link->dhcp_server,
338 &main_address->in_addr.in);
342 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
343 main_address->prefixlen);
348 r = sd_dhcp_server_start(link->dhcp_server);
350 log_warning_link(link, "could not start DHCPv4 server "
351 "instance: %s", strerror(-r));
353 link_enter_failed(link);
359 log_info_link(link, "link configured");
361 link->state = LINK_STATE_CONFIGURED;
368 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
369 Link *link = userdata;
372 assert(link->route_messages > 0);
373 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
374 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
377 link->route_messages --;
379 if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER)) {
384 r = sd_rtnl_message_get_errno(m);
385 if (r < 0 && r != -EEXIST)
386 log_struct_link(LOG_WARNING, link,
387 "MESSAGE=%-*s: could not set route: %s",
389 link->ifname, strerror(-r),
393 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
395 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
396 log_debug_link(link, "routes set");
397 link_enter_configured(link);
405 static int link_set_dhcp_routes(Link *link) {
406 struct sd_dhcp_route *static_routes;
407 size_t static_routes_size;
413 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes, &static_routes_size);
416 log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-r));
420 for (i = 0; i < static_routes_size; i++) {
421 _cleanup_route_free_ Route *route = NULL;
423 r = route_new_dynamic(&route);
425 log_error_link(link, "Could not allocate route: %s",
430 route->family = AF_INET;
431 route->in_addr.in = static_routes[i].gw_addr;
432 route->dst_addr.in = static_routes[i].dst_addr;
433 route->dst_prefixlen = static_routes[i].dst_prefixlen;
434 route->metrics = DHCP_STATIC_ROUTE_METRIC;
436 r = route_configure(route, link, &route_handler);
438 log_warning_link(link,
439 "could not set host route: %s", strerror(-r));
444 link->route_messages ++;
450 static int link_enter_set_routes(Link *link) {
455 assert(link->network);
456 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
458 link->state = LINK_STATE_SETTING_ROUTES;
460 if (!link->network->static_routes && !link->dhcp_lease &&
461 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
462 return link_enter_configured(link);
464 log_debug_link(link, "setting routes");
466 LIST_FOREACH(routes, rt, link->network->static_routes) {
467 r = route_configure(rt, link, &route_handler);
469 log_warning_link(link,
470 "could not set routes: %s", strerror(-r));
471 link_enter_failed(link);
476 link->route_messages ++;
479 if (link->ipv4ll && !link->dhcp_lease) {
480 _cleanup_route_free_ Route *route = NULL;
483 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
484 if (r < 0 && r != -ENOENT) {
485 log_warning_link(link, "IPV4LL error: no address: %s",
491 r = route_new_dynamic(&route);
493 log_error_link(link, "Could not allocate route: %s",
498 route->family = AF_INET;
499 route->scope = RT_SCOPE_LINK;
502 r = route_configure(route, link, &route_handler);
504 log_warning_link(link,
505 "could not set routes: %s", strerror(-r));
506 link_enter_failed(link);
511 link->route_messages ++;
515 if (link->dhcp_lease) {
516 _cleanup_route_free_ Route *route = NULL;
517 _cleanup_route_free_ Route *route_gw = NULL;
518 struct in_addr gateway;
520 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
521 if (r < 0 && r != -ENOENT) {
522 log_warning_link(link, "DHCP error: could not get gateway: %s",
528 r = route_new_dynamic(&route);
530 log_error_link(link, "Could not allocate route: %s",
535 r = route_new_dynamic(&route_gw);
537 log_error_link(link, "Could not allocate route: %s",
542 /* The dhcp netmask may mask out the gateway. Add an explicit
543 * route for the gw host so that we can route no matter the
544 * netmask or existing kernel route tables. */
545 route_gw->family = AF_INET;
546 route_gw->dst_addr.in = gateway;
547 route_gw->dst_prefixlen = 32;
548 route_gw->scope = RT_SCOPE_LINK;
549 route_gw->metrics = DHCP_STATIC_ROUTE_METRIC;
551 r = route_configure(route_gw, link, &route_handler);
553 log_warning_link(link,
554 "could not set host route: %s", strerror(-r));
559 link->route_messages ++;
561 route->family = AF_INET;
562 route->in_addr.in = gateway;
563 route->metrics = DHCP_STATIC_ROUTE_METRIC;
565 r = route_configure(route, link, &route_handler);
567 log_warning_link(link,
568 "could not set routes: %s", strerror(-r));
569 link_enter_failed(link);
574 link->route_messages ++;
577 if (link->network->dhcp_routes)
578 link_set_dhcp_routes(link);
581 if (link->route_messages == 0) {
582 link_enter_configured(link);
588 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
589 Link *link = userdata;
594 assert(link->ifname);
596 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
601 r = sd_rtnl_message_get_errno(m);
602 if (r < 0 && r != -ESRCH)
603 log_struct_link(LOG_WARNING, link,
604 "MESSAGE=%-*s: could not drop route: %s",
606 link->ifname, strerror(-r),
615 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
616 Link *link = userdata;
621 assert(link->ifname);
622 assert(link->addr_messages > 0);
623 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
624 LINK_STATE_FAILED, LINK_STATE_LINGER));
626 link->addr_messages --;
628 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
633 r = sd_rtnl_message_get_errno(m);
634 if (r < 0 && r != -EEXIST)
635 log_struct_link(LOG_WARNING, link,
636 "MESSAGE=%-*s: could not set address: %s",
638 link->ifname, strerror(-r),
642 if (link->addr_messages == 0) {
643 log_debug_link(link, "addresses set");
644 link_enter_set_routes(link);
652 static int link_enter_set_addresses(Link *link) {
655 uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
658 assert(link->network);
659 assert(link->state != _LINK_STATE_INVALID);
661 link->state = LINK_STATE_SETTING_ADDRESSES;
663 if (!link->network->static_addresses && !link->dhcp_lease &&
664 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
665 return link_enter_set_routes(link);
667 log_debug_link(link, "setting addresses");
669 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
670 r = address_configure(ad, link, &address_handler);
672 log_warning_link(link,
673 "could not set addresses: %s", strerror(-r));
674 link_enter_failed(link);
679 link->addr_messages ++;
682 if (link->ipv4ll && !link->dhcp_lease) {
683 _cleanup_address_free_ Address *ll_addr = NULL;
686 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
687 if (r < 0 && r != -ENOENT) {
688 log_warning_link(link, "IPV4LL error: no address: %s",
694 r = address_new_dynamic(&ll_addr);
696 log_error_link(link, "Could not allocate address: %s", strerror(-r));
700 ll_addr->family = AF_INET;
701 ll_addr->in_addr.in = addr;
702 ll_addr->prefixlen = 16;
703 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
704 ll_addr->scope = RT_SCOPE_LINK;
706 r = address_configure(ll_addr, link, &address_handler);
708 log_warning_link(link,
709 "could not set addresses: %s", strerror(-r));
710 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);
776 link->addr_messages ++;
782 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
783 Link *link = userdata;
788 assert(link->ifname);
790 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
795 r = sd_rtnl_message_get_errno(m);
796 if (r < 0 && r != -ENOENT)
797 log_struct_link(LOG_WARNING, link,
798 "MESSAGE=%-*s: could not update address: %s",
800 link->ifname, strerror(-r),
809 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
810 Link *link = userdata;
815 assert(link->ifname);
817 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
822 r = sd_rtnl_message_get_errno(m);
823 if (r < 0 && r != -EADDRNOTAVAIL)
824 log_struct_link(LOG_WARNING, link,
825 "MESSAGE=%-*s: could not drop address: %s",
827 link->ifname, strerror(-r),
836 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
837 Link *link = userdata;
842 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
847 r = sd_bus_message_get_errno(m);
849 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
856 static int link_set_hostname(Link *link, const char *hostname) {
857 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
861 assert(link->manager);
864 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
866 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
867 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
871 r = sd_bus_message_new_method_call(
874 "org.freedesktop.hostname1",
875 "/org/freedesktop/hostname1",
876 "org.freedesktop.hostname1",
881 r = sd_bus_message_append(m, "sb", hostname, false);
885 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
887 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
894 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
895 Link *link = userdata;
900 assert(link->ifname);
902 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
907 r = sd_rtnl_message_get_errno(m);
909 log_struct_link(LOG_WARNING, link,
910 "MESSAGE=%-*s: could not set MTU: %s",
911 IFNAMSIZ, link->ifname, strerror(-r),
920 static int link_set_mtu(Link *link, uint32_t mtu) {
921 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
925 assert(link->manager);
926 assert(link->manager->rtnl);
928 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
930 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
931 RTM_SETLINK, link->ifindex);
933 log_error_link(link, "Could not allocate RTM_SETLINK message");
937 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
939 log_error_link(link, "Could not append MTU: %s", strerror(-r));
943 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
946 "Could not send rtnetlink message: %s", strerror(-r));
955 static int dhcp_lease_lost(Link *link) {
956 _cleanup_address_free_ Address *address = NULL;
958 struct in_addr netmask;
959 struct in_addr gateway;
965 assert(link->dhcp_lease);
967 log_warning_link(link, "DHCP lease lost");
969 if (link->network->dhcp_routes) {
970 struct sd_dhcp_route *routes;
973 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes, &routes_size);
975 for (i = 0; i < routes_size; i++) {
976 _cleanup_route_free_ Route *route = NULL;
978 r = route_new_dynamic(&route);
980 route->family = AF_INET;
981 route->in_addr.in = routes[i].gw_addr;
982 route->dst_addr.in = routes[i].dst_addr;
983 route->dst_prefixlen = routes[i].dst_prefixlen;
985 route_drop(route, link, &route_drop_handler);
992 r = address_new_dynamic(&address);
994 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
996 _cleanup_route_free_ Route *route_gw = NULL;
997 _cleanup_route_free_ Route *route = NULL;
999 r = route_new_dynamic(&route_gw);
1001 route_gw->family = AF_INET;
1002 route_gw->dst_addr.in = gateway;
1003 route_gw->dst_prefixlen = 32;
1004 route_gw->scope = RT_SCOPE_LINK;
1006 route_drop(route_gw, link, &route_drop_handler);
1010 r = route_new_dynamic(&route);
1012 route->family = AF_INET;
1013 route->in_addr.in = gateway;
1015 route_drop(route, link, &route_drop_handler);
1020 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
1021 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
1022 prefixlen = net_netmask_to_prefixlen(&netmask);
1024 address->family = AF_INET;
1025 address->in_addr.in = addr;
1026 address->prefixlen = prefixlen;
1028 address_drop(address, link, &address_drop_handler);
1032 if (link->network->dhcp_mtu) {
1035 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1036 if (r >= 0 && link->original_mtu != mtu) {
1037 r = link_set_mtu(link, link->original_mtu);
1039 log_warning_link(link, "DHCP error: could not reset MTU");
1040 link_enter_failed(link);
1046 if (link->network->dhcp_hostname) {
1047 const char *hostname = NULL;
1049 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1050 if (r >= 0 && hostname) {
1051 r = link_set_hostname(link, "");
1053 log_error_link(link, "Failed to reset transient hostname");
1057 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1062 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1063 sd_dhcp_lease *lease;
1066 r = sd_dhcp_client_get_lease(client, &lease);
1068 log_warning_link(link, "DHCP error: no lease %s",
1073 sd_dhcp_lease_unref(link->dhcp_lease);
1074 link->dhcp_lease = lease;
1076 link_enter_set_addresses(link);
1081 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1082 sd_dhcp_lease *lease;
1083 struct in_addr address;
1084 struct in_addr netmask;
1085 struct in_addr gateway;
1092 r = sd_dhcp_client_get_lease(client, &lease);
1094 log_warning_link(link, "DHCP error: no lease: %s",
1099 r = sd_dhcp_lease_get_address(lease, &address);
1101 log_warning_link(link, "DHCP error: no address: %s",
1106 r = sd_dhcp_lease_get_netmask(lease, &netmask);
1108 log_warning_link(link, "DHCP error: no netmask: %s",
1113 prefixlen = net_netmask_to_prefixlen(&netmask);
1115 r = sd_dhcp_lease_get_router(lease, &gateway);
1116 if (r < 0 && r != -ENOENT) {
1117 log_warning_link(link, "DHCP error: could not get gateway: %s",
1123 log_struct_link(LOG_INFO, link,
1124 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1127 ADDRESS_FMT_VAL(address),
1129 ADDRESS_FMT_VAL(gateway),
1130 "ADDRESS=%u.%u.%u.%u",
1131 ADDRESS_FMT_VAL(address),
1134 "GATEWAY=%u.%u.%u.%u",
1135 ADDRESS_FMT_VAL(gateway),
1138 log_struct_link(LOG_INFO, link,
1139 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1142 ADDRESS_FMT_VAL(address),
1144 "ADDRESS=%u.%u.%u.%u",
1145 ADDRESS_FMT_VAL(address),
1150 link->dhcp_lease = lease;
1152 if (link->network->dhcp_mtu) {
1155 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1157 r = link_set_mtu(link, mtu);
1159 log_error_link(link, "Failed to set MTU "
1160 "to %" PRIu16, mtu);
1164 if (link->network->dhcp_hostname) {
1165 const char *hostname;
1167 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1169 r = link_set_hostname(link, hostname);
1171 log_error_link(link, "Failed to set transient hostname "
1172 "to '%s'", hostname);
1176 link_enter_set_addresses(link);
1181 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1182 Link *link = userdata;
1186 assert(link->network);
1187 assert(link->manager);
1189 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1193 case DHCP_EVENT_NO_LEASE:
1194 log_debug_link(link, "IP address in use.");
1196 case DHCP_EVENT_EXPIRED:
1197 case DHCP_EVENT_STOP:
1198 case DHCP_EVENT_IP_CHANGE:
1199 if (link->network->dhcp_critical) {
1200 log_error_link(link, "DHCPv4 connection considered system critical, "
1201 "ignoring request to reconfigure it.");
1205 if (link->dhcp_lease) {
1206 r = dhcp_lease_lost(link);
1208 link_enter_failed(link);
1213 if (event == DHCP_EVENT_IP_CHANGE) {
1214 r = dhcp_lease_acquired(client, link);
1216 link_enter_failed(link);
1221 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1222 if (!sd_ipv4ll_is_running(link->ipv4ll))
1223 r = sd_ipv4ll_start(link->ipv4ll);
1224 else if (ipv4ll_is_bound(link->ipv4ll))
1225 r = ipv4ll_address_update(link, false);
1227 link_enter_failed(link);
1233 case DHCP_EVENT_RENEW:
1234 r = dhcp_lease_renew(client, link);
1236 link_enter_failed(link);
1240 case DHCP_EVENT_IP_ACQUIRE:
1241 r = dhcp_lease_acquired(client, link);
1243 link_enter_failed(link);
1247 if (ipv4ll_is_bound(link->ipv4ll))
1248 r = ipv4ll_address_update(link, true);
1250 r = sd_ipv4ll_stop(link->ipv4ll);
1252 link_enter_failed(link);
1259 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1261 log_warning_link(link, "DHCP unknown event: %d", event);
1268 static int ipv4ll_address_update(Link *link, bool deprecate) {
1270 struct in_addr addr;
1274 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1276 _cleanup_address_free_ Address *address = NULL;
1278 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1279 deprecate ? "deprecate" : "approve",
1280 ADDRESS_FMT_VAL(addr));
1282 r = address_new_dynamic(&address);
1284 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1288 address->family = AF_INET;
1289 address->in_addr.in = addr;
1290 address->prefixlen = 16;
1291 address->scope = RT_SCOPE_LINK;
1292 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1293 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1295 address_update(address, link, &address_update_handler);
1303 static int ipv4ll_address_lost(Link *link) {
1305 struct in_addr addr;
1309 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1311 _cleanup_address_free_ Address *address = NULL;
1312 _cleanup_route_free_ Route *route = NULL;
1314 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1315 ADDRESS_FMT_VAL(addr));
1317 r = address_new_dynamic(&address);
1319 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1323 address->family = AF_INET;
1324 address->in_addr.in = addr;
1325 address->prefixlen = 16;
1326 address->scope = RT_SCOPE_LINK;
1328 address_drop(address, link, &address_drop_handler);
1331 r = route_new_dynamic(&route);
1333 log_error_link(link, "Could not allocate route: %s",
1338 route->family = AF_INET;
1339 route->scope = RT_SCOPE_LINK;
1340 route->metrics = 99;
1342 route_drop(route, link, &route_drop_handler);
1349 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1351 struct in_addr addr;
1355 r = sd_ipv4ll_get_address(ll, &addr);
1361 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1362 struct in_addr address;
1368 r = sd_ipv4ll_get_address(ll, &address);
1372 log_struct_link(LOG_INFO, link,
1373 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1376 ADDRESS_FMT_VAL(address),
1379 link_enter_set_addresses(link);
1384 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1385 Link *link = userdata;
1389 assert(link->network);
1390 assert(link->manager);
1392 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1396 case IPV4LL_EVENT_STOP:
1397 case IPV4LL_EVENT_CONFLICT:
1398 r = ipv4ll_address_lost(link);
1400 link_enter_failed(link);
1404 case IPV4LL_EVENT_BIND:
1405 r = ipv4ll_address_claimed(ll, link);
1407 link_enter_failed(link);
1413 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1415 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1420 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1421 Link *link = userdata;
1424 assert(link->network);
1425 assert(link->manager);
1427 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1431 case DHCP6_EVENT_STOP:
1432 case DHCP6_EVENT_RESEND_EXPIRE:
1433 case DHCP6_EVENT_RETRANS_MAX:
1434 case DHCP6_EVENT_IP_ACQUIRE:
1435 log_debug_link(link, "DHCPv6 event %d", event);
1441 log_warning_link(link, "DHCPv6 error: %s",
1444 log_warning_link(link, "DHCPv6 unknown event: %d",
1450 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1451 Link *link = userdata;
1455 assert(link->network);
1456 assert(link->manager);
1458 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1462 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1463 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1466 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1467 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1472 log_warning_link(link, "ICMPv6 error: %s",
1475 log_warning_link(link, "ICMPv6 unknown event: %d",
1481 if (link->dhcp6_client)
1484 r = sd_dhcp6_client_new(&link->dhcp6_client);
1488 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1490 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1494 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1496 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1500 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1502 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1506 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1509 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1513 r = sd_dhcp6_client_start(link->dhcp6_client);
1515 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1518 static int link_acquire_conf(Link *link) {
1522 assert(link->network);
1523 assert(link->manager);
1524 assert(link->manager->event);
1526 if (link->network->ipv4ll) {
1527 assert(link->ipv4ll);
1529 log_debug_link(link, "acquiring IPv4 link-local address");
1531 r = sd_ipv4ll_start(link->ipv4ll);
1533 log_warning_link(link, "could not acquire IPv4 "
1534 "link-local address");
1539 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1540 assert(link->dhcp_client);
1542 log_debug_link(link, "acquiring DHCPv4 lease");
1544 r = sd_dhcp_client_start(link->dhcp_client);
1546 log_warning_link(link, "could not acquire DHCPv4 "
1552 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1553 assert(link->icmp6_router_discovery);
1555 log_debug_link(link, "discovering IPv6 routers");
1557 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1559 log_warning_link(link, "could not start IPv6 router discovery");
1567 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1568 /* see Documentation/networking/operstates.txt in the kernel sources */
1570 if (operstate == IF_OPER_UP)
1573 if (operstate == IF_OPER_UNKNOWN)
1574 /* operstate may not be implemented, so fall back to flags */
1575 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1581 #define FLAG_STRING(string, flag, old, new) \
1582 (((old ^ new) & flag) \
1583 ? ((old & flag) ? (" -" string) : (" +" string)) \
1586 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1587 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1589 bool carrier_gained = false, carrier_lost = false;
1594 r = sd_rtnl_message_link_get_flags(m, &flags);
1596 log_warning_link(link, "Could not get link flags");
1600 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1602 /* if we got a message without operstate, take it to mean
1603 the state was unchanged */
1604 operstate = link->kernel_operstate;
1606 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1609 if (link->flags != flags) {
1610 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",
1611 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1612 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1613 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1614 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1615 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1616 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1617 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1618 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1619 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1620 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1621 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1622 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1623 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1624 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1625 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1626 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1627 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1628 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1629 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1631 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1632 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1633 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1634 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1635 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1636 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1637 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1638 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1640 /* link flags are currently at most 18 bits, let's align to printing 20 */
1641 if (unknown_flags_added)
1642 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1643 unknown_flags_added);
1645 if (unknown_flags_removed)
1646 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1647 unknown_flags_removed);
1650 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1651 link_has_carrier(flags, operstate);
1652 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1653 !link_has_carrier(flags, operstate);
1655 link->flags = flags;
1656 link->kernel_operstate = operstate;
1660 if (link->state == LINK_STATE_FAILED ||
1661 link->state == LINK_STATE_UNMANAGED)
1664 if (carrier_gained) {
1665 log_info_link(link, "gained carrier");
1667 if (link->network) {
1668 r = link_acquire_conf(link);
1670 link_enter_failed(link);
1674 } else if (carrier_lost) {
1675 log_info_link(link, "lost carrier");
1677 r = link_stop_clients(link);
1679 link_enter_failed(link);
1687 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1688 Link *link = userdata;
1693 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1698 r = sd_rtnl_message_get_errno(m);
1700 /* we warn but don't fail the link, as it may
1701 be brought up later */
1702 log_struct_link(LOG_WARNING, link,
1703 "MESSAGE=%-*s: could not bring up interface: %s",
1705 link->ifname, strerror(-r),
1715 static int link_up(Link *link) {
1716 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1720 assert(link->manager);
1721 assert(link->manager->rtnl);
1723 log_debug_link(link, "bringing link up");
1725 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1726 RTM_SETLINK, link->ifindex);
1728 log_error_link(link, "Could not allocate RTM_SETLINK message");
1732 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1734 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1738 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1740 log_error_link(link,
1741 "Could not send rtnetlink message: %s", strerror(-r));
1750 static int link_enslaved(Link *link) {
1754 assert(link->state == LINK_STATE_ENSLAVING);
1755 assert(link->network);
1757 if (!(link->flags & IFF_UP)) {
1760 link_enter_failed(link);
1765 return link_enter_set_addresses(link);
1768 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1769 Link *link = userdata;
1773 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1774 LINK_STATE_LINGER));
1775 assert(link->network);
1779 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1784 r = sd_rtnl_message_get_errno(m);
1786 log_struct_link(LOG_ERR, link,
1787 "MESSAGE=%-*s: could not enslave: %s",
1789 link->ifname, strerror(-r),
1792 link_enter_failed(link);
1797 log_debug_link(link, "enslaved");
1799 if (link->enslaving == 0)
1800 link_enslaved(link);
1807 static int link_enter_enslave(Link *link) {
1808 NetDev *vlan, *macvlan, *vxlan;
1813 assert(link->network);
1814 assert(link->state == LINK_STATE_INITIALIZING);
1816 link->state = LINK_STATE_ENSLAVING;
1820 if (!link->network->bridge &&
1821 !link->network->bond &&
1822 !link->network->tunnel &&
1823 hashmap_isempty(link->network->vlans) &&
1824 hashmap_isempty(link->network->macvlans) &&
1825 hashmap_isempty(link->network->vxlans))
1826 return link_enslaved(link);
1828 if (link->network->bond) {
1829 log_struct_link(LOG_DEBUG, link,
1830 "MESSAGE=%-*s: enslaving by '%s'",
1832 link->ifname, link->network->bond->ifname,
1833 NETDEV(link->network->bond),
1836 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1838 log_struct_link(LOG_WARNING, link,
1839 "MESSAGE=%-*s: could not enslave by '%s': %s",
1841 link->ifname, link->network->bond->ifname, strerror(-r),
1842 NETDEV(link->network->bond),
1844 link_enter_failed(link);
1852 if (link->network->bridge) {
1853 log_struct_link(LOG_DEBUG, link,
1854 "MESSAGE=%-*s: enslaving by '%s'",
1856 link->ifname, link->network->bridge->ifname,
1857 NETDEV(link->network->bridge),
1860 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1862 log_struct_link(LOG_WARNING, link,
1863 "MESSAGE=%-*s: could not enslave by '%s': %s",
1865 link->ifname, link->network->bridge->ifname, strerror(-r),
1866 NETDEV(link->network->bridge),
1868 link_enter_failed(link);
1876 if (link->network->tunnel) {
1877 log_struct_link(LOG_DEBUG, link,
1878 "MESSAGE=%-*s: enslaving by '%s'",
1880 link->ifname, link->network->tunnel->ifname,
1881 NETDEV(link->network->tunnel),
1884 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1886 log_struct_link(LOG_WARNING, link,
1887 "MESSAGE=%-*s: could not enslave by '%s': %s",
1889 link->ifname, link->network->tunnel->ifname, strerror(-r),
1890 NETDEV(link->network->tunnel),
1892 link_enter_failed(link);
1900 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1901 log_struct_link(LOG_DEBUG, link,
1902 "MESSAGE=%-*s: enslaving by '%s'",
1904 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1906 r = netdev_enslave(vlan, link, &enslave_handler);
1908 log_struct_link(LOG_WARNING, link,
1909 "MESSAGE=%-*s: could not enslave by '%s': %s",
1911 link->ifname, vlan->ifname, strerror(-r),
1912 NETDEV(vlan), NULL);
1913 link_enter_failed(link);
1921 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1922 log_struct_link(LOG_DEBUG, link,
1923 "MESSAGE=%-*s: enslaving by '%s'",
1925 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1927 r = netdev_enslave(macvlan, link, &enslave_handler);
1929 log_struct_link(LOG_WARNING, link,
1930 "MESSAGE=%-*s: could not enslave by '%s': %s",
1932 link->ifname, macvlan->ifname, strerror(-r),
1933 NETDEV(macvlan), NULL);
1934 link_enter_failed(link);
1942 HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1943 log_struct_link(LOG_DEBUG, link,
1944 "MESSAGE=%*s: enslaving by '%s'",
1946 link->ifname, vxlan->ifname, NETDEV(vxlan), NULL);
1948 r = netdev_enslave(vxlan, link, &enslave_handler);
1950 log_struct_link(LOG_WARNING, link,
1951 "MESSAGE=%*s: could not enslave by '%s': %s",
1953 link->ifname, vxlan->ifname, strerror(-r),
1954 NETDEV(vxlan), NULL);
1955 link_enter_failed(link);
1966 static int link_configure(Link *link) {
1970 assert(link->state == LINK_STATE_INITIALIZING);
1972 if (link->network->ipv4ll) {
1975 r = sd_ipv4ll_new(&link->ipv4ll);
1979 if (link->udev_device) {
1980 r = net_get_unique_predictable_data(link->udev_device, seed);
1982 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1988 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1992 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1996 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
2000 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
2005 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
2006 r = sd_dhcp_client_new(&link->dhcp_client);
2010 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
2014 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2018 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
2022 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
2026 if (link->network->dhcp_mtu) {
2027 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
2031 if (link->network->dhcp_routes) {
2032 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
2035 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
2041 if (link->network->dhcp_server) {
2042 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2046 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2051 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
2052 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
2056 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
2061 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
2066 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
2071 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
2072 icmp6_router_handler, link);
2077 if (link_has_carrier(link->flags, link->kernel_operstate)) {
2078 r = link_acquire_conf(link);
2083 return link_enter_enslave(link);
2086 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2087 Link *link = userdata;
2092 assert(link->ifname);
2093 assert(link->manager);
2095 if (link->state != LINK_STATE_INITIALIZING)
2098 log_debug_link(link, "link state is up-to-date");
2100 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2102 link_enter_unmanaged(link);
2107 r = network_apply(link->manager, network, link);
2111 r = link_configure(link);
2118 int link_initialized(Link *link, struct udev_device *device) {
2119 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2123 assert(link->manager);
2124 assert(link->manager->rtnl);
2127 if (link->state != LINK_STATE_INITIALIZING)
2130 log_debug_link(link, "udev initialized link");
2132 link->udev_device = udev_device_ref(device);
2134 /* udev has initialized the link, but we don't know if we have yet processed
2135 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2136 we know that the pending NEWLINKs have already been processed and that we
2139 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2143 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2150 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2151 Manager *m = userdata;
2154 _cleanup_address_free_ Address *address = NULL;
2156 char buf[INET6_ADDRSTRLEN];
2157 bool address_dropped = false;
2164 r = sd_rtnl_message_get_type(message, &type);
2166 log_warning("rtnl: could not get message type");
2170 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2171 if (r < 0 || ifindex <= 0) {
2172 log_warning("rtnl: received address message without valid ifindex, ignoring");
2175 r = link_get(m, ifindex, &link);
2176 if (r < 0 || !link) {
2177 log_warning("rtnl: received address for a nonexistent link, ignoring");
2182 r = address_new_dynamic(&address);
2186 r = sd_rtnl_message_addr_get_family(message, &address->family);
2187 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2188 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2192 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2194 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2198 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2200 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2204 switch (address->family) {
2206 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2208 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2215 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2217 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2224 assert_not_reached("invalid address family");
2227 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2228 log_warning_link(link, "could not print address");
2232 LIST_FOREACH(addresses, ad, link->addresses) {
2233 if (address_equal(ad, address)) {
2234 LIST_REMOVE(addresses, link->addresses, ad);
2238 address_dropped = true;
2246 if (!address_dropped)
2247 log_debug_link(link, "added address: %s/%u", buf,
2248 address->prefixlen);
2250 LIST_PREPEND(addresses, link->addresses, address);
2257 if (address_dropped) {
2258 log_debug_link(link, "removed address: %s/%u", buf,
2259 address->prefixlen);
2266 assert_not_reached("Received invalid RTNL message type");
2272 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2273 Link *link = userdata;
2280 for (; m; m = sd_rtnl_message_next(m)) {
2281 r = sd_rtnl_message_get_errno(m);
2283 log_debug_link(link, "getting address failed: %s", strerror(-r));
2287 r = link_rtnl_process_address(rtnl, m, link->manager);
2289 log_warning_link(link, "could not process address: %s", strerror(-r));
2295 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2297 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2298 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2299 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2307 r = link_new(m, message, ret);
2313 log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2315 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2319 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2323 if (detect_container(NULL) <= 0) {
2324 /* not in a container, udev will be around */
2325 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2326 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2328 log_warning_link(link, "could not find udev device");
2332 if (udev_device_get_is_initialized(device) <= 0) {
2334 log_debug_link(link, "udev initializing link...");
2338 r = link_initialized(link, device);
2342 r = link_initialized_and_synced(m->rtnl, NULL, link);
2350 int link_update(Link *link, sd_rtnl_message *m) {
2351 struct ether_addr mac;
2356 assert(link->ifname);
2359 if (link->state == LINK_STATE_LINGER) {
2361 log_info_link(link, "link readded");
2362 link->state = LINK_STATE_ENSLAVING;
2365 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2366 if (r >= 0 && !streq(ifname, link->ifname)) {
2367 log_info_link(link, "renamed to %s", ifname);
2370 link->ifname = strdup(ifname);
2375 if (!link->original_mtu) {
2376 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2378 log_debug_link(link, "saved original MTU: %"
2379 PRIu16, link->original_mtu);
2382 /* The kernel may broadcast NEWLINK messages without the MAC address
2383 set, simply ignore them. */
2384 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2386 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2388 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2390 log_debug_link(link, "MAC address: "
2391 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2392 mac.ether_addr_octet[0],
2393 mac.ether_addr_octet[1],
2394 mac.ether_addr_octet[2],
2395 mac.ether_addr_octet[3],
2396 mac.ether_addr_octet[4],
2397 mac.ether_addr_octet[5]);
2400 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2402 log_warning_link(link, "Could not update MAC "
2403 "address in IPv4LL client: %s",
2409 if (link->dhcp_client) {
2410 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2412 log_warning_link(link, "Could not update MAC "
2413 "address in DHCP client: %s",
2419 if (link->dhcp6_client) {
2420 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2423 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2431 return link_update_flags(link, m);
2434 static void serialize_addresses(FILE *f, const char *key, Address *address) {
2443 fprintf(f, "%s=", key);
2445 LIST_FOREACH(addresses, ad, address) {
2446 char buf[INET6_ADDRSTRLEN];
2448 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
2449 fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2455 static void link_update_operstate(Link *link) {
2459 if (link->kernel_operstate == IF_OPER_DORMANT)
2460 link->operstate = LINK_OPERSTATE_DORMANT;
2461 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2463 uint8_t scope = RT_SCOPE_NOWHERE;
2465 /* if we have carrier, check what addresses we have */
2466 LIST_FOREACH(addresses, address, link->addresses) {
2467 if (address->scope < scope)
2468 scope = address->scope;
2471 if (scope < RT_SCOPE_SITE)
2472 /* universally accessible addresses found */
2473 link->operstate = LINK_OPERSTATE_ROUTABLE;
2474 else if (scope < RT_SCOPE_HOST)
2475 /* only link or site local addresses found */
2476 link->operstate = LINK_OPERSTATE_DEGRADED;
2478 /* no useful addresses found */
2479 link->operstate = LINK_OPERSTATE_CARRIER;
2481 link->operstate = LINK_OPERSTATE_UNKNOWN;
2484 int link_save(Link *link) {
2485 _cleanup_free_ char *temp_path = NULL;
2486 _cleanup_fclose_ FILE *f = NULL;
2487 const char *admin_state, *oper_state;
2491 assert(link->state_file);
2492 assert(link->lease_file);
2493 assert(link->manager);
2495 link_update_operstate(link);
2497 r = manager_save(link->manager);
2501 if (link->state == LINK_STATE_LINGER) {
2502 unlink(link->state_file);
2506 admin_state = link_state_to_string(link->state);
2507 assert(admin_state);
2509 oper_state = link_operstate_to_string(link->operstate);
2512 r = fopen_temporary(link->state_file, &f, &temp_path);
2516 fchmod(fileno(f), 0644);
2519 "# This is private data. Do not parse.\n"
2523 admin_state, oper_state, link->flags);
2525 if (link->network) {
2526 serialize_addresses(f, "DNS", link->network->dns);
2527 serialize_addresses(f, "NTP", link->network->ntp);
2530 if (link->dhcp_lease) {
2531 assert(link->network);
2533 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2540 "DHCP_USE_NTP=%s\n",
2542 yes_no(link->network->dhcp_dns),
2543 yes_no(link->network->dhcp_ntp));
2545 unlink(link->lease_file);
2549 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2551 unlink(link->state_file);
2557 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2562 static const char* const link_state_table[_LINK_STATE_MAX] = {
2563 [LINK_STATE_INITIALIZING] = "initializing",
2564 [LINK_STATE_ENSLAVING] = "configuring",
2565 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2566 [LINK_STATE_SETTING_ROUTES] = "configuring",
2567 [LINK_STATE_CONFIGURED] = "configured",
2568 [LINK_STATE_UNMANAGED] = "unmanaged",
2569 [LINK_STATE_FAILED] = "failed",
2570 [LINK_STATE_LINGER] = "linger",
2573 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2575 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2576 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2577 [LINK_OPERSTATE_DORMANT] = "dormant",
2578 [LINK_OPERSTATE_CARRIER] = "carrier",
2579 [LINK_OPERSTATE_DEGRADED] = "degraded",
2580 [LINK_OPERSTATE_ROUTABLE] = "routable",
2583 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2585 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2586 [DHCP_SUPPORT_NONE] = "none",
2587 [DHCP_SUPPORT_BOTH] = "both",
2588 [DHCP_SUPPORT_V4] = "v4",
2589 [DHCP_SUPPORT_V6] = "v6",
2592 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2594 int config_parse_dhcp(
2596 const char *filename,
2598 const char *section,
2599 unsigned section_line,
2606 DHCPSupport *dhcp = data;
2614 /* Our enum shall be a superset of booleans, hence first try
2615 * to parse as boolean, and then as enum */
2617 k = parse_boolean(rvalue);
2619 *dhcp = DHCP_SUPPORT_BOTH;
2621 *dhcp = DHCP_SUPPORT_NONE;
2625 s = dhcp_support_from_string(rvalue);
2627 log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);