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

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

CA认证

开发平台：

WINDOWS

object.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: object.c,v $ $Revision: 1.4 $ $Date: 2000/05/16 01:54:45 $ $Name: NSS_3_1_1_RTM $";
  36. #endif /* DEBUG */
  38. /*
  39.  * object.c
  40.  *
  41.  * This file implements the NSSCKFWObject type and methods.
  42.  */
  44. #ifndef CK_T
  45. #include "ck.h"
  46. #endif /* CK_T */
  48. /*
  49.  * NSSCKFWObject
  50.  *
  51.  * -- create/destroy --
  52.  *  nssCKFWObject_Create
  53.  *  nssCKFWObject_Finalize
  54.  *  nssCKFWObject_Destroy
  55.  *
  56.  * -- public accessors --
  57.  *  NSSCKFWObject_GetMDObject
  58.  *  NSSCKFWObject_GetArena
  59.  *  NSSCKFWObject_IsTokenObject
  60.  *  NSSCKFWObject_GetAttributeCount
  61.  *  NSSCKFWObject_GetAttributeTypes
  62.  *  NSSCKFWObject_GetAttributeSize
  63.  *  NSSCKFWObject_GetAttribute
  64.  *  NSSCKFWObject_SetAttribute
  65.  *  NSSCKFWObject_GetObjectSize
  66.  *
  67.  * -- implement public accessors --
  68.  *  nssCKFWObject_GetMDObject
  69.  *  nssCKFWObject_GetArena
  70.  *
  71.  * -- private accessors --
  72.  *  nssCKFWObject_SetHandle
  73.  *  nssCKFWObject_GetHandle
  74.  *
  75.  * -- module fronts --
  76.  *  nssCKFWObject_IsTokenObject
  77.  *  nssCKFWObject_GetAttributeCount
  78.  *  nssCKFWObject_GetAttributeTypes
  79.  *  nssCKFWObject_GetAttributeSize
  80.  *  nssCKFWObject_GetAttribute
  81.  *  nssCKFWObject_SetAttribute
  82.  *  nssCKFWObject_GetObjectSize
  83.  */
  85. struct NSSCKFWObjectStr {
  86.   NSSCKFWMutex *mutex; /* merely to serialise the MDObject calls */
  87.   NSSArena *arena;
  88.   NSSCKMDObject *mdObject;
  89.   NSSCKMDSession *mdSession;
  90.   NSSCKFWSession *fwSession;
  91.   NSSCKMDToken *mdToken;
  92.   NSSCKFWToken *fwToken;
  93.   NSSCKMDInstance *mdInstance;
  94.   NSSCKFWInstance *fwInstance;
  95.   CK_OBJECT_HANDLE hObject;
  96. };
  98. #ifdef DEBUG
  99. /*
  100.  * But first, the pointer-tracking stuff.
  101.  *
  102.  * NOTE: the pointer-tracking support in NSS/base currently relies
  103.  * upon NSPR's CallOnce support.  That, however, relies upon NSPR's
  104.  * locking, which is tied into the runtime.  We need a pointer-tracker
  105.  * implementation that uses the locks supplied through C_Initialize.
  106.  * That support, however, can be filled in later.  So for now, I'll
  107.  * just do this routines as no-ops.
  108.  */
  110. static CK_RV
  111. object_add_pointer
  112. (
  113.   const NSSCKFWObject *fwObject
  114. )
  115. {
  116.   return CKR_OK;
  117. }
  119. static CK_RV
  120. object_remove_pointer
  121. (
  122.   const NSSCKFWObject *fwObject
  123. )
  124. {
  125.   return CKR_OK;
  126. }
  128. NSS_IMPLEMENT CK_RV
  129. nssCKFWObject_verifyPointer
  130. (
  131.   const NSSCKFWObject *fwObject
  132. )
  133. {
  134.   return CKR_OK;
  135. }
  137. #endif /* DEBUG */
  140. /*
  141.  * nssCKFWObject_Create
  142.  *
  143.  */
  144. NSS_IMPLEMENT NSSCKFWObject *
  145. nssCKFWObject_Create
  146. (
  147.   NSSArena *arena,
  148.   NSSCKMDObject *mdObject,
  149.   NSSCKFWSession *fwSession,
  150.   NSSCKFWToken *fwToken,
  151.   NSSCKFWInstance *fwInstance,
  152.   CK_RV *pError
  153. )
  154. {
  155.   NSSCKFWObject *fwObject;
  156.   nssCKFWHash *mdObjectHash;
  158. #ifdef NSSDEBUG
  159.   if( (CK_RV *)NULL == pError ) {
  160.     return (NSSCKFWObject *)NULL;
  161.   }
  163.   if( PR_SUCCESS != nssArena_verifyPointer(arena) ) {
  164.     *pError = CKR_ARGUMENTS_BAD;
  165.     return (NSSCKFWObject *)NULL;
  166.   }
  167. #endif /* NSSDEBUG */
  169.   mdObjectHash = nssCKFWToken_GetMDObjectHash(fwToken);
  170.   if( (nssCKFWHash *)NULL == mdObjectHash ) {
  171.     *pError = CKR_GENERAL_ERROR;
  172.     return (NSSCKFWObject *)NULL;
  173.   }
  175.   if( nssCKFWHash_Exists(mdObjectHash, mdObject) ) {
  176.     fwObject = nssCKFWHash_Lookup(mdObjectHash, mdObject);
  177.     return fwObject;
  178.   }
  180.   fwObject = nss_ZNEW(arena, NSSCKFWObject);
  181.   if( (NSSCKFWObject *)NULL == fwObject ) {
  182.     *pError = CKR_HOST_MEMORY;
  183.     return (NSSCKFWObject *)NULL;
  184.   }
  186.   fwObject->arena = arena;
  187.   fwObject->mdObject = mdObject;
  188.   fwObject->fwSession = fwSession;
  190.   if( (NSSCKFWSession *)NULL != fwSession ) {
  191.     fwObject->mdSession = nssCKFWSession_GetMDSession(fwSession);
  192.   }
  194.   fwObject->fwToken = fwToken;
  196.   if( (NSSCKFWToken *)NULL != fwToken ) {
  197.     fwObject->mdToken = nssCKFWToken_GetMDToken(fwToken);
  198.   }
  200.   fwObject->fwInstance = fwInstance;
  201.   fwObject->mdInstance = nssCKFWInstance_GetMDInstance(fwInstance);
  202.   fwObject->mutex = nssCKFWInstance_CreateMutex(fwInstance, arena, pError);
  203.   if( (NSSCKFWMutex *)NULL == fwObject->mutex ) {
  204.     if( CKR_OK == *pError ) {
  205.       *pError = CKR_GENERAL_ERROR;
  206.     }
  207.     return (NSSCKFWObject *)NULL;
  208.   }
  210.   *pError = nssCKFWHash_Add(mdObjectHash, mdObject, fwObject);
  211.   if( CKR_OK != *pError ) {
  212.     nss_ZFreeIf(fwObject);
  213.     return (NSSCKFWObject *)NULL;
  214.   }
  216. #ifdef DEBUG
  217.   *pError = object_add_pointer(fwObject);
  218.   if( CKR_OK != *pError ) {
  219.     nssCKFWHash_Remove(mdObjectHash, mdObject);
  220.     nss_ZFreeIf(fwObject);
  221.     return (NSSCKFWObject *)NULL;
  222.   }
  223. #endif /* DEBUG */
  225.   *pError = CKR_OK;
  226.   return fwObject;
  227. }
  229. /*
  230.  * nssCKFWObject_Finalize
  231.  *
  232.  */
  233. NSS_IMPLEMENT void
  234. nssCKFWObject_Finalize
  235. (
  236.   NSSCKFWObject *fwObject
  237. )
  238. {
  239.   nssCKFWHash *mdObjectHash;
  241. #ifdef NSSDEBUG
  242.   if( CKR_OK != nssCKFWObject_verifyPointer(fwObject) ) {
  243.     return;
  244.   }
  245. #endif /* NSSDEBUG */
  247.   (void)nssCKFWMutex_Destroy(fwObject->mutex);
  249.   if( (void *)NULL != (void *)fwObject->mdObject->Finalize ) {
  250.     fwObject->mdObject->Finalize(fwObject->mdObject, fwObject,
  251.       fwObject->mdSession, fwObject->fwSession, fwObject->mdToken,
  252.       fwObject->fwToken, fwObject->mdInstance, fwObject->fwInstance);
  253.   }
  255.   mdObjectHash = nssCKFWToken_GetMDObjectHash(fwObject->fwToken);
  256.   if( (nssCKFWHash *)NULL != mdObjectHash ) {
  257.     nssCKFWHash_Remove(mdObjectHash, fwObject->mdObject);
  258.   }
  260.   nssCKFWSession_DeregisterSessionObject(fwObject->fwSession, fwObject);
  261.   nss_ZFreeIf(fwObject);
  263. #ifdef DEBUG
  264.   (void)object_remove_pointer(fwObject);
  265. #endif /* DEBUG */
  267.   return;
  268. }
  270. /*
  271.  * nssCKFWObject_Destroy
  272.  *
  273.  */
  274. NSS_IMPLEMENT void
  275. nssCKFWObject_Destroy
  276. (
  277.   NSSCKFWObject *fwObject
  278. )
  279. {
  280.   nssCKFWHash *mdObjectHash;
  282. #ifdef NSSDEBUG
  283.   if( CKR_OK != nssCKFWObject_verifyPointer(fwObject) ) {
  284.     return;
  285.   }
  286. #endif /* NSSDEBUG */
  288.   (void)nssCKFWMutex_Destroy(fwObject->mutex);
  290.   if( (void *)NULL != (void *)fwObject->mdObject->Destroy ) {
  291.     fwObject->mdObject->Destroy(fwObject->mdObject, fwObject,
  292.       fwObject->mdSession, fwObject->fwSession, fwObject->mdToken,
  293.       fwObject->fwToken, fwObject->mdInstance, fwObject->fwInstance);
  294.   }
  296.   mdObjectHash = nssCKFWToken_GetMDObjectHash(fwObject->fwToken);
  297.   if( (nssCKFWHash *)NULL != mdObjectHash ) {
  298.     nssCKFWHash_Remove(mdObjectHash, fwObject->mdObject);
  299.   }
  301.   nssCKFWSession_DeregisterSessionObject(fwObject->fwSession, fwObject);
  302.   nss_ZFreeIf(fwObject);
  304. #ifdef DEBUG
  305.   (void)object_remove_pointer(fwObject);
  306. #endif /* DEBUG */
  308.   return;
  309. }
  311. /*
  312.  * nssCKFWObject_GetMDObject
  313.  *
  314.  */
  315. NSS_IMPLEMENT NSSCKMDObject *
  316. nssCKFWObject_GetMDObject
  317. (
  318.   NSSCKFWObject *fwObject
  319. )
  320. {
  321. #ifdef NSSDEBUG
  322.   if( CKR_OK != nssCKFWObject_verifyPointer(fwObject) ) {
  323.     return (NSSCKMDObject *)NULL;
  324.   }
  325. #endif /* NSSDEBUG */
  327.   return fwObject->mdObject;
  328. }
  330. /*
  331.  * nssCKFWObject_GetArena
  332.  *
  333.  */
  334. NSS_IMPLEMENT NSSArena *
  335. nssCKFWObject_GetArena
  336. (
  337.   NSSCKFWObject *fwObject,
  338.   CK_RV *pError
  339. )
  340. {
  341. #ifdef NSSDEBUG
  342.   if( (CK_RV *)NULL == pError ) {
  343.     return (NSSArena *)NULL;
  344.   }
  346.   *pError = nssCKFWObject_verifyPointer(fwObject);
  347.   if( CKR_OK != *pError ) {
  348.     return (NSSArena *)NULL;
  349.   }
  350. #endif /* NSSDEBUG */
  352.   return fwObject->arena;
  353. }
  355. /*
  356.  * nssCKFWObject_SetHandle
  357.  *
  358.  */
  359. NSS_IMPLEMENT CK_RV
  360. nssCKFWObject_SetHandle
  361. (
  362.   NSSCKFWObject *fwObject,
  363.   CK_OBJECT_HANDLE hObject
  364. )
  365. {
  366. #ifdef NSSDEBUG
  367.   CK_RV error = CKR_OK;
  368. #endif /* NSSDEBUG */
  370. #ifdef NSSDEBUG
  371.   error = nssCKFWObject_verifyPointer(fwObject);
  372.   if( CKR_OK != error ) {
  373.     return error;
  374.   }
  375. #endif /* NSSDEBUG */
  377.   if( (CK_OBJECT_HANDLE)0 != fwObject->hObject ) {
  378.     return CKR_GENERAL_ERROR;
  379.   }
  381.   fwObject->hObject = hObject;
  383.   return CKR_OK;
  384. }
  386. /*
  387.  * nssCKFWObject_GetHandle
  388.  *
  389.  */
  390. NSS_IMPLEMENT CK_OBJECT_HANDLE
  391. nssCKFWObject_GetHandle
  392. (
  393.   NSSCKFWObject *fwObject
  394. )
  395. {
  396. #ifdef NSSDEBUG
  397.   if( CKR_OK != nssCKFWObject_verifyPointer(fwObject) ) {
  398.     return (CK_OBJECT_HANDLE)0;
  399.   }
  400. #endif /* NSSDEBUG */
  402.   return fwObject->hObject;
  403. }
  405. /*
  406.  * nssCKFWObject_IsTokenObject
  407.  *
  408.  */
  409. NSS_IMPLEMENT CK_BBOOL
  410. nssCKFWObject_IsTokenObject
  411. (
  412.   NSSCKFWObject *fwObject
  413. )
  414. {
  415.   CK_BBOOL b = CK_FALSE;
  417. #ifdef NSSDEBUG
  418.   if( CKR_OK != nssCKFWObject_verifyPointer(fwObject) ) {
  419.     return CK_FALSE;
  420.   }
  421. #endif /* NSSDEBUG */
  423.   if( CKR_OK != nssCKFWMutex_Lock(fwObject->mutex) ) {
  424.     return CK_FALSE;
  425.   }
  427.   if( (void *)NULL == (void *)fwObject->mdObject->IsTokenObject ) {
  428.     NSSItem item;
  429.     NSSItem *pItem;
  430.     CK_RV rv = CKR_OK;
  432.     item.data = (void *)&b;
  433.     item.size = sizeof(b);
  435.     pItem = nssCKFWObject_GetAttribute(fwObject, CKA_TOKEN, &item, 
  436.       (NSSArena *)NULL, &rv);
  437.     if( (NSSItem *)NULL == pItem ) {
  438.       /* Error of some type */
  439.       b = CK_FALSE;
  440.       goto done;
  441.     }
  443.     goto done;
  444.   }
  446.   b = fwObject->mdObject->IsTokenObject(fwObject->mdObject, fwObject, 
  447.     fwObject->mdSession, fwObject->fwSession, fwObject->mdToken,
  448.     fwObject->fwToken, fwObject->mdInstance, fwObject->fwInstance);
  450.  done:
  451.   (void)nssCKFWMutex_Unlock(fwObject->mutex);
  452.   return b;
  453. }
  455. /*
  456.  * nssCKFWObject_GetAttributeCount
  457.  *
  458.  */
  459. NSS_IMPLEMENT CK_ULONG
  460. nssCKFWObject_GetAttributeCount
  461. (
  462.   NSSCKFWObject *fwObject,
  463.   CK_RV *pError
  464. )
  465. {
  466.   CK_ULONG rv;
  468. #ifdef NSSDEBUG
  469.   if( (CK_RV *)NULL == pError ) {
  470.     return (CK_ULONG)0;
  471.   }
  473.   *pError = nssCKFWObject_verifyPointer(fwObject);
  474.   if( CKR_OK != *pError ) {
  475.     return (CK_ULONG)0;
  476.   }
  477. #endif /* NSSDEBUG */
  479.   if( (void *)NULL == (void *)fwObject->mdObject->GetAttributeCount ) {
  480.     *pError = CKR_GENERAL_ERROR;
  481.     return (CK_ULONG)0;
  482.   }
  484.   *pError = nssCKFWMutex_Lock(fwObject->mutex);
  485.   if( CKR_OK != *pError ) {
  486.     return (CK_ULONG)0;
  487.   }
  489.   rv = fwObject->mdObject->GetAttributeCount(fwObject->mdObject, fwObject,
  490.     fwObject->mdSession, fwObject->fwSession, fwObject->mdToken, 
  491.     fwObject->fwToken, fwObject->mdInstance, fwObject->fwInstance,
  492.     pError);
  494.   (void)nssCKFWMutex_Unlock(fwObject->mutex);
  495.   return rv;
  496. }
  498. /*
  499.  * nssCKFWObject_GetAttributeTypes
  500.  *
  501.  */
  502. NSS_IMPLEMENT CK_RV
  503. nssCKFWObject_GetAttributeTypes
  504. (
  505.   NSSCKFWObject *fwObject,
  506.   CK_ATTRIBUTE_TYPE_PTR typeArray,
  507.   CK_ULONG ulCount
  508. )
  509. {
  510.   CK_RV error = CKR_OK;
  512. #ifdef NSSDEBUG
  513.   error = nssCKFWObject_verifyPointer(fwObject);
  514.   if( CKR_OK != error ) {
  515.     return error;
  516.   }
  518.   if( (CK_ATTRIBUTE_TYPE_PTR)NULL == typeArray ) {
  519.     return CKR_ARGUMENTS_BAD;
  520.   }
  521. #endif /* NSSDEBUG */
  523.   if( (void *)NULL == (void *)fwObject->mdObject->GetAttributeTypes ) {
  524.     return CKR_GENERAL_ERROR;
  525.   }
  527.   error = nssCKFWMutex_Lock(fwObject->mutex);
  528.   if( CKR_OK != error ) {
  529.     return error;
  530.   }
  532.   error = fwObject->mdObject->GetAttributeTypes(fwObject->mdObject, fwObject,
  533.     fwObject->mdSession, fwObject->fwSession, fwObject->mdToken, 
  534.     fwObject->fwToken, fwObject->mdInstance, fwObject->fwInstance,
  535.     typeArray, ulCount);
  537.   (void)nssCKFWMutex_Unlock(fwObject->mutex);
  538.   return error;
  539. }
  541. /*
  542.  * nssCKFWObject_GetAttributeSize
  543.  *
  544.  */
  545. NSS_IMPLEMENT CK_ULONG
  546. nssCKFWObject_GetAttributeSize
  547. (
  548.   NSSCKFWObject *fwObject,
  549.   CK_ATTRIBUTE_TYPE attribute,
  550.   CK_RV *pError
  551. )
  552. {
  553.   CK_ULONG rv;
  555. #ifdef NSSDEBUG
  556.   if( (CK_RV *)NULL == pError ) {
  557.     return (CK_ULONG)0;
  558.   }
  560.   *pError = nssCKFWObject_verifyPointer(fwObject);
  561.   if( CKR_OK != *pError ) {
  562.     return (CK_ULONG)0;
  563.   }
  564. #endif /* NSSDEBUG */
  566.   if( (void *)NULL == (void *)fwObject->mdObject->GetAttributeSize ) {
  567.     *pError = CKR_GENERAL_ERROR;
  568.     return (CK_ULONG )0;
  569.   }
  571.   *pError = nssCKFWMutex_Lock(fwObject->mutex);
  572.   if( CKR_OK != *pError ) {
  573.     return (CK_ULONG)0;
  574.   }
  576.   rv = fwObject->mdObject->GetAttributeSize(fwObject->mdObject, fwObject,
  577.     fwObject->mdSession, fwObject->fwSession, fwObject->mdToken, 
  578.     fwObject->fwToken, fwObject->mdInstance, fwObject->fwInstance,
  579.     attribute, pError);
  581.   (void)nssCKFWMutex_Unlock(fwObject->mutex);
  582.   return rv;
  583. }
  585. /*
  586.  * nssCKFWObject_GetAttribute
  587.  *
  588.  * Usual NSS allocation rules:
  589.  * If itemOpt is not NULL, it will be returned; otherwise an NSSItem
  590.  * will be allocated.  If itemOpt is not NULL but itemOpt->data is,
  591.  * the buffer will be allocated; otherwise, the buffer will be used.
  592.  * Any allocations will come from the optional arena, if one is
  593.  * specified.
  594.  */
  595. NSS_IMPLEMENT NSSItem *
  596. nssCKFWObject_GetAttribute
  597. (
  598.   NSSCKFWObject *fwObject,
  599.   CK_ATTRIBUTE_TYPE attribute,
  600.   NSSItem *itemOpt,
  601.   NSSArena *arenaOpt,
  602.   CK_RV *pError
  603. )
  604. {
  605.   NSSItem *rv = (NSSItem *)NULL;
  606.   NSSItem *mdItem;
  608. #ifdef NSSDEBUG
  609.   if( (CK_RV *)NULL == pError ) {
  610.     return (NSSItem *)NULL;
  611.   }
  613.   *pError = nssCKFWObject_verifyPointer(fwObject);
  614.   if( CKR_OK != *pError ) {
  615.     return (NSSItem *)NULL;
  616.   }
  617. #endif /* NSSDEBUG */
  619.   if( (void *)NULL == (void *)fwObject->mdObject->GetAttributeSize ) {
  620.     *pError = CKR_GENERAL_ERROR;
  621.     return (NSSItem *)NULL;
  622.   }
  624.   *pError = nssCKFWMutex_Lock(fwObject->mutex);
  625.   if( CKR_OK != *pError ) {
  626.     return (NSSItem *)NULL;
  627.   }
  629.   mdItem = fwObject->mdObject->GetAttribute(fwObject->mdObject, fwObject,
  630.     fwObject->mdSession, fwObject->fwSession, fwObject->mdToken, 
  631.     fwObject->fwToken, fwObject->mdInstance, fwObject->fwInstance,
  632.     attribute, pError);
  634.   if( (NSSItem *)NULL == mdItem ) {
  635.     if( CKR_OK == *pError ) {
  636.       *pError = CKR_GENERAL_ERROR;
  637.     }
  639.     goto done;
  640.   }
  642.   if( (NSSItem *)NULL == itemOpt ) {
  643.     rv = nss_ZNEW(arenaOpt, NSSItem);
  644.     if( (NSSItem *)NULL == rv ) {
  645.       *pError = CKR_HOST_MEMORY;
  646.       goto done;
  647.     }
  648.   } else {
  649.     rv = itemOpt;
  650.   }
  652.   if( (void *)NULL == rv->data ) {
  653.     rv->size = mdItem->size;
  654.     rv->data = nss_ZAlloc(arenaOpt, rv->size);
  655.     if( (void *)NULL == rv->data ) {
  656.       *pError = CKR_HOST_MEMORY;
  657.       if( (NSSItem *)NULL == itemOpt ) {
  658.         nss_ZFreeIf(rv);
  659.       }
  660.       rv = (NSSItem *)NULL;
  661.       goto done;
  662.     }
  663.   } else {
  664.     if( rv->size >= mdItem->size ) {
  665.       rv->size = mdItem->size;
  666.     } else {
  667.       *pError = CKR_BUFFER_TOO_SMALL;
  668.       /* Should we set rv->size to mdItem->size? */
  669.       /* rv can't have been allocated */
  670.       rv = (NSSItem *)NULL;
  671.       goto done;
  672.     }
  673.   }
  675.   (void)nsslibc_memcpy(rv->data, mdItem->data, rv->size);
  677.  done:
  678.   (void)nssCKFWMutex_Unlock(fwObject->mutex);
  679.   return rv;
  680. }
  682. /*
  683.  * nssCKFWObject_SetAttribute
  684.  *
  685.  */
  686. NSS_IMPLEMENT CK_RV
  687. nssCKFWObject_SetAttribute
  688. (
  689.   NSSCKFWObject *fwObject,
  690.   CK_ATTRIBUTE_TYPE attribute,
  691.   NSSItem *value
  692. )
  693. {
  694.   CK_RV error = CKR_OK;
  696. #ifdef NSSDEBUG
  697.   error = nssCKFWObject_verifyPointer(fwObject);
  698.   if( CKR_OK != error ) {
  699.     return error;
  700.   }
  701. #endif /* NSSDEBUG */
  703.   if( CKA_TOKEN == attribute ) {
  704.     /*
  705.      * We're changing from a session object to a token object or 
  706.      * vice-versa.
  707.      */
  709.     CK_ATTRIBUTE a;
  710.     NSSCKFWObject *newFwObject;
  711.     NSSCKFWObject swab;
  713.     a.type = CKA_TOKEN;
  714.     a.pValue = value->data;
  715.     a.ulValueLen = value->size;
  717.     newFwObject = nssCKFWSession_CopyObject(fwObject->fwSession, fwObject,
  718.                     &a, 1, &error);
  719.     if( (NSSCKFWObject *)NULL == newFwObject ) {
  720.       if( CKR_OK == error ) {
  721.         error = CKR_GENERAL_ERROR;
  722.       }
  723.       return error;
  724.     }
  726.     /*
  727.      * Actually, I bet the locking is worse than this.. this part of
  728.      * the code could probably use some scrutiny and reworking.
  729.      */
  730.     error = nssCKFWMutex_Lock(fwObject->mutex);
  731.     if( CKR_OK != error ) {
  732.       nssCKFWObject_Destroy(newFwObject);
  733.       return error;
  734.     }
  736.     error = nssCKFWMutex_Lock(newFwObject->mutex);
  737.     if( CKR_OK != error ) {
  738.       nssCKFWMutex_Unlock(fwObject->mutex);
  739.       nssCKFWObject_Destroy(newFwObject);
  740.       return error;
  741.     }
  743.     /* 
  744.      * Now, we have our new object, but it has a new fwObject pointer,
  745.      * while we have to keep the existing one.  So quick swap the contents.
  746.      */
  747.     swab = *fwObject;
  748.     *fwObject = *newFwObject;
  749.     *newFwObject = swab;
  751.     /* But keep the mutexes the same */
  752.     swab.mutex = fwObject->mutex;
  753.     fwObject->mutex = newFwObject->mutex;
  754.     newFwObject->mutex = swab.mutex;
  756.     (void)nssCKFWMutex_Unlock(newFwObject->mutex);
  757.     (void)nssCKFWMutex_Unlock(fwObject->mutex);
  759.     /*
  760.      * Either remove or add this to the list of session objects
  761.      */
  763.     if( CK_FALSE == *(CK_BBOOL *)value->data ) {
  764.       /* 
  765.        * New one is a session object, except since we "stole" the fwObject, it's
  766.        * not in the list.  Add it.
  767.        */
  768.       nssCKFWSession_RegisterSessionObject(fwObject->fwSession, fwObject);
  769.     } else {
  770.       /*
  771.        * New one is a token object, except since we "stole" the fwObject, it's
  772.        * in the list.  Remove it.
  773.        */
  774.       nssCKFWSession_DeregisterSessionObject(fwObject->fwSession, fwObject);
  775.     }
  777.     /*
  778.      * Now delete the old object.  Remember the names have changed.
  779.      */
  780.     nssCKFWObject_Destroy(newFwObject);
  782.     return CKR_OK;
  783.   } else {
  784.     /*
  785.      * An "ordinary" change.
  786.      */
  787.     if( (void *)NULL == (void *)fwObject->mdObject->SetAttribute ) {
  788.       /* We could fake it with copying, like above.. later */
  789.       return CKR_ATTRIBUTE_READ_ONLY;
  790.     }
  792.     error = nssCKFWMutex_Lock(fwObject->mutex);
  793.     if( CKR_OK != error ) {
  794.       return error;
  795.     }
  797.     error = fwObject->mdObject->SetAttribute(fwObject->mdObject, fwObject,
  798.       fwObject->mdSession, fwObject->fwSession, fwObject->mdToken, 
  799.       fwObject->fwToken, fwObject->mdInstance, fwObject->fwInstance,
  800.       attribute, value);
  802.     (void)nssCKFWMutex_Unlock(fwObject->mutex);
  804.     return error;
  805.   }
  806. }
  808. /*
  809.  * nssCKFWObject_GetObjectSize
  810.  *
  811.  */
  812. NSS_IMPLEMENT CK_ULONG
  813. nssCKFWObject_GetObjectSize
  814. (
  815.   NSSCKFWObject *fwObject,
  816.   CK_RV *pError
  817. )
  818. {
  819.   CK_ULONG rv;
  821. #ifdef NSSDEBUG
  822.   if( (CK_RV *)NULL == pError ) {
  823.     return (CK_ULONG)0;
  824.   }
  826.   *pError = nssCKFWObject_verifyPointer(fwObject);
  827.   if( CKR_OK != *pError ) {
  828.     return (CK_ULONG)0;
  829.   }
  830. #endif /* NSSDEBUG */
  832.   if( (void *)NULL == (void *)fwObject->mdObject->GetObjectSize ) {
  833.     *pError = CKR_INFORMATION_SENSITIVE;
  834.     return (CK_ULONG)0;
  835.   }
  837.   *pError = nssCKFWMutex_Lock(fwObject->mutex);
  838.   if( CKR_OK != *pError ) {
  839.     return (CK_ULONG)0;
  840.   }
  842.   rv = fwObject->mdObject->GetObjectSize(fwObject->mdObject, fwObject,
  843.     fwObject->mdSession, fwObject->fwSession, fwObject->mdToken, 
  844.     fwObject->fwToken, fwObject->mdInstance, fwObject->fwInstance,
  845.     pError);
  847.   (void)nssCKFWMutex_Unlock(fwObject->mutex);
  848.   return rv;
  849. }
  851. /*
  852.  * NSSCKFWObject_GetMDObject
  853.  *
  854.  */
  855. NSS_IMPLEMENT NSSCKMDObject *
  856. NSSCKFWObject_GetMDObject
  857. (
  858.   NSSCKFWObject *fwObject
  859. )
  860. {
  861. #ifdef DEBUG
  862.   if( CKR_OK != nssCKFWObject_verifyPointer(fwObject) ) {
  863.     return (NSSCKMDObject *)NULL;
  864.   }
  865. #endif /* DEBUG */
  867.   return nssCKFWObject_GetMDObject(fwObject);
  868. }
  870. /*
  871.  * NSSCKFWObject_GetArena
  872.  *
  873.  */
  874. NSS_IMPLEMENT NSSArena *
  875. NSSCKFWObject_GetArena
  876. (
  877.   NSSCKFWObject *fwObject,
  878.   CK_RV *pError
  879. )
  880. {
  881. #ifdef DEBUG
  882.   if( (CK_RV *)NULL == pError ) {
  883.     return (NSSArena *)NULL;
  884.   }
  886.   *pError = nssCKFWObject_verifyPointer(fwObject);
  887.   if( CKR_OK != *pError ) {
  888.     return (NSSArena *)NULL;
  889.   }
  890. #endif /* DEBUG */
  892.   return nssCKFWObject_GetArena(fwObject, pError);
  893. }
  895. /*
  896.  * NSSCKFWObject_IsTokenObject
  897.  *
  898.  */
  899. NSS_IMPLEMENT CK_BBOOL
  900. NSSCKFWObject_IsTokenObject
  901. (
  902.   NSSCKFWObject *fwObject
  903. )
  904. {
  905. #ifdef DEBUG
  906.   if( CKR_OK != nssCKFWObject_verifyPointer(fwObject) ) {
  907.     return CK_FALSE;
  908.   }
  909. #endif /* DEBUG */
  911.   return nssCKFWObject_IsTokenObject(fwObject);
  912. }
  914. /*
  915.  * NSSCKFWObject_GetAttributeCount
  916.  *
  917.  */
  918. NSS_IMPLEMENT CK_ULONG
  919. NSSCKFWObject_GetAttributeCount
  920. (
  921.   NSSCKFWObject *fwObject,
  922.   CK_RV *pError
  923. )
  924. {
  925. #ifdef DEBUG
  926.   if( (CK_RV *)NULL == pError ) {
  927.     return (CK_ULONG)0;
  928.   }
  930.   *pError = nssCKFWObject_verifyPointer(fwObject);
  931.   if( CKR_OK != *pError ) {
  932.     return (CK_ULONG)0;
  933.   }
  934. #endif /* DEBUG */
  936.   return nssCKFWObject_GetAttributeCount(fwObject, pError);
  937. }
  939. /*
  940.  * NSSCKFWObject_GetAttributeTypes
  941.  *
  942.  */
  943. NSS_IMPLEMENT CK_RV
  944. NSSCKFWObject_GetAttributeTypes
  945. (
  946.   NSSCKFWObject *fwObject,
  947.   CK_ATTRIBUTE_TYPE_PTR typeArray,
  948.   CK_ULONG ulCount
  949. )
  950. {
  951.   CK_RV error = CKR_OK;
  953. #ifdef DEBUG
  954.   error = nssCKFWObject_verifyPointer(fwObject);
  955.   if( CKR_OK != error ) {
  956.     return error;
  957.   }
  959.   if( (CK_ATTRIBUTE_TYPE_PTR)NULL == typeArray ) {
  960.     return CKR_ARGUMENTS_BAD;
  961.   }
  962. #endif /* DEBUG */
  964.   return nssCKFWObject_GetAttributeTypes(fwObject, typeArray, ulCount);
  965. }
  967. /*
  968.  * NSSCKFWObject_GetAttributeSize
  969.  *
  970.  */
  971. NSS_IMPLEMENT CK_ULONG
  972. NSSCKFWObject_GetAttributeSize
  973. (
  974.   NSSCKFWObject *fwObject,
  975.   CK_ATTRIBUTE_TYPE attribute,
  976.   CK_RV *pError
  977. )
  978. {
  979. #ifdef DEBUG
  980.   if( (CK_RV *)NULL == pError ) {
  981.     return (CK_ULONG)0;
  982.   }
  984.   *pError = nssCKFWObject_verifyPointer(fwObject);
  985.   if( CKR_OK != *pError ) {
  986.     return (CK_ULONG)0;
  987.   }
  988. #endif /* DEBUG */
  990.   return nssCKFWObject_GetAttributeSize(fwObject, attribute, pError);
  991. }
  993. /*
  994.  * NSSCKFWObject_GetAttribute
  995.  *
  996.  */
  997. NSS_IMPLEMENT NSSItem *
  998. NSSCKFWObject_GetAttribute
  999. (
  1000.   NSSCKFWObject *fwObject,
  1001.   CK_ATTRIBUTE_TYPE attribute,
  1002.   NSSItem *itemOpt,
  1003.   NSSArena *arenaOpt,
  1004.   CK_RV *pError
  1005. )
  1006. {
  1007. #ifdef DEBUG
  1008.   if( (CK_RV *)NULL == pError ) {
  1009.     return (NSSItem *)NULL;
  1010.   }
  1012.   *pError = nssCKFWObject_verifyPointer(fwObject);
  1013.   if( CKR_OK != *pError ) {
  1014.     return (NSSItem *)NULL;
  1015.   }
  1016. #endif /* DEBUG */
  1018.   return nssCKFWObject_GetAttribute(fwObject, attribute, itemOpt, arenaOpt, pError);
  1019. }
  1021. /*
  1022.  * NSSCKFWObject_GetObjectSize
  1023.  *
  1024.  */
  1025. NSS_IMPLEMENT CK_ULONG
  1026. NSSCKFWObject_GetObjectSize
  1027. (
  1028.   NSSCKFWObject *fwObject,
  1029.   CK_RV *pError
  1030. )
  1031. {
  1032. #ifdef DEBUG
  1033.   if( (CK_RV *)NULL == pError ) {
  1034.     return (CK_ULONG)0;
  1035.   }
  1037.   *pError = nssCKFWObject_verifyPointer(fwObject);
  1038.   if( CKR_OK != *pError ) {
  1039.     return (CK_ULONG)0;
  1040.   }
  1041. #endif /* DEBUG */
  1043.   return nssCKFWObject_GetObjectSize(fwObject, pError);
  1044. }