/security/nss/lib/ckfw/slot.c

http://github.com/zpao/v8monkey · C · 759 lines · 493 code · 94 blank · 172 comment · 101 complexity · 3b7d28434dc19db9e754e4589732d586 MD5 · raw file

  1. /* ***** BEGIN LICENSE BLOCK *****
  2. * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3. *
  4. * The contents of this file are subject to the Mozilla Public License Version
  5. * 1.1 (the "License"); you may not use this file except in compliance with
  6. * the License. You may obtain a copy of the License at
  7. * http://www.mozilla.org/MPL/
  8. *
  9. * Software distributed under the License is distributed on an "AS IS" basis,
  10. * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11. * for the specific language governing rights and limitations under the
  12. * License.
  13. *
  14. * The Original Code is the Netscape security libraries.
  15. *
  16. * The Initial Developer of the Original Code is
  17. * Netscape Communications Corporation.
  18. * Portions created by the Initial Developer are Copyright (C) 1994-2000
  19. * the Initial Developer. All Rights Reserved.
  20. *
  21. * Contributor(s):
  22. *
  23. * Alternatively, the contents of this file may be used under the terms of
  24. * either the GNU General Public License Version 2 or later (the "GPL"), or
  25. * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26. * in which case the provisions of the GPL or the LGPL are applicable instead
  27. * of those above. If you wish to allow use of your version of this file only
  28. * under the terms of either the GPL or the LGPL, and not to allow others to
  29. * use your version of this file under the terms of the MPL, indicate your
  30. * decision by deleting the provisions above and replace them with the notice
  31. * and other provisions required by the GPL or the LGPL. If you do not delete
  32. * the provisions above, a recipient may use your version of this file under
  33. * the terms of any one of the MPL, the GPL or the LGPL.
  34. *
  35. * ***** END LICENSE BLOCK ***** */
  36. #ifdef DEBUG
  37. static const char CVS_ID[] = "@(#) $RCSfile: slot.c,v $ $Revision: 1.7 $ $Date: 2009/02/09 07:55:53 $";
  38. #endif /* DEBUG */
  39. /*
  40. * slot.c
  41. *
  42. * This file implements the NSSCKFWSlot type and methods.
  43. */
  44. #ifndef CK_T
  45. #include "ck.h"
  46. #endif /* CK_T */
  47. /*
  48. * NSSCKFWSlot
  49. *
  50. * -- create/destroy --
  51. * nssCKFWSlot_Create
  52. * nssCKFWSlot_Destroy
  53. *
  54. * -- public accessors --
  55. * NSSCKFWSlot_GetMDSlot
  56. * NSSCKFWSlot_GetFWInstance
  57. * NSSCKFWSlot_GetMDInstance
  58. *
  59. * -- implement public accessors --
  60. * nssCKFWSlot_GetMDSlot
  61. * nssCKFWSlot_GetFWInstance
  62. * nssCKFWSlot_GetMDInstance
  63. *
  64. * -- private accessors --
  65. * nssCKFWSlot_GetSlotID
  66. * nssCKFWSlot_ClearToken
  67. *
  68. * -- module fronts --
  69. * nssCKFWSlot_GetSlotDescription
  70. * nssCKFWSlot_GetManufacturerID
  71. * nssCKFWSlot_GetTokenPresent
  72. * nssCKFWSlot_GetRemovableDevice
  73. * nssCKFWSlot_GetHardwareSlot
  74. * nssCKFWSlot_GetHardwareVersion
  75. * nssCKFWSlot_GetFirmwareVersion
  76. * nssCKFWSlot_InitToken
  77. * nssCKFWSlot_GetToken
  78. */
  79. struct NSSCKFWSlotStr {
  80. NSSCKFWMutex *mutex;
  81. NSSCKMDSlot *mdSlot;
  82. NSSCKFWInstance *fwInstance;
  83. NSSCKMDInstance *mdInstance;
  84. CK_SLOT_ID slotID;
  85. /*
  86. * Everything above is set at creation time, and then not modified.
  87. * The invariants the mutex protects are:
  88. *
  89. * 1) Each of the cached descriptions (versions, etc.) are in an
  90. * internally consistant state.
  91. *
  92. * 2) The fwToken points to the token currently in the slot, and
  93. * it is in a consistant state.
  94. *
  95. * Note that the calls accessing the cached descriptions will
  96. * call the NSSCKMDSlot methods with the mutex locked. Those
  97. * methods may then call the public NSSCKFWSlot routines. Those
  98. * public routines only access the constant data above, so there's
  99. * no problem. But be careful if you add to this object; mutexes
  100. * are in general not reentrant, so don't create deadlock situations.
  101. */
  102. NSSUTF8 *slotDescription;
  103. NSSUTF8 *manufacturerID;
  104. CK_VERSION hardwareVersion;
  105. CK_VERSION firmwareVersion;
  106. NSSCKFWToken *fwToken;
  107. };
  108. #ifdef DEBUG
  109. /*
  110. * But first, the pointer-tracking stuff.
  111. *
  112. * NOTE: the pointer-tracking support in NSS/base currently relies
  113. * upon NSPR's CallOnce support. That, however, relies upon NSPR's
  114. * locking, which is tied into the runtime. We need a pointer-tracker
  115. * implementation that uses the locks supplied through C_Initialize.
  116. * That support, however, can be filled in later. So for now, I'll
  117. * just do this routines as no-ops.
  118. */
  119. static CK_RV
  120. slot_add_pointer
  121. (
  122. const NSSCKFWSlot *fwSlot
  123. )
  124. {
  125. return CKR_OK;
  126. }
  127. static CK_RV
  128. slot_remove_pointer
  129. (
  130. const NSSCKFWSlot *fwSlot
  131. )
  132. {
  133. return CKR_OK;
  134. }
  135. NSS_IMPLEMENT CK_RV
  136. nssCKFWSlot_verifyPointer
  137. (
  138. const NSSCKFWSlot *fwSlot
  139. )
  140. {
  141. return CKR_OK;
  142. }
  143. #endif /* DEBUG */
  144. /*
  145. * nssCKFWSlot_Create
  146. *
  147. */
  148. NSS_IMPLEMENT NSSCKFWSlot *
  149. nssCKFWSlot_Create
  150. (
  151. NSSCKFWInstance *fwInstance,
  152. NSSCKMDSlot *mdSlot,
  153. CK_SLOT_ID slotID,
  154. CK_RV *pError
  155. )
  156. {
  157. NSSCKFWSlot *fwSlot;
  158. NSSCKMDInstance *mdInstance;
  159. NSSArena *arena;
  160. #ifdef NSSDEBUG
  161. if (!pError) {
  162. return (NSSCKFWSlot *)NULL;
  163. }
  164. *pError = nssCKFWInstance_verifyPointer(fwInstance);
  165. if( CKR_OK != *pError ) {
  166. return (NSSCKFWSlot *)NULL;
  167. }
  168. #endif /* NSSDEBUG */
  169. mdInstance = nssCKFWInstance_GetMDInstance(fwInstance);
  170. if (!mdInstance) {
  171. *pError = CKR_GENERAL_ERROR;
  172. return (NSSCKFWSlot *)NULL;
  173. }
  174. arena = nssCKFWInstance_GetArena(fwInstance, pError);
  175. if (!arena) {
  176. if( CKR_OK == *pError ) {
  177. *pError = CKR_GENERAL_ERROR;
  178. }
  179. }
  180. fwSlot = nss_ZNEW(arena, NSSCKFWSlot);
  181. if (!fwSlot) {
  182. *pError = CKR_HOST_MEMORY;
  183. return (NSSCKFWSlot *)NULL;
  184. }
  185. fwSlot->mdSlot = mdSlot;
  186. fwSlot->fwInstance = fwInstance;
  187. fwSlot->mdInstance = mdInstance;
  188. fwSlot->slotID = slotID;
  189. fwSlot->mutex = nssCKFWInstance_CreateMutex(fwInstance, arena, pError);
  190. if (!fwSlot->mutex) {
  191. if( CKR_OK == *pError ) {
  192. *pError = CKR_GENERAL_ERROR;
  193. }
  194. (void)nss_ZFreeIf(fwSlot);
  195. return (NSSCKFWSlot *)NULL;
  196. }
  197. if (mdSlot->Initialize) {
  198. *pError = CKR_OK;
  199. *pError = mdSlot->Initialize(mdSlot, fwSlot, mdInstance, fwInstance);
  200. if( CKR_OK != *pError ) {
  201. (void)nssCKFWMutex_Destroy(fwSlot->mutex);
  202. (void)nss_ZFreeIf(fwSlot);
  203. return (NSSCKFWSlot *)NULL;
  204. }
  205. }
  206. #ifdef DEBUG
  207. *pError = slot_add_pointer(fwSlot);
  208. if( CKR_OK != *pError ) {
  209. if (mdSlot->Destroy) {
  210. mdSlot->Destroy(mdSlot, fwSlot, mdInstance, fwInstance);
  211. }
  212. (void)nssCKFWMutex_Destroy(fwSlot->mutex);
  213. (void)nss_ZFreeIf(fwSlot);
  214. return (NSSCKFWSlot *)NULL;
  215. }
  216. #endif /* DEBUG */
  217. return fwSlot;
  218. }
  219. /*
  220. * nssCKFWSlot_Destroy
  221. *
  222. */
  223. NSS_IMPLEMENT CK_RV
  224. nssCKFWSlot_Destroy
  225. (
  226. NSSCKFWSlot *fwSlot
  227. )
  228. {
  229. CK_RV error = CKR_OK;
  230. #ifdef NSSDEBUG
  231. error = nssCKFWSlot_verifyPointer(fwSlot);
  232. if( CKR_OK != error ) {
  233. return error;
  234. }
  235. #endif /* NSSDEBUG */
  236. if (fwSlot->fwToken) {
  237. nssCKFWToken_Destroy(fwSlot->fwToken);
  238. }
  239. (void)nssCKFWMutex_Destroy(fwSlot->mutex);
  240. if (fwSlot->mdSlot->Destroy) {
  241. fwSlot->mdSlot->Destroy(fwSlot->mdSlot, fwSlot,
  242. fwSlot->mdInstance, fwSlot->fwInstance);
  243. }
  244. #ifdef DEBUG
  245. error = slot_remove_pointer(fwSlot);
  246. #endif /* DEBUG */
  247. (void)nss_ZFreeIf(fwSlot);
  248. return error;
  249. }
  250. /*
  251. * nssCKFWSlot_GetMDSlot
  252. *
  253. */
  254. NSS_IMPLEMENT NSSCKMDSlot *
  255. nssCKFWSlot_GetMDSlot
  256. (
  257. NSSCKFWSlot *fwSlot
  258. )
  259. {
  260. #ifdef NSSDEBUG
  261. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  262. return (NSSCKMDSlot *)NULL;
  263. }
  264. #endif /* NSSDEBUG */
  265. return fwSlot->mdSlot;
  266. }
  267. /*
  268. * nssCKFWSlot_GetFWInstance
  269. *
  270. */
  271. NSS_IMPLEMENT NSSCKFWInstance *
  272. nssCKFWSlot_GetFWInstance
  273. (
  274. NSSCKFWSlot *fwSlot
  275. )
  276. {
  277. #ifdef NSSDEBUG
  278. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  279. return (NSSCKFWInstance *)NULL;
  280. }
  281. #endif /* NSSDEBUG */
  282. return fwSlot->fwInstance;
  283. }
  284. /*
  285. * nssCKFWSlot_GetMDInstance
  286. *
  287. */
  288. NSS_IMPLEMENT NSSCKMDInstance *
  289. nssCKFWSlot_GetMDInstance
  290. (
  291. NSSCKFWSlot *fwSlot
  292. )
  293. {
  294. #ifdef NSSDEBUG
  295. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  296. return (NSSCKMDInstance *)NULL;
  297. }
  298. #endif /* NSSDEBUG */
  299. return fwSlot->mdInstance;
  300. }
  301. /*
  302. * nssCKFWSlot_GetSlotID
  303. *
  304. */
  305. NSS_IMPLEMENT CK_SLOT_ID
  306. nssCKFWSlot_GetSlotID
  307. (
  308. NSSCKFWSlot *fwSlot
  309. )
  310. {
  311. #ifdef NSSDEBUG
  312. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  313. return (CK_SLOT_ID)0;
  314. }
  315. #endif /* NSSDEBUG */
  316. return fwSlot->slotID;
  317. }
  318. /*
  319. * nssCKFWSlot_GetSlotDescription
  320. *
  321. */
  322. NSS_IMPLEMENT CK_RV
  323. nssCKFWSlot_GetSlotDescription
  324. (
  325. NSSCKFWSlot *fwSlot,
  326. CK_CHAR slotDescription[64]
  327. )
  328. {
  329. CK_RV error = CKR_OK;
  330. #ifdef NSSDEBUG
  331. if( (CK_CHAR_PTR)NULL == slotDescription ) {
  332. return CKR_ARGUMENTS_BAD;
  333. }
  334. error = nssCKFWSlot_verifyPointer(fwSlot);
  335. if( CKR_OK != error ) {
  336. return error;
  337. }
  338. #endif /* NSSDEBUG */
  339. error = nssCKFWMutex_Lock(fwSlot->mutex);
  340. if( CKR_OK != error ) {
  341. return error;
  342. }
  343. if (!fwSlot->slotDescription) {
  344. if (fwSlot->mdSlot->GetSlotDescription) {
  345. fwSlot->slotDescription = fwSlot->mdSlot->GetSlotDescription(
  346. fwSlot->mdSlot, fwSlot, fwSlot->mdInstance,
  347. fwSlot->fwInstance, &error);
  348. if ((!fwSlot->slotDescription) && (CKR_OK != error)) {
  349. goto done;
  350. }
  351. } else {
  352. fwSlot->slotDescription = (NSSUTF8 *) "";
  353. }
  354. }
  355. (void)nssUTF8_CopyIntoFixedBuffer(fwSlot->slotDescription, (char *)slotDescription, 64, ' ');
  356. error = CKR_OK;
  357. done:
  358. (void)nssCKFWMutex_Unlock(fwSlot->mutex);
  359. return error;
  360. }
  361. /*
  362. * nssCKFWSlot_GetManufacturerID
  363. *
  364. */
  365. NSS_IMPLEMENT CK_RV
  366. nssCKFWSlot_GetManufacturerID
  367. (
  368. NSSCKFWSlot *fwSlot,
  369. CK_CHAR manufacturerID[32]
  370. )
  371. {
  372. CK_RV error = CKR_OK;
  373. #ifdef NSSDEBUG
  374. if( (CK_CHAR_PTR)NULL == manufacturerID ) {
  375. return CKR_ARGUMENTS_BAD;
  376. }
  377. error = nssCKFWSlot_verifyPointer(fwSlot);
  378. if( CKR_OK != error ) {
  379. return error;
  380. }
  381. #endif /* NSSDEBUG */
  382. error = nssCKFWMutex_Lock(fwSlot->mutex);
  383. if( CKR_OK != error ) {
  384. return error;
  385. }
  386. if (!fwSlot->manufacturerID) {
  387. if (fwSlot->mdSlot->GetManufacturerID) {
  388. fwSlot->manufacturerID = fwSlot->mdSlot->GetManufacturerID(
  389. fwSlot->mdSlot, fwSlot, fwSlot->mdInstance,
  390. fwSlot->fwInstance, &error);
  391. if ((!fwSlot->manufacturerID) && (CKR_OK != error)) {
  392. goto done;
  393. }
  394. } else {
  395. fwSlot->manufacturerID = (NSSUTF8 *) "";
  396. }
  397. }
  398. (void)nssUTF8_CopyIntoFixedBuffer(fwSlot->manufacturerID, (char *)manufacturerID, 32, ' ');
  399. error = CKR_OK;
  400. done:
  401. (void)nssCKFWMutex_Unlock(fwSlot->mutex);
  402. return error;
  403. }
  404. /*
  405. * nssCKFWSlot_GetTokenPresent
  406. *
  407. */
  408. NSS_IMPLEMENT CK_BBOOL
  409. nssCKFWSlot_GetTokenPresent
  410. (
  411. NSSCKFWSlot *fwSlot
  412. )
  413. {
  414. #ifdef NSSDEBUG
  415. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  416. return CK_FALSE;
  417. }
  418. #endif /* NSSDEBUG */
  419. if (!fwSlot->mdSlot->GetTokenPresent) {
  420. return CK_TRUE;
  421. }
  422. return fwSlot->mdSlot->GetTokenPresent(fwSlot->mdSlot, fwSlot,
  423. fwSlot->mdInstance, fwSlot->fwInstance);
  424. }
  425. /*
  426. * nssCKFWSlot_GetRemovableDevice
  427. *
  428. */
  429. NSS_IMPLEMENT CK_BBOOL
  430. nssCKFWSlot_GetRemovableDevice
  431. (
  432. NSSCKFWSlot *fwSlot
  433. )
  434. {
  435. #ifdef NSSDEBUG
  436. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  437. return CK_FALSE;
  438. }
  439. #endif /* NSSDEBUG */
  440. if (!fwSlot->mdSlot->GetRemovableDevice) {
  441. return CK_FALSE;
  442. }
  443. return fwSlot->mdSlot->GetRemovableDevice(fwSlot->mdSlot, fwSlot,
  444. fwSlot->mdInstance, fwSlot->fwInstance);
  445. }
  446. /*
  447. * nssCKFWSlot_GetHardwareSlot
  448. *
  449. */
  450. NSS_IMPLEMENT CK_BBOOL
  451. nssCKFWSlot_GetHardwareSlot
  452. (
  453. NSSCKFWSlot *fwSlot
  454. )
  455. {
  456. #ifdef NSSDEBUG
  457. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  458. return CK_FALSE;
  459. }
  460. #endif /* NSSDEBUG */
  461. if (!fwSlot->mdSlot->GetHardwareSlot) {
  462. return CK_FALSE;
  463. }
  464. return fwSlot->mdSlot->GetHardwareSlot(fwSlot->mdSlot, fwSlot,
  465. fwSlot->mdInstance, fwSlot->fwInstance);
  466. }
  467. /*
  468. * nssCKFWSlot_GetHardwareVersion
  469. *
  470. */
  471. NSS_IMPLEMENT CK_VERSION
  472. nssCKFWSlot_GetHardwareVersion
  473. (
  474. NSSCKFWSlot *fwSlot
  475. )
  476. {
  477. CK_VERSION rv;
  478. #ifdef NSSDEBUG
  479. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  480. rv.major = rv.minor = 0;
  481. return rv;
  482. }
  483. #endif /* NSSDEBUG */
  484. if( CKR_OK != nssCKFWMutex_Lock(fwSlot->mutex) ) {
  485. rv.major = rv.minor = 0;
  486. return rv;
  487. }
  488. if( (0 != fwSlot->hardwareVersion.major) ||
  489. (0 != fwSlot->hardwareVersion.minor) ) {
  490. rv = fwSlot->hardwareVersion;
  491. goto done;
  492. }
  493. if (fwSlot->mdSlot->GetHardwareVersion) {
  494. fwSlot->hardwareVersion = fwSlot->mdSlot->GetHardwareVersion(
  495. fwSlot->mdSlot, fwSlot, fwSlot->mdInstance, fwSlot->fwInstance);
  496. } else {
  497. fwSlot->hardwareVersion.major = 0;
  498. fwSlot->hardwareVersion.minor = 1;
  499. }
  500. rv = fwSlot->hardwareVersion;
  501. done:
  502. (void)nssCKFWMutex_Unlock(fwSlot->mutex);
  503. return rv;
  504. }
  505. /*
  506. * nssCKFWSlot_GetFirmwareVersion
  507. *
  508. */
  509. NSS_IMPLEMENT CK_VERSION
  510. nssCKFWSlot_GetFirmwareVersion
  511. (
  512. NSSCKFWSlot *fwSlot
  513. )
  514. {
  515. CK_VERSION rv;
  516. #ifdef NSSDEBUG
  517. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  518. rv.major = rv.minor = 0;
  519. return rv;
  520. }
  521. #endif /* NSSDEBUG */
  522. if( CKR_OK != nssCKFWMutex_Lock(fwSlot->mutex) ) {
  523. rv.major = rv.minor = 0;
  524. return rv;
  525. }
  526. if( (0 != fwSlot->firmwareVersion.major) ||
  527. (0 != fwSlot->firmwareVersion.minor) ) {
  528. rv = fwSlot->firmwareVersion;
  529. goto done;
  530. }
  531. if (fwSlot->mdSlot->GetFirmwareVersion) {
  532. fwSlot->firmwareVersion = fwSlot->mdSlot->GetFirmwareVersion(
  533. fwSlot->mdSlot, fwSlot, fwSlot->mdInstance, fwSlot->fwInstance);
  534. } else {
  535. fwSlot->firmwareVersion.major = 0;
  536. fwSlot->firmwareVersion.minor = 1;
  537. }
  538. rv = fwSlot->firmwareVersion;
  539. done:
  540. (void)nssCKFWMutex_Unlock(fwSlot->mutex);
  541. return rv;
  542. }
  543. /*
  544. * nssCKFWSlot_GetToken
  545. *
  546. */
  547. NSS_IMPLEMENT NSSCKFWToken *
  548. nssCKFWSlot_GetToken
  549. (
  550. NSSCKFWSlot *fwSlot,
  551. CK_RV *pError
  552. )
  553. {
  554. NSSCKMDToken *mdToken;
  555. NSSCKFWToken *fwToken;
  556. #ifdef NSSDEBUG
  557. if (!pError) {
  558. return (NSSCKFWToken *)NULL;
  559. }
  560. *pError = nssCKFWSlot_verifyPointer(fwSlot);
  561. if( CKR_OK != *pError ) {
  562. return (NSSCKFWToken *)NULL;
  563. }
  564. #endif /* NSSDEBUG */
  565. *pError = nssCKFWMutex_Lock(fwSlot->mutex);
  566. if( CKR_OK != *pError ) {
  567. return (NSSCKFWToken *)NULL;
  568. }
  569. if (!fwSlot->fwToken) {
  570. if (!fwSlot->mdSlot->GetToken) {
  571. *pError = CKR_GENERAL_ERROR;
  572. fwToken = (NSSCKFWToken *)NULL;
  573. goto done;
  574. }
  575. mdToken = fwSlot->mdSlot->GetToken(fwSlot->mdSlot, fwSlot,
  576. fwSlot->mdInstance, fwSlot->fwInstance, pError);
  577. if (!mdToken) {
  578. if( CKR_OK == *pError ) {
  579. *pError = CKR_GENERAL_ERROR;
  580. }
  581. return (NSSCKFWToken *)NULL;
  582. }
  583. fwToken = nssCKFWToken_Create(fwSlot, mdToken, pError);
  584. fwSlot->fwToken = fwToken;
  585. } else {
  586. fwToken = fwSlot->fwToken;
  587. }
  588. done:
  589. (void)nssCKFWMutex_Unlock(fwSlot->mutex);
  590. return fwToken;
  591. }
  592. /*
  593. * nssCKFWSlot_ClearToken
  594. *
  595. */
  596. NSS_IMPLEMENT void
  597. nssCKFWSlot_ClearToken
  598. (
  599. NSSCKFWSlot *fwSlot
  600. )
  601. {
  602. #ifdef NSSDEBUG
  603. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  604. return;
  605. }
  606. #endif /* NSSDEBUG */
  607. if( CKR_OK != nssCKFWMutex_Lock(fwSlot->mutex) ) {
  608. /* Now what? */
  609. return;
  610. }
  611. fwSlot->fwToken = (NSSCKFWToken *)NULL;
  612. (void)nssCKFWMutex_Unlock(fwSlot->mutex);
  613. return;
  614. }
  615. /*
  616. * NSSCKFWSlot_GetMDSlot
  617. *
  618. */
  619. NSS_IMPLEMENT NSSCKMDSlot *
  620. NSSCKFWSlot_GetMDSlot
  621. (
  622. NSSCKFWSlot *fwSlot
  623. )
  624. {
  625. #ifdef DEBUG
  626. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  627. return (NSSCKMDSlot *)NULL;
  628. }
  629. #endif /* DEBUG */
  630. return nssCKFWSlot_GetMDSlot(fwSlot);
  631. }
  632. /*
  633. * NSSCKFWSlot_GetFWInstance
  634. *
  635. */
  636. NSS_IMPLEMENT NSSCKFWInstance *
  637. NSSCKFWSlot_GetFWInstance
  638. (
  639. NSSCKFWSlot *fwSlot
  640. )
  641. {
  642. #ifdef DEBUG
  643. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  644. return (NSSCKFWInstance *)NULL;
  645. }
  646. #endif /* DEBUG */
  647. return nssCKFWSlot_GetFWInstance(fwSlot);
  648. }
  649. /*
  650. * NSSCKFWSlot_GetMDInstance
  651. *
  652. */
  653. NSS_IMPLEMENT NSSCKMDInstance *
  654. NSSCKFWSlot_GetMDInstance
  655. (
  656. NSSCKFWSlot *fwSlot
  657. )
  658. {
  659. #ifdef DEBUG
  660. if( CKR_OK != nssCKFWSlot_verifyPointer(fwSlot) ) {
  661. return (NSSCKMDInstance *)NULL;
  662. }
  663. #endif /* DEBUG */
  664. return nssCKFWSlot_GetMDInstance(fwSlot);
  665. }