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
Line 
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/*
7 * Copyright (c) 2006-2007 Knut St. Osmundsen <bird-kStuff-spamix@anduin.net>
8 *
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:
17 *
18 * The above copyright notice and this permission notice shall be
19 * included in all copies or substantial portions of the Software.
20 *
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.
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 */
81typedef 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*******************************************************************************/
106static KI32 kldrModPENumberOfImports(PKLDRMOD pMod, const void *pvBits);
107static int kldrModPERelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
108 PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
109
110static int kldrModPEDoCreate(PKRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODPE *ppMod);
111/*static void kldrModPEDoLoadConfigConversion(PIMAGE_LOAD_CONFIG_DIRECTORY64 pLoadCfg); */
112static int kLdrModPEDoOptionalHeaderValidation(PKLDRMODPE pModPE);
113static int kLdrModPEDoSectionHeadersValidation(PKLDRMODPE pModPE);
114static void kldrModPEDoOptionalHeaderConversion(PIMAGE_OPTIONAL_HEADER64 pOptionalHeader);
115static int kldrModPEDoForwarderQuery(PKLDRMODPE pModPE, const void *pvBits, const char *pszForwarder,
116 PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser, PKLDRADDR puValue, KU32 *pfKind);
117static int kldrModPEDoFixups(PKLDRMODPE pModPE, void *pvMapping, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress);
118static int kldrModPEDoImports32Bit(PKLDRMODPE pModPE, void *pvMapping, const IMAGE_IMPORT_DESCRIPTOR *pImpDesc,
119 PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
120static int kldrModPEDoImports64Bit(PKLDRMODPE pModPE, void *pvMapping, const IMAGE_IMPORT_DESCRIPTOR *pImpDesc,
121 PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
122static int kldrModPEDoImports(PKLDRMODPE pModPE, void *pvMapping, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
123static int kldrModPEDoCallDLL(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle);
124static int kldrModPEDoCallTLS(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle);
125static 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.
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.
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 */
143static int kldrModPECreate(PCKLDRMODOPS pOps, PKRDR pRdr, KU32 fFlags, KCPUARCH enmCpuArch, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
144{
145 PKLDRMODPE pModPE;
146 int rc;
147 K_NOREF(fFlags);
148
149 /*
150 * Create the instance data and do a minimal header validation.
151 */
152 rc = kldrModPEDoCreate(pRdr, offNewHdr, &pModPE);
153 if (!rc)
154 {
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;
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 */
177static 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);
237 pMod->fFlags = 0;
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 */
445static 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 */
485static 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 */
516static 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 */
533static int kLdrModPEDoSectionHeadersValidation(PKLDRMODPE pModPE)
534{
535 /** @todo validate shdrs */
536 K_NOREF(pModPE);
537 return 0;
538}
539
540
541/** @copydoc KLDRMODOPS::pfnDestroy */
542static 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 */
570static 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 */
627static 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 */
666static 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 */
709static 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 */
833static 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 */
948static 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;
960 K_NOREF(fFlags);
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 */
1031static 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 */
1079static 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 */
1111static int kldrModPEGetStackInfo(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo)
1112{
1113 PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
1114 K_NOREF(pvBits);
1115 K_NOREF(BaseAddress);
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 */
1126static int kldrModPEQueryMainEntrypoint(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRADDR pMainEPAddress)
1127{
1128 PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
1129 int rc;
1130 K_NOREF(pvBits);
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 */
1150static 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,
1202 enmDbgInfoType, pDbgDir->MajorVersion, pDbgDir->MinorVersion, NULL,
1203 pDbgDir->PointerToRawData ? (KLDRFOFF)pDbgDir->PointerToRawData : -1,
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 */
1221static int kldrModPEHasDbgInfo(PKLDRMOD pMod, const void *pvBits)
1222{
1223 PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
1224 K_NOREF(pvBits);
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 */
1238static 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 */
1261static 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 */
1285static 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 */
1307static 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 */
1329static 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 */
1345static 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 */
1394static 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 */
1558static 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 */
1588static 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 */
1656static 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 */
1711static 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 */
1747static 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 */
1783static int kldrModPEDoCallTLS(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle)
1784{
1785 /** @todo implement TLS support. */
1786 K_NOREF(pModPE);
1787 K_NOREF(uOp);
1788 K_NOREF(uHandle);
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 */
1802static 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
1857 K_NOREF(pvReserved);
1858
1859 return rc;
1860}
1861
1862
1863/** @copydoc kLdrModCallTerm */
1864static 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 */
1886static 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 */
1913static KLDRADDR kldrModPESize(PKLDRMOD pMod)
1914{
1915 PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
1916 return pModPE->Hdrs.OptionalHeader.SizeOfImage;
1917}
1918
1919
1920/** @copydoc kLdrModGetBits */
1921static 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 */
1960static 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 */
1980KLDRMODOPS 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,
1993 NULL /* pfnQueryImageUuid */,
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.