The Tor Browser: security/nss/lib/ckfw/instance.c@b8a032363ba2 (annotated)

security/nss/lib/ckfw/instance.c@b8a032363ba2 (annotated)

security/nss/lib/ckfw/instance.c

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* 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/. */
 /*
  * 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);
 }

The Tor Browser / annotate

security/nss/lib/ckfw/instance.c@b8a032363ba2 (annotated)

security/nss/lib/ckfw/instance.c