/*

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

	#undef EAP_FILE_NUMBER_DATE 

	#define EAP_FILE_NUMBER_DATE 1127594498 

#endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

#include "eapol_message_wlan_authentication.h"

#include "eapol_wlan_database_reference.h"

#include "eap_am_memory.h"

#include "abs_eap_state_notification.h"

#include "eap_crypto_api.h"

#include "eap_header_string.h"

#include "eap_buffer.h"

#include "eapol_session_key.h"

#include "eapol_handle_tlv_message_data.h"

#include "eap_automatic_variable.h"

#include "eap_array_algorithms.h"

#include "eap_config.h"

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

#if defined(USE_TEST_WLAN_AUTHENTICATION_MUTEX) && defined(USE_EAPOL_WLAN_AUTHENTICATION_MUTEX)

	#error "You cannot define both USE_EAPOL_WLAN_AUTHENTICATION_MUTEX and USE_TEST_WLAN_AUTHENTICATION_MUTEX."

#endif

#if !defined(USE_TEST_WLAN_AUTHENTICATION_MUTEX) && defined(USE_EAPOL_WLAN_AUTHENTICATION_MESSAGE_ASYNCRONOUS_TEST)

	#error "You must define USE_TEST_WLAN_AUTHENTICATION_MUTEX if USE_EAPOL_WLAN_AUTHENTICATION_MESSAGE_ASYNCRONOUS_TEST is used."

#endif

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

/**

 * This is the timer ID used with abs_eap_am_tools_c::set_timer() and abs_eap_am_tools_c::cancel_timer().

 */

enum eapol_core_timer_id

{

	EAPOL_MESSAGE_TIMER_PROCESS_DATA_ID,

	EAPOL_MESSAGE_TIMER_SEND_DATA_ID,

};

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

EAP_FUNC_EXPORT eapol_message_wlan_authentication_c::~eapol_message_wlan_authentication_c()

{

}

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

EAP_FUNC_EXPORT eapol_message_wlan_authentication_c::eapol_message_wlan_authentication_c(

	abs_eap_am_tools_c * const tools,

	abs_eapol_message_wlan_authentication_c * const partner)

	: m_am_tools(tools)

	, m_wauth(0)

	, m_partner(partner)

	, m_wlan_database_reference(tools)

	, m_header_offset(0ul)

	, m_MTU(0ul)

	, m_trailer_length(0ul)

	, m_error_code(wlan_eap_if_send_status_ok)

	, m_error_function(eapol_tlv_message_type_function_none)

	, m_use_asyncronous_test(false)

	, m_is_valid(true)

{

}

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

EAP_FUNC_EXPORT eap_status_e eapol_message_wlan_authentication_c::configure(

	const u32_t header_offset,

	const u32_t MTU,

	const u32_t trailer_length)

{

	eap_status_e status(eap_status_ok);

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

	m_header_offset = header_offset;

	m_MTU = MTU;

	m_trailer_length = trailer_length;

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

	// eapol_wlan_authentication_c object uses the tools object.

	m_wauth = eapol_wlan_authentication_c::new_eapol_wlan_authentication(

		m_am_tools,

		this,

		true,

		this);

	if (m_wauth != 0

		&& m_wauth->get_is_valid() == true)

	{

		status = m_wauth->configure();

		if (status != eap_status_ok)

		{

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

	}

	else

	{

		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

	}

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

	{

		eap_variable_data_c EAPOL_TEST_use_asyncronous_test(m_am_tools);

		eap_status_e status = m_wauth->read_configure(

			cf_str_EAPOL_TEST_use_message_asyncronous_test.get_field(),

			&EAPOL_TEST_use_asyncronous_test);

		if (status == eap_status_ok

			&& EAPOL_TEST_use_asyncronous_test.get_is_valid_data() == true)

		{

			u32_t *use_asyncronous_test = reinterpret_cast<u32_t *>(

				EAPOL_TEST_use_asyncronous_test.get_data(sizeof(u32_t)));

			if (use_asyncronous_test != 0

				&& *use_asyncronous_test != 0)

			{

				m_use_asyncronous_test = true;

			}

		}

	}

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

	return EAP_STATUS_RETURN(m_am_tools, status);

}

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

EAP_FUNC_EXPORT eap_status_e eapol_message_wlan_authentication_c::shutdown()

{

	// After use the eapol_wlan_authentication_c object must be deleted first.

	if (m_wauth != 0)

	{

		m_wauth->shutdown();

		delete m_wauth;

		m_wauth = 0;

	}

	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

}

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

EAP_FUNC_EXPORT bool eapol_message_wlan_authentication_c::get_is_valid()

{

	return m_is_valid;

}

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

//

EAP_FUNC_EXPORT eap_status_e eapol_message_wlan_authentication_c::timer_expired(

	const u32_t id, void *data)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(

		m_am_tools, 

		TRACE_FLAGS_DEFAULT, 

		(EAPL("TIMER: [0x%08x]->eapol_message_wlan_authentication_c::timer_expired")

		 EAPL("(id 0x%02x, data 0x%08x).\n"),

		 this, id, data));

#if defined(USE_EAPOL_WLAN_AUTHENTICATION_MESSAGE_ASYNCRONOUS_TEST)

	if (id == EAPOL_MESSAGE_TIMER_PROCESS_DATA_ID)

	{

		EAP_TRACE_DEBUG(

			m_am_tools, 

			TRACE_FLAGS_DEFAULT, 

			(EAPL("TIMER: [0x%08x]->eapol_message_wlan_authentication_c::timer_expired: EAPOL_MESSAGE_TIMER_PROCESS_DATA_ID")

			 EAPL("(id 0x%02x, data 0x%08x).\n"),

			 this, id, data));

		eapol_handle_tlv_message_data_c * const message = reinterpret_cast<eapol_handle_tlv_message_data_c *>(data);

		if (message != 0)

		{

			eap_status_e status = process_message(message);

			(void) EAP_STATUS_RETURN(m_am_tools, status);

		}

	}

	else if (id == EAPOL_MESSAGE_TIMER_SEND_DATA_ID)

	{

		EAP_TRACE_DEBUG(

			m_am_tools, 

			TRACE_FLAGS_DEFAULT, 

			(EAPL("TIMER: [0x%08x]->eapol_message_wlan_authentication_c::timer_expired: EAPOL_MESSAGE_TIMER_SEND_DATA_ID")

			 EAPL("(id 0x%02x, data 0x%08x).\n"),

			 this, id, data));

		eapol_handle_tlv_message_data_c * const message = reinterpret_cast<eapol_handle_tlv_message_data_c *>(data);

		if (message != 0)

		{

			wlan_eap_if_send_status_e send_status = m_partner->send_data(

				message->get_message_data(),

				message->get_message_data_length());

			if (send_status != wlan_eap_if_send_status_ok)

			{

				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

				(void) EAP_STATUS_RETURN(m_am_tools,

					wlan_eap_if_send_status_conversion_c::convert(send_status));

			}

		}

	}

#else

	EAP_UNREFERENCED_PARAMETER(id);

	EAP_UNREFERENCED_PARAMETER(data);

#endif

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

	return eap_status_ok;

}

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

EAP_FUNC_EXPORT eap_status_e eapol_message_wlan_authentication_c::timer_delete_data(

	const u32_t id, void * data)

{

#if defined(USE_EAPOL_WLAN_AUTHENTICATION_MESSAGE_ASYNCRONOUS_TEST)

	if (id == EAPOL_MESSAGE_TIMER_PROCESS_DATA_ID

		|| id == EAPOL_MESSAGE_TIMER_SEND_DATA_ID)

	{

		eapol_handle_tlv_message_data_c * const message = reinterpret_cast<eapol_handle_tlv_message_data_c *>(data);

		if (message != 0)

		{

			delete message;

		}

	}

#else

	EAP_UNREFERENCED_PARAMETER(id);

	EAP_UNREFERENCED_PARAMETER(data);

#endif

	return eap_status_ok;

}

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

EAP_FUNC_EXPORT eap_status_e eapol_message_wlan_authentication_c::packet_send(

	const eap_am_network_id_c * const send_network_id,

	eap_buf_chain_wr_c * const sent_packet,

	const u32_t header_offset,

	const u32_t data_length,

	const u32_t buffer_length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	eap_status_e status(eap_status_ok);

	if (sent_packet->get_do_length_checks() == true)

	{

		if (header_offset != m_header_offset)

		{

			EAP_TRACE_ERROR(

				m_am_tools,

				TRACE_FLAGS_DEFAULT,

				(EAPL("ERROR: packet_send: packet buffer corrupted (header_offset != %d).\n"),

				m_header_offset));

			EAP_ASSERT_ALWAYS(header_offset == m_header_offset);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

		}

		else if (header_offset+data_length != sent_packet->get_data_length())

		{

			EAP_TRACE_ERROR(

				m_am_tools,

				TRACE_FLAGS_DEFAULT,

				(EAPL("ERROR: packet_send: packet buffer corrupted ")

				 EAPL("(data_length %d != sent_packet->get_data_length() %d).\n"),

				 header_offset+data_length,

				 sent_packet->get_data_length()));

			EAP_ASSERT_ALWAYS(data_length == sent_packet->get_buffer_length());

			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

		}

		else if (header_offset+data_length > buffer_length)

		{

			EAP_TRACE_ERROR(

				m_am_tools,

				TRACE_FLAGS_DEFAULT,

				(EAPL("ERROR: packet_send: packet buffer corrupted ")

				 EAPL("(header_offset+data_length %d > buffer_length %d).\n"),

				 header_offset+data_length,

				 buffer_length));

			EAP_ASSERT_ALWAYS(header_offset+data_length <= buffer_length);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

		}

		else if (header_offset+data_length > m_MTU)

		{

			EAP_TRACE_ERROR(

				m_am_tools,

				TRACE_FLAGS_DEFAULT,

				(EAPL("ERROR: packet_send: packet buffer corrupted ")

				 EAPL("(header_offset+data_length %d > m_MTU %d).\n"),

				 header_offset+data_length,

				 m_MTU));

			EAP_ASSERT_ALWAYS(header_offset+data_length <= m_MTU);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

		}

	}

	else

	{

		// Always we need at least the Ethernet header.

		if (sent_packet->get_data_length()

			< eapol_ethernet_header_wr_c::get_header_length())

		{

			EAP_TRACE_ERROR(

				m_am_tools,

				TRACE_FLAGS_DEFAULT,

				(EAPL("ERROR: packet_send: packet buffer corrupted ")

				 EAPL("(sent_packet->get_data_length() %d < ")

				 EAPL("eapol_ethernet_header_wr_c::get_header_length() %d).\n"),

				 sent_packet->get_data_length(),

				 eapol_ethernet_header_wr_c::get_header_length()));

			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

		}

	}

	eapol_ethernet_header_wr_c eth(

		m_am_tools,

		sent_packet->get_data_offset(header_offset, data_length),

		data_length);

	if (eth.get_is_valid() == false)

	{

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

	}

	{

		// Creates message data composed of Attribute-Value Pairs.

		eapol_handle_tlv_message_data_c message(m_am_tools);

		if (message.get_is_valid() == false)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

		}

		status = message.add_parameter_data(eapol_tlv_message_type_function_packet_send);

		if (status != eap_status_ok)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		status = message.add_parameter_data(send_network_id);

		if (status != eap_status_ok)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		status = message.add_parameter_data(sent_packet);

		if (status != eap_status_ok)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		status = send_message(&message);

		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 EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

}

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

EAP_FUNC_EXPORT u32_t eapol_message_wlan_authentication_c::get_header_offset(

	u32_t * const MTU,

	u32_t * const trailer_length)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	// Header of this module is in the beging of the buffer

	// no additional header are used.

	*MTU = m_MTU;

	*trailer_length = m_trailer_length;

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

	return m_header_offset;

}

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

EAP_FUNC_EXPORT eap_status_e eapol_message_wlan_authentication_c::associate(

	eapol_key_802_11_authentication_mode_e authentication_mode)

{

	eap_status_e status(eap_status_ok);

	{

		// Creates message data composed of Attribute-Value Pairs.

		eapol_handle_tlv_message_data_c message(m_am_tools);

		if (message.get_is_valid() == false)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

		}

		status = message.add_parameter_data(eapol_tlv_message_type_function_associate);

		if (status != eap_status_ok)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		status = message.add_parameter_data(

			eapol_tlv_message_type_eapol_key_802_11_authentication_mode,

			static_cast<u32_t>(authentication_mode));

		if (status != eap_status_ok)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		status = send_message(&message);

		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 EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

}

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

EAP_FUNC_EXPORT eap_status_e eapol_message_wlan_authentication_c::disassociate(

	const eap_am_network_id_c * const receive_network_id, ///< source includes remote address, destination includes local address.

	const bool self_disassociation)

{

	eap_status_e status(eap_status_ok);

	{

		// Creates message data composed of Attribute-Value Pairs.

		eapol_handle_tlv_message_data_c message(m_am_tools);

		if (message.get_is_valid() == false)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

		}

		status = message.add_parameter_data(eapol_tlv_message_type_function_disassociate);

		if (status != eap_status_ok)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		status = message.add_parameter_data(receive_network_id);

		if (status != eap_status_ok)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		status = message.add_parameter_data(self_disassociation);

		if (status != eap_status_ok)

		{

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

			return EAP_STATUS_RETURN(m_am_tools, status);

		}

		status = send_message(&message);

		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 EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

}

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

EAP_FUNC_EXPORT eap_status_e eapol_message_wlan_authentication_c::packet_data_session_key(

	const eap_am_network_id_c * const send_network_id,

	const eapol_session_key_c * const key)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);