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 unlink(link->lease_file);
287 free(link->lease_file);
289 sd_lldp_free(link->lldp);
291 unlink(link->lldp_file);
292 free(link->lldp_file);
294 sd_ipv4ll_unref(link->ipv4ll);
295 sd_dhcp6_client_unref(link->dhcp6_client);
296 sd_icmp6_nd_unref(link->icmp6_router_discovery);
299 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
303 unlink(link->state_file);
304 free(link->state_file);
306 udev_device_unref(link->udev_device);
311 Link *link_unref(Link *link) {
312 if (link && (-- link->n_ref <= 0))
318 Link *link_ref(Link *link) {
320 assert_se(++ link->n_ref >= 2);
325 int link_get(Manager *m, int ifindex, Link **ret) {
332 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
341 void link_drop(Link *link) {
342 if (!link || link->state == LINK_STATE_LINGER)
345 link->state = LINK_STATE_LINGER;
347 log_link_debug(link, "link removed");
354 static void link_enter_unmanaged(Link *link) {
357 log_link_debug(link, "unmanaged");
359 link->state = LINK_STATE_UNMANAGED;
364 static int link_stop_clients(Link *link) {
368 assert(link->manager);
369 assert(link->manager->event);
374 if (link->dhcp_client) {
375 k = sd_dhcp_client_stop(link->dhcp_client);
377 log_link_warning(link, "Could not stop DHCPv4 client: %s",
384 k = sd_ipv4ll_stop(link->ipv4ll);
386 log_link_warning(link, "Could not stop IPv4 link-local: %s",
392 if(link->icmp6_router_discovery) {
394 if (link->dhcp6_client) {
395 k = sd_dhcp6_client_stop(link->dhcp6_client);
397 log_link_warning(link, "Could not stop DHCPv6 client: %s",
403 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
405 log_link_warning(link,
406 "Could not stop ICMPv6 router discovery: %s",
414 k = sd_lldp_stop(link->lldp);
416 log_link_warning(link, "Could not stop LLDP : %s",
425 void link_enter_failed(Link *link) {
428 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
431 log_link_warning(link, "failed");
433 link->state = LINK_STATE_FAILED;
435 link_stop_clients(link);
440 static Address* link_find_dhcp_server_address(Link *link) {
444 assert(link->network);
446 /* The the first statically configured address if there is any */
447 LIST_FOREACH(addresses, address, link->network->static_addresses) {
449 if (address->family != AF_INET)
452 if (in_addr_is_null(address->family, &address->in_addr))
458 /* If that didn't work, find a suitable address we got from the pool */
459 LIST_FOREACH(addresses, address, link->pool_addresses) {
460 if (address->family != AF_INET)
469 static int link_enter_configured(Link *link) {
473 assert(link->network);
474 assert(link->state == LINK_STATE_SETTING_ROUTES);
476 if (link_dhcp4_server_enabled(link) &&
477 !sd_dhcp_server_is_running(link->dhcp_server)) {
478 struct in_addr pool_start;
481 address = link_find_dhcp_server_address(link);
483 log_link_warning(link,
484 "Failed to find suitable address for DHCPv4 server instance.");
485 link_enter_failed(link);
489 log_link_debug(link, "offering DHCPv4 leases");
491 r = sd_dhcp_server_set_address(link->dhcp_server,
492 &address->in_addr.in,
497 /* offer 32 addresses starting from the address following the server address */
498 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
499 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
505 r = sd_dhcp_server_set_router(link->dhcp_server,
506 &main_address->in_addr.in);
510 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
511 main_address->prefixlen);
516 r = sd_dhcp_server_start(link->dhcp_server);
518 log_link_warning(link, "could not start DHCPv4 server "
519 "instance: %s", strerror(-r));
521 link_enter_failed(link);
527 log_link_info(link, "link configured");
529 link->state = LINK_STATE_CONFIGURED;
536 void link_client_handler(Link *link) {
538 assert(link->network);
540 if (!link->static_configured)
543 if (link_ipv4ll_enabled(link))
544 if (!link->ipv4ll_address ||
548 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
551 if (link->state != LINK_STATE_CONFIGURED)
552 link_enter_configured(link);
557 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
558 _cleanup_link_unref_ Link *link = userdata;
561 assert(link->link_messages > 0);
562 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
563 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
566 link->link_messages --;
568 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
571 r = sd_rtnl_message_get_errno(m);
572 if (r < 0 && r != -EEXIST)
573 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
575 if (link->link_messages == 0) {
576 log_link_debug(link, "routes set");
577 link->static_configured = true;
578 link_client_handler(link);
584 static int link_enter_set_routes(Link *link) {
589 assert(link->network);
590 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
592 link->state = LINK_STATE_SETTING_ROUTES;
594 LIST_FOREACH(routes, rt, link->network->static_routes) {
595 r = route_configure(rt, link, &route_handler);
597 log_link_warning(link,
598 "could not set routes: %s",
600 link_enter_failed(link);
604 link->link_messages ++;
607 if (link->link_messages == 0) {
608 link->static_configured = true;
609 link_client_handler(link);
611 log_link_debug(link, "setting routes");
616 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
617 _cleanup_link_unref_ Link *link = userdata;
622 assert(link->ifname);
624 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
627 r = sd_rtnl_message_get_errno(m);
628 if (r < 0 && r != -ESRCH)
629 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
634 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
635 _cleanup_link_unref_ Link *link = userdata;
641 assert(link->ifname);
642 assert(link->link_messages > 0);
643 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
644 LINK_STATE_FAILED, LINK_STATE_LINGER));
646 link->link_messages --;
648 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
651 r = sd_rtnl_message_get_errno(m);
652 if (r < 0 && r != -EEXIST)
653 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
655 link_rtnl_process_address(rtnl, m, link->manager);
657 if (link->link_messages == 0) {
658 log_link_debug(link, "addresses set");
659 link_enter_set_routes(link);
665 static int link_enter_set_addresses(Link *link) {
670 assert(link->network);
671 assert(link->state != _LINK_STATE_INVALID);
673 link->state = LINK_STATE_SETTING_ADDRESSES;
675 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
676 r = address_configure(ad, link, &address_handler);
678 log_link_warning_errno(link, r, "Could not set addresses: %m");
679 link_enter_failed(link);
683 link->link_messages ++;
686 if (link->link_messages == 0) {
687 link_enter_set_routes(link);
689 log_link_debug(link, "setting addresses");
694 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
695 _cleanup_link_unref_ Link *link = userdata;
700 assert(link->ifname);
702 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
705 r = sd_rtnl_message_get_errno(m);
706 if (r < 0 && r != -EADDRNOTAVAIL)
707 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
712 static int link_set_bridge_fdb(const Link *const link) {
716 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
717 r = fdb_entry_configure(link->manager->rtnl, fdb_entry, link->ifindex);
719 log_link_error(link, "Failed to add MAC entry to static MAC table: %s", strerror(-r));
727 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
728 _cleanup_link_unref_ Link *link = userdata;
731 log_link_debug(link, "set link");
733 r = sd_rtnl_message_get_errno(m);
734 if (r < 0 && r != -EEXIST) {
735 log_link_struct(link, LOG_ERR,
736 "MESSAGE=%-*s: could not join netdev: %s",
738 link->ifname, strerror(-r),
741 link_enter_failed(link);
748 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
749 sd_bus_error *ret_error) {
750 _cleanup_link_unref_ Link *link = userdata;
755 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
758 r = sd_bus_message_get_errno(m);
760 log_link_warning(link, "Could not set hostname: %s",
766 int link_set_hostname(Link *link, const char *hostname) {
767 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
771 assert(link->manager);
774 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
776 if (!link->manager->bus) {
777 /* TODO: replace by assert when we can rely on kdbus */
779 "Not connected to system bus, ignoring transient hostname.");
783 r = sd_bus_message_new_method_call(
786 "org.freedesktop.hostname1",
787 "/org/freedesktop/hostname1",
788 "org.freedesktop.hostname1",
793 r = sd_bus_message_append(m, "sb", hostname, false);
797 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
800 log_link_error(link, "Could not set transient hostname: %s",
810 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
811 _cleanup_link_unref_ Link *link = userdata;
816 assert(link->ifname);
818 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
821 r = sd_rtnl_message_get_errno(m);
823 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
828 int link_set_mtu(Link *link, uint32_t mtu) {
829 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
833 assert(link->manager);
834 assert(link->manager->rtnl);
836 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
838 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
839 RTM_SETLINK, link->ifindex);
841 log_link_error(link, "Could not allocate RTM_SETLINK message");
845 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
847 log_link_error(link, "Could not append MTU: %s", strerror(-r));
851 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
855 "Could not send rtnetlink message: %s",
865 static int link_set_bridge(Link *link) {
866 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
870 assert(link->network);
872 if(link->network->cost == 0)
875 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
876 RTM_SETLINK, link->ifindex);
878 log_link_error(link, "Could not allocate RTM_SETLINK message");
882 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
885 "Could not set message family %s", strerror(-r));
889 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
892 "Could not append IFLA_PROTINFO attribute: %s",
897 if(link->network->cost != 0) {
898 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
901 "Could not append IFLA_BRPORT_COST attribute: %s",
907 r = sd_rtnl_message_close_container(req);
910 "Could not append IFLA_LINKINFO attribute: %s",
915 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
918 "Could not send rtnetlink message: %s",
928 static void lldp_handler(sd_lldp *lldp, int event, void *userdata) {
929 Link *link = userdata;
933 assert(link->network);
934 assert(link->manager);
936 if (event != UPDATE_INFO)
939 r = sd_lldp_save(link->lldp, link->lldp_file);
941 log_link_warning(link, "could not save LLDP");
945 static int link_acquire_conf(Link *link) {
949 assert(link->network);
950 assert(link->manager);
951 assert(link->manager->event);
953 if (link_ipv4ll_enabled(link)) {
954 assert(link->ipv4ll);
956 log_link_debug(link, "acquiring IPv4 link-local address");
958 r = sd_ipv4ll_start(link->ipv4ll);
960 log_link_warning(link, "could not acquire IPv4 "
961 "link-local address");
966 if (link_dhcp4_enabled(link)) {
967 assert(link->dhcp_client);
969 log_link_debug(link, "acquiring DHCPv4 lease");
971 r = sd_dhcp_client_start(link->dhcp_client);
973 log_link_warning(link, "could not acquire DHCPv4 "
979 if (link_dhcp6_enabled(link)) {
980 assert(link->icmp6_router_discovery);
982 log_link_debug(link, "discovering IPv6 routers");
984 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
986 log_link_warning(link,
987 "could not start IPv6 router discovery");
992 if (link_lldp_enabled(link)) {
995 log_link_debug(link, "Starting LLDP");
997 r = sd_lldp_start(link->lldp);
999 log_link_warning(link, "could not start LLDP ");
1007 bool link_has_carrier(Link *link) {
1008 /* see Documentation/networking/operstates.txt in the kernel sources */
1010 if (link->kernel_operstate == IF_OPER_UP)
1013 if (link->kernel_operstate == IF_OPER_UNKNOWN)
1014 /* operstate may not be implemented, so fall back to flags */
1015 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1021 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1022 _cleanup_link_unref_ Link *link = userdata;
1027 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1030 r = sd_rtnl_message_get_errno(m);
1032 /* we warn but don't fail the link, as it may
1033 be brought up later */
1034 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
1040 static int link_up(Link *link) {
1041 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1045 assert(link->network);
1046 assert(link->manager);
1047 assert(link->manager->rtnl);
1049 log_link_debug(link, "bringing link up");
1051 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1052 RTM_SETLINK, link->ifindex);
1054 log_link_error(link, "Could not allocate RTM_SETLINK message");
1058 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1060 log_link_error(link, "Could not set link flags: %s",
1065 if (link->network->mac) {
1066 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1068 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
1073 if (link->network->mtu) {
1074 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
1076 log_link_error(link, "Could not set MTU: %s", strerror(-r));
1081 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1084 log_link_error(link,
1085 "Could not send rtnetlink message: %s",
1095 static int link_joined(Link *link) {
1099 assert(link->network);
1101 if (!(link->flags & IFF_UP)) {
1104 link_enter_failed(link);
1109 if(link->network->bridge) {
1110 r = link_set_bridge(link);
1112 log_link_error(link,
1113 "Could not set bridge message: %s",
1118 return link_enter_set_addresses(link);
1121 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1123 _cleanup_link_unref_ Link *link = userdata;
1127 assert(link->network);
1131 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1134 r = sd_rtnl_message_get_errno(m);
1135 if (r < 0 && r != -EEXIST) {
1136 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1137 link_enter_failed(link);
1140 log_link_debug(link, "joined netdev");
1142 if (link->enslaving <= 0)
1148 static int link_enter_join_netdev(Link *link) {
1154 assert(link->network);
1155 assert(link->state == LINK_STATE_PENDING);
1157 link->state = LINK_STATE_ENSLAVING;
1161 if (!link->network->bridge &&
1162 !link->network->bond &&
1163 hashmap_isempty(link->network->stacked_netdevs))
1164 return link_joined(link);
1166 if (link->network->bond) {
1167 log_link_struct(link, LOG_DEBUG,
1168 "MESSAGE=%-*s: enslaving by '%s'",
1170 link->ifname, link->network->bond->ifname,
1171 NETDEVIF(link->network->bond),
1174 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1176 log_link_struct(link, LOG_WARNING,
1177 "MESSAGE=%-*s: could not join netdev '%s': %s",
1179 link->ifname, link->network->bond->ifname,
1181 NETDEVIF(link->network->bond),
1183 link_enter_failed(link);
1190 if (link->network->bridge) {
1191 log_link_struct(link, LOG_DEBUG,
1192 "MESSAGE=%-*s: enslaving by '%s'",
1194 link->ifname, link->network->bridge->ifname,
1195 NETDEVIF(link->network->bridge),
1198 r = netdev_join(link->network->bridge, link,
1199 &netdev_join_handler);
1201 log_link_struct(link, LOG_WARNING,
1202 "MESSAGE=%-*s: could not join netdev '%s': %s",
1204 link->ifname, link->network->bridge->ifname,
1206 NETDEVIF(link->network->bridge),
1208 link_enter_failed(link);
1215 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1216 log_link_struct(link, LOG_DEBUG,
1217 "MESSAGE=%-*s: enslaving by '%s'",
1219 link->ifname, netdev->ifname, NETDEVIF(netdev),
1222 r = netdev_join(netdev, link, &netdev_join_handler);
1224 log_link_struct(link, LOG_WARNING,
1225 "MESSAGE=%-*s: could not join netdev '%s': %s",
1227 link->ifname, netdev->ifname,
1229 NETDEVIF(netdev), NULL);
1230 link_enter_failed(link);
1240 static int link_set_ipv4_forward(Link *link) {
1241 const char *p = NULL;
1245 b = link_ipv4_forward_enabled(link);
1247 p = strappenda("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
1248 r = write_string_file_no_create(p, one_zero(b));
1250 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
1253 _cleanup_free_ char *buf = NULL;
1255 /* If IP forwarding is turned on for this interface,
1256 * then propagate this to the global setting. Given
1257 * that turning this on has side-effects on other
1258 * fields, we'll try to avoid doing this unless
1259 * necessary, hence check the previous value
1260 * first. Note that we never turn this option off
1261 * again, since all interfaces we manage do not do
1262 * forwarding anyway by default, and ownership rules
1263 * of this control are so unclear. */
1265 r = read_one_line_file("/proc/sys/net/ipv4/ip_forward", &buf);
1267 log_link_warning_errno(link, r, "Cannot read /proc/sys/net/ipv4/ip_forward: %m");
1268 else if (!streq(buf, "1")) {
1269 r = write_string_file_no_create("/proc/sys/net/ipv4/ip_forward", "1");
1271 log_link_warning_errno(link, r, "Cannot write /proc/sys/net/ipv4/ip_forward: %m");
1278 static int link_set_ipv6_forward(Link *link) {
1279 const char *p = NULL;
1282 p = strappenda("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
1283 r = write_string_file_no_create(p, one_zero(link_ipv6_forward_enabled(link)));
1285 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
1290 static int link_configure(Link *link) {
1294 assert(link->network);
1295 assert(link->state == LINK_STATE_PENDING);
1297 r = link_set_bridge_fdb(link);
1301 r = link_set_ipv4_forward(link);
1305 r = link_set_ipv6_forward(link);
1309 if (link_ipv4ll_enabled(link)) {
1310 r = ipv4ll_configure(link);
1315 if (link_dhcp4_enabled(link)) {
1316 r = dhcp4_configure(link);
1321 if (link_dhcp4_server_enabled(link)) {
1322 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1326 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1331 if (link_dhcp6_enabled(link)) {
1332 r = icmp6_configure(link);
1337 if (link_lldp_enabled(link)) {
1338 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1342 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1346 r = sd_lldp_set_callback(link->lldp,
1347 lldp_handler, link);
1352 if (link_has_carrier(link)) {
1353 r = link_acquire_conf(link);
1358 return link_enter_join_netdev(link);
1361 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1363 _cleanup_link_unref_ Link *link = userdata;
1368 assert(link->ifname);
1369 assert(link->manager);
1371 if (link->state != LINK_STATE_PENDING)
1374 log_link_debug(link, "link state is up-to-date");
1376 r = network_get(link->manager, link->udev_device, link->ifname,
1377 &link->mac, &network);
1379 link_enter_unmanaged(link);
1384 if (link->flags & IFF_LOOPBACK) {
1385 if (network->ipv4ll)
1386 log_link_debug(link, "ignoring IPv4LL for loopback link");
1388 if (network->dhcp != ADDRESS_FAMILY_NO)
1389 log_link_debug(link, "ignoring DHCP clients for loopback link");
1391 if (network->dhcp_server)
1392 log_link_debug(link, "ignoring DHCP server for loopback link");
1395 r = network_apply(link->manager, network, link);
1399 r = link_configure(link);
1406 int link_initialized(Link *link, struct udev_device *device) {
1407 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1411 assert(link->manager);
1412 assert(link->manager->rtnl);
1415 if (link->state != LINK_STATE_PENDING)
1418 if (link->udev_device)
1421 log_link_debug(link, "udev initialized link");
1423 link->udev_device = udev_device_ref(device);
1425 /* udev has initialized the link, but we don't know if we have yet
1426 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1427 * when it returns we know that the pending NEWLINKs have already been
1428 * processed and that we are up-to-date */
1430 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1435 r = sd_rtnl_call_async(link->manager->rtnl, req,
1436 link_initialized_and_synced, link, 0, NULL);
1445 static Address* link_get_equal_address(Link *link, Address *needle) {
1451 LIST_FOREACH(addresses, i, link->addresses)
1452 if (address_equal(i, needle))
1458 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1459 Manager *m = userdata;
1462 _cleanup_address_free_ Address *address = NULL;
1464 char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
1465 const char *valid_str = NULL;
1472 if (sd_rtnl_message_is_error(message)) {
1473 r = sd_rtnl_message_get_errno(message);
1475 log_warning_errno(r, "rtnl: failed to receive address: %m");
1480 r = sd_rtnl_message_get_type(message, &type);
1482 log_warning("rtnl: could not get message type");
1486 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1488 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1490 } else if (ifindex <= 0) {
1491 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1494 r = link_get(m, ifindex, &link);
1495 if (r < 0 || !link) {
1496 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1501 r = address_new_dynamic(&address);
1505 r = sd_rtnl_message_addr_get_family(message, &address->family);
1506 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1507 log_link_warning(link, "rtnl: received address with invalid family, ignoring");
1511 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1513 log_link_warning(link, "rtnl: received address with invalid prefixlen, ignoring");
1517 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1519 log_link_warning(link, "rtnl: received address with invalid scope, ignoring");
1523 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1525 log_link_warning(link, "rtnl: received address with invalid flags, ignoring");
1529 switch (address->family) {
1531 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1533 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1540 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1542 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1549 assert_not_reached("invalid address family");
1552 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1553 log_link_warning(link, "could not print address");
1557 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1559 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1562 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1563 address->cinfo.ifa_valid * USEC_PER_SEC,
1567 existing = link_get_equal_address(link, address);
1572 log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1575 existing->scope = address->scope;
1576 existing->flags = address->flags;
1577 existing->cinfo = address->cinfo;
1580 log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1582 LIST_PREPEND(addresses, link->addresses, address);
1583 address_establish(address, link);
1595 log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1596 address_release(existing, link);
1597 LIST_REMOVE(addresses, link->addresses, existing);
1598 address_free(existing);
1600 log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1604 assert_not_reached("Received invalid RTNL message type");
1610 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1612 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1613 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1621 r = link_new(m, message, ret);
1627 log_link_debug(link, "link %d added", link->ifindex);
1629 if (detect_container(NULL) <= 0) {
1630 /* not in a container, udev will be around */
1631 sprintf(ifindex_str, "n%d", link->ifindex);
1632 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1634 log_link_warning(link,
1635 "could not find udev device: %m");
1639 if (udev_device_get_is_initialized(device) <= 0) {
1641 log_link_debug(link, "link pending udev initialization...");
1645 r = link_initialized(link, device);
1649 /* we are calling a callback directly, so must take a ref */
1652 r = link_initialized_and_synced(m->rtnl, NULL, link);
1660 int link_update(Link *link, sd_rtnl_message *m) {
1661 struct ether_addr mac;
1664 bool had_carrier, carrier_gained, carrier_lost;
1668 assert(link->ifname);
1671 if (link->state == LINK_STATE_LINGER) {
1673 log_link_info(link, "link readded");
1674 link->state = LINK_STATE_ENSLAVING;
1677 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1678 if (r >= 0 && !streq(ifname, link->ifname)) {
1679 log_link_info(link, "renamed to %s", ifname);
1682 link->ifname = strdup(ifname);
1687 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1688 if (r >= 0 && mtu > 0) {
1690 if (!link->original_mtu) {
1691 link->original_mtu = mtu;
1692 log_link_debug(link, "saved original MTU: %"
1693 PRIu32, link->original_mtu);
1696 if (link->dhcp_client) {
1697 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1700 log_link_warning(link,
1701 "Could not update MTU in DHCP client: %s",
1708 /* The kernel may broadcast NEWLINK messages without the MAC address
1709 set, simply ignore them. */
1710 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1712 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1715 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1718 log_link_debug(link, "MAC address: "
1719 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1720 mac.ether_addr_octet[0],
1721 mac.ether_addr_octet[1],
1722 mac.ether_addr_octet[2],
1723 mac.ether_addr_octet[3],
1724 mac.ether_addr_octet[4],
1725 mac.ether_addr_octet[5]);
1728 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1730 log_link_warning(link,
1731 "Could not update MAC address in IPv4LL client: %s",
1737 if (link->dhcp_client) {
1738 r = sd_dhcp_client_set_mac(link->dhcp_client,
1739 (const uint8_t *) &link->mac,
1743 log_link_warning(link,
1744 "Could not update MAC address in DHCP client: %s",
1750 if (link->dhcp6_client) {
1751 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1752 (const uint8_t *) &link->mac,
1756 log_link_warning(link,
1757 "Could not update MAC address in DHCPv6 client: %s",
1765 had_carrier = link_has_carrier(link);
1767 r = link_update_flags(link, m);
1771 carrier_gained = !had_carrier && link_has_carrier(link);
1772 carrier_lost = had_carrier && !link_has_carrier(link);
1774 if (carrier_gained) {
1775 log_link_info(link, "gained carrier");
1777 if (link->network) {
1778 r = link_acquire_conf(link);
1780 link_enter_failed(link);
1784 } else if (carrier_lost) {
1785 log_link_info(link, "lost carrier");
1787 r = link_stop_clients(link);
1789 link_enter_failed(link);
1797 static void link_update_operstate(Link *link) {
1801 if (link->kernel_operstate == IF_OPER_DORMANT)
1802 link->operstate = LINK_OPERSTATE_DORMANT;
1803 else if (link_has_carrier(link)) {
1805 uint8_t scope = RT_SCOPE_NOWHERE;
1807 /* if we have carrier, check what addresses we have */
1808 LIST_FOREACH(addresses, address, link->addresses) {
1809 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1812 if (address->scope < scope)
1813 scope = address->scope;
1816 if (scope < RT_SCOPE_SITE)
1817 /* universally accessible addresses found */
1818 link->operstate = LINK_OPERSTATE_ROUTABLE;
1819 else if (scope < RT_SCOPE_HOST)
1820 /* only link or site local addresses found */
1821 link->operstate = LINK_OPERSTATE_DEGRADED;
1823 /* no useful addresses found */
1824 link->operstate = LINK_OPERSTATE_CARRIER;
1825 } else if (link->flags & IFF_UP)
1826 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1828 link->operstate = LINK_OPERSTATE_OFF;
1831 int link_save(Link *link) {
1832 _cleanup_free_ char *temp_path = NULL;
1833 _cleanup_fclose_ FILE *f = NULL;
1834 const char *admin_state, *oper_state;
1838 assert(link->state_file);
1839 assert(link->lease_file);
1840 assert(link->manager);
1842 link_update_operstate(link);
1844 r = manager_save(link->manager);
1848 if (link->state == LINK_STATE_LINGER) {
1849 unlink(link->state_file);
1853 admin_state = link_state_to_string(link->state);
1854 assert(admin_state);
1856 oper_state = link_operstate_to_string(link->operstate);
1859 r = fopen_temporary(link->state_file, &f, &temp_path);
1863 fchmod(fileno(f), 0644);
1866 "# This is private data. Do not parse.\n"
1869 admin_state, oper_state);
1871 if (link->network) {
1872 char **address, **domain;
1875 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1879 STRV_FOREACH(address, link->network->dns) {
1886 if (link->network->dhcp_dns &&
1888 const struct in_addr *addresses;
1890 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1894 serialize_in_addrs(f, addresses, r);
1902 STRV_FOREACH(address, link->network->ntp) {
1909 if (link->network->dhcp_ntp &&
1911 const struct in_addr *addresses;
1913 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1917 serialize_in_addrs(f, addresses, r);
1923 fprintf(f, "DOMAINS=");
1925 STRV_FOREACH(domain, link->network->domains) {
1932 if (link->network->dhcp_domains &&
1934 const char *domainname;
1936 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1940 fputs(domainname, f);
1946 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1947 yes_no(link->network->wildcard_domain));
1949 fprintf(f, "LLMNR=%s\n",
1950 llmnr_support_to_string(link->network->llmnr));
1953 if (link->dhcp_lease) {
1954 assert(link->network);
1956 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1964 unlink(link->lease_file);
1967 assert(link->network);
1969 r = sd_lldp_save(link->lldp, link->lldp_file);
1977 unlink(link->lldp_file);
1979 r = fflush_and_check(f);
1983 if (rename(temp_path, link->state_file) < 0) {
1990 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1991 unlink(link->state_file);
1996 static const char* const link_state_table[_LINK_STATE_MAX] = {
1997 [LINK_STATE_PENDING] = "pending",
1998 [LINK_STATE_ENSLAVING] = "configuring",
1999 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2000 [LINK_STATE_SETTING_ROUTES] = "configuring",
2001 [LINK_STATE_CONFIGURED] = "configured",
2002 [LINK_STATE_UNMANAGED] = "unmanaged",
2003 [LINK_STATE_FAILED] = "failed",
2004 [LINK_STATE_LINGER] = "linger",
2007 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2009 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2010 [LINK_OPERSTATE_OFF] = "off",
2011 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2012 [LINK_OPERSTATE_DORMANT] = "dormant",
2013 [LINK_OPERSTATE_CARRIER] = "carrier",
2014 [LINK_OPERSTATE_DEGRADED] = "degraded",
2015 [LINK_OPERSTATE_ROUTABLE] = "routable",
2018 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);