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; }