Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/certdb/certdb.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/. */
 
 /*
  * Certificate handling code
  */
 
 #include "nssilock.h"
 #include "prmon.h"
@@ skipping 191 matching lines @@
     { SEC_ASN1_SKIP_REST },
     { 0 }
 };
 
 SEC_ASN1_CHOOSER_IMPLEMENT(CERT_TimeChoiceTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(CERT_CertificateTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_SignedCertificateTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(CERT_SequenceOfCertExtensionTemplate)
 
 SECStatus
-CERT_KeyFromIssuerAndSN(PRArenaPool *arena, SECItem *issuer, SECItem *sn,
+CERT_KeyFromIssuerAndSN(PLArenaPool *arena, SECItem *issuer, SECItem *sn,
                         SECItem *key)
 {
     key->len = sn->len + issuer->len;
 
     if ((sn->data == NULL) || (issuer->data == NULL)) {
         goto loser;
     }
     
     key->data = (unsigned char*)PORT_ArenaAlloc(arena, key->len);
     if ( !key->data ) {
@@ skipping 13 matching lines @@
 }
 
 
 /*
  * Extract the subject name from a DER certificate
  */
 SECStatus
 CERT_NameFromDERCert(SECItem *derCert, SECItem *derName)
 {
     int rv;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     CERTSignedData sd;
     void *tmpptr;
     
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     
     if ( ! arena ) {
         return(SECFailure);
     }
    
     PORT_Memset(&sd, 0, sizeof(CERTSignedData));
@@ skipping 23 matching lines @@
 
 loser:
     PORT_FreeArena(arena, PR_FALSE);
     return(SECFailure);
 }
 
 SECStatus
 CERT_IssuerNameFromDERCert(SECItem *derCert, SECItem *derName)
 {
     int rv;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     CERTSignedData sd;
     void *tmpptr;
     
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     
     if ( ! arena ) {
         return(SECFailure);
     }
    
     PORT_Memset(&sd, 0, sizeof(CERTSignedData));
@@ skipping 23 matching lines @@
 
 loser:
     PORT_FreeArena(arena, PR_FALSE);
     return(SECFailure);
 }
 
 SECStatus
 CERT_SerialNumberFromDERCert(SECItem *derCert, SECItem *derName)
 {
     int rv;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     CERTSignedData sd;
     void *tmpptr;
     
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     
     if ( ! arena ) {
         return(SECFailure);
     }
    
     PORT_Memset(&sd, 0, sizeof(CERTSignedData));
@@ skipping 24 matching lines @@
 loser:
     PORT_FreeArena(arena, PR_FALSE);
     return(SECFailure);
 }
 
 /*
  * Generate a database key, based on serial number and issuer, from a
  * DER certificate.
  */
 SECStatus
-CERT_KeyFromDERCert(PRArenaPool *reqArena, SECItem *derCert, SECItem *key)
+CERT_KeyFromDERCert(PLArenaPool *reqArena, SECItem *derCert, SECItem *key)
 {
     int rv;
     CERTSignedData sd;
     CERTCertKey certkey;
 
     if (!reqArena) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return SECFailure;
     }
 
@@ skipping 347 matching lines @@
 }
 
 /*
  * take a DER certificate and decode it into a certificate structure
  */
 CERTCertificate *
 CERT_DecodeDERCertificate(SECItem *derSignedCert, PRBool copyDER,
                          char *nickname)
 {
     CERTCertificate *cert;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     void *data;
     int rv;
     int len;
     char *tmpname;
     
     /* make a new arena */
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     
     if ( !arena ) {
         return 0;
@@ skipping 109 matching lines @@
 
 CERTCertificate *
 __CERT_DecodeDERCertificate(SECItem *derSignedCert, PRBool copyDER,
                          char *nickname)
 {
     return CERT_DecodeDERCertificate(derSignedCert, copyDER, nickname);
 }
 
 
 CERTValidity *
-CERT_CreateValidity(int64 notBefore, int64 notAfter)
+CERT_CreateValidity(PRTime notBefore, PRTime notAfter)
 {
     CERTValidity *v;
     int rv;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
 
     if (notBefore > notAfter) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return NULL;
     }
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     
     if ( !arena ) {
         return(0);
     }
     
     v = (CERTValidity*) PORT_ArenaZAlloc(arena, sizeof(CERTValidity));
     if (v) {
         v->arena = arena;
         rv = DER_EncodeTimeChoice(arena, &v->notBefore, notBefore);
         if (rv) goto loser;
         rv = DER_EncodeTimeChoice(arena, &v->notAfter, notAfter);
         if (rv) goto loser;
     }
     return v;
 
   loser:
     CERT_DestroyValidity(v);
     return 0;
 }
 
 SECStatus
-CERT_CopyValidity(PRArenaPool *arena, CERTValidity *to, CERTValidity *from)
+CERT_CopyValidity(PLArenaPool *arena, CERTValidity *to, CERTValidity *from)
 {
     SECStatus rv;
 
     CERT_DestroyValidity(to);
     to->arena = arena;
     
     rv = SECITEM_CopyItem(arena, &to->notBefore, &from->notBefore);
     if (rv) return rv;
     rv = SECITEM_CopyItem(arena, &to->notAfter, &from->notAfter);
     return rv;
@@ skipping 490 matching lines @@
     }
 
     PORT_SetError(SSL_ERROR_BAD_CERT_DOMAIN);
     return SECFailure;
 }
 
 
 SECStatus
 cert_VerifySubjectAltName(const CERTCertificate *cert, const char *hn)
 {
-    PRArenaPool *     arena          = NULL;
+    PLArenaPool *     arena          = NULL;
     CERTGeneralName * nameList       = NULL;
     CERTGeneralName * current;
     char *            cn;
     int               cnBufLen;
     unsigned int      hnLen;
     int               DNSextCount    = 0;
     int               IPextCount     = 0;
     PRBool            isIPaddr       = PR_FALSE;
     SECStatus         rv             = SECFailure;
     SECItem           subAltName;
@@ skipping 114 matching lines @@
 }
 
 /*
  * If found:
  *   - subAltName contains the extension (caller must free)
  *   - return value is the decoded namelist (allocated off arena)
  * if not found, or if failure to decode:
  *   - return value is NULL
  */
 CERTGeneralName *
-cert_GetSubjectAltNameList(const CERTCertificate *cert, PRArenaPool *arena)
+cert_GetSubjectAltNameList(const CERTCertificate *cert, PLArenaPool *arena)
 {
     CERTGeneralName * nameList       = NULL;
     SECStatus         rv             = SECFailure;
     SECItem           subAltName;
 
     if (!cert || !arena)
       return NULL;
 
     subAltName.data = NULL;
 
@@ skipping 118 matching lines @@
  * Collect all valid DNS names from the given cert.
  * The output arena will reference some temporaray data,
  * but this saves us from dealing with two arenas.
  * The caller may free all data by freeing CERTCertNicknames->arena.
  */
 CERTCertNicknames *
 CERT_GetValidDNSPatternsFromCert(CERTCertificate *cert)
 {
     CERTGeneralName *generalNames;
     CERTCertNicknames *nickNames;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     char *singleName;
     
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (!arena) {
         return NULL;
     }
     
     nickNames = PORT_ArenaAlloc(arena, sizeof(CERTCertNicknames));
     if (!nickNames) {
       PORT_FreeArena(arena, PR_FALSE);
@@ skipping 204 matching lines @@
 
     return(PR_TRUE); /* all fields but common name are the same */
 }
 
 
 /* CERT_CertChainFromCert and CERT_DestroyCertificateList moved
    to certhigh.c */
 
 
 CERTIssuerAndSN *
-CERT_GetCertIssuerAndSN(PRArenaPool *arena, CERTCertificate *cert)
+CERT_GetCertIssuerAndSN(PLArenaPool *arena, CERTCertificate *cert)
 {
     CERTIssuerAndSN *result;
     SECStatus rv;
 
     if ( arena == NULL ) {
         arena = cert->arena;
     }
     
     result = (CERTIssuerAndSN*)PORT_ArenaZAlloc(arena, sizeof(*result));
     if (result == NULL) {
@@ skipping 575 matching lines @@
     return ((fcerts || !ncerts) ? SECSuccess : SECFailure);
 }
 
 /*
  * a real list of certificates - need to convert CERTCertificateList
  * stuff and ASN 1 encoder/decoder over to using this...
  */
 CERTCertList *
 CERT_NewCertList(void)
 {
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     CERTCertList *ret = NULL;
     
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if ( arena == NULL ) {
         goto loser;
     }
     
     ret = (CERTCertList *)PORT_ArenaZAlloc(arena, sizeof(CERTCertList));
     if ( ret == NULL ) {
         goto loser;
@@ skipping 737 matching lines @@
     CERTCertificate *cert = NULL;
     SECItem *derCert;
 
     derCert = cert_FindDERCertBySubjectKeyID(subjKeyID);
     if (derCert) {
         cert = CERT_FindCertByDERCert(handle, derCert);
         SECITEM_FreeItem(derCert, PR_TRUE);
     }
     return cert;
 }