/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (C) 2005 - 2012 Red Hat, Inc. */ #include #define __CONFIG_H__ #define _XOPEN_SOURCE #include #undef _XOPEN_SOURCE #include "nm-default.h" #if WITH_DHCLIENT #include #include #include #include #include #include #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 */