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 unlink(link->lldp_file);
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 unlink(link->state_file);
302 free(link->state_file);
304 udev_device_unref(link->udev_device);
309 Link *link_unref(Link *link) {
310 if (link && (-- link->n_ref <= 0))
316 Link *link_ref(Link *link) {
318 assert_se(++ link->n_ref >= 2);
323 int link_get(Manager *m, int ifindex, Link **ret) {
330 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
339 void link_drop(Link *link) {
340 if (!link || link->state == LINK_STATE_LINGER)
343 link->state = LINK_STATE_LINGER;
345 log_link_debug(link, "link removed");
352 static void link_enter_unmanaged(Link *link) {
355 log_link_debug(link, "unmanaged");
357 link->state = LINK_STATE_UNMANAGED;
362 static int link_stop_clients(Link *link) {
366 assert(link->manager);
367 assert(link->manager->event);
372 if (link->dhcp_client) {
373 k = sd_dhcp_client_stop(link->dhcp_client);
375 log_link_warning(link, "Could not stop DHCPv4 client: %s",
382 k = sd_ipv4ll_stop(link->ipv4ll);
384 log_link_warning(link, "Could not stop IPv4 link-local: %s",
390 if(link->icmp6_router_discovery) {
392 if (link->dhcp6_client) {
393 k = sd_dhcp6_client_stop(link->dhcp6_client);
395 log_link_warning(link, "Could not stop DHCPv6 client: %s",
401 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
403 log_link_warning(link,
404 "Could not stop ICMPv6 router discovery: %s",
412 k = sd_lldp_stop(link->lldp);
414 log_link_warning(link, "Could not stop LLDP : %s",
423 void link_enter_failed(Link *link) {
426 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
429 log_link_warning(link, "failed");
431 link->state = LINK_STATE_FAILED;
433 link_stop_clients(link);
438 static Address* link_find_dhcp_server_address(Link *link) {
442 assert(link->network);
444 /* The the first statically configured address if there is any */
445 LIST_FOREACH(addresses, address, link->network->static_addresses) {
447 if (address->family != AF_INET)
450 if (in_addr_is_null(address->family, &address->in_addr))
456 /* If that didn't work, find a suitable address we got from the pool */
457 LIST_FOREACH(addresses, address, link->pool_addresses) {
458 if (address->family != AF_INET)
467 static int link_enter_configured(Link *link) {
471 assert(link->network);
472 assert(link->state == LINK_STATE_SETTING_ROUTES);
474 if (link_dhcp4_server_enabled(link) &&
475 !sd_dhcp_server_is_running(link->dhcp_server)) {
476 struct in_addr pool_start;
479 address = link_find_dhcp_server_address(link);
481 log_link_warning(link,
482 "Failed to find suitable address for DHCPv4 server instance.");
483 link_enter_failed(link);
487 log_link_debug(link, "offering DHCPv4 leases");
489 r = sd_dhcp_server_set_address(link->dhcp_server,
490 &address->in_addr.in,
495 /* offer 32 addresses starting from the address following the server address */
496 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
497 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
503 r = sd_dhcp_server_set_router(link->dhcp_server,
504 &main_address->in_addr.in);
508 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
509 main_address->prefixlen);
514 r = sd_dhcp_server_start(link->dhcp_server);
516 log_link_warning(link, "could not start DHCPv4 server "
517 "instance: %s", strerror(-r));
519 link_enter_failed(link);
525 log_link_info(link, "link configured");
527 link->state = LINK_STATE_CONFIGURED;
534 void link_client_handler(Link *link) {
536 assert(link->network);
538 if (!link->static_configured)
541 if (link_ipv4ll_enabled(link))
542 if (!link->ipv4ll_address ||
546 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
549 if (link->state != LINK_STATE_CONFIGURED)
550 link_enter_configured(link);
555 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
556 _cleanup_link_unref_ Link *link = userdata;
559 assert(link->link_messages > 0);
560 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
561 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
564 link->link_messages --;
566 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
569 r = sd_rtnl_message_get_errno(m);
570 if (r < 0 && r != -EEXIST)
571 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
573 if (link->link_messages == 0) {
574 log_link_debug(link, "routes set");
575 link->static_configured = true;
576 link_client_handler(link);
582 static int link_enter_set_routes(Link *link) {
587 assert(link->network);
588 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
590 link->state = LINK_STATE_SETTING_ROUTES;
592 LIST_FOREACH(routes, rt, link->network->static_routes) {
593 r = route_configure(rt, link, &route_handler);
595 log_link_warning(link,
596 "could not set routes: %s",
598 link_enter_failed(link);
602 link->link_messages ++;
605 if (link->link_messages == 0) {
606 link->static_configured = true;
607 link_client_handler(link);
609 log_link_debug(link, "setting routes");
614 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
615 _cleanup_link_unref_ Link *link = userdata;
620 assert(link->ifname);
622 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
625 r = sd_rtnl_message_get_errno(m);
626 if (r < 0 && r != -ESRCH)
627 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
632 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
633 _cleanup_link_unref_ Link *link = userdata;
639 assert(link->ifname);
640 assert(link->link_messages > 0);
641 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
642 LINK_STATE_FAILED, LINK_STATE_LINGER));
644 link->link_messages --;
646 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
649 r = sd_rtnl_message_get_errno(m);
650 if (r < 0 && r != -EEXIST)
651 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
653 link_rtnl_process_address(rtnl, m, link->manager);
655 if (link->link_messages == 0) {
656 log_link_debug(link, "addresses set");
657 link_enter_set_routes(link);
663 static int link_enter_set_addresses(Link *link) {
668 assert(link->network);
669 assert(link->state != _LINK_STATE_INVALID);
671 link->state = LINK_STATE_SETTING_ADDRESSES;
673 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
674 r = address_configure(ad, link, &address_handler);
676 log_link_warning_errno(link, r, "Could not set addresses: %m");
677 link_enter_failed(link);
681 link->link_messages ++;
684 if (link->link_messages == 0) {
685 link_enter_set_routes(link);
687 log_link_debug(link, "setting addresses");
692 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
693 _cleanup_link_unref_ Link *link = userdata;
698 assert(link->ifname);
700 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
703 r = sd_rtnl_message_get_errno(m);
704 if (r < 0 && r != -EADDRNOTAVAIL)
705 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
710 static int link_set_bridge_fdb(const Link *const link) {
714 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
715 r = fdb_entry_configure(link->manager->rtnl, fdb_entry, link->ifindex);
717 log_link_error(link, "Failed to add MAC entry to static MAC table: %s", strerror(-r));
725 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
726 _cleanup_link_unref_ Link *link = userdata;
729 log_link_debug(link, "set link");
731 r = sd_rtnl_message_get_errno(m);
732 if (r < 0 && r != -EEXIST) {
733 log_link_struct(link, LOG_ERR,
734 "MESSAGE=%-*s: could not join netdev: %s",
736 link->ifname, strerror(-r),
739 link_enter_failed(link);
746 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
747 sd_bus_error *ret_error) {
748 _cleanup_link_unref_ Link *link = userdata;
753 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
756 r = sd_bus_message_get_errno(m);
758 log_link_warning(link, "Could not set hostname: %s",
764 int link_set_hostname(Link *link, const char *hostname) {
765 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
769 assert(link->manager);
772 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
774 if (!link->manager->bus) {
775 /* TODO: replace by assert when we can rely on kdbus */
777 "Not connected to system bus, ignoring transient hostname.");
781 r = sd_bus_message_new_method_call(
784 "org.freedesktop.hostname1",
785 "/org/freedesktop/hostname1",
786 "org.freedesktop.hostname1",
791 r = sd_bus_message_append(m, "sb", hostname, false);
795 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
798 log_link_error(link, "Could not set transient hostname: %s",
808 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
809 _cleanup_link_unref_ Link *link = userdata;
814 assert(link->ifname);
816 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
819 r = sd_rtnl_message_get_errno(m);
821 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
826 int link_set_mtu(Link *link, uint32_t mtu) {
827 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
831 assert(link->manager);
832 assert(link->manager->rtnl);
834 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
836 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
837 RTM_SETLINK, link->ifindex);
839 log_link_error(link, "Could not allocate RTM_SETLINK message");
843 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
845 log_link_error(link, "Could not append MTU: %s", strerror(-r));
849 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
853 "Could not send rtnetlink message: %s",
863 static int link_set_bridge(Link *link) {
864 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
868 assert(link->network);
870 if(link->network->cost == 0)
873 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
874 RTM_SETLINK, link->ifindex);
876 log_link_error(link, "Could not allocate RTM_SETLINK message");
880 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
883 "Could not set message family %s", strerror(-r));
887 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
890 "Could not append IFLA_PROTINFO attribute: %s",
895 if(link->network->cost != 0) {
896 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
899 "Could not append IFLA_BRPORT_COST attribute: %s",
905 r = sd_rtnl_message_close_container(req);
908 "Could not append IFLA_LINKINFO attribute: %s",
913 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
916 "Could not send rtnetlink message: %s",
926 static void lldp_handler(sd_lldp *lldp, int event, void *userdata) {
927 Link *link = userdata;
931 assert(link->network);
932 assert(link->manager);
934 if (event != UPDATE_INFO)
937 r = sd_lldp_save(link->lldp, link->lldp_file);
939 log_link_warning(link, "could not save LLDP");
943 static int link_acquire_conf(Link *link) {
947 assert(link->network);
948 assert(link->manager);
949 assert(link->manager->event);
951 if (link_ipv4ll_enabled(link)) {
952 assert(link->ipv4ll);
954 log_link_debug(link, "acquiring IPv4 link-local address");
956 r = sd_ipv4ll_start(link->ipv4ll);
958 log_link_warning(link, "could not acquire IPv4 "
959 "link-local address");
964 if (link_dhcp4_enabled(link)) {
965 assert(link->dhcp_client);
967 log_link_debug(link, "acquiring DHCPv4 lease");
969 r = sd_dhcp_client_start(link->dhcp_client);
971 log_link_warning(link, "could not acquire DHCPv4 "
977 if (link_dhcp6_enabled(link)) {
978 assert(link->icmp6_router_discovery);
980 log_link_debug(link, "discovering IPv6 routers");
982 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
984 log_link_warning(link,
985 "could not start IPv6 router discovery");
990 if (link_lldp_enabled(link)) {
993 log_link_debug(link, "Starting LLDP");
995 r = sd_lldp_start(link->lldp);
997 log_link_warning(link, "could not start LLDP ");
1005 bool link_has_carrier(Link *link) {
1006 /* see Documentation/networking/operstates.txt in the kernel sources */
1008 if (link->kernel_operstate == IF_OPER_UP)
1011 if (link->kernel_operstate == IF_OPER_UNKNOWN)
1012 /* operstate may not be implemented, so fall back to flags */
1013 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1019 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1020 _cleanup_link_unref_ Link *link = userdata;
1025 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1028 r = sd_rtnl_message_get_errno(m);
1030 /* we warn but don't fail the link, as it may
1031 be brought up later */
1032 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
1038 static int link_up(Link *link) {
1039 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1043 assert(link->network);
1044 assert(link->manager);
1045 assert(link->manager->rtnl);
1047 log_link_debug(link, "bringing link up");
1049 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1050 RTM_SETLINK, link->ifindex);
1052 log_link_error(link, "Could not allocate RTM_SETLINK message");
1056 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1058 log_link_error(link, "Could not set link flags: %s",
1063 if (link->network->mac) {
1064 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1066 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
1071 if (link->network->mtu) {
1072 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
1074 log_link_error(link, "Could not set MTU: %s", strerror(-r));
1079 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1082 log_link_error(link,
1083 "Could not send rtnetlink message: %s",
1093 static int link_joined(Link *link) {
1097 assert(link->network);
1099 if (!(link->flags & IFF_UP)) {
1102 link_enter_failed(link);
1107 if(link->network->bridge) {
1108 r = link_set_bridge(link);
1110 log_link_error(link,
1111 "Could not set bridge message: %s",
1116 return link_enter_set_addresses(link);
1119 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1121 _cleanup_link_unref_ Link *link = userdata;
1125 assert(link->network);
1129 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1132 r = sd_rtnl_message_get_errno(m);
1133 if (r < 0 && r != -EEXIST) {
1134 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1135 link_enter_failed(link);
1138 log_link_debug(link, "joined netdev");
1140 if (link->enslaving <= 0)
1146 static int link_enter_join_netdev(Link *link) {
1152 assert(link->network);
1153 assert(link->state == LINK_STATE_PENDING);
1155 link->state = LINK_STATE_ENSLAVING;
1159 if (!link->network->bridge &&
1160 !link->network->bond &&
1161 hashmap_isempty(link->network->stacked_netdevs))
1162 return link_joined(link);
1164 if (link->network->bond) {
1165 log_link_struct(link, LOG_DEBUG,
1166 "MESSAGE=%-*s: enslaving by '%s'",
1168 link->ifname, link->network->bond->ifname,
1169 NETDEVIF(link->network->bond),
1172 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1174 log_link_struct(link, LOG_WARNING,
1175 "MESSAGE=%-*s: could not join netdev '%s': %s",
1177 link->ifname, link->network->bond->ifname,
1179 NETDEVIF(link->network->bond),
1181 link_enter_failed(link);
1188 if (link->network->bridge) {
1189 log_link_struct(link, LOG_DEBUG,
1190 "MESSAGE=%-*s: enslaving by '%s'",
1192 link->ifname, link->network->bridge->ifname,
1193 NETDEVIF(link->network->bridge),
1196 r = netdev_join(link->network->bridge, link,
1197 &netdev_join_handler);
1199 log_link_struct(link, LOG_WARNING,
1200 "MESSAGE=%-*s: could not join netdev '%s': %s",
1202 link->ifname, link->network->bridge->ifname,
1204 NETDEVIF(link->network->bridge),
1206 link_enter_failed(link);
1213 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1214 log_link_struct(link, LOG_DEBUG,
1215 "MESSAGE=%-*s: enslaving by '%s'",
1217 link->ifname, netdev->ifname, NETDEVIF(netdev),
1220 r = netdev_join(netdev, link, &netdev_join_handler);
1222 log_link_struct(link, LOG_WARNING,
1223 "MESSAGE=%-*s: could not join netdev '%s': %s",
1225 link->ifname, netdev->ifname,
1227 NETDEVIF(netdev), NULL);
1228 link_enter_failed(link);
1238 static int link_set_ipv4_forward(Link *link) {
1239 const char *p = NULL;
1243 b = link_ipv4_forward_enabled(link);
1245 p = strappenda("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
1246 r = write_string_file_no_create(p, one_zero(b));
1248 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
1251 _cleanup_free_ char *buf = NULL;
1253 /* If IP forwarding is turned on for this interface,
1254 * then propagate this to the global setting. Given
1255 * that turning this on has side-effects on other
1256 * fields, we'll try to avoid doing this unless
1257 * necessary, hence check the previous value
1258 * first. Note that we never turn this option off
1259 * again, since all interfaces we manage do not do
1260 * forwarding anyway by default, and ownership rules
1261 * of this control are so unclear. */
1263 r = read_one_line_file("/proc/sys/net/ipv4/ip_forward", &buf);
1265 log_link_warning_errno(link, r, "Cannot read /proc/sys/net/ipv4/ip_forward: %m");
1266 else if (!streq(buf, "1")) {
1267 r = write_string_file_no_create("/proc/sys/net/ipv4/ip_forward", "1");
1269 log_link_warning_errno(link, r, "Cannot write /proc/sys/net/ipv4/ip_forward: %m");
1276 static int link_set_ipv6_forward(Link *link) {
1277 const char *p = NULL;
1280 p = strappenda("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
1281 r = write_string_file_no_create(p, one_zero(link_ipv6_forward_enabled(link)));
1283 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
1288 static int link_configure(Link *link) {
1292 assert(link->network);
1293 assert(link->state == LINK_STATE_PENDING);
1295 r = link_set_bridge_fdb(link);
1299 r = link_set_ipv4_forward(link);
1303 r = link_set_ipv6_forward(link);
1307 if (link_ipv4ll_enabled(link)) {
1308 r = ipv4ll_configure(link);
1313 if (link_dhcp4_enabled(link)) {
1314 r = dhcp4_configure(link);
1319 if (link_dhcp4_server_enabled(link)) {
1320 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1324 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1329 if (link_dhcp6_enabled(link)) {
1330 r = icmp6_configure(link);
1335 if (link_lldp_enabled(link)) {
1336 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1340 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1344 r = sd_lldp_set_callback(link->lldp,
1345 lldp_handler, link);
1350 if (link_has_carrier(link)) {
1351 r = link_acquire_conf(link);
1356 return link_enter_join_netdev(link);
1359 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1361 _cleanup_link_unref_ Link *link = userdata;
1366 assert(link->ifname);
1367 assert(link->manager);
1369 if (link->state != LINK_STATE_PENDING)
1372 log_link_debug(link, "link state is up-to-date");
1374 r = network_get(link->manager, link->udev_device, link->ifname,
1375 &link->mac, &network);
1377 link_enter_unmanaged(link);
1382 if (link->flags & IFF_LOOPBACK) {
1383 if (network->ipv4ll)
1384 log_link_debug(link, "ignoring IPv4LL for loopback link");
1386 if (network->dhcp != ADDRESS_FAMILY_NO)
1387 log_link_debug(link, "ignoring DHCP clients for loopback link");
1389 if (network->dhcp_server)
1390 log_link_debug(link, "ignoring DHCP server for loopback link");
1393 r = network_apply(link->manager, network, link);
1397 r = link_configure(link);
1404 int link_initialized(Link *link, struct udev_device *device) {
1405 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1409 assert(link->manager);
1410 assert(link->manager->rtnl);
1413 if (link->state != LINK_STATE_PENDING)
1416 if (link->udev_device)
1419 log_link_debug(link, "udev initialized link");
1421 link->udev_device = udev_device_ref(device);
1423 /* udev has initialized the link, but we don't know if we have yet
1424 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1425 * when it returns we know that the pending NEWLINKs have already been
1426 * processed and that we are up-to-date */
1428 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1433 r = sd_rtnl_call_async(link->manager->rtnl, req,
1434 link_initialized_and_synced, link, 0, NULL);
1443 static Address* link_get_equal_address(Link *link, Address *needle) {
1449 LIST_FOREACH(addresses, i, link->addresses)
1450 if (address_equal(i, needle))
1456 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1457 Manager *m = userdata;
1460 _cleanup_address_free_ Address *address = NULL;
1462 char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
1463 const char *valid_str = NULL;
1470 if (sd_rtnl_message_is_error(message)) {
1471 r = sd_rtnl_message_get_errno(message);
1473 log_warning_errno(r, "rtnl: failed to receive address: %m");
1478 r = sd_rtnl_message_get_type(message, &type);
1480 log_warning("rtnl: could not get message type");
1484 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1486 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1488 } else if (ifindex <= 0) {
1489 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1492 r = link_get(m, ifindex, &link);
1493 if (r < 0 || !link) {
1494 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1499 r = address_new_dynamic(&address);
1503 r = sd_rtnl_message_addr_get_family(message, &address->family);
1504 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1505 log_link_warning(link, "rtnl: received address with invalid family, ignoring");
1509 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1511 log_link_warning(link, "rtnl: received address with invalid prefixlen, ignoring");
1515 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1517 log_link_warning(link, "rtnl: received address with invalid scope, ignoring");
1521 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1523 log_link_warning(link, "rtnl: received address with invalid flags, ignoring");
1527 switch (address->family) {
1529 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1531 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1538 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1540 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1547 assert_not_reached("invalid address family");
1550 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1551 log_link_warning(link, "could not print address");
1555 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1557 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1560 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1561 address->cinfo.ifa_valid * USEC_PER_SEC,
1565 existing = link_get_equal_address(link, address);
1570 log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1573 existing->scope = address->scope;
1574 existing->flags = address->flags;
1575 existing->cinfo = address->cinfo;
1578 log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1580 LIST_PREPEND(addresses, link->addresses, address);
1581 address_establish(address, link);
1593 log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1594 address_release(existing, link);
1595 LIST_REMOVE(addresses, link->addresses, existing);
1596 address_free(existing);
1598 log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1602 assert_not_reached("Received invalid RTNL message type");
1608 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1610 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1611 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1619 r = link_new(m, message, ret);
1625 log_link_debug(link, "link %d added", link->ifindex);
1627 if (detect_container(NULL) <= 0) {
1628 /* not in a container, udev will be around */
1629 sprintf(ifindex_str, "n%d", link->ifindex);
1630 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1632 log_link_warning(link,
1633 "could not find udev device: %m");
1637 if (udev_device_get_is_initialized(device) <= 0) {
1639 log_link_debug(link, "link pending udev initialization...");
1643 r = link_initialized(link, device);
1647 /* we are calling a callback directly, so must take a ref */
1650 r = link_initialized_and_synced(m->rtnl, NULL, link);
1658 int link_update(Link *link, sd_rtnl_message *m) {
1659 struct ether_addr mac;
1662 bool had_carrier, carrier_gained, carrier_lost;
1666 assert(link->ifname);
1669 if (link->state == LINK_STATE_LINGER) {
1671 log_link_info(link, "link readded");
1672 link->state = LINK_STATE_ENSLAVING;
1675 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1676 if (r >= 0 && !streq(ifname, link->ifname)) {
1677 log_link_info(link, "renamed to %s", ifname);
1680 link->ifname = strdup(ifname);
1685 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1686 if (r >= 0 && mtu > 0) {
1688 if (!link->original_mtu) {
1689 link->original_mtu = mtu;
1690 log_link_debug(link, "saved original MTU: %"
1691 PRIu32, link->original_mtu);
1694 if (link->dhcp_client) {
1695 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1698 log_link_warning(link,
1699 "Could not update MTU in DHCP client: %s",
1706 /* The kernel may broadcast NEWLINK messages without the MAC address
1707 set, simply ignore them. */
1708 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1710 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1713 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1716 log_link_debug(link, "MAC address: "
1717 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1718 mac.ether_addr_octet[0],
1719 mac.ether_addr_octet[1],
1720 mac.ether_addr_octet[2],
1721 mac.ether_addr_octet[3],
1722 mac.ether_addr_octet[4],
1723 mac.ether_addr_octet[5]);
1726 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1728 log_link_warning(link,
1729 "Could not update MAC address in IPv4LL client: %s",
1735 if (link->dhcp_client) {
1736 r = sd_dhcp_client_set_mac(link->dhcp_client,
1737 (const uint8_t *) &link->mac,
1741 log_link_warning(link,
1742 "Could not update MAC address in DHCP client: %s",
1748 if (link->dhcp6_client) {
1749 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1750 (const uint8_t *) &link->mac,
1754 log_link_warning(link,
1755 "Could not update MAC address in DHCPv6 client: %s",
1763 had_carrier = link_has_carrier(link);
1765 r = link_update_flags(link, m);
1769 carrier_gained = !had_carrier && link_has_carrier(link);
1770 carrier_lost = had_carrier && !link_has_carrier(link);
1772 if (carrier_gained) {
1773 log_link_info(link, "gained carrier");
1775 if (link->network) {
1776 r = link_acquire_conf(link);
1778 link_enter_failed(link);
1782 } else if (carrier_lost) {
1783 log_link_info(link, "lost carrier");
1785 r = link_stop_clients(link);
1787 link_enter_failed(link);
1795 static void link_update_operstate(Link *link) {
1799 if (link->kernel_operstate == IF_OPER_DORMANT)
1800 link->operstate = LINK_OPERSTATE_DORMANT;
1801 else if (link_has_carrier(link)) {
1803 uint8_t scope = RT_SCOPE_NOWHERE;
1805 /* if we have carrier, check what addresses we have */
1806 LIST_FOREACH(addresses, address, link->addresses) {
1807 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1810 if (address->scope < scope)
1811 scope = address->scope;
1814 if (scope < RT_SCOPE_SITE)
1815 /* universally accessible addresses found */
1816 link->operstate = LINK_OPERSTATE_ROUTABLE;
1817 else if (scope < RT_SCOPE_HOST)
1818 /* only link or site local addresses found */
1819 link->operstate = LINK_OPERSTATE_DEGRADED;
1821 /* no useful addresses found */
1822 link->operstate = LINK_OPERSTATE_CARRIER;
1823 } else if (link->flags & IFF_UP)
1824 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1826 link->operstate = LINK_OPERSTATE_OFF;
1829 int link_save(Link *link) {
1830 _cleanup_free_ char *temp_path = NULL;
1831 _cleanup_fclose_ FILE *f = NULL;
1832 const char *admin_state, *oper_state;
1836 assert(link->state_file);
1837 assert(link->lease_file);
1838 assert(link->manager);
1840 link_update_operstate(link);
1842 r = manager_save(link->manager);
1846 if (link->state == LINK_STATE_LINGER) {
1847 unlink(link->state_file);
1851 admin_state = link_state_to_string(link->state);
1852 assert(admin_state);
1854 oper_state = link_operstate_to_string(link->operstate);
1857 r = fopen_temporary(link->state_file, &f, &temp_path);
1861 fchmod(fileno(f), 0644);
1864 "# This is private data. Do not parse.\n"
1867 admin_state, oper_state);
1869 if (link->network) {
1870 char **address, **domain;
1873 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1877 STRV_FOREACH(address, link->network->dns) {
1884 if (link->network->dhcp_dns &&
1886 const struct in_addr *addresses;
1888 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1892 serialize_in_addrs(f, addresses, r);
1900 STRV_FOREACH(address, link->network->ntp) {
1907 if (link->network->dhcp_ntp &&
1909 const struct in_addr *addresses;
1911 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1915 serialize_in_addrs(f, addresses, r);
1921 fprintf(f, "DOMAINS=");
1923 STRV_FOREACH(domain, link->network->domains) {
1930 if (link->network->dhcp_domains &&
1932 const char *domainname;
1934 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1938 fputs(domainname, f);
1944 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1945 yes_no(link->network->wildcard_domain));
1947 fprintf(f, "LLMNR=%s\n",
1948 llmnr_support_to_string(link->network->llmnr));
1951 if (link->dhcp_lease) {
1952 assert(link->network);
1954 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1962 unlink(link->lease_file);
1965 assert(link->network);
1967 r = sd_lldp_save(link->lldp, link->lldp_file);
1975 unlink(link->lldp_file);
1977 r = fflush_and_check(f);
1981 if (rename(temp_path, link->state_file) < 0) {
1988 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1989 unlink(link->state_file);
1994 static const char* const link_state_table[_LINK_STATE_MAX] = {
1995 [LINK_STATE_PENDING] = "pending",
1996 [LINK_STATE_ENSLAVING] = "configuring",
1997 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1998 [LINK_STATE_SETTING_ROUTES] = "configuring",
1999 [LINK_STATE_CONFIGURED] = "configured",
2000 [LINK_STATE_UNMANAGED] = "unmanaged",
2001 [LINK_STATE_FAILED] = "failed",
2002 [LINK_STATE_LINGER] = "linger",
2005 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2007 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2008 [LINK_OPERSTATE_OFF] = "off",
2009 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2010 [LINK_OPERSTATE_DORMANT] = "dormant",
2011 [LINK_OPERSTATE_CARRIER] = "carrier",
2012 [LINK_OPERSTATE_DEGRADED] = "degraded",
2013 [LINK_OPERSTATE_ROUTABLE] = "routable",
2016 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);