/*

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

*

*/

#if !defined(_ASN1_TYPE_H_)

#define _ASN1_TYPE_H_

#include "eap_variable_data.h"

#include "eap_am_export.h"

#include "eap_array.h"

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

class asn1_type_const_c;

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

class EAP_EXPORT asn1_der_type_c

{

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

public:

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

	enum asn1_class_e

	{

		asn1_class_universal        = 0x00,

		asn1_class_application      = 0x40,

		asn1_class_context_specific = 0x80,

		asn1_class_private          = 0xC0,

		asn1_class_none = 0xffffffff,

	};

	enum asn1_pc_e

	{

		asn1_pc_primitive   = 0x00,

		asn1_pc_constructed = 0x20,

		asn1_pc_none = 0xffffffff,

	};

	enum asn1_tag_e

	{

		asn1_tag_end_of_content = 0,

		asn1_tag_boolean = 1,

		asn1_tag_integer = 2,

		asn1_tag_bit_string = 3,

		asn1_tag_octet_string = 4,

		asn1_tag_null = 5,

		asn1_tag_object_identifier = 6,

		asn1_tag_object_descriptor = 7,

		asn1_tag_external = 8,

		asn1_tag_real = 9,

		asn1_tag_enumerated = 10,

		asn1_tag_empedded_pdv = 11,

		asn1_tag_utf8_string = 12,

		asn1_tag_relative_oid = 13,

		asn1_tag_unknown_14 = 14,

		asn1_tag_unknown_15 = 15,

		asn1_tag_sequence = 16,

		asn1_tag_set = 17,

		asn1_tag_numeric_string = 18,

		asn1_tag_printable_string = 19,

		asn1_tag_t61_string = 20,

		asn1_tag_videotex_string = 21,

		asn1_tag_ia5_string = 22,

		asn1_tag_utc_time = 23,

		asn1_tag_unknown_24 = 24,

		asn1_tag_graphic_string = 25,

		asn1_tag_visible_string = 26,

		asn1_tag_general_string = 27,

		asn1_tag_universal_string = 28,

		asn1_tag_character_string = 29,

		asn1_tag_bmp_string = 30,

		asn1_tag_extented = 0xfffffffe,

		asn1_tag_none = 0xffffffff,

	};

	enum asn1_identifier_mask_e

	{

		asn1_identifier_mask_class = 0xC0,

		asn1_identifier_mask_pc    = 0x20,

		asn1_identifier_mask_tag   = 0x1F,

		asn1_high_bit_mask_tag     = 0x80,

	};

	enum asn1_identifier_const_e

	{

		asn1_identifier_const_simple_tag_size   = sizeof(u8_t),

		asn1_identifier_const_short_length_size = sizeof(u8_t),

		asn1_length_field_base = 256ul,

	};

	EAP_FUNC_IMPORT virtual ~asn1_der_type_c();

	EAP_FUNC_IMPORT asn1_der_type_c(

		abs_eap_am_tools_c * const tools);

	/**

	 * The get_is_valid() function returns the status of the asn1_der_type_c object.

	 * @return True indicates the object is initialized.

	 */

	EAP_FUNC_IMPORT bool get_is_valid() const;

	EAP_FUNC_IMPORT u32_t get_index() const;

	/**

	 * The decode() function decodes ASN.1/DER data.

	 * @return eap_status_ok indicates successfull operation.

	 */

	EAP_FUNC_IMPORT eap_status_e decode(const eap_variable_data_c * const asn1_der_data);

	/**

	 * The get_class() returns Class of ASN.1/DER type.

	 */

	EAP_FUNC_IMPORT asn1_class_e get_class() const;

	/**

	 * The get_pc() returns Primitiva/Constructed flag of ASN.1/DER type.

	 */

	EAP_FUNC_IMPORT asn1_pc_e get_pc() const;

	/**

	 * The get_pc() returns Tag of ASN.1/DER type.

	 */

	EAP_FUNC_IMPORT asn1_tag_e get_tag() const;

	/**

	 * The get_pc() returns pointer to extented Tag of ASN.1/DER type.

	 */

	EAP_FUNC_IMPORT eap_status_e get_extented_tag(const u8_t ** const extented_tag, u32_t * const extented_tag_size) const;

	// Function returns count of octets in header of ASN.1/DER type.

	// This includes Identifier and Length octets.

	EAP_FUNC_IMPORT u32_t get_header_length() const;

	// Function returns count of octets in Contents of ASN.1/DER type.

	EAP_FUNC_IMPORT u32_t get_content_length() const;

	// Function returns pointer to Contents of ASN.1/DER type.

	EAP_FUNC_IMPORT const u8_t * get_content() const;

	// Function returns count of octets in full data of ASN.1/DER type, including Identifier, Length and Content.

	EAP_FUNC_IMPORT u32_t get_full_data_length() const;

	// Function returns pointer to full data of ASN.1/DER type, including Identifier, Length and Content.

	EAP_FUNC_IMPORT const u8_t * get_full_data() const;

	// Function returns pointer to array of ASN.1/DER sub types.

	EAP_FUNC_IMPORT const eap_array_c<asn1_der_type_c> * get_sub_types() const;

	// Function returns pointer to ASN.1/DER sub type.

	EAP_FUNC_IMPORT const asn1_der_type_c * get_sub_type(const asn1_type_const_c * const asn1_type) const;

	EAP_FUNC_IMPORT const asn1_der_type_c * get_previous_type() const;

	EAP_FUNC_IMPORT const asn1_der_type_c * get_next_type() const;

	EAP_FUNC_IMPORT u16_t get_count_of_sub_types() const;

	EAP_FUNC_IMPORT void increase_count_of_sub_types();

	EAP_FUNC_IMPORT eap_const_string get_class_string() const;

	EAP_FUNC_IMPORT eap_const_string get_pc_string() const;

	EAP_FUNC_IMPORT eap_const_string get_tag_string() const;

	EAP_FUNC_IMPORT eap_status_e compare_object_identifier(const u8_t * const der_encoded_oid, const u32_t oid_length) const;

	EAP_FUNC_IMPORT eap_status_e compare_object_identifier(eap_const_string oid, const u32_t oid_length) const;

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

private:

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

	abs_eap_am_tools_c * const m_am_tools;

	bool m_is_valid;

	u16_t m_index;

	u16_t m_count_of_sub_types;

	// Shows the recursion of ANS.1 type. The outer most have value 0.

	u16_t m_recursion;

	// +--------------+--------------+--------------+

	// | Identifier   | Length       | Content      |

	// +--------------+--------------+--------------+

	// 

	// +--------------------------------------------+

	//          m_input_data_length in octets

	u32_t m_input_data_length;

	// +--------------+--------------+--------------+

	// | Identifier   | Length       | Content      |

	// +--------------+--------------+--------------+

	// ^

	// |

	// This is pointer to begin of the input data.

	const u8_t * m_input_data;

	// Tells how many octets of tha data is used by sub types.

	u32_t m_used_octets;

	// +--------------+--------------+--------------+

	// | Identifier   | Length       | Content      |

	// +--------------+--------------+--------------+

	// 

	// +--------------+

	//     offset

	u16_t m_offset_of_length_field;

	// +--------------+--------------+--------------+

	// | Identifier   | Length       | Content      |

	// +--------------+--------------+--------------+

	// 

	// +-----------------------------+

	//             offset

	u16_t m_offset_of_contents_field;

	// This is pointer to parent type.

	asn1_der_type_c * m_parent_type;

	// This array includes all sub types.

	eap_array_c<asn1_der_type_c> * m_sub_types;

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

#if defined(USE_EAP_DEBUG_TRACE)

	enum asn1_debug_const_e

	{

		MAX_DEBUG_BUFFER = 256,

		MAX_STACK_BUFFER = 64,

		SIZE_OF_ONE_OCTET_STRING = 3ul,

		COUNT_OF_OCTETS = 16ul,

		OID_HIGH_BIT = 0x80,

	};

	eap_status_e debug_create_prefix(const u32_t recursion, u8_t * const prefix, const u32_t max_prefix, u32_t * const pregix_length);

	eap_status_e debug_header(eap_variable_data_c * const debug_buffer);

	eap_status_e debug_content(eap_variable_data_c * const debug_buffer);

	eap_status_e debug_data(eap_variable_data_c * const debug_buffer);

	eap_status_e debug_object_identifier(eap_variable_data_c * const debug_buffer);

#endif //#if defined(USE_EAP_DEBUG_TRACE)

	eap_status_e add_sub_type(asn1_der_type_c * const sub_type);

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

	u16_t get_offset_of_length_field();

	u16_t get_offset_of_contents_field();

	void set_parent_type(asn1_der_type_c * const parent_type);

	asn1_der_type_c * get_parent_type() const;

	u32_t get_input_data_length() const;

	const u8_t * get_input_data() const;

	u16_t get_recursion() const;

	void add_used_octets(const u32_t used_octets);

	u32_t get_used_octets() const;

	u32_t get_unused_data_length() const;

	const u8_t * get_unused_data() const;

	eap_status_e encode_oid_from_string(eap_const_string oid, const u32_t oid_length, eap_variable_data_c * const buffer) const;

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

};

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

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

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

class asn1_type_object_c

{

public:

	~asn1_type_object_c()

	{

	}

	asn1_der_type_c::asn1_class_e get_asn1_class() const

	{

		return m_asn1_class;

	}

	asn1_der_type_c::asn1_tag_e get_asn1_tag() const

	{

		return m_asn1_tag;

	}

	u32_t get_index() const

	{

		return m_index;

	}

	bool get_is_valid() const

	{

		return(

			get_asn1_class() != asn1_der_type_c::asn1_class_none

			&& get_asn1_tag() != asn1_der_type_c::asn1_tag_none);

	}

	bool compare(

		abs_eap_am_tools_c * const /* tools */,

		const asn1_type_object_c * const field) const

	{

		return field->get_asn1_class() == get_asn1_class()

			&& field->get_asn1_tag() == get_asn1_tag();

	}

private:

	asn1_der_type_c::asn1_class_e m_asn1_class;

	asn1_der_type_c::asn1_tag_e m_asn1_tag;

	u32_t m_index;

};

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

class asn1_type_const_c

{

public:

	inline const asn1_type_object_c * get_type() const;

	inline bool get_is_valid() const

	{

		return true;

	}

public:

	asn1_der_type_c::asn1_class_e m_asn1_class;

	asn1_der_type_c::asn1_tag_e m_asn1_tag;

	u32_t m_index;

};

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

inline const asn1_type_object_c * asn1_type_const_c::get_type() const

{

	EAP_STATIC_ASSERT(sizeof(asn1_type_const_c) == sizeof(asn1_type_object_c));

	return reinterpret_cast<const asn1_type_object_c *>(this);

}

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

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

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

template <u32_t max_name_length, u32_t max_object_count>

class asn1_named_object_const_c

{

public:

	inline const eap_char * get_name() const;

	inline const asn1_type_const_c * get_array() const;

	inline bool get_is_valid() const

	{

		return true;

	}

public:

	eap_char m_name[max_name_length];

	asn1_type_const_c m_array[max_object_count];

};

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

template <u32_t max_name_length, u32_t max_object_count>

inline const eap_char * asn1_named_object_const_c<max_name_length, max_object_count>::get_name() const

{

	return m_name;

}

template <u32_t max_name_length, u32_t max_object_count>

inline const asn1_type_const_c * asn1_named_object_const_c<max_name_length, max_object_count>::get_array() const

{

	return m_array;

}

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

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

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

#define ASN1_TYPE_OBJECT(asn1_class, asn1_tag, index) \

	{asn1_class, static_cast<asn1_der_type_c::asn1_tag_e>(asn1_tag), index}

#define ASN1_TYPE_OBJECT_TERMINATOR \

	{asn1_der_type_c::asn1_class_none, asn1_der_type_c::asn1_tag_none, 0ul}

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

#if defined(USE_EAP_DEBUG_TRACE)

	#define ASN1_DEBUG_HEADER(type, debug_buffer) { (void) (type)->debug_header(debug_buffer); }

	#define ASN1_DEBUG_DATA(type, debug_buffer) { (void) (type)->debug_content(debug_buffer); }

#else

	#define ASN1_DEBUG_HEADER(type, debug_buffer)

	#define ASN1_DEBUG_DATA(type, debug_buffer)

#endif //#if defined(USE_EAP_DEBUG_TRACE)

#if defined(USE_ASN1_TYPE_DEBUG_TRACE)

	#define ASN1_TYPE_TRACE_DEBUG EAP_TRACE_DEBUG

	#define ASN1_TYPE_TRACE_DATA_DEBUG EAP_TRACE_DATA_DEBUG

#else

	#define ASN1_TYPE_TRACE_DEBUG(object_name, flags, _parameter_list_)

	#define ASN1_TYPE_TRACE_DATA_DEBUG(object_name, flags, _parameter_list_)

#endif

#endif //#if !defined(_ASN1_TYPE_H_)

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

// End.