/*

* 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.

*

*/

#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)

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