chiark / gitweb /
networkd: link - split out dhcp4 handling
authorTom Gundersen <teg@jklm.no>
Fri, 8 Aug 2014 10:12:17 +0000 (12:12 +0200)
committerTom Gundersen <teg@jklm.no>
Tue, 12 Aug 2014 18:42:59 +0000 (20:42 +0200)
Makefile.am
src/network/networkd-dhcp4.c [new file with mode: 0644]
src/network/networkd-link.c
src/network/networkd-link.h
src/udev/net/link-config.c

index e65406f..fa6fd7d 100644 (file)
@@ -4942,7 +4942,6 @@ libsystemd_networkd_core_la_SOURCES = \
        src/libsystemd-network/network-internal.h \
        src/network/networkd.h \
        src/network/networkd-link.h \
-       src/network/networkd-ipv4ll.h \
        src/network/networkd-netdev.h \
        src/network/networkd-netdev-tunnel.h \
        src/network/networkd-netdev-veth.h \
@@ -4965,6 +4964,7 @@ libsystemd_networkd_core_la_SOURCES = \
        src/network/networkd-netdev-bridge.c \
        src/network/networkd-link.c \
        src/network/networkd-ipv4ll.c \
+       src/network/networkd-dhcp4.c \
        src/network/networkd-network.c \
        src/network/networkd-address.c \
        src/network/networkd-route.c \
diff --git a/src/network/networkd-dhcp4.c b/src/network/networkd-dhcp4.c
new file mode 100644 (file)
index 0000000..499e813
--- /dev/null
@@ -0,0 +1,652 @@
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
+
+/***
+  This file is part of systemd.
+
+  Copyright 2013-2014 Tom Gundersen <teg@jklm.no>
+
+  systemd is free software; you can redistribute it and/or modify it
+  under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  systemd is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
+
+#include <netinet/ether.h>
+#include <linux/if.h>
+
+#include "networkd-link.h"
+#include "network-internal.h"
+#include "dhcp-lease-internal.h"
+
+static int dhcp4_route_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
+                               void *userdata) {
+        _cleanup_link_unref_ Link *link = userdata;
+        int r;
+
+        assert(link);
+        assert(link->dhcp4_messages);
+
+        link->dhcp4_messages --;
+
+        r = sd_rtnl_message_get_errno(m);
+        if (r < 0 && r != -EEXIST) {
+                log_error_link(link, "could not set DHCPv4 route: %s",
+                               strerror(-r));
+                link_enter_failed(link);
+        }
+
+        if (!link->dhcp4_messages) {
+                link->dhcp4_configured = true;
+                link_client_handler(link);
+        }
+
+        return 1;
+}
+
+static int link_set_dhcp_routes(Link *link) {
+        struct in_addr gateway;
+        struct sd_dhcp_route *static_routes;
+        int r, n, i;
+
+        assert(link);
+        assert(link->dhcp_lease);
+
+        r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
+        if (r < 0 && r != -ENOENT) {
+                log_warning_link(link,
+                                 "DHCP error: could not get gateway: %s",
+                                 strerror(-r));
+                return r;
+        }
+        if (r >= 0) {
+                _cleanup_route_free_ Route *route = NULL;
+                _cleanup_route_free_ Route *route_gw = NULL;
+
+                r = route_new_dynamic(&route, RTPROT_DHCP);
+                if (r < 0) {
+                        log_error_link(link,
+                                       "Could not allocate route: %s",
+                                       strerror(-r));
+                        return r;
+                }
+
+                r = route_new_dynamic(&route_gw, RTPROT_DHCP);
+                if (r < 0) {
+                log_error_link(link,
+                               "Could not allocate route: %s",
+                               strerror(-r));
+                               return r;
+                }
+
+                /* The dhcp netmask may mask out the gateway. Add an explicit
+                 * route for the gw host so that we can route no matter the
+                 * netmask or existing kernel route tables. */
+                route_gw->family = AF_INET;
+                route_gw->dst_addr.in = gateway;
+                route_gw->dst_prefixlen = 32;
+                route_gw->scope = RT_SCOPE_LINK;
+                route_gw->metrics = DHCP_ROUTE_METRIC;
+
+                r = route_configure(route_gw, link, &dhcp4_route_handler);
+                if (r < 0) {
+                        log_warning_link(link,
+                                         "could not set host route: %s",
+                                         strerror(-r));
+                        return r;
+                }
+
+                link->dhcp4_messages ++;
+
+                route->family = AF_INET;
+                route->in_addr.in = gateway;
+                route->metrics = DHCP_ROUTE_METRIC;
+
+                r = route_configure(route, link, &dhcp4_route_handler);
+                if (r < 0) {
+                        log_warning_link(link,
+                                         "could not set routes: %s",
+                                         strerror(-r));
+                        link_enter_failed(link);
+                        return r;
+                }
+
+                link->dhcp4_messages ++;
+        }
+
+        n = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes);
+        if (n == -ENOENT)
+                return 0;
+        if (n < 0) {
+                log_warning_link(link,
+                                 "DHCP error: could not get routes: %s",
+                                 strerror(-n));
+
+                return n;
+        }
+
+        for (i = 0; i < n; i++) {
+                _cleanup_route_free_ Route *route = NULL;
+
+                r = route_new_dynamic(&route, RTPROT_DHCP);
+                if (r < 0) {
+                        log_error_link(link, "Could not allocate route: %s",
+                                       strerror(-r));
+                        return r;
+                }
+
+                route->family = AF_INET;
+                route->in_addr.in = static_routes[i].gw_addr;
+                route->dst_addr.in = static_routes[i].dst_addr;
+                route->dst_prefixlen = static_routes[i].dst_prefixlen;
+                route->metrics = DHCP_ROUTE_METRIC;
+
+                r = route_configure(route, link, &dhcp4_route_handler);
+                if (r < 0) {
+                        log_warning_link(link,
+                                         "could not set host route: %s",
+                                         strerror(-r));
+                        return r;
+                }
+
+                link->dhcp4_messages ++;
+        }
+
+        return 0;
+}
+
+static int dhcp_lease_lost(Link *link) {
+        _cleanup_address_free_ Address *address = NULL;
+        struct in_addr addr;
+        struct in_addr netmask;
+        struct in_addr gateway;
+        unsigned prefixlen;
+        int r;
+
+        assert(link);
+        assert(link->dhcp_lease);
+
+        log_warning_link(link, "DHCP lease lost");
+
+        if (link->network->dhcp_routes) {
+                struct sd_dhcp_route *routes;
+                int n, i;
+
+                n = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes);
+                if (n >= 0) {
+                        for (i = 0; i < n; i++) {
+                                _cleanup_route_free_ Route *route = NULL;
+
+                                r = route_new_dynamic(&route, RTPROT_UNSPEC);
+                                if (r >= 0) {
+                                        route->family = AF_INET;
+                                        route->in_addr.in = routes[i].gw_addr;
+                                        route->dst_addr.in = routes[i].dst_addr;
+                                        route->dst_prefixlen = routes[i].dst_prefixlen;
+
+                                        route_drop(route, link,
+                                                   &link_route_drop_handler);
+                                }
+                        }
+                }
+        }
+
+        r = address_new_dynamic(&address);
+        if (r >= 0) {
+                r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
+                if (r >= 0) {
+                        _cleanup_route_free_ Route *route_gw = NULL;
+                        _cleanup_route_free_ Route *route = NULL;
+
+                        r = route_new_dynamic(&route_gw, RTPROT_UNSPEC);
+                        if (r >= 0) {
+                                route_gw->family = AF_INET;
+                                route_gw->dst_addr.in = gateway;
+                                route_gw->dst_prefixlen = 32;
+                                route_gw->scope = RT_SCOPE_LINK;
+
+                                route_drop(route_gw, link,
+                                           &link_route_drop_handler);
+                        }
+
+                        r = route_new_dynamic(&route, RTPROT_UNSPEC);
+                        if (r >= 0) {
+                                route->family = AF_INET;
+                                route->in_addr.in = gateway;
+
+                                route_drop(route, link,
+                                           &link_route_drop_handler);
+                        }
+                }
+
+                sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
+                sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
+                prefixlen = in_addr_netmask_to_prefixlen(&netmask);
+
+                address->family = AF_INET;
+                address->in_addr.in = addr;
+                address->prefixlen = prefixlen;
+
+                address_drop(address, link, &link_address_drop_handler);
+        }
+
+        if (link->network->dhcp_mtu) {
+                uint16_t mtu;
+
+                r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
+                if (r >= 0 && link->original_mtu != mtu) {
+                        r = link_set_mtu(link, link->original_mtu);
+                        if (r < 0) {
+                                log_warning_link(link,
+                                                 "DHCP error: could not reset MTU");
+                                link_enter_failed(link);
+                                return r;
+                        }
+                }
+        }
+
+        if (link->network->dhcp_hostname) {
+                const char *hostname = NULL;
+
+                r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
+                if (r >= 0 && hostname) {
+                        r = link_set_hostname(link, "");
+                        if (r < 0)
+                                log_error_link(link,
+                                               "Failed to reset transient hostname");
+                }
+        }
+
+        link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
+        link->dhcp4_configured = false;
+
+        return 0;
+}
+
+static int dhcp4_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
+                                 void *userdata) {
+        _cleanup_link_unref_ Link *link = userdata;
+        int r;
+
+        assert(link);
+
+        r = sd_rtnl_message_get_errno(m);
+        if (r < 0 && r != -EEXIST) {
+                log_error_link(link, "could not set DHCPv4 address: %s",
+                               strerror(-r));
+                link_enter_failed(link);
+        } else if (r >= 0) {
+                /* calling handler directly so take a ref */
+                link_ref(link);
+                link_get_address_handler(rtnl, m, link);
+        }
+
+        link_set_dhcp_routes(link);
+
+        return 1;
+}
+
+static int dhcp4_update_address(Link *link,
+                                struct in_addr *address,
+                                struct in_addr *netmask,
+                                uint32_t lifetime) {
+        _cleanup_address_free_ Address *addr = NULL;
+        unsigned prefixlen;
+        int r;
+
+        assert(address);
+        assert(netmask);
+        assert(lifetime);
+
+        prefixlen = in_addr_netmask_to_prefixlen(netmask);
+
+        r = address_new_dynamic(&addr);
+        if (r < 0)
+                return r;
+
+        addr->family = AF_INET;
+        addr->in_addr.in.s_addr = address->s_addr;
+        addr->cinfo.ifa_prefered = lifetime;
+        addr->cinfo.ifa_valid = lifetime;
+        addr->prefixlen = prefixlen;
+        addr->broadcast.s_addr = address->s_addr | ~netmask->s_addr;
+
+        /* use update rather than configure so that we will update the
+         * lifetime of an existing address if it has already been configured */
+        r = address_update(addr, link, &dhcp4_address_handler);
+        if (r < 0)
+                return r;
+
+        return 0;
+}
+
+static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
+        sd_dhcp_lease *lease;
+        struct in_addr address;
+        struct in_addr netmask;
+        uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
+        int r;
+
+        assert(link);
+        assert(client);
+        assert(link->network);
+
+        r = sd_dhcp_client_get_lease(client, &lease);
+        if (r < 0) {
+                log_warning_link(link, "DHCP error: no lease %s",
+                                 strerror(-r));
+                return r;
+        }
+
+        sd_dhcp_lease_unref(link->dhcp_lease);
+        link->dhcp4_configured = false;
+        link->dhcp_lease = lease;
+
+        r = sd_dhcp_lease_get_address(lease, &address);
+        if (r < 0) {
+                log_warning_link(link, "DHCP error: no address: %s",
+                                 strerror(-r));
+                return r;
+        }
+
+        r = sd_dhcp_lease_get_netmask(lease, &netmask);
+        if (r < 0) {
+                log_warning_link(link, "DHCP error: no netmask: %s",
+                                 strerror(-r));
+                return r;
+        }
+
+        if (!link->network->dhcp_critical) {
+                r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
+                                               &lifetime);
+                if (r < 0) {
+                        log_warning_link(link,
+                                         "DHCP error: no lifetime: %s",
+                                         strerror(-r));
+                        return r;
+                }
+        }
+
+        r = dhcp4_update_address(link, &address, &netmask, lifetime);
+        if (r < 0) {
+                log_warning_link(link, "could not update IP address: %s",
+                                 strerror(-r));
+                link_enter_failed(link);
+                return r;
+        }
+
+        return 0;
+}
+
+static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
+        sd_dhcp_lease *lease;
+        struct in_addr address;
+        struct in_addr netmask;
+        struct in_addr gateway;
+        unsigned prefixlen;
+        uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
+        int r;
+
+        assert(client);
+        assert(link);
+
+        r = sd_dhcp_client_get_lease(client, &lease);
+        if (r < 0) {
+                log_warning_link(link, "DHCP error: no lease: %s",
+                                 strerror(-r));
+                return r;
+        }
+
+        r = sd_dhcp_lease_get_address(lease, &address);
+        if (r < 0) {
+                log_warning_link(link, "DHCP error: no address: %s",
+                                 strerror(-r));
+                return r;
+        }
+
+        r = sd_dhcp_lease_get_netmask(lease, &netmask);
+        if (r < 0) {
+                log_warning_link(link, "DHCP error: no netmask: %s",
+                                 strerror(-r));
+                return r;
+        }
+
+        prefixlen = in_addr_netmask_to_prefixlen(&netmask);
+
+        r = sd_dhcp_lease_get_router(lease, &gateway);
+        if (r < 0 && r != -ENOENT) {
+                log_warning_link(link, "DHCP error: could not get gateway: %s",
+                                 strerror(-r));
+                return r;
+        }
+
+        if (r >= 0)
+                log_struct_link(LOG_INFO, link,
+                                "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
+                                 IFNAMSIZ,
+                                 link->ifname,
+                                 ADDRESS_FMT_VAL(address),
+                                 prefixlen,
+                                 ADDRESS_FMT_VAL(gateway),
+                                 "ADDRESS=%u.%u.%u.%u",
+                                 ADDRESS_FMT_VAL(address),
+                                 "PREFIXLEN=%u",
+                                 prefixlen,
+                                 "GATEWAY=%u.%u.%u.%u",
+                                 ADDRESS_FMT_VAL(gateway),
+                                 NULL);
+        else
+                log_struct_link(LOG_INFO, link,
+                                "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
+                                 IFNAMSIZ,
+                                 link->ifname,
+                                 ADDRESS_FMT_VAL(address),
+                                 prefixlen,
+                                 "ADDRESS=%u.%u.%u.%u",
+                                 ADDRESS_FMT_VAL(address),
+                                 "PREFIXLEN=%u",
+                                 prefixlen,
+                                 NULL);
+
+        link->dhcp_lease = lease;
+
+        if (link->network->dhcp_mtu) {
+                uint16_t mtu;
+
+                r = sd_dhcp_lease_get_mtu(lease, &mtu);
+                if (r >= 0) {
+                        r = link_set_mtu(link, mtu);
+                        if (r < 0)
+                                log_error_link(link, "Failed to set MTU "
+                                               "to %" PRIu16, mtu);
+                }
+        }
+
+        if (link->network->dhcp_hostname) {
+                const char *hostname;
+
+                r = sd_dhcp_lease_get_hostname(lease, &hostname);
+                if (r >= 0) {
+                        r = link_set_hostname(link, hostname);
+                        if (r < 0)
+                                log_error_link(link,
+                                               "Failed to set transient hostname to '%s'",
+                                               hostname);
+                }
+        }
+
+        if (!link->network->dhcp_critical) {
+                r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
+                                               &lifetime);
+                if (r < 0) {
+                        log_warning_link(link,
+                                         "DHCP error: no lifetime: %s",
+                                         strerror(-r));
+                        return r;
+                }
+        }
+
+        r = dhcp4_update_address(link, &address, &netmask, lifetime);
+        if (r < 0) {
+                log_warning_link(link, "could not update IP address: %s",
+                                 strerror(-r));
+                link_enter_failed(link);
+                return r;
+        }
+
+        return 0;
+}
+static void dhcp4_handler(sd_dhcp_client *client, int event, void *userdata) {
+        Link *link = userdata;
+        int r = 0;
+
+        assert(link);
+        assert(link->network);
+        assert(link->manager);
+
+        if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
+                return;
+
+        switch (event) {
+                case DHCP_EVENT_EXPIRED:
+                case DHCP_EVENT_STOP:
+                case DHCP_EVENT_IP_CHANGE:
+                        if (link->network->dhcp_critical) {
+                                log_error_link(link,
+                                               "DHCPv4 connection considered system critical, ignoring request to reconfigure it.");
+                                return;
+                        }
+
+                        if (link->dhcp_lease) {
+                                r = dhcp_lease_lost(link);
+                                if (r < 0) {
+                                        link_enter_failed(link);
+                                        return;
+                                }
+                        }
+
+                        if (event == DHCP_EVENT_IP_CHANGE) {
+                                r = dhcp_lease_acquired(client, link);
+                                if (r < 0) {
+                                        link_enter_failed(link);
+                                        return;
+                                }
+                        }
+
+                        break;
+                case DHCP_EVENT_RENEW:
+                        r = dhcp_lease_renew(client, link);
+                        if (r < 0) {
+                                link_enter_failed(link);
+                                return;
+                        }
+                        break;
+                case DHCP_EVENT_IP_ACQUIRE:
+                        r = dhcp_lease_acquired(client, link);
+                        if (r < 0) {
+                                link_enter_failed(link);
+                                return;
+                        }
+                        break;
+                default:
+                        if (event < 0)
+                                log_warning_link(link,
+                                                 "DHCP error: client failed: %s",
+                                                 strerror(-event));
+                        else
+                                log_warning_link(link,
+                                                 "DHCP unknown event: %d",
+                                                 event);
+                        break;
+        }
+
+        return;
+}
+
+int dhcp4_configure(Link *link) {
+        int r;
+
+        assert(link);
+        assert(link->network);
+        assert(link->network->ipv4ll);
+
+        r = sd_dhcp_client_new(&link->dhcp_client);
+        if (r < 0)
+                return r;
+
+        r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
+        if (r < 0)
+                return r;
+
+        r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
+        if (r < 0)
+                return r;
+
+        r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
+        if (r < 0)
+                return r;
+
+        r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp4_handler, link);
+        if (r < 0)
+                return r;
+
+        r = sd_dhcp_client_set_request_broadcast(link->dhcp_client,
+                                                 link->network->dhcp_broadcast);
+        if (r < 0)
+                return r;
+
+        if (link->mtu) {
+                r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
+                if (r < 0)
+                        return r;
+        }
+
+        if (link->network->dhcp_mtu) {
+             r = sd_dhcp_client_set_request_option(link->dhcp_client,
+                                                   DHCP_OPTION_INTERFACE_MTU);
+             if (r < 0)
+                return r;
+        }
+
+        if (link->network->dhcp_routes) {
+                r = sd_dhcp_client_set_request_option(link->dhcp_client,
+                                                      DHCP_OPTION_STATIC_ROUTE);
+                if (r < 0)
+                        return r;
+                r = sd_dhcp_client_set_request_option(link->dhcp_client,
+                                                      DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
+                        if (r < 0)
+                                return r;
+        }
+
+        if (link->network->dhcp_sendhost) {
+                _cleanup_free_ char *hostname = NULL;
+
+                hostname = gethostname_malloc();
+                if (!hostname)
+                        return -ENOMEM;
+
+                if (!is_localhost(hostname)) {
+                        r = sd_dhcp_client_set_hostname(link->dhcp_client,
+                                                        hostname);
+                        if (r < 0)
+                                return r;
+                }
+        }
+
+        if (link->network->dhcp_vendor_class_identifier) {
+                r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
+                                                               link->network->dhcp_vendor_class_identifier);
+                if (r < 0)
+                        return r;
+        }
+
+        return 0;
+}
index 3605745..a62bdf9 100644 (file)
@@ -77,11 +77,13 @@ static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
         if (r < 0)
                 log_debug_link(link, "MAC address not found for new device, continuing without");
 
-        r = asprintf(&link->state_file, "/run/systemd/netif/links/%d", link->ifindex);
+        r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
+                     link->ifindex);
         if (r < 0)
                 return -ENOMEM;
 
-        r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d", link->ifindex);
+        r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
+                     link->ifindex);
         if (r < 0)
                 return -ENOMEM;
 
@@ -204,7 +206,8 @@ static int link_stop_clients(Link *link) {
         if (link->dhcp_client) {
                 k = sd_dhcp_client_stop(link->dhcp_client);
                 if (k < 0) {
-                        log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
+                        log_warning_link(link, "Could not stop DHCPv4 client: %s",
+                                         strerror(-r));
                         r = k;
                 }
         }
@@ -212,7 +215,8 @@ static int link_stop_clients(Link *link) {
         if (link->ipv4ll) {
                 k = sd_ipv4ll_stop(link->ipv4ll);
                 if (k < 0) {
-                        log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
+                        log_warning_link(link, "Could not stop IPv4 link-local: %s",
+                                         strerror(-r));
                         r = k;
                 }
         }
@@ -220,7 +224,8 @@ static int link_stop_clients(Link *link) {
         if (link->dhcp_server) {
                 k = sd_dhcp_server_stop(link->dhcp_server);
                 if (k < 0) {
-                        log_warning_link(link, "Could not stop DHCPv4 server: %s", strerror(-r));
+                        log_warning_link(link, "Could not stop DHCPv4 server: %s",
+                                         strerror(-r));
                         r = k;
                 }
         }
@@ -230,14 +235,17 @@ static int link_stop_clients(Link *link) {
                 if (link->dhcp6_client) {
                         k = sd_dhcp6_client_stop(link->dhcp6_client);
                         if (k < 0) {
-                                log_warning_link(link, "Could not stop DHCPv6 client: %s", strerror(-r));
+                                log_warning_link(link, "Could not stop DHCPv6 client: %s",
+                                                 strerror(-r));
                                 r = k;
                         }
                 }
 
                 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
                 if (k < 0) {
-                        log_warning_link(link, "Could not stop ICMPv6 router discovery: %s", strerror(-r));
+                        log_warning_link(link,
+                                         "Could not stop ICMPv6 router discovery: %s",
+                                         strerror(-r));
                         r = k;
                 }
         }
@@ -260,17 +268,6 @@ void link_enter_failed(Link *link) {
         link_save(link);
 }
 
-void link_client_handler(Link *link) {
-        assert(link);
-
-        if (link->ipv4ll_address && link->ipv4ll_route)
-                log_debug_link(link, "IPv4LL configured");
-        else
-                log_debug_link(link, "IPv4LL not configured");
-
-        return;
-}
-
 static Address* link_find_dhcp_server_address(Link *link) {
         Address *address;
 
@@ -314,14 +311,17 @@ static int link_enter_configured(Link *link) {
 
                 address = link_find_dhcp_server_address(link);
                 if (!address) {
-                        log_warning_link(link, "Failed to find suitable address for DHCPv4 server instance.");
+                        log_warning_link(link,
+                                         "Failed to find suitable address for DHCPv4 server instance.");
                         link_enter_failed(link);
                         return 0;
                 }
 
                 log_debug_link(link, "offering DHCPv4 leases");
 
-                r = sd_dhcp_server_set_address(link->dhcp_server, &address->in_addr.in, address->prefixlen);
+                r = sd_dhcp_server_set_address(link->dhcp_server,
+                                               &address->in_addr.in,
+                                               address->prefixlen);
                 if (r < 0)
                         return r;
 
@@ -364,16 +364,37 @@ static int link_enter_configured(Link *link) {
         return 0;
 }
 
+void link_client_handler(Link *link) {
+        assert(link);
+        assert(link->network);
+
+        if (!link->static_configured)
+                return;
+
+        if (link->network->ipv4ll)
+                if (!link->ipv4ll_address ||
+                    !link->ipv4ll_route)
+                        return;
+
+        if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4))
+                if (!link->dhcp4_configured)
+                        return;
+
+        link_enter_configured(link);
+
+        return;
+}
+
 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
         _cleanup_link_unref_ Link *link = userdata;
         int r;
 
-        assert(link->route_messages > 0);
+        assert(link->link_messages > 0);
         assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
                       LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
                       LINK_STATE_LINGER));
 
-        link->route_messages --;
+        link->link_messages --;
 
         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
                 return 1;
@@ -387,58 +408,15 @@ static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
                                 "ERRNO=%d", -r,
                                 NULL);
 
-        /* we might have received an old reply after moving back to SETTING_ADDRESSES,
-         * ignore it */
-        if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
+        if (link->link_messages == 0) {
                 log_debug_link(link, "routes set");
-                link_enter_configured(link);
+                link->static_configured = true;
+                link_client_handler(link);
         }
 
         return 1;
 }
 
-static int link_set_dhcp_routes(Link *link) {
-        struct sd_dhcp_route *static_routes;
-        int r, n, i;
-
-        assert(link);
-
-        n = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes);
-        if (n < 0) {
-                if (n != -ENOENT)
-                        log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-n));
-                return n;
-        }
-
-        for (i = 0; i < n; i++) {
-                _cleanup_route_free_ Route *route = NULL;
-
-                r = route_new_dynamic(&route, RTPROT_DHCP);
-                if (r < 0) {
-                        log_error_link(link, "Could not allocate route: %s",
-                                       strerror(-r));
-                        return r;
-                }
-
-                route->family = AF_INET;
-                route->in_addr.in = static_routes[i].gw_addr;
-                route->dst_addr.in = static_routes[i].dst_addr;
-                route->dst_prefixlen = static_routes[i].dst_prefixlen;
-                route->metrics = DHCP_ROUTE_METRIC;
-
-                r = route_configure(route, link, &route_handler);
-                if (r < 0) {
-                        log_warning_link(link,
-                                         "could not set host route: %s", strerror(-r));
-                        return r;
-                }
-
-                link->route_messages ++;
-        }
-
-        return 0;
-}
-
 static int link_enter_set_routes(Link *link) {
         Route *rt;
         int r;
@@ -453,80 +431,18 @@ static int link_enter_set_routes(Link *link) {
                 r = route_configure(rt, link, &route_handler);
                 if (r < 0) {
                         log_warning_link(link,
-                                         "could not set routes: %s", strerror(-r));
-                        link_enter_failed(link);
-                        return r;
-                }
-
-                link->route_messages ++;
-        }
-
-        if (link->dhcp_lease) {
-                _cleanup_route_free_ Route *route = NULL;
-                _cleanup_route_free_ Route *route_gw = NULL;
-                struct in_addr gateway;
-
-                r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
-                if (r < 0 && r != -ENOENT) {
-                        log_warning_link(link, "DHCP error: could not get gateway: %s",
+                                         "could not set routes: %s",
                                          strerror(-r));
+                        link_enter_failed(link);
                         return r;
                 }
 
-                if (r >= 0) {
-                        r = route_new_dynamic(&route, RTPROT_DHCP);
-                        if (r < 0) {
-                                log_error_link(link, "Could not allocate route: %s",
-                                               strerror(-r));
-                                return r;
-                        }
-
-                        r = route_new_dynamic(&route_gw, RTPROT_DHCP);
-                        if (r < 0) {
-                                log_error_link(link, "Could not allocate route: %s",
-                                               strerror(-r));
-                                return r;
-                        }
-
-                        /* The dhcp netmask may mask out the gateway. Add an explicit
-                         * route for the gw host so that we can route no matter the
-                         * netmask or existing kernel route tables. */
-                        route_gw->family = AF_INET;
-                        route_gw->dst_addr.in = gateway;
-                        route_gw->dst_prefixlen = 32;
-                        route_gw->scope = RT_SCOPE_LINK;
-                        route_gw->metrics = DHCP_ROUTE_METRIC;
-
-                        r = route_configure(route_gw, link, &route_handler);
-                        if (r < 0) {
-                                log_warning_link(link,
-                                                 "could not set host route: %s", strerror(-r));
-                                return r;
-                        }
-
-                        link->route_messages ++;
-
-                        route->family = AF_INET;
-                        route->in_addr.in = gateway;
-                        route->metrics = DHCP_ROUTE_METRIC;
-
-                        r = route_configure(route, link, &route_handler);
-                        if (r < 0) {
-                                log_warning_link(link,
-                                                 "could not set routes: %s", strerror(-r));
-                                link_enter_failed(link);
-                                return r;
-                        }
-
-                        link->route_messages ++;
-                }
-
-                if (link->network->dhcp_routes)
-                        link_set_dhcp_routes(link);
+                link->link_messages ++;
         }
 
-        if (link->route_messages == 0) {
-                link_enter_configured(link);
+        if (link->link_messages == 0) {
+                link->static_configured = true;
+                link_client_handler(link);
         } else
                 log_debug_link(link, "setting routes");
 
@@ -568,13 +484,15 @@ int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata)
         for (; m; m = sd_rtnl_message_next(m)) {
                 r = sd_rtnl_message_get_errno(m);
                 if (r < 0) {
-                        log_debug_link(link, "getting address failed: %s", strerror(-r));
+                        log_debug_link(link, "getting address failed: %s",
+                                       strerror(-r));
                         continue;
                 }
 
                 r = link_rtnl_process_address(rtnl, m, link->manager);
                 if (r < 0)
-                        log_warning_link(link, "could not process address: %s", strerror(-r));
+                        log_warning_link(link, "could not process address: %s",
+                                         strerror(-r));
         }
 
         return 1;
@@ -588,11 +506,11 @@ static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
         assert(m);
         assert(link);
         assert(link->ifname);
-        assert(link->addr_messages > 0);
+        assert(link->link_messages > 0);
         assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
                LINK_STATE_FAILED, LINK_STATE_LINGER));
 
-        link->addr_messages --;
+        link->link_messages --;
 
         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
                 return 1;
@@ -611,7 +529,7 @@ static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
                 link_get_address_handler(rtnl, m, link);
         }
 
-        if (link->addr_messages == 0) {
+        if (link->link_messages == 0) {
                 log_debug_link(link, "addresses set");
                 link_enter_set_routes(link);
         }
@@ -622,7 +540,6 @@ static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 static int link_enter_set_addresses(Link *link) {
         Address *ad;
         int r;
-        uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
 
         assert(link);
         assert(link->network);
@@ -634,74 +551,16 @@ static int link_enter_set_addresses(Link *link) {
                 r = address_configure(ad, link, &address_handler);
                 if (r < 0) {
                         log_warning_link(link,
-                                         "could not set addresses: %s", strerror(-r));
-                        link_enter_failed(link);
-                        return r;
-                }
-
-                link->addr_messages ++;
-        }
-
-        if (link->dhcp_lease) {
-                _cleanup_address_free_ Address *address = NULL;
-                struct in_addr addr;
-                struct in_addr netmask;
-                unsigned prefixlen;
-
-                r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
-                if (r < 0) {
-                        log_warning_link(link, "DHCP error: no address: %s",
+                                         "could not set addresses: %s",
                                          strerror(-r));
-                        return r;
-                }
-
-                if (!link->network->dhcp_critical) {
-                        r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
-                                                       &lifetime);
-                        if (r < 0) {
-                                log_warning_link(link, "DHCP error: no lifetime: %s",
-                                                 strerror(-r));
-                                return r;
-                        }
-                }
-
-                r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
-                if (r < 0) {
-                        log_warning_link(link, "DHCP error: no netmask: %s",
-                                         strerror(-r));
-                        return r;
-                }
-
-                prefixlen = in_addr_netmask_to_prefixlen(&netmask);
-
-                r = address_new_dynamic(&address);
-                if (r < 0) {
-                        log_error_link(link, "Could not allocate address: %s",
-                                       strerror(-r));
-                        return r;
-                }
-
-                address->family = AF_INET;
-                address->in_addr.in = addr;
-                address->cinfo.ifa_prefered = lifetime;
-                address->cinfo.ifa_valid = lifetime;
-                address->prefixlen = prefixlen;
-                address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
-
-                /* use update rather than configure so that we will update the lifetime
-                   of an existing address if it has already been configured */
-                r = address_update(address, link, &address_handler);
-                if (r < 0) {
-                        log_warning_link(link,
-                                         "could not set addresses: %s", strerror(-r));
                         link_enter_failed(link);
                         return r;
                 }
 
-                link->addr_messages ++;
+                link->link_messages ++;
         }
 
-        if (link->addr_messages == 0) {
+        if (link->link_messages == 0) {
                 link_enter_set_routes(link);
         } else
                 log_debug_link(link, "setting addresses");
@@ -732,7 +591,8 @@ int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata)
         return 1;
 }
 
-static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
+static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
+                                sd_bus_error *ret_error) {
         _cleanup_link_unref_ Link *link = userdata;
         int r;
 
@@ -745,12 +605,13 @@ static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
         if (r < 0)
                 r = -r;
         if (r > 0)
-                log_warning_link(link, "Could not set hostname: %s", strerror(r));
+                log_warning_link(link, "Could not set hostname: %s",
+                                 strerror(r));
 
         return 1;
 }
 
-static int link_set_hostname(Link *link, const char *hostname) {
+int link_set_hostname(Link *link, const char *hostname) {
         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
         int r = 0;
 
@@ -760,8 +621,10 @@ static int link_set_hostname(Link *link, const char *hostname) {
 
         log_debug_link(link, "Setting transient hostname: '%s'", hostname);
 
-        if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
-                log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
+        if (!link->manager->bus) {
+                /* TODO: replace by assert when we can rely on kdbus */
+                log_info_link(link,
+                              "Not connected to system bus, ignoring transient hostname.");
                 return 0;
         }
 
@@ -779,9 +642,11 @@ static int link_set_hostname(Link *link, const char *hostname) {
         if (r < 0)
                 return r;
 
-        r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
+        r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
+                              link, 0);
         if (r < 0) {
-                log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
+                log_error_link(link, "Could not set transient hostname: %s",
+                               strerror(-r));
                 return r;
         }
 
@@ -812,7 +677,7 @@ static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
         return 1;
 }
 
-static int link_set_mtu(Link *link, uint32_t mtu) {
+int link_set_mtu(Link *link, uint32_t mtu) {
         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
         int r;
 
@@ -835,10 +700,12 @@ static int link_set_mtu(Link *link, uint32_t mtu) {
                 return r;
         }
 
-        r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
+        r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
+                               0, NULL);
         if (r < 0) {
                 log_error_link(link,
-                               "Could not send rtnetlink message: %s", strerror(-r));
+                               "Could not send rtnetlink message: %s",
+                               strerror(-r));
                 return r;
         }
 
@@ -847,290 +714,6 @@ static int link_set_mtu(Link *link, uint32_t mtu) {
         return 0;
 }
 
-static int dhcp_lease_lost(Link *link) {
-        _cleanup_address_free_ Address *address = NULL;
-        struct in_addr addr;
-        struct in_addr netmask;
-        struct in_addr gateway;
-        unsigned prefixlen;
-        int r;
-
-        assert(link);
-        assert(link->dhcp_lease);
-
-        log_warning_link(link, "DHCP lease lost");
-
-        if (link->network->dhcp_routes) {
-                struct sd_dhcp_route *routes;
-                int n, i;
-
-                n = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes);
-                if (n >= 0) {
-                        for (i = 0; i < n; i++) {
-                                _cleanup_route_free_ Route *route = NULL;
-
-                                r = route_new_dynamic(&route, RTPROT_UNSPEC);
-                                if (r >= 0) {
-                                        route->family = AF_INET;
-                                        route->in_addr.in = routes[i].gw_addr;
-                                        route->dst_addr.in = routes[i].dst_addr;
-                                        route->dst_prefixlen = routes[i].dst_prefixlen;
-
-                                        route_drop(route, link, &link_route_drop_handler);
-                                }
-                        }
-                }
-        }
-
-        r = address_new_dynamic(&address);
-        if (r >= 0) {
-                r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
-                if (r >= 0) {
-                        _cleanup_route_free_ Route *route_gw = NULL;
-                        _cleanup_route_free_ Route *route = NULL;
-
-                        r = route_new_dynamic(&route_gw, RTPROT_UNSPEC);
-                        if (r >= 0) {
-                                route_gw->family = AF_INET;
-                                route_gw->dst_addr.in = gateway;
-                                route_gw->dst_prefixlen = 32;
-                                route_gw->scope = RT_SCOPE_LINK;
-
-                                route_drop(route_gw, link, &link_route_drop_handler);
-                        }
-
-                        r = route_new_dynamic(&route, RTPROT_UNSPEC);
-                        if (r >= 0) {
-                                route->family = AF_INET;
-                                route->in_addr.in = gateway;
-
-                                route_drop(route, link, &link_route_drop_handler);
-                        }
-                }
-
-                sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
-                sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
-                prefixlen = in_addr_netmask_to_prefixlen(&netmask);
-
-                address->family = AF_INET;
-                address->in_addr.in = addr;
-                address->prefixlen = prefixlen;
-
-                address_drop(address, link, &link_address_drop_handler);
-        }
-
-        if (link->network->dhcp_mtu) {
-                uint16_t mtu;
-
-                r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
-                if (r >= 0 && link->original_mtu != mtu) {
-                        r = link_set_mtu(link, link->original_mtu);
-                        if (r < 0) {
-                                log_warning_link(link, "DHCP error: could not reset MTU");
-                                link_enter_failed(link);
-                                return r;
-                        }
-                }
-        }
-
-        if (link->network->dhcp_hostname) {
-                const char *hostname = NULL;
-
-                r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
-                if (r >= 0 && hostname) {
-                        r = link_set_hostname(link, "");
-                        if (r < 0)
-                                log_error_link(link, "Failed to reset transient hostname");
-                }
-        }
-
-        link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
-
-        return 0;
-}
-
-static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
-        sd_dhcp_lease *lease;
-        int r;
-
-        r = sd_dhcp_client_get_lease(client, &lease);
-        if (r < 0) {
-                log_warning_link(link, "DHCP error: no lease %s",
-                                 strerror(-r));
-                return r;
-        }
-
-        sd_dhcp_lease_unref(link->dhcp_lease);
-        link->dhcp_lease = lease;
-
-        link_enter_set_addresses(link);
-
-        return 0;
-}
-
-static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
-        sd_dhcp_lease *lease;
-        struct in_addr address;
-        struct in_addr netmask;
-        struct in_addr gateway;
-        unsigned prefixlen;
-        int r;
-
-        assert(client);
-        assert(link);
-
-        r = sd_dhcp_client_get_lease(client, &lease);
-        if (r < 0) {
-                log_warning_link(link, "DHCP error: no lease: %s",
-                                 strerror(-r));
-                return r;
-        }
-
-        r = sd_dhcp_lease_get_address(lease, &address);
-        if (r < 0) {
-                log_warning_link(link, "DHCP error: no address: %s",
-                                 strerror(-r));
-                return r;
-        }
-
-        r = sd_dhcp_lease_get_netmask(lease, &netmask);
-        if (r < 0) {
-                log_warning_link(link, "DHCP error: no netmask: %s",
-                                 strerror(-r));
-                return r;
-        }
-
-        prefixlen = in_addr_netmask_to_prefixlen(&netmask);
-
-        r = sd_dhcp_lease_get_router(lease, &gateway);
-        if (r < 0 && r != -ENOENT) {
-                log_warning_link(link, "DHCP error: could not get gateway: %s",
-                                 strerror(-r));
-                return r;
-        }
-
-        if (r >= 0)
-                log_struct_link(LOG_INFO, link,
-                                "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
-                                 IFNAMSIZ,
-                                 link->ifname,
-                                 ADDRESS_FMT_VAL(address),
-                                 prefixlen,
-                                 ADDRESS_FMT_VAL(gateway),
-                                 "ADDRESS=%u.%u.%u.%u",
-                                 ADDRESS_FMT_VAL(address),
-                                 "PREFIXLEN=%u",
-                                 prefixlen,
-                                 "GATEWAY=%u.%u.%u.%u",
-                                 ADDRESS_FMT_VAL(gateway),
-                                 NULL);
-        else
-                log_struct_link(LOG_INFO, link,
-                                "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
-                                 IFNAMSIZ,
-                                 link->ifname,
-                                 ADDRESS_FMT_VAL(address),
-                                 prefixlen,
-                                 "ADDRESS=%u.%u.%u.%u",
-                                 ADDRESS_FMT_VAL(address),
-                                 "PREFIXLEN=%u",
-                                 prefixlen,
-                                 NULL);
-
-        link->dhcp_lease = lease;
-
-        if (link->network->dhcp_mtu) {
-                uint16_t mtu;
-
-                r = sd_dhcp_lease_get_mtu(lease, &mtu);
-                if (r >= 0) {
-                        r = link_set_mtu(link, mtu);
-                        if (r < 0)
-                                log_error_link(link, "Failed to set MTU "
-                                               "to %" PRIu16, mtu);
-                }
-        }
-
-        if (link->network->dhcp_hostname) {
-                const char *hostname;
-
-                r = sd_dhcp_lease_get_hostname(lease, &hostname);
-                if (r >= 0) {
-                        r = link_set_hostname(link, hostname);
-                        if (r < 0)
-                                log_error_link(link, "Failed to set transient hostname "
-                                          "to '%s'", hostname);
-                }
-        }
-
-        link_enter_set_addresses(link);
-
-        return 0;
-}
-
-static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
-        Link *link = userdata;
-        int r = 0;
-
-        assert(link);
-        assert(link->network);
-        assert(link->manager);
-
-        if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
-                return;
-
-        switch (event) {
-                case DHCP_EVENT_EXPIRED:
-                case DHCP_EVENT_STOP:
-                case DHCP_EVENT_IP_CHANGE:
-                        if (link->network->dhcp_critical) {
-                                log_error_link(link, "DHCPv4 connection considered system critical, "
-                                               "ignoring request to reconfigure it.");
-                                return;
-                        }
-
-                        if (link->dhcp_lease) {
-                                r = dhcp_lease_lost(link);
-                                if (r < 0) {
-                                        link_enter_failed(link);
-                                        return;
-                                }
-                        }
-
-                        if (event == DHCP_EVENT_IP_CHANGE) {
-                                r = dhcp_lease_acquired(client, link);
-                                if (r < 0) {
-                                        link_enter_failed(link);
-                                        return;
-                                }
-                        }
-
-                        break;
-                case DHCP_EVENT_RENEW:
-                        r = dhcp_lease_renew(client, link);
-                        if (r < 0) {
-                                link_enter_failed(link);
-                                return;
-                        }
-                        break;
-                case DHCP_EVENT_IP_ACQUIRE:
-                        r = dhcp_lease_acquired(client, link);
-                        if (r < 0) {
-                                link_enter_failed(link);
-                                return;
-                        }
-                        break;
-                default:
-                        if (event < 0)
-                                log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
-                        else
-                                log_warning_link(link, "DHCP unknown event: %d", event);
-                        break;
-        }
-
-        return;
-}
-
 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
         Link *link = userdata;
 
@@ -1270,7 +853,8 @@ static int link_acquire_conf(Link *link) {
 
                 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
                 if (r < 0) {
-                        log_warning_link(link, "could not start IPv6 router discovery");
+                        log_warning_link(link,
+                                         "could not start IPv6 router discovery");
                         return r;
                 }
         }
@@ -1351,13 +935,16 @@ static int link_update_flags(Link *link, sd_rtnl_message *m) {
                 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
                 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
 
-                /* link flags are currently at most 18 bits, let's align to printing 20 */
+                /* link flags are currently at most 18 bits, let's align to
+                 * printing 20 */
                 if (unknown_flags_added)
-                        log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
+                        log_debug_link(link,
+                                       "unknown link flags gained: %#.5x (ignoring)",
                                        unknown_flags_added);
 
                 if (unknown_flags_removed)
-                        log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
+                        log_debug_link(link,
+                                       "unknown link flags lost: %#.5x (ignoring)",
                                        unknown_flags_removed);
         }
 
@@ -1441,14 +1028,17 @@ static int link_up(Link *link) {
 
         r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
         if (r < 0) {
-                log_error_link(link, "Could not set link flags: %s", strerror(-r));
+                log_error_link(link, "Could not set link flags: %s",
+                               strerror(-r));
                 return r;
         }
 
-        r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
+        r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
+                               0, NULL);
         if (r < 0) {
                 log_error_link(link,
-                               "Could not send rtnetlink message: %s", strerror(-r));
+                               "Could not send rtnetlink message: %s",
+                               strerror(-r));
                 return r;
         }
 
@@ -1475,7 +1065,8 @@ static int link_joined(Link *link) {
         return link_enter_set_addresses(link);
 }
 
-static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
+static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
+                               void *userdata) {
         _cleanup_link_unref_ Link *link = userdata;
         int r;
 
@@ -1539,7 +1130,8 @@ static int link_enter_join_netdev(Link *link) {
                         log_struct_link(LOG_WARNING, link,
                                         "MESSAGE=%-*s: could not join netdev '%s': %s",
                                         IFNAMSIZ,
-                                        link->ifname, link->network->bond->ifname, strerror(-r),
+                                        link->ifname, link->network->bond->ifname,
+                                        strerror(-r),
                                         NETDEVIF(link->network->bond),
                                         NULL);
                         link_enter_failed(link);
@@ -1557,12 +1149,14 @@ static int link_enter_join_netdev(Link *link) {
                                 NETDEVIF(link->network->bridge),
                                 NULL);
 
-                r = netdev_join(link->network->bridge, link, &netdev_join_handler);
+                r = netdev_join(link->network->bridge, link,
+                                &netdev_join_handler);
                 if (r < 0) {
                         log_struct_link(LOG_WARNING, link,
                                         "MESSAGE=%-*s: could not join netdev '%s': %s",
                                         IFNAMSIZ,
-                                        link->ifname, link->network->bridge->ifname, strerror(-r),
+                                        link->ifname, link->network->bridge->ifname,
+                                        strerror(-r),
                                         NETDEVIF(link->network->bridge),
                                         NULL);
                         link_enter_failed(link);
@@ -1576,14 +1170,16 @@ static int link_enter_join_netdev(Link *link) {
                 log_struct_link(LOG_DEBUG, link,
                                 "MESSAGE=%-*s: enslaving by '%s'",
                                 IFNAMSIZ,
-                                link->ifname, netdev->ifname, NETDEVIF(netdev), NULL);
+                                link->ifname, netdev->ifname, NETDEVIF(netdev),
+                                NULL);
 
                 r = netdev_join(netdev, link, &netdev_join_handler);
                 if (r < 0) {
                         log_struct_link(LOG_WARNING, link,
                                         "MESSAGE=%-*s: could not join netdev '%s': %s",
                                         IFNAMSIZ,
-                                        link->ifname, netdev->ifname, strerror(-r),
+                                        link->ifname, netdev->ifname,
+                                        strerror(-r),
                                         NETDEVIF(netdev), NULL);
                         link_enter_failed(link);
                         return r;
@@ -1609,69 +1205,9 @@ static int link_configure(Link *link) {
         }
 
         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
-                r = sd_dhcp_client_new(&link->dhcp_client);
-                if (r < 0)
-                        return r;
-
-                r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
+                r = dhcp4_configure(link);
                 if (r < 0)
                         return r;
-
-                r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
-                if (r < 0)
-                        return r;
-
-                r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
-                if (r < 0)
-                        return r;
-
-                r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
-                if (r < 0)
-                        return r;
-
-                r = sd_dhcp_client_set_request_broadcast(link->dhcp_client, link->network->dhcp_broadcast);
-                if (r < 0)
-                        return r;
-
-                if (link->mtu) {
-                        r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
-                        if (r < 0)
-                                return r;
-                }
-
-                if (link->network->dhcp_mtu) {
-                        r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_INTERFACE_MTU);
-                        if (r < 0)
-                                return r;
-                }
-
-                if (link->network->dhcp_routes) {
-                        r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
-                        if (r < 0)
-                                return r;
-                        r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
-                        if (r < 0)
-                                return r;
-                }
-
-                if (link->network->dhcp_sendhost) {
-                        _cleanup_free_ char *hostname = gethostname_malloc();
-                        if (!hostname)
-                                return -ENOMEM;
-
-                        if (!is_localhost(hostname)) {
-                                r = sd_dhcp_client_set_hostname(link->dhcp_client, hostname);
-                                if (r < 0)
-                                        return r;
-                        }
-                }
-
-                if (link->network->dhcp_vendor_class_identifier) {
-                        r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
-                                                                       link->network->dhcp_vendor_class_identifier);
-                        if (r < 0)
-                                return r;
-                }
         }
 
         if (link->network->dhcp_server) {
@@ -1719,7 +1255,8 @@ static int link_configure(Link *link) {
         return link_enter_join_netdev(link);
 }
 
-static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
+static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
+                                       void *userdata) {
         _cleanup_link_unref_ Link *link = userdata;
         Network *network;
         int r;
@@ -1733,7 +1270,8 @@ static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *
 
         log_debug_link(link, "link state is up-to-date");
 
-        r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
+        r = network_get(link->manager, link->udev_device, link->ifname,
+                        &link->mac, &network);
         if (r == -ENOENT) {
                 link_enter_unmanaged(link);
                 return 1;
@@ -1770,16 +1308,18 @@ int link_initialized(Link *link, struct udev_device *device) {
 
         link->udev_device = udev_device_ref(device);
 
-        /* udev has initialized the link, but we don't know if we have yet processed
-           the NEWLINK messages with the latest state. Do a GETLINK, when it returns
-           we know that the pending NEWLINKs have already been processed and that we
-           are up-to-date */
+        /* udev has initialized the link, but we don't know if we have yet
+         * processed the NEWLINK messages with the latest state. Do a GETLINK,
+         * when it returns we know that the pending NEWLINKs have already been
+         * processed and that we are up-to-date */
 
-        r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
+        r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
+                                     link->ifindex);
         if (r < 0)
                 return r;
 
-        r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
+        r = sd_rtnl_call_async(link->manager->rtnl, req,
+                               link_initialized_and_synced, link, 0, NULL);
         if (r < 0)
                 return r;
 
@@ -1788,7 +1328,8 @@ int link_initialized(Link *link, struct udev_device *device) {
         return 0;
 }
 
-int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
+int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message,
+                              void *userdata) {
         Manager *m = userdata;
         Link *link = NULL;
         uint16_t type;
@@ -1826,36 +1367,43 @@ int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *use
 
         r = sd_rtnl_message_addr_get_family(message, &address->family);
         if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
-                log_warning_link(link, "rtnl: received address with invalid family, ignoring");
+                log_warning_link(link,
+                                 "rtnl: received address with invalid family, ignoring");
                 return 0;
         }
 
         r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
         if (r < 0) {
-                log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
+                log_warning_link(link,
+                                 "rtnl: received address with invalid prefixlen, ignoring");
                 return 0;
         }
 
         r = sd_rtnl_message_addr_get_scope(message, &address->scope);
         if (r < 0) {
-                log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
+                log_warning_link(link,
+                                 "rtnl: received address with invalid scope, ignoring");
                 return 0;
         }
 
         switch (address->family) {
         case AF_INET:
-                r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
+                r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
+                                                 &address->in_addr.in);
                 if (r < 0) {
-                        log_warning_link(link, "rtnl: received address without valid address, ignoring");
+                        log_warning_link(link,
+                                         "rtnl: received address without valid address, ignoring");
                         return 0;
                 }
 
                 break;
 
         case AF_INET6:
-                r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
+                r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
+                                                  &address->in_addr.in6);
                 if (r < 0) {
-                        log_warning_link(link, "rtnl: received address without valid address, ignoring");
+                        log_warning_link(link,
+                                         "rtnl: received address without valid address, ignoring");
                         return 0;
                 }
 
@@ -1865,7 +1413,8 @@ int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *use
                 assert_not_reached("invalid address family");
         }
 
-        if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
+        if (!inet_ntop(address->family, &address->in_addr, buf,
+                       INET6_ADDRSTRLEN)) {
                 log_warning_link(link, "could not print address");
                 return 0;
         }
@@ -1904,7 +1453,8 @@ int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *use
 
                         link_save(link);
                 } else
-                        log_warning_link(link, "removing non-existent address: %s/%u",
+                        log_warning_link(link,
+                                         "removing non-existent address: %s/%u",
                                          buf, address->prefixlen);
 
                 break;
@@ -1935,11 +1485,13 @@ int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
 
         log_debug_link(link, "link %d added", link->ifindex);
 
-        r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
+        r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex,
+                                     0);
         if (r < 0)
                 return r;
 
-        r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
+        r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0,
+                               NULL);
         if (r < 0)
                 return r;
 
@@ -1950,7 +1502,8 @@ int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
                 sprintf(ifindex_str, "n%d", link->ifindex);
                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
                 if (!device) {
-                        log_warning_link(link, "could not find udev device: %m");
+                        log_warning_link(link,
+                                         "could not find udev device: %m");
                         return -errno;
                 }
 
@@ -2011,9 +1564,11 @@ int link_update(Link *link, sd_rtnl_message *m) {
                 }
 
                 if (link->dhcp_client) {
-                        r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
+                        r = sd_dhcp_client_set_mtu(link->dhcp_client,
+                                                   link->mtu);
                         if (r < 0) {
-                                log_warning_link(link, "Could not update MTU in DHCP client: %s",
+                                log_warning_link(link,
+                                                 "Could not update MTU in DHCP client: %s",
                                                  strerror(-r));
                                 return r;
                         }
@@ -2024,9 +1579,11 @@ int link_update(Link *link, sd_rtnl_message *m) {
            set, simply ignore them. */
         r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
         if (r >= 0) {
-                if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
+                if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
+                           ETH_ALEN)) {
 
-                        memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
+                        memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
+                               ETH_ALEN);
 
                         log_debug_link(link, "MAC address: "
                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
@@ -2040,18 +1597,19 @@ int link_update(Link *link, sd_rtnl_message *m) {
                         if (link->ipv4ll) {
                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
                                 if (r < 0) {
-                                        log_warning_link(link, "Could not update MAC "
-                                                         "address in IPv4LL client: %s",
+                                        log_warning_link(link,
+                                                         "Could not update MAC address in IPv4LL client: %s",
                                                          strerror(-r));
                                         return r;
                                 }
                         }
 
                         if (link->dhcp_client) {
-                                r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
+                                r = sd_dhcp_client_set_mac(link->dhcp_client,
+                                                           &link->mac);
                                 if (r < 0) {
-                                        log_warning_link(link, "Could not update MAC "
-                                                         "address in DHCP client: %s",
+                                        log_warning_link(link,
+                                                         "Could not update MAC address in DHCP client: %s",
                                                          strerror(-r));
                                         return r;
                                 }
@@ -2061,7 +1619,8 @@ int link_update(Link *link, sd_rtnl_message *m) {
                                 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
                                                             &link->mac);
                                 if (r < 0) {
-                                        log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
+                                        log_warning_link(link,
+                                                         "Could not update MAC address in DHCPv6 client: %s",
                                                          strerror(-r));
                                         return r;
                                 }
@@ -2184,7 +1743,8 @@ int link_save(Link *link) {
 
                 fputs("\n", f);
 
-                fprintf(f, "LLMNR=%s\n", llmnr_support_to_string(link->network->llmnr));
+                fprintf(f, "LLMNR=%s\n",
+                        llmnr_support_to_string(link->network->llmnr));
         }
 
         if (link->dhcp_lease) {
@@ -2210,7 +1770,6 @@ int link_save(Link *link) {
         }
 
         return 0;
-
 fail:
         log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
         unlink(link->state_file);
index 1d0b466..1e64e12 100644 (file)
@@ -66,8 +66,7 @@ struct Link {
         LinkState state;
         LinkOperationalState operstate;
 
-        unsigned addr_messages;
-        unsigned route_messages;
+        unsigned link_messages;
         unsigned enslaving;
 
         LIST_HEAD(Address, addresses);
@@ -76,11 +75,15 @@ struct Link {
         sd_dhcp_lease *dhcp_lease;
         char *lease_file;
         uint16_t original_mtu;
+        unsigned dhcp4_messages;
+        bool dhcp4_configured;
 
         sd_ipv4ll *ipv4ll;
         bool ipv4ll_address;
         bool ipv4ll_route;
 
+        bool static_configured;
+
         LIST_HEAD(Address, pool_addresses);
 
         sd_dhcp_server *dhcp_server;
@@ -111,7 +114,11 @@ int link_save(Link *link);
 
 bool link_has_carrier(unsigned flags, uint8_t operstate);
 
+int link_set_mtu(Link *link, uint32_t mtu);
+int link_set_hostname(Link *link, const char *hostname);
+
 int ipv4ll_configure(Link *link);
+int dhcp4_configure(Link *link);
 
 const char* link_state_to_string(LinkState s) _const_;
 LinkState link_state_from_string(const char *s) _pure_;
index 4ff20e6..e2280f1 100644 (file)
@@ -279,9 +279,11 @@ static bool mac_is_random(struct udev_device *device) {
         unsigned type;
         int r;
 
+        /* if we can't get the assign type, assume it is not random */
         s = udev_device_get_sysattr_value(device, "addr_assign_type");
         if (!s)
-                return false; /* if we don't know, assume it is not random */
+                return false;
+
         r = safe_atou(s, &type);
         if (r < 0)
                 return false;
@@ -294,9 +296,11 @@ static bool should_rename(struct udev_device *device, bool respect_predictable)
         unsigned type;
         int r;
 
+        /* if we can't get the assgin type, assume we should rename */
         s = udev_device_get_sysattr_value(device, "name_assign_type");
         if (!s)
-                return true; /* if we don't know, assume we should rename */
+                return true;
+
         r = safe_atou(s, &type);
         if (r < 0)
                 return true;
@@ -304,14 +308,17 @@ static bool should_rename(struct udev_device *device, bool respect_predictable)
         switch (type) {
         case NET_NAME_USER:
         case NET_NAME_RENAMED:
-                return false; /* these were already named by userspace, do not touch again */
+                /* these were already named by userspace, do not touch again */
+                return false;
         case NET_NAME_PREDICTABLE:
+                /* the kernel claims to have given a predictable name */
                 if (respect_predictable)
-                        return false; /* the kernel claims to have given a predictable name */
+                        return false;
                 /* fall through */
         case NET_NAME_ENUM:
         default:
-                return true; /* the name is known to be bad, or of an unknown type */
+                /* the name is known to be bad, or of an unknown type */
+                return true;
         }
 }
 
@@ -333,8 +340,8 @@ static int get_mac(struct udev_device *device, bool want_random,
         }
 
         /* see eth_random_addr in the kernel */
-        mac->ether_addr_octet[0] &= 0xfe;        /* clear multicast bit */
-        mac->ether_addr_octet[0] |= 0x02;        /* set local assignment bit (IEEE802) */
+        mac->ether_addr_octet[0] &= 0xfe;  /* clear multicast bit */
+        mac->ether_addr_octet[0] |= 0x02;  /* set local assignment bit (IEEE802) */
 
         return 0;
 }
@@ -410,8 +417,8 @@ int link_config_apply(link_config_ctx *ctx, link_config *config,
         }
 
         if (should_rename(device, respect_predictable)) {
+                /* if not set by policy, fall back manually set name */
                 if (!new_name)
-                        /* if not set by policy, fall back manually set name */
                         new_name = config->name;
         } else
                 new_name = NULL;