/*

* Copyright (c) 1998-2009 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: 

*

*/

#include "test1certstore.h"

#include "tadditionalstoremappings.h"

#include <signed.h>

#include <x509cert.h>

#include <wtlscert.h>

#include <x509keys.h>

#include <ecom/implementationproxy.h>

_LIT(KName1, "Test store 1");

_LIT(KName2, "Test store 2");

//////////////////////////////////////////////////////////////////////////////////////////

//CFileCertStore

/////////////////////////////////////////////////////////////////////////////////////////

CTest1CertStore* CTest1CertStore::NewL(RFs& aFs,

									   CTest1CertStoreToken& aToken, 

									   const TDesC& aFileName,

									   TFileMode aMode)

	{

	CTest1CertStore* self = new(ELeave) CTest1CertStore(aToken, aFs);

	CleanupStack::PushL(self);

	self->ConstructL(aFileName, aMode);

	CleanupStack::Pop(self);

	return self;

	}

MCTToken& CTest1CertStore::Token()

	{

	return iToken;

	}

void CTest1CertStore::DoRelease()

	{

	if (iToken.Label() == KName1)

		{

		iToken.iRefCountInterface--;

		if (!iToken.iRefCountInterface)

			{

			delete this;

			}

		}

	else if (iToken.Label() == KName2)

		{

		iToken.iRefCountInterface2--;

		if (!iToken.iRefCountInterface2)

			{

			delete this;

			}

		}

	}

void CTest1CertStore::List(RMPointerArray<CCTCertInfo>& aCertInfos,

						  const CCertAttributeFilter& aFilter,

						  TRequestStatus& aStatus)

	{

	iOriginalRequestStatus = &aStatus;

	aStatus = KRequestPending;

	iCertInfos = &aCertInfos;

	iFilter = &aFilter;

	//Iinitialize the ketstore and then list the key info

	if (iFilter->iKeyUsage != EX509UsageAll)

		{

		// We have to initialize the unified key store

		TRAPD(err, iUnifiedKeyStore = CUnifiedKeyStore::NewL(iFs));

		if (err != KErrNone)

			{

			User::RequestComplete(iOriginalRequestStatus, err);

			iOriginalRequestStatus = 0;

			}

		else

			{

			iUnifiedKeyStore->Initialize(iStatus);

			iState = EGetKeyInfos;

			SetActive();

			}

		}

	else

		{

		iState = EList;

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		SetActive();

		}

	}

void CTest1CertStore::CancelList()

	{

	Cancel();

	}

void CTest1CertStore::GetCert(CCTCertInfo*& aCertInfo,

							 const TCTTokenObjectHandle& aHandle,

							 TRequestStatus& aStatus)

	{

	TInt err = KErrNotFound;

	if ((aHandle.iTokenHandle == iToken.Handle()) &&

		(aHandle.iObjectId < iCerts->Count()))

		{

		TRAP(err, aCertInfo = CCTCertInfo::NewL(iCerts->Entry(aHandle.iObjectId)));

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelGetCert()

	{

	// Nothing to do because GetCert is not asynchronous.

	}

void CTest1CertStore::Applications(const CCTCertInfo& aCertInfo,

								  RArray<TUid>& aApplications,

								  TRequestStatus& aStatus)

	{

	TInt err = KErrNone;

	TInt index = iCerts->Index(aCertInfo);

	if (index != KErrNotFound)

		{

		const RArray<TUid>& apps = iCerts->Mapping(index)->CertificateApps();

		TInt end = apps.Count();

		for (TInt i = 0; (i < end) && (err == KErrNone); i++)

			{

			err = aApplications.Append(apps[i]);

			}

		}

	else

		{

		err = index;

		}

	if (err != KErrNone)

		{

		aApplications.Reset();

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelApplications()

	{

	}

void CTest1CertStore::IsApplicable(const CCTCertInfo& aCertInfo,

								  TUid aApplication, 

								  TBool& aIsApplicable,

								  TRequestStatus& aStatus)

	{

	TInt index = iCerts->Index(aCertInfo);

	if (index != KErrNotFound)

		{

		const RArray<TUid>& apps = iCerts->Mapping(index)->CertificateApps();

		TInt end = apps.Count();

		TInt i;

		for (i = 0; i < end; i++)

			{

			if (apps[i] == aApplication)

				{

				break;

				}

			}

		if (i == end)

			{

			aIsApplicable = EFalse;

			}

		else

			{

			aIsApplicable = ETrue;

			}

		index = KErrNone;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, index);

	}

void CTest1CertStore::CancelIsApplicable()

	{

	// Nothing to do because IsApplicable is not asynchronous.

	}

void CTest1CertStore::Trusted(const CCTCertInfo& aCertInfo,

							 TBool& aTrusted, 

							 TRequestStatus& aStatus)

	{	

	TInt index = iCerts->Index(aCertInfo);

	if (index != KErrNotFound)

		{

		aTrusted = iCerts->Mapping(index)->Trusted();

		index = KErrNone;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, index);

	}

void CTest1CertStore::CancelTrusted()

	{

	// Nothing to do because Trusted is not asynchronous.

	}

void CTest1CertStore::Retrieve(const CCTCertInfo& aCertInfo,

							  TDes8& aCertificate,

							  TRequestStatus& aStatus)

	{

#ifdef CERTSTORE_SOFTWARE_ASYNCH

	// perform an asynchronous retrieval of the certificate

	iOriginalRequestStatus = &aStatus;

	aStatus = KRequestPending;

	iAsynchCertInfo = &aCertInfo;

	iAsynchCertificate = &aCertificate;

	iState = ERetrieve;

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	SetActive();

#else

	RetrieveNow(aCertInfo,aCertificate,aStatus);

#endif

	}

void CTest1CertStore::RetrieveNow(const CCTCertInfo& aCertInfo,

							  TDes8& aCertificate,

							  TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	TInt err;

	TInt index = iCerts->Index(aCertInfo);

	if (index == KErrNotFound)

		{

		err = KErrNotFound;

		}

	else

		{

		CFileCertStoreMapping* mapping = NULL;

		mapping = iCerts->Mapping(index);

		err = index;

		if (mapping)

			{

			TRAP(err, DoLoadL(aCertificate, *mapping));

			}

		}

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelRetrieve()

	{

	}

void CTest1CertStore::Capabilities(const CCTCertInfo& /*aCertInfo*/, TCapabilitySet& /*aCapbilitiesOut*/,

								  TRequestStatus& aStatus)

	{

	// currently not supported

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNotSupported);

	}

void CTest1CertStore::CancelCapabilities()

	{

	// Nothing to do because Capabilities is not asynchronous.

	}

void CTest1CertStore::IsMandatory(const CCTCertInfo& /*aCertInfo*/, TBool& /*aMandatoryOut*/,

								 TRequestStatus& aStatus)

	{

	// currently not supported

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNotSupported);

	}

void CTest1CertStore::CancelIsMandatory()

	{

	// Nothing to do because IsMandatory is not asynchronous.

	}

void CTest1CertStore::Remove(const CCTCertInfo& aCertInfo, TRequestStatus& aStatus)

	{

	// This removes the certificate from the file store.

	TRAPD(err, DoRemoveL(aCertInfo));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelRemove()

	{

	}

void CTest1CertStore::SetApplicability(const CCTCertInfo& aCertInfo,

									  const RArray<TUid>& aTrusters,

									  TRequestStatus& aStatus)

	{

	TRAPD(err, DoSetApplicabilityL(aCertInfo, aTrusters));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelSetApplicability()

	{

	}

void CTest1CertStore::SetTrust(const CCTCertInfo& aCertInfo, 

							  TBool aTrusted, 

							  TRequestStatus& aStatus)

	{

	TRAPD(err, DoSetTrustL(aCertInfo, aTrusted));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CTest1CertStore::CancelSetTrust()

	{

	// Nothing to do because SetTrust is not asynchronous.

	}

void CTest1CertStore::SetCapabilities(const CCTCertInfo& /*aCertInfo*/, const TCapabilitySet& /*aCapabilities*/, 

									 TRequestStatus& aStatus)

	{

	// currently not supported

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNotSupported);

	}

void CTest1CertStore::CancelSetCapabilities()

	{

	// Nothing to do because SetCapabilities is not asynchronous.

	}

void CTest1CertStore::SetMandatory(const CCTCertInfo& /*aCertInfo*/, TBool /*aMandatory*/,

								  TRequestStatus& aStatus)

	{

	// currently not supported

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNotSupported);

	}

void CTest1CertStore::CancelSetMandatory()

	{

	// Nothing to do because SetMandatory is not asynchronous.

	}

void CTest1CertStore::RevertStore(TAny* aStore)

	{

	//this is a CleanupItem

	CPermanentFileStore* store = REINTERPRET_CAST(CPermanentFileStore*, aStore);

	store->Revert();

	}

void CTest1CertStore::DeleteFile(TAny* aThis)

	{

	CTest1CertStore* self = REINTERPRET_CAST(CTest1CertStore*, aThis);

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TDriveName driveName(sysDrive.Name());

	TBuf<128> certStoreDefaultFullPath (driveName);

	certStoreDefaultFullPath.Append(_L("\\system\\data\\cacerts.dat"));

	self->iFile.Close();

	self->iFs.Delete(certStoreDefaultFullPath);

	}

CTest1CertStore::~CTest1CertStore()

	{

	Cancel();

	if (iStore != NULL)

		{

#ifdef _DEBUG

#else		

		TInt err;

		TRAP(err, iStore->ReclaimL());

		TRAP(err, iStore->CompactL());

		if (err == KErrNone)

			{

			TRAP(err, iStore->CommitL());

			}

#endif

		delete iStore;

		}

	iFile.Close();

	delete iCerts;

	iKeyInfos.Close();

	delete iUnifiedKeyStore;

	}

void CTest1CertStore::DoSetApplicabilityL(const CCTCertInfo& aCertInfo,

										 const RArray<TUid>& aTrusters)

	{

	TInt index = iCerts->Index(aCertInfo);

	if (index == KErrNotFound)

		{

		User::Leave(index);

		}

	CFileCertStoreMapping* mapping = iCerts->Mapping(index);

	const RArray<TUid>& trusters = mapping->CertificateApps(); //oldEntry->Trusters();

	RArray<TUid>* oldTrusters = new(ELeave) RArray<TUid>();

	CleanupStack::PushL(oldTrusters);

	CleanupClosePushL(*oldTrusters);

	TInt iEnd = trusters.Count();

	TInt i;

	for (i = 0; i < iEnd; i++)

		{

		User::LeaveIfError(oldTrusters->Append(trusters[i]));

		}

	RArray<TUid>* newTrusters = new (ELeave) RArray<TUid>;

	CleanupStack::PushL(newTrusters);

	CleanupClosePushL(*newTrusters);

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

		{

		User::LeaveIfError(newTrusters->Append(aTrusters[i]));		

		}

	mapping->SetCertificateApps(newTrusters);

	CleanupStack::Pop(2, newTrusters);

	TRAPD(err, UpdateStoreL());

	CleanupStack::Pop(2);	// *oldTrusters, oldTrusters

	if (err != KErrNone)

		{

		// If there is an error, we undo the change in oldEntry

		mapping->SetCertificateApps(oldTrusters);

		}

	else

		{

		oldTrusters->Close();

		delete oldTrusters;

		}

	}

void CTest1CertStore::DoSetTrustL(const CCTCertInfo& aCertInfo,

								 TBool aTrusted)

	{

	TInt index = iCerts->Index(aCertInfo);

	if (index == KErrNotFound)

		{

		User::Leave(index);

		}

	CFileCertStoreMapping* mapping = iCerts->Mapping(index);

	TBool oldValue = mapping->Trusted();

	mapping->SetTrusted(aTrusted);

	TRAPD(err, UpdateStoreL());

	if (err != KErrNone)

		{

		// If there is an error, we undo the change in oldEntry

		mapping->SetTrusted(oldValue);

		}

	}

void CTest1CertStore::Add(const TDesC& aLabel,

						 TCertificateFormat aFormat,

						 TCertificateOwnerType aCertificateOwnerType,

						 const TKeyIdentifier* aSubjectKeyId,

						 const TKeyIdentifier* aIssuerKeyId,

						 const TDesC8& aCert, 

						 TRequestStatus& aStatus)

	{

	TRAPD(err, DoAddL(aLabel, aFormat, aCertificateOwnerType, aSubjectKeyId,

		aIssuerKeyId, aCert));

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}