Update NSS to 3.21 RTM and NSPR to 4.11 RTM

nss/lib/util/secasn1d.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/. */
 
 /*
  * Support for DEcoding ASN.1 data based on BER/DER (Basic/Distinguished
  * Encoding Rules).
  */
 
 /* #define DEBUG_ASN1D_STATES 1 */
@@ skipping 967 matching lines @@
     *remaining -= consumed;
     return PR_TRUE;
 }
 
 static void
 sec_asn1d_prepare_for_contents (sec_asn1d_state *state)
 {
     SECItem *item;
     PLArenaPool *poolp;
     unsigned long alloc_len;
+    sec_asn1d_state *parent;
 
 #ifdef DEBUG_ASN1D_STATES
     {
         printf("Found Length %d %s\n", state->contents_length,
                state->indefinite ? "indefinite" : "");
     }
 #endif
 
     /**
      * The maximum length for a child element should be constrained to the
@@ skipping 15 matching lines @@
      * elements that may have been read).
      *
      * It's slightly complicated by the need to account both for integer
      * underflow and overflow, as well as ensure that for indefinite length
      * encodings, there's also enough space for the End-of-Contents (EOC)
      * octets (Tag = 0x00, Length = 0x00, or two bytes).
      */
 
     /* Determine the maximum length available for this element by finding the
      * first definite length ancestor, if any. */
-    sec_asn1d_state *parent = sec_asn1d_get_enclosing_construct(state);
+    parent = sec_asn1d_get_enclosing_construct(state);
     while (parent && parent->indefinite) {
         parent = sec_asn1d_get_enclosing_construct(parent);
     }
     /* If parent is null, state is either the outermost state / at the top of
      * the stack, or the outermost state uses indefinite length encoding. In
      * these cases, there's nothing external to constrain this element, so
      * there's nothing to check. */
     if (parent) {
         unsigned long remaining = parent->pending;
         parent = state;
@@ skipping 748 matching lines @@
         if (child_consumed > state->pending) {
             PORT_SetError (SEC_ERROR_BAD_DER);
             state->top->status = decodeError;
             return;
         }
 
         state->pending -= child_consumed;
         if (state->pending == 0)
             done = PR_TRUE;
     } else {
+        PRBool preallocatedString;
+        sec_asn1d_state *temp_state;
         PORT_Assert (state->indefinite);
 
         item = (SECItem *)(child->dest);
 
         /**
          * At this point, there's three states at play:
          *   child: The element that was just parsed
          *   state: The currently processed element
          *   'parent' (aka state->parent): The enclosing construct
          *      of state, or NULL if this is the top-most element.
@@ skipping 52 matching lines @@
          * any type, then the enclosing construct is either an any type (#3/#4)
          * or some other type (#5). Since this is BER, this nesting relationship
          * between 'state' and 'parent' may go through several levels of
          * constructed encoding, so continue walking the ancestor chain until a
          * clear determination can be made.
          *
          * The variable preallocatedString is used to indicate Case #1/#3,
          * indicating an in-place copy has already occurred, and Cases #2, #4,
          * and #5 all have the same behaviour of adding a new substring.
          */
-        PRBool preallocatedString = PR_FALSE;
-        sec_asn1d_state *temp_state = state;
+        preallocatedString = PR_FALSE;
+        temp_state = state;
         while (temp_state && item == temp_state->dest && temp_state->indefinite) {
             sec_asn1d_state *parent = sec_asn1d_get_enclosing_construct(temp_state);
             if (!parent || parent->underlying_kind != temp_state->underlying_kind) {
                 /* Case #5 - Either this is a top-level construct or it is part
                  * of some other element (e.g. a SEQUENCE), in which case, a
                  * new item should be allocated. */
                 break;
             }
             if (!parent->indefinite) {
                 /* Cases #1 / #3 - A definite length ancestor exists, for which
@@ skipping 1515 matching lines @@
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_EnumeratedTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_PointerToEnumeratedTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_SequenceOfAnyTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_SequenceOfObjectIDTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_SkipTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_UniversalStringTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_PrintableStringTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_T61StringTemplate)
 SEC_ASN1_CHOOSER_IMPLEMENT(SEC_PointerToGeneralizedTimeTemplate)