/*

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

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)

{

	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)

{

	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

}

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

void 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()

{

	iMatchingUserCerts.ResetAndDestroy();

	iRootCerts.ResetAndDestroy();

	iUserCertChain.ResetAndDestroy();

	iCertAuthorities.ResetAndDestroy();

	TInt i(0);

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

	{

		iCertInfos[i]->Release();

	}

	iCertInfos.Reset();

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

	{

		iKeyInfos[i]->Release();

	}

	iKeyInfos.Reset();

	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;

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

{

	iUseCertAuthoritiesFilter = aUseCertAuthoritiesFilter;

	iUseCertTypesFilter = aUseCertTypesFilter;

	iUseAllowedCipherSuitesFilter = aUseAllowedCipherSuitesFilter;

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

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

	{

	}

	if (iCertAuthorities.Count() > 0)

	{

		iCertAuthorities.ResetAndDestroy();

	}

	{

		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;

			{

				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->Initialize(iStatus);		

	}

	else

	{

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);		

	}		

	SetActive();	

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

}

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

{	

	iCertInfo = aCertInfo;

	iRetrieveChain = aRetrieveChain;

	iState = EReadCertInitStore;

	if (iCertStore == 0)

	{

		iCertStore->Initialize(iStatus);		

	}

	else

	{

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);		

	}		

	SetActive();			

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

}

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

{	

	iCertInfo = aCertInfo;

	iState = EReadCACertInitStore;

	if (iCertStore == 0)

	{

		iCertStore->Initialize(iStatus);		

	}

	else

	{

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);		

	}		

	SetActive();			

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

}

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

	iCAIndex = 0;

	delete iInputCertChain;

	iInputCertChain = 0;

	iInputCertChain = aCertChain.AllocL();

	iState = EValidateChainInitStore;

	if (iCertStore == 0)

	{

		iCertStore->Initialize(iStatus);		

	}

	else

	{

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);		

	}

	SetActive();

	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

}

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

void CEapTlsPeapCertInterface::DoCancel()

{