| Index: mozilla/security/nss/lib/ckfw/instance.c
|
| ===================================================================
|
| --- mozilla/security/nss/lib/ckfw/instance.c (revision 191424)
|
| +++ mozilla/security/nss/lib/ckfw/instance.c (working copy)
|
| @@ -1,1344 +0,0 @@
|
| -/* 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/. */
|
| -
|
| -#ifdef DEBUG
|
| -static const char CVS_ID[] = "@(#) $RCSfile: instance.c,v $ $Revision: 1.14 $ $Date: 2012/04/25 14:49:28 $";
|
| -#endif /* DEBUG */
|
| -
|
| -/*
|
| - * instance.c
|
| - *
|
| - * This file implements the NSSCKFWInstance type and methods.
|
| - */
|
| -
|
| -#ifndef CK_T
|
| -#include "ck.h"
|
| -#endif /* CK_T */
|
| -
|
| -/*
|
| - * NSSCKFWInstance
|
| - *
|
| - * -- create/destroy --
|
| - * nssCKFWInstance_Create
|
| - * nssCKFWInstance_Destroy
|
| - *
|
| - * -- public accessors --
|
| - * NSSCKFWInstance_GetMDInstance
|
| - * NSSCKFWInstance_GetArena
|
| - * NSSCKFWInstance_MayCreatePthreads
|
| - * NSSCKFWInstance_CreateMutex
|
| - * NSSCKFWInstance_GetConfigurationData
|
| - * NSSCKFWInstance_GetInitArgs
|
| - *
|
| - * -- implement public accessors --
|
| - * nssCKFWInstance_GetMDInstance
|
| - * nssCKFWInstance_GetArena
|
| - * nssCKFWInstance_MayCreatePthreads
|
| - * nssCKFWInstance_CreateMutex
|
| - * nssCKFWInstance_GetConfigurationData
|
| - * nssCKFWInstance_GetInitArgs
|
| - *
|
| - * -- private accessors --
|
| - * nssCKFWInstance_CreateSessionHandle
|
| - * nssCKFWInstance_ResolveSessionHandle
|
| - * nssCKFWInstance_DestroySessionHandle
|
| - * nssCKFWInstance_FindSessionHandle
|
| - * nssCKFWInstance_CreateObjectHandle
|
| - * nssCKFWInstance_ResolveObjectHandle
|
| - * nssCKFWInstance_DestroyObjectHandle
|
| - *
|
| - * -- module fronts --
|
| - * nssCKFWInstance_GetNSlots
|
| - * nssCKFWInstance_GetCryptokiVersion
|
| - * nssCKFWInstance_GetManufacturerID
|
| - * nssCKFWInstance_GetFlags
|
| - * nssCKFWInstance_GetLibraryDescription
|
| - * nssCKFWInstance_GetLibraryVersion
|
| - * nssCKFWInstance_GetModuleHandlesSessionObjects
|
| - * nssCKFWInstance_GetSlots
|
| - * nssCKFWInstance_WaitForSlotEvent
|
| - *
|
| - * -- debugging versions only --
|
| - * nssCKFWInstance_verifyPointer
|
| - */
|
| -
|
| -struct NSSCKFWInstanceStr {
|
| - NSSCKFWMutex *mutex;
|
| - NSSArena *arena;
|
| - NSSCKMDInstance *mdInstance;
|
| - CK_C_INITIALIZE_ARGS_PTR pInitArgs;
|
| - CK_C_INITIALIZE_ARGS initArgs;
|
| - CryptokiLockingState LockingState;
|
| - CK_BBOOL mayCreatePthreads;
|
| - NSSUTF8 *configurationData;
|
| - CK_ULONG nSlots;
|
| - NSSCKFWSlot **fwSlotList;
|
| - NSSCKMDSlot **mdSlotList;
|
| - CK_BBOOL moduleHandlesSessionObjects;
|
| -
|
| - /*
|
| - * Everything above is set at creation time, and then not modified.
|
| - * The invariants the mutex protects are:
|
| - *
|
| - * 1) Each of the cached descriptions (versions, etc.) are in an
|
| - * internally consistant state.
|
| - *
|
| - * 2) The session handle hashes and count are consistant
|
| - *
|
| - * 3) The object handle hashes and count are consistant.
|
| - *
|
| - * I could use multiple locks, but let's wait to see if that's
|
| - * really necessary.
|
| - *
|
| - * Note that the calls accessing the cached descriptions will
|
| - * call the NSSCKMDInstance methods with the mutex locked. Those
|
| - * methods may then call the public NSSCKFWInstance routines.
|
| - * Those public routines only access the constant data above, so
|
| - * there's no problem. But be careful if you add to this object;
|
| - * mutexes are in general not reentrant, so don't create deadlock
|
| - * situations.
|
| - */
|
| -
|
| - CK_VERSION cryptokiVersion;
|
| - NSSUTF8 *manufacturerID;
|
| - NSSUTF8 *libraryDescription;
|
| - CK_VERSION libraryVersion;
|
| -
|
| - CK_ULONG lastSessionHandle;
|
| - nssCKFWHash *sessionHandleHash;
|
| -
|
| - CK_ULONG lastObjectHandle;
|
| - nssCKFWHash *objectHandleHash;
|
| -};
|
| -
|
| -#ifdef DEBUG
|
| -/*
|
| - * But first, the pointer-tracking stuff.
|
| - *
|
| - * NOTE: the pointer-tracking support in NSS/base currently relies
|
| - * upon NSPR's CallOnce support. That, however, relies upon NSPR's
|
| - * locking, which is tied into the runtime. We need a pointer-tracker
|
| - * implementation that uses the locks supplied through C_Initialize.
|
| - * That support, however, can be filled in later. So for now, I'll
|
| - * just do this routines as no-ops.
|
| - */
|
| -
|
| -static CK_RV
|
| -instance_add_pointer
|
| -(
|
| - const NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| - return CKR_OK;
|
| -}
|
| -
|
| -static CK_RV
|
| -instance_remove_pointer
|
| -(
|
| - const NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| - return CKR_OK;
|
| -}
|
| -
|
| -NSS_IMPLEMENT CK_RV
|
| -nssCKFWInstance_verifyPointer
|
| -(
|
| - const NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| - return CKR_OK;
|
| -}
|
| -
|
| -#endif /* DEBUG */
|
| -
|
| -/*
|
| - * nssCKFWInstance_Create
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSCKFWInstance *
|
| -nssCKFWInstance_Create
|
| -(
|
| - CK_C_INITIALIZE_ARGS_PTR pInitArgs,
|
| - CryptokiLockingState LockingState,
|
| - NSSCKMDInstance *mdInstance,
|
| - CK_RV *pError
|
| -)
|
| -{
|
| - NSSCKFWInstance *fwInstance;
|
| - NSSArena *arena = (NSSArena *)NULL;
|
| - CK_ULONG i;
|
| - CK_BBOOL called_Initialize = CK_FALSE;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if( (CK_RV)NULL == pError ) {
|
| - return (NSSCKFWInstance *)NULL;
|
| - }
|
| -
|
| - if (!mdInstance) {
|
| - *pError = CKR_ARGUMENTS_BAD;
|
| - return (NSSCKFWInstance *)NULL;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - arena = NSSArena_Create();
|
| - if (!arena) {
|
| - *pError = CKR_HOST_MEMORY;
|
| - return (NSSCKFWInstance *)NULL;
|
| - }
|
| -
|
| - fwInstance = nss_ZNEW(arena, NSSCKFWInstance);
|
| - if (!fwInstance) {
|
| - goto nomem;
|
| - }
|
| -
|
| - fwInstance->arena = arena;
|
| - fwInstance->mdInstance = mdInstance;
|
| -
|
| - fwInstance->LockingState = LockingState;
|
| - if( (CK_C_INITIALIZE_ARGS_PTR)NULL != pInitArgs ) {
|
| - fwInstance->initArgs = *pInitArgs;
|
| - fwInstance->pInitArgs = &fwInstance->initArgs;
|
| - if( pInitArgs->flags & CKF_LIBRARY_CANT_CREATE_OS_THREADS ) {
|
| - fwInstance->mayCreatePthreads = CK_FALSE;
|
| - } else {
|
| - fwInstance->mayCreatePthreads = CK_TRUE;
|
| - }
|
| - fwInstance->configurationData = (NSSUTF8 *)(pInitArgs->pReserved);
|
| - } else {
|
| - fwInstance->mayCreatePthreads = CK_TRUE;
|
| - }
|
| -
|
| - fwInstance->mutex = nssCKFWMutex_Create(pInitArgs, LockingState, arena,
|
| - pError);
|
| - if (!fwInstance->mutex) {
|
| - if( CKR_OK == *pError ) {
|
| - *pError = CKR_GENERAL_ERROR;
|
| - }
|
| - goto loser;
|
| - }
|
| -
|
| - if (mdInstance->Initialize) {
|
| - *pError = mdInstance->Initialize(mdInstance, fwInstance, fwInstance->configurationData);
|
| - if( CKR_OK != *pError ) {
|
| - goto loser;
|
| - }
|
| -
|
| - called_Initialize = CK_TRUE;
|
| - }
|
| -
|
| - if (mdInstance->ModuleHandlesSessionObjects) {
|
| - fwInstance->moduleHandlesSessionObjects =
|
| - mdInstance->ModuleHandlesSessionObjects(mdInstance, fwInstance);
|
| - } else {
|
| - fwInstance->moduleHandlesSessionObjects = CK_FALSE;
|
| - }
|
| -
|
| - if (!mdInstance->GetNSlots) {
|
| - /* That routine is required */
|
| - *pError = CKR_GENERAL_ERROR;
|
| - goto loser;
|
| - }
|
| -
|
| - fwInstance->nSlots = mdInstance->GetNSlots(mdInstance, fwInstance, pError);
|
| - if( (CK_ULONG)0 == fwInstance->nSlots ) {
|
| - if( CKR_OK == *pError ) {
|
| - /* Zero is not a legitimate answer */
|
| - *pError = CKR_GENERAL_ERROR;
|
| - }
|
| - goto loser;
|
| - }
|
| -
|
| - fwInstance->fwSlotList = nss_ZNEWARRAY(arena, NSSCKFWSlot *, fwInstance->nSlots);
|
| - if( (NSSCKFWSlot **)NULL == fwInstance->fwSlotList ) {
|
| - goto nomem;
|
| - }
|
| -
|
| - fwInstance->mdSlotList = nss_ZNEWARRAY(arena, NSSCKMDSlot *, fwInstance->nSlots);
|
| - if( (NSSCKMDSlot **)NULL == fwInstance->mdSlotList ) {
|
| - goto nomem;
|
| - }
|
| -
|
| - fwInstance->sessionHandleHash = nssCKFWHash_Create(fwInstance,
|
| - fwInstance->arena, pError);
|
| - if (!fwInstance->sessionHandleHash) {
|
| - goto loser;
|
| - }
|
| -
|
| - fwInstance->objectHandleHash = nssCKFWHash_Create(fwInstance,
|
| - fwInstance->arena, pError);
|
| - if (!fwInstance->objectHandleHash) {
|
| - goto loser;
|
| - }
|
| -
|
| - if (!mdInstance->GetSlots) {
|
| - /* That routine is required */
|
| - *pError = CKR_GENERAL_ERROR;
|
| - goto loser;
|
| - }
|
| -
|
| - *pError = mdInstance->GetSlots(mdInstance, fwInstance, fwInstance->mdSlotList);
|
| - if( CKR_OK != *pError ) {
|
| - goto loser;
|
| - }
|
| -
|
| - for( i = 0; i < fwInstance->nSlots; i++ ) {
|
| - NSSCKMDSlot *mdSlot = fwInstance->mdSlotList[i];
|
| -
|
| - if (!mdSlot) {
|
| - *pError = CKR_GENERAL_ERROR;
|
| - goto loser;
|
| - }
|
| -
|
| - fwInstance->fwSlotList[i] = nssCKFWSlot_Create(fwInstance, mdSlot, i, pError);
|
| - if( CKR_OK != *pError ) {
|
| - CK_ULONG j;
|
| -
|
| - for( j = 0; j < i; j++ ) {
|
| - (void)nssCKFWSlot_Destroy(fwInstance->fwSlotList[j]);
|
| - }
|
| -
|
| - for( j = i; j < fwInstance->nSlots; j++ ) {
|
| - NSSCKMDSlot *mds = fwInstance->mdSlotList[j];
|
| - if (mds->Destroy) {
|
| - mds->Destroy(mds, (NSSCKFWSlot *)NULL, mdInstance, fwInstance);
|
| - }
|
| - }
|
| -
|
| - goto loser;
|
| - }
|
| - }
|
| -
|
| -#ifdef DEBUG
|
| - *pError = instance_add_pointer(fwInstance);
|
| - if( CKR_OK != *pError ) {
|
| - for( i = 0; i < fwInstance->nSlots; i++ ) {
|
| - (void)nssCKFWSlot_Destroy(fwInstance->fwSlotList[i]);
|
| - }
|
| -
|
| - goto loser;
|
| - }
|
| -#endif /* DEBUG */
|
| -
|
| - *pError = CKR_OK;
|
| - return fwInstance;
|
| -
|
| - nomem:
|
| - *pError = CKR_HOST_MEMORY;
|
| - /*FALLTHROUGH*/
|
| - loser:
|
| -
|
| - if( CK_TRUE == called_Initialize ) {
|
| - if (mdInstance->Finalize) {
|
| - mdInstance->Finalize(mdInstance, fwInstance);
|
| - }
|
| - }
|
| -
|
| - if (fwInstance && fwInstance->mutex) {
|
| - nssCKFWMutex_Destroy(fwInstance->mutex);
|
| - }
|
| -
|
| - if (arena) {
|
| - (void)NSSArena_Destroy(arena);
|
| - }
|
| - return (NSSCKFWInstance *)NULL;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_Destroy
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_RV
|
| -nssCKFWInstance_Destroy
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - CK_RV error = CKR_OK;
|
| -#endif /* NSSDEBUG */
|
| - CK_ULONG i;
|
| -
|
| -#ifdef NSSDEBUG
|
| - error = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != error ) {
|
| - return error;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - nssCKFWMutex_Destroy(fwInstance->mutex);
|
| -
|
| - for( i = 0; i < fwInstance->nSlots; i++ ) {
|
| - (void)nssCKFWSlot_Destroy(fwInstance->fwSlotList[i]);
|
| - }
|
| -
|
| - if (fwInstance->mdInstance->Finalize) {
|
| - fwInstance->mdInstance->Finalize(fwInstance->mdInstance, fwInstance);
|
| - }
|
| -
|
| - if (fwInstance->sessionHandleHash) {
|
| - nssCKFWHash_Destroy(fwInstance->sessionHandleHash);
|
| - }
|
| -
|
| - if (fwInstance->objectHandleHash) {
|
| - nssCKFWHash_Destroy(fwInstance->objectHandleHash);
|
| - }
|
| -
|
| -#ifdef DEBUG
|
| - (void)instance_remove_pointer(fwInstance);
|
| -#endif /* DEBUG */
|
| -
|
| - (void)NSSArena_Destroy(fwInstance->arena);
|
| - return CKR_OK;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetMDInstance
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSCKMDInstance *
|
| -nssCKFWInstance_GetMDInstance
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return (NSSCKMDInstance *)NULL;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - return fwInstance->mdInstance;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetArena
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSArena *
|
| -nssCKFWInstance_GetArena
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_RV *pError
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - if (!pError) {
|
| - return (NSSArena *)NULL;
|
| - }
|
| -
|
| - *pError = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != *pError ) {
|
| - return (NSSArena *)NULL;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - *pError = CKR_OK;
|
| - return fwInstance->arena;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_MayCreatePthreads
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_BBOOL
|
| -nssCKFWInstance_MayCreatePthreads
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return CK_FALSE;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - return fwInstance->mayCreatePthreads;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_CreateMutex
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSCKFWMutex *
|
| -nssCKFWInstance_CreateMutex
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - NSSArena *arena,
|
| - CK_RV *pError
|
| -)
|
| -{
|
| - NSSCKFWMutex *mutex;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if (!pError) {
|
| - return (NSSCKFWMutex *)NULL;
|
| - }
|
| -
|
| - *pError = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != *pError ) {
|
| - return (NSSCKFWMutex *)NULL;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - mutex = nssCKFWMutex_Create(fwInstance->pInitArgs, fwInstance->LockingState,
|
| - arena, pError);
|
| - if (!mutex) {
|
| - if( CKR_OK == *pError ) {
|
| - *pError = CKR_GENERAL_ERROR;
|
| - }
|
| -
|
| - return (NSSCKFWMutex *)NULL;
|
| - }
|
| -
|
| - return mutex;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetConfigurationData
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSUTF8 *
|
| -nssCKFWInstance_GetConfigurationData
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return (NSSUTF8 *)NULL;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - return fwInstance->configurationData;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetInitArgs
|
| - *
|
| - */
|
| -CK_C_INITIALIZE_ARGS_PTR
|
| -nssCKFWInstance_GetInitArgs
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return (CK_C_INITIALIZE_ARGS_PTR)NULL;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - return fwInstance->pInitArgs;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_CreateSessionHandle
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_SESSION_HANDLE
|
| -nssCKFWInstance_CreateSessionHandle
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - NSSCKFWSession *fwSession,
|
| - CK_RV *pError
|
| -)
|
| -{
|
| - CK_SESSION_HANDLE hSession;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if (!pError) {
|
| - return (CK_SESSION_HANDLE)0;
|
| - }
|
| -
|
| - *pError = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != *pError ) {
|
| - return (CK_SESSION_HANDLE)0;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - *pError = nssCKFWMutex_Lock(fwInstance->mutex);
|
| - if( CKR_OK != *pError ) {
|
| - return (CK_SESSION_HANDLE)0;
|
| - }
|
| -
|
| - hSession = ++(fwInstance->lastSessionHandle);
|
| -
|
| - /* Alan would say I should unlock for this call. */
|
| -
|
| - *pError = nssCKFWSession_SetHandle(fwSession, hSession);
|
| - if( CKR_OK != *pError ) {
|
| - goto done;
|
| - }
|
| -
|
| - *pError = nssCKFWHash_Add(fwInstance->sessionHandleHash,
|
| - (const void *)hSession, (const void *)fwSession);
|
| - if( CKR_OK != *pError ) {
|
| - hSession = (CK_SESSION_HANDLE)0;
|
| - goto done;
|
| - }
|
| -
|
| - done:
|
| - nssCKFWMutex_Unlock(fwInstance->mutex);
|
| - return hSession;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_ResolveSessionHandle
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSCKFWSession *
|
| -nssCKFWInstance_ResolveSessionHandle
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_SESSION_HANDLE hSession
|
| -)
|
| -{
|
| - NSSCKFWSession *fwSession;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return (NSSCKFWSession *)NULL;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - if( CKR_OK != nssCKFWMutex_Lock(fwInstance->mutex) ) {
|
| - return (NSSCKFWSession *)NULL;
|
| - }
|
| -
|
| - fwSession = (NSSCKFWSession *)nssCKFWHash_Lookup(
|
| - fwInstance->sessionHandleHash, (const void *)hSession);
|
| -
|
| - /* Assert(hSession == nssCKFWSession_GetHandle(fwSession)) */
|
| -
|
| - (void)nssCKFWMutex_Unlock(fwInstance->mutex);
|
| -
|
| - return fwSession;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_DestroySessionHandle
|
| - *
|
| - */
|
| -NSS_IMPLEMENT void
|
| -nssCKFWInstance_DestroySessionHandle
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_SESSION_HANDLE hSession
|
| -)
|
| -{
|
| - NSSCKFWSession *fwSession;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - if( CKR_OK != nssCKFWMutex_Lock(fwInstance->mutex) ) {
|
| - return;
|
| - }
|
| -
|
| - fwSession = (NSSCKFWSession *)nssCKFWHash_Lookup(
|
| - fwInstance->sessionHandleHash, (const void *)hSession);
|
| - if (fwSession) {
|
| - nssCKFWHash_Remove(fwInstance->sessionHandleHash, (const void *)hSession);
|
| - nssCKFWSession_SetHandle(fwSession, (CK_SESSION_HANDLE)0);
|
| - }
|
| -
|
| - (void)nssCKFWMutex_Unlock(fwInstance->mutex);
|
| -
|
| - return;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_FindSessionHandle
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_SESSION_HANDLE
|
| -nssCKFWInstance_FindSessionHandle
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - NSSCKFWSession *fwSession
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return (CK_SESSION_HANDLE)0;
|
| - }
|
| -
|
| - if( CKR_OK != nssCKFWSession_verifyPointer(fwSession) ) {
|
| - return (CK_SESSION_HANDLE)0;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - return nssCKFWSession_GetHandle(fwSession);
|
| - /* look it up and assert? */
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_CreateObjectHandle
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_OBJECT_HANDLE
|
| -nssCKFWInstance_CreateObjectHandle
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - NSSCKFWObject *fwObject,
|
| - CK_RV *pError
|
| -)
|
| -{
|
| - CK_OBJECT_HANDLE hObject;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if (!pError) {
|
| - return (CK_OBJECT_HANDLE)0;
|
| - }
|
| -
|
| - *pError = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != *pError ) {
|
| - return (CK_OBJECT_HANDLE)0;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - *pError = nssCKFWMutex_Lock(fwInstance->mutex);
|
| - if( CKR_OK != *pError ) {
|
| - return (CK_OBJECT_HANDLE)0;
|
| - }
|
| -
|
| - hObject = ++(fwInstance->lastObjectHandle);
|
| -
|
| - *pError = nssCKFWObject_SetHandle(fwObject, hObject);
|
| - if( CKR_OK != *pError ) {
|
| - hObject = (CK_OBJECT_HANDLE)0;
|
| - goto done;
|
| - }
|
| -
|
| - *pError = nssCKFWHash_Add(fwInstance->objectHandleHash,
|
| - (const void *)hObject, (const void *)fwObject);
|
| - if( CKR_OK != *pError ) {
|
| - hObject = (CK_OBJECT_HANDLE)0;
|
| - goto done;
|
| - }
|
| -
|
| - done:
|
| - (void)nssCKFWMutex_Unlock(fwInstance->mutex);
|
| - return hObject;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_ResolveObjectHandle
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSCKFWObject *
|
| -nssCKFWInstance_ResolveObjectHandle
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_OBJECT_HANDLE hObject
|
| -)
|
| -{
|
| - NSSCKFWObject *fwObject;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return (NSSCKFWObject *)NULL;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - if( CKR_OK != nssCKFWMutex_Lock(fwInstance->mutex) ) {
|
| - return (NSSCKFWObject *)NULL;
|
| - }
|
| -
|
| - fwObject = (NSSCKFWObject *)nssCKFWHash_Lookup(
|
| - fwInstance->objectHandleHash, (const void *)hObject);
|
| -
|
| - /* Assert(hObject == nssCKFWObject_GetHandle(fwObject)) */
|
| -
|
| - (void)nssCKFWMutex_Unlock(fwInstance->mutex);
|
| - return fwObject;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_ReassignObjectHandle
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_RV
|
| -nssCKFWInstance_ReassignObjectHandle
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_OBJECT_HANDLE hObject,
|
| - NSSCKFWObject *fwObject
|
| -)
|
| -{
|
| - CK_RV error = CKR_OK;
|
| - NSSCKFWObject *oldObject;
|
| -
|
| -#ifdef NSSDEBUG
|
| - error = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != error ) {
|
| - return error;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - error = nssCKFWMutex_Lock(fwInstance->mutex);
|
| - if( CKR_OK != error ) {
|
| - return error;
|
| - }
|
| -
|
| - oldObject = (NSSCKFWObject *)nssCKFWHash_Lookup(
|
| - fwInstance->objectHandleHash, (const void *)hObject);
|
| - if(oldObject) {
|
| - /* Assert(hObject == nssCKFWObject_GetHandle(oldObject) */
|
| - (void)nssCKFWObject_SetHandle(oldObject, (CK_SESSION_HANDLE)0);
|
| - nssCKFWHash_Remove(fwInstance->objectHandleHash, (const void *)hObject);
|
| - }
|
| -
|
| - error = nssCKFWObject_SetHandle(fwObject, hObject);
|
| - if( CKR_OK != error ) {
|
| - goto done;
|
| - }
|
| - error = nssCKFWHash_Add(fwInstance->objectHandleHash,
|
| - (const void *)hObject, (const void *)fwObject);
|
| -
|
| - done:
|
| - (void)nssCKFWMutex_Unlock(fwInstance->mutex);
|
| - return error;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_DestroyObjectHandle
|
| - *
|
| - */
|
| -NSS_IMPLEMENT void
|
| -nssCKFWInstance_DestroyObjectHandle
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_OBJECT_HANDLE hObject
|
| -)
|
| -{
|
| - NSSCKFWObject *fwObject;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - if( CKR_OK != nssCKFWMutex_Lock(fwInstance->mutex) ) {
|
| - return;
|
| - }
|
| -
|
| - fwObject = (NSSCKFWObject *)nssCKFWHash_Lookup(
|
| - fwInstance->objectHandleHash, (const void *)hObject);
|
| - if (fwObject) {
|
| - /* Assert(hObject = nssCKFWObject_GetHandle(fwObject)) */
|
| - nssCKFWHash_Remove(fwInstance->objectHandleHash, (const void *)hObject);
|
| - (void)nssCKFWObject_SetHandle(fwObject, (CK_SESSION_HANDLE)0);
|
| - }
|
| -
|
| - (void)nssCKFWMutex_Unlock(fwInstance->mutex);
|
| - return;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_FindObjectHandle
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_OBJECT_HANDLE
|
| -nssCKFWInstance_FindObjectHandle
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - NSSCKFWObject *fwObject
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return (CK_OBJECT_HANDLE)0;
|
| - }
|
| -
|
| - if( CKR_OK != nssCKFWObject_verifyPointer(fwObject) ) {
|
| - return (CK_OBJECT_HANDLE)0;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - return nssCKFWObject_GetHandle(fwObject);
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetNSlots
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_ULONG
|
| -nssCKFWInstance_GetNSlots
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_RV *pError
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - if (!pError) {
|
| - return (CK_ULONG)0;
|
| - }
|
| -
|
| - *pError = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != *pError ) {
|
| - return (CK_ULONG)0;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - *pError = CKR_OK;
|
| - return fwInstance->nSlots;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetCryptokiVersion
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_VERSION
|
| -nssCKFWInstance_GetCryptokiVersion
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| - CK_VERSION rv;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - rv.major = rv.minor = 0;
|
| - return rv;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - if( CKR_OK != nssCKFWMutex_Lock(fwInstance->mutex) ) {
|
| - rv.major = rv.minor = 0;
|
| - return rv;
|
| - }
|
| -
|
| - if( (0 != fwInstance->cryptokiVersion.major) ||
|
| - (0 != fwInstance->cryptokiVersion.minor) ) {
|
| - rv = fwInstance->cryptokiVersion;
|
| - goto done;
|
| - }
|
| -
|
| - if (fwInstance->mdInstance->GetCryptokiVersion) {
|
| - fwInstance->cryptokiVersion = fwInstance->mdInstance->GetCryptokiVersion(
|
| - fwInstance->mdInstance, fwInstance);
|
| - } else {
|
| - fwInstance->cryptokiVersion.major = 2;
|
| - fwInstance->cryptokiVersion.minor = 1;
|
| - }
|
| -
|
| - rv = fwInstance->cryptokiVersion;
|
| -
|
| - done:
|
| - (void)nssCKFWMutex_Unlock(fwInstance->mutex);
|
| - return rv;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetManufacturerID
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_RV
|
| -nssCKFWInstance_GetManufacturerID
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_CHAR manufacturerID[32]
|
| -)
|
| -{
|
| - CK_RV error = CKR_OK;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if( (CK_CHAR_PTR)NULL == manufacturerID ) {
|
| - return CKR_ARGUMENTS_BAD;
|
| - }
|
| -
|
| - error = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != error ) {
|
| - return error;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - error = nssCKFWMutex_Lock(fwInstance->mutex);
|
| - if( CKR_OK != error ) {
|
| - return error;
|
| - }
|
| -
|
| - if (!fwInstance->manufacturerID) {
|
| - if (fwInstance->mdInstance->GetManufacturerID) {
|
| - fwInstance->manufacturerID = fwInstance->mdInstance->GetManufacturerID(
|
| - fwInstance->mdInstance, fwInstance, &error);
|
| - if ((!fwInstance->manufacturerID) && (CKR_OK != error)) {
|
| - goto done;
|
| - }
|
| - } else {
|
| - fwInstance->manufacturerID = (NSSUTF8 *) "";
|
| - }
|
| - }
|
| -
|
| - (void)nssUTF8_CopyIntoFixedBuffer(fwInstance->manufacturerID, (char *)manufacturerID, 32, ' ');
|
| - error = CKR_OK;
|
| -
|
| - done:
|
| - (void)nssCKFWMutex_Unlock(fwInstance->mutex);
|
| - return error;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetFlags
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_ULONG
|
| -nssCKFWInstance_GetFlags
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return (CK_ULONG)0;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - /* No "instance flags" are yet defined by Cryptoki. */
|
| - return (CK_ULONG)0;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetLibraryDescription
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_RV
|
| -nssCKFWInstance_GetLibraryDescription
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_CHAR libraryDescription[32]
|
| -)
|
| -{
|
| - CK_RV error = CKR_OK;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if( (CK_CHAR_PTR)NULL == libraryDescription ) {
|
| - return CKR_ARGUMENTS_BAD;
|
| - }
|
| -
|
| - error = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != error ) {
|
| - return error;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - error = nssCKFWMutex_Lock(fwInstance->mutex);
|
| - if( CKR_OK != error ) {
|
| - return error;
|
| - }
|
| -
|
| - if (!fwInstance->libraryDescription) {
|
| - if (fwInstance->mdInstance->GetLibraryDescription) {
|
| - fwInstance->libraryDescription = fwInstance->mdInstance->GetLibraryDescription(
|
| - fwInstance->mdInstance, fwInstance, &error);
|
| - if ((!fwInstance->libraryDescription) && (CKR_OK != error)) {
|
| - goto done;
|
| - }
|
| - } else {
|
| - fwInstance->libraryDescription = (NSSUTF8 *) "";
|
| - }
|
| - }
|
| -
|
| - (void)nssUTF8_CopyIntoFixedBuffer(fwInstance->libraryDescription, (char *)libraryDescription, 32, ' ');
|
| - error = CKR_OK;
|
| -
|
| - done:
|
| - (void)nssCKFWMutex_Unlock(fwInstance->mutex);
|
| - return error;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetLibraryVersion
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_VERSION
|
| -nssCKFWInstance_GetLibraryVersion
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| - CK_VERSION rv;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - rv.major = rv.minor = 0;
|
| - return rv;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - if( CKR_OK != nssCKFWMutex_Lock(fwInstance->mutex) ) {
|
| - rv.major = rv.minor = 0;
|
| - return rv;
|
| - }
|
| -
|
| - if( (0 != fwInstance->libraryVersion.major) ||
|
| - (0 != fwInstance->libraryVersion.minor) ) {
|
| - rv = fwInstance->libraryVersion;
|
| - goto done;
|
| - }
|
| -
|
| - if (fwInstance->mdInstance->GetLibraryVersion) {
|
| - fwInstance->libraryVersion = fwInstance->mdInstance->GetLibraryVersion(
|
| - fwInstance->mdInstance, fwInstance);
|
| - } else {
|
| - fwInstance->libraryVersion.major = 0;
|
| - fwInstance->libraryVersion.minor = 3;
|
| - }
|
| -
|
| - rv = fwInstance->libraryVersion;
|
| - done:
|
| - (void)nssCKFWMutex_Unlock(fwInstance->mutex);
|
| - return rv;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetModuleHandlesSessionObjects
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_BBOOL
|
| -nssCKFWInstance_GetModuleHandlesSessionObjects
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return CK_FALSE;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - return fwInstance->moduleHandlesSessionObjects;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_GetSlots
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSCKFWSlot **
|
| -nssCKFWInstance_GetSlots
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_RV *pError
|
| -)
|
| -{
|
| -#ifdef NSSDEBUG
|
| - if (!pError) {
|
| - return (NSSCKFWSlot **)NULL;
|
| - }
|
| -
|
| - *pError = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != *pError ) {
|
| - return (NSSCKFWSlot **)NULL;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - return fwInstance->fwSlotList;
|
| -}
|
| -
|
| -/*
|
| - * nssCKFWInstance_WaitForSlotEvent
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSCKFWSlot *
|
| -nssCKFWInstance_WaitForSlotEvent
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_BBOOL block,
|
| - CK_RV *pError
|
| -)
|
| -{
|
| - NSSCKFWSlot *fwSlot = (NSSCKFWSlot *)NULL;
|
| - NSSCKMDSlot *mdSlot;
|
| - CK_ULONG i, n;
|
| -
|
| -#ifdef NSSDEBUG
|
| - if (!pError) {
|
| - return (NSSCKFWSlot *)NULL;
|
| - }
|
| -
|
| - *pError = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != *pError ) {
|
| - return (NSSCKFWSlot *)NULL;
|
| - }
|
| -
|
| - switch( block ) {
|
| - case CK_TRUE:
|
| - case CK_FALSE:
|
| - break;
|
| - default:
|
| - *pError = CKR_ARGUMENTS_BAD;
|
| - return (NSSCKFWSlot *)NULL;
|
| - }
|
| -#endif /* NSSDEBUG */
|
| -
|
| - if (!fwInstance->mdInstance->WaitForSlotEvent) {
|
| - *pError = CKR_NO_EVENT;
|
| - return (NSSCKFWSlot *)NULL;
|
| - }
|
| -
|
| - mdSlot = fwInstance->mdInstance->WaitForSlotEvent(
|
| - fwInstance->mdInstance,
|
| - fwInstance,
|
| - block,
|
| - pError
|
| - );
|
| -
|
| - if (!mdSlot) {
|
| - return (NSSCKFWSlot *)NULL;
|
| - }
|
| -
|
| - n = nssCKFWInstance_GetNSlots(fwInstance, pError);
|
| - if( ((CK_ULONG)0 == n) && (CKR_OK != *pError) ) {
|
| - return (NSSCKFWSlot *)NULL;
|
| - }
|
| -
|
| - for( i = 0; i < n; i++ ) {
|
| - if( fwInstance->mdSlotList[i] == mdSlot ) {
|
| - fwSlot = fwInstance->fwSlotList[i];
|
| - break;
|
| - }
|
| - }
|
| -
|
| - if (!fwSlot) {
|
| - /* Internal error */
|
| - *pError = CKR_GENERAL_ERROR;
|
| - return (NSSCKFWSlot *)NULL;
|
| - }
|
| -
|
| - return fwSlot;
|
| -}
|
| -
|
| -/*
|
| - * NSSCKFWInstance_GetMDInstance
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSCKMDInstance *
|
| -NSSCKFWInstance_GetMDInstance
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| -#ifdef DEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return (NSSCKMDInstance *)NULL;
|
| - }
|
| -#endif /* DEBUG */
|
| -
|
| - return nssCKFWInstance_GetMDInstance(fwInstance);
|
| -}
|
| -
|
| -/*
|
| - * NSSCKFWInstance_GetArena
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSArena *
|
| -NSSCKFWInstance_GetArena
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - CK_RV *pError
|
| -)
|
| -{
|
| -#ifdef DEBUG
|
| - if (!pError) {
|
| - return (NSSArena *)NULL;
|
| - }
|
| -
|
| - *pError = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != *pError ) {
|
| - return (NSSArena *)NULL;
|
| - }
|
| -#endif /* DEBUG */
|
| -
|
| - return nssCKFWInstance_GetArena(fwInstance, pError);
|
| -}
|
| -
|
| -/*
|
| - * NSSCKFWInstance_MayCreatePthreads
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_BBOOL
|
| -NSSCKFWInstance_MayCreatePthreads
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| -#ifdef DEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return CK_FALSE;
|
| - }
|
| -#endif /* DEBUG */
|
| -
|
| - return nssCKFWInstance_MayCreatePthreads(fwInstance);
|
| -}
|
| -
|
| -/*
|
| - * NSSCKFWInstance_CreateMutex
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSCKFWMutex *
|
| -NSSCKFWInstance_CreateMutex
|
| -(
|
| - NSSCKFWInstance *fwInstance,
|
| - NSSArena *arena,
|
| - CK_RV *pError
|
| -)
|
| -{
|
| -#ifdef DEBUG
|
| - if (!pError) {
|
| - return (NSSCKFWMutex *)NULL;
|
| - }
|
| -
|
| - *pError = nssCKFWInstance_verifyPointer(fwInstance);
|
| - if( CKR_OK != *pError ) {
|
| - return (NSSCKFWMutex *)NULL;
|
| - }
|
| -#endif /* DEBUG */
|
| -
|
| - return nssCKFWInstance_CreateMutex(fwInstance, arena, pError);
|
| -}
|
| -
|
| -/*
|
| - * NSSCKFWInstance_GetConfigurationData
|
| - *
|
| - */
|
| -NSS_IMPLEMENT NSSUTF8 *
|
| -NSSCKFWInstance_GetConfigurationData
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| -#ifdef DEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return (NSSUTF8 *)NULL;
|
| - }
|
| -#endif /* DEBUG */
|
| -
|
| - return nssCKFWInstance_GetConfigurationData(fwInstance);
|
| -}
|
| -
|
| -/*
|
| - * NSSCKFWInstance_GetInitArgs
|
| - *
|
| - */
|
| -NSS_IMPLEMENT CK_C_INITIALIZE_ARGS_PTR
|
| -NSSCKFWInstance_GetInitArgs
|
| -(
|
| - NSSCKFWInstance *fwInstance
|
| -)
|
| -{
|
| -#ifdef DEBUG
|
| - if( CKR_OK != nssCKFWInstance_verifyPointer(fwInstance) ) {
|
| - return (CK_C_INITIALIZE_ARGS_PTR)NULL;
|
| - }
|
| -#endif /* DEBUG */
|
| -
|
| - return nssCKFWInstance_GetInitArgs(fwInstance);
|
| -}
|
| -
|
|
|