/*

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

	#undef EAP_FILE_NUMBER_DATE 

	#define EAP_FILE_NUMBER_DATE 1127594498 

#endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

// INCLUDE FILES

#include "EapTlsPeapCertInterface.h"

#include "EapTlsPeapUtils.h"

#include <x509keys.h>

#include <x509cert.h>

#include "eap_tlv_message_data.h"

#include "EapTraceSymbian.h"

#include "eap_automatic_variable.h"

#if defined(USE_EAP_TLS_PEAP_UNIFIED_KEY_STORE_CACHE)

	const TText8 KKeyStoreHandlePrefix[] = "EapTlsPeapKeyStoreHandler";

	const TText8 KKeyStoreHandleKey[] = "CEapTlsPeapCertInterface KeyStore handle";

#endif //#if defined(USE_EAP_TLS_PEAP_UNIFIED_KEY_STORE_CACHE)

enum TAlgorithmAndSignedType

{

	ERSASign = 1,

	EDSASign,

	ERSASignWithFixedDH,

	EDSASignWithFixedDH,

	ERSASignWithEphemeralDH,

	EDSASignWithEphemeralDH

};

enum eap_type_tlspeap_stored_e

{

	eap_type_tlspeap_stored_keystore_handle = 1

};

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

// Completition functions should be moved to abstract IF

CEapTlsPeapCertInterface* CEapTlsPeapCertInterface::NewL(abs_eap_am_tools_c* const aTools, 

											   eap_am_type_tls_peap_symbian_c* const aParent)

{

	EAP_TRACE_DEBUG(

		aTools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::NewL()\n")));

	EAP_TRACE_RETURN_STRING(aTools, "returns: CEapTlsPeapCertInterface::NewL()");

	CEapTlsPeapCertInterface* self = new(ELeave) CEapTlsPeapCertInterface(aTools, aParent);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

}

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

CEapTlsPeapCertInterface::CEapTlsPeapCertInterface(abs_eap_am_tools_c* const aTools, eap_am_type_tls_peap_symbian_c* const aParent)

: CActive(CActive::EPriorityStandard)

, iParent(aParent)

, m_am_tools(aTools)

, iAllowedUserCerts(1)

, iEncodedCertificate(0)

, iCertPtr(0,0)

, iMatchingUserCertInfos(1)

, iCAIndex(0)

, iUseAutomaticCaCertificate(EFalse)

{

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::CEapTlsPeapCertInterface()\n")));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: CEapTlsPeapCertInterface::CEapTlsPeapCertInterface()");

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

}

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

void CEapTlsPeapCertInterface::ConstructL()

{

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::ConstructL()\n")));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: CEapTlsPeapCertInterface::ConstructL()");

	User::LeaveIfError(iFs.Connect());

	CActiveScheduler::Add(this);		

	iValidationResult = CPKIXValidationResult::NewL();

	iEncodedCertificate = HBufC8::NewL(0);

	iCertPtr.Set(iEncodedCertificate->Des());	

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

}

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

CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface()

{

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface()\n")));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface()");

	if(IsActive())

	{

		Cancel();		

	}

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface(): iMatchingUserCerts.ResetAndDestroy(): count=%d\n"),

		iMatchingUserCerts.Count()));

	iMatchingUserCerts.ResetAndDestroy();

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface(): iMatchingUserCertInfos.ResetAndDestroy(): count=%d\n"),

		iMatchingUserCertInfos.Count()));

	iMatchingUserCertInfos.ResetAndDestroy();

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface(): iAllowedUserCerts.ResetAndDestroy(): count=%d\n"),

		iAllowedUserCerts.Count()));

	iAllowedUserCerts.ResetAndDestroy();

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface(): iAllowedCACerts.ResetAndDestroy(): count=%d\n"),

		iAllowedCACerts.Count()));

	iAllowedCACerts.ResetAndDestroy();

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface(): iRootCerts.ResetAndDestroy(): count=%d\n"),

		iRootCerts.Count()));

	iRootCerts.ResetAndDestroy();

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface(): iUserCertChain.ResetAndDestroy(): count=%d\n"),

		iUserCertChain.Count()));

	iUserCertChain.ResetAndDestroy();

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface(): iCertAuthorities.ResetAndDestroy(): count=%d\n"),

		iCertAuthorities.Count()));

	iCertAuthorities.ResetAndDestroy();

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface(): iCertInfos.Reset(): count=%d\n"),

		iCertInfos.Count()));

	TInt i(0);

	for (i = 0; i < iCertInfos.Count(); i++)

	{

		iCertInfos[i]->Release();

	}

	iCertInfos.Reset();

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface(): iKeyInfos.Reset(): count=%d\n"),

		iKeyInfos.Count()));

	for (i = 0; i < iKeyInfos.Count(); i++)

	{

		iKeyInfos[i]->Release();

	}

	iKeyInfos.Reset();

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

	delete iCertFilter;

	delete iCertStore;

	delete iCertChain;

	delete iValidationResult;

	delete iInputCertChain;	

	delete iEncodedCertificate;	

	delete iDataIn;

	delete iDataOut;

	delete iSignature;

	delete iPtrOut;

	delete iSignaturePtr;

	delete iRSASignature;

	delete iDSASignature;

	delete iKeyFilter;

#if !defined(USE_EAP_TLS_PEAP_UNIFIED_KEY_STORE_CACHE)

	delete iKeyStore;

#endif //#if !defined(USE_EAP_TLS_PEAP_UNIFIED_KEY_STORE_CACHE)

	iFs.Close();

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::~CEapTlsPeapCertInterface(): returns\n")));

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

}

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

void CEapTlsPeapCertInterface::GetMatchingCertificatesL(

	const RPointerArray<EapCertificateEntry>& aAllowedUserCerts,

	const TBool aUseCertAuthoritiesFilter,

	EAP_TEMPLATE_CONST eap_array_c<eap_variable_data_c> * const aCertAuthorities,

	const TBool aUseCertTypesFilter,

	EAP_TEMPLATE_CONST eap_array_c<u8_t> * const aCertTypes,

	const TBool aUseAllowedCipherSuitesFilter,

	const RArray<TUint>& aAllowedCipherSuites)

{

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::GetMatchingCertificatesL(): Total allowed user certs=%d, aAllowedUserCerts=0x%08x, iAllowedUserCerts=0x%08x, aCertAuthorities=0x%08x, aCertTypes=0x%08x, aAllowedCipherSuites=0x%08x\n"),

		aAllowedUserCerts.Count(),

		&aAllowedUserCerts,

		&iAllowedUserCerts,

		aCertAuthorities,

		aCertTypes,

		&aAllowedCipherSuites));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: CEapTlsPeapCertInterface::GetMatchingCertificatesL()");

	iUseCertAuthoritiesFilter = aUseCertAuthoritiesFilter;

	iUseCertTypesFilter = aUseCertTypesFilter;

	iUseAllowedCipherSuitesFilter = aUseAllowedCipherSuitesFilter;

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::GetMatchingCertificatesL(): iAllowedUserCerts.Count()=%d\n"),

		iAllowedUserCerts.Count()));

	iAllowedUserCerts.ResetAndDestroy();

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::GetMatchingCertificatesL(): UseCertAuthoritiesFilter=%d, UseCertTypesFilter=%d, UseAllowedCipherSuitesFilter=%d\n"),

		iUseCertAuthoritiesFilter,

		iUseCertTypesFilter,

		iUseAllowedCipherSuitesFilter));		

	for (TInt j = 0; j < aAllowedUserCerts.Count(); j++)

	{

		EapCertificateEntry * const copy_cert = aAllowedUserCerts[j]->Copy();

		if (copy_cert == 0)

		{

			User::Leave(KErrNoMemory);

		}

		iAllowedUserCerts.AppendL(copy_cert);

		EAP_TRACE_SETTINGS(copy_cert);

	}

	if (iCertAuthorities.Count() > 0)

	{

		iCertAuthorities.ResetAndDestroy();

	}

	if (aUseCertAuthoritiesFilter

		&& aCertAuthorities)

	{

		for (TUint i = 0; i < aCertAuthorities->get_object_count(); i++)

		{

			HBufC8* buf = HBufC8::NewLC((aCertAuthorities->get_object(i))->get_data_length());

			TPtr8 ptr = buf->Des();

			ptr.Copy((aCertAuthorities->get_object(i))->get_data((aCertAuthorities->get_object(i))->get_data_length()),

				(aCertAuthorities->get_object(i))->get_data_length());

			// Try to form distiguished name

			CX500DistinguishedName* tmp = 0;

			TRAPD(error, tmp = CX500DistinguishedName::NewL(ptr));

			if (error == KErrNone)

			{

				CleanupStack::PushL(tmp);

				// Distinguished name was found -> add it to array.

				User::LeaveIfError(iCertAuthorities.Append(tmp));

				CleanupStack::Pop(tmp);

			}

			CleanupStack::PopAndDestroy(buf);

		}

	}

	if (aUseCertTypesFilter)

	{

		iCertTypes = aCertTypes;

	}

	if (aUseAllowedCipherSuitesFilter)

	{	

		iRSACertsAllowed = EFalse; 

		iDSACertsAllowed = EFalse;

		for (TInt i = 0; i < aAllowedCipherSuites.Count(); i++)

		{

			if (EapTlsPeapUtils::CipherSuiteUseRSAKeys(static_cast<tls_cipher_suites_e>(aAllowedCipherSuites[i])))

			{

				iRSACertsAllowed = ETrue;

			}

			else if (EapTlsPeapUtils::CipherSuiteUseDSAKeys(static_cast<tls_cipher_suites_e>(aAllowedCipherSuites[i])))

			{

				iDSACertsAllowed = ETrue;

			}

		}

	}

	iState = EGetMatchingCertsInitStore;

	if (iCertStore == 0)

	{

		iCertStore = CUnifiedCertStore::NewL(iFs, EFalse);

		iCertStore->Initialize(iStatus);		

	}

	else

	{

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);		

	}		

	SetActive();	

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

}

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

void CEapTlsPeapCertInterface::ReadCertificateL(EapCertificateEntry& aCertInfo, const TBool aRetrieveChain)

{	

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("CEapTlsPeapCertInterface::ReadCertificateL()\n")));

	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: CEapTlsPeapCertInterface::ReadCertificateL()");

	iCertInfo = aCertInfo;

	iRetrieveChain = aRetrieveChain;

	iState = EReadCertInitStore;

	if (iCertStore == 0)

	{

		iCertStore = CUnifiedCertStore::NewL(iFs, EFalse);

		iCertStore->Initialize(iStatus);		

	}

	else

	{

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);		

	}		

	SetActive();