gnss-sdr/src/core/libs/supl/asn-rrlp/BIT_STRING.c

/*-
 * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
 * Redistribution and modifications are permitted subject to BSD license.
 */
#include <BIT_STRING.h>
#include <asn_internal.h>

/*
 * BIT STRING basic type description.
 */
static ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
    (ASN_TAG_CLASS_UNIVERSAL | (3 << 2))};
static asn_OCTET_STRING_specifics_t asn_DEF_BIT_STRING_specs = {
    sizeof(BIT_STRING_t), offsetof(BIT_STRING_t, _asn_ctx), ASN_OSUBV_BIT};
asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
    "BIT STRING",
    "BIT_STRING",
    OCTET_STRING_free, /* Implemented in terms of OCTET STRING */
    BIT_STRING_print,
    BIT_STRING_constraint,
    OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */
    OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */
    OCTET_STRING_decode_xer_binary,
    BIT_STRING_encode_xer,
    OCTET_STRING_decode_uper, /* Unaligned PER decoder */
    OCTET_STRING_encode_uper, /* Unaligned PER encoder */
    0,                        /* Use generic outmost tag fetcher */
    asn_DEF_BIT_STRING_tags,
    sizeof(asn_DEF_BIT_STRING_tags) / sizeof(asn_DEF_BIT_STRING_tags[0]),
    asn_DEF_BIT_STRING_tags, /* Same as above */
    sizeof(asn_DEF_BIT_STRING_tags) / sizeof(asn_DEF_BIT_STRING_tags[0]),
    0, /* No PER visible constraints */
    0,
    0, /* No members */
    &asn_DEF_BIT_STRING_specs};

/*
 * BIT STRING generic constraint.
 */
int BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
    asn_app_constraint_failed_f *ctfailcb, void *app_key)
{
    const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;

    if (st && st->buf)
        {
            if ((st->size == 0 && st->bits_unused) || st->bits_unused < 0 ||
                st->bits_unused > 7)
                {
                    _ASN_CTFAIL(app_key, td, sptr,
                        "%s: invalid padding byte (%s:%d)", td->name,
                        __FILE__, __LINE__);
                    return -1;
                }
        }
    else
        {
            _ASN_CTFAIL(app_key, td, sptr, "%s: value not given (%s:%d)",
                td->name, __FILE__, __LINE__);
            return -1;
        }

    return 0;
}

static char *_bit_pattern[16] = {"0000", "0001", "0010", "0011", "0100", "0101",
    "0110", "0111", "1000", "1001", "1010", "1011",
    "1100", "1101", "1110", "1111"};

asn_enc_rval_t BIT_STRING_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)
{
    asn_enc_rval_t er;
    char scratch[128];
    char *p = scratch;
    char *scend = scratch + (sizeof(scratch) - 10);
    const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
    int xcan = (flags & XER_F_CANONICAL);
    uint8_t *buf;
    uint8_t *end;

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

    er.encoded = 0;

    buf = st->buf;
    end = buf + st->size - 1; /* Last byte is special */

    /*
     * Binary dump
     */
    for (; buf < end; buf++)
        {
            int v = *buf;
            int nline = xcan ? 0 : (((buf - st->buf) % 8) == 0);
            if (p >= scend || nline)
                {
                    er.encoded += p - scratch;
                    _ASN_CALLBACK(scratch, p - scratch);
                    p = scratch;
                    if (nline)
                        {
                            _i_ASN_TEXT_INDENT(1, ilevel);
                        }
                }
            memcpy(p + 0, _bit_pattern[v >> 4], 4);
            memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
            p += 8;
        }

    if (!xcan && ((buf - st->buf) % 8) == 0)
        {
            _i_ASN_TEXT_INDENT(1, ilevel);
        }
    er.encoded += p - scratch;
    _ASN_CALLBACK(scratch, p - scratch);
    p = scratch;

    if (buf == end)
        {
            int v = *buf;
            int ubits = st->bits_unused;
            int i;
            for (i = 7; i >= ubits; i--)
                {
                    *p++ = (v & (1 << i)) ? 0x31 : 0x30;
                }
            er.encoded += p - scratch;
            _ASN_CALLBACK(scratch, p - scratch);
        }

    if (!xcan)
        {
            _i_ASN_TEXT_INDENT(1, ilevel - 1);
        }

    _ASN_ENCODED_OK(er);
cb_failed:
    _ASN_ENCODE_FAILED;
}

/*
 * BIT STRING specific contents printer.
 */
int BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
    asn_app_consume_bytes_f *cb, void *app_key)
{
    static const char *h2c = "0123456789ABCDEF";
    char scratch[64];
    const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
    uint8_t *buf;
    uint8_t *end;
    char *p = scratch;

    (void)td; /* Unused argument */

    if (!st || !st->buf)
        {
            return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
        }

    ilevel++;
    buf = st->buf;
    end = buf + st->size;

    /*
     * Hexadecimal dump.
     */
    for (; buf < end; buf++)
        {
            if ((buf - st->buf) % 16 == 0 && (st->size > 16) && buf != st->buf)
                {
                    _i_INDENT(1);
                    /* Dump the string */
                    if (cb(scratch, p - scratch, app_key) < 0)
                        {
                            return -1;
                        }
                    p = scratch;
                }
            *p++ = h2c[*buf >> 4];
            *p++ = h2c[*buf & 0x0F];
            *p++ = 0x20;
        }

    if (p > scratch)
        {
            p--; /* Eat the tailing space */

            if ((st->size > 16))
                {
                    _i_INDENT(1);
                }

            /* Dump the incomplete 16-bytes row */
            if (cb(scratch, p - scratch, app_key) < 0)
                {
                    return -1;
                }
        }

    return 0;
}