system/NetworkManager
system/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager synced 2024-10-15 12:34:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

libnm: start glib-ifying NMSecretAgent APIs

Browse source 
Make register() and unregister() have cancellable sync and async
variants. And make NMSecretAgent implement GInitable/GAsyncInitable,
and do the initial auto-registration as part of initialization rather
than doing it asynchronously and emitting a signal.
This commit is contained in:
Dan Winship 2014-09-02 21:41:05 -04:00
parent c9fb96e02e
commit d3b53b707a
6 changed files with 569 additions and 193 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
clients/tui/nmt-secret-agent.c
View file

@ -639,8 +639,7 @@ nmt_secret_agent_class_init (NmtSecretAgentClass *klass)
NMSecretAgent *
nmt_secret_agent_new (void)
{
return g_object_new (NMT_TYPE_SECRET_AGENT,
NM_SECRET_AGENT_IDENTIFIER, "nmtui",
NM_SECRET_AGENT_AUTO_REGISTER, FALSE,
NULL);
return g_initable_new (NMT_TYPE_SECRET_AGENT, NULL, NULL,
NM_SECRET_AGENT_IDENTIFIER, "nmtui",
NULL);
}

7
clients/tui/nmtui-connect.c
View file

@ -142,7 +142,6 @@ activate_connection (NMConnection *connection,
nmt_newt_form_set_content (form, label);
agent = nmt_secret_agent_new ();
nm_secret_agent_register (agent);
g_signal_connect (agent, "request-secrets", G_CALLBACK (secrets_requested), NULL);
specific_object_path = specific_object ? nm_object_get_path (specific_object) : NULL;
@ -203,11 +202,7 @@ activate_connection (NMConnection *connection,
nmt_newt_form_quit (form);
g_object_unref (form);
/* If the activation failed very quickly, then agent won't be registered yet,
* and nm_secret_agent_unregister() would complain if we called it...
*/
if (nm_secret_agent_get_registered (agent))
nm_secret_agent_unregister (agent);
nm_secret_agent_unregister (agent, NULL, NULL);
g_object_unref (agent);
}

4
libnm/libnm.ver
View file

@ -370,8 +370,12 @@ global:
nm_secret_agent_get_secrets_flags_get_type;
nm_secret_agent_get_type;
nm_secret_agent_register;
nm_secret_agent_register_async;
nm_secret_agent_register_finish;
nm_secret_agent_save_secrets;
nm_secret_agent_unregister;
nm_secret_agent_unregister_async;
nm_secret_agent_unregister_finish;
nm_setting_802_1x_add_altsubject_match;
nm_setting_802_1x_add_eap_method;
nm_setting_802_1x_add_phase2_altsubject_match;

621
libnm/nm-secret-agent.c
View file

@ -54,14 +54,18 @@ static void impl_secret_agent_delete_secrets (NMSecretAgent *self,
#include "nm-secret-agent-glue.h"
G_DEFINE_ABSTRACT_TYPE (NMSecretAgent, nm_secret_agent, G_TYPE_OBJECT)
static void nm_secret_agent_initable_iface_init (GInitableIface *iface);
static void nm_secret_agent_async_initable_iface_init (GAsyncInitableIface *iface);
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (NMSecretAgent, nm_secret_agent, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, nm_secret_agent_initable_iface_init);
G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, nm_secret_agent_async_initable_iface_init);
)
#define NM_SECRET_AGENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SECRET_AGENT, NMSecretAgentPrivate))
static gboolean auto_register_cb (gpointer user_data);
typedef struct {
gboolean registered;
gboolean registering;
NMSecretAgentCapabilities capabilities;
DBusGConnection *bus;
@ -69,7 +73,6 @@ typedef struct {
gboolean session_bus;
DBusGProxy *dbus_proxy;
DBusGProxy *manager_proxy;
DBusGProxyCall *reg_call;
/* GetSecretsInfo structs of in-flight GetSecrets requests */
GSList *pending_gets;
@ -79,7 +82,6 @@ typedef struct {
char *identifier;
gboolean auto_register;
gboolean suppress_auto;
gboolean auto_register_id;
} NMSecretAgentPrivate;
enum {
@ -92,15 +94,6 @@ enum {
LAST_PROP
};
enum {
REGISTRATION_RESULT,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
/********************************************************************/
GQuark
@ -146,6 +139,7 @@ _internal_unregister (NMSecretAgent *self)
if (priv->registered) {
dbus_g_connection_unregister_g_object (priv->bus, G_OBJECT (self));
priv->registered = FALSE;
priv->registering = FALSE;
g_object_notify (G_OBJECT (self), NM_SECRET_AGENT_REGISTERED);
}
}
@ -171,6 +165,17 @@ get_secrets_info_finalize (NMSecretAgent *self, GetSecretsInfo *info)
g_free (info);
}
static inline gboolean
should_auto_register (NMSecretAgent *self)
{
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
return ( priv->auto_register
&& !priv->suppress_auto
&& !priv->registered
&& !priv->registering);
}
static void
name_owner_changed (DBusGProxy *proxy,
const char *name,
@ -190,7 +195,8 @@ name_owner_changed (DBusGProxy *proxy,
if (!old_owner_good && new_owner_good) {
/* NM appeared */
auto_register_cb (self);
if (should_auto_register (self))
nm_secret_agent_register_async (self, NULL, NULL, NULL);
} else if (old_owner_good && !new_owner_good) {
/* Cancel any pending secrets requests */
for (iter = priv->pending_gets; iter; iter = g_slist_next (iter)) {
@ -208,7 +214,8 @@ name_owner_changed (DBusGProxy *proxy,
} else if (old_owner_good && new_owner_good && strcmp (old_owner, new_owner)) {
/* Hmm, NM magically restarted */
_internal_unregister (self);
auto_register_cb (self);
if (should_auto_register (self))
nm_secret_agent_register_async (self, NULL, NULL, NULL);
}
}
}
@ -538,82 +545,40 @@ impl_secret_agent_delete_secrets (NMSecretAgent *self,
/**************************************************************/
static void
reg_result (NMSecretAgent *self, GError *error)
static gboolean
check_nm_running (NMSecretAgent *self, GError **error)
{
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
if (error) {
/* If registration failed we shouldn't expose ourselves on the bus */
_internal_unregister (self);
} else {
priv->registered = TRUE;
g_object_notify (G_OBJECT (self), NM_SECRET_AGENT_REGISTERED);
}
if (priv->nm_owner || priv->private_bus)
return TRUE;
g_signal_emit (self, signals[REGISTRATION_RESULT], 0, error);
g_set_error (error, NM_SECRET_AGENT_ERROR, NM_SECRET_AGENT_ERROR_INTERNAL_ERROR,
"NetworkManager is not running");
return FALSE;
}
static void
reg_request_cb (DBusGProxy *proxy,
DBusGProxyCall *call,
gpointer user_data)
{
NMSecretAgent *self = NM_SECRET_AGENT (user_data);
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
GError *error = NULL;
priv->reg_call = NULL;
dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
reg_result (self, error);
g_clear_error (&error);
}
static void
reg_with_caps_cb (DBusGProxy *proxy,
DBusGProxyCall *call,
gpointer user_data)
{
NMSecretAgent *self = NM_SECRET_AGENT (user_data);
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
priv->reg_call = NULL;
if (dbus_g_proxy_end_call (proxy, call, NULL, G_TYPE_INVALID)) {
reg_result (self, NULL);
return;
}
/* Might be an old NetworkManager that doesn't support capabilities;
* fall back to old Register() method instead.
*/
priv->reg_call = dbus_g_proxy_begin_call_with_timeout (priv->manager_proxy,
"Register",
reg_request_cb,
self,
NULL,
5000,
G_TYPE_STRING, priv->identifier,
G_TYPE_INVALID);
}
/**************************************************************/
/**
* nm_secret_agent_register:
* @self: a #NMSecretAgent
* @cancellable: a #GCancellable, or %NULL
* @error: return location for a #GError, or %NULL
*
* Registers the #NMSecretAgent 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. Registration is an
* asynchronous operation and its success or failure is indicated via the
* 'registration-result' signal.
* secrets for connections on behalf of its user.
*
* Returns: a new %TRUE if registration was successfully requested (this does
* not mean registration itself was successful), %FALSE if registration was not
* successfully requested.
* It is a programmer error to attempt to register an agent that is already
* registered, or in the process of registering.
*
* Returns: %TRUE if registration was successful, %FALSE on error.
**/
gboolean
nm_secret_agent_register (NMSecretAgent *self)
nm_secret_agent_register (NMSecretAgent *self,
GCancellable *cancellable,
GError **error)
{
NMSecretAgentPrivate *priv;
NMSecretAgentClass *class;
@ -623,7 +588,7 @@ nm_secret_agent_register (NMSecretAgent *self)
priv = NM_SECRET_AGENT_GET_PRIVATE (self);
g_return_val_if_fail (priv->registered == FALSE, FALSE);
g_return_val_if_fail (priv->reg_call == NULL, FALSE);
g_return_val_if_fail (priv->registering == FALSE, FALSE);
g_return_val_if_fail (priv->bus != NULL, FALSE);
g_return_val_if_fail (priv->manager_proxy != NULL, FALSE);
@ -633,7 +598,7 @@ nm_secret_agent_register (NMSecretAgent *self)
g_return_val_if_fail (class->save_secrets != NULL, FALSE);
g_return_val_if_fail (class->delete_secrets != NULL, FALSE);
if (!priv->nm_owner && !priv->private_bus)
if (!check_nm_running (self, error))
return FALSE;
priv->suppress_auto = FALSE;
@ -643,32 +608,224 @@ nm_secret_agent_register (NMSecretAgent *self)
NM_DBUS_PATH_SECRET_AGENT,
G_OBJECT (self));
priv->reg_call = dbus_g_proxy_begin_call_with_timeout (priv->manager_proxy,
"RegisterWithCapabilities",
reg_with_caps_cb,
self,
NULL,
5000,
G_TYPE_STRING, priv->identifier,
G_TYPE_UINT, priv->capabilities,
G_TYPE_INVALID);
priv->registering = TRUE;
if (dbus_g_proxy_call_with_timeout (priv->manager_proxy,
"RegisterWithCapabilities",
5000, NULL,
G_TYPE_STRING, priv->identifier,
G_TYPE_UINT, priv->capabilities,
G_TYPE_INVALID,
G_TYPE_INVALID))
goto success;
/* Might be an old NetworkManager that doesn't support capabilities;
* fall back to old Register() method instead.
*/
if (dbus_g_proxy_call_with_timeout (priv->manager_proxy,
"Register",
5000, error,
G_TYPE_STRING, priv->identifier,
G_TYPE_INVALID,
G_TYPE_INVALID))
goto success;
/* Failure */
priv->registering = FALSE;
_internal_unregister (self);
return FALSE;
success:
priv->registering = FALSE;
priv->registered = TRUE;
g_object_notify (G_OBJECT (self), NM_SECRET_AGENT_REGISTERED);
return TRUE;
}
static void
reg_result (NMSecretAgent *self, GSimpleAsyncResult *simple, GError *error)
{
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
priv->registering = FALSE;
if (error) {
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete (simple);
/* If registration failed we shouldn't expose ourselves on the bus */
_internal_unregister (self);
} else {
priv->registered = TRUE;
g_object_notify (G_OBJECT (self), NM_SECRET_AGENT_REGISTERED);
g_simple_async_result_set_op_res_gboolean (simple, TRUE);
g_simple_async_result_complete (simple);
}
g_object_unref (simple);
}
static void
reg_request_cb (DBusGProxy *proxy,
DBusGProxyCall *call,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
NMSecretAgent *self;
GError *error = NULL;
self = NM_SECRET_AGENT (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
g_object_unref (self); /* drop extra ref added by get_source_object() */
dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
reg_result (self, simple, error);
}
static void
reg_with_caps_cb (DBusGProxy *proxy,
DBusGProxyCall *call,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
NMSecretAgent *self;
NMSecretAgentPrivate *priv;
self = NM_SECRET_AGENT (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
g_object_unref (self); /* drop extra ref added by get_source_object() */
priv = NM_SECRET_AGENT_GET_PRIVATE (self);
if (dbus_g_proxy_end_call (proxy, call, NULL, G_TYPE_INVALID)) {
reg_result (self, simple, NULL);
return;
}
/* Might be an old NetworkManager that doesn't support capabilities;
* fall back to old Register() method instead.
*/
dbus_g_proxy_begin_call_with_timeout (priv->manager_proxy,
"Register",
reg_request_cb,
self,
NULL,
5000,
G_TYPE_STRING, priv->identifier,
G_TYPE_INVALID);
}
/**
* nm_secret_agent_register_async:
* @self: a #NMSecretAgent
* @cancellable: a #GCancellable, or %NULL
* @callback: callback to call when the agent is registered
* @user_data: data for @callback
*
* Asynchronously registers the #NMSecretAgent 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.
*
* It is a programmer error to attempt to register an agent that is already
* registered, or in the process of registering.
**/
void
nm_secret_agent_register_async (NMSecretAgent *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
NMSecretAgentPrivate *priv;
NMSecretAgentClass *class;
GSimpleAsyncResult *simple;
GError *error = NULL;
g_return_if_fail (NM_IS_SECRET_AGENT (self));
priv = NM_SECRET_AGENT_GET_PRIVATE (self);
g_return_if_fail (priv->registered == FALSE);
g_return_if_fail (priv->registering == FALSE);
g_return_if_fail (priv->bus != NULL);
g_return_if_fail (priv->manager_proxy != NULL);
/* Also make sure the subclass can actually respond to secrets requests */
class = NM_SECRET_AGENT_GET_CLASS (self);
g_return_if_fail (class->get_secrets != NULL);
g_return_if_fail (class->save_secrets != NULL);
g_return_if_fail (class->delete_secrets != NULL);
simple = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
nm_secret_agent_register_async);
if (!check_nm_running (self, &error)) {
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
priv->suppress_auto = FALSE;
/* Export our secret agent interface before registering with the manager */
dbus_g_connection_register_g_object (priv->bus,
NM_DBUS_PATH_SECRET_AGENT,
G_OBJECT (self));
priv->registering = TRUE;
dbus_g_proxy_begin_call_with_timeout (priv->manager_proxy,
"RegisterWithCapabilities",
reg_with_caps_cb,
simple,
NULL,
5000,
G_TYPE_STRING, priv->identifier,
G_TYPE_UINT, priv->capabilities,
G_TYPE_INVALID);
}
/**
* nm_secret_agent_register_finish:
* @self: a #NMSecretAgent
* @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_register_async().
*
* Returns: %TRUE if registration was successful, %FALSE on error.
**/
gboolean
nm_secret_agent_register_finish (NMSecretAgent *self,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self), nm_secret_agent_register_async), FALSE);
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
return FALSE;
else
return TRUE;
}
/**
* nm_secret_agent_unregister:
* @self: a #NMSecretAgent
* @cancellable: a #GCancellable, or %NULL
* @error: return location for a #GError, or %NULL
*
* Unregisters the #NMSecretAgent with the NetworkManager secret manager,
* indicating to NetworkManager that the agent is will no longer provide or
* indicating to NetworkManager that the agent will no longer provide or
* store secrets on behalf of this user.
*
* Returns: a new %TRUE if unregistration was successful, %FALSE if it was not.
* It is a programmer error to attempt to unregister an agent that is not
* registered.
*
* Returns: %TRUE if unregistration was successful, %FALSE on error
**/
gboolean
nm_secret_agent_unregister (NMSecretAgent *self)
nm_secret_agent_unregister (NMSecretAgent *self,
GCancellable *cancellable,
GError **error)
{
NMSecretAgentPrivate *priv;
gboolean success;
g_return_val_if_fail (NM_IS_SECRET_AGENT (self), FALSE);
@ -678,15 +835,118 @@ nm_secret_agent_unregister (NMSecretAgent *self)
g_return_val_if_fail (priv->bus != NULL, FALSE);
g_return_val_if_fail (priv->manager_proxy != NULL, FALSE);
if (!priv->nm_owner && !priv->private_bus)
if (!check_nm_running (self, error))
return FALSE;
dbus_g_proxy_call_no_reply (priv->manager_proxy, "Unregister", G_TYPE_INVALID);
_internal_unregister (self);
priv->suppress_auto = TRUE;
return TRUE;
success = dbus_g_proxy_call_with_timeout (priv->manager_proxy,
"Unregister",
5000, error,
G_TYPE_INVALID,
G_TYPE_INVALID);
_internal_unregister (self);
return success;
}
static void
unregister_cb (DBusGProxy *proxy,
DBusGProxyCall *call,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
NMSecretAgent *self;
GError *error = NULL;
self = NM_SECRET_AGENT (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
g_object_unref (self); /* drop extra ref added by get_source_object() */
_internal_unregister (self);
if (dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID))
g_simple_async_result_set_op_res_gboolean (simple, TRUE);
else
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete (simple);
g_object_unref (simple);
}
/**
* nm_secret_agent_unregister_async:
* @self: a #NMSecretAgent
* @cancellable: a #GCancellable, or %NULL
* @callback: callback to call when the agent is unregistered
* @user_data: data for @callback
*
* Asynchronously unregisters the #NMSecretAgent with the NetworkManager secret
* manager, indicating to NetworkManager that the agent will no longer provide
* or store secrets on behalf of this user.
*
* It is a programmer error to attempt to unregister an agent that is not
* registered.
**/
void
nm_secret_agent_unregister_async (NMSecretAgent *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
NMSecretAgentPrivate *priv;
GSimpleAsyncResult *simple;
GError *error = NULL;
g_return_val_if_fail (NM_IS_SECRET_AGENT (self), FALSE);
priv = NM_SECRET_AGENT_GET_PRIVATE (self);
g_return_val_if_fail (priv->registered == TRUE, FALSE);
g_return_val_if_fail (priv->bus != NULL, FALSE);
g_return_val_if_fail (priv->manager_proxy != NULL, FALSE);
simple = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
nm_secret_agent_unregister_async);
if (!check_nm_running (self, &error)) {
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
priv->suppress_auto = TRUE;
dbus_g_proxy_begin_call_with_timeout (priv->manager_proxy,
"Unregister",
unregister_cb,
simple,
NULL,
5000,
G_TYPE_INVALID);
}
/**
* nm_secret_agent_unregister_finish:
* @self: a #NMSecretAgent
* @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_unregister_async().
*
* Returns: %TRUE if unregistration was successful, %FALSE on error.
**/
gboolean
nm_secret_agent_unregister_finish (NMSecretAgent *self,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self), nm_secret_agent_unregister_async), FALSE);
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
return FALSE;
else
return TRUE;
}
/**
@ -703,19 +963,6 @@ nm_secret_agent_get_registered (NMSecretAgent *self)
return NM_SECRET_AGENT_GET_PRIVATE (self)->registered;
}
static gboolean
auto_register_cb (gpointer user_data)
{
NMSecretAgent *self = NM_SECRET_AGENT (user_data);
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
priv->auto_register_id = 0;
if (priv->auto_register && !priv->suppress_auto &&
(priv->reg_call == NULL && !priv->registered))
nm_secret_agent_register (self);
return FALSE;
}
/**************************************************************/
/**
@ -728,7 +975,7 @@ auto_register_cb (gpointer user_data)
* @callback: (scope async): a callback, to be invoked when the operation is done
* @user_data: (closure): caller-specific data to be passed to @callback
*
* Asyncronously retrieve secrets belonging to @connection for the
* 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
@ -770,8 +1017,8 @@ nm_secret_agent_get_secrets (NMSecretAgent *self,
* @callback: (scope async): a callback, to be invoked when the operation is done
* @user_data: (closure): caller-specific data to be passed to @callback
*
* Asyncronously ensure that all secrets inside @connection
* are stored to disk.
* Asynchronously ensures that all secrets inside @connection are stored to
* disk.
*
* Virtual: save_secrets
*/
@ -799,7 +1046,7 @@ nm_secret_agent_save_secrets (NMSecretAgent *self,
* @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 ask the agent to delete all saved secrets belonging to
* Asynchronously asks the agent to delete all saved secrets belonging to
* @connection.
*
* Virtual: delete_secrets
@ -851,17 +1098,18 @@ validate_identifier (const char *identifier)
static void
nm_secret_agent_init (NMSecretAgent *self)
{
}
static gboolean
init_common (NMSecretAgent *self, GError **error)
{
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
DBusGConnection *session_bus;
GError *error = NULL;
priv->bus = _nm_dbus_new_connection (&error);
if (!priv->bus) {
g_warning ("Couldn't connect to system bus: %s", error->message);
g_error_free (error);
return;
}
priv->bus = _nm_dbus_new_connection (error);
if (!priv->bus)
return FALSE;
priv->private_bus = _nm_dbus_is_connection_private (priv->bus);
session_bus = dbus_g_bus_get (DBUS_BUS_SESSION, NULL);
@ -896,12 +1144,82 @@ nm_secret_agent_init (NMSecretAgent *self)
NM_DBUS_PATH_AGENT_MANAGER,
NM_DBUS_INTERFACE_AGENT_MANAGER);
if (!priv->manager_proxy) {
g_warning ("Couldn't create NM agent manager proxy.");
g_set_error_literal (error, NM_SECRET_AGENT_ERROR, NM_SECRET_AGENT_ERROR_INTERNAL_ERROR,
"Couldn't create NM agent manager proxy.");
return FALSE;
}
return TRUE;
}
static gboolean
init_sync (GInitable *initable, GCancellable *cancellable, GError **error)
{
NMSecretAgent *self = NM_SECRET_AGENT (initable);
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
if (!init_common (self, error))
return FALSE;
if (priv->auto_register)
return nm_secret_agent_register (self, cancellable, error);
else
return TRUE;
}
static void
init_async_registered (GObject *initable, GAsyncResult *result, gpointer user_data)
{
NMSecretAgent *self = NM_SECRET_AGENT (initable);
GSimpleAsyncResult *simple = user_data;
GError *error = NULL;
if (nm_secret_agent_register_finish (self, result, &error))
g_simple_async_result_set_op_res_gboolean (simple, TRUE);
else
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
}
static void
init_async (GAsyncInitable *initable, int io_priority,
GCancellable *cancellable, GAsyncReadyCallback callback,
gpointer user_data)
{
NMSecretAgent *self = NM_SECRET_AGENT (initable);
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
GSimpleAsyncResult *simple;
GError *error = NULL;
simple = g_simple_async_result_new (G_OBJECT (initable), callback, user_data, init_async);
if (!init_common (self, &error)) {
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
if (priv->nm_owner || priv->private_bus)
priv->auto_register_id = g_idle_add (auto_register_cb, self);
if (priv->auto_register)
nm_secret_agent_register_async (self, cancellable, init_async_registered, simple);
else {
g_simple_async_result_set_op_res_gboolean (simple, TRUE);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
}
}
static gboolean
init_finish (GAsyncInitable *initable, GAsyncResult *result, GError **error)
{
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error))
return FALSE;
else
return TRUE;
}
static void
@ -968,12 +1286,7 @@ dispose (GObject *object)
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
if (priv->registered)
nm_secret_agent_unregister (self);
if (priv->auto_register_id) {
g_source_remove (priv->auto_register_id);
priv->auto_register_id = 0;
}
nm_secret_agent_unregister_async (self, NULL, NULL, NULL);
g_free (priv->identifier);
priv->identifier = NULL;
@ -1028,13 +1341,23 @@ nm_secret_agent_class_init (NMSecretAgentClass *class)
/**
* NMSecretAgent:auto-register:
*
* If TRUE, the agent will attempt to automatically register itself after
* it is created (via an idle handler) and to re-register itself if
* NetworkManager restarts. If FALSE, the agent does not automatically
* register with NetworkManager, and nm_secret_agent_register() must be
* called. If 'auto-register' is TRUE, calling nm_secret_agent_unregister()
* will suppress auto-registration until nm_secret_agent_register() is
* called, which re-enables auto-registration.
* 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 fail with an error
* if the agent is unable to register itself.
*
* If the property is %FALSE, the agent will not automatically register with
* NetworkManager, and nm_secret_agent_register() or
* nm_secret_agent_register_async() must be called to register it.
*
* Calling nm_secret_agent_unregister() will suppress auto-registration
* until nm_secret_agent_register() is called, which re-enables
* auto-registration. This ensures that the agent remains un-registered when
* you expect it to be unregistered.
**/
g_object_class_install_property
(object_class, PROP_AUTO_REGISTER,
@ -1070,21 +1393,6 @@ nm_secret_agent_class_init (NMSecretAgentClass *class)
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
/**
* NMSecretAgent::registration-result:
* @agent: the agent that received the signal
* @error: the error, if any, that occured while registering
*
* Indicates the result of a registration request; if @error is NULL the
* request was successful.
**/
signals[REGISTRATION_RESULT] =
g_signal_new (NM_SECRET_AGENT_REGISTRATION_RESULT,
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 1, G_TYPE_POINTER);
dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (class),
&dbus_glib_nm_secret_agent_object_info);
@ -1092,3 +1400,16 @@ nm_secret_agent_class_init (NMSecretAgentClass *class)
NM_DBUS_INTERFACE_SECRET_AGENT,
NM_TYPE_SECRET_AGENT_ERROR);
}
static void
nm_secret_agent_initable_iface_init (GInitableIface *iface)
{
iface->init = init_sync;
}
static void
nm_secret_agent_async_initable_iface_init (GAsyncInitableIface *iface)
{
iface->init_async = init_async;
iface->init_finish = init_finish;
}

28
libnm/nm-secret-agent.h
View file

@ -25,6 +25,7 @@
#error "Only <NetworkManager.h> can be included directly."
#endif
#include <gio/gio.h>
#include <nm-connection.h>
G_BEGIN_DECLS
@ -71,8 +72,6 @@ typedef enum {
#define NM_SECRET_AGENT_REGISTERED "registered"
#define NM_SECRET_AGENT_CAPABILITIES "capabilities"
#define NM_SECRET_AGENT_REGISTRATION_RESULT "registration-result"
typedef struct {
GObject parent;
} NMSecretAgent;
@ -170,9 +169,6 @@ typedef void (*NMSecretAgentDeleteSecretsFunc) (NMSecretAgent *agent,
typedef struct {
GObjectClass parent;
/* Signals */
void (*registration_result) (NMSecretAgent *agent, GError *error);
/* Virtual methods for subclasses */
/* Called when the subclass should retrieve and return secrets. Subclass
@ -231,9 +227,27 @@ typedef struct {
GType nm_secret_agent_get_type (void);
gboolean nm_secret_agent_register (NMSecretAgent *self);
gboolean nm_secret_agent_register (NMSecretAgent *self,
GCancellable *cancellable,
GError **error);
void nm_secret_agent_register_async (NMSecretAgent *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
gboolean nm_secret_agent_register_finish (NMSecretAgent *self,
GAsyncResult *result,
GError **error);
gboolean nm_secret_agent_unregister (NMSecretAgent *self);
gboolean nm_secret_agent_unregister (NMSecretAgent *self,
GCancellable *cancellable,
GError **error);
void nm_secret_agent_unregister_async (NMSecretAgent *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
gboolean nm_secret_agent_unregister_finish (NMSecretAgent *self,
GAsyncResult *result,
GError **error);
gboolean nm_secret_agent_get_registered (NMSecretAgent *self);

95
libnm/tests/test-secret-agent.c
View file

@ -164,10 +164,16 @@ test_secret_agent_class_init (TestSecretAgentClass *klass)
static NMSecretAgent *
test_secret_agent_new (void)
{
return g_object_new (test_secret_agent_get_type (),
NM_SECRET_AGENT_IDENTIFIER, "test-secret-agent",
NM_SECRET_AGENT_AUTO_REGISTER, FALSE,
NULL);
NMSecretAgent *agent;
GError *error = NULL;
agent = g_initable_new (test_secret_agent_get_type (), NULL, &error,
NM_SECRET_AGENT_IDENTIFIER, "test-secret-agent",
NM_SECRET_AGENT_AUTO_REGISTER, FALSE,
NULL);
g_assert_no_error (error);
return agent;
}
/*******************************************************************/
@ -227,11 +233,15 @@ connection_added_cb (NMRemoteSettings *s,
}
static void
registration_result (NMSecretAgent *agent, GError *error, gpointer user_data)
register_cb (GObject *object, GAsyncResult *result, gpointer user_data)
{
TestSecretAgentData *sadata = user_data;
GError *error = NULL;
nm_secret_agent_register_finish (sadata->agent, result, &error);
g_assert_no_error (error);
g_assert (nm_secret_agent_get_registered (sadata->agent));
g_main_loop_quit (sadata->loop);
}
@ -241,7 +251,7 @@ static void
test_setup (TestSecretAgentData *sadata, gconstpointer test_data)
{
static int counter = 0;
gboolean create_agent = GPOINTER_TO_UINT (test_data);
const char *agent_notes = test_data;
NMConnection *connection;
NMSettingConnection *s_con;
NMSettingWireless *s_wireless;
@ -313,13 +323,18 @@ test_setup (TestSecretAgentData *sadata, gconstpointer test_data)
g_main_loop_run (sadata->loop);
g_assert (sadata->connection);
if (create_agent) {
if (agent_notes) {
sadata->agent = test_secret_agent_new ();
nm_secret_agent_register (sadata->agent);
handler = g_signal_connect (sadata->agent, NM_SECRET_AGENT_REGISTRATION_RESULT,
G_CALLBACK (registration_result), sadata);
g_main_loop_run (sadata->loop);
g_signal_handler_disconnect (sadata->agent, handler);
if (!strcmp (agent_notes, "sync")) {
nm_secret_agent_register (sadata->agent, NULL, &error);
g_assert_no_error (error);
g_assert (nm_secret_agent_get_registered (sadata->agent));
} else {
nm_secret_agent_register_async (sadata->agent, NULL,
register_cb, sadata);
g_main_loop_run (sadata->loop);
}
}
}
@ -330,8 +345,10 @@ test_cleanup (TestSecretAgentData *sadata, gconstpointer test_data)
GError *error = NULL;
if (sadata->agent) {
if (nm_secret_agent_get_registered (sadata->agent))
nm_secret_agent_unregister (sadata->agent);
if (nm_secret_agent_get_registered (sadata->agent)) {
nm_secret_agent_unregister (sadata->agent, NULL, &error);
g_assert_no_error (error);
}
g_object_unref (sadata->agent);
}
@ -541,17 +558,43 @@ test_secret_agent_good (TestSecretAgentData *sadata, gconstpointer test_data)
}
static void
async_init_cb (GObject *object, GAsyncResult *result, gpointer user_data)
{
GMainLoop *loop = user_data;
GError *error = NULL;
GObject *agent;
agent = g_async_initable_new_finish (G_ASYNC_INITABLE (object), result, &error);
g_assert_error (error, NM_SECRET_AGENT_ERROR, NM_SECRET_AGENT_ERROR_INTERNAL_ERROR);
g_assert (agent == NULL);
g_clear_error (&error);
g_main_loop_quit (loop);
}
static void
test_secret_agent_nm_not_running (void)
{
NMSecretAgent *agent;
gboolean success;
GMainLoop *loop;
GError *error = NULL;
agent = test_secret_agent_new ();
success = nm_secret_agent_register (agent);
g_assert (!success);
agent = g_initable_new (test_secret_agent_get_type (), NULL, &error,
NM_SECRET_AGENT_IDENTIFIER, "test-secret-agent",
NULL);
g_assert_error (error, NM_SECRET_AGENT_ERROR, NM_SECRET_AGENT_ERROR_INTERNAL_ERROR);
g_assert (agent == NULL);
g_clear_error (&error);
g_object_unref (agent);
loop = g_main_loop_new (NULL, FALSE);
g_async_initable_new_async (test_secret_agent_get_type (),
G_PRIORITY_DEFAULT,
NULL, async_init_cb, loop,
NM_SECRET_AGENT_IDENTIFIER, "test-secret-agent",
NULL);
g_main_loop_run (loop);
g_main_loop_unref (loop);
}
@ -569,6 +612,7 @@ test_secret_agent_auto_register (void)
NMTestServiceInfo *sinfo;
NMSecretAgent *agent;
GMainLoop *loop;
GError *error = NULL;
sinfo = nm_test_service_init ();
loop = g_main_loop_new (NULL, FALSE);
@ -581,9 +625,8 @@ test_secret_agent_auto_register (void)
G_CALLBACK (registered_changed), loop);
g_assert (!nm_secret_agent_get_registered (agent));
/* Wait for initial registration */
g_main_loop_run (loop);
nm_secret_agent_register (agent, NULL, &error);
g_assert_no_error (error);
g_assert (nm_secret_agent_get_registered (agent));
/* Shut down test service */
@ -620,13 +663,13 @@ main (int argc, char **argv)
g_test_init (&argc, &argv, NULL);
g_test_add ("/libnm/secret-agent/none", TestSecretAgentData, GUINT_TO_POINTER (FALSE),
g_test_add ("/libnm/secret-agent/none", TestSecretAgentData, NULL,
test_setup, test_secret_agent_none, test_cleanup);
g_test_add ("/libnm/secret-agent/no-secrets", TestSecretAgentData, GUINT_TO_POINTER (TRUE),
g_test_add ("/libnm/secret-agent/no-secrets", TestSecretAgentData, "sync",
test_setup, test_secret_agent_no_secrets, test_cleanup);
g_test_add ("/libnm/secret-agent/cancel", TestSecretAgentData, GUINT_TO_POINTER (TRUE),
g_test_add ("/libnm/secret-agent/cancel", TestSecretAgentData, "async",
test_setup, test_secret_agent_cancel, test_cleanup);
g_test_add ("/libnm/secret-agent/good", TestSecretAgentData, GUINT_TO_POINTER (TRUE),
g_test_add ("/libnm/secret-agent/good", TestSecretAgentData, "async",
test_setup, test_secret_agent_good, test_cleanup);
g_test_add_func ("/libnm/secret-agent/nm-not-running", test_secret_agent_nm_not_running);
g_test_add_func ("/libnm/secret-agent/auto-register", test_secret_agent_auto_register);