diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/kerneltest/f32test/loader/security/t_ldrcheck.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/kernelhwsrv/kerneltest/f32test/loader/security/t_ldrcheck.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,1236 @@
+// Copyright (c) 1999-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:
+// f32test\loader\t_ldrcheck.cpp
+// 
+//
+
+
+#include "dlltree.h"
+#include <e32uid.h>
+#include <hal.h>
+#include <e32wins.h>
+#include <e32svr.h>
+#include <e32test.h>
+#include <f32file.h>
+#include <f32dbg.h>
+#include <f32image.h>
+#include "t_hash.h"
+
+#if defined (WIN32) && !defined (__X86GCC__)
+#include <emulator.h>
+#include <stdlib.h>
+#endif
+
+
+RTest test(_L("T_LDRCheck"));
+RFs TheFs;
+GLDEF_D TChar gDriveToTest;
+
+
+/**
+    Copy modules from z:\\sys\\bin to c:\\sys\\bin
+*/
+void CopyModules()
+	{
+	test.Next(_L("Copy Modules from ROM to disk"));
+
+	TInt r;
+	TTime modtime;
+
+	r=TheFs.MkDirAll(KSystemLibs);
+	test(r==KErrNone || r==KErrAlreadyExists);
+
+	CFileMan* fileMan=NULL;
+	TRAP(r,fileMan=CFileMan::NewL(TheFs));
+	test(r==KErrNone);
+
+	TBuf<40> dllfilenames;
+	TBuf<40> dlldestination;
+	
+	for(TInt i=0;i<14;i++)
+		{
+		dllfilenames=KDllfilename;
+		dllfilenames.AppendNum(i);
+		dllfilenames +=KDllExt;
+		dlldestination=KNewDllName;
+		dlldestination.AppendNum(i);
+		dlldestination+=KDllExt;
+#ifndef WIN32
+		r=fileMan->Copy(dllfilenames,dlldestination, 0);
+		test(r==KErrNone || r==KErrAlreadyExists);
+
+		r=fileMan->Attribs(dlldestination,0, KEntryAttReadOnly,modtime,0);
+		test(r==KErrNone);
+#endif
+		}
+
+	TBuf<40> exefilenames;
+	TBuf<40> exedestination;
+
+	for(TInt j=14;j<16;j++)
+		{
+		exefilenames=KExefilename;
+		exefilenames.AppendNum(j);
+		exefilenames +=KExeExt;
+		exedestination=KNewExeName;
+		exedestination.AppendNum(j);
+		exedestination+=KExeExt;
+#ifndef WIN32
+		r=fileMan->Copy(exefilenames,exedestination,0);
+		test(r==KErrNone || r==KErrAlreadyExists);
+
+		r=fileMan->Attribs(exedestination, 0, KEntryAttReadOnly, modtime, 0);
+		test(r==KErrNone);
+#endif
+		}
+	delete fileMan;
+	}
+
+
+
+#ifndef WIN32
+/*
+void ModifyModuleCapabilties(TUint32 aNewCap, TInt aModuleNumber)
+//
+//	Assign new capabilties to a module using raw disk write
+//
+	{
+//	test.Next(_L("Modify Module Capabilities"));
+	
+	test(aModuleNumber<=15 && aModuleNumber>=0);	
+	
+	TBuf<40> dlldestination;
+	RFile modFile;
+	TInt r=0;
+
+	SCapabilitySet caps;
+	memset(&caps,0,sizeof(caps));
+	caps[0] = aNewCap;
+	TPtrC8 theNewCaps((TUint8*)(&caps),sizeof(caps));
+
+	if(aModuleNumber < 14)
+		{
+		dlldestination=KNewDllName;
+		dlldestination.AppendNum(aModuleNumber);
+		dlldestination+=KDllExt;
+		}
+	else
+		{
+		dlldestination=KNewExeName;
+		dlldestination.AppendNum(aModuleNumber);
+		dlldestination+=KExeExt;
+		}
+
+	r=modFile.Open(TheFs, dlldestination, EFileWrite);
+	test(r==KErrNone);
+	r=modFile.Write(_FOFF(E32ImageHeaderV,iS.iCaps), theNewCaps,4);
+	test(r==KErrNone);
+	modFile.Close();	
+
+	RLibrary lib;
+	TCapabilitySet theCaps;
+	RLibrary::TInfoBuf info;
+
+	lib.GetInfo(dlldestination, info);
+	theCaps=info().iSecurityInfo.iCaps;
+
+	lib.Close();
+	test(theCaps==aNewCap);
+
+	}
+*/
+#else
+/*
+void ModifyModuleCapabilties(TUint32 aNewCap, TInt aModuleNumber)
+//
+//	Wins version (poking values is not quite so simple
+//
+	{
+//	test.Next(_L("Modify Module Capabilities"));
+	test(aModuleNumber<=15 && aModuleNumber>=0);	
+	
+	TBuf<40> dlldestination;
+	TInt r=0;
+
+	TPtrC8 theNewCaps((TUint8*)(&aNewCap),sizeof(TUint32));
+
+	
+	if(aModuleNumber < 14)
+		{
+		dlldestination=KNewDllName;
+		dlldestination.AppendNum(aModuleNumber);
+		dlldestination+=KDllExt;
+		}
+	else
+		{
+		dlldestination=KNewExeName;
+		dlldestination.AppendNum(aModuleNumber);
+		dlldestination+=KExeExt;
+		}
+
+	RLibrary lib2;
+	TCapabilitySet theCaps2;
+	RLibrary::TInfoBuf info;
+
+	lib2.GetInfo(dlldestination, info);
+	theCaps2=info().iSecurityInfo.iCaps;
+
+	lib2.Close();
+			
+	TBuf<MAX_PATH> fileName;
+	r = MapEmulatedFileName(fileName, dlldestination);
+
+	HANDLE hFile=Emulator::CreateFile((LPCTSTR)fileName.PtrZ(),GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,NULL);
+	if (hFile==INVALID_HANDLE_VALUE)
+		return;
+	DWORD ret;
+	TBuf8<sizeof(TCheckedUid)> checkedUidBuf;
+	checkedUidBuf.SetLength(sizeof(TCheckedUid));
+	ReadFile(hFile,&checkedUidBuf[0],sizeof(TCheckedUid),&ret,NULL);
+	if (ret!=sizeof(TCheckedUid))
+		goto close;
+
+		//Look at PE file for UID section
+		{
+		const TInt KPeHeaderAddrAddr=0x3c;
+		const TInt KPeHeaderAddrSize=0x01;
+		const TInt KNumberOfSectionsOffset=0x06;
+		const TInt KNumberOfSectionsSize=0x02;
+		const TInt KSectionTableOffset=0xf8;
+		const TInt KSectionHeaderSize=0x28;
+		const TInt KSectionNameLength=0x08;
+		const TInt KPtrToRawDataOffset=0x14;
+		const TInt KPtrToRawDataSize=0x04;
+		const TText8 peText[4]={'P','E',0,0};
+		const TText8 uidText[8]={'.','S','Y','M','B','I','A','N'};
+		
+	//Read address of start of PE header
+		if (SetFilePointer(hFile,KPeHeaderAddrAddr,0,FILE_BEGIN)==0xFFFFFFFF)
+			goto close;
+		TInt peAddr=0;
+		ReadFile(hFile,&peAddr,KPeHeaderAddrSize,&ret,NULL);
+		if (ret!=KPeHeaderAddrSize)
+			goto close;
+		
+	//Check it really is the start of PE header
+		if (SetFilePointer(hFile,peAddr,0,FILE_BEGIN)==0xFFFFFFFF)
+			goto close;
+		TText8 text[4];
+		ReadFile(hFile,text,4,&ret,NULL);
+		if (*(TInt32*)text!=*(TInt32*)peText)
+			goto close;
+		
+	//Read number of sections
+		if (SetFilePointer(hFile,peAddr+KNumberOfSectionsOffset,0,FILE_BEGIN)==0xFFFFFFFF)
+			goto close;
+		TInt sections=0;
+		ReadFile(hFile,&sections,KNumberOfSectionsSize,&ret,NULL);
+		if (ret!=KNumberOfSectionsSize)
+			goto close;
+
+	//Go through section headers looking for UID section
+		if (SetFilePointer(hFile,peAddr+KSectionTableOffset,0,FILE_BEGIN)==0xFFFFFFFF)
+			goto close;
+		TInt i=0;
+		for(;i<sections;i++)
+			{
+			TText8 name[KSectionNameLength];
+			ReadFile(hFile,name,KSectionNameLength,&ret,NULL);
+			if (ret!=KSectionNameLength)
+				goto close;
+			if (*(TInt64*)name==*(TInt64*)uidText)
+				break;
+			if (SetFilePointer(hFile,KSectionHeaderSize-KSectionNameLength,0,FILE_CURRENT)==0xFFFFFFFF)
+				goto close;
+			}
+		if (i==sections)
+			goto close;
+
+	//Read RVA/Offset
+		if (SetFilePointer(hFile,KPtrToRawDataOffset-KSectionNameLength,0,FILE_CURRENT)==0xFFFFFFFF)
+			goto close;
+		TInt uidOffset;
+		ReadFile(hFile,&uidOffset,KPtrToRawDataSize,&ret,NULL);
+		if (ret!=KPtrToRawDataSize)
+			goto close;
+
+	//SYMBIAN Header
+		if (SetFilePointer(hFile,uidOffset,0,FILE_BEGIN)==0xFFFFFFFF)
+			goto close;
+
+		TEmulatorImageHeader header;
+
+		ReadFile(hFile,&header,sizeof(header),&ret,NULL);
+		if (ret!=sizeof(header))
+			goto close;
+		
+// DON'T modify, for now		header.iS.iCaps[0] = aNewCap;		//assign new caps to binary
+
+
+		if (SetFilePointer(hFile,uidOffset,0,FILE_BEGIN)==0xFFFFFFFF)
+			goto close;
+
+		BOOL b = WriteFile(hFile,&header,sizeof(header),&ret,NULL);
+		if (b==FALSE)
+			goto close;
+		CloseHandle(hFile);
+		
+		RLibrary lib;
+		TCapabilitySet theCaps;
+		RLibrary::TInfoBuf info;
+		lib.GetInfo(dlldestination, info);
+		theCaps=info().iSecurityInfo.iCaps;
+
+		lib.Close();
+
+		SCapabilitySet& realCaps = (SCapabilitySet&) theCaps;
+// broke!		test(realCaps[0] == aNewCap && realCaps[1] == 0);
+		return;
+		}
+
+//Close file
+close:
+	CloseHandle(hFile);
+	test(0);
+	} 
+*/
+#endif
+
+/*
+void TestGetCapability()
+//
+//	test RLibrary::GetCapabilites
+//
+	{
+	RLibrary library;
+	TInt r;
+	test.Next(_L("Test RLibrary::GetCapabilities()"));
+
+// These tests check the error code returned by the (deprecated) GetCapability method
+// and now serve no useful purpose
+//	TCapability theCaps;
+//	r=library.GetCapability(theCaps,_L("Z:\\Mongolia"));
+//	test(r==KErrNotFound);
+//	r=library.GetCapability(theCaps,_L("C:\\Malawi.Fip"));
+//	test(r==KErrNotFound);
+
+	TCapabilitySet theCaps;
+	RLibrary::TInfoBuf info;
+#if defined __WINS__
+
+	
+
+
+	test.Next(_L("Get caps of an existing library"));
+//	r=lib1.GetCapability(theCaps,_L("ECONS"));
+//	test(r==KErrNone);
+	RLibrary lib1;
+//	r=lib1.GetInfo(_L("ECONS"), info);
+	r=lib1.GetInfo(_L("Z:\\SYS\\BIN\\ECONS"), info);
+	test(r==KErrNone);
+	theCaps=info().iSecurityInfo.iCaps;
+
+	test.Next(_L("And again"));
+//	r=lib2.GetCapability(theCaps,_L("ECONS.DLL"));
+//	test(r==KErrNone);
+	RLibrary lib2;
+	lib2.GetInfo(_L("ECONS.DLL"), info);
+	theCaps=info().iSecurityInfo.iCaps;
+	
+#else
+// This test checks for the correct return value from the (deprecated)
+// method GetCapability, and now serves no useful purpose??
+//	r=library.GetCapability(theCaps,_L("Malawi.Fip"));
+//	test(r==KErrNotSupported);
+	library.GetInfo(_L("Malawi.Fip"), info);
+	theCaps=info().iSecurityInfo.iCaps;
+
+//TODO uncomment when in ssytem bin
+//	RLibrary lib1;
+//	test.Next(_L("Get caps of an existing library"));
+//	r=lib1.GetCapability(theCaps,_L("ECONS"));
+//	r=lib1.GetCapability(theCaps,_L("Z:\\Sys\\Bin\\ECONS"));
+//	RDebug::Print(_L("r====%d"),r);
+//	test(r==KErrNone);
+	
+//	RLibrary lib2;
+//	test.Next(_L("And again"));
+//	r=lib2.GetCapability(theCaps,_L("Z:\\Sys\\Bin\\ECONS.DLL"));
+//	r=lib2.GetCapability(theCaps,_L("ECONS.DLL"));
+//	test(r==KErrNone);
+	
+	RLibrary lib3;
+	test.Next(_L("And again, but searching"));
+	r=lib3.GetCapability(theCaps,_L("ECONS.DLL"));
+	test(r==KErrNotSupported);
+	lib3.Close();
+	
+#endif
+
+	test.Next(_L("Search through DLLs from t_ldrcheck"));
+
+	// Not sure of the benefit of this test ??
+
+	TBuf<40> dllfilenames;
+	RLibrary tlib;
+//	TCapability deecaps;
+	TCapabilitySet deecaps;
+	for(TInt i=0;i<13;i++)
+		{
+		dllfilenames=KDllfilename;
+		dllfilenames.AppendNum(i);
+		dllfilenames +=KDllExt;
+//		r=tlib.GetCapability(deecaps,dllfilenames);		
+		tlib.GetInfo(dllfilenames, info);
+		theCaps=info().iSecurityInfo.iCaps;
+		}
+
+	test.Next(_L("Close()"));
+	tlib.Close();
+	library.Close();
+//	lib1.Close();
+//	lib2.Close();
+	}
+*/
+
+TInt LoadExe(TInt aModuleNum,  RProcess& aProcess)
+//
+//	Load executable
+//
+	{
+	TFileName fn;
+//#ifndef WIN32
+//	fn =KSystemLibs();
+//#endif
+	TBuf<16> cmd;
+	fn += MODULE_FILENAME(aModuleNum);
+	TInt r=aProcess.Create(fn, cmd);
+	return r;
+	}
+
+
+void TestLoad(TInt aSequence)
+//
+// Test doing the loads using sequence number to get the results
+//
+	{
+	test.Next(_L("Test all single EXE/DLL combinations\n"));
+	TInt r=0;
+	test.Next(_L("New EXE"));
+	RProcess p;
+
+	r=LoadExe(14,p);
+	test.Printf(_L("LoadExe(14)->%d, Expected %d, seq %d \n"),r,ModuleResultsA[aSequence], aSequence);
+	test(r==ModuleResultsA[aSequence]);
+	if (r==KErrNone)
+		p.Terminate(0);
+	p.Close();
+
+	r=LoadExe(15,p);
+	test.Printf(_L("LoadExe(15)->%d, seq %d\n"),r,aSequence);
+	test(r==ModuleResultsA[aSequence]);
+	if (r==KErrNone)
+		p.Terminate(0);
+	p.Close();
+	}
+
+/*
+void TestLoadLibrary()
+//
+//	test using load library to load dlls with out rom time dependancies
+//
+	{
+	test.Next(_L("Test loading libraries fromn this exe"));
+	
+	RLibrary lib;
+	TInt r=0;
+	//I want to load 6 7 and 11 as these	are of most interest
+
+	for(TInt i=0;i<KTestCases;i++)
+		{
+		for(TInt mod=0 ; mod < 16 ; mod++)	//each module
+			{
+			ModifyModuleCapabilties(ModuleCaps[mod][i],mod);
+			}
+		r=lib.Load(KDll11);
+		test.Printf(_L("mod11, iter=%d, ret=%d, exp=%d"),i,r,ModuleResultsB[i]);
+		test(r==ModuleResultsB[i]);
+		lib.Close();
+		r=lib.Load(KDll6);
+		test.Printf(_L("mod6, iter=%d, ret=%d, exp=%d"),i,r,ModuleResultsB[i]);
+		test(r==ModuleResultsB[i]);
+		lib.Close();
+		r=lib.Load(KDll7);
+		test.Printf(_L("mod7, iter=%d, ret=%d, exp=%d"),i,r,ModuleResultsC[i]);
+		test(r==ModuleResultsC[i]);
+		lib.Close();
+		}
+
+	}
+*/
+/*
+void TestLoading()
+//
+//	test loading various dependancies
+//
+	{
+	for(TInt tstcase=0; tstcase < KTestCases; tstcase++)	//each test case
+		{
+		for(TInt mod=0 ; mod < 16 ; mod++)	//each module
+			{
+			ModifyModuleCapabilties(ModuleCaps[mod][tstcase],mod);
+			}
+			TestLoad(tstcase);	
+		}
+	}
+*/
+
+
+_LIT(KSysHash,"?:\\Sys\\Hash\\");
+const TInt KSlash='\\';
+
+/**
+    Creates a hash file in c:\\sys\\hash for a given file
+    
+    @param aFileName full path to the file, which hash is to be created
+*/
+void CreateFileHash(const TDesC& aFileName)
+	{
+
+	test.Printf(_L("Create Hash for the file %S\n"), &aFileName);
+
+	TInt readsize = 1024*2;//to go into header
+	HBufC8* block0 = HBufC8::NewL(readsize); 
+
+	TPtr8 fileblock0(block0->Des());
+	CSHA1* hasher=CSHA1::NewL(); 
+	
+	RFile fTarget;
+	TInt r= fTarget.Open(TheFs, aFileName, EFileRead);
+	test(r==KErrNone);
+	TInt size;
+	r=fTarget.Size(size);
+	TInt offset=0;
+	do	{
+		if((size - offset) < readsize)
+			readsize = (size - offset);
+		r=fTarget.Read(offset, fileblock0, readsize);
+		test(r==KErrNone);
+		hasher->Update(fileblock0);
+		offset+=readsize;
+		}
+	while(offset < size); 
+
+	r=fTarget.Read(fileblock0, (size - offset));			
+	test(r==KErrNone);
+	hasher->Update(fileblock0);
+
+	TBuf8<20> hash;//only outputs a 20 byte hash
+	hash = hasher->Final();
+	fTarget.Close();
+		
+//	const TUint8 * hptr=hash.Ptr();
+//	for(TInt i=0;i<20;i++)
+//		{
+//		RDebug::Print(_L("install hash byte %d = 0x%x\n"),i,hptr[i]);
+//		}
+	
+	delete block0;
+	delete hasher;
+	TEntry entry;
+	r=TheFs.Entry(aFileName,entry);
+	test(r==KErrNone);
+	RFile fHash;
+	TBuf<50> hashfile;
+	hashfile = KSysHash;
+	hashfile[0] = (TUint8) RFs::GetSystemDriveChar();
+	TInt slashpos = aFileName.LocateReverse(KSlash);
+	hashfile += aFileName.Mid(slashpos+1);
+	
+	//-- create directory for dll hashes
+	r=TheFs.MkDirAll(hashfile);
+	test(r==KErrNone || r==KErrAlreadyExists);
+	
+    //-- copy / replace given dll hash 
+	r=fHash.Replace(TheFs, hashfile, EFileWrite);
+	test(r==KErrNone);
+	r=fHash.Write(hash);
+	test(r==KErrNone);
+	r=fHash.Size(size);
+	test(r==KErrNone);
+	test.Printf(_L("hash file size=%d\n"),size);
+	fHash.Close();
+	
+    }
+
+
+/**
+    Corrups a file.
+    
+    @param  aFileName   a full path to the file to corrupt
+    @return KErrNone on success
+*/
+static TInt CorruptFile(const TDesC& aFileName)
+{
+	test.Printf(_L("Corrupting file %S\n"), &aFileName);
+
+    RFile corrFile;
+    CleanupClosePushL(corrFile);	
+
+    TInt r=corrFile.Open(TheFs, aFileName, EFileWrite);
+	if(r != KErrNone)
+        return r;
+	
+    TInt size;
+	r=corrFile.Size(size);
+	if(r != KErrNone)
+        return r;
+	
+    TBuf8<2> dat;
+	r=corrFile.Read(size - 5, dat);
+	if(r != KErrNone)
+        return r;
+
+	dat[0] = (TUint8) ~dat[0];
+	
+    r=corrFile.Write(size - 5, dat);
+	if(r != KErrNone)
+        return r;
+
+    CleanupStack::PopAndDestroy(1); //-- corrFile
+
+    return KErrNone;
+}
+
+
+#ifndef WIN32
+void TestRemovableMediaWithHash()
+//
+//	test loading from removable media and substed drives Both should fail
+//
+	{
+	test.Next(_L("Testing Removable Media with hashing\n"));
+	TInt r=0;
+	CFileMan* fileMan=NULL;
+	TRAP(r,fileMan=CFileMan::NewL(TheFs));
+	test(r==KErrNone);
+
+	TBuf<30> dllfilenames;
+	TBuf<30> dlldestination;
+	RLibrary lib;
+	
+    for(TInt i=0;i<14;i++)
+		{
+		dllfilenames=KNewDllName;
+		dllfilenames.AppendNum(i);
+		dllfilenames +=KDllExt;
+		
+		dlldestination=KNewDllName;
+		dlldestination[0]=gDriveToTest;
+		dlldestination.AppendNum(i);
+		dlldestination+=KDllExt;
+		
+		r=TheFs.MkDirAll(dlldestination);
+		test.Printf(_L("MkDirAll(%S) returned %d\n"), &dlldestination, r);
+		test(r==KErrNone || r==KErrAlreadyExists);
+		r=fileMan->Copy(dllfilenames,dlldestination, 0); 
+        test(r==KErrNone || r==KErrAlreadyExists);	
+
+
+		//take hash of binary
+		CreateFileHash(dlldestination);
+
+		//load binary as is
+		r=lib.Load(dlldestination);
+		RDebug::Print(_L("t_ldrcheck: loading  %S returned %d\n"),&dlldestination, r);
+
+		User::After(100000);
+		test(r==KErrNone);
+		lib.Close();
+		test.Printf(_L("Close lib on untouched load\n"));
+
+        //-- corrupt dll
+        r = CorruptFile(dlldestination);
+        test(r==KErrNone);
+		test.Printf(_L("Binary %S now corrupted\n"), &dlldestination);
+
+		//load should fail
+		test.Printf(_L("loading %S\n"),&dlldestination);
+		r=lib.Load(dlldestination);
+		test.Printf(_L("load of %S returned %d\n"),&dlldestination,r);
+		test(r==KErrPermissionDenied);//as this process has Root caps and the dlls should be loaded with non
+		lib.Close();
+		test.Printf(_L("Lib close 1\n"));
+
+		r=TheFs.Delete(dlldestination);
+		test.Printf(_L("Delete ret=%d\n"),r);
+		test(r==KErrNone);
+		}//for(TInt i=0;i<14;i++)
+
+
+	TBuf<30> exefilenames;
+	TBuf<30> exedestination;
+	RProcess p;
+	TBuf<16> cmd;
+
+	for(TInt j=14;j<16;j++)
+		{
+		exefilenames=KNewExeName;;
+		exefilenames.AppendNum(j);
+		exefilenames +=KExeExt;
+		
+		exedestination=KNewExeName;
+		exedestination[0]=gDriveToTest;
+		exedestination.AppendNum(j);
+		exedestination+=KExeExt;
+
+		r=fileMan->Copy(exefilenames,exedestination,0);
+		test(r==KErrNone || r==KErrAlreadyExists);
+
+		CreateFileHash(exedestination);
+
+		r=p.Create(exedestination, cmd);
+		test(r==KErrNone);
+		p.Terminate(0);
+		p.Close();
+
+        r = CorruptFile(exedestination);
+        test(r==KErrNone);
+		
+		test.Printf(_L("Binary %S now corrupted\n"), &exedestination);
+
+		r=p.Create(exedestination, cmd);
+		test(r==KErrPermissionDenied);
+//		p.Terminate(0);	DON'T DO THIS SINCE CREATION FAILED - HANDLE NOT OPENED
+		p.Close();
+		
+		r=TheFs.Delete(exedestination);
+		test(r==KErrNone);
+
+		}
+	delete fileMan;
+	}
+
+/*
+void TestRemovableMedia()
+//
+//	test loading from removable media and substed drives Both should fail
+//
+	{
+	test.Next(_L("Testing Removeable Media"));
+	TInt r=0;
+	CFileMan* fileMan=NULL;
+	TRAP(r,fileMan=CFileMan::NewL(TheFs));
+	test(r==KErrNone);
+
+	TBuf<30> dllfilenames;
+	TBuf<30> dlldestination;
+	RLibrary lib;
+	for(TInt i=0;i<14;i++)
+		{
+		dllfilenames=KNewDllName;
+		dllfilenames.AppendNum(i);
+		dllfilenames +=KDllExt;
+		
+		dlldestination=KNewDllName;
+		dlldestination[0]='D';
+		dlldestination.AppendNum(i);
+		dlldestination+=KDllExt;
+		
+		r=TheFs.MkDirAll(dlldestination);
+		test(r==KErrNone || r==KErrAlreadyExists);
+
+		r=fileMan->Copy(dllfilenames,dlldestination, 0);
+		test(r==KErrNone || r==KErrAlreadyExists);	
+		
+		r=lib.Load(dlldestination);
+		test.Printf(_L("load %S ret=%d"),&dlldestination,r);
+		RDebug::Print(_L("r=%d"),r);
+		test(r==KErrPermissionDenied);//as this process has Root caps and the dlls should be loaded with non
+		lib.Close();
+		}
+
+	TBuf<30> exefilenames;
+	TBuf<30> exedestination;
+	RProcess p;
+	TBuf<16> cmd;
+
+	for(TInt j=14;j<16;j++)
+		{
+		exefilenames=KNewExeName;;
+		exefilenames.AppendNum(j);
+		exefilenames +=KExeExt;
+		
+		exedestination=KNewExeName;
+		exedestination[0]='D';
+		exedestination.AppendNum(j);
+		exedestination+=KExeExt;
+
+		r=fileMan->Copy(exefilenames,exedestination,0);
+		test(r==KErrNone || r==KErrAlreadyExists);
+
+		r=p.Create(exedestination, cmd);
+		test(r==KErrPermissionDenied);
+		p.Close();
+		}
+	delete fileMan;
+	}
+*/
+
+void TestNonSystemSubsted()
+//
+//	Test an internal drive on non system dir
+//
+	{
+	test.Next(_L("Testing Non System and Subst"));
+	TInt r=0;
+	CFileMan* fileMan=NULL;
+	TRAP(r,fileMan=CFileMan::NewL(TheFs));
+	test(r==KErrNone);
+
+	TBuf<50> dllfilenames;
+	TBuf<50> dlldestination;
+	TBuf<50> substed;
+	RLibrary lib;
+	for(TInt i=0;i<14;i++)
+		{
+		dllfilenames=KNewDllName;
+		dllfilenames.AppendNum(i);
+		dllfilenames +=KDllExt;
+
+		dlldestination=KAnyDirDll;
+      dlldestination+=_L("_X");
+		dlldestination.AppendNum(i);
+		dlldestination+=KDllExt;
+
+		if(i==0)
+			{
+			r=TheFs.MkDirAll(dlldestination);
+			test(r==KErrNone || r==KErrAlreadyExists);
+			r=TheFs.SetSubst(KAnyDirShort(), EDriveN);	//set up n as the substed drive
+			test(r==KErrNone);
+			}
+		
+		RDebug::Print(_L("copying from %S to %S"),&dllfilenames,&dlldestination);
+		r=fileMan->Copy(dllfilenames,dlldestination, 0);
+		test(r==KErrNone || r==KErrAlreadyExists);	
+
+      //
+      // Test that loading from fully qualified path fails
+      // (ie - C:\Anyoldname\sys\bin\DLLTS_X0.DLL)
+      //
+      r=lib.Load(dlldestination);
+      RDebug::Print(_L("RLibrary::Load(%S) : r=%d"), &dlldestination, r);
+      test(r==KErrNotFound);
+
+      //
+      // Test that loading from substituted drive fails
+      // (ie - N:\sys\bin\DLLTS_X0.DLL, where N:\ == C:\Anyoldname\)
+      //
+		substed=KJDllName;
+      substed+=_L("_X");
+		substed.AppendNum(i);
+		substed+=KDllExt;
+		
+		r=lib.Load(substed);
+      RDebug::Print(_L("RLibrary::Load(%S) : r=%d"), &substed, r);
+      test(r==KErrNotFound);
+
+      //
+      // Test that loader search does not find substituted drives when
+      // loading library with no drive or path specified.
+      //
+      substed=KJDllNameOnly;
+      substed+=_L("_X");
+      substed.AppendNum(i);
+      substed+=KDllExt;
+
+      r=lib.Load(substed);
+      RDebug::Print(_L("RLibrary::Load(%S) : r=%d"), &substed, r);
+      test(r==KErrNotFound);
+		}
+
+	TBuf<50> exefilenames;
+	TBuf<50> exedestination;
+	RProcess p;
+	TBuf<16> cmd;
+
+	for(TInt j=14;j<16;j++)
+		{
+		exefilenames=KNewExeName;;
+		exefilenames.AppendNum(j);
+		exefilenames +=KExeExt;
+
+		exedestination=KAnyDirExe;
+      exedestination+=_L("_X");
+		exedestination.AppendNum(j);
+		exedestination+=KExeExt;
+
+		RDebug::Print(_L("copying from %S to %S"),&exefilenames,&exedestination);
+		r=fileMan->Copy(exefilenames,exedestination,0);
+		test(r==KErrNone || r==KErrAlreadyExists);
+
+      //
+      // Test that loading from fully qualified path fails
+      // (ie - C:\Anyoldname\sys\bin\EXETS_X14.EXE)
+      //
+      r=p.Create(exedestination, cmd);
+      RDebug::Print(_L("RProcess::Create(%S) : r=%d"), &exedestination, r);
+      test(r==KErrNotFound);
+
+      //
+      // Test that loading from substituted drive fails
+      // (ie - N:\sys\bin\EXETS_X14.EXE, where N:\ == C:\Anyoldname\)
+      //
+		substed=KJExeName;
+      substed+=_L("_X");
+		substed.AppendNum(j);
+		substed+=KExeExt;
+
+		r=p.Create(substed, cmd);
+      RDebug::Print(_L("RProcess::Create(%S) : r=%d"), &substed, r);
+      test(r==KErrNotFound);
+
+      //
+      // Test that loader search does not find substituted drives when
+      // loading process with no drive or path specified.
+      //
+      substed=KJExeNameOnly;
+      substed+=_L("_X");
+      substed.AppendNum(j);
+      substed+=KExeExt;
+
+      r=p.Create(substed, cmd);
+      RDebug::Print(_L("RProcess::Create(%S) : r=%d"), &substed, r);
+      test(r==KErrNotFound);
+		}
+	delete fileMan;
+
+	// Clear the substituted drive
+	r=TheFs.SetSubst(KNullDesC, EDriveN);	
+	test(r==KErrNone);
+	}
+
+/*
+void TestSystemBinSubsted()
+//
+//	Test an internal drive on system dir
+//
+	{
+	test.Next(_L("Testing System bin -> Subst"));
+	TInt r=0;
+	CFileMan* fileMan=NULL;
+	TRAP(r,fileMan=CFileMan::NewL(TheFs));
+	test(r==KErrNone);
+
+	TBuf<50> dllfilenames;
+	TBuf<50> substed;
+	RLibrary lib;
+	r=TheFs.SetSubst(KSystemLibs, 14);	//set up O as the substed drive
+	test(r==KErrNone);
+	for(TInt i=0;i<14;i++)
+		{
+		RDebug::Print(_L("doing modify caps = %d"),i);
+		ModifyModuleCapabilties(KCapabilityRoot,i);
+		dllfilenames=KNewDllName;
+		dllfilenames.AppendNum(i);
+		dllfilenames +=KDllExt;
+		
+		RDebug::Print(_L("Module = %S"),&dllfilenames);
+		r=lib.Load(dllfilenames);
+		test(r==KErrNone);//as this process has Root caps and the dlls should be loaded with non
+		substed=_L("O:\\DLLTS");
+		substed.AppendNum(i);
+		substed+=KDllExt;
+	
+		r=lib.Load(substed);
+		test(r==KErrNone);
+		lib.Close();
+		}
+	TBuf<50> exefilenames;
+	RProcess p;
+	TBuf<16> cmd;
+
+	for(TInt j=14;j<16;j++)
+		{
+		exefilenames=KNewExeName;
+		exefilenames.AppendNum(j);
+		exefilenames +=KExeExt;
+		ModifyModuleCapabilties(KCapabilityRoot,j);
+		r=p.Create(exefilenames, cmd);
+		test(r==KErrNone);
+		p.Terminate(0);
+		p.Close();
+
+
+		substed=_L("O:\\EXETS");
+		substed.AppendNum(j);
+		substed+=KExeExt;
+		RDebug::Print(_L("substed=%S"),&substed);
+		r=p.Create(substed, cmd);
+		test(r==KErrNone);
+		p.Terminate(0);
+		p.Close();
+		}
+	delete fileMan;
+	}
+*/
+#endif
+
+
+
+void HashBM()
+//
+//	time how long to load a small dll 100 times and one large one
+//
+	{
+	test.Next(_L("Next Do Bench Mark\n"));
+	TBuf<30> dlldestination;
+	dlldestination=KNewDllName;
+	dlldestination[0]='D';
+	dlldestination.AppendNum(1);
+	dlldestination+=KDllExt;
+	RLibrary lib;
+	TInt r=0;
+	TUint32 startcount = User::NTickCount();
+	for (TInt i=0;i<100;i++)
+		{
+		r=lib.Load(dlldestination);
+		lib.Close();
+		}
+	TUint32 endcount = User::NTickCount();
+	test(r==KErrNone);
+	RDebug::Print(_L("100 * 4k dll \n"));
+	RDebug::Print(_L("start count=%d, end count=%d, dif=%d\n"),startcount,endcount,endcount-startcount);
+
+	startcount = User::NTickCount();
+	r=lib.Load(_L("D:\\sys\\bin\\euser.dll"));
+	lib.Close();
+	endcount = User::NTickCount();
+	RDebug::Print(_L("r=%d")); 
+//	test(r==KErrNone);
+	RDebug::Print(_L("1 * 233k dll \n"));
+	RDebug::Print(_L("start count=%d, end count=%d, dif=%d\n"),startcount,endcount,endcount-startcount);
+	}
+
+//-------------------------------------------------------
+
+/**
+    testing RLoader::CheckLibraryHash() API
+*/
+void  TestCheckLibraryHash()
+{
+    test.Next(_L("Testing CheckLibraryHash API\n"));
+
+	TInt r=0;
+	CFileMan* pFileMan=NULL;
+	TRAP(r,pFileMan=CFileMan::NewL(TheFs));
+	test(r==KErrNone);
+
+    RLoader loader;
+	r=loader.Connect();
+	test(r==KErrNone);
+    
+    //-- 1. copy test DLL to the specified drive and create hash file for it.
+	TBuf<40> dllFileName;
+	TBuf<40> dllDestination;
+	
+	const TInt KDllNumber = 0;
+
+    dllFileName=KDllfilename;
+	dllFileName.AppendNum(KDllNumber);
+	dllFileName+=KDllExt;
+	
+	dllDestination=KNewDllName;
+	dllDestination[0]=(TUint16)gDriveToTest;
+	dllDestination.AppendNum(KDllNumber);
+	dllDestination+=KDllExt;
+
+    test.Printf(_L("Copy %S to %S\n"), &dllFileName, &dllDestination);
+
+	r=TheFs.MkDirAll(dllDestination);
+	test(r==KErrNone || r==KErrAlreadyExists);
+
+	r=pFileMan->Copy(dllFileName, dllDestination);
+	test(r==KErrNone || r==KErrAlreadyExists);
+
+	r=pFileMan->Attribs(dllDestination, 0, KEntryAttReadOnly, TTime(0) ,0);
+	test(r==KErrNone);
+
+    test.Printf(_L("Creating Dll hash.\n"));
+    CreateFileHash(dllDestination);
+
+    //-- 2. check if the hash exists
+    r=loader.CheckLibraryHash(dllDestination);
+    test(r==KErrNone);
+    test.Printf(_L("Dll hash exists.\n"));
+
+    //-- 2.1 check if the hash exists and valid
+    r=loader.CheckLibraryHash(dllDestination, ETrue);
+    test(r==KErrNone);
+    
+    test.Printf(_L("Dll hash exists and valid.\n"));
+
+    //-- 3. corrupt dll
+    r = CorruptFile(dllDestination);
+    test(r==KErrNone);
+
+    //-- 3.1 check that the hash exists, but is incorrect.
+    r=loader.CheckLibraryHash(dllDestination);
+    test(r==KErrNone);
+    test.Printf(_L("Dll hash exists.\n"));
+
+    r=loader.CheckLibraryHash(dllDestination, ETrue);
+    test(r==KErrCorrupt);
+    
+    test.Printf(_L("Dll hash exists and INVALID.\n"));
+
+    //-- 4. try to locte hash fo the unexisting dll.
+    r=loader.CheckLibraryHash(_L("Z:\\sys\\bin\\NotExist.dll"));
+    test(r==KErrNotFound);
+
+    loader.Close();
+
+    delete pFileMan;
+}
+
+//-------------------------------------------------------
+
+void ParseCommandArguments()
+//
+//
+//
+	{
+	TBuf<0x100> cmd;
+	User::CommandLine(cmd);
+	TLex lex(cmd);
+	TPtrC token=lex.NextToken();
+	TFileName thisfile=RProcess().FileName();
+	if (token.MatchF(thisfile)==0)
+		{
+		token.Set(lex.NextToken());
+		}
+	test.Printf(_L("CLP=%S"),&token);
+
+	if(token.Length()!=0)		
+		{
+		gDriveToTest=token[0];
+		gDriveToTest.UpperCase();
+		}
+	else						
+		gDriveToTest='D';	//default to D:
+	}
+
+
+//-------------------------------------------------------
+
+void TestExes()
+{
+    test.Next(_L("Testing Exes presence.\n"));
+	
+    TInt r;
+
+    RProcess ap;
+	r=LoadExe(14,ap);
+	test(r==KErrNone);
+	ap.Terminate(0);
+	ap.Close();
+	
+    r=LoadExe(15,ap);
+	test(r==KErrNone);
+	ap.Terminate(0);
+	ap.Close();
+}
+
+
+//-------------------------------------------------------
+
+static void CallTestsL(void)
+{
+
+#ifdef __WINS__
+        test.Printf(_L("Not testing on WINS !\n"));
+        return;
+#else
+
+        TestExes();
+    //	TestGetCapability();
+	    CopyModules();				//copies modules from ROM to disk so they may be modified
+    //	TestLoading();
+    //	TestLoadLibrary();
+	
+
+#ifndef WIN32
+	    if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))
+		    TestRemovableMediaWithHash();
+
+    //	TestSystemBinSubsted();
+    //	TestRemovableMedia();
+	    TestNonSystemSubsted();
+#endif //WIN32
+    //	HashBM();
+
+        TestCheckLibraryHash();
+
+#endif //#ifndef __WINS__
+    
+}
+
+//-------------------------------------------------------
+//
+//	main
+//
+GLDEF_C TInt E32Main()
+	{
+	ParseCommandArguments(); //need this for drive letter to test
+
+	test.Title();
+	test.Start(_L("Setup\n"));
+	CTrapCleanup* cleanup;
+	cleanup=CTrapCleanup::New();
+	__UHEAP_MARK;
+
+	TBuf<20> sessPath;
+	TInt r=0;	
+	r=TheFs.Connect();
+	test(r==KErrNone);
+	r=TheFs.SessionPath(sessPath);
+	test(r==KErrNone);
+
+	TInt drive;
+	RFs::CharToDrive(gDriveToTest, drive);
+	TDriveInfo info;
+	r=TheFs.Drive(info, drive);
+	test(r==KErrNone);
+	
+    if((info.iDriveAtt & KDriveAttRemovable) == 0)
+	{
+        test.Printf(_L("Not testing on non-removable media !\n"));
+    }
+    else
+    {//-- testing on removable media
+        TRAP(r,CallTestsL());
+    }
+
+	TheFs.Close();
+	test.End();
+	test.Close();
+
+	__UHEAP_MARKEND;
+	delete cleanup;
+
+	return KErrNone;
+	}
+
+