/*-
 * SPDX-FileCopyrightText: (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
 * SPDX-License-Identifier: BSD-1-Clause
 */
#include <INTEGER.h>
#include <asn_codecs_prim.h> /* Encoder and decoder of a primitive type */
#include <asn_internal.h>
#include <errno.h>
#include <inttypes.h>

/*
 * INTEGER basic type description.
 */
static ber_tlv_tag_t asn_DEF_INTEGER_tags[] = {
    (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))};
asn_TYPE_descriptor_t asn_DEF_INTEGER = {
    "INTEGER",
    "INTEGER",
    ASN__PRIMITIVE_TYPE_free,
    INTEGER_print,
    asn_generic_no_constraint,
    ber_decode_primitive,
    INTEGER_encode_der,
    INTEGER_decode_xer,
    INTEGER_encode_xer,
    INTEGER_decode_uper, /* Unaligned PER decoder */
    INTEGER_encode_uper, /* Unaligned PER encoder */
    0,                   /* Use generic outmost tag fetcher */
    asn_DEF_INTEGER_tags,
    sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
    asn_DEF_INTEGER_tags, /* Same as above */
    sizeof(asn_DEF_INTEGER_tags) / sizeof(asn_DEF_INTEGER_tags[0]),
    0, /* No PER visible constraints */
    0,
    0, /* No members */
    0  /* No specifics */
};

/*
 * Encode INTEGER type using DER.
 */
asn_enc_rval_t INTEGER_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
    int tag_mode, ber_tlv_tag_t tag,
    asn_app_consume_bytes_f *cb, void *app_key)
{
    INTEGER_t *st = (INTEGER_t *)sptr;

    ASN_DEBUG("%s %s as INTEGER (tm=%d)", cb ? "Encoding" : "Estimating",
        td->name, tag_mode);

    /*
     * Canonicalize integer in the buffer.
     * (Remove too int64_t sign extension, remove some first 0x00 bytes)
     */
    if (st->buf)
        {
            uint8_t *buf = st->buf;
            uint8_t *end1 = buf + st->size - 1;
            int shift;

            /* Compute the number of superfluous leading bytes */
            for (; buf < end1; buf++)
                {
                    /*
                     * If the contents octets of an integer value encoding
                     * consist of more than one octet, then the bits of the
                     * first octet and bit 8 of the second octet:
                     * a) shall not all be ones; and
                     * b) shall not all be zero.
                     */
                    switch (*buf)
                        {
                        case 0x00:
                            if ((buf[1] & 0x80) == 0)
                                {
                                    continue;
                                }
                            break;
                        case 0xff:
                            if ((buf[1] & 0x80))
                                {
                                    continue;
                                }
                            break;
                        }
                    break;
                }

            /* Remove leading superfluous bytes from the integer */
            shift = buf - st->buf;
            if (shift)
                {
                    uint8_t *nb = st->buf;
                    uint8_t *end;

                    st->size -= shift; /* New size, minus bad bytes */
                    end = nb + st->size;

                    for (; nb < end; nb++, buf++)
                        {
                            *nb = *buf;
                        }
                }

        } /* if(1) */

    return der_encode_primitive(td, sptr, tag_mode, tag, cb, app_key);
}

static const asn_INTEGER_enum_map_t *INTEGER_map_enum2value(
    asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop);

/*
 * INTEGER specific human-readable output.
 */
static ssize_t INTEGER__dump(asn_TYPE_descriptor_t *td, const INTEGER_t *st,
    asn_app_consume_bytes_f *cb, void *app_key,
    int plainOrXER)
{
    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
    char scratch[32]; /* Enough for 64-bit integer */
    uint8_t *buf = st->buf;
    uint8_t *buf_end = st->buf + st->size;
    int64_t accum;
    ssize_t wrote = 0;
    char *p;
    int ret;

    /*
     * Advance buf pointer until the start of the value's body.
     * This will make us able to process large integers using simple case,
     * when the actual value is small
     * (0x0000000000abcdef would yield a fine 0x00abcdef)
     */
    /* Skip the insignificant leading bytes */
    for (; buf < buf_end - 1; buf++)
        {
            switch (*buf)
                {
                case 0x00:
                    if ((buf[1] & 0x80) == 0)
                        {
                            continue;
                        }
                    break;
                case 0xff:
                    if ((buf[1] & 0x80) != 0)
                        {
                            continue;
                        }
                    break;
                }
            break;
        }

    /* Simple case: the integer size is small */
    if ((size_t)(buf_end - buf) <= sizeof(accum))
        {
            const asn_INTEGER_enum_map_t *el;
            size_t scrsize;
            char *scr;

            if (buf == buf_end)
                {
                    accum = 0LL;
                }
            else
                {
                    accum = (*buf & 0x80) ? -1LL : 0LL;
                    for (; buf < buf_end; buf++)
                        {
                            accum = (accum * 256) | *buf;
                        }
                }

            el = INTEGER_map_value2enum(specs, accum);
            if (el)
                {
                    scrsize = el->enum_len + 32;
                    scr = (char *)alloca(scrsize);
                    if (plainOrXER == 0)
                        {
                            ret = snprintf(scr, scrsize, "%+" PRId64 "(%s)", accum,
                                el->enum_name);
                        }
                    else
                        {
                            ret = snprintf(scr, scrsize, "<%s/>", el->enum_name);
                        }
                }
            else if (plainOrXER && specs && specs->strict_enumeration)
                {
                    ASN_DEBUG(
                        "ASN.1 forbids dealing with "
                        "unknown value of ENUMERATED type");
                    errno = EPERM;
                    return -1;
                }
            else
                {
                    scrsize = sizeof(scratch);
                    scr = scratch;
                    ret =
                        snprintf(scr, scrsize,
                            (specs && specs->field_unsigned) ? "%" PRIu64
                                                             : "%+" PRId64,
                            accum);
                }
            assert(ret > 0 && (size_t)ret < scrsize);
            return (cb(scr, ret, app_key) < 0) ? -1 : ret;
        }
    else if (plainOrXER && specs && specs->strict_enumeration)
        {
            /*
             * Here and earlier, we cannot encode the ENUMERATED values
             * if there is no corresponding identifier.
             */
            ASN_DEBUG(
                "ASN.1 forbids dealing with "
                "unknown value of ENUMERATED type");
            errno = EPERM;
            return -1;
        }

    /* Output in the int64_t xx:yy:zz... format */
    /* TODO: replace with generic algorithm (Knuth TAOCP Vol 2, 4.3.1) */
    for (p = scratch; buf < buf_end; buf++)
        {
            static const char *h2c = "0123456789ABCDEF";
            if ((p - scratch) >= (ssize_t)(sizeof(scratch) - 4))
                {
                    /* Flush buffer */
                    if (cb(scratch, p - scratch, app_key) < 0)
                        {
                            return -1;
                        }
                    wrote += p - scratch;
                    p = scratch;
                }
            *p++ = h2c[*buf >> 4];
            *p++ = h2c[*buf & 0x0F];
            *p++ = 0x3a; /* ":" */
        }
    if (p != scratch)
        {
            p--; /* Remove the last ":" */
        }

    wrote += p - scratch;
    return (cb(scratch, p - scratch, app_key) < 0) ? -1 : wrote;
}

/*
 * INTEGER specific human-readable output.
 */
int INTEGER_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
    asn_app_consume_bytes_f *cb, void *app_key)
{
    const INTEGER_t *st = (const INTEGER_t *)sptr;
    ssize_t ret;

    (void)td;
    (void)ilevel;

    if (!st || !st->buf)
        {
            ret = cb("<absent>", 8, app_key);
        }
    else
        {
            ret = INTEGER__dump(td, st, cb, app_key, 0);
        }

    return (ret < 0) ? -1 : 0;
}

struct e2v_key
{
    const char *start;
    const char *stop;
    asn_INTEGER_enum_map_t *vemap;
    unsigned int *evmap;
};
static int INTEGER__compar_enum2value(const void *kp, const void *am)
{
    const struct e2v_key *key = (const struct e2v_key *)kp;
    const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
    const char *ptr;
    const char *end;
    const char *name;

    /* Remap the element (sort by different criterion) */
    el = key->vemap + key->evmap[el - key->vemap];

    /* Compare strings */
    for (ptr = key->start, end = key->stop, name = el->enum_name; ptr < end;
        ptr++, name++)
        {
            if (*ptr != *name)
                {
                    return *(const unsigned char *)ptr -
                           *(const unsigned char *)name;
                }
        }
    return name[0] ? -1 : 0;
}

static const asn_INTEGER_enum_map_t *INTEGER_map_enum2value(
    asn_INTEGER_specifics_t *specs, const char *lstart, const char *lstop)
{
    asn_INTEGER_enum_map_t *el_found;
    int count = specs ? specs->map_count : 0;
    struct e2v_key key;
    const char *lp;

    if (!count)
        {
            return NULL;
        }

    /* Guaranteed: assert(lstart < lstop); */
    /* Figure out the tag name */
    for (lstart++, lp = lstart; lp < lstop; lp++)
        {
            switch (*lp)
                {
                case 9:
                case 10:
                case 11:
                case 12:
                case 13:
                case 32:   /* WSP */
                case 0x2f: /* '/' */
                case 0x3e: /* '>' */
                    break;
                default:
                    continue;
                }
            break;
        }
    if (lp == lstop)
        {
            return NULL; /* No tag found */
        }
    lstop = lp;

    key.start = lstart;
    key.stop = lstop;
    key.vemap = specs->value2enum;
    key.evmap = specs->enum2value;
    el_found = (asn_INTEGER_enum_map_t *)bsearch(&key, specs->value2enum, count,
        sizeof(specs->value2enum[0]),
        INTEGER__compar_enum2value);
    if (el_found)
        {
            /* Remap enum2value into value2enum */
            el_found = key.vemap + key.evmap[el_found - key.vemap];
        }
    return el_found;
}

static int INTEGER__compar_value2enum(const void *kp, const void *am)
{
    int64_t a = *(const int64_t *)kp;
    const asn_INTEGER_enum_map_t *el = (const asn_INTEGER_enum_map_t *)am;
    int64_t b = el->nat_value;
    if (a < b)
        {
            return -1;
        }
    else if (a == b)
        {
            return 0;
        }
    else
        {
            return 1;
        }
}

const asn_INTEGER_enum_map_t *INTEGER_map_value2enum(
    asn_INTEGER_specifics_t *specs, int64_t value)
{
    int count = specs ? specs->map_count : 0;
    if (!count)
        {
            return 0;
        }
    return (asn_INTEGER_enum_map_t *)bsearch(&value, specs->value2enum, count,
        sizeof(specs->value2enum[0]),
        INTEGER__compar_value2enum);
}

static int INTEGER_st_prealloc(INTEGER_t *st, int min_size)
{
    void *p = MALLOC(min_size + 1);
    if (p)
        {
            void *b = st->buf;
            st->size = 0;
            st->buf = p;
            FREEMEM(b);
            return 0;
        }
    else
        {
            return -1;
        }
}

/*
 * Decode the chunk of XML text encoding INTEGER.
 */
static enum xer_pbd_rval INTEGER__xer_body_decode(asn_TYPE_descriptor_t *td,
    void *sptr,
    const void *chunk_buf,
    size_t chunk_size)
{
    INTEGER_t *st = (INTEGER_t *)sptr;
    int64_t sign = 1LL;
    int64_t value;
    const char *lp;
    const char *lstart = (const char *)chunk_buf;
    const char *lstop = lstart + chunk_size;
    enum
    {
        ST_SKIPSPACE,
        ST_SKIPSPHEX,
        ST_WAITDIGITS,
        ST_DIGITS,
        ST_HEXDIGIT1,
        ST_HEXDIGIT2,
        ST_HEXCOLON,
        ST_EXTRASTUFF
    } state = ST_SKIPSPACE;

    if (chunk_size)
        {
            ASN_DEBUG("INTEGER body %ld 0x%2x..0x%2x", (int64_t)chunk_size, *lstart,
                lstop[-1]);
        }

    /*
     * We may have received a tag here. It will be processed inline.
     * Use strtoul()-like code and serialize the result.
     */
    for (value = 0, lp = lstart; lp < lstop; lp++)
        {
            int lv = *lp;
            switch (lv)
                {
                case 0x09:
                case 0x0a:
                case 0x0d:
                case 0x20:
                    switch (state)
                        {
                        case ST_SKIPSPACE:
                        case ST_SKIPSPHEX:
                            continue;
                        case ST_HEXCOLON:
                            if (xer_is_whitespace(lp, lstop - lp))
                                {
                                    lp = lstop - 1;
                                    continue;
                                }
                            break;
                        default:
                            break;
                        }
                    break;
                case 0x2d: /* '-' */
                    if (state == ST_SKIPSPACE)
                        {
                            sign = -1;
                            state = ST_WAITDIGITS;
                            continue;
                        }
                    break;
                case 0x2b: /* '+' */
                    if (state == ST_SKIPSPACE)
                        {
                            state = ST_WAITDIGITS;
                            continue;
                        }
                    break;
                case 0x30:
                case 0x31:
                case 0x32:
                case 0x33:
                case 0x34:
                case 0x35:
                case 0x36:
                case 0x37:
                case 0x38:
                case 0x39:
                    switch (state)
                        {
                        case ST_DIGITS:
                            break;
                        case ST_SKIPSPHEX: /* Fall through */
                        case ST_HEXDIGIT1:
                            value = (lv - 0x30) << 4;
                            state = ST_HEXDIGIT2;
                            continue;
                        case ST_HEXDIGIT2:
                            value += (lv - 0x30);
                            state = ST_HEXCOLON;
                            st->buf[st->size++] = (uint8_t)value;
                            continue;
                        case ST_HEXCOLON:
                            return XPBD_BROKEN_ENCODING;
                        default:
                            state = ST_DIGITS;
                            break;
                        }

                    {
                        int64_t new_value = value * 10;

                        if (new_value / 10 != value)
                            { /* Overflow */
                                return XPBD_DECODER_LIMIT;
                            }

                        value = new_value + (lv - 0x30);
                        /* Check for two's complement overflow */
                        if (value < 0)
                            {
                                /* Check whether it is a LONG_MIN */
                                if (sign == -1 &&
                                    (uint64_t)value == ~((uint64_t)-1 >> 1))
                                    {
                                        sign = 1;
                                    }
                                else
                                    {
                                        /* Overflow */
                                        return XPBD_DECODER_LIMIT;
                                    }
                            }
                    }
                    continue;
                case 0x3c: /* '<' */
                    if (state == ST_SKIPSPACE)
                        {
                            const asn_INTEGER_enum_map_t *el;
                            el = INTEGER_map_enum2value(
                                (asn_INTEGER_specifics_t *)td->specifics,
                                lstart, lstop);
                            if (el)
                                {
                                    ASN_DEBUG("Found \"%s\" => %ld",
                                        el->enum_name, el->nat_value);
                                    state = ST_DIGITS;
                                    value = el->nat_value;
                                    lp = lstop - 1;
                                    continue;
                                }
                            ASN_DEBUG("Unknown identifier for INTEGER");
                        }
                    return XPBD_BROKEN_ENCODING;
                case 0x3a: /* ':' */
                    if (state == ST_HEXCOLON)
                        {
                            /* This colon is expected */
                            state = ST_HEXDIGIT1;
                            continue;
                        }
                    else if (state == ST_DIGITS)
                        {
                            /* The colon here means that we have
                             * decoded the first two hexadecimal
                             * places as a decimal value.
                             * Switch decoding mode. */
                            ASN_DEBUG("INTEGER re-evaluate as hex form");
                            if (INTEGER_st_prealloc(st,
                                    (chunk_size / 3) + 1))
                                {
                                    return XPBD_SYSTEM_FAILURE;
                                }
                            state = ST_SKIPSPHEX;
                            lp = lstart - 1;
                            continue;
                        }
                    else
                        {
                            ASN_DEBUG("state %d at %d", state, lp - lstart);
                            break;
                        }
                /* [A-Fa-f] */
                case 0x41:
                case 0x42:
                case 0x43:
                case 0x44:
                case 0x45:
                case 0x46:
                case 0x61:
                case 0x62:
                case 0x63:
                case 0x64:
                case 0x65:
                case 0x66:
                    switch (state)
                        {
                        case ST_SKIPSPHEX:
                        case ST_SKIPSPACE: /* Fall through */
                        case ST_HEXDIGIT1:
                            value = lv - ((lv < 0x61) ? 0x41 : 0x61);
                            value += 10;
                            value <<= 4;
                            state = ST_HEXDIGIT2;
                            continue;
                        case ST_HEXDIGIT2:
                            value += lv - ((lv < 0x61) ? 0x41 : 0x61);
                            value += 10;
                            st->buf[st->size++] = (uint8_t)value;
                            state = ST_HEXCOLON;
                            continue;
                        case ST_DIGITS:
                            ASN_DEBUG(
                                "INTEGER re-evaluate as hex form");
                            if (INTEGER_st_prealloc(
                                    st, (chunk_size / 3) + 1))
                                {
                                    return XPBD_SYSTEM_FAILURE;
                                }
                            state = ST_SKIPSPHEX;
                            lp = lstart - 1;
                            continue;
                        default:
                            break;
                        }
                    break;
                }

            /* Found extra non-numeric stuff */
            ASN_DEBUG("Found non-numeric 0x%2x at %d", lv, lp - lstart);
            state = ST_EXTRASTUFF;
            break;
        }

    switch (state)
        {
        case ST_DIGITS:
            /* Everything is cool */
            break;
        case ST_HEXCOLON:
            st->buf[st->size] = 0; /* Just in case termination */
            return XPBD_BODY_CONSUMED;
        case ST_HEXDIGIT1:
        case ST_HEXDIGIT2:
        case ST_SKIPSPHEX:
            return XPBD_BROKEN_ENCODING;
        default:
            if (xer_is_whitespace(lp, lstop - lp))
                {
                    if (state != ST_EXTRASTUFF)
                        {
                            return XPBD_NOT_BODY_IGNORE;
                        }
                    break;
                }
            else
                {
                    ASN_DEBUG("INTEGER: No useful digits (state %d)",
                        state);
                    return XPBD_BROKEN_ENCODING; /* No digits */
                }
            break;
        }

    value *= sign; /* Change sign, if needed */

    if (asn_long2INTEGER(st, value))
        {
            return XPBD_SYSTEM_FAILURE;
        }

    return XPBD_BODY_CONSUMED;
}

asn_dec_rval_t INTEGER_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
    asn_TYPE_descriptor_t *td, void **sptr,
    const char *opt_mname, const void *buf_ptr,
    size_t size)
{
    return xer_decode_primitive(opt_codec_ctx, td, sptr, sizeof(INTEGER_t),
        opt_mname, buf_ptr, size,
        INTEGER__xer_body_decode);
}

asn_enc_rval_t INTEGER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
    int ilevel, enum xer_encoder_flags_e flags,
    asn_app_consume_bytes_f *cb, void *app_key)
{
    const INTEGER_t *st = (const INTEGER_t *)sptr;
    asn_enc_rval_t er;

    (void)ilevel;
    (void)flags;

    if (!st || !st->buf)
        {
            _ASN_ENCODE_FAILED;
        }

    er.encoded = INTEGER__dump(td, st, cb, app_key, 1);
    if (er.encoded < 0)
        {
            _ASN_ENCODE_FAILED;
        }

    _ASN_ENCODED_OK(er);
}

asn_dec_rval_t INTEGER_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
    asn_TYPE_descriptor_t *td,
    asn_per_constraints_t *constraints,
    void **sptr, asn_per_data_t *pd)
{
    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
    asn_dec_rval_t rval = {RC_OK, 0};
    INTEGER_t *st = (INTEGER_t *)*sptr;
    asn_per_constraint_t *ct;
    int repeat;

    (void)opt_codec_ctx;

    if (!st)
        {
            st = (INTEGER_t *)(*sptr = CALLOC(1, sizeof(*st)));
            if (!st)
                {
                    _ASN_DECODE_FAILED;
                }
        }

    if (!constraints)
        {
            constraints = td->per_constraints;
        }
    ct = constraints ? &constraints->value : 0;

    if (ct && ct->flags & APC_EXTENSIBLE)
        {
            int inext = per_get_few_bits(pd, 1);
            if (inext < 0)
                {
                    _ASN_DECODE_STARVED;
                }
            if (inext)
                {
                    ct = 0;
                }
        }

    FREEMEM(st->buf);
    st->buf = 0;
    st->size = 0;
    if (ct)
        {
            if (ct->flags & APC_SEMI_CONSTRAINED)
                {
                    st->buf = (uint8_t *)CALLOC(1, 2);
                    if (!st->buf)
                        {
                            _ASN_DECODE_FAILED;
                        }
                    st->size = 1;
                }
            else if (ct->flags & APC_CONSTRAINED && ct->range_bits >= 0)
                {
                    size_t size = (ct->range_bits + 7) >> 3;
                    st->buf = (uint8_t *)MALLOC(1 + size + 1);
                    if (!st->buf)
                        {
                            _ASN_DECODE_FAILED;
                        }
                    st->size = size;
                }
        }

    /* X.691, #12.2.2 */
    if (ct && ct->flags != APC_UNCONSTRAINED)
        {
            /* #10.5.6 */
            ASN_DEBUG("Integer with range %d bits", ct->range_bits);
            if (ct->range_bits >= 0)
                {
                    int64_t value;
                    if (ct->range_bits == 32)
                        {
                            int64_t lhalf;
                            value = per_get_few_bits(pd, 16);
                            if (value < 0)
                                {
                                    _ASN_DECODE_STARVED;
                                }
                            lhalf = per_get_few_bits(pd, 16);
                            if (lhalf < 0)
                                {
                                    _ASN_DECODE_STARVED;
                                }
                            value = (value << 16) | lhalf;
                        }
                    else
                        {
                            value = per_get_few_bits(pd, ct->range_bits);
                            if (value < 0)
                                {
                                    _ASN_DECODE_STARVED;
                                }
                        }
                    ASN_DEBUG("Got value %ld + low %ld", value,
                        ct->lower_bound);
                    value += ct->lower_bound;
                    if ((specs && specs->field_unsigned)
                            ? asn_ulong2INTEGER(st, value)
                            : asn_long2INTEGER(st, value))
                        {
                            _ASN_DECODE_FAILED;
                        }
                    return rval;
                }
        }
    else
        {
            ASN_DEBUG("Decoding unconstrained integer %s", td->name);
        }

    /* X.691, #12.2.3, #12.2.4 */
    do
        {
            ssize_t len;
            void *p;
            int ret;

            /* Get the PER length */
            len = uper_get_length(pd, -1, &repeat);
            if (len < 0)
                {
                    _ASN_DECODE_STARVED;
                }

            p = REALLOC(st->buf, st->size + len + 1);
            if (!p)
                {
                    _ASN_DECODE_FAILED;
                }
            st->buf = (uint8_t *)p;

            ret = per_get_many_bits(pd, &st->buf[st->size], 0, 8 * len);
            if (ret < 0)
                {
                    _ASN_DECODE_STARVED;
                }
            st->size += len;
        }
    while (repeat);
    st->buf[st->size] = 0; /* JIC */

    /* #12.2.3 */
    if (ct && ct->lower_bound)
        {
            /*
             * TODO: replace by in-place arithmetics.
             */
            int64_t value;
            if (asn_INTEGER2long(st, &value))
                {
                    _ASN_DECODE_FAILED;
                }
            if (asn_long2INTEGER(st, value + ct->lower_bound))
                {
                    _ASN_DECODE_FAILED;
                }
        }

    return rval;
}

asn_enc_rval_t INTEGER_encode_uper(asn_TYPE_descriptor_t *td,
    asn_per_constraints_t *constraints,
    void *sptr, asn_per_outp_t *po)
{
    asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
    asn_enc_rval_t er;
    INTEGER_t *st = (INTEGER_t *)sptr;
    const uint8_t *buf;
    const uint8_t *end;
    asn_per_constraint_t *ct;
    int64_t value = 0;

    if (!st || st->size == 0)
        {
            _ASN_ENCODE_FAILED;
        }

    if (!constraints)
        {
            constraints = td->per_constraints;
        }
    ct = constraints ? &constraints->value : 0;

    er.encoded = 0;

    if (ct)
        {
            int inext = 0;
            if (specs && specs->field_unsigned)
                {
                    uint64_t uval;
                    if (asn_INTEGER2ulong(st, &uval))
                        {
                            _ASN_ENCODE_FAILED;
                        }
                    /* Check proper range */
                    if (ct->flags & APC_SEMI_CONSTRAINED)
                        {
                            if (uval < (uint64_t)ct->lower_bound)
                                {
                                    inext = 1;
                                }
                        }
                    else if (ct->range_bits >= 0)
                        {
                            if (uval < (uint64_t)ct->lower_bound ||
                                uval > (uint64_t)ct->upper_bound)
                                {
                                    inext = 1;
                                }
                        }
                    ASN_DEBUG("Value %lu (%02x/%d) lb %lu ub %lu %s", uval,
                        st->buf[0], st->size, ct->lower_bound,
                        ct->upper_bound, inext ? "ext" : "fix");
                    value = uval;
                }
            else
                {
                    if (asn_INTEGER2long(st, &value))
                        {
                            _ASN_ENCODE_FAILED;
                        }
                    /* Check proper range */
                    if (ct->flags & APC_SEMI_CONSTRAINED)
                        {
                            if (value < ct->lower_bound)
                                {
                                    inext = 1;
                                }
                        }
                    else if (ct->range_bits >= 0)
                        {
                            if (value < ct->lower_bound ||
                                value > ct->upper_bound)
                                {
                                    inext = 1;
                                }
                        }
                    ASN_DEBUG("Value %ld (%02x/%d) lb %ld ub %ld %s", value,
                        st->buf[0], st->size, ct->lower_bound,
                        ct->upper_bound, inext ? "ext" : "fix");
                }
            if (ct->flags & APC_EXTENSIBLE)
                {
                    if (per_put_few_bits(po, inext, 1))
                        {
                            _ASN_ENCODE_FAILED;
                        }
                    if (inext)
                        {
                            ct = 0;
                        }
                }
            else if (inext)
                {
                    _ASN_ENCODE_FAILED;
                }
        }

    /* X.691, #12.2.2 */
    if (ct && ct->range_bits >= 0)
        {
            /* #10.5.6 */
            ASN_DEBUG("Encoding integer with range %d bits", ct->range_bits);
            if (ct->range_bits == 32)
                {
                    /* TODO: extend to >32 bits */
                    int64_t v = value - ct->lower_bound;
                    if (per_put_few_bits(po, v >> 1, 31) ||
                        per_put_few_bits(po, v, 1))
                        {
                            _ASN_ENCODE_FAILED;
                        }
                }
            else
                {
                    if (per_put_few_bits(po, value - ct->lower_bound,
                            ct->range_bits))
                        {
                            _ASN_ENCODE_FAILED;
                        }
                }
            _ASN_ENCODED_OK(er);
        }

    if (ct && ct->lower_bound)
        {
            ASN_DEBUG("Adjust lower bound to %ld", ct->lower_bound);
            /* TODO: adjust lower bound */
            _ASN_ENCODE_FAILED;
        }

    for (buf = st->buf, end = st->buf + st->size; buf < end;)
        {
            ssize_t mayEncode = uper_put_length(po, end - buf);
            if (mayEncode < 0)
                {
                    _ASN_ENCODE_FAILED;
                }
            if (per_put_many_bits(po, buf, 8 * mayEncode))
                {
                    _ASN_ENCODE_FAILED;
                }
            buf += mayEncode;
        }

    _ASN_ENCODED_OK(er);
}

int asn_INTEGER2long(const INTEGER_t *iptr, int64_t *lptr)
{
    uint8_t *b;
    uint8_t *end;
    size_t size;
    int64_t l;

    /* Sanity checking */
    if (!iptr || !iptr->buf || !lptr)
        {
            errno = EINVAL;
            return -1;
        }

    /* Cache the begin/end of the buffer */
    b = iptr->buf; /* Start of the INTEGER buffer */
    size = iptr->size;
    end = b + size; /* Where to stop */

    if (size > sizeof(int64_t))
        {
            uint8_t *end1 = end - 1;
            /*
             * Slightly more advanced processing,
             * able to >sizeof(int64_t) bytes,
             * when the actual value is small
             * (0x0000000000abcdef would yield a fine 0x00abcdef)
             */
            /* Skip out the insignificant leading bytes */
            for (; b < end1; b++)
                {
                    switch (*b)
                        {
                        case 0x00:
                            if ((b[1] & 0x80) == 0)
                                {
                                    continue;
                                }
                            break;
                        case 0xff:
                            if ((b[1] & 0x80) != 0)
                                {
                                    continue;
                                }
                            break;
                        }
                    break;
                }

            size = end - b;
            if (size > sizeof(int64_t))
                {
                    /* Still cannot fit the int64_t */
                    errno = ERANGE;
                    return -1;
                }
        }

    /* Shortcut processing of a corner case */
    if (end == b)
        {
            *lptr = 0;
            return 0;
        }

    /* Perform the sign initialization */
    /* Actually l = -(*b >> 7); gains nothing, yet unreadable! */
    if ((*b >> 7))
        {
            l = -1;
        }
    else
        {
            l = 0;
        }

    /* Conversion engine */
    for (; b < end; b++)
        {
            l = (l * 256) | *b;
        }

    *lptr = l;
    return 0;
}

int asn_INTEGER2ulong(const INTEGER_t *iptr, uint64_t *lptr)
{
    uint8_t *b;
    uint8_t *end;
    uint64_t l;
    size_t size;

    if (!iptr || !iptr->buf || !lptr)
        {
            errno = EINVAL;
            return -1;
        }

    b = iptr->buf;
    size = iptr->size;
    end = b + size;

    /* If all extra leading bytes are zeroes, ignore them */
    for (; size > sizeof(uint64_t); b++, size--)
        {
            if (*b)
                {
                    /* Value won't fit uint64_t */
                    errno = ERANGE;
                    return -1;
                }
        }

    /* Conversion engine */
    for (l = 0; b < end; b++)
        {
            l = (l << 8) | *b;
        }

    *lptr = l;
    return 0;
}

int asn_ulong2INTEGER(INTEGER_t *st, uint64_t value)
{
    uint8_t *buf;
    uint8_t *end;
    uint8_t *b;
    int shr;

    if (value <= LONG_MAX)
        {
            return asn_long2INTEGER(st, value);
        }

    buf = (uint8_t *)MALLOC(1 + sizeof(value));
    if (!buf)
        {
            return -1;
        }

    end = buf + (sizeof(value) + 1);
    buf[0] = 0;
    for (b = buf + 1, shr = (sizeof(int64_t) - 1) * 8; b < end; shr -= 8, b++)
        {
            *b = (uint8_t)(value >> shr);
        }

    if (st->buf)
        {
            FREEMEM(st->buf);
        }
    st->buf = buf;
    st->size = 1 + sizeof(value);

    return 0;
}

int asn_long2INTEGER(INTEGER_t *st, int64_t value)
{
    uint8_t *buf;
    uint8_t *bp;
    uint8_t *p;
    uint8_t *pstart;
    uint8_t *pend1;
    int littleEndian = 1; /* Run-time detection */
    int add;

    if (!st)
        {
            errno = EINVAL;
            return -1;
        }

    buf = (uint8_t *)MALLOC(16);
    if (!buf)
        {
            return -1;
        }

    if (*(char *)&littleEndian)
        {
            pstart = (uint8_t *)&value + sizeof(value) - 1;
            pend1 = (uint8_t *)&value;
            add = -1;
        }
    else
        {
            pstart = (uint8_t *)&value;
            pend1 = pstart + sizeof(value) - 1;
            add = 1;
        }

    /*
     * If the contents octet consists of more than one octet,
     * then bits of the first octet and bit 8 of the second octet:
     * a) shall not all be ones; and
     * b) shall not all be zero.
     */
    for (p = pstart; p != pend1; p += add)
        {
            switch (*p)
                {
                case 0x00:
                    if ((*(p + add) & 0x80) == 0)
                        {
                            continue;
                        }
                    break;
                case 0xff:
                    if ((*(p + add) & 0x80))
                        {
                            continue;
                        }
                    break;
                }
            break;
        }
    /* Copy the integer body */
    for (pstart = p, bp = buf, pend1 += add; p != pend1; p += add)
        {
            *bp++ = *p;
        }

    if (st->buf)
        {
            FREEMEM(st->buf);
        }
    st->buf = buf;
    st->size = bp - buf;

    return 0;
}
