/*

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

*

*

*/

/*

*/

// This is enumeration of EAPOL source code.

#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

	#undef EAP_FILE_NUMBER_ENUM

	#define EAP_FILE_NUMBER_ENUM 147 

	#undef EAP_FILE_NUMBER_DATE 

	#define EAP_FILE_NUMBER_DATE 1127594498 

#endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

#include <e32math.h>

#include <utf.h>

#include "eap_am_tools_symbian.h"

#include "eap_am_types.h"

#include "eap_automatic_variable.h"

const TUint MAX_DB_TRANSACTION_RETRY_COUNT = 10;

const u32_t EAP_TIMER_MAX_AFTER_TIME_MILLISECONDS_SYMBIAN = 2100000ul;

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

#if defined(_WIN32) && !defined(__GNUC__)

	#pragma warning( disable : 4355 ) // 'this' : used in base member initializer list

#endif

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

EAP_FUNC_EXPORT eap_am_tools_symbian_c::~eap_am_tools_symbian_c()

{

	// If multithreading is used the log file is not kept open all the time

	// so no need to close the handles here.

#if defined(USE_EAP_FILE_TRACE)

#if !defined (USE_MULTITHREADING)

	m_LogFile.Close();

	m_Fs.Close();

#endif //#if !defined (USE_MULTITHREADING)

#endif //#if defined(USE_EAP_FILE_TRACE)

}

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

//

EAP_FUNC_EXPORT eap_am_tools_symbian_c::eap_am_tools_symbian_c(eap_const_string /*pfilename*/)

	: eap_am_tools_c()

	, CTimer(CTimer::EPriorityStandard)

	, m_prefix_string(this)

	, m_start_ticks(0)

	, m_directory_exists(false)

	, m_crypto(this)

	, m_timer_queue(this, EAP_TIMER_RESOLUTION)

	, m_run_thread(true)

	, m_is_valid(false)

	, m_configure_called(false)

	, iInterval(0ul)

	, iStartTime(0ul)

	, iLastTime(0ul)

	, m_logfile_open(false)	

{

	EAP_TRACE_BEGIN(this, TRACE_FLAGS_DEFAULT);

#if defined(USE_EAP_HARDWARE_TRACE)

	set_trace_mask(

		TRACE_FLAGS_ALWAYS

		| TRACE_FLAGS_ERROR

		| eap_am_tools_c::eap_trace_mask_debug

		| EAP_TRACE_FLAGS_MESSAGE_DATA

		| TRACE_FLAGS_TIMER

		| TRACE_FLAGS_TIMER_QUEUE);

#endif //#if defined(USE_EAP_HARDWARE_TRACE)

	const u8_t DEFAULT_PREFIX[] = "EAPOL";

	eap_status_e status = m_prefix_string.set_copy_of_buffer(DEFAULT_PREFIX, sizeof(DEFAULT_PREFIX)-1ul);;

	if (status != eap_status_ok)

	{

		EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);

		(void)EAP_STATUS_RETURN(this, status);

		return;

	}

	status = m_prefix_string.add_end_null();

	if (status != eap_status_ok)

	{

		EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);

		(void)EAP_STATUS_RETURN(this, status);

		return;

	}

	EAP_TRACE_DEBUG(

		this,

		TRACE_FLAGS_DEFAULT,

	EAP_TRACE_RETURN_STRING(this, "returns: eap_am_tools_symbian_c::eap_am_tools_symbian_c()");

	if (m_crypto.get_is_valid() == false)

	{

		EAP_TRACE_ERROR(

			this,

			TRACE_FLAGS_DEFAULT,

			(EAPL("ERROR: m_crypto.get_is_valid() == false\n")));

		return;

	}

	if (m_timer_queue.get_is_valid() == false)

	{

		EAP_TRACE_ERROR(

			this,

			TRACE_FLAGS_DEFAULT,

			(EAPL("ERROR: m_timer_queue.get_is_valid() == false\n")));

		return;

	}

	if (m_global_mutex.get_is_valid() == false)

	{

		EAP_TRACE_ERROR(

			this,

			TRACE_FLAGS_DEFAULT,

			(EAPL("ERROR: m_global_mutex.get_is_valid() == false\n")));

		return;

	}

	if (m_trace_mutex.get_is_valid() == false)

	{

		EAP_TRACE_ERROR(

			this,

			TRACE_FLAGS_DEFAULT,

			(EAPL("ERROR: m_trace_mutex.get_is_valid() == false\n")));

		return;

	}

	m_is_valid = true;

	EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);

}

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

//

EAP_FUNC_EXPORT void eap_am_tools_symbian_c::set_use_eap_milli_second_timer(

	const bool use_eap_millisecond_timer)

{

	m_timer_queue.set_use_eap_milli_second_timer(use_eap_millisecond_timer);

}

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

//

EAP_FUNC_EXPORT bool eap_am_tools_symbian_c::get_use_eap_milli_second_timer()

{

	return m_timer_queue.get_use_eap_milli_second_timer();

}

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

//

EAP_FUNC_EXPORT eap_status_e eap_am_tools_symbian_c::configure()

{

	EAP_TRACE_BEGIN(this, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(

		this,

		TRACE_FLAGS_DEFAULT,

		(EAPL("eap_am_tools_symbian_c::configure()\n")));

	EAP_TRACE_RETURN_STRING(this, "returns: eap_am_tools_symbian_c::configure()");

	if (m_configure_called == true)

	{

		return EAP_STATUS_RETURN(this, eap_status_ok);

	}

#if defined(USE_EAP_HARDWARE_TRACE)

	set_trace_mask(

		TRACE_FLAGS_ALWAYS

		| TRACE_FLAGS_ERROR

		| eap_am_tools_c::eap_trace_mask_debug

		| EAP_TRACE_FLAGS_MESSAGE_DATA

		| TRACE_FLAGS_TIMER

		| TRACE_FLAGS_TIMER_QUEUE);

#endif //#if defined(USE_EAP_HARDWARE_TRACE)

	m_start_ticks = get_clock_ticks();

	iLastTime = m_start_ticks;

	eap_status_e status = m_crypto.configure();

	if (status != eap_status_ok)

	{

		return EAP_STATUS_RETURN(this, status);

	}

	m_crypto.add_rand_seed_hw_ticks();

	if (m_crypto.get_is_valid() == false)

	{

		EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(this, eap_status_allocation_error);

	}

	if (m_timer_queue.get_is_valid() == false)

	{

		EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(this, eap_status_allocation_error);

	}

	if (m_global_mutex.get_is_valid() == false)

	{

		EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(this, eap_status_allocation_error);

	}

	if (m_trace_mutex.get_is_valid() == false)

	{

		EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(this, eap_status_allocation_error);

	}

#if defined(USE_EAP_FILE_TRACE)

#if !defined (USE_MULTITHREADING)

	TInt result = m_Fs.Connect();	

	if (result != KErrNone)

	{

		EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(this, eap_status_process_general_error);

	}

#endif //#if !defined (USE_MULTITHREADING)

#endif //#if defined(USE_EAP_FILE_TRACE)

	{

		set_use_timer_queue();

		set_use_eap_milli_second_timer(true);

		TRAPD(err, CTimer::ConstructL());

		if (err != KErrNone)

		{

			EAP_TRACE_ERROR(

				this,

				TRACE_FLAGS_DEFAULT,

				(EAPL("CTimer::ConstructL() failed, err %d.\n"),

				err));

			EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);	

			return EAP_STATUS_RETURN(this, eap_status_process_general_error);

		}

		CActiveScheduler::Add(this);

	}

	m_configure_called = true;

	EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);

	return eap_status_ok;

}

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

EAP_FUNC_EXPORT void eap_am_tools_symbian_c::enter_global_mutex()

{

	EAP_ASSERT_ALWAYS_TOOLS(this, m_configure_called == true);

	m_global_mutex.mutex_enter();

}

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

EAP_FUNC_EXPORT void eap_am_tools_symbian_c::leave_global_mutex()

{

	m_global_mutex.mutex_leave(this);

}

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

EAP_FUNC_EXPORT abs_eap_am_mutex_c * eap_am_tools_symbian_c::get_global_mutex()

{

	return &m_global_mutex;

}

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

EAP_FUNC_EXPORT void eap_am_tools_symbian_c::enter_trace_mutex()

{

	m_trace_mutex.mutex_enter();

}

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

EAP_FUNC_EXPORT void eap_am_tools_symbian_c::leave_trace_mutex()

{

	m_trace_mutex.mutex_leave(this);

}

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

EAP_FUNC_EXPORT abs_eap_am_mutex_c * eap_am_tools_symbian_c::get_trace_mutex()

{

	return &m_trace_mutex;

}

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

EAP_FUNC_EXPORT u32_t eap_am_tools_symbian_c::get_timer_resolution_ms()

{

	enter_global_mutex();

	const u32_t res = m_timer_queue.get_timer_resolution_ms();

	leave_global_mutex();

	return res;

}

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

//

EAP_FUNC_EXPORT void eap_am_tools_symbian_c::set_timer_resolution_ms(const u32_t timer_resolution_ms)

{

	enter_global_mutex();

	m_timer_queue.set_timer_resolution_ms(timer_resolution_ms);

	leave_global_mutex();

}

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

EAP_FUNC_EXPORT u32_t eap_am_tools_symbian_c::pulse_timer(const u32_t elapsed_time_in_ms)

{

	return m_timer_queue.pulse_timer(elapsed_time_in_ms, true);

}

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

//

EAP_FUNC_EXPORT void eap_am_tools_symbian_c::sprint(TDes& /*KPrintBuf*/, eap_const_string /*format*/, ...)

{

}

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

//

EAP_FUNC_EXPORT u32_t eap_am_tools_symbian_c::snprintf(u8_t * const buffer, u32_t buffer_size, eap_format_string format, ...)

{

	if (buffer == 0)

	{

		return 0ul;

	}

	u32_t result = 0;

	m_format_buf.Copy((const TUint8 *)format);

	VA_LIST args = {0,};

	VA_START(args, format);

	m_trace_buf.FormatList(m_format_buf, args);

	VA_END(args);

	result = (static_cast<u32_t>(m_trace_buf.Size()) < buffer_size) ? static_cast<u32_t>(m_trace_buf.Size()) : buffer_size;

	memmove(buffer, m_trace_buf.PtrZ(), result);

	return result;

}

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

//

EAP_FUNC_EXPORT void eap_am_tools_symbian_c::formatted_print(eap_format_string format, ...)

{

	EAP_UNREFERENCED_PARAMETER(format);

#if defined(USE_EAP_TRACE) || defined(USE_EAP_TRACE_ALWAYS)

	enter_trace_mutex();

	u64_t time_stamp = get_clock_ticks();

	TInt64 *_time_stamp = (TInt64 *)&time_stamp;		

	if (get_use_seconds_timestamp_in_traces() == true)

	{

		u64_t hw_ticks_of_second = get_clock_ticks_of_second();

		TInt64 *_hw_ticks_of_second = (TInt64 *)&hw_ticks_of_second;		

		time_stamp -= m_start_ticks;

		{

			TInt64 _seconds = (*_time_stamp) / (*_hw_ticks_of_second);

			TInt64 _remainder = (*_time_stamp) % (*_hw_ticks_of_second);

			TInt64 _multiplier((TUint)1000000ul);

			TInt64 _tmp = _multiplier * _remainder;

			TInt64 _micro_seconds = _tmp / (*_hw_ticks_of_second);

			TInt64 _div_60((TUint)60ul);

			TInt64 _minutes = _seconds / _div_60;

			_seconds = _seconds - _minutes * _div_60;

			TInt64 _hours = _minutes / _div_60;

			_minutes = _minutes - _hours* _div_60;

			_LIT8(KFormat1, "%02d:%02d:%02d.%06d:%s:");

			m_trace_buf.Format(

				KFormat1,

				static_cast<TInt32>(_hours),

				static_cast<TInt32>(_minutes),

				static_cast<TInt32>(_seconds),

				static_cast<TInt32>(_micro_seconds),

				m_prefix_string.get_data());

		}

	}

	else

	{

		_LIT8(KFormat2, "%08x%08x:%s:");

		u32_t *time_stamp_u32_t = reinterpret_cast<u32_t *>(&time_stamp);

		m_trace_buf.Format(

			KFormat2,

			time_stamp_u32_t[1],

			time_stamp_u32_t[0],

			m_prefix_string.get_data());

	}

	VA_LIST args = {0,};

	VA_START(args, format);

	m_format_buf.Copy((const TUint8 *)format);

	m_args_buf.FormatList(m_format_buf, args);

	m_trace_buf.Append(m_args_buf);			

	VA_END(args);

#if defined(USE_EAP_HARDWARE_TRACE)

	{

		#if !defined(USE_EAP_HARDWARE_TRACE_RAW_PRINT)

		{

			TInt length = m_trace_buf.Length();

			if (length >= 2ul)

			{

				--length;

				const TUint8 *last_char = m_trace_buf.Ptr() + length;

				if (last_char != 0

					&& *last_char == '\n')

				{

					// This removes the ending new line character.

					// RDebug::Print() will write new line automatically.

					m_trace_buf.SetLength(length);

				}

			}

		}

		#endif //#if !defined(USE_EAP_HARDWARE_TRACE_RAW_PRINT)

		m_trace_buf_16.Copy(m_trace_buf);

		#if defined(USE_EAP_HARDWARE_TRACE_RAW_PRINT)

			RDebug::RawPrint(m_trace_buf_16);

		#else

			RDebug::Print(_L("%S"), &m_trace_buf_16);

		#endif //#if defined(USE_EAP_HARDWARE_TRACE_RAW_PRINT)

	}

#endif //#if defined(USE_EAP_HARDWARE_TRACE)

#if defined(USE_EAP_FILE_TRACE)

	#if defined (USE_MULTITHREADING)

		if (m_filename.Length() > 0ul)

		{

			TInt result = session.Connect();	

			if (result != KErrNone)

			{

				leave_trace_mutex();

				EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);

				return;

			}	

			TInt err = m_LogFile.Open(session, m_filename, EFileWrite | EFileShareAny);

			if (err != KErrNone)

			{			

				session.Close();

				leave_trace_mutex();

				EAP_TRACE_END(this, TRACE_FLAGS_DEFAULT);

				return;

			}

			m_logfile_open = true;

		}

	#endif //#if defined (USE_MULTITHREADING)

	if (m_logfile_open == true)

	{

		//  possible errors in the write because we can't do anything if

		// for example disk is full.

		TInt pos = 0;

		// Seek to the end of file for appending

		m_LogFile.Seek(ESeekEnd, pos);

		m_LogFile.Write(m_trace_buf);