1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Tom Gundersen <teg@jklm.no>
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <netinet/ether.h>
27 #include "networkd-netdev.h"
28 #include "libudev-private.h"
29 #include "udev-util.h"
33 #include "network-internal.h"
34 #include "conf-parser.h"
36 #include "dhcp-lease-internal.h"
38 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
39 _cleanup_link_unref_ Link *link = NULL;
48 r = sd_rtnl_message_get_type(message, &type);
51 else if (type != RTM_NEWLINK)
54 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
57 else if (ifindex <= 0)
60 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
69 link->manager = manager;
70 link->state = LINK_STATE_INITIALIZING;
71 link->ifindex = ifindex;
72 link->ifname = strdup(ifname);
76 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
78 log_debug_link(link, "MAC address not found for new device, continuing without");
80 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d", link->ifindex);
84 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d", link->ifindex);
88 r = hashmap_ensure_allocated(&manager->links, NULL, NULL);
92 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
102 static void link_free(Link *link) {
108 while ((address = link->addresses)) {
109 LIST_REMOVE(addresses, link->addresses, address);
110 address_free(address);
113 while ((address = link->pool_addresses)) {
114 LIST_REMOVE(addresses, link->pool_addresses, address);
115 address_free(address);
118 sd_dhcp_client_unref(link->dhcp_client);
119 sd_dhcp_lease_unref(link->dhcp_lease);
121 unlink(link->lease_file);
122 free(link->lease_file);
124 sd_ipv4ll_unref(link->ipv4ll);
125 sd_dhcp6_client_unref(link->dhcp6_client);
126 sd_icmp6_nd_unref(link->icmp6_router_discovery);
129 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
133 unlink(link->state_file);
134 free(link->state_file);
136 udev_device_unref(link->udev_device);
141 Link *link_unref(Link *link) {
142 if (link && (-- link->n_ref <= 0))
148 Link *link_ref(Link *link) {
150 assert_se(++ link->n_ref >= 2);
155 int link_get(Manager *m, int ifindex, Link **ret) {
162 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
171 void link_drop(Link *link) {
172 if (!link || link->state == LINK_STATE_LINGER)
175 link->state = LINK_STATE_LINGER;
177 log_debug_link(link, "link removed");
184 static void link_enter_unmanaged(Link *link) {
187 log_debug_link(link, "unmanaged");
189 link->state = LINK_STATE_UNMANAGED;
194 static int link_stop_clients(Link *link) {
198 assert(link->manager);
199 assert(link->manager->event);
204 if (link->dhcp_client) {
205 k = sd_dhcp_client_stop(link->dhcp_client);
207 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
213 k = sd_ipv4ll_stop(link->ipv4ll);
215 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
220 if (link->dhcp_server) {
221 k = sd_dhcp_server_stop(link->dhcp_server);
223 log_warning_link(link, "Could not stop DHCPv4 server: %s", strerror(-r));
228 if(link->icmp6_router_discovery) {
230 if (link->dhcp6_client) {
231 k = sd_dhcp6_client_stop(link->dhcp6_client);
233 log_warning_link(link, "Could not stop DHCPv6 client: %s", strerror(-r));
238 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
240 log_warning_link(link, "Could not stop ICMPv6 router discovery: %s", strerror(-r));
248 static void link_enter_failed(Link *link) {
251 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
254 log_warning_link(link, "failed");
256 link->state = LINK_STATE_FAILED;
258 link_stop_clients(link);
263 static Address* link_find_dhcp_server_address(Link *link) {
267 assert(link->network);
269 /* The the first statically configured address if there is any */
270 LIST_FOREACH(addresses, address, link->network->static_addresses) {
272 if (address->family != AF_INET)
275 if (in_addr_is_null(address->family, &address->in_addr))
281 /* If that didn't work, find a suitable address we got from the pool */
282 LIST_FOREACH(addresses, address, link->pool_addresses) {
283 if (address->family != AF_INET)
292 static int link_enter_configured(Link *link) {
296 assert(link->network);
297 assert(link->state == LINK_STATE_SETTING_ROUTES);
299 if (link->network->dhcp_server &&
300 !sd_dhcp_server_is_running(link->dhcp_server)) {
301 struct in_addr pool_start;
304 address = link_find_dhcp_server_address(link);
306 log_warning_link(link, "Failed to find suitable address for DHCPv4 server instance.");
307 link_enter_failed(link);
311 log_debug_link(link, "offering DHCPv4 leases");
313 r = sd_dhcp_server_set_address(link->dhcp_server, &address->in_addr.in, address->prefixlen);
317 /* offer 32 addresses starting from the address following the server address */
318 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
319 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
325 r = sd_dhcp_server_set_router(link->dhcp_server,
326 &main_address->in_addr.in);
330 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
331 main_address->prefixlen);
336 r = sd_dhcp_server_start(link->dhcp_server);
338 log_warning_link(link, "could not start DHCPv4 server "
339 "instance: %s", strerror(-r));
341 link_enter_failed(link);
347 log_info_link(link, "link configured");
349 link->state = LINK_STATE_CONFIGURED;
356 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
357 _cleanup_link_unref_ Link *link = userdata;
360 assert(link->route_messages > 0);
361 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
362 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
365 link->route_messages --;
367 if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER))
370 r = sd_rtnl_message_get_errno(m);
371 if (r < 0 && r != -EEXIST)
372 log_struct_link(LOG_WARNING, link,
373 "MESSAGE=%-*s: could not set route: %s",
375 link->ifname, strerror(-r),
379 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
381 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
382 log_debug_link(link, "routes set");
383 link_enter_configured(link);
389 static int link_set_dhcp_routes(Link *link) {
390 struct sd_dhcp_route *static_routes;
395 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes);
398 log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-n));
402 for (i = 0; i < n; i++) {
403 _cleanup_route_free_ Route *route = NULL;
405 r = route_new_dynamic(&route, RTPROT_DHCP);
407 log_error_link(link, "Could not allocate route: %s",
412 route->family = AF_INET;
413 route->in_addr.in = static_routes[i].gw_addr;
414 route->dst_addr.in = static_routes[i].dst_addr;
415 route->dst_prefixlen = static_routes[i].dst_prefixlen;
416 route->metrics = DHCP_ROUTE_METRIC;
418 r = route_configure(route, link, &route_handler);
420 log_warning_link(link,
421 "could not set host route: %s", strerror(-r));
425 link->route_messages ++;
431 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
438 r = sd_ipv4ll_get_address(ll, &addr);
445 static int link_enter_set_routes(Link *link) {
450 assert(link->network);
451 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
453 link->state = LINK_STATE_SETTING_ROUTES;
455 if (!link->network->static_routes &&
457 !ipv4ll_is_bound(link->ipv4ll))
458 return link_enter_configured(link);
460 log_debug_link(link, "setting routes");
462 LIST_FOREACH(routes, rt, link->network->static_routes) {
463 r = route_configure(rt, link, &route_handler);
465 log_warning_link(link,
466 "could not set routes: %s", strerror(-r));
467 link_enter_failed(link);
471 link->route_messages ++;
474 if (ipv4ll_is_bound(link->ipv4ll)) {
475 _cleanup_route_free_ Route *route = NULL;
477 r = route_new_dynamic(&route, RTPROT_STATIC);
479 log_error_link(link, "Could not allocate route: %s",
484 route->family = AF_INET;
485 route->scope = RT_SCOPE_LINK;
486 route->metrics = IPV4LL_ROUTE_METRIC;
488 r = route_configure(route, link, &route_handler);
490 log_warning_link(link,
491 "could not set routes: %s", strerror(-r));
492 link_enter_failed(link);
496 link->route_messages ++;
499 if (link->dhcp_lease) {
500 _cleanup_route_free_ Route *route = NULL;
501 _cleanup_route_free_ Route *route_gw = NULL;
502 struct in_addr gateway;
504 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
505 if (r < 0 && r != -ENOENT) {
506 log_warning_link(link, "DHCP error: could not get gateway: %s",
512 r = route_new_dynamic(&route, RTPROT_DHCP);
514 log_error_link(link, "Could not allocate route: %s",
519 r = route_new_dynamic(&route_gw, RTPROT_DHCP);
521 log_error_link(link, "Could not allocate route: %s",
526 /* The dhcp netmask may mask out the gateway. Add an explicit
527 * route for the gw host so that we can route no matter the
528 * netmask or existing kernel route tables. */
529 route_gw->family = AF_INET;
530 route_gw->dst_addr.in = gateway;
531 route_gw->dst_prefixlen = 32;
532 route_gw->scope = RT_SCOPE_LINK;
533 route_gw->metrics = DHCP_ROUTE_METRIC;
535 r = route_configure(route_gw, link, &route_handler);
537 log_warning_link(link,
538 "could not set host route: %s", strerror(-r));
542 link->route_messages ++;
544 route->family = AF_INET;
545 route->in_addr.in = gateway;
546 route->metrics = DHCP_ROUTE_METRIC;
548 r = route_configure(route, link, &route_handler);
550 log_warning_link(link,
551 "could not set routes: %s", strerror(-r));
552 link_enter_failed(link);
556 link->route_messages ++;
559 if (link->network->dhcp_routes)
560 link_set_dhcp_routes(link);
563 if (link->route_messages == 0) {
564 link_enter_configured(link);
570 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
571 _cleanup_link_unref_ Link *link = userdata;
576 assert(link->ifname);
578 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
581 r = sd_rtnl_message_get_errno(m);
582 if (r < 0 && r != -ESRCH)
583 log_struct_link(LOG_WARNING, link,
584 "MESSAGE=%-*s: could not drop route: %s",
586 link->ifname, strerror(-r),
593 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
594 _cleanup_link_unref_ Link *link = userdata;
600 assert(link->manager);
602 for (; m; m = sd_rtnl_message_next(m)) {
603 r = sd_rtnl_message_get_errno(m);
605 log_debug_link(link, "getting address failed: %s", strerror(-r));
609 r = link_rtnl_process_address(rtnl, m, link->manager);
611 log_warning_link(link, "could not process address: %s", strerror(-r));
617 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
618 _cleanup_link_unref_ Link *link = userdata;
624 assert(link->ifname);
625 assert(link->addr_messages > 0);
626 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
627 LINK_STATE_FAILED, LINK_STATE_LINGER));
629 link->addr_messages --;
631 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
634 r = sd_rtnl_message_get_errno(m);
635 if (r < 0 && r != -EEXIST)
636 log_struct_link(LOG_WARNING, link,
637 "MESSAGE=%-*s: could not set address: %s",
639 link->ifname, strerror(-r),
643 /* calling handler directly so take a ref */
645 link_get_address_handler(rtnl, m, link);
648 if (link->addr_messages == 0) {
649 log_debug_link(link, "addresses set");
650 link_enter_set_routes(link);
656 static int link_enter_set_addresses(Link *link) {
659 uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
662 assert(link->network);
663 assert(link->state != _LINK_STATE_INVALID);
665 link->state = LINK_STATE_SETTING_ADDRESSES;
667 if (!link->network->static_addresses &&
669 !ipv4ll_is_bound(link->ipv4ll))
670 return link_enter_set_routes(link);
672 log_debug_link(link, "setting addresses");
674 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
675 r = address_configure(ad, link, &address_handler);
677 log_warning_link(link,
678 "could not set addresses: %s", strerror(-r));
679 link_enter_failed(link);
683 link->addr_messages ++;
687 _cleanup_address_free_ Address *ll_addr = NULL;
690 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
691 if (r < 0 && r != -ENOENT) {
692 log_warning_link(link, "IPV4LL error: no address: %s",
698 r = address_new_dynamic(&ll_addr);
700 log_error_link(link, "Could not allocate address: %s", strerror(-r));
704 ll_addr->family = AF_INET;
705 ll_addr->in_addr.in = addr;
706 ll_addr->prefixlen = 16;
707 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
708 ll_addr->scope = RT_SCOPE_LINK;
710 r = address_configure(ll_addr, link, &address_handler);
712 log_warning_link(link,
713 "could not set addresses: %s", strerror(-r));
714 link_enter_failed(link);
718 link->addr_messages ++;
722 if (link->dhcp_lease) {
723 _cleanup_address_free_ Address *address = NULL;
725 struct in_addr netmask;
728 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
730 log_warning_link(link, "DHCP error: no address: %s",
735 if (!link->network->dhcp_critical) {
736 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
739 log_warning_link(link, "DHCP error: no lifetime: %s",
745 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
747 log_warning_link(link, "DHCP error: no netmask: %s",
752 prefixlen = in_addr_netmask_to_prefixlen(&netmask);
754 r = address_new_dynamic(&address);
756 log_error_link(link, "Could not allocate address: %s",
761 address->family = AF_INET;
762 address->in_addr.in = addr;
763 address->cinfo.ifa_prefered = lifetime;
764 address->cinfo.ifa_valid = lifetime;
765 address->prefixlen = prefixlen;
766 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
768 /* use update rather than configure so that we will update the lifetime
769 of an existing address if it has already been configured */
770 r = address_update(address, link, &address_handler);
772 log_warning_link(link,
773 "could not set addresses: %s", strerror(-r));
774 link_enter_failed(link);
778 link->addr_messages ++;
784 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
785 _cleanup_link_unref_ Link *link = userdata;
790 assert(link->ifname);
792 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
795 r = sd_rtnl_message_get_errno(m);
796 if (r < 0 && r != -EADDRNOTAVAIL)
797 log_struct_link(LOG_WARNING, link,
798 "MESSAGE=%-*s: could not drop address: %s",
800 link->ifname, strerror(-r),
807 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
808 _cleanup_link_unref_ Link *link = userdata;
813 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
816 r = sd_bus_message_get_errno(m);
820 log_warning_link(link, "Could not set hostname: %s", strerror(r));
825 static int link_set_hostname(Link *link, const char *hostname) {
826 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
830 assert(link->manager);
833 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
835 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
836 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
840 r = sd_bus_message_new_method_call(
843 "org.freedesktop.hostname1",
844 "/org/freedesktop/hostname1",
845 "org.freedesktop.hostname1",
850 r = sd_bus_message_append(m, "sb", hostname, false);
854 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
856 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
865 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
866 _cleanup_link_unref_ Link *link = userdata;
871 assert(link->ifname);
873 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
876 r = sd_rtnl_message_get_errno(m);
878 log_struct_link(LOG_WARNING, link,
879 "MESSAGE=%-*s: could not set MTU: %s",
880 IFNAMSIZ, link->ifname, strerror(-r),
887 static int link_set_mtu(Link *link, uint32_t mtu) {
888 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
892 assert(link->manager);
893 assert(link->manager->rtnl);
895 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
897 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
898 RTM_SETLINK, link->ifindex);
900 log_error_link(link, "Could not allocate RTM_SETLINK message");
904 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
906 log_error_link(link, "Could not append MTU: %s", strerror(-r));
910 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
913 "Could not send rtnetlink message: %s", strerror(-r));
922 static int dhcp_lease_lost(Link *link) {
923 _cleanup_address_free_ Address *address = NULL;
925 struct in_addr netmask;
926 struct in_addr gateway;
931 assert(link->dhcp_lease);
933 log_warning_link(link, "DHCP lease lost");
935 if (link->network->dhcp_routes) {
936 struct sd_dhcp_route *routes;
939 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes);
941 for (i = 0; i < n; i++) {
942 _cleanup_route_free_ Route *route = NULL;
944 r = route_new_dynamic(&route, RTPROT_UNSPEC);
946 route->family = AF_INET;
947 route->in_addr.in = routes[i].gw_addr;
948 route->dst_addr.in = routes[i].dst_addr;
949 route->dst_prefixlen = routes[i].dst_prefixlen;
951 route_drop(route, link, &route_drop_handler);
957 r = address_new_dynamic(&address);
959 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
961 _cleanup_route_free_ Route *route_gw = NULL;
962 _cleanup_route_free_ Route *route = NULL;
964 r = route_new_dynamic(&route_gw, RTPROT_UNSPEC);
966 route_gw->family = AF_INET;
967 route_gw->dst_addr.in = gateway;
968 route_gw->dst_prefixlen = 32;
969 route_gw->scope = RT_SCOPE_LINK;
971 route_drop(route_gw, link, &route_drop_handler);
974 r = route_new_dynamic(&route, RTPROT_UNSPEC);
976 route->family = AF_INET;
977 route->in_addr.in = gateway;
979 route_drop(route, link, &route_drop_handler);
983 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
984 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
985 prefixlen = in_addr_netmask_to_prefixlen(&netmask);
987 address->family = AF_INET;
988 address->in_addr.in = addr;
989 address->prefixlen = prefixlen;
991 address_drop(address, link, &address_drop_handler);
994 if (link->network->dhcp_mtu) {
997 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
998 if (r >= 0 && link->original_mtu != mtu) {
999 r = link_set_mtu(link, link->original_mtu);
1001 log_warning_link(link, "DHCP error: could not reset MTU");
1002 link_enter_failed(link);
1008 if (link->network->dhcp_hostname) {
1009 const char *hostname = NULL;
1011 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1012 if (r >= 0 && hostname) {
1013 r = link_set_hostname(link, "");
1015 log_error_link(link, "Failed to reset transient hostname");
1019 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1024 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1025 sd_dhcp_lease *lease;
1028 r = sd_dhcp_client_get_lease(client, &lease);
1030 log_warning_link(link, "DHCP error: no lease %s",
1035 sd_dhcp_lease_unref(link->dhcp_lease);
1036 link->dhcp_lease = lease;
1038 link_enter_set_addresses(link);
1043 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1044 sd_dhcp_lease *lease;
1045 struct in_addr address;
1046 struct in_addr netmask;
1047 struct in_addr gateway;
1054 r = sd_dhcp_client_get_lease(client, &lease);
1056 log_warning_link(link, "DHCP error: no lease: %s",
1061 r = sd_dhcp_lease_get_address(lease, &address);
1063 log_warning_link(link, "DHCP error: no address: %s",
1068 r = sd_dhcp_lease_get_netmask(lease, &netmask);
1070 log_warning_link(link, "DHCP error: no netmask: %s",
1075 prefixlen = in_addr_netmask_to_prefixlen(&netmask);
1077 r = sd_dhcp_lease_get_router(lease, &gateway);
1078 if (r < 0 && r != -ENOENT) {
1079 log_warning_link(link, "DHCP error: could not get gateway: %s",
1085 log_struct_link(LOG_INFO, link,
1086 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1089 ADDRESS_FMT_VAL(address),
1091 ADDRESS_FMT_VAL(gateway),
1092 "ADDRESS=%u.%u.%u.%u",
1093 ADDRESS_FMT_VAL(address),
1096 "GATEWAY=%u.%u.%u.%u",
1097 ADDRESS_FMT_VAL(gateway),
1100 log_struct_link(LOG_INFO, link,
1101 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1104 ADDRESS_FMT_VAL(address),
1106 "ADDRESS=%u.%u.%u.%u",
1107 ADDRESS_FMT_VAL(address),
1112 link->dhcp_lease = lease;
1114 if (link->network->dhcp_mtu) {
1117 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1119 r = link_set_mtu(link, mtu);
1121 log_error_link(link, "Failed to set MTU "
1122 "to %" PRIu16, mtu);
1126 if (link->network->dhcp_hostname) {
1127 const char *hostname;
1129 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1131 r = link_set_hostname(link, hostname);
1133 log_error_link(link, "Failed to set transient hostname "
1134 "to '%s'", hostname);
1138 link_enter_set_addresses(link);
1143 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1144 Link *link = userdata;
1148 assert(link->network);
1149 assert(link->manager);
1151 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1155 case DHCP_EVENT_EXPIRED:
1156 case DHCP_EVENT_STOP:
1157 case DHCP_EVENT_IP_CHANGE:
1158 if (link->network->dhcp_critical) {
1159 log_error_link(link, "DHCPv4 connection considered system critical, "
1160 "ignoring request to reconfigure it.");
1164 if (link->dhcp_lease) {
1165 r = dhcp_lease_lost(link);
1167 link_enter_failed(link);
1172 if (event == DHCP_EVENT_IP_CHANGE) {
1173 r = dhcp_lease_acquired(client, link);
1175 link_enter_failed(link);
1181 case DHCP_EVENT_RENEW:
1182 r = dhcp_lease_renew(client, link);
1184 link_enter_failed(link);
1188 case DHCP_EVENT_IP_ACQUIRE:
1189 r = dhcp_lease_acquired(client, link);
1191 link_enter_failed(link);
1197 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1199 log_warning_link(link, "DHCP unknown event: %d", event);
1206 static int ipv4ll_address_lost(Link *link) {
1208 struct in_addr addr;
1212 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1214 _cleanup_address_free_ Address *address = NULL;
1215 _cleanup_route_free_ Route *route = NULL;
1217 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1218 ADDRESS_FMT_VAL(addr));
1220 r = address_new_dynamic(&address);
1222 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1226 address->family = AF_INET;
1227 address->in_addr.in = addr;
1228 address->prefixlen = 16;
1229 address->scope = RT_SCOPE_LINK;
1231 address_drop(address, link, &address_drop_handler);
1233 r = route_new_dynamic(&route, RTPROT_UNSPEC);
1235 log_error_link(link, "Could not allocate route: %s",
1240 route->family = AF_INET;
1241 route->scope = RT_SCOPE_LINK;
1242 route->metrics = 99;
1244 route_drop(route, link, &route_drop_handler);
1250 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1251 struct in_addr address;
1257 r = sd_ipv4ll_get_address(ll, &address);
1261 log_struct_link(LOG_INFO, link,
1262 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1265 ADDRESS_FMT_VAL(address),
1268 link_enter_set_addresses(link);
1273 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1274 Link *link = userdata;
1278 assert(link->network);
1279 assert(link->manager);
1281 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1285 case IPV4LL_EVENT_STOP:
1286 case IPV4LL_EVENT_CONFLICT:
1287 r = ipv4ll_address_lost(link);
1289 link_enter_failed(link);
1293 case IPV4LL_EVENT_BIND:
1294 r = ipv4ll_address_claimed(ll, link);
1296 link_enter_failed(link);
1302 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1304 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1309 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1310 Link *link = userdata;
1313 assert(link->network);
1314 assert(link->manager);
1316 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1320 case DHCP6_EVENT_STOP:
1321 case DHCP6_EVENT_RESEND_EXPIRE:
1322 case DHCP6_EVENT_RETRANS_MAX:
1323 case DHCP6_EVENT_IP_ACQUIRE:
1324 log_debug_link(link, "DHCPv6 event %d", event);
1330 log_warning_link(link, "DHCPv6 error: %s",
1333 log_warning_link(link, "DHCPv6 unknown event: %d",
1339 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1340 Link *link = userdata;
1344 assert(link->network);
1345 assert(link->manager);
1347 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1351 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1352 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1355 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1356 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1361 log_warning_link(link, "ICMPv6 error: %s",
1364 log_warning_link(link, "ICMPv6 unknown event: %d",
1370 if (link->dhcp6_client)
1373 r = sd_dhcp6_client_new(&link->dhcp6_client);
1377 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1379 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1383 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1385 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1389 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1391 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1395 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1398 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1402 r = sd_dhcp6_client_start(link->dhcp6_client);
1404 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1407 static int link_acquire_conf(Link *link) {
1411 assert(link->network);
1412 assert(link->manager);
1413 assert(link->manager->event);
1415 if (link->network->ipv4ll) {
1416 assert(link->ipv4ll);
1418 log_debug_link(link, "acquiring IPv4 link-local address");
1420 r = sd_ipv4ll_start(link->ipv4ll);
1422 log_warning_link(link, "could not acquire IPv4 "
1423 "link-local address");
1428 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1429 assert(link->dhcp_client);
1431 log_debug_link(link, "acquiring DHCPv4 lease");
1433 r = sd_dhcp_client_start(link->dhcp_client);
1435 log_warning_link(link, "could not acquire DHCPv4 "
1441 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1442 assert(link->icmp6_router_discovery);
1444 log_debug_link(link, "discovering IPv6 routers");
1446 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1448 log_warning_link(link, "could not start IPv6 router discovery");
1456 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1457 /* see Documentation/networking/operstates.txt in the kernel sources */
1459 if (operstate == IF_OPER_UP)
1462 if (operstate == IF_OPER_UNKNOWN)
1463 /* operstate may not be implemented, so fall back to flags */
1464 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1470 #define FLAG_STRING(string, flag, old, new) \
1471 (((old ^ new) & flag) \
1472 ? ((old & flag) ? (" -" string) : (" +" string)) \
1475 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1476 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1478 bool carrier_gained = false, carrier_lost = false;
1483 r = sd_rtnl_message_link_get_flags(m, &flags);
1485 log_warning_link(link, "Could not get link flags");
1489 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1491 /* if we got a message without operstate, take it to mean
1492 the state was unchanged */
1493 operstate = link->kernel_operstate;
1495 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1498 if (link->flags != flags) {
1499 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",
1500 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1501 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1502 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1503 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1504 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1505 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1506 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1507 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1508 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1509 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1510 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1511 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1512 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1513 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1514 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1515 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1516 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1517 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1518 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1520 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1521 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1522 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1523 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1524 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1525 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1526 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1527 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1529 /* link flags are currently at most 18 bits, let's align to printing 20 */
1530 if (unknown_flags_added)
1531 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1532 unknown_flags_added);
1534 if (unknown_flags_removed)
1535 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1536 unknown_flags_removed);
1539 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1540 link_has_carrier(flags, operstate);
1541 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1542 !link_has_carrier(flags, operstate);
1544 link->flags = flags;
1545 link->kernel_operstate = operstate;
1549 if (link->state == LINK_STATE_FAILED ||
1550 link->state == LINK_STATE_UNMANAGED)
1553 if (carrier_gained) {
1554 log_info_link(link, "gained carrier");
1556 if (link->network) {
1557 r = link_acquire_conf(link);
1559 link_enter_failed(link);
1563 } else if (carrier_lost) {
1564 log_info_link(link, "lost carrier");
1566 r = link_stop_clients(link);
1568 link_enter_failed(link);
1576 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1577 _cleanup_link_unref_ Link *link = userdata;
1582 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1585 r = sd_rtnl_message_get_errno(m);
1587 /* we warn but don't fail the link, as it may
1588 be brought up later */
1589 log_struct_link(LOG_WARNING, link,
1590 "MESSAGE=%-*s: could not bring up interface: %s",
1592 link->ifname, strerror(-r),
1600 static int link_up(Link *link) {
1601 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1605 assert(link->manager);
1606 assert(link->manager->rtnl);
1608 log_debug_link(link, "bringing link up");
1610 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1611 RTM_SETLINK, link->ifindex);
1613 log_error_link(link, "Could not allocate RTM_SETLINK message");
1617 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1619 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1623 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1625 log_error_link(link,
1626 "Could not send rtnetlink message: %s", strerror(-r));
1635 static int link_joined(Link *link) {
1639 assert(link->state == LINK_STATE_ENSLAVING);
1640 assert(link->network);
1642 if (!(link->flags & IFF_UP)) {
1645 link_enter_failed(link);
1650 return link_enter_set_addresses(link);
1653 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1654 _cleanup_link_unref_ Link *link = userdata;
1658 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1659 LINK_STATE_LINGER));
1660 assert(link->network);
1664 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1667 r = sd_rtnl_message_get_errno(m);
1668 if (r < 0 && r != -EEXIST) {
1669 log_struct_link(LOG_ERR, link,
1670 "MESSAGE=%-*s: could not join netdev: %s",
1672 link->ifname, strerror(-r),
1675 link_enter_failed(link);
1678 log_debug_link(link, "joined netdev");
1680 if (link->enslaving <= 0)
1686 static int link_enter_join_netdev(Link *link) {
1692 assert(link->network);
1693 assert(link->state == LINK_STATE_INITIALIZING);
1695 link->state = LINK_STATE_ENSLAVING;
1699 if (!link->network->bridge &&
1700 !link->network->bond &&
1701 hashmap_isempty(link->network->stacked_netdevs))
1702 return link_joined(link);
1704 if (link->network->bond) {
1705 log_struct_link(LOG_DEBUG, link,
1706 "MESSAGE=%-*s: enslaving by '%s'",
1708 link->ifname, link->network->bond->ifname,
1709 NETDEVIF(link->network->bond),
1712 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1714 log_struct_link(LOG_WARNING, link,
1715 "MESSAGE=%-*s: could not join netdev '%s': %s",
1717 link->ifname, link->network->bond->ifname, strerror(-r),
1718 NETDEVIF(link->network->bond),
1720 link_enter_failed(link);
1727 if (link->network->bridge) {
1728 log_struct_link(LOG_DEBUG, link,
1729 "MESSAGE=%-*s: enslaving by '%s'",
1731 link->ifname, link->network->bridge->ifname,
1732 NETDEVIF(link->network->bridge),
1735 r = netdev_join(link->network->bridge, link, &netdev_join_handler);
1737 log_struct_link(LOG_WARNING, link,
1738 "MESSAGE=%-*s: could not join netdev '%s': %s",
1740 link->ifname, link->network->bridge->ifname, strerror(-r),
1741 NETDEVIF(link->network->bridge),
1743 link_enter_failed(link);
1750 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1751 log_struct_link(LOG_DEBUG, link,
1752 "MESSAGE=%-*s: enslaving by '%s'",
1754 link->ifname, netdev->ifname, NETDEVIF(netdev), NULL);
1756 r = netdev_join(netdev, link, &netdev_join_handler);
1758 log_struct_link(LOG_WARNING, link,
1759 "MESSAGE=%-*s: could not join netdev '%s': %s",
1761 link->ifname, netdev->ifname, strerror(-r),
1762 NETDEVIF(netdev), NULL);
1763 link_enter_failed(link);
1773 static int link_configure(Link *link) {
1777 assert(link->state == LINK_STATE_INITIALIZING);
1779 if (link->network->ipv4ll) {
1782 r = sd_ipv4ll_new(&link->ipv4ll);
1786 if (link->udev_device) {
1787 r = net_get_unique_predictable_data(link->udev_device, seed);
1789 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1795 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1799 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1803 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1807 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1812 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1813 r = sd_dhcp_client_new(&link->dhcp_client);
1817 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1821 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1825 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1829 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1833 r = sd_dhcp_client_set_request_broadcast(link->dhcp_client, link->network->dhcp_broadcast);
1838 r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
1843 if (link->network->dhcp_mtu) {
1844 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_INTERFACE_MTU);
1849 if (link->network->dhcp_routes) {
1850 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
1853 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
1858 if (link->network->dhcp_sendhost) {
1859 _cleanup_free_ char *hostname = gethostname_malloc();
1863 if (!is_localhost(hostname)) {
1864 r = sd_dhcp_client_set_hostname(link->dhcp_client, hostname);
1870 if (link->network->dhcp_vendor_class_identifier) {
1871 r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
1872 link->network->dhcp_vendor_class_identifier);
1878 if (link->network->dhcp_server) {
1879 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1883 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1888 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1889 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1893 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1898 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1903 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1908 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1909 icmp6_router_handler, link);
1914 if (link_has_carrier(link->flags, link->kernel_operstate)) {
1915 r = link_acquire_conf(link);
1920 return link_enter_join_netdev(link);
1923 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1924 _cleanup_link_unref_ Link *link = userdata;
1929 assert(link->ifname);
1930 assert(link->manager);
1932 if (link->state != LINK_STATE_INITIALIZING)
1935 log_debug_link(link, "link state is up-to-date");
1937 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
1939 link_enter_unmanaged(link);
1944 r = network_apply(link->manager, network, link);
1948 r = link_configure(link);
1955 int link_initialized(Link *link, struct udev_device *device) {
1956 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1960 assert(link->manager);
1961 assert(link->manager->rtnl);
1964 if (link->state != LINK_STATE_INITIALIZING)
1967 if (link->udev_device)
1970 log_debug_link(link, "udev initialized link");
1972 link->udev_device = udev_device_ref(device);
1974 /* udev has initialized the link, but we don't know if we have yet processed
1975 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
1976 we know that the pending NEWLINKs have already been processed and that we
1979 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
1983 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
1992 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1993 Manager *m = userdata;
1996 _cleanup_address_free_ Address *address = NULL;
1998 char buf[INET6_ADDRSTRLEN];
1999 bool address_dropped = false;
2006 r = sd_rtnl_message_get_type(message, &type);
2008 log_warning("rtnl: could not get message type");
2012 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2013 if (r < 0 || ifindex <= 0) {
2014 log_warning("rtnl: received address message without valid ifindex, ignoring");
2017 r = link_get(m, ifindex, &link);
2018 if (r < 0 || !link) {
2019 log_warning("rtnl: received address for a nonexistent link, ignoring");
2024 r = address_new_dynamic(&address);
2028 r = sd_rtnl_message_addr_get_family(message, &address->family);
2029 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2030 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2034 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2036 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2040 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2042 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2046 switch (address->family) {
2048 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2050 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2057 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2059 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2066 assert_not_reached("invalid address family");
2069 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2070 log_warning_link(link, "could not print address");
2074 LIST_FOREACH(addresses, ad, link->addresses) {
2075 if (address_equal(ad, address)) {
2076 LIST_REMOVE(addresses, link->addresses, ad);
2080 address_dropped = true;
2088 if (!address_dropped)
2089 log_debug_link(link, "added address: %s/%u", buf,
2090 address->prefixlen);
2092 log_debug_link(link, "updated address: %s/%u", buf,
2093 address->prefixlen);
2095 LIST_PREPEND(addresses, link->addresses, address);
2102 if (address_dropped) {
2103 log_debug_link(link, "removed address: %s/%u", buf,
2104 address->prefixlen);
2108 log_warning_link(link, "removing non-existent address: %s/%u",
2109 buf, address->prefixlen);
2113 assert_not_reached("Received invalid RTNL message type");
2119 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2121 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2122 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2123 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2131 r = link_new(m, message, ret);
2137 log_debug_link(link, "link %d added", link->ifindex);
2139 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2143 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2149 if (detect_container(NULL) <= 0) {
2150 /* not in a container, udev will be around */
2151 sprintf(ifindex_str, "n%d", link->ifindex);
2152 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2154 log_warning_link(link, "could not find udev device: %m");
2158 if (udev_device_get_is_initialized(device) <= 0) {
2160 log_debug_link(link, "udev initializing link...");
2164 r = link_initialized(link, device);
2168 /* we are calling a callback directly, so must take a ref */
2171 r = link_initialized_and_synced(m->rtnl, NULL, link);
2179 int link_update(Link *link, sd_rtnl_message *m) {
2180 struct ether_addr mac;
2186 assert(link->ifname);
2189 if (link->state == LINK_STATE_LINGER) {
2191 log_info_link(link, "link readded");
2192 link->state = LINK_STATE_ENSLAVING;
2195 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2196 if (r >= 0 && !streq(ifname, link->ifname)) {
2197 log_info_link(link, "renamed to %s", ifname);
2200 link->ifname = strdup(ifname);
2205 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
2206 if (r >= 0 && mtu > 0) {
2208 if (!link->original_mtu) {
2209 link->original_mtu = mtu;
2210 log_debug_link(link, "saved original MTU: %"
2211 PRIu32, link->original_mtu);
2214 if (link->dhcp_client) {
2215 r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
2217 log_warning_link(link, "Could not update MTU in DHCP client: %s",
2224 /* The kernel may broadcast NEWLINK messages without the MAC address
2225 set, simply ignore them. */
2226 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2228 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2230 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2232 log_debug_link(link, "MAC address: "
2233 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2234 mac.ether_addr_octet[0],
2235 mac.ether_addr_octet[1],
2236 mac.ether_addr_octet[2],
2237 mac.ether_addr_octet[3],
2238 mac.ether_addr_octet[4],
2239 mac.ether_addr_octet[5]);
2242 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2244 log_warning_link(link, "Could not update MAC "
2245 "address in IPv4LL client: %s",
2251 if (link->dhcp_client) {
2252 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2254 log_warning_link(link, "Could not update MAC "
2255 "address in DHCP client: %s",
2261 if (link->dhcp6_client) {
2262 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2265 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2273 return link_update_flags(link, m);
2276 static void link_update_operstate(Link *link) {
2280 if (link->kernel_operstate == IF_OPER_DORMANT)
2281 link->operstate = LINK_OPERSTATE_DORMANT;
2282 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2284 uint8_t scope = RT_SCOPE_NOWHERE;
2286 /* if we have carrier, check what addresses we have */
2287 LIST_FOREACH(addresses, address, link->addresses) {
2288 if (address->scope < scope)
2289 scope = address->scope;
2292 if (scope < RT_SCOPE_SITE)
2293 /* universally accessible addresses found */
2294 link->operstate = LINK_OPERSTATE_ROUTABLE;
2295 else if (scope < RT_SCOPE_HOST)
2296 /* only link or site local addresses found */
2297 link->operstate = LINK_OPERSTATE_DEGRADED;
2299 /* no useful addresses found */
2300 link->operstate = LINK_OPERSTATE_CARRIER;
2302 link->operstate = LINK_OPERSTATE_UNKNOWN;
2305 int link_save(Link *link) {
2306 _cleanup_free_ char *temp_path = NULL;
2307 _cleanup_fclose_ FILE *f = NULL;
2308 const char *admin_state, *oper_state;
2312 assert(link->state_file);
2313 assert(link->lease_file);
2314 assert(link->manager);
2316 link_update_operstate(link);
2318 r = manager_save(link->manager);
2322 if (link->state == LINK_STATE_LINGER) {
2323 unlink(link->state_file);
2327 admin_state = link_state_to_string(link->state);
2328 assert(admin_state);
2330 oper_state = link_operstate_to_string(link->operstate);
2333 r = fopen_temporary(link->state_file, &f, &temp_path);
2337 fchmod(fileno(f), 0644);
2340 "# This is private data. Do not parse.\n"
2343 admin_state, oper_state);
2345 if (link->network) {
2350 if (link->network->dhcp_dns &&
2352 const struct in_addr *addresses;
2354 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2356 serialize_in_addrs(f, addresses, r);
2357 if (link->network->dns)
2362 STRV_FOREACH(address, link->network->dns)
2363 fprintf(f, "%s%s", *address,
2364 (address + 1 ? " " : ""));
2370 if (link->network->dhcp_ntp &&
2372 const struct in_addr *addresses;
2374 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2376 serialize_in_addrs(f, addresses, r);
2377 if (link->network->ntp)
2382 STRV_FOREACH(address, link->network->ntp)
2383 fprintf(f, "%s%s", *address,
2384 (address + 1 ? " " : ""));
2388 fprintf(f, "LLMNR=%s\n", llmnr_support_to_string(link->network->llmnr));
2391 if (link->dhcp_lease) {
2392 assert(link->network);
2394 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2402 unlink(link->lease_file);
2404 r = fflush_and_check(f);
2408 if (rename(temp_path, link->state_file) < 0) {
2416 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2417 unlink(link->state_file);
2422 static const char* const link_state_table[_LINK_STATE_MAX] = {
2423 [LINK_STATE_INITIALIZING] = "initializing",
2424 [LINK_STATE_ENSLAVING] = "configuring",
2425 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2426 [LINK_STATE_SETTING_ROUTES] = "configuring",
2427 [LINK_STATE_CONFIGURED] = "configured",
2428 [LINK_STATE_UNMANAGED] = "unmanaged",
2429 [LINK_STATE_FAILED] = "failed",
2430 [LINK_STATE_LINGER] = "linger",
2433 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2435 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2436 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2437 [LINK_OPERSTATE_DORMANT] = "dormant",
2438 [LINK_OPERSTATE_CARRIER] = "carrier",
2439 [LINK_OPERSTATE_DEGRADED] = "degraded",
2440 [LINK_OPERSTATE_ROUTABLE] = "routable",
2443 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);