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 "network-internal.h"
32 #include "networkd-link.h"
33 #include "networkd-netdev.h"
35 bool link_dhcp6_enabled(Link *link) {
36 if (link->flags & IFF_LOOPBACK)
42 return IN_SET(link->network->dhcp, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
45 bool link_dhcp4_enabled(Link *link) {
46 if (link->flags & IFF_LOOPBACK)
52 return IN_SET(link->network->dhcp, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
55 bool link_dhcp4_server_enabled(Link *link) {
56 if (link->flags & IFF_LOOPBACK)
62 return link->network->dhcp_server;
65 bool link_ipv4ll_enabled(Link *link) {
66 if (link->flags & IFF_LOOPBACK)
72 return IN_SET(link->network->link_local, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
75 bool link_ipv6ll_enabled(Link *link) {
76 if (link->flags & IFF_LOOPBACK)
82 return IN_SET(link->network->link_local, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
85 bool link_lldp_enabled(Link *link) {
86 if (link->flags & IFF_LOOPBACK)
92 if (link->network->bridge)
95 return link->network->lldp;
98 static bool link_ipv4_forward_enabled(Link *link) {
99 if (link->flags & IFF_LOOPBACK)
105 return IN_SET(link->network->ip_forward, ADDRESS_FAMILY_IPV4, ADDRESS_FAMILY_YES);
108 static bool link_ipv6_forward_enabled(Link *link) {
109 if (link->flags & IFF_LOOPBACK)
115 return IN_SET(link->network->ip_forward, ADDRESS_FAMILY_IPV6, ADDRESS_FAMILY_YES);
118 #define FLAG_STRING(string, flag, old, new) \
119 (((old ^ new) & flag) \
120 ? ((old & flag) ? (" -" string) : (" +" string)) \
123 static int link_update_flags(Link *link, sd_rtnl_message *m) {
124 unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
130 r = sd_rtnl_message_link_get_flags(m, &flags);
132 log_link_warning(link, "Could not get link flags");
136 r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
138 /* if we got a message without operstate, take it to mean
139 the state was unchanged */
140 operstate = link->kernel_operstate;
142 if ((link->flags == flags) && (link->kernel_operstate == operstate))
145 if (link->flags != flags) {
146 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",
147 FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
148 FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
149 FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
150 FLAG_STRING("UP", IFF_UP, link->flags, flags),
151 FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
152 FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
153 FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
154 FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
155 FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
156 FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
157 FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
158 FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
159 FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
160 FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
161 FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
162 FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
163 FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
164 FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
165 FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
167 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
168 IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
169 IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
170 IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
171 IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
172 IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
173 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
174 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
176 /* link flags are currently at most 18 bits, let's align to
178 if (unknown_flags_added)
180 "unknown link flags gained: %#.5x (ignoring)",
181 unknown_flags_added);
183 if (unknown_flags_removed)
185 "unknown link flags lost: %#.5x (ignoring)",
186 unknown_flags_removed);
190 link->kernel_operstate = operstate;
197 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
198 _cleanup_link_unref_ Link *link = NULL;
207 r = sd_rtnl_message_get_type(message, &type);
210 else if (type != RTM_NEWLINK)
213 r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
216 else if (ifindex <= 0)
219 r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
223 link = new0(Link, 1);
228 link->manager = manager;
229 link->state = LINK_STATE_PENDING;
230 link->ifindex = ifindex;
231 link->ifname = strdup(ifname);
235 r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
237 log_link_debug(link, "MAC address not found for new device, continuing without");
239 r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
244 r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
249 r = asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d",
255 r = hashmap_ensure_allocated(&manager->links, NULL);
259 r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
263 r = link_update_flags(link, message);
273 static void link_free(Link *link) {
279 while ((address = link->addresses)) {
280 LIST_REMOVE(addresses, link->addresses, address);
281 address_free(address);
284 while ((address = link->pool_addresses)) {
285 LIST_REMOVE(addresses, link->pool_addresses, address);
286 address_free(address);
289 sd_dhcp_server_unref(link->dhcp_server);
290 sd_dhcp_client_unref(link->dhcp_client);
291 sd_dhcp_lease_unref(link->dhcp_lease);
293 free(link->lease_file);
295 sd_lldp_free(link->lldp);
297 free(link->lldp_file);
299 sd_ipv4ll_unref(link->ipv4ll);
300 sd_dhcp6_client_unref(link->dhcp6_client);
301 sd_icmp6_nd_unref(link->icmp6_router_discovery);
304 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
308 free(link->state_file);
310 udev_device_unref(link->udev_device);
315 Link *link_unref(Link *link) {
316 if (link && (-- link->n_ref <= 0))
322 Link *link_ref(Link *link) {
324 assert_se(++ link->n_ref >= 2);
329 int link_get(Manager *m, int ifindex, Link **ret) {
336 link = hashmap_get(m->links, INT_TO_PTR(ifindex));
345 static void link_set_state(Link *link, LinkState state) {
348 if (link->state == state)
353 link_send_changed(link, "AdministrativeState", NULL);
358 void link_drop(Link *link) {
359 if (!link || link->state == LINK_STATE_LINGER)
362 link_set_state(link, LINK_STATE_LINGER);
364 log_link_debug(link, "link removed");
371 static void link_enter_unmanaged(Link *link) {
374 log_link_debug(link, "unmanaged");
376 link_set_state(link, LINK_STATE_UNMANAGED);
381 static int link_stop_clients(Link *link) {
385 assert(link->manager);
386 assert(link->manager->event);
391 if (link->dhcp_client) {
392 k = sd_dhcp_client_stop(link->dhcp_client);
394 log_link_warning(link, "Could not stop DHCPv4 client: %s",
401 k = sd_ipv4ll_stop(link->ipv4ll);
403 log_link_warning(link, "Could not stop IPv4 link-local: %s",
409 if(link->icmp6_router_discovery) {
411 if (link->dhcp6_client) {
412 k = sd_dhcp6_client_stop(link->dhcp6_client);
414 log_link_warning(link, "Could not stop DHCPv6 client: %s",
420 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
422 log_link_warning(link,
423 "Could not stop ICMPv6 router discovery: %s",
431 k = sd_lldp_stop(link->lldp);
433 log_link_warning(link, "Could not stop LLDP : %s",
442 void link_enter_failed(Link *link) {
445 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
448 log_link_warning(link, "failed");
450 link_set_state(link, LINK_STATE_FAILED);
452 link_stop_clients(link);
457 static Address* link_find_dhcp_server_address(Link *link) {
461 assert(link->network);
463 /* The first statically configured address if there is any */
464 LIST_FOREACH(addresses, address, link->network->static_addresses) {
466 if (address->family != AF_INET)
469 if (in_addr_is_null(address->family, &address->in_addr))
475 /* If that didn't work, find a suitable address we got from the pool */
476 LIST_FOREACH(addresses, address, link->pool_addresses) {
477 if (address->family != AF_INET)
486 static int link_enter_configured(Link *link) {
488 assert(link->network);
489 assert(link->state == LINK_STATE_SETTING_ROUTES);
491 log_link_info(link, "link configured");
493 link_set_state(link, LINK_STATE_CONFIGURED);
500 void link_client_handler(Link *link) {
502 assert(link->network);
504 if (!link->static_configured)
507 if (link_ipv4ll_enabled(link))
508 if (!link->ipv4ll_address ||
512 if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
515 if (link->state != LINK_STATE_CONFIGURED)
516 link_enter_configured(link);
521 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
522 _cleanup_link_unref_ Link *link = userdata;
525 assert(link->link_messages > 0);
526 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
527 LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
530 link->link_messages --;
532 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
535 r = sd_rtnl_message_get_errno(m);
536 if (r < 0 && r != -EEXIST)
537 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
539 if (link->link_messages == 0) {
540 log_link_debug(link, "routes set");
541 link->static_configured = true;
542 link_client_handler(link);
548 static int link_enter_set_routes(Link *link) {
553 assert(link->network);
554 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
556 link_set_state(link, LINK_STATE_SETTING_ROUTES);
558 LIST_FOREACH(routes, rt, link->network->static_routes) {
559 r = route_configure(rt, link, &route_handler);
561 log_link_warning(link,
562 "could not set routes: %s",
564 link_enter_failed(link);
568 link->link_messages ++;
571 if (link->link_messages == 0) {
572 link->static_configured = true;
573 link_client_handler(link);
575 log_link_debug(link, "setting routes");
580 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
581 _cleanup_link_unref_ Link *link = userdata;
586 assert(link->ifname);
588 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
591 r = sd_rtnl_message_get_errno(m);
592 if (r < 0 && r != -ESRCH)
593 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
598 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
599 _cleanup_link_unref_ Link *link = userdata;
605 assert(link->ifname);
606 assert(link->link_messages > 0);
607 assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
608 LINK_STATE_FAILED, LINK_STATE_LINGER));
610 link->link_messages --;
612 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
615 r = sd_rtnl_message_get_errno(m);
616 if (r < 0 && r != -EEXIST)
617 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
619 link_rtnl_process_address(rtnl, m, link->manager);
621 if (link->link_messages == 0) {
622 log_link_debug(link, "addresses set");
623 link_enter_set_routes(link);
629 static int link_enter_set_addresses(Link *link) {
634 assert(link->network);
635 assert(link->state != _LINK_STATE_INVALID);
637 link_set_state(link, LINK_STATE_SETTING_ADDRESSES);
639 LIST_FOREACH(addresses, ad, link->network->static_addresses) {
640 r = address_configure(ad, link, &address_handler);
642 log_link_warning_errno(link, r, "Could not set addresses: %m");
643 link_enter_failed(link);
647 link->link_messages ++;
650 /* now that we can figure out a default address for the dhcp server,
652 if (link_dhcp4_server_enabled(link)) {
653 struct in_addr pool_start;
656 address = link_find_dhcp_server_address(link);
658 log_link_warning(link,
659 "Failed to find suitable address for DHCPv4 server instance.");
660 link_enter_failed(link);
664 r = sd_dhcp_server_set_address(link->dhcp_server,
665 &address->in_addr.in,
670 /* offer 32 addresses starting from the address following the server address */
671 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
672 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
678 r = sd_dhcp_server_set_router(link->dhcp_server,
679 &main_address->in_addr.in);
683 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
684 main_address->prefixlen);
689 r = sd_dhcp_server_start(link->dhcp_server);
691 log_link_warning(link, "could not start DHCPv4 server "
692 "instance: %s", strerror(-r));
694 link_enter_failed(link);
699 log_link_debug(link, "offering DHCPv4 leases");
702 if (link->link_messages == 0) {
703 link_enter_set_routes(link);
705 log_link_debug(link, "setting addresses");
710 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
711 _cleanup_link_unref_ Link *link = userdata;
716 assert(link->ifname);
718 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
721 r = sd_rtnl_message_get_errno(m);
722 if (r < 0 && r != -EADDRNOTAVAIL)
723 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
728 static int link_set_bridge_fdb(Link *const link) {
732 LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
733 r = fdb_entry_configure(link, fdb_entry);
735 log_link_error(link, "Failed to add MAC entry to static MAC table: %s", strerror(-r));
743 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
744 _cleanup_link_unref_ Link *link = userdata;
747 log_link_debug(link, "set link");
749 r = sd_rtnl_message_get_errno(m);
750 if (r < 0 && r != -EEXIST) {
751 log_link_struct(link, LOG_ERR,
752 "MESSAGE=%-*s: could not join netdev: %s",
754 link->ifname, strerror(-r),
757 link_enter_failed(link);
764 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
765 sd_bus_error *ret_error) {
766 _cleanup_link_unref_ Link *link = userdata;
771 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
774 r = sd_bus_message_get_errno(m);
776 log_link_warning(link, "Could not set hostname: %s",
782 int link_set_hostname(Link *link, const char *hostname) {
783 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
787 assert(link->manager);
790 log_link_debug(link, "Setting transient hostname: '%s'", hostname);
792 if (!link->manager->bus) {
793 /* TODO: replace by assert when we can rely on kdbus */
795 "Not connected to system bus, ignoring transient hostname.");
799 r = sd_bus_message_new_method_call(
802 "org.freedesktop.hostname1",
803 "/org/freedesktop/hostname1",
804 "org.freedesktop.hostname1",
809 r = sd_bus_message_append(m, "sb", hostname, false);
813 r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
816 log_link_error(link, "Could not set transient hostname: %s",
826 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
827 _cleanup_link_unref_ Link *link = userdata;
832 assert(link->ifname);
834 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
837 r = sd_rtnl_message_get_errno(m);
839 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
844 int link_set_mtu(Link *link, uint32_t mtu) {
845 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
849 assert(link->manager);
850 assert(link->manager->rtnl);
852 log_link_debug(link, "setting MTU: %" PRIu32, mtu);
854 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
855 RTM_SETLINK, link->ifindex);
857 log_link_error(link, "Could not allocate RTM_SETLINK message");
861 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
863 log_link_error(link, "Could not append MTU: %s", strerror(-r));
867 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
871 "Could not send rtnetlink message: %s",
881 static int link_set_bridge(Link *link) {
882 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
886 assert(link->network);
888 if(link->network->cost == 0)
891 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
892 RTM_SETLINK, link->ifindex);
894 log_link_error(link, "Could not allocate RTM_SETLINK message");
898 r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
901 "Could not set message family %s", strerror(-r));
905 r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
908 "Could not append IFLA_PROTINFO attribute: %s",
913 if(link->network->cost != 0) {
914 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
917 "Could not append IFLA_BRPORT_COST attribute: %s",
923 r = sd_rtnl_message_close_container(req);
926 "Could not append IFLA_LINKINFO attribute: %s",
931 r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
934 "Could not send rtnetlink message: %s",
944 static void lldp_handler(sd_lldp *lldp, int event, void *userdata) {
945 Link *link = userdata;
949 assert(link->network);
950 assert(link->manager);
952 if (event != UPDATE_INFO)
955 r = sd_lldp_save(link->lldp, link->lldp_file);
957 log_link_warning(link, "could not save LLDP");
961 static int link_acquire_conf(Link *link) {
965 assert(link->network);
966 assert(link->manager);
967 assert(link->manager->event);
969 if (link_ipv4ll_enabled(link)) {
970 assert(link->ipv4ll);
972 log_link_debug(link, "acquiring IPv4 link-local address");
974 r = sd_ipv4ll_start(link->ipv4ll);
976 log_link_warning(link, "could not acquire IPv4 "
977 "link-local address");
982 if (link_dhcp4_enabled(link)) {
983 assert(link->dhcp_client);
985 log_link_debug(link, "acquiring DHCPv4 lease");
987 r = sd_dhcp_client_start(link->dhcp_client);
989 log_link_warning(link, "could not acquire DHCPv4 "
995 if (link_dhcp6_enabled(link)) {
996 assert(link->icmp6_router_discovery);
998 log_link_debug(link, "discovering IPv6 routers");
1000 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1002 log_link_warning(link,
1003 "could not start IPv6 router discovery");
1008 if (link_lldp_enabled(link)) {
1011 log_link_debug(link, "Starting LLDP");
1013 r = sd_lldp_start(link->lldp);
1015 log_link_warning(link, "could not start LLDP ");
1023 bool link_has_carrier(Link *link) {
1024 /* see Documentation/networking/operstates.txt in the kernel sources */
1026 if (link->kernel_operstate == IF_OPER_UP)
1029 if (link->kernel_operstate == IF_OPER_UNKNOWN)
1030 /* operstate may not be implemented, so fall back to flags */
1031 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1037 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1038 _cleanup_link_unref_ Link *link = userdata;
1043 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1046 r = sd_rtnl_message_get_errno(m);
1048 /* we warn but don't fail the link, as it may
1049 be brought up later */
1050 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
1056 static int link_up(Link *link) {
1057 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1058 uint8_t ipv6ll_mode;
1062 assert(link->network);
1063 assert(link->manager);
1064 assert(link->manager->rtnl);
1066 log_link_debug(link, "bringing link up");
1068 r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1069 RTM_SETLINK, link->ifindex);
1071 log_link_error(link, "Could not allocate RTM_SETLINK message");
1075 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1077 log_link_error(link, "Could not set link flags: %s",
1082 if (link->network->mac) {
1083 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1085 log_link_error(link, "Could not set MAC address: %s", strerror(-r));
1090 if (link->network->mtu) {
1091 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
1093 log_link_error(link, "Could not set MTU: %s", strerror(-r));
1098 r = sd_rtnl_message_open_container(req, IFLA_AF_SPEC);
1100 log_link_error(link, "Could not open IFLA_AF_SPEC container: %s", strerror(-r));
1104 r = sd_rtnl_message_open_container(req, AF_INET6);
1106 log_link_error(link, "Could not open AF_INET6 container: %s", strerror(-r));
1110 ipv6ll_mode = link_ipv6ll_enabled(link) ? IN6_ADDR_GEN_MODE_EUI64 : IN6_ADDR_GEN_MODE_NONE;
1111 r = sd_rtnl_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, ipv6ll_mode);
1113 log_link_error(link, "Could not append IFLA_INET6_ADDR_GEN_MODE: %s", strerror(-r));
1117 if (!in_addr_is_null(AF_INET6, &link->network->ipv6_token)) {
1118 r = sd_rtnl_message_append_in6_addr(req, IFLA_INET6_TOKEN, &link->network->ipv6_token.in6);
1120 log_link_error(link, "Could not append IFLA_INET6_TOKEN: %s", strerror(-r));
1125 r = sd_rtnl_message_close_container(req);
1127 log_link_error(link, "Could not close AF_INET6 container: %s", strerror(-r));
1131 r = sd_rtnl_message_close_container(req);
1133 log_link_error(link, "Could not close IFLA_AF_SPEC container: %s", strerror(-r));
1137 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1140 log_link_error(link,
1141 "Could not send rtnetlink message: %s",
1151 static int link_joined(Link *link) {
1155 assert(link->network);
1157 if (!(link->flags & IFF_UP)) {
1160 link_enter_failed(link);
1165 if(link->network->bridge) {
1166 r = link_set_bridge(link);
1168 log_link_error(link,
1169 "Could not set bridge message: %s",
1174 return link_enter_set_addresses(link);
1177 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1179 _cleanup_link_unref_ Link *link = userdata;
1183 assert(link->network);
1187 if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1190 r = sd_rtnl_message_get_errno(m);
1191 if (r < 0 && r != -EEXIST) {
1192 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1193 link_enter_failed(link);
1196 log_link_debug(link, "joined netdev");
1198 if (link->enslaving <= 0)
1204 static int link_enter_join_netdev(Link *link) {
1210 assert(link->network);
1211 assert(link->state == LINK_STATE_PENDING);
1213 link_set_state(link, LINK_STATE_ENSLAVING);
1217 if (!link->network->bridge &&
1218 !link->network->bond &&
1219 hashmap_isempty(link->network->stacked_netdevs))
1220 return link_joined(link);
1222 if (link->network->bond) {
1223 log_link_struct(link, LOG_DEBUG,
1224 "MESSAGE=%-*s: enslaving by '%s'",
1226 link->ifname, link->network->bond->ifname,
1227 NETDEVIF(link->network->bond),
1230 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1232 log_link_struct(link, LOG_WARNING,
1233 "MESSAGE=%-*s: could not join netdev '%s': %s",
1235 link->ifname, link->network->bond->ifname,
1237 NETDEVIF(link->network->bond),
1239 link_enter_failed(link);
1246 if (link->network->bridge) {
1247 log_link_struct(link, LOG_DEBUG,
1248 "MESSAGE=%-*s: enslaving by '%s'",
1250 link->ifname, link->network->bridge->ifname,
1251 NETDEVIF(link->network->bridge),
1254 r = netdev_join(link->network->bridge, link,
1255 &netdev_join_handler);
1257 log_link_struct(link, LOG_WARNING,
1258 "MESSAGE=%-*s: could not join netdev '%s': %s",
1260 link->ifname, link->network->bridge->ifname,
1262 NETDEVIF(link->network->bridge),
1264 link_enter_failed(link);
1271 HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1272 log_link_struct(link, LOG_DEBUG,
1273 "MESSAGE=%-*s: enslaving by '%s'",
1275 link->ifname, netdev->ifname, NETDEVIF(netdev),
1278 r = netdev_join(netdev, link, &netdev_join_handler);
1280 log_link_struct(link, LOG_WARNING,
1281 "MESSAGE=%-*s: could not join netdev '%s': %s",
1283 link->ifname, netdev->ifname,
1285 NETDEVIF(netdev), NULL);
1286 link_enter_failed(link);
1296 static int link_set_ipv4_forward(Link *link) {
1297 const char *p = NULL;
1301 b = link_ipv4_forward_enabled(link);
1303 p = strjoina("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
1304 r = write_string_file_no_create(p, one_zero(b));
1306 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
1309 _cleanup_free_ char *buf = NULL;
1311 /* If IP forwarding is turned on for this interface,
1312 * then propagate this to the global setting. Given
1313 * that turning this on has side-effects on other
1314 * fields, we'll try to avoid doing this unless
1315 * necessary, hence check the previous value
1316 * first. Note that we never turn this option off
1317 * again, since all interfaces we manage do not do
1318 * forwarding anyway by default, and ownership rules
1319 * of this control are so unclear. */
1321 r = read_one_line_file("/proc/sys/net/ipv4/ip_forward", &buf);
1323 log_link_warning_errno(link, r, "Cannot read /proc/sys/net/ipv4/ip_forward: %m");
1324 else if (!streq(buf, "1")) {
1325 r = write_string_file_no_create("/proc/sys/net/ipv4/ip_forward", "1");
1327 log_link_warning_errno(link, r, "Cannot write /proc/sys/net/ipv4/ip_forward: %m");
1334 static int link_set_ipv6_forward(Link *link) {
1335 const char *p = NULL;
1338 p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
1339 r = write_string_file_no_create(p, one_zero(link_ipv6_forward_enabled(link)));
1341 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
1346 static int link_configure(Link *link) {
1350 assert(link->network);
1351 assert(link->state == LINK_STATE_PENDING);
1353 r = link_set_bridge_fdb(link);
1357 r = link_set_ipv4_forward(link);
1361 r = link_set_ipv6_forward(link);
1365 if (link_ipv4ll_enabled(link)) {
1366 r = ipv4ll_configure(link);
1371 if (link_dhcp4_enabled(link)) {
1372 r = dhcp4_configure(link);
1377 if (link_dhcp4_server_enabled(link)) {
1378 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1382 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1387 if (link_dhcp6_enabled(link)) {
1388 r = icmp6_configure(link);
1393 if (link_lldp_enabled(link)) {
1394 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1398 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1402 r = sd_lldp_set_callback(link->lldp,
1403 lldp_handler, link);
1408 if (link_has_carrier(link)) {
1409 r = link_acquire_conf(link);
1414 return link_enter_join_netdev(link);
1417 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1419 _cleanup_link_unref_ Link *link = userdata;
1424 assert(link->ifname);
1425 assert(link->manager);
1427 if (link->state != LINK_STATE_PENDING)
1430 log_link_debug(link, "link state is up-to-date");
1432 r = network_get(link->manager, link->udev_device, link->ifname,
1433 &link->mac, &network);
1435 link_enter_unmanaged(link);
1440 if (link->flags & IFF_LOOPBACK) {
1441 if (network->link_local != ADDRESS_FAMILY_NO)
1442 log_link_debug(link, "ignoring link-local autoconfiguration for loopback link");
1444 if (network->dhcp != ADDRESS_FAMILY_NO)
1445 log_link_debug(link, "ignoring DHCP clients for loopback link");
1447 if (network->dhcp_server)
1448 log_link_debug(link, "ignoring DHCP server for loopback link");
1451 r = network_apply(link->manager, network, link);
1455 r = link_configure(link);
1462 int link_initialized(Link *link, struct udev_device *device) {
1463 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1467 assert(link->manager);
1468 assert(link->manager->rtnl);
1471 if (link->state != LINK_STATE_PENDING)
1474 if (link->udev_device)
1477 log_link_debug(link, "udev initialized link");
1479 link->udev_device = udev_device_ref(device);
1481 /* udev has initialized the link, but we don't know if we have yet
1482 * processed the NEWLINK messages with the latest state. Do a GETLINK,
1483 * when it returns we know that the pending NEWLINKs have already been
1484 * processed and that we are up-to-date */
1486 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1491 r = sd_rtnl_call_async(link->manager->rtnl, req,
1492 link_initialized_and_synced, link, 0, NULL);
1501 static Address* link_get_equal_address(Link *link, Address *needle) {
1507 LIST_FOREACH(addresses, i, link->addresses)
1508 if (address_equal(i, needle))
1514 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1515 Manager *m = userdata;
1518 _cleanup_address_free_ Address *address = NULL;
1520 char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
1521 const char *valid_str = NULL;
1528 if (sd_rtnl_message_is_error(message)) {
1529 r = sd_rtnl_message_get_errno(message);
1531 log_warning_errno(r, "rtnl: failed to receive address: %m");
1536 r = sd_rtnl_message_get_type(message, &type);
1538 log_warning("rtnl: could not get message type");
1542 r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1544 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1546 } else if (ifindex <= 0) {
1547 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1550 r = link_get(m, ifindex, &link);
1551 if (r < 0 || !link) {
1552 /* when enumerating we might be out of sync, but we will
1553 * get the address again, so just ignore it */
1554 if (!m->enumerating)
1555 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1560 r = address_new_dynamic(&address);
1564 r = sd_rtnl_message_addr_get_family(message, &address->family);
1565 if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1566 log_link_warning(link, "rtnl: received address with invalid family, ignoring");
1570 r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1572 log_link_warning(link, "rtnl: received address with invalid prefixlen, ignoring");
1576 r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1578 log_link_warning(link, "rtnl: received address with invalid scope, ignoring");
1582 r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1584 log_link_warning(link, "rtnl: received address with invalid flags, ignoring");
1588 switch (address->family) {
1590 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1592 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1599 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1601 log_link_warning(link, "rtnl: received address without valid address, ignoring");
1608 assert_not_reached("invalid address family");
1611 if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1612 log_link_warning(link, "could not print address");
1616 r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1618 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1621 valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1622 address->cinfo.ifa_valid * USEC_PER_SEC,
1626 existing = link_get_equal_address(link, address);
1631 log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1634 existing->scope = address->scope;
1635 existing->flags = address->flags;
1636 existing->cinfo = address->cinfo;
1639 log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1641 LIST_PREPEND(addresses, link->addresses, address);
1642 address_establish(address, link);
1654 log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1655 address_release(existing, link);
1656 LIST_REMOVE(addresses, link->addresses, existing);
1657 address_free(existing);
1659 log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1663 assert_not_reached("Received invalid RTNL message type");
1669 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1671 _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1672 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1680 r = link_new(m, message, ret);
1686 log_link_debug(link, "link %d added", link->ifindex);
1688 if (detect_container(NULL) <= 0) {
1689 /* not in a container, udev will be around */
1690 sprintf(ifindex_str, "n%d", link->ifindex);
1691 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1693 log_link_warning(link,
1694 "could not find udev device: %m");
1698 if (udev_device_get_is_initialized(device) <= 0) {
1700 log_link_debug(link, "link pending udev initialization...");
1704 r = link_initialized(link, device);
1708 /* we are calling a callback directly, so must take a ref */
1711 r = link_initialized_and_synced(m->rtnl, NULL, link);
1719 static int link_carrier_gained(Link *link) {
1724 if (link->network) {
1725 r = link_acquire_conf(link);
1727 link_enter_failed(link);
1735 static int link_carrier_lost(Link *link) {
1740 r = link_stop_clients(link);
1742 link_enter_failed(link);
1749 int link_carrier_reset(Link *link) {
1754 if (link_has_carrier(link)) {
1755 r = link_carrier_lost(link);
1759 r = link_carrier_gained(link);
1763 log_link_info(link, "reset carrier");
1770 int link_update(Link *link, sd_rtnl_message *m) {
1771 struct ether_addr mac;
1774 bool had_carrier, carrier_gained, carrier_lost;
1778 assert(link->ifname);
1781 if (link->state == LINK_STATE_LINGER) {
1783 log_link_info(link, "link readded");
1784 link_set_state(link, LINK_STATE_ENSLAVING);
1787 r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1788 if (r >= 0 && !streq(ifname, link->ifname)) {
1789 log_link_info(link, "renamed to %s", ifname);
1792 link->ifname = strdup(ifname);
1797 r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1798 if (r >= 0 && mtu > 0) {
1800 if (!link->original_mtu) {
1801 link->original_mtu = mtu;
1802 log_link_debug(link, "saved original MTU: %"
1803 PRIu32, link->original_mtu);
1806 if (link->dhcp_client) {
1807 r = sd_dhcp_client_set_mtu(link->dhcp_client,
1810 log_link_warning(link,
1811 "Could not update MTU in DHCP client: %s",
1818 /* The kernel may broadcast NEWLINK messages without the MAC address
1819 set, simply ignore them. */
1820 r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1822 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1825 memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1828 log_link_debug(link, "MAC address: "
1829 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1830 mac.ether_addr_octet[0],
1831 mac.ether_addr_octet[1],
1832 mac.ether_addr_octet[2],
1833 mac.ether_addr_octet[3],
1834 mac.ether_addr_octet[4],
1835 mac.ether_addr_octet[5]);
1838 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1840 log_link_warning(link,
1841 "Could not update MAC address in IPv4LL client: %s",
1847 if (link->dhcp_client) {
1848 r = sd_dhcp_client_set_mac(link->dhcp_client,
1849 (const uint8_t *) &link->mac,
1853 log_link_warning(link,
1854 "Could not update MAC address in DHCP client: %s",
1860 if (link->dhcp6_client) {
1861 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1862 (const uint8_t *) &link->mac,
1866 log_link_warning(link,
1867 "Could not update MAC address in DHCPv6 client: %s",
1875 had_carrier = link_has_carrier(link);
1877 r = link_update_flags(link, m);
1881 carrier_gained = !had_carrier && link_has_carrier(link);
1882 carrier_lost = had_carrier && !link_has_carrier(link);
1884 if (carrier_gained) {
1885 log_link_info(link, "gained carrier");
1887 r = link_carrier_gained(link);
1890 } else if (carrier_lost) {
1891 log_link_info(link, "lost carrier");
1893 r = link_carrier_lost(link);
1902 static void link_update_operstate(Link *link) {
1903 LinkOperationalState operstate;
1906 if (link->kernel_operstate == IF_OPER_DORMANT)
1907 operstate = LINK_OPERSTATE_DORMANT;
1908 else if (link_has_carrier(link)) {
1910 uint8_t scope = RT_SCOPE_NOWHERE;
1912 /* if we have carrier, check what addresses we have */
1913 LIST_FOREACH(addresses, address, link->addresses) {
1914 if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1917 if (address->scope < scope)
1918 scope = address->scope;
1921 if (scope < RT_SCOPE_SITE)
1922 /* universally accessible addresses found */
1923 operstate = LINK_OPERSTATE_ROUTABLE;
1924 else if (scope < RT_SCOPE_HOST)
1925 /* only link or site local addresses found */
1926 operstate = LINK_OPERSTATE_DEGRADED;
1928 /* no useful addresses found */
1929 operstate = LINK_OPERSTATE_CARRIER;
1930 } else if (link->flags & IFF_UP)
1931 operstate = LINK_OPERSTATE_NO_CARRIER;
1933 operstate = LINK_OPERSTATE_OFF;
1935 if (link->operstate != operstate) {
1936 link->operstate = operstate;
1937 link_send_changed(link, "OperationalState", NULL);
1941 int link_save(Link *link) {
1942 _cleanup_free_ char *temp_path = NULL;
1943 _cleanup_fclose_ FILE *f = NULL;
1944 const char *admin_state, *oper_state;
1948 assert(link->state_file);
1949 assert(link->lease_file);
1950 assert(link->manager);
1952 link_update_operstate(link);
1954 r = manager_save(link->manager);
1958 if (link->state == LINK_STATE_LINGER) {
1959 unlink(link->state_file);
1963 admin_state = link_state_to_string(link->state);
1964 assert(admin_state);
1966 oper_state = link_operstate_to_string(link->operstate);
1969 r = fopen_temporary(link->state_file, &f, &temp_path);
1973 fchmod(fileno(f), 0644);
1976 "# This is private data. Do not parse.\n"
1979 admin_state, oper_state);
1981 if (link->network) {
1982 char **address, **domain;
1985 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1989 STRV_FOREACH(address, link->network->dns) {
1996 if (link->network->dhcp_dns &&
1998 const struct in_addr *addresses;
2000 r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2004 serialize_in_addrs(f, addresses, r);
2012 STRV_FOREACH(address, link->network->ntp) {
2019 if (link->network->dhcp_ntp &&
2021 const struct in_addr *addresses;
2023 r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2027 serialize_in_addrs(f, addresses, r);
2033 fprintf(f, "DOMAINS=");
2035 STRV_FOREACH(domain, link->network->domains) {
2042 if (link->network->dhcp_domains &&
2044 const char *domainname;
2046 r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
2050 fputs(domainname, f);
2056 fprintf(f, "WILDCARD_DOMAIN=%s\n",
2057 yes_no(link->network->wildcard_domain));
2059 fprintf(f, "LLMNR=%s\n",
2060 llmnr_support_to_string(link->network->llmnr));
2063 if (link->dhcp_lease) {
2064 assert(link->network);
2066 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
2074 unlink(link->lease_file);
2077 assert(link->network);
2079 r = sd_lldp_save(link->lldp, link->lldp_file);
2087 unlink(link->lldp_file);
2089 r = fflush_and_check(f);
2093 if (rename(temp_path, link->state_file) < 0) {
2100 log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2101 unlink(link->state_file);
2106 static const char* const link_state_table[_LINK_STATE_MAX] = {
2107 [LINK_STATE_PENDING] = "pending",
2108 [LINK_STATE_ENSLAVING] = "configuring",
2109 [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2110 [LINK_STATE_SETTING_ROUTES] = "configuring",
2111 [LINK_STATE_CONFIGURED] = "configured",
2112 [LINK_STATE_UNMANAGED] = "unmanaged",
2113 [LINK_STATE_FAILED] = "failed",
2114 [LINK_STATE_LINGER] = "linger",
2117 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2119 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2120 [LINK_OPERSTATE_OFF] = "off",
2121 [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2122 [LINK_OPERSTATE_DORMANT] = "dormant",
2123 [LINK_OPERSTATE_CARRIER] = "carrier",
2124 [LINK_OPERSTATE_DEGRADED] = "degraded",
2125 [LINK_OPERSTATE_ROUTABLE] = "routable",
2128 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);