Context Navigation

source: trunk/kLdr/kLdrModPE.c@ 79

Last change on this file since 79 was 79, checked in by bird, 9 years ago
fixing warnings.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 69.4 KB

Rev	Line
[2]	1	/* $Id: kLdrModPE.c 79 2016-07-27 14:25:09Z bird $ */
	2	/** @file
	3	* kLdr - The Module Interpreter for the Portable Executable (PE) Format.
	4	*/
	5
	6	/*
[29]	7	* Copyright (c) 2006-2007 Knut St. Osmundsen <bird-kStuff-spamix@anduin.net>
[2]	8	*
[29]	9	* Permission is hereby granted, free of charge, to any person
	10	* obtaining a copy of this software and associated documentation
	11	* files (the "Software"), to deal in the Software without
	12	* restriction, including without limitation the rights to use,
	13	* copy, modify, merge, publish, distribute, sublicense, and/or sell
	14	* copies of the Software, and to permit persons to whom the
	15	* Software is furnished to do so, subject to the following
	16	* conditions:
[2]	17	*
[29]	18	* The above copyright notice and this permission notice shall be
	19	* included in all copies or substantial portions of the Software.
[2]	20	*
[29]	21	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	22	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
	23	* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	24	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
	25	* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	26	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	27	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	28	* OTHER DEALINGS IN THE SOFTWARE.
[2]	29	*/
	30
	31	/*******************************************************************************
	32	* Header Files *
	33	*******************************************************************************/
	34	#include <k/kLdr.h>
	35	#include "kLdrInternal.h"
	36	#include <k/kLdrFmts/pe.h>
	37
	38
	39	/*******************************************************************************
	40	* Defined Constants And Macros *
	41	*******************************************************************************/
	42	/** @def KLDRMODPE_STRICT
	43	* Define KLDRMODPE_STRICT to enabled strict checks in KLDRMODPE. */
	44	#define KLDRMODPE_STRICT 1
	45
	46	/** @def KLDRMODPE_ASSERT
	47	* Assert that an expression is true when KLDR_STRICT is defined.
	48	*/
	49	#ifdef KLDRMODPE_STRICT
	50	# define KLDRMODPE_ASSERT(expr) kHlpAssert(expr)
	51	#else
	52	# define KLDRMODPE_ASSERT(expr) do {} while (0)
	53	#endif
	54
	55	/** @def KLDRMODPE_RVA2TYPE
	56	* Converts a RVA to a pointer of the specified type.
	57	* @param pvBits The bits (image base).
	58	* @param uRVA The image relative virtual address.
	59	* @param type The type to cast to.
	60	*/
	61	#define KLDRMODPE_RVA2TYPE(pvBits, uRVA, type) \
	62	( (type) ((KUPTR)(pvBits) + (KUPTR)(uRVA)) )
	63
	64	/** @def KLDRMODPE_VALID_RVA
	65	* Checks that the specified RVA value is non-zero and within the bounds of the image.
	66	* @returns true/false.
	67	* @param pModPE The PE module interpreter instance.
	68	* @param uRVA The RVA to validate.
	69	*/
	70	#define KLDRMODPE_VALID_RVA(pModPE, uRVA) \
	71	( (uRVA) && (uRVA) < (pModPE)->Hdrs.OptionalHeader.SizeOfImage )
	72
	73
	74
	75	/*******************************************************************************
	76	* Structures and Typedefs *
	77	*******************************************************************************/
	78	/**
	79	* Instance data for the PE module interpreter.
	80	*/
	81	typedef struct KLDRMODPE
	82	{
	83	/** Pointer to the module. (Follows the section table.) */
	84	PKLDRMOD pMod;
	85	/** Pointer to the RDR mapping of the raw file bits. NULL if not mapped. */
	86	const void *pvBits;
	87	/** Pointer to the user mapping. */
	88	const void *pvMapping;
	89	/** Reserved flags. */
	90	KU32 f32Reserved;
	91	/** The number of imported modules.
	92	* If ~(KU32)0 this hasn't been determined yet. */
	93	KU32 cImportModules;
	94	/** The offset of the NT headers. */
	95	KLDRFOFF offHdrs;
	96	/** Copy of the NT headers. */
	97	IMAGE_NT_HEADERS64 Hdrs;
	98	/** The section header table . */
	99	IMAGE_SECTION_HEADER aShdrs[1];
	100	} KLDRMODPE, *PKLDRMODPE;
	101
	102
	103	/*******************************************************************************
	104	* Internal Functions *
	105	*******************************************************************************/
	106	static KI32 kldrModPENumberOfImports(PKLDRMOD pMod, const void *pvBits);
	107	static int kldrModPERelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
	108	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
	109
	110	static int kldrModPEDoCreate(PKRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODPE *ppMod);
	111	/static void kldrModPEDoLoadConfigConversion(PIMAGE_LOAD_CONFIG_DIRECTORY64 pLoadCfg); /
	112	static int kLdrModPEDoOptionalHeaderValidation(PKLDRMODPE pModPE);
	113	static int kLdrModPEDoSectionHeadersValidation(PKLDRMODPE pModPE);
	114	static void kldrModPEDoOptionalHeaderConversion(PIMAGE_OPTIONAL_HEADER64 pOptionalHeader);
	115	static int kldrModPEDoForwarderQuery(PKLDRMODPE pModPE, const void pvBits, const char pszForwarder,
	116	PFNKLDRMODGETIMPORT pfnGetImport, void pvUser, PKLDRADDR puValue, KU32 pfKind);
	117	static int kldrModPEDoFixups(PKLDRMODPE pModPE, void *pvMapping, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress);
	118	static int kldrModPEDoImports32Bit(PKLDRMODPE pModPE, void pvMapping, const IMAGE_IMPORT_DESCRIPTOR pImpDesc,
	119	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
	120	static int kldrModPEDoImports64Bit(PKLDRMODPE pModPE, void pvMapping, const IMAGE_IMPORT_DESCRIPTOR pImpDesc,
	121	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
	122	static int kldrModPEDoImports(PKLDRMODPE pModPE, void pvMapping, PFNKLDRMODGETIMPORT pfnGetImport, void pvUser);
	123	static int kldrModPEDoCallDLL(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle);
	124	static int kldrModPEDoCallTLS(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle);
	125	static KI32 kldrModPEDoCall(KUPTR uEntrypoint, KUPTR uHandle, KU32 uOp, void *pvReserved);
	126
	127
	128	/**
	129	* Create a loader module instance interpreting the executable image found
	130	* in the specified file provider instance.
	131	*
	132	* @returns 0 on success and *ppMod pointing to a module instance.
	133	* On failure, a non-zero OS specific error code is returned.
	134	* @param pOps Pointer to the registered method table.
	135	* @param pRdr The file provider instance to use.
[25]	136	* @param fFlags Flags, MBZ.
	137	* @param enmCpuArch The desired CPU architecture. KCPUARCH_UNKNOWN means
	138	* anything goes, but with a preference for the current
	139	* host architecture.
[2]	140	* @param offNewHdr The offset of the new header in MZ files. -1 if not found.
	141	* @param ppMod Where to store the module instance pointer.
	142	*/
[25]	143	static int kldrModPECreate(PCKLDRMODOPS pOps, PKRDR pRdr, KU32 fFlags, KCPUARCH enmCpuArch, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
[2]	144	{
	145	PKLDRMODPE pModPE;
	146	int rc;
[79]	147	K_NOREF(fFlags);
[2]	148
	149	/*
	150	* Create the instance data and do a minimal header validation.
	151	*/
	152	rc = kldrModPEDoCreate(pRdr, offNewHdr, &pModPE);
	153	if (!rc)
	154	{
[25]	155	/*
	156	* Match up against the requested CPU architecture.
	157	*/
	158	if ( enmCpuArch == KCPUARCH_UNKNOWN
	159	\|\| pModPE->pMod->enmArch == enmCpuArch)
	160	{
	161	pModPE->pMod->pOps = pOps;
	162	pModPE->pMod->u32Magic = KLDRMOD_MAGIC;
	163	*ppMod = pModPE->pMod;
	164	return 0;
	165	}
	166	rc = KLDR_ERR_CPU_ARCH_MISMATCH;
[2]	167	}
	168	kHlpFree(pModPE);
	169	return rc;
	170	}
	171
	172
	173	/**
	174	* Separate function for reading creating the PE module instance to
	175	* simplify cleanup on failure.
	176	*/
	177	static int kldrModPEDoCreate(PKRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODPE *ppModPE)
	178	{
	179	struct
	180	{
	181	KU32 Signature;
	182	IMAGE_FILE_HEADER FileHdr;
	183	} s;
	184	PKLDRMODPE pModPE;
	185	PKLDRMOD pMod;
	186	KSIZE cb;
	187	KSIZE cchFilename;
	188	KLDRFOFF off;
	189	KU32 i;
	190	int rc;
	191	*ppModPE = NULL;
	192
	193	/*
	194	* Read the signature and file header.
	195	*/
	196	rc = kRdrRead(pRdr, &s, sizeof(s), offNewHdr > 0 ? offNewHdr : 0);
	197	if (rc)
	198	return rc;
	199	if (s.Signature != IMAGE_NT_SIGNATURE)
	200	return KLDR_ERR_UNKNOWN_FORMAT;
	201
	202	/* sanity checks. */
	203	if ( s.FileHdr.NumberOfSections > 4096
	204	\|\| ( s.FileHdr.SizeOfOptionalHeader != sizeof(IMAGE_OPTIONAL_HEADER32)
	205	&& s.FileHdr.SizeOfOptionalHeader != sizeof(IMAGE_OPTIONAL_HEADER64))
	206	\|\| !(s.FileHdr.Characteristics & IMAGE_FILE_EXECUTABLE_IMAGE)
	207	)
	208	return KLDR_ERR_PE_BAD_FILE_HEADER;
	209	if ( s.FileHdr.Machine != IMAGE_FILE_MACHINE_I386
	210	&& s.FileHdr.Machine != IMAGE_FILE_MACHINE_AMD64
	211	)
	212	return KLDR_ERR_PE_UNSUPPORTED_MACHINE;
	213
	214	/*
	215	* Calc the instance size, allocate and initialize it.
	216	*/
	217	cchFilename = kHlpStrLen(kRdrName(pRdr));
	218	cb = K_ALIGN_Z(K_OFFSETOF(KLDRMODPE, aShdrs[s.FileHdr.NumberOfSections]), 16)
	219	+ K_OFFSETOF(KLDRMOD, aSegments[s.FileHdr.NumberOfSections + 1])
	220	+ cchFilename + 1;
	221	pModPE = (PKLDRMODPE)kHlpAlloc(cb);
	222	if (!pModPE)
	223	return KERR_NO_MEMORY;
	224	*ppModPE = pModPE;
	225
	226	/* KLDRMOD */
	227	pMod = (PKLDRMOD)((KU8 *)pModPE + K_ALIGN_Z(K_OFFSETOF(KLDRMODPE, aShdrs[s.FileHdr.NumberOfSections]), 16));
	228	pMod->pvData = pModPE;
	229	pMod->pRdr = pRdr;
	230	pMod->pOps = NULL; /* set upon success. */
	231	pMod->cSegments = s.FileHdr.NumberOfSections + 1;
	232	pMod->cchFilename = cchFilename;
	233	pMod->pszFilename = (char *)&pMod->aSegments[pMod->cSegments];
	234	kHlpMemCopy((char *)pMod->pszFilename, kRdrName(pRdr), cchFilename + 1);
	235	pMod->pszName = kHlpGetFilename(pMod->pszFilename);
	236	pMod->cchName = cchFilename - (pMod->pszName - pMod->pszFilename);
[58]	237	pMod->fFlags = 0;
[2]	238	switch (s.FileHdr.Machine)
	239	{
	240	case IMAGE_FILE_MACHINE_I386:
	241	pMod->enmCpu = KCPU_I386;
	242	pMod->enmArch = KCPUARCH_X86_32;
	243	pMod->enmEndian = KLDRENDIAN_LITTLE;
	244	break;
	245
	246	case IMAGE_FILE_MACHINE_AMD64:
	247	pMod->enmCpu = KCPU_K8;
	248	pMod->enmArch = KCPUARCH_AMD64;
	249	pMod->enmEndian = KLDRENDIAN_LITTLE;
	250	break;
	251	default:
	252	kHlpAssert(0);
	253	break;
	254	}
	255	pMod->enmFmt = KLDRFMT_PE;
	256	if (s.FileHdr.Characteristics & IMAGE_FILE_DLL)
	257	pMod->enmType = !(s.FileHdr.Characteristics & IMAGE_FILE_RELOCS_STRIPPED)
	258	? KLDRTYPE_SHARED_LIBRARY_RELOCATABLE
	259	: KLDRTYPE_SHARED_LIBRARY_FIXED;
	260	else
	261	pMod->enmType = !(s.FileHdr.Characteristics & IMAGE_FILE_RELOCS_STRIPPED)
	262	? KLDRTYPE_EXECUTABLE_RELOCATABLE
	263	: KLDRTYPE_EXECUTABLE_FIXED;
	264	pMod->u32Magic = 0; /* set upon success. */
	265
	266	/* KLDRMODPE */
	267	pModPE->pMod = pMod;
	268	pModPE->pvBits = NULL;
	269	pModPE->pvMapping = NULL;
	270	pModPE->f32Reserved = 0;
	271	pModPE->cImportModules = ~(KU32)0;
	272	pModPE->offHdrs = offNewHdr >= 0 ? offNewHdr : 0;
	273	pModPE->Hdrs.Signature = s.Signature;
	274	pModPE->Hdrs.FileHeader = s.FileHdr;
	275
	276	/*
	277	* Read the optional header and the section table.
	278	*/
	279	off = pModPE->offHdrs + sizeof(pModPE->Hdrs.Signature) + sizeof(pModPE->Hdrs.FileHeader);
	280	rc = kRdrRead(pRdr, &pModPE->Hdrs.OptionalHeader, pModPE->Hdrs.FileHeader.SizeOfOptionalHeader, off);
	281	if (rc)
	282	return rc;
	283	if (pModPE->Hdrs.FileHeader.SizeOfOptionalHeader != sizeof(pModPE->Hdrs.OptionalHeader))
	284	kldrModPEDoOptionalHeaderConversion(&pModPE->Hdrs.OptionalHeader);
	285	off += pModPE->Hdrs.FileHeader.SizeOfOptionalHeader;
	286	rc = kRdrRead(pRdr, &pModPE->aShdrs[0], sizeof(IMAGE_SECTION_HEADER) * pModPE->Hdrs.FileHeader.NumberOfSections, off);
	287	if (rc)
	288	return rc;
	289
	290	/*
	291	* Validate the two.
	292	*/
	293	rc = kLdrModPEDoOptionalHeaderValidation(pModPE);
	294	if (rc)
	295	return rc;
	296	for (i = 0; i < pModPE->Hdrs.FileHeader.NumberOfSections; i++)
	297	{
	298	rc = kLdrModPEDoSectionHeadersValidation(pModPE);
	299	if (rc)
	300	return rc;
	301	}
	302
	303	/*
	304	* Setup the KLDRMOD segment array.
	305	*/
	306	/* The implied headers section. */
	307	pMod->aSegments[0].pvUser = NULL;
	308	pMod->aSegments[0].pchName = "TheHeaders";
	309	pMod->aSegments[0].cchName = sizeof("TheHeaders") - 1;
	310	pMod->aSegments[0].enmProt = KPROT_READONLY;
	311	pMod->aSegments[0].cb = pModPE->Hdrs.OptionalHeader.SizeOfHeaders;
	312	pMod->aSegments[0].Alignment = pModPE->Hdrs.OptionalHeader.SectionAlignment;
	313	pMod->aSegments[0].LinkAddress = pModPE->Hdrs.OptionalHeader.ImageBase;
	314	pMod->aSegments[0].offFile = 0;
	315	pMod->aSegments[0].cbFile = pModPE->Hdrs.OptionalHeader.SizeOfHeaders;
	316	pMod->aSegments[0].RVA = 0;
	317	if (pMod->cSegments > 1)
	318	pMod->aSegments[0].cbMapped = pModPE->aShdrs[0].VirtualAddress;
	319	else
	320	pMod->aSegments[0].cbMapped = pModPE->Hdrs.OptionalHeader.SizeOfHeaders;
	321	pMod->aSegments[0].MapAddress = 0;
	322
	323	/* The section headers. */
	324	for (i = 0; i < pModPE->Hdrs.FileHeader.NumberOfSections; i++)
	325	{
	326	const char *pch;
	327
	328	/* unused */
	329	pMod->aSegments[i + 1].pvUser = NULL;
	330	pMod->aSegments[i + 1].MapAddress = 0;
	331	pMod->aSegments[i + 1].SelFlat = 0;
	332	pMod->aSegments[i + 1].Sel16bit = 0;
	333	pMod->aSegments[i + 1].fFlags = 0;
	334
	335	/* name */
	336	pMod->aSegments[i + 1].pchName = pch = (const char *)&pModPE->aShdrs[i].Name[0];
	337	cb = IMAGE_SIZEOF_SHORT_NAME;
	338	while ( cb > 0
	339	&& (pch[cb - 1] == ' ' \|\| pch[cb - 1] == '\0'))
	340	cb--;
	341	pMod->aSegments[i + 1].cchName = cb;
	342
	343	/* size and addresses */
	344	if (!(pModPE->aShdrs[i].Characteristics & IMAGE_SCN_TYPE_NOLOAD))
	345	{
	346	pMod->aSegments[i + 1].cb = pModPE->aShdrs[i].Misc.VirtualSize;
	347	pMod->aSegments[i + 1].LinkAddress = pModPE->aShdrs[i].VirtualAddress
	348	+ pModPE->Hdrs.OptionalHeader.ImageBase;
	349	pMod->aSegments[i + 1].RVA = pModPE->aShdrs[i].VirtualAddress;
	350	pMod->aSegments[i + 1].cbMapped = pModPE->aShdrs[i].Misc.VirtualSize;
	351	if (i + 2 < pMod->cSegments)
	352	pMod->aSegments[i + 1].cbMapped= pModPE->aShdrs[i + 1].VirtualAddress
	353	- pModPE->aShdrs[i].VirtualAddress;
	354	}
	355	else
	356	{
	357	pMod->aSegments[i + 1].cb = 0;
	358	pMod->aSegments[i + 1].cbMapped = 0;
	359	pMod->aSegments[i + 1].LinkAddress = NIL_KLDRADDR;
	360	pMod->aSegments[i + 1].RVA = 0;
	361	}
	362
	363	/* file location */
	364	pMod->aSegments[i + 1].offFile = pModPE->aShdrs[i].PointerToRawData;
	365	pMod->aSegments[i + 1].cbFile = pModPE->aShdrs[i].SizeOfRawData;
	366	if ( pMod->aSegments[i + 1].cbMapped > 0 /* if mapped */
	367	&& (KLDRSIZE)pMod->aSegments[i + 1].cbFile > pMod->aSegments[i + 1].cbMapped)
	368	pMod->aSegments[i + 1].cbFile = pMod->aSegments[i + 1].cbMapped;
	369
	370	/* protection */
	371	switch ( pModPE->aShdrs[i].Characteristics
	372	& (IMAGE_SCN_MEM_SHARED \| IMAGE_SCN_MEM_EXECUTE \| IMAGE_SCN_MEM_READ \| IMAGE_SCN_MEM_WRITE))
	373	{
	374	case 0:
	375	case IMAGE_SCN_MEM_SHARED:
	376	pMod->aSegments[i + 1].enmProt = KPROT_NOACCESS;
	377	break;
	378	case IMAGE_SCN_MEM_READ:
	379	case IMAGE_SCN_MEM_READ \| IMAGE_SCN_MEM_SHARED:
	380	pMod->aSegments[i + 1].enmProt = KPROT_READONLY;
	381	break;
	382	case IMAGE_SCN_MEM_WRITE:
	383	case IMAGE_SCN_MEM_WRITE \| IMAGE_SCN_MEM_READ:
	384	pMod->aSegments[i + 1].enmProt = KPROT_WRITECOPY;
	385	break;
	386	case IMAGE_SCN_MEM_WRITE \| IMAGE_SCN_MEM_SHARED:
	387	case IMAGE_SCN_MEM_WRITE \| IMAGE_SCN_MEM_SHARED \| IMAGE_SCN_MEM_READ:
	388	pMod->aSegments[i + 1].enmProt = KPROT_READWRITE;
	389	break;
	390	case IMAGE_SCN_MEM_EXECUTE:
	391	case IMAGE_SCN_MEM_EXECUTE \| IMAGE_SCN_MEM_SHARED:
	392	pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE;
	393	break;
	394	case IMAGE_SCN_MEM_EXECUTE \| IMAGE_SCN_MEM_READ:
	395	case IMAGE_SCN_MEM_EXECUTE \| IMAGE_SCN_MEM_READ \| IMAGE_SCN_MEM_SHARED:
	396	pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE_READ;
	397	break;
	398	case IMAGE_SCN_MEM_EXECUTE \| IMAGE_SCN_MEM_WRITE:
	399	case IMAGE_SCN_MEM_EXECUTE \| IMAGE_SCN_MEM_WRITE \| IMAGE_SCN_MEM_READ:
	400	pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE_WRITECOPY;
	401	break;
	402	case IMAGE_SCN_MEM_EXECUTE \| IMAGE_SCN_MEM_WRITE \| IMAGE_SCN_MEM_SHARED:
	403	case IMAGE_SCN_MEM_EXECUTE \| IMAGE_SCN_MEM_WRITE \| IMAGE_SCN_MEM_SHARED \| IMAGE_SCN_MEM_READ:
	404	pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE_READWRITE;
	405	break;
	406	}
	407
	408	/* alignment. */
	409	switch (pModPE->aShdrs[i].Characteristics & IMAGE_SCN_ALIGN_MASK)
	410	{
	411	case 0: /* hope this is right... */
	412	pMod->aSegments[i + 1].Alignment = pModPE->Hdrs.OptionalHeader.SectionAlignment;
	413	break;
	414	case IMAGE_SCN_ALIGN_1BYTES: pMod->aSegments[i + 1].Alignment = 1; break;
	415	case IMAGE_SCN_ALIGN_2BYTES: pMod->aSegments[i + 1].Alignment = 2; break;
	416	case IMAGE_SCN_ALIGN_4BYTES: pMod->aSegments[i + 1].Alignment = 4; break;
	417	case IMAGE_SCN_ALIGN_8BYTES: pMod->aSegments[i + 1].Alignment = 8; break;
	418	case IMAGE_SCN_ALIGN_16BYTES: pMod->aSegments[i + 1].Alignment = 16; break;
	419	case IMAGE_SCN_ALIGN_32BYTES: pMod->aSegments[i + 1].Alignment = 32; break;
	420	case IMAGE_SCN_ALIGN_64BYTES: pMod->aSegments[i + 1].Alignment = 64; break;
	421	case IMAGE_SCN_ALIGN_128BYTES: pMod->aSegments[i + 1].Alignment = 128; break;
	422	case IMAGE_SCN_ALIGN_256BYTES: pMod->aSegments[i + 1].Alignment = 256; break;
	423	case IMAGE_SCN_ALIGN_512BYTES: pMod->aSegments[i + 1].Alignment = 512; break;
	424	case IMAGE_SCN_ALIGN_1024BYTES: pMod->aSegments[i + 1].Alignment = 1024; break;
	425	case IMAGE_SCN_ALIGN_2048BYTES: pMod->aSegments[i + 1].Alignment = 2048; break;
	426	case IMAGE_SCN_ALIGN_4096BYTES: pMod->aSegments[i + 1].Alignment = 4096; break;
	427	case IMAGE_SCN_ALIGN_8192BYTES: pMod->aSegments[i + 1].Alignment = 8192; break;
	428	default: kHlpAssert(0); pMod->aSegments[i + 1].Alignment = 0; break;
	429	}
	430	}
	431
	432	/*
	433	* We're done.
	434	*/
	435	*ppModPE = pModPE;
	436	return 0;
	437	}
	438
	439
	440	/**
	441	* Converts a 32-bit optional header to a 64-bit one
	442	*
	443	* @param pOptHdr The optional header to convert.
	444	*/
	445	static void kldrModPEDoOptionalHeaderConversion(PIMAGE_OPTIONAL_HEADER64 pOptHdr)
	446	{
	447	/* volatile everywhere! */
	448	IMAGE_OPTIONAL_HEADER32 volatile pOptHdr32 = (IMAGE_OPTIONAL_HEADER32 volatile )pOptHdr;
	449	IMAGE_OPTIONAL_HEADER64 volatile *pOptHdr64 = pOptHdr;
	450	KU32 volatile *pu32Dst;
	451	KU32 volatile *pu32Src;
	452	KU32 volatile *pu32SrcLast;
	453	KU32 u32;
	454
	455	/* From LoaderFlags and out the difference is 4 * 32-bits. */
	456	pu32Dst = (KU32 *)&pOptHdr64->DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] - 1;
	457	pu32Src = (KU32 *)&pOptHdr32->DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] - 1;
	458	pu32SrcLast = (KU32 *)&pOptHdr32->LoaderFlags;
	459	while (pu32Src >= pu32SrcLast)
	460	pu32Dst-- = pu32Src--;
	461
	462	/* The previous 4 fields are 32/64 and needs special attention. */
	463	pOptHdr64->SizeOfHeapCommit = pOptHdr32->SizeOfHeapCommit;
	464	pOptHdr64->SizeOfHeapReserve = pOptHdr32->SizeOfHeapReserve;
	465	pOptHdr64->SizeOfStackCommit = pOptHdr32->SizeOfStackCommit;
	466	u32 = pOptHdr32->SizeOfStackReserve;
	467	pOptHdr64->SizeOfStackReserve = u32;
	468
	469	/*
	470	* The rest matches except for BaseOfData which has been merged into ImageBase in the 64-bit version.
	471	* Thus, ImageBase needs some special treatement. It will probably work fine assigning one to the
	472	* other since this is all declared volatile, but taking now chances, we'll use a temp variable.
	473	*/
	474	u32 = pOptHdr32->ImageBase;
	475	pOptHdr64->ImageBase = u32;
	476	}
	477
	478
	479	#if 0
	480	/**
	481	* Converts a 32-bit load config directory to a 64 bit one.
	482	*
	483	* @param pOptHdr The load config to convert.
	484	*/
	485	static void kldrModPEDoLoadConfigConversion(PIMAGE_LOAD_CONFIG_DIRECTORY64 pLoadCfg)
	486	{
	487	/* volatile everywhere! */
	488	IMAGE_LOAD_CONFIG_DIRECTORY32 volatile pLoadCfg32 = (IMAGE_LOAD_CONFIG_DIRECTORY32 volatile )pLoadCfg;
	489	IMAGE_LOAD_CONFIG_DIRECTORY64 volatile *pLoadCfg64 = pLoadCfg;
	490	KU32 u32;
	491
	492	pLoadCfg64->SEHandlerCount = pLoadCfg32->SEHandlerCount;
	493	pLoadCfg64->SEHandlerTable = pLoadCfg32->SEHandlerTable;
	494	pLoadCfg64->SecurityCookie = pLoadCfg32->SecurityCookie;
	495	pLoadCfg64->EditList = pLoadCfg32->EditList;
	496	pLoadCfg64->Reserved1 = pLoadCfg32->Reserved1;
	497	pLoadCfg64->CSDVersion = pLoadCfg32->CSDVersion;
	498	/* (ProcessHeapFlags switched place with ProcessAffinityMask, but we're
	499	* more than 16 byte off by now so it doesn't matter.) */
	500	pLoadCfg64->ProcessHeapFlags = pLoadCfg32->ProcessHeapFlags;
	501	pLoadCfg64->ProcessAffinityMask = pLoadCfg32->ProcessAffinityMask;
	502	pLoadCfg64->VirtualMemoryThreshold = pLoadCfg32->VirtualMemoryThreshold;
	503	pLoadCfg64->MaximumAllocationSize = pLoadCfg32->MaximumAllocationSize;
	504	pLoadCfg64->LockPrefixTable = pLoadCfg32->LockPrefixTable;
	505	pLoadCfg64->DeCommitTotalFreeThreshold = pLoadCfg32->DeCommitTotalFreeThreshold;
	506	u32 = pLoadCfg32->DeCommitFreeBlockThreshold;
	507	pLoadCfg64->DeCommitFreeBlockThreshold = u32;
	508	/* the remainder matches. */
	509	}
	510	#endif
	511
	512
	513	/**
	514	* Internal worker which validates the section headers.
	515	*/
	516	static int kLdrModPEDoOptionalHeaderValidation(PKLDRMODPE pModPE)
	517	{
	518	const unsigned fIs32Bit = pModPE->Hdrs.FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32);
	519
	520	/* the magic */
	521	if ( pModPE->Hdrs.OptionalHeader.Magic
	522	!= (fIs32Bit ? IMAGE_NT_OPTIONAL_HDR32_MAGIC : IMAGE_NT_OPTIONAL_HDR64_MAGIC))
	523	return KLDR_ERR_PE_BAD_OPTIONAL_HEADER;
	524
	525	/** @todo validate more */
	526	return 0;
	527	}
	528
	529
	530	/**
	531	* Internal worker which validates the section headers.
	532	*/
	533	static int kLdrModPEDoSectionHeadersValidation(PKLDRMODPE pModPE)
	534	{
	535	/** @todo validate shdrs */
[79]	536	K_NOREF(pModPE);
[2]	537	return 0;
	538	}
	539
	540
	541	/** @copydoc KLDRMODOPS::pfnDestroy */
	542	static int kldrModPEDestroy(PKLDRMOD pMod)
	543	{
	544	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	545	int rc = 0;
	546	KLDRMODPE_ASSERT(!pModPE->pvMapping);
	547
	548	if (pMod->pRdr)
	549	{
	550	rc = kRdrClose(pMod->pRdr);
	551	pMod->pRdr = NULL;
	552	}
	553	pMod->u32Magic = 0;
	554	pMod->pOps = NULL;
	555	kHlpFree(pModPE);
	556	return rc;
	557	}
	558
	559
	560	/**
	561	* Performs the mapping of the image.
	562	*
	563	* This can be used to do the internal mapping as well as the
	564	* user requested mapping. fForReal indicates which is desired.
	565	*
	566	* @returns 0 on success, non-zero OS or kLdr status code on failure.
	567	* @param pModPE The interpreter module instance
	568	* @param fForReal If set, do the user mapping. if clear, do the internal mapping.
	569	*/
	570	static int kldrModPEDoMap(PKLDRMODPE pModPE, unsigned fForReal)
	571	{
	572	PKLDRMOD pMod = pModPE->pMod;
	573	KBOOL fFixed;
	574	void *pvBase;
	575	int rc;
	576	KU32 i;
	577
	578	/*
	579	* Map it.
	580	*/
	581	/* fixed image? */
	582	fFixed = fForReal
	583	&& ( pMod->enmType == KLDRTYPE_EXECUTABLE_FIXED
	584	\|\| pMod->enmType == KLDRTYPE_SHARED_LIBRARY_FIXED);
	585	if (!fFixed)
	586	pvBase = NULL;
	587	else
	588	{
	589	pvBase = (void *)(KUPTR)pMod->aSegments[0].LinkAddress;
	590	if ((KUPTR)pvBase != pMod->aSegments[0].LinkAddress)
	591	return KLDR_ERR_ADDRESS_OVERFLOW;
	592	}
	593
	594	/* try do the prepare */
	595	rc = kRdrMap(pMod->pRdr, &pvBase, pMod->cSegments, pMod->aSegments, fFixed);
	596	if (rc)
	597	return rc;
	598
	599	/*
	600	* Update the segments with their map addresses.
	601	*/
	602	if (fForReal)
	603	{
	604	for (i = 0; i < pMod->cSegments; i++)
	605	{
	606	if (pMod->aSegments[i].RVA != NIL_KLDRADDR)
	607	pMod->aSegments[i].MapAddress = (KUPTR)pvBase + (KUPTR)pMod->aSegments[i].RVA;
	608	}
	609	pModPE->pvMapping = pvBase;
	610	}
	611	else
	612	pModPE->pvBits = pvBase;
	613	return 0;
	614	}
	615
	616
	617	/**
	618	* Unmaps a image mapping.
	619	*
	620	* This can be used to do the internal mapping as well as the
	621	* user requested mapping. fForReal indicates which is desired.
	622	*
	623	* @returns 0 on success, non-zero OS or kLdr status code on failure.
	624	* @param pModPE The interpreter module instance
	625	* @param pvMapping The mapping to unmap.
	626	*/
	627	static int kldrModPEDoUnmap(PKLDRMODPE pModPE, const void *pvMapping)
	628	{
	629	PKLDRMOD pMod = pModPE->pMod;
	630	int rc;
	631	KU32 i;
	632
	633	/*
	634	* Try unmap the image.
	635	*/
	636	rc = kRdrUnmap(pMod->pRdr, (void *)pvMapping, pMod->cSegments, pMod->aSegments);
	637	if (rc)
	638	return rc;
	639
	640	/*
	641	* Update the segments to reflect that they aren't mapped any longer.
	642	*/
	643	if (pModPE->pvMapping == pvMapping)
	644	{
	645	pModPE->pvMapping = NULL;
	646	for (i = 0; i < pMod->cSegments; i++)
	647	pMod->aSegments[i].MapAddress = 0;
	648	}
	649	if (pModPE->pvBits == pvMapping)
	650	pModPE->pvBits = NULL;
	651
	652	return 0;
	653	}
	654
	655
	656	/**
	657	* Gets usable bits and the right base address.
	658	*
	659	* @returns 0 on success.
	660	* @returns A non-zero status code if the BaseAddress isn't right or some problem is encountered
	661	* featch in a temp mapping the bits.
	662	* @param pModPE The interpreter module instance
	663	* @param ppvBits The bits address, IN & OUT.
	664	* @param pBaseAddress The base address, IN & OUT. Optional.
	665	*/
	666	static int kldrModPEBitsAndBaseAddress(PKLDRMODPE pModPE, const void **ppvBits, PKLDRADDR pBaseAddress)
	667	{
	668	int rc = 0;
	669
	670	/*
	671	* Correct the base address.
	672	*
	673	* We don't use the base address for interpreting the bits in this
	674	* interpreter, which makes things relativly simple.
	675	*/
	676	if (pBaseAddress)
	677	{
	678	if (*pBaseAddress == KLDRMOD_BASEADDRESS_MAP)
	679	*pBaseAddress = pModPE->pMod->aSegments[0].MapAddress;
	680	else if (*pBaseAddress == KLDRMOD_BASEADDRESS_LINK)
	681	*pBaseAddress = pModPE->Hdrs.OptionalHeader.ImageBase;
	682	}
	683
	684	/*
	685	* Get bits.
	686	*/
	687	if (ppvBits && !*ppvBits)
	688	{
	689	if (pModPE->pvMapping)
	690	*ppvBits = pModPE->pvMapping;
	691	else if (pModPE->pvBits)
	692	*ppvBits = pModPE->pvBits;
	693	else
	694	{
	695	/* create an internal mapping. */
	696	rc = kldrModPEDoMap(pModPE, 0 /* not for real */);
	697	if (rc)
	698	return rc;
	699	KLDRMODPE_ASSERT(pModPE->pvBits);
	700	*ppvBits = pModPE->pvBits;
	701	}
	702	}
	703
	704	return 0;
	705	}
	706
	707
	708	/** @copydoc kLdrModQuerySymbol */
	709	static int kldrModPEQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 iSymbol,
	710	const char pchSymbol, KSIZE cchSymbol, const char pszVersion,
	711	PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser, PKLDRADDR puValue, KU32 pfKind)
	712
	713	{
	714	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	715	const KU32 *paExportRVAs;
	716	const IMAGE_EXPORT_DIRECTORY *pExpDir;
	717	KU32 iExpOrd;
	718	KU32 uRVA;
	719	int rc;
	720
	721	/*
	722	* Make sure we've got mapped bits and resolve any base address aliases.
	723	*/
	724	rc = kldrModPEBitsAndBaseAddress(pModPE, &pvBits, &BaseAddress);
	725	if (rc)
	726	return rc;
	727	if ( pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size
	728	< sizeof(IMAGE_EXPORT_DIRECTORY))
	729	return KLDR_ERR_SYMBOL_NOT_FOUND;
	730	if (pszVersion && *pszVersion)
	731	return KLDR_ERR_SYMBOL_NOT_FOUND;
	732
	733	pExpDir = KLDRMODPE_RVA2TYPE(pvBits,
	734	pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress,
	735	PIMAGE_EXPORT_DIRECTORY);
	736	if (!pchSymbol)
	737	{
	738	/*
	739	* Simple, calculate the unbased ordinal and bounds check it.
	740	*/
	741	iExpOrd = iSymbol - pExpDir->Base;
	742	if (iExpOrd >= K_MAX(pExpDir->NumberOfNames, pExpDir->NumberOfFunctions))
	743	return KLDR_ERR_SYMBOL_NOT_FOUND;
	744	}
	745	else
	746	{
	747	/*
	748	* Do a binary search for the name.
	749	* (The name table is sorted in ascending ordered by the linker.)
	750	*/
	751	const KU32 paRVANames = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNames, const KU32 );
	752	const KU16 paOrdinals = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNameOrdinals, const KU16 );
	753	KI32 iStart = 1; /* one based binary searching is simpler. */
	754	KI32 iEnd = pExpDir->NumberOfNames;
	755
	756	for (;;)
	757	{
	758	KI32 i;
	759	int diff;
	760	const char *pszName;
	761
	762	/* done? */
	763	if (iStart > iEnd)
	764	{
	765	#ifdef KLDRMODPE_STRICT /* Make sure the linker and we both did our job right. */
	766	for (i = 0; i < (KI32)pExpDir->NumberOfNames; i++)
	767
	768	{
	769	pszName = KLDRMODPE_RVA2TYPE(pvBits, paRVANames[i], const char *);
	770	KLDRMODPE_ASSERT(kHlpStrNComp(pszName, pchSymbol, cchSymbol) \|\| pszName[cchSymbol]);
	771	KLDRMODPE_ASSERT(i == 0 \|\| kHlpStrComp(pszName, KLDRMODPE_RVA2TYPE(pvBits, paRVANames[i - 1], const char *)));
	772	}
	773	#endif
	774	return KLDR_ERR_SYMBOL_NOT_FOUND;
	775	}
	776
	777	i = (iEnd - iStart) / 2 + iStart;
	778	pszName = KLDRMODPE_RVA2TYPE(pvBits, paRVANames[i - 1], const char *);
	779	diff = kHlpStrNComp(pszName, pchSymbol, cchSymbol);
	780	if (!diff)
	781	diff = pszName[cchSymbol] - 0;
	782	if (diff < 0)
	783	iStart = i + 1; /* The symbol must be after the current name. */
	784	else if (diff)
	785	iEnd = i - 1; /* The symbol must be before the current name. */
	786	else
	787	{
	788	iExpOrd = paOrdinals[i - 1]; /* match! */
	789	break;
	790	}
	791	}
	792	}
	793
	794	/*
	795	* Lookup the address in the 'symbol' table.
	796	*/
	797	paExportRVAs = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfFunctions, const KU32 *);
	798	uRVA = paExportRVAs[iExpOrd];
	799	if ( uRVA - pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress
	800	< pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size)
	801	return kldrModPEDoForwarderQuery(pModPE, pvBits, KLDRMODPE_RVA2TYPE(pvBits, uRVA, const char *),
	802	pfnGetForwarder, pvUser, puValue, pfKind);
	803
	804	/*
	805	* Set the return value.
	806	*/
	807	if (puValue)
	808	*puValue = BaseAddress + uRVA;
	809	if (pfKind)
	810	*pfKind = (pModPE->Hdrs.FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32)
	811	? KLDRSYMKIND_32BIT : KLDRSYMKIND_64BIT)
	812	\| KLDRSYMKIND_NO_TYPE;
	813	return 0;
	814	}
	815
	816
	817	/**
	818	* Deal with a forwarder entry.
	819	*
	820	* We do this seprately from kldrModPEQuerySymbol because the code is clumsy (as is all PE code
	821	* thanks to the descriptive field names), and because it uses quite a bit more stack and we're
	822	* trying to avoid allocating stack unless we have to.
	823	*
	824	* @returns See kLdrModQuerySymbol.
	825	* @param pModPE The PE module interpreter instance.
	826	* @param pvBits Where to read the image from.
	827	* @param pszForwarder The forwarder entry name.
	828	* @param pfnGetForwarder The callback for resolving forwarder symbols. (optional)
	829	* @param pvUser The user argument for the callback.
	830	* @param puValue Where to put the value. (optional)
	831	* @param pfKind Where to put the symbol kind. (optional)
	832	*/
	833	static int kldrModPEDoForwarderQuery(PKLDRMODPE pModPE, const void pvBits, const char pszForwarder,
	834	PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser, PKLDRADDR puValue, KU32 pfKind)
	835	{
	836	const IMAGE_IMPORT_DESCRIPTOR *paImpDir;
	837	KU32 iImpModule;
	838	KU32 cchImpModule;
	839	const char *pszSymbol;
	840	KU32 iSymbol;
	841	int rc;
	842
	843	if (!pfnGetForwarder)
	844	return KLDR_ERR_FORWARDER_SYMBOL;
	845
	846	/*
	847	* Separate the name into a module name and a symbol name or ordinal.
	848	*
	849	* The module name ends at the first dot ('.').
	850	* After the dot follows either a symbol name or a hash ('#') + ordinal.
	851	*/
	852	pszSymbol = pszForwarder;
	853	while (*pszSymbol != '.')
	854	pszSymbol++;
	855	if (!*pszSymbol)
	856	return KLDR_ERR_PE_BAD_FORWARDER;
	857	cchImpModule = pszSymbol - pszForwarder;
	858
	859	pszSymbol++; /* skip the dot */
	860	if (!*pszSymbol)
	861	return KLDR_ERR_PE_BAD_FORWARDER;
	862	if (*pszSymbol == '#')
	863	{
	864	unsigned uBase;
	865	pszSymbol++; /* skip the hash */
	866
	867	/* base detection */
	868	uBase = 10;
	869	if (pszSymbol[0] == '0' && (pszSymbol[1] == 'x' \|\| pszSymbol[1] == 'X'))
	870	{
	871	uBase = 16;
	872	pszSymbol += 2;
	873	}
	874
	875	/* ascii to integer */
	876	iSymbol = 0;
	877	for (;;)
	878	{
	879	/* convert char to digit. */
	880	unsigned uDigit = *pszSymbol++;
	881	if (uDigit >= '0' && uDigit <= '9')
	882	uDigit -= '0';
	883	else if (uDigit >= 'a' && uDigit <= 'z')
	884	uDigit -= 'a' + 10;
	885	else if (uDigit >= 'A' && uDigit <= 'Z')
	886	uDigit -= 'A' + 10;
	887	else if (!uDigit)
	888	break;
	889	else
	890	return KLDR_ERR_PE_BAD_FORWARDER;
	891	if (uDigit >= uBase)
	892	return KLDR_ERR_PE_BAD_FORWARDER;
	893
	894	/* insert the digit */
	895	iSymbol *= uBase;
	896	iSymbol += uDigit;
	897	}
	898
	899	pszSymbol = NULL; /* no symbol name. */
	900	}
	901	else
	902	iSymbol = NIL_KLDRMOD_SYM_ORDINAL; /* no ordinal number. */
	903
	904
	905	/*
	906	* Find the import module name.
	907	*
	908	* We ASSUME the linker will make sure there is an import
	909	* entry for the module... not sure if this is right though.
	910	*/
	911	if ( !pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size
	912	\|\| !pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress)
	913	return KLDR_ERR_PE_FORWARDER_IMPORT_NOT_FOUND;
	914	paImpDir = KLDRMODPE_RVA2TYPE(pvBits,
	915	pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress,
	916	const IMAGE_IMPORT_DESCRIPTOR *);
	917
	918	kldrModPENumberOfImports(pModPE->pMod, pvBits);
	919	for (iImpModule = 0; iImpModule < pModPE->cImportModules; iImpModule++)
	920	{
	921	const char pszName = KLDRMODPE_RVA2TYPE(pvBits, paImpDir[iImpModule].Name, const char );
	922	KSIZE cchName = kHlpStrLen(pszName);
	923	if ( ( cchName == cchImpModule
	924	\|\| ( cchName > cchImpModule
	925	&& pszName[cchImpModule] == '.'
	926	&& (pszName[cchImpModule + 1] == 'd' \|\| pszName[cchImpModule + 1] == 'D')
	927	&& (pszName[cchImpModule + 2] == 'l' \|\| pszName[cchImpModule + 2] == 'L')
	928	&& (pszName[cchImpModule + 3] == 'l' \|\| pszName[cchImpModule + 3] == 'L'))
	929	)
	930	&& kHlpMemICompAscii(pszName, pszForwarder, cchImpModule)
	931	)
	932	{
	933	/*
	934	* Now the rest is up to the callback (almost).
	935	*/
	936	rc = pfnGetForwarder(pModPE->pMod, iImpModule, iSymbol, pszSymbol,
	937	pszSymbol ? kHlpStrLen(pszSymbol) : 0, NULL, puValue, pfKind, pvUser);
	938	if (!rc && pfKind)
	939	*pfKind \|= KLDRSYMKIND_FORWARDER;
	940	return rc;
	941	}
	942	}
	943	return KLDR_ERR_PE_FORWARDER_IMPORT_NOT_FOUND;
	944	}
	945
	946
	947	/** @copydoc kLdrModEnumSymbols */
	948	static int kldrModPEEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
	949	KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
	950	{
	951	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	952	const KU32 *paFunctions;
	953	const IMAGE_EXPORT_DIRECTORY *pExpDir;
	954	const KU32 *paRVANames;
	955	const KU16 *paOrdinals;
	956	KU32 iFunction;
	957	KU32 cFunctions;
	958	KU32 cNames;
	959	int rc;
[79]	960	K_NOREF(fFlags);
[2]	961
	962	/*
	963	* Make sure we've got mapped bits and resolve any base address aliases.
	964	*/
	965	rc = kldrModPEBitsAndBaseAddress(pModPE, &pvBits, &BaseAddress);
	966	if (rc)
	967	return rc;
	968
	969	if ( pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size
	970	< sizeof(IMAGE_EXPORT_DIRECTORY))
	971	return 0; /* no exports to enumerate, return success. */
	972
	973	pExpDir = KLDRMODPE_RVA2TYPE(pvBits,
	974	pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress,
	975	PIMAGE_EXPORT_DIRECTORY);
	976
	977	/*
	978	* Enumerate the ordinal exports.
	979	*/
	980	paRVANames = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNames, const KU32 *);
	981	paOrdinals = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfNameOrdinals, const KU16 *);
	982	paFunctions = KLDRMODPE_RVA2TYPE(pvBits, pExpDir->AddressOfFunctions, const KU32 *);
	983	cFunctions = pExpDir->NumberOfFunctions;
	984	cNames = pExpDir->NumberOfNames;
	985	for (iFunction = 0; iFunction < cFunctions; iFunction++)
	986	{
	987	unsigned fFoundName;
	988	KU32 iName;
	989	const KU32 uRVA = paFunctions[iFunction];
	990	const KLDRADDR uValue = BaseAddress + uRVA;
	991	KU32 fKind = (pModPE->Hdrs.FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32)
	992	? KLDRSYMKIND_32BIT : KLDRSYMKIND_64BIT)
	993	\| KLDRSYMKIND_NO_TYPE;
	994	if ( uRVA - pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress
	995	< pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size)
	996	fKind \|= KLDRSYMKIND_FORWARDER;
	997
	998	/*
	999	* Any symbol names?
	1000	*/
	1001	fFoundName = 0;
	1002	for (iName = 0; iName < cNames; iName++)
	1003	{
	1004	const char *pszName;
	1005	if (paOrdinals[iName] != iFunction)
	1006	continue;
	1007	fFoundName = 1;
	1008	pszName = KLDRMODPE_RVA2TYPE(pvBits, paRVANames[iName], const char *);
	1009	rc = pfnCallback(pMod, iFunction + pExpDir->Base, pszName, kHlpStrLen(pszName), NULL,
	1010	uValue, fKind, pvUser);
	1011	if (rc)
	1012	return rc;
	1013	}
	1014
	1015	/*
	1016	* If no names, call once with the ordinal only.
	1017	*/
	1018	if (!fFoundName)
	1019	{
	1020	rc = pfnCallback(pMod, iFunction + pExpDir->Base, NULL, 0, NULL, uValue, fKind, pvUser);
	1021	if (rc)
	1022	return rc;
	1023	}
	1024	}
	1025
	1026	return 0;
	1027	}
	1028
	1029
	1030	/** @copydoc kLdrModGetImport */
	1031	static int kldrModPEGetImport(PKLDRMOD pMod, const void pvBits, KU32 iImport, char pszName, KSIZE cchName)
	1032	{
	1033	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1034	const IMAGE_IMPORT_DESCRIPTOR *pImpDesc;
	1035	const char *pszImportName;
	1036	KSIZE cchImportName;
	1037	int rc;
	1038
	1039	/*
	1040	* Make sure we've got mapped bits and resolve any base address aliases.
	1041	*/
	1042	rc = kldrModPEBitsAndBaseAddress(pModPE, &pvBits, NULL);
	1043	if (rc)
	1044	return rc;
	1045
	1046	/*
	1047	* Simple bounds check.
	1048	*/
	1049	if (iImport >= (KU32)kldrModPENumberOfImports(pMod, pvBits))
	1050	return KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS;
	1051
	1052	/*
	1053	* Get the name.
	1054	*/
	1055	pImpDesc = KLDRMODPE_RVA2TYPE(pvBits,
	1056	pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress
	1057	+ sizeof(IMAGE_IMPORT_DESCRIPTOR) * iImport,
	1058	const IMAGE_IMPORT_DESCRIPTOR *);
	1059	pszImportName = KLDRMODPE_RVA2TYPE(pvBits, pImpDesc->Name, const char *);
	1060	cchImportName = kHlpStrLen(pszImportName);
	1061	if (cchImportName < cchName)
	1062	{
	1063	kHlpMemCopy(pszName, pszImportName, cchImportName + 1);
	1064	rc = 0;
	1065	}
	1066	else
	1067	{
	1068	kHlpMemCopy(pszName, pszImportName, cchName);
	1069	if (cchName)
	1070	pszName[cchName - 1] = '\0';
	1071	rc = KERR_BUFFER_OVERFLOW;
	1072	}
	1073
	1074	return rc;
	1075	}
	1076
	1077
	1078	/** @copydoc kLdrModNumberOfImports */
	1079	static KI32 kldrModPENumberOfImports(PKLDRMOD pMod, const void *pvBits)
	1080	{
	1081	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1082	if (pModPE->cImportModules == ~(KU32)0)
	1083	{
	1084	/*
	1085	* We'll have to walk the import descriptors to figure out their number.
	1086	* First, make sure we've got mapped bits.
	1087	*/
	1088	if (kldrModPEBitsAndBaseAddress(pModPE, &pvBits, NULL))
	1089	return -1;
	1090	pModPE->cImportModules = 0;
	1091	if ( pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size
	1092	&& pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress)
	1093	{
	1094	const IMAGE_IMPORT_DESCRIPTOR *pImpDesc;
	1095
	1096	pImpDesc = KLDRMODPE_RVA2TYPE(pvBits,
	1097	pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress,
	1098	const IMAGE_IMPORT_DESCRIPTOR *);
	1099	while (pImpDesc->Name && pImpDesc->FirstThunk)
	1100	{
	1101	pModPE->cImportModules++;
	1102	pImpDesc++;
	1103	}
	1104	}
	1105	}
	1106	return pModPE->cImportModules;
	1107	}
	1108
	1109
	1110	/** @copydoc kLdrModGetStackInfo */
	1111	static int kldrModPEGetStackInfo(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo)
	1112	{
	1113	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
[79]	1114	K_NOREF(pvBits);
	1115	K_NOREF(BaseAddress);
[2]	1116
	1117	pStackInfo->Address = NIL_KLDRADDR;
	1118	pStackInfo->LinkAddress = NIL_KLDRADDR;
	1119	pStackInfo->cbStack = pStackInfo->cbStackThread = pModPE->Hdrs.OptionalHeader.SizeOfStackReserve;
	1120
	1121	return 0;
	1122	}
	1123
	1124
	1125	/** @copydoc kLdrModQueryMainEntrypoint */
	1126	static int kldrModPEQueryMainEntrypoint(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRADDR pMainEPAddress)
	1127	{
	1128	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1129	int rc;
[79]	1130	K_NOREF(pvBits);
[2]	1131
	1132	/*
	1133	* Resolve base address alias if any.
	1134	*/
	1135	rc = kldrModPEBitsAndBaseAddress(pModPE, NULL, &BaseAddress);
	1136	if (rc)
	1137	return rc;
	1138
	1139	/*
	1140	* Convert the address from the header.
	1141	*/
	1142	*pMainEPAddress = pModPE->Hdrs.OptionalHeader.AddressOfEntryPoint
	1143	? BaseAddress + pModPE->Hdrs.OptionalHeader.AddressOfEntryPoint
	1144	: NIL_KLDRADDR;
	1145	return 0;
	1146	}
	1147
	1148
	1149	/** @copydoc kLdrModEnumDbgInfo */
	1150	static int kldrModPEEnumDbgInfo(PKLDRMOD pMod, const void pvBits, PFNKLDRENUMDBG pfnCallback, void pvUser)
	1151	{
	1152	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1153	const IMAGE_DEBUG_DIRECTORY *pDbgDir;
	1154	KU32 iDbgInfo;
	1155	KU32 cb;
	1156	int rc;
	1157
	1158	/*
	1159	* Check that there is a debug directory first.
	1160	*/
	1161	cb = pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size;
	1162	if ( cb < sizeof(IMAGE_DEBUG_DIRECTORY) /* screw borland linkers */
	1163	\|\| !pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress)
	1164	return 0;
	1165
	1166	/*
	1167	* Make sure we've got mapped bits.
	1168	*/
	1169	rc = kldrModPEBitsAndBaseAddress(pModPE, &pvBits, NULL);
	1170	if (rc)
	1171	return rc;
	1172
	1173	/*
	1174	* Enumerate the debug directory.
	1175	*/
	1176	pDbgDir = KLDRMODPE_RVA2TYPE(pvBits,
	1177	pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress,
	1178	const IMAGE_DEBUG_DIRECTORY *);
	1179	for (iDbgInfo = 0;; iDbgInfo++, pDbgDir++, cb -= sizeof(IMAGE_DEBUG_DIRECTORY))
	1180	{
	1181	KLDRDBGINFOTYPE enmDbgInfoType;
	1182
	1183	/* convert the type. */
	1184	switch (pDbgDir->Type)
	1185	{
	1186	case IMAGE_DEBUG_TYPE_UNKNOWN:
	1187	case IMAGE_DEBUG_TYPE_FPO:
	1188	case IMAGE_DEBUG_TYPE_COFF: /stabs dialect??/
	1189	case IMAGE_DEBUG_TYPE_MISC:
	1190	case IMAGE_DEBUG_TYPE_EXCEPTION:
	1191	case IMAGE_DEBUG_TYPE_FIXUP:
	1192	case IMAGE_DEBUG_TYPE_BORLAND:
	1193	default:
	1194	enmDbgInfoType = KLDRDBGINFOTYPE_UNKNOWN;
	1195	break;
	1196	case IMAGE_DEBUG_TYPE_CODEVIEW:
	1197	enmDbgInfoType = KLDRDBGINFOTYPE_CODEVIEW;
	1198	break;
	1199	}
	1200
	1201	rc = pfnCallback(pMod, iDbgInfo,
[41]	1202	enmDbgInfoType, pDbgDir->MajorVersion, pDbgDir->MinorVersion, NULL,
[28]	1203	pDbgDir->PointerToRawData ? (KLDRFOFF)pDbgDir->PointerToRawData : -1,
[2]	1204	pDbgDir->AddressOfRawData ? pDbgDir->AddressOfRawData : NIL_KLDRADDR,
	1205	pDbgDir->SizeOfData,
	1206	NULL,
	1207	pvUser);
	1208	if (rc)
	1209	break;
	1210
	1211	/* next */
	1212	if (cb <= sizeof(IMAGE_DEBUG_DIRECTORY))
	1213	break;
	1214	}
	1215
	1216	return rc;
	1217	}
	1218
	1219
	1220	/** @copydoc kLdrModHasDbgInfo */
	1221	static int kldrModPEHasDbgInfo(PKLDRMOD pMod, const void *pvBits)
	1222	{
	1223	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
[79]	1224	K_NOREF(pvBits);
[2]	1225
	1226	/*
	1227	* Base this entirely on the presence of a debug directory.
	1228	*/
	1229	if ( pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size
	1230	< sizeof(IMAGE_DEBUG_DIRECTORY) /* screw borland linkers */
	1231	\|\| !pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress)
	1232	return KLDR_ERR_NO_DEBUG_INFO;
	1233	return 0;
	1234	}
	1235
	1236
	1237	/** @copydoc kLdrModMap */
	1238	static int kldrModPEMap(PKLDRMOD pMod)
	1239	{
	1240	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1241	int rc;
	1242
	1243	/*
	1244	* Already mapped?
	1245	*/
	1246	if (pModPE->pvMapping)
	1247	return KLDR_ERR_ALREADY_MAPPED;
	1248
	1249	/*
	1250	* We've got a common worker which does this.
	1251	*/
	1252	rc = kldrModPEDoMap(pModPE, 1 /* the real thing */);
	1253	if (rc)
	1254	return rc;
	1255	KLDRMODPE_ASSERT(pModPE->pvMapping);
	1256	return 0;
	1257	}
	1258
	1259
	1260	/** @copydoc kLdrModUnmap */
	1261	static int kldrModPEUnmap(PKLDRMOD pMod)
	1262	{
	1263	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1264	int rc;
	1265
	1266	/*
	1267	* Mapped?
	1268	*/
	1269	if (!pModPE->pvMapping)
	1270	return KLDR_ERR_NOT_MAPPED;
	1271
	1272	/*
	1273	* We've got a common worker which does this.
	1274	*/
	1275	rc = kldrModPEDoUnmap(pModPE, pModPE->pvMapping);
	1276	if (rc)
	1277	return rc;
	1278	KLDRMODPE_ASSERT(!pModPE->pvMapping);
	1279	return 0;
	1280
	1281	}
	1282
	1283
	1284	/** @copydoc kLdrModAllocTLS */
	1285	static int kldrModPEAllocTLS(PKLDRMOD pMod)
	1286	{
	1287	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1288
	1289	/*
	1290	* Mapped?
	1291	*/
	1292	if (!pModPE->pvMapping)
	1293	return KLDR_ERR_NOT_MAPPED;
	1294
	1295	/*
	1296	* If no TLS directory then there is nothing to do.
	1297	*/
	1298	if ( !pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].Size
	1299	\|\| !pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].VirtualAddress)
	1300	return 0;
	1301	/** @todo implement TLS. */
	1302	return -1;
	1303	}
	1304
	1305
	1306	/** @copydoc kLdrModFreeTLS */
	1307	static void kldrModPEFreeTLS(PKLDRMOD pMod)
	1308	{
	1309	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1310
	1311	/*
	1312	* Mapped?
	1313	*/
	1314	if (!pModPE->pvMapping)
	1315	return;
	1316
	1317	/*
	1318	* If no TLS directory then there is nothing to do.
	1319	*/
	1320	if ( !pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].Size
	1321	\|\| !pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].VirtualAddress)
	1322	return;
	1323	/** @todo implement TLS. */
	1324	return;
	1325	}
	1326
	1327
	1328	/** @copydoc kLdrModReload */
	1329	static int kldrModPEReload(PKLDRMOD pMod)
	1330	{
	1331	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1332
	1333	/*
	1334	* Mapped?
	1335	*/
	1336	if (!pModPE->pvMapping)
	1337	return KLDR_ERR_NOT_MAPPED;
	1338
	1339	/* the file provider does it all */
	1340	return kRdrRefresh(pMod->pRdr, (void *)pModPE->pvMapping, pMod->cSegments, pMod->aSegments);
	1341	}
	1342
	1343
	1344	/** @copydoc kLdrModFixupMapping */
	1345	static int kldrModPEFixupMapping(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
	1346	{
	1347	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1348	int rc, rc2;
	1349
	1350	/*
	1351	* Mapped?
	1352	*/
	1353	if (!pModPE->pvMapping)
	1354	return KLDR_ERR_NOT_MAPPED;
	1355
	1356	/*
	1357	* Before doing anything we'll have to make all pages writable.
	1358	*/
	1359	rc = kRdrProtect(pMod->pRdr, (void )pModPE->pvMapping, pMod->cSegments, pMod->aSegments, 1 / unprotect */);
	1360	if (rc)
	1361	return rc;
	1362
	1363	/*
	1364	* Apply base relocations.
	1365	*/
	1366	rc = kldrModPEDoFixups(pModPE, (void *)pModPE->pvMapping, (KUPTR)pModPE->pvMapping,
	1367	pModPE->Hdrs.OptionalHeader.ImageBase);
	1368
	1369	/*
	1370	* Resolve imports.
	1371	*/
	1372	if (!rc)
	1373	rc = kldrModPEDoImports(pModPE, (void *)pModPE->pvMapping, pfnGetImport, pvUser);
	1374
	1375	/*
	1376	* Restore protection.
	1377	*/
	1378	rc2 = kRdrProtect(pMod->pRdr, (void )pModPE->pvMapping, pMod->cSegments, pMod->aSegments, 0 / protect */);
	1379	if (!rc && rc2)
	1380	rc = rc2;
	1381	return rc;
	1382	}
	1383
	1384
	1385	/**
	1386	* Applies base relocations to a (unprotected) image mapping.
	1387	*
	1388	* @returns 0 on success, non-zero kLdr status code on failure.
	1389	* @param pModPE The PE module interpreter instance.
	1390	* @param pvMapping The mapping to fixup.
	1391	* @param NewBaseAddress The address to fixup the mapping to.
	1392	* @param OldBaseAddress The address the mapping is currently fixed up to.
	1393	*/
	1394	static int kldrModPEDoFixups(PKLDRMODPE pModPE, void *pvMapping, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress)
	1395	{
	1396	const KLDRADDR Delta = NewBaseAddress - OldBaseAddress;
	1397	KU32 cbLeft = pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size;
	1398	const IMAGE_BASE_RELOCATION pBR, pFirstBR;
	1399
	1400	/*
	1401	* Don't don anything if the delta is 0 or there aren't any relocations.
	1402	*/
	1403	if ( !Delta
	1404	\|\| !cbLeft
	1405	\|\| !pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress)
	1406	return 0;
	1407
	1408	/*
	1409	* Process the fixups block by block.
	1410	* (These blocks appears to be 4KB on all archs despite the native page size.)
	1411	*/
	1412	pBR = pFirstBR = KLDRMODPE_RVA2TYPE(pvMapping,
	1413	pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress,
	1414	const IMAGE_BASE_RELOCATION *);
	1415	while ( cbLeft > sizeof(IMAGE_BASE_RELOCATION)
	1416	&& pBR->SizeOfBlock >= sizeof(IMAGE_BASE_RELOCATION) /* paranoia */)
	1417	{
	1418	union
	1419	{
	1420	KU8 *pu8;
	1421	KU16 *pu16;
	1422	KU32 *pu32;
	1423	KU64 *pu64;
	1424	} uChunk,
	1425	u;
	1426	const KU16 poffFixup = (const KU16 )(pBR + 1);
	1427	const KU32 cbBlock = K_MIN(cbLeft, pBR->SizeOfBlock) - sizeof(IMAGE_BASE_RELOCATION); /* more caution... */
	1428	KU32 cFixups = cbBlock / sizeof(poffFixup[0]);
	1429	uChunk.pu8 = KLDRMODPE_RVA2TYPE(pvMapping, pBR->VirtualAddress, KU8 *);
	1430
	1431	/*
	1432	* Loop thru the fixups in this chunk.
	1433	*/
	1434	while (cFixups > 0)
	1435	{
	1436	u.pu8 = uChunk.pu8 + (*poffFixup & 0xfff);
	1437	switch (poffFixup >> 12) / ordered by value. */
	1438	{
	1439	/* 0 - Alignment placeholder. */
	1440	case IMAGE_REL_BASED_ABSOLUTE:
	1441	break;
	1442
	1443	/* 1 - 16-bit, add 2nd 16-bit part of the delta. (rare) */
	1444	case IMAGE_REL_BASED_HIGH:
	1445	*u.pu16 += (KU16)(Delta >> 16);
	1446	break;
	1447
	1448	/* 2 - 16-bit, add 1st 16-bit part of the delta. (rare) */
	1449	case IMAGE_REL_BASED_LOW:
	1450	*u.pu16 += (KU16)Delta;
	1451	break;
	1452
	1453	/* 3 - 32-bit, add delta. (frequent in 32-bit images) */
	1454	case IMAGE_REL_BASED_HIGHLOW:
	1455	*u.pu32 += (KU32)Delta;
	1456	break;
	1457
	1458	/* 4 - 16-bit, add 2nd 16-bit of the delta, sign adjust for the lower 16-bit. one arg. (rare) */
	1459	case IMAGE_REL_BASED_HIGHADJ:
	1460	{
	1461	KI32 i32;
	1462	if (cFixups <= 1)
	1463	return KLDR_ERR_PE_BAD_FIXUP;
	1464
	1465	i32 = (KU32)*u.pu16 << 16;
	1466	i32 \|= ++poffFixup; cFixups--; / the addend argument */
	1467	i32 += (KU32)Delta;
	1468	i32 += 0x8000;
	1469	*u.pu16 = (KU16)(i32 >> 16);
	1470	break;
	1471	}
	1472
	1473	/* 5 - 32-bit MIPS JMPADDR, no implemented. */
	1474	case IMAGE_REL_BASED_MIPS_JMPADDR:
	1475	u.pu32 = (u.pu32 & 0xc0000000)
	1476	\| ((KU32)((*u.pu32 << 2) + (KU32)Delta) >> 2);
	1477	break;
	1478
	1479	/* 6 - Intra section? Reserved value in later specs. Not implemented. */
	1480	case IMAGE_REL_BASED_SECTION:
	1481	KLDRMODPE_ASSERT(!"SECTION");
	1482	return KLDR_ERR_PE_BAD_FIXUP;
	1483
	1484	/* 7 - Relative intra section? Reserved value in later specs. Not implemented. */
	1485	case IMAGE_REL_BASED_REL32:
	1486	KLDRMODPE_ASSERT(!"SECTION");
	1487	return KLDR_ERR_PE_BAD_FIXUP;
	1488
	1489	/* 8 - reserved according to binutils... */
	1490	case 8:
	1491	KLDRMODPE_ASSERT(!"RESERVERED8");
	1492	return KLDR_ERR_PE_BAD_FIXUP;
	1493
	1494	/* 9 - IA64_IMM64 (/ MIPS_JMPADDR16), no specs nor need to support the platform yet.
	1495	* Bet this requires more code than all the other fixups put together in good IA64 spirit :-) */
	1496	case IMAGE_REL_BASED_IA64_IMM64:
	1497	KLDRMODPE_ASSERT(!"IA64_IMM64 / MIPS_JMPADDR16");
	1498	return KLDR_ERR_PE_BAD_FIXUP;
	1499
	1500	/* 10 - 64-bit, add delta. (frequently in 64-bit images) */
	1501	case IMAGE_REL_BASED_DIR64:
	1502	*u.pu64 += (KU64)Delta;
	1503	break;
	1504
	1505	/* 11 - 16-bit, add 3rd 16-bit of the delta, sign adjust for the lower 32-bit. two args. (rare) */
	1506	case IMAGE_REL_BASED_HIGH3ADJ:
	1507	{
	1508	KI64 i64;
	1509	if (cFixups <= 2)
	1510	return KLDR_ERR_PE_BAD_FIXUP;
	1511
	1512	i64 = (KU64)*u.pu16 << 32
	1513	\| ((KU32)poffFixup[2] << 16)
	1514	\| poffFixup[1];
	1515	i64 += Delta;
	1516	i64 += 0x80008000UL;
	1517	*u.pu16 = (KU16)(i64 >> 32);
	1518	/* skip the addends arguments */
	1519	poffFixup += 2;
	1520	cFixups -= 2;
	1521	break;
	1522	}
	1523
	1524	/* the rest are yet to be defined.*/
	1525	default:
	1526	return KLDR_ERR_PE_BAD_FIXUP;
	1527	}
	1528
	1529	/*
	1530	* Next relocation.
	1531	*/
	1532	poffFixup++;
	1533	cFixups--;
	1534	}
	1535
	1536
	1537	/*
	1538	* Next block.
	1539	*/
	1540	cbLeft -= pBR->SizeOfBlock;
	1541	pBR = (PIMAGE_BASE_RELOCATION)((KUPTR)pBR + pBR->SizeOfBlock);
	1542	}
	1543
	1544	return 0;
	1545	}
	1546
	1547
	1548
	1549	/**
	1550	* Resolves imports.
	1551	*
	1552	* @returns 0 on success, non-zero kLdr status code on failure.
	1553	* @param pModPE The PE module interpreter instance.
	1554	* @param pvMapping The mapping which imports should be resolved.
	1555	* @param pfnGetImport The callback for resolving an imported symbol.
	1556	* @param pvUser User argument to the callback.
	1557	*/
	1558	static int kldrModPEDoImports(PKLDRMODPE pModPE, void pvMapping, PFNKLDRMODGETIMPORT pfnGetImport, void pvUser)
	1559	{
	1560	const IMAGE_IMPORT_DESCRIPTOR *pImpDesc;
	1561
	1562	/*
	1563	* If no imports, there is nothing to do.
	1564	*/
	1565	kldrModPENumberOfImports(pModPE->pMod, pvMapping);
	1566	if (!pModPE->cImportModules)
	1567	return 0;
	1568
	1569	pImpDesc = KLDRMODPE_RVA2TYPE(pvMapping,
	1570	pModPE->Hdrs.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress,
	1571	const IMAGE_IMPORT_DESCRIPTOR *);
	1572	if (pModPE->Hdrs.FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32))
	1573	return kldrModPEDoImports32Bit(pModPE, pvMapping, pImpDesc, pfnGetImport, pvUser);
	1574	return kldrModPEDoImports64Bit(pModPE, pvMapping, pImpDesc, pfnGetImport, pvUser);
	1575	}
	1576
	1577
	1578	/**
	1579	* Resolves imports, 32-bit image.
	1580	*
	1581	* @returns 0 on success, non-zero kLdr status code on failure.
	1582	* @param pModPE The PE module interpreter instance.
	1583	* @param pvMapping The mapping which imports should be resolved.
	1584	* @param pImpDesc Pointer to the first import descriptor.
	1585	* @param pfnGetImport The callback for resolving an imported symbol.
	1586	* @param pvUser User argument to the callback.
	1587	*/
	1588	static int kldrModPEDoImports32Bit(PKLDRMODPE pModPE, void pvMapping, const IMAGE_IMPORT_DESCRIPTOR pImpDesc,
	1589	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
	1590	{
	1591	PKLDRMOD pMod = pModPE->pMod;
	1592	KU32 iImp;
	1593
	1594	/*
	1595	* Iterate the import descriptors.
	1596	*/
	1597	for (iImp = 0; iImp < pModPE->cImportModules; iImp++, pImpDesc++)
	1598	{
	1599	PIMAGE_THUNK_DATA32 pFirstThunk = KLDRMODPE_RVA2TYPE(pvMapping, pImpDesc->FirstThunk, PIMAGE_THUNK_DATA32);
	1600	const IMAGE_THUNK_DATA32 *pThunk = pImpDesc->u.OriginalFirstThunk
	1601	? KLDRMODPE_RVA2TYPE(pvMapping, pImpDesc->u.OriginalFirstThunk, const IMAGE_THUNK_DATA32 *)
	1602	: KLDRMODPE_RVA2TYPE(pvMapping, pImpDesc->FirstThunk, const IMAGE_THUNK_DATA32 *);
	1603
	1604	/* Iterate the thunks. */
	1605	while (pThunk->u1.Ordinal != 0)
	1606	{
	1607	KLDRADDR Value;
	1608	KU32 fKind = KLDRSYMKIND_REQ_FLAT;
	1609	int rc;
	1610
	1611	/* Ordinal or name import? */
	1612	if (IMAGE_SNAP_BY_ORDINAL32(pThunk->u1.Ordinal))
	1613	rc = pfnGetImport(pMod, iImp, IMAGE_ORDINAL32(pThunk->u1.Ordinal), NULL, 0, NULL, &Value, &fKind, pvUser);
	1614	else if (KLDRMODPE_VALID_RVA(pModPE, pThunk->u1.Ordinal))
	1615	{
	1616	const IMAGE_IMPORT_BY_NAME pName = KLDRMODPE_RVA2TYPE(pvMapping, pThunk->u1.Ordinal, const IMAGE_IMPORT_BY_NAME );
	1617	rc = pfnGetImport(pMod, iImp, NIL_KLDRMOD_SYM_ORDINAL, (const char *)pName->Name,
	1618	kHlpStrLen((const char *)pName->Name), NULL, &Value, &fKind, pvUser);
	1619	}
	1620	else
	1621	{
	1622	KLDRMODPE_ASSERT(!"bad 32-bit import");
	1623	return KLDR_ERR_PE_BAD_IMPORT;
	1624	}
	1625	if (rc)
	1626	return rc;
	1627
	1628	/* Apply it. */
	1629	pFirstThunk->u1.Function = (KU32)Value;
	1630	if (pFirstThunk->u1.Function != Value)
	1631	{
	1632	KLDRMODPE_ASSERT(!"overflow");
	1633	return KLDR_ERR_ADDRESS_OVERFLOW;
	1634	}
	1635
	1636	/* next */
	1637	pThunk++;
	1638	pFirstThunk++;
	1639	}
	1640	}
	1641
	1642	return 0;
	1643	}
	1644
	1645
	1646	/**
	1647	* Resolves imports, 64-bit image.
	1648	*
	1649	* @returns 0 on success, non-zero kLdr status code on failure.
	1650	* @param pModPE The PE module interpreter instance.
	1651	* @param pvMapping The mapping which imports should be resolved.
	1652	* @param pImpDesc Pointer to the first import descriptor.
	1653	* @param pfnGetImport The callback for resolving an imported symbol.
	1654	* @param pvUser User argument to the callback.
	1655	*/
	1656	static int kldrModPEDoImports64Bit(PKLDRMODPE pModPE, void pvMapping, const IMAGE_IMPORT_DESCRIPTOR pImpDesc,
	1657	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
	1658	{
	1659	PKLDRMOD pMod = pModPE->pMod;
	1660	KU32 iImp;
	1661
	1662	/*
	1663	* Iterate the import descriptors.
	1664	*/
	1665	for (iImp = 0; iImp < pModPE->cImportModules; iImp++, pImpDesc++)
	1666	{
	1667	PIMAGE_THUNK_DATA64 pFirstThunk = KLDRMODPE_RVA2TYPE(pvMapping, pImpDesc->FirstThunk, PIMAGE_THUNK_DATA64);
	1668	const IMAGE_THUNK_DATA64 *pThunk = pImpDesc->u.OriginalFirstThunk
	1669	? KLDRMODPE_RVA2TYPE(pvMapping, pImpDesc->u.OriginalFirstThunk, const IMAGE_THUNK_DATA64 *)
	1670	: KLDRMODPE_RVA2TYPE(pvMapping, pImpDesc->FirstThunk, const IMAGE_THUNK_DATA64 *);
	1671
	1672	/* Iterate the thunks. */
	1673	while (pThunk->u1.Ordinal != 0)
	1674	{
	1675	KLDRADDR Value;
	1676	KU32 fKind = KLDRSYMKIND_REQ_FLAT;
	1677	int rc;
	1678
	1679	/* Ordinal or name import? */
	1680	if (IMAGE_SNAP_BY_ORDINAL64(pThunk->u1.Ordinal))
	1681	rc = pfnGetImport(pMod, iImp, (KU32)IMAGE_ORDINAL64(pThunk->u1.Ordinal), NULL, 0, NULL, &Value, &fKind, pvUser);
	1682	else if (KLDRMODPE_VALID_RVA(pModPE, pThunk->u1.Ordinal))
	1683	{
	1684	const IMAGE_IMPORT_BY_NAME pName = KLDRMODPE_RVA2TYPE(pvMapping, pThunk->u1.Ordinal, const IMAGE_IMPORT_BY_NAME );
	1685	rc = pfnGetImport(pMod, iImp, NIL_KLDRMOD_SYM_ORDINAL, (const char *)pName->Name,
	1686	kHlpStrLen((const char *)pName->Name), NULL, &Value, &fKind, pvUser);
	1687	}
	1688	else
	1689	{
	1690	KLDRMODPE_ASSERT(!"bad 64-bit import");
	1691	return KLDR_ERR_PE_BAD_IMPORT;
	1692	}
	1693	if (rc)
	1694	return rc;
	1695
	1696	/* Apply it. */
	1697	pFirstThunk->u1.Function = Value;
	1698
	1699	/* next */
	1700	pThunk++;
	1701	pFirstThunk++;
	1702	}
	1703	}
	1704
	1705	return 0;
	1706	}
	1707
	1708
	1709
	1710	/** @copydoc kLdrModCallInit */
	1711	static int kldrModPECallInit(PKLDRMOD pMod, KUPTR uHandle)
	1712	{
	1713	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1714	int rc;
	1715
	1716	/*
	1717	* Mapped?
	1718	*/
	1719	if (!pModPE->pvMapping)
	1720	return KLDR_ERR_NOT_MAPPED;
	1721
	1722	/*
	1723	* Do TLS callbacks first and then call the init/term function if it's a DLL.
	1724	*/
	1725	rc = kldrModPEDoCallTLS(pModPE, DLL_PROCESS_ATTACH, uHandle);
	1726	if ( !rc
	1727	&& (pModPE->Hdrs.FileHeader.Characteristics & IMAGE_FILE_DLL))
	1728	{
	1729	rc = kldrModPEDoCallDLL(pModPE, DLL_PROCESS_ATTACH, uHandle);
	1730	if (rc)
	1731	kldrModPEDoCallTLS(pModPE, DLL_PROCESS_DETACH, uHandle);
	1732	}
	1733
	1734	return rc;
	1735	}
	1736
	1737
	1738	/**
	1739	* Call the DLL entrypoint.
	1740	*
	1741	* @returns 0 on success.
	1742	* @returns KLDR_ERR_MODULE_INIT_FAILED or KLDR_ERR_THREAD_ATTACH_FAILED on failure.
	1743	* @param pModPE The PE module interpreter instance.
	1744	* @param uOp The operation (DLL_*).
	1745	* @param uHandle The module handle to present.
	1746	*/
	1747	static int kldrModPEDoCallDLL(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle)
	1748	{
	1749	int rc;
	1750
	1751	/*
	1752	* If no entrypoint there isn't anything to be done.
	1753	*/
	1754	if (!pModPE->Hdrs.OptionalHeader.AddressOfEntryPoint)
	1755	return 0;
	1756
	1757	/*
	1758	* Invoke the entrypoint and convert the boolean result to a kLdr status code.
	1759	*/
	1760	rc = kldrModPEDoCall((KUPTR)pModPE->pvMapping + pModPE->Hdrs.OptionalHeader.AddressOfEntryPoint,
	1761	uHandle, uOp, NULL);
	1762	if (rc)
	1763	rc = 0;
	1764	else if (uOp == DLL_PROCESS_ATTACH)
	1765	rc = KLDR_ERR_MODULE_INIT_FAILED;
	1766	else if (uOp == DLL_THREAD_ATTACH)
	1767	rc = KLDR_ERR_THREAD_ATTACH_FAILED;
	1768	else /* detach: ignore failures */
	1769	rc = 0;
	1770	return rc;
	1771	}
	1772
	1773
	1774	/**
	1775	* Call the TLS entrypoints.
	1776	*
	1777	* @returns 0 on success.
	1778	* @returns KLDR_ERR_THREAD_ATTACH_FAILED on failure.
	1779	* @param pModPE The PE module interpreter instance.
	1780	* @param uOp The operation (DLL_*).
	1781	* @param uHandle The module handle to present.
	1782	*/
	1783	static int kldrModPEDoCallTLS(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle)
	1784	{
	1785	/** @todo implement TLS support. */
[79]	1786	K_NOREF(pModPE);
	1787	K_NOREF(uOp);
	1788	K_NOREF(uHandle);
[2]	1789	return 0;
	1790	}
	1791
	1792
	1793	/**
	1794	* Do a 3 parameter callback.
	1795	*
	1796	* @returns 32-bit callback return.
	1797	* @param uEntrypoint The address of the function to be called.
	1798	* @param uHandle The first argument, the module handle.
	1799	* @param uOp The second argumnet, the reason we're calling.
	1800	* @param pvReserved The third argument, reserved argument. (figure this one out)
	1801	*/
	1802	static KI32 kldrModPEDoCall(KUPTR uEntrypoint, KUPTR uHandle, KU32 uOp, void *pvReserved)
	1803	{
	1804	KI32 rc;
	1805
	1806	/** @todo try/except */
	1807	#if defined(__X86__) \|\| defined(__i386__) \|\| defined(_M_IX86)
	1808	/*
	1809	* Be very careful.
	1810	* Not everyone will have got the calling convention right.
	1811	*/
	1812	# ifdef __GNUC__
	1813	__asm__ __volatile__(
	1814	"pushl %2\n\t"
	1815	"pushl %1\n\t"
	1816	"pushl %0\n\t"
	1817	"lea 12(%%esp), %2\n\t"
	1818	"call *%3\n\t"
	1819	"movl %2, %%esp\n\t"
	1820	: "=a" (rc)
	1821	: "d" (uOp),
	1822	"S" (0),
	1823	"c" (uEntrypoint),
	1824	"0" (uHandle));
	1825	# elif defined(_MSC_VER)
	1826	__asm {
	1827	mov eax, [uHandle]
	1828	mov edx, [uOp]
	1829	mov ecx, 0
	1830	mov ebx, [uEntrypoint]
	1831	push edi
	1832	mov edi, esp
	1833	push ecx
	1834	push edx
	1835	push eax
	1836	call ebx
	1837	mov esp, edi
	1838	pop edi
	1839	mov [rc], eax
	1840	}
	1841	# else
	1842	# error "port me!"
	1843	# endif
	1844
	1845	#elif defined(__AMD64__) \|\| defined(__x86_64__) \|\| defined(_M_IX86)
	1846	/*
	1847	* For now, let's just get the work done...
	1848	*/
	1849	/** @todo Deal with GCC / MSC differences in some sensible way. */
	1850	int (pfn)(KUPTR uHandle, KU32 uOp, void pvReserved);
	1851	pfn = (int ()(KUPTR uHandle, KU32 uOp, void pvReserved))uEntrypoint;
	1852	rc = pfn(uHandle, uOp, NULL);
	1853
	1854	#else
	1855	# error "port me"
	1856	#endif
[79]	1857	K_NOREF(pvReserved);
[2]	1858
	1859	return rc;
	1860	}
	1861
	1862
	1863	/** @copydoc kLdrModCallTerm */
	1864	static int kldrModPECallTerm(PKLDRMOD pMod, KUPTR uHandle)
	1865	{
	1866	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1867
	1868	/*
	1869	* Mapped?
	1870	*/
	1871	if (!pModPE->pvMapping)
	1872	return KLDR_ERR_NOT_MAPPED;
	1873
	1874	/*
	1875	* Do TLS callbacks first.
	1876	*/
	1877	kldrModPEDoCallTLS(pModPE, DLL_PROCESS_DETACH, uHandle);
	1878	if (pModPE->Hdrs.FileHeader.Characteristics & IMAGE_FILE_DLL)
	1879	kldrModPEDoCallDLL(pModPE, DLL_PROCESS_DETACH, uHandle);
	1880
	1881	return 0;
	1882	}
	1883
	1884
	1885	/** @copydoc kLdrModCallThread */
	1886	static int kldrModPECallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
	1887	{
	1888	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1889	unsigned uOp = fAttachingOrDetaching ? DLL_THREAD_ATTACH : DLL_THREAD_DETACH;
	1890	int rc;
	1891
	1892	/*
	1893	* Do TLS callbacks first and then call the init/term function if it's a DLL.
	1894	*/
	1895	rc = kldrModPEDoCallTLS(pModPE, uOp, uHandle);
	1896	if (!fAttachingOrDetaching)
	1897	rc = 0;
	1898	if ( !rc
	1899	&& (pModPE->Hdrs.FileHeader.Characteristics & IMAGE_FILE_DLL))
	1900	{
	1901	rc = kldrModPEDoCallDLL(pModPE, uOp, uHandle);
	1902	if (!fAttachingOrDetaching)
	1903	rc = 0;
	1904	if (rc)
	1905	kldrModPEDoCallTLS(pModPE, uOp, uHandle);
	1906	}
	1907
	1908	return rc;
	1909	}
	1910
	1911
	1912	/** @copydoc kLdrModSize */
	1913	static KLDRADDR kldrModPESize(PKLDRMOD pMod)
	1914	{
	1915	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1916	return pModPE->Hdrs.OptionalHeader.SizeOfImage;
	1917	}
	1918
	1919
	1920	/** @copydoc kLdrModGetBits */
	1921	static int kldrModPEGetBits(PKLDRMOD pMod, void pvBits, KLDRADDR BaseAddress, PFNKLDRMODGETIMPORT pfnGetImport, void pvUser)
	1922	{
	1923	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1924	KU32 i;
	1925	int rc;
	1926
	1927	/*
	1928	* Zero the entire buffer first to simplify things.
	1929	*/
	1930	kHlpMemSet(pvBits, 0, pModPE->Hdrs.OptionalHeader.SizeOfImage);
	1931
	1932	/*
	1933	* Iterate the segments and read the data within them.
	1934	*/
	1935	for (i = 0; i < pMod->cSegments; i++)
	1936	{
	1937	/* skip it? */
	1938	if ( pMod->aSegments[i].cbFile == -1
	1939	\|\| pMod->aSegments[i].offFile == -1
	1940	\|\| pMod->aSegments[i].LinkAddress == NIL_KLDRADDR
	1941	\|\| !pMod->aSegments[i].Alignment)
	1942	continue;
	1943	rc = kRdrRead(pMod->pRdr,
	1944	(KU8 *)pvBits + (pMod->aSegments[i].LinkAddress - pModPE->Hdrs.OptionalHeader.ImageBase),
	1945	pMod->aSegments[i].cbFile,
	1946	pMod->aSegments[i].offFile);
	1947	if (rc)
	1948	return rc;
	1949	}
	1950
	1951	/*
	1952	* Perform relocations.
	1953	*/
	1954	return kldrModPERelocateBits(pMod, pvBits, BaseAddress, pModPE->Hdrs.OptionalHeader.ImageBase, pfnGetImport, pvUser);
	1955
	1956	}
	1957
	1958
	1959	/** @copydoc kLdrModRelocateBits */
	1960	static int kldrModPERelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
	1961	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
	1962	{
	1963	PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
	1964	int rc;
	1965
	1966	/*
	1967	* Call workers to do the jobs.
	1968	*/
	1969	rc = kldrModPEDoFixups(pModPE, pvBits, NewBaseAddress, OldBaseAddress);
	1970	if (!rc)
	1971	rc = kldrModPEDoImports(pModPE, pvBits, pfnGetImport, pvUser);
	1972
	1973	return rc;
	1974	}
	1975
	1976
	1977	/**
	1978	* The PE module interpreter method table.
	1979	*/
	1980	KLDRMODOPS g_kLdrModPEOps =
	1981	{
	1982	"PE",
	1983	NULL,
	1984	kldrModPECreate,
	1985	kldrModPEDestroy,
	1986	kldrModPEQuerySymbol,
	1987	kldrModPEEnumSymbols,
	1988	kldrModPEGetImport,
	1989	kldrModPENumberOfImports,
	1990	NULL /* can execute one is optional */,
	1991	kldrModPEGetStackInfo,
	1992	kldrModPEQueryMainEntrypoint,
[54]	1993	NULL /* pfnQueryImageUuid */,
[2]	1994	NULL, /** @todo resources */
	1995	NULL, /** @todo resources */
	1996	kldrModPEEnumDbgInfo,
	1997	kldrModPEHasDbgInfo,
	1998	kldrModPEMap,
	1999	kldrModPEUnmap,
	2000	kldrModPEAllocTLS,
	2001	kldrModPEFreeTLS,
	2002	kldrModPEReload,
	2003	kldrModPEFixupMapping,
	2004	kldrModPECallInit,
	2005	kldrModPECallTerm,
	2006	kldrModPECallThread,
	2007	kldrModPESize,
	2008	kldrModPEGetBits,
	2009	kldrModPERelocateBits,
	2010	NULL, /** @todo mostly done */
	2011	42 /* the end */
	2012	};

Note: See TracBrowser for help on using the repository browser.

Download in other formats: