gck_mechanism_info_copy ()

GckMechanismInfo *
gck_mechanism_info_copy (GckMechanismInfo *mech_info);

Make a copy of the mechanism info.

gck_mechanism_info_free ()

void
gck_mechanism_info_free (GckMechanismInfo *mech_info);

Free the GckMechanismInfo and associated resources.

gck_mechanisms_length()

#define             gck_mechanisms_length(a)                ((a)->len)

Get the number of GckMechanismInfo in the set.

gck_mechanisms_at()

#define             gck_mechanisms_at(a, i)                 (g_array_index (a, CK_MECHANISM_TYPE, i))

Get a specific mechanism in a the set.

gck_mechanisms_check ()

gboolean
gck_mechanisms_check (GArray *mechanisms,
                      ...);

Check whether all the mechanism types are in the list.

The arguments should be a list of CKM_XXX mechanism types. The last argument should be GCK_INVALID.

gck_slot_equal ()

gboolean
gck_slot_equal (gconstpointer slot1,
                gconstpointer slot2);

Checks equality of two slots. Two GckSlot objects can point to the same underlying PKCS#11 slot.

gck_slot_hash ()

guint
gck_slot_hash (gconstpointer slot);

Create a hash value for the GckSlot.

This function is intended for easily hashing a GckSlot to add to a GHashTable or similar data structure.

gck_slot_get_module ()

GckModule *
gck_slot_get_module (GckSlot *self);

Get the module that this slot is on.

gck_slot_get_handle ()

gulong
gck_slot_get_handle (GckSlot *self);

Get the raw PKCS#11 handle of a slot.

gck_slot_get_info ()

GckSlotInfo *
gck_slot_get_info (GckSlot *self);

Get the information for this slot.

gck_slot_match ()

gboolean
gck_slot_match (GckSlot *self,
                GckUriData *uri);

Check whether the PKCS#11 URI matches the slot

gck_slot_get_token_info ()

GckTokenInfo *
gck_slot_get_token_info (GckSlot *self);

Get the token information for this slot.

gck_slot_get_mechanisms ()

GArray *
gck_slot_get_mechanisms (GckSlot *self);

Get the available mechanisms for this slot.

gck_slot_get_mechanism_info ()

GckMechanismInfo *
gck_slot_get_mechanism_info (GckSlot *self,
                             gulong mech_type);

Get information for the specified mechanism.

gck_slot_has_flags ()

gboolean
gck_slot_has_flags (GckSlot *self,
                    gulong flags);

Check if the PKCS11 slot has the given flags.

gck_slot_enumerate_objects ()

GckEnumerator *
gck_slot_enumerate_objects (GckSlot *self,
                            GckAttributes *match,
                            GckSessionOptions options);

Setup an enumerator for listing matching objects on the slot.

If the match GckAttributes is floating, it is consumed.

This call will not block but will return an enumerator immediately.

gck_slots_enumerate_objects ()

GckEnumerator *
gck_slots_enumerate_objects (GList *slots,
                             GckAttributes *match,
                             GckSessionOptions options);

Setup an enumerator for listing matching objects on the slots.

If the match GckAttributes is floating, it is consumed.

This call will not block but will return an enumerator immediately.

gck_slot_open_session ()

GckSession *
gck_slot_open_session (GckSlot *self,
                       GckSessionOptions options,
                       GCancellable *cancellable,
                       GError **error);

Open a session on the slot. If the 'auto reuse' setting is set, then this may be a recycled session with the same flags.

This call may block for an indefinite period.

gck_slot_open_session_full ()

GckSession *
gck_slot_open_session_full (GckSlot *self,
                            GckSessionOptions options,
                            gulong pkcs11_flags,
                            gpointer app_data,
                            CK_NOTIFY notify,
                            GCancellable *cancellable,
                            GError **error);

Open a session on the slot. If the 'auto reuse' setting is set, then this may be a recycled session with the same flags.

This call may block for an indefinite period.

[skip]

gck_slot_open_session_full_async ()

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);

Open a session on the slot. If the 'auto reuse' setting is set, then this may be a recycled session with the same flags.

This call will return immediately and complete asynchronously.

[skip]

gck_slot_open_session_async ()

void
gck_slot_open_session_async (GckSlot *self,
                             GckSessionOptions options,
                             GCancellable *cancellable,
                             GAsyncReadyCallback callback,
                             gpointer user_data);

Open a session on the slot. If the 'auto reuse' setting is set, then this may be a recycled session with the same flags.

This call will return immediately and complete asynchronously.

gck_slot_open_session_finish ()

GckSession *
gck_slot_open_session_finish (GckSlot *self,
                              GAsyncResult *result,
                              GError **error);

Get the result of an open session operation. If the 'auto reuse' setting is set, then this may be a recycled session with the same flags.

gck_slot_from_handle ()

GckSlot *
gck_slot_from_handle (GckModule *module,
                      gulong slot_id);

Create a new GckSlot object for a raw PKCS#11 handle.

gck_slot_info_copy ()

GckSlotInfo *
gck_slot_info_copy (GckSlotInfo *slot_info);

Make a copy of the slot info.

gck_slot_info_free ()

void
gck_slot_info_free (GckSlotInfo *slot_info);

Free the GckSlotInfo and associated resources.

gck_token_info_copy ()

GckTokenInfo *
gck_token_info_copy (GckTokenInfo *token_info);

Make a copy of the token info.

gck_token_info_free ()

void
gck_token_info_free (GckTokenInfo *token_info);

Free the GckTokenInfo and associated resources.

struct GckMechanismInfo

struct GckMechanismInfo {
	gulong min_key_size;
	gulong max_key_size;
	gulong flags;
};

Represents information about a PKCS11 mechanism.

This is analogous to a CK_MECHANISM_INFO structure.

When you're done with this structure it should be released with gck_mechanism_info_free().

enum GckSessionOptions

Options for creating sessions.

struct GckSlot

struct GckSlot;

Represents a PKCS11 slot.

struct 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;
};

Represents information about a PKCS11 slot.

This is analogous to a CK_SLOT_INFO structure, but the strings are far more usable.

When you're done with this structure it should be released with gck_slot_info_free().

struct 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;
};

Represents information about a PKCS11 token.

This is analogous to a CK_TOKEN_INFO structure, but the strings are far more usable.

When you're done with this structure it should be released with gck_token_info_free().

The “handle” property

  “handle”                   gulong

The raw CK_SLOT_ID handle of this slot.

Flags: Read / Write / Construct Only

The “module” property

  “module”                   GckModule *

The PKCS11 object that this slot is a part of.

Flags: Read / Write / Construct Only