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 r = sd_rtnl_message_open_container(req, IFLA_AF_SPEC);
1102 log_link_error(link, "Could not open IFLA_AF_SPEC container: %s", strerror(-r));
1106 r = sd_rtnl_message_open_container(req, AF_INET6);
1108 log_link_error(link, "Could not open AF_INET6 container: %s", strerror(-r));
1112 if (!link_ipv6ll_enabled(link)) {
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));
1120 if (!in_addr_is_null(AF_INET6, &link->network->ipv6_token)) {
1121 r = sd_rtnl_message_append_in6_addr(req, IFLA_INET6_TOKEN, &link->network->ipv6_token.in6);
1123 log_link_error(link, "Could not append IFLA_INET6_TOKEN: %s", strerror(-r));
1128 r = sd_rtnl_message_close_container(req);
1130 log_link_error(link, "Could not close AF_INET6 container: %s", strerror(-r));
1134 r = sd_rtnl_message_close_container(req);
1136 log_link_error(link, "Could not close IFLA_AF_SPEC container: %s", strerror(-r));
1140 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1143 log_link_error(link,
1144 "Could not send rtnetlink message: %s",
1154 static int link_joined(Link *link) {
1158 assert(link->network);
1160 if (!(link->flags & IFF_UP)) {
1163 link_enter_failed(link);
1168 if(link->network->bridge) {
1169 r = link_set_bridge(link);
1171 log_link_error(link,
1172 "Could not set bridge message: %s",
1177 return link_enter_set_addresses(link);
1180 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1182 _cleanup_link_unref_ Link *link = userdata;
1186 assert(link->network);
1190 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1193 r = sd_rtnl_message_get_errno(m);
1194 if (r < 0 && r != -EEXIST) {
1195 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1196 link_enter_failed(link);
1199 log_link_debug(link, "joined netdev");
1201 if (link->enslaving <= 0)
1207 static int link_enter_join_netdev(Link *link) {
1213 assert(link->network);
1214 assert(link->state == LINK_STATE_PENDING);
1216 link_set_state(link, LINK_STATE_ENSLAVING);
1220 if (!link->network->bridge &&
1221 !link->network->bond &&
1222 hashmap_isempty(link->network->stacked_netdevs))
1223 return link_joined(link);
1225 if (link->network->bond) {
1226 log_link_struct(link, LOG_DEBUG,
1227 "MESSAGE=%-*s: enslaving by '%s'",
1229 link->ifname, link->network->bond->ifname,
1230 NETDEVIF(link->network->bond),
1233 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1235 log_link_struct(link, LOG_WARNING,
1236 "MESSAGE=%-*s: could not join netdev '%s': %s",
1238 link->ifname, link->network->bond->ifname,
1240 NETDEVIF(link->network->bond),
1242 link_enter_failed(link);
1249 if (link->network->bridge) {
1250 log_link_struct(link, LOG_DEBUG,
1251 "MESSAGE=%-*s: enslaving by '%s'",
1253 link->ifname, link->network->bridge->ifname,
1254 NETDEVIF(link->network->bridge),
1257 r = netdev_join(link->network->bridge, link,
1258 &netdev_join_handler);
1260 log_link_struct(link, LOG_WARNING,
1261 "MESSAGE=%-*s: could not join netdev '%s': %s",
1263 link->ifname, link->network->bridge->ifname,
1265 NETDEVIF(link->network->bridge),
1267 link_enter_failed(link);
1274 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1275 log_link_struct(link, LOG_DEBUG,
1276 "MESSAGE=%-*s: enslaving by '%s'",
1278 link->ifname, netdev->ifname, NETDEVIF(netdev),
1281 r = netdev_join(netdev, link, &netdev_join_handler);
1283 log_link_struct(link, LOG_WARNING,
1284 "MESSAGE=%-*s: could not join netdev '%s': %s",
1286 link->ifname, netdev->ifname,
1288 NETDEVIF(netdev), NULL);
1289 link_enter_failed(link);
1299 static int link_set_ipv4_forward(Link *link) {
1300 const char *p = NULL;
1304 b = link_ipv4_forward_enabled(link);
1306 p = strjoina("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
1307 r = write_string_file_no_create(p, one_zero(b));
1309 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
1312 _cleanup_free_ char *buf = NULL;
1314 /* If IP forwarding is turned on for this interface,
1315 * then propagate this to the global setting. Given
1316 * that turning this on has side-effects on other
1317 * fields, we'll try to avoid doing this unless
1318 * necessary, hence check the previous value
1319 * first. Note that we never turn this option off
1320 * again, since all interfaces we manage do not do
1321 * forwarding anyway by default, and ownership rules
1322 * of this control are so unclear. */
1324 r = read_one_line_file("/proc/sys/net/ipv4/ip_forward", &buf);
1326 log_link_warning_errno(link, r, "Cannot read /proc/sys/net/ipv4/ip_forward: %m");
1327 else if (!streq(buf, "1")) {
1328 r = write_string_file_no_create("/proc/sys/net/ipv4/ip_forward", "1");
1330 log_link_warning_errno(link, r, "Cannot write /proc/sys/net/ipv4/ip_forward: %m");
1337 static int link_set_ipv6_forward(Link *link) {
1338 const char *p = NULL;
1341 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
1342 r = write_string_file_no_create(p, one_zero(link_ipv6_forward_enabled(link)));
1344 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
1349 static int link_configure(Link *link) {
1353 assert(link->network);
1354 assert(link->state == LINK_STATE_PENDING);
1356 r = link_set_bridge_fdb(link);
1360 r = link_set_ipv4_forward(link);
1364 r = link_set_ipv6_forward(link);
1368 if (link_ipv4ll_enabled(link)) {
1369 r = ipv4ll_configure(link);
1374 if (link_dhcp4_enabled(link)) {
1375 r = dhcp4_configure(link);
1380 if (link_dhcp4_server_enabled(link)) {
1381 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1385 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1390 if (link_dhcp6_enabled(link)) {
1391 r = icmp6_configure(link);
1396 if (link_lldp_enabled(link)) {
1397 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1401 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1405 r = sd_lldp_set_callback(link->lldp,
1406 lldp_handler, link);
1411 if (link_has_carrier(link)) {
1412 r = link_acquire_conf(link);
1417 return link_enter_join_netdev(link);
1420 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1422 _cleanup_link_unref_ Link *link = userdata;
1427 assert(link->ifname);
1428 assert(link->manager);
1430 if (link->state != LINK_STATE_PENDING)
1433 log_link_debug(link, "link state is up-to-date");
1435 r = network_get(link->manager, link->udev_device, link->ifname,
1436 &link->mac, &network);
1438 link_enter_unmanaged(link);
1443 if (link->flags & IFF_LOOPBACK) {
1444 if (network->link_local != ADDRESS_FAMILY_NO)
1445 log_link_debug(link, "ignoring link-local autoconfiguration for loopback link");
1447 if (network->dhcp != ADDRESS_FAMILY_NO)
1448 log_link_debug(link, "ignoring DHCP clients for loopback link");
1450 if (network->dhcp_server)
1451 log_link_debug(link, "ignoring DHCP server for loopback link");
1454 r = network_apply(link->manager, network, link);
1458 r = link_configure(link);
1465 int link_initialized(Link *link, struct udev_device *device) {
1466 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1470 assert(link->manager);
1471 assert(link->manager->rtnl);
1474 if (link->state != LINK_STATE_PENDING)
1477 if (link->udev_device)
1480 log_link_debug(link, "udev initialized link");
1482 link->udev_device = udev_device_ref(device);
1484 /* udev has initialized the link, but we don't know if we have yet
1485 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1486 * when it returns we know that the pending NEWLINKs have already been
1487 * processed and that we are up-to-date */
1489 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1494 r = sd_rtnl_call_async(link->manager->rtnl, req,
1495 link_initialized_and_synced, link, 0, NULL);
1504 static Address* link_get_equal_address(Link *link, Address *needle) {
1510 LIST_FOREACH(addresses, i, link->addresses)
1511 if (address_equal(i, needle))
1517 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1518 Manager *m = userdata;
1521 _cleanup_address_free_ Address *address = NULL;
1523 char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
1524 const char *valid_str = NULL;
1531 if (sd_rtnl_message_is_error(message)) {
1532 r = sd_rtnl_message_get_errno(message);
1534 log_warning_errno(r, "rtnl: failed to receive address: %m");
1539 r = sd_rtnl_message_get_type(message, &type);
1541 log_warning("rtnl: could not get message type");
1545 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1547 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1549 } else if (ifindex <= 0) {
1550 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1553 r = link_get(m, ifindex, &link);
1554 if (r < 0 || !link) {
1555 /* when enumerating we might be out of sync, but we will
1556 * get the address again, so just ignore it */
1557 if (!m->enumerating)
1558 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1563 r = address_new_dynamic(&address);
1567 r = sd_rtnl_message_addr_get_family(message, &address->family);
1568 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1569 log_link_warning(link, "rtnl: received address with invalid family, ignoring");
1573 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1575 log_link_warning(link, "rtnl: received address with invalid prefixlen, ignoring");
1579 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1581 log_link_warning(link, "rtnl: received address with invalid scope, ignoring");
1585 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1587 log_link_warning(link, "rtnl: received address with invalid flags, ignoring");
1591 switch (address->family) {
1593 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1595 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1602 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1604 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1611 assert_not_reached("invalid address family");
1614 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1615 log_link_warning(link, "could not print address");
1619 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1621 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1624 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1625 address->cinfo.ifa_valid * USEC_PER_SEC,
1629 existing = link_get_equal_address(link, address);
1634 log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1637 existing->scope = address->scope;
1638 existing->flags = address->flags;
1639 existing->cinfo = address->cinfo;
1642 log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1644 LIST_PREPEND(addresses, link->addresses, address);
1645 address_establish(address, link);
1657 log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1658 address_release(existing, link);
1659 LIST_REMOVE(addresses, link->addresses, existing);
1660 address_free(existing);
1662 log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1666 assert_not_reached("Received invalid RTNL message type");
1672 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1674 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1675 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1683 r = link_new(m, message, ret);
1689 log_link_debug(link, "link %d added", link->ifindex);
1691 if (detect_container(NULL) <= 0) {
1692 /* not in a container, udev will be around */
1693 sprintf(ifindex_str, "n%d", link->ifindex);
1694 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1696 log_link_warning(link,
1697 "could not find udev device: %m");
1701 if (udev_device_get_is_initialized(device) <= 0) {
1703 log_link_debug(link, "link pending udev initialization...");
1707 r = link_initialized(link, device);
1711 /* we are calling a callback directly, so must take a ref */
1714 r = link_initialized_and_synced(m->rtnl, NULL, link);
1722 static int link_carrier_gained(Link *link) {
1727 if (link->network) {
1728 r = link_acquire_conf(link);
1730 link_enter_failed(link);
1738 static int link_carrier_lost(Link *link) {
1743 r = link_stop_clients(link);
1745 link_enter_failed(link);
1752 int link_carrier_reset(Link *link) {
1757 if (link_has_carrier(link)) {
1758 r = link_carrier_lost(link);
1762 r = link_carrier_gained(link);
1766 log_link_info(link, "reset carrier");
1773 int link_update(Link *link, sd_rtnl_message *m) {
1774 struct ether_addr mac;
1777 bool had_carrier, carrier_gained, carrier_lost;
1781 assert(link->ifname);
1784 if (link->state == LINK_STATE_LINGER) {
1786 log_link_info(link, "link readded");
1787 link_set_state(link, LINK_STATE_ENSLAVING);
1790 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1791 if (r >= 0 && !streq(ifname, link->ifname)) {
1792 log_link_info(link, "renamed to %s", ifname);
1795 link->ifname = strdup(ifname);
1800 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1801 if (r >= 0 && mtu > 0) {
1803 if (!link->original_mtu) {
1804 link->original_mtu = mtu;
1805 log_link_debug(link, "saved original MTU: %"
1806 PRIu32, link->original_mtu);
1809 if (link->dhcp_client) {
1810 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1813 log_link_warning(link,
1814 "Could not update MTU in DHCP client: %s",
1821 /* The kernel may broadcast NEWLINK messages without the MAC address
1822 set, simply ignore them. */
1823 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1825 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1828 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1831 log_link_debug(link, "MAC address: "
1832 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1833 mac.ether_addr_octet[0],
1834 mac.ether_addr_octet[1],
1835 mac.ether_addr_octet[2],
1836 mac.ether_addr_octet[3],
1837 mac.ether_addr_octet[4],
1838 mac.ether_addr_octet[5]);
1841 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1843 log_link_warning(link,
1844 "Could not update MAC address in IPv4LL client: %s",
1850 if (link->dhcp_client) {
1851 r = sd_dhcp_client_set_mac(link->dhcp_client,
1852 (const uint8_t *) &link->mac,
1856 log_link_warning(link,
1857 "Could not update MAC address in DHCP client: %s",
1863 if (link->dhcp6_client) {
1864 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1865 (const uint8_t *) &link->mac,
1869 log_link_warning(link,
1870 "Could not update MAC address in DHCPv6 client: %s",
1878 had_carrier = link_has_carrier(link);
1880 r = link_update_flags(link, m);
1884 carrier_gained = !had_carrier && link_has_carrier(link);
1885 carrier_lost = had_carrier && !link_has_carrier(link);
1887 if (carrier_gained) {
1888 log_link_info(link, "gained carrier");
1890 r = link_carrier_gained(link);
1893 } else if (carrier_lost) {
1894 log_link_info(link, "lost carrier");
1896 r = link_carrier_lost(link);
1905 static void link_update_operstate(Link *link) {
1906 LinkOperationalState operstate;
1909 if (link->kernel_operstate == IF_OPER_DORMANT)
1910 operstate = LINK_OPERSTATE_DORMANT;
1911 else if (link_has_carrier(link)) {
1913 uint8_t scope = RT_SCOPE_NOWHERE;
1915 /* if we have carrier, check what addresses we have */
1916 LIST_FOREACH(addresses, address, link->addresses) {
1917 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1920 if (address->scope < scope)
1921 scope = address->scope;
1924 if (scope < RT_SCOPE_SITE)
1925 /* universally accessible addresses found */
1926 operstate = LINK_OPERSTATE_ROUTABLE;
1927 else if (scope < RT_SCOPE_HOST)
1928 /* only link or site local addresses found */
1929 operstate = LINK_OPERSTATE_DEGRADED;
1931 /* no useful addresses found */
1932 operstate = LINK_OPERSTATE_CARRIER;
1933 } else if (link->flags & IFF_UP)
1934 operstate = LINK_OPERSTATE_NO_CARRIER;
1936 operstate = LINK_OPERSTATE_OFF;
1938 if (link->operstate != operstate) {
1939 link->operstate = operstate;
1940 link_send_changed(link, "OperationalState", NULL);
1944 int link_save(Link *link) {
1945 _cleanup_free_ char *temp_path = NULL;
1946 _cleanup_fclose_ FILE *f = NULL;
1947 const char *admin_state, *oper_state;
1951 assert(link->state_file);
1952 assert(link->lease_file);
1953 assert(link->manager);
1955 link_update_operstate(link);
1957 r = manager_save(link->manager);
1961 if (link->state == LINK_STATE_LINGER) {
1962 unlink(link->state_file);
1966 admin_state = link_state_to_string(link->state);
1967 assert(admin_state);
1969 oper_state = link_operstate_to_string(link->operstate);
1972 r = fopen_temporary(link->state_file, &f, &temp_path);
1976 fchmod(fileno(f), 0644);
1979 "# This is private data. Do not parse.\n"
1982 admin_state, oper_state);
1984 if (link->network) {
1985 char **address, **domain;
1988 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1992 STRV_FOREACH(address, link->network->dns) {
1999 if (link->network->dhcp_dns &&
2001 const struct in_addr *addresses;
2003 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2007 serialize_in_addrs(f, addresses, r);
2015 STRV_FOREACH(address, link->network->ntp) {
2022 if (link->network->dhcp_ntp &&
2024 const struct in_addr *addresses;
2026 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2030 serialize_in_addrs(f, addresses, r);
2036 fprintf(f, "DOMAINS=");
2038 STRV_FOREACH(domain, link->network->domains) {
2045 if (link->network->dhcp_domains &&
2047 const char *domainname;
2049 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
2053 fputs(domainname, f);
2059 fprintf(f, "WILDCARD_DOMAIN=%s\n",
2060 yes_no(link->network->wildcard_domain));
2062 fprintf(f, "LLMNR=%s\n",
2063 llmnr_support_to_string(link->network->llmnr));
2066 if (link->dhcp_lease) {
2067 assert(link->network);
2069 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
2077 unlink(link->lease_file);
2080 assert(link->network);
2082 r = sd_lldp_save(link->lldp, link->lldp_file);
2090 unlink(link->lldp_file);
2092 r = fflush_and_check(f);
2096 if (rename(temp_path, link->state_file) < 0) {
2103 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2104 unlink(link->state_file);
2109 static const char* const link_state_table[_LINK_STATE_MAX] = {
2110 [LINK_STATE_PENDING] = "pending",
2111 [LINK_STATE_ENSLAVING] = "configuring",
2112 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2113 [LINK_STATE_SETTING_ROUTES] = "configuring",
2114 [LINK_STATE_CONFIGURED] = "configured",
2115 [LINK_STATE_UNMANAGED] = "unmanaged",
2116 [LINK_STATE_FAILED] = "failed",
2117 [LINK_STATE_LINGER] = "linger",
2120 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2122 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2123 [LINK_OPERSTATE_OFF] = "off",
2124 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2125 [LINK_OPERSTATE_DORMANT] = "dormant",
2126 [LINK_OPERSTATE_CARRIER] = "carrier",
2127 [LINK_OPERSTATE_DEGRADED] = "degraded",
2128 [LINK_OPERSTATE_ROUTABLE] = "routable",
2131 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);