diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/kernel/eka/euser/epoc/win32/emulator.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/kernelhwsrv/kernel/eka/euser/epoc/win32/emulator.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,841 @@ +// 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 +#include +#include +#include +#include +#include +#include + +#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); + } + +template +struct Buf8 + { +public: + Buf8(LPCWSTR aUnicode); + inline operator LPCSTR() const + {return iPtr;} +private: + const char* iPtr; + char iBuf[S]; + }; + +template +Buf8::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(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(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(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(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(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(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(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(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(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); + } + + + +/** +This function wraps the Win32 MoveFile API (see http://msdn2.microsoft.com/en-us/library/aa365239.aspx). +*/ +EXPORT_C BOOL Emulator::MoveFile(LPCWSTR lpExistingFileName,LPCWSTR lpNewFileName) + { + __LOCK_HOST; + + if (UnicodeHost) + return ::MoveFileW(lpExistingFileName,lpNewFileName); + + return ::MoveFileA(Buf8(lpExistingFileName),Buf8(lpNewFileName)); + } + + +/** +This function wraps the Win32 CopyFile API (see http://msdn2.microsoft.com/en-us/library/aa363851.aspx). +*/ +EXPORT_C BOOL Emulator::CopyFile(LPCWSTR lpExistingFileName,LPCWSTR lpNewFileName,BOOL aFailIfExists) + { + __LOCK_HOST; + + if (UnicodeHost) + return ::CopyFileW(lpExistingFileName,lpNewFileName,aFailIfExists); + + return ::CopyFileA(Buf8(lpExistingFileName),Buf8(lpNewFileName),aFailIfExists); + } + + +/** +This function wraps the Win32 OutputDebugString API (see http://msdn2.microsoft.com/en-us/library/aa363362.aspx). +*/ +EXPORT_C VOID Emulator::OutputDebugString(LPCWSTR lpOutputString) + { + if (UnicodeHost) + ::OutputDebugStringW(lpOutputString); + else + ::OutputDebugStringA(Buf8<1024>(lpOutputString)); + } + + + +/** +This function wraps the Win32 RemoveDirectory API (see http://msdn2.microsoft.com/en-us/library/aa365488.aspx). +*/ +EXPORT_C BOOL Emulator::RemoveDirectory(LPCWSTR lpPathName) + { + __LOCK_HOST; + + if (UnicodeHost) + return ::RemoveDirectoryW(lpPathName); + + return ::RemoveDirectoryA(Buf8(lpPathName)); + } + + +/** +This function wraps the Win32 SetFileAttributes API (see http://msdn2.microsoft.com/en-us/library/aa365535.aspx). +*/ + +EXPORT_C BOOL Emulator::SetFileAttributes(LPCWSTR lpFileName,DWORD dwFileAttributes) + { + __LOCK_HOST; + + if (UnicodeHost) + return ::SetFileAttributesW(lpFileName,dwFileAttributes); + + return ::SetFileAttributesA(Buf8(lpFileName),dwFileAttributes); + } + + + +/** +This function wraps the Win32 SetVolumeLabel API (see http://msdn2.microsoft.com/en-us/library/aa365560.aspx). +*/ +EXPORT_C BOOL Emulator::SetVolumeLabel(LPCWSTR lpRootPathName,LPCWSTR lpVolumeName) + { + __LOCK_HOST; + + if (UnicodeHost) + return ::SetVolumeLabelW(lpRootPathName,lpVolumeName); + + return ::SetVolumeLabelA(Buf8(lpRootPathName),Buf8(lpVolumeName)); + } + + +/** +Maps an NT error to an Epoc32 error. + +@return Last-error code of the calling thread. +*/ +EXPORT_C TInt Emulator::LastError() + +// For other error codes look at MSDN "Numerical List of Error Codes" + { + switch (GetLastError()) + { + case ERROR_SUCCESS: return KErrNone; + case ERROR_INVALID_DRIVE: return KErrNotReady; + case ERROR_INVALID_NAME: + case ERROR_FILENAME_EXCED_RANGE: + case ERROR_OPEN_FAILED: return KErrBadName; + case ERROR_INVALID_HANDLE: return KErrBadHandle; + case ERROR_NOT_SUPPORTED: + case ERROR_INVALID_FUNCTION: return KErrNotSupported; + case ERROR_SHARING_VIOLATION: + case ERROR_ACCESS_DENIED: + case ERROR_WRITE_PROTECT: return KErrAccessDenied; + case ERROR_LOCK_VIOLATION: return KErrLocked; + case ERROR_FILE_NOT_FOUND: + case ERROR_MOD_NOT_FOUND: return KErrNotFound; + case ERROR_DIRECTORY: + case ERROR_BAD_PATHNAME: + case ERROR_PATH_NOT_FOUND: return KErrPathNotFound; + case ERROR_ALREADY_EXISTS: + case ERROR_FILE_EXISTS: return KErrAlreadyExists; + case ERROR_NOT_READY: return KErrNotReady; + case ERROR_UNRECOGNIZED_VOLUME: + case ERROR_NOT_DOS_DISK: return KErrUnknown; + case ERROR_UNRECOGNIZED_MEDIA: + case ERROR_BAD_EXE_FORMAT: return KErrCorrupt; + case ERROR_NO_MORE_FILES: return KErrEof; + case ERROR_DIR_NOT_EMPTY: return KErrInUse; + case ERROR_INVALID_USER_BUFFER: + case ERROR_NOT_ENOUGH_MEMORY: + case ERROR_INSUFFICIENT_BUFFER: + case ERROR_OUTOFMEMORY: return KErrNoMemory; + case ERROR_DISK_FULL: return KErrDiskFull; + case ERROR_INVALID_DATA: + case ERROR_INVALID_PARAMETER: return KErrArgument; + case ERROR_OPERATION_ABORTED: return KErrCancel; + + default: return KErrGeneral; + } + } + +/** +This function wraps the Win32 GetProcAddress API (see http://msdn2.microsoft.com/en-us/library/ms683212.aspx). +*/ +FARPROC Emulator::GetProcAddress(HMODULE hModule, LPCSTR lpProcName) + { + __LOCK_HOST; + return ::GetProcAddress(hModule, lpProcName); + } + + + +// image file support + +// loaded modules + + +/** +Gets the header format of the file system. + +@return Returns the header format of the file system. +*/ +EXPORT_C const IMAGE_NT_HEADERS32* Emulator::TModule::NtHeader() const + { + if (!IsValid()) + return 0; + const IMAGE_DOS_HEADER* dhead = (const IMAGE_DOS_HEADER*)Translate(0); + if ( IMAGE_DOS_SIGNATURE != dhead->e_magic ) + return 0; + if (dhead->e_lfarlc < sizeof(IMAGE_DOS_HEADER)) + return 0; + const IMAGE_NT_HEADERS32* ntHead = (const IMAGE_NT_HEADERS32*)Translate(dhead->e_lfanew); + if ( ntHead->Signature != IMAGE_NT_SIGNATURE ) + return 0; + return ntHead; + } + + +/** +Constructor which sets the handles of loaded module to the specified module. + +@param aModuleName Holds the name of the module to be loaded. +*/ +EXPORT_C Emulator::TModule::TModule(LPCSTR aModuleName) + : iModule(GetModuleHandleA(aModuleName)), iBase(iModule) + { + if (!NtHeader()) + { + iModule = 0; + iBase = 0; + } + } + + +/** +Gets the pointer of the section header if the header name matches with the buffer aSection[]. + +@param aSection[] A buffer of type BYTE. + +@return Returns the pointer to section header of the file system. +*/ +EXPORT_C const IMAGE_SECTION_HEADER* Emulator::TModule::SectionHeader(const BYTE aSection[]) const + { + const IMAGE_NT_HEADERS32* ntHead = NtHeader(); + if (!ntHead) + return 0; + + 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) + { + if (memcmp(imgHead->Name, aSection, IMAGE_SIZEOF_SHORT_NAME)==0) + return imgHead; + } + return 0; + } + + +/** +Points to the first byte or first page of the loaded module or mapped file image. + +@param aSection[] A buffer of type BYTE. + +@return TAny Returns first byte of the loaded module or first page of the mapped file image. +*/ +EXPORT_C const TAny* Emulator::TModule::Section(const BYTE aSection[]) const + { + const IMAGE_SECTION_HEADER* imgHead = SectionHeader(aSection); + if (imgHead) + return Translate(IsLoaded() ? imgHead->VirtualAddress : imgHead->PointerToRawData); + return 0; + } + + +/** +Go through the section headers looking for UID section. + +@param aType Contains a UID type. +*/ +EXPORT_C void Emulator::TModule::GetUids(TUidType& aType) const + { + const TEmulatorImageHeader* hdr = (const TEmulatorImageHeader*)Section(KWin32SectionName_Symbian); + if (hdr) + aType = *(const TUidType*)&hdr->iUids[0]; + } + + +/** +Goes through section headers and gets the information of file system. + +@param aInfo Contains the information of the file system. +*/ +EXPORT_C void Emulator::TModule::GetInfo(TProcessCreateInfo& aInfo) const + { + aInfo.iExceptionDescriptor = 0; + const IMAGE_NT_HEADERS32* ntHead = NtHeader(); + if (ntHead) + { + const TEmulatorImageHeader* hdr = (const TEmulatorImageHeader*)Section(KWin32SectionName_Symbian); + if (hdr) + { + aInfo.iUids = *(const TUidType*)&hdr->iUids[0]; + TBool isExe = (hdr->iUids[0].iUid==KExecutableImageUidValue); + TBool data_section_present = (Section(KWin32SectionName_EpocData)!=NULL); + TBool data = hdr->iFlags & KEmulatorImageFlagAllowDllData; + if (data_section_present && isExe) + data = ETrue; + aInfo.iBssSize=data?1:0; + aInfo.iDataSize=0; + aInfo.iTotalDataSize=aInfo.iBssSize; + aInfo.iDepCount = 0; + aInfo.iHeapSizeMin = ntHead->OptionalHeader.SizeOfHeapCommit; + aInfo.iHeapSizeMax = ntHead->OptionalHeader.SizeOfHeapReserve; + aInfo.iStackSize = 0x1000; + aInfo.iPriority = hdr->iPriority; + aInfo.iHandle = NULL; + aInfo.iS = hdr->iS; + aInfo.iModuleVersion = hdr->iModuleVersion; + if (ntHead->FileHeader.Characteristics & IMAGE_FILE_DLL) + aInfo.iAttr |= ECodeSegAttHDll; + } + } + GetUids(aInfo.iUids); + } + + +/** +Finds the import section from the data directory. This relies on the module being loaded. + +@return Returns the imported executable. +*/ +EXPORT_C const IMAGE_IMPORT_DESCRIPTOR* Emulator::TModule::Imports() const + { + if (!IsLoaded()) + return NULL; + const IMAGE_NT_HEADERS32* ntHead = NtHeader(); + if (!ntHead) + return NULL; + DWORD va = ntHead->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress; + if (!va) + return NULL; + return (const IMAGE_IMPORT_DESCRIPTOR*)Translate(va); + } + +// modules in the file system +EXPORT_C TInt Emulator::RImageFile::Open(LPCTSTR aImageFile) + { + Buf8 nameBuf(aImageFile); + char *pName = (char *)strrchr(LPCSTR(nameBuf), '\\'); + pName ? ++pName : pName = (char *)LPCSTR(nameBuf); + + __LOCK_HOST; + iMapping = OpenFileMapping(FILE_MAP_READ, FALSE, (LPCTSTR)pName); + if (!iMapping) + { + if (pName == (char *)LPCSTR(nameBuf)) + iModule = Emulator::GetModuleHandle(aImageFile); + if (iModule) + iBase = iModule; + else + { + // need to map the file instead + HANDLE file = Emulator::CreateFile(aImageFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); + if (file == INVALID_HANDLE_VALUE) + return LastError(); + iMapping = CreateFileMappingA(file, NULL, PAGE_READONLY, 0, 0, pName); + CloseHandle(file); + } + } + if (!iModule) + { + if (!iMapping) + return LastError(); + + iBase = MapViewOfFile(iMapping, FILE_MAP_READ, 0, 0, 0); + + if (!iBase) + { + CloseHandle(iMapping); + iMapping = 0; + return LastError(); + } + } + + if (!NtHeader()) + { + Close(); + return KErrNotSupported; + } + return KErrNone; + } + +EXPORT_C void Emulator::RImageFile::Close() + { + if (iMapping) + { + UnmapViewOfFile(iBase); + CloseHandle(iMapping); + iMapping = 0; + } + iBase = 0; + iModule = 0; + }