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