/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  EAP and WLAN authentication protocols.
*
*/

/*
* %version: %
*/

#include "asn1_der_type.h"
#include "eap_automatic_variable.h"

//--------------------------------------------------

EAP_FUNC_EXPORT asn1_der_type_c::~asn1_der_type_c()
{
	delete m_sub_types;
	m_sub_types = 0;
}

//--------------------------------------------------

EAP_FUNC_EXPORT asn1_der_type_c::asn1_der_type_c(
	abs_eap_am_tools_c * const tools)
	: m_am_tools(tools)
	, m_is_valid(false)
	, m_index(0u)
	, m_count_of_sub_types(0u)
	, m_recursion(0ul)
	, m_input_data_length(0ul)
	, m_input_data(0)
	, m_used_octets(0ul)
	, m_offset_of_length_field(0ul)
	, m_offset_of_contents_field(0ul)
	, m_parent_type(0)
	, m_sub_types(0)
{
	m_is_valid = true;
}

//--------------------------------------------------

EAP_FUNC_EXPORT bool asn1_der_type_c::get_is_valid() const
{
	return m_is_valid;
}

//--------------------------------------------------

EAP_FUNC_EXPORT u32_t asn1_der_type_c::get_index() const
{
	return m_index;
}

//--------------------------------------------------

u32_t asn1_der_type_c::get_input_data_length() const
{
	return m_input_data_length;
}

//--------------------------------------------------

const u8_t * asn1_der_type_c::get_input_data() const
{
	return m_input_data;
}

//--------------------------------------------------

u16_t asn1_der_type_c::get_recursion() const
{
	return m_recursion;
}

//--------------------------------------------------

EAP_FUNC_EXPORT eap_const_string asn1_der_type_c::get_class_string() const
{

#if defined(USE_EAP_DEBUG_TRACE)

	asn1_class_e asn1_class = get_class();

	if (asn1_class == asn1_class_universal)
	{
		return("U");
	}
	else if (asn1_class == asn1_class_application)
	{
		return("A");
	}
	else if (asn1_class == asn1_class_context_specific)
	{
		return("C");
	}
	else if (asn1_class == asn1_class_private)
	{
		return("P");
	}
	else
#endif //#if defined(USE_EAP_DEBUG_TRACE)
	{
		return("<Unknown Class>");
	}
}

//--------------------------------------------------

EAP_FUNC_EXPORT eap_const_string asn1_der_type_c::get_pc_string() const
{

#if defined(USE_EAP_DEBUG_TRACE)

	asn1_pc_e pc = get_pc();

	if (pc == asn1_pc_primitive)
	{
		return("P");
	}
	else if (pc == asn1_pc_constructed)
	{
		return("C");
	}
	else
#endif //#if defined(USE_EAP_DEBUG_TRACE)
	{
		return("<Unknown PC>");
	}
}

//--------------------------------------------------

EAP_FUNC_EXPORT eap_const_string asn1_der_type_c::get_tag_string() const
{

#if defined(USE_EAP_DEBUG_TRACE)

	asn1_class_e asn1_class = get_class();
	asn1_tag_e tag = get_tag();

	if (asn1_class == asn1_class_context_specific)
	{
		static const eap_char context[][4] = { "[0]", "[1]", "[2]", "[3]", "[4]", "[5]", "[6]", "[7]", "[8]", "[9]", };
		if (tag < (sizeof(context)/sizeof(context[0])))
		{
			return context[tag];
		}
		else
		{
			return("<Too big context>");
		}
	}
	else
	{
		EAP_IF_RETURN_STRING(tag, asn1_tag_end_of_content)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_boolean)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_integer)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_bit_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_octet_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_null)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_object_identifier)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_object_descriptor)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_external)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_real)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_enumerated)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_empedded_pdv)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_utf8_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_relative_oid)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_unknown_14)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_unknown_15)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_sequence)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_set)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_numeric_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_printable_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_t61_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_videotex_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_ia5_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_utc_time)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_unknown_24)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_graphic_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_visible_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_general_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_universal_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_character_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_bmp_string)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_extented)
		else EAP_IF_RETURN_STRING(tag, asn1_tag_none)
		else
		{
			return("<Unknown Tag>");
		}
	}

#else

	return("<Unknown Tag>");

#endif //#if defined(USE_EAP_DEBUG_TRACE)

}

//--------------------------------------------------

#if defined(USE_EAP_DEBUG_TRACE)

eap_status_e asn1_der_type_c::debug_create_prefix(const u32_t recursion, u8_t * const prefix, const u32_t max_prefix, u32_t * const prefix_length)
{
	if (prefix == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	u32_t offset(0ul);

	for (u32_t ind = 0ul; ind < recursion; ++ind)
	{
		offset += m_am_tools->snprintf(
			&prefix[offset],
			max_prefix - offset,
			"  |\0");

		if (max_prefix <= offset)
		{
			break;
		}
	}

	if (max_prefix > offset)
	{
		prefix[offset] = 0;
	}

	*prefix_length = offset;

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
}

#endif //#if defined(USE_EAP_DEBUG_TRACE)

//--------------------------------------------------

#if defined(USE_EAP_DEBUG_TRACE)

eap_status_e asn1_der_type_c::debug_header(eap_variable_data_c * const debug_buffer)
{
	if (debug_buffer == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	const u32_t max_data_length(m_recursion * SIZE_OF_ONE_OCTET_STRING + m_offset_of_contents_field * SIZE_OF_ONE_OCTET_STRING);

	if (max_data_length > debug_buffer->get_buffer_length())
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_status_e status = debug_buffer->set_data_length(max_data_length);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	u32_t ind(0ul);
	u32_t offset(0ul);

	u8_t * const prefix = reinterpret_cast<u8_t *>(debug_buffer->get_data(max_data_length));

	if (prefix == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	status = debug_create_prefix(m_recursion, prefix, max_data_length, &offset);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	for (ind = 0ul; ind < m_offset_of_length_field && ind < m_input_data_length; ++ind)
	{
		offset += m_am_tools->snprintf(
			debug_buffer->get_data_offset(offset, debug_buffer->get_data_length() - offset),
			debug_buffer->get_data_length() - offset,
			"%02x \0",
			m_input_data[ind]);
	}

	for (ind = m_offset_of_length_field; ind < m_offset_of_contents_field && ind < m_input_data_length; ++ind)
	{
		offset += m_am_tools->snprintf(
			debug_buffer->get_data_offset(offset, debug_buffer->get_data_length() - offset),
			debug_buffer->get_data_length() - offset,
			"%02x \0",
			m_input_data[ind]);
	}

	status = debug_buffer->add_end_null();
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	eap_const_string tag_string = 0;
	eap_char buffer[MAX_STACK_BUFFER];

	if (get_class() == asn1_class_application)
	{
		m_am_tools->snprintf(
			reinterpret_cast<u8_t *>(buffer),
			MAX_STACK_BUFFER,
			"Application[%d]\0",
			get_tag());

		tag_string = buffer;
	}
	else if (get_class() == asn1_class_context_specific)
	{
		m_am_tools->snprintf(
			reinterpret_cast<u8_t *>(buffer),
			MAX_STACK_BUFFER,
			"[%d]\0",
			get_tag());

		tag_string = buffer;
	}
	else
	{
		tag_string = get_tag_string();
	}

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s # %s, %s, %s, length=0x%x=%d, this=0x%08x, index=%d\n"),
			debug_buffer->get_data(max_data_length),
			get_class_string(),
			get_pc_string(),
			tag_string,
			get_content_length(),
			get_content_length(),
			this,
			m_index));

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAP_DEBUG_TRACE)

//--------------------------------------------------

#if defined(USE_EAP_DEBUG_TRACE)

eap_status_e asn1_der_type_c::debug_content(eap_variable_data_c * const debug_buffer)
{
	if (debug_buffer == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	eap_status_e status(eap_status_process_general_error);

	if (get_tag() == asn1_tag_object_identifier)
	{
		status = debug_object_identifier(debug_buffer);
	}
	else
	{
		status = debug_data(debug_buffer);
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAP_DEBUG_TRACE)

//--------------------------------------------------

#if defined(USE_EAP_DEBUG_TRACE)

eap_status_e asn1_der_type_c::debug_data(eap_variable_data_c * const debug_buffer)
{
	if (debug_buffer == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	const u32_t max_prefix_length((m_recursion + 1ul) * SIZE_OF_ONE_OCTET_STRING + COUNT_OF_OCTETS * SIZE_OF_ONE_OCTET_STRING + 1ul);
	const u32_t ascii_length(COUNT_OF_OCTETS + 5ul);

	if ((max_prefix_length + ascii_length) > debug_buffer->get_buffer_length())
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_status_e status = debug_buffer->set_data_length(max_prefix_length + ascii_length);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	u8_t * const prefix = reinterpret_cast<u8_t *>(debug_buffer->get_data(max_prefix_length));
	u8_t * const ascii = reinterpret_cast<u8_t *>(debug_buffer->get_data_offset(max_prefix_length, ascii_length));

	if (prefix == 0 || ascii == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	u32_t ind(0ul);
	u32_t offset(0ul);

	status = debug_create_prefix(m_recursion + 1u, prefix, max_prefix_length, &offset);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	u32_t init_indentation_offset = offset;
	u32_t type_data_size = get_header_length() + get_content_length();
	u32_t data_ind(0ul);
	u32_t ascii_ind(0ul);
	u8_t octet(0);

	for (ind = m_offset_of_contents_field; ind < type_data_size && ind < m_input_data_length; ++ind)
	{
		offset += m_am_tools->snprintf(
			&prefix[offset],
			max_prefix_length - offset,
			"%02x \0",
			m_input_data[ind]);

		octet = m_input_data[ind];

		if (octet < 0x20 || 0x7e < octet)
		{
			octet = '.';
		}

		m_am_tools->snprintf(
			&ascii[ascii_ind],
			ascii_length - ascii_ind,
			"%c\0",
			octet);

		++data_ind;
		++ascii_ind;

		if ((ascii_ind % COUNT_OF_OCTETS) == 0)
		{
			prefix[offset] = 0;
			ascii[ascii_ind] = 0;

			offset = init_indentation_offset;
			ascii_ind = 0ul;

			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("%s |%s|\n"),
					prefix,
					ascii));
		}
	} // for()

	u32_t remainder(ascii_ind % COUNT_OF_OCTETS);

	if (remainder > 0ul)
	{
		for (; ascii_ind < COUNT_OF_OCTETS; ++ascii_ind)
		{
			offset += m_am_tools->snprintf(
				&prefix[offset],
				max_prefix_length - offset,
				"   \0");

			m_am_tools->snprintf(
				&ascii[ascii_ind],
				ascii_length - ascii_ind,
				" \0");
		} // for()

		prefix[offset] = 0;
		ascii[ascii_ind] = 0;

		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("%s |%s|\n"),
				prefix,
				ascii));
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAP_DEBUG_TRACE)

//--------------------------------------------------

#if defined(USE_EAP_DEBUG_TRACE)

eap_status_e asn1_der_type_c::debug_object_identifier(eap_variable_data_c * const debug_buffer)
{
	if (debug_buffer == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	eap_status_e status(eap_status_process_general_error);

	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

	status = debug_buffer->set_data_length(debug_buffer->get_buffer_length());
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	const u32_t recursion(m_recursion + 1u);
	const u32_t max_prefix_length(recursion * SIZE_OF_ONE_OCTET_STRING + 1ul);

	if (debug_buffer->get_buffer_length() < (max_prefix_length + 2ul))
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	const u32_t max_data_output_length((debug_buffer->get_buffer_length() - (max_prefix_length + 2ul))/2ul);
	const u32_t max_plain_output_length(max_data_output_length);

	u32_t prefix_length(0ul);

	u8_t * const prefix = debug_buffer->get_data();
	if (prefix == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	status = debug_create_prefix(recursion, prefix, max_prefix_length, &prefix_length);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	u8_t * const data_output = debug_buffer->get_data_offset(max_prefix_length, max_data_output_length);
	if (data_output == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}
	data_output[max_data_output_length-1ul] = 0;

	u8_t * const plain_output = debug_buffer->get_data_offset(max_prefix_length + max_data_output_length, max_plain_output_length);
	if (plain_output == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}
	plain_output[max_plain_output_length - 1ul] = 0;

	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

	const u32_t length = get_content_length();
	
	if (length == 0)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("# ERROR: invalid %s, length=%d\n"),
				get_tag_string(),
				length));

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_buffer_too_short);
	}

	const u8_t * const oid_data = get_content();

	if (oid_data == 0)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("# ERROR: invalid %s, length=%d\n"),
				get_tag_string(),
				length));

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_buffer_too_short);
	}

	u32_t offset(0ul);
	u8_t oid_octet = oid_data[offset];
	u32_t oid1 = oid_octet / 40;
	u32_t oid2 = (oid_octet - oid1*40);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s%02x # = %d = 40 * %d + %d => %d.%d\n"),
		prefix,
		oid_octet,
		oid_octet,
		oid1,
		oid2,
		oid1,
		oid2));

	++offset;

	while(offset < length)
	{
		u32_t oid_length(0ul);
		u32_t data_output_offset(0ul);
		u32_t plain_output_offset(0ul);
		u32_t ind(0ul);

		for (ind = offset; ind < length; ++ind)
		{
			u8_t oid_octet = oid_data[ind];
			++oid_length;
			if ((oid_octet & OID_HIGH_BIT) == 0)
			{
				break;
			}
		} // for()

		u32_t power = oid_length - 1ul;
		u32_t oid_value(0ul);

		for (ind = offset; ind < (offset+oid_length); ++ind)
		{
			u8_t oid_octet = oid_data[ind];

			data_output_offset += m_am_tools->snprintf(
				&data_output[data_output_offset],
				max_data_output_length - data_output_offset,
				"%02x \0",
				oid_octet);

			u8_t oid = static_cast<u8_t>(oid_octet & (~OID_HIGH_BIT));

			if (ind > offset)
			{
				plain_output_offset += m_am_tools->snprintf(
					&plain_output[plain_output_offset],
					max_data_output_length - plain_output_offset,
					" + \0");
			}

			if (power > 1ul)
			{
				plain_output_offset += m_am_tools->snprintf(
					&plain_output[plain_output_offset],
					max_data_output_length - plain_output_offset,
					"0x%02x * 128 ^ %d\0",
					oid,
					power);
			}
			else if (power > 0ul)
			{
				plain_output_offset += m_am_tools->snprintf(
					&plain_output[plain_output_offset],
					max_data_output_length - plain_output_offset,
					"0x%02x * 128\0",
					oid);
			}
			else
			{
				plain_output_offset += m_am_tools->snprintf(
					&plain_output[plain_output_offset],
					max_data_output_length - plain_output_offset,
					"0x%02x\0",
					oid);
			}

			oid_value = (oid_value << 7) + oid;

			--power;
		} // for()

		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("%s%s # %s = %d\n"),
			prefix,
			data_output,
			plain_output,
			oid_value));

		offset += oid_length;
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAP_DEBUG_TRACE)

//--------------------------------------------------

eap_status_e asn1_der_type_c::initialize(
	const u32_t length,
	const u8_t * const data,
	const u16_t recursion,
	const u32_t index,
	eap_variable_data_c * const debug_buffer)
{
	if (index > 0xffff)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	m_index = static_cast<u16_t>(index);

	m_recursion = recursion;

	m_input_data_length = length;

	if (m_input_data_length == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_buffer_too_short);
	}

	m_input_data = data;

	if (m_input_data == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}
	m_offset_of_length_field = get_offset_of_length_field();

	if (m_offset_of_length_field > m_input_data_length
		|| m_offset_of_length_field == 0)
	{
		ASN1_DEBUG_HEADER(this, debug_buffer);
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_buffer_too_short);
	}

	m_offset_of_contents_field = get_offset_of_contents_field();

	if (m_offset_of_contents_field > m_input_data_length
		|| m_offset_of_contents_field == 0)
	{
		ASN1_DEBUG_HEADER(this, debug_buffer);
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_buffer_too_short);
	}

	if ((m_offset_of_contents_field + get_content_length()) > m_input_data_length)
	{
		ASN1_DEBUG_HEADER(this, debug_buffer);
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_buffer_too_short);
	}

	u32_t data_length = get_header_length() + get_content_length();

	if (m_input_data_length >= data_length)
	{
		m_input_data_length = data_length;
	}
	else
	{
		ASN1_DEBUG_HEADER(this, debug_buffer);
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_buffer_too_short);
	}

	add_used_octets(get_header_length());

	ASN1_DEBUG_HEADER(this, debug_buffer);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
}

//--------------------------------------------------

EAP_FUNC_EXPORT asn1_der_type_c::asn1_class_e asn1_der_type_c::get_class() const
{
	if (m_input_data == 0)
	{
		return asn1_der_type_c::asn1_class_none;
	}

	return static_cast<asn1_der_type_c::asn1_class_e>(m_input_data[0] & asn1_identifier_mask_class);
}

//--------------------------------------------------

EAP_FUNC_EXPORT asn1_der_type_c::asn1_pc_e asn1_der_type_c::get_pc() const
{
	if (m_input_data == 0)
	{
		return asn1_der_type_c::asn1_pc_none;
	}

	return static_cast<asn1_der_type_c::asn1_pc_e>(m_input_data[0] & asn1_identifier_mask_pc);
}

//--------------------------------------------------

EAP_FUNC_EXPORT asn1_der_type_c::asn1_tag_e asn1_der_type_c::get_tag() const
{
	if (m_input_data == 0)
	{
		return asn1_der_type_c::asn1_tag_none;
	}

	asn1_der_type_c::asn1_tag_e tag = static_cast<asn1_der_type_c::asn1_tag_e>(m_input_data[0] & asn1_identifier_mask_tag);

	if (m_offset_of_length_field == asn1_identifier_const_simple_tag_size
		&& static_cast<asn1_identifier_mask_e>(tag) != asn1_identifier_mask_tag)
	{
		// Simple Tag.
		return tag;
	}
	else if (m_offset_of_length_field > asn1_identifier_const_simple_tag_size)
	{
		return asn1_der_type_c::asn1_tag_extented;
	}
	else
	{
		return asn1_der_type_c::asn1_tag_none;
	}
}

//--------------------------------------------------

EAP_FUNC_EXPORT eap_status_e asn1_der_type_c::get_extented_tag(const u8_t ** const extented_tag, u32_t * const extented_tag_size) const
{
	if (extented_tag == 0
		|| extented_tag_size == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	if (get_tag() == asn1_der_type_c::asn1_tag_extented)
	{
		*extented_tag = m_input_data + asn1_identifier_const_simple_tag_size;
		*extented_tag_size = m_offset_of_length_field - asn1_identifier_const_simple_tag_size;
	}
	else
	{
		*extented_tag = m_input_data;
		*extented_tag_size = m_offset_of_length_field;
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
}

//--------------------------------------------------

u16_t asn1_der_type_c::get_offset_of_length_field()
{
	if (m_input_data == 0)
	{
		return 0ul;
	}

	asn1_der_type_c::asn1_tag_e tag = static_cast<asn1_der_type_c::asn1_tag_e>(m_input_data[0] & asn1_identifier_mask_tag);

	if (static_cast<asn1_identifier_mask_e>(tag) != asn1_identifier_mask_tag)
	{
		// Simple Tag.
		return asn1_identifier_const_simple_tag_size;
	}
	else if (m_input_data_length > asn1_identifier_const_simple_tag_size)
	{
		const u8_t * extented_tag = &(m_input_data[1]);
		if (extented_tag == 0)
		{
			return 0ul;
		}

		const u8_t * const end_byte = &(m_input_data[m_input_data_length]);
		if (end_byte == 0)
		{
			return 0ul;
		}

		while (extented_tag < end_byte)
		{
			if ((extented_tag[0] & static_cast<u8_t>(asn1_high_bit_mask_tag)) == 0)
			{
				return static_cast<u16_t>(extented_tag - m_input_data);
			}

			++extented_tag;
		}
	}

	// Illegal data.
	return 0ul;
}

//--------------------------------------------------

u16_t asn1_der_type_c::get_offset_of_contents_field()
{
	if (m_input_data == 0)
	{
		return 0ul;
	}

	if (m_offset_of_length_field < asn1_identifier_const_simple_tag_size
		|| m_offset_of_length_field > m_input_data_length)
	{
		return 0ul;
	}

	const u8_t length_octet1 = m_input_data[m_offset_of_length_field];

	if ((length_octet1 & static_cast<u8_t>(asn1_high_bit_mask_tag)) == 0)
	{
		// Short Length field.
		return static_cast<u16_t>(m_offset_of_length_field + asn1_identifier_const_short_length_size);
	}
	else if (m_input_data_length > static_cast<u32_t>(m_offset_of_length_field + asn1_identifier_const_short_length_size))
	{
		const u8_t * extented_length = &(m_input_data[m_offset_of_length_field]);
		if (extented_length == 0)
		{
			return 0ul;
		}

		u16_t count_of_length_octets = static_cast<u16_t>((*extented_length) & static_cast<u8_t>(~asn1_high_bit_mask_tag));

		u16_t offset(static_cast<u16_t>(m_offset_of_length_field + asn1_identifier_const_short_length_size + count_of_length_octets));

		if (offset > m_input_data_length)
		{
			// Illegal data.
			return 0ul;
		}

		return offset;
	}

	// Illegal data.
	return 0ul;
}

//--------------------------------------------------

EAP_FUNC_EXPORT u32_t asn1_der_type_c::get_header_length() const
{
	return m_offset_of_contents_field;
}

//--------------------------------------------------

EAP_FUNC_EXPORT u32_t asn1_der_type_c::get_content_length() const
{
	if (m_input_data == 0
		|| m_offset_of_length_field == 0ul
		|| m_offset_of_contents_field == 0ul)
	{
		return 0ul;
	}

	const u8_t * extented_length = &(m_input_data[m_offset_of_length_field]);
	if (extented_length == 0)
	{
		return 0ul;
	}

	if (((*extented_length) & static_cast<u8_t>(asn1_high_bit_mask_tag)) == 0)
	{
		// Short Length field.
		return static_cast<u32_t>(*extented_length);
	}

	u32_t count_of_length_octets = static_cast<u32_t>((*extented_length) & static_cast<u8_t>(~asn1_high_bit_mask_tag));

	if ((m_offset_of_length_field + asn1_identifier_const_short_length_size + count_of_length_octets) > m_input_data_length)
	{
		// Illegal data.
		return 0ul;
	}

	const u8_t * end_byte = &(m_input_data[m_offset_of_contents_field]);
	if (end_byte == 0)
	{
		return 0ul;
	}

	++extented_length;

	if (static_cast<u32_t>(end_byte - extented_length) > sizeof(u32_t))
	{
		// Overflow of length.
		return 0ul;
	}

	u32_t length(0ul);


	while (extented_length < end_byte)
	{
		length = (length << 8) + static_cast<u32_t>(*extented_length);
		++extented_length;
	}

	return length;
}

//--------------------------------------------------

EAP_FUNC_EXPORT const u8_t * asn1_der_type_c::get_content() const
{
	if (m_input_data == 0)
	{
		return 0;
	}

	if (m_offset_of_contents_field > m_input_data_length
		|| m_offset_of_contents_field == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return 0;
	}

	return (&m_input_data[m_offset_of_contents_field]);
}

//--------------------------------------------------

EAP_FUNC_EXPORT u32_t asn1_der_type_c::get_full_data_length() const
{
	return m_input_data_length;
}

//--------------------------------------------------

EAP_FUNC_EXPORT const u8_t * asn1_der_type_c::get_full_data() const
{
	return m_input_data;
}

//--------------------------------------------------

void asn1_der_type_c::set_parent_type(asn1_der_type_c * const parent_type)
{
	m_parent_type = parent_type;
}

//--------------------------------------------------

asn1_der_type_c * asn1_der_type_c::get_parent_type() const
{
	return m_parent_type;
}

//--------------------------------------------------

eap_status_e asn1_der_type_c::add_sub_type(asn1_der_type_c * const sub_type)
{
	if (m_sub_types == 0)
	{
		m_sub_types = new eap_array_c<asn1_der_type_c>(m_am_tools);
		if (m_sub_types == 0)
		{
			delete sub_type;

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}
	}

	sub_type->set_parent_type(this);

	eap_status_e status = m_sub_types->add_object(sub_type, true);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

//--------------------------------------------------

EAP_FUNC_EXPORT const eap_array_c<asn1_der_type_c> * asn1_der_type_c::get_sub_types() const
{
	return m_sub_types;
}

//--------------------------------------------------

EAP_FUNC_EXPORT const asn1_der_type_c * asn1_der_type_c::get_sub_type(
	const asn1_type_const_c * const asn1_type) const
{
	const asn1_type_object_c * type = asn1_type[0].get_type();

	if (type == 0
		|| type->get_is_valid() == false)
	{
		return 0;
	}

	ASN1_TYPE_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("# asn1_type = 0x%08x, class=%d, tag=%d, index=%d\n"),
		type,
		type->get_asn1_class(),
		type->get_asn1_tag(),
		type->get_index()));

	const asn1_der_type_c * current_type = this;

	ASN1_TYPE_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("### current_type = 0x%08x, class=%d, tag=%d, index=%d\n"),
		current_type,
		current_type->get_class(),
		current_type->get_tag(),
		0));

	if (current_type->get_class() != type->get_asn1_class()
		|| current_type->get_tag() != type->get_asn1_tag())
	{
		ASN1_TYPE_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("ERROR: ### current_type does not match.\n")));
		return 0;
	}

	++type;

	while (current_type != 0 && type->get_is_valid() == true)
	{
		ASN1_TYPE_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("# asn1_type = 0x%08x, class=%d, tag=%d, index=%d\n"),
			type,
			type->get_asn1_class(),
			type->get_asn1_tag(),
			type->get_index()));

		const eap_array_c<asn1_der_type_c> * sub_type_array = current_type->get_sub_types();
		if (sub_type_array == 0)
		{
			ASN1_TYPE_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("ERROR: ### No sub-type array.\n")));
			return 0;
		}

		current_type = 0;

		for (u32_t sub_ind = type->get_index(); sub_ind < sub_type_array->get_object_count(); ++sub_ind)
		{
			const asn1_der_type_c * const sub_type = sub_type_array->get_object(sub_ind);
			if (sub_type == 0
				|| sub_type->get_is_valid() == false)
			{
				ASN1_TYPE_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("ERROR: ### No sub-type.\n")));
				return 0;
			}

			ASN1_TYPE_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("### sub_type = 0x%08x, class=%d, tag=%d, index=%d\n"),
				sub_type,
				sub_type->get_class(),
				sub_type->get_tag(),
				sub_ind));

			if (sub_type->get_class() == type->get_asn1_class()
				&& sub_type->get_tag() == type->get_asn1_tag())
			{
				current_type = sub_type;
				break;
			}
		}

		++type;
	}

	if (current_type == 0)
	{
		ASN1_TYPE_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("ERROR: ### No match found.\n")));
	}
	else
	{
		ASN1_TYPE_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("### Match found.\n")));

		ASN1_TYPE_TRACE_DATA_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("ASN.1 type data"),
			current_type->get_full_data(),
			current_type->get_full_data_length()));
	}

	return current_type;
}

//--------------------------------------------------

EAP_FUNC_EXPORT const asn1_der_type_c * asn1_der_type_c::get_previous_type() const
{
	const asn1_der_type_c * parent = get_parent_type();

	if (parent == 0)
	{
		return 0;
	}

	if (parent->get_sub_types() == 0)
	{
		return 0;
	}

	const u32_t object_count = parent->get_sub_types()->get_object_count();

	if (object_count <= 1ul)
	{
		return 0;
	}

	const u32_t previous_index = get_index() - 1ul;

	if (object_count <= previous_index)
	{
		return 0;
	}

	return parent->get_sub_types()->get_object(previous_index);
}

//--------------------------------------------------

EAP_FUNC_EXPORT const asn1_der_type_c * asn1_der_type_c::get_next_type() const
{
	const asn1_der_type_c * parent = get_parent_type();

	if (parent == 0)
	{
		return 0;
	}

	const u32_t next_index = get_index() + 1ul;

	if (parent->get_sub_types() == 0
		|| parent->get_sub_types()->get_object_count() <= next_index)
	{
		return 0;
	}

	return parent->get_sub_types()->get_object(next_index);
}

//--------------------------------------------------

EAP_FUNC_EXPORT u16_t asn1_der_type_c::get_count_of_sub_types() const
{
	return m_count_of_sub_types;
}

//--------------------------------------------------

EAP_FUNC_EXPORT void asn1_der_type_c::increase_count_of_sub_types()
{
	++m_count_of_sub_types;
}

//--------------------------------------------------

void asn1_der_type_c::add_used_octets(const u32_t used_octets)
{
	m_used_octets += used_octets;
}

//--------------------------------------------------

u32_t asn1_der_type_c::get_used_octets() const
{
	return m_used_octets;
}

//--------------------------------------------------

u32_t asn1_der_type_c::get_unused_data_length() const
{
	return get_input_data_length() - get_used_octets();
}

//--------------------------------------------------

const u8_t * asn1_der_type_c::get_unused_data() const
{
	return get_input_data() + get_used_octets();
}

//--------------------------------------------------

eap_status_e asn1_der_type_c::encode_oid_from_string(eap_const_string oid, const u32_t oid_length, eap_variable_data_c * const buffer) const
{
	if (oid == 0
		|| buffer == 0
		|| buffer->get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	eap_status_e status(eap_status_process_general_error);

	const eap_char * oid_char = oid;
	const eap_char * end_char = &oid[oid_length];
	u32_t remaining_length(oid_length);
	u32_t first_component(0ul);
	u32_t component_index(0ul);

	status = buffer->set_data_length(0ul);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	while(oid_char < end_char)
	{
		// Search next dot (.).
		const eap_char * dot  = reinterpret_cast<const eap_char *>(m_am_tools->memchr(oid_char, '.', remaining_length));
		if (dot == 0)
		{
			// The last component.
			dot  = reinterpret_cast<const eap_char *>(oid_char + remaining_length);
			if (dot == 0
				|| dot != end_char)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
			}
		}

		u32_t integer(0ul);

		status = m_am_tools->number_string_to_u32(
			reinterpret_cast<const u8_t *>(oid_char),
			dot - oid_char,
			&integer);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		if (component_index == 0ul)
		{
			// The first component is encoded with the second component.
			first_component = integer;
		}
		else if (component_index == 1ul)
		{
			if (first_component < 2ul
				&& integer > 39ul)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
			}
			else if (first_component > 2ul)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
			}

			const u32_t oid_value = first_component * 40ul + integer;
			if (oid_value > 0xff)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
			}

			const u8_t oid_octet(static_cast<u8_t>(oid_value));

			status = buffer->add_data(&oid_octet, sizeof(oid_octet));
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}
		}
		else
		{
			eap_variable_data_c encoded_data(m_am_tools);
			if (encoded_data.get_is_valid() == false)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
			}

			const u32_t ENCODE_BASE = 128ul;

			while(integer > 0ul)
			{
				const u8_t oid_octet = static_cast<u8_t>(integer % ENCODE_BASE);

				// Encodes the octets to reverse order.
				status = encoded_data.add_data(&oid_octet, sizeof(oid_octet));
				if (status != eap_status_ok)
				{
					EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
					return EAP_STATUS_RETURN(m_am_tools, status);
				}

				integer = integer / ENCODE_BASE;
			} // while()

			for (u32_t ind = encoded_data.get_data_length(); ind > 0ul; --ind)
			{
				// reads the octets on reverse order.
				u8_t * oid_octet = encoded_data.get_data_offset(ind-1ul, sizeof(u8_t));
				if (oid_octet == 0)
				{
					EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
					return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
				}

				if (ind > 1ul)
				{
					// All but the last octet have high bit set.
					*oid_octet |= static_cast<u8_t>(asn1_high_bit_mask_tag);
				}

				status = buffer->add_data(oid_octet, sizeof(*oid_octet));
				if (status != eap_status_ok)
				{
					EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
					return EAP_STATUS_RETURN(m_am_tools, status);
				}
			} // for()
		}

		remaining_length -= (dot - oid_char) + 1ul;

		oid_char = dot+1ul;

		++component_index;

	} // while()

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

//--------------------------------------------------

EAP_FUNC_EXPORT eap_status_e asn1_der_type_c::compare_object_identifier(const u8_t * const der_encoded_oid, const u32_t oid_length) const
{
	if (get_tag() != asn1_tag_object_identifier
		|| der_encoded_oid == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	const u32_t content_length(get_content_length());

	if (content_length != oid_length
		|| m_am_tools->memcmp(
			der_encoded_oid, 
			get_content(), 
			content_length) != 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return eap_status_no_match;
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
}

//--------------------------------------------------

EAP_FUNC_EXPORT eap_status_e asn1_der_type_c::compare_object_identifier(eap_const_string oid, const u32_t oid_length) const
{
	if (get_tag() != asn1_tag_object_identifier
		|| oid == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	eap_variable_data_c oid_buffer(m_am_tools);

	if (oid_buffer.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_status_e status = encode_oid_from_string(oid, oid_length, &oid_buffer);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return compare_object_identifier(oid_buffer.get_data(), oid_buffer.get_data_length());
}

//--------------------------------------------------

EAP_FUNC_EXPORT eap_status_e asn1_der_type_c::decode(const eap_variable_data_c * const asn1_der_data)
{
	if (asn1_der_data == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	eap_variable_data_c * debug_buffer = 0;

#if defined(USE_EAP_DEBUG_TRACE)
	// Buffer is used for debug traces.
	eap_variable_data_c tmp_debug_buffer(m_am_tools);

	{
		eap_status_e status = tmp_debug_buffer.set_buffer_length(MAX_DEBUG_BUFFER);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		debug_buffer = &tmp_debug_buffer;
	}
#endif //	#if defined(USE_EAP_DEBUG_TRACE)


	eap_status_e status = initialize(
		asn1_der_data->get_data_length(),
		asn1_der_data->get_data(),
		0ul,
		0ul,
		debug_buffer);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	asn1_der_type_c * current_type = this;

	if (current_type->get_pc() == asn1_pc_constructed)
	{
		ASN1_TYPE_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("# this = 0x%08x, input_data_length=%d, used_octets=%d\n"),
			 current_type,
			 current_type->get_input_data_length(),
			 current_type->get_used_octets()));

		while (current_type->get_used_octets() != current_type->get_input_data_length())
		{
			asn1_der_type_c * sub_type = new asn1_der_type_c(m_am_tools);

			eap_automatic_variable_c<asn1_der_type_c> automatic_sub_type(m_am_tools, sub_type);

			if (sub_type == 0
				|| sub_type->get_is_valid() == false)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
			}

			ASN1_TYPE_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("# this = 0x%08x, unused_data_length=%d, recursion=%d\n"),
				 current_type,
				 current_type->get_unused_data_length(),
				 current_type->get_recursion()));

			status = sub_type->initialize(
				current_type->get_unused_data_length(),
				current_type->get_unused_data(),
				static_cast<u16_t>(current_type->get_recursion() + 1u),
				current_type->get_count_of_sub_types(),
				debug_buffer);
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}

			current_type->increase_count_of_sub_types();

			ASN1_TYPE_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("# this = 0x%08x, used_octets=%d\n"),
				 sub_type,
				 sub_type->get_used_octets()));

			automatic_sub_type.do_not_free_variable();

			status = current_type->add_sub_type(sub_type);
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}

			if (sub_type->get_pc() == asn1_pc_primitive)
			{
				ASN1_DEBUG_DATA(sub_type, debug_buffer);

				sub_type->add_used_octets(sub_type->get_content_length());

				current_type = sub_type;

				do
				{
					sub_type = current_type;
					current_type = current_type->get_parent_type();
					current_type->add_used_octets(sub_type->get_used_octets());

					ASN1_TYPE_TRACE_DEBUG(
						m_am_tools,
						TRACE_FLAGS_DEFAULT,
						(EAPL("# this = 0x%08x, input_data_length=%d, used_octets=%d\n"),
						 current_type,
						 current_type->get_input_data_length(),
						 current_type->get_used_octets()));
				}
				while (current_type->get_used_octets() == current_type->get_input_data_length() && current_type->get_parent_type() != 0);
			}
			else
			{
				current_type = sub_type;
			}

		} // while()
	}
	else
	{
		ASN1_DEBUG_DATA(this, debug_buffer);
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
}

//--------------------------------------------------

// End.
