diff options
Diffstat (limited to 'src/nm-act-request.c')
| -rw-r--r-- | src/nm-act-request.c | 606 |
1 files changed, 606 insertions, 0 deletions
diff --git a/src/nm-act-request.c b/src/nm-act-request.c new file mode 100644 index 00000000..3a04667b --- /dev/null +++ b/src/nm-act-request.c @@ -0,0 +1,606 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */ +/* NetworkManager -- Network link manager + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Copyright (C) 2005 - 2012 Red Hat, Inc. + * Copyright (C) 2007 - 2008 Novell, Inc. + */ + +#include "nm-default.h" + +#include "nm-act-request.h" + +#include <string.h> +#include <stdlib.h> +#include <sys/wait.h> +#include <unistd.h> + +#include "nm-setting-wireless-security.h" +#include "nm-setting-8021x.h" +#include "devices/nm-device.h" +#include "nm-active-connection.h" +#include "settings/nm-settings-connection.h" +#include "nm-auth-subject.h" + +typedef struct { + char *table; + char *rule; +} ShareRule; + +typedef struct { + GSList *secrets_calls; + gboolean shared; + GSList *share_rules; +} NMActRequestPrivate; + +struct _NMActRequest { + NMActiveConnection parent; + NMActRequestPrivate _priv; +}; + +typedef struct { + NMActiveConnectionClass parent; +} NMActRequestClass; + +enum { + PROP_0, + PROP_IP4_CONFIG, + PROP_DHCP4_CONFIG, + PROP_IP6_CONFIG, + PROP_DHCP6_CONFIG, + + LAST_PROP +}; + +G_DEFINE_TYPE (NMActRequest, nm_act_request, NM_TYPE_ACTIVE_CONNECTION) + +#define NM_ACT_REQUEST_GET_PRIVATE(self) _NM_GET_PRIVATE (self, NMActRequest, NM_IS_ACT_REQUEST) + +/*****************************************************************************/ + +NMSettingsConnection * +nm_act_request_get_settings_connection (NMActRequest *req) +{ + g_return_val_if_fail (NM_IS_ACT_REQUEST (req), NULL); + + return nm_active_connection_get_settings_connection (NM_ACTIVE_CONNECTION (req)); +} + +NMConnection * +nm_act_request_get_applied_connection (NMActRequest *req) +{ + g_return_val_if_fail (NM_IS_ACT_REQUEST (req), NULL); + + return nm_active_connection_get_applied_connection (NM_ACTIVE_CONNECTION (req)); +} + +/*****************************************************************************/ + +struct _NMActRequestGetSecretsCallId { + NMActRequest *self; + NMActRequestSecretsFunc callback; + gpointer callback_data; + NMSettingsConnectionCallId call_id; + bool has_ref; +}; + +typedef struct _NMActRequestGetSecretsCallId GetSecretsInfo; + +static GetSecretsInfo * +_get_secrets_info_new (NMActRequest *self, gboolean ref_self, NMActRequestSecretsFunc callback, gpointer callback_data) +{ + GetSecretsInfo *info; + + info = g_slice_new0 (GetSecretsInfo); + info->has_ref = ref_self; + info->self = ref_self ? g_object_ref (self) : self; + info->callback = callback; + info->callback_data = callback_data; + + return info; +} + +static void +_get_secrets_info_free (GetSecretsInfo *info) +{ + if (info->has_ref) + g_object_unref (info->self); + g_slice_free (GetSecretsInfo, info); +} + +static void +get_secrets_cb (NMSettingsConnection *connection, + NMSettingsConnectionCallId call_id_s, + const char *agent_username, + const char *setting_name, + GError *error, + gpointer user_data) +{ + GetSecretsInfo *info = user_data; + NMActRequestPrivate *priv; + + g_return_if_fail (info && info->call_id == call_id_s); + g_return_if_fail (NM_IS_ACT_REQUEST (info->self)); + + if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + return; + + priv = NM_ACT_REQUEST_GET_PRIVATE (info->self); + + g_return_if_fail (g_slist_find (priv->secrets_calls, info)); + + priv->secrets_calls = g_slist_remove (priv->secrets_calls, info); + + if (info->callback) + info->callback (info->self, info, connection, error, info->callback_data); + + _get_secrets_info_free (info); +} + +/** + * nm_act_request_get_secrets: + * @self: + * @ref_self: if %TRUE, the pending call take a reference on @self. + * It also allows you to omit the @self argument in nm_act_request_cancel_secrets(). + * @setting_name: + * @flags: + * @hint: + * @callback: + * @callback_data: + * + * Asnychronously starts the request for secrets. This function cannot + * fail. + * + * The return call-id can be used to cancel the request. You are + * only allowed to cancel a still pending operation (once). + * The callback will always be invoked once, even for canceling + * or disposing of NMActRequest. + * + * Returns: a call-id. + */ +NMActRequestGetSecretsCallId +nm_act_request_get_secrets (NMActRequest *self, + gboolean ref_self, + const char *setting_name, + NMSecretAgentGetSecretsFlags flags, + const char *hint, + NMActRequestSecretsFunc callback, + gpointer callback_data) +{ + NMActRequestPrivate *priv; + GetSecretsInfo *info; + NMSettingsConnectionCallId call_id_s; + NMSettingsConnection *settings_connection; + NMConnection *applied_connection; + const char *hints[2] = { hint, NULL }; + + g_return_val_if_fail (NM_IS_ACT_REQUEST (self), NULL); + + priv = NM_ACT_REQUEST_GET_PRIVATE (self); + + settings_connection = nm_act_request_get_settings_connection (self); + applied_connection = nm_act_request_get_applied_connection (self); + + info = _get_secrets_info_new (self, ref_self, callback, callback_data); + + priv->secrets_calls = g_slist_append (priv->secrets_calls, info); + + if (nm_active_connection_get_user_requested (NM_ACTIVE_CONNECTION (self))) + flags |= NM_SECRET_AGENT_GET_SECRETS_FLAG_USER_REQUESTED; + + call_id_s = nm_settings_connection_get_secrets (settings_connection, + applied_connection, + nm_active_connection_get_subject (NM_ACTIVE_CONNECTION (self)), + setting_name, + flags, + hints, + get_secrets_cb, + info); + info->call_id = call_id_s; + g_return_val_if_fail (call_id_s, NULL); + return info; +} + +static void +_do_cancel_secrets (NMActRequest *self, GetSecretsInfo *info, gboolean is_disposing) +{ + NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (self); + + nm_assert (info && info->self == self); + nm_assert (g_slist_find (priv->secrets_calls, info)); + + priv->secrets_calls = g_slist_remove (priv->secrets_calls, info); + + nm_settings_connection_cancel_secrets (nm_act_request_get_settings_connection (self), info->call_id); + + if (info->callback) { + gs_free_error GError *error = NULL; + + nm_utils_error_set_cancelled (&error, is_disposing, "NMActRequest"); + info->callback (self, info, NULL, error, info->callback_data); + } + + _get_secrets_info_free (info); +} + +/** + * nm_act_request_cancel_secrets: + * @self: The #NMActRequest. Note that this argument can be %NULL if, and only if + * the call_id was created with @take_ref. + * @call_id: + * + * You are only allowed to cancel the call once, and only before the callback + * is already invoked. Note that cancelling causes the callback to be invoked + * synchronously. + */ +void +nm_act_request_cancel_secrets (NMActRequest *self, NMActRequestGetSecretsCallId call_id) +{ + NMActRequestPrivate *priv; + + g_return_if_fail (call_id); + + if (self) { + g_return_if_fail (NM_IS_ACT_REQUEST (self)); + g_return_if_fail (self == call_id->self); + } else { + g_return_if_fail (call_id->has_ref); + g_return_if_fail (NM_IS_ACT_REQUEST (call_id->self)); + self = call_id->self; + } + + priv = NM_ACT_REQUEST_GET_PRIVATE (self); + + if (!g_slist_find (priv->secrets_calls, call_id)) + g_return_if_reached (); + + _do_cancel_secrets (self, call_id, FALSE); +} + +void +nm_act_request_clear_secrets (NMActRequest *self) +{ + g_return_if_fail (NM_IS_ACT_REQUEST (self)); + + nm_active_connection_clear_secrets ((NMActiveConnection *) self); +} + +/*****************************************************************************/ + +static void +clear_share_rules (NMActRequest *req) +{ + NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (req); + GSList *iter; + + for (iter = priv->share_rules; iter; iter = g_slist_next (iter)) { + ShareRule *rule = (ShareRule *) iter->data; + + g_free (rule->table); + g_free (rule->rule); + g_free (rule); + } + + g_slist_free (priv->share_rules); + priv->share_rules = NULL; +} + +void +nm_act_request_set_shared (NMActRequest *req, gboolean shared) +{ + NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (req); + GSList *list, *iter; + + g_return_if_fail (NM_IS_ACT_REQUEST (req)); + + NM_ACT_REQUEST_GET_PRIVATE (req)->shared = shared; + + /* Tear the rules down in reverse order when sharing is stopped */ + list = g_slist_copy (priv->share_rules); + if (!shared) + list = g_slist_reverse (list); + + /* Send the rules to iptables */ + for (iter = list; iter; iter = g_slist_next (iter)) { + ShareRule *rule = (ShareRule *) iter->data; + char *envp[1] = { NULL }; + gs_strfreev char **argv = NULL; + gs_free char *cmd = NULL; + + cmd = g_strdup_printf ("%s --table %s %s %s", + IPTABLES_PATH, + rule->table, + shared ? "--insert" : "--delete", + rule->rule); + if (!cmd) + continue; + + argv = g_strsplit (cmd, " ", 0); + if (argv && argv[0]) { + int status; + GError *error = NULL; + + nm_log_info (LOGD_SHARING, "Executing: %s", cmd); + if (!g_spawn_sync ("/", argv, envp, G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL, + NULL, NULL, NULL, NULL, &status, &error)) { + nm_log_warn (LOGD_SHARING, "Error executing command: %s", + error->message); + g_clear_error (&error); + } else if (WEXITSTATUS (status)) { + nm_log_warn (LOGD_SHARING, "** Command returned exit status %d.", + WEXITSTATUS (status)); + } + } + } + + g_slist_free (list); + + /* Clear the share rule list when sharing is stopped */ + if (!shared) + clear_share_rules (req); +} + +gboolean +nm_act_request_get_shared (NMActRequest *req) +{ + g_return_val_if_fail (NM_IS_ACT_REQUEST (req), FALSE); + + return NM_ACT_REQUEST_GET_PRIVATE (req)->shared; +} + +void +nm_act_request_add_share_rule (NMActRequest *req, + const char *table, + const char *table_rule) +{ + NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (req); + ShareRule *rule; + + g_return_if_fail (NM_IS_ACT_REQUEST (req)); + g_return_if_fail (table != NULL); + g_return_if_fail (table_rule != NULL); + + rule = g_malloc0 (sizeof (ShareRule)); + rule->table = g_strdup (table); + rule->rule = g_strdup (table_rule); + priv->share_rules = g_slist_prepend (priv->share_rules, rule); +} + +/*****************************************************************************/ + +static void +device_notify (GObject *object, + GParamSpec *pspec, + gpointer self) +{ + g_object_notify (self, pspec->name); +} + +static void +device_state_changed (NMActiveConnection *active, + NMDevice *device, + NMDeviceState new_state, + NMDeviceState old_state) +{ + NMActiveConnectionState cur_ac_state = nm_active_connection_get_state (active); + NMActiveConnectionState ac_state = NM_ACTIVE_CONNECTION_STATE_UNKNOWN; + + /* Decide which device state changes to handle when this active connection + * is not the device's current request. Two cases here: (a) the AC is + * pending and not yet active, and (b) the AC was active but the device is + * entering DISCONNECTED state (which clears the device's current AC before + * emitting the state change signal). + */ + if (NM_ACTIVE_CONNECTION (nm_device_get_act_request (device)) != active) { + /* Some other request is activating; this one must be pending */ + if (new_state >= NM_DEVICE_STATE_PREPARE) + return; + else if (new_state == NM_DEVICE_STATE_DISCONNECTED) { + /* This request hasn't started activating yet; the device is + * disconnecting and cleaning up a previous activation request. + */ + if (cur_ac_state < NM_ACTIVE_CONNECTION_STATE_ACTIVATING) + return; + + /* Catch device disconnections after this request has been active */ + } + + /* All states < DISCONNECTED are fatal and handled */ + } + + /* Set NMActiveConnection state based on the device's state */ + switch (new_state) { + case NM_DEVICE_STATE_PREPARE: + case NM_DEVICE_STATE_CONFIG: + case NM_DEVICE_STATE_NEED_AUTH: + case NM_DEVICE_STATE_IP_CONFIG: + case NM_DEVICE_STATE_IP_CHECK: + case NM_DEVICE_STATE_SECONDARIES: + ac_state = NM_ACTIVE_CONNECTION_STATE_ACTIVATING; + break; + case NM_DEVICE_STATE_ACTIVATED: + ac_state = NM_ACTIVE_CONNECTION_STATE_ACTIVATED; + + g_signal_connect (device, "notify::" NM_DEVICE_IP4_CONFIG, + G_CALLBACK (device_notify), active); + g_signal_connect (device, "notify::" NM_DEVICE_DHCP4_CONFIG, + G_CALLBACK (device_notify), active); + g_signal_connect (device, "notify::" NM_DEVICE_IP6_CONFIG, + G_CALLBACK (device_notify), active); + g_signal_connect (device, "notify::" NM_DEVICE_DHCP6_CONFIG, + G_CALLBACK (device_notify), active); + break; + case NM_DEVICE_STATE_DEACTIVATING: + ac_state = NM_ACTIVE_CONNECTION_STATE_DEACTIVATING; + break; + case NM_DEVICE_STATE_FAILED: + case NM_DEVICE_STATE_DISCONNECTED: + case NM_DEVICE_STATE_UNMANAGED: + case NM_DEVICE_STATE_UNAVAILABLE: + ac_state = NM_ACTIVE_CONNECTION_STATE_DEACTIVATED; + + g_signal_handlers_disconnect_by_func (device, G_CALLBACK (device_notify), active); + break; + default: + break; + } + + if ( ac_state == NM_ACTIVE_CONNECTION_STATE_DEACTIVATED + || ac_state == NM_ACTIVE_CONNECTION_STATE_UNKNOWN) { + nm_active_connection_set_default (active, FALSE); + nm_active_connection_set_default6 (active, FALSE); + } + + nm_active_connection_set_state (active, ac_state); +} + +static void +master_failed (NMActiveConnection *self) +{ + NMDevice *device; + NMDeviceState device_state; + + /* If the connection has an active device, fail it */ + device = nm_active_connection_get_device (self); + if (device) { + device_state = nm_device_get_state (device); + if (nm_device_is_activating (device) || (device_state == NM_DEVICE_STATE_ACTIVATED)) { + nm_device_queue_state (device, + NM_DEVICE_STATE_FAILED, + NM_DEVICE_STATE_REASON_DEPENDENCY_FAILED); + return; + } + } + + /* If no device, or the device wasn't active, just move to deactivated state */ + nm_active_connection_set_state (self, NM_ACTIVE_CONNECTION_STATE_DEACTIVATED); +} + +/*****************************************************************************/ + +static void +get_property (GObject *object, guint prop_id, + GValue *value, GParamSpec *pspec) +{ + NMDevice *device; + + device = nm_active_connection_get_device (NM_ACTIVE_CONNECTION (object)); + if (!device) { + g_value_set_string (value, "/"); + return; + } + + switch (prop_id) { + case PROP_IP4_CONFIG: + g_object_get_property (G_OBJECT (device), NM_DEVICE_IP4_CONFIG, value); + break; + case PROP_DHCP4_CONFIG: + g_object_get_property (G_OBJECT (device), NM_DEVICE_DHCP4_CONFIG, value); + break; + case PROP_IP6_CONFIG: + g_object_get_property (G_OBJECT (device), NM_DEVICE_IP6_CONFIG, value); + break; + case PROP_DHCP6_CONFIG: + g_object_get_property (G_OBJECT (device), NM_DEVICE_DHCP6_CONFIG, value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +nm_act_request_init (NMActRequest *req) +{ +} + +/** + * nm_act_request_new: + * + * @settings_connection: (allow-none): the connection to activate @device with + * @applied_connection: (allow-none): the applied connection + * @specific_object: the object path of the specific object (ie, WiFi access point, + * etc) that will be used to activate @connection and @device + * @subject: the #NMAuthSubject representing the requestor of the activation + * @device: the device/interface to configure according to @connection + * + * Creates a new device-based activation request. If an applied connection is + * supplied, it shall not be modified by the caller afterwards. + * + * Returns: the new activation request on success, %NULL on error. + */ +NMActRequest * +nm_act_request_new (NMSettingsConnection *settings_connection, + NMConnection *applied_connection, + const char *specific_object, + NMAuthSubject *subject, + NMDevice *device) +{ + g_return_val_if_fail (!settings_connection || NM_IS_SETTINGS_CONNECTION (settings_connection), NULL); + g_return_val_if_fail (NM_IS_DEVICE (device), NULL); + g_return_val_if_fail (NM_IS_AUTH_SUBJECT (subject), NULL); + + return (NMActRequest *) g_object_new (NM_TYPE_ACT_REQUEST, + NM_ACTIVE_CONNECTION_INT_APPLIED_CONNECTION, applied_connection, + NM_ACTIVE_CONNECTION_INT_SETTINGS_CONNECTION, settings_connection, + NM_ACTIVE_CONNECTION_INT_DEVICE, device, + NM_ACTIVE_CONNECTION_SPECIFIC_OBJECT, specific_object, + NM_ACTIVE_CONNECTION_INT_SUBJECT, subject, + NULL); +} + +static void +dispose (GObject *object) +{ + NMActRequest *self = NM_ACT_REQUEST (object); + NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (self); + + /* Kill any in-progress secrets requests */ + while (priv->secrets_calls) + _do_cancel_secrets (self, priv->secrets_calls->data, TRUE); + + /* Clear any share rules */ + if (priv->share_rules) { + nm_act_request_set_shared (NM_ACT_REQUEST (object), FALSE); + clear_share_rules (NM_ACT_REQUEST (object)); + } + + G_OBJECT_CLASS (nm_act_request_parent_class)->dispose (object); +} + +static void +nm_act_request_class_init (NMActRequestClass *req_class) +{ + GObjectClass *object_class = G_OBJECT_CLASS (req_class); + NMActiveConnectionClass *active_class = NM_ACTIVE_CONNECTION_CLASS (req_class); + + /* virtual methods */ + object_class->dispose = dispose; + object_class->get_property = get_property; + active_class->master_failed = master_failed; + active_class->device_state_changed = device_state_changed; + + /* properties */ + g_object_class_override_property (object_class, PROP_IP4_CONFIG, + NM_ACTIVE_CONNECTION_IP4_CONFIG); + g_object_class_override_property (object_class, PROP_DHCP4_CONFIG, + NM_ACTIVE_CONNECTION_DHCP4_CONFIG); + g_object_class_override_property (object_class, PROP_IP6_CONFIG, + NM_ACTIVE_CONNECTION_IP6_CONFIG); + g_object_class_override_property (object_class, PROP_DHCP6_CONFIG, + NM_ACTIVE_CONNECTION_DHCP6_CONFIG); +} + |