// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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 "command.h"

#include "engine.h"

#include "panic.h"

#include "logger.h"

#include "result.h"

#include "TEFparser.h"

#include <f32file.h>

#include <utf.h>

// Define the commands the user can use in the input script

// *****************  General  ************************

// Comment prefix for input file

_LIT(KTOCSPCommandComment,		"REM");

// Print remaining text to console

_LIT(KTOCSPCommandPrint,		"PRINT");

// Bail out at this point

_LIT(KTOCSPCommandAbort,		"ABORT");

// NOTE: Skips CAN be nested

// Skip everything unil KTOCSPCommandEndSkip

_LIT(KTOCSPCommandSkip,			"SKIP");

// Stop skipping - does nothing if not skipping

_LIT(KTOCSPCommandEndSkip,		"ENDSKIP");

// ************ Configuring the request ***************

// Start a new OCSP request/response transaction

// Has exactly one parameter - the name of the test (which must not include spaces)

_LIT(KTOCSPCommandStart,		"START");

// Set the URI of the server

_LIT(KTOCSPCommandSetURI,		"SETURI");

// Parameter is a file from which to read a cert

_LIT(KTOCSPCommandCert,			"REQUESTCERT");

// Parameter is ON or OFF

_LIT(KTOCSPCommandNonce,        "NONCE");

// ************ Handling the communication *************

// Set transport scheme for communication

// Parameter DEFAULT means let the OCSP module deal with the transport

// Parameter TEST means use the test harness server

_LIT(KTOCSPCommandSetTransport,	"TRANSPORT");

// ******* Configuring + performing the validation ********

// Set transport retry count

// Takes one parameter, the retry count (1 means no retry)

// NOTE: This command must appear after the TRANSPORT command

_LIT(KTOCSPCommandSetTransportRetry, "TRANSPORTRETRY");

// Set transport timeout

// Takes one parameter, the timeout value in milliseconds

// NOTE: This command must appear after the TRANSPORT command

_LIT(KTOCSPCommandSetTransportTimeout, "TRANSPORTTIMEOUT");

// Set validation date, parameters are YYYY MM DD HH MM - optional

_LIT(KTOCSPCommandValidationDate, "VALIDATIONDATE");

// Parameter is a file containing a cert to be set as valid for authorisation of

// the response.  Can call more than once.

_LIT(KTOCSPCommandDirectAuthorisation, "AUTHORISATIONCERT");

// No parameters - tells test client to use ca delegate authorisation.

// (See RFC2560 S2.2, S4.2.2.2)

_LIT(KTOCSPCommandCADelegateAuthorisation, "CADELEGATE");

// No parameters - tells test client to use direct signing by ca.

// see (RFC 2560 S2.2)

_LIT(KTOCSPCommandCADirectAuthorisation, "CADIRECT");

// No parameters - tells test client to use all schemes

// see (RFC 2560 S2.2)

_LIT(KTOCSPCommandAllAuthorisationSchemes, "ALLSCHEMES");

// Set the maximum allowable age of the status returned.  Parameter is in

// seconds, or "OFF" to disable checking.

_LIT(KTOCSPCommandSetMaxStatusAge, "SETMAXSTATUSAGE");

// Set http filter parameters

// The parameters to FILTERPARAMS command are:

// numDelayResp countDropResp countCorruptHTTPDataHeader countCorruptHTTPDataBodySizeLarge countCorruptHTTPDataBodySizeSmall countCorruptOCSPData countInternalErrorResp countTryLaterResp

// where:

// 		numDelayResp - Delays response by specified number of milliseconds

//		countDropResp - Drops specified number of responses

//		countCorruptHTTPDataHeader - Corrupts specified number of responses (content-type in header is corrupted)

//		countCorruptHTTPDataBodySizeLarge - Corrupts specified number of responses (body is of larger size than expected)

//		countCorruptHTTPDataBodySizeSmall - Corrupts specified number of responses (body is of smaller size than expected)

//		countCorruptOCSPData - Corrupts specified number of responses (OCSPResponse data is corrupted)

//		countInternalErrorResp - Returns an "internalError" response for specified number of requests

//		countTryLaterResp - Returns a "tryLater" response for specified number of requests

//		countSigValidateFailure - Causes a signature validation failure by corrupting the Responder ID

// NOTE: This command must appear after the TRANSPORT command

_LIT(KTOCSPCommandSetFilterParams, "FILTERPARAMS");

// Cancel the OCSP check after its issued

// The parameter is the time in milliseconds to wait before issuing the cancel

// Note that this command must appear before the CHECK command

_LIT(KTOCSPCommandCancel, "CANCEL");

// Run the OCSP check

_LIT(KTOCSPCommandCheck, "CHECK");

// Tests that the revocation check was cancelled

_LIT(KTOCSPCommandTestCancel, "TESTCANCEL");

// Tests that the summary result is as expected.  Takes one parameter, the

// expected result.

_LIT(KTOCSPCommandTestSummary, "TESTSUMMARY");

// Tests that the outcome for a certificate is as expected.  Takes three

// paramters, the certificate index, the expected status and the expected result

_LIT(KTOCSPCommandTestOutcome, "TESTOUTCOME");

// Tests that the outcome for the tranport is as expected. Takes four

// paramters, the retry count number (0 means first attempt), the expected HTTP method, 

// and the range of time in milliseconds (min max) within which each request should complete

// NOTE: The usage of this command assumes only one certificate is being

// checked for revocation per test case! (also means CHECKRESPONDERCERT command cannot be used with this)

_LIT(KTOCSPCommandTestTransport, "TESTTRANSPORT");

// Tests that the outcome for the retry attempts is as expected. 

// Takes one paramter, the retry count (1 means single attempt ie. no retry)

// NOTE: The usage of this command assumes only one certificate is being

// checked for revocation per test case! (also means CHECKRESPONDERCERT command cannot be used with this)

_LIT(KTOCSPCommandTestTransportRetry, "TESTTRANSPORTRETRY");

// Log the reponses to a file.  The filename is the only parameter.

// This command must be placed after the CHECK command

_LIT(KTOCSPCommandLogResponse, "LOGRESPONSE");

// Log the requests to a file.  The filename is the only parameter.

// This command must be placed before the TRANSPORT command

_LIT(KTOCSPCommandLogRequest, "LOGREQUEST");

// End a test

_LIT(KTOCSPCommandEnd, "END");

// parameter for setting whether the ocsp status check 

// for responder certificate should be done or not.

_LIT(KTOCSPCheckResponderCert, "CHECKRESPONDERCERT");

_LIT(KTOCSPAddCertToStore, "ADDCERTTOSTORE");

_LIT(KTOCSPUseAIA, "USEAIA");

_LIT(KTOCSPCheckCertsWithAiaOnly, "CHECKCERTSWITHAIAONLY");

_LIT(KTOCSPExpectedError, "EXPECTEDERROR");

// ************* Parameter definitions *****************

// Default transport (currently only HTTP)

_LIT(KTOCSPDefaultTransport,		"DEFAULT");

_LIT(KTOCSPTestTransport,			"TEST");

_LIT(KTOCSPOcspSupportTransport,	"OCSPSUPPORT");

// Generic parameter for toggle of settings.

_LIT(KTOCSPOn,  "ON");

_LIT(KTOCSPOff, "OFF");

_LIT(KTOCSPEnable,  "ENABLE");

_LIT(KTOCSPDisable, "DISABLE");

_LIT(KTOCSPEnableDisable,"ENABLE|DISABLE");

CTOCSPCommand* CTOCSPCommand::NewL(CTOCSPLogger& aLog,

								   CTOCSPResult& aResult,	

								   TInt aTransaction)

	{

	CTOCSPCommand* self = new (ELeave) CTOCSPCommand(aLog, aResult, aTransaction);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTOCSPCommand::CTOCSPCommand(CTOCSPLogger& aLog,

							 CTOCSPResult& aResult,

							 TInt aTransaction) :

	CActive(EPriorityNormal),

	iResult(aResult),

	iLog(aLog),

	iTestToProcess(aTransaction)

	{

	CActiveScheduler::Add(this);

	}

void CTOCSPCommand::ConstructL()

	{

	iEngine = CTOCSPEngine::NewL(iLog);

	}

CTOCSPCommand::~CTOCSPCommand()

	{

    Cancel();

	delete iEngine;

	iTokens.Close();

	}

void CTOCSPCommand::ResetL()

    {

	FinishedTestL();

    iTestIndex = 0;

    iTestToProcess = 0;

    }

TInt CTOCSPCommand::CurrentTransaction() const

    {

    return iTestIndex;

    }

TBool CTOCSPCommand::ProcessCommand(const TDesC& aLine, TRequestStatus& aStatus)

	{

	iOriginalRequestStatus = &aStatus;

    TBool result = ETrue;

    TRAPD(err, result = DoProcessCommandL(aLine));

    if (err != KErrNone)

        {

        Cancel();

        User::RequestComplete(iOriginalRequestStatus, err);

        }

    return result;

    }

TBool CTOCSPCommand::DoProcessCommandL(const TDesC& aLine)

	{

	*iOriginalRequestStatus = KRequestPending;

	if (!iVerbose)

		{

		iLog.LogL(_L("."), ETrue);

		}

	TLex lex(aLine);

    // Empty line

    if (lex.Eos())

        {

        User::RequestComplete(iOriginalRequestStatus, KErrNone);

        return ETrue;

        }

    TPtrC command = lex.NextToken();

    // Handle skipping commands

	if (command == KTOCSPCommandSkip)

		{

		++iSkipping;

		}

	else if (command == KTOCSPCommandEndSkip)

		{

        --iSkipping;

		if (iSkipping < 0)

			{

            User::RequestComplete(iOriginalRequestStatus, KErrCorrupt);

			return ETrue;

			}

		}

	LogCommandL(aLine);

	if (iSkipping)

		{

		User::RequestComplete(iOriginalRequestStatus, KErrNone);

        return ETrue;

		}

	if (command == KTOCSPCommandSkip || command == KTOCSPCommandEndSkip)

		{

		User::RequestComplete(iOriginalRequestStatus, KErrNone);

        return ETrue;

		}

	if (command == KTOCSPCommandStart)

		{

		++iTestIndex;

		}

    // Don't process any tests except the ones we're interested in

    if (iTestToProcess != 0 && iTestToProcess != iTestIndex)

        {   

		User::RequestComplete(iOriginalRequestStatus, KErrNone);

        return ETrue;

        }

	// Handle comment and print commands

	if (command == KTOCSPCommandComment)

		{

		// Remark - nothing to do except move on to next line

		User::RequestComplete(iOriginalRequestStatus, KErrNone);

        return ETrue;

		}

	else if (command == KTOCSPCommandPrint)

		{

		lex.SkipSpace();

		PrintCommandL(lex.Remainder());

        return ETrue;

		}

    // Now split the rest of the command into tokens

	iTokens.Reset();

	while (!lex.Eos())

		{

		User::LeaveIfError(iTokens.Append(lex.NextToken()));

		}

    // Check commands that don't have to occur in tests

	if (command == KTOCSPCommandAbort)

		{

		User::RequestComplete(iOriginalRequestStatus, KErrNone);

		return EFalse;

		}

	else if (command == KTOCSPCommandStart)

        {

		StartCommandL();

		}

	else if (command == KTOCSPCommandEnd)

        {

		EndCommandL();

		}

	else

		{

		return ProcessTestCommandL(command);

		}

	return ETrue;

	}

TBool CTOCSPCommand::ProcessTestCommandL(const TDesC& command)

	{

	if (!iInsideTest)

		{

		iLog.LogL(_L("Command cannot occur outside test: "));

		iLog.LogL(command);

		iLog.NewLineL();

		User::Leave(KErrCorrupt);

		}

    // Check the other commands that can only occur in tests

	if (command == KTOCSPCommandSetURI)

		{

		SetURICommandL();

		}

	else if (command == KTOCSPCommandSetTransport)

		{

		SetTransportCommandL();

		}

	else if (command == KTOCSPCommandSetTransportRetry)

		{

		SetTransportRetryCommandL();

		}

	else if (command == KTOCSPCommandSetTransportTimeout)

		{

		SetTransportTimeoutCommandL();

		}

	else if (command == KTOCSPCommandCert)

		{

		CertCommandL();

		}

	else if (command == KTOCSPCommandValidationDate)

		{

		ValidationDateCommandL();

		}

	else if (command == KTOCSPCommandDirectAuthorisation)

		{

		DirectAuthorisationCommandL();

		}

	else if (command == KTOCSPCommandCADelegateAuthorisation)

		{

		CADelegateAuthorisationCommandL();

		}

	else if (command == KTOCSPCommandCADirectAuthorisation)

		{

		CADirectAuthorisationCommandL();

		}

	else if (command == KTOCSPCommandAllAuthorisationSchemes)

		{

		AllAuthorisationSchemesCommandL();

		}

	else if (command == KTOCSPCommandSetMaxStatusAge)

		{

		SetMaxStatusAgeCommandL();

		}

	else if (command == KTOCSPCommandSetFilterParams)

		{

		SetFilterParamsCommandL();

		}

	else if (command == KTOCSPCommandCancel)

		{

		CancelCommandL();

		}

	else if (command == KTOCSPCommandCheck)

		{

		CheckCommand();

		}

	else if (command == KTOCSPCommandTestCancel)

		{

		TestCancelCommand();

		}

	else if (command == KTOCSPCommandTestSummary)

		{

		TestSummaryCommandL();

		}

	else if (command == KTOCSPCommandTestOutcome)

		{

		TestOutcomeCommandL();

		}

	else if (command == KTOCSPCommandTestTransport)

		{

		TestTransportCommandL();

		}

	else if (command == KTOCSPCommandTestTransportRetry)

		{

		TestTransportRetryCommandL();

		}

	else if (command == KTOCSPCommandNonce)

		{

		SetNonceCommandL();

		}

	else if (command == KTOCSPCommandLogResponse)

		{

		LogResponseCommandL();

		}

	else if (command == KTOCSPCommandLogRequest)

		{

		LogRequestCommandL();

		}

	else if (command == KTOCSPCheckResponderCert)

		{

		SetResponderCertCheck();

		}

	else if(command == KTOCSPAddCertToStore)

		{

		AddCertToStoreL();

		}

	else if(command ==  KTOCSPCheckCertsWithAiaOnly )

		{

		SetCheckCertsWithAiaOnly();

		}

	else if(command  == KTOCSPUseAIA)

		{

		SetUseAIAL();

		}

	else if(command == KTOCSPExpectedError)

		{

		LogErrorL();

		}

	else

		{

		UnknownCommandL(command);

		}

	return ETrue;

	}

void CTOCSPCommand::LogErrorL()

	{

	if (iTokens.Count() != 1)

		{

		WrongNumberOfArgumentsL();

		}

	TLex expectedErrorLex(iTokens[0]);

	TInt expectedError = 0;

	User::LeaveIfError(expectedErrorLex.Val(expectedError));

	iTestResult = (expectedError == iError)?ETrue:EFalse;

	User::RequestComplete(iOriginalRequestStatus, KErrNone);

	}

void CTOCSPCommand::RunL()

	{

	TInt err = iStatus.Int();

	// The engine does not get a chance to process the cancel notification so we handle it here

	if (err == KErrCancel)

		{

		// Cancel expected

		iCheckCancelled = ETrue;

		}

	else

		{

		User::LeaveIfError(err);

		}

	switch (iState)

		{

		case EEngineStart:

		case EEngineEnd: