libsecret/secret-service.h

   1 /* libsecret - GLib wrapper for Secret Service
   2  *
   3  * Copyright 2011 Collabora Ltd.
   4  * Copyright 2012 Red Hat Inc.
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 2.1 of the licence or (at
   9  * your option) any later version.
  10  *
  11  * See the included COPYING file for more information.
  12  *
  13  * Author: Stef Walter <stefw@gnome.org>
  14  */
  15
  16 #if !defined (__SECRET_INSIDE_HEADER__) && !defined (SECRET_COMPILATION)
  17 #error "Only <libsecret/secret.h> or <libsecret/secret-unstable.h> can be included directly."
  18 #endif
  19
  20 #ifndef __SECRET_SERVICE_H__
  21 #define __SECRET_SERVICE_H__
  22
  23 #include <gio/gio.h>
  24
  25 #include "secret-prompt.h"
  26 #include "secret-schema.h"
  27 #include "secret-types.h"
  28 #include "secret-value.h"
  29
  30 G_BEGIN_DECLS
  31
  32 typedef enum {
  33         SECRET_SERVICE_NONE = 0,
  34         SECRET_SERVICE_OPEN_SESSION = 1 << 1,
  35         SECRET_SERVICE_LOAD_COLLECTIONS = 1 << 2,
  36 } SecretServiceFlags;
  37
  38 #define SECRET_TYPE_SERVICE            (secret_service_get_type ())
  39 #define SECRET_SERVICE(inst)           (G_TYPE_CHECK_INSTANCE_CAST ((inst), SECRET_TYPE_SERVICE, SecretService))
  40 #define SECRET_SERVICE_CLASS(class)    (G_TYPE_CHECK_CLASS_CAST ((class), SECRET_TYPE_SERVICE, SecretServiceClass))
  41 #define SECRET_IS_SERVICE(inst)        (G_TYPE_CHECK_INSTANCE_TYPE ((inst), SECRET_TYPE_SERVICE))
  42 #define SECRET_IS_SERVICE_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), SECRET_TYPE_SERVICE))
  43 #define SECRET_SERVICE_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), SECRET_TYPE_SERVICE, SecretServiceClass))
  44
  45 typedef struct _SecretServiceClass   SecretServiceClass;
  46 typedef struct _SecretServicePrivate SecretServicePrivate;
  47
  48 struct _SecretService {
  49         GDBusProxy parent;
  50
  51         /*< private >*/
  52         SecretServicePrivate *pv;
  53 };
  54
  55 struct _SecretServiceClass {
  56         GDBusProxyClass parent_class;
  57
  58         GType collection_gtype;
  59         GType item_gtype;
  60
  61         GVariant *  (* prompt_sync)      (SecretService *self,
  62                                           SecretPrompt *prompt,
  63                                           GCancellable *cancellable,
  64                                           const GVariantType *return_type,
  65                                           GError **error);
  66
  67         void        (* prompt_async)     (SecretService *self,
  68                                           SecretPrompt *prompt,
  69                                           GCancellable *cancellable,
  70                                           GAsyncReadyCallback callback,
  71                                           gpointer user_data);
  72
  73         GVariant *  (* prompt_finish)    (SecretService *self,
  74                                           GAsyncResult *result,
  75                                           const GVariantType *return_type,
  76                                           GError **error);
  77
  78         /*< private >*/
  79         gpointer padding[16];
  80 };
  81
  82 GType                secret_service_get_type                      (void) G_GNUC_CONST;
  83
  84 void                 secret_service_get                           (SecretServiceFlags flags,
  85                                                                    GCancellable *cancellable,
  86                                                                    GAsyncReadyCallback callback,
  87                                                                    gpointer user_data);
  88
  89 SecretService *      secret_service_get_finish                    (GAsyncResult *result,
  90                                                                    GError **error);
  91
  92 SecretService *      secret_service_get_sync                      (SecretServiceFlags flags,
  93                                                                    GCancellable *cancellable,
  94                                                                    GError **error);
  95
  96 void                 secret_service_disconnect                    (void);
  97
  98 void                 secret_service_new                           (GType service_gtype,
  99                                                                    const gchar *service_bus_name,
 100                                                                    SecretServiceFlags flags,
 101                                                                    GCancellable *cancellable,
 102                                                                    GAsyncReadyCallback callback,
 103                                                                    gpointer user_data);
 104
 105 SecretService *      secret_service_new_finish                    (GAsyncResult *result,
 106                                                                    GError **error);
 107
 108 SecretService *      secret_service_new_sync                      (GType service_gtype,
 109                                                                    const gchar *service_bus_name,
 110                                                                    SecretServiceFlags flags,
 111                                                                    GCancellable *cancellable,
 112                                                                    GError **error);
 113
 114 SecretServiceFlags   secret_service_get_flags                     (SecretService *self);
 115
 116 const gchar *        secret_service_get_session_algorithms        (SecretService *self);
 117
 118 GList *              secret_service_get_collections               (SecretService *self);
 119
 120 void                 secret_service_ensure_session                (SecretService *self,
 121                                                                    GCancellable *cancellable,
 122                                                                    GAsyncReadyCallback callback,
 123                                                                    gpointer user_data);
 124
 125 gboolean             secret_service_ensure_session_finish         (SecretService *self,
 126                                                                    GAsyncResult *result,
 127                                                                    GError **error);
 128
 129 gboolean             secret_service_ensure_session_sync           (SecretService *self,
 130                                                                    GCancellable *cancellable,
 131                                                                    GError **error);
 132
 133 void                 secret_service_load_collections              (SecretService *self,
 134                                                                    GCancellable *cancellable,
 135                                                                    GAsyncReadyCallback callback,
 136                                                                    gpointer user_data);
 137
 138 gboolean             secret_service_load_collections_finish       (SecretService *self,
 139                                                                    GAsyncResult *result,
 140                                                                    GError **error);
 141
 142 gboolean             secret_service_load_collections_sync         (SecretService *self,
 143                                                                    GCancellable *cancellable,
 144                                                                    GError **error);
 145
 146 GVariant *           secret_service_prompt_sync                   (SecretService *self,
 147                                                                    SecretPrompt *prompt,
 148                                                                    GCancellable *cancellable,
 149                                                                    const GVariantType *return_type,
 150                                                                    GError **error);
 151
 152 void                 secret_service_prompt                        (SecretService *self,
 153                                                                    SecretPrompt *prompt,
 154                                                                    GCancellable *cancellable,
 155                                                                    GAsyncReadyCallback callback,
 156                                                                    gpointer user_data);
 157
 158 GVariant *           secret_service_prompt_finish                 (SecretService *self,
 159                                                                    GAsyncResult *result,
 160                                                                    const GVariantType *return_type,
 161                                                                    GError **error);
 162
 163 void                 secret_service_search                        (SecretService *service,
 164                                                                    const SecretSchema *schema,
 165                                                                    GHashTable *attributes,
 166                                                                    SecretSearchFlags flags,
 167                                                                    GCancellable *cancellable,
 168                                                                    GAsyncReadyCallback callback,
 169                                                                    gpointer user_data);
 170
 171 GList *              secret_service_search_finish                 (SecretService *service,
 172                                                                    GAsyncResult *result,
 173                                                                    GError **error);
 174
 175 GList *              secret_service_search_sync                   (SecretService *service,
 176                                                                    const SecretSchema *schema,
 177                                                                    GHashTable *attributes,
 178                                                                    SecretSearchFlags flags,
 179                                                                    GCancellable *cancellable,
 180                                                                    GError **error);
 181
 182 void                 secret_service_lock                          (SecretService *service,
 183                                                                    GList *objects,
 184                                                                    GCancellable *cancellable,
 185                                                                    GAsyncReadyCallback callback,
 186                                                                    gpointer user_data);
 187
 188 gint                 secret_service_lock_finish                   (SecretService *service,
 189                                                                    GAsyncResult *result,
 190                                                                    GList **locked,
 191                                                                    GError **error);
 192
 193 gint                 secret_service_lock_sync                     (SecretService *service,
 194                                                                    GList *objects,
 195                                                                    GCancellable *cancellable,
 196                                                                    GList **locked,
 197                                                                    GError **error);
 198
 199 void                 secret_service_unlock                        (SecretService *service,
 200                                                                    GList *objects,
 201                                                                    GCancellable *cancellable,
 202                                                                    GAsyncReadyCallback callback,
 203                                                                    gpointer user_data);
 204
 205 gint                 secret_service_unlock_finish                 (SecretService *service,
 206                                                                    GAsyncResult *result,
 207                                                                    GList **unlocked,
 208                                                                    GError **error);
 209
 210 gint                 secret_service_unlock_sync                   (SecretService *service,
 211                                                                    GList *objects,
 212                                                                    GCancellable *cancellable,
 213                                                                    GList **unlocked,
 214                                                                    GError **error);
 215
 216 void                 secret_service_store                         (SecretService *service,
 217                                                                    const SecretSchema *schema,
 218                                                                    GHashTable *attributes,
 219                                                                    const gchar *collection,
 220                                                                    const gchar *label,
 221                                                                    SecretValue *value,
 222                                                                    GCancellable *cancellable,
 223                                                                    GAsyncReadyCallback callback,
 224                                                                    gpointer user_data);
 225
 226 gboolean             secret_service_store_finish                  (SecretService *service,
 227                                                                    GAsyncResult *result,
 228                                                                    GError **error);
 229
 230 gboolean             secret_service_store_sync                    (SecretService *service,
 231                                                                    const SecretSchema *schema,
 232                                                                    GHashTable *attributes,
 233                                                                    const gchar *collection,
 234                                                                    const gchar *label,
 235                                                                    SecretValue *value,
 236                                                                    GCancellable *cancellable,
 237                                                                    GError **error);
 238
 239 void                 secret_service_lookup                        (SecretService *service,
 240                                                                    const SecretSchema *schema,
 241                                                                    GHashTable *attributes,
 242                                                                    GCancellable *cancellable,
 243                                                                    GAsyncReadyCallback callback,
 244                                                                    gpointer user_data);
 245
 246 SecretValue *        secret_service_lookup_finish                 (SecretService *service,
 247                                                                    GAsyncResult *result,
 248                                                                    GError **error);
 249
 250 SecretValue *        secret_service_lookup_sync                   (SecretService *service,
 251                                                                    const SecretSchema *schema,
 252                                                                    GHashTable *attributes,
 253                                                                    GCancellable *cancellable,
 254                                                                    GError **error);
 255
 256 void                 secret_service_remove                        (SecretService *service,
 257                                                                    const SecretSchema *schema,
 258                                                                    GHashTable *attributes,
 259                                                                    GCancellable *cancellable,
 260                                                                    GAsyncReadyCallback callback,
 261                                                                    gpointer user_data);
 262
 263 gboolean             secret_service_remove_finish                 (SecretService *service,
 264                                                                    GAsyncResult *result,
 265                                                                    GError **error);
 266
 267 gboolean             secret_service_remove_sync                   (SecretService *service,
 268                                                                    const SecretSchema *schema,
 269                                                                    GHashTable *attributes,
 270                                                                    GCancellable *cancellable,
 271                                                                    GError **error);
 272
 273 void                 secret_service_set_alias                     (SecretService *service,
 274                                                                    const gchar *alias,
 275                                                                    SecretCollection *collection,
 276                                                                    GCancellable *cancellable,
 277                                                                    GAsyncReadyCallback callback,
 278                                                                    gpointer user_data);
 279
 280 gboolean             secret_service_set_alias_finish              (SecretService *service,
 281                                                                    GAsyncResult *result,
 282                                                                    GError **error);
 283
 284 gboolean             secret_service_set_alias_sync                (SecretService *service,
 285                                                                    const gchar *alias,
 286                                                                    SecretCollection *collection,
 287                                                                    GCancellable *cancellable,
 288                                                                    GError **error);
 289
 290 G_END_DECLS
 291
 292 #endif /* __SECRET_SERVICE_H___ */