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

//

#include <string.h>

#include <e32std.h>

#include <e32std_private.h>

#include <e32rom.h>

#include "e32image.h"

#include "pe_defs.h"

#include "pe_file.h"

#include "h_utl.h"

TBool hadText, hadReloc = EFalse;

TUint32 PEFile::iRomMemBase=0;

TUint32 PEFile::iRomLinearBase=0;

extern char* gX86imp;

extern int gX86num_imp_dlls;

PEFile::PEFile()

	:iMemBase(0),iEntryPoint(0),iImageSize(0),iCodeSize(0),iDataSize(0),

	iHeapReservedSize(0),iHeapCommittedSize(0),iStackReservedSize(0),iStackCommittedSize(0),

	iBssSize(0),iBssOffset(0),iSectionAlign(0),iExpDirectoryOffset(0),iDataOffset(0),

	iImageIsDll(EFalse),

	iHeader(0),iExpDirectory(0),iImpDescriptor(0),iFileName(0),iFileHandle(0),

	iLinkedBase(0),iStartOfHeaders(0),iSizeOfHeaders(0),iNumSections(0),

	iRomRunAddr(0),iRamRunAddr(0),iRomDelta(0),iRamDelta(0),iHadDataSection(EFalse),

	iBssSectionLinkedAddr(0),iBssSectionAddr(0),iBssSectionSize(0),

	iDataSectionLinkedAddr(0),iDataSectionAddr(0),iDataSectionSize(0),

	iCodeSectionAddr(0),iCodeSectionSize(0),

	iRDataSectionAddr(0),iRDataSectionSize(0),

	iCRTSectionAddr(0),iCRTSectionSize(0),

	iExportDataDir(0)

//

// Constructor

//

	{

	for (TInt i=0; i<KNumberOfSections; i++)

		{

		iSectionHeader[i]=NULL;

		iSectionData[i]=NULL;

		}

	}

PEFile::~PEFile()

//

// Destructor

//

	{

	delete [] iFileName;

	for (TInt i=0; i<KNumberOfSections; i++)

		{

		delete iSectionHeader[i];

		delete iSectionData[i];

		}

	}

TBool PEFile::Init(const TText * const aFileName)

//

// Reads the PE headers to fill in lots of nice instance variables with info about the file

//

 	{

 	delete [] iFileName;	

	iFileName = new TText[strlen((const char *)aFileName)+1];

	strcpy ((char *)iFileName, (const char *)aFileName);

	iHeader = (PIMAGE_NT_HEADERS)(HMem::Alloc(0,sizeof(IMAGE_DOS_HEADER)+sizeof(IMAGE_NT_HEADERS)));

	if (!iHeader)

		{

		Print(EPeError,"Failed to allocate memory for headers.\n");

		return EFalse;

		}

	TInt error = HFile::Open(iFileName, &iFileHandle);

	if (error!=0)

		return EFalse;

	if (!HFile::Read(iFileHandle,iHeader,sizeof(IMAGE_DOS_HEADER)))

		{

		Print(EPeError,"Unable to read file %s.\n",iFileName);

		HFile::Close(iFileHandle);

		return EFalse;

		}

	if (IsValidDOSHeader((PIMAGE_DOS_HEADER)iHeader)) // read in the rest, overwriting the DOS header

		iStartOfHeaders = ((PIMAGE_DOS_HEADER)iHeader)->e_lfanew;

	else

		iStartOfHeaders = 0;

	if (!HFile::Seek(iFileHandle, iStartOfHeaders))

		{

		Print(EPeError,"File %s is not large enough to contain valid headers.\n",iFileName);

		HFile::Close(iFileHandle);

		return EFalse;

		}

 	if (!HFile::Read(iFileHandle,iHeader,sizeof(IMAGE_NT_HEADERS)))

		{

		Print(EPeError,"Unable to read NT headers.\n");

		HFile::Close(iFileHandle);

		return EFalse;

		}

	if (!IsValidNTHeader(iHeader))

		{

		Print(EPeError,"Invalid NT header.\n");

		HFile::Close(iFileHandle);

		return EFalse;

		}

	if (!(IsValidFileHeader((PIMAGE_FILE_HEADER)&iHeader->FileHeader)))

		{

		Print(EPeError,"Invalid file header.\n");

		HFile::Close(iFileHandle);

		return EFalse;

		}

//	PIMAGE_NT_HEADERS pNTHeader = iHeader;

	PIMAGE_FILE_HEADER pFileHeader = (PIMAGE_FILE_HEADER)&iHeader->FileHeader;

	PIMAGE_OPTIONAL_HEADER pOptionalHeader = (PIMAGE_OPTIONAL_HEADER)&iHeader->OptionalHeader;

//	PIMAGE_SECTION_HEADER pSectionHeader = (PIMAGE_SECTION_HEADER)(iHeader+1);

	iImageSize = pOptionalHeader->SizeOfImage;

	iCodeSize = pOptionalHeader->SizeOfCode;

	iDataSize = pOptionalHeader->SizeOfInitializedData;

	iEntryPoint = pOptionalHeader->AddressOfEntryPoint;

	iHeapReservedSize = pOptionalHeader->SizeOfHeapReserve;

	iHeapCommittedSize = pOptionalHeader->SizeOfHeapCommit;

	iStackReservedSize = 0x2000;

	iStackCommittedSize = 0x2000;

	iBssSize = pOptionalHeader->SizeOfUninitializedData;

    iSectionAlign =	pOptionalHeader->SectionAlignment;

 	if (pFileHeader->Characteristics & IMAGE_FILE_DLL)

		iImageIsDll = ETrue;

	else

		iImageIsDll = EFalse;

 	iLinkedBase=pOptionalHeader->ImageBase;

	iNumSections = pFileHeader->NumberOfSections;

	iSizeOfHeaders = pOptionalHeader->SizeOfHeaders;

	iExportDataDir=pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;

	iExportDirSize=pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;

//

	iCpu=pFileHeader->Machine;

	HMem::Free(iHeader);

	iHeader=0;

	return ETrue;

	}

void PEFile::Close()

//

// close the pe file

//

	{

	HFile::Close(iFileHandle);

	}

TInt PEFile::ReadExportDirectory()

//

// Read in just the export directory

//

	{

	if (iExportDataDir==0)

		return KErrNotFound;

	TInt r=ReadSectionHeaders();

	if (r!=KErrNone)

		return r;

	iSectionData[KConstSection]=ReadSectionData(iSectionHeader[KConstSection]);

	iExpDirectoryOffset=iSectionHeader[KConstSection]->VirtualAddress;

	iExpDirectory=(PIMAGE_EXPORT_DIRECTORY)(iSectionData[KConstSection]+iExportDataDir-iExpDirectoryOffset);

	return KErrNone;

	}

TInt PEFile::ReadSectionHeaders()

//

// Read in the section headers

//

	{

	TInt i;

	for (i=0; i<KNumberOfSections; i++)

		iSectionHeader[i]=NULL;

	HFile::Seek(iFileHandle, iStartOfHeaders+sizeof(IMAGE_NT_HEADERS));

	for (i=0; i<(TInt)iNumSections; i++)

		{

		PIMAGE_SECTION_HEADER header = new IMAGE_SECTION_HEADER;

		if (!HFile::Read(iFileHandle, header, sizeof(IMAGE_SECTION_HEADER)))

			return Print(EError, "Cannot read section header.\n");

		if (CmpSectionName(header, ".text"))

			iSectionHeader[KTextSection]=header;

		else if (CmpSectionName(header, ".rdata"))

			iSectionHeader[KConstSection]=header;

		else if (CmpSectionName(header, ".edata"))

			iSectionHeader[KExportSection]=header;

		else if (CmpSectionName(header, ".data"))

			iSectionHeader[KDataSection]=header;

		else if (CmpSectionName(header, ".bss"))

			iSectionHeader[KBssSection]=header;

		else if (CmpSectionName(header, ".idata"))

			iSectionHeader[KImportSection]=header;

		else if (CmpSectionName(header, ".reloc"))

			iSectionHeader[KRelocSection]=header;

		else if (CmpSectionName(header, ".CRT"))

			iSectionHeader[KCrtSection]=header;

		else if (CmpSectionName(header, ".stab"))

			delete header;

		else if (CmpSectionName(header, ".stabstr"))

			delete header;

		else if (CmpSectionName(header,".E32_UID"))

			delete header;

		else if (CmpSectionName(header,".rsrc"))

			delete header;

		else

			{

			Print(EWarning, "Section '%.8s' removed.\n", header->Name);

			delete header;

			}

		}

	return KErrNone;

	}

char *PEFile::ReadSectionData(PIMAGE_SECTION_HEADER aPeHeader)

//

// Read in the data for this section

//

	{

	char *section=NULL;

	if (aPeHeader)

		{

		section=(char *)HMem::Alloc(NULL, aPeHeader->SizeOfRawData);

		if (section==NULL)

			return NULL;

		HFile::Seek(iFileHandle, aPeHeader->PointerToRawData);

		HFile::Read(iFileHandle, section, aPeHeader->SizeOfRawData);

		}

	return section;

	}

TInt PEFile::ReadData()

//

//

//

	{

	TInt i;

	for (i=0; i<KNumberOfSections; i++)

		{

		if (iSectionHeader[i])

			{

			iSectionData[i]=ReadSectionData(iSectionHeader[i]);

			if (iSectionData[i]==NULL)

				return Print(EError, "Cannot read %s section data.\n", iSectionHeader[i]->Name);

			}

		else

			iSectionData[i]=NULL;

		}

	return KErrNone;

	}

TInt PEFile::NumberOfImports() const

//

// Count the total number of imports for this image

//

	{

//	if (gX86imp)

//		return gX86num_imp_dlls;

	char *importData=iSectionData[KImportSection];

	PIMAGE_SECTION_HEADER importHeader=iSectionHeader[KImportSection];

	if (importData==NULL)

		return 0;

	TInt n=0;

	TUint *src=(TUint *)importData;

	while (*src)

		{

		TUint vaoffset=src[4];

		if (!gLittleEndian) ByteSwap(vaoffset);

		TUint offset=vaoffset-importHeader->VirtualAddress; // find the offset into the section of import addr table

		TUint *p=(TUint *)(importData+offset);

		while (*p++)

			n++;

		src+=5; // sizeof pe import block/4

		}

	return n;

	}

TInt PEFile::NumberOfImportDlls() const

//

// Count the number of referenced Dlls

//

	{

	char *importData=iSectionData[KImportSection];

//	PIMAGE_SECTION_HEADER importHeader=iSectionHeader[KImportSection];

	if (importData==NULL)

		return 0;

	TInt n=0;

	while (*(TUint *)importData)

		{

		n++;

		importData+=5*4; // size of pe import block

		}

	return n;

	}

TInt PEFile::NumberOfExports() const

//

// Count the number of exported symbols

//

	{

	if (iExportDataDir==0)

		return 0;

	return ((PIMAGE_EXPORT_DIRECTORY)iSectionData[KExportSection])->NumberOfFunctions;

	}

TInt PEFile::NumberOfRelocs()

//

// Count the number of reloctions

//

	{

	if (iSectionData[KRelocSection]==NULL)

		return 0;

	char *relocs=iSectionData[KRelocSection];

	TInt n=0;

	TInt dudrelocs=0;

	TInt blocksize;

	TUint page;

	TInt size=iSectionHeader[KRelocSection]->Misc.VirtualSize;

	TUint *rrelocs=(TUint *)relocs;

	TUint ssize=size;

	if (!gLittleEndian) ByteSwap(rrelocs, ssize);

	while (size>0)

		{

		page=*(TUint *)relocs;

		blocksize=*(TInt *)(relocs+4);

		if (blocksize==0)

			break;

		size-=blocksize;

		TUint16 *p=(TUint16 *)(relocs+8);

		relocs+=blocksize;

		blocksize-=8;

		while (blocksize>0)

			{

			TInt rtype=(*p&0xf000)>>12;

			if (rtype==IMAGE_REL_BASED_HIGHLOW)

				{

				TUint va=page+(*p&0xfff);

				// va is the address requiring relocation, so it must be in a section and can't have been offset

				TInt section=FindSectionByVa(va+iLinkedBase);

				if (section==KTextSection || section==KConstSection || section==KDataSection || section==KCrtSection)

					n++;

				else

					dudrelocs++;

				}

			else if (rtype!=IMAGE_REL_BASED_ABSOLUTE)	// used for padding

				Print(EWarning, "Relocation type other than IMAGE_REL_BASED_HIGHLOW has been ignored.\n");

			*p++;

			blocksize-=2;

			}

		}

#if defined(_DEBUG)

	if (dudrelocs>0)

		Print(EWarning, "Image '%s' has %d relocations pointing at uninitialised data.\n", iFileName, dudrelocs);

#endif

	if (!gLittleEndian) ByteSwap(rrelocs, ssize);

	return n;

	}

void PEFile::GetRelocs(TUint *aReloc, TUint *aRelocSection, TInt /*aNumberOfRelocs*/)

//

// load the relocs from the reloc section into relocation and relocsection arrays

//

	{

	TUint *relocation=aReloc;

	TUint *relocsection=aRelocSection;

	char *aRelocData=iSectionData[KRelocSection];

	TUint16 *relocs=(TUint16 *)aRelocData;

	TInt relocsize=iSectionHeader[KRelocSection]->Misc.VirtualSize;

	TUint offset;

	TUint page;

	TInt i=0;

	TUint *rrelocs=(TUint *)aRelocData;

	TUint ssize=relocsize;

	if (!gLittleEndian) ByteSwap(rrelocs, ssize);

	while (relocsize>0)

		{

		page=*(TUint *)relocs;

		relocs+=2;

		TInt size=*(TUint *)relocs;

		if (size==0)

			break;

		relocsize-=size;

		relocs+=2;

		size-=8;

		while (size>0)

			{

			offset=*relocs++;

			TInt type=offset&0xf000;

			if (type==0x3000)

				{

				TUint va=page+(offset&0xfff);

				// va is the address requiring relocation, so it must be in a section and can't have been offset

				TInt section=FindSectionByVa(va+iLinkedBase);

				if (section==KTextSection || section==KConstSection || section==KDataSection || section==KCrtSection)

					{

					relocsection[i]=section;

					relocation[i++]=va;

					}

				}

			size-=2;

			}

		}

	if (!gLittleEndian) ByteSwap(rrelocs, ssize);

	}

TInt PEFile::Normalise()

//

// Remove the MSVC anomalies

//

	{

	// MSVC puts export data in with .rdata

	if (iExportDataDir && iSectionHeader[KExportSection]==NULL)

		{

		if (!PEFile::VirtualAddressInSection(iExportDataDir+iLinkedBase, iSectionHeader[KConstSection]))

			return Print(EError, "Can't find exports in this PE file.\n");

		else

			{

			iSectionHeader[KExportSection]=new IMAGE_SECTION_HEADER;

			iSectionHeader[KExportSection]->VirtualAddress=iExportDataDir;

			iSectionHeader[KExportSection]->Misc.VirtualSize=iExportDirSize;

			iSectionHeader[KExportSection]->SizeOfRawData=iExportDirSize;

			iSectionData[KExportSection]=new char [iExportDirSize];

			if (iSectionData[KExportSection]==NULL)

				return Print(EError, "Out of memory.\n");

			memcpy(iSectionData[KExportSection], iSectionData[KConstSection]+iExportDataDir-iSectionHeader[KConstSection]->VirtualAddress, iExportDirSize);

			// adjust .rdata so it does not include .edata

			iSectionHeader[KConstSection]->Misc.VirtualSize-=iExportDirSize;

			iSectionHeader[KConstSection]->SizeOfRawData-=iExportDirSize;

			char *c=new char [iSectionHeader[KConstSection]->SizeOfRawData];

			if (c==NULL)

				return Print(EError, "Out of memory.\n");

			memcpy(c, iSectionData[KConstSection], iSectionHeader[KConstSection]->SizeOfRawData);

			delete iSectionData[KConstSection];

			iSectionData[KConstSection]=c;

			}

		}

	// Stupid compilers generate .idata sections even when there are no imports

	if (iSectionHeader[KImportSection])

		{

		if (NumberOfImports()==0)

			{

			delete iSectionHeader[KImportSection];

			delete iSectionData[KImportSection];

			iSectionHeader[KImportSection]=NULL;

			iSectionData[KImportSection]=NULL;

			}

		}

	return KErrNone;

	}

TInt PEFile::HasInitialisedData(PIMAGE_SECTION_HEADER aHeader)

//

// Returns true if the pe file section contains any initialised data

//

	{

	if (aHeader==NULL)

		return FALSE;

	if (aHeader->SizeOfRawData==0)

		return FALSE;

	return TRUE;

	}

void PEFile::CopySectionData(TAny *source, TAny *dest, TUint32 fileLength, TUint32 memLength)

	{

	if (fileLength <= memLength)

		{

		Print(EScreen,"   Copying %08x bytes from file at %08x to memory at %08x\n", fileLength, source, dest);

		HMem::Copy(dest,source,fileLength);

		dest = (TAny *)((TUint32)dest + fileLength);

		TUint32 remainingSize = memLength - fileLength;

		Print(EScreen,"   Zeroing remaining %08x bytes at %08x\n", remainingSize, dest);

		HMem::Set(dest, 0, remainingSize);

		}

	else

		{

		Print(EScreen,"   Copying %08x bytes from file at %08x to memory at %08x\n", memLength, source, dest);

		HMem::Copy(dest,source,memLength);

		}

	}		

TBool PEFile::ProcessRelocData(TAny *relocData,TInt dataSize)

	{