?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Unified "No implementation for..." warnings.
[wine.git] / loader / pe_image.c
blobc62cfc3618cfca8b375bc325b1910d4fb9a1ca20
1 /*
2 * Copyright 1994 Eric Youndale & Erik Bos
3 * Copyright 1995 Martin von Löwis
4 * Copyright 1996-98 Marcus Meissner
5 *
6 * based on Eric Youndale's pe-test and:
7 *
8 * ftp.microsoft.com:/pub/developer/MSDN/CD8/PEFILE.ZIP
9 * make that:
10 * ftp.microsoft.com:/developr/MSDN/OctCD/PEFILE.ZIP
11 */
12 /* Notes:
13 * Before you start changing something in this file be aware of the following:
14 *
15 * - There are several functions called recursively. In a very subtle and
16 * obscure way. DLLs can reference each other recursively etc.
17 * - If you want to enhance, speed up or clean up something in here, think
18 * twice WHY it is implemented in that strange way. There is usually a reason.
19 * Though sometimes it might just be lazyness ;)
20 * - In PE_MapImage, right before fixup_imports() all external and internal
21 * state MUST be correct since this function can be called with the SAME image
22 * AGAIN. (Thats recursion for you.) That means MODREF.module and
23 * NE_MODULE.module32.
24 * - No, you (usually) cannot use Linux mmap() to mmap() the images directly.
25 *
26 * The problem is, that there is not direct 1:1 mapping from a diskimage and
27 * a memoryimage. The headers at the start are mapped linear, but the sections
28 * are not. For x86 the sections are 512 byte aligned in file and 4096 byte
29 * aligned in memory. Linux likes them 4096 byte aligned in memory (due to
30 * x86 pagesize, this cannot be fixed without a rather large kernel rewrite)
31 * and 'blocksize' file-aligned (offsets). Since we have 512/1024/2048 (CDROM)
32 * and other byte blocksizes, we can't do this. However, this could be less
33 * difficult to support... (See mm/filemap.c).
34 * - All those function map things into a new addresspace. From the wrong
35 * process and the wrong thread. So calling other API functions will mess
36 * things up badly sometimes.
37 */
38
39 #include <errno.h>
40 #include <assert.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <unistd.h>
44 #include <sys/types.h>
45 #include <sys/stat.h>
46 #include <sys/mman.h>
47 #include "windows.h"
48 #include "winbase.h"
49 #include "callback.h"
50 #include "file.h"
51 #include "heap.h"
52 #include "neexe.h"
53 #include "peexe.h"
54 #include "process.h"
55 #include "thread.h"
56 #include "pe_image.h"
57 #include "module.h"
58 #include "global.h"
59 #include "task.h"
60 #include "snoop.h"
61 #include "debug.h"
62
63
64 /* convert PE image VirtualAddress to Real Address */
65 #define RVA(x) ((unsigned int)load_addr+(unsigned int)(x))
66
67 #define AdjustPtr(ptr,delta) ((char *)(ptr) + (delta))
68
69 void dump_exports( HMODULE32 hModule )
70 {
71 char *Module;
72 int i, j;
73 u_short *ordinal;
74 u_long *function,*functions;
75 u_char **name;
76 unsigned int load_addr = hModule;
77
78 DWORD rva_start = PE_HEADER(hModule)->OptionalHeader
79 .DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
80 DWORD rva_end = rva_start + PE_HEADER(hModule)->OptionalHeader
81 .DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
82 IMAGE_EXPORT_DIRECTORY *pe_exports = (IMAGE_EXPORT_DIRECTORY*)RVA(rva_start);
83
84 Module = (char*)RVA(pe_exports->Name);
85 TRACE(win32,"*******EXPORT DATA*******\n");
86 TRACE(win32,"Module name is %s, %ld functions, %ld names\n",
87 Module, pe_exports->NumberOfFunctions, pe_exports->NumberOfNames);
88
89 ordinal=(u_short*) RVA(pe_exports->AddressOfNameOrdinals);
90 functions=function=(u_long*) RVA(pe_exports->AddressOfFunctions);
91 name=(u_char**) RVA(pe_exports->AddressOfNames);
92
93 TRACE(win32," Ord RVA Addr Name\n" );
94 for (i=0;i<pe_exports->NumberOfFunctions;i++, function++)
95 {
96 if (!*function) continue; /* No such function */
97 if (TRACE_ON(win32)){
98 dbg_decl_str(win32, 1024);
99
100 dsprintf(win32,"%4ld %08lx %08x",
101 i + pe_exports->Base, *function, RVA(*function) );
102 /* Check if we have a name for it */
103 for (j = 0; j < pe_exports->NumberOfNames; j++)
104 if (ordinal[j] == i)
105 dsprintf(win32, " %s", (char*)RVA(name[j]) );
106 if ((*function >= rva_start) && (*function <= rva_end))
107 dsprintf(win32, " (forwarded -> %s)", (char *)RVA(*function));
108 TRACE(win32,"%s\n", dbg_str(win32));
109 }
110 }
111 }
112
113 /* Look up the specified function or ordinal in the exportlist:
114 * If it is a string:
115 * - look up the name in the Name list.
116 * - look up the ordinal with that index.
117 * - use the ordinal as offset into the functionlist
118 * If it is a ordinal:
119 * - use ordinal-pe_export->Base as offset into the functionlist
120 */
121 FARPROC32 PE_FindExportedFunction(
122 PDB32 *process, /* [in] process context */
123 WINE_MODREF *wm, /* [in] WINE modreference */
124 LPCSTR funcName, /* [in] function name */
125 BOOL32 snoop )
126 {
127 u_short * ordinal;
128 u_long * function;
129 u_char ** name, *ename;
130 int i;
131 PE_MODREF *pem = &(wm->binfmt.pe);
132 IMAGE_EXPORT_DIRECTORY *exports = pem->pe_export;
133 unsigned int load_addr = wm->module;
134 u_long rva_start, rva_end, addr;
135 char * forward;
136
137 if (HIWORD(funcName))
138 TRACE(win32,"(%s)\n",funcName);
139 else
140 TRACE(win32,"(%d)\n",(int)funcName);
141 if (!exports) {
142 /* Not a fatal problem, some apps do
143 * GetProcAddress(0,"RegisterPenApp") which triggers this
144 * case.
145 */
146 WARN(win32,"Module %08x(%s)/MODREF %p doesn't have a exports table.\n",wm->module,wm->modname,pem);
147 return NULL;
148 }
149 ordinal = (u_short*) RVA(exports->AddressOfNameOrdinals);
150 function= (u_long*) RVA(exports->AddressOfFunctions);
151 name = (u_char **) RVA(exports->AddressOfNames);
152 forward = NULL;
153 rva_start = PE_HEADER(wm->module)->OptionalHeader
154 .DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
155 rva_end = rva_start + PE_HEADER(wm->module)->OptionalHeader
156 .DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
157
158 if (HIWORD(funcName)) {
159 for(i=0; i<exports->NumberOfNames; i++) {
160 ename=(char*)RVA(*name);
161 if(!strcmp(ename,funcName))
162 {
163 addr = function[*ordinal];
164 if (!addr) return NULL;
165 if ((addr < rva_start) || (addr >= rva_end))
166 return snoop? SNOOP_GetProcAddress32(wm->module,ename,*ordinal,(FARPROC32)RVA(addr))
167 : (FARPROC32)RVA(addr);
168 forward = (char *)RVA(addr);
169 break;
170 }
171 ordinal++;
172 name++;
173 }
174 } else {
175 int i;
176 if (LOWORD(funcName)-exports->Base > exports->NumberOfFunctions) {
177 TRACE(win32," ordinal %d out of range!\n",
178 LOWORD(funcName));
179 return NULL;
180 }
181 addr = function[(int)funcName-exports->Base];
182 if (!addr) return NULL;
183 ename = "";
184 if (name) {
185 for (i=0;i<exports->NumberOfNames;i++) {
186 ename = (char*)RVA(*name);
187 if (*ordinal == LOWORD(funcName)-exports->Base)
188 break;
189 ordinal++;
190 name++;
191 }
192 if (i==exports->NumberOfNames)
193 ename = "";
194 }
195 if ((addr < rva_start) || (addr >= rva_end))
196 return snoop? SNOOP_GetProcAddress32(wm->module,ename,(DWORD)funcName-exports->Base,(FARPROC32)RVA(addr))
197 : (FARPROC32)RVA(addr);
198 forward = (char *)RVA(addr);
199 }
200 if (forward)
201 {
202 HMODULE32 hMod;
203 char module[256];
204 char *end = strchr(forward, '.');
205
206 if (!end) return NULL;
207 assert(end-forward<256);
208 strncpy(module, forward, (end - forward));
209 module[end-forward] = 0;
210 hMod = MODULE_FindModule32(process,module);
211 assert(hMod);
212 return MODULE_GetProcAddress32( process, hMod, end + 1, snoop );
213 }
214 return NULL;
215 }
216
217 DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
218 {
219 IMAGE_IMPORT_DESCRIPTOR *pe_imp;
220 WINE_MODREF *xwm;
221 PE_MODREF *pem;
222 unsigned int load_addr = wm->module;
223 int i,characteristics_detection=1;
224 char *modname;
225
226 assert(wm->type==MODULE32_PE);
227 pem = &(wm->binfmt.pe);
228 if (pem->pe_export)
229 modname = (char*) RVA(pem->pe_export->Name);
230 else
231 modname = "<unknown>";
232
233 /* OK, now dump the import list */
234 TRACE(win32, "Dumping imports list\n");
235
236 /* first, count the number of imported non-internal modules */
237 pe_imp = pem->pe_import;
238 if (!pe_imp)
239 ERR(win32, "no import directory????\n");
240
241 /* We assume that we have at least one import with !0 characteristics and
242 * detect broken imports with all characteristsics 0 (notably Borland) and
243 * switch the detection off for them.
244 */
245 for (i = 0; pe_imp->Name ; pe_imp++) {
246 if (!i && !pe_imp->u.Characteristics)
247 characteristics_detection = 0;
248 if (characteristics_detection && !pe_imp->u.Characteristics)
249 break;
250 i++;
251 }
252
253 /* Allocate module dependency list */
254 wm->nDeps = i;
255 wm->deps = HeapAlloc(process->heap, 0, i*sizeof(WINE_MODREF *));
256
257 /* load the imported modules. They are automatically
258 * added to the modref list of the process.
259 */
260
261 for (i = 0, pe_imp = pem->pe_import; pe_imp->Name ; pe_imp++) {
262 HMODULE32 hImpModule;
263 IMAGE_IMPORT_BY_NAME *pe_name;
264 PIMAGE_THUNK_DATA import_list,thunk_list;
265 char *name = (char *) RVA(pe_imp->Name);
266
267 if (characteristics_detection && !pe_imp->u.Characteristics)
268 break;
269
270 /* don't use MODULE_Load, Win32 creates new task differently */
271 hImpModule = MODULE_LoadLibraryEx32A( name, process, 0, 0 );
272 if (!hImpModule) {
273 char *p,buffer[2000];
274
275 /* GetModuleFileName would use the wrong process, so don't use it */
276 strcpy(buffer,wm->shortname);
277 if (!(p = strrchr (buffer, '\\')))
278 p = buffer;
279 strcpy (p + 1, name);
280 hImpModule = MODULE_LoadLibraryEx32A( buffer, process, 0, 0 );
281 }
282 if (!hImpModule) {
283 ERR (module, "Module %s not found\n", name);
284 return 1;
285 }
286 xwm = MODULE32_LookupHMODULE(process, hImpModule);
287 assert( xwm );
288 wm->deps[i++] = xwm;
289
290 /* FIXME: forwarder entries ... */
291
292 if (pe_imp->u.OriginalFirstThunk != 0) { /* original MS style */
293 TRACE(win32, "Microsoft style imports used\n");
294 import_list =(PIMAGE_THUNK_DATA) RVA(pe_imp->u.OriginalFirstThunk);
295 thunk_list = (PIMAGE_THUNK_DATA) RVA(pe_imp->FirstThunk);
296
297 while (import_list->u1.Ordinal) {
298 if (IMAGE_SNAP_BY_ORDINAL(import_list->u1.Ordinal)) {
299 int ordinal = IMAGE_ORDINAL(import_list->u1.Ordinal);
300
301 TRACE(win32, "--- Ordinal %s,%d\n", name, ordinal);
302 thunk_list->u1.Function=MODULE_GetProcAddress32(
303 process, hImpModule, (LPCSTR)ordinal, TRUE
304 );
305 if (!thunk_list->u1.Function) {
306 ERR(win32,"No implementation for %s.%d, setting to 0xdeadbeef\n",
307 name, ordinal);
308 thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
309 }
310 } else { /* import by name */
311 pe_name = (PIMAGE_IMPORT_BY_NAME)RVA(import_list->u1.AddressOfData);
312 TRACE(win32, "--- %s %s.%d\n", pe_name->Name, name, pe_name->Hint);
313 thunk_list->u1.Function=MODULE_GetProcAddress32(
314 process, hImpModule, pe_name->Name, TRUE
315 );
316 if (!thunk_list->u1.Function) {
317 ERR(win32,"No implementation for %s.%d(%s), setting to 0xdeadbeef\n",
318 name,pe_name->Hint,pe_name->Name);
319 thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
320 }
321 }
322 import_list++;
323 thunk_list++;
324 }
325 } else { /* Borland style */
326 TRACE(win32, "Borland style imports used\n");
327 thunk_list = (PIMAGE_THUNK_DATA) RVA(pe_imp->FirstThunk);
328 while (thunk_list->u1.Ordinal) {
329 if (IMAGE_SNAP_BY_ORDINAL(thunk_list->u1.Ordinal)) {
330 /* not sure about this branch, but it seems to work */
331 int ordinal = IMAGE_ORDINAL(thunk_list->u1.Ordinal);
332
333 TRACE(win32,"--- Ordinal %s.%d\n",name,ordinal);
334 thunk_list->u1.Function=MODULE_GetProcAddress32(
335 process, hImpModule, (LPCSTR) ordinal, TRUE
336 );
337 if (!thunk_list->u1.Function) {
338 ERR(win32, "No implementation for %s.%d, setting to 0xdeadbeef\n",
339 name,ordinal);
340 thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
341 }
342 } else {
343 pe_name=(PIMAGE_IMPORT_BY_NAME) RVA(thunk_list->u1.AddressOfData);
344 TRACE(win32,"--- %s %s.%d\n",
345 pe_name->Name,name,pe_name->Hint);
346 thunk_list->u1.Function=MODULE_GetProcAddress32(
347 process, hImpModule, pe_name->Name, TRUE
348 );
349 if (!thunk_list->u1.Function) {
350 ERR(win32, "No implementation for %s.%d, setting to 0xdeadbeef\n",
351 name, pe_name->Hint);
352 thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
353 }
354 }
355 thunk_list++;
356 }
357 }
358 }
359 return 0;
360 }
361
362 static int calc_vma_size( HMODULE32 hModule )
363 {
364 int i,vma_size = 0;
365 IMAGE_SECTION_HEADER *pe_seg = PE_SECTIONS(hModule);
366
367 TRACE(win32, "Dump of segment table\n");
368 TRACE(win32, " Name VSz Vaddr SzRaw Fileadr *Reloc *Lineum #Reloc #Linum Char\n");
369 for (i = 0; i< PE_HEADER(hModule)->FileHeader.NumberOfSections; i++)
370 {
371 TRACE(win32, "%8s: %4.4lx %8.8lx %8.8lx %8.8lx %8.8lx %8.8lx %4.4x %4.4x %8.8lx\n",
372 pe_seg->Name,
373 pe_seg->Misc.VirtualSize,
374 pe_seg->VirtualAddress,
375 pe_seg->SizeOfRawData,
376 pe_seg->PointerToRawData,
377 pe_seg->PointerToRelocations,
378 pe_seg->PointerToLinenumbers,
379 pe_seg->NumberOfRelocations,
380 pe_seg->NumberOfLinenumbers,
381 pe_seg->Characteristics);
382 vma_size=MAX(vma_size, pe_seg->VirtualAddress+pe_seg->SizeOfRawData);
383 vma_size=MAX(vma_size, pe_seg->VirtualAddress+pe_seg->Misc.VirtualSize);
384 pe_seg++;
385 }
386 return vma_size;
387 }
388
389 static void do_relocations(WINE_MODREF *wm)
390 {
391 PE_MODREF *pem = &(wm->binfmt.pe);
392 int delta = wm->module - PE_HEADER(wm->module)->OptionalHeader.ImageBase;
393 unsigned int load_addr= wm->module;
394
395 IMAGE_BASE_RELOCATION *r = pem->pe_reloc;
396 int hdelta = (delta >> 16) & 0xFFFF;
397 int ldelta = delta & 0xFFFF;
398
399 /* int reloc_size = */
400
401 if(delta == 0)
402 /* Nothing to do */
403 return;
404 while(r->VirtualAddress)
405 {
406 char *page = (char*) RVA(r->VirtualAddress);
407 int count = (r->SizeOfBlock - 8)/2;
408 int i;
409 TRACE(fixup, "%x relocations for page %lx\n",
410 count, r->VirtualAddress);
411 /* patching in reverse order */
412 for(i=0;i<count;i++)
413 {
414 int offset = r->TypeOffset[i] & 0xFFF;
415 int type = r->TypeOffset[i] >> 12;
416 TRACE(fixup,"patching %x type %x\n", offset, type);
417 switch(type)
418 {
419 case IMAGE_REL_BASED_ABSOLUTE: break;
420 case IMAGE_REL_BASED_HIGH:
421 *(short*)(page+offset) += hdelta;
422 break;
423 case IMAGE_REL_BASED_LOW:
424 *(short*)(page+offset) += ldelta;
425 break;
426 case IMAGE_REL_BASED_HIGHLOW:
427 #if 1
428 *(int*)(page+offset) += delta;
429 #else
430 { int h=*(unsigned short*)(page+offset);
431 int l=r->TypeOffset[++i];
432 *(unsigned int*)(page + offset) = (h<<16) + l + delta;
433 }
434 #endif
435 break;
436 case IMAGE_REL_BASED_HIGHADJ:
437 WARN(win32, "Don't know what to do with IMAGE_REL_BASED_HIGHADJ\n");
438 break;
439 case IMAGE_REL_BASED_MIPS_JMPADDR:
440 WARN(win32, "Is this a MIPS machine ???\n");
441 break;
442 default:
443 WARN(win32, "Unknown fixup type\n");
444 break;
445 }
446 }
447 r = (IMAGE_BASE_RELOCATION*)((char*)r + r->SizeOfBlock);
448 }
449 }
450
451
452
453
454
455 /**********************************************************************
456 * PE_LoadImage
457 * Load one PE format DLL/EXE into memory
458 *
459 * Unluckily we can't just mmap the sections where we want them, for
460 * (at least) Linux does only support offsets which are page-aligned.
461 *
462 * BUT we have to map the whole image anyway, for Win32 programs sometimes
463 * want to access them. (HMODULE32 point to the start of it)
464 */
465 static HMODULE32 PE_LoadImage( HFILE32 hFile )
466 {
467 HMODULE32 hModule;
468 HANDLE32 mapping;
469 int i,rawsize = 0;
470 IMAGE_SECTION_HEADER *pe_sec;
471 BY_HANDLE_FILE_INFORMATION bhfi;
472
473
474 /* map the PE file somewhere */
475 mapping = CreateFileMapping32A( hFile, NULL, PAGE_READONLY | SEC_COMMIT,
476 0, 0, NULL );
477 if (!mapping)
478 {
479 WARN( win32, "CreateFileMapping error %ld\n",
480 GetLastError() );
481 return 0;
482 }
483 hModule = (HMODULE32)MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
484 CloseHandle( mapping );
485 if (!hModule)
486 {
487 WARN( win32, "PE_LoadImage: MapViewOfFile error %ld\n",
488 GetLastError() );
489 return 0;
490 }
491
492 if (PE_HEADER(hModule)->Signature != IMAGE_NT_SIGNATURE)
493 {
494 WARN(win32,"image doesn't have PE signature, but 0x%08lx\n",
495 PE_HEADER(hModule)->Signature );
496 goto error;
497 }
498
499 if (PE_HEADER(hModule)->FileHeader.Machine != IMAGE_FILE_MACHINE_I386)
500 {
501 MSG("Trying to load PE image for unsupported architecture (");
502 switch (PE_HEADER(hModule)->FileHeader.Machine)
503 {
504 case IMAGE_FILE_MACHINE_UNKNOWN: MSG("Unknown"); break;
505 case IMAGE_FILE_MACHINE_I860: MSG("I860"); break;
506 case IMAGE_FILE_MACHINE_R3000: MSG("R3000"); break;
507 case IMAGE_FILE_MACHINE_R4000: MSG("R4000"); break;
508 case IMAGE_FILE_MACHINE_R10000: MSG("R10000"); break;
509 case IMAGE_FILE_MACHINE_ALPHA: MSG("Alpha"); break;
510 case IMAGE_FILE_MACHINE_POWERPC: MSG("PowerPC"); break;
511 default: MSG("Unknown-%04x",
512 PE_HEADER(hModule)->FileHeader.Machine); break;
513 }
514 MSG(")\n");
515 goto error;
516 }
517 /* find out how large this executeable should be */
518 pe_sec = PE_SECTIONS(hModule);
519 for (i=0;i<PE_HEADER(hModule)->FileHeader.NumberOfSections;i++) {
520 if (pe_sec[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
521 continue;
522 if (pe_sec[i].PointerToRawData+pe_sec[i].SizeOfRawData > rawsize)
523 rawsize = pe_sec[i].PointerToRawData+pe_sec[i].SizeOfRawData;
524 }
525 if (GetFileInformationByHandle(hFile,&bhfi)) {
526 /* FIXME: 64 bit */
527 if (bhfi.nFileSizeLow < rawsize) {
528 ERR(win32,"PE module is too small (header: %d, filesize: %d), probably truncated download?\n",rawsize,bhfi.nFileSizeLow);
529 goto error;
530 }
531 }
532 /* Else ... Hmm, we have opened it, so we should be able to get info?
533 * Anyway, don't care in this case
534 */
535 return hModule;
536
537 error:
538 UnmapViewOfFile( (LPVOID)hModule );
539 return 0;
540 }
541
542 /**********************************************************************
543 * This maps a loaded PE dll into the address space of the specified process.
544 */
545 static BOOL32 PE_MapImage( PDB32 *process,WINE_MODREF *wm, OFSTRUCT *ofs, DWORD flags )
546 {
547 PE_MODREF *pem;
548 int i, result;
549 DWORD load_addr;
550 IMAGE_DATA_DIRECTORY dir;
551 char *modname;
552 int vma_size;
553 HMODULE32 hModule = wm->module;
554
555 IMAGE_SECTION_HEADER *pe_seg;
556 IMAGE_DOS_HEADER *dos_header = (IMAGE_DOS_HEADER *)hModule;
557 IMAGE_NT_HEADERS *nt_header = PE_HEADER(hModule);
558
559 pem = &(wm->binfmt.pe);
560
561 result = GetLongPathName32A(ofs->szPathName,NULL,0);
562 wm->longname = (char*)HeapAlloc(process->heap,0,result+1);
563 GetLongPathName32A(ofs->szPathName,wm->longname,result+1);
564
565 wm->shortname = HEAP_strdupA(process->heap,0,ofs->szPathName);
566
567 if (!(nt_header->FileHeader.Characteristics & IMAGE_FILE_DLL))
568 {
569 if (process->exe_modref)
570 FIXME(win32,"overwriting old exe_modref... arrgh\n");
571 process->exe_modref = wm;
572 }
573
574 load_addr = nt_header->OptionalHeader.ImageBase;
575 vma_size = calc_vma_size( hModule );
576 TRACE(win32, "Load addr is %lx\n",load_addr);
577 load_addr = (DWORD)VirtualAlloc( (void*)load_addr, vma_size,
578 MEM_RESERVE | MEM_COMMIT,
579 PAGE_EXECUTE_READWRITE );
580 if (load_addr == 0) {
581 load_addr = (DWORD)VirtualAlloc( NULL, vma_size,
582 MEM_RESERVE | MEM_COMMIT,
583 PAGE_EXECUTE_READWRITE );
584 }
585 /* NOTE: this changes a value in the process modref chain, which can
586 * be accessed independently from this function
587 */
588 wm->module = (HMODULE32)load_addr;
589
590 TRACE(win32, "Load addr is really %lx, range %x\n",
591 load_addr, vma_size);
592
593 TRACE(segment, "Loading %s at %lx, range %x\n",
594 ofs->szPathName, load_addr, vma_size );
595
596 /* Store the NT header at the load addr
597 * (FIXME: should really use mmap)
598 */
599 *(IMAGE_DOS_HEADER *)load_addr = *dos_header;
600 *(IMAGE_NT_HEADERS *)(load_addr + dos_header->e_lfanew) = *nt_header;
601 memcpy(PE_SECTIONS(load_addr),PE_SECTIONS(hModule),sizeof(IMAGE_SECTION_HEADER)*nt_header->FileHeader.NumberOfSections);
602
603 pe_seg = PE_SECTIONS(hModule);
604 for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++, pe_seg++)
605 {
606 /* memcpy only non-BSS segments */
607 /* FIXME: this should be done by mmap(..MAP_PRIVATE|MAP_FIXED..)
608 * but it is not possible for (at least) Linux needs
609 * a page-aligned offset.
610 */
611 if(!(pe_seg->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA))
612 memcpy((char*)RVA(pe_seg->VirtualAddress),
613 (char*)(hModule + pe_seg->PointerToRawData),
614 pe_seg->SizeOfRawData
615 );
616
617 result = RVA (pe_seg->VirtualAddress);
618 #if 1
619 /* not needed, memory is zero */
620 if(strcmp(pe_seg->Name, ".bss") == 0)
621 memset((void *)result, 0,
622 pe_seg->Misc.VirtualSize ?
623 pe_seg->Misc.VirtualSize :
624 pe_seg->SizeOfRawData);
625 #endif
626
627 if(strcmp(pe_seg->Name, ".idata") == 0)
628 pem->pe_import = (PIMAGE_IMPORT_DESCRIPTOR) result;
629
630 if(strcmp(pe_seg->Name, ".edata") == 0)
631 pem->pe_export = (PIMAGE_EXPORT_DIRECTORY) result;
632
633 if(strcmp(pe_seg->Name, ".rsrc") == 0)
634 pem->pe_resource = (PIMAGE_RESOURCE_DIRECTORY) result;
635
636 if(strcmp(pe_seg->Name, ".reloc") == 0)
637 pem->pe_reloc = (PIMAGE_BASE_RELOCATION) result;
638 }
639
640 /* There is word that the actual loader does not care about the
641 section names, and only goes for the DataDirectory */
642 dir=nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
643 if(dir.Size)
644 {
645 if(pem->pe_export && (int)pem->pe_export!=RVA(dir.VirtualAddress))
646 WARN(win32,"wrong export directory??\n");
647 /* always trust the directory */
648 pem->pe_export = (PIMAGE_EXPORT_DIRECTORY) RVA(dir.VirtualAddress);
649 }
650
651 dir=nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
652 if(dir.Size)
653 {
654 /*
655 if(pem->pe_import && (int)pem->pe_import!=RVA(dir.VirtualAddress))
656 WARN(win32,"wrong import directory??\n");
657 */
658 pem->pe_import = (PIMAGE_IMPORT_DESCRIPTOR) RVA(dir.VirtualAddress);
659 }
660
661 dir=nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE];
662 if(dir.Size)
663 {
664 if(pem->pe_resource && (int)pem->pe_resource!=RVA(dir.VirtualAddress))
665 WARN(win32,"wrong resource directory??\n");
666 pem->pe_resource = (PIMAGE_RESOURCE_DIRECTORY) RVA(dir.VirtualAddress);
667 }
668
669 if(nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size)
670 FIXME(win32,"Exception directory ignored\n");
671
672 if(nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].Size)
673 FIXME(win32,"Security directory ignored\n");
674
675
676
677 dir=nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
678 if(dir.Size)
679 {
680 if(pem->pe_reloc && (int)pem->pe_reloc!= RVA(dir.VirtualAddress))
681 WARN(win32,"wrong relocation list??\n");
682 pem->pe_reloc = (void *) RVA(dir.VirtualAddress);
683 }
684
685 if(nt_header->OptionalHeader.DataDirectory
686 [IMAGE_DIRECTORY_ENTRY_COPYRIGHT].Size)
687 FIXME(win32,"Copyright string ignored\n");
688
689 if(nt_header->OptionalHeader.DataDirectory
690 [IMAGE_DIRECTORY_ENTRY_GLOBALPTR].Size)
691 FIXME(win32,"Global Pointer (MIPS) ignored\n");
692
693 if(nt_header->OptionalHeader.DataDirectory
694 [IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].Size)
695 FIXME(win32,"Load Configuration directory ignored\n");
696
697 if(nt_header->OptionalHeader.DataDirectory
698 [IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].Size)
699 TRACE(win32,"Bound Import directory ignored\n");
700
701 if(nt_header->OptionalHeader.DataDirectory
702 [IMAGE_DIRECTORY_ENTRY_IAT].Size)
703 TRACE(win32,"Import Address Table directory ignored\n");
704 if(nt_header->OptionalHeader.DataDirectory[13].Size)
705 FIXME(win32,"Unknown directory 13 ignored\n");
706 if(nt_header->OptionalHeader.DataDirectory[14].Size)
707 FIXME(win32,"Unknown directory 14 ignored\n");
708 if(nt_header->OptionalHeader.DataDirectory[15].Size)
709 FIXME(win32,"Unknown directory 15 ignored\n");
710
711 if(pem->pe_reloc) do_relocations(wm);
712 if(pem->pe_export) {
713 dump_exports(wm->module);
714
715 wm->modname = HEAP_strdupA(process->heap,0,(char*)RVA(pem->pe_export->Name));
716 } else {
717 /* try to find out the name from the OFSTRUCT */
718 char *s;
719 modname = s = ofs->szPathName;
720 while ((s=strchr(modname,'\\')))
721 modname = s+1;
722 wm->modname = HEAP_strdupA(process->heap,0,modname);
723 }
724 if(pem->pe_import) {
725 if (fixup_imports(process,wm)) {
726 WINE_MODREF **xwm;
727
728 /* remove entry from modref chain */
729 xwm = &(process->modref_list);
730 while (*xwm) {
731 if (*xwm==wm) {
732 *xwm = wm->next;
733 break;
734 }
735 xwm = &((*xwm)->next);
736 }
737 /* FIXME: there are several more dangling references
738 * left. Including dlls loaded by this dll before the
739 * failed one. Unrolling is rather difficult with the
740 * current structure and we can leave it them lying
741 * around with no problems, so we don't care
742 */
743 return 0;
744 }
745 }
746
747 /* Now that we got everything at the right address,
748 * we can unmap the previous module */
749 UnmapViewOfFile( (LPVOID)hModule );
750 return 1;
751 }
752
753 /******************************************************************************
754 * The PE Library Loader frontend.
755 * FIXME: handle the flags.
756 * internal module handling should be made better here (and in builtin.c)
757 */
758 HMODULE32 PE_LoadLibraryEx32A (LPCSTR name, PDB32 *process,
759 HFILE32 hFile, DWORD flags)
760 {
761 OFSTRUCT ofs;
762 HMODULE32 hModule;
763 NE_MODULE *pModule;
764 WINE_MODREF *wm;
765
766 if ((hModule = MODULE_FindModule32( process, name ))) {
767 for (wm= process->modref_list;wm;wm=wm->next)
768 if (wm->module == hModule)
769 return hModule;
770 /* Since MODULE_FindModule32 uses the modref chain too, the
771 * module MUST have been found above. If not, something has gone
772 * terribly wrong.
773 */
774 assert(0);
775 }
776 /* try to load builtin, enabled modules first */
777 if ((hModule = BUILTIN32_LoadModule( name, FALSE, process )))
778 return hModule;
779
780 /* try to load the specified dll/exe */
781 if (HFILE_ERROR32==(hFile=OpenFile32(name,&ofs,OF_READ))) {
782 /* Now try the built-in even if disabled */
783 if ((hModule = BUILTIN32_LoadModule( name, TRUE, process ))) {
784 WARN( module, "Could not load external DLL '%s', using built-in module.\n", name );
785 return hModule;
786 }
787 return 0;
788 }
789 /* will go away ... */
790 if ((hModule = MODULE_CreateDummyModule( &ofs )) < 32) {
791 _lclose32(hFile);
792 return hModule;
793 }
794 pModule = (NE_MODULE *)GlobalLock16( hModule );
795 pModule->flags = NE_FFLAGS_WIN32;
796 /* .. */
797
798 wm=(WINE_MODREF*)HeapAlloc(process->heap,HEAP_ZERO_MEMORY,sizeof(*wm));
799 wm->type = MODULE32_PE;
800 /* NOTE: fixup_imports takes care of the correct order */
801 wm->next = process->modref_list;
802 process->modref_list = wm;
803
804 wm->module = pModule->module32 = PE_LoadImage( hFile );
805
806 CloseHandle( hFile );
807 if (wm->module < 32)
808 {
809 process->modref_list = wm->next;
810 FreeLibrary16( hModule);
811 HeapFree(process->heap,0,wm);
812 ERR(win32,"can't load %s\n",ofs.szPathName);
813 return 0;
814 }
815
816 /* (possible) recursion */
817 if (!PE_MapImage(process,wm,&ofs,flags)) {
818 /* ERROR cleanup ... */
819 WINE_MODREF **xwm;
820
821 ERR(win32,"couldn't load %s\n",ofs.szPathName);
822 /* unlink from process modref chain */
823 for ( xwm=&(process->modref_list);
824 *xwm && (*xwm!=wm);
825 xwm=&((*xwm)->next)
826 ) /* EMPTY */;
827 if (*xwm)
828 *xwm=(*xwm)->next;
829
830 return 0;
831 }
832 pModule->module32 = wm->module;
833 if (wm->binfmt.pe.pe_export)
834 SNOOP_RegisterDLL(wm->module,wm->modname,wm->binfmt.pe.pe_export->NumberOfFunctions);
835 return wm->module;
836 }
837
838 /*****************************************************************************
839 * Load the PE main .EXE. All other loading is done by PE_LoadLibraryEx32A
840 * FIXME: this function should use PE_LoadLibraryEx32A, but currently can't
841 * due to the PROCESS_Create stuff.
842 */
843 HINSTANCE16 PE_CreateProcess( LPCSTR name, LPCSTR cmd_line,
844 LPCSTR env, LPSTARTUPINFO32A startup,
845 LPPROCESS_INFORMATION info )
846 {
847 HMODULE16 hModule16;
848 HMODULE32 hModule32;
849 HINSTANCE16 hInstance;
850 NE_MODULE *pModule;
851 HFILE32 hFile;
852 OFSTRUCT ofs;
853 PDB32 *process;
854 TDB *pTask;
855 WINE_MODREF *wm;
856
857 if ((hFile = OpenFile32( name, &ofs, OF_READ )) == HFILE_ERROR32)
858 return 2; /* File not found */
859
860 if ((hModule16 = MODULE_CreateDummyModule( &ofs )) < 32) return hModule16;
861 pModule = (NE_MODULE *)GlobalLock16( hModule16 );
862 pModule->flags = NE_FFLAGS_WIN32;
863
864 pModule->module32 = hModule32 = PE_LoadImage( hFile );
865 if (hModule32 < 32) return 21;
866
867 if (PE_HEADER(hModule32)->FileHeader.Characteristics & IMAGE_FILE_DLL)
868 return 11;
869
870 hInstance = NE_CreateInstance( pModule, NULL, FALSE );
871 process = PROCESS_Create( pModule, cmd_line, env,
872 hInstance, 0, startup, info );
873 pTask = (TDB *)GlobalLock16( process->task );
874
875 wm=(WINE_MODREF*)HeapAlloc(process->heap,HEAP_ZERO_MEMORY,sizeof(*wm));
876 wm->type = MODULE32_PE;
877 /* NOTE: fixup_imports takes care of the correct order */
878 wm->next = process->modref_list;
879 wm->module = hModule32;
880 process->modref_list = wm;
881 if (!PE_MapImage( process, wm, &ofs, 0 ))
882 {
883 /* FIXME: should destroy the task created and free referenced stuff */
884 return 0;
885 }
886 pModule->module32 = wm->module;
887
888 /* FIXME: Yuck. Is there no other good place to do that? */
889 PE_InitTls( pTask->thdb );
890
891 return hInstance;
892 }
893
894 /*********************************************************************
895 * PE_UnloadImage [internal]
896 */
897 int PE_UnloadImage( HMODULE32 hModule )
898 {
899 FIXME(win32,"stub.\n");
900 /* free resources, image, unmap */
901 return 1;
902 }
903
904 /* Called if the library is loaded or freed.
905 * NOTE: if a thread attaches a DLL, the current thread will only do
906 * DLL_PROCESS_ATTACH. Only new created threads do DLL_THREAD_ATTACH
907 * (SDK)
908 */
909 void PE_InitDLL(WINE_MODREF *wm, DWORD type, LPVOID lpReserved)
910 {
911 if (wm->type!=MODULE32_PE)
912 return;
913 if (wm->binfmt.pe.flags & PE_MODREF_NO_DLL_CALLS)
914 return;
915 if (type==DLL_PROCESS_ATTACH)
916 {
917 if (wm->binfmt.pe.flags & PE_MODREF_PROCESS_ATTACHED)
918 return;
919
920 wm->binfmt.pe.flags |= PE_MODREF_PROCESS_ATTACHED;
921 }
922
923 /* DLL_ATTACH_PROCESS:
924 * lpreserved is NULL for dynamic loads, not-NULL for static loads
925 * DLL_DETACH_PROCESS:
926 * lpreserved is NULL if called by FreeLibrary, not-NULL otherwise
927 * the SDK doesn't mention anything for DLL_THREAD_*
928 */
929
930 /* Is this a library? And has it got an entrypoint? */
931 if ((PE_HEADER(wm->module)->FileHeader.Characteristics & IMAGE_FILE_DLL) &&
932 (PE_HEADER(wm->module)->OptionalHeader.AddressOfEntryPoint)
933 ) {
934 DLLENTRYPROC32 entry = (void*)RVA_PTR( wm->module,OptionalHeader.AddressOfEntryPoint );
935 TRACE(relay, "CallTo32(entryproc=%p,module=%08x,type=%ld,res=%p)\n",
936 entry, wm->module, type, lpReserved );
937
938 entry( wm->module, type, lpReserved );
939 }
940 }
941
942 void PE_InitTls(THDB *thdb)
943 {
944 WINE_MODREF *wm;
945 PE_MODREF *pem;
946 IMAGE_NT_HEADERS *peh;
947 DWORD size,datasize;
948 LPVOID mem;
949 PIMAGE_TLS_DIRECTORY pdir;
950 PDB32 *pdb = thdb->process;
951 int delta;
952
953 for (wm = pdb->modref_list;wm;wm=wm->next) {
954 if (wm->type!=MODULE32_PE)
955 continue;
956 pem = &(wm->binfmt.pe);
957 peh = PE_HEADER(wm->module);
958 delta = wm->module - peh->OptionalHeader.ImageBase;
959 if (!peh->OptionalHeader.DataDirectory[IMAGE_FILE_THREAD_LOCAL_STORAGE].VirtualAddress)
960 continue;
961 pdir = (LPVOID)(wm->module + peh->OptionalHeader.
962 DataDirectory[IMAGE_FILE_THREAD_LOCAL_STORAGE].VirtualAddress);
963
964
965 if (!(pem->flags & PE_MODREF_TLS_ALLOCED)) {
966 pem->tlsindex = THREAD_TlsAlloc(thdb);
967 *(LPDWORD)AdjustPtr(pdir->AddressOfIndex,delta)
968 =pem->tlsindex;
969 }
970 pem->flags |= PE_MODREF_TLS_ALLOCED;
971 datasize= pdir->EndAddressOfRawData-pdir->StartAddressOfRawData;
972 size = datasize + pdir->SizeOfZeroFill;
973 mem=VirtualAlloc(0,size,MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
974 memcpy(mem,
975 AdjustPtr(pdir->StartAddressOfRawData,delta),
976 datasize);
977
978 /* don't use TlsSetValue, we are in the wrong thread */
979 if (pdir->AddressOfCallBacks) {
980 PIMAGE_TLS_CALLBACK *cbs =
981 (PIMAGE_TLS_CALLBACK *)
982 AdjustPtr(pdir->AddressOfCallBacks, delta);
983
984 if (*cbs) {
985 FIXME(win32, "TLS Callbacks aren't going to be called\n");
986 }
987 }
988 thdb->tls_array[pem->tlsindex] = mem;
989 }
990 }
991
992 /****************************************************************************
993 * DisableThreadLibraryCalls (KERNEL32.74)
994 * Don't call DllEntryPoint for DLL_THREAD_{ATTACH,DETACH} if set.
995 */
996 BOOL32 WINAPI DisableThreadLibraryCalls(HMODULE32 hModule)
997 {
998 WINE_MODREF *wm;
999
1000 for (wm=PROCESS_Current()->modref_list;wm;wm=wm->next)
1001 if ((wm->module == hModule) && (wm->type==MODULE32_PE))
1002 wm->binfmt.pe.flags|=PE_MODREF_NO_DLL_CALLS;
1003 return TRUE;
1004 }
Windows API implementation