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>
26 #include "networkd-link.h"
27 #include "networkd-netdev.h"
28 #include "libudev-private.h"
29 #include "udev-util.h"
33 #include "network-internal.h"
34 #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 #define FLAG_STRING(string, flag, old, new) \
79 (((old ^ new) & flag) \
80 ? ((old & flag) ? (" -" string) : (" +" string)) \
83 static int link_update_flags(Link *link, sd_rtnl_message *m) {
84 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
90 r = sd_rtnl_message_link_get_flags(m, &flags);
92 log_link_warning(link, "Could not get link flags");
96 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
98 /* if we got a message without operstate, take it to mean
99 the state was unchanged */
100 operstate = link->kernel_operstate;
102 if ((link->flags == flags) && (link->kernel_operstate == operstate))
105 if (link->flags != flags) {
106 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",
107 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
108 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
109 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
110 FLAG_STRING("UP", IFF_UP, link->flags, flags),
111 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
112 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
113 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
114 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
115 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
116 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
117 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
118 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
119 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
120 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
121 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
122 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
123 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
124 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
125 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
127 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
128 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
129 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
130 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
131 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
132 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
133 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
134 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
136 /* link flags are currently at most 18 bits, let's align to
138 if (unknown_flags_added)
140 "unknown link flags gained: %#.5x (ignoring)",
141 unknown_flags_added);
143 if (unknown_flags_removed)
145 "unknown link flags lost: %#.5x (ignoring)",
146 unknown_flags_removed);
150 link->kernel_operstate = operstate;
157 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
158 _cleanup_link_unref_ Link *link = NULL;
167 r = sd_rtnl_message_get_type(message, &type);
170 else if (type != RTM_NEWLINK)
173 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
176 else if (ifindex <= 0)
179 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
183 link = new0(Link, 1);
188 link->manager = manager;
189 link->state = LINK_STATE_PENDING;
190 link->ifindex = ifindex;
191 link->ifname = strdup(ifname);
195 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
197 log_link_debug(link, "MAC address not found for new device, continuing without");
199 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
204 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
209 r = hashmap_ensure_allocated(&manager->links, NULL);
213 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
217 r = link_update_flags(link, message);
227 static void link_free(Link *link) {
233 while ((address = link->addresses)) {
234 LIST_REMOVE(addresses, link->addresses, address);
235 address_free(address);
238 while ((address = link->pool_addresses)) {
239 LIST_REMOVE(addresses, link->pool_addresses, address);
240 address_free(address);
243 sd_dhcp_client_unref(link->dhcp_client);
244 sd_dhcp_lease_unref(link->dhcp_lease);
246 unlink(link->lease_file);
247 free(link->lease_file);
249 sd_ipv4ll_unref(link->ipv4ll);
250 sd_dhcp6_client_unref(link->dhcp6_client);
251 sd_icmp6_nd_unref(link->icmp6_router_discovery);
254 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
258 unlink(link->state_file);
259 free(link->state_file);
261 udev_device_unref(link->udev_device);
266 Link *link_unref(Link *link) {
267 if (link && (-- link->n_ref <= 0))
273 Link *link_ref(Link *link) {
275 assert_se(++ link->n_ref >= 2);
280 int link_get(Manager *m, int ifindex, Link **ret) {
287 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
296 void link_drop(Link *link) {
297 if (!link || link->state == LINK_STATE_LINGER)
300 link->state = LINK_STATE_LINGER;
302 log_link_debug(link, "link removed");
309 static void link_enter_unmanaged(Link *link) {
312 log_link_debug(link, "unmanaged");
314 link->state = LINK_STATE_UNMANAGED;
319 static int link_stop_clients(Link *link) {
323 assert(link->manager);
324 assert(link->manager->event);
329 if (link->dhcp_client) {
330 k = sd_dhcp_client_stop(link->dhcp_client);
332 log_link_warning(link, "Could not stop DHCPv4 client: %s",
339 k = sd_ipv4ll_stop(link->ipv4ll);
341 log_link_warning(link, "Could not stop IPv4 link-local: %s",
347 if(link->icmp6_router_discovery) {
349 if (link->dhcp6_client) {
350 k = sd_dhcp6_client_stop(link->dhcp6_client);
352 log_link_warning(link, "Could not stop DHCPv6 client: %s",
358 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
360 log_link_warning(link,
361 "Could not stop ICMPv6 router discovery: %s",
370 void link_enter_failed(Link *link) {
373 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
376 log_link_warning(link, "failed");
378 link->state = LINK_STATE_FAILED;
380 link_stop_clients(link);
385 static Address* link_find_dhcp_server_address(Link *link) {
389 assert(link->network);
391 /* The the first statically configured address if there is any */
392 LIST_FOREACH(addresses, address, link->network->static_addresses) {
394 if (address->family != AF_INET)
397 if (in_addr_is_null(address->family, &address->in_addr))
403 /* If that didn't work, find a suitable address we got from the pool */
404 LIST_FOREACH(addresses, address, link->pool_addresses) {
405 if (address->family != AF_INET)
414 static int link_enter_configured(Link *link) {
418 assert(link->network);
419 assert(link->state == LINK_STATE_SETTING_ROUTES);
421 if (link_dhcp4_server_enabled(link) &&
422 !sd_dhcp_server_is_running(link->dhcp_server)) {
423 struct in_addr pool_start;
426 address = link_find_dhcp_server_address(link);
428 log_link_warning(link,
429 "Failed to find suitable address for DHCPv4 server instance.");
430 link_enter_failed(link);
434 log_link_debug(link, "offering DHCPv4 leases");
436 r = sd_dhcp_server_set_address(link->dhcp_server,
437 &address->in_addr.in,
442 /* offer 32 addresses starting from the address following the server address */
443 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
444 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
450 r = sd_dhcp_server_set_router(link->dhcp_server,
451 &main_address->in_addr.in);
455 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
456 main_address->prefixlen);
461 r = sd_dhcp_server_start(link->dhcp_server);
463 log_link_warning(link, "could not start DHCPv4 server "
464 "instance: %s", strerror(-r));
466 link_enter_failed(link);
472 log_link_info(link, "link configured");
474 link->state = LINK_STATE_CONFIGURED;
481 void link_client_handler(Link *link) {
483 assert(link->network);
485 if (!link->static_configured)
488 if (link_ipv4ll_enabled(link))
489 if (!link->ipv4ll_address ||
493 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
496 if (link->state != LINK_STATE_CONFIGURED)
497 link_enter_configured(link);
502 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
503 _cleanup_link_unref_ Link *link = userdata;
506 assert(link->link_messages > 0);
507 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
508 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
511 link->link_messages --;
513 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
516 r = sd_rtnl_message_get_errno(m);
517 if (r < 0 && r != -EEXIST)
518 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
520 if (link->link_messages == 0) {
521 log_link_debug(link, "routes set");
522 link->static_configured = true;
523 link_client_handler(link);
529 static int link_enter_set_routes(Link *link) {
534 assert(link->network);
535 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
537 link->state = LINK_STATE_SETTING_ROUTES;
539 LIST_FOREACH(routes, rt, link->network->static_routes) {
540 r = route_configure(rt, link, &route_handler);
542 log_link_warning(link,
543 "could not set routes: %s",
545 link_enter_failed(link);
549 link->link_messages ++;
552 if (link->link_messages == 0) {
553 link->static_configured = true;
554 link_client_handler(link);
556 log_link_debug(link, "setting routes");
561 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
562 _cleanup_link_unref_ Link *link = userdata;
567 assert(link->ifname);
569 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
572 r = sd_rtnl_message_get_errno(m);
573 if (r < 0 && r != -ESRCH)
574 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
579 int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
580 _cleanup_link_unref_ Link *link = userdata;
586 assert(link->manager);
588 for (; m; m = sd_rtnl_message_next(m)) {
589 r = sd_rtnl_message_get_errno(m);
591 log_link_debug(link, "getting address failed: %s",
596 r = link_rtnl_process_address(rtnl, m, link->manager);
598 log_link_warning(link, "could not process address: %s",
605 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
606 _cleanup_link_unref_ Link *link = userdata;
612 assert(link->ifname);
613 assert(link->link_messages > 0);
614 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
615 LINK_STATE_FAILED, LINK_STATE_LINGER));
617 link->link_messages --;
619 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
622 r = sd_rtnl_message_get_errno(m);
623 if (r < 0 && r != -EEXIST)
624 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
626 /* calling handler directly so take a ref */
628 link_get_address_handler(rtnl, m, link);
631 if (link->link_messages == 0) {
632 log_link_debug(link, "addresses set");
633 link_enter_set_routes(link);
639 static int link_enter_set_addresses(Link *link) {
644 assert(link->network);
645 assert(link->state != _LINK_STATE_INVALID);
647 link->state = LINK_STATE_SETTING_ADDRESSES;
649 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
650 r = address_configure(ad, link, &address_handler);
652 log_link_warning(link,
653 "could not set addresses: %s",
655 link_enter_failed(link);
659 link->link_messages ++;
662 if (link->link_messages == 0) {
663 link_enter_set_routes(link);
665 log_link_debug(link, "setting addresses");
670 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
671 _cleanup_link_unref_ Link *link = userdata;
676 assert(link->ifname);
678 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
681 r = sd_rtnl_message_get_errno(m);
682 if (r < 0 && r != -EADDRNOTAVAIL)
683 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
688 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
689 _cleanup_link_unref_ Link *link = userdata;
692 log_link_debug(link, "set link");
694 r = sd_rtnl_message_get_errno(m);
695 if (r < 0 && r != -EEXIST) {
696 log_link_struct(link, LOG_ERR,
697 "MESSAGE=%-*s: could not join netdev: %s",
699 link->ifname, strerror(-r),
702 link_enter_failed(link);
709 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
710 sd_bus_error *ret_error) {
711 _cleanup_link_unref_ Link *link = userdata;
716 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
719 r = sd_bus_message_get_errno(m);
721 log_link_warning(link, "Could not set hostname: %s",
727 int link_set_hostname(Link *link, const char *hostname) {
728 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
732 assert(link->manager);
735 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
737 if (!link->manager->bus) {
738 /* TODO: replace by assert when we can rely on kdbus */
740 "Not connected to system bus, ignoring transient hostname.");
744 r = sd_bus_message_new_method_call(
747 "org.freedesktop.hostname1",
748 "/org/freedesktop/hostname1",
749 "org.freedesktop.hostname1",
754 r = sd_bus_message_append(m, "sb", hostname, false);
758 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
761 log_link_error(link, "Could not set transient hostname: %s",
771 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
772 _cleanup_link_unref_ Link *link = userdata;
777 assert(link->ifname);
779 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
782 r = sd_rtnl_message_get_errno(m);
784 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
789 int link_set_mtu(Link *link, uint32_t mtu) {
790 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
794 assert(link->manager);
795 assert(link->manager->rtnl);
797 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
799 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
800 RTM_SETLINK, link->ifindex);
802 log_link_error(link, "Could not allocate RTM_SETLINK message");
806 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
808 log_link_error(link, "Could not append MTU: %s", strerror(-r));
812 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
816 "Could not send rtnetlink message: %s",
826 static int link_set_bridge(Link *link) {
827 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
831 assert(link->network);
833 if(link->network->cost == 0)
836 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
837 RTM_SETLINK, link->ifindex);
839 log_link_error(link, "Could not allocate RTM_SETLINK message");
843 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
846 "Could not set message family %s", strerror(-r));
850 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
853 "Could not append IFLA_PROTINFO attribute: %s",
858 if(link->network->cost != 0) {
859 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
862 "Could not append IFLA_BRPORT_COST attribute: %s",
868 r = sd_rtnl_message_close_container(req);
871 "Could not append IFLA_LINKINFO attribute: %s",
876 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
879 "Could not send rtnetlink message: %s",
889 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
890 Link *link = userdata;
893 assert(link->network);
894 assert(link->manager);
896 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
900 case DHCP6_EVENT_STOP:
901 case DHCP6_EVENT_RESEND_EXPIRE:
902 case DHCP6_EVENT_RETRANS_MAX:
903 case DHCP6_EVENT_IP_ACQUIRE:
904 log_link_debug(link, "DHCPv6 event %d", event);
910 log_link_warning(link, "DHCPv6 error: %s",
913 log_link_warning(link, "DHCPv6 unknown event: %d",
919 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
920 Link *link = userdata;
924 assert(link->network);
925 assert(link->manager);
927 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
931 case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
932 case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
935 case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
936 case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
941 log_link_warning(link, "ICMPv6 error: %s",
944 log_link_warning(link, "ICMPv6 unknown event: %d",
950 if (link->dhcp6_client)
953 r = sd_dhcp6_client_new(&link->dhcp6_client);
957 r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
959 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
963 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
964 (const uint8_t *) &link->mac,
965 sizeof (link->mac), ARPHRD_ETHER);
967 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
971 r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
973 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
977 r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
980 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
984 r = sd_dhcp6_client_start(link->dhcp6_client);
986 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
989 static int link_acquire_conf(Link *link) {
993 assert(link->network);
994 assert(link->manager);
995 assert(link->manager->event);
997 if (link_ipv4ll_enabled(link)) {
998 assert(link->ipv4ll);
1000 log_link_debug(link, "acquiring IPv4 link-local address");
1002 r = sd_ipv4ll_start(link->ipv4ll);
1004 log_link_warning(link, "could not acquire IPv4 "
1005 "link-local address");
1010 if (link_dhcp4_enabled(link)) {
1011 assert(link->dhcp_client);
1013 log_link_debug(link, "acquiring DHCPv4 lease");
1015 r = sd_dhcp_client_start(link->dhcp_client);
1017 log_link_warning(link, "could not acquire DHCPv4 "
1023 if (link_dhcp6_enabled(link)) {
1024 assert(link->icmp6_router_discovery);
1026 log_link_debug(link, "discovering IPv6 routers");
1028 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1030 log_link_warning(link,
1031 "could not start IPv6 router discovery");
1039 bool link_has_carrier(Link *link) {
1040 /* see Documentation/networking/operstates.txt in the kernel sources */
1042 if (link->kernel_operstate == IF_OPER_UP)
1045 if (link->kernel_operstate == IF_OPER_UNKNOWN)
1046 /* operstate may not be implemented, so fall back to flags */
1047 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1053 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1054 _cleanup_link_unref_ Link *link = userdata;
1059 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1062 r = sd_rtnl_message_get_errno(m);
1064 /* we warn but don't fail the link, as it may
1065 be brought up later */
1066 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
1072 static int link_up(Link *link) {
1073 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1077 assert(link->manager);
1078 assert(link->manager->rtnl);
1080 log_link_debug(link, "bringing link up");
1082 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1083 RTM_SETLINK, link->ifindex);
1085 log_link_error(link, "Could not allocate RTM_SETLINK message");
1089 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1091 log_link_error(link, "Could not set link flags: %s",
1096 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1099 log_link_error(link,
1100 "Could not send rtnetlink message: %s",
1110 static int link_joined(Link *link) {
1114 assert(link->network);
1116 if (!(link->flags & IFF_UP)) {
1119 link_enter_failed(link);
1124 if(link->network->bridge) {
1125 r = link_set_bridge(link);
1127 log_link_error(link,
1128 "Could not set bridge message: %s",
1133 return link_enter_set_addresses(link);
1136 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1138 _cleanup_link_unref_ Link *link = userdata;
1142 assert(link->network);
1146 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1149 r = sd_rtnl_message_get_errno(m);
1150 if (r < 0 && r != -EEXIST) {
1151 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1152 link_enter_failed(link);
1155 log_link_debug(link, "joined netdev");
1157 if (link->enslaving <= 0)
1163 static int link_enter_join_netdev(Link *link) {
1169 assert(link->network);
1170 assert(link->state == LINK_STATE_PENDING);
1172 link->state = LINK_STATE_ENSLAVING;
1176 if (!link->network->bridge &&
1177 !link->network->bond &&
1178 hashmap_isempty(link->network->stacked_netdevs))
1179 return link_joined(link);
1181 if (link->network->bond) {
1182 log_link_struct(link, LOG_DEBUG,
1183 "MESSAGE=%-*s: enslaving by '%s'",
1185 link->ifname, link->network->bond->ifname,
1186 NETDEVIF(link->network->bond),
1189 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1191 log_link_struct(link, LOG_WARNING,
1192 "MESSAGE=%-*s: could not join netdev '%s': %s",
1194 link->ifname, link->network->bond->ifname,
1196 NETDEVIF(link->network->bond),
1198 link_enter_failed(link);
1205 if (link->network->bridge) {
1206 log_link_struct(link, LOG_DEBUG,
1207 "MESSAGE=%-*s: enslaving by '%s'",
1209 link->ifname, link->network->bridge->ifname,
1210 NETDEVIF(link->network->bridge),
1213 r = netdev_join(link->network->bridge, link,
1214 &netdev_join_handler);
1216 log_link_struct(link, LOG_WARNING,
1217 "MESSAGE=%-*s: could not join netdev '%s': %s",
1219 link->ifname, link->network->bridge->ifname,
1221 NETDEVIF(link->network->bridge),
1223 link_enter_failed(link);
1230 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1231 log_link_struct(link, LOG_DEBUG,
1232 "MESSAGE=%-*s: enslaving by '%s'",
1234 link->ifname, netdev->ifname, NETDEVIF(netdev),
1237 r = netdev_join(netdev, link, &netdev_join_handler);
1239 log_link_struct(link, LOG_WARNING,
1240 "MESSAGE=%-*s: could not join netdev '%s': %s",
1242 link->ifname, netdev->ifname,
1244 NETDEVIF(netdev), NULL);
1245 link_enter_failed(link);
1255 static int link_configure(Link *link) {
1259 assert(link->network);
1260 assert(link->state == LINK_STATE_PENDING);
1262 if (link_ipv4ll_enabled(link)) {
1263 r = ipv4ll_configure(link);
1268 if (link_dhcp4_enabled(link)) {
1269 r = dhcp4_configure(link);
1274 if (link_dhcp4_server_enabled(link)) {
1275 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1279 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1284 if (link_dhcp6_enabled(link)) {
1285 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1289 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1294 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1299 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1304 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1305 icmp6_router_handler, link);
1310 if (link_has_carrier(link)) {
1311 r = link_acquire_conf(link);
1316 return link_enter_join_netdev(link);
1319 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1321 _cleanup_link_unref_ Link *link = userdata;
1326 assert(link->ifname);
1327 assert(link->manager);
1329 if (link->state != LINK_STATE_PENDING)
1332 log_link_debug(link, "link state is up-to-date");
1334 r = network_get(link->manager, link->udev_device, link->ifname,
1335 &link->mac, &network);
1337 link_enter_unmanaged(link);
1342 if (link->flags & IFF_LOOPBACK) {
1343 if (network->ipv4ll)
1344 log_link_debug(link, "ignoring IPv4LL for loopback link");
1346 if (network->dhcp != DHCP_SUPPORT_NONE)
1347 log_link_debug(link, "ignoring DHCP clients for loopback link");
1349 if (network->dhcp_server)
1350 log_link_debug(link, "ignoring DHCP server for loopback link");
1353 r = network_apply(link->manager, network, link);
1357 r = link_configure(link);
1364 int link_initialized(Link *link, struct udev_device *device) {
1365 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1369 assert(link->manager);
1370 assert(link->manager->rtnl);
1373 if (link->state != LINK_STATE_PENDING)
1376 if (link->udev_device)
1379 log_link_debug(link, "udev initialized link");
1381 link->udev_device = udev_device_ref(device);
1383 /* udev has initialized the link, but we don't know if we have yet
1384 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1385 * when it returns we know that the pending NEWLINKs have already been
1386 * processed and that we are up-to-date */
1388 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1393 r = sd_rtnl_call_async(link->manager->rtnl, req,
1394 link_initialized_and_synced, link, 0, NULL);
1403 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message,
1405 Manager *m = userdata;
1408 _cleanup_address_free_ Address *address = NULL;
1410 char buf[INET6_ADDRSTRLEN];
1411 char valid_buf[FORMAT_TIMESPAN_MAX];
1412 const char *valid_str = NULL;
1413 bool address_dropped = false;
1420 r = sd_rtnl_message_get_type(message, &type);
1422 log_warning("rtnl: could not get message type");
1426 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1427 if (r < 0 || ifindex <= 0) {
1428 log_warning("rtnl: received address message without valid ifindex, ignoring");
1431 r = link_get(m, ifindex, &link);
1432 if (r < 0 || !link) {
1433 log_warning("rtnl: received address for a nonexistent link (%d), ignoring", ifindex);
1438 r = address_new_dynamic(&address);
1442 r = sd_rtnl_message_addr_get_family(message, &address->family);
1443 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1444 log_link_warning(link,
1445 "rtnl: received address with invalid family, ignoring");
1449 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1451 log_link_warning(link,
1452 "rtnl: received address with invalid prefixlen, ignoring");
1456 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1458 log_link_warning(link,
1459 "rtnl: received address with invalid scope, ignoring");
1463 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1465 log_link_warning(link,
1466 "rtnl: received address with invalid flags, ignoring");
1470 switch (address->family) {
1472 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
1473 &address->in_addr.in);
1475 log_link_warning(link,
1476 "rtnl: received address without valid address, ignoring");
1483 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
1484 &address->in_addr.in6);
1486 log_link_warning(link,
1487 "rtnl: received address without valid address, ignoring");
1494 assert_not_reached("invalid address family");
1497 if (!inet_ntop(address->family, &address->in_addr, buf,
1498 INET6_ADDRSTRLEN)) {
1499 log_link_warning(link, "could not print address");
1503 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO,
1506 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1509 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1510 address->cinfo.ifa_valid * USEC_PER_SEC,
1514 LIST_FOREACH(addresses, ad, link->addresses) {
1515 if (address_equal(ad, address)) {
1516 LIST_REMOVE(addresses, link->addresses, ad);
1520 address_dropped = true;
1528 if (!address_dropped)
1529 log_link_debug(link, "added address: %s/%u (valid for %s)",
1530 buf, address->prefixlen, valid_str);
1532 log_link_debug(link, "updated address: %s/%u (valid for %s)",
1533 buf, address->prefixlen, valid_str);
1535 LIST_PREPEND(addresses, link->addresses, address);
1542 if (address_dropped) {
1543 log_link_debug(link, "removed address: %s/%u (valid for %s)",
1544 buf, address->prefixlen, valid_str);
1548 log_link_warning(link,
1549 "removing non-existent address: %s/%u (valid for %s)",
1550 buf, address->prefixlen, valid_str);
1554 assert_not_reached("Received invalid RTNL message type");
1560 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1562 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1563 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1564 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1572 r = link_new(m, message, ret);
1578 log_link_debug(link, "link %d added", link->ifindex);
1580 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex,
1585 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0,
1592 if (detect_container(NULL) <= 0) {
1593 /* not in a container, udev will be around */
1594 sprintf(ifindex_str, "n%d", link->ifindex);
1595 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1597 log_link_warning(link,
1598 "could not find udev device: %m");
1602 if (udev_device_get_is_initialized(device) <= 0) {
1604 log_link_debug(link, "link pending udev initialization...");
1608 r = link_initialized(link, device);
1612 /* we are calling a callback directly, so must take a ref */
1615 r = link_initialized_and_synced(m->rtnl, NULL, link);
1623 int link_update(Link *link, sd_rtnl_message *m) {
1624 struct ether_addr mac;
1627 bool had_carrier, carrier_gained, carrier_lost;
1631 assert(link->ifname);
1634 if (link->state == LINK_STATE_LINGER) {
1636 log_link_info(link, "link readded");
1637 link->state = LINK_STATE_ENSLAVING;
1640 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1641 if (r >= 0 && !streq(ifname, link->ifname)) {
1642 log_link_info(link, "renamed to %s", ifname);
1645 link->ifname = strdup(ifname);
1650 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1651 if (r >= 0 && mtu > 0) {
1653 if (!link->original_mtu) {
1654 link->original_mtu = mtu;
1655 log_link_debug(link, "saved original MTU: %"
1656 PRIu32, link->original_mtu);
1659 if (link->dhcp_client) {
1660 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1663 log_link_warning(link,
1664 "Could not update MTU in DHCP client: %s",
1671 /* The kernel may broadcast NEWLINK messages without the MAC address
1672 set, simply ignore them. */
1673 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1675 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1678 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1681 log_link_debug(link, "MAC address: "
1682 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1683 mac.ether_addr_octet[0],
1684 mac.ether_addr_octet[1],
1685 mac.ether_addr_octet[2],
1686 mac.ether_addr_octet[3],
1687 mac.ether_addr_octet[4],
1688 mac.ether_addr_octet[5]);
1691 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1693 log_link_warning(link,
1694 "Could not update MAC address in IPv4LL client: %s",
1700 if (link->dhcp_client) {
1701 r = sd_dhcp_client_set_mac(link->dhcp_client,
1702 (const uint8_t *) &link->mac,
1706 log_link_warning(link,
1707 "Could not update MAC address in DHCP client: %s",
1713 if (link->dhcp6_client) {
1714 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1715 (const uint8_t *) &link->mac,
1719 log_link_warning(link,
1720 "Could not update MAC address in DHCPv6 client: %s",
1728 had_carrier = link_has_carrier(link);
1730 r = link_update_flags(link, m);
1734 carrier_gained = !had_carrier && link_has_carrier(link);
1735 carrier_lost = had_carrier && !link_has_carrier(link);
1737 if (carrier_gained) {
1738 log_link_info(link, "gained carrier");
1740 if (link->network) {
1741 r = link_acquire_conf(link);
1743 link_enter_failed(link);
1747 } else if (carrier_lost) {
1748 log_link_info(link, "lost carrier");
1750 r = link_stop_clients(link);
1752 link_enter_failed(link);
1760 static void link_update_operstate(Link *link) {
1764 if (link->kernel_operstate == IF_OPER_DORMANT)
1765 link->operstate = LINK_OPERSTATE_DORMANT;
1766 else if (link_has_carrier(link)) {
1768 uint8_t scope = RT_SCOPE_NOWHERE;
1770 /* if we have carrier, check what addresses we have */
1771 LIST_FOREACH(addresses, address, link->addresses) {
1772 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1775 if (address->scope < scope)
1776 scope = address->scope;
1779 if (scope < RT_SCOPE_SITE)
1780 /* universally accessible addresses found */
1781 link->operstate = LINK_OPERSTATE_ROUTABLE;
1782 else if (scope < RT_SCOPE_HOST)
1783 /* only link or site local addresses found */
1784 link->operstate = LINK_OPERSTATE_DEGRADED;
1786 /* no useful addresses found */
1787 link->operstate = LINK_OPERSTATE_CARRIER;
1788 } else if (link->flags & IFF_UP)
1789 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1791 link->operstate = LINK_OPERSTATE_OFF;
1794 int link_save(Link *link) {
1795 _cleanup_free_ char *temp_path = NULL;
1796 _cleanup_fclose_ FILE *f = NULL;
1797 const char *admin_state, *oper_state;
1801 assert(link->state_file);
1802 assert(link->lease_file);
1803 assert(link->manager);
1805 link_update_operstate(link);
1807 r = manager_save(link->manager);
1811 if (link->state == LINK_STATE_LINGER) {
1812 unlink(link->state_file);
1816 admin_state = link_state_to_string(link->state);
1817 assert(admin_state);
1819 oper_state = link_operstate_to_string(link->operstate);
1822 r = fopen_temporary(link->state_file, &f, &temp_path);
1826 fchmod(fileno(f), 0644);
1829 "# This is private data. Do not parse.\n"
1832 admin_state, oper_state);
1834 if (link->network) {
1835 char **address, **domain;
1838 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1842 STRV_FOREACH(address, link->network->dns) {
1849 if (link->network->dhcp_dns &&
1851 const struct in_addr *addresses;
1853 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1857 serialize_in_addrs(f, addresses, r);
1865 STRV_FOREACH(address, link->network->ntp) {
1872 if (link->network->dhcp_ntp &&
1874 const struct in_addr *addresses;
1876 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1880 serialize_in_addrs(f, addresses, r);
1886 fprintf(f, "DOMAINS=");
1888 STRV_FOREACH(domain, link->network->domains) {
1895 if (link->network->dhcp_domains &&
1897 const char *domainname;
1899 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1903 fputs(domainname, f);
1909 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1910 yes_no(link->network->wildcard_domain));
1912 fprintf(f, "LLMNR=%s\n",
1913 llmnr_support_to_string(link->network->llmnr));
1916 if (link->dhcp_lease) {
1917 assert(link->network);
1919 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1927 unlink(link->lease_file);
1929 r = fflush_and_check(f);
1933 if (rename(temp_path, link->state_file) < 0) {
1940 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1941 unlink(link->state_file);
1946 static const char* const link_state_table[_LINK_STATE_MAX] = {
1947 [LINK_STATE_PENDING] = "pending",
1948 [LINK_STATE_ENSLAVING] = "configuring",
1949 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1950 [LINK_STATE_SETTING_ROUTES] = "configuring",
1951 [LINK_STATE_CONFIGURED] = "configured",
1952 [LINK_STATE_UNMANAGED] = "unmanaged",
1953 [LINK_STATE_FAILED] = "failed",
1954 [LINK_STATE_LINGER] = "linger",
1957 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1959 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1960 [LINK_OPERSTATE_OFF] = "off",
1961 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1962 [LINK_OPERSTATE_DORMANT] = "dormant",
1963 [LINK_OPERSTATE_CARRIER] = "carrier",
1964 [LINK_OPERSTATE_DEGRADED] = "degraded",
1965 [LINK_OPERSTATE_ROUTABLE] = "routable",
1968 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);