Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/certdb/genname.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 "plarena.h"
 #include "seccomon.h"
 #include "secitem.h"
 #include "secoidt.h"
 #include "secasn1.h"
 #include "secder.h"
@@ skipping 138 matching lines @@
         name->l.prev = name->l.next = &name->l;
     }
     return name;
 }
 
 /* Copy content of one General Name to another.
 ** Caller has allocated destination general name.
 ** This function does not change the destinate's GeneralName's list linkage.
 */
 SECStatus
-cert_CopyOneGeneralName(PRArenaPool      *arena, 
+cert_CopyOneGeneralName(PLArenaPool      *arena,
                         CERTGeneralName  *dest, 
                         CERTGeneralName  *src)
 {
     SECStatus rv;
     void *mark = NULL;
 
     PORT_Assert(dest != NULL);
     dest->type = src->type;
 
     mark = PORT_ArenaMark(arena);
@@ skipping 44 matching lines @@
             PZ_DestroyLock(lock);
         } else {
             PZ_Unlock(lock);
         }
     }
     return;
 }
 
 CERTGeneralNameList *
 CERT_CreateGeneralNameList(CERTGeneralName *name) {
-    PRArenaPool *arena;
+    PLArenaPool *arena;
     CERTGeneralNameList *list = NULL;
 
     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     if (arena == NULL) {
         goto done;
     }
     list = PORT_ArenaZNew(arena, CERTGeneralNameList);
     if (!list)
         goto loser;
     if (name != NULL) {
@@ skipping 46 matching lines @@
 
 CERTNameConstraint *
 CERT_GetPrevNameConstraint(CERTNameConstraint *current)
 {
     PRCList *prev;
     prev = current->l.prev;
     return (CERTNameConstraint *) (((char *) prev) - offsetof(CERTNameConstraint, l));
 }
 
 SECItem *
-CERT_EncodeGeneralName(CERTGeneralName *genName, SECItem *dest, PRArenaPool *arena)
+CERT_EncodeGeneralName(CERTGeneralName *genName, SECItem *dest, PLArenaPool *arena)
 {
 
     const SEC_ASN1Template * template;
 
     PORT_Assert(arena);
     if (arena == NULL) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
     }
     /* TODO: mark arena */
@@ skipping 36 matching lines @@
         goto loser;
     }
     /* TODO: unmark arena */
     return dest;
 loser:
     /* TODO: release arena back to mark */
     return NULL;
 }
 
 SECItem **
-cert_EncodeGeneralNames(PRArenaPool *arena, CERTGeneralName *names)
+cert_EncodeGeneralNames(PLArenaPool *arena, CERTGeneralName *names)
 {
     CERTGeneralName  *current_name;
     SECItem          **items = NULL;
     int              count = 0;
     int              i;
     PRCList          *head;
 
     PORT_Assert(arena);
     /* TODO: mark arena */
     current_name = names;
@@ skipping 19 matching lines @@
     }
     items[i] = NULL;
     /* TODO: unmark arena */
     return items;
 loser:
     /* TODO: release arena to mark */
     return NULL;
 }
 
 CERTGeneralName *
-CERT_DecodeGeneralName(PRArenaPool      *reqArena,
+CERT_DecodeGeneralName(PLArenaPool      *reqArena,
                        SECItem          *encodedName,
                        CERTGeneralName  *genName)
 {
     const SEC_ASN1Template *         template;
     CERTGeneralNameType              genNameType;
     SECStatus                        rv = SECSuccess;
     SECItem* newEncodedName;
 
     if (!reqArena) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
@@ skipping 41 matching lines @@
     }
 
     /* TODO: unmark arena */
     return genName;
 loser:
     /* TODO: release arena to mark */
     return NULL;
 }
 
 CERTGeneralName *
-cert_DecodeGeneralNames (PRArenaPool  *arena,
+cert_DecodeGeneralNames (PLArenaPool  *arena,
                          SECItem      **encodedGenName)
 {
     PRCList                           *head = NULL;
     PRCList                           *tail = NULL;
     CERTGeneralName                   *currentName = NULL;
 
     PORT_Assert(arena);
     if (!encodedGenName || !arena) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
@@ skipping 38 matching lines @@
         next = CERT_GetNextGeneralName(name);
         PORT_Free(name);
         name = next;
     } while (name != first);
     return SECSuccess;
 }
 
 static SECItem *
 cert_EncodeNameConstraint(CERTNameConstraint  *constraint, 
                          SECItem             *dest,
-                         PRArenaPool         *arena)
+                         PLArenaPool         *arena)
 {
     PORT_Assert(arena);
     if (dest == NULL) {
         dest = PORT_ArenaZNew(arena, SECItem);
         if (dest == NULL) {
             return NULL;
         }
     }
     CERT_EncodeGeneralName(&(constraint->name), &(constraint->DERName), arena);
     
     dest = SEC_ASN1EncodeItem (arena, dest, constraint,
                                CERTNameConstraintTemplate);
     return dest;
 } 
 
 SECStatus 
 cert_EncodeNameConstraintSubTree(CERTNameConstraint  *constraints,
-                                 PRArenaPool         *arena,
+                                 PLArenaPool         *arena,
                                  SECItem             ***dest,
                                  PRBool              permited)
 {
     CERTNameConstraint  *current_constraint = constraints;
     SECItem             **items = NULL;
     int                 count = 0;
     int                 i;
     PRCList             *head;
 
     PORT_Assert(arena);
@@ skipping 25 matching lines @@
     }
     /* TODO: unmark arena */
     return SECSuccess;
 loser:
     /* TODO: release arena to mark */
     return SECFailure;
 }
 
 SECStatus 
 cert_EncodeNameConstraints(CERTNameConstraints  *constraints,
-                           PRArenaPool          *arena,
+                           PLArenaPool          *arena,
                            SECItem              *dest)
 {
     SECStatus    rv = SECSuccess;
 
     PORT_Assert(arena);
     /* TODO: mark arena */
     if (constraints->permited != NULL) {
         rv = cert_EncodeNameConstraintSubTree(constraints->permited, arena,
                                               &constraints->DERPermited, 
                                               PR_TRUE);
@@ skipping 16 matching lines @@
     }
     /* TODO: unmark arena */
     return SECSuccess;
 loser:
     /* TODO: release arena to mark */
     return SECFailure;
 }
 
 
 CERTNameConstraint *
-cert_DecodeNameConstraint(PRArenaPool       *reqArena,
+cert_DecodeNameConstraint(PLArenaPool       *reqArena,
                           SECItem           *encodedConstraint)
 {
     CERTNameConstraint     *constraint;
     SECStatus              rv = SECSuccess;
     CERTGeneralName        *temp;
     SECItem*               newEncodedConstraint;
 
     if (!reqArena) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
@@ skipping 24 matching lines @@
      */
     constraint->name.l.prev = constraint->name.l.next = &(constraint->name.l);
     /* TODO: unmark arena */
     return constraint;
 loser:
     /* TODO: release arena back to mark */
     return NULL;
 }
 
 CERTNameConstraint *
-cert_DecodeNameConstraintSubTree(PRArenaPool   *arena,
+cert_DecodeNameConstraintSubTree(PLArenaPool   *arena,
                                  SECItem       **subTree,
                                  PRBool        permited)
 {
     CERTNameConstraint   *current = NULL;
     CERTNameConstraint   *first = NULL;
     CERTNameConstraint   *last = NULL;
     int                  i = 0;
 
     PORT_Assert(arena);
     /* TODO: mark arena */
@@ skipping 12 matching lines @@
     }
     first->l.prev = &(current->l);
     /* TODO: unmark arena */
     return first;
 loser:
     /* TODO: release arena back to mark */
     return NULL;
 }
 
 CERTNameConstraints *
-cert_DecodeNameConstraints(PRArenaPool   *reqArena,
+cert_DecodeNameConstraints(PLArenaPool   *reqArena,
                            const SECItem *encodedConstraints)
 {
     CERTNameConstraints   *constraints;
     SECStatus             rv;
     SECItem*              newEncodedConstraints;
 
     if (!reqArena) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
     }
@@ skipping 45 matching lines @@
 ** If the source chain has more than one member, and the destination chain 
 ** has only one member, then this function allocates new structs for all but 
 ** the first copy from the arena and links them into the destination list.  
 ** If the destination struct is part of a list with more than one member,
 ** then this function traverses both the source and destination lists,
 ** copying each source struct to the corresponding dest struct.
 ** In that case, the destination list MUST contain at least as many 
 ** structs as the source list or some dest entries will be overwritten.
 */
 SECStatus
-CERT_CopyGeneralName(PRArenaPool      *arena, 
+CERT_CopyGeneralName(PLArenaPool      *arena,
                      CERTGeneralName  *dest, 
                      CERTGeneralName  *src)
 {
     SECStatus rv;
     CERTGeneralName *destHead = dest;
     CERTGeneralName *srcHead = src;
 
     PORT_Assert(dest != NULL);
     if (!dest) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
@@ skipping 36 matching lines @@
     if (list != NULL) {
         PZ_Lock(list->lock);
         list->refCount++;
         PZ_Unlock(list->lock);
     }
     return list;
 }
 
 /* Allocate space and copy CERTNameConstraint from src to dest */
 CERTNameConstraint *
-CERT_CopyNameConstraint(PRArenaPool         *arena, 
+CERT_CopyNameConstraint(PLArenaPool         *arena,
                         CERTNameConstraint  *dest, 
                         CERTNameConstraint  *src)
 {
     SECStatus  rv;
     
     /* TODO: mark arena */
     if (dest == NULL) {
         dest = PORT_ArenaZNew(arena, CERTNameConstraint);
         if (!dest)
             goto loser;
@@ skipping 86 matching lines @@
     constraint->l.next = constraint->l.prev = &constraint->l;
     list = cert_CombineConstraintsLists(list, constraint);
     return list;
 }
 
 
 SECStatus
 CERT_GetNameConstraintByType (CERTNameConstraint *constraints,
                               CERTGeneralNameType type, 
                               CERTNameConstraint **returnList,
-                              PRArenaPool *arena)
+                              PLArenaPool *arena)
 {
     CERTNameConstraint *current = NULL;
     void               *mark = NULL;
 
     *returnList = NULL;
     if (!constraints)
         return SECSuccess;
 
     mark = PORT_ArenaMark(arena);
 
@@ skipping 119 matching lines @@
 
 loser:
     /* TODO: release arena back to mark */
     return SECFailure;
 }
 
 /* Extract all names except Subject Common Name from a cert 
 ** in preparation for a name constraints test.
 */
 CERTGeneralName *
-CERT_GetCertificateNames(CERTCertificate *cert, PRArenaPool *arena)
+CERT_GetCertificateNames(CERTCertificate *cert, PLArenaPool *arena)
 {
     return CERT_GetConstrainedCertificateNames(cert, arena, PR_FALSE);
 }
 
 /* This function is called by CERT_VerifyCertChain to extract all
 ** names from a cert in preparation for a name constraints test.
 */
 CERTGeneralName *
 CERT_GetConstrainedCertificateNames(const CERTCertificate *cert,
-                                    PRArenaPool *arena,
+                                    PLArenaPool *arena,
                                     PRBool includeSubjectCommonName)
 {
     CERTGeneralName  *DN;
     CERTGeneralName  *SAN;
     PRUint32         numDNSNames = 0;
     SECStatus        rv;
 
     if (!arena) {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         return NULL;
@@ skipping 439 matching lines @@
     if (rv == SECFailure) {
         PORT_ArenaRelease(arena, mark);
     } else {
         PORT_ArenaUnmark(arena, mark);
     }
     return rv;
 }
 
 /* Extract the name constraints extension from the CA cert. */
 SECStatus
-CERT_FindNameConstraintsExten(PRArenaPool      *arena,
+CERT_FindNameConstraintsExten(PLArenaPool      *arena,
                               CERTCertificate  *cert,
                               CERTNameConstraints **constraints)
 {
     SECStatus            rv = SECSuccess;
     SECItem              constraintsExtension;
     void                *mark = NULL;
     
     *constraints = NULL;
 
     rv = CERT_FindCertExtension(cert, SEC_OID_X509_NAME_CONSTRAINTS, 
@@ skipping 19 matching lines @@
         PORT_ArenaUnmark(arena, mark);
     }
 
     return rv;
 }
 
 /* Verify name against all the constraints relevant to that type of
 ** the name.
 */
 SECStatus
-CERT_CheckNameSpace(PRArenaPool          *arena,
+CERT_CheckNameSpace(PLArenaPool          *arena,
                     const CERTNameConstraints *constraints,
                     const CERTGeneralName     *currentName)
 {
     CERTNameConstraint  *matchingConstraints;
     SECStatus            rv = SECSuccess;
     
     if (constraints->excluded != NULL) {
         rv = CERT_GetNameConstraintByType(constraints->excluded, 
                                           currentName->type, 
                                           &matchingConstraints, arena);
@@ skipping 28 matching lines @@
 ** Test each and every name in namesList against all the constraints
 ** relevant to that type of name.
 ** Returns NULL in pBadCert for success, if all names are acceptable.
 ** If some name is not acceptable, returns a pointer to the cert that
 ** contained that name.
 */
 SECStatus
 CERT_CompareNameSpace(CERTCertificate  *cert,
                       CERTGeneralName  *namesList,
                       CERTCertificate **certsList,
-                      PRArenaPool      *reqArena,
+                      PLArenaPool      *reqArena,
                       CERTCertificate **pBadCert)
 {
     SECStatus            rv = SECSuccess;
     CERTNameConstraints  *constraints;
     CERTGeneralName      *currentName;
     int                  count = 0;
     CERTCertificate      *badCert = NULL;
 
     /* If no names to check, then no names can be bad. */
     if (!namesList)
@@ skipping 120 matching lines @@
 #endif
 
 #if 0
 /* This function is not exported from NSS shared libraries, and is not
 ** used inside of NSS.
 ** XXX it doesn't check for failed allocations. :-(
 */
 void *
 CERT_GetGeneralNameFromListByType(CERTGeneralNameList *list,
                                   CERTGeneralNameType type,
-                                  PRArenaPool *arena)
+                                  PLArenaPool *arena)
 {
     CERTName *name = NULL; 
     SECItem *item = NULL;
     OtherName *other = NULL;
     OtherName *tmpOther = NULL;
     void *data;
 
     PZ_Lock(list->lock);
     data = CERT_GetGeneralNameByType(list->name, type, PR_FALSE);
     if (data != NULL) {
@@ skipping 84 matching lines @@
             break;
         }
         list->name = cert_CombineNamesLists(list->name, name);
         list->len++;
 done:
         PZ_Unlock(list->lock);
     }
     return;
 }
 #endif