/*

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

 * tcertuils.cpp

 *

 */

 #include "tcertutils.h"

 #include <wtlscert.h>

 #include <certificateapps.h>

 #include "t_input.h"

 #include <ccertattributefilter.h>

 #include <cctcertinfo.h>

 #include <mctwritablecertstore.h>

 EXPORT_C CCertUtils* CCertUtils::NewL(RFs& aFs)

 	{

 	CCertUtils* self = CCertUtils::NewLC(aFs);

 	CleanupStack::Pop(self);

 	return self;

 	}

 EXPORT_C CCertUtils* CCertUtils::NewLC(RFs& aFs)

 	{

 	CCertUtils* self = new(ELeave) CCertUtils(aFs);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	return self;

 	}

 CCertUtils::CCertUtils(RFs& aFs)

 : CActive(EPriorityNormal), iFs(aFs)

 	{

 	CActiveScheduler::Add(this);

 	}

 EXPORT_C CCertUtils::~CCertUtils()

 	{

 	Cancel();

 	delete iCertificate;

 	delete iCreatedUnifiedCertStore;

 	delete iCertData;

 	delete iLabelData;

 	delete iSecondCertUtils;

 	delete iCAFilter;

 	delete iUserFilter;

 	iCACertStoreEntries.Close();		// The entries are owned by us

 	iUserCertStoreEntries.Close();		// The entries are owned by us

 	iTrusters.Close();

 	}

 /**

 This function handles all the asynchronous calls. There is at least 

 one state for each of the functions of CCertUtils that requires 

 asynchronicity.

 */

 void CCertUtils::RunL()

 	{

 	if (iStatus != KErrNone)

         {

         User::RequestComplete(iOriginalRequestStatus, iStatus.Int());

         return;

         }

 	switch (iState)

 		{

 		// Used for AddCACerts

 		case EAddCACerts:

 			HandleEAddCACertsL();

 			break;

 		// Used for AddCert

 		case EAddCert:

 			TRAPD(err, HandleEAddCACertL());

 			if (err != KErrNone)

 				{

 				iDiagnosticState = EAddCert;

                 User::RequestComplete(iOriginalRequestStatus, err);

 				}

 			break;

 		case EAddCACertGetCAEntry:

 			HandleEAddCACertGetCAEntry();

 			break;

 		case EAddCACertSetApplications:

 			HandleEAddCACertSetApplicationsL();

 			break;

 		case EAddCACertSetTrust:

 			HandleEAddCACertSetTrust();

 			break;

 		case EAddCACertFinished:

 			HandleEAddCACertFinishedL();

 			delete iCreatedUnifiedCertStore;

 			iCreatedUnifiedCertStore = 0;

 			break;

 		// Used for RemoveCerts

 		case ERemoveCertsGetCACerts:

 			HandleERemoveCertsGetCACerts();

 			break;

 		case ERemoveCertsCACertsRetrieved:

 			HandleERemoveCertsCACertsRetrieved();

 			break;

 		case ERemoveCertsRemoveCACerts:

 			HandleERemoveCertsRemoveCACerts();

 			break;

 		case ERemoveCertsGetUserCerts:

 			HandleERemoveCertsGetUserCerts();

 			break;

 		case ERemoveCertsUserCertsRetrieved:

 			HandleERemoveCertsUserCertsRetrieved();

 			break;

 		case ERemoveCertsRemoveUserCerts:

 			HandleERemoveCertsRemoveUserCerts();

 			break;

 		case ERemoveCertsFinished:

 			HandleERemoveCertsFinished();

 			delete iCreatedUnifiedCertStore;

 			iCreatedUnifiedCertStore = 0;

 			break;

 		default:

 			break;

 		}

 	}

 TInt CCertUtils::RunError(TInt aError)

     {

 	User::RequestComplete(iOriginalRequestStatus, aError);

     return KErrNone;

     }

 void CCertUtils::DoCancel()

 	{

 	if (iSecondCertUtils)

 		iSecondCertUtils->Cancel();

 	if (iUnifiedCertStore)

 		{

 		iUnifiedCertStore->Cancel();

 		if (iUnifiedCertStore->WritableCertStoreCount() != 0)

 			{

 			MCTWritableCertStore *store;

 			store = &iUnifiedCertStore->WritableCertStore(0);

 			store->CancelRemove();

 			store->CancelSetApplicability();

 			}

 		}

 	if (iStore)

 		iStore->CancelAdd();

 	}

 EXPORT_C CCertificate* CCertUtils::CertFromFileLC(const TDesC& aFilename, 

 												  const TDesC& aPathname, 

 												  RFs& aFs,

 												  TCertificateFormat aFormat)

 	{

 	TFileName fullname;

 	fullname.Append(aPathname);

 	fullname.Append(aFilename);

 	HBufC8* certBuf = Input::ReadFileLC(fullname, aFs);

 	CCertificate* cert = 0;

 	if (aFormat == EX509Certificate)

 		{

 		cert = CX509Certificate::NewLC(*certBuf);

 		}

 	else if (aFormat == EWTLSCertificate)

 		{

 		cert = CWTLSCertificate::NewLC(*certBuf);

 		}

 	CleanupStack::Pop();//cert

 	CleanupStack::PopAndDestroy();//buf

 	CleanupStack::PushL(cert);

 	return cert;

 	}

 EXPORT_C CCertificate* CCertUtils::CertFromFileL(const TDesC& aFilename,

 												 const TDesC& aPathname,

 												 RFs& aFs,

 												 TCertificateFormat aFormat)

 	{

 	CCertificate* cert = CertFromFileLC(aFilename, aPathname, aFs, aFormat);

 	CleanupStack::Pop();

 	return cert;

 	}

 EXPORT_C void CCertUtils::AddCertL(const TDesC& aLabel,

 								  TCertificateFormat aFormat,

 								  TCertificateOwnerType aCertificateOwnerType, 

 								  TInt aTrustedUsage, 

 								  const TDesC& aCertificatePath, 

 								  const TDesC& aCertificateFileName,

 								  TRequestStatus& aStatus)

 	{

 	iOriginalRequestStatus = &aStatus;

 	aStatus = KRequestPending;

 	// We set up the member variable as required for this function

 	iCertificateFileName = &aCertificateFileName;

 	iLabel = &aLabel;

 	iFormat = aFormat;

 	iTrustedUsage = aTrustedUsage;

 	iPath = &aCertificatePath;

 	iCertificateOwnerType = aCertificateOwnerType;

 	if (iCreatedUnifiedCertStore)

 		{

 		delete iCreatedUnifiedCertStore;

 		}

 	iCreatedUnifiedCertStore = CUnifiedCertStore::NewL(iFs, ETrue);	// We want to open it for 

 																	// writing

 	iUnifiedCertStore = iCreatedUnifiedCertStore;

 	iCreatedUnifiedCertStore->Initialize(iStatus);

 	iState = EAddCert;

 	SetActive();

 	}

 EXPORT_C void CCertUtils::AddCert(const TDesC& aLabel,

 								  TCertificateFormat aFormat,

 								  TCertificateOwnerType aCertificateOwnerType, 

 								  TInt aTrustedUsage, 

 								  const TDesC& aCertificatePath, 

 								  const TDesC& aCertificateFileName,

 								  CUnifiedCertStore& aUnifiedCertStore,

 								  TRequestStatus& aStatus)

 	{

 	iOriginalRequestStatus = &aStatus;

 	aStatus = KRequestPending;

 	// We set up the member variable as required for this function

 	iCertificateFileName = &aCertificateFileName;

 	iLabel = &aLabel;

 	iFormat = aFormat;

 	iTrustedUsage = aTrustedUsage;

 	iPath = &aCertificatePath;

 	iCertificateOwnerType = aCertificateOwnerType;

 	iUnifiedCertStore = &aUnifiedCertStore;

 	iState = EAddCert;

 	SetActive();

 	TRequestStatus* status = &iStatus;

 	User::RequestComplete(status, KErrNone);

 	}

 EXPORT_C void CCertUtils::AddCACertsL(const CDesCArray& aRoots,

 									  const CDesCArray& aLabels,

 									  TCertificateFormat aFormat,

 									  TInt aTrustedUsage, 									

 									  const TDesC& aPath,

 									  TRequestStatus& aStatus)

 	{

 	iOriginalRequestStatus = &aStatus;

 	aStatus = KRequestPending;

 	// We set up the member variable as required for this function

 	iRoots = &aRoots;

 	iFormat = aFormat;

 	iLabels = &aLabels;	

 	iTrustedUsage = aTrustedUsage;

 	iPath = &aPath;

 	iIndex = -1;	// -1 because it will be incremented before its first use

 	if (!iSecondCertUtils)

 		{

 		iSecondCertUtils = CCertUtils::NewL(iFs);

 		}

 	if (iCreatedUnifiedCertStore)

 		{

 		delete iCreatedUnifiedCertStore;

 		}

 	iCreatedUnifiedCertStore = CUnifiedCertStore::NewL(iFs, ETrue);	// We want to open it for 

 																	// writing

 	iUnifiedCertStore = iCreatedUnifiedCertStore;

 	iCreatedUnifiedCertStore->Initialize(iStatus);

 	iState = EAddCACerts;

 	SetActive();

 	}

 EXPORT_C void CCertUtils::AddCACertsL(const CDesCArray& aRoots,

 									  const CDesCArray& aLabels,

 									  TCertificateFormat aFormat,

 									  TInt aTrustedUsage, 									

 									  const TDesC& aPath,

 									  CUnifiedCertStore& aUnifiedCertStore, 

 									  TRequestStatus& aStatus)

 	{

 	iOriginalRequestStatus = &aStatus;

 	aStatus = KRequestPending;

 	// We set up the member variable as required for this function

 	iRoots = &aRoots;

 	iFormat = aFormat;

 	iLabels = &aLabels;

 	iTrustedUsage = aTrustedUsage;

 	iPath = &aPath;

 	iUnifiedCertStore = &aUnifiedCertStore;

 	iIndex = -1;	// -1 because it will be incremented before its first use

 	if (!iSecondCertUtils)

 		{

 		iSecondCertUtils = CCertUtils::NewL(iFs);

 		}

 	iState = EAddCACerts;

 	SetActive();

 	TRequestStatus* status = &iStatus;

 	User::RequestComplete(status, KErrNone);

 	}

 EXPORT_C void CCertUtils::RemoveCertsL(CUnifiedCertStore& aUnifiedCertStore,

 									   TRequestStatus& aStatus)

 	{

 	iOriginalRequestStatus = &aStatus;

 	aStatus = KRequestPending;	

 	iUnifiedCertStore = &aUnifiedCertStore;

 	iState = ERemoveCertsGetCACerts;

 	TRequestStatus* status = &iStatus;

 	User::RequestComplete(status, KErrNone);

 	SetActive();

 	}

 EXPORT_C void CCertUtils::RemoveCertsL(TRequestStatus& aStatus)

 	{

 	iOriginalRequestStatus = &aStatus;

 	aStatus = KRequestPending;	

 	iState = ERemoveCertsGetCACerts;

 	if (iCreatedUnifiedCertStore)

 		{

 		delete iCreatedUnifiedCertStore;

 		}

 	iCreatedUnifiedCertStore = CUnifiedCertStore::NewL(iFs, ETrue);	// We want to open it for 

 																	// writing

 	iUnifiedCertStore = iCreatedUnifiedCertStore;

 	iCreatedUnifiedCertStore->Initialize(iStatus);

 	SetActive();

 	}

 EXPORT_C void CCertUtils::WriteError(TValidationError aError, Output& aOut)

 	{

 	aOut.writeString(CCertUtils::MapError(aError));

 	}

 EXPORT_C TPtrC CCertUtils::MapError(TValidationError aError)

 	{

 	switch(aError)

 		{

 		//errors

 		case EValidatedOK:

 			{

 			return (_L("Validated OK"));

 			}

 		case EChainHasNoRoot:

 			{

 			return(_L("Chain has no root"));

 			}

 		case ESignatureInvalid:

 			{

 			return(_L("Signature invalid"));

 			}

 		case EDateOutOfRange:

 			{

 			return(_L("Date out of range"));

 			}

 		case ENameIsExcluded:

 			{

 			return(_L("Name is excluded"));

 			}

 		case ENameNotPermitted:

 			{

 			return(_L("Name is not permitted"));

 			}

 		case ECertificateRevoked:

 			{

 			return(_L("Certificate revoked"));

 			}

 		case EUnrecognizedCriticalExtension:

 			{

 			return(_L("Unrecognized Critical Extension"));

 			}

 		case ENoBasicConstraintInCACert:

 			{

 			return(_L("CA cert with no Basic Constraint"));

 			}

 		case ENoAcceptablePolicy:

 			{

 			return(_L("No acceptable policy"));

 			}

 		case EPathTooLong:

 			{

 			return(_L("Path too long"));

 			}

 		case ENegativePathLengthSpecified:

 			{

 			return(_L("Negative path length specified"));

 			}

 		case ENamesDontChain:

 			{

 			return(_L("Names don't chain"));

 			}

 		case ERequiredPolicyNotFound:

 			{

 			return(_L("Required policy not found"));

 			}

 		case EBadKeyUsage:

 			{

 			return(_L("Bad key usage"));

 			}

 		case ENotCACert:

 			{

 			return(_L("Non-CA cert used as CA cert"));

 			}

 		//warnings

 		case ERootCertNotSelfSigned:

 			{

 			return(_L("Root cert not self-signed"));

 			}

 		case ECriticalExtendedKeyUsage:

 			{

 			return(_L("Critical extended key usage"));

 			}

 		case ECriticalCertPoliciesWithQualifiers:

 			{

 			return(_L("Critical cert policies with qualifiers"));

 			}

 		case ECriticalPolicyMapping:

 			{

 			return(_L("Critical policy mapping"));

 			}

 		case ECriticalDeviceId:

 			{

 			return(_L("Critical Device Id"));

 			}

 		case ECriticalSid:

 			{

 			return(_L("Critical Sid"));

 			}

 		case ECriticalVid:

 			{

 			return(_L("Critical Vid"));

 			}

 		case ECriticalCapabilities:

 			{

 			return(_L("Critical Capabilities"));

 			}

 		}

 	return (_L("Unknown Error"));

 	}

 EXPORT_C HBufC* CCertUtils::DiagnosticLC() const

 	{

 	HBufC* result = HBufC::NewLC(600);

 	switch (iDiagnosticState)

 		{

 		case EAddCert:

 			result->Des().Append(_L("EAddCACert"));

 			result->Des().Append(_L(" : "));

 			result->Des().Append(iDiagnosticMessage);

 			break;

 		default:

 			break;

 		}

 	return result;

 	}

 EXPORT_C void CCertUtils::AddApplicationL(const TDesC& aName, TUid aUid) const

 	{

 	CCertificateAppInfoManager* appManager = CCertificateAppInfoManager::NewL(iFs, ETrue);

 	CleanupStack::PushL(appManager);

 	// Only add the application if it doesn't exist already

 	const RArray<TCertificateAppInfo>& apps = appManager->Applications();

 	TInt i;

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

 		{

 		if (apps[i].Id() == aUid && apps[i].Name() == aName)

 			break;

 		}

 	if (i == apps.Count())

 		{

 		appManager->AddL(TCertificateAppInfo(aUid, aName));

 		}

 	CleanupStack::PopAndDestroy(appManager);

 	}

 EXPORT_C void CCertUtils::RemoveApplicationL(TUid aUid) const

 	{

 	CCertificateAppInfoManager* appManager = CCertificateAppInfoManager::NewL(iFs, ETrue);

 	CleanupStack::PushL(appManager);

 	appManager->RemoveL(aUid);

 	CleanupStack::PopAndDestroy(appManager);

 	}

 void CCertUtils::ConstructL()

 	{

 	iCAFilter = CCertAttributeFilter::NewL();

 	iCAFilter->SetOwnerType(ECACertificate);

 	iUserFilter = CCertAttributeFilter::NewL();

 	iUserFilter->SetOwnerType(EUserCertificate);

 	}

 void CCertUtils::HandleEAddCACertsL()

 	{

 	iIndex++;

 	if (iIndex < iRoots->Count())

 		{

 		// We still have some certificates to add

 		if (iCertData)

 			{	

 			delete iCertData;

 			iCertData = 0;

 			}

 		iCertData = iRoots->MdcaPoint(iIndex).AllocL();

 		if (iLabelData)

 			{

 			delete iLabelData;

 			iLabelData = 0;

 			}

 		iLabelData = iLabels->MdcaPoint(iIndex).AllocL();

 		iSecondCertUtils->AddCert(*iLabelData, iFormat, ECACertificate,

 			iTrustedUsage, *iPath, *iCertData, *iUnifiedCertStore, iStatus);

 		SetActive();

 		}

 	else

 		{

 		// We have finished adding all the certificates

 		delete iSecondCertUtils;

 		iSecondCertUtils = 0;

 		delete iCreatedUnifiedCertStore;

 		iCreatedUnifiedCertStore = 0;

 		User::RequestComplete(iOriginalRequestStatus, KErrNone);

 		}

 	}

 void CCertUtils::HandleEAddCACertL()

 	{

 	// At this stage we should always have an initialized iStoreManager

 	__ASSERT_DEBUG(iUnifiedCertStore, User::Panic(_L("TCertUtils"), 1));

 	// We use the first writable certstore

 	iStore = &iUnifiedCertStore->WritableCertStore(0);

 	__ASSERT_DEBUG(!iCertificate, User::Panic(_L("TCertUtils"), 1));

 	iCertificate = 0;

 	TRAPD(err, iCertificate =

 		CCertUtils::CertFromFileL(*iCertificateFileName, *iPath, iFs, iFormat));

 	if (err != KErrNone)

 		{

 		if (err != KErrNoMemory)

 			{

 			iDiagnosticMessage.Zero();

 			iDiagnosticMessage.Append(_L("CertFromFileL failed ("));

 			iDiagnosticMessage.Append(*iCertificateFileName);

 			iDiagnosticMessage.Append(_L(")"));

 			}

 		User::Leave(err);

 		}

 	iEncoding.Set(iCertificate->Encoding());

 	iStore->Add(*iLabel, iFormat, iCertificateOwnerType, 0, 0, iEncoding, iStatus);

 	iState = EAddCACertGetCAEntry;

 	SetActive();

 	}

 void CCertUtils::HandleEAddCACertGetCAEntry()

 	{

 	delete iCertificate;

 	iCertificate = 0;

 	iCACertStoreEntries.Close();

 	iUnifiedCertStore->List(iCACertStoreEntries, *iCAFilter, iStatus);

 	iState = EAddCACertSetApplications;

 	SetActive();

 	}

 void CCertUtils::HandleEAddCACertSetApplicationsL()

 	{

 	CCTCertInfo* entry = 0;

 	TInt iEnd = iCACertStoreEntries.Count();

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

 		{

 		if (iCACertStoreEntries[i]->Label() == *iLabel)

 			{

 			entry = iCACertStoreEntries[i];

 			}

 		}

 	__ASSERT_ALWAYS(entry, User::Panic(_L("TCertUtils"), 1));

 	iTrusters.Reset();

 	TUid truster = { iTrustedUsage };

 	User::LeaveIfError(iTrusters.Append(truster));

 	iUnifiedCertStore->SetApplicability(*entry, iTrusters, iStatus);

 	iState = EAddCACertSetTrust;

 	SetActive();

 	}

 void CCertUtils::HandleEAddCACertSetTrust()

 	{

 	CCTCertInfo* entry = 0;

 	TInt iEnd = iCACertStoreEntries.Count();

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

 		{

 		if (iCACertStoreEntries[i]->Label() == *iLabel)

 			{

 			entry = iCACertStoreEntries[i];

 			}

 		}

 	__ASSERT_ALWAYS(entry, User::Panic(_L("TCertUtils"), 1));

 	iUnifiedCertStore->SetTrust(*entry, ETrue, iStatus);

 	iState = EAddCACertFinished;

 	SetActive();

 	}

 void CCertUtils::HandleEAddCACertFinishedL()

 	{

 	User::RequestComplete(iOriginalRequestStatus, iStatus.Int());

 	}

 void CCertUtils::HandleERemoveCertsGetCACerts()

 	{

 	// At this stage we should always have an initialized iStoreManager

 	__ASSERT_DEBUG(iUnifiedCertStore, User::Panic(_L("TCertUtils"), 1));

 	iCACertStoreEntries.Close();

 	iUnifiedCertStore->List(iCACertStoreEntries, *iCAFilter, iStatus);

 	iState = ERemoveCertsCACertsRetrieved;

 	SetActive();

 	}

 void CCertUtils::HandleERemoveCertsCACertsRetrieved()

 	{

 	// This index will be used to keep track of the current entry

 	iIndex = -1;

 	iState = ERemoveCertsRemoveCACerts;

 	TRequestStatus* status = &iStatus;

 	SetActive();

 	User::RequestComplete(status, KErrNone);

 	}

 void CCertUtils::HandleERemoveCertsRemoveCACerts()

 	{

 	iIndex++;

 	if (iIndex < iCACertStoreEntries.Count())

 		{

 		// Remove this certificate if it can be deleted.

 		CCTCertInfo& cert = *iCACertStoreEntries[iIndex];

 		// Unfortunately, certs in non-writable stores can still be

 		// marked as deletable, so need to check if cert is also in a

 		// writable store.

 		TBool isDeletable = cert.IsDeletable();

 		TBool inWritableStore = EFalse;

 		TCTTokenObjectHandle certHandle(cert.Handle());

 		TInt writeStoreCount = iUnifiedCertStore->WritableCertStoreCount();

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

 			{

 			MCTWritableCertStore& wcs = iUnifiedCertStore->WritableCertStore(i);

 			if (wcs.Token().Handle() == certHandle.iTokenHandle)

 				{

 				inWritableStore = ETrue;

 				break;

 				}

 			}

 		if (isDeletable && inWritableStore)

 			{

 			iUnifiedCertStore->Remove(cert, iStatus);

 			SetActive();

 			}

 		else

 			{

 			TRequestStatus* status = &iStatus;

 			SetActive();

 			User::RequestComplete(status, KErrNone);

 			}

 		}

 	else

 		{

 		iState = ERemoveCertsGetUserCerts;

 		TRequestStatus* status = &iStatus;

 		SetActive();

 		User::RequestComplete(status, KErrNone);

 		}

 	}

 void CCertUtils::HandleERemoveCertsGetUserCerts()

 	{

 	// At this stage we should always have an initialized iStoreManager

 	__ASSERT_DEBUG(iUnifiedCertStore, User::Panic(_L("TCertUtils"), 1));

 	iUserCertStoreEntries.Close();

 	iUnifiedCertStore->List(iUserCertStoreEntries, *iUserFilter, iStatus);

 	iState = ERemoveCertsUserCertsRetrieved;

 	SetActive();

 	}

 void CCertUtils::HandleERemoveCertsUserCertsRetrieved()

 	{

 	iIndex = -1;

 	iState = ERemoveCertsRemoveUserCerts;

 	TRequestStatus* status = &iStatus;

 	SetActive();

 	User::RequestComplete(status, KErrNone);

 	}

 void CCertUtils::HandleERemoveCertsRemoveUserCerts()

 	{

 	// At this stage we should always have an initialized iStoreManager

 	__ASSERT_DEBUG(iUnifiedCertStore, User::Panic(_L("TCertUtils"), 1));

 	iIndex++;

 	if (iIndex < iUserCertStoreEntries.Count())

 		{

 		iUnifiedCertStore->Remove(*iUserCertStoreEntries[iIndex], iStatus);

 		SetActive();

 		}

 	else

 		{

 		iState = ERemoveCertsFinished;

 		TRequestStatus* status = &iStatus;

 		SetActive();

 		User::RequestComplete(status, KErrNone);

 		}

 	}

 void CCertUtils::HandleERemoveCertsFinished()

 	{

 	User::RequestComplete(iOriginalRequestStatus, KErrNone);

 	}