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_bridge_fdb(const Link *const link) {
663 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
664 r = fdb_entry_configure(link->manager->rtnl, fdb_entry, link->ifindex);
666 log_link_error(link, "Failed to add MAC entry to static MAC table: %s", strerror(-r));
674 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
675 _cleanup_link_unref_ Link *link = userdata;
678 log_link_debug(link, "set link");
680 r = sd_rtnl_message_get_errno(m);
681 if (r < 0 && r != -EEXIST) {
682 log_link_struct(link, LOG_ERR,
683 "MESSAGE=%-*s: could not join netdev: %s",
685 link->ifname, strerror(-r),
688 link_enter_failed(link);
695 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
696 sd_bus_error *ret_error) {
697 _cleanup_link_unref_ Link *link = userdata;
702 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
705 r = sd_bus_message_get_errno(m);
707 log_link_warning(link, "Could not set hostname: %s",
713 int link_set_hostname(Link *link, const char *hostname) {
714 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
718 assert(link->manager);
721 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
723 if (!link->manager->bus) {
724 /* TODO: replace by assert when we can rely on kdbus */
726 "Not connected to system bus, ignoring transient hostname.");
730 r = sd_bus_message_new_method_call(
733 "org.freedesktop.hostname1",
734 "/org/freedesktop/hostname1",
735 "org.freedesktop.hostname1",
740 r = sd_bus_message_append(m, "sb", hostname, false);
744 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
747 log_link_error(link, "Could not set transient hostname: %s",
757 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
758 _cleanup_link_unref_ Link *link = userdata;
763 assert(link->ifname);
765 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
768 r = sd_rtnl_message_get_errno(m);
770 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
775 int link_set_mtu(Link *link, uint32_t mtu) {
776 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
780 assert(link->manager);
781 assert(link->manager->rtnl);
783 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
785 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
786 RTM_SETLINK, link->ifindex);
788 log_link_error(link, "Could not allocate RTM_SETLINK message");
792 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
794 log_link_error(link, "Could not append MTU: %s", strerror(-r));
798 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
802 "Could not send rtnetlink message: %s",
812 static int link_set_bridge(Link *link) {
813 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
817 assert(link->network);
819 if(link->network->cost == 0)
822 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
823 RTM_SETLINK, link->ifindex);
825 log_link_error(link, "Could not allocate RTM_SETLINK message");
829 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
832 "Could not set message family %s", strerror(-r));
836 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
839 "Could not append IFLA_PROTINFO attribute: %s",
844 if(link->network->cost != 0) {
845 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
848 "Could not append IFLA_BRPORT_COST attribute: %s",
854 r = sd_rtnl_message_close_container(req);
857 "Could not append IFLA_LINKINFO attribute: %s",
862 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
865 "Could not send rtnetlink message: %s",
875 static int link_acquire_conf(Link *link) {
879 assert(link->network);
880 assert(link->manager);
881 assert(link->manager->event);
883 if (link_ipv4ll_enabled(link)) {
884 assert(link->ipv4ll);
886 log_link_debug(link, "acquiring IPv4 link-local address");
888 r = sd_ipv4ll_start(link->ipv4ll);
890 log_link_warning(link, "could not acquire IPv4 "
891 "link-local address");
896 if (link_dhcp4_enabled(link)) {
897 assert(link->dhcp_client);
899 log_link_debug(link, "acquiring DHCPv4 lease");
901 r = sd_dhcp_client_start(link->dhcp_client);
903 log_link_warning(link, "could not acquire DHCPv4 "
909 if (link_dhcp6_enabled(link)) {
910 assert(link->icmp6_router_discovery);
912 log_link_debug(link, "discovering IPv6 routers");
914 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
916 log_link_warning(link,
917 "could not start IPv6 router discovery");
925 bool link_has_carrier(Link *link) {
926 /* see Documentation/networking/operstates.txt in the kernel sources */
928 if (link->kernel_operstate == IF_OPER_UP)
931 if (link->kernel_operstate == IF_OPER_UNKNOWN)
932 /* operstate may not be implemented, so fall back to flags */
933 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
939 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
940 _cleanup_link_unref_ Link *link = userdata;
945 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
948 r = sd_rtnl_message_get_errno(m);
950 /* we warn but don't fail the link, as it may
951 be brought up later */
952 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
958 static int link_up(Link *link) {
959 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
963 assert(link->network);
964 assert(link->manager);
965 assert(link->manager->rtnl);
967 log_link_debug(link, "bringing link up");
969 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
970 RTM_SETLINK, link->ifindex);
972 log_link_error(link, "Could not allocate RTM_SETLINK message");
976 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
978 log_link_error(link, "Could not set link flags: %s",
983 if (link->network->mac) {
984 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
986 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
991 if (link->network->mtu) {
992 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
994 log_link_error(link, "Could not set MTU: %s", strerror(-r));
999 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1002 log_link_error(link,
1003 "Could not send rtnetlink message: %s",
1013 static int link_joined(Link *link) {
1017 assert(link->network);
1019 if (!(link->flags & IFF_UP)) {
1022 link_enter_failed(link);
1027 if(link->network->bridge) {
1028 r = link_set_bridge(link);
1030 log_link_error(link,
1031 "Could not set bridge message: %s",
1036 return link_enter_set_addresses(link);
1039 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1041 _cleanup_link_unref_ Link *link = userdata;
1045 assert(link->network);
1049 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1052 r = sd_rtnl_message_get_errno(m);
1053 if (r < 0 && r != -EEXIST) {
1054 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1055 link_enter_failed(link);
1058 log_link_debug(link, "joined netdev");
1060 if (link->enslaving <= 0)
1066 static int link_enter_join_netdev(Link *link) {
1072 assert(link->network);
1073 assert(link->state == LINK_STATE_PENDING);
1075 link->state = LINK_STATE_ENSLAVING;
1079 if (!link->network->bridge &&
1080 !link->network->bond &&
1081 hashmap_isempty(link->network->stacked_netdevs))
1082 return link_joined(link);
1084 if (link->network->bond) {
1085 log_link_struct(link, LOG_DEBUG,
1086 "MESSAGE=%-*s: enslaving by '%s'",
1088 link->ifname, link->network->bond->ifname,
1089 NETDEVIF(link->network->bond),
1092 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1094 log_link_struct(link, LOG_WARNING,
1095 "MESSAGE=%-*s: could not join netdev '%s': %s",
1097 link->ifname, link->network->bond->ifname,
1099 NETDEVIF(link->network->bond),
1101 link_enter_failed(link);
1108 if (link->network->bridge) {
1109 log_link_struct(link, LOG_DEBUG,
1110 "MESSAGE=%-*s: enslaving by '%s'",
1112 link->ifname, link->network->bridge->ifname,
1113 NETDEVIF(link->network->bridge),
1116 r = netdev_join(link->network->bridge, link,
1117 &netdev_join_handler);
1119 log_link_struct(link, LOG_WARNING,
1120 "MESSAGE=%-*s: could not join netdev '%s': %s",
1122 link->ifname, link->network->bridge->ifname,
1124 NETDEVIF(link->network->bridge),
1126 link_enter_failed(link);
1133 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1134 log_link_struct(link, LOG_DEBUG,
1135 "MESSAGE=%-*s: enslaving by '%s'",
1137 link->ifname, netdev->ifname, NETDEVIF(netdev),
1140 r = netdev_join(netdev, link, &netdev_join_handler);
1142 log_link_struct(link, LOG_WARNING,
1143 "MESSAGE=%-*s: could not join netdev '%s': %s",
1145 link->ifname, netdev->ifname,
1147 NETDEVIF(netdev), NULL);
1148 link_enter_failed(link);
1158 static int link_configure(Link *link) {
1162 assert(link->network);
1163 assert(link->state == LINK_STATE_PENDING);
1165 r = link_set_bridge_fdb(link);
1169 if (link_ipv4ll_enabled(link)) {
1170 r = ipv4ll_configure(link);
1175 if (link_dhcp4_enabled(link)) {
1176 r = dhcp4_configure(link);
1181 if (link_dhcp4_server_enabled(link)) {
1182 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1186 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1191 if (link_dhcp6_enabled(link)) {
1192 r = icmp6_configure(link);
1197 if (link_has_carrier(link)) {
1198 r = link_acquire_conf(link);
1203 return link_enter_join_netdev(link);
1206 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1208 _cleanup_link_unref_ Link *link = userdata;
1213 assert(link->ifname);
1214 assert(link->manager);
1216 if (link->state != LINK_STATE_PENDING)
1219 log_link_debug(link, "link state is up-to-date");
1221 r = network_get(link->manager, link->udev_device, link->ifname,
1222 &link->mac, &network);
1224 link_enter_unmanaged(link);
1229 if (link->flags & IFF_LOOPBACK) {
1230 if (network->ipv4ll)
1231 log_link_debug(link, "ignoring IPv4LL for loopback link");
1233 if (network->dhcp != DHCP_SUPPORT_NONE)
1234 log_link_debug(link, "ignoring DHCP clients for loopback link");
1236 if (network->dhcp_server)
1237 log_link_debug(link, "ignoring DHCP server for loopback link");
1240 r = network_apply(link->manager, network, link);
1244 r = link_configure(link);
1251 int link_initialized(Link *link, struct udev_device *device) {
1252 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1256 assert(link->manager);
1257 assert(link->manager->rtnl);
1260 if (link->state != LINK_STATE_PENDING)
1263 if (link->udev_device)
1266 log_link_debug(link, "udev initialized link");
1268 link->udev_device = udev_device_ref(device);
1270 /* udev has initialized the link, but we don't know if we have yet
1271 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1272 * when it returns we know that the pending NEWLINKs have already been
1273 * processed and that we are up-to-date */
1275 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1280 r = sd_rtnl_call_async(link->manager->rtnl, req,
1281 link_initialized_and_synced, link, 0, NULL);
1290 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1291 Manager *m = userdata;
1294 _cleanup_address_free_ Address *address = NULL;
1296 char buf[INET6_ADDRSTRLEN];
1297 char valid_buf[FORMAT_TIMESPAN_MAX];
1298 const char *valid_str = NULL;
1299 bool address_dropped = false;
1306 if (sd_rtnl_message_is_error(message)) {
1307 r = sd_rtnl_message_get_errno(message);
1309 log_warning_errno(r, "rtnl: failed to receive address: %m");
1314 r = sd_rtnl_message_get_type(message, &type);
1316 log_warning("rtnl: could not get message type");
1320 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1322 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1324 } else if (ifindex <= 0) {
1325 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1328 r = link_get(m, ifindex, &link);
1329 if (r < 0 || !link) {
1330 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1335 r = address_new_dynamic(&address);
1339 r = sd_rtnl_message_addr_get_family(message, &address->family);
1340 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1341 log_link_warning(link,
1342 "rtnl: received address with invalid family, ignoring");
1346 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1348 log_link_warning(link,
1349 "rtnl: received address with invalid prefixlen, ignoring");
1353 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1355 log_link_warning(link,
1356 "rtnl: received address with invalid scope, ignoring");
1360 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1362 log_link_warning(link,
1363 "rtnl: received address with invalid flags, ignoring");
1367 switch (address->family) {
1369 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
1370 &address->in_addr.in);
1372 log_link_warning(link,
1373 "rtnl: received address without valid address, ignoring");
1380 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
1381 &address->in_addr.in6);
1383 log_link_warning(link,
1384 "rtnl: received address without valid address, ignoring");
1391 assert_not_reached("invalid address family");
1394 if (!inet_ntop(address->family, &address->in_addr, buf,
1395 INET6_ADDRSTRLEN)) {
1396 log_link_warning(link, "could not print address");
1400 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO,
1403 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1406 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1407 address->cinfo.ifa_valid * USEC_PER_SEC,
1411 LIST_FOREACH(addresses, ad, link->addresses) {
1412 if (address_equal(ad, address)) {
1413 LIST_REMOVE(addresses, link->addresses, ad);
1417 address_dropped = true;
1425 if (!address_dropped)
1426 log_link_debug(link, "added address: %s/%u (valid for %s)",
1427 buf, address->prefixlen, valid_str);
1429 log_link_debug(link, "updated address: %s/%u (valid for %s)",
1430 buf, address->prefixlen, valid_str);
1432 LIST_PREPEND(addresses, link->addresses, address);
1439 if (address_dropped) {
1440 log_link_debug(link, "removed address: %s/%u (valid for %s)",
1441 buf, address->prefixlen, valid_str);
1445 log_link_warning(link,
1446 "removing non-existent address: %s/%u (valid for %s)",
1447 buf, address->prefixlen, valid_str);
1451 assert_not_reached("Received invalid RTNL message type");
1457 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1459 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1460 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1468 r = link_new(m, message, ret);
1474 log_link_debug(link, "link %d added", link->ifindex);
1476 if (detect_container(NULL) <= 0) {
1477 /* not in a container, udev will be around */
1478 sprintf(ifindex_str, "n%d", link->ifindex);
1479 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1481 log_link_warning(link,
1482 "could not find udev device: %m");
1486 if (udev_device_get_is_initialized(device) <= 0) {
1488 log_link_debug(link, "link pending udev initialization...");
1492 r = link_initialized(link, device);
1496 /* we are calling a callback directly, so must take a ref */
1499 r = link_initialized_and_synced(m->rtnl, NULL, link);
1507 int link_update(Link *link, sd_rtnl_message *m) {
1508 struct ether_addr mac;
1511 bool had_carrier, carrier_gained, carrier_lost;
1515 assert(link->ifname);
1518 if (link->state == LINK_STATE_LINGER) {
1520 log_link_info(link, "link readded");
1521 link->state = LINK_STATE_ENSLAVING;
1524 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1525 if (r >= 0 && !streq(ifname, link->ifname)) {
1526 log_link_info(link, "renamed to %s", ifname);
1529 link->ifname = strdup(ifname);
1534 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1535 if (r >= 0 && mtu > 0) {
1537 if (!link->original_mtu) {
1538 link->original_mtu = mtu;
1539 log_link_debug(link, "saved original MTU: %"
1540 PRIu32, link->original_mtu);
1543 if (link->dhcp_client) {
1544 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1547 log_link_warning(link,
1548 "Could not update MTU in DHCP client: %s",
1555 /* The kernel may broadcast NEWLINK messages without the MAC address
1556 set, simply ignore them. */
1557 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1559 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1562 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1565 log_link_debug(link, "MAC address: "
1566 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1567 mac.ether_addr_octet[0],
1568 mac.ether_addr_octet[1],
1569 mac.ether_addr_octet[2],
1570 mac.ether_addr_octet[3],
1571 mac.ether_addr_octet[4],
1572 mac.ether_addr_octet[5]);
1575 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1577 log_link_warning(link,
1578 "Could not update MAC address in IPv4LL client: %s",
1584 if (link->dhcp_client) {
1585 r = sd_dhcp_client_set_mac(link->dhcp_client,
1586 (const uint8_t *) &link->mac,
1590 log_link_warning(link,
1591 "Could not update MAC address in DHCP client: %s",
1597 if (link->dhcp6_client) {
1598 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1599 (const uint8_t *) &link->mac,
1603 log_link_warning(link,
1604 "Could not update MAC address in DHCPv6 client: %s",
1612 had_carrier = link_has_carrier(link);
1614 r = link_update_flags(link, m);
1618 carrier_gained = !had_carrier && link_has_carrier(link);
1619 carrier_lost = had_carrier && !link_has_carrier(link);
1621 if (carrier_gained) {
1622 log_link_info(link, "gained carrier");
1624 if (link->network) {
1625 r = link_acquire_conf(link);
1627 link_enter_failed(link);
1631 } else if (carrier_lost) {
1632 log_link_info(link, "lost carrier");
1634 r = link_stop_clients(link);
1636 link_enter_failed(link);
1644 static void link_update_operstate(Link *link) {
1648 if (link->kernel_operstate == IF_OPER_DORMANT)
1649 link->operstate = LINK_OPERSTATE_DORMANT;
1650 else if (link_has_carrier(link)) {
1652 uint8_t scope = RT_SCOPE_NOWHERE;
1654 /* if we have carrier, check what addresses we have */
1655 LIST_FOREACH(addresses, address, link->addresses) {
1656 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1659 if (address->scope < scope)
1660 scope = address->scope;
1663 if (scope < RT_SCOPE_SITE)
1664 /* universally accessible addresses found */
1665 link->operstate = LINK_OPERSTATE_ROUTABLE;
1666 else if (scope < RT_SCOPE_HOST)
1667 /* only link or site local addresses found */
1668 link->operstate = LINK_OPERSTATE_DEGRADED;
1670 /* no useful addresses found */
1671 link->operstate = LINK_OPERSTATE_CARRIER;
1672 } else if (link->flags & IFF_UP)
1673 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1675 link->operstate = LINK_OPERSTATE_OFF;
1678 int link_save(Link *link) {
1679 _cleanup_free_ char *temp_path = NULL;
1680 _cleanup_fclose_ FILE *f = NULL;
1681 const char *admin_state, *oper_state;
1685 assert(link->state_file);
1686 assert(link->lease_file);
1687 assert(link->manager);
1689 link_update_operstate(link);
1691 r = manager_save(link->manager);
1695 if (link->state == LINK_STATE_LINGER) {
1696 unlink(link->state_file);
1700 admin_state = link_state_to_string(link->state);
1701 assert(admin_state);
1703 oper_state = link_operstate_to_string(link->operstate);
1706 r = fopen_temporary(link->state_file, &f, &temp_path);
1710 fchmod(fileno(f), 0644);
1713 "# This is private data. Do not parse.\n"
1716 admin_state, oper_state);
1718 if (link->network) {
1719 char **address, **domain;
1722 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1726 STRV_FOREACH(address, link->network->dns) {
1733 if (link->network->dhcp_dns &&
1735 const struct in_addr *addresses;
1737 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1741 serialize_in_addrs(f, addresses, r);
1749 STRV_FOREACH(address, link->network->ntp) {
1756 if (link->network->dhcp_ntp &&
1758 const struct in_addr *addresses;
1760 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1764 serialize_in_addrs(f, addresses, r);
1770 fprintf(f, "DOMAINS=");
1772 STRV_FOREACH(domain, link->network->domains) {
1779 if (link->network->dhcp_domains &&
1781 const char *domainname;
1783 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1787 fputs(domainname, f);
1793 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1794 yes_no(link->network->wildcard_domain));
1796 fprintf(f, "LLMNR=%s\n",
1797 llmnr_support_to_string(link->network->llmnr));
1800 if (link->dhcp_lease) {
1801 assert(link->network);
1803 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1811 unlink(link->lease_file);
1813 r = fflush_and_check(f);
1817 if (rename(temp_path, link->state_file) < 0) {
1824 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1825 unlink(link->state_file);
1830 static const char* const link_state_table[_LINK_STATE_MAX] = {
1831 [LINK_STATE_PENDING] = "pending",
1832 [LINK_STATE_ENSLAVING] = "configuring",
1833 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1834 [LINK_STATE_SETTING_ROUTES] = "configuring",
1835 [LINK_STATE_CONFIGURED] = "configured",
1836 [LINK_STATE_UNMANAGED] = "unmanaged",
1837 [LINK_STATE_FAILED] = "failed",
1838 [LINK_STATE_LINGER] = "linger",
1841 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1843 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1844 [LINK_OPERSTATE_OFF] = "off",
1845 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1846 [LINK_OPERSTATE_DORMANT] = "dormant",
1847 [LINK_OPERSTATE_CARRIER] = "carrier",
1848 [LINK_OPERSTATE_DEGRADED] = "degraded",
1849 [LINK_OPERSTATE_ROUTABLE] = "routable",
1852 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);