diff -r 000000000000 -r bde4ae8d615e os/security/cryptoservices/filebasedcertificateandkeystores/test/certtool/certtool.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/security/cryptoservices/filebasedcertificateandkeystores/test/certtool/certtool.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,501 @@
+/*
+* 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 <e32cons.h>
+#include <bacline.h>
+
+#include "keytool_utils.h"
+#include "keytool_view_imp.h"
+#include "keytool_commands.h"
+#include "certtool_controller.h"
+#include "keytoolfileview.h"
+
+
+// Boiler plate 
+_LIT(KShortName, "Symbian OS CertTool");
+_LIT(KName, "Symbian OS CertStore Manipulation Tool");
+_LIT(KCopyright, "Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).  All rights reserved.");
+
+_LIT(KNewLine, "\n");
+
+_LIT(KDone, "Press any key to continue... \n");
+
+// CertTool command line parameters
+
+_LIT(KList, "-list");
+_LIT(KListShort, "-l");
+
+_LIT(KListStores, "-liststores");
+_LIT(KListStoresShort, "-ls");
+
+_LIT(KImport, "-import");
+_LIT(KImportShort, "-i");
+
+_LIT(KPrivate, "-private");
+
+
+_LIT(KSetApps, "-setapps");
+_LIT(KSetAppsShort, "-s");
+
+_LIT(KAddApps, "-addapps");
+_LIT(KAddAppsShort, "-a");
+
+_LIT(KApps, "-apps");
+
+_LIT(KRemoveApps, "-removeapps");
+
+_LIT(KRemove, "-remove");
+_LIT(KRemoveShort, "-r");
+
+// remove private key also while removing the certificate
+// which is applicable iff the key is imported using the certool -private option
+
+_LIT(KRemoveKeyAlso, "-rka");
+
+_LIT(KStore, "-store");
+
+_LIT(KHelp, "-help");
+_LIT(KHelpShort, "-h");
+
+// Command parameters
+_LIT(KLabel, "-label");
+
+_LIT(KDetails, "-details");
+_LIT(KDetailsShort, "-d");
+
+_LIT(KOwnerType, "-owner");
+_LIT(KOwnerTypeShort, "-o");
+
+_LIT(KPageWise, "-page");
+_LIT(KPageWiseShort, "-p");
+
+_LIT(KUids, "-uids");
+
+_LIT(KDeletable, "-deletable");
+_LIT(KDeletableShort, "-del");
+
+const TInt KMaxArgs = 10;
+
+/**
+ * Certtool can operate in the following modes.
+**/
+enum OperationMode {
+Interactive,
+NonInteractive
+};
+
+
+/**
+ * Displays tool name and copy-right informations.
+ */
+LOCAL_D void BoilerPlateL(CConsoleBase* console) 
+	{
+	console->Printf(KNewLine);
+	console->Printf(KName);
+	console->Printf(KNewLine);	
+	console->Printf(KCopyright);
+	console->Printf(KNewLine);
+	console->Printf(KNewLine);	
+	}
+
+LOCAL_D TBool VerifyCommand(const TDesC& aCommand, TInt& aCmdNum, TInt& aCmdCount)
+	{
+	if ((aCmdNum != -1) && (aCommand[0] == '-'))
+		{
+		aCmdNum = CertToolDefController::KUsageCommand;
+		aCmdCount = KMaxArgs;
+		return 1;
+		}
+	if (aCommand.CompareF(KList) == 0 || aCommand.Compare(KListShort) == 0)
+		{
+		aCmdNum = CertToolDefController::KListCommand;
+		}
+	else if (aCommand.CompareF(KListStores) == 0 || aCommand.Compare(KListStoresShort) == 0)
+		{
+		aCmdNum = CertToolDefController::KListStoresCommand;
+		}
+	else if	(aCommand.CompareF(KImport) == 0 || aCommand.Compare(KImportShort) == 0)
+		{
+		aCmdNum = CertToolDefController::KImportCommand;
+		}
+	else if	(aCommand.CompareF(KRemove) == 0 || aCommand.Compare(KRemoveShort) == 0)
+		{
+		aCmdNum = CertToolDefController::KRemoveCommand;
+		}
+	else if	(aCommand.CompareF(KSetApps) == 0 || aCommand.Compare(KSetAppsShort) == 0)
+		{
+		aCmdNum = CertToolDefController::KSetAppsCommand;
+		}
+	else if	(aCommand.CompareF(KAddApps) == 0 || aCommand.Compare(KAddAppsShort) == 0)
+		{
+		aCmdNum = CertToolDefController::KAddAppsCommand;
+		}
+	else if	(aCommand.CompareF(KRemoveApps) == 0 )
+		{
+		aCmdNum = CertToolDefController::KRemoveAppsCommand;
+		}
+	else	
+		{
+		return 0;
+		}
+
+	return 1;
+	}
+	
+/**
+ * Returns the mode in which the tool would operate. If the command is invoked 
+ * with 2 parameters(certool inputFile outputFile), the tool works in non-interactive
+ * mode else the interactive mode is chosen.
+ */
+
+LOCAL_D OperationMode ModeOfOperationL(const CCommandLineArguments& aCmdArgs, RFs& aFs, RFile& aFile)
+    {
+    OperationMode mode = Interactive;
+    if (KeyToolUtils::DoesFileExistsL(aFs,aCmdArgs.Arg(1)))
+        {
+		mode = NonInteractive;
+        TInt error = aFile.Open(aFs, aCmdArgs.Arg(1), EFileRead|EFileShareAny);
+        aFile.Close();
+        
+        TInt error1 = aFile.Replace(aFs, aCmdArgs.Arg(2), EFileWrite|EFileShareExclusive);
+        // If the input file doesn't exist or not able to create outputfile
+        // switch to Interactive mode
+        if (error != KErrNone || error1 != KErrNone)
+            {
+            CleanupStack::PopAndDestroy(&aFile);
+            mode = Interactive;
+            }   
+                    
+         }
+    return mode;
+    }
+
+/**
+ * The main parsing logic. Same for interactive and non-interactive modes.
+ */
+LOCAL_D void ParseAndHandleCommandL(CArrayFixFlat<TPtrC>& aArgs, CCertToolController& aController)
+    {
+    CKeyToolParameters* params = CKeyToolParameters::NewLC();
+            
+    TInt command = -1; 
+    TInt i = -1;
+           
+    TInt argsCount = aArgs.Count();
+    while (i < (argsCount-1))
+        {
+        i++;
+        if ((aArgs.At(i).CompareF(KDetails)==0)|| (aArgs.At(i).Compare(KDetailsShort)==0))
+                    {
+                    params->iIsDetailed = ETrue;
+                    continue;
+                    }
+        
+                if (aArgs.At(i).CompareF(KPageWise)==0 || (aArgs.At(i).Compare(KPageWiseShort)==0))
+                    {
+                    i++;
+                    params->iPageWise = ETrue;
+                    continue;
+                    }
+
+                if (aArgs.At(i).Compare(KRemoveKeyAlso)==0)
+                    {
+                    params->iRemoveKey = ETrue;
+                    continue;
+                    }
+
+                if (aArgs.At(i).CompareF(KApps)==0)
+                    {
+                    i++;
+                    RArray<TUid> apps;
+                    TInt k = 0;
+                    for (k = i; k < argsCount; k++)
+                        {               
+                        if (aArgs.At(k).Find(_L("-")) == KErrNotFound)
+                            {
+                            TUint uid;
+                            if (aArgs.At(k).CompareF(KSWInstall)==0)
+                                {
+                                uid = swinstalluid;
+                                }
+                            else
+                                {
+                                if (aArgs.At(k).CompareF(KSWInstallOCSP)==0)
+                                    {
+                                    uid = swinstallocspuid;
+                                    }
+                                else
+                                    {
+                                    if (aArgs.At(k).CompareF(KMidletInstall)==0)
+                                        {
+                                        uid = midletinstalluid;
+                                        }
+                                    else
+                                        {
+                                        if (aArgs.At(k).CompareF(KTls)==0)
+                                            {
+                                            uid = tlsuid;
+                                            }
+                                        else
+                                            {
+                                            // no more valid apps, break cycle
+                                            break;
+                                            }
+                                        }
+                                    }
+                                }
+                            apps.Append(TUid::Uid(uid));                        
+                            }
+                        else 
+                            {
+                            // We parsed all UIDs, break the cycle and go on!
+                            break;
+                            }
+                        }
+                    i = k-1;
+                    params->iUIDs = apps; // We pass on ownership
+                    params->iIsDetailed = ETrue;
+                    continue;           
+                    }
+            
+                if (aArgs.At(i).CompareF(KUids)==0)
+                    {
+                    i++;
+                    RArray<TUid> uids;
+                    TInt k = 0;
+                    for (k = i; k < argsCount; k++)
+                        {               
+                        if (aArgs.At(k).Left(2) == _L("0x"))
+                            {
+                            TLex lex(aArgs.At(k).Mid(2));       
+                            TUint uid =0;
+                            TInt err = lex.Val(uid, EHex);
+                            if (err == KErrNone)
+                                {
+                                params->iUIDs.Append(TUid::Uid(uid));                       
+                                }            
+                            }
+                        else 
+                            {
+                            // We parsed all UIDs, break the cycle and go on!
+                            break;
+                            }
+                        }
+                    i = k-1;
+                    params->iIsDetailed = ETrue;
+                    continue;           
+                    }
+                
+                TDesC& cmd = aArgs.At(i);
+                if (cmd.CompareF(KLabel) == 0 || 
+                    cmd.CompareF(KPrivate) == 0 || cmd.CompareF(KStore) == 0 ||
+                    cmd.CompareF(KOwnerType) == 0 || cmd.Compare(KOwnerTypeShort) == 0 ||
+                    cmd.CompareF(KHelp) == 0 || cmd.Compare(KHelpShort) == 0 ||
+                    cmd.CompareF(KDeletable) == 0 || cmd.CompareF(KDeletableShort) == 0)
+                    {
+                    i++;
+                    if (i >= argsCount || aArgs.At(i)[0] == '-')
+                        {
+                        i = argsCount;
+                        command = CertToolDefController::KUsageCommand;
+                        }
+                    else if (cmd.CompareF(KHelp) == 0 || cmd.Compare(KHelpShort) == 0)
+                        {
+                        params->iDefault = aArgs.At(i).AllocL();
+                        i = argsCount;  
+                        }
+                    else if (cmd.CompareF(KLabel) == 0)
+                        {
+                        params->iLabel = aArgs.At(i).AllocL();
+                        }
+                    else if (cmd.CompareF(KPrivate) == 0)
+                        {
+                        params->iPrivate = aArgs.At(i).AllocL();
+                        }
+                    else if (cmd.CompareF(KStore) == 0)
+                        {
+                        TLex parser(aArgs.At(i));
+                        TInt err = parser.Val(params->iCertstoreIndex);
+                        params->iIsDetailed = ETrue;
+                        }
+                    else if (cmd.CompareF(KOwnerType) == 0 || cmd.Compare(KOwnerTypeShort) == 0)
+                        {
+                        params->iIsDetailed = ETrue;
+                        params->iOwnerType = aArgs.At(i).AllocL();
+                        }
+                    else if (cmd.CompareF(KDeletable) == 0 || cmd.CompareF(KDeletableShort) == 0)
+                        {
+                        params->iIsDetailed = ETrue;
+                        params->iIsDeletable = aArgs.At(i).AllocL();
+                        }
+                    continue;
+                    }
+        
+                if (VerifyCommand(aArgs.At(i), command, i))
+                    {
+                    continue;
+                    }
+
+                    
+                if (i!=0) 
+                    {
+                    if (aArgs.At(i)[0] == '-')
+                        {
+                        i = argsCount;
+                        command = CertToolDefController::KUsageCommand;
+                        continue;
+                        }
+                    delete params->iDefault;
+                    params->iDefault = NULL;
+                    params->iDefault = aArgs.At(i).AllocL();
+                    params->iIsDetailed = ETrue;            
+                    }
+                } 
+             
+             
+            if (command != -1)
+                {
+                TRAP_IGNORE(aController.HandleCommandL(command, params));
+                }
+            else 
+                {
+                aController.HandleCommandL(CertToolDefController::KUsageCommand, params);       
+                }
+            CleanupStack::PopAndDestroy(params);
+            }
+
+
+/**
+ * Parsing the command for non-interactive mode.
+ */
+
+LOCAL_D void ParseCommandInNonInteractiveModeL(RFile& aFile, const CCommandLineArguments& aCmdArgs)
+    {
+  
+    KeyToolUtils::SetFile(&aFile);
+    
+    CKeytoolFileView* view(0); 
+    view = CKeytoolFileView::NewLC(aCmdArgs.Arg(1));
+    TInt cmdCount = view->SplitFileInputToArrayL();
+    
+    //For every command, parse and handle.
+    for (TInt j = 0; j < cmdCount; j++)
+        {
+        CCertToolController* controller = CCertToolController::NewLC(*view);
+        
+        CArrayFixFlat<TPtrC>* args = view->ReadArrayArgumentsLC(j);
+        ParseAndHandleCommandL(*args, *controller);
+        
+        CleanupStack::PopAndDestroy(2, controller);
+        }
+        
+    
+    CleanupStack::PopAndDestroy(view);
+    
+    }
+
+
+/**
+ * Parsing the command for interactive mode.
+ */
+
+
+LOCAL_D void ParseCommandInInteractiveModeL(CConsoleBase& aConsole, const CCommandLineArguments& aCmdArgs)
+    {
+    CArrayFixFlat<TPtrC>* args = new (ELeave) CArrayFixFlat<TPtrC> (10);
+    CleanupStack::PushL(args);
+    CKeytoolConsoleView* view = CKeytoolConsoleView::NewLC(aConsole);
+    CCertToolController* controller = CCertToolController::NewLC(*view);
+
+    TInt cmdArgsCount = aCmdArgs.Count();
+    
+    KeyToolUtils::SetConsole(&aConsole);
+    BoilerPlateL(&aConsole);
+    
+    for (TInt i = 0; i < cmdArgsCount; i++)
+        {
+        args->AppendL(aCmdArgs.Arg(i));
+        }
+    
+    //Interactive mode can handle only one command at a time.
+    ParseAndHandleCommandL(*args, *controller); 
+    
+    // We are done!
+    aConsole.Printf(KNewLine);
+    aConsole.Printf(KDone);
+    aConsole.Getch(); 
+    
+    CleanupStack::PopAndDestroy(3, args); // controller, view, args
+    
+    }
+
+/**
+ * Parses the command line and given control to the handler to deal with the request.
+ */
+LOCAL_D void DoMainL() 
+	{
+
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);
+	RFile file;
+	
+	CConsoleBase* console = Console::NewL(KShortName, TSize(KConsFullScreen, KConsFullScreen));
+	CleanupStack::PushL(console);
+	CCommandLineArguments* cmdArgs = CCommandLineArguments::NewLC();
+	TInt cmdArgsCount = cmdArgs->Count();
+	
+	
+	OperationMode currentMode = Interactive; //Interactive by default.
+	
+	// Determine the mode of operation as either interactive or non-interactive.
+	if (cmdArgsCount == 3)
+		{
+		currentMode = ModeOfOperationL(*cmdArgs, fs, file);
+		}
+		
+	switch(currentMode)
+	    {
+	    case Interactive:
+	        ParseCommandInInteractiveModeL(*console, *cmdArgs);
+	        break;
+	        
+	    case NonInteractive:
+	        //file refers to the output file name.
+	        CleanupClosePushL(file);
+	        ParseCommandInNonInteractiveModeL(file, *cmdArgs);
+	        CleanupStack::PopAndDestroy(&file);
+	        break;
+	    }
+
+	CleanupStack::PopAndDestroy(3, &fs);
+	}
+
+	
+
+GLDEF_C TInt E32Main()         // main function called by E32
+   	{
+	__UHEAP_MARK;
+	CTrapCleanup* cleanup=CTrapCleanup::New(); 
+	
+	TRAP_IGNORE(DoMainL());
+	
+	delete cleanup; 
+	__UHEAP_MARKEND;
+	return 0; 
+   	}
+