/*-

 * 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);

}