// Copyright (c) 1995-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:

// f32\sfile\sf_ldr.cpp

// 

//

#include "sf_std.h"

#include <f32image.h>

#include "sf_image.h"

#include "sf_cache.h"

#include "sf_ldr.h"

#include <e32uid.h>

#include <hal.h>

#ifdef _DEBUG

#define IF_DEBUG(x)	x

TInt KernHeapFailCount=0;

TInt LdrHeapFailCount=0;

TInt HeapFailActive=0;

void SetupHeapFail(const RMessage2& aMsg);

void EndHeapFailCheck(TInt);

TInt RFsFailCount=0;

TInt RFsErrorCode=0;

TBool RFsFailActive=0;

void SetupRFsFail(const RMessage2& aMsg);

void EndRFsFailCheck(TInt);

TRequestStatus ProcessDestructStat;

TRequestStatus* ProcessDestructStatPtr=0;

TBool ProcessCreated=EFalse;

#else

#define IF_DEBUG(x)

#endif

TInt DoLoaderDebugFunction(const RMessage2& aMsg);

//#define __TRACE_LOADER_HEAP__

class RLoaderFs : public RFs

	{

public:

	inline TInt SendReceive(TInt aFunction, const TIpcArgs& aArgs) const

		{ return RSessionBase::SendReceive(aFunction, aArgs); }

	};

static TInt CheckLibraryHash(RLdrReq& aReq);

const TInt KPriorityVeryHigh=14641;

GLDEF_D RFs gTheLoaderFs;

GLDEF_D TAny* gExeCodeSeg;

GLDEF_D TUint32 gExeAttr;

GLDEF_D TAny* gKernelCodeSeg;

GLDEF_D TUint32 gKernelAttr;

GLDEF_D SSecurityInfo gKernelSecInfo;

GLDEF_D TBool gExecutesInSupervisorMode;

GLDEF_D TAny* gFileServerCodeSeg;

GLDEF_D TUint32 gFileServerAttr;

GLDEF_D SSecurityInfo gFileServerSecInfo;

GLDEF_D CActiveReaper* gActiveReaper=NULL;

CSlottedChunkAllocator gFileDataAllocator;

GLREF_D TCodePageUtils TheCodePage;

_LIT(KDriveSystemRoot, "?:\\");

_LIT(KLoaderThreadName, "LoaderThread");

_LIT8(KFileExtensionExe,".EXE");

_LIT8(KFileExtensionDll,".DLL");

_LIT8(KFileExtensionLdd,".LDD");

_LIT8(KFileExtensionPdd,".PDD");

_LIT8(KFileExtensionFsy,".FSY");

_LIT8(KFileExtensionFxt,".FXT");

_LIT8(KFileExtensionPxt,".PXT");

_LIT8(KFileExtensionPxy,".PXY");

_LIT(KPathDel,"?:\\sys\\del\\");

const TInt KPathDelLength = 11; 

const TInt KExtensionLength=4;

#if defined(__EPOC32__) && defined(__X86__)

TInt UseFloppy;

#endif

/******************************************************************************

 * Loader top level stuff

 ******************************************************************************/

TUint32 GetCodeSegAttr(TAny* aCodeSeg, SSecurityInfo* aS, TUint32* aVer)

	{

	TCodeSegCreateInfo info;

	E32Loader::CodeSegInfo(aCodeSeg, info);

	if (aS)

		*aS = info.iS;

	if (aVer)

		*aVer = info.iModuleVersion;

	return info.iAttr;

	}

#ifdef __EPOC32__

extern void InitExecuteInSupervisorMode();

#endif

_LIT(KNullThreadName,"EKern*Null");

void GetKernelInfo()

	{

	TFindThread ft(KNullThreadName);

	TFullName fn;

	TInt r = ft.Next(fn);

	if (r==KErrNone)

		{

		RThread null;

		r = null.Open(ft);

		if (r==KErrNone)

			{

			gKernelCodeSeg = E32Loader::ThreadProcessCodeSeg(null.Handle());

			if (gKernelCodeSeg)

				{

				gKernelAttr = GetCodeSegAttr(gKernelCodeSeg, &gKernelSecInfo, NULL);

				__IF_DEBUG(Printf("gKernelCodeSeg=%08x", gKernelCodeSeg));

				__IF_DEBUG(Printf("gKernelAttr=%08x", gKernelAttr));

				}

			else

				r=KErrGeneral;

			null.Close();

			}

		}

	if (r==KErrNone)

		{

		gFileServerCodeSeg = E32Loader::ThreadProcessCodeSeg(KCurrentThreadHandle);

		if (gFileServerCodeSeg)

			{

			gFileServerAttr = GetCodeSegAttr(gFileServerCodeSeg, &gFileServerSecInfo, NULL);

			__IF_DEBUG(Printf("gFileServerCodeSeg=%08x", gFileServerCodeSeg));

			__IF_DEBUG(Printf("gFileServerAttr=%08x", gFileServerAttr));

			}

		else

			r=KErrGeneral;

		}

#ifdef __EPOC32__

	InitExecuteInSupervisorMode();

#else

	// When running on the emulator the loader can access all memory so effectively it is

	// running in supervisor mode.

	gExecutesInSupervisorMode = ETrue;

#endif

	__ASSERT_ALWAYS(r==KErrNone, Fault(ELdrGetKernelInfoFailed));

	}

#ifdef __TRACE_LOADER_HEAP__

void InstallHeapTracer();

#endif

#ifdef __LAZY_DLL_UNLOAD

const TInt KLoaderLazyDllDurationDefault=120;      // 120 seconds default

TInt KLoaderLazyDllDuration=KLoaderLazyDllDurationDefault;

CLazyUnloadTimer* LazyUnloadTimer=NULL;

void CLazyUnloadTimer::New()

//

// Create a new CLazyUnloadTimer.

//

	{

	CLazyUnloadTimer* lazyUnloadTimer=new CLazyUnloadTimer;

	if(lazyUnloadTimer)

		{

		TRAPD(err,lazyUnloadTimer->ConstructL());

		if(err==KErrNone)

			{

			lazyUnloadTimer->Start();

			}

		else

			{

			delete lazyUnloadTimer;

			}

		}

	}

CLazyUnloadTimer::CLazyUnloadTimer()

//

// Constructor

//

	: CTimer(EPriorityIdle)

	{

	Finish();

	LazyUnloadTimer = this;

	if (KLoaderLazyDllDuration < 0) 

		KLoaderLazyDllDuration = KLoaderLazyDllDurationDefault;

	}

CLazyUnloadTimer::~CLazyUnloadTimer()

	{

	LazyUnloadTimer = NULL;

	}

void CLazyUnloadTimer::Start()

	{

	E32Loader::CodeSegDeferDeletes();

	CActiveScheduler::Add(this);

	TTimeIntervalMicroSeconds32 timeout=KLoaderLazyDllDuration*1000000;

	After(timeout);

	}

void CLazyUnloadTimer::RunL()

//

// The timer has completed.

//

	{

	E32Loader::CodeSegEndDeferDeletes();

	delete this;

	}

void CLazyUnloadTimer::Finish()

	{

	if(LazyUnloadTimer)

		{

		LazyUnloadTimer->Cancel();

		LazyUnloadTimer->RunL();

		}

	}

#endif

/* ReaperCleanupTimer - Used to clear /sys/del/ shortly after boot. */

const TInt KLoaderReaperCleanupTimeDefault=60;      // 60 seconds default

TInt KLoaderReaperCleanupTime=KLoaderReaperCleanupTimeDefault;

CReaperCleanupTimer* CReaperCleanupTimer::Timer=NULL;

TInt CReaperCleanupTimer::New()

//

// Create a new CReaperCleanupTimer.

//

	{

	if (Timer)

		return KErrInUse;

	CReaperCleanupTimer* timer=new CReaperCleanupTimer;

	if(timer)

		{

		TRAPD(err,Timer->ConstructL());

		if(err==KErrNone)

			{

			Timer->Start();

			return KErrNone;

			}

		else

			{

			delete Timer;

			return err;

			}

		}

	return KErrNoMemory;

	}

CReaperCleanupTimer::CReaperCleanupTimer()

	: CTimer(EPriorityIdle)

	{

	Timer=this;

	}

CReaperCleanupTimer::~CReaperCleanupTimer()

	{

	Timer = NULL;

	}

void CReaperCleanupTimer::Start()

	{

	CActiveScheduler::Add(this);

	TTimeIntervalMicroSeconds32 timeout=KLoaderReaperCleanupTime*1000000;

	After(timeout);

	}

void CReaperCleanupTimer::RunL()

	{

	if (gActiveReaper)

		gActiveReaper->InitDelDir();

	delete this;

	}

void CReaperCleanupTimer::Complete()

	{

	if(Timer)

		{

		Timer->Cancel();

		Timer->RunL();

		}

	}	

GLDEF_C TInt LoaderThread(TAny*)

//

// The loader thread.

//

	{

#ifdef __TRACE_LOADER_HEAP__

	InstallHeapTracer();

#endif

	TInt r;

    __IF_DEBUG(Printf("LoaderThread"));

	User::SetCritical(User::ESystemCritical);

	GetKernelInfo();

	CServerLoader* serverLoader;

	CActiveSchedulerLoader* scheduler;

	CTrapCleanup* cleanup=CTrapCleanup::New();

	__ASSERT_ALWAYS(cleanup!=NULL, Fault(ELdrCleanupCreate));

	scheduler=CActiveSchedulerLoader::New();

	__ASSERT_ALWAYS(scheduler!=NULL, Fault(ELdrSchedulerCreate));

	serverLoader=CServerLoader::New();

	__ASSERT_ALWAYS(serverLoader!=NULL, Fault(ELdrServerCreate));

	RThread::Rendezvous(KErrNone);

	r=gTheLoaderFs.Connect();

	__ASSERT_ALWAYS(r==KErrNone, Fault(ELdrFsConnect));

	TBuf<sizeof(KDriveSystemRoot)> driveSystemRoot(KDriveSystemRoot);

	driveSystemRoot[0] = (TUint8) RFs::GetSystemDriveChar();

	r=gTheLoaderFs.SetSessionPath(driveSystemRoot);

	__ASSERT_ALWAYS(r==KErrNone, Fault(ELdrFsSetPath));

#ifdef __EPOC32__

	InitializeFileNameCache();

	r=gFileDataAllocator.Construct();

	__ASSERT_ALWAYS(r==KErrNone, Fault(ELdrFileDataAllocInit));

#endif

#ifdef __LAZY_DLL_UNLOAD

	CLazyUnloadTimer::New();

#endif

	gActiveReaper = CActiveReaper::New();

	__ASSERT_ALWAYS(gActiveReaper!=NULL, Fault(ELdrReaperCreate));

	r=CReaperCleanupTimer::New();

	__ASSERT_ALWAYS(r==KErrNone, Fault(ELdrReaperCleanupTimerCreate));

	CActiveSchedulerLoader::Start();

	Fault(ELdrSchedulerStopped);

	return 0;

	}

TInt InitLoader()

	{

	TRequestStatus lts;

	RThread loaderThread; 

	RHeap* h = (RHeap*)&User::Allocator();

	TInt maxsize = h->MaxLength();	// loader heap max size = file server heap max size

	TInt r=loaderThread.Create(KLoaderThreadName,LoaderThread,KLoaderStackSize,KHeapMinSize,maxsize,NULL);

	if (r!=KErrNone)

		{

		return r;

		}

	loaderThread.Rendezvous(lts);

	loaderThread.Resume();

	User::WaitForRequest(lts);

	loaderThread.Close();

	return lts.Int();

	}

TInt CompareVersions(TUint32 aL, TUint32 aR)

	{

	if (aL>aR)

		return 1;

	if (aL<aR)

		return -1;

	return 0;

	}

TInt DetailedCompareVersions(TUint32 aCandidate, TUint32 aRequest)

	{

	if (aRequest == KModuleVersionNull)

		return EVersion_MinorBigger;

	if (aCandidate == KModuleVersionNull)

		return EVersion_MajorSmaller;

	TUint32 C = aCandidate >> 16;

	TUint32 c = aCandidate & 0x0000ffffu;

	TUint32 R = aRequest >> 16;

	TUint32 r = aRequest & 0x0000ffffu;

	if (C==R)

		{

		if (c>r)

			return EVersion_MinorBigger;

		if (c==r)

			return EVersion_Exact;

		return EVersion_MinorSmaller;

		}

	if (C>R)

		return EVersion_MajorBigger;

	return EVersion_MajorSmaller;

	}

TInt DetailedCompareVersions(TUint32 aCandidate, TUint32 aRequest, TUint32 aCurrent, TBool aStrict)

	{

	TInt cvc = DetailedCompareVersions(aCandidate, aCurrent);

	if (aRequest == KModuleVersionWild)

		{

		return (cvc == EVersion_MinorBigger || cvc == EVersion_MajorBigger) ? EAction_Replace : EAction_Skip;

		}

	TInt candidate_state = DetailedCompareVersions(aCandidate, aRequest);

	if (aStrict)

		{

		if (candidate_state > EVersion_Exact)

			return EAction_Skip;	// no match

		if (cvc == EVersion_MinorBigger)

			return EAction_Replace;	// later minor version so take it

		return EAction_Skip;	// same or earlier minor version

		}

	TInt current_state = DetailedCompareVersions(aCurrent, aRequest);

	if (candidate_state < current_state)

		{

		// better match

		if (candidate_state <= EVersion_Exact)

			return EAction_Replace;

		return (candidate_state == EVersion_MajorBigger) ? EAction_CheckImports : EAction_CheckLastImport;

		}

	if (candidate_state > current_state)

		return EAction_Skip;	// worse match

	// match state same

	// skip if		(i) state=exact

	//				(ii) state=major smaller

	// replace if	(i) state=minor bigger and candidate minor > current minor

	//				(ii) state=minor smaller and candidate minor > current minor

	//				(iii) state=major bigger, candidate major=current major and candidate minor > current minor

	// check if		(i) state=major bigger and candidate major < current major

	switch (candidate_state)

		{

		case EVersion_MinorBigger:

		case EVersion_MinorSmaller:

			return (cvc == EVersion_MinorBigger) ? EAction_Replace : EAction_Skip;

		case EVersion_MajorBigger:

			if (cvc == EVersion_MinorBigger)

				return EAction_Replace;

			return (cvc == EVersion_MajorSmaller) ? EAction_CheckImports : EAction_Skip;

		default:

			return EAction_Skip;

		}

	}

TFileNameInfo::TFileNameInfo()

	{

	memclr(this, sizeof(TFileNameInfo));

	}

TInt TFileNameInfo::Set(const TDesC8& aFileName, TUint aFlags)

	{

	__IF_DEBUG(Printf(">TFileNameInfo::Set %S %08x", &aFileName, aFlags));

	iUid = 0;

	iVersion = 0;

	iPathPos = 0;

	iName = aFileName.Ptr();

	iLen = aFileName.Length();

	iExtPos = aFileName.LocateReverse('.');

	if (iExtPos<0)

		iExtPos = iLen;

	TInt osq = aFileName.LocateReverse('[');

	TInt csq = aFileName.LocateReverse(']');

	if (!(aFlags & EAllowUid) && (osq>=0 || csq>=0))

		{

		__IF_DEBUG(Printf("<TFileNameInfo::Set BadName1"));

		return KErrBadName;

		}

	if (osq>=iExtPos || csq>=iExtPos)

		{

		__IF_DEBUG(Printf("<TFileNameInfo::Set BadName2"));

		return KErrBadName;

		}

	TInt p = iExtPos;

	if ((aFlags & EAllowUid) && p>=10 && iName[p-1]==']' && iName[p-10]=='[')

		{

		TPtrC8 uidstr(iName + p - 9, 8);

		TLex8 uidlex(uidstr);

		TUint32 uid = 0;

		TInt r = uidlex.Val(uid, EHex);

		if (r==KErrNone && uidlex.Eos())

			iUid = uid, p -= 10;

		}

	iUidPos = p;

	TInt ob = aFileName.LocateReverse('{');

	TInt cb = aFileName.LocateReverse('}');

	if (ob>=iUidPos || cb>=iUidPos)

		{

		__IF_DEBUG(Printf("<TFileNameInfo::Set BadName3"));

		return KErrBadName;

		}

	if (ob>=0 && cb>=0 && p-1==cb)

		{

		TPtrC8 p8(iName, p);

		TInt d = p8.LocateReverse('.');

		TPtrC8 verstr(iName+ob+1, p-ob-2);

		TLex8 verlex(verstr);

		if (ob==p-10 && d<ob)

			{

			TUint32 ver = 0;

			TInt r = verlex.Val(ver, EHex);

			if (r==KErrNone && verlex.Eos())

				iVersion = ver, p = ob;

			}

		else if (d>ob && p-1>d && (aFlags & EAllowDecimalVersion))

			{

			TUint32 maj = 0;

			TUint32 min = 0;

			TInt r = verlex.Val(maj, EDecimal);

			TUint c = (TUint)verlex.Get();

			TInt r2 = verlex.Val(min, EDecimal);

			if (r==KErrNone && c=='.' && r2==KErrNone && verlex.Eos() && maj<32768 && min<32768)

				iVersion = (maj << 16) | min, p = ob;

			}

		}

	iVerPos = p;

	if (iLen>=2 && iName[1]==':')

		{

		TUint c = iName[0];

		if (c!='?' || !(aFlags & EAllowPlaceholder))

			{

			c |= 0x20;

			if (c<'a' || c>'z')

				{

				__IF_DEBUG(Printf("<TFileNameInfo::Set BadName4"));

				return KErrBadName;

				}

			}

		iPathPos = 2;

		}

	TPtrC8 pathp(iName+iPathPos, iVerPos-iPathPos);

	if (pathp.Locate('[')>=0 || pathp.Locate(']')>=0 || pathp.Locate('{')>=0 || pathp.Locate('}')>=0 || pathp.Locate(':')>=0)

		{

		__IF_DEBUG(Printf("<TFileNameInfo::Set BadName5"));

		return KErrBadName;

		}

	iBasePos = pathp.LocateReverse('\\') + 1 + iPathPos;

	__IF_DEBUG(Printf("<TFileNameInfo::Set OK"));

	__LDRTRACE(Dump());

	return KErrNone;

	}

void TFileNameInfo::GetName(TDes8& aName, TUint aFlags) const

	{

	if (aFlags & EIncludeDrive)

		aName.Append(Drive());

	if (aFlags & EIncludePath)

		{

		if (PathLen() && iName[iPathPos]!='\\')

			aName.Append('\\');

		aName.Append(Path());

		}

	if (aFlags & EIncludeBase)

		aName.Append(Base());

	if ((aFlags & EForceVer) || ((aFlags & EIncludeVer) && VerLen()) )

		{

		aName.Append('{');

		aName.AppendNumFixedWidth(iVersion, EHex, 8);

		aName.Append('}');		

		}

	if ((aFlags & EForceUid) || ((aFlags & EIncludeUid) && UidLen()) )

		{

		aName.Append('[');

		aName.AppendNumFixedWidth(iUid, EHex, 8);

		aName.Append(']');

		}

	if (aFlags & EIncludeExt)

		aName.Append(Ext());

	}

TInt OpenFile8(RFile& aFile, const TDesC8& aName)

	{

	TFileName fn;

	fn.Copy(aName);

	TInt r = aFile.Open(gTheLoaderFs, fn, EFileStream|EFileRead|EFileShareReadersOnly|EFileReadDirectIO);

	return r;

	}

RLdrReq::RLdrReq()

	{

	memclr(&iFileName, sizeof(RLdrReq) - sizeof(TLdrInfo));

	}

void RLdrReq::Close()

	{

	delete iFileName;

	delete iCmd;

	delete iPath;

	iClientThread.Close();

	iClientProcess.Close();

	}

void RLdrReq::Panic(TInt aPanic)

	{

	iMsg->Panic(KLitLoader,aPanic);

	}

TInt CheckedCollapse(TDes8& aDest, const TDesC16& aSrc)

	{

	TInt rl = aSrc.Length();

	aDest.SetLength(rl);

	TText8* d = (TText8*)aDest.Ptr();

	const TText16* s = aSrc.Ptr();

	const TText16* sE = s + rl;

	while (s<sE && *s>=0x20u && *s<0x7fu)

		*d++ = (TText8)*s++;

	return (s<sE) ? KErrBadName : KErrNone;

	}

TInt RLoaderMsg::GetString(HBufC8*& aBuf, TInt aParam, TInt aMaxLen, TInt aHeadroom, TBool aReduce) const

	{

	aBuf=NULL;

	TInt l=GetDesLength(aParam);

	if (l<0)

		return l;

	if (l>aMaxLen)

		return KErrOverflow;

	aBuf=HBufC8::New((l+aHeadroom)*sizeof(TText));

	if (!aBuf)

		return KErrNoMemory;

	TPtr8 bp8(aBuf->Des());

	TPtr16 bp16((TText*)bp8.Ptr(), 0, bp8.MaxLength()/sizeof(TText));

	TInt r = Read(aParam, bp16);

	if (r == KErrNone)

		{

		TInt rl = bp16.Length();

		if (aReduce)

			r = CheckedCollapse(bp8, bp16);

		else

			bp8.SetLength(rl*sizeof(TText));

		}

	if (r!=KErrNone)

		{

		delete aBuf;

		aBuf=NULL;

		}

	return r;

	}

TInt RLoaderMsg::GetLdrInfo(TLdrInfo& aInfo) const

	{

	TPckg<TLdrInfo> infoPckg(aInfo);

	return Read(0, infoPckg);

	}

TInt RLoaderMsg::UpdateLdrInfo(const TLdrInfo& aInfo) const

	{

	TPckgC<TLdrInfo> infoPckg(aInfo);

	return Write(0, infoPckg);

	}

TInt RLdrReq::AddFileExtension(const TDesC8& aExt)

	{

	if (iFileName->LocateReverse('.')==KErrNotFound)

		{

		if (iFileName->Length()+aExt.Length()>KMaxFileName)

			return KErrBadName;

		iFileName->Des().Append(aExt);

		}

	TInt r = iFileNameInfo.Set(*iFileName, TFileNameInfo::EAllowDecimalVersion);

	if (r == KErrNone)

		{

		TInt l = iFileNameInfo.BaseLen() + iFileNameInfo.ExtLen();

		if (l > KMaxProcessName)

			r = KErrBadName;

		}

	return r;

	}

TInt CheckSubstDrive(TDes8& aDest, const TDesC8& aSrc, TBool aIsPathOnly)

	{

	TInt r = KErrNone;

	TInt l = aSrc.Length();

	TInt mdl = aDest.MaxLength();

	TInt pathStart = 0;

	if (l>=3 && aSrc[1]==':')

		{

		// drive letter specified...

		pathStart = 2;

		TInt drive;

		TDriveInfo dI;

		r = RFs::CharToDrive((TChar)aSrc[0], drive);

		if (r!=KErrNone)

			{

			return r;

			}

		r = gTheLoaderFs.Drive(dI, drive);

		if (r!=KErrNone)

			{

			return r;

			}

		if (dI.iDriveAtt & KDriveAttSubsted)

			{

			TPtr16 ptr16(aDest.Expand());

			r = gTheLoaderFs.Subst(ptr16, drive);

			if (r!=KErrNone)

				{

				return r;

				}

			aDest.SetLength(ptr16.Length()*sizeof(TText));

			aDest.Collapse();

			TInt srcm = (aSrc[2]=='\\') ? 3 : 2;

			TPtrC8 rest(aSrc.Mid(srcm));

			if (rest.Length() + aDest.Length() > mdl)

				return KErrBadName;

			aDest.Append(rest);

			r=1;

			}

		}

	if(!PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))

		return r;

	// make sure path starts with "\sys\bin\"...

	// get filename/path...

	TPtrC8 ptr;

	if(!r)

		ptr.Set(aSrc);

	else

		ptr.Set(aDest);

	// set pathStart to first character of path (after any initial '\')

	if(ptr.Length() && ptr[pathStart]=='\\')

		++pathStart; // drop initial '\'

	// set pathEnd to first character after path (the final '\' if present)

	TInt pathEnd;

	if(aIsPathOnly)

		{

		pathEnd = ptr.Length();

		if(pathEnd && ptr[pathEnd-1]==';')

			--pathEnd; // drop trailing ';'

		if(pathEnd && ptr[pathEnd-1]=='\\')

			--pathEnd; // drop trailing '\'

		}

	else

		{

		pathEnd = ptr.LocateReverse('\\');

		if(pathEnd<0)

			return r;	// no path, so end

		}

	// check if path starts with "sys\bin"...

	const TUint8* fn = ptr.Ptr();

	_LIT8(KSysBin,"sys\\bin");

	const TInt KSysBinLength = 7;

	if(pathStart+KSysBinLength <= pathEnd)

		if(KSysBin().CompareF(TPtrC8(fn+pathStart,KSysBinLength))==0)

			return r;	// path already starts with "sys\bin", so end

	// replace path with "sys\bin"...

	TBuf8<KMaxFileName*sizeof(TText)> temp;

	temp.Append(TPtrC8(fn,pathStart));		// add bits before path

	temp.Append(KSysBin);					// add "sys\bin"

	TInt rootLen = ptr.Length()-pathEnd;

	if(temp.Length()+rootLen>temp.MaxLength())

		return KErrBadName;	// would overflow

	temp.Append(TPtrC8(fn+pathEnd,rootLen));	// add bits after path

	// return modified string...

	aDest = temp;

	return 1;

	}

TInt RLdrReq::CheckForSubstDriveInName()

	{

	TBuf8<KMaxFileName*sizeof(TText)> temp;

	TInt r = CheckSubstDrive(temp, *iFileName, EFalse);

	if (r<0)

		{

		return r;

		}

	if (r>0)

		{

		TInt l=temp.Length();

		HBufC8* p = HBufC8::New(l+KExtensionLength);

		if (!p)

			return KErrNoMemory;

		TPtr8 bp8(p->Des());

		bp8 = temp;		

		delete iFileName;

		iFileName = p;

		r = KErrNone;

		}

	return r;

	}

TInt RLdrReq::CheckForSubstDrivesInPath()

	{

	if (!iPath)

		return KErrNone;

	TBuf8<(KMaxFileName+1)*sizeof(TText)> temp;

	TInt ppos = 0;

	TInt plen = iPath->Length();

	HBufC8* newpath = NULL;

	while (ppos < plen)

		{

		TPtrC8 rmn(iPath->Mid(ppos));

		TInt term = rmn.Locate(';');

		TInt pel = (term<0) ? rmn.Length() : term+1;

		TPtrC8 path_element(iPath->Mid(ppos, pel));

		ppos += pel;

		temp.Zero();

		TInt r = CheckSubstDrive(temp, path_element, ETrue);

		if (r<0)

			{

			delete newpath;

			return r;

			}

		else if (r>0 || newpath)

			{

			if(!newpath)

				{

				// initialise 'newpath' to contain everything in path before the element just processed...

				newpath = iPath->Left(ppos-pel).Alloc();

				if(!newpath)

					return KErrNoMemory;

				}

			// grow 'newpath'...

			TInt xl = (r>0) ? temp.Length() : pel;

			HBufC8* np = newpath->ReAlloc(newpath->Length() + xl);

			if(!np)

				{

				delete newpath;

				return KErrNoMemory;

				}

			newpath = np;

			// append modified path element to the 'newpath'...

			newpath->Des().Append( (r>0) ? (const TDesC8&)temp : (const TDesC8&)path_element);

			}

		}

	if(newpath)

		{

		delete iPath;

		iPath = newpath;

		}

	return KErrNone;

	}

#ifdef __VC32__

#pragma warning( disable : 4701 )   // disable warning C4701: local variable 'missingCaps' may be used without having been initialized

#endif

TInt RLdrReq::CheckSecInfo(const SSecurityInfo& aCandidate) const

//

//	Check that the security info of a candidate loadee is sufficient

//

	{

	if (iSecureId && iSecureId != aCandidate.iSecureId)

		return KErrPermissionDenied;

	SCapabilitySet missingCaps;

	TUint32 checkFail = 0;

	for (TInt i=0; i<SCapabilitySet::ENCapW; ++i)

		{

		TUint32 missing = iPlatSecCaps[i] & ~aCandidate.iCaps[i];

		missingCaps[i] = missing;

		checkFail |= missing;

		}

	if(!checkFail)

		return KErrNone;

	// Failed check...

	if(iImporter)

		{

#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__

		return PlatSec::LoaderCapabilityViolation(iImporter->iFileName,*iFileName,missingCaps);

#else //__REMOVE_PLATSEC_DIAGNOSTICS__

		return PlatSec::EmitDiagnostic();

#endif //!__REMOVE_PLATSEC_DIAGNOSTICS__

		}

#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__

	return PlatSec::LoaderCapabilityViolation(iClientProcess,*iFileName,missingCaps);

#else //__REMOVE_PLATSEC_DIAGNOSTICS__

	return PlatSec::EmitDiagnostic();

#endif //!__REMOVE_PLATSEC_DIAGNOSTICS__

	}

#ifdef __VC32__

#pragma warning( default : 4701 )   // enable warning C4701: local variable 'missingCaps' may be used without having been initialized

#endif

void CSessionLoader::ServiceL(const RMessage2& aMessage)

//

// Handle messages for this server.

//

	{

	const RLoaderMsg& msg = (const RLoaderMsg&)aMessage;

	TLoaderMsg mid=(TLoaderMsg)msg.Function();

	__IF_DEBUG(Printf("Loader: RX msg %d", mid));

	if (mid<1 || mid>=EMaxLoaderMsg)

		{

		aMessage.Complete(KErrNotSupported);

		return;

		}

#ifdef __EPOC32__

#ifdef __X86__

	UseFloppy = -1;

#endif

	TInt r=CheckLoaderCacheInit();

	if (r!=KErrNone)

		{

		aMessage.Complete(r);

		return;

		}

#else

	TInt r = KErrNone;

#endif

#ifdef _DEBUG

	if(mid==ELoaderDebugFunction)

		{

		msg.Complete(DoLoaderDebugFunction(msg));

		return;

		}

#endif

	if(mid==ELoaderCancelLazyDllUnload)

		{

#ifdef __LAZY_DLL_UNLOAD

		CLazyUnloadTimer::Finish();

#endif

		msg.Complete(KErrNone);

		return;

		}

#ifdef _DEBUG

	gTheLoaderFs.ResourceCountMarkStart();

#endif

	if(mid==EGetInfoFromHeader)

		{

		r=GetInfoFromHeader(msg);

#ifdef _DEBUG

		gTheLoaderFs.ResourceCountMarkEnd();

#endif

		msg.Complete(r);

		return;

		}

	if (mid == ELdrDelete)

		{

		// TCB and AllFiles are sufficient to ensure that write

		// access to any part of the file system without having to

		// check substitutions and access rights here.

		if (! aMessage.HasCapability(ECapabilityTCB, ECapabilityAllFiles, __PLATSEC_DIAGNOSTIC_STRING("ELdrDelete,TCB+AllFiles")))

			{

			r = KErrPermissionDenied;

			}

		// because this function is a general-purpose replacement for RFs::Delete,

		// it doesn't use the transformed filename which would be put into ldrReq.iFileName,

		// but the literal filename which was supplied, provided it is absolute.

		else

			{

			TInt filenameLength = msg.GetDesLength(1);			

			if(filenameLength<0)

				r = filenameLength;

			else 

				{

				HBufC* fnSupply = HBufC::New(filenameLength);

				if(!fnSupply)

					r = KErrNoMemory;

				else

					{

					TPtr buf = fnSupply->Des();

					if ((r=msg.Read( 1, buf)) == KErrNone)

						{		

						_LIT(KAbsolutePathPattern,"?:\\*");

						if (fnSupply->MatchF(KAbsolutePathPattern) != 0)

							r = KErrBadName;

						else

							{

							_LIT(KSysBin,"?:\\sys\\bin\\*");

							if (fnSupply->MatchF(KSysBin) == 0)

								r = DeleteExecutable(*fnSupply);

							else

								r = gTheLoaderFs.Delete(*fnSupply);

							}	

						}

					delete fnSupply;

					}

				}

			} // endif !aMessage.HasCapability