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, DHCP_SUPPORT_V6, DHCP_SUPPORT_BOTH);
48 static bool link_dhcp4_enabled(Link *link) {
49 if (link->flags & IFF_LOOPBACK)
55 return IN_SET(link->network->dhcp, DHCP_SUPPORT_V4, DHCP_SUPPORT_BOTH);
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_ip_forward_enabled(Link *link) {
92 if (link->flags & IFF_LOOPBACK)
98 return link->network->ip_forward;
101 #define FLAG_STRING(string, flag, old, new) \
102 (((old ^ new) & flag) \
103 ? ((old & flag) ? (" -" string) : (" +" string)) \
106 static int link_update_flags(Link *link, sd_rtnl_message *m) {
107 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
113 r = sd_rtnl_message_link_get_flags(m, &flags);
115 log_link_warning(link, "Could not get link flags");
119 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
121 /* if we got a message without operstate, take it to mean
122 the state was unchanged */
123 operstate = link->kernel_operstate;
125 if ((link->flags == flags) && (link->kernel_operstate == operstate))
128 if (link->flags != flags) {
129 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",
130 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
131 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
132 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
133 FLAG_STRING("UP", IFF_UP, link->flags, flags),
134 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
135 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
136 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
137 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
138 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
139 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
140 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
141 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
142 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
143 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
144 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
145 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
146 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
147 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
148 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
150 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
151 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
152 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
153 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
154 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
155 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
156 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
157 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
159 /* link flags are currently at most 18 bits, let's align to
161 if (unknown_flags_added)
163 "unknown link flags gained: %#.5x (ignoring)",
164 unknown_flags_added);
166 if (unknown_flags_removed)
168 "unknown link flags lost: %#.5x (ignoring)",
169 unknown_flags_removed);
173 link->kernel_operstate = operstate;
180 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
181 _cleanup_link_unref_ Link *link = NULL;
190 r = sd_rtnl_message_get_type(message, &type);
193 else if (type != RTM_NEWLINK)
196 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
199 else if (ifindex <= 0)
202 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
206 link = new0(Link, 1);
211 link->manager = manager;
212 link->state = LINK_STATE_PENDING;
213 link->ifindex = ifindex;
214 link->ifname = strdup(ifname);
218 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
220 log_link_debug(link, "MAC address not found for new device, continuing without");
222 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
227 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
232 r = asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d",
238 r = hashmap_ensure_allocated(&manager->links, NULL);
242 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
246 r = link_update_flags(link, message);
256 static void link_free(Link *link) {
262 while ((address = link->addresses)) {
263 LIST_REMOVE(addresses, link->addresses, address);
264 address_free(address);
267 while ((address = link->pool_addresses)) {
268 LIST_REMOVE(addresses, link->pool_addresses, address);
269 address_free(address);
272 sd_dhcp_server_unref(link->dhcp_server);
273 sd_dhcp_client_unref(link->dhcp_client);
274 sd_dhcp_lease_unref(link->dhcp_lease);
276 unlink(link->lease_file);
277 free(link->lease_file);
279 unlink(link->lldp_file);
280 free(link->lldp_file);
282 sd_ipv4ll_unref(link->ipv4ll);
283 sd_dhcp6_client_unref(link->dhcp6_client);
284 sd_icmp6_nd_unref(link->icmp6_router_discovery);
287 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
291 unlink(link->state_file);
292 free(link->state_file);
294 udev_device_unref(link->udev_device);
299 Link *link_unref(Link *link) {
300 if (link && (-- link->n_ref <= 0))
306 Link *link_ref(Link *link) {
308 assert_se(++ link->n_ref >= 2);
313 int link_get(Manager *m, int ifindex, Link **ret) {
320 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
329 void link_drop(Link *link) {
330 if (!link || link->state == LINK_STATE_LINGER)
333 link->state = LINK_STATE_LINGER;
335 log_link_debug(link, "link removed");
342 static void link_enter_unmanaged(Link *link) {
345 log_link_debug(link, "unmanaged");
347 link->state = LINK_STATE_UNMANAGED;
352 static int link_stop_clients(Link *link) {
356 assert(link->manager);
357 assert(link->manager->event);
362 if (link->dhcp_client) {
363 k = sd_dhcp_client_stop(link->dhcp_client);
365 log_link_warning(link, "Could not stop DHCPv4 client: %s",
372 k = sd_ipv4ll_stop(link->ipv4ll);
374 log_link_warning(link, "Could not stop IPv4 link-local: %s",
380 if(link->icmp6_router_discovery) {
382 if (link->dhcp6_client) {
383 k = sd_dhcp6_client_stop(link->dhcp6_client);
385 log_link_warning(link, "Could not stop DHCPv6 client: %s",
391 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
393 log_link_warning(link,
394 "Could not stop ICMPv6 router discovery: %s",
402 k = sd_lldp_stop(link->lldp);
404 log_link_warning(link, "Could not stop LLDP : %s",
413 void link_enter_failed(Link *link) {
416 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
419 log_link_warning(link, "failed");
421 link->state = LINK_STATE_FAILED;
423 link_stop_clients(link);
428 static Address* link_find_dhcp_server_address(Link *link) {
432 assert(link->network);
434 /* The the first statically configured address if there is any */
435 LIST_FOREACH(addresses, address, link->network->static_addresses) {
437 if (address->family != AF_INET)
440 if (in_addr_is_null(address->family, &address->in_addr))
446 /* If that didn't work, find a suitable address we got from the pool */
447 LIST_FOREACH(addresses, address, link->pool_addresses) {
448 if (address->family != AF_INET)
457 static int link_enter_configured(Link *link) {
461 assert(link->network);
462 assert(link->state == LINK_STATE_SETTING_ROUTES);
464 if (link_dhcp4_server_enabled(link) &&
465 !sd_dhcp_server_is_running(link->dhcp_server)) {
466 struct in_addr pool_start;
469 address = link_find_dhcp_server_address(link);
471 log_link_warning(link,
472 "Failed to find suitable address for DHCPv4 server instance.");
473 link_enter_failed(link);
477 log_link_debug(link, "offering DHCPv4 leases");
479 r = sd_dhcp_server_set_address(link->dhcp_server,
480 &address->in_addr.in,
485 /* offer 32 addresses starting from the address following the server address */
486 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
487 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
493 r = sd_dhcp_server_set_router(link->dhcp_server,
494 &main_address->in_addr.in);
498 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
499 main_address->prefixlen);
504 r = sd_dhcp_server_start(link->dhcp_server);
506 log_link_warning(link, "could not start DHCPv4 server "
507 "instance: %s", strerror(-r));
509 link_enter_failed(link);
515 log_link_info(link, "link configured");
517 link->state = LINK_STATE_CONFIGURED;
524 void link_client_handler(Link *link) {
526 assert(link->network);
528 if (!link->static_configured)
531 if (link_ipv4ll_enabled(link))
532 if (!link->ipv4ll_address ||
536 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
539 if (link->state != LINK_STATE_CONFIGURED)
540 link_enter_configured(link);
545 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
546 _cleanup_link_unref_ Link *link = userdata;
549 assert(link->link_messages > 0);
550 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
551 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
554 link->link_messages --;
556 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
559 r = sd_rtnl_message_get_errno(m);
560 if (r < 0 && r != -EEXIST)
561 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
563 if (link->link_messages == 0) {
564 log_link_debug(link, "routes set");
565 link->static_configured = true;
566 link_client_handler(link);
572 static int link_enter_set_routes(Link *link) {
577 assert(link->network);
578 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
580 link->state = LINK_STATE_SETTING_ROUTES;
582 LIST_FOREACH(routes, rt, link->network->static_routes) {
583 r = route_configure(rt, link, &route_handler);
585 log_link_warning(link,
586 "could not set routes: %s",
588 link_enter_failed(link);
592 link->link_messages ++;
595 if (link->link_messages == 0) {
596 link->static_configured = true;
597 link_client_handler(link);
599 log_link_debug(link, "setting routes");
604 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
605 _cleanup_link_unref_ Link *link = userdata;
610 assert(link->ifname);
612 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
615 r = sd_rtnl_message_get_errno(m);
616 if (r < 0 && r != -ESRCH)
617 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
622 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
623 _cleanup_link_unref_ Link *link = userdata;
629 assert(link->ifname);
630 assert(link->link_messages > 0);
631 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
632 LINK_STATE_FAILED, LINK_STATE_LINGER));
634 link->link_messages --;
636 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
639 r = sd_rtnl_message_get_errno(m);
640 if (r < 0 && r != -EEXIST)
641 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
643 link_rtnl_process_address(rtnl, m, link->manager);
645 if (link->link_messages == 0) {
646 log_link_debug(link, "addresses set");
647 link_enter_set_routes(link);
653 static int link_enter_set_addresses(Link *link) {
658 assert(link->network);
659 assert(link->state != _LINK_STATE_INVALID);
661 link->state = LINK_STATE_SETTING_ADDRESSES;
663 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
664 r = address_configure(ad, link, &address_handler);
666 log_link_warning_errno(link, r, "Could not set addresses: %m");
667 link_enter_failed(link);
671 link->link_messages ++;
674 if (link->link_messages == 0) {
675 link_enter_set_routes(link);
677 log_link_debug(link, "setting addresses");
682 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
683 _cleanup_link_unref_ Link *link = userdata;
688 assert(link->ifname);
690 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
693 r = sd_rtnl_message_get_errno(m);
694 if (r < 0 && r != -EADDRNOTAVAIL)
695 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
700 static int link_set_bridge_fdb(const Link *const link) {
704 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
705 r = fdb_entry_configure(link->manager->rtnl, fdb_entry, link->ifindex);
707 log_link_error(link, "Failed to add MAC entry to static MAC table: %s", strerror(-r));
715 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
716 _cleanup_link_unref_ Link *link = userdata;
719 log_link_debug(link, "set link");
721 r = sd_rtnl_message_get_errno(m);
722 if (r < 0 && r != -EEXIST) {
723 log_link_struct(link, LOG_ERR,
724 "MESSAGE=%-*s: could not join netdev: %s",
726 link->ifname, strerror(-r),
729 link_enter_failed(link);
736 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
737 sd_bus_error *ret_error) {
738 _cleanup_link_unref_ Link *link = userdata;
743 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
746 r = sd_bus_message_get_errno(m);
748 log_link_warning(link, "Could not set hostname: %s",
754 int link_set_hostname(Link *link, const char *hostname) {
755 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
759 assert(link->manager);
762 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
764 if (!link->manager->bus) {
765 /* TODO: replace by assert when we can rely on kdbus */
767 "Not connected to system bus, ignoring transient hostname.");
771 r = sd_bus_message_new_method_call(
774 "org.freedesktop.hostname1",
775 "/org/freedesktop/hostname1",
776 "org.freedesktop.hostname1",
781 r = sd_bus_message_append(m, "sb", hostname, false);
785 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
788 log_link_error(link, "Could not set transient hostname: %s",
798 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
799 _cleanup_link_unref_ Link *link = userdata;
804 assert(link->ifname);
806 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
809 r = sd_rtnl_message_get_errno(m);
811 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
816 int link_set_mtu(Link *link, uint32_t mtu) {
817 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
821 assert(link->manager);
822 assert(link->manager->rtnl);
824 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
826 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
827 RTM_SETLINK, link->ifindex);
829 log_link_error(link, "Could not allocate RTM_SETLINK message");
833 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
835 log_link_error(link, "Could not append MTU: %s", strerror(-r));
839 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
843 "Could not send rtnetlink message: %s",
853 static int link_set_bridge(Link *link) {
854 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
858 assert(link->network);
860 if(link->network->cost == 0)
863 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
864 RTM_SETLINK, link->ifindex);
866 log_link_error(link, "Could not allocate RTM_SETLINK message");
870 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
873 "Could not set message family %s", strerror(-r));
877 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
880 "Could not append IFLA_PROTINFO attribute: %s",
885 if(link->network->cost != 0) {
886 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
889 "Could not append IFLA_BRPORT_COST attribute: %s",
895 r = sd_rtnl_message_close_container(req);
898 "Could not append IFLA_LINKINFO attribute: %s",
903 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
906 "Could not send rtnetlink message: %s",
916 static void lldp_handler(sd_lldp *lldp, int event, void *userdata) {
917 Link *link = userdata;
921 assert(link->network);
922 assert(link->manager);
924 if (event != UPDATE_INFO)
927 r = sd_lldp_save(link->lldp, link->lldp_file);
929 log_link_warning(link, "could not save LLDP");
933 static int link_acquire_conf(Link *link) {
937 assert(link->network);
938 assert(link->manager);
939 assert(link->manager->event);
941 if (link_ipv4ll_enabled(link)) {
942 assert(link->ipv4ll);
944 log_link_debug(link, "acquiring IPv4 link-local address");
946 r = sd_ipv4ll_start(link->ipv4ll);
948 log_link_warning(link, "could not acquire IPv4 "
949 "link-local address");
954 if (link_dhcp4_enabled(link)) {
955 assert(link->dhcp_client);
957 log_link_debug(link, "acquiring DHCPv4 lease");
959 r = sd_dhcp_client_start(link->dhcp_client);
961 log_link_warning(link, "could not acquire DHCPv4 "
967 if (link_dhcp6_enabled(link)) {
968 assert(link->icmp6_router_discovery);
970 log_link_debug(link, "discovering IPv6 routers");
972 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
974 log_link_warning(link,
975 "could not start IPv6 router discovery");
980 if (link_lldp_enabled(link)) {
983 log_link_debug(link, "Starting LLDP");
985 r = sd_lldp_start(link->lldp);
987 log_link_warning(link, "could not start LLDP ");
995 bool link_has_carrier(Link *link) {
996 /* see Documentation/networking/operstates.txt in the kernel sources */
998 if (link->kernel_operstate == IF_OPER_UP)
1001 if (link->kernel_operstate == IF_OPER_UNKNOWN)
1002 /* operstate may not be implemented, so fall back to flags */
1003 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1009 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1010 _cleanup_link_unref_ Link *link = userdata;
1015 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1018 r = sd_rtnl_message_get_errno(m);
1020 /* we warn but don't fail the link, as it may
1021 be brought up later */
1022 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
1028 static int link_up(Link *link) {
1029 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1033 assert(link->network);
1034 assert(link->manager);
1035 assert(link->manager->rtnl);
1037 log_link_debug(link, "bringing link up");
1039 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1040 RTM_SETLINK, link->ifindex);
1042 log_link_error(link, "Could not allocate RTM_SETLINK message");
1046 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1048 log_link_error(link, "Could not set link flags: %s",
1053 if (link->network->mac) {
1054 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1056 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
1061 if (link->network->mtu) {
1062 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
1064 log_link_error(link, "Could not set MTU: %s", strerror(-r));
1069 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1072 log_link_error(link,
1073 "Could not send rtnetlink message: %s",
1083 static int link_joined(Link *link) {
1087 assert(link->network);
1089 if (!(link->flags & IFF_UP)) {
1092 link_enter_failed(link);
1097 if(link->network->bridge) {
1098 r = link_set_bridge(link);
1100 log_link_error(link,
1101 "Could not set bridge message: %s",
1106 return link_enter_set_addresses(link);
1109 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1111 _cleanup_link_unref_ Link *link = userdata;
1115 assert(link->network);
1119 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1122 r = sd_rtnl_message_get_errno(m);
1123 if (r < 0 && r != -EEXIST) {
1124 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1125 link_enter_failed(link);
1128 log_link_debug(link, "joined netdev");
1130 if (link->enslaving <= 0)
1136 static int link_enter_join_netdev(Link *link) {
1142 assert(link->network);
1143 assert(link->state == LINK_STATE_PENDING);
1145 link->state = LINK_STATE_ENSLAVING;
1149 if (!link->network->bridge &&
1150 !link->network->bond &&
1151 hashmap_isempty(link->network->stacked_netdevs))
1152 return link_joined(link);
1154 if (link->network->bond) {
1155 log_link_struct(link, LOG_DEBUG,
1156 "MESSAGE=%-*s: enslaving by '%s'",
1158 link->ifname, link->network->bond->ifname,
1159 NETDEVIF(link->network->bond),
1162 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1164 log_link_struct(link, LOG_WARNING,
1165 "MESSAGE=%-*s: could not join netdev '%s': %s",
1167 link->ifname, link->network->bond->ifname,
1169 NETDEVIF(link->network->bond),
1171 link_enter_failed(link);
1178 if (link->network->bridge) {
1179 log_link_struct(link, LOG_DEBUG,
1180 "MESSAGE=%-*s: enslaving by '%s'",
1182 link->ifname, link->network->bridge->ifname,
1183 NETDEVIF(link->network->bridge),
1186 r = netdev_join(link->network->bridge, link,
1187 &netdev_join_handler);
1189 log_link_struct(link, LOG_WARNING,
1190 "MESSAGE=%-*s: could not join netdev '%s': %s",
1192 link->ifname, link->network->bridge->ifname,
1194 NETDEVIF(link->network->bridge),
1196 link_enter_failed(link);
1203 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1204 log_link_struct(link, LOG_DEBUG,
1205 "MESSAGE=%-*s: enslaving by '%s'",
1207 link->ifname, netdev->ifname, NETDEVIF(netdev),
1210 r = netdev_join(netdev, link, &netdev_join_handler);
1212 log_link_struct(link, LOG_WARNING,
1213 "MESSAGE=%-*s: could not join netdev '%s': %s",
1215 link->ifname, netdev->ifname,
1217 NETDEVIF(netdev), NULL);
1218 link_enter_failed(link);
1228 static int link_set_ip_forward(Link *link) {
1229 const char *p = NULL;
1232 p = strappenda("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
1233 r = write_string_file_no_create(p, link_ip_forward_enabled(link) ? "1" : "0");
1235 log_link_warning_errno(link, r, "Cannot configure IP forwarding for interface: %m");
1240 static int link_configure(Link *link) {
1244 assert(link->network);
1245 assert(link->state == LINK_STATE_PENDING);
1247 r = link_set_bridge_fdb(link);
1251 r = link_set_ip_forward(link);
1255 if (link_ipv4ll_enabled(link)) {
1256 r = ipv4ll_configure(link);
1261 if (link_dhcp4_enabled(link)) {
1262 r = dhcp4_configure(link);
1267 if (link_dhcp4_server_enabled(link)) {
1268 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1272 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1277 if (link_dhcp6_enabled(link)) {
1278 r = icmp6_configure(link);
1283 if (link_lldp_enabled(link)) {
1284 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1288 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1292 r = sd_lldp_set_callback(link->lldp,
1293 lldp_handler, link);
1298 if (link_has_carrier(link)) {
1299 r = link_acquire_conf(link);
1304 return link_enter_join_netdev(link);
1307 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1309 _cleanup_link_unref_ Link *link = userdata;
1314 assert(link->ifname);
1315 assert(link->manager);
1317 if (link->state != LINK_STATE_PENDING)
1320 log_link_debug(link, "link state is up-to-date");
1322 r = network_get(link->manager, link->udev_device, link->ifname,
1323 &link->mac, &network);
1325 link_enter_unmanaged(link);
1330 if (link->flags & IFF_LOOPBACK) {
1331 if (network->ipv4ll)
1332 log_link_debug(link, "ignoring IPv4LL for loopback link");
1334 if (network->dhcp != DHCP_SUPPORT_NONE)
1335 log_link_debug(link, "ignoring DHCP clients for loopback link");
1337 if (network->dhcp_server)
1338 log_link_debug(link, "ignoring DHCP server for loopback link");
1341 r = network_apply(link->manager, network, link);
1345 r = link_configure(link);
1352 int link_initialized(Link *link, struct udev_device *device) {
1353 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1357 assert(link->manager);
1358 assert(link->manager->rtnl);
1361 if (link->state != LINK_STATE_PENDING)
1364 if (link->udev_device)
1367 log_link_debug(link, "udev initialized link");
1369 link->udev_device = udev_device_ref(device);
1371 /* udev has initialized the link, but we don't know if we have yet
1372 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1373 * when it returns we know that the pending NEWLINKs have already been
1374 * processed and that we are up-to-date */
1376 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1381 r = sd_rtnl_call_async(link->manager->rtnl, req,
1382 link_initialized_and_synced, link, 0, NULL);
1391 static Address* link_get_equal_address(Link *link, Address *needle) {
1397 LIST_FOREACH(addresses, i, link->addresses)
1398 if (address_equal(i, needle))
1404 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1405 Manager *m = userdata;
1408 _cleanup_address_free_ Address *address = NULL;
1410 char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
1411 const char *valid_str = NULL;
1418 if (sd_rtnl_message_is_error(message)) {
1419 r = sd_rtnl_message_get_errno(message);
1421 log_warning_errno(r, "rtnl: failed to receive address: %m");
1426 r = sd_rtnl_message_get_type(message, &type);
1428 log_warning("rtnl: could not get message type");
1432 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1434 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1436 } else if (ifindex <= 0) {
1437 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1440 r = link_get(m, ifindex, &link);
1441 if (r < 0 || !link) {
1442 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1447 r = address_new_dynamic(&address);
1451 r = sd_rtnl_message_addr_get_family(message, &address->family);
1452 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1453 log_link_warning(link, "rtnl: received address with invalid family, ignoring");
1457 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1459 log_link_warning(link, "rtnl: received address with invalid prefixlen, ignoring");
1463 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1465 log_link_warning(link, "rtnl: received address with invalid scope, ignoring");
1469 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1471 log_link_warning(link, "rtnl: received address with invalid flags, ignoring");
1475 switch (address->family) {
1477 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1479 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1486 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1488 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1495 assert_not_reached("invalid address family");
1498 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1499 log_link_warning(link, "could not print address");
1503 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1505 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1508 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1509 address->cinfo.ifa_valid * USEC_PER_SEC,
1513 existing = link_get_equal_address(link, address);
1518 log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1521 existing->scope = address->scope;
1522 existing->flags = address->flags;
1523 existing->cinfo = address->cinfo;
1526 log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1528 LIST_PREPEND(addresses, link->addresses, address);
1529 address_establish(address, link);
1541 log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1542 address_release(existing, link);
1543 LIST_REMOVE(addresses, link->addresses, existing);
1544 address_free(existing);
1546 log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1550 assert_not_reached("Received invalid RTNL message type");
1556 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1558 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1559 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1567 r = link_new(m, message, ret);
1573 log_link_debug(link, "link %d added", link->ifindex);
1575 if (detect_container(NULL) <= 0) {
1576 /* not in a container, udev will be around */
1577 sprintf(ifindex_str, "n%d", link->ifindex);
1578 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1580 log_link_warning(link,
1581 "could not find udev device: %m");
1585 if (udev_device_get_is_initialized(device) <= 0) {
1587 log_link_debug(link, "link pending udev initialization...");
1591 r = link_initialized(link, device);
1595 /* we are calling a callback directly, so must take a ref */
1598 r = link_initialized_and_synced(m->rtnl, NULL, link);
1606 int link_update(Link *link, sd_rtnl_message *m) {
1607 struct ether_addr mac;
1610 bool had_carrier, carrier_gained, carrier_lost;
1614 assert(link->ifname);
1617 if (link->state == LINK_STATE_LINGER) {
1619 log_link_info(link, "link readded");
1620 link->state = LINK_STATE_ENSLAVING;
1623 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1624 if (r >= 0 && !streq(ifname, link->ifname)) {
1625 log_link_info(link, "renamed to %s", ifname);
1628 link->ifname = strdup(ifname);
1633 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1634 if (r >= 0 && mtu > 0) {
1636 if (!link->original_mtu) {
1637 link->original_mtu = mtu;
1638 log_link_debug(link, "saved original MTU: %"
1639 PRIu32, link->original_mtu);
1642 if (link->dhcp_client) {
1643 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1646 log_link_warning(link,
1647 "Could not update MTU in DHCP client: %s",
1654 /* The kernel may broadcast NEWLINK messages without the MAC address
1655 set, simply ignore them. */
1656 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1658 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1661 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1664 log_link_debug(link, "MAC address: "
1665 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1666 mac.ether_addr_octet[0],
1667 mac.ether_addr_octet[1],
1668 mac.ether_addr_octet[2],
1669 mac.ether_addr_octet[3],
1670 mac.ether_addr_octet[4],
1671 mac.ether_addr_octet[5]);
1674 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1676 log_link_warning(link,
1677 "Could not update MAC address in IPv4LL client: %s",
1683 if (link->dhcp_client) {
1684 r = sd_dhcp_client_set_mac(link->dhcp_client,
1685 (const uint8_t *) &link->mac,
1689 log_link_warning(link,
1690 "Could not update MAC address in DHCP client: %s",
1696 if (link->dhcp6_client) {
1697 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1698 (const uint8_t *) &link->mac,
1702 log_link_warning(link,
1703 "Could not update MAC address in DHCPv6 client: %s",
1711 had_carrier = link_has_carrier(link);
1713 r = link_update_flags(link, m);
1717 carrier_gained = !had_carrier && link_has_carrier(link);
1718 carrier_lost = had_carrier && !link_has_carrier(link);
1720 if (carrier_gained) {
1721 log_link_info(link, "gained carrier");
1723 if (link->network) {
1724 r = link_acquire_conf(link);
1726 link_enter_failed(link);
1730 } else if (carrier_lost) {
1731 log_link_info(link, "lost carrier");
1733 r = link_stop_clients(link);
1735 link_enter_failed(link);
1743 static void link_update_operstate(Link *link) {
1747 if (link->kernel_operstate == IF_OPER_DORMANT)
1748 link->operstate = LINK_OPERSTATE_DORMANT;
1749 else if (link_has_carrier(link)) {
1751 uint8_t scope = RT_SCOPE_NOWHERE;
1753 /* if we have carrier, check what addresses we have */
1754 LIST_FOREACH(addresses, address, link->addresses) {
1755 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1758 if (address->scope < scope)
1759 scope = address->scope;
1762 if (scope < RT_SCOPE_SITE)
1763 /* universally accessible addresses found */
1764 link->operstate = LINK_OPERSTATE_ROUTABLE;
1765 else if (scope < RT_SCOPE_HOST)
1766 /* only link or site local addresses found */
1767 link->operstate = LINK_OPERSTATE_DEGRADED;
1769 /* no useful addresses found */
1770 link->operstate = LINK_OPERSTATE_CARRIER;
1771 } else if (link->flags & IFF_UP)
1772 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1774 link->operstate = LINK_OPERSTATE_OFF;
1777 int link_save(Link *link) {
1778 _cleanup_free_ char *temp_path = NULL;
1779 _cleanup_fclose_ FILE *f = NULL;
1780 const char *admin_state, *oper_state;
1784 assert(link->state_file);
1785 assert(link->lease_file);
1786 assert(link->manager);
1788 link_update_operstate(link);
1790 r = manager_save(link->manager);
1794 if (link->state == LINK_STATE_LINGER) {
1795 unlink(link->state_file);
1799 admin_state = link_state_to_string(link->state);
1800 assert(admin_state);
1802 oper_state = link_operstate_to_string(link->operstate);
1805 r = fopen_temporary(link->state_file, &f, &temp_path);
1809 fchmod(fileno(f), 0644);
1812 "# This is private data. Do not parse.\n"
1815 admin_state, oper_state);
1817 if (link->network) {
1818 char **address, **domain;
1821 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1825 STRV_FOREACH(address, link->network->dns) {
1832 if (link->network->dhcp_dns &&
1834 const struct in_addr *addresses;
1836 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1840 serialize_in_addrs(f, addresses, r);
1848 STRV_FOREACH(address, link->network->ntp) {
1855 if (link->network->dhcp_ntp &&
1857 const struct in_addr *addresses;
1859 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1863 serialize_in_addrs(f, addresses, r);
1869 fprintf(f, "DOMAINS=");
1871 STRV_FOREACH(domain, link->network->domains) {
1878 if (link->network->dhcp_domains &&
1880 const char *domainname;
1882 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1886 fputs(domainname, f);
1892 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1893 yes_no(link->network->wildcard_domain));
1895 fprintf(f, "LLMNR=%s\n",
1896 llmnr_support_to_string(link->network->llmnr));
1899 if (link->dhcp_lease) {
1900 assert(link->network);
1902 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1910 unlink(link->lease_file);
1913 assert(link->network);
1915 r = sd_lldp_save(link->lldp, link->lldp_file);
1923 unlink(link->lldp_file);
1925 r = fflush_and_check(f);
1929 if (rename(temp_path, link->state_file) < 0) {
1936 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1937 unlink(link->state_file);
1942 static const char* const link_state_table[_LINK_STATE_MAX] = {
1943 [LINK_STATE_PENDING] = "pending",
1944 [LINK_STATE_ENSLAVING] = "configuring",
1945 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1946 [LINK_STATE_SETTING_ROUTES] = "configuring",
1947 [LINK_STATE_CONFIGURED] = "configured",
1948 [LINK_STATE_UNMANAGED] = "unmanaged",
1949 [LINK_STATE_FAILED] = "failed",
1950 [LINK_STATE_LINGER] = "linger",
1953 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1955 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1956 [LINK_OPERSTATE_OFF] = "off",
1957 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1958 [LINK_OPERSTATE_DORMANT] = "dormant",
1959 [LINK_OPERSTATE_CARRIER] = "carrier",
1960 [LINK_OPERSTATE_DEGRADED] = "degraded",
1961 [LINK_OPERSTATE_ROUTABLE] = "routable",
1964 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);