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, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
48 static bool link_dhcp4_enabled(Link *link) {
49 if (link->flags & IFF_LOOPBACK)
55 return IN_SET(link->network->dhcp, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
58 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_ipv4_forward_enabled(Link *link) {
92 if (link->flags & IFF_LOOPBACK)
98 return IN_SET(link->network->ip_forward, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
101 static bool link_ipv6_forward_enabled(Link *link) {
102 if (link->flags & IFF_LOOPBACK)
108 return IN_SET(link->network->ip_forward, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
111 #define FLAG_STRING(string, flag, old, new) \
112 (((old ^ new) & flag) \
113 ? ((old & flag) ? (" -" string) : (" +" string)) \
116 static int link_update_flags(Link *link, sd_rtnl_message *m) {
117 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
123 r = sd_rtnl_message_link_get_flags(m, &flags);
125 log_link_warning(link, "Could not get link flags");
129 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
131 /* if we got a message without operstate, take it to mean
132 the state was unchanged */
133 operstate = link->kernel_operstate;
135 if ((link->flags == flags) && (link->kernel_operstate == operstate))
138 if (link->flags != flags) {
139 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",
140 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
141 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
142 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
143 FLAG_STRING("UP", IFF_UP, link->flags, flags),
144 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
145 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
146 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
147 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
148 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
149 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
150 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
151 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
152 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
153 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
154 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
155 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
156 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
157 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
158 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
160 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
161 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
162 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
163 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
164 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
165 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
166 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
167 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
169 /* link flags are currently at most 18 bits, let's align to
171 if (unknown_flags_added)
173 "unknown link flags gained: %#.5x (ignoring)",
174 unknown_flags_added);
176 if (unknown_flags_removed)
178 "unknown link flags lost: %#.5x (ignoring)",
179 unknown_flags_removed);
183 link->kernel_operstate = operstate;
190 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
191 _cleanup_link_unref_ Link *link = NULL;
200 r = sd_rtnl_message_get_type(message, &type);
203 else if (type != RTM_NEWLINK)
206 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
209 else if (ifindex <= 0)
212 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
216 link = new0(Link, 1);
221 link->manager = manager;
222 link->state = LINK_STATE_PENDING;
223 link->ifindex = ifindex;
224 link->ifname = strdup(ifname);
228 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
230 log_link_debug(link, "MAC address not found for new device, continuing without");
232 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
237 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
242 r = asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d",
248 r = hashmap_ensure_allocated(&manager->links, NULL);
252 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
256 r = link_update_flags(link, message);
266 static void link_free(Link *link) {
272 while ((address = link->addresses)) {
273 LIST_REMOVE(addresses, link->addresses, address);
274 address_free(address);
277 while ((address = link->pool_addresses)) {
278 LIST_REMOVE(addresses, link->pool_addresses, address);
279 address_free(address);
282 sd_dhcp_server_unref(link->dhcp_server);
283 sd_dhcp_client_unref(link->dhcp_client);
284 sd_dhcp_lease_unref(link->dhcp_lease);
286 unlink(link->lease_file);
287 free(link->lease_file);
289 sd_lldp_free(link->lldp);
291 unlink(link->lldp_file);
292 free(link->lldp_file);
294 sd_ipv4ll_unref(link->ipv4ll);
295 sd_dhcp6_client_unref(link->dhcp6_client);
296 sd_icmp6_nd_unref(link->icmp6_router_discovery);
299 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
303 unlink(link->state_file);
304 free(link->state_file);
306 udev_device_unref(link->udev_device);
311 Link *link_unref(Link *link) {
312 if (link && (-- link->n_ref <= 0))
318 Link *link_ref(Link *link) {
320 assert_se(++ link->n_ref >= 2);
325 int link_get(Manager *m, int ifindex, Link **ret) {
332 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
341 void link_drop(Link *link) {
342 if (!link || link->state == LINK_STATE_LINGER)
345 link->state = LINK_STATE_LINGER;
347 log_link_debug(link, "link removed");
354 static void link_enter_unmanaged(Link *link) {
357 log_link_debug(link, "unmanaged");
359 link->state = LINK_STATE_UNMANAGED;
364 static int link_stop_clients(Link *link) {
368 assert(link->manager);
369 assert(link->manager->event);
374 if (link->dhcp_client) {
375 k = sd_dhcp_client_stop(link->dhcp_client);
377 log_link_warning(link, "Could not stop DHCPv4 client: %s",
384 k = sd_ipv4ll_stop(link->ipv4ll);
386 log_link_warning(link, "Could not stop IPv4 link-local: %s",
392 if(link->icmp6_router_discovery) {
394 if (link->dhcp6_client) {
395 k = sd_dhcp6_client_stop(link->dhcp6_client);
397 log_link_warning(link, "Could not stop DHCPv6 client: %s",
403 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
405 log_link_warning(link,
406 "Could not stop ICMPv6 router discovery: %s",
414 k = sd_lldp_stop(link->lldp);
416 log_link_warning(link, "Could not stop LLDP : %s",
425 void link_enter_failed(Link *link) {
428 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
431 log_link_warning(link, "failed");
433 link->state = LINK_STATE_FAILED;
435 link_stop_clients(link);
440 static Address* link_find_dhcp_server_address(Link *link) {
444 assert(link->network);
446 /* The first statically configured address if there is any */
447 LIST_FOREACH(addresses, address, link->network->static_addresses) {
449 if (address->family != AF_INET)
452 if (in_addr_is_null(address->family, &address->in_addr))
458 /* If that didn't work, find a suitable address we got from the pool */
459 LIST_FOREACH(addresses, address, link->pool_addresses) {
460 if (address->family != AF_INET)
469 static int link_enter_configured(Link *link) {
471 assert(link->network);
472 assert(link->state == LINK_STATE_SETTING_ROUTES);
474 log_link_info(link, "link configured");
476 link->state = LINK_STATE_CONFIGURED;
483 void link_client_handler(Link *link) {
485 assert(link->network);
487 if (!link->static_configured)
490 if (link_ipv4ll_enabled(link))
491 if (!link->ipv4ll_address ||
495 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
498 if (link->state != LINK_STATE_CONFIGURED)
499 link_enter_configured(link);
504 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
505 _cleanup_link_unref_ Link *link = userdata;
508 assert(link->link_messages > 0);
509 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
510 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
513 link->link_messages --;
515 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
518 r = sd_rtnl_message_get_errno(m);
519 if (r < 0 && r != -EEXIST)
520 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
522 if (link->link_messages == 0) {
523 log_link_debug(link, "routes set");
524 link->static_configured = true;
525 link_client_handler(link);
531 static int link_enter_set_routes(Link *link) {
536 assert(link->network);
537 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
539 link->state = LINK_STATE_SETTING_ROUTES;
541 LIST_FOREACH(routes, rt, link->network->static_routes) {
542 r = route_configure(rt, link, &route_handler);
544 log_link_warning(link,
545 "could not set routes: %s",
547 link_enter_failed(link);
551 link->link_messages ++;
554 if (link->link_messages == 0) {
555 link->static_configured = true;
556 link_client_handler(link);
558 log_link_debug(link, "setting routes");
563 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
564 _cleanup_link_unref_ Link *link = userdata;
569 assert(link->ifname);
571 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
574 r = sd_rtnl_message_get_errno(m);
575 if (r < 0 && r != -ESRCH)
576 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
581 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
582 _cleanup_link_unref_ Link *link = userdata;
588 assert(link->ifname);
589 assert(link->link_messages > 0);
590 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
591 LINK_STATE_FAILED, LINK_STATE_LINGER));
593 link->link_messages --;
595 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
598 r = sd_rtnl_message_get_errno(m);
599 if (r < 0 && r != -EEXIST)
600 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
602 link_rtnl_process_address(rtnl, m, link->manager);
604 if (link->link_messages == 0) {
605 log_link_debug(link, "addresses set");
606 link_enter_set_routes(link);
612 static int link_enter_set_addresses(Link *link) {
617 assert(link->network);
618 assert(link->state != _LINK_STATE_INVALID);
620 link->state = LINK_STATE_SETTING_ADDRESSES;
622 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
623 r = address_configure(ad, link, &address_handler);
625 log_link_warning_errno(link, r, "Could not set addresses: %m");
626 link_enter_failed(link);
630 link->link_messages ++;
633 /* now that we can figure out a default address for the dhcp server,
635 if (link_dhcp4_server_enabled(link)) {
636 struct in_addr pool_start;
639 address = link_find_dhcp_server_address(link);
641 log_link_warning(link,
642 "Failed to find suitable address for DHCPv4 server instance.");
643 link_enter_failed(link);
647 r = sd_dhcp_server_set_address(link->dhcp_server,
648 &address->in_addr.in,
653 /* offer 32 addresses starting from the address following the server address */
654 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
655 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
661 r = sd_dhcp_server_set_router(link->dhcp_server,
662 &main_address->in_addr.in);
666 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
667 main_address->prefixlen);
672 r = sd_dhcp_server_start(link->dhcp_server);
674 log_link_warning(link, "could not start DHCPv4 server "
675 "instance: %s", strerror(-r));
677 link_enter_failed(link);
682 log_link_debug(link, "offering DHCPv4 leases");
685 if (link->link_messages == 0) {
686 link_enter_set_routes(link);
688 log_link_debug(link, "setting addresses");
693 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
694 _cleanup_link_unref_ Link *link = userdata;
699 assert(link->ifname);
701 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
704 r = sd_rtnl_message_get_errno(m);
705 if (r < 0 && r != -EADDRNOTAVAIL)
706 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
711 static int link_set_bridge_fdb(const Link *const link) {
715 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
716 r = fdb_entry_configure(link->manager->rtnl, fdb_entry, link->ifindex);
718 log_link_error(link, "Failed to add MAC entry to static MAC table: %s", strerror(-r));
726 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
727 _cleanup_link_unref_ Link *link = userdata;
730 log_link_debug(link, "set link");
732 r = sd_rtnl_message_get_errno(m);
733 if (r < 0 && r != -EEXIST) {
734 log_link_struct(link, LOG_ERR,
735 "MESSAGE=%-*s: could not join netdev: %s",
737 link->ifname, strerror(-r),
740 link_enter_failed(link);
747 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
748 sd_bus_error *ret_error) {
749 _cleanup_link_unref_ Link *link = userdata;
754 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
757 r = sd_bus_message_get_errno(m);
759 log_link_warning(link, "Could not set hostname: %s",
765 int link_set_hostname(Link *link, const char *hostname) {
766 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
770 assert(link->manager);
773 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
775 if (!link->manager->bus) {
776 /* TODO: replace by assert when we can rely on kdbus */
778 "Not connected to system bus, ignoring transient hostname.");
782 r = sd_bus_message_new_method_call(
785 "org.freedesktop.hostname1",
786 "/org/freedesktop/hostname1",
787 "org.freedesktop.hostname1",
792 r = sd_bus_message_append(m, "sb", hostname, false);
796 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
799 log_link_error(link, "Could not set transient hostname: %s",
809 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
810 _cleanup_link_unref_ Link *link = userdata;
815 assert(link->ifname);
817 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
820 r = sd_rtnl_message_get_errno(m);
822 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
827 int link_set_mtu(Link *link, uint32_t mtu) {
828 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
832 assert(link->manager);
833 assert(link->manager->rtnl);
835 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
837 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
838 RTM_SETLINK, link->ifindex);
840 log_link_error(link, "Could not allocate RTM_SETLINK message");
844 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
846 log_link_error(link, "Could not append MTU: %s", strerror(-r));
850 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
854 "Could not send rtnetlink message: %s",
864 static int link_set_bridge(Link *link) {
865 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
869 assert(link->network);
871 if(link->network->cost == 0)
874 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
875 RTM_SETLINK, link->ifindex);
877 log_link_error(link, "Could not allocate RTM_SETLINK message");
881 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
884 "Could not set message family %s", strerror(-r));
888 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
891 "Could not append IFLA_PROTINFO attribute: %s",
896 if(link->network->cost != 0) {
897 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
900 "Could not append IFLA_BRPORT_COST attribute: %s",
906 r = sd_rtnl_message_close_container(req);
909 "Could not append IFLA_LINKINFO attribute: %s",
914 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
917 "Could not send rtnetlink message: %s",
927 static void lldp_handler(sd_lldp *lldp, int event, void *userdata) {
928 Link *link = userdata;
932 assert(link->network);
933 assert(link->manager);
935 if (event != UPDATE_INFO)
938 r = sd_lldp_save(link->lldp, link->lldp_file);
940 log_link_warning(link, "could not save LLDP");
944 static int link_acquire_conf(Link *link) {
948 assert(link->network);
949 assert(link->manager);
950 assert(link->manager->event);
952 if (link_ipv4ll_enabled(link)) {
953 assert(link->ipv4ll);
955 log_link_debug(link, "acquiring IPv4 link-local address");
957 r = sd_ipv4ll_start(link->ipv4ll);
959 log_link_warning(link, "could not acquire IPv4 "
960 "link-local address");
965 if (link_dhcp4_enabled(link)) {
966 assert(link->dhcp_client);
968 log_link_debug(link, "acquiring DHCPv4 lease");
970 r = sd_dhcp_client_start(link->dhcp_client);
972 log_link_warning(link, "could not acquire DHCPv4 "
978 if (link_dhcp6_enabled(link)) {
979 assert(link->icmp6_router_discovery);
981 log_link_debug(link, "discovering IPv6 routers");
983 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
985 log_link_warning(link,
986 "could not start IPv6 router discovery");
991 if (link_lldp_enabled(link)) {
994 log_link_debug(link, "Starting LLDP");
996 r = sd_lldp_start(link->lldp);
998 log_link_warning(link, "could not start LLDP ");
1006 bool link_has_carrier(Link *link) {
1007 /* see Documentation/networking/operstates.txt in the kernel sources */
1009 if (link->kernel_operstate == IF_OPER_UP)
1012 if (link->kernel_operstate == IF_OPER_UNKNOWN)
1013 /* operstate may not be implemented, so fall back to flags */
1014 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1020 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1021 _cleanup_link_unref_ Link *link = userdata;
1026 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1029 r = sd_rtnl_message_get_errno(m);
1031 /* we warn but don't fail the link, as it may
1032 be brought up later */
1033 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
1039 static int link_up(Link *link) {
1040 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1044 assert(link->network);
1045 assert(link->manager);
1046 assert(link->manager->rtnl);
1048 log_link_debug(link, "bringing link up");
1050 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1051 RTM_SETLINK, link->ifindex);
1053 log_link_error(link, "Could not allocate RTM_SETLINK message");
1057 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1059 log_link_error(link, "Could not set link flags: %s",
1064 if (link->network->mac) {
1065 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1067 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
1072 if (link->network->mtu) {
1073 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
1075 log_link_error(link, "Could not set MTU: %s", strerror(-r));
1080 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1083 log_link_error(link,
1084 "Could not send rtnetlink message: %s",
1094 static int link_joined(Link *link) {
1098 assert(link->network);
1100 if (!(link->flags & IFF_UP)) {
1103 link_enter_failed(link);
1108 if(link->network->bridge) {
1109 r = link_set_bridge(link);
1111 log_link_error(link,
1112 "Could not set bridge message: %s",
1117 return link_enter_set_addresses(link);
1120 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1122 _cleanup_link_unref_ Link *link = userdata;
1126 assert(link->network);
1130 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1133 r = sd_rtnl_message_get_errno(m);
1134 if (r < 0 && r != -EEXIST) {
1135 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1136 link_enter_failed(link);
1139 log_link_debug(link, "joined netdev");
1141 if (link->enslaving <= 0)
1147 static int link_enter_join_netdev(Link *link) {
1153 assert(link->network);
1154 assert(link->state == LINK_STATE_PENDING);
1156 link->state = LINK_STATE_ENSLAVING;
1160 if (!link->network->bridge &&
1161 !link->network->bond &&
1162 hashmap_isempty(link->network->stacked_netdevs))
1163 return link_joined(link);
1165 if (link->network->bond) {
1166 log_link_struct(link, LOG_DEBUG,
1167 "MESSAGE=%-*s: enslaving by '%s'",
1169 link->ifname, link->network->bond->ifname,
1170 NETDEVIF(link->network->bond),
1173 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1175 log_link_struct(link, LOG_WARNING,
1176 "MESSAGE=%-*s: could not join netdev '%s': %s",
1178 link->ifname, link->network->bond->ifname,
1180 NETDEVIF(link->network->bond),
1182 link_enter_failed(link);
1189 if (link->network->bridge) {
1190 log_link_struct(link, LOG_DEBUG,
1191 "MESSAGE=%-*s: enslaving by '%s'",
1193 link->ifname, link->network->bridge->ifname,
1194 NETDEVIF(link->network->bridge),
1197 r = netdev_join(link->network->bridge, link,
1198 &netdev_join_handler);
1200 log_link_struct(link, LOG_WARNING,
1201 "MESSAGE=%-*s: could not join netdev '%s': %s",
1203 link->ifname, link->network->bridge->ifname,
1205 NETDEVIF(link->network->bridge),
1207 link_enter_failed(link);
1214 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1215 log_link_struct(link, LOG_DEBUG,
1216 "MESSAGE=%-*s: enslaving by '%s'",
1218 link->ifname, netdev->ifname, NETDEVIF(netdev),
1221 r = netdev_join(netdev, link, &netdev_join_handler);
1223 log_link_struct(link, LOG_WARNING,
1224 "MESSAGE=%-*s: could not join netdev '%s': %s",
1226 link->ifname, netdev->ifname,
1228 NETDEVIF(netdev), NULL);
1229 link_enter_failed(link);
1239 static int link_set_ipv4_forward(Link *link) {
1240 const char *p = NULL;
1244 b = link_ipv4_forward_enabled(link);
1246 p = strjoina("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
1247 r = write_string_file_no_create(p, one_zero(b));
1249 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
1252 _cleanup_free_ char *buf = NULL;
1254 /* If IP forwarding is turned on for this interface,
1255 * then propagate this to the global setting. Given
1256 * that turning this on has side-effects on other
1257 * fields, we'll try to avoid doing this unless
1258 * necessary, hence check the previous value
1259 * first. Note that we never turn this option off
1260 * again, since all interfaces we manage do not do
1261 * forwarding anyway by default, and ownership rules
1262 * of this control are so unclear. */
1264 r = read_one_line_file("/proc/sys/net/ipv4/ip_forward", &buf);
1266 log_link_warning_errno(link, r, "Cannot read /proc/sys/net/ipv4/ip_forward: %m");
1267 else if (!streq(buf, "1")) {
1268 r = write_string_file_no_create("/proc/sys/net/ipv4/ip_forward", "1");
1270 log_link_warning_errno(link, r, "Cannot write /proc/sys/net/ipv4/ip_forward: %m");
1277 static int link_set_ipv6_forward(Link *link) {
1278 const char *p = NULL;
1281 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
1282 r = write_string_file_no_create(p, one_zero(link_ipv6_forward_enabled(link)));
1284 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
1289 static int link_configure(Link *link) {
1293 assert(link->network);
1294 assert(link->state == LINK_STATE_PENDING);
1296 r = link_set_bridge_fdb(link);
1300 r = link_set_ipv4_forward(link);
1304 r = link_set_ipv6_forward(link);
1308 if (link_ipv4ll_enabled(link)) {
1309 r = ipv4ll_configure(link);
1314 if (link_dhcp4_enabled(link)) {
1315 r = dhcp4_configure(link);
1320 if (link_dhcp4_server_enabled(link)) {
1321 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1325 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1330 if (link_dhcp6_enabled(link)) {
1331 r = icmp6_configure(link);
1336 if (link_lldp_enabled(link)) {
1337 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1341 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1345 r = sd_lldp_set_callback(link->lldp,
1346 lldp_handler, link);
1351 if (link_has_carrier(link)) {
1352 r = link_acquire_conf(link);
1357 return link_enter_join_netdev(link);
1360 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1362 _cleanup_link_unref_ Link *link = userdata;
1367 assert(link->ifname);
1368 assert(link->manager);
1370 if (link->state != LINK_STATE_PENDING)
1373 log_link_debug(link, "link state is up-to-date");
1375 r = network_get(link->manager, link->udev_device, link->ifname,
1376 &link->mac, &network);
1378 link_enter_unmanaged(link);
1383 if (link->flags & IFF_LOOPBACK) {
1384 if (network->ipv4ll)
1385 log_link_debug(link, "ignoring IPv4LL for loopback link");
1387 if (network->dhcp != ADDRESS_FAMILY_NO)
1388 log_link_debug(link, "ignoring DHCP clients for loopback link");
1390 if (network->dhcp_server)
1391 log_link_debug(link, "ignoring DHCP server for loopback link");
1394 r = network_apply(link->manager, network, link);
1398 r = link_configure(link);
1405 int link_initialized(Link *link, struct udev_device *device) {
1406 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1410 assert(link->manager);
1411 assert(link->manager->rtnl);
1414 if (link->state != LINK_STATE_PENDING)
1417 if (link->udev_device)
1420 log_link_debug(link, "udev initialized link");
1422 link->udev_device = udev_device_ref(device);
1424 /* udev has initialized the link, but we don't know if we have yet
1425 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1426 * when it returns we know that the pending NEWLINKs have already been
1427 * processed and that we are up-to-date */
1429 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1434 r = sd_rtnl_call_async(link->manager->rtnl, req,
1435 link_initialized_and_synced, link, 0, NULL);
1444 static Address* link_get_equal_address(Link *link, Address *needle) {
1450 LIST_FOREACH(addresses, i, link->addresses)
1451 if (address_equal(i, needle))
1457 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1458 Manager *m = userdata;
1461 _cleanup_address_free_ Address *address = NULL;
1463 char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
1464 const char *valid_str = NULL;
1471 if (sd_rtnl_message_is_error(message)) {
1472 r = sd_rtnl_message_get_errno(message);
1474 log_warning_errno(r, "rtnl: failed to receive address: %m");
1479 r = sd_rtnl_message_get_type(message, &type);
1481 log_warning("rtnl: could not get message type");
1485 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1487 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1489 } else if (ifindex <= 0) {
1490 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1493 r = link_get(m, ifindex, &link);
1494 if (r < 0 || !link) {
1495 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1500 r = address_new_dynamic(&address);
1504 r = sd_rtnl_message_addr_get_family(message, &address->family);
1505 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1506 log_link_warning(link, "rtnl: received address with invalid family, ignoring");
1510 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1512 log_link_warning(link, "rtnl: received address with invalid prefixlen, ignoring");
1516 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1518 log_link_warning(link, "rtnl: received address with invalid scope, ignoring");
1522 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1524 log_link_warning(link, "rtnl: received address with invalid flags, ignoring");
1528 switch (address->family) {
1530 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1532 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1539 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1541 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1548 assert_not_reached("invalid address family");
1551 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1552 log_link_warning(link, "could not print address");
1556 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1558 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1561 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1562 address->cinfo.ifa_valid * USEC_PER_SEC,
1566 existing = link_get_equal_address(link, address);
1571 log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1574 existing->scope = address->scope;
1575 existing->flags = address->flags;
1576 existing->cinfo = address->cinfo;
1579 log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1581 LIST_PREPEND(addresses, link->addresses, address);
1582 address_establish(address, link);
1594 log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1595 address_release(existing, link);
1596 LIST_REMOVE(addresses, link->addresses, existing);
1597 address_free(existing);
1599 log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1603 assert_not_reached("Received invalid RTNL message type");
1609 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1611 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1612 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1620 r = link_new(m, message, ret);
1626 log_link_debug(link, "link %d added", link->ifindex);
1628 if (detect_container(NULL) <= 0) {
1629 /* not in a container, udev will be around */
1630 sprintf(ifindex_str, "n%d", link->ifindex);
1631 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1633 log_link_warning(link,
1634 "could not find udev device: %m");
1638 if (udev_device_get_is_initialized(device) <= 0) {
1640 log_link_debug(link, "link pending udev initialization...");
1644 r = link_initialized(link, device);
1648 /* we are calling a callback directly, so must take a ref */
1651 r = link_initialized_and_synced(m->rtnl, NULL, link);
1659 int link_update(Link *link, sd_rtnl_message *m) {
1660 struct ether_addr mac;
1663 bool had_carrier, carrier_gained, carrier_lost;
1667 assert(link->ifname);
1670 if (link->state == LINK_STATE_LINGER) {
1672 log_link_info(link, "link readded");
1673 link->state = LINK_STATE_ENSLAVING;
1676 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1677 if (r >= 0 && !streq(ifname, link->ifname)) {
1678 log_link_info(link, "renamed to %s", ifname);
1681 link->ifname = strdup(ifname);
1686 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1687 if (r >= 0 && mtu > 0) {
1689 if (!link->original_mtu) {
1690 link->original_mtu = mtu;
1691 log_link_debug(link, "saved original MTU: %"
1692 PRIu32, link->original_mtu);
1695 if (link->dhcp_client) {
1696 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1699 log_link_warning(link,
1700 "Could not update MTU in DHCP client: %s",
1707 /* The kernel may broadcast NEWLINK messages without the MAC address
1708 set, simply ignore them. */
1709 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1711 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1714 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1717 log_link_debug(link, "MAC address: "
1718 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1719 mac.ether_addr_octet[0],
1720 mac.ether_addr_octet[1],
1721 mac.ether_addr_octet[2],
1722 mac.ether_addr_octet[3],
1723 mac.ether_addr_octet[4],
1724 mac.ether_addr_octet[5]);
1727 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1729 log_link_warning(link,
1730 "Could not update MAC address in IPv4LL client: %s",
1736 if (link->dhcp_client) {
1737 r = sd_dhcp_client_set_mac(link->dhcp_client,
1738 (const uint8_t *) &link->mac,
1742 log_link_warning(link,
1743 "Could not update MAC address in DHCP client: %s",
1749 if (link->dhcp6_client) {
1750 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1751 (const uint8_t *) &link->mac,
1755 log_link_warning(link,
1756 "Could not update MAC address in DHCPv6 client: %s",
1764 had_carrier = link_has_carrier(link);
1766 r = link_update_flags(link, m);
1770 carrier_gained = !had_carrier && link_has_carrier(link);
1771 carrier_lost = had_carrier && !link_has_carrier(link);
1773 if (carrier_gained) {
1774 log_link_info(link, "gained carrier");
1776 if (link->network) {
1777 r = link_acquire_conf(link);
1779 link_enter_failed(link);
1783 } else if (carrier_lost) {
1784 log_link_info(link, "lost carrier");
1786 r = link_stop_clients(link);
1788 link_enter_failed(link);
1796 static void link_update_operstate(Link *link) {
1800 if (link->kernel_operstate == IF_OPER_DORMANT)
1801 link->operstate = LINK_OPERSTATE_DORMANT;
1802 else if (link_has_carrier(link)) {
1804 uint8_t scope = RT_SCOPE_NOWHERE;
1806 /* if we have carrier, check what addresses we have */
1807 LIST_FOREACH(addresses, address, link->addresses) {
1808 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1811 if (address->scope < scope)
1812 scope = address->scope;
1815 if (scope < RT_SCOPE_SITE)
1816 /* universally accessible addresses found */
1817 link->operstate = LINK_OPERSTATE_ROUTABLE;
1818 else if (scope < RT_SCOPE_HOST)
1819 /* only link or site local addresses found */
1820 link->operstate = LINK_OPERSTATE_DEGRADED;
1822 /* no useful addresses found */
1823 link->operstate = LINK_OPERSTATE_CARRIER;
1824 } else if (link->flags & IFF_UP)
1825 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1827 link->operstate = LINK_OPERSTATE_OFF;
1830 int link_save(Link *link) {
1831 _cleanup_free_ char *temp_path = NULL;
1832 _cleanup_fclose_ FILE *f = NULL;
1833 const char *admin_state, *oper_state;
1837 assert(link->state_file);
1838 assert(link->lease_file);
1839 assert(link->manager);
1841 link_update_operstate(link);
1843 r = manager_save(link->manager);
1847 if (link->state == LINK_STATE_LINGER) {
1848 unlink(link->state_file);
1852 admin_state = link_state_to_string(link->state);
1853 assert(admin_state);
1855 oper_state = link_operstate_to_string(link->operstate);
1858 r = fopen_temporary(link->state_file, &f, &temp_path);
1862 fchmod(fileno(f), 0644);
1865 "# This is private data. Do not parse.\n"
1868 admin_state, oper_state);
1870 if (link->network) {
1871 char **address, **domain;
1874 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1878 STRV_FOREACH(address, link->network->dns) {
1885 if (link->network->dhcp_dns &&
1887 const struct in_addr *addresses;
1889 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1893 serialize_in_addrs(f, addresses, r);
1901 STRV_FOREACH(address, link->network->ntp) {
1908 if (link->network->dhcp_ntp &&
1910 const struct in_addr *addresses;
1912 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1916 serialize_in_addrs(f, addresses, r);
1922 fprintf(f, "DOMAINS=");
1924 STRV_FOREACH(domain, link->network->domains) {
1931 if (link->network->dhcp_domains &&
1933 const char *domainname;
1935 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1939 fputs(domainname, f);
1945 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1946 yes_no(link->network->wildcard_domain));
1948 fprintf(f, "LLMNR=%s\n",
1949 llmnr_support_to_string(link->network->llmnr));
1952 if (link->dhcp_lease) {
1953 assert(link->network);
1955 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1963 unlink(link->lease_file);
1966 assert(link->network);
1968 r = sd_lldp_save(link->lldp, link->lldp_file);
1976 unlink(link->lldp_file);
1978 r = fflush_and_check(f);
1982 if (rename(temp_path, link->state_file) < 0) {
1989 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1990 unlink(link->state_file);
1995 static const char* const link_state_table[_LINK_STATE_MAX] = {
1996 [LINK_STATE_PENDING] = "pending",
1997 [LINK_STATE_ENSLAVING] = "configuring",
1998 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1999 [LINK_STATE_SETTING_ROUTES] = "configuring",
2000 [LINK_STATE_CONFIGURED] = "configured",
2001 [LINK_STATE_UNMANAGED] = "unmanaged",
2002 [LINK_STATE_FAILED] = "failed",
2003 [LINK_STATE_LINGER] = "linger",
2006 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2008 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2009 [LINK_OPERSTATE_OFF] = "off",
2010 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2011 [LINK_OPERSTATE_DORMANT] = "dormant",
2012 [LINK_OPERSTATE_CARRIER] = "carrier",
2013 [LINK_OPERSTATE_DEGRADED] = "degraded",
2014 [LINK_OPERSTATE_ROUTABLE] = "routable",
2017 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);