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> 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 typedef enum {
  39         SECRET_SEARCH_NONE = 0,
  40         SECRET_SEARCH_ALL = 1 << 1,
  41         SECRET_SEARCH_UNLOCK = 1 << 2,
  42         SECRET_SEARCH_LOAD_SECRETS = 1 << 3,
  43 } SecretSearchFlags;
  44
  45 #define SECRET_TYPE_SERVICE            (secret_service_get_type ())
  46 #define SECRET_SERVICE(inst)           (G_TYPE_CHECK_INSTANCE_CAST ((inst), SECRET_TYPE_SERVICE, SecretService))
  47 #define SECRET_SERVICE_CLASS(class)    (G_TYPE_CHECK_CLASS_CAST ((class), SECRET_TYPE_SERVICE, SecretServiceClass))
  48 #define SECRET_IS_SERVICE(inst)        (G_TYPE_CHECK_INSTANCE_TYPE ((inst), SECRET_TYPE_SERVICE))
  49 #define SECRET_IS_SERVICE_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), SECRET_TYPE_SERVICE))
  50 #define SECRET_SERVICE_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), SECRET_TYPE_SERVICE, SecretServiceClass))
  51
  52 typedef struct _SecretCollection     SecretCollection;
  53 typedef struct _SecretService        SecretService;
  54 typedef struct _SecretServiceClass   SecretServiceClass;
  55 typedef struct _SecretServicePrivate SecretServicePrivate;
  56
  57 struct _SecretService {
  58         GDBusProxy parent;
  59
  60         /*< private >*/
  61         SecretServicePrivate *pv;
  62 };
  63
  64 struct _SecretServiceClass {
  65         GDBusProxyClass parent_class;
  66
  67         GType collection_gtype;
  68         GType item_gtype;
  69
  70         GVariant *  (* prompt_sync)      (SecretService *self,
  71                                           SecretPrompt *prompt,
  72                                           GCancellable *cancellable,
  73                                           const GVariantType *return_type,
  74                                           GError **error);
  75
  76         void        (* prompt_async)     (SecretService *self,
  77                                           SecretPrompt *prompt,
  78                                           GCancellable *cancellable,
  79                                           GAsyncReadyCallback callback,
  80                                           gpointer user_data);
  81
  82         GVariant *  (* prompt_finish)    (SecretService *self,
  83                                           GAsyncResult *result,
  84                                           const GVariantType *return_type,
  85                                           GError **error);
  86
  87         /*< private >*/
  88         gpointer padding[16];
  89 };
  90
  91 GType                secret_service_get_type                      (void) G_GNUC_CONST;
  92
  93 void                 secret_service_get                           (SecretServiceFlags flags,
  94                                                                    GCancellable *cancellable,
  95                                                                    GAsyncReadyCallback callback,
  96                                                                    gpointer user_data);
  97
  98 SecretService *      secret_service_get_finish                    (GAsyncResult *result,
  99                                                                    GError **error);
 100
 101 SecretService *      secret_service_get_sync                      (SecretServiceFlags flags,
 102                                                                    GCancellable *cancellable,
 103                                                                    GError **error);
 104
 105 void                 secret_service_disconnect                    (void);
 106
 107 void                 secret_service_new                           (GType service_gtype,
 108                                                                    const gchar *service_bus_name,
 109                                                                    SecretServiceFlags flags,
 110                                                                    GCancellable *cancellable,
 111                                                                    GAsyncReadyCallback callback,
 112                                                                    gpointer user_data);
 113
 114 SecretService *      secret_service_new_finish                    (GAsyncResult *result,
 115                                                                    GError **error);
 116
 117 SecretService *      secret_service_new_sync                      (GType service_gtype,
 118                                                                    const gchar *service_bus_name,
 119                                                                    SecretServiceFlags flags,
 120                                                                    GCancellable *cancellable,
 121                                                                    GError **error);
 122
 123 SecretServiceFlags   secret_service_get_flags                     (SecretService *self);
 124
 125 const gchar *        secret_service_get_session_algorithms        (SecretService *self);
 126
 127 GList *              secret_service_get_collections               (SecretService *self);
 128
 129 void                 secret_service_ensure_session                (SecretService *self,
 130                                                                    GCancellable *cancellable,
 131                                                                    GAsyncReadyCallback callback,
 132                                                                    gpointer user_data);
 133
 134 gboolean             secret_service_ensure_session_finish         (SecretService *self,
 135                                                                    GAsyncResult *result,
 136                                                                    GError **error);
 137
 138 gboolean             secret_service_ensure_session_sync           (SecretService *self,
 139                                                                    GCancellable *cancellable,
 140                                                                    GError **error);
 141
 142 void                 secret_service_load_collections              (SecretService *self,
 143                                                                    GCancellable *cancellable,
 144                                                                    GAsyncReadyCallback callback,
 145                                                                    gpointer user_data);
 146
 147 gboolean             secret_service_load_collections_finish       (SecretService *self,
 148                                                                    GAsyncResult *result,
 149                                                                    GError **error);
 150
 151 gboolean             secret_service_load_collections_sync         (SecretService *self,
 152                                                                    GCancellable *cancellable,
 153                                                                    GError **error);
 154
 155 GVariant *           secret_service_prompt_sync                   (SecretService *self,
 156                                                                    SecretPrompt *prompt,
 157                                                                    GCancellable *cancellable,
 158                                                                    const GVariantType *return_type,
 159                                                                    GError **error);
 160
 161 void                 secret_service_prompt                        (SecretService *self,
 162                                                                    SecretPrompt *prompt,
 163                                                                    GCancellable *cancellable,
 164                                                                    GAsyncReadyCallback callback,
 165                                                                    gpointer user_data);
 166
 167 GVariant *           secret_service_prompt_finish                 (SecretService *self,
 168                                                                    GAsyncResult *result,
 169                                                                    const GVariantType *return_type,
 170                                                                    GError **error);
 171
 172 void                 secret_service_search                        (SecretService *service,
 173                                                                    const SecretSchema *schema,
 174                                                                    GHashTable *attributes,
 175                                                                    SecretSearchFlags flags,
 176                                                                    GCancellable *cancellable,
 177                                                                    GAsyncReadyCallback callback,
 178                                                                    gpointer user_data);
 179
 180 GList *              secret_service_search_finish                 (SecretService *service,
 181                                                                    GAsyncResult *result,
 182                                                                    GError **error);
 183
 184 GList *              secret_service_search_sync                   (SecretService *service,
 185                                                                    const SecretSchema *schema,
 186                                                                    GHashTable *attributes,
 187                                                                    SecretSearchFlags flags,
 188                                                                    GCancellable *cancellable,
 189                                                                    GError **error);
 190
 191 void                 secret_service_lock                          (SecretService *service,
 192                                                                    GList *objects,
 193                                                                    GCancellable *cancellable,
 194                                                                    GAsyncReadyCallback callback,
 195                                                                    gpointer user_data);
 196
 197 gint                 secret_service_lock_finish                   (SecretService *service,
 198                                                                    GAsyncResult *result,
 199                                                                    GList **locked,
 200                                                                    GError **error);
 201
 202 gint                 secret_service_lock_sync                     (SecretService *service,
 203                                                                    GList *objects,
 204                                                                    GCancellable *cancellable,
 205                                                                    GList **locked,
 206                                                                    GError **error);
 207
 208 void                 secret_service_unlock                        (SecretService *service,
 209                                                                    GList *objects,
 210                                                                    GCancellable *cancellable,
 211                                                                    GAsyncReadyCallback callback,
 212                                                                    gpointer user_data);
 213
 214 gint                 secret_service_unlock_finish                 (SecretService *service,
 215                                                                    GAsyncResult *result,
 216                                                                    GList **unlocked,
 217                                                                    GError **error);
 218
 219 gint                 secret_service_unlock_sync                   (SecretService *service,
 220                                                                    GList *objects,
 221                                                                    GCancellable *cancellable,
 222                                                                    GList **unlocked,
 223                                                                    GError **error);
 224
 225 void                 secret_service_store                         (SecretService *service,
 226                                                                    const SecretSchema *schema,
 227                                                                    GHashTable *attributes,
 228                                                                    const gchar *collection,
 229                                                                    const gchar *label,
 230                                                                    SecretValue *value,
 231                                                                    GCancellable *cancellable,
 232                                                                    GAsyncReadyCallback callback,
 233                                                                    gpointer user_data);
 234
 235 gboolean             secret_service_store_finish                  (SecretService *service,
 236                                                                    GAsyncResult *result,
 237                                                                    GError **error);
 238
 239 gboolean             secret_service_store_sync                    (SecretService *service,
 240                                                                    const SecretSchema *schema,
 241                                                                    GHashTable *attributes,
 242                                                                    const gchar *collection,
 243                                                                    const gchar *label,
 244                                                                    SecretValue *value,
 245                                                                    GCancellable *cancellable,
 246                                                                    GError **error);
 247
 248 void                 secret_service_lookup                        (SecretService *service,
 249                                                                    const SecretSchema *schema,
 250                                                                    GHashTable *attributes,
 251                                                                    GCancellable *cancellable,
 252                                                                    GAsyncReadyCallback callback,
 253                                                                    gpointer user_data);
 254
 255 SecretValue *        secret_service_lookup_finish                 (SecretService *service,
 256                                                                    GAsyncResult *result,
 257                                                                    GError **error);
 258
 259 SecretValue *        secret_service_lookup_sync                   (SecretService *service,
 260                                                                    const SecretSchema *schema,
 261                                                                    GHashTable *attributes,
 262                                                                    GCancellable *cancellable,
 263                                                                    GError **error);
 264
 265 void                 secret_service_remove                        (SecretService *service,
 266                                                                    const SecretSchema *schema,
 267                                                                    GHashTable *attributes,
 268                                                                    GCancellable *cancellable,
 269                                                                    GAsyncReadyCallback callback,
 270                                                                    gpointer user_data);
 271
 272 gboolean             secret_service_remove_finish                 (SecretService *service,
 273                                                                    GAsyncResult *result,
 274                                                                    GError **error);
 275
 276 gboolean             secret_service_remove_sync                   (SecretService *service,
 277                                                                    const SecretSchema *schema,
 278                                                                    GHashTable *attributes,
 279                                                                    GCancellable *cancellable,
 280                                                                    GError **error);
 281
 282 void                 secret_service_set_alias                     (SecretService *service,
 283                                                                    const gchar *alias,
 284                                                                    SecretCollection *collection,
 285                                                                    GCancellable *cancellable,
 286                                                                    GAsyncReadyCallback callback,
 287                                                                    gpointer user_data);
 288
 289 gboolean             secret_service_set_alias_finish              (SecretService *service,
 290                                                                    GAsyncResult *result,
 291                                                                    GError **error);
 292
 293 gboolean             secret_service_set_alias_sync                (SecretService *service,
 294                                                                    const gchar *alias,
 295                                                                    SecretCollection *collection,
 296                                                                    GCancellable *cancellable,
 297                                                                    GError **error);
 298
 299 G_END_DECLS
 300
 301 #endif /* __SECRET_SERVICE_H___ */