// 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()

//