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>
26 #include "libudev-private.h"
27 #include "udev-util.h"
31 #include "network-internal.h"
33 #include "network-util.h"
34 #include "dhcp-lease-internal.h"
36 static int ipv4ll_address_update(Link *link, bool deprecate);
37 static bool ipv4ll_is_bound(sd_ipv4ll *ll);
39 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
40 _cleanup_link_unref_ Link *link = NULL;
46 assert(manager->links);
50 r = sd_rtnl_message_get_type(message, &type);
53 else if (type != RTM_NEWLINK)
56 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
59 else if (ifindex <= 0)
62 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
71 link->manager = manager;
72 link->state = LINK_STATE_INITIALIZING;
73 link->ifindex = ifindex;
74 link->ifname = strdup(ifname);
78 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
82 r = asprintf(&link->state_file, "/run/systemd/netif/links/%"PRIu64,
87 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%"PRIu64,
92 r = hashmap_put(manager->links, &link->ifindex, link);
102 static void link_free(Link *link) {
108 assert(link->manager);
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);
130 hashmap_remove(link->manager->links, &link->ifindex);
134 unlink(link->state_file);
135 free(link->state_file);
137 udev_device_unref(link->udev_device);
142 Link *link_unref(Link *link) {
143 if (link && (-- link->n_ref <= 0))
149 Link *link_ref(Link *link) {
151 assert_se(++ link->n_ref >= 2);
156 int link_get(Manager *m, int ifindex, Link **ret) {
165 ifindex_64 = ifindex;
166 link = hashmap_get(m->links, &ifindex_64);
175 void link_drop(Link *link) {
176 if (!link || link->state == LINK_STATE_LINGER)
179 link->state = LINK_STATE_LINGER;
181 log_debug_link(link, "link removed");
188 static void link_enter_unmanaged(Link *link) {
191 log_debug_link(link, "unmanaged");
193 link->state = LINK_STATE_UNMANAGED;
198 static int link_stop_clients(Link *link) {
202 assert(link->manager);
203 assert(link->manager->event);
208 if (link->network->dhcp) {
209 assert(link->dhcp_client);
211 k = sd_dhcp_client_stop(link->dhcp_client);
213 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
218 if (link->network->ipv4ll) {
219 assert(link->ipv4ll);
221 k = sd_ipv4ll_stop(link->ipv4ll);
223 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
228 if (link->network->dhcp_server) {
229 assert(link->dhcp_server);
231 k = sd_dhcp_server_stop(link->dhcp_server);
233 log_warning_link(link, "Could not stop DHCPv4 server: %s", strerror(-r));
238 if (link->network->dhcp6) {
239 assert(link->dhcp6_client);
241 k = sd_dhcp6_client_stop(link->dhcp6_client);
243 log_warning_link(link, "Could not stop DHCPv6 client: %s", strerror(-r));
251 static void link_enter_failed(Link *link) {
254 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
257 log_warning_link(link, "failed");
259 link->state = LINK_STATE_FAILED;
261 link_stop_clients(link);
266 static Address* link_find_dhcp_server_address(Link *link) {
270 assert(link->network);
272 /* The the first statically configured address if there is any */
273 LIST_FOREACH(addresses, address, link->network->static_addresses) {
275 if (address->family != AF_INET)
278 if (in_addr_null(address->family, &address->in_addr))
284 /* If that didn't work, find a suitable address we got from the pool */
285 LIST_FOREACH(addresses, address, link->pool_addresses) {
286 if (address->family != AF_INET)
295 static int link_enter_configured(Link *link) {
299 assert(link->network);
300 assert(link->state == LINK_STATE_SETTING_ROUTES);
302 if (link->network->dhcp_server) {
303 struct in_addr pool_start;
306 address = link_find_dhcp_server_address(link);
308 log_warning_link(link, "Failed to find suitable address for DHCPv4 server instance.");
309 link_enter_failed(link);
313 log_debug_link(link, "offering DHCPv4 leases");
315 r = sd_dhcp_server_set_address(link->dhcp_server, &address->in_addr.in);
319 /* offer 32 addresses starting from the address following the server address */
320 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
321 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
327 r = sd_dhcp_server_set_router(link->dhcp_server,
328 &main_address->in_addr.in);
332 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
333 main_address->prefixlen);
338 r = sd_dhcp_server_start(link->dhcp_server);
340 log_warning_link(link, "could not start DHCPv4 server "
341 "instance: %s", strerror(-r));
343 link_enter_failed(link);
349 log_info_link(link, "link configured");
351 link->state = LINK_STATE_CONFIGURED;
358 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
359 Link *link = userdata;
362 assert(link->route_messages > 0);
363 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
364 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
367 link->route_messages --;
369 if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER)) {
374 r = sd_rtnl_message_get_errno(m);
375 if (r < 0 && r != -EEXIST)
376 log_struct_link(LOG_WARNING, link,
377 "MESSAGE=%-*s: could not set route: %s",
379 link->ifname, strerror(-r),
383 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
385 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
386 log_debug_link(link, "routes set");
387 link_enter_configured(link);
395 static int link_enter_set_routes(Link *link) {
400 assert(link->network);
401 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
403 link->state = LINK_STATE_SETTING_ROUTES;
405 if (!link->network->static_routes && !link->dhcp_lease &&
406 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
407 return link_enter_configured(link);
409 log_debug_link(link, "setting routes");
411 LIST_FOREACH(routes, rt, link->network->static_routes) {
412 r = route_configure(rt, link, &route_handler);
414 log_warning_link(link,
415 "could not set routes: %s", strerror(-r));
416 link_enter_failed(link);
421 link->route_messages ++;
424 if (link->ipv4ll && !link->dhcp_lease) {
425 _cleanup_route_free_ Route *route = NULL;
428 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
429 if (r < 0 && r != -ENOENT) {
430 log_warning_link(link, "IPV4LL error: no address: %s",
436 r = route_new_dynamic(&route);
438 log_error_link(link, "Could not allocate route: %s",
443 route->family = AF_INET;
444 route->scope = RT_SCOPE_LINK;
447 r = route_configure(route, link, &route_handler);
449 log_warning_link(link,
450 "could not set routes: %s", strerror(-r));
451 link_enter_failed(link);
456 link->route_messages ++;
460 if (link->dhcp_lease) {
461 _cleanup_route_free_ Route *route = NULL;
462 _cleanup_route_free_ Route *route_gw = NULL;
463 struct in_addr gateway;
465 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
466 if (r < 0 && r != -ENOENT) {
467 log_warning_link(link, "DHCP error: %s", strerror(-r));
472 r = route_new_dynamic(&route);
474 log_error_link(link, "Could not allocate route: %s",
479 r = route_new_dynamic(&route_gw);
481 log_error_link(link, "Could not allocate route: %s",
486 /* The dhcp netmask may mask out the gateway. Add an explicit
487 * route for the gw host so that we can route no matter the
488 * netmask or existing kernel route tables. */
489 route_gw->family = AF_INET;
490 route_gw->dst_addr.in = gateway;
491 route_gw->dst_prefixlen = 32;
492 route_gw->scope = RT_SCOPE_LINK;
494 r = route_configure(route_gw, link, &route_handler);
496 log_warning_link(link,
497 "could not set host route: %s", strerror(-r));
502 link->route_messages ++;
504 route->family = AF_INET;
505 route->in_addr.in = gateway;
507 r = route_configure(route, link, &route_handler);
509 log_warning_link(link,
510 "could not set routes: %s", strerror(-r));
511 link_enter_failed(link);
516 link->route_messages ++;
520 if (link->route_messages == 0) {
521 link_enter_configured(link);
527 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
528 Link *link = userdata;
533 assert(link->ifname);
535 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
540 r = sd_rtnl_message_get_errno(m);
541 if (r < 0 && r != -ESRCH)
542 log_struct_link(LOG_WARNING, link,
543 "MESSAGE=%-*s: could not drop route: %s",
545 link->ifname, strerror(-r),
554 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
555 Link *link = userdata;
560 assert(link->ifname);
561 assert(link->addr_messages > 0);
562 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
563 LINK_STATE_FAILED, LINK_STATE_LINGER));
565 link->addr_messages --;
567 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
572 r = sd_rtnl_message_get_errno(m);
573 if (r < 0 && r != -EEXIST)
574 log_struct_link(LOG_WARNING, link,
575 "MESSAGE=%-*s: could not set address: %s",
577 link->ifname, strerror(-r),
581 if (link->addr_messages == 0) {
582 log_debug_link(link, "addresses set");
583 link_enter_set_routes(link);
591 static int link_enter_set_addresses(Link *link) {
596 assert(link->network);
597 assert(link->state != _LINK_STATE_INVALID);
599 link->state = LINK_STATE_SETTING_ADDRESSES;
601 if (!link->network->static_addresses && !link->dhcp_lease &&
602 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
603 return link_enter_set_routes(link);
605 log_debug_link(link, "setting addresses");
607 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
608 r = address_configure(ad, link, &address_handler);
610 log_warning_link(link,
611 "could not set addresses: %s", strerror(-r));
612 link_enter_failed(link);
617 link->addr_messages ++;
620 if (link->ipv4ll && !link->dhcp_lease) {
621 _cleanup_address_free_ Address *ll_addr = NULL;
624 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
625 if (r < 0 && r != -ENOENT) {
626 log_warning_link(link, "IPV4LL error: no address: %s",
632 r = address_new_dynamic(&ll_addr);
634 log_error_link(link, "Could not allocate address: %s", strerror(-r));
638 ll_addr->family = AF_INET;
639 ll_addr->in_addr.in = addr;
640 ll_addr->prefixlen = 16;
641 ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
642 ll_addr->scope = RT_SCOPE_LINK;
644 r = address_configure(ll_addr, link, &address_handler);
646 log_warning_link(link,
647 "could not set addresses: %s", strerror(-r));
648 link_enter_failed(link);
653 link->addr_messages ++;
657 if (link->dhcp_lease) {
658 _cleanup_address_free_ Address *address = NULL;
660 struct in_addr netmask;
663 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
665 log_warning_link(link, "DHCP error: no address: %s",
670 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
672 log_warning_link(link, "DHCP error: no netmask: %s",
677 prefixlen = net_netmask_to_prefixlen(&netmask);
679 r = address_new_dynamic(&address);
681 log_error_link(link, "Could not allocate address: %s",
686 address->family = AF_INET;
687 address->in_addr.in = addr;
688 address->prefixlen = prefixlen;
689 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
691 r = address_configure(address, link, &address_handler);
693 log_warning_link(link,
694 "could not set addresses: %s", strerror(-r));
695 link_enter_failed(link);
700 link->addr_messages ++;
706 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
707 Link *link = userdata;
712 assert(link->ifname);
714 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
719 r = sd_rtnl_message_get_errno(m);
720 if (r < 0 && r != -ENOENT)
721 log_struct_link(LOG_WARNING, link,
722 "MESSAGE=%-*s: could not update address: %s",
724 link->ifname, strerror(-r),
733 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
734 Link *link = userdata;
739 assert(link->ifname);
741 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
746 r = sd_rtnl_message_get_errno(m);
747 if (r < 0 && r != -EADDRNOTAVAIL)
748 log_struct_link(LOG_WARNING, link,
749 "MESSAGE=%-*s: could not drop address: %s",
751 link->ifname, strerror(-r),
760 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
761 Link *link = userdata;
766 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
771 r = sd_bus_message_get_errno(m);
773 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
780 static int link_set_hostname(Link *link, const char *hostname) {
781 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
785 assert(link->manager);
788 log_debug_link(link, "Setting transient hostname: '%s'", hostname);
790 if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
791 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
795 r = sd_bus_message_new_method_call(
798 "org.freedesktop.hostname1",
799 "/org/freedesktop/hostname1",
800 "org.freedesktop.hostname1",
805 r = sd_bus_message_append(m, "sb", hostname, false);
809 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
811 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
818 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
819 Link *link = userdata;
824 assert(link->ifname);
826 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
831 r = sd_rtnl_message_get_errno(m);
833 log_struct_link(LOG_WARNING, link,
834 "MESSAGE=%-*s: could not set MTU: %s",
835 IFNAMSIZ, link->ifname, strerror(-r),
844 static int link_set_mtu(Link *link, uint32_t mtu) {
845 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
849 assert(link->manager);
850 assert(link->manager->rtnl);
852 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
854 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
855 RTM_SETLINK, link->ifindex);
857 log_error_link(link, "Could not allocate RTM_SETLINK message");
861 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
863 log_error_link(link, "Could not append MTU: %s", strerror(-r));
867 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
870 "Could not send rtnetlink message: %s", strerror(-r));
879 static int dhcp_lease_lost(Link *link) {
880 _cleanup_address_free_ Address *address = NULL;
881 _cleanup_route_free_ Route *route_gw = NULL;
882 _cleanup_route_free_ Route *route = NULL;
884 struct in_addr netmask;
885 struct in_addr gateway;
890 assert(link->dhcp_lease);
892 log_warning_link(link, "DHCP lease lost");
894 r = address_new_dynamic(&address);
896 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
898 r = route_new_dynamic(&route_gw);
900 route_gw->family = AF_INET;
901 route_gw->dst_addr.in = gateway;
902 route_gw->dst_prefixlen = 32;
903 route_gw->scope = RT_SCOPE_LINK;
905 route_drop(route_gw, link, &route_drop_handler);
909 r = route_new_dynamic(&route);
911 route->family = AF_INET;
912 route->in_addr.in = gateway;
914 route_drop(route, link, &route_drop_handler);
919 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
920 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
921 prefixlen = net_netmask_to_prefixlen(&netmask);
923 address->family = AF_INET;
924 address->in_addr.in = addr;
925 address->prefixlen = prefixlen;
927 address_drop(address, link, &address_drop_handler);
931 if (link->network->dhcp_mtu) {
934 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
935 if (r >= 0 && link->original_mtu != mtu) {
936 r = link_set_mtu(link, link->original_mtu);
938 log_warning_link(link, "DHCP error: could not reset MTU");
939 link_enter_failed(link);
945 if (link->network->dhcp_hostname) {
946 const char *hostname = NULL;
948 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
949 if (r >= 0 && hostname) {
950 r = link_set_hostname(link, "");
952 log_error_link(link, "Failed to reset transient hostname");
956 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
961 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
962 sd_dhcp_lease *lease;
963 struct in_addr address;
964 struct in_addr netmask;
965 struct in_addr gateway;
972 r = sd_dhcp_client_get_lease(client, &lease);
974 log_warning_link(link, "DHCP error: no lease: %s",
979 r = sd_dhcp_lease_get_address(lease, &address);
981 log_warning_link(link, "DHCP error: no address: %s",
986 r = sd_dhcp_lease_get_netmask(lease, &netmask);
988 log_warning_link(link, "DHCP error: no netmask: %s",
993 prefixlen = net_netmask_to_prefixlen(&netmask);
995 r = sd_dhcp_lease_get_router(lease, &gateway);
996 if (r < 0 && r != -ENOENT) {
997 log_warning_link(link, "DHCP error: %s", strerror(-r));
1002 log_struct_link(LOG_INFO, link,
1003 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1006 ADDRESS_FMT_VAL(address),
1008 ADDRESS_FMT_VAL(gateway),
1009 "ADDRESS=%u.%u.%u.%u",
1010 ADDRESS_FMT_VAL(address),
1013 "GATEWAY=%u.%u.%u.%u",
1014 ADDRESS_FMT_VAL(gateway),
1017 log_struct_link(LOG_INFO, link,
1018 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1021 ADDRESS_FMT_VAL(address),
1023 "ADDRESS=%u.%u.%u.%u",
1024 ADDRESS_FMT_VAL(address),
1029 link->dhcp_lease = lease;
1031 if (link->network->dhcp_mtu) {
1034 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1036 r = link_set_mtu(link, mtu);
1038 log_error_link(link, "Failed to set MTU "
1039 "to %" PRIu16, mtu);
1043 if (link->network->dhcp_hostname) {
1044 const char *hostname;
1046 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1048 r = link_set_hostname(link, hostname);
1050 log_error_link(link, "Failed to set transient hostname "
1051 "to '%s'", hostname);
1055 link_enter_set_addresses(link);
1060 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1061 Link *link = userdata;
1065 assert(link->network);
1066 assert(link->manager);
1068 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1072 case DHCP_EVENT_NO_LEASE:
1073 log_debug_link(link, "IP address in use.");
1075 case DHCP_EVENT_EXPIRED:
1076 case DHCP_EVENT_STOP:
1077 case DHCP_EVENT_IP_CHANGE:
1078 if (link->network->dhcp_critical) {
1079 log_error_link(link, "DHCPv4 connection considered system critical, "
1080 "ignoring request to reconfigure it.");
1084 if (link->dhcp_lease) {
1085 r = dhcp_lease_lost(link);
1087 link_enter_failed(link);
1092 if (event == DHCP_EVENT_IP_CHANGE) {
1093 r = dhcp_lease_acquired(client, link);
1095 link_enter_failed(link);
1100 if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1101 if (!sd_ipv4ll_is_running(link->ipv4ll))
1102 r = sd_ipv4ll_start(link->ipv4ll);
1103 else if (ipv4ll_is_bound(link->ipv4ll))
1104 r = ipv4ll_address_update(link, false);
1106 link_enter_failed(link);
1112 case DHCP_EVENT_IP_ACQUIRE:
1113 r = dhcp_lease_acquired(client, link);
1115 link_enter_failed(link);
1119 if (ipv4ll_is_bound(link->ipv4ll))
1120 r = ipv4ll_address_update(link, true);
1122 r = sd_ipv4ll_stop(link->ipv4ll);
1124 link_enter_failed(link);
1131 log_warning_link(link, "DHCP error: %s", strerror(-event));
1133 log_warning_link(link, "DHCP unknown event: %d", event);
1140 static int ipv4ll_address_update(Link *link, bool deprecate) {
1142 struct in_addr addr;
1146 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1148 _cleanup_address_free_ Address *address = NULL;
1150 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1151 deprecate ? "deprecate" : "approve",
1152 ADDRESS_FMT_VAL(addr));
1154 r = address_new_dynamic(&address);
1156 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1160 address->family = AF_INET;
1161 address->in_addr.in = addr;
1162 address->prefixlen = 16;
1163 address->scope = RT_SCOPE_LINK;
1164 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1165 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1167 address_update(address, link, &address_update_handler);
1175 static int ipv4ll_address_lost(Link *link) {
1177 struct in_addr addr;
1181 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1183 _cleanup_address_free_ Address *address = NULL;
1184 _cleanup_route_free_ Route *route = NULL;
1186 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1187 ADDRESS_FMT_VAL(addr));
1189 r = address_new_dynamic(&address);
1191 log_error_link(link, "Could not allocate address: %s", strerror(-r));
1195 address->family = AF_INET;
1196 address->in_addr.in = addr;
1197 address->prefixlen = 16;
1198 address->scope = RT_SCOPE_LINK;
1200 address_drop(address, link, &address_drop_handler);
1203 r = route_new_dynamic(&route);
1205 log_error_link(link, "Could not allocate route: %s",
1210 route->family = AF_INET;
1211 route->scope = RT_SCOPE_LINK;
1212 route->metrics = 99;
1214 route_drop(route, link, &route_drop_handler);
1221 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1223 struct in_addr addr;
1227 r = sd_ipv4ll_get_address(ll, &addr);
1233 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1234 struct in_addr address;
1240 r = sd_ipv4ll_get_address(ll, &address);
1244 log_struct_link(LOG_INFO, link,
1245 "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1248 ADDRESS_FMT_VAL(address),
1251 link_enter_set_addresses(link);
1256 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1257 Link *link = userdata;
1261 assert(link->network);
1262 assert(link->manager);
1264 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1268 case IPV4LL_EVENT_STOP:
1269 case IPV4LL_EVENT_CONFLICT:
1270 r = ipv4ll_address_lost(link);
1272 link_enter_failed(link);
1276 case IPV4LL_EVENT_BIND:
1277 r = ipv4ll_address_claimed(ll, link);
1279 link_enter_failed(link);
1285 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1287 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1292 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1293 Link *link = userdata;
1296 assert(link->network);
1297 assert(link->manager);
1299 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1303 case DHCP6_EVENT_STOP:
1304 case DHCP6_EVENT_RESEND_EXPIRE:
1305 case DHCP6_EVENT_RETRANS_MAX:
1306 case DHCP6_EVENT_IP_ACQUIRE:
1307 log_debug_link(link, "DHCPv6 event %d", event);
1313 log_warning_link(link, "DHCPv6 error: %s",
1316 log_warning_link(link, "DHCPv6 unknown event: %d",
1322 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1323 Link *link = userdata;
1327 assert(link->network);
1328 assert(link->manager);
1330 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1334 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1335 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1338 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1339 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1344 log_warning_link(link, "ICMPv6 error: %s",
1347 log_warning_link(link, "ICMPv6 unknown event: %d",
1353 if (link->dhcp6_client)
1356 r = sd_dhcp6_client_new(&link->dhcp6_client);
1360 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1362 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1366 r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1368 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1372 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1374 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1378 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1381 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1385 r = sd_dhcp6_client_start(link->dhcp6_client);
1387 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1390 static int link_acquire_conf(Link *link) {
1394 assert(link->network);
1395 assert(link->manager);
1396 assert(link->manager->event);
1398 if (link->network->ipv4ll) {
1399 assert(link->ipv4ll);
1401 log_debug_link(link, "acquiring IPv4 link-local address");
1403 r = sd_ipv4ll_start(link->ipv4ll);
1405 log_warning_link(link, "could not acquire IPv4 "
1406 "link-local address");
1411 if (link->network->dhcp) {
1412 assert(link->dhcp_client);
1414 log_debug_link(link, "acquiring DHCPv4 lease");
1416 r = sd_dhcp_client_start(link->dhcp_client);
1418 log_warning_link(link, "could not acquire DHCPv4 "
1424 if (link->network->dhcp6) {
1425 assert(link->icmp6_router_discovery);
1427 log_debug_link(link, "discovering IPv6 routers");
1429 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1431 log_warning_link(link, "could not start IPv6 router discovery");
1439 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1440 /* see Documentation/networking/operstates.txt in the kernel sources */
1442 if (operstate == IF_OPER_UP)
1445 if (operstate == IF_OPER_UNKNOWN)
1446 /* operstate may not be implemented, so fall back to flags */
1447 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1453 #define FLAG_STRING(string, flag, old, new) \
1454 (((old ^ new) & flag) \
1455 ? ((old & flag) ? (" -" string) : (" +" string)) \
1458 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1459 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1461 bool carrier_gained = false, carrier_lost = false;
1466 r = sd_rtnl_message_link_get_flags(m, &flags);
1468 log_warning_link(link, "Could not get link flags");
1472 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1474 /* if we got a message without operstate, take it to mean
1475 the state was unchanged */
1476 operstate = link->kernel_operstate;
1478 if ((link->flags == flags) && (link->kernel_operstate == operstate))
1481 if (link->flags != flags) {
1482 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",
1483 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1484 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1485 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1486 FLAG_STRING("UP", IFF_UP, link->flags, flags),
1487 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1488 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1489 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1490 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1491 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1492 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1493 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1494 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1495 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1496 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1497 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1498 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1499 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1500 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1501 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1503 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1504 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1505 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1506 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1507 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1508 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1509 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1510 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1512 /* link flags are currently at most 18 bits, let's align to printing 20 */
1513 if (unknown_flags_added)
1514 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1515 unknown_flags_added);
1517 if (unknown_flags_removed)
1518 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1519 unknown_flags_removed);
1522 carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1523 link_has_carrier(flags, operstate);
1524 carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1525 !link_has_carrier(flags, operstate);
1527 link->flags = flags;
1528 link->kernel_operstate = operstate;
1532 if (link->state == LINK_STATE_FAILED ||
1533 link->state == LINK_STATE_UNMANAGED)
1536 if (carrier_gained) {
1537 log_info_link(link, "gained carrier");
1539 if (link->network) {
1540 r = link_acquire_conf(link);
1542 link_enter_failed(link);
1546 } else if (carrier_lost) {
1547 log_info_link(link, "lost carrier");
1549 r = link_stop_clients(link);
1551 link_enter_failed(link);
1559 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1560 Link *link = userdata;
1565 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1570 r = sd_rtnl_message_get_errno(m);
1572 /* we warn but don't fail the link, as it may
1573 be brought up later */
1574 log_struct_link(LOG_WARNING, link,
1575 "MESSAGE=%-*s: could not bring up interface: %s",
1577 link->ifname, strerror(-r),
1587 static int link_up(Link *link) {
1588 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1592 assert(link->manager);
1593 assert(link->manager->rtnl);
1595 log_debug_link(link, "bringing link up");
1597 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1598 RTM_SETLINK, link->ifindex);
1600 log_error_link(link, "Could not allocate RTM_SETLINK message");
1604 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1606 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1610 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1612 log_error_link(link,
1613 "Could not send rtnetlink message: %s", strerror(-r));
1622 static int link_enslaved(Link *link) {
1626 assert(link->state == LINK_STATE_ENSLAVING);
1627 assert(link->network);
1629 if (!(link->flags & IFF_UP)) {
1632 link_enter_failed(link);
1637 if (!link->network->dhcp && !link->network->ipv4ll)
1638 return link_enter_set_addresses(link);
1643 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1644 Link *link = userdata;
1648 assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1649 LINK_STATE_LINGER));
1650 assert(link->network);
1654 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1659 r = sd_rtnl_message_get_errno(m);
1661 log_struct_link(LOG_ERR, link,
1662 "MESSAGE=%-*s: could not enslave: %s",
1664 link->ifname, strerror(-r),
1667 link_enter_failed(link);
1672 log_debug_link(link, "enslaved");
1674 if (link->enslaving == 0)
1675 link_enslaved(link);
1682 static int link_enter_enslave(Link *link) {
1683 NetDev *vlan, *macvlan, *vxlan;
1688 assert(link->network);
1689 assert(link->state == LINK_STATE_INITIALIZING);
1691 link->state = LINK_STATE_ENSLAVING;
1695 if (!link->network->bridge &&
1696 !link->network->bond &&
1697 !link->network->tunnel &&
1698 hashmap_isempty(link->network->vlans) &&
1699 hashmap_isempty(link->network->macvlans) &&
1700 hashmap_isempty(link->network->vxlans))
1701 return link_enslaved(link);
1703 if (link->network->bond) {
1704 log_struct_link(LOG_DEBUG, link,
1705 "MESSAGE=%-*s: enslaving by '%s'",
1707 link->ifname, link->network->bond->ifname,
1708 NETDEV(link->network->bond),
1711 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1713 log_struct_link(LOG_WARNING, link,
1714 "MESSAGE=%-*s: could not enslave by '%s': %s",
1716 link->ifname, link->network->bond->ifname, strerror(-r),
1717 NETDEV(link->network->bond),
1719 link_enter_failed(link);
1727 if (link->network->bridge) {
1728 log_struct_link(LOG_DEBUG, link,
1729 "MESSAGE=%-*s: enslaving by '%s'",
1731 link->ifname, link->network->bridge->ifname,
1732 NETDEV(link->network->bridge),
1735 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1737 log_struct_link(LOG_WARNING, link,
1738 "MESSAGE=%-*s: could not enslave by '%s': %s",
1740 link->ifname, link->network->bridge->ifname, strerror(-r),
1741 NETDEV(link->network->bridge),
1743 link_enter_failed(link);
1751 if (link->network->tunnel) {
1752 log_struct_link(LOG_DEBUG, link,
1753 "MESSAGE=%-*s: enslaving by '%s'",
1755 link->ifname, link->network->tunnel->ifname,
1756 NETDEV(link->network->tunnel),
1759 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1761 log_struct_link(LOG_WARNING, link,
1762 "MESSAGE=%-*s: could not enslave by '%s': %s",
1764 link->ifname, link->network->tunnel->ifname, strerror(-r),
1765 NETDEV(link->network->tunnel),
1767 link_enter_failed(link);
1775 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1776 log_struct_link(LOG_DEBUG, link,
1777 "MESSAGE=%-*s: enslaving by '%s'",
1779 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1781 r = netdev_enslave(vlan, link, &enslave_handler);
1783 log_struct_link(LOG_WARNING, link,
1784 "MESSAGE=%-*s: could not enslave by '%s': %s",
1786 link->ifname, vlan->ifname, strerror(-r),
1787 NETDEV(vlan), NULL);
1788 link_enter_failed(link);
1796 HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1797 log_struct_link(LOG_DEBUG, link,
1798 "MESSAGE=%-*s: enslaving by '%s'",
1800 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1802 r = netdev_enslave(macvlan, link, &enslave_handler);
1804 log_struct_link(LOG_WARNING, link,
1805 "MESSAGE=%-*s: could not enslave by '%s': %s",
1807 link->ifname, macvlan->ifname, strerror(-r),
1808 NETDEV(macvlan), NULL);
1809 link_enter_failed(link);
1817 HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1818 log_struct_link(LOG_DEBUG, link,
1819 "MESSAGE=%*s: enslaving by '%s'",
1821 link->ifname, vxlan->ifname, NETDEV(vxlan), NULL);
1823 r = netdev_enslave(vxlan, link, &enslave_handler);
1825 log_struct_link(LOG_WARNING, link,
1826 "MESSAGE=%*s: could not enslave by '%s': %s",
1828 link->ifname, vxlan->ifname, strerror(-r),
1829 NETDEV(vxlan), NULL);
1830 link_enter_failed(link);
1841 static int link_configure(Link *link) {
1845 assert(link->state == LINK_STATE_INITIALIZING);
1847 if (link->network->ipv4ll) {
1850 r = sd_ipv4ll_new(&link->ipv4ll);
1854 if (link->udev_device) {
1855 r = net_get_unique_predictable_data(link->udev_device, seed);
1857 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1863 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1867 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1871 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1875 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1880 if (link->network->dhcp) {
1881 r = sd_dhcp_client_new(&link->dhcp_client);
1885 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1889 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1893 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1897 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1901 if (link->network->dhcp_mtu) {
1902 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1908 if (link->network->dhcp_server) {
1909 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1913 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1918 if (link->network->dhcp6) {
1919 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1923 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1928 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1933 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1938 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1939 icmp6_router_handler, link);
1944 if (link_has_carrier(link->flags, link->kernel_operstate)) {
1945 r = link_acquire_conf(link);
1950 return link_enter_enslave(link);
1953 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1954 Link *link = userdata;
1959 assert(link->ifname);
1960 assert(link->manager);
1962 if (link->state != LINK_STATE_INITIALIZING)
1965 log_debug_link(link, "link state is up-to-date");
1967 r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
1969 link_enter_unmanaged(link);
1974 r = network_apply(link->manager, network, link);
1978 r = link_configure(link);
1985 int link_initialized(Link *link, struct udev_device *device) {
1986 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1990 assert(link->manager);
1991 assert(link->manager->rtnl);
1994 if (link->state != LINK_STATE_INITIALIZING)
1997 log_debug_link(link, "udev initialized link");
1999 link->udev_device = udev_device_ref(device);
2001 /* udev has initialized the link, but we don't know if we have yet processed
2002 the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2003 we know that the pending NEWLINKs have already been processed and that we
2006 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2010 r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2017 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2018 Manager *m = userdata;
2021 _cleanup_address_free_ Address *address = NULL;
2023 char buf[INET6_ADDRSTRLEN];
2024 bool address_dropped = false;
2031 r = sd_rtnl_message_get_type(message, &type);
2033 log_warning("rtnl: could not get message type");
2037 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2038 if (r < 0 || ifindex <= 0) {
2039 log_warning("rtnl: received address message without valid ifindex, ignoring");
2042 r = link_get(m, ifindex, &link);
2043 if (r < 0 || !link) {
2044 log_warning("rtnl: received address for a nonexistent link, ignoring");
2049 r = address_new_dynamic(&address);
2053 r = sd_rtnl_message_addr_get_family(message, &address->family);
2054 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2055 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2059 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2061 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2065 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2067 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2071 switch (address->family) {
2073 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2075 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2082 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2084 log_warning_link(link, "rtnl: received address without valid address, ignoring");
2091 assert_not_reached("invalid address family");
2094 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2095 log_warning_link(link, "could not print address");
2099 LIST_FOREACH(addresses, ad, link->addresses) {
2100 if (address_equal(ad, address)) {
2101 LIST_REMOVE(addresses, link->addresses, ad);
2105 address_dropped = true;
2113 if (!address_dropped)
2114 log_debug_link(link, "added address: %s/%u", buf,
2115 address->prefixlen);
2117 LIST_PREPEND(addresses, link->addresses, address);
2124 if (address_dropped) {
2125 log_debug_link(link, "removed address: %s/%u", buf,
2126 address->prefixlen);
2133 assert_not_reached("Received invalid RTNL message type");
2139 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2140 Link *link = userdata;
2147 for (; m; m = sd_rtnl_message_next(m)) {
2148 r = sd_rtnl_message_get_errno(m);
2150 log_debug_link(link, "getting address failed: %s", strerror(-r));
2154 r = link_rtnl_process_address(rtnl, m, link->manager);
2156 log_warning_link(link, "could not process address: %s", strerror(-r));
2162 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2164 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2165 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2166 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2174 r = link_new(m, message, ret);
2180 log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2182 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2186 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2190 if (detect_container(NULL) <= 0) {
2191 /* not in a container, udev will be around */
2192 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2193 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2195 log_warning_link(link, "could not find udev device");
2199 if (udev_device_get_is_initialized(device) <= 0) {
2201 log_debug_link(link, "udev initializing link...");
2205 r = link_initialized(link, device);
2209 r = link_initialized_and_synced(m->rtnl, NULL, link);
2217 int link_update(Link *link, sd_rtnl_message *m) {
2218 struct ether_addr mac;
2223 assert(link->ifname);
2226 if (link->state == LINK_STATE_LINGER) {
2228 log_info_link(link, "link readded");
2229 link->state = LINK_STATE_ENSLAVING;
2232 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2233 if (r >= 0 && !streq(ifname, link->ifname)) {
2234 log_info_link(link, "renamed to %s", ifname);
2237 link->ifname = strdup(ifname);
2242 if (!link->original_mtu) {
2243 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2245 log_debug_link(link, "saved original MTU: %"
2246 PRIu16, link->original_mtu);
2249 /* The kernel may broadcast NEWLINK messages without the MAC address
2250 set, simply ignore them. */
2251 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2253 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2255 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2257 log_debug_link(link, "MAC address: "
2258 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2259 mac.ether_addr_octet[0],
2260 mac.ether_addr_octet[1],
2261 mac.ether_addr_octet[2],
2262 mac.ether_addr_octet[3],
2263 mac.ether_addr_octet[4],
2264 mac.ether_addr_octet[5]);
2267 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2269 log_warning_link(link, "Could not update MAC "
2270 "address in IPv4LL client: %s",
2276 if (link->dhcp_client) {
2277 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2279 log_warning_link(link, "Could not update MAC "
2280 "address in DHCP client: %s",
2286 if (link->dhcp6_client) {
2287 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2290 log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2298 return link_update_flags(link, m);
2301 static void serialize_addresses(FILE *f, const char *key, Address *address) {
2310 fprintf(f, "%s=", key);
2312 LIST_FOREACH(addresses, ad, address) {
2313 char buf[INET6_ADDRSTRLEN];
2315 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
2316 fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2322 static void link_update_operstate(Link *link) {
2326 if (link->kernel_operstate == IF_OPER_DORMANT)
2327 link->operstate = LINK_OPERSTATE_DORMANT;
2328 else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2330 uint8_t scope = RT_SCOPE_NOWHERE;
2332 /* if we have carrier, check what addresses we have */
2333 LIST_FOREACH(addresses, address, link->addresses) {
2334 if (address->scope < scope)
2335 scope = address->scope;
2338 if (scope < RT_SCOPE_SITE)
2339 /* universally accessible addresses found */
2340 link->operstate = LINK_OPERSTATE_ROUTABLE;
2341 else if (scope < RT_SCOPE_HOST)
2342 /* only link or site local addresses found */
2343 link->operstate = LINK_OPERSTATE_DEGRADED;
2345 /* no useful addresses found */
2346 link->operstate = LINK_OPERSTATE_CARRIER;
2348 link->operstate = LINK_OPERSTATE_UNKNOWN;
2351 int link_save(Link *link) {
2352 _cleanup_free_ char *temp_path = NULL;
2353 _cleanup_fclose_ FILE *f = NULL;
2354 const char *admin_state, *oper_state;
2358 assert(link->state_file);
2359 assert(link->lease_file);
2360 assert(link->manager);
2362 link_update_operstate(link);
2364 r = manager_save(link->manager);
2368 if (link->state == LINK_STATE_LINGER) {
2369 unlink(link->state_file);
2373 admin_state = link_state_to_string(link->state);
2374 assert(admin_state);
2376 oper_state = link_operstate_to_string(link->operstate);
2379 r = fopen_temporary(link->state_file, &f, &temp_path);
2383 fchmod(fileno(f), 0644);
2386 "# This is private data. Do not parse.\n"
2390 admin_state, oper_state, link->flags);
2392 if (link->network) {
2393 serialize_addresses(f, "DNS", link->network->dns);
2394 serialize_addresses(f, "NTP", link->network->ntp);
2397 if (link->dhcp_lease) {
2398 assert(link->network);
2400 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2407 "DHCP_USE_NTP=%s\n",
2409 yes_no(link->network->dhcp_dns),
2410 yes_no(link->network->dhcp_ntp));
2412 unlink(link->lease_file);
2416 if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2418 unlink(link->state_file);
2424 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2429 static const char* const link_state_table[_LINK_STATE_MAX] = {
2430 [LINK_STATE_INITIALIZING] = "initializing",
2431 [LINK_STATE_ENSLAVING] = "configuring",
2432 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2433 [LINK_STATE_SETTING_ROUTES] = "configuring",
2434 [LINK_STATE_CONFIGURED] = "configured",
2435 [LINK_STATE_UNMANAGED] = "unmanaged",
2436 [LINK_STATE_FAILED] = "failed",
2437 [LINK_STATE_LINGER] = "linger",
2440 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2442 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2443 [LINK_OPERSTATE_UNKNOWN] = "unknown",
2444 [LINK_OPERSTATE_DORMANT] = "dormant",
2445 [LINK_OPERSTATE_CARRIER] = "carrier",
2446 [LINK_OPERSTATE_DEGRADED] = "degraded",
2447 [LINK_OPERSTATE_ROUTABLE] = "routable",
2450 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);