/*

 * 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; 

    	}