/*

* Copyright (c) 2004-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 <mctkeystore.h>

#include <asn1dec.h>

#include <asnpkcs.h>

#include <unifiedkeystore.h>

#include <securityerr.h>

#include <mctwritablecertstore.h>

#include "certtool_commands.h"

#include "certtool_controller.h"

#include "keytool_commands.h"

const TInt KASN1SequenceTagValue = 0x30;

const TInt KWTLSCertificateVersionValue = 0x01;

/*static*/ CCertToolAdd* CCertToolAdd::NewLC(CCertToolController* aController)

	{

	CCertToolAdd* self = new (ELeave) CCertToolAdd(aController);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;	

	}

/*static*/ CCertToolAdd* CCertToolAdd::NewL(CCertToolController* aController)

	{

	CCertToolAdd* self = CCertToolAdd::NewLC(aController);

	CleanupStack::Pop(self);

	return self;	

	}

CCertToolAdd::~CCertToolAdd()

	{

	Cancel();	

	delete iCertData;	

	}

void CCertToolAdd::ConstructL()

	{

	//The Certificate added is deletable by default.

	iIsDeletable = ETrue;

	}

TCertificateFormat CCertToolAdd::DoRecognizeL(const TDesC8& iData)

	{

	// Ensure length is sufficient for checking type

	if ( iData.Size() >= 1 )

		{

		// First byte of X.509 certificate is an ANS.1 SEQUENCE tag

		if ( iData[0] == KASN1SequenceTagValue )

			{

			return EX509Certificate;

			}

		// First byte of WTLS certificate is version == 1

		else if ( iData[0] == KWTLSCertificateVersionValue )

			{

			return EWTLSCertificate;

			}

		}

	User::Leave(KErrEof);

	return EWTLSCertificate;

	}

/**

 * Inserts a certificate in the certstore. 

 * If a specific certstore implementation is given using

 * the -store command line parameter the certificate is inserted

 * there. If no implementation is specified the first one is used.

 * Initially we try to add the certificate as a *user* certificate

 * if this fails (no corresponding private key in the keystore)

 * the certificate is added a root (CA) certificate.

 * If the option -private was present then the private key is in the

 * keystore and the certificate will be a user certificate.

 */

void CCertToolAdd::DoCommandL(CUnifiedCertStore& aCertStore, CKeyToolParameters* aParam)

	{

	Cancel();	

	iParams = aParam;	

	iCertStore = &aCertStore;

	if (!aParam->iDefault)

		{

		iController->DisplayLocalisedMsgL(R_CERTTOOL_ERR_CERTFILE);			

		User::Leave(KErrNotFound);

		CActiveScheduler::Stop();		

		}

		// must get proper certstore, hard-coded 0 is no good!

		if (aParam->iCertstoreIndex == -1)

			{

			aParam->iCertstoreIndex = 0;

			}

		if (aParam->iCertstoreIndex >= iCertStore->WritableCertStoreCount())

			{

			iController->DisplayLocalisedMsgL(R_CERTTOOL_ERR_NOTEXIST);	

			User::Leave(KErrCorrupt);

			}

		MCTWritableCertStore& wCertStore = iCertStore->WritableCertStore(aParam->iCertstoreIndex);

		if (!iParams->iLabel)

			{

			iParams->iLabel	= (iParams->iDefault)->AllocL();

			}

		// Get the certificate binary!

		RFs fs;

		CleanupClosePushL(fs);

		User::LeaveIfError(fs.Connect());	

		RFile file;

		CleanupClosePushL(file);	

		TInt r = file.Open(fs, *(iParams->iDefault), EFileRead);

		if (r != KErrNone)

			{

			iController->DisplayLocalisedMsgL(R_CERTTOOL_ERR_OPENFAIL);				

			User::Leave(r);

			}

		TInt fileSize = 0;

		file.Size(fileSize);

		if (fileSize <= 0)

		{

			iController->DisplayLocalisedMsgL(R_CERTTOOL_ERR_EMPTYFILE);	

			User::Leave(KErrCorrupt);

		}

		iCertData = HBufC8::NewMaxL(fileSize);

		TPtr8 data(iCertData->Des());

		data.FillZ();

		User::LeaveIfError(file.Read(data, fileSize));

		// Use the recognizer to see what kind of certificate we have!

		TCertificateFormat format = DoRecognizeL(*iCertData);

		iState = EIntermediate;

		/**

		 * If the iIsDeletable variable of iParams is set, parse its value

		 * and set the iIsDeletable flag appropriately.

		 */

		if(iParams->iIsDeletable)

		    {

		    HBufC* lowerCaseString = HBufC::NewLC(iParams->iIsDeletable->Length());

		    TPtr ptr(lowerCaseString->Des());

		    //Convert to lower case.

		    ptr.CopyLC(*iParams->iIsDeletable);

		    if(ptr.CompareF(_L("n")) == 0 || ptr.CompareF(_L("no")) == 0 )

		        {

		        iIsDeletable = EFalse;

		        }

            else if (ptr.CompareF(_L("y")) != 0  && ptr.CompareF(_L("yes")) != 0)

                {

                //Wrong value passed.

                User::Leave(KErrArgument);     

                }

		    CleanupStack::PopAndDestroy(lowerCaseString);            

		    }

		SetActive();

		//wCertStore.Add(*iParams->iLabel, format, ECACertificate, NULL, NULL, *iCertData, iStatus);

		wCertStore.Add(*iParams->iLabel, format, EUserCertificate, NULL, NULL, *iCertData, iIsDeletable, iStatus);

		CleanupStack::PopAndDestroy(2, &fs);

	}

void CCertToolAdd::RunL()

	{	

	if ((iStatus.Int() != KErrNone) && (iStatus.Int() != KErrPrivateKeyNotFound))

		{

		// A problem occured. Handle gracefully.

		User::Leave(iStatus.Int());

		}

	switch (iState)

		{

		case EIntermediate :

			{

			if (iStatus.Int() == KErrPrivateKeyNotFound)

				{

				// Not an user certificate add as root!

				iState = EFinish;

				MCTWritableCertStore& wCertStore = iCertStore->WritableCertStore(iParams->iCertstoreIndex);

				TCertificateFormat format = DoRecognizeL(*iCertData);

				SetActive();				

				wCertStore.Add(*iParams->iLabel, format, ECACertificate, NULL, NULL, *iCertData, iIsDeletable, iStatus);				

				}

			else 

				{

				iController->DisplayLocalisedMsgL(R_CERTTOOL_ERR_IMPORTSUCCESS);			

				CActiveScheduler::Stop();				

				}

			}

			break;

		case EFinish : 

			{

			iController->DisplayLocalisedMsgL(R_CERTTOOL_ERR_IMPORTSUCCESS);

			CActiveScheduler::Stop();			

			}	

			break;

		default :

			{

			}

		}

	}

TInt CCertToolAdd::RunError(TInt aError)

	{

	CActiveScheduler::Stop();

	switch (aError)

		{

		case KErrBadName:

			{

			// Most likely it was there already

			TRAP_IGNORE(iController->DisplayErrorL(_L("The given label is invalid, or already present in the certstore."), iParams->iPageWise));

			}

			break;

		case KErrKeyNotWeakEnough:

			{

			TRAP_IGNORE(iController->DisplayLocalisedMsgL(R_CERTTOOL_ERR_WEAK, iStatus.Int()));			

			}

			break;			

		default:

			{

			TRAP_IGNORE(iController->DisplayLocalisedMsgL(R_CERTTOOL_ERR_IMPORT, iStatus.Int()));			

			}

		}	

	return KErrNone;

	}

void CCertToolAdd::DoCancel()

	{

	}

CCertToolAdd::CCertToolAdd(CCertToolController* aController) : CCertToolCommand(aController)

	{

	CActiveScheduler::Add(this);	

	}