← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gcr/trusty-proposed

« back to all changes in this revision

Viewing changes to gck/gck.h

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach
  • Date: 2012-05-03 10:18:39 UTC
  • Revision ID: package-import@ubuntu.com-20120503101839-wuvloldm7gmdsnij
Tags: upstream-3.4.1
Import upstream version 3.4.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
gck/gck.h
 
1
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
 
2
/* gck.h - the GObject PKCS#11 wrapper library
 
3
 
 
4
   Copyright (C) 2008, Stefan Walter
 
5
 
 
6
   The Gnome Keyring Library is free software; you can redistribute it and/or
 
7
   modify it under the terms of the GNU Library General Public License as
 
8
   published by the Free Software Foundation; either version 2 of the
 
9
   License, or (at your option) any later version.
 
10
 
 
11
   The Gnome Keyring Library is distributed in the hope that it will be useful,
 
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
   Library General Public License for more details.
 
15
 
 
16
   You should have received a copy of the GNU Library General Public
 
17
   License along with the Gnome Library; see the file COPYING.LIB.  If not,
 
18
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
19
   Boston, MA 02111-1307, USA.
 
20
 
 
21
   Author: Stef Walter <nielsen@memberwebs.com>
 
22
*/
 
23
 
 
24
#ifndef GCK_H
 
25
#define GCK_H
 
26
 
 
27
#include <glib.h>
 
28
#include <glib-object.h>
 
29
#include <gio/gio.h>
 
30
 
 
31
#include "pkcs11.h"
 
32
 
 
33
#define __GCK_INSIDE_HEADER__
 
34
 
 
35
#include <gck/gck-enum-types.h>
 
36
 
 
37
G_BEGIN_DECLS
 
38
 
 
39
/*
 
40
 * To use this API, you need to be prepared for changes to the API,
 
41
 * and add the C flag: -DGCK_API_SUBJECT_TO_CHANGE
 
42
 */
 
43
 
 
44
#ifndef GCK_API_SUBJECT_TO_CHANGE
 
45
#error "This API has not yet reached stability."
 
46
#endif
 
47
 
 
48
#define             GCK_VENDOR_CODE                         0x47434B00 /* GCK */
 
49
 
 
50
/* An error code which results from a failure to load the PKCS11 module */
 
51
typedef enum {
 
52
        GCK_ERROR_MODULE_PROBLEM = (CKR_VENDOR_DEFINED | (GCK_VENDOR_CODE + 1)),
 
53
} GckError;
 
54
 
 
55
#define             GCK_ERROR                               (gck_error_get_quark ())
 
56
 
 
57
GQuark              gck_error_get_quark                     (void) G_GNUC_CONST;
 
58
 
 
59
#define             GCK_TYPE_LIST                           (gck_list_get_boxed_type ())
 
60
 
 
61
GType               gck_list_get_boxed_type                 (void) G_GNUC_CONST;
 
62
 
 
63
GList*              gck_list_ref_copy                       (GList *reflist);
 
64
 
 
65
void                gck_list_unref_free                     (GList *reflist);
 
66
 
 
67
const gchar*        gck_message_from_rv                     (gulong rv);
 
68
 
 
69
gboolean            gck_string_to_chars                     (guchar *data,
 
70
                                                             gsize max,
 
71
                                                             const gchar *string);
 
72
 
 
73
gchar*              gck_string_from_chars                   (const guchar *data,
 
74
                                                             gsize max);
 
75
 
 
76
typedef gpointer    (*GckAllocator)                         (gpointer data, gsize length);
 
77
 
 
78
typedef enum {
 
79
        GCK_SESSION_READ_ONLY = 0,
 
80
        GCK_SESSION_READ_WRITE = 1 << 1,
 
81
        GCK_SESSION_LOGIN_USER =  1 << 2,
 
82
        GCK_SESSION_AUTHENTICATE = 1 << 3,
 
83
} GckSessionOptions;
 
84
 
 
85
typedef struct _GckMechanism GckMechanism;
 
86
 
 
87
struct _GckMechanism {
 
88
        gulong type;
 
89
        gconstpointer parameter;
 
90
        gulong n_parameter;
 
91
};
 
92
 
 
93
typedef struct _GckAttribute GckAttribute;
 
94
 
 
95
struct _GckAttribute {
 
96
        gulong type;
 
97
        guchar *value;
 
98
        gulong length;
 
99
};
 
100
 
 
101
#define GCK_INVALID G_MAXULONG
 
102
 
 
103
gboolean            gck_value_to_ulong                      (const guchar *value,
 
104
                                                             gsize length,
 
105
                                                             gulong *result);
 
106
 
 
107
gboolean            gck_value_to_boolean                    (const guchar *value,
 
108
                                                             gsize length,
 
109
                                                             gboolean *result);
 
110
 
 
111
void                gck_attribute_init                      (GckAttribute *attr,
 
112
                                                             gulong attr_type,
 
113
                                                             const guchar *value,
 
114
                                                             gsize length);
 
115
 
 
116
void                gck_attribute_init_invalid              (GckAttribute *attr,
 
117
                                                             gulong attr_type);
 
118
 
 
119
void                gck_attribute_init_empty                (GckAttribute *attr,
 
120
                                                             gulong attr_type);
 
121
 
 
122
void                gck_attribute_init_boolean              (GckAttribute *attr,
 
123
                                                             gulong attr_type,
 
124
                                                             gboolean value);
 
125
 
 
126
void                gck_attribute_init_date                 (GckAttribute *attr,
 
127
                                                             gulong attr_type,
 
128
                                                             const GDate *value);
 
129
 
 
130
void                gck_attribute_init_ulong                (GckAttribute *attr,
 
131
                                                             gulong attr_type,
 
132
                                                             gulong value);
 
133
 
 
134
void                gck_attribute_init_string               (GckAttribute *attr,
 
135
                                                             gulong attr_type,
 
136
                                                             const gchar *value);
 
137
 
 
138
void                gck_attribute_init_copy                 (GckAttribute *dest,
 
139
                                                             const GckAttribute *src);
 
140
 
 
141
#define             GCK_TYPE_ATTRIBUTE                      (gck_attribute_get_type ())
 
142
 
 
143
GType               gck_attribute_get_type                  (void) G_GNUC_CONST;
 
144
 
 
145
GckAttribute*       gck_attribute_new                       (gulong attr_type,
 
146
                                                             const guchar *value,
 
147
                                                             gsize length);
 
148
 
 
149
GckAttribute*       gck_attribute_new_invalid               (gulong attr_type);
 
150
 
 
151
GckAttribute*       gck_attribute_new_empty                 (gulong attr_type);
 
152
 
 
153
GckAttribute*       gck_attribute_new_boolean               (gulong attr_type,
 
154
                                                             gboolean value);
 
155
 
 
156
GckAttribute*       gck_attribute_new_date                  (gulong attr_type,
 
157
                                                             const GDate *value);
 
158
 
 
159
GckAttribute*       gck_attribute_new_ulong                 (gulong attr_type,
 
160
                                                             gulong value);
 
161
 
 
162
GckAttribute*       gck_attribute_new_string                (gulong attr_type,
 
163
                                                             const gchar *value);
 
164
 
 
165
gboolean            gck_attribute_is_invalid                (const GckAttribute *attr);
 
166
 
 
167
gboolean            gck_attribute_get_boolean               (const GckAttribute *attr);
 
168
 
 
169
gulong              gck_attribute_get_ulong                 (const GckAttribute *attr);
 
170
 
 
171
gchar*              gck_attribute_get_string                (const GckAttribute *attr);
 
172
 
 
173
void                gck_attribute_get_date                  (const GckAttribute *attr,
 
174
                                                             GDate* value);
 
175
 
 
176
gboolean            gck_attribute_equal                     (gconstpointer attr1,
 
177
                                                             gconstpointer attr2);
 
178
 
 
179
guint               gck_attribute_hash                      (gconstpointer attr);
 
180
 
 
181
GckAttribute*       gck_attribute_dup                       (const GckAttribute *attr);
 
182
 
 
183
void                gck_attribute_clear                     (GckAttribute *attr);
 
184
 
 
185
void                gck_attribute_free                      (gpointer attr);
 
186
 
 
187
void                gck_attribute_dump                      (const GckAttribute *attr);
 
188
 
 
189
typedef struct _GckBuilder GckBuilder;
 
190
 
 
191
struct _GckBuilder {
 
192
        /*< private >*/
 
193
        gsize x[16];
 
194
};
 
195
 
 
196
typedef enum {
 
197
        GCK_BUILDER_NONE,
 
198
        GCK_BUILDER_SECURE_MEMORY = 1,
 
199
} GckBuilderFlags;
 
200
 
 
201
typedef struct _GckAttributes GckAttributes;
 
202
 
 
203
GckBuilder *         gck_builder_new                        (GckBuilderFlags flags);
 
204
 
 
205
#define              GCK_BUILDER_INIT                       { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } }
 
206
 
 
207
GckBuilder *         gck_builder_ref                        (GckBuilder *builder);
 
208
 
 
209
void                 gck_builder_unref                      (gpointer builder);
 
210
 
 
211
void                 gck_builder_init                       (GckBuilder *builder);
 
212
 
 
213
void                 gck_builder_init_full                  (GckBuilder *builder,
 
214
                                                             GckBuilderFlags flags);
 
215
 
 
216
#define              GCK_TYPE_BUILDER                       (gck_builder_get_type ())
 
217
 
 
218
GType                gck_builder_get_type                   (void) G_GNUC_CONST;
 
219
 
 
220
void                 gck_builder_take_data                  (GckBuilder *builder,
 
221
                                                             gulong attr_type,
 
222
                                                             guchar *value,
 
223
                                                             gsize length);
 
224
 
 
225
void                 gck_builder_add_data                   (GckBuilder *builder,
 
226
                                                             gulong attr_type,
 
227
                                                             const guchar *value,
 
228
                                                             gsize length);
 
229
 
 
230
void                 gck_builder_add_empty                  (GckBuilder *builder,
 
231
                                                             gulong attr_type);
 
232
 
 
233
void                 gck_builder_add_invalid                (GckBuilder *builder,
 
234
                                                             gulong attr_type);
 
235
 
 
236
void                 gck_builder_add_ulong                  (GckBuilder *builder,
 
237
                                                             gulong attr_type,
 
238
                                                             gulong value);
 
239
 
 
240
void                 gck_builder_add_boolean                (GckBuilder *builder,
 
241
                                                             gulong attr_type,
 
242
                                                             gboolean value);
 
243
 
 
244
void                 gck_builder_add_date                   (GckBuilder *builder,
 
245
                                                             gulong attr_type,
 
246
                                                             const GDate *value);
 
247
 
 
248
void                 gck_builder_add_string                 (GckBuilder *builder,
 
249
                                                             gulong attr_type,
 
250
                                                             const gchar *value);
 
251
 
 
252
void                 gck_builder_add_attribute              (GckBuilder *builder,
 
253
                                                             const GckAttribute *attr);
 
254
 
 
255
void                 gck_builder_add_all                    (GckBuilder *builder,
 
256
                                                             GckAttributes *attrs);
 
257
 
 
258
void                 gck_builder_add_only                   (GckBuilder *builder,
 
259
                                                             GckAttributes *attrs,
 
260
                                                             gulong only_type,
 
261
                                                             ...);
 
262
 
 
263
void                 gck_builder_add_onlyv                  (GckBuilder *builder,
 
264
                                                             GckAttributes *attrs,
 
265
                                                             const gulong *only_types,
 
266
                                                             guint n_only_types);
 
267
 
 
268
void                 gck_builder_add_except                 (GckBuilder *builder,
 
269
                                                             GckAttributes *attrs,
 
270
                                                             gulong except_type,
 
271
                                                             ...);
 
272
 
 
273
void                 gck_builder_add_exceptv                (GckBuilder *builder,
 
274
                                                             GckAttributes *attrs,
 
275
                                                             const gulong *except_types,
 
276
                                                             guint n_except_types);
 
277
 
 
278
void                 gck_builder_set_data                   (GckBuilder *builder,
 
279
                                                             gulong attr_type,
 
280
                                                             const guchar *value,
 
281
                                                             gsize length);
 
282
 
 
283
void                 gck_builder_set_empty                  (GckBuilder *builder,
 
284
                                                             gulong attr_type);
 
285
 
 
286
void                 gck_builder_set_invalid                (GckBuilder *builder,
 
287
                                                             gulong attr_type);
 
288
 
 
289
void                 gck_builder_set_ulong                  (GckBuilder *builder,
 
290
                                                             gulong attr_type,
 
291
                                                             gulong value);
 
292
 
 
293
void                 gck_builder_set_boolean                (GckBuilder *builder,
 
294
                                                             gulong attr_type,
 
295
                                                             gboolean value);
 
296
 
 
297
void                 gck_builder_set_date                   (GckBuilder *builder,
 
298
                                                             gulong attr_type,
 
299
                                                             const GDate *value);
 
300
 
 
301
void                 gck_builder_set_string                 (GckBuilder *builder,
 
302
                                                             gulong attr_type,
 
303
                                                             const gchar *value);
 
304
 
 
305
void                 gck_builder_set_all                    (GckBuilder *builder,
 
306
                                                             GckAttributes *attrs);
 
307
 
 
308
const GckAttribute * gck_builder_find                       (GckBuilder *builder,
 
309
                                                             gulong attr_type);
 
310
 
 
311
gboolean             gck_builder_find_boolean               (GckBuilder *builder,
 
312
                                                             gulong attr_type,
 
313
                                                             gboolean *value);
 
314
 
 
315
gboolean             gck_builder_find_ulong                 (GckBuilder *builder,
 
316
                                                             gulong attr_type,
 
317
                                                             gulong *value);
 
318
 
 
319
gboolean             gck_builder_find_string                (GckBuilder *builder,
 
320
                                                             gulong attr_type,
 
321
                                                             gchar **value);
 
322
 
 
323
gboolean             gck_builder_find_date                  (GckBuilder *builder,
 
324
                                                             gulong attr_type,
 
325
                                                             GDate *value);
 
326
 
 
327
GckAttributes *      gck_builder_steal                      (GckBuilder *builder);
 
328
 
 
329
GckAttributes *      gck_builder_end                        (GckBuilder *builder);
 
330
 
 
331
GckBuilder *         gck_builder_copy                       (GckBuilder *builder);
 
332
 
 
333
void                 gck_builder_clear                      (GckBuilder *builder);
 
334
 
 
335
#define              GCK_TYPE_ATTRIBUTES                    (gck_attributes_get_boxed_type ())
 
336
 
 
337
GType                gck_attributes_get_type                (void) G_GNUC_CONST;
 
338
 
 
339
GckAttributes *      gck_attributes_new                     (gulong reserved);
 
340
 
 
341
GckAttributes *      gck_attributes_new_empty               (gulong first_type,
 
342
                                                             ...);
 
343
 
 
344
const GckAttribute * gck_attributes_at                      (GckAttributes *attrs,
 
345
                                                             guint index);
 
346
 
 
347
const GckAttribute * gck_attributes_find                    (GckAttributes *attrs,
 
348
                                                             gulong attr_type);
 
349
 
 
350
gboolean             gck_attributes_find_boolean            (GckAttributes *attrs,
 
351
                                                             gulong attr_type,
 
352
                                                             gboolean *value);
 
353
 
 
354
gboolean             gck_attributes_find_ulong              (GckAttributes *attrs,
 
355
                                                             gulong attr_type,
 
356
                                                             gulong *value);
 
357
 
 
358
gboolean             gck_attributes_find_string             (GckAttributes *attrs,
 
359
                                                             gulong attr_type,
 
360
                                                             gchar **value);
 
361
 
 
362
gboolean             gck_attributes_find_date               (GckAttributes *attrs,
 
363
                                                             gulong attr_type,
 
364
                                                             GDate *value);
 
365
 
 
366
gulong               gck_attributes_count                   (GckAttributes *attrs);
 
367
 
 
368
GckAttributes *      gck_attributes_ref                     (GckAttributes *attrs);
 
369
 
 
370
GckAttributes *      gck_attributes_ref_sink                (GckAttributes *attrs);
 
371
 
 
372
void                 gck_attributes_unref                   (gpointer attrs);
 
373
 
 
374
gboolean             gck_attributes_contains                (GckAttributes *attrs,
 
375
                                                             const GckAttribute *match);
 
376
 
 
377
void                 gck_attributes_dump                    (GckAttributes *attrs);
 
378
 
 
379
gchar *              gck_attributes_to_string               (GckAttributes *attrs);
 
380
 
 
381
/* -------------------------------------------------------------------------
 
382
 * FORWARDS
 
383
 */
 
384
typedef struct _GckSlot GckSlot;
 
385
typedef struct _GckModule GckModule;
 
386
typedef struct _GckSession GckSession;
 
387
typedef struct _GckObject GckObject;
 
388
typedef struct _GckObjectCache GckObjectCache;
 
389
typedef struct _GckEnumerator GckEnumerator;
 
390
typedef struct _GckUriData GckUriData;
 
391
 
 
392
/* -------------------------------------------------------------------------
 
393
 * MODULE
 
394
 */
 
395
 
 
396
typedef struct _GckModuleInfo GckModuleInfo;
 
397
 
 
398
struct _GckModuleInfo {
 
399
        guint8 pkcs11_version_major;
 
400
        guint8 pkcs11_version_minor;
 
401
 
 
402
        gchar *manufacturer_id;
 
403
        gulong flags;
 
404
 
 
405
        gchar *library_description;
 
406
        guint8 library_version_major;
 
407
        guint8 library_version_minor;
 
408
};
 
409
 
 
410
#define             GCK_TYPE_MODULE_INFO                   (gck_module_info_get_type ())
 
411
 
 
412
GType               gck_module_info_get_type               (void) G_GNUC_CONST;
 
413
 
 
414
GckModuleInfo *     gck_module_info_copy                   (GckModuleInfo *module_info);
 
415
 
 
416
void                gck_module_info_free                   (GckModuleInfo *module_info);
 
417
 
 
418
#define GCK_TYPE_MODULE             (gck_module_get_type())
 
419
#define GCK_MODULE(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_MODULE, GckModule))
 
420
#define GCK_MODULE_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_MODULE, GckModule))
 
421
#define GCK_IS_MODULE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_MODULE))
 
422
#define GCK_IS_MODULE_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_MODULE))
 
423
#define GCK_MODULE_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_MODULE, GckModuleClass))
 
424
 
 
425
typedef struct _GckModuleClass GckModuleClass;
 
426
typedef struct _GckModulePrivate GckModulePrivate;
 
427
 
 
428
struct _GckModule {
 
429
        GObject parent;
 
430
 
 
431
        /*< private >*/
 
432
        GckModulePrivate *pv;
 
433
        gpointer reserved[4];
 
434
};
 
435
 
 
436
struct _GckModuleClass {
 
437
        GObjectClass parent;
 
438
 
 
439
        gboolean (*authenticate_slot) (GckModule *self, GckSlot *slot, gchar *label, gchar **password);
 
440
 
 
441
        gboolean (*authenticate_object) (GckModule *self, GckObject *object, gchar *label, gchar **password);
 
442
 
 
443
        /*< private >*/
 
444
        gpointer reserved[8];
 
445
};
 
446
 
 
447
GType                 gck_module_get_type                     (void) G_GNUC_CONST;
 
448
 
 
449
GckModule*            gck_module_new                          (CK_FUNCTION_LIST_PTR funcs);
 
450
 
 
451
GckModule*            gck_module_initialize                   (const gchar *path,
 
452
                                                               GCancellable *cancellable,
 
453
                                                               GError **error);
 
454
 
 
455
void                  gck_module_initialize_async             (const gchar *path,
 
456
                                                               GCancellable *cancellable,
 
457
                                                               GAsyncReadyCallback callback,
 
458
                                                               gpointer user_data);
 
459
 
 
460
GckModule *           gck_module_initialize_finish            (GAsyncResult *result,
 
461
                                                               GError **error);
 
462
 
 
463
gboolean              gck_module_equal                        (gconstpointer module1,
 
464
                                                               gconstpointer module2);
 
465
 
 
466
guint                 gck_module_hash                         (gconstpointer module);
 
467
 
 
468
gboolean              gck_module_match                        (GckModule *self,
 
469
                                                               GckUriData *uri);
 
470
 
 
471
const gchar*          gck_module_get_path                     (GckModule *self);
 
472
 
 
473
CK_FUNCTION_LIST_PTR  gck_module_get_functions                (GckModule *self);
 
474
 
 
475
GckModuleInfo*        gck_module_get_info                     (GckModule *self);
 
476
 
 
477
GList*                gck_module_get_slots                    (GckModule *self,
 
478
                                                               gboolean token_present);
 
479
 
 
480
GList*                gck_modules_initialize_registered        (GCancellable *cancellable,
 
481
                                                                GError **error);
 
482
 
 
483
void                  gck_modules_initialize_registered_async  (GCancellable *cancellable,
 
484
                                                                GAsyncReadyCallback callback,
 
485
                                                                gpointer user_data);
 
486
 
 
487
GList *               gck_modules_initialize_registered_finish (GAsyncResult *result,
 
488
                                                                GError **error);
 
489
 
 
490
GList*                gck_modules_get_slots                   (GList *modules,
 
491
                                                               gboolean token_present);
 
492
 
 
493
GckEnumerator*        gck_modules_enumerate_objects           (GList *modules,
 
494
                                                               GckAttributes *attrs,
 
495
                                                               GckSessionOptions session_options);
 
496
 
 
497
GckSlot*              gck_modules_token_for_uri               (GList *modules,
 
498
                                                               const gchar *uri,
 
499
                                                               GError **error);
 
500
 
 
501
GList *               gck_modules_tokens_for_uri              (GList *modules,
 
502
                                                               const gchar *uri,
 
503
                                                               GError **error);
 
504
 
 
505
GckObject*            gck_modules_object_for_uri              (GList *modules,
 
506
                                                               const gchar *uri,
 
507
                                                               GckSessionOptions session_options,
 
508
                                                               GError **error);
 
509
 
 
510
GList*                gck_modules_objects_for_uri             (GList *modules,
 
511
                                                               const gchar *uri,
 
512
                                                               GckSessionOptions session_options,
 
513
                                                               GError **error);
 
514
 
 
515
GckEnumerator*        gck_modules_enumerate_uri               (GList *modules,
 
516
                                                               const gchar *uri,
 
517
                                                               GckSessionOptions session_options,
 
518
                                                               GError **error);
 
519
 
 
520
 
 
521
/* ------------------------------------------------------------------------
 
522
 * ENUMERATOR
 
523
 */
 
524
 
 
525
#define GCK_TYPE_ENUMERATOR             (gck_enumerator_get_type())
 
526
#define GCK_ENUMERATOR(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_ENUMERATOR, GckEnumerator))
 
527
#define GCK_ENUMERATOR_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_ENUMERATOR, GckEnumerator))
 
528
#define GCK_IS_ENUMERATOR(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_ENUMERATOR))
 
529
#define GCK_IS_ENUMERATOR_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_ENUMERATOR))
 
530
#define GCK_ENUMERATOR_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_ENUMERATOR, GckEnumeratorClass))
 
531
 
 
532
typedef struct _GckEnumeratorClass GckEnumeratorClass;
 
533
typedef struct _GckEnumeratorPrivate GckEnumeratorPrivate;
 
534
 
 
535
struct _GckEnumerator {
 
536
        GObject parent;
 
537
 
 
538
        /*< private >*/
 
539
        GckEnumeratorPrivate *pv;
 
540
        gpointer reserved[2];
 
541
};
 
542
 
 
543
struct _GckEnumeratorClass {
 
544
        GObjectClass parent;
 
545
 
 
546
        /*< private >*/
 
547
        gpointer reserved[2];
 
548
};
 
549
 
 
550
GType                 gck_enumerator_get_type                 (void) G_GNUC_CONST;
 
551
 
 
552
GTlsInteraction *     gck_enumerator_get_interaction          (GckEnumerator *self);
 
553
 
 
554
void                  gck_enumerator_set_interaction          (GckEnumerator *self,
 
555
                                                               GTlsInteraction *interaction);
 
556
 
 
557
GType                 gck_enumerator_get_object_type          (GckEnumerator *self);
 
558
 
 
559
void                  gck_enumerator_set_object_type          (GckEnumerator *self,
 
560
                                                               GType object_type);
 
561
 
 
562
GckEnumerator *       gck_enumerator_get_chained              (GckEnumerator *self);
 
563
 
 
564
void                  gck_enumerator_set_chained              (GckEnumerator *self,
 
565
                                                               GckEnumerator *chained);
 
566
 
 
567
GckObject *           gck_enumerator_next                     (GckEnumerator *self,
 
568
                                                               GCancellable *cancellable,
 
569
                                                               GError **error);
 
570
 
 
571
GList*                gck_enumerator_next_n                   (GckEnumerator *self,
 
572
                                                               gint max_objects,
 
573
                                                               GCancellable *cancellable,
 
574
                                                               GError **error);
 
575
 
 
576
void                  gck_enumerator_next_async               (GckEnumerator *self,
 
577
                                                               gint max_objects,
 
578
                                                               GCancellable *cancellable,
 
579
                                                               GAsyncReadyCallback callback,
 
580
                                                               gpointer user_data);
 
581
 
 
582
GList*                gck_enumerator_next_finish              (GckEnumerator *self,
 
583
                                                               GAsyncResult *result,
 
584
                                                               GError **error);
 
585
 
 
586
/* ------------------------------------------------------------------------
 
587
 * SLOT
 
588
 */
 
589
 
 
590
typedef struct _GckSlotInfo GckSlotInfo;
 
591
 
 
592
struct _GckSlotInfo {
 
593
        gchar *slot_description;
 
594
        gchar *manufacturer_id;
 
595
        gulong flags;
 
596
        guint8 hardware_version_major;
 
597
        guint8 hardware_version_minor;
 
598
        guint8 firmware_version_major;
 
599
        guint8 firmware_version_minor;
 
600
};
 
601
 
 
602
#define             GCK_TYPE_SLOT_INFO                      (gck_slot_info_get_type ())
 
603
 
 
604
GType               gck_slot_info_get_type                  (void) G_GNUC_CONST;
 
605
 
 
606
GckSlotInfo *       gck_slot_info_copy                      (GckSlotInfo *slot_info);
 
607
 
 
608
void                gck_slot_info_free                      (GckSlotInfo *slot_info);
 
609
 
 
610
typedef struct _GckTokenInfo GckTokenInfo;
 
611
 
 
612
struct _GckTokenInfo {
 
613
        gchar *label;
 
614
        gchar *manufacturer_id;
 
615
        gchar *model;
 
616
        gchar *serial_number;
 
617
        gulong flags;
 
618
        glong max_session_count;
 
619
        glong session_count;
 
620
        glong max_rw_session_count;
 
621
        glong rw_session_count;
 
622
        glong max_pin_len;
 
623
        glong min_pin_len;
 
624
        glong total_public_memory;
 
625
        glong free_public_memory;
 
626
        glong total_private_memory;
 
627
        glong free_private_memory;
 
628
        guint8 hardware_version_major;
 
629
        guint8 hardware_version_minor;
 
630
        guint8 firmware_version_major;
 
631
        guint8 firmware_version_minor;
 
632
        gint64 utc_time;
 
633
};
 
634
 
 
635
#define             GCK_TYPE_TOKEN_INFO                     (gck_token_info_get_type ())
 
636
 
 
637
GType               gck_token_info_get_type                 (void) G_GNUC_CONST;
 
638
 
 
639
GckTokenInfo *      gck_token_info_copy                     (GckTokenInfo *token_info);
 
640
 
 
641
void                gck_token_info_free                     (GckTokenInfo *token_info);
 
642
 
 
643
typedef struct _GckMechanismInfo GckMechanismInfo;
 
644
 
 
645
struct _GckMechanismInfo {
 
646
        gulong min_key_size;
 
647
        gulong max_key_size;
 
648
        gulong flags;
 
649
};
 
650
 
 
651
#define             GCK_TYPE_MECHANISM_INFO                 (gck_mechanism_info_get_type ())
 
652
 
 
653
GType               gck_mechanism_info_get_type             (void) G_GNUC_CONST;
 
654
 
 
655
GckMechanismInfo *  gck_mechanism_info_copy                 (GckMechanismInfo *mech_info);
 
656
 
 
657
void                gck_mechanism_info_free                 (GckMechanismInfo *mech_info);
 
658
 
 
659
#define             gck_mechanisms_length(a)                ((a)->len)
 
660
 
 
661
#define             gck_mechanisms_at(a, i)                 (g_array_index (a, CK_MECHANISM_TYPE, i))
 
662
 
 
663
gboolean            gck_mechanisms_check                    (GArray *mechanisms,
 
664
                                                             ...);
 
665
 
 
666
#define GCK_TYPE_SLOT             (gck_slot_get_type())
 
667
#define GCK_SLOT(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_SLOT, GckSlot))
 
668
#define GCK_SLOT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_SLOT, GckSlot))
 
669
#define GCK_IS_SLOT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_SLOT))
 
670
#define GCK_IS_SLOT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_SLOT))
 
671
#define GCK_SLOT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_SLOT, GckSlotClass))
 
672
 
 
673
typedef struct _GckSlotClass GckSlotClass;
 
674
typedef struct _GckSlotPrivate GckSlotPrivate;
 
675
 
 
676
struct _GckSlot {
 
677
        GObject parent;
 
678
 
 
679
        /*< private >*/
 
680
        GckSlotPrivate *pv;
 
681
        gpointer reserved[4];
 
682
};
 
683
 
 
684
struct _GckSlotClass {
 
685
        GObjectClass parent;
 
686
 
 
687
        /*< private >*/
 
688
        gpointer reserved[9];
 
689
};
 
690
 
 
691
GType               gck_slot_get_type                       (void) G_GNUC_CONST;
 
692
 
 
693
gboolean            gck_slot_equal                          (gconstpointer slot1,
 
694
                                                             gconstpointer slot2);
 
695
 
 
696
guint               gck_slot_hash                           (gconstpointer slot);
 
697
 
 
698
gboolean            gck_slot_match                          (GckSlot *self,
 
699
                                                             GckUriData *uri);
 
700
 
 
701
GckSlot*            gck_slot_from_handle                    (GckModule *module,
 
702
                                                             gulong slot_id);
 
703
 
 
704
GckModule*          gck_slot_get_module                     (GckSlot *self);
 
705
 
 
706
gulong              gck_slot_get_handle                     (GckSlot *self);
 
707
 
 
708
GckSlotInfo*        gck_slot_get_info                       (GckSlot *self);
 
709
 
 
710
GckTokenInfo*       gck_slot_get_token_info                 (GckSlot *self);
 
711
 
 
712
GArray *            gck_slot_get_mechanisms                 (GckSlot *self);
 
713
 
 
714
GckMechanismInfo*   gck_slot_get_mechanism_info             (GckSlot *self,
 
715
                                                             gulong mech_type);
 
716
 
 
717
gboolean            gck_slot_has_flags                      (GckSlot *self,
 
718
                                                             gulong flags);
 
719
 
 
720
GckSession*         gck_slot_open_session                   (GckSlot *self,
 
721
                                                             GckSessionOptions options,
 
722
                                                             GCancellable *cancellable,
 
723
                                                             GError **error);
 
724
 
 
725
GckSession*         gck_slot_open_session_full              (GckSlot *self,
 
726
                                                             GckSessionOptions options,
 
727
                                                             gulong pkcs11_flags,
 
728
                                                             gpointer app_data,
 
729
                                                             CK_NOTIFY notify,
 
730
                                                             GCancellable *cancellable,
 
731
                                                             GError **error);
 
732
 
 
733
void                gck_slot_open_session_async             (GckSlot *self,
 
734
                                                             GckSessionOptions options,
 
735
                                                             GCancellable *cancellable,
 
736
                                                             GAsyncReadyCallback callback,
 
737
                                                             gpointer user_data);
 
738
 
 
739
void                gck_slot_open_session_full_async        (GckSlot *self,
 
740
                                                             GckSessionOptions options,
 
741
                                                             gulong pkcs11_flags,
 
742
                                                             gpointer app_data,
 
743
                                                             CK_NOTIFY notify,
 
744
                                                             GCancellable *cancellable,
 
745
                                                             GAsyncReadyCallback callback,
 
746
                                                             gpointer user_data);
 
747
 
 
748
GckSession*         gck_slot_open_session_finish            (GckSlot *self,
 
749
                                                             GAsyncResult *result,
 
750
                                                             GError **error);
 
751
 
 
752
GckEnumerator *     gck_slot_enumerate_objects              (GckSlot *self,
 
753
                                                             GckAttributes *match,
 
754
                                                             GckSessionOptions options);
 
755
 
 
756
GckEnumerator*      gck_slots_enumerate_objects             (GList *slots,
 
757
                                                             GckAttributes *match,
 
758
                                                             GckSessionOptions options);
 
759
 
 
760
/* ------------------------------------------------------------------------
 
761
 * SESSION
 
762
 */
 
763
 
 
764
typedef struct _GckSessionInfo GckSessionInfo;
 
765
 
 
766
struct _GckSessionInfo {
 
767
        gulong slot_id;
 
768
        gulong state;
 
769
        gulong flags;
 
770
        gulong device_error;
 
771
};
 
772
 
 
773
#define             GCK_TYPE_SESSION_INFO                  (gck_session_info_get_type ())
 
774
 
 
775
GType               gck_session_info_get_type              (void) G_GNUC_CONST;
 
776
 
 
777
GckSessionInfo *    gck_session_info_copy                  (GckSessionInfo *session_info);
 
778
 
 
779
void                gck_session_info_free                  (GckSessionInfo *session_info);
 
780
 
 
781
#define GCK_TYPE_SESSION             (gck_session_get_type())
 
782
#define GCK_SESSION(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_SESSION, GckSession))
 
783
#define GCK_SESSION_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_SESSION, GckSession))
 
784
#define GCK_IS_SESSION(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_SESSION))
 
785
#define GCK_IS_SESSION_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_SESSION))
 
786
#define GCK_SESSION_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_SESSION, GckSessionClass))
 
787
 
 
788
typedef struct _GckSessionClass GckSessionClass;
 
789
typedef struct _GckSessionPrivate GckSessionPrivate;
 
790
 
 
791
struct _GckSession {
 
792
        GObject parent;
 
793
 
 
794
        /*< private >*/
 
795
        GckSessionPrivate *pv;
 
796
        gpointer reserved[4];
 
797
};
 
798
 
 
799
struct _GckSessionClass {
 
800
        GObjectClass parent;
 
801
 
 
802
        gboolean (*discard_handle) (GckSession *session, CK_SESSION_HANDLE handle);
 
803
 
 
804
        /*< private >*/
 
805
        gpointer reserved[8];
 
806
};
 
807
 
 
808
GType               gck_session_get_type                    (void) G_GNUC_CONST;
 
809
 
 
810
GckSession *        gck_session_from_handle                 (GckSlot *slot,
 
811
                                                             gulong session_handle,
 
812
                                                             GckSessionOptions options);
 
813
 
 
814
GckModule*          gck_session_get_module                  (GckSession *self);
 
815
 
 
816
GckSlot*            gck_session_get_slot                    (GckSession *self);
 
817
 
 
818
gulong              gck_session_get_handle                  (GckSession *self);
 
819
 
 
820
GckSessionInfo*     gck_session_get_info                    (GckSession *self);
 
821
 
 
822
gulong              gck_session_get_state                   (GckSession *self);
 
823
 
 
824
GckSessionOptions   gck_session_get_options                 (GckSession *self);
 
825
 
 
826
GTlsInteraction *   gck_session_get_interaction             (GckSession *self);
 
827
 
 
828
void                gck_session_set_interaction             (GckSession *self,
 
829
                                                             GTlsInteraction *interaction);
 
830
 
 
831
GckSession *        gck_session_open                        (GckSlot *slot,
 
832
                                                             GckSessionOptions options,
 
833
                                                             GTlsInteraction *interaction,
 
834
                                                             GCancellable *cancellable,
 
835
                                                             GError **error);
 
836
 
 
837
void                gck_session_open_async                  (GckSlot *slot,
 
838
                                                             GckSessionOptions options,
 
839
                                                             GTlsInteraction *interaction,
 
840
                                                             GCancellable *cancellable,
 
841
                                                             GAsyncReadyCallback callback,
 
842
                                                             gpointer user_data);
 
843
 
 
844
GckSession *        gck_session_open_finish                 (GAsyncResult *result,
 
845
                                                             GError **error);
 
846
 
 
847
gboolean            gck_session_init_pin                    (GckSession *self,
 
848
                                                             const guchar *pin,
 
849
                                                             gsize n_pin,
 
850
                                                             GCancellable *cancellable,
 
851
                                                             GError **error);
 
852
 
 
853
void                gck_session_init_pin_async              (GckSession *self,
 
854
                                                             const guchar *pin,
 
855
                                                             gsize n_pin,
 
856
                                                             GCancellable *cancellable,
 
857
                                                             GAsyncReadyCallback callback,
 
858
                                                             gpointer user_data);
 
859
 
 
860
gboolean            gck_session_init_pin_finish             (GckSession *self,
 
861
                                                             GAsyncResult *result,
 
862
                                                             GError **error);
 
863
 
 
864
gboolean            gck_session_set_pin                     (GckSession *self,
 
865
                                                             const guchar *old_pin,
 
866
                                                             gsize n_old_pin,
 
867
                                                             const guchar *new_pin,
 
868
                                                             gsize n_new_pin,
 
869
                                                             GCancellable *cancellable,
 
870
                                                             GError **error);
 
871
 
 
872
void                gck_session_set_pin_async               (GckSession *self,
 
873
                                                             const guchar *old_pin,
 
874
                                                             gsize n_old_pin,
 
875
                                                             const guchar *new_pin,
 
876
                                                             gsize n_new_pin,
 
877
                                                             GCancellable *cancellable,
 
878
                                                             GAsyncReadyCallback callback,
 
879
                                                             gpointer user_data);
 
880
 
 
881
gboolean            gck_session_set_pin_finish              (GckSession *self,
 
882
                                                             GAsyncResult *result,
 
883
                                                             GError **error);
 
884
 
 
885
gboolean            gck_session_login                       (GckSession *self,
 
886
                                                             gulong user_type,
 
887
                                                             const guchar *pin,
 
888
                                                             gsize n_pin,
 
889
                                                             GCancellable *cancellable,
 
890
                                                             GError **error);
 
891
 
 
892
void                gck_session_login_async                 (GckSession *self,
 
893
                                                             gulong user_type,
 
894
                                                             const guchar *pin,
 
895
                                                             gsize n_pin,
 
896
                                                             GCancellable *cancellable,
 
897
                                                             GAsyncReadyCallback callback,
 
898
                                                             gpointer user_data);
 
899
 
 
900
gboolean            gck_session_login_finish                (GckSession *self,
 
901
                                                             GAsyncResult *result,
 
902
                                                             GError **error);
 
903
 
 
904
gboolean            gck_session_login_interactive           (GckSession *self,
 
905
                                                             gulong user_type,
 
906
                                                             GTlsInteraction *interaction,
 
907
                                                             GCancellable *cancellable,
 
908
                                                             GError **error);
 
909
 
 
910
void                gck_session_login_interactive_async     (GckSession *self,
 
911
                                                             gulong user_type,
 
912
                                                             GTlsInteraction *interaction,
 
913
                                                             GCancellable *cancellable,
 
914
                                                             GAsyncReadyCallback callback,
 
915
                                                             gpointer user_data);
 
916
 
 
917
gboolean            gck_session_login_interactive_finish    (GckSession *self,
 
918
                                                             GAsyncResult *result,
 
919
                                                             GError **error);
 
920
 
 
921
gboolean            gck_session_logout                      (GckSession *self,
 
922
                                                             GCancellable *cancellable,
 
923
                                                             GError **error);
 
924
 
 
925
void                gck_session_logout_async                (GckSession *self,
 
926
                                                             GCancellable *cancellable,
 
927
                                                             GAsyncReadyCallback callback,
 
928
                                                             gpointer user_data);
 
929
 
 
930
gboolean            gck_session_logout_finish               (GckSession *self,
 
931
                                                             GAsyncResult *result,
 
932
                                                             GError **error);
 
933
 
 
934
GckObject*          gck_session_create_object               (GckSession *self,
 
935
                                                             GckAttributes *attrs,
 
936
                                                             GCancellable *cancellable,
 
937
                                                             GError **error);
 
938
 
 
939
void                gck_session_create_object_async         (GckSession *self,
 
940
                                                             GckAttributes *attrs,
 
941
                                                             GCancellable *cancellable,
 
942
                                                             GAsyncReadyCallback callback,
 
943
                                                             gpointer user_data);
 
944
 
 
945
GckObject*          gck_session_create_object_finish        (GckSession *self,
 
946
                                                             GAsyncResult *result,
 
947
                                                             GError **error);
 
948
 
 
949
GList*              gck_session_find_objects                (GckSession *self,
 
950
                                                             GckAttributes *match,
 
951
                                                             GCancellable *cancellable,
 
952
                                                             GError **error);
 
953
 
 
954
void                gck_session_find_objects_async          (GckSession *self,
 
955
                                                             GckAttributes *match,
 
956
                                                             GCancellable *cancellable,
 
957
                                                             GAsyncReadyCallback callback,
 
958
                                                             gpointer user_data);
 
959
 
 
960
GList*              gck_session_find_objects_finish         (GckSession *self,
 
961
                                                             GAsyncResult *result,
 
962
                                                             GError **error);
 
963
 
 
964
gulong *            gck_session_find_handles                (GckSession *self,
 
965
                                                             GckAttributes *match,
 
966
                                                             GCancellable *cancellable,
 
967
                                                             gulong *n_handles,
 
968
                                                             GError **error);
 
969
 
 
970
void                gck_session_find_handles_async          (GckSession *self,
 
971
                                                             GckAttributes *match,
 
972
                                                             GCancellable *cancellable,
 
973
                                                             GAsyncReadyCallback callback,
 
974
                                                             gpointer user_data);
 
975
 
 
976
gulong *            gck_session_find_handles_finish         (GckSession *self,
 
977
                                                             GAsyncResult *result,
 
978
                                                             gulong *n_handles,
 
979
                                                             GError **error);
 
980
 
 
981
GckEnumerator *     gck_session_enumerate_objects           (GckSession *self,
 
982
                                                             GckAttributes *match);
 
983
 
 
984
gboolean            gck_session_generate_key_pair           (GckSession *self,
 
985
                                                             gulong mech_type,
 
986
                                                             GckAttributes *public_attrs,
 
987
                                                             GckAttributes *private_attrs,
 
988
                                                             GckObject **public_key,
 
989
                                                             GckObject **private_key,
 
990
                                                             GCancellable *cancellable,
 
991
                                                             GError **error);
 
992
 
 
993
gboolean            gck_session_generate_key_pair_full      (GckSession *self,
 
994
                                                             GckMechanism *mechanism,
 
995
                                                             GckAttributes *public_attrs,
 
996
                                                             GckAttributes *private_attrs,
 
997
                                                             GckObject **public_key,
 
998
                                                             GckObject **private_key,
 
999
                                                             GCancellable *cancellable,
 
1000
                                                             GError **error);
 
1001
 
 
1002
void                gck_session_generate_key_pair_async     (GckSession *self,
 
1003
                                                             GckMechanism *mechanism,
 
1004
                                                             GckAttributes *public_attrs,
 
1005
                                                             GckAttributes *private_attrs,
 
1006
                                                             GCancellable *cancellable,
 
1007
                                                             GAsyncReadyCallback callback,
 
1008
                                                             gpointer user_data);
 
1009
 
 
1010
gboolean            gck_session_generate_key_pair_finish    (GckSession *self,
 
1011
                                                             GAsyncResult *result,
 
1012
                                                             GckObject **public_key,
 
1013
                                                             GckObject **private_key,
 
1014
                                                             GError **error);
 
1015
 
 
1016
guchar*             gck_session_encrypt                      (GckSession *self,
 
1017
                                                              GckObject *key,
 
1018
                                                              gulong mech_type,
 
1019
                                                              const guchar *input,
 
1020
                                                              gsize n_input,
 
1021
                                                              gsize *n_result,
 
1022
                                                              GCancellable *cancellable,
 
1023
                                                              GError **error);
 
1024
 
 
1025
guchar*             gck_session_encrypt_full                 (GckSession *self,
 
1026
                                                              GckObject *key,
 
1027
                                                              GckMechanism *mechanism,
 
1028
                                                              const guchar *input,
 
1029
                                                              gsize n_input,
 
1030
                                                              gsize *n_result,
 
1031
                                                              GCancellable *cancellable,
 
1032
                                                              GError **error);
 
1033
 
 
1034
void                gck_session_encrypt_async                (GckSession *self,
 
1035
                                                              GckObject *key,
 
1036
                                                              GckMechanism *mechanism,
 
1037
                                                              const guchar *input,
 
1038
                                                              gsize n_input,
 
1039
                                                              GCancellable *cancellable,
 
1040
                                                              GAsyncReadyCallback callback,
 
1041
                                                              gpointer user_data);
 
1042
 
 
1043
guchar*             gck_session_encrypt_finish               (GckSession *self,
 
1044
                                                              GAsyncResult *result,
 
1045
                                                              gsize *n_result,
 
1046
                                                              GError **error);
 
1047
 
 
1048
guchar*             gck_session_decrypt                      (GckSession *self,
 
1049
                                                              GckObject *key,
 
1050
                                                              gulong mech_type,
 
1051
                                                              const guchar *input,
 
1052
                                                              gsize n_input,
 
1053
                                                              gsize *n_result,
 
1054
                                                              GCancellable *cancellable,
 
1055
                                                              GError **error);
 
1056
 
 
1057
guchar*             gck_session_decrypt_full                 (GckSession *self,
 
1058
                                                              GckObject *key,
 
1059
                                                              GckMechanism *mechanism,
 
1060
                                                              const guchar *input,
 
1061
                                                              gsize n_input,
 
1062
                                                              gsize *n_result,
 
1063
                                                              GCancellable *cancellable,
 
1064
                                                              GError **error);
 
1065
 
 
1066
void                gck_session_decrypt_async                (GckSession *self,
 
1067
                                                              GckObject *key,
 
1068
                                                              GckMechanism *mechanism,
 
1069
                                                              const guchar *input,
 
1070
                                                              gsize n_input,
 
1071
                                                              GCancellable *cancellable,
 
1072
                                                              GAsyncReadyCallback callback,
 
1073
                                                              gpointer user_data);
 
1074
 
 
1075
guchar*             gck_session_decrypt_finish               (GckSession *self,
 
1076
                                                              GAsyncResult *result,
 
1077
                                                              gsize *n_result,
 
1078
                                                              GError **error);
 
1079
 
 
1080
guchar*             gck_session_sign                         (GckSession *self,
 
1081
                                                              GckObject *key,
 
1082
                                                              gulong mech_type,
 
1083
                                                              const guchar *input,
 
1084
                                                              gsize n_input,
 
1085
                                                              gsize *n_result,
 
1086
                                                              GCancellable *cancellable,
 
1087
                                                              GError **error);
 
1088
 
 
1089
guchar*             gck_session_sign_full                    (GckSession *self,
 
1090
                                                              GckObject *key,
 
1091
                                                              GckMechanism *mechanism,
 
1092
                                                              const guchar *input,
 
1093
                                                              gsize n_input,
 
1094
                                                              gsize *n_result,
 
1095
                                                              GCancellable *cancellable,
 
1096
                                                              GError **error);
 
1097
 
 
1098
void                gck_session_sign_async                   (GckSession *self,
 
1099
                                                              GckObject *key,
 
1100
                                                              GckMechanism *mechanism,
 
1101
                                                              const guchar *input,
 
1102
                                                              gsize n_input,
 
1103
                                                              GCancellable *cancellable,
 
1104
                                                              GAsyncReadyCallback callback,
 
1105
                                                              gpointer user_data);
 
1106
 
 
1107
guchar*             gck_session_sign_finish                  (GckSession *self,
 
1108
                                                              GAsyncResult *result,
 
1109
                                                              gsize *n_result,
 
1110
                                                              GError **error);
 
1111
 
 
1112
gboolean            gck_session_verify                       (GckSession *self,
 
1113
                                                              GckObject *key,
 
1114
                                                              gulong mech_type,
 
1115
                                                              const guchar *input,
 
1116
                                                              gsize n_input,
 
1117
                                                              const guchar *signature,
 
1118
                                                              gsize n_signature,
 
1119
                                                              GCancellable *cancellable,
 
1120
                                                              GError **error);
 
1121
 
 
1122
gboolean            gck_session_verify_full                  (GckSession *self,
 
1123
                                                              GckObject *key,
 
1124
                                                              GckMechanism *mechanism,
 
1125
                                                              const guchar *input,
 
1126
                                                              gsize n_input,
 
1127
                                                              const guchar *signature,
 
1128
                                                              gsize n_signature,
 
1129
                                                              GCancellable *cancellable,
 
1130
                                                              GError **error);
 
1131
 
 
1132
void                gck_session_verify_async                 (GckSession *self,
 
1133
                                                              GckObject *key,
 
1134
                                                              GckMechanism *mechanism,
 
1135
                                                              const guchar *input,
 
1136
                                                              gsize n_input,
 
1137
                                                              const guchar *signature,
 
1138
                                                              gsize n_signature,
 
1139
                                                              GCancellable *cancellable,
 
1140
                                                              GAsyncReadyCallback callback,
 
1141
                                                              gpointer user_data);
 
1142
 
 
1143
gboolean            gck_session_verify_finish                (GckSession *self,
 
1144
                                                              GAsyncResult *result,
 
1145
                                                              GError **error);
 
1146
 
 
1147
guchar *            gck_session_wrap_key                     (GckSession *self,
 
1148
                                                              GckObject *wrapper,
 
1149
                                                              gulong mech_type,
 
1150
                                                              GckObject *wrapped,
 
1151
                                                              gsize *n_result,
 
1152
                                                              GCancellable *cancellable,
 
1153
                                                              GError **error);
 
1154
 
 
1155
guchar *            gck_session_wrap_key_full                (GckSession *self,
 
1156
                                                              GckObject *wrapper,
 
1157
                                                              GckMechanism *mechanism,
 
1158
                                                              GckObject *wrapped,
 
1159
                                                              gsize *n_result,
 
1160
                                                              GCancellable *cancellable,
 
1161
                                                              GError **error);
 
1162
 
 
1163
void                gck_session_wrap_key_async               (GckSession *self,
 
1164
                                                              GckObject *wrapper,
 
1165
                                                              GckMechanism *mechanism,
 
1166
                                                              GckObject *wrapped,
 
1167
                                                              GCancellable *cancellable,
 
1168
                                                              GAsyncReadyCallback callback,
 
1169
                                                              gpointer user_data);
 
1170
 
 
1171
guchar *            gck_session_wrap_key_finish              (GckSession *self,
 
1172
                                                              GAsyncResult *result,
 
1173
                                                              gsize *n_result,
 
1174
                                                              GError **error);
 
1175
 
 
1176
GckObject*          gck_session_unwrap_key                   (GckSession *self,
 
1177
                                                              GckObject *wrapper,
 
1178
                                                              gulong mech_type,
 
1179
                                                              const guchar *input,
 
1180
                                                              gsize n_input,
 
1181
                                                              GckAttributes *attrs,
 
1182
                                                              GCancellable *cancellable,
 
1183
                                                              GError **error);
 
1184
 
 
1185
GckObject*          gck_session_unwrap_key_full              (GckSession *self,
 
1186
                                                              GckObject *wrapper,
 
1187
                                                              GckMechanism *mechanism,
 
1188
                                                              const guchar *input,
 
1189
                                                              gsize n_input,
 
1190
                                                              GckAttributes *attrs,
 
1191
                                                              GCancellable *cancellable,
 
1192
                                                              GError **error);
 
1193
 
 
1194
void                gck_session_unwrap_key_async             (GckSession *self,
 
1195
                                                              GckObject *wrapper,
 
1196
                                                              GckMechanism *mechanism,
 
1197
                                                              const guchar *input,
 
1198
                                                              gsize n_input,
 
1199
                                                              GckAttributes *attrs,
 
1200
                                                              GCancellable *cancellable,
 
1201
                                                              GAsyncReadyCallback callback,
 
1202
                                                              gpointer user_data);
 
1203
 
 
1204
GckObject*          gck_session_unwrap_key_finish            (GckSession *self,
 
1205
                                                              GAsyncResult *result,
 
1206
                                                              GError **error);
 
1207
 
 
1208
GckObject*          gck_session_derive_key                   (GckSession *self,
 
1209
                                                              GckObject *base,
 
1210
                                                              gulong mech_type,
 
1211
                                                              GckAttributes *attrs,
 
1212
                                                              GCancellable *cancellable,
 
1213
                                                              GError **error);
 
1214
 
 
1215
GckObject*          gck_session_derive_key_full              (GckSession *self,
 
1216
                                                              GckObject *base,
 
1217
                                                              GckMechanism *mechanism,
 
1218
                                                              GckAttributes *attrs,
 
1219
                                                              GCancellable *cancellable,
 
1220
                                                              GError **error);
 
1221
 
 
1222
void                gck_session_derive_key_async             (GckSession *self,
 
1223
                                                              GckObject *base,
 
1224
                                                              GckMechanism *mechanism,
 
1225
                                                              GckAttributes *attrs,
 
1226
                                                              GCancellable *cancellable,
 
1227
                                                              GAsyncReadyCallback callback,
 
1228
                                                              gpointer user_data);
 
1229
 
 
1230
GckObject*          gck_session_derive_key_finish            (GckSession *self,
 
1231
                                                              GAsyncResult *result,
 
1232
                                                              GError **error);
 
1233
 
 
1234
/* ------------------------------------------------------------------------
 
1235
 * OBJECT
 
1236
 */
 
1237
 
 
1238
#define GCK_TYPE_OBJECT             (gck_object_get_type())
 
1239
#define GCK_OBJECT(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_OBJECT, GckObject))
 
1240
#define GCK_OBJECT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_OBJECT, GckObjectClass))
 
1241
#define GCK_IS_OBJECT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_OBJECT))
 
1242
#define GCK_IS_OBJECT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_OBJECT))
 
1243
#define GCK_OBJECT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_OBJECT, GckObjectClass))
 
1244
 
 
1245
typedef struct _GckObjectClass GckObjectClass;
 
1246
typedef struct _GckObjectPrivate GckObjectPrivate;
 
1247
 
 
1248
struct _GckObject {
 
1249
        GObject parent;
 
1250
 
 
1251
        /*< private >*/
 
1252
        GckObjectPrivate *pv;
 
1253
        gpointer reserved[4];
 
1254
};
 
1255
 
 
1256
struct _GckObjectClass {
 
1257
        GObjectClass parent;
 
1258
 
 
1259
        /*< private >*/
 
1260
        gpointer reserved[8];
 
1261
};
 
1262
 
 
1263
GType               gck_object_get_type                     (void) G_GNUC_CONST;
 
1264
 
 
1265
GckObject *         gck_object_from_handle                  (GckSession *session,
 
1266
                                                             gulong object_handle);
 
1267
 
 
1268
GList*              gck_objects_from_handle_array           (GckSession *session,
 
1269
                                                             gulong *object_handles,
 
1270
                                                             gulong n_object_handles);
 
1271
 
 
1272
gboolean            gck_object_equal                        (gconstpointer object1,
 
1273
                                                             gconstpointer object2);
 
1274
 
 
1275
guint               gck_object_hash                         (gconstpointer object);
 
1276
 
 
1277
GckModule*          gck_object_get_module                   (GckObject *self);
 
1278
 
 
1279
gulong              gck_object_get_handle                   (GckObject *self);
 
1280
 
 
1281
GckSession*         gck_object_get_session                  (GckObject *self);
 
1282
 
 
1283
gboolean            gck_object_destroy                      (GckObject *self,
 
1284
                                                             GCancellable *cancellable,
 
1285
                                                             GError **error);
 
1286
 
 
1287
void                gck_object_destroy_async                (GckObject *self,
 
1288
                                                             GCancellable *cancellable,
 
1289
                                                             GAsyncReadyCallback callback,
 
1290
                                                             gpointer user_data);
 
1291
 
 
1292
gboolean            gck_object_destroy_finish               (GckObject *self,
 
1293
                                                             GAsyncResult *result,
 
1294
                                                             GError **error);
 
1295
 
 
1296
gboolean            gck_object_set                          (GckObject *self,
 
1297
                                                             GckAttributes *attrs,
 
1298
                                                             GCancellable *cancellable,
 
1299
                                                             GError **error);
 
1300
 
 
1301
void                gck_object_set_async                    (GckObject *self,
 
1302
                                                             GckAttributes *attrs,
 
1303
                                                             GCancellable *cancellable,
 
1304
                                                             GAsyncReadyCallback callback,
 
1305
                                                             gpointer user_data);
 
1306
 
 
1307
gboolean            gck_object_set_finish                   (GckObject *self,
 
1308
                                                             GAsyncResult *result,
 
1309
                                                             GError **error);
 
1310
 
 
1311
GckAttributes*      gck_object_get                          (GckObject *self,
 
1312
                                                             GCancellable *cancellable,
 
1313
                                                             GError **error,
 
1314
                                                             ...);
 
1315
 
 
1316
GckAttributes*      gck_object_get_full                     (GckObject *self,
 
1317
                                                             const gulong *attr_types,
 
1318
                                                             guint n_attr_types,
 
1319
                                                             GCancellable *cancellable,
 
1320
                                                             GError **error);
 
1321
 
 
1322
void                gck_object_get_async                    (GckObject *self,
 
1323
                                                             const gulong *attr_types,
 
1324
                                                             guint n_attr_types,
 
1325
                                                             GCancellable *cancellable,
 
1326
                                                             GAsyncReadyCallback callback,
 
1327
                                                             gpointer user_data);
 
1328
 
 
1329
GckAttributes*      gck_object_get_finish                   (GckObject *self,
 
1330
                                                             GAsyncResult *result,
 
1331
                                                             GError **error);
 
1332
 
 
1333
guchar *            gck_object_get_data                     (GckObject *self,
 
1334
                                                             gulong attr_type,
 
1335
                                                             GCancellable *cancellable,
 
1336
                                                             gsize *n_data,
 
1337
                                                             GError **error);
 
1338
 
 
1339
guchar *            gck_object_get_data_full                (GckObject *self,
 
1340
                                                             gulong attr_type,
 
1341
                                                             GckAllocator allocator,
 
1342
                                                             GCancellable *cancellable,
 
1343
                                                             gsize *n_data,
 
1344
                                                             GError **error);
 
1345
 
 
1346
void                gck_object_get_data_async               (GckObject *self,
 
1347
                                                             gulong attr_type,
 
1348
                                                             GckAllocator allocator,
 
1349
                                                             GCancellable *cancellable,
 
1350
                                                             GAsyncReadyCallback callback,
 
1351
                                                             gpointer user_data);
 
1352
 
 
1353
guchar *            gck_object_get_data_finish              (GckObject *self,
 
1354
                                                             GAsyncResult *result,
 
1355
                                                             gsize *n_data,
 
1356
                                                             GError **error);
 
1357
 
 
1358
gboolean            gck_object_set_template                 (GckObject *self,
 
1359
                                                             gulong attr_type,
 
1360
                                                             GckAttributes *attrs,
 
1361
                                                             GCancellable *cancellable,
 
1362
                                                             GError **error);
 
1363
 
 
1364
void                gck_object_set_template_async           (GckObject *self,
 
1365
                                                             gulong attr_type,
 
1366
                                                             GckAttributes *attrs,
 
1367
                                                             GCancellable *cancellable,
 
1368
                                                             GAsyncReadyCallback callback,
 
1369
                                                             gpointer user_data);
 
1370
 
 
1371
gboolean            gck_object_set_template_finish          (GckObject *self,
 
1372
                                                             GAsyncResult *result,
 
1373
                                                             GError **error);
 
1374
 
 
1375
GckAttributes*      gck_object_get_template                 (GckObject *self,
 
1376
                                                             gulong attr_type,
 
1377
                                                             GCancellable *cancellable,
 
1378
                                                             GError **error);
 
1379
 
 
1380
void                gck_object_get_template_async           (GckObject *self,
 
1381
                                                             gulong attr_type,
 
1382
                                                             GCancellable *cancellable,
 
1383
                                                             GAsyncReadyCallback callback,
 
1384
                                                             gpointer user_data);
 
1385
 
 
1386
GckAttributes*      gck_object_get_template_finish          (GckObject *self,
 
1387
                                                             GAsyncResult *result,
 
1388
                                                             GError **error);
 
1389
 
 
1390
/* ------------------------------------------------------------------------
 
1391
 * OBJECT ATTRIBUTES
 
1392
 */
 
1393
 
 
1394
#define GCK_TYPE_OBJECT_CACHE                    (gck_object_cache_get_type ())
 
1395
#define GCK_OBJECT_CACHE(obj)                    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCK_TYPE_OBJECT_CACHE, GckObjectCache))
 
1396
#define GCK_IS_OBJECT_CACHE(obj)                 (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GCK_TYPE_OBJECT_CACHE))
 
1397
#define GCK_OBJECT_CACHE_GET_INTERFACE(inst)     (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GCK_TYPE_OBJECT_CACHE, GckObjectCacheIface))
 
1398
 
 
1399
typedef struct _GckObjectCacheIface GckObjectCacheIface;
 
1400
 
 
1401
struct _GckObjectCacheIface {
 
1402
        GTypeInterface interface;
 
1403
 
 
1404
        const gulong *  default_types;
 
1405
        gint            n_default_types;
 
1406
 
 
1407
        void         (* fill)                              (GckObjectCache *object,
 
1408
                                                            GckAttributes *attrs);
 
1409
 
 
1410
        /*< private >*/
 
1411
        gpointer reserved[6];
 
1412
};
 
1413
 
 
1414
GType               gck_object_cache_get_type              (void) G_GNUC_CONST;
 
1415
 
 
1416
GckAttributes *     gck_object_cache_get_attributes        (GckObjectCache *object);
 
1417
 
 
1418
void                gck_object_cache_set_attributes        (GckObjectCache *object,
 
1419
                                                            GckAttributes *attrs);
 
1420
 
 
1421
void                gck_object_cache_fill                  (GckObjectCache *object,
 
1422
                                                            GckAttributes *attrs);
 
1423
 
 
1424
gboolean            gck_object_cache_update                (GckObjectCache *object,
 
1425
                                                            const gulong *attr_types,
 
1426
                                                            gint n_attr_types,
 
1427
                                                            GCancellable *cancellable,
 
1428
                                                            GError **error);
 
1429
 
 
1430
void                gck_object_cache_update_async          (GckObjectCache *object,
 
1431
                                                            const gulong *attr_types,
 
1432
                                                            gint n_attr_types,
 
1433
                                                            GCancellable *cancellable,
 
1434
                                                            GAsyncReadyCallback callback,
 
1435
                                                            gpointer user_data);
 
1436
 
 
1437
gboolean            gck_object_cache_update_finish         (GckObjectCache *object,
 
1438
                                                            GAsyncResult *result,
 
1439
                                                            GError **error);
 
1440
 
 
1441
GckAttributes *     gck_object_cache_lookup                (GckObject *object,
 
1442
                                                            const gulong *attr_types,
 
1443
                                                            gint n_attr_types,
 
1444
                                                            GCancellable *cancellable,
 
1445
                                                            GError **error);
 
1446
 
 
1447
void                gck_object_cache_lookup_async          (GckObject *object,
 
1448
                                                            const gulong *attr_types,
 
1449
                                                            gint n_attr_types,
 
1450
                                                            GCancellable *cancellable,
 
1451
                                                            GAsyncReadyCallback callback,
 
1452
                                                            gpointer user_data);
 
1453
 
 
1454
GckAttributes *     gck_object_cache_lookup_finish         (GckObject *object,
 
1455
                                                            GAsyncResult *result,
 
1456
                                                            GError **error);
 
1457
 
 
1458
/* ------------------------------------------------------------------------
 
1459
 * PASSWORD
 
1460
 */
 
1461
 
 
1462
#define GCK_TYPE_PASSWORD             (gck_password_get_type ())
 
1463
#define GCK_PASSWORD(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCK_TYPE_PASSWORD, GckPassword))
 
1464
#define GCK_PASSWORD_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GCK_TYPE_PASSWORD, GckPassword))
 
1465
#define GCK_IS_PASSWORD(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GCK_TYPE_PASSWORD))
 
1466
#define GCK_IS_PASSWORD_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GCK_TYPE_PASSWORD))
 
1467
#define GCK_PASSWORD_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GCK_TYPE_PASSWORD, GckPasswordClass))
 
1468
 
 
1469
typedef struct _GckPassword GckPassword;
 
1470
typedef struct _GckPasswordClass GckPasswordClass;
 
1471
typedef struct _GckPasswordPrivate GckPasswordPrivate;
 
1472
 
 
1473
struct _GckPassword {
 
1474
        GTlsPassword parent;
 
1475
 
 
1476
        /*< private >*/
 
1477
        GckPasswordPrivate *pv;
 
1478
        gpointer reserved[4];
 
1479
};
 
1480
 
 
1481
struct _GckPasswordClass {
 
1482
        GTlsPasswordClass parent;
 
1483
 
 
1484
        /*< private >*/
 
1485
        gpointer reserved[4];
 
1486
};
 
1487
 
 
1488
GType               gck_password_get_type                   (void) G_GNUC_CONST;
 
1489
 
 
1490
GckModule *         gck_password_get_module                 (GckPassword *self);
 
1491
 
 
1492
GckSlot *           gck_password_get_token                  (GckPassword *self);
 
1493
 
 
1494
GckObject *         gck_password_get_key                    (GckPassword *self);
 
1495
 
 
1496
/* ----------------------------------------------------------------------------
 
1497
 * URI
 
1498
 */
 
1499
 
 
1500
typedef enum {
 
1501
        GCK_URI_BAD_SCHEME = 1,
 
1502
        GCK_URI_BAD_ENCODING,
 
1503
        GCK_URI_BAD_SYNTAX,
 
1504
        GCK_URI_BAD_VERSION,
 
1505
        GCK_URI_NOT_FOUND
 
1506
} GckUriError;
 
1507
 
 
1508
/* WARNING: Don't modify these without syncing with p11-kit */
 
1509
typedef enum {
 
1510
        GCK_URI_FOR_OBJECT =  (1 << 1),
 
1511
        GCK_URI_FOR_TOKEN =   (1 << 2),
 
1512
        GCK_URI_FOR_MODULE =  (1 << 3),
 
1513
        GCK_URI_WITH_VERSION = (1 << 4),
 
1514
        GCK_URI_FOR_ANY =     0x0000FFFF,
 
1515
} GckUriFlags;
 
1516
 
 
1517
#define             GCK_URI_FOR_MODULE_WITH_VERSION         (GCK_URI_WITH_VERSION | GCK_URI_FOR_MODULE)
 
1518
 
 
1519
#define             GCK_URI_FOR_OBJECT_ON_TOKEN             (GCK_URI_FOR_OBJECT | GCK_URI_FOR_TOKEN)
 
1520
 
 
1521
#define             GCK_URI_FOR_OBJECT_ON_TOKEN_AND_MODULE  (GCK_URI_FOR_OBJECT_ON_TOKEN | GCK_URI_FOR_MODULE)
 
1522
 
 
1523
struct _GckUriData {
 
1524
        gboolean any_unrecognized;
 
1525
        GckModuleInfo *module_info;
 
1526
        GckTokenInfo *token_info;
 
1527
        GckAttributes *attributes;
 
1528
 
 
1529
        /*< private >*/
 
1530
        gpointer dummy[4];
 
1531
};
 
1532
 
 
1533
#define             GCK_URI_ERROR                           (gck_uri_error_get_quark ())
 
1534
 
 
1535
GQuark              gck_uri_error_get_quark                 (void) G_GNUC_CONST;
 
1536
 
 
1537
GckUriData*         gck_uri_data_new                        (void);
 
1538
 
 
1539
gchar*              gck_uri_build                           (GckUriData *uri_data,
 
1540
                                                             GckUriFlags flags);
 
1541
 
 
1542
GckUriData*         gck_uri_parse                           (const gchar *string,
 
1543
                                                             GckUriFlags flags,
 
1544
                                                             GError **error);
 
1545
 
 
1546
#define             GCK_URI_DATA_TYPE                       (gck_uri_data_get_type ())
 
1547
 
 
1548
GType               gck_uri_data_get_type                   (void) G_GNUC_CONST;
 
1549
 
 
1550
GckUriData *        gck_uri_data_copy                       (GckUriData *uri_data);
 
1551
 
 
1552
void                gck_uri_data_free                       (GckUriData *uri_data);
 
1553
 
 
1554
G_END_DECLS
 
1555
 
 
1556
#include "gck-deprecated.h"
 
1557
 
 
1558
#undef __GCK_INSIDE_HEADER__
 
1559
 
 
1560
#endif /* GCK_H */