Allow NSS to be built with NO_NSPR_10_SUPPORT.

nss/lib/util/quickder.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/. */
 
 /*
     Optimized ASN.1 DER decoder
     
 */
 
 #include "secerr.h"
@@ skipping 315 matching lines @@
     /* XXX also enforce ASN.1 requirement that tags be
        distinct for consecutive optional components */
 
     return rv;
 }
 
 #endif
 
 static SECStatus DecodeItem(void* dest,
                      const SEC_ASN1Template* templateEntry,
-                     SECItem* src, PRArenaPool* arena, PRBool checkTag);
+                     SECItem* src, PLArenaPool* arena, PRBool checkTag);
 
 static SECStatus DecodeSequence(void* dest,
                      const SEC_ASN1Template* templateEntry,
-                     SECItem* src, PRArenaPool* arena)
+                     SECItem* src, PLArenaPool* arena)
 {
     SECStatus rv = SECSuccess;
     SECItem source;
     SECItem sequence;
     const SEC_ASN1Template* sequenceTemplate = &(templateEntry[1]);
     const SEC_ASN1Template* sequenceEntry = NULL;
     unsigned long seqindex = 0;
 
 #ifdef DEBUG
     /* for a sequence, we need to validate the template. */
@@ skipping 31 matching lines @@
            data in the DER that the template doesn't know about */
         PORT_SetError(SEC_ERROR_BAD_DER);
         rv = SECFailure;
     }
 
     return rv;
 }
 
 static SECStatus DecodeInline(void* dest,
                      const SEC_ASN1Template* templateEntry,
-                     SECItem* src, PRArenaPool* arena, PRBool checkTag)
+                     SECItem* src, PLArenaPool* arena, PRBool checkTag)
 {
     const SEC_ASN1Template* inlineTemplate = 
         SEC_ASN1GetSubtemplate (templateEntry, dest, PR_FALSE);
     return DecodeItem((void*)((char*)dest + templateEntry->offset),
                             inlineTemplate, src, arena, checkTag);
 }
 
 static SECStatus DecodePointer(void* dest,
                      const SEC_ASN1Template* templateEntry,
-                     SECItem* src, PRArenaPool* arena, PRBool checkTag)
+                     SECItem* src, PLArenaPool* arena, PRBool checkTag)
 {
     const SEC_ASN1Template* ptrTemplate = 
         SEC_ASN1GetSubtemplate (templateEntry, dest, PR_FALSE);
     void* subdata = PORT_ArenaZAlloc(arena, ptrTemplate->size);
     *(void**)((char*)dest + templateEntry->offset) = subdata;
     if (subdata)
     {
         return DecodeItem(subdata, ptrTemplate, src, arena, checkTag);
     }
     else
     {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
         return SECFailure;
     }
 }
 
 static SECStatus DecodeImplicit(void* dest,
                      const SEC_ASN1Template* templateEntry,
-                     SECItem* src, PRArenaPool* arena)
+                     SECItem* src, PLArenaPool* arena)
 {
     if (templateEntry->kind & SEC_ASN1_POINTER)
     {
         return DecodePointer((void*)((char*)dest ),
                              templateEntry, src, arena, PR_FALSE);
     }
     else
     {
         return DecodeInline((void*)((char*)dest ),
                              templateEntry, src, arena, PR_FALSE);
     }
 }
 
 static SECStatus DecodeChoice(void* dest,
                      const SEC_ASN1Template* templateEntry,
-                     SECItem* src, PRArenaPool* arena)
+                     SECItem* src, PLArenaPool* arena)
 {
     SECStatus rv = SECSuccess;
     SECItem choice;
     const SEC_ASN1Template* choiceTemplate = &(templateEntry[1]);
     const SEC_ASN1Template* choiceEntry = NULL;
     unsigned long choiceindex = 0;
 
     /* XXX for a choice component, we should validate the template to make
        sure the tags are distinct, in debug builds. This hasn't been
        implemented yet */
@@ skipping 28 matching lines @@
     {
         /* there is extra data that isn't listed in the template */
         PORT_SetError(SEC_ERROR_BAD_DER);
         rv = SECFailure;
     }
     return rv;
 }
 
 static SECStatus DecodeGroup(void* dest,
                      const SEC_ASN1Template* templateEntry,
-                     SECItem* src, PRArenaPool* arena)
+                     SECItem* src, PLArenaPool* arena)
 {
     SECStatus rv = SECSuccess;
     SECItem source;
     SECItem group;
     PRUint32 totalEntries = 0;
     PRUint32 entryIndex = 0;
     void** entries = NULL;
 
     const SEC_ASN1Template* subTemplate =
         SEC_ASN1GetSubtemplate (templateEntry, dest, PR_FALSE);
@@ skipping 67 matching lines @@
     } while ( (SECSuccess == rv) && (group.len) );
     /* we should be at the end of the set by now */    
     /* save the entries where requested */
     memcpy(((char*)dest + templateEntry->offset), &entries, sizeof(void**));
 
     return rv;
 }
 
 static SECStatus DecodeExplicit(void* dest,
                      const SEC_ASN1Template* templateEntry,
-                     SECItem* src, PRArenaPool* arena)
+                     SECItem* src, PLArenaPool* arena)
 {
     SECStatus rv = SECSuccess;
     SECItem subItem;
     SECItem constructed = *src;
 
     rv = GetItem(&constructed, &subItem, PR_FALSE);
 
     if (SECSuccess == rv)
     {
         if (templateEntry->kind & SEC_ASN1_POINTER)
         {
             rv = DecodePointer(dest, templateEntry, &subItem, arena, PR_TRUE);
         }
         else
         {
             rv = DecodeInline(dest, templateEntry, &subItem, arena, PR_TRUE);
         }
     }
 
     return rv;
 }
 
 /* new decoder implementation. This is a recursive function */
 
 static SECStatus DecodeItem(void* dest,
                      const SEC_ASN1Template* templateEntry,
-                     SECItem* src, PRArenaPool* arena, PRBool checkTag)
+                     SECItem* src, PLArenaPool* arena, PRBool checkTag)
 {
     SECStatus rv = SECSuccess;
     SECItem temp;
     SECItem mark;
     PRBool pop = PR_FALSE;
     PRBool decode = PR_TRUE;
     PRBool save = PR_FALSE;
     unsigned long kind;
     PRBool match = PR_TRUE;
     PRBool optional = PR_FALSE;
@@ skipping 249 matching lines @@
     if (PR_TRUE == pop)
     {
         /* we don't want to move ahead, so restore the position */
         *src = mark;
     }
     return rv;
 }
 
 /* the function below is the public one */
 
-SECStatus SEC_QuickDERDecodeItem(PRArenaPool* arena, void* dest,
+SECStatus SEC_QuickDERDecodeItem(PLArenaPool* arena, void* dest,
                      const SEC_ASN1Template* templateEntry,
                      const SECItem* src)
 {
     SECStatus rv = SECSuccess;
     SECItem newsrc;
 
     if (!arena || !templateEntry || !src)
     {
         PORT_SetError(SEC_ERROR_INVALID_ARGS);
         rv = SECFailure;
     }
 
     if (SECSuccess == rv)
     {
         newsrc = *src;
         rv = DecodeItem(dest, templateEntry, &newsrc, arena, PR_TRUE);
         if (SECSuccess == rv && newsrc.len)
         {
             rv = SECFailure;
             PORT_SetError(SEC_ERROR_EXTRA_INPUT);
         }
     }
 
     return rv;
 }