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

// e32\memmodel\emul\win32\mcodeseg.cpp

// 

//

#define __INCLUDE_ALL_SUPPORTED_CAPABILITIES__

#include "memmodel.h"

#include <property.h>

#include <emulator.h>

#include <wchar.h>

#define __CHECKHEAP()	((RHeapK*)K::Allocator)->Check()

static TBool BootComplete;	// flag set when boot EXE is loaded as an EPOC process

static DWin32CodeSeg* KernelCodeSeg;

static HMODULE KernelModuleHandle;

GLREF_C TInt CompareCodeSegsByName(const DCodeSeg& aA, const DCodeSeg& aB);

void TruncToNarrow(TUint8* aDes, const TUint16* aSrc, int aLen)

	{

	//converts to narrow by dumping the high order byte

	if(aDes && aSrc)

		{

		if(aLen==-1)

			{

			for(int index=0;*aSrc;index++)

				*aDes++ = (TUint8)*aSrc++;

			*aDes = '\0';

			}

		else

			for(int index=0;index<aLen;index++)

				*aDes++ = (TUint8)*aSrc++;

		}

	}

void ExpandToWide(TUint16* aDes, const TUint8* aSrc, int aLen)

	{

	if(aDes && aSrc)

		{

		for(int index=0;index<aLen;index++)

			*aDes++ = (TUint16)*aSrc++;

		}

	}

#ifdef KDLL

void DumpWin32CodeSeg(DWin32CodeSeg& a)

	{

	const TUint32* uid=(const TUint32*)&a.iUids;

	Kern::Printf("DWin32CodeSeg@%08x:",&a);

	Kern::Printf("iLink = %08x %08x", a.iLink.iNext, a.iLink.iPrev);

	Kern::Printf("iTempLink = %08x %08x", a.iTempLink.iNext, a.iTempLink.iPrev);

	Kern::Printf("iGbgLink = %08x %08x", a.iGbgLink.iNext, a.iGbgLink.iPrev);

	Kern::Printf("iAccessCount = %d", a.iAccessCount);

	Kern::Printf("iEntryPtVeneer = %08x", a.iEntryPtVeneer);

	Kern::Printf("iFileEntryPoint = %08x", a.iFileEntryPoint);

	Kern::Printf("iFileName = %lS", a.iFileName);

	Kern::Printf("iRootName = %lS", &a.iRootName);

	Kern::Printf("iExtOffset = %d", a.iExtOffset);

	Kern::Printf("iModuleVersion = %08x", a.iModuleVersion);

	Kern::Printf("iUids = %08x %08x %08x", uid[0], uid[1], uid[2]);

	Kern::Printf("iDepCount=%d iDeps=%08x", a.iDepCount, a.iDeps);

	Kern::Printf("iNextDep=%d, iMark=%08x, iAttr=%08x", a.iNextDep, a.iMark, a.iAttr);

	Kern::Printf("iExeCodeSeg=%08x, iAttachProcess=%O", a.iExeCodeSeg, a.iAttachProcess);

	Kern::Printf("iWinInstance = %08x", a.iWinInstance);

	Kern::Printf("iModuleHandle = %08x", a.iModuleHandle);

	Kern::Printf("iModuleFile = %08x", a.iModuleFile);

	Kern::Printf("iAlwaysLoaded = %08x", a.iAlwaysLoaded);

	Kern::Printf("iModuleList = %08x", a.iModuleList);

	}

#endif

void ExecInEntryPoint()

	{

	// This function will be called if an Exec:: call is attempted in the entry

	// point of a DLL which didn't specify 'epocallowdlldata'

	Kern::Fault("BAD DLL STATIC",0);

	}

static const SFastExecTable DummyFastExecTable={0,{0}};

static const SSlowExecTable DummySlowExecTable={0,(TLinAddr)ExecInEntryPoint,0,{{0,0}}};

// Force a call to a DLL entry point to initialise any gratuitous writeable data

// generated by the compiler.

// Change exec table to prevent any executive calls in case someone forgot to

// use the 'epocallowdlldata' option.

void ForceEntryPointCall(TLinAddr aEntryPoint)

	{

	__KTRACE_OPT(KDLL,Kern::Printf("ForceEntryPoint %08x", aEntryPoint));

	NKern::Lock();

	NThread* nthrd = NKern::CurrentThread();

	const SFastExecTable* fast = nthrd->iFastExecTable;

	const SSlowExecEntry* slow = nthrd->iSlowExecTable;

	nthrd->iFastExecTable = (SFastExecTable*)&DummyFastExecTable;

	nthrd->iSlowExecTable = DummySlowExecTable.iEntries;

	TLibraryEntry ep = (TLibraryEntry)aEntryPoint;

	(*ep)(KModuleEntryReasonProcessAttach);

	nthrd->iFastExecTable = fast;

	nthrd->iSlowExecTable = slow;

	NKern::Unlock();

	}

class TWin32Filename

	{

public:

	inline TWin32Filename()

		{iBuf[0] = '\0';}

	inline TWin32Filename(const TDesC& aFilename)

		{Set(aFilename);}

	inline TWin32Filename& operator=(const TDesC& aFilename)

		{Set(aFilename);return *this;}

	inline operator LPCWSTR() const

		{return iBuf;}

private:

	void Set(const TDesC& aFilename);

private:

	WCHAR iBuf[KMaxFileName + 1];

	};

void TWin32Filename::Set(const TDesC& aFilename)

	{

	TUint16 fileName[KMaxFileName];

	ExpandToWide(fileName, aFilename.Ptr(), aFilename.Length());

	TPtr p((TUint8*)iBuf,KMaxFileName<<1);

	Property::MapFilename(p, TPtrC((TUint8*)fileName,aFilename.Length()<<1));

	iBuf[p.Length()>>1] = '\0';

	}

class DModuleList : public DBase

	{

public:

	enum TFlags

		{

		EFlagData=0x01,

		EFlagDataPresent=0x02,

		EFlagAlreadyLoaded=0x04,

		EFlagMark=0x08,

		EFlagExe=0x10,

		EFlagAlwaysLoaded=0x20,

		EFlagExeInTree=0x40,

		};

	struct SModule

		{

		TLinAddr iModuleHandle;

		DWin32CodeSeg* iCodeSeg;

		TUint32 iFlags;

		SSecurityInfo iS;

		TUint32 iModuleVersion;

		TInt iDepCount;

		TInt* iDepList;

		};

public:

	DModuleList(DWin32CodeSeg* aMainSeg, DProcess* aProcess);

	virtual ~DModuleList();

	TInt Find(TInt aModule);

	TInt GatherDependencies(HMODULE aModule);

	TInt CompileDepLists();

	void SetFlags();

	TUint32 Flags(SModule* aM);

	TInt LoadDependencies();

	void LinkDependencies();

	TInt Loaded();

public:

	DWin32CodeSeg* iMain;

	DProcess* iAttachProcess;

	RArray<SModule> iModules;

	};

DModuleList::DModuleList(DWin32CodeSeg* aMainSeg, DProcess* aProcess)

	:	iMain(aMainSeg), iAttachProcess(aProcess),

		iModules(8, _FOFF(SModule,iModuleHandle), 2*256)

	{

	}

DModuleList::~DModuleList()

	{

	TInt c = iModules.Count();

	if (c)

		{

		SModule* pM = (SModule*)&iModules[0];

		SModule* pE = pM + c;

		for (; pM<pE; ++pM)

			{

			Kern::Free(pM->iDepList);

			}

		}

	iModules.Close();

	}

TInt DModuleList::Find(TInt aModule)

	{

	SModule mod;

	mod.iModuleHandle=(TLinAddr)aModule;

	return iModules.FindInUnsignedKeyOrder(mod);

	}

/**

Populate iModules with SModule entries corresponding to supplied HModule and all of its dependencies,

direct and indirect.  

@param aModule A Windows module handle

@return KErrNone if successful

*/

TInt DModuleList::GatherDependencies(HMODULE aModule)

	{

	__KTRACE_OPT(KDLL, Kern::Printf(">DModuleList::GatherDependencies %08x %08x %C", aModule, iMain, iMain));

	Emulator::TModule etm(aModule);

	SModule mod;

	mod.iModuleHandle=(TLinAddr)aModule;

	mod.iCodeSeg=NULL;

	mod.iDepList=NULL;

	TUint32 uid[3];

	TUidType& uidref=*(TUidType*)uid;

	const TEmulatorImageHeader* hdr = (const TEmulatorImageHeader*)etm.Section(KWin32SectionName_Symbian);

	if (!hdr)

		return KErrNotSupported;

	__KTRACE_OPT(KDLL,Kern::Printf("Module flags %08x, cap %08x %08x, sid %08x", hdr->iFlags, hdr->iS.iCaps[1], hdr->iS.iCaps[0], hdr->iS.iSecureId));

	mod.iS = hdr->iS;

	// Overide capabilities in image

	const SCapabilitySet& disabledCaps = *(SCapabilitySet*)&TheSuperPage().iDisabledCapabilities;

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

		{

		mod.iS.iCaps[i] |= disabledCaps[i];

		mod.iS.iCaps[i] &= AllSupportedCapabilities[i];

		}

	mod.iModuleVersion = hdr->iModuleVersion;

	mod.iFlags = (hdr->iFlags & KEmulatorImageFlagAllowDllData) ? EFlagData|EFlagDataPresent : 0;

	uidref = *(const TUidType*)&hdr->iUids[0];

	TBool isExe = (uid[0]==KExecutableImageUidValue);

	TBool data_section_present = (etm.Section(KWin32SectionName_EpocData) != NULL);

	if (data_section_present && isExe)

		mod.iFlags = EFlagData|EFlagDataPresent;

	__KTRACE_OPT(KDLL,Kern::Printf("DataSectionPresent = %x", data_section_present));

	// Can't do this for CodeWarrior since it sticks everything in .data, even constants

	// On VC6 this check works for Base code, but not for some other code.

//	if (data_section_present && !isExe && !(hdr->iFlags & KEmulatorImageFlagAllowDllData))

//		return KErrNotSupported;

	if (!data_section_present)

		mod.iFlags = 0;

	if (isExe)

		mod.iFlags |= EFlagExe|EFlagExeInTree;

	SWin32Module w32m;

	w32m.iWin32ModuleHandle=(TLinAddr)aModule;

	w32m.iCodeSeg=NULL;

	TInt ix=MM::Win32Modules.FindInUnsignedKeyOrder(w32m);

	__KTRACE_OPT(KDLL, Kern::Printf("GlobalIx=%d", ix));

	if ((ix>=0 && !MM::Win32Modules[ix].iCodeSeg) || aModule==KernelModuleHandle)

		mod.iFlags|=EFlagAlwaysLoaded;

	TInt r=iModules.InsertInUnsignedKeyOrder(mod);

	__KTRACE_OPT(KDLL, Kern::Printf("Flags=%08x, InsertRes=%d", mod.iFlags, r));

	if (r==KErrAlreadyExists)

		return KErrNone;

	if (r!=KErrNone)

		return r;

	if (mod.iFlags & EFlagAlwaysLoaded)

		return KErrNone;	// stop if we reach an extension or variant

	if (data_section_present && (mod.iFlags & EFlagData)==0)

		{

		// DLL, .data present but 'epocallowdlldata' not specified

		// - either the compiler forgetting that something's constant or

		// developer forgetting to specify 'epocallowdlldata'.

		// call entry point from here to keep the compiler happy

		const char* entry_name = "_E32Dll" ;

		TLinAddr ep = (TLinAddr)Emulator::GetProcAddress(aModule, entry_name);

		__NK_ASSERT_ALWAYS(ep!=0);

		ForceEntryPointCall(ep);

		}

	const IMAGE_IMPORT_DESCRIPTOR* imports = etm.Imports();

	if (imports)

		{

	    for (; imports->Characteristics; ++imports )

			{

			__KTRACE_OPT(KDLL, { TPtrC8 n((const TText8*)etm.Translate(imports->Name)); Kern::Printf("Importing from %S", &n);} );

			Emulator::TModule imp_etm((PCSTR)etm.Translate(imports->Name));

			if (!imp_etm.IsValid())

				{

				__KTRACE_OPT(KDLL, Kern::Printf("Spurious import"));

				continue;

				}

			if (imp_etm.Section(KWin32SectionName_Symbian) == 0)

				{

				__KTRACE_OPT(KDLL, Kern::Printf("Not EPOC Module"));

				continue;		// not an epoc DLL

				}

			r=GatherDependencies(imp_etm.iModule);

			if (r!=KErrNone)

				return r;

			}

		}

	__KTRACE_OPT(KDLL, Kern::Printf("<DModuleList::GatherDependencies %08x %08x %C", aModule, iMain, iMain));

	return KErrNone;

	}

#ifdef __VC32__

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

#endif

/**

Iterate through imports (if any) of each SModule in list. Populate iDepList with the indicies (in iModules)

of directly required modules. Checks that dependencies are legal under platsec.

@return KErrNone on success.

*/

TInt DModuleList::CompileDepLists()

	{

	__KTRACE_OPT(KDLL, Kern::Printf(">DModuleList::CompileDepLists"));

	TInt result=KErrNone;

	TInt c=iModules.Count();

	SModule* pM=(SModule*)&iModules[0];

	SModule* pE=pM+c;

	for (; pM<pE; ++pM)

		{

		pM->iDepList=(TInt*)Kern::Alloc(c*sizeof(TInt));

		if (!pM->iDepList)

			return KErrNoMemory;

		memset(pM->iDepList, 0xff, c*sizeof(TInt));

		Emulator::TModule etm((HINSTANCE)pM->iModuleHandle);

		const IMAGE_IMPORT_DESCRIPTOR* imports = etm.Imports();

		__KTRACE_OPT(KDLL, Kern::Printf("Module %08x, imports=%08x flags=%08x", pM->iModuleHandle, imports, pM->iFlags));

		if (!imports || (pM->iFlags&EFlagAlwaysLoaded))

			continue;

		const SCapabilitySet& cap = pM->iS.iCaps;

		const SCapabilitySet& disabledCaps=*(SCapabilitySet*)&TheSuperPage().iDisabledCapabilities;

		TInt* pI=pM->iDepList;

		for (; imports->Characteristics; ++imports )

			{

			Emulator::TModule imp_etm((PCSTR)etm.Translate(imports->Name));

			if (!imp_etm.IsValid())

				continue;		// spurious import

			if (imp_etm.Section(KWin32SectionName_Symbian) == 0)

				continue;		// not an epoc DLL

			TInt ix=Find((TInt)imp_etm.iModule);

			__ASSERT_ALWAYS(ix>=0, MM::Panic(MM::ECompileDepLists));

			*pI++=ix;

			__KTRACE_OPT(KDLL, Kern::Printf("Depends on %08x, ix=%d", imp_etm.iModule, ix));

			const SModule& dep = iModules[ix];

			SCapabilitySet missingCaps;

			SCapabilitySet depCaps = dep.iS.iCaps;

			TUint32 checkFail = 0;

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

				{

				depCaps[i] = dep.iS.iCaps[i]|disabledCaps[i];

				TUint32 missing = cap[i] & ~depCaps[i];

				missingCaps[i] = missing;

				checkFail |= missing;

				}

			__KTRACE_OPT(KDLL, Kern::Printf("Cap=%08x %08x, DepCap=%08x %08x", cap[1], cap[0], depCaps[1], depCaps[0]));

			if (checkFail)

				{

				TUint8	mainBuf8[MAX_PATH];

				TInt	mainlen;

				{

				TUint16 mainBuf[MAX_PATH];

				mainlen=Emulator::GetModuleFileName(reinterpret_cast<HMODULE>(pM->iModuleHandle),mainBuf);

				TruncToNarrow(mainBuf8, mainBuf, mainlen);

				}

				TPtrC mainp(mainBuf8,mainlen);

				TInt ix=mainp.LocateReverse('\\');

				if (ix>=0)

					mainp.Set(mainp.Mid(ix+1));

				if (mainp.Length() && mainp[mainp.Length()-1]==')' && (ix=mainp.LocateReverse('('))>=0)

					mainp.Set(mainp.Left(ix));

				TUint8	depBuf8[MAX_PATH];

				TInt	deplen;

				{

				TUint16 depBuf[MAX_PATH];

				deplen=Emulator::GetModuleFileName(reinterpret_cast<HMODULE>(dep.iModuleHandle),depBuf);

				TruncToNarrow(depBuf8, depBuf, deplen);

				}

				TPtrC depp(depBuf8,deplen);

				if ((ix=depp.LocateReverse('\\'))>=0)

					depp.Set(depp.Mid(ix+1));

#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__

				TInt r = PlatSec::LoaderCapabilityViolation(mainp, depp, missingCaps);

#else //__REMOVE_PLATSEC_DIAGNOSTICS__

				TInt r = PlatSec::EmitDiagnostic();

#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__

				if(r!=KErrNone)

					result=r;

				}

			}

		}

	return result;

	}

#ifdef __VC32__

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

#endif

void DModuleList::SetFlags()

	{

	__KTRACE_OPT(KDLL, Kern::Printf("DModuleList::SetFlags"));

	TInt c=iModules.Count();

	SModule* pM=(SModule*)&iModules[0];

	SModule* pE=pM+c;

	for (; pM<pE; ++pM)

		{

		SModule* pM2=(SModule*)&iModules[0];

		for (; pM2<pE; ++pM2)

			pM2->iFlags &= ~EFlagMark;

		TUint32 flags=Flags(pM);

		if (flags & EFlagData)

			pM->iFlags|=EFlagDataPresent;

		if (flags & EFlagExe)

			pM->iFlags|=EFlagExeInTree;

		__KTRACE_OPT(KDLL, Kern::Printf("Module %08x Flags=%08x", pM->iModuleHandle, pM->iFlags));

		}

	pM=(SModule*)&iModules[0];

	for (; pM<pE; ++pM)

		{	

		TInt dc=0;

		const TInt* pI=pM->iDepList;

		const TInt* pIE=pI+c;

		while (pI<pIE)

			{

			TInt ix=*pI++;

			if (ix<0)

				break;

			TUint32 mflags=iModules[ix].iFlags;

			if ( (mflags&(EFlagDataPresent|EFlagExeInTree)) && !(mflags&EFlagAlwaysLoaded))

				++dc;

			}

		pM->iDepCount=dc;

		__KTRACE_OPT(KDLL, Kern::Printf("Module %08x DepCount=%d", pM->iModuleHandle, pM->iDepCount));

		}

	}

TUint32 DModuleList::Flags(SModule* aM)

	{

	TUint32 flags=aM->iFlags;

	__KTRACE_OPT(KDLL, Kern::Printf(">DModuleList::Flags %08x", aM->iModuleHandle));

	if ((aM->iFlags & EFlagMark)==0)

		{

		aM->iFlags |= EFlagMark;

		const TInt* pI=aM->iDepList;

		const TInt* pE=pI+iModules.Count();

		while (pI<pE)

			{

			TInt ix=*pI++;

			if (ix<0)

				break;

			TUint32 mflags=Flags(&iModules[ix]);

			if (mflags&EFlagExe)

				mflags&=~EFlagData;

			flags |= mflags;

			}

		}

	__KTRACE_OPT(KDLL, Kern::Printf("<DModuleList::Flags %08x = %08x", aM->iModuleHandle, flags));

	return flags;

	}

TInt DModuleList::LoadDependencies()

	{

	__KTRACE_OPT(KDLL, Kern::Printf("DModuleList::LoadDependencies"));

	TInt c=iModules.Count();

	SModule* pM=(SModule*)&iModules[0];

	SModule* pE=pM+c;

	for (; pM<pE; ++pM)

		{

		DWin32CodeSeg* pS;

		TUint32 flags=pM->iFlags;

		__KTRACE_OPT(KDLL, Kern::Printf("ModuleHandle %08x flags %08x", pM->iModuleHandle, flags));

		if (!(flags & (EFlagDataPresent|EFlagExeInTree)) || (flags&EFlagAlwaysLoaded))

			continue;

		SWin32Module w32m;

		w32m.iWin32ModuleHandle=(TLinAddr)pM->iModuleHandle;

		w32m.iCodeSeg=NULL;

		TInt ix=MM::Win32Modules.FindInUnsignedKeyOrder(w32m);

		__KTRACE_OPT(KDLL, Kern::Printf("GlobalIndex=%d", ix));

		if (ix<0 && (flags & EFlagExe))

			return KErrNotSupported;	// we never implicitly load an EXE

		if (ix>=0)

			{

			pS=MM::Win32Modules[ix].iCodeSeg;

			__KTRACE_OPT(KDLL, Kern::Printf("Already loaded; CSEG=%08x %C", pS, pS));

			if (pS==iMain)

				{

				pS->iDepCount=pM->iDepCount;

				if (pS->iDepCount)

					{

					pS->iDeps=(DCodeSeg**)Kern::AllocZ(pS->iDepCount*sizeof(DCodeSeg*));

					if (!pS->iDeps)

						return KErrNoMemory;

					}

				}

			else

				{

				if (!(pS->iMark & DCodeSeg::EMarkLdr))

					{

					pS->iMark |= DCodeSeg::EMarkLdr;

					pS->CheckedOpen();

					}

				pM->iFlags|=EFlagAlreadyLoaded;

				}

			pM->iCodeSeg=pS;

			continue;

			}

		__KTRACE_OPT(KDLL, Kern::Printf("Create new, depcount=%d", pM->iDepCount));

		pS=new DWin32CodeSeg;