diff options
| author | Corentin Noël <corentin.noel@collabora.com> | 2021-09-17 08:49:45 +0200 |
|---|---|---|
| committer | Corentin Noël <corentin.noel@collabora.com> | 2021-11-16 22:44:25 +0100 |
| commit | 326347deae82aab89406a21e99ed82d5a2061908 (patch) | |
| tree | 8cb39321b4ac8c11f1c74d12b15030e6457b6a27 | |
| parent | 0319ca16692d8432045d689772904a826effd8c9 (diff) | |
| download | gcr-tintou/several-headers.tar.gz | |
gck: Separate each object into their own headerstintou/several-headers
| -rw-r--r-- | gck/gck-attributes.h | 364 | ||||
| -rw-r--r-- | gck/gck-deprecated.h | 4 | ||||
| -rw-r--r-- | gck/gck-enumerator.c | 4 | ||||
| -rw-r--r-- | gck/gck-enumerator.h | 92 | ||||
| -rw-r--r-- | gck/gck-module.h | 154 | ||||
| -rw-r--r-- | gck/gck-modules.c | 2 | ||||
| -rw-r--r-- | gck/gck-object-cache.h | 88 | ||||
| -rw-r--r-- | gck/gck-object.h | 182 | ||||
| -rw-r--r-- | gck/gck-password.h | 60 | ||||
| -rw-r--r-- | gck/gck-session.h | 499 | ||||
| -rw-r--r-- | gck/gck-slot.c | 2 | ||||
| -rw-r--r-- | gck/gck-slot.h | 206 | ||||
| -rw-r--r-- | gck/gck-uri.h | 80 | ||||
| -rw-r--r-- | gck/gck.h | 1572 | ||||
| -rw-r--r-- | gck/gck.pc.in | 2 | ||||
| -rw-r--r-- | gck/meson.build | 10 |
16 files changed, 1756 insertions, 1565 deletions
diff --git a/gck/gck-attributes.h b/gck/gck-attributes.h new file mode 100644 index 0000000..e13303c --- /dev/null +++ b/gck/gck-attributes.h @@ -0,0 +1,364 @@ +/* + * Copyright 2008, Stefan Walter <nielsen@memberwebs.com> + * + * SPDX-License-Identifier: LGPL-2.0-or-later + */ + +#ifndef __GCK_ATTRIBUTES_H__ +#define __GCK_ATTRIBUTES_H__ + +#if !defined (__GCK_INSIDE_HEADER__) && !defined (GCK_COMPILATION) +#error "Only <gck/gck.h> can be included directly." +#endif + +#include <glib-object.h> +#include <p11-kit/p11-kit.h> + +G_BEGIN_DECLS + + +#define GCK_VENDOR_CODE 0x47434B00 /* GCK */ + +/* An error code which results from a failure to load the PKCS11 module */ +typedef enum { + GCK_ERROR_MODULE_PROBLEM = (CKR_VENDOR_DEFINED | (GCK_VENDOR_CODE + 1)), +} GckError; + +#define GCK_ERROR (gck_error_get_quark ()) + +GQuark gck_error_get_quark (void) G_GNUC_CONST; + +#define GCK_TYPE_LIST (gck_list_get_boxed_type ()) + +GType gck_list_get_boxed_type (void) G_GNUC_CONST; + +GList* gck_list_ref_copy (GList *reflist); + +void gck_list_unref_free (GList *reflist); + +const gchar* gck_message_from_rv (gulong rv); + +gboolean gck_string_to_chars (guchar *data, + gsize max, + const gchar *string); + +gchar* gck_string_from_chars (const guchar *data, + gsize max); + +typedef gpointer (*GckAllocator) (gpointer data, gsize length); + +typedef enum { + GCK_SESSION_READ_ONLY = 0, + GCK_SESSION_READ_WRITE = 1 << 1, + GCK_SESSION_LOGIN_USER = 1 << 2, + GCK_SESSION_AUTHENTICATE = 1 << 3, +} GckSessionOptions; + +typedef struct _GckMechanism GckMechanism; + +struct _GckMechanism { + gulong type; + gconstpointer parameter; + gulong n_parameter; +}; + +typedef struct _GckAttribute GckAttribute; + +struct _GckAttribute { + gulong type; + guchar *value; + gulong length; +}; + +#define GCK_INVALID ((gulong)-1) + +gboolean gck_value_to_ulong (const guchar *value, + gsize length, + gulong *result); + +gboolean gck_value_to_boolean (const guchar *value, + gsize length, + gboolean *result); + +void gck_attribute_init (GckAttribute *attr, + gulong attr_type, + const guchar *value, + gsize length); + +void gck_attribute_init_invalid (GckAttribute *attr, + gulong attr_type); + +void gck_attribute_init_empty (GckAttribute *attr, + gulong attr_type); + +void gck_attribute_init_boolean (GckAttribute *attr, + gulong attr_type, + gboolean value); + +void gck_attribute_init_date (GckAttribute *attr, + gulong attr_type, + const GDate *value); + +void gck_attribute_init_ulong (GckAttribute *attr, + gulong attr_type, + gulong value); + +void gck_attribute_init_string (GckAttribute *attr, + gulong attr_type, + const gchar *value); + +void gck_attribute_init_copy (GckAttribute *dest, + const GckAttribute *src); + +#define GCK_TYPE_ATTRIBUTE (gck_attribute_get_type ()) + +GType gck_attribute_get_type (void) G_GNUC_CONST; + +GckAttribute* gck_attribute_new (gulong attr_type, + const guchar *value, + gsize length); + +GckAttribute* gck_attribute_new_invalid (gulong attr_type); + +GckAttribute* gck_attribute_new_empty (gulong attr_type); + +GckAttribute* gck_attribute_new_boolean (gulong attr_type, + gboolean value); + +GckAttribute* gck_attribute_new_date (gulong attr_type, + const GDate *value); + +GckAttribute* gck_attribute_new_ulong (gulong attr_type, + gulong value); + +GckAttribute* gck_attribute_new_string (gulong attr_type, + const gchar *value); + +gboolean gck_attribute_is_invalid (const GckAttribute *attr); + +gboolean gck_attribute_get_boolean (const GckAttribute *attr); + +gulong gck_attribute_get_ulong (const GckAttribute *attr); + +gchar* gck_attribute_get_string (const GckAttribute *attr); + +void gck_attribute_get_date (const GckAttribute *attr, + GDate* value); + +const guchar * gck_attribute_get_data (const GckAttribute *attr, + gsize *length); + +gboolean gck_attribute_equal (gconstpointer attr1, + gconstpointer attr2); + +guint gck_attribute_hash (gconstpointer attr); + +GckAttribute* gck_attribute_dup (const GckAttribute *attr); + +void gck_attribute_clear (GckAttribute *attr); + +void gck_attribute_free (gpointer attr); + +void gck_attribute_dump (const GckAttribute *attr); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckAttribute, gck_attribute_free); + +typedef struct _GckBuilder GckBuilder; + +struct _GckBuilder { + /*< private >*/ + gsize x[16]; +}; + +typedef enum { + GCK_BUILDER_NONE, + GCK_BUILDER_SECURE_MEMORY = 1, +} GckBuilderFlags; + +typedef struct _GckAttributes GckAttributes; + +GckBuilder * gck_builder_new (GckBuilderFlags flags); + +#define GCK_BUILDER_INIT { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } + +GckBuilder * gck_builder_ref (GckBuilder *builder); + +void gck_builder_unref (gpointer builder); + +void gck_builder_init (GckBuilder *builder); + +void gck_builder_init_full (GckBuilder *builder, + GckBuilderFlags flags); + +#define GCK_TYPE_BUILDER (gck_builder_get_type ()) + +GType gck_builder_get_type (void) G_GNUC_CONST; + +void gck_builder_take_data (GckBuilder *builder, + gulong attr_type, + guchar *value, + gsize length); + +void gck_builder_add_data (GckBuilder *builder, + gulong attr_type, + const guchar *value, + gsize length); + +void gck_builder_add_empty (GckBuilder *builder, + gulong attr_type); + +void gck_builder_add_invalid (GckBuilder *builder, + gulong attr_type); + +void gck_builder_add_ulong (GckBuilder *builder, + gulong attr_type, + gulong value); + +void gck_builder_add_boolean (GckBuilder *builder, + gulong attr_type, + gboolean value); + +void gck_builder_add_date (GckBuilder *builder, + gulong attr_type, + const GDate *value); + +void gck_builder_add_string (GckBuilder *builder, + gulong attr_type, + const gchar *value); + +void gck_builder_add_attribute (GckBuilder *builder, + const GckAttribute *attr); + +void gck_builder_add_all (GckBuilder *builder, + GckAttributes *attrs); + +void gck_builder_add_only (GckBuilder *builder, + GckAttributes *attrs, + gulong only_type, + ...); + +void gck_builder_add_onlyv (GckBuilder *builder, + GckAttributes *attrs, + const gulong *only_types, + guint n_only_types); + +void gck_builder_add_except (GckBuilder *builder, + GckAttributes *attrs, + gulong except_type, + ...); + +void gck_builder_add_exceptv (GckBuilder *builder, + GckAttributes *attrs, + const gulong *except_types, + guint n_except_types); + +void gck_builder_set_data (GckBuilder *builder, + gulong attr_type, + const guchar *value, + gsize length); + +void gck_builder_set_empty (GckBuilder *builder, + gulong attr_type); + +void gck_builder_set_invalid (GckBuilder *builder, + gulong attr_type); + +void gck_builder_set_ulong (GckBuilder *builder, + gulong attr_type, + gulong value); + +void gck_builder_set_boolean (GckBuilder *builder, + gulong attr_type, + gboolean value); + +void gck_builder_set_date (GckBuilder *builder, + gulong attr_type, + const GDate *value); + +void gck_builder_set_string (GckBuilder *builder, + gulong attr_type, + const gchar *value); + +void gck_builder_set_all (GckBuilder *builder, + GckAttributes *attrs); + +const GckAttribute * gck_builder_find (GckBuilder *builder, + gulong attr_type); + +gboolean gck_builder_find_boolean (GckBuilder *builder, + gulong attr_type, + gboolean *value); + +gboolean gck_builder_find_ulong (GckBuilder *builder, + gulong attr_type, + gulong *value); + +gboolean gck_builder_find_string (GckBuilder *builder, + gulong attr_type, + gchar **value); + +gboolean gck_builder_find_date (GckBuilder *builder, + gulong attr_type, + GDate *value); + +GckAttributes * gck_builder_steal (GckBuilder *builder); + +GckAttributes * gck_builder_end (GckBuilder *builder); + +GckBuilder * gck_builder_copy (GckBuilder *builder); + +void gck_builder_clear (GckBuilder *builder); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckBuilder, gck_builder_unref); + +#define GCK_TYPE_ATTRIBUTES (gck_attributes_get_type ()) + +GType gck_attributes_get_type (void) G_GNUC_CONST; + +GckAttributes * gck_attributes_new (gulong reserved); + +GckAttributes * gck_attributes_new_empty (gulong first_type, + ...); + +const GckAttribute * gck_attributes_at (GckAttributes *attrs, + guint index); + +const GckAttribute * gck_attributes_find (GckAttributes *attrs, + gulong attr_type); + +gboolean gck_attributes_find_boolean (GckAttributes *attrs, + gulong attr_type, + gboolean *value); + +gboolean gck_attributes_find_ulong (GckAttributes *attrs, + gulong attr_type, + gulong *value); + +gboolean gck_attributes_find_string (GckAttributes *attrs, + gulong attr_type, + gchar **value); + +gboolean gck_attributes_find_date (GckAttributes *attrs, + gulong attr_type, + GDate *value); + +gulong gck_attributes_count (GckAttributes *attrs); + +GckAttributes * gck_attributes_ref (GckAttributes *attrs); + +GckAttributes * gck_attributes_ref_sink (GckAttributes *attrs); + +void gck_attributes_unref (gpointer attrs); + +gboolean gck_attributes_contains (GckAttributes *attrs, + const GckAttribute *match); + +void gck_attributes_dump (GckAttributes *attrs); + +gchar * gck_attributes_to_string (GckAttributes *attrs); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckAttributes, gck_attributes_unref); + +G_END_DECLS + +#endif /* __GCK_ATTRIBUTES_H__ */ diff --git a/gck/gck-deprecated.h b/gck/gck-deprecated.h index 029ab7e..b82affa 100644 --- a/gck/gck-deprecated.h +++ b/gck/gck-deprecated.h @@ -23,7 +23,9 @@ #ifndef GCK_DEPRECATED_H #define GCK_DEPRECATED_H -#include "gck.h" +#include <glib.h> +#include <gck/gck.h> +#include <gck/gck-attributes.h> G_BEGIN_DECLS diff --git a/gck/gck-enumerator.c b/gck/gck-enumerator.c index c1b82ee..18df07d 100644 --- a/gck/gck-enumerator.c +++ b/gck/gck-enumerator.c @@ -22,10 +22,12 @@ #include "config.h" -#include "gck.h" +#include "gck-enumerator.h" +#include "gck-attributes.h" #include "gck-private.h" #include <string.h> +#include <p11-kit/pkcs11.h> /** * GckEnumerator: diff --git a/gck/gck-enumerator.h b/gck/gck-enumerator.h new file mode 100644 index 0000000..092df49 --- /dev/null +++ b/gck/gck-enumerator.h @@ -0,0 +1,92 @@ +/* + * Copyright 2008, Stefan Walter <nielsen@memberwebs.com> + * + * SPDX-License-Identifier: LGPL-2.0-or-later + */ + +#ifndef __GCK_ENUMERATOR_H__ +#define __GCK_ENUMERATOR_H__ + +#if !defined (__GCK_INSIDE_HEADER__) && !defined (GCK_COMPILATION) +#error "Only <gck/gck.h> can be included directly." +#endif + +#include <glib-object.h> +#include <gio/gio.h> + +#include <gck/gck-object.h> + +G_BEGIN_DECLS + +#define GCK_TYPE_ENUMERATOR (gck_enumerator_get_type()) +#define GCK_ENUMERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_ENUMERATOR, GckEnumerator)) +#define GCK_ENUMERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_ENUMERATOR, GckEnumerator)) +#define GCK_IS_ENUMERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_ENUMERATOR)) +#define GCK_IS_ENUMERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_ENUMERATOR)) +#define GCK_ENUMERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_ENUMERATOR, GckEnumeratorClass)) + +typedef struct _GckEnumerator GckEnumerator; +typedef struct _GckEnumeratorClass GckEnumeratorClass; +typedef struct _GckEnumeratorPrivate GckEnumeratorPrivate; + +struct _GckEnumerator { + GObject parent; + + /*< private >*/ + GckEnumeratorPrivate *pv; + gpointer reserved[2]; +}; + +struct _GckEnumeratorClass { + GObjectClass parent; + + /*< private >*/ + gpointer reserved[2]; +}; + +GType gck_enumerator_get_type (void) G_GNUC_CONST; + +GTlsInteraction * gck_enumerator_get_interaction (GckEnumerator *self); + +void gck_enumerator_set_interaction (GckEnumerator *self, + GTlsInteraction *interaction); + +GType gck_enumerator_get_object_type (GckEnumerator *self); + +void gck_enumerator_set_object_type (GckEnumerator *self, + GType object_type); + +void gck_enumerator_set_object_type_full (GckEnumerator *self, + GType object_type, + const gulong *attr_types, + gint attr_count); + +GckEnumerator * gck_enumerator_get_chained (GckEnumerator *self); + +void gck_enumerator_set_chained (GckEnumerator *self, + GckEnumerator *chained); + +GckObject * gck_enumerator_next (GckEnumerator *self, + GCancellable *cancellable, + GError **error); + +GList* gck_enumerator_next_n (GckEnumerator *self, + gint max_objects, + GCancellable *cancellable, + GError **error); + +void gck_enumerator_next_async (GckEnumerator *self, + gint max_objects, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GList* gck_enumerator_next_finish (GckEnumerator *self, + GAsyncResult *result, + GError **error); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckEnumerator, g_object_unref); + +G_END_DECLS + +#endif /* __GCK_ENUMERATOR_H__ */ diff --git a/gck/gck-module.h b/gck/gck-module.h new file mode 100644 index 0000000..4ec366c --- /dev/null +++ b/gck/gck-module.h @@ -0,0 +1,154 @@ +/* + * Copyright 2008, Stefan Walter <nielsen@memberwebs.com> + * + * SPDX-License-Identifier: LGPL-2.0-or-later + */ + +#ifndef __GCK_MODULE_H__ +#define __GCK_MODULE_H__ + +#if !defined (__GCK_INSIDE_HEADER__) && !defined (GCK_COMPILATION) +#error "Only <gck/gck.h> can be included directly." +#endif + +#include <glib-object.h> +#include <gio/gio.h> + +#include <gck/gck-object.h> +#include <gck/gck-slot.h> +#include <gck/gck-attributes.h> +#include <gck/gck-enumerator.h> + +G_BEGIN_DECLS + +typedef struct _GckModuleInfo GckModuleInfo; + +struct _GckModuleInfo { + guint8 pkcs11_version_major; + guint8 pkcs11_version_minor; + + gchar *manufacturer_id; + gulong flags; + + gchar *library_description; + guint8 library_version_major; + guint8 library_version_minor; +}; + +#define GCK_TYPE_MODULE_INFO (gck_module_info_get_type ()) + +GType gck_module_info_get_type (void) G_GNUC_CONST; + +GckModuleInfo * gck_module_info_copy (GckModuleInfo *module_info); + +void gck_module_info_free (GckModuleInfo *module_info); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckModuleInfo, gck_module_info_free); + +#define GCK_TYPE_MODULE (gck_module_get_type()) +#define GCK_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_MODULE, GckModule)) +#define GCK_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_MODULE, GckModule)) +#define GCK_IS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_MODULE)) +#define GCK_IS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_MODULE)) +#define GCK_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_MODULE, GckModuleClass)) + +typedef struct _GckModuleClass GckModuleClass; +typedef struct _GckModulePrivate GckModulePrivate; + +struct _GckModule { + GObject parent; + + /*< private >*/ + GckModulePrivate *pv; + gpointer reserved[4]; +}; + +struct _GckModuleClass { + GObjectClass parent; + + gboolean (*authenticate_slot) (GckModule *self, GckSlot *slot, gchar *label, gchar **password); + + gboolean (*authenticate_object) (GckModule *self, GckObject *object, gchar *label, gchar **password); + + /*< private >*/ + gpointer reserved[8]; +}; + +GType gck_module_get_type (void) G_GNUC_CONST; + +GckModule* gck_module_new (CK_FUNCTION_LIST_PTR funcs); + +GckModule* gck_module_initialize (const gchar *path, + GCancellable *cancellable, + GError **error); + +void gck_module_initialize_async (const gchar *path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GckModule * gck_module_initialize_finish (GAsyncResult *result, + GError **error); + +gboolean gck_module_equal (gconstpointer module1, + gconstpointer module2); + +guint gck_module_hash (gconstpointer module); + +gboolean gck_module_match (GckModule *self, + GckUriData *uri); + +const gchar* gck_module_get_path (GckModule *self); + +CK_FUNCTION_LIST_PTR gck_module_get_functions (GckModule *self); + +GckModuleInfo* gck_module_get_info (GckModule *self); + +GList* gck_module_get_slots (GckModule *self, + gboolean token_present); + +GList* gck_modules_initialize_registered (GCancellable *cancellable, + GError **error); + +void gck_modules_initialize_registered_async (GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GList * gck_modules_initialize_registered_finish (GAsyncResult *result, + GError **error); + +GList* gck_modules_get_slots (GList *modules, + gboolean token_present); + +GckEnumerator* gck_modules_enumerate_objects (GList *modules, + GckAttributes *attrs, + GckSessionOptions session_options); + +GckSlot* gck_modules_token_for_uri (GList *modules, + const gchar *uri, + GError **error); + +GList * gck_modules_tokens_for_uri (GList *modules, + const gchar *uri, + GError **error); + +GckObject* gck_modules_object_for_uri (GList *modules, + const gchar *uri, + GckSessionOptions session_options, + GError **error); + +GList* gck_modules_objects_for_uri (GList *modules, + const gchar *uri, + GckSessionOptions session_options, + GError **error); + +GckEnumerator* gck_modules_enumerate_uri (GList *modules, + const gchar *uri, + GckSessionOptions session_options, + GError **error); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckModule, g_object_unref); + +G_END_DECLS + +#endif /* __GCK_MODULE_H__ */ diff --git a/gck/gck-modules.c b/gck/gck-modules.c index 97d7f01..d82592e 100644 --- a/gck/gck-modules.c +++ b/gck/gck-modules.c @@ -22,7 +22,7 @@ #include "config.h" -#include "gck.h" +#include "gck-module.h" #include "gck-private.h" #include "gck/gck-marshal.h" diff --git a/gck/gck-object-cache.h b/gck/gck-object-cache.h new file mode 100644 index 0000000..97df286 --- /dev/null +++ b/gck/gck-object-cache.h @@ -0,0 +1,88 @@ +/* + * Copyright 2008, Stefan Walter <nielsen@memberwebs.com> + * + * SPDX-License-Identifier: LGPL-2.0-or-later + */ + +#ifndef __GCK_OBJECT_CACHE_H__ +#define __GCK_OBJECT_CACHE_H__ + +#if !defined (__GCK_INSIDE_HEADER__) && !defined (GCK_COMPILATION) +#error "Only <gck/gck.h> can be included directly." +#endif + +#include <glib-object.h> +#include <gio/gio.h> + +G_BEGIN_DECLS + +#define GCK_TYPE_OBJECT_CACHE (gck_object_cache_get_type ()) +#define GCK_OBJECT_CACHE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCK_TYPE_OBJECT_CACHE, GckObjectCache)) +#define GCK_IS_OBJECT_CACHE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GCK_TYPE_OBJECT_CACHE)) +#define GCK_OBJECT_CACHE_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GCK_TYPE_OBJECT_CACHE, GckObjectCacheIface)) + +typedef struct _GckObjectCache GckObjectCache; +typedef struct _GckObjectCacheIface GckObjectCacheIface; + +struct _GckObjectCacheIface { + GTypeInterface interface; + + const gulong * default_types; + gint n_default_types; + + void (* fill) (GckObjectCache *object, + GckAttributes *attrs); + + /*< private >*/ + gpointer reserved[6]; +}; + +GType gck_object_cache_get_type (void) G_GNUC_CONST; + +GckAttributes * gck_object_cache_get_attributes (GckObjectCache *object); + +void gck_object_cache_set_attributes (GckObjectCache *object, + GckAttributes *attrs); + +void gck_object_cache_fill (GckObjectCache *object, + GckAttributes *attrs); + +gboolean gck_object_cache_update (GckObjectCache *object, + const gulong *attr_types, + gint n_attr_types, + GCancellable *cancellable, + GError **error); + +void gck_object_cache_update_async (GckObjectCache *object, + const gulong *attr_types, + gint n_attr_types, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean gck_object_cache_update_finish (GckObjectCache *object, + GAsyncResult *result, + GError **error); + +GckAttributes * gck_object_cache_lookup (GckObject *object, + const gulong *attr_types, + gint n_attr_types, + GCancellable *cancellable, + GError **error); + +void gck_object_cache_lookup_async (GckObject *object, + const gulong *attr_types, + gint n_attr_types, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GckAttributes * gck_object_cache_lookup_finish (GckObject *object, + GAsyncResult *result, + GError **error); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckObjectCache, g_object_unref); + +G_END_DECLS + +#endif /* __GCK_OBJECT_CACHE_H__ */ diff --git a/gck/gck-object.h b/gck/gck-object.h new file mode 100644 index 0000000..f80e457 --- /dev/null +++ b/gck/gck-object.h @@ -0,0 +1,182 @@ +/* + * Copyright 2008, Stefan Walter <nielsen@memberwebs.com> + * + * SPDX-License-Identifier: LGPL-2.0-or-later + */ + +#ifndef __GCK_OBJECT_H__ +#define __GCK_OBJECT_H__ + +#if !defined (__GCK_INSIDE_HEADER__) && !defined (GCK_COMPILATION) +#error "Only <gck/gck.h> can be included directly." +#endif + +#include <glib-object.h> +#include <gio/gio.h> + +#include <gck/gck-attributes.h> + +G_BEGIN_DECLS + +/* FORWARD DECLARATIONS */ +typedef struct _GckModule GckModule; +typedef struct _GckSession GckSession; + +#define GCK_TYPE_OBJECT (gck_object_get_type()) +#define GCK_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_OBJECT, GckObject)) +#define GCK_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_OBJECT, GckObjectClass)) +#define GCK_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_OBJECT)) +#define GCK_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_OBJECT)) +#define GCK_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_OBJECT, GckObjectClass)) + +typedef struct _GckObject GckObject; +typedef struct _GckObjectClass GckObjectClass; +typedef struct _GckObjectPrivate GckObjectPrivate; + +struct _GckObject { + GObject parent; + + /*< private >*/ + GckObjectPrivate *pv; + gpointer reserved[4]; +}; + +struct _GckObjectClass { + GObjectClass parent; + + /*< private >*/ + gpointer reserved[8]; +}; + +GType gck_object_get_type (void) G_GNUC_CONST; + +GckObject * gck_object_from_handle (GckSession *session, + gulong object_handle); + +GList* gck_objects_from_handle_array (GckSession *session, + gulong *object_handles, + gulong n_object_handles); + +gboolean gck_object_equal (gconstpointer object1, + gconstpointer object2); + +guint gck_object_hash (gconstpointer object); + +GckModule* gck_object_get_module (GckObject *self); + +gulong gck_object_get_handle (GckObject *self); + +GckSession* gck_object_get_session (GckObject *self); + +gboolean gck_object_destroy (GckObject *self, + GCancellable *cancellable, + GError **error); + +void gck_object_destroy_async (GckObject *self, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean gck_object_destroy_finish (GckObject *self, + GAsyncResult *result, + GError **error); + +gboolean gck_object_set (GckObject *self, + GckAttributes *attrs, + GCancellable *cancellable, + GError **error); + +void gck_object_set_async (GckObject *self, + GckAttributes *attrs, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean gck_object_set_finish (GckObject *self, + GAsyncResult *result, + GError **error); + +GckAttributes* gck_object_get (GckObject *self, + GCancellable *cancellable, + GError **error, + ...); + +GckAttributes* gck_object_get_full (GckObject *self, + const gulong *attr_types, + guint n_attr_types, + GCancellable *cancellable, + GError **error); + +void gck_object_get_async (GckObject *self, + const gulong *attr_types, + guint n_attr_types, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GckAttributes* gck_object_get_finish (GckObject *self, + GAsyncResult *result, + GError **error); + +guchar * gck_object_get_data (GckObject *self, + gulong attr_type, + GCancellable *cancellable, + gsize *n_data, + GError **error); + +guchar * gck_object_get_data_full (GckObject *self, + gulong attr_type, + GckAllocator allocator, + GCancellable *cancellable, + gsize *n_data, + GError **error); + +void gck_object_get_data_async (GckObject *self, + gulong attr_type, + GckAllocator allocator, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +guchar * gck_object_get_data_finish (GckObject *self, + GAsyncResult *result, + gsize *n_data, + GError **error); + +gboolean gck_object_set_template (GckObject *self, + gulong attr_type, + GckAttributes *attrs, + GCancellable *cancellable, + GError **error); + +void gck_object_set_template_async (GckObject *self, + gulong attr_type, + GckAttributes *attrs, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean gck_object_set_template_finish (GckObject *self, + GAsyncResult *result, + GError **error); + +GckAttributes* gck_object_get_template (GckObject *self, + gulong attr_type, + GCancellable *cancellable, + GError **error); + +void gck_object_get_template_async (GckObject *self, + gulong attr_type, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GckAttributes* gck_object_get_template_finish (GckObject *self, + GAsyncResult *result, + GError **error); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckObject, g_object_unref); + +G_END_DECLS + +#endif /* __GCK_OBJECT_H__ */ diff --git a/gck/gck-password.h b/gck/gck-password.h new file mode 100644 index 0000000..bf6889f --- /dev/null +++ b/gck/gck-password.h @@ -0,0 +1,60 @@ +/* + * Copyright 2008, Stefan Walter <nielsen@memberwebs.com> + * + * SPDX-License-Identifier: LGPL-2.0-or-later + */ + +#ifndef __GCK_PASSWORD_H__ +#define __GCK_PASSWORD_H__ + +#if !defined (__GCK_INSIDE_HEADER__) && !defined (GCK_COMPILATION) +#error "Only <gck/gck.h> can be included directly." +#endif + +#include <glib-object.h> + +#include <gck/gck-module.h> +#include <gck/gck-slot.h> +#include <gck/gck-object.h> + +G_BEGIN_DECLS + +#define GCK_TYPE_PASSWORD (gck_password_get_type ()) +#define GCK_PASSWORD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCK_TYPE_PASSWORD, GckPassword)) +#define GCK_PASSWORD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GCK_TYPE_PASSWORD, GckPassword)) +#define GCK_IS_PASSWORD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GCK_TYPE_PASSWORD)) +#define GCK_IS_PASSWORD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GCK_TYPE_PASSWORD)) +#define GCK_PASSWORD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GCK_TYPE_PASSWORD, GckPasswordClass)) + +typedef struct _GckPassword GckPassword; +typedef struct _GckPasswordClass GckPasswordClass; +typedef struct _GckPasswordPrivate GckPasswordPrivate; + +struct _GckPassword { + GTlsPassword parent; + + /*< private >*/ + GckPasswordPrivate *pv; + gpointer reserved[4]; +}; + +struct _GckPasswordClass { + GTlsPasswordClass parent; + + /*< private >*/ + gpointer reserved[4]; +}; + +GType gck_password_get_type (void) G_GNUC_CONST; + +GckModule * gck_password_get_module (GckPassword *self); + +GckSlot * gck_password_get_token (GckPassword *self); + +GckObject * gck_password_get_key (GckPassword *self); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckPassword, g_object_unref); + +G_END_DECLS + +#endif /* __GCK_PASSWORD_H__ */ diff --git a/gck/gck-session.h b/gck/gck-session.h new file mode 100644 index 0000000..481487d --- /dev/null +++ b/gck/gck-session.h @@ -0,0 +1,499 @@ +/* + * Copyright 2008, Stefan Walter <nielsen@memberwebs.com> + * + * SPDX-License-Identifier: LGPL-2.0-or-later + */ + +#ifndef __GCK_SESSION_H__ +#define __GCK_SESSION_H__ + +#if !defined (__GCK_INSIDE_HEADER__) && !defined (GCK_COMPILATION) +#error "Only <gck/gck.h> can be included directly." +#endif + +#include <glib-object.h> +#include <p11-kit/p11-kit.h> + +#include <gck/gck-object.h> +#include <gck/gck-slot.h> +#include <gck/gck-session.h> + +G_BEGIN_DECLS + +typedef struct _GckSessionInfo GckSessionInfo; + +struct _GckSessionInfo { + gulong slot_id; + gulong state; + gulong flags; + gulong device_error; +}; + +#define GCK_TYPE_SESSION_INFO (gck_session_info_get_type ()) + +GType gck_session_info_get_type (void) G_GNUC_CONST; + +GckSessionInfo * gck_session_info_copy (GckSessionInfo *session_info); + +void gck_session_info_free (GckSessionInfo *session_info); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckSessionInfo, gck_session_info_free); + +#define GCK_TYPE_SESSION (gck_session_get_type()) +#define GCK_SESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_SESSION, GckSession)) +#define GCK_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_SESSION, GckSession)) +#define GCK_IS_SESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_SESSION)) +#define GCK_IS_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_SESSION)) +#define GCK_SESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_SESSION, GckSessionClass)) + +typedef struct _GckSessionClass GckSessionClass; +typedef struct _GckSessionPrivate GckSessionPrivate; + +struct _GckSession { + GObject parent; + + /*< private >*/ + GckSessionPrivate *pv; + gpointer reserved[4]; +}; + +struct _GckSessionClass { + GObjectClass parent; + + gboolean (*discard_handle) (GckSession *session, CK_SESSION_HANDLE handle); + + /*< private >*/ + gpointer reserved[8]; +}; + +GType gck_session_get_type (void) G_GNUC_CONST; + +GckSession * gck_session_from_handle (GckSlot *slot, + gulong session_handle, + GckSessionOptions options); + +GckModule* gck_session_get_module (GckSession *self); + +GckSlot* gck_session_get_slot (GckSession *self); + +gulong gck_session_get_handle (GckSession *self); + +GckSessionInfo* gck_session_get_info (GckSession *self); + +gulong gck_session_get_state (GckSession *self); + +GckSessionOptions gck_session_get_options (GckSession *self); + +GTlsInteraction * gck_session_get_interaction (GckSession *self); + +void gck_session_set_interaction (GckSession *self, + GTlsInteraction *interaction); + +GckSession * gck_session_open (GckSlot *slot, + GckSessionOptions options, + GTlsInteraction *interaction, + GCancellable *cancellable, + GError **error); + +void gck_session_open_async (GckSlot *slot, + GckSessionOptions options, + GTlsInteraction *interaction, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GckSession * gck_session_open_finish (GAsyncResult *result, + GError **error); + +gboolean gck_session_init_pin (GckSession *self, + const guchar *pin, + gsize n_pin, + GCancellable *cancellable, + GError **error); + +void gck_session_init_pin_async (GckSession *self, + const guchar *pin, + gsize n_pin, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean gck_session_init_pin_finish (GckSession *self, + GAsyncResult *result, + GError **error); + +gboolean gck_session_set_pin (GckSession *self, + const guchar *old_pin, + gsize n_old_pin, + const guchar *new_pin, + gsize n_new_pin, + GCancellable *cancellable, + GError **error); + +void gck_session_set_pin_async (GckSession *self, + const guchar *old_pin, + gsize n_old_pin, + const guchar *new_pin, + gsize n_new_pin, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean gck_session_set_pin_finish (GckSession *self, + GAsyncResult *result, + GError **error); + +gboolean gck_session_login (GckSession *self, + gulong user_type, + const guchar *pin, + gsize n_pin, + GCancellable *cancellable, + GError **error); + +void gck_session_login_async (GckSession *self, + gulong user_type, + const guchar *pin, + gsize n_pin, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean gck_session_login_finish (GckSession *self, + GAsyncResult *result, + GError **error); + +gboolean gck_session_login_interactive (GckSession *self, + gulong user_type, + GTlsInteraction *interaction, + GCancellable *cancellable, + GError **error); + +void gck_session_login_interactive_async (GckSession *self, + gulong user_type, + GTlsInteraction *interaction, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean gck_session_login_interactive_finish (GckSession *self, + GAsyncResult *result, + GError **error); + +gboolean gck_session_logout (GckSession *self, + GCancellable *cancellable, + GError **error); + +void gck_session_logout_async (GckSession *self, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean gck_session_logout_finish (GckSession *self, + GAsyncResult *result, + GError **error); + +GckObject* gck_session_create_object (GckSession *self, + GckAttributes *attrs, + GCancellable *cancellable, + GError **error); + +void gck_session_create_object_async (GckSession *self, + GckAttributes *attrs, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GckObject* gck_session_create_object_finish (GckSession *self, + GAsyncResult *result, + GError **error); + +GList* gck_session_find_objects (GckSession *self, + GckAttributes *match, + GCancellable *cancellable, + GError **error); + +void gck_session_find_objects_async (GckSession *self, + GckAttributes *match, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GList* gck_session_find_objects_finish (GckSession *self, + GAsyncResult *result, + GError **error); + +gulong * gck_session_find_handles (GckSession *self, + GckAttributes *match, + GCancellable *cancellable, + gulong *n_handles, + GError **error); + +void gck_session_find_handles_async (GckSession *self, + GckAttributes *match, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gulong * gck_session_find_handles_finish (GckSession *self, + GAsyncResult *result, + gulong *n_handles, + GError **error); + +GckEnumerator * gck_session_enumerate_objects (GckSession *self, + GckAttributes *match); + +gboolean gck_session_generate_key_pair (GckSession *self, + gulong mech_type, + GckAttributes *public_attrs, + GckAttributes *private_attrs, + GckObject **public_key, + GckObject **private_key, + GCancellable *cancellable, + GError **error); + +gboolean gck_session_generate_key_pair_full (GckSession *self, + GckMechanism *mechanism, + GckAttributes *public_attrs, + GckAttributes *private_attrs, + GckObject **public_key, + GckObject **private_key, + GCancellable *cancellable, + GError **error); + +void gck_session_generate_key_pair_async (GckSession *self, + GckMechanism *mechanism, + GckAttributes *public_attrs, + GckAttributes *private_attrs, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean gck_session_generate_key_pair_finish (GckSession *self, + GAsyncResult *result, + GckObject **public_key, + GckObject **private_key, + GError **error); + +guchar* gck_session_encrypt (GckSession *self, + GckObject *key, + gulong mech_type, + const guchar *input, + gsize n_input, + gsize *n_result, + GCancellable *cancellable, + GError **error); + +guchar* gck_session_encrypt_full (GckSession *self, + GckObject *key, + GckMechanism *mechanism, + const guchar *input, + gsize n_input, + gsize *n_result, + GCancellable *cancellable, + GError **error); + +void gck_session_encrypt_async (GckSession *self, + GckObject *key, + GckMechanism *mechanism, + const guchar *input, + gsize n_input, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +guchar* gck_session_encrypt_finish (GckSession *self, + GAsyncResult *result, + gsize *n_result, + GError **error); + +guchar* gck_session_decrypt (GckSession *self, + GckObject *key, + gulong mech_type, + const guchar *input, + gsize n_input, + gsize *n_result, + GCancellable *cancellable, + GError **error); + +guchar* gck_session_decrypt_full (GckSession *self, + GckObject *key, + GckMechanism *mechanism, + const guchar *input, + gsize n_input, + gsize *n_result, + GCancellable *cancellable, + GError **error); + +void gck_session_decrypt_async (GckSession *self, + GckObject *key, + GckMechanism *mechanism, + const guchar *input, + gsize n_input, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +guchar* gck_session_decrypt_finish (GckSession *self, + GAsyncResult *result, + gsize *n_result, + GError **error); + +guchar* gck_session_sign (GckSession *self, + GckObject *key, + gulong mech_type, + const guchar *input, + gsize n_input, + gsize *n_result, + GCancellable *cancellable, + GError **error); + +guchar* gck_session_sign_full (GckSession *self, + GckObject *key, + GckMechanism *mechanism, + const guchar *input, + gsize n_input, + gsize *n_result, + GCancellable *cancellable, + GError **error); + +void gck_session_sign_async (GckSession *self, + GckObject *key, + GckMechanism *mechanism, + const guchar *input, + gsize n_input, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +guchar* gck_session_sign_finish (GckSession *self, + GAsyncResult *result, + gsize *n_result, + GError **error); + +gboolean gck_session_verify (GckSession *self, + GckObject *key, + gulong mech_type, + const guchar *input, + gsize n_input, + const guchar *signature, + gsize n_signature, + GCancellable *cancellable, + GError **error); + +gboolean gck_session_verify_full (GckSession *self, + GckObject *key, + GckMechanism *mechanism, + const guchar *input, + gsize n_input, + const guchar *signature, + gsize n_signature, + GCancellable *cancellable, + GError **error); + +void gck_session_verify_async (GckSession *self, + GckObject *key, + GckMechanism *mechanism, + const guchar *input, + gsize n_input, + const guchar *signature, + gsize n_signature, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean gck_session_verify_finish (GckSession *self, + GAsyncResult *result, + GError **error); + +guchar * gck_session_wrap_key (GckSession *self, + GckObject *wrapper, + gulong mech_type, + GckObject *wrapped, + gsize *n_result, + GCancellable *cancellable, + GError **error); + +guchar * gck_session_wrap_key_full (GckSession *self, + GckObject *wrapper, + GckMechanism *mechanism, + GckObject *wrapped, + gsize *n_result, + GCancellable *cancellable, + GError **error); + +void gck_session_wrap_key_async (GckSession *self, + GckObject *wrapper, + GckMechanism *mechanism, + GckObject *wrapped, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +guchar * gck_session_wrap_key_finish (GckSession *self, + GAsyncResult *result, + gsize *n_result, + GError **error); + +GckObject* gck_session_unwrap_key (GckSession *self, + GckObject *wrapper, + gulong mech_type, + const guchar *input, + gsize n_input, + GckAttributes *attrs, + GCancellable *cancellable, + GError **error); + +GckObject* gck_session_unwrap_key_full (GckSession *self, + GckObject *wrapper, + GckMechanism *mechanism, + const guchar *input, + gsize n_input, + GckAttributes *attrs, + GCancellable *cancellable, + GError **error); + +void gck_session_unwrap_key_async (GckSession *self, + GckObject *wrapper, + GckMechanism *mechanism, + const guchar *input, + gsize n_input, + GckAttributes *attrs, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GckObject* gck_session_unwrap_key_finish (GckSession *self, + GAsyncResult *result, + GError **error); + +GckObject* gck_session_derive_key (GckSession *self, + GckObject *base, + gulong mech_type, + GckAttributes *attrs, + GCancellable *cancellable, + GError **error); + +GckObject* gck_session_derive_key_full (GckSession *self, + GckObject *base, + GckMechanism *mechanism, + GckAttributes *attrs, + GCancellable *cancellable, + GError **error); + +void gck_session_derive_key_async (GckSession *self, + GckObject *base, + GckMechanism *mechanism, + GckAttributes *attrs, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GckObject* gck_session_derive_key_finish (GckSession *self, + GAsyncResult *result, + GError **error); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckSession, g_object_unref); + +G_END_DECLS + +#endif /* __GCK_SESSION_H__ */ diff --git a/gck/gck-slot.c b/gck/gck-slot.c index 8ec121e..d536997 100644 --- a/gck/gck-slot.c +++ b/gck/gck-slot.c @@ -22,7 +22,7 @@ #include "config.h" -#include "gck.h" +#include "gck-slot.h" #include "gck-private.h" #include "egg/egg-timegm.h" diff --git a/gck/gck-slot.h b/gck/gck-slot.h new file mode 100644 index 0000000..776f638 --- /dev/null +++ b/gck/gck-slot.h @@ -0,0 +1,206 @@ +/* + * Copyright 2008, Stefan Walter <nielsen@memberwebs.com> + * + * SPDX-License-Identifier: LGPL-2.0-or-later + */ + +#ifndef __GCK_SLOT_H__ +#define __GCK_SLOT_H__ + +#if !defined (__GCK_INSIDE_HEADER__) && !defined (GCK_COMPILATION) +#error "Only <gck/gck.h> can be included directly." +#endif + +#include <glib-object.h> +#include <gio/gio.h> +#include <p11-kit/p11-kit.h> + +#include <gck/gck-enumerator.h> + +G_BEGIN_DECLS + +/* FORWARD DECLARATION */ +typedef struct _GckUriData GckUriData; + +typedef struct _GckSlotInfo GckSlotInfo; + +struct _GckSlotInfo { + gchar *slot_description; + gchar *manufacturer_id; + gulong flags; + guint8 hardware_version_major; + guint8 hardware_version_minor; + guint8 firmware_version_major; + guint8 firmware_version_minor; +}; + +#define GCK_TYPE_SLOT_INFO (gck_slot_info_get_type ()) + +GType gck_slot_info_get_type (void) G_GNUC_CONST; + +GckSlotInfo * gck_slot_info_copy (GckSlotInfo *slot_info); + +void gck_slot_info_free (GckSlotInfo *slot_info); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckSlotInfo, gck_slot_info_free); + +typedef struct _GckTokenInfo GckTokenInfo; + +struct _GckTokenInfo { + gchar *label; + gchar *manufacturer_id; + gchar *model; + gchar *serial_number; + gulong flags; + glong max_session_count; + glong session_count; + glong max_rw_session_count; + glong rw_session_count; + glong max_pin_len; + glong min_pin_len; + glong total_public_memory; + glong free_public_memory; + glong total_private_memory; + glong free_private_memory; + guint8 hardware_version_major; + guint8 hardware_version_minor; + guint8 firmware_version_major; + guint8 firmware_version_minor; + gint64 utc_time; +}; + +#define GCK_TYPE_TOKEN_INFO (gck_token_info_get_type ()) + +GType gck_token_info_get_type (void) G_GNUC_CONST; + +GckTokenInfo * gck_token_info_copy (GckTokenInfo *token_info); + +void gck_token_info_free (GckTokenInfo *token_info); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckTokenInfo, gck_token_info_free); + +typedef struct _GckMechanismInfo GckMechanismInfo; + +struct _GckMechanismInfo { + gulong min_key_size; + gulong max_key_size; + gulong flags; +}; + +#define GCK_TYPE_MECHANISM_INFO (gck_mechanism_info_get_type ()) + +GType gck_mechanism_info_get_type (void) G_GNUC_CONST; + +GckMechanismInfo * gck_mechanism_info_copy (GckMechanismInfo *mech_info); + +void gck_mechanism_info_free (GckMechanismInfo *mech_info); + +#define gck_mechanisms_length(a) ((a)->len) + +#define gck_mechanisms_at(a, i) (g_array_index (a, CK_MECHANISM_TYPE, i)) + +gboolean gck_mechanisms_check (GArray *mechanisms, + ...); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckMechanismInfo, gck_mechanism_info_free); + +#define GCK_TYPE_SLOT (gck_slot_get_type()) +#define GCK_SLOT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_SLOT, GckSlot)) +#define GCK_SLOT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_SLOT, GckSlot)) +#define GCK_IS_SLOT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_SLOT)) +#define GCK_IS_SLOT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_SLOT)) +#define GCK_SLOT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_SLOT, GckSlotClass)) + +typedef struct _GckSlot GckSlot; +typedef struct _GckSlotClass GckSlotClass; +typedef struct _GckSlotPrivate GckSlotPrivate; + +struct _GckSlot { + GObject parent; + + /*< private >*/ + GckSlotPrivate *pv; + gpointer reserved[4]; +}; + +struct _GckSlotClass { + GObjectClass parent; + + /*< private >*/ + gpointer reserved[9]; +}; + +GType gck_slot_get_type (void) G_GNUC_CONST; + +gboolean gck_slot_equal (gconstpointer slot1, + gconstpointer slot2); + +guint gck_slot_hash (gconstpointer slot); + +gboolean gck_slot_match (GckSlot *self, + GckUriData *uri); + +GckSlot* gck_slot_from_handle (GckModule *module, + gulong slot_id); + +GckModule* gck_slot_get_module (GckSlot *self); + +gulong gck_slot_get_handle (GckSlot *self); + +GckSlotInfo* gck_slot_get_info (GckSlot *self); + +GckTokenInfo* gck_slot_get_token_info (GckSlot *self); + +GArray * gck_slot_get_mechanisms (GckSlot *self); + +GckMechanismInfo* gck_slot_get_mechanism_info (GckSlot *self, + gulong mech_type); + +gboolean gck_slot_has_flags (GckSlot *self, + gulong flags); + +GckSession* gck_slot_open_session (GckSlot *self, + GckSessionOptions options, + GCancellable *cancellable, + GError **error); + +GckSession* gck_slot_open_session_full (GckSlot *self, + GckSessionOptions options, + gulong pkcs11_flags, + gpointer app_data, + CK_NOTIFY notify, + GCancellable *cancellable, + GError **error); + +void gck_slot_open_session_async (GckSlot *self, + GckSessionOptions options, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +void gck_slot_open_session_full_async (GckSlot *self, + GckSessionOptions options, + gulong pkcs11_flags, + gpointer app_data, + CK_NOTIFY notify, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +GckSession* gck_slot_open_session_finish (GckSlot *self, + GAsyncResult *result, + GError **error); + +GckEnumerator * gck_slot_enumerate_objects (GckSlot *self, + GckAttributes *match, + GckSessionOptions options); + +GckEnumerator* gck_slots_enumerate_objects (GList *slots, + GckAttributes *match, + GckSessionOptions options); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckSlot, g_object_unref); + +G_END_DECLS + +#endif /* __GCK_SLOT_H__ */ diff --git a/gck/gck-uri.h b/gck/gck-uri.h new file mode 100644 index 0000000..98970ca --- /dev/null +++ b/gck/gck-uri.h @@ -0,0 +1,80 @@ +/* + * Copyright 2008, Stefan Walter <nielsen@memberwebs.com> + * + * SPDX-License-Identifier: LGPL-2.0-or-later + */ + +#ifndef __GCK_URI_H__ +#define __GCK_URI_H__ + +#if !defined (__GCK_INSIDE_HEADER__) && !defined (GCK_COMPILATION) +#error "Only <gck/gck.h> can be included directly." +#endif + +#include <glib-object.h> + +#include <gck/gck-slot.h> +#include <gck/gck-module.h> +#include <gck/gck-attributes.h> + +G_BEGIN_DECLS + +typedef enum { + GCK_URI_BAD_SCHEME = 1, + GCK_URI_BAD_ENCODING, + GCK_URI_BAD_SYNTAX, + GCK_URI_BAD_VERSION, + GCK_URI_NOT_FOUND +} GckUriError; + +/* WARNING: Don't modify these without syncing with p11-kit */ +typedef enum { + GCK_URI_FOR_OBJECT = (1 << 1), + GCK_URI_FOR_TOKEN = (1 << 2), + GCK_URI_FOR_MODULE = (1 << 3), + GCK_URI_WITH_VERSION = (1 << 4), + GCK_URI_FOR_ANY = 0x0000FFFF, +} GckUriFlags; + +#define GCK_URI_FOR_MODULE_WITH_VERSION (GCK_URI_WITH_VERSION | GCK_URI_FOR_MODULE) + +#define GCK_URI_FOR_OBJECT_ON_TOKEN (GCK_URI_FOR_OBJECT | GCK_URI_FOR_TOKEN) + +#define GCK_URI_FOR_OBJECT_ON_TOKEN_AND_MODULE (GCK_URI_FOR_OBJECT_ON_TOKEN | GCK_URI_FOR_MODULE) + +struct _GckUriData { + gboolean any_unrecognized; + GckModuleInfo *module_info; + GckTokenInfo *token_info; + GckAttributes *attributes; + + /*< private >*/ + gpointer dummy[4]; +}; + +#define GCK_URI_ERROR (gck_uri_error_get_quark ()) + +GQuark gck_uri_error_get_quark (void) G_GNUC_CONST; + +GckUriData* gck_uri_data_new (void); + +gchar* gck_uri_build (GckUriData *uri_data, + GckUriFlags flags); + +GckUriData* gck_uri_parse (const gchar *string, + GckUriFlags flags, + GError **error); + +#define GCK_URI_DATA_TYPE (gck_uri_data_get_type ()) + +GType gck_uri_data_get_type (void) G_GNUC_CONST; + +GckUriData * gck_uri_data_copy (GckUriData *uri_data); + +void gck_uri_data_free (GckUriData *uri_data); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckUriData, gck_uri_data_free); + +G_END_DECLS + +#endif /* __GCK_URI_H__ */ @@ -23,19 +23,8 @@ #ifndef GCK_H #define GCK_H -#include <glib.h> -#include <glib-object.h> -#include <gio/gio.h> - -#include <p11-kit/pkcs11.h> - #define __GCK_INSIDE_HEADER__ -#include <gck/gck-enum-types.h> -#include <gck/gck-version.h> - -G_BEGIN_DECLS - /* * To use this API, you need to be prepared for changes to the API, * and add the C flag: -DGCK_API_SUBJECT_TO_CHANGE @@ -47,1555 +36,18 @@ G_BEGIN_DECLS #endif #endif -#define GCK_VENDOR_CODE 0x47434B00 /* GCK */ - -/* An error code which results from a failure to load the PKCS11 module */ -typedef enum { - GCK_ERROR_MODULE_PROBLEM = (CKR_VENDOR_DEFINED | (GCK_VENDOR_CODE + 1)), -} GckError; - -#define GCK_ERROR (gck_error_get_quark ()) - -GQuark gck_error_get_quark (void) G_GNUC_CONST; - -#define GCK_TYPE_LIST (gck_list_get_boxed_type ()) - -GType gck_list_get_boxed_type (void) G_GNUC_CONST; - -GList* gck_list_ref_copy (GList *reflist); - -void gck_list_unref_free (GList *reflist); - -const gchar* gck_message_from_rv (gulong rv); - -gboolean gck_string_to_chars (guchar *data, - gsize max, - const gchar *string); - -gchar* gck_string_from_chars (const guchar *data, - gsize max); - -typedef gpointer (*GckAllocator) (gpointer data, gsize length); - -typedef enum { - GCK_SESSION_READ_ONLY = 0, - GCK_SESSION_READ_WRITE = 1 << 1, - GCK_SESSION_LOGIN_USER = 1 << 2, - GCK_SESSION_AUTHENTICATE = 1 << 3, -} GckSessionOptions; - -typedef struct _GckMechanism GckMechanism; - -struct _GckMechanism { - gulong type; - gconstpointer parameter; - gulong n_parameter; -}; - -typedef struct _GckAttribute GckAttribute; - -struct _GckAttribute { - gulong type; - guchar *value; - gulong length; -}; - -#define GCK_INVALID ((gulong)-1) - -gboolean gck_value_to_ulong (const guchar *value, - gsize length, - gulong *result); - -gboolean gck_value_to_boolean (const guchar *value, - gsize length, - gboolean *result); - -void gck_attribute_init (GckAttribute *attr, - gulong attr_type, - const guchar *value, - gsize length); - -void gck_attribute_init_invalid (GckAttribute *attr, - gulong attr_type); - -void gck_attribute_init_empty (GckAttribute *attr, - gulong attr_type); - -void gck_attribute_init_boolean (GckAttribute *attr, - gulong attr_type, - gboolean value); - -void gck_attribute_init_date (GckAttribute *attr, - gulong attr_type, - const GDate *value); - -void gck_attribute_init_ulong (GckAttribute *attr, - gulong attr_type, - gulong value); - -void gck_attribute_init_string (GckAttribute *attr, - gulong attr_type, - const gchar *value); - -void gck_attribute_init_copy (GckAttribute *dest, - const GckAttribute *src); - -#define GCK_TYPE_ATTRIBUTE (gck_attribute_get_type ()) - -GType gck_attribute_get_type (void) G_GNUC_CONST; - -GckAttribute* gck_attribute_new (gulong attr_type, - const guchar *value, - gsize length); - -GckAttribute* gck_attribute_new_invalid (gulong attr_type); - -GckAttribute* gck_attribute_new_empty (gulong attr_type); - -GckAttribute* gck_attribute_new_boolean (gulong attr_type, - gboolean value); - -GckAttribute* gck_attribute_new_date (gulong attr_type, - const GDate *value); - -GckAttribute* gck_attribute_new_ulong (gulong attr_type, - gulong value); - -GckAttribute* gck_attribute_new_string (gulong attr_type, - const gchar *value); - -gboolean gck_attribute_is_invalid (const GckAttribute *attr); - -gboolean gck_attribute_get_boolean (const GckAttribute *attr); - -gulong gck_attribute_get_ulong (const GckAttribute *attr); - -gchar* gck_attribute_get_string (const GckAttribute *attr); - -void gck_attribute_get_date (const GckAttribute *attr, - GDate* value); - -const guchar * gck_attribute_get_data (const GckAttribute *attr, - gsize *length); - -gboolean gck_attribute_equal (gconstpointer attr1, - gconstpointer attr2); - -guint gck_attribute_hash (gconstpointer attr); - -GckAttribute* gck_attribute_dup (const GckAttribute *attr); - -void gck_attribute_clear (GckAttribute *attr); - -void gck_attribute_free (gpointer attr); - -void gck_attribute_dump (const GckAttribute *attr); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckAttribute, gck_attribute_free); - -typedef struct _GckBuilder GckBuilder; - -struct _GckBuilder { - /*< private >*/ - gsize x[16]; -}; - -typedef enum { - GCK_BUILDER_NONE, - GCK_BUILDER_SECURE_MEMORY = 1, -} GckBuilderFlags; - -typedef struct _GckAttributes GckAttributes; - -GckBuilder * gck_builder_new (GckBuilderFlags flags); - -#define GCK_BUILDER_INIT { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } - -GckBuilder * gck_builder_ref (GckBuilder *builder); - -void gck_builder_unref (gpointer builder); - -void gck_builder_init (GckBuilder *builder); - -void gck_builder_init_full (GckBuilder *builder, - GckBuilderFlags flags); - -#define GCK_TYPE_BUILDER (gck_builder_get_type ()) - -GType gck_builder_get_type (void) G_GNUC_CONST; - -void gck_builder_take_data (GckBuilder *builder, - gulong attr_type, - guchar *value, - gsize length); - -void gck_builder_add_data (GckBuilder *builder, - gulong attr_type, - const guchar *value, - gsize length); - -void gck_builder_add_empty (GckBuilder *builder, - gulong attr_type); - -void gck_builder_add_invalid (GckBuilder *builder, - gulong attr_type); - -void gck_builder_add_ulong (GckBuilder *builder, - gulong attr_type, - gulong value); - -void gck_builder_add_boolean (GckBuilder *builder, - gulong attr_type, - gboolean value); - -void gck_builder_add_date (GckBuilder *builder, - gulong attr_type, - const GDate *value); - -void gck_builder_add_string (GckBuilder *builder, - gulong attr_type, - const gchar *value); - -void gck_builder_add_attribute (GckBuilder *builder, - const GckAttribute *attr); - -void gck_builder_add_all (GckBuilder *builder, - GckAttributes *attrs); - -void gck_builder_add_only (GckBuilder *builder, - GckAttributes *attrs, - gulong only_type, - ...); - -void gck_builder_add_onlyv (GckBuilder *builder, - GckAttributes *attrs, - const gulong *only_types, - guint n_only_types); - -void gck_builder_add_except (GckBuilder *builder, - GckAttributes *attrs, - gulong except_type, - ...); - -void gck_builder_add_exceptv (GckBuilder *builder, - GckAttributes *attrs, - const gulong *except_types, - guint n_except_types); - -void gck_builder_set_data (GckBuilder *builder, - gulong attr_type, - const guchar *value, - gsize length); - -void gck_builder_set_empty (GckBuilder *builder, - gulong attr_type); - -void gck_builder_set_invalid (GckBuilder *builder, - gulong attr_type); - -void gck_builder_set_ulong (GckBuilder *builder, - gulong attr_type, - gulong value); - -void gck_builder_set_boolean (GckBuilder *builder, - gulong attr_type, - gboolean value); - -void gck_builder_set_date (GckBuilder *builder, - gulong attr_type, - const GDate *value); - -void gck_builder_set_string (GckBuilder *builder, - gulong attr_type, - const gchar *value); - -void gck_builder_set_all (GckBuilder *builder, - GckAttributes *attrs); - -const GckAttribute * gck_builder_find (GckBuilder *builder, - gulong attr_type); - -gboolean gck_builder_find_boolean (GckBuilder *builder, - gulong attr_type, - gboolean *value); - -gboolean gck_builder_find_ulong (GckBuilder *builder, - gulong attr_type, - gulong *value); - -gboolean gck_builder_find_string (GckBuilder *builder, - gulong attr_type, - gchar **value); - -gboolean gck_builder_find_date (GckBuilder *builder, - gulong attr_type, - GDate *value); - -GckAttributes * gck_builder_steal (GckBuilder *builder); - -GckAttributes * gck_builder_end (GckBuilder *builder); - -GckBuilder * gck_builder_copy (GckBuilder *builder); - -void gck_builder_clear (GckBuilder *builder); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckBuilder, gck_builder_unref); - -#define GCK_TYPE_ATTRIBUTES (gck_attributes_get_type ()) - -GType gck_attributes_get_type (void) G_GNUC_CONST; - -GckAttributes * gck_attributes_new (gulong reserved); - -GckAttributes * gck_attributes_new_empty (gulong first_type, - ...); - -const GckAttribute * gck_attributes_at (GckAttributes *attrs, - guint index); - -const GckAttribute * gck_attributes_find (GckAttributes *attrs, - gulong attr_type); - -gboolean gck_attributes_find_boolean (GckAttributes *attrs, - gulong attr_type, - gboolean *value); - -gboolean gck_attributes_find_ulong (GckAttributes *attrs, - gulong attr_type, - gulong *value); - -gboolean gck_attributes_find_string (GckAttributes *attrs, - gulong attr_type, - gchar **value); - -gboolean gck_attributes_find_date (GckAttributes *attrs, - gulong attr_type, - GDate *value); - -gulong gck_attributes_count (GckAttributes *attrs); - -GckAttributes * gck_attributes_ref (GckAttributes *attrs); - -GckAttributes * gck_attributes_ref_sink (GckAttributes *attrs); - -void gck_attributes_unref (gpointer attrs); - -gboolean gck_attributes_contains (GckAttributes *attrs, - const GckAttribute *match); - -void gck_attributes_dump (GckAttributes *attrs); - -gchar * gck_attributes_to_string (GckAttributes *attrs); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckAttributes, gck_attributes_unref); - -/* ------------------------------------------------------------------------- - * FORWARDS - */ -typedef struct _GckSlot GckSlot; -typedef struct _GckModule GckModule; -typedef struct _GckSession GckSession; -typedef struct _GckObject GckObject; -typedef struct _GckObjectCache GckObjectCache; -typedef struct _GckEnumerator GckEnumerator; -typedef struct _GckUriData GckUriData; - -/* ------------------------------------------------------------------------- - * MODULE - */ - -typedef struct _GckModuleInfo GckModuleInfo; - -struct _GckModuleInfo { - guint8 pkcs11_version_major; - guint8 pkcs11_version_minor; - - gchar *manufacturer_id; - gulong flags; - - gchar *library_description; - guint8 library_version_major; - guint8 library_version_minor; -}; - -#define GCK_TYPE_MODULE_INFO (gck_module_info_get_type ()) - -GType gck_module_info_get_type (void) G_GNUC_CONST; - -GckModuleInfo * gck_module_info_copy (GckModuleInfo *module_info); - -void gck_module_info_free (GckModuleInfo *module_info); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckModuleInfo, gck_module_info_free); - -#define GCK_TYPE_MODULE (gck_module_get_type()) -#define GCK_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_MODULE, GckModule)) -#define GCK_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_MODULE, GckModule)) -#define GCK_IS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_MODULE)) -#define GCK_IS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_MODULE)) -#define GCK_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_MODULE, GckModuleClass)) - -typedef struct _GckModuleClass GckModuleClass; -typedef struct _GckModulePrivate GckModulePrivate; - -struct _GckModule { - GObject parent; - - /*< private >*/ - GckModulePrivate *pv; - gpointer reserved[4]; -}; - -struct _GckModuleClass { - GObjectClass parent; - - gboolean (*authenticate_slot) (GckModule *self, GckSlot *slot, gchar *label, gchar **password); - - gboolean (*authenticate_object) (GckModule *self, GckObject *object, gchar *label, gchar **password); - - /*< private >*/ - gpointer reserved[8]; -}; - -GType gck_module_get_type (void) G_GNUC_CONST; - -GckModule* gck_module_new (CK_FUNCTION_LIST_PTR funcs); - -GckModule* gck_module_initialize (const gchar *path, - GCancellable *cancellable, - GError **error); - -void gck_module_initialize_async (const gchar *path, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GckModule * gck_module_initialize_finish (GAsyncResult *result, - GError **error); - -gboolean gck_module_equal (gconstpointer module1, - gconstpointer module2); - -guint gck_module_hash (gconstpointer module); - -gboolean gck_module_match (GckModule *self, - GckUriData *uri); - -const gchar* gck_module_get_path (GckModule *self); - -CK_FUNCTION_LIST_PTR gck_module_get_functions (GckModule *self); - -GckModuleInfo* gck_module_get_info (GckModule *self); - -GList* gck_module_get_slots (GckModule *self, - gboolean token_present); - -GList* gck_modules_initialize_registered (GCancellable *cancellable, - GError **error); - -void gck_modules_initialize_registered_async (GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GList * gck_modules_initialize_registered_finish (GAsyncResult *result, - GError **error); - -GList* gck_modules_get_slots (GList *modules, - gboolean token_present); - -GckEnumerator* gck_modules_enumerate_objects (GList *modules, - GckAttributes *attrs, - GckSessionOptions session_options); - -GckSlot* gck_modules_token_for_uri (GList *modules, - const gchar *uri, - GError **error); - -GList * gck_modules_tokens_for_uri (GList *modules, - const gchar *uri, - GError **error); - -GckObject* gck_modules_object_for_uri (GList *modules, - const gchar *uri, - GckSessionOptions session_options, - GError **error); - -GList* gck_modules_objects_for_uri (GList *modules, - const gchar *uri, - GckSessionOptions session_options, - GError **error); - -GckEnumerator* gck_modules_enumerate_uri (GList *modules, - const gchar *uri, - GckSessionOptions session_options, - GError **error); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckModule, g_object_unref); - - -/* ------------------------------------------------------------------------ - * ENUMERATOR - */ - -#define GCK_TYPE_ENUMERATOR (gck_enumerator_get_type()) -#define GCK_ENUMERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_ENUMERATOR, GckEnumerator)) -#define GCK_ENUMERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_ENUMERATOR, GckEnumerator)) -#define GCK_IS_ENUMERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_ENUMERATOR)) -#define GCK_IS_ENUMERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_ENUMERATOR)) -#define GCK_ENUMERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_ENUMERATOR, GckEnumeratorClass)) - -typedef struct _GckEnumeratorClass GckEnumeratorClass; -typedef struct _GckEnumeratorPrivate GckEnumeratorPrivate; - -struct _GckEnumerator { - GObject parent; - - /*< private >*/ - GckEnumeratorPrivate *pv; - gpointer reserved[2]; -}; - -struct _GckEnumeratorClass { - GObjectClass parent; - - /*< private >*/ - gpointer reserved[2]; -}; - -GType gck_enumerator_get_type (void) G_GNUC_CONST; - -GTlsInteraction * gck_enumerator_get_interaction (GckEnumerator *self); - -void gck_enumerator_set_interaction (GckEnumerator *self, - GTlsInteraction *interaction); - -GType gck_enumerator_get_object_type (GckEnumerator *self); - -void gck_enumerator_set_object_type (GckEnumerator *self, - GType object_type); - -void gck_enumerator_set_object_type_full (GckEnumerator *self, - GType object_type, - const gulong *attr_types, - gint attr_count); - -GckEnumerator * gck_enumerator_get_chained (GckEnumerator *self); - -void gck_enumerator_set_chained (GckEnumerator *self, - GckEnumerator *chained); - -GckObject * gck_enumerator_next (GckEnumerator *self, - GCancellable *cancellable, - GError **error); - -GList* gck_enumerator_next_n (GckEnumerator *self, - gint max_objects, - GCancellable *cancellable, - GError **error); - -void gck_enumerator_next_async (GckEnumerator *self, - gint max_objects, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GList* gck_enumerator_next_finish (GckEnumerator *self, - GAsyncResult *result, - GError **error); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckEnumerator, g_object_unref); - -/* ------------------------------------------------------------------------ - * SLOT - */ - -typedef struct _GckSlotInfo GckSlotInfo; - -struct _GckSlotInfo { - gchar *slot_description; - gchar *manufacturer_id; - gulong flags; - guint8 hardware_version_major; - guint8 hardware_version_minor; - guint8 firmware_version_major; - guint8 firmware_version_minor; -}; - -#define GCK_TYPE_SLOT_INFO (gck_slot_info_get_type ()) - -GType gck_slot_info_get_type (void) G_GNUC_CONST; - -GckSlotInfo * gck_slot_info_copy (GckSlotInfo *slot_info); - -void gck_slot_info_free (GckSlotInfo *slot_info); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckSlotInfo, gck_slot_info_free); - -typedef struct _GckTokenInfo GckTokenInfo; - -struct _GckTokenInfo { - gchar *label; - gchar *manufacturer_id; - gchar *model; - gchar *serial_number; - gulong flags; - glong max_session_count; - glong session_count; - glong max_rw_session_count; - glong rw_session_count; - glong max_pin_len; - glong min_pin_len; - glong total_public_memory; - glong free_public_memory; - glong total_private_memory; - glong free_private_memory; - guint8 hardware_version_major; - guint8 hardware_version_minor; - guint8 firmware_version_major; - guint8 firmware_version_minor; - gint64 utc_time; -}; - -#define GCK_TYPE_TOKEN_INFO (gck_token_info_get_type ()) - -GType gck_token_info_get_type (void) G_GNUC_CONST; - -GckTokenInfo * gck_token_info_copy (GckTokenInfo *token_info); - -void gck_token_info_free (GckTokenInfo *token_info); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckTokenInfo, gck_token_info_free); - -typedef struct _GckMechanismInfo GckMechanismInfo; - -struct _GckMechanismInfo { - gulong min_key_size; - gulong max_key_size; - gulong flags; -}; - -#define GCK_TYPE_MECHANISM_INFO (gck_mechanism_info_get_type ()) - -GType gck_mechanism_info_get_type (void) G_GNUC_CONST; - -GckMechanismInfo * gck_mechanism_info_copy (GckMechanismInfo *mech_info); - -void gck_mechanism_info_free (GckMechanismInfo *mech_info); - -#define gck_mechanisms_length(a) ((a)->len) - -#define gck_mechanisms_at(a, i) (g_array_index (a, CK_MECHANISM_TYPE, i)) - -gboolean gck_mechanisms_check (GArray *mechanisms, - ...); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckMechanismInfo, gck_mechanism_info_free); - -#define GCK_TYPE_SLOT (gck_slot_get_type()) -#define GCK_SLOT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_SLOT, GckSlot)) -#define GCK_SLOT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_SLOT, GckSlot)) -#define GCK_IS_SLOT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_SLOT)) -#define GCK_IS_SLOT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_SLOT)) -#define GCK_SLOT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_SLOT, GckSlotClass)) - -typedef struct _GckSlotClass GckSlotClass; -typedef struct _GckSlotPrivate GckSlotPrivate; - -struct _GckSlot { - GObject parent; - - /*< private >*/ - GckSlotPrivate *pv; - gpointer reserved[4]; -}; - -struct _GckSlotClass { - GObjectClass parent; - - /*< private >*/ - gpointer reserved[9]; -}; - -GType gck_slot_get_type (void) G_GNUC_CONST; - -gboolean gck_slot_equal (gconstpointer slot1, - gconstpointer slot2); - -guint gck_slot_hash (gconstpointer slot); - -gboolean gck_slot_match (GckSlot *self, - GckUriData *uri); - -GckSlot* gck_slot_from_handle (GckModule *module, - gulong slot_id); - -GckModule* gck_slot_get_module (GckSlot *self); - -gulong gck_slot_get_handle (GckSlot *self); - -GckSlotInfo* gck_slot_get_info (GckSlot *self); - -GckTokenInfo* gck_slot_get_token_info (GckSlot *self); - -GArray * gck_slot_get_mechanisms (GckSlot *self); - -GckMechanismInfo* gck_slot_get_mechanism_info (GckSlot *self, - gulong mech_type); - -gboolean gck_slot_has_flags (GckSlot *self, - gulong flags); - -GckSession* gck_slot_open_session (GckSlot *self, - GckSessionOptions options, - GCancellable *cancellable, - GError **error); - -GckSession* gck_slot_open_session_full (GckSlot *self, - GckSessionOptions options, - gulong pkcs11_flags, - gpointer app_data, - CK_NOTIFY notify, - GCancellable *cancellable, - GError **error); - -void gck_slot_open_session_async (GckSlot *self, - GckSessionOptions options, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -void gck_slot_open_session_full_async (GckSlot *self, - GckSessionOptions options, - gulong pkcs11_flags, - gpointer app_data, - CK_NOTIFY notify, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GckSession* gck_slot_open_session_finish (GckSlot *self, - GAsyncResult *result, - GError **error); - -GckEnumerator * gck_slot_enumerate_objects (GckSlot *self, - GckAttributes *match, - GckSessionOptions options); - -GckEnumerator* gck_slots_enumerate_objects (GList *slots, - GckAttributes *match, - GckSessionOptions options); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckSlot, g_object_unref); - -/* ------------------------------------------------------------------------ - * SESSION - */ - -typedef struct _GckSessionInfo GckSessionInfo; - -struct _GckSessionInfo { - gulong slot_id; - gulong state; - gulong flags; - gulong device_error; -}; - -#define GCK_TYPE_SESSION_INFO (gck_session_info_get_type ()) - -GType gck_session_info_get_type (void) G_GNUC_CONST; - -GckSessionInfo * gck_session_info_copy (GckSessionInfo *session_info); - -void gck_session_info_free (GckSessionInfo *session_info); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckSessionInfo, gck_session_info_free); - -#define GCK_TYPE_SESSION (gck_session_get_type()) -#define GCK_SESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_SESSION, GckSession)) -#define GCK_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_SESSION, GckSession)) -#define GCK_IS_SESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_SESSION)) -#define GCK_IS_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_SESSION)) -#define GCK_SESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_SESSION, GckSessionClass)) - -typedef struct _GckSessionClass GckSessionClass; -typedef struct _GckSessionPrivate GckSessionPrivate; - -struct _GckSession { - GObject parent; - - /*< private >*/ - GckSessionPrivate *pv; - gpointer reserved[4]; -}; - -struct _GckSessionClass { - GObjectClass parent; - - gboolean (*discard_handle) (GckSession *session, CK_SESSION_HANDLE handle); - - /*< private >*/ - gpointer reserved[8]; -}; - -GType gck_session_get_type (void) G_GNUC_CONST; - -GckSession * gck_session_from_handle (GckSlot *slot, - gulong session_handle, - GckSessionOptions options); - -GckModule* gck_session_get_module (GckSession *self); - -GckSlot* gck_session_get_slot (GckSession *self); - -gulong gck_session_get_handle (GckSession *self); - -GckSessionInfo* gck_session_get_info (GckSession *self); - -gulong gck_session_get_state (GckSession *self); - -GckSessionOptions gck_session_get_options (GckSession *self); - -GTlsInteraction * gck_session_get_interaction (GckSession *self); - -void gck_session_set_interaction (GckSession *self, - GTlsInteraction *interaction); - -GckSession * gck_session_open (GckSlot *slot, - GckSessionOptions options, - GTlsInteraction *interaction, - GCancellable *cancellable, - GError **error); - -void gck_session_open_async (GckSlot *slot, - GckSessionOptions options, - GTlsInteraction *interaction, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GckSession * gck_session_open_finish (GAsyncResult *result, - GError **error); - -gboolean gck_session_init_pin (GckSession *self, - const guchar *pin, - gsize n_pin, - GCancellable *cancellable, - GError **error); - -void gck_session_init_pin_async (GckSession *self, - const guchar *pin, - gsize n_pin, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gboolean gck_session_init_pin_finish (GckSession *self, - GAsyncResult *result, - GError **error); - -gboolean gck_session_set_pin (GckSession *self, - const guchar *old_pin, - gsize n_old_pin, - const guchar *new_pin, - gsize n_new_pin, - GCancellable *cancellable, - GError **error); - -void gck_session_set_pin_async (GckSession *self, - const guchar *old_pin, - gsize n_old_pin, - const guchar *new_pin, - gsize n_new_pin, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gboolean gck_session_set_pin_finish (GckSession *self, - GAsyncResult *result, - GError **error); - -gboolean gck_session_login (GckSession *self, - gulong user_type, - const guchar *pin, - gsize n_pin, - GCancellable *cancellable, - GError **error); - -void gck_session_login_async (GckSession *self, - gulong user_type, - const guchar *pin, - gsize n_pin, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gboolean gck_session_login_finish (GckSession *self, - GAsyncResult *result, - GError **error); - -gboolean gck_session_login_interactive (GckSession *self, - gulong user_type, - GTlsInteraction *interaction, - GCancellable *cancellable, - GError **error); - -void gck_session_login_interactive_async (GckSession *self, - gulong user_type, - GTlsInteraction *interaction, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gboolean gck_session_login_interactive_finish (GckSession *self, - GAsyncResult *result, - GError **error); - -gboolean gck_session_logout (GckSession *self, - GCancellable *cancellable, - GError **error); - -void gck_session_logout_async (GckSession *self, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gboolean gck_session_logout_finish (GckSession *self, - GAsyncResult *result, - GError **error); - -GckObject* gck_session_create_object (GckSession *self, - GckAttributes *attrs, - GCancellable *cancellable, - GError **error); - -void gck_session_create_object_async (GckSession *self, - GckAttributes *attrs, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GckObject* gck_session_create_object_finish (GckSession *self, - GAsyncResult *result, - GError **error); - -GList* gck_session_find_objects (GckSession *self, - GckAttributes *match, - GCancellable *cancellable, - GError **error); - -void gck_session_find_objects_async (GckSession *self, - GckAttributes *match, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GList* gck_session_find_objects_finish (GckSession *self, - GAsyncResult *result, - GError **error); - -gulong * gck_session_find_handles (GckSession *self, - GckAttributes *match, - GCancellable *cancellable, - gulong *n_handles, - GError **error); - -void gck_session_find_handles_async (GckSession *self, - GckAttributes *match, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gulong * gck_session_find_handles_finish (GckSession *self, - GAsyncResult *result, - gulong *n_handles, - GError **error); - -GckEnumerator * gck_session_enumerate_objects (GckSession *self, - GckAttributes *match); - -gboolean gck_session_generate_key_pair (GckSession *self, - gulong mech_type, - GckAttributes *public_attrs, - GckAttributes *private_attrs, - GckObject **public_key, - GckObject **private_key, - GCancellable *cancellable, - GError **error); - -gboolean gck_session_generate_key_pair_full (GckSession *self, - GckMechanism *mechanism, - GckAttributes *public_attrs, - GckAttributes *private_attrs, - GckObject **public_key, - GckObject **private_key, - GCancellable *cancellable, - GError **error); - -void gck_session_generate_key_pair_async (GckSession *self, - GckMechanism *mechanism, - GckAttributes *public_attrs, - GckAttributes *private_attrs, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gboolean gck_session_generate_key_pair_finish (GckSession *self, - GAsyncResult *result, - GckObject **public_key, - GckObject **private_key, - GError **error); - -guchar* gck_session_encrypt (GckSession *self, - GckObject *key, - gulong mech_type, - const guchar *input, - gsize n_input, - gsize *n_result, - GCancellable *cancellable, - GError **error); - -guchar* gck_session_encrypt_full (GckSession *self, - GckObject *key, - GckMechanism *mechanism, - const guchar *input, - gsize n_input, - gsize *n_result, - GCancellable *cancellable, - GError **error); - -void gck_session_encrypt_async (GckSession *self, - GckObject *key, - GckMechanism *mechanism, - const guchar *input, - gsize n_input, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -guchar* gck_session_encrypt_finish (GckSession *self, - GAsyncResult *result, - gsize *n_result, - GError **error); - -guchar* gck_session_decrypt (GckSession *self, - GckObject *key, - gulong mech_type, - const guchar *input, - gsize n_input, - gsize *n_result, - GCancellable *cancellable, - GError **error); - -guchar* gck_session_decrypt_full (GckSession *self, - GckObject *key, - GckMechanism *mechanism, - const guchar *input, - gsize n_input, - gsize *n_result, - GCancellable *cancellable, - GError **error); - -void gck_session_decrypt_async (GckSession *self, - GckObject *key, - GckMechanism *mechanism, - const guchar *input, - gsize n_input, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -guchar* gck_session_decrypt_finish (GckSession *self, - GAsyncResult *result, - gsize *n_result, - GError **error); - -guchar* gck_session_sign (GckSession *self, - GckObject *key, - gulong mech_type, - const guchar *input, - gsize n_input, - gsize *n_result, - GCancellable *cancellable, - GError **error); - -guchar* gck_session_sign_full (GckSession *self, - GckObject *key, - GckMechanism *mechanism, - const guchar *input, - gsize n_input, - gsize *n_result, - GCancellable *cancellable, - GError **error); - -void gck_session_sign_async (GckSession *self, - GckObject *key, - GckMechanism *mechanism, - const guchar *input, - gsize n_input, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -guchar* gck_session_sign_finish (GckSession *self, - GAsyncResult *result, - gsize *n_result, - GError **error); - -gboolean gck_session_verify (GckSession *self, - GckObject *key, - gulong mech_type, - const guchar *input, - gsize n_input, - const guchar *signature, - gsize n_signature, - GCancellable *cancellable, - GError **error); - -gboolean gck_session_verify_full (GckSession *self, - GckObject *key, - GckMechanism *mechanism, - const guchar *input, - gsize n_input, - const guchar *signature, - gsize n_signature, - GCancellable *cancellable, - GError **error); - -void gck_session_verify_async (GckSession *self, - GckObject *key, - GckMechanism *mechanism, - const guchar *input, - gsize n_input, - const guchar *signature, - gsize n_signature, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gboolean gck_session_verify_finish (GckSession *self, - GAsyncResult *result, - GError **error); - -guchar * gck_session_wrap_key (GckSession *self, - GckObject *wrapper, - gulong mech_type, - GckObject *wrapped, - gsize *n_result, - GCancellable *cancellable, - GError **error); - -guchar * gck_session_wrap_key_full (GckSession *self, - GckObject *wrapper, - GckMechanism *mechanism, - GckObject *wrapped, - gsize *n_result, - GCancellable *cancellable, - GError **error); - -void gck_session_wrap_key_async (GckSession *self, - GckObject *wrapper, - GckMechanism *mechanism, - GckObject *wrapped, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -guchar * gck_session_wrap_key_finish (GckSession *self, - GAsyncResult *result, - gsize *n_result, - GError **error); - -GckObject* gck_session_unwrap_key (GckSession *self, - GckObject *wrapper, - gulong mech_type, - const guchar *input, - gsize n_input, - GckAttributes *attrs, - GCancellable *cancellable, - GError **error); - -GckObject* gck_session_unwrap_key_full (GckSession *self, - GckObject *wrapper, - GckMechanism *mechanism, - const guchar *input, - gsize n_input, - GckAttributes *attrs, - GCancellable *cancellable, - GError **error); - -void gck_session_unwrap_key_async (GckSession *self, - GckObject *wrapper, - GckMechanism *mechanism, - const guchar *input, - gsize n_input, - GckAttributes *attrs, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GckObject* gck_session_unwrap_key_finish (GckSession *self, - GAsyncResult *result, - GError **error); - -GckObject* gck_session_derive_key (GckSession *self, - GckObject *base, - gulong mech_type, - GckAttributes *attrs, - GCancellable *cancellable, - GError **error); - -GckObject* gck_session_derive_key_full (GckSession *self, - GckObject *base, - GckMechanism *mechanism, - GckAttributes *attrs, - GCancellable *cancellable, - GError **error); - -void gck_session_derive_key_async (GckSession *self, - GckObject *base, - GckMechanism *mechanism, - GckAttributes *attrs, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GckObject* gck_session_derive_key_finish (GckSession *self, - GAsyncResult *result, - GError **error); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckSession, g_object_unref); - -/* ------------------------------------------------------------------------ - * OBJECT - */ - -#define GCK_TYPE_OBJECT (gck_object_get_type()) -#define GCK_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCK_TYPE_OBJECT, GckObject)) -#define GCK_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCK_TYPE_OBJECT, GckObjectClass)) -#define GCK_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCK_TYPE_OBJECT)) -#define GCK_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCK_TYPE_OBJECT)) -#define GCK_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCK_TYPE_OBJECT, GckObjectClass)) - -typedef struct _GckObjectClass GckObjectClass; -typedef struct _GckObjectPrivate GckObjectPrivate; - -struct _GckObject { - GObject parent; - - /*< private >*/ - GckObjectPrivate *pv; - gpointer reserved[4]; -}; - -struct _GckObjectClass { - GObjectClass parent; - - /*< private >*/ - gpointer reserved[8]; -}; - -GType gck_object_get_type (void) G_GNUC_CONST; - -GckObject * gck_object_from_handle (GckSession *session, - gulong object_handle); - -GList* gck_objects_from_handle_array (GckSession *session, - gulong *object_handles, - gulong n_object_handles); - -gboolean gck_object_equal (gconstpointer object1, - gconstpointer object2); - -guint gck_object_hash (gconstpointer object); - -GckModule* gck_object_get_module (GckObject *self); - -gulong gck_object_get_handle (GckObject *self); - -GckSession* gck_object_get_session (GckObject *self); - -gboolean gck_object_destroy (GckObject *self, - GCancellable *cancellable, - GError **error); - -void gck_object_destroy_async (GckObject *self, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gboolean gck_object_destroy_finish (GckObject *self, - GAsyncResult *result, - GError **error); - -gboolean gck_object_set (GckObject *self, - GckAttributes *attrs, - GCancellable *cancellable, - GError **error); - -void gck_object_set_async (GckObject *self, - GckAttributes *attrs, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gboolean gck_object_set_finish (GckObject *self, - GAsyncResult *result, - GError **error); - -GckAttributes* gck_object_get (GckObject *self, - GCancellable *cancellable, - GError **error, - ...); - -GckAttributes* gck_object_get_full (GckObject *self, - const gulong *attr_types, - guint n_attr_types, - GCancellable *cancellable, - GError **error); - -void gck_object_get_async (GckObject *self, - const gulong *attr_types, - guint n_attr_types, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GckAttributes* gck_object_get_finish (GckObject *self, - GAsyncResult *result, - GError **error); - -guchar * gck_object_get_data (GckObject *self, - gulong attr_type, - GCancellable *cancellable, - gsize *n_data, - GError **error); - -guchar * gck_object_get_data_full (GckObject *self, - gulong attr_type, - GckAllocator allocator, - GCancellable *cancellable, - gsize *n_data, - GError **error); - -void gck_object_get_data_async (GckObject *self, - gulong attr_type, - GckAllocator allocator, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -guchar * gck_object_get_data_finish (GckObject *self, - GAsyncResult *result, - gsize *n_data, - GError **error); - -gboolean gck_object_set_template (GckObject *self, - gulong attr_type, - GckAttributes *attrs, - GCancellable *cancellable, - GError **error); - -void gck_object_set_template_async (GckObject *self, - gulong attr_type, - GckAttributes *attrs, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gboolean gck_object_set_template_finish (GckObject *self, - GAsyncResult *result, - GError **error); - -GckAttributes* gck_object_get_template (GckObject *self, - gulong attr_type, - GCancellable *cancellable, - GError **error); - -void gck_object_get_template_async (GckObject *self, - gulong attr_type, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GckAttributes* gck_object_get_template_finish (GckObject *self, - GAsyncResult *result, - GError **error); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckObject, g_object_unref); - -/* ------------------------------------------------------------------------ - * OBJECT ATTRIBUTES - */ - -#define GCK_TYPE_OBJECT_CACHE (gck_object_cache_get_type ()) -#define GCK_OBJECT_CACHE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCK_TYPE_OBJECT_CACHE, GckObjectCache)) -#define GCK_IS_OBJECT_CACHE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GCK_TYPE_OBJECT_CACHE)) -#define GCK_OBJECT_CACHE_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GCK_TYPE_OBJECT_CACHE, GckObjectCacheIface)) - -typedef struct _GckObjectCacheIface GckObjectCacheIface; - -struct _GckObjectCacheIface { - GTypeInterface interface; - - const gulong * default_types; - gint n_default_types; - - void (* fill) (GckObjectCache *object, - GckAttributes *attrs); - - /*< private >*/ - gpointer reserved[6]; -}; - -GType gck_object_cache_get_type (void) G_GNUC_CONST; - -GckAttributes * gck_object_cache_get_attributes (GckObjectCache *object); - -void gck_object_cache_set_attributes (GckObjectCache *object, - GckAttributes *attrs); - -void gck_object_cache_fill (GckObjectCache *object, - GckAttributes *attrs); - -gboolean gck_object_cache_update (GckObjectCache *object, - const gulong *attr_types, - gint n_attr_types, - GCancellable *cancellable, - GError **error); - -void gck_object_cache_update_async (GckObjectCache *object, - const gulong *attr_types, - gint n_attr_types, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -gboolean gck_object_cache_update_finish (GckObjectCache *object, - GAsyncResult *result, - GError **error); - -GckAttributes * gck_object_cache_lookup (GckObject *object, - const gulong *attr_types, - gint n_attr_types, - GCancellable *cancellable, - GError **error); - -void gck_object_cache_lookup_async (GckObject *object, - const gulong *attr_types, - gint n_attr_types, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data); - -GckAttributes * gck_object_cache_lookup_finish (GckObject *object, - GAsyncResult *result, - GError **error); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckObjectCache, g_object_unref); - -/* ------------------------------------------------------------------------ - * PASSWORD - */ - -#define GCK_TYPE_PASSWORD (gck_password_get_type ()) -#define GCK_PASSWORD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCK_TYPE_PASSWORD, GckPassword)) -#define GCK_PASSWORD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GCK_TYPE_PASSWORD, GckPassword)) -#define GCK_IS_PASSWORD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GCK_TYPE_PASSWORD)) -#define GCK_IS_PASSWORD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GCK_TYPE_PASSWORD)) -#define GCK_PASSWORD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GCK_TYPE_PASSWORD, GckPasswordClass)) - -typedef struct _GckPassword GckPassword; -typedef struct _GckPasswordClass GckPasswordClass; -typedef struct _GckPasswordPrivate GckPasswordPrivate; - -struct _GckPassword { - GTlsPassword parent; - - /*< private >*/ - GckPasswordPrivate *pv; - gpointer reserved[4]; -}; - -struct _GckPasswordClass { - GTlsPasswordClass parent; - - /*< private >*/ - gpointer reserved[4]; -}; - -GType gck_password_get_type (void) G_GNUC_CONST; - -GckModule * gck_password_get_module (GckPassword *self); - -GckSlot * gck_password_get_token (GckPassword *self); - -GckObject * gck_password_get_key (GckPassword *self); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckPassword, g_object_unref); - -/* ---------------------------------------------------------------------------- - * URI - */ - -typedef enum { - GCK_URI_BAD_SCHEME = 1, - GCK_URI_BAD_ENCODING, - GCK_URI_BAD_SYNTAX, - GCK_URI_BAD_VERSION, - GCK_URI_NOT_FOUND -} GckUriError; - -/* WARNING: Don't modify these without syncing with p11-kit */ -typedef enum { - GCK_URI_FOR_OBJECT = (1 << 1), - GCK_URI_FOR_TOKEN = (1 << 2), - GCK_URI_FOR_MODULE = (1 << 3), - GCK_URI_WITH_VERSION = (1 << 4), - GCK_URI_FOR_ANY = 0x0000FFFF, -} GckUriFlags; - -#define GCK_URI_FOR_MODULE_WITH_VERSION (GCK_URI_WITH_VERSION | GCK_URI_FOR_MODULE) - -#define GCK_URI_FOR_OBJECT_ON_TOKEN (GCK_URI_FOR_OBJECT | GCK_URI_FOR_TOKEN) - -#define GCK_URI_FOR_OBJECT_ON_TOKEN_AND_MODULE (GCK_URI_FOR_OBJECT_ON_TOKEN | GCK_URI_FOR_MODULE) - -struct _GckUriData { - gboolean any_unrecognized; - GckModuleInfo *module_info; - GckTokenInfo *token_info; - GckAttributes *attributes; - - /*< private >*/ - gpointer dummy[4]; -}; - -#define GCK_URI_ERROR (gck_uri_error_get_quark ()) - -GQuark gck_uri_error_get_quark (void) G_GNUC_CONST; - -GckUriData* gck_uri_data_new (void); - -gchar* gck_uri_build (GckUriData *uri_data, - GckUriFlags flags); - -GckUriData* gck_uri_parse (const gchar *string, - GckUriFlags flags, - GError **error); - -#define GCK_URI_DATA_TYPE (gck_uri_data_get_type ()) - -GType gck_uri_data_get_type (void) G_GNUC_CONST; - -GckUriData * gck_uri_data_copy (GckUriData *uri_data); - -void gck_uri_data_free (GckUriData *uri_data); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC (GckUriData, gck_uri_data_free); - -G_END_DECLS - -#include "gck-deprecated.h" +#include <gck/gck-enum-types.h> +#include <gck/gck-version.h> +#include <gck/gck-attributes.h> +#include <gck/gck-module.h> +#include <gck/gck-enumerator.h> +#include <gck/gck-slot.h> +#include <gck/gck-session.h> +#include <gck/gck-object.h> +#include <gck/gck-object-cache.h> +#include <gck/gck-password.h> +#include <gck/gck-uri.h> +#include <gck/gck-deprecated.h> #undef __GCK_INSIDE_HEADER__ diff --git a/gck/gck.pc.in b/gck/gck.pc.in index 4a46409..6b463a3 100644 --- a/gck/gck.pc.in +++ b/gck/gck.pc.in @@ -11,4 +11,4 @@ Description: GObject bindings for PKCS#11 Version: @VERSION@ Requires: glib-2.0 gobject-2.0 gio-2.0 p11-kit-1 Libs: -L${libdir} -lgck-@GCK_MAJOR@ -Cflags: -I${includedir}/gck-@GCK_MAJOR@ +Cflags: -I${includedir} -I${includedir}/gck-@GCK_MAJOR@ diff --git a/gck/meson.build b/gck/meson.build index 756b486..117700b 100644 --- a/gck/meson.build +++ b/gck/meson.build @@ -22,6 +22,15 @@ gck_sources_private = files( gck_headers = files( 'gck.h', + 'gck-attributes.h', + 'gck-enumerator.h', + 'gck-module.h', + 'gck-object.h', + 'gck-object-cache.h', + 'gck-password.h', + 'gck-session.h', + 'gck-slot.h', + 'gck-uri.h', ) # Generated sources @@ -79,6 +88,7 @@ gck_cflags = [ '-DPKCS11_REGISTRY_DIR="@0@"'.format(get_option('prefix') / get_option('libdir') / 'pkcs11'), '-D_XOPEN_SOURCE', # Needed for strptime() '-D_DEFAULT_SOURCE', # Needed for timegm + '-DGCK_COMPILATION', ] gck_symbolmap = meson.current_source_dir() / 'libgck.map' |