libsecret/secret-password.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

/* libsecret - GLib wrapper for Secret Service
 *
 * Copyright 2011 Collabora Ltd.
 *
 * 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 <stefw@gnome.org>
 */

#if !defined (__SECRET_INSIDE_HEADER__) && !defined (SECRET_COMPILATION)
#error "Only <libsecret/secret.h> can be included directly."
#endif

#ifndef __SECRET_PASSWORD_H__
#define __SECRET_PASSWORD_H__

#include <gio/gio.h>

G_BEGIN_DECLS

#include "secret-schema.h"
#include "secret-types.h"

void        secret_password_store                      (const SecretSchema *schema,
                                                        const gchar *collection,
                                                        const gchar *label,
                                                        const gchar *password,
                                                        GCancellable *cancellable,
                                                        GAsyncReadyCallback callback,
                                                        gpointer user_data,
                                                        ...) G_GNUC_NULL_TERMINATED;

void        secret_password_storev                     (const SecretSchema *schema,
                                                        GHashTable *attributes,
                                                        const gchar *collection,
                                                        const gchar *label,
                                                        const gchar *password,
                                                        GCancellable *cancellable,
                                                        GAsyncReadyCallback callback,
                                                        gpointer user_data);

gboolean    secret_password_store_finish               (GAsyncResult *result,
                                                        GError **error);

gboolean    secret_password_store_sync                 (const SecretSchema *schema,
                                                        const gchar *collection,
                                                        const gchar *label,
                                                        const gchar *password,
                                                        GCancellable *cancellable,
                                                        GError **error,
                                                        ...) G_GNUC_NULL_TERMINATED;

gboolean    secret_password_storev_sync                (const SecretSchema *schema,
                                                        GHashTable *attributes,
                                                        const gchar *collection,
                                                        const gchar *label,
                                                        const gchar *password,
                                                        GCancellable *cancellable,
                                                        GError **error);

void        secret_password_lookup                     (const SecretSchema *schema,
                                                        GCancellable *cancellable,
                                                        GAsyncReadyCallback callback,
                                                        gpointer user_data,
                                                        ...) G_GNUC_NULL_TERMINATED;

void        secret_password_lookupv                    (const SecretSchema *schema,
                                                        GHashTable *attributes,
                                                        GCancellable *cancellable,
                                                        GAsyncReadyCallback callback,
                                                        gpointer user_data);

gchar *     secret_password_lookup_finish              (GAsyncResult *result,
                                                        GError **error);

gchar *     secret_password_lookup_nonpageable_finish  (GAsyncResult *result,
                                                        GError **error);

gchar *     secret_password_lookup_sync                (const SecretSchema *schema,
                                                        GCancellable *cancellable,
                                                        GError **error,
                                                        ...) G_GNUC_NULL_TERMINATED;

gchar *     secret_password_lookup_nonpageable_sync    (const SecretSchema *schema,
                                                        GCancellable *cancellable,
                                                        GError **error,
                                                        ...);

gchar *     secret_password_lookupv_sync               (const SecretSchema *schema,
                                                        GHashTable *attributes,
                                                        GCancellable *cancellable,
                                                        GError **error);

gchar *     secret_password_lookupv_nonpageable_sync   (const SecretSchema *schema,
                                                        GHashTable *attributes,
                                                        GCancellable *cancellable,
                                                        GError **error);

void        secret_password_clear                      (const SecretSchema *schema,
                                                        GCancellable *cancellable,
                                                        GAsyncReadyCallback callback,
                                                        gpointer user_data,
                                                        ...) G_GNUC_NULL_TERMINATED;

void        secret_password_clearv                     (const SecretSchema *schema,
                                                        GHashTable *attributes,
                                                        GCancellable *cancellable,
                                                        GAsyncReadyCallback callback,
                                                        gpointer user_data);

gboolean    secret_password_clear_finish               (GAsyncResult *result,
                                                        GError **error);

gboolean    secret_password_clear_sync                 (const SecretSchema* schema,
                                                        GCancellable *cancellable,
                                                        GError **error,
                                                        ...) G_GNUC_NULL_TERMINATED;

gboolean    secret_password_clearv_sync                (const SecretSchema *schema,
                                                        GHashTable *attributes,
                                                        GCancellable *cancellable,
                                                        GError **error);

void        secret_password_free                       (gchar *password);

void        secret_password_wipe                       (gchar *password);

G_END_DECLS

#endif /* __SECRET_PASSWORD_H___ */