Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/certdb/xconst.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/. */
 
 /*
  * X.509 Extension Encoding  
  */
 
 #include "prtypes.h"
 #include "seccomon.h"
@@ skipping 48 matching lines @@
       offsetof(CERTAuthInfoAccess, derLocation) },
     { 0, }
 };
 
 const SEC_ASN1Template CERTAuthInfoAccessTemplate[] = {
     { SEC_ASN1_SEQUENCE_OF, 0, CERTAuthInfoAccessItemTemplate }
 };
 
 
 SECStatus 
-CERT_EncodeSubjectKeyID(PRArenaPool *arena, const SECItem* srcString,
+CERT_EncodeSubjectKeyID(PLArenaPool *arena, const SECItem* srcString,
                         SECItem *encodedValue)
 {
     SECStatus rv = SECSuccess;
 
     if (!srcString) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return SECFailure;
     }
     if (SEC_ASN1EncodeItem (arena, encodedValue, srcString,
                             CERTSubjectKeyIDTemplate) == NULL) {
         rv = SECFailure;
     }
     
     return(rv);
 }
 
 
 SECStatus
-CERT_EncodePrivateKeyUsagePeriod(PRArenaPool *arena, 
+CERT_EncodePrivateKeyUsagePeriod(PLArenaPool *arena,
                                 CERTPrivKeyUsagePeriod *pkup, 
                                 SECItem *encodedValue)
 {
     SECStatus rv = SECSuccess;
 
     if (SEC_ASN1EncodeItem (arena, encodedValue, pkup,
                             CERTPrivateKeyUsagePeriodTemplate) == NULL) {
         rv = SECFailure;
     }
     return(rv);
@@ skipping 28 matching lines @@
         goto loser;
     }
     return pPeriod;
     
 loser:
     return NULL;
 }
 
 
 SECStatus 
-CERT_EncodeIA5TypeExtension(PRArenaPool *arena, char *value, SECItem *encodedValue)
+CERT_EncodeIA5TypeExtension(PLArenaPool *arena, char *value, SECItem *encodedValue)
 {
     SECItem encodeContext;
     SECStatus rv = SECSuccess;
 
 
     PORT_Memset (&encodeContext, 0, sizeof (encodeContext));
     
     if (value != NULL) {
         encodeContext.data = (unsigned char *)value;
         encodeContext.len = strlen(value);
     }
     if (SEC_ASN1EncodeItem (arena, encodedValue, &encodeContext,
                             CERTIA5TypeTemplate) == NULL) {
         rv = SECFailure;
     }
     
     return(rv);
 }
 
 SECStatus
-CERT_EncodeAltNameExtension(PRArenaPool *arena,  CERTGeneralName  *value, SECItem *encodedValue)
+CERT_EncodeAltNameExtension(PLArenaPool *arena,  CERTGeneralName  *value, SECItem *encodedValue)
 {
     SECItem                **encodedGenName;
     SECStatus              rv = SECSuccess;
 
     encodedGenName = cert_EncodeGeneralNames(arena, value);
     if (SEC_ASN1EncodeItem (arena, encodedValue, &encodedGenName,
                             CERT_GeneralNamesTemplate) == NULL) {
         rv = SECFailure;
     }
 
     return rv;
 }
 
 CERTGeneralName *
-CERT_DecodeAltNameExtension(PRArenaPool *reqArena, SECItem *EncodedAltName)
+CERT_DecodeAltNameExtension(PLArenaPool *reqArena, SECItem *EncodedAltName)
 {
     SECStatus                  rv = SECSuccess;
     CERTAltNameEncodedContext  encodedContext;
     SECItem*                   newEncodedAltName;
 
     if (!reqArena) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
     }
 
@@ skipping 14 matching lines @@
                                        encodedContext.encodedGenName);
     /* Extension contained an empty GeneralNames sequence */
     /* Treat as extension not found */
     PORT_SetError(SEC_ERROR_EXTENSION_NOT_FOUND);
 loser:
     return NULL;
 }
 
 
 SECStatus
-CERT_EncodeNameConstraintsExtension(PRArenaPool          *arena, 
+CERT_EncodeNameConstraintsExtension(PLArenaPool          *arena, 
                                     CERTNameConstraints  *value,
                                     SECItem              *encodedValue)
 {
     SECStatus     rv = SECSuccess;
     
     rv = cert_EncodeNameConstraints(value, arena, encodedValue);
     return rv;
 }
 
 
 CERTNameConstraints *
-CERT_DecodeNameConstraintsExtension(PRArenaPool          *arena,
+CERT_DecodeNameConstraintsExtension(PLArenaPool          *arena,
                                     const SECItem        *encodedConstraints)
 {
     return cert_DecodeNameConstraints(arena, encodedConstraints);
 }
 
 
 CERTAuthInfoAccess **
-CERT_DecodeAuthInfoAccessExtension(PRArenaPool *reqArena,
+CERT_DecodeAuthInfoAccessExtension(PLArenaPool *reqArena,
                                    SECItem     *encodedExtension)
 {
     CERTAuthInfoAccess **info = NULL;
     SECStatus rv;
     int i;
     SECItem* newEncodedExtension;
 
     if (!reqArena) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
@@ skipping 12 matching lines @@
 
     for (i = 0; info[i] != NULL; i++) {
         info[i]->location = CERT_DecodeGeneralName(reqArena,
                                                    &(info[i]->derLocation),
                                                    NULL);
     }
     return info;
 }
 
 SECStatus
-CERT_EncodeInfoAccessExtension(PRArenaPool *arena,
+CERT_EncodeInfoAccessExtension(PLArenaPool *arena,
                                    CERTAuthInfoAccess **info,
                                    SECItem *dest)
 {
     SECItem *dummy;
     int i;
 
     PORT_Assert(info != NULL);
     PORT_Assert(dest != NULL);
     if (info == NULL || dest == NULL) {
         return SECFailure;
     }
 
     for (i = 0; info[i] != NULL; i++) {
         if (CERT_EncodeGeneralName(info[i]->location, &(info[i]->derLocation),
                                    arena) == NULL)
             /* Note that this may leave some of the locations filled in. */
             return SECFailure;
     }
     dummy = SEC_ASN1EncodeItem(arena, dest, &info,
                                CERTAuthInfoAccessTemplate);
     if (dummy == NULL) {
         return SECFailure;
     }
     return SECSuccess;
 }