|  |  |  | GP11 Reference Manual |  | 
|---|---|---|---|---|
| Top | Description | Object Hierarchy | Properties | Signals | ||||
                    GP11Session;
GP11Session*        gp11_session_from_handle            (GP11Slot *slot,
                                                         CK_SESSION_HANDLE handle);
GP11Module*         gp11_session_get_module             (GP11Session *self);
GP11Slot*           gp11_session_get_slot               (GP11Session *self);
CK_SESSION_HANDLE   gp11_session_get_handle             (GP11Session *self);
GP11SessionInfo*    gp11_session_get_info               (GP11Session *self);
gboolean            gp11_session_login                  (GP11Session *self,
                                                         gulong user_type,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GError **err);
gboolean            gp11_session_login_full             (GP11Session *self,
                                                         gulong user_type,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GError **err);
void                gp11_session_login_async            (GP11Session *self,
                                                         gulong user_type,
                                                         const guchar *pin,
                                                         gsize n_pin,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            gp11_session_login_finish           (GP11Session *self,
                                                         GAsyncResult *result,
                                                         GError **err);
gboolean            gp11_session_logout                 (GP11Session *self,
                                                         GError **err);
gboolean            gp11_session_logout_full            (GP11Session *self,
                                                         GCancellable *cancellable,
                                                         GError **err);
void                gp11_session_logout_async           (GP11Session *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            gp11_session_logout_finish          (GP11Session *self,
                                                         GAsyncResult *result,
                                                         GError **err);
GP11Object*         gp11_session_create_object          (GP11Session *self,
                                                         GError **err,
                                                         ...);
void                gp11_session_create_object_async    (GP11Session *self,
                                                         GP11Attributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GP11Object*         gp11_session_create_object_finish   (GP11Session *self,
                                                         GAsyncResult *result,
                                                         GError **err);
GList*              gp11_session_find_objects           (GP11Session *self,
                                                         GError **err,
                                                         ...);
void                gp11_session_find_objects_async     (GP11Session *self,
                                                         GP11Attributes *attrs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GList*              gp11_session_find_objects_finish    (GP11Session *self,
                                                         GAsyncResult *result,
                                                         GError **err);
guchar*             gp11_session_encrypt                (GP11Session *self,
                                                         GP11Object *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GError **err);
guchar*             gp11_session_encrypt_full           (GP11Session *self,
                                                         GP11Object *key,
                                                         GP11Mechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);
void                gp11_session_encrypt_async          (GP11Session *self,
                                                         GP11Object *key,
                                                         GP11Mechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
guchar*             gp11_session_encrypt_finish         (GP11Session *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **err);
guchar*             gp11_session_decrypt                (GP11Session *self,
                                                         GP11Object *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GError **err);
guchar*             gp11_session_decrypt_full           (GP11Session *self,
                                                         GP11Object *key,
                                                         GP11Mechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);
void                gp11_session_decrypt_async          (GP11Session *self,
                                                         GP11Object *key,
                                                         GP11Mechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
guchar*             gp11_session_decrypt_finish         (GP11Session *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **err);
guchar*             gp11_session_sign                   (GP11Session *self,
                                                         GP11Object *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GError **err);
guchar*             gp11_session_sign_full              (GP11Session *self,
                                                         GP11Object *key,
                                                         GP11Mechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         gsize *n_result,
                                                         GCancellable *cancellable,
                                                         GError **err);
void                gp11_session_sign_async             (GP11Session *self,
                                                         GP11Object *key,
                                                         GP11Mechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
guchar*             gp11_session_sign_finish            (GP11Session *self,
                                                         GAsyncResult *result,
                                                         gsize *n_result,
                                                         GError **err);
gboolean            gp11_session_verify                 (GP11Session *self,
                                                         GP11Object *key,
                                                         gulong mech_type,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         const guchar *signature,
                                                         gsize n_signature,
                                                         GError **err);
gboolean            gp11_session_verify_full            (GP11Session *self,
                                                         GP11Object *key,
                                                         GP11Mechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         const guchar *signature,
                                                         gsize n_signature,
                                                         GCancellable *cancellable,
                                                         GError **err);
void                gp11_session_verify_async           (GP11Session *self,
                                                         GP11Object *key,
                                                         GP11Mechanism *mechanism,
                                                         const guchar *input,
                                                         gsize n_input,
                                                         const guchar *signature,
                                                         gsize n_signature,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            gp11_session_verify_finish          (GP11Session *self,
                                                         GAsyncResult *result,
                                                         GError **err);
                    GP11SessionInfo;
void                gp11_session_info_free              (GP11SessionInfo *session_info);
                    GP11Mechanism;
"handle" gulong : Read / Write / Construct Only "module" GP11Module* : Read / Write / Construct Only "slot" GP11Slot* : Read / Write / Construct Only
Before performing any PKCS11 operations, a session must be opened. This is analogous to an open database handle, or a file handle.
GP11Session* gp11_session_from_handle (GP11Slot *slot, CK_SESSION_HANDLE handle);
Initialize a GP11Session object from a raw PKCS11 session handle.
Usually one would use the gp11_slot_open_session() function to 
create a session.
| 
 | The slot which the session belongs to. | 
| 
 | The raw PKCS11 handle of the session. | 
| Returns : | The new GP11Session object. | 
GP11Module* gp11_session_get_module (GP11Session *self);
Get the PKCS11 module to which this session belongs.
| 
 | The session object. | 
| Returns : | The module, which should be unreffed after use. | 
GP11Slot* gp11_session_get_slot (GP11Session *self);
Get the PKCS11 slot to which this session belongs.
| 
 | The session object. | 
| Returns : | The slot, which should be unreffed after use. | 
CK_SESSION_HANDLE gp11_session_get_handle (GP11Session *self);
Get the raw PKCS11 session handle from a GP11Session object.
| 
 | The session object. | 
| Returns : | The raw session handle. | 
GP11SessionInfo* gp11_session_get_info (GP11Session *self);
Get information about the session.
| 
 | The session object. | 
| Returns : | The session info. Use the gp11_session_info_free()to release
when done. | 
gboolean gp11_session_login (GP11Session *self, gulong user_type, const guchar *pin, gsize n_pin, GError **err);
Login the user on the session. This call may block for an indefinite period.
| 
 | Log into this session. | 
| 
 | The type of login user. | 
| 
 | The user's PIN, or NULL for protected authentication path. | 
| 
 | The length of the PIN. | 
| 
 | A location to return an error. | 
| Returns : | Whether successful or not. | 
gboolean gp11_session_login_full (GP11Session *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.
| 
 | Log into this session. | 
| 
 | The type of login user. | 
| 
 | The user's PIN, or NULL for protected authentication path. | 
| 
 | The length of the PIN. | 
| 
 | Optional cancellation object, or NULL. | 
| 
 | A location to return an error. | 
| Returns : | Whether successful or not. | 
void gp11_session_login_async (GP11Session *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.
| 
 | Log into this session. | 
| 
 | The type of login user. | 
| 
 | The user's PIN, or NULL for protected authentication path. | 
| 
 | The length of the PIN. | 
| 
 | Optional cancellation object, or NULL. | 
| 
 | Called when the operation completes. | 
| 
 | Data to pass to the callback. | 
gboolean gp11_session_login_finish (GP11Session *self, GAsyncResult *result, GError **err);
Get the result of a login operation.
| 
 | The session logged into. | 
| 
 | The result passed to the callback. | 
| 
 | A location to return an error. | 
| Returns : | Whether the operation was successful or not. | 
gboolean gp11_session_logout (GP11Session *self, GError **err);
Log out of the session. This call may block for an indefinite period.
| 
 | Logout of this session. | 
| 
 | A location to return an error. | 
| Returns : | Whether the logout was successful or not. | 
gboolean gp11_session_logout_full (GP11Session *self, GCancellable *cancellable, GError **err);
Log out of the session. This call may block for an indefinite period.
| 
 | Logout of this session. | 
| 
 | Optional cancellation object, or NULL. | 
| 
 | A location to return an error. | 
| Returns : | Whether the logout was successful or not. | 
void gp11_session_logout_async (GP11Session *self, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
Log out of the session. This call returns immediately and completes asynchronously.
| 
 | Logout of this session. | 
| 
 | Optional cancellation object, or NULL. | 
| 
 | Called when the operation completes. | 
| 
 | Data to pass to the callback. | 
gboolean gp11_session_logout_finish (GP11Session *self, GAsyncResult *result, GError **err);
Get the result of logging out of a session.
| 
 | Logout of this session. | 
| 
 | The result passed to the callback. | 
| 
 | A location to return an error. | 
| Returns : | Whether the logout was successful or not. | 
GP11Object* gp11_session_create_object (GP11Session *self, GError **err, ...);
Create a new PKCS11 object. This call may block for an indefinite period.
The arguments must be triples of: attribute type, data type, value
The variable argument list should contain:
| a) | The gulong attribute type (ie: CKA_LABEL). | 
| b) | The attribute data type (one of GP11_BOOLEAN, GP11_ULONG, GP11_STRING, GP11_DATE) orthe raw attribute value length. | 
| c) | The attribute value, either a gboolean, gulong, gchar*, GDate* or a pointer to a raw attribute value. | 
The variable argument list should be terminated with GP11_INVALID.
| 
 | The session to create the object on. | 
| 
 | A location to store an error. | 
| 
 | The attributes to create the new object with. | 
| Returns : | The newly created object, or NULL if an error occurred. | 
void gp11_session_create_object_async (GP11Session *self, GP11Attributes *attrs, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
Create a new PKCS11 object. This call will return immediately and complete asynchronously.
| 
 | The session to create the object on. | 
| 
 | The attributes to create the object with. | 
| 
 | Optional cancellation object or NULL. | 
| 
 | Called when the operation completes. | 
| 
 | Data to pass to the callback. | 
GP11Object* gp11_session_create_object_finish (GP11Session *self, GAsyncResult *result, GError **err);
Get the result of creating a new PKCS11 object.
| 
 | The session to create the object on. | 
| 
 | The result passed to the callback. | 
| 
 | A location to return an error, or NULL. | 
| Returns : | The newly created object or NULL if an error occurred. | 
GList* gp11_session_find_objects (GP11Session *self, GError **err, ...);
Find objects matching the passed attributes. This call may block for an indefinite period.
The arguments must be triples of: attribute type, data type, value
The variable argument list should contain:
| a) | The gulong attribute type (ie: CKA_LABEL). | 
| b) | The attribute data type (one of GP11_BOOLEAN, GP11_ULONG, GP11_STRING, GP11_DATE) orthe raw attribute value length. | 
| c) | The attribute value, either a gboolean, gulong, gchar*, GDate* or a pointer to a raw attribute value. | 
The variable argument list should be terminated with GP11_INVALID.
| 
 | The session to find objects on. | 
| 
 | A location to return an error or NULL. | 
| 
 | The attributes to match. | 
| Returns : | A list of the matching objects, which may be empty. | 
void gp11_session_find_objects_async (GP11Session *self, GP11Attributes *attrs, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
Find the objects matching the passed attributes. This call will return immediately and complete asynchronously.
| 
 | The session to find objects on. | 
| 
 | The attributes to match. | 
| 
 | Optional cancellation object or NULL. | 
| 
 | Called when the operation completes. | 
| 
 | Data to pass to the callback. | 
GList* gp11_session_find_objects_finish (GP11Session *self, GAsyncResult *result, GError **err);
Get the result of a find operation.
| 
 | The session to find objects on. | 
| 
 | The attributes to match. | 
| 
 | A location to return an error. | 
| Returns : | A list of the matching objects, which may be empty. | 
guchar* gp11_session_encrypt (GP11Session *self, GP11Object *key, gulong mech_type, const guchar *input, gsize n_input, gsize *n_result, GError **err);
Encrypt data in a mechanism specific manner. This call may block for an indefinite period.
| 
 | The session. | 
| 
 | The key to encrypt with. | 
| 
 | The mechanism type to use for encryption. | 
| 
 | The data to encrypt. | 
| 
 | The length of the data to encrypt. | 
| 
 | A location to store the length of the result data. | 
| 
 | A location to place error information. | 
| Returns : | The data that was encrypted, or NULL if an error occured. | 
guchar* gp11_session_encrypt_full (GP11Session *self, GP11Object *key, GP11Mechanism *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.
| 
 | The session. | 
| 
 | The key to encrypt with. | 
| 
 | The mechanism type and parameters to use for encryption. | 
| 
 | The data to encrypt. | 
| 
 | The length of the data to encrypt. | 
| 
 | A location to store the length of the result data. | 
| 
 | A GCancellable which can be used to cancel the operation. | 
| 
 | A location to place error information. | 
| Returns : | The data that was encrypted, or NULL if an error occured. | 
void gp11_session_encrypt_async (GP11Session *self, GP11Object *key, GP11Mechanism *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.
| 
 | The session. | 
| 
 | The key to encrypt with. | 
| 
 | The mechanism type and parameters to use for encryption. | 
| 
 | The data to encrypt. | 
| 
 | The length of the data to encrypt. | 
| 
 | A GCancellable which can be used to cancel the operation. | 
| 
 | Called when the operation completes. | 
| 
 | A pointer to pass to the callback. | 
guchar* gp11_session_encrypt_finish (GP11Session *self, GAsyncResult *result, gsize *n_result, GError **err);
Get the result of an encryption operation.
| 
 | The session. | 
| 
 | The result object passed to the callback. | 
| 
 | A location to store the length of the result data. | 
| 
 | A location to place error information. | 
| Returns : | The data that was encrypted, or NULL if an error occurred. | 
guchar* gp11_session_decrypt (GP11Session *self, GP11Object *key, gulong mech_type, const guchar *input, gsize n_input, gsize *n_result, GError **err);
Decrypt data in a mechanism specific manner. This call may block for an indefinite period.
| 
 | The session. | 
| 
 | The key to decrypt with. | 
| 
 | The mechanism type to use for decryption. | 
| 
 | The data to decrypt. | 
| 
 | The length of the data to decrypt. | 
| 
 | A location to store the length of the result data. | 
| 
 | A location to place an error. | 
| Returns : | The data that was decrypted, or NULL if an error occured. | 
guchar* gp11_session_decrypt_full (GP11Session *self, GP11Object *key, GP11Mechanism *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.
| 
 | The session. | 
| 
 | The key to decrypt with. | 
| 
 | The mechanism type and parameters to use for decryption. | 
| 
 | The data to decrypt. | 
| 
 | The length of the data to decrypt. | 
| 
 | A location to store the length of the result data. | 
| 
 | A GCancellable which can be used to cancel the operation. | 
| 
 | A location to place error information. | 
| Returns : | The data that was decrypted, or NULL if an error occured. | 
void gp11_session_decrypt_async (GP11Session *self, GP11Object *key, GP11Mechanism *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.
| 
 | The session. | 
| 
 | The key to decrypt with. | 
| 
 | The mechanism type and parameters to use for decryption. | 
| 
 | The data to decrypt. | 
| 
 | The length of the data to decrypt. | 
| 
 | A GCancellable which can be used to cancel the operation. | 
| 
 | Called when the operation completes. | 
| 
 | A pointer to pass to the callback. | 
guchar* gp11_session_decrypt_finish (GP11Session *self, GAsyncResult *result, gsize *n_result, GError **err);
Get the result of an decryption operation.
| 
 | The session. | 
| 
 | The result object passed to the callback. | 
| 
 | A location to store the length of the result data. | 
| 
 | A location to place error information. | 
| Returns : | The data that was decrypted, or NULL if an error occurred. | 
guchar* gp11_session_sign (GP11Session *self, GP11Object *key, gulong mech_type, const guchar *input, gsize n_input, gsize *n_result, GError **err);
Sign data in a mechanism specific manner. This call may block for an indefinite period.
| 
 | The session. | 
| 
 | The key to sign with. | 
| 
 | The mechanism type to use for signing. | 
| 
 | The data to sign. | 
| 
 | The length of the data to sign. | 
| 
 | A location to store the length of the result data. | 
| 
 | A location to place an error. | 
| Returns : | The data that was signed, or NULL if an error occured. | 
guchar* gp11_session_sign_full (GP11Session *self, GP11Object *key, GP11Mechanism *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.
| 
 | The session. | 
| 
 | The key to sign with. | 
| 
 | The mechanism type and parameters to use for signing. | 
| 
 | The data to sign. | 
| 
 | The length of the data to sign. | 
| 
 | A location to store the length of the result data. | 
| 
 | A GCancellable which can be used to cancel the operation. | 
| 
 | A location to place error information. | 
| Returns : | The data that was signed, or NULL if an error occured. | 
void gp11_session_sign_async (GP11Session *self, GP11Object *key, GP11Mechanism *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.
| 
 | The session. | 
| 
 | The key to sign with. | 
| 
 | The mechanism type and parameters to use for signing. | 
| 
 | The data to sign. | 
| 
 | The length of the data to sign. | 
| 
 | A GCancellable which can be used to cancel the operation. | 
| 
 | Called when the operation completes. | 
| 
 | A pointer to pass to the callback. | 
guchar* gp11_session_sign_finish (GP11Session *self, GAsyncResult *result, gsize *n_result, GError **err);
Get the result of an signing operation.
| 
 | The session. | 
| 
 | The result object passed to the callback. | 
| 
 | A location to store the length of the result data. | 
| 
 | A location to place error information. | 
| Returns : | The data that was signed, or NULL if an error occurred. | 
gboolean gp11_session_verify (GP11Session *self, GP11Object *key, gulong mech_type, const guchar *input, gsize n_input, const guchar *signature, gsize n_signature, GError **err);
Verify data in a mechanism specific manner. This call may block for an indefinite period.
| 
 | The session. | 
| 
 | The key to verify with. | 
| 
 | The mechanism type to use for verifying. | 
| 
 | The data to verify. | 
| 
 | The length of the data to verify. | 
| 
 | The signature. | 
| 
 | The length of the signature. | 
| 
 | A location to place an error. | 
| Returns : | TRUE if the data verified correctly, otherwise a failure or error occurred. | 
gboolean gp11_session_verify_full (GP11Session *self, GP11Object *key, GP11Mechanism *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.
| 
 | The session. | 
| 
 | The key to verify with. | 
| 
 | The mechanism type and parameters to use for signing. | 
| 
 | The data to verify. | 
| 
 | The length of the data to verify. | 
| 
 | The signature. | 
| 
 | The length of the signature. | 
| 
 | A GCancellable which can be used to cancel the operation. | 
| 
 | A location to place an error. | 
| Returns : | TRUE if the data verified correctly, otherwise a failure or error occurred. | 
void gp11_session_verify_async (GP11Session *self, GP11Object *key, GP11Mechanism *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.
| 
 | The session. | 
| 
 | The key to verify with. | 
| 
 | The mechanism type and parameters to use for signing. | 
| 
 | The data to verify. | 
| 
 | The length of the data to verify. | 
| 
 | The signature. | 
| 
 | The length of the signature. | 
| 
 | A GCancellable which can be used to cancel the operation. | 
| 
 | Called when the operation completes. | 
| 
 | A pointer to pass to the callback. | 
gboolean gp11_session_verify_finish (GP11Session *self, GAsyncResult *result, GError **err);
Get the result of an verify operation.
| 
 | The session. | 
| 
 | The result object passed to the callback. | 
| 
 | A location to place error information. | 
| Returns : | TRUE if the data verified correctly, otherwise a failure or error occurred. | 
typedef struct {
	gulong slot_id;
	gulong state;
	gulong flags;
	gulong device_error;
} GP11SessionInfo;
Information about the session. This is analogous to a CK_SESSION_INFO structure.
When done with this structure, release it using gp11_session_info_free().
void gp11_session_info_free (GP11SessionInfo *session_info);
Free the GP11SessionInfo structure and all associated memory.
| 
 | Session info to free. | 
"handle" property"handle" gulong : Read / Write / Construct Only
The raw CK_SESSION_HANDLE handle of this session.
"module" property"module" GP11Module* : Read / Write / Construct Only
The GP11Module that this session is opened on.
"slot" property"slot" GP11Slot* : Read / Write / Construct Only
The GP11Slot this session is opened on.
"discard-handle" signalgboolean user_function (GP11Session *session, gulong handle, gpointer user_data) : Run Last
When a GP11Session 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 
gp11_module_set_pool_sessions() to implement the module session pool.
| 
 | The session. | 
| 
 | The handle being discarded. | 
| 
 | user data set when the signal handler was connected. | 
| Returns : | Whether or not this handle was claimed. |