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 /* when enumerating we might be out of sync, but we will
1496 * get the address again, so just ignore it */
1497 if (!m->enumerating)
1498 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1503 r = address_new_dynamic(&address);
1507 r = sd_rtnl_message_addr_get_family(message, &address->family);
1508 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1509 log_link_warning(link, "rtnl: received address with invalid family, ignoring");
1513 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1515 log_link_warning(link, "rtnl: received address with invalid prefixlen, ignoring");
1519 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1521 log_link_warning(link, "rtnl: received address with invalid scope, ignoring");
1525 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1527 log_link_warning(link, "rtnl: received address with invalid flags, ignoring");
1531 switch (address->family) {
1533 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1535 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1542 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1544 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1551 assert_not_reached("invalid address family");
1554 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1555 log_link_warning(link, "could not print address");
1559 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1561 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1564 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1565 address->cinfo.ifa_valid * USEC_PER_SEC,
1569 existing = link_get_equal_address(link, address);
1574 log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1577 existing->scope = address->scope;
1578 existing->flags = address->flags;
1579 existing->cinfo = address->cinfo;
1582 log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1584 LIST_PREPEND(addresses, link->addresses, address);
1585 address_establish(address, link);
1597 log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1598 address_release(existing, link);
1599 LIST_REMOVE(addresses, link->addresses, existing);
1600 address_free(existing);
1602 log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1606 assert_not_reached("Received invalid RTNL message type");
1612 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1614 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1615 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1623 r = link_new(m, message, ret);
1629 log_link_debug(link, "link %d added", link->ifindex);
1631 if (detect_container(NULL) <= 0) {
1632 /* not in a container, udev will be around */
1633 sprintf(ifindex_str, "n%d", link->ifindex);
1634 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1636 log_link_warning(link,
1637 "could not find udev device: %m");
1641 if (udev_device_get_is_initialized(device) <= 0) {
1643 log_link_debug(link, "link pending udev initialization...");
1647 r = link_initialized(link, device);
1651 /* we are calling a callback directly, so must take a ref */
1654 r = link_initialized_and_synced(m->rtnl, NULL, link);
1662 static int link_carrier_gained(Link *link) {
1667 if (link->network) {
1668 r = link_acquire_conf(link);
1670 link_enter_failed(link);
1678 static int link_carrier_lost(Link *link) {
1683 r = link_stop_clients(link);
1685 link_enter_failed(link);
1692 int link_carrier_reset(Link *link) {
1697 if (link_has_carrier(link)) {
1698 r = link_carrier_lost(link);
1702 r = link_carrier_gained(link);
1706 log_link_info(link, "reset carrier");
1713 int link_update(Link *link, sd_rtnl_message *m) {
1714 struct ether_addr mac;
1717 bool had_carrier, carrier_gained, carrier_lost;
1721 assert(link->ifname);
1724 if (link->state == LINK_STATE_LINGER) {
1726 log_link_info(link, "link readded");
1727 link->state = LINK_STATE_ENSLAVING;
1730 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1731 if (r >= 0 && !streq(ifname, link->ifname)) {
1732 log_link_info(link, "renamed to %s", ifname);
1735 link->ifname = strdup(ifname);
1740 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1741 if (r >= 0 && mtu > 0) {
1743 if (!link->original_mtu) {
1744 link->original_mtu = mtu;
1745 log_link_debug(link, "saved original MTU: %"
1746 PRIu32, link->original_mtu);
1749 if (link->dhcp_client) {
1750 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1753 log_link_warning(link,
1754 "Could not update MTU in DHCP client: %s",
1761 /* The kernel may broadcast NEWLINK messages without the MAC address
1762 set, simply ignore them. */
1763 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1765 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1768 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1771 log_link_debug(link, "MAC address: "
1772 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1773 mac.ether_addr_octet[0],
1774 mac.ether_addr_octet[1],
1775 mac.ether_addr_octet[2],
1776 mac.ether_addr_octet[3],
1777 mac.ether_addr_octet[4],
1778 mac.ether_addr_octet[5]);
1781 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1783 log_link_warning(link,
1784 "Could not update MAC address in IPv4LL client: %s",
1790 if (link->dhcp_client) {
1791 r = sd_dhcp_client_set_mac(link->dhcp_client,
1792 (const uint8_t *) &link->mac,
1796 log_link_warning(link,
1797 "Could not update MAC address in DHCP client: %s",
1803 if (link->dhcp6_client) {
1804 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1805 (const uint8_t *) &link->mac,
1809 log_link_warning(link,
1810 "Could not update MAC address in DHCPv6 client: %s",
1818 had_carrier = link_has_carrier(link);
1820 r = link_update_flags(link, m);
1824 carrier_gained = !had_carrier && link_has_carrier(link);
1825 carrier_lost = had_carrier && !link_has_carrier(link);
1827 if (carrier_gained) {
1828 log_link_info(link, "gained carrier");
1830 r = link_carrier_gained(link);
1833 } else if (carrier_lost) {
1834 log_link_info(link, "lost carrier");
1836 r = link_carrier_lost(link);
1845 static void link_update_operstate(Link *link) {
1849 if (link->kernel_operstate == IF_OPER_DORMANT)
1850 link->operstate = LINK_OPERSTATE_DORMANT;
1851 else if (link_has_carrier(link)) {
1853 uint8_t scope = RT_SCOPE_NOWHERE;
1855 /* if we have carrier, check what addresses we have */
1856 LIST_FOREACH(addresses, address, link->addresses) {
1857 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1860 if (address->scope < scope)
1861 scope = address->scope;
1864 if (scope < RT_SCOPE_SITE)
1865 /* universally accessible addresses found */
1866 link->operstate = LINK_OPERSTATE_ROUTABLE;
1867 else if (scope < RT_SCOPE_HOST)
1868 /* only link or site local addresses found */
1869 link->operstate = LINK_OPERSTATE_DEGRADED;
1871 /* no useful addresses found */
1872 link->operstate = LINK_OPERSTATE_CARRIER;
1873 } else if (link->flags & IFF_UP)
1874 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1876 link->operstate = LINK_OPERSTATE_OFF;
1879 int link_save(Link *link) {
1880 _cleanup_free_ char *temp_path = NULL;
1881 _cleanup_fclose_ FILE *f = NULL;
1882 const char *admin_state, *oper_state;
1886 assert(link->state_file);
1887 assert(link->lease_file);
1888 assert(link->manager);
1890 link_update_operstate(link);
1892 r = manager_save(link->manager);
1896 if (link->state == LINK_STATE_LINGER) {
1897 unlink(link->state_file);
1901 admin_state = link_state_to_string(link->state);
1902 assert(admin_state);
1904 oper_state = link_operstate_to_string(link->operstate);
1907 r = fopen_temporary(link->state_file, &f, &temp_path);
1911 fchmod(fileno(f), 0644);
1914 "# This is private data. Do not parse.\n"
1917 admin_state, oper_state);
1919 if (link->network) {
1920 char **address, **domain;
1923 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1927 STRV_FOREACH(address, link->network->dns) {
1934 if (link->network->dhcp_dns &&
1936 const struct in_addr *addresses;
1938 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1942 serialize_in_addrs(f, addresses, r);
1950 STRV_FOREACH(address, link->network->ntp) {
1957 if (link->network->dhcp_ntp &&
1959 const struct in_addr *addresses;
1961 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1965 serialize_in_addrs(f, addresses, r);
1971 fprintf(f, "DOMAINS=");
1973 STRV_FOREACH(domain, link->network->domains) {
1980 if (link->network->dhcp_domains &&
1982 const char *domainname;
1984 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1988 fputs(domainname, f);
1994 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1995 yes_no(link->network->wildcard_domain));
1997 fprintf(f, "LLMNR=%s\n",
1998 llmnr_support_to_string(link->network->llmnr));
2001 if (link->dhcp_lease) {
2002 assert(link->network);
2004 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
2012 unlink(link->lease_file);
2015 assert(link->network);
2017 r = sd_lldp_save(link->lldp, link->lldp_file);
2025 unlink(link->lldp_file);
2027 r = fflush_and_check(f);
2031 if (rename(temp_path, link->state_file) < 0) {
2038 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2039 unlink(link->state_file);
2044 static const char* const link_state_table[_LINK_STATE_MAX] = {
2045 [LINK_STATE_PENDING] = "pending",
2046 [LINK_STATE_ENSLAVING] = "configuring",
2047 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2048 [LINK_STATE_SETTING_ROUTES] = "configuring",
2049 [LINK_STATE_CONFIGURED] = "configured",
2050 [LINK_STATE_UNMANAGED] = "unmanaged",
2051 [LINK_STATE_FAILED] = "failed",
2052 [LINK_STATE_LINGER] = "linger",
2055 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2057 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2058 [LINK_OPERSTATE_OFF] = "off",
2059 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2060 [LINK_OPERSTATE_DORMANT] = "dormant",
2061 [LINK_OPERSTATE_CARRIER] = "carrier",
2062 [LINK_OPERSTATE_DEGRADED] = "degraded",
2063 [LINK_OPERSTATE_ROUTABLE] = "routable",
2066 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);