4 * Copyright 1995 Alexandre Julliard
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
27 #ifdef HAVE_SYS_TYPES_H
28 # include <sys/types.h>
33 #include "wine/winbase16.h"
43 #include "wine/debug.h"
44 #include "wine/unicode.h"
45 #include "wine/server.h"
47 WINE_DEFAULT_DEBUG_CHANNEL(module);
48 WINE_DECLARE_DEBUG_CHANNEL(loaddll);
51 /****************************************************************************
52 * DisableThreadLibraryCalls (KERNEL32.@)
54 * Inform the module loader that thread notifications are not required for a dll.
57 * hModule [I] Module handle to skip calls for
60 * Success: TRUE. Thread attach and detach notifications will not be sent
62 * Failure: FALSE. Use GetLastError() to determine the cause.
65 * This is typically called from the dll entry point of a dll during process
66 * attachment, for dlls that do not need to process thread notifications.
68 BOOL WINAPI DisableThreadLibraryCalls( HMODULE hModule )
70 NTSTATUS nts = LdrDisableThreadCalloutsForDll( hModule );
71 if (nts == STATUS_SUCCESS) return TRUE;
73 SetLastError( RtlNtStatusToDosError( nts ) );
78 /* Check whether a file is an OS/2 or a very old Windows executable
79 * by testing on import of KERNEL.
81 * FIXME: is reading the module imports the only way of discerning
82 * old Windows binaries from OS/2 ones ? At least it seems so...
84 static enum binary_type MODULE_Decide_OS2_OldWin(HANDLE hfile, const IMAGE_DOS_HEADER *mz,
85 const IMAGE_OS2_HEADER *ne)
87 DWORD currpos = SetFilePointer( hfile, 0, NULL, SEEK_CUR);
88 enum binary_type ret = BINARY_OS216;
94 /* read modref table */
95 if ( (SetFilePointer( hfile, mz->e_lfanew + ne->ne_modtab, NULL, SEEK_SET ) == -1)
96 || (!(modtab = HeapAlloc( GetProcessHeap(), 0, ne->ne_cmod*sizeof(WORD))))
97 || (!(ReadFile(hfile, modtab, ne->ne_cmod*sizeof(WORD), &len, NULL)))
98 || (len != ne->ne_cmod*sizeof(WORD)) )
101 /* read imported names table */
102 if ( (SetFilePointer( hfile, mz->e_lfanew + ne->ne_imptab, NULL, SEEK_SET ) == -1)
103 || (!(nametab = HeapAlloc( GetProcessHeap(), 0, ne->ne_enttab - ne->ne_imptab)))
104 || (!(ReadFile(hfile, nametab, ne->ne_enttab - ne->ne_imptab, &len, NULL)))
105 || (len != ne->ne_enttab - ne->ne_imptab) )
108 for (i=0; i < ne->ne_cmod; i++)
110 LPSTR module = &nametab[modtab[i]];
111 TRACE("modref: %.*s\n", module[0], &module[1]);
112 if (!(strncmp(&module[1], "KERNEL", module[0])))
113 { /* very old Windows file */
114 MESSAGE("This seems to be a very old (pre-3.0) Windows executable. Expect crashes, especially if this is a real-mode binary !\n");
121 ERR("Hmm, an error occurred. Is this binary file broken ?\n");
124 HeapFree( GetProcessHeap(), 0, modtab);
125 HeapFree( GetProcessHeap(), 0, nametab);
126 SetFilePointer( hfile, currpos, NULL, SEEK_SET); /* restore filepos */
130 /***********************************************************************
131 * MODULE_GetBinaryType
133 enum binary_type MODULE_GetBinaryType( HANDLE hfile )
139 unsigned char magic[4];
140 unsigned char ignored[12];
146 unsigned long cputype;
147 unsigned long cpusubtype;
148 unsigned long filetype;
156 /* Seek to the start of the file and read the header information. */
157 if (SetFilePointer( hfile, 0, NULL, SEEK_SET ) == -1)
158 return BINARY_UNKNOWN;
159 if (!ReadFile( hfile, &header, sizeof(header), &len, NULL ) || len != sizeof(header))
160 return BINARY_UNKNOWN;
162 if (!memcmp( header.elf.magic, "\177ELF", 4 ))
164 /* FIXME: we don't bother to check byte order, architecture, etc. */
165 switch(header.elf.type)
167 case 2: return BINARY_UNIX_EXE;
168 case 3: return BINARY_UNIX_LIB;
170 return BINARY_UNKNOWN;
173 /* Mach-o File with Endian set to Big Endian or Little Endian*/
174 if (header.macho.magic == 0xfeedface || header.macho.magic == 0xecafdeef)
176 switch(header.macho.filetype)
178 case 0x8: /* MH_BUNDLE */ return BINARY_UNIX_LIB;
180 return BINARY_UNKNOWN;
183 /* Not ELF, try DOS */
185 if (header.mz.e_magic == IMAGE_DOS_SIGNATURE)
187 /* We do have a DOS image so we will now try to seek into
188 * the file by the amount indicated by the field
189 * "Offset to extended header" and read in the
190 * "magic" field information at that location.
191 * This will tell us if there is more header information
194 /* But before we do we will make sure that header
195 * structure encompasses the "Offset to extended header"
198 if (header.mz.e_lfanew < sizeof(IMAGE_DOS_HEADER))
200 if (SetFilePointer( hfile, header.mz.e_lfanew, NULL, SEEK_SET ) == -1)
202 if (!ReadFile( hfile, magic, sizeof(magic), &len, NULL ) || len != sizeof(magic))
205 /* Reading the magic field succeeded so
206 * we will try to determine what type it is.
208 if (!memcmp( magic, "PE\0\0", 4 ))
210 IMAGE_FILE_HEADER FileHeader;
212 if (ReadFile( hfile, &FileHeader, sizeof(FileHeader), &len, NULL ) && len == sizeof(FileHeader))
214 if (FileHeader.Characteristics & IMAGE_FILE_DLL) return BINARY_PE_DLL;
215 return BINARY_PE_EXE;
220 if (!memcmp( magic, "NE", 2 ))
222 /* This is a Windows executable (NE) header. This can
223 * mean either a 16-bit OS/2 or a 16-bit Windows or even a
224 * DOS program (running under a DOS extender). To decide
225 * which, we'll have to read the NE header.
228 if ( SetFilePointer( hfile, header.mz.e_lfanew, NULL, SEEK_SET ) != -1
229 && ReadFile( hfile, &ne, sizeof(ne), &len, NULL )
230 && len == sizeof(ne) )
232 switch ( ne.ne_exetyp )
234 case 2: return BINARY_WIN16;
235 case 5: return BINARY_DOS;
236 default: return MODULE_Decide_OS2_OldWin(hfile, &header.mz, &ne);
239 /* Couldn't read header, so abort. */
243 /* Unknown extended header, but this file is nonetheless DOS-executable. */
247 return BINARY_UNKNOWN;
250 /***********************************************************************
251 * GetBinaryTypeW [KERNEL32.@]
253 * Determine whether a file is executable, and if so, what kind.
256 * lpApplicationName [I] Path of the file to check
257 * lpBinaryType [O] Destination for the binary type
260 * TRUE, if the file is an executable, in which case lpBinaryType is set.
261 * FALSE, if the file is not an executable or if the function fails.
264 * The type of executable is a property that determines which subsytem an
265 * executable file runs under. lpBinaryType can be set to one of the following
267 * SCS_32BIT_BINARY: A Win32 based application
268 * SCS_DOS_BINARY: An MS-Dos based application
269 * SCS_WOW_BINARY: A Win16 based application
270 * SCS_PIF_BINARY: A PIF file that executes an MS-Dos based app
271 * SCS_POSIX_BINARY: A POSIX based application ( Not implemented )
272 * SCS_OS216_BINARY: A 16bit OS/2 based application
274 * To find the binary type, this function reads in the files header information.
275 * If extended header information is not present it will assume that the file
276 * is a DOS executable. If extended header information is present it will
277 * determine if the file is a 16 or 32 bit Windows executable by checking the
278 * flags in the header.
280 * ".com" and ".pif" files are only recognized by their file name extension,
281 * as per native Windows.
283 BOOL WINAPI GetBinaryTypeW( LPCWSTR lpApplicationName, LPDWORD lpBinaryType )
288 TRACE("%s\n", debugstr_w(lpApplicationName) );
292 if ( lpApplicationName == NULL || lpBinaryType == NULL )
295 /* Open the file indicated by lpApplicationName for reading.
297 hfile = CreateFileW( lpApplicationName, GENERIC_READ, FILE_SHARE_READ,
298 NULL, OPEN_EXISTING, 0, 0 );
299 if ( hfile == INVALID_HANDLE_VALUE )
304 switch(MODULE_GetBinaryType( hfile ))
308 static const WCHAR comW[] = { '.','C','O','M',0 };
309 static const WCHAR pifW[] = { '.','P','I','F',0 };
312 /* try to determine from file name */
313 ptr = strrchrW( lpApplicationName, '.' );
315 if (!strcmpiW( ptr, comW ))
317 *lpBinaryType = SCS_DOS_BINARY;
320 else if (!strcmpiW( ptr, pifW ))
322 *lpBinaryType = SCS_PIF_BINARY;
329 *lpBinaryType = SCS_32BIT_BINARY;
333 *lpBinaryType = SCS_WOW_BINARY;
337 *lpBinaryType = SCS_OS216_BINARY;
341 *lpBinaryType = SCS_DOS_BINARY;
344 case BINARY_UNIX_EXE:
345 case BINARY_UNIX_LIB:
350 CloseHandle( hfile );
354 /***********************************************************************
355 * GetBinaryTypeA [KERNEL32.@]
356 * GetBinaryType [KERNEL32.@]
358 BOOL WINAPI GetBinaryTypeA( LPCSTR lpApplicationName, LPDWORD lpBinaryType )
360 ANSI_STRING app_nameA;
363 TRACE("%s\n", debugstr_a(lpApplicationName));
367 if ( lpApplicationName == NULL || lpBinaryType == NULL )
370 RtlInitAnsiString(&app_nameA, lpApplicationName);
371 status = RtlAnsiStringToUnicodeString(&NtCurrentTeb()->StaticUnicodeString,
374 return GetBinaryTypeW(NtCurrentTeb()->StaticUnicodeString.Buffer, lpBinaryType);
376 SetLastError(RtlNtStatusToDosError(status));
381 /***********************************************************************
382 * GetModuleHandleA (KERNEL32.@)
383 * GetModuleHandle32 (KERNEL.488)
385 * Get the handle of a dll loaded into the process address space.
388 * module [I] Name of the dll
391 * Success: A handle to the loaded dll.
392 * Failure: A NULL handle. Use GetLastError() to determine the cause.
394 HMODULE WINAPI GetModuleHandleA(LPCSTR module)
400 if (!module) return NtCurrentTeb()->Peb->ImageBaseAddress;
402 RtlCreateUnicodeStringFromAsciiz(&wstr, module);
403 nts = LdrGetDllHandle(0, 0, &wstr, &ret);
404 RtlFreeUnicodeString( &wstr );
405 if (nts != STATUS_SUCCESS)
408 SetLastError( RtlNtStatusToDosError( nts ) );
413 /***********************************************************************
414 * GetModuleHandleW (KERNEL32.@)
416 * Unicode version of GetModuleHandleA.
418 HMODULE WINAPI GetModuleHandleW(LPCWSTR module)
424 if (!module) return NtCurrentTeb()->Peb->ImageBaseAddress;
426 RtlInitUnicodeString( &wstr, module );
427 nts = LdrGetDllHandle( 0, 0, &wstr, &ret);
428 if (nts != STATUS_SUCCESS)
430 SetLastError( RtlNtStatusToDosError( nts ) );
437 /***********************************************************************
438 * GetModuleFileNameA (KERNEL32.@)
439 * GetModuleFileName32 (KERNEL.487)
441 * Get the file name of a loaded module from its handle.
444 * Success: The length of the file name, excluding the terminating NUL.
445 * Failure: 0. Use GetLastError() to determine the cause.
448 * This function always returns the long path of hModule (as opposed to
449 * GetModuleFileName16() which returns short paths when the modules version
452 DWORD WINAPI GetModuleFileNameA(
453 HMODULE hModule, /* [in] Module handle (32 bit) */
454 LPSTR lpFileName, /* [out] Destination for file name */
455 DWORD size ) /* [in] Size of lpFileName in characters */
457 LPWSTR filenameW = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) );
461 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
464 GetModuleFileNameW( hModule, filenameW, size );
465 WideCharToMultiByte( CP_ACP, 0, filenameW, -1, lpFileName, size, NULL, NULL );
466 HeapFree( GetProcessHeap(), 0, filenameW );
467 return strlen( lpFileName );
470 /***********************************************************************
471 * GetModuleFileNameW (KERNEL32.@)
473 * Unicode version of GetModuleFileNameA.
475 DWORD WINAPI GetModuleFileNameW( HMODULE hModule, LPWSTR lpFileName, DWORD size )
481 LdrLockLoaderLock( 0, NULL, &magic );
482 if (!hModule && !(NtCurrentTeb()->tibflags & TEBF_WIN32))
484 /* 16-bit task - get current NE module name */
485 NE_MODULE *pModule = NE_GetPtr( GetCurrentTask() );
488 WCHAR path[MAX_PATH];
490 MultiByteToWideChar( CP_ACP, 0, NE_MODULE_NAME(pModule), -1, path, MAX_PATH );
491 GetLongPathNameW(path, lpFileName, size);
499 if (!hModule) hModule = NtCurrentTeb()->Peb->ImageBaseAddress;
500 nts = LdrFindEntryForAddress( hModule, &pldr );
501 if (nts == STATUS_SUCCESS) lstrcpynW(lpFileName, pldr->FullDllName.Buffer, size);
502 else SetLastError( RtlNtStatusToDosError( nts ) );
505 LdrUnlockLoaderLock( 0, magic );
507 TRACE( "%s\n", debugstr_w(lpFileName) );
508 return strlenW(lpFileName);
512 /***********************************************************************
513 * get_dll_system_path
515 static const WCHAR *get_dll_system_path(void)
524 exe_name = NtCurrentTeb()->Peb->ProcessParameters->ImagePathName.Buffer;
525 if (!(p = strrchrW( exe_name, '\\' ))) p = exe_name;
526 /* include trailing backslash only on drive root */
527 if (p == exe_name + 2 && exe_name[1] == ':') p++;
529 len += GetSystemDirectoryW( NULL, 0 );
530 len += GetWindowsDirectoryW( NULL, 0 );
531 path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
532 memcpy( path, exe_name, (p - exe_name) * sizeof(WCHAR) );
533 p = path + (p - exe_name);
537 GetSystemDirectoryW( p, path + len - p);
540 GetWindowsDirectoryW( p, path + len - p);
546 /******************************************************************
549 * Compute the load path to use for a given dll.
550 * Returned pointer must be freed by caller.
552 static WCHAR *get_dll_load_path( LPCWSTR module )
554 static const WCHAR pathW[] = {'P','A','T','H',0};
556 const WCHAR *system_path = get_dll_system_path();
557 const WCHAR *mod_end = NULL;
558 UNICODE_STRING name, value;
560 int len = 0, path_len = 0;
562 /* adjust length for module name */
567 if ((p = strrchrW( mod_end, '\\' ))) mod_end = p;
568 if ((p = strrchrW( mod_end, '/' ))) mod_end = p;
569 if (mod_end == module + 2 && module[1] == ':') mod_end++;
570 if (mod_end == module && module[0] && module[1] == ':') mod_end += 2;
571 len += (mod_end - module);
572 system_path = strchrW( system_path, ';' );
574 len += strlenW( system_path ) + 2;
576 /* get the PATH variable */
578 RtlInitUnicodeString( &name, pathW );
580 value.MaximumLength = 0;
582 if (RtlQueryEnvironmentVariable_U( NULL, &name, &value ) == STATUS_BUFFER_TOO_SMALL)
583 path_len = value.Length;
585 if (!(ret = HeapAlloc( GetProcessHeap(), 0, path_len + len * sizeof(WCHAR) ))) return NULL;
589 memcpy( ret, module, (mod_end - module) * sizeof(WCHAR) );
590 p += (mod_end - module);
592 strcpyW( p, system_path );
596 value.MaximumLength = path_len;
598 while (RtlQueryEnvironmentVariable_U( NULL, &name, &value ) == STATUS_BUFFER_TOO_SMALL)
602 /* grow the buffer and retry */
603 path_len = value.Length;
604 if (!(new_ptr = HeapReAlloc( GetProcessHeap(), 0, ret, path_len + len * sizeof(WCHAR) )))
606 HeapFree( GetProcessHeap(), 0, ret );
609 value.Buffer = new_ptr + (value.Buffer - ret);
610 value.MaximumLength = path_len;
613 value.Buffer[value.Length / sizeof(WCHAR)] = 0;
618 /******************************************************************
619 * MODULE_InitLoadPath
621 * Create the initial dll load path.
623 void MODULE_InitLoadPath(void)
625 WCHAR *path = get_dll_load_path( NULL );
626 RtlInitUnicodeString( &NtCurrentTeb()->Peb->ProcessParameters->DllPath, path );
630 /******************************************************************
631 * load_library_as_datafile
633 static BOOL load_library_as_datafile( LPCWSTR name, HMODULE* hmod)
635 static const WCHAR dotDLL[] = {'.','d','l','l',0};
637 WCHAR filenameW[MAX_PATH];
638 HANDLE hFile = INVALID_HANDLE_VALUE;
644 if (SearchPathW( NULL, (LPCWSTR)name, dotDLL, sizeof(filenameW) / sizeof(filenameW[0]),
647 hFile = CreateFileW( filenameW, GENERIC_READ, FILE_SHARE_READ,
648 NULL, OPEN_EXISTING, 0, 0 );
650 if (hFile == INVALID_HANDLE_VALUE) return FALSE;
652 mapping = CreateFileMappingW( hFile, NULL, PAGE_READONLY, 0, 0, NULL );
653 CloseHandle( hFile );
654 if (!mapping) return FALSE;
656 module = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
657 CloseHandle( mapping );
658 if (!module) return FALSE;
660 /* make sure it's a valid PE file */
661 if (!RtlImageNtHeader(module))
663 UnmapViewOfFile( module );
666 *hmod = (HMODULE)((char *)module + 1); /* set low bit of handle to indicate datafile module */
671 /******************************************************************
674 * Helper for LoadLibraryExA/W.
676 static HMODULE load_library( const UNICODE_STRING *libname, DWORD flags )
682 if (flags & LOAD_LIBRARY_AS_DATAFILE)
684 /* The method in load_library_as_datafile allows searching for the
685 * 'native' libraries only
687 if (load_library_as_datafile( libname->Buffer, &hModule )) return hModule;
688 flags |= DONT_RESOLVE_DLL_REFERENCES; /* Just in case */
689 /* Fallback to normal behaviour */
692 load_path = get_dll_load_path( flags & LOAD_WITH_ALTERED_SEARCH_PATH ? libname->Buffer : NULL );
693 nts = LdrLoadDll( load_path, flags, libname, &hModule );
694 HeapFree( GetProcessHeap(), 0, load_path );
695 if (nts != STATUS_SUCCESS)
698 SetLastError( RtlNtStatusToDosError( nts ) );
704 /******************************************************************
705 * LoadLibraryExA (KERNEL32.@)
707 * Load a dll file into the process address space.
710 * libname [I] Name of the file to load
711 * hfile [I] Reserved, must be 0.
712 * flags [I] Flags for loading the dll
715 * Success: A handle to the loaded dll.
716 * Failure: A NULL handle. Use GetLastError() to determine the cause.
719 * The HFILE parameter is not used and marked reserved in the SDK. I can
720 * only guess that it should force a file to be mapped, but I rather
721 * ignore the parameter because it would be extremely difficult to
722 * integrate this with different types of module representations.
724 HMODULE WINAPI LoadLibraryExA(LPCSTR libname, HANDLE hfile, DWORD flags)
731 SetLastError(ERROR_INVALID_PARAMETER);
734 RtlCreateUnicodeStringFromAsciiz( &wstr, libname );
735 hModule = load_library( &wstr, flags );
736 RtlFreeUnicodeString( &wstr );
740 /***********************************************************************
741 * LoadLibraryExW (KERNEL32.@)
743 * Unicode version of LoadLibraryExA.
745 HMODULE WINAPI LoadLibraryExW(LPCWSTR libnameW, HANDLE hfile, DWORD flags)
751 SetLastError(ERROR_INVALID_PARAMETER);
754 RtlInitUnicodeString( &wstr, libnameW );
755 return load_library( &wstr, flags );
758 /***********************************************************************
759 * LoadLibraryA (KERNEL32.@)
761 * Load a dll file into the process address space.
764 * libname [I] Name of the file to load
767 * Success: A handle to the loaded dll.
768 * Failure: A NULL handle. Use GetLastError() to determine the cause.
771 * See LoadLibraryExA().
773 HMODULE WINAPI LoadLibraryA(LPCSTR libname)
775 return LoadLibraryExA(libname, 0, 0);
778 /***********************************************************************
779 * LoadLibraryW (KERNEL32.@)
781 * Unicode version of LoadLibraryA.
783 HMODULE WINAPI LoadLibraryW(LPCWSTR libnameW)
785 return LoadLibraryExW(libnameW, 0, 0);
788 /***********************************************************************
789 * FreeLibrary (KERNEL32.@)
790 * FreeLibrary32 (KERNEL.486)
792 * Free a dll loaded into the process address space.
795 * hLibModule [I] Handle to the dll returned by LoadLibraryA().
798 * Success: TRUE. The dll is removed if it is not still in use.
799 * Failure: FALSE. Use GetLastError() to determine the cause.
801 BOOL WINAPI FreeLibrary(HINSTANCE hLibModule)
808 SetLastError( ERROR_INVALID_HANDLE );
812 if ((ULONG_PTR)hLibModule & 1)
814 /* this is a LOAD_LIBRARY_AS_DATAFILE module */
815 char *ptr = (char *)hLibModule - 1;
816 UnmapViewOfFile( ptr );
820 if ((nts = LdrUnloadDll( hLibModule )) == STATUS_SUCCESS) retv = TRUE;
821 else SetLastError( RtlNtStatusToDosError( nts ) );
826 /***********************************************************************
827 * GetProcAddress (KERNEL32.@)
829 * Find the address of an exported symbol in a loaded dll.
832 * hModule [I] Handle to the dll returned by LoadLibraryA().
833 * function [I] Name of the symbol, or an integer ordinal number < 16384
836 * Success: A pointer to the symbol in the process address space.
837 * Failure: NULL. Use GetLastError() to determine the cause.
839 FARPROC WINAPI GetProcAddress( HMODULE hModule, LPCSTR function )
844 if (HIWORD(function))
848 RtlInitAnsiString( &str, function );
849 nts = LdrGetProcedureAddress( hModule, &str, 0, (void**)&fp );
852 nts = LdrGetProcedureAddress( hModule, NULL, (DWORD)function, (void**)&fp );
853 if (nts != STATUS_SUCCESS)
855 SetLastError( RtlNtStatusToDosError( nts ) );
861 /***********************************************************************
862 * GetProcAddress32 (KERNEL.453)
864 * Find the address of an exported symbol in a loaded dll.
867 * hModule [I] Handle to the dll returned by LoadLibraryA().
868 * function [I] Name of the symbol, or an integer ordinal number < 16384
871 * Success: A pointer to the symbol in the process address space.
872 * Failure: NULL. Use GetLastError() to determine the cause.
874 FARPROC WINAPI GetProcAddress32_16( HMODULE hModule, LPCSTR function )
876 /* FIXME: we used to disable snoop when returning proc for Win16 subsystem */
877 return GetProcAddress( hModule, function );