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 ipv4ll_address_update(Link *link, bool deprecate);
40 static bool ipv4ll_is_bound(sd_ipv4ll *ll);
42 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
43 _cleanup_link_unref_ Link *link = NULL;
49 assert(manager->links);
53 r = sd_rtnl_message_get_type(message, &type);
56 else if (type != RTM_NEWLINK)
59 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
62 else if (ifindex <= 0)
65 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
74 link->manager = manager;
75 link->state = LINK_STATE_INITIALIZING;
76 link->ifindex = ifindex;
77 link->ifname = strdup(ifname);
81 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
83 log_debug_link(link, "MAC address not found for new device, continuing without");
85 r = asprintf(&link->state_file, "/run/systemd/netif/links/%"PRIu64,
90 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%"PRIu64,
95 r = hashmap_put(manager->links, &link->ifindex, link);
105 static void link_free(Link *link) {
111 while ((address = link->addresses)) {
112 LIST_REMOVE(addresses, link->addresses, address);
113 address_free(address);
116 while ((address = link->pool_addresses)) {
117 LIST_REMOVE(addresses, link->pool_addresses, address);
118 address_free(address);
121 sd_dhcp_client_unref(link->dhcp_client);
122 sd_dhcp_lease_unref(link->dhcp_lease);
124 unlink(link->lease_file);
125 free(link->lease_file);
127 sd_ipv4ll_unref(link->ipv4ll);
128 sd_dhcp6_client_unref(link->dhcp6_client);
129 sd_icmp6_nd_unref(link->icmp6_router_discovery);
132 hashmap_remove(link->manager->links, &link->ifindex);
136 unlink(link->state_file);
137 free(link->state_file);
139 udev_device_unref(link->udev_device);
144 Link *link_unref(Link *link) {
145 if (link && (-- link->n_ref <= 0))
151 Link *link_ref(Link *link) {
153 assert_se(++ link->n_ref >= 2);
158 int link_get(Manager *m, int ifindex, Link **ret) {
167 ifindex_64 = ifindex;
168 link = hashmap_get(m->links, &ifindex_64);
177 void link_drop(Link *link) {
178 if (!link || link->state == LINK_STATE_LINGER)
181 link->state = LINK_STATE_LINGER;
183 log_debug_link(link, "link removed");
190 static void link_enter_unmanaged(Link *link) {
193 log_debug_link(link, "unmanaged");
195 link->state = LINK_STATE_UNMANAGED;
200 static int link_stop_clients(Link *link) {
204 assert(link->manager);
205 assert(link->manager->event);
210 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
211 assert(link->dhcp_client);
213 k = sd_dhcp_client_stop(link->dhcp_client);
215 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
220 if (link->network->ipv4ll) {
221 assert(link->ipv4ll);
223 k = sd_ipv4ll_stop(link->ipv4ll);
225 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
230 if (link->network->dhcp_server) {
231 assert(link->dhcp_server);
233 k = sd_dhcp_server_stop(link->dhcp_server);
235 log_warning_link(link, "Could not stop DHCPv4 server: %s", strerror(-r));
240 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
241 assert(link->icmp6_router_discovery);
243 if (link->dhcp6_client) {
244 k = sd_dhcp6_client_stop(link->dhcp6_client);
246 log_warning_link(link, "Could not stop DHCPv6 client: %s", strerror(-r));
251 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
253 log_warning_link(link, "Could not stop ICMPv6 router discovery: %s", strerror(-r));
261 static void link_enter_failed(Link *link) {
264 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
267 log_warning_link(link, "failed");
269 link->state = LINK_STATE_FAILED;
271 link_stop_clients(link);
276 static Address* link_find_dhcp_server_address(Link *link) {
280 assert(link->network);
282 /* The the first statically configured address if there is any */
283 LIST_FOREACH(addresses, address, link->network->static_addresses) {
285 if (address->family != AF_INET)
288 if (in_addr_null(address->family, &address->in_addr))
294 /* If that didn't work, find a suitable address we got from the pool */
295 LIST_FOREACH(addresses, address, link->pool_addresses) {
296 if (address->family != AF_INET)
305 static int link_enter_configured(Link *link) {
309 assert(link->network);
310 assert(link->state == LINK_STATE_SETTING_ROUTES);
312 if (link->network->dhcp_server &&
313 !sd_dhcp_server_is_running(link->dhcp_server)) {
314 struct in_addr pool_start;
317 address = link_find_dhcp_server_address(link);
319 log_warning_link(link, "Failed to find suitable address for DHCPv4 server instance.");
320 link_enter_failed(link);
324 log_debug_link(link, "offering DHCPv4 leases");
326 r = sd_dhcp_server_set_address(link->dhcp_server, &address->in_addr.in);
330 /* offer 32 addresses starting from the address following the server address */
331 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
332 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
338 r = sd_dhcp_server_set_router(link->dhcp_server,
339 &main_address->in_addr.in);
343 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
344 main_address->prefixlen);
349 r = sd_dhcp_server_start(link->dhcp_server);
351 log_warning_link(link, "could not start DHCPv4 server "
352 "instance: %s", strerror(-r));
354 link_enter_failed(link);
360 log_info_link(link, "link configured");
362 link->state = LINK_STATE_CONFIGURED;
369 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
370 _cleanup_link_unref_ Link *link = userdata;
373 assert(link->route_messages > 0);
374 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
375 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
378 link->route_messages --;
380 if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER))
383 r = sd_rtnl_message_get_errno(m);
384 if (r < 0 && r != -EEXIST)
385 log_struct_link(LOG_WARNING, link,
386 "MESSAGE=%-*s: could not set route: %s",
388 link->ifname, strerror(-r),
392 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
394 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
395 log_debug_link(link, "routes set");
396 link_enter_configured(link);
402 static int link_set_dhcp_routes(Link *link) {
403 struct sd_dhcp_route *static_routes;
408 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes);
411 log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-n));
415 for (i = 0; i < n; i++) {
416 _cleanup_route_free_ Route *route = NULL;
418 r = route_new_dynamic(&route);
420 log_error_link(link, "Could not allocate route: %s",
425 route->family = AF_INET;
426 route->in_addr.in = static_routes[i].gw_addr;
427 route->dst_addr.in = static_routes[i].dst_addr;
428 route->dst_prefixlen = static_routes[i].dst_prefixlen;
429 route->metrics = DHCP_ROUTE_METRIC;
431 r = route_configure(route, link, &route_handler);
433 log_warning_link(link,
434 "could not set host route: %s", strerror(-r));
438 link->route_messages ++;
444 static int link_enter_set_routes(Link *link) {
449 assert(link->network);
450 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
452 link->state = LINK_STATE_SETTING_ROUTES;
454 if (!link->network->static_routes && !link->dhcp_lease &&
455 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
456 return link_enter_configured(link);
458 log_debug_link(link, "setting routes");
460 LIST_FOREACH(routes, rt, link->network->static_routes) {
461 r = route_configure(rt, link, &route_handler);
463 log_warning_link(link,
464 "could not set routes: %s", strerror(-r));
465 link_enter_failed(link);
469 link->route_messages ++;
472 if (link->ipv4ll && !link->dhcp_lease) {
473 _cleanup_route_free_ Route *route = NULL;
476 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
477 if (r < 0 && r != -ENOENT) {
478 log_warning_link(link, "IPV4LL error: no address: %s",
484 r = route_new_dynamic(&route);
486 log_error_link(link, "Could not allocate route: %s",
491 route->family = AF_INET;
492 route->scope = RT_SCOPE_LINK;
493 route->metrics = IPV4LL_ROUTE_METRIC;
495 r = route_configure(route, link, &route_handler);
497 log_warning_link(link,
498 "could not set routes: %s", strerror(-r));
499 link_enter_failed(link);
503 link->route_messages ++;
507 if (link->dhcp_lease) {
508 _cleanup_route_free_ Route *route = NULL;
509 _cleanup_route_free_ Route *route_gw = NULL;
510 struct in_addr gateway;
512 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
513 if (r < 0 && r != -ENOENT) {
514 log_warning_link(link, "DHCP error: could not get gateway: %s",
520 r = route_new_dynamic(&route);
522 log_error_link(link, "Could not allocate route: %s",
527 r = route_new_dynamic(&route_gw);
529 log_error_link(link, "Could not allocate route: %s",
534 /* The dhcp netmask may mask out the gateway. Add an explicit
535 * route for the gw host so that we can route no matter the
536 * netmask or existing kernel route tables. */
537 route_gw->family = AF_INET;
538 route_gw->dst_addr.in = gateway;
539 route_gw->dst_prefixlen = 32;
540 route_gw->scope = RT_SCOPE_LINK;
541 route_gw->metrics = DHCP_ROUTE_METRIC;
543 r = route_configure(route_gw, link, &route_handler);
545 log_warning_link(link,
546 "could not set host route: %s", strerror(-r));
550 link->route_messages ++;
552 route->family = AF_INET;
553 route->in_addr.in = gateway;
554 route->metrics = DHCP_ROUTE_METRIC;
556 r = route_configure(route, link, &route_handler);
558 log_warning_link(link,
559 "could not set routes: %s", strerror(-r));
560 link_enter_failed(link);
564 link->route_messages ++;
567 if (link->network->dhcp_routes)
568 link_set_dhcp_routes(link);
571 if (link->route_messages == 0) {
572 link_enter_configured(link);
578 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
579 _cleanup_link_unref_ Link *link = userdata;
584 assert(link->ifname);
586 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
589 r = sd_rtnl_message_get_errno(m);
590 if (r < 0 && r != -ESRCH)
591 log_struct_link(LOG_WARNING, link,
592 "MESSAGE=%-*s: could not drop route: %s",
594 link->ifname, strerror(-r),
601 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
602 _cleanup_link_unref_ Link *link = userdata;
608 assert(link->manager);
610 for (; m; m = sd_rtnl_message_next(m)) {
611 r = sd_rtnl_message_get_errno(m);
613 log_debug_link(link, "getting address failed: %s", strerror(-r));
617 r = link_rtnl_process_address(rtnl, m, link->manager);
619 log_warning_link(link, "could not process address: %s", strerror(-r));
625 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
626 _cleanup_link_unref_ Link *link = userdata;
632 assert(link->ifname);
633 assert(link->addr_messages > 0);
634 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
635 LINK_STATE_FAILED, LINK_STATE_LINGER));
637 link->addr_messages --;
639 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
642 r = sd_rtnl_message_get_errno(m);
643 if (r < 0 && r != -EEXIST)
644 log_struct_link(LOG_WARNING, link,
645 "MESSAGE=%-*s: could not set address: %s",
647 link->ifname, strerror(-r),
651 /* calling handler directly so take a ref */
653 link_get_address_handler(rtnl, m, link);
656 if (link->addr_messages == 0) {
657 log_debug_link(link, "addresses set");
658 link_enter_set_routes(link);
664 static int link_enter_set_addresses(Link *link) {
667 uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
670 assert(link->network);
671 assert(link->state != _LINK_STATE_INVALID);
673 link->state = LINK_STATE_SETTING_ADDRESSES;
675 if (!link->network->static_addresses && !link->dhcp_lease &&
676 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
677 return link_enter_set_routes(link);
679 log_debug_link(link, "setting addresses");
681 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
682 r = address_configure(ad, link, &address_handler);
684 log_warning_link(link,
685 "could not set addresses: %s", strerror(-r));
686 link_enter_failed(link);
690 link->addr_messages ++;
693 if (link->ipv4ll && !link->dhcp_lease) {
694 _cleanup_address_free_ Address *ll_addr = NULL;
697 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
698 if (r < 0 && r != -ENOENT) {
699 log_warning_link(link, "IPV4LL error: no address: %s",
705 r = address_new_dynamic(&ll_addr);
707 log_error_link(link, "Could not allocate address: %s", strerror(-r));
711 ll_addr->family = AF_INET;
712 ll_addr->in_addr.in = addr;
713 ll_addr->prefixlen = 16;
714 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
715 ll_addr->scope = RT_SCOPE_LINK;
717 r = address_configure(ll_addr, link, &address_handler);
719 log_warning_link(link,
720 "could not set addresses: %s", strerror(-r));
721 link_enter_failed(link);
725 link->addr_messages ++;
729 if (link->dhcp_lease) {
730 _cleanup_address_free_ Address *address = NULL;
732 struct in_addr netmask;
735 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
737 log_warning_link(link, "DHCP error: no address: %s",
742 if (!link->network->dhcp_critical) {
743 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
746 log_warning_link(link, "DHCP error: no lifetime: %s",
752 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
754 log_warning_link(link, "DHCP error: no netmask: %s",
759 prefixlen = net_netmask_to_prefixlen(&netmask);
761 r = address_new_dynamic(&address);
763 log_error_link(link, "Could not allocate address: %s",
768 address->family = AF_INET;
769 address->in_addr.in = addr;
770 address->cinfo.ifa_prefered = lifetime;
771 address->cinfo.ifa_valid = lifetime;
772 address->prefixlen = prefixlen;
773 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
775 /* use update rather than configure so that we will update the lifetime
776 of an existing address if it has already been configured */
777 r = address_update(address, link, &address_handler);
779 log_warning_link(link,
780 "could not set addresses: %s", strerror(-r));
781 link_enter_failed(link);
785 link->addr_messages ++;
791 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
792 _cleanup_link_unref_ Link *link = userdata;
797 assert(link->ifname);
799 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
802 r = sd_rtnl_message_get_errno(m);
803 if (r < 0 && r != -ENOENT)
804 log_struct_link(LOG_WARNING, link,
805 "MESSAGE=%-*s: could not update address: %s",
807 link->ifname, strerror(-r),
814 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
815 _cleanup_link_unref_ Link *link = userdata;
820 assert(link->ifname);
822 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
825 r = sd_rtnl_message_get_errno(m);
826 if (r < 0 && r != -EADDRNOTAVAIL)
827 log_struct_link(LOG_WARNING, link,
828 "MESSAGE=%-*s: could not drop address: %s",
830 link->ifname, strerror(-r),
837 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
838 _cleanup_link_unref_ Link *link = userdata;
843 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
846 r = sd_bus_message_get_errno(m);
848 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
853 static int link_set_hostname(Link *link, const char *hostname) {
854 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
858 assert(link->manager);
861 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
863 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
864 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
868 r = sd_bus_message_new_method_call(
871 "org.freedesktop.hostname1",
872 "/org/freedesktop/hostname1",
873 "org.freedesktop.hostname1",
878 r = sd_bus_message_append(m, "sb", hostname, false);
882 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
884 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
893 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
894 _cleanup_link_unref_ Link *link = userdata;
899 assert(link->ifname);
901 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
904 r = sd_rtnl_message_get_errno(m);
906 log_struct_link(LOG_WARNING, link,
907 "MESSAGE=%-*s: could not set MTU: %s",
908 IFNAMSIZ, link->ifname, strerror(-r),
915 static int link_set_mtu(Link *link, uint32_t mtu) {
916 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
920 assert(link->manager);
921 assert(link->manager->rtnl);
923 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
925 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
926 RTM_SETLINK, link->ifindex);
928 log_error_link(link, "Could not allocate RTM_SETLINK message");
932 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
934 log_error_link(link, "Could not append MTU: %s", strerror(-r));
938 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
941 "Could not send rtnetlink message: %s", strerror(-r));
950 static int dhcp_lease_lost(Link *link) {
951 _cleanup_address_free_ Address *address = NULL;
953 struct in_addr netmask;
954 struct in_addr gateway;
959 assert(link->dhcp_lease);
961 log_warning_link(link, "DHCP lease lost");
963 if (link->network->dhcp_routes) {
964 struct sd_dhcp_route *routes;
967 n = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes);
969 for (i = 0; i < n; i++) {
970 _cleanup_route_free_ Route *route = NULL;
972 r = route_new_dynamic(&route);
974 route->family = AF_INET;
975 route->in_addr.in = routes[i].gw_addr;
976 route->dst_addr.in = routes[i].dst_addr;
977 route->dst_prefixlen = routes[i].dst_prefixlen;
979 route_drop(route, link, &route_drop_handler);
985 r = address_new_dynamic(&address);
987 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
989 _cleanup_route_free_ Route *route_gw = NULL;
990 _cleanup_route_free_ Route *route = NULL;
992 r = route_new_dynamic(&route_gw);
994 route_gw->family = AF_INET;
995 route_gw->dst_addr.in = gateway;
996 route_gw->dst_prefixlen = 32;
997 route_gw->scope = RT_SCOPE_LINK;
999 route_drop(route_gw, link, &route_drop_handler);
1002 r = route_new_dynamic(&route);
1004 route->family = AF_INET;
1005 route->in_addr.in = gateway;
1007 route_drop(route, link, &route_drop_handler);
1011 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
1012 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
1013 prefixlen = net_netmask_to_prefixlen(&netmask);
1015 address->family = AF_INET;
1016 address->in_addr.in = addr;
1017 address->prefixlen = prefixlen;
1019 address_drop(address, link, &address_drop_handler);
1022 if (link->network->dhcp_mtu) {
1025 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1026 if (r >= 0 && link->original_mtu != mtu) {
1027 r = link_set_mtu(link, link->original_mtu);
1029 log_warning_link(link, "DHCP error: could not reset MTU");
1030 link_enter_failed(link);
1036 if (link->network->dhcp_hostname) {
1037 const char *hostname = NULL;
1039 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1040 if (r >= 0 && hostname) {
1041 r = link_set_hostname(link, "");
1043 log_error_link(link, "Failed to reset transient hostname");
1047 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1052 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1053 sd_dhcp_lease *lease;
1056 r = sd_dhcp_client_get_lease(client, &lease);
1058 log_warning_link(link, "DHCP error: no lease %s",
1063 sd_dhcp_lease_unref(link->dhcp_lease);
1064 link->dhcp_lease = lease;
1066 link_enter_set_addresses(link);
1071 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1072 sd_dhcp_lease *lease;
1073 struct in_addr address;
1074 struct in_addr netmask;
1075 struct in_addr gateway;
1082 r = sd_dhcp_client_get_lease(client, &lease);
1084 log_warning_link(link, "DHCP error: no lease: %s",
1089 r = sd_dhcp_lease_get_address(lease, &address);
1091 log_warning_link(link, "DHCP error: no address: %s",
1096 r = sd_dhcp_lease_get_netmask(lease, &netmask);
1098 log_warning_link(link, "DHCP error: no netmask: %s",
1103 prefixlen = net_netmask_to_prefixlen(&netmask);
1105 r = sd_dhcp_lease_get_router(lease, &gateway);
1106 if (r < 0 && r != -ENOENT) {
1107 log_warning_link(link, "DHCP error: could not get gateway: %s",
1113 log_struct_link(LOG_INFO, link,
1114 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1117 ADDRESS_FMT_VAL(address),
1119 ADDRESS_FMT_VAL(gateway),
1120 "ADDRESS=%u.%u.%u.%u",
1121 ADDRESS_FMT_VAL(address),
1124 "GATEWAY=%u.%u.%u.%u",
1125 ADDRESS_FMT_VAL(gateway),
1128 log_struct_link(LOG_INFO, link,
1129 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1132 ADDRESS_FMT_VAL(address),
1134 "ADDRESS=%u.%u.%u.%u",
1135 ADDRESS_FMT_VAL(address),
1140 link->dhcp_lease = lease;
1142 if (link->network->dhcp_mtu) {
1145 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1147 r = link_set_mtu(link, mtu);
1149 log_error_link(link, "Failed to set MTU "
1150 "to %" PRIu16, mtu);
1154 if (link->network->dhcp_hostname) {
1155 const char *hostname;
1157 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1159 r = link_set_hostname(link, hostname);
1161 log_error_link(link, "Failed to set transient hostname "
1162 "to '%s'", hostname);
1166 link_enter_set_addresses(link);
1171 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1172 Link *link = userdata;
1176 assert(link->network);
1177 assert(link->manager);
1179 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1183 case DHCP_EVENT_NO_LEASE:
1184 log_debug_link(link, "IP address in use.");
1186 case DHCP_EVENT_EXPIRED:
1187 case DHCP_EVENT_STOP:
1188 case DHCP_EVENT_IP_CHANGE:
1189 if (link->network->dhcp_critical) {
1190 log_error_link(link, "DHCPv4 connection considered system critical, "
1191 "ignoring request to reconfigure it.");
1195 if (link->dhcp_lease) {
1196 r = dhcp_lease_lost(link);
1198 link_enter_failed(link);
1203 if (event == DHCP_EVENT_IP_CHANGE) {
1204 r = dhcp_lease_acquired(client, link);
1206 link_enter_failed(link);
1211 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1212 if (!sd_ipv4ll_is_running(link->ipv4ll))
1213 r = sd_ipv4ll_start(link->ipv4ll);
1214 else if (ipv4ll_is_bound(link->ipv4ll))
1215 r = ipv4ll_address_update(link, false);
1217 link_enter_failed(link);
1223 case DHCP_EVENT_RENEW:
1224 r = dhcp_lease_renew(client, link);
1226 link_enter_failed(link);
1230 case DHCP_EVENT_IP_ACQUIRE:
1231 r = dhcp_lease_acquired(client, link);
1233 link_enter_failed(link);
1237 if (ipv4ll_is_bound(link->ipv4ll))
1238 r = ipv4ll_address_update(link, true);
1240 r = sd_ipv4ll_stop(link->ipv4ll);
1242 link_enter_failed(link);
1249 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1251 log_warning_link(link, "DHCP unknown event: %d", event);
1258 static int ipv4ll_address_update(Link *link, bool deprecate) {
1260 struct in_addr addr;
1264 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1266 _cleanup_address_free_ Address *address = NULL;
1268 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1269 deprecate ? "deprecate" : "approve",
1270 ADDRESS_FMT_VAL(addr));
1272 r = address_new_dynamic(&address);
1274 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1278 address->family = AF_INET;
1279 address->in_addr.in = addr;
1280 address->prefixlen = 16;
1281 address->scope = RT_SCOPE_LINK;
1282 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1283 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1285 address_update(address, link, &address_update_handler);
1292 static int ipv4ll_address_lost(Link *link) {
1294 struct in_addr addr;
1298 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1300 _cleanup_address_free_ Address *address = NULL;
1301 _cleanup_route_free_ Route *route = NULL;
1303 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1304 ADDRESS_FMT_VAL(addr));
1306 r = address_new_dynamic(&address);
1308 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1312 address->family = AF_INET;
1313 address->in_addr.in = addr;
1314 address->prefixlen = 16;
1315 address->scope = RT_SCOPE_LINK;
1317 address_drop(address, link, &address_drop_handler);
1319 r = route_new_dynamic(&route);
1321 log_error_link(link, "Could not allocate route: %s",
1326 route->family = AF_INET;
1327 route->scope = RT_SCOPE_LINK;
1328 route->metrics = 99;
1330 route_drop(route, link, &route_drop_handler);
1336 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1338 struct in_addr addr;
1342 r = sd_ipv4ll_get_address(ll, &addr);
1348 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1349 struct in_addr address;
1355 r = sd_ipv4ll_get_address(ll, &address);
1359 log_struct_link(LOG_INFO, link,
1360 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1363 ADDRESS_FMT_VAL(address),
1366 link_enter_set_addresses(link);
1371 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1372 Link *link = userdata;
1376 assert(link->network);
1377 assert(link->manager);
1379 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1383 case IPV4LL_EVENT_STOP:
1384 case IPV4LL_EVENT_CONFLICT:
1385 r = ipv4ll_address_lost(link);
1387 link_enter_failed(link);
1391 case IPV4LL_EVENT_BIND:
1392 r = ipv4ll_address_claimed(ll, link);
1394 link_enter_failed(link);
1400 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1402 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1407 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1408 Link *link = userdata;
1411 assert(link->network);
1412 assert(link->manager);
1414 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1418 case DHCP6_EVENT_STOP:
1419 case DHCP6_EVENT_RESEND_EXPIRE:
1420 case DHCP6_EVENT_RETRANS_MAX:
1421 case DHCP6_EVENT_IP_ACQUIRE:
1422 log_debug_link(link, "DHCPv6 event %d", event);
1428 log_warning_link(link, "DHCPv6 error: %s",
1431 log_warning_link(link, "DHCPv6 unknown event: %d",
1437 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1438 Link *link = userdata;
1442 assert(link->network);
1443 assert(link->manager);
1445 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1449 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1450 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1453 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1454 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1459 log_warning_link(link, "ICMPv6 error: %s",
1462 log_warning_link(link, "ICMPv6 unknown event: %d",
1468 if (link->dhcp6_client)
1471 r = sd_dhcp6_client_new(&link->dhcp6_client);
1475 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1477 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1481 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1483 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1487 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1489 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1493 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1496 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1500 r = sd_dhcp6_client_start(link->dhcp6_client);
1502 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1505 static int link_acquire_conf(Link *link) {
1509 assert(link->network);
1510 assert(link->manager);
1511 assert(link->manager->event);
1513 if (link->network->ipv4ll) {
1514 assert(link->ipv4ll);
1516 log_debug_link(link, "acquiring IPv4 link-local address");
1518 r = sd_ipv4ll_start(link->ipv4ll);
1520 log_warning_link(link, "could not acquire IPv4 "
1521 "link-local address");
1526 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1527 assert(link->dhcp_client);
1529 log_debug_link(link, "acquiring DHCPv4 lease");
1531 r = sd_dhcp_client_start(link->dhcp_client);
1533 log_warning_link(link, "could not acquire DHCPv4 "
1539 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1540 assert(link->icmp6_router_discovery);
1542 log_debug_link(link, "discovering IPv6 routers");
1544 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1546 log_warning_link(link, "could not start IPv6 router discovery");
1554 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1555 /* see Documentation/networking/operstates.txt in the kernel sources */
1557 if (operstate == IF_OPER_UP)
1560 if (operstate == IF_OPER_UNKNOWN)
1561 /* operstate may not be implemented, so fall back to flags */
1562 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1568 #define FLAG_STRING(string, flag, old, new) \
1569 (((old ^ new) & flag) \
1570 ? ((old & flag) ? (" -" string) : (" +" string)) \
1573 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1574 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1576 bool carrier_gained = false, carrier_lost = false;
1581 r = sd_rtnl_message_link_get_flags(m, &flags);
1583 log_warning_link(link, "Could not get link flags");
1587 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1589 /* if we got a message without operstate, take it to mean
1590 the state was unchanged */
1591 operstate = link->kernel_operstate;
1593 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1596 if (link->flags != flags) {
1597 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",
1598 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1599 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1600 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1601 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1602 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1603 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1604 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1605 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1606 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1607 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1608 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1609 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1610 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1611 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1612 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1613 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1614 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1615 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1616 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1618 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1619 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1620 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1621 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1622 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1623 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1624 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1625 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1627 /* link flags are currently at most 18 bits, let's align to printing 20 */
1628 if (unknown_flags_added)
1629 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1630 unknown_flags_added);
1632 if (unknown_flags_removed)
1633 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1634 unknown_flags_removed);
1637 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1638 link_has_carrier(flags, operstate);
1639 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1640 !link_has_carrier(flags, operstate);
1642 link->flags = flags;
1643 link->kernel_operstate = operstate;
1647 if (link->state == LINK_STATE_FAILED ||
1648 link->state == LINK_STATE_UNMANAGED)
1651 if (carrier_gained) {
1652 log_info_link(link, "gained carrier");
1654 if (link->network) {
1655 r = link_acquire_conf(link);
1657 link_enter_failed(link);
1661 } else if (carrier_lost) {
1662 log_info_link(link, "lost carrier");
1664 r = link_stop_clients(link);
1666 link_enter_failed(link);
1674 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1675 _cleanup_link_unref_ Link *link = userdata;
1680 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1683 r = sd_rtnl_message_get_errno(m);
1685 /* we warn but don't fail the link, as it may
1686 be brought up later */
1687 log_struct_link(LOG_WARNING, link,
1688 "MESSAGE=%-*s: could not bring up interface: %s",
1690 link->ifname, strerror(-r),
1698 static int link_up(Link *link) {
1699 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1703 assert(link->manager);
1704 assert(link->manager->rtnl);
1706 log_debug_link(link, "bringing link up");
1708 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1709 RTM_SETLINK, link->ifindex);
1711 log_error_link(link, "Could not allocate RTM_SETLINK message");
1715 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1717 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1721 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1723 log_error_link(link,
1724 "Could not send rtnetlink message: %s", strerror(-r));
1733 static int link_joined(Link *link) {
1737 assert(link->state == LINK_STATE_ENSLAVING);
1738 assert(link->network);
1740 log_debug_link(link, "joined netdev");
1742 if (!(link->flags & IFF_UP)) {
1745 link_enter_failed(link);
1750 return link_enter_set_addresses(link);
1753 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1754 _cleanup_link_unref_ Link *link = userdata;
1758 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1759 LINK_STATE_LINGER));
1760 assert(link->network);
1764 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1767 r = sd_rtnl_message_get_errno(m);
1768 if (r < 0 && r != -EEXIST) {
1769 log_struct_link(LOG_ERR, link,
1770 "MESSAGE=%-*s: could not join netdev: %s",
1772 link->ifname, strerror(-r),
1775 link_enter_failed(link);
1779 if (link->enslaving <= 0)
1785 static int link_enter_join_netdev(Link *link) {
1786 NetDev *vlan, *macvlan, *vxlan;
1791 assert(link->network);
1792 assert(link->state == LINK_STATE_INITIALIZING);
1794 link->state = LINK_STATE_ENSLAVING;
1798 if (!link->network->bridge &&
1799 !link->network->bond &&
1800 !link->network->tunnel &&
1801 hashmap_isempty(link->network->vlans) &&
1802 hashmap_isempty(link->network->macvlans) &&
1803 hashmap_isempty(link->network->vxlans))
1804 return link_joined(link);
1806 if (link->network->bond) {
1807 log_struct_link(LOG_DEBUG, link,
1808 "MESSAGE=%-*s: enslaving by '%s'",
1810 link->ifname, link->network->bond->ifname,
1811 NETDEV(link->network->bond),
1814 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1816 log_struct_link(LOG_WARNING, link,
1817 "MESSAGE=%-*s: could not join netdev '%s': %s",
1819 link->ifname, link->network->bond->ifname, strerror(-r),
1820 NETDEV(link->network->bond),
1822 link_enter_failed(link);
1829 if (link->network->bridge) {
1830 log_struct_link(LOG_DEBUG, link,
1831 "MESSAGE=%-*s: enslaving by '%s'",
1833 link->ifname, link->network->bridge->ifname,
1834 NETDEV(link->network->bridge),
1837 r = netdev_join(link->network->bridge, link, &netdev_join_handler);
1839 log_struct_link(LOG_WARNING, link,
1840 "MESSAGE=%-*s: could not join netdev '%s': %s",
1842 link->ifname, link->network->bridge->ifname, strerror(-r),
1843 NETDEV(link->network->bridge),
1845 link_enter_failed(link);
1852 if (link->network->tunnel) {
1853 log_struct_link(LOG_DEBUG, link,
1854 "MESSAGE=%-*s: enslaving by '%s'",
1856 link->ifname, link->network->tunnel->ifname,
1857 NETDEV(link->network->tunnel),
1860 r = netdev_join(link->network->tunnel, link, &netdev_join_handler);
1862 log_struct_link(LOG_WARNING, link,
1863 "MESSAGE=%-*s: could not join netdev '%s': %s",
1865 link->ifname, link->network->tunnel->ifname, strerror(-r),
1866 NETDEV(link->network->tunnel),
1868 link_enter_failed(link);
1875 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1876 log_struct_link(LOG_DEBUG, link,
1877 "MESSAGE=%-*s: enslaving by '%s'",
1879 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1881 r = netdev_join(vlan, link, &netdev_join_handler);
1883 log_struct_link(LOG_WARNING, link,
1884 "MESSAGE=%-*s: could not join netdev '%s': %s",
1886 link->ifname, vlan->ifname, strerror(-r),
1887 NETDEV(vlan), NULL);
1888 link_enter_failed(link);
1895 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1896 log_struct_link(LOG_DEBUG, link,
1897 "MESSAGE=%-*s: enslaving by '%s'",
1899 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1901 r = netdev_join(macvlan, link, &netdev_join_handler);
1903 log_struct_link(LOG_WARNING, link,
1904 "MESSAGE=%-*s: could not join netdev '%s': %s",
1906 link->ifname, macvlan->ifname, strerror(-r),
1907 NETDEV(macvlan), NULL);
1908 link_enter_failed(link);
1915 HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1916 log_struct_link(LOG_DEBUG, link,
1917 "MESSAGE=%*s: enslaving by '%s'",
1919 link->ifname, vxlan->ifname, NETDEV(vxlan), NULL);
1921 r = netdev_join(vxlan, link, &netdev_join_handler);
1923 log_struct_link(LOG_WARNING, link,
1924 "MESSAGE=%*s: could not join netdev '%s': %s",
1926 link->ifname, vxlan->ifname, strerror(-r),
1927 NETDEV(vxlan), NULL);
1928 link_enter_failed(link);
1938 static int link_configure(Link *link) {
1942 assert(link->state == LINK_STATE_INITIALIZING);
1944 if (link->network->ipv4ll) {
1947 r = sd_ipv4ll_new(&link->ipv4ll);
1951 if (link->udev_device) {
1952 r = net_get_unique_predictable_data(link->udev_device, seed);
1954 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1960 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1964 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1968 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1972 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1977 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1978 r = sd_dhcp_client_new(&link->dhcp_client);
1982 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1986 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1990 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1994 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1998 r = sd_dhcp_client_set_request_broadcast(link->dhcp_client, link->network->dhcp_broadcast);
2002 if (link->network->dhcp_mtu) {
2003 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
2008 if (link->network->dhcp_routes) {
2009 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
2012 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
2017 if (link->network->dhcp_sendhost) {
2018 _cleanup_free_ char *hostname = gethostname_malloc();
2022 if (!is_localhost(hostname)) {
2023 r = sd_dhcp_client_set_hostname(link->dhcp_client, hostname);
2029 if (link->network->dhcp_vendor_class_identifier) {
2030 r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
2031 link->network->dhcp_vendor_class_identifier);
2037 if (link->network->dhcp_server) {
2038 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2042 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2047 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
2048 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
2052 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
2057 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
2062 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
2067 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
2068 icmp6_router_handler, link);
2073 if (link_has_carrier(link->flags, link->kernel_operstate)) {
2074 r = link_acquire_conf(link);
2079 return link_enter_join_netdev(link);
2082 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2083 _cleanup_link_unref_ Link *link = userdata;
2088 assert(link->ifname);
2089 assert(link->manager);
2091 if (link->state != LINK_STATE_INITIALIZING)
2094 log_debug_link(link, "link state is up-to-date");
2096 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2098 link_enter_unmanaged(link);
2103 r = network_apply(link->manager, network, link);
2107 r = link_configure(link);
2114 int link_initialized(Link *link, struct udev_device *device) {
2115 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2119 assert(link->manager);
2120 assert(link->manager->rtnl);
2123 if (link->state != LINK_STATE_INITIALIZING)
2126 if (link->udev_device)
2129 log_debug_link(link, "udev initialized link");
2131 link->udev_device = udev_device_ref(device);
2133 /* udev has initialized the link, but we don't know if we have yet processed
2134 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2135 we know that the pending NEWLINKs have already been processed and that we
2138 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2142 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2151 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2152 Manager *m = userdata;
2155 _cleanup_address_free_ Address *address = NULL;
2157 char buf[INET6_ADDRSTRLEN];
2158 bool address_dropped = false;
2165 r = sd_rtnl_message_get_type(message, &type);
2167 log_warning("rtnl: could not get message type");
2171 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2172 if (r < 0 || ifindex <= 0) {
2173 log_warning("rtnl: received address message without valid ifindex, ignoring");
2176 r = link_get(m, ifindex, &link);
2177 if (r < 0 || !link) {
2178 log_warning("rtnl: received address for a nonexistent link, ignoring");
2183 r = address_new_dynamic(&address);
2187 r = sd_rtnl_message_addr_get_family(message, &address->family);
2188 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2189 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2193 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2195 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2199 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2201 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2205 switch (address->family) {
2207 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2209 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2216 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2218 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2225 assert_not_reached("invalid address family");
2228 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2229 log_warning_link(link, "could not print address");
2233 LIST_FOREACH(addresses, ad, link->addresses) {
2234 if (address_equal(ad, address)) {
2235 LIST_REMOVE(addresses, link->addresses, ad);
2239 address_dropped = true;
2247 if (!address_dropped)
2248 log_debug_link(link, "added address: %s/%u", buf,
2249 address->prefixlen);
2251 log_debug_link(link, "updated address: %s/%u", buf,
2252 address->prefixlen);
2254 LIST_PREPEND(addresses, link->addresses, address);
2261 if (address_dropped) {
2262 log_debug_link(link, "removed address: %s/%u", buf,
2263 address->prefixlen);
2267 log_warning_link(link, "removing non-existent address: %s/%u",
2268 buf, address->prefixlen);
2272 assert_not_reached("Received invalid RTNL message type");
2278 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2280 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2281 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2282 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2290 r = link_new(m, message, ret);
2296 log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2298 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2302 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2308 if (detect_container(NULL) <= 0) {
2309 /* not in a container, udev will be around */
2310 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2311 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2313 log_warning_link(link, "could not find udev device");
2317 if (udev_device_get_is_initialized(device) <= 0) {
2319 log_debug_link(link, "udev initializing link...");
2323 r = link_initialized(link, device);
2327 /* we are calling a callback directly, so must take a ref */
2330 r = link_initialized_and_synced(m->rtnl, NULL, link);
2338 int link_update(Link *link, sd_rtnl_message *m) {
2339 struct ether_addr mac;
2344 assert(link->ifname);
2347 if (link->state == LINK_STATE_LINGER) {
2349 log_info_link(link, "link readded");
2350 link->state = LINK_STATE_ENSLAVING;
2353 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2354 if (r >= 0 && !streq(ifname, link->ifname)) {
2355 log_info_link(link, "renamed to %s", ifname);
2358 link->ifname = strdup(ifname);
2363 if (!link->original_mtu) {
2364 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2366 log_debug_link(link, "saved original MTU: %"
2367 PRIu16, link->original_mtu);
2370 /* The kernel may broadcast NEWLINK messages without the MAC address
2371 set, simply ignore them. */
2372 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2374 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2376 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2378 log_debug_link(link, "MAC address: "
2379 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2380 mac.ether_addr_octet[0],
2381 mac.ether_addr_octet[1],
2382 mac.ether_addr_octet[2],
2383 mac.ether_addr_octet[3],
2384 mac.ether_addr_octet[4],
2385 mac.ether_addr_octet[5]);
2388 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2390 log_warning_link(link, "Could not update MAC "
2391 "address in IPv4LL client: %s",
2397 if (link->dhcp_client) {
2398 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2400 log_warning_link(link, "Could not update MAC "
2401 "address in DHCP client: %s",
2407 if (link->dhcp6_client) {
2408 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2411 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2419 return link_update_flags(link, m);
2422 static void serialize_addresses(FILE *f, const char *key, Address *address) {
2431 fprintf(f, "%s=", key);
2433 LIST_FOREACH(addresses, ad, address) {
2434 char buf[INET6_ADDRSTRLEN];
2436 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
2437 fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2443 static void link_update_operstate(Link *link) {
2447 if (link->kernel_operstate == IF_OPER_DORMANT)
2448 link->operstate = LINK_OPERSTATE_DORMANT;
2449 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2451 uint8_t scope = RT_SCOPE_NOWHERE;
2453 /* if we have carrier, check what addresses we have */
2454 LIST_FOREACH(addresses, address, link->addresses) {
2455 if (address->scope < scope)
2456 scope = address->scope;
2459 if (scope < RT_SCOPE_SITE)
2460 /* universally accessible addresses found */
2461 link->operstate = LINK_OPERSTATE_ROUTABLE;
2462 else if (scope < RT_SCOPE_HOST)
2463 /* only link or site local addresses found */
2464 link->operstate = LINK_OPERSTATE_DEGRADED;
2466 /* no useful addresses found */
2467 link->operstate = LINK_OPERSTATE_CARRIER;
2469 link->operstate = LINK_OPERSTATE_UNKNOWN;
2472 int link_save(Link *link) {
2473 _cleanup_free_ char *temp_path = NULL;
2474 _cleanup_fclose_ FILE *f = NULL;
2475 const char *admin_state, *oper_state;
2479 assert(link->state_file);
2480 assert(link->lease_file);
2481 assert(link->manager);
2483 link_update_operstate(link);
2485 r = manager_save(link->manager);
2489 if (link->state == LINK_STATE_LINGER) {
2490 unlink(link->state_file);
2494 admin_state = link_state_to_string(link->state);
2495 assert(admin_state);
2497 oper_state = link_operstate_to_string(link->operstate);
2500 r = fopen_temporary(link->state_file, &f, &temp_path);
2504 fchmod(fileno(f), 0644);
2507 "# This is private data. Do not parse.\n"
2510 admin_state, oper_state);
2512 if (link->network) {
2513 serialize_addresses(f, "DNS", link->network->dns);
2514 serialize_addresses(f, "NTP", link->network->ntp);
2517 if (link->dhcp_lease) {
2518 assert(link->network);
2520 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2527 "DHCP_USE_NTP=%s\n",
2529 yes_no(link->network->dhcp_dns),
2530 yes_no(link->network->dhcp_ntp));
2532 unlink(link->lease_file);
2536 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2538 unlink(link->state_file);
2544 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2549 static const char* const link_state_table[_LINK_STATE_MAX] = {
2550 [LINK_STATE_INITIALIZING] = "initializing",
2551 [LINK_STATE_ENSLAVING] = "configuring",
2552 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2553 [LINK_STATE_SETTING_ROUTES] = "configuring",
2554 [LINK_STATE_CONFIGURED] = "configured",
2555 [LINK_STATE_UNMANAGED] = "unmanaged",
2556 [LINK_STATE_FAILED] = "failed",
2557 [LINK_STATE_LINGER] = "linger",
2560 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2562 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2563 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2564 [LINK_OPERSTATE_DORMANT] = "dormant",
2565 [LINK_OPERSTATE_CARRIER] = "carrier",
2566 [LINK_OPERSTATE_DEGRADED] = "degraded",
2567 [LINK_OPERSTATE_ROUTABLE] = "routable",
2570 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2572 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2573 [DHCP_SUPPORT_NONE] = "none",
2574 [DHCP_SUPPORT_BOTH] = "both",
2575 [DHCP_SUPPORT_V4] = "v4",
2576 [DHCP_SUPPORT_V6] = "v6",
2579 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2581 int config_parse_dhcp(
2583 const char *filename,
2585 const char *section,
2586 unsigned section_line,
2593 DHCPSupport *dhcp = data;
2601 /* Our enum shall be a superset of booleans, hence first try
2602 * to parse as boolean, and then as enum */
2604 k = parse_boolean(rvalue);
2606 *dhcp = DHCP_SUPPORT_BOTH;
2608 *dhcp = DHCP_SUPPORT_NONE;
2612 s = dhcp_support_from_string(rvalue);
2614 log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);