/*

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