?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Restore blitting environment after modifying it.
[wine/testsucceed.git] / dlls / ntdll / loader.c
blob7ff3ca16b3926613452b5c6d350c3af4e8b57887
1 /*
2 * Loader functions
3 *
4 * Copyright 1995, 2003 Alexandre Julliard
5 * Copyright 2002 Dmitry Timoshkov for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <stdarg.h>
27
28 #define NONAMELESSUNION
29 #define NONAMELESSSTRUCT
30
31 #include "ntstatus.h"
32 #define WIN32_NO_STATUS
33 #include "windef.h"
34 #include "winnt.h"
35 #include "winternl.h"
36
37 #include "wine/exception.h"
38 #include "excpt.h"
39 #include "wine/library.h"
40 #include "wine/unicode.h"
41 #include "wine/debug.h"
42 #include "wine/server.h"
43 #include "ntdll_misc.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(module);
46 WINE_DECLARE_DEBUG_CHANNEL(relay);
47 WINE_DECLARE_DEBUG_CHANNEL(snoop);
48 WINE_DECLARE_DEBUG_CHANNEL(loaddll);
49 WINE_DECLARE_DEBUG_CHANNEL(imports);
50
51 typedef DWORD (CALLBACK *DLLENTRYPROC)(HMODULE,DWORD,LPVOID);
52
53 static int process_detaching = 0; /* set on process detach to avoid deadlocks with thread detach */
54 static int free_lib_count; /* recursion depth of LdrUnloadDll calls */
55
56 static const char * const reason_names[] =
57 {
58 "PROCESS_DETACH",
59 "PROCESS_ATTACH",
60 "THREAD_ATTACH",
61 "THREAD_DETACH",
62 NULL, NULL, NULL, NULL,
63 "WINE_PREATTACH"
64 };
65
66 static const WCHAR dllW[] = {'.','d','l','l',0};
67
68 /* internal representation of 32bit modules. per process. */
69 typedef struct _wine_modref
70 {
71 LDR_MODULE ldr;
72 int nDeps;
73 struct _wine_modref **deps;
74 } WINE_MODREF;
75
76 /* info about the current builtin dll load */
77 /* used to keep track of things across the register_dll constructor call */
78 struct builtin_load_info
79 {
80 const WCHAR *load_path;
81 const WCHAR *filename;
82 NTSTATUS status;
83 WINE_MODREF *wm;
84 };
85
86 static struct builtin_load_info default_load_info;
87 static struct builtin_load_info *builtin_load_info = &default_load_info;
88
89 static HANDLE main_exe_file;
90 static UINT tls_module_count; /* number of modules with TLS directory */
91 static UINT tls_total_size; /* total size of TLS storage */
92 static const IMAGE_TLS_DIRECTORY **tls_dirs; /* array of TLS directories */
93
94 UNICODE_STRING system_dir = { 0, 0, NULL }; /* system directory */
95
96 static RTL_CRITICAL_SECTION loader_section;
97 static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
98 {
99 0, 0, &loader_section,
100 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
101 0, 0, { (DWORD_PTR)(__FILE__ ": loader_section") }
102 };
103 static RTL_CRITICAL_SECTION loader_section = { &critsect_debug, -1, 0, 0, 0, 0 };
104
105 static WINE_MODREF *cached_modref;
106 static WINE_MODREF *current_modref;
107 static WINE_MODREF *last_failed_modref;
108
109 static NTSTATUS load_dll( LPCWSTR load_path, LPCWSTR libname, DWORD flags, WINE_MODREF** pwm );
110 static FARPROC find_named_export( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
111 DWORD exp_size, const char *name, int hint );
112
113 /* convert PE image VirtualAddress to Real Address */
114 inline static void *get_rva( HMODULE module, DWORD va )
115 {
116 return (void *)((char *)module + va);
117 }
118
119 /* check whether the file name contains a path */
120 inline static int contains_path( LPCWSTR name )
121 {
122 return ((*name && (name[1] == ':')) || strchrW(name, '/') || strchrW(name, '\\'));
123 }
124
125 /* convert from straight ASCII to Unicode without depending on the current codepage */
126 inline static void ascii_to_unicode( WCHAR *dst, const char *src, size_t len )
127 {
128 while (len--) *dst++ = (unsigned char)*src++;
129 }
130
131
132 /*************************************************************************
133 * call_dll_entry_point
134 *
135 * Some brain-damaged dlls (ir32_32.dll for instance) modify ebx in
136 * their entry point, so we need a small asm wrapper.
137 */
138 #ifdef __i386__
139 extern BOOL call_dll_entry_point( DLLENTRYPROC proc, void *module, UINT reason, void *reserved );
140 __ASM_GLOBAL_FUNC(call_dll_entry_point,
141 "pushl %ebp\n\t"
142 "movl %esp,%ebp\n\t"
143 "pushl %ebx\n\t"
144 "subl $8,%esp\n\t"
145 "pushl 20(%ebp)\n\t"
146 "pushl 16(%ebp)\n\t"
147 "pushl 12(%ebp)\n\t"
148 "movl 8(%ebp),%eax\n\t"
149 "call *%eax\n\t"
150 "leal -4(%ebp),%esp\n\t"
151 "popl %ebx\n\t"
152 "popl %ebp\n\t"
153 "ret" )
154 #else /* __i386__ */
155 static inline BOOL call_dll_entry_point( DLLENTRYPROC proc, void *module,
156 UINT reason, void *reserved )
157 {
158 return proc( module, reason, reserved );
159 }
160 #endif /* __i386__ */
161
162
163 #ifdef __i386__
164 /*************************************************************************
165 * stub_entry_point
166 *
167 * Entry point for stub functions.
168 */
169 static void stub_entry_point( const char *dll, const char *name, ... )
170 {
171 EXCEPTION_RECORD rec;
172
173 rec.ExceptionCode = EXCEPTION_WINE_STUB;
174 rec.ExceptionFlags = EH_NONCONTINUABLE;
175 rec.ExceptionRecord = NULL;
176 #ifdef __GNUC__
177 rec.ExceptionAddress = __builtin_return_address(0);
178 #else
179 rec.ExceptionAddress = *((void **)&dll - 1);
180 #endif
181 rec.NumberParameters = 2;
182 rec.ExceptionInformation[0] = (ULONG_PTR)dll;
183 rec.ExceptionInformation[1] = (ULONG_PTR)name;
184 for (;;) RtlRaiseException( &rec );
185 }
186
187
188 #include "pshpack1.h"
189 struct stub
190 {
191 BYTE popl_eax; /* popl %eax */
192 BYTE pushl1; /* pushl $name */
193 const char *name;
194 BYTE pushl2; /* pushl $dll */
195 const char *dll;
196 BYTE pushl_eax; /* pushl %eax */
197 BYTE jmp; /* jmp stub_entry_point */
198 DWORD entry;
199 };
200 #include "poppack.h"
201
202 /*************************************************************************
203 * allocate_stub
204 *
205 * Allocate a stub entry point.
206 */
207 static ULONG_PTR allocate_stub( const char *dll, const char *name )
208 {
209 #define MAX_SIZE 65536
210 static struct stub *stubs;
211 static unsigned int nb_stubs;
212 struct stub *stub;
213
214 if (nb_stubs >= MAX_SIZE / sizeof(*stub)) return 0xdeadbeef;
215
216 if (!stubs)
217 {
218 SIZE_T size = MAX_SIZE;
219 if (NtAllocateVirtualMemory( NtCurrentProcess(), (void **)&stubs, 0, &size,
220 MEM_COMMIT, PAGE_EXECUTE_WRITECOPY ) != STATUS_SUCCESS)
221 return 0xdeadbeef;
222 }
223 stub = &stubs[nb_stubs++];
224 stub->popl_eax = 0x58; /* popl %eax */
225 stub->pushl1 = 0x68; /* pushl $name */
226 stub->name = name;
227 stub->pushl2 = 0x68; /* pushl $dll */
228 stub->dll = dll;
229 stub->pushl_eax = 0x50; /* pushl %eax */
230 stub->jmp = 0xe9; /* jmp stub_entry_point */
231 stub->entry = (BYTE *)stub_entry_point - (BYTE *)(&stub->entry + 1);
232 return (ULONG_PTR)stub;
233 }
234
235 #else /* __i386__ */
236 static inline ULONG_PTR allocate_stub( const char *dll, const char *name ) { return 0xdeadbeef; }
237 #endif /* __i386__ */
238
239
240 /*************************************************************************
241 * get_modref
242 *
243 * Looks for the referenced HMODULE in the current process
244 * The loader_section must be locked while calling this function.
245 */
246 static WINE_MODREF *get_modref( HMODULE hmod )
247 {
248 PLIST_ENTRY mark, entry;
249 PLDR_MODULE mod;
250
251 if (cached_modref && cached_modref->ldr.BaseAddress == hmod) return cached_modref;
252
253 mark = &NtCurrentTeb()->Peb->LdrData->InMemoryOrderModuleList;
254 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
255 {
256 mod = CONTAINING_RECORD(entry, LDR_MODULE, InMemoryOrderModuleList);
257 if (mod->BaseAddress == hmod)
258 return cached_modref = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
259 if (mod->BaseAddress > (void*)hmod) break;
260 }
261 return NULL;
262 }
263
264
265 /**********************************************************************
266 * find_basename_module
267 *
268 * Find a module from its base name.
269 * The loader_section must be locked while calling this function
270 */
271 static WINE_MODREF *find_basename_module( LPCWSTR name )
272 {
273 PLIST_ENTRY mark, entry;
274
275 if (cached_modref && !strcmpiW( name, cached_modref->ldr.BaseDllName.Buffer ))
276 return cached_modref;
277
278 mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
279 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
280 {
281 LDR_MODULE *mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
282 if (!strcmpiW( name, mod->BaseDllName.Buffer ))
283 {
284 cached_modref = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
285 return cached_modref;
286 }
287 }
288 return NULL;
289 }
290
291
292 /**********************************************************************
293 * find_fullname_module
294 *
295 * Find a module from its full path name.
296 * The loader_section must be locked while calling this function
297 */
298 static WINE_MODREF *find_fullname_module( LPCWSTR name )
299 {
300 PLIST_ENTRY mark, entry;
301
302 if (cached_modref && !strcmpiW( name, cached_modref->ldr.FullDllName.Buffer ))
303 return cached_modref;
304
305 mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
306 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
307 {
308 LDR_MODULE *mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
309 if (!strcmpiW( name, mod->FullDllName.Buffer ))
310 {
311 cached_modref = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
312 return cached_modref;
313 }
314 }
315 return NULL;
316 }
317
318
319 /*************************************************************************
320 * find_forwarded_export
321 *
322 * Find the final function pointer for a forwarded function.
323 * The loader_section must be locked while calling this function.
324 */
325 static FARPROC find_forwarded_export( HMODULE module, const char *forward )
326 {
327 const IMAGE_EXPORT_DIRECTORY *exports;
328 DWORD exp_size;
329 WINE_MODREF *wm;
330 WCHAR mod_name[32];
331 const char *end = strrchr(forward, '.');
332 FARPROC proc = NULL;
333
334 if (!end) return NULL;
335 if ((end - forward) * sizeof(WCHAR) >= sizeof(mod_name)) return NULL;
336 ascii_to_unicode( mod_name, forward, end - forward );
337 mod_name[end - forward] = 0;
338 if (!strchrW( mod_name, '.' ))
339 {
340 if ((end - forward) * sizeof(WCHAR) >= sizeof(mod_name) - sizeof(dllW)) return NULL;
341 memcpy( mod_name + (end - forward), dllW, sizeof(dllW) );
342 }
343
344 if (!(wm = find_basename_module( mod_name )))
345 {
346 ERR("module not found for forward '%s' used by %s\n",
347 forward, debugstr_w(get_modref(module)->ldr.FullDllName.Buffer) );
348 return NULL;
349 }
350 if ((exports = RtlImageDirectoryEntryToData( wm->ldr.BaseAddress, TRUE,
351 IMAGE_DIRECTORY_ENTRY_EXPORT, &exp_size )))
352 proc = find_named_export( wm->ldr.BaseAddress, exports, exp_size, end + 1, -1 );
353
354 if (!proc)
355 {
356 ERR("function not found for forward '%s' used by %s."
357 " If you are using builtin %s, try using the native one instead.\n",
358 forward, debugstr_w(get_modref(module)->ldr.FullDllName.Buffer),
359 debugstr_w(get_modref(module)->ldr.BaseDllName.Buffer) );
360 }
361 return proc;
362 }
363
364
365 /*************************************************************************
366 * find_ordinal_export
367 *
368 * Find an exported function by ordinal.
369 * The exports base must have been subtracted from the ordinal already.
370 * The loader_section must be locked while calling this function.
371 */
372 static FARPROC find_ordinal_export( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
373 DWORD exp_size, DWORD ordinal )
374 {
375 FARPROC proc;
376 const DWORD *functions = get_rva( module, exports->AddressOfFunctions );
377
378 if (ordinal >= exports->NumberOfFunctions)
379 {
380 TRACE(" ordinal %d out of range!\n", ordinal + exports->Base );
381 return NULL;
382 }
383 if (!functions[ordinal]) return NULL;
384
385 proc = get_rva( module, functions[ordinal] );
386
387 /* if the address falls into the export dir, it's a forward */
388 if (((const char *)proc >= (const char *)exports) &&
389 ((const char *)proc < (const char *)exports + exp_size))
390 return find_forwarded_export( module, (const char *)proc );
391
392 if (TRACE_ON(snoop))
393 {
394 const WCHAR *user = current_modref ? current_modref->ldr.BaseDllName.Buffer : NULL;
395 proc = SNOOP_GetProcAddress( module, exports, exp_size, proc, ordinal, user );
396 }
397 if (TRACE_ON(relay))
398 {
399 const WCHAR *user = current_modref ? current_modref->ldr.BaseDllName.Buffer : NULL;
400 proc = RELAY_GetProcAddress( module, exports, exp_size, proc, ordinal, user );
401 }
402 return proc;
403 }
404
405
406 /*************************************************************************
407 * find_named_export
408 *
409 * Find an exported function by name.
410 * The loader_section must be locked while calling this function.
411 */
412 static FARPROC find_named_export( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
413 DWORD exp_size, const char *name, int hint )
414 {
415 const WORD *ordinals = get_rva( module, exports->AddressOfNameOrdinals );
416 const DWORD *names = get_rva( module, exports->AddressOfNames );
417 int min = 0, max = exports->NumberOfNames - 1;
418
419 /* first check the hint */
420 if (hint >= 0 && hint <= max)
421 {
422 char *ename = get_rva( module, names[hint] );
423 if (!strcmp( ename, name ))
424 return find_ordinal_export( module, exports, exp_size, ordinals[hint] );
425 }
426
427 /* then do a binary search */
428 while (min <= max)
429 {
430 int res, pos = (min + max) / 2;
431 char *ename = get_rva( module, names[pos] );
432 if (!(res = strcmp( ename, name )))
433 return find_ordinal_export( module, exports, exp_size, ordinals[pos] );
434 if (res > 0) max = pos - 1;
435 else min = pos + 1;
436 }
437 return NULL;
438
439 }
440
441
442 /*************************************************************************
443 * import_dll
444 *
445 * Import the dll specified by the given import descriptor.
446 * The loader_section must be locked while calling this function.
447 */
448 static WINE_MODREF *import_dll( HMODULE module, const IMAGE_IMPORT_DESCRIPTOR *descr, LPCWSTR load_path )
449 {
450 NTSTATUS status;
451 WINE_MODREF *wmImp;
452 HMODULE imp_mod;
453 const IMAGE_EXPORT_DIRECTORY *exports;
454 DWORD exp_size;
455 const IMAGE_THUNK_DATA *import_list;
456 IMAGE_THUNK_DATA *thunk_list;
457 WCHAR buffer[32];
458 const char *name = get_rva( module, descr->Name );
459 DWORD len = strlen(name);
460 PVOID protect_base;
461 SIZE_T protect_size = 0;
462 DWORD protect_old;
463
464 thunk_list = get_rva( module, (DWORD)descr->FirstThunk );
465 if (descr->u.OriginalFirstThunk)
466 import_list = get_rva( module, (DWORD)descr->u.OriginalFirstThunk );
467 else
468 import_list = thunk_list;
469
470 while (len && name[len-1] == ' ') len--; /* remove trailing spaces */
471
472 if (len * sizeof(WCHAR) < sizeof(buffer))
473 {
474 ascii_to_unicode( buffer, name, len );
475 buffer[len] = 0;
476 status = load_dll( load_path, buffer, 0, &wmImp );
477 }
478 else /* need to allocate a larger buffer */
479 {
480 WCHAR *ptr = RtlAllocateHeap( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
481 if (!ptr) return NULL;
482 ascii_to_unicode( ptr, name, len );
483 ptr[len] = 0;
484 status = load_dll( load_path, ptr, 0, &wmImp );
485 RtlFreeHeap( GetProcessHeap(), 0, ptr );
486 }
487
488 if (status)
489 {
490 if (status == STATUS_DLL_NOT_FOUND)
491 ERR("Library %s (which is needed by %s) not found\n",
492 name, debugstr_w(current_modref->ldr.FullDllName.Buffer));
493 else
494 ERR("Loading library %s (which is needed by %s) failed (error %x).\n",
495 name, debugstr_w(current_modref->ldr.FullDllName.Buffer), status);
496 return NULL;
497 }
498
499 /* unprotect the import address table since it can be located in
500 * readonly section */
501 while (import_list[protect_size].u1.Ordinal) protect_size++;
502 protect_base = thunk_list;
503 protect_size *= sizeof(*thunk_list);
504 NtProtectVirtualMemory( NtCurrentProcess(), &protect_base,
505 &protect_size, PAGE_WRITECOPY, &protect_old );
506
507 imp_mod = wmImp->ldr.BaseAddress;
508 exports = RtlImageDirectoryEntryToData( imp_mod, TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &exp_size );
509
510 if (!exports)
511 {
512 /* set all imported function to deadbeef */
513 while (import_list->u1.Ordinal)
514 {
515 if (IMAGE_SNAP_BY_ORDINAL(import_list->u1.Ordinal))
516 {
517 int ordinal = IMAGE_ORDINAL(import_list->u1.Ordinal);
518 WARN("No implementation for %s.%d", name, ordinal );
519 thunk_list->u1.Function = allocate_stub( name, (const char *)ordinal );
520 }
521 else
522 {
523 IMAGE_IMPORT_BY_NAME *pe_name = get_rva( module, (DWORD)import_list->u1.AddressOfData );
524 WARN("No implementation for %s.%s", name, pe_name->Name );
525 thunk_list->u1.Function = allocate_stub( name, (const char*)pe_name->Name );
526 }
527 WARN(" imported from %s, allocating stub %p\n",
528 debugstr_w(current_modref->ldr.FullDllName.Buffer),
529 (void *)thunk_list->u1.Function );
530 import_list++;
531 thunk_list++;
532 }
533 goto done;
534 }
535
536 while (import_list->u1.Ordinal)
537 {
538 if (IMAGE_SNAP_BY_ORDINAL(import_list->u1.Ordinal))
539 {
540 int ordinal = IMAGE_ORDINAL(import_list->u1.Ordinal);
541
542 thunk_list->u1.Function = (ULONG_PTR)find_ordinal_export( imp_mod, exports, exp_size,
543 ordinal - exports->Base );
544 if (!thunk_list->u1.Function)
545 {
546 thunk_list->u1.Function = allocate_stub( name, (const char *)ordinal );
547 WARN("No implementation for %s.%d imported from %s, setting to %p\n",
548 name, ordinal, debugstr_w(current_modref->ldr.FullDllName.Buffer),
549 (void *)thunk_list->u1.Function );
550 }
551 TRACE_(imports)("--- Ordinal %s.%d = %p\n", name, ordinal, (void *)thunk_list->u1.Function );
552 }
553 else /* import by name */
554 {
555 IMAGE_IMPORT_BY_NAME *pe_name;
556 pe_name = get_rva( module, (DWORD)import_list->u1.AddressOfData );
557 thunk_list->u1.Function = (ULONG_PTR)find_named_export( imp_mod, exports, exp_size,
558 (const char*)pe_name->Name, pe_name->Hint );
559 if (!thunk_list->u1.Function)
560 {
561 thunk_list->u1.Function = allocate_stub( name, (const char*)pe_name->Name );
562 WARN("No implementation for %s.%s imported from %s, setting to %p\n",
563 name, pe_name->Name, debugstr_w(current_modref->ldr.FullDllName.Buffer),
564 (void *)thunk_list->u1.Function );
565 }
566 TRACE_(imports)("--- %s %s.%d = %p\n",
567 pe_name->Name, name, pe_name->Hint, (void *)thunk_list->u1.Function);
568 }
569 import_list++;
570 thunk_list++;
571 }
572
573 done:
574 /* restore old protection of the import address table */
575 NtProtectVirtualMemory( NtCurrentProcess(), &protect_base, &protect_size, protect_old, NULL );
576 return wmImp;
577 }
578
579
580 /****************************************************************
581 * fixup_imports
582 *
583 * Fixup all imports of a given module.
584 * The loader_section must be locked while calling this function.
585 */
586 static NTSTATUS fixup_imports( WINE_MODREF *wm, LPCWSTR load_path )
587 {
588 int i, nb_imports;
589 const IMAGE_IMPORT_DESCRIPTOR *imports;
590 WINE_MODREF *prev;
591 DWORD size;
592 NTSTATUS status;
593
594 if (!(wm->ldr.Flags & LDR_DONT_RESOLVE_REFS)) return STATUS_SUCCESS; /* already done */
595 wm->ldr.Flags &= ~LDR_DONT_RESOLVE_REFS;
596
597 if (!(imports = RtlImageDirectoryEntryToData( wm->ldr.BaseAddress, TRUE,
598 IMAGE_DIRECTORY_ENTRY_IMPORT, &size )))
599 return STATUS_SUCCESS;
600
601 nb_imports = 0;
602 while (imports[nb_imports].Name && imports[nb_imports].FirstThunk) nb_imports++;
603
604 if (!nb_imports) return STATUS_SUCCESS; /* no imports */
605
606 /* Allocate module dependency list */
607 wm->nDeps = nb_imports;
608 wm->deps = RtlAllocateHeap( GetProcessHeap(), 0, nb_imports*sizeof(WINE_MODREF *) );
609
610 /* load the imported modules. They are automatically
611 * added to the modref list of the process.
612 */
613 prev = current_modref;
614 current_modref = wm;
615 status = STATUS_SUCCESS;
616 for (i = 0; i < nb_imports; i++)
617 {
618 if (!(wm->deps[i] = import_dll( wm->ldr.BaseAddress, &imports[i], load_path )))
619 status = STATUS_DLL_NOT_FOUND;
620 }
621 current_modref = prev;
622 return status;
623 }
624
625
626 /*************************************************************************
627 * alloc_module
628 *
629 * Allocate a WINE_MODREF structure and add it to the process list
630 * The loader_section must be locked while calling this function.
631 */
632 static WINE_MODREF *alloc_module( HMODULE hModule, LPCWSTR filename )
633 {
634 WINE_MODREF *wm;
635 const WCHAR *p;
636 const IMAGE_NT_HEADERS *nt = RtlImageNtHeader(hModule);
637 PLIST_ENTRY entry, mark;
638
639 if (!(wm = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*wm) ))) return NULL;
640
641 wm->nDeps = 0;
642 wm->deps = NULL;
643
644 wm->ldr.BaseAddress = hModule;
645 wm->ldr.EntryPoint = NULL;
646 wm->ldr.SizeOfImage = nt->OptionalHeader.SizeOfImage;
647 wm->ldr.Flags = LDR_DONT_RESOLVE_REFS;
648 wm->ldr.LoadCount = 1;
649 wm->ldr.TlsIndex = -1;
650 wm->ldr.SectionHandle = NULL;
651 wm->ldr.CheckSum = 0;
652 wm->ldr.TimeDateStamp = 0;
653
654 RtlCreateUnicodeString( &wm->ldr.FullDllName, filename );
655 if ((p = strrchrW( wm->ldr.FullDllName.Buffer, '\\' ))) p++;
656 else p = wm->ldr.FullDllName.Buffer;
657 RtlInitUnicodeString( &wm->ldr.BaseDllName, p );
658
659 if (nt->FileHeader.Characteristics & IMAGE_FILE_DLL)
660 {
661 wm->ldr.Flags |= LDR_IMAGE_IS_DLL;
662 if (nt->OptionalHeader.AddressOfEntryPoint)
663 wm->ldr.EntryPoint = (char *)hModule + nt->OptionalHeader.AddressOfEntryPoint;
664 }
665
666 InsertTailList(&NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList,
667 &wm->ldr.InLoadOrderModuleList);
668
669 /* insert module in MemoryList, sorted in increasing base addresses */
670 mark = &NtCurrentTeb()->Peb->LdrData->InMemoryOrderModuleList;
671 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
672 {
673 if (CONTAINING_RECORD(entry, LDR_MODULE, InMemoryOrderModuleList)->BaseAddress > wm->ldr.BaseAddress)
674 break;
675 }
676 entry->Blink->Flink = &wm->ldr.InMemoryOrderModuleList;
677 wm->ldr.InMemoryOrderModuleList.Blink = entry->Blink;
678 wm->ldr.InMemoryOrderModuleList.Flink = entry;
679 entry->Blink = &wm->ldr.InMemoryOrderModuleList;
680
681 /* wait until init is called for inserting into this list */
682 wm->ldr.InInitializationOrderModuleList.Flink = NULL;
683 wm->ldr.InInitializationOrderModuleList.Blink = NULL;
684
685 if (!(nt->OptionalHeader.DllCharacteristics & IMAGE_DLLCHARACTERISTICS_NX_COMPAT))
686 {
687 WARN( "disabling no-exec because of %s\n", debugstr_w(wm->ldr.BaseDllName.Buffer) );
688 VIRTUAL_SetForceExec( TRUE );
689 }
690 return wm;
691 }
692
693
694 /*************************************************************************
695 * alloc_process_tls
696 *
697 * Allocate the process-wide structure for module TLS storage.
698 */
699 static NTSTATUS alloc_process_tls(void)
700 {
701 PLIST_ENTRY mark, entry;
702 PLDR_MODULE mod;
703 const IMAGE_TLS_DIRECTORY *dir;
704 ULONG size, i;
705
706 mark = &NtCurrentTeb()->Peb->LdrData->InMemoryOrderModuleList;
707 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
708 {
709 mod = CONTAINING_RECORD(entry, LDR_MODULE, InMemoryOrderModuleList);
710 if (!(dir = RtlImageDirectoryEntryToData( mod->BaseAddress, TRUE,
711 IMAGE_DIRECTORY_ENTRY_TLS, &size )))
712 continue;
713 size = (dir->EndAddressOfRawData - dir->StartAddressOfRawData) + dir->SizeOfZeroFill;
714 if (!size) continue;
715 tls_total_size += size;
716 tls_module_count++;
717 }
718 if (!tls_module_count) return STATUS_SUCCESS;
719
720 TRACE( "count %u size %u\n", tls_module_count, tls_total_size );
721
722 tls_dirs = RtlAllocateHeap( GetProcessHeap(), 0, tls_module_count * sizeof(*tls_dirs) );
723 if (!tls_dirs) return STATUS_NO_MEMORY;
724
725 for (i = 0, entry = mark->Flink; entry != mark; entry = entry->Flink)
726 {
727 mod = CONTAINING_RECORD(entry, LDR_MODULE, InMemoryOrderModuleList);
728 if (!(dir = RtlImageDirectoryEntryToData( mod->BaseAddress, TRUE,
729 IMAGE_DIRECTORY_ENTRY_TLS, &size )))
730 continue;
731 tls_dirs[i] = dir;
732 *(DWORD *)dir->AddressOfIndex = i;
733 mod->TlsIndex = i;
734 mod->LoadCount = -1; /* can't unload it */
735 i++;
736 }
737 return STATUS_SUCCESS;
738 }
739
740
741 /*************************************************************************
742 * alloc_thread_tls
743 *
744 * Allocate the per-thread structure for module TLS storage.
745 */
746 static NTSTATUS alloc_thread_tls(void)
747 {
748 void **pointers;
749 char *data;
750 UINT i;
751
752 if (!tls_module_count) return STATUS_SUCCESS;
753
754 if (!(pointers = RtlAllocateHeap( GetProcessHeap(), 0,
755 tls_module_count * sizeof(*pointers) )))
756 return STATUS_NO_MEMORY;
757
758 if (!(data = RtlAllocateHeap( GetProcessHeap(), 0, tls_total_size )))
759 {
760 RtlFreeHeap( GetProcessHeap(), 0, pointers );
761 return STATUS_NO_MEMORY;
762 }
763
764 for (i = 0; i < tls_module_count; i++)
765 {
766 const IMAGE_TLS_DIRECTORY *dir = tls_dirs[i];
767 ULONG size = dir->EndAddressOfRawData - dir->StartAddressOfRawData;
768
769 TRACE( "thread %04x idx %d: %d/%d bytes from %p to %p\n",
770 GetCurrentThreadId(), i, size, dir->SizeOfZeroFill,
771 (void *)dir->StartAddressOfRawData, data );
772
773 pointers[i] = data;
774 memcpy( data, (void *)dir->StartAddressOfRawData, size );
775 data += size;
776 memset( data, 0, dir->SizeOfZeroFill );
777 data += dir->SizeOfZeroFill;
778 }
779 NtCurrentTeb()->ThreadLocalStoragePointer = pointers;
780 return STATUS_SUCCESS;
781 }
782
783
784 /*************************************************************************
785 * call_tls_callbacks
786 */
787 static void call_tls_callbacks( HMODULE module, UINT reason )
788 {
789 const IMAGE_TLS_DIRECTORY *dir;
790 const PIMAGE_TLS_CALLBACK *callback;
791 ULONG dirsize;
792
793 dir = RtlImageDirectoryEntryToData( module, TRUE, IMAGE_DIRECTORY_ENTRY_TLS, &dirsize );
794 if (!dir || !dir->AddressOfCallBacks) return;
795
796 for (callback = (const PIMAGE_TLS_CALLBACK *)dir->AddressOfCallBacks; *callback; callback++)
797 {
798 if (TRACE_ON(relay))
799 DPRINTF("%04x:Call TLS callback (proc=%p,module=%p,reason=%s,reserved=0)\n",
800 GetCurrentThreadId(), *callback, module, reason_names[reason] );
801 (*callback)( module, reason, NULL );
802 if (TRACE_ON(relay))
803 DPRINTF("%04x:Ret TLS callback (proc=%p,module=%p,reason=%s,reserved=0)\n",
804 GetCurrentThreadId(), *callback, module, reason_names[reason] );
805 }
806 }
807
808
809 /*************************************************************************
810 * MODULE_InitDLL
811 */
812 static BOOL MODULE_InitDLL( WINE_MODREF *wm, UINT reason, LPVOID lpReserved )
813 {
814 WCHAR mod_name[32];
815 BOOL retv = TRUE;
816 DLLENTRYPROC entry = wm->ldr.EntryPoint;
817 void *module = wm->ldr.BaseAddress;
818
819 /* Skip calls for modules loaded with special load flags */
820
821 if (wm->ldr.Flags & LDR_DONT_RESOLVE_REFS) return TRUE;
822 if (wm->ldr.TlsIndex != -1) call_tls_callbacks( wm->ldr.BaseAddress, reason );
823 if (!entry) return TRUE;
824
825 if (TRACE_ON(relay))
826 {
827 size_t len = min( wm->ldr.BaseDllName.Length, sizeof(mod_name)-sizeof(WCHAR) );
828 memcpy( mod_name, wm->ldr.BaseDllName.Buffer, len );
829 mod_name[len / sizeof(WCHAR)] = 0;
830 DPRINTF("%04x:Call PE DLL (proc=%p,module=%p %s,reason=%s,res=%p)\n",
831 GetCurrentThreadId(), entry, module, debugstr_w(mod_name),
832 reason_names[reason], lpReserved );
833 }
834 else TRACE("(%p %s,%s,%p) - CALL\n", module, debugstr_w(wm->ldr.BaseDllName.Buffer),
835 reason_names[reason], lpReserved );
836
837 retv = call_dll_entry_point( entry, module, reason, lpReserved );
838
839 /* The state of the module list may have changed due to the call
840 to the dll. We cannot assume that this module has not been
841 deleted. */
842 if (TRACE_ON(relay))
843 DPRINTF("%04x:Ret PE DLL (proc=%p,module=%p %s,reason=%s,res=%p) retval=%x\n",
844 GetCurrentThreadId(), entry, module, debugstr_w(mod_name),
845 reason_names[reason], lpReserved, retv );
846 else TRACE("(%p,%s,%p) - RETURN %d\n", module, reason_names[reason], lpReserved, retv );
847
848 return retv;
849 }
850
851
852 /*************************************************************************
853 * process_attach
854 *
855 * Send the process attach notification to all DLLs the given module
856 * depends on (recursively). This is somewhat complicated due to the fact that
857 *
858 * - we have to respect the module dependencies, i.e. modules implicitly
859 * referenced by another module have to be initialized before the module
860 * itself can be initialized
861 *
862 * - the initialization routine of a DLL can itself call LoadLibrary,
863 * thereby introducing a whole new set of dependencies (even involving
864 * the 'old' modules) at any time during the whole process
865 *
866 * (Note that this routine can be recursively entered not only directly
867 * from itself, but also via LoadLibrary from one of the called initialization
868 * routines.)
869 *
870 * Furthermore, we need to rearrange the main WINE_MODREF list to allow
871 * the process *detach* notifications to be sent in the correct order.
872 * This must not only take into account module dependencies, but also
873 * 'hidden' dependencies created by modules calling LoadLibrary in their
874 * attach notification routine.
875 *
876 * The strategy is rather simple: we move a WINE_MODREF to the head of the
877 * list after the attach notification has returned. This implies that the
878 * detach notifications are called in the reverse of the sequence the attach
879 * notifications *returned*.
880 *
881 * The loader_section must be locked while calling this function.
882 */
883 static NTSTATUS process_attach( WINE_MODREF *wm, LPVOID lpReserved )
884 {
885 NTSTATUS status = STATUS_SUCCESS;
886 int i;
887
888 if (process_detaching) return status;
889
890 /* prevent infinite recursion in case of cyclical dependencies */
891 if ( ( wm->ldr.Flags & LDR_LOAD_IN_PROGRESS )
892 || ( wm->ldr.Flags & LDR_PROCESS_ATTACHED ) )
893 return status;
894
895 TRACE("(%s,%p) - START\n", debugstr_w(wm->ldr.BaseDllName.Buffer), lpReserved );
896
897 /* Tag current MODREF to prevent recursive loop */
898 wm->ldr.Flags |= LDR_LOAD_IN_PROGRESS;
899
900 /* Recursively attach all DLLs this one depends on */
901 for ( i = 0; i < wm->nDeps; i++ )
902 {
903 if (!wm->deps[i]) continue;
904 if ((status = process_attach( wm->deps[i], lpReserved )) != STATUS_SUCCESS) break;
905 }
906
907 /* Call DLL entry point */
908 if (status == STATUS_SUCCESS)
909 {
910 WINE_MODREF *prev = current_modref;
911 current_modref = wm;
912 if (MODULE_InitDLL( wm, DLL_PROCESS_ATTACH, lpReserved ))
913 {
914 wm->ldr.Flags |= LDR_PROCESS_ATTACHED;
915 }
916 else
917 {
918 /* point to the name so LdrInitializeThunk can print it */
919 last_failed_modref = wm;
920 WARN("Initialization of %s failed\n", debugstr_w(wm->ldr.BaseDllName.Buffer));
921 status = STATUS_DLL_INIT_FAILED;
922 }
923 current_modref = prev;
924 }
925
926 if (!wm->ldr.InInitializationOrderModuleList.Flink)
927 InsertTailList(&NtCurrentTeb()->Peb->LdrData->InInitializationOrderModuleList,
928 &wm->ldr.InInitializationOrderModuleList);
929
930 /* Remove recursion flag */
931 wm->ldr.Flags &= ~LDR_LOAD_IN_PROGRESS;
932
933 TRACE("(%s,%p) - END\n", debugstr_w(wm->ldr.BaseDllName.Buffer), lpReserved );
934 return status;
935 }
936
937
938 /**********************************************************************
939 * attach_implicitly_loaded_dlls
940 *
941 * Attach to the (builtin) dlls that have been implicitly loaded because
942 * of a dependency at the Unix level, but not imported at the Win32 level.
943 */
944 static void attach_implicitly_loaded_dlls( LPVOID reserved )
945 {
946 for (;;)
947 {
948 PLIST_ENTRY mark, entry;
949
950 mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
951 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
952 {
953 LDR_MODULE *mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
954
955 if (mod->Flags & (LDR_LOAD_IN_PROGRESS | LDR_PROCESS_ATTACHED)) continue;
956 TRACE( "found implicitly loaded %s, attaching to it\n",
957 debugstr_w(mod->BaseDllName.Buffer));
958 mod->LoadCount = -1; /* we can't unload it anyway */
959 process_attach( CONTAINING_RECORD(mod, WINE_MODREF, ldr), reserved );
960 break; /* restart the search from the start */
961 }
962 if (entry == mark) break; /* nothing found */
963 }
964 }
965
966
967 /*************************************************************************
968 * process_detach
969 *
970 * Send DLL process detach notifications. See the comment about calling
971 * sequence at process_attach. Unless the bForceDetach flag
972 * is set, only DLLs with zero refcount are notified.
973 */
974 static void process_detach( BOOL bForceDetach, LPVOID lpReserved )
975 {
976 PLIST_ENTRY mark, entry;
977 PLDR_MODULE mod;
978
979 RtlEnterCriticalSection( &loader_section );
980 if (bForceDetach) process_detaching = 1;
981 mark = &NtCurrentTeb()->Peb->LdrData->InInitializationOrderModuleList;
982 do
983 {
984 for (entry = mark->Blink; entry != mark; entry = entry->Blink)
985 {
986 mod = CONTAINING_RECORD(entry, LDR_MODULE,
987 InInitializationOrderModuleList);
988 /* Check whether to detach this DLL */
989 if ( !(mod->Flags & LDR_PROCESS_ATTACHED) )
990 continue;
991 if ( mod->LoadCount && !bForceDetach )
992 continue;
993
994 /* Call detach notification */
995 mod->Flags &= ~LDR_PROCESS_ATTACHED;
996 MODULE_InitDLL( CONTAINING_RECORD(mod, WINE_MODREF, ldr),
997 DLL_PROCESS_DETACH, lpReserved );
998
999 /* Restart at head of WINE_MODREF list, as entries might have
1000 been added and/or removed while performing the call ... */
1001 break;
1002 }
1003 } while (entry != mark);
1004
1005 RtlLeaveCriticalSection( &loader_section );
1006 }
1007
1008 /*************************************************************************
1009 * MODULE_DllThreadAttach
1010 *
1011 * Send DLL thread attach notifications. These are sent in the
1012 * reverse sequence of process detach notification.
1013 *
1014 */
1015 NTSTATUS MODULE_DllThreadAttach( LPVOID lpReserved )
1016 {
1017 PLIST_ENTRY mark, entry;
1018 PLDR_MODULE mod;
1019 NTSTATUS status;
1020
1021 /* don't do any attach calls if process is exiting */
1022 if (process_detaching) return STATUS_SUCCESS;
1023 /* FIXME: there is still a race here */
1024
1025 RtlEnterCriticalSection( &loader_section );
1026
1027 if ((status = alloc_thread_tls()) != STATUS_SUCCESS) goto done;
1028
1029 mark = &NtCurrentTeb()->Peb->LdrData->InInitializationOrderModuleList;
1030 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
1031 {
1032 mod = CONTAINING_RECORD(entry, LDR_MODULE,
1033 InInitializationOrderModuleList);
1034 if ( !(mod->Flags & LDR_PROCESS_ATTACHED) )
1035 continue;
1036 if ( mod->Flags & LDR_NO_DLL_CALLS )
1037 continue;
1038
1039 MODULE_InitDLL( CONTAINING_RECORD(mod, WINE_MODREF, ldr),
1040 DLL_THREAD_ATTACH, lpReserved );
1041 }
1042
1043 done:
1044 RtlLeaveCriticalSection( &loader_section );
1045 return status;
1046 }
1047
1048 /******************************************************************
1049 * LdrDisableThreadCalloutsForDll (NTDLL.@)
1050 *
1051 */
1052 NTSTATUS WINAPI LdrDisableThreadCalloutsForDll(HMODULE hModule)
1053 {
1054 WINE_MODREF *wm;
1055 NTSTATUS ret = STATUS_SUCCESS;
1056
1057 RtlEnterCriticalSection( &loader_section );
1058
1059 wm = get_modref( hModule );
1060 if (!wm || wm->ldr.TlsIndex != -1)
1061 ret = STATUS_DLL_NOT_FOUND;
1062 else
1063 wm->ldr.Flags |= LDR_NO_DLL_CALLS;
1064
1065 RtlLeaveCriticalSection( &loader_section );
1066
1067 return ret;
1068 }
1069
1070 /******************************************************************
1071 * LdrFindEntryForAddress (NTDLL.@)
1072 *
1073 * The loader_section must be locked while calling this function
1074 */
1075 NTSTATUS WINAPI LdrFindEntryForAddress(const void* addr, PLDR_MODULE* pmod)
1076 {
1077 PLIST_ENTRY mark, entry;
1078 PLDR_MODULE mod;
1079
1080 mark = &NtCurrentTeb()->Peb->LdrData->InMemoryOrderModuleList;
1081 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
1082 {
1083 mod = CONTAINING_RECORD(entry, LDR_MODULE, InMemoryOrderModuleList);
1084 if ((const void *)mod->BaseAddress <= addr &&
1085 (const char *)addr < (char*)mod->BaseAddress + mod->SizeOfImage)
1086 {
1087 *pmod = mod;
1088 return STATUS_SUCCESS;
1089 }
1090 if ((const void *)mod->BaseAddress > addr) break;
1091 }
1092 return STATUS_NO_MORE_ENTRIES;
1093 }
1094
1095 /******************************************************************
1096 * LdrLockLoaderLock (NTDLL.@)
1097 *
1098 * Note: flags are not implemented.
1099 * Flag 0x01 is used to raise exceptions on errors.
1100 * Flag 0x02 is used to avoid waiting on the section (does RtlTryEnterCriticalSection instead).
1101 */
1102 NTSTATUS WINAPI LdrLockLoaderLock( ULONG flags, ULONG *result, ULONG *magic )
1103 {
1104 if (flags) FIXME( "flags %x not supported\n", flags );
1105
1106 if (result) *result = 1;
1107 if (!magic) return STATUS_INVALID_PARAMETER_3;
1108 RtlEnterCriticalSection( &loader_section );
1109 *magic = GetCurrentThreadId();
1110 return STATUS_SUCCESS;
1111 }
1112
1113
1114 /******************************************************************
1115 * LdrUnlockLoaderUnlock (NTDLL.@)
1116 */
1117 NTSTATUS WINAPI LdrUnlockLoaderLock( ULONG flags, ULONG magic )
1118 {
1119 if (magic)
1120 {
1121 if (magic != GetCurrentThreadId()) return STATUS_INVALID_PARAMETER_2;
1122 RtlLeaveCriticalSection( &loader_section );
1123 }
1124 return STATUS_SUCCESS;
1125 }
1126
1127
1128 /******************************************************************
1129 * LdrGetDllHandle (NTDLL.@)
1130 */
1131 NTSTATUS WINAPI LdrGetDllHandle(ULONG x, ULONG y, const UNICODE_STRING *name, HMODULE *base)
1132 {
1133 NTSTATUS status = STATUS_DLL_NOT_FOUND;
1134 WCHAR dllname[MAX_PATH+4], *p;
1135 UNICODE_STRING str;
1136 PLIST_ENTRY mark, entry;
1137 PLDR_MODULE mod;
1138
1139 if (x != 0 || y != 0)
1140 FIXME("Unknown behavior, please report\n");
1141
1142 /* Append .DLL to name if no extension present */
1143 if (!(p = strrchrW( name->Buffer, '.')) || strchrW( p, '/' ) || strchrW( p, '\\'))
1144 {
1145 if (name->Length >= MAX_PATH) return STATUS_NAME_TOO_LONG;
1146 strcpyW( dllname, name->Buffer );
1147 strcatW( dllname, dllW );
1148 RtlInitUnicodeString( &str, dllname );
1149 name = &str;
1150 }
1151
1152 RtlEnterCriticalSection( &loader_section );
1153
1154 if (cached_modref)
1155 {
1156 if (RtlEqualUnicodeString( name, &cached_modref->ldr.FullDllName, TRUE ) ||
1157 RtlEqualUnicodeString( name, &cached_modref->ldr.BaseDllName, TRUE ))
1158 {
1159 *base = cached_modref->ldr.BaseAddress;
1160 status = STATUS_SUCCESS;
1161 goto done;
1162 }
1163 }
1164
1165 mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
1166 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
1167 {
1168 mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
1169
1170 if (RtlEqualUnicodeString( name, &mod->FullDllName, TRUE ) ||
1171 RtlEqualUnicodeString( name, &mod->BaseDllName, TRUE ))
1172 {
1173 cached_modref = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
1174 *base = mod->BaseAddress;
1175 status = STATUS_SUCCESS;
1176 break;
1177 }
1178 }
1179 done:
1180 RtlLeaveCriticalSection( &loader_section );
1181 TRACE("%x %x %s -> %p\n", x, y, debugstr_us(name), status ? NULL : *base);
1182 return status;
1183 }
1184
1185
1186 /******************************************************************
1187 * LdrGetProcedureAddress (NTDLL.@)
1188 */
1189 NTSTATUS WINAPI LdrGetProcedureAddress(HMODULE module, const ANSI_STRING *name,
1190 ULONG ord, PVOID *address)
1191 {
1192 IMAGE_EXPORT_DIRECTORY *exports;
1193 DWORD exp_size;
1194 NTSTATUS ret = STATUS_PROCEDURE_NOT_FOUND;
1195
1196 RtlEnterCriticalSection( &loader_section );
1197
1198 /* check if the module itself is invalid to return the proper error */
1199 if (!get_modref( module )) ret = STATUS_DLL_NOT_FOUND;
1200 else if ((exports = RtlImageDirectoryEntryToData( module, TRUE,
1201 IMAGE_DIRECTORY_ENTRY_EXPORT, &exp_size )))
1202 {
1203 void *proc = name ? find_named_export( module, exports, exp_size, name->Buffer, -1 )
1204 : find_ordinal_export( module, exports, exp_size, ord - exports->Base );
1205 if (proc)
1206 {
1207 *address = proc;
1208 ret = STATUS_SUCCESS;
1209 }
1210 }
1211
1212 RtlLeaveCriticalSection( &loader_section );
1213 return ret;
1214 }
1215
1216
1217 /***********************************************************************
1218 * is_fake_dll
1219 *
1220 * Check if a loaded native dll is a Wine fake dll.
1221 */
1222 static BOOL is_fake_dll( const void *base )
1223 {
1224 static const char fakedll_signature[] = "Wine placeholder DLL";
1225 const IMAGE_DOS_HEADER *dos = base;
1226
1227 if (dos->e_lfanew >= sizeof(*dos) + sizeof(fakedll_signature) &&
1228 !memcmp( dos + 1, fakedll_signature, sizeof(fakedll_signature) )) return TRUE;
1229 return FALSE;
1230 }
1231
1232
1233 /***********************************************************************
1234 * get_builtin_fullname
1235 *
1236 * Build the full pathname for a builtin dll.
1237 */
1238 static WCHAR *get_builtin_fullname( const WCHAR *path, const char *filename )
1239 {
1240 static const WCHAR soW[] = {'.','s','o',0};
1241 WCHAR *p, *fullname;
1242 size_t i, len = strlen(filename);
1243
1244 /* check if path can correspond to the dll we have */
1245 if (path && (p = strrchrW( path, '\\' )))
1246 {
1247 p++;
1248 for (i = 0; i < len; i++)
1249 if (tolowerW(p[i]) != tolowerW( (WCHAR)filename[i]) ) break;
1250 if (i == len && (!p[len] || !strcmpiW( p + len, soW )))
1251 {
1252 /* the filename matches, use path as the full path */
1253 len += p - path;
1254 if ((fullname = RtlAllocateHeap( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) )))
1255 {
1256 memcpy( fullname, path, len * sizeof(WCHAR) );
1257 fullname[len] = 0;
1258 }
1259 return fullname;
1260 }
1261 }
1262
1263 if ((fullname = RtlAllocateHeap( GetProcessHeap(), 0,
1264 system_dir.MaximumLength + (len + 1) * sizeof(WCHAR) )))
1265 {
1266 memcpy( fullname, system_dir.Buffer, system_dir.Length );
1267 p = fullname + system_dir.Length / sizeof(WCHAR);
1268 if (p > fullname && p[-1] != '\\') *p++ = '\\';
1269 ascii_to_unicode( p, filename, len + 1 );
1270 }
1271 return fullname;
1272 }
1273
1274
1275 /***********************************************************************
1276 * load_builtin_callback
1277 *
1278 * Load a library in memory; callback function for wine_dll_register
1279 */
1280 static void load_builtin_callback( void *module, const char *filename )
1281 {
1282 static const WCHAR emptyW[1];
1283 void *addr;
1284 IMAGE_NT_HEADERS *nt;
1285 WINE_MODREF *wm;
1286 WCHAR *fullname;
1287 const WCHAR *load_path;
1288 SIZE_T size;
1289
1290 if (!module)
1291 {
1292 ERR("could not map image for %s\n", filename ? filename : "main exe" );
1293 return;
1294 }
1295 if (!(nt = RtlImageNtHeader( module )))
1296 {
1297 ERR( "bad module for %s\n", filename ? filename : "main exe" );
1298 builtin_load_info->status = STATUS_INVALID_IMAGE_FORMAT;
1299 return;
1300 }
1301 addr = module;
1302 size = nt->OptionalHeader.SizeOfImage;
1303 NtAllocateVirtualMemory( NtCurrentProcess(), &addr, 0, &size,
1304 MEM_SYSTEM | MEM_IMAGE, PAGE_EXECUTE_WRITECOPY );
1305 /* create the MODREF */
1306
1307 if (!(fullname = get_builtin_fullname( builtin_load_info->filename, filename )))
1308 {
1309 ERR( "can't load %s\n", filename );
1310 builtin_load_info->status = STATUS_NO_MEMORY;
1311 return;
1312 }
1313
1314 wm = alloc_module( module, fullname );
1315 RtlFreeHeap( GetProcessHeap(), 0, fullname );
1316 if (!wm)
1317 {
1318 ERR( "can't load %s\n", filename );
1319 builtin_load_info->status = STATUS_NO_MEMORY;
1320 return;
1321 }
1322 wm->ldr.Flags |= LDR_WINE_INTERNAL;
1323
1324 if (!(nt->FileHeader.Characteristics & IMAGE_FILE_DLL) &&
1325 !NtCurrentTeb()->Peb->ImageBaseAddress) /* if we already have an executable, ignore this one */
1326 {
1327 NtCurrentTeb()->Peb->ImageBaseAddress = module;
1328 }
1329 else
1330 {
1331 /* fixup imports */
1332
1333 load_path = builtin_load_info->load_path;
1334 if (!load_path) load_path = NtCurrentTeb()->Peb->ProcessParameters->DllPath.Buffer;
1335 if (!load_path) load_path = emptyW;
1336 if (fixup_imports( wm, load_path ) != STATUS_SUCCESS)
1337 {
1338 /* the module has only be inserted in the load & memory order lists */
1339 RemoveEntryList(&wm->ldr.InLoadOrderModuleList);
1340 RemoveEntryList(&wm->ldr.InMemoryOrderModuleList);
1341 /* FIXME: free the modref */
1342 builtin_load_info->status = STATUS_DLL_NOT_FOUND;
1343 return;
1344 }
1345 }
1346
1347 builtin_load_info->wm = wm;
1348 TRACE( "loaded %s %p %p\n", filename, wm, module );
1349
1350 /* send the DLL load event */
1351
1352 SERVER_START_REQ( load_dll )
1353 {
1354 req->handle = 0;
1355 req->base = module;
1356 req->size = nt->OptionalHeader.SizeOfImage;
1357 req->dbg_offset = nt->FileHeader.PointerToSymbolTable;
1358 req->dbg_size = nt->FileHeader.NumberOfSymbols;
1359 req->name = &wm->ldr.FullDllName.Buffer;
1360 wine_server_add_data( req, wm->ldr.FullDllName.Buffer, wm->ldr.FullDllName.Length );
1361 wine_server_call( req );
1362 }
1363 SERVER_END_REQ;
1364
1365 /* setup relay debugging entry points */
1366 if (TRACE_ON(relay)) RELAY_SetupDLL( module );
1367 }
1368
1369
1370 /******************************************************************************
1371 * load_native_dll (internal)
1372 */
1373 static NTSTATUS load_native_dll( LPCWSTR load_path, LPCWSTR name, HANDLE file,
1374 DWORD flags, WINE_MODREF** pwm )
1375 {
1376 void *module;
1377 HANDLE mapping;
1378 OBJECT_ATTRIBUTES attr;
1379 LARGE_INTEGER size;
1380 IMAGE_NT_HEADERS *nt;
1381 SIZE_T len = 0;
1382 WINE_MODREF *wm;
1383 NTSTATUS status;
1384
1385 TRACE("Trying native dll %s\n", debugstr_w(name));
1386
1387 attr.Length = sizeof(attr);
1388 attr.RootDirectory = 0;
1389 attr.ObjectName = NULL;
1390 attr.Attributes = 0;
1391 attr.SecurityDescriptor = NULL;
1392 attr.SecurityQualityOfService = NULL;
1393 size.QuadPart = 0;
1394
1395 status = NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1396 &attr, &size, 0, SEC_IMAGE, file );
1397 if (status != STATUS_SUCCESS) return status;
1398
1399 module = NULL;
1400 status = NtMapViewOfSection( mapping, NtCurrentProcess(),
1401 &module, 0, 0, &size, &len, ViewShare, 0, PAGE_READONLY );
1402 NtClose( mapping );
1403 if (status != STATUS_SUCCESS) return status;
1404
1405 if (is_fake_dll( module ))
1406 {
1407 TRACE( "%s is a fake dll, not loading it\n", debugstr_w(name) );
1408 NtUnmapViewOfSection( NtCurrentProcess(), module );
1409 return STATUS_DLL_NOT_FOUND;
1410 }
1411
1412 /* create the MODREF */
1413
1414 if (!(wm = alloc_module( module, name ))) return STATUS_NO_MEMORY;
1415
1416 /* fixup imports */
1417
1418 if (!(flags & DONT_RESOLVE_DLL_REFERENCES))
1419 {
1420 if ((status = fixup_imports( wm, load_path )) != STATUS_SUCCESS)
1421 {
1422 /* the module has only be inserted in the load & memory order lists */
1423 RemoveEntryList(&wm->ldr.InLoadOrderModuleList);
1424 RemoveEntryList(&wm->ldr.InMemoryOrderModuleList);
1425
1426 /* FIXME: there are several more dangling references
1427 * left. Including dlls loaded by this dll before the
1428 * failed one. Unrolling is rather difficult with the
1429 * current structure and we can leave them lying
1430 * around with no problems, so we don't care.
1431 * As these might reference our wm, we don't free it.
1432 */
1433 return status;
1434 }
1435 }
1436
1437 /* send DLL load event */
1438
1439 nt = RtlImageNtHeader( module );
1440
1441 SERVER_START_REQ( load_dll )
1442 {
1443 req->handle = file;
1444 req->base = module;
1445 req->size = nt->OptionalHeader.SizeOfImage;
1446 req->dbg_offset = nt->FileHeader.PointerToSymbolTable;
1447 req->dbg_size = nt->FileHeader.NumberOfSymbols;
1448 req->name = &wm->ldr.FullDllName.Buffer;
1449 wine_server_add_data( req, wm->ldr.FullDllName.Buffer, wm->ldr.FullDllName.Length );
1450 wine_server_call( req );
1451 }
1452 SERVER_END_REQ;
1453
1454 if (TRACE_ON(snoop)) SNOOP_SetupDLL( module );
1455
1456 TRACE_(loaddll)( " Loaded module %s : native\n", debugstr_w(wm->ldr.FullDllName.Buffer) );
1457
1458 wm->ldr.LoadCount = 1;
1459 *pwm = wm;
1460 return STATUS_SUCCESS;
1461 }
1462
1463
1464 /***********************************************************************
1465 * load_builtin_dll
1466 */
1467 static NTSTATUS load_builtin_dll( LPCWSTR load_path, LPCWSTR path, HANDLE file,
1468 DWORD flags, WINE_MODREF** pwm )
1469 {
1470 char error[256], dllname[MAX_PATH];
1471 const WCHAR *name, *p;
1472 DWORD len, i;
1473 void *handle = NULL;
1474 struct builtin_load_info info, *prev_info;
1475
1476 /* Fix the name in case we have a full path and extension */
1477 name = path;
1478 if ((p = strrchrW( name, '\\' ))) name = p + 1;
1479 if ((p = strrchrW( name, '/' ))) name = p + 1;
1480
1481 /* load_library will modify info.status. Note also that load_library can be
1482 * called several times, if the .so file we're loading has dependencies.
1483 * info.status will gather all the errors we may get while loading all these
1484 * libraries
1485 */
1486 info.load_path = load_path;
1487 info.filename = NULL;
1488 info.status = STATUS_SUCCESS;
1489 info.wm = NULL;
1490
1491 if (file) /* we have a real file, try to load it */
1492 {
1493 UNICODE_STRING nt_name;
1494 ANSI_STRING unix_name;
1495
1496 TRACE("Trying built-in %s\n", debugstr_w(path));
1497
1498 if (!RtlDosPathNameToNtPathName_U( path, &nt_name, NULL, NULL ))
1499 return STATUS_DLL_NOT_FOUND;
1500
1501 if (wine_nt_to_unix_file_name( &nt_name, &unix_name, FILE_OPEN, FALSE ))
1502 {
1503 RtlFreeUnicodeString( &nt_name );
1504 return STATUS_DLL_NOT_FOUND;
1505 }
1506 prev_info = builtin_load_info;
1507 info.filename = nt_name.Buffer + 4; /* skip \??\ */
1508 builtin_load_info = &info;
1509 handle = wine_dlopen( unix_name.Buffer, RTLD_NOW, error, sizeof(error) );
1510 builtin_load_info = prev_info;
1511 RtlFreeUnicodeString( &nt_name );
1512 RtlFreeHeap( GetProcessHeap(), 0, unix_name.Buffer );
1513 if (!handle)
1514 {
1515 WARN( "failed to load .so lib for builtin %s: %s\n", debugstr_w(path), error );
1516 return STATUS_INVALID_IMAGE_FORMAT;
1517 }
1518 }
1519 else
1520 {
1521 int file_exists;
1522
1523 TRACE("Trying built-in %s\n", debugstr_w(name));
1524
1525 /* we don't want to depend on the current codepage here */
1526 len = strlenW( name ) + 1;
1527 if (len >= sizeof(dllname)) return STATUS_NAME_TOO_LONG;
1528 for (i = 0; i < len; i++)
1529 {
1530 if (name[i] > 127) return STATUS_DLL_NOT_FOUND;
1531 dllname[i] = (char)name[i];
1532 if (dllname[i] >= 'A' && dllname[i] <= 'Z') dllname[i] += 'a' - 'A';
1533 }
1534
1535 prev_info = builtin_load_info;
1536 builtin_load_info = &info;
1537 handle = wine_dll_load( dllname, error, sizeof(error), &file_exists );
1538 builtin_load_info = prev_info;
1539 if (!handle)
1540 {
1541 if (!file_exists)
1542 {
1543 /* The file does not exist -> WARN() */
1544 WARN("cannot open .so lib for builtin %s: %s\n", debugstr_w(name), error);
1545 return STATUS_DLL_NOT_FOUND;
1546 }
1547 /* ERR() for all other errors (missing functions, ...) */
1548 ERR("failed to load .so lib for builtin %s: %s\n", debugstr_w(name), error );
1549 return STATUS_PROCEDURE_NOT_FOUND;
1550 }
1551 }
1552
1553 if (info.status != STATUS_SUCCESS)
1554 {
1555 wine_dll_unload( handle );
1556 return info.status;
1557 }
1558
1559 if (!info.wm)
1560 {
1561 PLIST_ENTRY mark, entry;
1562
1563 /* The constructor wasn't called, this means the .so is already
1564 * loaded under a different name. Try to find the wm for it. */
1565
1566 mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
1567 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
1568 {
1569 LDR_MODULE *mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
1570 if (mod->Flags & LDR_WINE_INTERNAL && mod->SectionHandle == handle)
1571 {
1572 info.wm = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
1573 TRACE( "Found already loaded module %s for builtin %s\n",
1574 debugstr_w(info.wm->ldr.FullDllName.Buffer), debugstr_w(path) );
1575 break;
1576 }
1577 }
1578 wine_dll_unload( handle ); /* release the libdl refcount */
1579 if (!info.wm) return STATUS_INVALID_IMAGE_FORMAT;
1580 if (info.wm->ldr.LoadCount != -1) info.wm->ldr.LoadCount++;
1581 }
1582 else
1583 {
1584 TRACE_(loaddll)( "Loaded module %s : builtin\n", debugstr_w(info.wm->ldr.FullDllName.Buffer) );
1585 info.wm->ldr.LoadCount = 1;
1586 info.wm->ldr.SectionHandle = handle;
1587 }
1588
1589 *pwm = info.wm;
1590 return STATUS_SUCCESS;
1591 }
1592
1593
1594 /***********************************************************************
1595 * find_dll_file
1596 *
1597 * Find the file (or already loaded module) for a given dll name.
1598 */
1599 static NTSTATUS find_dll_file( const WCHAR *load_path, const WCHAR *libname,
1600 WCHAR *filename, ULONG *size, WINE_MODREF **pwm, HANDLE *handle )
1601 {
1602 OBJECT_ATTRIBUTES attr;
1603 IO_STATUS_BLOCK io;
1604 UNICODE_STRING nt_name;
1605 WCHAR *file_part, *ext, *dllname;
1606 ULONG len;
1607
1608 /* first append .dll if needed */
1609
1610 dllname = NULL;
1611 if (!(ext = strrchrW( libname, '.')) || strchrW( ext, '/' ) || strchrW( ext, '\\'))
1612 {
1613 if (!(dllname = RtlAllocateHeap( GetProcessHeap(), 0,
1614 (strlenW(libname) * sizeof(WCHAR)) + sizeof(dllW) )))
1615 return STATUS_NO_MEMORY;
1616 strcpyW( dllname, libname );
1617 strcatW( dllname, dllW );
1618 libname = dllname;
1619 }
1620
1621 nt_name.Buffer = NULL;
1622
1623 if (!contains_path( libname ))
1624 {
1625 if ((*pwm = find_basename_module( libname )) != NULL) goto found;
1626 }
1627
1628 if (RtlDetermineDosPathNameType_U( libname ) == RELATIVE_PATH)
1629 {
1630 /* we need to search for it */
1631 len = RtlDosSearchPath_U( load_path, libname, NULL, *size, filename, &file_part );
1632 if (len)
1633 {
1634 if (len >= *size) goto overflow;
1635 if ((*pwm = find_fullname_module( filename )) != NULL) goto found;
1636
1637 if (!RtlDosPathNameToNtPathName_U( filename, &nt_name, NULL, NULL ))
1638 {
1639 RtlFreeHeap( GetProcessHeap(), 0, dllname );
1640 return STATUS_NO_MEMORY;
1641 }
1642 attr.Length = sizeof(attr);
1643 attr.RootDirectory = 0;
1644 attr.Attributes = OBJ_CASE_INSENSITIVE;
1645 attr.ObjectName = &nt_name;
1646 attr.SecurityDescriptor = NULL;
1647 attr.SecurityQualityOfService = NULL;
1648 if (NtOpenFile( handle, GENERIC_READ, &attr, &io, FILE_SHARE_READ|FILE_SHARE_DELETE, 0 )) *handle = 0;
1649 goto found;
1650 }
1651
1652 /* not found */
1653
1654 if (!contains_path( libname ))
1655 {
1656 /* if libname doesn't contain a path at all, we simply return the name as is,
1657 * to be loaded as builtin */
1658 len = strlenW(libname) * sizeof(WCHAR);
1659 if (len >= *size) goto overflow;
1660 strcpyW( filename, libname );
1661 goto found;
1662 }
1663 }
1664
1665 /* absolute path name, or relative path name but not found above */
1666
1667 if (!RtlDosPathNameToNtPathName_U( libname, &nt_name, &file_part, NULL ))
1668 {
1669 RtlFreeHeap( GetProcessHeap(), 0, dllname );
1670 return STATUS_NO_MEMORY;
1671 }
1672 len = nt_name.Length - 4*sizeof(WCHAR); /* for \??\ prefix */
1673 if (len >= *size) goto overflow;
1674 memcpy( filename, nt_name.Buffer + 4, len + sizeof(WCHAR) );
1675 if (!(*pwm = find_fullname_module( filename )))
1676 {
1677 attr.Length = sizeof(attr);
1678 attr.RootDirectory = 0;
1679 attr.Attributes = OBJ_CASE_INSENSITIVE;
1680 attr.ObjectName = &nt_name;
1681 attr.SecurityDescriptor = NULL;
1682 attr.SecurityQualityOfService = NULL;
1683 if (NtOpenFile( handle, GENERIC_READ, &attr, &io, FILE_SHARE_READ|FILE_SHARE_DELETE, 0 )) *handle = 0;
1684 }
1685 found:
1686 RtlFreeUnicodeString( &nt_name );
1687 RtlFreeHeap( GetProcessHeap(), 0, dllname );
1688 return STATUS_SUCCESS;
1689
1690 overflow:
1691 RtlFreeUnicodeString( &nt_name );
1692 RtlFreeHeap( GetProcessHeap(), 0, dllname );
1693 *size = len + sizeof(WCHAR);
1694 return STATUS_BUFFER_TOO_SMALL;
1695 }
1696
1697
1698 /***********************************************************************
1699 * load_dll (internal)
1700 *
1701 * Load a PE style module according to the load order.
1702 * The loader_section must be locked while calling this function.
1703 */
1704 static NTSTATUS load_dll( LPCWSTR load_path, LPCWSTR libname, DWORD flags, WINE_MODREF** pwm )
1705 {
1706 enum loadorder loadorder;
1707 WCHAR buffer[32];
1708 WCHAR *filename;
1709 ULONG size;
1710 WINE_MODREF *main_exe;
1711 HANDLE handle = 0;
1712 NTSTATUS nts;
1713
1714 TRACE( "looking for %s in %s\n", debugstr_w(libname), debugstr_w(load_path) );
1715
1716 filename = buffer;
1717 size = sizeof(buffer);
1718 for (;;)
1719 {
1720 nts = find_dll_file( load_path, libname, filename, &size, pwm, &handle );
1721 if (nts == STATUS_SUCCESS) break;
1722 if (filename != buffer) RtlFreeHeap( GetProcessHeap(), 0, filename );
1723 if (nts != STATUS_BUFFER_TOO_SMALL) return nts;
1724 /* grow the buffer and retry */
1725 if (!(filename = RtlAllocateHeap( GetProcessHeap(), 0, size ))) return STATUS_NO_MEMORY;
1726 }
1727
1728 if (*pwm) /* found already loaded module */
1729 {
1730 if ((*pwm)->ldr.LoadCount != -1) (*pwm)->ldr.LoadCount++;
1731
1732 if (!(flags & DONT_RESOLVE_DLL_REFERENCES)) fixup_imports( *pwm, load_path );
1733
1734 TRACE("Found loaded module %s for %s at %p, count=%d\n",
1735 debugstr_w((*pwm)->ldr.FullDllName.Buffer), debugstr_w(libname),
1736 (*pwm)->ldr.BaseAddress, (*pwm)->ldr.LoadCount);
1737 if (filename != buffer) RtlFreeHeap( GetProcessHeap(), 0, filename );
1738 return STATUS_SUCCESS;
1739 }
1740
1741 main_exe = get_modref( NtCurrentTeb()->Peb->ImageBaseAddress );
1742 loadorder = get_load_order( main_exe ? main_exe->ldr.BaseDllName.Buffer : NULL, filename );
1743
1744 switch(loadorder)
1745 {
1746 case LO_INVALID:
1747 nts = STATUS_NO_MEMORY;
1748 break;
1749 case LO_DISABLED:
1750 nts = STATUS_DLL_NOT_FOUND;
1751 break;
1752 case LO_NATIVE:
1753 case LO_NATIVE_BUILTIN:
1754 if (!handle) nts = STATUS_DLL_NOT_FOUND;
1755 else
1756 {
1757 nts = load_native_dll( load_path, filename, handle, flags, pwm );
1758 if (nts == STATUS_INVALID_FILE_FOR_SECTION)
1759 /* not in PE format, maybe it's a builtin */
1760 nts = load_builtin_dll( load_path, filename, handle, flags, pwm );
1761 }
1762 if (nts == STATUS_DLL_NOT_FOUND && loadorder == LO_NATIVE_BUILTIN)
1763 nts = load_builtin_dll( load_path, filename, 0, flags, pwm );
1764 break;
1765 case LO_BUILTIN:
1766 case LO_BUILTIN_NATIVE:
1767 case LO_DEFAULT: /* default is builtin,native */
1768 nts = load_builtin_dll( load_path, filename, handle, flags, pwm );
1769 if (!handle) break; /* nothing else we can try */
1770 /* file is not a builtin library, try without using the specified file */
1771 if (nts != STATUS_SUCCESS)
1772 nts = load_builtin_dll( load_path, filename, 0, flags, pwm );
1773 if (nts == STATUS_SUCCESS && loadorder == LO_DEFAULT &&
1774 !MODULE_InitDLL( *pwm, DLL_WINE_PREATTACH, NULL ))
1775 {
1776 /* stub-only dll, try native */
1777 TRACE( "%s pre-attach returned FALSE, preferring native\n", debugstr_w(filename) );
1778 LdrUnloadDll( (*pwm)->ldr.BaseAddress );
1779 nts = STATUS_DLL_NOT_FOUND;
1780 }
1781 if (nts == STATUS_DLL_NOT_FOUND && loadorder != LO_BUILTIN)
1782 nts = load_native_dll( load_path, filename, handle, flags, pwm );
1783 break;
1784 }
1785
1786 if (nts == STATUS_SUCCESS)
1787 {
1788 /* Initialize DLL just loaded */
1789 TRACE("Loaded module %s (%s) at %p\n", debugstr_w(filename),
1790 ((*pwm)->ldr.Flags & LDR_WINE_INTERNAL) ? "builtin" : "native",
1791 (*pwm)->ldr.BaseAddress);
1792 if (handle) NtClose( handle );
1793 if (filename != buffer) RtlFreeHeap( GetProcessHeap(), 0, filename );
1794 return nts;
1795 }
1796
1797 WARN("Failed to load module %s; status=%x\n", debugstr_w(libname), nts);
1798 if (handle) NtClose( handle );
1799 if (filename != buffer) RtlFreeHeap( GetProcessHeap(), 0, filename );
1800 return nts;
1801 }
1802
1803 /******************************************************************
1804 * LdrLoadDll (NTDLL.@)
1805 */
1806 NTSTATUS WINAPI LdrLoadDll(LPCWSTR path_name, DWORD flags,
1807 const UNICODE_STRING *libname, HMODULE* hModule)
1808 {
1809 WINE_MODREF *wm;
1810 NTSTATUS nts;
1811
1812 RtlEnterCriticalSection( &loader_section );
1813
1814 if (!path_name) path_name = NtCurrentTeb()->Peb->ProcessParameters->DllPath.Buffer;
1815 nts = load_dll( path_name, libname->Buffer, flags, &wm );
1816
1817 if (nts == STATUS_SUCCESS && !(wm->ldr.Flags & LDR_DONT_RESOLVE_REFS))
1818 {
1819 nts = process_attach( wm, NULL );
1820 if (nts != STATUS_SUCCESS)
1821 {
1822 LdrUnloadDll(wm->ldr.BaseAddress);
1823 wm = NULL;
1824 }
1825 }
1826 *hModule = (wm) ? wm->ldr.BaseAddress : NULL;
1827
1828 RtlLeaveCriticalSection( &loader_section );
1829 return nts;
1830 }
1831
1832 /******************************************************************
1833 * LdrQueryProcessModuleInformation
1834 *
1835 */
1836 NTSTATUS WINAPI LdrQueryProcessModuleInformation(PSYSTEM_MODULE_INFORMATION smi,
1837 ULONG buf_size, ULONG* req_size)
1838 {
1839 SYSTEM_MODULE* sm = &smi->Modules[0];
1840 ULONG size = sizeof(ULONG);
1841 NTSTATUS nts = STATUS_SUCCESS;
1842 ANSI_STRING str;
1843 char* ptr;
1844 PLIST_ENTRY mark, entry;
1845 PLDR_MODULE mod;
1846
1847 smi->ModulesCount = 0;
1848
1849 RtlEnterCriticalSection( &loader_section );
1850 mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
1851 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
1852 {
1853 mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
1854 size += sizeof(*sm);
1855 if (size <= buf_size)
1856 {
1857 sm->Reserved1 = 0; /* FIXME */
1858 sm->Reserved2 = 0; /* FIXME */
1859 sm->ImageBaseAddress = mod->BaseAddress;
1860 sm->ImageSize = mod->SizeOfImage;
1861 sm->Flags = mod->Flags;
1862 sm->Id = 0; /* FIXME */
1863 sm->Rank = 0; /* FIXME */
1864 sm->Unknown = 0; /* FIXME */
1865 str.Length = 0;
1866 str.MaximumLength = MAXIMUM_FILENAME_LENGTH;
1867 str.Buffer = (char*)sm->Name;
1868 RtlUnicodeStringToAnsiString(&str, &mod->FullDllName, FALSE);
1869 ptr = strrchr(str.Buffer, '\\');
1870 sm->NameOffset = (ptr != NULL) ? (ptr - str.Buffer + 1) : 0;
1871
1872 smi->ModulesCount++;
1873 sm++;
1874 }
1875 else nts = STATUS_INFO_LENGTH_MISMATCH;
1876 }
1877 RtlLeaveCriticalSection( &loader_section );
1878
1879 if (req_size) *req_size = size;
1880
1881 return nts;
1882 }
1883
1884
1885 /******************************************************************
1886 * RtlDllShutdownInProgress (NTDLL.@)
1887 */
1888 BOOLEAN WINAPI RtlDllShutdownInProgress(void)
1889 {
1890 return process_detaching;
1891 }
1892
1893
1894 /******************************************************************
1895 * LdrShutdownProcess (NTDLL.@)
1896 *
1897 */
1898 void WINAPI LdrShutdownProcess(void)
1899 {
1900 TRACE("()\n");
1901 process_detach( TRUE, (LPVOID)1 );
1902 }
1903
1904 /******************************************************************
1905 * LdrShutdownThread (NTDLL.@)
1906 *
1907 */
1908 void WINAPI LdrShutdownThread(void)
1909 {
1910 PLIST_ENTRY mark, entry;
1911 PLDR_MODULE mod;
1912
1913 TRACE("()\n");
1914
1915 /* don't do any detach calls if process is exiting */
1916 if (process_detaching) return;
1917 /* FIXME: there is still a race here */
1918
1919 RtlEnterCriticalSection( &loader_section );
1920
1921 mark = &NtCurrentTeb()->Peb->LdrData->InInitializationOrderModuleList;
1922 for (entry = mark->Blink; entry != mark; entry = entry->Blink)
1923 {
1924 mod = CONTAINING_RECORD(entry, LDR_MODULE,
1925 InInitializationOrderModuleList);
1926 if ( !(mod->Flags & LDR_PROCESS_ATTACHED) )
1927 continue;
1928 if ( mod->Flags & LDR_NO_DLL_CALLS )
1929 continue;
1930
1931 MODULE_InitDLL( CONTAINING_RECORD(mod, WINE_MODREF, ldr),
1932 DLL_THREAD_DETACH, NULL );
1933 }
1934
1935 RtlLeaveCriticalSection( &loader_section );
1936 RtlFreeHeap( GetProcessHeap(), 0, NtCurrentTeb()->ThreadLocalStoragePointer );
1937 }
1938
1939
1940 /***********************************************************************
1941 * free_modref
1942 *
1943 */
1944 static void free_modref( WINE_MODREF *wm )
1945 {
1946 RemoveEntryList(&wm->ldr.InLoadOrderModuleList);
1947 RemoveEntryList(&wm->ldr.InMemoryOrderModuleList);
1948 if (wm->ldr.InInitializationOrderModuleList.Flink)
1949 RemoveEntryList(&wm->ldr.InInitializationOrderModuleList);
1950
1951 TRACE(" unloading %s\n", debugstr_w(wm->ldr.FullDllName.Buffer));
1952 if (!TRACE_ON(module))
1953 TRACE_(loaddll)("Unloaded module %s : %s\n",
1954 debugstr_w(wm->ldr.FullDllName.Buffer),
1955 (wm->ldr.Flags & LDR_WINE_INTERNAL) ? "builtin" : "native" );
1956
1957 SERVER_START_REQ( unload_dll )
1958 {
1959 req->base = wm->ldr.BaseAddress;
1960 wine_server_call( req );
1961 }
1962 SERVER_END_REQ;
1963
1964 NtUnmapViewOfSection( NtCurrentProcess(), wm->ldr.BaseAddress );
1965 if (wm->ldr.Flags & LDR_WINE_INTERNAL) wine_dll_unload( wm->ldr.SectionHandle );
1966 if (cached_modref == wm) cached_modref = NULL;
1967 RtlFreeUnicodeString( &wm->ldr.FullDllName );
1968 RtlFreeHeap( GetProcessHeap(), 0, wm->deps );
1969 RtlFreeHeap( GetProcessHeap(), 0, wm );
1970 }
1971
1972 /***********************************************************************
1973 * MODULE_FlushModrefs
1974 *
1975 * Remove all unused modrefs and call the internal unloading routines
1976 * for the library type.
1977 *
1978 * The loader_section must be locked while calling this function.
1979 */
1980 static void MODULE_FlushModrefs(void)
1981 {
1982 PLIST_ENTRY mark, entry, prev;
1983 PLDR_MODULE mod;
1984 WINE_MODREF*wm;
1985
1986 mark = &NtCurrentTeb()->Peb->LdrData->InInitializationOrderModuleList;
1987 for (entry = mark->Blink; entry != mark; entry = prev)
1988 {
1989 mod = CONTAINING_RECORD(entry, LDR_MODULE, InInitializationOrderModuleList);
1990 wm = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
1991 prev = entry->Blink;
1992 if (!mod->LoadCount) free_modref( wm );
1993 }
1994
1995 /* check load order list too for modules that haven't been initialized yet */
1996 mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
1997 for (entry = mark->Blink; entry != mark; entry = prev)
1998 {
1999 mod = CONTAINING_RECORD(entry, LDR_MODULE, InLoadOrderModuleList);
2000 wm = CONTAINING_RECORD(mod, WINE_MODREF, ldr);
2001 prev = entry->Blink;
2002 if (!mod->LoadCount) free_modref( wm );
2003 }
2004 }
2005
2006 /***********************************************************************
2007 * MODULE_DecRefCount
2008 *
2009 * The loader_section must be locked while calling this function.
2010 */
2011 static void MODULE_DecRefCount( WINE_MODREF *wm )
2012 {
2013 int i;
2014
2015 if ( wm->ldr.Flags & LDR_UNLOAD_IN_PROGRESS )
2016 return;
2017
2018 if ( wm->ldr.LoadCount <= 0 )
2019 return;
2020
2021 --wm->ldr.LoadCount;
2022 TRACE("(%s) ldr.LoadCount: %d\n", debugstr_w(wm->ldr.BaseDllName.Buffer), wm->ldr.LoadCount );
2023
2024 if ( wm->ldr.LoadCount == 0 )
2025 {
2026 wm->ldr.Flags |= LDR_UNLOAD_IN_PROGRESS;
2027
2028 for ( i = 0; i < wm->nDeps; i++ )
2029 if ( wm->deps[i] )
2030 MODULE_DecRefCount( wm->deps[i] );
2031
2032 wm->ldr.Flags &= ~LDR_UNLOAD_IN_PROGRESS;
2033 }
2034 }
2035
2036 /******************************************************************
2037 * LdrUnloadDll (NTDLL.@)
2038 *
2039 *
2040 */
2041 NTSTATUS WINAPI LdrUnloadDll( HMODULE hModule )
2042 {
2043 NTSTATUS retv = STATUS_SUCCESS;
2044
2045 TRACE("(%p)\n", hModule);
2046
2047 RtlEnterCriticalSection( &loader_section );
2048
2049 /* if we're stopping the whole process (and forcing the removal of all
2050 * DLLs) the library will be freed anyway
2051 */
2052 if (!process_detaching)
2053 {
2054 WINE_MODREF *wm;
2055
2056 free_lib_count++;
2057 if ((wm = get_modref( hModule )) != NULL)
2058 {
2059 TRACE("(%s) - START\n", debugstr_w(wm->ldr.BaseDllName.Buffer));
2060
2061 /* Recursively decrement reference counts */
2062 MODULE_DecRefCount( wm );
2063
2064 /* Call process detach notifications */
2065 if ( free_lib_count <= 1 )
2066 {
2067 process_detach( FALSE, NULL );
2068 MODULE_FlushModrefs();
2069 }
2070
2071 TRACE("END\n");
2072 }
2073 else
2074 retv = STATUS_DLL_NOT_FOUND;
2075
2076 free_lib_count--;
2077 }
2078
2079 RtlLeaveCriticalSection( &loader_section );
2080
2081 return retv;
2082 }
2083
2084 /***********************************************************************
2085 * RtlImageNtHeader (NTDLL.@)
2086 */
2087 PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE hModule)
2088 {
2089 IMAGE_NT_HEADERS *ret;
2090
2091 __TRY
2092 {
2093 IMAGE_DOS_HEADER *dos = (IMAGE_DOS_HEADER *)hModule;
2094
2095 ret = NULL;
2096 if (dos->e_magic == IMAGE_DOS_SIGNATURE)
2097 {
2098 ret = (IMAGE_NT_HEADERS *)((char *)dos + dos->e_lfanew);
2099 if (ret->Signature != IMAGE_NT_SIGNATURE) ret = NULL;
2100 }
2101 }
2102 __EXCEPT_PAGE_FAULT
2103 {
2104 return NULL;
2105 }
2106 __ENDTRY
2107 return ret;
2108 }
2109
2110
2111 /******************************************************************
2112 * LdrInitializeThunk (NTDLL.@)
2113 *
2114 */
2115 void WINAPI LdrInitializeThunk( ULONG unknown1, ULONG unknown2, ULONG unknown3, ULONG unknown4 )
2116 {
2117 NTSTATUS status;
2118 WINE_MODREF *wm;
2119 LPCWSTR load_path;
2120 PEB *peb = NtCurrentTeb()->Peb;
2121 IMAGE_NT_HEADERS *nt = RtlImageNtHeader( peb->ImageBaseAddress );
2122
2123 if (main_exe_file) NtClose( main_exe_file ); /* at this point the main module is created */
2124
2125 /* allocate the modref for the main exe (if not already done) */
2126 wm = get_modref( peb->ImageBaseAddress );
2127 assert( wm );
2128 if (wm->ldr.Flags & LDR_IMAGE_IS_DLL)
2129 {
2130 ERR("%s is a dll, not an executable\n", debugstr_w(wm->ldr.FullDllName.Buffer) );
2131 exit(1);
2132 }
2133 wm->ldr.LoadCount = -1; /* can't unload main exe */
2134
2135 peb->ProcessParameters->ImagePathName = wm->ldr.FullDllName;
2136 version_init( wm->ldr.FullDllName.Buffer );
2137
2138 /* the main exe needs to be the first in the load order list */
2139 RemoveEntryList( &wm->ldr.InLoadOrderModuleList );
2140 InsertHeadList( &peb->LdrData->InLoadOrderModuleList, &wm->ldr.InLoadOrderModuleList );
2141
2142 status = server_init_process_done();
2143 if (status != STATUS_SUCCESS) goto error;
2144
2145 RtlEnterCriticalSection( &loader_section );
2146
2147 load_path = NtCurrentTeb()->Peb->ProcessParameters->DllPath.Buffer;
2148 if ((status = fixup_imports( wm, load_path )) != STATUS_SUCCESS) goto error;
2149 if ((status = alloc_process_tls()) != STATUS_SUCCESS) goto error;
2150 if ((status = alloc_thread_tls()) != STATUS_SUCCESS) goto error;
2151 if ((status = process_attach( wm, (LPVOID)1 )) != STATUS_SUCCESS)
2152 {
2153 if (last_failed_modref)
2154 ERR( "%s failed to initialize, aborting\n", debugstr_w(last_failed_modref->ldr.BaseDllName.Buffer) + 1 );
2155 goto error;
2156 }
2157 attach_implicitly_loaded_dlls( (LPVOID)1 );
2158
2159 RtlLeaveCriticalSection( &loader_section );
2160
2161 if (nt->FileHeader.Characteristics & IMAGE_FILE_LARGE_ADDRESS_AWARE) VIRTUAL_UseLargeAddressSpace();
2162 return;
2163
2164 error:
2165 ERR( "Main exe initialization for %s failed, status %x\n",
2166 debugstr_w(peb->ProcessParameters->ImagePathName.Buffer), status );
2167 exit(1);
2168 }
2169
2170
2171 /***********************************************************************
2172 * RtlImageDirectoryEntryToData (NTDLL.@)
2173 */
2174 PVOID WINAPI RtlImageDirectoryEntryToData( HMODULE module, BOOL image, WORD dir, ULONG *size )
2175 {
2176 const IMAGE_NT_HEADERS *nt;
2177 DWORD addr;
2178
2179 if ((ULONG_PTR)module & 1) /* mapped as data file */
2180 {
2181 module = (HMODULE)((ULONG_PTR)module & ~1);
2182 image = FALSE;
2183 }
2184 if (!(nt = RtlImageNtHeader( module ))) return NULL;
2185 if (dir >= nt->OptionalHeader.NumberOfRvaAndSizes) return NULL;
2186 if (!(addr = nt->OptionalHeader.DataDirectory[dir].VirtualAddress)) return NULL;
2187 *size = nt->OptionalHeader.DataDirectory[dir].Size;
2188 if (image || addr < nt->OptionalHeader.SizeOfHeaders) return (char *)module + addr;
2189
2190 /* not mapped as image, need to find the section containing the virtual address */
2191 return RtlImageRvaToVa( nt, module, addr, NULL );
2192 }
2193
2194
2195 /***********************************************************************
2196 * RtlImageRvaToSection (NTDLL.@)
2197 */
2198 PIMAGE_SECTION_HEADER WINAPI RtlImageRvaToSection( const IMAGE_NT_HEADERS *nt,
2199 HMODULE module, DWORD rva )
2200 {
2201 int i;
2202 const IMAGE_SECTION_HEADER *sec;
2203
2204 sec = (const IMAGE_SECTION_HEADER*)((const char*)&nt->OptionalHeader +
2205 nt->FileHeader.SizeOfOptionalHeader);
2206 for (i = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
2207 {
2208 if ((sec->VirtualAddress <= rva) && (sec->VirtualAddress + sec->SizeOfRawData > rva))
2209 return (PIMAGE_SECTION_HEADER)sec;
2210 }
2211 return NULL;
2212 }
2213
2214
2215 /***********************************************************************
2216 * RtlImageRvaToVa (NTDLL.@)
2217 */
2218 PVOID WINAPI RtlImageRvaToVa( const IMAGE_NT_HEADERS *nt, HMODULE module,
2219 DWORD rva, IMAGE_SECTION_HEADER **section )
2220 {
2221 IMAGE_SECTION_HEADER *sec;
2222
2223 if (section && *section) /* try this section first */
2224 {
2225 sec = *section;
2226 if ((sec->VirtualAddress <= rva) && (sec->VirtualAddress + sec->SizeOfRawData > rva))
2227 goto found;
2228 }
2229 if (!(sec = RtlImageRvaToSection( nt, module, rva ))) return NULL;
2230 found:
2231 if (section) *section = sec;
2232 return (char *)module + sec->PointerToRawData + (rva - sec->VirtualAddress);
2233 }
2234
2235
2236 /***********************************************************************
2237 * RtlPcToFileHeader (NTDLL.@)
2238 */
2239 PVOID WINAPI RtlPcToFileHeader( PVOID pc, PVOID *address )
2240 {
2241 LDR_MODULE *module;
2242 PVOID ret = NULL;
2243
2244 RtlEnterCriticalSection( &loader_section );
2245 if (!LdrFindEntryForAddress( pc, &module )) ret = module->BaseAddress;
2246 RtlLeaveCriticalSection( &loader_section );
2247 *address = ret;
2248 return ret;
2249 }
2250
2251
2252 /***********************************************************************
2253 * NtLoadDriver (NTDLL.@)
2254 * ZwLoadDriver (NTDLL.@)
2255 */
2256 NTSTATUS WINAPI NtLoadDriver( const UNICODE_STRING *DriverServiceName )
2257 {
2258 FIXME("(%p), stub!\n",DriverServiceName);
2259 return STATUS_NOT_IMPLEMENTED;
2260 }
2261
2262
2263 /***********************************************************************
2264 * NtUnloadDriver (NTDLL.@)
2265 * ZwUnloadDriver (NTDLL.@)
2266 */
2267 NTSTATUS WINAPI NtUnloadDriver( const UNICODE_STRING *DriverServiceName )
2268 {
2269 FIXME("(%p), stub!\n",DriverServiceName);
2270 return STATUS_NOT_IMPLEMENTED;
2271 }
2272
2273
2274 /******************************************************************
2275 * DllMain (NTDLL.@)
2276 */
2277 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
2278 {
2279 if (reason == DLL_PROCESS_ATTACH) LdrDisableThreadCalloutsForDll( inst );
2280 return TRUE;
2281 }
2282
2283
2284 /******************************************************************
2285 * __wine_init_windows_dir (NTDLL.@)
2286 *
2287 * Windows and system dir initialization once kernel32 has been loaded.
2288 */
2289 void __wine_init_windows_dir( const WCHAR *windir, const WCHAR *sysdir )
2290 {
2291 PLIST_ENTRY mark, entry;
2292 LPWSTR buffer, p;
2293
2294 RtlCreateUnicodeString( &system_dir, sysdir );
2295
2296 /* prepend the system dir to the name of the already created modules */
2297 mark = &NtCurrentTeb()->Peb->LdrData->InLoadOrderModuleList;
2298 for (entry = mark->Flink; entry != mark; entry = entry->Flink)
2299 {
2300 LDR_MODULE *mod = CONTAINING_RECORD( entry, LDR_MODULE, InLoadOrderModuleList );
2301
2302 assert( mod->Flags & LDR_WINE_INTERNAL );
2303
2304 buffer = RtlAllocateHeap( GetProcessHeap(), 0,
2305 system_dir.Length + mod->FullDllName.Length + 2*sizeof(WCHAR) );
2306 if (!buffer) continue;
2307 strcpyW( buffer, system_dir.Buffer );
2308 p = buffer + strlenW( buffer );
2309 if (p > buffer && p[-1] != '\\') *p++ = '\\';
2310 strcpyW( p, mod->FullDllName.Buffer );
2311 RtlInitUnicodeString( &mod->FullDllName, buffer );
2312 RtlInitUnicodeString( &mod->BaseDllName, p );
2313 }
2314 }
2315
2316
2317 /***********************************************************************
2318 * __wine_process_init
2319 */
2320 void __wine_process_init(void)
2321 {
2322 static const WCHAR kernel32W[] = {'k','e','r','n','e','l','3','2','.','d','l','l',0};
2323
2324 WINE_MODREF *wm;
2325 NTSTATUS status;
2326 ANSI_STRING func_name;
2327 void (* DECLSPEC_NORETURN init_func)(void);
2328 extern mode_t FILE_umask;
2329
2330 main_exe_file = thread_init();
2331
2332 /* retrieve current umask */
2333 FILE_umask = umask(0777);
2334 umask( FILE_umask );
2335
2336 /* setup the load callback and create ntdll modref */
2337 wine_dll_set_callback( load_builtin_callback );
2338
2339 if ((status = load_builtin_dll( NULL, kernel32W, 0, 0, &wm )) != STATUS_SUCCESS)
2340 {
2341 MESSAGE( "wine: could not load kernel32.dll, status %x\n", status );
2342 exit(1);
2343 }
2344 RtlInitAnsiString( &func_name, "__wine_kernel_init" );
2345 if ((status = LdrGetProcedureAddress( wm->ldr.BaseAddress, &func_name,
2346 0, (void **)&init_func )) != STATUS_SUCCESS)
2347 {
2348 MESSAGE( "wine: could not find __wine_kernel_init in kernel32.dll, status %x\n", status );
2349 exit(1);
2350 }
2351 init_func();
2352 }
Quick hack tree for wine patches julliard doesn't want to commit