/*

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

 *

 */

 /**

  @file

  @internalComponent

 */

 #include "dumpprocessor.h"

 #include <e32cons.h>

 #include <cryptospi/cryptospidef.h>

 #include <bacline.h>

 #include <cryptospi/cryptocharacteristics.h>

 #include <cryptospi/cryptospistateapi.h>

 using namespace CryptoSpi;

 //Copy-right, Tool name format

 _LIT(KShortName, "Dump CryptoSpi Tool");

 _LIT(KName, "Symbian Dump CryptoSpi Tool");

 _LIT(KCopyright, "Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).  All rights reserved.");

 _LIT(KDone, "Complete Dumping... \n");

 //dumpcryptoplugin options

 _LIT(KAll, "-all");

 _LIT(KAllShort, "-a");

 _LIT(KInterface, "-interface");

 _LIT(KInterfaceShort, "-i");

 _LIT(KAlgorithm, "-algorithm");

 _LIT(KAlgorithmShort, "-al");

 _LIT(KExtended, "-extended");

 _LIT(KExtendedShort, "-e");

 _LIT(KDll, "-dll");

 _LIT(KDllShort, "-d");

 _LIT(KHelp, "-help");

 _LIT(KHelpShort, "-h");

 _LIT(KOutputFile, "-out");

 _LIT(KOutputFileShort, "-o");

 //Error messages

 _LIT(KMissingInterfaceName, "Missing Interface Name. \n");

 _LIT(KInvalidInterfaceName, "Invalid Interface Name. \n");

 _LIT(KMissingAlgorithmName, "Missing Algorithm Name. \n");

 _LIT(KInvalidAlgorithmName, "Invalid Algorithm Name. \n");

 _LIT(KMissingDllName, "Missing Plugin Dll Name. \n");

 _LIT(KMissingOutputName, "Missing Output Name. \n");

 _LIT(KError, "Error=%d \n");

 /**

 The method converts the given interface name to interface uid

 */

 TInt ConvertToInterfaceId(const TDesC& aInterfaceName, TInt32& aInterfaceId)

 	{

 	if (aInterfaceName.CompareF(KHash)==0)

 		{

 		aInterfaceId=KHashInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KRandom)==0)

 		{

 		aInterfaceId=KRandomInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KSymmetricCipher)==0)

 		{

 		aInterfaceId=KSymmetricCipherInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KAsymmetricCipher)==0)

 		{

 		aInterfaceId=KAsymmetricCipherInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KSigner)==0)

 		{

 		aInterfaceId=KSignerInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KVerifier)==0)

 		{

 		aInterfaceId=KVerifierInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KKeyPairGenerator)==0)

 		{

 		aInterfaceId=KKeypairGeneratorInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KKeyAgreement)==0)

 		{

 		aInterfaceId=KKeyAgreementInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KAsyncHash)==0)

 		{

 		aInterfaceId=KAsyncHashInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KAsyncRandom)==0)

 		{

 		aInterfaceId=KAsyncRandomInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KAsyncSymmetricCipher)==0)

 		{

 		aInterfaceId=KAsyncSymmetricCipherInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KAsyncAsymmetricCipher)==0)

 		{

 		aInterfaceId=KAsyncAsymmetricCipherInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KAsyncSigner)==0)

 		{

 		aInterfaceId=KAsyncSignerInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KAsyncVerifier)==0)

 		{

 		aInterfaceId=KAsyncVerifierInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KAsyncKeyPairGenerator)==0)

 		{

 		aInterfaceId=KAsyncKeypairGeneratorInterface;

 		return KErrNone;

 		}

 	if (aInterfaceName.CompareF(KAsyncKeyAgreement)==0)

 		{

 		aInterfaceId=KAsyncKeyAgreementInterface;

 		return KErrNone;

 		}

 	return KErrNotFound;

 	}

 /**

 The method converts the given algorithm name to algorithm uid

 */

 TInt ConvertToAlgorithmId(const TDesC& aAlgorithmName, TInt32& aAlgorithmId)

 	{

 	if (aAlgorithmName.CompareF(KMd2)==0)

 		{

 		aAlgorithmId=KAlgorithmHashMd2;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KMd5)==0)

 		{

 		aAlgorithmId=KAlgorithmHashMd5;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KMd4)==0)

 		{

 		aAlgorithmId=KAlgorithmHashMd4;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KSha1)==0)

 		{

 		aAlgorithmId=KAlgorithmHashSha1;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KDes)==0)

 		{

 		aAlgorithmId=KAlgorithmCipherDes;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(K3Des)==0)

 		{

 		aAlgorithmId=KAlgorithmCipher3Des;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KRC2)==0)

 		{

 		aAlgorithmId=KAlgorithmCipherRc2;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KAes)==0)

 		{

 		aAlgorithmId=KAlgorithmCipherAes;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KRC4)==0)

 		{

 		aAlgorithmId=KAlgorithmCipherArc4;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KRsaCipher)==0)

 		{

 		aAlgorithmId=KAlgorithmCipherRsa;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KRsaSigner)==0)

 		{

 		aAlgorithmId=KAlgorithmSignerRsa;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KRsaVerifier)==0)

 		{

 		aAlgorithmId=KAlgorithmVerifierRsa;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KRsaKeyPair)==0)

 		{

 		aAlgorithmId=KAlgorithmRSAKeyPairGenerator;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KDsaSigner)==0)

 		{

 		aAlgorithmId=KAlgorithmSignerDsa;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KDsaVerifier)==0)

 		{

 		aAlgorithmId=KAlgorithmVerifierDsa;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KDsaKeyPair)==0)

 		{

 		aAlgorithmId=KAlgorithmDSAKeyPairGenerator;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KDhKeyPair)==0)

 		{

 		aAlgorithmId=KAlgorithmDHKeyPairGenerator;

 		return KErrNone;

 		}

 	if (aAlgorithmName.CompareF(KDhKeyAgreement)==0)

 		{

 		aAlgorithmId=KAlgorithmKeyAgreementDH;

 		return KErrNone;

 		}

 	return KErrNotFound;

 	}

 /**

 Displays tool name and copy-right informations.

 */

 void BoilerPlate(CConsoleBase* console) 

 	{

 	console->Printf(KNewLine);

 	console->Printf(KName);

 	console->Printf(KNewLine);	

 	console->Printf(KCopyright);

 	console->Printf(KNewLine);

 	console->Printf(KNewLine);

 	}

 /**

 The method retrieves the command line parameters and build the CDumpToolParameters object.

 */

 void ExtractOptionL(const CCommandLineArguments& aInput, CDumpToolParameters& aParam, CConsoleBase* aConsole)

 	{

 	TInt count=aInput.Count();

 	TInt i=0;

 	while (i<count-1)

 	 	{

 		i++;

 		//Handle -a and -all		

 		if ((aInput.Arg(i).Compare(KAll)==0)||(aInput.Arg(i).Compare(KAllShort)==0))

 			{

 			continue;

 			}		

 		//Handle -i and -interface

 		if ((aInput.Arg(i).Compare(KInterface)==0)||(aInput.Arg(i).Compare(KInterfaceShort)==0))

 			{

 			//Move to interface name

 			i++;

 			if (i>count-1)

 				{

 				aConsole->Printf(KMissingInterfaceName);

 				User::Leave(KErrArgument);	

 				}

 			//Currently point to interface name

 			if (KErrNone!=ConvertToInterfaceId(aInput.Arg(i), aParam.iInterface))

 				{

 				//Invalid interface name

 				aConsole->Printf(KInvalidInterfaceName);

 				User::Leave(KErrArgument);

 				}

 			continue;

 			}

 		//Handle -al and -algorithm

 		if ((aInput.Arg(i).Compare(KAlgorithm)==0)||(aInput.Arg(i).Compare(KAlgorithmShort)==0))

 			{

 			//Move to algorithm name

 			i++;

 			if (i>count-1)

 				{

 				aConsole->Printf(KMissingAlgorithmName);

 				User::Leave(KErrArgument);	

 				}

 			//Currently point to algorithm name

 			if (KErrNone!=ConvertToAlgorithmId(aInput.Arg(i), aParam.iAlgorithm))

 				{

 				//Invalid algorithm name

 				aConsole->Printf(KInvalidAlgorithmName);

 				User::Leave(KErrArgument);

 				}

 			continue;

 			}

 		//Handle -e and -extended

 		if ((aInput.Arg(i).Compare(KExtended)==0)||(aInput.Arg(i).Compare(KExtendedShort)==0))

 			{

 			aParam.iOptions.AppendL(CDumpToolParameters::EOptionExtendedCharacteristic);

 			continue;

 			}		

 		//Handle -d and -dll

 		if ((aInput.Arg(i).Compare(KDll)==0)||(aInput.Arg(i).Compare(KDllShort)==0))

 			{

 			i++;

 			if (i>count-1)

 				{

 				aConsole->Printf(KMissingDllName);

 				User::Leave(KErrArgument);	

 				}

 			aParam.iDllName=aInput.Arg(i);

 			continue;

 			}

 		//Handle -o and -out

 		if ((aInput.Arg(i).Compare(KOutputFile)==0)||(aInput.Arg(i).Compare(KOutputFileShort)==0))

 			{

 			i++;

 			if (i>count-1)

 				{

 				aConsole->Printf(KMissingOutputName);

 				User::Leave(KErrArgument);	

 				}

 			aParam.iDumpFileName=aInput.Arg(i);

 			continue;

 			}

 		//Handle -h and -help

  		if ((aInput.Arg(i).Compare(KHelp)==0)||(aInput.Arg(i).Compare(KHelpShort)==0))

  			{

   			aParam.iOptions.AppendL(CDumpToolParameters::EOptionHelp);

   			continue;

    			}

    		HBufC* temp=aInput.Arg(i).AllocLC();

    		aParam.iInvalidOptions.AppendL(temp);

    		CleanupStack::Pop(temp);

 	 	}

 	}

 void DoProcessL(CConsoleBase* aConsole)

 	{

 	//Get the command line arguments

 	CCommandLineArguments* args = CCommandLineArguments::NewLC();

 	//Construct the parameters holder

 	CDumpToolParameters* params = CDumpToolParameters::NewLC();

 	//Retrieve the command line options

 	ExtractOptionL(*args, *params, aConsole);

 	//Process the command line and output the characteristics.

 	CDumpToolProcessor* processor=CDumpToolProcessor::NewLC(*params, aConsole);

 	processor->ProcessL();

 	aConsole->Printf(KNewLine);

 	CleanupStack::PopAndDestroy(processor);			

 	CleanupStack::PopAndDestroy(2, args); //	params, args, 

 	}

 /**

 Main function to retrieve and log the characteristics

 */

 void DoMainL()

 	{

 	//New a console and print tool information

 	CConsoleBase* console = Console::NewL(KShortName, TSize(KDefaultConsWidth, KDefaultConsHeight));

 	CleanupStack::PushL(console);

 	BoilerPlate(console);

 	TRAPD(err, DoProcessL(console));

 	if (err!=KErrArgument && err!=KErrNone)

 		{

 		console->Printf(KError, err);

 		}

 	if (err!=KErrNone)

 		{

 		console->Printf(KPressAnyKey);

 		console->Getch();			

 		}

 	console->Printf(KDone);

 	//console->Getch();

 	CleanupStack::PopAndDestroy(console); //	params, args, console

 	}

 /**

 @return KErrNone (0) if successful, KErrMemory if out of memory

 otherwise error result from DoMainL

 */

 TInt E32Main()

 	{

 	__UHEAP_MARK;

 	CTrapCleanup* trapCleanup=CTrapCleanup::New();

 	if (!trapCleanup)

 		{

 		return KErrNoMemory;

 		}

 	TRAPD(err, DoMainL());

 	delete trapCleanup;

 	__UHEAP_MARKEND;

 	return err;

 	}