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 static bool link_lldp_enabled(Link *link) {
79 if (link->flags & IFF_LOOPBACK)
85 if(link->network->bridge)
88 return link->network->lldp;
91 #define FLAG_STRING(string, flag, old, new) \
92 (((old ^ new) & flag) \
93 ? ((old & flag) ? (" -" string) : (" +" string)) \
96 static int link_update_flags(Link *link, sd_rtnl_message *m) {
97 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
103 r = sd_rtnl_message_link_get_flags(m, &flags);
105 log_link_warning(link, "Could not get link flags");
109 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
111 /* if we got a message without operstate, take it to mean
112 the state was unchanged */
113 operstate = link->kernel_operstate;
115 if ((link->flags == flags) && (link->kernel_operstate == operstate))
118 if (link->flags != flags) {
119 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",
120 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
121 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
122 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
123 FLAG_STRING("UP", IFF_UP, link->flags, flags),
124 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
125 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
126 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
127 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
128 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
129 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
130 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
131 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
132 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
133 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
134 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
135 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
136 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
137 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
138 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
140 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
141 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
142 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
143 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
144 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
145 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
146 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
147 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
149 /* link flags are currently at most 18 bits, let's align to
151 if (unknown_flags_added)
153 "unknown link flags gained: %#.5x (ignoring)",
154 unknown_flags_added);
156 if (unknown_flags_removed)
158 "unknown link flags lost: %#.5x (ignoring)",
159 unknown_flags_removed);
163 link->kernel_operstate = operstate;
170 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
171 _cleanup_link_unref_ Link *link = NULL;
180 r = sd_rtnl_message_get_type(message, &type);
183 else if (type != RTM_NEWLINK)
186 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
189 else if (ifindex <= 0)
192 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
196 link = new0(Link, 1);
201 link->manager = manager;
202 link->state = LINK_STATE_PENDING;
203 link->ifindex = ifindex;
204 link->ifname = strdup(ifname);
208 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
210 log_link_debug(link, "MAC address not found for new device, continuing without");
212 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
217 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
222 r = asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d",
228 r = hashmap_ensure_allocated(&manager->links, NULL);
232 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
236 r = link_update_flags(link, message);
246 static void link_free(Link *link) {
252 while ((address = link->addresses)) {
253 LIST_REMOVE(addresses, link->addresses, address);
254 address_free(address);
257 while ((address = link->pool_addresses)) {
258 LIST_REMOVE(addresses, link->pool_addresses, address);
259 address_free(address);
262 sd_dhcp_server_unref(link->dhcp_server);
263 sd_dhcp_client_unref(link->dhcp_client);
264 sd_dhcp_lease_unref(link->dhcp_lease);
266 unlink(link->lease_file);
267 free(link->lease_file);
269 unlink(link->lldp_file);
270 free(link->lldp_file);
272 sd_ipv4ll_unref(link->ipv4ll);
273 sd_dhcp6_client_unref(link->dhcp6_client);
274 sd_icmp6_nd_unref(link->icmp6_router_discovery);
277 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
281 unlink(link->state_file);
282 free(link->state_file);
284 udev_device_unref(link->udev_device);
289 Link *link_unref(Link *link) {
290 if (link && (-- link->n_ref <= 0))
296 Link *link_ref(Link *link) {
298 assert_se(++ link->n_ref >= 2);
303 int link_get(Manager *m, int ifindex, Link **ret) {
310 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
319 void link_drop(Link *link) {
320 if (!link || link->state == LINK_STATE_LINGER)
323 link->state = LINK_STATE_LINGER;
325 log_link_debug(link, "link removed");
332 static void link_enter_unmanaged(Link *link) {
335 log_link_debug(link, "unmanaged");
337 link->state = LINK_STATE_UNMANAGED;
342 static int link_stop_clients(Link *link) {
346 assert(link->manager);
347 assert(link->manager->event);
352 if (link->dhcp_client) {
353 k = sd_dhcp_client_stop(link->dhcp_client);
355 log_link_warning(link, "Could not stop DHCPv4 client: %s",
362 k = sd_ipv4ll_stop(link->ipv4ll);
364 log_link_warning(link, "Could not stop IPv4 link-local: %s",
370 if(link->icmp6_router_discovery) {
372 if (link->dhcp6_client) {
373 k = sd_dhcp6_client_stop(link->dhcp6_client);
375 log_link_warning(link, "Could not stop DHCPv6 client: %s",
381 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
383 log_link_warning(link,
384 "Could not stop ICMPv6 router discovery: %s",
392 k = sd_lldp_stop(link->lldp);
394 log_link_warning(link, "Could not stop LLDP : %s",
403 void link_enter_failed(Link *link) {
406 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
409 log_link_warning(link, "failed");
411 link->state = LINK_STATE_FAILED;
413 link_stop_clients(link);
418 static Address* link_find_dhcp_server_address(Link *link) {
422 assert(link->network);
424 /* The the first statically configured address if there is any */
425 LIST_FOREACH(addresses, address, link->network->static_addresses) {
427 if (address->family != AF_INET)
430 if (in_addr_is_null(address->family, &address->in_addr))
436 /* If that didn't work, find a suitable address we got from the pool */
437 LIST_FOREACH(addresses, address, link->pool_addresses) {
438 if (address->family != AF_INET)
447 static int link_enter_configured(Link *link) {
451 assert(link->network);
452 assert(link->state == LINK_STATE_SETTING_ROUTES);
454 if (link_dhcp4_server_enabled(link) &&
455 !sd_dhcp_server_is_running(link->dhcp_server)) {
456 struct in_addr pool_start;
459 address = link_find_dhcp_server_address(link);
461 log_link_warning(link,
462 "Failed to find suitable address for DHCPv4 server instance.");
463 link_enter_failed(link);
467 log_link_debug(link, "offering DHCPv4 leases");
469 r = sd_dhcp_server_set_address(link->dhcp_server,
470 &address->in_addr.in,
475 /* offer 32 addresses starting from the address following the server address */
476 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
477 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
483 r = sd_dhcp_server_set_router(link->dhcp_server,
484 &main_address->in_addr.in);
488 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
489 main_address->prefixlen);
494 r = sd_dhcp_server_start(link->dhcp_server);
496 log_link_warning(link, "could not start DHCPv4 server "
497 "instance: %s", strerror(-r));
499 link_enter_failed(link);
505 log_link_info(link, "link configured");
507 link->state = LINK_STATE_CONFIGURED;
514 void link_client_handler(Link *link) {
516 assert(link->network);
518 if (!link->static_configured)
521 if (link_ipv4ll_enabled(link))
522 if (!link->ipv4ll_address ||
526 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
529 if (link->state != LINK_STATE_CONFIGURED)
530 link_enter_configured(link);
535 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
536 _cleanup_link_unref_ Link *link = userdata;
539 assert(link->link_messages > 0);
540 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
541 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
544 link->link_messages --;
546 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
549 r = sd_rtnl_message_get_errno(m);
550 if (r < 0 && r != -EEXIST)
551 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
553 if (link->link_messages == 0) {
554 log_link_debug(link, "routes set");
555 link->static_configured = true;
556 link_client_handler(link);
562 static int link_enter_set_routes(Link *link) {
567 assert(link->network);
568 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
570 link->state = LINK_STATE_SETTING_ROUTES;
572 LIST_FOREACH(routes, rt, link->network->static_routes) {
573 r = route_configure(rt, link, &route_handler);
575 log_link_warning(link,
576 "could not set routes: %s",
578 link_enter_failed(link);
582 link->link_messages ++;
585 if (link->link_messages == 0) {
586 link->static_configured = true;
587 link_client_handler(link);
589 log_link_debug(link, "setting routes");
594 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
595 _cleanup_link_unref_ Link *link = userdata;
600 assert(link->ifname);
602 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
605 r = sd_rtnl_message_get_errno(m);
606 if (r < 0 && r != -ESRCH)
607 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
612 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
613 _cleanup_link_unref_ Link *link = userdata;
619 assert(link->ifname);
620 assert(link->link_messages > 0);
621 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
622 LINK_STATE_FAILED, LINK_STATE_LINGER));
624 link->link_messages --;
626 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
629 r = sd_rtnl_message_get_errno(m);
630 if (r < 0 && r != -EEXIST)
631 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
633 link_rtnl_process_address(rtnl, m, link->manager);
635 if (link->link_messages == 0) {
636 log_link_debug(link, "addresses set");
637 link_enter_set_routes(link);
643 static int link_enter_set_addresses(Link *link) {
648 assert(link->network);
649 assert(link->state != _LINK_STATE_INVALID);
651 link->state = LINK_STATE_SETTING_ADDRESSES;
653 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
654 r = address_configure(ad, link, &address_handler);
656 log_link_warning(link,
657 "could not set addresses: %s",
659 link_enter_failed(link);
663 link->link_messages ++;
666 if (link->link_messages == 0) {
667 link_enter_set_routes(link);
669 log_link_debug(link, "setting addresses");
674 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
675 _cleanup_link_unref_ Link *link = userdata;
680 assert(link->ifname);
682 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
685 r = sd_rtnl_message_get_errno(m);
686 if (r < 0 && r != -EADDRNOTAVAIL)
687 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
692 static int link_set_bridge_fdb(const Link *const link) {
696 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
697 r = fdb_entry_configure(link->manager->rtnl, fdb_entry, link->ifindex);
699 log_link_error(link, "Failed to add MAC entry to static MAC table: %s", strerror(-r));
707 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
708 _cleanup_link_unref_ Link *link = userdata;
711 log_link_debug(link, "set link");
713 r = sd_rtnl_message_get_errno(m);
714 if (r < 0 && r != -EEXIST) {
715 log_link_struct(link, LOG_ERR,
716 "MESSAGE=%-*s: could not join netdev: %s",
718 link->ifname, strerror(-r),
721 link_enter_failed(link);
728 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
729 sd_bus_error *ret_error) {
730 _cleanup_link_unref_ Link *link = userdata;
735 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
738 r = sd_bus_message_get_errno(m);
740 log_link_warning(link, "Could not set hostname: %s",
746 int link_set_hostname(Link *link, const char *hostname) {
747 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
751 assert(link->manager);
754 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
756 if (!link->manager->bus) {
757 /* TODO: replace by assert when we can rely on kdbus */
759 "Not connected to system bus, ignoring transient hostname.");
763 r = sd_bus_message_new_method_call(
766 "org.freedesktop.hostname1",
767 "/org/freedesktop/hostname1",
768 "org.freedesktop.hostname1",
773 r = sd_bus_message_append(m, "sb", hostname, false);
777 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
780 log_link_error(link, "Could not set transient hostname: %s",
790 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
791 _cleanup_link_unref_ Link *link = userdata;
796 assert(link->ifname);
798 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
801 r = sd_rtnl_message_get_errno(m);
803 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
808 int link_set_mtu(Link *link, uint32_t mtu) {
809 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
813 assert(link->manager);
814 assert(link->manager->rtnl);
816 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
818 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
819 RTM_SETLINK, link->ifindex);
821 log_link_error(link, "Could not allocate RTM_SETLINK message");
825 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
827 log_link_error(link, "Could not append MTU: %s", strerror(-r));
831 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
835 "Could not send rtnetlink message: %s",
845 static int link_set_bridge(Link *link) {
846 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
850 assert(link->network);
852 if(link->network->cost == 0)
855 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
856 RTM_SETLINK, link->ifindex);
858 log_link_error(link, "Could not allocate RTM_SETLINK message");
862 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
865 "Could not set message family %s", strerror(-r));
869 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
872 "Could not append IFLA_PROTINFO attribute: %s",
877 if(link->network->cost != 0) {
878 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
881 "Could not append IFLA_BRPORT_COST attribute: %s",
887 r = sd_rtnl_message_close_container(req);
890 "Could not append IFLA_LINKINFO attribute: %s",
895 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
898 "Could not send rtnetlink message: %s",
908 static void lldp_handler(sd_lldp *lldp, int event, void *userdata) {
909 Link *link = userdata;
913 assert(link->network);
914 assert(link->manager);
916 if (event != UPDATE_INFO)
919 r = sd_lldp_save(link->lldp, link->lldp_file);
921 log_link_warning(link, "could not save LLDP");
925 static int link_acquire_conf(Link *link) {
929 assert(link->network);
930 assert(link->manager);
931 assert(link->manager->event);
933 if (link_ipv4ll_enabled(link)) {
934 assert(link->ipv4ll);
936 log_link_debug(link, "acquiring IPv4 link-local address");
938 r = sd_ipv4ll_start(link->ipv4ll);
940 log_link_warning(link, "could not acquire IPv4 "
941 "link-local address");
946 if (link_dhcp4_enabled(link)) {
947 assert(link->dhcp_client);
949 log_link_debug(link, "acquiring DHCPv4 lease");
951 r = sd_dhcp_client_start(link->dhcp_client);
953 log_link_warning(link, "could not acquire DHCPv4 "
959 if (link_dhcp6_enabled(link)) {
960 assert(link->icmp6_router_discovery);
962 log_link_debug(link, "discovering IPv6 routers");
964 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
966 log_link_warning(link,
967 "could not start IPv6 router discovery");
972 if (link_lldp_enabled(link)) {
975 log_link_debug(link, "Starting LLDP");
977 r = sd_lldp_start(link->lldp);
979 log_link_warning(link, "could not start LLDP ");
987 bool link_has_carrier(Link *link) {
988 /* see Documentation/networking/operstates.txt in the kernel sources */
990 if (link->kernel_operstate == IF_OPER_UP)
993 if (link->kernel_operstate == IF_OPER_UNKNOWN)
994 /* operstate may not be implemented, so fall back to flags */
995 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1001 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1002 _cleanup_link_unref_ Link *link = userdata;
1007 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1010 r = sd_rtnl_message_get_errno(m);
1012 /* we warn but don't fail the link, as it may
1013 be brought up later */
1014 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
1020 static int link_up(Link *link) {
1021 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1025 assert(link->network);
1026 assert(link->manager);
1027 assert(link->manager->rtnl);
1029 log_link_debug(link, "bringing link up");
1031 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1032 RTM_SETLINK, link->ifindex);
1034 log_link_error(link, "Could not allocate RTM_SETLINK message");
1038 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1040 log_link_error(link, "Could not set link flags: %s",
1045 if (link->network->mac) {
1046 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1048 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
1053 if (link->network->mtu) {
1054 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
1056 log_link_error(link, "Could not set MTU: %s", strerror(-r));
1061 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1064 log_link_error(link,
1065 "Could not send rtnetlink message: %s",
1075 static int link_joined(Link *link) {
1079 assert(link->network);
1081 if (!(link->flags & IFF_UP)) {
1084 link_enter_failed(link);
1089 if(link->network->bridge) {
1090 r = link_set_bridge(link);
1092 log_link_error(link,
1093 "Could not set bridge message: %s",
1098 return link_enter_set_addresses(link);
1101 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1103 _cleanup_link_unref_ Link *link = userdata;
1107 assert(link->network);
1111 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1114 r = sd_rtnl_message_get_errno(m);
1115 if (r < 0 && r != -EEXIST) {
1116 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1117 link_enter_failed(link);
1120 log_link_debug(link, "joined netdev");
1122 if (link->enslaving <= 0)
1128 static int link_enter_join_netdev(Link *link) {
1134 assert(link->network);
1135 assert(link->state == LINK_STATE_PENDING);
1137 link->state = LINK_STATE_ENSLAVING;
1141 if (!link->network->bridge &&
1142 !link->network->bond &&
1143 hashmap_isempty(link->network->stacked_netdevs))
1144 return link_joined(link);
1146 if (link->network->bond) {
1147 log_link_struct(link, LOG_DEBUG,
1148 "MESSAGE=%-*s: enslaving by '%s'",
1150 link->ifname, link->network->bond->ifname,
1151 NETDEVIF(link->network->bond),
1154 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1156 log_link_struct(link, LOG_WARNING,
1157 "MESSAGE=%-*s: could not join netdev '%s': %s",
1159 link->ifname, link->network->bond->ifname,
1161 NETDEVIF(link->network->bond),
1163 link_enter_failed(link);
1170 if (link->network->bridge) {
1171 log_link_struct(link, LOG_DEBUG,
1172 "MESSAGE=%-*s: enslaving by '%s'",
1174 link->ifname, link->network->bridge->ifname,
1175 NETDEVIF(link->network->bridge),
1178 r = netdev_join(link->network->bridge, link,
1179 &netdev_join_handler);
1181 log_link_struct(link, LOG_WARNING,
1182 "MESSAGE=%-*s: could not join netdev '%s': %s",
1184 link->ifname, link->network->bridge->ifname,
1186 NETDEVIF(link->network->bridge),
1188 link_enter_failed(link);
1195 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1196 log_link_struct(link, LOG_DEBUG,
1197 "MESSAGE=%-*s: enslaving by '%s'",
1199 link->ifname, netdev->ifname, NETDEVIF(netdev),
1202 r = netdev_join(netdev, link, &netdev_join_handler);
1204 log_link_struct(link, LOG_WARNING,
1205 "MESSAGE=%-*s: could not join netdev '%s': %s",
1207 link->ifname, netdev->ifname,
1209 NETDEVIF(netdev), NULL);
1210 link_enter_failed(link);
1220 static int link_configure(Link *link) {
1224 assert(link->network);
1225 assert(link->state == LINK_STATE_PENDING);
1227 r = link_set_bridge_fdb(link);
1231 if (link_ipv4ll_enabled(link)) {
1232 r = ipv4ll_configure(link);
1237 if (link_dhcp4_enabled(link)) {
1238 r = dhcp4_configure(link);
1243 if (link_dhcp4_server_enabled(link)) {
1244 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1248 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1253 if (link_dhcp6_enabled(link)) {
1254 r = icmp6_configure(link);
1259 if (link_lldp_enabled(link)) {
1260 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1264 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1268 r = sd_lldp_set_callback(link->lldp,
1269 lldp_handler, link);
1274 if (link_has_carrier(link)) {
1275 r = link_acquire_conf(link);
1280 return link_enter_join_netdev(link);
1283 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1285 _cleanup_link_unref_ Link *link = userdata;
1290 assert(link->ifname);
1291 assert(link->manager);
1293 if (link->state != LINK_STATE_PENDING)
1296 log_link_debug(link, "link state is up-to-date");
1298 r = network_get(link->manager, link->udev_device, link->ifname,
1299 &link->mac, &network);
1301 link_enter_unmanaged(link);
1306 if (link->flags & IFF_LOOPBACK) {
1307 if (network->ipv4ll)
1308 log_link_debug(link, "ignoring IPv4LL for loopback link");
1310 if (network->dhcp != DHCP_SUPPORT_NONE)
1311 log_link_debug(link, "ignoring DHCP clients for loopback link");
1313 if (network->dhcp_server)
1314 log_link_debug(link, "ignoring DHCP server for loopback link");
1317 r = network_apply(link->manager, network, link);
1321 r = link_configure(link);
1328 int link_initialized(Link *link, struct udev_device *device) {
1329 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1333 assert(link->manager);
1334 assert(link->manager->rtnl);
1337 if (link->state != LINK_STATE_PENDING)
1340 if (link->udev_device)
1343 log_link_debug(link, "udev initialized link");
1345 link->udev_device = udev_device_ref(device);
1347 /* udev has initialized the link, but we don't know if we have yet
1348 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1349 * when it returns we know that the pending NEWLINKs have already been
1350 * processed and that we are up-to-date */
1352 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1357 r = sd_rtnl_call_async(link->manager->rtnl, req,
1358 link_initialized_and_synced, link, 0, NULL);
1367 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1368 Manager *m = userdata;
1371 _cleanup_address_free_ Address *address = NULL;
1373 char buf[INET6_ADDRSTRLEN];
1374 char valid_buf[FORMAT_TIMESPAN_MAX];
1375 const char *valid_str = NULL;
1376 bool address_dropped = false;
1383 if (sd_rtnl_message_is_error(message)) {
1384 r = sd_rtnl_message_get_errno(message);
1386 log_warning_errno(r, "rtnl: failed to receive address: %m");
1391 r = sd_rtnl_message_get_type(message, &type);
1393 log_warning("rtnl: could not get message type");
1397 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1399 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1401 } else if (ifindex <= 0) {
1402 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1405 r = link_get(m, ifindex, &link);
1406 if (r < 0 || !link) {
1407 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1412 r = address_new_dynamic(&address);
1416 r = sd_rtnl_message_addr_get_family(message, &address->family);
1417 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1418 log_link_warning(link,
1419 "rtnl: received address with invalid family, ignoring");
1423 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1425 log_link_warning(link,
1426 "rtnl: received address with invalid prefixlen, ignoring");
1430 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1432 log_link_warning(link,
1433 "rtnl: received address with invalid scope, ignoring");
1437 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1439 log_link_warning(link,
1440 "rtnl: received address with invalid flags, ignoring");
1444 switch (address->family) {
1446 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
1447 &address->in_addr.in);
1449 log_link_warning(link,
1450 "rtnl: received address without valid address, ignoring");
1457 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
1458 &address->in_addr.in6);
1460 log_link_warning(link,
1461 "rtnl: received address without valid address, ignoring");
1468 assert_not_reached("invalid address family");
1471 if (!inet_ntop(address->family, &address->in_addr, buf,
1472 INET6_ADDRSTRLEN)) {
1473 log_link_warning(link, "could not print address");
1477 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO,
1480 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1483 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1484 address->cinfo.ifa_valid * USEC_PER_SEC,
1488 LIST_FOREACH(addresses, ad, link->addresses) {
1489 if (address_equal(ad, address)) {
1490 LIST_REMOVE(addresses, link->addresses, ad);
1494 address_dropped = true;
1502 if (!address_dropped)
1503 log_link_debug(link, "added address: %s/%u (valid for %s)",
1504 buf, address->prefixlen, valid_str);
1506 log_link_debug(link, "updated address: %s/%u (valid for %s)",
1507 buf, address->prefixlen, valid_str);
1509 LIST_PREPEND(addresses, link->addresses, address);
1516 if (address_dropped) {
1517 log_link_debug(link, "removed address: %s/%u (valid for %s)",
1518 buf, address->prefixlen, valid_str);
1522 log_link_warning(link,
1523 "removing non-existent address: %s/%u (valid for %s)",
1524 buf, address->prefixlen, valid_str);
1528 assert_not_reached("Received invalid RTNL message type");
1534 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1536 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1537 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1545 r = link_new(m, message, ret);
1551 log_link_debug(link, "link %d added", link->ifindex);
1553 if (detect_container(NULL) <= 0) {
1554 /* not in a container, udev will be around */
1555 sprintf(ifindex_str, "n%d", link->ifindex);
1556 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1558 log_link_warning(link,
1559 "could not find udev device: %m");
1563 if (udev_device_get_is_initialized(device) <= 0) {
1565 log_link_debug(link, "link pending udev initialization...");
1569 r = link_initialized(link, device);
1573 /* we are calling a callback directly, so must take a ref */
1576 r = link_initialized_and_synced(m->rtnl, NULL, link);
1584 int link_update(Link *link, sd_rtnl_message *m) {
1585 struct ether_addr mac;
1588 bool had_carrier, carrier_gained, carrier_lost;
1592 assert(link->ifname);
1595 if (link->state == LINK_STATE_LINGER) {
1597 log_link_info(link, "link readded");
1598 link->state = LINK_STATE_ENSLAVING;
1601 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1602 if (r >= 0 && !streq(ifname, link->ifname)) {
1603 log_link_info(link, "renamed to %s", ifname);
1606 link->ifname = strdup(ifname);
1611 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1612 if (r >= 0 && mtu > 0) {
1614 if (!link->original_mtu) {
1615 link->original_mtu = mtu;
1616 log_link_debug(link, "saved original MTU: %"
1617 PRIu32, link->original_mtu);
1620 if (link->dhcp_client) {
1621 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1624 log_link_warning(link,
1625 "Could not update MTU in DHCP client: %s",
1632 /* The kernel may broadcast NEWLINK messages without the MAC address
1633 set, simply ignore them. */
1634 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1636 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1639 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1642 log_link_debug(link, "MAC address: "
1643 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1644 mac.ether_addr_octet[0],
1645 mac.ether_addr_octet[1],
1646 mac.ether_addr_octet[2],
1647 mac.ether_addr_octet[3],
1648 mac.ether_addr_octet[4],
1649 mac.ether_addr_octet[5]);
1652 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1654 log_link_warning(link,
1655 "Could not update MAC address in IPv4LL client: %s",
1661 if (link->dhcp_client) {
1662 r = sd_dhcp_client_set_mac(link->dhcp_client,
1663 (const uint8_t *) &link->mac,
1667 log_link_warning(link,
1668 "Could not update MAC address in DHCP client: %s",
1674 if (link->dhcp6_client) {
1675 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1676 (const uint8_t *) &link->mac,
1680 log_link_warning(link,
1681 "Could not update MAC address in DHCPv6 client: %s",
1689 had_carrier = link_has_carrier(link);
1691 r = link_update_flags(link, m);
1695 carrier_gained = !had_carrier && link_has_carrier(link);
1696 carrier_lost = had_carrier && !link_has_carrier(link);
1698 if (carrier_gained) {
1699 log_link_info(link, "gained carrier");
1701 if (link->network) {
1702 r = link_acquire_conf(link);
1704 link_enter_failed(link);
1708 } else if (carrier_lost) {
1709 log_link_info(link, "lost carrier");
1711 r = link_stop_clients(link);
1713 link_enter_failed(link);
1721 static void link_update_operstate(Link *link) {
1725 if (link->kernel_operstate == IF_OPER_DORMANT)
1726 link->operstate = LINK_OPERSTATE_DORMANT;
1727 else if (link_has_carrier(link)) {
1729 uint8_t scope = RT_SCOPE_NOWHERE;
1731 /* if we have carrier, check what addresses we have */
1732 LIST_FOREACH(addresses, address, link->addresses) {
1733 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1736 if (address->scope < scope)
1737 scope = address->scope;
1740 if (scope < RT_SCOPE_SITE)
1741 /* universally accessible addresses found */
1742 link->operstate = LINK_OPERSTATE_ROUTABLE;
1743 else if (scope < RT_SCOPE_HOST)
1744 /* only link or site local addresses found */
1745 link->operstate = LINK_OPERSTATE_DEGRADED;
1747 /* no useful addresses found */
1748 link->operstate = LINK_OPERSTATE_CARRIER;
1749 } else if (link->flags & IFF_UP)
1750 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1752 link->operstate = LINK_OPERSTATE_OFF;
1755 int link_save(Link *link) {
1756 _cleanup_free_ char *temp_path = NULL;
1757 _cleanup_fclose_ FILE *f = NULL;
1758 const char *admin_state, *oper_state;
1762 assert(link->state_file);
1763 assert(link->lease_file);
1764 assert(link->manager);
1766 link_update_operstate(link);
1768 r = manager_save(link->manager);
1772 if (link->state == LINK_STATE_LINGER) {
1773 unlink(link->state_file);
1777 admin_state = link_state_to_string(link->state);
1778 assert(admin_state);
1780 oper_state = link_operstate_to_string(link->operstate);
1783 r = fopen_temporary(link->state_file, &f, &temp_path);
1787 fchmod(fileno(f), 0644);
1790 "# This is private data. Do not parse.\n"
1793 admin_state, oper_state);
1795 if (link->network) {
1796 char **address, **domain;
1799 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1803 STRV_FOREACH(address, link->network->dns) {
1810 if (link->network->dhcp_dns &&
1812 const struct in_addr *addresses;
1814 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1818 serialize_in_addrs(f, addresses, r);
1826 STRV_FOREACH(address, link->network->ntp) {
1833 if (link->network->dhcp_ntp &&
1835 const struct in_addr *addresses;
1837 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1841 serialize_in_addrs(f, addresses, r);
1847 fprintf(f, "DOMAINS=");
1849 STRV_FOREACH(domain, link->network->domains) {
1856 if (link->network->dhcp_domains &&
1858 const char *domainname;
1860 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1864 fputs(domainname, f);
1870 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1871 yes_no(link->network->wildcard_domain));
1873 fprintf(f, "LLMNR=%s\n",
1874 llmnr_support_to_string(link->network->llmnr));
1877 if (link->dhcp_lease) {
1878 assert(link->network);
1880 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1888 unlink(link->lease_file);
1891 assert(link->network);
1893 r = sd_lldp_save(link->lldp, link->lldp_file);
1901 unlink(link->lldp_file);
1903 r = fflush_and_check(f);
1907 if (rename(temp_path, link->state_file) < 0) {
1914 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1915 unlink(link->state_file);
1920 static const char* const link_state_table[_LINK_STATE_MAX] = {
1921 [LINK_STATE_PENDING] = "pending",
1922 [LINK_STATE_ENSLAVING] = "configuring",
1923 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1924 [LINK_STATE_SETTING_ROUTES] = "configuring",
1925 [LINK_STATE_CONFIGURED] = "configured",
1926 [LINK_STATE_UNMANAGED] = "unmanaged",
1927 [LINK_STATE_FAILED] = "failed",
1928 [LINK_STATE_LINGER] = "linger",
1931 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1933 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1934 [LINK_OPERSTATE_OFF] = "off",
1935 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1936 [LINK_OPERSTATE_DORMANT] = "dormant",
1937 [LINK_OPERSTATE_CARRIER] = "carrier",
1938 [LINK_OPERSTATE_DEGRADED] = "degraded",
1939 [LINK_OPERSTATE_ROUTABLE] = "routable",
1942 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);