mirror of
https://gitlab.gnome.org/GNOME/libsecret.git
synced 2024-12-23 05:08:56 +00:00
3162 lines
97 KiB
C
3162 lines
97 KiB
C
/* GSecret - GLib wrapper for Secret Service
|
|
*
|
|
* Copyright 2011 Collabora Ltd.
|
|
* Copyright 2012 Red Hat Inc.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published
|
|
* by the Free Software Foundation; either version 2 of the licence or (at
|
|
* your option) any later version.
|
|
*
|
|
* See the included COPYING file for more information.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "gsecret-collection.h"
|
|
#include "gsecret-dbus-generated.h"
|
|
#include "gsecret-enum-types.h"
|
|
#include "gsecret-item.h"
|
|
#include "gsecret-private.h"
|
|
#include "gsecret-service.h"
|
|
#include "gsecret-types.h"
|
|
#include "gsecret-value.h"
|
|
|
|
#include "egg/egg-secure-memory.h"
|
|
|
|
#include <glib.h>
|
|
#include <glib/gi18n-lib.h>
|
|
|
|
#include <gcrypt.h>
|
|
|
|
EGG_SECURE_GLIB_DEFINITIONS ();
|
|
|
|
EGG_SECURE_DECLARE (secret_service);
|
|
|
|
static const gchar *default_bus_name = GSECRET_SERVICE_BUS_NAME;
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_FLAGS,
|
|
PROP_COLLECTIONS
|
|
};
|
|
|
|
typedef struct _GSecretServicePrivate {
|
|
/* No change between construct and finalize */
|
|
GCancellable *cancellable;
|
|
GSecretServiceFlags init_flags;
|
|
|
|
/* Locked by mutex */
|
|
GMutex mutex;
|
|
gpointer session;
|
|
GHashTable *collections;
|
|
} GSecretServicePrivate;
|
|
|
|
G_LOCK_DEFINE (service_instance);
|
|
static gpointer service_instance = NULL;
|
|
|
|
static GInitableIface *gsecret_service_initable_parent_iface = NULL;
|
|
|
|
static GAsyncInitableIface *gsecret_service_async_initable_parent_iface = NULL;
|
|
|
|
static void gsecret_service_initable_iface (GInitableIface *iface);
|
|
|
|
static void gsecret_service_async_initable_iface (GAsyncInitableIface *iface);
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GSecretService, gsecret_service, G_TYPE_DBUS_PROXY,
|
|
G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, gsecret_service_initable_iface);
|
|
G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, gsecret_service_async_initable_iface);
|
|
);
|
|
|
|
static void
|
|
gsecret_service_init (GSecretService *self)
|
|
{
|
|
self->pv = G_TYPE_INSTANCE_GET_PRIVATE (self, GSECRET_TYPE_SERVICE,
|
|
GSecretServicePrivate);
|
|
|
|
g_mutex_init (&self->pv->mutex);
|
|
self->pv->cancellable = g_cancellable_new ();
|
|
}
|
|
|
|
static void
|
|
gsecret_service_get_property (GObject *obj,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GSecretService *self = GSECRET_SERVICE (obj);
|
|
|
|
switch (prop_id) {
|
|
case PROP_FLAGS:
|
|
g_value_set_flags (value, gsecret_service_get_flags (self));
|
|
break;
|
|
case PROP_COLLECTIONS:
|
|
g_value_take_boxed (value, gsecret_service_get_collections (self));
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gsecret_service_set_property (GObject *obj,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GSecretService *self = GSECRET_SERVICE (obj);
|
|
|
|
switch (prop_id) {
|
|
case PROP_FLAGS:
|
|
self->pv->init_flags = g_value_get_flags (value);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gsecret_service_dispose (GObject *obj)
|
|
{
|
|
GSecretService *self = GSECRET_SERVICE (obj);
|
|
|
|
g_cancellable_cancel (self->pv->cancellable);
|
|
|
|
G_OBJECT_CLASS (gsecret_service_parent_class)->dispose (obj);
|
|
}
|
|
|
|
static void
|
|
gsecret_service_finalize (GObject *obj)
|
|
{
|
|
GSecretService *self = GSECRET_SERVICE (obj);
|
|
|
|
_gsecret_session_free (self->pv->session);
|
|
if (self->pv->collections)
|
|
g_hash_table_destroy (self->pv->collections);
|
|
g_clear_object (&self->pv->cancellable);
|
|
|
|
G_OBJECT_CLASS (gsecret_service_parent_class)->finalize (obj);
|
|
}
|
|
|
|
static gboolean
|
|
gsecret_service_real_prompt_sync (GSecretService *self,
|
|
GSecretPrompt *prompt,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
return gsecret_prompt_perform_sync (prompt, 0, cancellable, error);
|
|
}
|
|
|
|
static void
|
|
on_real_prompt_completed (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
GError *error = NULL;
|
|
gboolean ret;
|
|
|
|
ret = gsecret_prompt_perform_finish (GSECRET_PROMPT (source), result, &error);
|
|
g_simple_async_result_set_op_res_gboolean (res, ret);
|
|
if (error != NULL)
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
gsecret_service_real_prompt_async (GSecretService *self,
|
|
GSecretPrompt *prompt,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
gsecret_service_real_prompt_async);
|
|
|
|
gsecret_prompt_perform (prompt, 0, cancellable,
|
|
on_real_prompt_completed,
|
|
g_object_ref (res));
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static gboolean
|
|
gsecret_service_real_prompt_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (result);
|
|
|
|
if (g_simple_async_result_propagate_error (res, error))
|
|
return FALSE;
|
|
|
|
return g_simple_async_result_get_op_res_gboolean (res);
|
|
}
|
|
|
|
static void
|
|
handle_property_changed (GSecretService *self,
|
|
const gchar *property_name,
|
|
GVariant *value)
|
|
{
|
|
gboolean perform;
|
|
|
|
if (g_str_equal (property_name, "Collections")) {
|
|
|
|
g_mutex_lock (&self->pv->mutex);
|
|
perform = self->pv->collections != NULL;
|
|
g_mutex_unlock (&self->pv->mutex);
|
|
|
|
if (perform)
|
|
gsecret_service_ensure_collections (self, self->pv->cancellable, NULL, NULL);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gsecret_service_properties_changed (GDBusProxy *proxy,
|
|
GVariant *changed_properties,
|
|
const gchar* const *invalidated_properties)
|
|
{
|
|
GSecretService *self = GSECRET_SERVICE (proxy);
|
|
gchar *property_name;
|
|
GVariantIter iter;
|
|
GVariant *value;
|
|
|
|
g_object_freeze_notify (G_OBJECT (self));
|
|
|
|
g_variant_iter_init (&iter, changed_properties);
|
|
while (g_variant_iter_loop (&iter, "{sv}", &property_name, &value))
|
|
handle_property_changed (self, property_name, value);
|
|
|
|
g_object_thaw_notify (G_OBJECT (self));
|
|
}
|
|
|
|
static void
|
|
gsecret_service_class_init (GSecretServiceClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
GDBusProxyClass *proxy_class = G_DBUS_PROXY_CLASS (klass);
|
|
|
|
object_class->get_property = gsecret_service_get_property;
|
|
object_class->set_property = gsecret_service_set_property;
|
|
object_class->dispose = gsecret_service_dispose;
|
|
object_class->finalize = gsecret_service_finalize;
|
|
|
|
proxy_class->g_properties_changed = gsecret_service_properties_changed;
|
|
|
|
klass->prompt_sync = gsecret_service_real_prompt_sync;
|
|
klass->prompt_async = gsecret_service_real_prompt_async;
|
|
klass->prompt_finish = gsecret_service_real_prompt_finish;
|
|
|
|
klass->item_gtype = GSECRET_TYPE_ITEM;
|
|
klass->collection_gtype = GSECRET_TYPE_COLLECTION;
|
|
|
|
g_object_class_install_property (object_class, PROP_FLAGS,
|
|
g_param_spec_flags ("flags", "Flags", "Service flags",
|
|
g_secret_service_flags_get_type (), GSECRET_SERVICE_NONE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (object_class, PROP_COLLECTIONS,
|
|
g_param_spec_boxed ("collections", "Collections", "Secret Service Collections",
|
|
_gsecret_list_get_type (), G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_type_class_add_private (klass, sizeof (GSecretServicePrivate));
|
|
}
|
|
|
|
typedef struct {
|
|
GCancellable *cancellable;
|
|
GSecretServiceFlags flags;
|
|
} InitClosure;
|
|
|
|
static void
|
|
init_closure_free (gpointer data)
|
|
{
|
|
InitClosure *closure = data;
|
|
g_clear_object (&closure->cancellable);
|
|
g_slice_free (InitClosure, closure);
|
|
}
|
|
|
|
static gboolean
|
|
service_ensure_for_flags_sync (GSecretService *self,
|
|
GSecretServiceFlags flags,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
if (flags & GSECRET_SERVICE_OPEN_SESSION)
|
|
if (!gsecret_service_ensure_session_sync (self, cancellable, error))
|
|
return FALSE;
|
|
|
|
if (flags & GSECRET_SERVICE_LOAD_COLLECTIONS)
|
|
if (!gsecret_service_ensure_collections_sync (self, cancellable, error))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
on_ensure_collections (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
GSecretService *self = GSECRET_SERVICE (source);
|
|
GError *error = NULL;
|
|
|
|
if (!gsecret_service_ensure_collections_finish (self, result, &error))
|
|
g_simple_async_result_take_error (res, error);
|
|
|
|
g_simple_async_result_complete (res);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
on_ensure_session (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
InitClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GSecretService *self = GSECRET_SERVICE (source);
|
|
GError *error = NULL;
|
|
|
|
if (!gsecret_service_ensure_session_finish (self, result, &error)) {
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
|
|
} else if (closure->flags & GSECRET_SERVICE_LOAD_COLLECTIONS) {
|
|
gsecret_service_ensure_collections (self, closure->cancellable,
|
|
on_ensure_collections, g_object_ref (res));
|
|
|
|
} else {
|
|
g_simple_async_result_complete_in_idle (res);
|
|
}
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
service_ensure_for_flags_async (GSecretService *self,
|
|
GSecretServiceFlags flags,
|
|
GSimpleAsyncResult *res)
|
|
{
|
|
InitClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
|
|
closure->flags = flags;
|
|
|
|
if (closure->flags & GSECRET_SERVICE_OPEN_SESSION)
|
|
gsecret_service_ensure_session (self, closure->cancellable,
|
|
on_ensure_session, g_object_ref (res));
|
|
|
|
else if (closure->flags & GSECRET_SERVICE_LOAD_COLLECTIONS)
|
|
gsecret_service_ensure_collections (self, closure->cancellable,
|
|
on_ensure_collections, g_object_ref (res));
|
|
|
|
else
|
|
g_simple_async_result_complete_in_idle (res);
|
|
}
|
|
|
|
static gboolean
|
|
gsecret_service_initable_init (GInitable *initable,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretService *self;
|
|
|
|
if (!gsecret_service_initable_parent_iface->init (initable, cancellable, error))
|
|
return FALSE;
|
|
|
|
self = GSECRET_SERVICE (initable);
|
|
return service_ensure_for_flags_sync (self, self->pv->init_flags, cancellable, error);
|
|
}
|
|
|
|
static void
|
|
gsecret_service_initable_iface (GInitableIface *iface)
|
|
{
|
|
gsecret_service_initable_parent_iface = g_type_interface_peek_parent (iface);
|
|
|
|
iface->init = gsecret_service_initable_init;
|
|
}
|
|
|
|
static void
|
|
on_init_base (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
GSecretService *self = GSECRET_SERVICE (source);
|
|
GError *error = NULL;
|
|
|
|
if (!gsecret_service_async_initable_parent_iface->init_finish (G_ASYNC_INITABLE (self),
|
|
result, &error)) {
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
} else {
|
|
|
|
}
|
|
|
|
service_ensure_for_flags_async (self, self->pv->init_flags, res);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
gsecret_service_async_initable_init_async (GAsyncInitable *initable,
|
|
int io_priority,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
InitClosure *closure;
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (initable), callback, user_data,
|
|
gsecret_service_async_initable_init_async);
|
|
closure = g_slice_new0 (InitClosure);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, init_closure_free);
|
|
|
|
gsecret_service_async_initable_parent_iface->init_async (initable, io_priority,
|
|
cancellable,
|
|
on_init_base,
|
|
g_object_ref (res));
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static gboolean
|
|
gsecret_service_async_initable_init_finish (GAsyncInitable *initable,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (initable),
|
|
gsecret_service_async_initable_init_async), FALSE);
|
|
|
|
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
gsecret_service_async_initable_iface (GAsyncInitableIface *iface)
|
|
{
|
|
gsecret_service_async_initable_parent_iface = g_type_interface_peek_parent (iface);
|
|
|
|
iface->init_async = gsecret_service_async_initable_init_async;
|
|
iface->init_finish = gsecret_service_async_initable_init_finish;
|
|
}
|
|
|
|
void
|
|
_gsecret_service_set_default_bus_name (const gchar *bus_name)
|
|
{
|
|
g_return_if_fail (bus_name != NULL);
|
|
default_bus_name = bus_name;
|
|
}
|
|
|
|
static void
|
|
on_service_instance_gone (gpointer user_data,
|
|
GObject *where_the_object_was)
|
|
{
|
|
G_LOCK (service_instance);
|
|
|
|
g_assert (service_instance == where_the_object_was);
|
|
service_instance = NULL;
|
|
|
|
G_UNLOCK (service_instance);
|
|
}
|
|
|
|
void
|
|
gsecret_service_get (GSecretServiceFlags flags,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSecretService *service = NULL;
|
|
GSimpleAsyncResult *res;
|
|
InitClosure *closure;
|
|
|
|
G_LOCK (service_instance);
|
|
if (service_instance != NULL)
|
|
service = g_object_ref (service_instance);
|
|
G_UNLOCK (service_instance);
|
|
|
|
/* Create a whole new service */
|
|
if (service == NULL) {
|
|
g_async_initable_new_async (GSECRET_TYPE_SERVICE, G_PRIORITY_DEFAULT,
|
|
cancellable, callback, user_data,
|
|
"g-flags", G_DBUS_PROXY_FLAGS_NONE,
|
|
"g-interface-info", _gsecret_gen_service_interface_info (),
|
|
"g-name", default_bus_name,
|
|
"g-bus-type", G_BUS_TYPE_SESSION,
|
|
"g-object-path", GSECRET_SERVICE_PATH,
|
|
"g-interface-name", GSECRET_SERVICE_INTERFACE,
|
|
"flags", flags,
|
|
NULL);
|
|
|
|
/* Just have to ensure that the service matches flags */
|
|
} else {
|
|
res = g_simple_async_result_new (G_OBJECT (service), callback,
|
|
user_data, gsecret_service_get);
|
|
closure = g_slice_new0 (InitClosure);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
|
|
closure->flags = flags;
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, init_closure_free);
|
|
|
|
service_ensure_for_flags_async (service, flags, res);
|
|
|
|
g_object_unref (service);
|
|
g_object_unref (res);
|
|
}
|
|
}
|
|
|
|
GSecretService *
|
|
gsecret_service_get_finish (GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GObject *service = NULL;
|
|
GObject *source_object;
|
|
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
|
|
source_object = g_async_result_get_source_object (result);
|
|
|
|
/* Just ensuring that the service matches flags */
|
|
if (g_simple_async_result_is_valid (result, source_object, gsecret_service_get)) {
|
|
if (!g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
|
|
service = g_object_ref (source_object);
|
|
|
|
/* Creating a whole new service */
|
|
} else {
|
|
service = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), result, error);
|
|
|
|
if (service) {
|
|
G_LOCK (service_instance);
|
|
if (service_instance == NULL) {
|
|
service_instance = service;
|
|
g_object_weak_ref (G_OBJECT (service), on_service_instance_gone, NULL);
|
|
}
|
|
G_UNLOCK (service_instance);
|
|
}
|
|
}
|
|
|
|
if (source_object)
|
|
g_object_unref (source_object);
|
|
|
|
if (service == NULL)
|
|
return NULL;
|
|
|
|
return GSECRET_SERVICE (service);
|
|
}
|
|
|
|
GSecretService *
|
|
gsecret_service_get_sync (GSecretServiceFlags flags,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretService *service = NULL;
|
|
|
|
G_LOCK (service_instance);
|
|
if (service_instance != NULL)
|
|
service = g_object_ref (service_instance);
|
|
G_UNLOCK (service_instance);
|
|
|
|
if (service == NULL) {
|
|
service = g_initable_new (GSECRET_TYPE_SERVICE, cancellable, error,
|
|
"g-flags", G_DBUS_PROXY_FLAGS_NONE,
|
|
"g-interface-info", _gsecret_gen_service_interface_info (),
|
|
"g-name", default_bus_name,
|
|
"g-bus-type", G_BUS_TYPE_SESSION,
|
|
"g-object-path", GSECRET_SERVICE_PATH,
|
|
"g-interface-name", GSECRET_SERVICE_INTERFACE,
|
|
"flags", flags,
|
|
NULL);
|
|
|
|
if (service != NULL) {
|
|
G_LOCK (service_instance);
|
|
if (service_instance == NULL) {
|
|
service_instance = service;
|
|
g_object_weak_ref (G_OBJECT (service), on_service_instance_gone, NULL);
|
|
}
|
|
G_UNLOCK (service_instance);
|
|
}
|
|
|
|
} else {
|
|
if (!service_ensure_for_flags_sync (service, flags, cancellable, error)) {
|
|
g_object_unref (service);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return service;
|
|
}
|
|
|
|
void
|
|
gsecret_service_new (const gchar *service_bus_name,
|
|
GSecretServiceFlags flags,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
if (service_bus_name == NULL)
|
|
service_bus_name = default_bus_name;
|
|
|
|
g_async_initable_new_async (GSECRET_TYPE_SERVICE, G_PRIORITY_DEFAULT,
|
|
cancellable, callback, user_data,
|
|
"g-flags", G_DBUS_PROXY_FLAGS_NONE,
|
|
"g-interface-info", _gsecret_gen_service_interface_info (),
|
|
"g-name", service_bus_name,
|
|
"g-bus-type", G_BUS_TYPE_SESSION,
|
|
"g-object-path", GSECRET_SERVICE_PATH,
|
|
"g-interface-name", GSECRET_SERVICE_INTERFACE,
|
|
"flags", flags,
|
|
NULL);
|
|
}
|
|
|
|
GSecretService *
|
|
gsecret_service_new_finish (GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GObject *source_object;
|
|
GObject *object;
|
|
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
|
|
source_object = g_async_result_get_source_object (result);
|
|
object = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object),
|
|
result, error);
|
|
g_object_unref (source_object);
|
|
|
|
if (object == NULL)
|
|
return NULL;
|
|
|
|
return GSECRET_SERVICE (object);
|
|
}
|
|
|
|
GSecretService *
|
|
gsecret_service_new_sync (const gchar *service_bus_name,
|
|
GSecretServiceFlags flags,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
|
|
|
|
if (service_bus_name == NULL)
|
|
service_bus_name = default_bus_name;
|
|
|
|
return g_initable_new (GSECRET_TYPE_SERVICE, cancellable, error,
|
|
"g-flags", G_DBUS_PROXY_FLAGS_NONE,
|
|
"g-interface-info", _gsecret_gen_service_interface_info (),
|
|
"g-name", service_bus_name,
|
|
"g-bus-type", G_BUS_TYPE_SESSION,
|
|
"g-object-path", GSECRET_SERVICE_PATH,
|
|
"g-interface-name", GSECRET_SERVICE_INTERFACE,
|
|
"flags", flags,
|
|
NULL);
|
|
}
|
|
|
|
GSecretServiceFlags
|
|
gsecret_service_get_flags (GSecretService *self)
|
|
{
|
|
GSecretServiceFlags flags = 0;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), GSECRET_SERVICE_NONE);
|
|
|
|
g_mutex_lock (&self->pv->mutex);
|
|
|
|
if (self->pv->session)
|
|
flags |= GSECRET_SERVICE_OPEN_SESSION;
|
|
if (self->pv->collections)
|
|
flags |= GSECRET_SERVICE_LOAD_COLLECTIONS;
|
|
|
|
g_mutex_unlock (&self->pv->mutex);
|
|
|
|
return flags;
|
|
}
|
|
|
|
GList *
|
|
gsecret_service_get_collections (GSecretService *self)
|
|
{
|
|
GList *l, *collections;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
|
|
g_mutex_lock (&self->pv->mutex);
|
|
|
|
if (self->pv->collections == NULL) {
|
|
collections = NULL;
|
|
|
|
} else {
|
|
collections = g_hash_table_get_values (self->pv->collections);
|
|
for (l = collections; l != NULL; l = g_list_next (l))
|
|
g_object_ref (l->data);
|
|
}
|
|
|
|
g_mutex_unlock (&self->pv->mutex);
|
|
|
|
return collections;
|
|
}
|
|
|
|
GSecretItem *
|
|
_gsecret_service_find_item_instance (GSecretService *self,
|
|
const gchar *item_path)
|
|
{
|
|
GSecretCollection *collection = NULL;
|
|
gchar *collection_path;
|
|
GSecretItem *item;
|
|
|
|
collection_path = _gsecret_util_parent_path (item_path);
|
|
|
|
g_mutex_lock (&self->pv->mutex);
|
|
if (self->pv->collections) {
|
|
collection = g_hash_table_lookup (self->pv->collections, collection_path);
|
|
if (collection != NULL)
|
|
g_object_ref (collection);
|
|
}
|
|
g_mutex_unlock (&self->pv->mutex);
|
|
|
|
g_free (collection_path);
|
|
|
|
if (collection == NULL)
|
|
return NULL;
|
|
|
|
item = _gsecret_collection_find_item_instance (collection, item_path);
|
|
g_object_unref (collection);
|
|
|
|
return item;
|
|
}
|
|
|
|
GSecretSession *
|
|
_gsecret_service_get_session (GSecretService *self)
|
|
{
|
|
GSecretSession *session;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
|
|
g_mutex_lock (&self->pv->mutex);
|
|
session = self->pv->session;
|
|
g_mutex_unlock (&self->pv->mutex);
|
|
|
|
return session;
|
|
}
|
|
|
|
void
|
|
_gsecret_service_take_session (GSecretService *self,
|
|
GSecretSession *session)
|
|
{
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (session != NULL);
|
|
|
|
g_mutex_lock (&self->pv->mutex);
|
|
if (self->pv->session == NULL)
|
|
self->pv->session = session;
|
|
else
|
|
_gsecret_session_free (session);
|
|
g_mutex_unlock (&self->pv->mutex);
|
|
}
|
|
|
|
const gchar *
|
|
gsecret_service_get_session_algorithms (GSecretService *self)
|
|
{
|
|
GSecretSession *session;
|
|
const gchar *algorithms;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
|
|
g_mutex_lock (&self->pv->mutex);
|
|
session = self->pv->session;
|
|
algorithms = session ? _gsecret_session_get_algorithms (session) : NULL;
|
|
g_mutex_unlock (&self->pv->mutex);
|
|
|
|
/* Session never changes once established, so can return const */
|
|
return algorithms;
|
|
}
|
|
|
|
const gchar *
|
|
gsecret_service_get_session_path (GSecretService *self)
|
|
{
|
|
GSecretSession *session;
|
|
const gchar *path;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
|
|
g_mutex_lock (&self->pv->mutex);
|
|
session = self->pv->session;
|
|
path = session ? _gsecret_session_get_path (session) : NULL;
|
|
g_mutex_unlock (&self->pv->mutex);
|
|
|
|
/* Session never changes once established, so can return const */
|
|
return path;
|
|
}
|
|
|
|
void
|
|
gsecret_service_ensure_session (GSecretService *self,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
GSecretSession *session;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
g_mutex_lock (&self->pv->mutex);
|
|
session = self->pv->session;
|
|
g_mutex_unlock (&self->pv->mutex);
|
|
|
|
if (session == NULL) {
|
|
_gsecret_session_open (self, cancellable, callback, user_data);
|
|
|
|
} else {
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
gsecret_service_ensure_session);
|
|
g_simple_async_result_complete_in_idle (res);
|
|
g_object_unref (res);
|
|
}
|
|
}
|
|
|
|
const gchar *
|
|
gsecret_service_ensure_session_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
|
|
if (!g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
gsecret_service_ensure_session)) {
|
|
if (!_gsecret_session_open_finish (result, error))
|
|
return NULL;
|
|
}
|
|
|
|
g_return_val_if_fail (self->pv->session != NULL, NULL);
|
|
return gsecret_service_get_session_path (self);
|
|
}
|
|
|
|
const gchar *
|
|
gsecret_service_ensure_session_sync (GSecretService *self,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
const gchar *path;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_ensure_session (self, cancellable,
|
|
_gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
path = gsecret_service_ensure_session_finish (self, sync->result, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return path;
|
|
}
|
|
|
|
static GSecretCollection *
|
|
service_lookup_collection (GSecretService *self,
|
|
const gchar *path)
|
|
{
|
|
GSecretCollection *collection = NULL;
|
|
|
|
g_mutex_lock (&self->pv->mutex);
|
|
|
|
if (self->pv->collections) {
|
|
collection = g_hash_table_lookup (self->pv->collections, path);
|
|
if (collection != NULL)
|
|
g_object_ref (collection);
|
|
}
|
|
|
|
g_mutex_unlock (&self->pv->mutex);
|
|
|
|
return collection;
|
|
}
|
|
|
|
static void
|
|
service_update_collections (GSecretService *self,
|
|
GHashTable *collections)
|
|
{
|
|
GHashTable *previous;
|
|
|
|
g_hash_table_ref (collections);
|
|
|
|
g_mutex_lock (&self->pv->mutex);
|
|
|
|
previous = self->pv->collections;
|
|
self->pv->collections = collections;
|
|
|
|
g_mutex_unlock (&self->pv->mutex);
|
|
|
|
if (previous != NULL)
|
|
g_hash_table_unref (previous);
|
|
}
|
|
|
|
typedef struct {
|
|
GCancellable *cancellable;
|
|
GHashTable *collections;
|
|
gint collections_loading;
|
|
} EnsureClosure;
|
|
|
|
static GHashTable *
|
|
collections_table_new (void)
|
|
{
|
|
return g_hash_table_new_full (g_str_hash, g_str_equal,
|
|
g_free, g_object_unref);
|
|
}
|
|
|
|
static void
|
|
ensure_closure_free (gpointer data)
|
|
{
|
|
EnsureClosure *closure = data;
|
|
g_clear_object (&closure->cancellable);
|
|
g_hash_table_unref (closure->collections);
|
|
g_slice_free (EnsureClosure, closure);
|
|
}
|
|
|
|
static void
|
|
on_ensure_collection (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
GSecretService *self = GSECRET_SERVICE (g_async_result_get_source_object (user_data));
|
|
EnsureClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GSecretCollection *collection;
|
|
const gchar *path;
|
|
GError *error = NULL;
|
|
|
|
closure->collections_loading--;
|
|
|
|
collection = gsecret_collection_new_finish (result, &error);
|
|
|
|
if (error != NULL)
|
|
g_simple_async_result_take_error (res, error);
|
|
|
|
if (collection != NULL) {
|
|
path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (self));
|
|
g_hash_table_insert (closure->collections, g_strdup (path), collection);
|
|
}
|
|
|
|
if (closure->collections_loading == 0) {
|
|
service_update_collections (self, closure->collections);
|
|
g_simple_async_result_complete (res);
|
|
}
|
|
|
|
g_object_unref (self);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
void
|
|
gsecret_service_ensure_collections (GSecretService *self,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
EnsureClosure *closure;
|
|
GSecretCollection *collection;
|
|
GSimpleAsyncResult *res;
|
|
const gchar *path;
|
|
GVariant *paths;
|
|
GVariantIter iter;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
paths = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (self), "Collections");
|
|
g_return_if_fail (paths != NULL);
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
gsecret_service_ensure_collections);
|
|
closure = g_slice_new0 (EnsureClosure);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
|
|
closure->collections = collections_table_new ();
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, ensure_closure_free);
|
|
|
|
g_variant_iter_init (&iter, paths);
|
|
while (g_variant_iter_loop (&iter, "&o", &path)) {
|
|
collection = service_lookup_collection (self, path);
|
|
|
|
/* No such collection yet create a new one */
|
|
if (collection == NULL) {
|
|
gsecret_collection_new (self, path, cancellable,
|
|
on_ensure_collection, g_object_ref (res));
|
|
closure->collections_loading++;
|
|
} else {
|
|
g_hash_table_insert (closure->collections, g_strdup (path), collection);
|
|
}
|
|
}
|
|
|
|
if (closure->collections_loading == 0) {
|
|
service_update_collections (self, closure->collections);
|
|
g_simple_async_result_complete_in_idle (res);
|
|
}
|
|
|
|
g_variant_unref (paths);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_ensure_collections_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
gsecret_service_ensure_collections), FALSE);
|
|
|
|
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_ensure_collections_sync (GSecretService *self,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretCollection *collection;
|
|
GHashTable *collections;
|
|
GVariant *paths;
|
|
GVariantIter iter;
|
|
const gchar *path;
|
|
gboolean ret = TRUE;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
paths = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (self), "Collections");
|
|
g_return_val_if_fail (paths != NULL, FALSE);
|
|
|
|
collections = collections_table_new ();
|
|
|
|
g_variant_iter_init (&iter, paths);
|
|
while (g_variant_iter_next (&iter, "&o", &path)) {
|
|
collection = service_lookup_collection (self, path);
|
|
|
|
/* No such collection yet create a new one */
|
|
if (collection == NULL) {
|
|
collection = gsecret_collection_new_sync (self, path, cancellable, error);
|
|
if (collection == NULL) {
|
|
ret = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
g_hash_table_insert (collections, g_strdup (path), collection);
|
|
}
|
|
|
|
if (ret)
|
|
service_update_collections (self, collections);
|
|
|
|
g_hash_table_unref (collections);
|
|
g_variant_unref (paths);
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
on_search_items_complete (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
GError *error = NULL;
|
|
GVariant *response;
|
|
|
|
response = g_dbus_proxy_call_finish (G_DBUS_PROXY (source), result, &error);
|
|
if (error != NULL)
|
|
g_simple_async_result_take_error (res, error);
|
|
else
|
|
g_simple_async_result_set_op_res_gpointer (res, response,
|
|
(GDestroyNotify)g_variant_unref);
|
|
|
|
g_simple_async_result_complete (res);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
void
|
|
gsecret_service_search_for_paths (GSecretService *self,
|
|
GHashTable *attributes,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (attributes != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
gsecret_service_search_for_paths);
|
|
|
|
g_dbus_proxy_call (G_DBUS_PROXY (self), "SearchItems",
|
|
g_variant_new ("(@a{ss})",
|
|
_gsecret_util_variant_for_attributes (attributes)),
|
|
G_DBUS_CALL_FLAGS_NONE, -1, cancellable,
|
|
on_search_items_complete, g_object_ref (res));
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_search_for_paths_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
gchar ***unlocked,
|
|
gchar ***locked,
|
|
GError **error)
|
|
{
|
|
GVariant *response;
|
|
GSimpleAsyncResult *res;
|
|
gchar **dummy = NULL;
|
|
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
gsecret_service_search_for_paths), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
res = G_SIMPLE_ASYNC_RESULT (result);
|
|
if (g_simple_async_result_propagate_error (res, error))
|
|
return FALSE;
|
|
|
|
if (unlocked || locked) {
|
|
if (!unlocked)
|
|
unlocked = &dummy;
|
|
else if (!locked)
|
|
locked = &dummy;
|
|
response = g_simple_async_result_get_op_res_gpointer (res);
|
|
g_variant_get (response, "(^ao^ao)", unlocked, locked);
|
|
}
|
|
|
|
g_strfreev (dummy);
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_search_for_paths_sync (GSecretService *self,
|
|
GHashTable *attributes,
|
|
GCancellable *cancellable,
|
|
gchar ***unlocked,
|
|
gchar ***locked,
|
|
GError **error)
|
|
{
|
|
gchar **dummy = NULL;
|
|
GVariant *response;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (attributes != NULL, FALSE);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
response = g_dbus_proxy_call_sync (G_DBUS_PROXY (self), "SearchItems",
|
|
g_variant_new ("(@a{ss})",
|
|
_gsecret_util_variant_for_attributes (attributes)),
|
|
G_DBUS_CALL_FLAGS_NONE, -1, cancellable, error);
|
|
|
|
if (response != NULL) {
|
|
if (unlocked || locked) {
|
|
if (!unlocked)
|
|
unlocked = &dummy;
|
|
else if (!locked)
|
|
locked = &dummy;
|
|
g_variant_get (response, "(^ao^ao)", unlocked, locked);
|
|
}
|
|
|
|
g_variant_unref (response);
|
|
}
|
|
|
|
g_strfreev (dummy);
|
|
|
|
return response != NULL;
|
|
}
|
|
|
|
typedef struct {
|
|
GCancellable *cancellable;
|
|
GHashTable *items;
|
|
gchar **unlocked;
|
|
gchar **locked;
|
|
guint loading;
|
|
} SearchClosure;
|
|
|
|
static void
|
|
search_closure_free (gpointer data)
|
|
{
|
|
SearchClosure *closure = data;
|
|
g_clear_object (&closure->cancellable);
|
|
g_hash_table_unref (closure->items);
|
|
g_strfreev (closure->unlocked);
|
|
g_strfreev (closure->locked);
|
|
g_slice_free (SearchClosure, closure);
|
|
}
|
|
|
|
static void
|
|
search_closure_take_item (SearchClosure *closure,
|
|
GSecretItem *item)
|
|
{
|
|
const gchar *path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (item));
|
|
g_hash_table_insert (closure->items, (gpointer)path, item);
|
|
}
|
|
|
|
static void
|
|
on_search_loaded (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
SearchClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GError *error = NULL;
|
|
GSecretItem *item;
|
|
|
|
closure->loading--;
|
|
|
|
item = gsecret_item_new_finish (result, &error);
|
|
if (error != NULL)
|
|
g_simple_async_result_take_error (res, error);
|
|
|
|
if (item != NULL)
|
|
search_closure_take_item (closure, item);
|
|
if (closure->loading == 0)
|
|
g_simple_async_result_complete (res);
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
search_load_item_async (GSecretService *self,
|
|
GSimpleAsyncResult *res,
|
|
SearchClosure *closure,
|
|
const gchar *path)
|
|
{
|
|
GSecretItem *item;
|
|
|
|
item = _gsecret_service_find_item_instance (self, path);
|
|
if (item == NULL) {
|
|
gsecret_item_new (self, path, closure->cancellable,
|
|
on_search_loaded, g_object_ref (res));
|
|
closure->loading++;
|
|
} else {
|
|
search_closure_take_item (closure, item);
|
|
}
|
|
}
|
|
|
|
static void
|
|
on_search_paths (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
SearchClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GSecretService *self = GSECRET_SERVICE (source);
|
|
GError *error = NULL;
|
|
guint i;
|
|
|
|
if (!gsecret_service_search_for_paths_finish (self, result, &closure->unlocked,
|
|
&closure->locked, &error)) {
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
}
|
|
|
|
for (i = 0; closure->unlocked[i] != NULL; i++)
|
|
search_load_item_async (self, res, closure, closure->unlocked[i]);
|
|
for (i = 0; closure->locked[i] != NULL; i++)
|
|
search_load_item_async (self, res, closure, closure->locked[i]);
|
|
|
|
if (closure->loading == 0)
|
|
g_simple_async_result_complete (res);
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
void
|
|
gsecret_service_search (GSecretService *self,
|
|
GHashTable *attributes,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
SearchClosure *closure;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (attributes != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
gsecret_service_search);
|
|
closure = g_slice_new0 (SearchClosure);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
|
|
closure->items = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_object_unref);
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, search_closure_free);
|
|
|
|
gsecret_service_search_for_paths (self, attributes, cancellable,
|
|
on_search_paths, g_object_ref (res));
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static GList *
|
|
search_finish_build (gchar **paths,
|
|
SearchClosure *closure)
|
|
{
|
|
GList *results = NULL;
|
|
GSecretItem *item;
|
|
guint i;
|
|
|
|
for (i = 0; paths[i]; i++) {
|
|
item = g_hash_table_lookup (closure->items, paths[i]);
|
|
if (item != NULL)
|
|
results = g_list_prepend (results, g_object_ref (item));
|
|
}
|
|
|
|
return g_list_reverse (results);
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_search_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GList **unlocked,
|
|
GList **locked,
|
|
GError **error)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
SearchClosure *closure;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
gsecret_service_search), FALSE);
|
|
|
|
res = G_SIMPLE_ASYNC_RESULT (result);
|
|
|
|
if (g_simple_async_result_propagate_error (res, error))
|
|
return FALSE;
|
|
|
|
closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
if (unlocked)
|
|
*unlocked = search_finish_build (closure->unlocked, closure);
|
|
if (locked)
|
|
*locked = search_finish_build (closure->locked, closure);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
service_load_items_sync (GSecretService *self,
|
|
GCancellable *cancellable,
|
|
gchar **paths,
|
|
GList **items,
|
|
GError **error)
|
|
{
|
|
GSecretItem *item;
|
|
GList *result = NULL;
|
|
guint i;
|
|
|
|
for (i = 0; paths[i] != NULL; i++) {
|
|
item = _gsecret_service_find_item_instance (self, paths[i]);
|
|
if (item == NULL)
|
|
item = gsecret_item_new_sync (self, paths[i], cancellable, error);
|
|
if (item == NULL) {
|
|
g_list_free_full (result, g_object_unref);
|
|
return FALSE;
|
|
} else {
|
|
result = g_list_prepend (result, item);
|
|
}
|
|
}
|
|
|
|
*items = g_list_reverse (result);
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_search_sync (GSecretService *self,
|
|
GHashTable *attributes,
|
|
GCancellable *cancellable,
|
|
GList **unlocked,
|
|
GList **locked,
|
|
GError **error)
|
|
{
|
|
gchar **unlocked_paths = NULL;
|
|
gchar **locked_paths = NULL;
|
|
gboolean ret;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
if (!gsecret_service_search_for_paths_sync (self, attributes, cancellable,
|
|
unlocked ? &unlocked_paths : NULL,
|
|
locked ? &locked_paths : NULL, error))
|
|
return FALSE;
|
|
|
|
ret = TRUE;
|
|
|
|
if (unlocked)
|
|
ret = service_load_items_sync (self, cancellable, unlocked_paths, unlocked, error);
|
|
if (ret && locked)
|
|
ret = service_load_items_sync (self, cancellable, locked_paths, locked, error);
|
|
|
|
g_strfreev (unlocked_paths);
|
|
g_strfreev (locked_paths);
|
|
|
|
return ret;
|
|
}
|
|
|
|
typedef struct {
|
|
GCancellable *cancellable;
|
|
GVariant *in;
|
|
GVariant *out;
|
|
GHashTable *items;
|
|
} GetClosure;
|
|
|
|
static void
|
|
get_closure_free (gpointer data)
|
|
{
|
|
GetClosure *closure = data;
|
|
if (closure->in)
|
|
g_variant_unref (closure->in);
|
|
if (closure->out)
|
|
g_variant_unref (closure->out);
|
|
g_clear_object (&closure->cancellable);
|
|
g_slice_free (GetClosure, closure);
|
|
}
|
|
|
|
static void
|
|
on_get_secrets_complete (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
GetClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GError *error = NULL;
|
|
|
|
closure->out = g_dbus_proxy_call_finish (G_DBUS_PROXY (source), result, &error);
|
|
if (error != NULL)
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
on_get_secrets_session (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
GetClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GError *error = NULL;
|
|
const gchar *session;
|
|
|
|
session = gsecret_service_ensure_session_finish (GSECRET_SERVICE (source),
|
|
result, &error);
|
|
if (error != NULL) {
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
} else {
|
|
g_dbus_proxy_call (G_DBUS_PROXY (source), "GetSecrets",
|
|
g_variant_new ("(@aoo)", closure->in, session),
|
|
G_DBUS_CALL_FLAGS_NO_AUTO_START, -1,
|
|
closure->cancellable, on_get_secrets_complete,
|
|
g_object_ref (res));
|
|
}
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
void
|
|
gsecret_service_get_secret_for_path (GSecretService *self,
|
|
const gchar *object_path,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
GetClosure *closure;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (object_path != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
gsecret_service_get_secret_for_path);
|
|
|
|
closure = g_slice_new0 (GetClosure);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
|
|
closure->in = g_variant_ref_sink (g_variant_new_objv (&object_path, 1));
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, get_closure_free);
|
|
|
|
gsecret_service_ensure_session (self, cancellable,
|
|
on_get_secrets_session,
|
|
g_object_ref (res));
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static GSecretValue *
|
|
service_decode_get_secrets_first (GSecretService *self,
|
|
GVariant *out)
|
|
{
|
|
GSecretSession *session;
|
|
GSecretValue *value = NULL;
|
|
GVariantIter *iter;
|
|
GVariant *variant;
|
|
const gchar *path;
|
|
|
|
g_variant_get (out, "(a{o(oayays)})", &iter);
|
|
while (g_variant_iter_next (iter, "{&o@(oayays)}", &path, &variant)) {
|
|
session = _gsecret_service_get_session (self);
|
|
value = _gsecret_session_decode_secret (session, variant);
|
|
g_variant_unref (variant);
|
|
break;
|
|
}
|
|
g_variant_iter_free (iter);
|
|
return value;
|
|
}
|
|
|
|
static GHashTable *
|
|
service_decode_get_secrets_all (GSecretService *self,
|
|
GVariant *out)
|
|
{
|
|
GSecretSession *session;
|
|
GVariantIter *iter;
|
|
GVariant *variant;
|
|
GHashTable *values;
|
|
GSecretValue *value;
|
|
gchar *path;
|
|
|
|
session = _gsecret_service_get_session (self);
|
|
values = g_hash_table_new_full (g_str_hash, g_str_equal,
|
|
g_free, gsecret_value_unref);
|
|
g_variant_get (out, "(a{o(oayays)})", &iter);
|
|
while (g_variant_iter_loop (iter, "{o@(oayays)}", &path, &variant)) {
|
|
value = _gsecret_session_decode_secret (session, variant);
|
|
if (value && path)
|
|
g_hash_table_insert (values, g_strdup (path), value);
|
|
}
|
|
g_variant_iter_free (iter);
|
|
return values;
|
|
}
|
|
|
|
GSecretValue *
|
|
gsecret_service_get_secret_for_path_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
GetClosure *closure;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
gsecret_service_get_secret_for_path), NULL);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
|
|
res = G_SIMPLE_ASYNC_RESULT (result);
|
|
if (g_simple_async_result_propagate_error (res, error))
|
|
return NULL;
|
|
|
|
closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
return service_decode_get_secrets_first (self, closure->out);
|
|
}
|
|
|
|
GSecretValue *
|
|
gsecret_service_get_secret_for_path_sync (GSecretService *self,
|
|
const gchar *object_path,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
GSecretValue *value;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_get_secret_for_path (self, object_path, cancellable,
|
|
_gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
value = gsecret_service_get_secret_for_path_finish (self, sync->result, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
void
|
|
gsecret_service_get_secrets_for_paths (GSecretService *self,
|
|
const gchar **object_paths,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
GetClosure *closure;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (object_paths != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
gsecret_service_get_secret_for_path);
|
|
|
|
closure = g_slice_new0 (GetClosure);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
|
|
closure->in = g_variant_ref_sink (g_variant_new_objv (object_paths, -1));
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, get_closure_free);
|
|
|
|
gsecret_service_ensure_session (self, cancellable,
|
|
on_get_secrets_session,
|
|
g_object_ref (res));
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
GHashTable *
|
|
gsecret_service_get_secrets_for_paths_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
GetClosure *closure;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
gsecret_service_get_secret_for_path), NULL);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
|
|
res = G_SIMPLE_ASYNC_RESULT (result);
|
|
if (g_simple_async_result_propagate_error (res, error))
|
|
return NULL;
|
|
|
|
closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
return service_decode_get_secrets_all (self, closure->out);
|
|
}
|
|
|
|
GHashTable *
|
|
gsecret_service_get_secrets_for_paths_sync (GSecretService *self,
|
|
const gchar **object_paths,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
GHashTable *secrets;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_get_secrets_for_paths (self, object_paths, cancellable,
|
|
_gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
secrets = gsecret_service_get_secrets_for_paths_finish (self, sync->result, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return secrets;
|
|
}
|
|
|
|
void
|
|
gsecret_service_get_secrets (GSecretService *self,
|
|
GList *items,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
GetClosure *closure;
|
|
GPtrArray *paths;
|
|
const gchar *path;
|
|
GList *l;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
gsecret_service_get_secrets);
|
|
closure = g_slice_new0 (GetClosure);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
|
|
closure->items = g_hash_table_new_full (g_str_hash, g_str_equal,
|
|
g_free, g_object_unref);
|
|
|
|
paths = g_ptr_array_new ();
|
|
for (l = items; l != NULL; l = g_list_next (l)) {
|
|
path = g_dbus_proxy_get_object_path (l->data);
|
|
g_hash_table_insert (closure->items, g_strdup (path), g_object_ref (l->data));
|
|
g_ptr_array_add (paths, (gpointer)path);
|
|
}
|
|
|
|
closure->in = g_variant_new_objv ((const gchar * const *)paths->pdata, paths->len);
|
|
g_variant_ref_sink (closure->in);
|
|
|
|
g_ptr_array_free (paths, TRUE);
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, get_closure_free);
|
|
|
|
gsecret_service_ensure_session (self, cancellable,
|
|
on_get_secrets_session,
|
|
g_object_ref (res));
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
GHashTable *
|
|
gsecret_service_get_secrets_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
GetClosure *closure;
|
|
GHashTable *with_paths;
|
|
GHashTable *with_items;
|
|
GHashTableIter iter;
|
|
const gchar *path;
|
|
GSecretValue *value;
|
|
GSecretItem *item;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
gsecret_service_get_secrets), NULL);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
|
|
res = G_SIMPLE_ASYNC_RESULT (result);
|
|
if (g_simple_async_result_propagate_error (res, error))
|
|
return NULL;
|
|
|
|
closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
with_paths = service_decode_get_secrets_all (self, closure->out);
|
|
g_return_val_if_fail (with_paths != NULL, NULL);
|
|
|
|
with_items = g_hash_table_new_full (g_direct_hash, g_direct_equal,
|
|
g_object_unref, gsecret_value_unref);
|
|
|
|
g_hash_table_iter_init (&iter, with_paths);
|
|
while (g_hash_table_iter_next (&iter, (gpointer *)&path, (gpointer *)&value)) {
|
|
item = g_hash_table_lookup (closure->items, path);
|
|
if (item != NULL)
|
|
g_hash_table_insert (with_items, g_object_ref (item),
|
|
gsecret_value_ref (value));
|
|
}
|
|
|
|
g_hash_table_unref (with_paths);
|
|
return with_items;
|
|
}
|
|
|
|
GHashTable *
|
|
gsecret_service_get_secrets_sync (GSecretService *self,
|
|
GList *items,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
GHashTable *secrets;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_get_secrets (self, items, cancellable,
|
|
_gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
secrets = gsecret_service_get_secrets_finish (self, sync->result, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return secrets;
|
|
}
|
|
|
|
typedef struct {
|
|
GCancellable *cancellable;
|
|
GSecretPrompt *prompt;
|
|
GHashTable *objects;
|
|
GPtrArray *xlocked;
|
|
} XlockClosure;
|
|
|
|
static void
|
|
xlock_closure_free (gpointer data)
|
|
{
|
|
XlockClosure *closure = data;
|
|
g_clear_object (&closure->cancellable);
|
|
g_clear_object (&closure->prompt);
|
|
if (closure->xlocked)
|
|
g_ptr_array_unref (closure->xlocked);
|
|
if (closure->objects)
|
|
g_hash_table_unref (closure->objects);
|
|
g_slice_free (XlockClosure, closure);
|
|
}
|
|
|
|
static void
|
|
on_xlock_prompted (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
XlockClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GSecretService *self = GSECRET_SERVICE (source);
|
|
GError *error = NULL;
|
|
GVariantIter iter;
|
|
GVariant *retval;
|
|
gchar *path;
|
|
gboolean ret;
|
|
|
|
ret = gsecret_service_prompt_finish (self, result, &error);
|
|
if (error != NULL)
|
|
g_simple_async_result_take_error (res, error);
|
|
|
|
if (ret) {
|
|
retval = gsecret_prompt_get_result_value (closure->prompt, G_VARIANT_TYPE ("ao"));
|
|
g_variant_iter_init (&iter, retval);
|
|
while (g_variant_iter_loop (&iter, "o", &path))
|
|
g_ptr_array_add (closure->xlocked, g_strdup (path));
|
|
g_variant_unref (retval);
|
|
}
|
|
|
|
g_simple_async_result_complete (res);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
on_xlock_called (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
XlockClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GSecretService *self = GSECRET_SERVICE (g_async_result_get_source_object (user_data));
|
|
const gchar *prompt = NULL;
|
|
gchar **xlocked = NULL;
|
|
GError *error = NULL;
|
|
GVariant *retval;
|
|
guint i;
|
|
|
|
retval = g_dbus_proxy_call_finish (G_DBUS_PROXY (source), result, &error);
|
|
if (error != NULL) {
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
|
|
} else {
|
|
g_variant_get (retval, "(^ao&o)", &xlocked, &prompt);
|
|
|
|
if (_gsecret_util_empty_path (prompt)) {
|
|
for (i = 0; xlocked[i]; i++)
|
|
g_ptr_array_add (closure->xlocked, g_strdup (xlocked[i]));
|
|
g_simple_async_result_complete (res);
|
|
|
|
} else {
|
|
closure->prompt = gsecret_prompt_instance (self, prompt);
|
|
gsecret_service_prompt (self, closure->prompt, closure->cancellable,
|
|
on_xlock_prompted, g_object_ref (res));
|
|
}
|
|
|
|
g_strfreev (xlocked);
|
|
g_variant_unref (retval);
|
|
}
|
|
|
|
g_object_unref (self);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static GSimpleAsyncResult *
|
|
service_xlock_paths_async (GSecretService *self,
|
|
const gchar *method,
|
|
const gchar **paths,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
XlockClosure *closure;
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
service_xlock_paths_async);
|
|
closure = g_slice_new0 (XlockClosure);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : cancellable;
|
|
closure->xlocked = g_ptr_array_new_with_free_func (g_free);
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, xlock_closure_free);
|
|
|
|
g_dbus_proxy_call (G_DBUS_PROXY (self), method,
|
|
g_variant_new ("(@ao)", g_variant_new_objv (paths, -1)),
|
|
G_DBUS_CALL_FLAGS_NO_AUTO_START, -1,
|
|
cancellable, on_xlock_called, g_object_ref (res));
|
|
|
|
return res;
|
|
}
|
|
|
|
static gint
|
|
service_xlock_paths_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
gchar ***xlocked,
|
|
GError **error)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
XlockClosure *closure;
|
|
gint count;
|
|
|
|
res = G_SIMPLE_ASYNC_RESULT (result);
|
|
if (g_simple_async_result_propagate_error (res, error))
|
|
return -1;
|
|
|
|
closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
count = closure->xlocked->len;
|
|
|
|
if (xlocked != NULL) {
|
|
g_ptr_array_add (closure->xlocked, NULL);
|
|
*xlocked = (gchar **)g_ptr_array_free (closure->xlocked, FALSE);
|
|
closure->xlocked = NULL;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
static void
|
|
service_xlock_async (GSecretService *self,
|
|
const gchar *method,
|
|
GList *objects,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
XlockClosure *closure;
|
|
GHashTable *table;
|
|
GPtrArray *paths;
|
|
const gchar *path;
|
|
GList *l;
|
|
|
|
table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
|
|
paths = g_ptr_array_new ();
|
|
|
|
for (l = objects; l != NULL; l = g_list_next (l)) {
|
|
path = g_dbus_proxy_get_object_path (l->data);
|
|
g_ptr_array_add (paths, (gpointer)path);
|
|
g_hash_table_insert (table, g_strdup (path), g_object_ref (l->data));
|
|
}
|
|
g_ptr_array_add (paths, NULL);
|
|
|
|
res = service_xlock_paths_async (self, "Lock", (const gchar **)paths->pdata,
|
|
cancellable, callback, user_data);
|
|
|
|
closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
closure->objects = table;
|
|
|
|
g_ptr_array_free (paths, TRUE);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static gint
|
|
service_xlock_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GList **xlocked,
|
|
GError **error)
|
|
{
|
|
XlockClosure *closure;
|
|
gchar **paths = NULL;
|
|
GObject *object;
|
|
gint count;
|
|
guint i;
|
|
|
|
count = service_xlock_paths_finish (self, result,
|
|
xlocked ? &paths : NULL,
|
|
error);
|
|
|
|
if (count > 0 && xlocked) {
|
|
closure = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
|
|
*xlocked = NULL;
|
|
|
|
for (i = 0; paths[i] != NULL; i++) {
|
|
object = g_hash_table_lookup (closure->objects, paths[i]);
|
|
if (object != NULL)
|
|
*xlocked = g_list_prepend (*xlocked, g_object_ref (object));
|
|
}
|
|
|
|
*xlocked = g_list_reverse (*xlocked);
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
void
|
|
gsecret_service_lock (GSecretService *self,
|
|
GList *objects,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
service_xlock_async (self, "Lock", objects, cancellable, callback, user_data);
|
|
}
|
|
|
|
gint
|
|
gsecret_service_lock_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GList **locked,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
return service_xlock_finish (self, result, locked, error);
|
|
}
|
|
|
|
gint
|
|
gsecret_service_lock_sync (GSecretService *self,
|
|
GList *objects,
|
|
GCancellable *cancellable,
|
|
GList **locked,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
gint count;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), -1);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), -1);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, -1);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_lock (self, objects, cancellable,
|
|
_gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
count = gsecret_service_lock_finish (self, sync->result, locked, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return count;
|
|
}
|
|
|
|
gint
|
|
gsecret_service_lock_paths_sync (GSecretService *self,
|
|
const gchar **paths,
|
|
GCancellable *cancellable,
|
|
gchar ***locked,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
gint count;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), -1);
|
|
g_return_val_if_fail (paths != NULL, -1);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), -1);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, -1);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_lock_paths (self, paths, cancellable,
|
|
_gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
count = gsecret_service_lock_paths_finish (self, sync->result,
|
|
locked, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return count;
|
|
}
|
|
|
|
void
|
|
gsecret_service_lock_paths (GSecretService *self,
|
|
const gchar **paths,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (paths != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
res = service_xlock_paths_async (self, "Lock", paths, cancellable,
|
|
callback, user_data);
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
gint
|
|
gsecret_service_lock_paths_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
gchar ***unlocked,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), -1);
|
|
g_return_val_if_fail (unlocked != NULL, -1);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, -1);
|
|
|
|
return service_xlock_paths_finish (self, result, unlocked, error);
|
|
}
|
|
|
|
gint
|
|
gsecret_service_unlock_paths_sync (GSecretService *self,
|
|
const gchar **paths,
|
|
GCancellable *cancellable,
|
|
gchar ***unlocked,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
gint count;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), -1);
|
|
g_return_val_if_fail (paths != NULL, -1);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), -1);
|
|
g_return_val_if_fail (unlocked != NULL, -1);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, -1);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_unlock_paths (self, paths, cancellable,
|
|
_gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
count = gsecret_service_unlock_paths_finish (self, sync->result,
|
|
unlocked, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return count;
|
|
}
|
|
|
|
void
|
|
gsecret_service_unlock_paths (GSecretService *self,
|
|
const gchar **paths,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (paths != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
res = service_xlock_paths_async (self, "Unlock",
|
|
paths, cancellable,
|
|
callback, user_data);
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
gint
|
|
gsecret_service_unlock_paths_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
gchar ***unlocked,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), -1);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, -1);
|
|
|
|
return service_xlock_paths_finish (self, result,
|
|
unlocked, error);
|
|
}
|
|
|
|
void
|
|
gsecret_service_unlock (GSecretService *self,
|
|
GList *objects,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
service_xlock_async (self, "Unlock", objects, cancellable, callback, user_data);
|
|
}
|
|
|
|
gint
|
|
gsecret_service_unlock_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GList **unlocked,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), -1);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, -1);
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
service_xlock_paths_async), -1);
|
|
|
|
return service_xlock_finish (self, result, unlocked, error);
|
|
}
|
|
|
|
gint
|
|
gsecret_service_unlock_sync (GSecretService *self,
|
|
GList *objects,
|
|
GCancellable *cancellable,
|
|
GList **unlocked,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
gint count;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), -1);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), -1);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, -1);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_unlock (self, objects, cancellable,
|
|
_gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
count = gsecret_service_unlock_finish (self, sync->result,
|
|
unlocked, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return count;
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_prompt_sync (GSecretService *self,
|
|
GSecretPrompt *prompt,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretServiceClass *klass;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (GSECRET_IS_PROMPT (prompt), FALSE);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
klass = GSECRET_SERVICE_GET_CLASS (self);
|
|
g_return_val_if_fail (klass->prompt_sync != NULL, FALSE);
|
|
|
|
return (klass->prompt_sync) (self, prompt, cancellable, error);
|
|
}
|
|
|
|
void
|
|
gsecret_service_prompt (GSecretService *self,
|
|
GSecretPrompt *prompt,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSecretServiceClass *klass;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (GSECRET_IS_PROMPT (prompt));
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
klass = GSECRET_SERVICE_GET_CLASS (self);
|
|
g_return_if_fail (klass->prompt_async != NULL);
|
|
|
|
(klass->prompt_async) (self, prompt, cancellable, callback, user_data);
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_prompt_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GSecretServiceClass *klass;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
klass = GSECRET_SERVICE_GET_CLASS (self);
|
|
g_return_val_if_fail (klass->prompt_finish != NULL, FALSE);
|
|
|
|
return (klass->prompt_finish) (self, result, error);
|
|
}
|
|
|
|
typedef struct {
|
|
gchar *collection_path;
|
|
GSecretValue *value;
|
|
GCancellable *cancellable;
|
|
GSecretPrompt *prompt;
|
|
gboolean created;
|
|
} StoreClosure;
|
|
|
|
static void
|
|
store_closure_free (gpointer data)
|
|
{
|
|
StoreClosure *closure = data;
|
|
g_free (closure->collection_path);
|
|
gsecret_value_unref (closure->value);
|
|
g_clear_object (&closure->cancellable);
|
|
g_clear_object (&closure->prompt);
|
|
g_free (closure);
|
|
}
|
|
|
|
void
|
|
gsecret_service_store (GSecretService *self,
|
|
const GSecretSchema *schema,
|
|
const gchar *collection_path,
|
|
const gchar *label,
|
|
GSecretValue *value,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data,
|
|
...)
|
|
{
|
|
GHashTable *attributes;
|
|
va_list va;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (schema != NULL);
|
|
g_return_if_fail (collection_path != NULL);
|
|
g_return_if_fail (label != NULL);
|
|
g_return_if_fail (value != NULL);
|
|
|
|
va_start (va, user_data);
|
|
attributes = _gsecret_util_attributes_for_varargs (schema, va);
|
|
va_end (va);
|
|
|
|
gsecret_service_storev (self, schema, attributes, collection_path,
|
|
label, value, cancellable, callback, user_data);
|
|
|
|
g_hash_table_unref (attributes);
|
|
}
|
|
|
|
static void
|
|
on_store_prompt (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
StoreClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GError *error = NULL;
|
|
|
|
closure->created = gsecret_service_prompt_finish (GSECRET_SERVICE (source), result, &error);
|
|
if (error != NULL)
|
|
g_simple_async_result_take_error (res, error);
|
|
|
|
g_simple_async_result_complete (res);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
on_store_create (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
StoreClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GSecretService *self = GSECRET_SERVICE (g_async_result_get_source_object (result));
|
|
const gchar *prompt_path = NULL;
|
|
const gchar *item_path = NULL;
|
|
GError *error = NULL;
|
|
GVariant *retval;
|
|
|
|
retval = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), result, &error);
|
|
if (error == NULL) {
|
|
g_variant_get (retval, "(&o&o)", &item_path, &prompt_path);
|
|
if (!_gsecret_util_empty_path (prompt_path)) {
|
|
closure->prompt = gsecret_prompt_instance (self, prompt_path);
|
|
gsecret_service_prompt (self, closure->prompt, closure->cancellable,
|
|
on_store_prompt, g_object_ref (res));
|
|
|
|
} else {
|
|
g_simple_async_result_complete (res);
|
|
}
|
|
|
|
g_variant_unref (retval);
|
|
|
|
} else {
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
}
|
|
|
|
g_object_unref (self);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
void
|
|
gsecret_service_storev (GSecretService *self,
|
|
const GSecretSchema *schema,
|
|
GHashTable *attributes,
|
|
const gchar *collection_path,
|
|
const gchar *label,
|
|
GSecretValue *value,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
GSecretSession *session;
|
|
GVariant *attrs;
|
|
StoreClosure *closure;
|
|
GVariantBuilder builder;
|
|
GVariant *params;
|
|
GDBusProxy *proxy;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (schema != NULL);
|
|
g_return_if_fail (attributes != NULL);
|
|
g_return_if_fail (collection_path != NULL);
|
|
g_return_if_fail (label != NULL);
|
|
g_return_if_fail (value != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
/* Build up the attributes */
|
|
attrs = _gsecret_util_variant_for_attributes (attributes);
|
|
|
|
/* Build up the various properties */
|
|
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
|
|
g_variant_builder_add (&builder, "{sv}", GSECRET_SERVICE_INTERFACE "Attributes", attrs);
|
|
g_variant_builder_add (&builder, "{sv}", GSECRET_SERVICE_INTERFACE "Label", g_variant_new_string (label));
|
|
g_variant_builder_add (&builder, "{sv}", GSECRET_SERVICE_INTERFACE "Schema", g_variant_new_string (schema->schema_name));
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
gsecret_service_storev);
|
|
closure = g_new0 (StoreClosure, 1);
|
|
closure->collection_path = g_strdup (collection_path);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, store_closure_free);
|
|
|
|
session = _gsecret_service_get_session (self);
|
|
params = g_variant_new ("(&a{sv}&(oayays)b)",
|
|
g_variant_builder_end (&builder),
|
|
_gsecret_session_encode_secret (session, value),
|
|
TRUE);
|
|
|
|
proxy = G_DBUS_PROXY (self);
|
|
g_dbus_connection_call (g_dbus_proxy_get_connection (proxy),
|
|
g_dbus_proxy_get_name (proxy),
|
|
closure->collection_path,
|
|
GSECRET_COLLECTION_INTERFACE,
|
|
"CreateItem", params, G_VARIANT_TYPE ("(oo)"),
|
|
G_DBUS_CALL_FLAGS_NO_AUTO_START, -1,
|
|
closure->cancellable, on_store_create,
|
|
g_object_ref (res));
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_store_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
StoreClosure *closure;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
gsecret_service_storev), FALSE);
|
|
|
|
res = G_SIMPLE_ASYNC_RESULT (result);
|
|
if (!g_simple_async_result_propagate_error (res, error))
|
|
return FALSE;
|
|
|
|
closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
return closure->created;
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_store_sync (GSecretService *self,
|
|
const GSecretSchema *schema,
|
|
const gchar *collection_path,
|
|
const gchar *label,
|
|
GSecretValue *value,
|
|
GCancellable *cancellable,
|
|
GError **error,
|
|
...)
|
|
{
|
|
GHashTable *attributes;
|
|
gboolean ret;
|
|
va_list va;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (schema != NULL, FALSE);
|
|
g_return_val_if_fail (collection_path != NULL, FALSE);
|
|
g_return_val_if_fail (label != NULL, FALSE);
|
|
g_return_val_if_fail (value != NULL, FALSE);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
va_start (va, error);
|
|
attributes = _gsecret_util_attributes_for_varargs (schema, va);
|
|
va_end (va);
|
|
|
|
ret = gsecret_service_storev_sync (self, schema, attributes, collection_path,
|
|
label, value, cancellable, error);
|
|
|
|
g_hash_table_unref (attributes);
|
|
|
|
return ret;
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_storev_sync (GSecretService *self,
|
|
const GSecretSchema *schema,
|
|
GHashTable *attributes,
|
|
const gchar *collection_path,
|
|
const gchar *label,
|
|
GSecretValue *value,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
gboolean ret;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (schema != NULL, FALSE);
|
|
g_return_val_if_fail (attributes != NULL, FALSE);
|
|
g_return_val_if_fail (collection_path != NULL, FALSE);
|
|
g_return_val_if_fail (label != NULL, FALSE);
|
|
g_return_val_if_fail (value != NULL, FALSE);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_storev (self, schema, attributes, collection_path,
|
|
label, value, cancellable, _gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
ret = gsecret_service_store_finish (self, sync->result, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return ret;
|
|
}
|
|
|
|
typedef struct {
|
|
GSecretValue *value;
|
|
GCancellable *cancellable;
|
|
} LookupClosure;
|
|
|
|
static void
|
|
lookup_closure_free (gpointer data)
|
|
{
|
|
LookupClosure *closure = data;
|
|
if (closure->value)
|
|
gsecret_value_unref (closure->value);
|
|
g_clear_object (&closure->cancellable);
|
|
g_slice_free (LookupClosure, closure);
|
|
}
|
|
|
|
void
|
|
gsecret_service_lookup (GSecretService *self,
|
|
const GSecretSchema *schema,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data,
|
|
...)
|
|
{
|
|
GHashTable *attributes;
|
|
va_list va;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (schema != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
va_start (va, user_data);
|
|
attributes = _gsecret_util_attributes_for_varargs (schema, va);
|
|
va_end (va);
|
|
|
|
gsecret_service_lookupv (self, attributes, cancellable, callback, user_data);
|
|
|
|
g_hash_table_unref (attributes);
|
|
}
|
|
|
|
static void
|
|
on_lookup_get_secret (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
LookupClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GSecretService *self = GSECRET_SERVICE (source);
|
|
GError *error = NULL;
|
|
|
|
closure->value = gsecret_service_get_secret_for_path_finish (self, result, &error);
|
|
if (error != NULL)
|
|
g_simple_async_result_take_error (res, error);
|
|
|
|
g_simple_async_result_complete (res);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
on_lookup_unlocked (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
LookupClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GSecretService *self = GSECRET_SERVICE (source);
|
|
GError *error = NULL;
|
|
gchar **unlocked = NULL;
|
|
|
|
gsecret_service_unlock_paths_finish (GSECRET_SERVICE (source),
|
|
result, &unlocked, &error);
|
|
if (error != NULL) {
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
|
|
} else if (unlocked && unlocked[0]) {
|
|
gsecret_service_get_secret_for_path (self, unlocked[0],
|
|
closure->cancellable,
|
|
on_lookup_get_secret,
|
|
g_object_ref (res));
|
|
|
|
} else {
|
|
g_simple_async_result_complete (res);
|
|
}
|
|
|
|
g_strfreev (unlocked);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
on_lookup_searched (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
LookupClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GSecretService *self = GSECRET_SERVICE (source);
|
|
GError *error = NULL;
|
|
gchar **unlocked = NULL;
|
|
gchar **locked = NULL;
|
|
|
|
gsecret_service_search_for_paths_finish (self, result, &unlocked, &locked, &error);
|
|
if (error != NULL) {
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
|
|
} else if (unlocked && unlocked[0]) {
|
|
gsecret_service_get_secret_for_path (self, unlocked[0],
|
|
closure->cancellable,
|
|
on_lookup_get_secret,
|
|
g_object_ref (res));
|
|
|
|
} else if (locked && locked[0]) {
|
|
const gchar *paths[] = { locked[0], NULL };
|
|
gsecret_service_unlock_paths (self, paths,
|
|
closure->cancellable,
|
|
on_lookup_unlocked,
|
|
g_object_ref (res));
|
|
|
|
} else {
|
|
g_simple_async_result_complete (res);
|
|
}
|
|
|
|
g_strfreev (unlocked);
|
|
g_strfreev (locked);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
void
|
|
gsecret_service_lookupv (GSecretService *self,
|
|
GHashTable *attributes,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
LookupClosure *closure;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (attributes != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
gsecret_service_lookupv);
|
|
closure = g_slice_new0 (LookupClosure);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, lookup_closure_free);
|
|
|
|
gsecret_service_search_for_paths (self, attributes, cancellable,
|
|
on_lookup_searched, g_object_ref (res));
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
GSecretValue *
|
|
gsecret_service_lookup_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
LookupClosure *closure;
|
|
GSecretValue *value;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
gsecret_service_lookupv), NULL);
|
|
|
|
res = G_SIMPLE_ASYNC_RESULT (result);
|
|
if (g_simple_async_result_propagate_error (res, error))
|
|
return NULL;
|
|
|
|
closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
value = closure->value;
|
|
closure->value = NULL;
|
|
return value;
|
|
}
|
|
|
|
GSecretValue *
|
|
gsecret_service_lookup_sync (GSecretService *self,
|
|
const GSecretSchema *schema,
|
|
GCancellable *cancellable,
|
|
GError **error,
|
|
...)
|
|
{
|
|
GHashTable *attributes;
|
|
GSecretValue *value;
|
|
va_list va;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
g_return_val_if_fail (schema != NULL, NULL);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
|
|
|
|
va_start (va, error);
|
|
attributes = _gsecret_util_attributes_for_varargs (schema, va);
|
|
va_end (va);
|
|
|
|
value = gsecret_service_lookupv_sync (self, attributes, cancellable, error);
|
|
|
|
g_hash_table_unref (attributes);
|
|
|
|
return value;
|
|
}
|
|
|
|
GSecretValue *
|
|
gsecret_service_lookupv_sync (GSecretService *self,
|
|
GHashTable *attributes,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
GSecretValue *value;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), NULL);
|
|
g_return_val_if_fail (attributes != NULL, NULL);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_lookupv (self, attributes, cancellable,
|
|
_gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
value = gsecret_service_lookup_finish (self, sync->result, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return value;
|
|
}
|
|
|
|
typedef struct {
|
|
GCancellable *cancellable;
|
|
GSecretPrompt *prompt;
|
|
gboolean deleted;
|
|
} DeleteClosure;
|
|
|
|
static void
|
|
delete_closure_free (gpointer data)
|
|
{
|
|
DeleteClosure *closure = data;
|
|
g_clear_object (&closure->prompt);
|
|
g_clear_object (&closure->cancellable);
|
|
g_slice_free (DeleteClosure, closure);
|
|
}
|
|
|
|
static void
|
|
on_delete_prompted (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
DeleteClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GError *error = NULL;
|
|
|
|
gsecret_service_prompt_finish (GSECRET_SERVICE (source), result, &error);
|
|
|
|
if (error == NULL)
|
|
closure->deleted = TRUE;
|
|
else
|
|
g_simple_async_result_take_error (res, error);
|
|
|
|
g_simple_async_result_complete (res);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
on_delete_complete (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
DeleteClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GSecretService *self = GSECRET_SERVICE (g_async_result_get_source_object (user_data));
|
|
const gchar *prompt_path;
|
|
GError *error = NULL;
|
|
GVariant *retval;
|
|
|
|
retval = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), result, &error);
|
|
if (error == NULL) {
|
|
g_variant_get (retval, "(&o)", &prompt_path);
|
|
|
|
if (_gsecret_util_empty_path (prompt_path)) {
|
|
closure->deleted = TRUE;
|
|
g_simple_async_result_complete (res);
|
|
|
|
} else {
|
|
closure->prompt = gsecret_prompt_instance (self, prompt_path);
|
|
|
|
gsecret_service_prompt (self, closure->prompt,
|
|
closure->cancellable,
|
|
on_delete_prompted,
|
|
g_object_ref (res));
|
|
}
|
|
|
|
g_variant_unref (retval);
|
|
|
|
} else {
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
}
|
|
|
|
g_object_unref (self);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
void
|
|
_gsecret_service_delete_path (GSecretService *self,
|
|
const gchar *object_path,
|
|
gboolean is_an_item,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
DeleteClosure *closure;
|
|
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (object_path != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
_gsecret_service_delete_path);
|
|
closure = g_slice_new0 (DeleteClosure);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, delete_closure_free);
|
|
|
|
g_dbus_connection_call (g_dbus_proxy_get_connection (G_DBUS_PROXY (self)),
|
|
g_dbus_proxy_get_name (G_DBUS_PROXY (self)), object_path,
|
|
is_an_item ? GSECRET_ITEM_INTERFACE : GSECRET_COLLECTION_INTERFACE,
|
|
"Delete", g_variant_new ("()"), G_VARIANT_TYPE ("(o)"),
|
|
G_DBUS_CALL_FLAGS_NO_AUTO_START, -1,
|
|
cancellable, on_delete_complete, g_object_ref (res));
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
void
|
|
gsecret_service_delete_path (GSecretService *self,
|
|
const gchar *item_path,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (GSECRET_IS_SERVICE (self));
|
|
g_return_if_fail (item_path != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
_gsecret_service_delete_path (self, item_path, TRUE, cancellable, callback, user_data);
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_delete_path_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
DeleteClosure *closure;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
_gsecret_service_delete_path), FALSE);
|
|
|
|
res = G_SIMPLE_ASYNC_RESULT (result);
|
|
if (g_simple_async_result_propagate_error (res, error))
|
|
return FALSE;
|
|
|
|
closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
return closure->deleted;
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_delete_path_sync (GSecretService *self,
|
|
const gchar *object_path,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
gboolean result;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (object_path != NULL, FALSE);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_delete_path (self, object_path, cancellable,
|
|
_gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
result = gsecret_service_delete_path_finish (self, sync->result, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return result;
|
|
}
|
|
|
|
static void
|
|
on_delete_password_complete (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
GSecretService *self = GSECRET_SERVICE (g_async_result_get_source_object (user_data));
|
|
DeleteClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GError *error = NULL;
|
|
|
|
closure->deleted = gsecret_service_delete_path_finish (self, result, &error);
|
|
if (error != NULL)
|
|
g_simple_async_result_take_error (res, error);
|
|
|
|
g_simple_async_result_complete (res);
|
|
|
|
g_object_unref (self);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
static void
|
|
on_search_delete_password (GObject *source,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
|
|
DeleteClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
GSecretService *self = GSECRET_SERVICE (g_async_result_get_source_object (user_data));
|
|
const gchar *path = NULL;
|
|
GError *error = NULL;
|
|
gchar **locked;
|
|
gchar **unlocked;
|
|
|
|
gsecret_service_search_for_paths_finish (self, result, &unlocked, &locked, &error);
|
|
if (error != NULL) {
|
|
g_simple_async_result_take_error (res, error);
|
|
g_simple_async_result_complete (res);
|
|
|
|
} else {
|
|
/* Choose the first path */
|
|
if (unlocked && unlocked[0])
|
|
path = unlocked[0];
|
|
else if (locked && locked[0])
|
|
path = locked[0];
|
|
|
|
/* Nothing to delete? */
|
|
if (path == NULL) {
|
|
closure->deleted = FALSE;
|
|
g_simple_async_result_complete (res);
|
|
|
|
/* Delete the first path */
|
|
} else {
|
|
closure->deleted = TRUE;
|
|
_gsecret_service_delete_path (self, path, TRUE,
|
|
closure->cancellable,
|
|
on_delete_password_complete,
|
|
g_object_ref (res));
|
|
}
|
|
}
|
|
|
|
g_strfreev (locked);
|
|
g_strfreev (unlocked);
|
|
g_object_unref (self);
|
|
g_object_unref (res);
|
|
}
|
|
|
|
void
|
|
gsecret_service_remove (GSecretService *self,
|
|
const GSecretSchema *schema,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data,
|
|
...)
|
|
{
|
|
GHashTable *attributes;
|
|
va_list va;
|
|
|
|
g_return_if_fail (GSECRET_SERVICE (self));
|
|
g_return_if_fail (schema != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
va_start (va, user_data);
|
|
attributes = _gsecret_util_attributes_for_varargs (schema, va);
|
|
va_end (va);
|
|
|
|
gsecret_service_removev (self, attributes, cancellable,
|
|
callback, user_data);
|
|
|
|
g_hash_table_unref (attributes);
|
|
}
|
|
|
|
void
|
|
gsecret_service_removev (GSecretService *self,
|
|
GHashTable *attributes,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
DeleteClosure *closure;
|
|
|
|
g_return_if_fail (GSECRET_SERVICE (self));
|
|
g_return_if_fail (attributes != NULL);
|
|
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
|
|
|
|
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
|
|
gsecret_service_remove);
|
|
closure = g_slice_new0 (DeleteClosure);
|
|
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
|
|
g_simple_async_result_set_op_res_gpointer (res, closure, delete_closure_free);
|
|
|
|
gsecret_service_search_for_paths (self, attributes, cancellable,
|
|
on_search_delete_password, g_object_ref (res));
|
|
|
|
g_object_unref (res);
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_remove_finish (GSecretService *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
GSimpleAsyncResult *res;
|
|
DeleteClosure *closure;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
|
|
gsecret_service_remove), FALSE);
|
|
|
|
res = G_SIMPLE_ASYNC_RESULT (result);
|
|
if (g_simple_async_result_propagate_error (res, error))
|
|
return FALSE;
|
|
|
|
closure = g_simple_async_result_get_op_res_gpointer (res);
|
|
return closure->deleted;
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_remove_sync (GSecretService *self,
|
|
const GSecretSchema* schema,
|
|
GCancellable *cancellable,
|
|
GError **error,
|
|
...)
|
|
{
|
|
GHashTable *attributes;
|
|
gboolean result;
|
|
va_list va;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
va_start (va, error);
|
|
attributes = _gsecret_util_attributes_for_varargs (schema, va);
|
|
va_end (va);
|
|
|
|
result = gsecret_service_removev_sync (self, attributes, cancellable, error);
|
|
|
|
g_hash_table_unref (attributes);
|
|
|
|
return result;
|
|
}
|
|
|
|
gboolean
|
|
gsecret_service_removev_sync (GSecretService *self,
|
|
GHashTable *attributes,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GSecretSync *sync;
|
|
gboolean result;
|
|
|
|
g_return_val_if_fail (GSECRET_IS_SERVICE (self), FALSE);
|
|
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
sync = _gsecret_sync_new ();
|
|
g_main_context_push_thread_default (sync->context);
|
|
|
|
gsecret_service_removev (self, attributes, cancellable,
|
|
_gsecret_sync_on_result, sync);
|
|
|
|
g_main_loop_run (sync->loop);
|
|
|
|
result = gsecret_service_remove_finish (self, sync->result, error);
|
|
|
|
g_main_context_pop_thread_default (sync->context);
|
|
_gsecret_sync_free (sync);
|
|
|
|
return result;
|
|
}
|