Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/certhigh/certhigh.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/. */
 #include "nspr.h"
 #include "secerr.h"
 #include "secasn1.h"
 #include "seccomon.h"
 #include "pk11func.h"
 #include "certdb.h"
 #include "certt.h"
@@ skipping 62 matching lines @@
                           PRBool oneCertPerName,
                           PRBool validOnly,
                           void *proto_win)
 {
     CERTCertNicknames *nicknames = NULL;
     char **nnptr;
     int nn;
     CERTCertificate *cert = NULL;
     CERTCertList *certList = NULL;
     SECStatus rv;
-    int64 time;
+    PRTime time;
     CERTCertListNode *node = NULL;
     CERTCertListNode *freenode = NULL;
     int n;
     
     time = PR_Now();
     
     nicknames = CERT_GetCertNicknames(handle, SEC_CERT_NICKNAMES_USER,
                                       proto_win);
     
     if ( ( nicknames == NULL ) || ( nicknames->numnicknames == 0 ) ) {
@@ skipping 127 matching lines @@
 CERTCertificate *
 CERT_FindUserCertByUsage(CERTCertDBHandle *handle,
                          const char *nickname,
                          SECCertUsage usage,
                          PRBool validOnly,
                          void *proto_win)
 {
     CERTCertificate *cert = NULL;
     CERTCertList *certList = NULL;
     SECStatus rv;
-    int64 time;
+    PRTime time;
     
     time = PR_Now();
     
     /* use the pk11 call so that we pick up any certs on tokens,
      * which may require login
      */
     /* XXX - why is this restricted? */
     if ( proto_win != NULL ) {
         cert = PK11_FindCertFromNickname(nickname,proto_win);
     }
@@ skipping 209 matching lines @@
         names->numnicknames++;
     }
     
     if (nickname) PORT_Free(nickname);
     return(PR_SUCCESS);
 }
 
 CERTCertNicknames *
 CERT_GetCertNicknames(CERTCertDBHandle *handle, int what, void *wincx)
 {
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     CERTCertNicknames *names;
     int i;
     stringNode *node;
     
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if ( arena == NULL ) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
         return(NULL);
     }
     
@@ skipping 109 matching lines @@
     
     return(SECSuccess);
 }
 
 /*
  * Return all of the CAs that are "trusted" for SSL.
  */
 CERTDistNames *
 CERT_DupDistNames(CERTDistNames *orig)
 {
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     CERTDistNames *names;
     int i;
     SECStatus rv;
     
     /* allocate an arena to use */
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
         return(NULL);
     }
@@ skipping 27 matching lines @@
     return(names);
     
 loser:
     PORT_FreeArena(arena, PR_FALSE);
     return(NULL);
 }
 
 CERTDistNames *
 CERT_GetSSLCACerts(CERTCertDBHandle *handle)
 {
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     CERTDistNames *names;
     int i;
     SECStatus rv;
     dnameNode *node;
     
     /* allocate an arena to use */
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if ( arena == NULL ) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
         return(NULL);
@@ skipping 41 matching lines @@
     
 loser:
     PORT_FreeArena(arena, PR_FALSE);
     return(NULL);
 }
 
 CERTDistNames *
 CERT_DistNamesFromCertList(CERTCertList *certList)
 {
     CERTDistNames *   dnames = NULL;
-    PRArenaPool *     arena;
+    PLArenaPool *     arena;
     CERTCertListNode *node = NULL;
     SECItem *         names = NULL;
     int               listLen = 0, i = 0;
 
     if (certList == NULL) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
     }
 
     node = CERT_LIST_HEAD(certList);
@@ skipping 27 matching lines @@
         PORT_FreeArena(arena, PR_FALSE);
     }
     return NULL;
 }
 
 CERTDistNames *
 CERT_DistNamesFromNicknames(CERTCertDBHandle *handle, char **nicknames,
                            int nnames)
 {
     CERTDistNames *dnames = NULL;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     int i, rv;
     SECItem *names = NULL;
     CERTCertificate *cert = NULL;
     
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) goto loser;
     dnames = PORT_ArenaZNew(arena, CERTDistNames);
     if (dnames == NULL) goto loser;
 
     dnames->arena = arena;
@@ skipping 21 matching lines @@
 /* [ from pcertdb.c - calls Ascii to Name ] */
 /*
  * Lookup a certificate in the database by name
  */
 CERTCertificate *
 CERT_FindCertByNameString(CERTCertDBHandle *handle, char *nameStr)
 {
     CERTName *name;
     SECItem *nameItem;
     CERTCertificate *cert = NULL;
-    PRArenaPool *arena = NULL;
+    PLArenaPool *arena = NULL;
     
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     
     if ( arena == NULL ) {
         goto loser;
     }
     
     name = CERT_AsciiToName(nameStr);
     
     if ( name ) {
@@ skipping 215 matching lines @@
     CERTCertificate *cert;
 } certNode;
 
 CERTCertificateList *
 CERT_CertChainFromCert(CERTCertificate *cert, SECCertUsage usage,
                        PRBool includeRoot)
 {
     CERTCertificateList *chain = NULL;
     NSSCertificate **stanChain;
     NSSCertificate *stanCert;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     NSSUsage nssUsage;
     int i, len;
     NSSTrustDomain *td   = STAN_GetDefaultTrustDomain();
     NSSCryptoContext *cc = STAN_GetDefaultCryptoContext();
 
     stanCert = STAN_GetNSSCertificate(cert);
     if (!stanCert) {
         /* error code is set */
         return NULL;
     }
@@ skipping 71 matching lines @@
 }
 
 /* Builds a CERTCertificateList holding just one DER-encoded cert, namely
 ** the one for the cert passed as an argument.
 */
 CERTCertificateList *
 CERT_CertListFromCert(CERTCertificate *cert)
 {
     CERTCertificateList *chain = NULL;
     int rv;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
 
     /* arena for SecCertificateList */
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) goto no_memory;
 
     /* build the CERTCertificateList */
     chain = (CERTCertificateList *)PORT_ArenaAlloc(arena, sizeof(CERTCertificateList));
     if (chain == NULL) goto no_memory;
     chain->certs = (SECItem*)PORT_ArenaAlloc(arena, 1 * sizeof(SECItem));
     if (chain->certs == NULL) goto no_memory;
@@ skipping 10 matching lines @@
     if (arena != NULL) {
         PORT_FreeArena(arena, PR_FALSE);
     }
     return NULL;
 }
 
 CERTCertificateList *
 CERT_DupCertList(const CERTCertificateList * oldList)
 {
     CERTCertificateList *newList = NULL;
-    PRArenaPool         *arena   = NULL;
+    PLArenaPool         *arena   = NULL;
     SECItem             *newItem;
     SECItem             *oldItem;
     int                 len      = oldList->len;
     int                 rv;
 
     /* arena for SecCertificateList */
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) 
         goto no_memory;
 
@@ skipping 23 matching lines @@
     }
     return NULL;
 }
 
 void
 CERT_DestroyCertificateList(CERTCertificateList *list)
 {
     PORT_FreeArena(list->arena, PR_FALSE);
 }