pk11util.c

Bug Summary

File:	s/lib/pk11wrap/pk11util.c
Warning:	line 375, column 18 Access to field 'internal' results in a dereference of a null pointer (loaded from field 'module')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name pk11util.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/var/lib/jenkins/workspace/nss-scan-build/nss/lib/pk11wrap -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/var/lib/jenkins/workspace/nss-scan-build/nss/lib/pk11wrap -resource-dir /usr/lib/llvm-18/lib/clang/18 -D HAVE_STRERROR -D LINUX -D linux -D XP_UNIX -D XP_UNIX -D SHLIB_SUFFIX="so" -D SHLIB_PREFIX="lib" -D NSS_SHLIB_VERSION="3" -D SOFTOKEN_SHLIB_VERSION="3" -D DEBUG -U NDEBUG -D _DEFAULT_SOURCE -D _BSD_SOURCE -D _POSIX_SOURCE -D SDB_MEASURE_USE_TEMP_DIR -D _REENTRANT -D DEBUG -U NDEBUG -D _DEFAULT_SOURCE -D _BSD_SOURCE -D _POSIX_SOURCE -D SDB_MEASURE_USE_TEMP_DIR -D _REENTRANT -D NSS_DISABLE_SSE3 -D NSS_NO_INIT_SUPPORT -D USE_UTIL_DIRECTLY -D NO_NSPR_10_SUPPORT -D SSL_DISABLE_DEPRECATED_CIPHER_SUITE_NAMES -I ../../../dist/Linux4.19_x86_64_gcc_glibc_PTH_64_DBG.OBJ/include -I ../../../dist/public/nss -I ../../../dist/private/nss -internal-isystem /usr/lib/llvm-18/lib/clang/18/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=c99 -ferror-limit 19 -fgnuc-version=4.2.1 -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-05-18-082241-28900-1 -x c pk11util.c
1/* 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/. */
4/*
* Initialize the PCKS 11 subsystem
*/
7#include "seccomon.h"
8#include "secmod.h"
9#include "nssilock.h"
10#include "secmodi.h"
11#include "secmodti.h"
12#include "pk11func.h"
13#include "pki3hack.h"
14#include "secerr.h"
15#include "dev.h"
16#include "dev3hack.h"
17#include "utilpars.h"
18#include "pkcs11uri.h"

20/* these are for displaying error messages */

22static SECMODModuleList *modules = NULL((void*)0);
23static SECMODModuleList *modulesDB = NULL((void*)0);
24static SECMODModuleList *modulesUnload = NULL((void*)0);
25static SECMODModule *internalModule = NULL((void*)0);
26static SECMODModule *defaultDBModule = NULL((void*)0);
27static SECMODModule *pendingModule = NULL((void*)0);
28static SECMODListLock *moduleLock = NULL((void*)0);

30int secmod_PrivateModuleCount = 0;

32extern const PK11DefaultArrayEntry PK11_DefaultArray[];
33extern const int num_pk11_default_mechanisms;

35void
36SECMOD_Init()
37{
  /* don't initialize twice */
  if (moduleLock)
      return;

  moduleLock = SECMOD_NewListLock();
  PK11_InitSlotLists();
44}

46SECStatus
47SECMOD_Shutdown()
48{
  /* destroy the lock */
  if (moduleLock) {
      SECMOD_DestroyListLock(moduleLock);
      moduleLock = NULL((void*)0);
  }
  /* free the internal module */
  if (internalModule) {
      SECMOD_DestroyModule(internalModule);
      internalModule = NULL((void*)0);
  }

  /* free the default database module */
  if (defaultDBModule) {
      SECMOD_DestroyModule(defaultDBModule);
      defaultDBModule = NULL((void*)0);
  }

  /* destroy the list */
  if (modules) {
      SECMOD_DestroyModuleList(modules);
      modules = NULL((void*)0);
  }

  if (modulesDB) {
      SECMOD_DestroyModuleList(modulesDB);
      modulesDB = NULL((void*)0);
  }

  if (modulesUnload) {
      SECMOD_DestroyModuleList(modulesUnload);
      modulesUnload = NULL((void*)0);
  }

  /* make all the slots and the lists go away */
  PK11_DestroySlotLists();

  nss_DumpModuleLog();

87#ifdef DEBUG1
  if (PR_GetEnvSecure("NSS_STRICT_SHUTDOWN")) {
      PORT_Assert(secmod_PrivateModuleCount == 0)((secmod_PrivateModuleCount == 0)?((void)0):PR_Assert("secmod_PrivateModuleCount == 0"
,"pk11util.c",89));
  }
91#endif
  if (secmod_PrivateModuleCount) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_BUSY);
      return SECFailure;
  }
  return SECSuccess;
97}

99PRBool
100SECMOD_GetSystemFIPSEnabled(void)
101{
  return NSS_GetSystemFIPSEnabled();
103}

105/*
* retrieve the internal module
*/
108SECMODModule *
109SECMOD_GetInternalModule(void)
110{
  return internalModule;
112}

114SECStatus
115secmod_AddModuleToList(SECMODModuleList **moduleList, SECMODModule *newModule)
116{
  SECMODModuleList *mlp, *newListElement, *last = NULL((void*)0);

  newListElement = SECMOD_NewModuleListElement();
  if (newListElement == NULL((void*)0)) {
      return SECFailure;
  }

  newListElement->module = SECMOD_ReferenceModule(newModule);

  SECMOD_GetWriteLock(moduleLock);
  /* Added it to the end (This is very inefficient, but Adding a module
   * on the fly should happen maybe 2-3 times through the life this program
   * on a given computer, and this list should be *SHORT*. */
  for (mlp = *moduleList; mlp != NULL((void*)0); mlp = mlp->next) {
      last = mlp;
  }

  if (last == NULL((void*)0)) {
      *moduleList = newListElement;
  } else {
      SECMOD_AddList(last, newListElement, NULL((void*)0));
  }
  SECMOD_ReleaseWriteLock(moduleLock);
  return SECSuccess;
141}

143SECStatus
144SECMOD_AddModuleToList(SECMODModule *newModule)
145{
  if (newModule->internal && !internalModule) {
      internalModule = SECMOD_ReferenceModule(newModule);
  }
  return secmod_AddModuleToList(&modules, newModule);
150}

152SECStatus
153SECMOD_AddModuleToDBOnlyList(SECMODModule *newModule)
154{
  if (defaultDBModule && SECMOD_GetDefaultModDBFlag(newModule)) {
      SECMOD_DestroyModule(defaultDBModule);
      defaultDBModule = SECMOD_ReferenceModule(newModule);
  } else if (defaultDBModule == NULL((void*)0)) {
      defaultDBModule = SECMOD_ReferenceModule(newModule);
  }
  return secmod_AddModuleToList(&modulesDB, newModule);
162}

164SECStatus
165SECMOD_AddModuleToUnloadList(SECMODModule *newModule)
166{
  return secmod_AddModuleToList(&modulesUnload, newModule);
168}

170/*
* get the list of PKCS11 modules that are available.
*/
173SECMODModuleList *
174SECMOD_GetDefaultModuleList()
175{
  return modules;
177}
178SECMODModuleList *
179SECMOD_GetDeadModuleList()
180{
  return modulesUnload;
182}
183SECMODModuleList *
184SECMOD_GetDBModuleList()
185{
  return modulesDB;
187}

189/*
* This lock protects the global module lists.
* it also protects changes to the slot array (module->slots[]) and slot count
* (module->slotCount) in each module. It is a read/write lock with multiple
* readers or one writer. Writes are uncommon.
* Because of legacy considerations protection of the slot array and count is
* only necessary in applications if the application calls
* SECMOD_UpdateSlotList() or SECMOD_WaitForAnyTokenEvent(), though all new
* applications are encouraged to acquire this lock when reading the
* slot array information directly.
*/
200SECMODListLock *
201SECMOD_GetDefaultModuleListLock()
202{
  return moduleLock;
204}

206/*
* find a module by name, and add a reference to it.
* return that module.
*/
210SECMODModule *
211SECMOD_FindModule(const char *name)
212{
  SECMODModuleList *mlp;
  SECMODModule *module = NULL((void*)0);

  if (!moduleLock) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return module;
  }
  SECMOD_GetReadLock(moduleLock);
  for (mlp = modules; mlp != NULL((void*)0); mlp = mlp->next) {
      if (PORT_Strcmpstrcmp(name, mlp->module->commonName) == 0) {
          module = mlp->module;
          SECMOD_ReferenceModule(module);
          break;
      }
  }
  if (module) {
      goto found;
  }
  for (mlp = modulesUnload; mlp != NULL((void*)0); mlp = mlp->next) {
      if (PORT_Strcmpstrcmp(name, mlp->module->commonName) == 0) {
          module = mlp->module;
          SECMOD_ReferenceModule(module);
          break;
      }
  }

239found:
  SECMOD_ReleaseReadLock(moduleLock);

  return module;
243}

245/*
* find a module by ID, and add a reference to it.
* return that module.
*/
249SECMODModule *
250SECMOD_FindModuleByID(SECMODModuleID id)
251{
  SECMODModuleList *mlp;
  SECMODModule *module = NULL((void*)0);

  if (!moduleLock) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return module;
  }
  SECMOD_GetReadLock(moduleLock);
  for (mlp = modules; mlp != NULL((void*)0); mlp = mlp->next) {
      if (id == mlp->module->moduleID) {
          module = mlp->module;
          SECMOD_ReferenceModule(module);
          break;
      }
  }
  SECMOD_ReleaseReadLock(moduleLock);
  if (module == NULL((void*)0)) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NO_MODULE);
  }
  return module;
272}

274/*
* find the function pointer.
*/
277SECMODModule *
278secmod_FindModuleByFuncPtr(void *funcPtr)
279{
  SECMODModuleList *mlp;
  SECMODModule *module = NULL((void*)0);

  SECMOD_GetReadLock(moduleLock);
  for (mlp = modules; mlp != NULL((void*)0); mlp = mlp->next) {
      /* paranoia, shouldn't ever happen */
      if (!mlp->module) {
          continue;
      }
      if (funcPtr == mlp->module->functionList) {
          module = mlp->module;
          SECMOD_ReferenceModule(module);
          break;
      }
  }
  SECMOD_ReleaseReadLock(moduleLock);
  if (module == NULL((void*)0)) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NO_MODULE);
  }
  return module;
300}

302/*
* Find the Slot based on ID and the module.
*/
305PK11SlotInfo *
306SECMOD_FindSlotByID(SECMODModule *module, CK_SLOT_ID slotID)
307{
  int i;
  PK11SlotInfo *slot = NULL((void*)0);

  if (!moduleLock) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return slot;
  }
  SECMOD_GetReadLock(moduleLock);
  for (i = 0; i < module->slotCount; i++) {
      PK11SlotInfo *cSlot = module->slots[i];

      if (cSlot->slotID == slotID) {
          slot = PK11_ReferenceSlot(cSlot);
          break;
      }
  }
  SECMOD_ReleaseReadLock(moduleLock);

  if (slot == NULL((void*)0)) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NO_SLOT_SELECTED);
  }
  return slot;
330}

332/*
* lookup the Slot module based on it's module ID and slot ID.
*/
335PK11SlotInfo *
336SECMOD_LookupSlot(SECMODModuleID moduleID, CK_SLOT_ID slotID)
337{
  SECMODModule *module;
  PK11SlotInfo *slot;

  module = SECMOD_FindModuleByID(moduleID);
  if (module == NULL((void*)0))
      return NULL((void*)0);

  slot = SECMOD_FindSlotByID(module, slotID);
  SECMOD_DestroyModule(module);
  return slot;
348}

350/*
* find a module by name or module pointer and delete it off the module list.
* optionally remove it from secmod.db.
*/
354SECStatus
355SECMOD_DeleteModuleEx(const char *name, SECMODModule *mod,
                    int *type, PRBool permdb)
357{
  SECMODModuleList *mlp;
  SECMODModuleList **mlpp;
  SECStatus rv = SECFailure;

  if (!moduleLock) {
2
←
Assuming 'moduleLock' is non-null→
3
←
Taking false branch→
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return rv;
  }

  *type = SECMOD_EXTERNAL0;

  SECMOD_GetWriteLock(moduleLock);
  for (mlpp = &modules, mlp = modules;
       mlp != NULL((void*)0); mlpp = &mlp->next, mlp = *mlpp) {
4
←
Assuming 'mlp' is not equal to NULL→
      if ((name && (PORT_Strcmpstrcmp(name, mlp->module->commonName) == 0)) ||
5
←
Assuming 'name' is null→
7
←
Taking true branch→
          mod == mlp->module) {
6
←
Assuming 'mod' is equal to field 'module'→
          /* don't delete the internal module */
          if (!mlp->module->internal) {
8
←
Access to field 'internal' results in a dereference of a null pointer (loaded from field 'module')
              SECMOD_RemoveList(mlpp, mlp);
              /* delete it after we release the lock */
              rv = STAN_RemoveModuleFromDefaultTrustDomain(mlp->module);
          } else if (mlp->module->isFIPS) {
              *type = SECMOD_FIPS2;
          } else {
              *type = SECMOD_INTERNAL1;
          }
          break;
      }
  }
  if (mlp) {
      goto found;
  }
  /* not on the internal list, check the unload list */
  for (mlpp = &modulesUnload, mlp = modulesUnload;
       mlp != NULL((void*)0); mlpp = &mlp->next, mlp = *mlpp) {
      if ((name && (PORT_Strcmpstrcmp(name, mlp->module->commonName) == 0)) ||
          mod == mlp->module) {
          /* don't delete the internal module */
          if (!mlp->module->internal) {
              SECMOD_RemoveList(mlpp, mlp);
              rv = SECSuccess;
          } else if (mlp->module->isFIPS) {
              *type = SECMOD_FIPS2;
          } else {
              *type = SECMOD_INTERNAL1;
          }
          break;
      }
  }
407found:
  SECMOD_ReleaseWriteLock(moduleLock);

  if (rv == SECSuccess) {
      if (permdb) {
          SECMOD_DeletePermDB(mlp->module);
      }
      SECMOD_DestroyModuleListElement(mlp);
  }
  return rv;
417}

419/*
* find a module by name and delete it off the module list
*/
422SECStatus
423SECMOD_DeleteModule(const char *name, int *type)
424{
  return SECMOD_DeleteModuleEx(name, NULL((void*)0), type, PR_TRUE1);
1
Calling 'SECMOD_DeleteModuleEx'→
426}

428/*
* find a module by name and delete it off the module list
*/
431SECStatus
432SECMOD_DeleteInternalModule(const char *name)
433{
434#ifndef NSS_FIPS_DISABLED
  SECMODModuleList *mlp;
  SECMODModuleList **mlpp;
437#endif
  SECStatus rv = SECFailure;

  if (SECMOD_GetSystemFIPSEnabled() || pendingModule) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_MODULE_STUCK);
      return rv;
  }
  if (!moduleLock) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return rv;
  }

449#ifdef NSS_FIPS_DISABLED
  PORT_SetErrorPORT_SetError_Util(PR_OPERATION_NOT_SUPPORTED_ERROR(-5965L));
  return rv;
452#else
  SECMOD_GetWriteLock(moduleLock);
  for (mlpp = &modules, mlp = modules;
       mlp != NULL((void*)0); mlpp = &mlp->next, mlp = *mlpp) {
      if (PORT_Strcmpstrcmp(name, mlp->module->commonName) == 0) {
          /* don't delete the internal module */
          if (mlp->module->internal) {
              SECMOD_RemoveList(mlpp, mlp);
              rv = STAN_RemoveModuleFromDefaultTrustDomain(mlp->module);
          }
          break;
      }
  }
  SECMOD_ReleaseWriteLock(moduleLock);

  if (rv == SECSuccess) {
      SECMODModule *newModule, *oldModule;

      if (mlp->module->isFIPS) {
          newModule = SECMOD_CreateModule(NULL((void*)0), SECMOD_INT_NAME"NSS Internal PKCS #11 Module",
                                          NULL((void*)0), SECMOD_INT_FLAGS"Flags=internal,critical" "" " slotparams=(" "1" "={" "slotFlags=[RSA,DSA,DH,RC2,RC4,DES,RANDOM,SHA1,MD5,MD2,SSL,TLS,AES,Camellia,SEED,SHA256,SHA512]"
 "})");
      } else {
          newModule = SECMOD_CreateModule(NULL((void*)0), SECMOD_FIPS_NAME"NSS Internal FIPS PKCS #11 Module",
                                          NULL((void*)0), SECMOD_FIPS_FLAGS"Flags=internal,critical" ",fips" " slotparams=(" "3" "={" "slotFlags=[RSA,DSA,DH,RC2,RC4,DES,RANDOM,SHA1,MD5,MD2,SSL,TLS,AES,Camellia,SEED,SHA256,SHA512]"
 "})");
      }
      if (newModule) {
          PK11SlotInfo *slot;
          newModule->libraryParams =
              PORT_ArenaStrdupPORT_ArenaStrdup_Util(newModule->arena, mlp->module->libraryParams);
          /* if an explicit internal key slot has been set, reset it */
          slot = pk11_SwapInternalKeySlot(NULL((void*)0));
          if (slot) {
              secmod_SetInternalKeySlotFlag(newModule, PR_TRUE1);
          }
          rv = SECMOD_AddModule(newModule);
          if (rv != SECSuccess) {
              /* load failed, restore the internal key slot */
              pk11_SetInternalKeySlot(slot);
              SECMOD_DestroyModule(newModule);
              newModule = NULL((void*)0);
          }
          /* free the old explicit internal key slot, we now have a new one */
          if (slot) {
              PK11_FreeSlot(slot);
          }
      }
      if (newModule == NULL((void*)0)) {
          SECMODModuleList *last = NULL((void*)0), *mlp2;
          /* we're in pretty deep trouble if this happens...Security
           * not going to work well... try to put the old module back on
           * the list */
          SECMOD_GetWriteLock(moduleLock);
          for (mlp2 = modules; mlp2 != NULL((void*)0); mlp2 = mlp->next) {
              last = mlp2;
          }

          if (last == NULL((void*)0)) {
              modules = mlp;
          } else {
              SECMOD_AddList(last, mlp, NULL((void*)0));
          }
          SECMOD_ReleaseWriteLock(moduleLock);
          return SECFailure;
      }
      pendingModule = oldModule = internalModule;
      internalModule = NULL((void*)0);
      SECMOD_DestroyModule(oldModule);
      SECMOD_DeletePermDB(mlp->module);
      SECMOD_DestroyModuleListElement(mlp);
      internalModule = newModule; /* adopt the module */
  }
  return rv;
524#endif
525}

527SECStatus
528SECMOD_AddModule(SECMODModule *newModule)
529{
  SECStatus rv;
  SECMODModule *oldModule;

  /* Test if a module w/ the same name already exists */
  /* and return SECWouldBlock if so. */
  /* We should probably add a new return value such as */
  /* SECDublicateModule, but to minimize ripples, I'll */
  /* give SECWouldBlock a new meaning */
  if ((oldModule = SECMOD_FindModule(newModule->commonName)) != NULL((void*)0)) {
      SECMOD_DestroyModule(oldModule);
      return SECWouldBlock;
      /* module already exists. */
  }

  rv = secmod_LoadPKCS11Module(newModule, NULL((void*)0));
  if (rv != SECSuccess) {
      return rv;
  }

  if (newModule->parent == NULL((void*)0)) {
      newModule->parent = SECMOD_ReferenceModule(defaultDBModule);
  }

  SECMOD_AddPermDB(newModule);
  SECMOD_AddModuleToList(newModule);

  rv = STAN_AddModuleToDefaultTrustDomain(newModule);

  return rv;
559}

561PK11SlotInfo *
562SECMOD_FindSlot(SECMODModule *module, const char *name)
563{
  int i;
  char *string;
  PK11SlotInfo *retSlot = NULL((void*)0);

  if (!moduleLock) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return retSlot;
  }
  SECMOD_GetReadLock(moduleLock);
  for (i = 0; i < module->slotCount; i++) {
      PK11SlotInfo *slot = module->slots[i];

      if (PK11_IsPresent(slot)) {
          string = PK11_GetTokenName(slot);
      } else {
          string = PK11_GetSlotName(slot);
      }
      if (PORT_Strcmpstrcmp(name, string) == 0) {
          retSlot = PK11_ReferenceSlot(slot);
          break;
      }
  }
  SECMOD_ReleaseReadLock(moduleLock);

  if (retSlot == NULL((void*)0)) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NO_SLOT_SELECTED);
  }
  return retSlot;
592}

594SECStatus
595PK11_GetModInfo(SECMODModule *mod, CK_INFO *info)
596{
  CK_RV crv;

  if (mod->functionList == NULL((void*)0))
      return SECFailure;
  crv = PK11_GETTAB(mod)((CK_FUNCTION_LIST_3_0_PTR)((mod)->functionList))->C_GetInfo(info);
  if (crv != CKR_OK0x00000000UL) {
      PORT_SetErrorPORT_SetError_Util(PK11_MapError(crv));
  }
  return (crv == CKR_OK0x00000000UL) ? SECSuccess : SECFailure;
606}

608char *
609PK11_GetModuleURI(SECMODModule *mod)
610{
  CK_INFO info;
  PK11URI *uri;
  char *ret = NULL((void*)0);
  PK11URIAttribute attrs[3];
  size_t nattrs = 0;
  char libraryManufacturer[32 + 1], libraryDescription[32 + 1], libraryVersion[8];

  if (PK11_GetModInfo(mod, &info) == SECFailure) {
      return NULL((void*)0);
  }

  PK11_MakeString(NULL((void*)0), libraryManufacturer, (char *)info.manufacturerID,
                  sizeof(info.manufacturerID));
  if (*libraryManufacturer != '\0') {
      attrs[nattrs].name = PK11URI_PATTR_LIBRARY_MANUFACTURER"library-manufacturer";
      attrs[nattrs].value = libraryManufacturer;
      nattrs++;
  }

  PK11_MakeString(NULL((void*)0), libraryDescription, (char *)info.libraryDescription,
                  sizeof(info.libraryDescription));
  if (*libraryDescription != '\0') {
      attrs[nattrs].name = PK11URI_PATTR_LIBRARY_DESCRIPTION"library-description";
      attrs[nattrs].value = libraryDescription;
      nattrs++;
  }

  PR_snprintf(libraryVersion, sizeof(libraryVersion), "%d.%d",
              info.libraryVersion.major, info.libraryVersion.minor);
  attrs[nattrs].name = PK11URI_PATTR_LIBRARY_VERSION"library-version";
  attrs[nattrs].value = libraryVersion;
  nattrs++;

  uri = PK11URI_CreateURI(attrs, nattrs, NULL((void*)0), 0);
  if (uri == NULL((void*)0)) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_LIBRARY_FAILURE);
      return NULL((void*)0);
  }

  ret = PK11URI_FormatURI(NULL((void*)0), uri);
  PK11URI_DestroyURI(uri);
  if (ret == NULL((void*)0)) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_LIBRARY_FAILURE);
      return NULL((void*)0);
  }

  return ret;
658}

660/* Determine if we have the FIP's module loaded as the default
* module to trigger other bogus FIPS requirements in PKCS #12 and
* SSL
*/
664PRBool
665PK11_IsFIPS(void)
666{
  SECMODModule *mod = SECMOD_GetInternalModule();

  if (mod && mod->internal) {
      return mod->isFIPS;
  }

  return PR_FALSE0;
674}

676/* combines NewModule() & AddModule */
677/* give a string for the module name & the full-path for the dll, */
678/* installs the PKCS11 module & update registry */
679SECStatus
680SECMOD_AddNewModuleEx(const char *moduleName, const char *dllPath,
                    unsigned long defaultMechanismFlags,
                    unsigned long cipherEnableFlags,
                    char *modparms, char *nssparms)
684{
  SECMODModule *module;
  SECStatus result = SECFailure;
  int s, i;
  PK11SlotInfo *slot;

  PR_SetErrorText(0, NULL((void*)0));
  if (!moduleLock) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return result;
  }

  module = SECMOD_CreateModule(dllPath, moduleName, modparms, nssparms);

  if (module == NULL((void*)0)) {
      return result;
  }

  if (module->dllName != NULL((void*)0)) {
      if (module->dllName[0] != 0) {
          result = SECMOD_AddModule(module);
          if (result == SECSuccess) {
              /* turn on SSL cipher enable flags */
              module->ssl[0] = cipherEnableFlags;

              SECMOD_GetReadLock(moduleLock);
              /* check each slot to turn on appropriate mechanisms */
              for (s = 0; s < module->slotCount; s++) {
                  slot = (module->slots)[s];
                  /* for each possible mechanism */
                  for (i = 0; i < num_pk11_default_mechanisms; i++) {
                      /* we are told to turn it on by default ? */
                      PRBool add =
                          (PK11_DefaultArray[i].flag & defaultMechanismFlags) ? PR_TRUE1 : PR_FALSE0;
                      result = PK11_UpdateSlotAttribute(slot,
                                                        &(PK11_DefaultArray[i]), add);
                      if (result != SECSuccess) {
                          SECMOD_ReleaseReadLock(moduleLock);
                          SECMOD_DestroyModule(module);
                          return result;
                      }
                  } /* for each mechanism */
                  /* disable each slot if the defaultFlags say so */
                  if (defaultMechanismFlags & PK11_DISABLE_FLAG0x40000000L) {
                      PK11_UserDisableSlot(slot);
                  }
              } /* for each slot of this module */
              SECMOD_ReleaseReadLock(moduleLock);

              /* delete and re-add module in order to save changes
               * to the module */
              result = SECMOD_UpdateModule(module);
          }
      }
  }
  SECMOD_DestroyModule(module);
  return result;
741}

743SECStatus
744SECMOD_AddNewModule(const char *moduleName, const char *dllPath,
                  unsigned long defaultMechanismFlags,
                  unsigned long cipherEnableFlags)
747{
  return SECMOD_AddNewModuleEx(moduleName, dllPath, defaultMechanismFlags,
                               cipherEnableFlags,
                               NULL((void*)0), NULL((void*)0)); /* don't pass module or nss params */
751}

753SECStatus
754SECMOD_UpdateModule(SECMODModule *module)
755{
  SECStatus result;

  result = SECMOD_DeletePermDB(module);

  if (result == SECSuccess) {
      result = SECMOD_AddPermDB(module);
  }
  return result;
764}

766/* Public & Internal(Security Library)  representation of
* encryption mechanism flags conversion */

769/* Currently, the only difference is that internal representation
* puts RANDOM_FLAG at bit 31 (Most-significant bit), but
* public representation puts this bit at bit 28
*/
773unsigned long
774SECMOD_PubMechFlagstoInternal(unsigned long publicFlags)
775{
  unsigned long internalFlags = publicFlags;

  if (publicFlags & PUBLIC_MECH_RANDOM_FLAG0x08000000ul) {
      internalFlags &= ~PUBLIC_MECH_RANDOM_FLAG0x08000000ul;
      internalFlags |= SECMOD_RANDOM_FLAG0x80000000L;
  }
  return internalFlags;
783}

785unsigned long
786SECMOD_InternaltoPubMechFlags(unsigned long internalFlags)
787{
  unsigned long publicFlags = internalFlags;

  if (internalFlags & SECMOD_RANDOM_FLAG0x80000000L) {
      publicFlags &= ~SECMOD_RANDOM_FLAG0x80000000L;
      publicFlags |= PUBLIC_MECH_RANDOM_FLAG0x08000000ul;
  }
  return publicFlags;
795}

797/* Public & Internal(Security Library)  representation of */
798/* cipher flags conversion */
799/* Note: currently they are just stubs */
800unsigned long
801SECMOD_PubCipherFlagstoInternal(unsigned long publicFlags)
802{
  return publicFlags;
804}

806unsigned long
807SECMOD_InternaltoPubCipherFlags(unsigned long internalFlags)
808{
  return internalFlags;
810}

812/* Funtion reports true if module of modType is installed/configured */
813PRBool
814SECMOD_IsModulePresent(unsigned long int pubCipherEnableFlags)
815{
  PRBool result = PR_FALSE0;
  SECMODModuleList *mods;

  if (!moduleLock) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return result;
  }
  SECMOD_GetReadLock(moduleLock);
  mods = SECMOD_GetDefaultModuleList();
  for (; mods != NULL((void*)0); mods = mods->next) {
      if (mods->module->ssl[0] &
          SECMOD_PubCipherFlagstoInternal(pubCipherEnableFlags)) {
          result = PR_TRUE1;
      }
  }

  SECMOD_ReleaseReadLock(moduleLock);
  return result;
834}

836/* create a new ModuleListElement */
837SECMODModuleList *
838SECMOD_NewModuleListElement(void)
839{
  SECMODModuleList *newModList;

  newModList = (SECMODModuleList *)PORT_AllocPORT_Alloc_Util(sizeof(SECMODModuleList));
  if (newModList) {
      newModList->next = NULL((void*)0);
      newModList->module = NULL((void*)0);
  }
  return newModList;
848}

850/*
* make a new reference to a module so It doesn't go away on us
*/
853SECMODModule *
854SECMOD_ReferenceModule(SECMODModule *module)
855{
  PZ_Lock(module->refLock)PR_Lock((module->refLock));
  PORT_Assert(module->refCount > 0)((module->refCount > 0)?((void)0):PR_Assert("module->refCount > 0"
,"pk11util.c",857));

  module->refCount++;
  PZ_Unlock(module->refLock)PR_Unlock((module->refLock));
  return module;
862}

864/* destroy an existing module */
865void
866SECMOD_DestroyModule(SECMODModule *module)
867{
  PRBool willfree = PR_FALSE0;
  int slotCount;
  int i;

  PZ_Lock(module->refLock)PR_Lock((module->refLock));
  if (module->refCount-- == 1) {
      willfree = PR_TRUE1;
  }
  PORT_Assert(willfree || (module->refCount > 0))((willfree || (module->refCount > 0))?((void)0):PR_Assert
("willfree || (module->refCount > 0)","pk11util.c",876)
);
  PZ_Unlock(module->refLock)PR_Unlock((module->refLock));

  if (!willfree) {
      return;
  }

  if (module->parent != NULL((void*)0)) {
      SECMODModule *parent = module->parent;
      /* paranoia, don't loop forever if the modules are looped */
      module->parent = NULL((void*)0);
      SECMOD_DestroyModule(parent);
  }

  /* slots can't really disappear until our module starts freeing them,
   * so this check is safe */
  slotCount = module->slotCount;
  if (slotCount == 0) {
      SECMOD_SlotDestroyModule(module, PR_FALSE0);
      return;
  }

  /* now free all out slots, when they are done, they will cause the
   * module to disappear altogether */
  for (i = 0; i < slotCount; i++) {
      if (!module->slots[i]->disabled) {
          PK11_ClearSlotList(module->slots[i]);
      }
      PK11_FreeSlot(module->slots[i]);
  }
  /* WARNING: once the last slot has been freed is it possible (even likely)
   * that module is no more... touching it now is a good way to go south */
908}

910/* we can only get here if we've destroyed the module, or some one has
* erroneously freed a slot that wasn't referenced. */
912void
913SECMOD_SlotDestroyModule(SECMODModule *module, PRBool fromSlot)
914{
  PRBool willfree = PR_FALSE0;
  if (fromSlot) {
      PORT_Assert(module->refCount == 0)((module->refCount == 0)?((void)0):PR_Assert("module->refCount == 0"
,"pk11util.c",917));
      PZ_Lock(module->refLock)PR_Lock((module->refLock));
      if (module->slotCount-- == 1) {
          willfree = PR_TRUE1;
      }
      PORT_Assert(willfree || (module->slotCount > 0))((willfree || (module->slotCount > 0))?((void)0):PR_Assert
("willfree || (module->slotCount > 0)","pk11util.c",922
));
      PZ_Unlock(module->refLock)PR_Unlock((module->refLock));
      if (!willfree)
          return;
  }

  if (module == pendingModule) {
      pendingModule = NULL((void*)0);
  }

  if (module->loaded) {
      SECMOD_UnloadModule(module);
  }
  PZ_DestroyLock(module->refLock)PR_DestroyLock((module->refLock));
  PORT_FreeArenaPORT_FreeArena_Util(module->arena, PR_FALSE0);
  secmod_PrivateModuleCount--;
938}

940/* destroy a list element
* this destroys a single element, and returns the next element
* on the chain. It makes it easy to implement for loops to delete
* the chain. It also make deleting a single element easy */
944SECMODModuleList *
945SECMOD_DestroyModuleListElement(SECMODModuleList *element)
946{
  SECMODModuleList *next = element->next;

  if (element->module) {
      SECMOD_DestroyModule(element->module);
      element->module = NULL((void*)0);
  }
  PORT_FreePORT_Free_Util(element);
  return next;
955}

957/*
* Destroy an entire module list
*/
960void
961SECMOD_DestroyModuleList(SECMODModuleList *list)
962{
  SECMODModuleList *lp;

  for (lp = list; lp != NULL((void*)0); lp = SECMOD_DestroyModuleListElement(lp))
      ;
967}

969PRBool
970SECMOD_CanDeleteInternalModule(void)
971{
972#ifdef NSS_FIPS_DISABLED
  return PR_FALSE0;
974#else
  return (PRBool)((pendingModule == NULL((void*)0)) && !SECMOD_GetSystemFIPSEnabled());
976#endif
977}

979/*
* check to see if the module has added new slots. PKCS 11 v2.20 allows for
* modules to add new slots, but never remove them. Slots cannot be added
* between a call to C_GetSlotLlist(Flag, NULL, &count) and the subsequent
* C_GetSlotList(flag, &data, &count) so that the array doesn't accidently
* grow on the caller. It is permissible for the slots to increase between
* successive calls with NULL to get the size.
*
* Caller must not hold a module list read lock.
*/
989SECStatus
990SECMOD_UpdateSlotList(SECMODModule *mod)
991{
  CK_RV crv;
  CK_ULONG count;
  CK_ULONG i, oldCount;
  PRBool freeRef = PR_FALSE0;
  void *mark = NULL((void*)0);
  CK_ULONG *slotIDs = NULL((void*)0);
  PK11SlotInfo **newSlots = NULL((void*)0);
  PK11SlotInfo **oldSlots = NULL((void*)0);

  if (!moduleLock) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return SECFailure;
  }

  /* C_GetSlotList is not a session function, make sure
   * calls are serialized */
  PZ_Lock(mod->refLock)PR_Lock((mod->refLock));
  freeRef = PR_TRUE1;
  /* see if the number of slots have changed */
  crv = PK11_GETTAB(mod)((CK_FUNCTION_LIST_3_0_PTR)((mod)->functionList))->C_GetSlotList(PR_FALSE0, NULL((void*)0), &count);
  if (crv != CKR_OK0x00000000UL) {
      PORT_SetErrorPORT_SetError_Util(PK11_MapError(crv));
      goto loser;
  }
  /* nothing new, blow out early, we want this function to be quick
   * and cheap in the normal case  */
  if (count == mod->slotCount) {
      PZ_Unlock(mod->refLock)PR_Unlock((mod->refLock));
      return SECSuccess;
  }
  if (count < (CK_ULONG)mod->slotCount) {
      /* shouldn't happen with a properly functioning PKCS #11 module */
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_INCOMPATIBLE_PKCS11);
      goto loser;
  }

  /* get the new slot list */
  slotIDs = PORT_NewArray(CK_SLOT_ID, count)(CK_SLOT_ID *)PORT_Alloc_Util(sizeof(CK_SLOT_ID) * (count));
  if (slotIDs == NULL((void*)0)) {
      goto loser;
  }

  crv = PK11_GETTAB(mod)((CK_FUNCTION_LIST_3_0_PTR)((mod)->functionList))->C_GetSlotList(PR_FALSE0, slotIDs, &count);
  if (crv != CKR_OK0x00000000UL) {
      PORT_SetErrorPORT_SetError_Util(PK11_MapError(crv));
      goto loser;
  }
  freeRef = PR_FALSE0;
  PZ_Unlock(mod->refLock)PR_Unlock((mod->refLock));
  mark = PORT_ArenaMarkPORT_ArenaMark_Util(mod->arena);
  if (mark == NULL((void*)0)) {
      goto loser;
  }
  newSlots = PORT_ArenaZNewArray(mod->arena, PK11SlotInfo *, count)(PK11SlotInfo * *)PORT_ArenaZAlloc_Util(mod->arena, sizeof
(PK11SlotInfo *) * (count));

  /* walk down the new slot ID list returned from the module. We keep
   * the old slots which match a returned ID, and we initialize the new
   * slots. */
  for (i = 0; i < count; i++) {
      PK11SlotInfo *slot = SECMOD_FindSlotByID(mod, slotIDs[i]);

      if (!slot) {
          /* we have a new slot create a new slot data structure */
          slot = PK11_NewSlotInfo(mod);
          if (!slot) {
              goto loser;
          }
          PK11_InitSlot(mod, slotIDs[i], slot);
          STAN_InitTokenForSlotInfo(NULL((void*)0), slot);
      }
      newSlots[i] = slot;
  }
  STAN_ResetTokenInterator(NULL((void*)0));
  PORT_FreePORT_Free_Util(slotIDs);
  slotIDs = NULL((void*)0);
  PORT_ArenaUnmarkPORT_ArenaUnmark_Util(mod->arena, mark);

  /* until this point we're still using the old slot list. Now we update
   * module slot list. We update the slots (array) first then the count,
   * since we've already guarrenteed that count has increased (just in case
   * someone is looking at the slots field of  module without holding the
   * moduleLock */
  SECMOD_GetWriteLock(moduleLock);
  oldCount = mod->slotCount;
  oldSlots = mod->slots;
  mod->slots = newSlots; /* typical arena 'leak'... old mod->slots is
                          * allocated out of the module arena and won't
                          * be freed until the module is freed */
  mod->slotCount = count;
  SECMOD_ReleaseWriteLock(moduleLock);
  /* free our old references before forgetting about oldSlot*/
  for (i = 0; i < oldCount; i++) {
      PK11_FreeSlot(oldSlots[i]);
  }
  return SECSuccess;

1088loser:
  if (freeRef) {
      PZ_Unlock(mod->refLock)PR_Unlock((mod->refLock));
  }
  if (slotIDs) {
      PORT_FreePORT_Free_Util(slotIDs);
  }
  /* free all the slots we allocated. newSlots are part of the
   * mod arena. NOTE: the newSlots array contain both new and old
   * slots, but we kept a reference to the old slots when we built the new
   * array, so we need to free all the slots in newSlots array. */
  if (newSlots) {
      for (i = 0; i < count; i++) {
          if (newSlots[i] == NULL((void*)0)) {
              break; /* hit the last one */
          }
          PK11_FreeSlot(newSlots[i]);
      }
  }
  /* must come after freeing newSlots */
  if (mark) {
      PORT_ArenaReleasePORT_ArenaRelease_Util(mod->arena, mark);
  }
  return SECFailure;
1112}

1114/*
* this handles modules that do not support C_WaitForSlotEvent().
* The internal flags are stored. Note that C_WaitForSlotEvent() does not
* have a timeout, so we don't have one for handleWaitForSlotEvent() either.
*/
1119PK11SlotInfo *
1120secmod_HandleWaitForSlotEvent(SECMODModule *mod, unsigned long flags,
                            PRIntervalTime latency)
1122{
  PRBool removableSlotsFound = PR_FALSE0;
  int i;
  int error = SEC_ERROR_NO_EVENT;

  if (!moduleLock) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return NULL((void*)0);
  }
  PZ_Lock(mod->refLock)PR_Lock((mod->refLock));
  if (mod->evControlMask & SECMOD_END_WAIT0x01) {
      mod->evControlMask &= ~SECMOD_END_WAIT0x01;
      PZ_Unlock(mod->refLock)PR_Unlock((mod->refLock));
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NO_EVENT);
      return NULL((void*)0);
  }
  mod->evControlMask |= SECMOD_WAIT_SIMULATED_EVENT0x02;
  while (mod->evControlMask & SECMOD_WAIT_SIMULATED_EVENT0x02) {
      PZ_Unlock(mod->refLock)PR_Unlock((mod->refLock));
      /* now is a good time to see if new slots have been added */
      SECMOD_UpdateSlotList(mod);

      /* loop through all the slots on a module */
      SECMOD_GetReadLock(moduleLock);
      for (i = 0; i < mod->slotCount; i++) {
          PK11SlotInfo *slot = mod->slots[i];
          PRUint16 series;
          PRBool present;

          /* perm modules do not change */
          if (slot->isPerm) {
              continue;
          }
          removableSlotsFound = PR_TRUE1;
          /* simulate the PKCS #11 module flags. are the flags different
           * from the last time we called? */
          series = slot->series;
          present = PK11_IsPresent(slot);
          if ((slot->flagSeries != series) || (slot->flagState != present)) {
              slot->flagState = present;
              slot->flagSeries = series;
              SECMOD_ReleaseReadLock(moduleLock);
              PZ_Lock(mod->refLock)PR_Lock((mod->refLock));
              mod->evControlMask &= ~SECMOD_END_WAIT0x01;
              PZ_Unlock(mod->refLock)PR_Unlock((mod->refLock));
              return PK11_ReferenceSlot(slot);
          }
      }
      SECMOD_ReleaseReadLock(moduleLock);
      /* if everything was perm modules, don't lock up forever */
      if ((mod->slotCount != 0) && !removableSlotsFound) {
          error = SEC_ERROR_NO_SLOT_SELECTED;
          PZ_Lock(mod->refLock)PR_Lock((mod->refLock));
          break;
      }
      if (flags & CKF_DONT_BLOCK1) {
          PZ_Lock(mod->refLock)PR_Lock((mod->refLock));
          break;
      }
      PR_Sleep(latency);
      PZ_Lock(mod->refLock)PR_Lock((mod->refLock));
  }
  mod->evControlMask &= ~SECMOD_END_WAIT0x01;
  PZ_Unlock(mod->refLock)PR_Unlock((mod->refLock));
  PORT_SetErrorPORT_SetError_Util(error);
  return NULL((void*)0);
1188}

1190/*
* this function waits for a token event on any slot of a given module
* This function should not be called from more than one thread of the
* same process (though other threads can make other library calls
* on this module while this call is blocked).
*/
1196PK11SlotInfo *
1197SECMOD_WaitForAnyTokenEvent(SECMODModule *mod, unsigned long flags,
                          PRIntervalTime latency)
1199{
  CK_SLOT_ID id;
  CK_RV crv;
  PK11SlotInfo *slot;

  if (!pk11_getFinalizeModulesOption() ||
      ((mod->cryptokiVersion.major == 2) &&
       (mod->cryptokiVersion.minor < 1))) {
      /* if we are sharing the module with other software in our
       * address space, we can't reliably use C_WaitForSlotEvent(),
       * and if the module is version 2.0, C_WaitForSlotEvent() doesn't
       * exist */
      return secmod_HandleWaitForSlotEvent(mod, flags, latency);
  }
  /* first the the PKCS #11 call */
  PZ_Lock(mod->refLock)PR_Lock((mod->refLock));
  if (mod->evControlMask & SECMOD_END_WAIT0x01) {
      goto end_wait;
  }
  mod->evControlMask |= SECMOD_WAIT_PKCS11_EVENT0x04;
  PZ_Unlock(mod->refLock)PR_Unlock((mod->refLock));
  crv = PK11_GETTAB(mod)((CK_FUNCTION_LIST_3_0_PTR)((mod)->functionList))->C_WaitForSlotEvent(flags, &id, NULL((void*)0));
  PZ_Lock(mod->refLock)PR_Lock((mod->refLock));
  mod->evControlMask &= ~SECMOD_WAIT_PKCS11_EVENT0x04;
  /* if we are in end wait, short circuit now, don't even risk
   * going into secmod_HandleWaitForSlotEvent */
  if (mod->evControlMask & SECMOD_END_WAIT0x01) {
      goto end_wait;
  }
  PZ_Unlock(mod->refLock)PR_Unlock((mod->refLock));
  if (crv == CKR_FUNCTION_NOT_SUPPORTED0x00000054UL) {
      /* module doesn't support that call, simulate it */
      return secmod_HandleWaitForSlotEvent(mod, flags, latency);
  }
  if (crv != CKR_OK0x00000000UL) {
      /* we can get this error if finalize was called while we were
       * still running. This is the only way to force a C_WaitForSlotEvent()
       * to return in PKCS #11. In this case, just return that there
       * was no event. */
      if (crv == CKR_CRYPTOKI_NOT_INITIALIZED0x00000190UL) {
          PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NO_EVENT);
      } else {
          PORT_SetErrorPORT_SetError_Util(PK11_MapError(crv));
      }
      return NULL((void*)0);
  }
  slot = SECMOD_FindSlotByID(mod, id);
  if (slot == NULL((void*)0)) {
      /* possibly a new slot that was added? */
      SECMOD_UpdateSlotList(mod);
      slot = SECMOD_FindSlotByID(mod, id);
  }
  /* if we are in the delay period for the "isPresent" call, reset
   * the delay since we know things have probably changed... */
  if (slot) {
      NSSToken *nssToken = PK11Slot_GetNSSToken(slot);
      if (nssToken) {
          if (nssToken->slot) {
              nssSlot_ResetDelay(nssToken->slot);
          }
          (void)nssToken_Destroy(nssToken);
      }
  }
  return slot;

1264/* must be called with the lock on. */
1265end_wait:
  mod->evControlMask &= ~SECMOD_END_WAIT0x01;
  PZ_Unlock(mod->refLock)PR_Unlock((mod->refLock));
  PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NO_EVENT);
  return NULL((void*)0);
1270}

1272/*
* This function "wakes up" WaitForAnyTokenEvent. It's a pretty drastic
* function, possibly bringing down the pkcs #11 module in question. This
* should be OK because 1) it does reinitialize, and 2) it should only be
* called when we are on our way to tear the whole system down anyway.
*/
1278SECStatus
1279SECMOD_CancelWait(SECMODModule *mod)
1280{
  unsigned long controlMask;
  SECStatus rv = SECSuccess;
  CK_RV crv;

  PZ_Lock(mod->refLock)PR_Lock((mod->refLock));
  mod->evControlMask |= SECMOD_END_WAIT0x01;
  controlMask = mod->evControlMask;
  if (controlMask & SECMOD_WAIT_PKCS11_EVENT0x04) {
      if (!pk11_getFinalizeModulesOption()) {
          /* can't get here unless pk11_getFinalizeModulesOption is set */
          PORT_Assert(0)((0)?((void)0):PR_Assert("0","pk11util.c",1291));
          PORT_SetErrorPORT_SetError_Util(SEC_ERROR_LIBRARY_FAILURE);
          rv = SECFailure;
          goto loser;
      }
      /* NOTE: this call will drop all transient keys, in progress
       * operations, and any authentication. This is the only documented
       * way to get WaitForSlotEvent to return. Also note: for non-thread
       * safe tokens, we need to hold the module lock, this is not yet at
       * system shutdown/startup time, so we need to protect these calls */
      crv = PK11_GETTAB(mod)((CK_FUNCTION_LIST_3_0_PTR)((mod)->functionList))->C_Finalize(NULL((void*)0));
      /* ok, we slammed the module down, now we need to reinit it in case
       * we intend to use it again */
      if (CKR_OK0x00000000UL == crv) {
          PRBool alreadyLoaded;
          secmod_ModuleInit(mod, NULL((void*)0), &alreadyLoaded);
      } else {
          /* Finalized failed for some reason,  notify the application
           * so maybe it has a prayer of recovering... */
          PORT_SetErrorPORT_SetError_Util(PK11_MapError(crv));
          rv = SECFailure;
      }
  } else if (controlMask & SECMOD_WAIT_SIMULATED_EVENT0x02) {
      mod->evControlMask &= ~SECMOD_WAIT_SIMULATED_EVENT0x02;
      /* Simulated events will eventually timeout
       * and wake up in the loop */
  }
1318loser:
  PZ_Unlock(mod->refLock)PR_Unlock((mod->refLock));
  return rv;
1321}

1323/*
* check to see if the module has removable slots that we may need to
* watch for.
*/
1327PRBool
1328SECMOD_HasRemovableSlots(SECMODModule *mod)
1329{
  PRBool ret = PR_FALSE0;
  if (!moduleLock) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return ret;
  }
  SECMOD_GetReadLock(moduleLock);
  ret = SECMOD_LockedModuleHasRemovableSlots(mod);
  SECMOD_ReleaseReadLock(moduleLock);
  return ret;
1339}

1341PRBool
1342SECMOD_LockedModuleHasRemovableSlots(SECMODModule *mod)
1343{
  int i;
  PRBool ret;
  if (mod->slotCount == 0) {
      return PR_TRUE1;
  }

  ret = PR_FALSE0;
  for (i = 0; i < mod->slotCount; i++) {
      PK11SlotInfo *slot = mod->slots[i];
      /* perm modules are not inserted or removed */
      if (slot->isPerm) {
          continue;
      }
      ret = PR_TRUE1;
      break;
  }
  return ret;
1361}

1363/*
* helper function to actually create and destroy user defined slots
*/
1366static SECStatus
1367secmod_UserDBOp(PK11SlotInfo *slot, CK_OBJECT_CLASS objClass,
              const char *sendSpec)
1369{
  CK_OBJECT_HANDLE dummy;
  CK_ATTRIBUTE template[2];
  CK_ATTRIBUTE *attrs = template;
  CK_RV crv;

  PK11_SETATTRS(attrs, CKA_CLASS, &objClass, sizeof(objClass))(attrs)->type = (0x00000000UL); (attrs)->pValue = (&
objClass); (attrs)->ulValueLen = (sizeof(objClass));;
  attrs++;
  PK11_SETATTRS(attrs, CKA_NSS_MODULE_SPEC, (unsigned char *)sendSpec,(attrs)->type = (((0x80000000UL | 0x4E534350) + 24)); (attrs
)->pValue = ((unsigned char *)sendSpec); (attrs)->ulValueLen
 = (strlen(sendSpec) + 1);
                strlen(sendSpec) + 1)(attrs)->type = (((0x80000000UL | 0x4E534350) + 24)); (attrs
)->pValue = ((unsigned char *)sendSpec); (attrs)->ulValueLen
 = (strlen(sendSpec) + 1);;
  attrs++;

  PORT_Assert(attrs - template <= 2)((attrs - template <= 2)?((void)0):PR_Assert("attrs - template <= 2"
,"pk11util.c",1381));

  PK11_EnterSlotMonitor(slot);
  crv = PK11_CreateNewObject(slot, slot->session,
                             template, attrs - template, PR_FALSE0, &dummy);
  PK11_ExitSlotMonitor(slot);

  if (crv != CKR_OK0x00000000UL) {
      PORT_SetErrorPORT_SetError_Util(PK11_MapError(crv));
      return SECFailure;
  }
  return SECMOD_UpdateSlotList(slot->module);
1393}

1395/*
* return true if the selected slot ID is not present or doesn't exist
*/
1398static PRBool
1399secmod_SlotIsEmpty(SECMODModule *mod, CK_SLOT_ID slotID)
1400{
  PK11SlotInfo *slot = SECMOD_LookupSlot(mod->moduleID, slotID);
  if (slot) {
      PRBool present = PK11_IsPresent(slot);
      PK11_FreeSlot(slot);
      if (present) {
          return PR_FALSE0;
      }
  }
  /* it doesn't exist or isn't present, it's available */
  return PR_TRUE1;
1411}

1413/*
* Find an unused slot id in module.
*/
1416static CK_SLOT_ID
1417secmod_FindFreeSlot(SECMODModule *mod)
1418{
  CK_SLOT_ID i, minSlotID, maxSlotID;

  /* look for a free slot id on the internal module */
  if (mod->internal && mod->isFIPS) {
      minSlotID = SFTK_MIN_FIPS_USER_SLOT_ID101;
      maxSlotID = SFTK_MAX_FIPS_USER_SLOT_ID127;
  } else {
      minSlotID = SFTK_MIN_USER_SLOT_ID4;
      maxSlotID = SFTK_MAX_USER_SLOT_ID100;
  }
  for (i = minSlotID; i < maxSlotID; i++) {
      if (secmod_SlotIsEmpty(mod, i)) {
          return i;
      }
  }
  PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NO_SLOT_SELECTED);
  return (CK_SLOT_ID)-1;
1436}

1438/*
* Attempt to open a new slot.
*
* This works the same os OpenUserDB except it can be called against
* any module that understands the softoken protocol for opening new
* slots, not just the softoken itself. If the selected module does not
* understand the protocol, C_CreateObject will fail with
* CKR_INVALID_ATTRIBUTE, and SECMOD_OpenNewSlot will return NULL and set
* SEC_ERROR_BAD_DATA.
*
* NewSlots can be closed with SECMOD_CloseUserDB();
*
* Modulespec is module dependent.
*/
1452PK11SlotInfo *
1453SECMOD_OpenNewSlot(SECMODModule *mod, const char *moduleSpec)
1454{
  CK_SLOT_ID slotID = 0;
  PK11SlotInfo *slot;
  char *escSpec;
  char *sendSpec;
  SECStatus rv;

  slotID = secmod_FindFreeSlot(mod);
  if (slotID == (CK_SLOT_ID)-1) {
      return NULL((void*)0);
  }

  if (mod->slotCount == 0) {
      return NULL((void*)0);
  }

  /* just grab the first slot in the module, any present slot should work */
  slot = PK11_ReferenceSlot(mod->slots[0]);
  if (slot == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* we've found the slot, now build the moduleSpec */
  escSpec = NSSUTIL_DoubleEscape(moduleSpec, '>', ']');
  if (escSpec == NULL((void*)0)) {
      PK11_FreeSlot(slot);
      return NULL((void*)0);
  }
  sendSpec = PR_smprintf("tokens=[0x%x=<%s>]", slotID, escSpec);
  PORT_FreePORT_Free_Util(escSpec);

  if (sendSpec == NULL((void*)0)) {
      /* PR_smprintf does not set SEC_ERROR_NO_MEMORY on failure. */
      PK11_FreeSlot(slot);
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NO_MEMORY);
      return NULL((void*)0);
  }
  rv = secmod_UserDBOp(slot, CKO_NSS_NEWSLOT((0x80000000UL | 0x4E534350) + 5), sendSpec);
  PR_smprintf_free(sendSpec);
  PK11_FreeSlot(slot);
  if (rv != SECSuccess) {
      return NULL((void*)0);
  }

  slot = SECMOD_FindSlotByID(mod, slotID);
  if (slot) {
      /* if we are in the delay period for the "isPresent" call, reset
       * the delay since we know things have probably changed... */
      NSSToken *nssToken = PK11Slot_GetNSSToken(slot);
      if (nssToken) {
          if (nssToken->slot) {
              nssSlot_ResetDelay(nssToken->slot);
          }
          (void)nssToken_Destroy(nssToken);
      }
      /* force the slot info structures to properly reset */
      (void)PK11_IsPresent(slot);
  }
  return slot;
1513}

1515/*
* given a module spec, find the slot in the module for it.
*/
1518PK11SlotInfo *
1519secmod_FindSlotFromModuleSpec(const char *moduleSpec, SECMODModule *module)
1520{
  CK_SLOT_ID slot_id = secmod_GetSlotIDFromModuleSpec(moduleSpec, module);
  if (slot_id == -1) {
      return NULL((void*)0);
  }

  return SECMOD_FindSlotByID(module, slot_id);
1527}

1529/*
* Open a new database using the softoken. The caller is responsible for making
* sure the module spec is correct and usable. The caller should ask for one
* new database per call if the caller wants to get meaningful information
* about the new database.
*
* moduleSpec is the same data that you would pass to softoken at
* initialization time under the 'tokens' options. For example, if you were
* to specify tokens=<0x4=[configdir='./mybackup' tokenDescription='Backup']>
* You would specify "configdir='./mybackup' tokenDescription='Backup'" as your
* module spec here. The slot ID will be calculated for you by
* SECMOD_OpenUserDB().
*
* Typical parameters here are configdir, tokenDescription and flags.
*
* a Full list is below:
*
*
*  configDir - The location of the databases for this token. If configDir is
*         not specified, and noCertDB and noKeyDB is not specified, the load
*         will fail.
*   certPrefix - Cert prefix for this token.
*   keyPrefix - Prefix for the key database for this token. (if not specified,
*         certPrefix will be used).
*   tokenDescription - The label value for this token returned in the
*         CK_TOKEN_INFO structure with an internationalize string (UTF8).
*         This value will be truncated at 32 bytes (no NULL, partial UTF8
*         characters dropped). You should specify a user friendly name here
*         as this is the value the token will be referred to in most
*         application UI's. You should make sure tokenDescription is unique.
*   slotDescription - The slotDescription value for this token returned
*         in the CK_SLOT_INFO structure with an internationalize string
*         (UTF8). This value will be truncated at 64 bytes (no NULL, partial
*         UTF8 characters dropped). This name will not change after the
*         database is closed. It should have some number to make this unique.
*   minPWLen - minimum password length for this token.
*   flags - comma separated list of flag values, parsed case-insensitive.
*         Valid flags are:
*              readOnly - Databases should be opened read only.
*              noCertDB - Don't try to open a certificate database.
*              noKeyDB - Don't try to open a key database.
*              forceOpen - Don't fail to initialize the token if the
*                databases could not be opened.
*              passwordRequired - zero length passwords are not acceptable
*                (valid only if there is a keyDB).
*              optimizeSpace - allocate smaller hash tables and lock tables.
*                When this flag is not specified, Softoken will allocate
*                large tables to prevent lock contention.
*/
1578PK11SlotInfo *
1579SECMOD_OpenUserDB(const char *moduleSpec)
1580{
  SECMODModule *mod;
  SECMODConfigList *conflist = NULL((void*)0);
  int count = 0;

  if (moduleSpec == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* NOTE: unlike most PK11 function, this does not return a reference
   * to the module */
  mod = SECMOD_GetInternalModule();
  if (!mod) {
      /* shouldn't happen */
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_LIBRARY_FAILURE);
      return NULL((void*)0);
  }

  /* make sure we don't open the same database twice. We only understand 
   * the moduleSpec for internal databases well enough to do this, so only
   * do this in OpenUserDB */
  conflist = secmod_GetConfigList(mod->isFIPS, mod->libraryParams, &count);
  if (conflist) {
      PK11SlotInfo *slot = NULL((void*)0);
      if (secmod_MatchConfigList(moduleSpec, conflist, count)) {
          slot = secmod_FindSlotFromModuleSpec(moduleSpec, mod);
      }
      secmod_FreeConfigList(conflist, count);
      if (slot) {
          return slot;
      }
  }
  return SECMOD_OpenNewSlot(mod, moduleSpec);
1613}

1615/*
* close an already opened user database. NOTE: the database must be
* in the internal token, and must be one created with SECMOD_OpenUserDB().
* Once the database is closed, the slot will remain as an empty slot
* until it's used again with SECMOD_OpenUserDB() or SECMOD_OpenNewSlot().
*/
1621SECStatus
1622SECMOD_CloseUserDB(PK11SlotInfo *slot)
1623{
  SECStatus rv;
  char *sendSpec;

  sendSpec = PR_smprintf("tokens=[0x%x=<>]", slot->slotID);
  if (sendSpec == NULL((void*)0)) {
      /* PR_smprintf does not set no memory error */
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NO_MEMORY);
      return SECFailure;
  }
  rv = secmod_UserDBOp(slot, CKO_NSS_DELSLOT((0x80000000UL | 0x4E534350) + 6), sendSpec);
  PR_smprintf_free(sendSpec);
  /* if we are in the delay period for the "isPresent" call, reset
   * the delay since we know things have probably changed... */
  NSSToken *nssToken = PK11Slot_GetNSSToken(slot);
  if (nssToken) {
      if (nssToken->slot) {
          nssSlot_ResetDelay(nssToken->slot);
      }
      (void)nssToken_Destroy(nssToken);
      /* force the slot info structures to properly reset */
      (void)PK11_IsPresent(slot);
  }
  return rv;
1647}

1649/*
* Restart PKCS #11 modules after a fork(). See secmod.h for more information.
*/
1652SECStatus
1653SECMOD_RestartModules(PRBool force)
1654{
  SECMODModuleList *mlp;
  SECStatus rrv = SECSuccess;
  int lastError = 0;

  if (!moduleLock) {
      PORT_SetErrorPORT_SetError_Util(SEC_ERROR_NOT_INITIALIZED);
      return SECFailure;
  }

  /* Only need to restart the PKCS #11 modules that were initialized */
  SECMOD_GetReadLock(moduleLock);
  for (mlp = modules; mlp != NULL((void*)0); mlp = mlp->next) {
      SECMODModule *mod = mlp->module;
      CK_ULONG count;
      SECStatus rv;
      int i;

      /* If the module needs to be reset, do so */
      if (force || (PK11_GETTAB(mod)((CK_FUNCTION_LIST_3_0_PTR)((mod)->functionList))->C_GetSlotList(CK_FALSE0, NULL((void*)0), &count) != CKR_OK0x00000000UL)) {
          PRBool alreadyLoaded;
          /* first call Finalize. This is not required by PKCS #11, but some
           * older modules require it, and it doesn't hurt (compliant modules
           * will return CKR_NOT_INITIALIZED */
          (void)PK11_GETTAB(mod)((CK_FUNCTION_LIST_3_0_PTR)((mod)->functionList))->C_Finalize(NULL((void*)0));
          /* now initialize the module, this function reinitializes
           * a module in place, preserving existing slots (even if they
           * no longer exist) */
          rv = secmod_ModuleInit(mod, NULL((void*)0), &alreadyLoaded);
          if (rv != SECSuccess) {
              /* save the last error code */
              lastError = PORT_GetErrorPORT_GetError_Util();
              rrv = rv;
              /* couldn't reinit the module, disable all its slots */
              for (i = 0; i < mod->slotCount; i++) {
                  mod->slots[i]->disabled = PR_TRUE1;
                  mod->slots[i]->reason = PK11_DIS_COULD_NOT_INIT_TOKEN;
              }
              continue;
          }
          for (i = 0; i < mod->slotCount; i++) {
              /* get new token sessions, bump the series up so that
               * we refresh other old sessions. This will tell much of
               * NSS to flush cached handles it may hold as well */
              rv = PK11_InitToken(mod->slots[i], PR_TRUE1);
              /* PK11_InitToken could fail if the slot isn't present.
               * If it is present, though, something is wrong and we should
               * disable the slot and let the caller know. */
              if (rv != SECSuccess && PK11_IsPresent(mod->slots[i])) {
                  /* save the last error code */
                  lastError = PORT_GetErrorPORT_GetError_Util();
                  rrv = rv;
                  /* disable the token */
                  mod->slots[i]->disabled = PR_TRUE1;
                  mod->slots[i]->reason = PK11_DIS_COULD_NOT_INIT_TOKEN;
              }
          }
      }
  }
  SECMOD_ReleaseReadLock(moduleLock);

  /*
   * on multiple failures, we are only returning the lastError. The caller
   * can determine which slots are bad by calling PK11_IsDisabled().
   */
  if (rrv != SECSuccess) {
      /* restore the last error code */
      PORT_SetErrorPORT_SetError_Util(lastError);
  }

  return rrv;
1725}