Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/certdb/polcyxtn.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/. */
 
 /*
  * Support for various policy related extensions
  */
 
 #include "seccomon.h"
 #include "secport.h"
@@ skipping 130 matching lines @@
         curlen++;
         tmpstr++;
     }
     
     return;
 }
 
 CERTCertificatePolicies *
 CERT_DecodeCertificatePoliciesExtension(const SECItem *extnValue)
 {
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv;
     CERTCertificatePolicies *policies;
     CERTPolicyInfo **policyInfos, *policyInfo;
     CERTPolicyQualifier **policyQualifiers, *policyQualifier;
     SECItem newExtnValue;
     
     /* make a new arena */
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     
     if ( !arena ) {
@@ skipping 55 matching lines @@
 {
     if ( policies != NULL ) {
         PORT_FreeArena(policies->arena, PR_FALSE);
     }
     return;
 }
 
 CERTCertificatePolicyMappings *
 CERT_DecodePolicyMappingsExtension(SECItem *extnValue)
 {
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv;
     CERTCertificatePolicyMappings *mappings;
     SECItem newExtnValue;
     
     /* make a new arena */
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if ( !arena ) {
         goto loser;
     }
 
@@ skipping 37 matching lines @@
     }
     return SECSuccess;
 }
 
 SECStatus
 CERT_DecodePolicyConstraintsExtension
                              (CERTCertificatePolicyConstraints *decodedValue,
                               const SECItem *encodedValue)
 {
     CERTCertificatePolicyConstraints decodeContext;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv = SECSuccess;
 
     /* initialize so we can tell when an optional component is omitted */
     PORT_Memset(&decodeContext, 0, sizeof(decodeContext));
 
     /* make a new arena */
     arena = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE);
     if (!arena) {
         return SECFailure;
     }
@@ skipping 35 matching lines @@
     } while (0);
 
     PORT_FreeArena(arena, PR_FALSE);
     return(rv);
 }
 
 SECStatus CERT_DecodeInhibitAnyExtension
         (CERTCertificateInhibitAny *decodedValue, SECItem *encodedValue)
 {
     CERTCertificateInhibitAny decodeContext;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv = SECSuccess;
 
     /* make a new arena */
     arena = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE);
     if ( !arena ) {
         return SECFailure;
     }
 
     do {
 
@@ skipping 11 matching lines @@
 
     } while (0);
 
     PORT_FreeArena(arena, PR_FALSE);
     return(rv);
 }
 
 CERTUserNotice *
 CERT_DecodeUserNotice(SECItem *noticeItem)
 {
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv;
     CERTUserNotice *userNotice;
     SECItem newNoticeItem;
     
     /* make a new arena */
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     
     if ( !arena ) {
         goto loser;
     }
@@ skipping 213 matching lines @@
 
 const SEC_ASN1Template CERT_OidSeqTemplate[] = {
     { SEC_ASN1_SEQUENCE_OF | SEC_ASN1_XTRN,
           offsetof(CERTOidSequence, oids),
           SEC_ASN1_SUB(SEC_ObjectIDTemplate) }
 };
 
 CERTOidSequence *
 CERT_DecodeOidSequence(const SECItem *seqItem)
 {
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     SECStatus rv;
     CERTOidSequence *oidSeq;
     SECItem newSeqItem;
     
     /* make a new arena */
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     
     if ( !arena ) {
         goto loser;
     }
@@ skipping 83 matching lines @@
         CERT_DestroyOidSequence(oidSeq);
     }
     if (extItem.data != NULL) {
         PORT_Free(extItem.data);
     }
     return(ret);
 }
 
 
 SECStatus
-CERT_EncodePolicyConstraintsExtension(PRArenaPool *arena,
+CERT_EncodePolicyConstraintsExtension(PLArenaPool *arena,
                                       CERTCertificatePolicyConstraints *constr,
                                       SECItem *dest)
 {
     SECStatus rv = SECSuccess;
 
     PORT_Assert(constr != NULL && dest != NULL);
     if (constr == NULL || dest == NULL) {
         return SECFailure;
     }
 
     if (SEC_ASN1EncodeItem (arena, dest, constr,
                             CERT_PolicyConstraintsTemplate) == NULL) {
         rv = SECFailure;
     }
     return(rv);
 }
 
 SECStatus
-CERT_EncodePolicyMappingExtension(PRArenaPool *arena,
+CERT_EncodePolicyMappingExtension(PLArenaPool *arena,
                                   CERTCertificatePolicyMappings *mapping,
                                   SECItem *dest)
 {
     SECStatus rv = SECSuccess;
 
     PORT_Assert(mapping != NULL && dest != NULL);
     if (mapping == NULL || dest == NULL) {
         return SECFailure;
     }
 
     if (SEC_ASN1EncodeItem (arena, dest, mapping,
                             CERT_PolicyMappingsTemplate) == NULL) {
         rv = SECFailure;
     }
     return(rv);
 }
 
 
 
 SECStatus
-CERT_EncodeCertPoliciesExtension(PRArenaPool *arena,
+CERT_EncodeCertPoliciesExtension(PLArenaPool *arena,
                                  CERTPolicyInfo **info,
                                  SECItem *dest)
 {
     SECStatus rv = SECSuccess;
 
     PORT_Assert(info != NULL && dest != NULL);
     if (info == NULL || dest == NULL) {
         return SECFailure;
     }
 
     if (SEC_ASN1EncodeItem (arena, dest, info,
                             CERT_CertificatePoliciesTemplate) == NULL) {
         rv = SECFailure;
     }
     return(rv);
 }
 
 SECStatus
-CERT_EncodeUserNotice(PRArenaPool *arena,
+CERT_EncodeUserNotice(PLArenaPool *arena,
                       CERTUserNotice *notice,
                       SECItem *dest)
 {
     SECStatus rv = SECSuccess;
 
     PORT_Assert(notice != NULL && dest != NULL);
     if (notice == NULL || dest == NULL) {
         return SECFailure;
     }
 
     if (SEC_ASN1EncodeItem(arena, dest,
                            notice, CERT_UserNoticeTemplate) == NULL) {
         rv = SECFailure;
     }
 
     return(rv);
 }
 
 SECStatus
-CERT_EncodeNoticeReference(PRArenaPool *arena,
+CERT_EncodeNoticeReference(PLArenaPool *arena,
                            CERTNoticeReference *reference,
                            SECItem *dest)
 {
     SECStatus rv = SECSuccess;
     
     PORT_Assert(reference != NULL && dest != NULL);
     if (reference == NULL || dest == NULL) {
         return SECFailure;
     }
 
     if (SEC_ASN1EncodeItem (arena, dest, reference,
                             CERT_NoticeReferenceTemplate) == NULL) {
         rv = SECFailure;
     }
 
     return(rv);
 }
 
 SECStatus
-CERT_EncodeInhibitAnyExtension(PRArenaPool *arena,
+CERT_EncodeInhibitAnyExtension(PLArenaPool *arena,
                                CERTCertificateInhibitAny *certInhibitAny,
                                SECItem *dest)
 {
     SECStatus rv = SECSuccess;
 
     PORT_Assert(certInhibitAny != NULL && dest != NULL);
     if (certInhibitAny == NULL || dest == NULL) {
         return SECFailure;
     }
 
     if (SEC_ASN1EncodeItem (arena, dest, certInhibitAny,
                             CERT_InhibitAnyTemplate) == NULL) {
         rv = SECFailure;
     }
     return(rv);
 }