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