/* libsecret - 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.1 of the licence or (at * your option) any later version. * * See the included COPYING file for more information. * * Author: Stef Walter */ #include "config.h" #include "secret-backend.h" #include "secret-collection.h" #include "secret-dbus-generated.h" #include "secret-item.h" #include "secret-paths.h" #include "secret-private.h" #include "secret-service.h" #include "secret-types.h" #include "secret-value.h" #include "libsecret/secret-enum-types.h" #include "egg/egg-secure-memory.h" /** * SecretService: * * A proxy object representing the Secret Service. * * A #SecretService object represents the Secret Service implementation which * runs as a D-Bus service. * * Normally a single #SecretService object can be shared between multiple * callers. The [func@Service.get] method is used to access this #SecretService * object. If a new independent #SecretService object is required, use * [func@Service.open]. * * In order to securely transfer secrets to the Sercret Service, a session * is established. This session can be established while initializing a * #SecretService object by passing the %SECRET_SERVICE_OPEN_SESSION flag * to the [func@Service.get] or [func@Service.open] functions. In order to * establish a session on an already existing #SecretService, use the * [method@Service.ensure_session] function. * * To search for items, use the [method@Service.search] method. * * Multiple collections can exist in the Secret Service, each of which contains * secret items. In order to instantiate [class@Collection] objects which * represent those collections while initializing a #SecretService then pass * the %SECRET_SERVICE_LOAD_COLLECTIONS flag to the [func@Service.get] or * [func@Service.open] functions. In order to establish a session on an already * existing #SecretService, use the [method@Service.load_collections] function. * To access the list of collections use [method@Service.get_collections]. * * Certain actions on the Secret Service require user prompting to complete, * such as creating a collection, or unlocking a collection. When such a prompt * is necessary, then a [class@Prompt] object is created by this library, and * passed to the [method@Service.prompt] method. In this way it is handled * automatically. * * In order to customize prompt handling, override the * [vfunc@Service.prompt_async] and [vfunc@Service.prompt_finish] virtual * methods of the #SecretService class. * * Stability: Stable */ /** * SecretServiceClass: * @parent_class: the parent class * @collection_gtype: the [alias@GLib.Type] of the [class@Collection] objects instantiated * by the #SecretService proxy * @item_gtype: the [alias@GLib.Type] of the [class@Item] objects instantiated by the * #SecretService proxy * @prompt_async: called to perform asynchronous prompting when necessary * @prompt_finish: called to complete an asynchronous prompt operation * @prompt_sync: called to perform synchronous prompting when necessary * @get_collection_gtype: called to get the GObject type for collections * instantiated by the #SecretService proxy * @get_item_gtype: called to get the GObject type for collections * instantiated by the #SecretService proxy * * The class for #SecretService. */ /** * SecretServiceFlags: * @SECRET_SERVICE_NONE: no flags for initializing the #SecretService * @SECRET_SERVICE_OPEN_SESSION: establish a session for transfer of secrets * while initializing the #SecretService * @SECRET_SERVICE_LOAD_COLLECTIONS: load collections while initializing the * #SecretService * * Flags which determine which parts of the #SecretService proxy are initialized * during a [func@Service.get] or [func@Service.open] operation. */ EGG_SECURE_DEFINE_GLIB_GLOBALS (); GQuark _secret_error_quark = 0; enum { PROP_0, PROP_FLAGS, PROP_COLLECTIONS }; struct _SecretServicePrivate { /* No change between construct and finalize */ GCancellable *cancellable; SecretServiceFlags init_flags; /* Locked by mutex */ GMutex mutex; gpointer session; GHashTable *collections; }; G_LOCK_DEFINE (service_instance); static gpointer service_instance = NULL; static guint service_watch = 0; static GInitableIface *secret_service_initable_parent_iface = NULL; static GAsyncInitableIface *secret_service_async_initable_parent_iface = NULL; static SecretBackendInterface *secret_service_backend_parent_iface = NULL; static void secret_service_initable_iface (GInitableIface *iface); static void secret_service_async_initable_iface (GAsyncInitableIface *iface); static void secret_service_backend_iface (SecretBackendInterface *iface); G_DEFINE_TYPE_WITH_CODE (SecretService, secret_service, G_TYPE_DBUS_PROXY, G_ADD_PRIVATE (SecretService) G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, secret_service_initable_iface); G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, secret_service_async_initable_iface); G_IMPLEMENT_INTERFACE (SECRET_TYPE_BACKEND, secret_service_backend_iface); _secret_backend_ensure_extension_point (); g_io_extension_point_implement (SECRET_BACKEND_EXTENSION_POINT_NAME, g_define_type_id, "service", 0) ); static SecretService * service_get_instance (void) { SecretService *instance = NULL; G_LOCK (service_instance); if (service_instance != NULL) instance = g_object_ref (service_instance); G_UNLOCK (service_instance); return instance; } static gboolean service_uncache_instance (SecretService *which) { SecretService *instance = NULL; guint watch = 0; gboolean matched = FALSE; G_LOCK (service_instance); if (which == NULL || service_instance == which) { instance = service_instance; service_instance = NULL; watch = service_watch; service_watch = 0; matched = TRUE; } G_UNLOCK (service_instance); if (instance != NULL) g_object_unref (instance); if (watch != 0) g_bus_unwatch_name (watch); _secret_backend_uncache_instance (); return matched; } static void on_service_instance_vanished (GDBusConnection *connection, const gchar *name, gpointer user_data) { if (!service_uncache_instance (user_data)) { g_warning ("Global default SecretService instance out of sync " "with the watch for its DBus name"); } } static void service_cache_instance (SecretService *instance) { GDBusProxy *proxy; guint watch; g_object_ref (instance); proxy = G_DBUS_PROXY (instance); watch = g_bus_watch_name_on_connection (g_dbus_proxy_get_connection (proxy), g_dbus_proxy_get_name (proxy), G_BUS_NAME_WATCHER_FLAGS_NONE, NULL, on_service_instance_vanished, instance, NULL); G_LOCK (service_instance); if (service_instance == NULL) { service_instance = instance; instance = NULL; service_watch = watch; watch = 0; } G_UNLOCK (service_instance); if (instance != NULL) g_object_unref (instance); if (watch != 0) g_bus_unwatch_name (watch); } static void secret_service_init (SecretService *self) { self->pv = secret_service_get_instance_private (self); g_mutex_init (&self->pv->mutex); self->pv->cancellable = g_cancellable_new (); } static void secret_service_get_property (GObject *obj, guint prop_id, GValue *value, GParamSpec *pspec) { SecretService *self = SECRET_SERVICE (obj); switch (prop_id) { case PROP_FLAGS: g_value_set_flags (value, secret_service_get_flags (self)); break; case PROP_COLLECTIONS: g_value_take_boxed (value, secret_service_get_collections (self)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec); break; } } static void secret_service_set_property (GObject *obj, guint prop_id, const GValue *value, GParamSpec *pspec) { SecretService *self = SECRET_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 secret_service_dispose (GObject *obj) { SecretService *self = SECRET_SERVICE (obj); g_cancellable_cancel (self->pv->cancellable); G_OBJECT_CLASS (secret_service_parent_class)->dispose (obj); } static void secret_service_finalize (GObject *obj) { SecretService *self = SECRET_SERVICE (obj); _secret_session_free (self->pv->session); if (self->pv->collections) g_hash_table_destroy (self->pv->collections); g_clear_object (&self->pv->cancellable); g_mutex_clear (&self->pv->mutex); G_OBJECT_CLASS (secret_service_parent_class)->finalize (obj); } static GVariant * secret_service_real_prompt_sync (SecretService *self, SecretPrompt *prompt, GCancellable *cancellable, const GVariantType *return_type, GError **error) { return secret_prompt_perform_sync (prompt, NULL, cancellable, return_type, error); } static void on_real_prompt_completed (GObject *source, GAsyncResult *result, gpointer user_data) { GTask *task = G_TASK (user_data); GError *error = NULL; GVariant *retval; retval = secret_prompt_perform_finish (SECRET_PROMPT (source), result, &error); if (retval != NULL) g_task_return_pointer (task, g_steal_pointer (&retval), (GDestroyNotify) g_variant_unref); else g_task_return_error (task, g_steal_pointer (&error)); g_object_unref (task); } static void secret_service_real_prompt_async (SecretService *self, SecretPrompt *prompt, const GVariantType *return_type, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; task = g_task_new (self, cancellable, callback, user_data); g_task_set_source_tag (task, secret_service_real_prompt_async); secret_prompt_perform (prompt, 0, return_type, cancellable, on_real_prompt_completed, g_object_ref (task)); g_object_unref (task); } static GVariant * secret_service_real_prompt_finish (SecretService *self, GAsyncResult *result, GError **error) { GVariant *retval; g_return_val_if_fail (g_task_is_valid (result, self), NULL); g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == secret_service_real_prompt_async, NULL); retval = g_task_propagate_pointer (G_TASK (result), error); if (!retval) { _secret_util_strip_remote_error (error); return NULL; } return g_variant_ref_sink (retval); } static void handle_property_changed (SecretService *self, const gchar *property_name, GVariant *value) { gboolean perform; g_variant_ref_sink (value); 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) secret_service_load_collections (self, self->pv->cancellable, NULL, NULL); } g_variant_unref (value); } static void secret_service_properties_changed (GDBusProxy *proxy, GVariant *changed_properties, const gchar* const *invalidated_properties) { SecretService *self = SECRET_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 secret_service_signal (GDBusProxy *proxy, const gchar *sender_name, const gchar *signal_name, GVariant *parameters) { SecretService *self = SECRET_SERVICE (proxy); SecretCollection *collection; const gchar *collection_path; GVariantBuilder builder; gboolean found = FALSE; GVariantIter iter; GVariant *value; GVariant *paths; GVariant *path; /* * Remember that these signals come from a time before PropertiesChanged. * We support them because they're in the spec, and ksecretservice uses them. */ paths = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (self), "Collections"); /* A new collection was added, add it to the Collections property */ if (g_str_equal (signal_name, SECRET_SIGNAL_COLLECTION_CREATED)) { g_variant_get (parameters, "(@o)", &value); g_variant_builder_init (&builder, G_VARIANT_TYPE ("ao")); g_variant_iter_init (&iter, paths); while ((path = g_variant_iter_next_value (&iter)) != NULL) { if (g_variant_equal (path, value)) { found = TRUE; break; } g_variant_builder_add_value (&builder, path); g_variant_unref (path); } if (!found) { g_variant_builder_add_value (&builder, value); handle_property_changed (self, "Collections", g_variant_builder_end (&builder)); } g_variant_builder_clear (&builder); g_variant_unref (value); /* A collection was deleted, remove it from the Collections property */ } else if (g_str_equal (signal_name, SECRET_SIGNAL_COLLECTION_DELETED)) { g_variant_get (parameters, "(@o)", &value); g_variant_builder_init (&builder, G_VARIANT_TYPE ("ao")); g_variant_iter_init (&iter, paths); while ((path = g_variant_iter_next_value (&iter)) != NULL) { if (g_variant_equal (path, value)) found = TRUE; else g_variant_builder_add_value (&builder, path); g_variant_unref (path); } if (found) handle_property_changed (self, "Collections", g_variant_builder_end (&builder)); g_variant_unref (value); /* The collection changed, update it */ } else if (g_str_equal (signal_name, SECRET_SIGNAL_COLLECTION_CHANGED)) { g_variant_get (parameters, "(&o)", &collection_path); g_mutex_lock (&self->pv->mutex); if (self->pv->collections) collection = g_hash_table_lookup (self->pv->collections, collection_path); else collection = NULL; if (collection) g_object_ref (collection); g_mutex_unlock (&self->pv->mutex); if (collection) { secret_collection_refresh (collection); g_object_unref (collection); } } g_variant_unref (paths); } static GType secret_service_real_get_collection_gtype (SecretService *self) { SecretServiceClass *klass; klass = SECRET_SERVICE_GET_CLASS (self); return klass->collection_gtype; } static GType secret_service_real_get_item_gtype (SecretService *self) { SecretServiceClass *klass; klass = SECRET_SERVICE_GET_CLASS (self); return klass->item_gtype; } static const gchar * get_default_bus_name (void) { const gchar *bus_name; bus_name = g_getenv ("SECRET_SERVICE_BUS_NAME"); if (bus_name == NULL) bus_name = SECRET_SERVICE_BUS_NAME; return bus_name; } static GObject * secret_service_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_properties) { GObject *object; object = G_OBJECT_CLASS (secret_service_parent_class)-> constructor (type, n_construct_properties, construct_properties); g_object_set (object, "g-flags", G_DBUS_PROXY_FLAGS_NONE, "g-interface-info", _secret_gen_service_interface_info (), "g-name", get_default_bus_name (), "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", SECRET_SERVICE_PATH, "g-interface-name", SECRET_SERVICE_INTERFACE, NULL); return object; } static void secret_service_class_init (SecretServiceClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GDBusProxyClass *proxy_class = G_DBUS_PROXY_CLASS (klass); object_class->get_property = secret_service_get_property; object_class->set_property = secret_service_set_property; object_class->dispose = secret_service_dispose; object_class->finalize = secret_service_finalize; object_class->constructor = secret_service_constructor; proxy_class->g_properties_changed = secret_service_properties_changed; proxy_class->g_signal = secret_service_signal; klass->prompt_sync = secret_service_real_prompt_sync; klass->prompt_async = secret_service_real_prompt_async; klass->prompt_finish = secret_service_real_prompt_finish; klass->item_gtype = SECRET_TYPE_ITEM; klass->collection_gtype = SECRET_TYPE_COLLECTION; klass->get_item_gtype = secret_service_real_get_item_gtype; klass->get_collection_gtype = secret_service_real_get_collection_gtype; /** * SecretService:flags: * * A set of flags describing which parts of the secret service have * been initialized. */ g_object_class_override_property (object_class, PROP_FLAGS, "flags"); /** * SecretService:collections: (attributes org.gtk.Property.get=secret_service_get_collections) * * A list of [class@Collection] objects representing the collections in * the Secret Service. * * This list may be %NULL if the collections have not been loaded. * * To load the collections, specify the %SECRET_SERVICE_LOAD_COLLECTIONS * initialization flag when calling the [func@Service.get] or * [func@Service.open] functions. Or call the [method@Service.load_collections] * method. */ g_object_class_install_property (object_class, PROP_COLLECTIONS, g_param_spec_boxed ("collections", "Collections", "Secret Service Collections", _secret_list_get_type (), G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); /* Initialize this error domain, registers dbus errors */ _secret_error_quark = secret_error_get_quark (); } typedef struct { SecretServiceFlags flags; } InitClosure; static void init_closure_free (gpointer data) { InitClosure *closure = data; g_free (closure); } static gboolean service_ensure_for_flags_sync (SecretService *self, SecretServiceFlags flags, GCancellable *cancellable, GError **error) { if (flags & SECRET_SERVICE_OPEN_SESSION) if (!secret_service_ensure_session_sync (self, cancellable, error)) return FALSE; if (flags & SECRET_SERVICE_LOAD_COLLECTIONS) if (!secret_service_load_collections_sync (self, cancellable, error)) return FALSE; return TRUE; } static void on_load_collections (GObject *source, GAsyncResult *result, gpointer user_data) { GTask *task = G_TASK (user_data); SecretService *self = SECRET_SERVICE (source); GError *error = NULL; if (!secret_service_load_collections_finish (self, result, &error)) g_task_return_error (task, g_steal_pointer (&error)); else g_task_return_boolean (task, TRUE); g_object_unref (task); } static void on_ensure_session (GObject *source, GAsyncResult *result, gpointer user_data) { GTask *task = G_TASK (user_data); InitClosure *closure = g_task_get_task_data (task); SecretService *self = SECRET_SERVICE (source); GError *error = NULL; if (!secret_service_ensure_session_finish (self, result, &error)) { g_task_return_error (task, g_steal_pointer (&error)); } else if (closure->flags & SECRET_SERVICE_LOAD_COLLECTIONS) { secret_service_load_collections (self, g_task_get_cancellable (task), on_load_collections, g_object_ref (task)); } else { g_task_return_boolean (task, TRUE); } g_object_unref (task); } static void service_ensure_for_flags_async (SecretService *self, SecretServiceFlags flags, GTask *task) { InitClosure *closure = g_task_get_task_data (task); closure->flags = flags; if (closure->flags & SECRET_SERVICE_OPEN_SESSION) secret_service_ensure_session (self, g_task_get_cancellable (task), on_ensure_session, g_object_ref (task)); else if (closure->flags & SECRET_SERVICE_LOAD_COLLECTIONS) secret_service_load_collections (self, g_task_get_cancellable (task), on_load_collections, g_object_ref (task)); else g_task_return_boolean (task, TRUE); } static gboolean secret_service_initable_init (GInitable *initable, GCancellable *cancellable, GError **error) { SecretService *self; if (!secret_service_initable_parent_iface->init (initable, cancellable, error)) return FALSE; self = SECRET_SERVICE (initable); return service_ensure_for_flags_sync (self, self->pv->init_flags, cancellable, error); } static void secret_service_initable_iface (GInitableIface *iface) { secret_service_initable_parent_iface = g_type_interface_peek_parent (iface); iface->init = secret_service_initable_init; } static void secret_service_async_initable_init_async (GAsyncInitable *initable, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); typedef struct { GAsyncReadyCallback callback; gpointer user_data; } InitBaseClosure; static void on_init_base (GObject *source, GAsyncResult *result, gpointer user_data) { GTask *base_task = G_TASK (user_data); InitBaseClosure *base = g_task_get_task_data (base_task); GCancellable *cancellable = g_task_get_cancellable (base_task); GTask *task; InitClosure *init; SecretService *self = SECRET_SERVICE (source); GError *error = NULL; task = g_task_new (source, cancellable, base->callback, base->user_data); g_task_set_source_tag (task, secret_service_async_initable_init_async); init = g_new0 (InitClosure, 1); g_task_set_task_data (task, init, init_closure_free); g_clear_object (&base_task); if (!secret_service_async_initable_parent_iface->init_finish (G_ASYNC_INITABLE (self), result, &error)) { g_task_return_error (task, g_steal_pointer (&error)); } else { service_ensure_for_flags_async (self, self->pv->init_flags, task); } g_object_unref (task); } static void secret_service_async_initable_init_async (GAsyncInitable *initable, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; InitBaseClosure *base; task = g_task_new (initable, cancellable, NULL, NULL); g_task_set_source_tag (task, secret_service_async_initable_init_async); base = g_new0 (InitBaseClosure, 1); base->callback = callback; base->user_data = user_data; g_task_set_task_data (task, base, g_free); secret_service_async_initable_parent_iface->init_async (initable, io_priority, cancellable, on_init_base, g_object_ref (task)); g_object_unref (task); } static gboolean secret_service_async_initable_init_finish (GAsyncInitable *initable, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, initable), FALSE); if (!g_task_propagate_boolean (G_TASK (result), error)) { _secret_util_strip_remote_error (error); return FALSE; } return TRUE; } static void secret_service_async_initable_iface (GAsyncInitableIface *iface) { secret_service_async_initable_parent_iface = g_type_interface_peek_parent (iface); iface->init_async = secret_service_async_initable_init_async; iface->init_finish = secret_service_async_initable_init_finish; } static void secret_service_real_ensure_for_flags (SecretBackend *self, SecretBackendFlags flags, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; InitClosure *closure; g_return_if_fail (SECRET_IS_SERVICE (self)); task = g_task_new (self, cancellable, callback, user_data); closure = g_new0 (InitClosure, 1); g_task_set_task_data (task, closure, init_closure_free); service_ensure_for_flags_async (SECRET_SERVICE (self), flags, task); g_object_unref (task); } static gboolean secret_service_real_ensure_for_flags_finish (SecretBackend *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, self), FALSE); if (!g_task_propagate_boolean (G_TASK (result), error)) { _secret_util_strip_remote_error (error); return FALSE; } return TRUE; } static void secret_service_real_store (SecretBackend *self, const SecretSchema *schema, GHashTable *attributes, const gchar *collection, const gchar *label, SecretValue *value, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { g_return_if_fail (SECRET_IS_SERVICE (self)); secret_service_store (SECRET_SERVICE (self), schema, attributes, collection, label, value, cancellable, callback, user_data); } static gboolean secret_service_real_store_finish (SecretBackend *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (SECRET_IS_SERVICE (self), FALSE); return secret_service_store_finish (SECRET_SERVICE (self), result, error); } static void secret_service_real_lookup (SecretBackend *self, const SecretSchema *schema, GHashTable *attributes, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { g_return_if_fail (SECRET_IS_SERVICE (self)); secret_service_lookup (SECRET_SERVICE (self), schema, attributes, cancellable, callback, user_data); } static SecretValue * secret_service_real_lookup_finish (SecretBackend *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (SECRET_IS_SERVICE (self), NULL); return secret_service_lookup_finish (SECRET_SERVICE (self), result, error); } static void secret_service_real_clear (SecretBackend *self, const SecretSchema *schema, GHashTable *attributes, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { g_return_if_fail (SECRET_IS_SERVICE (self)); secret_service_clear (SECRET_SERVICE (self), schema, attributes, cancellable, callback, user_data); } static gboolean secret_service_real_clear_finish (SecretBackend *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (SECRET_IS_SERVICE (self), FALSE); return secret_service_clear_finish (SECRET_SERVICE (self), result, error); } static void secret_service_real_search (SecretBackend *self, const SecretSchema *schema, GHashTable *attributes, SecretSearchFlags flags, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { g_return_if_fail (SECRET_IS_SERVICE (self)); secret_service_search (SECRET_SERVICE (self), schema, attributes, flags, cancellable, callback, user_data); } static GList * secret_service_real_search_finish (SecretBackend *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (SECRET_IS_SERVICE (self), NULL); return secret_service_search_finish (SECRET_SERVICE (self), result, error); } static void secret_service_backend_iface (SecretBackendInterface *iface) { secret_service_backend_parent_iface = g_type_interface_peek_parent (iface); iface->ensure_for_flags = secret_service_real_ensure_for_flags; iface->ensure_for_flags_finish = secret_service_real_ensure_for_flags_finish; iface->store = secret_service_real_store; iface->store_finish = secret_service_real_store_finish; iface->lookup = secret_service_real_lookup; iface->lookup_finish = secret_service_real_lookup_finish; iface->clear = secret_service_real_clear; iface->clear_finish = secret_service_real_clear_finish; iface->search = secret_service_real_search; iface->search_finish = secret_service_real_search_finish; } /** * secret_service_get: * @flags: flags for which service functionality to ensure is initialized * @cancellable: (nullable): optional cancellation object * @callback: called when the operation completes * @user_data: data to be passed to the callback * * Get a #SecretService proxy for the Secret Service. * * If such a proxy object already exists, then the same proxy is returned. * * If @flags contains any flags of which parts of the secret service to * ensure are initialized, then those will be initialized before completing. * * This method will return immediately and complete asynchronously. */ void secret_service_get (SecretServiceFlags flags, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { SecretService *service = NULL; GTask *task; InitClosure *closure; service = service_get_instance (); /* Create a whole new service */ if (service == NULL) { g_async_initable_new_async (SECRET_TYPE_SERVICE, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "flags", flags, NULL); /* Just have to ensure that the service matches flags */ } else { task = g_task_new (service, cancellable, callback, user_data); g_task_set_source_tag (task, secret_service_get); closure = g_new0 (InitClosure, 1); closure->flags = flags; g_task_set_task_data (task, closure, init_closure_free); service_ensure_for_flags_async (service, flags, task); g_object_unref (service); g_object_unref (task); } } /** * secret_service_get_finish: * @result: the asynchronous result passed to the callback * @error: location to place an error on failure * * Complete an asynchronous operation to get a #SecretService proxy for the * Secret Service. * * Returns: (transfer full): a new reference to a #SecretService proxy, which * should be released with [method@GObject.Object.unref]. */ SecretService * secret_service_get_finish (GAsyncResult *result, GError **error) { GTask *task; 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); task = G_TASK (result); source_object = g_task_get_source_object (task); g_return_val_if_fail (g_task_is_valid (result, source_object), NULL); /* Just ensuring that the service matches flags */ if (g_task_get_source_tag (task) == secret_service_get) { if (g_task_had_error (task)) { g_task_propagate_pointer (task, error); _secret_util_strip_remote_error (error); } else { 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) service_cache_instance (SECRET_SERVICE (service)); } if (service == NULL) return NULL; return SECRET_SERVICE (service); } /** * secret_service_get_sync: * @flags: flags for which service functionality to ensure is initialized * @cancellable: (nullable): optional cancellation object * @error: location to place an error on failure * * Get a #SecretService proxy for the Secret Service. * * If such a proxy object already exists, then the same proxy is returned. * * If @flags contains any flags of which parts of the secret service to * ensure are initialized, then those will be initialized before returning. * * This method may block indefinitely and should not be used in user interface * threads. * * Returns: (transfer full): a new reference to a #SecretService proxy, which * should be released with [method@GObject.Object.unref]. */ SecretService * secret_service_get_sync (SecretServiceFlags flags, GCancellable *cancellable, GError **error) { SecretService *service = NULL; service = service_get_instance (); if (service == NULL) { service = g_initable_new (SECRET_TYPE_SERVICE, cancellable, error, "flags", flags, NULL); if (service != NULL) service_cache_instance (service); } else { if (!service_ensure_for_flags_sync (service, flags, cancellable, error)) { g_object_unref (service); return NULL; } } return service; } /** * secret_service_disconnect: * * Disconnect the default #SecretService proxy returned by [func@Service.get] * and [func@Service.get_sync]. * * It is not necessary to call this function, but you may choose to do so at * program exit. It is useful for testing that memory is not leaked. * * This function is safe to call at any time. But if other objects in this * library are still referenced, then this will not result in all memory * being freed. */ void secret_service_disconnect (void) { service_uncache_instance (NULL); } /** * secret_service_open: * @service_gtype: the GType of the new secret service * @service_bus_name: (nullable): the D-Bus service name of the secret service * @flags: flags for which service functionality to ensure is initialized * @cancellable: (nullable): optional cancellation object * @callback: called when the operation completes * @user_data: data to be passed to the callback * * Create a new #SecretService proxy for the Secret Service. * * This function is rarely used, see [func@Service.get] instead. * * The @service_gtype argument should be set to %SECRET_TYPE_SERVICE or a the type * of a derived class. * * If @flags contains any flags of which parts of the secret service to * ensure are initialized, then those will be initialized before returning. * * If @service_bus_name is %NULL then the default is used. * * This method will return immediately and complete asynchronously. */ void secret_service_open (GType service_gtype, const gchar *service_bus_name, SecretServiceFlags flags, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable)); g_return_if_fail (g_type_is_a (service_gtype, SECRET_TYPE_SERVICE)); g_async_initable_new_async (service_gtype, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "flags", flags, NULL); } /** * secret_service_open_finish: * @result: the asynchronous result passed to the callback * @error: location to place an error on failure * * Complete an asynchronous operation to create a new #SecretService proxy for * the Secret Service. * * Returns: (transfer full): a new reference to a #SecretService proxy, which * should be released with [method@GObject.Object.unref]. */ SecretService * secret_service_open_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 SECRET_SERVICE (object); } /** * secret_service_open_sync: * @service_gtype: the GType of the new secret service * @service_bus_name: (nullable): the D-Bus service name of the secret service * @flags: flags for which service functionality to ensure is initialized * @cancellable: (nullable): optional cancellation object * @error: location to place an error on failure * * Create a new #SecretService proxy for the Secret Service. * * This function is rarely used, see [func@Service.get_sync] instead. * * The @service_gtype argument should be set to %SECRET_TYPE_SERVICE or a the * type of a derived class. * * If @flags contains any flags of which parts of the secret service to * ensure are initialized, then those will be initialized before returning. * * If @service_bus_name is %NULL then the default is used. * * This method may block indefinitely and should not be used in user interface * threads. * * Returns: (transfer full): a new reference to a #SecretService proxy, which * should be released with [method@GObject.Object.unref]. */ SecretService * secret_service_open_sync (GType service_gtype, const gchar *service_bus_name, SecretServiceFlags flags, GCancellable *cancellable, GError **error) { g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL); g_return_val_if_fail (g_type_is_a (service_gtype, SECRET_TYPE_SERVICE), NULL); return g_initable_new (service_gtype, cancellable, error, "flags", flags, NULL); } /** * secret_service_get_flags: * @self: the secret service proxy * * Get the flags representing what features of the #SecretService proxy * have been initialized. * * Use [method@Service.ensure_session] or [method@Service.load_collections] * to initialize further features and change the flags. * * Returns: the flags for features initialized */ SecretServiceFlags secret_service_get_flags (SecretService *self) { SecretServiceFlags flags = 0; g_return_val_if_fail (SECRET_IS_SERVICE (self), SECRET_SERVICE_NONE); g_mutex_lock (&self->pv->mutex); if (self->pv->session) flags |= SECRET_SERVICE_OPEN_SESSION; if (self->pv->collections) flags |= SECRET_SERVICE_LOAD_COLLECTIONS; g_mutex_unlock (&self->pv->mutex); return flags; } /** * secret_service_get_collections: (attributes org.gtk.Method.get_property=collections) * @self: the secret service proxy * * Get a list of [class@Collection] objects representing all the collections * in the secret service. * * If the %SECRET_SERVICE_LOAD_COLLECTIONS flag was not specified when * initializing #SecretService proxy object, then this method will return * %NULL. Use [method@Service.load_collections] to load the collections. * * Returns: (transfer full) (element-type Secret.Collection) (nullable): a * list of the collections in the secret service */ GList * secret_service_get_collections (SecretService *self) { GList *l, *collections; g_return_val_if_fail (SECRET_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; } SecretItem * _secret_service_find_item_instance (SecretService *self, const gchar *item_path) { SecretCollection *collection = NULL; gchar *collection_path; SecretItem *item; collection_path = _secret_util_parent_path (item_path); collection = _secret_service_find_collection_instance (self, collection_path); g_free (collection_path); if (collection == NULL) return NULL; item = _secret_collection_find_item_instance (collection, item_path); g_object_unref (collection); return item; } SecretCollection * _secret_service_find_collection_instance (SecretService *self, const gchar *collection_path) { SecretCollection *collection = NULL; 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); return collection; } SecretSession * _secret_service_get_session (SecretService *self) { SecretSession *session; g_return_val_if_fail (SECRET_IS_SERVICE (self), NULL); g_mutex_lock (&self->pv->mutex); session = self->pv->session; g_mutex_unlock (&self->pv->mutex); return session; } void _secret_service_take_session (SecretService *self, SecretSession *session) { g_return_if_fail (SECRET_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 _secret_session_free (session); g_mutex_unlock (&self->pv->mutex); } /** * secret_service_get_session_algorithms: * @self: the secret service proxy * * Get the set of algorithms being used to transfer secrets between this * secret service proxy and the Secret Service itself. * * This will be %NULL if no session has been established. Use * [method@Service.ensure_session] to establish a session. * * Returns: (nullable): a string representing the algorithms for transferring * secrets */ const gchar * secret_service_get_session_algorithms (SecretService *self) { SecretSession *session; const gchar *algorithms; g_return_val_if_fail (SECRET_IS_SERVICE (self), NULL); g_mutex_lock (&self->pv->mutex); session = self->pv->session; algorithms = session ? _secret_session_get_algorithms (session) : NULL; g_mutex_unlock (&self->pv->mutex); /* Session never changes once established, so can return const */ return algorithms; } /** * secret_service_get_session_dbus_path: * @self: the secret service proxy * * Get the D-Bus object path of the session object being used to transfer * secrets between this secret service proxy and the Secret Service itself. * * This will be %NULL if no session has been established. Use * [method@Service.ensure_session] to establish a session. * * Returns: (nullable): a string representing the D-Bus object path of the * session */ const gchar * secret_service_get_session_dbus_path (SecretService *self) { SecretSession *session; const gchar *path; g_return_val_if_fail (SECRET_IS_SERVICE (self), NULL); g_mutex_lock (&self->pv->mutex); session = self->pv->session; path = session ? _secret_session_get_path (session) : NULL; g_mutex_unlock (&self->pv->mutex); /* Session never changes once established, so can return const */ return path; } /** * secret_service_ensure_session: * @self: the secret service * @cancellable: (nullable): optional cancellation object * @callback: called when the operation completes * @user_data: data to be passed to the callback * * Ensure that the #SecretService proxy has established a session with the * Secret Service. * * This session is used to transfer secrets. * * It is not normally necessary to call this method, as the session is * established as necessary. You can also pass the %SECRET_SERVICE_OPEN_SESSION * to [func@Service.get] in order to ensure that a session has been established * by the time you get the #SecretService proxy. * * This method will return immediately and complete asynchronously. */ void secret_service_ensure_session (SecretService *self, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; SecretSession *session; g_return_if_fail (SECRET_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) { _secret_session_open (self, cancellable, callback, user_data); } else { task = g_task_new (self, cancellable, callback, user_data); g_task_set_source_tag (task, secret_service_ensure_session); g_task_return_boolean (task, TRUE); g_object_unref (task); } } /** * secret_service_ensure_session_finish: * @self: the secret service * @result: the asynchronous result passed to the callback * @error: location to place an error on failure * * Finish an asynchronous operation to ensure that the #SecretService proxy * has established a session with the Secret Service. * * Returns: whether a session is established or not */ gboolean secret_service_ensure_session_finish (SecretService *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (SECRET_IS_SERVICE (self), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); g_return_val_if_fail (g_task_is_valid (result, self), FALSE); if (!g_task_propagate_boolean (G_TASK (result), error)) { _secret_util_strip_remote_error (error); return FALSE; } g_return_val_if_fail (self->pv->session != NULL, FALSE); return TRUE; } /** * secret_service_ensure_session_sync: * @self: the secret service * @cancellable: (nullable): optional cancellation object * @error: location to place an error on failure * * Ensure that the #SecretService proxy has established a session with the * Secret Service. * * This session is used to transfer secrets. * * It is not normally necessary to call this method, as the session is * established as necessary. You can also pass the %SECRET_SERVICE_OPEN_SESSION * to [func@Service.get_sync] in order to ensure that a session has been * established by the time you get the #SecretService proxy. * * This method may block indefinitely and should not be used in user interface * threads. * * Returns: whether a session is established or not */ gboolean secret_service_ensure_session_sync (SecretService *self, GCancellable *cancellable, GError **error) { SecretSync *sync; gboolean ret; g_return_val_if_fail (SECRET_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 = _secret_sync_new (); g_main_context_push_thread_default (sync->context); secret_service_ensure_session (self, cancellable, _secret_sync_on_result, sync); g_main_loop_run (sync->loop); ret = secret_service_ensure_session_finish (self, sync->result, error); g_main_context_pop_thread_default (sync->context); _secret_sync_free (sync); return ret; } static SecretCollection * service_lookup_collection (SecretService *self, const gchar *path) { SecretCollection *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 (SecretService *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); g_object_notify (G_OBJECT (self), "collections"); } typedef struct { 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_hash_table_unref (closure->collections); g_free (closure); } static void on_ensure_collection (GObject *source, GAsyncResult *result, gpointer user_data) { GTask *task = G_TASK (user_data); SecretService *self = SECRET_SERVICE (g_async_result_get_source_object (user_data)); EnsureClosure *closure = g_task_get_task_data (task); SecretCollection *collection; const gchar *path; GError *error = NULL; closure->collections_loading--; collection = secret_collection_new_for_dbus_path_finish (result, &error); if (error != NULL) { g_task_return_error (task, g_steal_pointer (&error)); } else if (collection != NULL) { path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (collection)); g_hash_table_insert (closure->collections, g_strdup (path), collection); if (closure->collections_loading == 0) { service_update_collections (self, closure->collections); g_task_return_boolean (task, TRUE); } } g_object_unref (self); g_object_unref (task); } /** * secret_service_load_collections: * @self: the secret service * @cancellable: (nullable): optional cancellation object * @callback: called when the operation completes * @user_data: data to be passed to the callback * * Ensure that the #SecretService proxy has loaded all the collections present * in the Secret Service. * * This affects the result of [method@Service.get_collections]. * * You can also pass the %SECRET_SERVICE_LOAD_COLLECTIONS to * [func@Service.get_sync] in order to ensure that the collections have been * loaded by the time you get the #SecretService proxy. * * This method will return immediately and complete asynchronously. */ void secret_service_load_collections (SecretService *self, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { EnsureClosure *closure; SecretCollection *collection; GTask *task; const gchar *path; GVariant *paths; GVariantIter iter; g_return_if_fail (SECRET_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); task = g_task_new (self, cancellable, callback, user_data); g_task_set_source_tag (task, secret_service_load_collections); closure = g_new0 (EnsureClosure, 1); closure->collections = collections_table_new (); g_task_set_task_data (task, 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) { secret_collection_new_for_dbus_path (self, path, SECRET_COLLECTION_LOAD_ITEMS, cancellable, on_ensure_collection, g_object_ref (task)); 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_task_return_boolean (task, TRUE); } g_variant_unref (paths); g_object_unref (task); } /** * secret_service_load_collections_finish: * @self: the secret service * @result: the asynchronous result passed to the callback * @error: location to place an error on failure * * Complete an asynchronous operation to ensure that the #SecretService proxy * has loaded all the collections present in the Secret Service. * * Returns: whether the load was successful or not */ gboolean secret_service_load_collections_finish (SecretService *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (SECRET_IS_SERVICE (self), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); g_return_val_if_fail (g_task_is_valid (result, self), FALSE); g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == secret_service_load_collections, FALSE); if (!g_task_propagate_boolean (G_TASK (result), error)) { _secret_util_strip_remote_error (error); return FALSE; } return TRUE; } /** * secret_service_load_collections_sync: * @self: the secret service * @cancellable: (nullable): optional cancellation object * @error: location to place an error on failure * * Ensure that the #SecretService proxy has loaded all the collections present * in the Secret Service. * * This affects the result of [method@Service.get_collections]. * * You can also pass the %SECRET_SERVICE_LOAD_COLLECTIONS to * [func@Service.get_sync] in order to ensure that the collections have been * loaded by the time you get the #SecretService proxy. * * This method may block indefinitely and should not be used in user interface * threads. * * Returns: whether the load was successful or not */ gboolean secret_service_load_collections_sync (SecretService *self, GCancellable *cancellable, GError **error) { SecretCollection *collection; GHashTable *collections; GVariant *paths; GVariantIter iter; const gchar *path; gboolean ret = TRUE; g_return_val_if_fail (SECRET_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 = secret_collection_new_for_dbus_path_sync (self, path, SECRET_COLLECTION_LOAD_ITEMS, 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; } /** * secret_service_prompt_sync: * @self: the secret service * @prompt: the prompt * @cancellable: (nullable): optional cancellation object * @return_type: the variant type of the prompt result * @error: location to place an error on failure * * Perform prompting for a [class@Prompt]. * * Runs a prompt and performs the prompting. Returns a variant result if the * prompt was completed and not dismissed. The type of result depends on the * action the prompt is completing, and is defined in the Secret Service DBus * API specification. * * This function is called by other parts of this library to handle prompts * for the various actions that can require prompting. * * Override the #SecretServiceClass [vfunc@Service.prompt_sync] virtual method * to change the behavior of the prompting. The default behavior is to simply * run [method@Prompt.perform_sync] on the prompt with a %NULL `window_id`. * * Returns: (transfer full): %NULL if the prompt was dismissed or an error occurred, * a variant result if the prompt was successful */ GVariant * secret_service_prompt_sync (SecretService *self, SecretPrompt *prompt, GCancellable *cancellable, const GVariantType *return_type, GError **error) { SecretServiceClass *klass; g_return_val_if_fail (SECRET_IS_SERVICE (self), NULL); g_return_val_if_fail (SECRET_IS_PROMPT (prompt), NULL); g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); klass = SECRET_SERVICE_GET_CLASS (self); g_return_val_if_fail (klass->prompt_sync != NULL, NULL); return (klass->prompt_sync) (self, prompt, cancellable, return_type, error); } /** * secret_service_prompt: * @self: the secret service * @prompt: the prompt * @return_type: (nullable): the variant type of the prompt result * @cancellable: (nullable): optional cancellation object * @callback: called when the operation completes * @user_data: data to be passed to the callback * * Perform prompting for a [class@Prompt]. * * This function is called by other parts of this library to handle prompts * for the various actions that can require prompting. * * Override the #SecretServiceClass [vfunc@Service.prompt_async] virtual method * to change the behavior of the prompting. The default behavior is to simply * run [method@Prompt.perform] on the prompt. */ void secret_service_prompt (SecretService *self, SecretPrompt *prompt, const GVariantType *return_type, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { SecretServiceClass *klass; g_return_if_fail (SECRET_IS_SERVICE (self)); g_return_if_fail (SECRET_IS_PROMPT (prompt)); g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable)); klass = SECRET_SERVICE_GET_CLASS (self); g_return_if_fail (klass->prompt_async != NULL); (klass->prompt_async) (self, prompt, return_type, cancellable, callback, user_data); } /** * secret_service_prompt_finish: * @self: the secret service * @result: the asynchronous result passed to the callback * @error: location to place an error on failure * * Complete asynchronous operation to perform prompting for a [class@Prompt]. * * Returns a variant result if the prompt was completed and not dismissed. The * type of result depends on the action the prompt is completing, and is defined * in the Secret Service DBus API specification. * * Returns: (transfer full): %NULL if the prompt was dismissed or an error occurred, * a variant result if the prompt was successful */ GVariant * secret_service_prompt_finish (SecretService *self, GAsyncResult *result, GError **error) { SecretServiceClass *klass; g_return_val_if_fail (SECRET_IS_SERVICE (self), NULL); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); klass = SECRET_SERVICE_GET_CLASS (self); g_return_val_if_fail (klass->prompt_finish != NULL, NULL); return (klass->prompt_finish) (self, result, error); } /** * secret_service_get_collection_gtype: * @self: the secret service * * Get the GObject type for collections instantiated by this service. * * This will always be either [class@Collection] or derived from it. * * Returns: the gobject type for collections */ GType secret_service_get_collection_gtype (SecretService *self) { SecretServiceClass *klass; GType type; g_return_val_if_fail (SECRET_IS_SERVICE (self), 0); klass = SECRET_SERVICE_GET_CLASS (self); g_return_val_if_fail (klass->get_collection_gtype != NULL, SECRET_TYPE_COLLECTION); type = (klass->get_collection_gtype) (self); g_return_val_if_fail (g_type_is_a (type, SECRET_TYPE_COLLECTION), SECRET_TYPE_COLLECTION); return type; } /** * secret_service_get_item_gtype: * @self: the service * * Get the GObject type for items instantiated by this service. * * This will always be either [class@Item] or derived from it. * * Returns: the gobject type for items */ GType secret_service_get_item_gtype (SecretService *self) { SecretServiceClass *klass; GType type; g_return_val_if_fail (SECRET_IS_SERVICE (self), 0); klass = SECRET_SERVICE_GET_CLASS (self); g_return_val_if_fail (klass->get_item_gtype != NULL, SECRET_TYPE_ITEM); type = (klass->get_item_gtype) (self); g_return_val_if_fail (g_type_is_a (type, SECRET_TYPE_ITEM), SECRET_TYPE_ITEM); return type; }