4 * Copyright 1995 Alexandre Julliard
11 #include <sys/types.h>
13 #include "wine/winuser16.h"
14 #include "wine/winbase16.h"
27 #include "selectors.h"
28 #include "stackframe.h"
30 #include "debugtools.h"
32 #include "loadorder.h"
35 DECLARE_DEBUG_CHANNEL(module
)
36 DECLARE_DEBUG_CHANNEL(win32
)
39 /*************************************************************************
40 * MODULE32_LookupHMODULE
41 * looks for the referenced HMODULE in the current process
43 WINE_MODREF
*MODULE32_LookupHMODULE( HMODULE hmod
)
48 return PROCESS_Current()->exe_modref
;
51 ERR_(module
)("tried to lookup 0x%04x in win32 module handler!\n",hmod
);
54 for ( wm
= PROCESS_Current()->modref_list
; wm
; wm
=wm
->next
)
55 if (wm
->module
== hmod
)
60 /*************************************************************************
63 static BOOL
MODULE_InitDll( WINE_MODREF
*wm
, DWORD type
, LPVOID lpReserved
)
67 static LPCSTR typeName
[] = { "PROCESS_DETACH", "PROCESS_ATTACH",
68 "THREAD_ATTACH", "THREAD_DETACH" };
72 /* Skip calls for modules loaded with special load flags */
74 if ( ( wm
->flags
& WINE_MODREF_DONT_RESOLVE_REFS
)
75 || ( wm
->flags
& WINE_MODREF_LOAD_AS_DATAFILE
) )
79 TRACE_(module
)("(%s,%s,%p) - CALL\n",
80 wm
->modname
, typeName
[type
], lpReserved
);
82 /* Call the initialization routine */
86 retv
= PE_InitDLL( wm
, type
, lpReserved
);
90 /* no need to do that, dlopen() already does */
94 ERR_(module
)("wine_modref type %d not handled.\n", wm
->type
);
99 TRACE_(module
)("(%s,%s,%p) - RETURN %d\n",
100 wm
->modname
, typeName
[type
], lpReserved
, retv
);
105 /*************************************************************************
106 * MODULE_DllProcessAttach
108 * Send the process attach notification to all DLLs the given module
109 * depends on (recursively). This is somewhat complicated due to the fact that
111 * - we have to respect the module dependencies, i.e. modules implicitly
112 * referenced by another module have to be initialized before the module
113 * itself can be initialized
115 * - the initialization routine of a DLL can itself call LoadLibrary,
116 * thereby introducing a whole new set of dependencies (even involving
117 * the 'old' modules) at any time during the whole process
119 * (Note that this routine can be recursively entered not only directly
120 * from itself, but also via LoadLibrary from one of the called initialization
123 * Furthermore, we need to rearrange the main WINE_MODREF list to allow
124 * the process *detach* notifications to be sent in the correct order.
125 * This must not only take into account module dependencies, but also
126 * 'hidden' dependencies created by modules calling LoadLibrary in their
127 * attach notification routine.
129 * The strategy is rather simple: we move a WINE_MODREF to the head of the
130 * list after the attach notification has returned. This implies that the
131 * detach notifications are called in the reverse of the sequence the attach
132 * notifications *returned*.
134 * NOTE: Assumes that the process critical section is held!
137 BOOL
MODULE_DllProcessAttach( WINE_MODREF
*wm
, LPVOID lpReserved
)
143 /* prevent infinite recursion in case of cyclical dependencies */
144 if ( ( wm
->flags
& WINE_MODREF_MARKER
)
145 || ( wm
->flags
& WINE_MODREF_PROCESS_ATTACHED
) )
148 TRACE_(module
)("(%s,%p) - START\n",
149 wm
->modname
, lpReserved
);
151 /* Tag current MODREF to prevent recursive loop */
152 wm
->flags
|= WINE_MODREF_MARKER
;
154 /* Recursively attach all DLLs this one depends on */
155 for ( i
= 0; retv
&& i
< wm
->nDeps
; i
++ )
157 retv
= MODULE_DllProcessAttach( wm
->deps
[i
], lpReserved
);
159 /* Call DLL entry point */
162 retv
= MODULE_InitDll( wm
, DLL_PROCESS_ATTACH
, lpReserved
);
164 wm
->flags
|= WINE_MODREF_PROCESS_ATTACHED
;
167 /* Re-insert MODREF at head of list */
168 if ( retv
&& wm
->prev
)
170 wm
->prev
->next
= wm
->next
;
171 if ( wm
->next
) wm
->next
->prev
= wm
->prev
;
174 wm
->next
= PROCESS_Current()->modref_list
;
175 PROCESS_Current()->modref_list
= wm
->next
->prev
= wm
;
178 /* Remove recursion flag */
179 wm
->flags
&= ~WINE_MODREF_MARKER
;
181 TRACE_(module
)("(%s,%p) - END\n",
182 wm
->modname
, lpReserved
);
187 /*************************************************************************
188 * MODULE_DllProcessDetach
190 * Send DLL process detach notifications. See the comment about calling
191 * sequence at MODULE_DllProcessAttach. Unless the bForceDetach flag
192 * is set, only DLLs with zero refcount are notified.
194 * NOTE: Assumes that the process critical section is held!
197 void MODULE_DllProcessDetach( BOOL bForceDetach
, LPVOID lpReserved
)
203 for ( wm
= PROCESS_Current()->modref_list
; wm
; wm
= wm
->next
)
205 /* Check whether to detach this DLL */
206 if ( !(wm
->flags
& WINE_MODREF_PROCESS_ATTACHED
) )
208 if ( wm
->refCount
> 0 && !bForceDetach
)
211 /* Call detach notification */
212 wm
->flags
&= ~WINE_MODREF_PROCESS_ATTACHED
;
213 MODULE_InitDll( wm
, DLL_PROCESS_DETACH
, lpReserved
);
215 /* Restart at head of WINE_MODREF list, as entries might have
216 been added and/or removed while performing the call ... */
222 /*************************************************************************
223 * MODULE_DllThreadAttach
225 * Send DLL thread attach notifications. These are sent in the
226 * reverse sequence of process detach notification.
229 void MODULE_DllThreadAttach( LPVOID lpReserved
)
233 EnterCriticalSection( &PROCESS_Current()->crit_section
);
235 for ( wm
= PROCESS_Current()->modref_list
; wm
; wm
= wm
->next
)
239 for ( ; wm
; wm
= wm
->prev
)
241 if ( !(wm
->flags
& WINE_MODREF_PROCESS_ATTACHED
) )
243 if ( wm
->flags
& WINE_MODREF_NO_DLL_CALLS
)
246 MODULE_InitDll( wm
, DLL_THREAD_ATTACH
, lpReserved
);
249 LeaveCriticalSection( &PROCESS_Current()->crit_section
);
252 /*************************************************************************
253 * MODULE_DllThreadDetach
255 * Send DLL thread detach notifications. These are sent in the
256 * same sequence as process detach notification.
259 void MODULE_DllThreadDetach( LPVOID lpReserved
)
263 EnterCriticalSection( &PROCESS_Current()->crit_section
);
265 for ( wm
= PROCESS_Current()->modref_list
; wm
; wm
= wm
->next
)
267 if ( !(wm
->flags
& WINE_MODREF_PROCESS_ATTACHED
) )
269 if ( wm
->flags
& WINE_MODREF_NO_DLL_CALLS
)
272 MODULE_InitDll( wm
, DLL_THREAD_DETACH
, lpReserved
);
275 LeaveCriticalSection( &PROCESS_Current()->crit_section
);
278 /****************************************************************************
279 * DisableThreadLibraryCalls (KERNEL32.74)
281 * Don't call DllEntryPoint for DLL_THREAD_{ATTACH,DETACH} if set.
283 BOOL WINAPI
DisableThreadLibraryCalls( HMODULE hModule
)
288 EnterCriticalSection( &PROCESS_Current()->crit_section
);
290 wm
= MODULE32_LookupHMODULE( hModule
);
294 wm
->flags
|= WINE_MODREF_NO_DLL_CALLS
;
296 LeaveCriticalSection( &PROCESS_Current()->crit_section
);
302 /***********************************************************************
303 * MODULE_CreateDummyModule
305 * Create a dummy NE module for Win32 or Winelib.
307 HMODULE
MODULE_CreateDummyModule( const OFSTRUCT
*ofs
, LPCSTR modName
)
311 SEGTABLEENTRY
*pSegment
;
314 const char* basename
;
316 INT of_size
= sizeof(OFSTRUCT
) - sizeof(ofs
->szPathName
)
317 + strlen(ofs
->szPathName
) + 1;
318 INT size
= sizeof(NE_MODULE
) +
319 /* loaded file info */
321 /* segment table: DS,CS */
322 2 * sizeof(SEGTABLEENTRY
) +
325 /* several empty tables */
328 hModule
= GlobalAlloc16( GMEM_MOVEABLE
| GMEM_ZEROINIT
, size
);
329 if (!hModule
) return (HMODULE
)11; /* invalid exe */
331 FarSetOwner16( hModule
, hModule
);
332 pModule
= (NE_MODULE
*)GlobalLock16( hModule
);
334 /* Set all used entries */
335 pModule
->magic
= IMAGE_OS2_SIGNATURE
;
342 pModule
->heap_size
= 0;
343 pModule
->stack_size
= 0;
344 pModule
->seg_count
= 2;
345 pModule
->modref_count
= 0;
346 pModule
->nrname_size
= 0;
347 pModule
->fileinfo
= sizeof(NE_MODULE
);
348 pModule
->os_flags
= NE_OSFLAGS_WINDOWS
;
349 pModule
->expected_version
= 0x030a;
350 pModule
->self
= hModule
;
352 /* Set loaded file information */
353 memcpy( pModule
+ 1, ofs
, of_size
);
354 ((OFSTRUCT
*)(pModule
+1))->cBytes
= of_size
- 1;
356 pSegment
= (SEGTABLEENTRY
*)((char*)(pModule
+ 1) + of_size
);
357 pModule
->seg_table
= (int)pSegment
- (int)pModule
;
360 pSegment
->flags
= NE_SEGFLAGS_DATA
;
361 pSegment
->minsize
= 0x1000;
368 pStr
= (char *)pSegment
;
369 pModule
->name_table
= (int)pStr
- (int)pModule
;
374 basename
= strrchr(ofs
->szPathName
,'\\');
375 if (!basename
) basename
= ofs
->szPathName
;
378 len
= strlen(basename
);
379 if ((s
= strchr(basename
,'.'))) len
= s
- basename
;
380 if (len
> 8) len
= 8;
382 strncpy( pStr
+1, basename
, len
);
383 if (len
< 8) pStr
[len
+1] = 0;
386 /* All tables zero terminated */
387 pModule
->res_table
= pModule
->import_table
= pModule
->entry_table
=
388 (int)pStr
- (int)pModule
;
390 NE_RegisterModule( pModule
);
395 /***********************************************************************
396 * MODULE_GetWndProcEntry16 (not a Windows API function)
398 * Return an entry point from the WPROCS dll.
400 FARPROC16
MODULE_GetWndProcEntry16( LPCSTR name
)
402 FARPROC16 ret
= NULL
;
406 /* FIXME: hack for Winelib */
407 extern LRESULT
ColorDlgProc16(HWND16
,UINT16
,WPARAM16
,LPARAM
);
408 extern LRESULT
FileOpenDlgProc16(HWND16
,UINT16
,WPARAM16
,LPARAM
);
409 extern LRESULT
FileSaveDlgProc16(HWND16
,UINT16
,WPARAM16
,LPARAM
);
410 extern LRESULT
FindTextDlgProc16(HWND16
,UINT16
,WPARAM16
,LPARAM
);
411 extern LRESULT
PrintDlgProc16(HWND16
,UINT16
,WPARAM16
,LPARAM
);
412 extern LRESULT
PrintSetupDlgProc16(HWND16
,UINT16
,WPARAM16
,LPARAM
);
413 extern LRESULT
ReplaceTextDlgProc16(HWND16
,UINT16
,WPARAM16
,LPARAM
);
415 if (!strcmp(name
,"ColorDlgProc"))
416 return (FARPROC16
)ColorDlgProc16
;
417 if (!strcmp(name
,"FileOpenDlgProc"))
418 return (FARPROC16
)FileOpenDlgProc16
;
419 if (!strcmp(name
,"FileSaveDlgProc"))
420 return (FARPROC16
)FileSaveDlgProc16
;
421 if (!strcmp(name
,"FindTextDlgProc"))
422 return (FARPROC16
)FindTextDlgProc16
;
423 if (!strcmp(name
,"PrintDlgProc"))
424 return (FARPROC16
)PrintDlgProc16
;
425 if (!strcmp(name
,"PrintSetupDlgProc"))
426 return (FARPROC16
)PrintSetupDlgProc16
;
427 if (!strcmp(name
,"ReplaceTextDlgProc"))
428 return (FARPROC16
)ReplaceTextDlgProc16
;
429 FIXME_(module
)("No mapping for %s(), add one in library/miscstubs.c\n",name
);
436 static HMODULE hModule
= 0;
438 if (!hModule
) hModule
= GetModuleHandle16( "WPROCS" );
439 ordinal
= NE_GetOrdinal( hModule
, name
);
440 if (!(ret
= NE_GetEntryPoint( hModule
, ordinal
)))
442 WARN_(module
)("%s not found\n", name
);
450 /**********************************************************************
451 * MODULE_FindModule32
453 * Find a (loaded) win32 module depending on path
454 * The handling of '.' is a bit weird, but we need it that way,
455 * for sometimes the programs use '<name>.exe' and '<name>.dll' and
456 * this is the only way to differentiate. (mainly hypertrm.exe)
459 * the module handle if found
462 WINE_MODREF
*MODULE_FindModule(
463 LPCSTR path
/* [in] pathname of module/library to be found */
469 if (!(filename
= strrchr( path
, '\\' )))
470 filename
= HEAP_strdupA( GetProcessHeap(), 0, path
);
472 filename
= HEAP_strdupA( GetProcessHeap(), 0, filename
+1 );
473 dotptr
=strrchr(filename
,'.');
475 for ( wm
= PROCESS_Current()->modref_list
; wm
; wm
=wm
->next
) {
476 LPSTR xmodname
,xdotptr
;
478 assert (wm
->modname
);
479 xmodname
= HEAP_strdupA( GetProcessHeap(), 0, wm
->modname
);
480 xdotptr
=strrchr(xmodname
,'.');
481 if ( (xdotptr
&& !dotptr
) ||
484 if (dotptr
) *dotptr
= '\0';
485 if (xdotptr
) *xdotptr
= '\0';
487 if (!strcasecmp( filename
, xmodname
)) {
488 HeapFree( GetProcessHeap(), 0, filename
);
489 HeapFree( GetProcessHeap(), 0, xmodname
);
492 if (dotptr
) *dotptr
='.';
493 /* FIXME: add paths, shortname */
494 HeapFree( GetProcessHeap(), 0, xmodname
);
496 /* if that fails, try looking for the filename... */
497 for ( wm
= PROCESS_Current()->modref_list
; wm
; wm
=wm
->next
) {
498 LPSTR xlname
,xdotptr
;
500 assert (wm
->longname
);
501 xlname
= strrchr(wm
->longname
,'\\');
503 xlname
= wm
->longname
;
506 xlname
= HEAP_strdupA( GetProcessHeap(), 0, xlname
);
507 xdotptr
=strrchr(xlname
,'.');
508 if ( (xdotptr
&& !dotptr
) ||
511 if (dotptr
) *dotptr
= '\0';
512 if (xdotptr
) *xdotptr
= '\0';
514 if (!strcasecmp( filename
, xlname
)) {
515 HeapFree( GetProcessHeap(), 0, filename
);
516 HeapFree( GetProcessHeap(), 0, xlname
);
519 if (dotptr
) *dotptr
='.';
520 /* FIXME: add paths, shortname */
521 HeapFree( GetProcessHeap(), 0, xlname
);
523 HeapFree( GetProcessHeap(), 0, filename
);
527 /***********************************************************************
528 * MODULE_GetBinaryType
530 * The GetBinaryType function determines whether a file is executable
531 * or not and if it is it returns what type of executable it is.
532 * The type of executable is a property that determines in which
533 * subsystem an executable file runs under.
535 * Binary types returned:
536 * SCS_32BIT_BINARY: A Win32 based application
537 * SCS_DOS_BINARY: An MS-Dos based application
538 * SCS_WOW_BINARY: A Win16 based application
539 * SCS_PIF_BINARY: A PIF file that executes an MS-Dos based app
540 * SCS_POSIX_BINARY: A POSIX based application ( Not implemented )
541 * SCS_OS216_BINARY: A 16bit OS/2 based application ( Not implemented )
543 * Returns TRUE if the file is an executable in which case
544 * the value pointed by lpBinaryType is set.
545 * Returns FALSE if the file is not an executable or if the function fails.
547 * To do so it opens the file and reads in the header information
548 * if the extended header information is not presend it will
549 * assume that that the file is a DOS executable.
550 * If the extended header information is present it will
551 * determine if the file is an 16 or 32 bit Windows executable
552 * by check the flags in the header.
554 * Note that .COM and .PIF files are only recognized by their
555 * file name extension; but Windows does it the same way ...
557 static BOOL
MODULE_GetBinaryType( HFILE hfile
, OFSTRUCT
*ofs
,
558 LPDWORD lpBinaryType
)
560 IMAGE_DOS_HEADER mz_header
;
563 /* Seek to the start of the file and read the DOS header information.
565 if ( _llseek( hfile
, 0, SEEK_SET
) >= 0 &&
566 _lread( hfile
, &mz_header
, sizeof(mz_header
) ) == sizeof(mz_header
) )
568 /* Now that we have the header check the e_magic field
569 * to see if this is a dos image.
571 if ( mz_header
.e_magic
== IMAGE_DOS_SIGNATURE
)
573 BOOL lfanewValid
= FALSE
;
574 /* We do have a DOS image so we will now try to seek into
575 * the file by the amount indicated by the field
576 * "Offset to extended header" and read in the
577 * "magic" field information at that location.
578 * This will tell us if there is more header information
581 /* But before we do we will make sure that header
582 * structure encompasses the "Offset to extended header"
585 if ( (mz_header
.e_cparhdr
<<4) >= sizeof(IMAGE_DOS_HEADER
) )
586 if ( ( mz_header
.e_crlc
== 0 && mz_header
.e_lfarlc
== 0 ) ||
587 ( mz_header
.e_lfarlc
>= sizeof(IMAGE_DOS_HEADER
) ) )
588 if ( mz_header
.e_lfanew
>= sizeof(IMAGE_DOS_HEADER
) &&
589 _llseek( hfile
, mz_header
.e_lfanew
, SEEK_SET
) >= 0 &&
590 _lread( hfile
, magic
, sizeof(magic
) ) == sizeof(magic
) )
595 /* If we cannot read this "extended header" we will
596 * assume that we have a simple DOS executable.
598 *lpBinaryType
= SCS_DOS_BINARY
;
603 /* Reading the magic field succeeded so
604 * we will try to determine what type it is.
606 if ( *(DWORD
*)magic
== IMAGE_NT_SIGNATURE
)
608 /* This is an NT signature.
610 *lpBinaryType
= SCS_32BIT_BINARY
;
613 else if ( *(WORD
*)magic
== IMAGE_OS2_SIGNATURE
)
615 /* The IMAGE_OS2_SIGNATURE indicates that the
616 * "extended header is a Windows executable (NE)
617 * header. This is a bit misleading, but it is
618 * documented in the SDK. ( for more details see
621 *lpBinaryType
= SCS_WOW_BINARY
;
626 /* Unknown extended header, so abort.
634 /* If we get here, we don't even have a correct MZ header.
635 * Try to check the file extension for known types ...
637 ptr
= strrchr( ofs
->szPathName
, '.' );
638 if ( ptr
&& !strchr( ptr
, '\\' ) && !strchr( ptr
, '/' ) )
640 if ( !lstrcmpiA( ptr
, ".COM" ) )
642 *lpBinaryType
= SCS_DOS_BINARY
;
646 if ( !lstrcmpiA( ptr
, ".PIF" ) )
648 *lpBinaryType
= SCS_PIF_BINARY
;
656 /***********************************************************************
657 * GetBinaryTypeA [KERNEL32.280]
659 BOOL WINAPI
GetBinaryTypeA( LPCSTR lpApplicationName
, LPDWORD lpBinaryType
)
665 TRACE_(win32
)("%s\n", lpApplicationName
);
669 if ( lpApplicationName
== NULL
|| lpBinaryType
== NULL
)
672 /* Open the file indicated by lpApplicationName for reading.
674 if ( (hfile
= OpenFile( lpApplicationName
, &ofs
, OF_READ
)) == HFILE_ERROR
)
679 ret
= MODULE_GetBinaryType( hfile
, &ofs
, lpBinaryType
);
683 CloseHandle( hfile
);
688 /***********************************************************************
689 * GetBinaryTypeW [KERNEL32.281]
691 BOOL WINAPI
GetBinaryTypeW( LPCWSTR lpApplicationName
, LPDWORD lpBinaryType
)
696 TRACE_(win32
)("%s\n", debugstr_w(lpApplicationName
) );
700 if ( lpApplicationName
== NULL
|| lpBinaryType
== NULL
)
703 /* Convert the wide string to a ascii string.
705 strNew
= HEAP_strdupWtoA( GetProcessHeap(), 0, lpApplicationName
);
707 if ( strNew
!= NULL
)
709 ret
= GetBinaryTypeA( strNew
, lpBinaryType
);
711 /* Free the allocated string.
713 HeapFree( GetProcessHeap(), 0, strNew
);
719 /**********************************************************************
720 * MODULE_CreateUnixProcess
722 static BOOL
MODULE_CreateUnixProcess( LPCSTR filename
, LPCSTR lpCmdLine
,
723 LPSTARTUPINFOA lpStartupInfo
,
724 LPPROCESS_INFORMATION lpProcessInfo
,
727 DOS_FULL_NAME full_name
;
728 const char *unixfilename
= filename
;
729 const char *argv
[256], **argptr
;
732 /* Get Unix file name and iconic flag */
734 if ( lpStartupInfo
->dwFlags
& STARTF_USESHOWWINDOW
)
735 if ( lpStartupInfo
->wShowWindow
== SW_SHOWMINIMIZED
736 || lpStartupInfo
->wShowWindow
== SW_SHOWMINNOACTIVE
)
739 if ( strchr(filename
, '/')
740 || strchr(filename
, ':')
741 || strchr(filename
, '\\') )
743 if ( DOSFS_GetFullName( filename
, TRUE
, &full_name
) )
744 unixfilename
= full_name
.long_name
;
749 SetLastError( ERROR_FILE_NOT_FOUND
);
753 /* Build argument list */
758 char *p
= strdup(lpCmdLine
);
759 *argptr
++ = unixfilename
;
760 if (iconic
) *argptr
++ = "-iconic";
763 while (*p
&& (*p
== ' ' || *p
== '\t')) *p
++ = '\0';
766 while (*p
&& *p
!= ' ' && *p
!= '\t') p
++;
772 if (iconic
) *argptr
++ = "-iconic";
773 *argptr
++ = lpCmdLine
;
777 /* Fork and execute */
781 /* Note: don't use Wine routines here, as this process
782 has not been correctly initialized! */
784 execvp( argv
[0], (char**)argv
);
788 fprintf( stderr
, "CreateProcess: can't exec 'wine %s'\n",
793 /* Fake success return value */
795 memset( lpProcessInfo
, '\0', sizeof( *lpProcessInfo
) );
796 lpProcessInfo
->hProcess
= INVALID_HANDLE_VALUE
;
797 lpProcessInfo
->hThread
= INVALID_HANDLE_VALUE
;
799 SetLastError( ERROR_SUCCESS
);
803 /***********************************************************************
804 * WinExec16 (KERNEL.166)
806 HINSTANCE16 WINAPI
WinExec16( LPCSTR lpCmdLine
, UINT16 nCmdShow
)
810 SYSLEVEL_ReleaseWin16Lock();
811 hInst
= WinExec( lpCmdLine
, nCmdShow
);
812 SYSLEVEL_RestoreWin16Lock();
817 /***********************************************************************
818 * WinExec (KERNEL32.566)
820 HINSTANCE WINAPI
WinExec( LPCSTR lpCmdLine
, UINT nCmdShow
)
823 UINT16 paramCmdShow
[2];
826 return 2; /* File not found */
828 /* Set up LOADPARAMS buffer for LoadModule */
830 memset( ¶ms
, '\0', sizeof(params
) );
831 params
.lpCmdLine
= (LPSTR
)lpCmdLine
;
832 params
.lpCmdShow
= paramCmdShow
;
833 params
.lpCmdShow
[0] = 2;
834 params
.lpCmdShow
[1] = nCmdShow
;
836 /* Now load the executable file */
838 return LoadModule( NULL
, ¶ms
);
841 /**********************************************************************
842 * LoadModule (KERNEL32.499)
844 HINSTANCE WINAPI
LoadModule( LPCSTR name
, LPVOID paramBlock
)
846 LOADPARAMS
*params
= (LOADPARAMS
*)paramBlock
;
847 PROCESS_INFORMATION info
;
848 STARTUPINFOA startup
;
853 memset( &startup
, '\0', sizeof(startup
) );
854 startup
.cb
= sizeof(startup
);
855 startup
.dwFlags
= STARTF_USESHOWWINDOW
;
856 startup
.wShowWindow
= params
->lpCmdShow
? params
->lpCmdShow
[1] : 0;
858 if ( !CreateProcessA( name
, params
->lpCmdLine
,
859 NULL
, NULL
, FALSE
, 0, params
->lpEnvAddress
,
860 NULL
, &startup
, &info
) )
862 hInstance
= GetLastError();
863 if ( hInstance
< 32 ) return hInstance
;
865 FIXME_(module
)("Strange error set by CreateProcess: %d\n", hInstance
);
869 /* Get 16-bit hInstance/hTask from process */
870 pdb
= PROCESS_IdToPDB( info
.dwProcessId
);
871 tdb
= pdb
? (TDB
*)GlobalLock16( pdb
->task
) : NULL
;
872 hInstance
= tdb
&& tdb
->hInstance
? tdb
->hInstance
: pdb
? pdb
->task
: 0;
873 /* If there is no hInstance (32-bit process) return a dummy value
875 * FIXME: should do this in all cases and fix Win16 callers */
876 if (!hInstance
) hInstance
= 33;
878 /* Close off the handles */
879 CloseHandle( info
.hThread
);
880 CloseHandle( info
.hProcess
);
885 /*************************************************************************
886 * get_executable_name
888 * Try longer and longer strings from "line" to find an existing
889 * file name. Each attempt is delimited by a blank outside of quotes.
890 * Also will attempt to append ".exe" if requested and not already
891 * present. Returns the address of the remaining portion of the
896 static void get_executable_name( LPCSTR line
, LPSTR name
, int namelen
,
897 LPCSTR
*after
, BOOL extension
)
901 LPSTR to
, to_end
, to_old
;
904 to_end
= to
+ namelen
- 1;
907 while ( *line
== ' ' ) line
++; /* point to beginning of string */
911 /* Copy all input till end, blank, or quote */
912 while((*from
!= 0) && (*from
!= ' ') && (*from
!= '"') && (to
< to_end
))
914 if (to
>= to_end
) { *to
= 0; pcmd
= from
; break; }
918 /* Handle quoted string. If there is a closing quote, copy all */
919 /* that is inside. */
921 if (!strchr(from
, '"'))
923 /* fail - no closing quote */
924 to
= to_old
; /* restore to previous attempt */
925 *to
= 0; /* end string */
926 break; /* exit with previous attempt */
928 while((*from
!= '"') && (to
< to_end
)) *to
++ = *from
++;
929 if (to
>= to_end
) { *to
= 0; pcmd
= from
; break; }
931 continue; /* past quoted string, so restart from top */
934 *to
= 0; /* terminate output string */
935 to_old
= to
; /* save for possible use in unmatched quote case */
938 /* Input termination is a blank. Try this file name */
940 /* Append ".exe" if necessary and space permits */
941 if ( (to
-name
) < namelen
-4)
943 if(extension
&& (strrchr(name
, '.') <= strrchr(name
, '\\')) )
944 strcat(name
, ".exe");
947 TRACE_(module
)("checking if file exists '%s'\n", name
);
949 if (GetFileAttributesA(name
)!=-1)
950 break; /* if file exists then all done */
952 /* loop around keeping the blank as part of file name */
954 break; /* exit if out of input string */
956 *to
++ = *from
++; /* move in blank and restart */
959 if (after
) *after
= pcmd
;
960 TRACE_(module
)("selected as file name '%s'\n and cmdline as %s\n",
961 name
, debugstr_a(pcmd
));
964 /*************************************************************************
965 * make_executable_name
967 * Scan input string (the lpApplicationName) and remove any quotes
968 * if they are balanced. Also will attempt to append ".exe" if requested
969 * and not already present.
973 static void make_executable_name( LPCSTR line
, LPSTR name
, int namelen
,
977 LPSTR to
, to_end
, to_old
;
980 to_end
= to
+ namelen
- 1;
983 while ( *line
== ' ' ) line
++; /* point to beginning of string */
986 /* Copy all input till end, blank, or quote */
987 while((*from
!= 0) && (*from
!= '"') && (to
< to_end
))
989 if (to
>= to_end
) { *to
= 0; break; }
993 /* Handle quoted string. If there is a closing quote, copy all */
994 /* that is inside. */
996 if (!strchr(from
, '"'))
998 /* fail - no closing quote */
999 to
= to_old
; /* restore to previous attempt */
1000 *to
= 0; /* end string */
1001 break; /* exit with previous attempt */
1003 while((*from
!= '"') && (to
< to_end
)) *to
++ = *from
++;
1004 if (to
>= to_end
) { *to
= 0; break; }
1006 continue; /* past quoted string, so restart from top */
1009 *to
= 0; /* terminate output string */
1010 to_old
= to
; /* save for possible use in unmatched quote case */
1012 /* loop around keeping the blank as part of file name */
1014 break; /* exit if out of input string */
1016 *to
++ = *from
++; /* move in blank and restart */
1019 /* Append ".exe" if necessary and space permits */
1020 if ( (to
-name
) < namelen
-4)
1022 if(extension
&& (strrchr(name
, '.') <= strrchr(name
, '\\')) )
1023 strcat(name
, ".exe");
1026 TRACE_(module
)("selected as file name '%s'\n", name
);
1029 /**********************************************************************
1030 * CreateProcessA (KERNEL32.171)
1032 BOOL WINAPI
CreateProcessA( LPCSTR lpApplicationName
, LPSTR lpCommandLine
,
1033 LPSECURITY_ATTRIBUTES lpProcessAttributes
,
1034 LPSECURITY_ATTRIBUTES lpThreadAttributes
,
1035 BOOL bInheritHandles
, DWORD dwCreationFlags
,
1036 LPVOID lpEnvironment
, LPCSTR lpCurrentDirectory
,
1037 LPSTARTUPINFOA lpStartupInfo
,
1038 LPPROCESS_INFORMATION lpProcessInfo
)
1045 LPCSTR cmdline
= NULL
;
1047 /* Get name and command line */
1049 if (!lpApplicationName
&& !lpCommandLine
)
1051 SetLastError( ERROR_FILE_NOT_FOUND
);
1057 if (lpApplicationName
) {
1058 make_executable_name( lpApplicationName
, name
, sizeof(name
), TRUE
);
1059 cmdline
= (lpCommandLine
) ? lpCommandLine
: lpApplicationName
;
1062 get_executable_name( lpCommandLine
, name
, sizeof ( name
), &cmdline
, TRUE
);
1065 /* Warn if unsupported features are used */
1067 if (dwCreationFlags
& DEBUG_PROCESS
)
1068 FIXME_(module
)("(%s,...): DEBUG_PROCESS ignored\n", name
);
1069 if (dwCreationFlags
& DEBUG_ONLY_THIS_PROCESS
)
1070 FIXME_(module
)("(%s,...): DEBUG_ONLY_THIS_PROCESS ignored\n", name
);
1071 if (dwCreationFlags
& CREATE_SUSPENDED
)
1072 FIXME_(module
)("(%s,...): CREATE_SUSPENDED ignored\n", name
);
1073 if (dwCreationFlags
& DETACHED_PROCESS
)
1074 FIXME_(module
)("(%s,...): DETACHED_PROCESS ignored\n", name
);
1075 if (dwCreationFlags
& CREATE_NEW_CONSOLE
)
1076 FIXME_(module
)("(%s,...): CREATE_NEW_CONSOLE ignored\n", name
);
1077 if (dwCreationFlags
& NORMAL_PRIORITY_CLASS
)
1078 FIXME_(module
)("(%s,...): NORMAL_PRIORITY_CLASS ignored\n", name
);
1079 if (dwCreationFlags
& IDLE_PRIORITY_CLASS
)
1080 FIXME_(module
)("(%s,...): IDLE_PRIORITY_CLASS ignored\n", name
);
1081 if (dwCreationFlags
& HIGH_PRIORITY_CLASS
)
1082 FIXME_(module
)("(%s,...): HIGH_PRIORITY_CLASS ignored\n", name
);
1083 if (dwCreationFlags
& REALTIME_PRIORITY_CLASS
)
1084 FIXME_(module
)("(%s,...): REALTIME_PRIORITY_CLASS ignored\n", name
);
1085 if (dwCreationFlags
& CREATE_NEW_PROCESS_GROUP
)
1086 FIXME_(module
)("(%s,...): CREATE_NEW_PROCESS_GROUP ignored\n", name
);
1087 if (dwCreationFlags
& CREATE_UNICODE_ENVIRONMENT
)
1088 FIXME_(module
)("(%s,...): CREATE_UNICODE_ENVIRONMENT ignored\n", name
);
1089 if (dwCreationFlags
& CREATE_SEPARATE_WOW_VDM
)
1090 FIXME_(module
)("(%s,...): CREATE_SEPARATE_WOW_VDM ignored\n", name
);
1091 if (dwCreationFlags
& CREATE_SHARED_WOW_VDM
)
1092 FIXME_(module
)("(%s,...): CREATE_SHARED_WOW_VDM ignored\n", name
);
1093 if (dwCreationFlags
& CREATE_DEFAULT_ERROR_MODE
)
1094 FIXME_(module
)("(%s,...): CREATE_DEFAULT_ERROR_MODE ignored\n", name
);
1095 if (dwCreationFlags
& CREATE_NO_WINDOW
)
1096 FIXME_(module
)("(%s,...): CREATE_NO_WINDOW ignored\n", name
);
1097 if (dwCreationFlags
& PROFILE_USER
)
1098 FIXME_(module
)("(%s,...): PROFILE_USER ignored\n", name
);
1099 if (dwCreationFlags
& PROFILE_KERNEL
)
1100 FIXME_(module
)("(%s,...): PROFILE_KERNEL ignored\n", name
);
1101 if (dwCreationFlags
& PROFILE_SERVER
)
1102 FIXME_(module
)("(%s,...): PROFILE_SERVER ignored\n", name
);
1103 if (lpCurrentDirectory
)
1104 FIXME_(module
)("(%s,...): lpCurrentDirectory %s ignored\n",
1105 name
, lpCurrentDirectory
);
1106 if (lpStartupInfo
->lpDesktop
)
1107 FIXME_(module
)("(%s,...): lpStartupInfo->lpDesktop %s ignored\n",
1108 name
, lpStartupInfo
->lpDesktop
);
1109 if (lpStartupInfo
->lpTitle
)
1110 FIXME_(module
)("(%s,...): lpStartupInfo->lpTitle %s ignored\n",
1111 name
, lpStartupInfo
->lpTitle
);
1112 if (lpStartupInfo
->dwFlags
& STARTF_USECOUNTCHARS
)
1113 FIXME_(module
)("(%s,...): STARTF_USECOUNTCHARS (%ld,%ld) ignored\n",
1114 name
, lpStartupInfo
->dwXCountChars
, lpStartupInfo
->dwYCountChars
);
1115 if (lpStartupInfo
->dwFlags
& STARTF_USEFILLATTRIBUTE
)
1116 FIXME_(module
)("(%s,...): STARTF_USEFILLATTRIBUTE %lx ignored\n",
1117 name
, lpStartupInfo
->dwFillAttribute
);
1118 if (lpStartupInfo
->dwFlags
& STARTF_RUNFULLSCREEN
)
1119 FIXME_(module
)("(%s,...): STARTF_RUNFULLSCREEN ignored\n", name
);
1120 if (lpStartupInfo
->dwFlags
& STARTF_FORCEONFEEDBACK
)
1121 FIXME_(module
)("(%s,...): STARTF_FORCEONFEEDBACK ignored\n", name
);
1122 if (lpStartupInfo
->dwFlags
& STARTF_FORCEOFFFEEDBACK
)
1123 FIXME_(module
)("(%s,...): STARTF_FORCEOFFFEEDBACK ignored\n", name
);
1124 if (lpStartupInfo
->dwFlags
& STARTF_USEHOTKEY
)
1125 FIXME_(module
)("(%s,...): STARTF_USEHOTKEY ignored\n", name
);
1128 /* When in WineLib, always fork new Unix process */
1131 return MODULE_CreateUnixProcess( name
, cmdline
,
1132 lpStartupInfo
, lpProcessInfo
, TRUE
);
1134 /* Check for special case: second instance of NE module */
1136 lstrcpynA( ofs
.szPathName
, name
, sizeof( ofs
.szPathName
) );
1137 retv
= NE_CreateProcess( HFILE_ERROR
, &ofs
, cmdline
, lpEnvironment
,
1138 lpProcessAttributes
, lpThreadAttributes
,
1139 bInheritHandles
, lpStartupInfo
, lpProcessInfo
);
1141 /* Load file and create process */
1145 /* Open file and determine executable type */
1147 if ( (hFile
= OpenFile( name
, &ofs
, OF_READ
)) == HFILE_ERROR
)
1149 SetLastError( ERROR_FILE_NOT_FOUND
);
1153 if ( !MODULE_GetBinaryType( hFile
, &ofs
, &type
) )
1155 CloseHandle( hFile
);
1157 /* FIXME: Try Unix executable only when appropriate! */
1158 if ( MODULE_CreateUnixProcess( name
, cmdline
,
1159 lpStartupInfo
, lpProcessInfo
, FALSE
) )
1162 SetLastError( ERROR_BAD_FORMAT
);
1167 /* Create process */
1171 case SCS_32BIT_BINARY
:
1172 retv
= PE_CreateProcess( hFile
, &ofs
, cmdline
, lpEnvironment
,
1173 lpProcessAttributes
, lpThreadAttributes
,
1174 bInheritHandles
, lpStartupInfo
, lpProcessInfo
);
1177 case SCS_DOS_BINARY
:
1178 retv
= MZ_CreateProcess( hFile
, &ofs
, cmdline
, lpEnvironment
,
1179 lpProcessAttributes
, lpThreadAttributes
,
1180 bInheritHandles
, lpStartupInfo
, lpProcessInfo
);
1183 case SCS_WOW_BINARY
:
1184 retv
= NE_CreateProcess( hFile
, &ofs
, cmdline
, lpEnvironment
,
1185 lpProcessAttributes
, lpThreadAttributes
,
1186 bInheritHandles
, lpStartupInfo
, lpProcessInfo
);
1189 case SCS_PIF_BINARY
:
1190 case SCS_POSIX_BINARY
:
1191 case SCS_OS216_BINARY
:
1192 FIXME_(module
)("Unsupported executable type: %ld\n", type
);
1196 SetLastError( ERROR_BAD_FORMAT
);
1201 CloseHandle( hFile
);
1206 /**********************************************************************
1207 * CreateProcessW (KERNEL32.172)
1209 * lpReserved is not converted
1211 BOOL WINAPI
CreateProcessW( LPCWSTR lpApplicationName
, LPWSTR lpCommandLine
,
1212 LPSECURITY_ATTRIBUTES lpProcessAttributes
,
1213 LPSECURITY_ATTRIBUTES lpThreadAttributes
,
1214 BOOL bInheritHandles
, DWORD dwCreationFlags
,
1215 LPVOID lpEnvironment
, LPCWSTR lpCurrentDirectory
,
1216 LPSTARTUPINFOW lpStartupInfo
,
1217 LPPROCESS_INFORMATION lpProcessInfo
)
1219 STARTUPINFOA StartupInfoA
;
1221 LPSTR lpApplicationNameA
= HEAP_strdupWtoA (GetProcessHeap(),0,lpApplicationName
);
1222 LPSTR lpCommandLineA
= HEAP_strdupWtoA (GetProcessHeap(),0,lpCommandLine
);
1223 LPSTR lpCurrentDirectoryA
= HEAP_strdupWtoA (GetProcessHeap(),0,lpCurrentDirectory
);
1225 memcpy (&StartupInfoA
, lpStartupInfo
, sizeof(STARTUPINFOA
));
1226 StartupInfoA
.lpDesktop
= HEAP_strdupWtoA (GetProcessHeap(),0,lpStartupInfo
->lpDesktop
);
1227 StartupInfoA
.lpTitle
= HEAP_strdupWtoA (GetProcessHeap(),0,lpStartupInfo
->lpTitle
);
1229 TRACE_(win32
)("(%s,%s,...)\n", debugstr_w(lpApplicationName
), debugstr_w(lpCommandLine
));
1231 if (lpStartupInfo
->lpReserved
)
1232 FIXME_(win32
)("StartupInfo.lpReserved is used, please report (%s)\n", debugstr_w(lpStartupInfo
->lpReserved
));
1234 ret
= CreateProcessA( lpApplicationNameA
, lpCommandLineA
,
1235 lpProcessAttributes
, lpThreadAttributes
,
1236 bInheritHandles
, dwCreationFlags
,
1237 lpEnvironment
, lpCurrentDirectoryA
,
1238 &StartupInfoA
, lpProcessInfo
);
1240 HeapFree( GetProcessHeap(), 0, lpCurrentDirectoryA
);
1241 HeapFree( GetProcessHeap(), 0, lpCommandLineA
);
1242 HeapFree( GetProcessHeap(), 0, StartupInfoA
.lpDesktop
);
1243 HeapFree( GetProcessHeap(), 0, StartupInfoA
.lpTitle
);
1248 /***********************************************************************
1249 * GetModuleHandle (KERNEL32.237)
1251 HMODULE WINAPI
GetModuleHandleA(LPCSTR module
)
1255 if ( module
== NULL
)
1256 wm
= PROCESS_Current()->exe_modref
;
1258 wm
= MODULE_FindModule( module
);
1260 return wm
? wm
->module
: 0;
1263 HMODULE WINAPI
GetModuleHandleW(LPCWSTR module
)
1266 LPSTR modulea
= HEAP_strdupWtoA( GetProcessHeap(), 0, module
);
1267 hModule
= GetModuleHandleA( modulea
);
1268 HeapFree( GetProcessHeap(), 0, modulea
);
1273 /***********************************************************************
1274 * GetModuleFileName32A (KERNEL32.235)
1276 DWORD WINAPI
GetModuleFileNameA(
1277 HMODULE hModule
, /* [in] module handle (32bit) */
1278 LPSTR lpFileName
, /* [out] filenamebuffer */
1279 DWORD size
/* [in] size of filenamebuffer */
1281 WINE_MODREF
*wm
= MODULE32_LookupHMODULE( hModule
);
1283 if (!wm
) /* can happen on start up or the like */
1286 if (PE_HEADER(wm
->module
)->OptionalHeader
.MajorOperatingSystemVersion
>= 4.0)
1287 lstrcpynA( lpFileName
, wm
->longname
, size
);
1289 lstrcpynA( lpFileName
, wm
->shortname
, size
);
1291 TRACE_(module
)("%s\n", lpFileName
);
1292 return strlen(lpFileName
);
1296 /***********************************************************************
1297 * GetModuleFileName32W (KERNEL32.236)
1299 DWORD WINAPI
GetModuleFileNameW( HMODULE hModule
, LPWSTR lpFileName
,
1302 LPSTR fnA
= (char*)HeapAlloc( GetProcessHeap(), 0, size
);
1303 DWORD res
= GetModuleFileNameA( hModule
, fnA
, size
);
1304 lstrcpynAtoW( lpFileName
, fnA
, size
);
1305 HeapFree( GetProcessHeap(), 0, fnA
);
1310 /***********************************************************************
1311 * LoadLibraryEx32W (KERNEL.513)
1314 HMODULE WINAPI
LoadLibraryEx32W16( LPCSTR libname
, HANDLE16 hf
,
1317 TRACE_(module
)("(%s,%d,%08lx)\n",libname
,hf
,flags
);
1318 return LoadLibraryExA(libname
, hf
,flags
);
1321 /***********************************************************************
1322 * LoadLibraryExA (KERNEL32)
1324 HMODULE WINAPI
LoadLibraryExA(LPCSTR libname
, HFILE hfile
, DWORD flags
)
1330 SetLastError(ERROR_INVALID_PARAMETER
);
1334 EnterCriticalSection(&PROCESS_Current()->crit_section
);
1336 wm
= MODULE_LoadLibraryExA( libname
, hfile
, flags
);
1338 if(wm
&& !MODULE_DllProcessAttach(wm
, NULL
))
1340 WARN_(module
)("Attach failed for module '%s', \n", libname
);
1341 MODULE_FreeLibrary(wm
);
1342 SetLastError(ERROR_DLL_INIT_FAILED
);
1346 LeaveCriticalSection(&PROCESS_Current()->crit_section
);
1348 return wm
? wm
->module
: 0;
1351 /***********************************************************************
1352 * MODULE_LoadLibraryExA (internal)
1354 * Load a PE style module according to the load order.
1356 * The HFILE parameter is not used and marked reserved in the SDK. I can
1357 * only guess that it should force a file to be mapped, but I rather
1358 * ignore the parameter because it would be extremely difficult to
1359 * integrate this with different types of module represenations.
1362 WINE_MODREF
*MODULE_LoadLibraryExA( LPCSTR libname
, HFILE hfile
, DWORD flags
)
1367 module_loadorder_t
*plo
;
1369 EnterCriticalSection(&PROCESS_Current()->crit_section
);
1371 /* Check for already loaded module */
1372 if((pwm
= MODULE_FindModule(libname
)))
1374 if(!(pwm
->flags
& WINE_MODREF_MARKER
))
1376 TRACE_(module
)("Already loaded module '%s' at 0x%08x, count=%d, \n", libname
, pwm
->module
, pwm
->refCount
);
1377 LeaveCriticalSection(&PROCESS_Current()->crit_section
);
1381 plo
= MODULE_GetLoadOrder(libname
);
1383 for(i
= 0; i
< MODULE_LOADORDER_NTYPES
; i
++)
1385 switch(plo
->loadorder
[i
])
1387 case MODULE_LOADORDER_DLL
:
1388 TRACE_(module
)("Trying native dll '%s'\n", libname
);
1389 pwm
= PE_LoadLibraryExA(libname
, flags
, &err
);
1392 case MODULE_LOADORDER_ELFDLL
:
1393 TRACE_(module
)("Trying elfdll '%s'\n", libname
);
1394 pwm
= ELFDLL_LoadLibraryExA(libname
, flags
, &err
);
1397 case MODULE_LOADORDER_SO
:
1398 TRACE_(module
)("Trying so-library '%s'\n", libname
);
1399 pwm
= ELF_LoadLibraryExA(libname
, flags
, &err
);
1402 case MODULE_LOADORDER_BI
:
1403 TRACE_(module
)("Trying built-in '%s'\n", libname
);
1404 pwm
= BUILTIN32_LoadLibraryExA(libname
, flags
, &err
);
1408 ERR_(module
)("Got invalid loadorder type %d (%s index %d)\n", plo
->loadorder
[i
], plo
->modulename
, i
);
1411 case MODULE_LOADORDER_INVALID
: /* We ignore this as it is an empty entry */
1418 /* Initialize DLL just loaded */
1419 TRACE_(module
)("Loaded module '%s' at 0x%08x, \n", libname
, pwm
->module
);
1421 /* Set the refCount here so that an attach failure will */
1422 /* decrement the dependencies through the MODULE_FreeLibrary call. */
1425 LeaveCriticalSection(&PROCESS_Current()->crit_section
);
1429 if(err
!= ERROR_FILE_NOT_FOUND
)
1433 ERR_(module
)("Failed to load module '%s'; error=0x%08lx, \n", libname
, err
);
1435 LeaveCriticalSection(&PROCESS_Current()->crit_section
);
1439 /***********************************************************************
1440 * LoadLibraryA (KERNEL32)
1442 HMODULE WINAPI
LoadLibraryA(LPCSTR libname
) {
1443 return LoadLibraryExA(libname
,0,0);
1446 /***********************************************************************
1447 * LoadLibraryW (KERNEL32)
1449 HMODULE WINAPI
LoadLibraryW(LPCWSTR libnameW
)
1451 return LoadLibraryExW(libnameW
,0,0);
1454 /***********************************************************************
1455 * LoadLibraryExW (KERNEL32)
1457 HMODULE WINAPI
LoadLibraryExW(LPCWSTR libnameW
,HFILE hfile
,DWORD flags
)
1459 LPSTR libnameA
= HEAP_strdupWtoA( GetProcessHeap(), 0, libnameW
);
1460 HMODULE ret
= LoadLibraryExA( libnameA
, hfile
, flags
);
1462 HeapFree( GetProcessHeap(), 0, libnameA
);
1466 /***********************************************************************
1467 * MODULE_FlushModrefs
1469 * NOTE: Assumes that the process critical section is held!
1471 * Remove all unused modrefs and call the internal unloading routines
1472 * for the library type.
1474 static void MODULE_FlushModrefs(void)
1476 WINE_MODREF
*wm
, *next
;
1478 for(wm
= PROCESS_Current()->modref_list
; wm
; wm
= next
)
1485 /* Unlink this modref from the chain */
1487 wm
->next
->prev
= wm
->prev
;
1489 wm
->prev
->next
= wm
->next
;
1490 if(wm
== PROCESS_Current()->modref_list
)
1491 PROCESS_Current()->modref_list
= wm
->next
;
1494 * The unloaders are also responsible for freeing the modref itself
1495 * because the loaders were responsible for allocating it.
1499 case MODULE32_PE
: PE_UnloadLibrary(wm
); break;
1500 case MODULE32_ELF
: ELF_UnloadLibrary(wm
); break;
1501 case MODULE32_ELFDLL
: ELFDLL_UnloadLibrary(wm
); break;
1502 case MODULE32_BI
: BUILTIN32_UnloadLibrary(wm
); break;
1505 ERR_(module
)("Invalid or unhandled MODREF type %d encountered (wm=%p)\n", wm
->type
, wm
);
1510 /***********************************************************************
1513 BOOL WINAPI
FreeLibrary(HINSTANCE hLibModule
)
1518 EnterCriticalSection( &PROCESS_Current()->crit_section
);
1520 wm
= MODULE32_LookupHMODULE( hLibModule
);
1522 SetLastError( ERROR_INVALID_HANDLE
);
1524 retv
= MODULE_FreeLibrary( wm
);
1526 LeaveCriticalSection( &PROCESS_Current()->crit_section
);
1531 /***********************************************************************
1532 * MODULE_DecRefCount
1534 * NOTE: Assumes that the process critical section is held!
1536 static void MODULE_DecRefCount( WINE_MODREF
*wm
)
1540 if ( wm
->flags
& WINE_MODREF_MARKER
)
1543 if ( wm
->refCount
<= 0 )
1547 TRACE_(module
)("(%s) refCount: %d\n", wm
->modname
, wm
->refCount
);
1549 if ( wm
->refCount
== 0 )
1551 wm
->flags
|= WINE_MODREF_MARKER
;
1553 for ( i
= 0; i
< wm
->nDeps
; i
++ )
1555 MODULE_DecRefCount( wm
->deps
[i
] );
1557 wm
->flags
&= ~WINE_MODREF_MARKER
;
1561 /***********************************************************************
1562 * MODULE_FreeLibrary
1564 * NOTE: Assumes that the process critical section is held!
1566 BOOL
MODULE_FreeLibrary( WINE_MODREF
*wm
)
1568 TRACE_(module
)("(%s) - START\n", wm
->modname
);
1570 /* Recursively decrement reference counts */
1571 MODULE_DecRefCount( wm
);
1573 /* Call process detach notifications */
1574 MODULE_DllProcessDetach( FALSE
, NULL
);
1576 MODULE_FlushModrefs();
1578 TRACE_(module
)("(%s) - END\n", wm
->modname
);
1584 /***********************************************************************
1585 * FreeLibraryAndExitThread
1587 VOID WINAPI
FreeLibraryAndExitThread(HINSTANCE hLibModule
, DWORD dwExitCode
)
1589 FreeLibrary(hLibModule
);
1590 ExitThread(dwExitCode
);
1593 /***********************************************************************
1594 * PrivateLoadLibrary (KERNEL32)
1596 * FIXME: rough guesswork, don't know what "Private" means
1598 HINSTANCE WINAPI
PrivateLoadLibrary(LPCSTR libname
)
1600 return (HINSTANCE
)LoadLibrary16(libname
);
1605 /***********************************************************************
1606 * PrivateFreeLibrary (KERNEL32)
1608 * FIXME: rough guesswork, don't know what "Private" means
1610 void WINAPI
PrivateFreeLibrary(HINSTANCE handle
)
1612 FreeLibrary16((HINSTANCE16
)handle
);
1616 /***********************************************************************
1617 * WIN32_GetProcAddress16 (KERNEL32.36)
1618 * Get procaddress in 16bit module from win32... (kernel32 undoc. ordinal func)
1620 FARPROC16 WINAPI
WIN32_GetProcAddress16( HMODULE hModule
, LPCSTR name
)
1626 WARN_(module
)("hModule may not be 0!\n");
1627 return (FARPROC16
)0;
1629 if (HIWORD(hModule
))
1631 WARN_(module
)("hModule is Win32 handle (%08x)\n", hModule
);
1632 return (FARPROC16
)0;
1634 hModule
= GetExePtr( hModule
);
1636 ordinal
= NE_GetOrdinal( hModule
, name
);
1637 TRACE_(module
)("%04x '%s'\n",
1640 ordinal
= LOWORD(name
);
1641 TRACE_(module
)("%04x %04x\n",
1644 if (!ordinal
) return (FARPROC16
)0;
1645 ret
= NE_GetEntryPoint( hModule
, ordinal
);
1646 TRACE_(module
)("returning %08x\n",(UINT
)ret
);
1650 /***********************************************************************
1651 * GetProcAddress16 (KERNEL.50)
1653 FARPROC16 WINAPI
GetProcAddress16( HMODULE16 hModule
, SEGPTR name
)
1658 if (!hModule
) hModule
= GetCurrentTask();
1659 hModule
= GetExePtr( hModule
);
1661 if (HIWORD(name
) != 0)
1663 ordinal
= NE_GetOrdinal( hModule
, (LPSTR
)PTR_SEG_TO_LIN(name
) );
1664 TRACE_(module
)("%04x '%s'\n",
1665 hModule
, (LPSTR
)PTR_SEG_TO_LIN(name
) );
1669 ordinal
= LOWORD(name
);
1670 TRACE_(module
)("%04x %04x\n",
1673 if (!ordinal
) return (FARPROC16
)0;
1675 ret
= NE_GetEntryPoint( hModule
, ordinal
);
1677 TRACE_(module
)("returning %08x\n", (UINT
)ret
);
1682 /***********************************************************************
1683 * GetProcAddress32 (KERNEL32.257)
1685 FARPROC WINAPI
GetProcAddress( HMODULE hModule
, LPCSTR function
)
1687 return MODULE_GetProcAddress( hModule
, function
, TRUE
);
1690 /***********************************************************************
1691 * WIN16_GetProcAddress32 (KERNEL.453)
1693 FARPROC WINAPI
GetProcAddress32_16( HMODULE hModule
, LPCSTR function
)
1695 return MODULE_GetProcAddress( hModule
, function
, FALSE
);
1698 /***********************************************************************
1699 * MODULE_GetProcAddress32 (internal)
1701 FARPROC
MODULE_GetProcAddress(
1702 HMODULE hModule
, /* [in] current module handle */
1703 LPCSTR function
, /* [in] function to be looked up */
1706 WINE_MODREF
*wm
= MODULE32_LookupHMODULE( hModule
);
1709 if (HIWORD(function
))
1710 TRACE_(win32
)("(%08lx,%s)\n",(DWORD
)hModule
,function
);
1712 TRACE_(win32
)("(%08lx,%p)\n",(DWORD
)hModule
,function
);
1714 SetLastError(ERROR_INVALID_HANDLE
);
1720 retproc
= PE_FindExportedFunction( wm
, function
, snoop
);
1721 if (!retproc
) SetLastError(ERROR_PROC_NOT_FOUND
);
1724 retproc
= ELF_FindExportedFunction( wm
, function
);
1725 if (!retproc
) SetLastError(ERROR_PROC_NOT_FOUND
);
1728 ERR_(module
)("wine_modref type %d not handled.\n",wm
->type
);
1729 SetLastError(ERROR_INVALID_HANDLE
);
1735 /***********************************************************************
1736 * RtlImageNtHeaders (NTDLL)
1738 PIMAGE_NT_HEADERS WINAPI
RtlImageNtHeader(HMODULE hModule
)
1741 * return hModule+(((IMAGE_DOS_HEADER*)hModule)->e_lfanew);
1742 * but we could get HMODULE16 or the like (think builtin modules)
1745 WINE_MODREF
*wm
= MODULE32_LookupHMODULE( hModule
);
1746 if (!wm
|| (wm
->type
!= MODULE32_PE
)) return (PIMAGE_NT_HEADERS
)0;
1747 return PE_HEADER(wm
->module
);
1751 /***************************************************************************
1752 * HasGPHandler (KERNEL.338)
1755 #include "pshpack1.h"
1756 typedef struct _GPHANDLERDEF
1763 #include "poppack.h"
1765 SEGPTR WINAPI
HasGPHandler16( SEGPTR address
)
1770 GPHANDLERDEF
*gpHandler
;
1772 if ( (hModule
= FarGetOwner16( SELECTOROF(address
) )) != 0
1773 && (gpOrdinal
= NE_GetOrdinal( hModule
, "__GP" )) != 0
1774 && (gpPtr
= (SEGPTR
)NE_GetEntryPointEx( hModule
, gpOrdinal
, FALSE
)) != 0
1775 && !IsBadReadPtr16( gpPtr
, sizeof(GPHANDLERDEF
) )
1776 && (gpHandler
= PTR_SEG_TO_LIN( gpPtr
)) != NULL
)
1778 while (gpHandler
->selector
)
1780 if ( SELECTOROF(address
) == gpHandler
->selector
1781 && OFFSETOF(address
) >= gpHandler
->rangeStart
1782 && OFFSETOF(address
) < gpHandler
->rangeEnd
)
1783 return PTR_SEG_OFF_TO_SEGPTR( gpHandler
->selector
,
1784 gpHandler
->handler
);