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