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->network);
1078 assert(link->manager);
1079 assert(link->manager->rtnl);
1081 log_link_debug(link, "bringing link up");
1083 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1084 RTM_SETLINK, link->ifindex);
1086 log_link_error(link, "Could not allocate RTM_SETLINK message");
1090 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1092 log_link_error(link, "Could not set link flags: %s",
1097 if (link->network->mac) {
1098 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1100 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
1105 if (link->network->mtu) {
1106 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
1108 log_link_error(link, "Could not set MTU: %s", strerror(-r));
1113 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1116 log_link_error(link,
1117 "Could not send rtnetlink message: %s",
1127 static int link_joined(Link *link) {
1131 assert(link->network);
1133 if (!(link->flags & IFF_UP)) {
1136 link_enter_failed(link);
1141 if(link->network->bridge) {
1142 r = link_set_bridge(link);
1144 log_link_error(link,
1145 "Could not set bridge message: %s",
1150 return link_enter_set_addresses(link);
1153 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1155 _cleanup_link_unref_ Link *link = userdata;
1159 assert(link->network);
1163 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1166 r = sd_rtnl_message_get_errno(m);
1167 if (r < 0 && r != -EEXIST) {
1168 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1169 link_enter_failed(link);
1172 log_link_debug(link, "joined netdev");
1174 if (link->enslaving <= 0)
1180 static int link_enter_join_netdev(Link *link) {
1186 assert(link->network);
1187 assert(link->state == LINK_STATE_PENDING);
1189 link->state = LINK_STATE_ENSLAVING;
1193 if (!link->network->bridge &&
1194 !link->network->bond &&
1195 hashmap_isempty(link->network->stacked_netdevs))
1196 return link_joined(link);
1198 if (link->network->bond) {
1199 log_link_struct(link, LOG_DEBUG,
1200 "MESSAGE=%-*s: enslaving by '%s'",
1202 link->ifname, link->network->bond->ifname,
1203 NETDEVIF(link->network->bond),
1206 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1208 log_link_struct(link, LOG_WARNING,
1209 "MESSAGE=%-*s: could not join netdev '%s': %s",
1211 link->ifname, link->network->bond->ifname,
1213 NETDEVIF(link->network->bond),
1215 link_enter_failed(link);
1222 if (link->network->bridge) {
1223 log_link_struct(link, LOG_DEBUG,
1224 "MESSAGE=%-*s: enslaving by '%s'",
1226 link->ifname, link->network->bridge->ifname,
1227 NETDEVIF(link->network->bridge),
1230 r = netdev_join(link->network->bridge, link,
1231 &netdev_join_handler);
1233 log_link_struct(link, LOG_WARNING,
1234 "MESSAGE=%-*s: could not join netdev '%s': %s",
1236 link->ifname, link->network->bridge->ifname,
1238 NETDEVIF(link->network->bridge),
1240 link_enter_failed(link);
1247 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1248 log_link_struct(link, LOG_DEBUG,
1249 "MESSAGE=%-*s: enslaving by '%s'",
1251 link->ifname, netdev->ifname, NETDEVIF(netdev),
1254 r = netdev_join(netdev, link, &netdev_join_handler);
1256 log_link_struct(link, LOG_WARNING,
1257 "MESSAGE=%-*s: could not join netdev '%s': %s",
1259 link->ifname, netdev->ifname,
1261 NETDEVIF(netdev), NULL);
1262 link_enter_failed(link);
1272 static int link_configure(Link *link) {
1276 assert(link->network);
1277 assert(link->state == LINK_STATE_PENDING);
1279 if (link_ipv4ll_enabled(link)) {
1280 r = ipv4ll_configure(link);
1285 if (link_dhcp4_enabled(link)) {
1286 r = dhcp4_configure(link);
1291 if (link_dhcp4_server_enabled(link)) {
1292 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1296 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1301 if (link_dhcp6_enabled(link)) {
1302 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1306 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1311 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1316 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1321 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1322 icmp6_router_handler, link);
1327 if (link_has_carrier(link)) {
1328 r = link_acquire_conf(link);
1333 return link_enter_join_netdev(link);
1336 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1338 _cleanup_link_unref_ Link *link = userdata;
1343 assert(link->ifname);
1344 assert(link->manager);
1346 if (link->state != LINK_STATE_PENDING)
1349 log_link_debug(link, "link state is up-to-date");
1351 r = network_get(link->manager, link->udev_device, link->ifname,
1352 &link->mac, &network);
1354 link_enter_unmanaged(link);
1359 if (link->flags & IFF_LOOPBACK) {
1360 if (network->ipv4ll)
1361 log_link_debug(link, "ignoring IPv4LL for loopback link");
1363 if (network->dhcp != DHCP_SUPPORT_NONE)
1364 log_link_debug(link, "ignoring DHCP clients for loopback link");
1366 if (network->dhcp_server)
1367 log_link_debug(link, "ignoring DHCP server for loopback link");
1370 r = network_apply(link->manager, network, link);
1374 r = link_configure(link);
1381 int link_initialized(Link *link, struct udev_device *device) {
1382 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1386 assert(link->manager);
1387 assert(link->manager->rtnl);
1390 if (link->state != LINK_STATE_PENDING)
1393 if (link->udev_device)
1396 log_link_debug(link, "udev initialized link");
1398 link->udev_device = udev_device_ref(device);
1400 /* udev has initialized the link, but we don't know if we have yet
1401 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1402 * when it returns we know that the pending NEWLINKs have already been
1403 * processed and that we are up-to-date */
1405 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1410 r = sd_rtnl_call_async(link->manager->rtnl, req,
1411 link_initialized_and_synced, link, 0, NULL);
1420 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message,
1422 Manager *m = userdata;
1425 _cleanup_address_free_ Address *address = NULL;
1427 char buf[INET6_ADDRSTRLEN];
1428 char valid_buf[FORMAT_TIMESPAN_MAX];
1429 const char *valid_str = NULL;
1430 bool address_dropped = false;
1437 r = sd_rtnl_message_get_type(message, &type);
1439 log_warning("rtnl: could not get message type");
1443 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1444 if (r < 0 || ifindex <= 0) {
1445 log_warning("rtnl: received address message without valid ifindex, ignoring");
1448 r = link_get(m, ifindex, &link);
1449 if (r < 0 || !link) {
1450 log_warning("rtnl: received address for a nonexistent link (%d), ignoring", ifindex);
1455 r = address_new_dynamic(&address);
1459 r = sd_rtnl_message_addr_get_family(message, &address->family);
1460 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1461 log_link_warning(link,
1462 "rtnl: received address with invalid family, ignoring");
1466 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1468 log_link_warning(link,
1469 "rtnl: received address with invalid prefixlen, ignoring");
1473 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1475 log_link_warning(link,
1476 "rtnl: received address with invalid scope, ignoring");
1480 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1482 log_link_warning(link,
1483 "rtnl: received address with invalid flags, ignoring");
1487 switch (address->family) {
1489 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
1490 &address->in_addr.in);
1492 log_link_warning(link,
1493 "rtnl: received address without valid address, ignoring");
1500 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
1501 &address->in_addr.in6);
1503 log_link_warning(link,
1504 "rtnl: received address without valid address, ignoring");
1511 assert_not_reached("invalid address family");
1514 if (!inet_ntop(address->family, &address->in_addr, buf,
1515 INET6_ADDRSTRLEN)) {
1516 log_link_warning(link, "could not print address");
1520 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO,
1523 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1526 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1527 address->cinfo.ifa_valid * USEC_PER_SEC,
1531 LIST_FOREACH(addresses, ad, link->addresses) {
1532 if (address_equal(ad, address)) {
1533 LIST_REMOVE(addresses, link->addresses, ad);
1537 address_dropped = true;
1545 if (!address_dropped)
1546 log_link_debug(link, "added address: %s/%u (valid for %s)",
1547 buf, address->prefixlen, valid_str);
1549 log_link_debug(link, "updated address: %s/%u (valid for %s)",
1550 buf, address->prefixlen, valid_str);
1552 LIST_PREPEND(addresses, link->addresses, address);
1559 if (address_dropped) {
1560 log_link_debug(link, "removed address: %s/%u (valid for %s)",
1561 buf, address->prefixlen, valid_str);
1565 log_link_warning(link,
1566 "removing non-existent address: %s/%u (valid for %s)",
1567 buf, address->prefixlen, valid_str);
1571 assert_not_reached("Received invalid RTNL message type");
1577 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1579 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1580 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1581 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1589 r = link_new(m, message, ret);
1595 log_link_debug(link, "link %d added", link->ifindex);
1597 r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex,
1602 r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0,
1609 if (detect_container(NULL) <= 0) {
1610 /* not in a container, udev will be around */
1611 sprintf(ifindex_str, "n%d", link->ifindex);
1612 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1614 log_link_warning(link,
1615 "could not find udev device: %m");
1619 if (udev_device_get_is_initialized(device) <= 0) {
1621 log_link_debug(link, "link pending udev initialization...");
1625 r = link_initialized(link, device);
1629 /* we are calling a callback directly, so must take a ref */
1632 r = link_initialized_and_synced(m->rtnl, NULL, link);
1640 int link_update(Link *link, sd_rtnl_message *m) {
1641 struct ether_addr mac;
1644 bool had_carrier, carrier_gained, carrier_lost;
1648 assert(link->ifname);
1651 if (link->state == LINK_STATE_LINGER) {
1653 log_link_info(link, "link readded");
1654 link->state = LINK_STATE_ENSLAVING;
1657 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1658 if (r >= 0 && !streq(ifname, link->ifname)) {
1659 log_link_info(link, "renamed to %s", ifname);
1662 link->ifname = strdup(ifname);
1667 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1668 if (r >= 0 && mtu > 0) {
1670 if (!link->original_mtu) {
1671 link->original_mtu = mtu;
1672 log_link_debug(link, "saved original MTU: %"
1673 PRIu32, link->original_mtu);
1676 if (link->dhcp_client) {
1677 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1680 log_link_warning(link,
1681 "Could not update MTU in DHCP client: %s",
1688 /* The kernel may broadcast NEWLINK messages without the MAC address
1689 set, simply ignore them. */
1690 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1692 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1695 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1698 log_link_debug(link, "MAC address: "
1699 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1700 mac.ether_addr_octet[0],
1701 mac.ether_addr_octet[1],
1702 mac.ether_addr_octet[2],
1703 mac.ether_addr_octet[3],
1704 mac.ether_addr_octet[4],
1705 mac.ether_addr_octet[5]);
1708 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1710 log_link_warning(link,
1711 "Could not update MAC address in IPv4LL client: %s",
1717 if (link->dhcp_client) {
1718 r = sd_dhcp_client_set_mac(link->dhcp_client,
1719 (const uint8_t *) &link->mac,
1723 log_link_warning(link,
1724 "Could not update MAC address in DHCP client: %s",
1730 if (link->dhcp6_client) {
1731 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1732 (const uint8_t *) &link->mac,
1736 log_link_warning(link,
1737 "Could not update MAC address in DHCPv6 client: %s",
1745 had_carrier = link_has_carrier(link);
1747 r = link_update_flags(link, m);
1751 carrier_gained = !had_carrier && link_has_carrier(link);
1752 carrier_lost = had_carrier && !link_has_carrier(link);
1754 if (carrier_gained) {
1755 log_link_info(link, "gained carrier");
1757 if (link->network) {
1758 r = link_acquire_conf(link);
1760 link_enter_failed(link);
1764 } else if (carrier_lost) {
1765 log_link_info(link, "lost carrier");
1767 r = link_stop_clients(link);
1769 link_enter_failed(link);
1777 static void link_update_operstate(Link *link) {
1781 if (link->kernel_operstate == IF_OPER_DORMANT)
1782 link->operstate = LINK_OPERSTATE_DORMANT;
1783 else if (link_has_carrier(link)) {
1785 uint8_t scope = RT_SCOPE_NOWHERE;
1787 /* if we have carrier, check what addresses we have */
1788 LIST_FOREACH(addresses, address, link->addresses) {
1789 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1792 if (address->scope < scope)
1793 scope = address->scope;
1796 if (scope < RT_SCOPE_SITE)
1797 /* universally accessible addresses found */
1798 link->operstate = LINK_OPERSTATE_ROUTABLE;
1799 else if (scope < RT_SCOPE_HOST)
1800 /* only link or site local addresses found */
1801 link->operstate = LINK_OPERSTATE_DEGRADED;
1803 /* no useful addresses found */
1804 link->operstate = LINK_OPERSTATE_CARRIER;
1805 } else if (link->flags & IFF_UP)
1806 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1808 link->operstate = LINK_OPERSTATE_OFF;
1811 int link_save(Link *link) {
1812 _cleanup_free_ char *temp_path = NULL;
1813 _cleanup_fclose_ FILE *f = NULL;
1814 const char *admin_state, *oper_state;
1818 assert(link->state_file);
1819 assert(link->lease_file);
1820 assert(link->manager);
1822 link_update_operstate(link);
1824 r = manager_save(link->manager);
1828 if (link->state == LINK_STATE_LINGER) {
1829 unlink(link->state_file);
1833 admin_state = link_state_to_string(link->state);
1834 assert(admin_state);
1836 oper_state = link_operstate_to_string(link->operstate);
1839 r = fopen_temporary(link->state_file, &f, &temp_path);
1843 fchmod(fileno(f), 0644);
1846 "# This is private data. Do not parse.\n"
1849 admin_state, oper_state);
1851 if (link->network) {
1852 char **address, **domain;
1855 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1859 STRV_FOREACH(address, link->network->dns) {
1866 if (link->network->dhcp_dns &&
1868 const struct in_addr *addresses;
1870 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1874 serialize_in_addrs(f, addresses, r);
1882 STRV_FOREACH(address, link->network->ntp) {
1889 if (link->network->dhcp_ntp &&
1891 const struct in_addr *addresses;
1893 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1897 serialize_in_addrs(f, addresses, r);
1903 fprintf(f, "DOMAINS=");
1905 STRV_FOREACH(domain, link->network->domains) {
1912 if (link->network->dhcp_domains &&
1914 const char *domainname;
1916 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1920 fputs(domainname, f);
1926 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1927 yes_no(link->network->wildcard_domain));
1929 fprintf(f, "LLMNR=%s\n",
1930 llmnr_support_to_string(link->network->llmnr));
1933 if (link->dhcp_lease) {
1934 assert(link->network);
1936 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1944 unlink(link->lease_file);
1946 r = fflush_and_check(f);
1950 if (rename(temp_path, link->state_file) < 0) {
1957 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1958 unlink(link->state_file);
1963 static const char* const link_state_table[_LINK_STATE_MAX] = {
1964 [LINK_STATE_PENDING] = "pending",
1965 [LINK_STATE_ENSLAVING] = "configuring",
1966 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1967 [LINK_STATE_SETTING_ROUTES] = "configuring",
1968 [LINK_STATE_CONFIGURED] = "configured",
1969 [LINK_STATE_UNMANAGED] = "unmanaged",
1970 [LINK_STATE_FAILED] = "failed",
1971 [LINK_STATE_LINGER] = "linger",
1974 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1976 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1977 [LINK_OPERSTATE_OFF] = "off",
1978 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1979 [LINK_OPERSTATE_DORMANT] = "dormant",
1980 [LINK_OPERSTATE_CARRIER] = "carrier",
1981 [LINK_OPERSTATE_DEGRADED] = "degraded",
1982 [LINK_OPERSTATE_ROUTABLE] = "routable",
1985 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);