Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/certdb/alg1485.c

 /* alg1485.c - implementation of RFCs 1485, 1779 and 2253.
  *
  * 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 "prprf.h"
 #include "cert.h"
 #include "certi.h"
 #include "xconst.h"
@@ skipping 345 matching lines @@
 }
 
 /* Parses one AVA, starting at *pbp.  Stops at endptr.
  * Advances *pbp past parsed AVA and trailing separator (if present).
  * On any error, returns NULL and *pbp is undefined.
  * On success, returns CERTAVA allocated from arena, and (*pbp)[-1] was 
  * the last character parsed.  *pbp is either equal to endptr or 
  * points to first character after separator.
  */
 static CERTAVA *
-ParseRFC1485AVA(PRArenaPool *arena, const char **pbp, const char *endptr)
+ParseRFC1485AVA(PLArenaPool *arena, const char **pbp, const char *endptr)
 {
     CERTAVA *a;
     const NameToKind *n2k;
     const char *bp;
     int       vt = -1;
     int       valLen;
     SECOidTag kind  = SEC_OID_UNKNOWN;
     SECStatus rv    = SECFailure;
     SECItem   derOid = { 0, NULL, 0 };
     SECItem   derVal = { 0, NULL, 0};
@@ skipping 755 matching lines @@
 }
 
 /*
  * Return the string representation of a DER encoded distinguished name
  * "dername" - The DER encoded name to convert
  */
 char *
 CERT_DerNameToAscii(SECItem *dername)
 {
     int rv;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     CERTName name;
     char *retstr = NULL;
     
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     
     if ( arena == NULL) {
         goto loser;
     }
     
     rv = SEC_QuickDERDecodeItem(arena, &name, CERT_NameTemplate, dername);
     
     if ( rv != SECSuccess ) {
         goto loser;
     }
 
     retstr = CERT_NameToAscii(&name);
 
 loser:
     if ( arena != NULL ) {
         PORT_FreeArena(arena, PR_FALSE);
     }
     
     return(retstr);
 }
 
 static char *
-avaToString(PRArenaPool *arena, CERTAVA *ava)
+avaToString(PLArenaPool *arena, CERTAVA *ava)
 {
     char *    buf       = NULL;
     SECItem*  avaValue;
     int       valueLen;
 
     avaValue = CERT_DecodeAVAValue(&ava->value);
     if(!avaValue) {
         return buf;
     }
     valueLen = cert_RFC1485_GetRequiredLen((char *)avaValue->data,
@@ skipping 13 matching lines @@
         }
     }
     SECITEM_FreeItem(avaValue, PR_TRUE);
     return buf;
 }
 
 /* RDNs are sorted from most general to most specific.
  * This code returns the FIRST one found, the most general one found.
  */
 static char *
-CERT_GetNameElement(PRArenaPool *arena, const CERTName *name, int wantedTag)
+CERT_GetNameElement(PLArenaPool *arena, const CERTName *name, int wantedTag)
 {
     CERTRDN** rdns = name->rdns;
     CERTRDN*  rdn;
     CERTAVA*  ava  = NULL;
 
     while (rdns && (rdn = *rdns++) != 0) {
         CERTAVA** avas = rdn->avas;
         while (avas && (ava = *avas++) != 0) {
             int tag = CERT_GetAVATag(ava);
             if ( tag == wantedTag ) {
                 avas = NULL;
                 rdns = NULL; /* break out of all loops */
             }
         }
     }
     return ava ? avaToString(arena, ava) : NULL;
 }
 
 /* RDNs are sorted from most general to most specific.
  * This code returns the LAST one found, the most specific one found.
  * This is particularly appropriate for Common Name.  See RFC 2818.
  */
 static char *
-CERT_GetLastNameElement(PRArenaPool *arena, const CERTName *name, int wantedTag)
+CERT_GetLastNameElement(PLArenaPool *arena, const CERTName *name, int wantedTag)
 {
     CERTRDN** rdns    = name->rdns;
     CERTRDN*  rdn;
     CERTAVA*  lastAva = NULL;
     
     while (rdns && (rdn = *rdns++) != 0) {
         CERTAVA** avas = rdn->avas;
         CERTAVA*  ava;
         while (avas && (ava = *avas++) != 0) {
             int tag = CERT_GetAVATag(ava);
             if ( tag == wantedTag ) {
                 lastAva = ava;
             }
         }
     }
     return lastAva ? avaToString(arena, lastAva) : NULL;
 }
 
 char *
 CERT_GetCertificateEmailAddress(CERTCertificate *cert)
 {
     char *rawEmailAddr = NULL;
     SECItem subAltName;
     SECStatus rv;
     CERTGeneralName *nameList = NULL;
     CERTGeneralName *current;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     int i;
     
     subAltName.data = NULL;
 
     rawEmailAddr = CERT_GetNameElement(cert->arena, &(cert->subject),
                                                  SEC_OID_PKCS9_EMAIL_ADDRESS);
     if ( rawEmailAddr == NULL ) {
         rawEmailAddr = CERT_GetNameElement(cert->arena, &(cert->subject), 
                                                         SEC_OID_RFC1274_MAIL);
     }
@@ skipping 111 matching lines @@
 /* Returns a pointer to an environment-like string, a series of 
 ** null-terminated strings, terminated by a zero-length string.
 ** This function is intended to be internal to NSS.
 */
 char *
 cert_GetCertificateEmailAddresses(CERTCertificate *cert)
 {
     char *           rawEmailAddr = NULL;
     char *           addrBuf      = NULL;
     char *           pBuf         = NULL;
-    PRArenaPool *    tmpArena     = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
+    PLArenaPool *    tmpArena     = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     PRUint32         maxLen       = 0;
     PRInt32          finalLen     = 0;
     SECStatus        rv;
     SECItem          subAltName;
     
     if (!tmpArena) 
         return addrBuf;
 
     subAltName.data = NULL;
     maxLen = cert->derCert.len;
@@ skipping 154 matching lines @@
 {
     return(CERT_GetNameElement(NULL, name, SEC_OID_AVA_DN_QUALIFIER));
 }
 
 char *
 CERT_GetCertUid(const CERTName *name)
 {
     return(CERT_GetNameElement(NULL, name, SEC_OID_RFC1274_UID));
 }