source: trunk/kLdr/kLdrModPE.c@ 58

Last change on this file since 58 was 58, checked in by bird, 12 years ago

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