Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(148)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: nss/lib/ckfw/slot.c

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

Powered by Google App Engine
This is Rietveld 408576698