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>
30 #include "udev-util.h"
31 #include "libudev-private.h"
32 #include "network-internal.h"
33 #include "networkd-link.h"
34 #include "networkd-netdev.h"
35 #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, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
48 static bool link_dhcp4_enabled(Link *link) {
49 if (link->flags & IFF_LOOPBACK)
55 return IN_SET(link->network->dhcp, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
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 static bool link_ipv4_forward_enabled(Link *link) {
92 if (link->flags & IFF_LOOPBACK)
98 return IN_SET(link->network->ip_forward, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
101 static bool link_ipv6_forward_enabled(Link *link) {
102 if (link->flags & IFF_LOOPBACK)
108 return IN_SET(link->network->ip_forward, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
111 #define FLAG_STRING(string, flag, old, new) \
112 (((old ^ new) & flag) \
113 ? ((old & flag) ? (" -" string) : (" +" string)) \
116 static int link_update_flags(Link *link, sd_rtnl_message *m) {
117 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
123 r = sd_rtnl_message_link_get_flags(m, &flags);
125 log_link_warning(link, "Could not get link flags");
129 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
131 /* if we got a message without operstate, take it to mean
132 the state was unchanged */
133 operstate = link->kernel_operstate;
135 if ((link->flags == flags) && (link->kernel_operstate == operstate))
138 if (link->flags != flags) {
139 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",
140 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
141 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
142 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
143 FLAG_STRING("UP", IFF_UP, link->flags, flags),
144 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
145 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
146 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
147 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
148 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
149 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
150 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
151 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
152 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
153 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
154 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
155 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
156 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
157 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
158 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
160 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
161 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
162 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
163 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
164 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
165 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
166 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
167 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
169 /* link flags are currently at most 18 bits, let's align to
171 if (unknown_flags_added)
173 "unknown link flags gained: %#.5x (ignoring)",
174 unknown_flags_added);
176 if (unknown_flags_removed)
178 "unknown link flags lost: %#.5x (ignoring)",
179 unknown_flags_removed);
183 link->kernel_operstate = operstate;
190 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
191 _cleanup_link_unref_ Link *link = NULL;
200 r = sd_rtnl_message_get_type(message, &type);
203 else if (type != RTM_NEWLINK)
206 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
209 else if (ifindex <= 0)
212 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
216 link = new0(Link, 1);
221 link->manager = manager;
222 link->state = LINK_STATE_PENDING;
223 link->ifindex = ifindex;
224 link->ifname = strdup(ifname);
228 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
230 log_link_debug(link, "MAC address not found for new device, continuing without");
232 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
237 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
242 r = asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d",
248 r = hashmap_ensure_allocated(&manager->links, NULL);
252 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
256 r = link_update_flags(link, message);
266 static void link_free(Link *link) {
272 while ((address = link->addresses)) {
273 LIST_REMOVE(addresses, link->addresses, address);
274 address_free(address);
277 while ((address = link->pool_addresses)) {
278 LIST_REMOVE(addresses, link->pool_addresses, address);
279 address_free(address);
282 sd_dhcp_server_unref(link->dhcp_server);
283 sd_dhcp_client_unref(link->dhcp_client);
284 sd_dhcp_lease_unref(link->dhcp_lease);
286 free(link->lease_file);
288 sd_lldp_free(link->lldp);
290 free(link->lldp_file);
292 sd_ipv4ll_unref(link->ipv4ll);
293 sd_dhcp6_client_unref(link->dhcp6_client);
294 sd_icmp6_nd_unref(link->icmp6_router_discovery);
297 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
301 free(link->state_file);
303 udev_device_unref(link->udev_device);
308 Link *link_unref(Link *link) {
309 if (link && (-- link->n_ref <= 0))
315 Link *link_ref(Link *link) {
317 assert_se(++ link->n_ref >= 2);
322 int link_get(Manager *m, int ifindex, Link **ret) {
329 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
338 static void link_set_state(Link *link, LinkState state) {
341 if (link->state == state)
346 link_send_changed(link, "AdministrativeState", NULL);
351 void link_drop(Link *link) {
352 if (!link || link->state == LINK_STATE_LINGER)
355 link_set_state(link, LINK_STATE_LINGER);
357 log_link_debug(link, "link removed");
364 static void link_enter_unmanaged(Link *link) {
367 log_link_debug(link, "unmanaged");
369 link_set_state(link, LINK_STATE_UNMANAGED);
374 static int link_stop_clients(Link *link) {
378 assert(link->manager);
379 assert(link->manager->event);
384 if (link->dhcp_client) {
385 k = sd_dhcp_client_stop(link->dhcp_client);
387 log_link_warning(link, "Could not stop DHCPv4 client: %s",
394 k = sd_ipv4ll_stop(link->ipv4ll);
396 log_link_warning(link, "Could not stop IPv4 link-local: %s",
402 if(link->icmp6_router_discovery) {
404 if (link->dhcp6_client) {
405 k = sd_dhcp6_client_stop(link->dhcp6_client);
407 log_link_warning(link, "Could not stop DHCPv6 client: %s",
413 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
415 log_link_warning(link,
416 "Could not stop ICMPv6 router discovery: %s",
424 k = sd_lldp_stop(link->lldp);
426 log_link_warning(link, "Could not stop LLDP : %s",
435 void link_enter_failed(Link *link) {
438 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
441 log_link_warning(link, "failed");
443 link_set_state(link, LINK_STATE_FAILED);
445 link_stop_clients(link);
450 static Address* link_find_dhcp_server_address(Link *link) {
454 assert(link->network);
456 /* The first statically configured address if there is any */
457 LIST_FOREACH(addresses, address, link->network->static_addresses) {
459 if (address->family != AF_INET)
462 if (in_addr_is_null(address->family, &address->in_addr))
468 /* If that didn't work, find a suitable address we got from the pool */
469 LIST_FOREACH(addresses, address, link->pool_addresses) {
470 if (address->family != AF_INET)
479 static int link_enter_configured(Link *link) {
481 assert(link->network);
482 assert(link->state == LINK_STATE_SETTING_ROUTES);
484 log_link_info(link, "link configured");
486 link_set_state(link, LINK_STATE_CONFIGURED);
493 void link_client_handler(Link *link) {
495 assert(link->network);
497 if (!link->static_configured)
500 if (link_ipv4ll_enabled(link))
501 if (!link->ipv4ll_address ||
505 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
508 if (link->state != LINK_STATE_CONFIGURED)
509 link_enter_configured(link);
514 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
515 _cleanup_link_unref_ Link *link = userdata;
518 assert(link->link_messages > 0);
519 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
520 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
523 link->link_messages --;
525 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
528 r = sd_rtnl_message_get_errno(m);
529 if (r < 0 && r != -EEXIST)
530 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
532 if (link->link_messages == 0) {
533 log_link_debug(link, "routes set");
534 link->static_configured = true;
535 link_client_handler(link);
541 static int link_enter_set_routes(Link *link) {
546 assert(link->network);
547 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
549 link_set_state(link, LINK_STATE_SETTING_ROUTES);
551 LIST_FOREACH(routes, rt, link->network->static_routes) {
552 r = route_configure(rt, link, &route_handler);
554 log_link_warning(link,
555 "could not set routes: %s",
557 link_enter_failed(link);
561 link->link_messages ++;
564 if (link->link_messages == 0) {
565 link->static_configured = true;
566 link_client_handler(link);
568 log_link_debug(link, "setting routes");
573 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
574 _cleanup_link_unref_ Link *link = userdata;
579 assert(link->ifname);
581 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
584 r = sd_rtnl_message_get_errno(m);
585 if (r < 0 && r != -ESRCH)
586 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
591 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
592 _cleanup_link_unref_ Link *link = userdata;
598 assert(link->ifname);
599 assert(link->link_messages > 0);
600 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
601 LINK_STATE_FAILED, LINK_STATE_LINGER));
603 link->link_messages --;
605 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
608 r = sd_rtnl_message_get_errno(m);
609 if (r < 0 && r != -EEXIST)
610 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
612 link_rtnl_process_address(rtnl, m, link->manager);
614 if (link->link_messages == 0) {
615 log_link_debug(link, "addresses set");
616 link_enter_set_routes(link);
622 static int link_enter_set_addresses(Link *link) {
627 assert(link->network);
628 assert(link->state != _LINK_STATE_INVALID);
630 link_set_state(link, LINK_STATE_SETTING_ADDRESSES);
632 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
633 r = address_configure(ad, link, &address_handler);
635 log_link_warning_errno(link, r, "Could not set addresses: %m");
636 link_enter_failed(link);
640 link->link_messages ++;
643 /* now that we can figure out a default address for the dhcp server,
645 if (link_dhcp4_server_enabled(link)) {
646 struct in_addr pool_start;
649 address = link_find_dhcp_server_address(link);
651 log_link_warning(link,
652 "Failed to find suitable address for DHCPv4 server instance.");
653 link_enter_failed(link);
657 r = sd_dhcp_server_set_address(link->dhcp_server,
658 &address->in_addr.in,
663 /* offer 32 addresses starting from the address following the server address */
664 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
665 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
671 r = sd_dhcp_server_set_router(link->dhcp_server,
672 &main_address->in_addr.in);
676 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
677 main_address->prefixlen);
682 r = sd_dhcp_server_start(link->dhcp_server);
684 log_link_warning(link, "could not start DHCPv4 server "
685 "instance: %s", strerror(-r));
687 link_enter_failed(link);
692 log_link_debug(link, "offering DHCPv4 leases");
695 if (link->link_messages == 0) {
696 link_enter_set_routes(link);
698 log_link_debug(link, "setting addresses");
703 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
704 _cleanup_link_unref_ Link *link = userdata;
709 assert(link->ifname);
711 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
714 r = sd_rtnl_message_get_errno(m);
715 if (r < 0 && r != -EADDRNOTAVAIL)
716 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
721 static int link_set_bridge_fdb(const Link *const link) {
725 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
726 r = fdb_entry_configure(link->manager->rtnl, fdb_entry, link->ifindex);
728 log_link_error(link, "Failed to add MAC entry to static MAC table: %s", strerror(-r));
736 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
737 _cleanup_link_unref_ Link *link = userdata;
740 log_link_debug(link, "set link");
742 r = sd_rtnl_message_get_errno(m);
743 if (r < 0 && r != -EEXIST) {
744 log_link_struct(link, LOG_ERR,
745 "MESSAGE=%-*s: could not join netdev: %s",
747 link->ifname, strerror(-r),
750 link_enter_failed(link);
757 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
758 sd_bus_error *ret_error) {
759 _cleanup_link_unref_ Link *link = userdata;
764 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
767 r = sd_bus_message_get_errno(m);
769 log_link_warning(link, "Could not set hostname: %s",
775 int link_set_hostname(Link *link, const char *hostname) {
776 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
780 assert(link->manager);
783 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
785 if (!link->manager->bus) {
786 /* TODO: replace by assert when we can rely on kdbus */
788 "Not connected to system bus, ignoring transient hostname.");
792 r = sd_bus_message_new_method_call(
795 "org.freedesktop.hostname1",
796 "/org/freedesktop/hostname1",
797 "org.freedesktop.hostname1",
802 r = sd_bus_message_append(m, "sb", hostname, false);
806 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
809 log_link_error(link, "Could not set transient hostname: %s",
819 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
820 _cleanup_link_unref_ Link *link = userdata;
825 assert(link->ifname);
827 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
830 r = sd_rtnl_message_get_errno(m);
832 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
837 int link_set_mtu(Link *link, uint32_t mtu) {
838 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
842 assert(link->manager);
843 assert(link->manager->rtnl);
845 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
847 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
848 RTM_SETLINK, link->ifindex);
850 log_link_error(link, "Could not allocate RTM_SETLINK message");
854 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
856 log_link_error(link, "Could not append MTU: %s", strerror(-r));
860 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
864 "Could not send rtnetlink message: %s",
874 static int link_set_bridge(Link *link) {
875 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
879 assert(link->network);
881 if(link->network->cost == 0)
884 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
885 RTM_SETLINK, link->ifindex);
887 log_link_error(link, "Could not allocate RTM_SETLINK message");
891 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
894 "Could not set message family %s", strerror(-r));
898 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
901 "Could not append IFLA_PROTINFO attribute: %s",
906 if(link->network->cost != 0) {
907 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
910 "Could not append IFLA_BRPORT_COST attribute: %s",
916 r = sd_rtnl_message_close_container(req);
919 "Could not append IFLA_LINKINFO attribute: %s",
924 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
927 "Could not send rtnetlink message: %s",
937 static void lldp_handler(sd_lldp *lldp, int event, void *userdata) {
938 Link *link = userdata;
942 assert(link->network);
943 assert(link->manager);
945 if (event != UPDATE_INFO)
948 r = sd_lldp_save(link->lldp, link->lldp_file);
950 log_link_warning(link, "could not save LLDP");
954 static int link_acquire_conf(Link *link) {
958 assert(link->network);
959 assert(link->manager);
960 assert(link->manager->event);
962 if (link_ipv4ll_enabled(link)) {
963 assert(link->ipv4ll);
965 log_link_debug(link, "acquiring IPv4 link-local address");
967 r = sd_ipv4ll_start(link->ipv4ll);
969 log_link_warning(link, "could not acquire IPv4 "
970 "link-local address");
975 if (link_dhcp4_enabled(link)) {
976 assert(link->dhcp_client);
978 log_link_debug(link, "acquiring DHCPv4 lease");
980 r = sd_dhcp_client_start(link->dhcp_client);
982 log_link_warning(link, "could not acquire DHCPv4 "
988 if (link_dhcp6_enabled(link)) {
989 assert(link->icmp6_router_discovery);
991 log_link_debug(link, "discovering IPv6 routers");
993 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
995 log_link_warning(link,
996 "could not start IPv6 router discovery");
1001 if (link_lldp_enabled(link)) {
1004 log_link_debug(link, "Starting LLDP");
1006 r = sd_lldp_start(link->lldp);
1008 log_link_warning(link, "could not start LLDP ");
1016 bool link_has_carrier(Link *link) {
1017 /* see Documentation/networking/operstates.txt in the kernel sources */
1019 if (link->kernel_operstate == IF_OPER_UP)
1022 if (link->kernel_operstate == IF_OPER_UNKNOWN)
1023 /* operstate may not be implemented, so fall back to flags */
1024 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1030 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1031 _cleanup_link_unref_ Link *link = userdata;
1036 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1039 r = sd_rtnl_message_get_errno(m);
1041 /* we warn but don't fail the link, as it may
1042 be brought up later */
1043 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
1049 static int link_up(Link *link) {
1050 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1054 assert(link->network);
1055 assert(link->manager);
1056 assert(link->manager->rtnl);
1058 log_link_debug(link, "bringing link up");
1060 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1061 RTM_SETLINK, link->ifindex);
1063 log_link_error(link, "Could not allocate RTM_SETLINK message");
1067 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1069 log_link_error(link, "Could not set link flags: %s",
1074 if (link->network->mac) {
1075 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1077 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
1082 if (link->network->mtu) {
1083 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
1085 log_link_error(link, "Could not set MTU: %s", strerror(-r));
1090 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1093 log_link_error(link,
1094 "Could not send rtnetlink message: %s",
1104 static int link_joined(Link *link) {
1108 assert(link->network);
1110 if (!(link->flags & IFF_UP)) {
1113 link_enter_failed(link);
1118 if(link->network->bridge) {
1119 r = link_set_bridge(link);
1121 log_link_error(link,
1122 "Could not set bridge message: %s",
1127 return link_enter_set_addresses(link);
1130 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1132 _cleanup_link_unref_ Link *link = userdata;
1136 assert(link->network);
1140 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1143 r = sd_rtnl_message_get_errno(m);
1144 if (r < 0 && r != -EEXIST) {
1145 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1146 link_enter_failed(link);
1149 log_link_debug(link, "joined netdev");
1151 if (link->enslaving <= 0)
1157 static int link_enter_join_netdev(Link *link) {
1163 assert(link->network);
1164 assert(link->state == LINK_STATE_PENDING);
1166 link_set_state(link, LINK_STATE_ENSLAVING);
1170 if (!link->network->bridge &&
1171 !link->network->bond &&
1172 hashmap_isempty(link->network->stacked_netdevs))
1173 return link_joined(link);
1175 if (link->network->bond) {
1176 log_link_struct(link, LOG_DEBUG,
1177 "MESSAGE=%-*s: enslaving by '%s'",
1179 link->ifname, link->network->bond->ifname,
1180 NETDEVIF(link->network->bond),
1183 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1185 log_link_struct(link, LOG_WARNING,
1186 "MESSAGE=%-*s: could not join netdev '%s': %s",
1188 link->ifname, link->network->bond->ifname,
1190 NETDEVIF(link->network->bond),
1192 link_enter_failed(link);
1199 if (link->network->bridge) {
1200 log_link_struct(link, LOG_DEBUG,
1201 "MESSAGE=%-*s: enslaving by '%s'",
1203 link->ifname, link->network->bridge->ifname,
1204 NETDEVIF(link->network->bridge),
1207 r = netdev_join(link->network->bridge, link,
1208 &netdev_join_handler);
1210 log_link_struct(link, LOG_WARNING,
1211 "MESSAGE=%-*s: could not join netdev '%s': %s",
1213 link->ifname, link->network->bridge->ifname,
1215 NETDEVIF(link->network->bridge),
1217 link_enter_failed(link);
1224 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1225 log_link_struct(link, LOG_DEBUG,
1226 "MESSAGE=%-*s: enslaving by '%s'",
1228 link->ifname, netdev->ifname, NETDEVIF(netdev),
1231 r = netdev_join(netdev, link, &netdev_join_handler);
1233 log_link_struct(link, LOG_WARNING,
1234 "MESSAGE=%-*s: could not join netdev '%s': %s",
1236 link->ifname, netdev->ifname,
1238 NETDEVIF(netdev), NULL);
1239 link_enter_failed(link);
1249 static int link_set_ipv4_forward(Link *link) {
1250 const char *p = NULL;
1254 b = link_ipv4_forward_enabled(link);
1256 p = strjoina("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
1257 r = write_string_file_no_create(p, one_zero(b));
1259 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
1262 _cleanup_free_ char *buf = NULL;
1264 /* If IP forwarding is turned on for this interface,
1265 * then propagate this to the global setting. Given
1266 * that turning this on has side-effects on other
1267 * fields, we'll try to avoid doing this unless
1268 * necessary, hence check the previous value
1269 * first. Note that we never turn this option off
1270 * again, since all interfaces we manage do not do
1271 * forwarding anyway by default, and ownership rules
1272 * of this control are so unclear. */
1274 r = read_one_line_file("/proc/sys/net/ipv4/ip_forward", &buf);
1276 log_link_warning_errno(link, r, "Cannot read /proc/sys/net/ipv4/ip_forward: %m");
1277 else if (!streq(buf, "1")) {
1278 r = write_string_file_no_create("/proc/sys/net/ipv4/ip_forward", "1");
1280 log_link_warning_errno(link, r, "Cannot write /proc/sys/net/ipv4/ip_forward: %m");
1287 static int link_set_ipv6_forward(Link *link) {
1288 const char *p = NULL;
1291 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
1292 r = write_string_file_no_create(p, one_zero(link_ipv6_forward_enabled(link)));
1294 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
1299 static int link_configure(Link *link) {
1303 assert(link->network);
1304 assert(link->state == LINK_STATE_PENDING);
1306 r = link_set_bridge_fdb(link);
1310 r = link_set_ipv4_forward(link);
1314 r = link_set_ipv6_forward(link);
1318 if (link_ipv4ll_enabled(link)) {
1319 r = ipv4ll_configure(link);
1324 if (link_dhcp4_enabled(link)) {
1325 r = dhcp4_configure(link);
1330 if (link_dhcp4_server_enabled(link)) {
1331 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1335 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1340 if (link_dhcp6_enabled(link)) {
1341 r = icmp6_configure(link);
1346 if (link_lldp_enabled(link)) {
1347 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1351 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1355 r = sd_lldp_set_callback(link->lldp,
1356 lldp_handler, link);
1361 if (link_has_carrier(link)) {
1362 r = link_acquire_conf(link);
1367 return link_enter_join_netdev(link);
1370 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1372 _cleanup_link_unref_ Link *link = userdata;
1377 assert(link->ifname);
1378 assert(link->manager);
1380 if (link->state != LINK_STATE_PENDING)
1383 log_link_debug(link, "link state is up-to-date");
1385 r = network_get(link->manager, link->udev_device, link->ifname,
1386 &link->mac, &network);
1388 link_enter_unmanaged(link);
1393 if (link->flags & IFF_LOOPBACK) {
1394 if (network->ipv4ll)
1395 log_link_debug(link, "ignoring IPv4LL for loopback link");
1397 if (network->dhcp != ADDRESS_FAMILY_NO)
1398 log_link_debug(link, "ignoring DHCP clients for loopback link");
1400 if (network->dhcp_server)
1401 log_link_debug(link, "ignoring DHCP server for loopback link");
1404 r = network_apply(link->manager, network, link);
1408 r = link_configure(link);
1415 int link_initialized(Link *link, struct udev_device *device) {
1416 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1420 assert(link->manager);
1421 assert(link->manager->rtnl);
1424 if (link->state != LINK_STATE_PENDING)
1427 if (link->udev_device)
1430 log_link_debug(link, "udev initialized link");
1432 link->udev_device = udev_device_ref(device);
1434 /* udev has initialized the link, but we don't know if we have yet
1435 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1436 * when it returns we know that the pending NEWLINKs have already been
1437 * processed and that we are up-to-date */
1439 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1444 r = sd_rtnl_call_async(link->manager->rtnl, req,
1445 link_initialized_and_synced, link, 0, NULL);
1454 static Address* link_get_equal_address(Link *link, Address *needle) {
1460 LIST_FOREACH(addresses, i, link->addresses)
1461 if (address_equal(i, needle))
1467 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1468 Manager *m = userdata;
1471 _cleanup_address_free_ Address *address = NULL;
1473 char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
1474 const char *valid_str = NULL;
1481 if (sd_rtnl_message_is_error(message)) {
1482 r = sd_rtnl_message_get_errno(message);
1484 log_warning_errno(r, "rtnl: failed to receive address: %m");
1489 r = sd_rtnl_message_get_type(message, &type);
1491 log_warning("rtnl: could not get message type");
1495 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1497 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1499 } else if (ifindex <= 0) {
1500 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1503 r = link_get(m, ifindex, &link);
1504 if (r < 0 || !link) {
1505 /* when enumerating we might be out of sync, but we will
1506 * get the address again, so just ignore it */
1507 if (!m->enumerating)
1508 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1513 r = address_new_dynamic(&address);
1517 r = sd_rtnl_message_addr_get_family(message, &address->family);
1518 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1519 log_link_warning(link, "rtnl: received address with invalid family, ignoring");
1523 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1525 log_link_warning(link, "rtnl: received address with invalid prefixlen, ignoring");
1529 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1531 log_link_warning(link, "rtnl: received address with invalid scope, ignoring");
1535 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1537 log_link_warning(link, "rtnl: received address with invalid flags, ignoring");
1541 switch (address->family) {
1543 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1545 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1552 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1554 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1561 assert_not_reached("invalid address family");
1564 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1565 log_link_warning(link, "could not print address");
1569 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1571 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1574 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1575 address->cinfo.ifa_valid * USEC_PER_SEC,
1579 existing = link_get_equal_address(link, address);
1584 log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1587 existing->scope = address->scope;
1588 existing->flags = address->flags;
1589 existing->cinfo = address->cinfo;
1592 log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1594 LIST_PREPEND(addresses, link->addresses, address);
1595 address_establish(address, link);
1607 log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1608 address_release(existing, link);
1609 LIST_REMOVE(addresses, link->addresses, existing);
1610 address_free(existing);
1612 log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1616 assert_not_reached("Received invalid RTNL message type");
1622 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1624 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1625 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1633 r = link_new(m, message, ret);
1639 log_link_debug(link, "link %d added", link->ifindex);
1641 if (detect_container(NULL) <= 0) {
1642 /* not in a container, udev will be around */
1643 sprintf(ifindex_str, "n%d", link->ifindex);
1644 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1646 log_link_warning(link,
1647 "could not find udev device: %m");
1651 if (udev_device_get_is_initialized(device) <= 0) {
1653 log_link_debug(link, "link pending udev initialization...");
1657 r = link_initialized(link, device);
1661 /* we are calling a callback directly, so must take a ref */
1664 r = link_initialized_and_synced(m->rtnl, NULL, link);
1672 static int link_carrier_gained(Link *link) {
1677 if (link->network) {
1678 r = link_acquire_conf(link);
1680 link_enter_failed(link);
1688 static int link_carrier_lost(Link *link) {
1693 r = link_stop_clients(link);
1695 link_enter_failed(link);
1702 int link_carrier_reset(Link *link) {
1707 if (link_has_carrier(link)) {
1708 r = link_carrier_lost(link);
1712 r = link_carrier_gained(link);
1716 log_link_info(link, "reset carrier");
1723 int link_update(Link *link, sd_rtnl_message *m) {
1724 struct ether_addr mac;
1727 bool had_carrier, carrier_gained, carrier_lost;
1731 assert(link->ifname);
1734 if (link->state == LINK_STATE_LINGER) {
1736 log_link_info(link, "link readded");
1737 link_set_state(link, LINK_STATE_ENSLAVING);
1740 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1741 if (r >= 0 && !streq(ifname, link->ifname)) {
1742 log_link_info(link, "renamed to %s", ifname);
1745 link->ifname = strdup(ifname);
1750 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1751 if (r >= 0 && mtu > 0) {
1753 if (!link->original_mtu) {
1754 link->original_mtu = mtu;
1755 log_link_debug(link, "saved original MTU: %"
1756 PRIu32, link->original_mtu);
1759 if (link->dhcp_client) {
1760 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1763 log_link_warning(link,
1764 "Could not update MTU in DHCP client: %s",
1771 /* The kernel may broadcast NEWLINK messages without the MAC address
1772 set, simply ignore them. */
1773 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1775 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1778 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1781 log_link_debug(link, "MAC address: "
1782 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1783 mac.ether_addr_octet[0],
1784 mac.ether_addr_octet[1],
1785 mac.ether_addr_octet[2],
1786 mac.ether_addr_octet[3],
1787 mac.ether_addr_octet[4],
1788 mac.ether_addr_octet[5]);
1791 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1793 log_link_warning(link,
1794 "Could not update MAC address in IPv4LL client: %s",
1800 if (link->dhcp_client) {
1801 r = sd_dhcp_client_set_mac(link->dhcp_client,
1802 (const uint8_t *) &link->mac,
1806 log_link_warning(link,
1807 "Could not update MAC address in DHCP client: %s",
1813 if (link->dhcp6_client) {
1814 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1815 (const uint8_t *) &link->mac,
1819 log_link_warning(link,
1820 "Could not update MAC address in DHCPv6 client: %s",
1828 had_carrier = link_has_carrier(link);
1830 r = link_update_flags(link, m);
1834 carrier_gained = !had_carrier && link_has_carrier(link);
1835 carrier_lost = had_carrier && !link_has_carrier(link);
1837 if (carrier_gained) {
1838 log_link_info(link, "gained carrier");
1840 r = link_carrier_gained(link);
1843 } else if (carrier_lost) {
1844 log_link_info(link, "lost carrier");
1846 r = link_carrier_lost(link);
1855 static void link_update_operstate(Link *link) {
1856 LinkOperationalState operstate;
1859 if (link->kernel_operstate == IF_OPER_DORMANT)
1860 operstate = LINK_OPERSTATE_DORMANT;
1861 else if (link_has_carrier(link)) {
1863 uint8_t scope = RT_SCOPE_NOWHERE;
1865 /* if we have carrier, check what addresses we have */
1866 LIST_FOREACH(addresses, address, link->addresses) {
1867 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1870 if (address->scope < scope)
1871 scope = address->scope;
1874 if (scope < RT_SCOPE_SITE)
1875 /* universally accessible addresses found */
1876 operstate = LINK_OPERSTATE_ROUTABLE;
1877 else if (scope < RT_SCOPE_HOST)
1878 /* only link or site local addresses found */
1879 operstate = LINK_OPERSTATE_DEGRADED;
1881 /* no useful addresses found */
1882 operstate = LINK_OPERSTATE_CARRIER;
1883 } else if (link->flags & IFF_UP)
1884 operstate = LINK_OPERSTATE_NO_CARRIER;
1886 operstate = LINK_OPERSTATE_OFF;
1888 if (link->operstate != operstate) {
1889 link->operstate = operstate;
1890 link_send_changed(link, "OperationalState", NULL);
1894 int link_save(Link *link) {
1895 _cleanup_free_ char *temp_path = NULL;
1896 _cleanup_fclose_ FILE *f = NULL;
1897 const char *admin_state, *oper_state;
1901 assert(link->state_file);
1902 assert(link->lease_file);
1903 assert(link->manager);
1905 link_update_operstate(link);
1907 r = manager_save(link->manager);
1911 if (link->state == LINK_STATE_LINGER) {
1912 unlink(link->state_file);
1916 admin_state = link_state_to_string(link->state);
1917 assert(admin_state);
1919 oper_state = link_operstate_to_string(link->operstate);
1922 r = fopen_temporary(link->state_file, &f, &temp_path);
1926 fchmod(fileno(f), 0644);
1929 "# This is private data. Do not parse.\n"
1932 admin_state, oper_state);
1934 if (link->network) {
1935 char **address, **domain;
1938 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1942 STRV_FOREACH(address, link->network->dns) {
1949 if (link->network->dhcp_dns &&
1951 const struct in_addr *addresses;
1953 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1957 serialize_in_addrs(f, addresses, r);
1965 STRV_FOREACH(address, link->network->ntp) {
1972 if (link->network->dhcp_ntp &&
1974 const struct in_addr *addresses;
1976 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1980 serialize_in_addrs(f, addresses, r);
1986 fprintf(f, "DOMAINS=");
1988 STRV_FOREACH(domain, link->network->domains) {
1995 if (link->network->dhcp_domains &&
1997 const char *domainname;
1999 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
2003 fputs(domainname, f);
2009 fprintf(f, "WILDCARD_DOMAIN=%s\n",
2010 yes_no(link->network->wildcard_domain));
2012 fprintf(f, "LLMNR=%s\n",
2013 llmnr_support_to_string(link->network->llmnr));
2016 if (link->dhcp_lease) {
2017 assert(link->network);
2019 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
2027 unlink(link->lease_file);
2030 assert(link->network);
2032 r = sd_lldp_save(link->lldp, link->lldp_file);
2040 unlink(link->lldp_file);
2042 r = fflush_and_check(f);
2046 if (rename(temp_path, link->state_file) < 0) {
2053 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2054 unlink(link->state_file);
2059 static const char* const link_state_table[_LINK_STATE_MAX] = {
2060 [LINK_STATE_PENDING] = "pending",
2061 [LINK_STATE_ENSLAVING] = "configuring",
2062 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2063 [LINK_STATE_SETTING_ROUTES] = "configuring",
2064 [LINK_STATE_CONFIGURED] = "configured",
2065 [LINK_STATE_UNMANAGED] = "unmanaged",
2066 [LINK_STATE_FAILED] = "failed",
2067 [LINK_STATE_LINGER] = "linger",
2070 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2072 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2073 [LINK_OPERSTATE_OFF] = "off",
2074 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2075 [LINK_OPERSTATE_DORMANT] = "dormant",
2076 [LINK_OPERSTATE_CARRIER] = "carrier",
2077 [LINK_OPERSTATE_DEGRADED] = "degraded",
2078 [LINK_OPERSTATE_ROUTABLE] = "routable",
2081 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);