|  |  |  | Gck Library Reference Manual |  | 
|---|---|---|---|---|
| Top | Description | Object Hierarchy | Properties | Signals | ||||
struct GckModule; GckModule * gck_module_initialize (const gchar *path,GCancellable *cancellable,GError **error); void gck_module_initialize_async (const gchar *path,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data); GckModule * gck_module_initialize_finish (GAsyncResult *result,GError **error); GckModule * gck_module_new (CK_FUNCTION_LIST_PTR funcs); gboolean gck_module_equal (gconstpointer module1,gconstpointer module2); guint gck_module_hash (gconstpointer module); gboolean gck_module_match (GckModule *self,GckUriData *uri); const gchar * gck_module_get_path (GckModule *self); CK_FUNCTION_LIST_PTR gck_module_get_functions (GckModule *self); GckModuleInfo * gck_module_get_info (GckModule *self); GList * gck_module_get_slots (GckModule *self,gboolean token_present); struct GckModuleInfo; GckModuleInfo * gck_module_info_copy (GckModuleInfo *module_info); void gck_module_info_free (GckModuleInfo *module_info);
"functions" gpointer : Read / Write / Construct Only "path" gchar* : Read / Write / Construct Only
A GckModule object holds a loaded PKCS#11 module. A PKCS#11 module is a shared library.
You can load and initialize a PKCS#11 module with the gck_module_initialize() call. If you already
have a loaded and initialized module that you'd like to use with the various gck functions, then
you can use gck_module_new().
GckModule * gck_module_initialize (const gchar *path,GCancellable *cancellable,GError **error);
Load and initialize a PKCS#11 module represented by a GckModule object.
| 
 | The file system path to the PKCS#11 module to load. | 
| 
 | optional cancellation object. [allow-none] | 
| 
 | A location to store an error resulting from a failed load. | 
| Returns : | The loaded PKCS#11 module or NULLif failed. [transfer full] | 
void gck_module_initialize_async (const gchar *path,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously load and initialize a PKCS#11 module represented by a GckModule object.
| 
 | the file system path to the PKCS#11 module to load | 
| 
 | optional cancellation object. [allow-none] | 
| 
 | a callback which will be called when the operation completes | 
| 
 | data to pass to the callback | 
GckModule * gck_module_initialize_finish (GAsyncResult *result,GError **error);
Finishes the asynchronous initialize operation.
| 
 | the asynchronous result | 
| 
 | location to place an error on failure | 
| Returns : | The initialized module, or NULL. [transfer full][allow-none] | 
GckModule *         gck_module_new                      (CK_FUNCTION_LIST_PTR funcs);
Create a GckModule representing a PKCS#11 module. It is assumed that this the module is already initialized. In addition it will not be finalized when complete.
| 
 | Initialized PKCS#11 function list pointer | 
| Returns : | The new PKCS#11 module. | 
gboolean gck_module_equal (gconstpointer module1,gconstpointer module2);
Checks equality of two modules. Two GckModule objects can point to the same underlying PKCS#11 module.
guint               gck_module_hash                     (gconstpointer module);
Create a hash value for the GckModule.
This function is intended for easily hashing a GckModule to add to a GHashTable or similar data structure.
| 
 | a pointer to a GckModule. [type Gck.Module] | 
| Returns : | An integer that can be used as a hash value, or 0 if invalid. | 
gboolean gck_module_match (GckModule *self,GckUriData *uri);
Check whether the PKCS#11 URI matches the module
| 
 | the module to match | 
| 
 | the uri to match against the module | 
| Returns : | whether the URI matches or not | 
const gchar *       gck_module_get_path                 (GckModule *self);
Get the file path of this module. This may not be an absolute path, and
usually reflects the path passed to gck_module_initialize().
| 
 | The module for which to get the path. | 
| Returns : | The path, do not modify or free this value. | 
CK_FUNCTION_LIST_PTR gck_module_get_functions           (GckModule *self);
Get the PKCS#11 function list for the module.
| 
 | The module for which to get the function list. | 
| Returns : | The function list, do not modify this structure. | 
GckModuleInfo *     gck_module_get_info                 (GckModule *self);
Get the info about a PKCS#11 module.
| 
 | The module to get info for. | 
| Returns : | the module info; release this with gck_module_info_free(). [transfer full] | 
GList * gck_module_get_slots (GckModule *self,gboolean token_present);
Get the GckSlot objects for a given module.
| 
 | The module for which to get the slots. | 
| 
 | Whether to limit only to slots with a token present. | 
| Returns : | The possibly empty
list of slots. Release this with gck_list_unref_free(). [element-type Gck.Slot][transfer full] | 
struct GckModuleInfo {
	guint8 pkcs11_version_major;
	guint8 pkcs11_version_minor;
	gchar *manufacturer_id;
	gulong flags;
	gchar *library_description;
	guint8 library_version_major;
	guint8 library_version_minor;
};
Holds information about the PKCS#11 module.
This structure corresponds to CK_MODULE_INFO in the PKCS#11 standard. The strings are NULL terminated for easier use.
Use gck_module_info_free() to release this structure when done with it.
| guint8  | The major version of the module. | 
| guint8  | The minor version of the module. | 
| gchar * | The module manufacturer. | 
| gulong  | The module PKCS#11 flags. | 
| gchar * | The module description. | 
| guint8  | The major version of the library. | 
| guint8  | The minor version of the library. | 
GckModuleInfo *     gck_module_info_copy                (GckModuleInfo *module_info);
Make a copy of the module info.
| 
 | a module info | 
| Returns : | a newly allocated copy module info. [transfer full] | 
void                gck_module_info_free                (GckModuleInfo *module_info);
Free a GckModuleInfo structure.
| 
 | The module info to free, or NULL. | 
"functions" property"functions" gpointer : Read / Write / Construct Only
The raw PKCS#11 function list for the module.
This points to a CK_FUNCTION_LIST structure.
"path" property"path" gchar* : Read / Write / Construct Only
The PKCS#11 module file path.
This may be set to NULL if this object was created from an already
initialized module via the gck_module_new() function.
Default value: NULL
"authenticate-object" signalgboolean            user_function                      (GckModule *module,
                                                        GckObject *object,
                                                        gchar     *label,
                                                        gpointer   password,
                                                        gpointer   user_data)      : Run Last
GckModule::authenticate-object is deprecated and should not be used in newly-written code. Since 3.4
Use gck_session_set_interaction() instead of connecting to this signal.
| 
 | The module. | 
| 
 | The object to be authenticated. | 
| 
 | A displayable label which describes the object. | 
| 
 | A gchar** where a password should be returned. | 
| 
 | user data set when the signal handler was connected. | 
"authenticate-slot" signalgboolean            user_function                      (GckModule *module,
                                                        GckSlot   *slot,
                                                        gchar     *string,
                                                        gpointer   password,
                                                        gpointer   user_data)      : Run Last
GckModule::authenticate-slot is deprecated and should not be used in newly-written code. Since 3.4
Use gck_session_set_interaction() instead of connecting to this signal.
| 
 | The module | 
| 
 | The slot to be authenticated. | 
| 
 | A displayable label which describes the object. | 
| 
 | A gchar** where a password should be returned. | 
| 
 | user data set when the signal handler was connected. |