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

/*
* %version: 67.1.2.1.2 %
*/

// This is enumeration of EAPOL source code.
#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)
	#undef EAP_FILE_NUMBER_ENUM
	#define EAP_FILE_NUMBER_ENUM 48 
	#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_tools.h"
#include "eapol_core.h"
#include "eap_crypto_api.h"
#include "eapol_key_header.h"
#include "eapol_rc4_key_header.h"
#include "eap_state_notification.h"
#include "eap_automatic_variable.h"
#include "eap_network_id_selector.h"
#include "eap_config.h"
#include "eap_buffer.h"
#include "eapol_session_key.h"
#include "eap_master_session_key.h"

#define MPPE_KEY_LENGTH 32

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

// 
EAP_FUNC_EXPORT eapol_core_c::~eapol_core_c()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("eapol_core_c::~eapol_core_c(): this = 0x%08x\n"),
		this));

	EAP_ASSERT(m_shutdown_was_called == true);

	delete m_eap_core;

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
}

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

#if defined(_WIN32) && !defined(__GNUC__)
	#pragma warning( disable : 4355 ) // 'this' : used in base member initializer list
#endif

// 
EAP_FUNC_EXPORT eapol_core_c::eapol_core_c(
	abs_eap_am_tools_c * const tools,
	abs_eapol_core_c * const partner,
	const bool is_client_when_true)
	: m_partner(partner)
#if !defined(NO_EAP_SESSION_CORE)
	  , m_eap_core(new eap_session_core_c(tools, this, is_client_when_true))
#else
	  , m_eap_core(new eap_core_c(tools, this, is_client_when_true, 0, false))
#endif
#if defined(USE_EAPOL_KEY_STATE)
	  , m_eapol_key_state_map(tools, this)
#endif //#if defined(USE_EAPOL_KEY_STATE)
	  , m_am_tools(tools)
	  , m_master_session_key(m_am_tools)
	  , m_authentication_type(eapol_key_authentication_type_none)
	  , m_eapol_header_offset(0u)
	  , m_MTU(0u)
	  , m_trailer_length(0u)
	  , m_max_eapol_starts(0u)
	  , m_eapol_start_interval(0u)
	  , m_eapol_starts_sent(0u)
	  , m_is_client(is_client_when_true)
	  , m_is_valid(false)
	  , m_shutdown_was_called(false)
	  , m_block_state_notifications(false)
#if defined(USE_EAPOL_KEY_STATE)
	  , m_skip_start_4_way_handshake(false)
#endif //#if defined(USE_EAPOL_KEY_STATE)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("eapol_core_c::eapol_core_c(): %s, this = 0x%08x => 0x%08x, compiled %s %s.\n"),
		(m_is_client == true) ? "client": "server",
		this,
		dynamic_cast<abs_eap_base_timer_c *>(this),
		__DATE__,
		__TIME__));

	if (m_eap_core != 0
		&& m_eap_core->get_is_valid() == true)
	{
		set_is_valid();
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::packet_process(
	const eap_am_network_id_c * const receive_network_id,
	eap_general_header_base_c * const packet_data,
	const u32_t packet_length)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	eap_status_e status = eap_status_process_general_error;

	if (receive_network_id == 0
		|| receive_network_id->get_is_valid_data() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	if (packet_data == 0
		|| packet_length < eap_header_base_c::get_header_length())
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_illegal_packet_error);
	}

	eapol_header_wr_c eapol(
		m_am_tools,
		packet_data->get_header_buffer(packet_data->get_header_buffer_length()),
		packet_data->get_header_buffer_length());

	if (eapol.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_illegal_packet_error);
	}

	if (packet_length < eapol.get_data_length())
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_illegal_packet_error);
	}

	if (m_eap_core == 0)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	if (packet_length < eapol_header_rd_c::get_header_length() // First we need atleast header to check the data length.
		|| packet_length < eapol_header_rd_c::get_header_length()+eapol.get_data_length())
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_illegal_packet_error);
	}

	EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("-> EAPOL: %s, version=0x%02x, packet_type=0x%02x=%s, data_length=0x%04x, packet_length 0x%04x\n"),
		(m_is_client == true) ? "client": "server",
		eapol.get_version(),
		eapol.get_packet_type(),
		eapol.get_type_string(),
		eapol.get_data_length(),
		packet_length));

	status = eapol.check_header();
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	if (receive_network_id->get_type() == eapol_ethernet_type_preauthentication
		&& eapol.get_packet_type() != eapol_packet_type_eap
		&& eapol.get_packet_type() != eapol_packet_type_start)
	{
		// Only EAP-Packet and EAPOL-Start are valid for preauthentication.
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_wrong_eapol_type);
	}


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

	eapol_key_state_c *eapol_key_state = 0;

	{
		// Here we swap the addresses.
		eap_am_network_id_c send_network_id(
			m_am_tools,
			receive_network_id->get_destination_id(),
			receive_network_id->get_source_id(),
			receive_network_id->get_type());
		if (send_network_id.get_is_valid_data() == false)
		{
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		eap_network_id_selector_c state_selector(
			m_am_tools,
			&send_network_id);

		if (state_selector.get_is_valid() == false)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		EAP_TRACE_DATA_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("packet_process(): EAPOL-Key session"),
			state_selector.get_data(state_selector.get_data_length()),
			state_selector.get_data_length()));


		// Check do we have handler for this packet. This applies to EAP-packets too.
		eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

		if (eapol_key_state == 0)
		{
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("ERROR: eapol_core_c::packet_process() failed, no eapol_key_state_c object for this packet. Drop packet.\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_drop_packet_quietly);
		}
	}

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


	if (eapol.get_packet_type() == eapol_packet_type_eap
		&& eapol.get_data_length() >= eap_header_base_c::get_header_length())
	{
		if (m_authentication_type != eapol_key_authentication_type_RSNA_EAP
			&& m_authentication_type != eapol_key_authentication_type_WPA_EAP
			&& m_authentication_type != eapol_key_authentication_type_dynamic_WEP
#if defined(EAP_USE_WPXM)
			&& m_authentication_type != eapol_key_authentication_type_WPXM
#endif //#if defined(EAP_USE_WPXM)
			&& m_authentication_type != eapol_key_authentication_type_WFA_SC
			&& m_authentication_type != eapol_key_authentication_type_EAP_authentication_no_encryption
			)
		{
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("WARNING: eapol_core_c::packet_process(): Illegal authentication type 0x%08x\n"),
				 m_authentication_type));
			
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_wrong_eapol_type);
		}


#if defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)

		// Test first we are connected.
		if (eapol_key_state->get_is_associated() == true)
		{
			status = m_eap_core->synchronous_create_eap_session(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);
			}
		}

#endif //#if !defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)


		eap_header_wr_c eap(
			m_am_tools,
			eapol.get_eap_header(),
			eapol.get_data_length());

		status = m_eap_core->packet_process(
			receive_network_id,
			&eap,
			eapol.get_data_length());

		EAP_GENERAL_HEADER_COPY_ERROR_PARAMETERS(packet_data, &eap);
	}
	else if (m_is_client == false
		&& eapol.get_packet_type() == eapol_packet_type_logoff)
	{
		status = eap_status_ok;
	}
	else if (m_is_client == false
		&& eapol.get_packet_type() == eapol_packet_type_start)
	{
		if (m_authentication_type != eapol_key_authentication_type_RSNA_EAP
			&& m_authentication_type != eapol_key_authentication_type_WPA_EAP
			&& m_authentication_type != eapol_key_authentication_type_dynamic_WEP
			&& m_authentication_type != eapol_key_authentication_type_WFA_SC
#if defined(EAP_USE_WPXM)
			&& m_authentication_type != eapol_key_authentication_type_WPXM
#endif //#if defined(EAP_USE_WPXM)
			&& m_authentication_type != eapol_key_authentication_type_EAP_authentication_no_encryption
			)
		{
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("WARNING: eapol_core_c::packet_process(): Illegal authentication type 0x%08x\n"),
				 m_authentication_type));
			
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_wrong_eapol_type);
		}

		// This call does not cause clean restart. On-going authentication is not terminated.
		status = restart_authentication(
			receive_network_id,
			m_is_client,
			false);
	}
#if defined(USE_EAPOL_KEY_STATE)
	else if (eapol.get_packet_type() == eapol_packet_type_key)
	{
		if (m_authentication_type != eapol_key_authentication_type_RSNA_EAP
			&& m_authentication_type != eapol_key_authentication_type_RSNA_PSK
			&& m_authentication_type != eapol_key_authentication_type_WPA_EAP
			&& m_authentication_type != eapol_key_authentication_type_WPA_PSK
			&& m_authentication_type != eapol_key_authentication_type_dynamic_WEP
#if defined(EAP_USE_WPXM)
			&& m_authentication_type != eapol_key_authentication_type_WPXM
#endif //#if defined(EAP_USE_WPXM)
			&& m_authentication_type != eapol_key_authentication_type_EAP_authentication_no_encryption
			)
		{
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("WARNING: eapol_core_c::packet_process(): Illegal authentication type 0x%08x\n"),
				 m_authentication_type));
			
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_wrong_eapol_type);
		}

		// Indicates EAP-Core of received EAPOL-Key message.
		// This is indication of finished EAP-authentication.
		// NOTE, we do not care of the status.
		// Some EAP-types does not implement this function.
		(void) eap_acknowledge(receive_network_id);

		if (eapol_key_state != 0)
		{
			status = eapol_key_state->process_eapol_key_frame(
				receive_network_id,
				packet_data,
				packet_length);
		}
		else
		{
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("ERROR: process_eapol_key_frame() failed, no eapol_key_state_c object\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_handler_does_not_exists_error);
		}
	}
#endif //#if defined(USE_EAPOL_KEY_STATE)
#if ! defined(USE_EAPOL_KEY_STATE)
	else if (
		m_is_client == true
		&& eapol.get_packet_type() == eapol_packet_type_key)
	{
		// Handle EAPOL-Key frame.
		// Here is assumed the EAPOL-Key frame includes RC4 Key Descriptor.
		/**
		 * @{ Here we need to check the Descriptor Type field.
		 * It may be RC4 Key Descriptor, RSNA Key Descriptor or other descriptor. }
		 */
		
		eapol_RC4_key_header_c eapol_key_msg(
			m_am_tools,
			eapol.get_header_buffer(eapol.get_header_buffer_length()),
			eapol.get_header_buffer_length());
		if (eapol_key_msg.get_is_valid() == false)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);
		}
		else if (eapol_key_msg.check_header() != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		status = handle_RC4_key_descriptor(
			receive_network_id,
			&eapol_key_msg,
			packet_length);
	}
#endif //#if ! defined(USE_EAPOL_KEY_STATE)
	else
	{
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("ERROR: %s, packet_type=0x%02x=%s not handled, data length 0x%04x.\n"),
			(m_is_client == true) ? "client": "server",
			eapol.get_packet_type(),
			eapol.get_type_string(),
			eapol.get_data_length()));
		EAP_TRACE_DATA_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("     source"), receive_network_id->get_source(), receive_network_id->get_source_length()));
		EAP_TRACE_DATA_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("destination"), receive_network_id->get_destination(), receive_network_id->get_destination_length()));

		status = eap_status_wrong_eapol_type;
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_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_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);
	EAP_ASSERT(header_offset < sent_packet->get_data_length());
	EAP_ASSERT(data_length <= sent_packet->get_data_length());
	EAP_ASSERT(sent_packet->get_data_length() <= buffer_length);

	if (header_offset < eap_header_wr_c::get_header_length())
	{
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("packet_send: packet buffer corrupted.\n")));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);
	}

	eapol_header_wr_c eapol(
		m_am_tools,
		sent_packet->get_data_offset(
			header_offset-eap_header_wr_c::get_header_length(), data_length),
		data_length);

	if (eapol.get_is_valid() == false)
	{
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("packet_send: packet buffer corrupted.\n")));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);
	}

	eapol.set_version(eapol_protocol_version_1);
	eapol.set_packet_type(eapol_packet_type_eap);
	eapol.set_data_length(static_cast<u16_t>(data_length));

	{
		eap_network_id_selector_c state_selector(
			m_am_tools,
			send_network_id);
		if (state_selector.get_is_valid() == false)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		EAP_TRACE_DATA_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("packet_send(): EAPOL-Key session"),
			state_selector.get_data(state_selector.get_data_length()),
			state_selector.get_data_length()));

		eapol_key_state_c *session = m_eapol_key_state_map.get_handler(&state_selector);

		bool encryption_on(false);

		if (session != 0
			&& session->get_is_valid() == true)
		{
			encryption_on = session->get_is_encryption_on();
		}

		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Read EAPOL-Key session: encryption is %s\n"),
			((encryption_on == true) ? "on" : "off")));
		
		sent_packet->set_encrypt(encryption_on);
	}

	EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("<- EAPOL: %s, version=0x%02x, packet_type=0x%02x=%s, data_length=0x%04x, packet_length 0x%04x\n"),
		(m_is_client == true) ? "client": "server",
		eapol.get_version(),
		eapol.get_packet_type(),
		eapol.get_type_string(),
		eapol.get_data_length(),
		data_length));

	if (m_shutdown_was_called == true
		&& m_is_client == true)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: EAP_Core: %s, eapol_core_c::packet_send(): %s packet dropped quietly because shutdown was already called.\n"),
			 (m_is_client == true) ? "client": "server",
			 eapol.get_type_string()));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_drop_packet_quietly);
	}

	eap_status_e status = m_partner->packet_send(
		send_network_id, sent_packet, header_offset-eapol_header_wr_c::get_header_length(),
		data_length+eapol_header_wr_c::get_header_length(), buffer_length);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT u32_t eapol_core_c::get_header_offset(
	u32_t * const MTU,
	u32_t * const trailer_length)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	const u32_t offset = m_partner->get_header_offset(MTU, trailer_length);
	(*MTU) -= eapol_header_wr_c::get_header_length();
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return offset+eapol_header_wr_c::get_header_length();
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::eap_acknowledge(
	const eap_am_network_id_c * const receive_network_id)
{
	// Any Network Protocol packet is accepted as a success indication.
	// This is described in RFC 2284 "PPP Extensible Authentication Protocol (EAP)".

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	if (m_eap_core == 0)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_status_e status = m_eap_core->eap_acknowledge(receive_network_id);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::load_module(
	const eap_type_value_e type,
	const eap_type_value_e tunneling_type,
	abs_eap_base_type_c * const partner,
	eap_base_type_c ** const eap_type,
	const bool is_client_when_true,
	const eap_am_network_id_c * const receive_network_id)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	eap_status_e status = m_partner->load_module(
		type,
		tunneling_type,
		partner,
		eap_type,
		is_client_when_true,
		receive_network_id);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::unload_module(const eap_type_value_e type)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	const eap_status_e status = m_partner->unload_module(type);
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::restart_authentication(
	const eap_am_network_id_c * const receive_network_id,
	const bool is_client_when_true,
	const bool force_clean_restart,
	const bool from_timer)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("eapol_core_c::restart_authentication(): %s\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::restart_authentication()");

	eap_status_e status = eap_status_process_general_error;

	if (receive_network_id->get_type() != eapol_ethernet_type_pae
		&& receive_network_id->get_type() != eapol_ethernet_type_preauthentication)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: eapol_core_c::restart_authentication(): Illegal Ethernet type %d\n"),
			receive_network_id->get_type()));

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_ethernet_type_not_supported);
	}

	if (is_client_when_true == true)
	{
		// Client sends a EAPOL-Start message.
		(void) m_partner->cancel_timer(
			this,
			EAPOL_CORE_TIMER_SEND_START_AGAIN_ID);

#if !defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)
#if !defined(NO_EAP_SESSION_CORE)
		// First we remove possible EAP session.
		(void) m_eap_core->synchronous_remove_eap_session(receive_network_id);
#endif
#endif //#if defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)

		// Here we swap the addresses.
		eap_am_network_id_c send_network_id(m_am_tools,
			receive_network_id->get_destination_id(),
			receive_network_id->get_source_id(),
			receive_network_id->get_type());
		if (send_network_id.get_is_valid_data() == false)
		{
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		eap_buf_chain_wr_c start_packet(
			eap_write_buffer, 
			m_am_tools, 
			EAP_MAX_LOCAL_PACKET_BUFFER_LENGTH);

		if (start_packet.get_is_valid() == false)
		{
			EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("packet buffer corrupted.\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		u32_t buffer_size = EAP_MAX_LOCAL_PACKET_BUFFER_LENGTH;
		EAP_ASSERT_ALWAYS(m_MTU > m_trailer_length);
		if (m_MTU-m_trailer_length < buffer_size)
		{
			buffer_size = m_MTU-m_trailer_length;
		}

		EAP_ASSERT_ALWAYS(buffer_size >= m_eapol_header_offset);
		eapol_header_wr_c eapol(
			m_am_tools,
			start_packet.get_data_offset(
				m_eapol_header_offset,
				(buffer_size-m_eapol_header_offset)),
			(buffer_size-m_eapol_header_offset));

		if (eapol.get_is_valid() == false)
		{
			EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("packet_send: packet buffer corrupted.\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);
		}

		eapol.set_version(eapol_protocol_version_1);
		eapol.set_packet_type(eapol_packet_type_start);
		eapol.set_data_length(0);

		start_packet.set_data_length(
			m_eapol_header_offset
			+eapol_header_wr_c::get_header_length()
			+eapol.get_data_length());

		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("<- EAPOL: %s, version=0x%02x, packet_type=0x%02x=%s, data_length=0x%04x, packet length 0x%04x\n"),
			(m_is_client == true) ? "client": "server",
			eapol.get_version(),
			eapol.get_packet_type(),
			eapol.get_type_string(),
			eapol.get_data_length(),
			eapol_header_wr_c::get_header_length()+eapol.get_data_length()));

		status = m_partner->packet_send(
			&send_network_id,
			&start_packet,
			m_eapol_header_offset,
			eapol_header_wr_c::get_header_length()+eapol.get_data_length(),
			buffer_size);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		if (m_authentication_type == eapol_key_authentication_type_EAP_authentication_no_encryption)
		{
			// This is a hack for this security mode. Some APs need broadcast EAPOL-Start-message.

			const u8_t BROADCAST_ADDRESS[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };

			eap_variable_data_c broadcast_destination(
				m_am_tools,
				BROADCAST_ADDRESS,
				sizeof(BROADCAST_ADDRESS),
				false,
				false);
		
			if (broadcast_destination.get_is_valid_data() == false)
			{
				return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
			}

			// Here we swap the addresses.
			eap_am_network_id_c broadcast_send_network_id(m_am_tools,
				receive_network_id->get_destination_id(),
				&broadcast_destination,
				receive_network_id->get_type());
			if (send_network_id.get_is_valid_data() == false)
			{
				return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
			}

			status = m_partner->packet_send(
				&broadcast_send_network_id,
				&start_packet,
				m_eapol_header_offset,
				eapol_header_wr_c::get_header_length()+eapol.get_data_length(),
				buffer_size);
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}
		}

		if (from_timer == false)
		{
			// Reset EAPOL-Start counter because this is not a resending.
			m_eapol_starts_sent = 1;
			// Send notification
			eap_state_notification_c notification(
				m_am_tools,
				&send_network_id,
				true, // m_is_client
				eap_state_notification_generic,
				eap_protocol_layer_eapol,
				eap_type_none,
				eapol_state_none,
				eapol_state_start_sent,
				0 /* EAP identifier not valid here */,
				false);
			state_notification(&notification);
		}

		// This copy is important because timer needs data that is allocated from heap.
		eap_am_network_id_c * const copy_receive_network_id = receive_network_id->copy();
		eap_automatic_variable_c<eap_am_network_id_c> automatic_copy_receive_network_id(
			m_am_tools,
			copy_receive_network_id);

		if (copy_receive_network_id == 0
			|| copy_receive_network_id->get_is_valid_data() == false)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		// Timer will hold copy_send_network_id data.
		automatic_copy_receive_network_id.do_not_free_variable();

		status = m_partner->set_timer(
			this,
			EAPOL_CORE_TIMER_SEND_START_AGAIN_ID, 
			copy_receive_network_id,
			m_eapol_start_interval);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("TIMER: %s: EAPOL_CORE_TIMER_SEND_START_AGAIN_ID set %d ms.\n"),
			 (m_is_client == true ? "client": "server"),
			 m_eapol_start_interval));
		
	}
#if defined(USE_EAP_CORE_SERVER)
	else 
	{
		// Server.

		if (m_eap_core == 0)
		{
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		if (force_clean_restart == true)
		{
			// It is bad idea to terminate on-going authentication
			// when EAPOL-Start is received.
			// Because of that synchronous_remove_eap_session() is called
			// only when force_clean_restart is true.
#if !defined(NO_EAP_SESSION_CORE)
			bool previous_block = m_block_state_notifications;
			m_block_state_notifications = true;
			(void) m_eap_core->synchronous_remove_eap_session(receive_network_id);
			m_block_state_notifications = previous_block;
#endif
		}

		if (m_authentication_type == eapol_key_authentication_type_RSNA_EAP
			|| m_authentication_type == eapol_key_authentication_type_WPA_EAP
			|| m_authentication_type == eapol_key_authentication_type_dynamic_WEP
#if defined(EAP_USE_WPXM)
			|| m_authentication_type == eapol_key_authentication_type_WPXM
#endif //#if defined(EAP_USE_WPXM)
			|| m_authentication_type == eapol_key_authentication_type_WFA_SC
			|| m_authentication_type == eapol_key_authentication_type_EAP_authentication_no_encryption
			)
		{
			status = m_eap_core->send_eap_identity_request(receive_network_id);
		}
		else
		{
			status = eap_status_ok;
		}
	}

#else

	EAP_UNREFERENCED_PARAMETER(force_clean_restart); // Only server version uses this.

#endif //#if defined(USE_EAP_CORE_SERVER)

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::check_pmksa_cache(
	eap_array_c<eap_am_network_id_c> * const bssid_sta_receive_network_ids,
	const eapol_key_authentication_type_e selected_eapol_key_authentication_type,
	const eapol_RSNA_key_header_c::eapol_RSNA_cipher_e pairwise_key_cipher_suite,
	const eapol_RSNA_key_header_c::eapol_RSNA_cipher_e group_key_cipher_suite)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_core_c::check_pmksa_cache(): %s\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::check_pmksa_cache()");

	eap_status_e status = eap_status_ok;

	for (u32_t ind = 0ul; ind < bssid_sta_receive_network_ids->get_object_count();)
	{
		eap_am_network_id_c * const receive_network_id = bssid_sta_receive_network_ids->get_object(ind);
		if (receive_network_id == 0)
		{
			bssid_sta_receive_network_ids->reset();
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		// Here we swap the addresses.
		eap_am_network_id_c send_network_id(
			m_am_tools,
			receive_network_id->get_destination_id(),
			receive_network_id->get_source_id(),
			receive_network_id->get_type());
		if (send_network_id.get_is_valid_data() == false)
		{
			bssid_sta_receive_network_ids->reset();
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		eap_network_id_selector_c state_selector(
			m_am_tools,
			&send_network_id);
		if (state_selector.get_is_valid() == false)
		{
			bssid_sta_receive_network_ids->reset();
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		EAP_TRACE_DATA_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("check_pmksa_cache(): checks PMKSA EAPOL-Key session"),
			 state_selector.get_data(state_selector.get_data_length()),
			 state_selector.get_data_length()));
		
		eapol_key_state_c *session = m_eapol_key_state_map.get_handler(&state_selector);
		
		if (session == 0
			|| selected_eapol_key_authentication_type == eapol_key_authentication_type_RSNA_PSK
			|| selected_eapol_key_authentication_type == eapol_key_authentication_type_WPA_PSK
			|| session->check_pmksa_cache(
				selected_eapol_key_authentication_type,
				pairwise_key_cipher_suite,
				group_key_cipher_suite) != eap_status_ok)
		{
			// No cached PMKID for this address and security suite.
			EAP_TRACE_DATA_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("No cached PMKID for this address"),
				 state_selector.get_data(state_selector.get_data_length()),
				 state_selector.get_data_length()));

			status = bssid_sta_receive_network_ids->remove_object(ind);
			if (status != eap_status_ok)
			{
				bssid_sta_receive_network_ids->reset();
				return EAP_STATUS_RETURN(m_am_tools, status);
			}

			// Note here we do not increase index because we removed the current object.
		}
		else
		{
			// Check the next index.
			++ind;
		}
	} // for()

	if (bssid_sta_receive_network_ids->get_object_count() > 0ul)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
		return EAP_STATUS_RETURN(m_am_tools, status);
	}
	else
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
		return EAP_STATUS_RETURN(m_am_tools, eap_status_not_found);
	}
}

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

/**
 * This function removes PMKSA from cache.
 * @param receive_network_id carries the MAC addresses.
 * MAC address of Authenticator should be in source address.
 * MAC address of Supplicant should be in destination address.
 */
EAP_FUNC_EXPORT eap_status_e eapol_core_c::remove_pmksa_from_cache(
	const eap_am_network_id_c * const receive_network_id
	)
{
	eap_status_e status = eap_status_process_general_error;

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::remove_pmksa_from_cache().\n"),
		 (m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::remove_pmksa_from_cache()");

	if (receive_network_id == 0)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	// Here we swap the addresses.
	eap_am_network_id_c send_network_id(
		m_am_tools,
		receive_network_id->get_destination_id(),
		receive_network_id->get_source_id(),
		receive_network_id->get_type());
	if (send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	status = remove_eapol_key_state(
		&send_network_id);
	if (status != eap_status_ok)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: eapol_core_c::disassociation(): ")
			 EAPL("remove_eapol_key_state(), eap_status_e %d\n"),
			status));
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::start_preauthentication(
	const eap_am_network_id_c * const receive_network_id,
	const eapol_key_authentication_type_e authentication_type)
{
	eap_status_e status = eap_status_process_general_error;

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::start_preauthentication().\n"),
		 (m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::start_preauthentication()");

#if defined(USE_EAPOL_KEY_STATE)

	if (receive_network_id->get_type() != eapol_ethernet_type_preauthentication)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: eapol_core_c::start_preauthentication(): Illegal Ethernet type 0x%04x\n"),
			receive_network_id->get_type()));

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_ethernet_type_not_supported);
	}


	if (m_authentication_type != authentication_type)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: eapol_core_c::start_preauthentication(): Illegal authentication type 0x%08x, ")
			 EAPL("it should be 0x%08x\n"),
			 authentication_type,
			 m_authentication_type));

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_wrong_authentication_type);
	}


	// Here we swap the addresses.
	eap_am_network_id_c send_network_id(
		m_am_tools,
		receive_network_id->get_destination_id(),
		receive_network_id->get_source_id(),
		receive_network_id->get_type());
	if (send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_network_id_selector_c state_selector(
		m_am_tools,
		&send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("start_preauthentication(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));


	eapol_key_state_c *eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

	if (eapol_key_state != 0)
	{
		// Reuse the session.
		eapol_key_state->unset_marked_removed();

		status = eapol_key_state->reset();
		if (status != eap_status_ok)
		{
			// We cannot reuse the session.
			EAP_TRACE_ERROR(
				m_am_tools, 
				TRACE_FLAGS_ERROR, 
				(EAPL("start_preauthentication(): eapol_key_state NOT reused.\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}
	}


	if (eapol_key_state == 0)
	{
		eapol_key_state = new eapol_key_state_c(
			m_am_tools,
			this,
			m_partner,
			m_is_client,
			receive_network_id,
			authentication_type);
		if (eapol_key_state == 0
			|| eapol_key_state->get_is_valid() == false)
		{
			if (eapol_key_state != 0)
			{
				eapol_key_state->shutdown();
			}
			else
			{
				EAP_TRACE_DEBUG(
					m_am_tools, 
					TRACE_FLAGS_DEFAULT, 
					(EAPL("WARNING: eapol_core_c::start_preauthentication(): Cannot run eapol_key_state->shutdown() 0x%08x\n"),
					eapol_key_state));
			}
			delete eapol_key_state;
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		status = eapol_key_state->initialize_preauthentication(
			receive_network_id,
			authentication_type);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		status = m_eapol_key_state_map.add_handler(&state_selector, eapol_key_state);
		if (status != eap_status_ok)
		{
			eapol_key_state->shutdown();
			delete eapol_key_state;
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}
	}
	else
	{
		status = eapol_key_state->initialize_preauthentication(
			receive_network_id,
			authentication_type);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}
	}


	status = eapol_key_state->configure();
	if (status != eap_status_ok)
	{
		status = remove_eapol_key_state(
			&send_network_id);
		if (status != eap_status_ok)
		{
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("WARNING: eapol_core_c::start_preauthentication(): remove_eapol_key_state(), eap_status_e %d\n"),
				status));
		}

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}


	// This call does cause clean restart. On-going authentication is terminated.
	status = restart_authentication(
		receive_network_id,
		m_is_client,
		true,
		false);

#endif //#if defined(USE_EAPOL_KEY_STATE)

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
eap_status_e eapol_core_c::copy_eapol_key_state(
	const eap_am_network_id_c * const old_receive_network_id, ///< source includes remote address, destination includes local address.
	const eap_am_network_id_c * const new_receive_network_id ///< source includes remote address, destination includes local address.
	)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s: eapol_core_c::copy_eapol_key_state()\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::copy_eapol_key_state()");

	eap_status_e status(eap_status_process_general_error);

	if (old_receive_network_id == 0
		|| old_receive_network_id->get_is_valid_data() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	if (new_receive_network_id == 0
		|| new_receive_network_id->get_is_valid_data() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

#if defined(USE_EAPOL_KEY_STATE)

	// Here we swap the addresses.
	eap_am_network_id_c old_send_network_id(
		m_am_tools,
		old_receive_network_id->get_destination_id(),
		old_receive_network_id->get_source_id(),
		old_receive_network_id->get_type());
	if (old_send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_network_id_selector_c old_state_selector(
		m_am_tools,
		&old_send_network_id);

	if (old_state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("copy_eapol_key_state(): old EAPOL-Key session"),
		old_state_selector.get_data(),
		old_state_selector.get_data_length()));

	eapol_key_state_c *old_eapol_key_state = m_eapol_key_state_map.get_handler(&old_state_selector);

	if (old_eapol_key_state != 0)
	{
		{
			// Here we remove the old state from map. Note the old state is not deleted.
			// Later we add the modified old map to new location in the map.
			status = m_eapol_key_state_map.remove_handler(&old_state_selector, false);
			if (status != eap_status_ok)
			{
				old_eapol_key_state->shutdown();
				delete old_eapol_key_state;
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}

			// Set up the old state and add it to m_eapol_key_state_map.

			// Here we swap the addresses.
			eap_am_network_id_c new_send_network_id(
				m_am_tools,
				new_receive_network_id->get_destination_id(),
				new_receive_network_id->get_source_id(),
				new_receive_network_id->get_type());
			if (new_send_network_id.get_is_valid_data() == false)
			{
				return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
			}

#if defined(EAP_USE_WPXM)
			status = old_eapol_key_state->set_WPXM_parameters(new_receive_network_id);
			if (status != eap_status_ok)
			{
				old_eapol_key_state->shutdown();
				delete old_eapol_key_state;
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}
#endif //#if defined(EAP_USE_WPXM)

			eap_network_id_selector_c new_state_selector(
				m_am_tools,
				&new_send_network_id);

			if (new_state_selector.get_is_valid() == false)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
			}

			EAP_TRACE_DATA_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("copy_eapol_key_state(): new EAPOL-Key session"),
				new_state_selector.get_data(),
				new_state_selector.get_data_length()));

			status = m_eapol_key_state_map.add_handler(&new_state_selector, old_eapol_key_state);
			if (status != eap_status_ok)
			{
				old_eapol_key_state->shutdown();
				delete old_eapol_key_state;
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}
		}
	}

#endif //#if defined(USE_EAPOL_KEY_STATE)

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
eap_status_e eapol_core_c::generate_new_pmksa(
	eapol_key_state_c * * const new_eapol_key_state,
	const eap_am_network_id_c * const old_receive_network_id, ///< source includes remote address, destination includes local address.
	const eap_am_network_id_c * const new_receive_network_id ///< source includes remote address, destination includes local address.
	)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s: eapol_core_c::generate_new_pmksa()\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::generate_new_pmksa()");

	eap_status_e status(eap_status_process_general_error);

	if (new_eapol_key_state == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	if (old_receive_network_id == 0
		|| old_receive_network_id->get_is_valid_data() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	if (new_receive_network_id == 0
		|| new_receive_network_id->get_is_valid_data() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

#if defined(USE_EAPOL_KEY_STATE)

	// Here we swap the addresses.
	eap_am_network_id_c old_send_network_id(
		m_am_tools,
		old_receive_network_id->get_destination_id(),
		old_receive_network_id->get_source_id(),
		old_receive_network_id->get_type());
	if (old_send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_network_id_selector_c old_state_selector(
		m_am_tools,
		&old_send_network_id);

	if (old_state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("generate_new_pmksa(): old EAPOL-Key session"),
		old_state_selector.get_data(),
		old_state_selector.get_data_length()));

	eapol_key_state_c *old_eapol_key_state = m_eapol_key_state_map.get_handler(&old_state_selector);

	if (old_eapol_key_state != 0)
	{
		*new_eapol_key_state = old_eapol_key_state->copy(new_receive_network_id);

		if (*new_eapol_key_state == 0
			|| (*new_eapol_key_state)->get_is_valid() == false)
		{
			if (*new_eapol_key_state != 0)
			{
				(*new_eapol_key_state)->shutdown();
				delete *new_eapol_key_state;
				*new_eapol_key_state = 0;
			}
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		if (*new_eapol_key_state != 0)
		{
			// Here we swap the addresses.
			eap_am_network_id_c new_send_network_id(
				m_am_tools,
				new_receive_network_id->get_destination_id(),
				new_receive_network_id->get_source_id(),
				new_receive_network_id->get_type());
			if (new_send_network_id.get_is_valid_data() == false)
			{
				(*new_eapol_key_state)->shutdown();
				delete *new_eapol_key_state;
				*new_eapol_key_state = 0;
				return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
			}

			eap_network_id_selector_c new_state_selector(
				m_am_tools,
				&new_send_network_id);

			if (new_state_selector.get_is_valid() == false)
			{
				(*new_eapol_key_state)->shutdown();
				delete *new_eapol_key_state;
				*new_eapol_key_state = 0;
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
			}

			EAP_TRACE_DATA_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("generate_new_pmksa(): new EAPOL-Key session"),
				new_state_selector.get_data(),
				new_state_selector.get_data_length()));

			status = m_eapol_key_state_map.add_handler(&new_state_selector, *new_eapol_key_state);
			if (status != eap_status_ok)
			{
				(*new_eapol_key_state)->shutdown();
				delete *new_eapol_key_state;
				*new_eapol_key_state = 0;
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}
		}
	}
	else
	{
		status = eap_status_not_found;
	}

#endif //#if defined(USE_EAPOL_KEY_STATE)

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
eap_status_e eapol_core_c::read_reassociation_parameters(
	const eap_am_network_id_c * const old_receive_network_id, ///< source includes remote address, destination includes local address.
	const eap_am_network_id_c * const new_receive_network_id, ///< source includes remote address, destination includes local address.
	const eapol_key_authentication_type_e authentication_type,
	eap_variable_data_c * const PMKID,
	const eap_variable_data_c * const received_WPA_ie,
	const eap_variable_data_c * const sent_WPA_ie)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s: eapol_core_c::read_reassociation_parameters()\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::read_reassociation_parameters()");

	eap_status_e status(eap_status_process_general_error);

#if defined(USE_EAPOL_KEY_STATE)

	// No need to check authentication type anymore. It can be changed in reassociation.

#if defined(EAP_USE_WPXM)
	if (authentication_type == eapol_key_authentication_type_WPXM)
	{
		status = copy_eapol_key_state(old_receive_network_id, new_receive_network_id);
		if (status != eap_status_ok)
		{
			// We cannot copy the session.
			EAP_TRACE_ERROR(
				m_am_tools, 
				TRACE_FLAGS_ERROR, 
				(EAPL("eapol_core_c::read_reassociation_parameters(): cannot copy eapol_key_state.\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}
	}
#else
	EAP_UNREFERENCED_PARAMETER(old_receive_network_id);
#endif //#if defined(EAP_USE_WPXM)

	// Here we swap the addresses.
	eap_am_network_id_c new_send_network_id(
		m_am_tools,
		new_receive_network_id->get_destination_id(),
		new_receive_network_id->get_source_id(),
		new_receive_network_id->get_type());
	if (new_send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_network_id_selector_c state_selector(
		m_am_tools,
		&new_send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("read_reassociation_parameters(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));

	eapol_key_state_c *eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

	if (eapol_key_state == 0
		&& authentication_type == eapol_key_authentication_type_RSNA_EAP)
	{
		// Creates a new PMKSA based on old PMKSA and the new MAC address of new access point.
		status = generate_new_pmksa(&eapol_key_state, old_receive_network_id, new_receive_network_id);
		if (status != eap_status_ok)
		{
			// We cannot generate a new PMKSA.
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("eapol_core_c::read_reassociation_parameters(): new eapol_key_state NOT generated.\n")));
			status = eap_status_not_found;
		}
	}

	if (eapol_key_state != 0)
	{
		status = eapol_key_state->reset_cached_pmksa();
		if (status != eap_status_ok)
		{
			// We cannot reuse the session.
			EAP_TRACE_ERROR(
				m_am_tools, 
				TRACE_FLAGS_ERROR, 
				(EAPL("eapol_core_c::read_reassociation_parameters(): eapol_key_state NOT reused.\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		// We have state for this connection.
		status = eapol_key_state->read_reassociation_parameters(
			new_receive_network_id, ///< source includes remote address, destination includes local address.
			authentication_type,
			PMKID,
			received_WPA_ie,
			sent_WPA_ie);
		if (status != eap_status_ok)
		{
			// ERROR, Cannot reassociate.

			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("ERROR: eapol_core_c::read_reassociation_parameters(): Cannot reassociate.\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
			return EAP_STATUS_RETURN(m_am_tools, status);
		}
	}
	else
	{
		status = eap_status_not_found;
	}

#endif //#if defined(USE_EAPOL_KEY_STATE)

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::start_reassociation(
	const eap_am_network_id_c * const receive_network_id,
	const eapol_key_authentication_type_e authentication_type,
	const eap_variable_data_c * const /*PMKID*/)
{
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s: eapol_core_c::start_reassociation()\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::start_reassociation()");

	// Here we swap the addresses.
	eap_am_network_id_c send_network_id(
		m_am_tools,
		receive_network_id->get_destination_id(),
		receive_network_id->get_source_id(),
		receive_network_id->get_type());
	if (send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_network_id_selector_c state_selector(
		m_am_tools,
		&send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("start_reassociation(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));

	eap_status_e status(eap_status_process_general_error);

	eapol_key_state_c *eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

	if (eapol_key_state != 0)
	{
		status = eapol_key_state->reset_cached_pmksa();
		if (status != eap_status_ok)
		{
			// We cannot reuse the session.
			EAP_TRACE_ERROR(
				m_am_tools, 
				TRACE_FLAGS_ERROR, 
				(EAPL("eapol_core_c::start_reassociation(): eapol_key_state NOT reused.\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

#if defined(USE_EAPOL_KEY_STATE)
		if (m_skip_start_4_way_handshake == true
			&& (authentication_type == eapol_key_authentication_type_RSNA_EAP
				|| authentication_type == eapol_key_authentication_type_RSNA_PSK
				|| authentication_type == eapol_key_authentication_type_WPA_EAP
				|| authentication_type == eapol_key_authentication_type_WPA_PSK))
		{
			// This is test to skip 4-Way Handshake start.
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("WARNING: eapol_core_c::start_reassociation(): ")
				 EAPL("skips start_4_way_handshake()\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
		}
		else
#endif //#if defined(USE_EAPOL_KEY_STATE)
		{
#if !defined(NO_EAPOL_KEY_STATE_SERVER)
			status = eapol_key_state->start_4_way_handshake(
				receive_network_id);
#endif //#if !defined(NO_EAPOL_KEY_STATE_SERVER)
		}

#if !defined(NO_EAPOL_KEY_STATE_SERVER)
		if (status != eap_status_ok)
		{
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("ERROR: eapol_core_c::start_reassociation(): ")
				 EAPL("start_4_way_handshake() failed, eap_status_e %d\n"),
				 status));
		}
		else
		{
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("eapol_core_c::start_reassociation(): ")
				 EAPL("start_4_way_handshake(), eap_status_e %d\n"),
				 status));
		}
#endif //#if !defined(NO_EAPOL_KEY_STATE_SERVER)

	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
eap_status_e eapol_core_c::complete_reassociation(
	const eapol_wlan_authentication_state_e reassociation_result,
	const eap_am_network_id_c * const receive_network_id,
	const eapol_key_authentication_type_e authentication_type,
	const eap_variable_data_c * const received_WPA_IE,
	const eap_variable_data_c * const sent_WPA_IE,
	const eapol_RSNA_key_header_c::eapol_RSNA_cipher_e pairwise_key_cipher_suite,
	const eapol_RSNA_key_header_c::eapol_RSNA_cipher_e group_key_cipher_suite
	)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s: eapol_core_c::complete_reassociation()\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::complete_reassociation()");

#if defined(USE_EAPOL_KEY_STATE)

	// Here we swap the addresses.
	eap_am_network_id_c send_network_id(
		m_am_tools,
		receive_network_id->get_destination_id(),
		receive_network_id->get_source_id(),
		receive_network_id->get_type());
	if (send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}


	// No need to check previous authentication type. It can be changed in reassociation.
	m_authentication_type = authentication_type;


	eap_network_id_selector_c state_selector(
		m_am_tools,
		&send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("complete_reassociation(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));

	eapol_key_state_c *eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

	if (eapol_key_state != 0)
	{
		// We have state for this connection.
		eap_status_e status = eapol_key_state->complete_reassociation(
			reassociation_result,
			receive_network_id,
			authentication_type,
			received_WPA_IE,
			sent_WPA_IE,
			pairwise_key_cipher_suite,
			group_key_cipher_suite
			);

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
		return EAP_STATUS_RETURN(m_am_tools, status);
	}
	else
#endif //#if defined(USE_EAPOL_KEY_STATE)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
		return EAP_STATUS_RETURN(m_am_tools, eap_status_authentication_failure);
	}
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::send_logoff(
	const eap_am_network_id_c * const receive_network_id)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s: eapol_core_c::send_logoff()\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::send_logoff()");

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	eap_status_e status(eap_status_not_supported);

	if (m_eap_core == 0)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	if (receive_network_id == 0)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	// Here we swap the addresses.
	eap_am_network_id_c send_network_id(m_am_tools,
		receive_network_id->get_destination_id(),
		receive_network_id->get_source_id(),
		receive_network_id->get_type());
	if (send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_buf_chain_wr_c logoff_packet(
		eap_write_buffer, 
		m_am_tools, 
		EAP_MAX_LOCAL_PACKET_BUFFER_LENGTH);

	if (logoff_packet.get_is_valid() == false)
	{
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("packet buffer corrupted.\n")));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	u32_t data_length = EAP_MAX_LOCAL_PACKET_BUFFER_LENGTH;

	if (data_length > 0)
	{
		data_length = 0;
	}

	eapol_header_wr_c eapol(
		m_am_tools,
		logoff_packet.get_data_offset(
			m_eapol_header_offset, m_eapol_header_offset+data_length),
		m_eapol_header_offset+data_length);

	if (eapol.get_is_valid() == false)
	{
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("packet_send: packet buffer corrupted.\n")));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);
	}

	eapol.set_version(eapol_protocol_version_1);
	eapol.set_packet_type(eapol_packet_type_logoff);
	eapol.set_data_length(static_cast<u16_t>(data_length));

	logoff_packet.set_data_length(m_eapol_header_offset+eapol_header_wr_c::get_header_length()+data_length);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("<- EAPOL: %s, version=0x%02x, packet_type=0x%02x=%s, data_length=0x%04x, packet length 0x%04x\n"),
		(m_is_client == true) ? "client": "server",
		eapol.get_version(),
		eapol.get_packet_type(),
		eapol.get_type_string(),
		eapol.get_data_length(),
		eapol.get_header_length()+eapol.get_data_length()));

	status = m_partner->packet_send(
		&send_network_id, &logoff_packet, m_eapol_header_offset,
		eapol.get_header_length()+eapol.get_data_length(), EAP_MAX_LOCAL_PACKET_BUFFER_LENGTH);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::packet_data_crypto_keys(
	const eap_am_network_id_c * const send_network_id,
	const eap_master_session_key_c * const master_session_key
	)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s: eapol_core_c::packet_data_crypto_keys()\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::packet_data_crypto_keys()");

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	eap_status_e status = eap_status_process_general_error;

	if (master_session_key->get_is_valid() == true)
	{
		EAP_TRACE_DATA_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("master session key"),
			 master_session_key->get_data(master_session_key->get_data_length()),
			 master_session_key->get_data_length()));
	}

#if defined(USE_EAPOL_KEY_STATE)

	eap_network_id_selector_c state_selector(
		m_am_tools,
		send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("packet_data_crypto_keys(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));

	eapol_key_state_c *eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

	if (eapol_key_state != 0)
	{
		status = eapol_key_state->set_pairwise_PMK(
			master_session_key,
			send_network_id);
	}
	else
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("ERROR: packet_data_crypto_keys() failed, no eapol_key_state_c object\n")));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_handler_does_not_exists_error);
	}

#else

	// Store the session key so it can be used when EAPOL-Key is received.
	m_master_session_key.reset();

	status = m_master_session_key.set_copy_of_buffer(master_session_key);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

#endif //#if defined(USE_EAPOL_KEY_STATE)

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_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);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s: eapol_core_c::packet_data_session_key()\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::packet_data_session_key()");

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	eap_status_e status = eap_status_process_general_error;

	if (key->get_is_valid() == true)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("eapol session key: type 0x%02x, index 0x%02x, tx %d\n"),
			 key->get_key_type(),
			 key->get_key_index(),
			 key->get_key_tx_bit()));

		EAP_TRACE_DATA_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("eapol session key"),
			 key->get_key()->get_data(key->get_key()->get_data_length()),
			 key->get_key()->get_data_length()));
	}

	// Forward the keys to lower layers
	status = m_partner->packet_data_session_key(
			send_network_id,
			key);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

#if !defined(USE_EAPOL_KEY_STATE)

//
eap_status_e eapol_core_c::handle_RC4_key_descriptor(
	const eap_am_network_id_c * const receive_network_id,
	eapol_RC4_key_header_c* const packet,
	const u32_t packet_length)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s: eapol_core_c::handle_RC4_key_descriptor()\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::handle_RC4_key_descriptor()");

	eap_status_e status = eap_status_process_general_error;

	// Check the packet length
	if (static_cast<u32_t>(packet->get_header_length()) != packet_length
		&& static_cast<u32_t>(packet->get_header_length() + packet->get_key_length()) != packet_length)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("ERROR: Illegal EAPOL-Key frame length, packet->get_header_length() %d, packet_length %d\n"),
			packet->get_header_length(),
			packet_length));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_illegal_packet_error);
	}

	// Get MS-MPPE-Recv-Key and MS-MPPE-Send-Key
	// Recv-Key is the first 32 bytes of master session key and Send-Key is the next 32 bytes.
	eap_variable_data_c mppe_recv_key(m_am_tools);
	eap_variable_data_c mppe_send_key(m_am_tools);
	if (m_master_session_key.get_data_length() == 16ul)
	{
		status = mppe_recv_key.set_buffer(
			m_master_session_key.get_data(m_master_session_key.get_data_length()),
			m_master_session_key.get_data_length(),
			false,
			false);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		status = mppe_send_key.set_buffer(
			m_master_session_key.get_data(m_master_session_key.get_data_length()),
			m_master_session_key.get_data_length(),
			false,
			false);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}
	}
	else
	{
		status = mppe_recv_key.set_buffer(
			m_master_session_key.get_data(MPPE_KEY_LENGTH),
			MPPE_KEY_LENGTH,
			false,
			false);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		status = mppe_send_key.set_buffer(
			m_master_session_key.get_data_offset(MPPE_KEY_LENGTH, MPPE_KEY_LENGTH),
			MPPE_KEY_LENGTH,
			false,
			false);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}
	}

	if (mppe_recv_key.get_is_valid() == false
		|| mppe_send_key.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	// Verify the the MD5 signature in Eapol-Key
	crypto_md5_c md5(m_am_tools);
	crypto_hmac_c hmac_md5(m_am_tools, &md5, false);
	if (hmac_md5.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	// MPPE-Send-Key is used as the signature key.
	if (hmac_md5.hmac_set_key(&mppe_send_key) != eap_status_ok)
	{
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("ERROR: hmac_md5_init failed\n")));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	// Save the signature from the packet
	eap_variable_data_c signature(m_am_tools);
	status = signature.set_copy_of_buffer(packet->get_key_signature(), EAPOL_RC4_KEY_SIGNATURE_LENGTH);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	// Replace the signature with zeros.
	packet->zero_key_signature(m_am_tools);

	// Send the data to HMAC-MD5 module
	if (hmac_md5.hmac_update(packet->get_header_buffer(packet_length), packet_length) != eap_status_ok)
	{
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("ERROR: hmac_md5_update failed\n")));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);		
		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);
	}

	// Get the calculated signature
	u8_t tmp_signature[EAPOL_RC4_KEY_SIGNATURE_LENGTH];
	u32_t length = EAPOL_RC4_KEY_SIGNATURE_LENGTH;
	if (hmac_md5.hmac_final(tmp_signature, &length) != eap_status_ok)
	{
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("ERROR: hmac_md5_final failed\n")));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);
	}
	
	// Compare the calculated and original signature
	if (m_am_tools->memcmp(
		tmp_signature,
		signature.get_data(
			EAPOL_RC4_KEY_SIGNATURE_LENGTH),
			EAPOL_RC4_KEY_SIGNATURE_LENGTH) != 0)
	{
		// Signatures did not match. Something's wrong.
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("ERROR: EAPOL-Key HMAC-MD5 check failed.\n")));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);
	}
	EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("EAPOL-Key HMAC-MD5 check passed.\n")));

	eap_variable_data_c key_out(m_am_tools);
	// Decrypt the RC4 encrypted key
	if (packet->get_key() == 0)
	{
		// EAPOL-Key does not contain the key. This means that we should use
		// the first bytes from MS-MPPE-Recv-Key as the key. There is a slight 
		// confusion in draft-congdon-radius-8021x-23.txt regarding this but this is how
		// it works.
		if (packet->get_key_length() > 0)
		{
			status = key_out.set_copy_of_buffer(mppe_recv_key.get_data(packet->get_key_length()), packet->get_key_length());	
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}
		} 
		else
		{
			// Key message with no key length?
			// Just ignore the message.
			EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("Got empty WEP unicast key message.\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
		}
	} 
	else
	{
		// Set-up RC4 key. Key is the IV and the MS-MPPE-Recv-Key truncated together.
		eap_variable_data_c rc4_key(m_am_tools);
		status = rc4_key.set_copy_of_buffer(packet->get_key_IV(), EAPOL_RC4_KEY_IV_LENGTH);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		rc4_key.add_data(&mppe_recv_key);

		// Set-up RC4 module
		crypto_rc4_c rc4(m_am_tools);
		// Set the key for RC4
		if (rc4.set_key(&rc4_key) != eap_status_ok)
		{
			EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("ERROR: rc4_set_key failed\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);
		}

		// Decrypt the key to key_out
		key_out.set_buffer_length(packet->get_key_length());
		if (rc4.decrypt_data(packet->get_key(), key_out.get_data(packet->get_key_length()), packet->get_key_length()) != eap_status_ok)
		{
			EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("ERROR: rc4 failed\n")));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);
		}		
		key_out.set_data_length(packet->get_key_length());
	}

	// Find out the key type. At the moment only WEP keys are supported.
	eapol_key_type_e key_type;
	switch (packet->get_key_flag())
	{
	case eapol_RC4_key_flag_broadcast:
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("Got WEP broadcast key\n")));
		key_type = eapol_key_type_broadcast;
		break;
	case eapol_RC4_key_flag_unicast:
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("Got WEP unicast key\n")));
		key_type = eapol_key_type_unicast;
		break;
	default:
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("Key"),
		 key_out.get_data(key_out.get_data_length()),
		 key_out.get_data_length()));

	// Here we swap the addresses.
	eap_am_network_id_c send_network_id(m_am_tools,
		receive_network_id->get_destination_id(),
		receive_network_id->get_source_id(),
		receive_network_id->get_type());
	if (send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eapol_session_key_c wep_key(
		m_am_tools,
		&key_out,
		key_type,
		packet->get_key_index(),
		true);

	// Forward the keys to lower layers
	status = m_partner->packet_data_session_key(
		&send_network_id,
		&wep_key);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if !defined(USE_EAPOL_KEY_STATE)

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::configure()
{
	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s: eapol_core_c::configure()\n"),
		(m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::configure()");

	m_eapol_header_offset = m_partner->get_header_offset(
		&m_MTU, &m_trailer_length);
	
	eap_status_e status = eap_status_process_general_error;

	{
		eap_variable_data_c max_eapol_starts(m_am_tools);

		status = read_configure(
			cf_str_EAPOL_CORE_starts_max_count.get_field(),
			&max_eapol_starts);
		if (status != eap_status_ok 
			|| max_eapol_starts.get_is_valid_data() == false
			|| max_eapol_starts.get_data_length() < sizeof(u32_t))
		{
			// Probably not found from db. Use the default value.
			m_max_eapol_starts = EAPOL_CORE_MAX_EAPOL_START_SENDINGS;						
		} 
		else 
		{
			m_max_eapol_starts = *reinterpret_cast<u32_t *>(
				max_eapol_starts.get_data(sizeof(u32_t)));
		}
	}

	{
		eap_variable_data_c eapol_start_interval(m_am_tools);

		status = read_configure(
			cf_str_EAPOL_CORE_send_start_interval.get_field(),
			&eapol_start_interval);
		if (status != eap_status_ok 
			|| eapol_start_interval.get_is_valid_data() == false
			|| eapol_start_interval.get_data_length() < sizeof(u32_t))
		{
			// Probably not found from db. Use the default value.
			m_eapol_start_interval = EAPOL_CORE_TIMER_SEND_START_AGAIN_TIMEOUT;						
		} 
		else 
		{
			m_eapol_start_interval = *reinterpret_cast<u32_t *>(
				eapol_start_interval.get_data(sizeof(u32_t)));
		}
	}

#if defined(USE_EAP_CORE_SERVER)
	if (m_is_client == false)
	{
		eap_variable_data_c data(m_am_tools);

		eap_status_e status = read_configure(
			cf_str_EAPOL_CORE_skip_start_4_way_handshake.get_field(),
			&data);
		if (status == eap_status_ok
			&& data.get_data_length() == sizeof(u32_t)
			&& data.get_data(data.get_data_length()) != 0)
		{
			u32_t *flag = reinterpret_cast<u32_t *>(data.get_data(data.get_data_length()));

			if (flag != 0)
			{
				if ((*flag) != 0ul)
				{
					m_skip_start_4_way_handshake = true;
				}
				else
				{
					m_skip_start_4_way_handshake = false;
				}
			}
		}
	}
#endif //#if defined(USE_EAP_CORE_SERVER)

	return EAP_STATUS_RETURN(m_am_tools, m_eap_core->configure());
}

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

#if defined(USE_EAPOL_KEY_STATE)

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::shutdown_operation(
	eapol_key_state_c * const handler,
	abs_eap_am_tools_c * const m_am_tools)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_UNREFERENCED_PARAMETER(m_am_tools);

	eap_status_e status = handler->shutdown();

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAPOL_KEY_STATE)

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::shutdown()
{
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("%s: eapol_core_c::shutdown(), m_shutdown_was_called=%d\n"),
		(m_is_client == true) ? "client": "server",
		m_shutdown_was_called));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::shutdown()");

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	if (m_shutdown_was_called == true)
	{
		// Shutdown function was called already.
		return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
	}
	m_shutdown_was_called = true;

	eap_status_e status;
#if defined(USE_EAPOL_KEY_STATE)
	status = m_eapol_key_state_map.for_each(shutdown_operation, true);
#endif //#if defined(USE_EAPOL_KEY_STATE)

	if (m_eap_core != 0)
	{
		status = m_eap_core->shutdown();
	}

	// This will cancel all timers of this object.
	m_partner->cancel_timer(this, EAPOL_CORE_TIMER_SEND_START_AGAIN_ID);
#if defined(USE_EAPOL_KEY_STATE)
	m_partner->cancel_timer(this, EAPOL_REMOVE_EAPOL_KEY_HANDSHAKE_ID);
#endif //#if defined(USE_EAPOL_KEY_STATE)
	
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::read_configure(
	const eap_configuration_field_c * const field,
	eap_variable_data_c * const data)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	const eap_status_e status = m_partner->read_configure(field, data);
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

EAP_FUNC_EXPORT eap_status_e eapol_core_c::write_configure(
	const eap_configuration_field_c * const field,
	eap_variable_data_c * const data)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	const eap_status_e status = m_partner->write_configure(field, data);
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT void eapol_core_c::set_is_valid()
{
	m_is_valid = true;
}

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

//
EAP_FUNC_EXPORT bool eapol_core_c::get_is_valid()
{
	return m_is_valid;
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_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: %s: [0x%08x]->eapol_core_c::timer_expired(id 0x%02x, data 0x%08x).\n"),
		 (m_is_client == true) ? "client": "server",
		 this,
		 id,
		 data));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::timer_expired()");

	if (id == EAPOL_CORE_TIMER_SEND_START_AGAIN_ID)
	{
		const eap_am_network_id_c * const receive_network_id
			= reinterpret_cast<const eap_am_network_id_c *>(data);
		if (m_eapol_starts_sent < m_max_eapol_starts)
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("TIMER: %s: EAPOL_CORE_TIMER_SEND_START_AGAIN_ID expired, re-start authentication.\n"),
				 (m_is_client == true ? "client": "server"),
				 m_eapol_start_interval));

			m_eapol_starts_sent++;			
			restart_authentication(receive_network_id , m_is_client, true, true);
		}
		else 
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("ERROR: TIMER: %s: EAPOL_CORE_TIMER_SEND_START_AGAIN_ID expired, too many re-starts, notifies lower layers.\n"),
				 (m_is_client == true ? "client": "server"),
				 m_eapol_start_interval));

			// Here we swap the addresses.
			eap_am_network_id_c send_network_id(m_am_tools,
				receive_network_id->get_destination_id(),
				receive_network_id->get_source_id(),
				receive_network_id->get_type());
			if (send_network_id.get_is_valid_data() == false)
			{
				return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
			}

			// EAPOL-Start has been sent enough times. Send notification to lower layers.
			// After this EAPOL stays quiet and waits for incoming
			// packets or authentication restarting.
			eap_state_notification_c notification(
				m_am_tools,
				&send_network_id,
				true, // m_is_client
				eap_state_notification_generic,
				eap_protocol_layer_eapol,
				eap_type_none,
				eapol_state_start_sent,
				eapol_state_no_start_response,
				0 /* EAP identifier not valid here */,
				false);

			notification.set_authentication_error(eap_status_authentication_failure);

			state_notification(&notification);
		}
	}
#if defined(USE_EAPOL_KEY_STATE)
	else if (id == EAPOL_REMOVE_EAPOL_KEY_HANDSHAKE_ID)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("TIMER: EAPOL_REMOVE_EAPOL_KEY_HANDSHAKE_ID elapsed, %s.\n"),
			 (m_is_client == true) ? "client": "server"));

		const eap_am_network_id_c * const send_network_id 
			= reinterpret_cast<const eap_am_network_id_c *>(data);
		if (send_network_id->get_is_valid_data() == false)
		{
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		(void) remove_eapol_key_state(send_network_id);
	}
#endif //#if defined(USE_EAPOL_KEY_STATE)

	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::timer_delete_data(
	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: %s: [0x%08x]->eapol_core_c::timer_delete_data(id 0x%02x, data 0x%08x).\n"),
		(m_is_client == true) ? "client": "server",
		this, id, data));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::timer_delete_data()");

	if (id == EAPOL_CORE_TIMER_SEND_START_AGAIN_ID)
	{
		const eap_am_network_id_c * const send_network_id
			= reinterpret_cast<const eap_am_network_id_c *>(data);
		delete send_network_id;
	}
#if defined(USE_EAPOL_KEY_STATE)
	else if (id == EAPOL_REMOVE_EAPOL_KEY_HANDSHAKE_ID)

	{
		const eap_am_network_id_c * const send_network_id 
			= reinterpret_cast<const eap_am_network_id_c *>(data);
		delete send_network_id;
	}
#endif //#if defined(USE_EAPOL_KEY_STATE)

	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
}

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

#if defined(USE_EAPOL_KEY_STATE)

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::init_eapol_key_pmksa_caching_timeout(
	const eap_am_network_id_c * const send_network_id)
{
	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::init_eapol_key_pmksa_caching_timeout().\n"),
		 (m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::init_eapol_key_pmksa_caching_timeout()");

	// Initialize PMK caching timeout of EAPOL Key state.
	eap_network_id_selector_c state_selector(
		m_am_tools,
		send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("init_eapol_key_pmksa_caching_timeout(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));

	eapol_key_state_c *eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

	if (eapol_key_state == 0)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("session not found.\n"),
			 (m_is_client == true) ? "client": "server"));

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
	}

	eap_status_e status = eapol_key_state->init_pmksa_caching_timeout();
	if (status != eap_status_ok)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: eapol_core_c::init_eapol_key_pmksa_caching_timeout(): ")
			 EAPL("eapol_key_state->init_pmksa_caching_timeout(), eap_status_e %d\n"),
			 status));
	}

	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAPOL_KEY_STATE)

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

#if defined(USE_EAPOL_KEY_STATE)

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::indicate_eapol_key_state_started_eap_authentication(
	const eap_am_network_id_c * const send_network_id)
{
	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::indicate_eapol_key_state_started_eap_authentication().\n"),
		 (m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::indicate_eapol_key_state_started_eap_authentication()");

	// Remove possible EAPOL Key state.
	eap_network_id_selector_c state_selector(
		m_am_tools,
		send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("indicate_eapol_key_state_started_eap_authentication(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));

	eapol_key_state_c *eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

	eap_status_e status(eap_status_handler_does_not_exists_error);

	if (eapol_key_state != 0)
	{
		status = eapol_key_state->started_eap_authentication();
	}
	else
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: eapol_core_c::indicate_eapol_key_state_started_eap_authentication(): Cannot run eapol_key_state->started_eap_authentication() 0x%08x\n"),
			eapol_key_state));
	}

	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAPOL_KEY_STATE)

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

#if defined(USE_EAPOL_KEY_STATE)

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::remove_eapol_key_state(
	const eap_am_network_id_c * const send_network_id)
{
	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::remove_eapol_key_state().\n"),
		 (m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::remove_eapol_key_state()");

	// Remove possible EAPOL Key state.
	eap_network_id_selector_c state_selector(
		m_am_tools,
		send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("remove_eapol_key_state(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));

	eapol_key_state_c *eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

	if (eapol_key_state != 0)
	{
		if (eapol_key_state->get_marked_removed() == false)
		{
			// Do not remove object in use.
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("WARNING: eapol_core_c::remove_eapol_key_state(): Cannot removed used object 0x%08x\n"),
				eapol_key_state));
			return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
		}

		eapol_key_state->shutdown();
	}
	else
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: eapol_core_c::remove_eapol_key_state(): Cannot run eapol_key_state->shutdown() 0x%08x\n"),
			eapol_key_state));
	}

	eap_status_e status = m_eapol_key_state_map.remove_handler(&state_selector, true);
	if (status != eap_status_ok)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: eapol_core_c::remove_eapol_key_state(): ")
			 EAPL("eapol_key_state->remove_handler(), eap_status_e %d\n"),
			 status));
	}

	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAPOL_KEY_STATE)

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

#if defined(USE_EAPOL_KEY_STATE)

//
eap_status_e eapol_core_c::asynchronous_init_remove_eapol_key_state(
	const eap_am_network_id_c * const send_network_id)
{
	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::asynchronous_init_remove_eapol_key_state().\n"),
		 (m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::asynchronous_init_remove_eapol_key_state()");

	// NOTE: we cannot delete the eapol_key_state_c object directly, because we will
	// return from here to removed object.

	eap_status_e status = eap_status_process_general_error;

	eap_network_id_selector_c state_selector(
		m_am_tools,
		send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("asynchronous_init_remove_eapol_key_state(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));

	eapol_key_state_c *session = m_eapol_key_state_map.get_handler(&state_selector);

	if (session != 0)
	{
		session->set_marked_removed();

		// So we initiate a timer to remove session identified by state_selector.
		eap_am_network_id_c * const copy_send_network_id = send_network_id->copy();
		if (copy_send_network_id == 0
			|| copy_send_network_id->get_is_valid_data() == false)
		{
			delete copy_send_network_id;
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		status = m_partner->set_timer(
			this,
			EAPOL_REMOVE_EAPOL_KEY_HANDSHAKE_ID, 
			copy_send_network_id,
			EAPOL_REMOVE_EAPOL_KEY_HANDSHAKE_TIMEOUT);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("eapol_core_c::asynchronous_init_remove_eapol_key_state()")
			 EAPL(": %s: EAPOL_REMOVE_EAPOL_KEY_HANDSHAKE_ID timer set %d ms.\n"),
			 (m_is_client == true) ? "client": "server",
			 EAPOL_REMOVE_EAPOL_KEY_HANDSHAKE_TIMEOUT));
	}
	else
	{
		// Not found, cannot remove.
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("ERROR: eapol_core_c::asynchronous_init_remove_eapol_key_state()")
			 EAPL(": %s: failed session not found.\n"),
			 (m_is_client == true) ? "client": "server"));

		status = eap_status_ok;
	}

	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAPOL_KEY_STATE)

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

EAP_FUNC_EXPORT void eapol_core_c::state_notification(
	const abs_eap_state_notification_c * const state)
{
	eap_status_e status = eap_status_process_general_error;

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::state_notification(): m_block_state_notifications=%d.\n"),
		 (m_is_client == true) ? "client": "server",
		 m_block_state_notifications));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::state_notification()");

	if (m_block_state_notifications == true)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("WARNING: eapol_core_c::state_notification(): Blocks state notification")
			 EAPL("Protocol layer %d, Protocol %d, State transition ")
			 EAPL("from %d=%s to %d=%s, client %d\n"),
			state->get_protocol_layer(), 
			state->get_protocol(), 
			state->get_previous_state(), 
			state->get_previous_state_string(), 
			state->get_current_state(), 
			state->get_current_state_string(),
			state->get_is_client()));

		return;
	}

	if (state->get_protocol_layer() == eap_protocol_layer_eap)
	{
		if (state->get_current_state() == eap_state_identity_request_received
			|| state->get_current_state() == eap_state_eap_response_sent)
		{
			if (state->get_current_state() == eap_state_identity_request_received)
			{
				(void) m_partner->cancel_timer(
					this,
					EAPOL_CORE_TIMER_SEND_START_AGAIN_ID);
			}

			if (state->get_current_state() == eap_state_identity_request_received
				|| state->get_current_state() == eap_state_eap_response_sent)
			{
#if defined(USE_EAPOL_KEY_STATE)
				// Indicate EAPOL Key state the started EAP-authentication.
				status = indicate_eapol_key_state_started_eap_authentication(
					state->get_send_network_id());
				if (status != eap_status_ok)
				{
					EAP_TRACE_DEBUG(
						m_am_tools, 
						TRACE_FLAGS_DEFAULT, 
						(EAPL("WARNING: eapol_core_c::state_notification(): ")
						 EAPL("indicate_eapol_key_state_started_eap_authentication(), eap_status_e %d\n"),
						status));
				}
#endif //#if defined(USE_EAPOL_KEY_STATE)
			}

		}
		else if (state->get_current_state() == eap_state_authentication_terminated_unsuccessfully)
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("ERROR: eapol_core_c::state_notification(): %s: EAP-authentication FAILED\n"),
				 (state->get_is_client() == true ? "client": "server")));

#if defined(USE_EAPOL_KEY_STATE)
			// Remove possible EAPOL Key state.
			status = remove_eapol_key_state(
				state->get_send_network_id());
			if (status != eap_status_ok)
			{
				EAP_TRACE_DEBUG(
					m_am_tools, 
					TRACE_FLAGS_DEFAULT, 
					(EAPL("WARNING: eapol_core_c::state_notification(): ")
					 EAPL("remove_eapol_key_state(), eap_status_e %d\n"),
					status));
			}
#endif //#if defined(USE_EAPOL_KEY_STATE)

		}
		else if (state->get_current_state() == eap_state_authentication_finished_successfully)
		{
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("eapol_core_c::state_notification(): %s: EAP authentication SUCCESS\n"),
				(state->get_is_client() == true ? "client": "server")));

#if defined(USE_EAPOL_KEY_STATE)
			eap_network_id_selector_c state_selector(
				m_am_tools,
				state->get_send_network_id());

			if (state_selector.get_is_valid() == false)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return;
			}

			EAP_TRACE_DATA_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("state_notification(): EAPOL-Key session"),
				 state_selector.get_data(state_selector.get_data_length()),
				 state_selector.get_data_length()));

			eapol_key_state_c *eapol_key_state
				= m_eapol_key_state_map.get_handler(&state_selector);

#if !defined(NO_EAPOL_KEY_STATE_SERVER)
			if (m_is_client == false)
			{
				// server
				if (eapol_key_state != 0)
				{
					// Here we swap the addresses.
					eap_am_network_id_c receive_network_id(
						m_am_tools,
						state->get_send_network_id()->get_destination_id(),
						state->get_send_network_id()->get_source_id(),
						state->get_send_network_id()->get_type());
					if (receive_network_id.get_is_valid_data() == false)
					{
						EAP_TRACE_DEBUG(
							m_am_tools, 
							TRACE_FLAGS_DEFAULT, 
							(EAPL("ERROR: eapol_core_c::state_notification(): ")
							 EAPL("start_4_way_handshake() failed, allocation error\n"),
							status));
						return;
					}

					if (m_skip_start_4_way_handshake == true
						&& (m_authentication_type == eapol_key_authentication_type_RSNA_EAP
							|| m_authentication_type == eapol_key_authentication_type_RSNA_PSK
							|| m_authentication_type == eapol_key_authentication_type_WPA_EAP
							|| m_authentication_type == eapol_key_authentication_type_WPA_PSK
							|| m_authentication_type == eapol_key_authentication_type_WPXM))
					{
						// This is test to skip 4-Way Handshake start.
						EAP_TRACE_DEBUG(
							m_am_tools, 
							TRACE_FLAGS_DEFAULT, 
							(EAPL("WARNING: eapol_core_c::state_notification(): ")
							 EAPL("skips start_4_way_handshake()\n")));
						EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
						return;
					}
					else
					{
						status = eapol_key_state->start_4_way_handshake(
							&receive_network_id);
					}

					if (status != eap_status_ok)
					{
						EAP_TRACE_DEBUG(
							m_am_tools, 
							TRACE_FLAGS_DEFAULT, 
							(EAPL("ERROR: eapol_core_c::state_notification(): ")
							 EAPL("start_4_way_handshake() failed, eap_status_e %d\n"),
							status));
					}
					else
					{
						EAP_TRACE_DEBUG(
							m_am_tools, 
							TRACE_FLAGS_DEFAULT, 
							(EAPL("eapol_core_c::state_notification(): ")
							 EAPL("start_4_way_handshake(), eap_status_e %d\n"),
							status));
					}
				}
				else
				{
					EAP_TRACE_DEBUG(
						m_am_tools, 
						TRACE_FLAGS_DEFAULT, 
						(EAPL("ERROR: eapol_core_c::state_notification(): ")
						 EAPL("start_4_way_handshake() failed, no eapol_key_state_c object\n")));
				}
			}
			else
#endif //#if !defined(NO_EAPOL_KEY_STATE_SERVER)
			{
				if (eapol_key_state != 0)
				{
					eap_status_e status = eapol_key_state->allow_4_way_handshake();
					if (status != eap_status_ok)
					{
						EAP_TRACE_DEBUG(
							m_am_tools, 
							TRACE_FLAGS_DEFAULT, 
							(EAPL("ERROR: eapol_core_c::state_notification(): ")
							 EAPL("allow_4_way_handshake() failed, eap_status_e %d\n"),
							status));
					}
					else
					{
						EAP_TRACE_DEBUG(
							m_am_tools, 
							TRACE_FLAGS_DEFAULT, 
							(EAPL("eapol_core_c::state_notification(): ")
							 EAPL("allow_4_way_handshake(), eap_status_e %d\n"),
							status));
					}
				}
				else
				{
					EAP_TRACE_DEBUG(
						m_am_tools, 
						TRACE_FLAGS_DEFAULT, 
						(EAPL("ERROR: eapol_core_c::state_notification(): ")
						 EAPL("allow_4_way_handshake() failed, no eapol_key_state_c object\n")));
				}
			}
#endif //#if defined(USE_EAPOL_KEY_STATE)
		}
		else
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("eapol_core_c::state_notification(): Unknown notification: ")
				 EAPL("Protocol layer %d, Protocol %d, State transition ")
				 EAPL("from %d=%s to %d=%s, client %d\n"),
				state->get_protocol_layer(), 
				state->get_protocol(), 
				state->get_previous_state(), 
				state->get_previous_state_string(), 
				state->get_current_state(), 
				state->get_current_state_string(),
				state->get_is_client()));
		}
	}
#if defined(USE_EAPOL_KEY_STATE)
	else if (state->get_protocol_layer() == eap_protocol_layer_eapol_key)
	{
		// This nofifation is from eapol_key_state_c object.
		if (state->get_current_state()
			== eapol_key_state_802_11i_authentication_terminated_unsuccessfull)
		{
			if (state->get_protocol() == eapol_key_handshake_type_4_way_handshake)
			{
				// 4-Way Handshake failed.
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("ERROR: eapol_core_c::state_notification(): ")
					 EAPL("%s: 4-Way Handshake FAILED\n"),
					 (state->get_is_client() == true ? "client": "server")));
			}
			else if (state->get_protocol() == eapol_key_handshake_type_group_key_handshake)
			{
				// Group Key Handshake failed.
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("ERROR: eapol_core_c::state_notification(): ")
					 EAPL("%s: Group Key Handshake FAILED\n"),
					 (state->get_is_client() == true ? "client": "server")));
			}
		}
		else if (state->get_current_state()
				 == eapol_key_state_802_11i_authentication_finished_successfull)
		{
			if (state->get_protocol() == eapol_key_handshake_type_4_way_handshake)
			{
				// 4-Way Handshake succesfull.
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("eapol_core_c::state_notification(): %s: 4-Way Handshake SUCCESS.\n"),
					 (state->get_is_client() == true ? "client": "server")));
			}
			else if (state->get_protocol() == eapol_key_handshake_type_group_key_handshake)
			{
				// Group Key Handshake succesfull.
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("eapol_core_c::state_notification(): %s: Group Key Handshake SUCCESS.\n"),
					 (state->get_is_client() == true ? "client": "server")));
			}
			else if (state->get_protocol() == eapol_key_handshake_type_802_11i_handshake)
			{
				// Full 802.11i authentication succesfull.
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("eapol_core_c::state_notification(): %s: ")
					 EAPL("Full 802.11i authentication SUCCESS.\n"),
					 (state->get_is_client() == true ? "client": "server")));
			}
			else
			{
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("eapol_core_c::state_notification(): Unknown notification: ")
					 EAPL("Protocol layer %d, Protocol %d, State transition ")
					 EAPL("from %d=%s to %d=%s, client %d\n"),
					state->get_protocol_layer(), 
					state->get_protocol(), 
					state->get_previous_state(), 
					state->get_previous_state_string(), 
					state->get_current_state(), 
					state->get_current_state_string(),
					state->get_is_client()));
			}
		}
#if defined(EAP_USE_WPXM)
		else if (state->get_current_state()
				 == eapol_key_state_wpxm_reassociation_finished_successfull)
		{
			if (state->get_protocol() == eapol_key_handshake_type_WPXM_reassociation)
			{
				// WPXM reassociation succesfull.
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("eapol_core_c::state_notification(): %s: ")
					 EAPL("WPXM reassociation SUCCESS.\n"),
					 (state->get_is_client() == true ? "client": "server")));
			}
			else
			{
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("eapol_core_c::state_notification(): Unknown notification: ")
					 EAPL("Protocol layer %d, Protocol %d, State transition ")
					 EAPL("from %d=%s to %d=%s, client %d\n"),
					state->get_protocol_layer(), 
					state->get_protocol(), 
					state->get_previous_state(), 
					state->get_previous_state_string(), 
					state->get_current_state(), 
					state->get_current_state_string(),
					state->get_is_client()));
			}
		}
#endif //#if defined(EAP_USE_WPXM)
		else if (state->get_current_state()
				 == eapol_key_state_group_key_handshake_successfull)
		{
			if (state->get_protocol() == eapol_key_handshake_type_group_key_handshake)
			{
				// Group Key Handshake succesfull.
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("eapol_core_c::state_notification(): %s: Group Key Handshake SUCCESS.\n"),
					 (state->get_is_client() == true ? "client": "server")));
			}
			else
			{
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("eapol_core_c::state_notification(): Unknown notification: ")
					 EAPL("Protocol layer %d, Protocol %d, State transition ")
					 EAPL("from %d=%s to %d=%s, client %d\n"),
					state->get_protocol_layer(), 
					state->get_protocol(), 
					state->get_previous_state(), 
					state->get_previous_state_string(), 
					state->get_current_state(), 
					state->get_current_state_string(),
					state->get_is_client()));
			}
		}
		else
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("eapol_core_c::state_notification(): Unknown notification: ")
				 EAPL("Protocol layer %d, Protocol %d, State transition ")
				 EAPL("from %d=%s to %d=%s, client %d\n"),
				state->get_protocol_layer(), 
				state->get_protocol(), 
				state->get_previous_state(), 
				state->get_previous_state_string(), 
				state->get_current_state(), 
				state->get_current_state_string(),
				state->get_is_client()));
		}
	}
#endif //#if defined(USE_EAPOL_KEY_STATE)


	m_partner->state_notification(state);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::asynchronous_init_remove_eap_session(
	const eap_am_network_id_c * const /* send_network_id */)
{
	// eapol_core_c object does not support asynchronous_init_remove_eap_session().
	return EAP_STATUS_RETURN(m_am_tools, eap_status_not_supported);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::asynchronous_start_authentication(
	const eap_am_network_id_c * const /* receive_network_id */,
	const bool /* is_client_when_true */)
{
	return EAP_STATUS_RETURN(m_am_tools, eap_status_not_supported);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::set_timer(
	abs_eap_base_timer_c * const p_initializer, 
	const u32_t p_id, 
	void * const p_data,
	const u32_t p_time_ms)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	const eap_status_e status = m_partner->set_timer(
		p_initializer, 
		p_id, 
		p_data,
		p_time_ms);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::cancel_timer(
	abs_eap_base_timer_c * const p_initializer, 
	const u32_t p_id)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	const eap_status_e status = m_partner->cancel_timer(
		p_initializer, 
		p_id);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::cancel_all_timers()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	const eap_status_e status = m_partner->cancel_all_timers();

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

EAP_FUNC_EXPORT eap_status_e eapol_core_c::check_is_valid_eap_type(
	const eap_type_value_e eap_type)
{
	eap_status_e status = m_partner->check_is_valid_eap_type(eap_type);

	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

EAP_FUNC_EXPORT eap_status_e eapol_core_c::get_eap_type_list(
	eap_array_c<eap_type_value_e> * const eap_type_list)
{
	eap_status_e status = m_partner->get_eap_type_list(eap_type_list);

	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

#if defined(USE_EAPOL_KEY_STATE)

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::cancel_authentication_session(
	eapol_key_state_c * const handler,
	abs_eap_am_tools_c * const m_am_tools)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("eapol_core_c::cancel_authentication_session(): this = 0x%08x => 0x%08x.\n"),
		handler,
		dynamic_cast<abs_eap_base_timer_c *>(handler)));

	EAP_UNREFERENCED_PARAMETER(m_am_tools);

	eap_status_e status = handler->cancel_authentication_session();

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAPOL_KEY_STATE)

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

EAP_FUNC_EXPORT eap_status_e eapol_core_c::cancel_all_authentication_sessions()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("eapol_core_c::cancel_all_authentication_sessions(): this = 0x%08x => 0x%08x.\n"),
		this,
		dynamic_cast<abs_eap_base_timer_c *>(this)));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::cancel_all_authentication_sessions()");

	eap_status_e status(eap_status_ok);


	bool previous_block = m_block_state_notifications;
	m_block_state_notifications = true;

#if !defined(NO_EAP_SESSION_CORE)
	if (m_eap_core != 0)
	{
		status = m_eap_core->synchronous_cancel_all_eap_sessions();
	}
#endif //#if !defined(NO_EAP_SESSION_CORE)


#if defined(USE_EAPOL_KEY_STATE)
	status = m_eapol_key_state_map.for_each(cancel_authentication_session, true);
#endif //#if defined(USE_EAPOL_KEY_STATE)

	m_block_state_notifications = previous_block;


	// This will cancel all timers of this object.
	m_partner->cancel_timer(this, EAPOL_CORE_TIMER_SEND_START_AGAIN_ID);
#if defined(USE_EAPOL_KEY_STATE)
	m_partner->cancel_timer(this, EAPOL_REMOVE_EAPOL_KEY_HANDSHAKE_ID);
#endif //#if defined(USE_EAPOL_KEY_STATE)

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

#if defined(USE_EAPOL_KEY_STATE)

EAP_FUNC_EXPORT eap_status_e eapol_core_c::get_and_increment_global_key_counter(
	eap_variable_data_c * const key_counter)
{
	key_counter->reset();
	return EAP_STATUS_RETURN(m_am_tools, eap_status_not_supported);
}

#endif //#if defined(USE_EAPOL_KEY_STATE)

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

#if defined(USE_EAPOL_KEY_STATE) && defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)
/**
 * Function creates a state for later use. This is for optimazing 4-Way Handshake.
 * @param receive_network_id carries the MAC addresses.
 * MAC address of Authenticator should be in source address. MAC address of 
 * Supplicant should be in destination address.
 * @param authentication_type is the selected authentication type.
 */
EAP_FUNC_EXPORT eap_status_e eapol_core_c::create_state(
	const eap_am_network_id_c * const receive_network_id,
	const eapol_key_authentication_type_e authentication_type
	)
{
	eap_status_e status = eap_status_process_general_error;

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::create_state().\n"),
		 (m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::create_state()");

	if (receive_network_id->get_type() != eapol_ethernet_type_pae)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: eapol_core_c::create_state(): Illegal Ethernet type %d\n"),
			receive_network_id->get_type()));

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_ethernet_type_not_supported);
	}

	// Here we swap the addresses.
	eap_am_network_id_c send_network_id(
		m_am_tools,
		receive_network_id->get_destination_id(),
		receive_network_id->get_source_id(),
		receive_network_id->get_type());
	if (send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_network_id_selector_c state_selector(
		m_am_tools,
		&send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	m_authentication_type = authentication_type;

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("create_state(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));


	eapol_key_state_c *eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

	if (eapol_key_state != 0)
	{
		// Reuse the session.
		eapol_key_state->unset_marked_removed();

		if (m_is_client == false)
		{
			// In test version do not reset server.
		}
		else
		{
			status = eapol_key_state->reset();
			if (status != eap_status_ok)
			{
				// We cannot reuse the session.
				EAP_TRACE_ERROR(
					m_am_tools,
					TRACE_FLAGS_ERROR,
					(EAPL("eapol_core_c::create_state(): eapol_key_state NOT reused.\n")));
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}
		}
	}


	if (eapol_key_state == 0)
	{
		eapol_key_state = new eapol_key_state_c(
			m_am_tools,
			this,
			m_partner,
			m_is_client,
			receive_network_id,
			authentication_type);
		if (eapol_key_state == 0
			|| eapol_key_state->get_is_valid() == false)
		{
			if (eapol_key_state != 0)
			{
				eapol_key_state->shutdown();
			}
			else
			{
				EAP_TRACE_DEBUG(
					m_am_tools, 
					TRACE_FLAGS_DEFAULT, 
					(EAPL("WARNING: eapol_core_c::create_state(): Cannot run eapol_key_state->shutdown() 0x%08x\n"),
					eapol_key_state));
			}
			delete eapol_key_state;
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		status = eapol_key_state->initialize(
			receive_network_id,
			authentication_type);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		status = m_eapol_key_state_map.add_handler(&state_selector, eapol_key_state);
		if (status != eap_status_ok)
		{
			if (eapol_key_state != 0)
			{
				eapol_key_state->shutdown();
			}
			else
			{
				EAP_TRACE_DEBUG(
					m_am_tools, 
					TRACE_FLAGS_DEFAULT, 
					(EAPL("WARNING: eapol_core_c::create_state(): Cannot run eapol_key_state->shutdown() 0x%08x\n"),
					eapol_key_state));
			}
			delete eapol_key_state;
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}
	}
	else
	{
		status = eapol_key_state->initialize(
			receive_network_id,
			authentication_type);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}
	}

	status = eapol_key_state->configure();
	if (status != eap_status_ok)
	{
		status = remove_eapol_key_state(
			&send_network_id);
		if (status != eap_status_ok)
		{
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("WARNING: eapol_core_c::create_state(): ")
				 EAPL("remove_eapol_key_state(), eap_status_e %d\n"),
				status));
		}

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAPOL_KEY_STATE) && defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)

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

#if defined(USE_EAPOL_KEY_STATE)
/**
 * @param receive_network_id carries the MAC addresses.
 * MAC address of Authenticator should be in source address. MAC address of 
 * Supplicant should be in destination address.
 * @param authenticator_RSNA_IE is RSN IE of authenticator. Authenticator 
 * sends this in Beacon or Probe message.
 * @param supplicant_RSNA_IE is RSN IE of supplicant. Supplicant sends 
 * this in (re)association request message.
 * @param eapol_pairwise_cipher is the selected pairwise cipher.
 * @param eapol_group_cipher is the selected group cipher.
 */
EAP_FUNC_EXPORT eap_status_e eapol_core_c::association(
	const eap_am_network_id_c * const receive_network_id,
	const eapol_key_authentication_type_e authentication_type,
	const eap_variable_data_c * const authenticator_RSNA_IE,
	const eap_variable_data_c * const supplicant_RSNA_IE,
	const eapol_RSNA_key_header_c::eapol_RSNA_cipher_e eapol_pairwise_cipher,
	const eapol_RSNA_key_header_c::eapol_RSNA_cipher_e eapol_group_cipher,
	const eap_variable_data_c * const pre_shared_key_PSK
	)
{
	eap_status_e status = eap_status_process_general_error;

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::association().\n"),
		 (m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::association()");

	if (receive_network_id->get_type() != eapol_ethernet_type_pae)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: eapol_core_c::association(): Illegal Ethernet type %d\n"),
			receive_network_id->get_type()));

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_ethernet_type_not_supported);
	}

	// Here we swap the addresses.
	eap_am_network_id_c send_network_id(
		m_am_tools,
		receive_network_id->get_destination_id(),
		receive_network_id->get_source_id(),
		receive_network_id->get_type());
	if (send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_network_id_selector_c state_selector(
		m_am_tools,
		&send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	m_authentication_type = authentication_type;

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("association(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));


	eapol_key_state_c *eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

#if !defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)
	if (eapol_key_state != 0)
	{
		// Reuse the session.
		eapol_key_state->unset_marked_removed();

		if (m_is_client == false)
		{
			// In test version do not reset server.
		}
		else
		{
			status = eapol_key_state->reset();
			if (status != eap_status_ok)
			{
				// We cannot reuse the session.
				EAP_TRACE_ERROR(
					m_am_tools,
					TRACE_FLAGS_ERROR,
					(EAPL("eapol_core_c::association(): eapol_key_state NOT reused.\n")));
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}
		}
	}
#endif //#if !defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)


	if (eapol_key_state == 0)
	{

#if !defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)

		eapol_key_state = new eapol_key_state_c(
			m_am_tools,
			this,
			m_partner,
			m_is_client,
			receive_network_id,
			authentication_type,
			authenticator_RSNA_IE,
			supplicant_RSNA_IE,
			eapol_pairwise_cipher,
			eapol_group_cipher,
			pre_shared_key_PSK);
		if (eapol_key_state == 0
			|| eapol_key_state->get_is_valid() == false)
		{
			if (eapol_key_state != 0)
			{
				eapol_key_state->shutdown();
			}
			else
			{
				EAP_TRACE_DEBUG(
					m_am_tools, 
					TRACE_FLAGS_DEFAULT, 
					(EAPL("WARNING: eapol_core_c::association(): Cannot run eapol_key_state->shutdown() 0x%08x\n"),
					eapol_key_state));
			}
			delete eapol_key_state;
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		status = eapol_key_state->initialize(
			receive_network_id,
			authentication_type,
			authenticator_RSNA_IE,
			supplicant_RSNA_IE,
			eapol_pairwise_cipher,
			eapol_group_cipher,
			pre_shared_key_PSK);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		status = m_eapol_key_state_map.add_handler(&state_selector, eapol_key_state);
		if (status != eap_status_ok)
		{
			if (eapol_key_state != 0)
			{
				eapol_key_state->shutdown();
			}
			else
			{
				EAP_TRACE_DEBUG(
					m_am_tools, 
					TRACE_FLAGS_DEFAULT, 
					(EAPL("WARNING: eapol_core_c::association(): Cannot run eapol_key_state->shutdown() 0x%08x\n"),
					eapol_key_state));
			}
			delete eapol_key_state;
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

#else

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_handler_does_not_exists_error);

#endif //#if !defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)

	}
	else
	{
		status = eapol_key_state->initialize(
			receive_network_id,
			authentication_type,
			authenticator_RSNA_IE,
			supplicant_RSNA_IE,
			eapol_pairwise_cipher,
			eapol_group_cipher,
			pre_shared_key_PSK);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}
	}


#if !defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)
	status = eapol_key_state->configure();
	if (status != eap_status_ok)
	{
		status = remove_eapol_key_state(
			&send_network_id);
		if (status != eap_status_ok)
		{
			EAP_TRACE_DEBUG(
				m_am_tools, 
				TRACE_FLAGS_DEFAULT, 
				(EAPL("WARNING: eapol_core_c::association(): ")
				 EAPL("remove_eapol_key_state(), eap_status_e %d\n"),
				status));
		}

		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}
#endif //#if !defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)


	if (authentication_type == eapol_key_authentication_type_RSNA_PSK
		|| authentication_type == eapol_key_authentication_type_WPA_PSK)
	{

#if !defined(NO_EAPOL_KEY_STATE_SERVER)
		if (m_is_client == false)
		{
#if defined(USE_EAPOL_KEY_STATE)
			if (m_skip_start_4_way_handshake == true)
			{
				// This is test to skip 4-Way Handshake start.
				EAP_TRACE_DEBUG(
					m_am_tools, 
					TRACE_FLAGS_DEFAULT, 
					(EAPL("WARNING: eapol_core_c::association(): ")
					 EAPL("skips start_4_way_handshake()\n")));
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
			}
			else
#endif //#if defined(USE_EAPOL_KEY_STATE)
			{
				status = eapol_key_state->start_4_way_handshake(
					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);
			}
		}
		else
#endif //#if !defined(NO_EAPOL_KEY_STATE_SERVER)
		{
			eapol_key_state->allow_4_way_handshake();
		}
	}
#if defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)
	else if (authentication_type == eapol_key_authentication_type_RSNA_EAP
		|| authentication_type == eapol_key_authentication_type_WPA_EAP
		|| authentication_type == eapol_key_authentication_type_dynamic_WEP
		|| authentication_type == eapol_key_authentication_type_WPXM
		|| authentication_type == eapol_key_authentication_type_WFA_SC
		|| authentication_type == eapol_key_authentication_type_EAP_authentication_no_encryption
		)
	{
		// Creates a EAP-session.
		status = m_eap_core->synchronous_create_eap_session(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);
		}
	}
#endif //#if defined(USE_EAPOL_KEY_STATE_OPTIMIZED_4_WAY_HANDSHAKE)


	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAPOL_KEY_STATE)

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

#if defined(USE_EAPOL_KEY_STATE)
/**
 * @param receive_network_id carries the MAC addresses.
 * MAC address of Authenticator should be in source address.
 * MAC address of Supplicant should be in destination address.
 */
EAP_FUNC_EXPORT eap_status_e eapol_core_c::disassociation(
	const eap_am_network_id_c * const receive_network_id
	)
{
	eap_status_e status = eap_status_process_general_error;

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::disassociation().\n"),
		 (m_is_client == true) ? "client": "server"));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: eapol_core_c::disassociation()");

	if (receive_network_id == 0)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);
	}

	// Here we swap the addresses.
	eap_am_network_id_c send_network_id(
		m_am_tools,
		receive_network_id->get_destination_id(),
		receive_network_id->get_source_id(),
		receive_network_id->get_type());
	if (send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}


	(void) m_partner->cancel_timer(this, EAPOL_CORE_TIMER_SEND_START_AGAIN_ID);

#if !defined(NO_EAP_SESSION_CORE)
	// First we remove possible EAP session.
	(void) m_eap_core->synchronous_remove_eap_session(receive_network_id);
#endif

	status = init_eapol_key_pmksa_caching_timeout(
		&send_network_id);
	if (status != eap_status_ok)
	{
		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("WARNING: eapol_core_c::disassociation(): ")
			 EAPL("init_eapol_key_pmksa_caching_timeout(), eap_status_e %d\n"),
			status));
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	return EAP_STATUS_RETURN(m_am_tools, status);
}

#endif //#if defined(USE_EAPOL_KEY_STATE)

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

/// @see abs_eap_core_c::add_rogue_ap().
EAP_FUNC_EXPORT eap_status_e eapol_core_c::add_rogue_ap(
	eap_array_c<eap_rogue_ap_entry_c> & rogue_ap_list)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::add_rogue_ap().\n"),
		 (m_is_client == true) ? "client": "server"));

	const eap_status_e status = m_partner->add_rogue_ap(rogue_ap_list);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

EAP_FUNC_EXPORT eap_status_e eapol_core_c::tkip_mic_failure(
	const eap_am_network_id_c * const receive_network_id,
	const bool fatal_failure_when_true,
	const eapol_RSNA_key_header_c::eapol_tkip_mic_failure_type_e tkip_mic_failure_type)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools, 
		TRACE_FLAGS_DEFAULT, 
		(EAPL("%s: eapol_core_c::tkip_mic_failure().\n"),
		 (m_is_client == true) ? "client": "server"));

	eap_status_e status = eap_status_process_general_error;

#if defined(USE_EAPOL_KEY_STATE)

	// Here we swap the addresses.
	eap_am_network_id_c send_network_id(
		m_am_tools,
		receive_network_id->get_destination_id(),
		receive_network_id->get_source_id(),
		receive_network_id->get_type());
	if (send_network_id.get_is_valid_data() == false)
	{
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	eap_network_id_selector_c state_selector(
		m_am_tools,
		&send_network_id);

	if (state_selector.get_is_valid() == false)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("tkip_mic_failure(): EAPOL-Key session"),
		state_selector.get_data(state_selector.get_data_length()),
		state_selector.get_data_length()));


	eapol_key_state_c *eapol_key_state = m_eapol_key_state_map.get_handler(&state_selector);

	if (eapol_key_state != 0)
	{
		status = eapol_key_state->tkip_mic_failure(
			fatal_failure_when_true,
			tkip_mic_failure_type);
	}
	else
	{
		status = eap_status_handler_does_not_exists_error;
	}

#else

	status = eap_status_not_supported;

#endif //#if defined(USE_EAPOL_KEY_STATE)

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
EAP_FUNC_EXPORT eap_status_e eapol_core_c::set_session_timeout(
	const u32_t /* session_timeout_ms */)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, eap_status_not_supported);
}

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



// End.
