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

//

#define _CRTIMP			// we want to use the static runtime library

#include <e32cmn.h>

#include <e32cmn_private.h>

#include <string.h>

#include <emulator.h>

#include <e32ldr.h>

#include <e32ldr_private.h>

#include <e32uid.h>

#pragma data_seg(".data2")

#ifdef __VC32__

#pragma bss_seg(".data2")

#endif

static TBool UnicodeHost;

static Emulator::SInit Data;

#pragma data_seg()

#ifdef __VC32__

#pragma bss_seg()

#endif

/**	

Initializes a module and prepares it to handle requests.

@param aInit	An object of the structure SInit.

@see SInit.

*/

EXPORT_C void Emulator::Init(const Emulator::SInit& aInit)

	{

	UnicodeHost = (GetVersion() & 0x80000000) ? FALSE : TRUE;

	Data = aInit;

	if (Data.iCodePage == 0)

		Data.iCodePage = CP_ACP;

	}

LOCAL_C DWORD UStringLength(LPCSTR lpMultiByteStr)

//

// returns length of unicode string generated - assumes null terminated string

//

	{

	return MultiByteToWideChar(Data.iCodePage,0,lpMultiByteStr,-1,0,0);

	}

LOCAL_C DWORD ConvertToUnicode(LPCSTR aNarrow,LPWSTR aUnicode,DWORD aLength,BOOL aCharsRequired)

//

// Converts narrow string to unicode string

//

	{

	DWORD uniLength=UStringLength(aNarrow);

	if(uniLength>aLength || uniLength==0)

		return aCharsRequired ? uniLength : 0;

	uniLength=MultiByteToWideChar(Data.iCodePage,0,aNarrow,-1,aUnicode,aLength);

	// return number of characters excluding the null terminator

	return uniLength ? uniLength-1 : 0;

	}

LOCAL_C DWORD ConvertToNarrow(LPCWSTR aUnicode,LPSTR aNarrow,DWORD aLength)

//

// Converts unicode string to narrow string

//

	{

	return WideCharToMultiByte(Data.iCodePage,0,aUnicode,-1,aNarrow,aLength,"@",NULL);

	}

LOCAL_C TInt GetSectionsSize(const IMAGE_NT_HEADERS32* aBase)

//

// Iterates through the section headers at the start of an image and determines the minimum amount of the

// PE file that must be read in in order to examine the sections themselves

//

	{

    // List of sections are are interested in examining

	const BYTE* sectionNames[] =

			{

			KWin32SectionName_Symbian, KWin32SectionName_Import, KWin32SectionName_EpocData, KWin32SectionName_EpocBss,

			KWin32SectionName_Text, KWin32SectionName_RData, KWin32SectionName_NmdExpData

			};

	// Get a ptr to the first section header in preparation for examining all the section headers

	DWORD maxOffset = 0;

	const IMAGE_NT_HEADERS32* ntHead = aBase;

	const IMAGE_SECTION_HEADER* imgHead = (const IMAGE_SECTION_HEADER*) ((TUint8*) &ntHead->OptionalHeader + ntHead->FileHeader.SizeOfOptionalHeader);

	const IMAGE_SECTION_HEADER* end = imgHead + ntHead->FileHeader.NumberOfSections;

	for (; imgHead < end; ++imgHead)

		{

		TBool SectionUsed = EFalse;

		// Go through each of the sections that we need to examine and see if the current section is in the list

		for (TInt index = 0; index < (sizeof(sectionNames) / sizeof(BYTE*)); ++index)

			{

			if (memcmp(imgHead->Name, sectionNames[index], IMAGE_SIZEOF_SHORT_NAME)==0)

				SectionUsed = ETrue;

			}

		// If the current section is one we are interested in, calculate its offset in the raw file and add its size;

		// this gives us the minimum amount of the file to be mapped in order to examine this section and all those

		// preceding it

		if (SectionUsed)

			{

			if ((imgHead->PointerToRawData + imgHead->SizeOfRawData) > maxOffset)

				{

				maxOffset = (imgHead->PointerToRawData + imgHead->SizeOfRawData);

				}

			}

		}

	return(maxOffset);

	}

template <TUint S>

struct Buf8

	{

public:

	Buf8(LPCWSTR aUnicode);

	inline operator LPCSTR() const

		{return iPtr;}

private:

	const char* iPtr;

	char iBuf[S];

	};

template <TUint S>

Buf8<S>::Buf8(LPCWSTR aUnicode)

	{

	if (aUnicode)

		{

		iPtr = iBuf;

		ConvertToNarrow(aUnicode,iBuf,S);

		}

	else

		{

		iPtr = NULL;

		}

	}

/**	

Acquires the global lock for host interaction.

*/

EXPORT_C void Emulator::Lock()

	{

	Data.iLock();

	}

/**

Releases the global lock for host interaction.

This may overwrite the error code for this thread and that is not the behaviour expected, 

so save and restore it.

*/

EXPORT_C void Emulator::Unlock()

	{

	DWORD error=GetLastError();

	Data.iUnlock();

	SetLastError(error);

	}

/**

Takes the current thread out of the emulator scheduling model.

*/

EXPORT_C void Emulator::Escape()

	{

	Data.iEscape();

	}

/**

Returns the calling thread into the emulator scheduling model.

This may overwrite the error code for this thread and that is not the behaviour expected, 

so save and restore it.

*/

EXPORT_C void Emulator::Reenter()

	{

	DWORD error=GetLastError();

	Data.iReenter();

	SetLastError(error);

	}

/**

Jumps to the NThread Win32 SEH exception handler.

@param aException	Describes an exception.

@param aContext		Describes the context.

@return   A handler to handle the exception occurred

*/

EXPORT_C DWORD Emulator::Win32SEHException(EXCEPTION_RECORD* aException, CONTEXT* aContext)

	{

	return Data.iException(aException, aContext);

	}

/**

This function wraps the Win32 CreateDirectory API (see http://msdn2.microsoft.com/en-us/library/aa363855.aspx).

*/  

EXPORT_C BOOL Emulator::CreateDirectory(LPCWSTR lpPathName,LPSECURITY_ATTRIBUTES lpSecurityAttributes)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::CreateDirectoryW(lpPathName, lpSecurityAttributes);

	return ::CreateDirectoryA(Buf8<MAX_PATH>(lpPathName),lpSecurityAttributes);

	}

#ifdef __VC32__

//disable unreachable code warning in VC++

#pragma warning (disable : 4702)

#endif

/**

Recursively ensures that the full directory exists.

@param aPathName  	Provides the path name.

@return  TRUE, if the function succeeds

		 FALSE, if the function fails

*/

EXPORT_C BOOL Emulator::CreateAllDirectories(LPCSTR aPathName)

	{

	__LOCK_HOST;

	char path[MAX_PATH];

	strcpy(path, aPathName);

	char* p = path;

	for (;;)

		{

		p = strchr(p, '\\');

		char temp=0;

		if (p)

			{

			temp = *++p;

			*p = '\0';

			}

		DWORD att = ::GetFileAttributesA(path);

		if ((att == -1 || !(att&FILE_ATTRIBUTE_DIRECTORY)) && !::CreateDirectoryA(path, NULL))

			return EFalse;

		if (!p)

			return ETrue;

		*p = temp;

		}

	}

#ifdef __VC32__

//enable unreachable code warning in VC++

#pragma warning (default : 4702)

#endif

#ifndef INVALID_FILE_ATTRIBUTES	

#define INVALID_FILE_ATTRIBUTES	 ((DWORD)-1)

#endif

/**

This function wraps the Win32 CreateFile API (see http://msdn2.microsoft.com/en-us/library/aa363858.aspx).

It also modifies file attributes depending on whether the file is hidden or not.

*/

EXPORT_C HANDLE Emulator::CreateFile(LPCWSTR lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode,

						   LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwCreationDistribution,

						   DWORD dwFlagsAndAttributes,HANDLE hTemplateFile)

	{

	__LOCK_HOST;

	HANDLE h;

	BOOL hidden = 0; 

	DWORD att = INVALID_FILE_ATTRIBUTES;

	if(dwCreationDistribution==CREATE_ALWAYS)

		{

		att = ::GetFileAttributes(lpFileName);

		if(att!=INVALID_FILE_ATTRIBUTES && (att&FILE_ATTRIBUTE_HIDDEN))

			{

			hidden = ::SetFileAttributes(lpFileName, (att&~FILE_ATTRIBUTE_HIDDEN));

			}

		}

	if (UnicodeHost)

		h = ::CreateFileW(lpFileName,dwDesiredAccess,dwShareMode,lpSecurityAttributes,dwCreationDistribution,

							dwFlagsAndAttributes,hTemplateFile);

	else

		h = ::CreateFileA(Buf8<MAX_PATH>(lpFileName),dwDesiredAccess,dwShareMode,lpSecurityAttributes,dwCreationDistribution,

						dwFlagsAndAttributes,hTemplateFile);

	if(hidden && h!=INVALID_HANDLE_VALUE)

		{

		::SetFileAttributes(lpFileName, att);

		}

	return h;

	}

/**

This function wraps the Win32 DeleteFile API (see http://msdn2.microsoft.com/en-us/library/aa363915.aspx).

*/

EXPORT_C BOOL Emulator::DeleteFile(LPCWSTR lpFileName)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::DeleteFileW(lpFileName);

	return ::DeleteFileA(Buf8<MAX_PATH>(lpFileName));

	}

LOCAL_C TBool MapFindFileData(LPWIN32_FIND_DATAW lpFindFileData, LPWIN32_FIND_DATAA lpFindNarrow)

	{

	lpFindFileData->dwFileAttributes=lpFindNarrow->dwFileAttributes;

	lpFindFileData->ftCreationTime=lpFindNarrow->ftCreationTime;

	lpFindFileData->ftLastAccessTime=lpFindNarrow->ftLastAccessTime;

	lpFindFileData->ftLastWriteTime=lpFindNarrow->ftLastWriteTime;

	lpFindFileData->nFileSizeHigh=lpFindNarrow->nFileSizeHigh;

	lpFindFileData->nFileSizeLow=lpFindNarrow->nFileSizeLow;

	if(!MultiByteToWideChar(Data.iCodePage,0,lpFindNarrow->cFileName,-1,lpFindFileData->cFileName,MAX_PATH))

		return FALSE;

	if(lpFindNarrow->cAlternateFileName!=NULL)

		{

		// magic number 14 comes from MS documentation

		if(!MultiByteToWideChar(Data.iCodePage,0,lpFindNarrow->cAlternateFileName,-1,lpFindFileData->cAlternateFileName,14))

			return FALSE;

		}

	return TRUE;

	}

/**

This function wraps the Win32 FindFirstFile API (see http://msdn2.microsoft.com/en-us/library/aa364418.aspx).	

*/

EXPORT_C HANDLE Emulator::FindFirstFile(LPCWSTR lpFileName,LPWIN32_FIND_DATAW lpFindFileData)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::FindFirstFileW(lpFileName, lpFindFileData);

	WIN32_FIND_DATAA lpFindNarrow;

	HANDLE h=::FindFirstFileA(Buf8<MAX_PATH>(lpFileName),&lpFindNarrow);

	if(h==INVALID_HANDLE_VALUE)

		return h;

	if (!MapFindFileData(lpFindFileData, &lpFindNarrow))

		{

		FindClose(h);

		return INVALID_HANDLE_VALUE;

		}

	return h;

	}

/**

This function wraps the Win32 FindNextFile API (see http://msdn2.microsoft.com/en-us/library/aa364428.aspx).	

*/

EXPORT_C BOOL Emulator::FindNextFile(HANDLE hFindFile,LPWIN32_FIND_DATAW lpFindFileData)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::FindNextFileW(hFindFile, lpFindFileData);

	WIN32_FIND_DATAA lpFindNarrow;

	if(!::FindNextFileA(hFindFile,&lpFindNarrow))

		return FALSE;

	return MapFindFileData(lpFindFileData, &lpFindNarrow);

	}

/**

This function wraps the Win32 GetDiskFreeSpace API (see http://msdn2.microsoft.com/en-us/library/aa364935.aspx).

*/

EXPORT_C BOOL Emulator::GetDiskFreeSpace(LPCWSTR lpRootPathName,LPDWORD lpSectorsPerCluster,\

							   LPDWORD lpBytesPerSector,LPDWORD lpNumberOfFreeClusters,\

							   LPDWORD lpTotalNumberOfClusters)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetDiskFreeSpaceW(lpRootPathName,lpSectorsPerCluster,lpBytesPerSector,lpNumberOfFreeClusters,lpTotalNumberOfClusters);

	return ::GetDiskFreeSpaceA(Buf8<MAX_PATH>(lpRootPathName),lpSectorsPerCluster,lpBytesPerSector,lpNumberOfFreeClusters,lpTotalNumberOfClusters);

	}

/**

This function wraps the Win32 GetFileAttributes API (see http://msdn2.microsoft.com/en-us/library/aa364944.aspx).

*/

EXPORT_C DWORD Emulator::GetFileAttributes(LPCWSTR lpFileName)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetFileAttributesW(lpFileName);

	return ::GetFileAttributesA(Buf8<MAX_PATH>(lpFileName));

	}

/**

This function wraps the Win32 GetModuleHandle API (see http://msdn2.microsoft.com/en-us/library/ms683199.aspx).

*/

EXPORT_C HMODULE Emulator::GetModuleHandle(LPCWSTR lpModuleName)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetModuleHandleW(lpModuleName);

	return ::GetModuleHandleA(Buf8<MAX_PATH>(lpModuleName));

	}

/**

This function wraps the Win32 GetModuleFileName API (see http://msdn2.microsoft.com/en-us/library/ms683197.aspx).

*/

EXPORT_C DWORD Emulator::GetModuleFileName(HMODULE hModule, LPWSTR lpFilename)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetModuleFileNameW(hModule, lpFilename, MAX_PATH);

	char fn[MAX_PATH];

	DWORD r=::GetModuleFileNameA(hModule, fn, MAX_PATH);

	if (r>MAX_PATH||r==0)

		return 0;

	return ConvertToUnicode(fn, lpFilename, MAX_PATH, TRUE);

	}

/**

This function wraps the Win32 GetTempPath API (see http://msdn2.microsoft.com/en-us/library/Aa364992.aspx).

*/

EXPORT_C DWORD Emulator::GetTempPath(DWORD nBufferLength,LPWSTR lpBuff)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetTempPathW(nBufferLength,lpBuff);

	char path[MAX_PATH];

	DWORD r=::GetTempPathA(MAX_PATH,path);

	if(r>MAX_PATH||r==0)

		return 0;

	return ConvertToUnicode(path,lpBuff,nBufferLength,TRUE);

	}

/**

This function wraps the Win32 GetCurrentDirectory API (see http://msdn2.microsoft.com/en-us/library/aa364934.aspx).

*/

EXPORT_C DWORD Emulator::GetCurrentDirectory(DWORD nBufferLength,LPWSTR lpBuff)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::GetCurrentDirectoryW(nBufferLength,lpBuff);

	char path[MAX_PATH];

	DWORD r=::GetCurrentDirectoryA(MAX_PATH,path);

	if(r>MAX_PATH||r==0)

		return 0;

	return ConvertToUnicode(path,lpBuff,nBufferLength,TRUE);

	}

/**

This function wraps the Win32 GetVolumeInformation API (see http://msdn2.microsoft.com/en-us/library/aa364993.aspx).

*/

EXPORT_C BOOL Emulator::GetVolumeInformation(LPCWSTR lpRootPathName,LPWSTR lpVolumeNameBuffer,DWORD nVolumeNameSize,

								   LPDWORD lpVolumeSerialNumber,LPDWORD lpMaximumComponentLength,

								   LPDWORD lpFileSystemFlags,LPWSTR,DWORD)

	{

	__LOCK_HOST;

	// lpfileSystemNameBuffer always NULL so no need to convert

	if (UnicodeHost)

		return ::GetVolumeInformationW(lpRootPathName,lpVolumeNameBuffer,nVolumeNameSize,lpVolumeSerialNumber,

										lpMaximumComponentLength,lpFileSystemFlags,NULL,0);

	char volName[MAX_PATH];

	BOOL res=::GetVolumeInformationA(Buf8<MAX_PATH>(lpRootPathName),volName,MAX_PATH,lpVolumeSerialNumber,

									lpMaximumComponentLength,lpFileSystemFlags,NULL,0);

	if(res && lpVolumeNameBuffer)

		ConvertToUnicode(volName,lpVolumeNameBuffer,nVolumeNameSize,FALSE);

	return res;

	}

/**

This function wraps the Win32 LoadLibrary API (see http://msdn2.microsoft.com/en-us/library/ms684175.aspx).

*/

EXPORT_C HMODULE Emulator::LoadLibrary(LPCWSTR lpLibFileName)

	{

	__LOCK_HOST;

	if (UnicodeHost)

		return ::LoadLibraryW(lpLibFileName);

	return ::LoadLibraryA(Buf8<MAX_PATH>(lpLibFileName));

	}

/**

This function wraps the Win32 FreeLibrary API (see http://msdn2.microsoft.com/en-us/library/ms683152.aspx).

*/

EXPORT_C BOOL Emulator::FreeLibrary(HMODULE hLibModule)

	{

	__LOCK_HOST;

	return ::FreeLibrary(hLibModule);