Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3443 insertions, 0 deletions

diff --git a/security/nss/lib/util/secasn1d.c b/security/nss/lib/util/secasn1d.c
new file mode 100644
index 0000000000..e503c6b1ca
--- /dev/null
+++ b/security/nss/lib/util/secasn1d.c
@@ -0,0 +1,3443 @@
+/* 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 */
+
+#ifdef DEBUG_ASN1D_STATES
+#include <stdio.h>
+#define PR_Assert sec_asn1d_Assert
+#endif
+
+#include <limits.h>
+
+#include "secasn1.h"
+#include "secerr.h"
+
+typedef enum {
+    beforeIdentifier,
+    duringIdentifier,
+    afterIdentifier,
+    beforeLength,
+    duringLength,
+    afterLength,
+    beforeBitString,
+    duringBitString,
+    duringConstructedString,
+    duringGroup,
+    duringLeaf,
+    duringSaveEncoding,
+    duringSequence,
+    afterConstructedString,
+    afterGroup,
+    afterExplicit,
+    afterImplicit,
+    afterInline,
+    afterPointer,
+    afterSaveEncoding,
+    beforeEndOfContents,
+    duringEndOfContents,
+    afterEndOfContents,
+    beforeChoice,
+    duringChoice,
+    afterChoice,
+    notInUse
+} sec_asn1d_parse_place;
+
+#ifdef DEBUG_ASN1D_STATES
+static const char *const place_names[] = {
+    "beforeIdentifier",
+    "duringIdentifier",
+    "afterIdentifier",
+    "beforeLength",
+    "duringLength",
+    "afterLength",
+    "beforeBitString",
+    "duringBitString",
+    "duringConstructedString",
+    "duringGroup",
+    "duringLeaf",
+    "duringSaveEncoding",
+    "duringSequence",
+    "afterConstructedString",
+    "afterGroup",
+    "afterExplicit",
+    "afterImplicit",
+    "afterInline",
+    "afterPointer",
+    "afterSaveEncoding",
+    "beforeEndOfContents",
+    "duringEndOfContents",
+    "afterEndOfContents",
+    "beforeChoice",
+    "duringChoice",
+    "afterChoice",
+    "notInUse"
+};
+
+static const char *const class_names[] = {
+    "UNIVERSAL",
+    "APPLICATION",
+    "CONTEXT_SPECIFIC",
+    "PRIVATE"
+};
+
+static const char *const method_names[] = { "PRIMITIVE", "CONSTRUCTED" };
+
+static const char *const type_names[] = {
+    "END_OF_CONTENTS",
+    "BOOLEAN",
+    "INTEGER",
+    "BIT_STRING",
+    "OCTET_STRING",
+    "NULL",
+    "OBJECT_ID",
+    "OBJECT_DESCRIPTOR",
+    "(type 08)",
+    "REAL",
+    "ENUMERATED",
+    "EMBEDDED",
+    "UTF8_STRING",
+    "(type 0d)",
+    "(type 0e)",
+    "(type 0f)",
+    "SEQUENCE",
+    "SET",
+    "NUMERIC_STRING",
+    "PRINTABLE_STRING",
+    "T61_STRING",
+    "VIDEOTEXT_STRING",
+    "IA5_STRING",
+    "UTC_TIME",
+    "GENERALIZED_TIME",
+    "GRAPHIC_STRING",
+    "VISIBLE_STRING",
+    "GENERAL_STRING",
+    "UNIVERSAL_STRING",
+    "(type 1d)",
+    "BMP_STRING",
+    "HIGH_TAG_VALUE"
+};
+
+static const char *const flag_names[] = {
+    /* flags, right to left */
+    "OPTIONAL",
+    "EXPLICIT",
+    "ANY",
+    "INLINE",
+    "POINTER",
+    "GROUP",
+    "DYNAMIC",
+    "SKIP",
+    "INNER",
+    "SAVE",
+    "", /* decoder ignores "MAY_STREAM", */
+    "SKIP_REST",
+    "CHOICE",
+    "NO_STREAM",
+    "DEBUG_BREAK",
+    "unknown 08",
+    "unknown 10",
+    "unknown 20",
+    "unknown 40",
+    "unknown 80"
+};
+
+static int /* bool */
+formatKind(unsigned long kind, char *buf, int space_in_buffer)
+{
+    int i;
+    unsigned long k = kind & SEC_ASN1_TAGNUM_MASK;
+    unsigned long notag = kind & (SEC_ASN1_CHOICE | SEC_ASN1_POINTER |
+                                  SEC_ASN1_INLINE | SEC_ASN1_ANY | SEC_ASN1_SAVE);
+
+    buf[0] = 0;
+    if ((kind & SEC_ASN1_CLASS_MASK) != SEC_ASN1_UNIVERSAL) {
+        space_in_buffer -= snprintf(buf, space_in_buffer, " %s", class_names[(kind & SEC_ASN1_CLASS_MASK) >> 6]);
+        buf += strlen(buf);
+    }
+    if (kind & SEC_ASN1_METHOD_MASK) {
+        space_in_buffer -= snprintf(buf, space_in_buffer, " %s", method_names[1]);
+        buf += strlen(buf);
+    }
+    if ((kind & SEC_ASN1_CLASS_MASK) == SEC_ASN1_UNIVERSAL) {
+        if (k || !notag) {
+            space_in_buffer -= snprintf(buf, space_in_buffer, " %s", type_names[k]);
+            if ((k == SEC_ASN1_SET || k == SEC_ASN1_SEQUENCE) &&
+                (kind & SEC_ASN1_GROUP)) {
+                buf += strlen(buf);
+                space_in_buffer -= snprintf(buf, space_in_buffer, "_OF");
+            }
+        }
+    } else {
+        space_in_buffer -= snprintf(buf, space_in_buffer, " [%lu]", k);
+    }
+    buf += strlen(buf);
+
+    for (k = kind >> 8, i = 0; k; k >>= 1, ++i) {
+        if (k & 1) {
+            space_in_buffer -= snprintf(buf, space_in_buffer, " %s", flag_names[i]);
+            buf += strlen(buf);
+        }
+    }
+    return notag != 0;
+}
+
+#endif /* DEBUG_ASN1D_STATES */
+
+typedef enum {
+    allDone,
+    decodeError,
+    keepGoing,
+    needBytes
+} sec_asn1d_parse_status;
+
+struct subitem {
+    const void *data;
+    unsigned long len; /* only used for substrings */
+    struct subitem *next;
+};
+
+typedef struct sec_asn1d_state_struct {
+    SEC_ASN1DecoderContext *top;
+    const SEC_ASN1Template *theTemplate;
+    void *dest;
+
+    void *our_mark; /* free on completion */
+
+    struct sec_asn1d_state_struct *parent; /* aka prev */
+    struct sec_asn1d_state_struct *child;  /* aka next */
+
+    sec_asn1d_parse_place place;
+
+    /*
+     * XXX explain the next fields as clearly as possible...
+     */
+    unsigned char found_tag_modifiers;
+    unsigned char expect_tag_modifiers;
+    unsigned long check_tag_mask;
+    unsigned long found_tag_number;
+    unsigned long expect_tag_number;
+    unsigned long underlying_kind;
+
+    unsigned long contents_length;
+    unsigned long pending;
+    unsigned long consumed;
+
+    int depth;
+
+    /*
+     * Bit strings have their length adjusted -- the first octet of the
+     * contents contains a value between 0 and 7 which says how many bits
+     * at the end of the octets are not actually part of the bit string;
+     * when parsing bit strings we put that value here because we need it
+     * later, for adjustment of the length (when the whole string is done).
+     */
+    unsigned int bit_string_unused_bits;
+
+    /*
+     * The following are used for indefinite-length constructed strings.
+     */
+    struct subitem *subitems_head;
+    struct subitem *subitems_tail;
+
+    PRPackedBool
+        allocate,      /* when true, need to allocate the destination */
+        endofcontents, /* this state ended up parsing its parent's end-of-contents octets */
+        explicit,      /* we are handling an explicit header */
+        indefinite,    /* the current item has indefinite-length encoding */
+        missing,       /* an optional field that was not present */
+        optional,      /* the template says this field may be omitted */
+        substring;     /* this is a substring of a constructed string */
+
+} sec_asn1d_state;
+
+#define IS_HIGH_TAG_NUMBER(n) ((n) == SEC_ASN1_HIGH_TAG_NUMBER)
+#define LAST_TAG_NUMBER_BYTE(b) (((b)&0x80) == 0)
+#define TAG_NUMBER_BITS 7
+#define TAG_NUMBER_MASK 0x7f
+
+#define LENGTH_IS_SHORT_FORM(b) (((b)&0x80) == 0)
+#define LONG_FORM_LENGTH(b) ((b)&0x7f)
+
+#define HIGH_BITS(field, cnt) ((field) >> ((sizeof(field) * 8) - (cnt)))
+
+/*
+ * An "outsider" will have an opaque pointer to this, created by calling
+ * SEC_ASN1DecoderStart().  It will be passed back in to all subsequent
+ * calls to SEC_ASN1DecoderUpdate(), and when done it is passed to
+ * SEC_ASN1DecoderFinish().
+ */
+struct sec_DecoderContext_struct {
+    PLArenaPool *our_pool;     /* for our internal allocs */
+    PLArenaPool *their_pool;   /* for destination structure allocs */
+#ifdef SEC_ASN1D_FREE_ON_ERROR /*                                 \
+                                * XXX see comment below (by same  \
+                                * ifdef) that explains why this   \
+                                * does not work (need more smarts \
+                                * in order to free back to mark)  \
+                                */
+    /*
+     * XXX how to make their_mark work in the case where they do NOT
+     * give us a pool pointer?
+     */
+    void *their_mark; /* free on error */
+#endif
+
+    sec_asn1d_state *current;
+    sec_asn1d_parse_status status;
+
+    /* The maximum size the caller is willing to allow a single element
+     * to be before returning an error.
+     *
+     * In the case of an indefinite length element, this is the sum total
+     * of all child elements.
+     *
+     * In the case of a definite length element, this represents the maximum
+     * size of the top-level element.
+     */
+    unsigned long max_element_size;
+
+    SEC_ASN1NotifyProc notify_proc; /* call before/after handling field */
+    void *notify_arg;               /* argument to notify_proc */
+    PRBool during_notify;           /* true during call to notify_proc */
+
+    SEC_ASN1WriteProc filter_proc; /* pass field bytes to this  */
+    void *filter_arg;              /* argument to that function */
+    PRBool filter_only;            /* do not allocate/store fields */
+};
+
+/*
+ * XXX this is a fairly generic function that may belong elsewhere
+ */
+static void *
+sec_asn1d_alloc(PLArenaPool *poolp, unsigned long len)
+{
+    void *thing;
+
+    if (poolp != NULL) {
+        /*
+         * Allocate from the pool.
+         */
+        thing = PORT_ArenaAlloc(poolp, len);
+    } else {
+        /*
+         * Allocate generically.
+         */
+        thing = PORT_Alloc(len);
+    }
+
+    return thing;
+}
+
+/*
+ * XXX this is a fairly generic function that may belong elsewhere
+ */
+static void *
+sec_asn1d_zalloc(PLArenaPool *poolp, unsigned long len)
+{
+    void *thing;
+
+    thing = sec_asn1d_alloc(poolp, len);
+    if (thing != NULL)
+        PORT_Memset(thing, 0, len);
+    return thing;
+}
+
+static sec_asn1d_state *
+sec_asn1d_push_state(SEC_ASN1DecoderContext *cx,
+                     const SEC_ASN1Template *theTemplate,
+                     void *dest, PRBool new_depth)
+{
+    sec_asn1d_state *state, *new_state;
+
+    state = cx->current;
+
+    PORT_Assert(state == NULL || state->child == NULL);
+
+    if (state != NULL) {
+        PORT_Assert(state->our_mark == NULL);
+        state->our_mark = PORT_ArenaMark(cx->our_pool);
+    }
+
+    if (theTemplate == NULL) {
+        PORT_SetError(SEC_ERROR_BAD_TEMPLATE);
+        goto loser;
+    }
+
+    new_state = (sec_asn1d_state *)sec_asn1d_zalloc(cx->our_pool,
+                                                    sizeof(*new_state));
+    if (new_state == NULL) {
+        goto loser;
+    }
+
+    new_state->top = cx;
+    new_state->parent = state;
+    new_state->theTemplate = theTemplate;
+    new_state->place = notInUse;
+    if (dest != NULL)
+        new_state->dest = (char *)dest + theTemplate->offset;
+
+    if (state != NULL) {
+        new_state->depth = state->depth;
+        if (new_depth) {
+            if (++new_state->depth > SEC_ASN1D_MAX_DEPTH) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                goto loser;
+            }
+        }
+        state->child = new_state;
+    }
+
+    cx->current = new_state;
+    return new_state;
+
+loser:
+    cx->status = decodeError;
+    if (state != NULL) {
+        PORT_ArenaRelease(cx->our_pool, state->our_mark);
+        state->our_mark = NULL;
+    }
+    return NULL;
+}
+
+static void
+sec_asn1d_scrub_state(sec_asn1d_state *state)
+{
+    /*
+     * Some default "scrubbing".
+     * XXX right set of initializations?
+     */
+    state->place = beforeIdentifier;
+    state->endofcontents = PR_FALSE;
+    state->indefinite = PR_FALSE;
+    state->missing = PR_FALSE;
+    PORT_Assert(state->consumed == 0);
+}
+
+static void
+sec_asn1d_notify_before(SEC_ASN1DecoderContext *cx, void *dest, int depth)
+{
+    if (cx->notify_proc == NULL)
+        return;
+
+    cx->during_notify = PR_TRUE;
+    (*cx->notify_proc)(cx->notify_arg, PR_TRUE, dest, depth);
+    cx->during_notify = PR_FALSE;
+}
+
+static void
+sec_asn1d_notify_after(SEC_ASN1DecoderContext *cx, void *dest, int depth)
+{
+    if (cx->notify_proc == NULL)
+        return;
+
+    cx->during_notify = PR_TRUE;
+    (*cx->notify_proc)(cx->notify_arg, PR_FALSE, dest, depth);
+    cx->during_notify = PR_FALSE;
+}
+
+static sec_asn1d_state *
+sec_asn1d_init_state_based_on_template(sec_asn1d_state *state)
+{
+    PRBool explicit, optional, universal;
+    unsigned char expect_tag_modifiers;
+    unsigned long encode_kind, under_kind;
+    unsigned long check_tag_mask, expect_tag_number;
+
+    /* XXX Check that both of these tests are really needed/appropriate. */
+    if (state == NULL || state->top->status == decodeError)
+        return state;
+
+    encode_kind = state->theTemplate->kind;
+
+    if (encode_kind & SEC_ASN1_SAVE) {
+        /*
+         * This is a "magic" field that saves away all bytes, allowing
+         * the immediately following field to still be decoded from this
+         * same spot -- sort of a fork.
+         */
+        /* check that there are no extraneous bits */
+        PORT_Assert(encode_kind == SEC_ASN1_SAVE);
+        if (state->top->filter_only) {
+            /*
+             * If we are not storing, then we do not do the SAVE field
+             * at all.  Just move ahead to the "real" field instead,
+             * doing the appropriate notify calls before and after.
+             */
+            sec_asn1d_notify_after(state->top, state->dest, state->depth);
+            /*
+             * Since we are not storing, allow for our current dest value
+             * to be NULL.  (This might not actually occur, but right now I
+             * cannot convince myself one way or the other.)  If it is NULL,
+             * assume that our parent dest can help us out.
+             */
+            if (state->dest == NULL)
+                state->dest = state->parent->dest;
+            else
+                state->dest = (char *)state->dest - state->theTemplate->offset;
+            state->theTemplate++;
+            if (state->dest != NULL)
+                state->dest = (char *)state->dest + state->theTemplate->offset;
+            sec_asn1d_notify_before(state->top, state->dest, state->depth);
+            encode_kind = state->theTemplate->kind;
+            PORT_Assert((encode_kind & SEC_ASN1_SAVE) == 0);
+        } else {
+            sec_asn1d_scrub_state(state);
+            state->place = duringSaveEncoding;
+            state = sec_asn1d_push_state(state->top, SEC_AnyTemplate,
+                                         state->dest, PR_FALSE);
+            if (state != NULL)
+                state = sec_asn1d_init_state_based_on_template(state);
+            return state;
+        }
+    }
+
+    universal = ((encode_kind & SEC_ASN1_CLASS_MASK) == SEC_ASN1_UNIVERSAL)
+                    ? PR_TRUE
+                    : PR_FALSE;
+
+    explicit = (encode_kind & SEC_ASN1_EXPLICIT) ? PR_TRUE : PR_FALSE;
+    encode_kind &= ~SEC_ASN1_EXPLICIT;
+
+    optional = (encode_kind & SEC_ASN1_OPTIONAL) ? PR_TRUE : PR_FALSE;
+    encode_kind &= ~SEC_ASN1_OPTIONAL;
+
+    PORT_Assert(!(explicit && universal)); /* bad templates */
+
+    encode_kind &= ~SEC_ASN1_DYNAMIC;
+    encode_kind &= ~SEC_ASN1_MAY_STREAM;
+
+    if (encode_kind & SEC_ASN1_CHOICE) {
+#if 0 /* XXX remove? */
+      sec_asn1d_state *child = sec_asn1d_push_state(state->top, state->theTemplate, state->dest, PR_FALSE);
+      if ((sec_asn1d_state *)NULL == child) {
+        return (sec_asn1d_state *)NULL;
+      }
+
+      child->allocate = state->allocate;
+      child->place = beforeChoice;
+      return child;
+#else
+        state->place = beforeChoice;
+        return state;
+#endif
+    }
+
+    if ((encode_kind & (SEC_ASN1_POINTER | SEC_ASN1_INLINE)) || (!universal && !explicit)) {
+        const SEC_ASN1Template *subt;
+        void *dest;
+        PRBool child_allocate;
+
+        PORT_Assert((encode_kind & (SEC_ASN1_ANY | SEC_ASN1_SKIP)) == 0);
+
+        sec_asn1d_scrub_state(state);
+        child_allocate = PR_FALSE;
+
+        if (encode_kind & SEC_ASN1_POINTER) {
+            /*
+             * A POINTER means we need to allocate the destination for
+             * this field.  But, since it may also be an optional field,
+             * we defer the allocation until later; we just record that
+             * it needs to be done.
+             *
+             * There are two possible scenarios here -- one is just a
+             * plain POINTER (kind of like INLINE, except with allocation)
+             * and the other is an implicitly-tagged POINTER.  We don't
+             * need to do anything special here for the two cases, but
+             * since the template definition can be tricky, we do check
+             * that there are no extraneous bits set in encode_kind.
+             *
+             * XXX The same conditions which assert should set an error.
+             */
+            if (universal) {
+                /*
+                 * "universal" means this entry is a standalone POINTER;
+                 * there should be no other bits set in encode_kind.
+                 */
+                PORT_Assert(encode_kind == SEC_ASN1_POINTER);
+            } else {
+                /*
+                 * If we get here we have an implicitly-tagged field
+                 * that needs to be put into a POINTER.  The subtemplate
+                 * will determine how to decode the field, but encode_kind
+                 * describes the (implicit) tag we are looking for.
+                 * The non-tag bits of encode_kind will be ignored by
+                 * the code below; none of them should be set, however,
+                 * except for the POINTER bit itself -- so check that.
+                 */
+                PORT_Assert((encode_kind & ~SEC_ASN1_TAG_MASK) == SEC_ASN1_POINTER);
+            }
+            if (!state->top->filter_only)
+                child_allocate = PR_TRUE;
+            dest = NULL;
+            state->place = afterPointer;
+        } else {
+            dest = state->dest;
+            if (encode_kind & SEC_ASN1_INLINE) {
+                /* check that there are no extraneous bits */
+                PORT_Assert(encode_kind == SEC_ASN1_INLINE && !optional);
+                state->place = afterInline;
+            } else {
+                state->place = afterImplicit;
+            }
+        }
+
+        state->optional = optional;
+        subt = SEC_ASN1GetSubtemplate(state->theTemplate, state->dest, PR_FALSE);
+        state = sec_asn1d_push_state(state->top, subt, dest, PR_FALSE);
+        if (state == NULL)
+            return NULL;
+
+        state->allocate = child_allocate;
+
+        if (universal) {
+            state = sec_asn1d_init_state_based_on_template(state);
+            if (state != NULL) {
+                /*
+                 * If this field is optional, we need to record that on
+                 * the pushed child so it won't fail if the field isn't
+                 * found.  I can't think of a way that this new state
+                 * could already have optional set (which we would wipe
+                 * out below if our local optional is not set) -- but
+                 * just to be sure, assert that it isn't set.
+                 */
+                PORT_Assert(!state->optional);
+                state->optional = optional;
+            }
+            return state;
+        }
+
+        under_kind = state->theTemplate->kind;
+        under_kind &= ~SEC_ASN1_MAY_STREAM;
+    } else if (explicit) {
+        /*
+         * For explicit, we only need to match the encoding tag next,
+         * then we will push another state to handle the entire inner
+         * part.  In this case, there is no underlying kind which plays
+         * any part in the determination of the outer, explicit tag.
+         * So we just set under_kind to 0, which is not a valid tag,
+         * and the rest of the tag matching stuff should be okay.
+         */
+        under_kind = 0;
+    } else {
+        /*
+         * Nothing special; the underlying kind and the given encoding
+         * information are the same.
+         */
+        under_kind = encode_kind;
+    }
+
+    /* XXX is this the right set of bits to test here? */
+    PORT_Assert((under_kind & (SEC_ASN1_EXPLICIT | SEC_ASN1_OPTIONAL | SEC_ASN1_MAY_STREAM | SEC_ASN1_INLINE | SEC_ASN1_POINTER)) == 0);
+
+    if (encode_kind & (SEC_ASN1_ANY | SEC_ASN1_SKIP)) {
+        PORT_Assert(encode_kind == under_kind);
+        if (encode_kind & SEC_ASN1_SKIP) {
+            PORT_Assert(!optional);
+            PORT_Assert(encode_kind == SEC_ASN1_SKIP);
+            state->dest = NULL;
+        }
+        check_tag_mask = 0;
+        expect_tag_modifiers = 0;
+        expect_tag_number = 0;
+    } else {
+        check_tag_mask = SEC_ASN1_TAG_MASK;
+        expect_tag_modifiers = (unsigned char)encode_kind & SEC_ASN1_TAG_MASK & ~SEC_ASN1_TAGNUM_MASK;
+        /*
+         * XXX This assumes only single-octet identifiers.  To handle
+         * the HIGH TAG form we would need to do some more work, especially
+         * in how to specify them in the template, because right now we
+         * do not provide a way to specify more *tag* bits in encode_kind.
+         */
+        expect_tag_number = encode_kind & SEC_ASN1_TAGNUM_MASK;
+
+        switch (under_kind & SEC_ASN1_TAGNUM_MASK) {
+            case SEC_ASN1_SET:
+                /*
+                 * XXX A plain old SET (as opposed to a SET OF) is not implemented.
+                 * If it ever is, remove this assert...
+                 */
+                PORT_Assert((under_kind & SEC_ASN1_GROUP) != 0);
+            /* fallthru */
+            case SEC_ASN1_SEQUENCE:
+                expect_tag_modifiers |= SEC_ASN1_CONSTRUCTED;
+                break;
+            case SEC_ASN1_BIT_STRING:
+            case SEC_ASN1_BMP_STRING:
+            case SEC_ASN1_GENERALIZED_TIME:
+            case SEC_ASN1_IA5_STRING:
+            case SEC_ASN1_OCTET_STRING:
+            case SEC_ASN1_PRINTABLE_STRING:
+            case SEC_ASN1_T61_STRING:
+            case SEC_ASN1_UNIVERSAL_STRING:
+            case SEC_ASN1_UTC_TIME:
+            case SEC_ASN1_UTF8_STRING:
+            case SEC_ASN1_VISIBLE_STRING:
+                check_tag_mask &= ~SEC_ASN1_CONSTRUCTED;
+                break;
+        }
+    }
+
+    state->check_tag_mask = check_tag_mask;
+    state->expect_tag_modifiers = expect_tag_modifiers;
+    state->expect_tag_number = expect_tag_number;
+    state->underlying_kind = under_kind;
+    state->explicit = explicit;
+    state->optional = optional;
+
+    sec_asn1d_scrub_state(state);
+
+    return state;
+}
+
+static sec_asn1d_state *
+sec_asn1d_get_enclosing_construct(sec_asn1d_state *state)
+{
+    for (state = state->parent; state; state = state->parent) {
+        sec_asn1d_parse_place place = state->place;
+        if (place != afterImplicit &&
+            place != afterPointer &&
+            place != afterInline &&
+            place != afterSaveEncoding &&
+            place != duringSaveEncoding &&
+            place != duringChoice) {
+
+            /* we've walked up the stack to a state that represents
+            ** the enclosing construct.
+            */
+            break;
+        }
+    }
+    return state;
+}
+
+static PRBool
+sec_asn1d_parent_allows_EOC(sec_asn1d_state *state)
+{
+    /* get state of enclosing construct. */
+    state = sec_asn1d_get_enclosing_construct(state);
+    if (state) {
+        sec_asn1d_parse_place place = state->place;
+        /* Is it one of the types that permits an unexpected EOC? */
+        int eoc_permitted =
+            (place == duringGroup ||
+             place == duringConstructedString ||
+             state->child->optional);
+        return (state->indefinite && eoc_permitted) ? PR_TRUE : PR_FALSE;
+    }
+    return PR_FALSE;
+}
+
+static unsigned long
+sec_asn1d_parse_identifier(sec_asn1d_state *state,
+                           const char *buf, unsigned long len)
+{
+    unsigned char byte;
+    unsigned char tag_number;
+
+    PORT_Assert(state->place == beforeIdentifier);
+
+    if (len == 0) {
+        state->top->status = needBytes;
+        return 0;
+    }
+
+    byte = (unsigned char)*buf;
+#ifdef DEBUG_ASN1D_STATES
+    {
+        int bufsize = 256;
+        char kindBuf[bufsize];
+        formatKind(byte, kindBuf, bufsize);
+        printf("Found tag %02x %s\n", byte, kindBuf);
+    }
+#endif
+    tag_number = byte & SEC_ASN1_TAGNUM_MASK;
+
+    if (IS_HIGH_TAG_NUMBER(tag_number)) {
+        state->place = duringIdentifier;
+        state->found_tag_number = 0;
+        /*
+         * Actually, we have no idea how many bytes are pending, but we
+         * do know that it is at least 1.  That is all we know; we have
+         * to look at each byte to know if there is another, etc.
+         */
+        state->pending = 1;
+    } else {
+        if (byte == 0 && sec_asn1d_parent_allows_EOC(state)) {
+            /*
+             * Our parent has indefinite-length encoding, and the
+             * entire tag found is 0, so it seems that we have hit the
+             * end-of-contents octets.  To handle this, we just change
+             * our state to that which expects to get the bytes of the
+             * end-of-contents octets and let that code re-read this byte
+             * so that our categorization of field types is correct.
+             * After that, our parent will then deal with everything else.
+             */
+            state->place = duringEndOfContents;
+            state->pending = 2;
+            state->found_tag_number = 0;
+            state->found_tag_modifiers = 0;
+            /*
+             * We might be an optional field that is, as we now find out,
+             * missing.  Give our parent a clue that this happened.
+             */
+            if (state->optional)
+                state->missing = PR_TRUE;
+            return 0;
+        }
+        state->place = afterIdentifier;
+        state->found_tag_number = tag_number;
+    }
+    state->found_tag_modifiers = byte & ~SEC_ASN1_TAGNUM_MASK;
+
+    return 1;
+}
+
+static unsigned long
+sec_asn1d_parse_more_identifier(sec_asn1d_state *state,
+                                const char *buf, unsigned long len)
+{
+    unsigned char byte;
+    int count;
+
+    PORT_Assert(state->pending == 1);
+    PORT_Assert(state->place == duringIdentifier);
+
+    if (len == 0) {
+        state->top->status = needBytes;
+        return 0;
+    }
+
+    count = 0;
+
+    while (len && state->pending) {
+        if (HIGH_BITS(state->found_tag_number, TAG_NUMBER_BITS) != 0) {
+            /*
+             * The given high tag number overflows our container;
+             * just give up.  This is not likely to *ever* happen.
+             */
+            PORT_SetError(SEC_ERROR_BAD_DER);
+            state->top->status = decodeError;
+            return 0;
+        }
+
+        state->found_tag_number <<= TAG_NUMBER_BITS;
+
+        byte = (unsigned char)buf[count++];
+        state->found_tag_number |= (byte & TAG_NUMBER_MASK);
+
+        len--;
+        if (LAST_TAG_NUMBER_BYTE(byte))
+            state->pending = 0;
+    }
+
+    if (state->pending == 0)
+        state->place = afterIdentifier;
+
+    return count;
+}
+
+static void
+sec_asn1d_confirm_identifier(sec_asn1d_state *state)
+{
+    PRBool match;
+
+    PORT_Assert(state->place == afterIdentifier);
+
+    match = (PRBool)(((state->found_tag_modifiers & state->check_tag_mask) == state->expect_tag_modifiers) && ((state->found_tag_number & state->check_tag_mask) == state->expect_tag_number));
+    if (match) {
+        state->place = beforeLength;
+    } else {
+        if (state->optional) {
+            state->missing = PR_TRUE;
+            state->place = afterEndOfContents;
+        } else {
+            PORT_SetError(SEC_ERROR_BAD_DER);
+            state->top->status = decodeError;
+        }
+    }
+}
+
+static unsigned long
+sec_asn1d_parse_length(sec_asn1d_state *state,
+                       const char *buf, unsigned long len)
+{
+    unsigned char byte;
+
+    PORT_Assert(state->place == beforeLength);
+
+    if (len == 0) {
+        state->top->status = needBytes;
+        return 0;
+    }
+
+    /*
+     * The default/likely outcome.  It may get adjusted below.
+     */
+    state->place = afterLength;
+
+    byte = (unsigned char)*buf;
+
+    if (LENGTH_IS_SHORT_FORM(byte)) {
+        state->contents_length = byte;
+    } else {
+        state->contents_length = 0;
+        state->pending = LONG_FORM_LENGTH(byte);
+        if (state->pending == 0) {
+            state->indefinite = PR_TRUE;
+        } else {
+            state->place = duringLength;
+        }
+    }
+
+    /* If we're parsing an ANY, SKIP, or SAVE template, and
+    ** the object being saved is definite length encoded and constructed,
+    ** there's no point in decoding that construct's members.
+    ** So, just forget it's constructed and treat it as primitive.
+    ** (SAVE appears as an ANY at this point)
+    */
+    if (!state->indefinite &&
+        (state->underlying_kind & (SEC_ASN1_ANY | SEC_ASN1_SKIP))) {
+        state->found_tag_modifiers &= ~SEC_ASN1_CONSTRUCTED;
+    }
+
+    return 1;
+}
+
+static unsigned long
+sec_asn1d_parse_more_length(sec_asn1d_state *state,
+                            const char *buf, unsigned long len)
+{
+    int count;
+
+    PORT_Assert(state->pending > 0);
+    PORT_Assert(state->place == duringLength);
+
+    if (len == 0) {
+        state->top->status = needBytes;
+        return 0;
+    }
+
+    count = 0;
+
+    while (len && state->pending) {
+        if (HIGH_BITS(state->contents_length, 9) != 0) {
+            /*
+             * The given full content length overflows our container;
+             * just give up.
+             */
+            PORT_SetError(SEC_ERROR_BAD_DER);
+            state->top->status = decodeError;
+            return 0;
+        }
+
+        state->contents_length <<= 8;
+        state->contents_length |= (unsigned char)buf[count++];
+
+        len--;
+        state->pending--;
+    }
+
+    if (state->pending == 0)
+        state->place = afterLength;
+
+    return count;
+}
+
+/*
+ * Helper function for sec_asn1d_prepare_for_contents.
+ * Checks that a value representing a number of bytes consumed can be
+ * subtracted from a remaining length. If so, returns PR_TRUE.
+ * Otherwise, sets the error SEC_ERROR_BAD_DER, indicates that there was a
+ * decoding error in the given SEC_ASN1DecoderContext, and returns PR_FALSE.
+ */
+static PRBool
+sec_asn1d_check_and_subtract_length(unsigned long *remaining,
+                                    unsigned long consumed,
+                                    SEC_ASN1DecoderContext *cx)
+{
+    PORT_Assert(remaining);
+    PORT_Assert(cx);
+    if (!remaining || !cx) {
+        PORT_SetError(SEC_ERROR_INVALID_ARGS);
+        cx->status = decodeError;
+        return PR_FALSE;
+    }
+    if (*remaining < consumed) {
+        PORT_SetError(SEC_ERROR_BAD_DER);
+        cx->status = decodeError;
+        return PR_FALSE;
+    }
+    *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 %lu %s\n", state->contents_length,
+               state->indefinite ? "indefinite" : "");
+    }
+#endif
+
+    /**
+     * The maximum length for a child element should be constrained to the
+     * length remaining in the first definite length element in the ancestor
+     * stack. If there is no definite length element in the ancestor stack,
+     * there's nothing to constrain the length of the child, so there's no
+     * further processing necessary.
+     *
+     * It's necessary to walk the ancestor stack, because it's possible to have
+     * definite length children that are part of an indefinite length element,
+     * which is itself part of an indefinite length element, and which is
+     * ultimately part of a definite length element. A simple example of this
+     * would be the handling of constructed OCTET STRINGs in BER encoding.
+     *
+     * This algorithm finds the first definite length element in the ancestor
+     * stack, if any, and if so, ensures that the length of the child element
+     * is consistent with the number of bytes remaining in the constraining
+     * ancestor element (that is, after accounting for any other sibling
+     * 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. */
+    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;
+        do {
+            if (!sec_asn1d_check_and_subtract_length(
+                    &remaining, parent->consumed, state->top) ||
+                /* If parent->indefinite is true, parent->contents_length is
+                 * zero and this is a no-op. */
+                !sec_asn1d_check_and_subtract_length(
+                    &remaining, parent->contents_length, state->top) ||
+                /* If parent->indefinite is true, then ensure there is enough
+                 * space for an EOC tag of 2 bytes. */
+                (parent->indefinite && !sec_asn1d_check_and_subtract_length(&remaining, 2, state->top))) {
+                /* This element is larger than its enclosing element, which is
+                 * invalid. */
+                return;
+            }
+        } while ((parent = sec_asn1d_get_enclosing_construct(parent)) &&
+                 parent->indefinite);
+    }
+
+    /*
+     * XXX I cannot decide if this allocation should exclude the case
+     *     where state->endofcontents is true -- figure it out!
+     */
+    if (state->allocate) {
+        void *dest;
+
+        PORT_Assert(state->dest == NULL);
+        /*
+         * We are handling a POINTER or a member of a GROUP, and need to
+         * allocate for the data structure.
+         */
+        dest = sec_asn1d_zalloc(state->top->their_pool,
+                                state->theTemplate->size);
+        if (dest == NULL) {
+            state->top->status = decodeError;
+            return;
+        }
+        state->dest = (char *)dest + state->theTemplate->offset;
+
+        /*
+         * For a member of a GROUP, our parent will later put the
+         * pointer wherever it belongs.  But for a POINTER, we need
+         * to record the destination now, in case notify or filter
+         * procs need access to it -- they cannot find it otherwise,
+         * until it is too late (for one-pass processing).
+         */
+        if (state->parent->place == afterPointer) {
+            void **placep;
+
+            placep = state->parent->dest;
+            *placep = dest;
+        }
+    }
+
+    /*
+     * Remember, length may be indefinite here!  In that case,
+     * both contents_length and pending will be zero.
+     */
+    state->pending = state->contents_length;
+
+    /*
+     * An EXPLICIT is nothing but an outer header, which we have
+     * already parsed and accepted.  Now we need to do the inner
+     * header and its contents.
+     */
+    if (state->explicit) {
+        state->place = afterExplicit;
+        state = sec_asn1d_push_state(state->top,
+                                     SEC_ASN1GetSubtemplate(state->theTemplate,
+                                                            state->dest,
+                                                            PR_FALSE),
+                                     state->dest, PR_TRUE);
+        if (state != NULL) {
+            (void)sec_asn1d_init_state_based_on_template(state);
+        }
+        return;
+    }
+
+    /*
+     * For GROUP (SET OF, SEQUENCE OF), even if we know the length here
+     * we cannot tell how many items we will end up with ... so push a
+     * state that can keep track of "children" (the individual members
+     * of the group; we will allocate as we go and put them all together
+     * at the end.
+     */
+    if (state->underlying_kind & SEC_ASN1_GROUP) {
+        /* XXX If this assertion holds (should be able to confirm it via
+         * inspection, too) then move this code into the switch statement
+         * below under cases SET_OF and SEQUENCE_OF; it will be cleaner.
+         */
+        PORT_Assert(state->underlying_kind == SEC_ASN1_SET_OF || state->underlying_kind == SEC_ASN1_SEQUENCE_OF || state->underlying_kind == (SEC_ASN1_SET_OF | SEC_ASN1_DYNAMIC) || state->underlying_kind == (SEC_ASN1_SEQUENCE_OF | SEC_ASN1_DYNAMIC));
+        if (state->contents_length != 0 || state->indefinite) {
+            const SEC_ASN1Template *subt;
+
+            state->place = duringGroup;
+            subt = SEC_ASN1GetSubtemplate(state->theTemplate, state->dest,
+                                          PR_FALSE);
+            state = sec_asn1d_push_state(state->top, subt, NULL, PR_TRUE);
+            if (state != NULL) {
+                if (!state->top->filter_only)
+                    state->allocate = PR_TRUE; /* XXX propogate this? */
+                /*
+                 * Do the "before" field notification for next in group.
+                 */
+                sec_asn1d_notify_before(state->top, state->dest, state->depth);
+                (void)sec_asn1d_init_state_based_on_template(state);
+            }
+        } else {
+            /*
+             * A group of zero; we are done.
+             * Set state to afterGroup and let that code plant the NULL.
+             */
+            state->place = afterGroup;
+        }
+        return;
+    }
+
+    switch (state->underlying_kind) {
+        case SEC_ASN1_SEQUENCE:
+            /*
+             * We need to push a child to handle the individual fields.
+             */
+            state->place = duringSequence;
+            state = sec_asn1d_push_state(state->top, state->theTemplate + 1,
+                                         state->dest, PR_TRUE);
+            if (state != NULL) {
+                /*
+                 * Do the "before" field notification.
+                 */
+                sec_asn1d_notify_before(state->top, state->dest, state->depth);
+                (void)sec_asn1d_init_state_based_on_template(state);
+            }
+            break;
+
+        case SEC_ASN1_SET: /* XXX SET is not really implemented */
+            /*
+             * XXX A plain SET requires special handling; scanning of a
+             * template to see where a field should go (because by definition,
+             * they are not in any particular order, and you have to look at
+             * each tag to disambiguate what the field is).  We may never
+             * implement this because in practice, it seems to be unused.
+             */
+            PORT_Assert(0);
+            PORT_SetError(SEC_ERROR_BAD_DER); /* XXX */
+            state->top->status = decodeError;
+            break;
+
+        case SEC_ASN1_NULL:
+            /*
+             * The NULL type, by definition, is "nothing", content length of zero.
+             * An indefinite-length encoding is not alloweed.
+             */
+            if (state->contents_length || state->indefinite) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                break;
+            }
+            if (state->dest != NULL) {
+                item = (SECItem *)(state->dest);
+                item->data = NULL;
+                item->len = 0;
+            }
+            state->place = afterEndOfContents;
+            break;
+
+        case SEC_ASN1_BMP_STRING:
+            /* Error if length is not divisable by 2 */
+            if (state->contents_length % 2) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                break;
+            }
+            /* otherwise, handle as other string types */
+            goto regular_string_type;
+
+        case SEC_ASN1_UNIVERSAL_STRING:
+            /* Error if length is not divisable by 4 */
+            if (state->contents_length % 4) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                break;
+            }
+            /* otherwise, handle as other string types */
+            goto regular_string_type;
+
+        case SEC_ASN1_SKIP:
+        case SEC_ASN1_ANY:
+        case SEC_ASN1_ANY_CONTENTS:
+        /*
+         * These are not (necessarily) strings, but they need nearly
+         * identical handling (especially when we need to deal with
+         * constructed sub-pieces), so we pretend they are.
+         */
+        /* fallthru */
+        regular_string_type:
+        case SEC_ASN1_BIT_STRING:
+        case SEC_ASN1_IA5_STRING:
+        case SEC_ASN1_OCTET_STRING:
+        case SEC_ASN1_PRINTABLE_STRING:
+        case SEC_ASN1_T61_STRING:
+        case SEC_ASN1_UTC_TIME:
+        case SEC_ASN1_UTF8_STRING:
+        case SEC_ASN1_VISIBLE_STRING:
+            /*
+             * We are allocating for a primitive or a constructed string.
+             * If it is a constructed string, it may also be indefinite-length.
+             * If it is primitive, the length can (legally) be zero.
+             * Our first order of business is to allocate the memory for
+             * the string, if we can (if we know the length).
+             */
+            item = (SECItem *)(state->dest);
+
+            /*
+             * If the item is a definite-length constructed string, then
+             * the contents_length is actually larger than what we need
+             * (because it also counts each intermediate header which we
+             * will be throwing away as we go), but it is a perfectly good
+             * upper bound that we just allocate anyway, and then concat
+             * as we go; we end up wasting a few extra bytes but save a
+             * whole other copy.
+             */
+            alloc_len = state->contents_length;
+            poolp = NULL; /* quiet compiler warnings about unused... */
+
+            if (item == NULL || state->top->filter_only) {
+                if (item != NULL) {
+                    item->data = NULL;
+                    item->len = 0;
+                }
+                alloc_len = 0;
+            } else if (state->substring) {
+                /*
+                 * If we are a substring of a constructed string, then we may
+                 * not have to allocate anything (because our parent, the
+                 * actual constructed string, did it for us).  If we are a
+                 * substring and we *do* have to allocate, that means our
+                 * parent is an indefinite-length, so we allocate from our pool;
+                 * later our parent will copy our string into the aggregated
+                 * whole and free our pool allocation.
+                 */
+                if (item->data == NULL) {
+                    PORT_Assert(item->len == 0);
+                    poolp = state->top->our_pool;
+                } else {
+                    alloc_len = 0;
+                }
+            } else {
+                item->len = 0;
+                item->data = NULL;
+                poolp = state->top->their_pool;
+            }
+
+            if (alloc_len || ((!state->indefinite) && (state->subitems_head != NULL))) {
+                struct subitem *subitem;
+                int len;
+
+                PORT_Assert(item);
+                if (!item) {
+                    PORT_SetError(SEC_ERROR_BAD_DER);
+                    state->top->status = decodeError;
+                    return;
+                }
+                PORT_Assert(item->len == 0 && item->data == NULL);
+                /*
+                 * Check for and handle an ANY which has stashed aside the
+                 * header (identifier and length) bytes for us to include
+                 * in the saved contents.
+                 */
+                if (state->subitems_head != NULL) {
+                    PORT_Assert(state->underlying_kind == SEC_ASN1_ANY);
+                    for (subitem = state->subitems_head;
+                         subitem != NULL; subitem = subitem->next)
+                        alloc_len += subitem->len;
+                }
+
+                if (state->top->max_element_size > 0 &&
+                    alloc_len > state->top->max_element_size) {
+                    PORT_SetError(SEC_ERROR_OUTPUT_LEN);
+                    state->top->status = decodeError;
+                    return;
+                }
+
+                item->data = (unsigned char *)sec_asn1d_zalloc(poolp, alloc_len);
+                if (item->data == NULL) {
+                    state->top->status = decodeError;
+                    break;
+                }
+
+                len = 0;
+                for (subitem = state->subitems_head;
+                     subitem != NULL; subitem = subitem->next) {
+                    PORT_Memcpy(item->data + len, subitem->data, subitem->len);
+                    len += subitem->len;
+                }
+                item->len = len;
+
+                /*
+                 * Because we use arenas and have a mark set, we later free
+                 * everything we have allocated, so this does *not* present
+                 * a memory leak (it is just temporarily left dangling).
+                 */
+                state->subitems_head = state->subitems_tail = NULL;
+            }
+
+            if (state->contents_length == 0 && (!state->indefinite)) {
+                /*
+                 * A zero-length simple or constructed string; we are done.
+                 */
+                state->place = afterEndOfContents;
+            } else if (state->found_tag_modifiers & SEC_ASN1_CONSTRUCTED) {
+                const SEC_ASN1Template *sub;
+
+                switch (state->underlying_kind) {
+                    case SEC_ASN1_ANY:
+                    case SEC_ASN1_ANY_CONTENTS:
+                        sub = SEC_AnyTemplate;
+                        break;
+                    case SEC_ASN1_BIT_STRING:
+                        sub = SEC_BitStringTemplate;
+                        break;
+                    case SEC_ASN1_BMP_STRING:
+                        sub = SEC_BMPStringTemplate;
+                        break;
+                    case SEC_ASN1_GENERALIZED_TIME:
+                        sub = SEC_GeneralizedTimeTemplate;
+                        break;
+                    case SEC_ASN1_IA5_STRING:
+                        sub = SEC_IA5StringTemplate;
+                        break;
+                    case SEC_ASN1_OCTET_STRING:
+                        sub = SEC_OctetStringTemplate;
+                        break;
+                    case SEC_ASN1_PRINTABLE_STRING:
+                        sub = SEC_PrintableStringTemplate;
+                        break;
+                    case SEC_ASN1_T61_STRING:
+                        sub = SEC_T61StringTemplate;
+                        break;
+                    case SEC_ASN1_UNIVERSAL_STRING:
+                        sub = SEC_UniversalStringTemplate;
+                        break;
+                    case SEC_ASN1_UTC_TIME:
+                        sub = SEC_UTCTimeTemplate;
+                        break;
+                    case SEC_ASN1_UTF8_STRING:
+                        sub = SEC_UTF8StringTemplate;
+                        break;
+                    case SEC_ASN1_VISIBLE_STRING:
+                        sub = SEC_VisibleStringTemplate;
+                        break;
+                    case SEC_ASN1_SKIP:
+                        sub = SEC_SkipTemplate;
+                        break;
+                    default:            /* redundant given outer switch cases, but */
+                        PORT_Assert(0); /* the compiler does not seem to know that, */
+                        sub = NULL;     /* so just do enough to quiet it. */
+                        break;
+                }
+
+                state->place = duringConstructedString;
+                state = sec_asn1d_push_state(state->top, sub, item, PR_TRUE);
+                if (state != NULL) {
+                    state->substring = PR_TRUE; /* XXX propogate? */
+                    (void)sec_asn1d_init_state_based_on_template(state);
+                }
+            } else if (state->indefinite) {
+                /*
+                 * An indefinite-length string *must* be constructed!
+                 */
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+            } else {
+                /*
+                 * A non-zero-length simple string.
+                 */
+                if (state->underlying_kind == SEC_ASN1_BIT_STRING)
+                    state->place = beforeBitString;
+                else
+                    state->place = duringLeaf;
+            }
+            break;
+
+        default:
+            /*
+             * We are allocating for a simple leaf item.
+             */
+            if (state->contents_length) {
+                if (state->dest != NULL) {
+                    item = (SECItem *)(state->dest);
+                    item->len = 0;
+                    if (state->top->max_element_size > 0 &&
+                        state->contents_length > state->top->max_element_size) {
+                        PORT_SetError(SEC_ERROR_OUTPUT_LEN);
+                        state->top->status = decodeError;
+                        return;
+                    }
+
+                    if (state->top->filter_only) {
+                        item->data = NULL;
+                    } else {
+                        item->data = (unsigned char *)
+                            sec_asn1d_zalloc(state->top->their_pool,
+                                             state->contents_length);
+                        if (item->data == NULL) {
+                            state->top->status = decodeError;
+                            return;
+                        }
+                    }
+                }
+                state->place = duringLeaf;
+            } else {
+                /*
+                 * An indefinite-length or zero-length item is not allowed.
+                 * (All legal cases of such were handled above.)
+                 */
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+            }
+    }
+}
+
+static void
+sec_asn1d_free_child(sec_asn1d_state *state, PRBool error)
+{
+    if (state->child != NULL) {
+        PORT_Assert(error || state->child->consumed == 0);
+        PORT_Assert(state->our_mark != NULL);
+        PORT_ArenaZRelease(state->top->our_pool, state->our_mark);
+        if (error && state->top->their_pool == NULL) {
+            /*
+             * XXX We need to free anything allocated.
+             * At this point, we failed in the middle of decoding. But we
+             * can't free the data we previously allocated with PR_Malloc
+             * unless we keep track of every pointer. So instead we have a
+             * memory leak when decoding fails half-way, unless an arena is
+             * used. See bug 95311 .
+            */
+        }
+        state->child = NULL;
+        state->our_mark = NULL;
+    } else {
+        /*
+         * It is important that we do not leave a mark unreleased/unmarked.
+         * But I do not think we should ever have one set in this case, only
+         * if we had a child (handled above).  So check for that.  If this
+         * assertion should ever get hit, then we probably need to add code
+         * here to release back to our_mark (and then set our_mark to NULL).
+         */
+        PORT_Assert(state->our_mark == NULL);
+    }
+    state->place = beforeEndOfContents;
+}
+
+/* We have just saved an entire encoded ASN.1 object (type) for a SAVE
+** template, and now in the next template, we are going to decode that
+** saved data  by calling SEC_ASN1DecoderUpdate recursively.
+** If that recursive call fails with needBytes, it is a fatal error,
+** because the encoded object should have been complete.
+** If that recursive call fails with decodeError, it will have already
+** cleaned up the state stack, so we must bail out quickly.
+**
+** These checks of the status returned by the recursive call are now
+** done in the caller of this function, immediately after it returns.
+*/
+static void
+sec_asn1d_reuse_encoding(sec_asn1d_state *state)
+{
+    sec_asn1d_state *child;
+    unsigned long consumed;
+    SECItem *item;
+    void *dest;
+
+    child = state->child;
+    PORT_Assert(child != NULL);
+
+    consumed = child->consumed;
+    child->consumed = 0;
+
+    item = (SECItem *)(state->dest);
+    PORT_Assert(item != NULL);
+
+    PORT_Assert(item->len == consumed);
+
+    /*
+     * Free any grandchild.
+     */
+    sec_asn1d_free_child(child, PR_FALSE);
+
+    /*
+     * Notify after the SAVE field.
+     */
+    sec_asn1d_notify_after(state->top, state->dest, state->depth);
+
+    /*
+     * Adjust to get new dest and move forward.
+     */
+    dest = (char *)state->dest - state->theTemplate->offset;
+    state->theTemplate++;
+    child->dest = (char *)dest + state->theTemplate->offset;
+    child->theTemplate = state->theTemplate;
+
+    /*
+     * Notify before the "real" field.
+     */
+    PORT_Assert(state->depth == child->depth);
+    sec_asn1d_notify_before(state->top, child->dest, child->depth);
+
+    /*
+     * This will tell DecoderUpdate to return when it is done.
+     */
+    state->place = afterSaveEncoding;
+
+    /*
+     * We already have a child; "push" it by making it current.
+     */
+    state->top->current = child;
+
+    /*
+     * And initialize it so it is ready to parse.
+     */
+    (void)sec_asn1d_init_state_based_on_template(child);
+
+    /*
+     * Now parse that out of our data.
+     */
+    if (SEC_ASN1DecoderUpdate(state->top,
+                              (char *)item->data, item->len) != SECSuccess)
+        return;
+    if (state->top->status == needBytes) {
+        return;
+    }
+
+    PORT_Assert(state->top->current == state);
+    PORT_Assert(state->child == child);
+
+    /*
+     * That should have consumed what we consumed before.
+     */
+    PORT_Assert(consumed == child->consumed);
+    child->consumed = 0;
+
+    /*
+     * Done.
+     */
+    state->consumed += consumed;
+    child->place = notInUse;
+    state->place = afterEndOfContents;
+}
+
+static unsigned long
+sec_asn1d_parse_leaf(sec_asn1d_state *state,
+                     const char *buf, unsigned long len)
+{
+    SECItem *item;
+    unsigned long bufLen;
+
+    if (len == 0) {
+        state->top->status = needBytes;
+        return 0;
+    }
+
+    if (state->pending < len)
+        len = state->pending;
+
+    bufLen = len;
+
+    item = (SECItem *)(state->dest);
+    if (item != NULL && item->data != NULL) {
+        unsigned long offset;
+        /* Strip leading zeroes when target is unsigned integer */
+        if (state->underlying_kind == SEC_ASN1_INTEGER && /* INTEGER   */
+            item->len == 0 &&                             /* MSB       */
+            item->type == siUnsignedInteger)              /* unsigned  */
+        {
+            while (len > 1 && buf[0] == 0) { /* leading 0 */
+                buf++;
+                len--;
+            }
+        }
+        offset = item->len;
+        if (state->underlying_kind == SEC_ASN1_BIT_STRING) {
+            // The previous bit string must have no unused bits.
+            if (item->len & 0x7) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                return 0;
+            }
+            // If this is a bit string, the length is bits, not bytes.
+            offset = item->len >> 3;
+        }
+        if (state->underlying_kind == SEC_ASN1_BIT_STRING) {
+            unsigned long len_in_bits;
+            // Protect against overflow during the bytes-to-bits conversion.
+            if (len >= (ULONG_MAX >> 3) + 1) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                return 0;
+            }
+            len_in_bits = (len << 3) - state->bit_string_unused_bits;
+            // Protect against overflow when computing the total length in bits.
+            if (UINT_MAX - item->len < len_in_bits) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                return 0;
+            }
+            item->len += len_in_bits;
+        } else {
+            if (UINT_MAX - item->len < len) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                return 0;
+            }
+            item->len += len;
+        }
+        PORT_Memcpy(item->data + offset, buf, len);
+    }
+    state->pending -= bufLen;
+    if (state->pending == 0)
+        state->place = beforeEndOfContents;
+
+    return bufLen;
+}
+
+static unsigned long
+sec_asn1d_parse_bit_string(sec_asn1d_state *state,
+                           const char *buf, unsigned long len)
+{
+    unsigned char byte;
+
+    /*PORT_Assert (state->pending > 0); */
+    PORT_Assert(state->place == beforeBitString);
+
+    if (state->pending == 0) {
+        if (state->dest != NULL) {
+            SECItem *item = (SECItem *)(state->dest);
+            item->data = NULL;
+            item->len = 0;
+            state->place = beforeEndOfContents;
+            return 0;
+        }
+    }
+
+    if (len == 0) {
+        state->top->status = needBytes;
+        return 0;
+    }
+
+    byte = (unsigned char)*buf;
+    if (byte > 7) {
+        PORT_SetError(SEC_ERROR_BAD_DER);
+        state->top->status = decodeError;
+        return 0;
+    }
+
+    state->bit_string_unused_bits = byte;
+    state->place = duringBitString;
+    state->pending -= 1;
+
+    return 1;
+}
+
+static unsigned long
+sec_asn1d_parse_more_bit_string(sec_asn1d_state *state,
+                                const char *buf, unsigned long len)
+{
+    PORT_Assert(state->place == duringBitString);
+    if (state->pending == 0) {
+        /* An empty bit string with some unused bits is invalid. */
+        if (state->bit_string_unused_bits) {
+            PORT_SetError(SEC_ERROR_BAD_DER);
+            state->top->status = decodeError;
+        } else {
+            /* An empty bit string with no unused bits is OK. */
+            state->place = beforeEndOfContents;
+        }
+        return 0;
+    }
+
+    len = sec_asn1d_parse_leaf(state, buf, len);
+    return len;
+}
+
+/*
+ * XXX All callers should be looking at return value to detect
+ * out-of-memory errors (and stop!).
+ */
+static struct subitem *
+sec_asn1d_add_to_subitems(sec_asn1d_state *state,
+                          const void *data, unsigned long len,
+                          PRBool copy_data)
+{
+    struct subitem *thing;
+
+    thing = (struct subitem *)sec_asn1d_zalloc(state->top->our_pool,
+                                               sizeof(struct subitem));
+    if (thing == NULL) {
+        state->top->status = decodeError;
+        return NULL;
+    }
+
+    if (copy_data) {
+        void *copy;
+        copy = sec_asn1d_alloc(state->top->our_pool, len);
+        if (copy == NULL) {
+            state->top->status = decodeError;
+            if (!state->top->our_pool)
+                PORT_Free(thing);
+            return NULL;
+        }
+        PORT_Memcpy(copy, data, len);
+        thing->data = copy;
+    } else {
+        thing->data = data;
+    }
+    thing->len = len;
+    thing->next = NULL;
+
+    if (state->subitems_head == NULL) {
+        PORT_Assert(state->subitems_tail == NULL);
+        state->subitems_head = state->subitems_tail = thing;
+    } else {
+        state->subitems_tail->next = thing;
+        state->subitems_tail = thing;
+    }
+
+    return thing;
+}
+
+static void
+sec_asn1d_record_any_header(sec_asn1d_state *state,
+                            const char *buf,
+                            unsigned long len)
+{
+    SECItem *item;
+
+    item = (SECItem *)(state->dest);
+    if (item != NULL && item->data != NULL) {
+        PORT_Assert(state->substring);
+        PORT_Memcpy(item->data + item->len, buf, len);
+        item->len += len;
+    } else {
+        sec_asn1d_add_to_subitems(state, buf, len, PR_TRUE);
+    }
+}
+
+/*
+ * We are moving along through the substrings of a constructed string,
+ * and have just finished parsing one -- we need to save our child data
+ * (if the child was not already writing directly into the destination)
+ * and then move forward by one.
+ *
+ * We also have to detect when we are done:
+ *  - a definite-length encoding stops when our pending value hits 0
+ *  - an indefinite-length encoding stops when our child is empty
+ *    (which means it was the end-of-contents octets)
+ */
+static void
+sec_asn1d_next_substring(sec_asn1d_state *state)
+{
+    sec_asn1d_state *child;
+    SECItem *item;
+    unsigned long child_consumed;
+    PRBool done;
+
+    PORT_Assert(state->place == duringConstructedString);
+    PORT_Assert(state->child != NULL);
+
+    child = state->child;
+
+    child_consumed = child->consumed;
+    child->consumed = 0;
+    state->consumed += child_consumed;
+
+    done = PR_FALSE;
+
+    if (state->pending) {
+        PORT_Assert(!state->indefinite);
+        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.
+         *
+         * This state handles both substrings of a constructed string AND
+         * child elements of items whose template type was that of
+         * SEC_ASN1_ANY, SEC_ASN1_SAVE, SEC_ASN1_ANY_CONTENTS, SEC_ASN1_SKIP
+         * template, as described in sec_asn1d_prepare_for_contents. For
+         * brevity, these will be referred to as 'string' and 'any' types.
+         *
+         * This leads to the following possibilities:
+         *   1: This element is an indefinite length string, part of a
+         *      definite length string.
+         *   2: This element is an indefinite length string, part of an
+         *      indefinite length string.
+         *   3: This element is an indefinite length any, part of a
+         *      definite length any.
+         *   4: This element is an indefinite length any, part of an
+         *      indefinite length any.
+         *   5: This element is an indefinite length any and does not
+         *      meet any of the above criteria. Note that this would include
+         *      an indefinite length string type matching an indefinite
+         *      length any template.
+         *
+         * In Cases #1 and #3, the definite length 'parent' element will
+         * have allocated state->dest based on the parent elements definite
+         * size. During the processing of 'child', sec_asn1d_parse_leaf will
+         * have copied the (string, any) data directly into the offset of
+         * dest, as appropriate, so there's no need for this class to still
+         * store the child - it's already been processed.
+         *
+         * In Cases #2 and #4, dest will be set to the parent element's dest,
+         * but dest->data will not have been allocated yet, due to the
+         * indefinite length encoding. In this situation, it's necessary to
+         * hold onto child (and all other children) until the EOC, at which
+         * point, it becomes possible to compute 'state's overall length. Once
+         * 'state' has a computed length, this can then be fed to 'parent' (via
+         * this state), and then 'parent' can similarly compute the length of
+         * all of its children up to the EOC, which will ultimately transit to
+         * sec_asn1d_concat_substrings, determine the overall size needed,
+         * allocate, and copy the contents (of all of parent's children, which
+         * would include 'state', just as 'state' will have copied all of its
+         * children via sec_asn1d_concat_substrings)
+         *
+         * The final case, Case #5, will manifest in that item->data and
+         * item->len will be NULL/0, respectively, since this element was
+         * indefinite-length encoded. In that case, both the tag and length will
+         * already exist in state's subitems, via sec_asn1d_record_any_header,
+         * and so the contents (aka 'child') should be added to that list of
+         * items to concatenate in sec_asn1d_concat_substrings once the EOC
+         * is encountered.
+         *
+         * To distinguish #2/#4 from #1/#3, it's sufficient to walk the ancestor
+         * tree. If the current type is a string type, then the enclosing
+         * construct will be that same type (#1/#2). If the current type is an
+         * 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.
+         */
+        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
+                 * this is a substring that has already copied into dest. */
+                preallocatedString = PR_TRUE;
+                break;
+            }
+            if (!parent->substring) {
+                /* Cases #2 / #4 - If the parent is not a substring, but is
+                 * indefinite, then there's nothing further up that may have
+                 * preallocated dest, thus child will not have already
+                 * been copied in place, therefore it's necessary to save child
+                 * as a subitem. */
+                break;
+            }
+            temp_state = parent;
+        }
+        if (item != NULL && item->data != NULL && !preallocatedString) {
+            /*
+             * Save the string away for later concatenation.
+             */
+            PORT_Assert(item->data != NULL);
+            sec_asn1d_add_to_subitems(state, item->data, item->len, PR_FALSE);
+            /*
+             * Clear the child item for the next round.
+             */
+            item->data = NULL;
+            item->len = 0;
+        }
+
+        /*
+         * If our child was just our end-of-contents octets, we are done.
+         */
+        if (child->endofcontents)
+            done = PR_TRUE;
+    }
+
+    /*
+     * Stop or do the next one.
+     */
+    if (done) {
+        child->place = notInUse;
+        state->place = afterConstructedString;
+    } else {
+        sec_asn1d_scrub_state(child);
+        state->top->current = child;
+    }
+}
+
+/*
+ * We are doing a SET OF or SEQUENCE OF, and have just finished an item.
+ */
+static void
+sec_asn1d_next_in_group(sec_asn1d_state *state)
+{
+    sec_asn1d_state *child;
+    unsigned long child_consumed;
+
+    PORT_Assert(state->place == duringGroup);
+    PORT_Assert(state->child != NULL);
+
+    child = state->child;
+
+    child_consumed = child->consumed;
+    child->consumed = 0;
+    state->consumed += child_consumed;
+
+    /*
+     * If our child was just our end-of-contents octets, we are done.
+     */
+    if (child->endofcontents) {
+        /* XXX I removed the PORT_Assert (child->dest == NULL) because there
+         * was a bug in that a template that was a sequence of which also had
+         * a child of a sequence of, in an indefinite group was not working
+         * properly.  This fix seems to work, (added the if statement below),
+         * and nothing appears broken, but I am putting this note here just
+         * in case. */
+        /*
+         * XXX No matter how many times I read that comment,
+         * I cannot figure out what case he was fixing.  I believe what he
+         * did was deliberate, so I am loathe to touch it.  I need to
+         * understand how it could ever be that child->dest != NULL but
+         * child->endofcontents is true, and why it is important to check
+         * that state->subitems_head is NULL.  This really needs to be
+         * figured out, as I am not sure if the following code should be
+         * compensating for "offset", as is done a little farther below
+         * in the more normal case.
+         */
+        /*
+         * XXX We used to assert our overall state was that we were decoding
+         * an indefinite-length object here (state->indefinite == TRUE and no
+         * pending bytes in the decoder), but those assertions aren't correct
+         * as it's legitimate to wrap indefinite sequences inside definite ones
+         * and this code handles that case. Additionally, when compiled in
+         * release mode these assertions aren't checked anyway, yet function
+         * safely.
+         */
+        if (child->dest && !state->subitems_head) {
+            sec_asn1d_add_to_subitems(state, child->dest, 0, PR_FALSE);
+            child->dest = NULL;
+        }
+
+        child->place = notInUse;
+        state->place = afterGroup;
+        return;
+    }
+
+    /*
+     * Do the "after" field notification for next in group.
+     */
+    sec_asn1d_notify_after(state->top, child->dest, child->depth);
+
+    /*
+     * Save it away (unless we are not storing).
+     */
+    if (child->dest != NULL) {
+        void *dest;
+
+        dest = child->dest;
+        dest = (char *)dest - child->theTemplate->offset;
+        sec_asn1d_add_to_subitems(state, dest, 0, PR_FALSE);
+        child->dest = NULL;
+    }
+
+    /*
+     * Account for those bytes; see if we are done.
+     */
+    if (state->pending) {
+        PORT_Assert(!state->indefinite);
+        if (child_consumed > state->pending) {
+            PORT_SetError(SEC_ERROR_BAD_DER);
+            state->top->status = decodeError;
+            return;
+        }
+
+        state->pending -= child_consumed;
+        if (state->pending == 0) {
+            child->place = notInUse;
+            state->place = afterGroup;
+            return;
+        }
+    }
+
+    /*
+     * Do the "before" field notification for next item in group.
+     */
+    sec_asn1d_notify_before(state->top, child->dest, child->depth);
+
+    /*
+     * Now we do the next one.
+     */
+    sec_asn1d_scrub_state(child);
+
+    /* Initialize child state from the template */
+    sec_asn1d_init_state_based_on_template(child);
+
+    state->top->current = child;
+}
+
+/*
+ * We are moving along through a sequence; move forward by one,
+ * (detecting end-of-sequence when it happens).
+ * XXX The handling of "missing" is ugly.  Fix it.
+ */
+static void
+sec_asn1d_next_in_sequence(sec_asn1d_state *state)
+{
+    sec_asn1d_state *child;
+    unsigned long child_consumed;
+    PRBool child_missing;
+
+    PORT_Assert(state->place == duringSequence);
+    PORT_Assert(state->child != NULL);
+
+    child = state->child;
+
+    /*
+     * Do the "after" field notification.
+     */
+    sec_asn1d_notify_after(state->top, child->dest, child->depth);
+
+    child_missing = (PRBool)child->missing;
+    child_consumed = child->consumed;
+    child->consumed = 0;
+
+    /*
+     * Take care of accounting.
+     */
+    if (child_missing) {
+        PORT_Assert(child->optional);
+    } else {
+        state->consumed += child_consumed;
+        /*
+         * Free any grandchild.
+         */
+        sec_asn1d_free_child(child, PR_FALSE);
+        if (state->pending) {
+            PORT_Assert(!state->indefinite);
+            if (child_consumed > state->pending) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                return;
+            }
+            state->pending -= child_consumed;
+            if (state->pending == 0) {
+                child->theTemplate++;
+                while (child->theTemplate->kind != 0) {
+                    if ((child->theTemplate->kind & SEC_ASN1_OPTIONAL) == 0) {
+                        PORT_SetError(SEC_ERROR_BAD_DER);
+                        state->top->status = decodeError;
+                        return;
+                    }
+                    child->theTemplate++;
+                }
+                child->place = notInUse;
+                state->place = afterEndOfContents;
+                return;
+            }
+        }
+    }
+
+    /*
+     * Move forward.
+     */
+    child->theTemplate++;
+    if (child->theTemplate->kind == 0) {
+        /*
+         * We are done with this sequence.
+         */
+        child->place = notInUse;
+        if (state->pending) {
+            PORT_SetError(SEC_ERROR_BAD_DER);
+            state->top->status = decodeError;
+        } else if (child_missing) {
+            /*
+             * We got to the end, but have a child that started parsing
+             * and ended up "missing".  The only legitimate reason for
+             * this is that we had one or more optional fields at the
+             * end of our sequence, and we were encoded indefinite-length,
+             * so when we went looking for those optional fields we
+             * found our end-of-contents octets instead.
+             * (Yes, this is ugly; dunno a better way to handle it.)
+             * So, first confirm the situation, and then mark that we
+             * are done.
+             */
+            if (state->indefinite && child->endofcontents) {
+                PORT_Assert(child_consumed == 2);
+                if (child_consumed != 2) {
+                    PORT_SetError(SEC_ERROR_BAD_DER);
+                    state->top->status = decodeError;
+                } else {
+                    state->consumed += child_consumed;
+                    state->place = afterEndOfContents;
+                }
+            } else {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+            }
+        } else {
+            /*
+             * We have to finish out, maybe reading end-of-contents octets;
+             * let the normal logic do the right thing.
+             */
+            state->place = beforeEndOfContents;
+        }
+    } else {
+        unsigned char child_found_tag_modifiers = 0;
+        unsigned long child_found_tag_number = 0;
+
+        /*
+         * Reset state and push.
+         */
+        if (state->dest != NULL)
+            child->dest = (char *)state->dest + child->theTemplate->offset;
+
+        /*
+         * Do the "before" field notification.
+         */
+        sec_asn1d_notify_before(state->top, child->dest, child->depth);
+
+        if (child_missing) { /* if previous child was missing, copy the tag data we already have */
+            child_found_tag_modifiers = child->found_tag_modifiers;
+            child_found_tag_number = child->found_tag_number;
+        }
+        state->top->current = child;
+        child = sec_asn1d_init_state_based_on_template(child);
+        if (child_missing && child) {
+            child->place = afterIdentifier;
+            child->found_tag_modifiers = child_found_tag_modifiers;
+            child->found_tag_number = child_found_tag_number;
+            child->consumed = child_consumed;
+            if (child->underlying_kind == SEC_ASN1_ANY && !child->top->filter_only) {
+                /*
+                 * If the new field is an ANY, and we are storing, then
+                 * we need to save the tag out.  We would have done this
+                 * already in the normal case, but since we were looking
+                 * for an optional field, and we did not find it, we only
+                 * now realize we need to save the tag.
+                 */
+                unsigned char identifier;
+
+                /*
+                 * Check that we did not end up with a high tag; for that
+                 * we need to re-encode the tag into multiple bytes in order
+                 * to store it back to look like what we parsed originally.
+                 * In practice this does not happen, but for completeness
+                 * sake it should probably be made to work at some point.
+                 */
+                if (child_found_tag_modifiers >= SEC_ASN1_HIGH_TAG_NUMBER) {
+                    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
+                    state->top->status = decodeError;
+                } else {
+                    identifier = (unsigned char)(child_found_tag_modifiers | child_found_tag_number);
+                    sec_asn1d_record_any_header(child, (char *)&identifier, 1);
+                }
+            }
+        }
+    }
+}
+
+static void
+sec_asn1d_concat_substrings(sec_asn1d_state *state)
+{
+    PORT_Assert(state->place == afterConstructedString);
+
+    if (state->subitems_head != NULL) {
+        struct subitem *substring;
+        unsigned long alloc_len, item_len;
+        unsigned char *where;
+        SECItem *item;
+        PRBool is_bit_string;
+
+        item_len = 0;
+        is_bit_string = (state->underlying_kind == SEC_ASN1_BIT_STRING)
+                            ? PR_TRUE
+                            : PR_FALSE;
+
+        substring = state->subitems_head;
+        while (substring != NULL) {
+            /*
+             * All bit-string substrings except the last one should be
+             * a clean multiple of 8 bits.
+             */
+            if (is_bit_string && (substring->next != NULL) && (substring->len & 0x7)) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                return;
+            }
+            item_len += substring->len;
+            substring = substring->next;
+        }
+
+        if (is_bit_string) {
+            alloc_len = ((item_len + 7) >> 3);
+        } else {
+            /*
+             * Add 2 for the end-of-contents octets of an indefinite-length
+             * ANY that is *not* also an INNER.  Because we zero-allocate
+             * below, all we need to do is increase the length here.
+             */
+            if (state->underlying_kind == SEC_ASN1_ANY && state->indefinite)
+                item_len += 2;
+            alloc_len = item_len;
+        }
+
+        if (state->top->max_element_size > 0 &&
+            alloc_len > state->top->max_element_size) {
+            PORT_SetError(SEC_ERROR_OUTPUT_LEN);
+            state->top->status = decodeError;
+            return;
+        }
+
+        item = (SECItem *)(state->dest);
+        PORT_Assert(item != NULL);
+        PORT_Assert(item->data == NULL);
+        item->data = (unsigned char *)sec_asn1d_zalloc(state->top->their_pool,
+                                                       alloc_len);
+        if (item->data == NULL) {
+            state->top->status = decodeError;
+            return;
+        }
+        item->len = item_len;
+
+        where = item->data;
+        substring = state->subitems_head;
+        while (substring != NULL) {
+            if (is_bit_string)
+                item_len = (substring->len + 7) >> 3;
+            else
+                item_len = substring->len;
+            PORT_Memcpy(where, substring->data, item_len);
+            where += item_len;
+            substring = substring->next;
+        }
+
+        /*
+         * Because we use arenas and have a mark set, we later free
+         * everything we have allocated, so this does *not* present
+         * a memory leak (it is just temporarily left dangling).
+         */
+        state->subitems_head = state->subitems_tail = NULL;
+    }
+
+    state->place = afterEndOfContents;
+}
+
+static void
+sec_asn1d_concat_group(sec_asn1d_state *state)
+{
+    const void ***placep;
+
+    PORT_Assert(state->place == afterGroup);
+
+    placep = (const void ***)state->dest;
+    PORT_Assert(state->subitems_head == NULL || placep != NULL);
+    if (placep != NULL) {
+        struct subitem *item;
+        const void **group;
+        int count;
+
+        count = 0;
+        item = state->subitems_head;
+        while (item != NULL) {
+            PORT_Assert(item->next != NULL || item == state->subitems_tail);
+            count++;
+            item = item->next;
+        }
+
+        group = (const void **)sec_asn1d_zalloc(state->top->their_pool,
+                                                (count + 1) * (sizeof(void *)));
+        if (group == NULL) {
+            state->top->status = decodeError;
+            return;
+        }
+
+        *placep = group;
+
+        item = state->subitems_head;
+        while (item != NULL) {
+            *group++ = item->data;
+            item = item->next;
+        }
+        *group = NULL;
+
+        /*
+         * Because we use arenas and have a mark set, we later free
+         * everything we have allocated, so this does *not* present
+         * a memory leak (it is just temporarily left dangling).
+         */
+        state->subitems_head = state->subitems_tail = NULL;
+    }
+
+    state->place = afterEndOfContents;
+}
+
+/*
+ * For those states that push a child to handle a subtemplate,
+ * "absorb" that child (transfer necessary information).
+ */
+static void
+sec_asn1d_absorb_child(sec_asn1d_state *state)
+{
+    /*
+     * There is absolutely supposed to be a child there.
+     */
+    PORT_Assert(state->child != NULL);
+
+    /*
+     * Inherit the missing status of our child, and do the ugly
+     * backing-up if necessary.
+     */
+    state->missing = state->child->missing;
+    if (state->missing) {
+        state->found_tag_number = state->child->found_tag_number;
+        state->found_tag_modifiers = state->child->found_tag_modifiers;
+        state->endofcontents = state->child->endofcontents;
+    }
+
+    /*
+     * Add in number of bytes consumed by child.
+     * (Only EXPLICIT should have already consumed bytes itself.)
+     */
+    PORT_Assert(state->place == afterExplicit || state->consumed == 0);
+    state->consumed += state->child->consumed;
+
+    /*
+     * Subtract from bytes pending; this only applies to a definite-length
+     * EXPLICIT field.
+     */
+    if (state->pending) {
+        PORT_Assert(!state->indefinite);
+        PORT_Assert(state->place == afterExplicit);
+
+        /*
+         * If we had a definite-length explicit, then what the child
+         * consumed should be what was left pending.
+         */
+        if (state->pending != state->child->consumed) {
+            if (state->pending < state->child->consumed) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                return;
+            }
+            /*
+             * Okay, this is a hack.  It *should* be an error whether
+             * pending is too big or too small, but it turns out that
+             * we had a bug in our *old* DER encoder that ended up
+             * counting an explicit header twice in the case where
+             * the underlying type was an ANY.  So, because we cannot
+             * prevent receiving these (our own certificate server can
+             * send them to us), we need to be lenient and accept them.
+             * To do so, we need to pretend as if we read all of the
+             * bytes that the header said we would find, even though
+             * we actually came up short.
+             */
+            state->consumed += (state->pending - state->child->consumed);
+        }
+        state->pending = 0;
+    }
+
+    /*
+     * Indicate that we are done with child.
+     */
+    state->child->consumed = 0;
+
+    /*
+     * And move on to final state.
+     * (Technically everybody could move to afterEndOfContents except
+     * for an indefinite-length EXPLICIT; for simplicity though we assert
+     * that but let the end-of-contents code do the real determination.)
+     */
+    PORT_Assert(state->place == afterExplicit || (!state->indefinite));
+    state->place = beforeEndOfContents;
+}
+
+static void
+sec_asn1d_prepare_for_end_of_contents(sec_asn1d_state *state)
+{
+    PORT_Assert(state->place == beforeEndOfContents);
+
+    if (state->indefinite) {
+        state->place = duringEndOfContents;
+        state->pending = 2;
+    } else {
+        state->place = afterEndOfContents;
+    }
+}
+
+static unsigned long
+sec_asn1d_parse_end_of_contents(sec_asn1d_state *state,
+                                const char *buf, unsigned long len)
+{
+    unsigned int i;
+
+    PORT_Assert(state->pending <= 2);
+    PORT_Assert(state->place == duringEndOfContents);
+
+    if (len == 0) {
+        state->top->status = needBytes;
+        return 0;
+    }
+
+    if (state->pending < len)
+        len = state->pending;
+
+    for (i = 0; i < len; i++) {
+        if (buf[i] != 0) {
+            /*
+             * We expect to find only zeros; if not, just give up.
+             */
+            PORT_SetError(SEC_ERROR_BAD_DER);
+            state->top->status = decodeError;
+            return 0;
+        }
+    }
+
+    state->pending -= len;
+
+    if (state->pending == 0) {
+        state->place = afterEndOfContents;
+        /* These end-of-contents octets either terminate a SEQUENCE, a GROUP,
+         * or a constructed string. The SEQUENCE case is unique in that the
+         * state parses its own end-of-contents octets and therefore should not
+         * have its `endofcontents` flag set. We identify the SEQUENCE case by
+         * checking whether the child state's template is pointing at a
+         * template terminator (see `sec_asn1d_next_in_sequence`).
+         */
+        if (state->child && state->child->theTemplate->kind == 0) {
+            state->endofcontents = PR_FALSE;
+        } else {
+            state->endofcontents = PR_TRUE;
+        }
+    }
+
+    return len;
+}
+
+static void
+sec_asn1d_pop_state(sec_asn1d_state *state)
+{
+#if 0  /* XXX I think this should always be handled explicitly by parent? */
+    /*
+     * Account for our child.
+     */
+    if (state->child != NULL) {
+    state->consumed += state->child->consumed;
+    if (state->pending) {
+        PORT_Assert (!state->indefinite);
+        if (state->child->consumed > state->pending) {
+        PORT_SetError (SEC_ERROR_BAD_DER);
+        state->top->status = decodeError;
+        } else {
+        state->pending -= state->child->consumed;
+        }
+    }
+    state->child->consumed = 0;
+    }
+#endif /* XXX */
+
+    /*
+     * Free our child.
+     */
+    sec_asn1d_free_child(state, PR_FALSE);
+
+    /*
+     * Just make my parent be the current state.  It will then clean
+     * up after me and free me (or reuse me).
+     */
+    state->top->current = state->parent;
+}
+
+static sec_asn1d_state *
+sec_asn1d_before_choice(sec_asn1d_state *state)
+{
+    sec_asn1d_state *child;
+
+    if (state->allocate) {
+        void *dest;
+
+        dest = sec_asn1d_zalloc(state->top->their_pool, state->theTemplate->size);
+        if ((void *)NULL == dest) {
+            state->top->status = decodeError;
+            return (sec_asn1d_state *)NULL;
+        }
+
+        state->dest = (char *)dest + state->theTemplate->offset;
+    }
+
+    child = sec_asn1d_push_state(state->top, state->theTemplate + 1,
+                                 (char *)state->dest - state->theTemplate->offset,
+                                 PR_FALSE);
+    if ((sec_asn1d_state *)NULL == child) {
+        return (sec_asn1d_state *)NULL;
+    }
+
+    sec_asn1d_scrub_state(child);
+    child = sec_asn1d_init_state_based_on_template(child);
+    if ((sec_asn1d_state *)NULL == child) {
+        return (sec_asn1d_state *)NULL;
+    }
+
+    child->optional = PR_TRUE;
+
+    state->place = duringChoice;
+
+    return child;
+}
+
+static sec_asn1d_state *
+sec_asn1d_during_choice(sec_asn1d_state *state)
+{
+    sec_asn1d_state *child = state->child;
+
+    PORT_Assert((sec_asn1d_state *)NULL != child);
+
+    if (child->missing) {
+        unsigned char child_found_tag_modifiers = 0;
+        unsigned long child_found_tag_number = 0;
+        void *dest;
+
+        state->consumed += child->consumed;
+
+        if (child->endofcontents) {
+            /* This choice is probably the first item in a GROUP
+            ** (e.g. SET_OF) that was indefinite-length encoded.
+            ** We're actually at the end of that GROUP.
+            ** We look up the stack to be sure that we find
+            ** a state with indefinite length encoding before we
+            ** find a state (like a SEQUENCE) that is definite.
+            */
+            child->place = notInUse;
+            state->place = afterChoice;
+            state->endofcontents = PR_TRUE; /* propagate this up */
+            if (sec_asn1d_parent_allows_EOC(state))
+                return state;
+            PORT_SetError(SEC_ERROR_BAD_DER);
+            state->top->status = decodeError;
+            return NULL;
+        }
+
+        dest = (char *)child->dest - child->theTemplate->offset;
+        child->theTemplate++;
+
+        if (0 == child->theTemplate->kind) {
+            /* Ran out of choices */
+            PORT_SetError(SEC_ERROR_BAD_DER);
+            state->top->status = decodeError;
+            return (sec_asn1d_state *)NULL;
+        }
+        child->dest = (char *)dest + child->theTemplate->offset;
+
+        /* cargo'd from next_in_sequence innards */
+        if (state->pending) {
+            PORT_Assert(!state->indefinite);
+            if (child->consumed > state->pending) {
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                return NULL;
+            }
+            state->pending -= child->consumed;
+            if (0 == state->pending) {
+                /* XXX uh.. not sure if I should have stopped this
+                 * from happening before. */
+                PORT_Assert(0);
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                state->top->status = decodeError;
+                return (sec_asn1d_state *)NULL;
+            }
+        }
+
+        child->consumed = 0;
+        sec_asn1d_scrub_state(child);
+
+        /* move it on top again */
+        state->top->current = child;
+
+        child_found_tag_modifiers = child->found_tag_modifiers;
+        child_found_tag_number = child->found_tag_number;
+
+        child = sec_asn1d_init_state_based_on_template(child);
+        if ((sec_asn1d_state *)NULL == child) {
+            return (sec_asn1d_state *)NULL;
+        }
+
+        /* copy our findings to the new top */
+        child->found_tag_modifiers = child_found_tag_modifiers;
+        child->found_tag_number = child_found_tag_number;
+
+        child->optional = PR_TRUE;
+        child->place = afterIdentifier;
+
+        return child;
+    }
+    if ((void *)NULL != state->dest) {
+        /* Store the enum */
+        int *which = (int *)state->dest;
+        *which = (int)child->theTemplate->size;
+    }
+
+    child->place = notInUse;
+
+    state->place = afterChoice;
+    return state;
+}
+
+static void
+sec_asn1d_after_choice(sec_asn1d_state *state)
+{
+    state->consumed += state->child->consumed;
+    state->child->consumed = 0;
+    state->place = afterEndOfContents;
+    sec_asn1d_pop_state(state);
+}
+
+unsigned long
+sec_asn1d_uinteger(SECItem *src)
+{
+    unsigned long value;
+    int len;
+
+    if (src->len > 5 || (src->len > 4 && src->data[0] == 0))
+        return 0;
+
+    value = 0;
+    len = src->len;
+    while (len) {
+        value <<= 8;
+        value |= src->data[--len];
+    }
+    return value;
+}
+
+SECStatus
+SEC_ASN1DecodeInteger(SECItem *src, unsigned long *value)
+{
+    unsigned long v;
+    unsigned int i;
+
+    if (src == NULL) {
+        PORT_SetError(SEC_ERROR_INVALID_ARGS);
+        return SECFailure;
+    }
+
+    if (src->len > sizeof(unsigned long)) {
+        PORT_SetError(SEC_ERROR_INVALID_ARGS);
+        return SECFailure;
+    }
+
+    if (src->data == NULL) {
+        PORT_SetError(SEC_ERROR_INVALID_ARGS);
+        return SECFailure;
+    }
+
+    if (src->data[0] & 0x80)
+        v = -1; /* signed and negative - start with all 1's */
+    else
+        v = 0;
+
+    for (i = 0; i < src->len; i++) {
+        /* shift in next byte */
+        v <<= 8;
+        v |= src->data[i];
+    }
+    *value = v;
+    return SECSuccess;
+}
+
+#ifdef DEBUG_ASN1D_STATES
+static void
+dump_states(SEC_ASN1DecoderContext *cx)
+{
+    sec_asn1d_state *state;
+    int bufsize = 256;
+    char kindBuf[bufsize];
+
+    for (state = cx->current; state->parent; state = state->parent) {
+        ;
+    }
+
+    for (; state; state = state->child) {
+        int i;
+        for (i = 0; i < state->depth; i++) {
+            printf("  ");
+        }
+
+        i = formatKind(state->theTemplate->kind, kindBuf, bufsize);
+        printf("%s: tmpl kind %s",
+               (state == cx->current) ? "STATE" : "State",
+               kindBuf);
+        printf(" %s", (state->place >= 0 && state->place <= notInUse) ? place_names[state->place] : "(undefined)");
+        if (!i)
+            printf(", expect 0x%02lx",
+                   state->expect_tag_number | state->expect_tag_modifiers);
+
+        printf("%s%s%s %lu\n",
+               state->indefinite ? ", indef" : "",
+               state->missing ? ", miss" : "",
+               state->endofcontents ? ", EOC" : "",
+               state->pending);
+    }
+
+    return;
+}
+#endif /* DEBUG_ASN1D_STATES */
+
+SECStatus
+SEC_ASN1DecoderUpdate(SEC_ASN1DecoderContext *cx,
+                      const char *buf, unsigned long len)
+{
+    sec_asn1d_state *state = NULL;
+    unsigned long consumed;
+    SEC_ASN1EncodingPart what;
+
+    if (cx->status == needBytes)
+        cx->status = keepGoing;
+
+    while (cx->status == keepGoing) {
+        state = cx->current;
+        what = SEC_ASN1_Contents;
+        consumed = 0;
+#ifdef DEBUG_ASN1D_STATES
+        printf("\nPLACE = %s, next byte = 0x%02x, %p[%lu]\n",
+               (state->place >= 0 && state->place <= notInUse) ? place_names[state->place] : "(undefined)",
+               len ? (unsigned int)((unsigned char *)buf)[consumed] : 0,
+               buf, consumed);
+        dump_states(cx);
+#endif /* DEBUG_ASN1D_STATES */
+        switch (state->place) {
+            case beforeIdentifier:
+                consumed = sec_asn1d_parse_identifier(state, buf, len);
+                what = SEC_ASN1_Identifier;
+                break;
+            case duringIdentifier:
+                consumed = sec_asn1d_parse_more_identifier(state, buf, len);
+                what = SEC_ASN1_Identifier;
+                break;
+            case afterIdentifier:
+                sec_asn1d_confirm_identifier(state);
+                break;
+            case beforeLength:
+                consumed = sec_asn1d_parse_length(state, buf, len);
+                what = SEC_ASN1_Length;
+                break;
+            case duringLength:
+                consumed = sec_asn1d_parse_more_length(state, buf, len);
+                what = SEC_ASN1_Length;
+                break;
+            case afterLength:
+                sec_asn1d_prepare_for_contents(state);
+                break;
+            case beforeBitString:
+                consumed = sec_asn1d_parse_bit_string(state, buf, len);
+                break;
+            case duringBitString:
+                consumed = sec_asn1d_parse_more_bit_string(state, buf, len);
+                break;
+            case duringConstructedString:
+                sec_asn1d_next_substring(state);
+                break;
+            case duringGroup:
+                sec_asn1d_next_in_group(state);
+                break;
+            case duringLeaf:
+                consumed = sec_asn1d_parse_leaf(state, buf, len);
+                break;
+            case duringSaveEncoding:
+                sec_asn1d_reuse_encoding(state);
+                if (cx->status == decodeError) {
+                    /* recursive call has already popped all states from stack.
+                    ** Bail out quickly.
+                    */
+                    return SECFailure;
+                }
+                if (cx->status == needBytes) {
+                    /* recursive call wanted more data. Fatal. Clean up below. */
+                    PORT_SetError(SEC_ERROR_BAD_DER);
+                    cx->status = decodeError;
+                }
+                break;
+            case duringSequence:
+                sec_asn1d_next_in_sequence(state);
+                break;
+            case afterConstructedString:
+                sec_asn1d_concat_substrings(state);
+                break;
+            case afterExplicit:
+            case afterImplicit:
+            case afterInline:
+            case afterPointer:
+                sec_asn1d_absorb_child(state);
+                break;
+            case afterGroup:
+                sec_asn1d_concat_group(state);
+                break;
+            case afterSaveEncoding:
+                /* SEC_ASN1DecoderUpdate has called itself recursively to
+                ** decode SAVEd encoded data, and now is done decoding that.
+                ** Return to the calling copy of SEC_ASN1DecoderUpdate.
+                */
+                return SECSuccess;
+            case beforeEndOfContents:
+                sec_asn1d_prepare_for_end_of_contents(state);
+                break;
+            case duringEndOfContents:
+                consumed = sec_asn1d_parse_end_of_contents(state, buf, len);
+                what = SEC_ASN1_EndOfContents;
+                break;
+            case afterEndOfContents:
+                sec_asn1d_pop_state(state);
+                break;
+            case beforeChoice:
+                state = sec_asn1d_before_choice(state);
+                break;
+            case duringChoice:
+                state = sec_asn1d_during_choice(state);
+                break;
+            case afterChoice:
+                sec_asn1d_after_choice(state);
+                break;
+            case notInUse:
+            default:
+                /* This is not an error, but rather a plain old BUG! */
+                PORT_Assert(0);
+                PORT_SetError(SEC_ERROR_BAD_DER);
+                cx->status = decodeError;
+                break;
+        }
+
+        if (cx->status == decodeError)
+            break;
+
+        /* We should not consume more than we have.  */
+        PORT_Assert(consumed <= len);
+        if (consumed > len) {
+            PORT_SetError(SEC_ERROR_BAD_DER);
+            cx->status = decodeError;
+            break;
+        }
+
+        /* It might have changed, so we have to update our local copy.  */
+        state = cx->current;
+
+        /* If it is NULL, we have popped all the way to the top.  */
+        if (state == NULL) {
+            PORT_Assert(consumed == 0);
+#if 0 /* XXX I want this here, but it seems that we have situations (like \
+       * downloading a pkcs7 cert chain from some issuers) that give us a \
+       * length which is greater than the entire encoding.  So, we cannot \
+       * have this be an error.                                           \
+       */
+        if (len > 0) {
+        PORT_SetError (SEC_ERROR_BAD_DER);
+        cx->status = decodeError;
+        } else
+#endif
+            cx->status = allDone;
+            break;
+        } else if (state->theTemplate->kind == SEC_ASN1_SKIP_REST) {
+            cx->status = allDone;
+            break;
+        }
+
+        if (consumed == 0)
+            continue;
+
+        /*
+         * The following check is specifically looking for an ANY
+         * that is *not* also an INNER, because we need to save aside
+         * all bytes in that case -- the contents parts will get
+         * handled like all other contents, and the end-of-contents
+         * bytes are added by the concat code, but the outer header
+         * bytes need to get saved too, so we do them explicitly here.
+         */
+        if (state->underlying_kind == SEC_ASN1_ANY && !cx->filter_only && (what == SEC_ASN1_Identifier || what == SEC_ASN1_Length)) {
+            sec_asn1d_record_any_header(state, buf, consumed);
+        }
+
+        /*
+         * We had some number of good, accepted bytes.  If the caller
+         * has registered to see them, pass them along.
+         */
+        if (state->top->filter_proc != NULL) {
+            int depth;
+
+            depth = state->depth;
+            if (what == SEC_ASN1_EndOfContents && !state->indefinite) {
+                PORT_Assert(state->parent != NULL && state->parent->indefinite);
+                depth--;
+                PORT_Assert(depth == state->parent->depth);
+            }
+            (*state->top->filter_proc)(state->top->filter_arg,
+                                       buf, consumed, depth, what);
+        }
+
+        state->consumed += consumed;
+        buf += consumed;
+        len -= consumed;
+    }
+
+    if (cx->status == decodeError) {
+        while (state != NULL) {
+            sec_asn1d_free_child(state, PR_TRUE);
+            state = state->parent;
+        }
+#ifdef SEC_ASN1D_FREE_ON_ERROR /*                                           \
+                                * XXX This does not work because we can     \
+                                * end up leaving behind dangling pointers   \
+                                * to stuff that was allocated.  In order    \
+                                * to make this really work (which would     \
+                                * be a good thing, I think), we need to     \
+                                * keep track of every place/pointer that    \
+                                * was allocated and make sure to NULL it    \
+                                * out before we then free back to the mark. \
+                                */
+        if (cx->their_pool != NULL) {
+            PORT_Assert(cx->their_mark != NULL);
+            PORT_ArenaRelease(cx->their_pool, cx->their_mark);
+            cx->their_mark = NULL;
+        }
+#endif
+        return SECFailure;
+    }
+
+#if 0 /* XXX This is what I want, but cannot have because it seems we    \
+       * have situations (like when downloading a pkcs7 cert chain from  \
+       * some issuers) that give us a total length which is greater than \
+       * the entire encoding.  So, we have to allow allDone to have a    \
+       * remaining length greater than zero.  I wanted to catch internal \
+       * bugs with this, noticing when we do not have the right length.  \
+       * Oh well.                                                        \
+       */
+    PORT_Assert (len == 0
+         && (cx->status == needBytes || cx->status == allDone));
+#else
+    PORT_Assert((len == 0 && cx->status == needBytes) || cx->status == allDone);
+#endif
+    return SECSuccess;
+}
+
+SECStatus
+SEC_ASN1DecoderFinish(SEC_ASN1DecoderContext *cx)
+{
+    SECStatus rv;
+
+    if (!cx || cx->status == needBytes) {
+        PORT_SetError(SEC_ERROR_BAD_DER);
+        rv = SECFailure;
+    } else {
+        rv = SECSuccess;
+    }
+
+    /*
+     * XXX anything else that needs to be finished?
+     */
+
+    if (cx) {
+        PORT_FreeArena(cx->our_pool, PR_TRUE);
+    }
+
+    return rv;
+}
+
+SEC_ASN1DecoderContext *
+SEC_ASN1DecoderStart(PLArenaPool *their_pool, void *dest,
+                     const SEC_ASN1Template *theTemplate)
+{
+    PLArenaPool *our_pool;
+    SEC_ASN1DecoderContext *cx;
+
+    our_pool = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE);
+    if (our_pool == NULL)
+        return NULL;
+
+    cx = (SEC_ASN1DecoderContext *)PORT_ArenaZAlloc(our_pool, sizeof(*cx));
+    if (cx == NULL) {
+        PORT_FreeArena(our_pool, PR_FALSE);
+        return NULL;
+    }
+
+    cx->our_pool = our_pool;
+    if (their_pool != NULL) {
+        cx->their_pool = their_pool;
+#ifdef SEC_ASN1D_FREE_ON_ERROR
+        cx->their_mark = PORT_ArenaMark(their_pool);
+#endif
+    }
+
+    cx->status = needBytes;
+
+    if (sec_asn1d_push_state(cx, theTemplate, dest, PR_FALSE) == NULL || sec_asn1d_init_state_based_on_template(cx->current) == NULL) {
+        /*
+         * Trouble initializing (probably due to failed allocations)
+         * requires that we just give up.
+         */
+        PORT_FreeArena(our_pool, PR_FALSE);
+        return NULL;
+    }
+
+    return cx;
+}
+
+void
+SEC_ASN1DecoderSetFilterProc(SEC_ASN1DecoderContext *cx,
+                             SEC_ASN1WriteProc fn, void *arg,
+                             PRBool only)
+{
+    /* check that we are "between" fields here */
+    PORT_Assert(cx->during_notify);
+
+    cx->filter_proc = fn;
+    cx->filter_arg = arg;
+    cx->filter_only = only;
+}
+
+void
+SEC_ASN1DecoderClearFilterProc(SEC_ASN1DecoderContext *cx)
+{
+    /* check that we are "between" fields here */
+    PORT_Assert(cx->during_notify);
+
+    cx->filter_proc = NULL;
+    cx->filter_arg = NULL;
+    cx->filter_only = PR_FALSE;
+}
+
+void
+SEC_ASN1DecoderSetNotifyProc(SEC_ASN1DecoderContext *cx,
+                             SEC_ASN1NotifyProc fn, void *arg)
+{
+    cx->notify_proc = fn;
+    cx->notify_arg = arg;
+}
+
+void
+SEC_ASN1DecoderClearNotifyProc(SEC_ASN1DecoderContext *cx)
+{
+    cx->notify_proc = NULL;
+    cx->notify_arg = NULL; /* not necessary; just being clean */
+}
+
+void
+SEC_ASN1DecoderSetMaximumElementSize(SEC_ASN1DecoderContext *cx,
+                                     unsigned long max_size)
+{
+    cx->max_element_size = max_size;
+}
+
+void
+SEC_ASN1DecoderAbort(SEC_ASN1DecoderContext *cx, int error)
+{
+    PORT_Assert(cx);
+    PORT_SetError(error);
+    cx->status = decodeError;
+}
+
+SECStatus
+SEC_ASN1Decode(PLArenaPool *poolp, void *dest,
+               const SEC_ASN1Template *theTemplate,
+               const char *buf, long len)
+{
+    SEC_ASN1DecoderContext *dcx;
+    SECStatus urv, frv;
+
+    dcx = SEC_ASN1DecoderStart(poolp, dest, theTemplate);
+    if (dcx == NULL)
+        return SECFailure;
+
+    /* In one-shot mode, there's no possibility of streaming data beyond the
+     * length of len */
+    SEC_ASN1DecoderSetMaximumElementSize(dcx, len);
+
+    urv = SEC_ASN1DecoderUpdate(dcx, buf, len);
+    frv = SEC_ASN1DecoderFinish(dcx);
+
+    if (urv != SECSuccess)
+        return urv;
+
+    return frv;
+}
+
+SECStatus
+SEC_ASN1DecodeItem(PLArenaPool *poolp, void *dest,
+                   const SEC_ASN1Template *theTemplate,
+                   const SECItem *src)
+{
+    return SEC_ASN1Decode(poolp, dest, theTemplate,
+                          (const char *)src->data, src->len);
+}
+
+#ifdef DEBUG_ASN1D_STATES
+void
+sec_asn1d_Assert(const char *s, const char *file, PRIntn ln)
+{
+    printf("Assertion failed, \"%s\", file %s, line %d\n", s, file, ln);
+    fflush(stdout);
+}
+#endif
+
+/*
+ * Generic templates for individual/simple items and pointers to
+ * and sets of same.
+ *
+ * If you need to add a new one, please note the following:
+ *   - For each new basic type you should add *four* templates:
+ *  one plain, one PointerTo, one SequenceOf and one SetOf.
+ *   - If the new type can be constructed (meaning, it is a
+ *  *string* type according to BER/DER rules), then you should
+ *  or-in SEC_ASN1_MAY_STREAM to the type in the basic template.
+ *  See the definition of the OctetString template for an example.
+ *   - It may not be obvious, but these are in *alphabetical*
+ *  order based on the SEC_ASN1_XXX name; so put new ones in
+ *  the appropriate place.
+ */
+
+const SEC_ASN1Template SEC_SequenceOfAnyTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_AnyTemplate }
+};
+
+#if 0
+
+const SEC_ASN1Template SEC_PointerToBitStringTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_BitStringTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfBitStringTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_BitStringTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfBitStringTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_BitStringTemplate }
+};
+
+const SEC_ASN1Template SEC_PointerToBMPStringTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_BMPStringTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfBMPStringTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_BMPStringTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfBMPStringTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_BMPStringTemplate }
+};
+
+const SEC_ASN1Template SEC_PointerToBooleanTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_BooleanTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfBooleanTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_BooleanTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfBooleanTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_BooleanTemplate }
+};
+
+#endif
+
+const SEC_ASN1Template SEC_EnumeratedTemplate[] = {
+    { SEC_ASN1_ENUMERATED, 0, NULL, sizeof(SECItem) }
+};
+
+const SEC_ASN1Template SEC_PointerToEnumeratedTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_EnumeratedTemplate }
+};
+
+#if 0
+
+const SEC_ASN1Template SEC_SequenceOfEnumeratedTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_EnumeratedTemplate }
+};
+
+#endif
+
+const SEC_ASN1Template SEC_SetOfEnumeratedTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_EnumeratedTemplate }
+};
+
+const SEC_ASN1Template SEC_PointerToGeneralizedTimeTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_GeneralizedTimeTemplate }
+};
+
+#if 0
+
+const SEC_ASN1Template SEC_SequenceOfGeneralizedTimeTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_GeneralizedTimeTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfGeneralizedTimeTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_GeneralizedTimeTemplate }
+};
+
+const SEC_ASN1Template SEC_PointerToIA5StringTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_IA5StringTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfIA5StringTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_IA5StringTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfIA5StringTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_IA5StringTemplate }
+};
+
+const SEC_ASN1Template SEC_PointerToIntegerTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_IntegerTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfIntegerTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_IntegerTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfIntegerTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_IntegerTemplate }
+};
+
+const SEC_ASN1Template SEC_PointerToNullTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_NullTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfNullTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_NullTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfNullTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_NullTemplate }
+};
+
+const SEC_ASN1Template SEC_PointerToObjectIDTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_ObjectIDTemplate }
+};
+
+#endif
+
+const SEC_ASN1Template SEC_SequenceOfObjectIDTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_ObjectIDTemplate }
+};
+
+#if 0
+
+const SEC_ASN1Template SEC_SetOfObjectIDTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_ObjectIDTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfOctetStringTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_OctetStringTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfOctetStringTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_OctetStringTemplate }
+};
+
+#endif
+
+const SEC_ASN1Template SEC_PrintableStringTemplate[] = {
+    { SEC_ASN1_PRINTABLE_STRING | SEC_ASN1_MAY_STREAM, 0, NULL, sizeof(SECItem) }
+};
+
+#if 0
+
+const SEC_ASN1Template SEC_PointerToPrintableStringTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_PrintableStringTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfPrintableStringTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_PrintableStringTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfPrintableStringTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_PrintableStringTemplate }
+};
+
+#endif
+
+const SEC_ASN1Template SEC_T61StringTemplate[] = {
+    { SEC_ASN1_T61_STRING | SEC_ASN1_MAY_STREAM, 0, NULL, sizeof(SECItem) }
+};
+
+#if 0
+
+const SEC_ASN1Template SEC_PointerToT61StringTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_T61StringTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfT61StringTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_T61StringTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfT61StringTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_T61StringTemplate }
+};
+
+#endif
+
+const SEC_ASN1Template SEC_UniversalStringTemplate[] = {
+    { SEC_ASN1_UNIVERSAL_STRING | SEC_ASN1_MAY_STREAM, 0, NULL, sizeof(SECItem) }
+};
+
+#if 0
+
+const SEC_ASN1Template SEC_PointerToUniversalStringTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_UniversalStringTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfUniversalStringTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_UniversalStringTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfUniversalStringTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_UniversalStringTemplate }
+};
+
+const SEC_ASN1Template SEC_PointerToUTCTimeTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_UTCTimeTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfUTCTimeTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_UTCTimeTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfUTCTimeTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_UTCTimeTemplate }
+};
+
+const SEC_ASN1Template SEC_PointerToUTF8StringTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_UTF8StringTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfUTF8StringTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_UTF8StringTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfUTF8StringTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_UTF8StringTemplate }
+};
+
+#endif
+
+const SEC_ASN1Template SEC_VisibleStringTemplate[] = {
+    { SEC_ASN1_VISIBLE_STRING | SEC_ASN1_MAY_STREAM, 0, NULL, sizeof(SECItem) }
+};
+
+#if 0
+
+const SEC_ASN1Template SEC_PointerToVisibleStringTemplate[] = {
+    { SEC_ASN1_POINTER, 0, SEC_VisibleStringTemplate }
+};
+
+const SEC_ASN1Template SEC_SequenceOfVisibleStringTemplate[] = {
+    { SEC_ASN1_SEQUENCE_OF, 0, SEC_VisibleStringTemplate }
+};
+
+const SEC_ASN1Template SEC_SetOfVisibleStringTemplate[] = {
+    { SEC_ASN1_SET_OF, 0, SEC_VisibleStringTemplate }
+};
+
+#endif
+
+/*
+ * Template for skipping a subitem.
+ *
+ * Note that it only makes sense to use this for decoding (when you want
+ * to decode something where you are only interested in one or two of
+ * the fields); you cannot encode a SKIP!
+ */
+const SEC_ASN1Template SEC_SkipTemplate[] = {
+    { SEC_ASN1_SKIP }
+};
+
+/* These functions simply return the address of the above-declared templates.
+** This is necessary for Windows DLLs.  Sigh.
+*/
+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)