Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/certdb/secname.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 "cert.h"
 #include "secoid.h"
 #include "secder.h"     /* XXX remove this when remove the DERTemplates */
 #include "secasn1.h"
 #include "secitem.h"
 #include <stdarg.h>
@@ skipping 22 matching lines @@
     int count = 0;
     if (array) {
         while (*array++) {
             count++;
         }
     }
     return count;
 }
 
 static void **
-AddToArray(PRArenaPool *arena, void **array, void *element)
+AddToArray(PLArenaPool *arena, void **array, void *element)
 {
     unsigned count;
     void **ap;
 
     /* Count up number of slots already in use in the array */
     count = 0;
     ap = array;
     if (ap) {
         while (*ap++) {
             count++;
@@ skipping 23 matching lines @@
 
     oid = SECOID_FindOID(&ava->type);
     
     if ( oid ) {
         return(oid->offset);
     }
     return (SECOidTag)-1;
 }
 
 static SECStatus
-SetupAVAType(PRArenaPool *arena, SECOidTag type, SECItem *it, unsigned *maxLenp)
+SetupAVAType(PLArenaPool *arena, SECOidTag type, SECItem *it, unsigned *maxLenp)
 {
     unsigned char *oid;
     unsigned oidLen;
     unsigned char *cp;
     int      maxLen;
     SECOidData *oidrec;
 
     oidrec = SECOID_FindOIDByTag(type);
     if (oidrec == NULL)
         return SECFailure;
@@ skipping 11 matching lines @@
     if (cp == NULL) {
         return SECFailure;
     }
     it->len = oidLen;
     PORT_Memcpy(cp, oid, oidLen);
     *maxLenp = (unsigned)maxLen;
     return SECSuccess;
 }
 
 static SECStatus
-SetupAVAValue(PRArenaPool *arena, int valueType, const SECItem *in, 
+SetupAVAValue(PLArenaPool *arena, int valueType, const SECItem *in,
               SECItem *out, unsigned maxLen)
 {
     PRUint8 *value, *cp, *ucs4Val;
     unsigned valueLen, valueLenLen, total;
     unsigned ucs4Len = 0, ucs4MaxLen;
 
     value    = in->data;
     valueLen = in->len;
     switch (valueType) {
       case SEC_ASN1_PRINTABLE_STRING:
@@ skipping 30 matching lines @@
         return SECFailure;
     }
     out->data = cp;
     out->len  = total;
     cp = (PRUint8 *)DER_StoreHeader(cp, valueType, valueLen);
     PORT_Memcpy(cp, value, valueLen);
     return SECSuccess;
 }
 
 CERTAVA *
-CERT_CreateAVAFromRaw(PRArenaPool *pool, const SECItem * OID, 
+CERT_CreateAVAFromRaw(PLArenaPool *pool, const SECItem * OID,
                       const SECItem * value)
 {
     CERTAVA *ava;
     int rv;
 
     ava = PORT_ArenaZNew(pool, CERTAVA);
     if (ava) {
         rv = SECITEM_CopyItem(pool, &ava->type, OID);
         if (rv) 
             return NULL;
 
         rv = SECITEM_CopyItem(pool, &ava->value, value);
         if (rv) 
             return NULL;
     }
     return ava;
 }
 
 CERTAVA *
-CERT_CreateAVAFromSECItem(PRArenaPool *arena, SECOidTag kind, int valueType, 
+CERT_CreateAVAFromSECItem(PLArenaPool *arena, SECOidTag kind, int valueType,
                           SECItem *value)
 {
     CERTAVA *ava;
     int rv;
     unsigned maxLen;
 
     ava = (CERTAVA*) PORT_ArenaZAlloc(arena, sizeof(CERTAVA));
     if (ava) {
         rv = SetupAVAType(arena, kind, &ava->type, &maxLen);
         if (rv) {
             /* Illegal AVA type */
             return NULL;
         }
         rv = SetupAVAValue(arena, valueType, value, &ava->value, maxLen);
         if (rv) {
             /* Illegal value type */
             return NULL;
         }
     }
     return ava;
 }
 
 CERTAVA *
-CERT_CreateAVA(PRArenaPool *arena, SECOidTag kind, int valueType, char *value)
+CERT_CreateAVA(PLArenaPool *arena, SECOidTag kind, int valueType, char *value)
 {
     SECItem item = { siBuffer, NULL, 0 };
 
     item.data = (PRUint8 *)value;
     item.len  = PORT_Strlen(value);
 
     return CERT_CreateAVAFromSECItem(arena, kind, valueType, &item);
 }
 
 CERTAVA *
-CERT_CopyAVA(PRArenaPool *arena, CERTAVA *from)
+CERT_CopyAVA(PLArenaPool *arena, CERTAVA *from)
 {
     CERTAVA *ava;
     int rv;
 
     ava = (CERTAVA*) PORT_ArenaZAlloc(arena, sizeof(CERTAVA));
     if (ava) {
         rv = SECITEM_CopyItem(arena, &ava->type, &from->type);
         if (rv) goto loser;
         rv = SECITEM_CopyItem(arena, &ava->value, &from->value);
         if (rv) goto loser;
     }
     return ava;
 
   loser:
     return 0;
 }
 
 /************************************************************************/
 /* XXX This template needs to go away in favor of the new SEC_ASN1 version. */
 static const SEC_ASN1Template cert_RDNTemplate[] = {
     { SEC_ASN1_SET_OF,
           offsetof(CERTRDN,avas), cert_AVATemplate, sizeof(CERTRDN) }
 };
 
 
 CERTRDN *
-CERT_CreateRDN(PRArenaPool *arena, CERTAVA *ava0, ...)
+CERT_CreateRDN(PLArenaPool *arena, CERTAVA *ava0, ...)
 {
     CERTAVA *ava;
     CERTRDN *rdn;
     va_list ap;
     unsigned count;
     CERTAVA **avap;
 
     rdn = (CERTRDN*) PORT_ArenaAlloc(arena, sizeof(CERTRDN));
     if (rdn) {
         /* Count number of avas going into the rdn */
@@ skipping 20 matching lines @@
                 *avap++ = ava;
             }
             va_end(ap);
         }
         *avap++ = 0;
     }
     return rdn;
 }
 
 SECStatus
-CERT_AddAVA(PRArenaPool *arena, CERTRDN *rdn, CERTAVA *ava)
+CERT_AddAVA(PLArenaPool *arena, CERTRDN *rdn, CERTAVA *ava)
 {
     rdn->avas = (CERTAVA**) AddToArray(arena, (void**) rdn->avas, ava);
     return rdn->avas ? SECSuccess : SECFailure;
 }
 
 SECStatus
-CERT_CopyRDN(PRArenaPool *arena, CERTRDN *to, CERTRDN *from)
+CERT_CopyRDN(PLArenaPool *arena, CERTRDN *to, CERTRDN *from)
 {
     CERTAVA **avas, *fava, *tava;
     SECStatus rv = SECSuccess;
 
     /* Copy each ava from from */
     avas = from->avas;
     if (avas) {
         if (avas[0] == NULL) {
             rv = CERT_AddAVA(arena, to, NULL);
             return rv;
@@ skipping 22 matching lines @@
 SEC_ASN1_CHOOSER_IMPLEMENT(CERT_NameTemplate)
 
 CERTName *
 CERT_CreateName(CERTRDN *rdn0, ...)
 {
     CERTRDN *rdn;
     CERTName *name;
     va_list ap;
     unsigned count;
     CERTRDN **rdnp;
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if ( !arena ) {
         return(0);
     }
     
     name = (CERTName*) PORT_ArenaAlloc(arena, sizeof(CERTName));
     if (name) {
         name->arena = arena;
         
@@ skipping 34 matching lines @@
 loser:
     PORT_FreeArena(arena, PR_FALSE);
     return(0);
 }
 
 void
 CERT_DestroyName(CERTName *name)
 {
     if (name)
     {
-        PRArenaPool *arena = name->arena;
+        PLArenaPool *arena = name->arena;
         name->rdns = NULL;
         name->arena = NULL;
         if (arena) PORT_FreeArena(arena, PR_FALSE);
     }
 }
 
 SECStatus
 CERT_AddRDN(CERTName *name, CERTRDN *rdn)
 {
     name->rdns = (CERTRDN**) AddToArray(name->arena, (void**) name->rdns, rdn);
     return name->rdns ? SECSuccess : SECFailure;
 }
 
 SECStatus
-CERT_CopyName(PRArenaPool *arena, CERTName *to, const CERTName *from)
+CERT_CopyName(PLArenaPool *arena, CERTName *to, const CERTName *from)
 {
     CERTRDN **rdns, *frdn, *trdn;
     SECStatus rv = SECSuccess;
 
     if (!to || !from) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return SECFailure;
     }
 
     CERT_DestroyName(to);
@@ skipping 276 matching lines @@
         }
           
         avaValue.data = utf8Val;
         avaValue.len = utf8ValLen;
     }
 
     retItem = SECITEM_DupItem(&avaValue);
     PORT_FreeArena(newarena, PR_FALSE);
     return retItem;
 }