| 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);
 | 
| -}
 | 
| -
 | 
| 
 |