/*

* 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: 

*

*/

/**

 @file 

*/

#define __INCLUDE_CAPABILITY_NAMES__

#include <e32capability.h>

#include "captestframeworkstep.h"

#include "captestframework.h"

#include <test/testexecutelog.h>

#include <s32file.h>

#include <f32file.h>

CCapTestFrameworkStep::CCapTestFrameworkStep(TThoroughness aThoroughness)

	: iThoroughness(aThoroughness)

	{

	}

CCapTestFrameworkStep::~CCapTestFrameworkStep()

	{

	iLibrary.Close();

	iFs.Close();	

	}

TVerdict CCapTestFrameworkStep::doTestStepPreambleL()

	{

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

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

	if (EFalse==GetStringFromConfig(ConfigSection(), _L("DllName"), iDllName))

		{

		return EFail;

		}

	GetBoolFromConfig(ConfigSection(), _L("OmitTCBCapInComplementSet"), iOmitTCBCapInComplementSet);

	SetupFactoryL();

	return EPass;

	}

TVerdict CCapTestFrameworkStep::doTestStepL()

	{

	for (iCurrentTest=0; iCurrentTest < iFactory->NumberOfTests(); ++iCurrentTest)

		{

		INFO_PRINTF1(_L(""));

		INFO_PRINTF2(_L("Running %S"), &iFactory->Test(iCurrentTest)->Name());

		INFO_PRINTF1(_L("Assumed to require:"));

		INFO_PRINTF2(_L("\tSid: %x"), iFactory->Test(iCurrentTest)->SidRequired());

		INFO_PRINTF2(_L("\tVid: %x"), iFactory->Test(iCurrentTest)->VidRequired());

		PrintCapabilitySet(iFactory->Test(iCurrentTest)->CapabilitiesRequired(), _L("\tCapabilities: "));

		RunTestStepL(iFactory->Test(iCurrentTest));

		}

	return EPass;

	}

void CCapTestFrameworkStep::RunTestStepL(MCapabilityTest* aTest)

	{

	// figure out capabilities required

	TCapabilitySet capsRequired=aTest->CapabilitiesRequired();

	TUid sidRequired=aTest->SidRequired();

	TUid vidRequired=aTest->VidRequired();

	RArray<TTestEnvironment> capTestEnvs;

	CleanupClosePushL(capTestEnvs);

	GenerateEnvironmentsL(capsRequired, sidRequired, vidRequired, capTestEnvs);

	// for all cap sets needed

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

		{

		INFO_PRINTF1(_L("With:"));

		INFO_PRINTF2(_L("\tSid: %x"), capTestEnvs[i].iSid);

		INFO_PRINTF2(_L("\tVid: %x"), capTestEnvs[i].iVid);

		PrintCapabilitySet(capTestEnvs[i].iCaps, _L("\tCapabilities: "));

		// Set the capabilities of the helper

		SetupHelperL(capTestEnvs[i]);

		// run the helper and check results

		RunHelperL(iCurrentTest, capTestEnvs[i].iExpectPass);

		}

	CleanupStack::PopAndDestroy(&capTestEnvs);

	}

void CCapTestFrameworkStep::RunHelperL(TInt aTestNumber, TBool aShouldPass)

	{

	RProcess p;

	//Launching process

	User::LeaveIfError(p.Create(_L("tempcaptestframeworkhelper.exe"), KNullDesC));

	p.SetParameter(KDllNameTransferSlot, iDllName);

	p.SetParameter(KShouldPassTransferSlot, aShouldPass);

	p.SetParameter(KTestNumberTransferSlot, aTestNumber);

	_LIT(KLogFileName , "\\captestframework.txt");

	TDriveUnit sysDrive(RFs::GetSystemDrive());

	TBuf<128> logFileNameOnSysDrive = sysDrive.Name();

	logFileNameOnSysDrive.Append(KLogFileName);

	p.SetParameter(KLogFileNameTransferSlot, logFileNameOnSysDrive);

	// Wait for the test to finish

	TRequestStatus s;

	TRequestStatus& a=s;

	p.Logon(a);

	p.Resume();

	User::WaitForRequest(a);

	p.Close();

	// Extract the info from the logfile

	RFileReadStream logFile;

	logFile.Open(iFs, logFileNameOnSysDrive, 0);

	CleanupClosePushL(logFile);

	while (ETrue)

		{

		TInt32 pass=logFile.ReadInt32L();

		if (pass==ETestsEnded)

			{

			break;	// end of file

			}

		else if (pass==EFileEnd)

			{

			// reached end of file marker, with no success

			SetTestStepResult(EFail);

			break;	

			}

		else if (pass==ETestFailed)

			{

			HBufC* text=HBufC::NewL(logFile, KMaxTInt);

			ERR_PRINTF2(_L("%S"), text);

			delete text;

			}

		else if (pass==ETestPassed)

			{

			HBufC* text=HBufC::NewL(logFile, KMaxTInt);

			INFO_PRINTF2(_L("%S"), text);

			delete text;

			}

		}	

	CleanupStack::PopAndDestroy(&logFile);

	}

void CCapTestFrameworkStep::SetupHelperL(const TTestEnvironment& aEnvironment)

	{

	RProcess p;

// SETCAP source_exe capability [-SID secureId] [-VID vendorId] [destination_path]

	_LIT(KArgsFormat, "captestframeworkhelper.exe  %X -SID %X -VID %X tempcaptestframeworkhelper.exe");

// The 'capability' command line argument is the hexadecimal value of the

// capabilities when they are represented as a bit-field. E.g. the 3 capabilities

// LocalServices, ReadUserData and WriteUserData would together have a value of:

//

// (1<<ECapabilityLocalServices) | (<<ECapabilityReadUserData) | (1<<ECapabilityWriteUserData)

//

// Which in hexadecimal is '1c000'

 	const TCapabilitySet& aCapSet=aEnvironment.iCaps;

	TInt caps=0;

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

		{

		if (aCapSet.HasCapability(TCapability(c)))

			{

			caps+=(1<<c);

			}

		}

	TBuf<512> cmdLine;

	cmdLine.Format(KArgsFormat, caps, aEnvironment.iSid, aEnvironment.iVid);

	User::LeaveIfError(p.Create(_L("setcap.exe"), cmdLine));

	// Wait for setcap to finish

	TRequestStatus s;

	TRequestStatus& rs=s;

	p.Logon(rs);

	p.Resume();

	User::WaitForRequest(rs);

	p.Close();

	}

void CCapTestFrameworkStep::PrintCapabilitySet(const TCapabilitySet& aCapSet, const TDesC& aExtra)

	{

	TBuf<512> string;

	string.AppendFormat(_L("%S"), &aExtra);

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

		{

		if (aCapSet.HasCapability(TCapability(c)))

			{

			string.Append(' ');

			const char *p=CapabilityNames[c];

			while(*p)

				{

				string.Append(*p++);

				}

			}

		}

	if (string.Length()==aExtra.Length())

		{

		string.AppendFormat(_L("None"));

		}

	INFO_PRINTF1(string);

	}

void CCapTestFrameworkStep::GenerateEnvironmentsL(const TCapabilitySet& aCapsNeeded, const TUid& aSidNeeded, const TUid& aVidNeeded, RArray<TTestEnvironment>& aEnvironments)

	{

	for (TUid sid={0}; sid.iUid <= aSidNeeded.iUid; sid.iUid+= aSidNeeded.iUid ? aSidNeeded.iUid : 1) // if no sid is needed then only do check once

		{

		TBool shouldPass=ETrue;

		if (sid!=aSidNeeded)

			{

			shouldPass=EFalse;

			}

		for (TUid vid={0}; vid.iUid <= aVidNeeded.iUid; vid.iUid+= aVidNeeded.iUid ? aVidNeeded.iUid : 1)

			{

			if (vid!=aVidNeeded)

				{

				shouldPass=EFalse;

				}

			//For each IPC, your test should implement the following:

			//

			// If an IPC is controlled by one capability only, the test code should run 

			//first with the required capability only and second with the complement set

			//of the required capability. If the first test is successful and the second 

			//a failure, the IPC value is proven to be controlled by the required capability

			//only. 

			//

			// If an IPC is controlled by n capabilities, the test code should run first with

			//exact n required capabilities and after with any combination of all subsets of 

			//n-1 capabilities with the complement set. 

			//

			// For example, ABC controls an IPC. The full list of capabilities is 

			//A, B, C, D, E and F. Test code with ABC must be successful, while test code

			//with ABDEF, ACDEF, BCDEF must all fail.

			//

			// So, the number of tests to run to validate a IPC is the combination of n 

			//capabilities, n-1 at a time (i.e. n!/(n-1)! )  plus 1 exact positive test,

			//therefore a total of n+1 tests.

			// possibly positive case (depends on Sid and Vid settings)

			aEnvironments.Append(TTestEnvironment(aCapsNeeded, sid, vid, shouldPass));

			if (iThoroughness == EBasicChecks) // will fail when cap set is empty, but there is no TCapabilitySet::NotEmpty exported, write a replacement copy

				{

				// Just add one with no caps and expect to fail

				TCapabilitySet noCaps;

				aEnvironments.Append(TTestEnvironment(noCaps, sid, vid, EFalse));

				}

			else

				{

				// Thorough, cap sets as per comment above 

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

					{

					if (aCapsNeeded.HasCapability(TCapability(c)))

						{

						// Need to add a new one with (aCapsNeeded / c) | ~aCapsNeeded

						TCapabilitySet caps(aCapsNeeded);

						caps.RemoveCapability(TCapability(c)); // take cap c away

						caps.Union(InvertCapSet(aCapsNeeded)); // add in complement

						aEnvironments.Append(TTestEnvironment(caps, sid, vid, EFalse)); // add to sets, should fail

						}

					}

				} // end thorough cap tests

			} // end vid loop

		} // end sid loop

	}

TVerdict CCapTestFrameworkStep::doTestStepPostambleL()

	{

	return EPass;

	}

// helper functions

TCapabilitySet CCapTestFrameworkStep::InvertCapSet(const TCapabilitySet& aCapSet)

	{

	TCapabilitySet ret;

	ret.SetEmpty();

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

		{

		if (c == ECapabilityTCB && iOmitTCBCapInComplementSet)

			{

			continue;

			}

		if (!aCapSet.HasCapability(TCapability(c)))

			{

			ret.AddCapability(TCapability(c));

			}

		}

	return ret;

	}

MCapabilityTestFactory* CCapTestFrameworkStep::SetupFactoryL()

	{

	User::LeaveIfError(iLibrary.Load(iDllName));

	TLibraryFunction testFactory=iLibrary.Lookup(1);

	iFactory=reinterpret_cast<MCapabilityTestFactory*>(testFactory());

	return iFactory;

	}

// TCapSetTestInfo

TTestEnvironment::TTestEnvironment(const TCapabilitySet& aCaps, TUid aSid, TUid aVid, TBool aExpectPass)

	: iCaps(aCaps), iSid(aSid), iVid(aVid), iExpectPass(aExpectPass)

	{

	}