Add subclassable CK_X_FUNCTION_LIST

One of the flaws in PKCS#11 for our usage is that each PKCS#11 module
is not passed the pointer to the function list, ie: the vtable

Here we define a new function list vtable, where each PKCS#11 function
takes the vtable itself as the first argument. We use this new
list internally to represent subclassable PKCS#11 modules for
various features.

1 files changed, 755 insertions, 2 deletions

diff --git a/common/mock.c b/common/mock.c
index 1a283b9..6176fa9 100644
--- a/common/mock.c
+++ b/common/mock.c
@@ -407,6 +407,13 @@ done:
 }
 
 CK_RV
+mock_X_Initialize (CK_X_FUNCTION_LIST *self,
+                   CK_VOID_PTR init_args)
+{
+	return mock_C_Initialize (init_args);
+}
+
+CK_RV
 mock_C_Initialize__fails (CK_VOID_PTR init_args)
 {
 	return CKR_FUNCTION_FAILED;
@@ -439,6 +446,13 @@ mock_C_Finalize (CK_VOID_PTR reserved)
 	return CKR_OK;
 }
 
+CK_RV
+mock_X_Finalize (CK_X_FUNCTION_LIST *self,
+                 CK_VOID_PTR reserved)
+{
+	return mock_C_Finalize (reserved);
+}
+
 static const CK_INFO MOCK_INFO = {
 	{ CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },
 	"MOCK MANUFACTURER               ",
@@ -458,6 +472,13 @@ mock_C_GetInfo (CK_INFO_PTR info)
 }
 
 CK_RV
+mock_X_GetInfo (CK_X_FUNCTION_LIST *self,
+                CK_INFO_PTR info)
+{
+	return mock_C_GetInfo (info);
+}
+
+CK_RV
 mock_C_GetFunctionList_not_supported (CK_FUNCTION_LIST_PTR_PTR list)
 {
 	/* This would be a strange call to receive, should be overridden  */
@@ -505,6 +526,18 @@ mock_C_GetSlotList__no_tokens (CK_BBOOL token_present,
 	return CKR_OK;
 }
 
+CK_RV
+mock_X_GetSlotList__no_tokens (CK_X_FUNCTION_LIST *self,
+                               CK_BBOOL token_present,
+                               CK_SLOT_ID_PTR slot_list,
+                               CK_ULONG_PTR count)
+{
+	return mock_C_GetSlotList__no_tokens (token_present,
+	                                      slot_list,
+	                                      count);
+;
+}
+
 /* Update mock-module.h URIs when updating this */
 
 static const CK_SLOT_INFO MOCK_INFO_ONE = {
@@ -569,6 +602,16 @@ mock_C_GetSlotInfo__invalid_slotid (CK_SLOT_ID id,
 	return CKR_SLOT_ID_INVALID;
 }
 
+CK_RV
+mock_X_GetSlotInfo__invalid_slotid (CK_X_FUNCTION_LIST *self,
+                                    CK_SLOT_ID id,
+                                    CK_SLOT_INFO_PTR info)
+{
+	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
+
+	return CKR_SLOT_ID_INVALID;
+}
+
 /* Update gck-mock.h URIs when updating this */
 
 static const CK_TOKEN_INFO MOCK_TOKEN_ONE = {
@@ -617,6 +660,16 @@ mock_C_GetTokenInfo__invalid_slotid (CK_SLOT_ID slot_id,
 	return CKR_SLOT_ID_INVALID;
 }
 
+CK_RV
+mock_X_GetTokenInfo__invalid_slotid (CK_X_FUNCTION_LIST *self,
+                                     CK_SLOT_ID slot_id,
+                                     CK_TOKEN_INFO_PTR info)
+{
+	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
+
+	return CKR_SLOT_ID_INVALID;
+}
+
 /*
  * TWO mechanisms:
  *  CKM_MOCK_CAPITALIZE
@@ -651,8 +704,8 @@ mock_C_GetMechanismList (CK_SLOT_ID slot_id,
 }
 
 CK_RV
-mock_C_GetTokenInfo_not_initialized (CK_SLOT_ID slot_id,
-                                     CK_TOKEN_INFO_PTR info)
+mock_C_GetTokenInfo__not_initialized (CK_SLOT_ID slot_id,
+                                      CK_TOKEN_INFO_PTR info)
 {
 	CK_RV rv;
 
@@ -679,6 +732,17 @@ mock_C_GetMechanismList__invalid_slotid (CK_SLOT_ID id,
 	return CKR_SLOT_ID_INVALID;
 }
 
+CK_RV
+mock_X_GetMechanismList__invalid_slotid (CK_X_FUNCTION_LIST *self,
+                                         CK_SLOT_ID id,
+                                         CK_MECHANISM_TYPE_PTR mechanism_list,
+                                         CK_ULONG_PTR count)
+{
+	return_val_if_fail (count, CKR_ARGUMENTS_BAD);
+
+	return CKR_SLOT_ID_INVALID;
+}
+
 static const CK_MECHANISM_INFO MOCK_MECH_CAPITALIZE = {
 	512, 4096, CKF_ENCRYPT | CKF_DECRYPT
 };
@@ -721,6 +785,17 @@ mock_C_GetMechanismInfo__invalid_slotid (CK_SLOT_ID slot_id,
 }
 
 CK_RV
+mock_X_GetMechanismInfo__invalid_slotid (CK_X_FUNCTION_LIST *self,
+                                         CK_SLOT_ID slot_id,
+                                         CK_MECHANISM_TYPE type,
+                                         CK_MECHANISM_INFO_PTR info)
+{
+	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
+
+	return CKR_SLOT_ID_INVALID;
+}
+
+CK_RV
 mock_C_InitToken__specific_args (CK_SLOT_ID slot_id,
                                  CK_UTF8CHAR_PTR pin,
                                  CK_ULONG pin_len,
@@ -757,6 +832,16 @@ mock_C_InitToken__invalid_slotid (CK_SLOT_ID slot_id,
 }
 
 CK_RV
+mock_X_InitToken__invalid_slotid (CK_X_FUNCTION_LIST *self,
+                                  CK_SLOT_ID slot_id,
+                                  CK_UTF8CHAR_PTR pin,
+                                  CK_ULONG pin_len,
+                                  CK_UTF8CHAR_PTR label)
+{
+	return CKR_SLOT_ID_INVALID;
+}
+
+CK_RV
 mock_C_WaitForSlotEvent (CK_FLAGS flags,
                          CK_SLOT_ID_PTR slot,
                          CK_VOID_PTR reserved)
@@ -781,6 +866,17 @@ mock_C_WaitForSlotEvent__no_event (CK_FLAGS flags,
 }
 
 CK_RV
+mock_X_WaitForSlotEvent__no_event (CK_X_FUNCTION_LIST *self,
+                                   CK_FLAGS flags,
+                                   CK_SLOT_ID_PTR slot,
+                                   CK_VOID_PTR reserved)
+{
+	return_val_if_fail (slot, CKR_ARGUMENTS_BAD);
+
+	return CKR_NO_EVENT;
+}
+
+CK_RV
 mock_C_OpenSession (CK_SLOT_ID slot_id,
                     CK_FLAGS flags,
                     CK_VOID_PTR user_data,
@@ -828,6 +924,19 @@ mock_C_OpenSession__invalid_slotid (CK_SLOT_ID slot_id,
 }
 
 CK_RV
+mock_X_OpenSession__invalid_slotid (CK_X_FUNCTION_LIST *self,
+                                    CK_SLOT_ID slot_id,
+                                    CK_FLAGS flags,
+                                    CK_VOID_PTR user_data,
+                                    CK_NOTIFY callback,
+                                    CK_SESSION_HANDLE_PTR session)
+{
+	return_val_if_fail (session, CKR_ARGUMENTS_BAD);
+
+	return CKR_SLOT_ID_INVALID;
+}
+
+CK_RV
 mock_C_OpenSession__fails (CK_SLOT_ID slot_id,
                            CK_FLAGS flags,
                            CK_VOID_PTR user_data,
@@ -859,6 +968,13 @@ mock_C_CloseSession__invalid_handle (CK_SESSION_HANDLE session)
 }
 
 CK_RV
+mock_X_CloseSession__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                     CK_SESSION_HANDLE session)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_CloseAllSessions (CK_SLOT_ID slot_id)
 {
 	if (slot_id == MOCK_SLOT_TWO_ID)
@@ -877,6 +993,13 @@ mock_C_CloseAllSessions__invalid_slotid (CK_SLOT_ID slot_id)
 }
 
 CK_RV
+mock_X_CloseAllSessions__invalid_slotid (CK_X_FUNCTION_LIST *self,
+                                         CK_SLOT_ID slot_id)
+{
+	return CKR_SLOT_ID_INVALID;
+}
+
+CK_RV
 mock_C_GetFunctionStatus (CK_SESSION_HANDLE session)
 {
 	if (!p11_dict_get (the_sessions, handle_to_pointer (session)))
@@ -942,6 +1065,16 @@ mock_C_GetSessionInfo__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_GetSessionInfo__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                       CK_SESSION_HANDLE session,
+                                       CK_SESSION_INFO_PTR info)
+{
+	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_InitPIN__specific_args (CK_SESSION_HANDLE session,
                                CK_UTF8CHAR_PTR pin,
                                CK_ULONG pin_len)
@@ -972,6 +1105,15 @@ mock_C_InitPIN__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_InitPIN__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                CK_SESSION_HANDLE session,
+                                CK_UTF8CHAR_PTR pin,
+                                CK_ULONG pin_len)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_SetPIN__specific_args (CK_SESSION_HANDLE session,
                               CK_UTF8CHAR_PTR old_pin,
                               CK_ULONG old_pin_len,
@@ -1011,6 +1153,17 @@ mock_C_SetPIN__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_SetPIN__invalid_handle (CK_X_FUNCTION_LIST *self,
+                               CK_SESSION_HANDLE session,
+                               CK_UTF8CHAR_PTR old_pin,
+                               CK_ULONG old_pin_len,
+                               CK_UTF8CHAR_PTR new_pin,
+                               CK_ULONG new_pin_len)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_GetOperationState (CK_SESSION_HANDLE session,
                           CK_BYTE_PTR operation_state,
                           CK_ULONG_PTR operation_state_len)
@@ -1045,6 +1198,15 @@ mock_C_GetOperationState__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_GetOperationState__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                          CK_SESSION_HANDLE session,
+                                          CK_BYTE_PTR operation_state,
+                                          CK_ULONG_PTR operation_state_len)
+{
+	return CKR_FUNCTION_NOT_SUPPORTED;
+}
+
+CK_RV
 mock_C_SetOperationState (CK_SESSION_HANDLE session,
                           CK_BYTE_PTR operation_state,
                           CK_ULONG operation_state_len,
@@ -1079,6 +1241,17 @@ mock_C_SetOperationState__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_SetOperationState__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                          CK_SESSION_HANDLE session,
+                                          CK_BYTE_PTR operation_state,
+                                          CK_ULONG operation_state_len,
+                                          CK_OBJECT_HANDLE encryption_key,
+                                          CK_OBJECT_HANDLE authentication_key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_Login (CK_SESSION_HANDLE session,
               CK_USER_TYPE user_type,
               CK_UTF8CHAR_PTR pin,
@@ -1127,6 +1300,16 @@ mock_C_Login__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_Login__invalid_handle (CK_X_FUNCTION_LIST *self,
+                              CK_SESSION_HANDLE session,
+                              CK_USER_TYPE user_type,
+                              CK_UTF8CHAR_PTR pin,
+                              CK_ULONG pin_len)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_Logout (CK_SESSION_HANDLE session)
 {
 	Session *sess;
@@ -1150,6 +1333,13 @@ mock_C_Logout__invalid_handle (CK_SESSION_HANDLE session)
 }
 
 CK_RV
+mock_X_Logout__invalid_handle (CK_X_FUNCTION_LIST *self,
+                               CK_SESSION_HANDLE session)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_CreateObject (CK_SESSION_HANDLE session,
                      CK_ATTRIBUTE_PTR template,
                      CK_ULONG count,
@@ -1195,6 +1385,18 @@ mock_C_CreateObject__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_CreateObject__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                     CK_SESSION_HANDLE session,
+                                     CK_ATTRIBUTE_PTR template,
+                                     CK_ULONG count,
+                                     CK_OBJECT_HANDLE_PTR new_object)
+{
+	return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_CopyObject (CK_SESSION_HANDLE session,
                    CK_OBJECT_HANDLE object,
                    CK_ATTRIBUTE_PTR template,
@@ -1246,6 +1448,19 @@ mock_C_CopyObject__invalid_handle (CK_SESSION_HANDLE session,
 
 
 CK_RV
+mock_X_CopyObject__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                   CK_SESSION_HANDLE session,
+                                   CK_OBJECT_HANDLE object,
+                                   CK_ATTRIBUTE_PTR template,
+                                   CK_ULONG count,
+                                   CK_OBJECT_HANDLE_PTR new_object)
+{
+	return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DestroyObject (CK_SESSION_HANDLE session,
                       CK_OBJECT_HANDLE object)
 {
@@ -1274,6 +1489,14 @@ mock_C_DestroyObject__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_DestroyObject__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                      CK_SESSION_HANDLE session,
+                                      CK_OBJECT_HANDLE object)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_GetObjectSize (CK_SESSION_HANDLE session,
                       CK_OBJECT_HANDLE object,
                       CK_ULONG_PTR size)
@@ -1313,6 +1536,17 @@ mock_C_GetObjectSize__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_GetObjectSize__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                      CK_SESSION_HANDLE session,
+                                      CK_OBJECT_HANDLE object,
+                                      CK_ULONG_PTR size)
+{
+	return_val_if_fail (size, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_GetAttributeValue (CK_SESSION_HANDLE session,
                           CK_OBJECT_HANDLE object,
                           CK_ATTRIBUTE_PTR template,
@@ -1371,6 +1605,16 @@ mock_C_GetAttributeValue__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_GetAttributeValue__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                          CK_SESSION_HANDLE session,
+                                          CK_OBJECT_HANDLE object,
+                                          CK_ATTRIBUTE_PTR template,
+                                          CK_ULONG count)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_GetAttributeValue__fail_first (CK_SESSION_HANDLE session,
                                       CK_OBJECT_HANDLE object,
                                       CK_ATTRIBUTE_PTR template,
@@ -1428,6 +1672,16 @@ mock_C_SetAttributeValue__invalid_handle (CK_SESSION_HANDLE session,
 	return CKR_SESSION_HANDLE_INVALID;
 }
 
+CK_RV
+mock_X_SetAttributeValue__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                          CK_SESSION_HANDLE session,
+                                          CK_OBJECT_HANDLE object,
+                                          CK_ATTRIBUTE_PTR template,
+                                          CK_ULONG count)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
 typedef struct _FindObjects {
 	CK_ATTRIBUTE *template;
 	CK_ULONG count;
@@ -1512,6 +1766,15 @@ mock_C_FindObjectsInit__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_FindObjectsInit__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                        CK_SESSION_HANDLE session,
+                                        CK_ATTRIBUTE_PTR template,
+                                        CK_ULONG count)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_FindObjectsInit__fails (CK_SESSION_HANDLE session,
                                CK_ATTRIBUTE_PTR template,
                                CK_ULONG count)
@@ -1563,6 +1826,18 @@ mock_C_FindObjects__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_FindObjects__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                    CK_SESSION_HANDLE session,
+                                    CK_OBJECT_HANDLE_PTR objects,
+                                    CK_ULONG max_count,
+                                    CK_ULONG_PTR count)
+{
+	return_val_if_fail (count, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_FindObjects__fails (CK_SESSION_HANDLE session,
                            CK_OBJECT_HANDLE_PTR objects,
                            CK_ULONG max_count,
@@ -1599,6 +1874,13 @@ mock_C_FindObjectsFinal__invalid_handle (CK_SESSION_HANDLE session)
 }
 
 CK_RV
+mock_X_FindObjectsFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                         CK_SESSION_HANDLE session)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_EncryptInit (CK_SESSION_HANDLE session,
                     CK_MECHANISM_PTR mechanism,
                     CK_OBJECT_HANDLE key)
@@ -1634,6 +1916,15 @@ mock_C_EncryptInit__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_EncryptInit__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                    CK_SESSION_HANDLE session,
+                                    CK_MECHANISM_PTR mechanism,
+                                    CK_OBJECT_HANDLE key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_Encrypt (CK_SESSION_HANDLE session,
                 CK_BYTE_PTR data,
                 CK_ULONG data_len,
@@ -1661,6 +1952,19 @@ mock_C_Encrypt__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_Encrypt__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                CK_SESSION_HANDLE session,
+                                CK_BYTE_PTR data,
+                                CK_ULONG data_len,
+                                CK_BYTE_PTR encrypted_data,
+                                CK_ULONG_PTR encrypted_data_len)
+{
+	return_val_if_fail (encrypted_data_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_EncryptUpdate (CK_SESSION_HANDLE session,
                       CK_BYTE_PTR part,
                       CK_ULONG part_len,
@@ -1713,6 +2017,19 @@ mock_C_EncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_EncryptUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                      CK_SESSION_HANDLE session,
+                                      CK_BYTE_PTR part,
+                                      CK_ULONG part_len,
+                                      CK_BYTE_PTR encrypted_part,
+                                      CK_ULONG_PTR encrypted_part_len)
+{
+	return_val_if_fail (encrypted_part_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_EncryptFinal (CK_SESSION_HANDLE session,
                      CK_BYTE_PTR last_encrypted_part,
                      CK_ULONG_PTR last_encrypted_part_len)
@@ -1749,6 +2066,17 @@ mock_C_EncryptFinal__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_EncryptFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                     CK_SESSION_HANDLE session,
+                                     CK_BYTE_PTR last_part,
+                                     CK_ULONG_PTR last_part_len)
+{
+	return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DecryptInit (CK_SESSION_HANDLE session,
                     CK_MECHANISM_PTR mechanism,
                     CK_OBJECT_HANDLE key)
@@ -1784,6 +2112,15 @@ mock_C_DecryptInit__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_DecryptInit__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                    CK_SESSION_HANDLE session,
+                                    CK_MECHANISM_PTR mechanism,
+                                    CK_OBJECT_HANDLE key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_Decrypt (CK_SESSION_HANDLE session,
                 CK_BYTE_PTR encrypted_data,
                 CK_ULONG encrypted_data_len,
@@ -1811,6 +2148,19 @@ mock_C_Decrypt__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_Decrypt__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                CK_SESSION_HANDLE session,
+                                CK_BYTE_PTR enc_data,
+                                CK_ULONG enc_data_len,
+                                CK_BYTE_PTR data,
+                                CK_ULONG_PTR data_len)
+{
+	return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DecryptUpdate (CK_SESSION_HANDLE session,
                       CK_BYTE_PTR encrypted_part,
                       CK_ULONG encrypted_part_len,
@@ -1863,6 +2213,19 @@ mock_C_DecryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_DecryptUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                      CK_SESSION_HANDLE session,
+                                      CK_BYTE_PTR enc_part,
+                                      CK_ULONG enc_part_len,
+                                      CK_BYTE_PTR part,
+                                      CK_ULONG_PTR part_len)
+{
+	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DecryptFinal (CK_SESSION_HANDLE session,
                      CK_BYTE_PTR last_part,
                      CK_ULONG_PTR last_part_len)
@@ -1900,6 +2263,17 @@ mock_C_DecryptFinal__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_DecryptFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                     CK_SESSION_HANDLE session,
+                                     CK_BYTE_PTR last_part,
+                                     CK_ULONG_PTR last_part_len)
+{
+	return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DigestInit (CK_SESSION_HANDLE session,
                    CK_MECHANISM_PTR mechanism)
 {
@@ -1932,6 +2306,14 @@ mock_C_DigestInit__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_DigestInit__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                   CK_SESSION_HANDLE session,
+                                   CK_MECHANISM_PTR mechanism)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_Digest (CK_SESSION_HANDLE session,
                CK_BYTE_PTR data,
                CK_ULONG data_len,
@@ -1961,6 +2343,19 @@ mock_C_Digest__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_Digest__invalid_handle (CK_X_FUNCTION_LIST *self,
+                               CK_SESSION_HANDLE session,
+                               CK_BYTE_PTR data,
+                               CK_ULONG data_len,
+                               CK_BYTE_PTR digest,
+                               CK_ULONG_PTR digest_len)
+{
+	return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DigestUpdate (CK_SESSION_HANDLE session,
                      CK_BYTE_PTR part,
                      CK_ULONG part_len)
@@ -1990,6 +2385,15 @@ mock_C_DigestUpdate__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_DigestUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                     CK_SESSION_HANDLE session,
+                                     CK_BYTE_PTR part,
+                                     CK_ULONG part_len)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DigestKey (CK_SESSION_HANDLE session,
                   CK_OBJECT_HANDLE key)
 {
@@ -2017,6 +2421,14 @@ mock_C_DigestKey__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_DigestKey__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                  CK_SESSION_HANDLE session,
+                                  CK_OBJECT_HANDLE key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DigestFinal (CK_SESSION_HANDLE session,
                     CK_BYTE_PTR digest,
                     CK_ULONG_PTR digest_len)
@@ -2068,6 +2480,17 @@ mock_C_DigestFinal__invalid_handle (CK_SESSION_HANDLE session,
 	return CKR_SESSION_HANDLE_INVALID;
 }
 
+CK_RV
+mock_X_DigestFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                    CK_SESSION_HANDLE session,
+                                    CK_BYTE_PTR digest,
+                                    CK_ULONG_PTR digest_len)
+{
+	return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
 static CK_RV
 prefix_mechanism_init (CK_SESSION_HANDLE session,
                        CK_ATTRIBUTE_TYPE method,
@@ -2156,6 +2579,15 @@ mock_C_SignInit__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_SignInit__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                 CK_SESSION_HANDLE session,
+                                 CK_MECHANISM_PTR mechanism,
+                                 CK_OBJECT_HANDLE key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_Sign (CK_SESSION_HANDLE session,
              CK_BYTE_PTR data,
              CK_ULONG data_len,
@@ -2184,6 +2616,19 @@ mock_C_Sign__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_Sign__invalid_handle (CK_X_FUNCTION_LIST *self,
+                             CK_SESSION_HANDLE session,
+                             CK_BYTE_PTR data,
+                             CK_ULONG data_len,
+                             CK_BYTE_PTR signature,
+                             CK_ULONG_PTR signature_len)
+{
+	return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_SignUpdate (CK_SESSION_HANDLE session,
                    CK_BYTE_PTR part,
                    CK_ULONG part_len)
@@ -2214,6 +2659,17 @@ mock_C_SignUpdate__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_SignUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                   CK_SESSION_HANDLE session,
+                                   CK_BYTE_PTR part,
+                                   CK_ULONG part_len)
+{
+	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_SignFinal (CK_SESSION_HANDLE session,
                   CK_BYTE_PTR signature,
                   CK_ULONG_PTR signature_len)
@@ -2270,6 +2726,17 @@ mock_C_SignFinal__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_SignFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                  CK_SESSION_HANDLE session,
+                                  CK_BYTE_PTR signature,
+                                  CK_ULONG_PTR signature_len)
+{
+	return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_SignRecoverInit (CK_SESSION_HANDLE session,
                         CK_MECHANISM_PTR mechanism,
                         CK_OBJECT_HANDLE key)
@@ -2287,6 +2754,15 @@ mock_C_SignRecoverInit__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_SignRecoverInit__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                        CK_SESSION_HANDLE session,
+                                        CK_MECHANISM_PTR mechanism,
+                                        CK_OBJECT_HANDLE key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_SignRecover (CK_SESSION_HANDLE session,
                     CK_BYTE_PTR data,
                     CK_ULONG data_len,
@@ -2345,6 +2821,19 @@ mock_C_SignRecover__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_SignRecover__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                    CK_SESSION_HANDLE session,
+                                    CK_BYTE_PTR data,
+                                    CK_ULONG data_len,
+                                    CK_BYTE_PTR signature,
+                                    CK_ULONG_PTR signature_len)
+{
+	return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_VerifyInit (CK_SESSION_HANDLE session,
                    CK_MECHANISM_PTR mechanism,
                    CK_OBJECT_HANDLE key)
@@ -2362,6 +2851,15 @@ mock_C_VerifyInit__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_VerifyInit__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                   CK_SESSION_HANDLE session,
+                                   CK_MECHANISM_PTR mechanism,
+                                   CK_OBJECT_HANDLE key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_Verify (CK_SESSION_HANDLE session,
                CK_BYTE_PTR data,
                CK_ULONG data_len,
@@ -2388,6 +2886,17 @@ mock_C_Verify__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_Verify__invalid_handle (CK_X_FUNCTION_LIST *self,
+                               CK_SESSION_HANDLE session,
+                               CK_BYTE_PTR data,
+                               CK_ULONG data_len,
+                               CK_BYTE_PTR signature,
+                               CK_ULONG signature_len)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_VerifyUpdate (CK_SESSION_HANDLE session,
                      CK_BYTE_PTR part,
                      CK_ULONG part_len)
@@ -2416,6 +2925,15 @@ mock_C_VerifyUpdate__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_VerifyUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                     CK_SESSION_HANDLE session,
+                                     CK_BYTE_PTR part,
+                                     CK_ULONG part_len)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_VerifyFinal (CK_SESSION_HANDLE session,
                     CK_BYTE_PTR signature,
                     CK_ULONG signature_len)
@@ -2463,6 +2981,15 @@ mock_C_VerifyFinal__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_VerifyFinal__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                    CK_SESSION_HANDLE session,
+                                    CK_BYTE_PTR signature,
+                                    CK_ULONG signature_len)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_VerifyRecoverInit (CK_SESSION_HANDLE session,
                           CK_MECHANISM_PTR mechanism,
                           CK_OBJECT_HANDLE key)
@@ -2480,6 +3007,15 @@ mock_C_VerifyRecoverInit__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_VerifyRecoverInit__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                          CK_SESSION_HANDLE session,
+                                          CK_MECHANISM_PTR mechanism,
+                                          CK_OBJECT_HANDLE key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_VerifyRecover (CK_SESSION_HANDLE session,
                       CK_BYTE_PTR signature,
                       CK_ULONG signature_len,
@@ -2534,6 +3070,19 @@ mock_C_VerifyRecover__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_VerifyRecover__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                      CK_SESSION_HANDLE session,
+                                      CK_BYTE_PTR signature,
+                                      CK_ULONG signature_len,
+                                      CK_BYTE_PTR data,
+                                      CK_ULONG_PTR data_len)
+{
+	return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DigestEncryptUpdate (CK_SESSION_HANDLE session,
                             CK_BYTE_PTR part,
                             CK_ULONG part_len,
@@ -2562,6 +3111,19 @@ mock_C_DigestEncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_DigestEncryptUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                            CK_SESSION_HANDLE session,
+                                            CK_BYTE_PTR part,
+                                            CK_ULONG part_len,
+                                            CK_BYTE_PTR enc_part,
+                                            CK_ULONG_PTR enc_part_len)
+{
+	return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DecryptDigestUpdate (CK_SESSION_HANDLE session,
                             CK_BYTE_PTR encrypted_part,
                             CK_ULONG encrypted_part_len,
@@ -2590,6 +3152,19 @@ mock_C_DecryptDigestUpdate__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_DecryptDigestUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                            CK_SESSION_HANDLE session,
+                                            CK_BYTE_PTR enc_part,
+                                            CK_ULONG enc_part_len,
+                                            CK_BYTE_PTR part,
+                                            CK_ULONG_PTR part_len)
+{
+	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_SignEncryptUpdate (CK_SESSION_HANDLE session,
                           CK_BYTE_PTR part,
                           CK_ULONG part_len,
@@ -2618,6 +3193,19 @@ mock_C_SignEncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_SignEncryptUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                          CK_SESSION_HANDLE session,
+                                          CK_BYTE_PTR part,
+                                          CK_ULONG part_len,
+                                          CK_BYTE_PTR enc_part,
+                                          CK_ULONG_PTR enc_part_len)
+{
+	return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DecryptVerifyUpdate (CK_SESSION_HANDLE session,
                             CK_BYTE_PTR encrypted_part,
                             CK_ULONG encrypted_part_len,
@@ -2646,6 +3234,19 @@ mock_C_DecryptVerifyUpdate__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_DecryptVerifyUpdate__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                            CK_SESSION_HANDLE session,
+                                            CK_BYTE_PTR enc_part,
+                                            CK_ULONG enc_part_len,
+                                            CK_BYTE_PTR part,
+                                            CK_ULONG_PTR part_len)
+{
+	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_GenerateKey (CK_SESSION_HANDLE session,
                     CK_MECHANISM_PTR mechanism,
                     CK_ATTRIBUTE_PTR template,
@@ -2700,6 +3301,17 @@ mock_C_GenerateKey__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_GenerateKey__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                    CK_SESSION_HANDLE session,
+                                    CK_MECHANISM_PTR mechanism,
+                                    CK_ATTRIBUTE_PTR template,
+                                    CK_ULONG count,
+                                    CK_OBJECT_HANDLE_PTR key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_GenerateKeyPair (CK_SESSION_HANDLE session,
                         CK_MECHANISM_PTR mechanism,
                         CK_ATTRIBUTE_PTR public_key_template,
@@ -2772,6 +3384,20 @@ mock_C_GenerateKeyPair__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_GenerateKeyPair__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                        CK_SESSION_HANDLE session,
+                                        CK_MECHANISM_PTR mechanism,
+                                        CK_ATTRIBUTE_PTR pub_template,
+                                        CK_ULONG pub_count,
+                                        CK_ATTRIBUTE_PTR priv_template,
+                                        CK_ULONG priv_count,
+                                        CK_OBJECT_HANDLE_PTR pub_key,
+                                        CK_OBJECT_HANDLE_PTR priv_key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_WrapKey (CK_SESSION_HANDLE session,
                 CK_MECHANISM_PTR mechanism,
                 CK_OBJECT_HANDLE wrapping_key,
@@ -2848,6 +3474,20 @@ mock_C_WrapKey__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_WrapKey__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                CK_SESSION_HANDLE session,
+                                CK_MECHANISM_PTR mechanism,
+                                CK_OBJECT_HANDLE wrapping_key,
+                                CK_OBJECT_HANDLE key,
+                                CK_BYTE_PTR wrapped_key,
+                                CK_ULONG_PTR wrapped_key_len)
+{
+	return_val_if_fail (wrapped_key_len, CKR_ARGUMENTS_BAD);
+
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_UnwrapKey (CK_SESSION_HANDLE session,
                   CK_MECHANISM_PTR mechanism,
                   CK_OBJECT_HANDLE unwrapping_key,
@@ -2920,6 +3560,20 @@ mock_C_UnwrapKey__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_UnwrapKey__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                  CK_SESSION_HANDLE session,
+                                  CK_MECHANISM_PTR mechanism,
+                                  CK_OBJECT_HANDLE unwrapping_key,
+                                  CK_BYTE_PTR wrapped_key,
+                                  CK_ULONG wrapped_key_len,
+                                  CK_ATTRIBUTE_PTR template,
+                                  CK_ULONG count,
+                                  CK_OBJECT_HANDLE_PTR key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_DeriveKey (CK_SESSION_HANDLE session,
                   CK_MECHANISM_PTR mechanism,
                   CK_OBJECT_HANDLE base_key,
@@ -2985,6 +3639,18 @@ mock_C_DeriveKey__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_DeriveKey__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                  CK_SESSION_HANDLE session,
+                                  CK_MECHANISM_PTR mechanism,
+                                  CK_OBJECT_HANDLE base_key,
+                                  CK_ATTRIBUTE_PTR template,
+                                  CK_ULONG count,
+                                  CK_OBJECT_HANDLE_PTR key)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_SeedRandom (CK_SESSION_HANDLE session,
                    CK_BYTE_PTR seed,
                    CK_ULONG seed_len)
@@ -3012,6 +3678,15 @@ mock_C_SeedRandom__invalid_handle (CK_SESSION_HANDLE session,
 }
 
 CK_RV
+mock_X_SeedRandom__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                   CK_SESSION_HANDLE session,
+                                   CK_BYTE_PTR seed,
+                                   CK_ULONG seed_len)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
+CK_RV
 mock_C_GenerateRandom (CK_SESSION_HANDLE session,
                        CK_BYTE_PTR random_data,
                        CK_ULONG random_len)
@@ -3043,6 +3718,15 @@ mock_C_GenerateRandom__invalid_handle (CK_SESSION_HANDLE session,
 	return CKR_SESSION_HANDLE_INVALID;
 }
 
+CK_RV
+mock_X_GenerateRandom__invalid_handle (CK_X_FUNCTION_LIST *self,
+                                       CK_SESSION_HANDLE session,
+                                       CK_BYTE_PTR random_data,
+                                       CK_ULONG random_len)
+{
+	return CKR_SESSION_HANDLE_INVALID;
+}
+
 CK_FUNCTION_LIST mock_module_no_slots = {
 	{ CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },  /* version */
 	mock_C_Initialize,
@@ -3115,6 +3799,75 @@ CK_FUNCTION_LIST mock_module_no_slots = {
 	mock_C_WaitForSlotEvent__no_event,
 };
 
+CK_X_FUNCTION_LIST mock_x_module_no_slots = {
+	{ CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },  /* version */
+	mock_X_Initialize,
+	mock_X_Finalize,
+	mock_X_GetInfo,
+	mock_X_GetSlotList__no_tokens,
+	mock_X_GetSlotInfo__invalid_slotid,
+	mock_X_GetTokenInfo__invalid_slotid,
+	mock_X_GetMechanismList__invalid_slotid,
+	mock_X_GetMechanismInfo__invalid_slotid,
+	mock_X_InitToken__invalid_slotid,
+	mock_X_InitPIN__invalid_handle,
+	mock_X_SetPIN__invalid_handle,
+	mock_X_OpenSession__invalid_slotid,
+	mock_X_CloseSession__invalid_handle,
+	mock_X_CloseAllSessions__invalid_slotid,
+	mock_X_GetSessionInfo__invalid_handle,
+	mock_X_GetOperationState__invalid_handle,
+	mock_X_SetOperationState__invalid_handle,
+	mock_X_Login__invalid_handle,
+	mock_X_Logout__invalid_handle,
+	mock_X_CreateObject__invalid_handle,
+	mock_X_CopyObject__invalid_handle,
+	mock_X_DestroyObject__invalid_handle,
+	mock_X_GetObjectSize__invalid_handle,
+	mock_X_GetAttributeValue__invalid_handle,
+	mock_X_SetAttributeValue__invalid_handle,
+	mock_X_FindObjectsInit__invalid_handle,
+	mock_X_FindObjects__invalid_handle,
+	mock_X_FindObjectsFinal__invalid_handle,
+	mock_X_EncryptInit__invalid_handle,
+	mock_X_Encrypt__invalid_handle,
+	mock_X_EncryptUpdate__invalid_handle,
+	mock_X_EncryptFinal__invalid_handle,
+	mock_X_DecryptInit__invalid_handle,
+	mock_X_Decrypt__invalid_handle,
+	mock_X_DecryptUpdate__invalid_handle,
+	mock_X_DecryptFinal__invalid_handle,
+	mock_X_DigestInit__invalid_handle,
+	mock_X_Digest__invalid_handle,
+	mock_X_DigestUpdate__invalid_handle,
+	mock_X_DigestKey__invalid_handle,
+	mock_X_DigestFinal__invalid_handle,
+	mock_X_SignInit__invalid_handle,
+	mock_X_Sign__invalid_handle,
+	mock_X_SignUpdate__invalid_handle,
+	mock_X_SignFinal__invalid_handle,
+	mock_X_SignRecoverInit__invalid_handle,
+	mock_X_SignRecover__invalid_handle,
+	mock_X_VerifyInit__invalid_handle,
+	mock_X_Verify__invalid_handle,
+	mock_X_VerifyUpdate__invalid_handle,
+	mock_X_VerifyFinal__invalid_handle,
+	mock_X_VerifyRecoverInit__invalid_handle,
+	mock_X_VerifyRecover__invalid_handle,
+	mock_X_DigestEncryptUpdate__invalid_handle,
+	mock_X_DecryptDigestUpdate__invalid_handle,
+	mock_X_SignEncryptUpdate__invalid_handle,
+	mock_X_DecryptVerifyUpdate__invalid_handle,
+	mock_X_GenerateKey__invalid_handle,
+	mock_X_GenerateKeyPair__invalid_handle,
+	mock_X_WrapKey__invalid_handle,
+	mock_X_UnwrapKey__invalid_handle,
+	mock_X_DeriveKey__invalid_handle,
+	mock_X_SeedRandom__invalid_handle,
+	mock_X_GenerateRandom__invalid_handle,
+	mock_X_WaitForSlotEvent__no_event,
+};
+
 CK_FUNCTION_LIST mock_module = {
 	{ CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },  /* version */
 	mock_C_Initialize,