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 "libudev-private.h"
28 #include "udev-util.h"
32 #include "network-internal.h"
33 #include "conf-parser.h"
35 #include "network-util.h"
36 #include "dhcp-lease-internal.h"
38 static int ipv4ll_address_update(Link *link, bool deprecate);
39 static bool ipv4ll_is_bound(sd_ipv4ll *ll);
41 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
42 _cleanup_link_unref_ Link *link = NULL;
48 assert(manager->links);
52 r = sd_rtnl_message_get_type(message, &type);
55 else if (type != RTM_NEWLINK)
58 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
61 else if (ifindex <= 0)
64 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
73 link->manager = manager;
74 link->state = LINK_STATE_INITIALIZING;
75 link->ifindex = ifindex;
76 link->ifname = strdup(ifname);
80 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
82 log_debug_link(link, "MAC address not found for new device, continuing without");
84 r = asprintf(&link->state_file, "/run/systemd/netif/links/%"PRIu64,
89 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%"PRIu64,
94 r = hashmap_put(manager->links, &link->ifindex, link);
104 static void link_free(Link *link) {
110 while ((address = link->addresses)) {
111 LIST_REMOVE(addresses, link->addresses, address);
112 address_free(address);
115 while ((address = link->pool_addresses)) {
116 LIST_REMOVE(addresses, link->pool_addresses, address);
117 address_free(address);
120 sd_dhcp_client_unref(link->dhcp_client);
121 sd_dhcp_lease_unref(link->dhcp_lease);
123 unlink(link->lease_file);
124 free(link->lease_file);
126 sd_ipv4ll_unref(link->ipv4ll);
127 sd_dhcp6_client_unref(link->dhcp6_client);
128 sd_icmp6_nd_unref(link->icmp6_router_discovery);
131 hashmap_remove(link->manager->links, &link->ifindex);
135 unlink(link->state_file);
136 free(link->state_file);
138 udev_device_unref(link->udev_device);
143 Link *link_unref(Link *link) {
144 if (link && (-- link->n_ref <= 0))
150 Link *link_ref(Link *link) {
152 assert_se(++ link->n_ref >= 2);
157 int link_get(Manager *m, int ifindex, Link **ret) {
166 ifindex_64 = ifindex;
167 link = hashmap_get(m->links, &ifindex_64);
176 void link_drop(Link *link) {
177 if (!link || link->state == LINK_STATE_LINGER)
180 link->state = LINK_STATE_LINGER;
182 log_debug_link(link, "link removed");
189 static void link_enter_unmanaged(Link *link) {
192 log_debug_link(link, "unmanaged");
194 link->state = LINK_STATE_UNMANAGED;
199 static int link_stop_clients(Link *link) {
203 assert(link->manager);
204 assert(link->manager->event);
209 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
210 assert(link->dhcp_client);
212 k = sd_dhcp_client_stop(link->dhcp_client);
214 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
219 if (link->network->ipv4ll) {
220 assert(link->ipv4ll);
222 k = sd_ipv4ll_stop(link->ipv4ll);
224 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
229 if (link->network->dhcp_server) {
230 assert(link->dhcp_server);
232 k = sd_dhcp_server_stop(link->dhcp_server);
234 log_warning_link(link, "Could not stop DHCPv4 server: %s", strerror(-r));
239 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
240 assert(link->icmp6_router_discovery);
242 if (link->dhcp6_client) {
243 k = sd_dhcp6_client_stop(link->dhcp6_client);
245 log_warning_link(link, "Could not stop DHCPv6 client: %s", strerror(-r));
250 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
252 log_warning_link(link, "Could not stop ICMPv6 router discovery: %s", strerror(-r));
260 static void link_enter_failed(Link *link) {
263 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
266 log_warning_link(link, "failed");
268 link->state = LINK_STATE_FAILED;
270 link_stop_clients(link);
275 static Address* link_find_dhcp_server_address(Link *link) {
279 assert(link->network);
281 /* The the first statically configured address if there is any */
282 LIST_FOREACH(addresses, address, link->network->static_addresses) {
284 if (address->family != AF_INET)
287 if (in_addr_null(address->family, &address->in_addr))
293 /* If that didn't work, find a suitable address we got from the pool */
294 LIST_FOREACH(addresses, address, link->pool_addresses) {
295 if (address->family != AF_INET)
304 static int link_enter_configured(Link *link) {
308 assert(link->network);
309 assert(link->state == LINK_STATE_SETTING_ROUTES);
311 if (link->network->dhcp_server &&
312 !sd_dhcp_server_is_running(link->dhcp_server)) {
313 struct in_addr pool_start;
316 address = link_find_dhcp_server_address(link);
318 log_warning_link(link, "Failed to find suitable address for DHCPv4 server instance.");
319 link_enter_failed(link);
323 log_debug_link(link, "offering DHCPv4 leases");
325 r = sd_dhcp_server_set_address(link->dhcp_server, &address->in_addr.in);
329 /* offer 32 addresses starting from the address following the server address */
330 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
331 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
337 r = sd_dhcp_server_set_router(link->dhcp_server,
338 &main_address->in_addr.in);
342 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
343 main_address->prefixlen);
348 r = sd_dhcp_server_start(link->dhcp_server);
350 log_warning_link(link, "could not start DHCPv4 server "
351 "instance: %s", strerror(-r));
353 link_enter_failed(link);
359 log_info_link(link, "link configured");
361 link->state = LINK_STATE_CONFIGURED;
368 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
369 _cleanup_link_unref_ Link *link = userdata;
372 assert(link->route_messages > 0);
373 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
374 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
377 link->route_messages --;
379 if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER))
382 r = sd_rtnl_message_get_errno(m);
383 if (r < 0 && r != -EEXIST)
384 log_struct_link(LOG_WARNING, link,
385 "MESSAGE=%-*s: could not set route: %s",
387 link->ifname, strerror(-r),
391 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
393 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
394 log_debug_link(link, "routes set");
395 link_enter_configured(link);
401 static int link_set_dhcp_routes(Link *link) {
402 struct sd_dhcp_route *static_routes;
403 size_t static_routes_size;
409 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes, &static_routes_size);
412 log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-r));
416 for (i = 0; i < static_routes_size; i++) {
417 _cleanup_route_free_ Route *route = NULL;
419 r = route_new_dynamic(&route);
421 log_error_link(link, "Could not allocate route: %s",
426 route->family = AF_INET;
427 route->in_addr.in = static_routes[i].gw_addr;
428 route->dst_addr.in = static_routes[i].dst_addr;
429 route->dst_prefixlen = static_routes[i].dst_prefixlen;
430 route->metrics = DHCP_STATIC_ROUTE_METRIC;
432 r = route_configure(route, link, &route_handler);
434 log_warning_link(link,
435 "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);
472 link->route_messages ++;
475 if (link->ipv4ll && !link->dhcp_lease) {
476 _cleanup_route_free_ Route *route = NULL;
479 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
480 if (r < 0 && r != -ENOENT) {
481 log_warning_link(link, "IPV4LL error: no address: %s",
487 r = route_new_dynamic(&route);
489 log_error_link(link, "Could not allocate route: %s",
494 route->family = AF_INET;
495 route->scope = RT_SCOPE_LINK;
498 r = route_configure(route, link, &route_handler);
500 log_warning_link(link,
501 "could not set routes: %s", strerror(-r));
502 link_enter_failed(link);
507 link->route_messages ++;
511 if (link->dhcp_lease) {
512 _cleanup_route_free_ Route *route = NULL;
513 _cleanup_route_free_ Route *route_gw = NULL;
514 struct in_addr gateway;
516 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
517 if (r < 0 && r != -ENOENT) {
518 log_warning_link(link, "DHCP error: could not get gateway: %s",
524 r = route_new_dynamic(&route);
526 log_error_link(link, "Could not allocate route: %s",
531 r = route_new_dynamic(&route_gw);
533 log_error_link(link, "Could not allocate route: %s",
538 /* The dhcp netmask may mask out the gateway. Add an explicit
539 * route for the gw host so that we can route no matter the
540 * netmask or existing kernel route tables. */
541 route_gw->family = AF_INET;
542 route_gw->dst_addr.in = gateway;
543 route_gw->dst_prefixlen = 32;
544 route_gw->scope = RT_SCOPE_LINK;
545 route_gw->metrics = DHCP_STATIC_ROUTE_METRIC;
547 r = route_configure(route_gw, link, &route_handler);
549 log_warning_link(link,
550 "could not set host route: %s", strerror(-r));
555 link->route_messages ++;
557 route->family = AF_INET;
558 route->in_addr.in = gateway;
559 route->metrics = DHCP_STATIC_ROUTE_METRIC;
561 r = route_configure(route, link, &route_handler);
563 log_warning_link(link,
564 "could not set routes: %s", strerror(-r));
565 link_enter_failed(link);
570 link->route_messages ++;
573 if (link->network->dhcp_routes)
574 link_set_dhcp_routes(link);
577 if (link->route_messages == 0) {
578 link_enter_configured(link);
584 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
585 _cleanup_link_unref_ Link *link = userdata;
590 assert(link->ifname);
592 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
595 r = sd_rtnl_message_get_errno(m);
596 if (r < 0 && r != -ESRCH)
597 log_struct_link(LOG_WARNING, link,
598 "MESSAGE=%-*s: could not drop route: %s",
600 link->ifname, strerror(-r),
607 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
608 _cleanup_link_unref_ Link *link = userdata;
613 assert(link->ifname);
614 assert(link->addr_messages > 0);
615 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
616 LINK_STATE_FAILED, LINK_STATE_LINGER));
618 link->addr_messages --;
620 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
623 r = sd_rtnl_message_get_errno(m);
624 if (r < 0 && r != -EEXIST)
625 log_struct_link(LOG_WARNING, link,
626 "MESSAGE=%-*s: could not set address: %s",
628 link->ifname, strerror(-r),
632 if (link->addr_messages == 0) {
633 log_debug_link(link, "addresses set");
634 link_enter_set_routes(link);
640 static int link_enter_set_addresses(Link *link) {
643 uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
646 assert(link->network);
647 assert(link->state != _LINK_STATE_INVALID);
649 link->state = LINK_STATE_SETTING_ADDRESSES;
651 if (!link->network->static_addresses && !link->dhcp_lease &&
652 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
653 return link_enter_set_routes(link);
655 log_debug_link(link, "setting addresses");
657 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
658 r = address_configure(ad, link, &address_handler);
660 log_warning_link(link,
661 "could not set addresses: %s", strerror(-r));
662 link_enter_failed(link);
667 link->addr_messages ++;
670 if (link->ipv4ll && !link->dhcp_lease) {
671 _cleanup_address_free_ Address *ll_addr = NULL;
674 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
675 if (r < 0 && r != -ENOENT) {
676 log_warning_link(link, "IPV4LL error: no address: %s",
682 r = address_new_dynamic(&ll_addr);
684 log_error_link(link, "Could not allocate address: %s", strerror(-r));
688 ll_addr->family = AF_INET;
689 ll_addr->in_addr.in = addr;
690 ll_addr->prefixlen = 16;
691 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
692 ll_addr->scope = RT_SCOPE_LINK;
694 r = address_configure(ll_addr, link, &address_handler);
696 log_warning_link(link,
697 "could not set addresses: %s", strerror(-r));
698 link_enter_failed(link);
703 link->addr_messages ++;
707 if (link->dhcp_lease) {
708 _cleanup_address_free_ Address *address = NULL;
710 struct in_addr netmask;
713 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
715 log_warning_link(link, "DHCP error: no address: %s",
720 if (!link->network->dhcp_critical) {
721 r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
724 log_warning_link(link, "DHCP error: no lifetime: %s",
730 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
732 log_warning_link(link, "DHCP error: no netmask: %s",
737 prefixlen = net_netmask_to_prefixlen(&netmask);
739 r = address_new_dynamic(&address);
741 log_error_link(link, "Could not allocate address: %s",
746 address->family = AF_INET;
747 address->in_addr.in = addr;
748 address->cinfo.ifa_prefered = lifetime;
749 address->cinfo.ifa_valid = lifetime;
750 address->prefixlen = prefixlen;
751 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
753 /* use update rather than configure so that we will update the lifetime
754 of an existing address if it has already been configured */
755 r = address_update(address, link, &address_handler);
757 log_warning_link(link,
758 "could not set addresses: %s", strerror(-r));
759 link_enter_failed(link);
764 link->addr_messages ++;
770 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
771 _cleanup_link_unref_ Link *link = userdata;
776 assert(link->ifname);
778 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
781 r = sd_rtnl_message_get_errno(m);
782 if (r < 0 && r != -ENOENT)
783 log_struct_link(LOG_WARNING, link,
784 "MESSAGE=%-*s: could not update address: %s",
786 link->ifname, strerror(-r),
793 static int address_drop_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 != -EADDRNOTAVAIL)
806 log_struct_link(LOG_WARNING, link,
807 "MESSAGE=%-*s: could not drop address: %s",
809 link->ifname, strerror(-r),
816 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
817 _cleanup_link_unref_ Link *link = userdata;
822 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
825 r = sd_bus_message_get_errno(m);
827 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
832 static int link_set_hostname(Link *link, const char *hostname) {
833 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
837 assert(link->manager);
840 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
842 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
843 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
847 r = sd_bus_message_new_method_call(
850 "org.freedesktop.hostname1",
851 "/org/freedesktop/hostname1",
852 "org.freedesktop.hostname1",
857 r = sd_bus_message_append(m, "sb", hostname, false);
861 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
863 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
872 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
873 _cleanup_link_unref_ Link *link = userdata;
878 assert(link->ifname);
880 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
883 r = sd_rtnl_message_get_errno(m);
885 log_struct_link(LOG_WARNING, link,
886 "MESSAGE=%-*s: could not set MTU: %s",
887 IFNAMSIZ, link->ifname, strerror(-r),
894 static int link_set_mtu(Link *link, uint32_t mtu) {
895 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
899 assert(link->manager);
900 assert(link->manager->rtnl);
902 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
904 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
905 RTM_SETLINK, link->ifindex);
907 log_error_link(link, "Could not allocate RTM_SETLINK message");
911 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
913 log_error_link(link, "Could not append MTU: %s", strerror(-r));
917 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
920 "Could not send rtnetlink message: %s", strerror(-r));
929 static int dhcp_lease_lost(Link *link) {
930 _cleanup_address_free_ Address *address = NULL;
932 struct in_addr netmask;
933 struct in_addr gateway;
939 assert(link->dhcp_lease);
941 log_warning_link(link, "DHCP lease lost");
943 if (link->network->dhcp_routes) {
944 struct sd_dhcp_route *routes;
947 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes, &routes_size);
949 for (i = 0; i < routes_size; i++) {
950 _cleanup_route_free_ Route *route = NULL;
952 r = route_new_dynamic(&route);
954 route->family = AF_INET;
955 route->in_addr.in = routes[i].gw_addr;
956 route->dst_addr.in = routes[i].dst_addr;
957 route->dst_prefixlen = routes[i].dst_prefixlen;
959 route_drop(route, link, &route_drop_handler);
966 r = address_new_dynamic(&address);
968 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
970 _cleanup_route_free_ Route *route_gw = NULL;
971 _cleanup_route_free_ Route *route = NULL;
973 r = route_new_dynamic(&route_gw);
975 route_gw->family = AF_INET;
976 route_gw->dst_addr.in = gateway;
977 route_gw->dst_prefixlen = 32;
978 route_gw->scope = RT_SCOPE_LINK;
980 route_drop(route_gw, link, &route_drop_handler);
984 r = route_new_dynamic(&route);
986 route->family = AF_INET;
987 route->in_addr.in = gateway;
989 route_drop(route, link, &route_drop_handler);
994 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
995 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
996 prefixlen = net_netmask_to_prefixlen(&netmask);
998 address->family = AF_INET;
999 address->in_addr.in = addr;
1000 address->prefixlen = prefixlen;
1002 address_drop(address, link, &address_drop_handler);
1006 if (link->network->dhcp_mtu) {
1009 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1010 if (r >= 0 && link->original_mtu != mtu) {
1011 r = link_set_mtu(link, link->original_mtu);
1013 log_warning_link(link, "DHCP error: could not reset MTU");
1014 link_enter_failed(link);
1020 if (link->network->dhcp_hostname) {
1021 const char *hostname = NULL;
1023 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1024 if (r >= 0 && hostname) {
1025 r = link_set_hostname(link, "");
1027 log_error_link(link, "Failed to reset transient hostname");
1031 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1036 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1037 sd_dhcp_lease *lease;
1040 r = sd_dhcp_client_get_lease(client, &lease);
1042 log_warning_link(link, "DHCP error: no lease %s",
1047 sd_dhcp_lease_unref(link->dhcp_lease);
1048 link->dhcp_lease = lease;
1050 link_enter_set_addresses(link);
1055 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1056 sd_dhcp_lease *lease;
1057 struct in_addr address;
1058 struct in_addr netmask;
1059 struct in_addr gateway;
1066 r = sd_dhcp_client_get_lease(client, &lease);
1068 log_warning_link(link, "DHCP error: no lease: %s",
1073 r = sd_dhcp_lease_get_address(lease, &address);
1075 log_warning_link(link, "DHCP error: no address: %s",
1080 r = sd_dhcp_lease_get_netmask(lease, &netmask);
1082 log_warning_link(link, "DHCP error: no netmask: %s",
1087 prefixlen = net_netmask_to_prefixlen(&netmask);
1089 r = sd_dhcp_lease_get_router(lease, &gateway);
1090 if (r < 0 && r != -ENOENT) {
1091 log_warning_link(link, "DHCP error: could not get gateway: %s",
1097 log_struct_link(LOG_INFO, link,
1098 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1101 ADDRESS_FMT_VAL(address),
1103 ADDRESS_FMT_VAL(gateway),
1104 "ADDRESS=%u.%u.%u.%u",
1105 ADDRESS_FMT_VAL(address),
1108 "GATEWAY=%u.%u.%u.%u",
1109 ADDRESS_FMT_VAL(gateway),
1112 log_struct_link(LOG_INFO, link,
1113 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1116 ADDRESS_FMT_VAL(address),
1118 "ADDRESS=%u.%u.%u.%u",
1119 ADDRESS_FMT_VAL(address),
1124 link->dhcp_lease = lease;
1126 if (link->network->dhcp_mtu) {
1129 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1131 r = link_set_mtu(link, mtu);
1133 log_error_link(link, "Failed to set MTU "
1134 "to %" PRIu16, mtu);
1138 if (link->network->dhcp_hostname) {
1139 const char *hostname;
1141 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1143 r = link_set_hostname(link, hostname);
1145 log_error_link(link, "Failed to set transient hostname "
1146 "to '%s'", hostname);
1150 link_enter_set_addresses(link);
1155 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1156 Link *link = userdata;
1160 assert(link->network);
1161 assert(link->manager);
1163 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1167 case DHCP_EVENT_NO_LEASE:
1168 log_debug_link(link, "IP address in use.");
1170 case DHCP_EVENT_EXPIRED:
1171 case DHCP_EVENT_STOP:
1172 case DHCP_EVENT_IP_CHANGE:
1173 if (link->network->dhcp_critical) {
1174 log_error_link(link, "DHCPv4 connection considered system critical, "
1175 "ignoring request to reconfigure it.");
1179 if (link->dhcp_lease) {
1180 r = dhcp_lease_lost(link);
1182 link_enter_failed(link);
1187 if (event == DHCP_EVENT_IP_CHANGE) {
1188 r = dhcp_lease_acquired(client, link);
1190 link_enter_failed(link);
1195 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1196 if (!sd_ipv4ll_is_running(link->ipv4ll))
1197 r = sd_ipv4ll_start(link->ipv4ll);
1198 else if (ipv4ll_is_bound(link->ipv4ll))
1199 r = ipv4ll_address_update(link, false);
1201 link_enter_failed(link);
1207 case DHCP_EVENT_RENEW:
1208 r = dhcp_lease_renew(client, link);
1210 link_enter_failed(link);
1214 case DHCP_EVENT_IP_ACQUIRE:
1215 r = dhcp_lease_acquired(client, link);
1217 link_enter_failed(link);
1221 if (ipv4ll_is_bound(link->ipv4ll))
1222 r = ipv4ll_address_update(link, true);
1224 r = sd_ipv4ll_stop(link->ipv4ll);
1226 link_enter_failed(link);
1233 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1235 log_warning_link(link, "DHCP unknown event: %d", event);
1242 static int ipv4ll_address_update(Link *link, bool deprecate) {
1244 struct in_addr addr;
1248 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1250 _cleanup_address_free_ Address *address = NULL;
1252 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1253 deprecate ? "deprecate" : "approve",
1254 ADDRESS_FMT_VAL(addr));
1256 r = address_new_dynamic(&address);
1258 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1262 address->family = AF_INET;
1263 address->in_addr.in = addr;
1264 address->prefixlen = 16;
1265 address->scope = RT_SCOPE_LINK;
1266 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1267 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1269 address_update(address, link, &address_update_handler);
1277 static int ipv4ll_address_lost(Link *link) {
1279 struct in_addr addr;
1283 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1285 _cleanup_address_free_ Address *address = NULL;
1286 _cleanup_route_free_ Route *route = NULL;
1288 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1289 ADDRESS_FMT_VAL(addr));
1291 r = address_new_dynamic(&address);
1293 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1297 address->family = AF_INET;
1298 address->in_addr.in = addr;
1299 address->prefixlen = 16;
1300 address->scope = RT_SCOPE_LINK;
1302 address_drop(address, link, &address_drop_handler);
1305 r = route_new_dynamic(&route);
1307 log_error_link(link, "Could not allocate route: %s",
1312 route->family = AF_INET;
1313 route->scope = RT_SCOPE_LINK;
1314 route->metrics = 99;
1316 route_drop(route, link, &route_drop_handler);
1323 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1325 struct in_addr addr;
1329 r = sd_ipv4ll_get_address(ll, &addr);
1335 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1336 struct in_addr address;
1342 r = sd_ipv4ll_get_address(ll, &address);
1346 log_struct_link(LOG_INFO, link,
1347 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1350 ADDRESS_FMT_VAL(address),
1353 link_enter_set_addresses(link);
1358 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1359 Link *link = userdata;
1363 assert(link->network);
1364 assert(link->manager);
1366 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1370 case IPV4LL_EVENT_STOP:
1371 case IPV4LL_EVENT_CONFLICT:
1372 r = ipv4ll_address_lost(link);
1374 link_enter_failed(link);
1378 case IPV4LL_EVENT_BIND:
1379 r = ipv4ll_address_claimed(ll, link);
1381 link_enter_failed(link);
1387 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1389 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1394 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1395 Link *link = userdata;
1398 assert(link->network);
1399 assert(link->manager);
1401 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1405 case DHCP6_EVENT_STOP:
1406 case DHCP6_EVENT_RESEND_EXPIRE:
1407 case DHCP6_EVENT_RETRANS_MAX:
1408 case DHCP6_EVENT_IP_ACQUIRE:
1409 log_debug_link(link, "DHCPv6 event %d", event);
1415 log_warning_link(link, "DHCPv6 error: %s",
1418 log_warning_link(link, "DHCPv6 unknown event: %d",
1424 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1425 Link *link = userdata;
1429 assert(link->network);
1430 assert(link->manager);
1432 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1436 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1437 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1440 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1441 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1446 log_warning_link(link, "ICMPv6 error: %s",
1449 log_warning_link(link, "ICMPv6 unknown event: %d",
1455 if (link->dhcp6_client)
1458 r = sd_dhcp6_client_new(&link->dhcp6_client);
1462 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1464 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1468 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1470 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1474 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1476 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1480 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1483 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1487 r = sd_dhcp6_client_start(link->dhcp6_client);
1489 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1492 static int link_acquire_conf(Link *link) {
1496 assert(link->network);
1497 assert(link->manager);
1498 assert(link->manager->event);
1500 if (link->network->ipv4ll) {
1501 assert(link->ipv4ll);
1503 log_debug_link(link, "acquiring IPv4 link-local address");
1505 r = sd_ipv4ll_start(link->ipv4ll);
1507 log_warning_link(link, "could not acquire IPv4 "
1508 "link-local address");
1513 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1514 assert(link->dhcp_client);
1516 log_debug_link(link, "acquiring DHCPv4 lease");
1518 r = sd_dhcp_client_start(link->dhcp_client);
1520 log_warning_link(link, "could not acquire DHCPv4 "
1526 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1527 assert(link->icmp6_router_discovery);
1529 log_debug_link(link, "discovering IPv6 routers");
1531 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1533 log_warning_link(link, "could not start IPv6 router discovery");
1541 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1542 /* see Documentation/networking/operstates.txt in the kernel sources */
1544 if (operstate == IF_OPER_UP)
1547 if (operstate == IF_OPER_UNKNOWN)
1548 /* operstate may not be implemented, so fall back to flags */
1549 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1555 #define FLAG_STRING(string, flag, old, new) \
1556 (((old ^ new) & flag) \
1557 ? ((old & flag) ? (" -" string) : (" +" string)) \
1560 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1561 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1563 bool carrier_gained = false, carrier_lost = false;
1568 r = sd_rtnl_message_link_get_flags(m, &flags);
1570 log_warning_link(link, "Could not get link flags");
1574 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1576 /* if we got a message without operstate, take it to mean
1577 the state was unchanged */
1578 operstate = link->kernel_operstate;
1580 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1583 if (link->flags != flags) {
1584 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",
1585 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1586 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1587 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1588 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1589 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1590 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1591 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1592 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1593 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1594 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1595 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1596 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1597 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1598 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1599 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1600 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1601 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1602 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1603 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1605 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1606 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1607 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1608 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1609 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1610 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1611 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1612 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1614 /* link flags are currently at most 18 bits, let's align to printing 20 */
1615 if (unknown_flags_added)
1616 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1617 unknown_flags_added);
1619 if (unknown_flags_removed)
1620 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1621 unknown_flags_removed);
1624 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1625 link_has_carrier(flags, operstate);
1626 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1627 !link_has_carrier(flags, operstate);
1629 link->flags = flags;
1630 link->kernel_operstate = operstate;
1634 if (link->state == LINK_STATE_FAILED ||
1635 link->state == LINK_STATE_UNMANAGED)
1638 if (carrier_gained) {
1639 log_info_link(link, "gained carrier");
1641 if (link->network) {
1642 r = link_acquire_conf(link);
1644 link_enter_failed(link);
1648 } else if (carrier_lost) {
1649 log_info_link(link, "lost carrier");
1651 r = link_stop_clients(link);
1653 link_enter_failed(link);
1661 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1662 _cleanup_link_unref_ Link *link = userdata;
1667 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1670 r = sd_rtnl_message_get_errno(m);
1672 /* we warn but don't fail the link, as it may
1673 be brought up later */
1674 log_struct_link(LOG_WARNING, link,
1675 "MESSAGE=%-*s: could not bring up interface: %s",
1677 link->ifname, strerror(-r),
1685 static int link_up(Link *link) {
1686 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1690 assert(link->manager);
1691 assert(link->manager->rtnl);
1693 log_debug_link(link, "bringing link up");
1695 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1696 RTM_SETLINK, link->ifindex);
1698 log_error_link(link, "Could not allocate RTM_SETLINK message");
1702 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1704 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1708 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1710 log_error_link(link,
1711 "Could not send rtnetlink message: %s", strerror(-r));
1720 static int link_enslaved(Link *link) {
1724 assert(link->state == LINK_STATE_ENSLAVING);
1725 assert(link->network);
1727 log_debug_link(link, "enslaved");
1729 if (!(link->flags & IFF_UP)) {
1732 link_enter_failed(link);
1737 return link_enter_set_addresses(link);
1740 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1741 _cleanup_link_unref_ Link *link = userdata;
1745 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1746 LINK_STATE_LINGER));
1747 assert(link->network);
1751 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1754 r = sd_rtnl_message_get_errno(m);
1755 if (r < 0 && r != -EEXIST) {
1756 log_struct_link(LOG_ERR, link,
1757 "MESSAGE=%-*s: could not enslave: %s",
1759 link->ifname, strerror(-r),
1762 link_enter_failed(link);
1766 if (link->enslaving <= 0)
1767 link_enslaved(link);
1772 static int link_enter_enslave(Link *link) {
1773 NetDev *vlan, *macvlan, *vxlan;
1778 assert(link->network);
1779 assert(link->state == LINK_STATE_INITIALIZING);
1781 link->state = LINK_STATE_ENSLAVING;
1785 if (!link->network->bridge &&
1786 !link->network->bond &&
1787 !link->network->tunnel &&
1788 hashmap_isempty(link->network->vlans) &&
1789 hashmap_isempty(link->network->macvlans) &&
1790 hashmap_isempty(link->network->vxlans))
1791 return link_enslaved(link);
1793 if (link->network->bond) {
1794 log_struct_link(LOG_DEBUG, link,
1795 "MESSAGE=%-*s: enslaving by '%s'",
1797 link->ifname, link->network->bond->ifname,
1798 NETDEV(link->network->bond),
1801 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1803 log_struct_link(LOG_WARNING, link,
1804 "MESSAGE=%-*s: could not enslave by '%s': %s",
1806 link->ifname, link->network->bond->ifname, strerror(-r),
1807 NETDEV(link->network->bond),
1809 link_enter_failed(link);
1817 if (link->network->bridge) {
1818 log_struct_link(LOG_DEBUG, link,
1819 "MESSAGE=%-*s: enslaving by '%s'",
1821 link->ifname, link->network->bridge->ifname,
1822 NETDEV(link->network->bridge),
1825 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1827 log_struct_link(LOG_WARNING, link,
1828 "MESSAGE=%-*s: could not enslave by '%s': %s",
1830 link->ifname, link->network->bridge->ifname, strerror(-r),
1831 NETDEV(link->network->bridge),
1833 link_enter_failed(link);
1841 if (link->network->tunnel) {
1842 log_struct_link(LOG_DEBUG, link,
1843 "MESSAGE=%-*s: enslaving by '%s'",
1845 link->ifname, link->network->tunnel->ifname,
1846 NETDEV(link->network->tunnel),
1849 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1851 log_struct_link(LOG_WARNING, link,
1852 "MESSAGE=%-*s: could not enslave by '%s': %s",
1854 link->ifname, link->network->tunnel->ifname, strerror(-r),
1855 NETDEV(link->network->tunnel),
1857 link_enter_failed(link);
1865 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1866 log_struct_link(LOG_DEBUG, link,
1867 "MESSAGE=%-*s: enslaving by '%s'",
1869 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1871 r = netdev_enslave(vlan, link, &enslave_handler);
1873 log_struct_link(LOG_WARNING, link,
1874 "MESSAGE=%-*s: could not enslave by '%s': %s",
1876 link->ifname, vlan->ifname, strerror(-r),
1877 NETDEV(vlan), NULL);
1878 link_enter_failed(link);
1886 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1887 log_struct_link(LOG_DEBUG, link,
1888 "MESSAGE=%-*s: enslaving by '%s'",
1890 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1892 r = netdev_enslave(macvlan, link, &enslave_handler);
1894 log_struct_link(LOG_WARNING, link,
1895 "MESSAGE=%-*s: could not enslave by '%s': %s",
1897 link->ifname, macvlan->ifname, strerror(-r),
1898 NETDEV(macvlan), NULL);
1899 link_enter_failed(link);
1907 HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1908 log_struct_link(LOG_DEBUG, link,
1909 "MESSAGE=%*s: enslaving by '%s'",
1911 link->ifname, vxlan->ifname, NETDEV(vxlan), NULL);
1913 r = netdev_enslave(vxlan, link, &enslave_handler);
1915 log_struct_link(LOG_WARNING, link,
1916 "MESSAGE=%*s: could not enslave by '%s': %s",
1918 link->ifname, vxlan->ifname, strerror(-r),
1919 NETDEV(vxlan), NULL);
1920 link_enter_failed(link);
1931 static int link_configure(Link *link) {
1935 assert(link->state == LINK_STATE_INITIALIZING);
1937 if (link->network->ipv4ll) {
1940 r = sd_ipv4ll_new(&link->ipv4ll);
1944 if (link->udev_device) {
1945 r = net_get_unique_predictable_data(link->udev_device, seed);
1947 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1953 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1957 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1961 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1965 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1970 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1971 r = sd_dhcp_client_new(&link->dhcp_client);
1975 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1979 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1983 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1987 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1991 if (link->network->dhcp_mtu) {
1992 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1997 if (link->network->dhcp_routes) {
1998 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
2001 r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
2006 if (link->network->dhcp_sendhost) {
2007 _cleanup_free_ char *hostname = gethostname_malloc();
2011 if (!is_localhost(hostname)) {
2012 r = sd_dhcp_client_set_hostname(link->dhcp_client, hostname);
2019 if (link->network->dhcp_server) {
2020 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2024 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2029 if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
2030 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
2034 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
2039 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
2044 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
2049 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
2050 icmp6_router_handler, link);
2055 if (link_has_carrier(link->flags, link->kernel_operstate)) {
2056 r = link_acquire_conf(link);
2061 return link_enter_enslave(link);
2064 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2065 _cleanup_link_unref_ Link *link = userdata;
2070 assert(link->ifname);
2071 assert(link->manager);
2073 if (link->state != LINK_STATE_INITIALIZING)
2076 log_debug_link(link, "link state is up-to-date");
2078 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2080 link_enter_unmanaged(link);
2085 r = network_apply(link->manager, network, link);
2089 r = link_configure(link);
2096 int link_initialized(Link *link, struct udev_device *device) {
2097 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2101 assert(link->manager);
2102 assert(link->manager->rtnl);
2105 if (link->state != LINK_STATE_INITIALIZING)
2108 log_debug_link(link, "udev initialized link");
2110 link->udev_device = udev_device_ref(device);
2112 /* udev has initialized the link, but we don't know if we have yet processed
2113 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2114 we know that the pending NEWLINKs have already been processed and that we
2117 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2121 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2130 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2131 Manager *m = userdata;
2134 _cleanup_address_free_ Address *address = NULL;
2136 char buf[INET6_ADDRSTRLEN];
2137 bool address_dropped = false;
2144 r = sd_rtnl_message_get_type(message, &type);
2146 log_warning("rtnl: could not get message type");
2150 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2151 if (r < 0 || ifindex <= 0) {
2152 log_warning("rtnl: received address message without valid ifindex, ignoring");
2155 r = link_get(m, ifindex, &link);
2156 if (r < 0 || !link) {
2157 log_warning("rtnl: received address for a nonexistent link, ignoring");
2162 r = address_new_dynamic(&address);
2166 r = sd_rtnl_message_addr_get_family(message, &address->family);
2167 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2168 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2172 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2174 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2178 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2180 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2184 switch (address->family) {
2186 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2188 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2195 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2197 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2204 assert_not_reached("invalid address family");
2207 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2208 log_warning_link(link, "could not print address");
2212 LIST_FOREACH(addresses, ad, link->addresses) {
2213 if (address_equal(ad, address)) {
2214 LIST_REMOVE(addresses, link->addresses, ad);
2218 address_dropped = true;
2226 if (!address_dropped)
2227 log_debug_link(link, "added address: %s/%u", buf,
2228 address->prefixlen);
2230 LIST_PREPEND(addresses, link->addresses, address);
2237 if (address_dropped) {
2238 log_debug_link(link, "removed address: %s/%u", buf,
2239 address->prefixlen);
2246 assert_not_reached("Received invalid RTNL message type");
2252 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2253 _cleanup_link_unref_ Link *link = userdata;
2259 assert(link->manager);
2261 for (; m; m = sd_rtnl_message_next(m)) {
2262 r = sd_rtnl_message_get_errno(m);
2264 log_debug_link(link, "getting address failed: %s", strerror(-r));
2268 r = link_rtnl_process_address(rtnl, m, link->manager);
2270 log_warning_link(link, "could not process address: %s", strerror(-r));
2276 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2278 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2279 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2280 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2288 r = link_new(m, message, ret);
2294 log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2296 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2300 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2306 if (detect_container(NULL) <= 0) {
2307 /* not in a container, udev will be around */
2308 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2309 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2311 log_warning_link(link, "could not find udev device");
2315 if (udev_device_get_is_initialized(device) <= 0) {
2317 log_debug_link(link, "udev initializing link...");
2321 r = link_initialized(link, device);
2325 /* we are calling a callback directly, so must take a ref */
2328 r = link_initialized_and_synced(m->rtnl, NULL, link);
2336 int link_update(Link *link, sd_rtnl_message *m) {
2337 struct ether_addr mac;
2342 assert(link->ifname);
2345 if (link->state == LINK_STATE_LINGER) {
2347 log_info_link(link, "link readded");
2348 link->state = LINK_STATE_ENSLAVING;
2351 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2352 if (r >= 0 && !streq(ifname, link->ifname)) {
2353 log_info_link(link, "renamed to %s", ifname);
2356 link->ifname = strdup(ifname);
2361 if (!link->original_mtu) {
2362 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2364 log_debug_link(link, "saved original MTU: %"
2365 PRIu16, link->original_mtu);
2368 /* The kernel may broadcast NEWLINK messages without the MAC address
2369 set, simply ignore them. */
2370 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2372 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2374 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2376 log_debug_link(link, "MAC address: "
2377 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2378 mac.ether_addr_octet[0],
2379 mac.ether_addr_octet[1],
2380 mac.ether_addr_octet[2],
2381 mac.ether_addr_octet[3],
2382 mac.ether_addr_octet[4],
2383 mac.ether_addr_octet[5]);
2386 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2388 log_warning_link(link, "Could not update MAC "
2389 "address in IPv4LL client: %s",
2395 if (link->dhcp_client) {
2396 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2398 log_warning_link(link, "Could not update MAC "
2399 "address in DHCP client: %s",
2405 if (link->dhcp6_client) {
2406 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2409 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2417 return link_update_flags(link, m);
2420 static void serialize_addresses(FILE *f, const char *key, Address *address) {
2429 fprintf(f, "%s=", key);
2431 LIST_FOREACH(addresses, ad, address) {
2432 char buf[INET6_ADDRSTRLEN];
2434 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
2435 fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2441 static void link_update_operstate(Link *link) {
2445 if (link->kernel_operstate == IF_OPER_DORMANT)
2446 link->operstate = LINK_OPERSTATE_DORMANT;
2447 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2449 uint8_t scope = RT_SCOPE_NOWHERE;
2451 /* if we have carrier, check what addresses we have */
2452 LIST_FOREACH(addresses, address, link->addresses) {
2453 if (address->scope < scope)
2454 scope = address->scope;
2457 if (scope < RT_SCOPE_SITE)
2458 /* universally accessible addresses found */
2459 link->operstate = LINK_OPERSTATE_ROUTABLE;
2460 else if (scope < RT_SCOPE_HOST)
2461 /* only link or site local addresses found */
2462 link->operstate = LINK_OPERSTATE_DEGRADED;
2464 /* no useful addresses found */
2465 link->operstate = LINK_OPERSTATE_CARRIER;
2467 link->operstate = LINK_OPERSTATE_UNKNOWN;
2470 int link_save(Link *link) {
2471 _cleanup_free_ char *temp_path = NULL;
2472 _cleanup_fclose_ FILE *f = NULL;
2473 const char *admin_state, *oper_state;
2477 assert(link->state_file);
2478 assert(link->lease_file);
2479 assert(link->manager);
2481 link_update_operstate(link);
2483 r = manager_save(link->manager);
2487 if (link->state == LINK_STATE_LINGER) {
2488 unlink(link->state_file);
2492 admin_state = link_state_to_string(link->state);
2493 assert(admin_state);
2495 oper_state = link_operstate_to_string(link->operstate);
2498 r = fopen_temporary(link->state_file, &f, &temp_path);
2502 fchmod(fileno(f), 0644);
2505 "# This is private data. Do not parse.\n"
2509 admin_state, oper_state, link->flags);
2511 if (link->network) {
2512 serialize_addresses(f, "DNS", link->network->dns);
2513 serialize_addresses(f, "NTP", link->network->ntp);
2516 if (link->dhcp_lease) {
2517 assert(link->network);
2519 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2526 "DHCP_USE_NTP=%s\n",
2528 yes_no(link->network->dhcp_dns),
2529 yes_no(link->network->dhcp_ntp));
2531 unlink(link->lease_file);
2535 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2537 unlink(link->state_file);
2543 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2548 static const char* const link_state_table[_LINK_STATE_MAX] = {
2549 [LINK_STATE_INITIALIZING] = "initializing",
2550 [LINK_STATE_ENSLAVING] = "configuring",
2551 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2552 [LINK_STATE_SETTING_ROUTES] = "configuring",
2553 [LINK_STATE_CONFIGURED] = "configured",
2554 [LINK_STATE_UNMANAGED] = "unmanaged",
2555 [LINK_STATE_FAILED] = "failed",
2556 [LINK_STATE_LINGER] = "linger",
2559 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2561 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2562 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2563 [LINK_OPERSTATE_DORMANT] = "dormant",
2564 [LINK_OPERSTATE_CARRIER] = "carrier",
2565 [LINK_OPERSTATE_DEGRADED] = "degraded",
2566 [LINK_OPERSTATE_ROUTABLE] = "routable",
2569 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2571 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2572 [DHCP_SUPPORT_NONE] = "none",
2573 [DHCP_SUPPORT_BOTH] = "both",
2574 [DHCP_SUPPORT_V4] = "v4",
2575 [DHCP_SUPPORT_V6] = "v6",
2578 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2580 int config_parse_dhcp(
2582 const char *filename,
2584 const char *section,
2585 unsigned section_line,
2592 DHCPSupport *dhcp = data;
2600 /* Our enum shall be a superset of booleans, hence first try
2601 * to parse as boolean, and then as enum */
2603 k = parse_boolean(rvalue);
2605 *dhcp = DHCP_SUPPORT_BOTH;
2607 *dhcp = DHCP_SUPPORT_NONE;
2611 s = dhcp_support_from_string(rvalue);
2613 log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);