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

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

CA认证

开发平台：

WINDOWS

token.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: token.c,v $ $Revision: 1.4 $ $Date: 2000/09/06 22:23:57 $ $Name: NSS_3_1_1_RTM $";
  36. #endif /* DEBUG */
  38. /*
  39.  * token.c
  40.  *
  41.  * This file implements the NSSCKFWToken type and methods.
  42.  */
  44. #ifndef CK_T
  45. #include "ck.h"
  46. #endif /* CK_T */
  48. /*
  49.  * NSSCKFWToken
  50.  *
  51.  *  -- create/destroy --
  52.  *  nssCKFWToken_Create
  53.  *  nssCKFWToken_Destroy
  54.  *
  55.  *  -- public accessors --
  56.  *  NSSCKFWToken_GetMDToken
  57.  *  NSSCKFWToken_GetFWSlot
  58.  *  NSSCKFWToken_GetMDSlot
  59.  *  NSSCKFWToken_GetSessionState
  60.  *
  61.  *  -- implement public accessors --
  62.  *  nssCKFWToken_GetMDToken
  63.  *  nssCKFWToken_GetFWSlot
  64.  *  nssCKFWToken_GetMDSlot
  65.  *  nssCKFWToken_GetSessionState
  66.  *  nssCKFWToken_SetSessionState
  67.  *
  68.  *  -- private accessors --
  69.  *  nssCKFWToken_SetSessionState
  70.  *  nssCKFWToken_RemoveSession
  71.  *  nssCKFWToken_CloseAllSessions
  72.  *  nssCKFWToken_GetSessionCount
  73.  *  nssCKFWToken_GetRwSessionCount
  74.  *  nssCKFWToken_GetRoSessionCount
  75.  *  nssCKFWToken_GetSessionObjectHash
  76.  *  nssCKFWToken_GetMDObjectHash
  77.  *  nssCKFWToken_GetObjectHandleHash
  78.  *
  79.  *  -- module fronts --
  80.  *  nssCKFWToken_InitToken
  81.  *  nssCKFWToken_GetLabel
  82.  *  nssCKFWToken_GetManufacturerID
  83.  *  nssCKFWToken_GetModel
  84.  *  nssCKFWToken_GetSerialNumber
  85.  *  nssCKFWToken_GetHasRNG
  86.  *  nssCKFWToken_GetIsWriteProtected
  87.  *  nssCKFWToken_GetLoginRequired
  88.  *  nssCKFWToken_GetUserPinInitialized
  89.  *  nssCKFWToken_GetRestoreKeyNotNeeded
  90.  *  nssCKFWToken_GetHasClockOnToken
  91.  *  nssCKFWToken_GetHasProtectedAuthenticationPath
  92.  *  nssCKFWToken_GetSupportsDualCryptoOperations
  93.  *  nssCKFWToken_GetMaxSessionCount
  94.  *  nssCKFWToken_GetMaxRwSessionCount
  95.  *  nssCKFWToken_GetMaxPinLen
  96.  *  nssCKFWToken_GetMinPinLen
  97.  *  nssCKFWToken_GetTotalPublicMemory
  98.  *  nssCKFWToken_GetFreePublicMemory
  99.  *  nssCKFWToken_GetTotalPrivateMemory
  100.  *  nssCKFWToken_GetFreePrivateMemory
  101.  *  nssCKFWToken_GetHardwareVersion
  102.  *  nssCKFWToken_GetFirmwareVersion
  103.  *  nssCKFWToken_GetUTCTime
  104.  *  nssCKFWToken_OpenSession
  105.  *  nssCKFWToken_GetMechanismCount
  106.  *  nssCKFWToken_GetMechanismTypes
  107.  *  nssCKFWToken_GetMechanism
  108.  */
  110. struct NSSCKFWTokenStr {
  111.   NSSCKFWMutex *mutex;
  112.   NSSArena *arena;
  113.   NSSCKMDToken *mdToken;
  114.   NSSCKFWSlot *fwSlot;
  115.   NSSCKMDSlot *mdSlot;
  116.   NSSCKFWInstance *fwInstance;
  117.   NSSCKMDInstance *mdInstance;
  119.   /*
  120.    * Everything above is set at creation time, and then not modified.
  121.    * The invariants the mutex protects are:
  122.    *
  123.    * 1) Each of the cached descriptions (versions, etc.) are in an
  124.    *    internally consistant state.
  125.    *
  126.    * 2) The session counts and hashes are consistant.
  127.    *
  128.    * 3) The object hashes are consistant.
  129.    *
  130.    * Note that the calls accessing the cached descriptions will call
  131.    * the NSSCKMDToken methods with the mutex locked.  Those methods
  132.    * may then call the public NSSCKFWToken routines.  Those public
  133.    * routines only access the constant data above and the atomic
  134.    * CK_STATE session state variable below, so there's no problem.
  135.    * But be careful if you add to this object; mutexes are in
  136.    * general not reentrant, so don't create deadlock situations.
  137.    */
  139.   NSSUTF8 *label;
  140.   NSSUTF8 *manufacturerID;
  141.   NSSUTF8 *model;
  142.   NSSUTF8 *serialNumber;
  143.   CK_VERSION hardwareVersion;
  144.   CK_VERSION firmwareVersion;
  146.   CK_ULONG sessionCount;
  147.   CK_ULONG rwSessionCount;
  148.   nssCKFWHash *sessions;
  149.   nssCKFWHash *sessionObjectHash;
  150.   nssCKFWHash *mdObjectHash;
  152.   CK_STATE state;
  153. };
  155. #ifdef DEBUG
  156. /*
  157.  * But first, the pointer-tracking stuff.
  158.  *
  159.  * NOTE: the pointer-tracking support in NSS/base currently relies
  160.  * upon NSPR's CallOnce support.  That, however, relies upon NSPR's
  161.  * locking, which is tied into the runtime.  We need a pointer-tracker
  162.  * implementation that uses the locks supplied through C_Initialize.
  163.  * That support, however, can be filled in later.  So for now, I'll
  164.  * just do this routines as no-ops.
  165.  */
  167. static CK_RV
  168. token_add_pointer
  169. (
  170.   const NSSCKFWToken *fwToken
  171. )
  172. {
  173.   return CKR_OK;
  174. }
  176. static CK_RV
  177. token_remove_pointer
  178. (
  179.   const NSSCKFWToken *fwToken
  180. )
  181. {
  182.   return CKR_OK;
  183. }
  185. NSS_IMPLEMENT CK_RV
  186. nssCKFWToken_verifyPointer
  187. (
  188.   const NSSCKFWToken *fwToken
  189. )
  190. {
  191.   return CKR_OK;
  192. }
  194. #endif /* DEBUG */
  196. /*
  197.  * nssCKFWToken_Create
  198.  *
  199.  */
  200. NSS_IMPLEMENT NSSCKFWToken *
  201. nssCKFWToken_Create
  202. (
  203.   NSSCKFWSlot *fwSlot,
  204.   NSSCKMDToken *mdToken,
  205.   CK_RV *pError
  206. )
  207. {
  208.   NSSArena *arena = (NSSArena *)NULL;
  209.   NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
  210.   CK_BBOOL called_setup = CK_FALSE;
  212.   /*
  213.    * We have already verified the arguments in nssCKFWSlot_GetToken.
  214.    */
  216.   arena = NSSArena_Create();
  217.   if( (NSSArena *)NULL == arena ) {
  218.     *pError = CKR_HOST_MEMORY;
  219.     goto loser;
  220.   }
  222.   fwToken = nss_ZNEW(arena, NSSCKFWToken);
  223.   if( (NSSCKFWToken *)NULL == fwToken ) {
  224.     *pError = CKR_HOST_MEMORY;
  225.     goto loser;
  226.   }    
  228.   fwToken->arena = arena;
  229.   fwToken->mdToken = mdToken;
  230.   fwToken->fwSlot = fwSlot;
  231.   fwToken->fwInstance = nssCKFWSlot_GetFWInstance(fwSlot);
  232.   fwToken->mdInstance = nssCKFWSlot_GetMDInstance(fwSlot);
  233.   fwToken->state = CKS_RO_PUBLIC_SESSION; /* some default */
  234.   fwToken->sessionCount = 0;
  235.   fwToken->rwSessionCount = 0;
  237.   fwToken->mutex = nssCKFWInstance_CreateMutex(fwToken->fwInstance, arena, pError);
  238.   if( (NSSCKFWMutex *)NULL == fwToken->mutex ) {
  239.     if( CKR_OK == *pError ) {
  240.       *pError = CKR_GENERAL_ERROR;
  241.     }
  242.     goto loser;
  243.   }
  245.   fwToken->sessions = nssCKFWHash_Create(fwToken->fwInstance, arena, pError);
  246.   if( (nssCKFWHash *)NULL == fwToken->sessions ) {
  247.     if( CKR_OK == *pError ) {
  248.       *pError = CKR_GENERAL_ERROR;
  249.     }
  250.     goto loser;
  251.   }
  253.   if( CK_TRUE != nssCKFWInstance_GetModuleHandlesSessionObjects(
  254.                    fwToken->fwInstance) ) {
  255.     fwToken->sessionObjectHash = nssCKFWHash_Create(fwToken->fwInstance, 
  256.                                    arena, pError);
  257.     if( (nssCKFWHash *)NULL == fwToken->sessionObjectHash ) {
  258.       if( CKR_OK == *pError ) {
  259.         *pError = CKR_GENERAL_ERROR;
  260.       }
  261.       goto loser;
  262.     }
  263.   }
  265.   fwToken->mdObjectHash = nssCKFWHash_Create(fwToken->fwInstance, 
  266.                             arena, pError);
  267.   if( (nssCKFWHash *)NULL == fwToken->mdObjectHash ) {
  268.     if( CKR_OK == *pError ) {
  269.       *pError = CKR_GENERAL_ERROR;
  270.     }
  271.     goto loser;
  272.   }
  274.   fwToken->mdObjectHash = nssCKFWHash_Create(fwToken->fwInstance, 
  275.                                 arena, pError);
  276.   if( (nssCKFWHash *)NULL == fwToken->mdObjectHash ) {
  277.     if( CKR_OK == *pError ) {
  278.       *pError = CKR_GENERAL_ERROR;
  279.     }
  280.     goto loser;
  281.   }
  283.   /* More here */
  285.   if( (void *)NULL != (void *)mdToken->Setup ) {
  286.     *pError = mdToken->Setup(mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
  287.     if( CKR_OK != *pError ) {
  288.       goto loser;
  289.     }
  290.   }
  292.   called_setup = CK_TRUE;
  294. #ifdef DEBUG
  295.   *pError = token_add_pointer(fwToken);
  296.   if( CKR_OK != *pError ) {
  297.     goto loser;
  298.   }
  299. #endif /* DEBUG */
  301.   *pError = CKR_OK;
  302.   return fwToken;
  304.  loser:
  306.   if( CK_TRUE == called_setup ) {
  307.     if( (void *)NULL != (void *)mdToken->Invalidate ) {
  308.       mdToken->Invalidate(mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
  309.     }
  310.   }
  312.   if( (NSSArena *)NULL != arena ) {
  313.     (void)NSSArena_Destroy(arena);
  314.   }
  316.   return (NSSCKFWToken *)NULL;
  317. }
  319. /*
  320.  * nssCKFWToken_Destroy
  321.  *
  322.  */
  323. NSS_IMPLEMENT CK_RV
  324. nssCKFWToken_Destroy
  325. (
  326.   NSSCKFWToken *fwToken
  327. )
  328. {
  329.   CK_RV error = CKR_OK;
  331. #ifdef NSSDEBUG
  332.   error = nssCKFWToken_verifyPointer(fwToken);
  333.   if( CKR_OK != error ) {
  334.     return error;
  335.   }
  336. #endif /* NSSDEBUG */
  338.   (void)nssCKFWMutex_Destroy(fwToken->mutex);
  339.   
  340.   if( (void *)NULL != (void *)fwToken->mdToken->Invalidate ) {
  341.     fwToken->mdToken->Invalidate(fwToken->mdToken, fwToken,
  342.       fwToken->mdInstance, fwToken->fwInstance);
  343.   }
  345.   nssCKFWSlot_ClearToken(fwToken->fwSlot);
  346.   
  347. #ifdef DEBUG
  348.   error = token_remove_pointer(fwToken);
  349. #endif /* DEBUG */
  351.   (void)NSSArena_Destroy(fwToken->arena);
  352.   return error;
  353. }
  355. /*
  356.  * nssCKFWToken_GetMDToken
  357.  *
  358.  */
  359. NSS_IMPLEMENT NSSCKMDToken *
  360. nssCKFWToken_GetMDToken
  361. (
  362.   NSSCKFWToken *fwToken
  363. )
  364. {
  365. #ifdef NSSDEBUG
  366.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  367.     return (NSSCKMDToken *)NULL;
  368.   }
  369. #endif /* NSSDEBUG */
  371.   return fwToken->mdToken;
  372. }
  374. /*
  375.  * nssCKFWToken_GetArena
  376.  *
  377.  */
  378. NSS_IMPLEMENT NSSArena *
  379. nssCKFWToken_GetArena
  380. (
  381.   NSSCKFWToken *fwToken,
  382.   CK_RV *pError
  383. )
  384. {
  385. #ifdef NSSDEBUG
  386.   if( (CK_RV *)NULL == pError ) {
  387.     return (NSSArena *)NULL;
  388.   }
  390.   *pError = nssCKFWToken_verifyPointer(fwToken);
  391.   if( CKR_OK != *pError ) {
  392.     return (NSSArena *)NULL;
  393.   }
  394. #endif /* NSSDEBUG */
  396.   return fwToken->arena;
  397. }
  399. /*
  400.  * nssCKFWToken_GetFWSlot
  401.  *
  402.  */
  403. NSS_IMPLEMENT NSSCKFWSlot *
  404. nssCKFWToken_GetFWSlot
  405. (
  406.   NSSCKFWToken *fwToken
  407. )
  408. {
  409. #ifdef NSSDEBUG
  410.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  411.     return (NSSCKFWSlot *)NULL;
  412.   }
  413. #endif /* NSSDEBUG */
  415.   return fwToken->fwSlot;
  416. }
  418. /*
  419.  * nssCKFWToken_GetMDSlot
  420.  *
  421.  */
  422. NSS_IMPLEMENT NSSCKMDSlot *
  423. nssCKFWToken_GetMDSlot
  424. (
  425.   NSSCKFWToken *fwToken
  426. )
  427. {
  428. #ifdef NSSDEBUG
  429.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  430.     return (NSSCKMDSlot *)NULL;
  431.   }
  432. #endif /* NSSDEBUG */
  434.   return fwToken->mdSlot;
  435. }
  437. /*
  438.  * nssCKFWToken_GetSessionState
  439.  *
  440.  */
  441. NSS_IMPLEMENT CK_STATE
  442. nssCKFWToken_GetSessionState
  443. (
  444.   NSSCKFWToken *fwToken
  445. )
  446. {
  447. #ifdef NSSDEBUG
  448.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  449.     return CKS_RO_PUBLIC_SESSION; /* whatever */
  450.   }
  451. #endif /* NSSDEBUG */
  453.   /*
  454.    * BTW, do not lock the token in this method.
  455.    */
  457.   /*
  458.    * Theoretically, there is no state if there aren't any
  459.    * sessions open.  But then we'd need to worry about
  460.    * reporting an error, etc.  What the heck-- let's just
  461.    * revert to CKR_RO_PUBLIC_SESSION as the "default."
  462.    */
  464.   return fwToken->state;
  465. }
  467. /*
  468.  * nssCKFWToken_InitToken
  469.  *
  470.  */
  471. NSS_IMPLEMENT CK_RV
  472. nssCKFWToken_InitToken
  473. (
  474.   NSSCKFWToken *fwToken,
  475.   NSSItem *pin,
  476.   NSSUTF8 *label
  477. )
  478. {
  479.   CK_RV error;
  481. #ifdef NSSDEBUG
  482.   error = nssCKFWToken_verifyPointer(fwToken);
  483.   if( CKR_OK != error ) {
  484.     return CKR_ARGUMENTS_BAD;
  485.   }
  486. #endif /* NSSDEBUG */
  488.   error = nssCKFWMutex_Lock(fwToken->mutex);
  489.   if( CKR_OK != error ) {
  490.     return error;
  491.   }
  493.   if( fwToken->sessionCount > 0 ) {
  494.     error = CKR_SESSION_EXISTS;
  495.     goto done;
  496.   }
  498.   if( (void *)NULL == (void *)fwToken->mdToken->InitToken ) {
  499.     error = CKR_DEVICE_ERROR;
  500.     goto done;
  501.   }
  503.   if( (NSSItem *)NULL == pin ) {
  504.     if( nssCKFWToken_GetHasProtectedAuthenticationPath(fwToken) ) {
  505.       ; /* okay */
  506.     } else {
  507.       error = CKR_PIN_INCORRECT;
  508.       goto done;
  509.     }
  510.   }
  512.   if( (NSSUTF8 *)NULL == label ) {
  513.     label = (NSSUTF8 *) "";
  514.   }
  516.   error = fwToken->mdToken->InitToken(fwToken->mdToken, fwToken,
  517.             fwToken->mdInstance, fwToken->fwInstance, pin, label);
  519.  done:
  520.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  521.   return error;
  522. }
  524. /*
  525.  * nssCKFWToken_GetLabel
  526.  *
  527.  */
  528. NSS_IMPLEMENT CK_RV
  529. nssCKFWToken_GetLabel
  530. (
  531.   NSSCKFWToken *fwToken,
  532.   CK_CHAR label[32]
  533. )
  534. {
  535.   CK_RV error = CKR_OK;
  537. #ifdef NSSDEBUG
  538.   if( (CK_CHAR_PTR)NULL == label ) {
  539.     return CKR_ARGUMENTS_BAD;
  540.   }
  542.   error = nssCKFWToken_verifyPointer(fwToken);
  543.   if( CKR_OK != error ) {
  544.     return error;
  545.   }
  546. #endif /* NSSDEBUG */
  548.   error = nssCKFWMutex_Lock(fwToken->mutex);
  549.   if( CKR_OK != error ) {
  550.     return error;
  551.   }
  553.   if( (NSSUTF8 *)NULL == fwToken->label ) {
  554.     if( (void *)NULL != (void *)fwToken->mdToken->GetLabel ) {
  555.       fwToken->label = fwToken->mdToken->GetLabel(fwToken->mdToken, fwToken,
  556.         fwToken->mdInstance, fwToken->fwInstance, &error);
  557.       if( ((NSSUTF8 *)NULL == fwToken->label) && (CKR_OK != error) ) {
  558.         goto done;
  559.       }
  560.     } else {
  561.       fwToken->label = (NSSUTF8 *) "";
  562.     }
  563.   }
  565.   (void)nssUTF8_CopyIntoFixedBuffer(fwToken->label, (char *)label, 32, ' ');
  566.   error = CKR_OK;
  568.  done:
  569.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  570.   return error;
  571. }
  573. /*
  574.  * nssCKFWToken_GetManufacturerID
  575.  *
  576.  */
  577. NSS_IMPLEMENT CK_RV
  578. nssCKFWToken_GetManufacturerID
  579. (
  580.   NSSCKFWToken *fwToken,
  581.   CK_CHAR manufacturerID[32]
  582. )
  583. {
  584.   CK_RV error = CKR_OK;
  586. #ifdef NSSDEBUG
  587.   if( (CK_CHAR_PTR)NULL == manufacturerID ) {
  588.     return CKR_ARGUMENTS_BAD;
  589.   }
  591.   error = nssCKFWToken_verifyPointer(fwToken);
  592.   if( CKR_OK != error ) {
  593.     return error;
  594.   }
  595. #endif /* NSSDEBUG */
  597.   error = nssCKFWMutex_Lock(fwToken->mutex);
  598.   if( CKR_OK != error ) {
  599.     return error;
  600.   }
  602.   if( (NSSUTF8 *)NULL == fwToken->manufacturerID ) {
  603.     if( (void *)NULL != (void *)fwToken->mdToken->GetManufacturerID ) {
  604.       fwToken->manufacturerID = fwToken->mdToken->GetManufacturerID(fwToken->mdToken,
  605.         fwToken, fwToken->mdInstance, fwToken->fwInstance, &error);
  606.       if( ((NSSUTF8 *)NULL == fwToken->manufacturerID) && (CKR_OK != error) ) {
  607.         goto done;
  608.       }
  609.     } else {
  610.       fwToken->manufacturerID = (NSSUTF8 *)"";
  611.     }
  612.   }
  614.   (void)nssUTF8_CopyIntoFixedBuffer(fwToken->manufacturerID, (char *)manufacturerID, 32, ' ');
  615.   error = CKR_OK;
  617.  done:
  618.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  619.   return error;
  620. }
  622. /*
  623.  * nssCKFWToken_GetModel
  624.  *
  625.  */
  626. NSS_IMPLEMENT CK_RV
  627. nssCKFWToken_GetModel
  628. (
  629.   NSSCKFWToken *fwToken,
  630.   CK_CHAR model[16]
  631. )
  632. {
  633.   CK_RV error = CKR_OK;
  635. #ifdef NSSDEBUG
  636.   if( (CK_CHAR_PTR)NULL == model ) {
  637.     return CKR_ARGUMENTS_BAD;
  638.   }
  640.   error = nssCKFWToken_verifyPointer(fwToken);
  641.   if( CKR_OK != error ) {
  642.     return error;
  643.   }
  644. #endif /* NSSDEBUG */
  646.   error = nssCKFWMutex_Lock(fwToken->mutex);
  647.   if( CKR_OK != error ) {
  648.     return error;
  649.   }
  651.   if( (NSSUTF8 *)NULL == fwToken->model ) {
  652.     if( (void *)NULL != (void *)fwToken->mdToken->GetModel ) {
  653.       fwToken->model = fwToken->mdToken->GetModel(fwToken->mdToken, fwToken,
  654.         fwToken->mdInstance, fwToken->fwInstance, &error);
  655.       if( ((NSSUTF8 *)NULL == fwToken->model) && (CKR_OK != error) ) {
  656.         goto done;
  657.       }
  658.     } else {
  659.       fwToken->model = (NSSUTF8 *)"";
  660.     }
  661.   }
  663.   (void)nssUTF8_CopyIntoFixedBuffer(fwToken->model, (char *)model, 16, ' ');
  664.   error = CKR_OK;
  666.  done:
  667.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  668.   return error;
  669. }
  671. /*
  672.  * nssCKFWToken_GetSerialNumber
  673.  *
  674.  */
  675. NSS_IMPLEMENT CK_RV
  676. nssCKFWToken_GetSerialNumber
  677. (
  678.   NSSCKFWToken *fwToken,
  679.   CK_CHAR serialNumber[16]
  680. )
  681. {
  682.   CK_RV error = CKR_OK;
  684. #ifdef NSSDEBUG
  685.   if( (CK_CHAR_PTR)NULL == serialNumber ) {
  686.     return CKR_ARGUMENTS_BAD;
  687.   }
  689.   error = nssCKFWToken_verifyPointer(fwToken);
  690.   if( CKR_OK != error ) {
  691.     return error;
  692.   }
  693. #endif /* NSSDEBUG */
  695.   error = nssCKFWMutex_Lock(fwToken->mutex);
  696.   if( CKR_OK != error ) {
  697.     return error;
  698.   }
  700.   if( (NSSUTF8 *)NULL == fwToken->serialNumber ) {
  701.     if( (void *)NULL != (void *)fwToken->mdToken->GetSerialNumber ) {
  702.       fwToken->serialNumber = fwToken->mdToken->GetSerialNumber(fwToken->mdToken, 
  703.         fwToken, fwToken->mdInstance, fwToken->fwInstance, &error);
  704.       if( ((NSSUTF8 *)NULL == fwToken->serialNumber) && (CKR_OK != error) ) {
  705.         goto done;
  706.       }
  707.     } else {
  708.       fwToken->serialNumber = (NSSUTF8 *)"";
  709.     }
  710.   }
  712.   (void)nssUTF8_CopyIntoFixedBuffer(fwToken->serialNumber, (char *)serialNumber, 16, ' ');
  713.   error = CKR_OK;
  715.  done:
  716.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  717.   return error;
  718. }
  721. /*
  722.  * nssCKFWToken_GetHasRNG
  723.  *
  724.  */
  725. NSS_IMPLEMENT CK_BBOOL
  726. nssCKFWToken_GetHasRNG
  727. (
  728.   NSSCKFWToken *fwToken
  729. )
  730. {
  731. #ifdef NSSDEBUG
  732.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  733.     return CK_FALSE;
  734.   }
  735. #endif /* NSSDEBUG */
  737.   if( (void *)NULL == (void *)fwToken->mdToken->GetHasRNG ) {
  738.     return CK_FALSE;
  739.   }
  741.   return fwToken->mdToken->GetHasRNG(fwToken->mdToken, fwToken, 
  742.     fwToken->mdInstance, fwToken->fwInstance);
  743. }
  745. /*
  746.  * nssCKFWToken_GetIsWriteProtected
  747.  *
  748.  */
  749. NSS_IMPLEMENT CK_BBOOL
  750. nssCKFWToken_GetIsWriteProtected
  751. (
  752.   NSSCKFWToken *fwToken
  753. )
  754. {
  755. #ifdef NSSDEBUG
  756.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  757.     return CK_FALSE;
  758.   }
  759. #endif /* NSSDEBUG */
  761.   if( (void *)NULL == (void *)fwToken->mdToken->GetIsWriteProtected ) {
  762.     return CK_FALSE;
  763.   }
  765.   return fwToken->mdToken->GetIsWriteProtected(fwToken->mdToken, fwToken, 
  766.     fwToken->mdInstance, fwToken->fwInstance);
  767. }
  769. /*
  770.  * nssCKFWToken_GetLoginRequired
  771.  *
  772.  */
  773. NSS_IMPLEMENT CK_BBOOL
  774. nssCKFWToken_GetLoginRequired
  775. (
  776.   NSSCKFWToken *fwToken
  777. )
  778. {
  779. #ifdef NSSDEBUG
  780.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  781.     return CK_FALSE;
  782.   }
  783. #endif /* NSSDEBUG */
  785.   if( (void *)NULL == (void *)fwToken->mdToken->GetLoginRequired ) {
  786.     return CK_FALSE;
  787.   }
  789.   return fwToken->mdToken->GetLoginRequired(fwToken->mdToken, fwToken, 
  790.     fwToken->mdInstance, fwToken->fwInstance);
  791. }
  793. /*
  794.  * nssCKFWToken_GetUserPinInitialized
  795.  *
  796.  */
  797. NSS_IMPLEMENT CK_BBOOL
  798. nssCKFWToken_GetUserPinInitialized
  799. (
  800.   NSSCKFWToken *fwToken
  801. )
  802. {
  803. #ifdef NSSDEBUG
  804.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  805.     return CK_FALSE;
  806.   }
  807. #endif /* NSSDEBUG */
  809.   if( (void *)NULL == (void *)fwToken->mdToken->GetUserPinInitialized ) {
  810.     return CK_FALSE;
  811.   }
  813.   return fwToken->mdToken->GetUserPinInitialized(fwToken->mdToken, fwToken, 
  814.     fwToken->mdInstance, fwToken->fwInstance);
  815. }
  817. /*
  818.  * nssCKFWToken_GetRestoreKeyNotNeeded
  819.  *
  820.  */
  821. NSS_IMPLEMENT CK_BBOOL
  822. nssCKFWToken_GetRestoreKeyNotNeeded
  823. (
  824.   NSSCKFWToken *fwToken
  825. )
  826. {
  827. #ifdef NSSDEBUG
  828.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  829.     return CK_FALSE;
  830.   }
  831. #endif /* NSSDEBUG */
  833.   if( (void *)NULL == (void *)fwToken->mdToken->GetRestoreKeyNotNeeded ) {
  834.     return CK_FALSE;
  835.   }
  837.   return fwToken->mdToken->GetRestoreKeyNotNeeded(fwToken->mdToken, fwToken, 
  838.     fwToken->mdInstance, fwToken->fwInstance);
  839. }
  841. /*
  842.  * nssCKFWToken_GetHasClockOnToken
  843.  *
  844.  */
  845. NSS_IMPLEMENT CK_BBOOL
  846. nssCKFWToken_GetHasClockOnToken
  847. (
  848.   NSSCKFWToken *fwToken
  849. )
  850. {
  851. #ifdef NSSDEBUG
  852.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  853.     return CK_FALSE;
  854.   }
  855. #endif /* NSSDEBUG */
  857.   if( (void *)NULL == (void *)fwToken->mdToken->GetHasClockOnToken ) {
  858.     return CK_FALSE;
  859.   }
  861.   return fwToken->mdToken->GetHasClockOnToken(fwToken->mdToken, fwToken, 
  862.     fwToken->mdInstance, fwToken->fwInstance);
  863. }
  865. /*
  866.  * nssCKFWToken_GetHasProtectedAuthenticationPath
  867.  *
  868.  */
  869. NSS_IMPLEMENT CK_BBOOL
  870. nssCKFWToken_GetHasProtectedAuthenticationPath
  871. (
  872.   NSSCKFWToken *fwToken
  873. )
  874. {
  875. #ifdef NSSDEBUG
  876.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  877.     return CK_FALSE;
  878.   }
  879. #endif /* NSSDEBUG */
  881.   if( (void *)NULL == (void *)fwToken->mdToken->GetHasProtectedAuthenticationPath ) {
  882.     return CK_FALSE;
  883.   }
  885.   return fwToken->mdToken->GetHasProtectedAuthenticationPath(fwToken->mdToken, 
  886.     fwToken, fwToken->mdInstance, fwToken->fwInstance);
  887. }
  889. /*
  890.  * nssCKFWToken_GetSupportsDualCryptoOperations
  891.  *
  892.  */
  893. NSS_IMPLEMENT CK_BBOOL
  894. nssCKFWToken_GetSupportsDualCryptoOperations
  895. (
  896.   NSSCKFWToken *fwToken
  897. )
  898. {
  899. #ifdef NSSDEBUG
  900.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  901.     return CK_FALSE;
  902.   }
  903. #endif /* NSSDEBUG */
  905.   if( (void *)NULL == (void *)fwToken->mdToken->GetSupportsDualCryptoOperations ) {
  906.     return CK_FALSE;
  907.   }
  909.   return fwToken->mdToken->GetSupportsDualCryptoOperations(fwToken->mdToken, 
  910.     fwToken, fwToken->mdInstance, fwToken->fwInstance);
  911. }
  913. /*
  914.  * nssCKFWToken_GetMaxSessionCount
  915.  *
  916.  */
  917. NSS_IMPLEMENT CK_ULONG
  918. nssCKFWToken_GetMaxSessionCount
  919. (
  920.   NSSCKFWToken *fwToken
  921. )
  922. {
  923. #ifdef NSSDEBUG
  924.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  925.     return CK_UNAVAILABLE_INFORMATION;
  926.   }
  927. #endif /* NSSDEBUG */
  929.   if( (void *)NULL == (void *)fwToken->mdToken->GetMaxSessionCount ) {
  930.     return CK_UNAVAILABLE_INFORMATION;
  931.   }
  933.   return fwToken->mdToken->GetMaxSessionCount(fwToken->mdToken, fwToken, 
  934.     fwToken->mdInstance, fwToken->fwInstance);
  935. }
  937. /*
  938.  * nssCKFWToken_GetMaxRwSessionCount
  939.  *
  940.  */
  941. NSS_IMPLEMENT CK_ULONG
  942. nssCKFWToken_GetMaxRwSessionCount
  943. (
  944.   NSSCKFWToken *fwToken
  945. )
  946. {
  947. #ifdef NSSDEBUG
  948.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  949.     return CK_UNAVAILABLE_INFORMATION;
  950.   }
  951. #endif /* NSSDEBUG */
  953.   if( (void *)NULL == (void *)fwToken->mdToken->GetMaxRwSessionCount ) {
  954.     return CK_UNAVAILABLE_INFORMATION;
  955.   }
  957.   return fwToken->mdToken->GetMaxRwSessionCount(fwToken->mdToken, fwToken, 
  958.     fwToken->mdInstance, fwToken->fwInstance);
  959. }
  961. /*
  962.  * nssCKFWToken_GetMaxPinLen
  963.  *
  964.  */
  965. NSS_IMPLEMENT CK_ULONG
  966. nssCKFWToken_GetMaxPinLen
  967. (
  968.   NSSCKFWToken *fwToken
  969. )
  970. {
  971. #ifdef NSSDEBUG
  972.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  973.     return CK_UNAVAILABLE_INFORMATION;
  974.   }
  975. #endif /* NSSDEBUG */
  977.   if( (void *)NULL == (void *)fwToken->mdToken->GetMaxPinLen ) {
  978.     return CK_UNAVAILABLE_INFORMATION;
  979.   }
  981.   return fwToken->mdToken->GetMaxPinLen(fwToken->mdToken, fwToken, 
  982.     fwToken->mdInstance, fwToken->fwInstance);
  983. }
  985. /*
  986.  * nssCKFWToken_GetMinPinLen
  987.  *
  988.  */
  989. NSS_IMPLEMENT CK_ULONG
  990. nssCKFWToken_GetMinPinLen
  991. (
  992.   NSSCKFWToken *fwToken
  993. )
  994. {
  995. #ifdef NSSDEBUG
  996.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  997.     return CK_UNAVAILABLE_INFORMATION;
  998.   }
  999. #endif /* NSSDEBUG */
  1001.   if( (void *)NULL == (void *)fwToken->mdToken->GetMinPinLen ) {
  1002.     return CK_UNAVAILABLE_INFORMATION;
  1003.   }
  1005.   return fwToken->mdToken->GetMinPinLen(fwToken->mdToken, fwToken, 
  1006.     fwToken->mdInstance, fwToken->fwInstance);
  1007. }
  1009. /*
  1010.  * nssCKFWToken_GetTotalPublicMemory
  1011.  *
  1012.  */
  1013. NSS_IMPLEMENT CK_ULONG
  1014. nssCKFWToken_GetTotalPublicMemory
  1015. (
  1016.   NSSCKFWToken *fwToken
  1017. )
  1018. {
  1019. #ifdef NSSDEBUG
  1020.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1021.     return CK_UNAVAILABLE_INFORMATION;
  1022.   }
  1023. #endif /* NSSDEBUG */
  1025.   if( (void *)NULL == (void *)fwToken->mdToken->GetTotalPublicMemory ) {
  1026.     return CK_UNAVAILABLE_INFORMATION;
  1027.   }
  1029.   return fwToken->mdToken->GetTotalPublicMemory(fwToken->mdToken, fwToken, 
  1030.     fwToken->mdInstance, fwToken->fwInstance);
  1031. }
  1033. /*
  1034.  * nssCKFWToken_GetFreePublicMemory
  1035.  *
  1036.  */
  1037. NSS_IMPLEMENT CK_ULONG
  1038. nssCKFWToken_GetFreePublicMemory
  1039. (
  1040.   NSSCKFWToken *fwToken
  1041. )
  1042. {
  1043. #ifdef NSSDEBUG
  1044.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1045.     return CK_UNAVAILABLE_INFORMATION;
  1046.   }
  1047. #endif /* NSSDEBUG */
  1049.   if( (void *)NULL == (void *)fwToken->mdToken->GetFreePublicMemory ) {
  1050.     return CK_UNAVAILABLE_INFORMATION;
  1051.   }
  1053.   return fwToken->mdToken->GetFreePublicMemory(fwToken->mdToken, fwToken, 
  1054.     fwToken->mdInstance, fwToken->fwInstance);
  1055. }
  1057. /*
  1058.  * nssCKFWToken_GetTotalPrivateMemory
  1059.  *
  1060.  */
  1061. NSS_IMPLEMENT CK_ULONG
  1062. nssCKFWToken_GetTotalPrivateMemory
  1063. (
  1064.   NSSCKFWToken *fwToken
  1065. )
  1066. {
  1067. #ifdef NSSDEBUG
  1068.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1069.     return CK_UNAVAILABLE_INFORMATION;
  1070.   }
  1071. #endif /* NSSDEBUG */
  1073.   if( (void *)NULL == (void *)fwToken->mdToken->GetTotalPrivateMemory ) {
  1074.     return CK_UNAVAILABLE_INFORMATION;
  1075.   }
  1077.   return fwToken->mdToken->GetTotalPrivateMemory(fwToken->mdToken, fwToken, 
  1078.     fwToken->mdInstance, fwToken->fwInstance);
  1079. }
  1081. /*
  1082.  * nssCKFWToken_GetFreePrivateMemory
  1083.  *
  1084.  */
  1085. NSS_IMPLEMENT CK_ULONG
  1086. nssCKFWToken_GetFreePrivateMemory
  1087. (
  1088.   NSSCKFWToken *fwToken
  1089. )
  1090. {
  1091. #ifdef NSSDEBUG
  1092.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1093.     return CK_UNAVAILABLE_INFORMATION;
  1094.   }
  1095. #endif /* NSSDEBUG */
  1097.   if( (void *)NULL == (void *)fwToken->mdToken->GetFreePrivateMemory ) {
  1098.     return CK_UNAVAILABLE_INFORMATION;
  1099.   }
  1101.   return fwToken->mdToken->GetFreePrivateMemory(fwToken->mdToken, fwToken, 
  1102.     fwToken->mdInstance, fwToken->fwInstance);
  1103. }
  1105. /*
  1106.  * nssCKFWToken_GetHardwareVersion
  1107.  *
  1108.  */
  1109. NSS_IMPLEMENT CK_VERSION
  1110. nssCKFWToken_GetHardwareVersion
  1111. (
  1112.   NSSCKFWToken *fwToken
  1113. )
  1114. {
  1115.   CK_VERSION rv;
  1117. #ifdef NSSDEBUG
  1118.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1119.     rv.major = rv.minor = 0;
  1120.     return rv;
  1121.   }
  1122. #endif /* NSSDEBUG */
  1124.   if( CKR_OK != nssCKFWMutex_Lock(fwToken->mutex) ) {
  1125.     rv.major = rv.minor = 0;
  1126.     return rv;
  1127.   }
  1129.   if( (0 != fwToken->hardwareVersion.major) ||
  1130.       (0 != fwToken->hardwareVersion.minor) ) {
  1131.     rv = fwToken->hardwareVersion;
  1132.     goto done;
  1133.   }
  1135.   if( (void *)NULL != (void *)fwToken->mdToken->GetHardwareVersion ) {
  1136.     fwToken->hardwareVersion = fwToken->mdToken->GetHardwareVersion(
  1137.       fwToken->mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
  1138.   } else {
  1139.     fwToken->hardwareVersion.major = 0;
  1140.     fwToken->hardwareVersion.minor = 1;
  1141.   }
  1143.   rv = fwToken->hardwareVersion;
  1145.  done:
  1146.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  1147.   return rv;
  1148. }
  1150. /*
  1151.  * nssCKFWToken_GetFirmwareVersion
  1152.  *
  1153.  */
  1154. NSS_IMPLEMENT CK_VERSION
  1155. nssCKFWToken_GetFirmwareVersion
  1156. (
  1157.   NSSCKFWToken *fwToken
  1158. )
  1159. {
  1160.   CK_VERSION rv;
  1162. #ifdef NSSDEBUG
  1163.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1164.     rv.major = rv.minor = 0;
  1165.     return rv;
  1166.   }
  1167. #endif /* NSSDEBUG */
  1169.   if( CKR_OK != nssCKFWMutex_Lock(fwToken->mutex) ) {
  1170.     rv.major = rv.minor = 0;
  1171.     return rv;
  1172.   }
  1174.   if( (0 != fwToken->firmwareVersion.major) ||
  1175.       (0 != fwToken->firmwareVersion.minor) ) {
  1176.     rv = fwToken->firmwareVersion;
  1177.     goto done;
  1178.   }
  1180.   if( (void *)NULL != (void *)fwToken->mdToken->GetFirmwareVersion ) {
  1181.     fwToken->firmwareVersion = fwToken->mdToken->GetFirmwareVersion(
  1182.       fwToken->mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
  1183.   } else {
  1184.     fwToken->firmwareVersion.major = 0;
  1185.     fwToken->firmwareVersion.minor = 1;
  1186.   }
  1188.   rv = fwToken->firmwareVersion;
  1190.  done:
  1191.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  1192.   return rv;
  1193. }
  1195. /*
  1196.  * nssCKFWToken_GetUTCTime
  1197.  *
  1198.  */
  1199. NSS_IMPLEMENT CK_RV
  1200. nssCKFWToken_GetUTCTime
  1201. (
  1202.   NSSCKFWToken *fwToken,
  1203.   CK_CHAR utcTime[16]
  1204. )
  1205. {
  1206.   CK_RV error = CKR_OK;
  1208. #ifdef NSSDEBUG
  1209.   error = nssCKFWToken_verifyPointer(fwToken);
  1210.   if( CKR_OK != error ) {
  1211.     return error;
  1212.   }
  1214.   if( (CK_CHAR_PTR)NULL == utcTime ) {
  1215.     return CKR_ARGUMENTS_BAD;
  1216.   }
  1217. #endif /* DEBUG */
  1219.   if( CK_TRUE != nssCKFWToken_GetHasClockOnToken(fwToken) ) {
  1220.     /* return CKR_DEVICE_ERROR; */
  1221.     (void)nssUTF8_CopyIntoFixedBuffer((NSSUTF8 *)NULL, (char *)utcTime, 16, ' ');
  1222.     return CKR_OK;
  1223.   }
  1225.   if( (void *)NULL == (void *)fwToken->mdToken->GetUTCTime ) {
  1226.     /* It said it had one! */
  1227.     return CKR_GENERAL_ERROR;
  1228.   }
  1230.   error = fwToken->mdToken->GetUTCTime(fwToken->mdToken, fwToken, 
  1231.             fwToken->mdInstance, fwToken->fwInstance, utcTime);
  1232.   if( CKR_OK != error ) {
  1233.     return error;
  1234.   }
  1236.   /* Sanity-check the data */
  1237.   {
  1238.     /* Format is YYYYMMDDhhmmss00 */
  1239.     int i;
  1240.     int Y, M, D, h, m, s, z;
  1241.     static int dims[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  1243.     for( i = 0; i < 16; i++ ) {
  1244.       if( (utcTime[i] < '0') || (utcTime[i] > '9') ) {
  1245.         goto badtime;
  1246.       }
  1247.     }
  1249.     Y = ((utcTime[ 0] - '0') * 1000) + ((utcTime[1] - '0') * 100) +
  1250.         ((utcTime[ 2] - '0') * 10) + (utcTime[ 3] - '0');
  1251.     M = ((utcTime[ 4] - '0') * 10) + (utcTime[ 5] - '0');
  1252.     D = ((utcTime[ 6] - '0') * 10) + (utcTime[ 7] - '0');
  1253.     h = ((utcTime[ 8] - '0') * 10) + (utcTime[ 9] - '0');
  1254.     m = ((utcTime[10] - '0') * 10) + (utcTime[11] - '0');
  1255.     s = ((utcTime[12] - '0') * 10) + (utcTime[13] - '0');
  1256.     z = ((utcTime[14] - '0') * 10) + (utcTime[15] - '0');
  1258.     if( (Y < 1990) || (Y > 3000) ) goto badtime; /* Y3K problem.  heh heh heh */
  1259.     if( (M < 1) || (M > 12) ) goto badtime;
  1260.     if( (D < 1) || (D > 31) ) goto badtime;
  1262.     if( D > dims[M-1] ) goto badtime; /* per-month check */
  1263.     if( (2 == M) && (((Y%4)||!(Y%100))&&(Y%400)) && (D > 28) ) goto badtime; /* leap years */
  1265.     if( (h < 0) || (h > 23) ) goto badtime;
  1266.     if( (m < 0) || (m > 60) ) goto badtime;
  1267.     if( (s < 0) || (s > 61) ) goto badtime;
  1269.     /* 60m and 60 or 61s is only allowed for leap seconds. */
  1270.     if( (60 == m) || (s >= 60) ) {
  1271.       if( (23 != h) || (60 != m) || (s < 60) ) goto badtime;
  1272.       /* leap seconds can only happen on June 30 or Dec 31.. I think */
  1273.       /* if( ((6 != M) || (30 != D)) && ((12 != M) || (31 != D)) ) goto badtime; */
  1274.     }
  1275.   }
  1277.   return CKR_OK;
  1279.  badtime:
  1280.   return CKR_GENERAL_ERROR;
  1281. }
  1283. /*
  1284.  * nssCKFWToken_OpenSession
  1285.  *
  1286.  */
  1287. NSS_IMPLEMENT NSSCKFWSession *
  1288. nssCKFWToken_OpenSession
  1289. (
  1290.   NSSCKFWToken *fwToken,
  1291.   CK_BBOOL rw,
  1292.   CK_VOID_PTR pApplication,
  1293.   CK_NOTIFY Notify,
  1294.   CK_RV *pError
  1295. )
  1296. {
  1297.   NSSCKFWSession *fwSession = (NSSCKFWSession *)NULL;
  1298.   NSSCKMDSession *mdSession;
  1300. #ifdef NSSDEBUG
  1301.   if( (CK_RV *)NULL == pError ) {
  1302.     return (NSSCKFWSession *)NULL;
  1303.   }
  1305.   *pError = nssCKFWToken_verifyPointer(fwToken);
  1306.   if( CKR_OK != *pError ) {
  1307.     return (NSSCKFWSession *)NULL;
  1308.   }
  1310.   switch( rw ) {
  1311.   case CK_TRUE:
  1312.   case CK_FALSE:
  1313.     break;
  1314.   default:
  1315.     *pError = CKR_ARGUMENTS_BAD;
  1316.     return (NSSCKFWSession *)NULL;
  1317.   }
  1318. #endif /* NSSDEBUG */
  1320.   *pError = nssCKFWMutex_Lock(fwToken->mutex);
  1321.   if( CKR_OK != *pError ) {
  1322.     return (NSSCKFWSession *)NULL;
  1323.   }
  1325.   if( CK_TRUE == rw ) {
  1326.     /* Read-write session desired */
  1327.     if( CK_TRUE != nssCKFWToken_GetIsWriteProtected(fwToken) ) {
  1328.       *pError = CKR_TOKEN_WRITE_PROTECTED;
  1329.       goto done;
  1330.     }
  1331.   } else {
  1332.     /* Read-only session desired */
  1333.     if( CKS_RW_SO_FUNCTIONS == nssCKFWToken_GetSessionState(fwToken) ) {
  1334.       *pError = CKR_SESSION_READ_WRITE_SO_EXISTS;
  1335.       goto done;
  1336.     }
  1337.   }
  1339.   /* We could compare sesion counts to any limits we know of, I guess.. */
  1341.   if( (void *)NULL == (void *)fwToken->mdToken->OpenSession ) {
  1342.     /*
  1343.      * I'm not sure that the Module actually needs to implement
  1344.      * mdSessions -- the Framework can keep track of everything 
  1345.      * needed, really.  But I'll sort out that detail later..
  1346.      */
  1347.     *pError = CKR_GENERAL_ERROR;
  1348.     goto done;
  1349.   }
  1351.   fwSession = nssCKFWSession_Create(fwToken, rw, pApplication, Notify, pError);
  1352.   if( (NSSCKFWSession *)NULL == fwSession ) {
  1353.     if( CKR_OK == *pError ) {
  1354.       *pError = CKR_GENERAL_ERROR;
  1355.     }
  1356.     goto done;
  1357.   }
  1359.   mdSession = fwToken->mdToken->OpenSession(fwToken->mdToken, fwToken,
  1360.                 fwToken->mdInstance, fwToken->fwInstance, fwSession,
  1361.                 rw, pError);
  1362.   if( (NSSCKMDSession *)NULL == mdSession ) {
  1363.     (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
  1364.     if( CKR_OK == *pError ) {
  1365.       *pError = CKR_GENERAL_ERROR;
  1366.     }
  1367.     goto done;
  1368.   }
  1370.   *pError = nssCKFWSession_SetMDSession(fwSession, mdSession);
  1371.   if( CKR_OK != *pError ) {
  1372.     if( (void *)NULL != (void *)mdSession->Close ) {
  1373.       mdSession->Close(mdSession, fwSession, fwToken->mdToken, fwToken,
  1374.       fwToken->mdInstance, fwToken->fwInstance);
  1375.     }
  1376.     (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
  1377.     goto done;
  1378.   }
  1380.   *pError = nssCKFWHash_Add(fwToken->sessions, fwSession, fwSession);
  1381.   if( CKR_OK != *pError ) {
  1382.     (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
  1383.     fwSession = (NSSCKFWSession *)NULL;
  1384.     goto done;
  1385.   }
  1387.  done:
  1388.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  1389.   return fwSession;
  1390. }
  1392. /*
  1393.  * nssCKFWToken_GetMechanismCount
  1394.  *
  1395.  */
  1396. NSS_IMPLEMENT CK_ULONG
  1397. nssCKFWToken_GetMechanismCount
  1398. (
  1399.   NSSCKFWToken *fwToken
  1400. )
  1401. {
  1402. #ifdef NSSDEBUG
  1403.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1404.     return 0;
  1405.   }
  1406. #endif /* NSSDEBUG */
  1408.   if( (void *)NULL == fwToken->mdToken->GetMechanismCount ) {
  1409.     return 0;
  1410.   }
  1412.   return fwToken->mdToken->GetMechanismCount(fwToken->mdToken, fwToken,
  1413.     fwToken->mdInstance, fwToken->fwInstance);
  1414. }
  1416. /*
  1417.  * nssCKFWToken_GetMechanismTypes
  1418.  *
  1419.  */
  1420. NSS_IMPLEMENT CK_RV
  1421. nssCKFWToken_GetMechanismTypes
  1422. (
  1423.   NSSCKFWToken *fwToken,
  1424.   CK_MECHANISM_TYPE types[]
  1425. )
  1426. {
  1427. #ifdef NSSDEBUG
  1428.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1429.     return CKR_ARGUMENTS_BAD;
  1430.   }
  1432.   if( (CK_MECHANISM_TYPE *)NULL == types ) {
  1433.     return CKR_ARGUMENTS_BAD;
  1434.   }
  1435. #endif /* NSSDEBUG */
  1437.   if( (void *)NULL == fwToken->mdToken->GetMechanismTypes ) {
  1438.     /*
  1439.      * This should only be called with a sufficiently-large
  1440.      * "types" array, which can only be done if GetMechanismCount
  1441.      * is implemented.  If that's implemented (and returns nonzero),
  1442.      * then this should be too.  So return an error.
  1443.      */
  1444.     return CKR_GENERAL_ERROR;
  1445.   }
  1447.   return fwToken->mdToken->GetMechanismTypes(fwToken->mdToken, fwToken,
  1448.     fwToken->mdInstance, fwToken->fwInstance, types);
  1449. }
  1452. /*
  1453.  * nssCKFWToken_GetMechanism
  1454.  *
  1455.  */
  1456. NSS_IMPLEMENT NSSCKFWMechanism *
  1457. nssCKFWToken_GetMechanism
  1458. (
  1459.   NSSCKFWToken *fwToken,
  1460.   CK_MECHANISM_TYPE which,
  1461.   CK_RV *pError
  1462. )
  1463. {
  1464.   /* XXX fgmr */
  1465.   return (NSSCKFWMechanism *)NULL;
  1466. }
  1468. NSS_IMPLEMENT CK_RV
  1469. nssCKFWToken_SetSessionState
  1470. (
  1471.   NSSCKFWToken *fwToken,
  1472.   CK_STATE newState
  1473. )
  1474. {
  1475.   CK_RV error = CKR_OK;
  1477. #ifdef NSSDEBUG
  1478.   error = nssCKFWToken_verifyPointer(fwToken);
  1479.   if( CKR_OK != error ) {
  1480.     return error;
  1481.   }
  1483.   switch( newState ) {
  1484.   case CKS_RO_PUBLIC_SESSION:
  1485.   case CKS_RO_USER_FUNCTIONS:
  1486.   case CKS_RW_PUBLIC_SESSION:
  1487.   case CKS_RW_USER_FUNCTIONS:
  1488.   case CKS_RW_SO_FUNCTIONS:
  1489.     break;
  1490.   default:
  1491.     return CKR_ARGUMENTS_BAD;
  1492.   }
  1493. #endif /* NSSDEBUG */
  1495.   error = nssCKFWMutex_Lock(fwToken->mutex);
  1496.   if( CKR_OK != error ) {
  1497.     return error;
  1498.   }
  1500.   fwToken->state = newState;
  1501.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  1502.   return CKR_OK;
  1503. }
  1505. /*
  1506.  * nssCKFWToken_RemoveSession
  1507.  *
  1508.  */
  1509. NSS_IMPLEMENT CK_RV
  1510. nssCKFWToken_RemoveSession
  1511. (
  1512.   NSSCKFWToken *fwToken,
  1513.   NSSCKFWSession *fwSession
  1514. )
  1515. {
  1516.   CK_RV error = CKR_OK;
  1518. #ifdef NSSDEBUG
  1519.   error = nssCKFWToken_verifyPointer(fwToken);
  1520.   if( CKR_OK != error ) {
  1521.     return error;
  1522.   }
  1524.   error = nssCKFWSession_verifyPointer(fwSession);
  1525.   if( CKR_OK != error ) {
  1526.     return error;
  1527.   }
  1528. #endif /* NSSDEBUG */
  1530.   error = nssCKFWMutex_Lock(fwToken->mutex);
  1531.   if( CKR_OK != error ) {
  1532.     return error;
  1533.   }
  1535.   if( CK_TRUE != nssCKFWHash_Exists(fwToken->sessions, fwSession) ) {
  1536.     error = CKR_SESSION_HANDLE_INVALID;
  1537.     goto done;
  1538.   }
  1540.   nssCKFWHash_Remove(fwToken->sessions, fwSession);
  1541.   fwToken->sessionCount--;
  1543.   if( nssCKFWSession_IsRWSession(fwSession) ) {
  1544.     fwToken->rwSessionCount--;
  1545.   }
  1547.   if( 0 == fwToken->sessionCount ) {
  1548.     fwToken->rwSessionCount = 0; /* sanity */
  1549.     fwToken->state = CKS_RO_PUBLIC_SESSION; /* some default */
  1550.   }
  1552.   error = CKR_OK;
  1554.  done:
  1555.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  1556.   return error;
  1557. }
  1559. static void
  1560. nss_ckfwtoken_session_iterator
  1561. (
  1562.   const void *key,
  1563.   void *value,
  1564.   void *closure
  1565. )
  1566. {
  1567.   /*
  1568.    * Remember that the fwToken->mutex is locked
  1569.    */
  1570.   NSSCKFWSession *fwSession = (NSSCKFWSession *)value;
  1571.   (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
  1572.   return;
  1573. }
  1575. /*
  1576.  * nssCKFWToken_CloseAllSessions
  1577.  *
  1578.  */
  1579. NSS_IMPLEMENT CK_RV
  1580. nssCKFWToken_CloseAllSessions
  1581. (
  1582.   NSSCKFWToken *fwToken
  1583. )
  1584. {
  1585.   CK_RV error = CKR_OK;
  1587. #ifdef NSSDEBUG
  1588.   error = nssCKFWToken_verifyPointer(fwToken);
  1589.   if( CKR_OK != error ) {
  1590.     return error;
  1591.   }
  1592. #endif /* NSSDEBUG */
  1594.   error = nssCKFWMutex_Lock(fwToken->mutex);
  1595.   if( CKR_OK != error ) {
  1596.     return error;
  1597.   }
  1599.   nssCKFWHash_Iterate(fwToken->sessions, nss_ckfwtoken_session_iterator, (void *)NULL);
  1601.   nssCKFWHash_Destroy(fwToken->sessions);
  1603.   fwToken->sessions = nssCKFWHash_Create(fwToken->fwInstance, fwToken->arena, &error);
  1604.   if( (nssCKFWHash *)NULL == fwToken->sessions ) {
  1605.     if( CKR_OK == error ) {
  1606.       error = CKR_GENERAL_ERROR;
  1607.     }
  1608.     goto done;
  1609.   }
  1611.   fwToken->state = CKS_RO_PUBLIC_SESSION; /* some default */
  1612.   fwToken->sessionCount = 0;
  1613.   fwToken->rwSessionCount = 0;
  1615.   error = CKR_OK;
  1617.  done:
  1618.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  1619.   return error;
  1620. }
  1622. /*
  1623.  * nssCKFWToken_GetSessionCount
  1624.  *
  1625.  */
  1626. NSS_IMPLEMENT CK_ULONG
  1627. nssCKFWToken_GetSessionCount
  1628. (
  1629.   NSSCKFWToken *fwToken
  1630. )
  1631. {
  1632.   CK_ULONG rv;
  1634. #ifdef NSSDEBUG
  1635.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1636.     return (CK_ULONG)0;
  1637.   }
  1638. #endif /* NSSDEBUG */
  1640.   if( CKR_OK != nssCKFWMutex_Lock(fwToken->mutex) ) {
  1641.     return (CK_ULONG)0;
  1642.   }
  1644.   rv = fwToken->sessionCount;
  1645.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  1646.   return rv;
  1647. }
  1649. /*
  1650.  * nssCKFWToken_GetRwSessionCount
  1651.  *
  1652.  */
  1653. NSS_IMPLEMENT CK_ULONG
  1654. nssCKFWToken_GetRwSessionCount
  1655. (
  1656.   NSSCKFWToken *fwToken
  1657. )
  1658. {
  1659.   CK_ULONG rv;
  1661. #ifdef NSSDEBUG
  1662.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1663.     return (CK_ULONG)0;
  1664.   }
  1665. #endif /* NSSDEBUG */
  1667.   if( CKR_OK != nssCKFWMutex_Lock(fwToken->mutex) ) {
  1668.     return (CK_ULONG)0;
  1669.   }
  1671.   rv = fwToken->rwSessionCount;
  1672.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  1673.   return rv;
  1674. }
  1676. /*
  1677.  * nssCKFWToken_GetRoSessionCount
  1678.  *
  1679.  */
  1680. NSS_IMPLEMENT CK_ULONG
  1681. nssCKFWToken_GetRoSessionCount
  1682. (
  1683.   NSSCKFWToken *fwToken
  1684. )
  1685. {
  1686.   CK_ULONG rv;
  1688. #ifdef NSSDEBUG
  1689.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1690.     return (CK_ULONG)0;
  1691.   }
  1692. #endif /* NSSDEBUG */
  1694.   if( CKR_OK != nssCKFWMutex_Lock(fwToken->mutex) ) {
  1695.     return (CK_ULONG)0;
  1696.   }
  1698.   rv = fwToken->sessionCount - fwToken->rwSessionCount;
  1699.   (void)nssCKFWMutex_Unlock(fwToken->mutex);
  1700.   return rv;
  1701. }
  1703. /*
  1704.  * nssCKFWToken_GetSessionObjectHash
  1705.  *
  1706.  */
  1707. NSS_IMPLEMENT nssCKFWHash *
  1708. nssCKFWToken_GetSessionObjectHash
  1709. (
  1710.   NSSCKFWToken *fwToken
  1711. )
  1712. {
  1713. #ifdef NSSDEBUG
  1714.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1715.     return (nssCKFWHash *)NULL;
  1716.   }
  1717. #endif /* NSSDEBUG */
  1719.   return fwToken->sessionObjectHash;
  1720. }
  1722. /*
  1723.  * nssCKFWToken_GetMDObjectHash
  1724.  *
  1725.  */
  1726. NSS_IMPLEMENT nssCKFWHash *
  1727. nssCKFWToken_GetMDObjectHash
  1728. (
  1729.   NSSCKFWToken *fwToken
  1730. )
  1731. {
  1732. #ifdef NSSDEBUG
  1733.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1734.     return (nssCKFWHash *)NULL;
  1735.   }
  1736. #endif /* NSSDEBUG */
  1738.   return fwToken->mdObjectHash;
  1739. }
  1741. /*
  1742.  * nssCKFWToken_GetObjectHandleHash
  1743.  *
  1744.  */
  1745. NSS_IMPLEMENT nssCKFWHash *
  1746. nssCKFWToken_GetObjectHandleHash
  1747. (
  1748.   NSSCKFWToken *fwToken
  1749. )
  1750. {
  1751. #ifdef NSSDEBUG
  1752.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1753.     return (nssCKFWHash *)NULL;
  1754.   }
  1755. #endif /* NSSDEBUG */
  1757.   return fwToken->mdObjectHash;
  1758. }
  1760. /*
  1761.  * NSSCKFWToken_GetMDToken
  1762.  *
  1763.  */
  1765. NSS_IMPLEMENT NSSCKMDToken *
  1766. NSSCKFWToken_GetMDToken
  1767. (
  1768.   NSSCKFWToken *fwToken
  1769. )
  1770. {
  1771. #ifdef DEBUG
  1772.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1773.     return (NSSCKMDToken *)NULL;
  1774.   }
  1775. #endif /* DEBUG */
  1777.   return nssCKFWToken_GetMDToken(fwToken);
  1778. }
  1780. /*
  1781.  * NSSCKFWToken_GetArena
  1782.  *
  1783.  */
  1785. NSS_IMPLEMENT NSSArena *
  1786. NSSCKFWToken_GetArena
  1787. (
  1788.   NSSCKFWToken *fwToken,
  1789.   CK_RV *pError
  1790. )
  1791. {
  1792. #ifdef DEBUG
  1793.   if( (CK_RV *)NULL == pError ) {
  1794.     return (NSSArena *)NULL;
  1795.   }
  1797.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1798.     *pError = CKR_ARGUMENTS_BAD;
  1799.     return (NSSArena *)NULL;
  1800.   }
  1801. #endif /* DEBUG */
  1803.   return nssCKFWToken_GetArena(fwToken, pError);
  1804. }
  1806. /*
  1807.  * NSSCKFWToken_GetFWSlot
  1808.  *
  1809.  */
  1811. NSS_IMPLEMENT NSSCKFWSlot *
  1812. NSSCKFWToken_GetFWSlot
  1813. (
  1814.   NSSCKFWToken *fwToken
  1815. )
  1816. {
  1817. #ifdef DEBUG
  1818.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1819.     return (NSSCKFWSlot *)NULL;
  1820.   }
  1821. #endif /* DEBUG */
  1823.   return nssCKFWToken_GetFWSlot(fwToken);
  1824. }
  1826. /*
  1827.  * NSSCKFWToken_GetMDSlot
  1828.  *
  1829.  */
  1831. NSS_IMPLEMENT NSSCKMDSlot *
  1832. NSSCKFWToken_GetMDSlot
  1833. (
  1834.   NSSCKFWToken *fwToken
  1835. )
  1836. {
  1837. #ifdef DEBUG
  1838.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1839.     return (NSSCKMDSlot *)NULL;
  1840.   }
  1841. #endif /* DEBUG */
  1843.   return nssCKFWToken_GetMDSlot(fwToken);
  1844. }
  1846. /*
  1847.  * NSSCKFWToken_GetSessionState
  1848.  *
  1849.  */
  1851. NSS_IMPLEMENT CK_STATE
  1852. NSSCKFWSession_GetSessionState
  1853. (
  1854.   NSSCKFWToken *fwToken
  1855. )
  1856. {
  1857. #ifdef DEBUG
  1858.   if( CKR_OK != nssCKFWToken_verifyPointer(fwToken) ) {
  1859.     return CKS_RO_PUBLIC_SESSION;
  1860.   }
  1861. #endif /* DEBUG */
  1863.   return nssCKFWToken_GetSessionState(fwToken);
  1864. }