/*

 * 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 "t_policy.h"

 #include "t_input.h"

 #include "t_output.h"

 #include "t_testhandler.h"

 #include "utf.h"

 #include <s32file.h>

 // run failure tests first

 _LIT8(KTestExeStart, "<testexe>");

 _LIT8(KExcludedCapsStart, "<excludedcapabilities>");

 _LIT8(KPolicyStart, "<policy>");

 _LIT8(KPreActionsStart, "<preactions>");

 _LIT8(KPassAcionStart, "<passactions>");

 _LIT8(KFailAcionStart, "<failactions>");

 _LIT8(KPostActionsStart, "<postactions>");

 _LIT8(KSecureIdStart, "<secureid>");

 _LIT8(KSecureIdEnd, "</secureid>");

 _LIT8(KVendorIdStart, "<vendorid>");

 _LIT8(KVendorIdEnd, "</vendorid>");

 _LIT(KFormat,"Action Name : %S \n");

 _LIT(KSetCapExe, "setcap");

 _LIT(KSetCapExe2, "setcap : ");

 //NOTE :If the below literal is uncommented , remove the c:\hardcoded reference

 // and replace with RFs::GetSystemDrive().

 //_LIT(KTestExeTmpPath, "c:\\sys\\bin\\policytest_exe.exe");

 _LIT(KPassScriptPath, "\\policytest_script_pass.txt");

 _LIT(KFailScriptPath, "\\policytest_script_fail.txt");

 _LIT(KLogTmpPath, "\\policytest_log.txt");

 _LIT(KTestPath, "policytest_");

 _LIT(KFailTestRunning, "Fail Test Script Running");

 _LIT(KPassTestRunning, "Pass Test Script Running");

 const TUint KCapabilityAll = 0xffffffff;

 CPolicyTest* CPolicyTest::NewL(CConsoleBase& aConsole, 

 							   Output& aOut,

 							   const TTestActionSpec& aTestActionSpec)

 	{

 	CPolicyTest* self = CPolicyTest::NewLC(aConsole, aOut, aTestActionSpec);

 	CleanupStack::Pop(self);

 	return self;

 	}

 CPolicyTest* CPolicyTest::NewLC(CConsoleBase& aConsole, 

 								Output& aOut,

 								const TTestActionSpec& aTestActionSpec)

 	{

 	CPolicyTest* self = new(ELeave) CPolicyTest(aConsole, aOut);

 	CleanupStack::PushL(self);

 	self->ConstructL(aTestActionSpec);

 	return self;

 	}

 CPolicyTest::CPolicyTest(CConsoleBase& aConsole, 

 						 Output& aOut)

     : CTestAction(aConsole, aOut)

 	{

 	}

 void CPolicyTest::ConstructL(const TTestActionSpec& aTestActionSpec)

 	{

 	CTestAction::ConstructL(aTestActionSpec);

 	iExpectedResult = KErrNone;

 	User::LeaveIfError(iFs.Connect());

 	RProcess thisProcess;

 	User::LeaveIfError(thisProcess.Open(thisProcess.Id()));

 	iProcessSecureId = thisProcess.SecureId();

 	iProcessVendorId = thisProcess.VendorId();

 	thisProcess.Close();

 	SetTestExeL(Input::ParseElement(aTestActionSpec.iActionBody, KTestExeStart));

 	Input::ParseCapabilitySetL(Input::ParseElement(aTestActionSpec.iActionBody, KExcludedCapsStart), iExcludedCaps);

 	SetPolicyL(Input::ParseElement(aTestActionSpec.iActionBody, KPolicyStart));

 	iPreActions = Input::ParseElement(aTestActionSpec.iActionBody, KPreActionsStart).AllocL();

 	SetTestActionL(Input::ParseElement(aTestActionSpec.iActionBody, KPassAcionStart),

 				   Input::ParseElement(aTestActionSpec.iActionBody, KFailAcionStart));

 	iPostActions = Input::ParseElement(aTestActionSpec.iActionBody, KPostActionsStart).AllocL();

 	}

 CPolicyTest::~CPolicyTest()

 	{

 	iFs.Close();

 	delete iTestExe;

 	iCapabilities.Close();

 	delete iPreActions;

 	delete iPassAction;

 	delete iFailAction;

 	delete iPostActions;

 	iProcess.Close();

 	}

 void CPolicyTest::BadUsageL(const TDesC& aMessage)

 	{

 	iOut.writeString(_L("Error in script action testpolicy"));

 	iOut.writeNewLine();

 	iOut.writeString(aMessage);

 	iOut.writeNewLine();

 	User::Leave(KErrArgument);

 	}

 void CPolicyTest::SetTestExeL(const TDesC8& aPath)

 	{

 	if (aPath == KNullDesC8)

 		{

 		BadUsageL(_L("testexe not specified"));

 		}

 	iTestExe = HBufC::NewMaxL(aPath.Length());

 	TPtr ptr = iTestExe->Des();

 	ptr.Copy(aPath);

 	}

 void CPolicyTest::SetPolicyL(const TDesC8& aSpec)

 	{

 	iSecureId = Input::ParseIntElement(aSpec, KSecureIdStart, KSecureIdEnd);

 	iVendorId = Input::ParseIntElement(aSpec, KVendorIdStart, KVendorIdEnd);

 	TCapabilitySet capSet;

 	Input::ParseCapabilitySetL(aSpec, capSet);

 	// Extract capabilities into array

 	for (TInt i = 0 ; i < ECapability_Limit ; ++i)

 		{

 		TCapability c = static_cast<TCapability>(i);

 		if (capSet.HasCapability(c))

 			{

 			User::LeaveIfError(iCapabilities.Append(c));

 			}

 		}	

 	}

 void CPolicyTest::SetTestActionL(const TDesC8& aPassAction, const TDesC8& aFailAction)

 	{

 	if (aPassAction == KNullDesC8)

 		{

 		BadUsageL(_L("passactions not specified"));

 		}

 	iPassAction = aPassAction.AllocL();

 	if (aFailAction == KNullDesC8)

 		{

 		BadUsageL(_L("failactions not specified"));

 		}

 	iFailAction = aFailAction.AllocL();

 }

 void CPolicyTest::PerformAction(TRequestStatus& aStatus)

 	{

 	if (aStatus < 0)

 		{

 		iState = EFinished;

 		}

 	switch (iState)

 		{

 		case EInit:

 			{

 			TDriveUnit sysDrive (RFs::GetSystemDrive());

 			TDriveName sysDriveName (sysDrive.Name());

 			TBuf<128> scriptFile (sysDriveName);

 			scriptFile.Append(KPassScriptPath);

 			WriteScriptFileL(scriptFile, *iPassAction);	

 			scriptFile.Copy(sysDriveName);

 			scriptFile.Append(KFailScriptPath);

 			WriteScriptFileL(scriptFile, *iFailAction);

 			}

 			// fall through

 		case ESetupTest:

 			GetNextTest();

 			if (iTestState == ETestFinished)

 				{

 				iState = EFinished;

 				TRequestStatus* status = &aStatus;

 				User::RequestComplete(status, KErrNone);

 				}

 			else

 				{

 				SetupTestL(aStatus);

 				iState = ERunTest;

 				}

 			break;

 		case ERunTest:

 			CheckProcessTermintationL();

 			RunTestL(aStatus);

 			iState = EProcessResults;

 			break;

 		case EProcessResults:

 			CheckProcessTermintationL();

 			ProcessResultsL(aStatus);

 			iState = ESetupTest;

 			break;

 		case EFinished:

 			iActionState = EPostrequisite;				

 			TRequestStatus* status = &aStatus;

 			User::RequestComplete(status, aStatus.Int());

 			break;

 		}

 	}

 void CPolicyTest::StartProcessL(const TDesC& aExe, const TDesC& aCommandLine, TRequestStatus& aStatus)

 	{

 	iOut.writeString(_L("Starting child process: "));

 	iOut.writeString(aExe);

 	iOut.writeString(_L(" "));

 	iOut.writeString(aCommandLine);

 	iOut.writeNewLine();

 	User::LeaveIfError(iProcess.Create(aExe, aCommandLine));

 	iProcess.Logon(aStatus);

 	iProcess.Resume();

 	}

 void CPolicyTest::CheckProcessTermintationL()

 	{

 	if (iProcess.ExitType() == EExitPanic)

 		{

 		iOut.writeString(_L("Child process panicked: "));

 		iOut.writeString(iProcess.ExitCategory());

 		iOut.writeString(_L(" "));

 		iOut.writeNum(iProcess.ExitReason());

 		iOut.writeNewLine();

 		User::Leave(KErrGeneral);

 		}

 	ASSERT(iProcess.ExitType() == EExitKill);

 	iProcess.Close();

 	}

 void CPolicyTest::GetNextTest()

 	{

 	// Step through capabilities to be tested

 	if (iTestState == ETestFailCap)

 		{

 		++iCapIndex;

 		if (iCapIndex < iCapabilities.Count())

 			return;

 		}

 	// Step through possible tests until we hit a vaild test

 	do

 		{

 		iTestState = static_cast<TTestState>(iTestState + 1);

 		}

 	while (!((iTestState == ETestFailSID && iSecureId) ||

 			 (iTestState == ETestFailVID && iVendorId) ||

 			 (iTestState == ETestFailCap && iCapabilities.Count()) ||

 			 (iTestState == ETestPass) ||

 			 (iTestState == ETestFinished)));

 	}

 void CPolicyTest::SetupTestL(TRequestStatus& aStatus)

 	{

 	switch (iTestState)

 		{

 		case ETestFailSID:

 			{

 			TInt wrongSecureId = iSecureId + 1;

 			iOut.write(_L("Failure test: Wrong SID (%08x):\n\n"), wrongSecureId);			

 			SetTestSecurityInfoL(wrongSecureId, iVendorId, KCapabilityAll, aStatus);

 			}

 			break;

 		case ETestFailVID:

 			{

 			TInt wrongVendorId = iVendorId + 1;

 			iOut.write(_L("Failure test: Wrong VID (%08x):\n\n"), wrongVendorId);

 			SetTestSecurityInfoL(iSecureId, wrongVendorId, KCapabilityAll, aStatus);

 			}

 			break;

 		case ETestFailCap:

 			{

 			TCapability missingCap = iCapabilities[iCapIndex];

 			iOut.writeString(_L("Failure test: Missing capability ("));

 			iOut.writeCapabilityL(missingCap);

 			iOut.writeString(_L("):\n\n"));

 			TUint capSet = ~ (1 << missingCap);			

 			SetTestSecurityInfoL(iSecureId, iVendorId, capSet, aStatus);

 			}

 			break;

 		case ETestPass:

 			{

 			iOut.write(_L("Pass test:\n\n"));			

 			TUint capSet = 0;

 			for (TInt i = 0 ; i < iCapabilities.Count() ; ++i)

 				{

 				capSet |= 1 << iCapabilities[i];

 				}

 			SetTestSecurityInfoL(iSecureId, iVendorId, capSet, aStatus);

 			}

 			break;

 		default:

 			User::Invariant();

 		}

 	}

 void CPolicyTest::SetTestSecurityInfoL(TInt aSecureId, TInt aVendorId, TUint aCapSet, TRequestStatus& aStatus)

 	{

 	// Remove excluded capabilities

 	for (TInt i = 0 ; i < ECapability_Limit ; ++i)

 		{

 		if (iExcludedCaps.HasCapability(static_cast<TCapability>(i)))

 			{

 			aCapSet &= ~ (1 << i);

 			}

 		}

 	TBuf<128> commandLine;

 	commandLine.AppendFormat(_L("%S %08x "), iTestExe, aCapSet);

 	if (aSecureId)

 		{

 		commandLine.AppendFormat(_L("-SID %08x "), aSecureId);

 		}

 	if (aVendorId)

 		{

 		commandLine.AppendFormat(_L("-VID %08x "), aVendorId);

 		}

    // commandLine.Append(KTestExeTmpPath);

     iTestExeTmpNewPath = KTestPath;

 	iTestExeTmpNewPath.Append(*iTestExe);

 	commandLine.Append(iTestExeTmpNewPath);

     TBuf<128> isetcapTmpNewPath1; //stores the value of commandline

     TBuf<128> isetcapTmpNewPath;  //stores the value of KsetCapexe2

 	isetcapTmpNewPath = KSetCapExe2;

 	isetcapTmpNewPath1= commandLine;

 	isetcapTmpNewPath.Append(isetcapTmpNewPath1);

 	RDebug::RawPrint(isetcapTmpNewPath);

 	StartProcessL(KSetCapExe, commandLine, aStatus);

 	}

 void CPolicyTest::WriteScriptFileL(const TDesC& aPath, const TDesC8& aAction)

 	{	

 	iFs.Delete(aPath); // ignore errors

 	RFile file;

 	User::LeaveIfError(file.Create(iFs, aPath, EFileShareExclusive | EFileWrite));

 	CleanupClosePushL(file);

 	User::LeaveIfError(file.Write(*iPreActions));

 	User::LeaveIfError(file.Write(aAction));	

 	User::LeaveIfError(file.Write(*iPostActions));

 	CleanupStack::PopAndDestroy(&file);

 	}

 void CPolicyTest::RunTestL(TRequestStatus& aStatus)

 	{

 	HBufC* hptr16; 

 	hptr16 = CnvUtfConverter::ConvertToUnicodeFromUtf8L(*iNameInfo);

 	RDebug::Print(KFormat,hptr16);

 	delete hptr16;

 	TDriveUnit sysDrive (RFs::GetSystemDrive());

 	TDriveName sysDriveName (sysDrive.Name());

 	TBuf<128> passScriptFile (sysDriveName);

 	passScriptFile.Append(KPassScriptPath);

 	TBuf<128> failScriptFile (sysDriveName);

 	failScriptFile.Append(KFailScriptPath);

 	TPtrC script = (iTestState == ETestPass) ? passScriptFile : failScriptFile;

 	(iTestState == ETestPass) ? RDebug::RawPrint(KPassTestRunning) : RDebug::RawPrint(KFailTestRunning);

 	TBuf<128> logTmpFile (sysDriveName);

 	logTmpFile.Append(KLogTmpPath);

 	iFs.Delete(logTmpFile); // ignore errors

 	TBuf<128> commandLine;

 	commandLine.AppendFormat(_L("%S %S"), &script, &logTmpFile);	

 	StartProcessL(iTestExeTmpNewPath, commandLine, aStatus);

 	}

 void CPolicyTest::ProcessResultsL(TRequestStatus& aStatus)

 	{

 	_LIT8(KSummaryLine, " tests failed out of ");

 	_LIT8(KNewLine, "\r\n");

 	TInt failCount = KErrNotFound, runCount;

 	// Read entire log file into memory to process

 	RFile file;

 	TDriveUnit sysDrive (RFs::GetSystemDrive());

 	TBuf<128> logTmpFile (sysDrive.Name());

 	logTmpFile.Append(KLogTmpPath);

 	User::LeaveIfError(file.Open(iFs, logTmpFile, EFileShareReadersOnly | EFileRead));

 	CleanupClosePushL(file);

 	TInt size;

 	User::LeaveIfError(file.Size(size));

 	HBufC8* buffer = HBufC8::NewLC(size);

 	TPtr8 ptr = buffer->Des();

 	User::LeaveIfError(file.Read(ptr));

 	iOut.writeString(_L("Child test output:\n"));

 	TInt pos = 0;

 	while (pos < size)

 		{

 		TInt nextNewline = buffer->Mid(pos).Find(KNewLine);

 		// Split buffer into lines

 		TPtrC8 line;

 		if (nextNewline == KErrNotFound)

 			{

 			line.Set(buffer->Mid(pos));

 			}

 		else

 			{

 			line.Set(buffer->Mid(pos, nextNewline + KNewLine().Length()));

 			}

 		pos += line.Length();

 		// Search for summary line

 		TInt pos2 = line.Find(KSummaryLine);

 		if (pos2 != KErrNotFound)

 			{

 			// Parse the summary line to work out if the test passed

 			TLex8 lex1(line.Left(pos2));

 			TInt err1 = lex1.Val(failCount);

 			TLex8 lex2(line.Mid(pos2 + KSummaryLine().Length()));

 			TInt err2 = lex2.Val(runCount);

 			if (err1 != KErrNone || err2 != KErrNone)

 				{

 				iOut.writeString(_L("Failed to parse summary line\n"));

 				User::LeaveIfError(err1);

 				User::LeaveIfError(err2);

 				}

 			}

 		else

 			{

 			// Don't print the summary line as this will confuse whatever parsed

 			// the main log

 			iOut.writeString(_L("> "));

 			iOut.writeString(line);

 			}		

 		}

 	if (failCount == KErrNotFound)

 		{

 		iOut.writeString(_L("Couldn't find summary line in test output\n"));

 		User::Leave(KErrNotFound);

 		}

 	iFailCount += failCount;

 	// Print results in different format

 	iOut.write(_L("Tests run: %d\n"), runCount);

 	iOut.write(_L("Tests failed: %d\n"), failCount);

 	iOut.writeNewLine();

 	CleanupStack::PopAndDestroy(2, &file);

 	TRequestStatus* status = &aStatus;

 	User::RequestComplete(status, KErrNone);

 	}

 void CPolicyTest::PerformCancel()

 	{

 	// not implemented - need to pass original status object to LogonCancel

 	User::Invariant(); 

 	/*

 	switch (iState)

 		{

 		case ESetCapsPass:

 		case ERunTest:

 			iProcess.LogonCancel();

 			iProcess.Kill(KErrCancel);

 			iProcess.Close();

 			break;

 		}

 	*/

 	}

 void CPolicyTest::Reset()

 	{

 	iProcess.Close();

 	iState = ESetupTest;

 	iTestState = ETestNone;

 	iCapIndex = -1;

 	iFailCount = 0;

 	}

 void CPolicyTest::DoReportAction()

 	{

 	iOut.writeString(_L("Running policy tests...\n\n"));

 	}

 void CPolicyTest::DoCheckResult(TInt aError)

 	{

 	if (aError == KErrNone && iFailCount > 0)

 		{

 		iOut.write(_L("%d tests failed\n"), iFailCount);

 		aError = KErrGeneral;

 		}

 	iResult = (aError == iExpectedResult);

 	}