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 "networkd-link.h"
27 #include "networkd-netdev.h"
28 #include "libudev-private.h"
29 #include "udev-util.h"
33 #include "network-internal.h"
34 #include "conf-parser.h"
36 #include "dhcp-lease-internal.h"
38 static bool link_dhcp6_enabled(Link *link) {
39 if (link->flags & IFF_LOOPBACK)
45 return IN_SET(link->network->dhcp, DHCP_SUPPORT_V6, DHCP_SUPPORT_BOTH);
48 static bool link_dhcp4_enabled(Link *link) {
49 if (link->flags & IFF_LOOPBACK)
55 return IN_SET(link->network->dhcp, DHCP_SUPPORT_V4, DHCP_SUPPORT_BOTH);
58 static bool link_dhcp4_server_enabled(Link *link) {
59 if (link->flags & IFF_LOOPBACK)
65 return link->network->dhcp_server;
68 static bool link_ipv4ll_enabled(Link *link) {
69 if (link->flags & IFF_LOOPBACK)
75 return link->network->ipv4ll;
78 #define FLAG_STRING(string, flag, old, new) \
79 (((old ^ new) & flag) \
80 ? ((old & flag) ? (" -" string) : (" +" string)) \
83 static int link_update_flags(Link *link, sd_rtnl_message *m) {
84 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
90 r = sd_rtnl_message_link_get_flags(m, &flags);
92 log_link_warning(link, "Could not get link flags");
96 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
98 /* if we got a message without operstate, take it to mean
99 the state was unchanged */
100 operstate = link->kernel_operstate;
102 if ((link->flags == flags) && (link->kernel_operstate == operstate))
105 if (link->flags != flags) {
106 log_link_debug(link, "flags change:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
107 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
108 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
109 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
110 FLAG_STRING("UP", IFF_UP, link->flags, flags),
111 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
112 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
113 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
114 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
115 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
116 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
117 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
118 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
119 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
120 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
121 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
122 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
123 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
124 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
125 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
127 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
128 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
129 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
130 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
131 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
132 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
133 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
134 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
136 /* link flags are currently at most 18 bits, let's align to
138 if (unknown_flags_added)
140 "unknown link flags gained: %#.5x (ignoring)",
141 unknown_flags_added);
143 if (unknown_flags_removed)
145 "unknown link flags lost: %#.5x (ignoring)",
146 unknown_flags_removed);
150 link->kernel_operstate = operstate;
157 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
158 _cleanup_link_unref_ Link *link = NULL;
167 r = sd_rtnl_message_get_type(message, &type);
170 else if (type != RTM_NEWLINK)
173 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
176 else if (ifindex <= 0)
179 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
183 link = new0(Link, 1);
188 link->manager = manager;
189 link->state = LINK_STATE_PENDING;
190 link->ifindex = ifindex;
191 link->ifname = strdup(ifname);
195 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
197 log_link_debug(link, "MAC address not found for new device, continuing without");
199 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
204 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
209 r = hashmap_ensure_allocated(&manager->links, NULL);
213 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
217 r = link_update_flags(link, message);
227 static void link_free(Link *link) {
233 while ((address = link->addresses)) {
234 LIST_REMOVE(addresses, link->addresses, address);
235 address_free(address);
238 while ((address = link->pool_addresses)) {
239 LIST_REMOVE(addresses, link->pool_addresses, address);
240 address_free(address);
243 sd_dhcp_client_unref(link->dhcp_client);
244 sd_dhcp_lease_unref(link->dhcp_lease);
246 unlink(link->lease_file);
247 free(link->lease_file);
249 sd_ipv4ll_unref(link->ipv4ll);
250 sd_dhcp6_client_unref(link->dhcp6_client);
251 sd_icmp6_nd_unref(link->icmp6_router_discovery);
254 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
258 unlink(link->state_file);
259 free(link->state_file);
261 udev_device_unref(link->udev_device);
266 Link *link_unref(Link *link) {
267 if (link && (-- link->n_ref <= 0))
273 Link *link_ref(Link *link) {
275 assert_se(++ link->n_ref >= 2);
280 int link_get(Manager *m, int ifindex, Link **ret) {
287 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
296 void link_drop(Link *link) {
297 if (!link || link->state == LINK_STATE_LINGER)
300 link->state = LINK_STATE_LINGER;
302 log_link_debug(link, "link removed");
309 static void link_enter_unmanaged(Link *link) {
312 log_link_debug(link, "unmanaged");
314 link->state = LINK_STATE_UNMANAGED;
319 static int link_stop_clients(Link *link) {
323 assert(link->manager);
324 assert(link->manager->event);
329 if (link->dhcp_client) {
330 k = sd_dhcp_client_stop(link->dhcp_client);
332 log_link_warning(link, "Could not stop DHCPv4 client: %s",
339 k = sd_ipv4ll_stop(link->ipv4ll);
341 log_link_warning(link, "Could not stop IPv4 link-local: %s",
347 if(link->icmp6_router_discovery) {
349 if (link->dhcp6_client) {
350 k = sd_dhcp6_client_stop(link->dhcp6_client);
352 log_link_warning(link, "Could not stop DHCPv6 client: %s",
358 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
360 log_link_warning(link,
361 "Could not stop ICMPv6 router discovery: %s",
370 void link_enter_failed(Link *link) {
373 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
376 log_link_warning(link, "failed");
378 link->state = LINK_STATE_FAILED;
380 link_stop_clients(link);
385 static Address* link_find_dhcp_server_address(Link *link) {
389 assert(link->network);
391 /* The the first statically configured address if there is any */
392 LIST_FOREACH(addresses, address, link->network->static_addresses) {
394 if (address->family != AF_INET)
397 if (in_addr_is_null(address->family, &address->in_addr))
403 /* If that didn't work, find a suitable address we got from the pool */
404 LIST_FOREACH(addresses, address, link->pool_addresses) {
405 if (address->family != AF_INET)
414 static int link_enter_configured(Link *link) {
418 assert(link->network);
419 assert(link->state == LINK_STATE_SETTING_ROUTES);
421 if (link_dhcp4_server_enabled(link) &&
422 !sd_dhcp_server_is_running(link->dhcp_server)) {
423 struct in_addr pool_start;
426 address = link_find_dhcp_server_address(link);
428 log_link_warning(link,
429 "Failed to find suitable address for DHCPv4 server instance.");
430 link_enter_failed(link);
434 log_link_debug(link, "offering DHCPv4 leases");
436 r = sd_dhcp_server_set_address(link->dhcp_server,
437 &address->in_addr.in,
442 /* offer 32 addresses starting from the address following the server address */
443 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
444 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
450 r = sd_dhcp_server_set_router(link->dhcp_server,
451 &main_address->in_addr.in);
455 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
456 main_address->prefixlen);
461 r = sd_dhcp_server_start(link->dhcp_server);
463 log_link_warning(link, "could not start DHCPv4 server "
464 "instance: %s", strerror(-r));
466 link_enter_failed(link);
472 log_link_info(link, "link configured");
474 link->state = LINK_STATE_CONFIGURED;
481 void link_client_handler(Link *link) {
483 assert(link->network);
485 if (!link->static_configured)
488 if (link_ipv4ll_enabled(link))
489 if (!link->ipv4ll_address ||
493 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
496 if (link->state != LINK_STATE_CONFIGURED)
497 link_enter_configured(link);
502 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
503 _cleanup_link_unref_ Link *link = userdata;
506 assert(link->link_messages > 0);
507 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
508 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
511 link->link_messages --;
513 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
516 r = sd_rtnl_message_get_errno(m);
517 if (r < 0 && r != -EEXIST)
518 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
520 if (link->link_messages == 0) {
521 log_link_debug(link, "routes set");
522 link->static_configured = true;
523 link_client_handler(link);
529 static int link_enter_set_routes(Link *link) {
534 assert(link->network);
535 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
537 link->state = LINK_STATE_SETTING_ROUTES;
539 LIST_FOREACH(routes, rt, link->network->static_routes) {
540 r = route_configure(rt, link, &route_handler);
542 log_link_warning(link,
543 "could not set routes: %s",
545 link_enter_failed(link);
549 link->link_messages ++;
552 if (link->link_messages == 0) {
553 link->static_configured = true;
554 link_client_handler(link);
556 log_link_debug(link, "setting routes");
561 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
562 _cleanup_link_unref_ Link *link = userdata;
567 assert(link->ifname);
569 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
572 r = sd_rtnl_message_get_errno(m);
573 if (r < 0 && r != -ESRCH)
574 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
579 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
580 _cleanup_link_unref_ Link *link = userdata;
586 assert(link->ifname);
587 assert(link->link_messages > 0);
588 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
589 LINK_STATE_FAILED, LINK_STATE_LINGER));
591 link->link_messages --;
593 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
596 r = sd_rtnl_message_get_errno(m);
597 if (r < 0 && r != -EEXIST)
598 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
600 link_rtnl_process_address(rtnl, m, link->manager);
602 if (link->link_messages == 0) {
603 log_link_debug(link, "addresses set");
604 link_enter_set_routes(link);
610 static int link_enter_set_addresses(Link *link) {
615 assert(link->network);
616 assert(link->state != _LINK_STATE_INVALID);
618 link->state = LINK_STATE_SETTING_ADDRESSES;
620 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
621 r = address_configure(ad, link, &address_handler);
623 log_link_warning(link,
624 "could not set addresses: %s",
626 link_enter_failed(link);
630 link->link_messages ++;
633 if (link->link_messages == 0) {
634 link_enter_set_routes(link);
636 log_link_debug(link, "setting addresses");
641 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
642 _cleanup_link_unref_ Link *link = userdata;
647 assert(link->ifname);
649 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
652 r = sd_rtnl_message_get_errno(m);
653 if (r < 0 && r != -EADDRNOTAVAIL)
654 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
659 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
660 _cleanup_link_unref_ Link *link = userdata;
663 log_link_debug(link, "set link");
665 r = sd_rtnl_message_get_errno(m);
666 if (r < 0 && r != -EEXIST) {
667 log_link_struct(link, LOG_ERR,
668 "MESSAGE=%-*s: could not join netdev: %s",
670 link->ifname, strerror(-r),
673 link_enter_failed(link);
680 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
681 sd_bus_error *ret_error) {
682 _cleanup_link_unref_ Link *link = userdata;
687 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
690 r = sd_bus_message_get_errno(m);
692 log_link_warning(link, "Could not set hostname: %s",
698 int link_set_hostname(Link *link, const char *hostname) {
699 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
703 assert(link->manager);
706 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
708 if (!link->manager->bus) {
709 /* TODO: replace by assert when we can rely on kdbus */
711 "Not connected to system bus, ignoring transient hostname.");
715 r = sd_bus_message_new_method_call(
718 "org.freedesktop.hostname1",
719 "/org/freedesktop/hostname1",
720 "org.freedesktop.hostname1",
725 r = sd_bus_message_append(m, "sb", hostname, false);
729 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
732 log_link_error(link, "Could not set transient hostname: %s",
742 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
743 _cleanup_link_unref_ Link *link = userdata;
748 assert(link->ifname);
750 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
753 r = sd_rtnl_message_get_errno(m);
755 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
760 int link_set_mtu(Link *link, uint32_t mtu) {
761 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
765 assert(link->manager);
766 assert(link->manager->rtnl);
768 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
770 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
771 RTM_SETLINK, link->ifindex);
773 log_link_error(link, "Could not allocate RTM_SETLINK message");
777 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
779 log_link_error(link, "Could not append MTU: %s", strerror(-r));
783 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
787 "Could not send rtnetlink message: %s",
797 static int link_set_bridge(Link *link) {
798 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
802 assert(link->network);
804 if(link->network->cost == 0)
807 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
808 RTM_SETLINK, link->ifindex);
810 log_link_error(link, "Could not allocate RTM_SETLINK message");
814 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
817 "Could not set message family %s", strerror(-r));
821 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
824 "Could not append IFLA_PROTINFO attribute: %s",
829 if(link->network->cost != 0) {
830 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
833 "Could not append IFLA_BRPORT_COST attribute: %s",
839 r = sd_rtnl_message_close_container(req);
842 "Could not append IFLA_LINKINFO attribute: %s",
847 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
850 "Could not send rtnetlink message: %s",
860 static int link_acquire_conf(Link *link) {
864 assert(link->network);
865 assert(link->manager);
866 assert(link->manager->event);
868 if (link_ipv4ll_enabled(link)) {
869 assert(link->ipv4ll);
871 log_link_debug(link, "acquiring IPv4 link-local address");
873 r = sd_ipv4ll_start(link->ipv4ll);
875 log_link_warning(link, "could not acquire IPv4 "
876 "link-local address");
881 if (link_dhcp4_enabled(link)) {
882 assert(link->dhcp_client);
884 log_link_debug(link, "acquiring DHCPv4 lease");
886 r = sd_dhcp_client_start(link->dhcp_client);
888 log_link_warning(link, "could not acquire DHCPv4 "
894 if (link_dhcp6_enabled(link)) {
895 assert(link->icmp6_router_discovery);
897 log_link_debug(link, "discovering IPv6 routers");
899 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
901 log_link_warning(link,
902 "could not start IPv6 router discovery");
910 bool link_has_carrier(Link *link) {
911 /* see Documentation/networking/operstates.txt in the kernel sources */
913 if (link->kernel_operstate == IF_OPER_UP)
916 if (link->kernel_operstate == IF_OPER_UNKNOWN)
917 /* operstate may not be implemented, so fall back to flags */
918 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
924 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
925 _cleanup_link_unref_ Link *link = userdata;
930 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
933 r = sd_rtnl_message_get_errno(m);
935 /* we warn but don't fail the link, as it may
936 be brought up later */
937 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
943 static int link_up(Link *link) {
944 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
948 assert(link->network);
949 assert(link->manager);
950 assert(link->manager->rtnl);
952 log_link_debug(link, "bringing link up");
954 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
955 RTM_SETLINK, link->ifindex);
957 log_link_error(link, "Could not allocate RTM_SETLINK message");
961 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
963 log_link_error(link, "Could not set link flags: %s",
968 if (link->network->mac) {
969 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
971 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
976 if (link->network->mtu) {
977 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
979 log_link_error(link, "Could not set MTU: %s", strerror(-r));
984 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
988 "Could not send rtnetlink message: %s",
998 static int link_joined(Link *link) {
1002 assert(link->network);
1004 if (!(link->flags & IFF_UP)) {
1007 link_enter_failed(link);
1012 if(link->network->bridge) {
1013 r = link_set_bridge(link);
1015 log_link_error(link,
1016 "Could not set bridge message: %s",
1021 return link_enter_set_addresses(link);
1024 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1026 _cleanup_link_unref_ Link *link = userdata;
1030 assert(link->network);
1034 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1037 r = sd_rtnl_message_get_errno(m);
1038 if (r < 0 && r != -EEXIST) {
1039 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1040 link_enter_failed(link);
1043 log_link_debug(link, "joined netdev");
1045 if (link->enslaving <= 0)
1051 static int link_enter_join_netdev(Link *link) {
1057 assert(link->network);
1058 assert(link->state == LINK_STATE_PENDING);
1060 link->state = LINK_STATE_ENSLAVING;
1064 if (!link->network->bridge &&
1065 !link->network->bond &&
1066 hashmap_isempty(link->network->stacked_netdevs))
1067 return link_joined(link);
1069 if (link->network->bond) {
1070 log_link_struct(link, LOG_DEBUG,
1071 "MESSAGE=%-*s: enslaving by '%s'",
1073 link->ifname, link->network->bond->ifname,
1074 NETDEVIF(link->network->bond),
1077 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1079 log_link_struct(link, LOG_WARNING,
1080 "MESSAGE=%-*s: could not join netdev '%s': %s",
1082 link->ifname, link->network->bond->ifname,
1084 NETDEVIF(link->network->bond),
1086 link_enter_failed(link);
1093 if (link->network->bridge) {
1094 log_link_struct(link, LOG_DEBUG,
1095 "MESSAGE=%-*s: enslaving by '%s'",
1097 link->ifname, link->network->bridge->ifname,
1098 NETDEVIF(link->network->bridge),
1101 r = netdev_join(link->network->bridge, link,
1102 &netdev_join_handler);
1104 log_link_struct(link, LOG_WARNING,
1105 "MESSAGE=%-*s: could not join netdev '%s': %s",
1107 link->ifname, link->network->bridge->ifname,
1109 NETDEVIF(link->network->bridge),
1111 link_enter_failed(link);
1118 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1119 log_link_struct(link, LOG_DEBUG,
1120 "MESSAGE=%-*s: enslaving by '%s'",
1122 link->ifname, netdev->ifname, NETDEVIF(netdev),
1125 r = netdev_join(netdev, link, &netdev_join_handler);
1127 log_link_struct(link, LOG_WARNING,
1128 "MESSAGE=%-*s: could not join netdev '%s': %s",
1130 link->ifname, netdev->ifname,
1132 NETDEVIF(netdev), NULL);
1133 link_enter_failed(link);
1143 static int link_configure(Link *link) {
1147 assert(link->network);
1148 assert(link->state == LINK_STATE_PENDING);
1150 if (link_ipv4ll_enabled(link)) {
1151 r = ipv4ll_configure(link);
1156 if (link_dhcp4_enabled(link)) {
1157 r = dhcp4_configure(link);
1162 if (link_dhcp4_server_enabled(link)) {
1163 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1167 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1172 if (link_dhcp6_enabled(link)) {
1173 r = icmp6_configure(link);
1178 if (link_has_carrier(link)) {
1179 r = link_acquire_conf(link);
1184 return link_enter_join_netdev(link);
1187 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1189 _cleanup_link_unref_ Link *link = userdata;
1194 assert(link->ifname);
1195 assert(link->manager);
1197 if (link->state != LINK_STATE_PENDING)
1200 log_link_debug(link, "link state is up-to-date");
1202 r = network_get(link->manager, link->udev_device, link->ifname,
1203 &link->mac, &network);
1205 link_enter_unmanaged(link);
1210 if (link->flags & IFF_LOOPBACK) {
1211 if (network->ipv4ll)
1212 log_link_debug(link, "ignoring IPv4LL for loopback link");
1214 if (network->dhcp != DHCP_SUPPORT_NONE)
1215 log_link_debug(link, "ignoring DHCP clients for loopback link");
1217 if (network->dhcp_server)
1218 log_link_debug(link, "ignoring DHCP server for loopback link");
1221 r = network_apply(link->manager, network, link);
1225 r = link_configure(link);
1232 int link_initialized(Link *link, struct udev_device *device) {
1233 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1237 assert(link->manager);
1238 assert(link->manager->rtnl);
1241 if (link->state != LINK_STATE_PENDING)
1244 if (link->udev_device)
1247 log_link_debug(link, "udev initialized link");
1249 link->udev_device = udev_device_ref(device);
1251 /* udev has initialized the link, but we don't know if we have yet
1252 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1253 * when it returns we know that the pending NEWLINKs have already been
1254 * processed and that we are up-to-date */
1256 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1261 r = sd_rtnl_call_async(link->manager->rtnl, req,
1262 link_initialized_and_synced, link, 0, NULL);
1271 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1272 Manager *m = userdata;
1275 _cleanup_address_free_ Address *address = NULL;
1277 char buf[INET6_ADDRSTRLEN];
1278 char valid_buf[FORMAT_TIMESPAN_MAX];
1279 const char *valid_str = NULL;
1280 bool address_dropped = false;
1287 if (sd_rtnl_message_is_error(message)) {
1288 r = sd_rtnl_message_get_errno(message);
1290 log_warning_errno(r, "rtnl: failed to receive address: %m");
1295 r = sd_rtnl_message_get_type(message, &type);
1297 log_warning("rtnl: could not get message type");
1301 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1303 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1305 } else if (ifindex <= 0) {
1306 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1309 r = link_get(m, ifindex, &link);
1310 if (r < 0 || !link) {
1311 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1316 r = address_new_dynamic(&address);
1320 r = sd_rtnl_message_addr_get_family(message, &address->family);
1321 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1322 log_link_warning(link,
1323 "rtnl: received address with invalid family, ignoring");
1327 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1329 log_link_warning(link,
1330 "rtnl: received address with invalid prefixlen, ignoring");
1334 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1336 log_link_warning(link,
1337 "rtnl: received address with invalid scope, ignoring");
1341 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1343 log_link_warning(link,
1344 "rtnl: received address with invalid flags, ignoring");
1348 switch (address->family) {
1350 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
1351 &address->in_addr.in);
1353 log_link_warning(link,
1354 "rtnl: received address without valid address, ignoring");
1361 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
1362 &address->in_addr.in6);
1364 log_link_warning(link,
1365 "rtnl: received address without valid address, ignoring");
1372 assert_not_reached("invalid address family");
1375 if (!inet_ntop(address->family, &address->in_addr, buf,
1376 INET6_ADDRSTRLEN)) {
1377 log_link_warning(link, "could not print address");
1381 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO,
1384 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1387 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1388 address->cinfo.ifa_valid * USEC_PER_SEC,
1392 LIST_FOREACH(addresses, ad, link->addresses) {
1393 if (address_equal(ad, address)) {
1394 LIST_REMOVE(addresses, link->addresses, ad);
1398 address_dropped = true;
1406 if (!address_dropped)
1407 log_link_debug(link, "added address: %s/%u (valid for %s)",
1408 buf, address->prefixlen, valid_str);
1410 log_link_debug(link, "updated address: %s/%u (valid for %s)",
1411 buf, address->prefixlen, valid_str);
1413 LIST_PREPEND(addresses, link->addresses, address);
1420 if (address_dropped) {
1421 log_link_debug(link, "removed address: %s/%u (valid for %s)",
1422 buf, address->prefixlen, valid_str);
1426 log_link_warning(link,
1427 "removing non-existent address: %s/%u (valid for %s)",
1428 buf, address->prefixlen, valid_str);
1432 assert_not_reached("Received invalid RTNL message type");
1438 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1440 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1441 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1449 r = link_new(m, message, ret);
1455 log_link_debug(link, "link %d added", link->ifindex);
1457 if (detect_container(NULL) <= 0) {
1458 /* not in a container, udev will be around */
1459 sprintf(ifindex_str, "n%d", link->ifindex);
1460 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1462 log_link_warning(link,
1463 "could not find udev device: %m");
1467 if (udev_device_get_is_initialized(device) <= 0) {
1469 log_link_debug(link, "link pending udev initialization...");
1473 r = link_initialized(link, device);
1477 /* we are calling a callback directly, so must take a ref */
1480 r = link_initialized_and_synced(m->rtnl, NULL, link);
1488 int link_update(Link *link, sd_rtnl_message *m) {
1489 struct ether_addr mac;
1492 bool had_carrier, carrier_gained, carrier_lost;
1496 assert(link->ifname);
1499 if (link->state == LINK_STATE_LINGER) {
1501 log_link_info(link, "link readded");
1502 link->state = LINK_STATE_ENSLAVING;
1505 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1506 if (r >= 0 && !streq(ifname, link->ifname)) {
1507 log_link_info(link, "renamed to %s", ifname);
1510 link->ifname = strdup(ifname);
1515 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1516 if (r >= 0 && mtu > 0) {
1518 if (!link->original_mtu) {
1519 link->original_mtu = mtu;
1520 log_link_debug(link, "saved original MTU: %"
1521 PRIu32, link->original_mtu);
1524 if (link->dhcp_client) {
1525 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1528 log_link_warning(link,
1529 "Could not update MTU in DHCP client: %s",
1536 /* The kernel may broadcast NEWLINK messages without the MAC address
1537 set, simply ignore them. */
1538 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1540 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1543 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1546 log_link_debug(link, "MAC address: "
1547 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1548 mac.ether_addr_octet[0],
1549 mac.ether_addr_octet[1],
1550 mac.ether_addr_octet[2],
1551 mac.ether_addr_octet[3],
1552 mac.ether_addr_octet[4],
1553 mac.ether_addr_octet[5]);
1556 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1558 log_link_warning(link,
1559 "Could not update MAC address in IPv4LL client: %s",
1565 if (link->dhcp_client) {
1566 r = sd_dhcp_client_set_mac(link->dhcp_client,
1567 (const uint8_t *) &link->mac,
1571 log_link_warning(link,
1572 "Could not update MAC address in DHCP client: %s",
1578 if (link->dhcp6_client) {
1579 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1580 (const uint8_t *) &link->mac,
1584 log_link_warning(link,
1585 "Could not update MAC address in DHCPv6 client: %s",
1593 had_carrier = link_has_carrier(link);
1595 r = link_update_flags(link, m);
1599 carrier_gained = !had_carrier && link_has_carrier(link);
1600 carrier_lost = had_carrier && !link_has_carrier(link);
1602 if (carrier_gained) {
1603 log_link_info(link, "gained carrier");
1605 if (link->network) {
1606 r = link_acquire_conf(link);
1608 link_enter_failed(link);
1612 } else if (carrier_lost) {
1613 log_link_info(link, "lost carrier");
1615 r = link_stop_clients(link);
1617 link_enter_failed(link);
1625 static void link_update_operstate(Link *link) {
1629 if (link->kernel_operstate == IF_OPER_DORMANT)
1630 link->operstate = LINK_OPERSTATE_DORMANT;
1631 else if (link_has_carrier(link)) {
1633 uint8_t scope = RT_SCOPE_NOWHERE;
1635 /* if we have carrier, check what addresses we have */
1636 LIST_FOREACH(addresses, address, link->addresses) {
1637 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1640 if (address->scope < scope)
1641 scope = address->scope;
1644 if (scope < RT_SCOPE_SITE)
1645 /* universally accessible addresses found */
1646 link->operstate = LINK_OPERSTATE_ROUTABLE;
1647 else if (scope < RT_SCOPE_HOST)
1648 /* only link or site local addresses found */
1649 link->operstate = LINK_OPERSTATE_DEGRADED;
1651 /* no useful addresses found */
1652 link->operstate = LINK_OPERSTATE_CARRIER;
1653 } else if (link->flags & IFF_UP)
1654 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1656 link->operstate = LINK_OPERSTATE_OFF;
1659 int link_save(Link *link) {
1660 _cleanup_free_ char *temp_path = NULL;
1661 _cleanup_fclose_ FILE *f = NULL;
1662 const char *admin_state, *oper_state;
1666 assert(link->state_file);
1667 assert(link->lease_file);
1668 assert(link->manager);
1670 link_update_operstate(link);
1672 r = manager_save(link->manager);
1676 if (link->state == LINK_STATE_LINGER) {
1677 unlink(link->state_file);
1681 admin_state = link_state_to_string(link->state);
1682 assert(admin_state);
1684 oper_state = link_operstate_to_string(link->operstate);
1687 r = fopen_temporary(link->state_file, &f, &temp_path);
1691 fchmod(fileno(f), 0644);
1694 "# This is private data. Do not parse.\n"
1697 admin_state, oper_state);
1699 if (link->network) {
1700 char **address, **domain;
1703 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1707 STRV_FOREACH(address, link->network->dns) {
1714 if (link->network->dhcp_dns &&
1716 const struct in_addr *addresses;
1718 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1722 serialize_in_addrs(f, addresses, r);
1730 STRV_FOREACH(address, link->network->ntp) {
1737 if (link->network->dhcp_ntp &&
1739 const struct in_addr *addresses;
1741 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1745 serialize_in_addrs(f, addresses, r);
1751 fprintf(f, "DOMAINS=");
1753 STRV_FOREACH(domain, link->network->domains) {
1760 if (link->network->dhcp_domains &&
1762 const char *domainname;
1764 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1768 fputs(domainname, f);
1774 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1775 yes_no(link->network->wildcard_domain));
1777 fprintf(f, "LLMNR=%s\n",
1778 llmnr_support_to_string(link->network->llmnr));
1781 if (link->dhcp_lease) {
1782 assert(link->network);
1784 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1792 unlink(link->lease_file);
1794 r = fflush_and_check(f);
1798 if (rename(temp_path, link->state_file) < 0) {
1805 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1806 unlink(link->state_file);
1811 static const char* const link_state_table[_LINK_STATE_MAX] = {
1812 [LINK_STATE_PENDING] = "pending",
1813 [LINK_STATE_ENSLAVING] = "configuring",
1814 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1815 [LINK_STATE_SETTING_ROUTES] = "configuring",
1816 [LINK_STATE_CONFIGURED] = "configured",
1817 [LINK_STATE_UNMANAGED] = "unmanaged",
1818 [LINK_STATE_FAILED] = "failed",
1819 [LINK_STATE_LINGER] = "linger",
1822 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1824 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1825 [LINK_OPERSTATE_OFF] = "off",
1826 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1827 [LINK_OPERSTATE_DORMANT] = "dormant",
1828 [LINK_OPERSTATE_CARRIER] = "carrier",
1829 [LINK_OPERSTATE_DEGRADED] = "degraded",
1830 [LINK_OPERSTATE_ROUTABLE] = "routable",
1833 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);