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