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;
404 size_t static_routes_size;
410 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes, &static_routes_size);
413 log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-r));
417 for (i = 0; i < static_routes_size; i++) {
418 _cleanup_route_free_ Route *route = NULL;
420 r = route_new_dynamic(&route);
422 log_error_link(link, "Could not allocate route: %s",
427 route->family = AF_INET;
428 route->in_addr.in = static_routes[i].gw_addr;
429 route->dst_addr.in = static_routes[i].dst_addr;
430 route->dst_prefixlen = static_routes[i].dst_prefixlen;
431 route->metrics = DHCP_ROUTE_METRIC;
433 r = route_configure(route, link, &route_handler);
435 log_warning_link(link,
436 "could not set host route: %s", strerror(-r));
440 link->route_messages ++;
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 && !link->dhcp_lease &&
457 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
458 return link_enter_configured(link);
460 log_debug_link(link, "setting routes");
462 LIST_FOREACH(routes, rt, link->network->static_routes) {
463 r = route_configure(rt, link, &route_handler);
465 log_warning_link(link,
466 "could not set routes: %s", strerror(-r));
467 link_enter_failed(link);
471 link->route_messages ++;
474 if (link->ipv4ll && !link->dhcp_lease) {
475 _cleanup_route_free_ Route *route = NULL;
478 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
479 if (r < 0 && r != -ENOENT) {
480 log_warning_link(link, "IPV4LL error: no address: %s",
486 r = route_new_dynamic(&route);
488 log_error_link(link, "Could not allocate route: %s",
493 route->family = AF_INET;
494 route->scope = RT_SCOPE_LINK;
495 route->metrics = IPV4LL_ROUTE_METRIC;
497 r = route_configure(route, link, &route_handler);
499 log_warning_link(link,
500 "could not set routes: %s", strerror(-r));
501 link_enter_failed(link);
505 link->route_messages ++;
509 if (link->dhcp_lease) {
510 _cleanup_route_free_ Route *route = NULL;
511 _cleanup_route_free_ Route *route_gw = NULL;
512 struct in_addr gateway;
514 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
515 if (r < 0 && r != -ENOENT) {
516 log_warning_link(link, "DHCP error: could not get gateway: %s",
522 r = route_new_dynamic(&route);
524 log_error_link(link, "Could not allocate route: %s",
529 r = route_new_dynamic(&route_gw);
531 log_error_link(link, "Could not allocate route: %s",
536 /* The dhcp netmask may mask out the gateway. Add an explicit
537 * route for the gw host so that we can route no matter the
538 * netmask or existing kernel route tables. */
539 route_gw->family = AF_INET;
540 route_gw->dst_addr.in = gateway;
541 route_gw->dst_prefixlen = 32;
542 route_gw->scope = RT_SCOPE_LINK;
543 route_gw->metrics = DHCP_ROUTE_METRIC;
545 r = route_configure(route_gw, link, &route_handler);
547 log_warning_link(link,
548 "could not set host route: %s", strerror(-r));
552 link->route_messages ++;
554 route->family = AF_INET;
555 route->in_addr.in = gateway;
556 route->metrics = DHCP_ROUTE_METRIC;
558 r = route_configure(route, link, &route_handler);
560 log_warning_link(link,
561 "could not set routes: %s", strerror(-r));
562 link_enter_failed(link);
566 link->route_messages ++;
569 if (link->network->dhcp_routes)
570 link_set_dhcp_routes(link);
573 if (link->route_messages == 0) {
574 link_enter_configured(link);
580 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
581 _cleanup_link_unref_ Link *link = userdata;
586 assert(link->ifname);
588 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
591 r = sd_rtnl_message_get_errno(m);
592 if (r < 0 && r != -ESRCH)
593 log_struct_link(LOG_WARNING, link,
594 "MESSAGE=%-*s: could not drop route: %s",
596 link->ifname, strerror(-r),
603 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
604 _cleanup_link_unref_ Link *link = userdata;
610 assert(link->manager);
612 for (; m; m = sd_rtnl_message_next(m)) {
613 r = sd_rtnl_message_get_errno(m);
615 log_debug_link(link, "getting address failed: %s", strerror(-r));
619 r = link_rtnl_process_address(rtnl, m, link->manager);
621 log_warning_link(link, "could not process address: %s", strerror(-r));
627 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
628 _cleanup_link_unref_ Link *link = userdata;
634 assert(link->ifname);
635 assert(link->addr_messages > 0);
636 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
637 LINK_STATE_FAILED, LINK_STATE_LINGER));
639 link->addr_messages --;
641 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
644 r = sd_rtnl_message_get_errno(m);
645 if (r < 0 && r != -EEXIST)
646 log_struct_link(LOG_WARNING, link,
647 "MESSAGE=%-*s: could not set address: %s",
649 link->ifname, strerror(-r),
653 /* calling handler directly so take a ref */
655 link_get_address_handler(rtnl, m, link);
658 if (link->addr_messages == 0) {
659 log_debug_link(link, "addresses set");
660 link_enter_set_routes(link);
666 static int link_enter_set_addresses(Link *link) {
669 uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
672 assert(link->network);
673 assert(link->state != _LINK_STATE_INVALID);
675 link->state = LINK_STATE_SETTING_ADDRESSES;
677 if (!link->network->static_addresses && !link->dhcp_lease &&
678 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
679 return link_enter_set_routes(link);
681 log_debug_link(link, "setting addresses");
683 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
684 r = address_configure(ad, link, &address_handler);
686 log_warning_link(link,
687 "could not set addresses: %s", strerror(-r));
688 link_enter_failed(link);
692 link->addr_messages ++;
695 if (link->ipv4ll && !link->dhcp_lease) {
696 _cleanup_address_free_ Address *ll_addr = NULL;
699 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
700 if (r < 0 && r != -ENOENT) {
701 log_warning_link(link, "IPV4LL error: no address: %s",
707 r = address_new_dynamic(&ll_addr);
709 log_error_link(link, "Could not allocate address: %s", strerror(-r));
713 ll_addr->family = AF_INET;
714 ll_addr->in_addr.in = addr;
715 ll_addr->prefixlen = 16;
716 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
717 ll_addr->scope = RT_SCOPE_LINK;
719 r = address_configure(ll_addr, link, &address_handler);
721 log_warning_link(link,
722 "could not set addresses: %s", strerror(-r));
723 link_enter_failed(link);
727 link->addr_messages ++;
731 if (link->dhcp_lease) {
732 _cleanup_address_free_ Address *address = NULL;
734 struct in_addr netmask;
737 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
739 log_warning_link(link, "DHCP error: no address: %s",
744 if (!link->network->dhcp_critical) {
745 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
748 log_warning_link(link, "DHCP error: no lifetime: %s",
754 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
756 log_warning_link(link, "DHCP error: no netmask: %s",
761 prefixlen = net_netmask_to_prefixlen(&netmask);
763 r = address_new_dynamic(&address);
765 log_error_link(link, "Could not allocate address: %s",
770 address->family = AF_INET;
771 address->in_addr.in = addr;
772 address->cinfo.ifa_prefered = lifetime;
773 address->cinfo.ifa_valid = lifetime;
774 address->prefixlen = prefixlen;
775 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
777 /* use update rather than configure so that we will update the lifetime
778 of an existing address if it has already been configured */
779 r = address_update(address, link, &address_handler);
781 log_warning_link(link,
782 "could not set addresses: %s", strerror(-r));
783 link_enter_failed(link);
787 link->addr_messages ++;
793 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
794 _cleanup_link_unref_ Link *link = userdata;
799 assert(link->ifname);
801 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
804 r = sd_rtnl_message_get_errno(m);
805 if (r < 0 && r != -ENOENT)
806 log_struct_link(LOG_WARNING, link,
807 "MESSAGE=%-*s: could not update address: %s",
809 link->ifname, strerror(-r),
816 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
817 _cleanup_link_unref_ Link *link = userdata;
822 assert(link->ifname);
824 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
827 r = sd_rtnl_message_get_errno(m);
828 if (r < 0 && r != -EADDRNOTAVAIL)
829 log_struct_link(LOG_WARNING, link,
830 "MESSAGE=%-*s: could not drop address: %s",
832 link->ifname, strerror(-r),
839 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
840 _cleanup_link_unref_ Link *link = userdata;
845 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
848 r = sd_bus_message_get_errno(m);
850 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
855 static int link_set_hostname(Link *link, const char *hostname) {
856 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
860 assert(link->manager);
863 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
865 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
866 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
870 r = sd_bus_message_new_method_call(
873 "org.freedesktop.hostname1",
874 "/org/freedesktop/hostname1",
875 "org.freedesktop.hostname1",
880 r = sd_bus_message_append(m, "sb", hostname, false);
884 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
886 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
895 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
896 _cleanup_link_unref_ Link *link = userdata;
901 assert(link->ifname);
903 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
906 r = sd_rtnl_message_get_errno(m);
908 log_struct_link(LOG_WARNING, link,
909 "MESSAGE=%-*s: could not set MTU: %s",
910 IFNAMSIZ, link->ifname, strerror(-r),
917 static int link_set_mtu(Link *link, uint32_t mtu) {
918 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
922 assert(link->manager);
923 assert(link->manager->rtnl);
925 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
927 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
928 RTM_SETLINK, link->ifindex);
930 log_error_link(link, "Could not allocate RTM_SETLINK message");
934 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
936 log_error_link(link, "Could not append MTU: %s", strerror(-r));
940 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
943 "Could not send rtnetlink message: %s", strerror(-r));
952 static int dhcp_lease_lost(Link *link) {
953 _cleanup_address_free_ Address *address = NULL;
955 struct in_addr netmask;
956 struct in_addr gateway;
962 assert(link->dhcp_lease);
964 log_warning_link(link, "DHCP lease lost");
966 if (link->network->dhcp_routes) {
967 struct sd_dhcp_route *routes;
970 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes, &routes_size);
972 for (i = 0; i < routes_size; i++) {
973 _cleanup_route_free_ Route *route = NULL;
975 r = route_new_dynamic(&route);
977 route->family = AF_INET;
978 route->in_addr.in = routes[i].gw_addr;
979 route->dst_addr.in = routes[i].dst_addr;
980 route->dst_prefixlen = routes[i].dst_prefixlen;
982 route_drop(route, link, &route_drop_handler);
988 r = address_new_dynamic(&address);
990 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
992 _cleanup_route_free_ Route *route_gw = NULL;
993 _cleanup_route_free_ Route *route = NULL;
995 r = route_new_dynamic(&route_gw);
997 route_gw->family = AF_INET;
998 route_gw->dst_addr.in = gateway;
999 route_gw->dst_prefixlen = 32;
1000 route_gw->scope = RT_SCOPE_LINK;
1002 route_drop(route_gw, link, &route_drop_handler);
1005 r = route_new_dynamic(&route);
1007 route->family = AF_INET;
1008 route->in_addr.in = gateway;
1010 route_drop(route, link, &route_drop_handler);
1014 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
1015 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
1016 prefixlen = net_netmask_to_prefixlen(&netmask);
1018 address->family = AF_INET;
1019 address->in_addr.in = addr;
1020 address->prefixlen = prefixlen;
1022 address_drop(address, link, &address_drop_handler);
1025 if (link->network->dhcp_mtu) {
1028 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1029 if (r >= 0 && link->original_mtu != mtu) {
1030 r = link_set_mtu(link, link->original_mtu);
1032 log_warning_link(link, "DHCP error: could not reset MTU");
1033 link_enter_failed(link);
1039 if (link->network->dhcp_hostname) {
1040 const char *hostname = NULL;
1042 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1043 if (r >= 0 && hostname) {
1044 r = link_set_hostname(link, "");
1046 log_error_link(link, "Failed to reset transient hostname");
1050 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1055 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1056 sd_dhcp_lease *lease;
1059 r = sd_dhcp_client_get_lease(client, &lease);
1061 log_warning_link(link, "DHCP error: no lease %s",
1066 sd_dhcp_lease_unref(link->dhcp_lease);
1067 link->dhcp_lease = lease;
1069 link_enter_set_addresses(link);
1074 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1075 sd_dhcp_lease *lease;
1076 struct in_addr address;
1077 struct in_addr netmask;
1078 struct in_addr gateway;
1085 r = sd_dhcp_client_get_lease(client, &lease);
1087 log_warning_link(link, "DHCP error: no lease: %s",
1092 r = sd_dhcp_lease_get_address(lease, &address);
1094 log_warning_link(link, "DHCP error: no address: %s",
1099 r = sd_dhcp_lease_get_netmask(lease, &netmask);
1101 log_warning_link(link, "DHCP error: no netmask: %s",
1106 prefixlen = net_netmask_to_prefixlen(&netmask);
1108 r = sd_dhcp_lease_get_router(lease, &gateway);
1109 if (r < 0 && r != -ENOENT) {
1110 log_warning_link(link, "DHCP error: could not get gateway: %s",
1116 log_struct_link(LOG_INFO, link,
1117 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1120 ADDRESS_FMT_VAL(address),
1122 ADDRESS_FMT_VAL(gateway),
1123 "ADDRESS=%u.%u.%u.%u",
1124 ADDRESS_FMT_VAL(address),
1127 "GATEWAY=%u.%u.%u.%u",
1128 ADDRESS_FMT_VAL(gateway),
1131 log_struct_link(LOG_INFO, link,
1132 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1135 ADDRESS_FMT_VAL(address),
1137 "ADDRESS=%u.%u.%u.%u",
1138 ADDRESS_FMT_VAL(address),
1143 link->dhcp_lease = lease;
1145 if (link->network->dhcp_mtu) {
1148 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1150 r = link_set_mtu(link, mtu);
1152 log_error_link(link, "Failed to set MTU "
1153 "to %" PRIu16, mtu);
1157 if (link->network->dhcp_hostname) {
1158 const char *hostname;
1160 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1162 r = link_set_hostname(link, hostname);
1164 log_error_link(link, "Failed to set transient hostname "
1165 "to '%s'", hostname);
1169 link_enter_set_addresses(link);
1174 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1175 Link *link = userdata;
1179 assert(link->network);
1180 assert(link->manager);
1182 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1186 case DHCP_EVENT_NO_LEASE:
1187 log_debug_link(link, "IP address in use.");
1189 case DHCP_EVENT_EXPIRED:
1190 case DHCP_EVENT_STOP:
1191 case DHCP_EVENT_IP_CHANGE:
1192 if (link->network->dhcp_critical) {
1193 log_error_link(link, "DHCPv4 connection considered system critical, "
1194 "ignoring request to reconfigure it.");
1198 if (link->dhcp_lease) {
1199 r = dhcp_lease_lost(link);
1201 link_enter_failed(link);
1206 if (event == DHCP_EVENT_IP_CHANGE) {
1207 r = dhcp_lease_acquired(client, link);
1209 link_enter_failed(link);
1214 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1215 if (!sd_ipv4ll_is_running(link->ipv4ll))
1216 r = sd_ipv4ll_start(link->ipv4ll);
1217 else if (ipv4ll_is_bound(link->ipv4ll))
1218 r = ipv4ll_address_update(link, false);
1220 link_enter_failed(link);
1226 case DHCP_EVENT_RENEW:
1227 r = dhcp_lease_renew(client, link);
1229 link_enter_failed(link);
1233 case DHCP_EVENT_IP_ACQUIRE:
1234 r = dhcp_lease_acquired(client, link);
1236 link_enter_failed(link);
1240 if (ipv4ll_is_bound(link->ipv4ll))
1241 r = ipv4ll_address_update(link, true);
1243 r = sd_ipv4ll_stop(link->ipv4ll);
1245 link_enter_failed(link);
1252 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1254 log_warning_link(link, "DHCP unknown event: %d", event);
1261 static int ipv4ll_address_update(Link *link, bool deprecate) {
1263 struct in_addr addr;
1267 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1269 _cleanup_address_free_ Address *address = NULL;
1271 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1272 deprecate ? "deprecate" : "approve",
1273 ADDRESS_FMT_VAL(addr));
1275 r = address_new_dynamic(&address);
1277 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1281 address->family = AF_INET;
1282 address->in_addr.in = addr;
1283 address->prefixlen = 16;
1284 address->scope = RT_SCOPE_LINK;
1285 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1286 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1288 address_update(address, link, &address_update_handler);
1295 static int ipv4ll_address_lost(Link *link) {
1297 struct in_addr addr;
1301 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1303 _cleanup_address_free_ Address *address = NULL;
1304 _cleanup_route_free_ Route *route = NULL;
1306 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1307 ADDRESS_FMT_VAL(addr));
1309 r = address_new_dynamic(&address);
1311 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1315 address->family = AF_INET;
1316 address->in_addr.in = addr;
1317 address->prefixlen = 16;
1318 address->scope = RT_SCOPE_LINK;
1320 address_drop(address, link, &address_drop_handler);
1322 r = route_new_dynamic(&route);
1324 log_error_link(link, "Could not allocate route: %s",
1329 route->family = AF_INET;
1330 route->scope = RT_SCOPE_LINK;
1331 route->metrics = 99;
1333 route_drop(route, link, &route_drop_handler);
1339 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1341 struct in_addr addr;
1345 r = sd_ipv4ll_get_address(ll, &addr);
1351 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1352 struct in_addr address;
1358 r = sd_ipv4ll_get_address(ll, &address);
1362 log_struct_link(LOG_INFO, link,
1363 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1366 ADDRESS_FMT_VAL(address),
1369 link_enter_set_addresses(link);
1374 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1375 Link *link = userdata;
1379 assert(link->network);
1380 assert(link->manager);
1382 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1386 case IPV4LL_EVENT_STOP:
1387 case IPV4LL_EVENT_CONFLICT:
1388 r = ipv4ll_address_lost(link);
1390 link_enter_failed(link);
1394 case IPV4LL_EVENT_BIND:
1395 r = ipv4ll_address_claimed(ll, link);
1397 link_enter_failed(link);
1403 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1405 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1410 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1411 Link *link = userdata;
1414 assert(link->network);
1415 assert(link->manager);
1417 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1421 case DHCP6_EVENT_STOP:
1422 case DHCP6_EVENT_RESEND_EXPIRE:
1423 case DHCP6_EVENT_RETRANS_MAX:
1424 case DHCP6_EVENT_IP_ACQUIRE:
1425 log_debug_link(link, "DHCPv6 event %d", event);
1431 log_warning_link(link, "DHCPv6 error: %s",
1434 log_warning_link(link, "DHCPv6 unknown event: %d",
1440 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1441 Link *link = userdata;
1445 assert(link->network);
1446 assert(link->manager);
1448 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1452 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1453 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1456 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1457 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1462 log_warning_link(link, "ICMPv6 error: %s",
1465 log_warning_link(link, "ICMPv6 unknown event: %d",
1471 if (link->dhcp6_client)
1474 r = sd_dhcp6_client_new(&link->dhcp6_client);
1478 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1480 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1484 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1486 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1490 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1492 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1496 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1499 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1503 r = sd_dhcp6_client_start(link->dhcp6_client);
1505 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1508 static int link_acquire_conf(Link *link) {
1512 assert(link->network);
1513 assert(link->manager);
1514 assert(link->manager->event);
1516 if (link->network->ipv4ll) {
1517 assert(link->ipv4ll);
1519 log_debug_link(link, "acquiring IPv4 link-local address");
1521 r = sd_ipv4ll_start(link->ipv4ll);
1523 log_warning_link(link, "could not acquire IPv4 "
1524 "link-local address");
1529 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1530 assert(link->dhcp_client);
1532 log_debug_link(link, "acquiring DHCPv4 lease");
1534 r = sd_dhcp_client_start(link->dhcp_client);
1536 log_warning_link(link, "could not acquire DHCPv4 "
1542 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1543 assert(link->icmp6_router_discovery);
1545 log_debug_link(link, "discovering IPv6 routers");
1547 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1549 log_warning_link(link, "could not start IPv6 router discovery");
1557 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1558 /* see Documentation/networking/operstates.txt in the kernel sources */
1560 if (operstate == IF_OPER_UP)
1563 if (operstate == IF_OPER_UNKNOWN)
1564 /* operstate may not be implemented, so fall back to flags */
1565 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1571 #define FLAG_STRING(string, flag, old, new) \
1572 (((old ^ new) & flag) \
1573 ? ((old & flag) ? (" -" string) : (" +" string)) \
1576 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1577 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1579 bool carrier_gained = false, carrier_lost = false;
1584 r = sd_rtnl_message_link_get_flags(m, &flags);
1586 log_warning_link(link, "Could not get link flags");
1590 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1592 /* if we got a message without operstate, take it to mean
1593 the state was unchanged */
1594 operstate = link->kernel_operstate;
1596 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1599 if (link->flags != flags) {
1600 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",
1601 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1602 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1603 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1604 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1605 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1606 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1607 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1608 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1609 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1610 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1611 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1612 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1613 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1614 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1615 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1616 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1617 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1618 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1619 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1621 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1622 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1623 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1624 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1625 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1626 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1627 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1628 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1630 /* link flags are currently at most 18 bits, let's align to printing 20 */
1631 if (unknown_flags_added)
1632 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1633 unknown_flags_added);
1635 if (unknown_flags_removed)
1636 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1637 unknown_flags_removed);
1640 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1641 link_has_carrier(flags, operstate);
1642 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1643 !link_has_carrier(flags, operstate);
1645 link->flags = flags;
1646 link->kernel_operstate = operstate;
1650 if (link->state == LINK_STATE_FAILED ||
1651 link->state == LINK_STATE_UNMANAGED)
1654 if (carrier_gained) {
1655 log_info_link(link, "gained carrier");
1657 if (link->network) {
1658 r = link_acquire_conf(link);
1660 link_enter_failed(link);
1664 } else if (carrier_lost) {
1665 log_info_link(link, "lost carrier");
1667 r = link_stop_clients(link);
1669 link_enter_failed(link);
1677 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1678 _cleanup_link_unref_ Link *link = userdata;
1683 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1686 r = sd_rtnl_message_get_errno(m);
1688 /* we warn but don't fail the link, as it may
1689 be brought up later */
1690 log_struct_link(LOG_WARNING, link,
1691 "MESSAGE=%-*s: could not bring up interface: %s",
1693 link->ifname, strerror(-r),
1701 static int link_up(Link *link) {
1702 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1706 assert(link->manager);
1707 assert(link->manager->rtnl);
1709 log_debug_link(link, "bringing link up");
1711 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1712 RTM_SETLINK, link->ifindex);
1714 log_error_link(link, "Could not allocate RTM_SETLINK message");
1718 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1720 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1724 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1726 log_error_link(link,
1727 "Could not send rtnetlink message: %s", strerror(-r));
1736 static int link_joined(Link *link) {
1740 assert(link->state == LINK_STATE_ENSLAVING);
1741 assert(link->network);
1743 log_debug_link(link, "joined netdev");
1745 if (!(link->flags & IFF_UP)) {
1748 link_enter_failed(link);
1753 return link_enter_set_addresses(link);
1756 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1757 _cleanup_link_unref_ Link *link = userdata;
1761 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1762 LINK_STATE_LINGER));
1763 assert(link->network);
1767 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1770 r = sd_rtnl_message_get_errno(m);
1771 if (r < 0 && r != -EEXIST) {
1772 log_struct_link(LOG_ERR, link,
1773 "MESSAGE=%-*s: could not join netdev: %s",
1775 link->ifname, strerror(-r),
1778 link_enter_failed(link);
1782 if (link->enslaving <= 0)
1788 static int link_enter_join_netdev(Link *link) {
1789 NetDev *vlan, *macvlan, *vxlan;
1794 assert(link->network);
1795 assert(link->state == LINK_STATE_INITIALIZING);
1797 link->state = LINK_STATE_ENSLAVING;
1801 if (!link->network->bridge &&
1802 !link->network->bond &&
1803 !link->network->tunnel &&
1804 hashmap_isempty(link->network->vlans) &&
1805 hashmap_isempty(link->network->macvlans) &&
1806 hashmap_isempty(link->network->vxlans))
1807 return link_joined(link);
1809 if (link->network->bond) {
1810 log_struct_link(LOG_DEBUG, link,
1811 "MESSAGE=%-*s: enslaving by '%s'",
1813 link->ifname, link->network->bond->ifname,
1814 NETDEV(link->network->bond),
1817 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1819 log_struct_link(LOG_WARNING, link,
1820 "MESSAGE=%-*s: could not join netdev '%s': %s",
1822 link->ifname, link->network->bond->ifname, strerror(-r),
1823 NETDEV(link->network->bond),
1825 link_enter_failed(link);
1832 if (link->network->bridge) {
1833 log_struct_link(LOG_DEBUG, link,
1834 "MESSAGE=%-*s: enslaving by '%s'",
1836 link->ifname, link->network->bridge->ifname,
1837 NETDEV(link->network->bridge),
1840 r = netdev_join(link->network->bridge, link, &netdev_join_handler);
1842 log_struct_link(LOG_WARNING, link,
1843 "MESSAGE=%-*s: could not join netdev '%s': %s",
1845 link->ifname, link->network->bridge->ifname, strerror(-r),
1846 NETDEV(link->network->bridge),
1848 link_enter_failed(link);
1855 if (link->network->tunnel) {
1856 log_struct_link(LOG_DEBUG, link,
1857 "MESSAGE=%-*s: enslaving by '%s'",
1859 link->ifname, link->network->tunnel->ifname,
1860 NETDEV(link->network->tunnel),
1863 r = netdev_join(link->network->tunnel, link, &netdev_join_handler);
1865 log_struct_link(LOG_WARNING, link,
1866 "MESSAGE=%-*s: could not join netdev '%s': %s",
1868 link->ifname, link->network->tunnel->ifname, strerror(-r),
1869 NETDEV(link->network->tunnel),
1871 link_enter_failed(link);
1878 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1879 log_struct_link(LOG_DEBUG, link,
1880 "MESSAGE=%-*s: enslaving by '%s'",
1882 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1884 r = netdev_join(vlan, link, &netdev_join_handler);
1886 log_struct_link(LOG_WARNING, link,
1887 "MESSAGE=%-*s: could not join netdev '%s': %s",
1889 link->ifname, vlan->ifname, strerror(-r),
1890 NETDEV(vlan), NULL);
1891 link_enter_failed(link);
1898 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1899 log_struct_link(LOG_DEBUG, link,
1900 "MESSAGE=%-*s: enslaving by '%s'",
1902 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1904 r = netdev_join(macvlan, link, &netdev_join_handler);
1906 log_struct_link(LOG_WARNING, link,
1907 "MESSAGE=%-*s: could not join netdev '%s': %s",
1909 link->ifname, macvlan->ifname, strerror(-r),
1910 NETDEV(macvlan), NULL);
1911 link_enter_failed(link);
1918 HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1919 log_struct_link(LOG_DEBUG, link,
1920 "MESSAGE=%*s: enslaving by '%s'",
1922 link->ifname, vxlan->ifname, NETDEV(vxlan), NULL);
1924 r = netdev_join(vxlan, link, &netdev_join_handler);
1926 log_struct_link(LOG_WARNING, link,
1927 "MESSAGE=%*s: could not join netdev '%s': %s",
1929 link->ifname, vxlan->ifname, strerror(-r),
1930 NETDEV(vxlan), NULL);
1931 link_enter_failed(link);
1941 static int link_configure(Link *link) {
1945 assert(link->state == LINK_STATE_INITIALIZING);
1947 if (link->network->ipv4ll) {
1950 r = sd_ipv4ll_new(&link->ipv4ll);
1954 if (link->udev_device) {
1955 r = net_get_unique_predictable_data(link->udev_device, seed);
1957 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1963 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1967 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1971 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1975 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1980 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1981 r = sd_dhcp_client_new(&link->dhcp_client);
1985 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1989 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1993 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1997 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
2001 r = sd_dhcp_client_set_request_broadcast(link->dhcp_client, link->network->dhcp_broadcast);
2005 if (link->network->dhcp_mtu) {
2006 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
2011 if (link->network->dhcp_routes) {
2012 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
2015 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
2020 if (link->network->dhcp_sendhost) {
2021 _cleanup_free_ char *hostname = gethostname_malloc();
2025 if (!is_localhost(hostname)) {
2026 r = sd_dhcp_client_set_hostname(link->dhcp_client, hostname);
2032 if (link->network->dhcp_vendor_class_identifier) {
2033 r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
2034 link->network->dhcp_vendor_class_identifier);
2040 if (link->network->dhcp_server) {
2041 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2045 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2050 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
2051 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
2055 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
2060 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
2065 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
2070 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
2071 icmp6_router_handler, link);
2076 if (link_has_carrier(link->flags, link->kernel_operstate)) {
2077 r = link_acquire_conf(link);
2082 return link_enter_join_netdev(link);
2085 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2086 _cleanup_link_unref_ Link *link = userdata;
2091 assert(link->ifname);
2092 assert(link->manager);
2094 if (link->state != LINK_STATE_INITIALIZING)
2097 log_debug_link(link, "link state is up-to-date");
2099 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2101 link_enter_unmanaged(link);
2106 r = network_apply(link->manager, network, link);
2110 r = link_configure(link);
2117 int link_initialized(Link *link, struct udev_device *device) {
2118 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2122 assert(link->manager);
2123 assert(link->manager->rtnl);
2126 if (link->state != LINK_STATE_INITIALIZING)
2129 if (link->udev_device)
2132 log_debug_link(link, "udev initialized link");
2134 link->udev_device = udev_device_ref(device);
2136 /* udev has initialized the link, but we don't know if we have yet processed
2137 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2138 we know that the pending NEWLINKs have already been processed and that we
2141 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2145 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2154 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2155 Manager *m = userdata;
2158 _cleanup_address_free_ Address *address = NULL;
2160 char buf[INET6_ADDRSTRLEN];
2161 bool address_dropped = false;
2168 r = sd_rtnl_message_get_type(message, &type);
2170 log_warning("rtnl: could not get message type");
2174 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2175 if (r < 0 || ifindex <= 0) {
2176 log_warning("rtnl: received address message without valid ifindex, ignoring");
2179 r = link_get(m, ifindex, &link);
2180 if (r < 0 || !link) {
2181 log_warning("rtnl: received address for a nonexistent link, ignoring");
2186 r = address_new_dynamic(&address);
2190 r = sd_rtnl_message_addr_get_family(message, &address->family);
2191 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2192 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2196 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2198 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2202 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2204 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2208 switch (address->family) {
2210 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2212 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2219 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2221 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2228 assert_not_reached("invalid address family");
2231 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2232 log_warning_link(link, "could not print address");
2236 LIST_FOREACH(addresses, ad, link->addresses) {
2237 if (address_equal(ad, address)) {
2238 LIST_REMOVE(addresses, link->addresses, ad);
2242 address_dropped = true;
2250 if (!address_dropped)
2251 log_debug_link(link, "added address: %s/%u", buf,
2252 address->prefixlen);
2254 log_debug_link(link, "updated address: %s/%u", buf,
2255 address->prefixlen);
2257 LIST_PREPEND(addresses, link->addresses, address);
2264 if (address_dropped) {
2265 log_debug_link(link, "removed address: %s/%u", buf,
2266 address->prefixlen);
2270 log_warning_link(link, "removing non-existent address: %s/%u",
2271 buf, address->prefixlen);
2275 assert_not_reached("Received invalid RTNL message type");
2281 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2283 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2284 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2285 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2293 r = link_new(m, message, ret);
2299 log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2301 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2305 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2311 if (detect_container(NULL) <= 0) {
2312 /* not in a container, udev will be around */
2313 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2314 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2316 log_warning_link(link, "could not find udev device");
2320 if (udev_device_get_is_initialized(device) <= 0) {
2322 log_debug_link(link, "udev initializing link...");
2326 r = link_initialized(link, device);
2330 /* we are calling a callback directly, so must take a ref */
2333 r = link_initialized_and_synced(m->rtnl, NULL, link);
2341 int link_update(Link *link, sd_rtnl_message *m) {
2342 struct ether_addr mac;
2347 assert(link->ifname);
2350 if (link->state == LINK_STATE_LINGER) {
2352 log_info_link(link, "link readded");
2353 link->state = LINK_STATE_ENSLAVING;
2356 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2357 if (r >= 0 && !streq(ifname, link->ifname)) {
2358 log_info_link(link, "renamed to %s", ifname);
2361 link->ifname = strdup(ifname);
2366 if (!link->original_mtu) {
2367 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2369 log_debug_link(link, "saved original MTU: %"
2370 PRIu16, link->original_mtu);
2373 /* The kernel may broadcast NEWLINK messages without the MAC address
2374 set, simply ignore them. */
2375 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2377 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2379 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2381 log_debug_link(link, "MAC address: "
2382 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2383 mac.ether_addr_octet[0],
2384 mac.ether_addr_octet[1],
2385 mac.ether_addr_octet[2],
2386 mac.ether_addr_octet[3],
2387 mac.ether_addr_octet[4],
2388 mac.ether_addr_octet[5]);
2391 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2393 log_warning_link(link, "Could not update MAC "
2394 "address in IPv4LL client: %s",
2400 if (link->dhcp_client) {
2401 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2403 log_warning_link(link, "Could not update MAC "
2404 "address in DHCP client: %s",
2410 if (link->dhcp6_client) {
2411 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2414 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2422 return link_update_flags(link, m);
2425 static void serialize_addresses(FILE *f, const char *key, Address *address) {
2434 fprintf(f, "%s=", key);
2436 LIST_FOREACH(addresses, ad, address) {
2437 char buf[INET6_ADDRSTRLEN];
2439 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
2440 fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2446 static void link_update_operstate(Link *link) {
2450 if (link->kernel_operstate == IF_OPER_DORMANT)
2451 link->operstate = LINK_OPERSTATE_DORMANT;
2452 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2454 uint8_t scope = RT_SCOPE_NOWHERE;
2456 /* if we have carrier, check what addresses we have */
2457 LIST_FOREACH(addresses, address, link->addresses) {
2458 if (address->scope < scope)
2459 scope = address->scope;
2462 if (scope < RT_SCOPE_SITE)
2463 /* universally accessible addresses found */
2464 link->operstate = LINK_OPERSTATE_ROUTABLE;
2465 else if (scope < RT_SCOPE_HOST)
2466 /* only link or site local addresses found */
2467 link->operstate = LINK_OPERSTATE_DEGRADED;
2469 /* no useful addresses found */
2470 link->operstate = LINK_OPERSTATE_CARRIER;
2472 link->operstate = LINK_OPERSTATE_UNKNOWN;
2475 int link_save(Link *link) {
2476 _cleanup_free_ char *temp_path = NULL;
2477 _cleanup_fclose_ FILE *f = NULL;
2478 const char *admin_state, *oper_state;
2482 assert(link->state_file);
2483 assert(link->lease_file);
2484 assert(link->manager);
2486 link_update_operstate(link);
2488 r = manager_save(link->manager);
2492 if (link->state == LINK_STATE_LINGER) {
2493 unlink(link->state_file);
2497 admin_state = link_state_to_string(link->state);
2498 assert(admin_state);
2500 oper_state = link_operstate_to_string(link->operstate);
2503 r = fopen_temporary(link->state_file, &f, &temp_path);
2507 fchmod(fileno(f), 0644);
2510 "# This is private data. Do not parse.\n"
2514 admin_state, oper_state, link->flags);
2516 if (link->network) {
2517 serialize_addresses(f, "DNS", link->network->dns);
2518 serialize_addresses(f, "NTP", link->network->ntp);
2521 if (link->dhcp_lease) {
2522 assert(link->network);
2524 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2531 "DHCP_USE_NTP=%s\n",
2533 yes_no(link->network->dhcp_dns),
2534 yes_no(link->network->dhcp_ntp));
2536 unlink(link->lease_file);
2540 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2542 unlink(link->state_file);
2548 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2553 static const char* const link_state_table[_LINK_STATE_MAX] = {
2554 [LINK_STATE_INITIALIZING] = "initializing",
2555 [LINK_STATE_ENSLAVING] = "configuring",
2556 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2557 [LINK_STATE_SETTING_ROUTES] = "configuring",
2558 [LINK_STATE_CONFIGURED] = "configured",
2559 [LINK_STATE_UNMANAGED] = "unmanaged",
2560 [LINK_STATE_FAILED] = "failed",
2561 [LINK_STATE_LINGER] = "linger",
2564 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2566 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2567 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2568 [LINK_OPERSTATE_DORMANT] = "dormant",
2569 [LINK_OPERSTATE_CARRIER] = "carrier",
2570 [LINK_OPERSTATE_DEGRADED] = "degraded",
2571 [LINK_OPERSTATE_ROUTABLE] = "routable",
2574 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2576 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2577 [DHCP_SUPPORT_NONE] = "none",
2578 [DHCP_SUPPORT_BOTH] = "both",
2579 [DHCP_SUPPORT_V4] = "v4",
2580 [DHCP_SUPPORT_V6] = "v6",
2583 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2585 int config_parse_dhcp(
2587 const char *filename,
2589 const char *section,
2590 unsigned section_line,
2597 DHCPSupport *dhcp = data;
2605 /* Our enum shall be a superset of booleans, hence first try
2606 * to parse as boolean, and then as enum */
2608 k = parse_boolean(rvalue);
2610 *dhcp = DHCP_SUPPORT_BOTH;
2612 *dhcp = DHCP_SUPPORT_NONE;
2616 s = dhcp_support_from_string(rvalue);
2618 log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);