diff -r 675a964f4eb5 -r 35751d3474b7 crypto/weakcryptospi/test/dumpcryptoplugin/dumpcryptoplugin.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/test/dumpcryptoplugin/dumpcryptoplugin.cpp	Thu Sep 10 14:01:51 2009 +0300
@@ -0,0 +1,477 @@
+/*
+* 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;
+	}
+		
+
+
+
+