We had this problem here, and solved making little changes in the
attached files. You can just replace your by these and recompile the module
RABLAT Guillaume wrote:
Hello,
I'm using muscleframework-1.1.5 and tried to install libmusclepkcs11 on
Firefox on Linux (Mandriva2006), but it says "Unable to add module". The
same happens with Mozilla 1.7.5.
ldconfig seems to have load libmusclepkcs11 correctly:
# ldconfig -p|grep pkcs
libmusclepkcs11.so.0 (libc6) => /usr/local/lib/libmusclepkcs11.so.0
libmusclepkcs11.so (libc6) => /usr/local/lib/libmusclepkcs11.so
Even with a $HOME/.pkcs11rc file, no log appears in /tmp/PKCS11.log
I have done a strace on firefox-bin process, but I cannot see any clues.
Anyone have any suggestions how can I debug this ?
_______________________________________________
Muscle mailing list
[email protected]
http://lists.drizzle.com/mailman/listinfo/muscle
/******************************************************************************
**
** $Id: p11_crypt.c,v 1.10 2003/10/04 08:30:18 rousseau Exp $
**
** Package: PKCS-11
** Author : Chris Osgood <[EMAIL PROTECTED]>
** License: Copyright (C) 2002 Schlumberger Network Solutions
** <http://www.slb.com/sns>
** Purpose: Encryption and decryption
**
******************************************************************************/
#include <assert.h>
#include "cryptoki.h"
/* Removed by Netscape
#include <openssl/rsa.h>
*/
/**
* Padding algorithm defined in RSA's PKCS #1.
* to: pre-allocated buffer to receive the padded data
* toLen: the length of the buffer. This should be the same as the size
* of the RSA modulus. (toLen - 3) > fromLen.
* from: data to be padded.
* fromLen: size of data to be padded. fromLen < (toLen-3).
* Returns: nonzero for success, zero for failure.
*/
int
padRSAType1(CK_BYTE* to, CK_ULONG toLen, CK_BYTE*from, CK_ULONG fromLen)
{
int i = 0;
int padLen = toLen - 3 - fromLen;
assert( toLen > fromLen );
assert( padLen >= 0 );
if( toLen < fromLen || padLen < 0 ) {
return 0;
}
/* First byte: 00 */
to[i++] = 0x00;
/* Second Byte: Block Type == 01 */
to[i++] = 0x01;
/* Padding String, each byte is 0xFF for block type 01 */
memset(to+i, 0xFF, padLen);
i += padLen;
/* Separator byte: 00 */
to[i++] = 0x00;
/* Finally, the data */
memcpy(to+i, from, fromLen);
i += fromLen;
assert( (CK_ULONG) i == toLen );
return 1;
}
/* C_EncryptInit initializes an encryption operation. */
CK_DEFINE_FUNCTION(CK_RV, C_EncryptInit)
(
CK_SESSION_HANDLE hSession, /* the session's handle */
CK_MECHANISM_PTR pMechanism, /* the encryption mechanism */
CK_OBJECT_HANDLE hKey /* handle of encryption key */
)
{
CK_RV rv = CKR_OK;
P11_Session *session; /* = (P11_Session *)hSession; */
P11_LOG_START("C_EncryptInit");
thread_MutexLock(st.async_lock);
/* Added by Netscape */
session = session_LookupSession(hSession);
if( session == NULL ) {
rv = CKR_SESSION_HANDLE_INVALID;
goto finish;
}
/* end */
log_Log(LOG_LOW, "Encrypt mech: %X", *pMechanism);
log_Log(LOG_LOW, "Encrypt key: %lX", hKey);
if (CKR_ERROR(rv = slot_TokenChanged()))
rv = CKR_SESSION_HANDLE_INVALID;
else if (!pMechanism || !hKey)
rv = CKR_ARGUMENTS_BAD;
/* removed by Netscape
else if (INVALID_SESSION)
rv = CKR_SESSION_HANDLE_INVALID;
*/
else if (!USER_MODE)
rv = CKR_USER_NOT_LOGGED_IN;
else if (pMechanism->mechanism != CKM_RSA_PKCS)
rv = CKR_MECHANISM_INVALID;
else
{
/* Fixme: need to verify that the card supports the mechanism and its parameters */
/* Fixme: should probably add session.encrypt_mech and session.encrypt_key */
session->sign_mech = *pMechanism;
session->sign_key = hKey;
}
finish:
thread_MutexUnlock(st.async_lock);
P11_LOG_END("C_EncryptInit");
return rv;
}
/* C_Encrypt encrypts single-part data. */
CK_DEFINE_FUNCTION(CK_RV, C_Encrypt)
(
CK_SESSION_HANDLE hSession, /* session's handle */
CK_BYTE_PTR pData, /* the plaintext data */
CK_ULONG ulDataLen, /* bytes of plaintext */
CK_BYTE_PTR pEncryptedData, /* gets ciphertext */
CK_ULONG_PTR pulEncryptedDataLen /* gets c-text size */
)
{
CK_RV rv = CKR_OK;
P11_Session *session; // = (P11_Session *)hSession;
P11_Object *key; // = (P11_Object *)session->sign_key;
MSCCryptInit cryptInit;
CK_BYTE *t_data1 = 0;
CK_ULONG t_data1_len;
P11_Slot *slot;
CK_ULONG slotID;
P11_LOG_START("C_Encrypt");
thread_MutexLock(st.async_lock);
session = session_LookupSession(hSession);
if( session == NULL ) {
rv = CKR_SESSION_HANDLE_INVALID;
goto finish;
}
slotID = session->session.slotID;
slot = &st.slots[slotID-1];
key = (P11_Object *)session->sign_key;
if (CKR_ERROR(rv = slot_TokenChanged()))
rv = CKR_SESSION_HANDLE_INVALID;
else if (!pEncryptedData || !pData)
rv = CKR_ARGUMENTS_BAD;
/* else if (INVALID_SESSION)
rv = CKR_SESSION_HANDLE_INVALID;
*/
else if (!key)
rv = CKR_OPERATION_NOT_INITIALIZED;
else if (!USER_MODE)
rv = CKR_USER_NOT_LOGGED_IN;
else if ((CK_ULONG)(key->msc_key->keySize / 8) > ulDataLen)
rv = CKR_ENCRYPTED_DATA_LEN_RANGE;
else if (CKR_ERROR(rv = slot_BeginTransaction(session->session.slotID)))
/* Intentionally blank */;
else if (session->sign_mech.mechanism == CKM_RSA_PKCS)
{
/* Fixme: this is not fully implemented since it doesn't look at the mechanism parameter */
cryptInit.keyNum = key->msc_key->keyNum;
cryptInit.cipherMode = MSC_MODE_RSA_NOPAD;
cryptInit.cipherDirection = MSC_DIR_SIGN;
cryptInit.optParams = 0;
cryptInit.optParamsSize = 0;
log_Log(LOG_LOW, "Using key number: %d", cryptInit.keyNum);
t_data1_len = key->msc_key->keySize / 8;
t_data1 = (CK_BYTE *)malloc(t_data1_len);
if (!t_data1)
rv = CKR_HOST_MEMORY;
else if (t_data1_len > *pulEncryptedDataLen)
rv = CKR_BUFFER_TOO_SMALL;
/*
else if (!RSA_padding_add_PKCS1_type_1(t_data1, t_data1_len, pData, ulDataLen))
*/
else if (!padRSAType1(t_data1, t_data1_len, pData, ulDataLen))
rv = CKR_FUNCTION_FAILED;
/*
else if (MSC_ERROR(msc_ComputeCrypt(&st.slots[session->session.slotID - 1].conn,
&cryptInit,
t_data1,
t_data1_len,
pEncryptedData,
pulEncryptedDataLen)))
*/
else if (MSC_ERROR(msc_ComputeCrypt(slot, slotID, &slot->conn,
&cryptInit,
t_data1,
t_data1_len,
pEncryptedData,
pulEncryptedDataLen)))
{
P11_ERR("MSCComputeCrypt failed");
rv = CKR_FUNCTION_FAILED;
}
if (t_data1)
free(t_data1);
(void)CKR_ERROR(slot_EndTransaction(session->session.slotID, MSC_LEAVE_TOKEN));
}
else
{
(void)CKR_ERROR(slot_EndTransaction(session->session.slotID, MSC_LEAVE_TOKEN));
rv = CKR_MECHANISM_INVALID;
}
session->sign_key = 0;
finish:
thread_MutexUnlock(st.async_lock);
P11_LOG_END("C_Encrypt");
return rv;
}
/* C_EncryptUpdate continues a multiple-part encryption
* operation. */
CK_DEFINE_FUNCTION(CK_RV, C_EncryptUpdate)
(
CK_SESSION_HANDLE hSession, /* session's handle */
CK_BYTE_PTR pPart, /* the plaintext data */
CK_ULONG ulPartLen, /* plaintext data len */
CK_BYTE_PTR pEncryptedPart, /* gets ciphertext */
CK_ULONG_PTR pulEncryptedPartLen /* gets c-text size */
)
{
CK_RV rv = CKR_OK;
P11_LOG_START("C_EncryptUpdate");
thread_MutexLock(st.async_lock);
rv = CKR_FUNCTION_NOT_SUPPORTED;
log_Log(LOG_MED, "Function not supported");
thread_MutexUnlock(st.async_lock);
P11_LOG_END("C_EncryptUpdate");
return rv;
}
/* C_EncryptFinal finishes a multiple-part encryption
* operation. */
CK_DEFINE_FUNCTION(CK_RV, C_EncryptFinal)
(
CK_SESSION_HANDLE hSession, /* session handle */
CK_BYTE_PTR pLastEncryptedPart, /* last c-text */
CK_ULONG_PTR pulLastEncryptedPartLen /* gets last size */
)
{
CK_RV rv = CKR_OK;
P11_LOG_START("C_EncryptFinal");
thread_MutexLock(st.async_lock);
rv = CKR_FUNCTION_NOT_SUPPORTED;
log_Log(LOG_MED, "Function not supported");
thread_MutexUnlock(st.async_lock);
P11_LOG_END("C_EncryptFinal");
return rv;
}
/* C_DecryptInit initializes a decryption operation. */
CK_DEFINE_FUNCTION(CK_RV, C_DecryptInit)
(
CK_SESSION_HANDLE hSession, /* the session's handle */
CK_MECHANISM_PTR pMechanism, /* the decryption mechanism */
CK_OBJECT_HANDLE hKey /* handle of decryption key */
)
{
CK_RV rv = CKR_OK;
P11_Session *session; // = (P11_Session *)hSession;
P11_LOG_START("C_DecryptInit");
thread_MutexLock(st.async_lock);
session = session_LookupSession(hSession);
if( session == NULL ) {
rv = CKR_SESSION_HANDLE_INVALID;
goto finish;
}
log_Log(LOG_LOW, "Decrypt mech: %X", *pMechanism);
log_Log(LOG_LOW, "Decrypt key: %lX", hKey);
if (CKR_ERROR(rv = slot_TokenChanged()))
rv = CKR_SESSION_HANDLE_INVALID;
else if (!pMechanism || !hKey)
rv = CKR_ARGUMENTS_BAD;
/*
else if (INVALID_SESSION)
rv = CKR_SESSION_HANDLE_INVALID;
*/
else if (!USER_MODE)
rv = CKR_USER_NOT_LOGGED_IN;
else if (pMechanism->mechanism != CKM_RSA_PKCS)
rv = CKR_MECHANISM_INVALID;
else
{
/* Fixme: need to verify that the card supports the mechanism and its parameters */
/* Fixme: should probably add session.decrypt_mech and session.decrypt_key */
session->sign_mech = *pMechanism;
session->sign_key = hKey;
}
finish:
thread_MutexUnlock(st.async_lock);
P11_LOG_END("C_DecryptInit");
return rv;
}
/* C_Decrypt decrypts encrypted data in a single part. */
CK_DEFINE_FUNCTION(CK_RV, C_Decrypt)
(
CK_SESSION_HANDLE hSession, /* session's handle */
CK_BYTE_PTR pEncryptedData, /* ciphertext */
CK_ULONG ulEncryptedDataLen, /* ciphertext length */
CK_BYTE_PTR pData, /* gets plaintext */
CK_ULONG_PTR pulDataLen /* gets p-text size */
)
{
CK_RV rv = CKR_OK;
P11_Session *session; /* = (P11_Session *)hSession; */
P11_Object *key; /* = (P11_Object *)session->sign_key; */
MSCCryptInit cryptInit;
CK_BYTE *t_data1 = 0, *t_data2 = 0;
CK_ULONG t_data1_len, t_data2_len;
P11_Slot *slot;
CK_ULONG slotID;
P11_LOG_START("C_Decrypt");
thread_MutexLock(st.async_lock);
session = session_LookupSession(hSession);
if( session == NULL ) {
rv = CKR_SESSION_HANDLE_INVALID;
goto finish;
}
slotID = session->session.slotID;
slot = &st.slots[slotID-1];
key = (P11_Object *)session->sign_key;
if (CKR_ERROR(rv = slot_TokenChanged()))
rv = CKR_SESSION_HANDLE_INVALID;
else if (!pEncryptedData || !pData)
rv = CKR_ARGUMENTS_BAD;
/*
else if (INVALID_SESSION)
rv = CKR_SESSION_HANDLE_INVALID;
*/
else if (!key)
rv = CKR_OPERATION_NOT_INITIALIZED;
else if (!USER_MODE)
rv = CKR_USER_NOT_LOGGED_IN;
else if ((CK_ULONG)(key->msc_key->keySize / 8) > ulEncryptedDataLen)
rv = CKR_ENCRYPTED_DATA_LEN_RANGE;
else if (CKR_ERROR(rv = slot_BeginTransaction(session->session.slotID)))
/* Intentionally blank */;
else if (session->sign_mech.mechanism == CKM_RSA_PKCS)
{
CK_ULONG ulValue, lenValue;
/* Fixme: this is not fully implemented since it doesn't look at the mechanism parameter */
/*
if (MSC_ERROR(msc_GetCapabilities(&st.slots[session->session.slotID - 1].conn,
MSC_TAG_CAPABLE_RSA,
(CK_BYTE_PTR) &ulValue,
&lenValue)))
*/
if (MSC_ERROR(msc_GetCapabilities(&slot->conn,
MSC_TAG_CAPABLE_RSA,
(CK_BYTE_PTR) &ulValue,
&lenValue)))
rv = CKR_FUNCTION_FAILED;
else if (ulValue & MSC_CAPABLE_RSA_NOPAD) {
log_Log(LOG_LOW, "Decrypt: RSA NOPAD; key %i; keysize %i",
key->msc_key->keyNum, key->msc_key->keySize);
cryptInit.keyNum = key->msc_key->keyNum;
cryptInit.cipherMode = MSC_MODE_RSA_NOPAD;
cryptInit.cipherDirection = MSC_DIR_DECRYPT;
cryptInit.optParams = 0;
cryptInit.optParamsSize = 0;
t_data1 = (CK_BYTE *)malloc(key->msc_key->keySize / 8);
t_data2 = (CK_BYTE *)malloc(key->msc_key->keySize / 8);
t_data2_len = key->msc_key->keySize / 8; // PATCH
if (!t_data1 || !t_data2)
rv = CKR_HOST_MEMORY;
else if (MSC_ERROR(msc_ComputeCrypt(
/* &st.slots[session->session.slotID - 1].conn, */
slot,
slotID,
&slot->conn,
&cryptInit,
pEncryptedData,
ulEncryptedDataLen,
t_data1,
&t_data1_len)))
{
P11_ERR("MSCComputeCrypt failed");
rv = CKR_FUNCTION_FAILED;
}
else if (CKR_ERROR(rv = util_StripPKCS1(t_data1, t_data1_len,
t_data2, &t_data2_len)))
/* Intentionally blank */;
else if (t_data2_len > *pulDataLen)
rv = CKR_BUFFER_TOO_SMALL;
else
{
memcpy(pData, t_data2, t_data2_len);
*pulDataLen = t_data2_len;
}
}
else if (ulValue & MSC_CAPABLE_RSA_PKCS1)
{
log_Log(LOG_LOW, "Decrypt: RSA PKCS1; key %i; keysize %i",
key->msc_key->keyNum, key->msc_key->keySize);
cryptInit.keyNum = key->msc_key->keyNum;
cryptInit.cipherDirection = MSC_DIR_DECRYPT;
cryptInit.cipherMode = MSC_MODE_RSA_PAD_PKCS1;
cryptInit.optParams = 0;
cryptInit.optParamsSize = 0;
t_data1 = (CK_BYTE *)malloc(key->msc_key->keySize / 8);
if (!t_data1)
rv = CKR_HOST_MEMORY;
else if (MSC_ERROR(msc_ComputeCrypt(
/* &st.slots[session->session.slotID - 1].conn, */
slot,
slotID,
&slot->conn,
&cryptInit,
pEncryptedData,
ulEncryptedDataLen,
t_data1,
&t_data1_len)))
{
P11_ERR("MSCComputeCrypt failed");
rv = CKR_FUNCTION_FAILED;
}
if (t_data1_len > *pulDataLen)
rv = CKR_BUFFER_TOO_SMALL;
else {
memcpy(pData, t_data1, t_data1_len);
*pulDataLen = t_data1_len;
}
} else
rv = CKR_MECHANISM_PARAM_INVALID;
if (t_data1)
free(t_data1);
if (t_data2)
free(t_data2);
(void)CKR_ERROR(slot_EndTransaction(session->session.slotID, MSC_LEAVE_TOKEN));
} else {
(void)CKR_ERROR(slot_EndTransaction(session->session.slotID, MSC_LEAVE_TOKEN));
rv = CKR_MECHANISM_INVALID;
}
session->sign_key = 0;
finish:
thread_MutexUnlock(st.async_lock);
P11_LOG_END("C_Decrypt");
return rv;
}
/* C_DecryptUpdate continues a multiple-part decryption
* operation. */
CK_DEFINE_FUNCTION(CK_RV, C_DecryptUpdate)
(
CK_SESSION_HANDLE hSession, /* session's handle */
CK_BYTE_PTR pEncryptedPart, /* encrypted data */
CK_ULONG ulEncryptedPartLen, /* input length */
CK_BYTE_PTR pPart, /* gets plaintext */
CK_ULONG_PTR pulPartLen /* p-text size */
)
{
CK_RV rv = CKR_OK;
P11_LOG_START("C_DecryptUpdate");
thread_MutexLock(st.async_lock);
rv = CKR_FUNCTION_NOT_SUPPORTED;
log_Log(LOG_MED, "Function not supported");
thread_MutexUnlock(st.async_lock);
P11_LOG_END("C_DecryptUpdate");
return rv;
}
/* C_DecryptFinal finishes a multiple-part decryption
* operation. */
CK_DEFINE_FUNCTION(CK_RV, C_DecryptFinal)
(
CK_SESSION_HANDLE hSession, /* the session's handle */
CK_BYTE_PTR pLastPart, /* gets plaintext */
CK_ULONG_PTR pulLastPartLen /* p-text size */
)
{
CK_RV rv = CKR_OK;
P11_LOG_START("C_DecryptFinal");
thread_MutexLock(st.async_lock);
rv = CKR_FUNCTION_NOT_SUPPORTED;
log_Log(LOG_MED, "Function not supported");
thread_MutexUnlock(st.async_lock);
P11_LOG_END("C_DecryptFinal");
return rv;
}
/******************************************************************************
**
** $Id: p11x_thread.c,v 1.8 2003/11/26 20:22:38 rousseau Exp $
**
** Package: PKCS-11
** Author : Chris Osgood
** License: Copyright (C) 2002 Schlumberger Network Solutions
** <http://www.slb.com/sns>
** Purpose: Thread functions. This should probably just use the Musclecard
** framework functions instead (if in native mode).
**
******************************************************************************/
#include "cryptoki.h"
#include "thread_generic.h"
static int (*p11_pthread_mutex_init)(PCSCLITE_MUTEX_T mMutex) = 0;
static int (*p11_pthread_mutex_destroy)(PCSCLITE_MUTEX_T mMutex) = 0;
static int (*p11_pthread_mutex_lock)(PCSCLITE_MUTEX_T mMutex) = 0;
static int (*p11_pthread_mutex_unlock)(PCSCLITE_MUTEX_T mMutex) = 0;
static CK_CREATEMUTEX p11_createmutex = 0;
static CK_DESTROYMUTEX p11_destroymutex = 0;
static CK_LOCKMUTEX p11_lockmutex = 0;
static CK_UNLOCKMUTEX p11_unlockmutex = 0;
int SYS_MutexInit(PCSCLITE_MUTEX_T mMutex)
{
return pthread_mutex_init(mMutex, NULL);
}
int SYS_MutexDestroy(PCSCLITE_MUTEX_T mMutex)
{
return pthread_mutex_destroy(mMutex);
}
int SYS_MutexLock(PCSCLITE_MUTEX_T mMutex)
{
return pthread_mutex_lock(mMutex);
}
int SYS_MutexUnLock(PCSCLITE_MUTEX_T mMutex)
{
return pthread_mutex_unlock(mMutex);
}
/******************************************************************************
** Function: thread_Initialize
**
** Initializes the thread subsystem
**
** Parameters:
** none
**
** Returns:
** CKR_FUNCTION_FAILED on error
** CKR_OK
*******************************************************************************/
CK_RV thread_Initialize()
{
CK_RV rv = CKR_OK;
if (st.prefs.threaded && st.native_locks)
{
p11_pthread_mutex_init = SYS_MutexInit;
p11_pthread_mutex_destroy = SYS_MutexDestroy;
p11_pthread_mutex_lock = SYS_MutexLock;
p11_pthread_mutex_unlock = SYS_MutexUnLock;
}
return rv;
}
/******************************************************************************
** Function: thread_InitFunctions
**
** Initializes the thread subsystem to use external locking mechanisms
**
** Parameters:
** none
**
** Returns:
** CKR_ARGUMENTS_BAD if any function is null
** CKR_FUNCTION_FAILED on error
** CKR_OK
*******************************************************************************/
CK_RV thread_InitFunctions(CK_CREATEMUTEX fn_createmutex,
CK_DESTROYMUTEX fn_destroymutex,
CK_LOCKMUTEX fn_lockmutex,
CK_UNLOCKMUTEX fn_unlockmutex)
{
CK_RV rv = CKR_OK;
if (!st.prefs.threaded)
rv = CKR_FUNCTION_FAILED;
else
{
if (!fn_createmutex || !fn_destroymutex || !fn_lockmutex || !fn_unlockmutex)
rv = CKR_ARGUMENTS_BAD;
else
{
log_Log(LOG_LOW, "Using application supplied locking functions");
p11_createmutex = fn_createmutex;
p11_destroymutex = fn_destroymutex;
p11_lockmutex = fn_lockmutex;
p11_unlockmutex = fn_unlockmutex;
}
}
return rv;
}
/******************************************************************************
** Function: thread_Finalize
**
** Unloads the Pthread library
**
** Parameters:
** none
**
** Returns:
** CKR_FUNCTION_FAILED on general error
** CKR_OK
*******************************************************************************/
CK_RV thread_Finalize()
{
CK_RV rv = CKR_OK;
if (st.prefs.threaded)
{
p11_pthread_mutex_init = 0;
p11_pthread_mutex_destroy = 0;
p11_pthread_mutex_lock = 0;
p11_pthread_mutex_unlock = 0;
p11_createmutex = 0;
p11_destroymutex = 0;
p11_lockmutex = 0;
p11_unlockmutex = 0;
}
return rv;
}
/******************************************************************************
** Function: thread_MutexInit
**
** Initializes a mutex
**
** Parameters:
** mutex - Pointer to mutex memory
**
** Returns:
** CKR_HOST_MEMORY on memory alloc error
** CKR_FUNCTION_FAILED on general error
** CKR_OK
*******************************************************************************/
CK_RV thread_MutexInit(P11_Mutex *mutex)
{
CK_RV rv = CKR_OK;
if (st.prefs.threaded)
{
if (st.native_locks && mutex && p11_pthread_mutex_init)
{
*mutex = (P11_Mutex *)malloc(sizeof(PCSCLITE_MUTEX));
if (!*mutex)
rv = CKR_HOST_MEMORY;
else
p11_pthread_mutex_init((PCSCLITE_MUTEX_T)*mutex);
}
else if (!st.native_locks && mutex && p11_createmutex)
p11_createmutex(mutex);
else
rv = CKR_FUNCTION_FAILED;
}
return rv;
}
/******************************************************************************
** Function: thread_MutexDestroy
**
** Destroys a mutex
**
** Parameters:
** mutex - Pointer to mutex memory
**
** Returns:
** CKR_FUNCTION_FAILED on general error
** CKR_OK
*******************************************************************************/
CK_RV thread_MutexDestroy(P11_Mutex mutex)
{
CK_RV rv = CKR_OK;
if (st.prefs.threaded)
{
if (st.native_locks && mutex && p11_pthread_mutex_destroy)
{
p11_pthread_mutex_destroy((PCSCLITE_MUTEX_T)mutex);
free(mutex);
}
else if (!st.native_locks && mutex && p11_destroymutex)
p11_destroymutex(mutex);
else
rv = CKR_FUNCTION_FAILED;
}
return rv;
}
/******************************************************************************
** Function: thread_MutexLock
**
** Locks a mutex
**
** Parameters:
** mutex - Pointer to mutex memory
**
** Returns:
** CKR_FUNCTION_FAILED on general error
** CKR_OK
*******************************************************************************/
CK_RV thread_MutexLock(P11_Mutex mutex)
{
CK_RV rv = CKR_OK;
if (st.prefs.threaded)
{
if (st.native_locks && mutex && p11_pthread_mutex_lock)
p11_pthread_mutex_lock((PCSCLITE_MUTEX_T)mutex);
else if (!st.native_locks && mutex && p11_lockmutex)
p11_lockmutex(mutex);
else
rv = CKR_FUNCTION_FAILED;
}
return rv;
}
/******************************************************************************
** Function: thread_MutexUnlock
**
** Unlocks a mutex
**
** Parameters:
** mutex - Pointer to mutex memory
**
** Returns:
** CKR_FUNCTION_FAILED on general error
** CKR_OK
*******************************************************************************/
CK_RV thread_MutexUnlock(P11_Mutex mutex)
{
CK_RV rv = CKR_OK;
if (st.prefs.threaded)
{
if (st.native_locks && mutex && p11_pthread_mutex_unlock)
p11_pthread_mutex_unlock((PCSCLITE_MUTEX_T)mutex);
else if (!st.native_locks && mutex && p11_unlockmutex)
p11_unlockmutex(mutex);
else
rv = CKR_FUNCTION_FAILED;
}
return rv;
}
_______________________________________________
Muscle mailing list
[email protected]
http://lists.drizzle.com/mailman/listinfo/muscle
