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