Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/certhigh/ocspti.h

 /* 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/. */
 
 /*
  * Private header defining OCSP types.
  */
 
 #ifndef _OCSPTI_H_
 #define _OCSPTI_H_
@@ skipping 54 matching lines @@
 typedef struct ocspSignatureStr ocspSignature;
 typedef struct ocspSingleRequestStr ocspSingleRequest;
 typedef struct ocspSingleResponseStr ocspSingleResponse;
 typedef struct ocspTBSRequestStr ocspTBSRequest;
 
 
 /*
  * An OCSPRequest; this is what is sent (encoded) to an OCSP responder.
  */
 struct CERTOCSPRequestStr {
-    PRArenaPool *arena;                 /* local; not part of encoding */
+    PLArenaPool *arena;                 /* local; not part of encoding */
     ocspTBSRequest *tbsRequest;
     ocspSignature *optionalSignature;
 };
 
 /*
  * A TBSRequest; when an OCSPRequest is signed, the encoding of this
  * is what the signature is actually applied to.  ("TBS" == To Be Signed)
  * Whether signed or not, however, this structure will be present, and
  * is the "meat" of the OCSPRequest.
  *
@@ skipping 51 matching lines @@
  * whose status is being checked.
  *
  * Note that in the OCSP specification this is just called "Request",
  * but since that seemed confusing (vs. an OCSPRequest) and to be more
  * consistent with the parallel type "SingleResponse", I called it a
  * "SingleRequest".
  * 
  * XXX figure out how to get rid of that arena -- there must be a way
  */
 struct ocspSingleRequestStr {
-    PRArenaPool *arena;                 /* just a copy of the response arena,
+    PLArenaPool *arena;                 /* just a copy of the response arena,
                                          * needed here for extension handling
                                          * routines, on creation only */
     CERTOCSPCertID *reqCert;
     CERTCertExtension **singleRequestExtensions;
 };
 
 /*
  * A CertID is the means of identifying a certificate, used both in requests
  * and in responses.
  *
  * When in a SingleRequest it specifies the certificate to be checked.
  * When in a SingleResponse it is the cert whose status is being given.
  */
 struct CERTOCSPCertIDStr {
     SECAlgorithmID hashAlgorithm;
     SECItem issuerNameHash;             /* an OCTET STRING */
     SECItem issuerKeyHash;              /* an OCTET STRING */
     SECItem serialNumber;               /* an INTEGER */
     SECItem issuerSHA1NameHash;         /* keep other hashes around when */
     SECItem issuerMD5NameHash;              /* we have them */
     SECItem issuerMD2NameHash;
     SECItem issuerSHA1KeyHash;          /* keep other hashes around when */
     SECItem issuerMD5KeyHash;              /* we have them */
     SECItem issuerMD2KeyHash;
-    PRArenaPool *poolp;
+    PLArenaPool *poolp;
 };
 
 /*
  * This describes the value of the responseStatus field in an OCSPResponse.
  * The corresponding ASN.1 definition is:
  *
  * OCSPResponseStatus   ::=     ENUMERATED {
  *      successful              (0),    --Response has valid confirmations
  *      malformedRequest        (1),    --Illegal confirmation request
  *      internalError           (2),    --Internal error in issuer
@@ skipping 19 matching lines @@
 } ocspResponseStatus;
 
 /*
  * An OCSPResponse is what is sent (encoded) by an OCSP responder.
  *
  * The field "responseStatus" is the ASN.1 encoded value; the field
  * "statusValue" is simply that same value translated into our local
  * type ocspResponseStatus.
  */
 struct CERTOCSPResponseStr {
-    PRArenaPool *arena;                 /* local; not part of encoding */
+    PLArenaPool *arena;                 /* local; not part of encoding */
     SECItem responseStatus;             /* an ENUMERATED, see above */
     ocspResponseStatus statusValue;     /* local; not part of encoding */
     ocspResponseBytes *responseBytes;   /* only when status is successful */
 };
 
 /*
  * A ResponseBytes (despite appearances) is what contains the meat
  * of a successful response -- but still in encoded form.  The type
  * given as "responseType" tells you how to decode the string.
  *
@@ skipping 54 matching lines @@
     } responderIDValue;
 };
 
 /*
  * The ResponseData in a BasicOCSPResponse contains a SEQUENCE OF
  * SingleResponse -- one for each certificate whose status is being supplied.
  * 
  * XXX figure out how to get rid of that arena -- there must be a way
  */
 struct CERTOCSPSingleResponseStr {
-    PRArenaPool *arena;                 /* just a copy of the response arena,
+    PLArenaPool *arena;                 /* just a copy of the response arena,
                                          * needed here for extension handling
                                          * routines, on creation only */
     CERTOCSPCertID *certID;
     SECItem derCertStatus;
     ocspCertStatus *certStatus;         /* local; not part of encoding */
     SECItem thisUpdate;                 /* a GeneralizedTime */
     SECItem *nextUpdate;                /* a GeneralizedTime */
     CERTCertExtension **singleExtensions;
 };
 
@@ skipping 52 matching lines @@
  * When added, it specifies the (name of the) issuer of the cert being
  * checked, and optionally the value of the AuthorityInfoAccess extension
  * if the cert has one.
  */
 struct ocspServiceLocatorStr {
     CERTName *issuer;
     SECItem locator;    /* DER encoded authInfoAccess extension from cert */
 };
 
 #endif /* _OCSPTI_H_ */