1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Tom Gundersen <teg@jklm.no>
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <netinet/ether.h>
27 #include "networkd-netdev.h"
28 #include "libudev-private.h"
29 #include "udev-util.h"
33 #include "network-internal.h"
34 #include "conf-parser.h"
36 #include "network-util.h"
37 #include "dhcp-lease-internal.h"
39 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
40 _cleanup_link_unref_ Link *link = NULL;
49 r = sd_rtnl_message_get_type(message, &type);
52 else if (type != RTM_NEWLINK)
55 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
58 else if (ifindex <= 0)
61 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
70 link->manager = manager;
71 link->state = LINK_STATE_INITIALIZING;
72 link->ifindex = ifindex;
73 link->ifname = strdup(ifname);
77 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
79 log_debug_link(link, "MAC address not found for new device, continuing without");
81 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d", link->ifindex);
85 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d", link->ifindex);
89 r = hashmap_ensure_allocated(&manager->links, NULL, NULL);
93 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
103 static void link_free(Link *link) {
109 while ((address = link->addresses)) {
110 LIST_REMOVE(addresses, link->addresses, address);
111 address_free(address);
114 while ((address = link->pool_addresses)) {
115 LIST_REMOVE(addresses, link->pool_addresses, address);
116 address_free(address);
119 sd_dhcp_client_unref(link->dhcp_client);
120 sd_dhcp_lease_unref(link->dhcp_lease);
122 unlink(link->lease_file);
123 free(link->lease_file);
125 sd_ipv4ll_unref(link->ipv4ll);
126 sd_dhcp6_client_unref(link->dhcp6_client);
127 sd_icmp6_nd_unref(link->icmp6_router_discovery);
130 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
134 unlink(link->state_file);
135 free(link->state_file);
137 udev_device_unref(link->udev_device);
142 Link *link_unref(Link *link) {
143 if (link && (-- link->n_ref <= 0))
149 Link *link_ref(Link *link) {
151 assert_se(++ link->n_ref >= 2);
156 int link_get(Manager *m, int ifindex, Link **ret) {
163 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
172 void link_drop(Link *link) {
173 if (!link || link->state == LINK_STATE_LINGER)
176 link->state = LINK_STATE_LINGER;
178 log_debug_link(link, "link removed");
185 static void link_enter_unmanaged(Link *link) {
188 log_debug_link(link, "unmanaged");
190 link->state = LINK_STATE_UNMANAGED;
195 static int link_stop_clients(Link *link) {
199 assert(link->manager);
200 assert(link->manager->event);
205 if (link->dhcp_client) {
206 k = sd_dhcp_client_stop(link->dhcp_client);
208 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
214 k = sd_ipv4ll_stop(link->ipv4ll);
216 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
221 if (link->dhcp_server) {
222 k = sd_dhcp_server_stop(link->dhcp_server);
224 log_warning_link(link, "Could not stop DHCPv4 server: %s", strerror(-r));
229 if(link->icmp6_router_discovery) {
231 if (link->dhcp6_client) {
232 k = sd_dhcp6_client_stop(link->dhcp6_client);
234 log_warning_link(link, "Could not stop DHCPv6 client: %s", strerror(-r));
239 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
241 log_warning_link(link, "Could not stop ICMPv6 router discovery: %s", strerror(-r));
249 static void link_enter_failed(Link *link) {
252 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
255 log_warning_link(link, "failed");
257 link->state = LINK_STATE_FAILED;
259 link_stop_clients(link);
264 static Address* link_find_dhcp_server_address(Link *link) {
268 assert(link->network);
270 /* The the first statically configured address if there is any */
271 LIST_FOREACH(addresses, address, link->network->static_addresses) {
273 if (address->family != AF_INET)
276 if (in_addr_is_null(address->family, &address->in_addr))
282 /* If that didn't work, find a suitable address we got from the pool */
283 LIST_FOREACH(addresses, address, link->pool_addresses) {
284 if (address->family != AF_INET)
293 static int link_enter_configured(Link *link) {
297 assert(link->network);
298 assert(link->state == LINK_STATE_SETTING_ROUTES);
300 if (link->network->dhcp_server &&
301 !sd_dhcp_server_is_running(link->dhcp_server)) {
302 struct in_addr pool_start;
305 address = link_find_dhcp_server_address(link);
307 log_warning_link(link, "Failed to find suitable address for DHCPv4 server instance.");
308 link_enter_failed(link);
312 log_debug_link(link, "offering DHCPv4 leases");
314 r = sd_dhcp_server_set_address(link->dhcp_server, &address->in_addr.in, address->prefixlen);
318 /* offer 32 addresses starting from the address following the server address */
319 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
320 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
326 r = sd_dhcp_server_set_router(link->dhcp_server,
327 &main_address->in_addr.in);
331 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
332 main_address->prefixlen);
337 r = sd_dhcp_server_start(link->dhcp_server);
339 log_warning_link(link, "could not start DHCPv4 server "
340 "instance: %s", strerror(-r));
342 link_enter_failed(link);
348 log_info_link(link, "link configured");
350 link->state = LINK_STATE_CONFIGURED;
357 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
358 _cleanup_link_unref_ Link *link = userdata;
361 assert(link->route_messages > 0);
362 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
363 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
366 link->route_messages --;
368 if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER))
371 r = sd_rtnl_message_get_errno(m);
372 if (r < 0 && r != -EEXIST)
373 log_struct_link(LOG_WARNING, link,
374 "MESSAGE=%-*s: could not set route: %s",
376 link->ifname, strerror(-r),
380 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
382 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
383 log_debug_link(link, "routes set");
384 link_enter_configured(link);
390 static int link_set_dhcp_routes(Link *link) {
391 struct sd_dhcp_route *static_routes;
396 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes);
399 log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-n));
403 for (i = 0; i < n; i++) {
404 _cleanup_route_free_ Route *route = NULL;
406 r = route_new_dynamic(&route, RTPROT_DHCP);
408 log_error_link(link, "Could not allocate route: %s",
413 route->family = AF_INET;
414 route->in_addr.in = static_routes[i].gw_addr;
415 route->dst_addr.in = static_routes[i].dst_addr;
416 route->dst_prefixlen = static_routes[i].dst_prefixlen;
417 route->metrics = DHCP_ROUTE_METRIC;
419 r = route_configure(route, link, &route_handler);
421 log_warning_link(link,
422 "could not set host route: %s", strerror(-r));
426 link->route_messages ++;
432 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
439 r = sd_ipv4ll_get_address(ll, &addr);
446 static int link_enter_set_routes(Link *link) {
451 assert(link->network);
452 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
454 link->state = LINK_STATE_SETTING_ROUTES;
456 if (!link->network->static_routes &&
458 !ipv4ll_is_bound(link->ipv4ll))
459 return link_enter_configured(link);
461 log_debug_link(link, "setting routes");
463 LIST_FOREACH(routes, rt, link->network->static_routes) {
464 r = route_configure(rt, link, &route_handler);
466 log_warning_link(link,
467 "could not set routes: %s", strerror(-r));
468 link_enter_failed(link);
472 link->route_messages ++;
475 if (ipv4ll_is_bound(link->ipv4ll)) {
476 _cleanup_route_free_ Route *route = NULL;
478 r = route_new_dynamic(&route, RTPROT_STATIC);
480 log_error_link(link, "Could not allocate route: %s",
485 route->family = AF_INET;
486 route->scope = RT_SCOPE_LINK;
487 route->metrics = IPV4LL_ROUTE_METRIC;
489 r = route_configure(route, link, &route_handler);
491 log_warning_link(link,
492 "could not set routes: %s", strerror(-r));
493 link_enter_failed(link);
497 link->route_messages ++;
500 if (link->dhcp_lease) {
501 _cleanup_route_free_ Route *route = NULL;
502 _cleanup_route_free_ Route *route_gw = NULL;
503 struct in_addr gateway;
505 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
506 if (r < 0 && r != -ENOENT) {
507 log_warning_link(link, "DHCP error: could not get gateway: %s",
513 r = route_new_dynamic(&route, RTPROT_DHCP);
515 log_error_link(link, "Could not allocate route: %s",
520 r = route_new_dynamic(&route_gw, RTPROT_DHCP);
522 log_error_link(link, "Could not allocate route: %s",
527 /* The dhcp netmask may mask out the gateway. Add an explicit
528 * route for the gw host so that we can route no matter the
529 * netmask or existing kernel route tables. */
530 route_gw->family = AF_INET;
531 route_gw->dst_addr.in = gateway;
532 route_gw->dst_prefixlen = 32;
533 route_gw->scope = RT_SCOPE_LINK;
534 route_gw->metrics = DHCP_ROUTE_METRIC;
536 r = route_configure(route_gw, link, &route_handler);
538 log_warning_link(link,
539 "could not set host route: %s", strerror(-r));
543 link->route_messages ++;
545 route->family = AF_INET;
546 route->in_addr.in = gateway;
547 route->metrics = DHCP_ROUTE_METRIC;
549 r = route_configure(route, link, &route_handler);
551 log_warning_link(link,
552 "could not set routes: %s", strerror(-r));
553 link_enter_failed(link);
557 link->route_messages ++;
560 if (link->network->dhcp_routes)
561 link_set_dhcp_routes(link);
564 if (link->route_messages == 0) {
565 link_enter_configured(link);
571 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
572 _cleanup_link_unref_ Link *link = userdata;
577 assert(link->ifname);
579 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
582 r = sd_rtnl_message_get_errno(m);
583 if (r < 0 && r != -ESRCH)
584 log_struct_link(LOG_WARNING, link,
585 "MESSAGE=%-*s: could not drop route: %s",
587 link->ifname, strerror(-r),
594 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
595 _cleanup_link_unref_ Link *link = userdata;
601 assert(link->manager);
603 for (; m; m = sd_rtnl_message_next(m)) {
604 r = sd_rtnl_message_get_errno(m);
606 log_debug_link(link, "getting address failed: %s", strerror(-r));
610 r = link_rtnl_process_address(rtnl, m, link->manager);
612 log_warning_link(link, "could not process address: %s", strerror(-r));
618 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
619 _cleanup_link_unref_ Link *link = userdata;
625 assert(link->ifname);
626 assert(link->addr_messages > 0);
627 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
628 LINK_STATE_FAILED, LINK_STATE_LINGER));
630 link->addr_messages --;
632 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
635 r = sd_rtnl_message_get_errno(m);
636 if (r < 0 && r != -EEXIST)
637 log_struct_link(LOG_WARNING, link,
638 "MESSAGE=%-*s: could not set address: %s",
640 link->ifname, strerror(-r),
644 /* calling handler directly so take a ref */
646 link_get_address_handler(rtnl, m, link);
649 if (link->addr_messages == 0) {
650 log_debug_link(link, "addresses set");
651 link_enter_set_routes(link);
657 static int link_enter_set_addresses(Link *link) {
660 uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
663 assert(link->network);
664 assert(link->state != _LINK_STATE_INVALID);
666 link->state = LINK_STATE_SETTING_ADDRESSES;
668 if (!link->network->static_addresses &&
670 !ipv4ll_is_bound(link->ipv4ll))
671 return link_enter_set_routes(link);
673 log_debug_link(link, "setting addresses");
675 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
676 r = address_configure(ad, link, &address_handler);
678 log_warning_link(link,
679 "could not set addresses: %s", strerror(-r));
680 link_enter_failed(link);
684 link->addr_messages ++;
688 _cleanup_address_free_ Address *ll_addr = NULL;
691 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
692 if (r < 0 && r != -ENOENT) {
693 log_warning_link(link, "IPV4LL error: no address: %s",
699 r = address_new_dynamic(&ll_addr);
701 log_error_link(link, "Could not allocate address: %s", strerror(-r));
705 ll_addr->family = AF_INET;
706 ll_addr->in_addr.in = addr;
707 ll_addr->prefixlen = 16;
708 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
709 ll_addr->scope = RT_SCOPE_LINK;
711 r = address_configure(ll_addr, link, &address_handler);
713 log_warning_link(link,
714 "could not set addresses: %s", strerror(-r));
715 link_enter_failed(link);
719 link->addr_messages ++;
723 if (link->dhcp_lease) {
724 _cleanup_address_free_ Address *address = NULL;
726 struct in_addr netmask;
729 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
731 log_warning_link(link, "DHCP error: no address: %s",
736 if (!link->network->dhcp_critical) {
737 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
740 log_warning_link(link, "DHCP error: no lifetime: %s",
746 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
748 log_warning_link(link, "DHCP error: no netmask: %s",
753 prefixlen = net_netmask_to_prefixlen(&netmask);
755 r = address_new_dynamic(&address);
757 log_error_link(link, "Could not allocate address: %s",
762 address->family = AF_INET;
763 address->in_addr.in = addr;
764 address->cinfo.ifa_prefered = lifetime;
765 address->cinfo.ifa_valid = lifetime;
766 address->prefixlen = prefixlen;
767 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
769 /* use update rather than configure so that we will update the lifetime
770 of an existing address if it has already been configured */
771 r = address_update(address, link, &address_handler);
773 log_warning_link(link,
774 "could not set addresses: %s", strerror(-r));
775 link_enter_failed(link);
779 link->addr_messages ++;
785 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
786 _cleanup_link_unref_ Link *link = userdata;
791 assert(link->ifname);
793 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
796 r = sd_rtnl_message_get_errno(m);
797 if (r < 0 && r != -EADDRNOTAVAIL)
798 log_struct_link(LOG_WARNING, link,
799 "MESSAGE=%-*s: could not drop address: %s",
801 link->ifname, strerror(-r),
808 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
809 _cleanup_link_unref_ Link *link = userdata;
814 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
817 r = sd_bus_message_get_errno(m);
821 log_warning_link(link, "Could not set hostname: %s", strerror(r));
826 static int link_set_hostname(Link *link, const char *hostname) {
827 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
831 assert(link->manager);
834 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
836 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
837 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
841 r = sd_bus_message_new_method_call(
844 "org.freedesktop.hostname1",
845 "/org/freedesktop/hostname1",
846 "org.freedesktop.hostname1",
851 r = sd_bus_message_append(m, "sb", hostname, false);
855 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
857 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
866 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
867 _cleanup_link_unref_ Link *link = userdata;
872 assert(link->ifname);
874 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
877 r = sd_rtnl_message_get_errno(m);
879 log_struct_link(LOG_WARNING, link,
880 "MESSAGE=%-*s: could not set MTU: %s",
881 IFNAMSIZ, link->ifname, strerror(-r),
888 static int link_set_mtu(Link *link, uint32_t mtu) {
889 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
893 assert(link->manager);
894 assert(link->manager->rtnl);
896 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
898 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
899 RTM_SETLINK, link->ifindex);
901 log_error_link(link, "Could not allocate RTM_SETLINK message");
905 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
907 log_error_link(link, "Could not append MTU: %s", strerror(-r));
911 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
914 "Could not send rtnetlink message: %s", strerror(-r));
923 static int dhcp_lease_lost(Link *link) {
924 _cleanup_address_free_ Address *address = NULL;
926 struct in_addr netmask;
927 struct in_addr gateway;
932 assert(link->dhcp_lease);
934 log_warning_link(link, "DHCP lease lost");
936 if (link->network->dhcp_routes) {
937 struct sd_dhcp_route *routes;
940 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes);
942 for (i = 0; i < n; i++) {
943 _cleanup_route_free_ Route *route = NULL;
945 r = route_new_dynamic(&route, RTPROT_UNSPEC);
947 route->family = AF_INET;
948 route->in_addr.in = routes[i].gw_addr;
949 route->dst_addr.in = routes[i].dst_addr;
950 route->dst_prefixlen = routes[i].dst_prefixlen;
952 route_drop(route, link, &route_drop_handler);
958 r = address_new_dynamic(&address);
960 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
962 _cleanup_route_free_ Route *route_gw = NULL;
963 _cleanup_route_free_ Route *route = NULL;
965 r = route_new_dynamic(&route_gw, RTPROT_UNSPEC);
967 route_gw->family = AF_INET;
968 route_gw->dst_addr.in = gateway;
969 route_gw->dst_prefixlen = 32;
970 route_gw->scope = RT_SCOPE_LINK;
972 route_drop(route_gw, link, &route_drop_handler);
975 r = route_new_dynamic(&route, RTPROT_UNSPEC);
977 route->family = AF_INET;
978 route->in_addr.in = gateway;
980 route_drop(route, link, &route_drop_handler);
984 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
985 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
986 prefixlen = net_netmask_to_prefixlen(&netmask);
988 address->family = AF_INET;
989 address->in_addr.in = addr;
990 address->prefixlen = prefixlen;
992 address_drop(address, link, &address_drop_handler);
995 if (link->network->dhcp_mtu) {
998 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
999 if (r >= 0 && link->original_mtu != mtu) {
1000 r = link_set_mtu(link, link->original_mtu);
1002 log_warning_link(link, "DHCP error: could not reset MTU");
1003 link_enter_failed(link);
1009 if (link->network->dhcp_hostname) {
1010 const char *hostname = NULL;
1012 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1013 if (r >= 0 && hostname) {
1014 r = link_set_hostname(link, "");
1016 log_error_link(link, "Failed to reset transient hostname");
1020 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1025 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1026 sd_dhcp_lease *lease;
1029 r = sd_dhcp_client_get_lease(client, &lease);
1031 log_warning_link(link, "DHCP error: no lease %s",
1036 sd_dhcp_lease_unref(link->dhcp_lease);
1037 link->dhcp_lease = lease;
1039 link_enter_set_addresses(link);
1044 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1045 sd_dhcp_lease *lease;
1046 struct in_addr address;
1047 struct in_addr netmask;
1048 struct in_addr gateway;
1055 r = sd_dhcp_client_get_lease(client, &lease);
1057 log_warning_link(link, "DHCP error: no lease: %s",
1062 r = sd_dhcp_lease_get_address(lease, &address);
1064 log_warning_link(link, "DHCP error: no address: %s",
1069 r = sd_dhcp_lease_get_netmask(lease, &netmask);
1071 log_warning_link(link, "DHCP error: no netmask: %s",
1076 prefixlen = net_netmask_to_prefixlen(&netmask);
1078 r = sd_dhcp_lease_get_router(lease, &gateway);
1079 if (r < 0 && r != -ENOENT) {
1080 log_warning_link(link, "DHCP error: could not get gateway: %s",
1086 log_struct_link(LOG_INFO, link,
1087 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1090 ADDRESS_FMT_VAL(address),
1092 ADDRESS_FMT_VAL(gateway),
1093 "ADDRESS=%u.%u.%u.%u",
1094 ADDRESS_FMT_VAL(address),
1097 "GATEWAY=%u.%u.%u.%u",
1098 ADDRESS_FMT_VAL(gateway),
1101 log_struct_link(LOG_INFO, link,
1102 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1105 ADDRESS_FMT_VAL(address),
1107 "ADDRESS=%u.%u.%u.%u",
1108 ADDRESS_FMT_VAL(address),
1113 link->dhcp_lease = lease;
1115 if (link->network->dhcp_mtu) {
1118 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1120 r = link_set_mtu(link, mtu);
1122 log_error_link(link, "Failed to set MTU "
1123 "to %" PRIu16, mtu);
1127 if (link->network->dhcp_hostname) {
1128 const char *hostname;
1130 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1132 r = link_set_hostname(link, hostname);
1134 log_error_link(link, "Failed to set transient hostname "
1135 "to '%s'", hostname);
1139 link_enter_set_addresses(link);
1144 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1145 Link *link = userdata;
1149 assert(link->network);
1150 assert(link->manager);
1152 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1156 case DHCP_EVENT_EXPIRED:
1157 case DHCP_EVENT_STOP:
1158 case DHCP_EVENT_IP_CHANGE:
1159 if (link->network->dhcp_critical) {
1160 log_error_link(link, "DHCPv4 connection considered system critical, "
1161 "ignoring request to reconfigure it.");
1165 if (link->dhcp_lease) {
1166 r = dhcp_lease_lost(link);
1168 link_enter_failed(link);
1173 if (event == DHCP_EVENT_IP_CHANGE) {
1174 r = dhcp_lease_acquired(client, link);
1176 link_enter_failed(link);
1182 case DHCP_EVENT_RENEW:
1183 r = dhcp_lease_renew(client, link);
1185 link_enter_failed(link);
1189 case DHCP_EVENT_IP_ACQUIRE:
1190 r = dhcp_lease_acquired(client, link);
1192 link_enter_failed(link);
1198 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1200 log_warning_link(link, "DHCP unknown event: %d", event);
1207 static int ipv4ll_address_lost(Link *link) {
1209 struct in_addr addr;
1213 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1215 _cleanup_address_free_ Address *address = NULL;
1216 _cleanup_route_free_ Route *route = NULL;
1218 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1219 ADDRESS_FMT_VAL(addr));
1221 r = address_new_dynamic(&address);
1223 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1227 address->family = AF_INET;
1228 address->in_addr.in = addr;
1229 address->prefixlen = 16;
1230 address->scope = RT_SCOPE_LINK;
1232 address_drop(address, link, &address_drop_handler);
1234 r = route_new_dynamic(&route, RTPROT_UNSPEC);
1236 log_error_link(link, "Could not allocate route: %s",
1241 route->family = AF_INET;
1242 route->scope = RT_SCOPE_LINK;
1243 route->metrics = 99;
1245 route_drop(route, link, &route_drop_handler);
1251 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1252 struct in_addr address;
1258 r = sd_ipv4ll_get_address(ll, &address);
1262 log_struct_link(LOG_INFO, link,
1263 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1266 ADDRESS_FMT_VAL(address),
1269 link_enter_set_addresses(link);
1274 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1275 Link *link = userdata;
1279 assert(link->network);
1280 assert(link->manager);
1282 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1286 case IPV4LL_EVENT_STOP:
1287 case IPV4LL_EVENT_CONFLICT:
1288 r = ipv4ll_address_lost(link);
1290 link_enter_failed(link);
1294 case IPV4LL_EVENT_BIND:
1295 r = ipv4ll_address_claimed(ll, link);
1297 link_enter_failed(link);
1303 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1305 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1310 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1311 Link *link = userdata;
1314 assert(link->network);
1315 assert(link->manager);
1317 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1321 case DHCP6_EVENT_STOP:
1322 case DHCP6_EVENT_RESEND_EXPIRE:
1323 case DHCP6_EVENT_RETRANS_MAX:
1324 case DHCP6_EVENT_IP_ACQUIRE:
1325 log_debug_link(link, "DHCPv6 event %d", event);
1331 log_warning_link(link, "DHCPv6 error: %s",
1334 log_warning_link(link, "DHCPv6 unknown event: %d",
1340 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1341 Link *link = userdata;
1345 assert(link->network);
1346 assert(link->manager);
1348 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1352 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1353 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1356 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1357 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1362 log_warning_link(link, "ICMPv6 error: %s",
1365 log_warning_link(link, "ICMPv6 unknown event: %d",
1371 if (link->dhcp6_client)
1374 r = sd_dhcp6_client_new(&link->dhcp6_client);
1378 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1380 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1384 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1386 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1390 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1392 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1396 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1399 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1403 r = sd_dhcp6_client_start(link->dhcp6_client);
1405 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1408 static int link_acquire_conf(Link *link) {
1412 assert(link->network);
1413 assert(link->manager);
1414 assert(link->manager->event);
1416 if (link->network->ipv4ll) {
1417 assert(link->ipv4ll);
1419 log_debug_link(link, "acquiring IPv4 link-local address");
1421 r = sd_ipv4ll_start(link->ipv4ll);
1423 log_warning_link(link, "could not acquire IPv4 "
1424 "link-local address");
1429 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1430 assert(link->dhcp_client);
1432 log_debug_link(link, "acquiring DHCPv4 lease");
1434 r = sd_dhcp_client_start(link->dhcp_client);
1436 log_warning_link(link, "could not acquire DHCPv4 "
1442 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1443 assert(link->icmp6_router_discovery);
1445 log_debug_link(link, "discovering IPv6 routers");
1447 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1449 log_warning_link(link, "could not start IPv6 router discovery");
1457 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1458 /* see Documentation/networking/operstates.txt in the kernel sources */
1460 if (operstate == IF_OPER_UP)
1463 if (operstate == IF_OPER_UNKNOWN)
1464 /* operstate may not be implemented, so fall back to flags */
1465 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1471 #define FLAG_STRING(string, flag, old, new) \
1472 (((old ^ new) & flag) \
1473 ? ((old & flag) ? (" -" string) : (" +" string)) \
1476 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1477 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1479 bool carrier_gained = false, carrier_lost = false;
1484 r = sd_rtnl_message_link_get_flags(m, &flags);
1486 log_warning_link(link, "Could not get link flags");
1490 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1492 /* if we got a message without operstate, take it to mean
1493 the state was unchanged */
1494 operstate = link->kernel_operstate;
1496 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1499 if (link->flags != flags) {
1500 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",
1501 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1502 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1503 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1504 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1505 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1506 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1507 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1508 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1509 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1510 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1511 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1512 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1513 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1514 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1515 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1516 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1517 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1518 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1519 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1521 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1522 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1523 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1524 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1525 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1526 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1527 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1528 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1530 /* link flags are currently at most 18 bits, let's align to printing 20 */
1531 if (unknown_flags_added)
1532 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1533 unknown_flags_added);
1535 if (unknown_flags_removed)
1536 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1537 unknown_flags_removed);
1540 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1541 link_has_carrier(flags, operstate);
1542 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1543 !link_has_carrier(flags, operstate);
1545 link->flags = flags;
1546 link->kernel_operstate = operstate;
1550 if (link->state == LINK_STATE_FAILED ||
1551 link->state == LINK_STATE_UNMANAGED)
1554 if (carrier_gained) {
1555 log_info_link(link, "gained carrier");
1557 if (link->network) {
1558 r = link_acquire_conf(link);
1560 link_enter_failed(link);
1564 } else if (carrier_lost) {
1565 log_info_link(link, "lost carrier");
1567 r = link_stop_clients(link);
1569 link_enter_failed(link);
1577 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1578 _cleanup_link_unref_ Link *link = userdata;
1583 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1586 r = sd_rtnl_message_get_errno(m);
1588 /* we warn but don't fail the link, as it may
1589 be brought up later */
1590 log_struct_link(LOG_WARNING, link,
1591 "MESSAGE=%-*s: could not bring up interface: %s",
1593 link->ifname, strerror(-r),
1601 static int link_up(Link *link) {
1602 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1606 assert(link->manager);
1607 assert(link->manager->rtnl);
1609 log_debug_link(link, "bringing link up");
1611 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1612 RTM_SETLINK, link->ifindex);
1614 log_error_link(link, "Could not allocate RTM_SETLINK message");
1618 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1620 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1624 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1626 log_error_link(link,
1627 "Could not send rtnetlink message: %s", strerror(-r));
1636 static int link_joined(Link *link) {
1640 assert(link->state == LINK_STATE_ENSLAVING);
1641 assert(link->network);
1643 if (!(link->flags & IFF_UP)) {
1646 link_enter_failed(link);
1651 return link_enter_set_addresses(link);
1654 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1655 _cleanup_link_unref_ Link *link = userdata;
1659 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1660 LINK_STATE_LINGER));
1661 assert(link->network);
1665 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1668 r = sd_rtnl_message_get_errno(m);
1669 if (r < 0 && r != -EEXIST) {
1670 log_struct_link(LOG_ERR, link,
1671 "MESSAGE=%-*s: could not join netdev: %s",
1673 link->ifname, strerror(-r),
1676 link_enter_failed(link);
1679 log_debug_link(link, "joined netdev");
1681 if (link->enslaving <= 0)
1687 static int link_enter_join_netdev(Link *link) {
1693 assert(link->network);
1694 assert(link->state == LINK_STATE_INITIALIZING);
1696 link->state = LINK_STATE_ENSLAVING;
1700 if (!link->network->bridge &&
1701 !link->network->bond &&
1702 hashmap_isempty(link->network->stacked_netdevs))
1703 return link_joined(link);
1705 if (link->network->bond) {
1706 log_struct_link(LOG_DEBUG, link,
1707 "MESSAGE=%-*s: enslaving by '%s'",
1709 link->ifname, link->network->bond->ifname,
1710 NETDEVIF(link->network->bond),
1713 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1715 log_struct_link(LOG_WARNING, link,
1716 "MESSAGE=%-*s: could not join netdev '%s': %s",
1718 link->ifname, link->network->bond->ifname, strerror(-r),
1719 NETDEVIF(link->network->bond),
1721 link_enter_failed(link);
1728 if (link->network->bridge) {
1729 log_struct_link(LOG_DEBUG, link,
1730 "MESSAGE=%-*s: enslaving by '%s'",
1732 link->ifname, link->network->bridge->ifname,
1733 NETDEVIF(link->network->bridge),
1736 r = netdev_join(link->network->bridge, link, &netdev_join_handler);
1738 log_struct_link(LOG_WARNING, link,
1739 "MESSAGE=%-*s: could not join netdev '%s': %s",
1741 link->ifname, link->network->bridge->ifname, strerror(-r),
1742 NETDEVIF(link->network->bridge),
1744 link_enter_failed(link);
1751 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1752 log_struct_link(LOG_DEBUG, link,
1753 "MESSAGE=%-*s: enslaving by '%s'",
1755 link->ifname, netdev->ifname, NETDEVIF(netdev), NULL);
1757 r = netdev_join(netdev, link, &netdev_join_handler);
1759 log_struct_link(LOG_WARNING, link,
1760 "MESSAGE=%-*s: could not join netdev '%s': %s",
1762 link->ifname, netdev->ifname, strerror(-r),
1763 NETDEVIF(netdev), NULL);
1764 link_enter_failed(link);
1774 static int link_configure(Link *link) {
1778 assert(link->state == LINK_STATE_INITIALIZING);
1780 if (link->network->ipv4ll) {
1783 r = sd_ipv4ll_new(&link->ipv4ll);
1787 if (link->udev_device) {
1788 r = net_get_unique_predictable_data(link->udev_device, seed);
1790 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1796 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1800 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1804 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1808 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1813 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1814 r = sd_dhcp_client_new(&link->dhcp_client);
1818 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1822 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1826 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1830 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1834 r = sd_dhcp_client_set_request_broadcast(link->dhcp_client, link->network->dhcp_broadcast);
1839 r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
1844 if (link->network->dhcp_mtu) {
1845 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_INTERFACE_MTU);
1850 if (link->network->dhcp_routes) {
1851 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
1854 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
1859 if (link->network->dhcp_sendhost) {
1860 _cleanup_free_ char *hostname = gethostname_malloc();
1864 if (!is_localhost(hostname)) {
1865 r = sd_dhcp_client_set_hostname(link->dhcp_client, hostname);
1871 if (link->network->dhcp_vendor_class_identifier) {
1872 r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
1873 link->network->dhcp_vendor_class_identifier);
1879 if (link->network->dhcp_server) {
1880 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1884 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1889 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1890 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1894 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1899 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1904 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1909 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1910 icmp6_router_handler, link);
1915 if (link_has_carrier(link->flags, link->kernel_operstate)) {
1916 r = link_acquire_conf(link);
1921 return link_enter_join_netdev(link);
1924 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1925 _cleanup_link_unref_ Link *link = userdata;
1930 assert(link->ifname);
1931 assert(link->manager);
1933 if (link->state != LINK_STATE_INITIALIZING)
1936 log_debug_link(link, "link state is up-to-date");
1938 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
1940 link_enter_unmanaged(link);
1945 r = network_apply(link->manager, network, link);
1949 r = link_configure(link);
1956 int link_initialized(Link *link, struct udev_device *device) {
1957 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1961 assert(link->manager);
1962 assert(link->manager->rtnl);
1965 if (link->state != LINK_STATE_INITIALIZING)
1968 if (link->udev_device)
1971 log_debug_link(link, "udev initialized link");
1973 link->udev_device = udev_device_ref(device);
1975 /* udev has initialized the link, but we don't know if we have yet processed
1976 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
1977 we know that the pending NEWLINKs have already been processed and that we
1980 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
1984 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
1993 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1994 Manager *m = userdata;
1997 _cleanup_address_free_ Address *address = NULL;
1999 char buf[INET6_ADDRSTRLEN];
2000 bool address_dropped = false;
2007 r = sd_rtnl_message_get_type(message, &type);
2009 log_warning("rtnl: could not get message type");
2013 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2014 if (r < 0 || ifindex <= 0) {
2015 log_warning("rtnl: received address message without valid ifindex, ignoring");
2018 r = link_get(m, ifindex, &link);
2019 if (r < 0 || !link) {
2020 log_warning("rtnl: received address for a nonexistent link, ignoring");
2025 r = address_new_dynamic(&address);
2029 r = sd_rtnl_message_addr_get_family(message, &address->family);
2030 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2031 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2035 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2037 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2041 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2043 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2047 switch (address->family) {
2049 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2051 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2058 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2060 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2067 assert_not_reached("invalid address family");
2070 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2071 log_warning_link(link, "could not print address");
2075 LIST_FOREACH(addresses, ad, link->addresses) {
2076 if (address_equal(ad, address)) {
2077 LIST_REMOVE(addresses, link->addresses, ad);
2081 address_dropped = true;
2089 if (!address_dropped)
2090 log_debug_link(link, "added address: %s/%u", buf,
2091 address->prefixlen);
2093 log_debug_link(link, "updated address: %s/%u", buf,
2094 address->prefixlen);
2096 LIST_PREPEND(addresses, link->addresses, address);
2103 if (address_dropped) {
2104 log_debug_link(link, "removed address: %s/%u", buf,
2105 address->prefixlen);
2109 log_warning_link(link, "removing non-existent address: %s/%u",
2110 buf, address->prefixlen);
2114 assert_not_reached("Received invalid RTNL message type");
2120 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2122 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2123 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2124 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2132 r = link_new(m, message, ret);
2138 log_debug_link(link, "link %d added", link->ifindex);
2140 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2144 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2150 if (detect_container(NULL) <= 0) {
2151 /* not in a container, udev will be around */
2152 sprintf(ifindex_str, "n%d", link->ifindex);
2153 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2155 log_warning_link(link, "could not find udev device: %m");
2159 if (udev_device_get_is_initialized(device) <= 0) {
2161 log_debug_link(link, "udev initializing link...");
2165 r = link_initialized(link, device);
2169 /* we are calling a callback directly, so must take a ref */
2172 r = link_initialized_and_synced(m->rtnl, NULL, link);
2180 int link_update(Link *link, sd_rtnl_message *m) {
2181 struct ether_addr mac;
2187 assert(link->ifname);
2190 if (link->state == LINK_STATE_LINGER) {
2192 log_info_link(link, "link readded");
2193 link->state = LINK_STATE_ENSLAVING;
2196 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2197 if (r >= 0 && !streq(ifname, link->ifname)) {
2198 log_info_link(link, "renamed to %s", ifname);
2201 link->ifname = strdup(ifname);
2206 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
2207 if (r >= 0 && mtu > 0) {
2209 if (!link->original_mtu) {
2210 link->original_mtu = mtu;
2211 log_debug_link(link, "saved original MTU: %"
2212 PRIu32, link->original_mtu);
2215 if (link->dhcp_client) {
2216 r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
2218 log_warning_link(link, "Could not update MTU in DHCP client: %s",
2225 /* The kernel may broadcast NEWLINK messages without the MAC address
2226 set, simply ignore them. */
2227 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2229 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2231 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2233 log_debug_link(link, "MAC address: "
2234 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2235 mac.ether_addr_octet[0],
2236 mac.ether_addr_octet[1],
2237 mac.ether_addr_octet[2],
2238 mac.ether_addr_octet[3],
2239 mac.ether_addr_octet[4],
2240 mac.ether_addr_octet[5]);
2243 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2245 log_warning_link(link, "Could not update MAC "
2246 "address in IPv4LL client: %s",
2252 if (link->dhcp_client) {
2253 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2255 log_warning_link(link, "Could not update MAC "
2256 "address in DHCP client: %s",
2262 if (link->dhcp6_client) {
2263 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2266 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2274 return link_update_flags(link, m);
2277 static void link_update_operstate(Link *link) {
2281 if (link->kernel_operstate == IF_OPER_DORMANT)
2282 link->operstate = LINK_OPERSTATE_DORMANT;
2283 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2285 uint8_t scope = RT_SCOPE_NOWHERE;
2287 /* if we have carrier, check what addresses we have */
2288 LIST_FOREACH(addresses, address, link->addresses) {
2289 if (address->scope < scope)
2290 scope = address->scope;
2293 if (scope < RT_SCOPE_SITE)
2294 /* universally accessible addresses found */
2295 link->operstate = LINK_OPERSTATE_ROUTABLE;
2296 else if (scope < RT_SCOPE_HOST)
2297 /* only link or site local addresses found */
2298 link->operstate = LINK_OPERSTATE_DEGRADED;
2300 /* no useful addresses found */
2301 link->operstate = LINK_OPERSTATE_CARRIER;
2303 link->operstate = LINK_OPERSTATE_UNKNOWN;
2306 int link_save(Link *link) {
2307 _cleanup_free_ char *temp_path = NULL;
2308 _cleanup_fclose_ FILE *f = NULL;
2309 const char *admin_state, *oper_state;
2313 assert(link->state_file);
2314 assert(link->lease_file);
2315 assert(link->manager);
2317 link_update_operstate(link);
2319 r = manager_save(link->manager);
2323 if (link->state == LINK_STATE_LINGER) {
2324 unlink(link->state_file);
2328 admin_state = link_state_to_string(link->state);
2329 assert(admin_state);
2331 oper_state = link_operstate_to_string(link->operstate);
2334 r = fopen_temporary(link->state_file, &f, &temp_path);
2338 fchmod(fileno(f), 0644);
2341 "# This is private data. Do not parse.\n"
2344 admin_state, oper_state);
2346 if (link->network) {
2351 if (link->network->dhcp_dns &&
2353 const struct in_addr *addresses;
2355 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2357 serialize_in_addrs(f, addresses, r);
2358 if (link->network->dns)
2363 STRV_FOREACH(address, link->network->dns)
2364 fprintf(f, "%s%s", *address,
2365 (address + 1 ? " " : ""));
2371 if (link->network->dhcp_ntp &&
2373 const struct in_addr *addresses;
2375 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2377 serialize_in_addrs(f, addresses, r);
2378 if (link->network->ntp)
2383 STRV_FOREACH(address, link->network->ntp)
2384 fprintf(f, "%s%s", *address,
2385 (address + 1 ? " " : ""));
2389 fprintf(f, "LLMNR=%s\n", llmnr_support_to_string(link->network->llmnr));
2392 if (link->dhcp_lease) {
2393 assert(link->network);
2395 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2403 unlink(link->lease_file);
2407 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2409 unlink(link->state_file);
2415 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2420 static const char* const link_state_table[_LINK_STATE_MAX] = {
2421 [LINK_STATE_INITIALIZING] = "initializing",
2422 [LINK_STATE_ENSLAVING] = "configuring",
2423 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2424 [LINK_STATE_SETTING_ROUTES] = "configuring",
2425 [LINK_STATE_CONFIGURED] = "configured",
2426 [LINK_STATE_UNMANAGED] = "unmanaged",
2427 [LINK_STATE_FAILED] = "failed",
2428 [LINK_STATE_LINGER] = "linger",
2431 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2433 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2434 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2435 [LINK_OPERSTATE_DORMANT] = "dormant",
2436 [LINK_OPERSTATE_CARRIER] = "carrier",
2437 [LINK_OPERSTATE_DEGRADED] = "degraded",
2438 [LINK_OPERSTATE_ROUTABLE] = "routable",
2441 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);