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;
550 r = route_configure(route_gw, link, &route_handler);
552 log_warning_link(link,
553 "could not set host route: %s", strerror(-r));
558 link->route_messages ++;
560 route->family = AF_INET;
561 route->in_addr.in = gateway;
563 r = route_configure(route, link, &route_handler);
565 log_warning_link(link,
566 "could not set routes: %s", strerror(-r));
567 link_enter_failed(link);
572 link->route_messages ++;
575 if (link->network->dhcp_routes)
576 link_set_dhcp_routes(link);
579 if (link->route_messages == 0) {
580 link_enter_configured(link);
586 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
587 Link *link = userdata;
592 assert(link->ifname);
594 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
599 r = sd_rtnl_message_get_errno(m);
600 if (r < 0 && r != -ESRCH)
601 log_struct_link(LOG_WARNING, link,
602 "MESSAGE=%-*s: could not drop route: %s",
604 link->ifname, strerror(-r),
613 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
614 Link *link = userdata;
619 assert(link->ifname);
620 assert(link->addr_messages > 0);
621 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
622 LINK_STATE_FAILED, LINK_STATE_LINGER));
624 link->addr_messages --;
626 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
631 r = sd_rtnl_message_get_errno(m);
632 if (r < 0 && r != -EEXIST)
633 log_struct_link(LOG_WARNING, link,
634 "MESSAGE=%-*s: could not set address: %s",
636 link->ifname, strerror(-r),
640 if (link->addr_messages == 0) {
641 log_debug_link(link, "addresses set");
642 link_enter_set_routes(link);
650 static int link_enter_set_addresses(Link *link) {
653 uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
656 assert(link->network);
657 assert(link->state != _LINK_STATE_INVALID);
659 link->state = LINK_STATE_SETTING_ADDRESSES;
661 if (!link->network->static_addresses && !link->dhcp_lease &&
662 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
663 return link_enter_set_routes(link);
665 log_debug_link(link, "setting addresses");
667 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
668 r = address_configure(ad, link, &address_handler);
670 log_warning_link(link,
671 "could not set addresses: %s", strerror(-r));
672 link_enter_failed(link);
677 link->addr_messages ++;
680 if (link->ipv4ll && !link->dhcp_lease) {
681 _cleanup_address_free_ Address *ll_addr = NULL;
684 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
685 if (r < 0 && r != -ENOENT) {
686 log_warning_link(link, "IPV4LL error: no address: %s",
692 r = address_new_dynamic(&ll_addr);
694 log_error_link(link, "Could not allocate address: %s", strerror(-r));
698 ll_addr->family = AF_INET;
699 ll_addr->in_addr.in = addr;
700 ll_addr->prefixlen = 16;
701 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
702 ll_addr->scope = RT_SCOPE_LINK;
704 r = address_configure(ll_addr, link, &address_handler);
706 log_warning_link(link,
707 "could not set addresses: %s", strerror(-r));
708 link_enter_failed(link);
713 link->addr_messages ++;
717 if (link->dhcp_lease) {
718 _cleanup_address_free_ Address *address = NULL;
720 struct in_addr netmask;
723 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
725 log_warning_link(link, "DHCP error: no address: %s",
730 if (!link->network->dhcp_critical) {
731 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
734 log_warning_link(link, "DHCP error: no lifetime: %s",
740 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
742 log_warning_link(link, "DHCP error: no netmask: %s",
747 prefixlen = net_netmask_to_prefixlen(&netmask);
749 r = address_new_dynamic(&address);
751 log_error_link(link, "Could not allocate address: %s",
756 address->family = AF_INET;
757 address->in_addr.in = addr;
758 address->cinfo.ifa_prefered = lifetime;
759 address->cinfo.ifa_valid = lifetime;
760 address->prefixlen = prefixlen;
761 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
763 r = address_configure(address, link, &address_handler);
765 log_warning_link(link,
766 "could not set addresses: %s", strerror(-r));
767 link_enter_failed(link);
772 link->addr_messages ++;
778 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
779 Link *link = userdata;
784 assert(link->ifname);
786 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
791 r = sd_rtnl_message_get_errno(m);
792 if (r < 0 && r != -ENOENT)
793 log_struct_link(LOG_WARNING, link,
794 "MESSAGE=%-*s: could not update address: %s",
796 link->ifname, strerror(-r),
805 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
806 Link *link = userdata;
811 assert(link->ifname);
813 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
818 r = sd_rtnl_message_get_errno(m);
819 if (r < 0 && r != -EADDRNOTAVAIL)
820 log_struct_link(LOG_WARNING, link,
821 "MESSAGE=%-*s: could not drop address: %s",
823 link->ifname, strerror(-r),
832 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
833 Link *link = userdata;
838 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
843 r = sd_bus_message_get_errno(m);
845 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
852 static int link_set_hostname(Link *link, const char *hostname) {
853 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
857 assert(link->manager);
860 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
862 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
863 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
867 r = sd_bus_message_new_method_call(
870 "org.freedesktop.hostname1",
871 "/org/freedesktop/hostname1",
872 "org.freedesktop.hostname1",
877 r = sd_bus_message_append(m, "sb", hostname, false);
881 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
883 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
890 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
891 Link *link = userdata;
896 assert(link->ifname);
898 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
903 r = sd_rtnl_message_get_errno(m);
905 log_struct_link(LOG_WARNING, link,
906 "MESSAGE=%-*s: could not set MTU: %s",
907 IFNAMSIZ, link->ifname, strerror(-r),
916 static int link_set_mtu(Link *link, uint32_t mtu) {
917 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
921 assert(link->manager);
922 assert(link->manager->rtnl);
924 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
926 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
927 RTM_SETLINK, link->ifindex);
929 log_error_link(link, "Could not allocate RTM_SETLINK message");
933 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
935 log_error_link(link, "Could not append MTU: %s", strerror(-r));
939 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
942 "Could not send rtnetlink message: %s", strerror(-r));
951 static int dhcp_lease_lost(Link *link) {
952 _cleanup_address_free_ Address *address = NULL;
954 struct in_addr netmask;
955 struct in_addr gateway;
961 assert(link->dhcp_lease);
963 log_warning_link(link, "DHCP lease lost");
965 if (link->network->dhcp_routes) {
966 struct sd_dhcp_route *routes;
969 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes, &routes_size);
971 for (i = 0; i < routes_size; i++) {
972 _cleanup_route_free_ Route *route = NULL;
974 r = route_new_dynamic(&route);
976 route->family = AF_INET;
977 route->in_addr.in = routes[i].gw_addr;
978 route->dst_addr.in = routes[i].dst_addr;
979 route->dst_prefixlen = routes[i].dst_prefixlen;
981 route_drop(route, link, &route_drop_handler);
988 r = address_new_dynamic(&address);
990 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
992 _cleanup_route_free_ Route *route_gw = NULL;
993 _cleanup_route_free_ Route *route = NULL;
995 r = route_new_dynamic(&route_gw);
997 route_gw->family = AF_INET;
998 route_gw->dst_addr.in = gateway;
999 route_gw->dst_prefixlen = 32;
1000 route_gw->scope = RT_SCOPE_LINK;
1002 route_drop(route_gw, link, &route_drop_handler);
1006 r = route_new_dynamic(&route);
1008 route->family = AF_INET;
1009 route->in_addr.in = gateway;
1011 route_drop(route, link, &route_drop_handler);
1016 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
1017 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
1018 prefixlen = net_netmask_to_prefixlen(&netmask);
1020 address->family = AF_INET;
1021 address->in_addr.in = addr;
1022 address->prefixlen = prefixlen;
1024 address_drop(address, link, &address_drop_handler);
1028 if (link->network->dhcp_mtu) {
1031 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1032 if (r >= 0 && link->original_mtu != mtu) {
1033 r = link_set_mtu(link, link->original_mtu);
1035 log_warning_link(link, "DHCP error: could not reset MTU");
1036 link_enter_failed(link);
1042 if (link->network->dhcp_hostname) {
1043 const char *hostname = NULL;
1045 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1046 if (r >= 0 && hostname) {
1047 r = link_set_hostname(link, "");
1049 log_error_link(link, "Failed to reset transient hostname");
1053 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1058 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1059 sd_dhcp_lease *lease;
1062 r = sd_dhcp_client_get_lease(client, &lease);
1064 log_warning_link(link, "DHCP error: no lease %s",
1069 sd_dhcp_lease_unref(link->dhcp_lease);
1070 link->dhcp_lease = lease;
1072 link_enter_set_addresses(link);
1077 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1078 sd_dhcp_lease *lease;
1079 struct in_addr address;
1080 struct in_addr netmask;
1081 struct in_addr gateway;
1088 r = sd_dhcp_client_get_lease(client, &lease);
1090 log_warning_link(link, "DHCP error: no lease: %s",
1095 r = sd_dhcp_lease_get_address(lease, &address);
1097 log_warning_link(link, "DHCP error: no address: %s",
1102 r = sd_dhcp_lease_get_netmask(lease, &netmask);
1104 log_warning_link(link, "DHCP error: no netmask: %s",
1109 prefixlen = net_netmask_to_prefixlen(&netmask);
1111 r = sd_dhcp_lease_get_router(lease, &gateway);
1112 if (r < 0 && r != -ENOENT) {
1113 log_warning_link(link, "DHCP error: could not get gateway: %s",
1119 log_struct_link(LOG_INFO, link,
1120 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1123 ADDRESS_FMT_VAL(address),
1125 ADDRESS_FMT_VAL(gateway),
1126 "ADDRESS=%u.%u.%u.%u",
1127 ADDRESS_FMT_VAL(address),
1130 "GATEWAY=%u.%u.%u.%u",
1131 ADDRESS_FMT_VAL(gateway),
1134 log_struct_link(LOG_INFO, link,
1135 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1138 ADDRESS_FMT_VAL(address),
1140 "ADDRESS=%u.%u.%u.%u",
1141 ADDRESS_FMT_VAL(address),
1146 link->dhcp_lease = lease;
1148 if (link->network->dhcp_mtu) {
1151 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1153 r = link_set_mtu(link, mtu);
1155 log_error_link(link, "Failed to set MTU "
1156 "to %" PRIu16, mtu);
1160 if (link->network->dhcp_hostname) {
1161 const char *hostname;
1163 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1165 r = link_set_hostname(link, hostname);
1167 log_error_link(link, "Failed to set transient hostname "
1168 "to '%s'", hostname);
1172 link_enter_set_addresses(link);
1177 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1178 Link *link = userdata;
1182 assert(link->network);
1183 assert(link->manager);
1185 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1189 case DHCP_EVENT_NO_LEASE:
1190 log_debug_link(link, "IP address in use.");
1192 case DHCP_EVENT_EXPIRED:
1193 case DHCP_EVENT_STOP:
1194 case DHCP_EVENT_IP_CHANGE:
1195 if (link->network->dhcp_critical) {
1196 log_error_link(link, "DHCPv4 connection considered system critical, "
1197 "ignoring request to reconfigure it.");
1201 if (link->dhcp_lease) {
1202 r = dhcp_lease_lost(link);
1204 link_enter_failed(link);
1209 if (event == DHCP_EVENT_IP_CHANGE) {
1210 r = dhcp_lease_acquired(client, link);
1212 link_enter_failed(link);
1217 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1218 if (!sd_ipv4ll_is_running(link->ipv4ll))
1219 r = sd_ipv4ll_start(link->ipv4ll);
1220 else if (ipv4ll_is_bound(link->ipv4ll))
1221 r = ipv4ll_address_update(link, false);
1223 link_enter_failed(link);
1229 case DHCP_EVENT_RENEW:
1230 r = dhcp_lease_renew(client, link);
1232 link_enter_failed(link);
1236 case DHCP_EVENT_IP_ACQUIRE:
1237 r = dhcp_lease_acquired(client, link);
1239 link_enter_failed(link);
1243 if (ipv4ll_is_bound(link->ipv4ll))
1244 r = ipv4ll_address_update(link, true);
1246 r = sd_ipv4ll_stop(link->ipv4ll);
1248 link_enter_failed(link);
1255 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1257 log_warning_link(link, "DHCP unknown event: %d", event);
1264 static int ipv4ll_address_update(Link *link, bool deprecate) {
1266 struct in_addr addr;
1270 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1272 _cleanup_address_free_ Address *address = NULL;
1274 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1275 deprecate ? "deprecate" : "approve",
1276 ADDRESS_FMT_VAL(addr));
1278 r = address_new_dynamic(&address);
1280 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1284 address->family = AF_INET;
1285 address->in_addr.in = addr;
1286 address->prefixlen = 16;
1287 address->scope = RT_SCOPE_LINK;
1288 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1289 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1291 address_update(address, link, &address_update_handler);
1299 static int ipv4ll_address_lost(Link *link) {
1301 struct in_addr addr;
1305 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1307 _cleanup_address_free_ Address *address = NULL;
1308 _cleanup_route_free_ Route *route = NULL;
1310 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1311 ADDRESS_FMT_VAL(addr));
1313 r = address_new_dynamic(&address);
1315 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1319 address->family = AF_INET;
1320 address->in_addr.in = addr;
1321 address->prefixlen = 16;
1322 address->scope = RT_SCOPE_LINK;
1324 address_drop(address, link, &address_drop_handler);
1327 r = route_new_dynamic(&route);
1329 log_error_link(link, "Could not allocate route: %s",
1334 route->family = AF_INET;
1335 route->scope = RT_SCOPE_LINK;
1336 route->metrics = 99;
1338 route_drop(route, link, &route_drop_handler);
1345 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1347 struct in_addr addr;
1351 r = sd_ipv4ll_get_address(ll, &addr);
1357 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1358 struct in_addr address;
1364 r = sd_ipv4ll_get_address(ll, &address);
1368 log_struct_link(LOG_INFO, link,
1369 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1372 ADDRESS_FMT_VAL(address),
1375 link_enter_set_addresses(link);
1380 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1381 Link *link = userdata;
1385 assert(link->network);
1386 assert(link->manager);
1388 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1392 case IPV4LL_EVENT_STOP:
1393 case IPV4LL_EVENT_CONFLICT:
1394 r = ipv4ll_address_lost(link);
1396 link_enter_failed(link);
1400 case IPV4LL_EVENT_BIND:
1401 r = ipv4ll_address_claimed(ll, link);
1403 link_enter_failed(link);
1409 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1411 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1416 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1417 Link *link = userdata;
1420 assert(link->network);
1421 assert(link->manager);
1423 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1427 case DHCP6_EVENT_STOP:
1428 case DHCP6_EVENT_RESEND_EXPIRE:
1429 case DHCP6_EVENT_RETRANS_MAX:
1430 case DHCP6_EVENT_IP_ACQUIRE:
1431 log_debug_link(link, "DHCPv6 event %d", event);
1437 log_warning_link(link, "DHCPv6 error: %s",
1440 log_warning_link(link, "DHCPv6 unknown event: %d",
1446 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1447 Link *link = userdata;
1451 assert(link->network);
1452 assert(link->manager);
1454 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1458 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1459 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1462 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1463 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1468 log_warning_link(link, "ICMPv6 error: %s",
1471 log_warning_link(link, "ICMPv6 unknown event: %d",
1477 if (link->dhcp6_client)
1480 r = sd_dhcp6_client_new(&link->dhcp6_client);
1484 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1486 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1490 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1492 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1496 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1498 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1502 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1505 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1509 r = sd_dhcp6_client_start(link->dhcp6_client);
1511 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1514 static int link_acquire_conf(Link *link) {
1518 assert(link->network);
1519 assert(link->manager);
1520 assert(link->manager->event);
1522 if (link->network->ipv4ll) {
1523 assert(link->ipv4ll);
1525 log_debug_link(link, "acquiring IPv4 link-local address");
1527 r = sd_ipv4ll_start(link->ipv4ll);
1529 log_warning_link(link, "could not acquire IPv4 "
1530 "link-local address");
1535 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1536 assert(link->dhcp_client);
1538 log_debug_link(link, "acquiring DHCPv4 lease");
1540 r = sd_dhcp_client_start(link->dhcp_client);
1542 log_warning_link(link, "could not acquire DHCPv4 "
1548 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1549 assert(link->icmp6_router_discovery);
1551 log_debug_link(link, "discovering IPv6 routers");
1553 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1555 log_warning_link(link, "could not start IPv6 router discovery");
1563 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1564 /* see Documentation/networking/operstates.txt in the kernel sources */
1566 if (operstate == IF_OPER_UP)
1569 if (operstate == IF_OPER_UNKNOWN)
1570 /* operstate may not be implemented, so fall back to flags */
1571 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1577 #define FLAG_STRING(string, flag, old, new) \
1578 (((old ^ new) & flag) \
1579 ? ((old & flag) ? (" -" string) : (" +" string)) \
1582 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1583 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1585 bool carrier_gained = false, carrier_lost = false;
1590 r = sd_rtnl_message_link_get_flags(m, &flags);
1592 log_warning_link(link, "Could not get link flags");
1596 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1598 /* if we got a message without operstate, take it to mean
1599 the state was unchanged */
1600 operstate = link->kernel_operstate;
1602 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1605 if (link->flags != flags) {
1606 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",
1607 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1608 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1609 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1610 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1611 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1612 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1613 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1614 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1615 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1616 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1617 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1618 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1619 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1620 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1621 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1622 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1623 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1624 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1625 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1627 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1628 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1629 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1630 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1631 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1632 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1633 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1634 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1636 /* link flags are currently at most 18 bits, let's align to printing 20 */
1637 if (unknown_flags_added)
1638 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1639 unknown_flags_added);
1641 if (unknown_flags_removed)
1642 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1643 unknown_flags_removed);
1646 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1647 link_has_carrier(flags, operstate);
1648 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1649 !link_has_carrier(flags, operstate);
1651 link->flags = flags;
1652 link->kernel_operstate = operstate;
1656 if (link->state == LINK_STATE_FAILED ||
1657 link->state == LINK_STATE_UNMANAGED)
1660 if (carrier_gained) {
1661 log_info_link(link, "gained carrier");
1663 if (link->network) {
1664 r = link_acquire_conf(link);
1666 link_enter_failed(link);
1670 } else if (carrier_lost) {
1671 log_info_link(link, "lost carrier");
1673 r = link_stop_clients(link);
1675 link_enter_failed(link);
1683 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1684 Link *link = userdata;
1689 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1694 r = sd_rtnl_message_get_errno(m);
1696 /* we warn but don't fail the link, as it may
1697 be brought up later */
1698 log_struct_link(LOG_WARNING, link,
1699 "MESSAGE=%-*s: could not bring up interface: %s",
1701 link->ifname, strerror(-r),
1711 static int link_up(Link *link) {
1712 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1716 assert(link->manager);
1717 assert(link->manager->rtnl);
1719 log_debug_link(link, "bringing link up");
1721 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1722 RTM_SETLINK, link->ifindex);
1724 log_error_link(link, "Could not allocate RTM_SETLINK message");
1728 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1730 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1734 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1736 log_error_link(link,
1737 "Could not send rtnetlink message: %s", strerror(-r));
1746 static int link_enslaved(Link *link) {
1750 assert(link->state == LINK_STATE_ENSLAVING);
1751 assert(link->network);
1753 if (!(link->flags & IFF_UP)) {
1756 link_enter_failed(link);
1761 return link_enter_set_addresses(link);
1764 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1765 Link *link = userdata;
1769 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1770 LINK_STATE_LINGER));
1771 assert(link->network);
1775 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1780 r = sd_rtnl_message_get_errno(m);
1782 log_struct_link(LOG_ERR, link,
1783 "MESSAGE=%-*s: could not enslave: %s",
1785 link->ifname, strerror(-r),
1788 link_enter_failed(link);
1793 log_debug_link(link, "enslaved");
1795 if (link->enslaving == 0)
1796 link_enslaved(link);
1803 static int link_enter_enslave(Link *link) {
1804 NetDev *vlan, *macvlan, *vxlan;
1809 assert(link->network);
1810 assert(link->state == LINK_STATE_INITIALIZING);
1812 link->state = LINK_STATE_ENSLAVING;
1816 if (!link->network->bridge &&
1817 !link->network->bond &&
1818 !link->network->tunnel &&
1819 hashmap_isempty(link->network->vlans) &&
1820 hashmap_isempty(link->network->macvlans) &&
1821 hashmap_isempty(link->network->vxlans))
1822 return link_enslaved(link);
1824 if (link->network->bond) {
1825 log_struct_link(LOG_DEBUG, link,
1826 "MESSAGE=%-*s: enslaving by '%s'",
1828 link->ifname, link->network->bond->ifname,
1829 NETDEV(link->network->bond),
1832 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1834 log_struct_link(LOG_WARNING, link,
1835 "MESSAGE=%-*s: could not enslave by '%s': %s",
1837 link->ifname, link->network->bond->ifname, strerror(-r),
1838 NETDEV(link->network->bond),
1840 link_enter_failed(link);
1848 if (link->network->bridge) {
1849 log_struct_link(LOG_DEBUG, link,
1850 "MESSAGE=%-*s: enslaving by '%s'",
1852 link->ifname, link->network->bridge->ifname,
1853 NETDEV(link->network->bridge),
1856 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1858 log_struct_link(LOG_WARNING, link,
1859 "MESSAGE=%-*s: could not enslave by '%s': %s",
1861 link->ifname, link->network->bridge->ifname, strerror(-r),
1862 NETDEV(link->network->bridge),
1864 link_enter_failed(link);
1872 if (link->network->tunnel) {
1873 log_struct_link(LOG_DEBUG, link,
1874 "MESSAGE=%-*s: enslaving by '%s'",
1876 link->ifname, link->network->tunnel->ifname,
1877 NETDEV(link->network->tunnel),
1880 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1882 log_struct_link(LOG_WARNING, link,
1883 "MESSAGE=%-*s: could not enslave by '%s': %s",
1885 link->ifname, link->network->tunnel->ifname, strerror(-r),
1886 NETDEV(link->network->tunnel),
1888 link_enter_failed(link);
1896 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1897 log_struct_link(LOG_DEBUG, link,
1898 "MESSAGE=%-*s: enslaving by '%s'",
1900 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1902 r = netdev_enslave(vlan, link, &enslave_handler);
1904 log_struct_link(LOG_WARNING, link,
1905 "MESSAGE=%-*s: could not enslave by '%s': %s",
1907 link->ifname, vlan->ifname, strerror(-r),
1908 NETDEV(vlan), NULL);
1909 link_enter_failed(link);
1917 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1918 log_struct_link(LOG_DEBUG, link,
1919 "MESSAGE=%-*s: enslaving by '%s'",
1921 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1923 r = netdev_enslave(macvlan, link, &enslave_handler);
1925 log_struct_link(LOG_WARNING, link,
1926 "MESSAGE=%-*s: could not enslave by '%s': %s",
1928 link->ifname, macvlan->ifname, strerror(-r),
1929 NETDEV(macvlan), NULL);
1930 link_enter_failed(link);
1938 HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1939 log_struct_link(LOG_DEBUG, link,
1940 "MESSAGE=%*s: enslaving by '%s'",
1942 link->ifname, vxlan->ifname, NETDEV(vxlan), NULL);
1944 r = netdev_enslave(vxlan, link, &enslave_handler);
1946 log_struct_link(LOG_WARNING, link,
1947 "MESSAGE=%*s: could not enslave by '%s': %s",
1949 link->ifname, vxlan->ifname, strerror(-r),
1950 NETDEV(vxlan), NULL);
1951 link_enter_failed(link);
1962 static int link_configure(Link *link) {
1966 assert(link->state == LINK_STATE_INITIALIZING);
1968 if (link->network->ipv4ll) {
1971 r = sd_ipv4ll_new(&link->ipv4ll);
1975 if (link->udev_device) {
1976 r = net_get_unique_predictable_data(link->udev_device, seed);
1978 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1984 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1988 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1992 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1996 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
2001 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
2002 r = sd_dhcp_client_new(&link->dhcp_client);
2006 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
2010 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2014 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
2018 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
2022 if (link->network->dhcp_mtu) {
2023 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
2027 if (link->network->dhcp_routes) {
2028 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
2031 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
2037 if (link->network->dhcp_server) {
2038 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2042 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2047 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
2048 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
2052 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
2057 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
2062 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
2067 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
2068 icmp6_router_handler, link);
2073 if (link_has_carrier(link->flags, link->kernel_operstate)) {
2074 r = link_acquire_conf(link);
2079 return link_enter_enslave(link);
2082 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2083 Link *link = userdata;
2088 assert(link->ifname);
2089 assert(link->manager);
2091 if (link->state != LINK_STATE_INITIALIZING)
2094 log_debug_link(link, "link state is up-to-date");
2096 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2098 link_enter_unmanaged(link);
2103 r = network_apply(link->manager, network, link);
2107 r = link_configure(link);
2114 int link_initialized(Link *link, struct udev_device *device) {
2115 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2119 assert(link->manager);
2120 assert(link->manager->rtnl);
2123 if (link->state != LINK_STATE_INITIALIZING)
2126 log_debug_link(link, "udev initialized link");
2128 link->udev_device = udev_device_ref(device);
2130 /* udev has initialized the link, but we don't know if we have yet processed
2131 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2132 we know that the pending NEWLINKs have already been processed and that we
2135 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2139 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2146 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2147 Manager *m = userdata;
2150 _cleanup_address_free_ Address *address = NULL;
2152 char buf[INET6_ADDRSTRLEN];
2153 bool address_dropped = false;
2160 r = sd_rtnl_message_get_type(message, &type);
2162 log_warning("rtnl: could not get message type");
2166 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2167 if (r < 0 || ifindex <= 0) {
2168 log_warning("rtnl: received address message without valid ifindex, ignoring");
2171 r = link_get(m, ifindex, &link);
2172 if (r < 0 || !link) {
2173 log_warning("rtnl: received address for a nonexistent link, ignoring");
2178 r = address_new_dynamic(&address);
2182 r = sd_rtnl_message_addr_get_family(message, &address->family);
2183 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2184 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2188 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2190 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2194 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2196 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2200 switch (address->family) {
2202 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2204 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2211 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2213 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2220 assert_not_reached("invalid address family");
2223 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2224 log_warning_link(link, "could not print address");
2228 LIST_FOREACH(addresses, ad, link->addresses) {
2229 if (address_equal(ad, address)) {
2230 LIST_REMOVE(addresses, link->addresses, ad);
2234 address_dropped = true;
2242 if (!address_dropped)
2243 log_debug_link(link, "added address: %s/%u", buf,
2244 address->prefixlen);
2246 LIST_PREPEND(addresses, link->addresses, address);
2253 if (address_dropped) {
2254 log_debug_link(link, "removed address: %s/%u", buf,
2255 address->prefixlen);
2262 assert_not_reached("Received invalid RTNL message type");
2268 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2269 Link *link = userdata;
2276 for (; m; m = sd_rtnl_message_next(m)) {
2277 r = sd_rtnl_message_get_errno(m);
2279 log_debug_link(link, "getting address failed: %s", strerror(-r));
2283 r = link_rtnl_process_address(rtnl, m, link->manager);
2285 log_warning_link(link, "could not process address: %s", strerror(-r));
2291 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2293 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2294 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2295 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2303 r = link_new(m, message, ret);
2309 log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2311 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2315 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2319 if (detect_container(NULL) <= 0) {
2320 /* not in a container, udev will be around */
2321 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2322 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2324 log_warning_link(link, "could not find udev device");
2328 if (udev_device_get_is_initialized(device) <= 0) {
2330 log_debug_link(link, "udev initializing link...");
2334 r = link_initialized(link, device);
2338 r = link_initialized_and_synced(m->rtnl, NULL, link);
2346 int link_update(Link *link, sd_rtnl_message *m) {
2347 struct ether_addr mac;
2352 assert(link->ifname);
2355 if (link->state == LINK_STATE_LINGER) {
2357 log_info_link(link, "link readded");
2358 link->state = LINK_STATE_ENSLAVING;
2361 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2362 if (r >= 0 && !streq(ifname, link->ifname)) {
2363 log_info_link(link, "renamed to %s", ifname);
2366 link->ifname = strdup(ifname);
2371 if (!link->original_mtu) {
2372 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2374 log_debug_link(link, "saved original MTU: %"
2375 PRIu16, link->original_mtu);
2378 /* The kernel may broadcast NEWLINK messages without the MAC address
2379 set, simply ignore them. */
2380 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2382 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2384 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2386 log_debug_link(link, "MAC address: "
2387 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2388 mac.ether_addr_octet[0],
2389 mac.ether_addr_octet[1],
2390 mac.ether_addr_octet[2],
2391 mac.ether_addr_octet[3],
2392 mac.ether_addr_octet[4],
2393 mac.ether_addr_octet[5]);
2396 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2398 log_warning_link(link, "Could not update MAC "
2399 "address in IPv4LL client: %s",
2405 if (link->dhcp_client) {
2406 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2408 log_warning_link(link, "Could not update MAC "
2409 "address in DHCP client: %s",
2415 if (link->dhcp6_client) {
2416 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2419 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2427 return link_update_flags(link, m);
2430 static void serialize_addresses(FILE *f, const char *key, Address *address) {
2439 fprintf(f, "%s=", key);
2441 LIST_FOREACH(addresses, ad, address) {
2442 char buf[INET6_ADDRSTRLEN];
2444 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
2445 fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2451 static void link_update_operstate(Link *link) {
2455 if (link->kernel_operstate == IF_OPER_DORMANT)
2456 link->operstate = LINK_OPERSTATE_DORMANT;
2457 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2459 uint8_t scope = RT_SCOPE_NOWHERE;
2461 /* if we have carrier, check what addresses we have */
2462 LIST_FOREACH(addresses, address, link->addresses) {
2463 if (address->scope < scope)
2464 scope = address->scope;
2467 if (scope < RT_SCOPE_SITE)
2468 /* universally accessible addresses found */
2469 link->operstate = LINK_OPERSTATE_ROUTABLE;
2470 else if (scope < RT_SCOPE_HOST)
2471 /* only link or site local addresses found */
2472 link->operstate = LINK_OPERSTATE_DEGRADED;
2474 /* no useful addresses found */
2475 link->operstate = LINK_OPERSTATE_CARRIER;
2477 link->operstate = LINK_OPERSTATE_UNKNOWN;
2480 int link_save(Link *link) {
2481 _cleanup_free_ char *temp_path = NULL;
2482 _cleanup_fclose_ FILE *f = NULL;
2483 const char *admin_state, *oper_state;
2487 assert(link->state_file);
2488 assert(link->lease_file);
2489 assert(link->manager);
2491 link_update_operstate(link);
2493 r = manager_save(link->manager);
2497 if (link->state == LINK_STATE_LINGER) {
2498 unlink(link->state_file);
2502 admin_state = link_state_to_string(link->state);
2503 assert(admin_state);
2505 oper_state = link_operstate_to_string(link->operstate);
2508 r = fopen_temporary(link->state_file, &f, &temp_path);
2512 fchmod(fileno(f), 0644);
2515 "# This is private data. Do not parse.\n"
2519 admin_state, oper_state, link->flags);
2521 if (link->network) {
2522 serialize_addresses(f, "DNS", link->network->dns);
2523 serialize_addresses(f, "NTP", link->network->ntp);
2526 if (link->dhcp_lease) {
2527 assert(link->network);
2529 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2536 "DHCP_USE_NTP=%s\n",
2538 yes_no(link->network->dhcp_dns),
2539 yes_no(link->network->dhcp_ntp));
2541 unlink(link->lease_file);
2545 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2547 unlink(link->state_file);
2553 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2558 static const char* const link_state_table[_LINK_STATE_MAX] = {
2559 [LINK_STATE_INITIALIZING] = "initializing",
2560 [LINK_STATE_ENSLAVING] = "configuring",
2561 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2562 [LINK_STATE_SETTING_ROUTES] = "configuring",
2563 [LINK_STATE_CONFIGURED] = "configured",
2564 [LINK_STATE_UNMANAGED] = "unmanaged",
2565 [LINK_STATE_FAILED] = "failed",
2566 [LINK_STATE_LINGER] = "linger",
2569 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2571 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2572 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2573 [LINK_OPERSTATE_DORMANT] = "dormant",
2574 [LINK_OPERSTATE_CARRIER] = "carrier",
2575 [LINK_OPERSTATE_DEGRADED] = "degraded",
2576 [LINK_OPERSTATE_ROUTABLE] = "routable",
2579 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2581 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2582 [DHCP_SUPPORT_NONE] = "none",
2583 [DHCP_SUPPORT_BOTH] = "both",
2584 [DHCP_SUPPORT_V4] = "v4",
2585 [DHCP_SUPPORT_V6] = "v6",
2588 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2590 int config_parse_dhcp(
2592 const char *filename,
2594 const char *section,
2595 unsigned section_line,
2602 DHCPSupport *dhcp = data;
2610 /* Our enum shall be a superset of booleans, hence first try
2611 * to parse as boolean, and then as enum */
2613 k = parse_boolean(rvalue);
2615 *dhcp = DHCP_SUPPORT_BOTH;
2617 *dhcp = DHCP_SUPPORT_NONE;
2621 s = dhcp_support_from_string(rvalue);
2623 log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);