|  |  |  | GP11 Reference Manual |  | 
|---|---|---|---|---|
| Top | Description | Object Hierarchy | Properties | ||||
GP11MechanismInfo; void gp11_mechanism_info_free (GP11MechanismInfo *mech_info); typedef GP11Mechanisms; #define gp11_mechanisms_length (a) #define gp11_mechanisms_at (a, i) #define gp11_mechanisms_free (a) gboolean gp11_mechanisms_check (GP11Mechanisms *mechanisms,...); GP11Slot; gboolean gp11_slot_equal (gconstpointer slot1,gconstpointer slot2); guint gp11_slot_hash (gconstpointer slot); GP11Module* gp11_slot_get_module (GP11Slot *self); CK_SLOT_ID gp11_slot_get_handle (GP11Slot *self); GP11SlotInfo* gp11_slot_get_info (GP11Slot *self); GP11TokenInfo* gp11_slot_get_token_info (GP11Slot *self); GP11Mechanisms* gp11_slot_get_mechanisms (GP11Slot *self); GP11MechanismInfo* gp11_slot_get_mechanism_info (GP11Slot *self,gulong mech_type); gboolean gp11_slot_has_flags (GP11Slot *self,gulong flags); GP11Session* gp11_slot_open_session (GP11Slot *self,gulong flags,GError **err); GP11Session* gp11_slot_open_session_full (GP11Slot *self,gulong flags,gpointer app_data,CK_NOTIFY notify,GCancellable *cancellable,GError **err); void gp11_slot_open_session_async (GP11Slot *self,gulong flags,gpointer app_data,CK_NOTIFY notify,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data); GP11Session* gp11_slot_open_session_finish (GP11Slot *self,GAsyncResult *result,GError **err); GP11SlotInfo; void gp11_slot_info_free (GP11SlotInfo *slot_info); GP11TokenInfo; void gp11_token_info_free (GP11TokenInfo *token_info);
"handle" gulong : Read / Write / Construct Only "module" GP11Module* : Read / Write / Construct Only
A PKCS11 slot can contain a token. As an example, a slot might be a card reader, and the token the card. If the PKCS11 module is not a hardware driver, often the slot and token are equivalent.
typedef struct {
	gulong min_key_size;
	gulong max_key_size;
	gulong flags;
} GP11MechanismInfo;
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 
gp11_mechanism_info_free().
void                gp11_mechanism_info_free            (GP11MechanismInfo *mech_info);
Free the GP11MechanismInfo and associated resources.
| 
 | The mechanism info to free, or NULL. | 
#define gp11_mechanisms_length(a) ((a)->len)
Get the number of GP11MechanismInfo in the set.
| 
 | A GP11Mechanisms set. | 
| Returns : | The number in the set. | 
#define gp11_mechanisms_at(a, i) (g_array_index(a, CK_MECHANISM_TYPE, i))
Get a specific GP11MechanismInfo in a the set.
| 
 | A GP11Mechanisms set. | 
| 
 | The index of a GP11MechanismInfo. | 
| Returns : | The GP11MechanismInfo. | 
#define gp11_mechanisms_free(a) (g_array_free(a, TRUE))
Free a GP11Mechanisms set.
| 
 | A GP11Mechanisms set. | 
gboolean gp11_mechanisms_check (GP11Mechanisms *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 GP11_INVALID.
| 
 | A list of mechanisms, perhaps retrieved from gp11_slot_get_mechanisms(). | 
| 
 | A list of mechanism types followed by GP11_INVALID. | 
| Returns : | Whether the mechanism is in the list or not. | 
gboolean gp11_slot_equal (gconstpointer slot1,gconstpointer slot2);
Checks equality of two slots. Two GP11Slot objects can point to the same underlying PKCS11 slot.
| 
 | A pointer to the first GP11Slot | 
| 
 | A pointer to the second GP11Slot | 
| Returns : | TRUE if slot1 and slot2 are equal. FALSE if either is not a GP11Slot. | 
guint               gp11_slot_hash                      (gconstpointer slot);
Create a hash value for the GP11Slot.
This function is intended for easily hashing a GP11Slot to add to a GHashTable or similar data structure.
| 
 | A pointer to a GP11Slot | 
| Returns : | An integer that can be used as a hash value, or 0 if invalid. | 
GP11Module*         gp11_slot_get_module                (GP11Slot *self);
Get the module that this slot is on.
| 
 | The slot to get the module for. | 
| Returns : | The module, you must unreference this after you're done with it. | 
CK_SLOT_ID          gp11_slot_get_handle                (GP11Slot *self);
Get the raw PKCS11 handle of a slot.
| 
 | The slot to get the handle of. | 
| Returns : | The raw handle. | 
GP11SlotInfo*       gp11_slot_get_info                  (GP11Slot *self);
Get the information for this slot.
| 
 | The slot to get info for. | 
| Returns : | The slot information. When done, use gp11_slot_info_free()to release it. | 
GP11TokenInfo*      gp11_slot_get_token_info            (GP11Slot *self);
Get the token information for this slot.
| 
 | The slot to get info for. | 
| Returns : | The token information. When done, use gp11_token_info_free()to release it. | 
GP11Mechanisms*     gp11_slot_get_mechanisms            (GP11Slot *self);
Get the available mechanisms for this slot.
| 
 | The slot to get mechanisms for. | 
| Returns : | A list of the mechanisms for this slot. Use gp11_mechanisms_free()when done with this. | 
GP11MechanismInfo* gp11_slot_get_mechanism_info (GP11Slot *self,gulong mech_type);
Get information for the specified mechanism.
| 
 | The slot to get mechanism info from. | 
| 
 | The mechanisms type to get info for. | 
| Returns : | The mechanism information, or NULL if failed. Use gp11_mechanism_info_free()when done with it. | 
gboolean gp11_slot_has_flags (GP11Slot *self,gulong flags);
Check if the PKCS11 slot has the given flags.
| 
 | The GP11Slot object. | 
| 
 | The flags to check. | 
| Returns : | Whether one or more flags exist. | 
GP11Session* gp11_slot_open_session (GP11Slot *self,gulong flags,GError **err);
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.
| 
 | The slot ot open a session on. | 
| 
 | The flags to open a session with. | 
| 
 | A location to return an error, or NULL. | 
| Returns : | A new session or NULL if an error occurs. | 
GP11Session* gp11_slot_open_session_full (GP11Slot *self,gulong flags,gpointer app_data,CK_NOTIFY notify,GCancellable *cancellable,GError **err);
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.
| 
 | The slot to open a session on. | 
| 
 | The flags to open a session with. | 
| 
 | Application data for notification callback. | 
| 
 | PKCS11 notification callback. | 
| 
 | Optional cancellation object, or NULL. | 
| 
 | A location to return an error, or NULL. | 
| Returns : | A new session or NULL if an error occurs. | 
void gp11_slot_open_session_async (GP11Slot *self,gulong 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.
| 
 | The slot to open a session on. | 
| 
 | The flags to open a session with. | 
| 
 | Application data for notification callback. | 
| 
 | PKCS11 notification callback. | 
| 
 | Optional cancellation object, or NULL. | 
| 
 | Called when the operation completes. | 
| 
 | Data to pass to the callback. | 
GP11Session* gp11_slot_open_session_finish (GP11Slot *self,GAsyncResult *result,GError **err);
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.
| 
 | The slot to open a session on. | 
| 
 | The result passed to the callback. | 
| 
 | A location to return an error or NULL. | 
| Returns : | The new session or NULL if an error occurs. | 
typedef struct {
	gchar *slot_description;
	gchar *manufacturer_id;
	gulong flags;
	guint8 hardware_version_major;
	guint8 hardware_version_minor;
	guint8 firmware_version_major;
	guint8 firmware_version_minor;
} GP11SlotInfo;
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 
gp11_slot_info_free().
| gchar * | Description of the slot. | 
| gchar * | The manufacturer of this slot. | 
| gulong  | Various PKCS11 flags that apply to this slot. | 
| guint8  | The major version of the hardware. | 
| guint8  | The minor version of the hardware. | 
| guint8  | The major version of the firmware. | 
| guint8  | The minor version of the firmware. | 
void                gp11_slot_info_free                 (GP11SlotInfo *slot_info);
Free the GP11SlotInfo and associated resources.
| 
 | The slot info to free, or NULL. | 
typedef struct {
	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;
} GP11TokenInfo;
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 
gp11_token_info_free().
| gchar * | The displayable token label. | 
| gchar * | The manufacturer of this slot. | 
| gchar * | The token model number as a string. | 
| gchar * | The token serial number as a string. | 
| gulong  | Various PKCS11 flags that apply to this token. | 
| glong  | The maximum number of sessions allowed on this token. | 
| glong  | The number of sessions open on this token. | 
| glong  | The maximum number of read/write sessions allowed on this token. | 
| glong  | The number of sessions open on this token. | 
| glong  | The maximum length of a PIN for locking this token. | 
| glong  | The minimum length of a PIN for locking this token. | 
| glong  | The total amount of memory on this token for storing public objects. | 
| glong  | The available amount of memory on this token for storing public objects. | 
| glong  | The total amount of memory on this token for storing private objects. | 
| glong  | The available amount of memory on this token for storing private objects. | 
| guint8  | The major version of the hardware. | 
| guint8  | The minor version of the hardware. | 
| guint8  | The major version of the firmware. | 
| guint8  | The minor version of the firmware. | 
| gint64  | If the token has a hardware clock, this is set to the number of seconds since the epoch. | 
void                gp11_token_info_free                (GP11TokenInfo *token_info);
Free the GP11TokenInfo and associated resources.
| 
 | The token info to free, or NULL. | 
"handle" property"handle" gulong : Read / Write / Construct Only
The raw CK_SLOT_ID handle of this slot.
"module" property"module" GP11Module* : Read / Write / Construct Only
The PKCS11 object that this slot is a part of.