/*
* Copyright (c) 2005-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:  CEapVpnInterfaceImplementation
*
*/

/*
* %version: 38.1.5 %
*/

// INCLUDE FILES
#include <w32std.h>
#include <pathinfo.h>

#include "eap_vpn_if_implementation.h"
#include "eap_am_memory.h"
#include "eap_tools.h"
#include "eap_type_all.h"
#include "eap_am_tools_symbian.h"
#include "eap_crypto_api.h"
#include "eap_type_gsmsim.h"
#include "eap_type_aka.h"
#include "eap_header_string.h"
#include "EapolDbDefaults.h"
#include "EapolDbParameterNames.h"
#include "eap_am_file_input_symbian.h"
#include "abs_eap_vpn_if.h"
#include "eap_array_algorithms.h"

#include "EapSimDbDefaults.h"

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

#ifndef USE_EAP_EXPANDED_TYPES

static const TUint KMaxEapCueLength = 3;

#endif //#ifndef USE_EAP_EXPANDED_TYPES

#define KEapIdentityOffset 5
const eap_const_string EAPPLUGIN_TRACE_FILE = EAPL("logs\\eapol\\eap_vpn_if.txt");

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,
};

// ================= MEMBER FUNCTIONS =======================
// Create instance of concrete ECOM interface implementation
CEapVpnInterfaceImplementation* CEapVpnInterfaceImplementation::NewL(TAbsEapVpnInterfaceParams* aParams)
{
	CEapVpnInterfaceImplementation* self = new (ELeave) CEapVpnInterfaceImplementation;
	CleanupStack::PushL(self);
	self->ConstructL(aParams->iCaller, aParams->iClient);

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

	CleanupStack::Pop();
	return self;
}

	
//--------------------------------------------------
// Constructor
//--------------------------------------------------

/// VPN does not have any IAP setting at all but we use index 1 in the EAP databases
/// for all VPN related settings.
const TInt EAP_VPN_DEFAULT_SERVICE_TABLE_INDEX = 1; 

CEapVpnInterfaceImplementation::CEapVpnInterfaceImplementation()
: m_trace_log_file_name(0)
, m_is_client(true)
#ifdef USE_EAP_EXPANDED_TYPES
, m_eap_type_array(0)
#endif //#ifdef USE_EAP_EXPANDED_TYPES
, m_index_type(EVpn)
, m_index(EAP_VPN_DEFAULT_SERVICE_TABLE_INDEX)
{
}
	
//--------------------------------------------------
// Second phase construction.
//--------------------------------------------------
void CEapVpnInterfaceImplementation::ConstructL(MAbsEapVpnInterface* aCaller, TBool aClient)
{
    EAP_TRACE_DEBUG(
        m_am_tools,
        TRACE_FLAGS_DEFAULT,
        (EAPL("CEapVpnInterfaceImplementation::ConstructL()\n")));

	iCaller = aCaller;
	if(aClient)
	{
		m_is_client = true;
	}
	else
	{
		m_is_client = false;
	}

	if (iCaller == 0)
	{
		User::Leave(KErrGeneral);
	}

	// Create tools class
	m_am_tools = new(ELeave) eap_am_tools_symbian_c(0);

	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);
	}


	{
		TFileName drivePath( PathInfo::MemoryCardRootPath() );

		const TInt MAXPATHNAME=256ul;

		HBufC* buf = HBufC::NewLC(MAXPATHNAME);
		TPtr pathbuffer = buf->Des();

		pathbuffer.Append( TParsePtrC( drivePath ).DriveAndPath() );

		{
			eap_variable_data_c unicode_drivepath(m_am_tools);
			if (unicode_drivepath.get_is_valid() == false)
			{
				(void) EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
				User::Leave(KErrGeneral);
			}

			eap_status_e status = unicode_drivepath.set_buffer(pathbuffer.Ptr(), pathbuffer.Length(), false, false);
			if (status != eap_status_ok)
			{
				(void) EAP_STATUS_RETURN(m_am_tools, status);
				User::Leave(KErrGeneral);
			}

			eap_variable_data_c utf8_drivepath(m_am_tools);
			if (utf8_drivepath.get_is_valid() == false)
			{
				(void) EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
				User::Leave(KErrGeneral);
			}

			status = m_am_tools->convert_unicode_to_utf8(
				utf8_drivepath,
				unicode_drivepath);
			if (status != eap_status_ok)
			{
				(void) EAP_STATUS_RETURN(m_am_tools, status);
				User::Leave(KErrGeneral);
			}

			delete m_trace_log_file_name;
			m_trace_log_file_name = new eap_variable_data_c(m_am_tools);

			if (m_trace_log_file_name == 0
				|| m_trace_log_file_name->get_is_valid() == false)
			{
				(void) EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
				User::Leave(KErrGeneral);
			}

			status = m_trace_log_file_name->set_copy_of_buffer(&utf8_drivepath);
			if (status != eap_status_ok)
			{
				(void) EAP_STATUS_RETURN(m_am_tools, status);
				User::Leave(KErrGeneral);
			}

			status = m_trace_log_file_name->add_data(EAPPLUGIN_TRACE_FILE, sizeof(EAPPLUGIN_TRACE_FILE)-1);
			if (status != eap_status_ok)
			{
				(void) EAP_STATUS_RETURN(m_am_tools, status);
				User::Leave(KErrGeneral);
			}

			status = m_trace_log_file_name->add_end_null();
			if (status != eap_status_ok)
			{
				(void) EAP_STATUS_RETURN(m_am_tools, status);
				User::Leave(KErrGeneral);
			}
		}

		CleanupStack::PopAndDestroy(buf); // Delete pathbuffer.
	}
    

#ifdef USE_EAP_EXPANDED_TYPES

	m_eap_type_array = new eap_array_c<eap_type_value_e>(m_am_tools);
	if (m_eap_type_array == 0)
	{
		User::Leave(KErrGeneral);
	}

#endif //#ifdef USE_EAP_EXPANDED_TYPES


    //------ Create network id
	{
		EAP_TRACE_DEBUG(
    		m_am_tools,
    		TRACE_FLAGS_DEFAULT,
    		(EAPL("CEapVpnInterfaceImplementation: Create network ID\n")));

		u32_t NWID_SRC = 0;
		u32_t NWID_DEST = 1;
		const u16_t EAP_DUMMY_PACKET_TYPE = 1;

		m_receive_network_id = new eap_am_network_id_c(
			m_am_tools);

		if (m_receive_network_id == NULL
			|| m_receive_network_id->get_is_valid() != true)
		{
			delete m_receive_network_id;
			m_receive_network_id = 0;
			User::Leave(KErrGeneral);
		}

		eap_status_e status = m_receive_network_id->set_copy_of_am_network_id(
			&NWID_SRC,
			sizeof(NWID_SRC),
			&NWID_DEST,
			sizeof(NWID_DEST),
			EAP_DUMMY_PACKET_TYPE);
		if (status != eap_status_ok)
		{
			delete m_receive_network_id;
			m_receive_network_id = 0;
			User::Leave(KErrGeneral);
		}
	}


    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_functions
		| eap_am_tools_c::eap_trace_mask_error
		| eap_am_tools_c::eap_trace_mask_message_data);

    
#if !defined(USE_EAP_RDEBUG_TRACE)
	{
		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)
		{
			(void) m_am_tools->set_trace_file_name(&trace_output_file);
		}
	}
#endif //#if defined(USE_EAP_RDEBUG_TRACE)

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation: configure\n")));

	if (configure() != eap_status_ok)
	{
		User::Leave(KErrGeneral);
	}

	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("Configured EAPPlugin...\n")));

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

	set_is_valid();
}


//--------------------------------------------------
// Destructor    
//--------------------------------------------------

CEapVpnInterfaceImplementation::~CEapVpnInterfaceImplementation()
{
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::~CEapVpnInterfaceImplementation() - destructor\n")));

	delete m_trace_log_file_name;
	m_trace_log_file_name = 0;

	shutdown();
}


    
//--------------------------------------------------
// Shutdown()
//--------------------------------------------------
eap_status_e CEapVpnInterfaceImplementation::shutdown()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation: Shutdown called\n")));

	// Cancel timer	
	cancel_all_timers();

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

	// 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\n"),
			m_successful_authentications,
			m_failed_authentications));	
	}
	else
	{
		EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_ALWAYS|TRACE_TEST_VECTORS,
			(EAPL("server authentication SUCCESS %d, FAILED %d\n"),
			m_successful_authentications,
			m_failed_authentications));
	}	

	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("EAPPlugin EXITING.\n")));

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	

	if(m_receive_network_id != 0)
	{
		delete m_receive_network_id;
	}

	// Unload all loaded plugins
	for(int i = 0; i < m_plugin_if_array.Count(); i++)
	{
		delete m_plugin_if_array[i];
	}

	m_plugin_if_array.Close();

#ifdef USE_EAP_EXPANDED_TYPES

	m_enabled_expanded_eap_array.ResetAndDestroy();

	m_disabled_expanded_eap_array.ResetAndDestroy();
	
	m_eap_type_array->reset();

	delete m_eap_type_array;
	m_eap_type_array = 0;

#else // For normal EAP type.

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

	m_eap_type_array.Close();

#endif //#ifdef USE_EAP_EXPANDED_TYPES

	delete iManualUsername;
	iManualUsername = NULL;

	delete iManualRealm;
	iManualRealm = NULL;

	delete iRealmPrefix;
	iRealmPrefix = NULL;

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

	return eap_status_ok;
}
    


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

//
void CEapVpnInterfaceImplementation::RunL()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation: 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_stack_marked_to_be_deleted = true;
	set_timer(this, EAPOL_AM_CORE_TIMER_DELETE_STACK_ID, 0, 0);

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

	iCaller->EapIndication(EFailedCompletely);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
}

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

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

	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eap_vpn_if::DoCancel()\n")));

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);	
}

    
//--------------------------------------------------
// Configure()        
//--------------------------------------------------

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

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

	{		
		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 = (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;
}

    
//----------------------------------------------------------        
// Implementations of virtual functions from CEapVpnInterface
//----------------------------------------------------------

/**
 * Function:    EapConfigure
 *
 * Description: Configures the eap plugin
 *
 * @param       aManualUsername The username, if not zero
 * @param       aManualRealm The realm, if not zero
 * @param       aManualRealmPrefix The realm prefix, if not zero
 * @param       aHideInitialIdentity Scramble username, if true
 *
 */
TInt CEapVpnInterfaceImplementation::EapConfigure(
	TDesC8& aManualUsername,
	TDesC8& aManualRealm,
	TDesC8& aRealmPrefix,
	TBool aHideInitialIdentity)
{
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::EapConfigure()\n")));

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::EapConfigure(): aManualUsername\n"),
		aManualUsername.Ptr(),
		aManualUsername.Size()));

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::EapConfigure(): aManualRealm\n"),
		aManualRealm.Ptr(),
		aManualRealm.Size()));

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::EapConfigure(): aRealmPrefix\n"),
		aRealmPrefix.Ptr(),
		aRealmPrefix.Size()));

	iHideInitialIdentity = aHideInitialIdentity;

	delete iManualUsername;
	iManualUsername = NULL;

	delete iManualRealm;
	iManualRealm = NULL;

	delete iRealmPrefix;
	iRealmPrefix = NULL;

	TRAPD(error,
		iManualUsername = aManualUsername.AllocL();
		iManualRealm = aManualRealm.AllocL();
		iRealmPrefix = aRealmPrefix.AllocL();
		);

	if (error != KErrNone)
	{
		EAP_TRACE_ERROR(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("CEapVpnInterfaceImplementation::EapConfigure(): error = %d\n"),
			error));
		return error;
	}

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::EapConfigure(): iManualUsername\n"),
		iManualUsername->Ptr(),
		iManualUsername->Size()));

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::EapConfigure(): iManualRealm\n"),
		iManualRealm->Ptr(),
		iManualRealm->Size()));

	EAP_TRACE_DATA_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::EapConfigure(): iRealmPrefix\n"),
		iRealmPrefix->Ptr(),
		iRealmPrefix->Size()));

	return KErrNone;
}

    
/**
 * Function:    StartL
 *
 * Description: Initializes the eap plugin
 *
 */
TInt CEapVpnInterfaceImplementation::StartL(const TUint8 aEapType)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::StartL()\n")));

	eap_status_e status(eap_status_ok);
	iQueryIdentity = EFalse;

	iRequestedEapType = static_cast<eap_type_ietf_values_e>(aEapType);

	if (iEapCore != 0)
	{
		EAP_TRACE_ALWAYS(
			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("eap_vpn_if::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
		iEapCore->shutdown();
		delete iEapCore;
		iEapCore = 0;				

		m_stack_marked_to_be_deleted = false;
	}

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

#ifdef USE_EAP_EXPANDED_TYPES

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

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

		RImplInfoPtrArray eapArray;
		CleanupStack::PushL( TCleanupItem( CleanupImplArray, &eapArray ) );

		REComSession::ListImplementationsL(KEapTypeInterfaceUid, eapArray);

		for (TInt i = 0; i < eapArray.Count(); i++)
		{
			SEapExpandedType * expandedEAPType = new (ELeave) SEapExpandedType;
			expandedEAPType->EapExpandedType = eapArray[i]->DataType();
					
			eap_expanded_type_c tmpExpEAPType;
			
			// This is to make the tmpExpEAPType in 8 byte string with correct vendor type and vendor id details.
			status = eap_expanded_type_c::read_type(m_am_tools,
													0, // index should be zero here.
													expandedEAPType->EapExpandedType.Ptr(),
													KExpandedEapTypeSize,
													&tmpExpEAPType);
			if (status != eap_status_ok)
			{
				delete expandedEAPType;
				expandedEAPType = 0;

				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("CEapVpnInterfaceImplementation::StartL: eap_expanded_type_c::write_type failed \n")));
			
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}
			
			// Now add the EAP types to the array
			if(tmpExpEAPType == iRequestedEapType)
			{
				// This is the requested EAP type.
				
				EAP_TRACE_DATA_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("CEapVpnInterfaceImplementation::StartL:Enabled (Requested) EAP type:"),
					expandedEAPType->EapExpandedType.Ptr(),
					expandedEAPType->EapExpandedType.Size()));
			
				m_enabled_expanded_eap_array.Insert(expandedEAPType, 0); // This goes to the beginning.
			}
			else
			{
				EAP_TRACE_DATA_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("CEapVpnInterfaceImplementation::StartL:Disabled EAP type:"),
					expandedEAPType->EapExpandedType.Ptr(),
					expandedEAPType->EapExpandedType.Size()));

				delete expandedEAPType;
				expandedEAPType = 0;

			}
		} // for()

		CleanupStack::PopAndDestroy(&eapArray);
	}

#else // For normal EAP type.

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

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

		RImplInfoPtrArray eapArray;
		CleanupStack::PushL( TCleanupItem( CleanupImplArray, &eapArray ) );

		REComSession::ListImplementationsL(KEapTypeInterfaceUid, eapArray);

		for (TInt i = 0; i < eapArray.Count(); i++)
		{
			TEap *eap = new(ELeave) TEap;
			eap->UID.Copy(eapArray[i]->DataType());
			eap->Enabled = EFalse;

			// Convert the string to integer
			TLex8 tmp(eap->UID);
			TInt val(0);
			tmp.Val(val);

			if(val == iRequestedEapType)
			{
				eap->Enabled = ETrue;

				EAP_TRACE_ALWAYS(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("EAP-Type %d enabled\n"), val));

				m_iap_eap_array.Insert(eap, 0);
			}
			else
			{
				m_iap_eap_array.Append(eap);

				EAP_TRACE_ALWAYS(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("EAP-Type %d disabled\n"), val));
			}
		} // for()

		CleanupStack::PopAndDestroy(&eapArray);
	}

#endif //#ifdef USE_EAP_EXPANDED_TYPES

	CompleteAssociation(status);

	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 CEapVpnInterfaceImplementation::CompleteAssociation(
		const TInt aResult
		)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::CompleteAssociation(): aResult=%d\n"),
		aResult));

	eap_status_e status(eap_status_ok);

	// ASSOCIATION UNSUCCESSFUL
	if (aResult != KErrNone)
	{
		EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("CompleteAssociation: Unsuccessful.\n")));
			iCaller->EapIndication(EFailedCompletely);
		return KErrNone;
	}

	// ASSOCIATION SUCCESSFUL
	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_ALWAYS|TRACE_FLAGS_DEFAULT,
		(EAPL("CompleteAssociation: Successful.\n")));

	// 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 VPN: EFailedCompletely.\n")));

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

	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));
}

/**
 * Function:    QueryIdentity
 *
 * Description: Ask the identity
 *
 * @param       aType name of requested eap type implementation.
 */
TInt CEapVpnInterfaceImplementation::QueryIdentity()
{
	// Build Eap Identity reques message
	// and send it to eap_core.
	// Eap core determines the identity and
	// responses with packet_send() callback
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::QueryIdentity()\n")));

	// Build identity request only if GSM/SIM or AKA
	if((iRequestedEapType != eap_type_gsmsim) && (iRequestedEapType != eap_type_aka))
	{
		TRAPD(error, (iCaller->EapIdentityResponseL(NULL)));
		if(error != KErrNone)
		{
			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(error));				
		}
		return m_am_tools->convert_eapol_error_to_am_error(EAP_STATUS_RETURN(m_am_tools, eap_status_ok));
	}

	iQueryIdentity = ETrue;
	eap_status_e status(eap_status_ok);

	status = send_eap_identity_request();

	if(status == eap_status_pending_request)
	{
		// Request pending, it's OK
		status = eap_status_ok;
	}

	if(status != eap_status_ok)
	{
		EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("eap_vpn_if::QueryIdentity() error, status = %d\n"), status));

		iQueryIdentity = EFalse;
	}

	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));
}

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

//
eap_status_e CEapVpnInterfaceImplementation::send_eap_identity_request()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

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

	eap_status_e status = eap_status_process_general_error;

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::send_eap_identity_request()\n")));

	// Creates a identity request message.
	eap_buf_chain_wr_c request_packet(
		eap_write_buffer, 
		m_am_tools, 
		EAP_CORE_PACKET_BUFFER_LENGTH);

	if (request_packet.get_is_valid() == false)
	{
		EAP_TRACE_ERROR(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("send_eap_identity_request(): %s, %s, packet buffer corrupted.\n"),
			(m_is_client == true) ? "client": "server"
			));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
	}

	u32_t buffer_size = EAP_CORE_PACKET_BUFFER_LENGTH;

	eap_header_wr_c eap_request(
		m_am_tools,
		request_packet.get_data_offset(0, buffer_size),
		buffer_size);

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

	eap_request.set_length((u16_t)(EAP_CORE_PACKET_BUFFER_LENGTH), true);
	eap_request.set_code(eap_code_request);
	eap_request.set_identifier(0);
	eap_request.set_type_data_length(0u, false);
	eap_request.set_type(eap_type_identity, false);

	EAP_ASSERT(eap_request.get_length() >= 4);

	status = iEapCore->packet_process(
		m_receive_network_id,
		&eap_request,
		eap_request.get_length());

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::send_identity_request(): iEapCore->packet_process() = %d\n"), status));
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

	return EAP_STATUS_RETURN(m_am_tools, status);
}


/**
 * Function:    EapInbound
 *
 * Description: Handle incoming eap message.
 *
 * @param       aMessage incoming eap message.
 *              
 */
TInt CEapVpnInterfaceImplementation::EapInbound(const TDesC8& aMessage)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);	

	// from eapol_am_core_symbian.cpp ReceivePacket
	iQueryIdentity = EFalse;
	eap_status_e status(eap_status_ok);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::EapInbound()\n")));

	TInt length = aMessage.Length();
	if (length < 4)
	{
		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));
	}

	// Creates a identity request message.
	eap_buf_chain_wr_c request_packet(
		eap_write_buffer, 
		m_am_tools, 
		aMessage.Length());

	request_packet.add_data(aMessage.Ptr(), aMessage.Length());

	eap_header_wr_c eap_request(
		m_am_tools,
		request_packet.get_data_offset(0, aMessage.Length()),
		aMessage.Length());

	// Forward the packet to the Eap layer of the EAPOL stack. Ignore return value. Failure is signalled using state_notification.
	status = iEapCore->packet_process(
		m_receive_network_id,
		&eap_request,
		length);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::iEapCore->packet_process() = %d\n"), status));

	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));
}

//--------------------------------------------------
// create_upper_stack
//--------------------------------------------------
eap_status_e CEapVpnInterfaceImplementation::create_upper_stack()
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::create_upper_stack()\n")));

	eap_status_e status(eap_status_ok);

	if (iEapCore == 0)
	{        
		iEapCore = new eap_core_c(m_am_tools, this, m_is_client, m_receive_network_id, EFalse);

		if (iEapCore == 0
			|| iEapCore->get_is_valid() != true)
		{
			if (iEapCore != 0)
			{
				iEapCore->shutdown();
				delete iEapCore;
				iEapCore = 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 = iEapCore->configure();

		if (status != eap_status_ok)
		{
			iEapCore->shutdown();
			delete iEapCore;
			iEapCore = 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;	
}


// Virtual callback function implementations, called by the eap_core

/**
 * The derived class could send packets to partner class with this function.
 * @see abs_eap_base_type_c::packet_send().
 */
eap_status_e CEapVpnInterfaceImplementation::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("CEapVpnInterfaceImplementation::packet_send(data_length=%d)\n"),
		data_length));

	if (header_offset != 0u)
	{
		EAP_TRACE_ALWAYS(
			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_ALWAYS(
			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_ALWAYS(
			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;
	}

	eap_header_wr_c eap(
		m_am_tools,
		sent_packet->get_data_offset(
			header_offset, data_length),
			data_length);

	TInt status(KErrNone);
	if (status == KErrNone)
	{
		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.
		HBufC8* eapData = NULL;
		TInt error = KErrNone;

		if(iQueryIdentity)
		{
			TPtr8 eapPtr(packet_data + KEapIdentityOffset, data_length - KEapIdentityOffset, data_length - KEapIdentityOffset);
			TRAP(error, eapData = eapPtr.Alloc());
		}
		else
		{
			TPtr8 eapPtr(packet_data, data_length, data_length);
			TRAP(error, eapData = eapPtr.Alloc());
		}

		if(error != KErrNone)
		{
			EAP_TRACE_ALWAYS(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Allocation error\n")));
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
		}

		if(iQueryIdentity)
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("CEapVpnInterfaceImplementation::EapIdentityResponseL()\n")));

			TRAPD(error, (iCaller->EapIdentityResponseL(eapData)));
			if(error != KErrNone)
			{
				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(error));				
			}

			iQueryIdentity = EFalse;
		}
		else
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("CEapVpnInterfaceImplementation::EapOutboundL()\n")));

			TRAPD(error, (iCaller->EapOutboundL(eapData)));
			if(error != KErrNone)
			{
				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(error));				
			}
		}
		++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));
}


/**
 * The get_header_offset() function obtains the header offset of EAP-packet.
 * @see abs_eap_base_type_c::get_header_offset().
 */
u32_t CEapVpnInterfaceImplementation::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;
}

/**
 * The load_module() function function indicates the lower level to
 * load new module of EAP-type.
 * @param type is the requested EAP-type.
 * @param partner is pointer to the caller object.
 * The partner of the new created EAP-type object is the caller object.
 * @param eap_type is a pointer to a pointer of EAP-type object.
 * Adaptation module sets eap_type pointer to created EAP-type object.
 * @param is_client_when_true parameter indicates whether the network entity should
 * act as a client (true) or server (false), in terms of EAP-protocol whether
 * this network entity is EAP-supplicant (true) or EAP-authenticator (false).
 * @param receive_network_id includes the addresses (network identity) and packet type.
 */
eap_status_e CEapVpnInterfaceImplementation::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("CEapVpnInterfaceImplementation::load_module()\n")));

	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eap_vpn_if::load_module(type %d=%s, tunneling_type %d=%s)\n"),
		convert_eap_type_to_u32_t(type),
		eap_header_string_c::get_eap_type_string(type),
		convert_eap_type_to_u32_t(tunneling_type),
		eap_header_string_c::get_eap_type_string(tunneling_type)));

	EAP_UNREFERENCED_PARAMETER(type);
	EAP_UNREFERENCED_PARAMETER(tunneling_type);

	eap_status_e status = eap_status_process_general_error;

	if (type != iRequestedEapType)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("load_module: eap_expanded_type_c::write_type(): not supported EAP-method\n")));
	
		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_eap_type);
	}

	EAP_ASSERT_TOOLS(m_am_tools, (type == iRequestedEapType));

#ifdef USE_EAP_EXPANDED_TYPES

		TBuf8<KExpandedEapTypeSize> cue;
		
		// Some indirect way of forming the 8 byte string of an EAP type for the cue is needed here.		
		TUint8 tmpExpCue[KExpandedEapTypeSize];

		// This is to make the tmpExpCue in 8 byte string with correct vendor type and vendor id details.
		status = eap_expanded_type_c::write_type(m_am_tools,
												0, // index should be zero here.
												tmpExpCue,
												KExpandedEapTypeSize,
												true,
												iRequestedEapType);
		if (status != eap_status_ok)
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("load_module: eap_expanded_type_c::write_type failed \n")));
		
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}
		
		// Now copy the 8 byte string to the real expanded cue.
		cue.Copy(tmpExpCue, KExpandedEapTypeSize);

		EAP_TRACE_DATA_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("EAPOL:CEapVpnInterfaceImplementation::load_module: Expanded CUE:"),
			cue.Ptr(),
			cue.Size()));

#else

	TBuf8<KMaxEapCueLength> cue;
	cue.Num(static_cast<TInt>(iRequestedEapType));

#endif //#ifdef USE_EAP_EXPANDED_TYPES

	CEapType* eapType = 0;
	TInt error(KErrNone);

#ifdef USE_EAP_EXPANDED_TYPES

	// Check if this EAP type has already been loaded
	TInt eapArrayIndex = find<eap_type_value_e>(
		m_eap_type_array,
		&iRequestedEapType,
		m_am_tools);

	if (eapArrayIndex >= 0)

#else // For normal EAP type.

	// Check if this EAP type has already been loaded
	TInt eapArrayIndex = m_eap_type_array.Find(iRequestedEapType);

	if (eapArrayIndex != KErrNotFound)

#endif

	{
		// Yep. It was loaded already.
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("CEapVpnInterfaceImplementation: EAP Type Already loaded\n")));

		eapType = m_plugin_if_array[eapArrayIndex];		
	}
	else 
	{
		// We must have a trap here since the EAP core knows nothing about Symbian.
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("CEapVpnInterfaceImplementation: EAP Type new\n")));

		TRAP(error, (eapType = CEapType::NewL(cue, m_index_type, m_index)));	

		if (error != KErrNone
			|| eapType == 0)
		{
			// Interface not found or implementation creation function failed
			
			delete eapType;
			eapType = 0;
			
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("CEapVpnInterfaceImplementation: EAP Type new, unable to load\n")));
			EAP_TRACE_ALWAYS(
				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 values for realm and user name if there is any.
	// If there is no values the default settings will be used( automatic realm and username).


	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("CEapVpnInterfaceImplementation::load_module - About to configure manual/auto username and manual/auto realm \n")));
	
	    EAPSettings* setSettings = new EAPSettings;
		if( setSettings == NULL )     
		{
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("CEapVpnInterfaceImplementation::load_module - EAPSettings allocation error \n")));
	    	
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);				
		}
	    
		if(iRequestedEapType == eap_type_aka)
		{
			setSettings->iEAPType = EAPSettings::EEapAka;
			
		}
		else if(iRequestedEapType == eap_type_gsmsim)
		{
			setSettings->iEAPType = EAPSettings::EEapSim;
		}
		else
		{
			delete setSettings;
			setSettings = 0;

			// Only EAP-SIM and AKA are possible now.
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_eap_type);
		}
	    
	    if(iManualUsername && iManualUsername->Length() != 0)
	    {
    		setSettings->iUsernamePresent = EGSMSIMUseManualUsernameYes; // Same value for both SIM and AKA.
	    	setSettings->iUsername.Copy(iManualUsername->Des());
	    }
	    else
	    {
	    	// No user name. we have to set automatic now.
	    	setSettings->iUsernamePresent = EGSMSIMUseManualUsernameNo; // Same value for both SIM and AKA.
	    }
	    
	    if(iManualRealm && iManualRealm->Length() != 0)
	    {
	    	setSettings->iRealmPresent = EGSMSIMUseManualRealmYes; // Same value for both SIM and AKA.
	    	setSettings->iRealm.Copy(iManualRealm->Des());
	    }
	    else
	    {
	    	// No realm. we have to set automatic now.
	    	setSettings->iRealmPresent = EGSMSIMUseManualRealmNo; // Same value for both SIM and AKA.
	    }    
	    
		TRAP(error, eapType->SetConfigurationL(*setSettings) );
	    if ( error != KErrNone )
	    {
			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("CEapVpnInterfaceImplementation::load_module - Setting Manual Username and Realm failed.error=%d, Continuing \n")));
	    }
	    
	    delete setSettings;
	    setSettings = 0;    
	}
    
	//--------------------------------------------------------
	//--------------------------------------------------------
	
	// Create the EAP protocol interface implementation.
	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation: EAP Type new, GetStackInterfaceL()\n")));

#ifdef USE_EAP_SIMPLE_CONFIG

	TRAP(error, (*eap_type_if = eapType->GetStackInterfaceL(
		m_am_tools, 
		partner, 
		is_client_when_true, 
		receive_network_id,
		0))); // Check this up.

#else

	TRAP(error, (*eap_type_if = eapType->GetStackInterfaceL(
		m_am_tools, 
		partner, 
		is_client_when_true, 
		receive_network_id)));

#endif // #ifdef USE_EAP_SIMPLE_CONFIG

	if (error != KErrNone 
		|| *eap_type_if == 0 
		|| (*eap_type_if)->get_is_valid() == false)
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("CEapVpnInterfaceImplementation: EAP Type new, GetStackInterfaceL(), failed = %d\n"), error));

		EAP_TRACE_ALWAYS(
			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((eap_type_value_e)iRequestedEapType);
		}
		// Note: even in error cases eap_core_c deletes eap_type_if
	}
	else
	{
		EAP_TRACE_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("CEapVpnInterfaceImplementation: EAP Type new, GetStackInterfaceL(), success\n")));

		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);				
			}

#ifdef USE_EAP_EXPANDED_TYPES

			eap_type_value_e * tmpEAPType = new eap_type_value_e();
			if(tmpEAPType == NULL)
			{
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("eapol_am_wlan_authentication_symbian_c::load_module() eap_type_value_e creation failed\n")));
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);				
			}
			
			*tmpEAPType = type;
			
			status = m_eap_type_array->add_object(tmpEAPType, true);
			
			if (status != eap_status_ok)			

#else // For normal EAP type.			

			if (m_eap_type_array.Append(iRequestedEapType) != KErrNone)

#endif
			{
				// 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);
}

/**
 * The unload_module() function unloads the module of a EAP-type. 
 * @param eap_type is the requested EAP-type.
 */
eap_status_e CEapVpnInterfaceImplementation::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);

#ifdef USE_EAP_EXPANDED_TYPES

	// Check if this EAP type has already been loaded
	TInt index = find<eap_type_value_e>(
		m_eap_type_array,
		&type,
		m_am_tools);
		
	if (index >= 0)
	{
		// EAP was loaded before.
		
		delete m_plugin_if_array[index];
		m_plugin_if_array.Remove(index);
		
		status = m_eap_type_array->remove_object(index);
	}

#else // For normal EAP types.

	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;			
	}

#endif

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

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

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

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

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

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

/**
 * Note this function is just an example. Parameters will change later.
 * The packet_data_crypto_keys() function gives the generated keys to lower level.
 * After EAP-authentication has generated the keys it calls this function
 * to offer the keys to lower level.
 * @see abs_eap_base_type_c::packet_data_crypto_keys().
 */
eap_status_e CEapVpnInterfaceImplementation::packet_data_crypto_keys(
    const eap_am_network_id_c * const /*send_network_id*/,
    const eap_master_session_key_c * const master_session_key
    )
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	HBufC8* sharedKey = NULL;
	TPtr8 keyPtr(
		master_session_key->get_data(
			master_session_key->get_data_length()/2),
		master_session_key->get_data_length()/2,
		master_session_key->get_data_length()/2);

	TRAPD(error, (sharedKey = keyPtr.AllocL()));
	if(error != KErrNone)
	{
		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("CEapVpnInterfaceImplementation: EapSharedKeyL()\n")));

	TRAP(error, (iCaller->EapSharedKeyL(sharedKey)));
	if(error != KErrNone)
	{
		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(error));				
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return eap_status_ok;
}

/**
 * The packet_data_session_key() function passes one traffic encryption key to 
 * the lower layers. Ultimately the key can end up to the WLAN hardware.
 * @param send_network_id carries the addresses (network identity) and type of the packet.
 * @param key is the encryption key
 * @param key_length is the length of the key
 * @param key_type describes the type of the key (WEP or something else...)
 * @param key_index is the index of the encryption key (there can be four broadcast keys in WEP for example)
 */
eap_status_e CEapVpnInterfaceImplementation::packet_data_session_key(
    const eap_am_network_id_c * const /*send_network_id*/,
    const eapol_session_key_c * const /*key*/
    )
{
	// Not used, but might be called?
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);
	TInt status(KErrNone);

	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));
}

/**
 * The read_configure() function reads the configuration data identified
 * by the field string of field_length bytes length. Adaptation module must direct
 * the query to some persistent store.
 * @see abs_eap_base_type_c::read_configure().
 */
eap_status_e CEapVpnInterfaceImplementation::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);
	EAP_ASSERT_ALWAYS(field->get_field_length() <= KMaxConfigStringLength);

	EAP_UNREFERENCED_PARAMETER(KMaxConfigStringLength);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::read_configure()\n")));

	eap_status_e status(eap_status_ok);

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


	// Check if the wanted parameter is default type

	{
		eap_variable_data_c wanted_field(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;
		}


		if (wanted_field.compare(
		cf_str_EAP_default_type_u32_t.get_field()->get_field(),
		cf_str_EAP_default_type_u32_t.get_field()->get_field_length()) == 0
		|| wanted_field.compare(
		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()) == 0)
		{
			// We need to return here the next EAP type we should try
			
#ifdef USE_EAP_EXPANDED_TYPES

			if(m_enabled_expanded_eap_array.Count() < 1)
			{
				// No enabled EAP types.
				
				// 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);				
			}

			// Now there are enabled EAP type, we need to take the first EAP type from the arrary.
			SEapExpandedType * expandedEAPType = m_enabled_expanded_eap_array[0]; //First item.
			
			status = data->set_copy_of_buffer(expandedEAPType->EapExpandedType.Ptr(), KExpandedEapTypeSize);
			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);			
			}
			
			// This is to check if this is the requested EAP type.
			
			eap_expanded_type_c tmpExpEAPType;
			
			// This is to make the tmpExpEAPType in 8 byte string with correct vendor type and vendor id details.
			status = eap_expanded_type_c::read_type(m_am_tools,
													0, // index should be zero here.
													expandedEAPType->EapExpandedType.Ptr(),
													KExpandedEapTypeSize,
													&tmpExpEAPType);
			if (status != eap_status_ok)
			{
				EAP_TRACE_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("CEapVpnInterfaceImplementation::read_configure: eap_expanded_type_c::write_type failed \n")));
			
				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
				return EAP_STATUS_RETURN(m_am_tools, status);
			}
			
			if(tmpExpEAPType == iRequestedEapType)
			{			
				EAP_TRACE_DATA_DEBUG(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("CEapVpnInterfaceImplementation::StartL:Trying EAP type:"),
					expandedEAPType->EapExpandedType.Ptr(),
					expandedEAPType->EapExpandedType.Size()));
			}							

#else // For normal EAP types
		
			TInt i; 	

			for (i = 0; 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((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);			
					}

					if(val == iRequestedEapType)
					{
						EAP_TRACE_ALWAYS(
							m_am_tools,
							TRACE_FLAGS_DEFAULT,
							(EAPL("EAPOL: Trying EAP type: %d.\n"), val));
						break;
					}
					else
					{
						continue;
					}
				}
			} // for()

			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);
			}

#endif //#ifdef USE_EAP_EXPANDED_TYPES

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else if (wanted_field.compare(
				cf_str_EAP_GSMSIM_UMA_profile.get_field()->get_field(),
				cf_str_EAP_GSMSIM_UMA_profile.get_field()->get_field_length()) == 0
			|| wanted_field.compare(
					cf_str_EAP_AKA_UMA_profile.get_field()->get_field(),
					cf_str_EAP_AKA_UMA_profile.get_field()->get_field_length()) == 0)
		{
			// Set uma profile of EAP-SIM and EAP-AKA.
			TInt val(1);
			status = data->set_copy_of_buffer((u8_t*) &val, sizeof(TUint));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else if (wanted_field.compare(
				cf_str_EAP_GSMSIM_wait_eap_success_packet.get_field()->get_field(),
				cf_str_EAP_GSMSIM_wait_eap_success_packet.get_field()->get_field_length()) == 0
			|| wanted_field.compare(
					cf_str_EAP_AKA_wait_eap_success_packet.get_field()->get_field(),
					cf_str_EAP_AKA_wait_eap_success_packet.get_field()->get_field_length()) == 0)
		{
			// Set wait eap success of EAP-SIM and EAP-AKA.
			TInt val(1);
			status = data->set_copy_of_buffer((u8_t*) &val, sizeof(TUint));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else if (wanted_field.compare(
				cf_str_EAP_GSMSIM_UMA_realm_prefix.get_field()->get_field(),
				cf_str_EAP_GSMSIM_UMA_realm_prefix.get_field()->get_field_length()) == 0
			|| wanted_field.compare(
					cf_str_EAP_AKA_UMA_realm_prefix.get_field()->get_field(),
					cf_str_EAP_AKA_UMA_realm_prefix.get_field()->get_field_length()) == 0)
		{
			// Set uma realm prefix of EAP-SIM and EAP-AKA.
			status = data->set_copy_of_buffer(iRealmPrefix->Ptr(), iRealmPrefix->Length());
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else if (wanted_field.compare(
				cf_str_EAP_GSMSIM_use_manual_realm.get_field()->get_field(),
				cf_str_EAP_GSMSIM_use_manual_realm.get_field()->get_field_length()) == 0
			|| wanted_field.compare(
					cf_str_EAP_AKA_use_manual_realm.get_field()->get_field(),
					cf_str_EAP_AKA_use_manual_realm.get_field()->get_field_length()) == 0)
		{
			// Use ManualRealm of EAP-SIM and EAP-AKA.
			TInt val(1);
			if(iManualRealm == NULL || (iManualRealm && (iManualRealm->Length() == 0)))
			{
				val = 0;
			}
			status = data->set_copy_of_buffer((u8_t*) &val, sizeof(TUint));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else if (wanted_field.compare(
				cf_str_EAP_GSMSIM_manual_realm.get_field()->get_field(),
				cf_str_EAP_GSMSIM_manual_realm.get_field()->get_field_length()) == 0
			|| wanted_field.compare(
					cf_str_EAP_AKA_manual_realm.get_field()->get_field(),
					cf_str_EAP_AKA_manual_realm.get_field()->get_field_length()) == 0)
		{
			// ManualRealm of EAP-SIM and EAP-AKA.
			status = data->set_copy_of_buffer(iManualRealm->Ptr(), iManualRealm->Length());
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else if (wanted_field.compare(
				cf_str_EAP_GSMSIM_use_manual_username.get_field()->get_field(),
				cf_str_EAP_GSMSIM_use_manual_username.get_field()->get_field_length()) == 0
			|| wanted_field.compare(
				cf_str_EAP_AKA_use_manual_username.get_field()->get_field(),
				cf_str_EAP_AKA_use_manual_username.get_field()->get_field_length()) == 0)
		{
			// Use ManualUsername of EAP-SIM and EAP-AKA.
			TInt val(1);
			if(iManualUsername == NULL || (iManualUsername && (iManualUsername->Length() == 0)))
			{
				val = 0;
			}
			status = data->set_copy_of_buffer((u8_t*) &val, sizeof(TUint));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else if (wanted_field.compare(
				cf_str_EAP_GSMSIM_manual_username.get_field()->get_field(),
				cf_str_EAP_GSMSIM_manual_username.get_field()->get_field_length()) == 0
			|| wanted_field.compare(
				cf_str_EAP_AKA_manual_username.get_field()->get_field(),
				cf_str_EAP_AKA_manual_username.get_field()->get_field_length()) == 0)
		{
			// ManualUsername of EAP-SIM and EAP-AKA.
			status = data->set_copy_of_buffer(iManualUsername->Ptr(), iManualUsername->Length());
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else if (wanted_field.compare(
				cf_str_EAP_GSMSIM_2_digit_mnc_map_of_mcc_of_imsi_array.get_field()->get_field(),
				cf_str_EAP_GSMSIM_2_digit_mnc_map_of_mcc_of_imsi_array.get_field()->get_field_length()) == 0
			|| wanted_field.compare(
					cf_str_EAP_AKA_2_digit_mnc_map_of_mcc_of_imsi_array.get_field()->get_field(),
					cf_str_EAP_AKA_2_digit_mnc_map_of_mcc_of_imsi_array.get_field()->get_field_length()) == 0)
		{
			// 2-digit MNC configuration of EAP-SIM and EAP-AKA.
			const TUint32 K2DigitMncMccList[]
				= {
					202,204,206,208,213,214,216,218,
					219,220,222,226,228,230,231,232,
					234,238,240,242,244,246,247,248,
					250,255,257,259,260,262,266,268,
					270,272,274,276,278,280,282,284,
					286,288,290,293,294,295,308,340,
					362,363,400,401,402,404,410,413,
					414,415,416,417,419,420,421,422,
					424,425,426,427,428,429,432,434,
					436,437,438,440,441,452,454,455,
					456,457,460,470,472,502,505,510,
					515,520,525,528,530,537,539,541,
					546,547,549,602,603,604,605,607,
					608,609,610,611,612,613,614,615,
					616,617,619,620,621,622,623,624,
					625,626,628,629,630,631,633,634,
					635,636,638,639,640,641,642,643,
					645,646,647,648,649,650,651,652,
					653,654,655,702,704,706,710,712,
					714,716,724,730,734,744,746,901
				};

			status = data->set_copy_of_buffer((u32_t*) K2DigitMncMccList, sizeof(K2DigitMncMccList));
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else if (wanted_field.compare(
				cf_str_EAP_TRACE_output_file_name.get_field()->get_field(),
				cf_str_EAP_TRACE_output_file_name.get_field()->get_field_length()) == 0)
		{
			// Trace output file name.
			status = data->set_copy_of_buffer(
				m_trace_log_file_name);
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else if (wanted_field.compare(
					cf_str_EAP_GSMSIM_max_session_validity_time.get_field()->get_field(),
					cf_str_EAP_GSMSIM_max_session_validity_time.get_field()->get_field_length()) == 0
				|| wanted_field.compare(
					cf_str_EAP_AKA_max_session_validity_time.get_field()->get_field(),
					cf_str_EAP_AKA_max_session_validity_time.get_field()->get_field_length()) == 0)
		{
			u32_t session_validity_time_in_seconds(43200ul);

			status = data->set_copy_of_buffer(reinterpret_cast<u8_t*>(&session_validity_time_in_seconds), sizeof(session_validity_time_in_seconds));

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else if (wanted_field.compare(
					cf_str_EAP_CORE_wait_eap_request_type_timeout.get_field()->get_field(),
					cf_str_EAP_CORE_wait_eap_request_type_timeout.get_field()->get_field_length()) == 0)
		{
			u32_t wait_eap_request_type_timeout_in_milli_seconds(30000ul);

			status = data->set_copy_of_buffer(reinterpret_cast<u8_t*>(&wait_eap_request_type_timeout_in_milli_seconds), sizeof(wait_eap_request_type_timeout_in_milli_seconds));

			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);		
		}
		else
		{
			EAP_TRACE_DATA_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("WARNING: CEapVpnInterfaceImplementation: read_configure(): Unknown configuration\n"),
				field->get_field(),
				field->get_field_length()));
		}
	}

	// Otherways just use the default value
	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);
}

/**
 * The write_configure() function writes the configuration data identified
 * by the field string of field_length bytes length. Adaptation module must direct
 * the action to some persistent store.
 * @see abs_eap_base_type_c::write_configure().
 */
eap_status_e CEapVpnInterfaceImplementation::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;
}

/**
 * This is notification of internal state transition.
 * This is used for notifications, debugging and protocol testing.
 * The primal notifications are eap_state_variable_e::eap_state_authentication_finished_successfully
 * and eap_state_variable_e::eap_state_authentication_terminated_unsuccessfully.
 * These two notifications are sent from EAP-protocol layer (eap_protocol_layer_e::eap_protocol_layer_eap).
 * These two notifications tells the end state of authentication session. These are the only
 * reliable indications of the final status of authentication session.
 * You MUST NOT make decision based on the return value of abs_eap_stack_interface_c::packet_process().
 */
void CEapVpnInterfaceImplementation::state_notification(
                                const abs_eap_state_notification_c * const state)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::state_notification() = %d\n"), state->get_current_state()));

	if (m_block_packet_sends_and_notifications == true)
	{
		// Notification block is active.		
		EAP_TRACE_ALWAYS(
			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:
			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++;	
	
			EAP_TRACE_ALWAYS(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("Indication sent: ESuccess.\n")));

			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("CEapVpnInterfaceImplementation: Indication sent: ESuccess\n")));
			iCaller->EapIndication(ESuccess);
			break;
		}
		case eap_state_authentication_terminated_unsuccessfully:
		{
			increment_authentication_counter();
			m_failed_authentications++;

			EAP_TRACE_DEBUG(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("CEapVpnInterfaceImplementation: Indication sent: EFailure\n")));

			EAP_TRACE_ALWAYS(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("Indication sent: EFailure.\n")));
			iCaller->EapIndication(EFailure);
			break;
		}
		default:
			break;
		}
	}

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
}

/**
 * The set_timer() function initializes timer to be elapsed after time_ms milliseconds.
 * @param initializer is pointer to object which timer_expired() function will
 * be called after timer elapses.
 * @param id is identifier which will be returned in timer_expired() function.
 * The user selects and interprets the id for this timer.
 * @param data is pointer to any user selected data which will be returned in timer_expired() function.
 * @param time_ms is the time of timer in milli seconds.
 *
 * Adaptation module internally implements the timer.
 */
eap_status_e CEapVpnInterfaceImplementation::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;
}

/**
 * The cancel_timer() function cancels the timer id initiated by initializer.
 * @param initializer is pointer to object which set the cancelled timer.
 * @param id is identifier which will be returned in timer_expired() function.
 * The user selects and interprets the id for this timer.
 *
 * Adaptation module internally implements the timer.
 */
eap_status_e CEapVpnInterfaceImplementation::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;
}

/**
 * The cancel_all_timers() function cancels all timers.
 * User should use this in termination of the stack before
 * the adaptation module of tools is deleted.
 * Preferred mode is to cancel each timer directly
 * using cancel_timer() function.
 *
 * Adaptation module internally implements the timer.
 */
eap_status_e CEapVpnInterfaceImplementation::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;
}

/**
 * This function queries the validity of EAP-type.
 * Lower layer should return eap_status_ok if this EAP-type is supported.
 * @param eap_type is the requested EAP-type.
 */
eap_status_e CEapVpnInterfaceImplementation::check_is_valid_eap_type(const eap_type_value_e eap_type)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	eap_status_e status(eap_status_illegal_eap_type);

#ifdef USE_EAP_EXPANDED_TYPES

	for (int i = 0; i < m_enabled_expanded_eap_array.Count(); i++)
	{
		TBuf8<KExpandedEapTypeSize> tmpExpEAP(m_enabled_expanded_eap_array[i]->EapExpandedType);

		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("CEapVpnInterfaceImplementation::check_is_valid_eap_type:Enabled expanded EAP type at index=%d\n"),
			 i));

		EAP_TRACE_DATA_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Enabled expanded EAP type:"),
			tmpExpEAP.Ptr(),
			tmpExpEAP.Size()));

		// This is for one expanded EAP type (for the above one).
		eap_expanded_type_c expandedEAPType;
				
		// Read the expanded EAP type details for this item in m_enabled_expanded_eap_array.
		eap_status_e status = eap_expanded_type_c::read_type(m_am_tools,
												0,
												tmpExpEAP.Ptr(),
												tmpExpEAP.Size(),
												&expandedEAPType);
		if (status != eap_status_ok)
		{
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, status);
		}

		if (eap_type == expandedEAPType)
		{
			// This is Allowed and Valid.
			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
			return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);
		}
	} // End of for()
		 
#else // For normal unexpanded EAP type

	TEap *eapType = 0; 

	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 (val == eap_type)
			{
				// Allowed
				status = eap_status_ok;
				break;
			}	
		}
	} // for()

#endif // #ifdef USE_EAP_EXPANDED_TYPES

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

	return EAP_STATUS_RETURN(m_am_tools, status);
}

/**
 * This function queries the list of supported EAP-types.
 * Lower layer should return eap_status_ok if this call succeeds.
 * @param eap_type_list will include the list of supported EAP-types. Each value in list
 * is type of u32_t and represent one supported EAP-type. List consists of subsequent u32_t type values.
 */
eap_status_e CEapVpnInterfaceImplementation::get_eap_type_list(eap_array_c<eap_type_value_e> * const eap_type_list)
{
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	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);
	}

	eap_header_string_c eap_string;
	EAP_UNREFERENCED_PARAMETER(eap_string);

#ifdef USE_EAP_EXPANDED_TYPES

	// This function is same as get_selected_eap_types in behavior.

	// We need to return only the EAP types available as enabled types.
	// It means only the ones available in m_enabled_expanded_eap_array.
	
	for (TInt i = 0; i < m_enabled_expanded_eap_array.Count(); i++)
	{	
		TBuf8<KExpandedEapTypeSize> tmpExpEAP(m_enabled_expanded_eap_array[i]->EapExpandedType);

		EAP_TRACE_DEBUG(
			m_am_tools, 
			TRACE_FLAGS_DEFAULT, 
			(EAPL("CEapVpnInterfaceImplementation::get_eap_type_list:Enabled expanded EAP type at index=%d\n"),
			 i));

		EAP_TRACE_DATA_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("Enabled expanded EAP type:"),
			tmpExpEAP.Ptr(),
			tmpExpEAP.Size()));

		// This is for one expanded EAP type (for the above one).
		eap_expanded_type_c * expandedEAPType = new eap_type_value_e();
				
		// Read the expanded EAP type details from an item in m_enabled_expanded_eap_array.
		status = eap_expanded_type_c::read_type(m_am_tools,
												0,
												tmpExpEAP.Ptr(),
												tmpExpEAP.Size(),
												expandedEAPType);
		if (status != eap_status_ok)
		{
			delete expandedEAPType;
			expandedEAPType = 0;

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

		// Add EAP-type to list.		
		status = eap_type_list->add_object(expandedEAPType, 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_DEBUG(
			m_am_tools,
			TRACE_FLAGS_DEFAULT,
			(EAPL("get_eap_type_list():added EAP-type=0x%08x=%s\n"),
			expandedEAPType->get_vendor_type(),
			eap_string.get_eap_type_string(*expandedEAPType)));			
	}

#else // for normal EAP types.

	TEap *eapType = 0; 

	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);
			}
		}
	} // for()

#endif //#ifdef USE_EAP_EXPANDED_TYPES

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
	return eap_status_ok;
}
//--------------------------------------------------


eap_status_e CEapVpnInterfaceImplementation::add_rogue_ap(eap_array_c<eap_rogue_ap_entry_c> & /*rogue_ap_list*/)
{
	// Not used, but might be called
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);
	TInt err = KErrNone;

	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eap_vpn_if::add_rogue_ap()\n")));

	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));
}


eap_status_e CEapVpnInterfaceImplementation::restart_authentication(
	const eap_am_network_id_c * const /*receive_network_id*/,
	const bool /*is_client_when_true*/,
	const bool /*force_clean_restart*/,
	const bool /*from_timer*/)
{
	// Not used, but might be called
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("eap_vpn_if::restart_authentication()\n")));

	eap_status_e status = eap_status_ok;

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


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

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

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

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

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

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


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

//
eap_status_e CEapVpnInterfaceImplementation::timer_expired(
	const u32_t id,
	void * /*data*/)
{
	// Not used, but might be called
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_DEBUG(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("CEapVpnInterfaceImplementation::timer_expired()\n")));

	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("TIMER: [0x%08x]->eap_vpn_if::timer_expired(id 0x%02x).\n"),
		this,
		id));

	switch (id)
	{
	case EAPOL_AM_CORE_TIMER_DELETE_STACK_ID:
		{
			EAP_TRACE_ALWAYS(
				m_am_tools,
				TRACE_FLAGS_DEFAULT,
				(EAPL("EAPOL_AM_CORE_TIMER_DELETE_STACK_ID elapsed: Delete stack.\n")));

			cancel_all_timers();

			// Delete stack
			if (iEapCore != 0)
			{
				iEapCore->shutdown();
				delete iEapCore;
				iEapCore = 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_ALWAYS(
					m_am_tools,
					TRACE_FLAGS_DEFAULT,
					(EAPL("ERROR: re_activate_timer_queue() failed, status = %d\n")));
			}

			break;
		}

	default:
		break;
	} // switch()

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

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

//
eap_status_e CEapVpnInterfaceImplementation::timer_delete_data(
    const u32_t /*id*/, void * /*data*/)
{
	// Not used, but might be called
	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_ALWAYS(
		m_am_tools,
		TRACE_FLAGS_DEFAULT,
		(EAPL("TIMER: [0x%08x]->eap_vpn_if::timer_delete_data().\n"),
		this));

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

// -----------------------------------------------------------------------------
// CleanupImplArray
// -----------------------------------------------------------------------------
//
void CEapVpnInterfaceImplementation::CleanupImplArray( TAny* aAny )
{
	RImplInfoPtrArray* implArray = 
		reinterpret_cast<RImplInfoPtrArray*>( aAny );

	implArray->ResetAndDestroy();
	implArray->Close();
}

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

// End
