ber_decoder.c

Go to the documentation of this file.

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

#undef  ADVANCE
#define ADVANCE(num_bytes)  do {                    \
        size_t num = num_bytes;                 \
        ptr = ((const char *)ptr) + num;            \
        size -= num;                        \
        consumed_myself += num;                 \
    } while(0)
#undef  RETURN
#define RETURN(_code)   do {                        \
        asn_dec_rval_t rval;                    \
        rval.code = _code;                  \
        if(opt_ctx) opt_ctx->step = step; /* Save context */    \
        if(_code == RC_OK || opt_ctx)               \
            rval.consumed = consumed_myself;        \
        else                            \
            rval.consumed = 0;  /* Context-free */  \
        return rval;                        \
    } while(0)

/*
 * The BER decoder of any type.
 */
asn_dec_rval_t
ber_decode(asn_codec_ctx_t *opt_codec_ctx,
    asn_TYPE_descriptor_t *type_descriptor,
    void **struct_ptr, const void *ptr, size_t size) {
    asn_codec_ctx_t s_codec_ctx;

    /*
     * Stack checker requires that the codec context
     * must be allocated on the stack.
     */
    if(opt_codec_ctx) {
        if(opt_codec_ctx->max_stack_size) {
            s_codec_ctx = *opt_codec_ctx;
            opt_codec_ctx = &s_codec_ctx;
        }
    } else {
        /* If context is not given, be security-conscious anyway */
        memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));
        s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX;
        opt_codec_ctx = &s_codec_ctx;
    }

    /*
     * Invoke type-specific decoder.
     */
    return type_descriptor->ber_decoder(opt_codec_ctx, type_descriptor,
        struct_ptr, /* Pointer to the destination structure */
        ptr, size,  /* Buffer and its size */
        0       /* Default tag mode is 0 */
        );
}

/*
 * Check the set of <TL<TL<TL...>>> tags matches the definition.
 */
asn_dec_rval_t
ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
        asn_TYPE_descriptor_t *td, asn_struct_ctx_t *opt_ctx,
        const void *ptr, size_t size, int tag_mode, int last_tag_form,
        ber_tlv_len_t *last_length, int *opt_tlv_form) {
    ssize_t consumed_myself = 0;
    ssize_t tag_len;
    ssize_t len_len;
    ber_tlv_tag_t tlv_tag;
    ber_tlv_len_t tlv_len;
    ber_tlv_len_t limit_len = -1;
    int expect_00_terminators = 0;
    int tlv_constr = -1;    /* If CHOICE, opt_tlv_form is not given */
    int step = opt_ctx ? opt_ctx->step : 0; /* Where we left previously */
    int tagno;

    /*
     * Make sure we didn't exceed the maximum stack size.
     */
    if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
        RETURN(RC_FAIL);

    /*
     * So what does all this implicit skip stuff mean?
     * Imagine two types,
     *  A ::= [5] IMPLICIT  T
     *  B ::= [2] EXPLICIT  T
     * Where T is defined as
     *  T ::= [4] IMPLICIT SEQUENCE { ... }
     * 
     * Let's say, we are starting to decode type A, given the
     * following TLV stream: <5> <0>. What does this mean?
     * It means that the type A contains type T which is,
     * in turn, empty.
     * Remember though, that we are still in A. We cannot
     * just pass control to the type T decoder. Why? Because
     * the type T decoder expects <4> <0>, not <5> <0>.
     * So, we must make sure we are going to receive <5> while
     * still in A, then pass control to the T decoder, indicating
     * that the tag <4> was implicitly skipped. The decoder of T
     * hence will be prepared to treat <4> as valid tag, and decode
     * it appropriately.
     */

    tagno = step    /* Continuing where left previously */
        + (tag_mode==1?-1:0)
        ;
    ASN_DEBUG("ber_check_tags(%s, size=%ld, tm=%d, step=%d, tagno=%d)",
        td->name, (long)size, tag_mode, step, tagno);
    /* assert(td->tags_count >= 1) May not be the case for CHOICE or ANY */

    if(tag_mode == 0 && tagno == td->tags_count) {
        /*
         * This must be the _untagged_ ANY type,
         * which outermost tag isn't known in advance.
         * Fetch the tag and length separately.
         */
        tag_len = ber_fetch_tag(ptr, size, &tlv_tag);
        switch(tag_len) {
        case -1: RETURN(RC_FAIL);
        case 0: RETURN(RC_WMORE);
        }
        tlv_constr = BER_TLV_CONSTRUCTED(ptr);
        len_len = ber_fetch_length(tlv_constr,
            (const char *)ptr + tag_len, size - tag_len, &tlv_len);
        switch(len_len) {
        case -1: RETURN(RC_FAIL);
        case 0: RETURN(RC_WMORE);
        }
        ASN_DEBUG("Advancing %ld in ANY case",
            (long)(tag_len + len_len));
        ADVANCE(tag_len + len_len);
    } else {
        assert(tagno < td->tags_count); /* At least one loop */
    }
    for((void)tagno; tagno < td->tags_count; tagno++, step++) {

        /*
         * Fetch and process T from TLV.
         */
        tag_len = ber_fetch_tag(ptr, size, &tlv_tag);
            ASN_DEBUG("Fetching tag from {%p,%ld}: "
                "len %ld, step %d, tagno %d got %s",
                ptr, (long)size,
                (long)tag_len, step, tagno,
                ber_tlv_tag_string(tlv_tag));
        switch(tag_len) {
        case -1: RETURN(RC_FAIL);
        case 0: RETURN(RC_WMORE);
        }

        tlv_constr = BER_TLV_CONSTRUCTED(ptr);

        /*
         * If {I}, don't check anything.
         * If {I,B,C}, check B and C unless we're at I.
         */
        if(tag_mode != 0 && step == 0) {
            /*
             * We don't expect tag to match here.
             * It's just because we don't know how the tag
             * is supposed to look like.
             */
        } else {
            assert(tagno >= 0); /* Guaranteed by the code above */
            if(tlv_tag != td->tags[tagno]) {
            /*
             * Unexpected tag. Too bad.
             */
                ASN_DEBUG("Expected: %s, "
                "expectation failed (tn=%d, tm=%d)",
                ber_tlv_tag_string(td->tags[tagno]),
                tagno, tag_mode
            );
            RETURN(RC_FAIL);
            }
        }

        /*
         * Attention: if there are more tags expected,
         * ensure that the current tag is presented
         * in constructed form (it contains other tags!).
         * If this one is the last one, check that the tag form
         * matches the one given in descriptor.
         */
        if(tagno < (td->tags_count - 1)) {
            if(tlv_constr == 0) {
                ASN_DEBUG("tlv_constr = %d, expfail",
                    tlv_constr);
                RETURN(RC_FAIL);
            }
        } else {
            if(last_tag_form != tlv_constr
            && last_tag_form != -1) {
                ASN_DEBUG("last_tag_form %d != %d",
                    last_tag_form, tlv_constr);
                RETURN(RC_FAIL);
            }
        }

        /*
         * Fetch and process L from TLV.
         */
        len_len = ber_fetch_length(tlv_constr,
            (const char *)ptr + tag_len, size - tag_len, &tlv_len);
        ASN_DEBUG("Fetching len = %ld", (long)len_len);
        switch(len_len) {
        case -1: RETURN(RC_FAIL);
        case 0: RETURN(RC_WMORE);
        }

        /*
         * FIXME
         * As of today, the chain of tags
         * must either contain several indefinite length TLVs,
         * or several definite length ones.
         * No mixing is allowed.
         */
        if(tlv_len == -1) {
            /*
             * Indefinite length.
             */
            if(limit_len == -1) {
                expect_00_terminators++;
            } else {
                ASN_DEBUG("Unexpected indefinite length "
                    "in a chain of definite lengths");
                RETURN(RC_FAIL);
            }
            ADVANCE(tag_len + len_len);
            continue;
        } else {
            if(expect_00_terminators) {
                ASN_DEBUG("Unexpected definite length "
                    "in a chain of indefinite lengths");
                RETURN(RC_FAIL);
            }
        }

        /*
         * Check that multiple TLVs specify ever decreasing length,
         * which is consistent.
         */
        if(limit_len == -1) {
            limit_len    = tlv_len + tag_len + len_len;
            if(limit_len < 0) {
                /* Too great tlv_len value? */
                RETURN(RC_FAIL);
            }
        } else if(limit_len != tlv_len + tag_len + len_len) {
            /*
             * Inner TLV specifies length which is inconsistent
             * with the outer TLV's length value.
             */
            ASN_DEBUG("Outer TLV is %ld and inner is %ld",
                (long)limit_len, (long)tlv_len);
            RETURN(RC_FAIL);
        }

        ADVANCE(tag_len + len_len);

        limit_len -= (tag_len + len_len);
        if((ssize_t)size > limit_len) {
            /*
             * Make sure that we won't consume more bytes
             * from the parent frame than the inferred limit.
             */
            size = limit_len;
        }
    }

    if(opt_tlv_form)
        *opt_tlv_form = tlv_constr;
    if(expect_00_terminators)
        *last_length = -expect_00_terminators;
    else
        *last_length = tlv_len;

    RETURN(RC_OK);
}