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 +#include + +#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& 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 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 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* 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* args = new (ELeave) CArrayFixFlat (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; + } +