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