// 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 "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 <f32file.h>

#include <fbs.h>

#include <bitmap.h>

#include <bautils.h>

#include "../sfbs/UTILS.H"

#include "TSecureFBS.h"

LOCAL_C RFs fs;

//----------------------TEST DATA-------------------------------------

//RC_ROM12 is a ROM type mbm

//RC_RAM16 is a File Store type mbm

//TFBS inside TFBS_RSC is a File Store type mbm

//Bitmap for testing purposes

_LIT(KBmp1_Z,"z:\\system\\data\\RC_ROM12.mbm");

_LIT(KBmp2_Z,"z:\\system\\data\\RC_RAM16.mbm");

//Private path in C:

_LIT(KBmp2_CP,"c:\\private\\10273364\\RC_RAM16.mbm");

//Private path in Z:

_LIT(KBmp1_ZP,"z:\\private\\10273364\\RC_ROM12.mbm");

_LIT(KBmp2_ZP,"z:\\private\\10273364\\RC_RAM16.mbm");

_LIT(KRscHeader_ZP,"z:\\private\\10273364\\RscHeader3.bin");

_LIT(KDummyRsc_ZP,"z:\\private\\10273364\\DummyRscFile3.rsc");

_LIT(KTbsRsc_ZP,"z:\\private\\10273364\\TFBS_RSC.rsc");

_LIT(KInvalid_Bitmap,"z:\\private\\10273364\\invalid.mbm");

//Other private path 00999999 used for data caging test

_LIT(KBmp1_ZOP,"z:\\private\\00999999\\RC_ROM12.mbm");

_LIT(KBmp2_ZOP,"z:\\private\\00999999\\RC_RAM16.mbm");

_LIT(KPlatsecBegin,"*PlatSec* ERROR - BEGIN NEGATIVE PLATSEC TESTING");

_LIT(KPlatsecEnd,"*PlatSec* ERROR - END NEGATIVE PLATSEC TESTING");

//---------------------------------------------------------------------

CTFbsSecure::CTFbsSecure(CTestStep* aStep) :

	CTGraphicsBase(aStep)

	{

	}

//--------------------UTILITY Function---------------------------------

//This function is here to measure the offset in the rsc file

TInt CTFbsSecure::FileSizeL(const TDesC& aFileName)

	{

	RFile file;

	User::LeaveIfError(file.Open(fs, aFileName, EFileRead));

	CleanupClosePushL(file);

	TInt size = 0;

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

	CleanupStack::PopAndDestroy(&file);

	return size;

	}

//--------------------TEST CASE Function-------------------------------

/**

-Using two type of bitmaps Rom and File Store Bitmap

-Testing will focus on File Store type bitmap only

-Loading a bitmap in private data cage, expect KErrNone

-Loading a bitmap in other private data cage, expect KErrPermissionDenied(-46)

-Loading a bitmap from a public path, expect KErrNone

-Loading a bitmap from an rsc file inside the private data path

*/

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0585

	@SYMTestCaseDesc

	TestCase1 for testing data caging properties.

	@SYMTestActions

	Using two type of bitmaps Rom and File Store Bitmap.

	Testing will focus on File Store type bitmap only.

	Loading a bitmap in private data cage, expect KErrNone.

	Loading a bitmap in other private data cage, expect KErrPermissionDenied(-46).

	Loading a bitmap from a public path, expect KErrNone.

	Loading a bitmap from an rsc file inside the private data path.

	@SYMTestExpectedResults

	Test should pass

*/

void CTFbsSecure::TestCase1()

	{

	INFO_PRINTF1(_L("Test Case 1"));

    TInt skipRomBitmapTests = EFalse;

	TUint32* romAddress = NULL;

	if(!CFbsBitmap::IsFileInRom(KBmp1_ZP, romAddress)) //any ROM bitmap

		{

		INFO_PRINTF2(_L("Skipping ROM bitmap tests since file \"%S\" is reported to not be a ROM bitmap."),

				&KBmp1_ZP);

		INFO_PRINTF1(_L("This should only occur on non-XIP ROMs, e.g. NAND ROMs, where ROM bitmaps aren't supported."));

		skipRomBitmapTests = ETrue;

		}

	TInt ret;

	if(!skipRomBitmapTests)

		{

		//Loading a ROM bitmap from its own private data cage \private\00099999

		CFbsBitmap bmp1;

		ret=bmp1.Load(KBmp1_ZP,0);

		TEST(ret==KErrNone);

		TEST(bmp1.IsRomBitmap());

		//Loading a ROM bitmap from other private data cage \private\00999999

		//This test works if PlatSecEnforcement is ON otherwise it will return KErrNone

		CFbsBitmap bmp2;

		ret=bmp2.Load(KBmp1_ZOP,0);

		if (PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement) && PlatSec::IsCapabilityEnforced(ECapabilityAllFiles))

			TEST(ret==KErrPermissionDenied);

		else

			TEST(ret==KErrNone);

		//Loading a ROM bitmap from a public data cage \system\data

		CFbsBitmap bmp3;

		ret=bmp3.Load(KBmp1_Z,0);

		TEST(ret==KErrNone);

		}

	//Loading a File Store bitmap from its own private data cage \private\00099999

	CFbsBitmap bmp4;

	ret=bmp4.Load(KBmp2_ZP,0);

	TEST(ret==KErrNone);

	TEST(!bmp4.IsRomBitmap());

	//Loading a File Store bitmap from other own private data cage \private\00099999

	CFbsBitmap bmp5;

	ret=bmp5.Load(KBmp2_ZOP,0);

	if (PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement) && PlatSec::IsCapabilityEnforced(ECapabilityAllFiles))

		TEST(ret==KErrPermissionDenied);

	else

		TEST(ret==KErrNone);

	//Loading a File Store bitmap from a public data cage \system\data

	CFbsBitmap bmp6;

	ret=bmp6.Load(KBmp2_Z,0);

	TEST(ret==KErrNone);

	//Loading a bitmap file from an rsc file inside the private data path

	CFbsBitmap bmp7;

	TInt fileoffset=0;

	//Getting the file offset for the mbm file embedded inside the rsc

	TRAP(ret,fileoffset=FileSizeL(KRscHeader_ZP)+FileSizeL(KDummyRsc_ZP));

	TEST(ret==KErrNone);

	ret=bmp7.Load(KTbsRsc_ZP,0,EFalse,fileoffset);

	TEST(ret==KErrNone);

	//Loading a File Store bitmap from own private data cage in C:

	CFbsBitmap bmp8;

	ret=bmp8.Load(KBmp2_CP,0);

	TEST(ret==KErrNone);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0586

	@SYMTestCaseDesc

	TestCase2 for testing of invalid arguments such as file name,id, file offset

	@SYMTestActions

	Test focus on File Store bitmap

	Loading an invalid bitmap file name expect KErrNotFound

	Loading a bitmap with invalid id

	Loading a bitmap with invalid file offset

	@SYMTestExpectedResults

	Test should pass

*/

void CTFbsSecure::TestCase2()

	{

	INFO_PRINTF1(_L("Test Case 2"));

	TInt ret;

	//Loading an invalid bitmap KInvalid_Bitmap

	CFbsBitmap bmp1;

	ret=bmp1.Load(KInvalid_Bitmap,0);

	TEST(ret==KErrNotFound);

	//Loading a bitmap with invalid id,KBmp1_ZP only has one bitmap

	CFbsBitmap bmp2;

	ret=bmp2.Load(KBmp2_ZP,1);

	TEST(ret==KErrEof);

	//Loading a bitmap with invalid File offset

	CFbsBitmap bmp3;

	ret=bmp3.Load(KTbsRsc_ZP,0,EFalse,0);

	TEST(ret==KErrNotSupported);

	}

/**

*/

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0587

	@SYMTestCaseDesc

	TestCase3 for testing of the sharing of bitmaps using iShareIfLoaded

	this indirectly test the removal of the FileInfo and yet preserver 

	preserve the same functionality in 9.0 without any regression

	@SYMTestActions

	bmp1 load with iShareIfLoaded=ETrue and bmp2 load same file with ETrue

 	Expect the Handle() and DataAddress() to be the same as there will be

 	only one raw memory data stored in the global heap for these 2 instances of

 	the same bitmap

	bmp3 load with iShareIfLoaded=EFalse and bmp4 load same file with ETrue

 	Expect the Handle() and DataAddress() to be different as bmp1 does not want

 	to share the bitmap,so bmp2 will have its own Handle() and a completely pointer

 	to the bitmap raw data

	@SYMTestExpectedResults

	Test should pass

*/

void CTFbsSecure::TestCase3()

	{

	INFO_PRINTF1(_L("Test Case 3"));

	TInt ret;

	//Loading first bitmap with ShareIfLoaded

	CFbsBitmap* bmp1=new (ELeave) CFbsBitmap;

	ret=bmp1->Load(KBmp2_ZP,0,ETrue);

	TEST(ret==KErrNone);

	TEST(!bmp1->IsRomBitmap());

	//Loading second bitmap with ShareIfLoaded

	CFbsBitmap* bmp2=new (ELeave) CFbsBitmap;

	ret-bmp2->Load(KBmp2_ZP,0,ETrue);

	TEST(ret==KErrNone);

	TEST(!bmp2->IsRomBitmap());

	//Test the file sharing properties do exist here

	TEST(bmp1->Handle()==bmp2->Handle());

	TEST(bmp1->DataAddress()==bmp2->DataAddress());

	TInt fileoffset=0;

	TRAP(ret,fileoffset=FileSizeL(KRscHeader_ZP)+FileSizeL(KDummyRsc_ZP));

	TEST(ret==KErrNone);

	//Loading third bitmap with NO ShareIfLoaded

	CFbsBitmap* bmp3=new (ELeave) CFbsBitmap;

	ret=bmp3->Load(KTbsRsc_ZP,1,EFalse,fileoffset);

	TEST(ret==KErrNone);

	TEST(!bmp3->IsRomBitmap());

	//Loading fourth bitmap(similar to 3) with ShareIfLoaded

	CFbsBitmap* bmp4=new (ELeave) CFbsBitmap;

	ret=bmp4->Load(KTbsRsc_ZP,1,ETrue,fileoffset);

	TEST(ret==KErrNone);

	TEST(!bmp4->IsRomBitmap());

	//Test the file sharing properties does not exist here

	TEST(bmp3->Handle()!=bmp4->Handle());

	TEST(bmp3->DataAddress()!=bmp4->DataAddress());

	delete bmp1;

	delete bmp2;

	delete bmp3;

	delete bmp4;

	}

/**

@SYMTestCaseID GRAPHICS-SYSLIB-FBSERV-CT-0002

@SYMTestCaseDesc Testing for the secure bitmap loading in FBSERV

@SYMTestPriority High

@SYMTestActions  Testing the loading of a bitmap from its own data cage

				 Testing for permission denied when loading from other private data

				 Testing for invalid arguments

				 Testing for bitmap sharing

@SYMTestExpectedResults The test must not fail.

@SYMPREQ 280 General Datacaging

*/

void CTFbsSecure::RunTestCaseL(TInt aCurTestCase)

	{

	((CTFbsSecureStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(aCurTestCase)

		{

	case 1:

		((CTFbsSecureStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0585"));

		RDebug::Print(KPlatsecBegin);

		TestCase1();

		RDebug::Print(KPlatsecEnd);

		break;

	case 2:

		((CTFbsSecureStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0586"));

		TestCase2();

	case 3:

		((CTFbsSecureStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0587"));

		TestCase3();

		break;

	case 4:

		((CTFbsSecureStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTFbsSecureStep*)iStep)->CloseTMSGraphicsStep();

		TestComplete();

		break;

		}

	((CTFbsSecureStep*)iStep)->RecordTestResultL();

	}

//--------------

__CONSTRUCT_STEP__(FbsSecure)

void CTFbsSecureStep::TestSetupL()

	{

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

	//Creating secure private path for testing purpose

	//This should create the private\10099999 directory

	User::LeaveIfError(fs.CreatePrivatePath(EDriveC));

	//copying files to the secure path

	BaflUtils::CopyFile(fs,KBmp2_Z,KBmp2_CP);

	}

void CTFbsSecureStep::TestClose()

	{

	//Deleting any bitmaps copied to C:

	DeleteDataFile(KBmp2_CP);

	fs.Close();

	}

//This function is here to delete the bitmaps in C after finished with it

void CTFbsSecureStep::DeleteDataFile(const TDesC& aFullName)

	{

	TEntry entry;

	if(fs.Entry(aFullName, entry) == KErrNone)

		{

		RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

		TInt err = fs.SetAtt(aFullName, 0, KEntryAttReadOnly);

		if(err != KErrNone) 

			{

			RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

			}

		err = fs.Delete(aFullName);

		if(err != KErrNone) 

			{

			RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

			}

		}

	}