X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fnetwork%2Fnetworkd-link.c;h=752ecae2543132dde870511b22c73b95154d1162;hp=3ef7622f480af624dc486d42d5b8eb6246571b1a;hb=fd88eb8ab0ae6b3dec15b29725ad040eafe7ac67;hpb=cf6a8911738fe2635a5210769d5348b05b166691

diff --git a/src/network/networkd-link.c b/src/network/networkd-link.c
index 3ef7622f4..752ecae25 100644
--- a/src/network/networkd-link.c
+++ b/src/network/networkd-link.c
@@ -26,15 +26,17 @@
 #include "libudev-private.h"
 #include "util.h"
 #include "bus-util.h"
-#include "net-util.h"
+#include "network-internal.h"
+
+#include "dhcp-lease-internal.h"
 
 int link_new(Manager *manager, struct udev_device *device, Link **ret) {
         _cleanup_link_free_ Link *link = NULL;
-        const char *mac;
-        struct ether_addr *mac_addr;
         const char *ifname;
         int r;
 
+        assert(manager);
+        assert(manager->links);
         assert(device);
         assert(ret);
 
@@ -49,12 +51,10 @@ int link_new(Manager *manager, struct udev_device *device, Link **ret) {
         if (link->ifindex <= 0)
                 return -EINVAL;
 
-        mac = udev_device_get_sysattr_value(device, "address");
-        if (mac) {
-                mac_addr = ether_aton(mac);
-                if (mac_addr)
-                        memcpy(&link->mac, mac_addr, sizeof(struct ether_addr));
-        }
+        r = asprintf(&link->state_file, "/run/systemd/network/links/%"PRIu64,
+                     link->ifindex);
+        if (r < 0)
+                return -ENOMEM;
 
         ifname = udev_device_get_sysname(device);
         link->ifname = strdup(ifname);
@@ -63,6 +63,8 @@ int link_new(Manager *manager, struct udev_device *device, Link **ret) {
         if (r < 0)
                 return r;
 
+        link->udev_device = udev_device_ref(device);
+
         *ret = link;
         link = NULL;
 
@@ -78,43 +80,34 @@ void link_free(Link *link) {
         sd_dhcp_client_free(link->dhcp_client);
         sd_dhcp_lease_unref(link->dhcp_lease);
 
+        sd_ipv4ll_free(link->ipv4ll);
+
         hashmap_remove(link->manager->links, &link->ifindex);
 
         free(link->ifname);
+        free(link->state_file);
+
+        udev_device_unref(link->udev_device);
 
         free(link);
 }
 
-int link_add(Manager *m, struct udev_device *device, Link **ret) {
+int link_get(Manager *m, int ifindex, Link **ret) {
         Link *link;
-        Network *network;
-        int r;
-        uint64_t ifindex;
+        uint64_t ifindex_64;
 
         assert(m);
-        assert(device);
-
-        ifindex = udev_device_get_ifindex(device);
-        link = hashmap_get(m->links, &ifindex);
-        if (link) {
-                *ret = link;
-                return -EEXIST;
-        }
+        assert(m->links);
+        assert(ifindex);
+        assert(ret);
 
-        r = link_new(m, device, &link);
-        if (r < 0)
-                return r;
+        ifindex_64 = ifindex;
+        link = hashmap_get(m->links, &ifindex_64);
+        if (!link)
+                return -ENODEV;
 
         *ret = link;
 
-        r = network_get(m, device, &network);
-        if (r < 0)
-                return r == -ENOENT ? 0 : r;
-
-        r = network_apply(m, network, link);
-        if (r < 0)
-                return r;
-
         return 0;
 }
 
@@ -126,6 +119,8 @@ static int link_enter_configured(Link *link) {
 
         link->state = LINK_STATE_CONFIGURED;
 
+        link_save(link);
+
         return 0;
 }
 
@@ -135,6 +130,8 @@ static void link_enter_failed(Link *link) {
         log_warning_link(link, "failed");
 
         link->state = LINK_STATE_FAILED;
+
+        link_save(link);
 }
 
 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
@@ -171,6 +168,7 @@ static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 
 static int link_enter_set_routes(Link *link) {
         Route *rt;
+        struct in_addr a;
         int r;
 
         assert(link);
@@ -179,7 +177,8 @@ static int link_enter_set_routes(Link *link) {
 
         link->state = LINK_STATE_SETTING_ROUTES;
 
-        if (!link->network->static_routes && !link->dhcp_lease)
+        if (!link->network->static_routes && !link->dhcp_lease &&
+                (!link->ipv4ll || sd_ipv4ll_get_address(link->ipv4ll, &a) < 0))
                 return link_enter_configured(link);
 
         log_debug_link(link, "setting routes");
@@ -196,8 +195,44 @@ static int link_enter_set_routes(Link *link) {
                 link->route_messages ++;
         }
 
+        if (link->ipv4ll && !link->dhcp_lease) {
+                _cleanup_route_free_ Route *route = NULL;
+                struct in_addr addr;
+
+                r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
+                if (r < 0 && r != -ENOENT) {
+                        log_warning_link(link, "IPV4LL error: no address: %s",
+                                        strerror(-r));
+                        return r;
+                }
+
+                if (r != -ENOENT) {
+                        r = route_new_dynamic(&route);
+                        if (r < 0) {
+                                log_error_link(link, "Could not allocate route: %s",
+                                               strerror(-r));
+                                return r;
+                        }
+
+                        route->family = AF_INET;
+                        route->scope = RT_SCOPE_LINK;
+                        route->metrics = 99;
+
+                        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->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);
@@ -214,6 +249,30 @@ static int link_enter_set_routes(Link *link) {
                         return r;
                 }
 
+                r = route_new_dynamic(&route_gw);
+                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;
+
+                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;
 
@@ -231,6 +290,28 @@ static int link_enter_set_routes(Link *link) {
         return 0;
 }
 
+static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
+        Link *link = userdata;
+        int r;
+
+        assert(m);
+        assert(link);
+        assert(link->ifname);
+
+        if (link->state == LINK_STATE_FAILED)
+                return 1;
+
+        r = sd_rtnl_message_get_errno(m);
+        if (r < 0 && r != -ENOENT)
+                log_struct_link(LOG_WARNING, link,
+                                "MESSAGE=%s: could not drop route: %s",
+                                link->ifname, strerror(-r),
+                                "ERRNO=%d", -r,
+                                NULL);
+
+        return 0;
+}
+
 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
         Link *link = userdata;
         int r;
@@ -264,6 +345,7 @@ static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 
 static int link_enter_set_addresses(Link *link) {
         Address *ad;
+        struct in_addr a;
         int r;
 
         assert(link);
@@ -272,7 +354,8 @@ static int link_enter_set_addresses(Link *link) {
 
         link->state = LINK_STATE_SETTING_ADDRESSES;
 
-        if (!link->network->static_addresses && !link->dhcp_lease)
+        if (!link->network->static_addresses && !link->dhcp_lease &&
+                (!link->ipv4ll || sd_ipv4ll_get_address(link->ipv4ll, &a) < 0))
                 return link_enter_set_routes(link);
 
         log_debug_link(link, "setting addresses");
@@ -289,6 +372,42 @@ static int link_enter_set_addresses(Link *link) {
                 link->addr_messages ++;
         }
 
+        if (link->ipv4ll && !link->dhcp_lease) {
+                _cleanup_address_free_ Address *ll_addr = NULL;
+                struct in_addr addr;
+
+                r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
+                if (r < 0 && r != -ENOENT) {
+                        log_warning_link(link, "IPV4LL error: no address: %s",
+                                        strerror(-r));
+                        return r;
+                }
+
+                if (r != -ENOENT) {
+                        r = address_new_dynamic(&ll_addr);
+                        if (r < 0) {
+                                log_error_link(link, "Could not allocate address: %s", strerror(-r));
+                                return r;
+                        }
+
+                        ll_addr->family = AF_INET;
+                        ll_addr->in_addr.in = addr;
+                        ll_addr->prefixlen = 16;
+                        ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
+                        ll_addr->scope = RT_SCOPE_LINK;
+
+                        r = address_configure(ll_addr, 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;
@@ -356,7 +475,7 @@ static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdat
                                 "ERRNO=%d", -r,
                                 NULL);
 
-        return 1;
+        return 0;
 }
 
 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
@@ -384,11 +503,11 @@ static int set_hostname(sd_bus *bus, const char *hostname) {
 
         r = sd_bus_message_new_method_call(
                         bus,
+                        &m,
                         "org.freedesktop.hostname1",
                         "/org/freedesktop/hostname1",
                         "org.freedesktop.hostname1",
-                        "SetHostname",
-                        &m);
+                        "SetHostname");
         if (r < 0)
                 return r;
 
@@ -435,7 +554,8 @@ static int link_set_mtu(Link *link, uint32_t mtu) {
 
         log_debug_link(link, "setting MTU: %" PRIu32, mtu);
 
-        r = sd_rtnl_message_link_new(RTM_SETLINK, link->ifindex, &req);
+        r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
+                                     RTM_SETLINK, link->ifindex);
         if (r < 0) {
                 log_error_link(link, "Could not allocate RTM_SETLINK message");
                 return r;
@@ -467,6 +587,8 @@ static int dhcp_lease_lost(Link *link) {
         assert(link);
         assert(link->dhcp_lease);
 
+        log_warning_link(link, "DHCP lease lost");
+
         r = address_new_dynamic(&address);
         if (r >= 0) {
                 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
@@ -477,7 +599,7 @@ static int dhcp_lease_lost(Link *link) {
                 address->in_addr.in = addr;
                 address->prefixlen = prefixlen;
 
-                address_drop(address, link, address_drop_handler);
+                address_drop(address, link, &address_drop_handler);
         }
 
         if (link->network->dhcp_mtu) {
@@ -495,9 +617,14 @@ static int dhcp_lease_lost(Link *link) {
         }
 
         if (link->network->dhcp_hostname) {
-                r = set_hostname(link->manager->bus, "");
-                if (r < 0)
-                        log_error("Failed to reset transient hostname");
+                const char *hostname = NULL;
+
+                r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
+                if (r >= 0 && hostname) {
+                        r = set_hostname(link->manager->bus, "");
+                        if (r < 0)
+                                log_error("Failed to reset transient hostname");
+                }
         }
 
         link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
@@ -626,10 +753,12 @@ static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
                                 return;
                         }
 
-                        r = dhcp_lease_lost(link);
-                        if (r < 0) {
-                                link_enter_failed(link);
-                                return;
+                        if (link->dhcp_lease) {
+                                r = dhcp_lease_lost(link);
+                                if (r < 0) {
+                                        link_enter_failed(link);
+                                        return;
+                                }
                         }
 
                         if (event == DHCP_EVENT_IP_CHANGE) {
@@ -640,6 +769,14 @@ static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
                                 }
                         }
 
+                        if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
+                                r = sd_ipv4ll_start (link->ipv4ll);
+                                if (r < 0) {
+                                        link_enter_failed(link);
+                                        return;
+                                }
+                        }
+
                         break;
                 case DHCP_EVENT_IP_ACQUIRE:
                         r = dhcp_lease_acquired(client, link);
@@ -647,6 +784,13 @@ static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
                                 link_enter_failed(link);
                                 return;
                         }
+                        if (link->ipv4ll) {
+                                r = sd_ipv4ll_stop(link->ipv4ll);
+                                if (r < 0) {
+                                        link_enter_failed(link);
+                                        return;
+                                }
+                        }
                         break;
                 default:
                         if (event < 0)
@@ -659,49 +803,134 @@ static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
         return;
 }
 
+static int ipv4ll_address_lost(sd_ipv4ll *ll, Link *link) {
+        int r;
+        struct in_addr addr;
+
+        assert(ll);
+        assert(link);
+
+        r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
+        if (r >= 0) {
+                _cleanup_address_free_ Address *address = NULL;
+                _cleanup_route_free_ Route *route = NULL;
+
+                log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
+                                ADDRESS_FMT_VAL(addr));
+
+                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->prefixlen = 16;
+                address->scope = RT_SCOPE_LINK;
+
+                address_drop(address, link, &address_drop_handler);
+
+                r = route_new_dynamic(&route);
+                if (r < 0) {
+                        log_error_link(link, "Could not allocate route: %s",
+                                       strerror(-r));
+                        return r;
+                }
+
+                route->family = AF_INET;
+                route->scope = RT_SCOPE_LINK;
+                route->metrics = 99;
+
+                route_drop(route, link, &route_drop_handler);
+        }
+
+        return 0;
+}
+
+static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
+        struct in_addr address;
+        int r;
+
+        assert(ll);
+        assert(link);
+
+        r = sd_ipv4ll_get_address(ll, &address);
+        if (r < 0)
+                return r;
+
+        log_struct_link(LOG_INFO, link,
+                        "MESSAGE=%s: IPv4 link-local address %u.%u.%u.%u",
+                        link->ifname,
+                        ADDRESS_FMT_VAL(address),
+                        NULL);
+
+       link_enter_set_addresses(link);
+
+       return 0;
+}
+
+static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
+        Link *link = userdata;
+        int r;
+
+        assert(link);
+        assert(link->network);
+        assert(link->manager);
+
+        switch(event) {
+                case IPV4LL_EVENT_STOP:
+                case IPV4LL_EVENT_CONFLICT:
+                        r = ipv4ll_address_lost(ll, link);
+                        if (r < 0) {
+                                link_enter_failed(link);
+                                return;
+                        }
+                        break;
+                case IPV4LL_EVENT_BIND:
+                        r = ipv4ll_address_claimed(ll, link);
+                        if (r < 0) {
+                                link_enter_failed(link);
+                                return;
+                        }
+                        break;
+                default:
+                        if (event < 0)
+                                log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
+                        else
+                                log_warning_link(link, "IPv4 link-local unknown event: %d", event);
+                        break;
+        }
+}
+
 static int link_acquire_conf(Link *link) {
         int r;
 
         assert(link);
         assert(link->network);
-        assert(link->network->dhcp);
         assert(link->manager);
         assert(link->manager->event);
 
-        if (!link->dhcp_client) {
-                r = sd_dhcp_client_new(&link->dhcp_client);
-                if (r < 0)
-                        return r;
+        if (link->network->ipv4ll) {
+                assert(link->ipv4ll);
 
-                r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
-                if (r < 0)
-                        return r;
+                log_debug_link(link, "acquiring IPv4 link-local address");
 
-                r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
+                r = sd_ipv4ll_start(link->ipv4ll);
                 if (r < 0)
                         return r;
+        }
 
-                r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
-                if (r < 0)
-                        return r;
+        if (link->network->dhcp) {
+                assert(link->dhcp_client);
 
-                r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
+                log_debug_link(link, "acquiring DHCPv4 lease");
+
+                r = sd_dhcp_client_start(link->dhcp_client);
                 if (r < 0)
                         return r;
-
-                if (link->network->dhcp_mtu) {
-                        r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
-                        if (r < 0)
-                                return r;
-                }
         }
 
-        log_debug_link(link, "acquiring DHCPv4 lease");
-
-        r = sd_dhcp_client_start(link->dhcp_client);
-        if (r < 0)
-                return r;
-
         return 0;
 }
 
@@ -714,10 +943,11 @@ static int link_update_flags(Link *link, unsigned flags) {
         if (link->state == LINK_STATE_FAILED)
                 return 0;
 
-        if (link->flags == flags) {
-                log_debug_link(link, "link status unchanged: %#.8x", flags);
+        if (link->flags == flags)
                 return 0;
-        }
+
+        log_debug_link(link, "link status updated: %#.8x -> %#.8x",
+                       link->flags, flags);
 
         if ((link->flags & IFF_UP) != (flags & IFF_UP))
                 log_info_link(link,
@@ -727,10 +957,10 @@ static int link_update_flags(Link *link, unsigned flags) {
                 if (flags & IFF_LOWER_UP) {
                         log_info_link(link, "carrier on");
 
-                        if (link->network->dhcp) {
+                        if (link->network->dhcp || link->network->ipv4ll) {
                                 r = link_acquire_conf(link);
                                 if (r < 0) {
-                                        log_warning_link(link, "Could not acquire DHCPv4 lease: %s", strerror(-r));
+                                        log_warning_link(link, "Could not acquire configuration: %s", strerror(-r));
                                         link_enter_failed(link);
                                         return r;
                                 }
@@ -746,12 +976,18 @@ static int link_update_flags(Link *link, unsigned flags) {
                                         return r;
                                 }
                         }
+
+                        if (link->network->ipv4ll) {
+                                r = sd_ipv4ll_stop(link->ipv4ll);
+                                if (r < 0) {
+                                        log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
+                                        link_enter_failed(link);
+                                        return r;
+                                }
+                        }
                 }
         }
 
-        log_debug_link(link,
-                       "link status updated: %#.8x -> %#.8x", link->flags, flags);
-
         link->flags = flags;
 
         return 0;
@@ -767,18 +1003,14 @@ static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
                 return 1;
 
         r = sd_rtnl_message_get_errno(m);
-        if (r < 0) {
-                log_struct_link(LOG_ERR, link,
+        if (r >= 0)
+                link_update_flags(link, link->flags | IFF_UP);
+        else
+                log_struct_link(LOG_WARNING, link,
                                 "MESSAGE=%s: could not bring up interface: %s",
                                 link->ifname, strerror(-r),
                                 "ERRNO=%d", -r,
                                 NULL);
-                link_enter_failed(link);
-                return 1;
-        }
-
-        link_update_flags(link, link->flags | IFF_UP);
-
         return 1;
 }
 
@@ -792,7 +1024,8 @@ static int link_up(Link *link) {
 
         log_debug_link(link, "bringing link up");
 
-        r = sd_rtnl_message_link_new(RTM_SETLINK, link->ifindex, &req);
+        r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
+                                     RTM_SETLINK, link->ifindex);
         if (r < 0) {
                 log_error_link(link, "Could not allocate RTM_SETLINK message");
                 return r;
@@ -827,7 +1060,7 @@ static int link_enslaved(Link *link) {
                 return r;
         }
 
-        if (!link->network->dhcp)
+        if (!link->network->dhcp && !link->network->ipv4ll)
                 return link_enter_set_addresses(link);
 
         return 0;
@@ -866,7 +1099,7 @@ static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 }
 
 static int link_enter_enslave(Link *link) {
-        NetDev *vlan;
+        NetDev *vlan, *macvlan;
         Iterator i;
         int r;
 
@@ -876,8 +1109,11 @@ static int link_enter_enslave(Link *link) {
 
         link->state = LINK_STATE_ENSLAVING;
 
+        link_save(link);
+
         if (!link->network->bridge && !link->network->bond &&
-            hashmap_isempty(link->network->vlans))
+            hashmap_isempty(link->network->vlans) &&
+            hashmap_isempty(link->network->macvlans))
                 return link_enslaved(link);
 
         if (link->network->bridge) {
@@ -901,6 +1137,27 @@ static int link_enter_enslave(Link *link) {
                 link->enslaving ++;
         }
 
+        if (link->network->bond) {
+                log_struct_link(LOG_DEBUG, link,
+                                "MESSAGE=%s: enslaving by '%s'",
+                                link->ifname, link->network->bond->name,
+                                NETDEV(link->network->bond),
+                                NULL);
+
+                r = netdev_enslave(link->network->bond, link, &enslave_handler);
+                if (r < 0) {
+                        log_struct_link(LOG_WARNING, link,
+                                        "MESSAGE=%s: could not enslave by '%s': %s",
+                                        link->ifname, link->network->bond->name, strerror(-r),
+                                        NETDEV(link->network->bond),
+                                        NULL);
+                        link_enter_failed(link);
+                        return r;
+                }
+
+                link->enslaving ++;
+        }
+
         HASHMAP_FOREACH(vlan, link->network->vlans, i) {
                 log_struct_link(LOG_DEBUG, link,
                                 "MESSAGE=%s: enslaving by '%s'",
@@ -919,10 +1176,29 @@ static int link_enter_enslave(Link *link) {
                 link->enslaving ++;
         }
 
+        HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
+                log_struct_link(LOG_DEBUG, link,
+                                "MESSAGE=%s: enslaving by '%s'",
+                                link->ifname, macvlan->name, NETDEV(macvlan), NULL);
+
+                r = netdev_enslave(macvlan, link, &enslave_handler);
+                if (r < 0) {
+                        log_struct_link(LOG_WARNING, link,
+                                        "MESSAGE=%s: could not enslave by '%s': %s",
+                                        link->ifname, macvlan->name, strerror(-r),
+                                        NETDEV(macvlan), NULL);
+                        link_enter_failed(link);
+                        return r;
+                }
+
+                link->enslaving ++;
+        }
+
         return 0;
 }
 
-static int link_get_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
+static int link_getlink_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
+                                void *userdata) {
         Link *link = userdata;
         int r;
 
@@ -942,14 +1218,12 @@ static int link_get_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
                 return 1;
         }
 
-        log_debug_link(link, "got link state");
-
         link_update(link, m);
 
         return 1;
 }
 
-static int link_get(Link *link) {
+static int link_getlink(Link *link) {
         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
         int r;
 
@@ -959,13 +1233,15 @@ static int link_get(Link *link) {
 
         log_debug_link(link, "requesting link status");
 
-        r = sd_rtnl_message_link_new(RTM_GETLINK, link->ifindex, &req);
+        r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
+                                     RTM_GETLINK, link->ifindex);
         if (r < 0) {
                 log_error_link(link, "Could not allocate RTM_GETLINK message");
                 return r;
         }
 
-        r = sd_rtnl_call_async(link->manager->rtnl, req, link_get_handler, link, 0, NULL);
+        r = sd_rtnl_call_async(link->manager->rtnl, req, link_getlink_handler,
+                               link, 0, NULL);
         if (r < 0) {
                 log_error_link(link,
                                "Could not send rtnetlink message: %s", strerror(-r));
@@ -975,48 +1251,217 @@ static int link_get(Link *link) {
         return 0;
 }
 
-int link_configure(Link *link) {
+static int link_configure(Link *link) {
         int r;
 
         assert(link);
-        assert(link->network);
         assert(link->state == _LINK_STATE_INVALID);
 
-        r = link_get(link);
-        if (r < 0) {
-                link_enter_failed(link);
+        r = link_getlink(link);
+        if (r < 0)
                 return r;
-        }
 
         return link_enter_enslave(link);
 }
 
+int link_add(Manager *m, struct udev_device *device, Link **ret) {
+        Link *link = NULL;
+        Network *network;
+        int r;
+
+        assert(m);
+        assert(device);
+
+        r = link_new(m, device, &link);
+        if (r < 0)
+                return r;
+
+        *ret = link;
+
+        r = network_get(m, device, &network);
+        if (r < 0)
+                return r == -ENOENT ? 0 : r;
+
+        r = network_apply(m, network, link);
+        if (r < 0)
+                return r;
+
+        if (link->network->ipv4ll) {
+                uint8_t seed[8];
+                r = sd_ipv4ll_new(&link->ipv4ll);
+                if (r < 0)
+                        return r;
+
+                r = net_get_unique_predictable_data(link->udev_device, seed);
+                if (r >= 0) {
+                        r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
+                        if (r < 0)
+                                return r;
+                }
+
+                r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
+                if (r < 0)
+                        return r;
+
+                r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
+                if (r < 0)
+                        return r;
+
+                r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
+                if (r < 0)
+                        return r;
+        }
+
+        if (link->network->dhcp) {
+                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_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;
+
+                if (link->network->dhcp_mtu) {
+                        r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
+                        if (r < 0)
+                                return r;
+                }
+        }
+
+        r = link_configure(link);
+        if (r < 0)
+                return r;
+
+        return 0;
+}
+
 int link_update(Link *link, sd_rtnl_message *m) {
         unsigned flags;
-        void *data;
-        uint16_t type;
+        struct ether_addr mac;
         int r;
 
         assert(link);
+        assert(link->network);
         assert(m);
 
         if (link->state == LINK_STATE_FAILED)
                 return 0;
 
+        if (link->network->dhcp && link->network->dhcp_mtu &&
+            !link->original_mtu) {
+                r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
+                if (r >= 0)
+                        log_debug_link(link, "saved original MTU: %"
+                                       PRIu16, link->original_mtu);
+        }
+
+        r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
+        if (r >= 0 && memcmp(&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",
+                                mac.ether_addr_octet[0],
+                                mac.ether_addr_octet[1],
+                                mac.ether_addr_octet[2],
+                                mac.ether_addr_octet[3],
+                                mac.ether_addr_octet[4],
+                                mac.ether_addr_octet[5]);
+
+                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",
+                                                 strerror(-r));
+                                return r;
+                        }
+                }
+
+                if (link->dhcp_client) {
+                        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",
+                                                 strerror(-r));
+                                return r;
+                        }
+                }
+        }
+
         r = sd_rtnl_message_link_get_flags(m, &flags);
         if (r < 0) {
                 log_warning_link(link, "Could not get link flags");
                 return r;
         }
 
-        while (sd_rtnl_message_read(m, &type, &data) > 0) {
-                if (type == IFLA_MTU && link->network->dhcp &&
-                    link->network->dhcp_mtu && !link->original_mtu) {
-                        link->original_mtu = *(uint16_t *) data;
-                        log_debug_link(link, "saved original MTU: %" PRIu16,
-                                       link->original_mtu);
-                }
+        return link_update_flags(link, flags);
+}
+
+int link_save(Link *link) {
+        _cleanup_free_ char *temp_path = NULL;
+        _cleanup_fclose_ FILE *f = NULL;
+        int r;
+
+        assert(link);
+        assert(link->state_file);
+
+        r = fopen_temporary(link->state_file, &f, &temp_path);
+        if (r < 0)
+                goto finish;
+
+        fchmod(fileno(f), 0644);
+
+        fprintf(f,
+                "# This is private data. Do not parse.\n"
+                "STATE=%s\n",
+                link_state_to_string(link->state));
+
+        if (link->dhcp_lease) {
+                _cleanup_free_ char *lease_file = NULL;
+
+                r = asprintf(&lease_file, "/run/systemd/network/leases/%"PRIu64,
+                             link->ifindex);
+                if (r < 0)
+                        return -ENOMEM;
+
+                r = dhcp_lease_save(link->dhcp_lease, lease_file);
+                if (r < 0)
+                        goto finish;
+
+                fprintf(f, "DHCP_LEASE=%s\n", lease_file);
         }
 
-        return link_update_flags(link, flags);
+        fflush(f);
+
+        if (ferror(f) || rename(temp_path, link->state_file) < 0) {
+                r = -errno;
+                unlink(link->state_file);
+                unlink(temp_path);
+        }
+
+finish:
+        if (r < 0)
+                log_error("Failed to save link data %s: %s", link->state_file, strerror(-r));
+
+        return r;
 }
+
+static const char* const link_state_table[_LINK_STATE_MAX] = {
+        [LINK_STATE_ENSLAVING] = "configuring",
+        [LINK_STATE_SETTING_ADDRESSES] = "configuring",
+        [LINK_STATE_SETTING_ROUTES] = "configuring",
+        [LINK_STATE_CONFIGURED] = "configured",
+        [LINK_STATE_FAILED] = "failed",
+};
+
+DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);