// 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;