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 = hashmap_ensure_allocated(&manager->links, NULL);
226 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
230 r = link_update_flags(link, message);
240 static void link_free(Link *link) {
246 while ((address = link->addresses)) {
247 LIST_REMOVE(addresses, link->addresses, address);
248 address_free(address);
251 while ((address = link->pool_addresses)) {
252 LIST_REMOVE(addresses, link->pool_addresses, address);
253 address_free(address);
256 sd_dhcp_client_unref(link->dhcp_client);
257 sd_dhcp_lease_unref(link->dhcp_lease);
259 unlink(link->lease_file);
260 free(link->lease_file);
262 sd_ipv4ll_unref(link->ipv4ll);
263 sd_dhcp6_client_unref(link->dhcp6_client);
264 sd_icmp6_nd_unref(link->icmp6_router_discovery);
267 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
271 unlink(link->state_file);
272 free(link->state_file);
274 udev_device_unref(link->udev_device);
279 Link *link_unref(Link *link) {
280 if (link && (-- link->n_ref <= 0))
286 Link *link_ref(Link *link) {
288 assert_se(++ link->n_ref >= 2);
293 int link_get(Manager *m, int ifindex, Link **ret) {
300 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
309 void link_drop(Link *link) {
310 if (!link || link->state == LINK_STATE_LINGER)
313 link->state = LINK_STATE_LINGER;
315 log_link_debug(link, "link removed");
322 static void link_enter_unmanaged(Link *link) {
325 log_link_debug(link, "unmanaged");
327 link->state = LINK_STATE_UNMANAGED;
332 static int link_stop_clients(Link *link) {
336 assert(link->manager);
337 assert(link->manager->event);
342 if (link->dhcp_client) {
343 k = sd_dhcp_client_stop(link->dhcp_client);
345 log_link_warning(link, "Could not stop DHCPv4 client: %s",
352 k = sd_ipv4ll_stop(link->ipv4ll);
354 log_link_warning(link, "Could not stop IPv4 link-local: %s",
360 if(link->icmp6_router_discovery) {
362 if (link->dhcp6_client) {
363 k = sd_dhcp6_client_stop(link->dhcp6_client);
365 log_link_warning(link, "Could not stop DHCPv6 client: %s",
371 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
373 log_link_warning(link,
374 "Could not stop ICMPv6 router discovery: %s",
382 k = sd_lldp_stop(link->lldp);
384 log_link_warning(link, "Could not stop LLDP : %s",
393 void link_enter_failed(Link *link) {
396 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
399 log_link_warning(link, "failed");
401 link->state = LINK_STATE_FAILED;
403 link_stop_clients(link);
408 static Address* link_find_dhcp_server_address(Link *link) {
412 assert(link->network);
414 /* The the first statically configured address if there is any */
415 LIST_FOREACH(addresses, address, link->network->static_addresses) {
417 if (address->family != AF_INET)
420 if (in_addr_is_null(address->family, &address->in_addr))
426 /* If that didn't work, find a suitable address we got from the pool */
427 LIST_FOREACH(addresses, address, link->pool_addresses) {
428 if (address->family != AF_INET)
437 static int link_enter_configured(Link *link) {
441 assert(link->network);
442 assert(link->state == LINK_STATE_SETTING_ROUTES);
444 if (link_dhcp4_server_enabled(link) &&
445 !sd_dhcp_server_is_running(link->dhcp_server)) {
446 struct in_addr pool_start;
449 address = link_find_dhcp_server_address(link);
451 log_link_warning(link,
452 "Failed to find suitable address for DHCPv4 server instance.");
453 link_enter_failed(link);
457 log_link_debug(link, "offering DHCPv4 leases");
459 r = sd_dhcp_server_set_address(link->dhcp_server,
460 &address->in_addr.in,
465 /* offer 32 addresses starting from the address following the server address */
466 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
467 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
473 r = sd_dhcp_server_set_router(link->dhcp_server,
474 &main_address->in_addr.in);
478 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
479 main_address->prefixlen);
484 r = sd_dhcp_server_start(link->dhcp_server);
486 log_link_warning(link, "could not start DHCPv4 server "
487 "instance: %s", strerror(-r));
489 link_enter_failed(link);
495 log_link_info(link, "link configured");
497 link->state = LINK_STATE_CONFIGURED;
504 void link_client_handler(Link *link) {
506 assert(link->network);
508 if (!link->static_configured)
511 if (link_ipv4ll_enabled(link))
512 if (!link->ipv4ll_address ||
516 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
519 if (link->state != LINK_STATE_CONFIGURED)
520 link_enter_configured(link);
525 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
526 _cleanup_link_unref_ Link *link = userdata;
529 assert(link->link_messages > 0);
530 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
531 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
534 link->link_messages --;
536 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
539 r = sd_rtnl_message_get_errno(m);
540 if (r < 0 && r != -EEXIST)
541 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
543 if (link->link_messages == 0) {
544 log_link_debug(link, "routes set");
545 link->static_configured = true;
546 link_client_handler(link);
552 static int link_enter_set_routes(Link *link) {
557 assert(link->network);
558 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
560 link->state = LINK_STATE_SETTING_ROUTES;
562 LIST_FOREACH(routes, rt, link->network->static_routes) {
563 r = route_configure(rt, link, &route_handler);
565 log_link_warning(link,
566 "could not set routes: %s",
568 link_enter_failed(link);
572 link->link_messages ++;
575 if (link->link_messages == 0) {
576 link->static_configured = true;
577 link_client_handler(link);
579 log_link_debug(link, "setting routes");
584 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
585 _cleanup_link_unref_ Link *link = userdata;
590 assert(link->ifname);
592 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
595 r = sd_rtnl_message_get_errno(m);
596 if (r < 0 && r != -ESRCH)
597 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
602 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
603 _cleanup_link_unref_ Link *link = userdata;
609 assert(link->ifname);
610 assert(link->link_messages > 0);
611 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
612 LINK_STATE_FAILED, LINK_STATE_LINGER));
614 link->link_messages --;
616 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
619 r = sd_rtnl_message_get_errno(m);
620 if (r < 0 && r != -EEXIST)
621 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
623 link_rtnl_process_address(rtnl, m, link->manager);
625 if (link->link_messages == 0) {
626 log_link_debug(link, "addresses set");
627 link_enter_set_routes(link);
633 static int link_enter_set_addresses(Link *link) {
638 assert(link->network);
639 assert(link->state != _LINK_STATE_INVALID);
641 link->state = LINK_STATE_SETTING_ADDRESSES;
643 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
644 r = address_configure(ad, link, &address_handler);
646 log_link_warning(link,
647 "could not set addresses: %s",
649 link_enter_failed(link);
653 link->link_messages ++;
656 if (link->link_messages == 0) {
657 link_enter_set_routes(link);
659 log_link_debug(link, "setting addresses");
664 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
665 _cleanup_link_unref_ Link *link = userdata;
670 assert(link->ifname);
672 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
675 r = sd_rtnl_message_get_errno(m);
676 if (r < 0 && r != -EADDRNOTAVAIL)
677 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
682 static int link_set_bridge_fdb(const Link *const link) {
686 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
687 r = fdb_entry_configure(link->manager->rtnl, fdb_entry, link->ifindex);
689 log_link_error(link, "Failed to add MAC entry to static MAC table: %s", strerror(-r));
697 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
698 _cleanup_link_unref_ Link *link = userdata;
701 log_link_debug(link, "set link");
703 r = sd_rtnl_message_get_errno(m);
704 if (r < 0 && r != -EEXIST) {
705 log_link_struct(link, LOG_ERR,
706 "MESSAGE=%-*s: could not join netdev: %s",
708 link->ifname, strerror(-r),
711 link_enter_failed(link);
718 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
719 sd_bus_error *ret_error) {
720 _cleanup_link_unref_ Link *link = userdata;
725 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
728 r = sd_bus_message_get_errno(m);
730 log_link_warning(link, "Could not set hostname: %s",
736 int link_set_hostname(Link *link, const char *hostname) {
737 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
741 assert(link->manager);
744 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
746 if (!link->manager->bus) {
747 /* TODO: replace by assert when we can rely on kdbus */
749 "Not connected to system bus, ignoring transient hostname.");
753 r = sd_bus_message_new_method_call(
756 "org.freedesktop.hostname1",
757 "/org/freedesktop/hostname1",
758 "org.freedesktop.hostname1",
763 r = sd_bus_message_append(m, "sb", hostname, false);
767 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
770 log_link_error(link, "Could not set transient hostname: %s",
780 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
781 _cleanup_link_unref_ Link *link = userdata;
786 assert(link->ifname);
788 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
791 r = sd_rtnl_message_get_errno(m);
793 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
798 int link_set_mtu(Link *link, uint32_t mtu) {
799 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
803 assert(link->manager);
804 assert(link->manager->rtnl);
806 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
808 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
809 RTM_SETLINK, link->ifindex);
811 log_link_error(link, "Could not allocate RTM_SETLINK message");
815 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
817 log_link_error(link, "Could not append MTU: %s", strerror(-r));
821 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
825 "Could not send rtnetlink message: %s",
835 static int link_set_bridge(Link *link) {
836 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
840 assert(link->network);
842 if(link->network->cost == 0)
845 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
846 RTM_SETLINK, link->ifindex);
848 log_link_error(link, "Could not allocate RTM_SETLINK message");
852 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
855 "Could not set message family %s", strerror(-r));
859 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
862 "Could not append IFLA_PROTINFO attribute: %s",
867 if(link->network->cost != 0) {
868 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
871 "Could not append IFLA_BRPORT_COST attribute: %s",
877 r = sd_rtnl_message_close_container(req);
880 "Could not append IFLA_LINKINFO attribute: %s",
885 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
888 "Could not send rtnetlink message: %s",
898 static int link_acquire_conf(Link *link) {
902 assert(link->network);
903 assert(link->manager);
904 assert(link->manager->event);
906 if (link_ipv4ll_enabled(link)) {
907 assert(link->ipv4ll);
909 log_link_debug(link, "acquiring IPv4 link-local address");
911 r = sd_ipv4ll_start(link->ipv4ll);
913 log_link_warning(link, "could not acquire IPv4 "
914 "link-local address");
919 if (link_dhcp4_enabled(link)) {
920 assert(link->dhcp_client);
922 log_link_debug(link, "acquiring DHCPv4 lease");
924 r = sd_dhcp_client_start(link->dhcp_client);
926 log_link_warning(link, "could not acquire DHCPv4 "
932 if (link_dhcp6_enabled(link)) {
933 assert(link->icmp6_router_discovery);
935 log_link_debug(link, "discovering IPv6 routers");
937 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
939 log_link_warning(link,
940 "could not start IPv6 router discovery");
945 if (link_lldp_enabled(link)) {
948 log_link_debug(link, "Starting LLDP");
950 r = sd_lldp_start(link->lldp);
952 log_link_warning(link, "could not start LLDP ");
960 bool link_has_carrier(Link *link) {
961 /* see Documentation/networking/operstates.txt in the kernel sources */
963 if (link->kernel_operstate == IF_OPER_UP)
966 if (link->kernel_operstate == IF_OPER_UNKNOWN)
967 /* operstate may not be implemented, so fall back to flags */
968 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
974 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
975 _cleanup_link_unref_ Link *link = userdata;
980 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
983 r = sd_rtnl_message_get_errno(m);
985 /* we warn but don't fail the link, as it may
986 be brought up later */
987 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
993 static int link_up(Link *link) {
994 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
998 assert(link->network);
999 assert(link->manager);
1000 assert(link->manager->rtnl);
1002 log_link_debug(link, "bringing link up");
1004 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1005 RTM_SETLINK, link->ifindex);
1007 log_link_error(link, "Could not allocate RTM_SETLINK message");
1011 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1013 log_link_error(link, "Could not set link flags: %s",
1018 if (link->network->mac) {
1019 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1021 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
1026 if (link->network->mtu) {
1027 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
1029 log_link_error(link, "Could not set MTU: %s", strerror(-r));
1034 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1037 log_link_error(link,
1038 "Could not send rtnetlink message: %s",
1048 static int link_joined(Link *link) {
1052 assert(link->network);
1054 if (!(link->flags & IFF_UP)) {
1057 link_enter_failed(link);
1062 if(link->network->bridge) {
1063 r = link_set_bridge(link);
1065 log_link_error(link,
1066 "Could not set bridge message: %s",
1071 return link_enter_set_addresses(link);
1074 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1076 _cleanup_link_unref_ Link *link = userdata;
1080 assert(link->network);
1084 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1087 r = sd_rtnl_message_get_errno(m);
1088 if (r < 0 && r != -EEXIST) {
1089 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1090 link_enter_failed(link);
1093 log_link_debug(link, "joined netdev");
1095 if (link->enslaving <= 0)
1101 static int link_enter_join_netdev(Link *link) {
1107 assert(link->network);
1108 assert(link->state == LINK_STATE_PENDING);
1110 link->state = LINK_STATE_ENSLAVING;
1114 if (!link->network->bridge &&
1115 !link->network->bond &&
1116 hashmap_isempty(link->network->stacked_netdevs))
1117 return link_joined(link);
1119 if (link->network->bond) {
1120 log_link_struct(link, LOG_DEBUG,
1121 "MESSAGE=%-*s: enslaving by '%s'",
1123 link->ifname, link->network->bond->ifname,
1124 NETDEVIF(link->network->bond),
1127 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1129 log_link_struct(link, LOG_WARNING,
1130 "MESSAGE=%-*s: could not join netdev '%s': %s",
1132 link->ifname, link->network->bond->ifname,
1134 NETDEVIF(link->network->bond),
1136 link_enter_failed(link);
1143 if (link->network->bridge) {
1144 log_link_struct(link, LOG_DEBUG,
1145 "MESSAGE=%-*s: enslaving by '%s'",
1147 link->ifname, link->network->bridge->ifname,
1148 NETDEVIF(link->network->bridge),
1151 r = netdev_join(link->network->bridge, link,
1152 &netdev_join_handler);
1154 log_link_struct(link, LOG_WARNING,
1155 "MESSAGE=%-*s: could not join netdev '%s': %s",
1157 link->ifname, link->network->bridge->ifname,
1159 NETDEVIF(link->network->bridge),
1161 link_enter_failed(link);
1168 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1169 log_link_struct(link, LOG_DEBUG,
1170 "MESSAGE=%-*s: enslaving by '%s'",
1172 link->ifname, netdev->ifname, NETDEVIF(netdev),
1175 r = netdev_join(netdev, link, &netdev_join_handler);
1177 log_link_struct(link, LOG_WARNING,
1178 "MESSAGE=%-*s: could not join netdev '%s': %s",
1180 link->ifname, netdev->ifname,
1182 NETDEVIF(netdev), NULL);
1183 link_enter_failed(link);
1193 static int link_configure(Link *link) {
1197 assert(link->network);
1198 assert(link->state == LINK_STATE_PENDING);
1200 r = link_set_bridge_fdb(link);
1204 if (link_ipv4ll_enabled(link)) {
1205 r = ipv4ll_configure(link);
1210 if (link_dhcp4_enabled(link)) {
1211 r = dhcp4_configure(link);
1216 if (link_dhcp4_server_enabled(link)) {
1217 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1221 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1226 if (link_dhcp6_enabled(link)) {
1227 r = icmp6_configure(link);
1232 if (link_lldp_enabled(link)) {
1233 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1237 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1242 if (link_has_carrier(link)) {
1243 r = link_acquire_conf(link);
1248 return link_enter_join_netdev(link);
1251 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1253 _cleanup_link_unref_ Link *link = userdata;
1258 assert(link->ifname);
1259 assert(link->manager);
1261 if (link->state != LINK_STATE_PENDING)
1264 log_link_debug(link, "link state is up-to-date");
1266 r = network_get(link->manager, link->udev_device, link->ifname,
1267 &link->mac, &network);
1269 link_enter_unmanaged(link);
1274 if (link->flags & IFF_LOOPBACK) {
1275 if (network->ipv4ll)
1276 log_link_debug(link, "ignoring IPv4LL for loopback link");
1278 if (network->dhcp != DHCP_SUPPORT_NONE)
1279 log_link_debug(link, "ignoring DHCP clients for loopback link");
1281 if (network->dhcp_server)
1282 log_link_debug(link, "ignoring DHCP server for loopback link");
1285 r = network_apply(link->manager, network, link);
1289 r = link_configure(link);
1296 int link_initialized(Link *link, struct udev_device *device) {
1297 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1301 assert(link->manager);
1302 assert(link->manager->rtnl);
1305 if (link->state != LINK_STATE_PENDING)
1308 if (link->udev_device)
1311 log_link_debug(link, "udev initialized link");
1313 link->udev_device = udev_device_ref(device);
1315 /* udev has initialized the link, but we don't know if we have yet
1316 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1317 * when it returns we know that the pending NEWLINKs have already been
1318 * processed and that we are up-to-date */
1320 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1325 r = sd_rtnl_call_async(link->manager->rtnl, req,
1326 link_initialized_and_synced, link, 0, NULL);
1335 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1336 Manager *m = userdata;
1339 _cleanup_address_free_ Address *address = NULL;
1341 char buf[INET6_ADDRSTRLEN];
1342 char valid_buf[FORMAT_TIMESPAN_MAX];
1343 const char *valid_str = NULL;
1344 bool address_dropped = false;
1351 if (sd_rtnl_message_is_error(message)) {
1352 r = sd_rtnl_message_get_errno(message);
1354 log_warning_errno(r, "rtnl: failed to receive address: %m");
1359 r = sd_rtnl_message_get_type(message, &type);
1361 log_warning("rtnl: could not get message type");
1365 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1367 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1369 } else if (ifindex <= 0) {
1370 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1373 r = link_get(m, ifindex, &link);
1374 if (r < 0 || !link) {
1375 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1380 r = address_new_dynamic(&address);
1384 r = sd_rtnl_message_addr_get_family(message, &address->family);
1385 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1386 log_link_warning(link,
1387 "rtnl: received address with invalid family, ignoring");
1391 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1393 log_link_warning(link,
1394 "rtnl: received address with invalid prefixlen, ignoring");
1398 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1400 log_link_warning(link,
1401 "rtnl: received address with invalid scope, ignoring");
1405 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1407 log_link_warning(link,
1408 "rtnl: received address with invalid flags, ignoring");
1412 switch (address->family) {
1414 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
1415 &address->in_addr.in);
1417 log_link_warning(link,
1418 "rtnl: received address without valid address, ignoring");
1425 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
1426 &address->in_addr.in6);
1428 log_link_warning(link,
1429 "rtnl: received address without valid address, ignoring");
1436 assert_not_reached("invalid address family");
1439 if (!inet_ntop(address->family, &address->in_addr, buf,
1440 INET6_ADDRSTRLEN)) {
1441 log_link_warning(link, "could not print address");
1445 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO,
1448 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1451 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1452 address->cinfo.ifa_valid * USEC_PER_SEC,
1456 LIST_FOREACH(addresses, ad, link->addresses) {
1457 if (address_equal(ad, address)) {
1458 LIST_REMOVE(addresses, link->addresses, ad);
1462 address_dropped = true;
1470 if (!address_dropped)
1471 log_link_debug(link, "added address: %s/%u (valid for %s)",
1472 buf, address->prefixlen, valid_str);
1474 log_link_debug(link, "updated address: %s/%u (valid for %s)",
1475 buf, address->prefixlen, valid_str);
1477 LIST_PREPEND(addresses, link->addresses, address);
1484 if (address_dropped) {
1485 log_link_debug(link, "removed address: %s/%u (valid for %s)",
1486 buf, address->prefixlen, valid_str);
1490 log_link_warning(link,
1491 "removing non-existent address: %s/%u (valid for %s)",
1492 buf, address->prefixlen, valid_str);
1496 assert_not_reached("Received invalid RTNL message type");
1502 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1504 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1505 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1513 r = link_new(m, message, ret);
1519 log_link_debug(link, "link %d added", link->ifindex);
1521 if (detect_container(NULL) <= 0) {
1522 /* not in a container, udev will be around */
1523 sprintf(ifindex_str, "n%d", link->ifindex);
1524 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1526 log_link_warning(link,
1527 "could not find udev device: %m");
1531 if (udev_device_get_is_initialized(device) <= 0) {
1533 log_link_debug(link, "link pending udev initialization...");
1537 r = link_initialized(link, device);
1541 /* we are calling a callback directly, so must take a ref */
1544 r = link_initialized_and_synced(m->rtnl, NULL, link);
1552 int link_update(Link *link, sd_rtnl_message *m) {
1553 struct ether_addr mac;
1556 bool had_carrier, carrier_gained, carrier_lost;
1560 assert(link->ifname);
1563 if (link->state == LINK_STATE_LINGER) {
1565 log_link_info(link, "link readded");
1566 link->state = LINK_STATE_ENSLAVING;
1569 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1570 if (r >= 0 && !streq(ifname, link->ifname)) {
1571 log_link_info(link, "renamed to %s", ifname);
1574 link->ifname = strdup(ifname);
1579 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1580 if (r >= 0 && mtu > 0) {
1582 if (!link->original_mtu) {
1583 link->original_mtu = mtu;
1584 log_link_debug(link, "saved original MTU: %"
1585 PRIu32, link->original_mtu);
1588 if (link->dhcp_client) {
1589 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1592 log_link_warning(link,
1593 "Could not update MTU in DHCP client: %s",
1600 /* The kernel may broadcast NEWLINK messages without the MAC address
1601 set, simply ignore them. */
1602 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1604 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1607 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1610 log_link_debug(link, "MAC address: "
1611 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1612 mac.ether_addr_octet[0],
1613 mac.ether_addr_octet[1],
1614 mac.ether_addr_octet[2],
1615 mac.ether_addr_octet[3],
1616 mac.ether_addr_octet[4],
1617 mac.ether_addr_octet[5]);
1620 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1622 log_link_warning(link,
1623 "Could not update MAC address in IPv4LL client: %s",
1629 if (link->dhcp_client) {
1630 r = sd_dhcp_client_set_mac(link->dhcp_client,
1631 (const uint8_t *) &link->mac,
1635 log_link_warning(link,
1636 "Could not update MAC address in DHCP client: %s",
1642 if (link->dhcp6_client) {
1643 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1644 (const uint8_t *) &link->mac,
1648 log_link_warning(link,
1649 "Could not update MAC address in DHCPv6 client: %s",
1657 had_carrier = link_has_carrier(link);
1659 r = link_update_flags(link, m);
1663 carrier_gained = !had_carrier && link_has_carrier(link);
1664 carrier_lost = had_carrier && !link_has_carrier(link);
1666 if (carrier_gained) {
1667 log_link_info(link, "gained carrier");
1669 if (link->network) {
1670 r = link_acquire_conf(link);
1672 link_enter_failed(link);
1676 } else if (carrier_lost) {
1677 log_link_info(link, "lost carrier");
1679 r = link_stop_clients(link);
1681 link_enter_failed(link);
1689 static void link_update_operstate(Link *link) {
1693 if (link->kernel_operstate == IF_OPER_DORMANT)
1694 link->operstate = LINK_OPERSTATE_DORMANT;
1695 else if (link_has_carrier(link)) {
1697 uint8_t scope = RT_SCOPE_NOWHERE;
1699 /* if we have carrier, check what addresses we have */
1700 LIST_FOREACH(addresses, address, link->addresses) {
1701 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1704 if (address->scope < scope)
1705 scope = address->scope;
1708 if (scope < RT_SCOPE_SITE)
1709 /* universally accessible addresses found */
1710 link->operstate = LINK_OPERSTATE_ROUTABLE;
1711 else if (scope < RT_SCOPE_HOST)
1712 /* only link or site local addresses found */
1713 link->operstate = LINK_OPERSTATE_DEGRADED;
1715 /* no useful addresses found */
1716 link->operstate = LINK_OPERSTATE_CARRIER;
1717 } else if (link->flags & IFF_UP)
1718 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1720 link->operstate = LINK_OPERSTATE_OFF;
1723 int link_save(Link *link) {
1724 _cleanup_free_ char *temp_path = NULL;
1725 _cleanup_fclose_ FILE *f = NULL;
1726 const char *admin_state, *oper_state;
1730 assert(link->state_file);
1731 assert(link->lease_file);
1732 assert(link->manager);
1734 link_update_operstate(link);
1736 r = manager_save(link->manager);
1740 if (link->state == LINK_STATE_LINGER) {
1741 unlink(link->state_file);
1745 admin_state = link_state_to_string(link->state);
1746 assert(admin_state);
1748 oper_state = link_operstate_to_string(link->operstate);
1751 r = fopen_temporary(link->state_file, &f, &temp_path);
1755 fchmod(fileno(f), 0644);
1758 "# This is private data. Do not parse.\n"
1761 admin_state, oper_state);
1763 if (link->network) {
1764 char **address, **domain;
1767 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1771 STRV_FOREACH(address, link->network->dns) {
1778 if (link->network->dhcp_dns &&
1780 const struct in_addr *addresses;
1782 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1786 serialize_in_addrs(f, addresses, r);
1794 STRV_FOREACH(address, link->network->ntp) {
1801 if (link->network->dhcp_ntp &&
1803 const struct in_addr *addresses;
1805 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1809 serialize_in_addrs(f, addresses, r);
1815 fprintf(f, "DOMAINS=");
1817 STRV_FOREACH(domain, link->network->domains) {
1824 if (link->network->dhcp_domains &&
1826 const char *domainname;
1828 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1832 fputs(domainname, f);
1838 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1839 yes_no(link->network->wildcard_domain));
1841 fprintf(f, "LLMNR=%s\n",
1842 llmnr_support_to_string(link->network->llmnr));
1845 if (link->dhcp_lease) {
1846 assert(link->network);
1848 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1856 unlink(link->lease_file);
1858 r = fflush_and_check(f);
1862 if (rename(temp_path, link->state_file) < 0) {
1869 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1870 unlink(link->state_file);
1875 static const char* const link_state_table[_LINK_STATE_MAX] = {
1876 [LINK_STATE_PENDING] = "pending",
1877 [LINK_STATE_ENSLAVING] = "configuring",
1878 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1879 [LINK_STATE_SETTING_ROUTES] = "configuring",
1880 [LINK_STATE_CONFIGURED] = "configured",
1881 [LINK_STATE_UNMANAGED] = "unmanaged",
1882 [LINK_STATE_FAILED] = "failed",
1883 [LINK_STATE_LINGER] = "linger",
1886 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1888 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1889 [LINK_OPERSTATE_OFF] = "off",
1890 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1891 [LINK_OPERSTATE_DORMANT] = "dormant",
1892 [LINK_OPERSTATE_CARRIER] = "carrier",
1893 [LINK_OPERSTATE_DEGRADED] = "degraded",
1894 [LINK_OPERSTATE_ROUTABLE] = "routable",
1897 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);