Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/cryptohi/seckey.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/. */
 #include "cryptohi.h"
 #include "keyhi.h"
 #include "secoid.h"
 #include "secitem.h"
 #include "secder.h"
 #include "base64.h"
 #include "secasn1.h"
@@ skipping 248 matching lines @@
             }
             PK11_FreeSlot(pubk->pkcs11Slot);
         }
         if (pubk->arena) {
             PORT_FreeArena(pubk->arena, PR_FALSE);
         }
     }
 }
 
 SECStatus
-SECKEY_CopySubjectPublicKeyInfo(PRArenaPool *arena,
+SECKEY_CopySubjectPublicKeyInfo(PLArenaPool *arena,
                              CERTSubjectPublicKeyInfo *to,
                              CERTSubjectPublicKeyInfo *from)
 {
     SECStatus rv;
     SECItem spk;
 
     rv = SECOID_CopyAlgorithmID(arena, &to->algorithm, &from->algorithm);
     if (rv == SECSuccess) {
         /*
          * subjectPublicKey is a bit string, whose length is in bits.
@@ skipping 158 matching lines @@
     return seckey_UpdateCertPQGChain(subjectCert,0);
 }
    
 
 /* Decode the DSA PQG parameters.  The params could be stored in two
  * possible formats, the old fortezza-only wrapped format or
  * the normal standard format.  Store the decoded parameters in
  * a V3 certificate data structure.  */ 
 
 SECStatus
-SECKEY_DSADecodePQG(PRArenaPool *arena, SECKEYPublicKey *pubk, SECItem *params) {
+SECKEY_DSADecodePQG(PLArenaPool *arena, SECKEYPublicKey *pubk, SECItem *params) {
     SECStatus rv;
     SECItem newparams;
 
     if (params == NULL) return SECFailure; 
     
     if (params->data == NULL) return SECFailure;
 
     PORT_Assert(arena);
 
     /* make a copy of the data into the arena so QuickDER output is valid */
@@ skipping 84 matching lines @@
 {
     return seckey_GetKeyType(SECOID_GetAlgorithmTag(&spki->algorithm));
 }
 
 static SECKEYPublicKey *
 seckey_ExtractPublicKey(CERTSubjectPublicKeyInfo *spki)
 {
     SECKEYPublicKey *pubk;
     SECItem os, newOs, newParms;
     SECStatus rv;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     SECOidTag tag;
 
     arena = PORT_NewArena (DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL)
         return NULL;
 
     pubk = (SECKEYPublicKey *) PORT_ArenaZAlloc(arena, sizeof(SECKEYPublicKey));
     if (pubk == NULL) {
         PORT_FreeArena (arena, PR_FALSE);
         return NULL;
@@ skipping 455 matching lines @@
         break;
     }
     PORT_SetError(SEC_ERROR_INVALID_KEY);
     return 0;
 }
 
 SECKEYPrivateKey *
 SECKEY_CopyPrivateKey(const SECKEYPrivateKey *privk)
 {
     SECKEYPrivateKey *copyk;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     
     if (!privk || !privk->pkcs11Slot) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
     }
     
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) {
         return NULL;
     }
@@ skipping 25 matching lines @@
 
 fail:
     PORT_FreeArena (arena, PR_FALSE);
     return NULL;
 }
 
 SECKEYPublicKey *
 SECKEY_CopyPublicKey(const SECKEYPublicKey *pubk)
 {
     SECKEYPublicKey *copyk;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     SECStatus rv = SECSuccess;
 
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) {
         PORT_SetError (SEC_ERROR_NO_MEMORY);
         return NULL;
     }
 
     copyk = (SECKEYPublicKey *) PORT_ArenaZAlloc (arena, sizeof (SECKEYPublicKey));
     if (!copyk) {
@@ skipping 64 matching lines @@
 
     SECKEY_DestroyPublicKey (copyk);
     return NULL;
 }
 
 
 SECKEYPublicKey *
 SECKEY_ConvertToPublicKey(SECKEYPrivateKey *privk)
 {
     SECKEYPublicKey *pubk;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     CERTCertificate *cert;
     SECStatus rv;
 
     /*
      * First try to look up the cert.
      */
     cert = PK11_GetCertFromPrivateKey(privk);
     if (cert) {
         pubk = CERT_ExtractPublicKey(cert);
         CERT_DestroyCertificate(cert);
@@ skipping 38 matching lines @@
     }
 
     PORT_FreeArena (arena, PR_FALSE);
     return NULL;
 }
 
 CERTSubjectPublicKeyInfo *
 SECKEY_CreateSubjectPublicKeyInfo(SECKEYPublicKey *pubk)
 {
     CERTSubjectPublicKeyInfo *spki;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     SECItem params = { siBuffer, NULL, 0 };
 
     if (!pubk) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
     }
 
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
@@ skipping 109 matching lines @@
     }
 }
 
 /*
  * this only works for RSA keys... need to do something
  * similiar to CERT_ExtractPublicKey for other key times.
  */
 SECKEYPublicKey *
 SECKEY_DecodeDERPublicKey(SECItem *pubkder)
 {
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     SECKEYPublicKey *pubk;
     SECStatus rv;
     SECItem newPubkder;
 
     arena = PORT_NewArena (DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) {
         PORT_SetError (SEC_ERROR_NO_MEMORY);
         return NULL;
     }
 
@@ skipping 60 matching lines @@
     SECKEY_DestroySubjectPublicKeyInfo(spki);
 
 finish:
     return spkiDER;
 }
 
 
 CERTSubjectPublicKeyInfo *
 SECKEY_DecodeDERSubjectPublicKeyInfo(SECItem *spkider)
 {
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     CERTSubjectPublicKeyInfo *spki;
     SECStatus rv;
     SECItem newSpkider;
 
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
         return NULL;
     }
 
@@ skipping 44 matching lines @@
  * Verify digital signature and make sure challenge matches
  */
 CERTSubjectPublicKeyInfo *
 SECKEY_ConvertAndDecodePublicKeyAndChallenge(char *pkacstr, char *challenge,
                                                                 void *wincx)
 {
     CERTSubjectPublicKeyInfo *spki = NULL;
     CERTPublicKeyAndChallenge pkac;
     SECStatus rv;
     SECItem signedItem;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     CERTSignedData sd;
     SECItem sig;
     SECKEYPublicKey *pubKey = NULL;
     unsigned int len;
     
     signedItem.data = NULL;
     
     /* convert the base64 encoded data to binary */
     rv = ATOB_ConvertAsciiToItem(&signedItem, pkacstr);
     if (rv != SECSuccess) {
@@ skipping 74 matching lines @@
         SECKEY_DestroyPublicKey(pubKey);
     }
     
     return spki;
 }
 
 void
 SECKEY_DestroyPrivateKeyInfo(SECKEYPrivateKeyInfo *pvk,
                              PRBool freeit)
 {
-    PRArenaPool *poolp;
+    PLArenaPool *poolp;
 
     if(pvk != NULL) {
         if(pvk->arena) {
             poolp = pvk->arena;
             /* zero structure since PORT_FreeArena does not support
              * this yet.
              */
             PORT_Memset(pvk->privateKey.data, 0, pvk->privateKey.len);
             PORT_Memset((char *)pvk, 0, sizeof(*pvk));
             if(freeit == PR_TRUE) {
@@ skipping 10 matching lines @@
                 PORT_Free(pvk);
             }
         }
     }
 }
 
 void
 SECKEY_DestroyEncryptedPrivateKeyInfo(SECKEYEncryptedPrivateKeyInfo *epki,
                                       PRBool freeit)
 {
-    PRArenaPool *poolp;
+    PLArenaPool *poolp;
 
     if(epki != NULL) {
         if(epki->arena) {
             poolp = epki->arena;
             /* zero structure since PORT_FreeArena does not support
              * this yet.
              */
             PORT_Memset(epki->encryptedData.data, 0, epki->encryptedData.len);
             PORT_Memset((char *)epki, 0, sizeof(*epki));
             if(freeit == PR_TRUE) {
                 PORT_FreeArena(poolp, PR_TRUE);
             } else {
                 epki->arena = poolp;
             }
         } else {
             SECITEM_ZfreeItem(&epki->encryptedData, PR_FALSE);
             SECOID_DestroyAlgorithmID(&epki->algorithm, PR_FALSE);
             PORT_Memset((char *)epki, 0, sizeof(*epki));
             if(freeit == PR_TRUE) {
                 PORT_Free(epki);
             }
         }
     }
 }
 
 SECStatus
-SECKEY_CopyPrivateKeyInfo(PRArenaPool *poolp,
+SECKEY_CopyPrivateKeyInfo(PLArenaPool *poolp,
                           SECKEYPrivateKeyInfo *to,
                           SECKEYPrivateKeyInfo *from)
 {
     SECStatus rv = SECFailure;
 
     if((to == NULL) || (from == NULL)) {
         return SECFailure;
     }
 
     rv = SECOID_CopyAlgorithmID(poolp, &to->algorithm, &from->algorithm);
     if(rv != SECSuccess) {
         return SECFailure;
     }
     rv = SECITEM_CopyItem(poolp, &to->privateKey, &from->privateKey);
     if(rv != SECSuccess) {
         return SECFailure;
     }
     rv = SECITEM_CopyItem(poolp, &to->version, &from->version);
 
     return rv;
 }
 
 SECStatus
-SECKEY_CopyEncryptedPrivateKeyInfo(PRArenaPool *poolp, 
+SECKEY_CopyEncryptedPrivateKeyInfo(PLArenaPool *poolp,
                                    SECKEYEncryptedPrivateKeyInfo *to,
                                    SECKEYEncryptedPrivateKeyInfo *from)
 {
     SECStatus rv = SECFailure;
 
     if((to == NULL) || (from == NULL)) {
         return SECFailure;
     }
 
     rv = SECOID_CopyAlgorithmID(poolp, &to->algorithm, &from->algorithm);
@@ skipping 16 matching lines @@
 {
    return pubKey->keyType;
 }
 
 SECKEYPublicKey*
 SECKEY_ImportDERPublicKey(SECItem *derKey, CK_KEY_TYPE type)
 {
     SECKEYPublicKey *pubk = NULL;
     SECStatus rv = SECFailure;
     SECItem newDerKey;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
 
     if (!derKey) {
         return NULL;
     } 
 
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
         goto finish;
     }
@@ skipping 39 matching lines @@
             PORT_FreeArena(arena, PR_TRUE);
         }
         pubk = NULL;
     }
     return pubk;
 }
 
 SECKEYPrivateKeyList*
 SECKEY_NewPrivateKeyList(void)
 {
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECKEYPrivateKeyList *ret = NULL;
 
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if ( arena == NULL ) {
         goto loser;
     }
 
     ret = (SECKEYPrivateKeyList *)PORT_ArenaZAlloc(arena,
                 sizeof(SECKEYPrivateKeyList));
     if ( ret == NULL ) {
@@ skipping 56 matching lines @@
     return(SECSuccess);
 
 loser:
     return(SECFailure);
 }
 
 
 SECKEYPublicKeyList*
 SECKEY_NewPublicKeyList(void)
 {
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECKEYPublicKeyList *ret = NULL;
 
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if ( arena == NULL ) {
         goto loser;
     }
 
     ret = (SECKEYPublicKeyList *)PORT_ArenaZAlloc(arena,
                 sizeof(SECKEYPublicKeyList));
     if ( ret == NULL ) {
@@ skipping 71 matching lines @@
 {
     SECStatus rv = SECFailure;
     if (key && key->pkcs11Slot && key->pkcs11ID) {
         key->staticflags |= SECKEY_Attributes_Cached;
         SECKEY_CacheAttribute(key, CKA_PRIVATE);
         SECKEY_CacheAttribute(key, CKA_ALWAYS_AUTHENTICATE);
         rv = SECSuccess;
     }
     return rv;
 }