Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/pk11wrap/pk11akey.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/. */
 /*
  * This file contains functions to manage asymetric keys, (public and
  * private keys).
  */
 #include "seccomon.h"
 #include "secmod.h"
 #include "secmodi.h"
@@ skipping 196 matching lines @@
     pubKey->pkcs11ID = objectID;
     pubKey->pkcs11Slot = PK11_ReferenceSlot(slot);
 
     return objectID;
 }
 
 /*
  * take an attribute and copy it into a secitem
  */
 static CK_RV
-pk11_Attr2SecItem(PRArenaPool *arena, const CK_ATTRIBUTE *attr, SECItem *item) 
+pk11_Attr2SecItem(PLArenaPool *arena, const CK_ATTRIBUTE *attr, SECItem *item)
 {
     item->data = NULL;
 
     (void)SECITEM_AllocItem(arena, item, attr->ulValueLen);
     if (item->data == NULL) {
         return CKR_HOST_MEMORY;
     } 
     PORT_Memcpy(item->data, attr->pValue, item->len);
     return CKR_OK;
 }
 
 
 /*
  * get a curve length from a set of ecParams.
  * 
  * We need this so we can reliably determine if the ecPoint passed to us
  * was encoded or not. With out this, for many curves, we would incorrectly
  * identify an unencoded curve as an encoded curve 1 in 65536 times, and for
  * a few we would make that same mistake 1 in 32768 times. These are bad 
  * numbers since they are rare enough to pass tests, but common enough to
  * be tripped over in the field. 
  *
  * This function will only work for curves we recognized as of March 2009.
  * The assumption is curves in use after March of 2009 would be supplied by
  * PKCS #11 modules that already pass the correct encoding to us.
  *
  * Point length = (Roundup(curveLenInBits/8)*2+1)
  */
 static int
-pk11_get_EC_PointLenInBytes(PRArenaPool *arena, const SECItem *ecParams)
+pk11_get_EC_PointLenInBytes(PLArenaPool *arena, const SECItem *ecParams)
 {
    SECItem oid;
    SECOidTag tag;
    SECStatus rv;
 
    /* decode the OID tag */
    rv = SEC_QuickDERDecodeItem(arena, &oid,
                 SEC_ASN1_GET(SEC_ObjectIDTemplate), ecParams);
    if (rv != SECSuccess) {
         /* could be explict curves, allow them to work if the 
@@ skipping 91 matching lines @@
 }
 
 /*
  * returns the decoded point. In some cases the point may already be decoded.
  * this function tries to detect those cases and return the point in 
  * publicKeyValue. In other cases it's DER encoded. In those cases the point
  * is first decoded and returned. Space for the point is allocated out of 
  * the passed in arena.
  */
 static CK_RV
-pk11_get_Decoded_ECPoint(PRArenaPool *arena, const SECItem *ecParams, 
+pk11_get_Decoded_ECPoint(PLArenaPool *arena, const SECItem *ecParams,
         const CK_ATTRIBUTE *ecPoint, SECItem *publicKeyValue)
 {
     SECItem encodedPublicValue;
     SECStatus rv;
     int keyLen;
 
     if (ecPoint->ulValueLen == 0) {
         return CKR_ATTRIBUTE_VALUE_INVALID;
     }
 
@@ skipping 159 matching lines @@
     return CKR_ATTRIBUTE_VALUE_INVALID;
 }
 
 /*
  * extract a public key from a slot and id
  */
 SECKEYPublicKey *
 PK11_ExtractPublicKey(PK11SlotInfo *slot,KeyType keyType,CK_OBJECT_HANDLE id)
 {
     CK_OBJECT_CLASS keyClass = CKO_PUBLIC_KEY;
-    PRArenaPool *arena;
-    PRArenaPool *tmp_arena;
+    PLArenaPool *arena;
+    PLArenaPool *tmp_arena;
     SECKEYPublicKey *pubKey;
     int templateCount = 0;
     CK_KEY_TYPE pk11KeyType;
     CK_RV crv;
     CK_ATTRIBUTE template[8];
     CK_ATTRIBUTE *attrs= template;
     CK_ATTRIBUTE *modulus,*exponent,*base,*prime,*subprime,*value;
     CK_ATTRIBUTE *ecparams;
 
     /* if we didn't know the key type, get it */
@@ skipping 162 matching lines @@
     return pubKey;
 }
 
 /*
  * Build a Private Key structure from raw PKCS #11 information.
  */
 SECKEYPrivateKey *
 PK11_MakePrivKey(PK11SlotInfo *slot, KeyType keyType, 
                         PRBool isTemp, CK_OBJECT_HANDLE privID, void *wincx)
 {
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     SECKEYPrivateKey *privKey;
     PRBool isPrivate;
     SECStatus rv;
 
     /* don't know? look it up */
     if (keyType == nullKey) {
         CK_KEY_TYPE pk11Type = CKK_RSA;
 
         pk11Type = PK11_ReadULongAttribute(slot,privID,CKA_KEY_TYPE);
         isTemp = (PRBool)!PK11_HasAttributeSet(slot,privID,CKA_TOKEN,PR_FALSE);
@@ skipping 125 matching lines @@
         { CKA_PRIVATE, NULL, 0 },
         { CKA_MODIFIABLE, NULL, 0 },
         { CKA_SENSITIVE, NULL, 0 },
         { CKA_EXTRACTABLE, NULL, 0 },
 #define NUM_RESERVED_ATTRS 5    /* number of reserved attributes above */
     };
     CK_BBOOL cktrue = CK_TRUE;
     CK_BBOOL ckfalse = CK_FALSE;
     CK_ATTRIBUTE *attrs = NULL, *ap;
     const int templateSize = sizeof(privTemplate)/sizeof(privTemplate[0]);
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     CK_OBJECT_HANDLE objectID;
     int i, count = 0;
     int extra_count = 0;
     CK_RV crv;
     SECStatus rv;
     PRBool token = ((attrFlags & PK11_ATTR_TOKEN) != 0);
 
     if (pk11_BadAttrFlags(attrFlags)) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
@@ skipping 615 matching lines @@
                                                 attrFlags, wincx);
 }
 
 /* build a public KEA key from the public value */
 SECKEYPublicKey *
 PK11_MakeKEAPubKey(unsigned char *keyData,int length)
 {
     SECKEYPublicKey *pubk;
     SECItem pkData;
     SECStatus rv;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
 
     pkData.data = keyData;
     pkData.len = length;
 
     arena = PORT_NewArena (DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL)
         return NULL;
 
     pubk = (SECKEYPublicKey *) PORT_ArenaZAlloc(arena, sizeof(SECKEYPublicKey));
     if (pubk == NULL) {
@@ skipping 193 matching lines @@
 SECKEYEncryptedPrivateKeyInfo * 
 PK11_ExportEncryptedPrivKeyInfo(
    PK11SlotInfo     *slot,      /* optional, encrypt key in this slot */
    SECOidTag         algTag,    /* encrypt key with this algorithm */
    SECItem          *pwitem,    /* password for PBE encryption */
    SECKEYPrivateKey *pk,        /* encrypt this private key */
    int               iteration, /* interations for PBE alg */
    void             *wincx)     /* context for password callback ? */
 {
     SECKEYEncryptedPrivateKeyInfo *epki      = NULL;
-    PRArenaPool                   *arena     = NULL;
+    PLArenaPool                   *arena     = NULL;
     SECAlgorithmID                *algid;
     SECOidTag                     pbeAlgTag = SEC_OID_UNKNOWN;
     SECItem                       *crypto_param = NULL;
     PK11SymKey                    *key       = NULL;
     SECKEYPrivateKey              *tmpPK = NULL;
     SECStatus                      rv        = SECSuccess;
     CK_RV                          crv;
     CK_ULONG                       encBufLen;
     CK_MECHANISM_TYPE              pbeMechType;
     CK_MECHANISM_TYPE              cryptoMechType;
@@ skipping 185 matching lines @@
 
 SECKEYPQGParams *
 PK11_GetPQGParamsFromPrivateKey(SECKEYPrivateKey *privKey)
 {
     CK_ATTRIBUTE pTemplate[] = {
         { CKA_PRIME, NULL, 0 },
         { CKA_SUBPRIME, NULL, 0 },
         { CKA_BASE, NULL, 0 },
     };
     int pTemplateLen = sizeof(pTemplate)/sizeof(pTemplate[0]);
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECKEYPQGParams *params;
     CK_RV crv;
 
 
     arena = PORT_NewArena(2048);
     if (arena == NULL) {
         goto loser;
     }
     params=(SECKEYPQGParams *)PORT_ArenaZAlloc(arena,sizeof(SECKEYPQGParams));
     if (params == NULL) {
@@ skipping 432 matching lines @@
     for (i=0; i < objCount ; i++) {
         SECKEYPrivateKey *privKey = 
                 PK11_MakePrivKey(slot,nullKey,PR_TRUE,key_ids[i],wincx);
         SECKEY_AddPrivateKeyToListTail(keys, privKey);
    }
 
    PORT_Free(key_ids);
    return keys;
 }