/*

* 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 "unifiedcertstore.h"

#include "unifiedcertstoreworkingvars.h"

#include "CCheckedCertStore.h"

#include <certificateapps.h>

#include <x509cert.h>

#include <wtlscert.h>

#include <hash.h>

#include <ecom/ecom.h>

_LIT(KUCSPanic, "CUnifiedCertStore"); 

#define assert(x) __ASSERT_ALWAYS((x), User::Panic(KUCSPanic, 1));

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

//CUnifiedCertStore

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

EXPORT_C CUnifiedCertStore* CUnifiedCertStore::NewL(RFs& aFs, TBool aOpenForWrite)

	{

	CUnifiedCertStore* self = CUnifiedCertStore::NewLC(aFs, aOpenForWrite);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CUnifiedCertStore* CUnifiedCertStore::NewLC(RFs& aFs, TBool aOpenForWrite)

	{

	CUnifiedCertStore* self = new(ELeave) CUnifiedCertStore(aFs, aOpenForWrite);

	CleanupStack::PushL(self);

	RArray<TInt> orderingFilter;

	self->ConstructL(orderingFilter);

	return self;

	}

EXPORT_C CUnifiedCertStore::~CUnifiedCertStore()

	{

	Cancel();

	assert(!iWorkingVars);

	TInt end = iReadOnlyCertStores.Count();

	TInt i;

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

		{

		iReadOnlyCertStores[i]->Release();

		}

	iReadOnlyCertStores.Close();

	end = iWritableCertStores.Count();

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

		{

		iWritableCertStores[i]->Release();

		}

	iWritableCertStores.Close();

	// The elements are already released by the two loops above

	iCertStores.Close();

	// release resources allocated to order attributes list

	iOrderAttributes.Close();

    DestroyTemporaryMembers();

	iHardwareTypeUids.Close();

	REComSession::FinalClose();

	}

EXPORT_C void CUnifiedCertStore::Initialize(TRequestStatus& aStatus)

	{

	BeginAsyncOp(aStatus, EInitializeGetTokenList);

	TRAPD(err, InitializeL());

	if (err != KErrNone)

		{

		Complete(err);

		}

	}

void CUnifiedCertStore::InitializeL()

	{

	AllocWorkingVarsL();

	// We want the list of all token types that support a readable or writable 

	// certstore interface

	RArray<TUid> uidArray;

	CleanupClosePushL(uidArray);

	User::LeaveIfError(uidArray.Append(TUid::Uid(KInterfaceWritableCertStore)));

	TCTFindTokenTypesByInterface filter(uidArray.Array());

	CCTTokenTypeInfo::ListL(iWorkingVars->iWritableTokenTypes, filter);

	uidArray.Reset();

	User::LeaveIfError(uidArray.Append(TUid::Uid(KInterfaceCertStore)));

	RCPointerArray<CCTTokenTypeInfo> tokenTypes;

	CleanupClosePushL(tokenTypes);

	TCTFindTokenTypesByInterface filter2(uidArray.Array());

	CCTTokenTypeInfo::ListL(tokenTypes, filter2);

  	// Check whether client specified order list has attributes in it

  	if(iOrderAttributes.Count() > 0)

  	    {

  	    ApplyOrderingL(tokenTypes);

  	    }

	// Make a note of all hardware token types

	TInt i = 0;

	TInt end = tokenTypes.Count();

	for (; i < end; i++)

		{

		TCTTokenTypeAttribute software;

		software.iUID = KCTSoftware;

		TInt find = tokenTypes[i]->Attributes().Find(software);

		// In the case (TInt)ETrue == KThirdPartyCertStore == 1  

		if (find != KErrNotFound && tokenTypes[i]->Attributes()[find].iVal != 

			(TInt)ETrue && tokenTypes[i]->Attributes()[find].iVal != KManufactureCertStore)

			{

			// This is a hardware type. Add its UID to the list.

			User::LeaveIfError(iHardwareTypeUids.Append(tokenTypes[i]->Type()));

			}

		}

	i = 0;

	while (i < end)

		{

		TInt j = 0;

		TInt jEnd = iWorkingVars->iWritableTokenTypes.Count();

		while (j < jEnd)

			{

			if (iWorkingVars->iWritableTokenTypes[j]->Type() == tokenTypes[i]->Type())

				{

				break;

				}

			j++;

			}

		if (j == jEnd)

			{

			User::LeaveIfError(iWorkingVars->iReadOnlyTokenTypes.Append(tokenTypes[i]));

			tokenTypes.Remove(i);

			end--;

			}

		else

			{

			i++;

			}

		}

	CleanupStack::PopAndDestroy(2);	// uidArray, tokenTypes

	iWorkingVars->iIndex = -1;

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	SetActive();

	}

EXPORT_C void CUnifiedCertStore::CancelInitialize()

	{

	if (iState == EInitializeGetTokenList ||

		iState == EInitializeGetToken ||

		iState == EInitializeGetWritableInterface ||

		iState == EInitializeGetReadableInterface ||

		iState == EInitializeGetReadableInterfaceFinished ||

		iState == EInitializeFinished)

		{

		Cancel();

		}	

	}

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

							 const CCertAttributeFilter& aFilter,

							 TRequestStatus& aStatus)

	{

	BeginAsyncOp(aStatus, EList);	

	TRAPD(err, ListL(aCertInfos, aFilter));

	if (err != KErrNone)

		{

		Complete(err);

		}

	}

void CUnifiedCertStore::ListL(RMPointerArray<CCTCertInfo>& aCertInfos,

							  const CCertAttributeFilter& aFilter)

	{

	if (!iIsInitialized)

		{

		User::Leave(KErrNotReady);

		}

	AllocWorkingVarsL();

	iWorkingVars->iCertInfos = &aCertInfos;

	iWorkingVars->iFilter = &aFilter;

	iWorkingVars->iCertIndex = aCertInfos.Count();

	iIndex = -1;

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	}

void CUnifiedCertStore::CancelList()

	{

	if (iState == EList ||

		iState == ERetrieveForList)

		{

		Cancel();

		}

	}

EXPORT_C void CUnifiedCertStore::List(RMPointerArray<CCTCertInfo>& aCertInfos,

									  const CCertAttributeFilter& aFilter, 

									  const TDesC8& aIssuer, 

									  TRequestStatus& aStatus)

	{

	RPointerArray<const TDesC8> array;

	if (array.Append(&aIssuer) != KErrNone)

		{

		TRequestStatus* status = &aStatus;

		User::RequestComplete(status, KErrNoMemory);

		}

	else

		{

		List(aCertInfos, aFilter, array, aStatus);

		array.Close();

		}

	}

EXPORT_C void CUnifiedCertStore::List(RMPointerArray<CCTCertInfo>& aCertInfos,

									  const CCertAttributeFilter& aFilter, 

									  RPointerArray<const TDesC8> aIssuers, 

									  TRequestStatus& aStatus)

	{

	BeginAsyncOp(aStatus, EList);	

	TRAPD(err, ListL(aCertInfos, aFilter, aIssuers));

	if (err != KErrNone)

		{

		Complete(err);

		}

	}

void CUnifiedCertStore::ListL(RMPointerArray<CCTCertInfo>& aCertInfos,

							  const CCertAttributeFilter& aFilter, 

							  RPointerArray<const TDesC8> aIssuers)

	{

	// Obscure special case: If aIssuers has no elements, we should

	// return nothing.

	if (aIssuers.Count() == 0)

		{

		Complete(KErrNone);

		return;

		}

	AllocWorkingVarsL();

	iWorkingVars->iCertInfos = &aCertInfos;

	iWorkingVars->iFilter = &aFilter;

	iWorkingVars->iCertIndex = aCertInfos.Count();

	TInt count = aIssuers.Count();

	for (TInt i = 0 ; i < count ; ++i)

		{

		User::LeaveIfError(iWorkingVars->iIssuerNames.Append(aIssuers[i]));

		}

	iIndex = -1;

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);	

	}

EXPORT_C void CUnifiedCertStore::Retrieve(const CCTCertInfo& aCertInfo, 

								 CCertificate*& aCert,

								 TRequestStatus& aStatus)

	{

	BeginAsyncOp(aStatus, ERetrieve);	

	TRAPD(err, RetrieveL(aCertInfo, aCert));

	if (err != KErrNone)

		{

		Complete(err);

		}

	}

void CUnifiedCertStore::RetrieveL(const CCTCertInfo& aCertInfo, 

								  CCertificate*& aCert)

	{

	FindCertStoreL(aCertInfo.Handle());

    if (aCertInfo.CertificateFormat() != EX509Certificate &&

        aCertInfo.CertificateFormat() != EWTLSCertificate)

        {

        User::Leave(KErrNotSupported);

        }

	AllocWorkingVarsL();

	iWorkingVars->iCertDesC = HBufC8::NewMaxL(aCertInfo.Size());

	iWorkingVars->iReturnedCert = &aCert;

	iWorkingVars->iCertType = aCertInfo.CertificateFormat();

	iWorkingVars->iCertDes.Set(iWorkingVars->iCertDesC->Des());

	iCurrentCertStore->Retrieve(aCertInfo, iWorkingVars->iCertDes, iStatus);

	SetActive();

    }

void CUnifiedCertStore::GetCert(CCTCertInfo*& aCertInfo, 

								const TCTTokenObjectHandle& aHandle, 

								TRequestStatus& aStatus)

	{

	BeginAsyncOp(aStatus, EGetCert);

	TRAPD(err, GetCertL(aCertInfo, aHandle));

	if (err != KErrNone)

		{

		Complete(err);

		}

	}

void CUnifiedCertStore::GetCertL(CCTCertInfo*& aCertInfo,

								 const TCTTokenObjectHandle& aHandle)

	{

	FindCertStoreL(aHandle);

	iCurrentCertStore->GetCert(aCertInfo, aHandle, iStatus);

	SetActive();

	}

void CUnifiedCertStore::CancelGetCert()

	{

	if (iState == EGetCert)

		{

		Cancel();

		}

	}

void CUnifiedCertStore::Applications(const CCTCertInfo& aCertInfo,

									 RArray<TUid>& aApplications,

									 TRequestStatus& aStatus)

	{

	BeginAsyncOp(aStatus, EApplications);

	TRAPD(err, ApplicationsL(aCertInfo, aApplications));

	if (err != KErrNone)

		{

		Complete(err);

		}

	}

void CUnifiedCertStore::ApplicationsL(const CCTCertInfo& aCertInfo,

									 RArray<TUid>& aApplications)

	{

	FindCertStoreL(aCertInfo.Handle());

	iCurrentCertStore->Applications(aCertInfo, aApplications, iStatus);

	SetActive();

	}

void CUnifiedCertStore::CancelApplications()

	{

	if (iState == EApplications)

		{

		Cancel();

		}

	}

void CUnifiedCertStore::IsApplicable(const CCTCertInfo& aCertInfo,

									 TUid aApplication, 

									 TBool& aIsApplicable, 

									 TRequestStatus& aStatus)

	{

	BeginAsyncOp(aStatus, EIsApplicable);

	TRAPD(err, IsApplicableL(aCertInfo, aApplication, aIsApplicable));

	if (err != KErrNone)

		{

		Complete(err);

		}

	}

void CUnifiedCertStore::IsApplicableL(const CCTCertInfo& aCertInfo,

									  TUid aApplication, 

									  TBool& aIsApplicable)

	{

	FindCertStoreL(aCertInfo.Handle());

	iCurrentCertStore->IsApplicable(aCertInfo, aApplication, aIsApplicable, iStatus);

	SetActive();

	}

void CUnifiedCertStore::CancelIsApplicable()

	{

	if (iState == EIsApplicable)

		{

		Cancel();

		}

	}

void CUnifiedCertStore::Trusted(const CCTCertInfo& aCertInfo, 

								TBool& aTrusted, 

								TRequestStatus& aStatus)

	{

	BeginAsyncOp(aStatus, ETrusted);

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

	if (err != KErrNone)

		{

		Complete(err);

		}

	}

void CUnifiedCertStore::TrustedL(const CCTCertInfo& aCertInfo, 

								 TBool& aTrusted)

	{

	FindCertStoreL(aCertInfo.Handle());

	iCurrentCertStore->Trusted(aCertInfo, aTrusted, iStatus);

	SetActive();

	}

void CUnifiedCertStore::CancelTrusted()

	{

	if (iState == ETrusted)

		{

		Cancel();

		}

	}

void CUnifiedCertStore::Retrieve(const CCTCertInfo& aCertInfo,

								 TDes8& aEncodedCert,

								 TRequestStatus& aStatus)

	{

	BeginAsyncOp(aStatus, ERetrieveData);

	TRAPD(err, RetrieveDataL(aCertInfo, aEncodedCert));

	if (err != KErrNone)

		{

		Complete(err);

		}

	}

void CUnifiedCertStore::RetrieveDataL(const CCTCertInfo& aCertInfo,

									  TDes8& aEncodedCert)

	{

	FindCertStoreL(aCertInfo.Handle());

	iCurrentCertStore->Retrieve(aCertInfo, aEncodedCert, iStatus);	

	SetActive();

	}

void CUnifiedCertStore::CancelRetrieve()

	{

	if (iState == ERetrieveData)

		{

		Cancel();

		}

	}

EXPORT_C void CUnifiedCertStore::Remove(const CCTCertInfo& aCertInfo,

										TRequestStatus& aStatus)

	{

	BeginAsyncOp(aStatus, ERemove);

	TRAPD(err, RemoveL(aCertInfo));

	if (err != KErrNone)

		{

		Complete(err);

		}

	}

void CUnifiedCertStore::RemoveL(const CCTCertInfo& aCertInfo)

	{

	FindWritableCertStoreL(aCertInfo.Handle());

	iCurrentWritableCertStore->Remove(aCertInfo, iStatus);	

	SetActive();

	}

EXPORT_C void CUnifiedCertStore::CancelRemove()

	{

	if (iState == ERemove)

		{

		Cancel();

		}

	}

EXPORT_C void CUnifiedCertStore::SetApplicability(const CCTCertInfo& aCertInfo, 

												  const RArray<TUid>& aApplications,

												  TRequestStatus& aStatus)

	{

	BeginAsyncOp(aStatus, ESetApplicability);	

	TRAPD(err, SetApplicabilityL(aCertInfo, aApplications));

	if (err != KErrNone)

		{