/*
* Copyright (c) 2001-2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  EAP and WLAN authentication protocols.
*
*/


// This is enumeration of EAPOL source code.
#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)
	#undef EAP_FILE_NUMBER_ENUM
	#define EAP_FILE_NUMBER_ENUM 148 
	#undef EAP_FILE_NUMBER_DATE 
	#define EAP_FILE_NUMBER_DATE 1127594498 
#endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)


// INCLUDE FILES

#include "eap_am_memory.h"

#include "eap_variable_data.h"
#include "eap_tools.h"
#include "eap_type_all.h"

#include "eapol_am_core_symbian.h"
#include "eapol_ethernet_header.h"
#include "ethernet_core.h"
#include "eap_am_tools_symbian.h"
#include <EapolToWlmIf.h>
#include "EapolDbDefaults.h"
#include "EapolDbParameterNames.h"
#include "eap_crypto_api.h"
#include "eap_header_string.h"
#include "eap_am_file_input_symbian.h"
#include "eap_rogue_ap_entry.h"
#include "abs_eap_state_notification.h"
#include "eapol_session_key.h"
#include "eap_buffer.h"
#include "eap_config.h"

#if defined(USE_EAP_FILECONFIG)
	#include "eap_file_config.h"
#endif //#if defined(USE_EAP_FILECONFIG)

#if defined (USE_EAPOL_KEY_STATE) 
	#include "eapol_key_state.h"	
#endif

// LOCAL CONSTANTS
const TUint KMaxSqlQueryLength = 2048;
const TUint KMaxConfigStringLength = 256;
const u32_t KMTU = 1500u;
const u32_t KTrailerLength = 0;
const u32_t KHeaderOffset = 0;
const TUint KMaxEapCueLength = 3;

enum eapol_am_core_timer_id_e
{
	EAPOL_AM_CORE_TIMER_RESTART_AUTHENTICATION_ID,
	EAPOL_AM_CORE_TIMER_DELETE_STACK_ID,
	EAPOL_AM_CORE_TIMER_FAILED_COMPLETELY_ID,
};


const TUint8 TEST_RSN_IE[] =
{
	0xdd, // information element id, 221 expressed as Hex value
	0x14, // length in octets, 20 expressed as Hex value
	0x01, 0x00, // Version 1
	0x00, 0x0f, 0xac, 0x04, // CCMP as group key cipher suite
	0x01, 0x00, // pairwise key cipher suite count
	0x00, 0x0f, 0xac, 0x04, // CCMP as pairwise key cipher suite
	0x01, 0x00, // authentication count
	0x00, 0x0f, 0xac, 0x01, // 802.1X authentication
	0x01, 0x00, // Pre-authentication capabilities
};

// ================= MEMBER FUNCTIONS =======================

eapol_am_core_symbian_c::eapol_am_core_symbian_c(MEapolToWlmIf * const aPartner,
												 const bool is_client_when_true,
												 const TUint aServerIndex)
: CActive(CActive::EPriorityStandard)
, m_partner(aPartner)
, m_ethernet_core(0)
, m_am_tools(0)
, m_enable_random_errors(false)
, m_error_probability(0u)
, m_generate_multiple_error_packets(0u)
, m_authentication_counter(0u)
, m_successful_authentications(0u)
, m_failed_authentications(0u)
, m_is_valid(false)
, m_is_client(is_client_when_true)
, m_eap_index(0u)
, m_index_type(ELan)
, m_index(aServerIndex)
//, m_timer(0)
, m_packet_index(0)
, m_manipulate_ethernet_header(false)
, m_send_original_packet_first(false)
, m_authentication_indication_sent(false)
, m_unicast_wep_key_received(false)
, m_broadcast_wep_key_received(false)
, m_block_packet_sends_and_notifications(false)
, m_success_indication_sent(false)
, m_first_authentication(true)
, m_self_disassociated(false)
, m_802_11_authentication_mode(EAuthModeOpen)
, m_receive_network_id(0)
, m_wpa_override_enabled(false)
, m_wpa_psk_mode_allowed(false)
, m_wpa_psk_mode_active(false)
, m_stack_marked_to_be_deleted(false)
, m_active_type_is_leap(false)
, m_fileconfig(0)
{
}	

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

void eapol_am_core_symbian_c::ConstructL()
{
	if (m_partner == 0)
	{
		User::Leave(KErrGeneral);
	}

	// Create tools class
	m_am_tools = new(ELeave) eap_am_tools_symbian_c(EAP_DEFAULT_TRACE_FILE);
	if (m_am_tools->get_is_valid() != true)
	{
		// The real reason most likely is KErrNoMemory but since that is not sure we'll use KErrGeneral
		User::Leave(KErrGeneral);
	}
	if (m_am_tools->configure() != eap_status_ok)
	{
		User::Leave(KErrGeneral);
	}


	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("EAPOL INITIALISATION\n")));	
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("====================\n")));	

	m_wpa_preshared_key = new (ELeave) eap_variable_data_c(m_am_tools);

	m_ssid = new (ELeave) eap_variable_data_c(m_am_tools);

	m_wpa_psk_password_override = new (ELeave) eap_variable_data_c(m_am_tools);

	// Create/initialise the database
	OpenDatabaseL(m_database, m_session);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("Database initialized...\n")));
	
#if defined(USE_EAP_FILECONFIG)

	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Initialize file configuration.\n")));
			eap_am_file_input_symbian_c fileio(m_am_tools);

		eap_variable_data_c file_name_c_data(m_am_tools);

		eap_status_e status(eap_status_process_general_error);

		{
			eap_const_string const FILECONFIG_FILENAME_C
				= "c:\\system\\data\\eap.conf";

			status = file_name_c_data.set_copy_of_buffer(
				FILECONFIG_FILENAME_C,
				m_am_tools->strlen(FILECONFIG_FILENAME_C));
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
			}

			status = file_name_c_data.add_end_null();
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
			}
		}

		eap_variable_data_c file_name_z_data(m_am_tools);

		{
			eap_const_string const FILECONFIG_FILENAME_Z
				= "z:\\private\\101F8EC5\\eap.conf";

			status = file_name_z_data.set_copy_of_buffer(
				FILECONFIG_FILENAME_Z,
				m_am_tools->strlen(FILECONFIG_FILENAME_Z));
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
			}

			status = file_name_z_data.add_end_null();
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
			}
		}

		if (status == eap_status_ok)
		{
			// First try open from C: disk.
			status = fileio.file_open(
				&file_name_c_data,
				eap_file_io_direction_read);
			if (status == eap_status_ok)
			{
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("Opens configure file %s\n"),
					file_name_c_data.get_data(file_name_c_data.get_data_length())));
			}
			else if (status != eap_status_ok)
			{
				// Second try open from Z: disk.
				status = fileio.file_open(
					&file_name_z_data,
					eap_file_io_direction_read);
				if (status == eap_status_ok)
				{
					EAP_TRACE_DEBUG(
						m_am_tools,
						TRACE_FLAGS_DEFAULT,
						(EAPL("Opens configure file %s\n"),
						 file_name_z_data.get_data(file_name_z_data.get_data_length())));
				}
			}

			if (status == eap_status_ok)
			{
				// Some of the files were opened.

				m_fileconfig = new eap_file_config_c(m_am_tools);
				if (m_fileconfig != 0
					&& m_fileconfig->get_is_valid() == true)
				{
					status = m_fileconfig->configure(&fileio);
					if (status != eap_status_ok)
					{
						EAP_TRACE_DEBUG(
							m_am_tools,
							TRACE_FLAGS_DEFAULT,
							(EAPL("ERROR: Configure read from %s failed.\n"),
							file_name_c_data.get_data(file_name_c_data.get_data_length())));
					}
					else
					{
						EAP_TRACE_DEBUG(
							m_am_tools,
							TRACE_FLAGS_DEFAULT,
							(EAPL("Configure read from %s\n"),
							file_name_c_data.get_data(file_name_c_data.get_data_length())));
					}
				}
				else
				{
					// No file configuration.
					delete m_fileconfig;
					m_fileconfig = 0;

					EAP_TRACE_DEBUG(
						m_am_tools,
						TRACE_FLAGS_DEFAULT,
						(EAPL("ERROR: Cannot create configure object for file %s\n"),
						file_name_c_data.get_data(file_name_c_data.get_data_length())));
				}
			}
			else
			{
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("ERROR: Cannot open configure file neither %s nor %s\n"),
					file_name_c_data.get_data(file_name_c_data.get_data_length()),
					file_name_z_data.get_data(file_name_z_data.get_data_length())));
			}
		}
	}

#endif //#if defined(USE_EAP_FILECONFIG)

#if !defined(USE_EAP_HARDWARE_TRACE)
	{
		// Disable traces.
		m_am_tools->set_trace_mask(eap_am_tools_c::eap_trace_mask_none);

		eap_variable_data_c trace_output_file(m_am_tools);

		eap_status_e status = read_configure(
			cf_str_EAP_TRACE_output_file_name.get_field(),
			&trace_output_file);
		if (status == eap_status_ok
			&& trace_output_file.get_is_valid_data() == true)
		{
			status = m_am_tools->set_trace_file_name(&trace_output_file);
			if (status == eap_status_ok)
			{
				// OK, set the default trace mask.
				m_am_tools->set_trace_mask(
					eap_am_tools_c::eap_trace_mask_debug
					| eap_am_tools_c::eap_trace_mask_always
					| eap_am_tools_c::eap_trace_mask_error);
			}
		}
	}
#endif //#if defined(USE_EAP_HARDWARE_TRACE)


	{
		eap_status_e status = configure();
		if (status != eap_status_ok)
		{
			User::Leave(KErrGeneral);
			User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
		}
	}
	
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("Configured EAPOL AM...\n")));

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("Created timer...\n")));

	// SERVER TEST CODE
	if (m_is_client == false)
	{
		TRAPD(err, ReadEAPSettingsL());
		if (err != KErrNone)
		{
			// Setting reading from CommDB failed. Use default values instead (only EAP-SIM).
			
			// SIM
			_LIT(KSIM, "18");
			TEap* sim = new(ELeave) TEap;
			CleanupStack::PushL(sim);
			sim->Enabled = ETrue;
			sim->UID.Copy(KSIM);		
			User::LeaveIfError(m_iap_eap_array.Append(sim));
			CleanupStack::Pop(sim);
		}

	}

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("========================\n")));

	set_is_valid();

}


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

eapol_am_core_symbian_c* eapol_am_core_symbian_c::NewL(MEapolToWlmIf * const aPartner,
												  const bool aIsClient,
												  const TUint aServerIndex)
{
	eapol_am_core_symbian_c* self = new(ELeave) eapol_am_core_symbian_c(aPartner, aIsClient, aServerIndex);
	CleanupStack::PushL(self);
	self->ConstructL();

	if (self->get_is_valid() != true)
	{
		User::Leave(KErrGeneral);
	}

	CleanupStack::Pop();
	return self;
}

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

eapol_am_core_symbian_c::~eapol_am_core_symbian_c()
{

#if defined(USE_EAP_FILECONFIG)
	delete m_fileconfig;
	m_fileconfig = 0;
#endif //#if defined(USE_EAP_FILECONFIG)

	shutdown();
}

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

//
eap_status_e eapol_am_core_symbian_c::shutdown()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);
	
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::shutdown()\n")));

	// Cancel timer	
	cancel_all_timers();

	// Delete upper stack if it still exists
	if (m_ethernet_core != 0)
	{
		m_ethernet_core->shutdown();
		delete m_ethernet_core;
	}
	
	delete m_wpa_preshared_key;
	
	delete m_ssid;

	delete m_wpa_psk_password_override;

	delete m_receive_network_id;

	m_database.Close();
	m_session.Close();

	// Print some statistics
	if (m_is_client)
	{
		EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_ALWAYS|TRACE_TEST_VECTORS,
			(EAPL("client authentication SUCCESS %d, FAILED %d, count %d\n"),
			m_successful_authentications,
			m_failed_authentications,
			m_authentication_counter));	
	}
	else
	{
		EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_ALWAYS|TRACE_TEST_VECTORS,
			(EAPL("server authentication SUCCESS %d, FAILED %d, count %d\n"),
			m_successful_authentications,
			m_failed_authentications,
			m_authentication_counter));
	}	
	
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("EAPOL EXITING.\n")));
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	

	// Finally delete tools. No logging is allowed after this.
	if (m_am_tools != 0)
	{
		m_am_tools->shutdown();
		delete m_am_tools;
	}


	// Unload all loaded plugins
	// NOTE this must be after the m_am_tools->shutdown() call.
	// m_am_tools->shutdown() will run virtual functions of some plugins.
	for(int i = 0; i < m_plugin_if_array.Count(); i++)
	{
		delete m_plugin_if_array[i];
	}

	m_plugin_if_array.Close();
	m_eap_type_array.Close();

	// Delete the IAP EAP type info array
	m_iap_eap_array.ResetAndDestroy();
	

	return eap_status_ok;
}

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

//
void eapol_am_core_symbian_c::RunL()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::RunL(): iStatus.Int() = %d\n"),
		iStatus.Int()));

	if (iStatus.Int() != KErrNone)
	{
		return;
	}

	// Authentication cancelled.
	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
		(EAPL("Authentication cancelled.\n")));

	// Set block on.
	m_block_packet_sends_and_notifications = true;

	// Reset flags
	m_success_indication_sent = false;
	m_unicast_wep_key_received = false;
	m_broadcast_wep_key_received = false;
	m_authentication_indication_sent = false;

	m_stack_marked_to_be_deleted = true;
	set_timer(this, EAPOL_AM_CORE_TIMER_DELETE_STACK_ID, 0, 0);
	
	// reset index
	m_eap_index = 0;

	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
		(EAPL("Indication sent to WLM: EFailedCompletely.\n")));

	m_partner->EapIndication(EFailedCompletely);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
}

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

//
void eapol_am_core_symbian_c::DoCancel()
{	
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::DoCancel()\n")));

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
}

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

//
TInt eapol_am_core_symbian_c::Start(const TIndexType aIndexType, 
									const TUint aIndex, 
									const TSSID& aSSID, 
									const TBool aWPAOverrideEnabled,
									const TUint8* aWPAPSK,
									const TUint aWPAPSKLength)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::Start()\n")));

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("STARTING AUTHENTICATION.\n")));

	eap_status_e status(eap_status_ok);

	if (m_ethernet_core != 0)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Deleting previously used stack.\n")));

		// It is an error to call start without calling disassociated
		if (m_stack_marked_to_be_deleted == false)
		{	
			EAP_TRACE_ERROR(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("eapol_am_core_symbian_c::Start called twice!\n")));
			return KErrAlreadyExists;
		}

		// The previously used stack is perhaps still waiting for deletion.
		cancel_timer(this, EAPOL_AM_CORE_TIMER_DELETE_STACK_ID);
	
		// Delete stack
		m_ethernet_core->shutdown();
		delete m_ethernet_core;
		m_ethernet_core = 0;				
		
		m_stack_marked_to_be_deleted = false;
	}

	// Clear packet send and notification blocking.
	m_block_packet_sends_and_notifications = false;

	// Store SSID. This is needed for WPA PSK calculation.
	if (aSSID.ssidLength > 0)
	{		
		status = m_ssid->set_copy_of_buffer(aSSID.ssid, aSSID.ssidLength);
		if (status != eap_status_ok)
		{
			return m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status));
		}
	}
	
	// Store WPAPSK. This is needed for WPA PSK mode in Easy WLAN.
	if (aWPAPSKLength > 0
		&& aWPAPSK != 0)
	{		
		status = m_wpa_psk_password_override->set_copy_of_buffer(aWPAPSK, aWPAPSKLength);
		if (status != eap_status_ok)
		{
			return m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status));
		}
	}		

	if (aWPAOverrideEnabled)
	{
		m_wpa_override_enabled = true;
	}
	else
	{
		m_wpa_override_enabled = false;
	}
	
	///////////////////////////////////
	// Get EAP parameters from CommDbIf
	///////////////////////////////////
	m_index_type = aIndexType;
	m_index = aIndex;

	TRAPD(err, ReadEAPSettingsL());
	if (err != KErrNone)
	{
		EAP_TRACE_ERROR(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("EAP settings reading from CommDb failed or cancelled(err %d).\n"), err));
		m_partner->EapIndication(EFailedCompletely);
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
		return err;
	}

	// Start new authentication from scratch.
	m_unicast_wep_key_received = false;
	m_broadcast_wep_key_received = false;
	m_wpa_psk_mode_active = false;
	
	if (m_wpa_psk_mode_allowed == false
		|| m_wpa_preshared_key->get_data_length() == 0)
	{
		// Check the first enabled type
		TEap* eapType = 0;
		TInt i(0);
		for (i = 0; i < m_iap_eap_array.Count(); i++)
		{
			// Check if type is enabled
			eapType = m_iap_eap_array[i];
			if (eapType->Enabled == 1)
			{	
				break;
			}
		}
		if (i >= m_iap_eap_array.Count())
		{
			// No enabled EAP types.
			EAP_TRACE_ALWAYS(
				m_am_tools,
				TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
				(EAPL("No enabled EAP types.\n")));
			EAP_TRACE_ALWAYS(
				m_am_tools,
				TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
				(EAPL("Indication sent to WLM: EFailedCompletely.\n")));

			m_partner->EapIndication(EFailedCompletely);
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
			return KErrNone; 
		}	

		// reset index (start from the first enabled EAP type)
		m_eap_index = i;

		// Check if the first enabled type is LEAP.
		TLex8 tmp(eapType->UID);
		TInt type(0);
		tmp.Val(type);
		
		switch (type)
		{
		case eap_type_leap:
			if (m_security_mode != Wpa
				&& m_security_mode != Wpa2Only)
			{
				m_802_11_authentication_mode = EAuthModeLeap;

				EAP_TRACE_ALWAYS(
					m_am_tools,
					TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT, 
					(EAPL("Start: Trying auth mode LEAP.\n")));
			}
			else
			{
				// If security mode is WPA or WPA2 then even LEAP uses open authentication!
				m_802_11_authentication_mode = EAuthModeOpen;

				EAP_TRACE_ALWAYS(
					m_am_tools,
					TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT, 
					(EAPL("Start: Trying auth mode OPEN (LEAP in WPA mode).\n")));
			}

			m_active_type_is_leap = true;
			break;
		default:
			m_802_11_authentication_mode = EAuthModeOpen;

			EAP_TRACE_ALWAYS(
				m_am_tools,
				TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT, 
				(EAPL("Start: Trying auth mode OPEN.\n")));

			m_active_type_is_leap = false;
			break;
		}
	}
	else
	{
		// WPA Pre-shared key mode
		m_active_type_is_leap = false;
		m_wpa_psk_mode_active = true;
		m_802_11_authentication_mode = EAuthModeOpen;

		EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT, 
			(EAPL("Start: Trying auth mode OPEN.\n")));
	}
		
	// Ignore return value. Result comes with CompleteAssociation call.
	m_partner->Associate(m_802_11_authentication_mode);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
	return m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status));
}

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

//
TInt eapol_am_core_symbian_c::CompleteAssociation(
		const TInt aResult,
		const TMacAddress& aLocalAddress, 
		const TMacAddress& aRemoteAddress,
		const TUint8* const aReceivedWPAIE, // WLM must give only the WPA IE to EAPOL									        
		const TUint aReceivedWPAIELength,
		const TUint8* const aSentWPAIE,
		const TUint aSentWPAIELength,
		const TWPACipherSuite aGroupKeyCipherSuite,
		const TWPACipherSuite aPairwiseKeyCipherSuite
		)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	

	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::CompleteAssociation(): aResult %d\n"),
		aResult));

	eap_status_e status(eap_status_ok);

	// ASSOCIATION UNSUCCESSFUL
	if (aResult != KErrNone)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("CompleteAssociation: Unsuccessful.\n")));

		EAP_TRACE_DATA_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("Got AP MAC address"),
			aRemoteAddress.iMacAddress,
			KMacAddressLength));

		// Report rogue AP if we tried LEAP and it failed
		if (m_802_11_authentication_mode == EAuthModeLeap)
		{
			// Only add rogue AP if the error code is correct
			if (aResult == E802Dot11StatusAuthAlgorithmNotSupported)
			{
				eap_rogue_ap_entry_c rogue_entry(m_am_tools);
			
				rogue_entry.set_mac_address(static_cast<const u8_t *>(aRemoteAddress.iMacAddress));
				rogue_entry.set_rogue_reason(rogue_ap_association_failed);

				eap_array_c<eap_rogue_ap_entry_c> rogue_list(m_am_tools);
				status = rogue_list.add_object(&rogue_entry, false);
				if (status == eap_status_ok)
				{	
					status = add_rogue_ap(rogue_list);
					// Ignore return value on purpose - it's not fatal if this fails
				}
			}			
		}

		if (m_wpa_psk_mode_active == false)
		{
			if (aResult == E802Dot11StatusAuthAlgorithmNotSupported
				&& m_security_mode != Wpa
				&& m_security_mode != Wpa2Only) // If security mode is WPA or WPA2 then only OPEN auth should be used
			{
				// Association failed because we had wrong authentication type. 
				// Try to find next allowed type that uses different authentication type
				m_eap_index++;

				TEap* eapType;
				TBool found(EFalse);
				TInt i(0);
				for (i = m_eap_index; i < m_iap_eap_array.Count(); i++)
				{
					// Check if type is enabled
					eapType = m_iap_eap_array[i];
					if (eapType->Enabled == 1)
					{	
						TLex8 tmp(eapType->UID);
						TInt type(0);
						tmp.Val(type);
						
						switch (type)
						{
						case eap_type_leap:
							if (m_802_11_authentication_mode != EAuthModeLeap)
							{
								// This type will do; it uses different authentication mode.
								EAP_TRACE_ALWAYS(
									m_am_tools,
									TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT, 
									(EAPL("CompleteAssociation: Changed auth mode to LEAP.\n")));

								m_802_11_authentication_mode = EAuthModeLeap;
								m_active_type_is_leap = true;
								found = ETrue;
							}					
							break;
						default:
							if (m_802_11_authentication_mode != EAuthModeOpen)
							{
								// This type will do; it uses different authentication mode.
								EAP_TRACE_ALWAYS(
									m_am_tools,
									TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT, 
									(EAPL("CompleteAssociation: Changed auth mode to OPEN.\n")));

								m_802_11_authentication_mode = EAuthModeOpen;	
								m_active_type_is_leap = false;
								found = ETrue;
							}
							break;
						}				
						if (found)
						{
							break;
						}
					}
				}

				m_eap_index = i;

				if (i >= m_iap_eap_array.Count())
				{
					// All the remaining allowed types had the same authentication mode.
					// Give up this AP.
					EAP_TRACE_ALWAYS(
						m_am_tools,
						TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT, 
						(EAPL("Could not associate to the AP. Tried all types.\n")));

					EAP_TRACE_ALWAYS(
						m_am_tools,
						TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
						(EAPL("Indication sent to WLM: EThisAPFailed.\n")));

					m_partner->EapIndication(EThisAPFailed);
					return KErrNone;

				}

				// We found a type with different authentication mode. Try it.			
			
				// Ignore return value. Result comes with CompleteAssociation call.
				m_partner->Associate(m_802_11_authentication_mode);
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
				return KErrNone;
			}
			else
			{
				EAP_TRACE_ALWAYS(
					m_am_tools,
					TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT, 
					(EAPL("Could not associate to the AP (error %d).\n"), aResult));

				EAP_TRACE_ALWAYS(
					m_am_tools,
					TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
					(EAPL("Indication sent to WLM: EThisAPFailed.\n")));

				m_partner->EapIndication(EThisAPFailed);
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
				return KErrNone;
			}
		}
		else
		{
			EAP_TRACE_ALWAYS(
				m_am_tools,
				TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT, 
				(EAPL("Could not associate to the AP with WPA pre-shared-key.\n")));

			EAP_TRACE_ALWAYS(
				m_am_tools,
				TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
				(EAPL("Indication sent to WLM: EThisAPFailed.\n")));

			m_partner->EapIndication(EThisAPFailed);
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
			return KErrNone;
		}					
	}
	
	// ASSOCIATION SUCCESSFUL
	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
		(EAPL("CompleteAssociation: Successful.\n")));

	// Store parameters
	m_local_address = aLocalAddress;

	m_remote_address = aRemoteAddress;

	m_received_wpa_ie = aReceivedWPAIE;

	m_received_wpa_ie_length = aReceivedWPAIELength;

	m_sent_wpa_ie = aSentWPAIE;

	m_sent_wpa_ie_length = aSentWPAIELength;

	m_group_key_cipher_suite = aGroupKeyCipherSuite;

	m_pairwise_key_cipher_suite = aPairwiseKeyCipherSuite;

	// Create stack if it does not already exist. 
	status = create_upper_stack();
	if (status != eap_status_ok
		&& status != eap_status_already_exists)
	{
		EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
			(EAPL("Indication sent to WLM: EFailedCompletely.\n")));

		m_partner->EapIndication(EFailedCompletely);
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
		return KErrNone; 
	}

	// First create stack object and then copy it to heap object. This is because 
	// eap_am_network_id_c does not have a constructor that copies the buffers.
	eap_am_network_id_c receive_network_id(
			m_am_tools,
			&aRemoteAddress,
			sizeof(TMacAddress),
			&aLocalAddress,
			sizeof(TMacAddress),
			eapol_ethernet_type_pae,
			false,
			false);
	
	delete m_receive_network_id;
	m_receive_network_id = new eap_am_network_id_c(
		m_am_tools);

	if (m_receive_network_id == 0)
	{
		EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
			(EAPL("Indication sent to WLM: EFailedCompletely.\n")));

		m_partner->EapIndication(EFailedCompletely);
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
		return KErrNone; 
	}
	
	status = m_receive_network_id->set_copy_of_network_id(&receive_network_id);
	if (status != eap_status_ok)
	{
		EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
			(EAPL("Indication sent to WLM: EFailedCompletely.\n")));

		m_partner->EapIndication(EFailedCompletely);
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
		return KErrNone; 
	}

	
#if defined (USE_EAPOL_KEY_STATE) 

	// Initialise EAPOL key state

	eapol_key_authentication_type_e authentication_type(eapol_key_authentication_type_802_1X);
	
	if (aReceivedWPAIE !=0 
		&& aSentWPAIE != 0)
	{
		// WPA (in wpa or 802.1x security mode)
		if (m_wpa_psk_mode_allowed == false)
		{
			authentication_type = eapol_key_authentication_type_WPA_EAP;
		}
		else
		{
			m_wpa_psk_mode_active = true;
			authentication_type = eapol_key_authentication_type_WPA_PSK;
		}

	}
	else
	{
		// Non-wpa mode
		authentication_type = eapol_key_authentication_type_802_1X;
	}	

	eap_variable_data_c	authenticator_RSNA_IE(m_am_tools);
	eap_variable_data_c	supplicant_RSNA_IE(m_am_tools);

	// Note: the default values here are only for 802.1x mode. In that mode
	// we don't know the WEP key length beforehand so we will have to guess.
	// It does not matter in this case if we guess wrong - only thing that matters
	// is that it is WEP.
	eapol_RSNA_key_header_c::eapol_RSNA_cipher_e 
		eapol_pairwise_cipher(eapol_RSNA_key_header_c::eapol_RSNA_cipher_WEP_40);
	eapol_RSNA_key_header_c::eapol_RSNA_cipher_e 
		eapol_group_cipher(eapol_RSNA_key_header_c::eapol_RSNA_cipher_WEP_40);	
	
	// WPA mode is active if information elements are valid
	if (aReceivedWPAIE != 0
		&& aSentWPAIE != 0)
	{
		status = authenticator_RSNA_IE.set_copy_of_buffer(aReceivedWPAIE, aReceivedWPAIELength);
		if (status != eap_status_ok)
		{
			EAP_TRACE_ALWAYS(
				m_am_tools,
				TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
				(EAPL("Indication sent to WLM: EFailedCompletely.\n")));

			m_partner->EapIndication(EFailedCompletely);
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
			return KErrNoMemory;
		}
		status = supplicant_RSNA_IE.set_copy_of_buffer(aSentWPAIE, aSentWPAIELength);
		if (status != eap_status_ok)
		{
			EAP_TRACE_ALWAYS(
				m_am_tools,
				TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
				(EAPL("Indication sent to WLM: EFailedCompletely.\n")));

			m_partner->EapIndication(EFailedCompletely);
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
			return KErrNoMemory;
		}
		
		switch (aGroupKeyCipherSuite)
		{
		case ENoCipherSuite:
			eapol_group_cipher = eapol_RSNA_key_header_c::eapol_RSNA_cipher_none;
			break;
		case EWEP40:
			eapol_group_cipher = eapol_RSNA_key_header_c::eapol_RSNA_cipher_WEP_40;							 
			break;
		case EWEP104:
			eapol_group_cipher = eapol_RSNA_key_header_c::eapol_RSNA_cipher_WEP_104;
			break;
		case ETKIP:
			eapol_group_cipher = eapol_RSNA_key_header_c::eapol_RSNA_cipher_TKIP;
			break;
		case ECCMP:
			eapol_group_cipher = eapol_RSNA_key_header_c::eapol_RSNA_cipher_CCMP;
			break;
		case EWRAP:
		default:
			User::Panic(_L("EAPOL"), KErrNotSupported);							
		}

		switch (aPairwiseKeyCipherSuite)
		{
		case ENoCipherSuite:
			eapol_pairwise_cipher = eapol_RSNA_key_header_c::eapol_RSNA_cipher_none;
			break;
		case EWEP40:
			eapol_pairwise_cipher = eapol_RSNA_key_header_c::eapol_RSNA_cipher_WEP_40;							 
			break;
		case EWEP104:
			eapol_pairwise_cipher = eapol_RSNA_key_header_c::eapol_RSNA_cipher_WEP_104;
			break;
		case ETKIP:
			eapol_pairwise_cipher = eapol_RSNA_key_header_c::eapol_RSNA_cipher_TKIP;
			break;
		case ECCMP:
			eapol_pairwise_cipher = eapol_RSNA_key_header_c::eapol_RSNA_cipher_CCMP;
			break;
		case EWRAP:
		default:
			User::Panic(_L("EAPOL"), KErrNotSupported);							
		}
	} 

	if (authentication_type == eapol_key_authentication_type_WPA_PSK)
	{
		status = m_ethernet_core->association(
			m_receive_network_id,
			authentication_type,
			&authenticator_RSNA_IE,
			&supplicant_RSNA_IE,
			eapol_pairwise_cipher,
			eapol_group_cipher,
			m_wpa_preshared_key);
	}
	else
	{
		status = m_ethernet_core->association(
			m_receive_network_id,
			authentication_type,
			&authenticator_RSNA_IE,
			&supplicant_RSNA_IE,
			eapol_pairwise_cipher,
			eapol_group_cipher,
			0);
	}
	if (status != eap_status_ok)
	{

		EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
			(EAPL("m_ethernet_core->association call failed.\n")));

		EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
			(EAPL("Indication sent to WLM: EFailedCompletely.\n")));

		m_partner->EapIndication(EFailedCompletely);
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
		return KErrGeneral;
	}

#endif // USE_EAPOL_KEY_STATE

	if (m_wpa_psk_mode_active == false)
	{
		// Start authentication if mode is not pre-shared key. If mode is pre-shared key then
		// just wait for EAPOL-Key frames.
		status = m_ethernet_core->start_authentication(m_receive_network_id, m_is_client);		
	}
	
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
	return m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status));
}

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

//
TInt eapol_am_core_symbian_c::ReceivePacket(const TUint aLength, const TUint8* const aPacket)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	
		
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::ReceivePacket()\n")));

	if (aLength < eapol_ethernet_header_wr_c::get_header_length())
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, eap_status_too_short_message));
	}

	eapol_ethernet_header_wr_c eth_header(m_am_tools, aPacket, aLength);
	eap_am_network_id_c receive_network_id(
			m_am_tools,
			eth_header.get_source(),
			eth_header.get_source_length(),
			eth_header.get_destination(),
			eth_header.get_destination_length(),
			eth_header.get_type(),
			false,
			false);
	eap_status_e status(eap_status_process_general_error);
	if (eth_header.get_type() == eapol_ethernet_type_pae)
	{
		status = create_upper_stack();
		if (status != eap_status_ok 
			&& status != eap_status_already_exists)
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("Indication sent to WLM: EFailedCompletely.\n")));
			m_partner->EapIndication(EFailedCompletely);
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
			return KErrNone; 
		} 

#if defined (USE_EAPOL_KEY_STATE) 
		if (m_is_client == false
			&& status != eap_status_already_exists)
		{
			// If we are server we need to do associate here.
			eapol_key_authentication_type_e authentication_type(
				eapol_key_authentication_type_WPA_EAP);

			eap_variable_data_c authenticator_RSNA_IE(m_am_tools);
			eap_variable_data_c supplicant_RSNA_IE(m_am_tools);

			status = authenticator_RSNA_IE.set_buffer(TEST_RSN_IE, sizeof(TEST_RSN_IE), false, false);
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
			}

			status = supplicant_RSNA_IE.set_buffer(TEST_RSN_IE, sizeof(TEST_RSN_IE), false, false);
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
			}
						
			eapol_RSNA_key_header_c::eapol_RSNA_cipher_e 
				eapol_pairwise_cipher(eapol_RSNA_key_header_c::eapol_RSNA_cipher_TKIP);	
			eapol_RSNA_key_header_c::eapol_RSNA_cipher_e 
				eapol_group_cipher(eapol_RSNA_key_header_c::eapol_RSNA_cipher_TKIP);	
			
				
			if (authentication_type == eapol_key_authentication_type_WPA_PSK)
			{
				status = m_ethernet_core->association(
					&receive_network_id,
					authentication_type,
					&authenticator_RSNA_IE,
					&supplicant_RSNA_IE,
					eapol_pairwise_cipher,
					eapol_group_cipher,
					m_wpa_preshared_key);
			}
			else
			{
				status = m_ethernet_core->association(
					&receive_network_id,
					authentication_type,
					&authenticator_RSNA_IE,
					&supplicant_RSNA_IE,
					eapol_pairwise_cipher,
					eapol_group_cipher,
					0);
			}

		}
#endif // USE_EAPOL_KEY_STATE

		// Forward the packet to the Ethernet layer of the EAPOL stack. Ignore return value. Failure is signalled using state_notification.
		status = m_ethernet_core->packet_process(
			&receive_network_id,
			&eth_header,
			aLength);
		
	} 
	else
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Not supported ethernet type 0x%04x\n"), eth_header.get_type()));
		status = eap_status_ethernet_type_not_supported;
	}
	
	status = eap_status_ok;

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status));
}

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

void eapol_am_core_symbian_c::set_is_valid()
{
	m_is_valid = true;
}

bool eapol_am_core_symbian_c::get_is_valid()
{
	return m_is_valid;
}

void eapol_am_core_symbian_c::increment_authentication_counter()
{
	++m_authentication_counter;
}

u32_t eapol_am_core_symbian_c::get_authentication_counter()
{
	return m_authentication_counter;
}

bool eapol_am_core_symbian_c::get_is_client()
{
	return m_is_client;
}
	

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

//
eap_status_e eapol_am_core_symbian_c::packet_data_crypto_keys(
	const eap_am_network_id_c * const /*send_network_id*/,
	const eap_variable_data_c * const /*master_session_key*/)
{
	// Not needed in Symbian version
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return eap_status_ok;
}

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

eap_status_e eapol_am_core_symbian_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);
	TInt status(KErrNone);

	const eap_variable_data_c * const key_data = key->get_key();
	if (key_data == 0)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return eap_status_key_error;
	}

	EAP_TRACE_DEBUG(m_am_tools,
		TRACE_FLAGS_DEFAULT, 
		(EAPL("packet_data_session_key: index: %d, type %d\n"),
		key->get_key_index(),
		key->get_key_type()));
	
	EAP_TRACE_DATA_DEBUG(m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("packet_data_session_key:"),
		key_data->get_data(key_data->get_data_length()),
		key_data->get_data_length()));
	
	switch (key->get_key_type())
	{
	case eapol_key_type_broadcast:
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT, 
			(EAPL("eapol_am_core_symbian_c::packet_data_session_key: Got rc4_broadcast key.\n")));

		status = m_partner->SetCipherKey(
			ERC4Broadcast,
			static_cast<TUint8> (key->get_key_index()),
			key_data->get_data(key_data->get_data_length()),
			key_data->get_data_length());
		m_broadcast_wep_key_received = true;
		break;
	case eapol_key_type_unicast:
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT, 
			(EAPL("eapol_am_core_symbian_c::packet_data_session_key: Got rc4_unicast key.\n")));

		status = m_partner->SetCipherKey(
			ERC4Unicast,
			static_cast<TUint8> (key->get_key_index()),
			key_data->get_data(key_data->get_data_length()),
			key_data->get_data_length());
		m_unicast_wep_key_received = true;
		break;
	default:
		EAP_TRACE_ERROR(
			m_am_tools,
			TRACE_FLAGS_DEFAULT, 
			(EAPL("eapol_am_core_symbian_c::packet_data_session_key: Got unsupported key, type %d.\n"),
			key->get_key_type()));
		status = KErrNotSupported;
		break;
	}

	if (m_unicast_wep_key_received == true 
		&& m_broadcast_wep_key_received == true
		&& m_success_indication_sent == false)
	{
		// Signal success because we have received one unicast (pairwise) key and one broadcast (group) key.
		// If there are more keys coming later they are saved also.
		if (m_active_type_is_leap == true)
		{
			// Leap was successful
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("Indication sent to WLM: ELeapSuccess.\n")));
			m_partner->EapIndication(ELeapSuccess);
		}
		else
		{
			// some other type was successful
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("Indication sent to WLM: ESuccess.\n")));
			m_partner->EapIndication(ESuccess);
		}
		
		m_success_indication_sent = true;
		m_first_authentication = false;
	}
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, m_am_tools->convert_am_error_to_eapol_error(status));
}

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

//

eap_status_e eapol_am_core_symbian_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_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::packet_send(data_length=%d).\n"),
		data_length));

	if (header_offset != 0u)
	{
		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_process_general_error;
	}
	else if (header_offset+data_length != sent_packet->get_data_length())
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("ERROR: packet_send: packet buffer corrupted (data_length != sent_packet->get_data_length()).\n")));
		EAP_ASSERT(data_length == sent_packet->get_buffer_length());
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return eap_status_process_general_error;
	}	

	if (m_block_packet_sends_and_notifications == true)
	{
		// Packet sending block is active. This happens when disassociated has been called.  
		// start_authentication clears the block.
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("packet_send: packet ignored because Disassociated() was called.\n")));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return eap_status_ok;
	}

	TInt status(KErrNone);
	if (m_send_original_packet_first == true)
	{
		if (m_enable_random_errors == true)
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("TEST: random_error(): packet_index 0x%08x:%lu, Send original packet\n"),
				this,
				m_packet_index));
		}

		u8_t * const packet_data = sent_packet->get_data_offset(header_offset, data_length);
		if (packet_data == 0)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return eap_status_buffer_too_short;
		}

		// Here we send the original packet.
		status = m_partner->EapPacketSend(
			data_length, 
			static_cast<TUint8*>(packet_data));
		++m_packet_index;
	}

	if (m_enable_random_errors == true
		&& status == KErrNone)
	{
		if (m_generate_multiple_error_packets > 0ul)
		{
			// First create a copy of sent packet. Original correct packet will will be sent last.
			for (u32_t ind = 0ul; ind < m_generate_multiple_error_packets; ind++)
			{
				eap_buf_chain_wr_c *copy_packet = sent_packet->copy();

				if (copy_packet != 0
					&& copy_packet->get_is_valid_data() == true)
				{
					// Make a random error to the copy message.
					random_error(copy_packet, true, m_packet_index);

					EAP_TRACE_DEBUG(
						m_am_tools,
						TRACE_FLAGS_DEFAULT,
						(EAPL("TEST: random_error(): packet_index 0x%08x:%lu, Send error packet\n"),
						this,
						m_packet_index));
					
					u8_t * const packet_data = copy_packet->get_data_offset(header_offset, data_length);
					if (packet_data == 0)
					{
						EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
						return eap_status_buffer_too_short;
					}

					// Here we send the copied and manipulated packet.
					status = m_partner->EapPacketSend(
						data_length, 
						static_cast<TUint8*>(packet_data));
					
					++m_packet_index;
				}
				delete copy_packet;
			}
		}
		else
		{
			// Make a random error to the original message.
			random_error(sent_packet, false, m_packet_index);

			if (sent_packet->get_is_manipulated() == true)
			{
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("TEST: random_error(): packet_index 0x%08x:%lu, Send error packet\n"),
					this,
					m_packet_index));
			}
		}
	}


	if (m_send_original_packet_first == false
		&& status == KErrNone)
	{
		if (m_enable_random_errors == true)
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("TEST: random_error(): packet_index 0x%08x:%lu, Send original packet\n"),
				this,
				m_packet_index));
		}

		u8_t * const packet_data = sent_packet->get_data_offset(header_offset, data_length);
		if (packet_data == 0)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return eap_status_buffer_too_short;
		}

		// Here we send the original packet.
		status = m_partner->EapPacketSend(
			data_length,
			static_cast<TUint8*>(packet_data));
		++m_packet_index;
	}
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

	return EAP_STATUS_RETURN(m_am_tools, m_am_tools->convert_am_error_to_eapol_error(status));
}

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

//
eap_status_e eapol_am_core_symbian_c::reassociate(
		const eap_am_network_id_c * const /* send_network_id */,
		const eapol_key_authentication_type_e /* authentication_type */,
		const eap_variable_data_c * const /* PMKID */,
		const eap_variable_data_c * const /* WPXM_WPXK1 */,
		const eap_variable_data_c * const /* WPXM_WPXK2 */)
{
	return EAP_STATUS_RETURN(m_am_tools, eap_status_not_supported);
}

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

//
void eapol_am_core_symbian_c::state_notification(const abs_eap_state_notification_c * const state)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	if(state->get_protocol_layer() == eap_protocol_layer_general)
	{
		if (state->get_current_state() == eap_general_state_authentication_cancelled)
		{
			// Authentication was cancelled. Cannot continue.
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("Authentication was cancelled. Sets timer EAPOL_AM_CORE_TIMER_FAILED_COMPLETELY_ID.\n")));

			set_timer(this, EAPOL_AM_CORE_TIMER_FAILED_COMPLETELY_ID, 0, 0);
		}
		else if (state->get_current_state() == eap_general_state_configuration_error)
		{
			// Configuration error. Cannot continue.
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("Configuration error. Sets timer EAPOL_AM_CORE_TIMER_FAILED_COMPLETELY_ID.\n")));

			set_timer(this, EAPOL_AM_CORE_TIMER_FAILED_COMPLETELY_ID, 0, 0);
		}
	}


	if (m_block_packet_sends_and_notifications == true)
	{
		// Notification block is active.		
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("state_notification: notification ignored because Disassociated() was called.\n")));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return;
	}


	// Check if this is EAP layer notification
	if(state->get_protocol_layer() == eap_protocol_layer_eap)
	{
		switch (state->get_current_state())
		{
		case eap_state_none:
			break;
		case eap_state_identity_request_sent:
			// This is for server only so no need to notify WLM.
			break;
		case eap_state_identity_request_received:
			if (m_authentication_indication_sent == false) 
			{
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("Indication sent to WLM: EAuthenticating.\n")));
				m_partner->EapIndication(EAuthenticating);
				m_authentication_indication_sent = true;
			}
			break;
		case eap_state_identity_response_received:
			// This is for server only so no need to notify WLM.
			break;
		case eap_state_authentication_finished_successfully:
			{

			increment_authentication_counter();
			m_successful_authentications++;	
			
			if (m_wpa_psk_mode_active == false)
			{				
				TEap eap;
				eap.Enabled = ETrue;
				eap.UID.Num(static_cast<TInt>(state->get_eap_type()));
				
				// This moves the successful type to be the top priority type in IAP settings.
				TRAPD(err, SetToTopPriorityL(&eap));
				if (err != KErrNone)
				{
					// Just log the error. 
					EAP_TRACE_DEBUG(
						m_am_tools,
						TRACE_FLAGS_DEFAULT, 
						(EAPL("state_notification: SetToTopPriorityL leaved!\n")));
				}

				// Move the active eap type index to the first type
				m_eap_index = 0; 
			}
						

			}
			break;
		case eap_state_authentication_terminated_unsuccessfully:
			{
				if (m_wpa_psk_mode_active == false)
				{
					// Set index to next type.
					m_eap_index++;
				}
		
				increment_authentication_counter();
				m_failed_authentications++;

				// Restart authentication
				eap_am_network_id_c* send_network_id = new eap_am_network_id_c(m_am_tools, state->get_send_network_id());
				if (send_network_id == 0 
					|| send_network_id->get_is_valid_data() == false)
				{
					delete send_network_id;
					EAP_TRACE_DEBUG(
						m_am_tools,
						TRACE_FLAGS_DEFAULT,
						(EAPL("Indication sent to WLM: EFailedCompletely.\n")));
					m_partner->EapIndication(EFailedCompletely);
					break;
				}
				set_timer(this, EAPOL_AM_CORE_TIMER_RESTART_AUTHENTICATION_ID, send_network_id, 0);

			}
			break;
		default:
			break;
		}
	}
	else 
	{
		if(state->get_protocol_layer() == eap_protocol_layer_eapol)
		{
			switch (state->get_current_state())
			{
			case eapol_state_no_start_response:
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("Indication sent to WLM: ENoResponse.\n")));
				m_partner->EapIndication(ENoResponse);
				break;
			default:
				break;
			}
		}
		else if(state->get_protocol_layer() == eap_protocol_layer_eapol_key)
		{
			switch (state->get_current_state())
			{
			case eapol_key_state_802_11i_authentication_terminated_unsuccessfull:
				{					
					increment_authentication_counter();
					m_failed_authentications++;

					// Consider EAPOL layer failures fatal.
					EAP_TRACE_ERROR(
						m_am_tools,
						TRACE_FLAGS_DEFAULT,
						(EAPL("ERROR: Unsuccessful authentication on EAPOL level.\n")));
					EAP_TRACE_DEBUG(
						m_am_tools,
						TRACE_FLAGS_DEFAULT,
						(EAPL("Indication sent to WLM: EThisAPFailed.\n")));
					m_partner->EapIndication(EThisAPFailed);
				}
				break;
			case eapol_key_state_802_11i_authentication_finished_successfull:
				{					
					EAP_TRACE_ALWAYS(
						m_am_tools,
						TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
						(EAPL("EAPOL_KEY: %s: Authentication SUCCESS\n"),
						(m_is_client == true ? "client": "server")));
				}
				break;
			default:
				break;
			}
		}	
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
}

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

//

eap_status_e eapol_am_core_symbian_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("eapol_am_core_symbian_c::TimerExpired id = %d.\n"),
		id));

	switch (id)
	{
	case EAPOL_AM_CORE_TIMER_RESTART_AUTHENTICATION_ID:
		{			
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("EAPOL_AM_CORE_TIMER_RESTART_AUTHENTICATION_ID elapsed: Stopping stack.\n")));
			
			// Stop stack. Do this only if Ethernet core still exists.
			if (m_ethernet_core != 0)
			{
				m_ethernet_core->shutdown();
				delete m_ethernet_core;
				m_ethernet_core = 0;
			}
			if (m_wpa_psk_mode_active == true)
			{
				// PSK mode active - cannot restart. Just fail.
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("WPA PSK mode failed.\n")));
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("Indication sent to WLM: EThisAPFailed.\n")));
				m_partner->EapIndication(EThisAPFailed);			
				break;

			}

			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("Checking if more types.\n")));

			TInt i;
			TEap *eapType = 0;  
			// Search for more EAP types to try
			for (i = m_eap_index; i < m_iap_eap_array.Count(); i++)
			{
				// Find the next enabled EAP type (highest priority)
				eapType = m_iap_eap_array[i];			
				if (eapType->Enabled == 1)
				{
					break;
				}
			}
			// Update index to point to next type to be tried
			m_eap_index = i;

			if (i >= m_iap_eap_array.Count())
			{
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("No more configured EAP types to try.\n")));

				// No point in trying to restart authentication because there isn't any more
				// EAP types left to try...
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("Indication sent to WLM: EThisAPFailed.\n")));
				m_partner->EapIndication(EThisAPFailed);			
				break;
			}

			// Check if authentication mode must be changed
			TLex8 tmp(eapType->UID);
			TInt type(0);
			tmp.Val(type);

			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("Found new type to try: %d.\n"), type));

			switch (type)
			{
			case eap_type_leap:
				m_active_type_is_leap = true;
				if (m_802_11_authentication_mode != EAuthModeLeap
					&& m_security_mode != Wpa
					&& m_security_mode != Wpa2Only) // In WPA or WPA2 even LEAP uses open authentication
				{
					// New type is LEAP and the old was something else:
					// must reassociate with correct authentication mode.					
					m_self_disassociated = true;
					TInt result = m_partner->Disassociate();
					if (result != KErrNone)
					{
						// Probably unrecoverable error
						EAP_TRACE_DEBUG(
							m_am_tools,
							TRACE_FLAGS_DEFAULT,
							(EAPL("Indication sent to WLM: EFailedCompletely.\n")));				
						m_partner->EapIndication(EFailedCompletely);
						EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
						return eap_status_ok;
					}
					
					EAP_TRACE_DEBUG(
						m_am_tools,
						TRACE_FLAGS_DEFAULT,
						(EAPL("TimerExpired: Changing auth type to LEAP.\n")));

					m_802_11_authentication_mode = EAuthModeLeap;
					
					m_partner->Associate(EAuthModeLeap);
					EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
					return eap_status_ok;
				}
				break;
			default:
				m_active_type_is_leap = false;
				if (m_802_11_authentication_mode != EAuthModeOpen
					&& m_security_mode != Wpa
					&& m_security_mode != Wpa2Only) // In WPA or WPA2 even LEAP uses open authentication)
				{
					// New type is non-LEAP and the old was LEAP:
					// must reassociate with correct authentication mode
					m_self_disassociated = true;
					TInt result = m_partner->Disassociate();
					if (result != KErrNone)
					{
						// Probably unrecoverable error	
						EAP_TRACE_DEBUG(
							m_am_tools,
							TRACE_FLAGS_DEFAULT,
							(EAPL("Indication sent to WLM: EFailedCompletely.\n")));

						m_partner->EapIndication(EFailedCompletely);
						EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
						return eap_status_ok;
					}

					EAP_TRACE_DEBUG(
						m_am_tools,
						TRACE_FLAGS_DEFAULT,
						(EAPL("TimerExpired: Changing auth type to OPEN.\n")));				

					m_802_11_authentication_mode = EAuthModeOpen;
					
					m_partner->Associate(EAuthModeOpen);
					
					EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
					return eap_status_ok;
				}
				break;
			}

			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("TimerExpired: No need to change auth type.\n")));				

			if (CompleteAssociation(
					KErrNone,
					m_local_address, 
					m_remote_address,
					m_received_wpa_ie, 
					m_received_wpa_ie_length,
					m_sent_wpa_ie,
					m_sent_wpa_ie_length,
					m_group_key_cipher_suite,
					m_pairwise_key_cipher_suite) != KErrNone)
			{
				// Probably unrecoverable error	
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("Indication sent to WLM: EFailedCompletely.\n")));				
				m_partner->EapIndication(EFailedCompletely);
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
				return eap_status_ok;
			}			
		}
		break;
				
	case EAPOL_AM_CORE_TIMER_DELETE_STACK_ID:
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("EAPOL_AM_CORE_TIMER_DELETE_STACK_ID elapsed: Delete stack.\n")));

			cancel_all_timers();

			// Delete stack
			if (m_ethernet_core != 0)
			{
				m_ethernet_core->shutdown();
				delete m_ethernet_core;
				m_ethernet_core = 0;				
			}
			m_stack_marked_to_be_deleted = false;

			// Re-activates timer queue.
			eap_status_e status = m_am_tools->re_activate_timer_queue();
			if (status != eap_status_ok)
			{
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("ERROR: re_activate_timer_queue() failed, status = %d\n")));
			}
		}
		break;
	
	case EAPOL_AM_CORE_TIMER_FAILED_COMPLETELY_ID:
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("EAPOL_AM_CORE_TIMER_FAILED_COMPLETELY_ID elapsed: Indication sent to WLM: EFailedCompletely.\n")));

			m_partner->EapIndication(EFailedCompletely);
		}
		break;
	
	default:
		break;
	}
	return eap_status_ok;
}

eap_status_e eapol_am_core_symbian_c::timer_delete_data(
	const u32_t id, void *data)
{
	switch (id)
	{
	case EAPOL_AM_CORE_TIMER_RESTART_AUTHENTICATION_ID:
		{
			eap_am_network_id_c* tmp = static_cast<eap_am_network_id_c*>(data);
			delete tmp;
		}
		break;
	case EAPOL_AM_CORE_TIMER_DELETE_STACK_ID:
		break;
	case EAPOL_AM_CORE_TIMER_FAILED_COMPLETELY_ID:
		break;

	default:
		{
			EAP_TRACE_ERROR(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("eapol_am_core_symbian_c::timer_delete_data: deleted unknown timer.\n")));
			(void)EAP_STATUS_RETURN(m_am_tools, eap_status_not_supported);
		}
	}	
	return eap_status_ok;
}
//--------------------------------------------------

//
u32_t eapol_am_core_symbian_c::get_header_offset(
	u32_t * const MTU,
	u32_t * const trailer_length)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);
	*MTU = KMTU;
	*trailer_length = KTrailerLength;
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return KHeaderOffset;
}

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

//
eap_status_e eapol_am_core_symbian_c::unload_module(const eap_type_value_e type)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);
	eap_status_e status(eap_status_type_does_not_exists_error);
	TInt index = m_eap_type_array.Find(type);
	if (index != KErrNotFound)
	{
		delete m_plugin_if_array[index];
		m_plugin_if_array.Remove(index);
		m_eap_type_array.Remove(index);
		status = eap_status_ok;			
	}
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
eap_status_e eapol_am_core_symbian_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_status_e status = m_ethernet_core->eap_acknowledge(receive_network_id);

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

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

//
eap_status_e eapol_am_core_symbian_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_if,
		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_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::load_module(type %d=%s, tunneling_type %d=%s)\n"),
		static_cast<TInt>(type),
		eap_header_string_c::get_eap_type_string(type),
		static_cast<TInt>(tunneling_type),
		eap_header_string_c::get_eap_type_string(tunneling_type)));

	eap_status_e status = eap_status_process_general_error;
	TBuf8<KMaxEapCueLength> cue;
	cue.Num(static_cast<TInt>(convert_eap_type_to_u32_t(type)));
	CEapType* eapType = 0;
	TInt error(KErrNone);

	// Check if this EAP type has already been loaded
	TInt eapArrayIndex = m_eap_type_array.Find(type);
	if (eapArrayIndex != KErrNotFound)
	{
		// Yep. It was loaded already.
		eapType = m_plugin_if_array[eapArrayIndex];		
	}
	else 
	{
		// We must have a trap here since the EAPOL core knows nothing about Symbian.
		TRAP(error, (eapType = CEapType::NewL(cue, m_index_type, m_index)));	
		if (error != KErrNone
			|| eapType == 0)
		{
			// Interface not found or implementation creation function failed
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("ECom could not find/initiate implementation.\n")));
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}
	}
	// Set the tunneling type
	eapType->SetTunnelingType(convert_eap_type_to_u32_t(tunneling_type));

	// Create the EAP protocol interface implementation.
	TRAP(error, (*eap_type_if = eapType->GetStackInterfaceL(m_am_tools, partner, is_client_when_true, receive_network_id)));
		
	if (error != KErrNone 
		|| *eap_type_if == 0 
		|| (*eap_type_if)->get_is_valid() == false)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Could not create EAP type interface instance. Error: %d\n"), error));

		status = eap_status_allocation_error;
		// Unload DLL (two ways, depending whether this type was already loaded...)
		if  (eapArrayIndex == KErrNotFound)
		{
			// No need to call shutdown here because GetStackInterfaceL has done it.
			delete eapType;
		}
		else
		{
			unload_module(type);
		}
		// Note: even in error cases eap_core_c deletes eap_type_if
	}
	else
	{
		status = eap_status_ok;
		if (eapArrayIndex  == KErrNotFound)
		{
			// Add plugin information to the member arrays. There is no need to store eap_type pointer because
			// the stack takes care of its deletion.
			if (m_plugin_if_array.Append(eapType) != KErrNone)
			{
				delete eapType;
				status = eap_status_allocation_error;
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);				
			}
			if (m_eap_type_array.Append(type) != KErrNone)
			{
				// Remove the eap type added just previously
				m_plugin_if_array.Remove(m_plugin_if_array.Count() - 1);
				delete eapType;
				status = eap_status_allocation_error;
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);				
			}
		} 
	}
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

//
TInt eapol_am_core_symbian_c::Disassociated()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::Disassociated()\n")));

	if (m_self_disassociated == true)
	{
		// We were expecting this. No need to reset state.
		m_self_disassociated = false;
		return KErrNone;
	}

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::Disassociated.\n")));

	eap_status_e status(eap_status_ok);

	// Set block on.
	m_block_packet_sends_and_notifications = true;

	// Reset flags
	m_success_indication_sent = false;
	m_unicast_wep_key_received = false;
	m_broadcast_wep_key_received = false;
	m_authentication_indication_sent = false;

	if (m_ethernet_core != 0)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Stack exists. Set EAPOL_AM_CORE_TIMER_DELETE_STACK_ID timer.\n")));

		m_stack_marked_to_be_deleted = true;
		set_timer(this, EAPOL_AM_CORE_TIMER_DELETE_STACK_ID, 0, 0);
	} 
	else
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Stack did not exists. EAPOL_AM_CORE_TIMER_DELETE_STACK_ID timer not set.\n")));
	}

	// reset index
	m_eap_index = 0;


	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status));	
}

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

//
TInt eapol_am_core_symbian_c::SendWPAMICFailureReport(
		TBool aFatalMICFailure,
		const TMICFailureType aMICFailureType)
{
	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::SendWPAMICFailureReport(%d, %d).\n"),
		aFatalMICFailure,
		aMICFailureType));

	bool fatal_failure_when_true = true;

	if (!aFatalMICFailure)
	{
		fatal_failure_when_true = false;
	}

	eapol_RSNA_key_header_c::eapol_tkip_mic_failure_type_e tkip_mic_failure_type
		= eapol_RSNA_key_header_c::eapol_tkip_mic_failure_type_pairwise_key;

	if (aMICFailureType == EGroupKey)
	{
		tkip_mic_failure_type
			= eapol_RSNA_key_header_c::eapol_tkip_mic_failure_type_group_key;
	}

	const eap_status_e status = m_ethernet_core->tkip_mic_failure(
		m_receive_network_id,
		fatal_failure_when_true,
		tkip_mic_failure_type);

	return m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status));	
}


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

//
void eapol_am_core_symbian_c::ReadEAPSettingsL()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::ReadEAPSettingsL()\n")));

	eap_status_e status(eap_status_ok);

	// Delete old IAP settings
	m_iap_eap_array.ResetAndDestroy();
	if (m_index_type == ELan)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Beginning to read IAP settings - Type: %d, Index: %d.\n"), m_index_type, m_index));

		CWLanSettings* wlan = new(ELeave) CWLanSettings;
		CleanupStack::PushL(wlan);
		SWLANSettings wlanSettings;
		if (wlan->Connect() != KErrNone)
		{
			// Could not connect to CommDB			
			User::Leave(KErrCouldNotConnect);
		}

		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT, (EAPL("Connected to CommDbIf.\n")));

		if (wlan->GetWlanSettingsForService(m_index, wlanSettings) != KErrNone)
		{
			wlan->Disconnect();
			User::Leave(KErrUnknown);
		}

		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Got WLAN settings.\n")));
		
		wlan->GetEapDataL(m_iap_eap_array);
		
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Got EAP data:\n")));

		for (TInt i = 0; i < m_iap_eap_array.Count(); i++)
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("EAP type %d\n"),
				i));

			TLex8 tmp(m_iap_eap_array[i]->UID);
			TInt val(0);
			tmp.Val(val);
		
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("  UID: %d\n"), val));
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("  Enabled: %d\n"),
				m_iap_eap_array[i]->Enabled));
		}

		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("End EAP data:\n")));

		if (m_iap_eap_array.Count() == 0)
		{
			// The EAP field was empty. Allow all types.

			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("Empty EAP field -> enable all types.\n")));

			RImplInfoPtrArray eapArray;
			
			REComSession::ListImplementationsL(KEapTypeInterfaceUid, eapArray);
		
			TEap *eap;
			for (TInt i = 0; i < eapArray.Count(); i++)
			{
				eap = new(ELeave) TEap;
				eap->UID.Copy(eapArray[i]->DataType());
				eap->Enabled = ETrue;
				m_iap_eap_array.Append(eap);
			}

			eapArray.ResetAndDestroy();
		}

		// Get security mode
		if (m_wpa_override_enabled == false)
		{
			m_security_mode = static_cast<EWlanSecurityMode>(wlanSettings.SecurityMode);		
	
			if (wlanSettings.EnableWpaPsk)
			{
				m_wpa_psk_mode_allowed = true;
			}
			else
			{
				m_wpa_psk_mode_allowed = false;
			}
		}
		else
		{
			// WPA override is enabled
			m_security_mode = Wpa;
			if (m_wpa_psk_password_override->get_is_valid_data() == true
				&& m_wpa_psk_password_override->get_data_length() > 0)
			{
				m_wpa_psk_mode_allowed = true;
			}			
			else
			{
				m_wpa_psk_mode_allowed = false;
			}
		}
		
		
		// Get WPA or WPA2 pre shared key & SSID
		if ((m_security_mode == Wlan8021x
			|| m_security_mode == Wpa
			|| m_security_mode == Wpa2Only)
			&& m_wpa_psk_mode_allowed == true
			&& m_is_client == true)
		{
			eap_variable_data_c * password = new eap_variable_data_c(m_am_tools);
			if (password == 0)
			{
				wlan->Disconnect();
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				User::Leave(KErrNoMemory);
			}
			eap_variable_data_c * ssid = new eap_variable_data_c(m_am_tools);
			if (ssid == 0)
			{
				delete password;
				wlan->Disconnect();
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				User::Leave(KErrNoMemory);
			}

			// When using easy WLAN there might be WPA PSK override
			if (m_wpa_psk_password_override->get_is_valid_data() == true
				&& m_wpa_psk_password_override->get_data_length() > 0)
			{
				// Use WPA PSK override
				status = password->set_copy_of_buffer(
					m_wpa_psk_password_override->get_data(m_wpa_psk_password_override->get_data_length()), 
					m_wpa_psk_password_override->get_data_length());
				if (status != eap_status_ok)
				{
					delete password;
					delete ssid;
					wlan->Disconnect();
					EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
					User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
				}
			}
			else
			{
				status = password->set_copy_of_buffer(wlanSettings.WPAPreSharedKey.Ptr(), wlanSettings.WPAPreSharedKey.Size());
				if (status != eap_status_ok)
				{
					delete password;
					delete ssid;
					wlan->Disconnect();
					EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
					User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
				}
			}

			TBuf8<KMaxSSIDLength> tmp;
			tmp.Copy(wlanSettings.SSID);
			status = ssid->set_copy_of_buffer(tmp.Ptr(), tmp.Size());
			if (status != eap_status_ok)
			{
				delete password;
				delete ssid;
				wlan->Disconnect();
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
			}

			crypto_wpa_psk_password_hash_c password_hash(m_am_tools);

			if (ssid->get_data_length() == 0)
			{
				status = ssid->set_copy_of_buffer(m_ssid);
				if (status != eap_status_ok)
				{
					delete password;
					delete ssid;
					wlan->Disconnect();
					EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
					User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
				}
			}	

			TPSKEntry pskEntry;

			pskEntry.indexType = m_index_type;
			pskEntry.index = m_index;

			TPtr8 ssidPtr(
					ssid->get_data(ssid->get_data_length()),
					ssid->get_data_length(),
					ssid->get_data_length()
				);			

            TInt err(KErrNone);

			if (m_wpa_psk_password_override->get_is_valid_data() == false
				|| m_wpa_psk_password_override->get_data_length() == 0)
			{
				// Retrieve saved PSK only when override is not in effect
				TRAP(err, RetrievePSKL(pskEntry));
			} 
			
			if (err != KErrNone
				|| pskEntry.ssid.Compare(ssidPtr) != 0
				|| pskEntry.password.Compare(wlanSettings.WPAPreSharedKey) != 0)
			{
				EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("No previous PSK found...\n")));
				// No previous PSK or parameters were changed. We need to calculate
				// PSK again

				status = password_hash.password_hash(
					password,
					ssid,	
					m_wpa_preshared_key,
					0,
					0);

				if (status != eap_status_ok)
				{			
					delete password;
					delete ssid;
					wlan->Disconnect();							
					EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
					User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
				//	return;
				}
				
				if (m_wpa_psk_password_override->get_is_valid_data() == false
					|| m_wpa_psk_password_override->get_data_length() == 0)
				{
					// Save new PSK (only if psk override is not in effect)
					pskEntry.ssid.Copy(ssidPtr);
				
					pskEntry.password.Copy(wlanSettings.WPAPreSharedKey);
					
					pskEntry.psk.Copy(
						m_wpa_preshared_key->get_data(m_wpa_preshared_key->get_data_length()),
						m_wpa_preshared_key->get_data_length()
						);

					EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("Saving PSK.\n")));
					SavePSKL(pskEntry);																
				}
			}			
			else
			{
				// Copy retrieved psk to member variable
				status = m_wpa_preshared_key->set_copy_of_buffer(pskEntry.psk.Ptr(), pskEntry.psk.Size());
				if (status != eap_status_ok)
				{
					delete password;
					delete ssid;
					wlan->Disconnect();
					EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
					User::Leave(m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, status)));
				}
			}
			delete password;
			delete ssid;
		}
		
		wlan->Disconnect();
		CleanupStack::PopAndDestroy(wlan);		
		if (m_security_mode != Wlan8021x
			&& m_security_mode != Wpa
			&& m_security_mode != Wpa2Only)
		{
			// Unsupported mode
			User::Leave(KErrNotSupported);
		}
	} 
	else
	{
		// At the moment only LAN bearer is supported.
		User::Leave(KErrNotSupported);
	}
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
}

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

void eapol_am_core_symbian_c::SetToTopPriorityL(const TEap* const aEapType)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::SetToTopPriorityL()\n")));

	if (m_index_type == ELan)
	{
		TInt i(0);
		TBuf8<3> uid;
		for (i = 0; i < m_iap_eap_array.Count(); i++)
		{
			TEap* eap = m_iap_eap_array[i];
			if (eap->UID[0] == '0')
			{
				// Cut the leading zero
				uid.Copy(eap->UID.Right(eap->UID.Length()-1));				
			}
			else
			{
				uid.Copy(eap->UID);
			}
			if (eap->Enabled == aEapType->Enabled
				&& uid.Compare(aEapType->UID) == 0)
			{
				// Found
				break;
			}
		}
		if (i >= m_iap_eap_array.Count())
		{
			// This should never happen
			User::Leave(KErrNotFound);					
		}
	
		TLex8 tmp(aEapType->UID);
		TInt val(0);
		tmp.Val(val);

		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("Setting to top priority:\n")));
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("Old index: %d\n"), i));
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("  UID: %d\n"), val));
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("  Enabled: %d\n"), aEapType->Enabled));
	
		if (i == 0)
		{
			// Already at the highest priority
			return;
		}

		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("Beginning to write IAP EAP settings - Type: %d, Index: %d.\n"), m_index_type, m_index));
		
		CWLanSettings* wlan = new(ELeave) CWLanSettings;
		CleanupStack::PushL(wlan);
		SWLANSettings wlanSettings;
		if (wlan->Connect() != KErrNone)
		{
			// Could not connect to CommDB			
			User::Leave(KErrCouldNotConnect);
		}
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("Connected to CommDbIf.\n")));		
		if (wlan->GetWlanSettingsForService(m_index, wlanSettings) != KErrNone)
		{
			wlan->Disconnect();
			User::Leave(KErrUnknown);
		}
		EAP_TRACE_DEBUG(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("Got WLAN settings.\n")));
		
		// Change the order
		TEap* eap = m_iap_eap_array[i];

		m_iap_eap_array.Remove(i); // This does not delete the object	
				
		m_iap_eap_array.Insert(eap, 0);

		wlan->SetEapDataL(m_iap_eap_array);
		
		wlan->Disconnect();

		CleanupStack::PopAndDestroy(wlan);		
	} 
	else
	{
		// At the moment only LAN bearer is supported.
		User::Leave(KErrNotSupported);
	}
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
}

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

eap_status_e eapol_am_core_symbian_c::configure()
{	
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::configure()\n")));


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

#if defined(USE_EAP_ERROR_TESTS)

	{
		eap_variable_data_c EAP_ERROR_TEST_enable_random_errors(m_am_tools);

		eap_status_e status = read_configure(
			cf_str_EAP_ERROR_TEST_enable_random_errors.get_field(),
			&EAP_ERROR_TEST_enable_random_errors);
		if (status == eap_status_ok
			&& EAP_ERROR_TEST_enable_random_errors.get_is_valid_data() == true)
		{
			u32_t *enable_random_errors = reinterpret_cast<u32_t *>(
				EAP_ERROR_TEST_enable_random_errors.get_data(sizeof(u32_t));
			if (enable_random_errors != 0
				&& *enable_random_errors != 0)
			{
				m_enable_random_errors = true;
			}
		}
	}

	{
		eap_variable_data_c EAP_ERROR_TEST_send_original_packet_first(m_am_tools);

		eap_status_e status = read_configure(
			cf_str_EAP_ERROR_TEST_send_original_packet_first.get_field(),
			&EAP_ERROR_TEST_send_original_packet_first);
		if (status == eap_status_ok
			&& EAP_ERROR_TEST_send_original_packet_first.get_is_valid_data() == true)
		{
			u32_t *send_original_packet_first = reinterpret_cast<u32_t *>(
				EAP_ERROR_TEST_send_original_packet_first.get_data(sizeof(u32_t));
			if (send_original_packet_first != 0
				&& *send_original_packet_first != 0)
			{
				m_send_original_packet_first = true;
			}
		}
	}

	{
		eap_variable_data_c EAP_ERROR_TEST_generate_multiple_error_packets(m_am_tools);

		eap_status_e status = read_configure(
			cf_str_EAP_ERROR_TEST_generate_multiple_error_packets.get_field(),
			&EAP_ERROR_TEST_generate_multiple_error_packets);
		if (status == eap_status_ok
			&& EAP_ERROR_TEST_generate_multiple_error_packets.get_is_valid_data() == true)
		{
			u32_t *generate_multiple_error_packets = reinterpret_cast<u32_t *>(
				EAP_ERROR_TEST_generate_multiple_error_packets.get_data(sizeof(u32_t));
			if (generate_multiple_error_packets != 0
				&& *generate_multiple_error_packets != 0)
			{
				m_generate_multiple_error_packets = *generate_multiple_error_packets;
			}
		}
	}


	{
		eap_variable_data_c EAP_ERROR_TEST_manipulate_ethernet_header(m_am_tools);

		eap_status_e status = read_configure(
			cf_str_EAP_ERROR_TEST_manipulate_ethernet_header.get_field(),
			&EAP_ERROR_TEST_manipulate_ethernet_header);
		if (status == eap_status_ok
			&& EAP_ERROR_TEST_manipulate_ethernet_header.get_is_valid_data() == true)
		{
			u32_t *manipulate_ethernet_header = reinterpret_cast<u32_t *>(
				EAP_ERROR_TEST_manipulate_ethernet_header.get_data(sizeof(u32_t));
			if (manipulate_ethernet_header != 0
				&& *manipulate_ethernet_header != 0)
			{
				m_manipulate_ethernet_header = true;
			}
		}
	}

	{
		eap_variable_data_c EAP_ERROR_TEST_error_probability(m_am_tools);

		eap_status_e status = read_configure(
			cf_str_EAP_ERROR_TEST_error_probability.get_field(),
			&EAP_ERROR_TEST_error_probability);
		if (status == eap_status_ok
			&& EAP_ERROR_TEST_error_probability.get_is_valid_data() == true)
		{
			u32_t *error_probability = reinterpret_cast<u32_t *>(
				EAP_ERROR_TEST_error_probability.get_data(sizeof(u32_t));
			if (error_probability != 0)
			{
				m_error_probability = *error_probability;
			}
		}
	}	

	{
		eap_variable_data_c EAP_disable_function_traces(m_am_tools);

		eap_status_e status = read_configure(
			cf_str_EAP_TRACE_enable_function_traces.get_field(),
			&EAP_disable_function_traces);
		if (status == eap_status_ok
			&& EAP_disable_function_traces.get_is_valid_data() == true)
		{
			u32_t *disable_function_traces = reinterpret_cast<u32_t *>(
				EAP_disable_function_traces.get_data(sizeof(u32_t));
			if (disable_function_traces != 0
				&& *disable_function_traces != 0)
			{
				m_am_tools->set_trace_mask(
					m_am_tools->get_trace_mask()
					| eap_am_tools_c::eap_trace_mask_functions
					);
			}
		}
	}

#endif //#if defined(USE_EAP_ERROR_TESTS)


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

	{		
		eap_variable_data_c EAP_TRACE_disable_traces(m_am_tools);

		eap_status_e status = read_configure(
			cf_str_EAP_TRACE_disable_traces.get_field(),
			&EAP_TRACE_disable_traces);
		if (status == eap_status_ok
			&& EAP_TRACE_disable_traces.get_is_valid_data() == true)
		{
			u32_t *disable_traces = reinterpret_cast<u32_t *>(
				EAP_TRACE_disable_traces.get_data(sizeof(u32_t)));
			if (disable_traces != 0
				&& *disable_traces != 0)
			{
				m_am_tools->set_trace_mask(eap_am_tools_c::eap_trace_mask_none);
			}
			else
			{
				// OK, set the default trace mask.
				m_am_tools->set_trace_mask(
					eap_am_tools_c::eap_trace_mask_debug
					| eap_am_tools_c::eap_trace_mask_always
					| eap_am_tools_c::eap_trace_mask_error);
			}
		}
	}

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

	{		
		eap_variable_data_c EAP_TRACE_activate_only_trace_masks_always_and_error(m_am_tools);

		eap_status_e status = read_configure(
			cf_str_EAP_TRACE_activate_only_trace_masks_always_and_error.get_field(),
			&EAP_TRACE_activate_only_trace_masks_always_and_error);
		if (status == eap_status_ok
			&& EAP_TRACE_activate_only_trace_masks_always_and_error.get_is_valid_data() == true)
		{
			u32_t *activate_trace_mask_always
				= reinterpret_cast<u32_t *>(
					EAP_TRACE_activate_only_trace_masks_always_and_error.get_data(
						sizeof(u32_t)));
			if (activate_trace_mask_always != 0
				&& *activate_trace_mask_always != 0)
			{
				m_am_tools->set_trace_mask(
					eap_am_tools_c::eap_trace_mask_always
					| eap_am_tools_c::eap_trace_mask_error
					);
			}
		}
	}

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

	{		
		eap_variable_data_c EAP_TRACE_activate_trace_on_error(m_am_tools);

		eap_status_e status = read_configure(
			cf_str_EAP_TRACE_activate_trace_on_error.get_field(),
			&EAP_TRACE_activate_trace_on_error);
		if (status == eap_status_ok
			&& EAP_TRACE_activate_trace_on_error.get_is_valid_data() == true)
		{
			u32_t *activate_trace_on_error = reinterpret_cast<u32_t *>(
				EAP_TRACE_activate_trace_on_error.get_data(sizeof(u32_t)));
			if (activate_trace_on_error != 0
				&& *activate_trace_on_error != 0)
			{
				m_am_tools->set_activate_trace_on_error();
			}
		}
	}

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

	// All of the configuration options are optional.
	// So we return OK.
	return eap_status_ok;
}

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

eap_status_e eapol_am_core_symbian_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_ALWAYS(data != NULL);
	
	// To remove compilation warning in UREL due to KMaxConfigStringLength.
	if(field->get_field_length() > KMaxConfigStringLength)
	{
		return eap_status_process_general_error;
	}
	
	// Trap must be set here because the OS independent portion of EAPOL
	// that calls this function does not know anything about Symbian.	
	eap_status_e status(eap_status_ok);
	
	// Check if the wanted parameter is default type

	eap_variable_data_c wanted_field(m_am_tools);
	eap_variable_data_c type_field(m_am_tools);
	eap_variable_data_c type_field_server(m_am_tools);
	
	status = wanted_field.set_buffer(
		field->get_field(),
		field->get_field_length(),
		false,
		false);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return status;
	}
	
	status = type_field.set_buffer(
		cf_str_EAP_default_type_u32_t.get_field()->get_field(),
		cf_str_EAP_default_type_u32_t.get_field()->get_field_length(),
		false,
		false);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return status;
	}
	
	status = type_field_server.set_buffer(
		cf_str_EAP_server_default_type_u32_t.get_field()->get_field(),
		cf_str_EAP_server_default_type_u32_t.get_field()->get_field_length(),
		false,
		false);
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return status;
	}

	if (!wanted_field.compare(&type_field)
		|| !wanted_field.compare(&type_field_server))
	{
		TInt i; 
		// We need to return here the next EAP type we should try		
		for (i = m_eap_index; i < m_iap_eap_array.Count(); i++)
		{
			// Find the first enabled EAP type (highest priority)
			TEap *eapType = m_iap_eap_array[i];			
			if (eapType->Enabled == 1)
			{
				// Convert the string to integer
				TLex8 tmp(eapType->UID);
				TInt val(0);
				tmp.Val(val);
				status = data->set_copy_of_buffer(reinterpret_cast<u8_t *>(&val), sizeof(TUint));
				if (status != eap_status_ok)
				{
					EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
					return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);			
				}

				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("EAPOL: Trying EAP type: %d.\n"), val));
				break;
			}
		}	
		m_eap_index = i;
		if (i >= m_iap_eap_array.Count())
		{
			// Not found
			// Send WLM notification because there is no way that the authentication
			// can be successful if we don't have any EAP types to use...
			if (m_is_client)
			{
				EAP_TRACE_ERROR(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("ERROR: No configured EAP types or all tried unsuccessfully.\n")));
			}

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

	// It was something else than EAP type. Read it from DB.
	TRAPD(err, read_configureL(
		field->get_field(),
		field->get_field_length(),
		data));
	if (err != KErrNone) 
	{
		status = m_am_tools->convert_am_error_to_eapol_error(err);

#if defined(USE_EAP_FILECONFIG)
		if (m_fileconfig != 0
			&& m_fileconfig->get_is_valid() == true)
		{
			// Here we could try the final configuration option.
			status = m_fileconfig->read_configure(
				field,
				data);
		}
#endif //#if defined(USE_EAP_FILECONFIG)
	}

	m_am_tools->trace_configuration(
		status,
		field,
		data);

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

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

void eapol_am_core_symbian_c::read_configureL(
	eap_config_string field,
	const u32_t /*field_length*/,
	eap_variable_data_c * const data)
{	
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	// Create a buffer for the ascii strings - initialised with the argument
	HBufC8* asciibuf = HBufC8::NewLC(128);
	TPtr8 asciiString = asciibuf->Des();
	asciiString.Copy(reinterpret_cast<const unsigned char *>(field));
		
	// Buffer for unicode parameter
	HBufC* unicodebuf = HBufC::NewLC(128);
	TPtr unicodeString = unicodebuf->Des();
	
	// Convert to unicode 
	unicodeString.Copy(asciiString);

	// Now do the database query
	HBufC* buf = HBufC::NewLC(KMaxSqlQueryLength);
	TPtr sqlStatement = buf->Des();
	_LIT(KSQLQueryRow, "SELECT %S FROM eapol");
	sqlStatement.Format(KSQLQueryRow, &unicodeString);
	
	RDbView view;
	User::LeaveIfError(view.Prepare(m_database, TDbQuery(sqlStatement), TDbWindow::EUnlimited));
	CleanupClosePushL(view);
	User::LeaveIfError(view.EvaluateAll());	
	if (view.FirstL())
	{
		eap_status_e status(eap_status_process_general_error);
		view.GetL();		
		switch (view.ColType(1))
		{
		case EDbColText:				
			{
				unicodeString = view.ColDes(1);
				// Convert to 8-bit
				asciiString.Copy(unicodeString);
				if (asciiString.Size() > 0)
				{
					status = data->set_copy_of_buffer(asciiString.Ptr(), asciiString.Size());
					if (status != eap_status_ok)
					{
						User::Leave(KErrNoMemory);
					}
				} 
				else 
				{
					// Empty field. Do nothing...data remains invalid
					// and the stack knows what to do hopefully.
					break;
				}
			}
			break;
		case EDbColUint32:
			{
				TUint value;
				value = view.ColUint32(1);
				status = data->set_copy_of_buffer((const unsigned char *) &value, sizeof(value));
				if (status != eap_status_ok)
				{
					User::Leave(KErrNoMemory);
				}
			}
			break;
		default:
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("read_configureL: Unexpected column type.\n")));
			User::Panic(_L("EAPOL"), 1);			
		}
	} 
	else 
	{
		// Could not find parameter
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("read_configureL: Could not find configuration parameter.\n")));
		User::Leave(KErrNotFound);
	}		
	
	// Close database
	CleanupStack::PopAndDestroy(4); // session & 3 buffers


	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
}

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

eap_status_e eapol_am_core_symbian_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_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return eap_status_not_supported;
}

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

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

	const eap_status_e status = m_am_tools->am_set_timer(
		p_initializer, 
		p_id, 
		p_data,
		p_time_ms);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return status;
}

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

//
eap_status_e eapol_am_core_symbian_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);
	
	const eap_status_e status = m_am_tools->am_cancel_timer(
		p_initializer, 
		p_id);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return status;
}

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

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

	const eap_status_e status = m_am_tools->am_cancel_all_timers();

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return status;
}

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

eap_status_e eapol_am_core_symbian_c::check_is_valid_eap_type(const eap_type_value_e eap_type)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);
	
	TEap *eapType = 0; 
	
	eap_status_e status(eap_status_illegal_eap_type);
	
	for (int i = 0; i < m_iap_eap_array.Count(); i++)
	{
		// Try next EAP type
		eapType = m_iap_eap_array[i];
		if (eapType->Enabled == 1)
		{	
			// Convert the string to integer
			TLex8 tmp(eapType->UID);
			TInt val(0);
			tmp.Val(val);
			if (eap_type == static_cast<eap_type_ietf_values_e>(val))
			{
				// Allowed
				status = eap_status_ok;
				break;
			}	
		}
	}
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

	return EAP_STATUS_RETURN(m_am_tools, status);
}

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

eap_status_e eapol_am_core_symbian_c::get_eap_type_list(
	eap_array_c<eap_type_value_e> * const eap_type_list)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	TEap *eapType = 0; 

	eap_status_e status(eap_status_illegal_eap_type);

	status = eap_type_list->reset();
	if (status != eap_status_ok)
	{
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, status);
	}

	for (TInt i = 0; i < m_iap_eap_array.Count(); i++)
	{
		// Check if type is enabled
		eapType = m_iap_eap_array[i];
		if (eapType->Enabled == 1)
		{	
			TLex8 tmp(eapType->UID);
			TInt val(0);
			tmp.Val(val);

			eap_type_value_e * const eap_type = new eap_type_value_e(
				static_cast<eap_type_ietf_values_e>(val));
			if (eap_type == 0)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
			}

			status = eap_type_list->add_object(eap_type, true);
			if (status != eap_status_ok)
			{
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}
		}
	}
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return eap_status_ok;
}

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

void eapol_am_core_symbian_c::TryOpenDatabaseL(RDbNamedDatabase& aDatabase, RDbs& aSession)
{
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::TryOpenDatabaseL()\n")));

	// 1. Open/create a database	
	
	// Connect to the DBMS server.
	User::LeaveIfError(aSession.Connect());		
	CleanupClosePushL(aSession);	
	// aSession and aDatabase are pushed to the cleanup stack even though they may be member
	// variables of the calling class and would be closed in the destructor anyway. This ensures
	// that if they are not member variables they will be closed. Closing the handle twice
	// does no harm.	
	
#ifdef SYMBIAN_SECURE_DBMS
	
	// Create the secure shared database (if necessary) with the specified secure policy.
	// Database will be created in the data caging path for DBMS (C:\private\100012a5).
	
	TInt err = aDatabase.Create(aSession, KDatabaseName, KSecureUIDFormat);
	
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("TryOpenDatabaseL() - Created Secure DB for eapol.dat. err=%d\n"), err ));	
		
	if(err == KErrNone)
	{	
		aDatabase.Close();
		
	} else if (err != KErrAlreadyExists) 
	{
		User::LeaveIfError(err);
	}
	
	User::LeaveIfError(aDatabase.Open(aSession, KDatabaseName, KSecureUIDFormat));
	CleanupClosePushL(aDatabase);		
		
#else
	// For non-secured database. The database will be created in the old location (c:\system\data).
	
	RFs fsSession;		
	User::LeaveIfError(fsSession.Connect());
	CleanupClosePushL(fsSession);
	
	// Create the database (if necessary)		
	TInt err = aDatabase.Create(fsSession, KDatabaseName);
	
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("TryOpenDatabaseL() - Created Non-Secure DB for eapol.dat. err=%d\n"), err ));	
	
	if(err == KErrNone)
	{
		aDatabase.Close();
		
	} else if (err != KErrAlreadyExists) 
	{
		User::LeaveIfError(err);
	}
	CleanupStack::PopAndDestroy(); // close fsSession
	
	User::LeaveIfError(aDatabase.Open(aSession, KDatabaseName));
	CleanupClosePushL(aDatabase);		
	    
#endif // #ifdef SYMBIAN_SECURE_DBMS

	HBufC* buf = HBufC::NewLC(KMaxSqlQueryLength);
	TPtr sqlStatement = buf->Des();

	// 2. Create the table for pre-shared keys in database (ignore error if exists)
	
//// NAME /////////////////////////////////////////////////// TYPE ////////////// Constant ///////
//| ServiceType											  | UNSIGNED INTEGER | KServiceType    |//
//| ServiceIndex										  | UNSIGNED INTEGER | KServiceIndex   |//
//| SSID												  | VARBINARY(255)	 | KSSID		   |//	
//| Password											  | VARBINARY(255)	 | KPassword	   |//	
//| PSK												      | VARBINARY(255)   | KPSK			   |//	
//////////////////////////////////////////////////////////////////////////////////////////////////	

	_LIT(KSQLCreateTable2, "CREATE TABLE %S (%S UNSIGNED INTEGER, \
											 %S UNSIGNED INTEGER, \
											 %S VARBINARY(255), \
											 %S VARBINARY(255), \
											 %S VARBINARY(255))");
											 
	sqlStatement.Format(KSQLCreateTable2, &KEapolPSKTableName, 
		&KServiceType, &KServiceIndex, &KSSID, &KPassword, &KPSK);
		
	err = aDatabase.Execute(sqlStatement);
	if (err != KErrNone && err != KErrAlreadyExists)
	{
		User::Leave(err);
	}
	
	CleanupStack::PopAndDestroy(); // buf
	CleanupStack::Pop(2); // database, session
	
	// If compacting is not done the database will start growing
	aDatabase.Compact();
}

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

void eapol_am_core_symbian_c::OpenDatabaseL(RDbNamedDatabase& aDatabase, RDbs& aSession)
{
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::OpenDatabaseL()\n")));

	// Create the database (if necessary)
	TRAPD(err, TryOpenDatabaseL(aDatabase, aSession));
	if (err != KErrNone)
	{
		// Because of error remove the database file.
		RFs fsDataBaseFile;
		User::LeaveIfError(fsDataBaseFile.Connect());
		CleanupClosePushL(fsDataBaseFile);
		err = fsDataBaseFile.Delete(KDatabaseName);
		if(err != KErrNone)
		{
			User::Leave(KErrCorrupt);
		}
		CleanupStack::PopAndDestroy(); // close fsDataBaseFile

		// Try open database again. This will leave if fails second time.
		TryOpenDatabaseL(aDatabase, aSession);
	}
}

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

eap_status_e eapol_am_core_symbian_c::random_error(
	eap_buf_chain_wr_c * const sent_packet,
	const bool forse_error,
	const u32_t packet_index)
{	
	EAP_UNREFERENCED_PARAMETER(packet_index);
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::random_error()\n")));

	eap_status_e status(eap_status_ok);
	u8_t *data = sent_packet->get_data(sent_packet->get_data_length());

	crypto_random_c rand(m_am_tools);
	u32_t random_guard(0);
	bool error_generated(false);
	u32_t minimum_index(0);

	if (m_manipulate_ethernet_header == false)
	{
		minimum_index = eapol_ethernet_header_wr_c::get_header_length();
	}

	for (u32_t ind = minimum_index; ind < sent_packet->get_data_length(); ind++)
	{
		status = rand.get_rand_bytes(
			reinterpret_cast<u8_t *>(&random_guard),
			sizeof(random_guard));
		if (status != eap_status_ok)
		{
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		// This is simple limiter to the probability of an error.
		// probability = m_error_probability / (2^32)
		if (random_guard < m_error_probability)
		{
			u8_t rnd(0);
			u8_t previous_data(0);
			// Create an error.
			status = rand.get_rand_bytes(
				&rnd,
				sizeof(rnd));
			if (status != eap_status_ok)
			{
				return EAP_STATUS_RETURN(m_am_tools, status);
			}

			previous_data = data[ind];
			data[ind] ^= rnd;

			if (previous_data != data[ind])
			{
				error_generated = true;
				sent_packet->set_random_error_type(eap_random_error_type_manipulate_byte);

				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("TEST: random_error(): packet_index 0x%08x:%lu, data[0x%04x] changed from 0x%02x to 0x%02x.\n"),
					this,
					packet_index,
					ind,
					previous_data,
					data[ind]));
			}
		}
	}

	if (error_generated == false
		&& forse_error == true
		&& sent_packet->get_data_length() > 0ul)
	{
		// Generate one error.

		// Random error type.
		eap_random_error_type error_type = eap_random_error_type_none_keep_this_last_case;
		status = rand.get_rand_bytes(
			reinterpret_cast<u8_t *>(&error_type),
			sizeof(error_type));
		if (status != eap_status_ok)
		{
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		error_type = static_cast<eap_random_error_type>(
			static_cast<u32_t>(error_type % static_cast<u32_t>(
								   eap_random_error_type_none_keep_this_last_case)));

		sent_packet->set_random_error_type(error_type);

		switch(error_type)
		{
		case eap_random_error_type_manipulate_byte:
			{
				u32_t rnd_index(0);
				u8_t previous_data(0);
				u32_t index(0);

				do
				{
					do
					{
						// Create an error index.
						status = rand.get_rand_bytes(
							reinterpret_cast<u8_t *>(&rnd_index),
							sizeof(rnd_index));
						if (status != eap_status_ok)
						{
							return EAP_STATUS_RETURN(m_am_tools, status);
						}

						index = (rnd_index % (sent_packet->get_data_length() - minimum_index))
							+ minimum_index;
					}
					while(index < minimum_index
						|| index > sent_packet->get_buffer_length());

					u8_t rnd(0);
					// Create an error.
					status = rand.get_rand_bytes(
						&rnd,
						sizeof(rnd));
					if (status != eap_status_ok)
					{
						return EAP_STATUS_RETURN(m_am_tools, status);
					}

					previous_data = data[index];
					data[index] ^= rnd;
				}
				while(previous_data == data[index]);

				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("TEST: random_error(): packet_index 0x%08x:%lu, data[0x%04x] changed from 0x%02x to 0x%02x.\n"),
					this,
					packet_index,
					index,
					previous_data,
					data[index]));

				error_generated = true;
			}
			break;
		case eap_random_error_type_change_packet_length_longer:
			{
				u8_t delta_length(0);
				i32_t new_length(0);

				do
				{
					status = rand.get_rand_bytes(
						reinterpret_cast<u8_t *>(&delta_length),
						sizeof(delta_length));
					if (status != eap_status_ok)
					{
						return EAP_STATUS_RETURN(m_am_tools, status);
					}

					new_length = static_cast<i32_t>(sent_packet->get_data_length()
													+ static_cast<i32_t>(delta_length));
				}
				while (new_length < static_cast<i32_t>(
						   eapol_ethernet_header_wr_c::get_header_length())
					|| new_length > static_cast<i32_t>(sent_packet->get_buffer_length()));

				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("TEST: random_error(): packet_index 0x%08x:%lu, packet length changed from %lu to %lu.\n"),
					this,
					packet_index,
					sent_packet->get_data_length(),
					new_length));

				sent_packet->set_data_length(new_length);

				error_generated = true;
			}
			break;
		case eap_random_error_type_change_packet_length_shorter:
			{
				u8_t delta_length(0);
				i32_t new_length(0);

				do
				{
					status = rand.get_rand_bytes(
						reinterpret_cast<u8_t *>(&delta_length),
						sizeof(delta_length));
					if (status != eap_status_ok)
					{
						return EAP_STATUS_RETURN(m_am_tools, status);
					}

					delta_length %= static_cast<i32_t>(
						sent_packet->get_data_length()
						- static_cast<i32_t>(eapol_ethernet_header_wr_c::get_header_length()));

					if (delta_length == 0)
					{
						continue;
					}

					new_length = static_cast<i32_t>(
						sent_packet->get_data_length() - static_cast<i32_t>(delta_length));
				}
				while (new_length < static_cast<i32_t>(
						   eapol_ethernet_header_wr_c::get_header_length())
					|| new_length > static_cast<i32_t>(sent_packet->get_buffer_length()));

				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("TEST: random_error(): packet_index 0x%08x:%lu, packet length changed from %lu to %lu.\n"),
					this,
					packet_index,
					sent_packet->get_data_length(),
					new_length));

				sent_packet->set_data_length(new_length);

				error_generated = true;
			}
			break;
		default:
			User::Panic(_L("EAPOL"), 1);
			break;
		}
	}

	if (error_generated == true)
	{
		sent_packet->set_is_manipulated();
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return status;
}

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

eap_status_e eapol_am_core_symbian_c::create_upper_stack()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);
	
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eapol_am_core_symbian_c::create_upper_stack()\n")));

	eap_status_e status(eap_status_ok);

	if (m_ethernet_core == 0)
	{        
		m_ethernet_core = new ethernet_core_c(m_am_tools, this, m_is_client);
		if (m_ethernet_core == 0
			|| m_ethernet_core->get_is_valid() != true)
		{
			if (m_ethernet_core != 0)
			{
				m_ethernet_core->shutdown();
				delete m_ethernet_core;
				m_ethernet_core = 0;							
			}			
			EAP_TRACE_ERROR(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("Stack creation failed.\n")));			
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);	
		}

		// Initialise upper stack
		status = m_ethernet_core->configure();
		
		if (status != eap_status_ok)
		{
			m_ethernet_core->shutdown();
			delete m_ethernet_core;
			m_ethernet_core = 0;							

			EAP_TRACE_ERROR(m_am_tools, TRACE_FLAGS_DEFAULT, (EAPL("Stack creation failed.\n")));			
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);	
		}
	}
	else
	{			
		status = eap_status_already_exists;
	}
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return status;	
}

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

eap_status_e eapol_am_core_symbian_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("eapol_am_core_symbian_c::add_rogue_ap()\n")));

	TInt err(KErrNone);
	eap_rogue_ap_entry_c* entry = 0;

	TMacAddress mac;

	TRogueType type;

	for (u32_t i = 0; i < rogue_ap_list.get_object_count(); i++)
	{
		entry = rogue_ap_list.get_object(i);

		entry->get_mac_address(mac.iMacAddress);

		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Adding rogue AP - type: %d\n"),
			entry->get_rogue_reason()));
		EAP_TRACE_DATA_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("Rogue MAC address"),
			mac.iMacAddress,
			KMacAddressLength));

		switch (entry->get_rogue_reason())
		{
		case rogue_ap_none:
			// Ignore this
			continue;
		case rogue_ap_association_failed:
			type = EInvalidAuthenticationType;
			break;
		case rogue_ap_timeout:
			type = EAuthenticationTimeout;
			break;
		case rogue_ap_challenge_to_client_failed:
			type = EChallengeFromAPFailed;
			break;
		case rogue_ap_challenge_to_ap_failed:
			type = EChallengeToAPFailed;
			break;
		default:
			// ignore others
			continue;
		}

		err = m_partner->AddRogueAP(mac, type);
		if (err != KErrNone)
		{
			break;
		}
	}
	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
	return EAP_STATUS_RETURN(m_am_tools, m_am_tools->convert_am_error_to_eapol_error(err));
}

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

void eapol_am_core_symbian_c::RetrievePSKL(TPSKEntry& entry)
{
	HBufC* sqlbuf = HBufC::NewLC(KMaxSqlQueryLength);
	TPtr sqlStatement = sqlbuf->Des();

	RDbView view;

	_LIT(KSQL, "SELECT %S, %S, %S, %S, %S FROM %S WHERE %S=%d AND %S=%d");

	sqlStatement.Format(KSQL, &KServiceType, &KServiceIndex, &KSSID, &KPassword, &KPSK,
		&KEapolPSKTableName, &KServiceType, entry.indexType, &KServiceIndex, entry.index);
		
	User::LeaveIfError(view.Prepare(m_database, TDbQuery(sqlStatement), TDbWindow::EUnlimited));
	CleanupClosePushL(view);
	User::LeaveIfError(view.EvaluateAll());	

	TInt rows = view.CountL();
	
	if (rows == 0)
	{
		// No saved PSK
		User::Leave(KErrNotFound);
	}
	view.FirstL();
	view.GetL();

	entry.ssid.Copy(view.ColDes8(3));
	entry.password.Copy(view.ColDes8(4));
	entry.psk.Copy(view.ColDes8(5));

	CleanupStack::PopAndDestroy(2); // view, buf
}

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

void eapol_am_core_symbian_c::SavePSKL(TPSKEntry& entry)
{
	// Connect to CommDBif so that we can delete PSK entries that have no IAP associated anymore.
	CWLanSettings* wlan = new(ELeave) CWLanSettings;
	CleanupStack::PushL(wlan);
	
	SWLANSettings wlanSettings;

	if (wlan->Connect() != KErrNone)
	{
		// Could not connect to CommDB			
		User::Leave(KErrCouldNotConnect);
	}

	HBufC* sqlbuf = HBufC::NewLC(KMaxSqlQueryLength);
	TPtr sqlStatement = sqlbuf->Des();

	RDbView view;

	_LIT(KSQL, "SELECT %S, %S, %S, %S, %S FROM %S");
	
	sqlStatement.Format(KSQL, &KServiceType, &KServiceIndex, &KSSID, &KPassword, &KPSK,
		&KEapolPSKTableName);

	User::LeaveIfError(view.Prepare(m_database, TDbQuery(sqlStatement), TDbWindow::EUnlimited));	
	CleanupClosePushL(view);
	User::LeaveIfError(view.EvaluateAll());

	// Get column set so we get the correct column numbers
	CDbColSet* colSet = view.ColSetL();		
	CleanupStack::PushL(colSet);

	// Delete old row and also rows that have no associated IAP settings.
	if (view.FirstL())
	{		
		do {
			view.GetL();

			if ((wlan->GetWlanSettingsForService(view.ColUint32(colSet->ColNo(KServiceIndex)), wlanSettings) != KErrNone)
				|| (view.ColUint32(colSet->ColNo(KServiceType)) == static_cast<TUint>(entry.indexType)
					&& view.ColUint32(colSet->ColNo(KServiceIndex)) == static_cast<TUint>(entry.index)))
			{	
				// Not found or current IAP
				view.DeleteL();	
			}
			
		} while (view.NextL() != EFalse);
	}

	wlan->Disconnect();
		
	view.InsertL();
	
	view.SetColL(colSet->ColNo(KServiceType), (TUint)entry.indexType);
	view.SetColL(colSet->ColNo(KServiceIndex), (TUint)entry.index);
	view.SetColL(colSet->ColNo(KSSID), entry.ssid);
	view.SetColL(colSet->ColNo(KPassword), entry.password);
	view.SetColL(colSet->ColNo(KPSK), entry.psk);	
		
	view.PutL();
	
	CleanupStack::PopAndDestroy( colSet ); // Delete colSet.	

	CleanupStack::PopAndDestroy(3); // CWLanSettings, session, database

}

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


// End of file
