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