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