开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
wrap.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：69k
源码类别：

CA认证

开发平台：

WINDOWS

wrap.c：源码内容
  1. /* 
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. #ifdef DEBUG
  35. static const char CVS_ID[] = "@(#) $RCSfile: wrap.c,v $ $Revision: 1.3 $ $Date: 2000/09/06 22:23:57 $ $Name: NSS_3_1_1_RTM $";
  36. #endif /* DEBUG */
  38. /*
  39.  * wrap.c
  40.  *
  41.  * This file contains the routines that actually implement the cryptoki
  42.  * API, using the internal APIs of the NSS Cryptoki Framework.  There is
  43.  * one routine here for every cryptoki routine.  For linking reasons
  44.  * the actual entry points passed back with C_GetFunctionList have to
  45.  * exist in one of the Module's source files; however, those are merely
  46.  * simple wrappers that call these routines.  The intelligence of the
  47.  * implementations is here.
  48.  */
  50. #ifndef CK_T
  51. #include "ck.h"
  52. #endif /* CK_T */
  54. /*
  55.  * NSSCKFWC_Initialize
  56.  * NSSCKFWC_Finalize
  57.  * NSSCKFWC_GetInfo
  58.  * -- NSSCKFWC_GetFunctionList -- see the API insert file
  59.  * NSSCKFWC_GetSlotList
  60.  * NSSCKFWC_GetSlotInfo
  61.  * NSSCKFWC_GetTokenInfo
  62.  * NSSCKFWC_WaitForSlotEvent
  63.  * NSSCKFWC_GetMechanismList
  64.  * NSSCKFWC_GetMechanismInfo
  65.  * NSSCKFWC_InitToken
  66.  * NSSCKFWC_InitPIN
  67.  * NSSCKFWC_SetPIN
  68.  * NSSCKFWC_OpenSession
  69.  * NSSCKFWC_CloseSession
  70.  * NSSCKFWC_CloseAllSessions
  71.  * NSSCKFWC_GetSessionInfo
  72.  * NSSCKFWC_GetOperationState
  73.  * NSSCKFWC_SetOperationState
  74.  * NSSCKFWC_Login
  75.  * NSSCKFWC_Logout
  76.  * NSSCKFWC_CreateObject
  77.  * NSSCKFWC_CopyObject
  78.  * NSSCKFWC_DestroyObject
  79.  * NSSCKFWC_GetObjectSize
  80.  * NSSCKFWC_GetAttributeValue
  81.  * NSSCKFWC_SetAttributeValue
  82.  * NSSCKFWC_FindObjectsInit
  83.  * NSSCKFWC_FindObjects
  84.  * NSSCKFWC_FindObjectsFinal
  85.  * NSSCKFWC_EncryptInit
  86.  * NSSCKFWC_Encrypt
  87.  * NSSCKFWC_EncryptUpdate
  88.  * NSSCKFWC_EncryptFinal
  89.  * NSSCKFWC_DecryptInit
  90.  * NSSCKFWC_Decrypt
  91.  * NSSCKFWC_DecryptUpdate
  92.  * NSSCKFWC_DecryptFinal
  93.  * NSSCKFWC_DigestInit
  94.  * NSSCKFWC_Digest
  95.  * NSSCKFWC_DigestUpdate
  96.  * NSSCKFWC_DigestKey
  97.  * NSSCKFWC_DigestFinal
  98.  * NSSCKFWC_SignInit
  99.  * NSSCKFWC_Sign
  100.  * NSSCKFWC_SignUpdate
  101.  * NSSCKFWC_SignFinal
  102.  * NSSCKFWC_SignRecoverInit
  103.  * NSSCKFWC_SignRecover
  104.  * NSSCKFWC_VerifyInit
  105.  * NSSCKFWC_Verify
  106.  * NSSCKFWC_VerifyUpdate
  107.  * NSSCKFWC_VerifyFinal
  108.  * NSSCKFWC_VerifyRecoverInit
  109.  * NSSCKFWC_VerifyRecover
  110.  * NSSCKFWC_DigestEncryptUpdate
  111.  * NSSCKFWC_DecryptDigestUpdate
  112.  * NSSCKFWC_SignEncryptUpdate
  113.  * NSSCKFWC_DecryptVerifyUpdate
  114.  * NSSCKFWC_GenerateKey
  115.  * NSSCKFWC_GenerateKeyPair
  116.  * NSSCKFWC_WrapKey
  117.  * NSSCKFWC_UnwrapKey
  118.  * NSSCKFWC_DeriveKey
  119.  * NSSCKFWC_SeedRandom
  120.  * NSSCKFWC_GenerateRandom
  121.  * NSSCKFWC_GetFunctionStatus
  122.  * NSSCKFWC_CancelFunction
  123.  */
  125. /*
  126.  * NSSCKFWC_Initialize
  127.  *
  128.  */
  129. NSS_IMPLEMENT CK_RV
  130. NSSCKFWC_Initialize
  131. (
  132.   NSSCKFWInstance **pFwInstance,
  133.   NSSCKMDInstance *mdInstance,
  134.   CK_VOID_PTR pInitArgs
  135. )
  136. {
  137.   CK_RV error = CKR_OK;
  139.   if( (NSSCKFWInstance **)NULL == pFwInstance ) {
  140.     error = CKR_GENERAL_ERROR;
  141.     goto loser;
  142.   }
  144.   if( (NSSCKFWInstance *)NULL != *pFwInstance ) {
  145.     error = CKR_CRYPTOKI_ALREADY_INITIALIZED;
  146.     goto loser;
  147.   }
  149.   if( (NSSCKMDInstance *)NULL == mdInstance ) {
  150.     error = CKR_GENERAL_ERROR;
  151.     goto loser;
  152.   }
  154.   /* remember the locking args for those times we need to get a lock in code
  155.    * outside the framework.
  156.    */
  157.   nssSetLockArgs(pInitArgs);
  159.   *pFwInstance = nssCKFWInstance_Create(pInitArgs, mdInstance, &error);
  160.   if( (NSSCKFWInstance *)NULL == *pFwInstance ) {
  161.     goto loser;
  162.   }
  164.   return CKR_OK;
  166.  loser:
  167.   switch( error ) {
  168.   case CKR_ARGUMENTS_BAD:
  169.   case CKR_CANT_LOCK:
  170.   case CKR_CRYPTOKI_ALREADY_INITIALIZED:
  171.   case CKR_FUNCTION_FAILED:
  172.   case CKR_GENERAL_ERROR:
  173.   case CKR_HOST_MEMORY:
  174.   case CKR_NEED_TO_CREATE_THREADS:
  175.     break;
  176.   default:
  177.   case CKR_OK:
  178.     error = CKR_GENERAL_ERROR;
  179.     break;
  180.   }
  182.   return error;
  183. }
  185. /*
  186.  * NSSCKFWC_Finalize
  187.  *
  188.  */
  189. NSS_IMPLEMENT CK_RV
  190. NSSCKFWC_Finalize
  191. (
  192.   NSSCKFWInstance **pFwInstance
  193. )
  194. {
  195.   CK_RV error = CKR_OK;
  197.   if( (NSSCKFWInstance **)NULL == pFwInstance ) {
  198.     error = CKR_GENERAL_ERROR;
  199.     goto loser;
  200.   }
  202.   if( (NSSCKFWInstance *)NULL == *pFwInstance ) {
  203.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  204.     goto loser;
  205.   }
  207.   error = nssCKFWInstance_Destroy(*pFwInstance);
  209.   /* In any case */
  210.   *pFwInstance = (NSSCKFWInstance *)NULL;
  212.  loser:
  213.   switch( error ) {
  214.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  215.   case CKR_FUNCTION_FAILED:
  216.   case CKR_GENERAL_ERROR:
  217.   case CKR_HOST_MEMORY:
  218.   case CKR_OK:
  219.     break;
  220.   default:
  221.     error = CKR_GENERAL_ERROR;
  222.     break;
  223.   }
  225.   return error;
  226. }
  228. /*
  229.  * NSSCKFWC_GetInfo
  230.  *
  231.  */
  232. NSS_IMPLEMENT CK_RV
  233. NSSCKFWC_GetInfo
  234. (
  235.   NSSCKFWInstance *fwInstance,
  236.   CK_INFO_PTR pInfo
  237. )
  238. {
  239.   CK_RV error = CKR_OK;
  241.   if( (CK_INFO_PTR)CK_NULL_PTR == pInfo ) {
  242.     error = CKR_ARGUMENTS_BAD;
  243.     goto loser;
  244.   }
  246.   /*
  247.    * A purify error here means a caller error
  248.    */
  249.   (void)nsslibc_memset(pInfo, 0, sizeof(CK_INFO));
  251.   pInfo->cryptokiVersion = nssCKFWInstance_GetCryptokiVersion(fwInstance);
  253.   error = nssCKFWInstance_GetManufacturerID(fwInstance, pInfo->manufacturerID);
  254.   if( CKR_OK != error ) {
  255.     goto loser;
  256.   }
  258.   pInfo->flags = nssCKFWInstance_GetFlags(fwInstance);
  260.   error = nssCKFWInstance_GetLibraryDescription(fwInstance, pInfo->libraryDescription);
  261.   if( CKR_OK != error ) {
  262.     goto loser;
  263.   }
  265.   pInfo->libraryVersion = nssCKFWInstance_GetLibraryVersion(fwInstance);
  267.   return CKR_OK;
  269.  loser:
  270.   switch( error ) {
  271.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  272.   case CKR_FUNCTION_FAILED:
  273.   case CKR_GENERAL_ERROR:
  274.   case CKR_HOST_MEMORY:
  275.     break;
  276.   default:
  277.     error = CKR_GENERAL_ERROR;
  278.     break;
  279.   }
  281.   return error;
  282. }
  283.   
  284. /*
  285.  * C_GetFunctionList is implemented entirely in the Module's file which
  286.  * includes the Framework API insert file.  It requires no "actual"
  287.  * NSSCKFW routine.
  288.  */
  290. /*
  291.  * NSSCKFWC_GetSlotList
  292.  *
  293.  */
  294. NSS_IMPLEMENT CK_RV
  295. NSSCKFWC_GetSlotList
  296. (
  297.   NSSCKFWInstance *fwInstance,
  298.   CK_BBOOL tokenPresent,
  299.   CK_SLOT_ID_PTR pSlotList,
  300.   CK_ULONG_PTR pulCount
  301. )
  302. {
  303.   CK_RV error = CKR_OK;
  304.   CK_ULONG nSlots;
  306.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  307.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  308.     goto loser;
  309.   }
  311.   switch( tokenPresent ) {
  312.   case CK_TRUE:
  313.   case CK_FALSE:
  314.     break;
  315.   default:
  316.     error = CKR_ARGUMENTS_BAD;
  317.     goto loser;
  318.   }
  320.   if( (CK_ULONG_PTR)CK_NULL_PTR == pulCount ) {
  321.     error = CKR_ARGUMENTS_BAD;
  322.     goto loser;
  323.   }
  325.   nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
  326.   if( (CK_ULONG)0 == nSlots ) {
  327.     goto loser;
  328.   }
  330.   if( (CK_SLOT_ID_PTR)CK_NULL_PTR == pSlotList ) {
  331.     *pulCount = nSlots;
  332.     return CKR_OK;
  333.   } 
  334.     
  335.   /*
  336.    * A purify error here indicates caller error.
  337.    */
  338.   (void)nsslibc_memset(pSlotList, 0, *pulCount * sizeof(CK_SLOT_ID));
  340.   if( *pulCount < nSlots ) {
  341.     *pulCount = nSlots;
  342.     error = CKR_BUFFER_TOO_SMALL;
  343.     goto loser;
  344.   } else {
  345.     CK_ULONG i;
  346.     *pulCount = nSlots;
  347.     
  348.     /* 
  349.      * Our secret "mapping": CK_SLOT_IDs are integers [1,N], and we
  350.      * just index one when we need it.
  351.      */
  353.     for( i = 0; i < nSlots; i++ ) {
  354.       pSlotList[i] = i+1;
  355.     }
  357.     return CKR_OK;
  358.   }
  360.  loser:
  361.   switch( error ) {
  362.   case CKR_BUFFER_TOO_SMALL:
  363.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  364.   case CKR_FUNCTION_FAILED:
  365.   case CKR_GENERAL_ERROR:
  366.   case CKR_HOST_MEMORY:
  367.     break;
  368.   default:
  369.   case CKR_OK:
  370.     error = CKR_GENERAL_ERROR;
  371.     break;
  372.   }
  374.   return error;
  375. }
  376.  
  377. /*
  378.  * NSSCKFWC_GetSlotInfo
  379.  *
  380.  */
  381. NSS_IMPLEMENT CK_RV
  382. NSSCKFWC_GetSlotInfo
  383. (
  384.   NSSCKFWInstance *fwInstance,
  385.   CK_SLOT_ID slotID,
  386.   CK_SLOT_INFO_PTR pInfo
  387. )
  388. {
  389.   CK_RV error = CKR_OK;
  390.   CK_ULONG nSlots;
  391.   NSSCKFWSlot **slots;
  392.   NSSCKFWSlot *fwSlot;
  394.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  395.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  396.     goto loser;
  397.   }
  399.   nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
  400.   if( (CK_ULONG)0 == nSlots ) {
  401.     goto loser;
  402.   }
  404.   if( (slotID < 1) || (slotID > nSlots) ) {
  405.     error = CKR_SLOT_ID_INVALID;
  406.     goto loser;
  407.   }
  409.   if( (CK_SLOT_INFO_PTR)CK_NULL_PTR == pInfo ) {
  410.     error = CKR_ARGUMENTS_BAD;
  411.     goto loser;
  412.   }
  414.   /*
  415.    * A purify error here indicates caller error.
  416.    */
  417.   (void)nsslibc_memset(pInfo, 0, sizeof(CK_SLOT_INFO));
  419.   slots = nssCKFWInstance_GetSlots(fwInstance, &error);
  420.   if( (NSSCKFWSlot **)NULL == slots ) {
  421.     goto loser;
  422.   }
  424.   fwSlot = slots[ slotID-1 ];
  426.   error = nssCKFWSlot_GetSlotDescription(fwSlot, pInfo->slotDescription);
  427.   if( CKR_OK != error ) {
  428.     goto loser;
  429.   }
  431.   error = nssCKFWSlot_GetManufacturerID(fwSlot, pInfo->manufacturerID);
  432.   if( CKR_OK != error ) {
  433.     goto loser;
  434.   }
  436.   if( nssCKFWSlot_GetTokenPresent(fwSlot) ) {
  437.     pInfo->flags |= CKF_TOKEN_PRESENT;
  438.   }
  440.   if( nssCKFWSlot_GetRemovableDevice(fwSlot) ) {
  441.     pInfo->flags |= CKF_REMOVABLE_DEVICE;
  442.   }
  444.   if( nssCKFWSlot_GetHardwareSlot(fwSlot) ) {
  445.     pInfo->flags |= CKF_HW_SLOT;
  446.   }
  448.   pInfo->hardwareVersion = nssCKFWSlot_GetHardwareVersion(fwSlot);
  449.   pInfo->firmwareVersion = nssCKFWSlot_GetFirmwareVersion(fwSlot);
  451.   return CKR_OK;
  453.  loser:
  454.   switch( error ) {
  455.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  456.   case CKR_DEVICE_ERROR:
  457.   case CKR_FUNCTION_FAILED:
  458.   case CKR_GENERAL_ERROR:
  459.   case CKR_HOST_MEMORY:
  460.   case CKR_SLOT_ID_INVALID:
  461.     break;
  462.   default:
  463.   case CKR_OK:
  464.     error = CKR_GENERAL_ERROR;
  465.   }
  467.   return error;
  468. }
  470. /*
  471.  * NSSCKFWC_GetTokenInfo
  472.  *
  473.  */
  474. NSS_IMPLEMENT CK_RV
  475. NSSCKFWC_GetTokenInfo
  476. (
  477.   NSSCKFWInstance *fwInstance,
  478.   CK_SLOT_ID slotID,
  479.   CK_TOKEN_INFO_PTR pInfo
  480. )
  481. {
  482.   CK_RV error = CKR_OK;
  483.   CK_ULONG nSlots;
  484.   NSSCKFWSlot **slots;
  485.   NSSCKFWSlot *fwSlot;
  486.   NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
  488.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  489.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  490.     goto loser;
  491.   }
  493.   nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
  494.   if( (CK_ULONG)0 == nSlots ) {
  495.     goto loser;
  496.   }
  498.   if( (slotID < 1) || (slotID > nSlots) ) {
  499.     error = CKR_SLOT_ID_INVALID;
  500.     goto loser;
  501.   }
  503.   if( (CK_TOKEN_INFO_PTR)CK_NULL_PTR == pInfo ) {
  504.     error = CKR_ARGUMENTS_BAD;
  505.     goto loser;
  506.   }
  508.   /*
  509.    * A purify error here indicates caller error.
  510.    */
  511.   (void)nsslibc_memset(pInfo, 0, sizeof(CK_TOKEN_INFO));
  513.   slots = nssCKFWInstance_GetSlots(fwInstance, &error);
  514.   if( (NSSCKFWSlot **)NULL == slots ) {
  515.     goto loser;
  516.   }
  518.   fwSlot = slots[ slotID-1 ];
  520.   if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
  521.     error = CKR_TOKEN_NOT_PRESENT;
  522.     goto loser;
  523.   }
  525.   fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
  526.   if( (NSSCKFWToken *)NULL == fwToken ) {
  527.     goto loser;
  528.   }
  530.   error = nssCKFWToken_GetLabel(fwToken, pInfo->label);
  531.   if( CKR_OK != error ) {
  532.     goto loser;
  533.   }
  535.   error = nssCKFWToken_GetManufacturerID(fwToken, pInfo->manufacturerID);
  536.   if( CKR_OK != error ) {
  537.     goto loser;
  538.   }
  540.   error = nssCKFWToken_GetModel(fwToken, pInfo->model);
  541.   if( CKR_OK != error ) {
  542.     goto loser;
  543.   }
  545.   error = nssCKFWToken_GetSerialNumber(fwToken, pInfo->serialNumber);
  546.   if( CKR_OK != error ) {
  547.     goto loser;
  548.   }
  550.   if( nssCKFWToken_GetHasRNG(fwToken) ) {
  551.     pInfo->flags |= CKF_RNG;
  552.   }
  554.   if( nssCKFWToken_GetIsWriteProtected(fwToken) ) {
  555.     pInfo->flags |= CKF_WRITE_PROTECTED;
  556.   }
  558.   if( nssCKFWToken_GetLoginRequired(fwToken) ) {
  559.     pInfo->flags |= CKF_LOGIN_REQUIRED;
  560.   }
  562.   if( nssCKFWToken_GetUserPinInitialized(fwToken) ) {
  563.     pInfo->flags |= CKF_USER_PIN_INITIALIZED;
  564.   }
  566.   if( nssCKFWToken_GetRestoreKeyNotNeeded(fwToken) ) {
  567.     pInfo->flags |= CKF_RESTORE_KEY_NOT_NEEDED;
  568.   }
  570.   if( nssCKFWToken_GetHasClockOnToken(fwToken) ) {
  571.     pInfo->flags |= CKF_CLOCK_ON_TOKEN;
  572.   }
  574.   if( nssCKFWToken_GetHasProtectedAuthenticationPath(fwToken) ) {
  575.     pInfo->flags |= CKF_PROTECTED_AUTHENTICATION_PATH;
  576.   }
  578.   if( nssCKFWToken_GetSupportsDualCryptoOperations(fwToken) ) {
  579.     pInfo->flags |= CKF_DUAL_CRYPTO_OPERATIONS;
  580.   }
  582.   pInfo->ulMaxSessionCount = nssCKFWToken_GetMaxSessionCount(fwToken);
  583.   pInfo->ulSessionCount = nssCKFWToken_GetSessionCount(fwToken);
  584.   pInfo->ulMaxRwSessionCount = nssCKFWToken_GetMaxRwSessionCount(fwToken);
  585.   pInfo->ulRwSessionCount= nssCKFWToken_GetRwSessionCount(fwToken);
  586.   pInfo->ulMaxPinLen = nssCKFWToken_GetMaxPinLen(fwToken);
  587.   pInfo->ulMinPinLen = nssCKFWToken_GetMinPinLen(fwToken);
  588.   pInfo->ulTotalPublicMemory = nssCKFWToken_GetTotalPublicMemory(fwToken);
  589.   pInfo->ulFreePublicMemory = nssCKFWToken_GetFreePublicMemory(fwToken);
  590.   pInfo->ulTotalPrivateMemory = nssCKFWToken_GetTotalPrivateMemory(fwToken);
  591.   pInfo->ulFreePrivateMemory = nssCKFWToken_GetFreePrivateMemory(fwToken);
  592.   pInfo->hardwareVersion = nssCKFWToken_GetHardwareVersion(fwToken);
  593.   pInfo->firmwareVersion = nssCKFWToken_GetFirmwareVersion(fwToken);
  594.   
  595.   error = nssCKFWToken_GetUTCTime(fwToken, pInfo->utcTime);
  596.   if( CKR_OK != error ) {
  597.     goto loser;
  598.   }
  600.   return CKR_OK;
  602.  loser:
  603.   switch( error ) {
  604.   case CKR_DEVICE_REMOVED:
  605.   case CKR_TOKEN_NOT_PRESENT:
  606.     (void)nssCKFWToken_Destroy(fwToken);
  607.     break;
  608.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  609.   case CKR_DEVICE_ERROR:
  610.   case CKR_DEVICE_MEMORY:
  611.   case CKR_FUNCTION_FAILED:
  612.   case CKR_GENERAL_ERROR:
  613.   case CKR_HOST_MEMORY:
  614.   case CKR_SLOT_ID_INVALID:
  615.   case CKR_TOKEN_NOT_RECOGNIZED:
  616.     break;
  617.   default:
  618.   case CKR_OK:
  619.     error = CKR_GENERAL_ERROR;
  620.     break;
  621.   }
  623.   return error;
  624. }
  626. /*
  627.  * NSSCKFWC_WaitForSlotEvent
  628.  *
  629.  */
  630. NSS_IMPLEMENT CK_RV
  631. NSSCKFWC_WaitForSlotEvent
  632. (
  633.   NSSCKFWInstance *fwInstance,
  634.   CK_FLAGS flags,
  635.   CK_SLOT_ID_PTR pSlot,
  636.   CK_VOID_PTR pReserved
  637. )
  638. {
  639.   CK_RV error = CKR_OK;
  640.   CK_ULONG nSlots;
  641.   CK_BBOOL block;
  642.   NSSCKFWSlot **slots;
  643.   NSSCKFWSlot *fwSlot;
  644.   CK_ULONG i;
  646.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  647.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  648.     goto loser;
  649.   }
  651.   if( flags & ~CKF_DONT_BLOCK ) {
  652.     error = CKR_ARGUMENTS_BAD;
  653.     goto loser;
  654.   }
  656.   block = (flags & CKF_DONT_BLOCK) ? CK_TRUE : CK_FALSE;
  658.   nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
  659.   if( (CK_ULONG)0 == nSlots ) {
  660.     goto loser;
  661.   }
  663.   if( (CK_SLOT_ID_PTR)CK_NULL_PTR == pSlot ) {
  664.     error = CKR_ARGUMENTS_BAD;
  665.     goto loser;
  666.   }
  668.   if( (CK_VOID_PTR)CK_NULL_PTR != pReserved ) {
  669.     error = CKR_ARGUMENTS_BAD;
  670.     goto loser;
  671.   }
  673.   slots = nssCKFWInstance_GetSlots(fwInstance, &error);
  674.   if( (NSSCKFWSlot **)NULL == slots ) {
  675.     goto loser;
  676.   }
  678.   fwSlot = nssCKFWInstance_WaitForSlotEvent(fwInstance, block, &error);
  679.   if( (NSSCKFWSlot *)NULL == fwSlot ) {
  680.     goto loser;
  681.   }
  683.   for( i = 0; i < nSlots; i++ ) {
  684.     if( fwSlot == slots[i] ) {
  685.       *pSlot = (CK_SLOT_ID)(CK_ULONG)(i+1);
  686.     }
  688.     return CKR_OK;
  689.   }
  691.   error = CKR_GENERAL_ERROR; /* returned something not in the slot list */
  693.  loser:
  694.   switch( error ) {
  695.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  696.   case CKR_FUNCTION_FAILED:
  697.   case CKR_GENERAL_ERROR:
  698.   case CKR_HOST_MEMORY:
  699.   case CKR_NO_EVENT:
  700.     break;
  701.   default:
  702.   case CKR_OK:
  703.     error = CKR_GENERAL_ERROR;
  704.     break;
  705.   }
  707.   return error;
  708. }
  710. /*
  711.  * NSSCKFWC_GetMechanismList
  712.  *
  713.  */
  714. NSS_IMPLEMENT CK_RV
  715. NSSCKFWC_GetMechanismList
  716. (
  717.   NSSCKFWInstance *fwInstance,
  718.   CK_SLOT_ID slotID,
  719.   CK_MECHANISM_TYPE_PTR pMechanismList,
  720.   CK_ULONG_PTR pulCount
  721. )
  722. {
  723.   CK_RV error = CKR_OK;
  724.   CK_ULONG nSlots;
  725.   NSSCKFWSlot **slots;
  726.   NSSCKFWSlot *fwSlot;
  727.   NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
  728.   CK_ULONG count;
  730.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  731.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  732.     goto loser;
  733.   }
  735.   nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
  736.   if( (CK_ULONG)0 == nSlots ) {
  737.     goto loser;
  738.   }
  740.   if( (slotID < 1) || (slotID > nSlots) ) {
  741.     error = CKR_SLOT_ID_INVALID;
  742.     goto loser;
  743.   }
  745.   if( (CK_ULONG_PTR)CK_NULL_PTR == pulCount ) {
  746.     error = CKR_ARGUMENTS_BAD;
  747.     goto loser;
  748.   }
  750.   slots = nssCKFWInstance_GetSlots(fwInstance, &error);
  751.   if( (NSSCKFWSlot **)NULL == slots ) {
  752.     goto loser;
  753.   }
  755.   fwSlot = slots[ slotID-1 ];
  757.   if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
  758.     error = CKR_TOKEN_NOT_PRESENT;
  759.     goto loser;
  760.   }
  762.   fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
  763.   if( (NSSCKFWToken *)NULL == fwToken ) {
  764.     goto loser;
  765.   }
  767.   count = nssCKFWToken_GetMechanismCount(fwToken);
  769.   if( (CK_MECHANISM_TYPE_PTR)CK_NULL_PTR == pMechanismList ) {
  770.     *pulCount = count;
  771.     return CKR_OK;
  772.   }
  774.   if( *pulCount < count ) {
  775.     *pulCount = count;
  776.     error = CKR_BUFFER_TOO_SMALL;
  777.     goto loser;
  778.   }
  780.   /*
  781.    * A purify error here indicates caller error.
  782.    */
  783.   (void)nsslibc_memset(pMechanismList, 0, *pulCount * sizeof(CK_MECHANISM_TYPE));
  785.   *pulCount = count;
  787.   if( 0 != count ) {
  788.     error = nssCKFWToken_GetMechanismTypes(fwToken, pMechanismList);
  789.   } else {
  790.     error = CKR_OK;
  791.   }
  793.   if( CKR_OK == error ) {
  794.     return CKR_OK;
  795.   }
  797.  loser:
  798.   switch( error ) {
  799.   case CKR_DEVICE_REMOVED:
  800.   case CKR_TOKEN_NOT_PRESENT:
  801.     (void)nssCKFWToken_Destroy(fwToken);
  802.     break;
  803.   case CKR_BUFFER_TOO_SMALL:
  804.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  805.   case CKR_DEVICE_ERROR:
  806.   case CKR_DEVICE_MEMORY:
  807.   case CKR_FUNCTION_FAILED:
  808.   case CKR_GENERAL_ERROR:
  809.   case CKR_HOST_MEMORY:
  810.   case CKR_SLOT_ID_INVALID:
  811.   case CKR_TOKEN_NOT_RECOGNIZED:
  812.     break;
  813.   default:
  814.   case CKR_OK:
  815.     error = CKR_GENERAL_ERROR;
  816.     break;
  817.   }
  819.   return error;
  820. }
  822. /*
  823.  * NSSCKFWC_GetMechanismInfo
  824.  *
  825.  */
  826. NSS_IMPLEMENT CK_RV
  827. NSSCKFWC_GetMechanismInfo
  828. (
  829.   NSSCKFWInstance *fwInstance,
  830.   CK_SLOT_ID slotID,
  831.   CK_MECHANISM_TYPE type,
  832.   CK_MECHANISM_INFO_PTR pInfo
  833. )
  834. {
  835.   CK_RV error = CKR_OK;
  836.   CK_ULONG nSlots;
  837.   NSSCKFWSlot **slots;
  838.   NSSCKFWSlot *fwSlot;
  839.   NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
  840.   NSSCKFWMechanism *fwMechanism;
  842.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  843.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  844.     goto loser;
  845.   }
  847.   nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
  848.   if( (CK_ULONG)0 == nSlots ) {
  849.     goto loser;
  850.   }
  852.   if( (slotID < 1) || (slotID > nSlots) ) {
  853.     error = CKR_SLOT_ID_INVALID;
  854.     goto loser;
  855.   }
  857.   slots = nssCKFWInstance_GetSlots(fwInstance, &error);
  858.   if( (NSSCKFWSlot **)NULL == slots ) {
  859.     goto loser;
  860.   }
  862.   fwSlot = slots[ slotID-1 ];
  864.   if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
  865.     error = CKR_TOKEN_NOT_PRESENT;
  866.     goto loser;
  867.   }
  869.   if( (CK_MECHANISM_INFO_PTR)CK_NULL_PTR == pInfo ) {
  870.     error = CKR_ARGUMENTS_BAD;
  871.     goto loser;
  872.   }
  874.   /*
  875.    * A purify error here indicates caller error.
  876.    */
  877.   (void)nsslibc_memset(pInfo, 0, sizeof(CK_MECHANISM_INFO));
  879.   fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
  880.   if( (NSSCKFWToken *)NULL == fwToken ) {
  881.     goto loser;
  882.   }
  884.   fwMechanism = nssCKFWToken_GetMechanism(fwToken, type, &error);
  885.   if( (NSSCKFWMechanism *)NULL == fwMechanism ) {
  886.     goto loser;
  887.   }
  889.   pInfo->ulMinKeySize = nssCKFWMechanism_GetMinKeySize(fwMechanism);
  890.   pInfo->ulMaxKeySize = nssCKFWMechanism_GetMaxKeySize(fwMechanism);
  892.   if( nssCKFWMechanism_GetInHardware(fwMechanism) ) {
  893.     pInfo->flags |= CKF_HW;
  894.   }
  896.   /* More here... */
  898.   return CKR_OK;
  900.  loser:
  901.   switch( error ) {
  902.   case CKR_DEVICE_REMOVED:
  903.   case CKR_TOKEN_NOT_PRESENT:
  904.     (void)nssCKFWToken_Destroy(fwToken);
  905.     break;
  906.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  907.   case CKR_DEVICE_ERROR:
  908.   case CKR_DEVICE_MEMORY:
  909.   case CKR_FUNCTION_FAILED:
  910.   case CKR_GENERAL_ERROR:
  911.   case CKR_HOST_MEMORY:
  912.   case CKR_MECHANISM_INVALID:
  913.   case CKR_SLOT_ID_INVALID:
  914.   case CKR_TOKEN_NOT_RECOGNIZED:
  915.     break;
  916.   default:
  917.   case CKR_OK:
  918.     error = CKR_GENERAL_ERROR;
  919.     break;
  920.   }
  922.   return error;
  923. }
  925. /*
  926.  * NSSCKFWC_InitToken
  927.  *
  928.  */
  929. NSS_IMPLEMENT CK_RV
  930. NSSCKFWC_InitToken
  931. (
  932.   NSSCKFWInstance *fwInstance,
  933.   CK_SLOT_ID slotID,
  934.   CK_CHAR_PTR pPin,
  935.   CK_ULONG ulPinLen,
  936.   CK_CHAR_PTR pLabel
  937. )
  938. {
  939.   CK_RV error = CKR_OK;
  940.   CK_ULONG nSlots;
  941.   NSSCKFWSlot **slots;
  942.   NSSCKFWSlot *fwSlot;
  943.   NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
  944.   NSSItem pin;
  945.   NSSUTF8 *label;
  947.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  948.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  949.     goto loser;
  950.   }
  952.   nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
  953.   if( (CK_ULONG)0 == nSlots ) {
  954.     goto loser;
  955.   }
  957.   if( (slotID < 1) || (slotID > nSlots) ) {
  958.     error = CKR_SLOT_ID_INVALID;
  959.     goto loser;
  960.   }
  962.   slots = nssCKFWInstance_GetSlots(fwInstance, &error);
  963.   if( (NSSCKFWSlot **)NULL == slots ) {
  964.     goto loser;
  965.   }
  967.   fwSlot = slots[ slotID-1 ];
  969.   if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
  970.     error = CKR_TOKEN_NOT_PRESENT;
  971.     goto loser;
  972.   }
  974.   fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
  975.   if( (NSSCKFWToken *)NULL == fwToken ) {
  976.     goto loser;
  977.   }
  979.   pin.size = (PRUint32)ulPinLen;
  980.   pin.data = (void *)pPin;
  981.   label = (NSSUTF8 *)pLabel; /* identity conversion */
  983.   error = nssCKFWToken_InitToken(fwToken, &pin, label);
  984.   if( CKR_OK != error ) {
  985.     goto loser;
  986.   }
  988.   return CKR_OK;
  990.  loser:
  991.   switch( error ) {
  992.   case CKR_DEVICE_REMOVED:
  993.   case CKR_TOKEN_NOT_PRESENT:
  994.     (void)nssCKFWToken_Destroy(fwToken);
  995.     break;
  996.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  997.   case CKR_DEVICE_ERROR:
  998.   case CKR_DEVICE_MEMORY:
  999.   case CKR_FUNCTION_FAILED:
  1000.   case CKR_GENERAL_ERROR:
  1001.   case CKR_HOST_MEMORY:
  1002.   case CKR_PIN_INCORRECT:
  1003.   case CKR_PIN_LOCKED:
  1004.   case CKR_SESSION_EXISTS:
  1005.   case CKR_SLOT_ID_INVALID:
  1006.   case CKR_TOKEN_NOT_RECOGNIZED:
  1007.   case CKR_TOKEN_WRITE_PROTECTED:
  1008.     break;
  1009.   default:
  1010.   case CKR_OK:
  1011.     error = CKR_GENERAL_ERROR;
  1012.     break;
  1013.   }
  1015.   return error;
  1016. }
  1018. /*
  1019.  * NSSCKFWC_InitPIN
  1020.  *
  1021.  */
  1022. NSS_IMPLEMENT CK_RV
  1023. NSSCKFWC_InitPIN
  1024. (
  1025.   NSSCKFWInstance *fwInstance,
  1026.   CK_SESSION_HANDLE hSession,
  1027.   CK_CHAR_PTR pPin,
  1028.   CK_ULONG ulPinLen
  1029. )
  1030. {
  1031.   CK_RV error = CKR_OK;
  1032.   NSSCKFWSession *fwSession;
  1033.   NSSItem pin, *arg;
  1035.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1036.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1037.     goto loser;
  1038.   }
  1040.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  1041.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1042.     error = CKR_SESSION_HANDLE_INVALID;
  1043.     goto loser;
  1044.   }
  1046.   if( (CK_CHAR_PTR)CK_NULL_PTR == pPin ) {
  1047.     arg = (NSSItem *)NULL;
  1048.   } else {
  1049.     arg = &pin;
  1050.     pin.size = (PRUint32)ulPinLen;
  1051.     pin.data = (void *)pPin;
  1052.   }
  1054.   error = nssCKFWSession_InitPIN(fwSession, arg);
  1055.   if( CKR_OK != error ) {
  1056.     goto loser;
  1057.   }
  1059.   return CKR_OK;
  1061.  loser:
  1062.   switch( error ) {
  1063.   case CKR_SESSION_CLOSED:
  1064.     /* destroy session? */
  1065.     break;
  1066.   case CKR_DEVICE_REMOVED:
  1067.     /* (void)nssCKFWToken_Destroy(fwToken); */
  1068.     break;
  1069.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  1070.   case CKR_DEVICE_ERROR:
  1071.   case CKR_DEVICE_MEMORY:
  1072.   case CKR_FUNCTION_FAILED:
  1073.   case CKR_GENERAL_ERROR:
  1074.   case CKR_HOST_MEMORY:
  1075.   case CKR_PIN_INVALID:
  1076.   case CKR_PIN_LEN_RANGE:
  1077.   case CKR_SESSION_READ_ONLY:
  1078.   case CKR_SESSION_HANDLE_INVALID:
  1079.   case CKR_TOKEN_WRITE_PROTECTED:
  1080.   case CKR_USER_NOT_LOGGED_IN:
  1081.     break;
  1082.   default:
  1083.   case CKR_OK:
  1084.     error = CKR_GENERAL_ERROR;
  1085.     break;
  1086.   }
  1088.   return error;
  1089. }
  1091. /*
  1092.  * NSSCKFWC_SetPIN
  1093.  *
  1094.  */
  1095. NSS_IMPLEMENT CK_RV
  1096. NSSCKFWC_SetPIN
  1097. (
  1098.   NSSCKFWInstance *fwInstance,
  1099.   CK_SESSION_HANDLE hSession,
  1100.   CK_CHAR_PTR pOldPin,
  1101.   CK_ULONG ulOldLen,
  1102.   CK_CHAR_PTR pNewPin,
  1103.   CK_ULONG ulNewLen
  1104. )
  1105. {
  1106.   CK_RV error = CKR_OK;
  1107.   NSSCKFWSession *fwSession;
  1108.   NSSItem oldPin, newPin, *oldArg, *newArg;
  1110.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1111.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1112.     goto loser;
  1113.   }
  1115.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  1116.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1117.     error = CKR_SESSION_HANDLE_INVALID;
  1118.     goto loser;
  1119.   }
  1121.   if( (CK_CHAR_PTR)CK_NULL_PTR == pOldPin ) {
  1122.     oldArg = (NSSItem *)NULL;
  1123.   } else {
  1124.     oldArg = &oldPin;
  1125.     oldPin.size = (PRUint32)ulOldLen;
  1126.     oldPin.data = (void *)pOldPin;
  1127.   }
  1129.   if( (CK_CHAR_PTR)CK_NULL_PTR == pNewPin ) {
  1130.     newArg = (NSSItem *)NULL;
  1131.   } else {
  1132.     newArg = &newPin;
  1133.     newPin.size = (PRUint32)ulNewLen;
  1134.     newPin.data = (void *)pNewPin;
  1135.   }
  1137.   error = nssCKFWSession_SetPIN(fwSession, oldArg, newArg);
  1138.   if( CKR_OK != error ) {
  1139.     goto loser;
  1140.   }
  1142.   return CKR_OK;
  1144.  loser:
  1145.   switch( error ) {
  1146.   case CKR_SESSION_CLOSED:
  1147.     /* destroy session? */
  1148.     break;
  1149.   case CKR_DEVICE_REMOVED:
  1150.     /* (void)nssCKFWToken_Destroy(fwToken); */
  1151.     break;
  1152.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  1153.   case CKR_DEVICE_ERROR:
  1154.   case CKR_DEVICE_MEMORY:
  1155.   case CKR_FUNCTION_FAILED:
  1156.   case CKR_GENERAL_ERROR:
  1157.   case CKR_HOST_MEMORY:
  1158.   case CKR_PIN_INCORRECT:
  1159.   case CKR_PIN_INVALID:
  1160.   case CKR_PIN_LEN_RANGE:
  1161.   case CKR_PIN_LOCKED:
  1162.   case CKR_SESSION_HANDLE_INVALID:
  1163.   case CKR_SESSION_READ_ONLY:
  1164.   case CKR_TOKEN_WRITE_PROTECTED:
  1165.     break;
  1166.   default:
  1167.   case CKR_OK:
  1168.     error = CKR_GENERAL_ERROR;
  1169.     break;
  1170.   }
  1172.   return error;
  1173. }
  1175. /*
  1176.  * NSSCKFWC_OpenSession
  1177.  *
  1178.  */
  1179. NSS_IMPLEMENT CK_RV
  1180. NSSCKFWC_OpenSession
  1181. (
  1182.   NSSCKFWInstance *fwInstance,
  1183.   CK_SLOT_ID slotID,
  1184.   CK_FLAGS flags,
  1185.   CK_VOID_PTR pApplication,
  1186.   CK_NOTIFY Notify,
  1187.   CK_SESSION_HANDLE_PTR phSession
  1188. )
  1189. {
  1190.   CK_RV error = CKR_OK;
  1191.   CK_ULONG nSlots;
  1192.   NSSCKFWSlot **slots;
  1193.   NSSCKFWSlot *fwSlot;
  1194.   NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
  1195.   NSSCKFWSession *fwSession;
  1196.   CK_BBOOL rw;
  1198.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1199.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1200.     goto loser;
  1201.   }
  1203.   nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
  1204.   if( (CK_ULONG)0 == nSlots ) {
  1205.     goto loser;
  1206.   }
  1208.   if( (slotID < 1) || (slotID > nSlots) ) {
  1209.     error = CKR_SLOT_ID_INVALID;
  1210.     goto loser;
  1211.   }
  1213.   if( flags & CKF_RW_SESSION ) {
  1214.     rw = CK_TRUE;
  1215.   } else {
  1216.     rw = CK_FALSE;
  1217.   }
  1219.   if( flags & CKF_SERIAL_SESSION ) {
  1220.     ;
  1221.   } else {
  1222.     error = CKR_SESSION_PARALLEL_NOT_SUPPORTED;
  1223.     goto loser;
  1224.   }
  1226.   if( flags & ~(CKF_RW_SESSION|CKF_SERIAL_SESSION) ) {
  1227.     error = CKR_ARGUMENTS_BAD;
  1228.     goto loser;
  1229.   }
  1231.   if( (CK_SESSION_HANDLE_PTR)CK_NULL_PTR == phSession ) {
  1232.     error = CKR_ARGUMENTS_BAD;
  1233.     goto loser;
  1234.   }
  1236.   /*
  1237.    * A purify error here indicates caller error.
  1238.    */
  1239.   *phSession = (CK_SESSION_HANDLE)0;
  1241.   slots = nssCKFWInstance_GetSlots(fwInstance, &error);
  1242.   if( (NSSCKFWSlot **)NULL == slots ) {
  1243.     goto loser;
  1244.   }
  1246.   fwSlot = slots[ slotID-1 ];
  1248.   if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
  1249.     error = CKR_TOKEN_NOT_PRESENT;
  1250.     goto loser;
  1251.   }
  1253.   fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
  1254.   if( (NSSCKFWToken *)NULL == fwToken ) {
  1255.     goto loser;
  1256.   }
  1258.   fwSession = nssCKFWToken_OpenSession(fwToken, rw, pApplication,
  1259.                Notify, &error);
  1260.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1261.     goto loser;
  1262.   }
  1264.   *phSession = nssCKFWInstance_CreateSessionHandle(fwInstance,
  1265.                  fwSession, &error);
  1266.   if( (CK_SESSION_HANDLE)0 == *phSession ) {
  1267.     goto loser;
  1268.   }
  1270.   return CKR_OK;
  1272.  loser:
  1273.   switch( error ) {
  1274.   case CKR_SESSION_CLOSED:
  1275.     /* destroy session? */
  1276.     break;
  1277.   case CKR_DEVICE_REMOVED:
  1278.     /* (void)nssCKFWToken_Destroy(fwToken); */
  1279.     break;
  1280.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  1281.   case CKR_DEVICE_ERROR:
  1282.   case CKR_DEVICE_MEMORY:
  1283.   case CKR_FUNCTION_FAILED:
  1284.   case CKR_GENERAL_ERROR:
  1285.   case CKR_HOST_MEMORY:
  1286.   case CKR_SESSION_COUNT:
  1287.   case CKR_SESSION_EXISTS:
  1288.   case CKR_SESSION_PARALLEL_NOT_SUPPORTED:
  1289.   case CKR_SESSION_READ_WRITE_SO_EXISTS:
  1290.   case CKR_SLOT_ID_INVALID:
  1291.   case CKR_TOKEN_NOT_PRESENT:
  1292.   case CKR_TOKEN_NOT_RECOGNIZED:
  1293.   case CKR_TOKEN_WRITE_PROTECTED:
  1294.     break;
  1295.   default:
  1296.   case CKR_OK:
  1297.     error = CKR_GENERAL_ERROR;
  1298.     break;
  1299.   }
  1301.   return error;
  1302. }
  1304. /*
  1305.  * NSSCKFWC_CloseSession
  1306.  *
  1307.  */
  1308. NSS_IMPLEMENT CK_RV
  1309. NSSCKFWC_CloseSession
  1310. (
  1311.   NSSCKFWInstance *fwInstance,
  1312.   CK_SESSION_HANDLE hSession
  1313. )
  1314. {
  1315.   CK_RV error = CKR_OK;
  1316.   NSSCKFWSession *fwSession;
  1318.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1319.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1320.     goto loser;
  1321.   }
  1323.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  1324.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1325.     error = CKR_SESSION_HANDLE_INVALID;
  1326.     goto loser;
  1327.   }
  1329.   nssCKFWInstance_DestroySessionHandle(fwInstance, hSession);
  1330.   error = nssCKFWSession_Destroy(fwSession, CK_TRUE);
  1332.   if( CKR_OK != error ) {
  1333.     goto loser;
  1334.   }
  1336.   return CKR_OK;
  1338.  loser:
  1339.   switch( error ) {
  1340.   case CKR_SESSION_CLOSED:
  1341.     /* destroy session? */
  1342.     break;
  1343.   case CKR_DEVICE_REMOVED:
  1344.     /* (void)nssCKFWToken_Destroy(fwToken); */
  1345.     break;
  1346.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  1347.   case CKR_DEVICE_ERROR:
  1348.   case CKR_DEVICE_MEMORY:
  1349.   case CKR_FUNCTION_FAILED:
  1350.   case CKR_GENERAL_ERROR:
  1351.   case CKR_HOST_MEMORY:
  1352.   case CKR_SESSION_HANDLE_INVALID:
  1353.     break;
  1354.   default:
  1355.   case CKR_OK:
  1356.     error = CKR_GENERAL_ERROR;
  1357.     break;
  1358.   }
  1360.   return error;
  1361. }
  1363. /*
  1364.  * NSSCKFWC_CloseAllSessions
  1365.  *
  1366.  */
  1367. NSS_IMPLEMENT CK_RV
  1368. NSSCKFWC_CloseAllSessions
  1369. (
  1370.   NSSCKFWInstance *fwInstance,
  1371.   CK_SLOT_ID slotID
  1372. )
  1373. {
  1374.   CK_RV error = CKR_OK;
  1375.   CK_ULONG nSlots;
  1376.   NSSCKFWSlot **slots;
  1377.   NSSCKFWSlot *fwSlot;
  1378.   NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
  1380.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1381.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1382.     goto loser;
  1383.   }
  1385.   nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
  1386.   if( (CK_ULONG)0 == nSlots ) {
  1387.     goto loser;
  1388.   }
  1390.   if( (slotID < 1) || (slotID > nSlots) ) {
  1391.     error = CKR_SLOT_ID_INVALID;
  1392.     goto loser;
  1393.   }
  1395.   slots = nssCKFWInstance_GetSlots(fwInstance, &error);
  1396.   if( (NSSCKFWSlot **)NULL == slots ) {
  1397.     goto loser;
  1398.   }
  1400.   fwSlot = slots[ slotID-1 ];
  1402.   if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
  1403.     error = CKR_TOKEN_NOT_PRESENT;
  1404.     goto loser;
  1405.   }
  1407.   fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
  1408.   if( (NSSCKFWToken *)NULL == fwToken ) {
  1409.     goto loser;
  1410.   }
  1412.   error = nssCKFWToken_CloseAllSessions(fwToken);
  1413.   if( CKR_OK != error ) {
  1414.     goto loser;
  1415.   }
  1417.   return CKR_OK;
  1419.  loser:
  1420.   switch( error ) {
  1421.   case CKR_DEVICE_REMOVED:
  1422.     /* (void)nssCKFWToken_Destroy(fwToken); */
  1423.     break;
  1424.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  1425.   case CKR_DEVICE_ERROR:
  1426.   case CKR_DEVICE_MEMORY:
  1427.   case CKR_FUNCTION_FAILED:
  1428.   case CKR_GENERAL_ERROR:
  1429.   case CKR_HOST_MEMORY:
  1430.   case CKR_SLOT_ID_INVALID:
  1431.   case CKR_TOKEN_NOT_PRESENT:
  1432.     break;
  1433.   default:
  1434.   case CKR_OK:
  1435.     error = CKR_GENERAL_ERROR;
  1436.     break;
  1437.   }
  1439.   return error;
  1440. }
  1442. /*
  1443.  * NSSCKFWC_GetSessionInfo
  1444.  *
  1445.  */
  1446. NSS_IMPLEMENT CK_RV
  1447. NSSCKFWC_GetSessionInfo
  1448. (
  1449.   NSSCKFWInstance *fwInstance,
  1450.   CK_SESSION_HANDLE hSession,
  1451.   CK_SESSION_INFO_PTR pInfo
  1452. )
  1453. {
  1454.   CK_RV error = CKR_OK;
  1455.   NSSCKFWSession *fwSession;
  1456.   NSSCKFWSlot *fwSlot;
  1458.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1459.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1460.     goto loser;
  1461.   }
  1463.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  1464.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1465.     error = CKR_SESSION_HANDLE_INVALID;
  1466.     goto loser;
  1467.   }
  1469.   if( (CK_SESSION_INFO_PTR)CK_NULL_PTR == pInfo ) {
  1470.     error = CKR_ARGUMENTS_BAD;
  1471.     goto loser;
  1472.   }
  1474.   /*
  1475.    * A purify error here indicates caller error.
  1476.    */
  1477.   (void)nsslibc_memset(pInfo, 0, sizeof(CK_SESSION_INFO));
  1479.   fwSlot = nssCKFWSession_GetFWSlot(fwSession);
  1480.   if( (NSSCKFWSlot *)NULL == fwSlot ) {
  1481.     error = CKR_GENERAL_ERROR;
  1482.     goto loser;
  1483.   }
  1485.   pInfo->slotID = nssCKFWSlot_GetSlotID(fwSlot);
  1486.   pInfo->state = nssCKFWSession_GetSessionState(fwSession);
  1488.   if( CK_TRUE == nssCKFWSession_IsRWSession(fwSession) ) {
  1489.     pInfo->flags |= CKF_RW_SESSION;
  1490.   }
  1492.   pInfo->flags |= CKF_SERIAL_SESSION; /* Always true */
  1494.   pInfo->ulDeviceError = nssCKFWSession_GetDeviceError(fwSession);
  1496.   return CKR_OK;
  1498.  loser:
  1499.   switch( error ) {
  1500.   case CKR_SESSION_CLOSED:
  1501.     /* destroy session? */
  1502.     break;
  1503.   case CKR_DEVICE_REMOVED:
  1504.     /* (void)nssCKFWToken_Destroy(fwToken); */
  1505.     break;
  1506.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  1507.   case CKR_DEVICE_ERROR:
  1508.   case CKR_DEVICE_MEMORY:
  1509.   case CKR_FUNCTION_FAILED:
  1510.   case CKR_GENERAL_ERROR:
  1511.   case CKR_HOST_MEMORY:
  1512.   case CKR_SESSION_HANDLE_INVALID:
  1513.     break;
  1514.   default:
  1515.   case CKR_OK:
  1516.     error = CKR_GENERAL_ERROR;
  1517.     break;
  1518.   }
  1520.   return error;
  1521. }
  1523. /*
  1524.  * NSSCKFWC_GetOperationState
  1525.  *
  1526.  */
  1527. NSS_IMPLEMENT CK_RV
  1528. NSSCKFWC_GetOperationState
  1529. (
  1530.   NSSCKFWInstance *fwInstance,
  1531.   CK_SESSION_HANDLE hSession,
  1532.   CK_BYTE_PTR pOperationState,
  1533.   CK_ULONG_PTR pulOperationStateLen
  1534. )
  1535. {
  1536.   CK_RV error = CKR_OK;
  1537.   NSSCKFWSession *fwSession;
  1538.   CK_ULONG len;
  1539.   NSSItem buf;
  1541.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1542.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1543.     goto loser;
  1544.   }
  1546.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  1547.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1548.     error = CKR_SESSION_HANDLE_INVALID;
  1549.     goto loser;
  1550.   }
  1552.   if( (CK_ULONG_PTR)CK_NULL_PTR == pulOperationStateLen ) {
  1553.     error = CKR_ARGUMENTS_BAD;
  1554.     goto loser;
  1555.   }
  1557.   len = nssCKFWSession_GetOperationStateLen(fwSession, &error);
  1558.   if( ((CK_ULONG)0 == len) && (CKR_OK != error) ) {
  1559.     goto loser;
  1560.   }
  1562.   if( (CK_BYTE_PTR)CK_NULL_PTR == pOperationState ) {
  1563.     *pulOperationStateLen = len;
  1564.     return CKR_OK;
  1565.   }
  1567.   if( *pulOperationStateLen < len ) {
  1568.     *pulOperationStateLen = len;
  1569.     error = CKR_BUFFER_TOO_SMALL;
  1570.     goto loser;
  1571.   }
  1573.   buf.size = (PRUint32)*pulOperationStateLen;
  1574.   buf.data = (void *)pOperationState;
  1575.   *pulOperationStateLen = len;
  1576.   error = nssCKFWSession_GetOperationState(fwSession, &buf);
  1578.   if( CKR_OK != error ) {
  1579.     goto loser;
  1580.   }
  1582.   return CKR_OK;
  1584.  loser:
  1585.   switch( error ) {
  1586.   case CKR_SESSION_CLOSED:
  1587.     /* destroy session? */
  1588.     break;
  1589.   case CKR_DEVICE_REMOVED:
  1590.     /* (void)nssCKFWToken_Destroy(fwToken); */
  1591.     break;
  1592.   case CKR_BUFFER_TOO_SMALL:
  1593.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  1594.   case CKR_DEVICE_ERROR:
  1595.   case CKR_DEVICE_MEMORY:
  1596.   case CKR_FUNCTION_FAILED:
  1597.   case CKR_GENERAL_ERROR:
  1598.   case CKR_HOST_MEMORY:
  1599.   case CKR_OPERATION_NOT_INITIALIZED:
  1600.   case CKR_SESSION_HANDLE_INVALID:
  1601.   case CKR_STATE_UNSAVEABLE:
  1602.     break;
  1603.   default:
  1604.   case CKR_OK:
  1605.     error = CKR_GENERAL_ERROR;
  1606.     break;
  1607.   }
  1609.   return error;
  1610. }
  1612. /*
  1613.  * NSSCKFWC_SetOperationState
  1614.  *
  1615.  */
  1616. NSS_IMPLEMENT CK_RV
  1617. NSSCKFWC_SetOperationState
  1618. (
  1619.   NSSCKFWInstance *fwInstance,
  1620.   CK_SESSION_HANDLE hSession,
  1621.   CK_BYTE_PTR pOperationState,
  1622.   CK_ULONG ulOperationStateLen,
  1623.   CK_OBJECT_HANDLE hEncryptionKey,
  1624.   CK_OBJECT_HANDLE hAuthenticationKey
  1625. )
  1626. {
  1627.   CK_RV error = CKR_OK;
  1628.   NSSCKFWSession *fwSession;
  1629.   NSSCKFWObject *eKey;
  1630.   NSSCKFWObject *aKey;
  1631.   NSSItem state;
  1633.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1634.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1635.     goto loser;
  1636.   }
  1637.   
  1638.   if( (CK_BYTE_PTR)CK_NULL_PTR == pOperationState ) {
  1639.     error = CKR_ARGUMENTS_BAD;
  1640.     goto loser;
  1641.   }
  1643.   /* 
  1644.    * We could loop through the buffer, to catch any purify errors
  1645.    * in a place with a "user error" note.
  1646.    */
  1648.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  1649.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1650.     error = CKR_SESSION_HANDLE_INVALID;
  1651.     goto loser;
  1652.   }
  1654.   if( (CK_OBJECT_HANDLE)0 == hEncryptionKey ) {
  1655.     eKey = (NSSCKFWObject *)NULL;
  1656.   } else {
  1657.     eKey = nssCKFWInstance_ResolveObjectHandle(fwInstance, hEncryptionKey);
  1658.     if( (NSSCKFWObject *)NULL == eKey ) {
  1659.       error = CKR_KEY_HANDLE_INVALID;
  1660.       goto loser;
  1661.     }
  1662.   }
  1664.   if( (CK_OBJECT_HANDLE)0 == hAuthenticationKey ) {
  1665.     aKey = (NSSCKFWObject *)NULL;
  1666.   } else {
  1667.     aKey = nssCKFWInstance_ResolveObjectHandle(fwInstance, hAuthenticationKey);
  1668.     if( (NSSCKFWObject *)NULL == aKey ) {
  1669.       error = CKR_KEY_HANDLE_INVALID;
  1670.       goto loser;
  1671.     }
  1672.   }
  1674.   error = nssCKFWSession_SetOperationState(fwSession, &state, eKey, aKey);
  1675.   if( CKR_OK != error ) {
  1676.     goto loser;
  1677.   }
  1679.   return CKR_OK;
  1681.  loser:
  1682.   switch( error ) {
  1683.   case CKR_SESSION_CLOSED:
  1684.     /* destroy session? */
  1685.     break;
  1686.   case CKR_DEVICE_REMOVED:
  1687.     /* (void)nssCKFWToken_Destroy(fwToken); */
  1688.     break;
  1689.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  1690.   case CKR_DEVICE_ERROR:
  1691.   case CKR_DEVICE_MEMORY:
  1692.   case CKR_FUNCTION_FAILED:
  1693.   case CKR_GENERAL_ERROR:
  1694.   case CKR_HOST_MEMORY:
  1695.   case CKR_KEY_CHANGED:
  1696.   case CKR_KEY_NEEDED:
  1697.   case CKR_KEY_NOT_NEEDED:
  1698.   case CKR_SAVED_STATE_INVALID:
  1699.   case CKR_SESSION_HANDLE_INVALID:
  1700.     break;
  1701.   default:
  1702.   case CKR_OK:
  1703.     error = CKR_GENERAL_ERROR;
  1704.     break;
  1705.   }
  1707.   return error;
  1708. }
  1710. /*
  1711.  * NSSCKFWC_Login
  1712.  *
  1713.  */
  1714. NSS_IMPLEMENT CK_RV
  1715. NSSCKFWC_Login
  1716. (
  1717.   NSSCKFWInstance *fwInstance,
  1718.   CK_SESSION_HANDLE hSession,
  1719.   CK_USER_TYPE userType,
  1720.   CK_CHAR_PTR pPin,
  1721.   CK_ULONG ulPinLen
  1722. )
  1723. {
  1724.   CK_RV error = CKR_OK;
  1725.   NSSCKFWSession *fwSession;
  1726.   NSSItem pin, *arg;
  1728.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1729.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1730.     goto loser;
  1731.   }
  1732.   
  1733.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  1734.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1735.     error = CKR_SESSION_HANDLE_INVALID;
  1736.     goto loser;
  1737.   }
  1739.   if( (CK_CHAR_PTR)CK_NULL_PTR == pPin ) {
  1740.     arg = (NSSItem *)NULL;
  1741.   } else {
  1742.     arg = &pin;
  1743.     pin.size = (PRUint32)ulPinLen;
  1744.     pin.data = (void *)pPin;
  1745.   }
  1747.   error = nssCKFWSession_Login(fwSession, userType, arg);
  1748.   if( CKR_OK != error ) {
  1749.     goto loser;
  1750.   }
  1752.   return CKR_OK;
  1754.  loser:
  1755.   switch( error ) {
  1756.   case CKR_SESSION_CLOSED:
  1757.     /* destroy session? */
  1758.     break;
  1759.   case CKR_DEVICE_REMOVED:
  1760.     /* (void)nssCKFWToken_Destroy(fwToken); */
  1761.     break;
  1762.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  1763.   case CKR_DEVICE_ERROR:
  1764.   case CKR_DEVICE_MEMORY:
  1765.   case CKR_FUNCTION_FAILED:
  1766.   case CKR_GENERAL_ERROR:
  1767.   case CKR_HOST_MEMORY:
  1768.   case CKR_PIN_EXPIRED:
  1769.   case CKR_PIN_INCORRECT:
  1770.   case CKR_PIN_LOCKED:
  1771.   case CKR_SESSION_HANDLE_INVALID:
  1772.   case CKR_SESSION_READ_ONLY_EXISTS:
  1773.   case CKR_USER_ALREADY_LOGGED_IN:
  1774.   case CKR_USER_ANOTHER_ALREADY_LOGGED_IN:
  1775.   case CKR_USER_PIN_NOT_INITIALIZED:
  1776.   case CKR_USER_TOO_MANY_TYPES:
  1777.   case CKR_USER_TYPE_INVALID:
  1778.     break;
  1779.   default:
  1780.   case CKR_OK:
  1781.     error = CKR_GENERAL_ERROR;
  1782.     break;
  1783.   }
  1785.   return error;
  1786. }
  1788. /*
  1789.  * NSSCKFWC_Logout
  1790.  *
  1791.  */
  1792. NSS_IMPLEMENT CK_RV
  1793. NSSCKFWC_Logout
  1794. (
  1795.   NSSCKFWInstance *fwInstance,
  1796.   CK_SESSION_HANDLE hSession
  1797. )
  1798. {
  1799.   CK_RV error = CKR_OK;
  1800.   NSSCKFWSession *fwSession;
  1802.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1803.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1804.     goto loser;
  1805.   }
  1806.   
  1807.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  1808.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1809.     error = CKR_SESSION_HANDLE_INVALID;
  1810.     goto loser;
  1811.   }
  1813.   error = nssCKFWSession_Logout(fwSession);
  1814.   if( CKR_OK != error ) {
  1815.     goto loser;
  1816.   }
  1818.   return CKR_OK;
  1820.  loser:
  1821.   switch( error ) {
  1822.   case CKR_SESSION_CLOSED:
  1823.     /* destroy session? */
  1824.     break;
  1825.   case CKR_DEVICE_REMOVED:
  1826.     /* (void)nssCKFWToken_Destroy(fwToken); */
  1827.     break;
  1828.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  1829.   case CKR_DEVICE_ERROR:
  1830.   case CKR_DEVICE_MEMORY:
  1831.   case CKR_FUNCTION_FAILED:
  1832.   case CKR_GENERAL_ERROR:
  1833.   case CKR_HOST_MEMORY:
  1834.   case CKR_SESSION_HANDLE_INVALID:
  1835.   case CKR_USER_NOT_LOGGED_IN:
  1836.     break;
  1837.   default:
  1838.   case CKR_OK:
  1839.     error = CKR_GENERAL_ERROR;
  1840.     break;
  1841.   }
  1843.   return error;
  1844. }
  1846. /*
  1847.  * NSSCKFWC_CreateObject
  1848.  *
  1849.  */
  1850. NSS_IMPLEMENT CK_RV
  1851. NSSCKFWC_CreateObject
  1852. (
  1853.   NSSCKFWInstance *fwInstance,
  1854.   CK_SESSION_HANDLE hSession,
  1855.   CK_ATTRIBUTE_PTR pTemplate,
  1856.   CK_ULONG ulCount,
  1857.   CK_OBJECT_HANDLE_PTR phObject
  1858. )
  1859. {
  1860.   CK_RV error = CKR_OK;
  1861.   NSSCKFWSession *fwSession;
  1862.   NSSCKFWObject *fwObject;
  1864.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1865.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1866.     goto loser;
  1867.   }
  1868.   
  1869.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  1870.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1871.     error = CKR_SESSION_HANDLE_INVALID;
  1872.     goto loser;
  1873.   }
  1875.   if( (CK_OBJECT_HANDLE_PTR)CK_NULL_PTR == phObject ) {
  1876.     error = CKR_ARGUMENTS_BAD;
  1877.     goto loser;
  1878.   }
  1880.   /*
  1881.    * A purify error here indicates caller error.
  1882.    */
  1883.   *phObject = (CK_OBJECT_HANDLE)0;
  1885.   fwObject = nssCKFWSession_CreateObject(fwSession, pTemplate,
  1886.                ulCount, &error);
  1887.   if( (NSSCKFWObject *)NULL == fwObject ) {
  1888.     goto loser;
  1889.   }
  1891.   *phObject = nssCKFWInstance_CreateObjectHandle(fwInstance, fwObject, &error);
  1892.   if( (CK_OBJECT_HANDLE)0 == *phObject ) {
  1893.     nssCKFWObject_Destroy(fwObject);
  1894.     goto loser;
  1895.   }
  1897.   return CKR_OK;
  1899.  loser:
  1900.   switch( error ) {
  1901.   case CKR_SESSION_CLOSED:
  1902.     /* destroy session? */
  1903.     break;
  1904.   case CKR_DEVICE_REMOVED:
  1905.     /* (void)nssCKFWToken_Destroy(fwToken); */
  1906.     break;
  1907.   case CKR_ATTRIBUTE_READ_ONLY:
  1908.   case CKR_ATTRIBUTE_TYPE_INVALID:
  1909.   case CKR_ATTRIBUTE_VALUE_INVALID:
  1910.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  1911.   case CKR_DEVICE_ERROR:
  1912.   case CKR_DEVICE_MEMORY:
  1913.   case CKR_FUNCTION_FAILED:
  1914.   case CKR_GENERAL_ERROR:
  1915.   case CKR_HOST_MEMORY:
  1916.   case CKR_SESSION_HANDLE_INVALID:
  1917.   case CKR_SESSION_READ_ONLY:
  1918.   case CKR_TEMPLATE_INCOMPLETE:
  1919.   case CKR_TEMPLATE_INCONSISTENT:
  1920.   case CKR_TOKEN_WRITE_PROTECTED:
  1921.   case CKR_USER_NOT_LOGGED_IN:
  1922.     break;
  1923.   default:
  1924.   case CKR_OK:
  1925.     error = CKR_GENERAL_ERROR;
  1926.     break;
  1927.   }
  1929.   return error;
  1930. }
  1932. /*
  1933.  * NSSCKFWC_CopyObject
  1934.  *
  1935.  */
  1936. NSS_IMPLEMENT CK_RV
  1937. NSSCKFWC_CopyObject
  1938. (
  1939.   NSSCKFWInstance *fwInstance,
  1940.   CK_SESSION_HANDLE hSession,
  1941.   CK_OBJECT_HANDLE hObject,
  1942.   CK_ATTRIBUTE_PTR pTemplate,
  1943.   CK_ULONG ulCount,
  1944.   CK_OBJECT_HANDLE_PTR phNewObject
  1945. )
  1946. {
  1947.   CK_RV error = CKR_OK;
  1948.   NSSCKFWSession *fwSession;
  1949.   NSSCKFWObject *fwObject;
  1950.   NSSCKFWObject *fwNewObject;
  1952.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  1953.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  1954.     goto loser;
  1955.   }
  1956.   
  1957.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  1958.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1959.     error = CKR_SESSION_HANDLE_INVALID;
  1960.     goto loser;
  1961.   }
  1963.   if( (CK_OBJECT_HANDLE_PTR)CK_NULL_PTR == phNewObject ) {
  1964.     error = CKR_ARGUMENTS_BAD;
  1965.     goto loser;
  1966.   }
  1968.   /*
  1969.    * A purify error here indicates caller error.
  1970.    */
  1971.   *phNewObject = (CK_OBJECT_HANDLE)0;
  1973.   fwObject = nssCKFWInstance_ResolveObjectHandle(fwInstance, hObject);
  1974.   if( (NSSCKFWObject *)NULL == fwObject ) {
  1975.     error = CKR_OBJECT_HANDLE_INVALID;
  1976.     goto loser;
  1977.   }
  1979.   fwNewObject = nssCKFWSession_CopyObject(fwSession, fwObject,
  1980.                   pTemplate, ulCount, &error);
  1981.   if( (NSSCKFWObject *)NULL == fwNewObject ) {
  1982.     goto loser;
  1983.   }
  1985.   *phNewObject = nssCKFWInstance_CreateObjectHandle(fwInstance, 
  1986.                    fwNewObject, &error);
  1987.   if( (CK_OBJECT_HANDLE)0 == *phNewObject ) {
  1988.     nssCKFWObject_Destroy(fwNewObject);
  1989.     goto loser;
  1990.   }
  1992.   return CKR_OK;
  1994.  loser:
  1995.   switch( error ) {
  1996.   case CKR_SESSION_CLOSED:
  1997.     /* destroy session? */
  1998.     break;
  1999.   case CKR_DEVICE_REMOVED:
  2000.     /* (void)nssCKFWToken_Destroy(fwToken); */
  2001.     break;
  2002.   case CKR_ATTRIBUTE_READ_ONLY:
  2003.   case CKR_ATTRIBUTE_TYPE_INVALID:
  2004.   case CKR_ATTRIBUTE_VALUE_INVALID:
  2005.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  2006.   case CKR_DEVICE_ERROR:
  2007.   case CKR_DEVICE_MEMORY:
  2008.   case CKR_FUNCTION_FAILED:
  2009.   case CKR_GENERAL_ERROR:
  2010.   case CKR_HOST_MEMORY:
  2011.   case CKR_OBJECT_HANDLE_INVALID:
  2012.   case CKR_SESSION_HANDLE_INVALID:
  2013.   case CKR_SESSION_READ_ONLY:
  2014.   case CKR_TEMPLATE_INCONSISTENT:
  2015.   case CKR_TOKEN_WRITE_PROTECTED:
  2016.   case CKR_USER_NOT_LOGGED_IN:
  2017.     break;
  2018.   default:
  2019.   case CKR_OK:
  2020.     error = CKR_GENERAL_ERROR;
  2021.     break;
  2022.   }
  2024.   return error;
  2025. }
  2027. /*
  2028.  * NSSCKFWC_DestroyObject
  2029.  *
  2030.  */
  2031. NSS_IMPLEMENT CK_RV
  2032. NSSCKFWC_DestroyObject
  2033. (
  2034.   NSSCKFWInstance *fwInstance,
  2035.   CK_SESSION_HANDLE hSession,
  2036.   CK_OBJECT_HANDLE hObject
  2037. )
  2038. {
  2039.   CK_RV error = CKR_OK;
  2040.   NSSCKFWSession *fwSession;
  2041.   NSSCKFWObject *fwObject;
  2043.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  2044.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  2045.     goto loser;
  2046.   }
  2047.   
  2048.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  2049.   if( (NSSCKFWSession *)NULL == fwSession ) {
  2050.     error = CKR_SESSION_HANDLE_INVALID;
  2051.     goto loser;
  2052.   }
  2054.   fwObject = nssCKFWInstance_ResolveObjectHandle(fwInstance, hObject);
  2055.   if( (NSSCKFWObject *)NULL == fwObject ) {
  2056.     error = CKR_OBJECT_HANDLE_INVALID;
  2057.     goto loser;
  2058.   }
  2060.   nssCKFWObject_Destroy(fwObject);
  2061.   nssCKFWInstance_DestroyObjectHandle(fwInstance, hObject);
  2063.   return CKR_OK;
  2065.  loser:
  2066.   switch( error ) {
  2067.   case CKR_SESSION_CLOSED:
  2068.     /* destroy session? */
  2069.     break;
  2070.   case CKR_DEVICE_REMOVED:
  2071.     /* (void)nssCKFWToken_Destroy(fwToken); */
  2072.     break;
  2073.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  2074.   case CKR_DEVICE_ERROR:
  2075.   case CKR_DEVICE_MEMORY:
  2076.   case CKR_FUNCTION_FAILED:
  2077.   case CKR_GENERAL_ERROR:
  2078.   case CKR_HOST_MEMORY:
  2079.   case CKR_OBJECT_HANDLE_INVALID:
  2080.   case CKR_SESSION_HANDLE_INVALID:
  2081.   case CKR_SESSION_READ_ONLY:
  2082.   case CKR_TOKEN_WRITE_PROTECTED:
  2083.     break;
  2084.   default:
  2085.   case CKR_OK:
  2086.     error = CKR_GENERAL_ERROR;
  2087.     break;
  2088.   }
  2090.   return error;
  2091. }
  2093. /*
  2094.  * NSSCKFWC_GetObjectSize
  2095.  *
  2096.  */
  2097. NSS_IMPLEMENT CK_RV
  2098. NSSCKFWC_GetObjectSize
  2099. (
  2100.   NSSCKFWInstance *fwInstance,
  2101.   CK_SESSION_HANDLE hSession,
  2102.   CK_OBJECT_HANDLE hObject,
  2103.   CK_ULONG_PTR pulSize
  2104. )
  2105. {
  2106.   CK_RV error = CKR_OK;
  2107.   NSSCKFWSession *fwSession;
  2108.   NSSCKFWObject *fwObject;
  2110.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  2111.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  2112.     goto loser;
  2113.   }
  2114.   
  2115.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  2116.   if( (NSSCKFWSession *)NULL == fwSession ) {
  2117.     error = CKR_SESSION_HANDLE_INVALID;
  2118.     goto loser;
  2119.   }
  2121.   fwObject = nssCKFWInstance_ResolveObjectHandle(fwInstance, hObject);
  2122.   if( (NSSCKFWObject *)NULL == fwObject ) {
  2123.     error = CKR_OBJECT_HANDLE_INVALID;
  2124.     goto loser;
  2125.   }
  2127.   if( (CK_ULONG_PTR)CK_NULL_PTR == pulSize ) {
  2128.     error = CKR_ARGUMENTS_BAD;
  2129.     goto loser;
  2130.   }
  2132.   /*
  2133.    * A purify error here indicates caller error.
  2134.    */
  2135.   *pulSize = (CK_ULONG)0;
  2137.   *pulSize = nssCKFWObject_GetObjectSize(fwObject, &error);
  2138.   if( ((CK_ULONG)0 == *pulSize) && (CKR_OK != error) ) {
  2139.     goto loser;
  2140.   }
  2142.   return CKR_OK;
  2144.  loser:
  2145.   switch( error ) {
  2146.   case CKR_SESSION_CLOSED:
  2147.     /* destroy session? */
  2148.     break;
  2149.   case CKR_DEVICE_REMOVED:
  2150.     /* (void)nssCKFWToken_Destroy(fwToken); */
  2151.     break;
  2152.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  2153.   case CKR_DEVICE_ERROR:
  2154.   case CKR_DEVICE_MEMORY:
  2155.   case CKR_FUNCTION_FAILED:
  2156.   case CKR_GENERAL_ERROR:
  2157.   case CKR_HOST_MEMORY:
  2158.   case CKR_INFORMATION_SENSITIVE:
  2159.   case CKR_OBJECT_HANDLE_INVALID:
  2160.   case CKR_SESSION_HANDLE_INVALID:
  2161.     break;
  2162.   default:
  2163.   case CKR_OK:
  2164.     error = CKR_GENERAL_ERROR;
  2165.     break;
  2166.   }
  2168.   return error;
  2169. }
  2171. /*
  2172.  * NSSCKFWC_GetAttributeValue
  2173.  *
  2174.  */
  2175. NSS_IMPLEMENT CK_RV
  2176. NSSCKFWC_GetAttributeValue
  2177. (
  2178.   NSSCKFWInstance *fwInstance,
  2179.   CK_SESSION_HANDLE hSession,
  2180.   CK_OBJECT_HANDLE hObject,
  2181.   CK_ATTRIBUTE_PTR pTemplate,
  2182.   CK_ULONG ulCount
  2183. )
  2184. {
  2185.   CK_RV error = CKR_OK;
  2186.   NSSCKFWSession *fwSession;
  2187.   NSSCKFWObject *fwObject;
  2188.   CK_BBOOL sensitive = CK_FALSE;
  2189.   CK_BBOOL invalid = CK_FALSE;
  2190.   CK_BBOOL tooSmall = CK_FALSE;
  2191.   CK_ULONG i;
  2193.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  2194.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  2195.     goto loser;
  2196.   }
  2197.   
  2198.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  2199.   if( (NSSCKFWSession *)NULL == fwSession ) {
  2200.     error = CKR_SESSION_HANDLE_INVALID;
  2201.     goto loser;
  2202.   }
  2204.   fwObject = nssCKFWInstance_ResolveObjectHandle(fwInstance, hObject);
  2205.   if( (NSSCKFWObject *)NULL == fwObject ) {
  2206.     error = CKR_OBJECT_HANDLE_INVALID;
  2207.     goto loser;
  2208.   }
  2210.   if( (CK_ATTRIBUTE_PTR)CK_NULL_PTR == pTemplate ) {
  2211.     error = CKR_ARGUMENTS_BAD;
  2212.     goto loser;
  2213.   }
  2215.   for( i = 0; i < ulCount; i++ ) {
  2216.     CK_ULONG size = nssCKFWObject_GetAttributeSize(fwObject, 
  2217.                       pTemplate[i].type, &error);
  2218.     if( (CK_ULONG)0 == size ) {
  2219.       switch( error ) {
  2220.       case CKR_ATTRIBUTE_SENSITIVE:
  2221.       case CKR_INFORMATION_SENSITIVE:
  2222.         sensitive = CK_TRUE;
  2223.         pTemplate[i].ulValueLen = (CK_ULONG)(-1);
  2224.         continue;
  2225.       case CKR_ATTRIBUTE_TYPE_INVALID:
  2226.         invalid = CK_TRUE;
  2227.         pTemplate[i].ulValueLen = (CK_ULONG)(-1);
  2228.         continue;
  2229.       case CKR_OK:
  2230.         break;
  2231.       default:
  2232.         goto loser;
  2233.       }
  2234.     }
  2236.     if( (CK_VOID_PTR)CK_NULL_PTR == pTemplate[i].pValue ) {
  2237.       pTemplate[i].ulValueLen = size;
  2238.     } else {
  2239.       NSSItem it, *p;
  2241.       if( pTemplate[i].ulValueLen < size ) {
  2242.         tooSmall = CK_TRUE;
  2243.         continue;
  2244.       }
  2246.       it.size = (PRUint32)pTemplate[i].ulValueLen;
  2247.       it.data = (void *)pTemplate[i].pValue;
  2248.       p = nssCKFWObject_GetAttribute(fwObject, pTemplate[i].type, &it, 
  2249.             (NSSArena *)NULL, &error);
  2250.       if( (NSSItem *)NULL == p ) {
  2251.         switch( error ) {
  2252.         case CKR_ATTRIBUTE_SENSITIVE:
  2253.         case CKR_INFORMATION_SENSITIVE:
  2254.           sensitive = CK_TRUE;
  2255.           pTemplate[i].ulValueLen = (CK_ULONG)(-1);
  2256.           continue;
  2257.         case CKR_ATTRIBUTE_TYPE_INVALID:
  2258.           invalid = CK_TRUE;
  2259.           pTemplate[i].ulValueLen = (CK_ULONG)(-1);
  2260.           continue;
  2261.         default:
  2262.           goto loser;
  2263.         }
  2264.       }
  2266.       pTemplate[i].ulValueLen = size;
  2267.     }
  2268.   }
  2270.   if( sensitive ) {
  2271.     error = CKR_ATTRIBUTE_SENSITIVE;
  2272.     goto loser;
  2273.   } else if( invalid ) {
  2274.     error = CKR_ATTRIBUTE_TYPE_INVALID;
  2275.     goto loser;
  2276.   } else if( tooSmall ) {
  2277.     error = CKR_BUFFER_TOO_SMALL;
  2278.     goto loser;
  2279.   }
  2281.   return CKR_OK;
  2283.  loser:
  2284.   switch( error ) {
  2285.   case CKR_SESSION_CLOSED:
  2286.     /* destroy session? */
  2287.     break;
  2288.   case CKR_DEVICE_REMOVED:
  2289.     /* (void)nssCKFWToken_Destroy(fwToken); */
  2290.     break;
  2291.   case CKR_ATTRIBUTE_SENSITIVE:
  2292.   case CKR_ATTRIBUTE_TYPE_INVALID:
  2293.   case CKR_BUFFER_TOO_SMALL:
  2294.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  2295.   case CKR_DEVICE_ERROR:
  2296.   case CKR_DEVICE_MEMORY:
  2297.   case CKR_FUNCTION_FAILED:
  2298.   case CKR_GENERAL_ERROR:
  2299.   case CKR_HOST_MEMORY:
  2300.   case CKR_OBJECT_HANDLE_INVALID:
  2301.   case CKR_SESSION_HANDLE_INVALID:
  2302.     break;
  2303.   default:
  2304.   case CKR_OK:
  2305.     error = CKR_GENERAL_ERROR;
  2306.     break;
  2307.   }
  2309.   return error;
  2310. }
  2311.   
  2312. /*
  2313.  * NSSCKFWC_SetAttributeValue
  2314.  *
  2315.  */
  2316. NSS_IMPLEMENT CK_RV
  2317. NSSCKFWC_SetAttributeValue
  2318. (
  2319.   NSSCKFWInstance *fwInstance,
  2320.   CK_SESSION_HANDLE hSession,
  2321.   CK_OBJECT_HANDLE hObject,
  2322.   CK_ATTRIBUTE_PTR pTemplate,
  2323.   CK_ULONG ulCount
  2324. )
  2325. {
  2326.   CK_RV error = CKR_OK;
  2327.   NSSCKFWSession *fwSession;
  2328.   NSSCKFWObject *fwObject;
  2329.   NSSCKFWObject *newFwObject;
  2331.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  2332.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  2333.     goto loser;
  2334.   }
  2335.   
  2336.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  2337.   if( (NSSCKFWSession *)NULL == fwSession ) {
  2338.     error = CKR_SESSION_HANDLE_INVALID;
  2339.     goto loser;
  2340.   }
  2342.   fwObject = nssCKFWInstance_ResolveObjectHandle(fwInstance, hObject);
  2343.   if( (NSSCKFWObject *)NULL == fwObject ) {
  2344.     error = CKR_OBJECT_HANDLE_INVALID;
  2345.     goto loser;
  2346.   }
  2348.   if( (CK_ATTRIBUTE_PTR)CK_NULL_PTR == pTemplate ) {
  2349.     error = CKR_ARGUMENTS_BAD;
  2350.     goto loser;
  2351.   }
  2353.   newFwObject = nssCKFWSession_CopyObject(fwSession, fwObject, pTemplate, 
  2354.                   ulCount, &error);
  2355.   if( (NSSCKFWObject *)NULL == newFwObject ) {
  2356.     goto loser;
  2357.   }
  2359.   error = nssCKFWInstance_ReassignObjectHandle(fwInstance, hObject, newFwObject);
  2360.   nssCKFWObject_Destroy(fwObject);
  2362.   if( CKR_OK != error ) {
  2363.     goto loser;
  2364.   }
  2366.   return CKR_OK;
  2368.  loser:
  2369.   switch( error ) {
  2370.   case CKR_SESSION_CLOSED:
  2371.     /* destroy session? */
  2372.     break;
  2373.   case CKR_DEVICE_REMOVED:
  2374.     /* (void)nssCKFWToken_Destroy(fwToken); */
  2375.     break;
  2376.   case CKR_ATTRIBUTE_READ_ONLY:
  2377.   case CKR_ATTRIBUTE_TYPE_INVALID:
  2378.   case CKR_ATTRIBUTE_VALUE_INVALID:
  2379.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  2380.   case CKR_DEVICE_ERROR:
  2381.   case CKR_DEVICE_MEMORY:
  2382.   case CKR_FUNCTION_FAILED:
  2383.   case CKR_GENERAL_ERROR:
  2384.   case CKR_HOST_MEMORY:
  2385.   case CKR_OBJECT_HANDLE_INVALID:
  2386.   case CKR_SESSION_HANDLE_INVALID:
  2387.   case CKR_SESSION_READ_ONLY:
  2388.   case CKR_TEMPLATE_INCONSISTENT:
  2389.   case CKR_TOKEN_WRITE_PROTECTED:
  2390.     break;
  2391.   default:
  2392.   case CKR_OK:
  2393.     error = CKR_GENERAL_ERROR;
  2394.     break;
  2395.   }
  2397.   return error;
  2398. }
  2400. /*
  2401.  * NSSCKFWC_FindObjectsInit
  2402.  *
  2403.  */
  2404. NSS_IMPLEMENT CK_RV
  2405. NSSCKFWC_FindObjectsInit
  2406. (
  2407.   NSSCKFWInstance *fwInstance,
  2408.   CK_SESSION_HANDLE hSession,
  2409.   CK_ATTRIBUTE_PTR pTemplate,
  2410.   CK_ULONG ulCount
  2411. )
  2412. {
  2413.   CK_RV error = CKR_OK;
  2414.   NSSCKFWSession *fwSession;
  2415.   NSSCKFWFindObjects *fwFindObjects;
  2417.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  2418.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  2419.     goto loser;
  2420.   }
  2421.   
  2422.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  2423.   if( (NSSCKFWSession *)NULL == fwSession ) {
  2424.     error = CKR_SESSION_HANDLE_INVALID;
  2425.     goto loser;
  2426.   }
  2428.   if( ((CK_ATTRIBUTE_PTR)CK_NULL_PTR == pTemplate) && (ulCount != 0) ) {
  2429.     error = CKR_ARGUMENTS_BAD;
  2430.     goto loser;
  2431.   }
  2433.   fwFindObjects = nssCKFWSession_GetFWFindObjects(fwSession, &error);
  2434.   if( (NSSCKFWFindObjects *)NULL != fwFindObjects ) {
  2435.     error = CKR_OPERATION_ACTIVE;
  2436.     goto loser;
  2437.   }
  2439.   if( CKR_OPERATION_NOT_INITIALIZED != error ) {
  2440.     goto loser;
  2441.   }
  2443.   fwFindObjects = nssCKFWSession_FindObjectsInit(fwSession,
  2444.                     pTemplate, ulCount, &error);
  2445.   if( (NSSCKFWFindObjects *)NULL == fwFindObjects ) {
  2446.     goto loser;
  2447.   }
  2449.   error = nssCKFWSession_SetFWFindObjects(fwSession, fwFindObjects);
  2451.   if( CKR_OK != error ) {
  2452.     nssCKFWFindObjects_Destroy(fwFindObjects);
  2453.     goto loser;
  2454.   }
  2456.   return CKR_OK;
  2458.  loser:
  2459.   switch( error ) {
  2460.   case CKR_SESSION_CLOSED:
  2461.     /* destroy session? */
  2462.     break;
  2463.   case CKR_DEVICE_REMOVED:
  2464.     /* (void)nssCKFWToken_Destroy(fwToken); */
  2465.     break;
  2466.   case CKR_ATTRIBUTE_TYPE_INVALID:
  2467.   case CKR_ATTRIBUTE_VALUE_INVALID:
  2468.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  2469.   case CKR_DEVICE_ERROR:
  2470.   case CKR_DEVICE_MEMORY:
  2471.   case CKR_FUNCTION_FAILED:
  2472.   case CKR_GENERAL_ERROR:
  2473.   case CKR_HOST_MEMORY:
  2474.   case CKR_OPERATION_ACTIVE:
  2475.   case CKR_SESSION_HANDLE_INVALID:
  2476.     break;
  2477.   default:
  2478.   case CKR_OK:
  2479.     error = CKR_GENERAL_ERROR;
  2480.     break;
  2481.   }
  2483.   return error;
  2484. }
  2486. /*
  2487.  * NSSCKFWC_FindObjects
  2488.  *
  2489.  */
  2490. NSS_IMPLEMENT CK_RV
  2491. NSSCKFWC_FindObjects
  2492. (
  2493.   NSSCKFWInstance *fwInstance,
  2494.   CK_SESSION_HANDLE hSession,
  2495.   CK_OBJECT_HANDLE_PTR phObject,
  2496.   CK_ULONG ulMaxObjectCount,
  2497.   CK_ULONG_PTR pulObjectCount
  2498. )
  2499. {
  2500.   CK_RV error = CKR_OK;
  2501.   NSSCKFWSession *fwSession;
  2502.   NSSCKFWFindObjects *fwFindObjects;
  2503.   CK_ULONG i;
  2504.   NSSArena *arena;
  2506.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  2507.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  2508.     goto loser;
  2509.   }
  2510.   
  2511.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  2512.   if( (NSSCKFWSession *)NULL == fwSession ) {
  2513.     error = CKR_SESSION_HANDLE_INVALID;
  2514.     goto loser;
  2515.   }
  2517.   arena = nssCKFWSession_GetArena(fwSession, &error);
  2518.   if( (NSSArena *)NULL == arena ) {
  2519.     goto loser;
  2520.   }
  2522.   if( (CK_OBJECT_HANDLE_PTR)CK_NULL_PTR == phObject ) {
  2523.     error = CKR_ARGUMENTS_BAD;
  2524.     goto loser;
  2525.   }
  2527.   /*
  2528.    * A purify error here indicates caller error.
  2529.    */
  2530.   (void)nsslibc_memset(phObject, 0, sizeof(CK_OBJECT_HANDLE) * ulMaxObjectCount);
  2531.   *pulObjectCount = (CK_ULONG)0;
  2533.   fwFindObjects = nssCKFWSession_GetFWFindObjects(fwSession, &error);
  2534.   if( (NSSCKFWFindObjects *)NULL == fwFindObjects ) {
  2535.     goto loser;
  2536.   }
  2538.   for( i = 0; i < ulMaxObjectCount; i++ ) {
  2539.     NSSCKFWObject *fwObject = nssCKFWFindObjects_Next(fwFindObjects,
  2540.                                 arena, &error);
  2541.     if( (NSSCKFWObject *)NULL == fwObject ) {
  2542.       break;
  2543.     }
  2545.     phObject[i] = nssCKFWInstance_FindObjectHandle(fwInstance, fwObject);
  2546.     if( (CK_OBJECT_HANDLE)0 == phObject[i] ) {
  2547.       phObject[i] = nssCKFWInstance_CreateObjectHandle(fwInstance, fwObject, &error);
  2548.     }
  2549.     if( (CK_OBJECT_HANDLE)0 == phObject[i] ) {
  2550.       /* This isn't right either, is it? */
  2551.       nssCKFWObject_Destroy(fwObject);
  2552.       goto loser;
  2553.     }
  2554.   }
  2556.   *pulObjectCount = i;
  2558.   return CKR_OK;
  2560.  loser:
  2561.   switch( error ) {
  2562.   case CKR_SESSION_CLOSED:
  2563.     /* destroy session? */
  2564.     break;
  2565.   case CKR_DEVICE_REMOVED:
  2566.     /* (void)nssCKFWToken_Destroy(fwToken); */
  2567.     break;
  2568.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  2569.   case CKR_DEVICE_ERROR:
  2570.   case CKR_DEVICE_MEMORY:
  2571.   case CKR_FUNCTION_FAILED:
  2572.   case CKR_GENERAL_ERROR:
  2573.   case CKR_HOST_MEMORY:
  2574.   case CKR_OPERATION_NOT_INITIALIZED:
  2575.   case CKR_SESSION_HANDLE_INVALID:
  2576.     break;
  2577.   default:
  2578.   case CKR_OK:
  2579.     error = CKR_GENERAL_ERROR;
  2580.     break;
  2581.   }
  2583.   return error;
  2584. }
  2586. /*
  2587.  * NSSCKFWC_FindObjectsFinal
  2588.  *
  2589.  */
  2590. NSS_IMPLEMENT CK_RV
  2591. NSSCKFWC_FindObjectsFinal
  2592. (
  2593.   NSSCKFWInstance *fwInstance,
  2594.   CK_SESSION_HANDLE hSession
  2595. )
  2596. {
  2597.   CK_RV error = CKR_OK;
  2598.   NSSCKFWSession *fwSession;
  2599.   NSSCKFWFindObjects *fwFindObjects;
  2600.   
  2601.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  2602.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  2603.     goto loser;
  2604.   }
  2605.   
  2606.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  2607.   if( (NSSCKFWSession *)NULL == fwSession ) {
  2608.     error = CKR_SESSION_HANDLE_INVALID;
  2609.     goto loser;
  2610.   }
  2612.   fwFindObjects = nssCKFWSession_GetFWFindObjects(fwSession, &error);
  2613.   if( (NSSCKFWFindObjects *)NULL == fwFindObjects ) {
  2614.     error = CKR_OPERATION_NOT_INITIALIZED;
  2615.     goto loser;
  2616.   }
  2618.   nssCKFWFindObjects_Destroy(fwFindObjects);
  2619.   error = nssCKFWSession_SetFWFindObjects(fwSession, (NSSCKFWFindObjects *)NULL);
  2621.   if( CKR_OK != error ) {
  2622.     goto loser;
  2623.   }
  2625.   return CKR_OK;
  2627.  loser:
  2628.   switch( error ) {
  2629.   case CKR_SESSION_CLOSED:
  2630.     /* destroy session? */
  2631.     break;
  2632.   case CKR_DEVICE_REMOVED:
  2633.     /* (void)nssCKFWToken_Destroy(fwToken); */
  2634.     break;
  2635.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  2636.   case CKR_DEVICE_ERROR:
  2637.   case CKR_DEVICE_MEMORY:
  2638.   case CKR_FUNCTION_FAILED:
  2639.   case CKR_GENERAL_ERROR:
  2640.   case CKR_HOST_MEMORY:
  2641.   case CKR_OPERATION_NOT_INITIALIZED:
  2642.   case CKR_SESSION_HANDLE_INVALID:
  2643.     break;
  2644.   default:
  2645.   case CKR_OK:
  2646.     error = CKR_GENERAL_ERROR;
  2647.     break;
  2648.   }
  2650.   return error;
  2651. }
  2653. /*
  2654.  * NSSCKFWC_EncryptInit
  2655.  *
  2656.  */
  2657. NSS_IMPLEMENT CK_RV
  2658. NSSCKFWC_EncryptInit
  2659. (
  2660.   NSSCKFWInstance *fwInstance,
  2661.   CK_SESSION_HANDLE hSession,
  2662.   CK_MECHANISM_PTR pMechanism,
  2663.   CK_OBJECT_HANDLE hKey
  2664. )
  2665. {
  2666.   return CKR_FUNCTION_FAILED;
  2667. }
  2669. /*
  2670.  * NSSCKFWC_Encrypt
  2671.  *
  2672.  */
  2673. NSS_IMPLEMENT CK_RV
  2674. NSSCKFWC_Encrypt
  2675. (
  2676.   NSSCKFWInstance *fwInstance,
  2677.   CK_SESSION_HANDLE hSession,
  2678.   CK_BYTE_PTR pData,
  2679.   CK_ULONG ulDataLen,
  2680.   CK_BYTE_PTR pEncryptedData,
  2681.   CK_ULONG_PTR pulEncryptedDataLen
  2682. )
  2683. {
  2684.   return CKR_FUNCTION_FAILED;
  2685. }
  2687. /*
  2688.  * NSSCKFWC_EncryptUpdate
  2689.  *
  2690.  */
  2691. NSS_IMPLEMENT CK_RV
  2692. NSSCKFWC_EncryptUpdate
  2693. (
  2694.   NSSCKFWInstance *fwInstance,
  2695.   CK_SESSION_HANDLE hSession,
  2696.   CK_BYTE_PTR pPart,
  2697.   CK_ULONG ulPartLen,
  2698.   CK_BYTE_PTR pEncryptedPart,
  2699.   CK_ULONG_PTR pulEncryptedPartLen
  2700. )
  2701. {
  2702.   return CKR_FUNCTION_FAILED;
  2703. }
  2705. /*
  2706.  * NSSCKFWC_EncryptFinal
  2707.  *
  2708.  */
  2709. NSS_IMPLEMENT CK_RV
  2710. NSSCKFWC_EncryptFinal
  2711. (
  2712.   NSSCKFWInstance *fwInstance,
  2713.   CK_SESSION_HANDLE hSession,
  2714.   CK_BYTE_PTR pLastEncryptedPart,
  2715.   CK_ULONG_PTR pulLastEncryptedPartLen
  2716. )
  2717. {
  2718.   return CKR_FUNCTION_FAILED;
  2719. }
  2721. /*
  2722.  * NSSCKFWC_DecryptInit
  2723.  *
  2724.  */
  2725. NSS_IMPLEMENT CK_RV
  2726. NSSCKFWC_DecryptInit
  2727. (
  2728.   NSSCKFWInstance *fwInstance,
  2729.   CK_SESSION_HANDLE hSession,
  2730.   CK_MECHANISM_PTR pMechanism,
  2731.   CK_OBJECT_HANDLE hKey
  2732. )
  2733. {
  2734.   return CKR_FUNCTION_FAILED;
  2735. }
  2737. /*
  2738.  * NSSCKFWC_Decrypt
  2739.  *
  2740.  */
  2741. NSS_IMPLEMENT CK_RV
  2742. NSSCKFWC_Decrypt
  2743. (
  2744.   NSSCKFWInstance *fwInstance,
  2745.   CK_SESSION_HANDLE hSession,
  2746.   CK_BYTE_PTR pEncryptedData,
  2747.   CK_ULONG ulEncryptedDataLen,
  2748.   CK_BYTE_PTR pData,
  2749.   CK_ULONG_PTR pulDataLen
  2750. )
  2751. {
  2752.   return CKR_FUNCTION_FAILED;
  2753. }
  2755. /*
  2756.  * NSSCKFWC_DecryptUpdate
  2757.  *
  2758.  */
  2759. NSS_IMPLEMENT CK_RV
  2760. NSSCKFWC_DecryptUpdate
  2761. (
  2762.   NSSCKFWInstance *fwInstance,
  2763.   CK_SESSION_HANDLE hSession,
  2764.   CK_BYTE_PTR pEncryptedPart,
  2765.   CK_ULONG ulEncryptedPartLen,
  2766.   CK_BYTE_PTR pPart,
  2767.   CK_ULONG_PTR pulPartLen
  2768. )
  2769. {
  2770.   return CKR_FUNCTION_FAILED;
  2771. }
  2773. /*
  2774.  * NSSCKFWC_DecryptFinal
  2775.  *
  2776.  */
  2777. NSS_IMPLEMENT CK_RV
  2778. NSSCKFWC_DecryptFinal
  2779. (
  2780.   NSSCKFWInstance *fwInstance,
  2781.   CK_SESSION_HANDLE hSession,
  2782.   CK_BYTE_PTR pLastPart,
  2783.   CK_ULONG_PTR pulLastPartLen
  2784. )
  2785. {
  2786.   return CKR_FUNCTION_FAILED;
  2787. }
  2789. /*
  2790.  * NSSCKFWC_DigestInit
  2791.  *
  2792.  */
  2793. NSS_IMPLEMENT CK_RV
  2794. NSSCKFWC_DigestInit
  2795. (
  2796.   NSSCKFWInstance *fwInstance,
  2797.   CK_SESSION_HANDLE hSession,
  2798.   CK_MECHANISM_PTR pMechanism
  2799. )
  2800. {
  2801.   return CKR_FUNCTION_FAILED;
  2802. }
  2804. /*
  2805.  * NSSCKFWC_Digest
  2806.  *
  2807.  */
  2808. NSS_IMPLEMENT CK_RV
  2809. NSSCKFWC_Digest
  2810. (
  2811.   NSSCKFWInstance *fwInstance,
  2812.   CK_SESSION_HANDLE hSession,
  2813.   CK_BYTE_PTR pData,
  2814.   CK_ULONG ulDataLen,
  2815.   CK_BYTE_PTR pDigest,
  2816.   CK_ULONG_PTR pulDigestLen
  2817. )
  2818. {
  2819.   return CKR_FUNCTION_FAILED;
  2820. }
  2822. /*
  2823.  * NSSCKFWC_DigestUpdate
  2824.  *
  2825.  */
  2826. NSS_IMPLEMENT CK_RV
  2827. NSSCKFWC_DigestUpdate
  2828. (
  2829.   NSSCKFWInstance *fwInstance,
  2830.   CK_SESSION_HANDLE hSession,
  2831.   CK_BYTE_PTR pData,
  2832.   CK_ULONG ulDataLen
  2833. )
  2834. {
  2835.   return CKR_FUNCTION_FAILED;
  2836. }
  2838. /*
  2839.  * NSSCKFWC_DigestKey
  2840.  *
  2841.  */
  2842. NSS_IMPLEMENT CK_RV
  2843. NSSCKFWC_DigestKey
  2844. (
  2845.   NSSCKFWInstance *fwInstance,
  2846.   CK_SESSION_HANDLE hSession,
  2847.   CK_OBJECT_HANDLE hKey
  2848. )
  2849. {
  2850.   return CKR_FUNCTION_FAILED;
  2851. }
  2853. /*
  2854.  * NSSCKFWC_DigestFinal
  2855.  *
  2856.  */
  2857. NSS_IMPLEMENT CK_RV
  2858. NSSCKFWC_DigestFinal
  2859. (
  2860.   NSSCKFWInstance *fwInstance,
  2861.   CK_SESSION_HANDLE hSession,
  2862.   CK_BYTE_PTR pDigest,
  2863.   CK_ULONG_PTR pulDigestLen
  2864. )
  2865. {
  2866.   return CKR_FUNCTION_FAILED;
  2867. }
  2869. /*
  2870.  * NSSCKFWC_SignInit
  2871.  *
  2872.  */
  2873. NSS_IMPLEMENT CK_RV
  2874. NSSCKFWC_SignInit
  2875. (
  2876.   NSSCKFWInstance *fwInstance,
  2877.   CK_SESSION_HANDLE hSession,
  2878.   CK_MECHANISM_PTR pMechanism,
  2879.   CK_OBJECT_HANDLE hKey
  2880. )
  2881. {
  2882.   return CKR_FUNCTION_FAILED;
  2883. }
  2885. /*
  2886.  * NSSCKFWC_Sign
  2887.  *
  2888.  */
  2889. NSS_IMPLEMENT CK_RV
  2890. NSSCKFWC_Sign
  2891. (
  2892.   NSSCKFWInstance *fwInstance,
  2893.   CK_SESSION_HANDLE hSession,
  2894.   CK_BYTE_PTR pData,
  2895.   CK_ULONG ulDataLen,
  2896.   CK_BYTE_PTR pSignature,
  2897.   CK_ULONG_PTR pulSignatureLen
  2898. )
  2899. {
  2900.   return CKR_FUNCTION_FAILED;
  2901. }
  2903. /*
  2904.  * NSSCKFWC_SignUpdate
  2905.  *
  2906.  */
  2907. NSS_IMPLEMENT CK_RV
  2908. NSSCKFWC_SignUpdate
  2909. (
  2910.   NSSCKFWInstance *fwInstance,
  2911.   CK_SESSION_HANDLE hSession,
  2912.   CK_BYTE_PTR pPart,
  2913.   CK_ULONG ulPartLen
  2914. )
  2915. {
  2916.   return CKR_FUNCTION_FAILED;
  2917. }
  2919. /*
  2920.  * NSSCKFWC_SignFinal
  2921.  *
  2922.  */
  2923. NSS_IMPLEMENT CK_RV
  2924. NSSCKFWC_SignFinal
  2925. (
  2926.   NSSCKFWInstance *fwInstance,
  2927.   CK_SESSION_HANDLE hSession,
  2928.   CK_BYTE_PTR pSignature,
  2929.   CK_ULONG_PTR pulSignatureLen
  2930. )
  2931. {
  2932.   return CKR_FUNCTION_FAILED;
  2933. }
  2935. /*
  2936.  * NSSCKFWC_SignRecoverInit
  2937.  *
  2938.  */
  2939. NSS_IMPLEMENT CK_RV
  2940. NSSCKFWC_SignRecoverInit
  2941. (
  2942.   NSSCKFWInstance *fwInstance,
  2943.   CK_SESSION_HANDLE hSession,
  2944.   CK_MECHANISM_PTR pMechanism,
  2945.   CK_OBJECT_HANDLE hKey
  2946. )
  2947. {
  2948.   return CKR_FUNCTION_FAILED;
  2949. }
  2951. /*
  2952.  * NSSCKFWC_SignRecover
  2953.  *
  2954.  */
  2955. NSS_IMPLEMENT CK_RV
  2956. NSSCKFWC_SignRecover
  2957. (
  2958.   NSSCKFWInstance *fwInstance,
  2959.   CK_SESSION_HANDLE hSession,
  2960.   CK_BYTE_PTR pData,
  2961.   CK_ULONG ulDataLen,
  2962.   CK_BYTE_PTR pSignature,
  2963.   CK_ULONG_PTR pulSignatureLen
  2964. )
  2965. {
  2966.   return CKR_FUNCTION_FAILED;
  2967. }
  2969. /*
  2970.  * NSSCKFWC_VerifyInit
  2971.  *
  2972.  */
  2973. NSS_IMPLEMENT CK_RV
  2974. NSSCKFWC_VerifyInit
  2975. (
  2976.   NSSCKFWInstance *fwInstance,
  2977.   CK_SESSION_HANDLE hSession,
  2978.   CK_MECHANISM_PTR pMechanism,
  2979.   CK_OBJECT_HANDLE hKey
  2980. )
  2981. {
  2982.   return CKR_FUNCTION_FAILED;
  2983. }
  2985. /*
  2986.  * NSSCKFWC_Verify
  2987.  *
  2988.  */
  2989. NSS_IMPLEMENT CK_RV
  2990. NSSCKFWC_Verify
  2991. (
  2992.   NSSCKFWInstance *fwInstance,
  2993.   CK_SESSION_HANDLE hSession,
  2994.   CK_BYTE_PTR pData,
  2995.   CK_ULONG ulDataLen,
  2996.   CK_BYTE_PTR pSignature,
  2997.   CK_ULONG ulSignatureLen
  2998. )
  2999. {
  3000.   return CKR_FUNCTION_FAILED;
  3001. }
  3003. /*
  3004.  * NSSCKFWC_VerifyUpdate
  3005.  *
  3006.  */
  3007. NSS_IMPLEMENT CK_RV
  3008. NSSCKFWC_VerifyUpdate
  3009. (
  3010.   NSSCKFWInstance *fwInstance,
  3011.   CK_SESSION_HANDLE hSession,
  3012.   CK_BYTE_PTR pPart,
  3013.   CK_ULONG ulPartLen
  3014. )
  3015. {
  3016.   return CKR_FUNCTION_FAILED;
  3017. }
  3019. /*
  3020.  * NSSCKFWC_VerifyFinal
  3021.  *
  3022.  */
  3023. NSS_IMPLEMENT CK_RV
  3024. NSSCKFWC_VerifyFinal
  3025. (
  3026.   NSSCKFWInstance *fwInstance,
  3027.   CK_SESSION_HANDLE hSession,
  3028.   CK_BYTE_PTR pSignature,
  3029.   CK_ULONG ulSignatureLen
  3030. )
  3031. {
  3032.   return CKR_FUNCTION_FAILED;
  3033. }
  3035. /*
  3036.  * NSSCKFWC_VerifyRecoverInit
  3037.  *
  3038.  */
  3039. NSS_IMPLEMENT CK_RV
  3040. NSSCKFWC_VerifyRecoverInit
  3041. (
  3042.   NSSCKFWInstance *fwInstance,
  3043.   CK_SESSION_HANDLE hSession,
  3044.   CK_MECHANISM_PTR pMechanism,
  3045.   CK_OBJECT_HANDLE hKey
  3046. )
  3047. {
  3048.   return CKR_FUNCTION_FAILED;
  3049. }
  3051. /*
  3052.  * NSSCKFWC_VerifyRecover
  3053.  *
  3054.  */
  3055. NSS_IMPLEMENT CK_RV
  3056. NSSCKFWC_VerifyRecover
  3057. (
  3058.   NSSCKFWInstance *fwInstance,
  3059.   CK_SESSION_HANDLE hSession,
  3060.   CK_BYTE_PTR pSignature,
  3061.   CK_ULONG ulSignatureLen,
  3062.   CK_BYTE_PTR pData,
  3063.   CK_ULONG_PTR pulDataLen
  3064. )
  3065. {
  3066.   return CKR_FUNCTION_FAILED;
  3067. }
  3069. /*
  3070.  * NSSCKFWC_DigestEncryptUpdate
  3071.  *
  3072.  */
  3073. NSS_IMPLEMENT CK_RV
  3074. NSSCKFWC_DigestEncryptUpdate
  3075. (
  3076.   NSSCKFWInstance *fwInstance,
  3077.   CK_SESSION_HANDLE hSession,
  3078.   CK_BYTE_PTR pPart,
  3079.   CK_ULONG ulPartLen,
  3080.   CK_BYTE_PTR pEncryptedPart,
  3081.   CK_ULONG_PTR pulEncryptedPartLen
  3082. )
  3083. {
  3084.   return CKR_FUNCTION_FAILED;
  3085. }
  3087. /*
  3088.  * NSSCKFWC_DecryptDigestUpdate
  3089.  *
  3090.  */
  3091. NSS_IMPLEMENT CK_RV
  3092. NSSCKFWC_DecryptDigestUpdate
  3093. (
  3094.   NSSCKFWInstance *fwInstance,
  3095.   CK_SESSION_HANDLE hSession,
  3096.   CK_BYTE_PTR pEncryptedPart,
  3097.   CK_ULONG ulEncryptedPartLen,
  3098.   CK_BYTE_PTR pPart,
  3099.   CK_ULONG_PTR pulPartLen
  3100. )
  3101. {
  3102.   return CKR_FUNCTION_FAILED;
  3103. }
  3105. /*
  3106.  * NSSCKFWC_SignEncryptUpdate
  3107.  *
  3108.  */
  3109. NSS_IMPLEMENT CK_RV
  3110. NSSCKFWC_SignEncryptUpdate
  3111. (
  3112.   NSSCKFWInstance *fwInstance,
  3113.   CK_SESSION_HANDLE hSession,
  3114.   CK_BYTE_PTR pPart,
  3115.   CK_ULONG ulPartLen,
  3116.   CK_BYTE_PTR pEncryptedPart,
  3117.   CK_ULONG_PTR pulEncryptedPartLen
  3118. )
  3119. {
  3120.   return CKR_FUNCTION_FAILED;
  3121. }
  3123. /*
  3124.  * NSSCKFWC_DecryptVerifyUpdate
  3125.  *
  3126.  */
  3127. NSS_IMPLEMENT CK_RV
  3128. NSSCKFWC_DecryptVerifyUpdate
  3129. (
  3130.   NSSCKFWInstance *fwInstance,
  3131.   CK_SESSION_HANDLE hSession,
  3132.   CK_BYTE_PTR pEncryptedPart,
  3133.   CK_ULONG ulEncryptedPartLen,
  3134.   CK_BYTE_PTR pPart,
  3135.   CK_ULONG_PTR pulPartLen
  3136. )
  3137. {
  3138.   return CKR_FUNCTION_FAILED;
  3139. }
  3141. /*
  3142.  * NSSCKFWC_GenerateKey
  3143.  *
  3144.  */
  3145. NSS_IMPLEMENT CK_RV
  3146. NSSCKFWC_GenerateKey
  3147. (
  3148.   NSSCKFWInstance *fwInstance,
  3149.   CK_SESSION_HANDLE hSession,
  3150.   CK_MECHANISM_PTR pMechanism,
  3151.   CK_ATTRIBUTE_PTR pTemplate,
  3152.   CK_ULONG ulCount,
  3153.   CK_OBJECT_HANDLE_PTR phKey
  3154. )
  3155. {
  3156.   return CKR_FUNCTION_FAILED;
  3157. }
  3159. /*
  3160.  * NSSCKFWC_GenerateKeyPair
  3161.  *
  3162.  */
  3163. NSS_IMPLEMENT CK_RV
  3164. NSSCKFWC_GenerateKeyPair
  3165. (
  3166.   NSSCKFWInstance *fwInstance,
  3167.   CK_SESSION_HANDLE hSession,
  3168.   CK_MECHANISM_PTR pMechanism,
  3169.   CK_ATTRIBUTE_PTR pPublicKeyTemplate,
  3170.   CK_ULONG ulPublicKeyAttributeCount,
  3171.   CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
  3172.   CK_ULONG ulPrivateKeyAttributeCount,
  3173.   CK_OBJECT_HANDLE_PTR phPublicKey,
  3174.   CK_OBJECT_HANDLE_PTR phPrivateKey
  3175. )
  3176. {
  3177.   return CKR_FUNCTION_FAILED;
  3178. }
  3180. /*
  3181.  * NSSCKFWC_WrapKey
  3182.  *
  3183.  */
  3184. NSS_IMPLEMENT CK_RV
  3185. NSSCKFWC_WrapKey
  3186. (
  3187.   NSSCKFWInstance *fwInstance,
  3188.   CK_SESSION_HANDLE hSession,
  3189.   CK_MECHANISM_PTR pMechanism,
  3190.   CK_OBJECT_HANDLE hWrappingKey,
  3191.   CK_OBJECT_HANDLE hKey,
  3192.   CK_BYTE_PTR pWrappedKey,
  3193.   CK_ULONG_PTR pulWrappedKeyLen
  3194. )
  3195. {
  3196.   return CKR_FUNCTION_FAILED;
  3197. }
  3199. /*
  3200.  * NSSCKFWC_UnwrapKey
  3201.  *
  3202.  */
  3203. NSS_IMPLEMENT CK_RV
  3204. NSSCKFWC_UnwrapKey
  3205. (
  3206.   NSSCKFWInstance *fwInstance,
  3207.   CK_SESSION_HANDLE hSession,
  3208.   CK_MECHANISM_PTR pMechanism,
  3209.   CK_OBJECT_HANDLE hUnwrappingKey,
  3210.   CK_BYTE_PTR pWrappedKey,
  3211.   CK_ULONG ulWrappedKeyLen,
  3212.   CK_ATTRIBUTE_PTR pTemplate,
  3213.   CK_ULONG ulAttributeCount,
  3214.   CK_OBJECT_HANDLE_PTR phKey
  3215. )
  3216. {
  3217.   return CKR_FUNCTION_FAILED;
  3218. }
  3220. /*
  3221.  * NSSCKFWC_DeriveKey
  3222.  *
  3223.  */
  3224. NSS_IMPLEMENT CK_RV
  3225. NSSCKFWC_DeriveKey
  3226. (
  3227.   NSSCKFWInstance *fwInstance,
  3228.   CK_SESSION_HANDLE hSession,
  3229.   CK_MECHANISM_PTR pMechanism,
  3230.   CK_OBJECT_HANDLE hBaseKey,
  3231.   CK_ATTRIBUTE_PTR pTemplate,
  3232.   CK_ULONG ulAttributeCount,
  3233.   CK_OBJECT_HANDLE_PTR phKey
  3234. )
  3235. {
  3236.   return CKR_FUNCTION_FAILED;
  3237. }
  3239. /*
  3240.  * NSSCKFWC_SeedRandom
  3241.  *
  3242.  */
  3243. NSS_IMPLEMENT CK_RV
  3244. NSSCKFWC_SeedRandom
  3245. (
  3246.   NSSCKFWInstance *fwInstance,
  3247.   CK_SESSION_HANDLE hSession,
  3248.   CK_BYTE_PTR pSeed,
  3249.   CK_ULONG ulSeedLen
  3250. )
  3251. {
  3252.   CK_RV error = CKR_OK;
  3253.   NSSCKFWSession *fwSession;
  3254.   NSSItem seed;
  3256.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  3257.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  3258.     goto loser;
  3259.   }
  3261.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  3262.   if( (NSSCKFWSession *)NULL == fwSession ) {
  3263.     error = CKR_SESSION_HANDLE_INVALID;
  3264.     goto loser;
  3265.   }
  3267.   if( (CK_BYTE_PTR)CK_NULL_PTR == pSeed ) {
  3268.     error = CKR_ARGUMENTS_BAD;
  3269.     goto loser;
  3270.   }
  3272.   /* We could read through the buffer in a Purify trap */
  3274.   seed.size = (PRUint32)ulSeedLen;
  3275.   seed.data = (void *)pSeed;
  3277.   error = nssCKFWSession_SeedRandom(fwSession, &seed);
  3279.   if( CKR_OK != error ) {
  3280.     goto loser;
  3281.   }
  3283.   return CKR_OK;
  3285.  loser:
  3286.   switch( error ) {
  3287.   case CKR_SESSION_CLOSED:
  3288.     /* destroy session? */
  3289.     break;
  3290.   case CKR_DEVICE_REMOVED:
  3291.     /* (void)nssCKFWToken_Destroy(fwToken); */
  3292.     break;
  3293.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  3294.   case CKR_DEVICE_ERROR:
  3295.   case CKR_DEVICE_MEMORY:
  3296.   case CKR_FUNCTION_CANCELED:
  3297.   case CKR_FUNCTION_FAILED:
  3298.   case CKR_GENERAL_ERROR:
  3299.   case CKR_HOST_MEMORY:
  3300.   case CKR_OPERATION_ACTIVE:
  3301.   case CKR_RANDOM_SEED_NOT_SUPPORTED:
  3302.   case CKR_RANDOM_NO_RNG:
  3303.   case CKR_SESSION_HANDLE_INVALID:
  3304.   case CKR_USER_NOT_LOGGED_IN:
  3305.     break;
  3306.   default:
  3307.   case CKR_OK:
  3308.     error = CKR_GENERAL_ERROR;
  3309.     break;
  3310.   }
  3312.   return error;
  3313. }
  3315. /*
  3316.  * NSSCKFWC_GenerateRandom
  3317.  *
  3318.  */
  3319. NSS_IMPLEMENT CK_RV
  3320. NSSCKFWC_GenerateRandom
  3321. (
  3322.   NSSCKFWInstance *fwInstance,
  3323.   CK_SESSION_HANDLE hSession,
  3324.   CK_BYTE_PTR pRandomData,
  3325.   CK_ULONG ulRandomLen
  3326. )
  3327. {
  3328.   CK_RV error = CKR_OK;
  3329.   NSSCKFWSession *fwSession;
  3330.   NSSItem buffer;
  3332.   if( (NSSCKFWInstance *)NULL == fwInstance ) {
  3333.     error = CKR_CRYPTOKI_NOT_INITIALIZED;
  3334.     goto loser;
  3335.   }
  3337.   fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
  3338.   if( (NSSCKFWSession *)NULL == fwSession ) {
  3339.     error = CKR_SESSION_HANDLE_INVALID;
  3340.     goto loser;
  3341.   }
  3343.   if( (CK_BYTE_PTR)CK_NULL_PTR == pRandomData ) {
  3344.     error = CKR_ARGUMENTS_BAD;
  3345.     goto loser;
  3346.   }
  3348.   /*
  3349.    * A purify error here indicates caller error.
  3350.    */
  3351.   (void)nsslibc_memset(pRandomData, 0, ulRandomLen);
  3353.   buffer.size = (PRUint32)ulRandomLen;
  3354.   buffer.data = (void *)pRandomData;
  3356.   error = nssCKFWSession_GetRandom(fwSession, &buffer);
  3358.   if( CKR_OK != error ) {
  3359.     goto loser;
  3360.   }
  3362.   return CKR_OK;
  3364.  loser:
  3365.   switch( error ) {
  3366.   case CKR_SESSION_CLOSED:
  3367.     /* destroy session? */
  3368.     break;
  3369.   case CKR_DEVICE_REMOVED:
  3370.     /* (void)nssCKFWToken_Destroy(fwToken); */
  3371.     break;
  3372.   case CKR_CRYPTOKI_NOT_INITIALIZED:
  3373.   case CKR_DEVICE_ERROR:
  3374.   case CKR_DEVICE_MEMORY:
  3375.   case CKR_FUNCTION_CANCELED:
  3376.   case CKR_FUNCTION_FAILED:
  3377.   case CKR_GENERAL_ERROR:
  3378.   case CKR_HOST_MEMORY:
  3379.   case CKR_OPERATION_ACTIVE:
  3380.   case CKR_RANDOM_NO_RNG:
  3381.   case CKR_SESSION_HANDLE_INVALID:
  3382.   case CKR_USER_NOT_LOGGED_IN:
  3383.     break;
  3384.   default:
  3385.   case CKR_OK:
  3386.     error = CKR_GENERAL_ERROR;
  3387.     break;
  3388.   }
  3390.   return error;
  3391. }
  3393. /*
  3394.  * NSSCKFWC_GetFunctionStatus
  3395.  *
  3396.  */
  3397. NSS_IMPLEMENT CK_RV
  3398. NSSCKFWC_GetFunctionStatus
  3399. (
  3400.   NSSCKFWInstance *fwInstance,
  3401.   CK_SESSION_HANDLE hSession
  3402. )
  3403. {
  3404.   return CKR_FUNCTION_NOT_PARALLEL;
  3405. }
  3407. /*
  3408.  * NSSCKFWC_CancelFunction
  3409.  *
  3410.  */
  3411. NSS_IMPLEMENT CK_RV
  3412. NSSCKFWC_CancelFunction
  3413. (
  3414.   NSSCKFWInstance *fwInstance,
  3415.   CK_SESSION_HANDLE hSession
  3416. )
  3417. {
  3418.   return CKR_FUNCTION_NOT_PARALLEL;
  3419. }