#include "nm-glib-compat.h"
#include "nm-dbus-interface.h"
-#include "nm-secret-agent.h"
+#include "nm-secret-agent-old.h"
#include "nm-enum-types.h"
#include "nm-dbus-helpers.h"
#include "nm-simple-connection.h"
#include "nmdbus-secret-agent.h"
#include "nmdbus-agent-manager.h"
-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);
+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_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SECRET_AGENT, NMSecretAgentPrivate))
+#define NM_SECRET_AGENT_OLD_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SECRET_AGENT_OLD, NMSecretAgentOldPrivate))
typedef struct {
gboolean registered;
char *identifier;
gboolean auto_register;
gboolean suppress_auto;
-} NMSecretAgentPrivate;
+} NMSecretAgentOldPrivate;
enum {
PROP_0,
/*************************************************************/
static void
-_internal_unregister (NMSecretAgent *self)
+_internal_unregister (NMSecretAgentOld *self)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
if (priv->registered) {
g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (priv->dbus_secret_agent));
priv->registered = FALSE;
priv->registering = FALSE;
- g_object_notify (G_OBJECT (self), NM_SECRET_AGENT_REGISTERED);
+ g_object_notify (G_OBJECT (self), NM_SECRET_AGENT_OLD_REGISTERED);
}
}
} GetSecretsInfo;
static void
-get_secrets_info_finalize (NMSecretAgent *self, GetSecretsInfo *info)
+get_secrets_info_finalize (NMSecretAgentOld *self, GetSecretsInfo *info)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
g_return_if_fail (info != NULL);
}
static inline gboolean
-should_auto_register (NMSecretAgent *self)
+should_auto_register (NMSecretAgentOld *self)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
return ( priv->auto_register
&& !priv->suppress_auto
GParamSpec *pspec,
gpointer user_data)
{
- NMSecretAgent *self = NM_SECRET_AGENT (user_data);
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOld *self = NM_SECRET_AGENT_OLD (user_data);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
GSList *iter;
char *owner;
owner = g_dbus_proxy_get_name_owner (G_DBUS_PROXY (proxy));
if (owner != NULL) {
if (should_auto_register (self))
- nm_secret_agent_register_async (self, NULL, NULL, NULL);
+ nm_secret_agent_old_register_async (self, NULL, NULL, NULL);
g_free (owner);
} else {
/* Cancel any pending secrets requests */
for (iter = priv->pending_gets; iter; iter = g_slist_next (iter)) {
GetSecretsInfo *info = iter->data;
- NM_SECRET_AGENT_GET_CLASS (self)->cancel_get_secrets (self,
+ NM_SECRET_AGENT_OLD_GET_CLASS (self)->cancel_get_secrets (self,
info->path,
info->setting_name);
}
}
static gboolean
-verify_sender (NMSecretAgent *self,
+verify_sender (NMSecretAgentOld *self,
GDBusMethodInvocation *context,
GError **error)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
char *nm_owner;
const char *sender;
guint32 sender_uid;
}
static gboolean
-verify_request (NMSecretAgent *self,
+verify_request (NMSecretAgentOld *self,
GDBusMethodInvocation *context,
GVariant *connection_dict,
const char *connection_path,
}
static void
-get_secrets_cb (NMSecretAgent *self,
+get_secrets_cb (NMSecretAgentOld *self,
NMConnection *connection,
GVariant *secrets,
GError *error,
}
static void
-impl_secret_agent_get_secrets (NMSecretAgent *self,
- GDBusMethodInvocation *context,
- GVariant *connection_dict,
- const char *connection_path,
- const char *setting_name,
- const char * const *hints,
- guint flags,
- gpointer user_data)
+impl_secret_agent_old_get_secrets (NMSecretAgentOld *self,
+ GDBusMethodInvocation *context,
+ GVariant *connection_dict,
+ const char *connection_path,
+ const char *setting_name,
+ const char * const *hints,
+ guint flags,
+ gpointer user_data)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
GError *error = NULL;
NMConnection *connection = NULL;
GetSecretsInfo *info;
info->context = context;
priv->pending_gets = g_slist_append (priv->pending_gets, info);
- NM_SECRET_AGENT_GET_CLASS (self)->get_secrets (self,
+ NM_SECRET_AGENT_OLD_GET_CLASS (self)->get_secrets (self,
connection,
connection_path,
setting_name,
}
static void
-impl_secret_agent_cancel_get_secrets (NMSecretAgent *self,
- GDBusMethodInvocation *context,
- const char *connection_path,
- const char *setting_name,
- gpointer user_data)
+impl_secret_agent_old_cancel_get_secrets (NMSecretAgentOld *self,
+ GDBusMethodInvocation *context,
+ const char *connection_path,
+ const char *setting_name,
+ gpointer user_data)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
GError *error = NULL;
GetSecretsInfo *info;
}
/* Send the cancel request up to the subclass and finalize it */
- NM_SECRET_AGENT_GET_CLASS (self)->cancel_get_secrets (self,
+ NM_SECRET_AGENT_OLD_GET_CLASS (self)->cancel_get_secrets (self,
info->path,
info->setting_name);
g_dbus_method_invocation_return_value (context, NULL);
}
static void
-save_secrets_cb (NMSecretAgent *self,
+save_secrets_cb (NMSecretAgentOld *self,
NMConnection *connection,
GError *error,
gpointer user_data)
}
static void
-impl_secret_agent_save_secrets (NMSecretAgent *self,
- GDBusMethodInvocation *context,
- GVariant *connection_dict,
- const char *connection_path,
- gpointer user_data)
+impl_secret_agent_old_save_secrets (NMSecretAgentOld *self,
+ GDBusMethodInvocation *context,
+ GVariant *connection_dict,
+ const char *connection_path,
+ gpointer user_data)
{
GError *error = NULL;
NMConnection *connection = NULL;
return;
}
- NM_SECRET_AGENT_GET_CLASS (self)->save_secrets (self,
+ NM_SECRET_AGENT_OLD_GET_CLASS (self)->save_secrets (self,
connection,
connection_path,
save_secrets_cb,
}
static void
-delete_secrets_cb (NMSecretAgent *self,
+delete_secrets_cb (NMSecretAgentOld *self,
NMConnection *connection,
GError *error,
gpointer user_data)
}
static void
-impl_secret_agent_delete_secrets (NMSecretAgent *self,
- GDBusMethodInvocation *context,
- GVariant *connection_dict,
- const char *connection_path,
- gpointer user_data)
+impl_secret_agent_old_delete_secrets (NMSecretAgentOld *self,
+ GDBusMethodInvocation *context,
+ GVariant *connection_dict,
+ const char *connection_path,
+ gpointer user_data)
{
GError *error = NULL;
NMConnection *connection = NULL;
return;
}
- NM_SECRET_AGENT_GET_CLASS (self)->delete_secrets (self,
+ NM_SECRET_AGENT_OLD_GET_CLASS (self)->delete_secrets (self,
connection,
connection_path,
delete_secrets_cb,
/**************************************************************/
static gboolean
-check_nm_running (NMSecretAgent *self, GError **error)
+check_nm_running (NMSecretAgentOld *self, GError **error)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
char *owner;
if (priv->private_bus)
/**************************************************************/
/**
- * nm_secret_agent_register:
- * @self: a #NMSecretAgent
+ * nm_secret_agent_old_register:
+ * @self: a #NMSecretAgentOld
* @cancellable: a #GCancellable, or %NULL
* @error: return location for a #GError, or %NULL
*
- * Registers the #NMSecretAgent with the NetworkManager secret manager,
+ * 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.
**/
gboolean
-nm_secret_agent_register (NMSecretAgent *self,
- GCancellable *cancellable,
- GError **error)
+nm_secret_agent_old_register (NMSecretAgentOld *self,
+ GCancellable *cancellable,
+ GError **error)
{
- NMSecretAgentPrivate *priv;
- NMSecretAgentClass *class;
+ NMSecretAgentOldPrivate *priv;
+ NMSecretAgentOldClass *class;
- g_return_val_if_fail (NM_IS_SECRET_AGENT (self), FALSE);
+ g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), FALSE);
- priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
g_return_val_if_fail (priv->registered == FALSE, FALSE);
g_return_val_if_fail (priv->registering == FALSE, FALSE);
g_return_val_if_fail (priv->manager_proxy != NULL, FALSE);
/* Also make sure the subclass can actually respond to secrets requests */
- class = NM_SECRET_AGENT_GET_CLASS (self);
+ class = NM_SECRET_AGENT_OLD_GET_CLASS (self);
g_return_val_if_fail (class->get_secrets != NULL, FALSE);
g_return_val_if_fail (class->save_secrets != NULL, FALSE);
g_return_val_if_fail (class->delete_secrets != NULL, FALSE);
success:
priv->registering = FALSE;
priv->registered = TRUE;
- g_object_notify (G_OBJECT (self), NM_SECRET_AGENT_REGISTERED);
+ g_object_notify (G_OBJECT (self), NM_SECRET_AGENT_OLD_REGISTERED);
return TRUE;
}
static void
-reg_result (NMSecretAgent *self, GSimpleAsyncResult *simple, GError *error)
+reg_result (NMSecretAgentOld *self, GSimpleAsyncResult *simple, GError *error)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
priv->registering = FALSE;
_internal_unregister (self);
} else {
priv->registered = TRUE;
- g_object_notify (G_OBJECT (self), NM_SECRET_AGENT_REGISTERED);
+ g_object_notify (G_OBJECT (self), NM_SECRET_AGENT_OLD_REGISTERED);
g_simple_async_result_set_op_res_gboolean (simple, TRUE);
g_simple_async_result_complete (simple);
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
- NMSecretAgent *self;
- NMSecretAgentPrivate *priv;
+ NMSecretAgentOld *self;
+ NMSecretAgentOldPrivate *priv;
GError *error = NULL;
- self = NM_SECRET_AGENT (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
+ self = NM_SECRET_AGENT_OLD (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);
+ priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
if (!nmdbus_agent_manager_call_register_finish (NMDBUS_AGENT_MANAGER (proxy), result, &error))
g_dbus_error_strip_remote_error (error);
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
- NMSecretAgent *self;
- NMSecretAgentPrivate *priv;
+ NMSecretAgentOld *self;
+ NMSecretAgentOldPrivate *priv;
- self = NM_SECRET_AGENT (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
+ self = NM_SECRET_AGENT_OLD (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);
+ priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
if (nmdbus_agent_manager_call_register_with_capabilities_finish (NMDBUS_AGENT_MANAGER (proxy), result, NULL)) {
reg_result (self, simple, NULL);
}
/**
- * nm_secret_agent_register_async:
- * @self: a #NMSecretAgent
+ * 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 #NMSecretAgent with the NetworkManager secret
+ * 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.
*
* registered, or in the process of registering.
**/
void
-nm_secret_agent_register_async (NMSecretAgent *self,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
+nm_secret_agent_old_register_async (NMSecretAgentOld *self,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
{
- NMSecretAgentPrivate *priv;
- NMSecretAgentClass *class;
+ NMSecretAgentOldPrivate *priv;
+ NMSecretAgentOldClass *class;
GSimpleAsyncResult *simple;
GError *error = NULL;
- g_return_if_fail (NM_IS_SECRET_AGENT (self));
+ g_return_if_fail (NM_IS_SECRET_AGENT_OLD (self));
- priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
g_return_if_fail (priv->registered == FALSE);
g_return_if_fail (priv->registering == FALSE);
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);
+ class = NM_SECRET_AGENT_OLD_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);
+ nm_secret_agent_old_register_async);
if (!check_nm_running (self, &error)) {
g_simple_async_result_take_error (simple, error);
}
/**
- * nm_secret_agent_register_finish:
- * @self: a #NMSecretAgent
+ * 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_register_async().
+ * Gets the result of a call to nm_secret_agent_old_register_async().
*
* Returns: %TRUE if registration was successful, %FALSE on error.
**/
gboolean
-nm_secret_agent_register_finish (NMSecretAgent *self,
- GAsyncResult *result,
- GError **error)
+nm_secret_agent_old_register_finish (NMSecretAgentOld *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);
+ g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self), nm_secret_agent_old_register_async), FALSE);
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
return FALSE;
}
/**
- * nm_secret_agent_unregister:
- * @self: a #NMSecretAgent
+ * nm_secret_agent_old_unregister:
+ * @self: a #NMSecretAgentOld
* @cancellable: a #GCancellable, or %NULL
* @error: return location for a #GError, or %NULL
*
- * Unregisters the #NMSecretAgent with the NetworkManager secret manager,
+ * 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
**/
gboolean
-nm_secret_agent_unregister (NMSecretAgent *self,
- GCancellable *cancellable,
- GError **error)
+nm_secret_agent_old_unregister (NMSecretAgentOld *self,
+ GCancellable *cancellable,
+ GError **error)
{
- NMSecretAgentPrivate *priv;
+ NMSecretAgentOldPrivate *priv;
gboolean success;
- g_return_val_if_fail (NM_IS_SECRET_AGENT (self), FALSE);
+ g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), FALSE);
- priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
g_return_val_if_fail (priv->registered == TRUE, FALSE);
g_return_val_if_fail (priv->bus != NULL, FALSE);
unregister_cb (GObject *proxy, GAsyncResult *result, gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
- NMSecretAgent *self;
+ NMSecretAgentOld *self;
GError *error = NULL;
- self = NM_SECRET_AGENT (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
+ self = NM_SECRET_AGENT_OLD (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);
}
/**
- * nm_secret_agent_unregister_async:
- * @self: a #NMSecretAgent
+ * 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 #NMSecretAgent with the NetworkManager secret
+ * 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.
*
* registered.
**/
void
-nm_secret_agent_unregister_async (NMSecretAgent *self,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
+nm_secret_agent_old_unregister_async (NMSecretAgentOld *self,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
{
- NMSecretAgentPrivate *priv;
+ NMSecretAgentOldPrivate *priv;
GSimpleAsyncResult *simple;
GError *error = NULL;
- g_return_if_fail (NM_IS_SECRET_AGENT (self));
+ g_return_if_fail (NM_IS_SECRET_AGENT_OLD (self));
- priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
g_return_if_fail (priv->registered == TRUE);
g_return_if_fail (priv->bus != NULL);
g_return_if_fail (priv->manager_proxy != NULL);
simple = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
- nm_secret_agent_unregister_async);
+ nm_secret_agent_old_unregister_async);
if (!check_nm_running (self, &error)) {
g_simple_async_result_take_error (simple, error);
}
/**
- * nm_secret_agent_unregister_finish:
- * @self: a #NMSecretAgent
+ * 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_unregister_async().
+ * Gets the result of a call to nm_secret_agent_old_unregister_async().
*
* Returns: %TRUE if unregistration was successful, %FALSE on error.
**/
gboolean
-nm_secret_agent_unregister_finish (NMSecretAgent *self,
- GAsyncResult *result,
- GError **error)
+nm_secret_agent_old_unregister_finish (NMSecretAgentOld *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);
+ g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self), nm_secret_agent_old_unregister_async), FALSE);
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
return FALSE;
}
/**
- * nm_secret_agent_get_registered:
- * @self: a #NMSecretAgent
+ * nm_secret_agent_old_get_registered:
+ * @self: a #NMSecretAgentOld
*
* Returns: a %TRUE if the agent is registered, %FALSE if it is not.
**/
gboolean
-nm_secret_agent_get_registered (NMSecretAgent *self)
+nm_secret_agent_old_get_registered (NMSecretAgentOld *self)
{
- g_return_val_if_fail (NM_IS_SECRET_AGENT (self), FALSE);
+ g_return_val_if_fail (NM_IS_SECRET_AGENT_OLD (self), FALSE);
- return NM_SECRET_AGENT_GET_PRIVATE (self)->registered;
+ return NM_SECRET_AGENT_OLD_GET_PRIVATE (self)->registered;
}
/**************************************************************/
/**
- * nm_secret_agent_get_secrets:
- * @self: a #NMSecretAgent
+ * nm_secret_agent_old_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
* Virtual: get_secrets
*/
void
-nm_secret_agent_get_secrets (NMSecretAgent *self,
- NMConnection *connection,
- const char *setting_name,
- const char **hints,
- NMSecretAgentGetSecretsFlags flags,
- NMSecretAgentGetSecretsFunc callback,
- gpointer user_data)
+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 (self));
+ 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 != NULL);
g_return_if_fail (!(flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_ONLY_SYSTEM));
g_return_if_fail (callback != NULL);
- NM_SECRET_AGENT_GET_CLASS (self)->get_secrets (self,
+ NM_SECRET_AGENT_OLD_GET_CLASS (self)->get_secrets (self,
connection,
nm_connection_get_path (connection),
setting_name,
}
/**
- * nm_secret_agent_save_secrets:
- * @self: a #NMSecretAgent
+ * nm_secret_agent_old_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
* Virtual: save_secrets
*/
void
-nm_secret_agent_save_secrets (NMSecretAgent *self,
- NMConnection *connection,
- NMSecretAgentSaveSecretsFunc callback,
- gpointer user_data)
+nm_secret_agent_old_save_secrets (NMSecretAgentOld *self,
+ NMConnection *connection,
+ NMSecretAgentOldSaveSecretsFunc callback,
+ gpointer user_data)
{
- g_return_if_fail (NM_IS_SECRET_AGENT (self));
+ 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_GET_CLASS (self)->save_secrets (self,
+ NM_SECRET_AGENT_OLD_GET_CLASS (self)->save_secrets (self,
connection,
nm_connection_get_path (connection),
callback,
}
/**
- * nm_secret_agent_delete_secrets:
- * @self: a #NMSecretAgent
+ * nm_secret_agent_old_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
* Virtual: delete_secrets
*/
void
-nm_secret_agent_delete_secrets (NMSecretAgent *self,
- NMConnection *connection,
- NMSecretAgentDeleteSecretsFunc callback,
- gpointer user_data)
+nm_secret_agent_old_delete_secrets (NMSecretAgentOld *self,
+ NMConnection *connection,
+ NMSecretAgentOldDeleteSecretsFunc callback,
+ gpointer user_data)
{
- g_return_if_fail (NM_IS_SECRET_AGENT (self));
+ 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_GET_CLASS (self)->delete_secrets (self,
+ NM_SECRET_AGENT_OLD_GET_CLASS (self)->delete_secrets (self,
connection,
nm_connection_get_path (connection),
callback,
}
static void
-nm_secret_agent_init (NMSecretAgent *self)
+nm_secret_agent_old_init (NMSecretAgentOld *self)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
priv->dbus_secret_agent = nmdbus_secret_agent_skeleton_new ();
_nm_dbus_bind_properties (self, priv->dbus_secret_agent);
_nm_dbus_bind_methods (self, priv->dbus_secret_agent,
- "GetSecrets", impl_secret_agent_get_secrets,
- "CancelGetSecrets", impl_secret_agent_cancel_get_secrets,
- "DeleteSecrets", impl_secret_agent_delete_secrets,
- "SaveSecrets", impl_secret_agent_save_secrets,
+ "GetSecrets", impl_secret_agent_old_get_secrets,
+ "CancelGetSecrets", impl_secret_agent_old_cancel_get_secrets,
+ "DeleteSecrets", impl_secret_agent_old_delete_secrets,
+ "SaveSecrets", impl_secret_agent_old_save_secrets,
NULL);
}
static void
-init_common (NMSecretAgent *self)
+init_common (NMSecretAgentOld *self)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
priv->private_bus = _nm_dbus_is_connection_private (priv->bus);
static gboolean
init_sync (GInitable *initable, GCancellable *cancellable, GError **error)
{
- NMSecretAgent *self = NM_SECRET_AGENT (initable);
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOld *self = NM_SECRET_AGENT_OLD (initable);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
GDBusProxy *proxy;
priv->bus = _nm_dbus_new_connection (cancellable, error);
init_common (self);
if (priv->auto_register)
- return nm_secret_agent_register (self, cancellable, error);
+ return nm_secret_agent_old_register (self, cancellable, error);
else
return TRUE;
}
typedef struct {
- NMSecretAgent *self;
+ NMSecretAgentOld *self;
GCancellable *cancellable;
GSimpleAsyncResult *simple;
-} NMSecretAgentInitData;
+} NMSecretAgentOldInitData;
static void
-init_async_complete (NMSecretAgentInitData *init_data, GError *error)
+init_async_complete (NMSecretAgentOldInitData *init_data, GError *error)
{
if (!error)
g_simple_async_result_set_op_res_gboolean (init_data->simple, TRUE);
g_object_unref (init_data->simple);
g_clear_object (&init_data->cancellable);
- g_slice_free (NMSecretAgentInitData, init_data);
+ g_slice_free (NMSecretAgentOldInitData, init_data);
}
static void
init_async_registered (GObject *object, GAsyncResult *result, gpointer user_data)
{
- NMSecretAgent *self = NM_SECRET_AGENT (object);
- NMSecretAgentInitData *init_data = user_data;
+ NMSecretAgentOld *self = NM_SECRET_AGENT_OLD (object);
+ NMSecretAgentOldInitData *init_data = user_data;
GError *error = NULL;
- nm_secret_agent_register_finish (self, result, &error);
+ nm_secret_agent_old_register_finish (self, result, &error);
init_async_complete (init_data, error);
}
static void
init_async_got_proxy (GObject *object, GAsyncResult *result, gpointer user_data)
{
- NMSecretAgentInitData *init_data = user_data;
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (init_data->self);
+ NMSecretAgentOldInitData *init_data = user_data;
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (init_data->self);
GDBusProxy *proxy;
GError *error = NULL;
init_common (init_data->self);
if (priv->auto_register) {
- nm_secret_agent_register_async (init_data->self, init_data->cancellable,
+ nm_secret_agent_old_register_async (init_data->self, init_data->cancellable,
init_async_registered, init_data);
} else
init_async_complete (init_data, NULL);
static void
init_async_got_bus (GObject *initable, GAsyncResult *result, gpointer user_data)
{
- NMSecretAgentInitData *init_data = user_data;
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (init_data->self);
+ NMSecretAgentOldInitData *init_data = user_data;
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (init_data->self);
GError *error = NULL;
priv->bus = _nm_dbus_new_connection_finish (result, &error);
GCancellable *cancellable, GAsyncReadyCallback callback,
gpointer user_data)
{
- NMSecretAgent *self = NM_SECRET_AGENT (initable);
- NMSecretAgentInitData *init_data;
+ NMSecretAgentOld *self = NM_SECRET_AGENT_OLD (initable);
+ NMSecretAgentOldInitData *init_data;
- init_data = g_slice_new (NMSecretAgentInitData);
+ init_data = g_slice_new (NMSecretAgentOldInitData);
init_data->self = self;
init_data->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
GValue *value,
GParamSpec *pspec)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (object);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (object);
switch (prop_id) {
case PROP_IDENTIFIER:
const GValue *value,
GParamSpec *pspec)
{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (object);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (object);
const char *identifier;
switch (prop_id) {
static void
dispose (GObject *object)
{
- NMSecretAgent *self = NM_SECRET_AGENT (object);
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ NMSecretAgentOld *self = NM_SECRET_AGENT_OLD (object);
+ NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE (self);
if (priv->registered)
- nm_secret_agent_unregister_async (self, NULL, NULL, NULL);
+ nm_secret_agent_old_unregister_async (self, NULL, NULL, NULL);
g_clear_pointer (&priv->identifier, g_free);
g_clear_object (&priv->manager_proxy);
g_clear_object (&priv->bus);
- G_OBJECT_CLASS (nm_secret_agent_parent_class)->dispose (object);
+ G_OBJECT_CLASS (nm_secret_agent_old_parent_class)->dispose (object);
}
static void
-nm_secret_agent_class_init (NMSecretAgentClass *class)
+nm_secret_agent_old_class_init (NMSecretAgentOldClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
- g_type_class_add_private (class, sizeof (NMSecretAgentPrivate));
+ g_type_class_add_private (class, sizeof (NMSecretAgentOldPrivate));
/* Virtual methods */
object_class->dispose = dispose;
object_class->set_property = set_property;
/**
- * NMSecretAgent:identifier:
+ * NMSecretAgentOld:identifier:
*
* Identifies this agent; only one agent in each user session may use the
* same identifier. Identifier formatting follows the same rules as
**/
g_object_class_install_property
(object_class, PROP_IDENTIFIER,
- g_param_spec_string (NM_SECRET_AGENT_IDENTIFIER, "", "",
+ g_param_spec_string (NM_SECRET_AGENT_OLD_IDENTIFIER, "", "",
NULL,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
/**
- * NMSecretAgent:auto-register:
+ * NMSecretAgentOld:auto-register:
*
* If %TRUE (the default), the agent will always be registered when
* NetworkManager is running; if NetworkManager exits and restarts, the
* 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.
+ * NetworkManager, and nm_secret_agent_old_register() or
+ * nm_secret_agent_old_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
+ * Calling nm_secret_agent_old_unregister() will suppress auto-registration
+ * until nm_secret_agent_old_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,
- g_param_spec_boolean (NM_SECRET_AGENT_AUTO_REGISTER, "", "",
+ g_param_spec_boolean (NM_SECRET_AGENT_OLD_AUTO_REGISTER, "", "",
TRUE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
/**
- * NMSecretAgent:registered:
+ * NMSecretAgentOld:registered:
*
* %TRUE if the agent is registered with NetworkManager, %FALSE if not.
**/
g_object_class_install_property
(object_class, PROP_REGISTERED,
- g_param_spec_boolean (NM_SECRET_AGENT_REGISTERED, "", "",
+ g_param_spec_boolean (NM_SECRET_AGENT_OLD_REGISTERED, "", "",
FALSE,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS));
/**
- * NMSecretAgent:capabilities:
+ * NMSecretAgentOld:capabilities:
*
* A bitfield of %NMSecretAgentCapabilities.
**/
g_object_class_install_property
(object_class, PROP_CAPABILITIES,
- g_param_spec_flags (NM_SECRET_AGENT_CAPABILITIES, "", "",
+ g_param_spec_flags (NM_SECRET_AGENT_OLD_CAPABILITIES, "", "",
NM_TYPE_SECRET_AGENT_CAPABILITIES,
NM_SECRET_AGENT_CAPABILITY_NONE,
G_PARAM_READWRITE |
}
static void
-nm_secret_agent_initable_iface_init (GInitableIface *iface)
+nm_secret_agent_old_initable_iface_init (GInitableIface *iface)
{
iface->init = init_sync;
}
static void
-nm_secret_agent_async_initable_iface_init (GAsyncInitableIface *iface)
+nm_secret_agent_old_async_initable_iface_init (GAsyncInitableIface *iface)
{
iface->init_async = init_async;
iface->init_finish = init_finish;
* Copyright 2010 - 2011 Red Hat, Inc.
*/
-#ifndef __NM_SECRET_AGENT_H__
-#define __NM_SECRET_AGENT_H__
-
-#if !defined (__NETWORKMANAGER_H_INSIDE__) && !defined (NETWORKMANAGER_COMPILATION)
-#error "Only <NetworkManager.h> can be included directly."
-#endif
+#ifndef __NM_SECRET_AGENT_OLD_H__
+#define __NM_SECRET_AGENT_OLD_H__
#include <nm-types.h>
G_BEGIN_DECLS
-#define NM_TYPE_SECRET_AGENT (nm_secret_agent_get_type ())
-#define NM_SECRET_AGENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_SECRET_AGENT, NMSecretAgent))
-#define NM_SECRET_AGENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NM_TYPE_SECRET_AGENT, NMSecretAgentClass))
-#define NM_IS_SECRET_AGENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NM_TYPE_SECRET_AGENT))
-#define NM_IS_SECRET_AGENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NM_TYPE_SECRET_AGENT))
-#define NM_SECRET_AGENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_SECRET_AGENT, NMSecretAgentClass))
+#define NM_TYPE_SECRET_AGENT_OLD (nm_secret_agent_old_get_type ())
+#define NM_SECRET_AGENT_OLD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_SECRET_AGENT_OLD, NMSecretAgentOld))
+#define NM_SECRET_AGENT_OLD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NM_TYPE_SECRET_AGENT_OLD, NMSecretAgentOldClass))
+#define NM_IS_SECRET_AGENT_OLD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NM_TYPE_SECRET_AGENT_OLD))
+#define NM_IS_SECRET_AGENT_OLD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NM_TYPE_SECRET_AGENT_OLD))
+#define NM_SECRET_AGENT_OLD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_SECRET_AGENT_OLD, NMSecretAgentOldClass))
-#define NM_SECRET_AGENT_IDENTIFIER "identifier"
-#define NM_SECRET_AGENT_AUTO_REGISTER "auto-register"
-#define NM_SECRET_AGENT_REGISTERED "registered"
-#define NM_SECRET_AGENT_CAPABILITIES "capabilities"
+#define NM_SECRET_AGENT_OLD_IDENTIFIER "identifier"
+#define NM_SECRET_AGENT_OLD_AUTO_REGISTER "auto-register"
+#define NM_SECRET_AGENT_OLD_REGISTERED "registered"
+#define NM_SECRET_AGENT_OLD_CAPABILITIES "capabilities"
-struct _NMSecretAgent {
+typedef struct {
GObject parent;
-};
+} NMSecretAgentOld;
/**
- * NMSecretAgentGetSecretsFunc:
+ * NMSecretAgentOldGetSecretsFunc:
* @agent: the secret agent object
* @connection: (transfer none): the connection for which secrets were requested,
* note that this object will be unrefed after the callback has returned, use
* @user_data: caller-specific data to be passed to the function
*
* Called as a result of a request by NM to retrieve secrets. When the
- * #NMSecretAgent subclass has finished retrieving secrets and is ready to
+ * #NMSecretAgentOld subclass has finished retrieving secrets and is ready to
* return them, or to return an error, this function should be called with
* those secrets or the error.
*
* nm_connection_add_setting (secrets, NM_SETTING (s_wsec));
* secrets_dict = nm_connection_to_dbus (secrets, NM_CONNECTION_SERIALIZE_ALL);
*
- * (call the NMSecretAgentGetSecretsFunc with secrets_dict)
+ * (call the NMSecretAgentOldGetSecretsFunc with secrets_dict)
*
* g_object_unref (secrets);
* g_variant_unref (secrets_dict);
* </programlisting>
* </example>
*/
-typedef void (*NMSecretAgentGetSecretsFunc) (NMSecretAgent *agent,
- NMConnection *connection,
- GVariant *secrets,
- GError *error,
- gpointer user_data);
+typedef void (*NMSecretAgentOldGetSecretsFunc) (NMSecretAgentOld *agent,
+ NMConnection *connection,
+ GVariant *secrets,
+ GError *error,
+ gpointer user_data);
/**
- * NMSecretAgentSaveSecretsFunc:
+ * NMSecretAgentOldSaveSecretsFunc:
* @agent: the secret agent object
* @connection: (transfer none): the connection for which secrets were to be saved,
* note that this object will be unrefed after the callback has returned, use
* @user_data: caller-specific data to be passed to the function
*
* Called as a result of a request by NM to save secrets. When the
- * #NMSecretAgent subclass has finished saving the secrets, this function
+ * #NMSecretAgentOld subclass has finished saving the secrets, this function
* should be called.
*/
-typedef void (*NMSecretAgentSaveSecretsFunc) (NMSecretAgent *agent,
- NMConnection *connection,
- GError *error,
- gpointer user_data);
+typedef void (*NMSecretAgentOldSaveSecretsFunc) (NMSecretAgentOld *agent,
+ NMConnection *connection,
+ GError *error,
+ gpointer user_data);
/**
- * NMSecretAgentDeleteSecretsFunc:
+ * NMSecretAgentOldDeleteSecretsFunc:
* @agent: the secret agent object
* @connection: (transfer none): the connection for which secrets were to be deleted,
* note that this object will be unrefed after the callback has returned, use
* @user_data: caller-specific data to be passed to the function
*
* Called as a result of a request by NM to delete secrets. When the
- * #NMSecretAgent subclass has finished deleting the secrets, this function
+ * #NMSecretAgentOld subclass has finished deleting the secrets, this function
* should be called.
*/
-typedef void (*NMSecretAgentDeleteSecretsFunc) (NMSecretAgent *agent,
- NMConnection *connection,
- GError *error,
- gpointer user_data);
+typedef void (*NMSecretAgentOldDeleteSecretsFunc) (NMSecretAgentOld *agent,
+ NMConnection *connection,
+ GError *error,
+ gpointer user_data);
typedef struct {
GObjectClass parent;
* must copy or reference any arguments it may require after returning from
* this method, as the arguments will freed (except for 'self', 'callback',
* and 'user_data' of course). If the request is canceled, the callback
- * should still be called, but with the NM_SECRET_AGENT_ERROR_AGENT_CANCELED
- * error.
+ * should still be called, but with the
+ * NM_SECRET_AGENT_OLD_ERROR_AGENT_CANCELED error.
*/
- void (*get_secrets) (NMSecretAgent *self,
+ void (*get_secrets) (NMSecretAgentOld *self,
NMConnection *connection,
const char *connection_path,
const char *setting_name,
const char **hints,
NMSecretAgentGetSecretsFlags flags,
- NMSecretAgentGetSecretsFunc callback,
+ NMSecretAgentOldGetSecretsFunc callback,
gpointer user_data);
/* Called when the subclass should cancel an outstanding request to
* get secrets for a given connection. Canceling the request MUST
* call the callback that was passed along with the initial get_secrets
- * call, sending the NM_SECRET_AGENT_ERROR/NM_SECRET_AGENT_ERROR_AGENT_CANCELED
- * error to that callback.
+ * call, sending the NM_SECRET_AGENT_OLD_ERROR/
+ * NM_SECRET_AGENT_OLD_ERROR_AGENT_CANCELED error to that callback.
*/
- void (*cancel_get_secrets) (NMSecretAgent *self,
+ void (*cancel_get_secrets) (NMSecretAgentOld *self,
const char *connection_path,
const char *setting_name);
* arguments will freed (except for 'self', 'callback', and 'user_data'
* of course).
*/
- void (*save_secrets) (NMSecretAgent *self,
+ void (*save_secrets) (NMSecretAgentOld *self,
NMConnection *connection,
const char *connection_path,
- NMSecretAgentSaveSecretsFunc callback,
+ NMSecretAgentOldSaveSecretsFunc callback,
gpointer user_data);
/* Called when the subclass should delete the secrets contained in the
* arguments will freed (except for 'self', 'callback', and 'user_data'
* of course).
*/
- void (*delete_secrets) (NMSecretAgent *self,
+ void (*delete_secrets) (NMSecretAgentOld *self,
NMConnection *connection,
const char *connection_path,
- NMSecretAgentDeleteSecretsFunc callback,
+ NMSecretAgentOldDeleteSecretsFunc callback,
gpointer user_data);
/*< private >*/
gpointer padding[8];
-} NMSecretAgentClass;
-
-GType nm_secret_agent_get_type (void);
-
-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,
- 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);
-
-void nm_secret_agent_get_secrets (NMSecretAgent *self,
- NMConnection *connection,
- const char *setting_name,
- const char **hints,
- NMSecretAgentGetSecretsFlags flags,
- NMSecretAgentGetSecretsFunc callback,
- gpointer user_data);
-
-void nm_secret_agent_save_secrets (NMSecretAgent *self,
- NMConnection *connection,
- NMSecretAgentSaveSecretsFunc callback,
- gpointer user_data);
-
-void nm_secret_agent_delete_secrets (NMSecretAgent *self,
- NMConnection *connection,
- NMSecretAgentDeleteSecretsFunc callback,
- gpointer user_data);
+} NMSecretAgentOldClass;
+
+GType nm_secret_agent_old_get_type (void);
+
+gboolean nm_secret_agent_old_register (NMSecretAgentOld *self,
+ GCancellable *cancellable,
+ GError **error);
+void nm_secret_agent_old_register_async (NMSecretAgentOld *self,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+gboolean nm_secret_agent_old_register_finish (NMSecretAgentOld *self,
+ GAsyncResult *result,
+ GError **error);
+
+gboolean nm_secret_agent_old_unregister (NMSecretAgentOld *self,
+ GCancellable *cancellable,
+ GError **error);
+void nm_secret_agent_old_unregister_async (NMSecretAgentOld *self,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+gboolean nm_secret_agent_old_unregister_finish (NMSecretAgentOld *self,
+ GAsyncResult *result,
+ GError **error);
+
+gboolean nm_secret_agent_old_get_registered (NMSecretAgentOld *self);
+
+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);
+
+void nm_secret_agent_old_save_secrets (NMSecretAgentOld *self,
+ NMConnection *connection,
+ NMSecretAgentOldSaveSecretsFunc callback,
+ gpointer user_data);
+
+void nm_secret_agent_old_delete_secrets (NMSecretAgentOld *self,
+ NMConnection *connection,
+ NMSecretAgentOldDeleteSecretsFunc callback,
+ gpointer user_data);
G_END_DECLS
-#endif /* __NM_SECRET_AGENT_H__ */
+#endif /* __NM_SECRET_AGENT_OLD_H__ */
#include <signal.h>
#include <NetworkManager.h>
+#include <nm-secret-agent-old.h>
#include "nm-glib-compat.h"
#include "nm-test-utils.h"
static guint signals[LAST_SIGNAL] = { 0 };
-typedef NMSecretAgent TestSecretAgent;
-typedef NMSecretAgentClass TestSecretAgentClass;
+typedef NMSecretAgentOld TestSecretAgent;
+typedef NMSecretAgentOldClass TestSecretAgentClass;
GType test_secret_agent_get_type (void);
-G_DEFINE_TYPE (TestSecretAgent, test_secret_agent, NM_TYPE_SECRET_AGENT)
+G_DEFINE_TYPE (TestSecretAgent, test_secret_agent, NM_TYPE_SECRET_AGENT_OLD)
static void
test_secret_agent_init (TestSecretAgent *agent)
}
static void
-test_secret_agent_get_secrets (NMSecretAgent *agent,
- NMConnection *connection,
- const char *connection_path,
- const char *setting_name,
- const char **hints,
- NMSecretAgentGetSecretsFlags flags,
- NMSecretAgentGetSecretsFunc callback,
- gpointer callback_data)
+test_secret_agent_get_secrets (NMSecretAgentOld *agent,
+ NMConnection *connection,
+ const char *connection_path,
+ const char *setting_name,
+ const char **hints,
+ NMSecretAgentGetSecretsFlags flags,
+ NMSecretAgentOldGetSecretsFunc callback,
+ gpointer callback_data)
{
NMSettingWirelessSecurity *s_wsec;
GVariant *secrets = NULL;
}
static void
-test_secret_agent_cancel_get_secrets (NMSecretAgent *agent,
- const gchar *connection_path,
- const gchar *setting_name)
+test_secret_agent_cancel_get_secrets (NMSecretAgentOld *agent,
+ const gchar *connection_path,
+ const gchar *setting_name)
{
g_assert_not_reached ();
}
static void
-test_secret_agent_save_secrets (NMSecretAgent *agent,
- NMConnection *connection,
- const gchar *connection_path,
- NMSecretAgentSaveSecretsFunc callback,
- gpointer callback_data)
+test_secret_agent_save_secrets (NMSecretAgentOld *agent,
+ NMConnection *connection,
+ const gchar *connection_path,
+ NMSecretAgentOldSaveSecretsFunc callback,
+ gpointer callback_data)
{
g_assert_not_reached ();
}
static void
-test_secret_agent_delete_secrets (NMSecretAgent *agent,
- NMConnection *connection,
- const gchar *connection_path,
- NMSecretAgentDeleteSecretsFunc callback,
- gpointer callback_data)
+test_secret_agent_delete_secrets (NMSecretAgentOld *agent,
+ NMConnection *connection,
+ const gchar *connection_path,
+ NMSecretAgentOldDeleteSecretsFunc callback,
+ gpointer callback_data)
{
g_assert_not_reached ();
}
test_secret_agent_class_init (TestSecretAgentClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- NMSecretAgentClass *agent_class = NM_SECRET_AGENT_CLASS (klass);
+ NMSecretAgentOldClass *agent_class = NM_SECRET_AGENT_OLD_CLASS (klass);
agent_class->get_secrets = test_secret_agent_get_secrets;
agent_class->cancel_get_secrets = test_secret_agent_cancel_get_secrets;
}
-static NMSecretAgent *
+static NMSecretAgentOld *
test_secret_agent_new (void)
{
- NMSecretAgent *agent;
+ NMSecretAgentOld *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,
+ NM_SECRET_AGENT_OLD_IDENTIFIER, "test-secret-agent",
+ NM_SECRET_AGENT_OLD_AUTO_REGISTER, FALSE,
NULL);
g_assert_no_error (error);
NMTestServiceInfo *sinfo;
NMClient *client;
- NMSecretAgent *agent;
+ NMSecretAgentOld *agent;
NMDevice *device;
NMConnection *connection;
TestSecretAgentData *sadata = user_data;
GError *error = NULL;
- nm_secret_agent_register_finish (sadata->agent, result, &error);
+ nm_secret_agent_old_register_finish (sadata->agent, result, &error);
g_assert_no_error (error);
- g_assert (nm_secret_agent_get_registered (sadata->agent));
+ g_assert (nm_secret_agent_old_get_registered (sadata->agent));
g_main_loop_quit (sadata->loop);
}
sadata->agent = test_secret_agent_new ();
if (!strcmp (agent_notes, "sync")) {
- nm_secret_agent_register (sadata->agent, NULL, &error);
+ nm_secret_agent_old_register (sadata->agent, NULL, &error);
g_assert_no_error (error);
- g_assert (nm_secret_agent_get_registered (sadata->agent));
+ g_assert (nm_secret_agent_old_get_registered (sadata->agent));
} else {
- nm_secret_agent_register_async (sadata->agent, NULL,
+ nm_secret_agent_old_register_async (sadata->agent, NULL,
register_cb, sadata);
g_main_loop_run (sadata->loop);
}
GError *error = NULL;
if (sadata->agent) {
- if (nm_secret_agent_get_registered (sadata->agent)) {
- nm_secret_agent_unregister (sadata->agent, NULL, &error);
+ if (nm_secret_agent_old_get_registered (sadata->agent)) {
+ nm_secret_agent_old_unregister (sadata->agent, NULL, &error);
g_assert_no_error (error);
}
g_object_unref (sadata->agent);
static void
test_secret_agent_nm_not_running (void)
{
- NMSecretAgent *agent;
+ NMSecretAgentOld *agent;
GMainLoop *loop;
GError *error = NULL;
agent = g_initable_new (test_secret_agent_get_type (), NULL, &error,
- NM_SECRET_AGENT_IDENTIFIER, "test-secret-agent",
+ NM_SECRET_AGENT_OLD_IDENTIFIER, "test-secret-agent",
NULL);
g_assert_error (error, NM_SECRET_AGENT_ERROR, NM_SECRET_AGENT_ERROR_FAILED);
g_assert (agent == NULL);
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",
+ NM_SECRET_AGENT_OLD_IDENTIFIER, "test-secret-agent",
NULL);
g_main_loop_run (loop);
g_main_loop_unref (loop);
test_secret_agent_auto_register (void)
{
NMTestServiceInfo *sinfo;
- NMSecretAgent *agent;
+ NMSecretAgentOld *agent;
GMainLoop *loop;
GError *error = NULL;
agent = test_secret_agent_new ();
g_object_set (agent,
- NM_SECRET_AGENT_AUTO_REGISTER, TRUE,
+ NM_SECRET_AGENT_OLD_AUTO_REGISTER, TRUE,
NULL);
- g_signal_connect (agent, "notify::" NM_SECRET_AGENT_REGISTERED,
+ g_signal_connect (agent, "notify::" NM_SECRET_AGENT_OLD_REGISTERED,
G_CALLBACK (registered_changed), loop);
- g_assert (!nm_secret_agent_get_registered (agent));
- nm_secret_agent_register (agent, NULL, &error);
+ g_assert (!nm_secret_agent_old_get_registered (agent));
+ nm_secret_agent_old_register (agent, NULL, &error);
g_assert_no_error (error);
- g_assert (nm_secret_agent_get_registered (agent));
+ g_assert (nm_secret_agent_old_get_registered (agent));
/* Shut down test service */
nm_test_service_cleanup (sinfo);
g_main_loop_run (loop);
- g_assert (!nm_secret_agent_get_registered (agent));
+ g_assert (!nm_secret_agent_old_get_registered (agent));
/* Restart test service */
sinfo = nm_test_service_init ();
g_main_loop_run (loop);
- g_assert (nm_secret_agent_get_registered (agent));
+ g_assert (nm_secret_agent_old_get_registered (agent));
/* Shut down test service again */
nm_test_service_cleanup (sinfo);
g_main_loop_run (loop);
- g_assert (!nm_secret_agent_get_registered (agent));
+ g_assert (!nm_secret_agent_old_get_registered (agent));
g_object_unref (agent);
g_main_loop_unref (loop);
projects / NetworkManager.git / commitdiff