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);
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);
1838 if (link->network->dhcp_mtu) {
1839 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_INTERFACE_MTU);
1844 if (link->network->dhcp_routes) {
1845 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
1848 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
1853 if (link->network->dhcp_sendhost) {
1854 _cleanup_free_ char *hostname = gethostname_malloc();
1858 if (!is_localhost(hostname)) {
1859 r = sd_dhcp_client_set_hostname(link->dhcp_client, hostname);
1865 if (link->network->dhcp_vendor_class_identifier) {
1866 r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
1867 link->network->dhcp_vendor_class_identifier);
1873 if (link->network->dhcp_server) {
1874 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1878 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1883 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1884 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1888 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1893 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1898 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1903 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1904 icmp6_router_handler, link);
1909 if (link_has_carrier(link->flags, link->kernel_operstate)) {
1910 r = link_acquire_conf(link);
1915 return link_enter_join_netdev(link);
1918 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1919 _cleanup_link_unref_ Link *link = userdata;
1924 assert(link->ifname);
1925 assert(link->manager);
1927 if (link->state != LINK_STATE_INITIALIZING)
1930 log_debug_link(link, "link state is up-to-date");
1932 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
1934 link_enter_unmanaged(link);
1939 r = network_apply(link->manager, network, link);
1943 r = link_configure(link);
1950 int link_initialized(Link *link, struct udev_device *device) {
1951 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1955 assert(link->manager);
1956 assert(link->manager->rtnl);
1959 if (link->state != LINK_STATE_INITIALIZING)
1962 if (link->udev_device)
1965 log_debug_link(link, "udev initialized link");
1967 link->udev_device = udev_device_ref(device);
1969 /* udev has initialized the link, but we don't know if we have yet processed
1970 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
1971 we know that the pending NEWLINKs have already been processed and that we
1974 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
1978 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
1987 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1988 Manager *m = userdata;
1991 _cleanup_address_free_ Address *address = NULL;
1993 char buf[INET6_ADDRSTRLEN];
1994 bool address_dropped = false;
2001 r = sd_rtnl_message_get_type(message, &type);
2003 log_warning("rtnl: could not get message type");
2007 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2008 if (r < 0 || ifindex <= 0) {
2009 log_warning("rtnl: received address message without valid ifindex, ignoring");
2012 r = link_get(m, ifindex, &link);
2013 if (r < 0 || !link) {
2014 log_warning("rtnl: received address for a nonexistent link, ignoring");
2019 r = address_new_dynamic(&address);
2023 r = sd_rtnl_message_addr_get_family(message, &address->family);
2024 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2025 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2029 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2031 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2035 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2037 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2041 switch (address->family) {
2043 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2045 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2052 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2054 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2061 assert_not_reached("invalid address family");
2064 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2065 log_warning_link(link, "could not print address");
2069 LIST_FOREACH(addresses, ad, link->addresses) {
2070 if (address_equal(ad, address)) {
2071 LIST_REMOVE(addresses, link->addresses, ad);
2075 address_dropped = true;
2083 if (!address_dropped)
2084 log_debug_link(link, "added address: %s/%u", buf,
2085 address->prefixlen);
2087 log_debug_link(link, "updated address: %s/%u", buf,
2088 address->prefixlen);
2090 LIST_PREPEND(addresses, link->addresses, address);
2097 if (address_dropped) {
2098 log_debug_link(link, "removed address: %s/%u", buf,
2099 address->prefixlen);
2103 log_warning_link(link, "removing non-existent address: %s/%u",
2104 buf, address->prefixlen);
2108 assert_not_reached("Received invalid RTNL message type");
2114 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2116 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2117 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2118 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2126 r = link_new(m, message, ret);
2132 log_debug_link(link, "link %d added", link->ifindex);
2134 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2138 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2144 if (detect_container(NULL) <= 0) {
2145 /* not in a container, udev will be around */
2146 sprintf(ifindex_str, "n%d", link->ifindex);
2147 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2149 log_warning_link(link, "could not find udev device");
2153 if (udev_device_get_is_initialized(device) <= 0) {
2155 log_debug_link(link, "udev initializing link...");
2159 r = link_initialized(link, device);
2163 /* we are calling a callback directly, so must take a ref */
2166 r = link_initialized_and_synced(m->rtnl, NULL, link);
2174 int link_update(Link *link, sd_rtnl_message *m) {
2175 struct ether_addr mac;
2180 assert(link->ifname);
2183 if (link->state == LINK_STATE_LINGER) {
2185 log_info_link(link, "link readded");
2186 link->state = LINK_STATE_ENSLAVING;
2189 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2190 if (r >= 0 && !streq(ifname, link->ifname)) {
2191 log_info_link(link, "renamed to %s", ifname);
2194 link->ifname = strdup(ifname);
2199 if (!link->original_mtu) {
2200 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2202 log_debug_link(link, "saved original MTU: %"
2203 PRIu16, link->original_mtu);
2206 /* The kernel may broadcast NEWLINK messages without the MAC address
2207 set, simply ignore them. */
2208 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2210 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2212 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2214 log_debug_link(link, "MAC address: "
2215 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2216 mac.ether_addr_octet[0],
2217 mac.ether_addr_octet[1],
2218 mac.ether_addr_octet[2],
2219 mac.ether_addr_octet[3],
2220 mac.ether_addr_octet[4],
2221 mac.ether_addr_octet[5]);
2224 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2226 log_warning_link(link, "Could not update MAC "
2227 "address in IPv4LL client: %s",
2233 if (link->dhcp_client) {
2234 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2236 log_warning_link(link, "Could not update MAC "
2237 "address in DHCP client: %s",
2243 if (link->dhcp6_client) {
2244 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2247 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2255 return link_update_flags(link, m);
2258 static void link_update_operstate(Link *link) {
2262 if (link->kernel_operstate == IF_OPER_DORMANT)
2263 link->operstate = LINK_OPERSTATE_DORMANT;
2264 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2266 uint8_t scope = RT_SCOPE_NOWHERE;
2268 /* if we have carrier, check what addresses we have */
2269 LIST_FOREACH(addresses, address, link->addresses) {
2270 if (address->scope < scope)
2271 scope = address->scope;
2274 if (scope < RT_SCOPE_SITE)
2275 /* universally accessible addresses found */
2276 link->operstate = LINK_OPERSTATE_ROUTABLE;
2277 else if (scope < RT_SCOPE_HOST)
2278 /* only link or site local addresses found */
2279 link->operstate = LINK_OPERSTATE_DEGRADED;
2281 /* no useful addresses found */
2282 link->operstate = LINK_OPERSTATE_CARRIER;
2284 link->operstate = LINK_OPERSTATE_UNKNOWN;
2287 int link_save(Link *link) {
2288 _cleanup_free_ char *temp_path = NULL;
2289 _cleanup_fclose_ FILE *f = NULL;
2290 const char *admin_state, *oper_state;
2294 assert(link->state_file);
2295 assert(link->lease_file);
2296 assert(link->manager);
2298 link_update_operstate(link);
2300 r = manager_save(link->manager);
2304 if (link->state == LINK_STATE_LINGER) {
2305 unlink(link->state_file);
2309 admin_state = link_state_to_string(link->state);
2310 assert(admin_state);
2312 oper_state = link_operstate_to_string(link->operstate);
2315 r = fopen_temporary(link->state_file, &f, &temp_path);
2319 fchmod(fileno(f), 0644);
2322 "# This is private data. Do not parse.\n"
2325 admin_state, oper_state);
2327 if (link->network) {
2332 if (link->network->dhcp_dns &&
2334 const struct in_addr *addresses;
2336 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2338 serialize_in_addrs(f, addresses, r);
2339 if (link->network->dns)
2344 STRV_FOREACH(address, link->network->dns)
2345 fprintf(f, "%s%s", *address,
2346 (address + 1 ? " " : ""));
2352 if (link->network->dhcp_ntp &&
2354 const struct in_addr *addresses;
2356 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2358 serialize_in_addrs(f, addresses, r);
2359 if (link->network->ntp)
2364 STRV_FOREACH(address, link->network->ntp)
2365 fprintf(f, "%s%s", *address,
2366 (address + 1 ? " " : ""));
2371 if (link->dhcp_lease) {
2372 assert(link->network);
2374 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2382 unlink(link->lease_file);
2386 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2388 unlink(link->state_file);
2394 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2399 static const char* const link_state_table[_LINK_STATE_MAX] = {
2400 [LINK_STATE_INITIALIZING] = "initializing",
2401 [LINK_STATE_ENSLAVING] = "configuring",
2402 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2403 [LINK_STATE_SETTING_ROUTES] = "configuring",
2404 [LINK_STATE_CONFIGURED] = "configured",
2405 [LINK_STATE_UNMANAGED] = "unmanaged",
2406 [LINK_STATE_FAILED] = "failed",
2407 [LINK_STATE_LINGER] = "linger",
2410 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2412 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2413 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2414 [LINK_OPERSTATE_DORMANT] = "dormant",
2415 [LINK_OPERSTATE_CARRIER] = "carrier",
2416 [LINK_OPERSTATE_DEGRADED] = "degraded",
2417 [LINK_OPERSTATE_ROUTABLE] = "routable",
2420 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2422 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2423 [DHCP_SUPPORT_NONE] = "none",
2424 [DHCP_SUPPORT_BOTH] = "both",
2425 [DHCP_SUPPORT_V4] = "v4",
2426 [DHCP_SUPPORT_V6] = "v6",
2429 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2431 int config_parse_dhcp(
2433 const char *filename,
2435 const char *section,
2436 unsigned section_line,
2443 DHCPSupport *dhcp = data;
2451 /* Our enum shall be a superset of booleans, hence first try
2452 * to parse as boolean, and then as enum */
2454 k = parse_boolean(rvalue);
2456 *dhcp = DHCP_SUPPORT_BOTH;
2458 *dhcp = DHCP_SUPPORT_NONE;
2462 s = dhcp_support_from_string(rvalue);
2464 log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);