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 }; char **argv; char *cmd; 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, share_child_setup, NULL, NULL, NULL, &status, &error)) { nm_log_warn (LOGD_SHARING, "Error executing command: (%d) %s", error ? error->code : -1, (error && error->message) ? error->message : "(unknown)"); g_clear_error (&error); } else if (WEXITSTATUS (status)) { nm_log_warn (LOGD_SHARING, "** Command returned exit status %d.", WEXITSTATUS (status)); } } g_free (cmd); if (argv) g_strfreev (argv); } g_slist_free (list); /* Clear the share rule list when sharing is stopped */ if (!shared) clear_share_rules (req); }
NMConnection * nm_act_request_get_connection (NMActRequest *req) { g_return_val_if_fail (NM_IS_ACT_REQUEST (req), NULL); return NM_ACT_REQUEST_GET_PRIVATE (req)->connection; }
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); }
void nm_act_request_cancel_secrets (NMActRequest *self, guint32 call_id) { NMActRequestPrivate *priv; GSList *iter; g_return_if_fail (self); g_return_if_fail (NM_IS_ACT_REQUEST (self)); g_return_if_fail (call_id > 0); priv = NM_ACT_REQUEST_GET_PRIVATE (self); for (iter = priv->secrets_calls; iter; iter = g_slist_next (iter)) { GetSecretsInfo *info = iter->data; /* Remove the matching info */ if (info->call_id == call_id) { priv->secrets_calls = g_slist_remove_link (priv->secrets_calls, iter); g_slist_free (iter); nm_settings_connection_cancel_secrets (NM_SETTINGS_CONNECTION (priv->connection), call_id); g_free (info); break; } } }
NMActRequestDependencyResult nm_act_request_get_dependency_result (NMActRequest *req) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (req); return priv->dep ? ac_state_to_dep_result (priv->dep) : NM_ACT_REQUEST_DEP_RESULT_READY; }
GObject * nm_act_request_get_device (NMActRequest *req) { g_return_val_if_fail (NM_IS_ACT_REQUEST (req), NULL); return G_OBJECT (NM_ACT_REQUEST_GET_PRIVATE (req)->device); }
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; }
NMActRequest * nm_act_request_new (NMConnection *connection, const char *specific_object, gboolean user_requested, gboolean assumed, gpointer *device) { GObject *object; NMActRequestPrivate *priv; g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL); g_return_val_if_fail (NM_DEVICE (device), NULL); object = g_object_new (NM_TYPE_ACT_REQUEST, NULL); if (!object) return NULL; priv = NM_ACT_REQUEST_GET_PRIVATE (object); priv->connection = g_object_ref (connection); if (specific_object) priv->specific_object = g_strdup (specific_object); priv->device = NM_DEVICE (device); g_signal_connect (device, "state-changed", G_CALLBACK (device_state_changed), NM_ACT_REQUEST (object)); priv->user_requested = user_requested; priv->assumed = assumed; return NM_ACT_REQUEST (object); }
/** * nm_act_request_new: * * @connection: the connection to activate @device with * @specific_object: the object path of the specific object (ie, WiFi access point, * etc) that will be used to activate @connection and @device * @user_requested: pass %TRUE if the activation was requested via D-Bus, * otherwise %FALSE if requested internally by NM (ie, autoconnect) * @user_uid: if @user_requested is %TRUE, the Unix UID of the user that requested * @dbus_sender: if @user_requested is %TRUE, the D-BUS sender that requested * the activation * @assumed: pass %TRUE if the activation should "assume" (ie, taking over) an * existing connection made before this instance of NM started * @device: the device/interface to configure according to @connection * @master: if the activation depends on another device (ie, bond or bridge * master to which this device will be enslaved) pass the #NMDevice that this * activation request be enslaved to * * Begins activation of @device using the given @connection and other details. * * Returns: the new activation request on success, %NULL on error. */ NMActRequest * nm_act_request_new (NMConnection *connection, const char *specific_object, gboolean user_requested, gulong user_uid, const char *dbus_sender, gboolean assumed, NMDevice *device, NMDevice *master) { GObject *object; g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL); g_return_val_if_fail (NM_DEVICE (device), NULL); object = g_object_new (NM_TYPE_ACT_REQUEST, NM_ACTIVE_CONNECTION_INT_CONNECTION, connection, NM_ACTIVE_CONNECTION_INT_DEVICE, device, NM_ACTIVE_CONNECTION_SPECIFIC_OBJECT, specific_object, NM_ACTIVE_CONNECTION_INT_USER_REQUESTED, user_requested, NM_ACTIVE_CONNECTION_INT_USER_UID, user_uid, NM_ACTIVE_CONNECTION_INT_ASSUMED, assumed, NM_ACTIVE_CONNECTION_INT_MASTER, master, NULL); if (object) { nm_active_connection_export (NM_ACTIVE_CONNECTION (object)); NM_ACT_REQUEST_GET_PRIVATE (object)->dbus_sender = g_strdup (dbus_sender); } return (NMActRequest *) object; }
const char * nm_act_request_get_dbus_sender (NMActRequest *req) { g_return_val_if_fail (NM_IS_ACT_REQUEST (req), NULL); return NM_ACT_REQUEST_GET_PRIVATE (req)->dbus_sender; }
gulong nm_act_request_get_user_uid (NMActRequest *req) { g_return_val_if_fail (NM_IS_ACT_REQUEST (req), 0); return NM_ACT_REQUEST_GET_PRIVATE (req)->user_uid; }
static void finalize (GObject *object) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (object); g_free (priv->specific_object); g_free (priv->ac_path); clear_share_rules (NM_ACT_REQUEST (object)); G_OBJECT_CLASS (nm_act_request_parent_class)->finalize (object); }
static void dep_gone (NMActRequest *self, GObject *ignored) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (self); g_warn_if_fail (G_OBJECT (priv->dep) == ignored); /* Dependent connection is gone; clean up and fail */ priv->dep = NULL; priv->dep_state_id = 0; g_signal_emit (self, signals[DEP_RESULT], 0, NM_ACT_REQUEST_DEP_RESULT_FAILED); }
/** * nm_act_request_new: * * @connection: the connection to activate @device with * @specific_object: the object path of the specific object (ie, WiFi access point, * etc) that will be used to activate @connection and @device * @user_requested: pass %TRUE if the activation was requested via D-Bus, * otherwise %FALSE if requested internally by NM (ie, autoconnect) * @user_uid: if @user_requested is %TRUE, the Unix UID of the user that requested * @dbus_sender: if @user_requested is %TRUE, the D-BUS sender that requested * the activation * @assumed: pass %TRUE if the activation should "assume" (ie, taking over) an * existing connection made before this instance of NM started * @device: the device/interface to configure according to @connection * @dependency: if the activation depends on another device (ie, VLAN slave, * bond slave, etc) pass the #NMActiveConnection that this activation request * should wait for before proceeding * * Begins activation of @device using the given @connection and other details. * * Returns: the new activation request on success, %NULL on error. */ NMActRequest * nm_act_request_new (NMConnection *connection, const char *specific_object, gboolean user_requested, gulong user_uid, const char *dbus_sender, gboolean assumed, gpointer *device, NMActiveConnection *dependency) { GObject *object; NMActRequestPrivate *priv; g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL); g_return_val_if_fail (NM_DEVICE (device), NULL); object = g_object_new (NM_TYPE_ACT_REQUEST, NM_ACTIVE_CONNECTION_SPECIFIC_OBJECT, specific_object, NULL); if (!object) return NULL; priv = NM_ACT_REQUEST_GET_PRIVATE (object); priv->connection = g_object_ref (connection); priv->device = NM_DEVICE (device); g_signal_connect (device, "state-changed", G_CALLBACK (device_state_changed), NM_ACT_REQUEST (object)); priv->user_uid = user_uid; priv->user_requested = user_requested; priv->dbus_sender = g_strdup (dbus_sender); priv->assumed = assumed; if (dependency) { priv->dep = dependency; g_object_weak_ref (G_OBJECT (dependency), (GWeakNotify) dep_gone, object); priv->dep_state_id = g_signal_connect (dependency, "notify::" NM_ACTIVE_CONNECTION_STATE, G_CALLBACK (dep_state_changed), object); } if (!nm_active_connection_export (NM_ACTIVE_CONNECTION (object), connection, nm_device_get_path (NM_DEVICE (device)))) { g_object_unref (object); object = NULL; } return (NMActRequest *) object; }
static void nm_act_request_init (NMActRequest *req) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (req); NMDBusManager *dbus_mgr; priv->ac_path = nm_active_connection_get_next_object_path (); priv->state = NM_ACTIVE_CONNECTION_STATE_UNKNOWN; dbus_mgr = nm_dbus_manager_get (); dbus_g_connection_register_g_object (nm_dbus_manager_get_connection (dbus_mgr), priv->ac_path, G_OBJECT (req)); g_object_unref (dbus_mgr); }
void nm_act_request_cancel_secrets (NMActRequest *self, NMActRequestGetSecretsCallId call_id) { NMActRequestPrivate *priv; g_return_if_fail (NM_IS_ACT_REQUEST (self)); g_return_if_fail (call_id); 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); }
static void device_state_changed (NMDevice *device, GParamSpec *pspec, NMActRequest *self) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (self); NMActiveConnectionState ac_state = NM_ACTIVE_CONNECTION_STATE_UNKNOWN; /* Set NMActiveConnection state based on the device's state */ switch (nm_device_get_state (device)) { 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; 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; /* No longer need to pay attention to device state */ if (priv->device && priv->device_state_id) { g_signal_handler_disconnect (priv->device, priv->device_state_id); priv->device_state_id = 0; } g_clear_object (&priv->device); break; default: break; } if ( ac_state == NM_ACTIVE_CONNECTION_STATE_DEACTIVATED || ac_state == NM_ACTIVE_CONNECTION_STATE_UNKNOWN) { nm_active_connection_set_default (NM_ACTIVE_CONNECTION (self), FALSE); nm_active_connection_set_default6 (NM_ACTIVE_CONNECTION (self), FALSE); } nm_active_connection_set_state (NM_ACTIVE_CONNECTION (self), ac_state); }
static void get_secrets_cb (NMSettingsConnection *connection, guint32 call_id, const char *agent_username, const char *setting_name, GError *error, gpointer user_data) { GetSecretsInfo *info = user_data; NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (info->self); g_return_if_fail (info->call_id == call_id); priv->secrets_calls = g_slist_remove (priv->secrets_calls, info); info->callback (info->self, call_id, NM_CONNECTION (connection), error, info->callback_data); g_free (info); }
guint32 nm_act_request_get_secrets (NMActRequest *self, const char *setting_name, NMSettingsGetSecretsFlags flags, const char *hint, NMActRequestSecretsFunc callback, gpointer callback_data) { NMActRequestPrivate *priv; GetSecretsInfo *info; guint32 call_id; NMConnection *connection; gboolean user_requested; g_return_val_if_fail (self, 0); g_return_val_if_fail (NM_IS_ACT_REQUEST (self), 0); priv = NM_ACT_REQUEST_GET_PRIVATE (self); info = g_malloc0 (sizeof (GetSecretsInfo)); info->self = self; info->callback = callback; info->callback_data = callback_data; user_requested = nm_active_connection_get_user_requested (NM_ACTIVE_CONNECTION (self)); if (user_requested) flags |= NM_SETTINGS_GET_SECRETS_FLAG_USER_REQUESTED; connection = nm_active_connection_get_connection (NM_ACTIVE_CONNECTION (self)); call_id = nm_settings_connection_get_secrets (NM_SETTINGS_CONNECTION (connection), user_requested, nm_active_connection_get_user_uid (NM_ACTIVE_CONNECTION (self)), setting_name, flags, hint, get_secrets_cb, info, NULL); if (call_id > 0) { info->call_id = call_id; priv->secrets_calls = g_slist_append (priv->secrets_calls, info); } else g_free (info); return call_id; }
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_append (priv->share_rules, rule); }
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; }
static void device_state_changed (NMDevice *device, NMDeviceState new_state, NMDeviceState old_state, NMDeviceStateReason reason, gpointer user_data) { NMActRequest *self = NM_ACT_REQUEST (user_data); NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (self); NMActiveConnectionState new_ac_state; gboolean new_default = FALSE, new_default6 = FALSE; /* 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: new_ac_state = NM_ACTIVE_CONNECTION_STATE_ACTIVATING; break; case NM_DEVICE_STATE_ACTIVATED: new_ac_state = NM_ACTIVE_CONNECTION_STATE_ACTIVATED; new_default = priv->is_default; new_default6 = priv->is_default6; break; default: new_ac_state = NM_ACTIVE_CONNECTION_STATE_UNKNOWN; break; } if (new_ac_state != priv->state) { priv->state = new_ac_state; g_object_notify (G_OBJECT (self), NM_ACTIVE_CONNECTION_STATE); } if (new_default != priv->is_default) { priv->is_default = new_default; g_object_notify (G_OBJECT (self), NM_ACTIVE_CONNECTION_DEFAULT); } if (new_default6 != priv->is_default6) { priv->is_default6 = new_default6; g_object_notify (G_OBJECT (self), NM_ACTIVE_CONNECTION_DEFAULT6); } }
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 dep_state_changed (NMActiveConnection *dep, GParamSpec *pspec, NMActRequest *self) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (self); NMActRequestDependencyResult result; g_warn_if_fail (priv->dep == dep); result = ac_state_to_dep_result (priv->dep); if (result == NM_ACT_REQUEST_DEP_RESULT_FAILED) { g_object_weak_unref (G_OBJECT (priv->dep), (GWeakNotify) dep_gone, self); g_signal_handler_disconnect (priv->dep, priv->dep_state_id); priv->dep = NULL; priv->dep_state_id = 0; } g_signal_emit (self, signals[DEP_RESULT], 0, result); }
static void dispose (GObject *object) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (object); GSList *iter; if (priv->disposed) { G_OBJECT_CLASS (nm_act_request_parent_class)->dispose (object); return; } priv->disposed = TRUE; g_signal_handlers_disconnect_by_func (G_OBJECT (priv->device), G_CALLBACK (device_state_changed), NM_ACT_REQUEST (object)); /* Clear any share rules */ nm_act_request_set_shared (NM_ACT_REQUEST (object), FALSE); /* Kill any in-progress secrets requests */ g_assert (priv->connection); for (iter = priv->secrets_calls; iter; iter = g_slist_next (iter)) { GetSecretsInfo *info = iter->data; nm_settings_connection_cancel_secrets (NM_SETTINGS_CONNECTION (priv->connection), info->call_id); g_free (info); } g_slist_free (priv->secrets_calls); g_object_unref (priv->connection); g_free (priv->dbus_sender); if (priv->dep) { g_object_weak_unref (G_OBJECT (priv->dep), (GWeakNotify) dep_gone, object); g_signal_handler_disconnect (priv->dep, priv->dep_state_id); priv->dep = NULL; priv->dep_state_id = 0; } G_OBJECT_CLASS (nm_act_request_parent_class)->dispose (object); }
static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (object); GPtrArray *devices; switch (prop_id) { case PROP_SERVICE_NAME: nm_active_connection_scope_to_value (priv->connection, value); break; case PROP_CONNECTION: g_value_set_boxed (value, nm_connection_get_path (priv->connection)); break; case PROP_SPECIFIC_OBJECT: if (priv->specific_object) g_value_set_boxed (value, priv->specific_object); else g_value_set_boxed (value, "/"); break; case PROP_DEVICES: devices = g_ptr_array_sized_new (1); g_ptr_array_add (devices, g_strdup (nm_device_get_path (priv->device))); g_value_take_boxed (value, devices); break; case PROP_STATE: g_value_set_uint (value, priv->state); break; case PROP_DEFAULT: g_value_set_boolean (value, priv->is_default); break; case PROP_DEFAULT6: g_value_set_boolean (value, priv->is_default6); break; case PROP_VPN: g_value_set_boolean (value, FALSE); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/** * nm_act_request_get_secrets: * @self: * @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, 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), 0); 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, 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 get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (object); NMDevice *master; switch (prop_id) { case PROP_MASTER: if (priv->dep && NM_IS_ACT_REQUEST (priv->dep)) { master = NM_DEVICE (nm_act_request_get_device (NM_ACT_REQUEST (priv->dep))); g_assert (master); g_value_set_boxed (value, nm_device_get_path (master)); } else g_value_set_boxed (value, "/"); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void constructed (GObject *object) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (object); NMConnection *connection; NMDevice *device; G_OBJECT_CLASS (nm_act_request_parent_class)->constructed (object); connection = nm_active_connection_get_connection (NM_ACTIVE_CONNECTION (object)); priv->connection = g_object_ref (connection); device = nm_active_connection_get_device (NM_ACTIVE_CONNECTION (object)); if (device) { priv->device = g_object_ref (device); priv->device_state_id = g_signal_connect (priv->device, "notify::" NM_DEVICE_STATE, G_CALLBACK (device_state_changed), NM_ACT_REQUEST (object)); } }
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); }