Add m-esr52 at 52.6.0

1 files changed, 1568 insertions, 0 deletions

diff --git a/security/nss/lib/util/secasn1e.c b/security/nss/lib/util/secasn1e.c
new file mode 100644
index 000000000..fb3feef52
--- /dev/null
+++ b/security/nss/lib/util/secasn1e.c
@@ -0,0 +1,1568 @@
+/* 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 ENcoding ASN.1 data based on BER/DER (Basic/Distinguished
+ * Encoding Rules).
+ */
+
+#include "secasn1.h"
+
+typedef enum {
+    beforeHeader,
+    duringContents,
+    duringGroup,
+    duringSequence,
+    afterContents,
+    afterImplicit,
+    afterInline,
+    afterPointer,
+    afterChoice,
+    notInUse
+} sec_asn1e_parse_place;
+
+typedef enum {
+    allDone,
+    encodeError,
+    keepGoing,
+    needBytes
+} sec_asn1e_parse_status;
+
+typedef enum {
+    hdr_normal = 0,     /* encode header normally */
+    hdr_any = 1,        /* header already encoded in content */
+    hdr_decoder = 2,    /* template only used by decoder. skip it. */
+    hdr_optional = 3,   /* optional component, to be omitted */
+    hdr_placeholder = 4 /* place holder for from_buf content */
+} sec_asn1e_hdr_encoding;
+
+typedef struct sec_asn1e_state_struct {
+    SEC_ASN1EncoderContext *top;
+    const SEC_ASN1Template *theTemplate;
+    void *src;
+
+    struct sec_asn1e_state_struct *parent; /* aka prev */
+    struct sec_asn1e_state_struct *child;  /* aka next */
+
+    sec_asn1e_parse_place place; /* where we are in encoding process */
+
+    /*
+     * XXX explain the next fields as clearly as possible...
+     */
+    unsigned char tag_modifiers;
+    unsigned char tag_number;
+    unsigned long underlying_kind;
+
+    int depth;
+
+    PRBool isExplicit,     /* we are handling an isExplicit header */
+        indefinite,        /* need end-of-contents */
+        is_string,         /* encoding a simple string or an ANY */
+        may_stream,        /* when streaming, do indefinite encoding */
+        optional,          /* omit field if it has no contents */
+        disallowStreaming; /* disallow streaming in all sub-templates */
+} sec_asn1e_state;
+
+/*
+ * An "outsider" will have an opaque pointer to this, created by calling
+ * SEC_ASN1EncoderStart().  It will be passed back in to all subsequent
+ * calls to SEC_ASN1EncoderUpdate() and related routines, and when done
+ * it is passed to SEC_ASN1EncoderFinish().
+ */
+struct sec_EncoderContext_struct {
+    PLArenaPool *our_pool; /* for our internal allocs */
+
+    sec_asn1e_state *current;
+    sec_asn1e_parse_status status;
+
+    PRBool streaming;
+    PRBool from_buf;
+
+    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 output_proc; /* pass encoded bytes to this  */
+    void *output_arg;              /* argument to that function */
+};
+
+static sec_asn1e_state *
+sec_asn1e_push_state(SEC_ASN1EncoderContext *cx,
+                     const SEC_ASN1Template *theTemplate,
+                     const void *src, PRBool new_depth)
+{
+    sec_asn1e_state *state, *new_state;
+
+    state = cx->current;
+
+    new_state = (sec_asn1e_state *)PORT_ArenaZAlloc(cx->our_pool,
+                                                    sizeof(*new_state));
+    if (new_state == NULL) {
+        cx->status = encodeError;
+        return NULL;
+    }
+
+    new_state->top = cx;
+    new_state->parent = state;
+    new_state->theTemplate = theTemplate;
+    new_state->place = notInUse;
+    if (src != NULL)
+        new_state->src = (char *)src + theTemplate->offset;
+
+    if (state != NULL) {
+        new_state->depth = state->depth;
+        if (new_depth)
+            new_state->depth++;
+        state->child = new_state;
+    }
+
+    cx->current = new_state;
+    return new_state;
+}
+
+static void
+sec_asn1e_scrub_state(sec_asn1e_state *state)
+{
+    /*
+     * Some default "scrubbing".
+     * XXX right set of initializations?
+     */
+    state->place = beforeHeader;
+    state->indefinite = PR_FALSE;
+}
+
+static void
+sec_asn1e_notify_before(SEC_ASN1EncoderContext *cx, void *src, int depth)
+{
+    if (cx->notify_proc == NULL)
+        return;
+
+    cx->during_notify = PR_TRUE;
+    (*cx->notify_proc)(cx->notify_arg, PR_TRUE, src, depth);
+    cx->during_notify = PR_FALSE;
+}
+
+static void
+sec_asn1e_notify_after(SEC_ASN1EncoderContext *cx, void *src, int depth)
+{
+    if (cx->notify_proc == NULL)
+        return;
+
+    cx->during_notify = PR_TRUE;
+    (*cx->notify_proc)(cx->notify_arg, PR_FALSE, src, depth);
+    cx->during_notify = PR_FALSE;
+}
+
+static sec_asn1e_state *
+sec_asn1e_init_state_based_on_template(sec_asn1e_state *state)
+{
+    PRBool isExplicit, is_string, may_stream, optional, universal;
+    PRBool disallowStreaming;
+    unsigned char tag_modifiers;
+    unsigned long encode_kind, under_kind;
+    unsigned long tag_number;
+    PRBool isInline = PR_FALSE;
+
+    encode_kind = state->theTemplate->kind;
+
+    universal = ((encode_kind & SEC_ASN1_CLASS_MASK) == SEC_ASN1_UNIVERSAL)
+                    ? PR_TRUE
+                    : PR_FALSE;
+
+    isExplicit = (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(!(isExplicit && universal)); /* bad templates */
+
+    may_stream = (encode_kind & SEC_ASN1_MAY_STREAM) ? PR_TRUE : PR_FALSE;
+    encode_kind &= ~SEC_ASN1_MAY_STREAM;
+
+    disallowStreaming = (encode_kind & SEC_ASN1_NO_STREAM) ? PR_TRUE : PR_FALSE;
+    encode_kind &= ~SEC_ASN1_NO_STREAM;
+
+    /* Just clear this to get it out of the way; we do not need it here */
+    encode_kind &= ~SEC_ASN1_DYNAMIC;
+
+    if (encode_kind & SEC_ASN1_CHOICE) {
+        under_kind = SEC_ASN1_CHOICE;
+    } else if ((encode_kind & (SEC_ASN1_POINTER | SEC_ASN1_INLINE)) ||
+               (!universal && !isExplicit)) {
+        const SEC_ASN1Template *subt;
+        void *src = NULL;
+
+        PORT_Assert((encode_kind & (SEC_ASN1_ANY | SEC_ASN1_SKIP)) == 0);
+
+        sec_asn1e_scrub_state(state);
+
+        if (encode_kind & SEC_ASN1_POINTER) {
+            src = *(void **)state->src;
+            state->place = afterPointer;
+
+            if (src == NULL) {
+                /*
+                 * If this is optional, but NULL, then the field does
+                 * not need to be encoded.  In this case we are done;
+                 * we do not want to push a subtemplate.
+                 */
+                if (optional)
+                    return state;
+
+                /*
+                 * XXX this is an error; need to figure out
+                 * how to handle this
+                 */
+            }
+        } else {
+            src = state->src;
+            if (encode_kind & SEC_ASN1_INLINE) {
+                /* check that there are no extraneous bits */
+                /* PORT_Assert (encode_kind == SEC_ASN1_INLINE && !optional); */
+                state->place = afterInline;
+                isInline = PR_TRUE;
+            } else {
+                /*
+                 * Save the tag modifiers and tag number here before moving
+                 * on to the next state in case this is a member of a
+                 * SEQUENCE OF
+                 */
+                state->tag_modifiers = (unsigned char)(encode_kind & (SEC_ASN1_TAG_MASK & ~SEC_ASN1_TAGNUM_MASK));
+                state->tag_number = (unsigned char)(encode_kind & SEC_ASN1_TAGNUM_MASK);
+
+                state->place = afterImplicit;
+                state->optional = optional;
+            }
+        }
+
+        subt = SEC_ASN1GetSubtemplate(state->theTemplate, state->src, PR_TRUE);
+        if (isInline && optional) {
+            /* we only handle a very limited set of optional inline cases at
+               this time */
+            if (PR_FALSE != SEC_ASN1IsTemplateSimple(subt)) {
+                /* we now know that the target is a SECItem*, so we can check
+                   if the source contains one */
+                SECItem *target = (SECItem *)state->src;
+                if (!target || !target->data || !target->len) {
+                    /* no valid data to encode subtemplate */
+                    return state;
+                }
+            } else {
+                PORT_Assert(0); /* complex templates are not handled as
+                                   inline optional */
+            }
+        }
+        state = sec_asn1e_push_state(state->top, subt, src, PR_FALSE);
+        if (state == NULL)
+            return state;
+
+        if (universal) {
+            /*
+             * This is a POINTER or INLINE; just init based on that
+             * and we are done.
+             */
+            return sec_asn1e_init_state_based_on_template(state);
+        }
+
+        /*
+         * This is an implicit, non-universal (meaning, application-private
+         * or context-specific) field.  This results in a "magic" tag but
+         * encoding based on the underlying type.  We pushed a new state
+         * that is based on the subtemplate (the underlying type), but
+         * now we will sort of alias it to give it some of our properties
+         * (tag, optional status, etc.).
+         *
+         * NB: ALL the following flags in the subtemplate are disallowed
+         *     and/or ignored: EXPLICIT, OPTIONAL, INNER, INLINE, POINTER.
+         */
+
+        under_kind = state->theTemplate->kind;
+        if ((under_kind & SEC_ASN1_MAY_STREAM) && !disallowStreaming) {
+            may_stream = PR_TRUE;
+        }
+        under_kind &= ~(SEC_ASN1_MAY_STREAM | SEC_ASN1_DYNAMIC);
+    } else {
+        under_kind = encode_kind;
+    }
+
+/*
+     * Sanity check that there are no unwanted bits marked in under_kind.
+     * These bits were either removed above (after we recorded them) or
+     * they simply should not be found (signalling a bad/broken template).
+     * XXX is this the right set of bits to test here? (i.e. need to add
+     * or remove any?)
+     */
+#define UNEXPECTED_FLAGS                                                      \
+    (SEC_ASN1_EXPLICIT | SEC_ASN1_OPTIONAL | SEC_ASN1_SKIP | SEC_ASN1_INNER | \
+     SEC_ASN1_DYNAMIC | SEC_ASN1_MAY_STREAM | SEC_ASN1_INLINE | SEC_ASN1_POINTER)
+
+    PORT_Assert((under_kind & UNEXPECTED_FLAGS) == 0);
+    under_kind &= ~UNEXPECTED_FLAGS;
+#undef UNEXPECTED_FLAGS
+
+    if (encode_kind & SEC_ASN1_ANY) {
+        PORT_Assert(encode_kind == under_kind);
+        tag_modifiers = 0;
+        tag_number = 0;
+        is_string = PR_TRUE;
+    } else {
+        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.
+         */
+        tag_number = encode_kind & SEC_ASN1_TAGNUM_MASK;
+
+        is_string = PR_FALSE;
+        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:
+                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:
+                /*
+                 * We do not yet know if we will be constructing the string,
+                 * so we have to wait to do this final tag modification.
+                 */
+                is_string = PR_TRUE;
+                break;
+        }
+    }
+
+    state->tag_modifiers = tag_modifiers;
+    state->tag_number = (unsigned char)tag_number;
+    state->underlying_kind = under_kind;
+    state->isExplicit = isExplicit;
+    state->may_stream = may_stream;
+    state->is_string = is_string;
+    state->optional = optional;
+    state->disallowStreaming = disallowStreaming;
+
+    sec_asn1e_scrub_state(state);
+
+    return state;
+}
+
+static void
+sec_asn1e_write_part(sec_asn1e_state *state,
+                     const char *buf, unsigned long len,
+                     SEC_ASN1EncodingPart part)
+{
+    SEC_ASN1EncoderContext *cx;
+
+    cx = state->top;
+    (*cx->output_proc)(cx->output_arg, buf, len, state->depth, part);
+}
+
+/*
+ * XXX This assumes only single-octet identifiers.  To handle
+ * the HIGH TAG form we would need to modify this interface and
+ * teach it to properly encode the special form.
+ */
+static void
+sec_asn1e_write_identifier_bytes(sec_asn1e_state *state, unsigned char value)
+{
+    char byte;
+
+    byte = (char)value;
+    sec_asn1e_write_part(state, &byte, 1, SEC_ASN1_Identifier);
+}
+
+int
+SEC_ASN1EncodeLength(unsigned char *buf, int value)
+{
+    int lenlen;
+
+    lenlen = SEC_ASN1LengthLength(value);
+    if (lenlen == 1) {
+        buf[0] = value;
+    } else {
+        int i;
+
+        i = lenlen - 1;
+        buf[0] = 0x80 | i;
+        while (i) {
+            buf[i--] = value;
+            value >>= 8;
+        }
+        PORT_Assert(value == 0);
+    }
+    return lenlen;
+}
+
+static void
+sec_asn1e_write_length_bytes(sec_asn1e_state *state, unsigned long value,
+                             PRBool indefinite)
+{
+    int lenlen;
+    unsigned char buf[sizeof(unsigned long) + 1];
+
+    if (indefinite) {
+        PORT_Assert(value == 0);
+        buf[0] = 0x80;
+        lenlen = 1;
+    } else {
+        lenlen = SEC_ASN1EncodeLength(buf, value);
+    }
+
+    sec_asn1e_write_part(state, (char *)buf, lenlen, SEC_ASN1_Length);
+}
+
+static void
+sec_asn1e_write_contents_bytes(sec_asn1e_state *state,
+                               const char *buf, unsigned long len)
+{
+    sec_asn1e_write_part(state, buf, len, SEC_ASN1_Contents);
+}
+
+static void
+sec_asn1e_write_end_of_contents_bytes(sec_asn1e_state *state)
+{
+    const char eoc[2] = { 0, 0 };
+
+    sec_asn1e_write_part(state, eoc, 2, SEC_ASN1_EndOfContents);
+}
+
+static int
+sec_asn1e_which_choice(
+    void *src,
+    const SEC_ASN1Template *theTemplate)
+{
+    int rv;
+    unsigned int which = *(unsigned int *)src;
+
+    for (rv = 1, theTemplate++; theTemplate->kind != 0; rv++, theTemplate++) {
+        if (which == theTemplate->size) {
+            return rv;
+        }
+    }
+
+    return 0;
+}
+
+static unsigned long
+sec_asn1e_contents_length(const SEC_ASN1Template *theTemplate, void *src,
+                          PRBool disallowStreaming, PRBool insideIndefinite,
+                          sec_asn1e_hdr_encoding *pHdrException)
+{
+    unsigned long encode_kind, underlying_kind;
+    PRBool isExplicit, optional, universal, may_stream;
+    unsigned long len;
+
+    /*
+     * This function currently calculates the length in all cases
+     * except the following: when writing out the contents of a
+     * template that belongs to a state where it was a sub-template
+     * with the SEC_ASN1_MAY_STREAM bit set and it's parent had the
+     * optional bit set.  The information that the parent is optional
+     * and that we should return the length of 0 when that length is
+     * present since that means the optional field is no longer present.
+     * So we add the disallowStreaming flag which is passed in when
+     * writing the contents, but for all recursive calls to
+     * sec_asn1e_contents_length, we pass PR_FALSE, because this
+     * function correctly calculates the length for children templates
+     * from that point on.  Confused yet?  At least you didn't have
+     * to figure it out.  ;)  -javi
+     */
+    encode_kind = theTemplate->kind;
+
+    universal = ((encode_kind & SEC_ASN1_CLASS_MASK) == SEC_ASN1_UNIVERSAL)
+                    ? PR_TRUE
+                    : PR_FALSE;
+
+    isExplicit = (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(!(isExplicit && universal)); /* bad templates */
+
+    may_stream = (encode_kind & SEC_ASN1_MAY_STREAM) ? PR_TRUE : PR_FALSE;
+    encode_kind &= ~SEC_ASN1_MAY_STREAM;
+
+    /* Just clear this to get it out of the way; we do not need it here */
+    encode_kind &= ~SEC_ASN1_DYNAMIC;
+
+    if (encode_kind & SEC_ASN1_NO_STREAM) {
+        disallowStreaming = PR_TRUE;
+    }
+    encode_kind &= ~SEC_ASN1_NO_STREAM;
+
+    if (encode_kind & SEC_ASN1_CHOICE) {
+        void *src2;
+        int indx = sec_asn1e_which_choice(src, theTemplate);
+        if (0 == indx) {
+            /* XXX set an error? "choice not found" */
+            /* state->top->status = encodeError; */
+            return 0;
+        }
+
+        src2 = (void *)((char *)src - theTemplate->offset + theTemplate[indx].offset);
+
+        return sec_asn1e_contents_length(&theTemplate[indx], src2,
+                                         disallowStreaming, insideIndefinite,
+                                         pHdrException);
+    }
+
+    if ((encode_kind & (SEC_ASN1_POINTER | SEC_ASN1_INLINE)) || !universal) {
+        /* XXX any bits we want to disallow (PORT_Assert against) here? */
+        theTemplate = SEC_ASN1GetSubtemplate(theTemplate, src, PR_TRUE);
+        if (encode_kind & SEC_ASN1_POINTER) {
+            src = *(void **)src;
+            if (src == NULL) {
+                *pHdrException = optional ? hdr_optional : hdr_normal;
+                return 0;
+            }
+        } else if (encode_kind & SEC_ASN1_INLINE) {
+            /* check that there are no extraneous bits */
+            if (optional) {
+                if (PR_FALSE != SEC_ASN1IsTemplateSimple(theTemplate)) {
+                    /* we now know that the target is a SECItem*, so we can check
+                       if the source contains one */
+                    SECItem *target = (SECItem *)src;
+                    if (!target || !target->data || !target->len) {
+                        /* no valid data to encode subtemplate */
+                        *pHdrException = hdr_optional;
+                        return 0;
+                    }
+                } else {
+                    PORT_Assert(0); /* complex templates not handled as inline
+                                       optional */
+                }
+            }
+        }
+
+        src = (char *)src + theTemplate->offset;
+
+        /* recurse to find the length of the subtemplate */
+        len = sec_asn1e_contents_length(theTemplate, src, disallowStreaming,
+                                        insideIndefinite, pHdrException);
+        if (len == 0 && optional) {
+            *pHdrException = hdr_optional;
+        } else if (isExplicit) {
+            if (*pHdrException == hdr_any) {
+                /* *we* do not want to add in a header,
+                ** but our caller still does.
+                */
+                *pHdrException = hdr_normal;
+            } else if (*pHdrException == hdr_normal) {
+                /* if the inner content exists, our length is
+                 * len(identifier) + len(length) + len(innercontent)
+                 * XXX we currently assume len(identifier) == 1;
+                 * to support a high-tag-number this would need to be smarter.
+                 */
+                len += 1 + SEC_ASN1LengthLength(len);
+            }
+        }
+        return len;
+    }
+    underlying_kind = encode_kind;
+
+    /* This is only used in decoding; it plays no part in encoding.  */
+    if (underlying_kind & SEC_ASN1_SAVE) {
+        /* check that there are no extraneous bits */
+        PORT_Assert(underlying_kind == SEC_ASN1_SAVE);
+        *pHdrException = hdr_decoder;
+        return 0;
+    }
+
+#define UNEXPECTED_FLAGS                                                          \
+    (SEC_ASN1_EXPLICIT | SEC_ASN1_OPTIONAL | SEC_ASN1_INLINE | SEC_ASN1_POINTER | \
+     SEC_ASN1_DYNAMIC | SEC_ASN1_MAY_STREAM | SEC_ASN1_SAVE | SEC_ASN1_SKIP)
+
+    /* Having any of these bits is not expected here...  */
+    PORT_Assert((underlying_kind & UNEXPECTED_FLAGS) == 0);
+    underlying_kind &= ~UNEXPECTED_FLAGS;
+#undef UNEXPECTED_FLAGS
+
+    if (underlying_kind & SEC_ASN1_CHOICE) {
+        void *src2;
+        int indx = sec_asn1e_which_choice(src, theTemplate);
+        if (0 == indx) {
+            /* XXX set an error? "choice not found" */
+            /* state->top->status = encodeError; */
+            return 0;
+        }
+
+        src2 = (void *)((char *)src - theTemplate->offset + theTemplate[indx].offset);
+        len = sec_asn1e_contents_length(&theTemplate[indx], src2,
+                                        disallowStreaming, insideIndefinite,
+                                        pHdrException);
+    } else {
+        switch (underlying_kind) {
+            case SEC_ASN1_SEQUENCE_OF:
+            case SEC_ASN1_SET_OF: {
+                const SEC_ASN1Template *tmpt;
+                void *sub_src;
+                unsigned long sub_len;
+                void **group;
+
+                len = 0;
+
+                group = *(void ***)src;
+                if (group == NULL)
+                    break;
+
+                tmpt = SEC_ASN1GetSubtemplate(theTemplate, src, PR_TRUE);
+
+                for (; *group != NULL; group++) {
+                    sub_src = (char *)(*group) + tmpt->offset;
+                    sub_len = sec_asn1e_contents_length(tmpt, sub_src,
+                                                        disallowStreaming,
+                                                        insideIndefinite,
+                                                        pHdrException);
+                    len += sub_len;
+                    /*
+                     * XXX The 1 below is the presumed length of the identifier;
+                     * to support a high-tag-number this would need to be smarter.
+                     */
+                    if (*pHdrException == hdr_normal)
+                        len += 1 + SEC_ASN1LengthLength(sub_len);
+                }
+            } break;
+
+            case SEC_ASN1_SEQUENCE:
+            case SEC_ASN1_SET: {
+                const SEC_ASN1Template *tmpt;
+                void *sub_src;
+                unsigned long sub_len;
+
+                len = 0;
+                for (tmpt = theTemplate + 1; tmpt->kind; tmpt++) {
+                    sub_src = (char *)src + tmpt->offset;
+                    sub_len = sec_asn1e_contents_length(tmpt, sub_src,
+                                                        disallowStreaming,
+                                                        insideIndefinite,
+                                                        pHdrException);
+                    len += sub_len;
+                    /*
+                     * XXX The 1 below is the presumed length of the identifier;
+                     * to support a high-tag-number this would need to be smarter.
+                     */
+                    if (*pHdrException == hdr_normal)
+                        len += 1 + SEC_ASN1LengthLength(sub_len);
+                }
+            } break;
+
+            case SEC_ASN1_BIT_STRING:
+                /* convert bit length to byte */
+                len = (((SECItem *)src)->len + 7) >> 3;
+                /* bit string contents involve an extra octet */
+                if (len)
+                    len++;
+                break;
+
+            case SEC_ASN1_INTEGER:
+                /* ASN.1 INTEGERs are signed.
+                 * If the source is an unsigned integer, the encoder will need
+                 * to handle the conversion here.
+                 */
+                {
+                    unsigned char *buf = ((SECItem *)src)->data;
+                    SECItemType integerType = ((SECItem *)src)->type;
+                    len = ((SECItem *)src)->len;
+                    while (len > 0) {
+                        if (*buf != 0) {
+                            if (*buf & 0x80 && integerType == siUnsignedInteger) {
+                                len++; /* leading zero needed to make number signed */
+                            }
+                            break; /* reached beginning of number */
+                        }
+                        if (len == 1) {
+                            break; /* the number 0 */
+                        }
+                        if (buf[1] & 0x80) {
+                            break; /* leading zero already present */
+                        }
+                        /* extraneous leading zero, keep going */
+                        buf++;
+                        len--;
+                    }
+                }
+                break;
+
+            default:
+                len = ((SECItem *)src)->len;
+                break;
+        } /* end switch */
+
+#ifndef WHAT_PROBLEM_DOES_THIS_SOLVE
+        /* if we're streaming, we may have a secitem w/len 0 as placeholder */
+        if (!len && insideIndefinite && may_stream && !disallowStreaming) {
+            len = 1;
+        }
+#endif
+    } /* end else */
+
+    if (len == 0 && optional)
+        *pHdrException = hdr_optional;
+    else if (underlying_kind == SEC_ASN1_ANY)
+        *pHdrException = hdr_any;
+    else
+        *pHdrException = hdr_normal;
+
+    return len;
+}
+
+static void
+sec_asn1e_write_header(sec_asn1e_state *state)
+{
+    unsigned long contents_length;
+    unsigned char tag_number, tag_modifiers;
+    sec_asn1e_hdr_encoding hdrException = hdr_normal;
+    PRBool indefinite = PR_FALSE;
+
+    PORT_Assert(state->place == beforeHeader);
+
+    tag_number = state->tag_number;
+    tag_modifiers = state->tag_modifiers;
+
+    if (state->underlying_kind == SEC_ASN1_ANY) {
+        state->place = duringContents;
+        return;
+    }
+
+    if (state->underlying_kind & SEC_ASN1_CHOICE) {
+        int indx = sec_asn1e_which_choice(state->src, state->theTemplate);
+        if (0 == indx) {
+            /* XXX set an error? "choice not found" */
+            state->top->status = encodeError;
+            return;
+        }
+        state->place = afterChoice;
+        state = sec_asn1e_push_state(state->top, &state->theTemplate[indx],
+                                     (char *)state->src - state->theTemplate->offset,
+                                     PR_TRUE);
+        if (state) {
+            /*
+             * Do the "before" field notification.
+             */
+            sec_asn1e_notify_before(state->top, state->src, state->depth);
+            (void)sec_asn1e_init_state_based_on_template(state);
+        }
+        return;
+    }
+
+    /* The !isString test below is apparently intended to ensure that all
+    ** constructed types receive indefinite length encoding.
+    */
+    indefinite = (PRBool)(state->top->streaming && state->may_stream &&
+                          (state->top->from_buf || !state->is_string));
+
+    /*
+     * If we are doing a definite-length encoding, first we have to
+     * walk the data structure to calculate the entire contents length.
+     * If we are doing an indefinite-length encoding, we still need to
+     * know if the contents is:
+     *    optional and to be omitted, or
+     *    an ANY (header is pre-encoded), or
+     *    a SAVE or some other kind of template used only by the decoder.
+     * So, we call this function either way.
+     */
+    contents_length = sec_asn1e_contents_length(state->theTemplate,
+                                                state->src,
+                                                state->disallowStreaming,
+                                                indefinite,
+                                                &hdrException);
+    /*
+     * We might be told explicitly not to put out a header.
+     * But it can also be the case, via a pushed subtemplate, that
+     * sec_asn1e_contents_length could not know that this field is
+     * really optional.  So check for that explicitly, too.
+     */
+    if (hdrException != hdr_normal ||
+        (contents_length == 0 && state->optional)) {
+        state->place = afterContents;
+        if (state->top->streaming &&
+            state->may_stream &&
+            state->top->from_buf) {
+            /* we did not find an optional indefinite string, so we
+             * don't encode it.  However, if TakeFromBuf is on, we stop
+             * here anyway to give our caller a chance to intercept at the
+             * same point where we would stop if the field were present.
+             */
+            state->top->status = needBytes;
+        }
+        return;
+    }
+
+    if (indefinite) {
+        /*
+         * We need to put out an indefinite-length encoding.
+         * The only universal types that can be constructed are SETs,
+         * SEQUENCEs, and strings; so check that it is one of those,
+         * or that it is not universal (e.g. context-specific).
+         */
+        state->indefinite = PR_TRUE;
+        PORT_Assert((tag_number == SEC_ASN1_SET) || (tag_number == SEC_ASN1_SEQUENCE) || ((tag_modifiers & SEC_ASN1_CLASS_MASK) != 0) || state->is_string);
+        tag_modifiers |= SEC_ASN1_CONSTRUCTED;
+        contents_length = 0;
+    }
+
+    sec_asn1e_write_identifier_bytes(state,
+                                     (unsigned char)(tag_number | tag_modifiers));
+    sec_asn1e_write_length_bytes(state, contents_length, state->indefinite);
+
+    if (contents_length == 0 && !state->indefinite) {
+        /*
+         * If no real contents to encode, then we are done with this field.
+         */
+        state->place = afterContents;
+        return;
+    }
+
+    /*
+     * An EXPLICIT is nothing but an outer header, which we have already
+     * written.  Now we need to do the inner header and contents.
+     */
+    if (state->isExplicit) {
+        const SEC_ASN1Template *subt =
+            SEC_ASN1GetSubtemplate(state->theTemplate, state->src, PR_TRUE);
+        state->place = afterContents;
+        state = sec_asn1e_push_state(state->top, subt, state->src, PR_TRUE);
+        if (state != NULL) {
+            (void)sec_asn1e_init_state_based_on_template(state);
+        }
+        return;
+    }
+
+    switch (state->underlying_kind) {
+        case SEC_ASN1_SET_OF:
+        case SEC_ASN1_SEQUENCE_OF:
+            /*
+             * We need to push a child to handle each member.
+             */
+            {
+                void **group;
+                const SEC_ASN1Template *subt;
+
+                group = *(void ***)state->src;
+                if (group == NULL || *group == NULL) {
+                    /*
+                     * Group is empty; we are done.
+                     */
+                    state->place = afterContents;
+                    return;
+                }
+                state->place = duringGroup;
+                subt = SEC_ASN1GetSubtemplate(state->theTemplate, state->src,
+                                              PR_TRUE);
+                state = sec_asn1e_push_state(state->top, subt, *group, PR_TRUE);
+                if (state != NULL) {
+                    (void)sec_asn1e_init_state_based_on_template(state);
+                }
+            }
+            break;
+
+        case SEC_ASN1_SEQUENCE:
+        case SEC_ASN1_SET:
+            /*
+             * We need to push a child to handle the individual fields.
+             */
+            state->place = duringSequence;
+            state = sec_asn1e_push_state(state->top, state->theTemplate + 1,
+                                         state->src, PR_TRUE);
+            if (state != NULL) {
+                /*
+                 * Do the "before" field notification.
+                 */
+                sec_asn1e_notify_before(state->top, state->src, state->depth);
+                (void)sec_asn1e_init_state_based_on_template(state);
+            }
+            break;
+
+        default:
+            /*
+             * I think we do not need to do anything else.
+             * XXX Correct?
+             */
+            state->place = duringContents;
+            break;
+    }
+}
+
+static void
+sec_asn1e_write_contents_from_buf(sec_asn1e_state *state,
+                                  const char *buf, unsigned long len)
+{
+    PORT_Assert(state->place == duringContents);
+    PORT_Assert(state->top->from_buf);
+    PORT_Assert(state->may_stream && !state->disallowStreaming);
+
+    /*
+     * Probably they just turned on "take from buf", but have not
+     * yet given us any bytes.  If there is nothing in the buffer
+     * then we have nothing to do but return and wait.
+     */
+    if (buf == NULL || len == 0) {
+        state->top->status = needBytes;
+        return;
+    }
+    /*
+     * We are streaming, reading from a passed-in buffer.
+     * This means we are encoding a simple string or an ANY.
+     * For the former, we need to put out a substring, with its
+     * own identifier and length.  For an ANY, we just write it
+     * out as is (our caller is required to ensure that it
+     * is a properly encoded entity).
+     */
+    PORT_Assert(state->is_string); /* includes ANY */
+    if (state->underlying_kind != SEC_ASN1_ANY) {
+        unsigned char identifier;
+
+        /*
+         * Create the identifier based on underlying_kind.  We cannot
+         * use tag_number and tag_modifiers because this can be an
+         * implicitly encoded field.  In that case, the underlying
+         * substrings *are* encoded with their real tag.
+         */
+        identifier = (unsigned char)(state->underlying_kind & SEC_ASN1_TAG_MASK);
+        /*
+         * The underlying kind should just be a simple string; there
+         * should be no bits like CONTEXT_SPECIFIC or CONSTRUCTED set.
+         */
+        PORT_Assert((identifier & SEC_ASN1_TAGNUM_MASK) == identifier);
+        /*
+         * Write out the tag and length for the substring.
+         */
+        sec_asn1e_write_identifier_bytes(state, identifier);
+        if (state->underlying_kind == SEC_ASN1_BIT_STRING) {
+            char byte;
+            /*
+             * Assume we have a length in bytes but we need to output
+             * a proper bit string.  This interface only works for bit
+             * strings that are full multiples of 8.  If support for
+             * real, variable length bit strings is needed then the
+             * caller will have to know to pass in a bit length instead
+             * of a byte length and then this code will have to
+             * perform the encoding necessary (length written is length
+             * in bytes plus 1, and the first octet of string is the
+             * number of bits remaining between the end of the bit
+             * string and the next byte boundary).
+             */
+            sec_asn1e_write_length_bytes(state, len + 1, PR_FALSE);
+            byte = 0;
+            sec_asn1e_write_contents_bytes(state, &byte, 1);
+        } else {
+            sec_asn1e_write_length_bytes(state, len, PR_FALSE);
+        }
+    }
+    sec_asn1e_write_contents_bytes(state, buf, len);
+    state->top->status = needBytes;
+}
+
+static void
+sec_asn1e_write_contents(sec_asn1e_state *state)
+{
+    unsigned long len = 0;
+
+    PORT_Assert(state->place == duringContents);
+
+    switch (state->underlying_kind) {
+        case SEC_ASN1_SET:
+        case SEC_ASN1_SEQUENCE:
+            PORT_Assert(0);
+            break;
+
+        case SEC_ASN1_BIT_STRING: {
+            SECItem *item;
+            char rem;
+
+            item = (SECItem *)state->src;
+            len = (item->len + 7) >> 3;
+            rem = (unsigned char)((len << 3) - item->len); /* remaining bits */
+            sec_asn1e_write_contents_bytes(state, &rem, 1);
+            sec_asn1e_write_contents_bytes(state, (char *)item->data, len);
+        } break;
+
+        case SEC_ASN1_BMP_STRING:
+            /* The number of bytes must be divisable by 2 */
+            if ((((SECItem *)state->src)->len) % 2) {
+                SEC_ASN1EncoderContext *cx;
+
+                cx = state->top;
+                cx->status = encodeError;
+                break;
+            }
+            /* otherwise, fall through to write the content */
+            goto process_string;
+
+        case SEC_ASN1_UNIVERSAL_STRING:
+            /* The number of bytes must be divisable by 4 */
+            if ((((SECItem *)state->src)->len) % 4) {
+                SEC_ASN1EncoderContext *cx;
+
+                cx = state->top;
+                cx->status = encodeError;
+                break;
+            }
+            /* otherwise, fall through to write the content */
+            goto process_string;
+
+        case SEC_ASN1_INTEGER:
+            /* ASN.1 INTEGERs are signed.  If the source is an unsigned
+             * integer, the encoder will need to handle the conversion here.
+             */
+            {
+                unsigned int blen;
+                unsigned char *buf;
+                SECItemType integerType;
+                blen = ((SECItem *)state->src)->len;
+                buf = ((SECItem *)state->src)->data;
+                integerType = ((SECItem *)state->src)->type;
+                while (blen > 0) {
+                    if (*buf & 0x80 && integerType == siUnsignedInteger) {
+                        char zero = 0; /* write a leading 0 */
+                        sec_asn1e_write_contents_bytes(state, &zero, 1);
+                        /* and then the remaining buffer */
+                        sec_asn1e_write_contents_bytes(state,
+                                                       (char *)buf, blen);
+                        break;
+                    }
+                    /* Check three possibilities:
+                     * 1.  No leading zeros, msb of MSB is not 1;
+                     * 2.  The number is zero itself;
+                     * 3.  Encoding a signed integer with a leading zero,
+                     *     keep the zero so that the number is positive.
+                     */
+                    if (*buf != 0 ||
+                        blen == 1 ||
+                        (buf[1] & 0x80 && integerType != siUnsignedInteger)) {
+                        sec_asn1e_write_contents_bytes(state,
+                                                       (char *)buf, blen);
+                        break;
+                    }
+                    /* byte is 0, continue */
+                    buf++;
+                    blen--;
+                }
+            }
+            /* done with this content */
+            break;
+
+        process_string:
+        default: {
+            SECItem *item;
+
+            item = (SECItem *)state->src;
+            sec_asn1e_write_contents_bytes(state, (char *)item->data,
+                                           item->len);
+        } break;
+    }
+    state->place = afterContents;
+}
+
+/*
+ * We are doing a SET OF or SEQUENCE OF, and have just finished an item.
+ */
+static void
+sec_asn1e_next_in_group(sec_asn1e_state *state)
+{
+    sec_asn1e_state *child;
+    void **group;
+    void *member;
+
+    PORT_Assert(state->place == duringGroup);
+    PORT_Assert(state->child != NULL);
+
+    child = state->child;
+
+    group = *(void ***)state->src;
+
+    /*
+     * Find placement of current item.
+     */
+    member = (char *)(state->child->src) - child->theTemplate->offset;
+    while (*group != member)
+        group++;
+
+    /*
+     * Move forward to next item.
+     */
+    group++;
+    if (*group == NULL) {
+        /*
+         * That was our last one; we are done now.
+         */
+        child->place = notInUse;
+        state->place = afterContents;
+        return;
+    }
+    child->src = (char *)(*group) + child->theTemplate->offset;
+
+    /*
+     * Re-"push" child.
+     */
+    sec_asn1e_scrub_state(child);
+    state->top->current = child;
+}
+
+/*
+ * We are moving along through a sequence; move forward by one,
+ * (detecting end-of-sequence when it happens).
+ */
+static void
+sec_asn1e_next_in_sequence(sec_asn1e_state *state)
+{
+    sec_asn1e_state *child;
+
+    PORT_Assert(state->place == duringSequence);
+    PORT_Assert(state->child != NULL);
+
+    child = state->child;
+
+    /*
+     * Do the "after" field notification.
+     */
+    sec_asn1e_notify_after(state->top, child->src, child->depth);
+
+    /*
+     * Move forward.
+     */
+    child->theTemplate++;
+    if (child->theTemplate->kind == 0) {
+        /*
+         * We are done with this sequence.
+         */
+        child->place = notInUse;
+        state->place = afterContents;
+        return;
+    }
+
+    /*
+     * Reset state and push.
+     */
+
+    child->src = (char *)state->src + child->theTemplate->offset;
+
+    /*
+     * Do the "before" field notification.
+     */
+    sec_asn1e_notify_before(state->top, child->src, child->depth);
+
+    state->top->current = child;
+    (void)sec_asn1e_init_state_based_on_template(child);
+}
+
+static void
+sec_asn1e_after_contents(sec_asn1e_state *state)
+{
+    PORT_Assert(state->place == afterContents);
+
+    if (state->indefinite)
+        sec_asn1e_write_end_of_contents_bytes(state);
+
+    /*
+     * 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;
+}
+
+/*
+ * This function is called whether or not we are streaming; if we
+ * *are* streaming, our caller can also instruct us to take bytes
+ * from the passed-in buffer (at buf, for length len, which is likely
+ * bytes but could even mean bits if the current field is a bit string).
+ * If we have been so instructed, we will gobble up bytes from there
+ * (rather than from our src structure) and output them, and then
+ * we will just return, expecting to be called again -- either with
+ * more bytes or after our caller has instructed us that we are done
+ * (for now) with the buffer.
+ */
+SECStatus
+SEC_ASN1EncoderUpdate(SEC_ASN1EncoderContext *cx,
+                      const char *buf, unsigned long len)
+{
+    sec_asn1e_state *state;
+
+    if (cx->status == needBytes) {
+        cx->status = keepGoing;
+    }
+
+    while (cx->status == keepGoing) {
+        state = cx->current;
+        switch (state->place) {
+            case beforeHeader:
+                sec_asn1e_write_header(state);
+                break;
+            case duringContents:
+                if (cx->from_buf)
+                    sec_asn1e_write_contents_from_buf(state, buf, len);
+                else
+                    sec_asn1e_write_contents(state);
+                break;
+            case duringGroup:
+                sec_asn1e_next_in_group(state);
+                break;
+            case duringSequence:
+                sec_asn1e_next_in_sequence(state);
+                break;
+            case afterContents:
+                sec_asn1e_after_contents(state);
+                break;
+            case afterImplicit:
+            case afterInline:
+            case afterPointer:
+            case afterChoice:
+                /*
+                 * These states are more documentation than anything.
+                 * They just need to force a pop.
+                 */
+                PORT_Assert(!state->indefinite);
+                state->place = afterContents;
+                break;
+            case notInUse:
+            default:
+                /* This is not an error, but rather a plain old BUG! */
+                PORT_Assert(0);
+                cx->status = encodeError;
+                break;
+        }
+
+        if (cx->status == encodeError)
+            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) {
+            cx->status = allDone;
+            break;
+        }
+    }
+
+    if (cx->status == encodeError) {
+        return SECFailure;
+    }
+
+    return SECSuccess;
+}
+
+void
+SEC_ASN1EncoderFinish(SEC_ASN1EncoderContext *cx)
+{
+    /*
+     * XXX anything else that needs to be finished?
+     */
+
+    PORT_FreeArena(cx->our_pool, PR_FALSE);
+}
+
+SEC_ASN1EncoderContext *
+SEC_ASN1EncoderStart(const void *src, const SEC_ASN1Template *theTemplate,
+                     SEC_ASN1WriteProc output_proc, void *output_arg)
+{
+    PLArenaPool *our_pool;
+    SEC_ASN1EncoderContext *cx;
+
+    our_pool = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE);
+    if (our_pool == NULL)
+        return NULL;
+
+    cx = (SEC_ASN1EncoderContext *)PORT_ArenaZAlloc(our_pool, sizeof(*cx));
+    if (cx == NULL) {
+        PORT_FreeArena(our_pool, PR_FALSE);
+        return NULL;
+    }
+
+    cx->our_pool = our_pool;
+    cx->output_proc = output_proc;
+    cx->output_arg = output_arg;
+
+    cx->status = keepGoing;
+
+    if (sec_asn1e_push_state(cx, theTemplate, src, PR_FALSE) == NULL ||
+        sec_asn1e_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;
+}
+
+/*
+ * XXX Do we need a FilterProc, too?
+ */
+
+void
+SEC_ASN1EncoderSetNotifyProc(SEC_ASN1EncoderContext *cx,
+                             SEC_ASN1NotifyProc fn, void *arg)
+{
+    cx->notify_proc = fn;
+    cx->notify_arg = arg;
+}
+
+void
+SEC_ASN1EncoderClearNotifyProc(SEC_ASN1EncoderContext *cx)
+{
+    cx->notify_proc = NULL;
+    cx->notify_arg = NULL; /* not necessary; just being clean */
+}
+
+void
+SEC_ASN1EncoderAbort(SEC_ASN1EncoderContext *cx, int error)
+{
+    PORT_Assert(cx);
+    PORT_SetError(error);
+    cx->status = encodeError;
+}
+
+void
+SEC_ASN1EncoderSetStreaming(SEC_ASN1EncoderContext *cx)
+{
+    /* XXX is there a way to check that we are "between" fields here? */
+
+    cx->streaming = PR_TRUE;
+}
+
+void
+SEC_ASN1EncoderClearStreaming(SEC_ASN1EncoderContext *cx)
+{
+    /* XXX is there a way to check that we are "between" fields here? */
+
+    cx->streaming = PR_FALSE;
+}
+
+void
+SEC_ASN1EncoderSetTakeFromBuf(SEC_ASN1EncoderContext *cx)
+{
+    /*
+     * XXX is there a way to check that we are "between" fields here?  this
+     * needs to include a check for being in between groups of items in
+     * a SET_OF or SEQUENCE_OF.
+     */
+    PORT_Assert(cx->streaming);
+
+    cx->from_buf = PR_TRUE;
+}
+
+void
+SEC_ASN1EncoderClearTakeFromBuf(SEC_ASN1EncoderContext *cx)
+{
+    /* we should actually be taking from buf *now* */
+    PORT_Assert(cx->from_buf);
+    if (!cx->from_buf) /* if not, just do nothing */
+        return;
+
+    cx->from_buf = PR_FALSE;
+
+    if (cx->status == needBytes) {
+        cx->status = keepGoing;
+        cx->current->place = afterContents;
+    }
+}
+
+SECStatus
+SEC_ASN1Encode(const void *src, const SEC_ASN1Template *theTemplate,
+               SEC_ASN1WriteProc output_proc, void *output_arg)
+{
+    SEC_ASN1EncoderContext *ecx;
+    SECStatus rv;
+
+    ecx = SEC_ASN1EncoderStart(src, theTemplate, output_proc, output_arg);
+    if (ecx == NULL)
+        return SECFailure;
+
+    rv = SEC_ASN1EncoderUpdate(ecx, NULL, 0);
+
+    SEC_ASN1EncoderFinish(ecx);
+    return rv;
+}
+
+/*
+ * XXX depth and data_kind are unused; is there a PC way to silence warnings?
+ * (I mean "politically correct", not anything to do with intel/win platform)
+ */
+static void
+sec_asn1e_encode_item_count(void *arg, const char *buf, unsigned long len,
+                            int depth, SEC_ASN1EncodingPart data_kind)
+{
+    unsigned long *count;
+
+    count = (unsigned long *)arg;
+    PORT_Assert(count != NULL);
+
+    *count += len;
+}
+
+/* XXX depth and data_kind are unused; is there a PC way to silence warnings? */
+static void
+sec_asn1e_encode_item_store(void *arg, const char *buf, unsigned long len,
+                            int depth, SEC_ASN1EncodingPart data_kind)
+{
+    SECItem *dest;
+
+    dest = (SECItem *)arg;
+    PORT_Assert(dest != NULL);
+
+    if (len > 0) {
+        PORT_Memcpy(dest->data + dest->len, buf, len);
+        dest->len += len;
+    }
+}
+
+/*
+ * Allocate an entire SECItem, or just the data part of it, to hold
+ * "len" bytes of stuff.  Allocate from the given pool, if specified,
+ * otherwise just do a vanilla PORT_Alloc.
+ *
+ * XXX This seems like a reasonable general-purpose function (for SECITEM_)?
+ */
+static SECItem *
+sec_asn1e_allocate_item(PLArenaPool *poolp, SECItem *dest, unsigned long len)
+{
+    if (poolp != NULL) {
+        void *release;
+
+        release = PORT_ArenaMark(poolp);
+        if (dest == NULL)
+            dest = (SECItem *)PORT_ArenaAlloc(poolp, sizeof(SECItem));
+        if (dest != NULL) {
+            dest->data = (unsigned char *)PORT_ArenaAlloc(poolp, len);
+            if (dest->data == NULL) {
+                dest = NULL;
+            }
+        }
+        if (dest == NULL) {
+            /* one or both allocations failed; release everything */
+            PORT_ArenaRelease(poolp, release);
+        } else {
+            /* everything okay; unmark the arena */
+            PORT_ArenaUnmark(poolp, release);
+        }
+    } else {
+        SECItem *indest;
+
+        indest = dest;
+        if (dest == NULL)
+            dest = (SECItem *)PORT_Alloc(sizeof(SECItem));
+        if (dest != NULL) {
+            dest->type = siBuffer;
+            dest->data = (unsigned char *)PORT_Alloc(len);
+            if (dest->data == NULL) {
+                if (indest == NULL)
+                    PORT_Free(dest);
+                dest = NULL;
+            }
+        }
+    }
+
+    return dest;
+}
+
+SECItem *
+SEC_ASN1EncodeItem(PLArenaPool *poolp, SECItem *dest, const void *src,
+                   const SEC_ASN1Template *theTemplate)
+{
+    unsigned long encoding_length;
+    SECStatus rv;
+
+    PORT_Assert(dest == NULL || dest->data == NULL);
+
+    encoding_length = 0;
+    rv = SEC_ASN1Encode(src, theTemplate,
+                        sec_asn1e_encode_item_count, &encoding_length);
+    if (rv != SECSuccess)
+        return NULL;
+
+    dest = sec_asn1e_allocate_item(poolp, dest, encoding_length);
+    if (dest == NULL)
+        return NULL;
+
+    /* XXX necessary?  This really just checks for a bug in the allocate fn */
+    PORT_Assert(dest->data != NULL);
+    if (dest->data == NULL)
+        return NULL;
+
+    dest->len = 0;
+    (void)SEC_ASN1Encode(src, theTemplate, sec_asn1e_encode_item_store, dest);
+
+    PORT_Assert(encoding_length == dest->len);
+    return dest;
+}
+
+static SECItem *
+sec_asn1e_integer(PLArenaPool *poolp, SECItem *dest, unsigned long value,
+                  PRBool is_unsigned)
+{
+    unsigned long copy;
+    unsigned char sign;
+    int len = 0;
+
+    /*
+     * Determine the length of the encoded value (minimum of 1).
+     */
+    copy = value;
+    do {
+        len++;
+        sign = (unsigned char)(copy & 0x80);
+        copy >>= 8;
+    } while (copy);
+
+    /*
+     * If 'value' is non-negative, and the high bit of the last
+     * byte we counted was set, we need to add one to the length so
+     * we put a high-order zero byte in the encoding.
+     */
+    if (sign && (is_unsigned || (long)value >= 0))
+        len++;
+
+    /*
+     * Allocate the item (if necessary) and the data pointer within.
+     */
+    dest = sec_asn1e_allocate_item(poolp, dest, len);
+    if (dest == NULL)
+        return NULL;
+
+    /*
+     * Store the value, byte by byte, in the item.
+     */
+    dest->len = len;
+    while (len) {
+        dest->data[--len] = (unsigned char)value;
+        value >>= 8;
+    }
+    PORT_Assert(value == 0);
+
+    return dest;
+}
+
+SECItem *
+SEC_ASN1EncodeInteger(PLArenaPool *poolp, SECItem *dest, long value)
+{
+    return sec_asn1e_integer(poolp, dest, (unsigned long)value, PR_FALSE);
+}
+
+SECItem *
+SEC_ASN1EncodeUnsignedInteger(PLArenaPool *poolp,
+                              SECItem *dest, unsigned long value)
+{
+    return sec_asn1e_integer(poolp, dest, value, PR_TRUE);
+}