diff -r 000000000000 -r bde4ae8d615e os/graphics/fbs/fontandbitmapserver/tfbs/TSecureFBS.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/fbs/fontandbitmapserver/tfbs/TSecureFBS.CPP Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,361 @@ +// 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 +#include +#include +#include +#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); + } + } + }