1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Tom Gundersen <teg@jklm.no>
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <netinet/ether.h>
26 #include "libudev-private.h"
31 int link_new(Manager *manager, struct udev_device *device, Link **ret) {
32 _cleanup_link_free_ Link *link = NULL;
34 struct ether_addr *mac_addr;
45 link->manager = manager;
46 link->state = _LINK_STATE_INVALID;
48 link->ifindex = udev_device_get_ifindex(device);
49 if (link->ifindex <= 0)
52 mac = udev_device_get_sysattr_value(device, "address");
54 mac_addr = ether_aton(mac);
56 memcpy(&link->mac, mac_addr, sizeof(struct ether_addr));
59 ifname = udev_device_get_sysname(device);
60 link->ifname = strdup(ifname);
62 r = hashmap_put(manager->links, &link->ifindex, link);
72 void link_free(Link *link) {
76 assert(link->manager);
78 sd_dhcp_client_free(link->dhcp_client);
79 sd_dhcp_lease_unref(link->dhcp_lease);
81 hashmap_remove(link->manager->links, &link->ifindex);
88 int link_get(Manager *m, int ifindex, Link **ret) {
98 link = hashmap_get(m->links, &ifindex_64);
107 int link_add(Manager *m, struct udev_device *device, Link **ret) {
115 r = link_new(m, device, &link);
121 r = network_get(m, device, &network);
123 return r == -ENOENT ? 0 : r;
125 r = network_apply(m, network, link);
132 static int link_enter_configured(Link *link) {
134 assert(link->state == LINK_STATE_SETTING_ROUTES);
136 log_info_link(link, "link configured");
138 link->state = LINK_STATE_CONFIGURED;
143 static void link_enter_failed(Link *link) {
146 log_warning_link(link, "failed");
148 link->state = LINK_STATE_FAILED;
151 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
152 Link *link = userdata;
155 assert(link->route_messages > 0);
156 assert(link->state == LINK_STATE_SETTING_ADDRESSES ||
157 link->state == LINK_STATE_SETTING_ROUTES ||
158 link->state == LINK_STATE_FAILED);
160 link->route_messages --;
162 if (link->state == LINK_STATE_FAILED)
165 r = sd_rtnl_message_get_errno(m);
166 if (r < 0 && r != -EEXIST)
167 log_struct_link(LOG_WARNING, link,
168 "MESSAGE=%s: could not set route: %s",
169 link->ifname, strerror(-r),
173 /* we might have received an old reply after moving back to SETTING_ADDRESSES,
175 if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
176 log_debug_link(link, "routes set");
177 link_enter_configured(link);
183 static int link_enter_set_routes(Link *link) {
188 assert(link->network);
189 assert(link->state == LINK_STATE_SETTING_ADDRESSES);
191 link->state = LINK_STATE_SETTING_ROUTES;
193 if (!link->network->static_routes && !link->dhcp_lease)
194 return link_enter_configured(link);
196 log_debug_link(link, "setting routes");
198 LIST_FOREACH(static_routes, rt, link->network->static_routes) {
199 r = route_configure(rt, link, &route_handler);
201 log_warning_link(link,
202 "could not set routes: %s", strerror(-r));
203 link_enter_failed(link);
207 link->route_messages ++;
210 if (link->dhcp_lease) {
211 _cleanup_route_free_ Route *route = NULL;
212 struct in_addr gateway;
214 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
216 log_warning_link(link, "DHCP error: no router: %s",
221 r = route_new_dynamic(&route);
223 log_error_link(link, "Could not allocate route: %s",
228 route->family = AF_INET;
229 route->in_addr.in = gateway;
231 r = route_configure(route, link, &route_handler);
233 log_warning_link(link,
234 "could not set routes: %s", strerror(-r));
235 link_enter_failed(link);
239 link->route_messages ++;
245 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
246 Link *link = userdata;
251 assert(link->ifname);
252 assert(link->addr_messages > 0);
253 assert(link->state == LINK_STATE_SETTING_ADDRESSES || link->state == LINK_STATE_FAILED);
255 link->addr_messages --;
257 if (link->state == LINK_STATE_FAILED)
260 r = sd_rtnl_message_get_errno(m);
261 if (r < 0 && r != -EEXIST)
262 log_struct_link(LOG_WARNING, link,
263 "MESSAGE=%s: could not set address: %s",
264 link->ifname, strerror(-r),
268 if (link->addr_messages == 0) {
269 log_debug_link(link, "addresses set");
270 link_enter_set_routes(link);
276 static int link_enter_set_addresses(Link *link) {
281 assert(link->network);
282 assert(link->state != _LINK_STATE_INVALID);
284 link->state = LINK_STATE_SETTING_ADDRESSES;
286 if (!link->network->static_addresses && !link->dhcp_lease)
287 return link_enter_set_routes(link);
289 log_debug_link(link, "setting addresses");
291 LIST_FOREACH(static_addresses, ad, link->network->static_addresses) {
292 r = address_configure(ad, link, &address_handler);
294 log_warning_link(link,
295 "could not set addresses: %s", strerror(-r));
296 link_enter_failed(link);
300 link->addr_messages ++;
303 if (link->dhcp_lease) {
304 _cleanup_address_free_ Address *address = NULL;
306 struct in_addr netmask;
309 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
311 log_warning_link(link, "DHCP error: no address: %s",
316 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
318 log_warning_link(link, "DHCP error: no netmask: %s",
323 prefixlen = net_netmask_to_prefixlen(&netmask);
325 r = address_new_dynamic(&address);
327 log_error_link(link, "Could not allocate address: %s",
332 address->family = AF_INET;
333 address->in_addr.in = addr;
334 address->prefixlen = prefixlen;
335 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
337 r = address_configure(address, link, &address_handler);
339 log_warning_link(link,
340 "could not set addresses: %s", strerror(-r));
341 link_enter_failed(link);
345 link->addr_messages ++;
351 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
352 Link *link = userdata;
357 assert(link->ifname);
359 if (link->state == LINK_STATE_FAILED)
362 r = sd_rtnl_message_get_errno(m);
363 if (r < 0 && r != -ENOENT)
364 log_struct_link(LOG_WARNING, link,
365 "MESSAGE=%s: could not drop address: %s",
366 link->ifname, strerror(-r),
373 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
376 r = sd_bus_message_get_errno(m);
378 log_warning("Could not set hostname: %s", strerror(-r));
383 static int set_hostname(sd_bus *bus, const char *hostname) {
384 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
389 log_debug("Setting transient hostname: '%s'", hostname);
391 if (!bus) { /* TODO: replace by assert when we can rely on kdbus */
392 log_info("Not connected to system bus, ignoring transient hostname.");
396 r = sd_bus_message_new_method_call(
398 "org.freedesktop.hostname1",
399 "/org/freedesktop/hostname1",
400 "org.freedesktop.hostname1",
406 r = sd_bus_message_append(m, "sb", hostname, false);
410 r = sd_bus_call_async(bus, m, set_hostname_handler, NULL, 0, NULL);
412 log_error("Could not set transient hostname: %s", strerror(-r));
417 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
418 Link *link = userdata;
423 assert(link->ifname);
425 if (link->state == LINK_STATE_FAILED)
428 r = sd_rtnl_message_get_errno(m);
430 log_struct_link(LOG_WARNING, link,
431 "MESSAGE=%s: could not set MTU: %s",
432 link->ifname, strerror(-r),
439 static int link_set_mtu(Link *link, uint32_t mtu) {
440 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
444 assert(link->manager);
445 assert(link->manager->rtnl);
447 log_debug_link(link, "setting MTU: %" PRIu32, mtu);
449 r = sd_rtnl_message_new_link(link->manager->rtnl, RTM_SETLINK,
450 link->ifindex, &req);
452 log_error_link(link, "Could not allocate RTM_SETLINK message");
456 r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
458 log_error_link(link, "Could not append MTU: %s", strerror(-r));
462 r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
465 "Could not send rtnetlink message: %s", strerror(-r));
472 static int dhcp_lease_lost(Link *link) {
473 _cleanup_address_free_ Address *address = NULL;
475 struct in_addr netmask;
480 assert(link->dhcp_lease);
482 r = address_new_dynamic(&address);
484 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
485 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
486 prefixlen = net_netmask_to_prefixlen(&netmask);
488 address->family = AF_INET;
489 address->in_addr.in = addr;
490 address->prefixlen = prefixlen;
492 address_drop(address, link, address_drop_handler);
495 if (link->network->dhcp_mtu) {
498 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
499 if (r >= 0 && link->original_mtu != mtu) {
500 r = link_set_mtu(link, link->original_mtu);
502 log_warning_link(link, "DHCP error: could not reset MTU");
503 link_enter_failed(link);
509 if (link->network->dhcp_hostname) {
510 r = set_hostname(link->manager->bus, "");
512 log_error("Failed to reset transient hostname");
515 link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
520 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
521 sd_dhcp_lease *lease;
522 struct in_addr address;
523 struct in_addr netmask;
524 struct in_addr gateway;
526 struct in_addr *nameservers;
527 size_t nameservers_size;
533 r = sd_dhcp_client_get_lease(client, &lease);
535 log_warning_link(link, "DHCP error: no lease: %s",
540 r = sd_dhcp_lease_get_address(lease, &address);
542 log_warning_link(link, "DHCP error: no address: %s",
547 r = sd_dhcp_lease_get_netmask(lease, &netmask);
549 log_warning_link(link, "DHCP error: no netmask: %s",
554 prefixlen = net_netmask_to_prefixlen(&netmask);
556 r = sd_dhcp_lease_get_router(lease, &gateway);
558 log_warning_link(link, "DHCP error: no router: %s",
563 log_struct_link(LOG_INFO, link,
564 "MESSAGE=%s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
566 ADDRESS_FMT_VAL(address),
568 ADDRESS_FMT_VAL(gateway),
569 "ADDRESS=%u.%u.%u.%u",
570 ADDRESS_FMT_VAL(address),
573 "GATEWAY=%u.%u.%u.%u",
574 ADDRESS_FMT_VAL(gateway),
577 link->dhcp_lease = lease;
579 if (link->network->dhcp_dns) {
580 r = sd_dhcp_lease_get_dns(lease, &nameservers, &nameservers_size);
582 r = manager_update_resolv_conf(link->manager);
584 log_error("Failed to update resolv.conf");
588 if (link->network->dhcp_mtu) {
591 r = sd_dhcp_lease_get_mtu(lease, &mtu);
593 r = link_set_mtu(link, mtu);
595 log_error_link(link, "Failed to set MTU "
600 if (link->network->dhcp_hostname) {
601 const char *hostname;
603 r = sd_dhcp_lease_get_hostname(lease, &hostname);
605 r = set_hostname(link->manager->bus, hostname);
607 log_error("Failed to set transient hostname "
608 "to '%s'", hostname);
612 link_enter_set_addresses(link);
617 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
618 Link *link = userdata;
622 assert(link->network);
623 assert(link->manager);
625 if (link->state == LINK_STATE_FAILED)
629 case DHCP_EVENT_NO_LEASE:
630 log_debug_link(link, "IP address in use.");
632 case DHCP_EVENT_EXPIRED:
633 case DHCP_EVENT_STOP:
634 case DHCP_EVENT_IP_CHANGE:
635 if (link->network->dhcp_critical) {
636 log_error_link(link, "DHCPv4 connection considered system critical, "
637 "ignoring request to reconfigure it.");
641 if (link->dhcp_lease) {
642 r = dhcp_lease_lost(link);
644 link_enter_failed(link);
649 if (event == DHCP_EVENT_IP_CHANGE) {
650 r = dhcp_lease_acquired(client, link);
652 link_enter_failed(link);
658 case DHCP_EVENT_IP_ACQUIRE:
659 r = dhcp_lease_acquired(client, link);
661 link_enter_failed(link);
667 log_warning_link(link, "DHCP error: %s", strerror(-event));
669 log_warning_link(link, "DHCP unknown event: %d", event);
676 static int link_acquire_conf(Link *link) {
680 assert(link->network);
681 assert(link->network->dhcp);
682 assert(link->manager);
683 assert(link->manager->event);
685 if (!link->dhcp_client) {
686 r = sd_dhcp_client_new(&link->dhcp_client);
690 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
694 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
698 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
702 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
706 if (link->network->dhcp_mtu) {
707 r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
713 log_debug_link(link, "acquiring DHCPv4 lease");
715 r = sd_dhcp_client_start(link->dhcp_client);
722 static int link_update_flags(Link *link, unsigned flags) {
726 assert(link->network);
728 if (link->state == LINK_STATE_FAILED)
731 if (link->flags == flags) {
732 log_debug_link(link, "link status unchanged: %#.8x", flags);
736 if ((link->flags & IFF_UP) != (flags & IFF_UP))
738 "link is %s", flags & IFF_UP ? "up": "down");
740 if ((link->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
741 if (flags & IFF_LOWER_UP) {
742 log_info_link(link, "carrier on");
744 if (link->network->dhcp) {
745 r = link_acquire_conf(link);
747 log_warning_link(link, "Could not acquire DHCPv4 lease: %s", strerror(-r));
748 link_enter_failed(link);
753 log_info_link(link, "carrier off");
755 if (link->network->dhcp) {
756 r = sd_dhcp_client_stop(link->dhcp_client);
758 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
759 link_enter_failed(link);
767 "link status updated: %#.8x -> %#.8x", link->flags, flags);
774 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
775 Link *link = userdata;
780 if (link->state == LINK_STATE_FAILED)
783 r = sd_rtnl_message_get_errno(m);
785 log_struct_link(LOG_ERR, link,
786 "MESSAGE=%s: could not bring up interface: %s",
787 link->ifname, strerror(-r),
790 link_enter_failed(link);
794 link_update_flags(link, link->flags | IFF_UP);
799 static int link_up(Link *link) {
800 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
804 assert(link->manager);
805 assert(link->manager->rtnl);
807 log_debug_link(link, "bringing link up");
809 r = sd_rtnl_message_new_link(link->manager->rtnl, RTM_SETLINK,
810 link->ifindex, &req);
812 log_error_link(link, "Could not allocate RTM_SETLINK message");
816 r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
818 log_error_link(link, "Could not set link flags: %s", strerror(-r));
822 r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
825 "Could not send rtnetlink message: %s", strerror(-r));
832 static int link_enslaved(Link *link) {
836 assert(link->state == LINK_STATE_ENSLAVING);
837 assert(link->network);
841 link_enter_failed(link);
845 if (!link->network->dhcp)
846 return link_enter_set_addresses(link);
851 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
852 Link *link = userdata;
856 assert(link->state == LINK_STATE_ENSLAVING || link->state == LINK_STATE_FAILED);
857 assert(link->network);
861 if (link->state == LINK_STATE_FAILED)
864 r = sd_rtnl_message_get_errno(m);
866 log_struct_link(LOG_ERR, link,
867 "MESSAGE=%s: could not enslave: %s",
868 link->ifname, strerror(-r),
871 link_enter_failed(link);
875 log_debug_link(link, "enslaved");
877 if (link->enslaving == 0)
883 static int link_enter_enslave(Link *link) {
889 assert(link->network);
890 assert(link->state == _LINK_STATE_INVALID);
892 link->state = LINK_STATE_ENSLAVING;
894 if (!link->network->bridge && !link->network->bond &&
895 hashmap_isempty(link->network->vlans))
896 return link_enslaved(link);
898 if (link->network->bridge) {
899 log_struct_link(LOG_DEBUG, link,
900 "MESSAGE=%s: enslaving by '%s'",
901 link->ifname, link->network->bridge->name,
902 NETDEV(link->network->bridge),
905 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
907 log_struct_link(LOG_WARNING, link,
908 "MESSAGE=%s: could not enslave by '%s': %s",
909 link->ifname, link->network->bridge->name, strerror(-r),
910 NETDEV(link->network->bridge),
912 link_enter_failed(link);
919 HASHMAP_FOREACH(vlan, link->network->vlans, i) {
920 log_struct_link(LOG_DEBUG, link,
921 "MESSAGE=%s: enslaving by '%s'",
922 link->ifname, vlan->name, NETDEV(vlan), NULL);
924 r = netdev_enslave(vlan, link, &enslave_handler);
926 log_struct_link(LOG_WARNING, link,
927 "MESSAGE=%s: could not enslave by '%s': %s",
928 link->ifname, vlan->name, strerror(-r),
930 link_enter_failed(link);
940 static int link_getlink_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
942 Link *link = userdata;
947 if (link->state == LINK_STATE_FAILED)
950 r = sd_rtnl_message_get_errno(m);
952 log_struct_link(LOG_ERR, link,
953 "MESSAGE=%s: could not get state: %s",
954 link->ifname, strerror(-r),
957 link_enter_failed(link);
961 log_debug_link(link, "got link state");
963 link_update(link, m);
968 static int link_getlink(Link *link) {
969 _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
973 assert(link->manager);
974 assert(link->manager->rtnl);
976 log_debug_link(link, "requesting link status");
978 r = sd_rtnl_message_new_link(link->manager->rtnl, RTM_GETLINK,
979 link->ifindex, &req);
981 log_error_link(link, "Could not allocate RTM_GETLINK message");
985 r = sd_rtnl_call_async(link->manager->rtnl, req, link_getlink_handler,
989 "Could not send rtnetlink message: %s", strerror(-r));
996 int link_configure(Link *link) {
1000 assert(link->network);
1001 assert(link->state == _LINK_STATE_INVALID);
1003 r = link_getlink(link);
1005 link_enter_failed(link);
1009 return link_enter_enslave(link);
1012 int link_update(Link *link, sd_rtnl_message *m) {
1021 if (link->state == LINK_STATE_FAILED)
1024 r = sd_rtnl_message_link_get_flags(m, &flags);
1026 log_warning_link(link, "Could not get link flags");
1030 while (sd_rtnl_message_read(m, &type, &data) > 0) {
1031 if (type == IFLA_MTU && link->network->dhcp &&
1032 link->network->dhcp_mtu && !link->original_mtu) {
1033 link->original_mtu = *(uint16_t *) data;
1034 log_debug_link(link, "saved original MTU: %" PRIu16,
1035 link->original_mtu);
1039 return link_update_flags(link, flags);