← Back to branch summary

~ubuntu-branches/ubuntu/trusty/xulrunner/trusty

« back to all changes in this revision

Viewing changes to security/nss-fips/lib/ckfw/wrap.c

  • Committer: Bazaar Package Importer
  • Author(s): Devid Antonio Filoni
  • Date: 2008-08-25 13:04:18 UTC
  • mfrom: (1.1.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20080825130418-ck1i2ms384tzb9m0
Tags: 1.8.1.16+nobinonly-0ubuntu1
https://launchpad.net/bugs/254618
* New upstream release (taken from upstream CVS), LP: #254618.
* Fix MFSA 2008-35, MFSA 2008-34, MFSA 2008-33, MFSA 2008-32, MFSA 2008-31,
  MFSA 2008-30, MFSA 2008-29, MFSA 2008-28, MFSA 2008-27, MFSA 2008-25,
  MFSA 2008-24, MFSA 2008-23, MFSA 2008-22, MFSA 2008-21, MFSA 2008-26 also
  known as CVE-2008-2933, CVE-2008-2785, CVE-2008-2811, CVE-2008-2810,
  CVE-2008-2809, CVE-2008-2808, CVE-2008-2807, CVE-2008-2806, CVE-2008-2805,
  CVE-2008-2803, CVE-2008-2802, CVE-2008-2801, CVE-2008-2800, CVE-2008-2798.
* Drop 89_bz419350_attachment_306066 patch, merged upstream.
* Bump Standards-Version to 3.8.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
security/nss-fips/lib/ckfw/wrap.c
 
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
 
 
37
#ifdef DEBUG
 
38
static const char CVS_ID[] = "@(#) $RCSfile: wrap.c,v $ $Revision: 1.13.2.1 $ $Date: 2006/06/10 22:19:16 $";
 
39
#endif /* DEBUG */
 
40
 
 
41
/*
 
42
 * wrap.c
 
43
 *
 
44
 * This file contains the routines that actually implement the cryptoki
 
45
 * API, using the internal APIs of the NSS Cryptoki Framework.  There is
 
46
 * one routine here for every cryptoki routine.  For linking reasons
 
47
 * the actual entry points passed back with C_GetFunctionList have to
 
48
 * exist in one of the Module's source files; however, those are merely
 
49
 * simple wrappers that call these routines.  The intelligence of the
 
50
 * implementations is here.
 
51
 */
 
52
 
 
53
#ifndef CK_T
 
54
#include "ck.h"
 
55
#endif /* CK_T */
 
56
 
 
57
/*
 
58
 * NSSCKFWC_Initialize
 
59
 * NSSCKFWC_Finalize
 
60
 * NSSCKFWC_GetInfo
 
61
 * -- NSSCKFWC_GetFunctionList -- see the API insert file
 
62
 * NSSCKFWC_GetSlotList
 
63
 * NSSCKFWC_GetSlotInfo
 
64
 * NSSCKFWC_GetTokenInfo
 
65
 * NSSCKFWC_WaitForSlotEvent
 
66
 * NSSCKFWC_GetMechanismList
 
67
 * NSSCKFWC_GetMechanismInfo
 
68
 * NSSCKFWC_InitToken
 
69
 * NSSCKFWC_InitPIN
 
70
 * NSSCKFWC_SetPIN
 
71
 * NSSCKFWC_OpenSession
 
72
 * NSSCKFWC_CloseSession
 
73
 * NSSCKFWC_CloseAllSessions
 
74
 * NSSCKFWC_GetSessionInfo
 
75
 * NSSCKFWC_GetOperationState
 
76
 * NSSCKFWC_SetOperationState
 
77
 * NSSCKFWC_Login
 
78
 * NSSCKFWC_Logout
 
79
 * NSSCKFWC_CreateObject
 
80
 * NSSCKFWC_CopyObject
 
81
 * NSSCKFWC_DestroyObject
 
82
 * NSSCKFWC_GetObjectSize
 
83
 * NSSCKFWC_GetAttributeValue
 
84
 * NSSCKFWC_SetAttributeValue
 
85
 * NSSCKFWC_FindObjectsInit
 
86
 * NSSCKFWC_FindObjects
 
87
 * NSSCKFWC_FindObjectsFinal
 
88
 * NSSCKFWC_EncryptInit
 
89
 * NSSCKFWC_Encrypt
 
90
 * NSSCKFWC_EncryptUpdate
 
91
 * NSSCKFWC_EncryptFinal
 
92
 * NSSCKFWC_DecryptInit
 
93
 * NSSCKFWC_Decrypt
 
94
 * NSSCKFWC_DecryptUpdate
 
95
 * NSSCKFWC_DecryptFinal
 
96
 * NSSCKFWC_DigestInit
 
97
 * NSSCKFWC_Digest
 
98
 * NSSCKFWC_DigestUpdate
 
99
 * NSSCKFWC_DigestKey
 
100
 * NSSCKFWC_DigestFinal
 
101
 * NSSCKFWC_SignInit
 
102
 * NSSCKFWC_Sign
 
103
 * NSSCKFWC_SignUpdate
 
104
 * NSSCKFWC_SignFinal
 
105
 * NSSCKFWC_SignRecoverInit
 
106
 * NSSCKFWC_SignRecover
 
107
 * NSSCKFWC_VerifyInit
 
108
 * NSSCKFWC_Verify
 
109
 * NSSCKFWC_VerifyUpdate
 
110
 * NSSCKFWC_VerifyFinal
 
111
 * NSSCKFWC_VerifyRecoverInit
 
112
 * NSSCKFWC_VerifyRecover
 
113
 * NSSCKFWC_DigestEncryptUpdate
 
114
 * NSSCKFWC_DecryptDigestUpdate
 
115
 * NSSCKFWC_SignEncryptUpdate
 
116
 * NSSCKFWC_DecryptVerifyUpdate
 
117
 * NSSCKFWC_GenerateKey
 
118
 * NSSCKFWC_GenerateKeyPair
 
119
 * NSSCKFWC_WrapKey
 
120
 * NSSCKFWC_UnwrapKey
 
121
 * NSSCKFWC_DeriveKey
 
122
 * NSSCKFWC_SeedRandom
 
123
 * NSSCKFWC_GenerateRandom
 
124
 * NSSCKFWC_GetFunctionStatus
 
125
 * NSSCKFWC_CancelFunction
 
126
 */
 
127
 
 
128
/* figure out out locking semantics */
 
129
static CK_RV
 
130
nssCKFW_GetThreadSafeState(CK_C_INITIALIZE_ARGS_PTR pInitArgs,
 
131
                           CryptokiLockingState *pLocking_state) {
 
132
  int functionCount = 0;
 
133
 
 
134
  /* parsed according to (PKCS #11 Section 11.4) */
 
135
  /* no args, the degenerate version of case 1 */
 
136
  if (!pInitArgs) {
 
137
    *pLocking_state = SingleThreaded;
 
138
    return CKR_OK;
 
139
  } 
 
140
 
 
141
  /* CKF_OS_LOCKING_OK set, Cases 2 and 4 */
 
142
  if (pInitArgs->flags & CKF_OS_LOCKING_OK) {
 
143
    *pLocking_state = MultiThreaded;
 
144
    return CKR_OK;
 
145
  }
 
146
  if ((CK_CREATEMUTEX) NULL != pInitArgs->CreateMutex) functionCount++;
 
147
  if ((CK_DESTROYMUTEX) NULL != pInitArgs->DestroyMutex) functionCount++;
 
148
  if ((CK_LOCKMUTEX) NULL != pInitArgs->LockMutex) functionCount++;
 
149
  if ((CK_UNLOCKMUTEX) NULL != pInitArgs->UnlockMutex) functionCount++;
 
150
 
 
151
  /* CKF_OS_LOCKING_OK is not set, and not functions supplied, 
 
152
   * explicit case 1 */
 
153
  if (0 == functionCount) {
 
154
    *pLocking_state = SingleThreaded;
 
155
    return CKR_OK;
 
156
  }
 
157
 
 
158
  /* OS_LOCKING_OK is not set and functions have been supplied. Since
 
159
   * ckfw uses nssbase library which explicitly calls NSPR, and since 
 
160
   * there is no way to reliably override these explicit calls to NSPR,
 
161
   * therefore we can't support applications which have their own threading 
 
162
   * module.  Return CKR_CANT_LOCK if they supplied the correct number of 
 
163
   * arguments, or CKR_ARGUMENTS_BAD if they did not in either case we will 
 
164
   * fail the initialize */
 
165
  return (4 == functionCount) ? CKR_CANT_LOCK : CKR_ARGUMENTS_BAD;
 
166
}
 
167
 
 
168
/*
 
169
 * NSSCKFWC_Initialize
 
170
 *
 
171
 */
 
172
NSS_IMPLEMENT CK_RV
 
173
NSSCKFWC_Initialize
 
174
(
 
175
  NSSCKFWInstance **pFwInstance,
 
176
  NSSCKMDInstance *mdInstance,
 
177
  CK_VOID_PTR pInitArgs
 
178
)
 
179
{
 
180
  CK_RV error = CKR_OK;
 
181
  CryptokiLockingState locking_state;
 
182
 
 
183
  if( (NSSCKFWInstance **)NULL == pFwInstance ) {
 
184
    error = CKR_GENERAL_ERROR;
 
185
    goto loser;
 
186
  }
 
187
 
 
188
  if( (NSSCKFWInstance *)NULL != *pFwInstance ) {
 
189
    error = CKR_CRYPTOKI_ALREADY_INITIALIZED;
 
190
    goto loser;
 
191
  }
 
192
 
 
193
  if( (NSSCKMDInstance *)NULL == mdInstance ) {
 
194
    error = CKR_GENERAL_ERROR;
 
195
    goto loser;
 
196
  }
 
197
 
 
198
  error = nssCKFW_GetThreadSafeState(pInitArgs,&locking_state);
 
199
  if( CKR_OK != error ) {
 
200
    goto loser;
 
201
  }
 
202
 
 
203
  *pFwInstance = nssCKFWInstance_Create(pInitArgs, locking_state, mdInstance, &error);
 
204
  if( (NSSCKFWInstance *)NULL == *pFwInstance ) {
 
205
    goto loser;
 
206
  }
 
207
 
 
208
  return CKR_OK;
 
209
 
 
210
 loser:
 
211
  switch( error ) {
 
212
  case CKR_ARGUMENTS_BAD:
 
213
  case CKR_CANT_LOCK:
 
214
  case CKR_CRYPTOKI_ALREADY_INITIALIZED:
 
215
  case CKR_FUNCTION_FAILED:
 
216
  case CKR_GENERAL_ERROR:
 
217
  case CKR_HOST_MEMORY:
 
218
  case CKR_NEED_TO_CREATE_THREADS:
 
219
    break;
 
220
  default:
 
221
  case CKR_OK:
 
222
    error = CKR_GENERAL_ERROR;
 
223
    break;
 
224
  }
 
225
 
 
226
  return error;
 
227
}
 
228
 
 
229
/*
 
230
 * NSSCKFWC_Finalize
 
231
 *
 
232
 */
 
233
NSS_IMPLEMENT CK_RV
 
234
NSSCKFWC_Finalize
 
235
(
 
236
  NSSCKFWInstance **pFwInstance
 
237
)
 
238
{
 
239
  CK_RV error = CKR_OK;
 
240
 
 
241
  if( (NSSCKFWInstance **)NULL == pFwInstance ) {
 
242
    error = CKR_GENERAL_ERROR;
 
243
    goto loser;
 
244
  }
 
245
 
 
246
  if( (NSSCKFWInstance *)NULL == *pFwInstance ) {
 
247
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
248
    goto loser;
 
249
  }
 
250
 
 
251
  error = nssCKFWInstance_Destroy(*pFwInstance);
 
252
 
 
253
  /* In any case */
 
254
  *pFwInstance = (NSSCKFWInstance *)NULL;
 
255
 
 
256
 loser:
 
257
  switch( error ) {
 
258
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
259
  case CKR_FUNCTION_FAILED:
 
260
  case CKR_GENERAL_ERROR:
 
261
  case CKR_HOST_MEMORY:
 
262
  case CKR_OK:
 
263
    break;
 
264
  default:
 
265
    error = CKR_GENERAL_ERROR;
 
266
    break;
 
267
  }
 
268
 
 
269
  return error;
 
270
}
 
271
 
 
272
/*
 
273
 * NSSCKFWC_GetInfo
 
274
 *
 
275
 */
 
276
NSS_IMPLEMENT CK_RV
 
277
NSSCKFWC_GetInfo
 
278
(
 
279
  NSSCKFWInstance *fwInstance,
 
280
  CK_INFO_PTR pInfo
 
281
)
 
282
{
 
283
  CK_RV error = CKR_OK;
 
284
 
 
285
  if( (CK_INFO_PTR)CK_NULL_PTR == pInfo ) {
 
286
    error = CKR_ARGUMENTS_BAD;
 
287
    goto loser;
 
288
  }
 
289
 
 
290
  /*
 
291
   * A purify error here means a caller error
 
292
   */
 
293
  (void)nsslibc_memset(pInfo, 0, sizeof(CK_INFO));
 
294
 
 
295
  pInfo->cryptokiVersion = nssCKFWInstance_GetCryptokiVersion(fwInstance);
 
296
 
 
297
  error = nssCKFWInstance_GetManufacturerID(fwInstance, pInfo->manufacturerID);
 
298
  if( CKR_OK != error ) {
 
299
    goto loser;
 
300
  }
 
301
 
 
302
  pInfo->flags = nssCKFWInstance_GetFlags(fwInstance);
 
303
 
 
304
  error = nssCKFWInstance_GetLibraryDescription(fwInstance, pInfo->libraryDescription);
 
305
  if( CKR_OK != error ) {
 
306
    goto loser;
 
307
  }
 
308
 
 
309
  pInfo->libraryVersion = nssCKFWInstance_GetLibraryVersion(fwInstance);
 
310
 
 
311
  return CKR_OK;
 
312
 
 
313
 loser:
 
314
  switch( error ) {
 
315
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
316
  case CKR_FUNCTION_FAILED:
 
317
  case CKR_GENERAL_ERROR:
 
318
  case CKR_HOST_MEMORY:
 
319
    break;
 
320
  default:
 
321
    error = CKR_GENERAL_ERROR;
 
322
    break;
 
323
  }
 
324
 
 
325
  return error;
 
326
}
 
327
  
 
328
/*
 
329
 * C_GetFunctionList is implemented entirely in the Module's file which
 
330
 * includes the Framework API insert file.  It requires no "actual"
 
331
 * NSSCKFW routine.
 
332
 */
 
333
 
 
334
/*
 
335
 * NSSCKFWC_GetSlotList
 
336
 *
 
337
 */
 
338
NSS_IMPLEMENT CK_RV
 
339
NSSCKFWC_GetSlotList
 
340
(
 
341
  NSSCKFWInstance *fwInstance,
 
342
  CK_BBOOL tokenPresent,
 
343
  CK_SLOT_ID_PTR pSlotList,
 
344
  CK_ULONG_PTR pulCount
 
345
)
 
346
{
 
347
  CK_RV error = CKR_OK;
 
348
  CK_ULONG nSlots;
 
349
 
 
350
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
351
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
352
    goto loser;
 
353
  }
 
354
 
 
355
  switch( tokenPresent ) {
 
356
  case CK_TRUE:
 
357
  case CK_FALSE:
 
358
    break;
 
359
  default:
 
360
    error = CKR_ARGUMENTS_BAD;
 
361
    goto loser;
 
362
  }
 
363
 
 
364
  if( (CK_ULONG_PTR)CK_NULL_PTR == pulCount ) {
 
365
    error = CKR_ARGUMENTS_BAD;
 
366
    goto loser;
 
367
  }
 
368
 
 
369
  nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
 
370
  if( (CK_ULONG)0 == nSlots ) {
 
371
    goto loser;
 
372
  }
 
373
 
 
374
  if( (CK_SLOT_ID_PTR)CK_NULL_PTR == pSlotList ) {
 
375
    *pulCount = nSlots;
 
376
    return CKR_OK;
 
377
  } 
 
378
    
 
379
  /*
 
380
   * A purify error here indicates caller error.
 
381
   */
 
382
  (void)nsslibc_memset(pSlotList, 0, *pulCount * sizeof(CK_SLOT_ID));
 
383
 
 
384
  if( *pulCount < nSlots ) {
 
385
    *pulCount = nSlots;
 
386
    error = CKR_BUFFER_TOO_SMALL;
 
387
    goto loser;
 
388
  } else {
 
389
    CK_ULONG i;
 
390
    *pulCount = nSlots;
 
391
    
 
392
    /* 
 
393
     * Our secret "mapping": CK_SLOT_IDs are integers [1,N], and we
 
394
     * just index one when we need it.
 
395
     */
 
396
 
 
397
    for( i = 0; i < nSlots; i++ ) {
 
398
      pSlotList[i] = i+1;
 
399
    }
 
400
 
 
401
    return CKR_OK;
 
402
  }
 
403
 
 
404
 loser:
 
405
  switch( error ) {
 
406
  case CKR_BUFFER_TOO_SMALL:
 
407
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
408
  case CKR_FUNCTION_FAILED:
 
409
  case CKR_GENERAL_ERROR:
 
410
  case CKR_HOST_MEMORY:
 
411
    break;
 
412
  default:
 
413
  case CKR_OK:
 
414
    error = CKR_GENERAL_ERROR;
 
415
    break;
 
416
  }
 
417
 
 
418
  return error;
 
419
}
 
420
 
 
421
/*
 
422
 * NSSCKFWC_GetSlotInfo
 
423
 *
 
424
 */
 
425
NSS_IMPLEMENT CK_RV
 
426
NSSCKFWC_GetSlotInfo
 
427
(
 
428
  NSSCKFWInstance *fwInstance,
 
429
  CK_SLOT_ID slotID,
 
430
  CK_SLOT_INFO_PTR pInfo
 
431
)
 
432
{
 
433
  CK_RV error = CKR_OK;
 
434
  CK_ULONG nSlots;
 
435
  NSSCKFWSlot **slots;
 
436
  NSSCKFWSlot *fwSlot;
 
437
 
 
438
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
439
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
440
    goto loser;
 
441
  }
 
442
 
 
443
  nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
 
444
  if( (CK_ULONG)0 == nSlots ) {
 
445
    goto loser;
 
446
  }
 
447
 
 
448
  if( (slotID < 1) || (slotID > nSlots) ) {
 
449
    error = CKR_SLOT_ID_INVALID;
 
450
    goto loser;
 
451
  }
 
452
 
 
453
  if( (CK_SLOT_INFO_PTR)CK_NULL_PTR == pInfo ) {
 
454
    error = CKR_ARGUMENTS_BAD;
 
455
    goto loser;
 
456
  }
 
457
 
 
458
  /*
 
459
   * A purify error here indicates caller error.
 
460
   */
 
461
  (void)nsslibc_memset(pInfo, 0, sizeof(CK_SLOT_INFO));
 
462
 
 
463
  slots = nssCKFWInstance_GetSlots(fwInstance, &error);
 
464
  if( (NSSCKFWSlot **)NULL == slots ) {
 
465
    goto loser;
 
466
  }
 
467
 
 
468
  fwSlot = slots[ slotID-1 ];
 
469
 
 
470
  error = nssCKFWSlot_GetSlotDescription(fwSlot, pInfo->slotDescription);
 
471
  if( CKR_OK != error ) {
 
472
    goto loser;
 
473
  }
 
474
 
 
475
  error = nssCKFWSlot_GetManufacturerID(fwSlot, pInfo->manufacturerID);
 
476
  if( CKR_OK != error ) {
 
477
    goto loser;
 
478
  }
 
479
 
 
480
  if( nssCKFWSlot_GetTokenPresent(fwSlot) ) {
 
481
    pInfo->flags |= CKF_TOKEN_PRESENT;
 
482
  }
 
483
 
 
484
  if( nssCKFWSlot_GetRemovableDevice(fwSlot) ) {
 
485
    pInfo->flags |= CKF_REMOVABLE_DEVICE;
 
486
  }
 
487
 
 
488
  if( nssCKFWSlot_GetHardwareSlot(fwSlot) ) {
 
489
    pInfo->flags |= CKF_HW_SLOT;
 
490
  }
 
491
 
 
492
  pInfo->hardwareVersion = nssCKFWSlot_GetHardwareVersion(fwSlot);
 
493
  pInfo->firmwareVersion = nssCKFWSlot_GetFirmwareVersion(fwSlot);
 
494
 
 
495
  return CKR_OK;
 
496
 
 
497
 loser:
 
498
  switch( error ) {
 
499
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
500
  case CKR_DEVICE_ERROR:
 
501
  case CKR_FUNCTION_FAILED:
 
502
  case CKR_GENERAL_ERROR:
 
503
  case CKR_HOST_MEMORY:
 
504
  case CKR_SLOT_ID_INVALID:
 
505
    break;
 
506
  default:
 
507
  case CKR_OK:
 
508
    error = CKR_GENERAL_ERROR;
 
509
  }
 
510
 
 
511
  return error;
 
512
}
 
513
 
 
514
/*
 
515
 * NSSCKFWC_GetTokenInfo
 
516
 *
 
517
 */
 
518
NSS_IMPLEMENT CK_RV
 
519
NSSCKFWC_GetTokenInfo
 
520
(
 
521
  NSSCKFWInstance *fwInstance,
 
522
  CK_SLOT_ID slotID,
 
523
  CK_TOKEN_INFO_PTR pInfo
 
524
)
 
525
{
 
526
  CK_RV error = CKR_OK;
 
527
  CK_ULONG nSlots;
 
528
  NSSCKFWSlot **slots;
 
529
  NSSCKFWSlot *fwSlot;
 
530
  NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
 
531
 
 
532
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
533
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
534
    goto loser;
 
535
  }
 
536
 
 
537
  nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
 
538
  if( (CK_ULONG)0 == nSlots ) {
 
539
    goto loser;
 
540
  }
 
541
 
 
542
  if( (slotID < 1) || (slotID > nSlots) ) {
 
543
    error = CKR_SLOT_ID_INVALID;
 
544
    goto loser;
 
545
  }
 
546
 
 
547
  if( (CK_TOKEN_INFO_PTR)CK_NULL_PTR == pInfo ) {
 
548
    error = CKR_ARGUMENTS_BAD;
 
549
    goto loser;
 
550
  }
 
551
 
 
552
  /*
 
553
   * A purify error here indicates caller error.
 
554
   */
 
555
  (void)nsslibc_memset(pInfo, 0, sizeof(CK_TOKEN_INFO));
 
556
 
 
557
  slots = nssCKFWInstance_GetSlots(fwInstance, &error);
 
558
  if( (NSSCKFWSlot **)NULL == slots ) {
 
559
    goto loser;
 
560
  }
 
561
 
 
562
  fwSlot = slots[ slotID-1 ];
 
563
 
 
564
  if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
 
565
    error = CKR_TOKEN_NOT_PRESENT;
 
566
    goto loser;
 
567
  }
 
568
 
 
569
  fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
 
570
  if( (NSSCKFWToken *)NULL == fwToken ) {
 
571
    goto loser;
 
572
  }
 
573
 
 
574
  error = nssCKFWToken_GetLabel(fwToken, pInfo->label);
 
575
  if( CKR_OK != error ) {
 
576
    goto loser;
 
577
  }
 
578
 
 
579
  error = nssCKFWToken_GetManufacturerID(fwToken, pInfo->manufacturerID);
 
580
  if( CKR_OK != error ) {
 
581
    goto loser;
 
582
  }
 
583
 
 
584
  error = nssCKFWToken_GetModel(fwToken, pInfo->model);
 
585
  if( CKR_OK != error ) {
 
586
    goto loser;
 
587
  }
 
588
 
 
589
  error = nssCKFWToken_GetSerialNumber(fwToken, pInfo->serialNumber);
 
590
  if( CKR_OK != error ) {
 
591
    goto loser;
 
592
  }
 
593
 
 
594
  if( nssCKFWToken_GetHasRNG(fwToken) ) {
 
595
    pInfo->flags |= CKF_RNG;
 
596
  }
 
597
 
 
598
  if( nssCKFWToken_GetIsWriteProtected(fwToken) ) {
 
599
    pInfo->flags |= CKF_WRITE_PROTECTED;
 
600
  }
 
601
 
 
602
  if( nssCKFWToken_GetLoginRequired(fwToken) ) {
 
603
    pInfo->flags |= CKF_LOGIN_REQUIRED;
 
604
  }
 
605
 
 
606
  if( nssCKFWToken_GetUserPinInitialized(fwToken) ) {
 
607
    pInfo->flags |= CKF_USER_PIN_INITIALIZED;
 
608
  }
 
609
 
 
610
  if( nssCKFWToken_GetRestoreKeyNotNeeded(fwToken) ) {
 
611
    pInfo->flags |= CKF_RESTORE_KEY_NOT_NEEDED;
 
612
  }
 
613
 
 
614
  if( nssCKFWToken_GetHasClockOnToken(fwToken) ) {
 
615
    pInfo->flags |= CKF_CLOCK_ON_TOKEN;
 
616
  }
 
617
 
 
618
  if( nssCKFWToken_GetHasProtectedAuthenticationPath(fwToken) ) {
 
619
    pInfo->flags |= CKF_PROTECTED_AUTHENTICATION_PATH;
 
620
  }
 
621
 
 
622
  if( nssCKFWToken_GetSupportsDualCryptoOperations(fwToken) ) {
 
623
    pInfo->flags |= CKF_DUAL_CRYPTO_OPERATIONS;
 
624
  }
 
625
 
 
626
  pInfo->ulMaxSessionCount = nssCKFWToken_GetMaxSessionCount(fwToken);
 
627
  pInfo->ulSessionCount = nssCKFWToken_GetSessionCount(fwToken);
 
628
  pInfo->ulMaxRwSessionCount = nssCKFWToken_GetMaxRwSessionCount(fwToken);
 
629
  pInfo->ulRwSessionCount= nssCKFWToken_GetRwSessionCount(fwToken);
 
630
  pInfo->ulMaxPinLen = nssCKFWToken_GetMaxPinLen(fwToken);
 
631
  pInfo->ulMinPinLen = nssCKFWToken_GetMinPinLen(fwToken);
 
632
  pInfo->ulTotalPublicMemory = nssCKFWToken_GetTotalPublicMemory(fwToken);
 
633
  pInfo->ulFreePublicMemory = nssCKFWToken_GetFreePublicMemory(fwToken);
 
634
  pInfo->ulTotalPrivateMemory = nssCKFWToken_GetTotalPrivateMemory(fwToken);
 
635
  pInfo->ulFreePrivateMemory = nssCKFWToken_GetFreePrivateMemory(fwToken);
 
636
  pInfo->hardwareVersion = nssCKFWToken_GetHardwareVersion(fwToken);
 
637
  pInfo->firmwareVersion = nssCKFWToken_GetFirmwareVersion(fwToken);
 
638
  
 
639
  error = nssCKFWToken_GetUTCTime(fwToken, pInfo->utcTime);
 
640
  if( CKR_OK != error ) {
 
641
    goto loser;
 
642
  }
 
643
 
 
644
  return CKR_OK;
 
645
 
 
646
 loser:
 
647
  switch( error ) {
 
648
  case CKR_DEVICE_REMOVED:
 
649
  case CKR_TOKEN_NOT_PRESENT:
 
650
    if (fwToken)
 
651
      nssCKFWToken_Destroy(fwToken);
 
652
    break;
 
653
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
654
  case CKR_DEVICE_ERROR:
 
655
  case CKR_DEVICE_MEMORY:
 
656
  case CKR_FUNCTION_FAILED:
 
657
  case CKR_GENERAL_ERROR:
 
658
  case CKR_HOST_MEMORY:
 
659
  case CKR_SLOT_ID_INVALID:
 
660
  case CKR_TOKEN_NOT_RECOGNIZED:
 
661
    break;
 
662
  default:
 
663
  case CKR_OK:
 
664
    error = CKR_GENERAL_ERROR;
 
665
    break;
 
666
  }
 
667
 
 
668
  return error;
 
669
}
 
670
 
 
671
/*
 
672
 * NSSCKFWC_WaitForSlotEvent
 
673
 *
 
674
 */
 
675
NSS_IMPLEMENT CK_RV
 
676
NSSCKFWC_WaitForSlotEvent
 
677
(
 
678
  NSSCKFWInstance *fwInstance,
 
679
  CK_FLAGS flags,
 
680
  CK_SLOT_ID_PTR pSlot,
 
681
  CK_VOID_PTR pReserved
 
682
)
 
683
{
 
684
  CK_RV error = CKR_OK;
 
685
  CK_ULONG nSlots;
 
686
  CK_BBOOL block;
 
687
  NSSCKFWSlot **slots;
 
688
  NSSCKFWSlot *fwSlot;
 
689
  CK_ULONG i;
 
690
 
 
691
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
692
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
693
    goto loser;
 
694
  }
 
695
 
 
696
  if( flags & ~CKF_DONT_BLOCK ) {
 
697
    error = CKR_ARGUMENTS_BAD;
 
698
    goto loser;
 
699
  }
 
700
 
 
701
  block = (flags & CKF_DONT_BLOCK) ? CK_TRUE : CK_FALSE;
 
702
 
 
703
  nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
 
704
  if( (CK_ULONG)0 == nSlots ) {
 
705
    goto loser;
 
706
  }
 
707
 
 
708
  if( (CK_SLOT_ID_PTR)CK_NULL_PTR == pSlot ) {
 
709
    error = CKR_ARGUMENTS_BAD;
 
710
    goto loser;
 
711
  }
 
712
 
 
713
  if( (CK_VOID_PTR)CK_NULL_PTR != pReserved ) {
 
714
    error = CKR_ARGUMENTS_BAD;
 
715
    goto loser;
 
716
  }
 
717
 
 
718
  slots = nssCKFWInstance_GetSlots(fwInstance, &error);
 
719
  if( (NSSCKFWSlot **)NULL == slots ) {
 
720
    goto loser;
 
721
  }
 
722
 
 
723
  fwSlot = nssCKFWInstance_WaitForSlotEvent(fwInstance, block, &error);
 
724
  if( (NSSCKFWSlot *)NULL == fwSlot ) {
 
725
    goto loser;
 
726
  }
 
727
 
 
728
  for( i = 0; i < nSlots; i++ ) {
 
729
    if( fwSlot == slots[i] ) {
 
730
      *pSlot = (CK_SLOT_ID)(CK_ULONG)(i+1);
 
731
      return CKR_OK;
 
732
    }
 
733
  }
 
734
 
 
735
  error = CKR_GENERAL_ERROR; /* returned something not in the slot list */
 
736
 
 
737
 loser:
 
738
  switch( error ) {
 
739
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
740
  case CKR_FUNCTION_FAILED:
 
741
  case CKR_GENERAL_ERROR:
 
742
  case CKR_HOST_MEMORY:
 
743
  case CKR_NO_EVENT:
 
744
    break;
 
745
  default:
 
746
  case CKR_OK:
 
747
    error = CKR_GENERAL_ERROR;
 
748
    break;
 
749
  }
 
750
 
 
751
  return error;
 
752
}
 
753
 
 
754
/*
 
755
 * NSSCKFWC_GetMechanismList
 
756
 *
 
757
 */
 
758
NSS_IMPLEMENT CK_RV
 
759
NSSCKFWC_GetMechanismList
 
760
(
 
761
  NSSCKFWInstance *fwInstance,
 
762
  CK_SLOT_ID slotID,
 
763
  CK_MECHANISM_TYPE_PTR pMechanismList,
 
764
  CK_ULONG_PTR pulCount
 
765
)
 
766
{
 
767
  CK_RV error = CKR_OK;
 
768
  CK_ULONG nSlots;
 
769
  NSSCKFWSlot **slots;
 
770
  NSSCKFWSlot *fwSlot;
 
771
  NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
 
772
  CK_ULONG count;
 
773
 
 
774
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
775
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
776
    goto loser;
 
777
  }
 
778
 
 
779
  nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
 
780
  if( (CK_ULONG)0 == nSlots ) {
 
781
    goto loser;
 
782
  }
 
783
 
 
784
  if( (slotID < 1) || (slotID > nSlots) ) {
 
785
    error = CKR_SLOT_ID_INVALID;
 
786
    goto loser;
 
787
  }
 
788
 
 
789
  if( (CK_ULONG_PTR)CK_NULL_PTR == pulCount ) {
 
790
    error = CKR_ARGUMENTS_BAD;
 
791
    goto loser;
 
792
  }
 
793
 
 
794
  slots = nssCKFWInstance_GetSlots(fwInstance, &error);
 
795
  if( (NSSCKFWSlot **)NULL == slots ) {
 
796
    goto loser;
 
797
  }
 
798
 
 
799
  fwSlot = slots[ slotID-1 ];
 
800
 
 
801
  if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
 
802
    error = CKR_TOKEN_NOT_PRESENT;
 
803
    goto loser;
 
804
  }
 
805
 
 
806
  fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
 
807
  if( (NSSCKFWToken *)NULL == fwToken ) {
 
808
    goto loser;
 
809
  }
 
810
 
 
811
  count = nssCKFWToken_GetMechanismCount(fwToken);
 
812
 
 
813
  if( (CK_MECHANISM_TYPE_PTR)CK_NULL_PTR == pMechanismList ) {
 
814
    *pulCount = count;
 
815
    return CKR_OK;
 
816
  }
 
817
 
 
818
  if( *pulCount < count ) {
 
819
    *pulCount = count;
 
820
    error = CKR_BUFFER_TOO_SMALL;
 
821
    goto loser;
 
822
  }
 
823
 
 
824
  /*
 
825
   * A purify error here indicates caller error.
 
826
   */
 
827
  (void)nsslibc_memset(pMechanismList, 0, *pulCount * sizeof(CK_MECHANISM_TYPE));
 
828
 
 
829
  *pulCount = count;
 
830
 
 
831
  if( 0 != count ) {
 
832
    error = nssCKFWToken_GetMechanismTypes(fwToken, pMechanismList);
 
833
  } else {
 
834
    error = CKR_OK;
 
835
  }
 
836
 
 
837
  if( CKR_OK == error ) {
 
838
    return CKR_OK;
 
839
  }
 
840
 
 
841
 loser:
 
842
  switch( error ) {
 
843
  case CKR_DEVICE_REMOVED:
 
844
  case CKR_TOKEN_NOT_PRESENT:
 
845
    if (fwToken)
 
846
      nssCKFWToken_Destroy(fwToken);
 
847
    break;
 
848
  case CKR_BUFFER_TOO_SMALL:
 
849
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
850
  case CKR_DEVICE_ERROR:
 
851
  case CKR_DEVICE_MEMORY:
 
852
  case CKR_FUNCTION_FAILED:
 
853
  case CKR_GENERAL_ERROR:
 
854
  case CKR_HOST_MEMORY:
 
855
  case CKR_SLOT_ID_INVALID:
 
856
  case CKR_TOKEN_NOT_RECOGNIZED:
 
857
    break;
 
858
  default:
 
859
  case CKR_OK:
 
860
    error = CKR_GENERAL_ERROR;
 
861
    break;
 
862
  }
 
863
 
 
864
  return error;
 
865
}
 
866
 
 
867
/*
 
868
 * NSSCKFWC_GetMechanismInfo
 
869
 *
 
870
 */
 
871
NSS_IMPLEMENT CK_RV
 
872
NSSCKFWC_GetMechanismInfo
 
873
(
 
874
  NSSCKFWInstance *fwInstance,
 
875
  CK_SLOT_ID slotID,
 
876
  CK_MECHANISM_TYPE type,
 
877
  CK_MECHANISM_INFO_PTR pInfo
 
878
)
 
879
{
 
880
  CK_RV error = CKR_OK;
 
881
  CK_ULONG nSlots;
 
882
  NSSCKFWSlot **slots;
 
883
  NSSCKFWSlot *fwSlot;
 
884
  NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
 
885
  NSSCKFWMechanism *fwMechanism;
 
886
 
 
887
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
888
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
889
    goto loser;
 
890
  }
 
891
 
 
892
  nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
 
893
  if( (CK_ULONG)0 == nSlots ) {
 
894
    goto loser;
 
895
  }
 
896
 
 
897
  if( (slotID < 1) || (slotID > nSlots) ) {
 
898
    error = CKR_SLOT_ID_INVALID;
 
899
    goto loser;
 
900
  }
 
901
 
 
902
  slots = nssCKFWInstance_GetSlots(fwInstance, &error);
 
903
  if( (NSSCKFWSlot **)NULL == slots ) {
 
904
    goto loser;
 
905
  }
 
906
 
 
907
  fwSlot = slots[ slotID-1 ];
 
908
 
 
909
  if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
 
910
    error = CKR_TOKEN_NOT_PRESENT;
 
911
    goto loser;
 
912
  }
 
913
 
 
914
  if( (CK_MECHANISM_INFO_PTR)CK_NULL_PTR == pInfo ) {
 
915
    error = CKR_ARGUMENTS_BAD;
 
916
    goto loser;
 
917
  }
 
918
 
 
919
  /*
 
920
   * A purify error here indicates caller error.
 
921
   */
 
922
  (void)nsslibc_memset(pInfo, 0, sizeof(CK_MECHANISM_INFO));
 
923
 
 
924
  fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
 
925
  if( (NSSCKFWToken *)NULL == fwToken ) {
 
926
    goto loser;
 
927
  }
 
928
 
 
929
  fwMechanism = nssCKFWToken_GetMechanism(fwToken, type, &error);
 
930
  if( (NSSCKFWMechanism *)NULL == fwMechanism ) {
 
931
    goto loser;
 
932
  }
 
933
 
 
934
  pInfo->ulMinKeySize = nssCKFWMechanism_GetMinKeySize(fwMechanism);
 
935
  pInfo->ulMaxKeySize = nssCKFWMechanism_GetMaxKeySize(fwMechanism);
 
936
 
 
937
  if( nssCKFWMechanism_GetInHardware(fwMechanism) ) {
 
938
    pInfo->flags |= CKF_HW;
 
939
  }
 
940
 
 
941
  /* More here... */
 
942
 
 
943
  return CKR_OK;
 
944
 
 
945
 loser:
 
946
  switch( error ) {
 
947
  case CKR_DEVICE_REMOVED:
 
948
  case CKR_TOKEN_NOT_PRESENT:
 
949
    if (fwToken)
 
950
      nssCKFWToken_Destroy(fwToken);
 
951
    break;
 
952
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
953
  case CKR_DEVICE_ERROR:
 
954
  case CKR_DEVICE_MEMORY:
 
955
  case CKR_FUNCTION_FAILED:
 
956
  case CKR_GENERAL_ERROR:
 
957
  case CKR_HOST_MEMORY:
 
958
  case CKR_MECHANISM_INVALID:
 
959
  case CKR_SLOT_ID_INVALID:
 
960
  case CKR_TOKEN_NOT_RECOGNIZED:
 
961
    break;
 
962
  default:
 
963
  case CKR_OK:
 
964
    error = CKR_GENERAL_ERROR;
 
965
    break;
 
966
  }
 
967
 
 
968
  return error;
 
969
}
 
970
 
 
971
/*
 
972
 * NSSCKFWC_InitToken
 
973
 *
 
974
 */
 
975
NSS_IMPLEMENT CK_RV
 
976
NSSCKFWC_InitToken
 
977
(
 
978
  NSSCKFWInstance *fwInstance,
 
979
  CK_SLOT_ID slotID,
 
980
  CK_CHAR_PTR pPin,
 
981
  CK_ULONG ulPinLen,
 
982
  CK_CHAR_PTR pLabel
 
983
)
 
984
{
 
985
  CK_RV error = CKR_OK;
 
986
  CK_ULONG nSlots;
 
987
  NSSCKFWSlot **slots;
 
988
  NSSCKFWSlot *fwSlot;
 
989
  NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
 
990
  NSSItem pin;
 
991
  NSSUTF8 *label;
 
992
 
 
993
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
994
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
995
    goto loser;
 
996
  }
 
997
 
 
998
  nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
 
999
  if( (CK_ULONG)0 == nSlots ) {
 
1000
    goto loser;
 
1001
  }
 
1002
 
 
1003
  if( (slotID < 1) || (slotID > nSlots) ) {
 
1004
    error = CKR_SLOT_ID_INVALID;
 
1005
    goto loser;
 
1006
  }
 
1007
 
 
1008
  slots = nssCKFWInstance_GetSlots(fwInstance, &error);
 
1009
  if( (NSSCKFWSlot **)NULL == slots ) {
 
1010
    goto loser;
 
1011
  }
 
1012
 
 
1013
  fwSlot = slots[ slotID-1 ];
 
1014
 
 
1015
  if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
 
1016
    error = CKR_TOKEN_NOT_PRESENT;
 
1017
    goto loser;
 
1018
  }
 
1019
 
 
1020
  fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
 
1021
  if( (NSSCKFWToken *)NULL == fwToken ) {
 
1022
    goto loser;
 
1023
  }
 
1024
 
 
1025
  pin.size = (PRUint32)ulPinLen;
 
1026
  pin.data = (void *)pPin;
 
1027
  label = (NSSUTF8 *)pLabel; /* identity conversion */
 
1028
 
 
1029
  error = nssCKFWToken_InitToken(fwToken, &pin, label);
 
1030
  if( CKR_OK != error ) {
 
1031
    goto loser;
 
1032
  }
 
1033
 
 
1034
  return CKR_OK;
 
1035
 
 
1036
 loser:
 
1037
  switch( error ) {
 
1038
  case CKR_DEVICE_REMOVED:
 
1039
  case CKR_TOKEN_NOT_PRESENT:
 
1040
    if (fwToken)
 
1041
      nssCKFWToken_Destroy(fwToken);
 
1042
    break;
 
1043
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1044
  case CKR_DEVICE_ERROR:
 
1045
  case CKR_DEVICE_MEMORY:
 
1046
  case CKR_FUNCTION_FAILED:
 
1047
  case CKR_GENERAL_ERROR:
 
1048
  case CKR_HOST_MEMORY:
 
1049
  case CKR_PIN_INCORRECT:
 
1050
  case CKR_PIN_LOCKED:
 
1051
  case CKR_SESSION_EXISTS:
 
1052
  case CKR_SLOT_ID_INVALID:
 
1053
  case CKR_TOKEN_NOT_RECOGNIZED:
 
1054
  case CKR_TOKEN_WRITE_PROTECTED:
 
1055
    break;
 
1056
  default:
 
1057
  case CKR_OK:
 
1058
    error = CKR_GENERAL_ERROR;
 
1059
    break;
 
1060
  }
 
1061
 
 
1062
  return error;
 
1063
}
 
1064
 
 
1065
/*
 
1066
 * NSSCKFWC_InitPIN
 
1067
 *
 
1068
 */
 
1069
NSS_IMPLEMENT CK_RV
 
1070
NSSCKFWC_InitPIN
 
1071
(
 
1072
  NSSCKFWInstance *fwInstance,
 
1073
  CK_SESSION_HANDLE hSession,
 
1074
  CK_CHAR_PTR pPin,
 
1075
  CK_ULONG ulPinLen
 
1076
)
 
1077
{
 
1078
  CK_RV error = CKR_OK;
 
1079
  NSSCKFWSession *fwSession;
 
1080
  NSSItem pin, *arg;
 
1081
 
 
1082
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
1083
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
1084
    goto loser;
 
1085
  }
 
1086
 
 
1087
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
1088
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
1089
    error = CKR_SESSION_HANDLE_INVALID;
 
1090
    goto loser;
 
1091
  }
 
1092
 
 
1093
  if( (CK_CHAR_PTR)CK_NULL_PTR == pPin ) {
 
1094
    arg = (NSSItem *)NULL;
 
1095
  } else {
 
1096
    arg = &pin;
 
1097
    pin.size = (PRUint32)ulPinLen;
 
1098
    pin.data = (void *)pPin;
 
1099
  }
 
1100
 
 
1101
  error = nssCKFWSession_InitPIN(fwSession, arg);
 
1102
  if( CKR_OK != error ) {
 
1103
    goto loser;
 
1104
  }
 
1105
 
 
1106
  return CKR_OK;
 
1107
 
 
1108
 loser:
 
1109
  switch( error ) {
 
1110
  case CKR_SESSION_CLOSED:
 
1111
    /* destroy session? */
 
1112
    break;
 
1113
  case CKR_DEVICE_REMOVED:
 
1114
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
1115
    break;
 
1116
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1117
  case CKR_DEVICE_ERROR:
 
1118
  case CKR_DEVICE_MEMORY:
 
1119
  case CKR_FUNCTION_FAILED:
 
1120
  case CKR_GENERAL_ERROR:
 
1121
  case CKR_HOST_MEMORY:
 
1122
  case CKR_PIN_INVALID:
 
1123
  case CKR_PIN_LEN_RANGE:
 
1124
  case CKR_SESSION_READ_ONLY:
 
1125
  case CKR_SESSION_HANDLE_INVALID:
 
1126
  case CKR_TOKEN_WRITE_PROTECTED:
 
1127
  case CKR_USER_NOT_LOGGED_IN:
 
1128
    break;
 
1129
  default:
 
1130
  case CKR_OK:
 
1131
    error = CKR_GENERAL_ERROR;
 
1132
    break;
 
1133
  }
 
1134
 
 
1135
  return error;
 
1136
}
 
1137
 
 
1138
/*
 
1139
 * NSSCKFWC_SetPIN
 
1140
 *
 
1141
 */
 
1142
NSS_IMPLEMENT CK_RV
 
1143
NSSCKFWC_SetPIN
 
1144
(
 
1145
  NSSCKFWInstance *fwInstance,
 
1146
  CK_SESSION_HANDLE hSession,
 
1147
  CK_CHAR_PTR pOldPin,
 
1148
  CK_ULONG ulOldLen,
 
1149
  CK_CHAR_PTR pNewPin,
 
1150
  CK_ULONG ulNewLen
 
1151
)
 
1152
{
 
1153
  CK_RV error = CKR_OK;
 
1154
  NSSCKFWSession *fwSession;
 
1155
  NSSItem oldPin, newPin, *oldArg, *newArg;
 
1156
 
 
1157
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
1158
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
1159
    goto loser;
 
1160
  }
 
1161
 
 
1162
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
1163
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
1164
    error = CKR_SESSION_HANDLE_INVALID;
 
1165
    goto loser;
 
1166
  }
 
1167
 
 
1168
  if( (CK_CHAR_PTR)CK_NULL_PTR == pOldPin ) {
 
1169
    oldArg = (NSSItem *)NULL;
 
1170
  } else {
 
1171
    oldArg = &oldPin;
 
1172
    oldPin.size = (PRUint32)ulOldLen;
 
1173
    oldPin.data = (void *)pOldPin;
 
1174
  }
 
1175
 
 
1176
  if( (CK_CHAR_PTR)CK_NULL_PTR == pNewPin ) {
 
1177
    newArg = (NSSItem *)NULL;
 
1178
  } else {
 
1179
    newArg = &newPin;
 
1180
    newPin.size = (PRUint32)ulNewLen;
 
1181
    newPin.data = (void *)pNewPin;
 
1182
  }
 
1183
 
 
1184
  error = nssCKFWSession_SetPIN(fwSession, oldArg, newArg);
 
1185
  if( CKR_OK != error ) {
 
1186
    goto loser;
 
1187
  }
 
1188
 
 
1189
  return CKR_OK;
 
1190
 
 
1191
 loser:
 
1192
  switch( error ) {
 
1193
  case CKR_SESSION_CLOSED:
 
1194
    /* destroy session? */
 
1195
    break;
 
1196
  case CKR_DEVICE_REMOVED:
 
1197
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
1198
    break;
 
1199
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1200
  case CKR_DEVICE_ERROR:
 
1201
  case CKR_DEVICE_MEMORY:
 
1202
  case CKR_FUNCTION_FAILED:
 
1203
  case CKR_GENERAL_ERROR:
 
1204
  case CKR_HOST_MEMORY:
 
1205
  case CKR_PIN_INCORRECT:
 
1206
  case CKR_PIN_INVALID:
 
1207
  case CKR_PIN_LEN_RANGE:
 
1208
  case CKR_PIN_LOCKED:
 
1209
  case CKR_SESSION_HANDLE_INVALID:
 
1210
  case CKR_SESSION_READ_ONLY:
 
1211
  case CKR_TOKEN_WRITE_PROTECTED:
 
1212
    break;
 
1213
  default:
 
1214
  case CKR_OK:
 
1215
    error = CKR_GENERAL_ERROR;
 
1216
    break;
 
1217
  }
 
1218
 
 
1219
  return error;
 
1220
}
 
1221
 
 
1222
/*
 
1223
 * NSSCKFWC_OpenSession
 
1224
 *
 
1225
 */
 
1226
NSS_IMPLEMENT CK_RV
 
1227
NSSCKFWC_OpenSession
 
1228
(
 
1229
  NSSCKFWInstance *fwInstance,
 
1230
  CK_SLOT_ID slotID,
 
1231
  CK_FLAGS flags,
 
1232
  CK_VOID_PTR pApplication,
 
1233
  CK_NOTIFY Notify,
 
1234
  CK_SESSION_HANDLE_PTR phSession
 
1235
)
 
1236
{
 
1237
  CK_RV error = CKR_OK;
 
1238
  CK_ULONG nSlots;
 
1239
  NSSCKFWSlot **slots;
 
1240
  NSSCKFWSlot *fwSlot;
 
1241
  NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
 
1242
  NSSCKFWSession *fwSession;
 
1243
  CK_BBOOL rw;
 
1244
 
 
1245
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
1246
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
1247
    goto loser;
 
1248
  }
 
1249
 
 
1250
  nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
 
1251
  if( (CK_ULONG)0 == nSlots ) {
 
1252
    goto loser;
 
1253
  }
 
1254
 
 
1255
  if( (slotID < 1) || (slotID > nSlots) ) {
 
1256
    error = CKR_SLOT_ID_INVALID;
 
1257
    goto loser;
 
1258
  }
 
1259
 
 
1260
  if( flags & CKF_RW_SESSION ) {
 
1261
    rw = CK_TRUE;
 
1262
  } else {
 
1263
    rw = CK_FALSE;
 
1264
  }
 
1265
 
 
1266
  if( flags & CKF_SERIAL_SESSION ) {
 
1267
    ;
 
1268
  } else {
 
1269
    error = CKR_SESSION_PARALLEL_NOT_SUPPORTED;
 
1270
    goto loser;
 
1271
  }
 
1272
 
 
1273
  if( flags & ~(CKF_RW_SESSION|CKF_SERIAL_SESSION) ) {
 
1274
    error = CKR_ARGUMENTS_BAD;
 
1275
    goto loser;
 
1276
  }
 
1277
 
 
1278
  if( (CK_SESSION_HANDLE_PTR)CK_NULL_PTR == phSession ) {
 
1279
    error = CKR_ARGUMENTS_BAD;
 
1280
    goto loser;
 
1281
  }
 
1282
 
 
1283
  /*
 
1284
   * A purify error here indicates caller error.
 
1285
   */
 
1286
  *phSession = (CK_SESSION_HANDLE)0;
 
1287
 
 
1288
  slots = nssCKFWInstance_GetSlots(fwInstance, &error);
 
1289
  if( (NSSCKFWSlot **)NULL == slots ) {
 
1290
    goto loser;
 
1291
  }
 
1292
 
 
1293
  fwSlot = slots[ slotID-1 ];
 
1294
 
 
1295
  if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
 
1296
    error = CKR_TOKEN_NOT_PRESENT;
 
1297
    goto loser;
 
1298
  }
 
1299
 
 
1300
  fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
 
1301
  if( (NSSCKFWToken *)NULL == fwToken ) {
 
1302
    goto loser;
 
1303
  }
 
1304
 
 
1305
  fwSession = nssCKFWToken_OpenSession(fwToken, rw, pApplication,
 
1306
               Notify, &error);
 
1307
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
1308
    goto loser;
 
1309
  }
 
1310
 
 
1311
  *phSession = nssCKFWInstance_CreateSessionHandle(fwInstance,
 
1312
                 fwSession, &error);
 
1313
  if( (CK_SESSION_HANDLE)0 == *phSession ) {
 
1314
    goto loser;
 
1315
  }
 
1316
 
 
1317
  return CKR_OK;
 
1318
 
 
1319
 loser:
 
1320
  switch( error ) {
 
1321
  case CKR_SESSION_CLOSED:
 
1322
    /* destroy session? */
 
1323
    break;
 
1324
  case CKR_DEVICE_REMOVED:
 
1325
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
1326
    break;
 
1327
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1328
  case CKR_DEVICE_ERROR:
 
1329
  case CKR_DEVICE_MEMORY:
 
1330
  case CKR_FUNCTION_FAILED:
 
1331
  case CKR_GENERAL_ERROR:
 
1332
  case CKR_HOST_MEMORY:
 
1333
  case CKR_SESSION_COUNT:
 
1334
  case CKR_SESSION_EXISTS:
 
1335
  case CKR_SESSION_PARALLEL_NOT_SUPPORTED:
 
1336
  case CKR_SESSION_READ_WRITE_SO_EXISTS:
 
1337
  case CKR_SLOT_ID_INVALID:
 
1338
  case CKR_TOKEN_NOT_PRESENT:
 
1339
  case CKR_TOKEN_NOT_RECOGNIZED:
 
1340
  case CKR_TOKEN_WRITE_PROTECTED:
 
1341
    break;
 
1342
  default:
 
1343
  case CKR_OK:
 
1344
    error = CKR_GENERAL_ERROR;
 
1345
    break;
 
1346
  }
 
1347
 
 
1348
  return error;
 
1349
}
 
1350
 
 
1351
/*
 
1352
 * NSSCKFWC_CloseSession
 
1353
 *
 
1354
 */
 
1355
NSS_IMPLEMENT CK_RV
 
1356
NSSCKFWC_CloseSession
 
1357
(
 
1358
  NSSCKFWInstance *fwInstance,
 
1359
  CK_SESSION_HANDLE hSession
 
1360
)
 
1361
{
 
1362
  CK_RV error = CKR_OK;
 
1363
  NSSCKFWSession *fwSession;
 
1364
 
 
1365
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
1366
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
1367
    goto loser;
 
1368
  }
 
1369
 
 
1370
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
1371
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
1372
    error = CKR_SESSION_HANDLE_INVALID;
 
1373
    goto loser;
 
1374
  }
 
1375
 
 
1376
  nssCKFWInstance_DestroySessionHandle(fwInstance, hSession);
 
1377
  error = nssCKFWSession_Destroy(fwSession, CK_TRUE);
 
1378
 
 
1379
  if( CKR_OK != error ) {
 
1380
    goto loser;
 
1381
  }
 
1382
 
 
1383
  return CKR_OK;
 
1384
 
 
1385
 loser:
 
1386
  switch( error ) {
 
1387
  case CKR_SESSION_CLOSED:
 
1388
    /* destroy session? */
 
1389
    break;
 
1390
  case CKR_DEVICE_REMOVED:
 
1391
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
1392
    break;
 
1393
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1394
  case CKR_DEVICE_ERROR:
 
1395
  case CKR_DEVICE_MEMORY:
 
1396
  case CKR_FUNCTION_FAILED:
 
1397
  case CKR_GENERAL_ERROR:
 
1398
  case CKR_HOST_MEMORY:
 
1399
  case CKR_SESSION_HANDLE_INVALID:
 
1400
    break;
 
1401
  default:
 
1402
  case CKR_OK:
 
1403
    error = CKR_GENERAL_ERROR;
 
1404
    break;
 
1405
  }
 
1406
 
 
1407
  return error;
 
1408
}
 
1409
 
 
1410
/*
 
1411
 * NSSCKFWC_CloseAllSessions
 
1412
 *
 
1413
 */
 
1414
NSS_IMPLEMENT CK_RV
 
1415
NSSCKFWC_CloseAllSessions
 
1416
(
 
1417
  NSSCKFWInstance *fwInstance,
 
1418
  CK_SLOT_ID slotID
 
1419
)
 
1420
{
 
1421
  CK_RV error = CKR_OK;
 
1422
  CK_ULONG nSlots;
 
1423
  NSSCKFWSlot **slots;
 
1424
  NSSCKFWSlot *fwSlot;
 
1425
  NSSCKFWToken *fwToken = (NSSCKFWToken *)NULL;
 
1426
 
 
1427
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
1428
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
1429
    goto loser;
 
1430
  }
 
1431
 
 
1432
  nSlots = nssCKFWInstance_GetNSlots(fwInstance, &error);
 
1433
  if( (CK_ULONG)0 == nSlots ) {
 
1434
    goto loser;
 
1435
  }
 
1436
 
 
1437
  if( (slotID < 1) || (slotID > nSlots) ) {
 
1438
    error = CKR_SLOT_ID_INVALID;
 
1439
    goto loser;
 
1440
  }
 
1441
 
 
1442
  slots = nssCKFWInstance_GetSlots(fwInstance, &error);
 
1443
  if( (NSSCKFWSlot **)NULL == slots ) {
 
1444
    goto loser;
 
1445
  }
 
1446
 
 
1447
  fwSlot = slots[ slotID-1 ];
 
1448
 
 
1449
  if( CK_TRUE != nssCKFWSlot_GetTokenPresent(fwSlot) ) {
 
1450
    error = CKR_TOKEN_NOT_PRESENT;
 
1451
    goto loser;
 
1452
  }
 
1453
 
 
1454
  fwToken = nssCKFWSlot_GetToken(fwSlot, &error);
 
1455
  if( (NSSCKFWToken *)NULL == fwToken ) {
 
1456
    goto loser;
 
1457
  }
 
1458
 
 
1459
  error = nssCKFWToken_CloseAllSessions(fwToken);
 
1460
  if( CKR_OK != error ) {
 
1461
    goto loser;
 
1462
  }
 
1463
 
 
1464
  return CKR_OK;
 
1465
 
 
1466
 loser:
 
1467
  switch( error ) {
 
1468
  case CKR_DEVICE_REMOVED:
 
1469
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
1470
    break;
 
1471
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1472
  case CKR_DEVICE_ERROR:
 
1473
  case CKR_DEVICE_MEMORY:
 
1474
  case CKR_FUNCTION_FAILED:
 
1475
  case CKR_GENERAL_ERROR:
 
1476
  case CKR_HOST_MEMORY:
 
1477
  case CKR_SLOT_ID_INVALID:
 
1478
  case CKR_TOKEN_NOT_PRESENT:
 
1479
    break;
 
1480
  default:
 
1481
  case CKR_OK:
 
1482
    error = CKR_GENERAL_ERROR;
 
1483
    break;
 
1484
  }
 
1485
 
 
1486
  return error;
 
1487
}
 
1488
 
 
1489
/*
 
1490
 * NSSCKFWC_GetSessionInfo
 
1491
 *
 
1492
 */
 
1493
NSS_IMPLEMENT CK_RV
 
1494
NSSCKFWC_GetSessionInfo
 
1495
(
 
1496
  NSSCKFWInstance *fwInstance,
 
1497
  CK_SESSION_HANDLE hSession,
 
1498
  CK_SESSION_INFO_PTR pInfo
 
1499
)
 
1500
{
 
1501
  CK_RV error = CKR_OK;
 
1502
  NSSCKFWSession *fwSession;
 
1503
  NSSCKFWSlot *fwSlot;
 
1504
 
 
1505
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
1506
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
1507
    goto loser;
 
1508
  }
 
1509
 
 
1510
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
1511
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
1512
    error = CKR_SESSION_HANDLE_INVALID;
 
1513
    goto loser;
 
1514
  }
 
1515
 
 
1516
  if( (CK_SESSION_INFO_PTR)CK_NULL_PTR == pInfo ) {
 
1517
    error = CKR_ARGUMENTS_BAD;
 
1518
    goto loser;
 
1519
  }
 
1520
 
 
1521
  /*
 
1522
   * A purify error here indicates caller error.
 
1523
   */
 
1524
  (void)nsslibc_memset(pInfo, 0, sizeof(CK_SESSION_INFO));
 
1525
 
 
1526
  fwSlot = nssCKFWSession_GetFWSlot(fwSession);
 
1527
  if( (NSSCKFWSlot *)NULL == fwSlot ) {
 
1528
    error = CKR_GENERAL_ERROR;
 
1529
    goto loser;
 
1530
  }
 
1531
 
 
1532
  pInfo->slotID = nssCKFWSlot_GetSlotID(fwSlot);
 
1533
  pInfo->state = nssCKFWSession_GetSessionState(fwSession);
 
1534
 
 
1535
  if( CK_TRUE == nssCKFWSession_IsRWSession(fwSession) ) {
 
1536
    pInfo->flags |= CKF_RW_SESSION;
 
1537
  }
 
1538
 
 
1539
  pInfo->flags |= CKF_SERIAL_SESSION; /* Always true */
 
1540
 
 
1541
  pInfo->ulDeviceError = nssCKFWSession_GetDeviceError(fwSession);
 
1542
 
 
1543
  return CKR_OK;
 
1544
 
 
1545
 loser:
 
1546
  switch( error ) {
 
1547
  case CKR_SESSION_CLOSED:
 
1548
    /* destroy session? */
 
1549
    break;
 
1550
  case CKR_DEVICE_REMOVED:
 
1551
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
1552
    break;
 
1553
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1554
  case CKR_DEVICE_ERROR:
 
1555
  case CKR_DEVICE_MEMORY:
 
1556
  case CKR_FUNCTION_FAILED:
 
1557
  case CKR_GENERAL_ERROR:
 
1558
  case CKR_HOST_MEMORY:
 
1559
  case CKR_SESSION_HANDLE_INVALID:
 
1560
    break;
 
1561
  default:
 
1562
  case CKR_OK:
 
1563
    error = CKR_GENERAL_ERROR;
 
1564
    break;
 
1565
  }
 
1566
 
 
1567
  return error;
 
1568
}
 
1569
 
 
1570
/*
 
1571
 * NSSCKFWC_GetOperationState
 
1572
 *
 
1573
 */
 
1574
NSS_IMPLEMENT CK_RV
 
1575
NSSCKFWC_GetOperationState
 
1576
(
 
1577
  NSSCKFWInstance *fwInstance,
 
1578
  CK_SESSION_HANDLE hSession,
 
1579
  CK_BYTE_PTR pOperationState,
 
1580
  CK_ULONG_PTR pulOperationStateLen
 
1581
)
 
1582
{
 
1583
  CK_RV error = CKR_OK;
 
1584
  NSSCKFWSession *fwSession;
 
1585
  CK_ULONG len;
 
1586
  NSSItem buf;
 
1587
 
 
1588
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
1589
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
1590
    goto loser;
 
1591
  }
 
1592
 
 
1593
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
1594
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
1595
    error = CKR_SESSION_HANDLE_INVALID;
 
1596
    goto loser;
 
1597
  }
 
1598
 
 
1599
  if( (CK_ULONG_PTR)CK_NULL_PTR == pulOperationStateLen ) {
 
1600
    error = CKR_ARGUMENTS_BAD;
 
1601
    goto loser;
 
1602
  }
 
1603
 
 
1604
  len = nssCKFWSession_GetOperationStateLen(fwSession, &error);
 
1605
  if( ((CK_ULONG)0 == len) && (CKR_OK != error) ) {
 
1606
    goto loser;
 
1607
  }
 
1608
 
 
1609
  if( (CK_BYTE_PTR)CK_NULL_PTR == pOperationState ) {
 
1610
    *pulOperationStateLen = len;
 
1611
    return CKR_OK;
 
1612
  }
 
1613
 
 
1614
  if( *pulOperationStateLen < len ) {
 
1615
    *pulOperationStateLen = len;
 
1616
    error = CKR_BUFFER_TOO_SMALL;
 
1617
    goto loser;
 
1618
  }
 
1619
 
 
1620
  buf.size = (PRUint32)*pulOperationStateLen;
 
1621
  buf.data = (void *)pOperationState;
 
1622
  *pulOperationStateLen = len;
 
1623
  error = nssCKFWSession_GetOperationState(fwSession, &buf);
 
1624
 
 
1625
  if( CKR_OK != error ) {
 
1626
    goto loser;
 
1627
  }
 
1628
 
 
1629
  return CKR_OK;
 
1630
 
 
1631
 loser:
 
1632
  switch( error ) {
 
1633
  case CKR_SESSION_CLOSED:
 
1634
    /* destroy session? */
 
1635
    break;
 
1636
  case CKR_DEVICE_REMOVED:
 
1637
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
1638
    break;
 
1639
  case CKR_BUFFER_TOO_SMALL:
 
1640
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1641
  case CKR_DEVICE_ERROR:
 
1642
  case CKR_DEVICE_MEMORY:
 
1643
  case CKR_FUNCTION_FAILED:
 
1644
  case CKR_GENERAL_ERROR:
 
1645
  case CKR_HOST_MEMORY:
 
1646
  case CKR_OPERATION_NOT_INITIALIZED:
 
1647
  case CKR_SESSION_HANDLE_INVALID:
 
1648
  case CKR_STATE_UNSAVEABLE:
 
1649
    break;
 
1650
  default:
 
1651
  case CKR_OK:
 
1652
    error = CKR_GENERAL_ERROR;
 
1653
    break;
 
1654
  }
 
1655
 
 
1656
  return error;
 
1657
}
 
1658
 
 
1659
/*
 
1660
 * NSSCKFWC_SetOperationState
 
1661
 *
 
1662
 */
 
1663
NSS_IMPLEMENT CK_RV
 
1664
NSSCKFWC_SetOperationState
 
1665
(
 
1666
  NSSCKFWInstance *fwInstance,
 
1667
  CK_SESSION_HANDLE hSession,
 
1668
  CK_BYTE_PTR pOperationState,
 
1669
  CK_ULONG ulOperationStateLen,
 
1670
  CK_OBJECT_HANDLE hEncryptionKey,
 
1671
  CK_OBJECT_HANDLE hAuthenticationKey
 
1672
)
 
1673
{
 
1674
  CK_RV error = CKR_OK;
 
1675
  NSSCKFWSession *fwSession;
 
1676
  NSSCKFWObject *eKey;
 
1677
  NSSCKFWObject *aKey;
 
1678
  NSSItem state;
 
1679
 
 
1680
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
1681
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
1682
    goto loser;
 
1683
  }
 
1684
  
 
1685
  if( (CK_BYTE_PTR)CK_NULL_PTR == pOperationState ) {
 
1686
    error = CKR_ARGUMENTS_BAD;
 
1687
    goto loser;
 
1688
  }
 
1689
 
 
1690
  /* 
 
1691
   * We could loop through the buffer, to catch any purify errors
 
1692
   * in a place with a "user error" note.
 
1693
   */
 
1694
 
 
1695
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
1696
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
1697
    error = CKR_SESSION_HANDLE_INVALID;
 
1698
    goto loser;
 
1699
  }
 
1700
 
 
1701
  if( (CK_OBJECT_HANDLE)0 == hEncryptionKey ) {
 
1702
    eKey = (NSSCKFWObject *)NULL;
 
1703
  } else {
 
1704
    eKey = nssCKFWInstance_ResolveObjectHandle(fwInstance, hEncryptionKey);
 
1705
    if( (NSSCKFWObject *)NULL == eKey ) {
 
1706
      error = CKR_KEY_HANDLE_INVALID;
 
1707
      goto loser;
 
1708
    }
 
1709
  }
 
1710
 
 
1711
  if( (CK_OBJECT_HANDLE)0 == hAuthenticationKey ) {
 
1712
    aKey = (NSSCKFWObject *)NULL;
 
1713
  } else {
 
1714
    aKey = nssCKFWInstance_ResolveObjectHandle(fwInstance, hAuthenticationKey);
 
1715
    if( (NSSCKFWObject *)NULL == aKey ) {
 
1716
      error = CKR_KEY_HANDLE_INVALID;
 
1717
      goto loser;
 
1718
    }
 
1719
  }
 
1720
 
 
1721
  error = nssCKFWSession_SetOperationState(fwSession, &state, eKey, aKey);
 
1722
  if( CKR_OK != error ) {
 
1723
    goto loser;
 
1724
  }
 
1725
 
 
1726
  return CKR_OK;
 
1727
 
 
1728
 loser:
 
1729
  switch( error ) {
 
1730
  case CKR_SESSION_CLOSED:
 
1731
    /* destroy session? */
 
1732
    break;
 
1733
  case CKR_DEVICE_REMOVED:
 
1734
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
1735
    break;
 
1736
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1737
  case CKR_DEVICE_ERROR:
 
1738
  case CKR_DEVICE_MEMORY:
 
1739
  case CKR_FUNCTION_FAILED:
 
1740
  case CKR_GENERAL_ERROR:
 
1741
  case CKR_HOST_MEMORY:
 
1742
  case CKR_KEY_CHANGED:
 
1743
  case CKR_KEY_NEEDED:
 
1744
  case CKR_KEY_NOT_NEEDED:
 
1745
  case CKR_SAVED_STATE_INVALID:
 
1746
  case CKR_SESSION_HANDLE_INVALID:
 
1747
    break;
 
1748
  default:
 
1749
  case CKR_OK:
 
1750
    error = CKR_GENERAL_ERROR;
 
1751
    break;
 
1752
  }
 
1753
 
 
1754
  return error;
 
1755
}
 
1756
 
 
1757
/*
 
1758
 * NSSCKFWC_Login
 
1759
 *
 
1760
 */
 
1761
NSS_IMPLEMENT CK_RV
 
1762
NSSCKFWC_Login
 
1763
(
 
1764
  NSSCKFWInstance *fwInstance,
 
1765
  CK_SESSION_HANDLE hSession,
 
1766
  CK_USER_TYPE userType,
 
1767
  CK_CHAR_PTR pPin,
 
1768
  CK_ULONG ulPinLen
 
1769
)
 
1770
{
 
1771
  CK_RV error = CKR_OK;
 
1772
  NSSCKFWSession *fwSession;
 
1773
  NSSItem pin, *arg;
 
1774
 
 
1775
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
1776
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
1777
    goto loser;
 
1778
  }
 
1779
  
 
1780
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
1781
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
1782
    error = CKR_SESSION_HANDLE_INVALID;
 
1783
    goto loser;
 
1784
  }
 
1785
 
 
1786
  if( (CK_CHAR_PTR)CK_NULL_PTR == pPin ) {
 
1787
    arg = (NSSItem *)NULL;
 
1788
  } else {
 
1789
    arg = &pin;
 
1790
    pin.size = (PRUint32)ulPinLen;
 
1791
    pin.data = (void *)pPin;
 
1792
  }
 
1793
 
 
1794
  error = nssCKFWSession_Login(fwSession, userType, arg);
 
1795
  if( CKR_OK != error ) {
 
1796
    goto loser;
 
1797
  }
 
1798
 
 
1799
  return CKR_OK;
 
1800
 
 
1801
 loser:
 
1802
  switch( error ) {
 
1803
  case CKR_SESSION_CLOSED:
 
1804
    /* destroy session? */
 
1805
    break;
 
1806
  case CKR_DEVICE_REMOVED:
 
1807
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
1808
    break;
 
1809
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1810
  case CKR_DEVICE_ERROR:
 
1811
  case CKR_DEVICE_MEMORY:
 
1812
  case CKR_FUNCTION_FAILED:
 
1813
  case CKR_GENERAL_ERROR:
 
1814
  case CKR_HOST_MEMORY:
 
1815
  case CKR_PIN_EXPIRED:
 
1816
  case CKR_PIN_INCORRECT:
 
1817
  case CKR_PIN_LOCKED:
 
1818
  case CKR_SESSION_HANDLE_INVALID:
 
1819
  case CKR_SESSION_READ_ONLY_EXISTS:
 
1820
  case CKR_USER_ALREADY_LOGGED_IN:
 
1821
  case CKR_USER_ANOTHER_ALREADY_LOGGED_IN:
 
1822
  case CKR_USER_PIN_NOT_INITIALIZED:
 
1823
  case CKR_USER_TOO_MANY_TYPES:
 
1824
  case CKR_USER_TYPE_INVALID:
 
1825
    break;
 
1826
  default:
 
1827
  case CKR_OK:
 
1828
    error = CKR_GENERAL_ERROR;
 
1829
    break;
 
1830
  }
 
1831
 
 
1832
  return error;
 
1833
}
 
1834
 
 
1835
/*
 
1836
 * NSSCKFWC_Logout
 
1837
 *
 
1838
 */
 
1839
NSS_IMPLEMENT CK_RV
 
1840
NSSCKFWC_Logout
 
1841
(
 
1842
  NSSCKFWInstance *fwInstance,
 
1843
  CK_SESSION_HANDLE hSession
 
1844
)
 
1845
{
 
1846
  CK_RV error = CKR_OK;
 
1847
  NSSCKFWSession *fwSession;
 
1848
 
 
1849
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
1850
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
1851
    goto loser;
 
1852
  }
 
1853
  
 
1854
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
1855
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
1856
    error = CKR_SESSION_HANDLE_INVALID;
 
1857
    goto loser;
 
1858
  }
 
1859
 
 
1860
  error = nssCKFWSession_Logout(fwSession);
 
1861
  if( CKR_OK != error ) {
 
1862
    goto loser;
 
1863
  }
 
1864
 
 
1865
  return CKR_OK;
 
1866
 
 
1867
 loser:
 
1868
  switch( error ) {
 
1869
  case CKR_SESSION_CLOSED:
 
1870
    /* destroy session? */
 
1871
    break;
 
1872
  case CKR_DEVICE_REMOVED:
 
1873
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
1874
    break;
 
1875
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1876
  case CKR_DEVICE_ERROR:
 
1877
  case CKR_DEVICE_MEMORY:
 
1878
  case CKR_FUNCTION_FAILED:
 
1879
  case CKR_GENERAL_ERROR:
 
1880
  case CKR_HOST_MEMORY:
 
1881
  case CKR_SESSION_HANDLE_INVALID:
 
1882
  case CKR_USER_NOT_LOGGED_IN:
 
1883
    break;
 
1884
  default:
 
1885
  case CKR_OK:
 
1886
    error = CKR_GENERAL_ERROR;
 
1887
    break;
 
1888
  }
 
1889
 
 
1890
  return error;
 
1891
}
 
1892
 
 
1893
/*
 
1894
 * NSSCKFWC_CreateObject
 
1895
 *
 
1896
 */
 
1897
NSS_IMPLEMENT CK_RV
 
1898
NSSCKFWC_CreateObject
 
1899
(
 
1900
  NSSCKFWInstance *fwInstance,
 
1901
  CK_SESSION_HANDLE hSession,
 
1902
  CK_ATTRIBUTE_PTR pTemplate,
 
1903
  CK_ULONG ulCount,
 
1904
  CK_OBJECT_HANDLE_PTR phObject
 
1905
)
 
1906
{
 
1907
  CK_RV error = CKR_OK;
 
1908
  NSSCKFWSession *fwSession;
 
1909
  NSSCKFWObject *fwObject;
 
1910
 
 
1911
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
1912
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
1913
    goto loser;
 
1914
  }
 
1915
  
 
1916
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
1917
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
1918
    error = CKR_SESSION_HANDLE_INVALID;
 
1919
    goto loser;
 
1920
  }
 
1921
 
 
1922
  if( (CK_OBJECT_HANDLE_PTR)CK_NULL_PTR == phObject ) {
 
1923
    error = CKR_ARGUMENTS_BAD;
 
1924
    goto loser;
 
1925
  }
 
1926
 
 
1927
  /*
 
1928
   * A purify error here indicates caller error.
 
1929
   */
 
1930
  *phObject = (CK_OBJECT_HANDLE)0;
 
1931
 
 
1932
  fwObject = nssCKFWSession_CreateObject(fwSession, pTemplate,
 
1933
               ulCount, &error);
 
1934
  if( (NSSCKFWObject *)NULL == fwObject ) {
 
1935
    goto loser;
 
1936
  }
 
1937
 
 
1938
  *phObject = nssCKFWInstance_CreateObjectHandle(fwInstance, fwObject, &error);
 
1939
  if( (CK_OBJECT_HANDLE)0 == *phObject ) {
 
1940
    nssCKFWObject_Destroy(fwObject);
 
1941
    goto loser;
 
1942
  }
 
1943
 
 
1944
  return CKR_OK;
 
1945
 
 
1946
 loser:
 
1947
  switch( error ) {
 
1948
  case CKR_SESSION_CLOSED:
 
1949
    /* destroy session? */
 
1950
    break;
 
1951
  case CKR_DEVICE_REMOVED:
 
1952
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
1953
    break;
 
1954
  case CKR_ATTRIBUTE_READ_ONLY:
 
1955
  case CKR_ATTRIBUTE_TYPE_INVALID:
 
1956
  case CKR_ATTRIBUTE_VALUE_INVALID:
 
1957
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
1958
  case CKR_DEVICE_ERROR:
 
1959
  case CKR_DEVICE_MEMORY:
 
1960
  case CKR_FUNCTION_FAILED:
 
1961
  case CKR_GENERAL_ERROR:
 
1962
  case CKR_HOST_MEMORY:
 
1963
  case CKR_SESSION_HANDLE_INVALID:
 
1964
  case CKR_SESSION_READ_ONLY:
 
1965
  case CKR_TEMPLATE_INCOMPLETE:
 
1966
  case CKR_TEMPLATE_INCONSISTENT:
 
1967
  case CKR_TOKEN_WRITE_PROTECTED:
 
1968
  case CKR_USER_NOT_LOGGED_IN:
 
1969
    break;
 
1970
  default:
 
1971
  case CKR_OK:
 
1972
    error = CKR_GENERAL_ERROR;
 
1973
    break;
 
1974
  }
 
1975
 
 
1976
  return error;
 
1977
}
 
1978
 
 
1979
/*
 
1980
 * NSSCKFWC_CopyObject
 
1981
 *
 
1982
 */
 
1983
NSS_IMPLEMENT CK_RV
 
1984
NSSCKFWC_CopyObject
 
1985
(
 
1986
  NSSCKFWInstance *fwInstance,
 
1987
  CK_SESSION_HANDLE hSession,
 
1988
  CK_OBJECT_HANDLE hObject,
 
1989
  CK_ATTRIBUTE_PTR pTemplate,
 
1990
  CK_ULONG ulCount,
 
1991
  CK_OBJECT_HANDLE_PTR phNewObject
 
1992
)
 
1993
{
 
1994
  CK_RV error = CKR_OK;
 
1995
  NSSCKFWSession *fwSession;
 
1996
  NSSCKFWObject *fwObject;
 
1997
  NSSCKFWObject *fwNewObject;
 
1998
 
 
1999
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
2000
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
2001
    goto loser;
 
2002
  }
 
2003
  
 
2004
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
2005
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
2006
    error = CKR_SESSION_HANDLE_INVALID;
 
2007
    goto loser;
 
2008
  }
 
2009
 
 
2010
  if( (CK_OBJECT_HANDLE_PTR)CK_NULL_PTR == phNewObject ) {
 
2011
    error = CKR_ARGUMENTS_BAD;
 
2012
    goto loser;
 
2013
  }
 
2014
 
 
2015
  /*
 
2016
   * A purify error here indicates caller error.
 
2017
   */
 
2018
  *phNewObject = (CK_OBJECT_HANDLE)0;
 
2019
 
 
2020
  fwObject = nssCKFWInstance_ResolveObjectHandle(fwInstance, hObject);
 
2021
  if( (NSSCKFWObject *)NULL == fwObject ) {
 
2022
    error = CKR_OBJECT_HANDLE_INVALID;
 
2023
    goto loser;
 
2024
  }
 
2025
 
 
2026
  fwNewObject = nssCKFWSession_CopyObject(fwSession, fwObject,
 
2027
                  pTemplate, ulCount, &error);
 
2028
  if( (NSSCKFWObject *)NULL == fwNewObject ) {
 
2029
    goto loser;
 
2030
  }
 
2031
 
 
2032
  *phNewObject = nssCKFWInstance_CreateObjectHandle(fwInstance, 
 
2033
                   fwNewObject, &error);
 
2034
  if( (CK_OBJECT_HANDLE)0 == *phNewObject ) {
 
2035
    nssCKFWObject_Destroy(fwNewObject);
 
2036
    goto loser;
 
2037
  }
 
2038
 
 
2039
  return CKR_OK;
 
2040
 
 
2041
 loser:
 
2042
  switch( error ) {
 
2043
  case CKR_SESSION_CLOSED:
 
2044
    /* destroy session? */
 
2045
    break;
 
2046
  case CKR_DEVICE_REMOVED:
 
2047
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
2048
    break;
 
2049
  case CKR_ATTRIBUTE_READ_ONLY:
 
2050
  case CKR_ATTRIBUTE_TYPE_INVALID:
 
2051
  case CKR_ATTRIBUTE_VALUE_INVALID:
 
2052
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
2053
  case CKR_DEVICE_ERROR:
 
2054
  case CKR_DEVICE_MEMORY:
 
2055
  case CKR_FUNCTION_FAILED:
 
2056
  case CKR_GENERAL_ERROR:
 
2057
  case CKR_HOST_MEMORY:
 
2058
  case CKR_OBJECT_HANDLE_INVALID:
 
2059
  case CKR_SESSION_HANDLE_INVALID:
 
2060
  case CKR_SESSION_READ_ONLY:
 
2061
  case CKR_TEMPLATE_INCONSISTENT:
 
2062
  case CKR_TOKEN_WRITE_PROTECTED:
 
2063
  case CKR_USER_NOT_LOGGED_IN:
 
2064
    break;
 
2065
  default:
 
2066
  case CKR_OK:
 
2067
    error = CKR_GENERAL_ERROR;
 
2068
    break;
 
2069
  }
 
2070
 
 
2071
  return error;
 
2072
}
 
2073
 
 
2074
/*
 
2075
 * NSSCKFWC_DestroyObject
 
2076
 *
 
2077
 */
 
2078
NSS_IMPLEMENT CK_RV
 
2079
NSSCKFWC_DestroyObject
 
2080
(
 
2081
  NSSCKFWInstance *fwInstance,
 
2082
  CK_SESSION_HANDLE hSession,
 
2083
  CK_OBJECT_HANDLE hObject
 
2084
)
 
2085
{
 
2086
  CK_RV error = CKR_OK;
 
2087
  NSSCKFWSession *fwSession;
 
2088
  NSSCKFWObject *fwObject;
 
2089
 
 
2090
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
2091
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
2092
    goto loser;
 
2093
  }
 
2094
  
 
2095
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
2096
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
2097
    error = CKR_SESSION_HANDLE_INVALID;
 
2098
    goto loser;
 
2099
  }
 
2100
 
 
2101
  fwObject = nssCKFWInstance_ResolveObjectHandle(fwInstance, hObject);
 
2102
  if( (NSSCKFWObject *)NULL == fwObject ) {
 
2103
    error = CKR_OBJECT_HANDLE_INVALID;
 
2104
    goto loser;
 
2105
  }
 
2106
 
 
2107
  nssCKFWInstance_DestroyObjectHandle(fwInstance, hObject);
 
2108
  nssCKFWObject_Destroy(fwObject);
 
2109
 
 
2110
  return CKR_OK;
 
2111
 
 
2112
 loser:
 
2113
  switch( error ) {
 
2114
  case CKR_SESSION_CLOSED:
 
2115
    /* destroy session? */
 
2116
    break;
 
2117
  case CKR_DEVICE_REMOVED:
 
2118
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
2119
    break;
 
2120
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
2121
  case CKR_DEVICE_ERROR:
 
2122
  case CKR_DEVICE_MEMORY:
 
2123
  case CKR_FUNCTION_FAILED:
 
2124
  case CKR_GENERAL_ERROR:
 
2125
  case CKR_HOST_MEMORY:
 
2126
  case CKR_OBJECT_HANDLE_INVALID:
 
2127
  case CKR_SESSION_HANDLE_INVALID:
 
2128
  case CKR_SESSION_READ_ONLY:
 
2129
  case CKR_TOKEN_WRITE_PROTECTED:
 
2130
    break;
 
2131
  default:
 
2132
  case CKR_OK:
 
2133
    error = CKR_GENERAL_ERROR;
 
2134
    break;
 
2135
  }
 
2136
 
 
2137
  return error;
 
2138
}
 
2139
 
 
2140
/*
 
2141
 * NSSCKFWC_GetObjectSize
 
2142
 *
 
2143
 */
 
2144
NSS_IMPLEMENT CK_RV
 
2145
NSSCKFWC_GetObjectSize
 
2146
(
 
2147
  NSSCKFWInstance *fwInstance,
 
2148
  CK_SESSION_HANDLE hSession,
 
2149
  CK_OBJECT_HANDLE hObject,
 
2150
  CK_ULONG_PTR pulSize
 
2151
)
 
2152
{
 
2153
  CK_RV error = CKR_OK;
 
2154
  NSSCKFWSession *fwSession;
 
2155
  NSSCKFWObject *fwObject;
 
2156
 
 
2157
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
2158
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
2159
    goto loser;
 
2160
  }
 
2161
  
 
2162
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
2163
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
2164
    error = CKR_SESSION_HANDLE_INVALID;
 
2165
    goto loser;
 
2166
  }
 
2167
 
 
2168
  fwObject = nssCKFWInstance_ResolveObjectHandle(fwInstance, hObject);
 
2169
  if( (NSSCKFWObject *)NULL == fwObject ) {
 
2170
    error = CKR_OBJECT_HANDLE_INVALID;
 
2171
    goto loser;
 
2172
  }
 
2173
 
 
2174
  if( (CK_ULONG_PTR)CK_NULL_PTR == pulSize ) {
 
2175
    error = CKR_ARGUMENTS_BAD;
 
2176
    goto loser;
 
2177
  }
 
2178
 
 
2179
  /*
 
2180
   * A purify error here indicates caller error.
 
2181
   */
 
2182
  *pulSize = (CK_ULONG)0;
 
2183
 
 
2184
  *pulSize = nssCKFWObject_GetObjectSize(fwObject, &error);
 
2185
  if( ((CK_ULONG)0 == *pulSize) && (CKR_OK != error) ) {
 
2186
    goto loser;
 
2187
  }
 
2188
 
 
2189
  return CKR_OK;
 
2190
 
 
2191
 loser:
 
2192
  switch( error ) {
 
2193
  case CKR_SESSION_CLOSED:
 
2194
    /* destroy session? */
 
2195
    break;
 
2196
  case CKR_DEVICE_REMOVED:
 
2197
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
2198
    break;
 
2199
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
2200
  case CKR_DEVICE_ERROR:
 
2201
  case CKR_DEVICE_MEMORY:
 
2202
  case CKR_FUNCTION_FAILED:
 
2203
  case CKR_GENERAL_ERROR:
 
2204
  case CKR_HOST_MEMORY:
 
2205
  case CKR_INFORMATION_SENSITIVE:
 
2206
  case CKR_OBJECT_HANDLE_INVALID:
 
2207
  case CKR_SESSION_HANDLE_INVALID:
 
2208
    break;
 
2209
  default:
 
2210
  case CKR_OK:
 
2211
    error = CKR_GENERAL_ERROR;
 
2212
    break;
 
2213
  }
 
2214
 
 
2215
  return error;
 
2216
}
 
2217
 
 
2218
/*
 
2219
 * NSSCKFWC_GetAttributeValue
 
2220
 *
 
2221
 */
 
2222
NSS_IMPLEMENT CK_RV
 
2223
NSSCKFWC_GetAttributeValue
 
2224
(
 
2225
  NSSCKFWInstance *fwInstance,
 
2226
  CK_SESSION_HANDLE hSession,
 
2227
  CK_OBJECT_HANDLE hObject,
 
2228
  CK_ATTRIBUTE_PTR pTemplate,
 
2229
  CK_ULONG ulCount
 
2230
)
 
2231
{
 
2232
  CK_RV error = CKR_OK;
 
2233
  NSSCKFWSession *fwSession;
 
2234
  NSSCKFWObject *fwObject;
 
2235
  CK_BBOOL sensitive = CK_FALSE;
 
2236
  CK_BBOOL invalid = CK_FALSE;
 
2237
  CK_BBOOL tooSmall = CK_FALSE;
 
2238
  CK_ULONG i;
 
2239
 
 
2240
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
2241
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
2242
    goto loser;
 
2243
  }
 
2244
  
 
2245
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
2246
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
2247
    error = CKR_SESSION_HANDLE_INVALID;
 
2248
    goto loser;
 
2249
  }
 
2250
 
 
2251
  fwObject = nssCKFWInstance_ResolveObjectHandle(fwInstance, hObject);
 
2252
  if( (NSSCKFWObject *)NULL == fwObject ) {
 
2253
    error = CKR_OBJECT_HANDLE_INVALID;
 
2254
    goto loser;
 
2255
  }
 
2256
 
 
2257
  if( (CK_ATTRIBUTE_PTR)CK_NULL_PTR == pTemplate ) {
 
2258
    error = CKR_ARGUMENTS_BAD;
 
2259
    goto loser;
 
2260
  }
 
2261
 
 
2262
  for( i = 0; i < ulCount; i++ ) {
 
2263
    CK_ULONG size = nssCKFWObject_GetAttributeSize(fwObject, 
 
2264
                      pTemplate[i].type, &error);
 
2265
    if( (CK_ULONG)0 == size ) {
 
2266
      switch( error ) {
 
2267
      case CKR_ATTRIBUTE_SENSITIVE:
 
2268
      case CKR_INFORMATION_SENSITIVE:
 
2269
        sensitive = CK_TRUE;
 
2270
        pTemplate[i].ulValueLen = (CK_ULONG)(-1);
 
2271
        continue;
 
2272
      case CKR_ATTRIBUTE_TYPE_INVALID:
 
2273
        invalid = CK_TRUE;
 
2274
        pTemplate[i].ulValueLen = (CK_ULONG)(-1);
 
2275
        continue;
 
2276
      case CKR_OK:
 
2277
        break;
 
2278
      default:
 
2279
        goto loser;
 
2280
      }
 
2281
    }
 
2282
 
 
2283
    if( (CK_VOID_PTR)CK_NULL_PTR == pTemplate[i].pValue ) {
 
2284
      pTemplate[i].ulValueLen = size;
 
2285
    } else {
 
2286
      NSSItem it, *p;
 
2287
 
 
2288
      if( pTemplate[i].ulValueLen < size ) {
 
2289
        tooSmall = CK_TRUE;
 
2290
        continue;
 
2291
      }
 
2292
 
 
2293
      it.size = (PRUint32)pTemplate[i].ulValueLen;
 
2294
      it.data = (void *)pTemplate[i].pValue;
 
2295
      p = nssCKFWObject_GetAttribute(fwObject, pTemplate[i].type, &it, 
 
2296
            (NSSArena *)NULL, &error);
 
2297
      if( (NSSItem *)NULL == p ) {
 
2298
        switch( error ) {
 
2299
        case CKR_ATTRIBUTE_SENSITIVE:
 
2300
        case CKR_INFORMATION_SENSITIVE:
 
2301
          sensitive = CK_TRUE;
 
2302
          pTemplate[i].ulValueLen = (CK_ULONG)(-1);
 
2303
          continue;
 
2304
        case CKR_ATTRIBUTE_TYPE_INVALID:
 
2305
          invalid = CK_TRUE;
 
2306
          pTemplate[i].ulValueLen = (CK_ULONG)(-1);
 
2307
          continue;
 
2308
        default:
 
2309
          goto loser;
 
2310
        }
 
2311
      }
 
2312
 
 
2313
      pTemplate[i].ulValueLen = size;
 
2314
    }
 
2315
  }
 
2316
 
 
2317
  if( sensitive ) {
 
2318
    error = CKR_ATTRIBUTE_SENSITIVE;
 
2319
    goto loser;
 
2320
  } else if( invalid ) {
 
2321
    error = CKR_ATTRIBUTE_TYPE_INVALID;
 
2322
    goto loser;
 
2323
  } else if( tooSmall ) {
 
2324
    error = CKR_BUFFER_TOO_SMALL;
 
2325
    goto loser;
 
2326
  }
 
2327
 
 
2328
  return CKR_OK;
 
2329
 
 
2330
 loser:
 
2331
  switch( error ) {
 
2332
  case CKR_SESSION_CLOSED:
 
2333
    /* destroy session? */
 
2334
    break;
 
2335
  case CKR_DEVICE_REMOVED:
 
2336
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
2337
    break;
 
2338
  case CKR_ATTRIBUTE_SENSITIVE:
 
2339
  case CKR_ATTRIBUTE_TYPE_INVALID:
 
2340
  case CKR_BUFFER_TOO_SMALL:
 
2341
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
2342
  case CKR_DEVICE_ERROR:
 
2343
  case CKR_DEVICE_MEMORY:
 
2344
  case CKR_FUNCTION_FAILED:
 
2345
  case CKR_GENERAL_ERROR:
 
2346
  case CKR_HOST_MEMORY:
 
2347
  case CKR_OBJECT_HANDLE_INVALID:
 
2348
  case CKR_SESSION_HANDLE_INVALID:
 
2349
    break;
 
2350
  default:
 
2351
  case CKR_OK:
 
2352
    error = CKR_GENERAL_ERROR;
 
2353
    break;
 
2354
  }
 
2355
 
 
2356
  return error;
 
2357
}
 
2358
  
 
2359
/*
 
2360
 * NSSCKFWC_SetAttributeValue
 
2361
 *
 
2362
 */
 
2363
NSS_IMPLEMENT CK_RV
 
2364
NSSCKFWC_SetAttributeValue
 
2365
(
 
2366
  NSSCKFWInstance *fwInstance,
 
2367
  CK_SESSION_HANDLE hSession,
 
2368
  CK_OBJECT_HANDLE hObject,
 
2369
  CK_ATTRIBUTE_PTR pTemplate,
 
2370
  CK_ULONG ulCount
 
2371
)
 
2372
{
 
2373
  CK_RV error = CKR_OK;
 
2374
  NSSCKFWSession *fwSession;
 
2375
  NSSCKFWObject *fwObject;
 
2376
  NSSCKFWObject *newFwObject;
 
2377
 
 
2378
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
2379
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
2380
    goto loser;
 
2381
  }
 
2382
  
 
2383
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
2384
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
2385
    error = CKR_SESSION_HANDLE_INVALID;
 
2386
    goto loser;
 
2387
  }
 
2388
 
 
2389
  fwObject = nssCKFWInstance_ResolveObjectHandle(fwInstance, hObject);
 
2390
  if( (NSSCKFWObject *)NULL == fwObject ) {
 
2391
    error = CKR_OBJECT_HANDLE_INVALID;
 
2392
    goto loser;
 
2393
  }
 
2394
 
 
2395
  if( (CK_ATTRIBUTE_PTR)CK_NULL_PTR == pTemplate ) {
 
2396
    error = CKR_ARGUMENTS_BAD;
 
2397
    goto loser;
 
2398
  }
 
2399
 
 
2400
  newFwObject = nssCKFWSession_CopyObject(fwSession, fwObject, pTemplate, 
 
2401
                  ulCount, &error);
 
2402
  if( (NSSCKFWObject *)NULL == newFwObject ) {
 
2403
    goto loser;
 
2404
  }
 
2405
 
 
2406
  error = nssCKFWInstance_ReassignObjectHandle(fwInstance, hObject, newFwObject);
 
2407
  nssCKFWObject_Destroy(fwObject);
 
2408
 
 
2409
  if( CKR_OK != error ) {
 
2410
    goto loser;
 
2411
  }
 
2412
 
 
2413
  return CKR_OK;
 
2414
 
 
2415
 loser:
 
2416
  switch( error ) {
 
2417
  case CKR_SESSION_CLOSED:
 
2418
    /* destroy session? */
 
2419
    break;
 
2420
  case CKR_DEVICE_REMOVED:
 
2421
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
2422
    break;
 
2423
  case CKR_ATTRIBUTE_READ_ONLY:
 
2424
  case CKR_ATTRIBUTE_TYPE_INVALID:
 
2425
  case CKR_ATTRIBUTE_VALUE_INVALID:
 
2426
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
2427
  case CKR_DEVICE_ERROR:
 
2428
  case CKR_DEVICE_MEMORY:
 
2429
  case CKR_FUNCTION_FAILED:
 
2430
  case CKR_GENERAL_ERROR:
 
2431
  case CKR_HOST_MEMORY:
 
2432
  case CKR_OBJECT_HANDLE_INVALID:
 
2433
  case CKR_SESSION_HANDLE_INVALID:
 
2434
  case CKR_SESSION_READ_ONLY:
 
2435
  case CKR_TEMPLATE_INCONSISTENT:
 
2436
  case CKR_TOKEN_WRITE_PROTECTED:
 
2437
    break;
 
2438
  default:
 
2439
  case CKR_OK:
 
2440
    error = CKR_GENERAL_ERROR;
 
2441
    break;
 
2442
  }
 
2443
 
 
2444
  return error;
 
2445
}
 
2446
 
 
2447
/*
 
2448
 * NSSCKFWC_FindObjectsInit
 
2449
 *
 
2450
 */
 
2451
NSS_IMPLEMENT CK_RV
 
2452
NSSCKFWC_FindObjectsInit
 
2453
(
 
2454
  NSSCKFWInstance *fwInstance,
 
2455
  CK_SESSION_HANDLE hSession,
 
2456
  CK_ATTRIBUTE_PTR pTemplate,
 
2457
  CK_ULONG ulCount
 
2458
)
 
2459
{
 
2460
  CK_RV error = CKR_OK;
 
2461
  NSSCKFWSession *fwSession;
 
2462
  NSSCKFWFindObjects *fwFindObjects;
 
2463
 
 
2464
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
2465
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
2466
    goto loser;
 
2467
  }
 
2468
  
 
2469
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
2470
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
2471
    error = CKR_SESSION_HANDLE_INVALID;
 
2472
    goto loser;
 
2473
  }
 
2474
 
 
2475
  if( ((CK_ATTRIBUTE_PTR)CK_NULL_PTR == pTemplate) && (ulCount != 0) ) {
 
2476
    error = CKR_ARGUMENTS_BAD;
 
2477
    goto loser;
 
2478
  }
 
2479
 
 
2480
  fwFindObjects = nssCKFWSession_GetFWFindObjects(fwSession, &error);
 
2481
  if( (NSSCKFWFindObjects *)NULL != fwFindObjects ) {
 
2482
    error = CKR_OPERATION_ACTIVE;
 
2483
    goto loser;
 
2484
  }
 
2485
 
 
2486
  if( CKR_OPERATION_NOT_INITIALIZED != error ) {
 
2487
    goto loser;
 
2488
  }
 
2489
 
 
2490
  fwFindObjects = nssCKFWSession_FindObjectsInit(fwSession,
 
2491
                    pTemplate, ulCount, &error);
 
2492
  if( (NSSCKFWFindObjects *)NULL == fwFindObjects ) {
 
2493
    goto loser;
 
2494
  }
 
2495
 
 
2496
  error = nssCKFWSession_SetFWFindObjects(fwSession, fwFindObjects);
 
2497
 
 
2498
  if( CKR_OK != error ) {
 
2499
    nssCKFWFindObjects_Destroy(fwFindObjects);
 
2500
    goto loser;
 
2501
  }
 
2502
 
 
2503
  return CKR_OK;
 
2504
 
 
2505
 loser:
 
2506
  switch( error ) {
 
2507
  case CKR_SESSION_CLOSED:
 
2508
    /* destroy session? */
 
2509
    break;
 
2510
  case CKR_DEVICE_REMOVED:
 
2511
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
2512
    break;
 
2513
  case CKR_ATTRIBUTE_TYPE_INVALID:
 
2514
  case CKR_ATTRIBUTE_VALUE_INVALID:
 
2515
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
2516
  case CKR_DEVICE_ERROR:
 
2517
  case CKR_DEVICE_MEMORY:
 
2518
  case CKR_FUNCTION_FAILED:
 
2519
  case CKR_GENERAL_ERROR:
 
2520
  case CKR_HOST_MEMORY:
 
2521
  case CKR_OPERATION_ACTIVE:
 
2522
  case CKR_SESSION_HANDLE_INVALID:
 
2523
    break;
 
2524
  default:
 
2525
  case CKR_OK:
 
2526
    error = CKR_GENERAL_ERROR;
 
2527
    break;
 
2528
  }
 
2529
 
 
2530
  return error;
 
2531
}
 
2532
 
 
2533
/*
 
2534
 * NSSCKFWC_FindObjects
 
2535
 *
 
2536
 */
 
2537
NSS_IMPLEMENT CK_RV
 
2538
NSSCKFWC_FindObjects
 
2539
(
 
2540
  NSSCKFWInstance *fwInstance,
 
2541
  CK_SESSION_HANDLE hSession,
 
2542
  CK_OBJECT_HANDLE_PTR phObject,
 
2543
  CK_ULONG ulMaxObjectCount,
 
2544
  CK_ULONG_PTR pulObjectCount
 
2545
)
 
2546
{
 
2547
  CK_RV error = CKR_OK;
 
2548
  NSSCKFWSession *fwSession;
 
2549
  NSSCKFWFindObjects *fwFindObjects;
 
2550
  CK_ULONG i;
 
2551
 
 
2552
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
2553
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
2554
    goto loser;
 
2555
  }
 
2556
  
 
2557
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
2558
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
2559
    error = CKR_SESSION_HANDLE_INVALID;
 
2560
    goto loser;
 
2561
  }
 
2562
 
 
2563
  if( (CK_OBJECT_HANDLE_PTR)CK_NULL_PTR == phObject ) {
 
2564
    error = CKR_ARGUMENTS_BAD;
 
2565
    goto loser;
 
2566
  }
 
2567
 
 
2568
  /*
 
2569
   * A purify error here indicates caller error.
 
2570
   */
 
2571
  (void)nsslibc_memset(phObject, 0, sizeof(CK_OBJECT_HANDLE) * ulMaxObjectCount);
 
2572
  *pulObjectCount = (CK_ULONG)0;
 
2573
 
 
2574
  fwFindObjects = nssCKFWSession_GetFWFindObjects(fwSession, &error);
 
2575
  if( (NSSCKFWFindObjects *)NULL == fwFindObjects ) {
 
2576
    goto loser;
 
2577
  }
 
2578
 
 
2579
  for( i = 0; i < ulMaxObjectCount; i++ ) {
 
2580
    NSSCKFWObject *fwObject = nssCKFWFindObjects_Next(fwFindObjects,
 
2581
                                NULL, &error);
 
2582
    if( (NSSCKFWObject *)NULL == fwObject ) {
 
2583
      break;
 
2584
    }
 
2585
 
 
2586
    phObject[i] = nssCKFWInstance_FindObjectHandle(fwInstance, fwObject);
 
2587
    if( (CK_OBJECT_HANDLE)0 == phObject[i] ) {
 
2588
      phObject[i] = nssCKFWInstance_CreateObjectHandle(fwInstance, fwObject, &error);
 
2589
    }
 
2590
    if( (CK_OBJECT_HANDLE)0 == phObject[i] ) {
 
2591
      /* This isn't right either, is it? */
 
2592
      nssCKFWObject_Destroy(fwObject);
 
2593
      goto loser;
 
2594
    }
 
2595
  }
 
2596
 
 
2597
  *pulObjectCount = i;
 
2598
 
 
2599
  return CKR_OK;
 
2600
 
 
2601
 loser:
 
2602
  switch( error ) {
 
2603
  case CKR_SESSION_CLOSED:
 
2604
    /* destroy session? */
 
2605
    break;
 
2606
  case CKR_DEVICE_REMOVED:
 
2607
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
2608
    break;
 
2609
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
2610
  case CKR_DEVICE_ERROR:
 
2611
  case CKR_DEVICE_MEMORY:
 
2612
  case CKR_FUNCTION_FAILED:
 
2613
  case CKR_GENERAL_ERROR:
 
2614
  case CKR_HOST_MEMORY:
 
2615
  case CKR_OPERATION_NOT_INITIALIZED:
 
2616
  case CKR_SESSION_HANDLE_INVALID:
 
2617
    break;
 
2618
  default:
 
2619
  case CKR_OK:
 
2620
    error = CKR_GENERAL_ERROR;
 
2621
    break;
 
2622
  }
 
2623
 
 
2624
  return error;
 
2625
}
 
2626
 
 
2627
/*
 
2628
 * NSSCKFWC_FindObjectsFinal
 
2629
 *
 
2630
 */
 
2631
NSS_IMPLEMENT CK_RV
 
2632
NSSCKFWC_FindObjectsFinal
 
2633
(
 
2634
  NSSCKFWInstance *fwInstance,
 
2635
  CK_SESSION_HANDLE hSession
 
2636
)
 
2637
{
 
2638
  CK_RV error = CKR_OK;
 
2639
  NSSCKFWSession *fwSession;
 
2640
  NSSCKFWFindObjects *fwFindObjects;
 
2641
  
 
2642
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
2643
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
2644
    goto loser;
 
2645
  }
 
2646
  
 
2647
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
2648
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
2649
    error = CKR_SESSION_HANDLE_INVALID;
 
2650
    goto loser;
 
2651
  }
 
2652
 
 
2653
  fwFindObjects = nssCKFWSession_GetFWFindObjects(fwSession, &error);
 
2654
  if( (NSSCKFWFindObjects *)NULL == fwFindObjects ) {
 
2655
    error = CKR_OPERATION_NOT_INITIALIZED;
 
2656
    goto loser;
 
2657
  }
 
2658
 
 
2659
  nssCKFWFindObjects_Destroy(fwFindObjects);
 
2660
  error = nssCKFWSession_SetFWFindObjects(fwSession, (NSSCKFWFindObjects *)NULL);
 
2661
 
 
2662
  if( CKR_OK != error ) {
 
2663
    goto loser;
 
2664
  }
 
2665
 
 
2666
  return CKR_OK;
 
2667
 
 
2668
 loser:
 
2669
  switch( error ) {
 
2670
  case CKR_SESSION_CLOSED:
 
2671
    /* destroy session? */
 
2672
    break;
 
2673
  case CKR_DEVICE_REMOVED:
 
2674
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
2675
    break;
 
2676
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
2677
  case CKR_DEVICE_ERROR:
 
2678
  case CKR_DEVICE_MEMORY:
 
2679
  case CKR_FUNCTION_FAILED:
 
2680
  case CKR_GENERAL_ERROR:
 
2681
  case CKR_HOST_MEMORY:
 
2682
  case CKR_OPERATION_NOT_INITIALIZED:
 
2683
  case CKR_SESSION_HANDLE_INVALID:
 
2684
    break;
 
2685
  default:
 
2686
  case CKR_OK:
 
2687
    error = CKR_GENERAL_ERROR;
 
2688
    break;
 
2689
  }
 
2690
 
 
2691
  return error;
 
2692
}
 
2693
 
 
2694
/*
 
2695
 * NSSCKFWC_EncryptInit
 
2696
 *
 
2697
 */
 
2698
NSS_IMPLEMENT CK_RV
 
2699
NSSCKFWC_EncryptInit
 
2700
(
 
2701
  NSSCKFWInstance *fwInstance,
 
2702
  CK_SESSION_HANDLE hSession,
 
2703
  CK_MECHANISM_PTR pMechanism,
 
2704
  CK_OBJECT_HANDLE hKey
 
2705
)
 
2706
{
 
2707
  return CKR_FUNCTION_FAILED;
 
2708
}
 
2709
 
 
2710
/*
 
2711
 * NSSCKFWC_Encrypt
 
2712
 *
 
2713
 */
 
2714
NSS_IMPLEMENT CK_RV
 
2715
NSSCKFWC_Encrypt
 
2716
(
 
2717
  NSSCKFWInstance *fwInstance,
 
2718
  CK_SESSION_HANDLE hSession,
 
2719
  CK_BYTE_PTR pData,
 
2720
  CK_ULONG ulDataLen,
 
2721
  CK_BYTE_PTR pEncryptedData,
 
2722
  CK_ULONG_PTR pulEncryptedDataLen
 
2723
)
 
2724
{
 
2725
  return CKR_FUNCTION_FAILED;
 
2726
}
 
2727
 
 
2728
/*
 
2729
 * NSSCKFWC_EncryptUpdate
 
2730
 *
 
2731
 */
 
2732
NSS_IMPLEMENT CK_RV
 
2733
NSSCKFWC_EncryptUpdate
 
2734
(
 
2735
  NSSCKFWInstance *fwInstance,
 
2736
  CK_SESSION_HANDLE hSession,
 
2737
  CK_BYTE_PTR pPart,
 
2738
  CK_ULONG ulPartLen,
 
2739
  CK_BYTE_PTR pEncryptedPart,
 
2740
  CK_ULONG_PTR pulEncryptedPartLen
 
2741
)
 
2742
{
 
2743
  return CKR_FUNCTION_FAILED;
 
2744
}
 
2745
 
 
2746
/*
 
2747
 * NSSCKFWC_EncryptFinal
 
2748
 *
 
2749
 */
 
2750
NSS_IMPLEMENT CK_RV
 
2751
NSSCKFWC_EncryptFinal
 
2752
(
 
2753
  NSSCKFWInstance *fwInstance,
 
2754
  CK_SESSION_HANDLE hSession,
 
2755
  CK_BYTE_PTR pLastEncryptedPart,
 
2756
  CK_ULONG_PTR pulLastEncryptedPartLen
 
2757
)
 
2758
{
 
2759
  return CKR_FUNCTION_FAILED;
 
2760
}
 
2761
 
 
2762
/*
 
2763
 * NSSCKFWC_DecryptInit
 
2764
 *
 
2765
 */
 
2766
NSS_IMPLEMENT CK_RV
 
2767
NSSCKFWC_DecryptInit
 
2768
(
 
2769
  NSSCKFWInstance *fwInstance,
 
2770
  CK_SESSION_HANDLE hSession,
 
2771
  CK_MECHANISM_PTR pMechanism,
 
2772
  CK_OBJECT_HANDLE hKey
 
2773
)
 
2774
{
 
2775
  return CKR_FUNCTION_FAILED;
 
2776
}
 
2777
 
 
2778
/*
 
2779
 * NSSCKFWC_Decrypt
 
2780
 *
 
2781
 */
 
2782
NSS_IMPLEMENT CK_RV
 
2783
NSSCKFWC_Decrypt
 
2784
(
 
2785
  NSSCKFWInstance *fwInstance,
 
2786
  CK_SESSION_HANDLE hSession,
 
2787
  CK_BYTE_PTR pEncryptedData,
 
2788
  CK_ULONG ulEncryptedDataLen,
 
2789
  CK_BYTE_PTR pData,
 
2790
  CK_ULONG_PTR pulDataLen
 
2791
)
 
2792
{
 
2793
  return CKR_FUNCTION_FAILED;
 
2794
}
 
2795
 
 
2796
/*
 
2797
 * NSSCKFWC_DecryptUpdate
 
2798
 *
 
2799
 */
 
2800
NSS_IMPLEMENT CK_RV
 
2801
NSSCKFWC_DecryptUpdate
 
2802
(
 
2803
  NSSCKFWInstance *fwInstance,
 
2804
  CK_SESSION_HANDLE hSession,
 
2805
  CK_BYTE_PTR pEncryptedPart,
 
2806
  CK_ULONG ulEncryptedPartLen,
 
2807
  CK_BYTE_PTR pPart,
 
2808
  CK_ULONG_PTR pulPartLen
 
2809
)
 
2810
{
 
2811
  return CKR_FUNCTION_FAILED;
 
2812
}
 
2813
 
 
2814
/*
 
2815
 * NSSCKFWC_DecryptFinal
 
2816
 *
 
2817
 */
 
2818
NSS_IMPLEMENT CK_RV
 
2819
NSSCKFWC_DecryptFinal
 
2820
(
 
2821
  NSSCKFWInstance *fwInstance,
 
2822
  CK_SESSION_HANDLE hSession,
 
2823
  CK_BYTE_PTR pLastPart,
 
2824
  CK_ULONG_PTR pulLastPartLen
 
2825
)
 
2826
{
 
2827
  return CKR_FUNCTION_FAILED;
 
2828
}
 
2829
 
 
2830
/*
 
2831
 * NSSCKFWC_DigestInit
 
2832
 *
 
2833
 */
 
2834
NSS_IMPLEMENT CK_RV
 
2835
NSSCKFWC_DigestInit
 
2836
(
 
2837
  NSSCKFWInstance *fwInstance,
 
2838
  CK_SESSION_HANDLE hSession,
 
2839
  CK_MECHANISM_PTR pMechanism
 
2840
)
 
2841
{
 
2842
  return CKR_FUNCTION_FAILED;
 
2843
}
 
2844
 
 
2845
/*
 
2846
 * NSSCKFWC_Digest
 
2847
 *
 
2848
 */
 
2849
NSS_IMPLEMENT CK_RV
 
2850
NSSCKFWC_Digest
 
2851
(
 
2852
  NSSCKFWInstance *fwInstance,
 
2853
  CK_SESSION_HANDLE hSession,
 
2854
  CK_BYTE_PTR pData,
 
2855
  CK_ULONG ulDataLen,
 
2856
  CK_BYTE_PTR pDigest,
 
2857
  CK_ULONG_PTR pulDigestLen
 
2858
)
 
2859
{
 
2860
  return CKR_FUNCTION_FAILED;
 
2861
}
 
2862
 
 
2863
/*
 
2864
 * NSSCKFWC_DigestUpdate
 
2865
 *
 
2866
 */
 
2867
NSS_IMPLEMENT CK_RV
 
2868
NSSCKFWC_DigestUpdate
 
2869
(
 
2870
  NSSCKFWInstance *fwInstance,
 
2871
  CK_SESSION_HANDLE hSession,
 
2872
  CK_BYTE_PTR pData,
 
2873
  CK_ULONG ulDataLen
 
2874
)
 
2875
{
 
2876
  return CKR_FUNCTION_FAILED;
 
2877
}
 
2878
 
 
2879
/*
 
2880
 * NSSCKFWC_DigestKey
 
2881
 *
 
2882
 */
 
2883
NSS_IMPLEMENT CK_RV
 
2884
NSSCKFWC_DigestKey
 
2885
(
 
2886
  NSSCKFWInstance *fwInstance,
 
2887
  CK_SESSION_HANDLE hSession,
 
2888
  CK_OBJECT_HANDLE hKey
 
2889
)
 
2890
{
 
2891
  return CKR_FUNCTION_FAILED;
 
2892
}
 
2893
 
 
2894
/*
 
2895
 * NSSCKFWC_DigestFinal
 
2896
 *
 
2897
 */
 
2898
NSS_IMPLEMENT CK_RV
 
2899
NSSCKFWC_DigestFinal
 
2900
(
 
2901
  NSSCKFWInstance *fwInstance,
 
2902
  CK_SESSION_HANDLE hSession,
 
2903
  CK_BYTE_PTR pDigest,
 
2904
  CK_ULONG_PTR pulDigestLen
 
2905
)
 
2906
{
 
2907
  return CKR_FUNCTION_FAILED;
 
2908
}
 
2909
 
 
2910
/*
 
2911
 * NSSCKFWC_SignInit
 
2912
 *
 
2913
 */
 
2914
NSS_IMPLEMENT CK_RV
 
2915
NSSCKFWC_SignInit
 
2916
(
 
2917
  NSSCKFWInstance *fwInstance,
 
2918
  CK_SESSION_HANDLE hSession,
 
2919
  CK_MECHANISM_PTR pMechanism,
 
2920
  CK_OBJECT_HANDLE hKey
 
2921
)
 
2922
{
 
2923
  return CKR_FUNCTION_FAILED;
 
2924
}
 
2925
 
 
2926
/*
 
2927
 * NSSCKFWC_Sign
 
2928
 *
 
2929
 */
 
2930
NSS_IMPLEMENT CK_RV
 
2931
NSSCKFWC_Sign
 
2932
(
 
2933
  NSSCKFWInstance *fwInstance,
 
2934
  CK_SESSION_HANDLE hSession,
 
2935
  CK_BYTE_PTR pData,
 
2936
  CK_ULONG ulDataLen,
 
2937
  CK_BYTE_PTR pSignature,
 
2938
  CK_ULONG_PTR pulSignatureLen
 
2939
)
 
2940
{
 
2941
  return CKR_FUNCTION_FAILED;
 
2942
}
 
2943
 
 
2944
/*
 
2945
 * NSSCKFWC_SignUpdate
 
2946
 *
 
2947
 */
 
2948
NSS_IMPLEMENT CK_RV
 
2949
NSSCKFWC_SignUpdate
 
2950
(
 
2951
  NSSCKFWInstance *fwInstance,
 
2952
  CK_SESSION_HANDLE hSession,
 
2953
  CK_BYTE_PTR pPart,
 
2954
  CK_ULONG ulPartLen
 
2955
)
 
2956
{
 
2957
  return CKR_FUNCTION_FAILED;
 
2958
}
 
2959
 
 
2960
/*
 
2961
 * NSSCKFWC_SignFinal
 
2962
 *
 
2963
 */
 
2964
NSS_IMPLEMENT CK_RV
 
2965
NSSCKFWC_SignFinal
 
2966
(
 
2967
  NSSCKFWInstance *fwInstance,
 
2968
  CK_SESSION_HANDLE hSession,
 
2969
  CK_BYTE_PTR pSignature,
 
2970
  CK_ULONG_PTR pulSignatureLen
 
2971
)
 
2972
{
 
2973
  return CKR_FUNCTION_FAILED;
 
2974
}
 
2975
 
 
2976
/*
 
2977
 * NSSCKFWC_SignRecoverInit
 
2978
 *
 
2979
 */
 
2980
NSS_IMPLEMENT CK_RV
 
2981
NSSCKFWC_SignRecoverInit
 
2982
(
 
2983
  NSSCKFWInstance *fwInstance,
 
2984
  CK_SESSION_HANDLE hSession,
 
2985
  CK_MECHANISM_PTR pMechanism,
 
2986
  CK_OBJECT_HANDLE hKey
 
2987
)
 
2988
{
 
2989
  return CKR_FUNCTION_FAILED;
 
2990
}
 
2991
 
 
2992
/*
 
2993
 * NSSCKFWC_SignRecover
 
2994
 *
 
2995
 */
 
2996
NSS_IMPLEMENT CK_RV
 
2997
NSSCKFWC_SignRecover
 
2998
(
 
2999
  NSSCKFWInstance *fwInstance,
 
3000
  CK_SESSION_HANDLE hSession,
 
3001
  CK_BYTE_PTR pData,
 
3002
  CK_ULONG ulDataLen,
 
3003
  CK_BYTE_PTR pSignature,
 
3004
  CK_ULONG_PTR pulSignatureLen
 
3005
)
 
3006
{
 
3007
  return CKR_FUNCTION_FAILED;
 
3008
}
 
3009
 
 
3010
/*
 
3011
 * NSSCKFWC_VerifyInit
 
3012
 *
 
3013
 */
 
3014
NSS_IMPLEMENT CK_RV
 
3015
NSSCKFWC_VerifyInit
 
3016
(
 
3017
  NSSCKFWInstance *fwInstance,
 
3018
  CK_SESSION_HANDLE hSession,
 
3019
  CK_MECHANISM_PTR pMechanism,
 
3020
  CK_OBJECT_HANDLE hKey
 
3021
)
 
3022
{
 
3023
  return CKR_FUNCTION_FAILED;
 
3024
}
 
3025
 
 
3026
/*
 
3027
 * NSSCKFWC_Verify
 
3028
 *
 
3029
 */
 
3030
NSS_IMPLEMENT CK_RV
 
3031
NSSCKFWC_Verify
 
3032
(
 
3033
  NSSCKFWInstance *fwInstance,
 
3034
  CK_SESSION_HANDLE hSession,
 
3035
  CK_BYTE_PTR pData,
 
3036
  CK_ULONG ulDataLen,
 
3037
  CK_BYTE_PTR pSignature,
 
3038
  CK_ULONG ulSignatureLen
 
3039
)
 
3040
{
 
3041
  return CKR_FUNCTION_FAILED;
 
3042
}
 
3043
 
 
3044
/*
 
3045
 * NSSCKFWC_VerifyUpdate
 
3046
 *
 
3047
 */
 
3048
NSS_IMPLEMENT CK_RV
 
3049
NSSCKFWC_VerifyUpdate
 
3050
(
 
3051
  NSSCKFWInstance *fwInstance,
 
3052
  CK_SESSION_HANDLE hSession,
 
3053
  CK_BYTE_PTR pPart,
 
3054
  CK_ULONG ulPartLen
 
3055
)
 
3056
{
 
3057
  return CKR_FUNCTION_FAILED;
 
3058
}
 
3059
 
 
3060
/*
 
3061
 * NSSCKFWC_VerifyFinal
 
3062
 *
 
3063
 */
 
3064
NSS_IMPLEMENT CK_RV
 
3065
NSSCKFWC_VerifyFinal
 
3066
(
 
3067
  NSSCKFWInstance *fwInstance,
 
3068
  CK_SESSION_HANDLE hSession,
 
3069
  CK_BYTE_PTR pSignature,
 
3070
  CK_ULONG ulSignatureLen
 
3071
)
 
3072
{
 
3073
  return CKR_FUNCTION_FAILED;
 
3074
}
 
3075
 
 
3076
/*
 
3077
 * NSSCKFWC_VerifyRecoverInit
 
3078
 *
 
3079
 */
 
3080
NSS_IMPLEMENT CK_RV
 
3081
NSSCKFWC_VerifyRecoverInit
 
3082
(
 
3083
  NSSCKFWInstance *fwInstance,
 
3084
  CK_SESSION_HANDLE hSession,
 
3085
  CK_MECHANISM_PTR pMechanism,
 
3086
  CK_OBJECT_HANDLE hKey
 
3087
)
 
3088
{
 
3089
  return CKR_FUNCTION_FAILED;
 
3090
}
 
3091
 
 
3092
/*
 
3093
 * NSSCKFWC_VerifyRecover
 
3094
 *
 
3095
 */
 
3096
NSS_IMPLEMENT CK_RV
 
3097
NSSCKFWC_VerifyRecover
 
3098
(
 
3099
  NSSCKFWInstance *fwInstance,
 
3100
  CK_SESSION_HANDLE hSession,
 
3101
  CK_BYTE_PTR pSignature,
 
3102
  CK_ULONG ulSignatureLen,
 
3103
  CK_BYTE_PTR pData,
 
3104
  CK_ULONG_PTR pulDataLen
 
3105
)
 
3106
{
 
3107
  return CKR_FUNCTION_FAILED;
 
3108
}
 
3109
 
 
3110
/*
 
3111
 * NSSCKFWC_DigestEncryptUpdate
 
3112
 *
 
3113
 */
 
3114
NSS_IMPLEMENT CK_RV
 
3115
NSSCKFWC_DigestEncryptUpdate
 
3116
(
 
3117
  NSSCKFWInstance *fwInstance,
 
3118
  CK_SESSION_HANDLE hSession,
 
3119
  CK_BYTE_PTR pPart,
 
3120
  CK_ULONG ulPartLen,
 
3121
  CK_BYTE_PTR pEncryptedPart,
 
3122
  CK_ULONG_PTR pulEncryptedPartLen
 
3123
)
 
3124
{
 
3125
  return CKR_FUNCTION_FAILED;
 
3126
}
 
3127
 
 
3128
/*
 
3129
 * NSSCKFWC_DecryptDigestUpdate
 
3130
 *
 
3131
 */
 
3132
NSS_IMPLEMENT CK_RV
 
3133
NSSCKFWC_DecryptDigestUpdate
 
3134
(
 
3135
  NSSCKFWInstance *fwInstance,
 
3136
  CK_SESSION_HANDLE hSession,
 
3137
  CK_BYTE_PTR pEncryptedPart,
 
3138
  CK_ULONG ulEncryptedPartLen,
 
3139
  CK_BYTE_PTR pPart,
 
3140
  CK_ULONG_PTR pulPartLen
 
3141
)
 
3142
{
 
3143
  return CKR_FUNCTION_FAILED;
 
3144
}
 
3145
 
 
3146
/*
 
3147
 * NSSCKFWC_SignEncryptUpdate
 
3148
 *
 
3149
 */
 
3150
NSS_IMPLEMENT CK_RV
 
3151
NSSCKFWC_SignEncryptUpdate
 
3152
(
 
3153
  NSSCKFWInstance *fwInstance,
 
3154
  CK_SESSION_HANDLE hSession,
 
3155
  CK_BYTE_PTR pPart,
 
3156
  CK_ULONG ulPartLen,
 
3157
  CK_BYTE_PTR pEncryptedPart,
 
3158
  CK_ULONG_PTR pulEncryptedPartLen
 
3159
)
 
3160
{
 
3161
  return CKR_FUNCTION_FAILED;
 
3162
}
 
3163
 
 
3164
/*
 
3165
 * NSSCKFWC_DecryptVerifyUpdate
 
3166
 *
 
3167
 */
 
3168
NSS_IMPLEMENT CK_RV
 
3169
NSSCKFWC_DecryptVerifyUpdate
 
3170
(
 
3171
  NSSCKFWInstance *fwInstance,
 
3172
  CK_SESSION_HANDLE hSession,
 
3173
  CK_BYTE_PTR pEncryptedPart,
 
3174
  CK_ULONG ulEncryptedPartLen,
 
3175
  CK_BYTE_PTR pPart,
 
3176
  CK_ULONG_PTR pulPartLen
 
3177
)
 
3178
{
 
3179
  return CKR_FUNCTION_FAILED;
 
3180
}
 
3181
 
 
3182
/*
 
3183
 * NSSCKFWC_GenerateKey
 
3184
 *
 
3185
 */
 
3186
NSS_IMPLEMENT CK_RV
 
3187
NSSCKFWC_GenerateKey
 
3188
(
 
3189
  NSSCKFWInstance *fwInstance,
 
3190
  CK_SESSION_HANDLE hSession,
 
3191
  CK_MECHANISM_PTR pMechanism,
 
3192
  CK_ATTRIBUTE_PTR pTemplate,
 
3193
  CK_ULONG ulCount,
 
3194
  CK_OBJECT_HANDLE_PTR phKey
 
3195
)
 
3196
{
 
3197
  return CKR_FUNCTION_FAILED;
 
3198
}
 
3199
 
 
3200
/*
 
3201
 * NSSCKFWC_GenerateKeyPair
 
3202
 *
 
3203
 */
 
3204
NSS_IMPLEMENT CK_RV
 
3205
NSSCKFWC_GenerateKeyPair
 
3206
(
 
3207
  NSSCKFWInstance *fwInstance,
 
3208
  CK_SESSION_HANDLE hSession,
 
3209
  CK_MECHANISM_PTR pMechanism,
 
3210
  CK_ATTRIBUTE_PTR pPublicKeyTemplate,
 
3211
  CK_ULONG ulPublicKeyAttributeCount,
 
3212
  CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
 
3213
  CK_ULONG ulPrivateKeyAttributeCount,
 
3214
  CK_OBJECT_HANDLE_PTR phPublicKey,
 
3215
  CK_OBJECT_HANDLE_PTR phPrivateKey
 
3216
)
 
3217
{
 
3218
  return CKR_FUNCTION_FAILED;
 
3219
}
 
3220
 
 
3221
/*
 
3222
 * NSSCKFWC_WrapKey
 
3223
 *
 
3224
 */
 
3225
NSS_IMPLEMENT CK_RV
 
3226
NSSCKFWC_WrapKey
 
3227
(
 
3228
  NSSCKFWInstance *fwInstance,
 
3229
  CK_SESSION_HANDLE hSession,
 
3230
  CK_MECHANISM_PTR pMechanism,
 
3231
  CK_OBJECT_HANDLE hWrappingKey,
 
3232
  CK_OBJECT_HANDLE hKey,
 
3233
  CK_BYTE_PTR pWrappedKey,
 
3234
  CK_ULONG_PTR pulWrappedKeyLen
 
3235
)
 
3236
{
 
3237
  return CKR_FUNCTION_FAILED;
 
3238
}
 
3239
 
 
3240
/*
 
3241
 * NSSCKFWC_UnwrapKey
 
3242
 *
 
3243
 */
 
3244
NSS_IMPLEMENT CK_RV
 
3245
NSSCKFWC_UnwrapKey
 
3246
(
 
3247
  NSSCKFWInstance *fwInstance,
 
3248
  CK_SESSION_HANDLE hSession,
 
3249
  CK_MECHANISM_PTR pMechanism,
 
3250
  CK_OBJECT_HANDLE hUnwrappingKey,
 
3251
  CK_BYTE_PTR pWrappedKey,
 
3252
  CK_ULONG ulWrappedKeyLen,
 
3253
  CK_ATTRIBUTE_PTR pTemplate,
 
3254
  CK_ULONG ulAttributeCount,
 
3255
  CK_OBJECT_HANDLE_PTR phKey
 
3256
)
 
3257
{
 
3258
  return CKR_FUNCTION_FAILED;
 
3259
}
 
3260
 
 
3261
/*
 
3262
 * NSSCKFWC_DeriveKey
 
3263
 *
 
3264
 */
 
3265
NSS_IMPLEMENT CK_RV
 
3266
NSSCKFWC_DeriveKey
 
3267
(
 
3268
  NSSCKFWInstance *fwInstance,
 
3269
  CK_SESSION_HANDLE hSession,
 
3270
  CK_MECHANISM_PTR pMechanism,
 
3271
  CK_OBJECT_HANDLE hBaseKey,
 
3272
  CK_ATTRIBUTE_PTR pTemplate,
 
3273
  CK_ULONG ulAttributeCount,
 
3274
  CK_OBJECT_HANDLE_PTR phKey
 
3275
)
 
3276
{
 
3277
  return CKR_FUNCTION_FAILED;
 
3278
}
 
3279
 
 
3280
/*
 
3281
 * NSSCKFWC_SeedRandom
 
3282
 *
 
3283
 */
 
3284
NSS_IMPLEMENT CK_RV
 
3285
NSSCKFWC_SeedRandom
 
3286
(
 
3287
  NSSCKFWInstance *fwInstance,
 
3288
  CK_SESSION_HANDLE hSession,
 
3289
  CK_BYTE_PTR pSeed,
 
3290
  CK_ULONG ulSeedLen
 
3291
)
 
3292
{
 
3293
  CK_RV error = CKR_OK;
 
3294
  NSSCKFWSession *fwSession;
 
3295
  NSSItem seed;
 
3296
 
 
3297
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
3298
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
3299
    goto loser;
 
3300
  }
 
3301
 
 
3302
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
3303
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
3304
    error = CKR_SESSION_HANDLE_INVALID;
 
3305
    goto loser;
 
3306
  }
 
3307
 
 
3308
  if( (CK_BYTE_PTR)CK_NULL_PTR == pSeed ) {
 
3309
    error = CKR_ARGUMENTS_BAD;
 
3310
    goto loser;
 
3311
  }
 
3312
 
 
3313
  /* We could read through the buffer in a Purify trap */
 
3314
 
 
3315
  seed.size = (PRUint32)ulSeedLen;
 
3316
  seed.data = (void *)pSeed;
 
3317
 
 
3318
  error = nssCKFWSession_SeedRandom(fwSession, &seed);
 
3319
 
 
3320
  if( CKR_OK != error ) {
 
3321
    goto loser;
 
3322
  }
 
3323
 
 
3324
  return CKR_OK;
 
3325
 
 
3326
 loser:
 
3327
  switch( error ) {
 
3328
  case CKR_SESSION_CLOSED:
 
3329
    /* destroy session? */
 
3330
    break;
 
3331
  case CKR_DEVICE_REMOVED:
 
3332
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
3333
    break;
 
3334
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
3335
  case CKR_DEVICE_ERROR:
 
3336
  case CKR_DEVICE_MEMORY:
 
3337
  case CKR_FUNCTION_CANCELED:
 
3338
  case CKR_FUNCTION_FAILED:
 
3339
  case CKR_GENERAL_ERROR:
 
3340
  case CKR_HOST_MEMORY:
 
3341
  case CKR_OPERATION_ACTIVE:
 
3342
  case CKR_RANDOM_SEED_NOT_SUPPORTED:
 
3343
  case CKR_RANDOM_NO_RNG:
 
3344
  case CKR_SESSION_HANDLE_INVALID:
 
3345
  case CKR_USER_NOT_LOGGED_IN:
 
3346
    break;
 
3347
  default:
 
3348
  case CKR_OK:
 
3349
    error = CKR_GENERAL_ERROR;
 
3350
    break;
 
3351
  }
 
3352
 
 
3353
  return error;
 
3354
}
 
3355
 
 
3356
/*
 
3357
 * NSSCKFWC_GenerateRandom
 
3358
 *
 
3359
 */
 
3360
NSS_IMPLEMENT CK_RV
 
3361
NSSCKFWC_GenerateRandom
 
3362
(
 
3363
  NSSCKFWInstance *fwInstance,
 
3364
  CK_SESSION_HANDLE hSession,
 
3365
  CK_BYTE_PTR pRandomData,
 
3366
  CK_ULONG ulRandomLen
 
3367
)
 
3368
{
 
3369
  CK_RV error = CKR_OK;
 
3370
  NSSCKFWSession *fwSession;
 
3371
  NSSItem buffer;
 
3372
 
 
3373
  if( (NSSCKFWInstance *)NULL == fwInstance ) {
 
3374
    error = CKR_CRYPTOKI_NOT_INITIALIZED;
 
3375
    goto loser;
 
3376
  }
 
3377
 
 
3378
  fwSession = nssCKFWInstance_ResolveSessionHandle(fwInstance, hSession);
 
3379
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
3380
    error = CKR_SESSION_HANDLE_INVALID;
 
3381
    goto loser;
 
3382
  }
 
3383
 
 
3384
  if( (CK_BYTE_PTR)CK_NULL_PTR == pRandomData ) {
 
3385
    error = CKR_ARGUMENTS_BAD;
 
3386
    goto loser;
 
3387
  }
 
3388
 
 
3389
  /*
 
3390
   * A purify error here indicates caller error.
 
3391
   */
 
3392
  (void)nsslibc_memset(pRandomData, 0, ulRandomLen);
 
3393
 
 
3394
  buffer.size = (PRUint32)ulRandomLen;
 
3395
  buffer.data = (void *)pRandomData;
 
3396
 
 
3397
  error = nssCKFWSession_GetRandom(fwSession, &buffer);
 
3398
 
 
3399
  if( CKR_OK != error ) {
 
3400
    goto loser;
 
3401
  }
 
3402
 
 
3403
  return CKR_OK;
 
3404
 
 
3405
 loser:
 
3406
  switch( error ) {
 
3407
  case CKR_SESSION_CLOSED:
 
3408
    /* destroy session? */
 
3409
    break;
 
3410
  case CKR_DEVICE_REMOVED:
 
3411
    /* (void)nssCKFWToken_Destroy(fwToken); */
 
3412
    break;
 
3413
  case CKR_CRYPTOKI_NOT_INITIALIZED:
 
3414
  case CKR_DEVICE_ERROR:
 
3415
  case CKR_DEVICE_MEMORY:
 
3416
  case CKR_FUNCTION_CANCELED:
 
3417
  case CKR_FUNCTION_FAILED:
 
3418
  case CKR_GENERAL_ERROR:
 
3419
  case CKR_HOST_MEMORY:
 
3420
  case CKR_OPERATION_ACTIVE:
 
3421
  case CKR_RANDOM_NO_RNG:
 
3422
  case CKR_SESSION_HANDLE_INVALID:
 
3423
  case CKR_USER_NOT_LOGGED_IN:
 
3424
    break;
 
3425
  default:
 
3426
  case CKR_OK:
 
3427
    error = CKR_GENERAL_ERROR;
 
3428
    break;
 
3429
  }
 
3430
 
 
3431
  return error;
 
3432
}
 
3433
 
 
3434
/*
 
3435
 * NSSCKFWC_GetFunctionStatus
 
3436
 *
 
3437
 */
 
3438
NSS_IMPLEMENT CK_RV
 
3439
NSSCKFWC_GetFunctionStatus
 
3440
(
 
3441
  NSSCKFWInstance *fwInstance,
 
3442
  CK_SESSION_HANDLE hSession
 
3443
)
 
3444
{
 
3445
  return CKR_FUNCTION_NOT_PARALLEL;
 
3446
}
 
3447
 
 
3448
/*
 
3449
 * NSSCKFWC_CancelFunction
 
3450
 *
 
3451
 */
 
3452
NSS_IMPLEMENT CK_RV
 
3453
NSSCKFWC_CancelFunction
 
3454
(
 
3455
  NSSCKFWInstance *fwInstance,
 
3456
  CK_SESSION_HANDLE hSession
 
3457
)
 
3458
{
 
3459
  return CKR_FUNCTION_NOT_PARALLEL;
 
3460
}