![]() |
![]() |
![]() |
Libsecret Library Reference Manual | ![]() |
---|---|---|---|---|
Top | Description | Object Hierarchy | Implemented Interfaces | Properties |
#include <secret/secret-unstable.h> SecretService; struct SecretServiceClass; enum SecretServiceFlags; void secret_service_get (SecretServiceFlags flags
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); SecretService * secret_service_get_sync (SecretServiceFlags flags
,GCancellable *cancellable
,GError **error
); SecretService * secret_service_get_finish (GAsyncResult *result
,GError **error
); void secret_service_new (const gchar *service_bus_name
,SecretServiceFlags flags
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); SecretService * secret_service_new_finish (GAsyncResult *result
,GError **error
); SecretService * secret_service_new_sync (const gchar *service_bus_name
,SecretServiceFlags flags
,GCancellable *cancellable
,GError **error
); GList * secret_service_get_collections (SecretService *self
); SecretServiceFlags secret_service_get_flags (SecretService *self
); const gchar * secret_service_get_session_algorithms (SecretService *self
); const gchar * secret_service_get_session_path (SecretService *self
); void secret_service_ensure_session (SecretService *self
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); const gchar * secret_service_ensure_session_finish (SecretService *self
,GAsyncResult *result
,GError **error
); const gchar * secret_service_ensure_session_sync (SecretService *self
,GCancellable *cancellable
,GError **error
); void secret_service_ensure_collections (SecretService *self
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gboolean secret_service_ensure_collections_finish (SecretService *self
,GAsyncResult *result
,GError **error
); gboolean secret_service_ensure_collections_sync (SecretService *self
,GCancellable *cancellable
,GError **error
); void secret_service_search (SecretService *self
,GHashTable *attributes
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gboolean secret_service_search_finish (SecretService *self
,GAsyncResult *result
,GList **unlocked
,GList **locked
,GError **error
); gboolean secret_service_search_sync (SecretService *self
,GHashTable *attributes
,GCancellable *cancellable
,GList **unlocked
,GList **locked
,GError **error
); void secret_service_search_for_paths (SecretService *self
,GHashTable *attributes
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gboolean secret_service_search_for_paths_finish (SecretService *self
,GAsyncResult *result
,gchar ***unlocked
,gchar ***locked
,GError **error
); gboolean secret_service_search_for_paths_sync (SecretService *self
,GHashTable *attributes
,GCancellable *cancellable
,gchar ***unlocked
,gchar ***locked
,GError **error
); void secret_service_get_secrets (SecretService *self
,GList *items
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); GHashTable * secret_service_get_secrets_finish (SecretService *self
,GAsyncResult *result
,GError **error
); GHashTable * secret_service_get_secrets_sync (SecretService *self
,GList *items
,GCancellable *cancellable
,GError **error
); void secret_service_get_secrets_for_paths (SecretService *self
,const gchar **item_paths
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); GHashTable * secret_service_get_secrets_for_paths_finish (SecretService *self
,GAsyncResult *result
,GError **error
); GHashTable * secret_service_get_secrets_for_paths_sync (SecretService *self
,const gchar **item_paths
,GCancellable *cancellable
,GError **error
); void secret_service_get_secret_for_path (SecretService *self
,const gchar *item_path
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); SecretValue * secret_service_get_secret_for_path_finish (SecretService *self
,GAsyncResult *result
,GError **error
); SecretValue * secret_service_get_secret_for_path_sync (SecretService *self
,const gchar *item_path
,GCancellable *cancellable
,GError **error
); void secret_service_lock (SecretService *self
,GList *objects
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gint secret_service_lock_finish (SecretService *self
,GAsyncResult *result
,GList **locked
,GError **error
); gint secret_service_lock_sync (SecretService *self
,GList *objects
,GCancellable *cancellable
,GList **locked
,GError **error
); void secret_service_lock_paths (SecretService *self
,const gchar **paths
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gint secret_service_lock_paths_finish (SecretService *self
,GAsyncResult *result
,gchar ***locked
,GError **error
); gint secret_service_lock_paths_sync (SecretService *self
,const gchar **paths
,GCancellable *cancellable
,gchar ***locked
,GError **error
); void secret_service_unlock (SecretService *self
,GList *objects
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gint secret_service_unlock_finish (SecretService *self
,GAsyncResult *result
,GList **unlocked
,GError **error
); gint secret_service_unlock_sync (SecretService *self
,GList *objects
,GCancellable *cancellable
,GList **unlocked
,GError **error
); void secret_service_unlock_paths (SecretService *self
,const gchar **paths
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gint secret_service_unlock_paths_finish (SecretService *self
,GAsyncResult *result
,gchar ***unlocked
,GError **error
); gint secret_service_unlock_paths_sync (SecretService *self
,const gchar **paths
,GCancellable *cancellable
,gchar ***unlocked
,GError **error
); void secret_service_store (SecretService *self
,const SecretSchema *schema
,const gchar *collection_path
,const gchar *label
,SecretValue *value
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
,...
); void secret_service_storev (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,const gchar *collection_path
,const gchar *label
,SecretValue *value
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gboolean secret_service_store_finish (SecretService *self
,GAsyncResult *result
,GError **error
); gboolean secret_service_store_sync (SecretService *self
,const SecretSchema *schema
,const gchar *collection_path
,const gchar *label
,SecretValue *value
,GCancellable *cancellable
,GError **error
,...
); gboolean secret_service_storev_sync (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,const gchar *collection_path
,const gchar *label
,SecretValue *value
,GCancellable *cancellable
,GError **error
); void secret_service_lookup (SecretService *self
,const SecretSchema *schema
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
,...
); void secret_service_lookupv (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); SecretValue * secret_service_lookup_finish (SecretService *self
,GAsyncResult *result
,GError **error
); SecretValue * secret_service_lookup_sync (SecretService *self
,const SecretSchema *schema
,GCancellable *cancellable
,GError **error
,...
); SecretValue * secret_service_lookupv_sync (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,GCancellable *cancellable
,GError **error
); void secret_service_remove (SecretService *self
,const SecretSchema *schema
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
,...
); void secret_service_removev (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gboolean secret_service_remove_finish (SecretService *self
,GAsyncResult *result
,GError **error
); gboolean secret_service_remove_sync (SecretService *self
,const SecretSchema *schema
,GCancellable *cancellable
,GError **error
,...
); gboolean secret_service_removev_sync (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,GCancellable *cancellable
,GError **error
); void secret_service_prompt (SecretService *self
,SecretPrompt *prompt
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gboolean secret_service_prompt_finish (SecretService *self
,GAsyncResult *result
,GError **error
); gboolean secret_service_prompt_sync (SecretService *self
,SecretPrompt *prompt
,GCancellable *cancellable
,GError **error
); void secret_service_create_collection_path (SecretService *self
,GHashTable *properties
,const gchar *alias
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gchar * secret_service_create_collection_path_finish (SecretService *self
,GAsyncResult *result
,GError **error
); gchar * secret_service_create_collection_path_sync (SecretService *self
,GHashTable *properties
,const gchar *alias
,GCancellable *cancellable
,GError **error
); void secret_service_create_item_path (SecretService *self
,const gchar *collection_path
,GHashTable *properties
,SecretValue *value
,gboolean replace
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gchar * secret_service_create_item_path_finish (SecretService *self
,GAsyncResult *result
,GError **error
); gchar * secret_service_create_item_path_sync (SecretService *self
,const gchar *collection_path
,GHashTable *properties
,SecretValue *value
,gboolean replace
,GCancellable *cancellable
,GError **error
); void secret_service_delete_path (SecretService *self
,const gchar *item_path
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
); gboolean secret_service_delete_path_finish (SecretService *self
,GAsyncResult *result
,GError **error
); gboolean secret_service_delete_path_sync (SecretService *self
,const gchar *item_path
,GCancellable *cancellable
,GError **error
);
"collections" SecretObjectList* : Read "flags" SecretServiceFlags : Read / Write / Construct Only
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 secret_service_get()
method is used to access this SecretService
object. If a new independent SecretService object is required, use
secret_service_new()
.
In order to securely transfer secrets to the Sercret Service, an session
is established. This session can be established while initializing a
SecretService object by passing the SECRET_SERVICE_OPEN_SESSION
flag
to the secret_service_get()
or secret_service_new()
functions. In order to
establish a session on an already existing SecretService, use the
secret_service_ensure_session()
function.
To search for items, use the secret_service_search()
method.
Multiple collections can exist in the Secret Service, each of which contains
secret items. In order to instantiate SecretCollection objects which
represent those collections while initializing a SecretService then pass
the SECRET_SERVICE_LOAD_COLLECTIONS
flag to the secret_service_get()
or
secret_service_new()
functions. In order to establish a session on an already
existing SecretService, use the secret_service_ensure_collections()
function.
To access the list of collections use secret_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 SecretPrompt object is created by this library, and
passed to the secret_service_prompt()
method. In this way it is handled
automatically.
In order to customize prompt handling, override the prompt_async
and prompt_finish
virtual methods of the SecretService class.
stability
: Unstable
typedef struct _SecretService SecretService;
A proxy object representing the Secret Service.
struct SecretServiceClass { GDBusProxyClass parent_class; GType collection_gtype; GType item_gtype; gboolean (*prompt_sync) (SecretService *self, SecretPrompt *prompt, GCancellable *cancellable, GError **error); void (*prompt_async) (SecretService *self, SecretPrompt *prompt, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean (*prompt_finish) (SecretService *self, GAsyncResult *result, GError **error); };
The class for SecretService.
GDBusProxyClass |
the parent class |
GType |
the GType of the SecretCollection objects instantiated by the SecretService proxy |
GType |
the GType of the SecretItem objects instantiated by the SecretService proxy |
called to perform synchronous prompting when necessary | |
called to perform asynchronous prompting when necessary | |
called to complete an asynchronous prompt operation |
typedef enum { SECRET_SERVICE_NONE, SECRET_SERVICE_OPEN_SESSION = 1 << 1, SECRET_SERVICE_LOAD_COLLECTIONS = 1 << 2, } SecretServiceFlags;
Flags which determine which parts of the SecretService proxy are initialized
during a secret_service_get()
or secret_service_new()
operation.
no flags for initializing the SecretService | |
establish a session for transfer of secrets while initializing the SecretService | |
load collections while initializing the SecretService |
void secret_service_get (SecretServiceFlags flags
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
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.
|
flags for which service functionality to ensure is initialized |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
SecretService * secret_service_get_sync (SecretServiceFlags flags
,GCancellable *cancellable
,GError **error
);
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.
|
flags for which service functionality to ensure is initialized |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
a new reference to a SecretService proxy, which
should be released with g_object_unref() . [transfer full]
|
SecretService * secret_service_get_finish (GAsyncResult *result
,GError **error
);
Complete an asynchronous operation to get a SecretService proxy for the Secret Service.
|
the asynchronous result passed to the callback |
|
location to place an error on failure |
Returns : |
a new reference to a SecretService proxy, which
should be released with g_object_unref() . [transfer full]
|
void secret_service_new (const gchar *service_bus_name
,SecretServiceFlags flags
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Create a new SecretService proxy for the Secret Service.
This function is rarely used, see secret_service_get()
instead.
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.
|
the D-Bus service name of the secret service. [allow-none] |
|
flags for which service functionality to ensure is initialized |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
SecretService * secret_service_new_finish (GAsyncResult *result
,GError **error
);
Complete an asynchronous operation to create a new SecretService proxy for the Secret Service.
|
the asynchronous result passed to the callback |
|
location to place an error on failure |
Returns : |
a new reference to a SecretService proxy, which
should be released with g_object_unref() . [transfer full]
|
SecretService * secret_service_new_sync (const gchar *service_bus_name
,SecretServiceFlags flags
,GCancellable *cancellable
,GError **error
);
Create a new SecretService proxy for the Secret Service.
This function is rarely used, see secret_service_get_sync()
instead.
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.
|
the D-Bus service name of the secret service. [allow-none] |
|
flags for which service functionality to ensure is initialized |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
a new reference to a SecretService proxy, which
should be released with g_object_unref() . [transfer full]
|
GList * secret_service_get_collections (SecretService *self
);
Get a list of SecretCollection 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 secret_service_ensure_collections()
to load the collections.
|
the secret service proxy |
Returns : |
a list of the collections in the secret service. [transfer full][element-type Secret.Collection][allow-none] |
SecretServiceFlags secret_service_get_flags (SecretService *self
);
Get the flags representing what features of the SecretService proxy have been initialized.
Use secret_service_ensure_session()
or secret_service_ensure_collections()
to initialize further features and change the flags.
|
the secret service proxy |
Returns : |
the flags for features initialized |
const gchar * secret_service_get_session_algorithms
(SecretService *self
);
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
secret_service_ensure_session()
to establish a session.
|
the secret service proxy |
Returns : |
a string representing the algorithms for transferring secrets. [allow-none] |
const gchar * secret_service_get_session_path (SecretService *self
);
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
secret_service_ensure_session()
to establish a session.
|
the secret service proxy |
Returns : |
a string representing the D-Bus object path of the session. [allow-none] |
void secret_service_ensure_session (SecretService *self
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
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 secret_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.
|
the secret service |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
const gchar * secret_service_ensure_session_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Finish an asynchronous operation to ensure that the SecretService proxy has established a session with the Secret Service.
|
the secret service |
|
the asynchronous result passed to the callback |
|
location to place an error on failure |
Returns : |
the path of the established session |
const gchar * secret_service_ensure_session_sync (SecretService *self
,GCancellable *cancellable
,GError **error
);
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 secret_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.
|
the secret service |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
the path of the established session |
void secret_service_ensure_collections (SecretService *self
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Ensure that the SecretService proxy has loaded all the collections present
in the Secret Service. This affects the result of
secret_service_get_collections()
.
You can also pass the SECRET_SERVICE_LOAD_COLLECTIONS
to
secret_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.
|
the secret service |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
gboolean secret_service_ensure_collections_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Complete an asynchronous operation to ensure that the SecretService proxy has loaded all the collections present in the Secret Service.
|
the secret service |
|
the asynchronous result passed to the callback |
|
location to place an error on failure |
Returns : |
whether the load was successful or not |
gboolean secret_service_ensure_collections_sync (SecretService *self
,GCancellable *cancellable
,GError **error
);
Ensure that the SecretService proxy has loaded all the collections present
in the Secret Service. This affects the result of
secret_service_get_collections()
.
You can also pass the SECRET_SERVICE_LOAD_COLLECTIONS
to
secret_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.
|
the secret service |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
whether the load was successful or not |
void secret_service_search (SecretService *self
,GHashTable *attributes
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Search for items matching the attributes
. All collections are searched.
The attributes
should be a table of string keys and string values.
This function returns immediately and completes asynchronously.
When your callback is called use secret_service_search_finish()
to get the results of this function. SecretItem proxy objects will be
returned. If you prefer to only have the items D-Bus object paths returned,
then then use the secret_service_search_for_paths()
function.
|
the secret service |
|
search for items matching these attributes. [element-type utf8 utf8] |
|
optional cancellation object |
|
called when the operation completes |
|
data to pass to the callback |
gboolean secret_service_search_finish (SecretService *self
,GAsyncResult *result
,GList **unlocked
,GList **locked
,GError **error
);
Complete asynchronous operation to search for items.
Matching items that are locked or unlocked are placed in the locked
or
unlocked
lists respectively.
SecretItem proxy objects will be returned. If you prefer to only have
the items' D-Bus object paths returned, then then use the
secret_service_search_for_paths()
function.
|
the secret service |
|
asynchronous result passed to callback |
|
location to place a list of matching items which were not locked. [out][transfer full][element-type Secret.Item][allow-none] |
|
location to place a list of matching items which were locked. [out][transfer full][element-type Secret.Item][allow-none] |
|
location to place error on failure |
Returns : |
whether the search was successful or not |
gboolean secret_service_search_sync (SecretService *self
,GHashTable *attributes
,GCancellable *cancellable
,GList **unlocked
,GList **locked
,GError **error
);
Search for items matching the attributes
. All collections are searched.
The attributes
should be a table of string keys and string values.
This function may block indefinetely. Use the asynchronous version in user interface threads.
Matching items that are locked or unlocked are placed
in the locked
or unlocked
lists respectively.
SecretItem proxy objects will be returned. If you prefer to only have
the items' D-Bus object paths returned, then then use the
secret_service_search_sync()
function.
|
the secret service |
|
search for items matching these attributes. [element-type utf8 utf8] |
|
optional cancellation object |
|
location to place a list of matching items which were not locked. [out][transfer full][element-type Secret.Item][allow-none] |
|
location to place a list of matching items which were locked. [out][transfer full][element-type Secret.Item][allow-none] |
|
location to place error on failure |
Returns : |
whether the search was successful or not |
void secret_service_search_for_paths (SecretService *self
,GHashTable *attributes
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Search for items matching the attributes
, and return their D-Bus object paths.
All collections are searched. The attributes
should be a table of string keys
and string values.
This function returns immediately and completes asynchronously.
When your callback is called use secret_service_search_for_paths_finish()
to get the results of this function. Only the D-Bus object paths of the
items will be returned. If you would like SecretItem objects to be returned
instead, then use the secret_service_search()
function.
|
the secret service |
|
search for items matching these attributes. [element-type utf8 utf8] |
|
optional cancellation object |
|
called when the operation completes |
|
data to pass to the callback |
gboolean secret_service_search_for_paths_finish (SecretService *self
,GAsyncResult *result
,gchar ***unlocked
,gchar ***locked
,GError **error
);
Complete asynchronous operation to search for items, and return their D-Bus object paths.
Matching items that are locked or unlocked, have their D-Bus paths placed
in the locked
or unlocked
arrays respectively.
D-Bus object paths of the items will be returned in the unlocked
or
locked
arrays. If you would to have SecretItem objects to be returned
instead, then us the secret_service_search()
and
secret_service_search_finish()
functions.
|
the secret service |
|
asynchronous result passed to callback |
|
location to place an array of D-Bus object paths for matching items which were locked. [out][transfer full][array zero-terminated=1][allow-none] |
|
location to place an array of D-Bus object paths for matching items which were locked. [out][transfer full][array zero-terminated=1][allow-none] |
|
location to place error on failure |
Returns : |
whether the search was successful or not |
gboolean secret_service_search_for_paths_sync (SecretService *self
,GHashTable *attributes
,GCancellable *cancellable
,gchar ***unlocked
,gchar ***locked
,GError **error
);
Search for items matching the attributes
, and return their D-Bus object
paths. All collections are searched. The attributes
should be a table of
string keys and string values.
This function may block indefinetely. Use the asynchronous version in user interface threads.
Matching items that are locked or unlocked, have their D-Bus paths placed
in the locked
or unlocked
arrays respectively.
D-Bus object paths of the items will be returned in the unlocked
or
locked
arrays. If you would to have SecretItem objects to be returned
instead, then use the secret_service_search_sync()
function.
|
the secret service |
|
search for items matching these attributes. [element-type utf8 utf8] |
|
optional cancellation object |
|
location to place an array of D-Bus object paths for matching items which were locked. [out][transfer full][array zero-terminated=1][allow-none] |
|
location to place an array of D-Bus object paths for matching items which were locked. [out][transfer full][array zero-terminated=1][allow-none] |
|
location to place error on failure |
Returns : |
whether the search was successful or not |
void secret_service_get_secrets (SecretService *self
,GList *items
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Get the secret values for an secret items stored in the service.
This method takes a list of SecretItem proxy objects. If you only have the
D-Bus object paths of the items, use secret_service_get_secrets_for_paths()
instead.
This function returns immediately and completes asynchronously.
|
the secret service |
|
the items to retrieve secrets for. [element-type Secret.Item] |
|
optional cancellation object |
|
called when the operation completes |
|
data to pass to the callback |
GHashTable * secret_service_get_secrets_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Complete asynchronous operation to get the secret values for an secret items stored in the service.
Items that are locked will not be included the results.
|
the secret service |
|
asynchronous result passed to callback |
|
location to place an error on failure |
Returns : |
a newly allocated hash table of SecretItem keys to SecretValue values. [transfer full] |
GHashTable * secret_service_get_secrets_sync (SecretService *self
,GList *items
,GCancellable *cancellable
,GError **error
);
Get the secret values for an secret items stored in the service.
This method takes a list of SecretItem proxy objects. If you only have the
D-Bus object paths of the items, use secret_service_get_secrets_for_paths_sync()
instead.
This method may block indefinitely and should not be used in user interface threads.
Items that are locked will not be included the results.
|
the secret service |
|
the items to retrieve secrets for. [element-type Secret.Item] |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
a newly allocated hash table of SecretItem keys to SecretValue values. [transfer full] |
void secret_service_get_secrets_for_paths (SecretService *self
,const gchar **item_paths
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Get the secret values for an secret items stored in the service.
The items are represented by their D-Bus object paths. If you already have
SecretItem proxy objects, use use secret_service_get_secrets()
to more simply
get their secret values.
This function returns immediately and completes asynchronously.
|
the secret service |
|
the D-Bus paths to items to retrieve secrets for |
|
optional cancellation object |
|
called when the operation completes |
|
data to pass to the callback |
GHashTable * secret_service_get_secrets_for_paths_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Complete asynchronous operation to get the secret values for an secret items stored in the service.
Items that are locked will not be included the results.
|
the secret service |
|
asynchronous result passed to callback |
|
location to place an error on failure |
Returns : |
a newly allocated hash table of item_path keys to SecretValue values. [transfer full] |
GHashTable * secret_service_get_secrets_for_paths_sync (SecretService *self
,const gchar **item_paths
,GCancellable *cancellable
,GError **error
);
Get the secret values for an secret items stored in the service.
The items are represented by their D-Bus object paths. If you already have
SecretItem proxy objects, use use secret_service_get_secrets_sync()
to more
simply get their secret values.
This method may block indefinitely and should not be used in user interface threads.
Items that are locked will not be included the results.
|
the secret service |
|
the D-Bus paths to items to retrieve secrets for |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
a newly allocated hash table of item_path keys to SecretValue values. [transfer full] |
void secret_service_get_secret_for_path (SecretService *self
,const gchar *item_path
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Get the secret value for an secret item stored in the service.
The item is represented by its D-Bus object path. If you already have a
SecretItem proxy object, use use secret_item_get_secret()
to more simply
get its secret value.
This function returns immediately and completes asynchronously.
|
the secret service |
|
the D-Bus path to item to retrieve secret for |
|
optional cancellation object |
|
called when the operation completes |
|
data to pass to the callback |
SecretValue * secret_service_get_secret_for_path_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Complete asynchronous operation to get the secret value for an secret item stored in the service.
Will return NULL
if the item is locked.
|
the secret service |
|
asynchronous result passed to callback |
|
location to place an error on failure |
Returns : |
the newly allocated secret value
for the item, which should be released with secret_value_unref() . [transfer full][allow-none]
|
SecretValue * secret_service_get_secret_for_path_sync (SecretService *self
,const gchar *item_path
,GCancellable *cancellable
,GError **error
);
Get the secret value for an secret item stored in the service.
The item is represented by its D-Bus object path. If you already have a
SecretItem proxy object, use use secret_item_get_secret_sync()
to more simply
get its secret value.
This method may block indefinitely and should not be used in user interface threads.
Will return NULL
if the item is locked.
|
the secret service |
|
the D-Bus path to item to retrieve secret for |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
the newly allocated secret value
for the item, which should be released with secret_value_unref() . [transfer full][allow-none]
|
void secret_service_lock (SecretService *self
,GList *objects
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Lock items or collections in the secret service.
This method takes a list of SecretItem or SecretCollection proxy objects.
If you only have the D-Bus object paths of the items or collections, use
secret_service_lock_paths()
instead.
The secret service may not be able to lock items individually, and may lock an entire collection instead.
This method returns immediately and completes asynchronously. The secret
service may prompt the user. secret_service_prompt()
will be used to handle
any prompts that show up.
|
the secret service |
|
the items or collections to lock. [element-type GLib.DBusProxy] |
|
optional cancellation object |
|
called when the operation completes |
|
data to pass to the callback |
gint secret_service_lock_finish (SecretService *self
,GAsyncResult *result
,GList **locked
,GError **error
);
Complete asynchronous operation to lock items or collections in the secret service.
The secret service may not be able to lock items individually, and may lock an entire collection instead.
|
the secret service |
|
asynchronous result passed to the callback |
|
location to place list of items or collections that were locked. [out][element-type GLib.DBusProxy][transfer full][allow-none] |
|
location to place an error on failure |
Returns : |
the number of items or collections that were locked |
gint secret_service_lock_sync (SecretService *self
,GList *objects
,GCancellable *cancellable
,GList **locked
,GError **error
);
Lock items or collections in the secret service.
This method takes a list of SecretItem or SecretCollection proxy objects.
If you only have the D-Bus object paths of the items or collections, use
secret_service_lock_paths_sync()
instead.
The secret service may not be able to lock items individually, and may lock an entire collection instead.
This method may block indefinitely and should not be used in user
interface threads. The secret service may prompt the user.
secret_service_prompt()
will be used to handle any prompts that show up.
|
the secret service |
|
the items or collections to lock. [element-type GLib.DBusProxy] |
|
optional cancellation object |
|
location to place list of items or collections that were locked. [out][element-type GLib.DBusProxy][transfer full][allow-none] |
|
location to place an error on failure |
Returns : |
the number of items or collections that were locked |
void secret_service_lock_paths (SecretService *self
,const gchar **paths
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Lock items or collections in the secret service.
The items or collections are represented by their D-Bus object paths. If you
already have SecretItem and SecretCollection proxy objects, use use
secret_service_lock()
instead.
The secret service may not be able to lock items individually, and may lock an entire collection instead.
This method returns immediately and completes asynchronously. The secret
service may prompt the user. secret_service_prompt()
will be used to handle
any prompts that show up.
|
the secret service |
|
the D-Bus paths for items or collections to lock |
|
optional cancellation object |
|
called when the operation completes |
|
data to pass to the callback |
gint secret_service_lock_paths_finish (SecretService *self
,GAsyncResult *result
,gchar ***locked
,GError **error
);
Complete asynchronous operation to lock items or collections in the secret service.
The secret service may not be able to lock items individually, and may lock an entire collection instead.
|
the secret service |
|
asynchronous result passed to the callback |
|
location to place array of D-Bus paths of items or collections that were locked. [out][array zero-terminated=1][transfer full][allow-none] |
|
location to place an error on failure |
Returns : |
the number of items or collections that were locked |
gint secret_service_lock_paths_sync (SecretService *self
,const gchar **paths
,GCancellable *cancellable
,gchar ***locked
,GError **error
);
Lock items or collections in the secret service.
The items or collections are represented by their D-Bus object paths. If you
already have SecretItem and SecretCollection proxy objects, use use
secret_service_lock_sync()
instead.
The secret service may not be able to lock items individually, and may lock an entire collection instead.
This method may block indefinitely and should not be used in user
interface threads. The secret service may prompt the user.
secret_service_prompt()
will be used to handle any prompts that show up.
|
the secret service |
|
the D-Bus object paths of the items or collections to lock |
|
optional cancellation object |
|
location to place array of D-Bus paths of items or collections that were locked. [out][array zero-terminated=1][transfer full][allow-none] |
|
location to place an error on failure |
Returns : |
the number of items or collections that were locked |
void secret_service_unlock (SecretService *self
,GList *objects
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Unlock items or collections in the secret service.
This method takes a list of SecretItem or SecretCollection proxy objects.
If you only have the D-Bus object paths of the items or collections, use
secret_service_unlock_paths()
instead.
The secret service may not be able to unlock items individually, and may unlock an entire collection instead.
This method may block indefinitely and should not be used in user
interface threads. The secret service may prompt the user.
secret_service_prompt()
will be used to handle any prompts that show up.
|
the secret service |
|
the items or collections to unlock. [element-type GLib.DBusProxy] |
|
optional cancellation object |
|
called when the operation completes |
|
data to pass to the callback |
gint secret_service_unlock_finish (SecretService *self
,GAsyncResult *result
,GList **unlocked
,GError **error
);
Complete asynchronous operation to unlock items or collections in the secret service.
The secret service may not be able to unlock items individually, and may unlock an entire collection instead.
|
the secret service |
|
asynchronous result passed to the callback |
|
location to place list of items or collections that were unlocked. [out][element-type GLib.DBusProxy][transfer full][allow-none] |
|
location to place an error on failure |
Returns : |
the number of items or collections that were unlocked |
gint secret_service_unlock_sync (SecretService *self
,GList *objects
,GCancellable *cancellable
,GList **unlocked
,GError **error
);
Unlock items or collections in the secret service.
This method takes a list of SecretItem or SecretCollection proxy objects.
If you only have the D-Bus object paths of the items or collections, use
secret_service_unlock_paths_sync()
instead.
The secret service may not be able to unlock items individually, and may unlock an entire collection instead.
This method may block indefinitely and should not be used in user
interface threads. The secret service may prompt the user.
secret_service_prompt()
will be used to handle any prompts that show up.
|
the secret service |
|
the items or collections to unlock. [element-type GLib.DBusProxy] |
|
optional cancellation object |
|
location to place list of items or collections that were unlocked. [out][element-type GLib.DBusProxy][transfer full][allow-none] |
|
location to place an error on failure |
Returns : |
the number of items or collections that were unlocked |
void secret_service_unlock_paths (SecretService *self
,const gchar **paths
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Unlock items or collections in the secret service.
The items or collections are represented by their D-Bus object paths. If you
already have SecretItem and SecretCollection proxy objects, use use
secret_service_unlock()
instead.
The secret service may not be able to unlock items individually, and may unlock an entire collection instead.
This method returns immediately and completes asynchronously. The secret
service may prompt the user. secret_service_prompt()
will be used to handle
any prompts that show up.
|
the secret service |
|
the D-Bus paths for items or collections to unlock |
|
optional cancellation object |
|
called when the operation completes |
|
data to pass to the callback |
gint secret_service_unlock_paths_finish (SecretService *self
,GAsyncResult *result
,gchar ***unlocked
,GError **error
);
Complete asynchronous operation to unlock items or collections in the secret service.
The secret service may not be able to unlock items individually, and may unlock an entire collection instead.
|
the secret service |
|
asynchronous result passed to the callback |
|
location to place array of D-Bus paths of items or collections that were unlocked. [out][array zero-terminated=1][transfer full][allow-none] |
|
location to place an error on failure |
Returns : |
the number of items or collections that were unlocked |
gint secret_service_unlock_paths_sync (SecretService *self
,const gchar **paths
,GCancellable *cancellable
,gchar ***unlocked
,GError **error
);
Unlock items or collections in the secret service.
The items or collections are represented by their D-Bus object paths. If you
already have SecretItem and SecretCollection proxy objects, use use
secret_service_unlock_sync()
instead.
The secret service may not be able to unlock items individually, and may unlock an entire collection instead.
This method may block indefinitely and should not be used in user
interface threads. The secret service may prompt the user.
secret_service_prompt()
will be used to handle any prompts that show up.
|
the secret service |
|
the D-Bus object paths of the items or collections to unlock |
|
optional cancellation object |
|
location to place array of D-Bus paths of items or collections that were unlocked. [out][array zero-terminated=1][transfer full][allow-none] |
|
location to place an error on failure |
Returns : |
the number of items or collections that were unlocked |
void secret_service_store (SecretService *self
,const SecretSchema *schema
,const gchar *collection_path
,const gchar *label
,SecretValue *value
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
,...
);
Store a secret value in the secret service.
The variable argument list should contain pairs of a) The attribute name as
a null-terminated string, followed by b) attribute value, either a character
string, an int number, or a gboolean value, as defined in the password
schema
. The list of attribtues should be terminated with a NULL
.
If the attributes match a secret item already stored in the collection, then the item will be updated with these new values.
If collection_path
is not specified, then the default collection will be
used. Use SECRET_COLLECTION_SESSION to store the password in the session
collection, which doesn't get stored across login sessions.
This method will return immediately and complete asynchronously.
|
the secret service |
|
the schema for the attributes |
|
the D-Bus path to the collection where to store the secret. [allow-none] |
|
label for the secret |
|
the secret value |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
|
the attribute keys and values, terminated with NULL
|
void secret_service_storev (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,const gchar *collection_path
,const gchar *label
,SecretValue *value
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Store a secret value in the secret service.
The attributes
should be a set of key and value string pairs.
If the attributes match a secret item already stored in the collection, then the item will be updated with these new values.
If collection_path
is not specified, then the default collection will be
used. Use SECRET_COLLECTION_SESSION to store the password in the session
collection, which doesn't get stored across login sessions.
This method will return immediately and complete asynchronously.
|
the secret service |
|
the schema to use to check attributes. [allow-none] |
|
the attribute keys and values. [element-type utf8 utf8] |
|
the D-Bus path to the collection where to store the secret. [allow-none] |
|
label for the secret |
|
the secret value |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
gboolean secret_service_store_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Finish asynchronous operation to store a password in the secret service.
|
the secret service |
|
the asynchronous result passed to the callback |
|
location to place an error on failure |
Returns : |
whether the storage was successful or not |
gboolean secret_service_store_sync (SecretService *self
,const SecretSchema *schema
,const gchar *collection_path
,const gchar *label
,SecretValue *value
,GCancellable *cancellable
,GError **error
,...
);
Store a secret value in the secret service.
The variable argument list should contain pairs of a) The attribute name as
a null-terminated string, followed by b) attribute value, either a character
string, an int number, or a gboolean value, as defined in the password
schema
. The list of attribtues should be terminated with a NULL
.
If the attributes match a secret item already stored in the collection, then the item will be updated with these new values.
If collection_path
is NULL
, then the default collection will be
used. Use SECRET_COLLECTION_SESSION to store the password in the session
collection, which doesn't get stored across login sessions.
This method may block indefinitely and should not be used in user interface threads.
|
the secret service |
|
the schema for the attributes |
|
the D-Bus path to the collection where to store the secret. [allow-none] |
|
label for the secret |
|
the secret value |
|
optional cancellation object |
|
location to place an error on failure |
|
the attribute keys and values, terminated with NULL
|
Returns : |
whether the storage was successful or not |
gboolean secret_service_storev_sync (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,const gchar *collection_path
,const gchar *label
,SecretValue *value
,GCancellable *cancellable
,GError **error
);
Store a secret value in the secret service.
The attributes
should be a set of key and value string pairs.
If the attributes match a secret item already stored in the collection, then the item will be updated with these new values.
If collection_path
is NULL
, then the default collection will be
used. Use SECRET_COLLECTION_SESSION to store the password in the session
collection, which doesn't get stored across login sessions.
This method may block indefinitely and should not be used in user interface threads.
|
the secret service |
|
the schema for the attributes. [allow-none] |
|
the attribute keys and values. [element-type utf8 utf8] |
|
the D-Bus path to the collection where to store the secret. [allow-none] |
|
label for the secret |
|
the secret value |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
whether the storage was successful or not |
void secret_service_lookup (SecretService *self
,const SecretSchema *schema
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
,...
);
Lookup a secret value in the secret service.
The variable argument list should contain pairs of a) The attribute name as
a null-terminated string, followed by b) attribute value, either a character
string, an int number, or a gboolean value, as defined in the password
schema
. The list of attribtues should be terminated with a NULL
.
This method will return immediately and complete asynchronously.
|
the secret service |
|
the schema for the attributes |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
|
the attribute keys and values, terminated with NULL
|
void secret_service_lookupv (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Lookup a secret value in the secret service.
The attributes
should be a set of key and value string pairs.
This method will return immediately and complete asynchronously.
|
the secret service |
|
the schema for the attributes. [allow-none] |
|
the attribute keys and values. [element-type utf8 utf8] |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
SecretValue * secret_service_lookup_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Finish asynchronous operation to lookup a secret value in the secret service.
If no secret is found then NULL
is returned.
|
the secret service |
|
the asynchronous result passed to the callback |
|
location to place an error on failure |
Returns : |
a newly allocated SecretValue, which should be
released with secret_value_unref() , or NULL if no secret found. [transfer full]
|
SecretValue * secret_service_lookup_sync (SecretService *self
,const SecretSchema *schema
,GCancellable *cancellable
,GError **error
,...
);
Lookup a secret value in the secret service.
The variable argument list should contain pairs of a) The attribute name as
a null-terminated string, followed by b) attribute value, either a character
string, an int number, or a gboolean value, as defined in the password
schema
. The list of attribtues should be terminated with a NULL
.
If no secret is found then NULL
is returned.
This method may block indefinitely and should not be used in user interface threads.
|
the secret service |
|
the schema for the attributes |
|
optional cancellation object |
|
location to place an error on failure |
|
the attribute keys and values, terminated with NULL
|
Returns : |
a newly allocated SecretValue, which should be
released with secret_value_unref() , or NULL if no secret found. [transfer full]
|
SecretValue * secret_service_lookupv_sync (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,GCancellable *cancellable
,GError **error
);
Lookup a secret value in the secret service.
The attributes
should be a set of key and value string pairs.
This method may block indefinitely and should not be used in user interface threads.
|
the secret service |
|
the schema for the attributes. [allow-none] |
|
the attribute keys and values. [element-type utf8 utf8] |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
a newly allocated SecretValue, which should be
released with secret_value_unref() , or NULL if no secret found. [transfer full]
|
void secret_service_remove (SecretService *self
,const SecretSchema *schema
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
,...
);
Remove a secret value from the secret service.
The variable argument list should contain pairs of a) The attribute name as
a null-terminated string, followed by b) attribute value, either a character
string, an int number, or a gboolean value, as defined in the password
schema
. The list of attribtues should be terminated with a NULL
.
If multiple items match the attributes, then only one will be deleted.
This method will return immediately and complete asynchronously.
|
the secret service |
|
the schema for the attributes |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
|
the attribute keys and values, terminated with NULL
|
void secret_service_removev (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Remove a secret value from the secret service.
The attributes
should be a set of key and value string pairs.
If multiple items match the attributes, then only one will be deleted.
This method will return immediately and complete asynchronously.
|
the secret service |
|
the schema for the attributes. [allow-none] |
|
the attribute keys and values. [element-type utf8 utf8] |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
gboolean secret_service_remove_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Finish asynchronous operation to remove a secret value from the secret service.
|
the secret service |
|
the asynchronous result passed to the callback |
|
location to place an error on failure |
Returns : |
whether the removal was successful or not |
gboolean secret_service_remove_sync (SecretService *self
,const SecretSchema *schema
,GCancellable *cancellable
,GError **error
,...
);
Remove a secret value from the secret service.
The variable argument list should contain pairs of a) The attribute name as
a null-terminated string, followed by b) attribute value, either a character
string, an int number, or a gboolean value, as defined in the password
schema
. The list of attribtues should be terminated with a NULL
.
If multiple items match the attributes, then only one will be deleted.
This method may block indefinitely and should not be used in user interface threads.
|
the secret service |
|
the schema for the attributes |
|
optional cancellation object |
|
location to place an error on failure |
|
the attribute keys and values, terminated with NULL
|
Returns : |
whether the removal was successful or not |
gboolean secret_service_removev_sync (SecretService *self
,const SecretSchema *schema
,GHashTable *attributes
,GCancellable *cancellable
,GError **error
);
Remove a secret value from the secret service.
The attributes
should be a set of key and value string pairs.
If multiple items match the attributes, then only one will be deleted.
This method may block indefinitely and should not be used in user interface threads.
|
the secret service |
|
the schema for the attributes. [allow-none] |
|
the attribute keys and values. [element-type utf8 utf8] |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
whether the removal was successful or not |
void secret_service_prompt (SecretService *self
,SecretPrompt *prompt
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Perform prompting for a SecretPrompt.
This function is called by other parts of this library to handle prompts for the various actions that can require prompting.
Override the SecretServiceClass prompt_async
virtual method
to change the behavior of the propmting. The default behavior is to simply
run secret_prompt_perform()
on the prompt.
|
the secret service |
|
the prompt |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
gboolean secret_service_prompt_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Complete asynchronous operation to perform prompting for a SecretPrompt.
|
the secret service |
|
the asynchronous result passed to the callback |
|
location to place an error on failure |
Returns : |
FALSE if the prompt was dismissed or an error occurred |
gboolean secret_service_prompt_sync (SecretService *self
,SecretPrompt *prompt
,GCancellable *cancellable
,GError **error
);
Perform prompting for a SecretPrompt.
This function is called by other parts of this library to handle prompts for the various actions that can require prompting.
Override the SecretServiceClass prompt_sync
virtual method
to change the behavior of the propmting. The default behavior is to simply
run secret_prompt_perform_sync()
on the prompt.
|
the secret service |
|
the prompt |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
FALSE if the prompt was dismissed or an error occurred |
void secret_service_create_collection_path (SecretService *self
,GHashTable *properties
,const gchar *alias
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Create a new collection in the secret service, and return its path.
Using this method requires that you setup a correct hash table of D-Bus
properties for the new collection. You may prefer to use
secret_collection_create()
which does handles this for you.
An alias
is a well-known tag for a collection, such as 'default' (ie: the
default collection to store items in). This allows other applications to
easily identify and share a collection. If a collection with the alias
already exists, then instead of creating a new collection, the existing
collection will be returned. If no collection with this alias exists, then a
new collection will be created and this alias will be assigned to it.
properties
is a set of properties for the new collection. The keys in the
hash table should be interface.property strings like
org.freedesktop.Secret.Collection.Label
. The values
in the hash table should be GVariant values of the properties.
If you wish to have a
This method will return immediately and complete asynchronously. The secret
service may prompt the user. secret_service_prompt()
will be used to handle
any prompts that are required.
|
a secret service object |
|
hash table of properties for the new collection. [element-type utf8 GLib.Variant] |
|
an alias to check for before creating the new collection, or to assign to the new collection. [allow-none] |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
gchar * secret_service_create_collection_path_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Finish asynchronous operation to create a new collection in the secret service.
|
a secret service object |
|
the asynchronous result passed to the callback |
|
location to place an error on failure |
Returns : |
a new string containing the D-Bus object path of the collection. [transfer full] |
gchar * secret_service_create_collection_path_sync (SecretService *self
,GHashTable *properties
,const gchar *alias
,GCancellable *cancellable
,GError **error
);
Create a new collection in the secret service and return its path.
Using this method requires that you setup a correct hash table of D-Bus
properties for the new collection. You may prefer to use
secret_collection_create()
which does handles this for you.
An alias
is a well-known tag for a collection, such as 'default' (ie: the
default collection to store items in). This allows other applications to
easily identify and share a collection. If a collection with the alias
already exists, then instead of creating a new collection, the existing
collection will be returned. If no collection with this alias exists, then
a new collection will be created and this alias will be assigned to it.
properties
is a set of properties for the new collection. The keys in the
hash table should be interface.property strings like
org.freedesktop.Secret.Collection.Label
. The values
in the hash table should be GVariant values of the properties.
This method may block indefinitely and should not be used in user interface
threads. The secret service may prompt the user. secret_service_prompt()
will be used to handle any prompts that are required.
|
a secret service object |
|
hash table of D-Bus properties for the new collection. [element-type utf8 GLib.Variant] |
|
an alias to check for before creating the new collection, or to assign to the new collection. [allow-none] |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
a new string containing the D-Bus object path of the collection. [transfer full] |
void secret_service_create_item_path (SecretService *self
,const gchar *collection_path
,GHashTable *properties
,SecretValue *value
,gboolean replace
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Create a new item in a secret service collection and return its D-Bus object path.
It is often easier to use secret_password_store()
or secret_item_create()
rather than using this function. Using this method requires that you setup
a correct hash table of D-Bus properties
for the new collection.
If replace
is set to TRUE
, and an item already in the collection matches
the attributes (specified in properties
) then the item will be updated
instead of creating a new item.
properties
is a set of properties for the new collection. The keys in the
hash table should be interface.property strings like
org.freedesktop.Secret.Item.Label
. The values
in the hash table should be GVariant values of the properties.
If collection_path
is NULL
, then the default collection will be
used. Use SECRET_COLLECTION_SESSION to store the password in the session
collection, which doesn't get stored across login sessions.
This method will return immediately and complete asynchronously. The secret
service may prompt the user. secret_service_prompt()
will be used to handle
any prompts that are required.
|
a secret service object |
|
the D-Bus object path of the collection in which to create item. [allow-none] |
|
hash table of D-Bus properties for the new collection. [element-type utf8 GLib.Variant] |
|
the secret value to store in the item |
|
whether to replace an item with the matching attributes |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
gchar * secret_service_create_item_path_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Finish asynchronous operation to create a new item in the secret service.
|
a secret service object |
|
the asynchronous result passed to the callback |
|
location to place an error on failure |
Returns : |
a new string containing the D-Bus object path of the item. [transfer full] |
gchar * secret_service_create_item_path_sync (SecretService *self
,const gchar *collection_path
,GHashTable *properties
,SecretValue *value
,gboolean replace
,GCancellable *cancellable
,GError **error
);
Create a new item in a secret service collection and return its D-Bus object path.
It is often easier to use secret_password_store_sync()
or secret_item_create_sync()
rather than using this function. Using this method requires that you setup
a correct hash table of D-Bus properties
for the new collection.
If replace
is set to TRUE
, and an item already in the collection matches
the attributes (specified in properties
) then the item will be updated
instead of creating a new item.
properties
is a set of properties for the new collection. The keys in the
hash table should be interface.property strings like
org.freedesktop.Secret.Item.Label
. The values
in the hash table should be GVariant values of the properties.
This method may block indefinitely and should not be used in user interface
threads. The secret service may prompt the user. secret_service_prompt()
will be used to handle any prompts that are required.
|
a secret service object |
|
the D-Bus path of the collection in which to create item. [allow-none] |
|
hash table of D-Bus properties for the new collection. [element-type utf8 GLib.Variant] |
|
the secret value to store in the item |
|
whether to replace an item with the matching attributes |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
a new string containing the D-Bus object path of the item. [transfer full] |
void secret_service_delete_path (SecretService *self
,const gchar *item_path
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Delete a secret item from the secret service.
The item is represented by its D-Bus object path. If you already have a
SecretItem proxy objects, use use secret_item_delete()
instead.
This method will return immediately and complete asynchronously.
|
the secret service |
|
the D-Bus path of item to delete |
|
optional cancellation object |
|
called when the operation completes |
|
data to be passed to the callback |
gboolean secret_service_delete_path_finish (SecretService *self
,GAsyncResult *result
,GError **error
);
Complete an asynchronous operation to delete a secret item from the secret service.
|
the secret service |
|
the asynchronous result passed to the callback |
|
location to place an error on failure |
Returns : |
whether the deletion was successful or not |
gboolean secret_service_delete_path_sync (SecretService *self
,const gchar *item_path
,GCancellable *cancellable
,GError **error
);
Delete a secret item from the secret service.
The item is represented by its D-Bus object path. If you already have a
SecretItem proxy objects, use use secret_item_delete_sync()
instead.
This method may block indefinitely and should not be used in user interface threads.
|
the secret service |
|
the D-Bus path of item to delete |
|
optional cancellation object |
|
location to place an error on failure |
Returns : |
whether the deletion was successful or not |
"collections"
property "collections" SecretObjectList* : Read
A list of SecretCollection 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 secret_service_get()
or
secret_service_new()
functions. Or call the secret_service_ensure_collections()
method.
"flags"
property"flags" SecretServiceFlags : Read / Write / Construct Only
A set of flags describing which parts of the secret service have been initialized.