mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager
synced 2024-07-22 02:35:25 +00:00
![Thomas Haller](/assets/img/avatar_default.png)
Most callers would pass FALSE to nm_utils_error_is_cancelled(). That's not very useful. Split the two functions and have nm_utils_error_is_cancelled() and nm_utils_error_is_cancelled_is_disposing().
2037 lines
67 KiB
C
2037 lines
67 KiB
C
// SPDX-License-Identifier: LGPL-2.1+
|
|
/*
|
|
* Copyright (C) 2010 - 2011 Red Hat, Inc.
|
|
*/
|
|
|
|
#include "nm-default.h"
|
|
|
|
#include "nm-secret-agent-old.h"
|
|
|
|
#include "c-list/src/c-list.h"
|
|
#include "nm-core-internal.h"
|
|
#include "nm-dbus-helpers.h"
|
|
#include "nm-dbus-interface.h"
|
|
#include "nm-enum-types.h"
|
|
#include "nm-glib-aux/nm-c-list.h"
|
|
#include "nm-glib-aux/nm-dbus-aux.h"
|
|
#include "nm-glib-aux/nm-time-utils.h"
|
|
#include "nm-simple-connection.h"
|
|
|
|
#define REGISTER_RETRY_TIMEOUT_MSEC 3000
|
|
#define _CALL_REGISTER_TIMEOUT_MSEC 15000
|
|
|
|
/*****************************************************************************/
|
|
|
|
typedef struct {
|
|
char *connection_path;
|
|
char *setting_name;
|
|
GDBusMethodInvocation *context;
|
|
CList gsi_lst;
|
|
bool is_cancelling:1;
|
|
} GetSecretsInfo;
|
|
|
|
NM_GOBJECT_PROPERTIES_DEFINE (NMSecretAgentOld,
|
|
PROP_IDENTIFIER,
|
|
PROP_AUTO_REGISTER,
|
|
PROP_REGISTERED,
|
|
PROP_CAPABILITIES,
|
|
PROP_DBUS_CONNECTION,
|
|
);
|
|
|
|
typedef struct {
|
|
GDBusConnection *dbus_connection;
|
|
GMainContext *main_context;
|
|
GMainContext *dbus_context;
|
|
GObject *context_busy_watcher;
|
|
GCancellable *name_owner_cancellable;
|
|
GCancellable *registering_cancellable;
|
|
GSource *registering_retry_source;
|
|
|
|
NMLInitData *init_data;
|
|
|
|
CList gsi_lst_head;
|
|
|
|
CList pending_tasks_register_lst_head;
|
|
|
|
char *identifier;
|
|
|
|
NMRefString *name_owner_curr;
|
|
NMRefString *name_owner_next;
|
|
|
|
gint64 registering_timeout_msec;
|
|
|
|
guint name_owner_changed_id;
|
|
|
|
guint exported_id;
|
|
|
|
guint capabilities;
|
|
|
|
guint8 registering_try_count;
|
|
|
|
guint8 register_state_change_reenter:2;
|
|
|
|
bool session_bus:1;
|
|
|
|
bool auto_register:1;
|
|
|
|
bool is_registered:1;
|
|
|
|
bool is_enabled:1;
|
|
|
|
bool registration_force_unregister:1;
|
|
|
|
/* This is true, if we either are in the process of RegisterWithCapabilities() or
|
|
* are already successfully registered.
|
|
*
|
|
* This is only TRUE, if the name owner was authenticated to run as root user.
|
|
*
|
|
* It also means, we should follow up with an Unregister() call during shutdown. */
|
|
bool registered_against_server:1;
|
|
|
|
bool is_initialized:1;
|
|
bool is_destroyed:1;
|
|
} NMSecretAgentOldPrivate;
|
|
|
|
static void nm_secret_agent_old_initable_iface_init (GInitableIface *iface);
|
|
static void nm_secret_agent_old_async_initable_iface_init (GAsyncInitableIface *iface);
|
|
|
|
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (NMSecretAgentOld, nm_secret_agent_old, G_TYPE_OBJECT,
|
|
G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, nm_secret_agent_old_initable_iface_init);
|
|
G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, nm_secret_agent_old_async_initable_iface_init);
|
|
)
|
|
|
|
#define NM_SECRET_AGENT_OLD_GET_PRIVATE(self) (G_TYPE_INSTANCE_GET_PRIVATE ((self), NM_TYPE_SECRET_AGENT_OLD, NMSecretAgentOldPrivate))
|
|
|
|
/*****************************************************************************/
|
|
|
|
#define _NMLOG(level, ...) \
|
|
NML_DBUS_LOG((level), \
|
|
"secret-agent["NM_HASH_OBFUSCATE_PTR_FMT"]: " _NM_UTILS_MACRO_FIRST (__VA_ARGS__), \
|
|
NM_HASH_OBFUSCATE_PTR (self) \
|
|
_NM_UTILS_MACRO_REST (__VA_ARGS__))
|
|
|
|
/*****************************************************************************/
|
|
|
|
static const GDBusInterfaceInfo interface_info = NM_DEFINE_GDBUS_INTERFACE_INFO_INIT (
|
|
NM_DBUS_INTERFACE_SECRET_AGENT,
|
|
.methods = NM_DEFINE_GDBUS_METHOD_INFOS (
|
|
NM_DEFINE_GDBUS_METHOD_INFO (
|
|
"GetSecrets",
|
|
.in_args = NM_DEFINE_GDBUS_ARG_INFOS (
|
|
NM_DEFINE_GDBUS_ARG_INFO ("connection", "a{sa{sv}}"),
|
|
NM_DEFINE_GDBUS_ARG_INFO ("connection_path", "o"),
|
|
NM_DEFINE_GDBUS_ARG_INFO ("setting_name", "s"),
|
|
NM_DEFINE_GDBUS_ARG_INFO ("hints", "as"),
|
|
NM_DEFINE_GDBUS_ARG_INFO ("flags", "u"),
|
|
),
|
|
.out_args = NM_DEFINE_GDBUS_ARG_INFOS (
|
|
NM_DEFINE_GDBUS_ARG_INFO ("secrets", "a{sa{sv}}"),
|
|
),
|
|
),
|
|
NM_DEFINE_GDBUS_METHOD_INFO (
|
|
"CancelGetSecrets",
|
|
.in_args = NM_DEFINE_GDBUS_ARG_INFOS (
|
|
NM_DEFINE_GDBUS_ARG_INFO ("connection_path", "o"),
|
|
NM_DEFINE_GDBUS_ARG_INFO ("setting_name", "s"),
|
|
),
|
|
),
|
|
NM_DEFINE_GDBUS_METHOD_INFO (
|
|
"SaveSecrets",
|
|
.in_args = NM_DEFINE_GDBUS_ARG_INFOS (
|
|
NM_DEFINE_GDBUS_ARG_INFO ("connection", "a{sa{sv}}"),
|
|
NM_DEFINE_GDBUS_ARG_INFO ("connection_path", "o"),
|
|
),
|
|
),
|
|
NM_DEFINE_GDBUS_METHOD_INFO (
|
|
"DeleteSecrets",
|
|
.in_args = NM_DEFINE_GDBUS_ARG_INFOS (
|
|
NM_DEFINE_GDBUS_ARG_INFO ("connection", "a{sa{sv}}"),
|
|
NM_DEFINE_GDBUS_ARG_INFO ("connection_path", "o"),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void _register_state_change (NMSecretAgentOld *self);
|
|
|
|
static void _register_dbus_call (NMSecretAgentOld *self);
|
|
|
|
static void _init_complete (NMSecretAgentOld *self, GError *error_take);
|
|
|
|
static void _register_state_complete (NMSecretAgentOld *self);
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* nm_secret_agent_old_get_dbus_connection:
|
|
* @self: the #NMSecretAgentOld instance
|
|
*
|
|
* Returns: (transfer none): the #GDBusConnection used by the secret agent.
|
|
* You may either set this as construct property %NM_SECRET_AGENT_OLD_DBUS_CONNECTION,
|
|
* or it will automatically set during initialization.
|
|
*
|
|
* Since: 1.24
|
|
*/
|
|
GDBusConnection *
|
|
nm_secret_agent_old_get_dbus_connection (NMSecretAgentOld *self)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), NULL);
|
|
|
|
return NM_SECRET_AGENT_OLD_GET_PRIVATE (self)->dbus_connection;
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_get_main_context:
|
|
* @self: the #NMSecretAgentOld instance
|
|
*
|
|
* Returns: (transfer none): the #GMainContext instance associate with the
|
|
* instance. This is the g_main_context_get_thread_default() at the time
|
|
* when creating the instance.
|
|
*
|
|
* Since: 1.24
|
|
*/
|
|
GMainContext *
|
|
nm_secret_agent_old_get_main_context (NMSecretAgentOld *self)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), NULL);
|
|
|
|
return NM_SECRET_AGENT_OLD_GET_PRIVATE (self)->main_context;
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_get_context_busy_watcher:
|
|
* @self: the #NMSecretAgentOld instance
|
|
*
|
|
* Returns a #GObject that stays alive as long as there are pending
|
|
* requests in the #GDBusConnection. Such requests keep the #GMainContext
|
|
* alive, and thus you may want to keep iterating the context as long
|
|
* until a weak reference indicates that this object is gone. This is
|
|
* useful because even when you destroy the instance right away (and all
|
|
* the internally pending requests get cancelled), any pending g_dbus_connection_call()
|
|
* requests will still invoke the result on the #GMainContext. Hence, this
|
|
* allows you to know how long you must iterate the context to know
|
|
* that all remains are cleaned up.
|
|
*
|
|
* Returns: (transfer none): a #GObject that you may register a weak pointer
|
|
* to know that the #GMainContext is still kept busy by @self.
|
|
*
|
|
* Since: 1.24
|
|
*/
|
|
GObject *
|
|
nm_secret_agent_old_get_context_busy_watcher (NMSecretAgentOld *self)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), NULL);
|
|
|
|
return NM_SECRET_AGENT_OLD_GET_PRIVATE (self)->context_busy_watcher;
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_get_dbus_name_owner:
|
|
* @self: the #NMSecretAgentOld instance
|
|
*
|
|
* Returns: the current D-Bus name owner. While this property
|
|
* is set while registering, it really only makes sense when
|
|
* the nm_secret_agent_old_get_registered() indicates that
|
|
* registration is successfull.
|
|
*
|
|
* Since: 1.24
|
|
*/
|
|
const char *
|
|
nm_secret_agent_old_get_dbus_name_owner (NMSecretAgentOld *self)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), NULL);
|
|
|
|
return nm_ref_string_get_str (NM_SECRET_AGENT_OLD_GET_PRIVATE (self)->name_owner_curr);
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_get_registered:
|
|
* @self: a #NMSecretAgentOld
|
|
*
|
|
* Note that the secret agent transparently registers and re-registers
|
|
* as the D-Bus name owner appears. Hence, this property is not really
|
|
* useful. Also, to be graceful against races during registration, the
|
|
* instance will already accept requests while being in the process of
|
|
* registering.
|
|
* If you need to avoid races and want to wait until @self is registered,
|
|
* call nm_secret_agent_old_register_async(). If that function completes
|
|
* with success, you know the instance is registered.
|
|
*
|
|
* Returns: a %TRUE if the agent is registered, %FALSE if it is not.
|
|
**/
|
|
gboolean
|
|
nm_secret_agent_old_get_registered (NMSecretAgentOld *self)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), FALSE);
|
|
|
|
return NM_SECRET_AGENT_OLD_GET_PRIVATE (self)->is_registered;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
get_secret_info_free (GetSecretsInfo *info)
|
|
{
|
|
nm_assert (info);
|
|
nm_assert (!info->context);
|
|
|
|
c_list_unlink_stale (&info->gsi_lst);
|
|
g_free (info->connection_path);
|
|
g_free (info->setting_name);
|
|
nm_g_slice_free (info);
|
|
}
|
|
|
|
static void
|
|
get_secret_info_complete_and_free (GetSecretsInfo *info,
|
|
GVariant *secrets,
|
|
GError *error)
|
|
{
|
|
if (error) {
|
|
if (secrets)
|
|
nm_g_variant_unref_floating (secrets);
|
|
g_dbus_method_invocation_return_gerror (g_steal_pointer (&info->context), error);
|
|
} else {
|
|
g_dbus_method_invocation_return_value (g_steal_pointer (&info->context),
|
|
g_variant_new ("(@a{sa{sv}})", secrets));
|
|
}
|
|
get_secret_info_free (info);
|
|
}
|
|
|
|
static void
|
|
get_secret_info_complete_and_free_error (GetSecretsInfo *info,
|
|
GQuark error_domain,
|
|
int error_code,
|
|
const char *error_message)
|
|
{
|
|
g_dbus_method_invocation_return_error_literal (g_steal_pointer (&info->context), error_domain, error_code, error_message);
|
|
get_secret_info_free (info);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
_dbus_connection_call_cb (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
gs_unref_object GObject *context_busy_watcher = NULL;
|
|
GAsyncReadyCallback callback;
|
|
gpointer callback_user_data;
|
|
|
|
nm_utils_user_data_unpack (user_data, &context_busy_watcher, &callback, &callback_user_data);
|
|
callback (source, result, callback_user_data);
|
|
}
|
|
|
|
static void
|
|
_dbus_connection_call (NMSecretAgentOld *self,
|
|
const char *bus_name,
|
|
const char *object_path,
|
|
const char *interface_name,
|
|
const char *method_name,
|
|
GVariant *parameters,
|
|
const GVariantType *reply_type,
|
|
GDBusCallFlags flags,
|
|
int timeout_msec,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
nm_assert (nm_g_main_context_is_thread_default (priv->dbus_context));
|
|
|
|
g_dbus_connection_call (priv->dbus_connection,
|
|
bus_name,
|
|
object_path,
|
|
interface_name,
|
|
method_name,
|
|
parameters,
|
|
reply_type,
|
|
flags,
|
|
timeout_msec,
|
|
cancellable,
|
|
callback
|
|
? _dbus_connection_call_cb
|
|
: NULL,
|
|
callback
|
|
? nm_utils_user_data_pack (g_object_ref (priv->context_busy_watcher), callback, user_data)
|
|
: NULL);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static GetSecretsInfo *
|
|
find_get_secrets_info (NMSecretAgentOldPrivate *priv,
|
|
const char *connection_path,
|
|
const char *setting_name)
|
|
{
|
|
GetSecretsInfo *info;
|
|
|
|
c_list_for_each_entry (info, &priv->gsi_lst_head, gsi_lst) {
|
|
if ( nm_streq (connection_path, info->connection_path)
|
|
&& nm_streq (setting_name, info->setting_name))
|
|
return info;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
_cancel_get_secret_request (NMSecretAgentOld *self,
|
|
GetSecretsInfo *info,
|
|
const char *message)
|
|
{
|
|
c_list_unlink (&info->gsi_lst);
|
|
info->is_cancelling = TRUE;
|
|
|
|
_LOGT ("cancel get-secrets request \"%s\", \"%s\": %s", info->connection_path, info->setting_name, message);
|
|
|
|
NM_SECRET_AGENT_OLD_GET_CLASS (self)->cancel_get_secrets (self,
|
|
info->connection_path,
|
|
info->setting_name);
|
|
|
|
get_secret_info_complete_and_free_error (info,
|
|
NM_SECRET_AGENT_ERROR,
|
|
NM_SECRET_AGENT_ERROR_AGENT_CANCELED,
|
|
message);
|
|
}
|
|
|
|
static gboolean
|
|
verify_request (NMSecretAgentOld *self,
|
|
GDBusMethodInvocation *context,
|
|
GVariant *connection_dict,
|
|
const char *connection_path,
|
|
NMConnection **out_connection,
|
|
GError **error)
|
|
{
|
|
gs_unref_object NMConnection *connection = NULL;
|
|
gs_free_error GError *local = NULL;
|
|
|
|
if (!nm_dbus_path_not_empty (connection_path)) {
|
|
g_set_error_literal (error,
|
|
NM_SECRET_AGENT_ERROR,
|
|
NM_SECRET_AGENT_ERROR_INVALID_CONNECTION,
|
|
"Invalid connection: no connection path given.");
|
|
return FALSE;
|
|
}
|
|
|
|
connection = _nm_simple_connection_new_from_dbus (connection_dict, NM_SETTING_PARSE_FLAGS_BEST_EFFORT, &local);
|
|
if (!connection) {
|
|
g_set_error (error,
|
|
NM_SECRET_AGENT_ERROR,
|
|
NM_SECRET_AGENT_ERROR_INVALID_CONNECTION,
|
|
"Invalid connection: %s", local->message);
|
|
return FALSE;
|
|
}
|
|
|
|
nm_connection_set_path (connection, connection_path);
|
|
NM_SET_OUT (out_connection, g_steal_pointer (&connection));
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
get_secrets_cb (NMSecretAgentOld *self,
|
|
NMConnection *connection,
|
|
GVariant *secrets,
|
|
GError *error,
|
|
gpointer user_data)
|
|
{
|
|
GetSecretsInfo *info = user_data;
|
|
|
|
if (info->is_cancelling) {
|
|
if (secrets)
|
|
nm_g_variant_unref_floating (secrets);
|
|
return;
|
|
}
|
|
|
|
_LOGT ("request: get-secrets request \"%s\", \"%s\" complete with %s%s%s",
|
|
info->connection_path,
|
|
info->setting_name,
|
|
NM_PRINT_FMT_QUOTED (error, "error: ", error->message, "", "success"));
|
|
|
|
get_secret_info_complete_and_free (info, secrets, error);
|
|
}
|
|
|
|
static void
|
|
impl_get_secrets (NMSecretAgentOld *self,
|
|
GVariant *parameters,
|
|
GDBusMethodInvocation *context)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
GError *error = NULL;
|
|
gs_unref_object NMConnection *connection = NULL;
|
|
GetSecretsInfo *info;
|
|
gs_unref_variant GVariant *arg_connection = NULL;
|
|
const char *arg_connection_path;
|
|
const char *arg_setting_name;
|
|
gs_free const char **arg_hints = NULL;
|
|
guint32 arg_flags;
|
|
|
|
g_variant_get (parameters,
|
|
"(@a{sa{sv}}&o&s^a&su)",
|
|
&arg_connection,
|
|
&arg_connection_path,
|
|
&arg_setting_name,
|
|
&arg_hints,
|
|
&arg_flags);
|
|
|
|
if (!verify_request (self, context, arg_connection, arg_connection_path, &connection, &error)) {
|
|
g_dbus_method_invocation_take_error (context, error);
|
|
return;
|
|
}
|
|
|
|
_LOGT ("request: get-secrets(\"%s\", \"%s\")", arg_connection_path, arg_setting_name);
|
|
|
|
info = find_get_secrets_info (priv, arg_connection_path, arg_setting_name);
|
|
if (info)
|
|
_cancel_get_secret_request (self, info, "Request aborted due to new request");
|
|
|
|
info = g_slice_new (GetSecretsInfo);
|
|
*info = (GetSecretsInfo) {
|
|
.context = context,
|
|
.connection_path = g_strdup (arg_connection_path),
|
|
.setting_name = g_strdup (arg_setting_name),
|
|
};
|
|
c_list_link_tail (&priv->gsi_lst_head, &info->gsi_lst);
|
|
|
|
NM_SECRET_AGENT_OLD_GET_CLASS (self)->get_secrets (self,
|
|
connection,
|
|
info->connection_path,
|
|
info->setting_name,
|
|
arg_hints,
|
|
arg_flags,
|
|
get_secrets_cb,
|
|
info);
|
|
}
|
|
|
|
static void
|
|
impl_cancel_get_secrets (NMSecretAgentOld *self,
|
|
GVariant *parameters,
|
|
GDBusMethodInvocation *context)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
GetSecretsInfo *info;
|
|
const char *arg_connection_path;
|
|
const char *arg_setting_name;
|
|
|
|
g_variant_get (parameters,
|
|
"(&o&s)",
|
|
&arg_connection_path,
|
|
&arg_setting_name);
|
|
|
|
info = find_get_secrets_info (priv, arg_connection_path, arg_setting_name);
|
|
if (!info) {
|
|
g_dbus_method_invocation_return_error_literal (context,
|
|
NM_SECRET_AGENT_ERROR,
|
|
NM_SECRET_AGENT_ERROR_FAILED,
|
|
"No secrets request in progress for this connection.");
|
|
return;
|
|
}
|
|
|
|
_cancel_get_secret_request (self,
|
|
info,
|
|
"Request cancelled by NetworkManager");
|
|
|
|
g_dbus_method_invocation_return_value (context, NULL);
|
|
}
|
|
|
|
static void
|
|
save_secrets_cb (NMSecretAgentOld *self,
|
|
NMConnection *connection,
|
|
GError *error,
|
|
gpointer user_data)
|
|
{
|
|
GDBusMethodInvocation *context = user_data;
|
|
|
|
if (error)
|
|
g_dbus_method_invocation_return_gerror (context, error);
|
|
else
|
|
g_dbus_method_invocation_return_value (context, NULL);
|
|
}
|
|
|
|
static void
|
|
impl_save_secrets (NMSecretAgentOld *self,
|
|
GVariant *parameters,
|
|
GDBusMethodInvocation *context)
|
|
{
|
|
gs_unref_object NMConnection *connection = NULL;
|
|
gs_unref_variant GVariant *arg_connection = NULL;
|
|
const char *arg_connection_path;
|
|
GError *error = NULL;
|
|
|
|
g_variant_get (parameters,
|
|
"(@a{sa{sv}}&o)",
|
|
&arg_connection,
|
|
&arg_connection_path);
|
|
|
|
if (!verify_request (self, context, arg_connection, arg_connection_path, &connection, &error)) {
|
|
g_dbus_method_invocation_take_error (context, error);
|
|
return;
|
|
}
|
|
|
|
_LOGT ("request: save-secrets(\"%s\")", arg_connection_path);
|
|
|
|
NM_SECRET_AGENT_OLD_GET_CLASS (self)->save_secrets (self,
|
|
connection,
|
|
arg_connection_path,
|
|
save_secrets_cb,
|
|
context);
|
|
}
|
|
|
|
static void
|
|
delete_secrets_cb (NMSecretAgentOld *self,
|
|
NMConnection *connection,
|
|
GError *error,
|
|
gpointer user_data)
|
|
{
|
|
GDBusMethodInvocation *context = user_data;
|
|
|
|
if (error)
|
|
g_dbus_method_invocation_return_gerror (context, error);
|
|
else
|
|
g_dbus_method_invocation_return_value (context, NULL);
|
|
}
|
|
|
|
static void
|
|
impl_delete_secrets (NMSecretAgentOld *self,
|
|
GVariant *parameters,
|
|
GDBusMethodInvocation *context)
|
|
{
|
|
gs_unref_object NMConnection *connection = NULL;
|
|
gs_unref_variant GVariant *arg_connection = NULL;
|
|
const char *arg_connection_path;
|
|
GError *error = NULL;
|
|
|
|
g_variant_get (parameters,
|
|
"(@a{sa{sv}}&o)",
|
|
&arg_connection,
|
|
&arg_connection_path);
|
|
|
|
if (!verify_request (self, context, arg_connection, arg_connection_path, &connection, &error)) {
|
|
g_dbus_method_invocation_take_error (context, error);
|
|
return;
|
|
}
|
|
|
|
_LOGT ("request: delete-secrets(\"%s\")", arg_connection_path);
|
|
|
|
NM_SECRET_AGENT_OLD_GET_CLASS (self)->delete_secrets (self,
|
|
connection,
|
|
arg_connection_path,
|
|
delete_secrets_cb,
|
|
context);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* nm_secret_agent_old_enable:
|
|
* @self: the #NMSecretAgentOld instance
|
|
* @enable: whether to enable or disable the listener.
|
|
*
|
|
* This has the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER
|
|
* property.
|
|
*
|
|
* Unlike most other functions, you may already call this function before
|
|
* initialization completes.
|
|
*
|
|
* Since: 1.24
|
|
*/
|
|
void
|
|
nm_secret_agent_old_enable (NMSecretAgentOld *self,
|
|
gboolean enable)
|
|
{
|
|
NMSecretAgentOldPrivate *priv;
|
|
|
|
g_return_if_fail (NM_IS_SECRET_AGENT_OLD (self));
|
|
|
|
priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
enable = (!!enable);
|
|
|
|
if (priv->auto_register != enable) {
|
|
priv->auto_register = enable;
|
|
priv->is_enabled = enable;
|
|
_notify (self, PROP_AUTO_REGISTER);
|
|
}
|
|
_register_state_change (self);
|
|
}
|
|
|
|
static void
|
|
_secret_agent_old_destroy (NMSecretAgentOld *self)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
priv->is_destroyed = TRUE;
|
|
|
|
if (priv->exported_id != 0) {
|
|
g_dbus_connection_unregister_object (priv->dbus_connection,
|
|
nm_steal_int (&priv->exported_id));
|
|
}
|
|
|
|
_register_state_change (self);
|
|
|
|
nm_assert (!priv->name_owner_changed_id);
|
|
nm_assert (!priv->name_owner_curr);
|
|
nm_assert (!priv->name_owner_next);
|
|
nm_assert (!priv->name_owner_cancellable);
|
|
nm_assert (!priv->registering_retry_source);
|
|
nm_assert (!priv->registering_cancellable);
|
|
nm_assert (!priv->init_data);
|
|
nm_assert (c_list_is_empty (&priv->gsi_lst_head));
|
|
nm_assert (c_list_is_empty (&priv->pending_tasks_register_lst_head));
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_destroy:
|
|
* @self: the #NMSecretAgentOld instance.
|
|
*
|
|
* Since 1.24, the instance will already register a D-Bus object on the
|
|
* D-Bus connection during initialization. That object will stay registered
|
|
* until @self gets unrefed (destroyed) or this function is called. This
|
|
* function performs the necessary cleanup to tear down the instance. Afterwards,
|
|
* the function can not longer be used. This is optional, but necessary to
|
|
* ensure unregistering the D-Bus object at a define point, when other users
|
|
* might still have a reference on @self.
|
|
*
|
|
* You may call this function any time and repeatedly. However, after destroying
|
|
* the instance, it is a bug to still use the instance for other purposes. The
|
|
* instance becomes defunct and cannot re-register.
|
|
*
|
|
* Since: 1.24
|
|
*/
|
|
void
|
|
nm_secret_agent_old_destroy (NMSecretAgentOld *self)
|
|
{
|
|
g_return_if_fail (NM_IS_SECRET_AGENT_OLD (self));
|
|
|
|
_LOGT ("destroying");
|
|
|
|
_secret_agent_old_destroy (self);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* nm_secret_agent_old_register:
|
|
* @self: a #NMSecretAgentOld
|
|
* @cancellable: a #GCancellable, or %NULL
|
|
* @error: return location for a #GError, or %NULL
|
|
*
|
|
* Registers the #NMSecretAgentOld with the NetworkManager secret manager,
|
|
* indicating to NetworkManager that the agent is able to provide and save
|
|
* secrets for connections on behalf of its user.
|
|
*
|
|
* Returns: %TRUE if registration was successful, %FALSE on error.
|
|
*
|
|
* Since 1.24, this can no longer fail unless the @cancellable gets
|
|
* cancelled. Contrary to nm_secret_agent_old_register_async(), this also
|
|
* does not wait for the registration to succeed. You cannot synchronously
|
|
* (without iterating the caller's GMainContext) wait for registration.
|
|
*
|
|
* Since 1.24, registration is idempotent. It has the same effect as setting
|
|
* %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %TRUE or nm_secret_agent_old_enable().
|
|
*
|
|
* Deprecated: 1.24: use nm_secret_agent_old_enable() or nm_secret_agent_old_register_async().
|
|
**/
|
|
gboolean
|
|
nm_secret_agent_old_register (NMSecretAgentOld *self,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
NMSecretAgentOldPrivate *priv;
|
|
|
|
g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), FALSE);
|
|
g_return_val_if_fail (!error || !*error, FALSE);
|
|
|
|
priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
g_return_val_if_fail (priv->is_initialized && !priv->is_destroyed, FALSE);
|
|
|
|
priv->is_enabled = TRUE;
|
|
_register_state_change (self);
|
|
|
|
if (g_cancellable_set_error_if_cancelled (cancellable, error))
|
|
return FALSE;
|
|
|
|
/* This is a synchronous function, meaning: we are not allowed to iterate
|
|
* the caller's GMainContext. This is a catch 22, because we don't want
|
|
* to perform synchronous calls that bypasses the ordering of our otherwise
|
|
* asynchronous mode of operation. Hence, we always signal success.
|
|
* That's why this function is deprecated.
|
|
*
|
|
* So despite claiming success, we might still be in the process of registering
|
|
* or NetworkManager might not be available.
|
|
*
|
|
* This is a change in behavior with respect to libnm before 1.24.
|
|
*/
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
_register_cancelled_cb (GObject *object, gpointer user_data)
|
|
{
|
|
GTask *task0 = user_data;
|
|
gs_unref_object GTask *task = NULL;
|
|
NMSecretAgentOld *self = g_task_get_source_object (task0);
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
gulong *p_cancelled_id;
|
|
NMCListElem *elem;
|
|
gs_free_error GError *error = NULL;
|
|
|
|
elem = nm_c_list_elem_find_first (&priv->pending_tasks_register_lst_head, x, x == task0);
|
|
|
|
g_return_if_fail (elem);
|
|
|
|
task = nm_c_list_elem_free_steal (elem);
|
|
|
|
p_cancelled_id = g_task_get_task_data (task);
|
|
if (p_cancelled_id) {
|
|
g_signal_handler_disconnect (g_task_get_cancellable (task), *p_cancelled_id);
|
|
g_task_set_task_data (task, NULL, NULL);
|
|
}
|
|
|
|
nm_utils_error_set_cancelled (&error, FALSE, NULL);
|
|
g_task_return_error (task, error);
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_register_async:
|
|
* @self: a #NMSecretAgentOld
|
|
* @cancellable: a #GCancellable, or %NULL
|
|
* @callback: callback to call when the agent is registered
|
|
* @user_data: data for @callback
|
|
*
|
|
* Asynchronously registers the #NMSecretAgentOld with the NetworkManager secret
|
|
* manager, indicating to NetworkManager that the agent is able to provide and
|
|
* save secrets for connections on behalf of its user.
|
|
*
|
|
* Since 1.24, registration cannot fail and is idempotent. It has
|
|
* the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %TRUE
|
|
* or nm_secret_agent_old_enable().
|
|
*
|
|
* Since 1.24, the asynchronous result indicates whether the instance is successfully
|
|
* registered. In any case, this call enables the agent and it will automatically
|
|
* try to register and handle secret requests. A failure of this function only indicates
|
|
* that currently the instance might not be ready (but since it will automatically
|
|
* try to recover, it might be ready in a moment afterwards). Use this function if
|
|
* you want to check and ensure that the agent is registered.
|
|
**/
|
|
void
|
|
nm_secret_agent_old_register_async (NMSecretAgentOld *self,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
NMSecretAgentOldPrivate *priv;
|
|
|
|
g_return_if_fail (NM_IS_SECRET_AGENT_OLD (self));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
g_return_if_fail (priv->is_initialized && !priv->is_destroyed);
|
|
|
|
if (callback) {
|
|
GTask *task;
|
|
|
|
task = nm_g_task_new (self, cancellable, nm_secret_agent_old_register_async, callback, user_data);
|
|
|
|
c_list_link_tail (&priv->pending_tasks_register_lst_head,
|
|
&nm_c_list_elem_new_stale (task)->lst);
|
|
|
|
if (cancellable) {
|
|
gulong cancelled_id;
|
|
|
|
cancelled_id = g_cancellable_connect (cancellable,
|
|
G_CALLBACK (_register_cancelled_cb),
|
|
task,
|
|
NULL);
|
|
if (cancelled_id != 0) {
|
|
g_task_set_task_data (task,
|
|
g_memdup (&cancelled_id, sizeof (cancelled_id)),
|
|
g_free);
|
|
}
|
|
}
|
|
}
|
|
|
|
priv->is_enabled = TRUE;
|
|
_register_state_change (self);
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_register_finish:
|
|
* @self: a #NMSecretAgentOld
|
|
* @result: the result passed to the #GAsyncReadyCallback
|
|
* @error: return location for a #GError, or %NULL
|
|
*
|
|
* Gets the result of a call to nm_secret_agent_old_register_async().
|
|
*
|
|
* Returns: %TRUE if registration was successful, %FALSE on error.
|
|
*
|
|
* Since 1.24, registration cannot fail and is idempotent. It has
|
|
* the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %TRUE
|
|
* or nm_secret_agent_old_enable().
|
|
**/
|
|
gboolean
|
|
nm_secret_agent_old_register_finish (NMSecretAgentOld *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), FALSE);
|
|
g_return_val_if_fail (nm_g_task_is_valid (result, self, nm_secret_agent_old_register_async), FALSE);
|
|
|
|
return g_task_propagate_boolean (G_TASK (result), error);
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_unregister:
|
|
* @self: a #NMSecretAgentOld
|
|
* @cancellable: a #GCancellable, or %NULL
|
|
* @error: return location for a #GError, or %NULL
|
|
*
|
|
* Unregisters the #NMSecretAgentOld with the NetworkManager secret manager,
|
|
* indicating to NetworkManager that the agent will no longer provide or
|
|
* store secrets on behalf of this user.
|
|
*
|
|
* Returns: %TRUE if unregistration was successful, %FALSE on error
|
|
*
|
|
* Since 1.24, registration cannot fail and is idempotent. It has
|
|
* the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %FALSE
|
|
* or nm_secret_agent_old_enable().
|
|
*
|
|
* Deprecated: 1.24: use nm_secret_agent_old_enable()
|
|
**/
|
|
gboolean
|
|
nm_secret_agent_old_unregister (NMSecretAgentOld *self,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
NMSecretAgentOldPrivate *priv;
|
|
|
|
g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), FALSE);
|
|
g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
|
|
g_return_val_if_fail (!error || !*error, FALSE);
|
|
|
|
priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
g_return_val_if_fail (priv->is_initialized && !priv->is_destroyed, FALSE);
|
|
|
|
priv->is_enabled = FALSE;
|
|
_register_state_change (self);
|
|
|
|
return !g_cancellable_set_error_if_cancelled (cancellable, error);
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_unregister_async:
|
|
* @self: a #NMSecretAgentOld
|
|
* @cancellable: a #GCancellable, or %NULL
|
|
* @callback: callback to call when the agent is unregistered
|
|
* @user_data: data for @callback
|
|
*
|
|
* Asynchronously unregisters the #NMSecretAgentOld with the NetworkManager secret
|
|
* manager, indicating to NetworkManager that the agent will no longer provide
|
|
* or store secrets on behalf of this user.
|
|
*
|
|
* Since 1.24, registration cannot fail and is idempotent. It has
|
|
* the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %FALSE
|
|
* or nm_secret_agent_old_enable().
|
|
*
|
|
* Deprecated: 1.24: use nm_secret_agent_old_enable()
|
|
**/
|
|
void
|
|
nm_secret_agent_old_unregister_async (NMSecretAgentOld *self,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
NMSecretAgentOldPrivate *priv;
|
|
|
|
g_return_if_fail (NM_IS_SECRET_AGENT_OLD (self));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
g_return_if_fail (priv->is_initialized && !priv->is_destroyed);
|
|
|
|
if (callback) {
|
|
gs_unref_object GTask *task = NULL;
|
|
|
|
task = nm_g_task_new (self, cancellable, nm_secret_agent_old_unregister_async, callback, user_data);
|
|
g_task_return_boolean (task, TRUE);
|
|
}
|
|
|
|
priv->is_enabled = FALSE;
|
|
_register_state_change (self);
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_unregister_finish:
|
|
* @self: a #NMSecretAgentOld
|
|
* @result: the result passed to the #GAsyncReadyCallback
|
|
* @error: return location for a #GError, or %NULL
|
|
*
|
|
* Gets the result of a call to nm_secret_agent_old_unregister_async().
|
|
*
|
|
* Returns: %TRUE if unregistration was successful, %FALSE on error.
|
|
*
|
|
* Since 1.24, registration cannot fail and is idempotent. It has
|
|
* the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %FALSE
|
|
* or nm_secret_agent_old_enable().
|
|
*
|
|
* Deprecated: 1.24: use nm_secret_agent_old_enable()
|
|
**/
|
|
gboolean
|
|
nm_secret_agent_old_unregister_finish (NMSecretAgentOld *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), FALSE);
|
|
g_return_val_if_fail (nm_g_task_is_valid (result, self, nm_secret_agent_old_unregister_async), FALSE);
|
|
|
|
return g_task_propagate_boolean (G_TASK (result), error);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* nm_secret_agent_old_get_secrets: (virtual get_secrets):
|
|
* @self: a #NMSecretAgentOld
|
|
* @connection: the #NMConnection for which we're asked secrets
|
|
* @setting_name: the name of the secret setting
|
|
* @hints: (array zero-terminated=1): hints to the agent
|
|
* @flags: flags that modify the behavior of the request
|
|
* @callback: (scope async): a callback, to be invoked when the operation is done
|
|
* @user_data: (closure): caller-specific data to be passed to @callback
|
|
*
|
|
* Asynchronously retrieves secrets belonging to @connection for the
|
|
* setting @setting_name. @flags indicate specific behavior that the secret
|
|
* agent should use when performing the request, for example returning only
|
|
* existing secrets without user interaction, or requesting entirely new
|
|
* secrets from the user.
|
|
*/
|
|
void
|
|
nm_secret_agent_old_get_secrets (NMSecretAgentOld *self,
|
|
NMConnection *connection,
|
|
const char *setting_name,
|
|
const char **hints,
|
|
NMSecretAgentGetSecretsFlags flags,
|
|
NMSecretAgentOldGetSecretsFunc callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (NM_IS_SECRET_AGENT_OLD (self));
|
|
g_return_if_fail (NM_IS_CONNECTION (connection));
|
|
g_return_if_fail (nm_connection_get_path (connection));
|
|
g_return_if_fail (setting_name && setting_name[0]);
|
|
g_return_if_fail (!(flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_ONLY_SYSTEM));
|
|
g_return_if_fail (!(flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_NO_ERRORS));
|
|
g_return_if_fail (callback != NULL);
|
|
|
|
NM_SECRET_AGENT_OLD_GET_CLASS (self)->get_secrets (self,
|
|
connection,
|
|
nm_connection_get_path (connection),
|
|
setting_name,
|
|
hints,
|
|
flags,
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_save_secrets: (virtual save_secrets):
|
|
* @self: a #NMSecretAgentOld
|
|
* @connection: a #NMConnection
|
|
* @callback: (scope async): a callback, to be invoked when the operation is done
|
|
* @user_data: (closure): caller-specific data to be passed to @callback
|
|
*
|
|
* Asynchronously ensures that all secrets inside @connection are stored to
|
|
* disk.
|
|
*/
|
|
void
|
|
nm_secret_agent_old_save_secrets (NMSecretAgentOld *self,
|
|
NMConnection *connection,
|
|
NMSecretAgentOldSaveSecretsFunc callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (NM_IS_SECRET_AGENT_OLD (self));
|
|
g_return_if_fail (NM_IS_CONNECTION (connection));
|
|
g_return_if_fail (nm_connection_get_path (connection));
|
|
|
|
NM_SECRET_AGENT_OLD_GET_CLASS (self)->save_secrets (self,
|
|
connection,
|
|
nm_connection_get_path (connection),
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* nm_secret_agent_old_delete_secrets: (virtual delete_secrets):
|
|
* @self: a #NMSecretAgentOld
|
|
* @connection: a #NMConnection
|
|
* @callback: (scope async): a callback, to be invoked when the operation is done
|
|
* @user_data: (closure): caller-specific data to be passed to @callback
|
|
*
|
|
* Asynchronously asks the agent to delete all saved secrets belonging to
|
|
* @connection.
|
|
*/
|
|
void
|
|
nm_secret_agent_old_delete_secrets (NMSecretAgentOld *self,
|
|
NMConnection *connection,
|
|
NMSecretAgentOldDeleteSecretsFunc callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (NM_IS_SECRET_AGENT_OLD (self));
|
|
g_return_if_fail (NM_IS_CONNECTION (connection));
|
|
g_return_if_fail (nm_connection_get_path (connection));
|
|
|
|
NM_SECRET_AGENT_OLD_GET_CLASS (self)->delete_secrets (self,
|
|
connection,
|
|
nm_connection_get_path (connection),
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gboolean
|
|
validate_identifier (const char *identifier)
|
|
{
|
|
const char *p = identifier;
|
|
size_t id_len;
|
|
|
|
/* Length between 3 and 255 characters inclusive */
|
|
id_len = strlen (identifier);
|
|
if (id_len < 3 || id_len > 255)
|
|
return FALSE;
|
|
|
|
if ((identifier[0] == '.') || (identifier[id_len - 1] == '.'))
|
|
return FALSE;
|
|
|
|
/* FIXME: do complete validation here */
|
|
while (p && *p) {
|
|
if (!g_ascii_isalnum (*p) && (*p != '_') && (*p != '-') && (*p != '.'))
|
|
return FALSE;
|
|
if ((*p == '.') && (*(p + 1) == '.'))
|
|
return FALSE;
|
|
p++;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gboolean
|
|
_register_retry_cb (gpointer user_data)
|
|
{
|
|
NMSecretAgentOld *self = user_data;
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
nm_auto_pop_gmaincontext GMainContext *dbus_context = NULL;
|
|
|
|
dbus_context = nm_g_main_context_push_thread_default_if_necessary (priv->dbus_context);
|
|
|
|
nm_clear_g_source_inst (&priv->registering_retry_source);
|
|
_register_dbus_call (self);
|
|
return G_SOURCE_CONTINUE;
|
|
}
|
|
|
|
static void
|
|
_register_call_cb (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
NMSecretAgentOld *self = user_data;
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
gs_unref_variant GVariant *ret = NULL;
|
|
gs_free_error GError *error = NULL;
|
|
|
|
ret = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), result, &error);
|
|
|
|
if (nm_utils_error_is_cancelled (error))
|
|
return;
|
|
|
|
nm_assert (!priv->registering_retry_source);
|
|
nm_assert (!priv->is_registered);
|
|
nm_assert (priv->registering_cancellable);
|
|
|
|
if ( nm_dbus_error_is (error, NM_DBUS_ERROR_NAME_UNKNOWN_METHOD)
|
|
&& nm_utils_get_monotonic_timestamp_msec () < priv->registering_timeout_msec) {
|
|
guint timeout_msec;
|
|
|
|
timeout_msec = (2u << NM_MIN (6u, ++priv->registering_try_count));
|
|
|
|
_LOGT ("register: registration failed with error \"%s\". Retry in %u msec...", error->message, timeout_msec);
|
|
|
|
priv->registering_retry_source = nm_g_source_attach (nm_g_timeout_source_new (timeout_msec,
|
|
G_PRIORITY_DEFAULT,
|
|
_register_retry_cb,
|
|
self,
|
|
NULL),
|
|
priv->dbus_context);
|
|
return;
|
|
}
|
|
|
|
g_clear_object (&priv->registering_cancellable);
|
|
|
|
if (error) {
|
|
/* registration apparently failed. However we still keep priv->registered_against_server TRUE, because
|
|
*
|
|
* - eventually we want to still make an Unregister() call. Even if it probably has no effect,
|
|
* better be sure.
|
|
*
|
|
* - we actually accept secret request (from the right name owner). We register so that
|
|
* NetworkManager knows that we are here. We don't require the registration to succeed
|
|
* for our purpose. If NetworkManager makes requests for us, despite the registration
|
|
* failing, that is fine. */
|
|
_LOGT ("register: registration failed with error \"%s\"", error->message);
|
|
goto out;
|
|
}
|
|
|
|
_LOGT ("register: registration succeeded");
|
|
priv->is_registered = TRUE;
|
|
_notify (self, PROP_REGISTERED);
|
|
|
|
out:
|
|
_register_state_complete (self);
|
|
}
|
|
|
|
static void
|
|
_register_dbus_call (NMSecretAgentOld *self)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
_dbus_connection_call (self,
|
|
nm_ref_string_get_str (priv->name_owner_curr),
|
|
NM_DBUS_PATH_AGENT_MANAGER,
|
|
NM_DBUS_INTERFACE_AGENT_MANAGER,
|
|
"RegisterWithCapabilities",
|
|
g_variant_new ("(su)",
|
|
priv->identifier,
|
|
(guint32) priv->capabilities),
|
|
G_VARIANT_TYPE ("()"),
|
|
G_DBUS_CALL_FLAGS_NONE,
|
|
_CALL_REGISTER_TIMEOUT_MSEC,
|
|
priv->registering_cancellable,
|
|
_register_call_cb,
|
|
self);
|
|
}
|
|
|
|
static void
|
|
_get_connection_unix_user_cb (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
NMSecretAgentOld *self;
|
|
NMSecretAgentOldPrivate *priv;
|
|
gs_unref_variant GVariant *ret = NULL;
|
|
gs_free_error GError *error = NULL;
|
|
guint32 sender_uid = 0;
|
|
|
|
ret = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), result, &error);
|
|
if (nm_utils_error_is_cancelled (error))
|
|
return;
|
|
|
|
self = user_data;
|
|
priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
nm_assert (priv->registering_cancellable);
|
|
nm_assert (!priv->registered_against_server);
|
|
|
|
if (ret)
|
|
g_variant_get (ret, "(u)", &sender_uid);
|
|
|
|
if ( ret
|
|
&& sender_uid == 0)
|
|
_LOGT ("register: peer %s is owned by root. Validated to accept requests.", priv->name_owner_curr->str);
|
|
else if ( ret
|
|
&& priv->session_bus) {
|
|
_LOGT ("register: peer %s is owned by user %d for session bus. Validated to accept requests.", priv->name_owner_curr->str, sender_uid);
|
|
} else {
|
|
/* the peer is not validated. We don't actually register. */
|
|
if (ret)
|
|
_LOGT ("register: peer %s is owned by user %u. Not validated as NetworkManager service.", priv->name_owner_curr->str, sender_uid);
|
|
else
|
|
_LOGT ("register: failed to get user id for peer %s: %s. Not validated as NetworkManager service.", priv->name_owner_curr->str, error->message);
|
|
|
|
/* we actually don't do anything and keep the agent unregistered.
|
|
*
|
|
* We keep priv->registering_cancellable set to not retry this again, until we loose the
|
|
* name owner. But the state of the agent is lingering and won't accept any requests. */
|
|
return;
|
|
}
|
|
|
|
priv->registering_timeout_msec = nm_utils_get_monotonic_timestamp_msec () + REGISTER_RETRY_TIMEOUT_MSEC;
|
|
priv->registering_try_count = 0;
|
|
priv->registered_against_server = TRUE;
|
|
_register_dbus_call (self);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
_name_owner_changed (NMSecretAgentOld *self,
|
|
const char *name_owner,
|
|
gboolean is_event)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
if (is_event) {
|
|
if (priv->name_owner_cancellable) {
|
|
/* we are still fetching the name-owner. Ignore this event. */
|
|
return;
|
|
}
|
|
} else
|
|
g_clear_object (&priv->name_owner_cancellable);
|
|
|
|
nm_ref_string_unref (priv->name_owner_next);
|
|
priv->name_owner_next = nm_ref_string_new (nm_str_not_empty (name_owner));
|
|
|
|
_LOGT ("name-owner changed: %s%s%s -> %s%s%s",
|
|
NM_PRINT_FMT_QUOTED (priv->name_owner_curr, "\"", priv->name_owner_curr->str, "\"", "(null)"),
|
|
NM_PRINT_FMT_QUOTED (priv->name_owner_next, "\"", priv->name_owner_next->str, "\"", "(null)"));
|
|
|
|
_register_state_change (self);
|
|
}
|
|
|
|
static void
|
|
_name_owner_changed_cb (GDBusConnection *connection,
|
|
const char *sender_name,
|
|
const char *object_path,
|
|
const char *interface_name,
|
|
const char *signal_name,
|
|
GVariant *parameters,
|
|
gpointer user_data)
|
|
{
|
|
NMSecretAgentOld *self = user_data;
|
|
const char *new_owner;
|
|
|
|
if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(sss)")))
|
|
return;
|
|
|
|
g_variant_get (parameters,
|
|
"(&s&s&s)",
|
|
NULL,
|
|
NULL,
|
|
&new_owner);
|
|
|
|
_name_owner_changed (self, new_owner, TRUE);
|
|
}
|
|
|
|
static void
|
|
_name_owner_get_cb (const char *name_owner,
|
|
GError *error,
|
|
gpointer user_data)
|
|
{
|
|
if ( name_owner
|
|
|| !nm_utils_error_is_cancelled (error))
|
|
_name_owner_changed (user_data, name_owner, FALSE);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
_method_call (GDBusConnection *connection,
|
|
const char *sender,
|
|
const char *object_path,
|
|
const char *interface_name,
|
|
const char *method_name,
|
|
GVariant *parameters,
|
|
GDBusMethodInvocation *context,
|
|
gpointer user_data)
|
|
{
|
|
NMSecretAgentOld *self = user_data;
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
nm_assert (nm_streq0 (object_path, NM_DBUS_PATH_SECRET_AGENT));
|
|
nm_assert (nm_streq0 (interface_name, NM_DBUS_INTERFACE_SECRET_AGENT));
|
|
nm_assert (sender);
|
|
nm_assert (nm_streq0 (sender, g_dbus_method_invocation_get_sender (context)));
|
|
|
|
if ( !priv->name_owner_curr
|
|
|| !priv->registered_against_server) {
|
|
/* priv->registered_against_server means that we started to register, but not necessarily
|
|
* that the registration fully succeeded. However, we already authenticated the request
|
|
* and so we accept it, even if the registration is not yet complete. */
|
|
g_dbus_method_invocation_return_error_literal (context,
|
|
NM_SECRET_AGENT_ERROR,
|
|
NM_SECRET_AGENT_ERROR_PERMISSION_DENIED,
|
|
"Request by non authenticated peer rejected");
|
|
return;
|
|
}
|
|
|
|
if (nm_streq (method_name, "GetSecrets"))
|
|
impl_get_secrets (self, parameters, context);
|
|
else if (nm_streq (method_name, "CancelGetSecrets"))
|
|
impl_cancel_get_secrets (self, parameters, context);
|
|
else if (nm_streq (method_name, "SaveSecrets"))
|
|
impl_save_secrets (self, parameters, context);
|
|
else if (nm_streq (method_name, "DeleteSecrets"))
|
|
impl_delete_secrets (self, parameters, context);
|
|
else
|
|
nm_assert_not_reached ();
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
_register_state_complete (NMSecretAgentOld *self)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
NMCListElem *elem;
|
|
gboolean any_tasks_to_complete = FALSE;
|
|
|
|
if (!c_list_is_empty (&priv->pending_tasks_register_lst_head)) {
|
|
/* add a dummy sentinel. We want to complete all the task we started
|
|
* so far, but as we invoke user callbacks, the user might register
|
|
* new tasks. Those we don't complete in this run. */
|
|
g_object_ref (self);
|
|
any_tasks_to_complete = TRUE;
|
|
c_list_link_tail (&priv->pending_tasks_register_lst_head,
|
|
&nm_c_list_elem_new_stale (&any_tasks_to_complete)->lst);
|
|
}
|
|
|
|
_init_complete (self, NULL);
|
|
|
|
if (any_tasks_to_complete) {
|
|
while ((elem = c_list_first_entry (&priv->pending_tasks_register_lst_head, NMCListElem, lst))) {
|
|
gpointer data = nm_c_list_elem_free_steal (elem);
|
|
gs_unref_object GTask *task = NULL;
|
|
|
|
if (data == &any_tasks_to_complete) {
|
|
any_tasks_to_complete = FALSE;
|
|
break;
|
|
}
|
|
|
|
task = data;
|
|
|
|
if (!priv->is_registered) {
|
|
g_task_return_error (task,
|
|
g_error_new_literal (NM_SECRET_AGENT_ERROR,
|
|
NM_SECRET_AGENT_ERROR_FAILED,
|
|
_("registration failed")));
|
|
continue;
|
|
}
|
|
g_task_return_boolean (task, TRUE);
|
|
}
|
|
nm_assert (!any_tasks_to_complete);
|
|
g_object_unref (self);
|
|
}
|
|
}
|
|
|
|
static void
|
|
_register_state_change_do (NMSecretAgentOld *self)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
if (priv->is_destroyed)
|
|
priv->is_enabled = FALSE;
|
|
|
|
if ( !priv->is_enabled
|
|
|| priv->registration_force_unregister
|
|
|| priv->name_owner_curr != priv->name_owner_next) {
|
|
GetSecretsInfo *info;
|
|
|
|
while ((info = c_list_first_entry (&priv->gsi_lst_head, GetSecretsInfo, gsi_lst))) {
|
|
_cancel_get_secret_request (self, info, "The secret agent is going away");
|
|
_register_state_change (self);
|
|
return;
|
|
}
|
|
|
|
priv->registration_force_unregister = FALSE;
|
|
|
|
nm_clear_g_cancellable (&priv->registering_cancellable);
|
|
nm_clear_g_source_inst (&priv->registering_retry_source);
|
|
|
|
if (priv->registered_against_server) {
|
|
priv->registered_against_server = FALSE;
|
|
if (priv->name_owner_curr) {
|
|
_LOGT ("register: unregister from %s", priv->name_owner_curr->str);
|
|
_dbus_connection_call (self,
|
|
priv->name_owner_curr->str,
|
|
NM_DBUS_PATH_AGENT_MANAGER,
|
|
NM_DBUS_INTERFACE_AGENT_MANAGER,
|
|
"Unregister",
|
|
g_variant_new ("()"),
|
|
G_VARIANT_TYPE ("()"),
|
|
G_DBUS_CALL_FLAGS_NONE,
|
|
_CALL_REGISTER_TIMEOUT_MSEC,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
}
|
|
}
|
|
|
|
if (!priv->is_enabled) {
|
|
nm_clear_g_cancellable (&priv->name_owner_cancellable);
|
|
nm_clear_g_dbus_connection_signal (priv->dbus_connection,
|
|
&priv->name_owner_changed_id);
|
|
nm_clear_pointer (&priv->name_owner_curr, nm_ref_string_unref);
|
|
nm_clear_pointer (&priv->name_owner_next, nm_ref_string_unref);
|
|
}
|
|
|
|
if (priv->is_registered) {
|
|
priv->is_registered = FALSE;
|
|
if (!priv->is_destroyed) {
|
|
_LOGT ("register: now unregistered");
|
|
_notify (self, PROP_REGISTERED);
|
|
_register_state_change (self);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!priv->is_enabled) {
|
|
_register_state_complete (self);
|
|
return;
|
|
}
|
|
|
|
if (priv->name_owner_curr != priv->name_owner_next) {
|
|
nm_ref_string_unref (priv->name_owner_curr);
|
|
priv->name_owner_curr = nm_ref_string_ref (priv->name_owner_next);
|
|
}
|
|
}
|
|
|
|
if (priv->name_owner_changed_id == 0) {
|
|
nm_assert (!priv->name_owner_cancellable);
|
|
nm_assert (!priv->name_owner_curr);
|
|
nm_assert (!priv->name_owner_next);
|
|
priv->name_owner_cancellable = g_cancellable_new ();
|
|
priv->name_owner_changed_id = nm_dbus_connection_signal_subscribe_name_owner_changed (priv->dbus_connection,
|
|
NM_DBUS_SERVICE,
|
|
_name_owner_changed_cb,
|
|
self,
|
|
NULL);
|
|
nm_dbus_connection_call_get_name_owner (priv->dbus_connection,
|
|
NM_DBUS_SERVICE,
|
|
-1,
|
|
priv->name_owner_cancellable,
|
|
_name_owner_get_cb,
|
|
self);
|
|
return;
|
|
}
|
|
|
|
if (priv->name_owner_cancellable) {
|
|
/* we still wait for the name owner. Nothing to do for now. */
|
|
return;
|
|
}
|
|
|
|
if (!priv->name_owner_curr) {
|
|
/* we don't have a name owner. We are done and wait. */
|
|
_register_state_complete (self);
|
|
return;
|
|
}
|
|
|
|
if (priv->registering_cancellable) {
|
|
/* we are already registering... wait longer. */
|
|
return;
|
|
}
|
|
|
|
nm_assert (!priv->registering_retry_source);
|
|
|
|
if (!priv->is_registered) {
|
|
/* start registering... */
|
|
priv->registering_cancellable = g_cancellable_new ();
|
|
_dbus_connection_call (self,
|
|
DBUS_SERVICE_DBUS,
|
|
DBUS_PATH_DBUS,
|
|
DBUS_INTERFACE_DBUS,
|
|
"GetConnectionUnixUser",
|
|
g_variant_new ("(s)", priv->name_owner_curr->str),
|
|
G_VARIANT_TYPE ("(u)"),
|
|
G_DBUS_CALL_FLAGS_NONE,
|
|
_CALL_REGISTER_TIMEOUT_MSEC,
|
|
priv->registering_cancellable,
|
|
_get_connection_unix_user_cb,
|
|
self);
|
|
return;
|
|
}
|
|
|
|
/* we are fully registered and done. */
|
|
_register_state_complete (self);
|
|
}
|
|
|
|
static void
|
|
_register_state_change (NMSecretAgentOld *self)
|
|
{
|
|
_nm_unused gs_unref_object NMSecretAgentOld *self_keep_alive = g_object_ref (self);
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
nm_auto_pop_gmaincontext GMainContext *dbus_context = NULL;
|
|
|
|
if (priv->register_state_change_reenter == 0) {
|
|
/* We are not yet initialized. Do nothing. */
|
|
return;
|
|
}
|
|
|
|
if (priv->register_state_change_reenter != 1) {
|
|
/* Recursive calls are prevented. Do nothing for now, but repeat
|
|
* the state change afterwards. */
|
|
priv->register_state_change_reenter = 3;
|
|
return;
|
|
}
|
|
|
|
dbus_context = nm_g_main_context_push_thread_default_if_necessary (priv->dbus_context);
|
|
|
|
again:
|
|
priv->register_state_change_reenter = 2;
|
|
|
|
_register_state_change_do (self);
|
|
|
|
if (priv->register_state_change_reenter != 2)
|
|
goto again;
|
|
|
|
priv->register_state_change_reenter = 1;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
_init_complete (NMSecretAgentOld *self,
|
|
GError *error_take)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
gs_free_error GError *error = g_steal_pointer (&error_take);
|
|
GError *error_cancelled = NULL;
|
|
|
|
if (!priv->init_data)
|
|
return;
|
|
|
|
if (g_cancellable_set_error_if_cancelled (priv->init_data->cancellable, &error_cancelled)) {
|
|
g_clear_error (&error);
|
|
g_propagate_error (&error, error_cancelled);
|
|
}
|
|
|
|
priv->is_initialized = (!error);
|
|
|
|
_LOGT ("%s init complete with %s%s%s",
|
|
priv->init_data->is_sync ? "sync" : "async",
|
|
NM_PRINT_FMT_QUOTED (error_take, "error: ", error_take->message, "", "success"));
|
|
|
|
nml_init_data_return (g_steal_pointer (&priv->init_data),
|
|
g_steal_pointer (&error));
|
|
}
|
|
|
|
static void
|
|
_init_register_object (NMSecretAgentOld *self)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
gs_free_error GError *error = NULL;
|
|
GDBusInterfaceVTable interface_vtable = {
|
|
.method_call = _method_call,
|
|
};
|
|
|
|
if (g_cancellable_set_error_if_cancelled (priv->init_data->cancellable, &error)) {
|
|
_init_complete (self, g_steal_pointer (&error));
|
|
return;
|
|
}
|
|
|
|
priv->exported_id = g_dbus_connection_register_object (priv->dbus_connection,
|
|
NM_DBUS_PATH_SECRET_AGENT,
|
|
(GDBusInterfaceInfo*) &interface_info,
|
|
&interface_vtable,
|
|
self,
|
|
NULL,
|
|
&error);
|
|
if (priv->exported_id == 0) {
|
|
_init_complete (self, g_steal_pointer (&error));
|
|
return;
|
|
}
|
|
|
|
priv->register_state_change_reenter = 1;
|
|
|
|
_register_state_change (self);
|
|
}
|
|
|
|
static void
|
|
_init_got_bus (GObject *initable, GAsyncResult *result, gpointer user_data)
|
|
{
|
|
NMSecretAgentOld *self = user_data;
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
gs_free_error GError *error = NULL;
|
|
|
|
priv->dbus_connection = g_bus_get_finish (result, &error);
|
|
if (!priv->dbus_connection) {
|
|
_init_complete (self, g_steal_pointer (&error));
|
|
return;
|
|
}
|
|
|
|
_LOGT ("init: got GDBusConnection");
|
|
|
|
_notify (self, PROP_DBUS_CONNECTION);
|
|
|
|
_init_register_object (self);
|
|
}
|
|
|
|
static void
|
|
_init_start (NMSecretAgentOld *self)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
if (!priv->dbus_connection) {
|
|
GBusType bus_type;
|
|
|
|
bus_type = _nm_dbus_bus_type ();
|
|
|
|
priv->session_bus = (bus_type == G_BUS_TYPE_SESSION);
|
|
|
|
g_bus_get (bus_type,
|
|
priv->init_data->cancellable,
|
|
_init_got_bus,
|
|
self);
|
|
return;
|
|
}
|
|
|
|
_init_register_object (self);
|
|
}
|
|
|
|
static void
|
|
init_async (GAsyncInitable *initable,
|
|
int io_priority,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
NMSecretAgentOld *self;
|
|
NMSecretAgentOldClass *klass;
|
|
NMSecretAgentOldPrivate *priv;
|
|
nm_auto_pop_gmaincontext GMainContext *dbus_context = NULL;
|
|
gs_unref_object GTask *task = NULL;
|
|
|
|
g_return_if_fail (NM_IS_SECRET_AGENT_OLD (initable));
|
|
|
|
self = NM_SECRET_AGENT_OLD (initable);
|
|
priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
g_return_if_fail (!priv->dbus_context);
|
|
g_return_if_fail (!priv->is_destroyed);
|
|
|
|
klass = NM_SECRET_AGENT_OLD_GET_CLASS (self);
|
|
g_return_if_fail (klass->get_secrets);
|
|
g_return_if_fail (klass->cancel_get_secrets);
|
|
g_return_if_fail (klass->save_secrets);
|
|
g_return_if_fail (klass->delete_secrets);
|
|
|
|
_LOGT ("init-async starting...");
|
|
|
|
priv->dbus_context = g_main_context_ref (priv->main_context);
|
|
|
|
dbus_context = nm_g_main_context_push_thread_default_if_necessary (priv->dbus_context);
|
|
|
|
task = nm_g_task_new (self, cancellable, init_async, callback, user_data);
|
|
g_task_set_priority (task, io_priority);
|
|
|
|
priv->init_data = nml_init_data_new_async (cancellable, g_steal_pointer (&task));
|
|
|
|
_init_start (self);
|
|
}
|
|
|
|
static gboolean
|
|
init_finish (GAsyncInitable *initable, GAsyncResult *result, GError **error)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (initable), FALSE);
|
|
g_return_val_if_fail (nm_g_task_is_valid (result, initable, init_async), FALSE);
|
|
|
|
return g_task_propagate_boolean (G_TASK (result), error);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gboolean
|
|
init_sync (GInitable *initable,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
gs_unref_object NMSecretAgentOld *self = NULL;
|
|
NMSecretAgentOldPrivate *priv;
|
|
NMSecretAgentOldClass *klass;
|
|
GMainLoop *main_loop;
|
|
GError *local_error = NULL;
|
|
|
|
g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (initable), FALSE);
|
|
|
|
self = g_object_ref (NM_SECRET_AGENT_OLD (initable));
|
|
priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
g_return_val_if_fail (!priv->dbus_context, FALSE);
|
|
g_return_val_if_fail (!priv->is_destroyed, FALSE);
|
|
|
|
klass = NM_SECRET_AGENT_OLD_GET_CLASS (self);
|
|
g_return_val_if_fail (klass->get_secrets, FALSE);
|
|
g_return_val_if_fail (klass->cancel_get_secrets, FALSE);
|
|
g_return_val_if_fail (klass->save_secrets, FALSE);
|
|
g_return_val_if_fail (klass->delete_secrets, FALSE);
|
|
|
|
_LOGT ("init-sync");
|
|
|
|
/* See NMClient's sync-init method for explanation about why we create
|
|
* an internal GMainContext priv->dbus_context. */
|
|
|
|
priv->dbus_context = g_main_context_new ();
|
|
|
|
g_main_context_push_thread_default (priv->dbus_context);
|
|
|
|
main_loop = g_main_loop_new (priv->dbus_context, FALSE);
|
|
|
|
priv->init_data = nml_init_data_new_sync (cancellable, main_loop, &local_error);
|
|
|
|
_init_start (self);
|
|
|
|
g_main_loop_run (main_loop);
|
|
|
|
g_main_loop_unref (main_loop);
|
|
|
|
g_main_context_pop_thread_default (priv->dbus_context);
|
|
|
|
nm_context_busy_watcher_integrate_source (priv->main_context,
|
|
priv->dbus_context,
|
|
priv->context_busy_watcher);
|
|
|
|
if (local_error) {
|
|
g_propagate_error (error, local_error);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_DBUS_CONNECTION:
|
|
g_value_set_object (value, priv->dbus_connection);
|
|
break;
|
|
case PROP_IDENTIFIER:
|
|
g_value_set_string (value, priv->identifier);
|
|
break;
|
|
case PROP_AUTO_REGISTER:
|
|
g_value_set_boolean (value, priv->auto_register);
|
|
break;
|
|
case PROP_REGISTERED:
|
|
g_value_set_boolean (value, priv->is_registered);
|
|
break;
|
|
case PROP_CAPABILITIES:
|
|
g_value_set_flags (value, priv->capabilities);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
NMSecretAgentOld *self = NM_SECRET_AGENT_OLD (object);
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
guint u;
|
|
|
|
switch (prop_id) {
|
|
case PROP_DBUS_CONNECTION:
|
|
/* construct-only */
|
|
priv->dbus_connection = g_value_dup_object (value);
|
|
break;
|
|
case PROP_IDENTIFIER:
|
|
/* construct-only */
|
|
priv->identifier = g_value_dup_string (value);
|
|
g_return_if_fail (validate_identifier (priv->identifier));
|
|
break;
|
|
case PROP_AUTO_REGISTER:
|
|
/* construct */
|
|
priv->auto_register = g_value_get_boolean (value);
|
|
priv->is_enabled = priv->auto_register;
|
|
_register_state_change (self);
|
|
break;
|
|
case PROP_CAPABILITIES:
|
|
/* construct */
|
|
u = g_value_get_flags (value);
|
|
if (u != priv->capabilities) {
|
|
priv->capabilities = u;
|
|
priv->registration_force_unregister = TRUE;
|
|
_register_state_change (self);
|
|
}
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
nm_secret_agent_old_init (NMSecretAgentOld *self)
|
|
{
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
_LOGT ("create new instance");
|
|
|
|
c_list_init (&priv->gsi_lst_head);
|
|
c_list_init (&priv->pending_tasks_register_lst_head);
|
|
|
|
priv->main_context = g_main_context_ref_thread_default ();
|
|
priv->context_busy_watcher = g_object_new (G_TYPE_OBJECT, NULL);
|
|
}
|
|
|
|
static void
|
|
dispose (GObject *object)
|
|
{
|
|
NMSecretAgentOld *self = NM_SECRET_AGENT_OLD (object);
|
|
|
|
_LOGT ("disposing");
|
|
|
|
_secret_agent_old_destroy (self);
|
|
|
|
G_OBJECT_CLASS (nm_secret_agent_old_parent_class)->dispose (object);
|
|
}
|
|
|
|
static void
|
|
finalize (GObject *object)
|
|
{
|
|
NMSecretAgentOld *self = NM_SECRET_AGENT_OLD (object);
|
|
NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
|
|
|
|
_LOGT ("finalizing");
|
|
|
|
if (priv->dbus_context) {
|
|
nml_cleanup_context_busy_watcher_on_idle (g_steal_pointer (&priv->context_busy_watcher),
|
|
priv->dbus_context);
|
|
}
|
|
|
|
g_clear_object (&priv->dbus_connection);
|
|
nm_clear_pointer (&priv->dbus_context, g_main_context_unref);
|
|
nm_clear_pointer (&priv->main_context, g_main_context_unref);
|
|
|
|
g_clear_object (&priv->context_busy_watcher);
|
|
|
|
g_free (priv->identifier);
|
|
|
|
G_OBJECT_CLASS (nm_secret_agent_old_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
nm_secret_agent_old_class_init (NMSecretAgentOldClass *class)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (class);
|
|
|
|
g_type_class_add_private (class, sizeof (NMSecretAgentOldPrivate));
|
|
|
|
object_class->get_property = get_property;
|
|
object_class->set_property = set_property;
|
|
object_class->dispose = dispose;
|
|
object_class->finalize = finalize;
|
|
|
|
/**
|
|
* NMSecretAgentOld:dbus-connection:
|
|
*
|
|
* The #GDBusConnection used by the instance. You may either set this
|
|
* as construct-only property, or otherwise #NMSecretAgentOld will choose
|
|
* a connection via g_bus_get() during initialization.
|
|
*
|
|
* Since: 1.24
|
|
**/
|
|
obj_properties[PROP_DBUS_CONNECTION] =
|
|
g_param_spec_object (NM_SECRET_AGENT_OLD_DBUS_CONNECTION, "", "",
|
|
G_TYPE_DBUS_CONNECTION,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
/**
|
|
* NMSecretAgentOld:identifier:
|
|
*
|
|
* Identifies this agent; only one agent in each user session may use the
|
|
* same identifier. Identifier formatting follows the same rules as
|
|
* D-Bus bus names with the exception that the ':' character is not
|
|
* allowed. The valid set of characters is "[A-Z][a-z][0-9]_-." and the
|
|
* identifier is limited in length to 255 characters with a minimum
|
|
* of 3 characters. An example valid identifier is 'org.gnome.nm-applet'
|
|
* (without quotes).
|
|
**/
|
|
obj_properties[PROP_IDENTIFIER] =
|
|
g_param_spec_string (NM_SECRET_AGENT_OLD_IDENTIFIER, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
/**
|
|
* NMSecretAgentOld:auto-register:
|
|
*
|
|
* If %TRUE (the default), the agent will always be registered when
|
|
* NetworkManager is running; if NetworkManager exits and restarts, the
|
|
* agent will re-register itself automatically.
|
|
*
|
|
* In particular, if this property is %TRUE at construct time, then the
|
|
* agent will register itself with NetworkManager during
|
|
* construction/initialization and initialization will only complete
|
|
* after registration is completed (either successfully or unsucessfully).
|
|
* Since 1.24, a failure to register will no longer cause initialization
|
|
* of #NMSecretAgentOld to fail.
|
|
*
|
|
* If the property is %FALSE, the agent will not automatically register with
|
|
* NetworkManager, and nm_secret_agent_old_enable() or
|
|
* nm_secret_agent_old_register_async() must be called to register it.
|
|
*
|
|
* Calling nm_secret_agent_old_enable() has the same effect as setting this
|
|
* property.
|
|
**/
|
|
obj_properties[PROP_AUTO_REGISTER] =
|
|
g_param_spec_boolean (NM_SECRET_AGENT_OLD_AUTO_REGISTER, "", "",
|
|
TRUE,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
/**
|
|
* NMSecretAgentOld:registered:
|
|
*
|
|
* %TRUE if the agent is registered with NetworkManager, %FALSE if not.
|
|
**/
|
|
obj_properties[PROP_REGISTERED] =
|
|
g_param_spec_boolean (NM_SECRET_AGENT_OLD_REGISTERED, "", "",
|
|
FALSE,
|
|
G_PARAM_READABLE |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
/**
|
|
* NMSecretAgentOld:capabilities:
|
|
*
|
|
* A bitfield of %NMSecretAgentCapabilities.
|
|
*
|
|
* Changing this property is possible at any time. In case the secret
|
|
* agent is currently registered, this will cause a re-registration.
|
|
**/
|
|
obj_properties[PROP_CAPABILITIES] =
|
|
g_param_spec_flags (NM_SECRET_AGENT_OLD_CAPABILITIES, "", "",
|
|
NM_TYPE_SECRET_AGENT_CAPABILITIES,
|
|
NM_SECRET_AGENT_CAPABILITY_NONE,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
g_object_class_install_properties (object_class, _PROPERTY_ENUMS_LAST, obj_properties);
|
|
}
|
|
|
|
static void
|
|
nm_secret_agent_old_initable_iface_init (GInitableIface *iface)
|
|
{
|
|
iface->init = init_sync;
|
|
}
|
|
|
|
static void
|
|
nm_secret_agent_old_async_initable_iface_init (GAsyncInitableIface *iface)
|
|
{
|
|
iface->init_async = init_async;
|
|
iface->init_finish = init_finish;
|
|
}
|