GckSession

GckSession — Represents an open PKCS11 session.

Synopsis

                    GckSession;
GckSession*         gck_session_from_handle             (GckSlot *slot,
                                                         CK_SESSION_HANDLE handle,
                                                         guint options);
GckModule*          gck_session_get_module              (GckSession *self);
GckSlot*            gck_session_get_slot                (GckSession *self);
CK_SESSION_HANDLE   gck_session_get_handle              (GckSession *self);
GckSessionInfo*     gck_session_get_info                (GckSession *self);
gboolean            gck_session_login                   (GckSession *self,
                                                         gulong user_type,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GError **err);
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 **err);
gboolean            gck_session_logout                  (GckSession *self,
                                                         GCancellable *cancellable,
                                                         GError **err);
void                gck_session_logout_async            (GckSession *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            gck_session_logout_finish           (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **err);
GckObject*          gck_session_create_object           (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **err);
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 **err);
GList*              gck_session_find_objects            (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **err);
void                gck_session_find_objects_async      (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GList*              gck_session_find_objects_finish     (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **err);
guchar*             gck_session_encrypt                 (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);
guchar*             gck_session_encrypt_full            (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);
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 **err);
guchar*             gck_session_decrypt                 (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);
guchar*             gck_session_decrypt_full            (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);
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 **err);
guchar*             gck_session_sign                    (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);
guchar*             gck_session_sign_full               (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);
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 **err);
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 **err);
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 **err);
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 **err);
                    GckSessionInfo;
void                gck_session_info_free               (GckSessionInfo *session_info);
                    GckMechanism;

Object Hierarchy

  GObject
   +----GckSession

Properties

  "handle"                   gulong                : Read / Write / Construct Only
  "module"                   GckModule*            : Read / Write / Construct Only
  "options"                  guint                 : Read / Write / Construct Only
  "slot"                     GckSlot*              : Read / Write / Construct Only

Signals

  "discard-handle"                                 : Run Last

Description

Before performing any PKCS11 operations, a session must be opened. This is analogous to an open database handle, or a file handle.

Details

GckSession

typedef struct _GckSession GckSession;

Represents an open PKCS11 session.


gck_session_from_handle ()

GckSession*         gck_session_from_handle             (GckSlot *slot,
                                                         CK_SESSION_HANDLE handle,
                                                         guint options);

Initialize a GckSession object from a raw PKCS11 session handle. Usually one would use the gck_slot_open_session() function to create a session.

slot :

The slot which the session belongs to.

handle :

The raw PKCS11 handle of the session.

options :

Session options. Those which are used during opening a session have no effect.

Returns :

The new GckSession object.

gck_session_get_module ()

GckModule*          gck_session_get_module              (GckSession *self);

Get the PKCS11 module to which this session belongs.

self :

The session object.

Returns :

The module, which should be unreffed after use.

gck_session_get_slot ()

GckSlot*            gck_session_get_slot                (GckSession *self);

Get the PKCS11 slot to which this session belongs.

self :

The session object.

Returns :

The slot, which should be unreffed after use.

gck_session_get_handle ()

CK_SESSION_HANDLE   gck_session_get_handle              (GckSession *self);

Get the raw PKCS11 session handle from a GckSession object.

self :

The session object.

Returns :

The raw session handle.

gck_session_get_info ()

GckSessionInfo*     gck_session_get_info                (GckSession *self);

Get information about the session.

self :

The session object.

Returns :

The session info. Use the gck_session_info_free() to release when done.

gck_session_login ()

gboolean            gck_session_login                   (GckSession *self,
                                                         gulong user_type,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GError **err);

Login the user on the session. This call may block for an indefinite period.

self :

Log in to this session.

user_type :

The type of login user.

pin :

The user's PIN, or NULL for protected authentication path.

n_pin :

The length of the PIN.

cancellable :

Optional cancellation object, or NULL.

err :

A location to return an error.

Returns :

Whether successful or not.

gck_session_login_async ()

void                gck_session_login_async             (GckSession *self,
                                                         gulong user_type,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Login the user on the session. This call will return immediately and completes asynchronously.

self :

Log in to this session.

user_type :

The type of login user.

pin :

The user's PIN, or NULL for protected authentication path.

n_pin :

The length of the PIN.

cancellable :

Optional cancellation object, or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_login_finish ()

gboolean            gck_session_login_finish            (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **err);

Get the result of a login operation.

self :

The session logged into.

result :

The result passed to the callback.

err :

A location to return an error.

Returns :

Whether the operation was successful or not.

gck_session_logout ()

gboolean            gck_session_logout                  (GckSession *self,
                                                         GCancellable *cancellable,
                                                         GError **err);

Log out of the session. This call may block for an indefinite period.

self :

Logout of this session.

cancellable :

Optional cancellation object, or NULL.

err :

A location to return an error.

Returns :

Whether the logout was successful or not.

gck_session_logout_async ()

void                gck_session_logout_async            (GckSession *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Log out of the session. This call returns immediately and completes asynchronously.

self :

Logout of this session.

cancellable :

Optional cancellation object, or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_logout_finish ()

gboolean            gck_session_logout_finish           (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **err);

Get the result of logging out of a session.

self :

Logout of this session.

result :

The result passed to the callback.

err :

A location to return an error.

Returns :

Whether the logout was successful or not.

gck_session_create_object ()

GckObject*          gck_session_create_object           (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **err);

Create a new PKCS11 object. This call may block for an indefinite period.

self :

The session to create the object on.

attrs :

The attributes to create the object with.

cancellable :

Optional cancellation object, or NULL.

err :

A location to return an error, or NULL.

Returns :

The newly created object or NULL if an error occurred.

gck_session_create_object_async ()

void                gck_session_create_object_async     (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Create a new PKCS11 object. This call will return immediately and complete asynchronously.

self :

The session to create the object on.

attrs :

The attributes to create the object with.

cancellable :

Optional cancellation object or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_create_object_finish ()

GckObject*          gck_session_create_object_finish    (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **err);

Get the result of creating a new PKCS11 object.

self :

The session to create the object on.

result :

The result passed to the callback.

err :

A location to return an error, or NULL.

Returns :

The newly created object or NULL if an error occurred.

gck_session_find_objects ()

GList*              gck_session_find_objects            (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GError **err);

Find the objects matching the passed attributes. This call may block for an indefinite period.

self :

The session to find objects on.

attrs :

The attributes to match.

cancellable :

Optional cancellation object or NULL.

err :

A location to return an error or NULL.

Returns :

A list of the matching objects, which may be empty.

gck_session_find_objects_async ()

void                gck_session_find_objects_async      (GckSession *self,
                                                         GckAttributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Find the objects matching the passed attributes. This call will return immediately and complete asynchronously.

self :

The session to find objects on.

attrs :

The attributes to match.

cancellable :

Optional cancellation object or NULL.

callback :

Called when the operation completes.

user_data :

Data to pass to the callback.

gck_session_find_objects_finish ()

GList*              gck_session_find_objects_finish     (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **err);

Get the result of a find operation.

self :

The session to find objects on.

result :

The attributes to match.

err :

A location to return an error.

Returns :

A list of the matching objects, which may be empty.

gck_session_encrypt ()

guchar*             gck_session_encrypt                 (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);

Encrypt data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to encrypt with.

mech_type :

The mechanism type to use for encryption.

input :

The data to encrypt.

n_input :

The length of the data to encrypt.

n_result :

A location to store the length of the result data.

cancellable :

err :

A location to place error information.

Returns :

The data that was encrypted, or NULL if an error occured.

gck_session_encrypt_full ()

guchar*             gck_session_encrypt_full            (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);

Encrypt data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to encrypt with.

mechanism :

The mechanism type and parameters to use for encryption.

input :

The data to encrypt.

n_input :

The length of the data to encrypt.

n_result :

A location to store the length of the result data.

cancellable :

A GCancellable which can be used to cancel the operation.

err :

A location to place error information.

Returns :

The data that was encrypted, or NULL if an error occured.

gck_session_encrypt_async ()

void                gck_session_encrypt_async           (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Encrypt data in a mechanism specific manner. This call will return immediately and complete asynchronously.

self :

The session.

key :

The key to encrypt with.

mechanism :

The mechanism type and parameters to use for encryption.

input :

The data to encrypt.

n_input :

The length of the data to encrypt.

cancellable :

A GCancellable which can be used to cancel the operation.

callback :

Called when the operation completes.

user_data :

A pointer to pass to the callback.

gck_session_encrypt_finish ()

guchar*             gck_session_encrypt_finish          (GckSession *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **err);

Get the result of an encryption operation.

self :

The session.

result :

The result object passed to the callback.

n_result :

A location to store the length of the result data.

err :

A location to place error information.

Returns :

The data that was encrypted, or NULL if an error occurred.

gck_session_decrypt ()

guchar*             gck_session_decrypt                 (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);

Decrypt data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to decrypt with.

mech_type :

The mechanism type to use for decryption.

input :

The data to decrypt.

n_input :

The length of the data to decrypt.

n_result :

A location to store the length of the result data.

cancellable :

err :

A location to place an error.

Returns :

The data that was decrypted, or NULL if an error occured.

gck_session_decrypt_full ()

guchar*             gck_session_decrypt_full            (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);

Decrypt data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to decrypt with.

mechanism :

The mechanism type and parameters to use for decryption.

input :

The data to decrypt.

n_input :

The length of the data to decrypt.

n_result :

A location to store the length of the result data.

cancellable :

A GCancellable which can be used to cancel the operation.

err :

A location to place error information.

Returns :

The data that was decrypted, or NULL if an error occured.

gck_session_decrypt_async ()

void                gck_session_decrypt_async           (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Decrypt data in a mechanism specific manner. This call will return immediately and complete asynchronously.

self :

The session.

key :

The key to decrypt with.

mechanism :

The mechanism type and parameters to use for decryption.

input :

The data to decrypt.

n_input :

The length of the data to decrypt.

cancellable :

A GCancellable which can be used to cancel the operation.

callback :

Called when the operation completes.

user_data :

A pointer to pass to the callback.

gck_session_decrypt_finish ()

guchar*             gck_session_decrypt_finish          (GckSession *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **err);

Get the result of an decryption operation.

self :

The session.

result :

The result object passed to the callback.

n_result :

A location to store the length of the result data.

err :

A location to place error information.

Returns :

The data that was decrypted, or NULL if an error occurred.

gck_session_sign ()

guchar*             gck_session_sign                    (GckSession *self,
                                                         GckObject *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);

Sign data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to sign with.

mech_type :

The mechanism type to use for signing.

input :

The data to sign.

n_input :

The length of the data to sign.

n_result :

A location to store the length of the result data.

cancellable :

err :

A location to place an error.

Returns :

The data that was signed, or NULL if an error occured.

gck_session_sign_full ()

guchar*             gck_session_sign_full               (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);

Sign data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to sign with.

mechanism :

The mechanism type and parameters to use for signing.

input :

The data to sign.

n_input :

The length of the data to sign.

n_result :

A location to store the length of the result data.

cancellable :

A GCancellable which can be used to cancel the operation.

err :

A location to place error information.

Returns :

The data that was signed, or NULL if an error occured.

gck_session_sign_async ()

void                gck_session_sign_async              (GckSession *self,
                                                         GckObject *key,
                                                         GckMechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Sign data in a mechanism specific manner. This call will return immediately and complete asynchronously.

self :

The session.

key :

The key to sign with.

mechanism :

The mechanism type and parameters to use for signing.

input :

The data to sign.

n_input :

The length of the data to sign.

cancellable :

A GCancellable which can be used to cancel the operation.

callback :

Called when the operation completes.

user_data :

A pointer to pass to the callback.

gck_session_sign_finish ()

guchar*             gck_session_sign_finish             (GckSession *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **err);

Get the result of an signing operation.

self :

The session.

result :

The result object passed to the callback.

n_result :

A location to store the length of the result data.

err :

A location to place error information.

Returns :

The data that was signed, or NULL if an error occurred.

gck_session_verify ()

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

Verify data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to verify with.

mech_type :

The mechanism type to use for verifying.

input :

The data to verify.

n_input :

The length of the data to verify.

signature :

The signature.

n_signature :

The length of the signature.

cancellable :

err :

A location to place an error.

Returns :

TRUE if the data verified correctly, otherwise a failure or error occurred.

gck_session_verify_full ()

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

Verify data in a mechanism specific manner. This call may block for an indefinite period.

self :

The session.

key :

The key to verify with.

mechanism :

The mechanism type and parameters to use for signing.

input :

The data to verify.

n_input :

The length of the data to verify.

signature :

The signature.

n_signature :

The length of the signature.

cancellable :

A GCancellable which can be used to cancel the operation.

err :

A location to place an error.

Returns :

TRUE if the data verified correctly, otherwise a failure or error occurred.

gck_session_verify_async ()

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

Verify data in a mechanism specific manner. This call returns immediately and completes asynchronously.

self :

The session.

key :

The key to verify with.

mechanism :

The mechanism type and parameters to use for signing.

input :

The data to verify.

n_input :

The length of the data to verify.

signature :

The signature.

n_signature :

The length of the signature.

cancellable :

A GCancellable which can be used to cancel the operation.

callback :

Called when the operation completes.

user_data :

A pointer to pass to the callback.

gck_session_verify_finish ()

gboolean            gck_session_verify_finish           (GckSession *self,
                                                         GAsyncResult *result,
                                                         GError **err);

Get the result of an verify operation.

self :

The session.

result :

The result object passed to the callback.

err :

A location to place error information.

Returns :

TRUE if the data verified correctly, otherwise a failure or error occurred.

GckSessionInfo

typedef struct {
	gulong slot_id;
	gulong state;
	gulong flags;
	gulong device_error;
} GckSessionInfo;

Information about the session. This is analogous to a CK_SESSION_INFO structure.

When done with this structure, release it using gck_session_info_free().

gulong slot_id;

The handle of the PKCS11 slot that this session is opened on.

gulong state;

The user login state of the session.

gulong flags;

Various PKCS11 flags.

gulong device_error;

The last device error that occurred from an operation on this session.

gck_session_info_free ()

void                gck_session_info_free               (GckSessionInfo *session_info);

Free the GckSessionInfo structure and all associated memory.

session_info :

Session info to free.

GckMechanism

typedef struct {
	gulong type;
	gconstpointer parameter;
	gulong n_parameter;
} GckMechanism;

Represents a mechanism used with crypto operations.

gulong type;

The mechanism type

gconstpointer parameter;

Mechanism specific data.

gulong n_parameter;

Length of mechanism specific data.

Property Details

The "handle" property

  "handle"                   gulong                : Read / Write / Construct Only

The raw CK_SESSION_HANDLE handle of this session.


The "module" property

  "module"                   GckModule*            : Read / Write / Construct Only

The GckModule that this session is opened on.


The "options" property

  "options"                  guint                 : Read / Write / Construct Only

The options this session was opened with.

Default value: 0


The "slot" property

  "slot"                     GckSlot*              : Read / Write / Construct Only

The GckSlot this session is opened on.

Signal Details

The "discard-handle" signal

gboolean            user_function                      (GckSession *session,
                                                        gulong      handle,
                                                        gpointer    user_data)      : Run Last

When a GckSession is being disposed of it emits this signal to allow a session pool to pick up the handle and keep it around.

If no signal handler claims the handle, then it is closed. This is used by gck_module_set_pool_sessions() to implement the module session pool.

session :

The session.

handle :

The handle being discarded.

user_data :

user data set when the signal handler was connected.

Returns :

Whether or not this handle was claimed.