Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/certdb/crl.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/. */
 
 /*
  * Moved from secpkcs7.c
  */
  
 #include "cert.h"
 #include "certi.h"
@@ skipping 286 matching lines @@
     }
 
     return (SECSuccess);
 }
 
 /*
  * Generate a database key, based on the issuer name from a
  * DER crl.
  */
 SECStatus
-CERT_KeyFromDERCrl(PRArenaPool *arena, SECItem *derCrl, SECItem *key)
+CERT_KeyFromDERCrl(PLArenaPool *arena, SECItem *derCrl, SECItem *key)
 {
     SECStatus rv;
     CERTSignedData sd;
     CERTCrlKey crlkey;
-    PRArenaPool* myArena;
+    PLArenaPool* myArena;
 
     if (!arena) {
         /* arena needed for QuickDER */
         myArena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     } else {
         myArena = arena;
     }
     PORT_Memset (&sd, 0, sizeof (sd));
     rv = SEC_QuickDERDecodeItem (myArena, &sd, CERT_SignedDataTemplate, derCrl);
     if (SECSuccess == rv) {
@@ skipping 62 matching lines @@
         }
     }
     return rv;
 }
 
 /*
  * take a DER CRL and decode it into a CRL structure
  * allow reusing the input DER without making a copy
  */
 CERTSignedCrl *
-CERT_DecodeDERCrlWithFlags(PRArenaPool *narena, SECItem *derSignedCrl,
+CERT_DecodeDERCrlWithFlags(PLArenaPool *narena, SECItem *derSignedCrl,
                           int type, PRInt32 options)
 {
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     CERTSignedCrl *crl;
     SECStatus rv;
     OpaqueCRLFields* extended = NULL;
     const SEC_ASN1Template* crlTemplate = CERT_SignedCrlTemplate;
     PRInt32 testOptions = options;
 
     PORT_Assert(derSignedCrl);
     if (!derSignedCrl) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
@@ skipping 116 matching lines @@
         PORT_FreeArena(arena, PR_FALSE);
     }
     
     return(0);
 }
 
 /*
  * take a DER CRL and decode it into a CRL structure
  */
 CERTSignedCrl *
-CERT_DecodeDERCrl(PRArenaPool *narena, SECItem *derSignedCrl, int type)
+CERT_DecodeDERCrl(PLArenaPool *narena, SECItem *derSignedCrl, int type)
 {
     return CERT_DecodeDERCrlWithFlags(narena, derSignedCrl, type,
                                       CRL_DECODE_DEFAULT_OPTIONS);
 }
 
 /*
  * Lookup a CRL in the databases. We mirror the same fast caching data base
  *  caching stuff used by certificates....?
  * return values :
  *
@@ skipping 167 matching lines @@
     retCrl = PK11_ImportCRL(slot, derCrl, url, type, NULL,
         CRL_IMPORT_BYPASS_CHECKS, NULL, CRL_DECODE_DEFAULT_OPTIONS);
     PK11_FreeSlot(slot);
 
     return retCrl;
 }
     
 CERTSignedCrl *
 SEC_FindCrlByDERCert(CERTCertDBHandle *handle, SECItem *derCrl, int type)
 {
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     SECItem crlKey;
     SECStatus rv;
     CERTSignedCrl *crl = NULL;
     
     /* create a scratch arena */
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if ( arena == NULL ) {
         return(NULL);
     }
     
@@ skipping 40 matching lines @@
         return SECSuccess;
     } else {
         return SECFailure;
     }
 }
 
 SECStatus
 SEC_LookupCrls(CERTCertDBHandle *handle, CERTCrlHeadNode **nodes, int type)
 {
     CERTCrlHeadNode *head;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv;
 
     *nodes = NULL;
 
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if ( arena == NULL ) {
         return SECFailure;
     }
 
     /* build a head structure */
@@ skipping 157 matching lines @@
     }
     if (PreAllocator->arena)
     {
         PORT_FreeArena(PreAllocator->arena, PR_TRUE);
     }
 }
 
 /* constructor for PreAllocator object */
 PreAllocator* PreAllocator_Create(PRSize size)
 {
-    PRArenaPool* arena = NULL;
+    PLArenaPool* arena = NULL;
     PreAllocator* prebuffer = NULL;
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (!arena)
     {
         return NULL;
     }
     prebuffer = (PreAllocator*)PORT_ArenaZAlloc(arena,
                                                 sizeof(PreAllocator));
     if (!prebuffer)
     {
@@ skipping 2389 matching lines @@
            to CERT_CacheCRL previously. That API takes a SECItem*, thus, we
            just do a pointer comparison here.
         */
         if (b->crl->derCrl == a->crl->derCrl)
         {
             *isDupe = PR_TRUE;
         }
     }
     return SECSuccess;
 }