1 /*
2 * Modules
3 *
4 * Copyright 1995 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <fcntl.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <sys/types.h>
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32 #include "ntstatus.h"
33 #define WIN32_NO_STATUS
34 #include "wine/winbase16.h"
35 #include "winerror.h"
36 #include "windef.h"
37 #include "winbase.h"
38 #include "winternl.h"
39 #include "kernel_private.h"
40
41 #include "wine/exception.h"
42 #include "wine/debug.h"
43 #include "wine/unicode.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(module);
46
47 static WCHAR *dll_directory; /* extra path for SetDllDirectoryW */
48
49 static CRITICAL_SECTION dlldir_section;
50 static CRITICAL_SECTION_DEBUG critsect_debug =
51 {
52 0, 0, &dlldir_section,
53 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
54 0, 0, { (DWORD_PTR)(__FILE__ ": dlldir_section") }
55 };
56 static CRITICAL_SECTION dlldir_section = { &critsect_debug, -1, 0, 0, 0, 0 };
57
58
59 /****************************************************************************
60 * GetDllDirectoryA (KERNEL32.@)
61 */
62 DWORD WINAPI GetDllDirectoryA( DWORD buf_len, LPSTR buffer )
63 {
64 DWORD len;
65
66 RtlEnterCriticalSection( &dlldir_section );
67 len = dll_directory ? FILE_name_WtoA( dll_directory, strlenW(dll_directory), NULL, 0 ) : 0;
68 if (buffer && buf_len > len)
69 {
70 if (dll_directory) FILE_name_WtoA( dll_directory, -1, buffer, buf_len );
71 else *buffer = 0;
72 }
73 else
74 {
75 len++; /* for terminating null */
76 if (buffer) *buffer = 0;
77 }
78 RtlLeaveCriticalSection( &dlldir_section );
79 return len;
80 }
81
82
83 /****************************************************************************
84 * GetDllDirectoryW (KERNEL32.@)
85 */
86 DWORD WINAPI GetDllDirectoryW( DWORD buf_len, LPWSTR buffer )
87 {
88 DWORD len;
89
90 RtlEnterCriticalSection( &dlldir_section );
91 len = dll_directory ? strlenW( dll_directory ) : 0;
92 if (buffer && buf_len > len)
93 {
94 if (dll_directory) memcpy( buffer, dll_directory, (len + 1) * sizeof(WCHAR) );
95 else *buffer = 0;
96 }
97 else
98 {
99 len++; /* for terminating null */
100 if (buffer) *buffer = 0;
101 }
102 RtlLeaveCriticalSection( &dlldir_section );
103 return len;
104 }
105
106
107 /****************************************************************************
108 * SetDllDirectoryA (KERNEL32.@)
109 */
110 BOOL WINAPI SetDllDirectoryA( LPCSTR dir )
111 {
112 WCHAR *dirW;
113 BOOL ret;
114
115 if (!(dirW = FILE_name_AtoW( dir, TRUE ))) return FALSE;
116 ret = SetDllDirectoryW( dirW );
117 HeapFree( GetProcessHeap(), 0, dirW );
118 return ret;
119 }
120
121
122 /****************************************************************************
123 * SetDllDirectoryW (KERNEL32.@)
124 */
125 BOOL WINAPI SetDllDirectoryW( LPCWSTR dir )
126 {
127 WCHAR *newdir = NULL;
128
129 if (dir)
130 {
131 DWORD len = (strlenW(dir) + 1) * sizeof(WCHAR);
132 if (!(newdir = HeapAlloc( GetProcessHeap(), 0, len )))
133 {
134 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
135 return FALSE;
136 }
137 memcpy( newdir, dir, len );
138 }
139
140 RtlEnterCriticalSection( &dlldir_section );
141 HeapFree( GetProcessHeap(), 0, dll_directory );
142 dll_directory = newdir;
143 RtlLeaveCriticalSection( &dlldir_section );
144 return TRUE;
145 }
146
147
148 /****************************************************************************
149 * DisableThreadLibraryCalls (KERNEL32.@)
150 *
151 * Inform the module loader that thread notifications are not required for a dll.
152 *
153 * PARAMS
154 * hModule [I] Module handle to skip calls for
155 *
156 * RETURNS
157 * Success: TRUE. Thread attach and detach notifications will not be sent
158 * to hModule.
159 * Failure: FALSE. Use GetLastError() to determine the cause.
160 *
161 * NOTES
162 * This is typically called from the dll entry point of a dll during process
163 * attachment, for dlls that do not need to process thread notifications.
164 */
165 BOOL WINAPI DisableThreadLibraryCalls( HMODULE hModule )
166 {
167 NTSTATUS nts = LdrDisableThreadCalloutsForDll( hModule );
168 if (nts == STATUS_SUCCESS) return TRUE;
169
170 SetLastError( RtlNtStatusToDosError( nts ) );
171 return FALSE;
172 }
173
174
175 /* Check whether a file is an OS/2 or a very old Windows executable
176 * by testing on import of KERNEL.
177 *
178 * FIXME: is reading the module imports the only way of discerning
179 * old Windows binaries from OS/2 ones ? At least it seems so...
180 */
181 static enum binary_type MODULE_Decide_OS2_OldWin(HANDLE hfile, const IMAGE_DOS_HEADER *mz,
182 const IMAGE_OS2_HEADER *ne)
183 {
184 DWORD currpos = SetFilePointer( hfile, 0, NULL, SEEK_CUR);
185 enum binary_type ret = BINARY_OS216;
186 LPWORD modtab = NULL;
187 LPSTR nametab = NULL;
188 DWORD len;
189 int i;
190
191 /* read modref table */
192 if ( (SetFilePointer( hfile, mz->e_lfanew + ne->ne_modtab, NULL, SEEK_SET ) == -1)
193 || (!(modtab = HeapAlloc( GetProcessHeap(), 0, ne->ne_cmod*sizeof(WORD))))
194 || (!(ReadFile(hfile, modtab, ne->ne_cmod*sizeof(WORD), &len, NULL)))
195 || (len != ne->ne_cmod*sizeof(WORD)) )
196 goto broken;
197
198 /* read imported names table */
199 if ( (SetFilePointer( hfile, mz->e_lfanew + ne->ne_imptab, NULL, SEEK_SET ) == -1)
200 || (!(nametab = HeapAlloc( GetProcessHeap(), 0, ne->ne_enttab - ne->ne_imptab)))
201 || (!(ReadFile(hfile, nametab, ne->ne_enttab - ne->ne_imptab, &len, NULL)))
202 || (len != ne->ne_enttab - ne->ne_imptab) )
203 goto broken;
204
205 for (i=0; i < ne->ne_cmod; i++)
206 {
207 LPSTR module = &nametab[modtab[i]];
208 TRACE("modref: %.*s\n", module[0], &module[1]);
209 if (!(strncmp(&module[1], "KERNEL", module[0])))
210 { /* very old Windows file */
211 MESSAGE("This seems to be a very old (pre-3.0) Windows executable. Expect crashes, especially if this is a real-mode binary !\n");
212 ret = BINARY_WIN16;
213 goto good;
214 }
215 }
216
217 broken:
218 ERR("Hmm, an error occurred. Is this binary file broken?\n");
219
220 good:
221 HeapFree( GetProcessHeap(), 0, modtab);
222 HeapFree( GetProcessHeap(), 0, nametab);
223 SetFilePointer( hfile, currpos, NULL, SEEK_SET); /* restore filepos */
224 return ret;
225 }
226
227 /***********************************************************************
228 * MODULE_GetBinaryType
229 */
230 enum binary_type MODULE_GetBinaryType( HANDLE hfile, void **res_start, void **res_end )
231 {
232 union
233 {
234 struct
235 {
236 unsigned char magic[4];
237 unsigned char ignored[12];
238 unsigned short type;
239 } elf;
240 struct
241 {
242 unsigned long magic;
243 unsigned long cputype;
244 unsigned long cpusubtype;
245 unsigned long filetype;
246 } macho;
247 IMAGE_DOS_HEADER mz;
248 } header;
249
250 DWORD len;
251
252 /* Seek to the start of the file and read the header information. */
253 if (SetFilePointer( hfile, 0, NULL, SEEK_SET ) == -1)
254 return BINARY_UNKNOWN;
255 if (!ReadFile( hfile, &header, sizeof(header), &len, NULL ) || len != sizeof(header))
256 return BINARY_UNKNOWN;
257
258 if (!memcmp( header.elf.magic, "\177ELF", 4 ))
259 {
260 /* FIXME: we don't bother to check byte order, architecture, etc. */
261 switch(header.elf.type)
262 {
263 case 2: return BINARY_UNIX_EXE;
264 case 3: return BINARY_UNIX_LIB;
265 }
266 return BINARY_UNKNOWN;
267 }
268
269 /* Mach-o File with Endian set to Big Endian or Little Endian */
270 if (header.macho.magic == 0xfeedface || header.macho.magic == 0xcefaedfe)
271 {
272 switch(header.macho.filetype)
273 {
274 case 0x8: /* MH_BUNDLE */ return BINARY_UNIX_LIB;
275 }
276 return BINARY_UNKNOWN;
277 }
278
279 /* Not ELF, try DOS */
280
281 if (header.mz.e_magic == IMAGE_DOS_SIGNATURE)
282 {
283 union
284 {
285 IMAGE_OS2_HEADER os2;
286 IMAGE_NT_HEADERS nt;
287 } ext_header;
288
289 /* We do have a DOS image so we will now try to seek into
290 * the file by the amount indicated by the field
291 * "Offset to extended header" and read in the
292 * "magic" field information at that location.
293 * This will tell us if there is more header information
294 * to read or not.
295 */
296 if (SetFilePointer( hfile, header.mz.e_lfanew, NULL, SEEK_SET ) == -1)
297 return BINARY_DOS;
298 if (!ReadFile( hfile, &ext_header, sizeof(ext_header), &len, NULL ) || len < 4)
299 return BINARY_DOS;
300
301 /* Reading the magic field succeeded so
302 * we will try to determine what type it is.
303 */
304 if (!memcmp( &ext_header.nt.Signature, "PE\0\0", 4 ))
305 {
306 if (len >= sizeof(ext_header.nt.FileHeader))
307 {
308 if (len < sizeof(ext_header.nt)) /* clear remaining part of header if missing */
309 memset( (char *)&ext_header.nt + len, 0, sizeof(ext_header.nt) - len );
310 if (res_start) *res_start = (void *)ext_header.nt.OptionalHeader.ImageBase;
311 if (res_end) *res_end = (void *)(ext_header.nt.OptionalHeader.ImageBase +
312 ext_header.nt.OptionalHeader.SizeOfImage);
313 if (ext_header.nt.FileHeader.Characteristics & IMAGE_FILE_DLL) return BINARY_PE_DLL;
314 return BINARY_PE_EXE;
315 }
316 return BINARY_DOS;
317 }
318
319 if (!memcmp( &ext_header.os2.ne_magic, "NE", 2 ))
320 {
321 /* This is a Windows executable (NE) header. This can
322 * mean either a 16-bit OS/2 or a 16-bit Windows or even a
323 * DOS program (running under a DOS extender). To decide
324 * which, we'll have to read the NE header.
325 */
326 if (len >= sizeof(ext_header.os2))
327 {
328 switch ( ext_header.os2.ne_exetyp )
329 {
330 case 1: return BINARY_OS216; /* OS/2 */
331 case 2: return BINARY_WIN16; /* Windows */
332 case 3: return BINARY_DOS; /* European MS-DOS 4.x */
333 case 4: return BINARY_WIN16; /* Windows 386; FIXME: is this 32bit??? */
334 case 5: return BINARY_DOS; /* BOSS, Borland Operating System Services */
335 /* other types, e.g. 0 is: "unknown" */
336 default: return MODULE_Decide_OS2_OldWin(hfile, &header.mz, &ext_header.os2);
337 }
338 }
339 /* Couldn't read header, so abort. */
340 return BINARY_DOS;
341 }
342
343 /* Unknown extended header, but this file is nonetheless DOS-executable. */
344 return BINARY_DOS;
345 }
346
347 return BINARY_UNKNOWN;
348 }
349
350 /***********************************************************************
351 * GetBinaryTypeW [KERNEL32.@]
352 *
353 * Determine whether a file is executable, and if so, what kind.
354 *
355 * PARAMS
356 * lpApplicationName [I] Path of the file to check
357 * lpBinaryType [O] Destination for the binary type
358 *
359 * RETURNS
360 * TRUE, if the file is an executable, in which case lpBinaryType is set.
361 * FALSE, if the file is not an executable or if the function fails.
362 *
363 * NOTES
364 * The type of executable is a property that determines which subsystem an
365 * executable file runs under. lpBinaryType can be set to one of the following
366 * values:
367 * SCS_32BIT_BINARY: A Win32 based application
368 * SCS_DOS_BINARY: An MS-Dos based application
369 * SCS_WOW_BINARY: A Win16 based application
370 * SCS_PIF_BINARY: A PIF file that executes an MS-Dos based app
371 * SCS_POSIX_BINARY: A POSIX based application ( Not implemented )
372 * SCS_OS216_BINARY: A 16bit OS/2 based application
373 *
374 * To find the binary type, this function reads in the files header information.
375 * If extended header information is not present it will assume that the file
376 * is a DOS executable. If extended header information is present it will
377 * determine if the file is a 16 or 32 bit Windows executable by checking the
378 * flags in the header.
379 *
380 * ".com" and ".pif" files are only recognized by their file name extension,
381 * as per native Windows.
382 */
383 BOOL WINAPI GetBinaryTypeW( LPCWSTR lpApplicationName, LPDWORD lpBinaryType )
384 {
385 BOOL ret = FALSE;
386 HANDLE hfile;
387
388 TRACE("%s\n", debugstr_w(lpApplicationName) );
389
390 /* Sanity check.
391 */
392 if ( lpApplicationName == NULL || lpBinaryType == NULL )
393 return FALSE;
394
395 /* Open the file indicated by lpApplicationName for reading.
396 */
397 hfile = CreateFileW( lpApplicationName, GENERIC_READ, FILE_SHARE_READ,
398 NULL, OPEN_EXISTING, 0, 0 );
399 if ( hfile == INVALID_HANDLE_VALUE )
400 return FALSE;
401
402 /* Check binary type
403 */
404 switch(MODULE_GetBinaryType( hfile, NULL, NULL ))
405 {
406 case BINARY_UNKNOWN:
407 {
408 static const WCHAR comW[] = { '.','C','O','M',0 };
409 static const WCHAR pifW[] = { '.','P','I','F',0 };
410 const WCHAR *ptr;
411
412 /* try to determine from file name */
413 ptr = strrchrW( lpApplicationName, '.' );
414 if (!ptr) break;
415 if (!strcmpiW( ptr, comW ))
416 {
417 *lpBinaryType = SCS_DOS_BINARY;
418 ret = TRUE;
419 }
420 else if (!strcmpiW( ptr, pifW ))
421 {
422 *lpBinaryType = SCS_PIF_BINARY;
423 ret = TRUE;
424 }
425 break;
426 }
427 case BINARY_PE_EXE:
428 case BINARY_PE_DLL:
429 *lpBinaryType = SCS_32BIT_BINARY;
430 ret = TRUE;
431 break;
432 case BINARY_WIN16:
433 *lpBinaryType = SCS_WOW_BINARY;
434 ret = TRUE;
435 break;
436 case BINARY_OS216:
437 *lpBinaryType = SCS_OS216_BINARY;
438 ret = TRUE;
439 break;
440 case BINARY_DOS:
441 *lpBinaryType = SCS_DOS_BINARY;
442 ret = TRUE;
443 break;
444 case BINARY_UNIX_EXE:
445 case BINARY_UNIX_LIB:
446 ret = FALSE;
447 break;
448 }
449
450 CloseHandle( hfile );
451 return ret;
452 }
453
454 /***********************************************************************
455 * GetBinaryTypeA [KERNEL32.@]
456 * GetBinaryType [KERNEL32.@]
457 *
458 * See GetBinaryTypeW.
459 */
460 BOOL WINAPI GetBinaryTypeA( LPCSTR lpApplicationName, LPDWORD lpBinaryType )
461 {
462 ANSI_STRING app_nameA;
463 NTSTATUS status;
464
465 TRACE("%s\n", debugstr_a(lpApplicationName));
466
467 /* Sanity check.
468 */
469 if ( lpApplicationName == NULL || lpBinaryType == NULL )
470 return FALSE;
471
472 RtlInitAnsiString(&app_nameA, lpApplicationName);
473 status = RtlAnsiStringToUnicodeString(&NtCurrentTeb()->StaticUnicodeString,
474 &app_nameA, FALSE);
475 if (!status)
476 return GetBinaryTypeW(NtCurrentTeb()->StaticUnicodeString.Buffer, lpBinaryType);
477
478 SetLastError(RtlNtStatusToDosError(status));
479 return FALSE;
480 }
481
482 /***********************************************************************
483 * GetModuleHandleExA (KERNEL32.@)
484 */
485 BOOL WINAPI GetModuleHandleExA( DWORD flags, LPCSTR name, HMODULE *module )
486 {
487 WCHAR *nameW;
488
489 if (!name || (flags & GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS))
490 return GetModuleHandleExW( flags, (LPCWSTR)name, module );
491
492 if (!(nameW = FILE_name_AtoW( name, FALSE ))) return FALSE;
493 return GetModuleHandleExW( flags, nameW, module );
494 }
495
496 /***********************************************************************
497 * GetModuleHandleExW (KERNEL32.@)
498 */
499 BOOL WINAPI GetModuleHandleExW( DWORD flags, LPCWSTR name, HMODULE *module )
500 {
501 NTSTATUS status = STATUS_SUCCESS;
502 HMODULE ret;
503 ULONG magic;
504
505 /* if we are messing with the refcount, grab the loader lock */
506 if ((flags & GET_MODULE_HANDLE_EX_FLAG_PIN) ||
507 !(flags & GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT))
508 LdrLockLoaderLock( 0, NULL, &magic );
509
510 if (!name)
511 {
512 ret = NtCurrentTeb()->Peb->ImageBaseAddress;
513 }
514 else if (flags & GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS)
515 {
516 void *dummy;
517 if (!(ret = RtlPcToFileHeader( (void *)name, &dummy ))) status = STATUS_DLL_NOT_FOUND;
518 }
519 else
520 {
521 UNICODE_STRING wstr;
522 RtlInitUnicodeString( &wstr, name );
523 status = LdrGetDllHandle( NULL, 0, &wstr, &ret );
524 }
525
526 if (status == STATUS_SUCCESS)
527 {
528 if (flags & GET_MODULE_HANDLE_EX_FLAG_PIN)
529 FIXME( "should pin refcount for %p\n", ret );
530 else if (!(flags & GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT))
531 LdrAddRefDll( 0, ret );
532 }
533 else SetLastError( RtlNtStatusToDosError( status ) );
534
535 if ((flags & GET_MODULE_HANDLE_EX_FLAG_PIN) ||
536 !(flags & GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT))
537 LdrUnlockLoaderLock( 0, magic );
538
539 if (module) *module = ret;
540 return (status == STATUS_SUCCESS);
541 }
542
543 /***********************************************************************
544 * GetModuleHandleA (KERNEL32.@)
545 * GetModuleHandle32 (KERNEL.488)
546 *
547 * Get the handle of a dll loaded into the process address space.
548 *
549 * PARAMS
550 * module [I] Name of the dll
551 *
552 * RETURNS
553 * Success: A handle to the loaded dll.
554 * Failure: A NULL handle. Use GetLastError() to determine the cause.
555 */
556 HMODULE WINAPI GetModuleHandleA(LPCSTR module)
557 {
558 HMODULE ret;
559
560 if (!GetModuleHandleExA( GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, module, &ret )) ret = 0;
561 return ret;
562 }
563
564 /***********************************************************************
565 * GetModuleHandleW (KERNEL32.@)
566 *
567 * Unicode version of GetModuleHandleA.
568 */
569 HMODULE WINAPI GetModuleHandleW(LPCWSTR module)
570 {
571 HMODULE ret;
572
573 if (!GetModuleHandleExW( GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, module, &ret )) ret = 0;
574 return ret;
575 }
576
577
578 /***********************************************************************
579 * GetModuleFileNameA (KERNEL32.@)
580 * GetModuleFileName32 (KERNEL.487)
581 *
582 * Get the file name of a loaded module from its handle.
583 *
584 * RETURNS
585 * Success: The length of the file name, excluding the terminating NUL.
586 * Failure: 0. Use GetLastError() to determine the cause.
587 *
588 * NOTES
589 * This function always returns the long path of hModule (as opposed to
590 * GetModuleFileName16() which returns short paths when the modules version
591 * field is < 4.0).
592 * The function doesn't write a terminating '\0' if the buffer is too
593 * small.
594 */
595 DWORD WINAPI GetModuleFileNameA(
596 HMODULE hModule, /* [in] Module handle (32 bit) */
597 LPSTR lpFileName, /* [out] Destination for file name */
598 DWORD size ) /* [in] Size of lpFileName in characters */
599 {
600 LPWSTR filenameW = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) );
601 DWORD len;
602
603 if (!filenameW)
604 {
605 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
606 return 0;
607 }
608 if ((len = GetModuleFileNameW( hModule, filenameW, size )))
609 {
610 len = FILE_name_WtoA( filenameW, len, lpFileName, size );
611 if (len < size) lpFileName[len] = '\0';
612 }
613 HeapFree( GetProcessHeap(), 0, filenameW );
614 return len;
615 }
616
617 /***********************************************************************
618 * GetModuleFileNameW (KERNEL32.@)
619 *
620 * Unicode version of GetModuleFileNameA.
621 */
622 DWORD WINAPI GetModuleFileNameW( HMODULE hModule, LPWSTR lpFileName, DWORD size )
623 {
624 ULONG magic, len = 0;
625 LDR_MODULE *pldr;
626 NTSTATUS nts;
627 WIN16_SUBSYSTEM_TIB *win16_tib;
628
629 if (!hModule && ((win16_tib = NtCurrentTeb()->Tib.SubSystemTib)) && win16_tib->exe_name)
630 {
631 len = min(size, win16_tib->exe_name->Length / sizeof(WCHAR));
632 memcpy( lpFileName, win16_tib->exe_name->Buffer, len * sizeof(WCHAR) );
633 if (len < size) lpFileName[len] = '\0';
634 goto done;
635 }
636
637 LdrLockLoaderLock( 0, NULL, &magic );
638
639 if (!hModule) hModule = NtCurrentTeb()->Peb->ImageBaseAddress;
640 nts = LdrFindEntryForAddress( hModule, &pldr );
641 if (nts == STATUS_SUCCESS)
642 {
643 len = min(size, pldr->FullDllName.Length / sizeof(WCHAR));
644 memcpy(lpFileName, pldr->FullDllName.Buffer, len * sizeof(WCHAR));
645 if (len < size) lpFileName[len] = '\0';
646 }
647 else SetLastError( RtlNtStatusToDosError( nts ) );
648
649 LdrUnlockLoaderLock( 0, magic );
650 done:
651 TRACE( "%s\n", debugstr_wn(lpFileName, len) );
652 return len;
653 }
654
655
656 /***********************************************************************
657 * get_dll_system_path
658 */
659 static const WCHAR *get_dll_system_path(void)
660 {
661 static WCHAR *cached_path;
662
663 if (!cached_path)
664 {
665 WCHAR *p, *path;
666 int len = 3;
667
668 len += 2 * GetSystemDirectoryW( NULL, 0 );
669 len += GetWindowsDirectoryW( NULL, 0 );
670 p = path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
671 *p++ = '.';
672 *p++ = ';';
673 GetSystemDirectoryW( p, path + len - p);
674 p += strlenW(p);
675 /* if system directory ends in "32" add 16-bit version too */
676 if (p[-2] == '3' && p[-1] == '2')
677 {
678 *p++ = ';';
679 GetSystemDirectoryW( p, path + len - p);
680 p += strlenW(p) - 2;
681 }
682 *p++ = ';';
683 GetWindowsDirectoryW( p, path + len - p);
684 cached_path = path;
685 }
686 return cached_path;
687 }
688
689 /******************************************************************
690 * get_module_path_end
691 *
692 * Returns the end of the directory component of the module path.
693 */
694 static inline const WCHAR *get_module_path_end(const WCHAR *module)
695 {
696 const WCHAR *p;
697 const WCHAR *mod_end = module;
698 if (!module) return mod_end;
699
700 if ((p = strrchrW( mod_end, '\\' ))) mod_end = p;
701 if ((p = strrchrW( mod_end, '/' ))) mod_end = p;
702 if (mod_end == module + 2 && module[1] == ':') mod_end++;
703 if (mod_end == module && module[0] && module[1] == ':') mod_end += 2;
704
705 return mod_end;
706 }
707
708 /******************************************************************
709 * MODULE_get_dll_load_path
710 *
711 * Compute the load path to use for a given dll.
712 * Returned pointer must be freed by caller.
713 */
714 WCHAR *MODULE_get_dll_load_path( LPCWSTR module )
715 {
716 static const WCHAR pathW[] = {'P','A','T','H',0};
717
718 const WCHAR *system_path = get_dll_system_path();
719 const WCHAR *mod_end = NULL;
720 UNICODE_STRING name, value;
721 WCHAR *p, *ret;
722 int len = 0, path_len = 0;
723
724 /* adjust length for module name */
725
726 if (module)
727 mod_end = get_module_path_end( module );
728 /* if module is NULL or doesn't contain a path, fall back to directory
729 * process was loaded from */
730 if (module == mod_end)
731 {
732 module = NtCurrentTeb()->Peb->ProcessParameters->ImagePathName.Buffer;
733 mod_end = get_module_path_end( module );
734 }
735 len += (mod_end - module) + 1;
736
737 len += strlenW( system_path ) + 2;
738
739 /* get the PATH variable */
740
741 RtlInitUnicodeString( &name, pathW );
742 value.Length = 0;
743 value.MaximumLength = 0;
744 value.Buffer = NULL;
745 if (RtlQueryEnvironmentVariable_U( NULL, &name, &value ) == STATUS_BUFFER_TOO_SMALL)
746 path_len = value.Length;
747
748 RtlEnterCriticalSection( &dlldir_section );
749 if (dll_directory) len += strlenW(dll_directory) + 1;
750 if ((p = ret = HeapAlloc( GetProcessHeap(), 0, path_len + len * sizeof(WCHAR) )))
751 {
752 if (module)
753 {
754 memcpy( ret, module, (mod_end - module) * sizeof(WCHAR) );
755 p += (mod_end - module);
756 *p++ = ';';
757 }
758 if (dll_directory)
759 {
760 strcpyW( p, dll_directory );
761 p += strlenW(p);
762 *p++ = ';';
763 }
764 }
765 RtlLeaveCriticalSection( &dlldir_section );
766 if (!ret) return NULL;
767
768 strcpyW( p, system_path );
769 p += strlenW(p);
770 *p++ = ';';
771 value.Buffer = p;
772 value.MaximumLength = path_len;
773
774 while (RtlQueryEnvironmentVariable_U( NULL, &name, &value ) == STATUS_BUFFER_TOO_SMALL)
775 {
776 WCHAR *new_ptr;
777
778 /* grow the buffer and retry */
779 path_len = value.Length;
780 if (!(new_ptr = HeapReAlloc( GetProcessHeap(), 0, ret, path_len + len * sizeof(WCHAR) )))
781 {
782 HeapFree( GetProcessHeap(), 0, ret );
783 return NULL;
784 }
785 value.Buffer = new_ptr + (value.Buffer - ret);
786 value.MaximumLength = path_len;
787 ret = new_ptr;
788 }
789 value.Buffer[value.Length / sizeof(WCHAR)] = 0;
790 return ret;
791 }
792
793
794 /******************************************************************
795 * load_library_as_datafile
796 */
797 static BOOL load_library_as_datafile( LPCWSTR name, HMODULE* hmod)
798 {
799 static const WCHAR dotDLL[] = {'.','d','l','l',0};
800
801 WCHAR filenameW[MAX_PATH];
802 HANDLE hFile = INVALID_HANDLE_VALUE;
803 HANDLE mapping;
804 HMODULE module;
805
806 *hmod = 0;
807
808 if (SearchPathW( NULL, name, dotDLL, sizeof(filenameW) / sizeof(filenameW[0]),
809 filenameW, NULL ))
810 {
811 hFile = CreateFileW( filenameW, GENERIC_READ, FILE_SHARE_READ,
812 NULL, OPEN_EXISTING, 0, 0 );
813 }
814 if (hFile == INVALID_HANDLE_VALUE) return FALSE;
815
816 mapping = CreateFileMappingW( hFile, NULL, PAGE_READONLY, 0, 0, NULL );
817 CloseHandle( hFile );
818 if (!mapping) return FALSE;
819
820 module = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
821 CloseHandle( mapping );
822 if (!module) return FALSE;
823
824 /* make sure it's a valid PE file */
825 if (!RtlImageNtHeader(module))
826 {
827 UnmapViewOfFile( module );
828 return FALSE;
829 }
830 *hmod = (HMODULE)((char *)module + 1); /* set low bit of handle to indicate datafile module */
831 return TRUE;
832 }
833
834
835 /******************************************************************
836 * load_library
837 *
838 * Helper for LoadLibraryExA/W.
839 */
840 static HMODULE load_library( const UNICODE_STRING *libname, DWORD flags )
841 {
842 NTSTATUS nts;
843 HMODULE hModule;
844 WCHAR *load_path;
845
846 load_path = MODULE_get_dll_load_path( flags & LOAD_WITH_ALTERED_SEARCH_PATH ? libname->Buffer : NULL );
847
848 if (flags & LOAD_LIBRARY_AS_DATAFILE)
849 {
850 ULONG magic;
851
852 LdrLockLoaderLock( 0, NULL, &magic );
853 if (!(nts = LdrGetDllHandle( load_path, flags, libname, &hModule )))
854 {
855 LdrAddRefDll( 0, hModule );
856 LdrUnlockLoaderLock( 0, magic );
857 goto done;
858 }
859 LdrUnlockLoaderLock( 0, magic );
860
861 /* The method in load_library_as_datafile allows searching for the
862 * 'native' libraries only
863 */
864 if (load_library_as_datafile( libname->Buffer, &hModule )) goto done;
865 flags |= DONT_RESOLVE_DLL_REFERENCES; /* Just in case */
866 /* Fallback to normal behaviour */
867 }
868
869 nts = LdrLoadDll( load_path, flags, libname, &hModule );
870 if (nts != STATUS_SUCCESS)
871 {
872 hModule = 0;
873 SetLastError( RtlNtStatusToDosError( nts ) );
874 }
875 done:
876 HeapFree( GetProcessHeap(), 0, load_path );
877 return hModule;
878 }
879
880
881 /******************************************************************
882 * LoadLibraryExA (KERNEL32.@)
883 *
884 * Load a dll file into the process address space.
885 *
886 * PARAMS
887 * libname [I] Name of the file to load
888 * hfile [I] Reserved, must be 0.
889 * flags [I] Flags for loading the dll
890 *
891 * RETURNS
892 * Success: A handle to the loaded dll.
893 * Failure: A NULL handle. Use GetLastError() to determine the cause.
894 *
895 * NOTES
896 * The HFILE parameter is not used and marked reserved in the SDK. I can
897 * only guess that it should force a file to be mapped, but I rather
898 * ignore the parameter because it would be extremely difficult to
899 * integrate this with different types of module representations.
900 */
901 HMODULE WINAPI LoadLibraryExA(LPCSTR libname, HANDLE hfile, DWORD flags)
902 {
903 WCHAR *libnameW;
904
905 if (!(libnameW = FILE_name_AtoW( libname, FALSE ))) return 0;
906 return LoadLibraryExW( libnameW, hfile, flags );
907 }
908
909 /***********************************************************************
910 * LoadLibraryExW (KERNEL32.@)
911 *
912 * Unicode version of LoadLibraryExA.
913 */
914 HMODULE WINAPI LoadLibraryExW(LPCWSTR libnameW, HANDLE hfile, DWORD flags)
915 {
916 UNICODE_STRING wstr;
917 HMODULE res;
918
919 if (!libnameW)
920 {
921 SetLastError(ERROR_INVALID_PARAMETER);
922 return 0;
923 }
924 RtlInitUnicodeString( &wstr, libnameW );
925 if (wstr.Buffer[wstr.Length/sizeof(WCHAR) - 1] != ' ')
926 return load_library( &wstr, flags );
927
928 /* Library name has trailing spaces */
929 RtlCreateUnicodeString( &wstr, libnameW );
930 while (wstr.Length > sizeof(WCHAR) &&
931 wstr.Buffer[wstr.Length/sizeof(WCHAR) - 1] == ' ')
932 {
933 wstr.Length -= sizeof(WCHAR);
934 }
935 wstr.Buffer[wstr.Length/sizeof(WCHAR)] = '\0';
936 res = load_library( &wstr, flags );
937 RtlFreeUnicodeString( &wstr );
938 return res;
939 }
940
941 /***********************************************************************
942 * LoadLibraryA (KERNEL32.@)
943 *
944 * Load a dll file into the process address space.
945 *
946 * PARAMS
947 * libname [I] Name of the file to load
948 *
949 * RETURNS
950 * Success: A handle to the loaded dll.
951 * Failure: A NULL handle. Use GetLastError() to determine the cause.
952 *
953 * NOTES
954 * See LoadLibraryExA().
955 */
956 HMODULE WINAPI LoadLibraryA(LPCSTR libname)
957 {
958 return LoadLibraryExA(libname, 0, 0);
959 }
960
961 /***********************************************************************
962 * LoadLibraryW (KERNEL32.@)
963 *
964 * Unicode version of LoadLibraryA.
965 */
966 HMODULE WINAPI LoadLibraryW(LPCWSTR libnameW)
967 {
968 return LoadLibraryExW(libnameW, 0, 0);
969 }
970
971 /***********************************************************************
972 * FreeLibrary (KERNEL32.@)
973 * FreeLibrary32 (KERNEL.486)
974 *
975 * Free a dll loaded into the process address space.
976 *
977 * PARAMS
978 * hLibModule [I] Handle to the dll returned by LoadLibraryA().
979 *
980 * RETURNS
981 * Success: TRUE. The dll is removed if it is not still in use.
982 * Failure: FALSE. Use GetLastError() to determine the cause.
983 */
984 BOOL WINAPI FreeLibrary(HINSTANCE hLibModule)
985 {
986 BOOL retv = FALSE;
987 NTSTATUS nts;
988
989 if (!hLibModule)
990 {
991 SetLastError( ERROR_INVALID_HANDLE );
992 return FALSE;
993 }
994
995 if ((ULONG_PTR)hLibModule & 1)
996 {
997 /* this is a LOAD_LIBRARY_AS_DATAFILE module */
998 char *ptr = (char *)hLibModule - 1;
999 UnmapViewOfFile( ptr );
1000 return TRUE;
1001 }
1002
1003 if ((nts = LdrUnloadDll( hLibModule )) == STATUS_SUCCESS) retv = TRUE;
1004 else SetLastError( RtlNtStatusToDosError( nts ) );
1005
1006 return retv;
1007 }
1008
1009 /***********************************************************************
1010 * GetProcAddress (KERNEL32.@)
1011 *
1012 * Find the address of an exported symbol in a loaded dll.
1013 *
1014 * PARAMS
1015 * hModule [I] Handle to the dll returned by LoadLibraryA().
1016 * function [I] Name of the symbol, or an integer ordinal number < 16384
1017 *
1018 * RETURNS
1019 * Success: A pointer to the symbol in the process address space.
1020 * Failure: NULL. Use GetLastError() to determine the cause.
1021 */
1022 FARPROC WINAPI GetProcAddress( HMODULE hModule, LPCSTR function )
1023 {
1024 NTSTATUS nts;
1025 FARPROC fp;
1026
1027 if (!hModule) hModule = NtCurrentTeb()->Peb->ImageBaseAddress;
1028
1029 if (HIWORD(function))
1030 {
1031 ANSI_STRING str;
1032
1033 RtlInitAnsiString( &str, function );
1034 nts = LdrGetProcedureAddress( hModule, &str, 0, (void**)&fp );
1035 }
1036 else
1037 nts = LdrGetProcedureAddress( hModule, NULL, LOWORD(function), (void**)&fp );
1038 if (nts != STATUS_SUCCESS)
1039 {
1040 SetLastError( RtlNtStatusToDosError( nts ) );
1041 fp = NULL;
1042 }
1043 return fp;
1044 }
1045
1046 /***********************************************************************
1047 * GetProcAddress32 (KERNEL.453)
1048 *
1049 * Find the address of an exported symbol in a loaded dll.
1050 *
1051 * PARAMS
1052 * hModule [I] Handle to the dll returned by LoadLibraryA().
1053 * function [I] Name of the symbol, or an integer ordinal number < 16384
1054 *
1055 * RETURNS
1056 * Success: A pointer to the symbol in the process address space.
1057 * Failure: NULL. Use GetLastError() to determine the cause.
1058 */
1059 FARPROC WINAPI GetProcAddress32_16( HMODULE hModule, LPCSTR function )
1060 {
1061 /* FIXME: we used to disable snoop when returning proc for Win16 subsystem */
1062 return GetProcAddress( hModule, function );
1063 }
1064
1065
1066 /***********************************************************************
1067 * DelayLoadFailureHook (KERNEL32.@)
1068 */
1069 FARPROC WINAPI DelayLoadFailureHook( LPCSTR name, LPCSTR function )
1070 {
1071 ULONG_PTR args[2];
1072
1073 if ((ULONG_PTR)function >> 16)
1074 ERR( "failed to delay load %s.%s\n", name, function );
1075 else
1076 ERR( "failed to delay load %s.%u\n", name, LOWORD(function) );
1077 args[0] = (ULONG_PTR)name;
1078 args[1] = (ULONG_PTR)function;
1079 RaiseException( EXCEPTION_WINE_STUB, EH_NONCONTINUABLE, 2, args );
1080 return NULL;
1081 }
1082
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.