core: use NML3ConfigData (WIP)next2

1 files changed, 219 insertions, 213 deletions

diff --git a/src/core/dhcp/nm-dhcp-client.c b/src/core/dhcp/nm-dhcp-client.c
index f88c79c0be..10d1291023 100644
--- a/src/core/dhcp/nm-dhcp-client.c
+++ b/src/core/dhcp/nm-dhcp-client.c
@@ -20,6 +20,7 @@
 
 #include "NetworkManagerUtils.h"
 #include "nm-utils.h"
+#include "nm-l3-config-data.h"
 #include "nm-dhcp-utils.h"
 #include "nm-dhcp-options.h"
 #include "libnm-platform/nm-platform.h"
@@ -41,9 +42,7 @@ NM_GOBJECT_PROPERTIES_DEFINE(NMDhcpClient,
                              PROP_IFACE,
                              PROP_IFINDEX,
                              PROP_MULTI_IDX,
-                             PROP_ROUTE_METRIC,
-                             PROP_ROUTE_TABLE,
-                             PROP_TIMEOUT,
+                             PROP_NO_LEASE_TIMEOUT,
                              PROP_UUID,
                              PROP_IAID,
                              PROP_IAID_EXPLICIT,
@@ -54,31 +53,31 @@ NM_GOBJECT_PROPERTIES_DEFINE(NMDhcpClient,
                              PROP_REJECT_SERVERS, );
 
 typedef struct _NMDhcpClientPrivate {
-    NMDedupMultiIndex * multi_idx;
-    char *              iface;
-    GBytes *            hwaddr;
-    GBytes *            bcast_hwaddr;
-    char *              uuid;
-    GBytes *            client_id;
-    char *              hostname;
-    const char **       reject_servers;
-    char *              mud_url;
-    char *              anycast_address;
-    GBytes *            vendor_class_identifier;
-    pid_t               pid;
-    guint               timeout_id;
-    guint               watch_id;
-    int                 addr_family;
-    int                 ifindex;
-    guint32             route_table;
-    guint32             route_metric;
-    guint32             timeout;
-    guint32             iaid;
-    NMDhcpState         state;
-    NMDhcpHostnameFlags hostname_flags;
-    NMDhcpClientFlags   client_flags;
-    bool                iaid_explicit : 1;
-    bool                is_stopped : 1;
+    NMDedupMultiIndex *   multi_idx;
+    char *                iface;
+    GBytes *              hwaddr;
+    GBytes *              bcast_hwaddr;
+    char *                uuid;
+    GBytes *              client_id;
+    char *                hostname;
+    const char **         reject_servers;
+    char *                mud_url;
+    char *                anycast_address;
+    GBytes *              vendor_class_identifier;
+    const NML3ConfigData *l3cd;
+    GSource *             no_lease_timeout_source;
+    pid_t                 pid;
+    guint                 timeout_id;
+    guint                 watch_id;
+    int                   addr_family;
+    int                   ifindex;
+    guint                 no_lease_timeout;
+    guint32               iaid;
+    NMDhcpState           state;
+    NMDhcpHostnameFlags   hostname_flags;
+    NMDhcpClientFlags     client_flags;
+    bool                  iaid_explicit : 1;
+    bool                  is_stopped : 1;
 } NMDhcpClientPrivate;
 
 G_DEFINE_ABSTRACT_TYPE(NMDhcpClient, nm_dhcp_client, G_TYPE_OBJECT)
@@ -98,25 +97,6 @@ _emit_notify(NMDhcpClient *self, const NMDhcpClientNotifyData *notify_data)
     g_signal_emit(G_OBJECT(self), signals[SIGNAL_NOTIFY], 0, notify_data);
 }
 
-static void
-_emit_notify_state_changed(NMDhcpClient *self,
-                           NMDhcpState   dhcp_state,
-                           NMIPConfig *  ip_config,
-                           GHashTable *  options)
-{
-    const NMDhcpClientNotifyData notify_data = {
-        .notify_type = NM_DHCP_CLIENT_NOTIFY_TYPE_STATE_CHANGED,
-        .state_changed =
-            {
-                .dhcp_state = dhcp_state,
-                .ip_config  = ip_config,
-                .options    = options,
-            },
-    };
-
-    _emit_notify(self, &notify_data);
-}
-
 /*****************************************************************************/
 
 pid_t
@@ -184,52 +164,6 @@ nm_dhcp_client_get_broadcast_hw_addr(NMDhcpClient *self)
 }
 
 guint32
-nm_dhcp_client_get_route_table(NMDhcpClient *self)
-{
-    g_return_val_if_fail(NM_IS_DHCP_CLIENT(self), RT_TABLE_MAIN);
-
-    return NM_DHCP_CLIENT_GET_PRIVATE(self)->route_table;
-}
-
-void
-nm_dhcp_client_set_route_table(NMDhcpClient *self, guint32 route_table)
-{
-    NMDhcpClientPrivate *priv = NM_DHCP_CLIENT_GET_PRIVATE(self);
-
-    if (route_table != priv->route_table) {
-        priv->route_table = route_table;
-        _notify(self, PROP_ROUTE_TABLE);
-    }
-}
-
-guint32
-nm_dhcp_client_get_route_metric(NMDhcpClient *self)
-{
-    g_return_val_if_fail(NM_IS_DHCP_CLIENT(self), G_MAXUINT32);
-
-    return NM_DHCP_CLIENT_GET_PRIVATE(self)->route_metric;
-}
-
-void
-nm_dhcp_client_set_route_metric(NMDhcpClient *self, guint32 route_metric)
-{
-    NMDhcpClientPrivate *priv = NM_DHCP_CLIENT_GET_PRIVATE(self);
-
-    if (route_metric != priv->route_metric) {
-        priv->route_metric = route_metric;
-        _notify(self, PROP_ROUTE_METRIC);
-    }
-}
-
-guint32
-nm_dhcp_client_get_timeout(NMDhcpClient *self)
-{
-    g_return_val_if_fail(NM_IS_DHCP_CLIENT(self), 0);
-
-    return NM_DHCP_CLIENT_GET_PRIVATE(self)->timeout;
-}
-
-guint32
 nm_dhcp_client_get_iaid(NMDhcpClient *self)
 {
     g_return_val_if_fail(NM_IS_DHCP_CLIENT(self), 0);
@@ -462,73 +396,149 @@ stop(NMDhcpClient *self, gboolean release)
     priv->pid = -1;
 }
 
-void
-nm_dhcp_client_set_state(NMDhcpClient *self,
-                         NMDhcpState   new_state,
-                         NMIPConfig *  ip_config,
-                         GHashTable *  options)
+static gboolean
+_no_lease_timeout(gpointer user_data)
 {
+    NMDhcpClient *       self = user_data;
     NMDhcpClientPrivate *priv = NM_DHCP_CLIENT_GET_PRIVATE(self);
 
+    nm_clear_g_source_inst(&priv->no_lease_timeout_source);
+
+    _emit_notify(self,
+                 &((NMDhcpClientNotifyData){
+                     .notify_type = NM_DHCP_CLIENT_NOTIFY_TYPE_NO_LEASE_TIMEOUT,
+                 }));
+    return G_SOURCE_CONTINUE;
+}
+
+void
+nm_dhcp_client_set_state(NMDhcpClient *self, NMDhcpState new_state, const NML3ConfigData *l3cd)
+{
+    NMDhcpClientPrivate *    priv = NM_DHCP_CLIENT_GET_PRIVATE(self);
+    GHashTable *             options;
+    const int                IS_IPv4                     = NM_IS_IPv4(priv->addr_family);
+    nm_auto_unref_l3cd const NML3ConfigData *l3cd_merged = NULL;
+
+    g_return_if_fail(NM_IS_DHCP_CLIENT(self));
+
     if (NM_IN_SET(new_state, NM_DHCP_STATE_BOUND, NM_DHCP_STATE_EXTENDED)) {
-        g_return_if_fail(NM_IS_IP_CONFIG_ADDR_FAMILY(ip_config, priv->addr_family));
-        g_return_if_fail(options);
-    } else {
-        g_return_if_fail(!ip_config);
-        g_return_if_fail(!options);
-    }
+        g_return_if_fail(NM_IS_L3_CONFIG_DATA(l3cd));
+        g_return_if_fail(
+            nm_l3_config_data_get_dhcp_lease(l3cd, nm_dhcp_client_get_addr_family(self)));
+    } else
+        g_return_if_fail(!l3cd);
+
+    if (l3cd)
+        nm_l3_config_data_seal(l3cd);
 
     if (new_state >= NM_DHCP_STATE_BOUND)
         timeout_cleanup(self);
     if (new_state >= NM_DHCP_STATE_TIMEOUT)
         watch_cleanup(self);
 
-    /* The client may send same-state transitions for RENEW/REBIND events and
-     * the lease may have changed, so handle same-state transitions for the
-     * EXTENDED and BOUND states.  Ignore same-state transitions for other
-     * events since the lease won't have changed and the state was already handled.
-     */
-    if ((priv->state == new_state)
-        && !NM_IN_SET(new_state, NM_DHCP_STATE_BOUND, NM_DHCP_STATE_EXTENDED))
-        return;
+    if (!IS_IPv4 && l3cd) {
+        if (nm_dhcp_utils_merge_new_dhcp6_lease(priv->l3cd, l3cd, &l3cd_merged)) {
+            l3cd = nm_l3_config_data_seal(l3cd_merged);
+        }
+    }
 
-    if (_LOGD_ENABLED()) {
-        gs_free const char **keys = NULL;
-        guint                i, nkeys;
+    if (priv->l3cd == l3cd)
+        return;
 
-        keys = nm_strdict_get_keys(options, TRUE, &nkeys);
-        for (i = 0; i < nkeys; i++) {
-            _LOGD("option %-20s => '%s'", keys[i], (char *) g_hash_table_lookup(options, keys[i]));
+    if (l3cd)
+        nm_clear_g_source_inst(&priv->no_lease_timeout_source);
+    else {
+        /* FIXME(next:dhcp): we also need to start no_lease_timeout initially, if the
+         * instance starts without a previous_lease. */
+        if (!priv->no_lease_timeout_source && priv->l3cd) {
+            if (priv->no_lease_timeout == NM_DHCP_TIMEOUT_INFINITY)
+                priv->no_lease_timeout_source = g_source_ref(nm_g_source_sentinel_get(0));
+            else {
+                priv->no_lease_timeout_source =
+                    nm_g_timeout_add_source_seconds(priv->no_lease_timeout,
+                                                    _no_lease_timeout,
+                                                    self);
+            }
         }
     }
 
-    if (_LOGT_ENABLED() && priv->addr_family == AF_INET6) {
-        gs_free char *event_id = NULL;
+    /* FIXME(next:dhcp): the API of NMDhcpClient is changing to expose a simpler API.
+     * The internals like NMDhcpState should not be exposed (or possibly dropped in large
+     * parts). */
+
+    nm_l3_config_data_reset(&priv->l3cd, l3cd);
+
+    options =
+        l3cd ? nm_dhcp_lease_get_options(nm_l3_config_data_get_dhcp_lease(l3cd, priv->addr_family))
+             : NULL;
+
+    if (_LOGD_ENABLED()) {
+        if (options) {
+            gs_free const char **keys = NULL;
+            guint                nkeys;
+            guint                i;
+
+            keys = nm_strdict_get_keys(options, TRUE, &nkeys);
+            for (i = 0; i < nkeys; i++) {
+                _LOGD("option %-20s => '%s'",
+                      keys[i],
+                      (char *) g_hash_table_lookup(options, keys[i]));
+            }
+
+            if (priv->addr_family == AF_INET6) {
+                gs_free char *event_id = NULL;
 
-        event_id = nm_dhcp_utils_get_dhcp6_event_id(options);
-        if (event_id)
-            _LOGT("event-id: \"%s\"", event_id);
+                event_id = nm_dhcp_utils_get_dhcp6_event_id(options);
+                if (event_id)
+                    _LOGT("event-id: \"%s\"", event_id);
+            }
+        }
     }
 
     if (_LOGI_ENABLED()) {
         const char *req_str =
-            NM_IS_IPv4(priv->addr_family)
-                ? nm_dhcp_option_request_string(AF_INET, NM_DHCP_OPTION_DHCP4_NM_IP_ADDRESS)
-                : nm_dhcp_option_request_string(AF_INET6, NM_DHCP_OPTION_DHCP6_NM_IP_ADDRESS);
+            IS_IPv4 ? nm_dhcp_option_request_string(AF_INET, NM_DHCP_OPTION_DHCP4_NM_IP_ADDRESS)
+                    : nm_dhcp_option_request_string(AF_INET6, NM_DHCP_OPTION_DHCP6_NM_IP_ADDRESS);
         const char *addr = nm_g_hash_table_lookup(options, req_str);
 
-        _LOGI("state changed %s -> %s%s%s%s",
-              nm_dhcp_state_to_string(priv->state),
-              nm_dhcp_state_to_string(new_state),
+        _LOGI("state changed %s%s%s%s",
+              priv->l3cd ? "new lease" : "no lease",
               NM_PRINT_FMT_QUOTED(addr, ", address=", addr, "", ""));
     }
 
-    priv->state = new_state;
+    /* FIXME(next:dhcp:acd): NMDhcpClient must also do ACD. It needs acd_timeout_msec
+     * as a configuration parameter (in NMDhcpClientConfig). When ACD is enabled,
+     * when a new lease gets announced, it must first use NML3Cfg to run ACD on the
+     * interface (the previous lease -- if any -- will still be used at that point).
+     * If ACD fails, we call nm_dhcp_client_decline() and try to get a different
+     * lease.
+     * If ACD passes, we need to notify the new lease, and the user (NMDevice) may
+     * then configure the address. We need to watch the configured addresses (in NML3Cfg),
+     * and if the address appears there, we need to accept the lease. That is complicated
+     * but necessary, because we can only accept the lease after we configured the
+     * address.
+     *
+     * As a whole, ACD is transparent for the user (NMDevice). It's entirely managed
+     * by NMDhcpClient. Note that we do ACD through NML3Cfg, which centralizes IP handling
+     * for one interface, so for example if the same address happens to be configured
+     * as a static address (bypassing ACD), then NML3Cfg is aware of that and signals
+     * immediate success. */
 
-    _emit_notify_state_changed(self, new_state, ip_config, options);
+    {
+        const NMDhcpClientNotifyData notify_data = {
+            .notify_type = NM_DHCP_CLIENT_NOTIFY_TYPE_LEASE_UPDATE,
+            .lease_update =
+                {
+                    .l3cd = priv->l3cd,
+                },
+        };
+
+        _emit_notify(self, &notify_data);
+    }
 }
 
-static gboolean
+/* FIXME(next:dhcp) */
+_nm_unused static gboolean
 transaction_timeout(gpointer user_data)
 {
     NMDhcpClient *       self = NM_DHCP_CLIENT(user_data);
@@ -536,7 +546,7 @@ transaction_timeout(gpointer user_data)
 
     priv->timeout_id = 0;
     _LOGW("request timed out");
-    nm_dhcp_client_set_state(self, NM_DHCP_STATE_TIMEOUT, NULL, NULL);
+    nm_dhcp_client_set_state(self, NM_DHCP_STATE_TIMEOUT, NULL);
     return G_SOURCE_REMOVE;
 }
 
@@ -554,7 +564,7 @@ daemon_watch_cb(GPid pid, int status, gpointer user_data)
 
     priv->pid = -1;
 
-    nm_dhcp_client_set_state(self, NM_DHCP_STATE_TERMINATED, NULL, NULL);
+    nm_dhcp_client_set_state(self, NM_DHCP_STATE_TERMINATED, NULL);
 }
 
 void
@@ -566,10 +576,10 @@ nm_dhcp_client_start_timeout(NMDhcpClient *self)
 
     /* Set up a timeout on the transaction to kill it after the timeout */
 
-    if (priv->timeout == NM_DHCP_TIMEOUT_INFINITY)
-        return;
-
-    priv->timeout_id = g_timeout_add_seconds(priv->timeout, transaction_timeout, self);
+    /* FIXME(next:dhcp): no-lease-timeout is only for convenience for the user (NMDevice).
+     * Whatever the purpose of nm_dhcp_client_start_timeout() is, it is not the same timer. */
+    return;
+    //priv->timeout_id = g_timeout_add_seconds(priv->no_lease_timeout, transaction_timeout, self);
 }
 
 void
@@ -613,10 +623,19 @@ nm_dhcp_client_start_ip4(NMDhcpClient *self,
     g_return_val_if_fail(priv->addr_family == AF_INET, FALSE);
     g_return_val_if_fail(priv->uuid != NULL, FALSE);
 
-    if (priv->timeout == NM_DHCP_TIMEOUT_INFINITY)
+    /* FIXME(next:dhcp:ipv6ll): for IPv6, NMDhcpClient needs to wait that
+     * a IPv6 LL address appears. The user (NMDevice) will start the generation
+     * of a LL address, but NMDhcpClient is already running and is just waiting.
+     *
+     * All the while, NM_DHCP_CLIENT_NO_LEASE_TIMEOUT is ticking. If the LL address
+     * does not appear in (e.g. 5 seconds), a NM_DHCP_CLIENT_NOTIFY_TYPE_IT_LOOKS_BAD signal
+     * can be emitted. */
+
+    if (priv->no_lease_timeout == NM_DHCP_TIMEOUT_INFINITY)
         _LOGI("activation: beginning transaction (no timeout)");
     else
-        _LOGI("activation: beginning transaction (timeout in %u seconds)", (guint) priv->timeout);
+        _LOGI("activation: beginning transaction (timeout in %u seconds)",
+              (guint) priv->no_lease_timeout);
 
     nm_dhcp_client_set_client_id(self, client_id);
 
@@ -626,8 +645,14 @@ nm_dhcp_client_start_ip4(NMDhcpClient *self,
 gboolean
 nm_dhcp_client_accept(NMDhcpClient *self, GError **error)
 {
+    NMDhcpClientPrivate *priv;
+
     g_return_val_if_fail(NM_IS_DHCP_CLIENT(self), FALSE);
 
+    priv = NM_DHCP_CLIENT_GET_PRIVATE(self);
+
+    g_return_val_if_fail(priv->l3cd, FALSE);
+
     if (NM_DHCP_CLIENT_GET_CLASS(self)->accept) {
         return NM_DHCP_CLIENT_GET_CLASS(self)->accept(self, error);
     }
@@ -652,8 +677,14 @@ nm_dhcp_client_can_accept(NMDhcpClient *self)
 gboolean
 nm_dhcp_client_decline(NMDhcpClient *self, const char *error_message, GError **error)
 {
+    NMDhcpClientPrivate *priv;
+
     g_return_val_if_fail(NM_IS_DHCP_CLIENT(self), FALSE);
 
+    priv = NM_DHCP_CLIENT_GET_PRIVATE(self);
+
+    g_return_val_if_fail(priv->l3cd, FALSE);
+
     if (NM_DHCP_CLIENT_GET_CLASS(self)->decline) {
         return NM_DHCP_CLIENT_GET_CLASS(self)->decline(self, error_message, error);
     }
@@ -694,10 +725,11 @@ nm_dhcp_client_start_ip6(NMDhcpClient *            self,
 
     _set_client_id(self, own_client_id ?: client_id, FALSE);
 
-    if (priv->timeout == NM_DHCP_TIMEOUT_INFINITY)
+    if (priv->no_lease_timeout == NM_DHCP_TIMEOUT_INFINITY)
         _LOGI("activation: beginning transaction (no timeout)");
     else
-        _LOGI("activation: beginning transaction (timeout in %u seconds)", (guint) priv->timeout);
+        _LOGI("activation: beginning transaction (timeout in %u seconds)",
+              (guint) priv->no_lease_timeout);
 
     return NM_DHCP_CLIENT_GET_CLASS(self)->ip6_start(self,
                                                      ll_addr,
@@ -789,7 +821,7 @@ nm_dhcp_client_stop(NMDhcpClient *self, gboolean release)
         _LOGI("canceled DHCP transaction");
     nm_assert(priv->pid == -1);
 
-    nm_dhcp_client_set_state(self, NM_DHCP_STATE_TERMINATED, NULL, NULL);
+    nm_dhcp_client_set_state(self, NM_DHCP_STATE_TERMINATED, NULL);
 }
 
 /*****************************************************************************/
@@ -921,12 +953,10 @@ nm_dhcp_client_handle_event(gpointer      unused,
                             const char *  reason,
                             NMDhcpClient *self)
 {
-    NMDhcpClientPrivate *priv;
-    guint32              old_state;
-    guint32              new_state;
-    gs_unref_hashtable GHashTable *str_options = NULL;
-    gs_unref_object NMIPConfig *ip_config      = NULL;
-    NMPlatformIP6Address        prefix         = {
+    NMDhcpClientPrivate *   priv;
+    guint32                 new_state;
+    nm_auto_unref_l3cd_init NML3ConfigData *l3cd   = NULL;
+    NMPlatformIP6Address                    prefix = {
         0,
     };
 
@@ -943,20 +973,21 @@ nm_dhcp_client_handle_event(gpointer      unused,
     if (priv->pid != pid)
         return FALSE;
 
-    old_state = priv->state;
     new_state = reason_to_state(self, priv->iface, reason);
+    if (new_state == NM_DHCP_STATE_NOOP)
+        return TRUE;
+
     _LOGD("DHCP state '%s' -> '%s' (reason: '%s')",
-          nm_dhcp_state_to_string(old_state),
+          nm_dhcp_state_to_string(priv->state),
           nm_dhcp_state_to_string(new_state),
           reason);
-
-    if (new_state == NM_DHCP_STATE_NOOP)
-        return TRUE;
+    priv->state = new_state;
 
     if (NM_IN_SET(new_state, NM_DHCP_STATE_BOUND, NM_DHCP_STATE_EXTENDED)) {
-        GVariantIter iter;
-        const char * name;
-        GVariant *   value;
+        gs_unref_hashtable GHashTable *str_options = NULL;
+        GVariantIter                   iter;
+        const char *                   name;
+        GVariant *                     value;
 
         /* Copy options */
         str_options = g_hash_table_new_full(nm_str_hash, g_str_equal, g_free, g_free);
@@ -969,24 +1000,27 @@ nm_dhcp_client_handle_event(gpointer      unused,
         /* Create the IP config */
         if (g_hash_table_size(str_options) > 0) {
             if (priv->addr_family == AF_INET) {
-                ip_config = NM_IP_CONFIG_CAST(
-                    nm_dhcp_utils_ip4_config_from_options(nm_dhcp_client_get_multi_idx(self),
-                                                          priv->ifindex,
-                                                          priv->iface,
-                                                          str_options,
-                                                          priv->route_table,
-                                                          priv->route_metric));
+                l3cd = nm_dhcp_utils_ip4_config_from_options(nm_dhcp_client_get_multi_idx(self),
+                                                             priv->ifindex,
+                                                             priv->iface,
+                                                             str_options);
             } else {
-                prefix    = nm_dhcp_utils_ip6_prefix_from_options(str_options);
-                ip_config = NM_IP_CONFIG_CAST(nm_dhcp_utils_ip6_config_from_options(
+                prefix = nm_dhcp_utils_ip6_prefix_from_options(str_options);
+                l3cd   = nm_dhcp_utils_ip6_config_from_options(
                     nm_dhcp_client_get_multi_idx(self),
                     priv->ifindex,
                     priv->iface,
                     str_options,
-                    NM_FLAGS_HAS(priv->client_flags, NM_DHCP_CLIENT_FLAGS_INFO_ONLY)));
+                    NM_FLAGS_HAS(priv->client_flags, NM_DHCP_CLIENT_FLAGS_INFO_ONLY));
             }
         } else
             g_warn_if_reached();
+
+        if (l3cd) {
+            nm_l3_config_data_set_dhcp_lease_from_options(l3cd,
+                                                          priv->addr_family,
+                                                          g_steal_pointer(&str_options));
+        }
     }
 
     if (!IN6_IS_ADDR_UNSPECIFIED(&prefix.address)) {
@@ -994,17 +1028,16 @@ nm_dhcp_client_handle_event(gpointer      unused,
          * of the DHCP client instance. Instead, we just signal the prefix
          * to the device. */
         nm_dhcp_client_emit_ipv6_prefix_delegated(self, &prefix);
-    } else {
-        /* Fail if no valid IP config was received */
-        if (NM_IN_SET(new_state, NM_DHCP_STATE_BOUND, NM_DHCP_STATE_EXTENDED) && !ip_config) {
-            _LOGW("client bound but IP config not received");
-            new_state = NM_DHCP_STATE_FAIL;
-            nm_clear_pointer(&str_options, g_hash_table_unref);
-        }
+        return TRUE;
+    }
 
-        nm_dhcp_client_set_state(self, new_state, ip_config, str_options);
+    /* Fail if no valid IP config was received */
+    if (NM_IN_SET(new_state, NM_DHCP_STATE_BOUND, NM_DHCP_STATE_EXTENDED) && !l3cd) {
+        _LOGW("client bound but IP config not received");
+        new_state = NM_DHCP_STATE_FAIL;
     }
 
+    nm_dhcp_client_set_state(self, new_state, l3cd);
     return TRUE;
 }
 
@@ -1075,14 +1108,8 @@ get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
     case PROP_HOSTNAME:
         g_value_set_string(value, priv->hostname);
         break;
-    case PROP_ROUTE_METRIC:
-        g_value_set_uint(value, priv->route_metric);
-        break;
-    case PROP_ROUTE_TABLE:
-        g_value_set_uint(value, priv->route_table);
-        break;
-    case PROP_TIMEOUT:
-        g_value_set_uint(value, priv->timeout);
+    case PROP_NO_LEASE_TIMEOUT:
+        g_value_set_uint(value, priv->no_lease_timeout);
         break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
@@ -1163,15 +1190,9 @@ set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *ps
         /* construct-only */
         priv->mud_url = g_value_dup_string(value);
         break;
-    case PROP_ROUTE_TABLE:
-        priv->route_table = g_value_get_uint(value);
-        break;
-    case PROP_ROUTE_METRIC:
-        priv->route_metric = g_value_get_uint(value);
-        break;
-    case PROP_TIMEOUT:
+    case PROP_NO_LEASE_TIMEOUT:
         /* construct-only */
-        priv->timeout = g_value_get_uint(value);
+        priv->no_lease_timeout = g_value_get_uint(value);
         break;
     case PROP_VENDOR_CLASS_IDENTIFIER:
         /* construct-only */
@@ -1233,6 +1254,8 @@ dispose(GObject *object)
     watch_cleanup(self);
     timeout_cleanup(self);
 
+    nm_clear_g_source_inst(&priv->no_lease_timeout_source);
+
     nm_clear_g_free(&priv->iface);
     nm_clear_g_free(&priv->hostname);
     nm_clear_g_free(&priv->uuid);
@@ -1243,6 +1266,7 @@ dispose(GObject *object)
     nm_clear_pointer(&priv->hwaddr, g_bytes_unref);
     nm_clear_pointer(&priv->bcast_hwaddr, g_bytes_unref);
     nm_clear_pointer(&priv->vendor_class_identifier, g_bytes_unref);
+    nm_clear_l3cd(&priv->l3cd);
 
     G_OBJECT_CLASS(nm_dhcp_client_parent_class)->dispose(object);
 
@@ -1364,31 +1388,13 @@ nm_dhcp_client_class_init(NMDhcpClientClass *client_class)
                             NULL,
                             G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
 
-    obj_properties[PROP_ROUTE_TABLE] =
-        g_param_spec_uint(NM_DHCP_CLIENT_ROUTE_TABLE,
-                          "",
-                          "",
-                          0,
-                          G_MAXUINT32,
-                          RT_TABLE_MAIN,
-                          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
-
-    obj_properties[PROP_ROUTE_METRIC] =
-        g_param_spec_uint(NM_DHCP_CLIENT_ROUTE_METRIC,
-                          "",
-                          "",
-                          0,
-                          G_MAXUINT32,
-                          0,
-                          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
-
     G_STATIC_ASSERT_EXPR(G_MAXINT32 == NM_DHCP_TIMEOUT_INFINITY);
-    obj_properties[PROP_TIMEOUT] =
-        g_param_spec_uint(NM_DHCP_CLIENT_TIMEOUT,
+    obj_properties[PROP_NO_LEASE_TIMEOUT] =
+        g_param_spec_uint(NM_DHCP_CLIENT_NO_LEASE_TIMEOUT,
                           "",
                           "",
-                          1,
-                          G_MAXINT32,
+                          0,
+                          G_MAXUINT,
                           NM_DHCP_TIMEOUT_DEFAULT,
                           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);