/*

* Copyright (c) 2001-2006 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.

*

*/

/*

*/

// This is enumeration of EAPOL source code.

#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

	#undef EAP_FILE_NUMBER_ENUM

	#define EAP_FILE_NUMBER_ENUM 13 

	#undef EAP_FILE_NUMBER_DATE 

	#define EAP_FILE_NUMBER_DATE 1127594498 

#endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

#include "eap_am_memory.h"

#include "eap_am_tools.h"

#include "abs_eap_am_mutex.h"

#include "eap_crypto_api.h"

#include "eap_buffer.h"

#include "eap_configuration_field.h"

//#if !defined(NO_EAP_AM_MEMORY_STORE)

	#include "eap_am_memory_store.h"

//#endif //#if !defined(NO_EAP_AM_MEMORY_STORE)

/**

 * This is the at character used in NAI.

 */

const u8_t EAP_AT_CHARACTER = '@';

/**

 * This is the length of UUIDs.

 */

static const u32_t EAP_UUID_LENGTH = 16;

/**

 * This is the name space UUID for MAC addresses.

 */

static const u8_t EAP_MAC_ADDRESS_NAMESPACE_UUID_V5[] = 

	{ 0x35, 0x0b, 0x16, 0xfd, 

	  0x5c, 0xd8, 0x45, 0x50, 

	  0x9b, 0xb8, 0x49, 0x8f, 

	  0x95, 0x8a, 0xc9, 0x66 };

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

//

EAP_FUNC_EXPORT eap_am_tools_c::~eap_am_tools_c()

{

	EAP_ASSERT_ALWAYS_NO_TRACE(m_shutdown_was_called == true);

}

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

//

EAP_FUNC_EXPORT eap_am_tools_c::eap_am_tools_c()

: 

#if !defined(NO_EAP_AM_MEMORY_STORE)

  m_memory_store(0)

, 

#endif //#if !defined(NO_EAP_AM_MEMORY_STORE)

 m_trace_mask(eap_am_tools_c::eap_trace_mask_none)

#if defined(USE_EAP_ERROR_TESTS)

, m_packet_index(0u)

#endif //#if defined(USE_EAP_ERROR_TESTS)

, m_use_seconds_timestamp_in_traces(true)

, m_thread_stopped(false)

, m_use_timer_queue(false)

, m_shutdown_was_called(false)

, m_activate_trace_on_error(false)

{

	abs_eap_am_tools_c *m_am_tools = this;

	u32_t bytes_8 = 8u;

	u32_t bytes_4 = 4u;

	u32_t bytes_2 = 2u;

	u32_t bytes_1 = 1u;

	EAP_UNREFERENCED_PARAMETER(m_am_tools);

	EAP_UNREFERENCED_PARAMETER(bytes_8);

	EAP_UNREFERENCED_PARAMETER(bytes_4);

	EAP_UNREFERENCED_PARAMETER(bytes_2);

	EAP_UNREFERENCED_PARAMETER(bytes_1);

	EAP_ASSERT_ALWAYS(sizeof(u64_t) == bytes_8);

	EAP_ASSERT_ALWAYS(sizeof(u32_t) == bytes_4);

	EAP_ASSERT_ALWAYS(sizeof(u16_t) == bytes_2);

	EAP_ASSERT_ALWAYS(sizeof(u8_t) == bytes_1);

	EAP_ASSERT_ALWAYS(sizeof(i64_t) == bytes_8);

	EAP_ASSERT_ALWAYS(sizeof(i32_t) == bytes_4);

	EAP_ASSERT_ALWAYS(sizeof(i16_t) == bytes_2);

	EAP_ASSERT_ALWAYS(sizeof(i8_t) == bytes_1);

	m_tmp_buffer[0] = 0;

	m_tmp_ascii_buffer[0] = 0;

#if !defined(NO_EAP_AM_MEMORY_STORE)

	m_memory_store = new eap_am_memory_store_c(m_am_tools);

#endif //#if !defined(NO_EAP_AM_MEMORY_STORE)

}

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

//

EAP_FUNC_EXPORT bool eap_am_tools_c::get_use_seconds_timestamp_in_traces()

{

	return m_use_seconds_timestamp_in_traces;

}

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

//

EAP_FUNC_EXPORT bool eap_am_tools_c::get_thread_stopped()

{

	return m_thread_stopped;

}

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

//

EAP_FUNC_EXPORT void eap_am_tools_c::set_use_timer_queue()

{

	m_use_timer_queue = true;

}

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

//

EAP_FUNC_EXPORT bool eap_am_tools_c::get_use_timer_queue()

{

	return m_use_timer_queue;

}

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

//

EAP_FUNC_EXPORT u32_t eap_am_tools_c::get_trace_mask() const

{

	return m_trace_mask;

}

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

//

EAP_FUNC_EXPORT void eap_am_tools_c::set_trace_mask(const u32_t mask)

{

	m_trace_mask = mask;

}

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

//

EAP_FUNC_EXPORT void eap_am_tools_c::set_activate_trace_on_error()

{

	m_activate_trace_on_error = true;

	// NOTE the always active traces are only left active.

	set_trace_mask(eap_trace_mask_always);

}

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

//

EAP_FUNC_EXPORT void eap_am_tools_c::check_activate_trace_on_error()

{

	if (m_activate_trace_on_error == true)

	{

		set_trace_mask(

			eap_trace_mask_debug

			| eap_trace_mask_always

			| eap_trace_mask_error

			| eap_am_tools_c::eap_trace_mask_message_data);

	}

}

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

//

EAP_FUNC_EXPORT u8_t eap_am_tools_c::octet_to_ascii(i32_t octet)

{

	if (0 <= octet && octet <= 9)

	{

		return static_cast<u8_t>('0' + octet);

	}

	else if (10 <= octet && octet <= 16)

	{

		return static_cast<u8_t>('a' + (octet-10u));

	}

	else

	{

		return 0;

	}

}

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

//

EAP_FUNC_EXPORT u8_t eap_am_tools_c::ascii_to_octet(i32_t character)

{

	if ('0' <= character && character <= '9')

	{

		return static_cast<u8_t>(character - '0');

	}

	else if ('a' <= character && character <= 'f')

	{

		return static_cast<u8_t>((character - 'a') + 10u);

	}

	else if ('A' <= character && character <= 'F')

	{

		return static_cast<u8_t>((character - 'A') + 10u);

	}

	else

	{

		return 0;

	}

}

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

//

EAP_FUNC_EXPORT void eap_am_tools_c::trace_data(

	eap_const_string prefix,

	const void * const p_data,

	const u32_t data_length)

{

	u8_t *cursor = m_tmp_buffer;

	u8_t *cursor_ascii = m_tmp_ascii_buffer;

	const u8_t *data = reinterpret_cast<const u8_t *>(p_data);

	u32_t ind;

	bool must_print = false;

	u32_t data_start = 0u;

	const u32_t EAP_DATA_TRACE_BYTE_GROUP_SIZE = 1;

	u32_t byte_group_size = EAP_DATA_TRACE_BYTE_GROUP_SIZE;

#if !defined(USE_EAP_DEBUG_TRACE)

	// This does not trace the pointer of the data.

	formatted_print(

		EAPL("%s: data begins: %d (0x%x) bytes\n"),

		prefix,

		data_length,

		data_length);

#else

	formatted_print(

		EAPL("%s: data begins 0x%08x: %d (0x%x) bytes\n"),

		prefix,

		p_data,

		data_length,

		data_length);

#endif

	if (p_data != 0)

	{

		for (ind = 0u; ind < data_length; ind++)

		{

			if ((cursor-m_tmp_buffer)+5u >= sizeof(m_tmp_buffer))

			{

				must_print = true;

				formatted_print(

					EAPL("ERROR: eap_am_tools_c::trace_data local buffer (%d bytes) too small.\n"),

					sizeof(m_tmp_buffer));

				break;

			}

			if (ind > 0u

				&& (ind % 16) == 0)

			{

				*cursor++ = 0;

				*cursor_ascii++ = 0;

				formatted_print(

					EAPL("%s: 0x%04x: %-48s |%-16s|\n"),

					prefix,

					data_start,

					m_tmp_buffer,

					m_tmp_ascii_buffer);

				cursor = m_tmp_buffer;

				cursor_ascii = m_tmp_ascii_buffer;

				must_print = false;

				data_start = ind;

			}

			*cursor++ = octet_to_ascii(((*data) & 0xf0) >> 4);

			*cursor++ = octet_to_ascii(((*data) & 0x0f));

			data++;

				|| byte_group_size == 1ul)

			{

				*cursor++ = ' ';

			}

			must_print = true;

		}

		if (must_print == true)

		{

			*cursor++ = 0;

			*cursor_ascii = 0;

			formatted_print(

				EAPL("%s: 0x%04x: %-48s |%-16s|\n"),

				prefix,

				data_start,

				m_tmp_buffer,

				m_tmp_ascii_buffer);

		}

	}

#if !defined(USE_EAP_DEBUG_TRACE)

	// This does not trace the pointer of the data.

	formatted_print(

		EAPL("%s: data ends: %d (0x%x) bytes\n"),

		prefix,

		data_length,

		data_length);

#else

	formatted_print(

		EAPL("%s: data ends 0x%08x: %d (0x%x) bytes\n"),

		prefix,

		p_data,

		data_length,

		data_length);

#endif

}

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

#if defined(__SYMBIAN32__) && defined(USE_MULTITHREADING)// Symbian does not have 64 bit divide operator :-(.

#include "eap_am_tools_symbian.h"

EAP_FUNC_EXPORT eap_status_e eap_am_tools_c::timer_thread_function()

{

	EAP_TRACE_DEBUG(this, TRACE_FLAGS_DEFAULT, (EAPL("TIMER: Timer thread starts.\n")));

	u64_t start_time = get_clock_ticks();

	u64_t current_time = start_time;

	u64_t real_time = 0u;

	u64_t virtual_time = 0u;

	u64_t begin_time = 0u;

	u64_t end_time = 0u;

#if defined(_DEBUG)

	TInt64 *_begin_time = (TInt64 *)&begin_time;	

	TInt64 *_real_time = (TInt64 *)&real_time;	

	TInt64 *_end_time = (TInt64 *)&end_time;	

#endif

	u64_t hw_ticks_of_millisecond = get_clock_ticks_of_second();

	TInt64 *hw_ticks_of_millisecond_tmp = (TInt64 *)&hw_ticks_of_millisecond;

	TReal _hw_ticks_of_millisecond = hw_ticks_of_millisecond_tmp->GetTReal();	

	_hw_ticks_of_millisecond /= 1000.0;

	// Note 64-bit casted to 32-bit.

	EAP_TRACE_DEBUG(this, TRACE_FLAGS_DEFAULT, (EAPL("TIMER: get_clock_ticks_of_second() = %lu\n"),

		static_cast<u32_t>(get_clock_ticks_of_second()));

	u32_t sleep_time = get_timer_resolution_ms();

	// The mutex handle must be dublicated in Symbian operating system for each thread.

	abs_eap_am_mutex_c *mutex = get_global_mutex()->dublicate_mutex();

	if (mutex == 0

		|| mutex->get_is_valid() == false)

	{

		EAP_TRACE_ERROR(this, TRACE_FLAGS_DEFAULT, (EAPL("ERROR: Mutex dublication failed.\n")));

		m_thread_stopped =true;

		return EAP_STATUS_RETURN(this, eap_status_allocation_error);

	}

	u32_t next_sleep_time = sleep_time;

	mutex->mutex_enter();

	while(get_is_timer_thread_active())

	{

		mutex->mutex_leave(this);

		virtual_time += sleep_time;

		// Symbian sleep is more like random generator.

		// It never sleep right time.

		begin_time = get_clock_ticks();

		timer_sleep(sleep_time);

		end_time = get_clock_ticks();

		current_time = get_clock_ticks();		

		real_time = current_time - start_time;

		EAP_TRACE_DEBUG(

			this,

			TRACE_FLAGS_DEFAULT,

			(EAPL("TIMER: Timer thread pulse_timer, sleep time = %d ms, ")

			 EAPL("actually %.3f ms, virtual_time %d ms, real_time %.3f ms.\n"),

			 sleep_time,

			 ((_end_time->GetTReal() - _begin_time->GetTReal()))/_hw_ticks_of_millisecond,

			 (static_cast<u32_t>(virtual_time),

			 (_real_time->GetTReal())/_hw_ticks_of_millisecond));

		mutex->mutex_enter();

		if (get_is_timer_thread_active())

		{

			next_sleep_time = pulse_timer(next_sleep_time);

		}

	}

	mutex->mutex_leave(this);

	delete mutex;

	EAP_TRACE_DEBUG(this, TRACE_FLAGS_DEFAULT, (EAPL("TIMER: Timer thread stops.\n")));

	m_thread_stopped =true;

	return eap_status_ok; 

}

#elif !defined(__SYMBIAN32__)

#if defined(USE_EAP_TIMER_QUEUE_TRACE)

	#define EAP_TRACE_TIMER EAP_TRACE_DEBUG

#else

	#define EAP_TRACE_TIMER(object, flags, parameters)

#endif //#if defined(USE_EAP_TIMER_QUEUE_TRACE)

EAP_FUNC_EXPORT eap_status_e eap_am_tools_c::timer_thread_function()

{

	u32_t static_sleep_time = get_timer_resolution_ms();

	u64_t start_time = get_clock_ticks();

	u64_t current_time = start_time;

	u64_t virtual_time = 0u;

	u64_t real_sleep_time = 0ul;

	u32_t current_sleep_time = 0u;

	u64_t real_time = 0u;

	u64_t hw_ticks_of_millisecond = 0u;

	u64_t begin_time = 0u;

	u64_t end_time = 0u;

	// Note 64-bit casted to 32-bit.

	EAP_TRACE_TIMER(

		this,

		static_cast<u32_t>(get_clock_ticks_of_second())));

	hw_ticks_of_millisecond = get_clock_ticks_of_second();

	hw_ticks_of_millisecond /= 1000u;

	// The mutex handle must be dublicated in Symbian operating system for each thread.

	abs_eap_am_mutex_c *mutex = get_global_mutex()->dublicate_mutex();

	if (mutex == 0

		|| mutex->get_is_valid() == false)

	{

		EAP_TRACE_ERROR(

			this,

			TRACE_FLAGS_DEFAULT,

			(EAPL("ERROR: Mutex dublication failed.\n")));

		m_thread_stopped =true;

		return EAP_STATUS_RETURN(this, eap_status_allocation_error);

	}

	u32_t next_sleep_time = static_sleep_time;

	u64_t delay_time = 0ul;

	EAP_TRACE_TIMER(

		this,

		(EAPL("MUTEX: eap_am_tools_c::timer_thread_function(): mutex_enter(): begin\n")));

	mutex->mutex_enter();

	EAP_TRACE_TIMER(

		this,

		(EAPL("MUTEX: eap_am_tools_c::timer_thread_function(): mutex_enter(): end\n")));

	while(get_is_timer_thread_active())

	{

		bool timer_queue_is_empty = get_timer_queue_is_empty();

		current_sleep_time = next_sleep_time;

		EAP_TRACE_TIMER(

			this,

			(EAPL("TIMER: timer_sleep(): current_sleep_time=%d\n"),

			 static_cast<u32_t>(current_sleep_time)));

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

		begin_time = get_clock_ticks();

		EAP_TRACE_TIMER(

			this,

			(EAPL("MUTEX: eap_am_tools_c::timer_thread_function(): mutex_leave(): begin\n")));

		mutex->mutex_leave(this);

		EAP_TRACE_TIMER(

			this,

			(EAPL("MUTEX: eap_am_tools_c::timer_thread_function(): mutex_leave(): end\n")));