/* SPDX-License-Identifier: GPL-2.0-or-later */

/*

 * Copyright (C) 2005 - 2012 Red Hat, Inc.

 */

#include <config.h>

#define __CONFIG_H__

#define _XOPEN_SOURCE

#include <time.h>

#undef _XOPEN_SOURCE

#include "nm-default.h"

#if WITH_DHCLIENT

    #include <stdlib.h>

    #include <unistd.h>

    #include <stdio.h>

    #include <netinet/in.h>

    #include <arpa/inet.h>

    #include <ctype.h>

    #include "nm-glib-aux/nm-dedup-multi.h"

    #include "nm-utils.h"

    #include "nm-dhcp-dhclient-utils.h"

    #include "nm-dhcp-manager.h"

    #include "NetworkManagerUtils.h"

    #include "nm-dhcp-listener.h"

    #include "nm-dhcp-client-logging.h"

/*****************************************************************************/

static const char *

_addr_family_to_path_part(int addr_family)

{

    nm_assert(NM_IN_SET(addr_family, AF_INET, AF_INET6));

    return (addr_family == AF_INET6) ? "6" : "";

}

/*****************************************************************************/

    #define NM_TYPE_DHCP_DHCLIENT (nm_dhcp_dhclient_get_type())

    #define NM_DHCP_DHCLIENT(obj) \

        (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_DHCP_DHCLIENT, NMDhcpDhclient))

    #define NM_DHCP_DHCLIENT_CLASS(klass) \

        (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_DHCP_DHCLIENT, NMDhcpDhclientClass))

    #define NM_IS_DHCP_DHCLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_DHCP_DHCLIENT))

    #define NM_IS_DHCP_DHCLIENT_CLASS(klass) \

        (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_DHCP_DHCLIENT))

    #define NM_DHCP_DHCLIENT_GET_CLASS(obj) \

        (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_DHCP_DHCLIENT, NMDhcpDhclientClass))

typedef struct _NMDhcpDhclient      NMDhcpDhclient;

typedef struct _NMDhcpDhclientClass NMDhcpDhclientClass;

static GType nm_dhcp_dhclient_get_type(void);

/*****************************************************************************/

typedef struct {

    char *          conf_file;

    const char *    def_leasefile;

    char *          lease_file;

    char *          pid_file;

    NMDhcpListener *dhcp_listener;

} NMDhcpDhclientPrivate;

struct _NMDhcpDhclient {

    NMDhcpClient          parent;

    NMDhcpDhclientPrivate _priv;

};

struct _NMDhcpDhclientClass {

    NMDhcpClientClass parent;

};

G_DEFINE_TYPE(NMDhcpDhclient, nm_dhcp_dhclient, NM_TYPE_DHCP_CLIENT)

    #define NM_DHCP_DHCLIENT_GET_PRIVATE(self) \

        _NM_GET_PRIVATE(self, NMDhcpDhclient, NM_IS_DHCP_DHCLIENT)

/*****************************************************************************/

static const char *

nm_dhcp_dhclient_get_path(void)

{

    return nm_utils_find_helper("dhclient", DHCLIENT_PATH, NULL);

}

/**

 * get_dhclient_leasefile():

 * @addr_family: AF_INET or AF_INET6

 * @iface: the interface name of the device on which DHCP will be done

 * @uuid: the connection UUID to which the returned lease should belong

 * @out_preferred_path: on return, the "most preferred" leasefile path

 *

 * Returns the path of an existing leasefile (if any) for this interface and

 * connection UUID.  Also returns the "most preferred" leasefile path, which

 * may be different than any found leasefile.

 *

 * Returns: an existing leasefile, or %NULL if no matching leasefile could be found

 */

static char *

get_dhclient_leasefile(int         addr_family,

                       const char *iface,

                       const char *uuid,

                       char **     out_preferred_path)

{

    gs_free char *path = NULL;

    if (nm_dhcp_utils_get_leasefile_path(addr_family, "dhclient", iface, uuid, &path)) {

        NM_SET_OUT(out_preferred_path, g_strdup(path));

        return g_steal_pointer(&path);

    }

    NM_SET_OUT(out_preferred_path, g_steal_pointer(&path));

    /* If the leasefile we're looking for doesn't exist yet in the new location

     * (eg, /var/lib/NetworkManager) then look in old locations to maintain

     * backwards compatibility with external tools (like dracut) that put

     * leasefiles there.

     */

    /* Old Debian, SUSE, and Mandriva location */

    g_free(path);

    path = g_strdup_printf(LOCALSTATEDIR "/lib/dhcp/dhclient%s-%s-%s.lease",

                           _addr_family_to_path_part(addr_family),

                           uuid,

                           iface);

    if (g_file_test(path, G_FILE_TEST_EXISTS))

        return g_steal_pointer(&path);

    /* Old Red Hat and Fedora location */

    g_free(path);

    path = g_strdup_printf(LOCALSTATEDIR "/lib/dhclient/dhclient%s-%s-%s.lease",

                           _addr_family_to_path_part(addr_family),

                           uuid,

                           iface);

    if (g_file_test(path, G_FILE_TEST_EXISTS))

        return g_steal_pointer(&path);

    /* Fail */

    return NULL;

}

static gboolean

merge_dhclient_config(NMDhcpDhclient *    self,

                      int                 addr_family,

                      const char *        iface,

                      const char *        conf_file,

                      GBytes *            client_id,

                      const char *        anycast_addr,

                      const char *        hostname,

                      guint32             timeout,

                      gboolean            use_fqdn,

                      NMDhcpHostnameFlags hostname_flags,

                      const char *        mud_url,

                      const char *const * reject_servers,

                      const char *        orig_path,

                      GBytes **           out_new_client_id,

                      GError **           error)

{

    gs_free char *orig = NULL;

    gs_free char *new  = NULL;

    g_return_val_if_fail(iface, FALSE);

    g_return_val_if_fail(conf_file, FALSE);

    if (orig_path && g_file_test(orig_path, G_FILE_TEST_EXISTS)) {

        GError *read_error = NULL;

        if (!g_file_get_contents(orig_path, &orig, NULL, &read_error)) {

            _LOGW("error reading dhclient configuration %s: %s", orig_path, read_error->message);

            g_error_free(read_error);

        }

    }

    new = nm_dhcp_dhclient_create_config(iface,

                                         addr_family,

                                         client_id,

                                         anycast_addr,

                                         hostname,

                                         timeout,

                                         use_fqdn,

                                         hostname_flags,

                                         mud_url,

                                         reject_servers,

                                         orig_path,

                                         orig,

                                         out_new_client_id);

    nm_assert(new);

    return g_file_set_contents(conf_file, new, -1, error);

}

static char *

find_existing_config(NMDhcpDhclient *self, int addr_family, const char *iface, const char *uuid)

{

    char *path;

    /* NetworkManager-overridden configuration can be used to ship DHCP config

     * with NetworkManager itself. It can be uuid-specific, device-specific

     * or generic.

     */

    if (uuid) {

        path = g_strdup_printf(NMCONFDIR "/dhclient%s-%s.conf",

                               _addr_family_to_path_part(addr_family),

                               uuid);

        _LOGD("looking for existing config %s", path);

        if (g_file_test(path, G_FILE_TEST_EXISTS))

            return path;

        g_free(path);

    }

    path = g_strdup_printf(NMCONFDIR "/dhclient%s-%s.conf",

                           _addr_family_to_path_part(addr_family),

                           iface);

    _LOGD("looking for existing config %s", path);

    if (g_file_test(path, G_FILE_TEST_EXISTS))

        return path;

    g_free(path);

    path = g_strdup_printf(NMCONFDIR "/dhclient%s.conf", _addr_family_to_path_part(addr_family));

    _LOGD("looking for existing config %s", path);

    if (g_file_test(path, G_FILE_TEST_EXISTS))

        return path;

    g_free(path);

    /* Distribution's dhclient configuration is used so that we can use

     * configuration shipped with dhclient (if any).

     *

     * This replaces conditional compilation based on distribution name. Fedora

     * and Debian store the configs in /etc/dhcp while upstream defaults to /etc

     * which is then used by many other distributions. Some distributions

     * (including Fedora) don't even provide a default configuration file.

     */

    path = g_strdup_printf(SYSCONFDIR "/dhcp/dhclient%s-%s.conf",

                           _addr_family_to_path_part(addr_family),

                           iface);

    _LOGD("looking for existing config %s", path);

    if (g_file_test(path, G_FILE_TEST_EXISTS))

        return path;

    g_free(path);

    path = g_strdup_printf(SYSCONFDIR "/dhclient%s-%s.conf",

                           _addr_family_to_path_part(addr_family),

                           iface);

    _LOGD("looking for existing config %s", path);

    if (g_file_test(path, G_FILE_TEST_EXISTS))

        return path;

    g_free(path);

    path =

        g_strdup_printf(SYSCONFDIR "/dhcp/dhclient%s.conf", _addr_family_to_path_part(addr_family));

    _LOGD("looking for existing config %s", path);

    if (g_file_test(path, G_FILE_TEST_EXISTS))

        return path;

    g_free(path);

    path = g_strdup_printf(SYSCONFDIR "/dhclient%s.conf", _addr_family_to_path_part(addr_family));

    _LOGD("looking for existing config %s", path);

    if (g_file_test(path, G_FILE_TEST_EXISTS))

        return path;

    g_free(path);

    return NULL;

}

/* NM provides interface-specific options; thus the same dhclient config

 * file cannot be used since DHCP transactions can happen in parallel.

 * Since some distros don't have default per-interface dhclient config files,

 * read their single config file and merge that into a custom per-interface

 * config file along with the NM options.

 */

static char *

create_dhclient_config(NMDhcpDhclient *    self,

                       int                 addr_family,

                       const char *        iface,

                       const char *        uuid,

                       GBytes *            client_id,

                       const char *        dhcp_anycast_addr,

                       const char *        hostname,

                       guint32             timeout,

                       gboolean            use_fqdn,

                       NMDhcpHostnameFlags hostname_flags,

                       const char *        mud_url,

                       const char *const * reject_servers,

                       GBytes **           out_new_client_id)

{

    gs_free char *orig = NULL;

    char *new          = NULL;

    GError *error      = NULL;

    g_return_val_if_fail(iface != NULL, NULL);

    new = g_strdup_printf(NMSTATEDIR "/dhclient%s-%s.conf",

                          _addr_family_to_path_part(addr_family),

                          iface);

    _LOGD("creating composite dhclient config %s", new);

    orig = find_existing_config(self, addr_family, iface, uuid);

    if (orig)

        _LOGD("merging existing dhclient config %s", orig);

    else

        _LOGD("no existing dhclient configuration to merge");

    if (!merge_dhclient_config(self,

                               addr_family,

                               iface,

                               new,

                               client_id,

                               dhcp_anycast_addr,

                               hostname,

                               timeout,

                               use_fqdn,

                               hostname_flags,

                               mud_url,

                               reject_servers,

                               orig,

                               out_new_client_id,

                               &error)) {

        _LOGW("error creating dhclient configuration: %s", error->message);

        g_clear_error(&error);

    }

    return new;

}

static gboolean

dhclient_start(NMDhcpClient *client,

               const char *  mode_opt,

               gboolean      release,

               pid_t *       out_pid,

               int           prefixes,

               GError **     error)

{

    NMDhcpDhclient *       self       = NM_DHCP_DHCLIENT(client);

    NMDhcpDhclientPrivate *priv       = NM_DHCP_DHCLIENT_GET_PRIVATE(self);

    gs_unref_ptrarray GPtrArray *argv = NULL;

    pid_t                        pid;

    gs_free_error GError *local = NULL;

    const char *          iface;

    const char *          uuid;

    const char *          system_bus_address;

    const char *          dhclient_path;

    char *                binary_name;

    gs_free char *        cmd_str                  = NULL;

    gs_free char *        pid_file                 = NULL;

    gs_free char *        system_bus_address_env   = NULL;

    gs_free char *        preferred_leasefile_path = NULL;

    const int             addr_family              = nm_dhcp_client_get_addr_family(client);

    g_return_val_if_fail(!priv->pid_file, FALSE);

    NM_SET_OUT(out_pid, 0);

    dhclient_path = nm_dhcp_dhclient_get_path();

    if (!dhclient_path) {

        nm_utils_error_set_literal(error, NM_UTILS_ERROR_UNKNOWN, "dhclient binary not found");

        return FALSE;

    }

    iface = nm_dhcp_client_get_iface(client);

    uuid  = nm_dhcp_client_get_uuid(client);

    pid_file = g_strdup_printf(NMRUNDIR "/dhclient%s-%s.pid",

                               _addr_family_to_path_part(addr_family),

                               iface);

    /* Kill any existing dhclient from the pidfile */

    binary_name = g_path_get_basename(dhclient_path);

    nm_dhcp_client_stop_existing(pid_file, binary_name);

    g_free(binary_name);

    if (release) {

        /* release doesn't use the pidfile after killing an old client */

        nm_clear_g_free(&pid_file);

    }

    g_free(priv->lease_file);

    priv->lease_file = get_dhclient_leasefile(addr_family, iface, uuid, &preferred_leasefile_path);

    nm_assert(preferred_leasefile_path);

    if (!priv->lease_file) {

        /* No existing leasefile, dhclient will create one at the preferred path */

        priv->lease_file = g_steal_pointer(&preferred_leasefile_path);

    } else if (!nm_streq0(priv->lease_file, preferred_leasefile_path)) {

        gs_unref_object GFile *src = g_file_new_for_path(priv->lease_file);

        gs_unref_object GFile *dst = g_file_new_for_path(preferred_leasefile_path);

        /* Try to copy the existing leasefile to the preferred location */

        if (!g_file_copy(src, dst, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, &local)) {

            gs_free char *s_path = NULL;

            gs_free char *d_path = NULL;

            /* Failure; just use the existing leasefile */

            _LOGW("failed to copy leasefile %s to %s: %s",

                  (s_path = g_file_get_path(src)),

                  (d_path = g_file_get_path(dst)),

                  local->message);

            g_clear_error(&local);

        } else {

            /* Success; use the preferred leasefile path */

            g_free(priv->lease_file);

            priv->lease_file = g_file_get_path(dst);

        }

    }

    /* Save the DUID to the leasefile dhclient will actually use */

    if (addr_family == AF_INET6) {

        if (!nm_dhcp_dhclient_save_duid(priv->lease_file,

                                        nm_dhcp_client_get_client_id(client),

                                        &local)) {

            nm_utils_error_set(error,

                               NM_UTILS_ERROR_UNKNOWN,

                               "failed to save DUID to '%s': %s",

                               priv->lease_file,

                               local->message);

            return FALSE;

        }

    }

    argv = g_ptr_array_new();

    g_ptr_array_add(argv, (gpointer) dhclient_path);

    g_ptr_array_add(argv, (gpointer) "-d");

    /* Be quiet. dhclient logs to syslog anyway. And we duplicate the syslog

     * to stderr in case of NM running with --debug.

     */

    g_ptr_array_add(argv, (gpointer) "-q");

    if (release)

        g_ptr_array_add(argv, (gpointer) "-r");

    if (addr_family == AF_INET6) {

        g_ptr_array_add(argv, (gpointer) "-6");

        if (mode_opt)

            g_ptr_array_add(argv, (gpointer) mode_opt);

        while (prefixes--)

            g_ptr_array_add(argv, (gpointer) "-P");

    }

    g_ptr_array_add(argv, (gpointer) "-sf"); /* Set script file */

    g_ptr_array_add(argv, (gpointer) nm_dhcp_helper_path);

    if (pid_file) {

        g_ptr_array_add(argv, (gpointer) "-pf"); /* Set pid file */

        g_ptr_array_add(argv, (gpointer) pid_file);

    }

    g_ptr_array_add(argv, (gpointer) "-lf"); /* Set lease file */

    g_ptr_array_add(argv, (gpointer) priv->lease_file);

    if (priv->conf_file) {

        g_ptr_array_add(argv, (gpointer) "-cf"); /* Set interface config file */

        g_ptr_array_add(argv, (gpointer) priv->conf_file);

    }

    /* Usually the system bus address is well-known; but if it's supposed

     * to be something else, we need to push it to dhclient, since dhclient

     * sanitizes the environment it gives the action scripts.

     */

    system_bus_address = getenv("DBUS_SYSTEM_BUS_ADDRESS");

    if (system_bus_address) {

        system_bus_address_env = g_strdup_printf("DBUS_SYSTEM_BUS_ADDRESS=%s", system_bus_address);

        g_ptr_array_add(argv, (gpointer) "-e");

        g_ptr_array_add(argv, (gpointer) system_bus_address_env);

    }

    g_ptr_array_add(argv, (gpointer) iface);

    g_ptr_array_add(argv, NULL);

    _LOGD("running: %s", (cmd_str = g_strjoinv(" ", (char **) argv->pdata)));

    if (!g_spawn_async(NULL,

                       (char **) argv->pdata,

                       NULL,

                       G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_STDOUT_TO_DEV_NULL

                           | G_SPAWN_STDERR_TO_DEV_NULL,

                       nm_utils_setpgid,

                       NULL,

                       &pid,

                       &local)) {

        nm_utils_error_set(error,

                           NM_UTILS_ERROR_UNKNOWN,

                           "dhclient failed to start: %s",

                           local->message);

        return FALSE;

    }

    _LOGI("dhclient started with pid %lld", (long long int) pid);

    if (!release)

        nm_dhcp_client_watch_child(client, pid);

    priv->pid_file = g_steal_pointer(&pid_file);

    NM_SET_OUT(out_pid, pid);

    return TRUE;

}

static gboolean

ip4_start(NMDhcpClient *client,

          const char *  dhcp_anycast_addr,

          const char *  last_ip4_address,

          GError **     error)

{

    NMDhcpDhclient *       self = NM_DHCP_DHCLIENT(client);

    NMDhcpDhclientPrivate *priv = NM_DHCP_DHCLIENT_GET_PRIVATE(self);

    GBytes *               client_id;

    gs_unref_bytes GBytes *new_client_id = NULL;

    client_id = nm_dhcp_client_get_client_id(client);

    priv->conf_file = create_dhclient_config(self,

                                             AF_INET,

                                             nm_dhcp_client_get_iface(client),

                                             nm_dhcp_client_get_uuid(client),

                                             client_id,

                                             dhcp_anycast_addr,

                                             nm_dhcp_client_get_hostname(client),

                                             nm_dhcp_client_get_timeout(client),

                                             nm_dhcp_client_get_use_fqdn(client),

                                             nm_dhcp_client_get_hostname_flags(client),

                                             nm_dhcp_client_get_mud_url(client),

                                             nm_dhcp_client_get_reject_servers(client),

                                             &new_client_id);

    if (!priv->conf_file) {

        nm_utils_error_set_literal(error,

                                   NM_UTILS_ERROR_UNKNOWN,

                                   "error creating dhclient configuration file");

        return FALSE;

    }

    if (new_client_id) {

        nm_assert(!client_id);

        nm_dhcp_client_set_client_id(client, new_client_id);

    }

    return dhclient_start(client, NULL, FALSE, NULL, 0, error);

}

static gboolean

ip6_start(NMDhcpClient *            client,

          const char *              dhcp_anycast_addr,

          const struct in6_addr *   ll_addr,

          NMSettingIP6ConfigPrivacy privacy,

          guint                     needed_prefixes,

          GError **                 error)

{

    NMDhcpDhclient *       self = NM_DHCP_DHCLIENT(client);

    NMDhcpDhclientPrivate *priv = NM_DHCP_DHCLIENT_GET_PRIVATE(self);

    if (nm_dhcp_client_get_iaid_explicit(client))

        _LOGW("dhclient does not support specifying an IAID for DHCPv6, it will be ignored");

    priv->conf_file = create_dhclient_config(self,

                                             AF_INET6,

                                             nm_dhcp_client_get_iface(client),

                                             nm_dhcp_client_get_uuid(client),

                                             NULL,

                                             dhcp_anycast_addr,

                                             nm_dhcp_client_get_hostname(client),

                                             nm_dhcp_client_get_timeout(client),

                                             TRUE,

                                             nm_dhcp_client_get_hostname_flags(client),

                                             nm_dhcp_client_get_mud_url(client),

                                             NULL,

                                             NULL);

    if (!priv->conf_file) {

        nm_utils_error_set_literal(error,

                                   NM_UTILS_ERROR_UNKNOWN,

                                   "error creating dhclient configuration file");

        return FALSE;

    }

    return dhclient_start(client,

                          nm_dhcp_client_get_info_only(NM_DHCP_CLIENT(self)) ? "-S" : "-N",

                          FALSE,

                          NULL,

                          needed_prefixes,

                          error);

}

static void

stop(NMDhcpClient *client, gboolean release)

{

    NMDhcpDhclient *       self = NM_DHCP_DHCLIENT(client);

    NMDhcpDhclientPrivate *priv = NM_DHCP_DHCLIENT_GET_PRIVATE(self);

    int                    errsv;

    NM_DHCP_CLIENT_CLASS(nm_dhcp_dhclient_parent_class)->stop(client, release);

    if (priv->conf_file)

        if (remove(priv->conf_file) == -1) {

            errsv = errno;

            _LOGD("could not remove dhcp config file \"%s\": %d (%s)",

                  priv->conf_file,

                  errsv,

                  nm_strerror_native(errsv));

        }

    if (priv->pid_file) {

        if (remove(priv->pid_file) == -1) {

            errsv = errno;

            _LOGD("could not remove dhcp pid file \"%s\": %s (%d)",

                  priv->pid_file,

                  nm_strerror_native(errsv),

                  errsv);

        }

        nm_clear_g_free(&priv->pid_file);

    }

    if (release) {

        pid_t rpid = -1;

        if (dhclient_start(client, NULL, TRUE, &rpid, 0, NULL)) {

            /* Wait a few seconds for the release to happen */

            nm_dhcp_client_stop_pid(rpid, nm_dhcp_client_get_iface(client));

        }

    }

}

static GBytes *

get_duid(NMDhcpClient *client)

{

    NMDhcpDhclient *       self      = NM_DHCP_DHCLIENT(client);

    NMDhcpDhclientPrivate *priv      = NM_DHCP_DHCLIENT_GET_PRIVATE(self);

    GBytes *               duid      = NULL;

    gs_free char *         leasefile = NULL;

    GError *               error     = NULL;

    /* Look in interface-specific leasefile first for backwards compat */

    leasefile = get_dhclient_leasefile(AF_INET6,

                                       nm_dhcp_client_get_iface(client),

                                       nm_dhcp_client_get_uuid(client),

                                       NULL);

    if (leasefile) {

        _LOGD("looking for DUID in '%s'", leasefile);

        duid = nm_dhcp_dhclient_read_duid(leasefile, &error);

        if (error) {

            _LOGW("failed to read leasefile '%s': %s", leasefile, error->message);

            g_clear_error(&error);

        }

        if (duid)

            return duid;

    }

    /* Otherwise, read the default machine-wide DUID */

    _LOGD("looking for default DUID in '%s'", priv->def_leasefile);

    duid = nm_dhcp_dhclient_read_duid(priv->def_leasefile, &error);

    if (error) {

        _LOGW("failed to read leasefile '%s': %s", priv->def_leasefile, error->message);

        g_clear_error(&error);

    }

    return duid;

}

/*****************************************************************************/

static void

nm_dhcp_dhclient_init(NMDhcpDhclient *self)

{

    static const char *const FILES[] = {

        SYSCONFDIR "/dhclient6.leases", /* default */

        LOCALSTATEDIR "/lib/dhcp/dhclient6.leases",

        LOCALSTATEDIR "/lib/dhclient/dhclient6.leases",

    };

    NMDhcpDhclientPrivate *priv = NM_DHCP_DHCLIENT_GET_PRIVATE(self);

    int                    i;

    priv->def_leasefile = FILES[0];

    for (i = 0; i < G_N_ELEMENTS(FILES); i++) {

        if (g_file_test(FILES[i], G_FILE_TEST_EXISTS)) {

            priv->def_leasefile = FILES[i];

            break;

        }

    }

    priv->dhcp_listener = g_object_ref(nm_dhcp_listener_get());

    g_signal_connect(priv->dhcp_listener,

                     NM_DHCP_LISTENER_EVENT,

                     G_CALLBACK(nm_dhcp_client_handle_event),

                     self);

}

static void

dispose(GObject *object)

{

    NMDhcpDhclientPrivate *priv = NM_DHCP_DHCLIENT_GET_PRIVATE(object);

    if (priv->dhcp_listener) {

        g_signal_handlers_disconnect_by_func(priv->dhcp_listener,

                                             G_CALLBACK(nm_dhcp_client_handle_event),

                                             NM_DHCP_DHCLIENT(object));

        g_clear_object(&priv->dhcp_listener);

    }

    nm_clear_g_free(&priv->pid_file);

    nm_clear_g_free(&priv->conf_file);

    nm_clear_g_free(&priv->lease_file);

    G_OBJECT_CLASS(nm_dhcp_dhclient_parent_class)->dispose(object);

}

static void

nm_dhcp_dhclient_class_init(NMDhcpDhclientClass *dhclient_class)

{

    NMDhcpClientClass *client_class = NM_DHCP_CLIENT_CLASS(dhclient_class);

    GObjectClass *     object_class = G_OBJECT_CLASS(dhclient_class);

    object_class->dispose = dispose;

    client_class->ip4_start = ip4_start;

    client_class->ip6_start = ip6_start;

    client_class->stop      = stop;

    client_class->get_duid  = get_duid;

}

const NMDhcpClientFactory _nm_dhcp_client_factory_dhclient = {

    .name     = "dhclient",

    .get_type = nm_dhcp_dhclient_get_type,

    .get_path = nm_dhcp_dhclient_get_path,

};

#endif /* WITH_DHCLIENT */