static NMDHCPClient *
get_client_for_iface (NMDHCPManager *manager,
const char *iface,
gboolean ip6)
{
NMDHCPManagerPrivate *priv;
GHashTableIter iter;
gpointer value;
g_return_val_if_fail (manager != NULL, NULL);
g_return_val_if_fail (NM_IS_DHCP_MANAGER (manager), NULL);
g_return_val_if_fail (iface, NULL);
priv = NM_DHCP_MANAGER_GET_PRIVATE (manager);
g_hash_table_iter_init (&iter, priv->clients);
while (g_hash_table_iter_next (&iter, NULL, &value)) {
NMDHCPClient *candidate = NM_DHCP_CLIENT (value);
if ( !strcmp (iface, nm_dhcp_client_get_iface (candidate))
&& (nm_dhcp_client_get_ipv6 (candidate) == ip6))
return candidate;
}
return NULL;
}
static void
nm_dhcp_manager_handle_event (DBusGProxy *proxy,
GHashTable *options,
gpointer user_data)
{
NMDHCPManager *manager;
NMDHCPManagerPrivate *priv;
NMDHCPClient *client;
char *iface = NULL;
char *pid_str = NULL;
char *reason = NULL;
unsigned long temp;
manager = NM_DHCP_MANAGER (user_data);
priv = NM_DHCP_MANAGER_GET_PRIVATE (manager);
iface = get_option (options, "interface");
if (iface == NULL) {
nm_log_warn (LOGD_DHCP, "DHCP event didn't have associated interface.");
goto out;
}
pid_str = get_option (options, "pid");
if (pid_str == NULL) {
nm_log_warn (LOGD_DHCP, "DHCP event didn't have associated PID.");
goto out;
}
temp = strtoul (pid_str, NULL, 10);
if ((temp == ULONG_MAX) && (errno == ERANGE)) {
nm_log_warn (LOGD_DHCP, "couldn't convert PID");
goto out;
}
client = get_client_for_pid (manager, (GPid) temp);
if (client == NULL) {
nm_log_warn (LOGD_DHCP, "(pid %d) unhandled DHCP event for interface %s", temp, iface);
goto out;
}
if (strcmp (iface, nm_dhcp_client_get_iface (client))) {
nm_log_warn (LOGD_DHCP, "(pid %d) received DHCP event from unexpected interface '%s' (expected '%s')",
temp, iface, nm_dhcp_client_get_iface (client));
goto out;
}
reason = get_option (options, "reason");
if (reason == NULL) {
nm_log_warn (LOGD_DHCP, "(pid %d) DHCP event didn't have a reason", temp);
goto out;
}
nm_dhcp_client_new_options (client, options, reason);
out:
g_free (iface);
g_free (pid_str);
g_free (reason);
}
static const char *
get_send_hostname (NMDhcpManager *self, const char *setting_hostname)
{
NMDhcpManagerPrivate *priv = NM_DHCP_MANAGER_GET_PRIVATE (self);
/* Always prefer the explicit dhcp-send-hostname if given */
return setting_hostname ? setting_hostname : priv->default_hostname;
}
static NMDHCPClient *
client_start (NMDHCPManager *self,
const char *iface,
const char *uuid,
gboolean ipv6,
NMSettingIP4Config *s_ip4,
NMSettingIP6Config *s_ip6,
guint32 timeout,
guint8 *dhcp_anycast_addr,
const char *hostname,
gboolean info_only)
{
NMDHCPManagerPrivate *priv;
NMDHCPClient *client;
gboolean success = FALSE;
g_return_val_if_fail (self, NULL);
g_return_val_if_fail (NM_IS_DHCP_MANAGER (self), NULL);
g_return_val_if_fail (iface != NULL, NULL);
g_return_val_if_fail (uuid != NULL, NULL);
priv = NM_DHCP_MANAGER_GET_PRIVATE (self);
/* Ensure we have a usable DHCP client */
g_return_val_if_fail (priv->client_type != 0, NULL);
/* Kill any old client instance */
client = get_client_for_iface (self, iface, ipv6);
if (client) {
nm_dhcp_client_stop (client);
remove_client (self, client);
}
/* And make a new one */
client = g_object_new (priv->client_type,
NM_DHCP_CLIENT_INTERFACE, iface,
NM_DHCP_CLIENT_IPV6, ipv6,
NM_DHCP_CLIENT_UUID, uuid,
NM_DHCP_CLIENT_TIMEOUT, timeout ? timeout : DHCP_TIMEOUT,
NULL);
g_return_val_if_fail (client != NULL, NULL);
add_client (self, client);
if (ipv6)
success = nm_dhcp_client_start_ip6 (client, s_ip6, dhcp_anycast_addr, hostname, info_only);
else
success = nm_dhcp_client_start_ip4 (client, s_ip4, dhcp_anycast_addr, hostname);
if (!success) {
remove_client (self, client);
g_object_unref (client);
client = NULL;
}
return client;
}
GSList *
nm_dhcp_manager_get_lease_config (NMDHCPManager *self,
const char *iface,
const char *uuid)
{
g_return_val_if_fail (self != NULL, NULL);
g_return_val_if_fail (NM_IS_DHCP_MANAGER (self), NULL);
g_return_val_if_fail (iface != NULL, NULL);
g_return_val_if_fail (uuid != NULL, NULL);
return NM_DHCP_MANAGER_GET_PRIVATE (self)->get_lease_config_func (iface, uuid);
}
static void
finalize (GObject *object)
{
NMDhcpManagerPrivate *priv = NM_DHCP_MANAGER_GET_PRIVATE (object);
g_free (priv->default_hostname);
if (priv->clients)
g_hash_table_destroy (priv->clients);
G_OBJECT_CLASS (nm_dhcp_manager_parent_class)->finalize (object);
}
static void
remove_client (NMDhcpManager *self, NMDhcpClient *client)
{
g_signal_handlers_disconnect_by_func (client, client_state_changed, self);
/* Stopping the client is left up to the controlling device
* explicitly since we may want to quit NetworkManager but not terminate
* the DHCP client.
*/
g_hash_table_remove (NM_DHCP_MANAGER_GET_PRIVATE (self)->clients, client);
}
void
nm_dhcp_manager_set_default_hostname (NMDhcpManager *manager, const char *hostname)
{
NMDhcpManagerPrivate *priv = NM_DHCP_MANAGER_GET_PRIVATE (manager);
g_clear_pointer (&priv->default_hostname, g_free);
/* Never send 'localhost'-type names to the DHCP server */
if (!nm_utils_is_specific_hostname (hostname))
return;
priv->default_hostname = g_strdup (hostname);
}
static void
add_client (NMDHCPManager *self, NMDHCPClient *client)
{
NMDHCPManagerPrivate *priv = NM_DHCP_MANAGER_GET_PRIVATE (self);
guint id;
id = g_signal_connect_swapped (client, "remove", G_CALLBACK (remove_client), self);
g_object_set_data (G_OBJECT (client), REMOVE_ID_TAG, GUINT_TO_POINTER (id));
id = g_signal_connect_swapped (client, "timeout", G_CALLBACK (remove_client), self);
g_object_set_data (G_OBJECT (client), TIMEOUT_ID_TAG, GUINT_TO_POINTER (id));
g_hash_table_insert (priv->clients, client, g_object_ref (client));
}
static void
dispose (GObject *object)
{
NMDhcpManagerPrivate *priv = NM_DHCP_MANAGER_GET_PRIVATE (object);
GList *values, *iter;
if (priv->clients) {
values = g_hash_table_get_values (priv->clients);
for (iter = values; iter; iter = g_list_next (iter))
remove_client (NM_DHCP_MANAGER (object), NM_DHCP_CLIENT (iter->data));
g_list_free (values);
}
G_OBJECT_CLASS (nm_dhcp_manager_parent_class)->dispose (object);
}
/* Caller owns a reference to the NMDHCPClient on return */
NMDHCPClient *
nm_dhcp_manager_start_ip4 (NMDHCPManager *self,
const char *iface,
const char *uuid,
NMSettingIP4Config *s_ip4,
guint32 timeout,
guint8 *dhcp_anycast_addr)
{
NMDHCPManagerPrivate *priv;
NMDHCPClient *client = NULL;
const char *hostname = NULL;
g_return_val_if_fail (self, NULL);
g_return_val_if_fail (NM_IS_DHCP_MANAGER (self), NULL);
priv = NM_DHCP_MANAGER_GET_PRIVATE (self);
if (s_ip4) {
const char *method = nm_setting_ip4_config_get_method (s_ip4);
if (method) {
/* Method must be 'auto' */
g_return_val_if_fail (strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_AUTO) == 0, NULL);
}
/* If we're asked to send the hostname to DHCP server, and the hostname
* isn't specified, and a hostname provider is registered: use that
*/
if (nm_setting_ip4_config_get_dhcp_send_hostname (s_ip4)) {
hostname = nm_setting_ip4_config_get_dhcp_hostname (s_ip4);
/* If we're supposed to send the hostname to the DHCP server but
* the user didn't specify one, use the persistent hostname.
*/
if (!hostname && priv->hostname_provider) {
hostname = nm_hostname_provider_get_hostname (priv->hostname_provider);
if ( hostname
&& (!strcmp (hostname, "localhost.localdomain") ||
!strcmp (hostname, "localhost6.localdomain6")))
hostname = NULL;
}
}
}
client = client_start (self, iface, uuid, FALSE, s_ip4, NULL, timeout, dhcp_anycast_addr, hostname, FALSE);
return client;
}
NMDHCPManager *
nm_dhcp_manager_new (const char *client, GError **error)
{
NMDHCPManagerPrivate *priv;
DBusGConnection *g_connection;
g_warn_if_fail (singleton == NULL);
singleton = g_object_new (NM_TYPE_DHCP_MANAGER, NULL);
priv = NM_DHCP_MANAGER_GET_PRIVATE (singleton);
/* Client-specific setup */
priv->client_type = get_client_type (client, error);
if (priv->client_type == NM_TYPE_DHCP_DHCLIENT)
priv->get_lease_config_func = nm_dhcp_dhclient_get_lease_config;
else if (priv->client_type == NM_TYPE_DHCP_DHCPCD)
priv->get_lease_config_func = nm_dhcp_dhcpcd_get_lease_config;
else {
nm_log_warn (LOGD_DHCP, "No usable DHCP client found! DHCP configurations will fail.");
}
priv->clients = g_hash_table_new_full (g_direct_hash, g_direct_equal,
NULL,
(GDestroyNotify) g_object_unref);
g_assert (priv->clients);
priv->dbus_mgr = nm_dbus_manager_get ();
g_connection = nm_dbus_manager_get_connection (priv->dbus_mgr);
priv->proxy = dbus_g_proxy_new_for_name (g_connection,
NM_DHCP_CLIENT_DBUS_SERVICE,
"/",
NM_DHCP_CLIENT_DBUS_IFACE);
g_assert (priv->proxy);
dbus_g_proxy_add_signal (priv->proxy,
"Event",
DBUS_TYPE_G_MAP_OF_VARIANT,
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->proxy, "Event",
G_CALLBACK (nm_dhcp_manager_handle_event),
singleton,
NULL);
return singleton;
}
static void
finalize (GObject *object)
{
NMDHCPManagerPrivate *priv = NM_DHCP_MANAGER_GET_PRIVATE (object);
if (priv->hostname_provider) {
g_object_weak_unref (G_OBJECT (priv->hostname_provider), hostname_provider_destroyed, object);
priv->hostname_provider = NULL;
}
if (priv->clients)
g_hash_table_destroy (priv->clients);
if (priv->proxy)
g_object_unref (priv->proxy);
if (priv->dbus_mgr)
g_object_unref (priv->dbus_mgr);
G_OBJECT_CLASS (nm_dhcp_manager_parent_class)->finalize (object);
}
GSList *
nm_dhcp_manager_get_lease_ip_configs (NMDhcpManager *self,
const char *iface,
int ifindex,
const char *uuid,
gboolean ipv6,
guint32 default_route_metric)
{
ClientDesc *desc;
g_return_val_if_fail (NM_IS_DHCP_MANAGER (self), NULL);
g_return_val_if_fail (iface != NULL, NULL);
g_return_val_if_fail (ifindex >= -1, NULL);
g_return_val_if_fail (uuid != NULL, NULL);
desc = find_client_desc (NULL, NM_DHCP_MANAGER_GET_PRIVATE (self)->client_type);
if (desc && desc->get_lease_configs_func)
return desc->get_lease_configs_func (iface, ifindex, uuid, ipv6, default_route_metric);
return NULL;
}
void
nm_dhcp_manager_set_hostname_provider (NMDHCPManager *manager,
NMHostnameProvider *provider)
{
NMDHCPManagerPrivate *priv;
g_return_if_fail (NM_IS_DHCP_MANAGER (manager));
priv = NM_DHCP_MANAGER_GET_PRIVATE (manager);
if (priv->hostname_provider) {
g_object_weak_unref (G_OBJECT (priv->hostname_provider), hostname_provider_destroyed, manager);
priv->hostname_provider = NULL;
}
if (provider) {
priv->hostname_provider = provider;
g_object_weak_ref (G_OBJECT (provider), hostname_provider_destroyed, manager);
}
}
static void
remove_client (NMDHCPManager *self, NMDHCPClient *client)
{
NMDHCPManagerPrivate *priv = NM_DHCP_MANAGER_GET_PRIVATE (self);
guint id;
id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (client), REMOVE_ID_TAG));
if (id)
g_signal_handler_disconnect (client, id);
id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (client), TIMEOUT_ID_TAG));
if (id)
g_signal_handler_disconnect (client, id);
/* Stopping the client is left up to the controlling device
* explicitly since we may want to quit NetworkManager but not terminate
* the DHCP client.
*/
g_hash_table_remove (priv->clients, client);
}
static NMDHCPClient *
get_client_for_pid (NMDHCPManager *manager, GPid pid)
{
NMDHCPManagerPrivate *priv;
GHashTableIter iter;
gpointer value;
g_return_val_if_fail (manager != NULL, NULL);
g_return_val_if_fail (NM_IS_DHCP_MANAGER (manager), NULL);
priv = NM_DHCP_MANAGER_GET_PRIVATE (manager);
g_hash_table_iter_init (&iter, priv->clients);
while (g_hash_table_iter_next (&iter, NULL, &value)) {
NMDHCPClient *candidate = NM_DHCP_CLIENT (value);
if (nm_dhcp_client_get_pid (candidate) == pid)
return candidate;
}
return NULL;
}
static void
nm_dhcp_manager_init (NMDhcpManager *self)
{
NMDhcpManagerPrivate *priv = NM_DHCP_MANAGER_GET_PRIVATE (self);
NMConfig *config = nm_config_get ();
const char *client;
GError *error = NULL;
GSList *iter;
for (iter = client_descs; iter; iter = iter->next) {
ClientDesc *desc = iter->data;
nm_log_dbg (LOGD_DHCP, "Registered DHCP client '%s' (%s)",
desc->name, g_type_name (desc->gtype));
}
/* Client-specific setup */
client = nm_config_get_dhcp_client (config);
if (nm_config_get_configure_and_quit (config)) {
if (g_strcmp0 (client, "internal") != 0)
nm_log_warn (LOGD_DHCP, "Using internal DHCP client since configure-and-quit is set.");
client = "internal";
}
priv->client_type = get_client_type (client, &error);
if (priv->client_type == G_TYPE_INVALID) {
nm_log_warn (LOGD_DHCP, "No usable DHCP client found (%s)! DHCP configurations will fail.",
error->message);
} else {
nm_log_dbg (LOGD_DHCP, "Using DHCP client '%s'", find_client_desc (NULL, priv->client_type)->name);
}
g_clear_error (&error);
priv->clients = g_hash_table_new_full (g_direct_hash, g_direct_equal,
NULL,
(GDestroyNotify) g_object_unref);
}
static NMDhcpClient *
get_client_for_ifindex (NMDhcpManager *manager, int ifindex, gboolean ip6)
{
NMDhcpManagerPrivate *priv;
GHashTableIter iter;
gpointer value;
g_return_val_if_fail (NM_IS_DHCP_MANAGER (manager), NULL);
g_return_val_if_fail (ifindex > 0, NULL);
priv = NM_DHCP_MANAGER_GET_PRIVATE (manager);
g_hash_table_iter_init (&iter, priv->clients);
while (g_hash_table_iter_next (&iter, NULL, &value)) {
NMDhcpClient *candidate = NM_DHCP_CLIENT (value);
if ( nm_dhcp_client_get_ifindex (candidate) == ifindex
&& nm_dhcp_client_get_ipv6 (candidate) == ip6)
return candidate;
}
return NULL;
}
static NMDhcpClient *
client_start (NMDhcpManager *self,
const char *iface,
int ifindex,
const GByteArray *hwaddr,
const char *uuid,
guint32 priority,
gboolean ipv6,
const char *dhcp_client_id,
guint32 timeout,
const char *dhcp_anycast_addr,
const char *hostname,
gboolean info_only,
NMSettingIP6ConfigPrivacy privacy,
const char *last_ip4_address)
{
NMDhcpManagerPrivate *priv;
NMDhcpClient *client;
gboolean success = FALSE;
g_return_val_if_fail (self, NULL);
g_return_val_if_fail (NM_IS_DHCP_MANAGER (self), NULL);
g_return_val_if_fail (ifindex > 0, NULL);
g_return_val_if_fail (uuid != NULL, NULL);
priv = NM_DHCP_MANAGER_GET_PRIVATE (self);
/* Ensure we have a usable DHCP client */
g_return_val_if_fail (priv->client_type != 0, NULL);
/* Kill any old client instance */
client = get_client_for_ifindex (self, ifindex, ipv6);
if (client) {
g_object_ref (client);
remove_client (self, client);
nm_dhcp_client_stop (client, FALSE);
g_object_unref (client);
}
/* And make a new one */
client = g_object_new (priv->client_type,
NM_DHCP_CLIENT_INTERFACE, iface,
NM_DHCP_CLIENT_IFINDEX, ifindex,
NM_DHCP_CLIENT_HWADDR, hwaddr,
NM_DHCP_CLIENT_IPV6, ipv6,
NM_DHCP_CLIENT_UUID, uuid,
NM_DHCP_CLIENT_PRIORITY, priority,
NM_DHCP_CLIENT_TIMEOUT, timeout ? timeout : DHCP_TIMEOUT,
NULL);
g_hash_table_insert (NM_DHCP_MANAGER_GET_PRIVATE (self)->clients, client, g_object_ref (client));
g_signal_connect (client, NM_DHCP_CLIENT_SIGNAL_STATE_CHANGED, G_CALLBACK (client_state_changed), self);
if (ipv6)
success = nm_dhcp_client_start_ip6 (client, dhcp_anycast_addr, hostname, info_only, privacy);
else
success = nm_dhcp_client_start_ip4 (client, dhcp_client_id, dhcp_anycast_addr, hostname, last_ip4_address);
if (!success) {
remove_client (self, client);
client = NULL;
}
return client;
}
static void
hostname_provider_destroyed (gpointer data, GObject *destroyed_object)
{
NM_DHCP_MANAGER_GET_PRIVATE (data)->hostname_provider = NULL;
}
