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 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 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 bool link_dhcp4_server_enabled(Link *link) {
59 if (link->flags & IFF_LOOPBACK)
65 return link->network->dhcp_server;
68 bool link_ipv4ll_enabled(Link *link) {
69 if (link->flags & IFF_LOOPBACK)
75 return IN_SET(link->network->link_local, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
78 bool link_ipv6ll_enabled(Link *link) {
79 if (link->flags & IFF_LOOPBACK)
85 return IN_SET(link->network->link_local, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
88 bool link_lldp_enabled(Link *link) {
89 if (link->flags & IFF_LOOPBACK)
95 if (link->network->bridge)
98 return link->network->lldp;
101 static bool link_ipv4_forward_enabled(Link *link) {
102 if (link->flags & IFF_LOOPBACK)
108 return IN_SET(link->network->ip_forward, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
111 static bool link_ipv6_forward_enabled(Link *link) {
112 if (link->flags & IFF_LOOPBACK)
118 return IN_SET(link->network->ip_forward, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
121 #define FLAG_STRING(string, flag, old, new) \
122 (((old ^ new) & flag) \
123 ? ((old & flag) ? (" -" string) : (" +" string)) \
126 static int link_update_flags(Link *link, sd_rtnl_message *m) {
127 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
133 r = sd_rtnl_message_link_get_flags(m, &flags);
135 log_link_warning(link, "Could not get link flags");
139 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
141 /* if we got a message without operstate, take it to mean
142 the state was unchanged */
143 operstate = link->kernel_operstate;
145 if ((link->flags == flags) && (link->kernel_operstate == operstate))
148 if (link->flags != flags) {
149 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",
150 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
151 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
152 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
153 FLAG_STRING("UP", IFF_UP, link->flags, flags),
154 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
155 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
156 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
157 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
158 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
159 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
160 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
161 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
162 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
163 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
164 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
165 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
166 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
167 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
168 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
170 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
171 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
172 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
173 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
174 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
175 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
176 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
177 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
179 /* link flags are currently at most 18 bits, let's align to
181 if (unknown_flags_added)
183 "unknown link flags gained: %#.5x (ignoring)",
184 unknown_flags_added);
186 if (unknown_flags_removed)
188 "unknown link flags lost: %#.5x (ignoring)",
189 unknown_flags_removed);
193 link->kernel_operstate = operstate;
200 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
201 _cleanup_link_unref_ Link *link = NULL;
210 r = sd_rtnl_message_get_type(message, &type);
213 else if (type != RTM_NEWLINK)
216 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
219 else if (ifindex <= 0)
222 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
226 link = new0(Link, 1);
231 link->manager = manager;
232 link->state = LINK_STATE_PENDING;
233 link->ifindex = ifindex;
234 link->ifname = strdup(ifname);
238 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
240 log_link_debug(link, "MAC address not found for new device, continuing without");
242 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
247 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
252 r = asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d",
258 r = hashmap_ensure_allocated(&manager->links, NULL);
262 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
266 r = link_update_flags(link, message);
276 static void link_free(Link *link) {
282 while ((address = link->addresses)) {
283 LIST_REMOVE(addresses, link->addresses, address);
284 address_free(address);
287 while ((address = link->pool_addresses)) {
288 LIST_REMOVE(addresses, link->pool_addresses, address);
289 address_free(address);
292 sd_dhcp_server_unref(link->dhcp_server);
293 sd_dhcp_client_unref(link->dhcp_client);
294 sd_dhcp_lease_unref(link->dhcp_lease);
296 free(link->lease_file);
298 sd_lldp_free(link->lldp);
300 free(link->lldp_file);
302 sd_ipv4ll_unref(link->ipv4ll);
303 sd_dhcp6_client_unref(link->dhcp6_client);
304 sd_icmp6_nd_unref(link->icmp6_router_discovery);
307 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
311 free(link->state_file);
313 udev_device_unref(link->udev_device);
318 Link *link_unref(Link *link) {
319 if (link && (-- link->n_ref <= 0))
325 Link *link_ref(Link *link) {
327 assert_se(++ link->n_ref >= 2);
332 int link_get(Manager *m, int ifindex, Link **ret) {
339 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
348 static void link_set_state(Link *link, LinkState state) {
351 if (link->state == state)
356 link_send_changed(link, "AdministrativeState", NULL);
361 void link_drop(Link *link) {
362 if (!link || link->state == LINK_STATE_LINGER)
365 link_set_state(link, LINK_STATE_LINGER);
367 log_link_debug(link, "link removed");
374 static void link_enter_unmanaged(Link *link) {
377 log_link_debug(link, "unmanaged");
379 link_set_state(link, LINK_STATE_UNMANAGED);
384 static int link_stop_clients(Link *link) {
388 assert(link->manager);
389 assert(link->manager->event);
394 if (link->dhcp_client) {
395 k = sd_dhcp_client_stop(link->dhcp_client);
397 log_link_warning(link, "Could not stop DHCPv4 client: %s",
404 k = sd_ipv4ll_stop(link->ipv4ll);
406 log_link_warning(link, "Could not stop IPv4 link-local: %s",
412 if(link->icmp6_router_discovery) {
414 if (link->dhcp6_client) {
415 k = sd_dhcp6_client_stop(link->dhcp6_client);
417 log_link_warning(link, "Could not stop DHCPv6 client: %s",
423 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
425 log_link_warning(link,
426 "Could not stop ICMPv6 router discovery: %s",
434 k = sd_lldp_stop(link->lldp);
436 log_link_warning(link, "Could not stop LLDP : %s",
445 void link_enter_failed(Link *link) {
448 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
451 log_link_warning(link, "failed");
453 link_set_state(link, LINK_STATE_FAILED);
455 link_stop_clients(link);
460 static Address* link_find_dhcp_server_address(Link *link) {
464 assert(link->network);
466 /* The first statically configured address if there is any */
467 LIST_FOREACH(addresses, address, link->network->static_addresses) {
469 if (address->family != AF_INET)
472 if (in_addr_is_null(address->family, &address->in_addr))
478 /* If that didn't work, find a suitable address we got from the pool */
479 LIST_FOREACH(addresses, address, link->pool_addresses) {
480 if (address->family != AF_INET)
489 static int link_enter_configured(Link *link) {
491 assert(link->network);
492 assert(link->state == LINK_STATE_SETTING_ROUTES);
494 log_link_info(link, "link configured");
496 link_set_state(link, LINK_STATE_CONFIGURED);
503 void link_client_handler(Link *link) {
505 assert(link->network);
507 if (!link->static_configured)
510 if (link_ipv4ll_enabled(link))
511 if (!link->ipv4ll_address ||
515 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
518 if (link->state != LINK_STATE_CONFIGURED)
519 link_enter_configured(link);
524 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
525 _cleanup_link_unref_ Link *link = userdata;
528 assert(link->link_messages > 0);
529 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
530 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
533 link->link_messages --;
535 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
538 r = sd_rtnl_message_get_errno(m);
539 if (r < 0 && r != -EEXIST)
540 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
542 if (link->link_messages == 0) {
543 log_link_debug(link, "routes set");
544 link->static_configured = true;
545 link_client_handler(link);
551 static int link_enter_set_routes(Link *link) {
556 assert(link->network);
557 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
559 link_set_state(link, LINK_STATE_SETTING_ROUTES);
561 LIST_FOREACH(routes, rt, link->network->static_routes) {
562 r = route_configure(rt, link, &route_handler);
564 log_link_warning(link,
565 "could not set routes: %s",
567 link_enter_failed(link);
571 link->link_messages ++;
574 if (link->link_messages == 0) {
575 link->static_configured = true;
576 link_client_handler(link);
578 log_link_debug(link, "setting routes");
583 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
584 _cleanup_link_unref_ Link *link = userdata;
589 assert(link->ifname);
591 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
594 r = sd_rtnl_message_get_errno(m);
595 if (r < 0 && r != -ESRCH)
596 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
601 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
602 _cleanup_link_unref_ Link *link = userdata;
608 assert(link->ifname);
609 assert(link->link_messages > 0);
610 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
611 LINK_STATE_FAILED, LINK_STATE_LINGER));
613 link->link_messages --;
615 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
618 r = sd_rtnl_message_get_errno(m);
619 if (r < 0 && r != -EEXIST)
620 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
622 link_rtnl_process_address(rtnl, m, link->manager);
624 if (link->link_messages == 0) {
625 log_link_debug(link, "addresses set");
626 link_enter_set_routes(link);
632 static int link_enter_set_addresses(Link *link) {
637 assert(link->network);
638 assert(link->state != _LINK_STATE_INVALID);
640 link_set_state(link, LINK_STATE_SETTING_ADDRESSES);
642 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
643 r = address_configure(ad, link, &address_handler);
645 log_link_warning_errno(link, r, "Could not set addresses: %m");
646 link_enter_failed(link);
650 link->link_messages ++;
653 /* now that we can figure out a default address for the dhcp server,
655 if (link_dhcp4_server_enabled(link)) {
656 struct in_addr pool_start;
659 address = link_find_dhcp_server_address(link);
661 log_link_warning(link,
662 "Failed to find suitable address for DHCPv4 server instance.");
663 link_enter_failed(link);
667 r = sd_dhcp_server_set_address(link->dhcp_server,
668 &address->in_addr.in,
673 /* offer 32 addresses starting from the address following the server address */
674 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
675 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
681 r = sd_dhcp_server_set_router(link->dhcp_server,
682 &main_address->in_addr.in);
686 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
687 main_address->prefixlen);
692 r = sd_dhcp_server_start(link->dhcp_server);
694 log_link_warning(link, "could not start DHCPv4 server "
695 "instance: %s", strerror(-r));
697 link_enter_failed(link);
702 log_link_debug(link, "offering DHCPv4 leases");
705 if (link->link_messages == 0) {
706 link_enter_set_routes(link);
708 log_link_debug(link, "setting addresses");
713 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
714 _cleanup_link_unref_ Link *link = userdata;
719 assert(link->ifname);
721 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
724 r = sd_rtnl_message_get_errno(m);
725 if (r < 0 && r != -EADDRNOTAVAIL)
726 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
731 static int link_set_bridge_fdb(const Link *const link) {
735 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
736 r = fdb_entry_configure(link->manager->rtnl, fdb_entry, link->ifindex);
738 log_link_error(link, "Failed to add MAC entry to static MAC table: %s", strerror(-r));
746 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
747 _cleanup_link_unref_ Link *link = userdata;
750 log_link_debug(link, "set link");
752 r = sd_rtnl_message_get_errno(m);
753 if (r < 0 && r != -EEXIST) {
754 log_link_struct(link, LOG_ERR,
755 "MESSAGE=%-*s: could not join netdev: %s",
757 link->ifname, strerror(-r),
760 link_enter_failed(link);
767 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
768 sd_bus_error *ret_error) {
769 _cleanup_link_unref_ Link *link = userdata;
774 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
777 r = sd_bus_message_get_errno(m);
779 log_link_warning(link, "Could not set hostname: %s",
785 int link_set_hostname(Link *link, const char *hostname) {
786 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
790 assert(link->manager);
793 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
795 if (!link->manager->bus) {
796 /* TODO: replace by assert when we can rely on kdbus */
798 "Not connected to system bus, ignoring transient hostname.");
802 r = sd_bus_message_new_method_call(
805 "org.freedesktop.hostname1",
806 "/org/freedesktop/hostname1",
807 "org.freedesktop.hostname1",
812 r = sd_bus_message_append(m, "sb", hostname, false);
816 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
819 log_link_error(link, "Could not set transient hostname: %s",
829 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
830 _cleanup_link_unref_ Link *link = userdata;
835 assert(link->ifname);
837 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
840 r = sd_rtnl_message_get_errno(m);
842 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
847 int link_set_mtu(Link *link, uint32_t mtu) {
848 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
852 assert(link->manager);
853 assert(link->manager->rtnl);
855 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
857 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
858 RTM_SETLINK, link->ifindex);
860 log_link_error(link, "Could not allocate RTM_SETLINK message");
864 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
866 log_link_error(link, "Could not append MTU: %s", strerror(-r));
870 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
874 "Could not send rtnetlink message: %s",
884 static int link_set_bridge(Link *link) {
885 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
889 assert(link->network);
891 if(link->network->cost == 0)
894 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
895 RTM_SETLINK, link->ifindex);
897 log_link_error(link, "Could not allocate RTM_SETLINK message");
901 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
904 "Could not set message family %s", strerror(-r));
908 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
911 "Could not append IFLA_PROTINFO attribute: %s",
916 if(link->network->cost != 0) {
917 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
920 "Could not append IFLA_BRPORT_COST attribute: %s",
926 r = sd_rtnl_message_close_container(req);
929 "Could not append IFLA_LINKINFO attribute: %s",
934 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
937 "Could not send rtnetlink message: %s",
947 static void lldp_handler(sd_lldp *lldp, int event, void *userdata) {
948 Link *link = userdata;
952 assert(link->network);
953 assert(link->manager);
955 if (event != UPDATE_INFO)
958 r = sd_lldp_save(link->lldp, link->lldp_file);
960 log_link_warning(link, "could not save LLDP");
964 static int link_acquire_conf(Link *link) {
968 assert(link->network);
969 assert(link->manager);
970 assert(link->manager->event);
972 if (link_ipv4ll_enabled(link)) {
973 assert(link->ipv4ll);
975 log_link_debug(link, "acquiring IPv4 link-local address");
977 r = sd_ipv4ll_start(link->ipv4ll);
979 log_link_warning(link, "could not acquire IPv4 "
980 "link-local address");
985 if (link_dhcp4_enabled(link)) {
986 assert(link->dhcp_client);
988 log_link_debug(link, "acquiring DHCPv4 lease");
990 r = sd_dhcp_client_start(link->dhcp_client);
992 log_link_warning(link, "could not acquire DHCPv4 "
998 if (link_dhcp6_enabled(link)) {
999 assert(link->icmp6_router_discovery);
1001 log_link_debug(link, "discovering IPv6 routers");
1003 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1005 log_link_warning(link,
1006 "could not start IPv6 router discovery");
1011 if (link_lldp_enabled(link)) {
1014 log_link_debug(link, "Starting LLDP");
1016 r = sd_lldp_start(link->lldp);
1018 log_link_warning(link, "could not start LLDP ");
1026 bool link_has_carrier(Link *link) {
1027 /* see Documentation/networking/operstates.txt in the kernel sources */
1029 if (link->kernel_operstate == IF_OPER_UP)
1032 if (link->kernel_operstate == IF_OPER_UNKNOWN)
1033 /* operstate may not be implemented, so fall back to flags */
1034 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1040 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1041 _cleanup_link_unref_ Link *link = userdata;
1046 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1049 r = sd_rtnl_message_get_errno(m);
1051 /* we warn but don't fail the link, as it may
1052 be brought up later */
1053 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
1059 static int link_up(Link *link) {
1060 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1064 assert(link->network);
1065 assert(link->manager);
1066 assert(link->manager->rtnl);
1068 log_link_debug(link, "bringing link up");
1070 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1071 RTM_SETLINK, link->ifindex);
1073 log_link_error(link, "Could not allocate RTM_SETLINK message");
1077 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1079 log_link_error(link, "Could not set link flags: %s",
1084 if (link->network->mac) {
1085 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1087 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
1092 if (link->network->mtu) {
1093 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
1095 log_link_error(link, "Could not set MTU: %s", strerror(-r));
1100 if (!link_ipv6ll_enabled(link)) {
1101 r = sd_rtnl_message_open_container(req, IFLA_AF_SPEC);
1103 log_link_error(link, "Could not open IFLA_AF_SPEC container: %s", strerror(-r));
1107 r = sd_rtnl_message_open_container(req, AF_INET6);
1109 log_link_error(link, "Could not open AF_INET6 container: %s", strerror(-r));
1113 r = sd_rtnl_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, IN6_ADDR_GEN_MODE_NONE);
1115 log_link_error(link, "Could not append IFLA_INET6_ADDR_GEN_MODE: %s", strerror(-r));
1119 r = sd_rtnl_message_close_container(req);
1121 log_link_error(link, "Could not close AF_INET6 contaire: %s", strerror(-r));
1125 r = sd_rtnl_message_close_container(req);
1127 log_link_error(link, "Could not close IFLA_AF_SPEC contaire: %s", strerror(-r));
1132 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1135 log_link_error(link,
1136 "Could not send rtnetlink message: %s",
1146 static int link_joined(Link *link) {
1150 assert(link->network);
1152 if (!(link->flags & IFF_UP)) {
1155 link_enter_failed(link);
1160 if(link->network->bridge) {
1161 r = link_set_bridge(link);
1163 log_link_error(link,
1164 "Could not set bridge message: %s",
1169 return link_enter_set_addresses(link);
1172 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1174 _cleanup_link_unref_ Link *link = userdata;
1178 assert(link->network);
1182 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1185 r = sd_rtnl_message_get_errno(m);
1186 if (r < 0 && r != -EEXIST) {
1187 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1188 link_enter_failed(link);
1191 log_link_debug(link, "joined netdev");
1193 if (link->enslaving <= 0)
1199 static int link_enter_join_netdev(Link *link) {
1205 assert(link->network);
1206 assert(link->state == LINK_STATE_PENDING);
1208 link_set_state(link, LINK_STATE_ENSLAVING);
1212 if (!link->network->bridge &&
1213 !link->network->bond &&
1214 hashmap_isempty(link->network->stacked_netdevs))
1215 return link_joined(link);
1217 if (link->network->bond) {
1218 log_link_struct(link, LOG_DEBUG,
1219 "MESSAGE=%-*s: enslaving by '%s'",
1221 link->ifname, link->network->bond->ifname,
1222 NETDEVIF(link->network->bond),
1225 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1227 log_link_struct(link, LOG_WARNING,
1228 "MESSAGE=%-*s: could not join netdev '%s': %s",
1230 link->ifname, link->network->bond->ifname,
1232 NETDEVIF(link->network->bond),
1234 link_enter_failed(link);
1241 if (link->network->bridge) {
1242 log_link_struct(link, LOG_DEBUG,
1243 "MESSAGE=%-*s: enslaving by '%s'",
1245 link->ifname, link->network->bridge->ifname,
1246 NETDEVIF(link->network->bridge),
1249 r = netdev_join(link->network->bridge, link,
1250 &netdev_join_handler);
1252 log_link_struct(link, LOG_WARNING,
1253 "MESSAGE=%-*s: could not join netdev '%s': %s",
1255 link->ifname, link->network->bridge->ifname,
1257 NETDEVIF(link->network->bridge),
1259 link_enter_failed(link);
1266 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1267 log_link_struct(link, LOG_DEBUG,
1268 "MESSAGE=%-*s: enslaving by '%s'",
1270 link->ifname, netdev->ifname, NETDEVIF(netdev),
1273 r = netdev_join(netdev, link, &netdev_join_handler);
1275 log_link_struct(link, LOG_WARNING,
1276 "MESSAGE=%-*s: could not join netdev '%s': %s",
1278 link->ifname, netdev->ifname,
1280 NETDEVIF(netdev), NULL);
1281 link_enter_failed(link);
1291 static int link_set_ipv4_forward(Link *link) {
1292 const char *p = NULL;
1296 b = link_ipv4_forward_enabled(link);
1298 p = strjoina("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
1299 r = write_string_file_no_create(p, one_zero(b));
1301 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
1304 _cleanup_free_ char *buf = NULL;
1306 /* If IP forwarding is turned on for this interface,
1307 * then propagate this to the global setting. Given
1308 * that turning this on has side-effects on other
1309 * fields, we'll try to avoid doing this unless
1310 * necessary, hence check the previous value
1311 * first. Note that we never turn this option off
1312 * again, since all interfaces we manage do not do
1313 * forwarding anyway by default, and ownership rules
1314 * of this control are so unclear. */
1316 r = read_one_line_file("/proc/sys/net/ipv4/ip_forward", &buf);
1318 log_link_warning_errno(link, r, "Cannot read /proc/sys/net/ipv4/ip_forward: %m");
1319 else if (!streq(buf, "1")) {
1320 r = write_string_file_no_create("/proc/sys/net/ipv4/ip_forward", "1");
1322 log_link_warning_errno(link, r, "Cannot write /proc/sys/net/ipv4/ip_forward: %m");
1329 static int link_set_ipv6_forward(Link *link) {
1330 const char *p = NULL;
1333 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
1334 r = write_string_file_no_create(p, one_zero(link_ipv6_forward_enabled(link)));
1336 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
1341 static int link_configure(Link *link) {
1345 assert(link->network);
1346 assert(link->state == LINK_STATE_PENDING);
1348 r = link_set_bridge_fdb(link);
1352 r = link_set_ipv4_forward(link);
1356 r = link_set_ipv6_forward(link);
1360 if (link_ipv4ll_enabled(link)) {
1361 r = ipv4ll_configure(link);
1366 if (link_dhcp4_enabled(link)) {
1367 r = dhcp4_configure(link);
1372 if (link_dhcp4_server_enabled(link)) {
1373 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1377 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1382 if (link_dhcp6_enabled(link)) {
1383 r = icmp6_configure(link);
1388 if (link_lldp_enabled(link)) {
1389 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1393 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1397 r = sd_lldp_set_callback(link->lldp,
1398 lldp_handler, link);
1403 if (link_has_carrier(link)) {
1404 r = link_acquire_conf(link);
1409 return link_enter_join_netdev(link);
1412 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1414 _cleanup_link_unref_ Link *link = userdata;
1419 assert(link->ifname);
1420 assert(link->manager);
1422 if (link->state != LINK_STATE_PENDING)
1425 log_link_debug(link, "link state is up-to-date");
1427 r = network_get(link->manager, link->udev_device, link->ifname,
1428 &link->mac, &network);
1430 link_enter_unmanaged(link);
1435 if (link->flags & IFF_LOOPBACK) {
1436 if (network->link_local != ADDRESS_FAMILY_NO)
1437 log_link_debug(link, "ignoring link-local autoconfiguration for loopback link");
1439 if (network->dhcp != ADDRESS_FAMILY_NO)
1440 log_link_debug(link, "ignoring DHCP clients for loopback link");
1442 if (network->dhcp_server)
1443 log_link_debug(link, "ignoring DHCP server for loopback link");
1446 r = network_apply(link->manager, network, link);
1450 r = link_configure(link);
1457 int link_initialized(Link *link, struct udev_device *device) {
1458 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1462 assert(link->manager);
1463 assert(link->manager->rtnl);
1466 if (link->state != LINK_STATE_PENDING)
1469 if (link->udev_device)
1472 log_link_debug(link, "udev initialized link");
1474 link->udev_device = udev_device_ref(device);
1476 /* udev has initialized the link, but we don't know if we have yet
1477 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1478 * when it returns we know that the pending NEWLINKs have already been
1479 * processed and that we are up-to-date */
1481 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1486 r = sd_rtnl_call_async(link->manager->rtnl, req,
1487 link_initialized_and_synced, link, 0, NULL);
1496 static Address* link_get_equal_address(Link *link, Address *needle) {
1502 LIST_FOREACH(addresses, i, link->addresses)
1503 if (address_equal(i, needle))
1509 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1510 Manager *m = userdata;
1513 _cleanup_address_free_ Address *address = NULL;
1515 char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
1516 const char *valid_str = NULL;
1523 if (sd_rtnl_message_is_error(message)) {
1524 r = sd_rtnl_message_get_errno(message);
1526 log_warning_errno(r, "rtnl: failed to receive address: %m");
1531 r = sd_rtnl_message_get_type(message, &type);
1533 log_warning("rtnl: could not get message type");
1537 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1539 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1541 } else if (ifindex <= 0) {
1542 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1545 r = link_get(m, ifindex, &link);
1546 if (r < 0 || !link) {
1547 /* when enumerating we might be out of sync, but we will
1548 * get the address again, so just ignore it */
1549 if (!m->enumerating)
1550 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1555 r = address_new_dynamic(&address);
1559 r = sd_rtnl_message_addr_get_family(message, &address->family);
1560 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1561 log_link_warning(link, "rtnl: received address with invalid family, ignoring");
1565 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1567 log_link_warning(link, "rtnl: received address with invalid prefixlen, ignoring");
1571 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1573 log_link_warning(link, "rtnl: received address with invalid scope, ignoring");
1577 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1579 log_link_warning(link, "rtnl: received address with invalid flags, ignoring");
1583 switch (address->family) {
1585 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1587 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1594 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1596 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1603 assert_not_reached("invalid address family");
1606 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1607 log_link_warning(link, "could not print address");
1611 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1613 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1616 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1617 address->cinfo.ifa_valid * USEC_PER_SEC,
1621 existing = link_get_equal_address(link, address);
1626 log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1629 existing->scope = address->scope;
1630 existing->flags = address->flags;
1631 existing->cinfo = address->cinfo;
1634 log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1636 LIST_PREPEND(addresses, link->addresses, address);
1637 address_establish(address, link);
1649 log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1650 address_release(existing, link);
1651 LIST_REMOVE(addresses, link->addresses, existing);
1652 address_free(existing);
1654 log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1658 assert_not_reached("Received invalid RTNL message type");
1664 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1666 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1667 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1675 r = link_new(m, message, ret);
1681 log_link_debug(link, "link %d added", link->ifindex);
1683 if (detect_container(NULL) <= 0) {
1684 /* not in a container, udev will be around */
1685 sprintf(ifindex_str, "n%d", link->ifindex);
1686 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1688 log_link_warning(link,
1689 "could not find udev device: %m");
1693 if (udev_device_get_is_initialized(device) <= 0) {
1695 log_link_debug(link, "link pending udev initialization...");
1699 r = link_initialized(link, device);
1703 /* we are calling a callback directly, so must take a ref */
1706 r = link_initialized_and_synced(m->rtnl, NULL, link);
1714 static int link_carrier_gained(Link *link) {
1719 if (link->network) {
1720 r = link_acquire_conf(link);
1722 link_enter_failed(link);
1730 static int link_carrier_lost(Link *link) {
1735 r = link_stop_clients(link);
1737 link_enter_failed(link);
1744 int link_carrier_reset(Link *link) {
1749 if (link_has_carrier(link)) {
1750 r = link_carrier_lost(link);
1754 r = link_carrier_gained(link);
1758 log_link_info(link, "reset carrier");
1765 int link_update(Link *link, sd_rtnl_message *m) {
1766 struct ether_addr mac;
1769 bool had_carrier, carrier_gained, carrier_lost;
1773 assert(link->ifname);
1776 if (link->state == LINK_STATE_LINGER) {
1778 log_link_info(link, "link readded");
1779 link_set_state(link, LINK_STATE_ENSLAVING);
1782 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1783 if (r >= 0 && !streq(ifname, link->ifname)) {
1784 log_link_info(link, "renamed to %s", ifname);
1787 link->ifname = strdup(ifname);
1792 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1793 if (r >= 0 && mtu > 0) {
1795 if (!link->original_mtu) {
1796 link->original_mtu = mtu;
1797 log_link_debug(link, "saved original MTU: %"
1798 PRIu32, link->original_mtu);
1801 if (link->dhcp_client) {
1802 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1805 log_link_warning(link,
1806 "Could not update MTU in DHCP client: %s",
1813 /* The kernel may broadcast NEWLINK messages without the MAC address
1814 set, simply ignore them. */
1815 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1817 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1820 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1823 log_link_debug(link, "MAC address: "
1824 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1825 mac.ether_addr_octet[0],
1826 mac.ether_addr_octet[1],
1827 mac.ether_addr_octet[2],
1828 mac.ether_addr_octet[3],
1829 mac.ether_addr_octet[4],
1830 mac.ether_addr_octet[5]);
1833 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1835 log_link_warning(link,
1836 "Could not update MAC address in IPv4LL client: %s",
1842 if (link->dhcp_client) {
1843 r = sd_dhcp_client_set_mac(link->dhcp_client,
1844 (const uint8_t *) &link->mac,
1848 log_link_warning(link,
1849 "Could not update MAC address in DHCP client: %s",
1855 if (link->dhcp6_client) {
1856 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1857 (const uint8_t *) &link->mac,
1861 log_link_warning(link,
1862 "Could not update MAC address in DHCPv6 client: %s",
1870 had_carrier = link_has_carrier(link);
1872 r = link_update_flags(link, m);
1876 carrier_gained = !had_carrier && link_has_carrier(link);
1877 carrier_lost = had_carrier && !link_has_carrier(link);
1879 if (carrier_gained) {
1880 log_link_info(link, "gained carrier");
1882 r = link_carrier_gained(link);
1885 } else if (carrier_lost) {
1886 log_link_info(link, "lost carrier");
1888 r = link_carrier_lost(link);
1897 static void link_update_operstate(Link *link) {
1898 LinkOperationalState operstate;
1901 if (link->kernel_operstate == IF_OPER_DORMANT)
1902 operstate = LINK_OPERSTATE_DORMANT;
1903 else if (link_has_carrier(link)) {
1905 uint8_t scope = RT_SCOPE_NOWHERE;
1907 /* if we have carrier, check what addresses we have */
1908 LIST_FOREACH(addresses, address, link->addresses) {
1909 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1912 if (address->scope < scope)
1913 scope = address->scope;
1916 if (scope < RT_SCOPE_SITE)
1917 /* universally accessible addresses found */
1918 operstate = LINK_OPERSTATE_ROUTABLE;
1919 else if (scope < RT_SCOPE_HOST)
1920 /* only link or site local addresses found */
1921 operstate = LINK_OPERSTATE_DEGRADED;
1923 /* no useful addresses found */
1924 operstate = LINK_OPERSTATE_CARRIER;
1925 } else if (link->flags & IFF_UP)
1926 operstate = LINK_OPERSTATE_NO_CARRIER;
1928 operstate = LINK_OPERSTATE_OFF;
1930 if (link->operstate != operstate) {
1931 link->operstate = operstate;
1932 link_send_changed(link, "OperationalState", NULL);
1936 int link_save(Link *link) {
1937 _cleanup_free_ char *temp_path = NULL;
1938 _cleanup_fclose_ FILE *f = NULL;
1939 const char *admin_state, *oper_state;
1943 assert(link->state_file);
1944 assert(link->lease_file);
1945 assert(link->manager);
1947 link_update_operstate(link);
1949 r = manager_save(link->manager);
1953 if (link->state == LINK_STATE_LINGER) {
1954 unlink(link->state_file);
1958 admin_state = link_state_to_string(link->state);
1959 assert(admin_state);
1961 oper_state = link_operstate_to_string(link->operstate);
1964 r = fopen_temporary(link->state_file, &f, &temp_path);
1968 fchmod(fileno(f), 0644);
1971 "# This is private data. Do not parse.\n"
1974 admin_state, oper_state);
1976 if (link->network) {
1977 char **address, **domain;
1980 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1984 STRV_FOREACH(address, link->network->dns) {
1991 if (link->network->dhcp_dns &&
1993 const struct in_addr *addresses;
1995 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1999 serialize_in_addrs(f, addresses, r);
2007 STRV_FOREACH(address, link->network->ntp) {
2014 if (link->network->dhcp_ntp &&
2016 const struct in_addr *addresses;
2018 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2022 serialize_in_addrs(f, addresses, r);
2028 fprintf(f, "DOMAINS=");
2030 STRV_FOREACH(domain, link->network->domains) {
2037 if (link->network->dhcp_domains &&
2039 const char *domainname;
2041 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
2045 fputs(domainname, f);
2051 fprintf(f, "WILDCARD_DOMAIN=%s\n",
2052 yes_no(link->network->wildcard_domain));
2054 fprintf(f, "LLMNR=%s\n",
2055 llmnr_support_to_string(link->network->llmnr));
2058 if (link->dhcp_lease) {
2059 assert(link->network);
2061 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
2069 unlink(link->lease_file);
2072 assert(link->network);
2074 r = sd_lldp_save(link->lldp, link->lldp_file);
2082 unlink(link->lldp_file);
2084 r = fflush_and_check(f);
2088 if (rename(temp_path, link->state_file) < 0) {
2095 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2096 unlink(link->state_file);
2101 static const char* const link_state_table[_LINK_STATE_MAX] = {
2102 [LINK_STATE_PENDING] = "pending",
2103 [LINK_STATE_ENSLAVING] = "configuring",
2104 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2105 [LINK_STATE_SETTING_ROUTES] = "configuring",
2106 [LINK_STATE_CONFIGURED] = "configured",
2107 [LINK_STATE_UNMANAGED] = "unmanaged",
2108 [LINK_STATE_FAILED] = "failed",
2109 [LINK_STATE_LINGER] = "linger",
2112 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2114 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2115 [LINK_OPERSTATE_OFF] = "off",
2116 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2117 [LINK_OPERSTATE_DORMANT] = "dormant",
2118 [LINK_OPERSTATE_CARRIER] = "carrier",
2119 [LINK_OPERSTATE_DEGRADED] = "degraded",
2120 [LINK_OPERSTATE_ROUTABLE] = "routable",
2123 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);