/*
 * Copyright (c) 2009 Kungliga Tekniska Högskolan
 * (Royal Institute of Technology, Stockholm, Sweden).
 * All rights reserved.
 *
 * Portions Copyright (c) 2009 - 2010 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the Institute nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "der_locl.h"
#include <com_err.h>
#include <vis.h>
#include <vis-extras.h>
#include <heimbase.h>

#ifndef ENOTSUP
/* Very old MSVC CRTs don't have ENOTSUP */
#define ENOTSUP EINVAL
#endif

struct asn1_type_func asn1_template_prim[A1T_NUM_ENTRY] = {
#define el(name, type) {				\
	(asn1_type_encode)der_put_##name,		\
	(asn1_type_decode)der_get_##name,		\
	(asn1_type_length)der_length_##name,		\
	(asn1_type_copy)der_copy_##name,		\
	(asn1_type_release)der_free_##name,		\
	(asn1_type_print)der_print_##name,		\
	sizeof(type)					\
    }
#define elber(name, type) {				\
	(asn1_type_encode)der_put_##name,		\
	(asn1_type_decode)der_get_##name##_ber,		\
	(asn1_type_length)der_length_##name,		\
	(asn1_type_copy)der_copy_##name,		\
	(asn1_type_release)der_free_##name,		\
	(asn1_type_print)der_print_##name,		\
	sizeof(type)					\
    }
    el(integer, int),
    el(heim_integer, heim_integer),
    el(integer, int),
    el(integer64, int64_t),
    el(unsigned, unsigned),
    el(unsigned64, uint64_t),
    el(general_string, heim_general_string),
    el(octet_string, heim_octet_string),
    elber(octet_string, heim_octet_string),
    el(ia5_string, heim_ia5_string),
    el(bmp_string, heim_bmp_string),
    el(universal_string, heim_universal_string),
    el(printable_string, heim_printable_string),
    el(visible_string, heim_visible_string),
    el(utf8string, heim_utf8_string),
    el(generalized_time, time_t),
    el(utctime, time_t),
    el(bit_string, heim_bit_string),
    { (asn1_type_encode)der_put_boolean, (asn1_type_decode)der_get_boolean,
      (asn1_type_length)der_length_boolean, (asn1_type_copy)der_copy_integer,
      (asn1_type_release)der_free_integer, (asn1_type_print)der_print_boolean,
      sizeof(int)
    },
    el(oid, heim_oid),
    el(general_string, heim_general_string),
    { (asn1_type_encode)der_put_null, (asn1_type_decode)der_get_null,
      (asn1_type_length)der_length_null, (asn1_type_copy)der_copy_integer,
      (asn1_type_release)der_free_integer, (asn1_type_print)der_print_null,
      sizeof(int)
    },
#undef el
#undef elber
};

size_t
_asn1_sizeofType(const struct asn1_template *t)
{
    return t->offset;
}

/*
 * Here is abstraction to not so well evil fact of bit fields in C,
 * they are endian dependent, so when getting and setting bits in the
 * host local structure we need to know the endianness of the host.
 *
 * Its not the first time in Heimdal this have bitten us, and some day
 * we'll grow up and use #defined constant, but bit fields are still
 * so pretty and shiny.
 */

static void
_asn1_bmember_get_bit(const unsigned char *p, void *data,
		      unsigned int bit, size_t size)
{
    unsigned int localbit = bit % 8;
    if ((*p >> (7 - localbit)) & 1) {
#ifdef WORDS_BIGENDIAN
	*(unsigned int *)data |= (1u << ((size * 8) - bit - 1));
#else
	*(unsigned int *)data |= (1u << bit);
#endif
    }
}

int
_asn1_bmember_isset_bit(const void *data, unsigned int bit, size_t size)
{
#ifdef WORDS_BIGENDIAN
    if ((*(const unsigned int *)data) & (1u << ((size * 8) - bit - 1)))
	return 1;
    return 0;
#else
    if ((*(const unsigned int *)data) & (1u << bit))
	return 1;
    return 0;
#endif
}

void
_asn1_bmember_put_bit(unsigned char *p, const void *data, unsigned int bit,
		      size_t size, unsigned int *bitset)
{
    unsigned int localbit = bit % 8;

    if (_asn1_bmember_isset_bit(data, bit, size)) {
	*p |= (1u << (7 - localbit));
	if (*bitset == 0)
	    *bitset = (7 - localbit) + 1;
    }
}

/*
 * Utility function to tell us if the encoding of some type per its template
 * will have an outer tag.  This is needed when the caller wants to slap on an
 * IMPLICIT tag: if the inner type has a tag then we need to replace it.
 */
static int
is_tagged(const struct asn1_template *t)
{
    size_t elements = A1_HEADER_LEN(t);

    t += A1_HEADER_LEN(t);
    if (elements != 1)
        return 0;
    switch (t->tt & A1_OP_MASK) {
    case A1_OP_SEQOF:       return 0;
    case A1_OP_SETOF:       return 0;
    case A1_OP_BMEMBER:     return 0;
    case A1_OP_PARSE:       return 0;
    case A1_OP_TAG:         return 1;
    case A1_OP_CHOICE:      return 1;
    case A1_OP_TYPE:        return 1;
    case A1_OP_TYPE_EXTERN: {
        const struct asn1_type_func *f = t->ptr;

        /*
         * XXX Add a boolean to struct asn1_type_func to tell us if the type is
         * tagged or not.  Basically, it's not tagged if it's primitive.
         */
        if (f->encode == (asn1_type_encode)encode_heim_any ||
            f->encode == (asn1_type_encode)encode_HEIM_ANY)
            return 0;
        abort(); /* XXX */
    }
    default: abort();
    }
}

static size_t
inner_type_taglen(const struct asn1_template *t)
{
    size_t elements = A1_HEADER_LEN(t);

    t += A1_HEADER_LEN(t);
    if (elements != 1)
        return 0;
    switch (t->tt & A1_OP_MASK) {
    case A1_OP_SEQOF:       return 0;
    case A1_OP_SETOF:       return 0;
    case A1_OP_BMEMBER:     return 0;
    case A1_OP_PARSE:       return 0;
    case A1_OP_CHOICE:      return 1;
    case A1_OP_TYPE:        return inner_type_taglen(t->ptr);
    case A1_OP_TAG:         return der_length_tag(A1_TAG_TAG(t->tt));
    case A1_OP_TYPE_EXTERN: {
        const struct asn1_type_func *f = t->ptr;

        /*
         * XXX Add a boolean to struct asn1_type_func to tell us if the type is
         * tagged or not.  Basically, it's not tagged if it's primitive.
         */
        if (f->encode == (asn1_type_encode)encode_heim_any ||
            f->encode == (asn1_type_encode)encode_HEIM_ANY)
            return 0;
        abort(); /* XXX */
    }
    default: abort();
#ifdef WIN32
             _exit(0); /* Quiet VC */
#endif
    }
}

/*
 * Compare some int of unknown size in a type ID field to the int value in
 * some IOS object's type ID template entry.
 *
 * This should be called with a `A1_TAG_T(ASN1_C_UNIV, PRIM, UT_Integer)'
 * template as the `ttypeid'.
 */
static int
typeid_int_cmp(const void *intp,
               int64_t i,
               const struct asn1_template *ttypeid)
{
    const struct asn1_template *tint = ttypeid->ptr;

    if ((tint[1].tt & A1_OP_MASK) != A1_OP_PARSE)
        return -1;
    if (A1_PARSE_TYPE(tint[1].tt) != A1T_INTEGER &&
        A1_PARSE_TYPE(tint[1].tt) != A1T_UNSIGNED &&
        A1_PARSE_TYPE(tint[1].tt) != A1T_INTEGER64 &&
        A1_PARSE_TYPE(tint[1].tt) != A1T_UNSIGNED64 &&
        A1_PARSE_TYPE(tint[1].tt) != A1T_IMEMBER)
        return -1;
    switch (tint[0].offset) {
    case 8:     return i - *(const int64_t *)intp;
    case 4:     return i - *(const int32_t *)intp;
    default:    return -1;
    }
}

/*
 * Map a logical SET/SEQUENCE member to a template entry.
 *
 * This should really have been done by the compiler, but clearly it wasn't.
 *
 * The point is that a struct type's template may be littered with entries that
 * don't directly correspond to a struct field (SET/SEQUENCE member), so we
 * have to count just the ones that do to get to the one we want.
 */
static const struct asn1_template *
template4member(const struct asn1_template *t, size_t f)
{
    size_t n = (uintptr_t)t->ptr;
    size_t i;

    for (i = 0, t++; i < n; t++, i++) {
        switch (t->tt & A1_OP_MASK) {
        case A1_OP_TAG:
        case A1_OP_TYPE:
        case A1_OP_TYPE_EXTERN:
            if (f-- == 0)
                return t;
            continue;
        case A1_OP_OPENTYPE_OBJSET:
        case A1_OP_NAME:
            return NULL;
        default:
            continue;
        }
    }
    return NULL;
}

/*
 * Attempt to decode known open type alternatives into a CHOICE-like
 * discriminated union.
 *
 * Arguments:
 *
 *  - object set template
 *  - decoder flags
 *  - pointer to memory object (C struct) to decode into
 *  - template for type ID field of `data'
 *  - template for open type field of `data' (an octet string or HEIM_ANY)
 *
 * Returns:
 *
 *  - 0
 *  - ENOMEM
 *
 * Other errors in decoding open type values are ignored, but applications can
 * note that an error must have occurred.  (Perhaps we should generate a `ret'
 * field for the discriminated union we decode into that we could use to
 * indicate what went wrong with decoding an open type value?  The application
 * can always try to decode itself to find out what the error was, but the
 * whole point is to save the developer the bother of writing code to decode
 * open type values.  Then again, the specific cause of any one decode failure
 * is not usually very important to users, so it's not very important to
 * applications either.)
 *
 * Here `data' is something like this:
 *
 *      typedef struct SingleAttribute {
 *          heim_oid type;              // <--- decoded already
 *          HEIM_ANY value;             // <--- decoded already
 *       // We must set this:
 *       // vvvvvvvv
 *          struct {
 *              enum {
 *                  choice_SingleAttribute_iosnumunknown = 0,
 *                  choice_SingleAttribute_iosnum_id_at_name,
 *                  ..
 *                  choice_SingleAttribute_iosnum_id_at_emailAddress,
 *              } element;     // <--- map type ID to enum
 *              union {
 *                  X520name* at_name;
 *                  X520name* at_surname;
 *                  ..
 *                  AliasIA5String* at_emailAddress;
 *              } u;           // <--- alloc and decode val above into this
 *          } _ioschoice_value;
 *      } SingleAttribute;
 *
 * or
 *
 *      typedef struct AttributeSet {
 *          heim_oid type;              // <--- decoded already
 *          struct AttributeSet_values {
 *              unsigned int len;       // <--- decoded already
 *              HEIM_ANY *val;          // <--- decoded already
 *          } values;
 *       // We must set this:
 *       // vvvvvvvv
 *          struct {
 *              enum { choice_AttributeSet_iosnumunknown = 0,
 *                  choice_AttributeSet_iosnum_id_at_name,
 *                  choice_AttributeSet_iosnum_id_at_surname,
 *                  ..
 *                  choice_AttributeSet_iosnum_id_at_emailAddress,
 *              } element;         // <--- map type ID to enum
 *              unsigned int len;   // <--- set len to len as above
 *              union {
 *                  X520name *at_name;
 *                  X520name *at_surname;
 *                  ..
 *                  AliasIA5String *at_emailAddress;
 *              } *val;         // <--- alloc and decode vals above into this
 *          } _ioschoice_values;
 *      } AttributeSet;
 */
static int
_asn1_decode_open_type(const struct asn1_template *t,
                       unsigned flags,
                       void *data,
                       const struct asn1_template *ttypeid,
                       const struct asn1_template *topentype)
{
    const struct asn1_template *ttypeid_univ = ttypeid;
    const struct asn1_template *tactual_type;
    const struct asn1_template *tos = t->ptr;
    size_t sz, n;
    size_t i = 0;
    unsigned int *lenp = NULL;  /* Pointer to array length field */
    unsigned int len = 1;       /* Array length */
    void **dp = NULL;           /* Decoded open type struct pointer */
    int *elementp;              /* Choice enum pointer */
    int typeid_is_oid = 0;
    int typeid_is_int = 0;
    int ret = 0;

    /*
     * NOTE: Here expressions like `DPO(data, t->offset + ...)' refer to parts
     *       of a _ioschoice_<fieldName> struct field of `data'.
     *
     *       Expressions like `DPO(data, topentype->offset + ...)' refer to
     *       the open type field in `data', which is either a `heim_any', a
     *       `heim_octet_string', or an array of one of those.
     *
     *       Expressions like `DPO(data, ttypeid->offset)' refer to the open
     *       type's type ID field in `data'.
     */

    /*
     * Minimal setup:
     *
     *  - set type choice to choice_<type>_iosnumunknown (zero).
     *  - set union value to zero
     *
     * We need a pointer to the choice ID:
     *
     *      typedef struct AttributeSet {
     *          heim_oid type;              // <--- decoded already
     *          struct AttributeSet_values {
     *              unsigned int len;       // <--- decoded already
     *              HEIM_ANY *val;          // <--- decoded already
     *          } values;
     *          struct {
     *              enum { choice_AttributeSet_iosnumunknown = 0,
     * ----------->     ...
     *              } element; // HERE
     *              ...
     *          } ...
     *      }
     *
     * XXX NOTE: We're assuming that sizeof(enum) == sizeof(int)!
     */
    elementp = DPO(data, t->offset);
    *elementp = 0; /* Set the choice to choice_<type>_iosnumunknown */
    if (t->tt & A1_OS_OT_IS_ARRAY) {
        /*
         * The open type is a SET OF / SEQUENCE OF -- an array.
         *
         * Get the number of elements to decode from:
         *
         *      typedef struct AttributeSet {
         *          heim_oid type;
         *          struct AttributeSet_values {
         * ------------>unsigned int len;       // HERE
         *              HEIM_ANY *val;
         *          } values;
         *          ...
         *      }
         */
        len = *((unsigned int *)DPO(data, topentype->offset));

        /*
         * Set the number of decoded elements to zero for now:
         *
         *      typedef struct AttributeSet {
         *          heim_oid type;
         *          struct AttributeSet_values {
         *              unsigned int len;
         *              HEIM_ANY *val;
         *          } values;
         *          struct {
         *              enum { ... } element;
         * ------------>unsigned int len;       // HERE
         *              ...
         *          } _ioschoice_values;
         *      }
         */
        lenp = DPO(data, t->offset + sizeof(*elementp));
        *lenp = 0;
        /*
         * Get a pointer to the place where we must put the decoded value:
         *
         *      typedef struct AttributeSet {
         *          heim_oid type;
         *          struct AttributeSet_values {
         *              unsigned int len;
         *              HEIM_ANY *val;
         *          } values;
         *          struct {
         *              enum { ... } element;
         *              unsigned int len;
         *              struct {
         *                  union { SomeType *some_choice; ... } u;
         * ------------>} *val;         // HERE
         *          } _ioschoice_values;
         *      } AttributeSet;
         */
        dp = DPO(data, t->offset + sizeof(*elementp) + sizeof(*lenp));
    } else {
        /*
         * Get a pointer to the place where we must put the decoded value:
         *
         *      typedef struct SingleAttribute {
         *          heim_oid type;
         *          HEIM_ANY value;
         *          struct {
         *              enum { ... } element;
         * ------------>union { SomeType *some_choice; ... } u; // HERE
         *          } _ioschoice_value;
         *      } SingleAttribute;
         */
        dp = DPO(data, t->offset + sizeof(*elementp));
    }

    /* Align `dp' */
    while (sizeof(void *) != sizeof(*elementp) &&
        ((uintptr_t)dp) % sizeof(void *) != 0)
        dp = (void *)(((char *)dp) + sizeof(*elementp));
    *dp = NULL;

    /*
     * Find out the type of the type ID member.  We currently support only
     * integers and OIDs.
     *
     * Chase through any tags to get to the type.
     */
    while (((ttypeid_univ->tt & A1_OP_MASK) == A1_OP_TAG &&
            A1_TAG_CLASS(ttypeid_univ->tt) == ASN1_C_CONTEXT) ||
           ((ttypeid_univ->tt & A1_OP_MASK) == A1_OP_TYPE)) {
        ttypeid_univ = ttypeid_univ->ptr;
        ttypeid_univ++;
    }
    switch (ttypeid_univ->tt & A1_OP_MASK) {
    case A1_OP_TAG:
        if (A1_TAG_CLASS(ttypeid_univ->tt) != ASN1_C_UNIV)
            return 0;       /* Do nothing, silently */
        switch (A1_TAG_TAG(ttypeid_univ->tt)) {
        case UT_OID:
            typeid_is_oid = 1;
            break;
        case UT_Integer: {
            const struct asn1_template *tint = ttypeid_univ->ptr;

            tint++;
            
            if ((tint->tt & A1_OP_MASK) != A1_OP_PARSE)
                return 0;   /* Do nothing, silently */
            if (A1_PARSE_TYPE(tint->tt) != A1T_INTEGER &&
                A1_PARSE_TYPE(tint->tt) != A1T_UNSIGNED &&
                A1_PARSE_TYPE(tint->tt) != A1T_INTEGER64 &&
                A1_PARSE_TYPE(tint->tt) != A1T_UNSIGNED64 &&
                A1_PARSE_TYPE(tint->tt) != A1T_IMEMBER)
                return 0;   /* Do nothing, silently (maybe a large int) */
            typeid_is_int = 1;
            break;
        }
        /* It might be cool to support string types as type ID types */
        default: return 0;  /* Do nothing, silently */
        }
        break;
    default: return 0;      /* Do nothing, silently */
    }

    /*
     * Find the type of the open type.
     *
     * An object set template looks like:
     *
     * const struct asn1_template asn1_ObjectSetName[] = {
     *     // Header entry (in this case it says there's 17 objects):
     *     { 0, 0, ((void*)17) },
     *
     *     // here's the name of the object set:
     *     { A1_OP_NAME, 0, "ObjectSetName" },
     *
     *     // then three entries per object: object name, object type ID,
     *     // object type:
     *     { A1_OP_NAME, 0, "ext-AuthorityInfoAccess" },
     *     { A1_OP_OPENTYPE_ID, 0, (const void*)&asn1_oid_oidName },
     *     { A1_OP_OPENTYPE, sizeof(SomeType), (const void*)&asn1_SomeType },
     *     ...
     * };
     *
     * `i' being a logical object offset, i*3+3 would be the index of the
     * A1_OP_OPENTYPE_ID entry for the current object, and i*3+4 the index of
     * the A1_OP_OPENTYPE entry for the current object.
     */
    if (t->tt & A1_OS_IS_SORTED) {
        size_t left = 0;
        size_t right = A1_HEADER_LEN(tos);
        const void *vp = DPO(data, ttypeid->offset);
        int c = -1;

        while (left < right) {
            size_t mid = (left + right) >> 1;

            if ((tos[3 + mid * 3].tt & A1_OP_MASK) != A1_OP_OPENTYPE_ID)
                return 0;
            if (typeid_is_int)
                c = typeid_int_cmp(vp, (intptr_t)tos[3 + mid * 3].ptr,
                                   ttypeid_univ);
            else if (typeid_is_oid)
                c = der_heim_oid_cmp(vp, tos[3 + mid * 3].ptr);
            if (c < 0) {
                right = mid;
            } else if (c > 0) {
                left = mid + 1;
            } else {
                i = mid;
                break;
            }
        }
        if (c)
            return 0; /* No match */
    } else {
        for (i = 0, n = A1_HEADER_LEN(tos); i < n; i++) {
            /* We add 1 to `i' because we're skipping the header */
            if ((tos[3 + i*3].tt & A1_OP_MASK) != A1_OP_OPENTYPE_ID)
                return 0;
            if (typeid_is_int &&
                typeid_int_cmp(DPO(data, ttypeid->offset),
                               (intptr_t)tos[3 + i*3].ptr,
                               ttypeid_univ))
                continue;
            if (typeid_is_oid &&
                der_heim_oid_cmp(DPO(data, ttypeid->offset), tos[3 + i*3].ptr))
                continue;
            break;
        }
        if (i == n)
            return 0; /* No match */
    }

    /* Match! */
    *elementp = i+1; /* Zero is the "unknown" choice, so add 1 */

    /*
     * We want the A1_OP_OPENTYPE template entry.  Its `offset' is the sizeof
     * the object we'll be decoding into, and its `ptr' is the pointer to the
     * template for decoding that type.
     */
    tactual_type = &tos[i*3 + 4];

    /* Decode the encoded open type value(s) */
    if (!(t->tt & A1_OS_OT_IS_ARRAY)) {
        /*
         * Not a SET OF/SEQUENCE OF open type, just singular.
         *
         * We need the address of the octet string / ANY field containing the
         * encoded open type value:
         *
         *      typedef struct SingleAttribute {
         *          heim_oid type;
         * -------->HEIM_ANY value; // HERE
         *          struct {
         *              ...
         *          } ...
         *      }
         *
         * Of course, the open type member could be OPTIONAL, in which case we
         * will have:
         *
         *      typedef struct SingleAttribute {
         *          heim_oid type;
         * -------->HEIM_ANY *value; // HERE
         *          struct {
         *              ...
         *          } ...
         *      }
         *
         * and we'll have to dereference that value pointer if it's not NULL.
         */
        const struct heim_base_data *d;
        void *o;

        if (t->tt & A1_OTF_IS_OPTIONAL) {
            struct heim_base_data *const *od = DPOC(data, topentype->offset);

            if (*od == NULL)
                /*
                 * Nothing to do.  The user has to check the open type field
                 * before they check the _ios_choice field.
                 */
                return 0;
            d = *od;
        } else {
            d = DPOC(data, topentype->offset);
        }

        if (d->data && d->length) {
            if ((o = calloc(1, tactual_type->offset)) == NULL)
                return ENOMEM;

            /* Re-enter to decode the encoded open type value */
            ret = _asn1_decode(tactual_type->ptr, flags, d->data, d->length, o, &sz);
            /*
             * Store the decoded object in the union:
             *
             *      typedef struct SingleAttribute {
             *          heim_oid type;
             *          HEIM_ANY value;
             *          struct {
             *              enum { ... } element;
             * ------------>union { SomeType *some_choice; ... } u; // HERE
             *          } _ioschoice_value;
             *      } SingleAttribute;
             *
             * All the union arms are pointers.
             */
            if (ret) {
                _asn1_free(tactual_type->ptr, o);
                free(o);
                /*
                 * So we failed to decode the open type -- that should not be fatal
                 * to decoding the rest of the input.  Only ENOMEM should be fatal.
                 */
                ret = 0;
            } else {
                *dp = o;
            }
        }
        return ret;
    } else {
        const struct heim_base_data * const *d;
        void **val; /* Array of pointers */

        /*
         * A SET OF/SEQUENCE OF open type, plural.
         *
         * We need the address of the octet string / ANY array pointer field
         * containing the encoded open type values:
         *
         *      typedef struct AttributeSet {
         *          heim_oid type;
         *          struct AttributeSet_values {
         *              unsigned int len;
         * ------------>HEIM_ANY *val;      // HERE
         *          } values;
         *      ...
         *      }
         *
         * We already know the value of the `len' field.
         */
        d = DPOC(data, topentype->offset + sizeof(unsigned int));
        while (sizeof(void *) != sizeof(len) &&
               ((uintptr_t)d) % sizeof(void *) != 0)
            d = (const void *)(((const char *)d) + sizeof(len));

        if ((val = calloc(len, sizeof(*val))) == NULL)
            ret = ENOMEM;

        /* Increment the count of decoded values as we decode */
        *lenp = len;
        for (i = 0; ret != ENOMEM && i < len; i++) {
            if ((val[i] = calloc(1, tactual_type->offset)) == NULL)
                ret = ENOMEM;
            if (ret == 0)
                /* Re-enter to decode the encoded open type value */
                ret = _asn1_decode(tactual_type->ptr, flags, d[0][i].data,
                                   d[0][i].length, val[i], &sz);
            if (ret) {
                _asn1_free(tactual_type->ptr, val[i]);
                free(val[i]);
                val[i] = NULL;
            }
        }
        if (ret != ENOMEM)
            ret = 0; /* See above */
        *dp = val;
        return ret;
    }
}

int
_asn1_decode(const struct asn1_template *t, unsigned flags,
	     const unsigned char *p, size_t len, void *data, size_t *size)
{
    const struct asn1_template *tbase = t;
    const struct asn1_template *tdefval = NULL;
    size_t elements = A1_HEADER_LEN(t);
    size_t oldlen = len;
    int ret = 0;
    const unsigned char *startp = NULL;
    unsigned int template_flags = t->tt;

    /*
     * Important notes:
     *
     *  - by and large we don't call _asn1_free() on error, except when we're
     *    decoding optional things or choices, then we do call _asn1_free()
     *    here
     *
     *    instead we leave it to _asn1_decode_top() to call _asn1_free() on
     *    error
     *
     *  - on error all fields of whatever we didn't _asn1_free() must have been
     *    initialized to sane values because _asn1_decode_top() will call
     *    _asn1_free() on error, so we must have left everything initialized
     *    that _asn1_free() could possibly look at
     *
     *  - so we must initialize everything
     *
     *    FIXME? but we mostly rely on calloc() to do this...
     *
     *  - we don't use malloc() unless we're going to write over the whole
     *    thing with memcpy() or whatever
     */

    /* skip over header */
    t++;

    if (template_flags & A1_HF_PRESERVE)
	startp = p;

    while (elements) {
	switch (t->tt & A1_OP_MASK) {
        case A1_OP_OPENTYPE_OBJSET: {
            size_t opentypeid = t->tt & ((1<<10)-1);
            size_t opentype = (t->tt >> 10) & ((1<<10)-1);

            /* Note that the only error returned here would be ENOMEM */
            ret = _asn1_decode_open_type(t, flags, data,
                                         template4member(tbase, opentypeid),
                                         template4member(tbase, opentype));
            if (ret)
                return ret;
            break;
        }
	case A1_OP_TYPE_DECORATE_EXTERN: break;
	case A1_OP_TYPE_DECORATE: break;
        case A1_OP_NAME: break;
	case A1_OP_DEFVAL:
            tdefval = t;
            break;
	case A1_OP_TYPE:
	case A1_OP_TYPE_EXTERN: {
	    size_t newsize, elsize;
	    void *el = DPO(data, t->offset);
	    void **pel = el;

	    if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
		elsize = _asn1_sizeofType(t->ptr);
	    } else {
		const struct asn1_type_func *f = t->ptr;
		elsize = f->size;
	    }

	    if (t->tt & A1_FLAG_OPTIONAL) {
		*pel = calloc(1, elsize);
		if (*pel == NULL)
		    return ENOMEM;
		el = *pel;
                if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
                    ret = _asn1_decode(t->ptr, flags, p, len, el, &newsize);
                } else {
                    const struct asn1_type_func *f = t->ptr;
                    ret = (f->decode)(p, len, el, &newsize);
                }
                if (ret) {
                    /*
                     * Optional field not present in encoding, presumably,
                     * though we should really look more carefully at `ret'.
                     */
                    if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
                        _asn1_free(t->ptr, el);
                    } else {
                        const struct asn1_type_func *f = t->ptr;
                        f->release(el);
                    }
		    free(*pel);
		    *pel = NULL;
		    break;
                }
	    } else {
                if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
                    ret = _asn1_decode(t->ptr, flags, p, len, el, &newsize);
                } else {
                    const struct asn1_type_func *f = t->ptr;
                    ret = (f->decode)(p, len, el, &newsize);
                }
            }
	    if (ret) {
		if (t->tt & A1_FLAG_OPTIONAL) {
		} else if (t->tt & A1_FLAG_DEFAULT) {
                    if (!tdefval)
                        return ASN1_PARSE_ERROR; /* Can't happen */
                    /*
                     * Defaulted field not present in encoding, presumably,
                     * though we should really look more carefully at `ret'.
                     */
                    if (tdefval->tt & A1_DV_BOOLEAN) {
                        int *i = el;

                        *i = tdefval->ptr ? 1 : 0;
                    } else if (tdefval->tt & A1_DV_INTEGER64) {
                        int64_t *i = el;

                        *i = (int64_t)(intptr_t)tdefval->ptr;
                    } else if (tdefval->tt & A1_DV_INTEGER32) {
                        int32_t *i = el;

                        *i = (int32_t)(intptr_t)tdefval->ptr;
                    } else if (tdefval->tt & A1_DV_INTEGER) {
                        struct heim_integer *i = el;

                        if ((ret = der_copy_heim_integer(tdefval->ptr, i)))
                            return ret;
                    } else if (tdefval->tt & A1_DV_UTF8STRING) {
                        char **s = el;

                        if ((*s = strdup(tdefval->ptr)) == NULL)
                            return ENOMEM;
                    } else {
                        abort();
                    }
                    break;
                }
		return ret; /* Error decoding required field */
	    }
	    p += newsize; len -= newsize;

	    break;
	}
	case A1_OP_TAG: {
	    Der_type dertype;
	    size_t newsize = 0;
	    size_t datalen, l = 0;
	    void *olddata = data;
	    int is_indefinite = 0;
	    int subflags = flags;
            int replace_tag = (t->tt & A1_FLAG_IMPLICIT) && is_tagged(t->ptr);
	    void *el = data = DPO(data, t->offset);
	    void **pel = el;

            /*
             * XXX If this type (chasing t->ptr through IMPLICIT tags, if this
             * one is too, till we find a non-TTag) is a [UNIVERSAL SET] type,
             * then we have to accept fields out of order.  For each field tag
             * we see we'd have to do a linear search of the SET's template
             * because it won't be sorted (or we could sort a copy and do a
             * binary search on that, but these SETs will always be small so it
             * won't be worthwhile).  We'll need a utility function to do all
             * of this.
             */
	    ret = der_match_tag_and_length(p, len, A1_TAG_CLASS(t->tt),
					   &dertype, A1_TAG_TAG(t->tt),
					   &datalen, &l);
	    if (ret) {
		if (t->tt & A1_FLAG_OPTIONAL) {
                    data = olddata;
		    break;
                } else if (t->tt & A1_FLAG_DEFAULT) {
                    if (!tdefval)
                        return ASN1_PARSE_ERROR; /* Can't happen */
                    /*
                     * Defaulted field not present in encoding, presumably,
                     * though we should really look more carefully at `ret'.
                     */
                    if (tdefval->tt & A1_DV_BOOLEAN) {
                        int *i = data;

                        *i = tdefval->ptr ? 1 : 0;
                    } else if (tdefval->tt & A1_DV_INTEGER64) {
                        int64_t *i = data;

                        *i = (int64_t)(intptr_t)tdefval->ptr;
                    } else if (tdefval->tt & A1_DV_INTEGER32) {
                        int32_t *i = data;

                        *i = (int32_t)(intptr_t)tdefval->ptr;
                    } else if (tdefval->tt & A1_DV_INTEGER) {
                        struct heim_integer *i = data;

                        if ((ret = der_copy_heim_integer(tdefval->ptr, i)))
                            return ret;
                    } else if (tdefval->tt & A1_DV_UTF8STRING) {
                        char **s = data;

                        if ((*s = strdup(tdefval->ptr)) == NULL)
                            return ENOMEM;
                    } else {
                        abort();
                    }
                    data = olddata;
                    break;
                }
		return ret; /* Error decoding required field */
	    }

	    p += l; len -= l;

	    /*
	     * Only allow indefinite encoding for OCTET STRING and BER
	     * for now. Should handle BIT STRING too.
	     */

	    if (dertype != A1_TAG_TYPE(t->tt) && (flags & A1_PF_ALLOW_BER)) {
		const struct asn1_template *subtype = t->ptr;
		subtype++; /* skip header */

		if (((subtype->tt & A1_OP_MASK) == A1_OP_PARSE) &&
		    A1_PARSE_TYPE(subtype->tt) == A1T_OCTET_STRING)
		    subflags |= A1_PF_INDEFINTE;
	    }

	    if (datalen == ASN1_INDEFINITE) {
		if ((flags & A1_PF_ALLOW_BER) == 0)
		    return ASN1_GOT_BER;
		is_indefinite = 1;
		datalen = len;
		if (datalen < 2)
		    return ASN1_OVERRUN;
		/* hide EndOfContent for sub-decoder, catching it below */
		datalen -= 2;
	    } else if (datalen > len)
		return ASN1_OVERRUN;

	    if (t->tt & A1_FLAG_OPTIONAL) {
		size_t ellen = _asn1_sizeofType(t->ptr);

		*pel = calloc(1, ellen);
		if (*pel == NULL)
		    return ENOMEM;
		data = *pel;
	    }

            if (replace_tag) {
                const struct asn1_template *subtype = t->ptr;
                int have_tag = 0;

                /*
                 * So, we have an IMPLICIT tag.  What we want to do is find the
                 * template for the body of the type so-tagged.  That's going
                 * to be a template that has a tag that isn't itself IMPLICIT.
                 *
                 * So we chase the pointer in the template until we find such a
                 * thing, then decode using that template.
                 */
                while (!have_tag) {
                    subtype++;
                    if ((subtype->tt & A1_OP_MASK) == A1_OP_TAG)
                        replace_tag = (subtype->tt & A1_FLAG_IMPLICIT) && is_tagged(t->ptr);
                    if (replace_tag) {
                        subtype = subtype->ptr;
                        continue;
                    }
                    if ((subtype->tt & A1_OP_MASK) == A1_OP_TAG) {
                        ret = _asn1_decode(subtype->ptr, subflags, p, datalen, data, &newsize);
                        have_tag = 1;
                    } else {
                        subtype = subtype->ptr;
                    }
                }
            } else {
                ret = _asn1_decode(t->ptr, subflags, p, datalen, data, &newsize);
            }
            if (ret == 0 && !is_indefinite && newsize != datalen)
		/* Hidden data */
                ret = ASN1_EXTRA_DATA;

            if (ret == 0) {
                if (is_indefinite) {
                    /* If we use indefinite encoding, the newsize is the datasize. */
                    datalen = newsize;
                }

                len -= datalen;
                p += datalen;

                /*
                 * Indefinite encoding needs a trailing EndOfContent,
                 * check for that.
                 */
                if (is_indefinite) {
                    ret = der_match_tag_and_length(p, len, ASN1_C_UNIV,
                                                   &dertype, UT_EndOfContent,
                                                   &datalen, &l);
                    if (ret == 0 && dertype != PRIM)
                        ret = ASN1_BAD_ID;
                    else if (ret == 0 && datalen != 0)
                        ret = ASN1_INDEF_EXTRA_DATA;
                    if (ret == 0) {
                        p += l; len -= l;
                    }
                }
            }
            if (ret) {
                if (!(t->tt & A1_FLAG_OPTIONAL))
                    return ret;

                _asn1_free(t->ptr, data);
                free(data);
                *pel = NULL;
                return ret;
            }
	    data = olddata;

	    break;
	}
	case A1_OP_PARSE: {
	    unsigned int type = A1_PARSE_TYPE(t->tt);
	    size_t newsize;
	    void *el = DPO(data, t->offset);

	    /*
	     * INDEFINITE primitive types are one element after the
	     * same type but non-INDEFINITE version.
	    */
	    if (flags & A1_PF_INDEFINTE)
		type++;

	    if (type >= sizeof(asn1_template_prim)/sizeof(asn1_template_prim[0])) {
		ABORT_ON_ERROR();
		return ASN1_PARSE_ERROR;
	    }

	    ret = (asn1_template_prim[type].decode)(p, len, el, &newsize);
	    if (ret)
		return ret;
	    p += newsize; len -= newsize;

	    break;
	}
	case A1_OP_SETOF:
	case A1_OP_SEQOF: {
	    struct template_of *el = DPO(data, t->offset);
	    size_t newsize;
	    size_t ellen = _asn1_sizeofType(t->ptr);
	    size_t vallength = 0;

	    while (len > 0) {
		void *tmp;
		size_t newlen = vallength + ellen;
		if (vallength > newlen)
		    return ASN1_OVERFLOW;

                /* XXX Slow */
		tmp = realloc(el->val, newlen);
		if (tmp == NULL)
		    return ENOMEM;

		memset(DPO(tmp, vallength), 0, ellen);
		el->val = tmp;

		el->len++;
		ret = _asn1_decode(t->ptr, flags & (~A1_PF_INDEFINTE), p, len,
				   DPO(el->val, vallength), &newsize);
		if (ret)
		    return ret;
		vallength = newlen;
		p += newsize; len -= newsize;
	    }

	    break;
	}
	case A1_OP_BMEMBER: {
	    const struct asn1_template *bmember = t->ptr;
	    size_t bsize = bmember->offset;
	    size_t belements = A1_HEADER_LEN(bmember);
	    size_t pos = 0;

	    bmember++;

	    memset(data, 0, bsize);

	    if (len < 1)
		return ASN1_OVERRUN;
	    p++; len--;

	    while (belements && len) {
		while (bmember->offset / 8 > pos / 8) {
		    if (len < 1)
			break;
		    p++; len--;
		    pos += 8;
		}
		if (len) {
		    _asn1_bmember_get_bit(p, data, bmember->offset, bsize);
		    belements--; bmember++;
		}
	    }
	    len = 0;
	    break;
	}
	case A1_OP_CHOICE: {
	    const struct asn1_template *choice = t->ptr;
	    unsigned int *element = DPO(data, choice->offset);
	    size_t datalen;
	    unsigned int i;

	    /*
             * CHOICE element IDs are assigned in monotonically increasing
             * fashion.  Therefore any unrealistic value is a suitable invalid
             * CHOICE value.  The largest binary value (or -1 if treating the
             * enum as signed on a twos-complement system, or...) will do.
             */
	    *element = ~0;

	    for (i = 1; i < A1_HEADER_LEN(choice) + 1 && choice[i].tt; i++) {
		/*
                 * This is more permissive than is required.  CHOICE
                 * alternatives must have different outer tags, so in principle
                 * we should just match the tag at `p' and `len' in sequence to
                 * the choice alternatives.
                 *
                 * Trying every alternative instead happens to do this anyways
                 * because each one will first match the tag at `p' and `len',
                 * but if there are CHOICE altnernatives with the same outer
                 * tag, then we'll allow it, and they had better be unambiguous
                 * in their internal details, otherwise there would be some
                 * aliasing.
                 *
                 * Arguably the *compiler* should detect ambiguous CHOICE types
                 * and raise an error, then we don't have to be concerned here
                 * at all.
                 */
		ret = _asn1_decode(choice[i].ptr, 0, p, len,
				   DPO(data, choice[i].offset), &datalen);
		if (ret == 0) {
		    *element = i;
		    p += datalen; len -= datalen;
		    break;
		}
                _asn1_free(choice[i].ptr, DPO(data, choice[i].offset));
                if (ret != ASN1_BAD_ID && ret != ASN1_MISPLACED_FIELD &&
                    ret != ASN1_MISSING_FIELD)
		    return ret;
	    }
	    if (i >= A1_HEADER_LEN(choice) + 1 || !choice[i].tt) {
                /*
                 * If this is an extensible CHOICE, then choice->tt will be the
                 * offset to u.ellipsis.  If it's not, then this "extension" is
                 * an error and must stop parsing it.  (We could be permissive
                 * and throw away the extension, though one might as well just
                 * mark such a CHOICE as extensible.)
                 */
		if (choice->tt == 0)
		    return ASN1_BAD_ID;

                /* This is the ellipsis case */
		*element = 0;
		ret = der_get_octet_string(p, len,
					   DPO(data, choice->tt), &datalen);
		if (ret)
		    return ret;
		p += datalen; len -= datalen;
	    }

	    break;
	}
	default:
	    ABORT_ON_ERROR();
	    return ASN1_PARSE_ERROR;
	}
	t++;
	elements--;
    }
    /* if we are using padding, eat up read of context */
    if (template_flags & A1_HF_ELLIPSIS)
	len = 0;

    oldlen -= len;

    if (size)
	*size = oldlen;

    /*
     * saved the raw bits if asked for it, useful for signature
     * verification.
     */
    if (startp) {
	heim_octet_string *save = data;

	save->data = malloc(oldlen);
	if (save->data == NULL)
	    return ENOMEM;
	else {
	    save->length = oldlen;
	    memcpy(save->data, startp, oldlen);
	}
    }
    return 0;
}

/*
 * This should be called with a `A1_TAG_T(ASN1_C_UNIV, PRIM, UT_Integer)'
 * template as the `ttypeid'.
 */
static int
typeid_int_copy(void *intp,
                int64_t i,
                const struct asn1_template *ttypeid)
{
    const struct asn1_template *tint = ttypeid->ptr;

    if ((tint[1].tt & A1_OP_MASK) != A1_OP_PARSE)
        return -1;
    if (A1_PARSE_TYPE(tint[1].tt) != A1T_INTEGER)
        return -1;
    switch (tint[0].offset) {
    case 8:     *((int64_t *)intp) = i; return 0;
    case 4:     *((int32_t *)intp) = i; return 0;
    default:    memset(intp, 0, tint[0].offset); return 0;
    }
}

/* See commentary in _asn1_decode_open_type() */
static int
_asn1_encode_open_type(const struct asn1_template *t,
                       const void *cdata,    /* NOTE: Not really const */
                       const struct asn1_template *ttypeid,
                       const struct asn1_template *topentype)
{
    void *data = rk_UNCONST(cdata); /* XXX */
    const struct asn1_template *ttypeid_univ = ttypeid;
    const struct asn1_template *tactual_type;
    const struct asn1_template *tos = t->ptr;
    size_t sz, i;
    unsigned int *lenp = NULL;
    unsigned int len = 1;
    int element = *(const int *)DPOC(data, t->offset);
    int typeid_is_oid = 0;
    int typeid_is_int = 0;
    int enotsup = 0;
    int ret = 0;

    if (element == 0 || element >= A1_HEADER_LEN(tos) + 1)
        return 0;

    if (t->tt & A1_OS_OT_IS_ARRAY) {
        /* The actual `len' is from the decoded open type field */
        len = *(const unsigned int *)DPOC(data, t->offset + sizeof(element));

        if (!len)
            return 0; /* The app may be encoding the open type by itself */
    }

    /* Work out the type ID field's type */
    while (((ttypeid_univ->tt & A1_OP_MASK) == A1_OP_TAG &&
            A1_TAG_CLASS(ttypeid_univ->tt) == ASN1_C_CONTEXT) ||
           ((ttypeid_univ->tt & A1_OP_MASK) == A1_OP_TYPE)) {
        ttypeid_univ = ttypeid_univ->ptr;
        ttypeid_univ++;
    }
    switch (ttypeid_univ->tt & A1_OP_MASK) {
    case A1_OP_TAG:
        if (A1_TAG_CLASS(ttypeid_univ->tt) != ASN1_C_UNIV) {
            enotsup = 1;
            break;
        }
        switch (A1_TAG_TAG(ttypeid_univ->tt)) {
        case UT_OID:
            typeid_is_oid = 1;
            break;
        case UT_Integer: {
            const struct asn1_template *tint = ttypeid_univ->ptr;

            tint++;
            if ((tint->tt & A1_OP_MASK) != A1_OP_PARSE ||
                A1_PARSE_TYPE(tint->tt) != A1T_INTEGER) {
                enotsup = 1;
                break;
            }
            typeid_is_int = 1;
            break;
        }
        default: enotsup = 1; break;
        }
        break;
    default: enotsup = 1; break;
    }

    /*
     * The app may not be aware of our automatic open type handling, so if the
     * open type already appears to have been encoded, then ignore the decoded
     * values.
     */
    if (!(t->tt & A1_OS_OT_IS_ARRAY)) {
        const struct heim_base_data *os = DPOC(data, topentype->offset);

        if (os->length && os->data)
            return 0;
    } else {
        struct heim_base_data **os =
	    DPO(data, topentype->offset + sizeof(len));

        while (sizeof(void *) != sizeof(unsigned int) &&
               ((uintptr_t)os) % sizeof(void *) != 0)
            os = (void *)(((char *)os) + sizeof(unsigned int));

        lenp = DPO(data, topentype->offset);
        if (*lenp == len && os[0]->length && os[0]->data)
            return 0;
    }

    if (typeid_is_int) {
        /*
         * Copy the int from the type ID object field to the type ID struct
         * field.
         */
        ret = typeid_int_copy(DPO(data, ttypeid->offset),
                              (intptr_t)tos[3 + (element-1)*3].ptr, ttypeid_univ);
    } else if (typeid_is_oid) {
        /*
         * Copy the OID from the type ID object field to the type ID struct
         * field.
         */
        ret = der_copy_oid(tos[3 + (element-1)*3].ptr, DPO(data, ttypeid->offset));
    } else
        enotsup = 1;

    /*
     * If the app did not already encode the open type, we can't help it if we
     * don't know what it is.
     */
    if (enotsup)
        return ENOTSUP;

    tactual_type = &tos[(element-1)*3 + 4];

    if (!(t->tt & A1_OS_OT_IS_ARRAY)) {
        struct heim_base_data *os = DPO(data, topentype->offset);
        const void * const *d = DPOC(data, t->offset + sizeof(element));

        while (sizeof(void *) != sizeof(element) &&
               ((uintptr_t)d) % sizeof(void *) != 0) {
            d = (const void *)(((const char *)d) + sizeof(element));
        }

        os->length = _asn1_length(tactual_type->ptr, *d);
        if ((os->data = malloc(os->length)) == NULL)
            return ENOMEM;
        ret = _asn1_encode(tactual_type->ptr, (os->length - 1) + (unsigned char *)os->data, os->length, *d, &sz);
    } else {
        struct heim_base_data *os;
        const void * const *val =
            DPOC(data, t->offset + sizeof(element) + sizeof(*lenp));

        if ((os = calloc(len, sizeof(*os))) == NULL)
            return ENOMEM;

        *lenp = len;
        for (i = 0; ret == 0 && i < len; i++) {
            os[i].length = _asn1_length(tactual_type->ptr, val[i]);
            if ((os[i].data = malloc(os[i].length)) == NULL)
                ret = ENOMEM;
            if (ret == 0)
                ret = _asn1_encode(tactual_type->ptr, (os[i].length - 1) + (unsigned char *)os[i].data, os[i].length,
                                   val[i], &sz);
        }
        if (ret) {
            for (i = 0; i < (*lenp); i++)
                free(os[i].data);
            free(os);
            *lenp = 0;
            return ret;
        }
        *(struct heim_base_data **)DPO(data, topentype->offset + sizeof(len)) = os;
    }
    return ret;
}

int
_asn1_encode(const struct asn1_template *t, unsigned char *p, size_t len, const void *data, size_t *size)
{
    const struct asn1_template *tbase = t;
    size_t elements = A1_HEADER_LEN(t);
    int ret = 0;
    size_t oldlen = len;

    t += A1_HEADER_LEN(t);

    while (elements) {
	switch (t->tt & A1_OP_MASK) {
        case A1_OP_OPENTYPE_OBJSET: {
            size_t opentypeid = t->tt & ((1<<10)-1);
            size_t opentype = (t->tt >> 10) & ((1<<10)-1);
            ret = _asn1_encode_open_type(t, data,
                                         template4member(tbase, opentypeid),
                                         template4member(tbase, opentype));
            if (ret)
                return ret;
            break;
        }
        case A1_OP_NAME: break;
	case A1_OP_DEFVAL: break;
	case A1_OP_TYPE_DECORATE_EXTERN: break;
	case A1_OP_TYPE_DECORATE: break;
	case A1_OP_TYPE:
	case A1_OP_TYPE_EXTERN: {
	    size_t newsize;
	    const void *el = DPOC(data, t->offset);

	    if (t->tt & A1_FLAG_OPTIONAL) {
		const void *const *pel = el;
		if (*pel == NULL)
		    break;
		el = *pel;
            } else if ((t->tt & A1_FLAG_DEFAULT) && elements > 1) {
                const struct asn1_template *tdefval = t - 1;
                /* Compare tdefval to whatever's at `el' */
                if (tdefval->tt & A1_DV_BOOLEAN) {
                    const int *i = el;

                    if ((*i && tdefval->ptr) || (!*i && !tdefval->ptr))
                        break;
                } else if (tdefval->tt & A1_DV_INTEGER64) {
                    const int64_t *i = el;

                    if (*i == (int64_t)(intptr_t)tdefval->ptr)
                        break;
                } else if (tdefval->tt & A1_DV_INTEGER32) {
                    const int32_t *i = el;

                    if ((int64_t)(intptr_t)tdefval->ptr <= INT_MAX &&
                        (int64_t)(intptr_t)tdefval->ptr >= INT_MIN &&
                        *i == (int32_t)(intptr_t)tdefval->ptr)
                        break;
                } else if (tdefval->tt & A1_DV_INTEGER) {
                    const struct heim_integer *i = el;

                    if (der_heim_integer_cmp(i, tdefval->ptr) == 0)
                        break;
                } else if (tdefval->tt & A1_DV_UTF8STRING) {
                    const char * const *s = el;

                    if (*s && strcmp(*s, tdefval->ptr) == 0)
                        break;
                } else {
                    abort();
                }
            }

	    if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
		ret = _asn1_encode(t->ptr, p, len, el, &newsize);
	    } else {
		const struct asn1_type_func *f = t->ptr;
		ret = (f->encode)(p, len, el, &newsize);
	    }

	    if (ret)
		return ret;
	    p -= newsize; len -= newsize;

	    break;
	}
	case A1_OP_TAG: {
	    const void *olddata = data;
	    size_t l, datalen = 0;
            int replace_tag = 0;

            /*
             * XXX If this type (chasing t->ptr through IMPLICIT tags, if this
             * one is too) till we find a non-TTag) is a [UNIVERSAL SET] type,
             * then we have to sort [a copy of] its template by tag, then
             * encode the SET using that sorted template.  These SETs will
             * generally be small, so when they are we might want to allocate
             * the copy on the stack and insertion sort it.  We'll need a
             * utility function to do all of this.
             */

	    data = DPOC(data, t->offset);

	    if (t->tt & A1_FLAG_OPTIONAL) {
		const void *const *el = data;
		if (*el == NULL) {
		    data = olddata;
		    break;
		}
		data = *el;
            } else if ((t->tt & A1_FLAG_DEFAULT) && elements > 1) {
                const struct asn1_template *tdefval = t - 1;
                int exclude = 0;

                /* Compare tdefval to whatever's at `data' */
                if (tdefval->tt & A1_DV_BOOLEAN) {
                    const int *i = data;

                    if ((*i && tdefval->ptr) || (!*i && !tdefval->ptr))
                        exclude = 1;
                } else if (tdefval->tt & A1_DV_INTEGER64) {
                    const int64_t *i = data;

                    if (*i == (int64_t)(intptr_t)tdefval->ptr)
                        exclude = 1;
                } else if (tdefval->tt & A1_DV_INTEGER32) {
                    const int32_t *i = data;

                    if ((int64_t)(intptr_t)tdefval->ptr <= INT_MAX &&
                        (int64_t)(intptr_t)tdefval->ptr >= INT_MIN &&
                        *i == (int32_t)(intptr_t)tdefval->ptr)
                        exclude = 1;
                } else if (tdefval->tt & A1_DV_INTEGER) {
                    const struct heim_integer *i = data;

                    if (der_heim_integer_cmp(i, tdefval->ptr) == 0)
                        break;
                } else if (tdefval->tt & A1_DV_UTF8STRING) {
                    const char * const *s = data;

                    if (*s && strcmp(*s, tdefval->ptr) == 0)
                        exclude = 1;
                } else {
                    abort();
                }
                if (exclude) {
                    data = olddata;
                    break;
                }
            }

            replace_tag = (t->tt & A1_FLAG_IMPLICIT) && is_tagged(t->ptr);

            /* IMPLICIT tags need special handling (see gen_encode.c) */
            if (replace_tag) {
                unsigned char *pfree, *psave = p;
                Der_class found_class;
                Der_type found_type = 0;
                unsigned int found_tag;
                size_t lensave = len;
                size_t oldtaglen = 0;
                size_t taglen = der_length_tag(A1_TAG_TAG(t->tt));;

                /* Allocate a buffer at least as big as we need */
                len = _asn1_length(t->ptr, data) + taglen;
                if ((p = pfree = malloc(len)) == NULL) {
                    ret = ENOMEM;
                } else {
                    /*
                     * Encode into it (with the wrong tag, which we'll replace
                     * below).
                     */
                    p += len - 1;
                    ret = _asn1_encode(t->ptr, p, len, data, &datalen);
                }
                if (ret == 0) {
                    /* Get the old tag and, critically, its length */
                    len -= datalen; p -= datalen;
                    ret = der_get_tag(p + 1, datalen, &found_class, &found_type,
                                      &found_tag, &oldtaglen);
                }
                if (ret == 0) {
                    /* Drop the old tag */
                    len += oldtaglen; p += oldtaglen;
                    /* Put the new tag */
                    ret = der_put_tag(p, len,
                                      A1_TAG_CLASS(t->tt),
                                      found_type,
                                      A1_TAG_TAG(t->tt), &l);
                }
                if (ret == 0) {
                    /* Copy the encoding where it belongs */
                    psave -= (datalen + l - oldtaglen);
                    lensave -= (datalen + l - oldtaglen);
                    memcpy(psave + 1, p + 1 - l, datalen + l - oldtaglen);
                    p = psave;
                    len = lensave;
                }
                free(pfree);
            } else {
                /* Easy case */
                ret = _asn1_encode(t->ptr, p, len, data, &datalen);
                if (ret)
                    return ret;

                len -= datalen; p -= datalen;

                ret = der_put_length_and_tag(p, len, datalen,
                                             A1_TAG_CLASS(t->tt),
                                             A1_TAG_TYPE(t->tt),
                                             A1_TAG_TAG(t->tt), &l);
                if (ret == 0) {
                    p -= l; len -= l;
                }
            }
	    if (ret)
		return ret;

	    data = olddata;

	    break;
	}
	case A1_OP_PARSE: {
	    unsigned int type = A1_PARSE_TYPE(t->tt);
	    size_t newsize;
	    const void *el = DPOC(data, t->offset);

	    if (type >= sizeof(asn1_template_prim)/sizeof(asn1_template_prim[0])) {
		ABORT_ON_ERROR();
		return ASN1_PARSE_ERROR;
	    }

	    ret = (asn1_template_prim[type].encode)(p, len, el, &newsize);
	    if (ret)
		return ret;
	    p -= newsize; len -= newsize;

	    break;
	}
	case A1_OP_SETOF: {
	    const struct template_of *el = DPOC(data, t->offset);
	    size_t ellen = _asn1_sizeofType(t->ptr);
	    heim_octet_string *val;
	    unsigned char *elptr = el->val;
	    size_t i, totallen;

	    if (el->len == 0)
		break;

	    if (el->len > UINT_MAX/sizeof(val[0]))
		return ERANGE;

	    val = calloc(el->len, sizeof(val[0]));
	    if (val == NULL)
		return ENOMEM;

	    for(totallen = 0, i = 0; i < el->len; i++) {
		unsigned char *next;
		size_t l;

		val[i].length = _asn1_length(t->ptr, elptr);
		if (val[i].length) {
		    val[i].data = malloc(val[i].length);
		    if (val[i].data == NULL) {
			ret = ENOMEM;
			break;
		    }
		}

		ret = _asn1_encode(t->ptr, DPO(val[i].data, val[i].length - 1),
				   val[i].length, elptr, &l);
		if (ret)
		    break;

		next = elptr + ellen;
		if (next < elptr) {
		    ret = ASN1_OVERFLOW;
		    break;
		}
		elptr = next;
		totallen += val[i].length;
	    }
	    if (ret == 0 && totallen > len)
		ret = ASN1_OVERFLOW;
	    if (ret) {
		for (i = 0; i < el->len; i++)
		    free(val[i].data);
		free(val);
		return ret;
	    }

	    len -= totallen;

	    qsort(val, el->len, sizeof(val[0]), _heim_der_set_sort);

	    i = el->len - 1;
	    do {
		p -= val[i].length;
		memcpy(p + 1, val[i].data, val[i].length);
		free(val[i].data);
	    } while(i-- > 0);
	    free(val);

	    break;

	}
	case A1_OP_SEQOF: {
	    const struct template_of *el = DPOC(data, t->offset);
	    size_t ellen = _asn1_sizeofType(t->ptr);
	    size_t newsize;
	    unsigned int i;
	    unsigned char *elptr = el->val;

	    if (el->len == 0)
		break;

	    elptr += ellen * (el->len - 1);

	    for (i = 0; i < el->len; i++) {
		ret = _asn1_encode(t->ptr, p, len,
				   elptr,
				   &newsize);
		if (ret)
		    return ret;
		p -= newsize; len -= newsize;
		elptr -= ellen;
	    }

	    break;
	}
	case A1_OP_BMEMBER: {
	    const struct asn1_template *bmember = t->ptr;
	    size_t bsize = bmember->offset;
	    size_t belements = A1_HEADER_LEN(bmember);
	    size_t pos;
	    unsigned char c = 0;
	    unsigned int bitset = 0;
	    int rfc1510 = (bmember->tt & A1_HBF_RFC1510);

	    bmember += belements;

	    if (rfc1510)
		pos = 31;
	    else
		pos = bmember->offset;

	    while (belements && len) {
		while (bmember->offset / 8 < pos / 8) {
		    if (rfc1510 || bitset || c) {
			if (len < 1)
			    return ASN1_OVERFLOW;
			*p-- = c; len--;
		    }
		    c = 0;
		    pos -= 8;
		}
		_asn1_bmember_put_bit(&c, data, bmember->offset, bsize, &bitset);
		belements--; bmember--;
	    }
	    if (rfc1510 || bitset) {
		if (len < 1)
		    return ASN1_OVERFLOW;
		*p-- = c; len--;
	    }

	    if (len < 1)
		return ASN1_OVERFLOW;
	    if (rfc1510 || bitset == 0)
		*p-- = 0;
	    else
		*p-- = bitset - 1;

	    len--;

	    break;
	}
	case A1_OP_CHOICE: {
	    const struct asn1_template *choice = t->ptr;
	    const unsigned int *element = DPOC(data, choice->offset);
	    size_t datalen;
	    const void *el;

	    if (*element > A1_HEADER_LEN(choice)) {
		printf("element: %d\n", *element);
		return ASN1_PARSE_ERROR;
	    }

	    if (*element == 0) {
                if (choice->tt) {
                    /* This is an extensible CHOICE */
                    ret += der_put_octet_string(p, len,
                                                DPOC(data, choice->tt), &datalen);
                    len -= datalen; p -= datalen;
                } /* else this is really an error -- XXX what to do? */
	    } else {
		choice += *element;
		el = DPOC(data, choice->offset);
		ret = _asn1_encode(choice->ptr, p, len, el, &datalen);
		if (ret)
		    return ret;
                len -= datalen; p -= datalen;
	    }

	    break;
	}
	default:
	    ABORT_ON_ERROR();
	}
	t--;
	elements--;
    }
    if (size)
	*size = oldlen - len;

    return 0;
}

static size_t
_asn1_length_open_type_helper(const struct asn1_template *t,
                              size_t sz)
{
    const struct asn1_template *tinner = t->ptr;

    switch (t->tt & A1_OP_MASK) {
    case A1_OP_TAG:
        /* XXX Not tail-recursive :( */
        sz = _asn1_length_open_type_helper(tinner, sz);
        sz += der_length_len(sz);
        sz += der_length_tag(A1_TAG_TAG(t->tt));
        return sz;
    default:
        return sz;
    }
}

static size_t
_asn1_length_open_type_id(const struct asn1_template *t,
                          const void *data)
{
    struct asn1_template pretend[2] = {
	{ 0, 0, ((void*)(uintptr_t)1) },
    };
    pretend[1] = *t;
    while ((t->tt & A1_OP_MASK) == A1_OP_TAG)
        t = t->ptr;
    pretend[0].offset = t->offset;
    return _asn1_length(pretend, data);
}

/* See commentary in _asn1_encode_open_type() */
static size_t
_asn1_length_open_type(const struct asn1_template *tbase,
                       const struct asn1_template *t,
                       const void *data,
                       const struct asn1_template *ttypeid,
                       const struct asn1_template *topentype)
{
    const struct asn1_template *ttypeid_univ = ttypeid;
    const struct asn1_template *tactual_type;
    const struct asn1_template *tos = t->ptr;
    const unsigned int *lenp = NULL;
    unsigned int len = 1;
    size_t sz = 0;
    size_t i;
    int element = *(const int *)DPOC(data, t->offset);
    int typeid_is_oid = 0;
    int typeid_is_int = 0;

    /* If nothing to encode, we add nothing to the length */
    if (element == 0 || element >= A1_HEADER_LEN(tos) + 1)
        return 0;
    if (t->tt & A1_OS_OT_IS_ARRAY) {
        len = *(const unsigned int *)DPOC(data, t->offset + sizeof(element));
        if (!len)
            return 0;
    }

    /* Work out the type ID field's type */
    while (((ttypeid_univ->tt & A1_OP_MASK) == A1_OP_TAG &&
            A1_TAG_CLASS(ttypeid_univ->tt) == ASN1_C_CONTEXT) ||
           ((ttypeid_univ->tt & A1_OP_MASK) == A1_OP_TYPE)) {
        ttypeid_univ = ttypeid_univ->ptr;
        ttypeid_univ++;
    }
    switch (ttypeid_univ->tt & A1_OP_MASK) {
    case A1_OP_TAG:
        if (A1_TAG_CLASS(ttypeid_univ->tt) != ASN1_C_UNIV)
            return 0;
        switch (A1_TAG_TAG(ttypeid_univ->tt)) {
        case UT_OID:
            typeid_is_oid = 1;
            break;
        case UT_Integer: {
            const struct asn1_template *tint = ttypeid_univ->ptr;

            tint++;
            if ((tint->tt & A1_OP_MASK) != A1_OP_PARSE ||
                A1_PARSE_TYPE(tint->tt) != A1T_INTEGER)
                return 0;
            typeid_is_int = 1;
            break;
        }
        default: return 0;
        }
        break;
    default: return 0;
    }
    if (!(t->tt & A1_OS_OT_IS_ARRAY)) {
        const struct heim_base_data *os = DPOC(data, topentype->offset);

        if (os->length && os->data)
            return 0;
    } else {
        const struct heim_base_data *const *os =
	    DPOC(data, topentype->offset + sizeof(len));

        while (sizeof(void *) != sizeof(unsigned int) &&
               ((uintptr_t)os) % sizeof(void *) != 0)
            os = (const void *)(((const char *)os) + sizeof(unsigned int));

        lenp = DPOC(data, topentype->offset);
        if (*lenp == len && os[0]->length && os[0]->data)
            return 0;
    }

    /* Compute the size of the type ID field */
    if (typeid_is_int) {
        int64_t i8;
        int32_t i4;

        switch (ttypeid_univ->offset) {
        case 8:
            i8 = (intptr_t)t->ptr;
            sz = _asn1_length_open_type_id(ttypeid, &i8);
            i8 = 0;
            sz -= _asn1_length_open_type_id(ttypeid, &i8);
            break;
        case 4:
            i4 = (intptr_t)t->ptr;
            sz = _asn1_length_open_type_id(ttypeid, &i4);
            i4 = 0;
            sz -= _asn1_length_open_type_id(ttypeid, &i8);
            break;
        default:
            return 0;
        }
    } else if (typeid_is_oid) {
        heim_oid no_oid = { 0, 0 };

        sz = _asn1_length_open_type_id(ttypeid, tos[3 + (element - 1)*3].ptr);
        sz -= _asn1_length_open_type_id(ttypeid, &no_oid);
    }

    tactual_type = &tos[(element-1)*3 + 4];

    /* Compute the size of the encoded value(s) */
    if (!(t->tt & A1_OS_OT_IS_ARRAY)) {
        const void * const *d = DPOC(data, t->offset + sizeof(element));

        while (sizeof(void *) != sizeof(element) &&
               ((uintptr_t)d) % sizeof(void *) != 0)
            d = (const void *)(((const char *)d) + sizeof(element));
        if (*d)
            sz += _asn1_length(tactual_type->ptr, *d);
    } else {
        size_t bodysz;
        const void * const * val =
            DPOC(data, t->offset + sizeof(element) + sizeof(*lenp));

        /* Compute the size of the encoded SET OF / SEQUENCE OF body */
        for (i = 0, bodysz = 0; i < len; i++) {
            if (val[i])
                bodysz += _asn1_length(tactual_type->ptr, val[i]);
        }

        /*
         * We now know the size of the body of the SET OF or SEQUENCE OF.  Now
         * we just need to count the length of all the TLs on the outside.
         */
        sz += _asn1_length_open_type_helper(topentype, bodysz);
    }
    return sz;
}

size_t
_asn1_length(const struct asn1_template *t, const void *data)
{
    const struct asn1_template *tbase = t;
    size_t elements = A1_HEADER_LEN(t);
    size_t ret = 0;

    t += A1_HEADER_LEN(t);

    while (elements) {
	switch (t->tt & A1_OP_MASK) {
        case A1_OP_OPENTYPE_OBJSET: {
            size_t opentypeid = t->tt & ((1<<10)-1);
            size_t opentype = (t->tt >> 10) & ((1<<10)-1);
            ret += _asn1_length_open_type(tbase, t, data,
                                          template4member(tbase, opentypeid),
                                          template4member(tbase, opentype));
            break;
        }
        case A1_OP_NAME: break;
	case A1_OP_DEFVAL: break;
	case A1_OP_TYPE_DECORATE_EXTERN: break;
	case A1_OP_TYPE_DECORATE: break;
	case A1_OP_TYPE:
	case A1_OP_TYPE_EXTERN: {
	    const void *el = DPOC(data, t->offset);

	    if (t->tt & A1_FLAG_OPTIONAL) {
		void *const *pel = el;
		if (*pel == NULL)
		    break;
		el = *pel;
            } else if ((t->tt & A1_FLAG_DEFAULT) && elements > 1) {
                const struct asn1_template *tdefval = t - 1;

                /* Compare tdefval to whatever's at `el' */
                if (tdefval->tt & A1_DV_BOOLEAN) {
                    const int *i = el;

                    if ((*i && tdefval->ptr) || (!*i && !tdefval->ptr))
                        break;
                } else if (tdefval->tt & A1_DV_INTEGER64) {
                    const int64_t *i = el;

                    if (*i == (int64_t)(intptr_t)tdefval->ptr)
                        break;
                } else if (tdefval->tt & A1_DV_INTEGER32) {
                    const int32_t *i = el;

                    if ((int64_t)(intptr_t)tdefval->ptr <= INT_MAX &&
                        (int64_t)(intptr_t)tdefval->ptr >= INT_MIN &&
                        *i == (int32_t)(intptr_t)tdefval->ptr)
                        break;
                } else if (tdefval->tt & A1_DV_INTEGER) {
                    const struct heim_integer *i = el;

                    if (der_heim_integer_cmp(i, tdefval->ptr) == 0)
                        break;
                } else if (tdefval->tt & A1_DV_UTF8STRING) {
                    const char * const *s = el;

                    if (*s && strcmp(*s, tdefval->ptr) == 0)
                        break;
                } else {
                    abort();
                }
            }

	    if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
		ret += _asn1_length(t->ptr, el);
	    } else {
		const struct asn1_type_func *f = t->ptr;
		ret += (f->length)(el);
	    }
	    break;
	}
	case A1_OP_TAG: {
	    size_t datalen;
	    const void *olddata = data;
            size_t oldtaglen = 0;

	    data = DPOC(data, t->offset);

	    if (t->tt & A1_FLAG_OPTIONAL) {
		void *const *el = data;
		if (*el == NULL) {
		    data = olddata;
		    break;
		}
		data = *el;
	    } else if ((t->tt & A1_FLAG_DEFAULT) && elements > 1) {
                const struct asn1_template *tdefval = t - 1;
                int exclude = 0;

                /* Compare tdefval to whatever's at `data' */
                if (tdefval->tt & A1_DV_BOOLEAN) {
                    const int *i = data;

                    if ((*i && tdefval->ptr) || (!*i && !tdefval->ptr))
                        exclude = 1;
                } else if (tdefval->tt & A1_DV_INTEGER64) {
                    const int64_t *i = data;

                    if (*i == (int64_t)(intptr_t)tdefval->ptr)
                        exclude = 1;
                } else if (tdefval->tt & A1_DV_INTEGER32) {
                    const int32_t *i = data;

                    if ((int64_t)(intptr_t)tdefval->ptr <= INT_MAX &&
                        (int64_t)(intptr_t)tdefval->ptr >= INT_MIN &&
                        *i == (int32_t)(intptr_t)tdefval->ptr)
                        exclude = 1;
                } else if (tdefval->tt & A1_DV_INTEGER) {
                    const struct heim_integer *i = data;

                    if (der_heim_integer_cmp(i, tdefval->ptr) == 0)
                        exclude = 1;
                } else if (tdefval->tt & A1_DV_UTF8STRING) {
                    const char * const *s = data;

                    if (*s && strcmp(*s, tdefval->ptr) == 0)
                        exclude = 1;
                } else {
                    abort();
                }
                if (exclude) {
                    data = olddata;
                    break;
                }
            }

            if (t->tt & A1_FLAG_IMPLICIT)
                oldtaglen = inner_type_taglen(t->ptr);

	    datalen = _asn1_length(t->ptr, data);
	    ret += datalen;
	    ret += der_length_tag(A1_TAG_TAG(t->tt));
            ret += oldtaglen ? -oldtaglen : der_length_len(datalen);
	    data = olddata;
	    break;
	}
	case A1_OP_PARSE: {
	    unsigned int type = A1_PARSE_TYPE(t->tt);
	    const void *el = DPOC(data, t->offset);

	    if (type >= sizeof(asn1_template_prim)/sizeof(asn1_template_prim[0])) {
		ABORT_ON_ERROR();
		break;
	    }
	    ret += (asn1_template_prim[type].length)(el);
	    break;
	}
	case A1_OP_SETOF:
	case A1_OP_SEQOF: {
	    const struct template_of *el = DPOC(data, t->offset);
	    size_t ellen = _asn1_sizeofType(t->ptr);
	    const unsigned char *element = el->val;
	    unsigned int i;

	    for (i = 0; i < el->len; i++) {
		ret += _asn1_length(t->ptr, element);
		element += ellen;
	    }

	    break;
	}
	case A1_OP_BMEMBER: {
	    const struct asn1_template *bmember = t->ptr;
	    size_t size = bmember->offset;
	    size_t belements = A1_HEADER_LEN(bmember);
	    int rfc1510 = (bmember->tt & A1_HBF_RFC1510);

	    if (rfc1510) {
		ret += 5;
	    } else {

		ret += 1;

		bmember += belements;

		while (belements) {
		    if (_asn1_bmember_isset_bit(data, bmember->offset, size)) {
			ret += (bmember->offset / 8) + 1;
			break;
		    }
		    belements--; bmember--;
		}
	    }
	    break;
	}
	case A1_OP_CHOICE: {
	    const struct asn1_template *choice = t->ptr;
	    const unsigned int *element = DPOC(data, choice->offset);

	    if (*element > A1_HEADER_LEN(choice))
		break;

	    if (*element == 0) {
                if (choice->tt)
                    ret += der_length_octet_string(DPOC(data, choice->tt));
	    } else {
		choice += *element;
		ret += _asn1_length(choice->ptr, DPOC(data, choice->offset));
	    }
	    break;
	}
	default:
	    ABORT_ON_ERROR();
	    break;
	}
	elements--;
	t--;
    }
    return ret;
}

/* See commentary in _asn1_decode_open_type() */
static void
_asn1_free_open_type(const struct asn1_template *t, /* object set template */
                     void *data)
{
    const struct asn1_template *tactual_type;
    const struct asn1_template *tos = t->ptr;
    unsigned int *lenp = NULL;  /* Pointer to array length field */
    unsigned int len = 1;       /* Array length */
    size_t i;
    void **dp;
    void **val;
    int *elementp = DPO(data, t->offset);   /* Choice enum pointer */

    /* XXX We assume sizeof(enum) == sizeof(int) */
    if (!*elementp || *elementp >= A1_HEADER_LEN(tos) + 1)
        return; /* Unknown choice -> it's not decoded, nothing to free here */
    tactual_type = tos[3*(*elementp - 1) + 4].ptr;

    if (!(t->tt & A1_OS_OT_IS_ARRAY)) {
        dp = DPO(data, t->offset + sizeof(*elementp));
        while (sizeof(void *) != sizeof(*elementp) &&
               ((uintptr_t)dp) % sizeof(void *) != 0)
            dp = (void *)(((char *)dp) + sizeof(*elementp));
        if (*dp) {
            _asn1_free(tactual_type, *dp);
            free(*dp);
            *dp = NULL;
        }
        return;
    }

    lenp = DPO(data, t->offset + sizeof(*elementp));
    len = *lenp;
    dp = DPO(data, t->offset + sizeof(*elementp) + sizeof(*lenp));
    while (sizeof(void *) != sizeof(*elementp) &&
           ((uintptr_t)dp) % sizeof(void *) != 0)
        dp = (void *)(((char *)dp) + sizeof(*elementp));
    val = *dp;

    for (i = 0; i < len; i++) {
        if (val[i]) {
            _asn1_free(tactual_type, val[i]);
            free(val[i]);
        }
    }
    free(val);
    *lenp = 0;
    *dp = NULL;
}

void
_asn1_free(const struct asn1_template *t, void *data)
{
    size_t elements = A1_HEADER_LEN(t);

    if (t->tt & A1_HF_PRESERVE)
	der_free_octet_string(data);

    t++;

    while (elements) {
	switch (t->tt & A1_OP_MASK) {
        case A1_OP_OPENTYPE_OBJSET: {
            _asn1_free_open_type(t, data);
            break;
        }
        case A1_OP_NAME: break;
	case A1_OP_DEFVAL: break;
	case A1_OP_TYPE_DECORATE_EXTERN:
	case A1_OP_TYPE_DECORATE:
	case A1_OP_TYPE:
	case A1_OP_TYPE_EXTERN: {
	    void *el = DPO(data, t->offset);
            void **pel = el;

	    if (t->tt & A1_FLAG_OPTIONAL) {
		if (*pel == NULL)
		    break;
		el = *pel;
	    }

	    if ((t->tt & A1_OP_MASK) == A1_OP_TYPE || (t->tt & A1_OP_MASK) == A1_OP_TYPE_DECORATE) {
		_asn1_free(t->ptr, el);
	    } else if ((t->tt & A1_OP_MASK) == A1_OP_TYPE_EXTERN) {
		const struct asn1_type_func *f = t->ptr;
		(f->release)(el);
	    } else {
                /* A1_OP_TYPE_DECORATE_EXTERN */
		const struct asn1_type_func *f = t->ptr;

                if (f && f->release)
                    (f->release)(el);
                else if (f)
                    memset(el, 0, f->size);
	    }
	    if (t->tt & A1_FLAG_OPTIONAL) {
		free(el);
                *pel = NULL;
            }

	    break;
	}
	case A1_OP_PARSE: {
	    unsigned int type = A1_PARSE_TYPE(t->tt);
	    void *el = DPO(data, t->offset);

	    if (type >= sizeof(asn1_template_prim)/sizeof(asn1_template_prim[0])) {
		ABORT_ON_ERROR();
		break;
	    }
	    (asn1_template_prim[type].release)(el);
	    break;
	}
	case A1_OP_TAG: {
	    void *el = DPO(data, t->offset);

	    if (t->tt & A1_FLAG_OPTIONAL) {
                void **pel = el;

		if (*pel == NULL)
		    break;
                _asn1_free(t->ptr, *pel);
		free(*pel);
                *pel = NULL;
            } else {
                _asn1_free(t->ptr, el);
            }

	    break;
	}
	case A1_OP_SETOF:
	case A1_OP_SEQOF: {
	    struct template_of *el = DPO(data, t->offset);
	    size_t ellen = _asn1_sizeofType(t->ptr);
	    unsigned char *element = el->val;
	    unsigned int i;

	    for (i = 0; i < el->len; i++) {
		_asn1_free(t->ptr, element);
		element += ellen;
	    }
	    free(el->val);
	    el->val = NULL;
	    el->len = 0;

	    break;
	}
	case A1_OP_BMEMBER:
	    break;
	case A1_OP_CHOICE: {
	    const struct asn1_template *choice = t->ptr;
	    const unsigned int *element = DPOC(data, choice->offset);

	    if (*element > A1_HEADER_LEN(choice))
		break;

	    if (*element == 0) {
                /*
                 * If choice->tt != 0 then this is an extensible choice, and
                 * the offset choice->tt is the offset to u.ellipsis.
                 */
                if (choice->tt != 0)
                    der_free_octet_string(DPO(data, choice->tt));
                /*
                 * Else this was a not-fully initialized CHOICE.  We could
                 * stand to memset clear the rest of it though...
                 */
	    } else {
		choice += *element;
		_asn1_free(choice->ptr, DPO(data, choice->offset));
	    }
	    break;
	}
	default:
	    ABORT_ON_ERROR();
	    break;
	}
	t++;
	elements--;
    }
}

static char *
getindent(int flags, unsigned int i)
{
    char *s;

    if (!(flags & ASN1_PRINT_INDENT) ||  i == 0)
        return NULL;
    if (i > 128)
        i = 128;
    if ((s = malloc(i * 2 + 2)) == NULL)
        return NULL;
    s[0] = '\n';
    s[i * 2 + 1] = '\0';
    memset(s + 1, ' ', i * 2);
    return s;
}

static struct rk_strpool *_asn1_print(const struct asn1_template *,
                                      struct rk_strpool *,
                                      int,
                                      unsigned int,
                                      const void *,
                                      const heim_octet_string *);

/* See commentary in _asn1_decode_open_type() */
static struct rk_strpool *
_asn1_print_open_type(const struct asn1_template *t, /* object set template */
                      struct rk_strpool *r,
                      int flags,
                      unsigned int indent,
                      const void *data,
                      const char *opentype_name)
{
    const struct asn1_template *tactual_type;
    const struct asn1_template *tos = t->ptr;
    const unsigned int *lenp = NULL;  /* Pointer to array length field */
    unsigned int len = 1;       /* Array length */
    size_t i;
    const void * const *dp;
    const void * const *val;
    const int *elementp = DPOC(data, t->offset);   /* Choice enum pointer */
    char *indents = getindent(flags, indent);

    /* XXX We assume sizeof(enum) == sizeof(int) */
    if (!*elementp || *elementp >= A1_HEADER_LEN(tos) + 1) {
        r = rk_strpoolprintf(r, ",%s\"_%s_choice\":\"<type not recognized or error decoding value of open type>\"",
                             indents ? indents : "", opentype_name);
        free(indents);
        return r;
    }
    tactual_type = tos[3*(*elementp - 1) + 4].ptr;

    r = rk_strpoolprintf(r, ",%s\"_%s_choice\":\"%s\"",
                         indents ? indents : "", opentype_name,
                         (const char *)tos[3*(*elementp - 1) + 2].ptr);
    if (!r) {
        free(indents);
        return r;
    }

    if (!(t->tt & A1_OS_OT_IS_ARRAY)) {
        unsigned align = 8 - ((t->offset + sizeof(*elementp)) & 0x7);
        dp = DPOC(data, t->offset + sizeof(*elementp) + align);
        if (*dp) {
            struct rk_strpool *r2 = NULL;
            char *s = NULL;

            r2 = _asn1_print(tactual_type, r2, flags, indent + 1, *dp, NULL);
            if (r2 == NULL) {
                r = rk_strpoolprintf(r, ",%s\"_%s\":\"_ERROR_FORMATTING_\"",
                                     indents ? indents : "", opentype_name);
                free(indents);
                return r;
            }
            s = rk_strpoolcollect(r2);
            if (s)
                r = rk_strpoolprintf(r, ",%s\"_%s\":%s",
                                     indents ? indents : "", opentype_name, s);
            free(s);
        }
	free(indents);
        return r;
    }

    lenp = DPOC(data, t->offset + sizeof(*elementp));
    len = *lenp;
    dp = DPOC(data, t->offset + sizeof(*elementp) + sizeof(*lenp));
    while (sizeof(void *) != sizeof(*elementp) &&
           ((uintptr_t)dp) % sizeof(void *) != 0)
        dp = (const void *)(((const char *)dp) + sizeof(*elementp));
    val = *dp;

    r = rk_strpoolprintf(r, ",%s\"_%s\":[", indents ? indents : "",
                         opentype_name);
    free(indents);
    indents = getindent(flags, indent + 1);
    r = rk_strpoolprintf(r, "%s", indents ? indents : "");
    for (i = 0; r && i < len; i++) {
        struct rk_strpool *r2 = NULL;
        char *s = NULL;;

        if (val[i]) {
            r2 = _asn1_print(tactual_type, r2, flags, indent + 2, val[i], NULL);
            if (r2 == NULL) {
                rk_strpoolfree(r);
                free(indents);
                return NULL;
            }
        }
        if (i)
            r = rk_strpoolprintf(r, ",%s", indents ? indents : "");
        if (r)
            r = rk_strpoolprintf(r, "%s", (s = rk_strpoolcollect(r2)));
        free(s);
    }
    free(indents);
    return rk_strpoolprintf(r, "]");
}

static struct rk_strpool *
_asn1_print(const struct asn1_template *t,
            struct rk_strpool *r,
            int flags,
            unsigned int indent,
            const void *data,
            const heim_octet_string *saved)
{
    const struct asn1_template *tbase = t;
    const struct asn1_template *tnames;
    size_t nelements = A1_HEADER_LEN(t);
    size_t elements = nelements;
    size_t nnames = 0;
    char *indents = getindent(flags, indent);

    for (t += nelements; t > tbase && (t->tt & A1_OP_MASK) == A1_OP_NAME; t--)
        nnames++;

    tnames = tbase + nelements - nnames + 1;

    if (!r)
        r = rk_strpoolprintf(r, "%s", "");

    if (nnames)
        r = rk_strpoolprintf(r, "%s{\"_type\":\"%s\"",
                             indents ? indents : "",
                             (const char *)(tnames++)->ptr);
    if (saved && r) {
        char *s = der_print_octet_string(data, 0);

        if (!s) {
            rk_strpoolfree(r);
            free(indents);
            return NULL;
        }
        r = rk_strpoolprintf(r, ",%s\"_save\":\"%s\"",
                             indents ? indents : "", s);
        free(s);
    }
    saved = NULL;
    if (tbase->tt & A1_HF_PRESERVE)
        saved = data;

    t = tbase + 1;
    while (r && elements && (t->tt & A1_OP_MASK) != A1_OP_NAME) {
	switch (t->tt & A1_OP_MASK) {
        case A1_OP_NAME:
            continue;
	case A1_OP_DEFVAL:
            t++;
            elements--;
            continue;
        case A1_OP_OPENTYPE_OBJSET: {
            size_t opentype = (t->tt >> 10) & ((1<<10)-1);
            r = _asn1_print_open_type(t, r, flags, indent + 1, data,
                                      tbase[(nelements - nnames) + 2 + opentype].ptr);
            t++;
            elements--;
            continue;
        }
        default: break;
        }
        if (nnames &&
            (t->tt & A1_OP_MASK) != A1_OP_TYPE_DECORATE_EXTERN &&
            (t->tt & A1_OP_MASK) != A1_OP_TYPE_DECORATE)
            r = rk_strpoolprintf(r, ",%s\"%s\":",
                                 indents ? indents : "",
                                 (const char *)(tnames++)->ptr);
	switch (t->tt & A1_OP_MASK) {
        case A1_OP_OPENTYPE_OBJSET:
            break;
        case A1_OP_NAME: break;
	case A1_OP_DEFVAL: break;
	case A1_OP_TYPE_DECORATE_EXTERN: break;
	case A1_OP_TYPE_DECORATE: break; /* We could probably print this though */
	case A1_OP_TYPE:
	case A1_OP_TYPE_EXTERN: {
	    const void *el = DPOC(data, t->offset);

	    if (t->tt & A1_FLAG_OPTIONAL) {
		const void * const *pel = (const void *const *)el;
		if (*pel == NULL) {
                    r = rk_strpoolprintf(r, "null");
		    break;
                }
		el = *pel;
	    }

	    if ((t->tt & A1_OP_MASK) == A1_OP_TYPE) {
		r = _asn1_print(t->ptr, r, flags, indent + 1, el, saved);
	    } else {
		const struct asn1_type_func *f = t->ptr;
                char *s = NULL;

                s = (f->print)(el, 0);
                if (s == NULL) {
                    rk_strpoolfree(r);
                    free(indents);
                    return NULL;
                }
		r = rk_strpoolprintf(r, "%s", s);
                free(s);
	    }
	    break;
	}
	case A1_OP_PARSE: {
	    unsigned int type = A1_PARSE_TYPE(t->tt);
	    const void *el = DPOC(data, t->offset);
            char *s = NULL;

	    if (type >= sizeof(asn1_template_prim)/sizeof(asn1_template_prim[0])) {
		ABORT_ON_ERROR();
		break;
	    }

            if (type == A1T_IMEMBER && t->ptr) {
                /* Enumeration.  Use the symbolic name of this value */
                const struct asn1_template *tenum = t->ptr;
                size_t left = 0;
                size_t right = A1_HEADER_LEN(tenum);
                size_t mid;
                uint32_t v = *(const unsigned int *)el;
                int c = -1;

                while (left <= right) {
                    mid = (left + right) >> 1;

                    if ((tenum[mid].tt & A1_OP_MASK) != A1_OP_NAME)
                        break;
                    c = v - tenum[mid].offset;
                    if (c < 0) {
                        if (mid)
                            right = mid - 1;
                        else
                            break;
                    } else if (c > 0) {
                        left = mid + 1;
                    } else {
                        break;
                    }
                }
                if (c == 0) {
                    r = rk_strpoolprintf(r, "\"%s\"", (const char *)tenum[mid].ptr);
                    break;
                }
            }
	    s = (asn1_template_prim[type].print)(el, flags);
            switch (type) {
            case A1T_OID:
            case A1T_IMEMBER:
            case A1T_BOOLEAN:
            case A1T_INTEGER:
            case A1T_INTEGER64:
            case A1T_UNSIGNED:
            case A1T_UNSIGNED64:
                if (s)
                    r = rk_strpoolprintf(r, "%s", s);
                break;
            default: {
                char *s2 = NULL;

                if (s)
                    (void) rk_strasvis(&s2, s, VIS_CSTYLE|VIS_TAB|VIS_NL, "\"");
                free(s);
                s = s2;
                if (s)
                    r = rk_strpoolprintf(r, "\"%s\"", s);
            }
            }
            if (!s) {
                rk_strpoolfree(r);
                free(indents);
                return NULL;
            }
            free(s);
	    break;
	}
	case A1_OP_TAG: {
	    const void *el = DPOC(data, t->offset);

	    if (t->tt & A1_FLAG_OPTIONAL) {
		const void * const *pel = (const void * const *)el;
		if (*pel == NULL) {
                    r = rk_strpoolprintf(r, "null");
		    break;
                }
		el = *pel;
	    }

	    r = _asn1_print(t->ptr, r, flags, indent + 1, el, saved);
	    break;
	}
	case A1_OP_SETOF:
	case A1_OP_SEQOF: {
	    const struct template_of *el = DPOC(data, t->offset);
	    size_t ellen = _asn1_sizeofType(t->ptr);
	    const unsigned char *element = el->val;
	    unsigned int i;

            r = rk_strpoolprintf(r, "%s[", indents ? indents : "");
	    for (i = 0; r && i < el->len; i++) {
                if (i)
                    r = rk_strpoolprintf(r, ",%s", indents ? indents : "");
		r = _asn1_print(t->ptr, r, flags, indent + 1, element, saved);
		element += ellen;
	    }
            if (r)
                r = rk_strpoolprintf(r, "]");
	    break;
	}
	case A1_OP_BMEMBER: {
	    const struct asn1_template *bmember = t->ptr;
	    size_t size = bmember->offset;
	    size_t belements = A1_HEADER_LEN(bmember);
            int first = 1;

            bmember += belements;
            r = rk_strpoolprintf(r, "%s[", indents ? indents : "");
            while (r && belements) {
                if (r && _asn1_bmember_isset_bit(data, bmember->offset, size)) {
                    if (!first)
                        r = rk_strpoolprintf(r, ",");
                    first = 0;
                    r = rk_strpoolprintf(r, "%s\"%s\"", indents ? indents : "",
                                         (const char *)bmember->ptr);
                }
                belements--; bmember--;
	    }
            if (r)
                r = rk_strpoolprintf(r, "]");
	    break;
	}
	case A1_OP_CHOICE: {
	    const struct asn1_template *choice = t->ptr;
	    const unsigned int *element = DPOC(data, choice->offset);
            unsigned int nchoices = ((uintptr_t)choice->ptr) >> 1;

	    if (*element > A1_HEADER_LEN(choice)) {
                r = rk_strpoolprintf(r, "null");
            } else if (*element == 0) {
                /* XXX If choice->tt then we should print the u.ellipsis */
                r = rk_strpoolprintf(r, "null");
	    } else {
		choice += *element;
                r = rk_strpoolprintf(r, "%s{\"_choice\":\"%s\",%s\"value\":",
                                     indents ? indents : "",
                                     (const char *)choice[nchoices].ptr,
                                     indents ? indents : "");
                if (r)
                    r = _asn1_print(choice->ptr, r, flags, indent + 1,
                                    DPOC(data, choice->offset), NULL);
                if (r)
                    r = rk_strpoolprintf(r, "}");
	    }
	    break;
	}
	default:
	    ABORT_ON_ERROR();
	    break;
	}
	t++;
	elements--;
    }
    free(indents);
    if (nnames && r)
        return rk_strpoolprintf(r, "}");
    return r;
}

char *
_asn1_print_top(const struct asn1_template *t,
                int flags,
                const void *data)
{
    struct rk_strpool *r = _asn1_print(t, NULL, flags, 0, data, NULL);

    if (r == NULL)
        return NULL;
    return rk_strpoolcollect(r);
}

/* See commentary in _asn1_decode_open_type() */
static int
_asn1_copy_open_type(const struct asn1_template *t, /* object set template */
                     const void *from,
                     void *to)
{
    const struct asn1_template *tactual_type;
    const struct asn1_template *tos = t->ptr;
    size_t i;
    const void * const *dfromp;
    const void * const *valfrom;
    const unsigned int *lenfromp;
    void **dtop;
    void **valto;
    unsigned int *lentop;
    unsigned int len;
    const int *efromp = DPOC(from, t->offset);
    int *etop = DPO(to, t->offset);
    int ret = 0;

    /* XXX We assume sizeof(enum) == sizeof(int) */
    if (!*efromp || *efromp >= A1_HEADER_LEN(tos) + 1) {
        if ((t->tt & A1_OS_OT_IS_ARRAY))
            memset(etop, 0, sizeof(int) + sizeof(unsigned int) + sizeof(void *));
        else
            memset(etop, 0, sizeof(int) + sizeof(void *));
        return 0; /* Unknown choice -> not copied */
    }
    tactual_type = &tos[3*(*efromp - 1) + 4];

    if (!(t->tt & A1_OS_OT_IS_ARRAY)) {
        dfromp = DPOC(from, t->offset + sizeof(*efromp));
        while (sizeof(void *) != sizeof(*efromp) &&
               ((uintptr_t)dfromp) % sizeof(void *) != 0)
            dfromp = (const void *)(((const char *)dfromp) + sizeof(*efromp));
        if (!*dfromp)
            return 0;

        dtop = DPO(to, t->offset + sizeof(*etop));
        while (sizeof(void *) != sizeof(*etop) &&
               ((uintptr_t)dtop) % sizeof(void *) != 0)
            dtop = (void *)(((char *)dtop) + sizeof(*etop));

        if ((*dtop = calloc(1, tactual_type->offset)) == NULL)
            ret = ENOMEM;
        if (ret == 0)
            ret = _asn1_copy(tactual_type->ptr, *dfromp, *dtop);
        if (ret == 0)
            *etop = *efromp;
        return ret;
    }

    lenfromp = DPOC(from, t->offset + sizeof(*efromp));
    dfromp   = DPOC(from, t->offset + sizeof(*efromp) + sizeof(*lenfromp));
    valfrom  = *dfromp;
    lentop   = DPO(to,   t->offset + sizeof(*etop));
    dtop     = DPO(to,   t->offset + sizeof(*etop)   + sizeof(*lentop));

    *etop = *efromp;

    len = *lenfromp;
    *lentop = 0;
    *dtop = NULL;
    if ((valto = calloc(len, sizeof(valto[0]))) == NULL)
        ret = ENOMEM;
    for (i = 0, len = *lenfromp; ret == 0 && i < len; i++) {
        if (valfrom[i] == NULL) {
            valto[i] = NULL;
            continue;
        }
        if ((valto[i] = calloc(1, tactual_type->offset)) == NULL)
            ret = ENOMEM;
        else
            ret = _asn1_copy(tactual_type->ptr, valfrom[i], valto[i]);
        (*lentop)++;
    }

    for (i = 0; ret && i < (*lentop); i++) {
        if (valto[i]) {
            _asn1_free(tactual_type->ptr, valto[i]);
            free(valto[i]);
        }
    }
    if (ret) {
        free(valto);
        *lentop = 0;
    } else
        *dtop = valto;
    return ret;
}

int
_asn1_copy(const struct asn1_template *t, const void *from, void *to)
{
    size_t elements = A1_HEADER_LEN(t);
    int ret = 0;
    int preserve = (t->tt & A1_HF_PRESERVE);

    t++;

    if (preserve) {
	ret = der_copy_octet_string(from, to);
	if (ret)
	    return ret;
    }

    while (elements) {
	switch (t->tt & A1_OP_MASK) {
        case A1_OP_OPENTYPE_OBJSET: {
            _asn1_copy_open_type(t, from, to);
            break;
        }
        case A1_OP_NAME: break;
	case A1_OP_DEFVAL: break;
	case A1_OP_TYPE_DECORATE_EXTERN:
	case A1_OP_TYPE_DECORATE:
	case A1_OP_TYPE:
	case A1_OP_TYPE_EXTERN: {
	    const void *fel = DPOC(from, t->offset);
	    void *tel = DPO(to, t->offset);
	    void **ptel = tel;
	    size_t size;

	    if ((t->tt & A1_OP_MASK) == A1_OP_TYPE ||
                (t->tt & A1_OP_MASK) == A1_OP_TYPE_DECORATE) {
		size = _asn1_sizeofType(t->ptr);
	    } else {
		const struct asn1_type_func *f = t->ptr;
		size = f->size;
	    }

	    if (t->tt & A1_FLAG_OPTIONAL) {
		const void *const *pfel = fel;
		if (*pfel == NULL)
		    break;
		fel = *pfel;

		tel = *ptel = calloc(1, size);
		if (tel == NULL)
		    return ENOMEM;
	    }

	    if ((t->tt & A1_OP_MASK) == A1_OP_TYPE ||
                (t->tt & A1_OP_MASK) == A1_OP_TYPE_DECORATE) {
		ret = _asn1_copy(t->ptr, fel, tel);
	    } else if ((t->tt & A1_OP_MASK) == A1_OP_TYPE_EXTERN) {
		const struct asn1_type_func *f = t->ptr;
                ret = (f->copy)(fel, tel);
	    } else {
		const struct asn1_type_func *f = t->ptr;

                /* A1_OP_TYPE_DECORATE_EXTERN */
                if (f && f->copy)
                    ret = (f->copy)(fel, tel);
                else if (f)
                    memset(tel, 0, f->size);
	    }

	    if (ret) {
		if (t->tt & A1_FLAG_OPTIONAL) {
		    free(*ptel);
		    *ptel = NULL;
		}
		return ret;
	    }
	    break;
	}
	case A1_OP_PARSE: {
	    unsigned int type = A1_PARSE_TYPE(t->tt);
	    const void *fel = DPOC(from, t->offset);
	    void *tel = DPO(to, t->offset);

	    if (type >= sizeof(asn1_template_prim)/sizeof(asn1_template_prim[0])) {
		ABORT_ON_ERROR();
		return ASN1_PARSE_ERROR;
	    }
	    ret = (asn1_template_prim[type].copy)(fel, tel);
	    if (ret)
		return ret;
	    break;
	}
	case A1_OP_TAG: {
	    const void *oldfrom = from;
	    void *oldto = to;
	    void **tel = NULL;

	    from = DPOC(from, t->offset);
	    to = DPO(to, t->offset);

	    if (t->tt & A1_FLAG_OPTIONAL) {
		const void *const *fel = from;
		tel = to;
		if (*fel == NULL) {
		    from = oldfrom;
		    to = oldto;
		    break;
		}
		from = *fel;

		to = *tel = calloc(1, _asn1_sizeofType(t->ptr));
		if (to == NULL)
		    return ENOMEM;
	    }

	    ret = _asn1_copy(t->ptr, from, to);
	    if (ret) {
		if (tel) {
		    free(*tel);
		    *tel = NULL;
		}
		return ret;
	    }

	    from = oldfrom;
	    to = oldto;

	    break;
	}
	case A1_OP_SETOF:
	case A1_OP_SEQOF: {
	    const struct template_of *fel = DPOC(from, t->offset);
	    struct template_of *tel = DPO(to, t->offset);
	    size_t ellen = _asn1_sizeofType(t->ptr);
	    unsigned int i;

	    tel->val = calloc(fel->len, ellen);
	    if (tel->val == NULL && fel->len > 0)
		return ENOMEM;

	    tel->len = fel->len;

	    for (i = 0; i < fel->len; i++) {
		ret = _asn1_copy(t->ptr,
				 DPOC(fel->val, (i * ellen)),
				 DPO(tel->val, (i *ellen)));
		if (ret)
		    return ret;
	    }
	    break;
	}
	case A1_OP_BMEMBER: {
	    const struct asn1_template *bmember = t->ptr;
	    size_t size = bmember->offset;
	    memcpy(to, from, size);
	    break;
	}
	case A1_OP_CHOICE: {
	    const struct asn1_template *choice = t->ptr;
	    const unsigned int *felement = DPOC(from, choice->offset);
	    unsigned int *telement = DPO(to, choice->offset);

	    if (*felement > A1_HEADER_LEN(choice))
		return ASN1_PARSE_ERROR;

	    *telement = *felement;

	    if (*felement == 0) {
                if (choice->tt)
                    ret = der_copy_octet_string(DPOC(from, choice->tt), DPO(to, choice->tt));
                /*
                 * Else we should really memset clear the rest of this choice,
                 * but we don't really know its size.
                 */
	    } else {
		choice += *felement;
		ret = _asn1_copy(choice->ptr,
				 DPOC(from, choice->offset),
				 DPO(to, choice->offset));
	    }
	    if (ret)
		return ret;
	    break;
	}
	default:
	    ABORT_ON_ERROR();
	    break;
	}
	t++;
	elements--;
    }
    return 0;
}

int
_asn1_decode_top(const struct asn1_template *t, unsigned flags, const unsigned char *p, size_t len, void *data, size_t *size)
{
    int ret;
    memset(data, 0, t->offset);
    ret = _asn1_decode(t, flags, p, len, data, size);
    if (ret)
	_asn1_free_top(t, data);

    return ret;
}

int
_asn1_copy_top(const struct asn1_template *t, const void *from, void *to)
{
    int ret;
    memset(to, 0, t->offset);
    ret = _asn1_copy(t, from, to);
    if (ret)
	_asn1_free_top(t, to);

    return ret;
}

void
_asn1_free_top(const struct asn1_template *t, void *data)
{
    _asn1_free(t, data);
    memset(data, 0, t->offset);
}
