/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*

 * Deal with PKCS #11 Slots.

 */

#include "seccomon.h"

#include "secmod.h"

#include "nssilock.h"

#include "secmodi.h"

#include "secmodti.h"

#include "pkcs11t.h"

#include "pk11func.h"

#include "secitem.h"

#include "secerr.h"

#include "dev.h" 

#include "dev3hack.h" 

#include "pkim.h"

#include "utilpars.h"

/*************************************************************

 * local static and global data

 *************************************************************/

/*

 * This array helps parsing between names, mechanisms, and flags.

 * to make the config files understand more entries, add them

 * to this table.

 */

const PK11DefaultArrayEntry PK11_DefaultArray[] = {

	{ "RSA", SECMOD_RSA_FLAG, CKM_RSA_PKCS },

	{ "DSA", SECMOD_DSA_FLAG, CKM_DSA },

	{ "ECC", SECMOD_ECC_FLAG, CKM_ECDSA },

	{ "DH", SECMOD_DH_FLAG, CKM_DH_PKCS_DERIVE },

	{ "RC2", SECMOD_RC2_FLAG, CKM_RC2_CBC },

	{ "RC4", SECMOD_RC4_FLAG, CKM_RC4 },

	{ "DES", SECMOD_DES_FLAG, CKM_DES_CBC },

	{ "AES", SECMOD_AES_FLAG, CKM_AES_CBC },

	{ "Camellia", SECMOD_CAMELLIA_FLAG, CKM_CAMELLIA_CBC },

	{ "SEED", SECMOD_SEED_FLAG, CKM_SEED_CBC },

	{ "RC5", SECMOD_RC5_FLAG, CKM_RC5_CBC },

	{ "SHA-1", SECMOD_SHA1_FLAG, CKM_SHA_1 },

/*	{ "SHA224", SECMOD_SHA256_FLAG, CKM_SHA224 }, */

	{ "SHA256", SECMOD_SHA256_FLAG, CKM_SHA256 },

/*	{ "SHA384", SECMOD_SHA512_FLAG, CKM_SHA384 }, */

	{ "SHA512", SECMOD_SHA512_FLAG, CKM_SHA512 },

	{ "MD5", SECMOD_MD5_FLAG, CKM_MD5 },

	{ "MD2", SECMOD_MD2_FLAG, CKM_MD2 },

	{ "SSL", SECMOD_SSL_FLAG, CKM_SSL3_PRE_MASTER_KEY_GEN },

	{ "TLS", SECMOD_TLS_FLAG, CKM_TLS_MASTER_KEY_DERIVE },

	{ "SKIPJACK", SECMOD_FORTEZZA_FLAG, CKM_SKIPJACK_CBC64 },

	{ "Publicly-readable certs", SECMOD_FRIENDLY_FLAG, CKM_INVALID_MECHANISM },

	{ "Random Num Generator", SECMOD_RANDOM_FLAG, CKM_FAKE_RANDOM },

};

const int num_pk11_default_mechanisms = 

                sizeof(PK11_DefaultArray) / sizeof(PK11_DefaultArray[0]);

const PK11DefaultArrayEntry *

PK11_GetDefaultArray(int *size)

{

    if (size) {

	*size = num_pk11_default_mechanisms;

    }

    return PK11_DefaultArray;

}

/*

 * These  slotlists are lists of modules which provide default support for

 *  a given algorithm or mechanism.

 */

static PK11SlotList 

    pk11_seedSlotList,

    pk11_camelliaSlotList,

    pk11_aesSlotList,

    pk11_desSlotList,

    pk11_rc4SlotList,

    pk11_rc2SlotList,

    pk11_rc5SlotList,

    pk11_sha1SlotList,

    pk11_md5SlotList,

    pk11_md2SlotList,

    pk11_rsaSlotList,

    pk11_dsaSlotList,

    pk11_dhSlotList,

    pk11_ecSlotList,

    pk11_ideaSlotList,

    pk11_sslSlotList,

    pk11_tlsSlotList,

    pk11_randomSlotList,

    pk11_sha256SlotList,

    pk11_sha512SlotList;	/* slots do SHA512 and SHA384 */

/************************************************************

 * Generic Slot List and Slot List element manipulations

 ************************************************************/

/*

 * allocate a new list 

 */

PK11SlotList *

PK11_NewSlotList(void)

{

    PK11SlotList *list;

    list = (PK11SlotList *)PORT_Alloc(sizeof(PK11SlotList));

    if (list == NULL) return NULL;

    list->head = NULL;

    list->tail = NULL;

    list->lock = PZ_NewLock(nssILockList);

    if (list->lock == NULL) {

	PORT_Free(list);

	return NULL;

    }

    return list;

}

/*

 * free a list element when all the references go away.

 */

SECStatus

PK11_FreeSlotListElement(PK11SlotList *list, PK11SlotListElement *le)

{

    PRBool freeit = PR_FALSE;

    if (list == NULL || le == NULL) {

	PORT_SetError(SEC_ERROR_INVALID_ARGS);

	return SECFailure;

    }

    PZ_Lock(list->lock);

    if (le->refCount-- == 1) {

	freeit = PR_TRUE;

    }

    PZ_Unlock(list->lock);

    if (freeit) {

    	PK11_FreeSlot(le->slot);

	PORT_Free(le);

    }

    return SECSuccess;

}

static void

pk11_FreeSlotListStatic(PK11SlotList *list)

{

    PK11SlotListElement *le, *next ;

    if (list == NULL) return;

    for (le = list->head ; le; le = next) {

	next = le->next;

	PK11_FreeSlotListElement(list,le);

    }

    if (list->lock) {

    	PZ_DestroyLock(list->lock);

    }

    list->lock = NULL;

    list->head = NULL;

}

/*

 * if we are freeing the list, we must be the only ones with a pointer

 * to the list.

 */

void

PK11_FreeSlotList(PK11SlotList *list)

{

    pk11_FreeSlotListStatic(list);

    PORT_Free(list);

}

/*

 * add a slot to a list

 * "slot" is the slot to be added. Ownership is not transferred.

 * "sorted" indicates whether or not the slot should be inserted according to

 *   cipherOrder of the associated module. PR_FALSE indicates that the slot

 *   should be inserted to the head of the list.

 */

SECStatus

PK11_AddSlotToList(PK11SlotList *list,PK11SlotInfo *slot, PRBool sorted)

{

    PK11SlotListElement *le;

    PK11SlotListElement *element;

    le = (PK11SlotListElement *) PORT_Alloc(sizeof(PK11SlotListElement));

    if (le == NULL) return SECFailure;

    le->slot = PK11_ReferenceSlot(slot);

    le->prev = NULL;

    le->refCount = 1;

    PZ_Lock(list->lock);

    element = list->head;

    /* Insertion sort, with higher cipherOrders are sorted first in the list */

    while (element && sorted && (element->slot->module->cipherOrder >

                                 le->slot->module->cipherOrder)) {

        element = element->next;

    }

    if (element) {

        le->prev = element->prev;

        element->prev = le;

        le->next = element;

    } else {

        le->prev = list->tail;

        le->next = NULL;

        list->tail = le;

    }

    if (le->prev) le->prev->next = le;

    if (list->head == element) list->head = le;

    PZ_Unlock(list->lock);

    return SECSuccess;

}

/*

 * remove a slot entry from the list

 */

SECStatus

PK11_DeleteSlotFromList(PK11SlotList *list,PK11SlotListElement *le)

{

    PZ_Lock(list->lock);

    if (le->prev) le->prev->next = le->next; else list->head = le->next;

    if (le->next) le->next->prev = le->prev; else list->tail = le->prev;

    le->next = le->prev = NULL;

    PZ_Unlock(list->lock);

    PK11_FreeSlotListElement(list,le);

    return SECSuccess;

}

/*

 * Move a list to the end of the target list.

 * NOTE: There is no locking here... This assumes BOTH lists are private copy

 * lists. It also does not re-sort the target list.

 */

SECStatus

pk11_MoveListToList(PK11SlotList *target,PK11SlotList *src)

{

    if (src->head == NULL) return SECSuccess;

    if (target->tail == NULL) {

	target->head = src->head;

    } else {

	target->tail->next = src->head;

    }

    src->head->prev = target->tail;

    target->tail = src->tail;

    src->head = src->tail = NULL;

    return SECSuccess;

}

/*

 * get an element from the list with a reference. You must own the list.

 */

PK11SlotListElement *

PK11_GetFirstRef(PK11SlotList *list)

{

    PK11SlotListElement *le;

    le = list->head;

    if (le != NULL) (le)->refCount++;

    return le;

}

/*

 * get the next element from the list with a reference. You must own the list.

 */

PK11SlotListElement *

PK11_GetNextRef(PK11SlotList *list, PK11SlotListElement *le, PRBool restart)

{

    PK11SlotListElement *new_le;

    new_le = le->next;

    if (new_le) new_le->refCount++;

    PK11_FreeSlotListElement(list,le);

    return new_le;

}

/*

 * get an element safely from the list. This just makes sure that if

 * this element is not deleted while we deal with it.

 */

PK11SlotListElement *

PK11_GetFirstSafe(PK11SlotList *list)

{

    PK11SlotListElement *le;

    PZ_Lock(list->lock);

    le = list->head;

    if (le != NULL) (le)->refCount++;

    PZ_Unlock(list->lock);

    return le;

}

/*

 * NOTE: if this element gets deleted, we can no longer safely traverse using

 * it's pointers. We can either terminate the loop, or restart from the

 * beginning. This is controlled by the restart option.

 */

PK11SlotListElement *

PK11_GetNextSafe(PK11SlotList *list, PK11SlotListElement *le, PRBool restart)

{

    PK11SlotListElement *new_le;

    PZ_Lock(list->lock);

    new_le = le->next;

    if (le->next == NULL) {

	/* if the prev and next fields are NULL then either this element

	 * has been removed and we need to walk the list again (if restart

	 * is true) or this was the only element on the list */

	if ((le->prev == NULL) && restart &&  (list->head != le)) {

	    new_le = list->head;

	}

    }

    if (new_le) new_le->refCount++;

    PZ_Unlock(list->lock);

    PK11_FreeSlotListElement(list,le);

    return new_le;

}

/*

 * Find the element that holds this slot

 */

PK11SlotListElement *

PK11_FindSlotElement(PK11SlotList *list,PK11SlotInfo *slot)

{

    PK11SlotListElement *le;

    for (le = PK11_GetFirstSafe(list); le;

			 	le = PK11_GetNextSafe(list,le,PR_TRUE)) {

	if (le->slot == slot) return le;

    }

    return NULL;

}

/************************************************************

 * Generic Slot Utilities

 ************************************************************/

/*

 * Create a new slot structure

 */

PK11SlotInfo *

PK11_NewSlotInfo(SECMODModule *mod)

{

    PK11SlotInfo *slot;

    slot = (PK11SlotInfo *)PORT_Alloc(sizeof(PK11SlotInfo));

    if (slot == NULL) return slot;

    slot->sessionLock = mod->isThreadSafe ?

	PZ_NewLock(nssILockSession) : mod->refLock;

    if (slot->sessionLock == NULL) {

	PORT_Free(slot);

	return NULL;

    }

    slot->freeListLock = PZ_NewLock(nssILockFreelist);

    if (slot->freeListLock == NULL) {

	if (mod->isThreadSafe) {

	    PZ_DestroyLock(slot->sessionLock);

	}

	PORT_Free(slot);

	return NULL;

    }

    slot->freeSymKeysWithSessionHead = NULL;

    slot->freeSymKeysHead = NULL;

    slot->keyCount = 0;

    slot->maxKeyCount = 0;

    slot->functionList = NULL;

    slot->needTest = PR_TRUE;

    slot->isPerm = PR_FALSE;

    slot->isHW = PR_FALSE;

    slot->isInternal = PR_FALSE;

    slot->isThreadSafe = PR_FALSE;

    slot->disabled = PR_FALSE;

    slot->series = 1;

    slot->wrapKey = 0;

    slot->wrapMechanism = CKM_INVALID_MECHANISM;

    slot->refKeys[0] = CK_INVALID_HANDLE;

    slot->reason = PK11_DIS_NONE;

    slot->readOnly = PR_TRUE;

    slot->needLogin = PR_FALSE;

    slot->hasRandom = PR_FALSE;

    slot->defRWSession = PR_FALSE;

    slot->protectedAuthPath = PR_FALSE;

    slot->flags = 0;

    slot->session = CK_INVALID_SESSION;

    slot->slotID = 0;

    slot->defaultFlags = 0;

    slot->refCount = 1;

    slot->askpw = 0;

    slot->timeout = 0;

    slot->mechanismList = NULL;

    slot->mechanismCount = 0;

    slot->cert_array = NULL;

    slot->cert_count = 0;

    slot->slot_name[0] = 0;

    slot->token_name[0] = 0;

    PORT_Memset(slot->serial,' ',sizeof(slot->serial));

    slot->module = NULL;

    slot->authTransact = 0;

    slot->authTime = LL_ZERO;

    slot->minPassword = 0;

    slot->maxPassword = 0;

    slot->hasRootCerts = PR_FALSE;

    slot->nssToken = NULL;

    return slot;

}

/* create a new reference to a slot so it doesn't go away */

PK11SlotInfo *

PK11_ReferenceSlot(PK11SlotInfo *slot)

{

    PR_ATOMIC_INCREMENT(&slot->refCount);

    return slot;

}

/* Destroy all info on a slot we have built up */

void

PK11_DestroySlot(PK11SlotInfo *slot)

{

   /* free up the cached keys and sessions */

   PK11_CleanKeyList(slot);

   /* free up all the sessions on this slot */

   if (slot->functionList) {

	PK11_GETTAB(slot)->C_CloseAllSessions(slot->slotID);

   }

   if (slot->mechanismList) {

	PORT_Free(slot->mechanismList);

   }

   if (slot->isThreadSafe && slot->sessionLock) {

	PZ_DestroyLock(slot->sessionLock);

   }

   slot->sessionLock = NULL;

   if (slot->freeListLock) {

	PZ_DestroyLock(slot->freeListLock);

	slot->freeListLock = NULL;

   }

   /* finally Tell our parent module that we've gone away so it can unload */

   if (slot->module) {

	SECMOD_SlotDestroyModule(slot->module,PR_TRUE);

   }

   /* ok, well not quit finally... now we free the memory */

   PORT_Free(slot);

}

/* We're all done with the slot, free it */

void

PK11_FreeSlot(PK11SlotInfo *slot)

{

    if (PR_ATOMIC_DECREMENT(&slot->refCount) == 0) {

	PK11_DestroySlot(slot);

    }

}

void

PK11_EnterSlotMonitor(PK11SlotInfo *slot) {

    PZ_Lock(slot->sessionLock);

}

void

PK11_ExitSlotMonitor(PK11SlotInfo *slot) {

    PZ_Unlock(slot->sessionLock);

}

/***********************************************************

 * Functions to find specific slots.

 ***********************************************************/

PRBool

SECMOD_HasRootCerts(void)

{

   SECMODModuleList *mlp;

   SECMODModuleList *modules;

   SECMODListLock *moduleLock = SECMOD_GetDefaultModuleListLock();

   int i;

   PRBool found = PR_FALSE;

    if (!moduleLock) {

    	PORT_SetError(SEC_ERROR_NOT_INITIALIZED);

	return found;

    }

   /* work through all the slots */

   SECMOD_GetReadLock(moduleLock);

   modules = SECMOD_GetDefaultModuleList();

   for(mlp = modules; mlp != NULL; mlp = mlp->next) {

	for (i=0; i < mlp->module->slotCount; i++) {

	    PK11SlotInfo *tmpSlot = mlp->module->slots[i];

	    if (PK11_IsPresent(tmpSlot)) {

		if (tmpSlot->hasRootCerts) {

		    found = PR_TRUE;

		    break;

		}

	    }

	}

	if (found) break;

    }

    SECMOD_ReleaseReadLock(moduleLock);

    return found;

}

/***********************************************************

 * Functions to find specific slots.

 ***********************************************************/

PK11SlotList *

PK11_FindSlotsByNames(const char *dllName, const char* slotName,

                        const char* tokenName, PRBool presentOnly)

{

    SECMODModuleList *mlp;

    SECMODModuleList *modules;

    SECMODListLock *moduleLock = SECMOD_GetDefaultModuleListLock();

    int i;

    PK11SlotList* slotList = NULL;

    PRUint32 slotcount = 0;

    SECStatus rv = SECSuccess;

    if (!moduleLock) {

    	PORT_SetError(SEC_ERROR_NOT_INITIALIZED);

	return slotList;

    }

    slotList = PK11_NewSlotList();

    if (!slotList) {

        PORT_SetError(SEC_ERROR_NO_MEMORY);

        return slotList;

    }

    if ( ((NULL == dllName) || (0 == *dllName)) &&

        ((NULL == slotName) || (0 == *slotName)) &&

        ((NULL == tokenName) || (0 == *tokenName)) ) {

        /* default to softoken */

        PK11_AddSlotToList(slotList, PK11_GetInternalKeySlot(), PR_TRUE);

        return slotList;

    }

    /* work through all the slots */

    SECMOD_GetReadLock(moduleLock);

    modules = SECMOD_GetDefaultModuleList();

    for (mlp = modules; mlp != NULL; mlp = mlp->next) {

        PORT_Assert(mlp->module);

        if (!mlp->module) {

            rv = SECFailure;

            break;

        }

        if ((!dllName) || (mlp->module->dllName &&

            (0 == PORT_Strcmp(mlp->module->dllName, dllName)))) {

            for (i=0; i < mlp->module->slotCount; i++) {

                PK11SlotInfo *tmpSlot = (mlp->module->slots?mlp->module->slots[i]:NULL);

                PORT_Assert(tmpSlot);

                if (!tmpSlot) {

                    rv = SECFailure;

                    break;

                }

                if ((PR_FALSE == presentOnly || PK11_IsPresent(tmpSlot)) &&

                    ( (!tokenName) || (tmpSlot->token_name &&

                    (0==PORT_Strcmp(tmpSlot->token_name, tokenName)))) &&

                    ( (!slotName) || (tmpSlot->slot_name &&

                    (0==PORT_Strcmp(tmpSlot->slot_name, slotName)))) ) {

                    if (tmpSlot) {

                        PK11_AddSlotToList(slotList, tmpSlot, PR_TRUE);

                        slotcount++;

                    }

                }

            }

        }

    }

    SECMOD_ReleaseReadLock(moduleLock);

    if ( (0 == slotcount) || (SECFailure == rv) ) {

        PORT_SetError(SEC_ERROR_NO_TOKEN);

        PK11_FreeSlotList(slotList);

        slotList = NULL;

    }

    if (SECFailure == rv) {

        PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);

    }

    return slotList;

}

PK11SlotInfo *

PK11_FindSlotByName(const char *name)

{

   SECMODModuleList *mlp;

   SECMODModuleList *modules;

   SECMODListLock *moduleLock = SECMOD_GetDefaultModuleListLock();

   int i;

   PK11SlotInfo *slot = NULL;

    if (!moduleLock) {

    	PORT_SetError(SEC_ERROR_NOT_INITIALIZED);

	return slot;

    }

   if ((name == NULL) || (*name == 0)) {

	return PK11_GetInternalKeySlot();

   }

   /* work through all the slots */

   SECMOD_GetReadLock(moduleLock);

   modules = SECMOD_GetDefaultModuleList();

   for(mlp = modules; mlp != NULL; mlp = mlp->next) {

	for (i=0; i < mlp->module->slotCount; i++) {

	    PK11SlotInfo *tmpSlot = mlp->module->slots[i];

	    if (PK11_IsPresent(tmpSlot)) {

		if (PORT_Strcmp(tmpSlot->token_name,name) == 0) {

		    slot = PK11_ReferenceSlot(tmpSlot);

		    break;

		}

	    }

	}

	if (slot != NULL) break;

    }

    SECMOD_ReleaseReadLock(moduleLock);

    if (slot == NULL) {

	PORT_SetError(SEC_ERROR_NO_TOKEN);

    }

    return slot;

}

PK11SlotInfo *

PK11_FindSlotBySerial(char *serial)

{

   SECMODModuleList *mlp;

   SECMODModuleList *modules;

   SECMODListLock *moduleLock = SECMOD_GetDefaultModuleListLock();

   int i;

   PK11SlotInfo *slot = NULL;

    if (!moduleLock) {

    	PORT_SetError(SEC_ERROR_NOT_INITIALIZED);

	return slot;

    }

   /* work through all the slots */

   SECMOD_GetReadLock(moduleLock);

   modules = SECMOD_GetDefaultModuleList();

   for(mlp = modules; mlp != NULL; mlp = mlp->next) {

	for (i=0; i < mlp->module->slotCount; i++) {

	    PK11SlotInfo *tmpSlot = mlp->module->slots[i];

	    if (PK11_IsPresent(tmpSlot)) {

		if (PORT_Memcmp(tmpSlot->serial,serial,

					sizeof(tmpSlot->serial)) == 0) {

		    slot = PK11_ReferenceSlot(tmpSlot);

		    break;

		}

	    }

	}

	if (slot != NULL) break;

    }

    SECMOD_ReleaseReadLock(moduleLock);

    if (slot == NULL) {

	PORT_SetError(SEC_ERROR_NO_TOKEN);

    }

    return slot;

}

/*

 * notification stub. If we ever get interested in any events that

 * the pkcs11 functions may pass back to use, we can catch them here...

 * currently pdata is a slotinfo structure.

 */

CK_RV pk11_notify(CK_SESSION_HANDLE session, CK_NOTIFICATION event,

							 CK_VOID_PTR pdata)

{

    return CKR_OK;

}

/*

 * grab a new RW session

 * !!! has a side effect of grabbing the Monitor if either the slot's default

 * session is RW or the slot is not thread safe. Monitor is release in function

 * below

 */

CK_SESSION_HANDLE PK11_GetRWSession(PK11SlotInfo *slot)

{

    CK_SESSION_HANDLE rwsession;

    CK_RV crv;

    PRBool haveMonitor = PR_FALSE;

    if (!slot->isThreadSafe || slot->defRWSession) {

    	PK11_EnterSlotMonitor(slot);

	haveMonitor = PR_TRUE;

    }

    if (slot->defRWSession) {

	PORT_Assert(slot->session != CK_INVALID_SESSION);

	if (slot->session != CK_INVALID_SESSION) 

	    return slot->session;

    }

    crv = PK11_GETTAB(slot)->C_OpenSession(slot->slotID,

				CKF_RW_SESSION|CKF_SERIAL_SESSION,

				  	  slot, pk11_notify,&rwsession);

    PORT_Assert(rwsession != CK_INVALID_SESSION || crv != CKR_OK);

    if (crv != CKR_OK || rwsession == CK_INVALID_SESSION) {

	if (crv == CKR_OK) 

	    crv = CKR_DEVICE_ERROR;

	if (haveMonitor)

	    PK11_ExitSlotMonitor(slot);

	PORT_SetError(PK11_MapError(crv));

	return CK_INVALID_SESSION;

    }

    if (slot->defRWSession) { /* we have the monitor */

    	slot->session = rwsession;

    }

    return rwsession;

}

PRBool

PK11_RWSessionHasLock(PK11SlotInfo *slot,CK_SESSION_HANDLE session_handle) 

{

    PRBool hasLock;

    hasLock = (PRBool)(!slot->isThreadSafe || 

    	      (slot->defRWSession && slot->session != CK_INVALID_SESSION));

    return hasLock;

}

static PRBool

pk11_RWSessionIsDefault(PK11SlotInfo *slot,CK_SESSION_HANDLE rwsession)

{

    PRBool isDefault;

    isDefault = (PRBool)(slot->session == rwsession &&

    	                 slot->defRWSession && 

			 slot->session != CK_INVALID_SESSION);

    return isDefault;

}

/*

 * close the rwsession and restore our readonly session

 * !!! has a side effect of releasing the Monitor if either the slot's default

 * session is RW or the slot is not thread safe.

 */

void

PK11_RestoreROSession(PK11SlotInfo *slot,CK_SESSION_HANDLE rwsession)

{

    PORT_Assert(rwsession != CK_INVALID_SESSION);

    if (rwsession != CK_INVALID_SESSION) {

    	PRBool doExit = PK11_RWSessionHasLock(slot, rwsession);

	if (!pk11_RWSessionIsDefault(slot, rwsession))

	    PK11_GETTAB(slot)->C_CloseSession(rwsession);

	if (doExit)

	    PK11_ExitSlotMonitor(slot);

    }

}

/************************************************************

 * Manage the built-In Slot Lists

 ************************************************************/

/* Init the static built int slot list (should actually integrate

 * with PK11_NewSlotList */

static void

pk11_InitSlotListStatic(PK11SlotList *list)

{

    list->lock = PZ_NewLock(nssILockList);

    list->head = NULL;

}

/* initialize the system slotlists */

SECStatus

PK11_InitSlotLists(void)

{

    pk11_InitSlotListStatic(&pk11_seedSlotList);

    pk11_InitSlotListStatic(&pk11_camelliaSlotList);

    pk11_InitSlotListStatic(&pk11_aesSlotList);

    pk11_InitSlotListStatic(&pk11_desSlotList);

    pk11_InitSlotListStatic(&pk11_rc4SlotList);

    pk11_InitSlotListStatic(&pk11_rc2SlotList);

    pk11_InitSlotListStatic(&pk11_rc5SlotList);

    pk11_InitSlotListStatic(&pk11_md5SlotList);

    pk11_InitSlotListStatic(&pk11_md2SlotList);

    pk11_InitSlotListStatic(&pk11_sha1SlotList);

    pk11_InitSlotListStatic(&pk11_rsaSlotList);

    pk11_InitSlotListStatic(&pk11_dsaSlotList);

    pk11_InitSlotListStatic(&pk11_dhSlotList);

    pk11_InitSlotListStatic(&pk11_ecSlotList);

    pk11_InitSlotListStatic(&pk11_ideaSlotList);

    pk11_InitSlotListStatic(&pk11_sslSlotList);

    pk11_InitSlotListStatic(&pk11_tlsSlotList);

    pk11_InitSlotListStatic(&pk11_randomSlotList);

    pk11_InitSlotListStatic(&pk11_sha256SlotList);

    pk11_InitSlotListStatic(&pk11_sha512SlotList);

    return SECSuccess;

}

void

PK11_DestroySlotLists(void)

{

    pk11_FreeSlotListStatic(&pk11_seedSlotList);

    pk11_FreeSlotListStatic(&pk11_camelliaSlotList);

    pk11_FreeSlotListStatic(&pk11_aesSlotList);

    pk11_FreeSlotListStatic(&pk11_desSlotList);

    pk11_FreeSlotListStatic(&pk11_rc4SlotList);

    pk11_FreeSlotListStatic(&pk11_rc2SlotList);

    pk11_FreeSlotListStatic(&pk11_rc5SlotList);

    pk11_FreeSlotListStatic(&pk11_md5SlotList);

    pk11_FreeSlotListStatic(&pk11_md2SlotList);

    pk11_FreeSlotListStatic(&pk11_sha1SlotList);

    pk11_FreeSlotListStatic(&pk11_rsaSlotList);

    pk11_FreeSlotListStatic(&pk11_dsaSlotList);

    pk11_FreeSlotListStatic(&pk11_dhSlotList);

    pk11_FreeSlotListStatic(&pk11_ecSlotList);

    pk11_FreeSlotListStatic(&pk11_ideaSlotList);

    pk11_FreeSlotListStatic(&pk11_sslSlotList);

    pk11_FreeSlotListStatic(&pk11_tlsSlotList);

    pk11_FreeSlotListStatic(&pk11_randomSlotList);

    pk11_FreeSlotListStatic(&pk11_sha256SlotList);

    pk11_FreeSlotListStatic(&pk11_sha512SlotList);

    return;

}

/* return a system slot list based on mechanism */

PK11SlotList *

PK11_GetSlotList(CK_MECHANISM_TYPE type)

{

/* XXX a workaround for Bugzilla bug #55267 */

#if defined(HPUX) && defined(__LP64__)

    if (CKM_INVALID_MECHANISM == type)

        return NULL;

#endif

    switch (type) {

    case CKM_SEED_CBC:

    case CKM_SEED_ECB:

	return &pk11_seedSlotList;

    case CKM_CAMELLIA_CBC:

    case CKM_CAMELLIA_ECB:

	return &pk11_camelliaSlotList;

    case CKM_AES_CBC:

    case CKM_AES_CCM:

    case CKM_AES_CTR:

    case CKM_AES_CTS:

    case CKM_AES_GCM:

    case CKM_AES_ECB:

	return &pk11_aesSlotList;

    case CKM_DES_CBC:

    case CKM_DES_ECB:

    case CKM_DES3_ECB:

    case CKM_DES3_CBC:

	return &pk11_desSlotList;

    case CKM_RC4:

	return &pk11_rc4SlotList;

    case CKM_RC5_CBC:

	return &pk11_rc5SlotList;

    case CKM_SHA_1:

	return &pk11_sha1SlotList;

    case CKM_SHA224:

    case CKM_SHA256:

	return &pk11_sha256SlotList;

    case CKM_SHA384:

    case CKM_SHA512:

	return &pk11_sha512SlotList;

    case CKM_MD5:

	return &pk11_md5SlotList;

    case CKM_MD2:

	return &pk11_md2SlotList;

    case CKM_RC2_ECB:

    case CKM_RC2_CBC:

	return &pk11_rc2SlotList;

    case CKM_RSA_PKCS:

    case CKM_RSA_PKCS_KEY_PAIR_GEN:

    case CKM_RSA_X_509:

	return &pk11_rsaSlotList;

    case CKM_DSA:

	return &pk11_dsaSlotList;

    case CKM_DH_PKCS_KEY_PAIR_GEN:

    case CKM_DH_PKCS_DERIVE:

	return &pk11_dhSlotList;

    case CKM_ECDSA:

    case CKM_ECDSA_SHA1:

    case CKM_EC_KEY_PAIR_GEN: /* aka CKM_ECDSA_KEY_PAIR_GEN */

    case CKM_ECDH1_DERIVE: