/*

* 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

*

*/

/*

*/

// INCLUDE FILES

#include <w32std.h>

#include <pathinfo.h>

#include <EapType.h>

#include <EapTypePlugin.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 "eap_core.h"

#include "EapSimDbDefaults.h"

#include "EapConversion.h"

#include "eap_session_core_base.h"

#include "eap_automatic_variable.h"

#include "eap_core_client_message_if.h"

#include "eap_process_tlv_message_data.h"

// LOCAL CONSTANTS

const TUint KMaxConfigStringLength = 256;

const u32_t KMTU = 1500u;

const u32_t KTrailerLength = 0;

const u32_t KHeaderOffset = 0;

#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)

, m_eap_type_array(0)

, 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.

	}

	m_eap_type_array = new eap_array_c<eap_type_value_e>(m_am_tools);

	if (m_eap_type_array == 0)

	{

		User::Leave(KErrGeneral);

	}

    //------ 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 EAP-interfaces.

		for(int i = 0; i < m_eap_if_array.Count(); i++)

		{

			delete m_eap_if_array[i];

		}

		m_eap_if_array.Close();

	}

	{

		// Unload all loaded EAP-plugins.

		for(int i = 0; i < m_eap_plugin_if_array.Count(); i++)

		{

			delete m_eap_plugin_if_array[i];

		}

		m_eap_plugin_if_array.Close();

	}

	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;

	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)

			{