Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/pk11wrap/pk11merge.c

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /*
  * Merge the source token into the target token.
  */
 
 #include "secmod.h"
 #include "secmodi.h"
@@ skipping 38 matching lines @@
     }
     return SECSuccess;
 }
 
 
 /*
  * copy a template of attributes from a source object to a target object.
  * if target object is not given, create it.
  */
 static SECStatus
-pk11_copyAttributes(PRArenaPool *arena, 
+pk11_copyAttributes(PLArenaPool *arena,
         PK11SlotInfo *targetSlot, CK_OBJECT_HANDLE targetID,
         PK11SlotInfo *sourceSlot, CK_OBJECT_HANDLE sourceID,
         CK_ATTRIBUTE *copyTemplate, CK_ULONG copyTemplateCount)
 {
     SECStatus rv = PK11_GetAttributes(arena, sourceSlot, sourceID, 
                                 copyTemplate, copyTemplateCount);
     if (rv != SECSuccess) {
         return rv;
     }
     if (targetID == CK_INVALID_HANDLE) {
         /* we need to create the object */
         rv = PK11_CreateNewObject(targetSlot, CK_INVALID_SESSION, 
                 copyTemplate, copyTemplateCount, PR_TRUE, &targetID);
     } else {
         /* update the existing object with the new attributes */
         rv = pk11_setAttributes(targetSlot, targetID, 
                         copyTemplate, copyTemplateCount);
     }
     return rv;
 }
 
 /*
  * look for a matching object across tokens.
  */
 static SECStatus
-pk11_matchAcrossTokens(PRArenaPool *arena, PK11SlotInfo *targetSlot, 
+pk11_matchAcrossTokens(PLArenaPool *arena, PK11SlotInfo *targetSlot,
                        PK11SlotInfo *sourceSlot,
                        CK_ATTRIBUTE *template, CK_ULONG tsize, 
                        CK_OBJECT_HANDLE id, CK_OBJECT_HANDLE *peer)
 {
 
     CK_RV crv;
     *peer = CK_INVALID_HANDLE;
 
     crv = PK11_GetAttributes(arena, sourceSlot, id, template, tsize);
     if (crv != CKR_OK) {
@@ skipping 99 matching lines @@
 pk11_mergePrivateKey(PK11SlotInfo *targetSlot, PK11SlotInfo *sourceSlot,
                 CK_OBJECT_HANDLE id, void *targetPwArg, void *sourcePwArg)
 {
     SECKEYPrivateKey *sourceKey = NULL;
     CK_OBJECT_HANDLE targetKeyID;
     SECKEYEncryptedPrivateKeyInfo *epki = NULL;
     char *nickname = NULL;
     SECItem nickItem;
     SECItem pwitem;
     SECItem publicValue;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv = SECSuccess;
     unsigned int keyUsage;
     unsigned char randomData[SHA1_LENGTH];
     SECOidTag algTag = SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC;
     CK_ATTRIBUTE privTemplate[] = {
         { CKA_ID, NULL, 0 },
         { CKA_CLASS, NULL, 0 }
     };
     CK_ULONG privTemplateCount = sizeof(privTemplate)/sizeof(privTemplate[0]);
     CK_ATTRIBUTE privCopyTemplate[] = {
@@ skipping 108 matching lines @@
  *  This code also handles the following corner cases:
  *   1) the single byte overflows. On overflow we increment the next byte up 
  *    and so forth until we have overflowed the entire CKA_ID.
  *   2) If we overflow the entire CKA_ID we expand it by one byte.
  *   3) the CKA_ID is non-existent, we create a new one with one byte.
  *    This means no matter what CKA_ID is passed, the result of this function 
  *    is always a new CKA_ID, and this function will never return the same 
  *    CKA_ID the it has returned in the passed.
  */
 static SECStatus
-pk11_incrementID(PRArenaPool *arena, CK_ATTRIBUTE *ptemplate)
+pk11_incrementID(PLArenaPool *arena, CK_ATTRIBUTE *ptemplate)
 {
     unsigned char *buf = ptemplate->pValue;
     CK_ULONG len = ptemplate->ulValueLen;
 
     if (buf == NULL || len == (CK_ULONG)-1) {
         /* we have no valid CKAID, we'll create a basic one byte CKA_ID below */
         len = 0;
     } else {
         CK_ULONG i;
 
@@ skipping 81 matching lines @@
 {
     PK11SymKey *sourceKey = NULL;
     PK11SymKey *targetKey = NULL;
     SECItem *sourceOutput = NULL;
     SECItem *targetOutput = NULL;
     SECItem *param = NULL;
     int blockSize;
     SECItem input;
     CK_OBJECT_HANDLE targetKeyID;
     CK_FLAGS flags;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv = SECSuccess;
     CK_MECHANISM_TYPE keyMechType, cryptoMechType;
     CK_KEY_TYPE sourceKeyType, targetKeyType;
     CK_ATTRIBUTE symTemplate[] = {
         { CKA_ID, NULL, 0 },
         { CKA_CLASS, NULL, 0 }
     };
     CK_ULONG symTemplateCount = sizeof(symTemplate)/sizeof(symTemplate[0]);
     CK_ATTRIBUTE symCopyTemplate[] = {
         { CKA_LABEL, NULL, 0 }
@@ skipping 153 matching lines @@
  *
  * Use the high level NSS calls to extract the public key and import it
  * into the token. Extra attributes are then copied to the new token.
  */
 static SECStatus
 pk11_mergePublicKey(PK11SlotInfo *targetSlot, PK11SlotInfo *sourceSlot,
                 CK_OBJECT_HANDLE id, void *targetPwArg, void *sourcePwArg)
 {
     SECKEYPublicKey *sourceKey = NULL;
     CK_OBJECT_HANDLE targetKeyID;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv = SECSuccess;
     CK_ATTRIBUTE pubTemplate[] = {
         { CKA_ID, NULL, 0 },
         { CKA_CLASS, NULL, 0 }
     };
     CK_ULONG pubTemplateCount = sizeof(pubTemplate)/sizeof(pubTemplate[0]);
     CK_ATTRIBUTE pubCopyTemplate[] = {
         { CKA_ID, NULL, 0 },
         { CKA_LABEL, NULL, 0 },
         { CKA_SUBJECT, NULL, 0 }
@@ skipping 118 matching lines @@
  * Use the high level NSS calls to extract and import the certificate.
  */
 static SECStatus
 pk11_mergeCert(PK11SlotInfo *targetSlot, PK11SlotInfo *sourceSlot,
                 CK_OBJECT_HANDLE id, void *targetPwArg, void *sourcePwArg)
 {
     CERTCertificate *sourceCert = NULL;
     CK_OBJECT_HANDLE targetCertID = CK_INVALID_HANDLE;
     char *nickname = NULL;
     SECStatus rv = SECSuccess;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     CK_ATTRIBUTE sourceCKAID = {CKA_ID, NULL, 0};
     CK_ATTRIBUTE targetCKAID = {CKA_ID, NULL, 0};
     SECStatus lrv = SECSuccess;
     int error;
 
 
     sourceCert = PK11_MakeCertFromHandle(sourceSlot, id, NULL);
     if (sourceCert == NULL) {
         rv = SECFailure;
         goto done;
@@ skipping 115 matching lines @@
 /*
  * Use the raw PKCS #11 interface to merge the CRLs.
  *
  * In the case where of collision, choose the newest CRL that is valid.
  */
 static SECStatus
 pk11_mergeCrl(PK11SlotInfo *targetSlot, PK11SlotInfo *sourceSlot,
                 CK_OBJECT_HANDLE id, void *targetPwArg, void *sourcePwArg)
 {
     CK_OBJECT_HANDLE targetCrlID;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv = SECSuccess;
     CK_ATTRIBUTE crlTemplate[] = {
         { CKA_SUBJECT, NULL, 0 },
         { CKA_CLASS, NULL, 0 },
         { CKA_NSS_KRL, NULL, 0 }
     };
     CK_ULONG crlTemplateCount = sizeof(crlTemplate)/sizeof(crlTemplate[0]);
     CK_ATTRIBUTE crlCopyTemplate[] = {
         { CKA_CLASS, NULL, 0 },
         { CKA_TOKEN, NULL, 0 },
@@ skipping 41 matching lines @@
  *************************************************************************/
 
 /*
  * use the raw PKCS #11 interface to merge the S/MIME records
  */
 static SECStatus
 pk11_mergeSmime(PK11SlotInfo *targetSlot, PK11SlotInfo *sourceSlot,
                 CK_OBJECT_HANDLE id, void *targetPwArg, void *sourcePwArg)
 {
     CK_OBJECT_HANDLE targetSmimeID;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv = SECSuccess;
     CK_ATTRIBUTE smimeTemplate[] = {
         { CKA_SUBJECT, NULL, 0 },
         { CKA_NSS_EMAIL, NULL, 0 },
         { CKA_CLASS, NULL, 0 },
     };
     CK_ULONG smimeTemplateCount = 
                 sizeof(smimeTemplate)/sizeof(smimeTemplate[0]);
     CK_ATTRIBUTE smimeCopyTemplate[] = {
         { CKA_CLASS, NULL, 0 },
@@ skipping 99 matching lines @@
     return USE_TARGET;
 }
 /*
  * use the raw PKCS #11 interface to merge the S/MIME records
  */
 static SECStatus
 pk11_mergeTrust(PK11SlotInfo *targetSlot, PK11SlotInfo *sourceSlot,
                 CK_OBJECT_HANDLE id, void *targetPwArg, void *sourcePwArg)
 {
     CK_OBJECT_HANDLE targetTrustID;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv = SECSuccess;
     int error = 0;
     CK_ATTRIBUTE trustTemplate[] = {
         { CKA_ISSUER, NULL, 0 },
         { CKA_SERIAL_NUMBER, NULL, 0 },
         { CKA_CLASS, NULL, 0 },
     };
     CK_ULONG trustTemplateCount = 
                 sizeof(trustTemplate)/sizeof(trustTemplate[0]);
     CK_ATTRIBUTE trustCopyTemplate[] = {
@@ skipping 143 matching lines @@
                                         targetPwArg, sourcePwArg);
     default:
         break;
     }
 
     PORT_SetError( SEC_ERROR_UNKNOWN_OBJECT_TYPE );
     return SECFailure;
 }
 
 PK11MergeLogNode *
-pk11_newMergeLogNode(PRArenaPool *arena, 
+pk11_newMergeLogNode(PLArenaPool *arena,
                      PK11SlotInfo *slot, CK_OBJECT_HANDLE id, int error)
 {
     PK11MergeLogNode *newLog;
     PK11GenericObject *obj;
 
     newLog = PORT_ArenaZNew(arena, PK11MergeLogNode);
     if (newLog == NULL) {
         return NULL;
     }
 
@@ skipping 143 matching lines @@
 loser:
     if (objectIDs) {
         PORT_Free(objectIDs);
     }
     return rv;
 }
 
 PK11MergeLog *
 PK11_CreateMergeLog(void)
 {
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     PK11MergeLog *log;
 
     arena = PORT_NewArena( DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) {
         return NULL;
     }
 
     log = PORT_ArenaZNew(arena, PK11MergeLog);
     if (log == NULL) {
          PORT_FreeArena(arena,PR_FALSE);
         return NULL;
     }
     log->arena = arena;
     log->version = 1;
     return log;
 }
 
 void
 PK11_DestroyMergeLog(PK11MergeLog *log)
 {
    if (log && log->arena) {
         PORT_FreeArena(log->arena, PR_FALSE);
     }
 }