Context Navigation

source: trunk/kLdr/kLdrModLX.c@ 2889

Visit:

Last change on this file since 2889 was 2889, checked in by bird, 19 years ago
started on fixups.
Property svn:keywords set to `Id`
File size: 74.6 KB

Rev	Line
[2826]	1	/* $Id: kLdrModLX.c 2889 2006-11-20 10:27:03Z bird $ */
[2821]	2	/** @file
	3	*
[2879]	4	* kLdr - The Module Interpreter for the Linear eXecutable (LX) Format.
[2821]	5	*
	6	* Copyright (c) 2006 knut st. osmundsen <bird@anduin.net>
	7	*
	8	*
	9	* This file is part of kLdr.
	10	*
	11	* kLdr is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2 of the License, or
	14	* (at your option) any later version.
	15	*
	16	* kLdr is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with kLdr; if not, write to the Free Software
	23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	24	*
	25	*/
	26
[2827]	27
[2879]	28	/*******************************************************************************
	29	* Header Files *
	30	*******************************************************************************/
	31	#include <kLdr.h>
	32	#include "kLdrHlp.h"
	33	#include "kLdrInternal.h"
	34	#include "kLdrModLX.h"
	35
	36
	37	/*******************************************************************************
	38	* Defined Constants And Macros *
	39	*******************************************************************************/
	40	/** @def KLDRMODLX_STRICT
	41	* Define KLDRMODLX_STRICT to enabled strict checks in KLDRMODLX. */
	42	#define KLDRMODLX_STRICT 1
	43
	44	/** @def KLDRMODLX_ASSERT
	45	* Assert that an expression is true when KLDR_STRICT is defined.
	46	*/
	47	#ifdef KLDRMODLX_STRICT
	48	# define KLDRMODLX_ASSERT(expr) kldrHlpAssert(expr)
	49	#else
	50	# define KLDRMODLX_ASSERT(expr) do {} while (0)
	51	#endif
	52
	53
	54	/*******************************************************************************
	55	* Structures and Typedefs *
	56	*******************************************************************************/
	57	/**
	58	* Instance data for the LX module interpreter.
	59	*/
	60	typedef struct KLDRMODLX
	61	{
	62	/** Pointer to the module. (Follows the section table.) */
	63	PKLDRMOD pMod;
	64	/** Pointer to the user mapping. */
	65	const void *pvMapping;
	66	/** The size of the mapped LX image. */
	67	size_t cbMapped;
	68	/** Reserved flags. */
	69	uint32_t f32Reserved;
	70
	71	/** The offset of the LX header. */
	72	off_t offHdr;
	73	/** Copy of the LX header. */
	74	struct e32_exe Hdr;
	75
	76	/** Pointer to the loader section.
	77	* Allocated together with this strcture. */
	78	const uint8_t *pbLoaderSection;
	79	/** Pointer to the last byte in the loader section. */
	80	const uint8_t *pbLoaderSectionLast;
	81	/** Pointer to the object table in the loader section. */
	82	const struct o32_obj *paObjs;
	83	/** Pointer to the object page map table in the loader section. */
	84	const struct o32_map *paPageMappings;
	85	/** Pointer to the resource table in the loader section. */
	86	const struct rsrc32 *paRsrcs;
	87	/** Pointer to the resident name table in the loader section. */
	88	const uint8_t *pbResNameTab;
	89	/** Pointer to the entry table in the loader section. */
	90	const uint8_t *pbEntryTab;
	91
	92	/** Pointer to the non-resident name table. */
	93	uint8_t *pbNonResNameTab;
	94	/** Pointer to the last byte in the non-resident name table. */
	95	const uint8_t *pbNonResNameTabLast;
	96
	97	/** Pointer to the fixup section. */
	98	uint8_t *pbFixupSection;
	99	/** Pointer to the last byte in the fixup section. */
	100	const uint8_t *pbFixupSectionLast;
	101	/** Pointer to the fixup page table within pvFixupSection. */
	102	const uint32_t *paoffPageFixups;
	103	/** Pointer to the fixup record table within pvFixupSection. */
	104	const uint8_t *pbFixupRecs;
	105	/** Pointer to the import module name table within pvFixupSection. */
	106	const uint8_t *pbImportMods;
	107	/** Pointer to the import module name table within pvFixupSection. */
	108	const uint8_t *pbImportProcs;
	109	} KLDRMODLX, *PKLDRMODLX;
	110
	111
	112	/*******************************************************************************
	113	* Internal Functions *
	114	*******************************************************************************/
	115	static int kldrModLXHasDbgInfo(PKLDRMOD pMod, const void *pvBits);
	116	static int kldrModLXRelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
	117	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
	118	static int kldrModLXDoCreate(PKLDRRDR pRdr, off_t offNewHdr, PKLDRMODLX *ppModLX);
[2882]	119	static const uint8_t kldrModLXDoNameTableLookupByOrdinal(const uint8_t pbNameTable, int32_t cbNameTable, uint32_t iOrdinal);
	120	static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char pszSymbol, uint32_t piSymbol);
[2889]	121	#if 0
[2882]	122	static const uint8_t kldrModLXDoNameTableLookupByName(const uint8_t pbNameTable, int32_t cbNameTable,
	123	char *pchSymbol, size_t cchSymbol);
[2889]	124	#endif
[2879]	125	static int kldrModLXDoLoadBits(PKLDRMODLX pModLX, void *pvBits);
[2880]	126	static int kldrModLXDoIterDataUnpacking(uint8_t pbDst, const uint8_t pbSrc, int cbSrc);
	127	static int kldrModLXDoIterData2Unpacking(uint8_t pbDst, const uint8_t pbSrc, int cbSrc);
	128	static void kLdrModLXMemCopyW(uint8_t pbDst, const uint8_t pbSrc, int cb);
[2879]	129	static int kldrModLXDoProtect(PKLDRMODLX pModLX, void *pvBits, unsigned fUnprotectOrProtect);
	130	static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, unsigned uOp, uintptr_t uHandle);
[2882]	131	static int kldrModLXDoForwarderQuery(PKLDRMODLX pModLX, const struct e32_entry *pEntry,
	132	PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser, PKLDRADDR puValue, uint32_t pfKind);
	133	static int kldrModLXDoLoadFixupSection(PKLDRMODLX pModLX);
[2879]	134	static int32_t kldrModLXDoCall(uintptr_t uEntrypoint, uintptr_t uHandle, uint32_t uOp, void *pvReserved);
[2889]	135	static int kldrModLXDoReloc(uint8_t *pbPage, int off, KLDRADDR uValue, uint32_t fKind);
[2879]	136
	137
	138	/**
	139	* Create a loader module instance interpreting the executable image found
	140	* in the specified file provider instance.
	141	*
	142	* @returns 0 on success and *ppMod pointing to a module instance.
	143	* On failure, a non-zero OS specific error code is returned.
	144	* @param pOps Pointer to the registered method table.
	145	* @param pRdr The file provider instance to use.
	146	* @param offNewHdr The offset of the new header in MZ files. -1 if not found.
	147	* @param ppMod Where to store the module instance pointer.
	148	*/
	149	static int kldrModLXCreate(PCKLDRMODOPS pOps, PKLDRRDR pRdr, off_t offNewHdr, PPKLDRMOD ppMod)
	150	{
	151	PKLDRMODLX pModLX;
	152	int rc;
	153
	154	/*
	155	* Create the instance data and do a minimal header validation.
	156	*/
	157	rc = kldrModLXDoCreate(pRdr, offNewHdr, &pModLX);
	158	if (!rc)
	159	{
	160	pModLX->pMod->pOps = pOps;
	161	pModLX->pMod->u32Magic = KLDRMOD_MAGIC;
	162	*ppMod = pModLX->pMod;
	163	return 0;
	164	}
	165	kldrHlpFree(pModLX);
	166	return rc;
	167	}
	168
	169
	170	/**
	171	* Separate function for reading creating the LX module instance to
	172	* simplify cleanup on failure.
	173	*/
	174	static int kldrModLXDoCreate(PKLDRRDR pRdr, off_t offNewHdr, PKLDRMODLX *ppModLX)
	175	{
	176	struct e32_exe Hdr;
	177	PKLDRMODLX pModLX;
	178	PKLDRMOD pMod;
	179	size_t cb;
	180	size_t cchFilename;
	181	uint32_t off, offEnd;
	182	uint32_t i;
	183	int rc;
	184	*ppModLX = NULL;
	185
	186	/*
	187	* Read the signature and file header.
	188	*/
	189	rc = kLdrRdrRead(pRdr, &Hdr, sizeof(Hdr), offNewHdr > 0 ? offNewHdr : 0);
	190	if (rc)
	191	return rc;
[2886]	192	if ( Hdr.e32_magic[0] != E32MAGIC1
	193	\|\| Hdr.e32_magic[1] != E32MAGIC2)
[2879]	194	return KLDR_ERR_UNKNOWN_FORMAT;
	195
	196	/* We're not interested in anything but x86 images. */
	197	if ( Hdr.e32_level != E32LEVEL
	198	\|\| Hdr.e32_border != E32LEBO
	199	\|\| Hdr.e32_worder != E32LEWO
	200	\|\| Hdr.e32_cpu < E32CPU286
	201	\|\| Hdr.e32_cpu > E32CPU486
	202	\|\| Hdr.e32_pagesize != OBJPAGELEN
	203	)
	204	return KLDR_ERR_LX_BAD_HEADER;
	205
	206	/* Some rough sanity checks. */
	207	offEnd = kLdrRdrSize(pRdr) >= (off_t)~(uint32_t)16 ? ~(uint32_t)16 : (uint32_t)kLdrRdrSize(pRdr);
	208	if ( Hdr.e32_itermap > offEnd
	209	\|\| Hdr.e32_datapage > offEnd
	210	\|\| Hdr.e32_nrestab > offEnd
	211	\|\| Hdr.e32_nrestab + Hdr.e32_cbnrestab > offEnd
	212	\|\| Hdr.e32_ldrsize > offEnd - offNewHdr - sizeof(Hdr)
	213	\|\| Hdr.e32_fixupsize > offEnd - offNewHdr - sizeof(Hdr)
	214	\|\| Hdr.e32_fixupsize + Hdr.e32_ldrsize > offEnd - offNewHdr - sizeof(Hdr))
	215	return KLDR_ERR_LX_BAD_HEADER;
	216
	217	/* Verify the loader section. */
	218	offEnd = Hdr.e32_objtab + Hdr.e32_ldrsize;
	219	if (Hdr.e32_objtab < sizeof(Hdr))
	220	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	221	off = Hdr.e32_objtab + sizeof(struct o32_obj) * Hdr.e32_objcnt;
	222	if (off > offEnd)
	223	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	224	if ( Hdr.e32_objmap
	225	&& (Hdr.e32_objmap < off \|\| Hdr.e32_objmap > offEnd))
	226	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	227	if ( Hdr.e32_rsrccnt
	228	&& ( Hdr.e32_rsrctab < off
	229	\|\| Hdr.e32_rsrctab > offEnd
	230	\|\| Hdr.e32_rsrctab + sizeof(struct rsrc32) * Hdr.e32_rsrccnt > offEnd))
	231	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	232	if ( Hdr.e32_restab
	233	&& (Hdr.e32_restab < off \|\| Hdr.e32_restab > offEnd - 2))
	234	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	235	if ( Hdr.e32_enttab
	236	&& (Hdr.e32_enttab < off \|\| Hdr.e32_enttab > offEnd - 2))
	237	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	238	if ( Hdr.e32_dircnt
	239	&& (Hdr.e32_dirtab < off \|\| Hdr.e32_dirtab > offEnd))
	240	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	241
	242	/* Verify the fixup section. */
	243	off = offEnd;
	244	offEnd = off + Hdr.e32_fixupsize;
	245	if ( Hdr.e32_fpagetab
	246	&& (Hdr.e32_fpagetab < off \|\| Hdr.e32_fpagetab > offEnd))
	247	return KLDR_ERR_LX_BAD_FIXUP_SECTION;
	248	if ( Hdr.e32_frectab
	249	&& (Hdr.e32_frectab < off \|\| Hdr.e32_frectab > offEnd))
	250	return KLDR_ERR_LX_BAD_FIXUP_SECTION;
	251	if ( Hdr.e32_impmod
	252	&& (Hdr.e32_impmod < off \|\| Hdr.e32_impmod > offEnd \|\| Hdr.e32_impmod + Hdr.e32_impmodcnt > offEnd))
	253	return KLDR_ERR_LX_BAD_FIXUP_SECTION;
	254	if ( Hdr.e32_impproc
	255	&& (Hdr.e32_impproc < off \|\| Hdr.e32_impproc > offEnd))
	256	return KLDR_ERR_LX_BAD_FIXUP_SECTION;
	257
	258	/*
	259	* Calc the instance size, allocate and initialize it.
	260	*/
	261	cchFilename = kLdrHlpStrLen(kLdrRdrName(pRdr));
	262	cb = KLDR_ALIGN_Z(sizeof(KLDRMODLX), 8)
	263	+ KLDR_ALIGN_Z(KLDR_OFFSETOF(KLDRMOD, aSegments[Hdr.e32_objcnt + 1]), 8)
[2883]	264	+ KLDR_ALIGN_Z(cchFilename + 1, 8)
[2879]	265	+ Hdr.e32_ldrsize;
	266	pModLX = (PKLDRMODLX)kldrHlpAlloc(cb);
	267	if (!pModLX)
	268	return KLDR_ERR_NO_MEMORY;
	269	*ppModLX = pModLX;
	270
	271	/* KLDRMOD */
	272	pMod = (PKLDRMOD)((uint8_t *)pModLX + KLDR_ALIGN_Z(sizeof(KLDRMODLX), 8));
	273	pMod->pvData = pModLX;
	274	pMod->pRdr = pRdr;
	275	pMod->pOps = NULL; /* set upon success. */
	276	pMod->cSegments = Hdr.e32_objcnt;
	277	pMod->cchFilename = cchFilename;
	278	pMod->pszFilename = (char *)KLDR_ALIGN_P(&pMod->aSegments[pMod->cSegments], 8);
	279	kLdrHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
	280	pMod->pszName = NULL; /* finalized further down */
	281	pMod->cchName = 0;
	282	switch (Hdr.e32_cpu)
	283	{
	284	case E32CPU286:
	285	pMod->enmCpu = KLDRCPU_I80286;
	286	pMod->enmArch = KLDRARCH_X86_16;
	287	break;
	288	case E32CPU386:
	289	pMod->enmCpu = KLDRCPU_I386;
	290	pMod->enmArch = KLDRARCH_X86_32;
	291	break;
	292	case E32CPU486:
	293	pMod->enmCpu = KLDRCPU_I486;
	294	pMod->enmArch = KLDRARCH_X86_32;
	295	break;
	296	}
	297	pMod->enmEndian = KLDRENDIAN_LITTLE;
	298	pMod->enmFmt = KLDRFMT_LX;
	299	switch (Hdr.e32_mflags & E32MODMASK)
	300	{
	301	case E32MODEXE:
	302	pMod->enmType = !(Hdr.e32_mflags & E32NOINTFIX)
	303	? KLDRTYPE_EXECUTABLE_RELOCATABLE
	304	: KLDRTYPE_EXECUTABLE_FIXED;
	305	break;
	306
	307	case E32MODDLL:
	308	case E32PROTDLL:
	309	case E32MODPROTDLL:
	310	pMod->enmType = !(Hdr.e32_mflags & E32SYSDLL)
	311	? KLDRTYPE_SHARED_LIBRARY_RELOCATABLE
	312	: KLDRTYPE_SHARED_LIBRARY_FIXED;
	313	break;
	314
	315	case E32MODPDEV:
	316	case E32MODVDEV:
	317	pMod->enmType = KLDRTYPE_SHARED_LIBRARY_RELOCATABLE;
	318	break;
	319	}
	320	pMod->u32Magic = 0; /* set upon success. */
	321
	322	/* KLDRMODLX */
	323	pModLX->pMod = pMod;
	324	pModLX->pvMapping = 0;
	325	pModLX->cbMapped = Hdr.e32_mpages * Hdr.e32_pagesize;
	326	pModLX->f32Reserved = 0;
	327
	328	pModLX->offHdr = offNewHdr >= 0 ? offNewHdr : 0;
	329	pModLX->Hdr = Hdr;
	330
	331	pModLX->pbLoaderSection = KLDR_ALIGN_P(pMod->pszFilename + pMod->cchFilename + 1, 16);
	332	pModLX->pbLoaderSectionLast = pModLX->pbLoaderSection + pModLX->Hdr.e32_ldrsize;
	333	pModLX->paObjs = NULL;
	334	pModLX->paPageMappings = NULL;
	335	pModLX->paRsrcs = NULL;
	336	pModLX->pbResNameTab = NULL;
	337	pModLX->pbEntryTab = NULL;
	338
	339	pModLX->pbNonResNameTab = NULL;
	340	pModLX->pbNonResNameTabLast = NULL;
	341
	342	pModLX->pbFixupSection = NULL;
	343	pModLX->pbFixupSectionLast = NULL;
	344	pModLX->paoffPageFixups = NULL;
	345	pModLX->pbFixupRecs = NULL;
	346	pModLX->pbImportMods = NULL;
	347	pModLX->pbImportProcs = NULL;
	348
	349	/*
	350	* Read the loader data.
	351	*/
	352	rc = kLdrRdrRead(pRdr, (void *)pModLX->pbLoaderSection, pModLX->Hdr.e32_ldrsize, pModLX->Hdr.e32_objtab + pModLX->offHdr);
	353	if (rc)
	354	return rc;
	355	if (pModLX->Hdr.e32_objcnt)
	356	pModLX->paObjs = (const struct o32_obj *)pModLX->pbLoaderSection;
	357	if (pModLX->Hdr.e32_objmap)
	358	pModLX->paPageMappings = (const struct o32_map *)(pModLX->pbLoaderSection + pModLX->Hdr.e32_objmap - pModLX->Hdr.e32_objtab);
	359	if (pModLX->Hdr.e32_rsrccnt)
	360	pModLX->paRsrcs = (const struct rsrc32 *)(pModLX->pbLoaderSection + pModLX->Hdr.e32_rsrctab - pModLX->Hdr.e32_objtab);
	361	if (pModLX->Hdr.e32_restab)
	362	pModLX->pbResNameTab = pModLX->pbLoaderSection + pModLX->Hdr.e32_restab - pModLX->Hdr.e32_objtab;
	363	if (pModLX->Hdr.e32_enttab)
	364	pModLX->pbEntryTab = pModLX->pbLoaderSection + pModLX->Hdr.e32_enttab - pModLX->Hdr.e32_objtab;
	365
	366	/*
	367	* Get the soname from the resident name table.
[2882]	368	* Very convenient that it's the 0 ordinal, because then we get a
	369	* free string terminator.
	370	* (The table entry consists of a pascal string followed by a 16-bit ordinal.)
[2879]	371	*/
[2883]	372	pMod->pszName = (const char *)kldrModLXDoNameTableLookupByOrdinal(pModLX->pbResNameTab,
	373	pModLX->pbLoaderSectionLast - pModLX->pbResNameTab + 1,
	374	0);
[2882]	375	if (!pMod->pszName)
	376	return KLDR_ERR_LX_NO_SONAME;
	377	pMod->cchName = (const uint8_t )pMod->pszName++;
	378	if (pMod->cchName != kLdrHlpStrLen(pMod->pszName))
	379	return KLDR_ERR_LX_BAD_SONAME;
[2879]	380
	381	/*
	382	* Quick validation of the object table.
	383	*/
	384	cb = 0;
	385	for (i = 0; i < pMod->cSegments; i++)
	386	{
	387	if (pModLX->paObjs[i].o32_base & (OBJPAGELEN - 1))
	388	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
	389	if (pModLX->paObjs[i].o32_base + pModLX->paObjs[i].o32_size <= pModLX->paObjs[i].o32_base)
	390	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
[2887]	391	if (pModLX->paObjs[i].o32_mapsize > (pModLX->paObjs[i].o32_size + (OBJPAGELEN - 1)))
[2879]	392	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
	393	if ( pModLX->paObjs[i].o32_mapsize
	394	&& ( (uint8_t *)&pModLX->paPageMappings[pModLX->paObjs[i].o32_pagemap] > pModLX->pbLoaderSectionLast
	395	\|\| (uint8_t *)&pModLX->paPageMappings[pModLX->paObjs[i].o32_pagemap + pModLX->paObjs[i].o32_mapsize]
	396	> pModLX->pbLoaderSectionLast))
	397	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
	398	if (i > 0)
	399	{
	400	if (pModLX->paObjs[i].o32_base <= pModLX->paObjs[i - 1].o32_base)
	401	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
	402	if (pModLX->paObjs[i].o32_base < pModLX->paObjs[i - 1].o32_base + pModLX->paObjs[i - 1].o32_mapsize)
	403	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
	404	}
	405	}
	406	pModLX->cbMapped = pMod->cSegments
	407	? pModLX->paObjs[pMod->cSegments - 1].o32_base + pModLX->paObjs[pMod->cSegments - 1].o32_size
	408	- pModLX->paObjs[pMod->cSegments - 1].o32_size
	409	: 0;
	410
	411	/*
	412	* Setup the KLDRMOD segment array.
	413	*/
	414	for (i = 0; i < pMod->cSegments; i++)
	415	{
	416	/* unused */
	417	pMod->aSegments[i].pvUser = NULL;
	418	pMod->aSegments[i].MapAddress = 0;
	419	pMod->aSegments[i].pchName = NULL;
	420	pMod->aSegments[i].cchName = 0;
	421	pMod->aSegments[i].offFile = -1;
	422	pMod->aSegments[i].cbFile = 0;
	423
	424	/* size and addresses */
	425	pMod->aSegments[i].Alignment = OBJPAGELEN;
	426	pMod->aSegments[i].cb = pModLX->paObjs[i].o32_size;
	427	pMod->aSegments[i].LinkAddress = pModLX->paObjs[i].o32_base;
	428	pMod->aSegments[i].RVA = pModLX->paObjs[i].o32_base - pModLX->paObjs[0].o32_base;
	429	pMod->aSegments[i].cbMapped = KLDR_ALIGN_Z(pModLX->paObjs[i].o32_size, 16);
	430	if (i + 1 < pMod->cSegments)
	431	pMod->aSegments[i].cbMapped = pModLX->paObjs[i + 1].o32_base - pModLX->paObjs[i].o32_base;
	432
	433	/* protection */
	434	switch ( pModLX->paObjs[i].o32_flags
	435	& (OBJSHARED \| OBJREAD \| OBJWRITE \| OBJEXEC))
	436	{
	437	case 0:
	438	case OBJSHARED:
	439	pMod->aSegments[i].enmProt = KLDRPROT_NOACCESS;
	440	break;
	441	case OBJREAD:
	442	case OBJREAD \| OBJSHARED:
	443	pMod->aSegments[i].enmProt = KLDRPROT_READONLY;
	444	break;
	445	case OBJWRITE:
	446	case OBJWRITE \| OBJREAD:
	447	pMod->aSegments[i].enmProt = KLDRPROT_WRITECOPY;
	448	break;
	449	case OBJWRITE \| OBJSHARED:
	450	case OBJWRITE \| OBJSHARED \| OBJREAD:
	451	pMod->aSegments[i].enmProt = KLDRPROT_READWRITE;
	452	break;
	453	case OBJEXEC:
	454	case OBJEXEC \| OBJSHARED:
	455	pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE;
	456	break;
	457	case OBJEXEC \| OBJREAD:
	458	case OBJEXEC \| OBJREAD \| OBJSHARED:
	459	pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE_READ;
	460	break;
	461	case OBJEXEC \| OBJWRITE:
	462	case OBJEXEC \| OBJWRITE \| OBJREAD:
	463	pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE_WRITECOPY;
	464	break;
	465	case OBJEXEC \| OBJWRITE \| OBJSHARED:
	466	case OBJEXEC \| OBJWRITE \| OBJSHARED \| OBJREAD:
	467	pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE_READWRITE;
	468	break;
	469	}
	470	if ((pModLX->paObjs[i].o32_flags & (OBJREAD \| OBJWRITE \| OBJEXEC \| OBJRSRC)) == OBJRSRC)
	471	pMod->aSegments[i].enmProt = KLDRPROT_READONLY;
[2883]	472	/*pMod->aSegments[i].f16bit = !(pModLX->paObjs[i].o32_flags & OBJBIGDEF)
	473	pMod->aSegments[i].fIOPL = !(pModLX->paObjs[i].o32_flags & OBJIOPL)
	474	pMod->aSegments[i].fConforming = !(pModLX->paObjs[i].o32_flags & OBJCONFORM) */
[2879]	475	}
	476
	477	/*
	478	* We're done.
	479	*/
	480	*ppModLX = pModLX;
	481	return 0;
	482	}
	483
	484
	485	/** @copydoc KLDRMODOPS::pfnDestroy */
	486	static int kldrModLXDestroy(PKLDRMOD pMod)
	487	{
	488	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	489	int rc = 0;
	490	KLDRMODLX_ASSERT(pModLX->pvMapping);
	491
	492	if (pMod->pRdr)
	493	{
	494	rc = kLdrRdrClose(pMod->pRdr);
	495	pMod->pRdr = NULL;
	496	}
	497	if (pModLX->pbNonResNameTab)
	498	{
	499	kldrHlpFree(pModLX->pbNonResNameTab);
	500	pModLX->pbNonResNameTab = NULL;
	501	}
	502	if (pModLX->pbFixupSection)
	503	{
	504	kldrHlpFree(pModLX->pbFixupSection);
	505	pModLX->pbFixupSection = NULL;
	506	}
	507	pMod->u32Magic = 0;
	508	pMod->pOps = NULL;
	509	kldrHlpFree(pModLX);
	510	return rc;
	511	}
	512
	513
	514	/**
	515	* Resolved base address aliases.
	516	*
	517	* @param pModLX The interpreter module instance
	518	* @param pBaseAddress The base address, IN & OUT.
	519	*/
	520	static void kldrModLXResolveBaseAddress(PKLDRMODLX pModLX, PKLDRADDR pBaseAddress)
	521	{
	522	if (*pBaseAddress == KLDRMOD_BASEADDRESS_MAP)
	523	*pBaseAddress = pModLX->pMod->aSegments[0].MapAddress;
	524	else if (*pBaseAddress == KLDRMOD_BASEADDRESS_LINK)
	525	*pBaseAddress = pModLX->pMod->aSegments[0].LinkAddress;
	526	}
	527
	528
	529	/** @copydoc kLdrModQuerySymbol */
	530	static int kldrModLXQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
	531	const char pszSymbol, PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser,
	532	PKLDRADDR puValue, uint32_t *pfKind)
	533	{
[2882]	534	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	535	uint32_t iOrdinal;
	536	int rc;
	537	const struct b32_bundle *pBundle;
[2879]	538
	539
[2882]	540	/*
	541	* Give up at once if there is no entry table.
	542	*/
	543	if (!pModLX->Hdr.e32_enttab)
	544	return KLDR_ERR_SYMBOL_NOT_FOUND;
	545
	546	/*
	547	* Translate the symbol name into an ordinal.
	548	*/
	549	if (pszSymbol)
	550	{
	551	rc = kldrModLXDoNameLookup(pModLX, pszSymbol, &iSymbol);
	552	if (rc)
	553	return rc;
	554	}
	555
	556	/*
	557	* Iterate the entry table.
	558	* (The entry table is made up of bundles of similar exports.)
	559	*/
	560	iOrdinal = 0;
	561	pBundle = (const struct b32_bundle *)pModLX->pbEntryTab;
	562	while (!pBundle->b32_cnt && iOrdinal <= iSymbol)
	563	{
	564	static const size_t s_cbEntry[] = { 0, 3, 5, 5, 7 };
	565
	566	/*
	567	* Check for a hit first.
	568	*/
	569	iOrdinal += pBundle->b32_cnt;
	570	if (iSymbol < iOrdinal)
	571	{
	572	uint32_t offObject;
	573	const struct e32_entry pEntry = (const struct e32_entry )((uintptr_t)(pBundle + 1)
	574	+ iSymbol - (iOrdinal - pBundle->b32_cnt));
	575
	576	/*
	577	* Calculate the return address.
	578	*/
	579	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
	580	switch (pBundle->b32_type)
	581	{
	582	/* empty bundles are place holders unused ordinal ranges. */
	583	case EMPTY:
	584	return KLDR_ERR_SYMBOL_NOT_FOUND;
	585
	586	/* e32_flags + a 16-bit offset. */
	587	case ENTRY16:
	588	offObject = pEntry->e32_variant.e32_offset.offset16;
	589	if (pfKind)
	590	*pfKind = KLDRSYMKIND_16BIT \| KLDRSYMKIND_NO_TYPE;
	591	break;
	592
	593	/* e32_flags + a 16-bit offset + a 16-bit callgate selector. */
	594	case GATE16:
	595	offObject = pEntry->e32_variant.e32_callgate.offset;
	596	if (pfKind)
	597	*pfKind = KLDRSYMKIND_16BIT \| KLDRSYMKIND_CODE;
	598	break;
	599
	600	/* e32_flags + a 32-bit offset. */
	601	case ENTRY32:
	602	offObject = pEntry->e32_variant.e32_offset.offset32;
	603	if (pfKind)
	604	*pfKind = KLDRSYMKIND_32BIT;
	605	break;
	606
	607	/* e32_flags + 16-bit import module ordinal + a 32-bit procname or ordinal. */
	608	case ENTRYFWD:
	609	return kldrModLXDoForwarderQuery(pModLX, pEntry, pfnGetForwarder, pvUser, puValue, pfKind);
	610
	611	default:
	612	/* anyone actually using TYPEINFO will end up here. */
	613	KLDRMODLX_ASSERT(!"Bad bundle type");
	614	break;
	615	}
	616
	617	/*
	618	* Validate the object number and calc the return address.
	619	*/
	620	if ( pBundle->b32_obj <= 0
	621	\|\| pBundle->b32_obj > pMod->cSegments)
	622	return KLDR_ERR_LX_BAD_BUNDLE;
	623	if (puValue)
	624	*puValue = BaseAddress
	625	+ offObject
	626	+ pMod->aSegments[pBundle->b32_obj - 1].RVA;
	627	return 0;
	628	}
	629
	630	/*
	631	* Skip the bundle.
	632	*/
	633	if (pBundle->b32_type > ENTRYFWD)
	634	{
	635	KLDRMODLX_ASSERT(!"Bad type"); /** @todo figure out TYPEINFO. */
	636	return KLDR_ERR_LX_BAD_BUNDLE;
	637	}
	638	if (pBundle->b32_type == 0)
	639	pBundle = (const struct b32_bundle )((const uint8_t )pBundle + 2);
	640	else
	641	pBundle = (const struct b32_bundle )((const uint8_t )pBundle + s_cbEntry[pBundle->b32_type] * pBundle->b32_cnt);
	642	}
	643
	644	return KLDR_ERR_SYMBOL_NOT_FOUND;
	645	}
	646
	647
	648	/**
	649	* Do name lookup.
	650	*
	651	* @returns See kLdrModQuerySymbol.
	652	* @param pModLX The module to lookup the symbol in.
	653	* @param pszSymbol The symbol to lookup.
	654	* @param piSymbol Where to store the symbol ordinal.
	655	*/
	656	static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char pszSymbol, uint32_t piSymbol)
	657	{
	658
	659	/*
	660	* First do a hash table lookup.
	661	*/
	662
	663
	664
	665	/*
	666
	667	*/
	668
[2879]	669	return -1;
	670	}
	671
	672
[2889]	673	#if 0
[2882]	674	/**
	675	* Hash a symbol using the algorithm from sdbm.
	676	*
	677	* The following was is the documenation of the orignal sdbm functions:
	678	*
	679	* This algorithm was created for sdbm (a public-domain reimplementation of
	680	* ndbm) database library. it was found to do well in scrambling bits,
	681	* causing better distribution of the keys and fewer splits. it also happens
	682	* to be a good general hashing function with good distribution. the actual
	683	* function is hash(i) = hash(i - 1) * 65599 + str[i]; what is included below
	684	* is the faster version used in gawk. [there is even a faster, duff-device
	685	* version] the magic constant 65599 was picked out of thin air while
	686	* experimenting with different constants, and turns out to be a prime.
	687	* this is one of the algorithms used in berkeley db (see sleepycat) and
	688	* elsewhere.
	689	*/
	690	static uint32_t kldrModLXDoHash(const char *pchSymbol, uint8_t cchSymbol)
	691	{
	692	uint32_t hash = 0;
	693	int ch;
	694
	695	while ( cchSymbol-- > 0
	696	&& (ch = (unsigned const char )pchSymbol++))
	697	hash = ch + (hash << 6) + (hash << 16) - hash;
	698
	699	return hash;
	700	}
	701
	702
	703	/**
	704	* Lookup a name table entry by name.
	705	*
	706	* @returns Pointer to the name table entry if found.
	707	* @returns NULL if not found.
	708	* @param pbNameTable Pointer to the name table that should be searched.
	709	* @param cbNameTable The size of the name table.
	710	* @param pchSymbol The name of the symbol we're looking for.
	711	* @param cchSymbol The length of the symbol name.
	712	*/
	713	static const uint8_t kldrModLXDoNameTableLookupByName(const uint8_t pbNameTable, int32_t cbNameTable,
	714	char *pchSymbol, size_t cchSymbol)
	715	{
	716	/*
	717	* Determin the namelength up front so we can skip anything which doesn't matches the length.
	718	*/
	719	uint8_t cbSymbol8Bit = (uint8_t)cchSymbol;
	720	if (cbSymbol8Bit != cchSymbol)
	721	return NULL; /* too long. */
	722
	723	/*
	724	* Walk the name table.
	725	*/
	726	while (*pbNameTable != 0 && cbNameTable > 0)
	727	{
	728	const uint8_t cbName = *pbNameTable;
	729
	730	cbNameTable -= cbName + 1 + 2;
	731	if (cbNameTable < 0)
	732	break;
	733
	734	if ( cbName == cbSymbol8Bit
	735	&& !kLdrHlpMemComp(pbNameTable + 1, pchSymbol, cbName))
	736	return pbNameTable;
	737
	738	/* next entry */
	739	pbNameTable += cbName + 1 + 2;
	740	}
	741
	742	return NULL;
	743	}
[2889]	744	#endif
[2882]	745
	746
	747	/**
	748	* Deal with a forwarder entry.
	749	*
	750	* @returns See kLdrModQuerySymbol.
	751	* @param pModLX The PE module interpreter instance.
	752	* @param pEntry The forwarder entry.
	753	* @param pfnGetForwarder The callback for resolving forwarder symbols. (optional)
	754	* @param pvUser The user argument for the callback.
	755	* @param puValue Where to put the value. (optional)
	756	* @param pfKind Where to put the symbol kind. (optional)
	757	*/
	758	static int kldrModLXDoForwarderQuery(PKLDRMODLX pModLX, const struct e32_entry *pEntry,
	759	PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser, PKLDRADDR puValue, uint32_t pfKind)
	760	{
	761	int rc;
	762	uint32_t iSymbol;
	763	const char *pszSymbol;
	764
	765	if (!pfnGetForwarder)
	766	return KLDR_ERR_FORWARDER_SYMBOL;
	767
	768	/*
	769	* Validate the entry import module ordinal.
	770	*/
	771	if ( !pEntry->e32_variant.e32_fwd.modord
	772	\|\| pEntry->e32_variant.e32_fwd.modord > pModLX->Hdr.e32_impmodcnt)
	773	return KLDR_ERR_LX_BAD_FORWARDER;
	774
	775	/*
	776	* Figure out the parameters.
	777	*/
	778	if (pEntry->e32_flags & FWD_ORDINAL)
	779	{
	780	iSymbol = pEntry->e32_variant.e32_fwd.value;
	781	pszSymbol = NULL; /* no symbol name. */
	782	}
	783	else
	784	{
	785	const uint8_t *pbName;
	786
	787	/* load the fixup section if necessary. */
	788	if (!pModLX->pbImportProcs)
	789	{
	790	rc = kldrModLXDoLoadFixupSection(pModLX);
	791	if (rc)
	792	return rc;
	793	}
	794
	795	/* Make name pointer. */
	796	pbName = pModLX->pbImportProcs + pEntry->e32_variant.e32_fwd.value;
	797	if ( pbName >= pModLX->pbFixupSectionLast
[2889]	798	\|\| pbName < pModLX->pbFixupSection
[2882]	799	\|\| !*pbName)
	800	return KLDR_ERR_LX_BAD_FORWARDER;
	801
	802
	803	/* check for '#' name. */
	804	if (pbName[1] == '#')
	805	{
	806	uint8_t cbLeft = *pbName;
	807	const uint8_t *pb = pbName + 1;
	808	unsigned uBase;
	809
	810	/* base detection */
	811	uBase = 10;
	812	if ( cbLeft > 1
	813	&& pb[1] == '0'
	814	&& (pb[2] == 'x' \|\| pb[2] == 'X'))
	815	{
	816	uBase = 16;
	817	pb += 2;
	818	cbLeft -= 2;
	819	}
	820
	821	/* ascii to integer */
	822	iSymbol = 0;
	823	while (cbLeft-- > 0)
	824	{
	825	/* convert char to digit. */
	826	unsigned uDigit = *pb++;
	827	if (uDigit >= '0' && uDigit <= '9')
	828	uDigit -= '0';
	829	else if (uDigit >= 'a' && uDigit <= 'z')
	830	uDigit -= 'a' + 10;
	831	else if (uDigit >= 'A' && uDigit <= 'Z')
	832	uDigit -= 'A' + 10;
	833	else if (!uDigit)
	834	break;
	835	else
	836	return KLDR_ERR_LX_BAD_FORWARDER;
	837	if (uDigit >= uBase)
	838	return KLDR_ERR_LX_BAD_FORWARDER;
	839
	840	/* insert the digit */
	841	iSymbol *= uBase;
	842	iSymbol += uDigit;
	843	}
	844	if (!iSymbol)
	845	return KLDR_ERR_LX_BAD_FORWARDER;
	846
	847	pszSymbol = NULL; /* no symbol name. */
	848	}
	849	else
	850	{
	851	/* Make a stack copy of the name that's zero terminated. */
	852	char pszCopy = kLdrHlpAllocA(pbName + 1);
	853	kLdrHlpMemCopy(pszCopy, pbName + 1, *pbName);
	854	pszCopy[*pbName] = '\0';
	855
	856	pszSymbol = pszCopy;
	857	iSymbol = NIL_KLDRMOD_SYM_ORDINAL;
	858	}
	859	}
	860
	861	/*
	862	* Resolve the forwarder.
	863	*/
	864	rc = pfnGetForwarder(pModLX->pMod, pEntry->e32_variant.e32_fwd.modord - 1, iSymbol, pszSymbol, puValue, pfKind, pvUser);
	865	if (!rc && pfKind)
	866	*pfKind \|= KLDRSYMKIND_FORWARDER;
	867	return rc;
	868	}
	869
	870
	871	/**
	872	* Loads the fixup section from the executable image.
	873	*
	874	* The fixup section isn't loaded until it's accessed. It's also freed by kLdrModDone().
	875	*
	876	* @returns 0 on success, non-zero kLdr or native status code on failure.
	877	* @param pModLX The PE module interpreter instance.
	878	*/
	879	static int kldrModLXDoLoadFixupSection(PKLDRMODLX pModLX)
	880	{
[2888]	881	int rc;
	882	uint32_t off;
	883	void *pv;
	884
	885	pv = kldrHlpAlloc(pModLX->Hdr.e32_fixupsize);
	886	if (!pv)
	887	return KLDR_ERR_NO_MEMORY;
	888
	889	off = pModLX->Hdr.e32_objtab + pModLX->Hdr.e32_ldrsize;
	890	rc = kLdrRdrRead(pModLX->pMod->pRdr, pv, pModLX->Hdr.e32_fixupsize,
	891	off + pModLX->offHdr);
	892	if (!rc)
	893	{
	894	pModLX->pbFixupSection = pv;
	895	pModLX->pbFixupSectionLast = pModLX->pbFixupSection + pModLX->Hdr.e32_fixupsize;
	896	KLDRMODLX_ASSERT(!pModLX->paoffPageFixups);
	897	if (pModLX->Hdr.e32_fpagetab)
	898	pModLX->paoffPageFixups = (const uint32_t *)(pModLX->pbFixupSection + pModLX->Hdr.e32_fpagetab - off);
	899	KLDRMODLX_ASSERT(!pModLX->pbFixupRecs);
	900	if (pModLX->Hdr.e32_frectab)
	901	pModLX->pbFixupRecs = pModLX->pbFixupSection + pModLX->Hdr.e32_frectab - off;
	902	KLDRMODLX_ASSERT(!pModLX->pbImportMods);
	903	if (pModLX->Hdr.e32_impmod)
	904	pModLX->pbImportMods = pModLX->pbFixupSection + pModLX->Hdr.e32_impmod - off;
	905	KLDRMODLX_ASSERT(!pModLX->pbImportProcs);
	906	if (pModLX->Hdr.e32_impproc)
	907	pModLX->pbImportProcs = pModLX->pbFixupSection + pModLX->Hdr.e32_impproc - off;
	908	}
	909	else
	910	kldrHlpFree(pv);
	911	return rc;
[2882]	912	}
	913
	914
[2879]	915	/** @copydoc kLdrModEnumSymbols */
	916	static int kldrModLXEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
	917	uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
	918	{
	919	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
[2883]	920	/* int rc; */
[2879]	921
	922	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
	923
	924	return -1;
	925	}
	926
	927
[2882]	928	/**
	929	* Lookup a name table entry by ordinal.
	930	*
	931	* @returns Pointer to the name table entry if found.
	932	* @returns NULL if not found.
	933	* @param pbNameTable Pointer to the name table that should be searched.
	934	* @param cbNameTable The size of the name table.
	935	* @param iOrdinal The ordinal to search for.
	936	*/
	937	static const uint8_t kldrModLXDoNameTableLookupByOrdinal(const uint8_t pbNameTable, int32_t cbNameTable, uint32_t iOrdinal)
	938	{
	939	while (*pbNameTable != 0 && cbNameTable > 0)
	940	{
	941	const uint8_t cbName = *pbNameTable;
	942	uint32_t iName;
	943
	944	cbNameTable -= cbName + 1 + 2;
	945	if (cbNameTable < 0)
	946	break;
	947
[2887]	948	iName = *(pbNameTable + cbName + 1)
	949	\| ((unsigned)*(pbNameTable + cbName + 2) << 8);
[2882]	950	if (iName == iOrdinal)
	951	return pbNameTable;
	952
	953	/* next entry */
	954	pbNameTable += cbName + 1 + 2;
	955	}
	956
	957	return NULL;
	958	}
	959
	960
[2879]	961	/** @copydoc kLdrModGetImport */
	962	static int kldrModLXGetImport(PKLDRMOD pMod, const void pvBits, uint32_t iImport, char pszName, size_t cchName)
	963	{
[2887]	964	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	965	const uint8_t * pb;
[2879]	966	int rc;
	967
[2887]	968	/*
	969	* Validate
	970	*/
	971	if (iImport >= pModLX->Hdr.e32_impmodcnt)
	972	return KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS;
[2879]	973
[2887]	974	/*
	975	* Lazy loading the fixup section.
	976	*/
	977	if (!pModLX->pbImportMods)
	978	{
	979	rc = kldrModLXDoLoadFixupSection(pModLX);
	980	if (rc)
	981	return rc;
	982	}
	983
	984	/*
	985	* Iterate the module import table until we reach the requested import ordinal.
	986	*/
	987	pb = pModLX->pbImportMods;
	988	while (iImport-- > 0)
	989	pb += *pb + 1;
	990
	991	/*
	992	* Copy out the result.
	993	*/
[2879]	994	if (*pb < cchName)
	995	{
	996	kLdrHlpMemCopy(pszName, pb + 1, *pb);
	997	pszName[*pb] = '\0';
	998	rc = 0;
	999	}
	1000	else
	1001	{
	1002	kLdrHlpMemCopy(pszName, pb + 1, cchName);
	1003	if (cchName)
	1004	pszName[cchName - 1] = '\0';
	1005	rc = KLDR_ERR_BUFFER_OVERFLOW;
	1006	}
	1007
	1008	return rc;
	1009	}
	1010
	1011
	1012	/** @copydoc kLdrModNumberOfImports */
	1013	static int32_t kldrModLXNumberOfImports(PKLDRMOD pMod, const void *pvBits)
	1014	{
	1015	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1016	return pModLX->Hdr.e32_impmodcnt;
	1017	}
	1018
	1019
	1020	/** @copydoc kLdrModGetStackInfo */
	1021	static int kldrModLXGetStackInfo(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo)
	1022	{
	1023	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1024	const uint32_t i = pModLX->Hdr.e32_stackobj;
	1025
	1026	if ( i
	1027	&& i <= pMod->cSegments
	1028	&& pModLX->Hdr.e32_esp <= pMod->aSegments[i - 1].LinkAddress + pMod->aSegments[i - 1].cb
	1029	&& pModLX->Hdr.e32_stacksize
	1030	&& pModLX->Hdr.e32_esp - pModLX->Hdr.e32_stacksize >= pMod->aSegments[i - 1].LinkAddress)
	1031	{
	1032
	1033	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
	1034	pStackInfo->LinkAddress = pModLX->Hdr.e32_esp - pModLX->Hdr.e32_stacksize;
	1035	pStackInfo->Address = BaseAddress
	1036	+ pMod->aSegments[i - 1].RVA
	1037	+ pModLX->Hdr.e32_esp - pModLX->Hdr.e32_stacksize - pMod->aSegments[i - 1].LinkAddress;
	1038	}
	1039	else
	1040	{
	1041	pStackInfo->Address = NIL_KLDRADDR;
	1042	pStackInfo->LinkAddress = NIL_KLDRADDR;
	1043	}
	1044	pStackInfo->cbStack = pModLX->Hdr.e32_stacksize;
	1045	pStackInfo->cbStackThread = 0;
	1046
	1047	return 0;
	1048	}
	1049
	1050
	1051	/** @copydoc kLdrModQueryMainEntrypoint */
	1052	static int kldrModLXQueryMainEntrypoint(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRADDR pMainEPAddress)
	1053	{
	1054	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1055
	1056	/*
	1057	* Convert the address from the header.
	1058	*/
	1059	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
	1060	*pMainEPAddress = pModLX->Hdr.e32_startobj
	1061	&& pModLX->Hdr.e32_startobj <= pMod->cSegments
	1062	&& pModLX->Hdr.e32_eip < pMod->aSegments[pModLX->Hdr.e32_startobj - 1].cb
	1063	? BaseAddress + pMod->aSegments[pModLX->Hdr.e32_startobj - 1].RVA + pModLX->Hdr.e32_eip
	1064	: NIL_KLDRADDR;
	1065	return 0;
	1066	}
	1067
	1068
	1069	/** @copydoc kLdrModEnumDbgInfo */
	1070	static int kldrModLXEnumDbgInfo(PKLDRMOD pMod, const void pvBits, PFNKLDRENUMDBG pfnCallback, void pvUser)
	1071	{
[2883]	1072	/PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;/
[2879]	1073
	1074	/*
	1075	* Quit immediately if no debug info.
	1076	*/
	1077	if (kldrModLXHasDbgInfo(pMod, pvBits))
	1078	return 0;
	1079	#if 0
	1080	/*
	1081	* Read the debug info and look for familiar magics and structures.
	1082	*/
	1083	/** @todo */
	1084	#endif
	1085
	1086	return 0;
	1087	}
	1088
	1089
	1090	/** @copydoc kLdrModHasDbgInfo */
	1091	static int kldrModLXHasDbgInfo(PKLDRMOD pMod, const void *pvBits)
	1092	{
	1093	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1094
	1095	/*
	1096	* Don't curretnly bother with linkers which doesn't advertise it in the header.
	1097	*/
	1098	if ( !pModLX->Hdr.e32_debuginfo
	1099	\|\| !pModLX->Hdr.e32_debuglen)
	1100	return KLDR_ERR_NO_DEBUG_INFO;
	1101	return 0;
	1102	}
	1103
	1104
	1105	/** @copydoc kLdrModMap */
	1106	static int kldrModLXMap(PKLDRMOD pMod)
	1107	{
	1108	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1109	unsigned fFixed;
	1110	void *pvBase;
	1111	int rc;
	1112
	1113	/*
	1114	* Already mapped?
	1115	*/
	1116	if (pModLX->pvMapping)
	1117	return KLDR_ERR_ALREADY_MAPPED;
	1118
	1119	/*
	1120	* Allocate memory for it.
	1121	*/
	1122	/* fixed image? */
	1123	fFixed = pMod->enmType == KLDRTYPE_EXECUTABLE_FIXED
	1124	\|\| pMod->enmType == KLDRTYPE_SHARED_LIBRARY_FIXED;
	1125	if (!fFixed)
	1126	pvBase = NULL;
	1127	else
	1128	{
	1129	pvBase = (void *)(uintptr_t)pMod->aSegments[0].LinkAddress;
	1130	if ((uintptr_t)pvBase != pMod->aSegments[0].LinkAddress)
	1131	return KLDR_ERR_ADDRESS_OVERFLOW;
	1132	}
	1133	rc = kldrHlpPageAlloc(&pvBase, pModLX->cbMapped, KLDRPROT_EXECUTE_READWRITE, fFixed);
	1134	if (rc)
	1135	return rc;
	1136
	1137	/*
	1138	* Load the bits, apply page protection, and update the segment table.
	1139	*/
	1140	rc = kldrModLXDoLoadBits(pModLX, pvBase);
	1141	if (!rc)
	1142	rc = kldrModLXDoProtect(pModLX, pvBase, 0 /* protect */);
	1143	if (!rc)
	1144	{
	1145	uint32_t i;
	1146	for (i = 0; i < pMod->cSegments; i++)
	1147	{
	1148	if (pMod->aSegments[i].RVA != NIL_KLDRADDR)
	1149	pMod->aSegments[i].MapAddress = (uintptr_t)pvBase + (uintptr_t)pMod->aSegments[i].RVA;
	1150	}
	1151	pModLX->pvMapping = pvBase;
	1152	}
	1153	else
	1154	kldrHlpPageFree(pvBase, pModLX->cbMapped);
	1155	return rc;
	1156	}
	1157
	1158
	1159	/**
	1160	* Loads the LX pages into the specified memory mapping.
	1161	*
	1162	* @returns 0 on success.
	1163	* @returns non-zero kLdr or OS status code on failure.
	1164	*
	1165	* @param pModLX The LX module interpreter instance.
	1166	* @param pvBits Where to load the bits.
	1167	*/
	1168	static int kldrModLXDoLoadBits(PKLDRMODLX pModLX, void *pvBits)
	1169	{
[2880]	1170	const PKLDRRDR pRdr = pModLX->pMod->pRdr;
	1171	uint8_t *pbTmpPage = NULL;
	1172	int rc = 0;
	1173	uint32_t i;
[2879]	1174
[2880]	1175	/*
	1176	* Iterate the segments.
	1177	*/
	1178	for (i = 0; i < pModLX->Hdr.e32_objcnt; i++)
	1179	{
	1180	const struct o32_obj * const pObj = &pModLX->paObjs[i];
	1181	const uint32_t cPages = pModLX->pMod->aSegments[i].cbMapped / OBJPAGELEN;
	1182	uint32_t iPage;
	1183	uint8_t pbPage = (uint8_t )pvBits + (uintptr_t)pModLX->pMod->aSegments[i].RVA;
	1184
	1185	/*
	1186	* Iterate the page map pages.
	1187	*/
	1188	for (iPage = 0; !rc && iPage < pObj->o32_mapsize; iPage++, pbPage += OBJPAGELEN)
	1189	{
	1190	const struct o32_map *pMap = &pModLX->paPageMappings[iPage + pObj->o32_pagemap - 1];
	1191	switch (pMap->o32_pageflags)
	1192	{
	1193	case VALID:
	1194	if (pMap->o32_pagesize == OBJPAGELEN)
	1195	rc = kLdrRdrRead(pRdr, pbPage, OBJPAGELEN, pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift);
	1196	else if (pMap->o32_pagesize < OBJPAGELEN)
	1197	{
	1198	rc = kLdrRdrRead(pRdr, pbPage, pMap->o32_pagesize, pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift);
	1199	kLdrHlpMemSet(pbPage + pMap->o32_pagesize, 0, OBJPAGELEN - pMap->o32_pagesize);
	1200	}
	1201	else
	1202	rc = KLDR_ERR_LX_BAD_PAGE_MAP;
	1203	break;
	1204
	1205	case ITERDATA:
	1206	case ITERDATA2:
	1207	/* make sure we've got a temp page .*/
	1208	if (!pbTmpPage)
	1209	{
	1210	pbTmpPage = kldrHlpAlloc(OBJPAGELEN + 256);
	1211	if (!pbTmpPage)
	1212	break;
	1213	}
	1214	/* validate the size. */
	1215	if (pMap->o32_pagesize > OBJPAGELEN + 252)
	1216	{
	1217	rc = KLDR_ERR_LX_BAD_PAGE_MAP;
	1218	break;
	1219	}
	1220
	1221	/* read it and ensure 4 extra zero bytes. */
	1222	rc = kLdrRdrRead(pRdr, pbTmpPage, pMap->o32_pagesize, pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift);
	1223	if (rc)
	1224	break;
	1225	kLdrHlpMemSet(pbTmpPage + pMap->o32_pagesize, 0, 4);
	1226
	1227	/* unpack it into the image page. */
	1228	if (pMap->o32_pageflags == ITERDATA2)
	1229	rc = kldrModLXDoIterData2Unpacking(pbPage, pbTmpPage, pMap->o32_pagesize);
	1230	else
	1231	rc = kldrModLXDoIterDataUnpacking(pbPage, pbTmpPage, pMap->o32_pagesize);
	1232	break;
	1233
	1234	case INVALID: /* we're probably not dealing correctly with INVALID pages... */
	1235	case ZEROED:
	1236	kLdrHlpMemSet(pbPage, 0, OBJPAGELEN);
	1237	break;
	1238
	1239	case RANGE:
	1240	KLDRMODLX_ASSERT(!"RANGE");
	1241	default:
	1242	rc = KLDR_ERR_LX_BAD_PAGE_MAP;
	1243	break;
	1244	}
	1245	}
	1246	if (rc)
	1247	break;
	1248
	1249	/*
	1250	* Zero the remaining pages.
	1251	*/
	1252	if (iPage < cPages)
	1253	kLdrHlpMemSet(pbPage, 0, (cPages - iPage) * OBJPAGELEN);
	1254	}
	1255
	1256	if (pbTmpPage)
	1257	kldrHlpFree(pbTmpPage);
	1258	return rc;
[2879]	1259	}
	1260
	1261
	1262	/**
[2880]	1263	* Unpacks iterdata (aka EXEPACK).
	1264	*
	1265	* @returns 0 on success, non-zero kLdr status code on failure.
	1266	* @param pbDst Where to put the uncompressed data. (Assumes OBJPAGELEN size.)
	1267	* @param pbSrc The compressed source data.
	1268	* @param cbSrc The file size of the compressed data. The source buffer
	1269	* contains 4 additional zero bytes.
	1270	*/
	1271	static int kldrModLXDoIterDataUnpacking(uint8_t pbDst, const uint8_t pbSrc, int cbSrc)
	1272	{
	1273	const struct LX_Iter pIter = (const struct LX_Iter )pbSrc;
	1274	int cbDst = OBJPAGELEN;
	1275
	1276	/* Validate size of data. */
	1277	if (cbSrc >= OBJPAGELEN - 2)
	1278	return KLDR_ERR_LX_BAD_ITERDATA;
	1279
	1280	/*
	1281	* Expand the page.
	1282	*/
	1283	while (cbSrc > 0 && pIter->LX_nIter)
	1284	{
	1285	if (pIter->LX_nBytes == 1)
	1286	{
	1287	/*
	1288	* Special case - one databyte.
	1289	*/
	1290	cbDst -= pIter->LX_nIter;
	1291	if (cbDst < 0)
	1292	return KLDR_ERR_LX_BAD_ITERDATA;
	1293
	1294	cbSrc -= 4 + 1;
	1295	if (cbSrc < -4)
	1296	return KLDR_ERR_LX_BAD_ITERDATA;
	1297
	1298	kLdrHlpMemSet(pbDst, pIter->LX_Iterdata, pIter->LX_nIter);
	1299	pbDst += pIter->LX_nIter;
	1300	pIter++;
	1301	}
	1302	else
	1303	{
	1304	/*
	1305	* General.
	1306	*/
	1307	int i;
	1308
	1309	cbDst -= pIter->LX_nIter * pIter->LX_nBytes;
	1310	if (cbDst < 0)
	1311	return KLDR_ERR_LX_BAD_ITERDATA;
	1312
	1313	cbSrc -= 4 + pIter->LX_nBytes;
	1314	if (cbSrc < -4)
	1315	return KLDR_ERR_LX_BAD_ITERDATA;
	1316
	1317	for (i = pIter->LX_nIter; i > 0; i--, pbDst += pIter->LX_nBytes)
[2883]	1318	kLdrHlpMemCopy(pbDst, &pIter->LX_Iterdata, pIter->LX_nBytes);
[2880]	1319	pIter = (struct LX_Iter )((char)pIter + 4 + pIter->LX_nBytes);
	1320	}
	1321	}
	1322
	1323	/*
	1324	* Zero remainder of the page.
	1325	*/
	1326	if (cbDst > 0)
	1327	kLdrHlpMemSet(pbDst, 0, cbDst);
	1328
	1329	return 0;
	1330	}
	1331
	1332
	1333	/**
	1334	* Unpacks iterdata (aka EXEPACK).
	1335	*
	1336	* @returns 0 on success, non-zero kLdr status code on failure.
	1337	* @param pbDst Where to put the uncompressed data. (Assumes OBJPAGELEN size.)
	1338	* @param pbSrc The compressed source data.
	1339	* @param cbSrc The file size of the compressed data. The source buffer
	1340	* contains 4 additional zero bytes.
	1341	*/
	1342	static int kldrModLXDoIterData2Unpacking(uint8_t pbDst, const uint8_t pbSrc, int cbSrc)
	1343	{
	1344	int cbDst = OBJPAGELEN;
	1345
	1346	while (cbSrc > 0)
	1347	{
	1348	/*
	1349	* Bit 0 and 1 is the encoding type.
	1350	*/
	1351	switch (*pbSrc & 0x03)
	1352	{
	1353	/*
	1354	*
	1355	* 0 1 2 3 4 5 6 7
	1356	* type \| \|
	1357	* ----------------
	1358	* cb <cb bytes of data>
	1359	*
	1360	* Bits 2-7 is, if not zero, the length of an uncompressed run
	1361	* starting at the following byte.
	1362	*
	1363	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
	1364	* type \| \| \| \| \| \|
	1365	* ---------------- ---------------------- -----------------------
	1366	* zero cb char to multiply
	1367	*
	1368	* If the bits are zero, the following two bytes describes a 1 byte interation
	1369	* run. First byte is count, second is the byte to copy. A count of zero is
	1370	* means end of data, and we simply stops. In that case the rest of the data
	1371	* should be zero.
	1372	*/
	1373	case 0:
	1374	{
	1375	if (*pbSrc)
	1376	{
	1377	const int cb = *pbSrc >> 2;
	1378	cbDst -= cb;
	1379	if (cbDst < 0)
	1380	return KLDR_ERR_LX_BAD_ITERDATA2;
	1381	cbSrc -= cb;
	1382	if (cbSrc < 0)
	1383	return KLDR_ERR_LX_BAD_ITERDATA2;
	1384	kLdrHlpMemCopy(pbDst, ++pbSrc, cb);
	1385	pbDst += cb;
	1386	pbSrc += cb;
	1387	}
	1388	else if (cbSrc < 2)
	1389	return KLDR_ERR_LX_BAD_ITERDATA2;
	1390	else
	1391	{
	1392	const int cb = pbSrc[1];
	1393	if (!cb)
	1394	goto l_endloop;
	1395	cbDst -= cb;
	1396	if (cbDst < 0)
	1397	return KLDR_ERR_LX_BAD_ITERDATA2;
	1398	cbSrc -= 3;
	1399	if (cbSrc < 0)
	1400	return KLDR_ERR_LX_BAD_ITERDATA2;
[2883]	1401	kLdrHlpMemSet(pbDst, pbSrc[2], cb);
[2880]	1402	pbDst += cb;
	1403	pbSrc += 3;
	1404	}
	1405	break;
	1406	}
	1407
	1408
	1409	/*
	1410	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
	1411	* type \| \| \| \| \| \|
	1412	* ---- ------- -------------------------
	1413	* cb1 cb2 - 3 offset <cb1 bytes of data>
	1414	*
	1415	* Two bytes layed out as described above, followed by cb1 bytes of data to be copied.
	1416	* The cb2(+3) and offset describes an amount of data to be copied from the expanded
	1417	* data relative to the current position. The data copied as you would expect it to be.
	1418	*/
	1419	case 1:
	1420	{
	1421	cbSrc -= 2;
	1422	if (cbSrc < 0)
	1423	return KLDR_ERR_LX_BAD_ITERDATA2;
	1424	else
	1425	{
	1426	const unsigned off = ((unsigned)pbSrc[1] << 1) \| (*pbSrc >> 7);
	1427	const int cb1 = (*pbSrc >> 2) & 3;
	1428	const int cb2 = ((*pbSrc >> 4) & 7) + 3;
	1429
	1430	pbSrc += 2;
	1431	cbSrc -= cb1;
	1432	if (cbSrc < 0)
	1433	return KLDR_ERR_LX_BAD_ITERDATA2;
	1434	cbDst -= cb1;
	1435	if (cbDst < 0)
	1436	return KLDR_ERR_LX_BAD_ITERDATA2;
	1437	kLdrHlpMemCopy(pbDst, pbSrc, cb1);
	1438	pbDst += cb1;
	1439
	1440	if (off > OBJPAGELEN - cbDst)
	1441	return KLDR_ERR_LX_BAD_ITERDATA2;
	1442	cbDst -= cb2;
	1443	if (cbDst < 0)
	1444	return KLDR_ERR_LX_BAD_ITERDATA2;
	1445	kLdrHlpMemMove(pbDst, pbDst - off, cb2);
	1446	pbDst += cb2;
	1447	}
	1448	break;
	1449	}
	1450
	1451
	1452	/*
	1453	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
	1454	* type \| \| \| \|
	1455	* ---- ----------------------------------
	1456	* cb-3 offset
	1457	*
	1458	* Two bytes layed out as described above.
	1459	* The cb(+3) and offset describes an amount of data to be copied from the expanded
	1460	* data relative to the current position.
	1461	*
	1462	* If offset == 1 the data is not copied as expected, but in the memcpyw manner.
	1463	*/
	1464	case 2:
	1465	{
	1466	cbSrc -= 2;
	1467	if (cbSrc < 0)
	1468	return KLDR_ERR_LX_BAD_ITERDATA2;
	1469	else
	1470	{
	1471	const unsigned off = ((unsigned)pbSrc[2] << 4) \| (*pbSrc >> 4);
	1472	const int cb = ((*pbSrc >> 2) & 3) + 3;
	1473
	1474	pbSrc += 2;
	1475	if (off > OBJPAGELEN - cbDst)
	1476	return KLDR_ERR_LX_BAD_ITERDATA2;
	1477	cbDst -= cb;
	1478	if (cbDst < 0)
	1479	return KLDR_ERR_LX_BAD_ITERDATA2;
	1480	kLdrModLXMemCopyW(pbDst, pbDst - off, cb);
	1481	pbDst += cb;
	1482	}
	1483	break;
	1484	}
	1485
	1486
	1487	/*
	1488	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
	1489	* type \| \| \| \| \| \|
	1490	* ---------- ---------------- ----------------------------------
	1491	* cb1 cb2 offset <cb1 bytes of data>
	1492	*
	1493	* Three bytes layed out as described above, followed by cb1 bytes of data to be copied.
	1494	* The cb2 and offset describes an amount of data to be copied from the expanded
	1495	* data relative to the current position.
	1496	*
	1497	* If offset == 1 the data is not copied as expected, but in the memcpyw manner.
	1498	*/
	1499	case 3:
	1500	{
	1501	cbSrc -= 3;
	1502	if (cbSrc < 0)
	1503	return KLDR_ERR_LX_BAD_ITERDATA2;
	1504	else
	1505	{
	1506	const int cb1 = (*pbSrc >> 2) & 0xf;
	1507	const int cb2 = ((pbSrc[1] & 0xf) << 2) \| (*pbSrc >> 6);
	1508	const unsigned off = ((unsigned)pbSrc[2] << 4) \| (pbSrc[1] >> 4);
	1509
	1510	pbSrc += 3;
	1511	cbSrc -= cb1;
	1512	if (cbSrc < 0)
	1513	return KLDR_ERR_LX_BAD_ITERDATA2;
	1514	cbDst -= cb1;
	1515	if (cbDst < 0)
	1516	return KLDR_ERR_LX_BAD_ITERDATA2;
	1517	kLdrHlpMemCopy(pbDst, pbSrc, cb1);
	1518	pbDst += cb1;
	1519
	1520	if (off > OBJPAGELEN - cbDst)
	1521	return KLDR_ERR_LX_BAD_ITERDATA2;
	1522	cbDst -= cb2;
	1523	if (cbDst < 0)
	1524	return KLDR_ERR_LX_BAD_ITERDATA2;
	1525	kLdrModLXMemCopyW(pbDst, pbDst - off, cb2);
	1526	pbDst += cb2;
	1527	}
	1528	break;
	1529	}
	1530	} /* type switch. */
	1531	} /* unpack loop */
	1532
	1533	l_endloop:
	1534
	1535
	1536	/*
	1537	* Zero remainder of the page.
	1538	*/
	1539	if (cbDst > 0)
	1540	kLdrHlpMemSet(pbDst, 0, cbDst);
	1541
	1542	return 0;
	1543	}
	1544
	1545
	1546	/**
	1547	* Special memcpy employed by the iterdata2 algorithm.
	1548	*
	1549	* Emulate a 16-bit memcpy (copying 16-bit at a time) and the effects this
	1550	* has if src is very close to the destination.
	1551	*
	1552	* @param pbDst Destination pointer.
	1553	* @param pbSrc Source pointer. Will always be <= pbDst.
	1554	* @param cb Amount of data to be copied.
	1555	* @remark This assumes that unaligned word and dword access is fine.
	1556	*/
	1557	static void kLdrModLXMemCopyW(uint8_t pbDst, const uint8_t pbSrc, int cb)
	1558	{
	1559	switch (pbDst - pbSrc)
	1560	{
	1561	case 0:
	1562	case 1:
	1563	case 2:
	1564	case 3:
	1565	/* 16-bit copy (unaligned) */
	1566	if (cb & 1)
[2883]	1567	pbDst++ = pbSrc++;
[2880]	1568	for (cb >>= 1; cb > 0; cb--, pbDst += 2, pbSrc += 2)
	1569	(uint16_t )pbDst = (const uint16_t )pbSrc;
	1570	break;
	1571
	1572	default:
	1573	/* 32-bit copy (unaligned) */
	1574	if (cb & 1)
[2883]	1575	pbDst++ = pbSrc++;
[2880]	1576	if (cb & 2)
	1577	{
	1578	(uint16_t )pbDst = (const uint16_t )pbSrc;
	1579	pbDst += 2;
	1580	pbSrc += 2;
	1581	}
	1582	for (cb >>= 2; cb > 0; cb--, pbDst += 4, pbSrc += 4)
	1583	(uint32_t )pbDst = (const uint32_t )pbSrc;
	1584	break;
	1585	}
	1586	}
	1587
	1588
	1589	/**
[2879]	1590	* Unprotects or protects the specified image mapping.
	1591	*
	1592	* @returns 0 on success.
	1593	* @returns non-zero kLdr or OS status code on failure.
	1594	*
	1595	* @param pModLX The LX module interpreter instance.
	1596	* @param pvBits The mapping to protect.
	1597	* @param UnprotectOrProtect If 1 unprotect (i.e. make all writable), otherwise
	1598	* protect according to the object table.
	1599	*/
[2882]	1600	static int kldrModLXDoProtect(PKLDRMODLX pModLX, void *pvBits, unsigned fUnprotectOrProtect)
[2879]	1601	{
[2882]	1602	uint32_t i;
	1603	PKLDRMOD pMod = pModLX->pMod;
	1604
	1605	/*
	1606	* Change object protection.
	1607	*/
	1608	for (i = 0; i < pMod->cSegments; i++)
	1609	{
	1610	int rc;
	1611	void *pv;
	1612	KLDRPROT enmProt;
	1613
	1614	/* calc new protection. */
	1615	enmProt = pMod->aSegments[i].enmProt;
	1616	if (fUnprotectOrProtect)
	1617	{
	1618	switch (enmProt)
	1619	{
	1620	case KLDRPROT_NOACCESS:
	1621	case KLDRPROT_READONLY:
	1622	case KLDRPROT_READWRITE:
	1623	case KLDRPROT_WRITECOPY:
	1624	enmProt = KLDRPROT_READWRITE;
	1625	break;
	1626	case KLDRPROT_EXECUTE:
	1627	case KLDRPROT_EXECUTE_READ:
	1628	case KLDRPROT_EXECUTE_READWRITE:
	1629	case KLDRPROT_EXECUTE_WRITECOPY:
	1630	enmProt = KLDRPROT_EXECUTE_READWRITE;
	1631	break;
	1632	default:
	1633	KLDRMODLX_ASSERT(!"bad enmProt");
	1634	return -1;
	1635	}
	1636	}
	1637	else
	1638	{
	1639	/* copy on write -> normal write. */
	1640	if (enmProt == KLDRPROT_EXECUTE_WRITECOPY)
	1641	enmProt = KLDRPROT_EXECUTE_READWRITE;
	1642	else if (enmProt == KLDRPROT_WRITECOPY)
	1643	enmProt = KLDRPROT_READWRITE;
	1644	}
	1645
	1646
	1647	/* calc the address and set page protection. */
	1648	pv = (uint8_t *)pvBits + pMod->aSegments[i].RVA;
	1649
	1650	rc = kldrHlpPageProtect(pv, pMod->aSegments[i].cbMapped, enmProt);
	1651	if (rc)
	1652	break;
	1653
	1654	/** @todo the gap page should be marked NOACCESS! */
	1655	}
	1656
	1657	return 0;
[2879]	1658	}
	1659
	1660
	1661	/** @copydoc kLdrModUnmap */
	1662	static int kldrModLXUnmap(PKLDRMOD pMod)
	1663	{
	1664	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1665	uint32_t i;
	1666	int rc;
	1667
	1668	/*
	1669	* Mapped?
	1670	*/
	1671	if (!pModLX->pvMapping)
	1672	return KLDR_ERR_NOT_MAPPED;
	1673
	1674	/*
	1675	* Free the mapping and update the segments.
	1676	*/
	1677	rc = kldrHlpPageFree((void *)pModLX->pvMapping, pModLX->cbMapped);
	1678	KLDRMODLX_ASSERT(!rc);
	1679	pModLX->pvMapping = NULL;
	1680
	1681	for (i = 0; i < pMod->cSegments; i++)
	1682	pMod->aSegments[i].MapAddress = 0;
	1683
	1684	return rc;
	1685	}
	1686
	1687
	1688	/** @copydoc kLdrModAllocTLS */
	1689	static int kldrModLXAllocTLS(PKLDRMOD pMod)
	1690	{
	1691	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1692
[2882]	1693	/* no tls, just do the error checking. */
[2879]	1694	if (!pModLX->pvMapping)
	1695	return KLDR_ERR_NOT_MAPPED;
	1696	return 0;
	1697	}
	1698
	1699
	1700	/** @copydoc kLdrModFreeTLS */
	1701	static void kldrModLXFreeTLS(PKLDRMOD pMod)
	1702	{
[2882]	1703	/* no tls. */
[2879]	1704	}
	1705
	1706
	1707	/** @copydoc kLdrModReload */
	1708	static int kldrModLXReload(PKLDRMOD pMod)
	1709	{
	1710	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1711
	1712	/*
	1713	* Mapped?
	1714	*/
	1715	if (!pModLX->pvMapping)
	1716	return KLDR_ERR_NOT_MAPPED;
	1717
	1718	/* the file provider does it all */
	1719	return kLdrRdrRefresh(pMod->pRdr, (void *)pModLX->pvMapping, pMod->cSegments, pMod->aSegments);
	1720	}
	1721
	1722
	1723	/** @copydoc kLdrModFixupMapping */
	1724	static int kldrModLXFixupMapping(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
	1725	{
	1726	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1727	int rc, rc2;
	1728
	1729	/*
	1730	* Mapped?
	1731	*/
	1732	if (!pModLX->pvMapping)
	1733	return KLDR_ERR_NOT_MAPPED;
	1734
	1735	/*
	1736	* Before doing anything we'll have to make all pages writable.
	1737	*/
[2882]	1738	rc = kldrModLXDoProtect(pModLX, (void )pModLX->pvMapping, 1 / unprotect */);
[2879]	1739	if (rc)
	1740	return rc;
	1741
	1742	/*
	1743	* Apply fixups and resolve imports.
	1744	*/
	1745	rc = kldrModLXRelocateBits(pMod, (void *)pModLX->pvMapping, (uintptr_t)pModLX->pvMapping,
	1746	pMod->aSegments[0].LinkAddress, pfnGetImport, pvUser);
	1747
	1748	/*
	1749	* Restore protection.
	1750	*/
[2882]	1751	rc2 = kldrModLXDoProtect(pModLX, (void )pModLX->pvMapping, 0 / protect */);
[2879]	1752	if (!rc && rc2)
	1753	rc = rc2;
	1754	return rc;
	1755	}
	1756
	1757
	1758	/** @copydoc kLdrModCallInit */
	1759	static int kldrModLXCallInit(PKLDRMOD pMod, uintptr_t uHandle)
	1760	{
	1761	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1762	int rc;
	1763
	1764	/*
	1765	* Mapped?
	1766	*/
	1767	if (!pModLX->pvMapping)
	1768	return KLDR_ERR_NOT_MAPPED;
	1769
	1770	/*
	1771	* Do TLS callbacks first and then call the init/term function if it's a DLL.
	1772	*/
	1773	if ((pModLX->Hdr.e32_mflags & E32MODMASK) == E32MODDLL)
	1774	rc = kldrModLXDoCallDLL(pModLX, 0 /* attach */, uHandle);
	1775	else
	1776	rc = 0;
	1777	return rc;
	1778	}
	1779
	1780
	1781	/**
	1782	* Call the DLL entrypoint.
	1783	*
	1784	* @returns 0 on success.
	1785	* @returns KLDR_ERR_MODULE_INIT_FAILED or KLDR_ERR_THREAD_ATTACH_FAILED on failure.
	1786	* @param pModLX The LX module interpreter instance.
	1787	* @param uOp The operation (DLL_*).
	1788	* @param uHandle The module handle to present.
	1789	*/
	1790	static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, unsigned uOp, uintptr_t uHandle)
	1791	{
	1792	int rc;
	1793
	1794	/*
	1795	* If no entrypoint there isn't anything to be done.
	1796	*/
	1797	if ( !pModLX->Hdr.e32_startobj
	1798	\|\| pModLX->Hdr.e32_startobj > pModLX->Hdr.e32_objcnt)
	1799	return 0;
	1800
	1801	/*
	1802	* Invoke the entrypoint and convert the boolean result to a kLdr status code.
	1803	*/
	1804	rc = kldrModLXDoCall((uintptr_t)pModLX->pvMapping
	1805	+ (uintptr_t)pModLX->pMod->aSegments[pModLX->Hdr.e32_startobj - 1].RVA
	1806	+ pModLX->Hdr.e32_eip,
	1807	uHandle, uOp, NULL);
	1808	if (rc)
	1809	rc = 0;
	1810	else if (uOp == 0 /* attach */)
	1811	rc = KLDR_ERR_MODULE_INIT_FAILED;
	1812	else /* detach: ignore failures */
	1813	rc = 0;
	1814	return rc;
	1815	}
	1816
	1817
	1818	/**
	1819	* Do a 3 parameter callback.
	1820	*
	1821	* @returns 32-bit callback return.
	1822	* @param uEntrypoint The address of the function to be called.
	1823	* @param uHandle The first argument, the module handle.
	1824	* @param uOp The second argumnet, the reason we're calling.
	1825	* @param pvReserved The third argument, reserved argument. (figure this one out)
	1826	*/
	1827	static int32_t kldrModLXDoCall(uintptr_t uEntrypoint, uintptr_t uHandle, uint32_t uOp, void *pvReserved)
	1828	{
	1829	#if defined(__X86__) \|\| defined(__i386__) \|\| defined(_M_IX86)
	1830	int32_t rc;
	1831	/** @todo try/except */
	1832
	1833	/*
	1834	* Paranoia.
	1835	*/
	1836	# ifdef __GNUC__
	1837	__asm__ __volatile__(
	1838	"pushl %2\n\t"
	1839	"pushl %1\n\t"
	1840	"pushl %0\n\t"
	1841	"lea 12(%%esp), %2\n\t"
	1842	"call *%3\n\t"
	1843	"movl %2, %%esp\n\t"
	1844	: "=a" (rc)
	1845	: "d" (uOp),
	1846	"S" (0),
	1847	"c" (uEntrypoint),
	1848	"0" (uHandle));
	1849	# elif defined(_MSC_VER)
	1850	__asm {
	1851	mov eax, [uHandle]
	1852	mov edx, [uOp]
	1853	mov ecx, 0
	1854	mov ebx, [uEntrypoint]
	1855	push edi
	1856	mov edi, esp
	1857	push ecx
	1858	push edx
	1859	push eax
	1860	call ebx
	1861	mov esp, edi
	1862	pop edi
	1863	mov [rc], eax
	1864	}
	1865	# else
	1866	# error "port me!"
	1867	# endif
	1868	return rc;
	1869
	1870	#else
	1871	return KLDR_ERR_ARCH_CPU_NOT_COMPATIBLE;
	1872	#endif
	1873	}
	1874
	1875
	1876	/** @copydoc kLdrModCallTerm */
	1877	static int kldrModLXCallTerm(PKLDRMOD pMod, uintptr_t uHandle)
	1878	{
	1879	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1880
	1881	/*
	1882	* Mapped?
	1883	*/
	1884	if (!pModLX->pvMapping)
	1885	return KLDR_ERR_NOT_MAPPED;
	1886
	1887	/*
	1888	* Do the call.
	1889	*/
	1890	if ((pModLX->Hdr.e32_mflags & E32MODMASK) == E32MODDLL)
	1891	kldrModLXDoCallDLL(pModLX, 1 /* detach */, uHandle);
	1892
	1893	return 0;
	1894	}
	1895
	1896
	1897	/** @copydoc kLdrModCallThread */
	1898	static int kldrModLXCallThread(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching)
	1899	{
[2882]	1900	/* no thread attach/detach callout. */
[2879]	1901	return 0;
	1902	}
	1903
	1904
	1905	/** @copydoc kLdrModSize */
	1906	static KLDRADDR kldrModLXSize(PKLDRMOD pMod)
	1907	{
	1908	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1909	return pModLX->cbMapped;
	1910	}
	1911
	1912
	1913	/** @copydoc kLdrModGetBits */
	1914	static int kldrModLXGetBits(PKLDRMOD pMod, void pvBits, KLDRADDR BaseAddress, PFNKLDRMODGETIMPORT pfnGetImport, void pvUser)
	1915	{
	1916	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1917	int rc;
	1918
	1919	/*
	1920	* Load the image bits.
	1921	*/
	1922	rc = kldrModLXDoLoadBits(pModLX, pvBits);
	1923	if (rc)
	1924	return rc;
	1925
	1926	/*
	1927	* Perform relocations.
	1928	*/
	1929	return kldrModLXRelocateBits(pMod, pvBits, BaseAddress, pMod->aSegments[0].LinkAddress, pfnGetImport, pvUser);
	1930
	1931	}
	1932
	1933
	1934	/** @copydoc kLdrModRelocateBits */
	1935	static int kldrModLXRelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
	1936	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
	1937	{
[2889]	1938	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1939	uint32_t i;
	1940	int rc;
[2879]	1941
[2889]	1942	/*
	1943	* Do we need to to anything?
	1944	*/
	1945	if ( NewBaseAddress == OldBaseAddress
	1946	&& NewBaseAddress == pModLX->paObjs[0].o32_base
	1947	&& !pModLX->Hdr.e32_impmodcnt)
	1948	return 0;
[2879]	1949
[2889]	1950	/*
	1951	* Load the fixup section.
	1952	*/
	1953	if (!pModLX->pbFixupSection)
	1954	{
	1955	rc = kldrModLXDoLoadFixupSection(pModLX);
	1956	if (rc)
	1957	return rc;
	1958	}
	1959
	1960	/*
	1961	* Iterate the segments.
	1962	*/
	1963	for (i = 0; i < pModLX->Hdr.e32_objcnt; i++)
	1964	{
	1965	const struct o32_obj * const pObj = &pModLX->paObjs[i];
	1966	uint32_t iPage;
	1967	uint8_t pbPage = (uint8_t )pvBits + (uintptr_t)pModLX->pMod->aSegments[i].RVA;
	1968
	1969	/*
	1970	* Iterate the page map pages.
	1971	*/
	1972	for (iPage = 0; !rc && iPage < pObj->o32_mapsize; iPage++, pbPage += OBJPAGELEN)
	1973	{
	1974	const uint8_t * const pbFixupRecEnd = pModLX->pbFixupRecs + pModLX->paoffPageFixups[iPage + pObj->o32_pagemap];
	1975	const uint8_t *pb = pModLX->pbFixupRecs + pModLX->paoffPageFixups[iPage + pObj->o32_pagemap - 1];
	1976	KLDRADDR uValue;
	1977	uint32_t fKind;
	1978
	1979	/* sanity */
	1980	if (pbFixupRecEnd < pb)
	1981	return KLDR_ERR_BAD_FIXUP;
	1982	if (pbFixupRecEnd - 1 > pModLX->pbFixupSectionLast)
	1983	return KLDR_ERR_BAD_FIXUP;
	1984	if (pb < pModLX->pbFixupSection)
	1985	return KLDR_ERR_BAD_FIXUP;
	1986
	1987	/*
	1988	* Iterate the fixup record.
	1989	*/
	1990	while (pb < pbFixupRecEnd)
	1991	{
	1992	union _rel
	1993	{
	1994	const uint8_t * pb;
	1995	const struct r32_rlc *prlc;
	1996	} u;
	1997
	1998	u.pb = pb;
	1999	pb += 3 + (u.prlc->nr_stype & NRCHAIN ? 0 : 1); /* place pch at the 4th member. */
	2000
	2001	/*
	2002	* Figure out the target.
	2003	*/
	2004	switch (u.prlc->nr_flags & NRRTYP)
	2005	{
	2006	/*
	2007	* Internal fixup.
	2008	*/
	2009	case NRRINT:
	2010	{
	2011	uint16_t iTrgObject;
	2012	uint32_t offTrgObject;
	2013
	2014	/* the object */
	2015	if (u.prlc->nr_flags & NR16OBJMOD)
	2016	{
	2017	iTrgObject = (const uint16_t )pb;
	2018	pb += 2;
	2019	}
	2020	else
	2021	iTrgObject = *pb++;
	2022	iTrgObject--;
	2023	if (iTrgObject >= pModLX->Hdr.e32_objcnt)
	2024	return KLDR_ERR_BAD_FIXUP;
	2025
	2026	/* the target */
	2027	if (u.prlc->nr_flags & NR32BITOFF)
	2028	{
	2029	offTrgObject = (const uint32_t )pb;
	2030	pb += 4;
	2031	}
	2032	else
	2033	{
	2034	offTrgObject = (const uint16_t )pb;
	2035	pb += 2;
	2036	}
	2037
	2038	/* calculate the symbol info. */
	2039	uValue = offTrgObject + pMod->aSegments[i].MapAddress;
	2040	fKind = 0;
	2041	break;
	2042	}
	2043
	2044	/*
	2045	* Import by symbol ordinal.
	2046	*/
	2047	case NRRORD:
	2048	{
	2049	uint16_t iModule;
	2050	uint32_t iSymbol;
	2051
	2052	/* the module ordinal */
	2053	if (u.prlc->nr_flags & NR16OBJMOD)
	2054	{
	2055	iModule = (const uint16_t )pb;
	2056	pb += 2;
	2057	}
	2058	else
	2059	iModule = *pb++;
	2060	iModule--;
	2061	if (iModule >= pModLX->Hdr.e32_impmodcnt)
	2062	return KLDR_ERR_BAD_FIXUP;
	2063
	2064	/* . */
	2065	if (u.prlc->nr_flags & NR32BITOFF)
	2066	{
	2067	iSymbol = (const uint32_t )pb;
	2068	pb += 4;
	2069	}
	2070	else if (!(u.prlc->nr_flags & NR8BITORD))
	2071	{
	2072	iSymbol = (const uint16_t )pb;
	2073	pb += 2;
	2074	}
	2075	else
	2076	iSymbol = *pb++;
	2077
	2078	/* resolve it. */
	2079	rc = pfnGetImport(pMod, iModule, iSymbol, NULL, &uValue, &fKind, pvUser);
	2080	if (rc)
	2081	return rc;
	2082	break;
	2083	}
	2084
	2085	/*
	2086	* Import by symbol name.
	2087	*/
	2088	case NRRNAM:
	2089	{
	2090	uint32_t iModule;
	2091	uint16_t offSymbol;
	2092	const uint8_t *pbSymbol;
	2093	char szSymbol[260];
	2094
	2095	/* the module ordinal */
	2096	if (u.prlc->nr_flags & NR16OBJMOD)
	2097	{
	2098	iModule = (const uint16_t )pb;
	2099	pb += 2;
	2100	}
	2101	else
	2102	iModule = *pb++;
	2103	iModule--;
	2104	if (iModule >= pModLX->Hdr.e32_impmodcnt)
	2105	return KLDR_ERR_BAD_FIXUP;
	2106	#if 1
	2107	if (u.prlc->nr_flags & NRCHAIN)
	2108	return KLDR_ERR_BAD_FIXUP;
	2109	#endif
	2110
	2111	/* . */
	2112	if (u.prlc->nr_flags & NR32BITOFF)
	2113	{
	2114	offSymbol = (const uint32_t )pb;
	2115	pb += 4;
	2116	}
	2117	else if (!(u.prlc->nr_flags & NR8BITORD))
	2118	{
	2119	offSymbol = (const uint16_t )pb;
	2120	pb += 2;
	2121	}
	2122	else
	2123	offSymbol = *pb++;
	2124	pbSymbol = pModLX->pbImportProcs + offSymbol;
	2125	if ( pbSymbol < pModLX->pbImportProcs
	2126	\|\| pbSymbol > pModLX->pbFixupSectionLast)
	2127	return KLDR_ERR_BAD_FIXUP;
	2128
	2129	/* resolve it. */
	2130	kLdrHlpMemCopy(szSymbol, pbSymbol + 1, *pbSymbol);
	2131	szSymbol[*pbSymbol] = '\0';
	2132	rc = pfnGetImport(pMod, iModule, NIL_KLDRMOD_SYM_ORDINAL, szSymbol, &uValue, &fKind, pvUser);
	2133	if (rc)
	2134	return rc;
	2135	break;
	2136	}
	2137
	2138	case NRRENT:
	2139	KLDRMODLX_ASSERT(!"NRRENT");
	2140	default:
	2141	break;
	2142	}
	2143
	2144	/* addend */
	2145	if (u.prlc->nr_flags & NRADD)
	2146	{
	2147	if (u.prlc->nr_flags & NR32BITADD)
	2148	{
	2149	uValue += (const uint32_t )pb;
	2150	pb += 4;
	2151	}
	2152	else
	2153	{
	2154	uValue += (const uint16_t )pb;
	2155	pb += 2;
	2156	}
	2157	}
	2158
	2159	/*
	2160	* Deal with the 'source' (i.e. the place that should be modified (very logical).
	2161	*/
	2162	if (!(u.prlc->nr_flags & NRCHAIN))
	2163	{
	2164	rc = kldrModLXDoReloc(pbPage, u.prlc->r32_soff, uValue, fKind);
	2165	if (rc)
	2166	return rc;
	2167	}
	2168	else if (!(u.prlc->nr_flags & NRICHAIN))
	2169	{
	2170	const uint16_t poffSrc = (const uint16_t )pb;
	2171	uint8_t c = u.pb[2];
	2172	while (c-- > 0)
	2173	{
	2174	rc = kldrModLXDoReloc(pbPage, *poffSrc++, uValue, fKind);
	2175	if (rc)
	2176	return rc;
	2177	}
	2178	}
	2179	else
	2180	{
	2181	KLDRMODLX_ASSERT(!"NRICHAIN");
	2182	return KLDR_ERR_LX_NRICHAIN_NOT_SUPPORTED;
	2183	}
	2184	}
	2185	}
	2186	}
	2187
	2188	return 0;
[2879]	2189	}
	2190
	2191
	2192	/**
[2889]	2193	* Applies the relocation to one 'source' in a page.
	2194	*
	2195	* @returns 0 on success, non-zero kLdr status code on failure.
	2196	* @param pbPage The page in which to apply the fixup.
	2197	* @param off Page relative offset of where to apply the offset.
	2198	* @param uValue The target value.
	2199	* @param fKind The target kind.
	2200	* @todo inline this.
	2201	*/
	2202	static int kldrModLXDoReloc(uint8_t *pbPage, int off, KLDRADDR uValue, uint32_t fKind)
	2203	{
	2204
	2205
	2206	return 0;
	2207	}
	2208
	2209
	2210	/**
[2879]	2211	* The LX module interpreter method table.
	2212	*/
	2213	KLDRMODOPS g_kLdrModLXOps =
	2214	{
	2215	"LX",
	2216	NULL,
	2217	kldrModLXCreate,
	2218	kldrModLXDestroy,
	2219	kldrModLXQuerySymbol,
	2220	kldrModLXEnumSymbols,
	2221	kldrModLXGetImport,
	2222	kldrModLXNumberOfImports,
	2223	NULL /* can execute one is optional */,
	2224	kldrModLXGetStackInfo,
	2225	kldrModLXQueryMainEntrypoint,
	2226	kldrModLXEnumDbgInfo,
	2227	kldrModLXHasDbgInfo,
	2228	kldrModLXMap,
	2229	kldrModLXUnmap,
	2230	kldrModLXAllocTLS,
	2231	kldrModLXFreeTLS,
	2232	kldrModLXReload,
	2233	kldrModLXFixupMapping,
	2234	kldrModLXCallInit,
	2235	kldrModLXCallTerm,
	2236	kldrModLXCallThread,
	2237	kldrModLXSize,
	2238	kldrModLXGetBits,
	2239	kldrModLXRelocateBits,
	2240	42 /* the end */
	2241	};
	2242

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

Download in other formats: