← Back to branch summary

~ubuntu-branches/ubuntu/karmic/nss/karmic-updates

« back to all changes in this revision

Viewing changes to mozilla/security/nss/lib/ckfw/token.c

  • Committer: Bazaar Package Importer
  • Author(s): Alexander Sack
  • Date: 2009-06-16 13:23:47 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20090616132347-311ysb8oep74b98y
Tags: 3.12.3-0ubuntu1
https://launchpad.net/bugs/387751
* new upstream release 3.12.3 RTM (NSS_3_12_3_RTM) (LP: #387751)
* adjust patches to changed upstream code base
  - update debian/patches/38_kbsd.patch
* needs nspr >= 4.7.4
  - update debian/control
* update 85_security_load.patch to latest debian version
  - update debian/patches/85_security_load.patch
* add new symbols for 3.12.3
  - update debian/libnss3-1d.symbols

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/security/nss/lib/ckfw/token.c
35
35
 * ***** END LICENSE BLOCK ***** */
36
36
 
37
37
#ifdef DEBUG
38
 
static const char CVS_ID[] = "@(#) $RCSfile: token.c,v $ $Revision: 1.12 $ $Date: 2007/10/06 01:41:28 $";
 
38
static const char CVS_ID[] = "@(#) $RCSfile: token.c,v $ $Revision: 1.13 $ $Date: 2009/02/09 07:55:53 $";
39
39
#endif /* DEBUG */
40
40
 
41
41
/*
218
218
   */
219
219
 
220
220
  arena = NSSArena_Create();
221
 
  if( (NSSArena *)NULL == arena ) {
 
221
  if (!arena) {
222
222
    *pError = CKR_HOST_MEMORY;
223
223
    goto loser;
224
224
  }
225
225
 
226
226
  fwToken = nss_ZNEW(arena, NSSCKFWToken);
227
 
  if( (NSSCKFWToken *)NULL == fwToken ) {
 
227
  if (!fwToken) {
228
228
    *pError = CKR_HOST_MEMORY;
229
229
    goto loser;
230
230
  }    
239
239
  fwToken->rwSessionCount = 0;
240
240
 
241
241
  fwToken->mutex = nssCKFWInstance_CreateMutex(fwToken->fwInstance, arena, pError);
242
 
  if( (NSSCKFWMutex *)NULL == fwToken->mutex ) {
 
242
  if (!fwToken->mutex) {
243
243
    if( CKR_OK == *pError ) {
244
244
      *pError = CKR_GENERAL_ERROR;
245
245
    }
247
247
  }
248
248
 
249
249
  fwToken->sessions = nssCKFWHash_Create(fwToken->fwInstance, arena, pError);
250
 
  if( (nssCKFWHash *)NULL == fwToken->sessions ) {
 
250
  if (!fwToken->sessions) {
251
251
    if( CKR_OK == *pError ) {
252
252
      *pError = CKR_GENERAL_ERROR;
253
253
    }
258
258
                   fwToken->fwInstance) ) {
259
259
    fwToken->sessionObjectHash = nssCKFWHash_Create(fwToken->fwInstance, 
260
260
                                   arena, pError);
261
 
    if( (nssCKFWHash *)NULL == fwToken->sessionObjectHash ) {
 
261
    if (!fwToken->sessionObjectHash) {
262
262
      if( CKR_OK == *pError ) {
263
263
        *pError = CKR_GENERAL_ERROR;
264
264
      }
268
268
 
269
269
  fwToken->mdObjectHash = nssCKFWHash_Create(fwToken->fwInstance, 
270
270
                            arena, pError);
271
 
  if( (nssCKFWHash *)NULL == fwToken->mdObjectHash ) {
 
271
  if (!fwToken->mdObjectHash) {
272
272
    if( CKR_OK == *pError ) {
273
273
      *pError = CKR_GENERAL_ERROR;
274
274
    }
277
277
 
278
278
  fwToken->mdMechanismHash = nssCKFWHash_Create(fwToken->fwInstance, 
279
279
                            arena, pError);
280
 
  if( (nssCKFWHash *)NULL == fwToken->mdMechanismHash ) {
 
280
  if (!fwToken->mdMechanismHash) {
281
281
    if( CKR_OK == *pError ) {
282
282
      *pError = CKR_GENERAL_ERROR;
283
283
    }
286
286
 
287
287
  /* More here */
288
288
 
289
 
  if( (void *)NULL != (void *)mdToken->Setup ) {
 
289
  if (mdToken->Setup) {
290
290
    *pError = mdToken->Setup(mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
291
291
    if( CKR_OK != *pError ) {
292
292
      goto loser;
308
308
 loser:
309
309
 
310
310
  if( CK_TRUE == called_setup ) {
311
 
    if( (void *)NULL != (void *)mdToken->Invalidate ) {
 
311
    if (mdToken->Invalidate) {
312
312
      mdToken->Invalidate(mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
313
313
    }
314
314
  }
315
315
 
316
 
  if( (NSSArena *)NULL != arena ) {
 
316
  if (arena) {
317
317
    (void)NSSArena_Destroy(arena);
318
318
  }
319
319
 
373
373
 
374
374
  (void)nssCKFWMutex_Destroy(fwToken->mutex);
375
375
  
376
 
  if( (void *)NULL != (void *)fwToken->mdToken->Invalidate ) {
 
376
  if (fwToken->mdToken->Invalidate) {
377
377
    fwToken->mdToken->Invalidate(fwToken->mdToken, fwToken,
378
378
      fwToken->mdInstance, fwToken->fwInstance);
379
379
  }
440
440
)
441
441
{
442
442
#ifdef NSSDEBUG
443
 
  if( (CK_RV *)NULL == pError ) {
 
443
  if (!pError) {
444
444
    return (NSSArena *)NULL;
445
445
  }
446
446
 
552
552
    goto done;
553
553
  }
554
554
 
555
 
  if( (void *)NULL == (void *)fwToken->mdToken->InitToken ) {
 
555
  if (!fwToken->mdToken->InitToken) {
556
556
    error = CKR_DEVICE_ERROR;
557
557
    goto done;
558
558
  }
559
559
 
560
 
  if( (NSSItem *)NULL == pin ) {
 
560
  if (!pin) {
561
561
    if( nssCKFWToken_GetHasProtectedAuthenticationPath(fwToken) ) {
562
562
      ; /* okay */
563
563
    } else {
566
566
    }
567
567
  }
568
568
 
569
 
  if( (NSSUTF8 *)NULL == label ) {
 
569
  if (!label) {
570
570
    label = (NSSUTF8 *) "";
571
571
  }
572
572
 
607
607
    return error;
608
608
  }
609
609
 
610
 
  if( (NSSUTF8 *)NULL == fwToken->label ) {
611
 
    if( (void *)NULL != (void *)fwToken->mdToken->GetLabel ) {
 
610
  if (!fwToken->label) {
 
611
    if (fwToken->mdToken->GetLabel) {
612
612
      fwToken->label = fwToken->mdToken->GetLabel(fwToken->mdToken, fwToken,
613
613
        fwToken->mdInstance, fwToken->fwInstance, &error);
614
 
      if( ((NSSUTF8 *)NULL == fwToken->label) && (CKR_OK != error) ) {
 
614
      if ((!fwToken->label) && (CKR_OK != error)) {
615
615
        goto done;
616
616
      }
617
617
    } else {
656
656
    return error;
657
657
  }
658
658
 
659
 
  if( (NSSUTF8 *)NULL == fwToken->manufacturerID ) {
660
 
    if( (void *)NULL != (void *)fwToken->mdToken->GetManufacturerID ) {
 
659
  if (!fwToken->manufacturerID) {
 
660
    if (fwToken->mdToken->GetManufacturerID) {
661
661
      fwToken->manufacturerID = fwToken->mdToken->GetManufacturerID(fwToken->mdToken,
662
662
        fwToken, fwToken->mdInstance, fwToken->fwInstance, &error);
663
 
      if( ((NSSUTF8 *)NULL == fwToken->manufacturerID) && (CKR_OK != error) ) {
 
663
      if ((!fwToken->manufacturerID) && (CKR_OK != error)) {
664
664
        goto done;
665
665
      }
666
666
    } else {
705
705
    return error;
706
706
  }
707
707
 
708
 
  if( (NSSUTF8 *)NULL == fwToken->model ) {
709
 
    if( (void *)NULL != (void *)fwToken->mdToken->GetModel ) {
 
708
  if (!fwToken->model) {
 
709
    if (fwToken->mdToken->GetModel) {
710
710
      fwToken->model = fwToken->mdToken->GetModel(fwToken->mdToken, fwToken,
711
711
        fwToken->mdInstance, fwToken->fwInstance, &error);
712
 
      if( ((NSSUTF8 *)NULL == fwToken->model) && (CKR_OK != error) ) {
 
712
      if ((!fwToken->model) && (CKR_OK != error)) {
713
713
        goto done;
714
714
      }
715
715
    } else {
754
754
    return error;
755
755
  }
756
756
 
757
 
  if( (NSSUTF8 *)NULL == fwToken->serialNumber ) {
758
 
    if( (void *)NULL != (void *)fwToken->mdToken->GetSerialNumber ) {
 
757
  if (!fwToken->serialNumber) {
 
758
    if (fwToken->mdToken->GetSerialNumber) {
759
759
      fwToken->serialNumber = fwToken->mdToken->GetSerialNumber(fwToken->mdToken, 
760
760
        fwToken, fwToken->mdInstance, fwToken->fwInstance, &error);
761
 
      if( ((NSSUTF8 *)NULL == fwToken->serialNumber) && (CKR_OK != error) ) {
 
761
      if ((!fwToken->serialNumber) && (CKR_OK != error)) {
762
762
        goto done;
763
763
      }
764
764
    } else {
791
791
  }
792
792
#endif /* NSSDEBUG */
793
793
 
794
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetHasRNG ) {
 
794
  if (!fwToken->mdToken->GetHasRNG) {
795
795
    return CK_FALSE;
796
796
  }
797
797
 
815
815
  }
816
816
#endif /* NSSDEBUG */
817
817
 
818
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetIsWriteProtected ) {
 
818
  if (!fwToken->mdToken->GetIsWriteProtected) {
819
819
    return CK_FALSE;
820
820
  }
821
821
 
839
839
  }
840
840
#endif /* NSSDEBUG */
841
841
 
842
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetLoginRequired ) {
 
842
  if (!fwToken->mdToken->GetLoginRequired) {
843
843
    return CK_FALSE;
844
844
  }
845
845
 
863
863
  }
864
864
#endif /* NSSDEBUG */
865
865
 
866
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetUserPinInitialized ) {
 
866
  if (!fwToken->mdToken->GetUserPinInitialized) {
867
867
    return CK_FALSE;
868
868
  }
869
869
 
887
887
  }
888
888
#endif /* NSSDEBUG */
889
889
 
890
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetRestoreKeyNotNeeded ) {
 
890
  if (!fwToken->mdToken->GetRestoreKeyNotNeeded) {
891
891
    return CK_FALSE;
892
892
  }
893
893
 
911
911
  }
912
912
#endif /* NSSDEBUG */
913
913
 
914
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetHasClockOnToken ) {
 
914
  if (!fwToken->mdToken->GetHasClockOnToken) {
915
915
    return CK_FALSE;
916
916
  }
917
917
 
935
935
  }
936
936
#endif /* NSSDEBUG */
937
937
 
938
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetHasProtectedAuthenticationPath ) {
 
938
  if (!fwToken->mdToken->GetHasProtectedAuthenticationPath) {
939
939
    return CK_FALSE;
940
940
  }
941
941
 
959
959
  }
960
960
#endif /* NSSDEBUG */
961
961
 
962
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetSupportsDualCryptoOperations ) {
 
962
  if (!fwToken->mdToken->GetSupportsDualCryptoOperations) {
963
963
    return CK_FALSE;
964
964
  }
965
965
 
983
983
  }
984
984
#endif /* NSSDEBUG */
985
985
 
986
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetMaxSessionCount ) {
 
986
  if (!fwToken->mdToken->GetMaxSessionCount) {
987
987
    return CK_UNAVAILABLE_INFORMATION;
988
988
  }
989
989
 
1007
1007
  }
1008
1008
#endif /* NSSDEBUG */
1009
1009
 
1010
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetMaxRwSessionCount ) {
 
1010
  if (!fwToken->mdToken->GetMaxRwSessionCount) {
1011
1011
    return CK_UNAVAILABLE_INFORMATION;
1012
1012
  }
1013
1013
 
1031
1031
  }
1032
1032
#endif /* NSSDEBUG */
1033
1033
 
1034
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetMaxPinLen ) {
 
1034
  if (!fwToken->mdToken->GetMaxPinLen) {
1035
1035
    return CK_UNAVAILABLE_INFORMATION;
1036
1036
  }
1037
1037
 
1055
1055
  }
1056
1056
#endif /* NSSDEBUG */
1057
1057
 
1058
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetMinPinLen ) {
 
1058
  if (!fwToken->mdToken->GetMinPinLen) {
1059
1059
    return CK_UNAVAILABLE_INFORMATION;
1060
1060
  }
1061
1061
 
1079
1079
  }
1080
1080
#endif /* NSSDEBUG */
1081
1081
 
1082
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetTotalPublicMemory ) {
 
1082
  if (!fwToken->mdToken->GetTotalPublicMemory) {
1083
1083
    return CK_UNAVAILABLE_INFORMATION;
1084
1084
  }
1085
1085
 
1103
1103
  }
1104
1104
#endif /* NSSDEBUG */
1105
1105
 
1106
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetFreePublicMemory ) {
 
1106
  if (!fwToken->mdToken->GetFreePublicMemory) {
1107
1107
    return CK_UNAVAILABLE_INFORMATION;
1108
1108
  }
1109
1109
 
1127
1127
  }
1128
1128
#endif /* NSSDEBUG */
1129
1129
 
1130
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetTotalPrivateMemory ) {
 
1130
  if (!fwToken->mdToken->GetTotalPrivateMemory) {
1131
1131
    return CK_UNAVAILABLE_INFORMATION;
1132
1132
  }
1133
1133
 
1151
1151
  }
1152
1152
#endif /* NSSDEBUG */
1153
1153
 
1154
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetFreePrivateMemory ) {
 
1154
  if (!fwToken->mdToken->GetFreePrivateMemory) {
1155
1155
    return CK_UNAVAILABLE_INFORMATION;
1156
1156
  }
1157
1157
 
1189
1189
    goto done;
1190
1190
  }
1191
1191
 
1192
 
  if( (void *)NULL != (void *)fwToken->mdToken->GetHardwareVersion ) {
 
1192
  if (fwToken->mdToken->GetHardwareVersion) {
1193
1193
    fwToken->hardwareVersion = fwToken->mdToken->GetHardwareVersion(
1194
1194
      fwToken->mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
1195
1195
  } else {
1234
1234
    goto done;
1235
1235
  }
1236
1236
 
1237
 
  if( (void *)NULL != (void *)fwToken->mdToken->GetFirmwareVersion ) {
 
1237
  if (fwToken->mdToken->GetFirmwareVersion) {
1238
1238
    fwToken->firmwareVersion = fwToken->mdToken->GetFirmwareVersion(
1239
1239
      fwToken->mdToken, fwToken, fwToken->mdInstance, fwToken->fwInstance);
1240
1240
  } else {
1279
1279
    return CKR_OK;
1280
1280
  }
1281
1281
 
1282
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetUTCTime ) {
 
1282
  if (!fwToken->mdToken->GetUTCTime) {
1283
1283
    /* It said it had one! */
1284
1284
    return CKR_GENERAL_ERROR;
1285
1285
  }
1355
1355
  NSSCKMDSession *mdSession;
1356
1356
 
1357
1357
#ifdef NSSDEBUG
1358
 
  if( (CK_RV *)NULL == pError ) {
 
1358
  if (!pError) {
1359
1359
    return (NSSCKFWSession *)NULL;
1360
1360
  }
1361
1361
 
1395
1395
 
1396
1396
  /* We could compare sesion counts to any limits we know of, I guess.. */
1397
1397
 
1398
 
  if( (void *)NULL == (void *)fwToken->mdToken->OpenSession ) {
 
1398
  if (!fwToken->mdToken->OpenSession) {
1399
1399
    /*
1400
1400
     * I'm not sure that the Module actually needs to implement
1401
1401
     * mdSessions -- the Framework can keep track of everything 
1406
1406
  }
1407
1407
 
1408
1408
  fwSession = nssCKFWSession_Create(fwToken, rw, pApplication, Notify, pError);
1409
 
  if( (NSSCKFWSession *)NULL == fwSession ) {
 
1409
  if (!fwSession) {
1410
1410
    if( CKR_OK == *pError ) {
1411
1411
      *pError = CKR_GENERAL_ERROR;
1412
1412
    }
1416
1416
  mdSession = fwToken->mdToken->OpenSession(fwToken->mdToken, fwToken,
1417
1417
                fwToken->mdInstance, fwToken->fwInstance, fwSession,
1418
1418
                rw, pError);
1419
 
  if( (NSSCKMDSession *)NULL == mdSession ) {
 
1419
  if (!mdSession) {
1420
1420
    (void)nssCKFWSession_Destroy(fwSession, CK_FALSE);
1421
1421
    if( CKR_OK == *pError ) {
1422
1422
      *pError = CKR_GENERAL_ERROR;
1426
1426
 
1427
1427
  *pError = nssCKFWSession_SetMDSession(fwSession, mdSession);
1428
1428
  if( CKR_OK != *pError ) {
1429
 
    if( (void *)NULL != (void *)mdSession->Close ) {
 
1429
    if (mdSession->Close) {
1430
1430
      mdSession->Close(mdSession, fwSession, fwToken->mdToken, fwToken,
1431
1431
      fwToken->mdInstance, fwToken->fwInstance);
1432
1432
    }
1462
1462
  }
1463
1463
#endif /* NSSDEBUG */
1464
1464
 
1465
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetMechanismCount ) {
 
1465
  if (!fwToken->mdToken->GetMechanismCount) {
1466
1466
    return 0;
1467
1467
  }
1468
1468
 
1486
1486
    return CKR_ARGUMENTS_BAD;
1487
1487
  }
1488
1488
 
1489
 
  if( (CK_MECHANISM_TYPE *)NULL == types ) {
 
1489
  if (!types) {
1490
1490
    return CKR_ARGUMENTS_BAD;
1491
1491
  }
1492
1492
#endif /* NSSDEBUG */
1493
1493
 
1494
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetMechanismTypes ) {
 
1494
  if (!fwToken->mdToken->GetMechanismTypes) {
1495
1495
    /*
1496
1496
     * This should only be called with a sufficiently-large
1497
1497
     * "types" array, which can only be done if GetMechanismCount
1519
1519
)
1520
1520
{
1521
1521
  NSSCKMDMechanism *mdMechanism;
1522
 
  if ((nssCKFWHash *)NULL == fwToken->mdMechanismHash) {
 
1522
  if (!fwToken->mdMechanismHash) {
1523
1523
    *pError = CKR_GENERAL_ERROR;
1524
1524
    return (NSSCKFWMechanism *)NULL;
1525
1525
  }
1526
1526
  
1527
 
  if( (void *)NULL == (void *)fwToken->mdToken->GetMechanism ) {
 
1527
  if (!fwToken->mdToken->GetMechanism) {
1528
1528
    /*
1529
1529
     * If we don't implement any GetMechanism function, then we must
1530
1530
     * not support any.
1536
1536
  /* lookup in hash table */
1537
1537
  mdMechanism = fwToken->mdToken->GetMechanism(fwToken->mdToken, fwToken,
1538
1538
    fwToken->mdInstance, fwToken->fwInstance, which, pError);
1539
 
  if ((NSSCKMDMechanism *)NULL == mdMechanism) {
 
1539
  if (!mdMechanism) {
1540
1540
    return (NSSCKFWMechanism *) NULL;
1541
1541
  }
1542
1542
  /* store in hash table */
1665
1665
  nssCKFWHash_Destroy(fwToken->sessions);
1666
1666
 
1667
1667
  fwToken->sessions = nssCKFWHash_Create(fwToken->fwInstance, fwToken->arena, &error);
1668
 
  if( (nssCKFWHash *)NULL == fwToken->sessions ) {
 
1668
  if (!fwToken->sessions) {
1669
1669
    if( CKR_OK == error ) {
1670
1670
      error = CKR_GENERAL_ERROR;
1671
1671
    }
1854
1854
)
1855
1855
{
1856
1856
#ifdef DEBUG
1857
 
  if( (CK_RV *)NULL == pError ) {
 
1857
  if (!pError) {
1858
1858
    return (NSSArena *)NULL;
1859
1859
  }
1860
1860