4 * Copyright 1995 Alexandre Julliard
12 #include <sys/types.h>
14 #include "wine/winbase16.h"
19 #include "debugtools.h"
21 #include "loadorder.h"
24 DEFAULT_DEBUG_CHANNEL(module
);
25 DECLARE_DEBUG_CHANNEL(win32
);
26 DECLARE_DEBUG_CHANNEL(loaddll
);
28 WINE_MODREF
*MODULE_modref_list
= NULL
;
30 static WINE_MODREF
*exe_modref
;
31 static int free_lib_count
; /* recursion depth of FreeLibrary calls */
32 static int process_detaching
; /* set on process detach to avoid deadlocks with thread detach */
34 /*************************************************************************
35 * MODULE32_LookupHMODULE
36 * looks for the referenced HMODULE in the current process
37 * NOTE: Assumes that the process critical section is held!
39 static WINE_MODREF
*MODULE32_LookupHMODULE( HMODULE hmod
)
47 ERR("tried to lookup 0x%04x in win32 module handler!\n",hmod
);
48 SetLastError( ERROR_INVALID_HANDLE
);
51 for ( wm
= MODULE_modref_list
; wm
; wm
=wm
->next
)
52 if (wm
->module
== hmod
)
54 SetLastError( ERROR_INVALID_HANDLE
);
58 /*************************************************************************
61 * Allocate a WINE_MODREF structure and add it to the process list
62 * NOTE: Assumes that the process critical section is held!
64 WINE_MODREF
*MODULE_AllocModRef( HMODULE hModule
, LPCSTR filename
)
69 if ((wm
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*wm
) )))
74 wm
->filename
= HEAP_strdupA( GetProcessHeap(), 0, filename
);
75 if ((wm
->modname
= strrchr( wm
->filename
, '\\' ))) wm
->modname
++;
76 else wm
->modname
= wm
->filename
;
78 len
= GetShortPathNameA( wm
->filename
, NULL
, 0 );
79 wm
->short_filename
= (char *)HeapAlloc( GetProcessHeap(), 0, len
+1 );
80 GetShortPathNameA( wm
->filename
, wm
->short_filename
, len
+1 );
81 if ((wm
->short_modname
= strrchr( wm
->short_filename
, '\\' ))) wm
->short_modname
++;
82 else wm
->short_modname
= wm
->short_filename
;
84 wm
->next
= MODULE_modref_list
;
85 if (wm
->next
) wm
->next
->prev
= wm
;
86 MODULE_modref_list
= wm
;
88 if (!(PE_HEADER(hModule
)->FileHeader
.Characteristics
& IMAGE_FILE_DLL
))
90 if (!exe_modref
) exe_modref
= wm
;
91 else FIXME( "Trying to load second .EXE file: %s\n", filename
);
97 /*************************************************************************
100 static BOOL
MODULE_InitDLL( WINE_MODREF
*wm
, DWORD type
, LPVOID lpReserved
)
104 static LPCSTR typeName
[] = { "PROCESS_DETACH", "PROCESS_ATTACH",
105 "THREAD_ATTACH", "THREAD_DETACH" };
108 /* Skip calls for modules loaded with special load flags */
110 if (wm
->flags
& WINE_MODREF_DONT_RESOLVE_REFS
) return TRUE
;
112 TRACE("(%s,%s,%p) - CALL\n", wm
->modname
, typeName
[type
], lpReserved
);
114 /* Call the initialization routine */
115 retv
= PE_InitDLL( wm
->module
, type
, lpReserved
);
117 /* The state of the module list may have changed due to the call
118 to PE_InitDLL. We cannot assume that this module has not been
120 TRACE("(%p,%s,%p) - RETURN %d\n", wm
, typeName
[type
], lpReserved
, retv
);
125 /*************************************************************************
126 * MODULE_DllProcessAttach
128 * Send the process attach notification to all DLLs the given module
129 * depends on (recursively). This is somewhat complicated due to the fact that
131 * - we have to respect the module dependencies, i.e. modules implicitly
132 * referenced by another module have to be initialized before the module
133 * itself can be initialized
135 * - the initialization routine of a DLL can itself call LoadLibrary,
136 * thereby introducing a whole new set of dependencies (even involving
137 * the 'old' modules) at any time during the whole process
139 * (Note that this routine can be recursively entered not only directly
140 * from itself, but also via LoadLibrary from one of the called initialization
143 * Furthermore, we need to rearrange the main WINE_MODREF list to allow
144 * the process *detach* notifications to be sent in the correct order.
145 * This must not only take into account module dependencies, but also
146 * 'hidden' dependencies created by modules calling LoadLibrary in their
147 * attach notification routine.
149 * The strategy is rather simple: we move a WINE_MODREF to the head of the
150 * list after the attach notification has returned. This implies that the
151 * detach notifications are called in the reverse of the sequence the attach
152 * notifications *returned*.
154 BOOL
MODULE_DllProcessAttach( WINE_MODREF
*wm
, LPVOID lpReserved
)
161 if (!wm
) wm
= exe_modref
;
164 /* prevent infinite recursion in case of cyclical dependencies */
165 if ( ( wm
->flags
& WINE_MODREF_MARKER
)
166 || ( wm
->flags
& WINE_MODREF_PROCESS_ATTACHED
) )
169 TRACE("(%s,%p) - START\n", wm
->modname
, lpReserved
);
171 /* Tag current MODREF to prevent recursive loop */
172 wm
->flags
|= WINE_MODREF_MARKER
;
174 /* Recursively attach all DLLs this one depends on */
175 for ( i
= 0; retv
&& i
< wm
->nDeps
; i
++ )
177 retv
= MODULE_DllProcessAttach( wm
->deps
[i
], lpReserved
);
179 /* Call DLL entry point */
182 retv
= MODULE_InitDLL( wm
, DLL_PROCESS_ATTACH
, lpReserved
);
184 wm
->flags
|= WINE_MODREF_PROCESS_ATTACHED
;
187 /* Re-insert MODREF at head of list */
188 if ( retv
&& wm
->prev
)
190 wm
->prev
->next
= wm
->next
;
191 if ( wm
->next
) wm
->next
->prev
= wm
->prev
;
194 wm
->next
= MODULE_modref_list
;
195 MODULE_modref_list
= wm
->next
->prev
= wm
;
198 /* Remove recursion flag */
199 wm
->flags
&= ~WINE_MODREF_MARKER
;
201 TRACE("(%s,%p) - END\n", wm
->modname
, lpReserved
);
208 /*************************************************************************
209 * MODULE_DllProcessDetach
211 * Send DLL process detach notifications. See the comment about calling
212 * sequence at MODULE_DllProcessAttach. Unless the bForceDetach flag
213 * is set, only DLLs with zero refcount are notified.
215 void MODULE_DllProcessDetach( BOOL bForceDetach
, LPVOID lpReserved
)
220 if (bForceDetach
) process_detaching
= 1;
223 for ( wm
= MODULE_modref_list
; wm
; wm
= wm
->next
)
225 /* Check whether to detach this DLL */
226 if ( !(wm
->flags
& WINE_MODREF_PROCESS_ATTACHED
) )
228 if ( wm
->refCount
> 0 && !bForceDetach
)
231 /* Call detach notification */
232 wm
->flags
&= ~WINE_MODREF_PROCESS_ATTACHED
;
233 MODULE_InitDLL( wm
, DLL_PROCESS_DETACH
, lpReserved
);
235 /* Restart at head of WINE_MODREF list, as entries might have
236 been added and/or removed while performing the call ... */
244 /*************************************************************************
245 * MODULE_DllThreadAttach
247 * Send DLL thread attach notifications. These are sent in the
248 * reverse sequence of process detach notification.
251 void MODULE_DllThreadAttach( LPVOID lpReserved
)
255 /* don't do any attach calls if process is exiting */
256 if (process_detaching
) return;
257 /* FIXME: there is still a race here */
261 for ( wm
= MODULE_modref_list
; wm
; wm
= wm
->next
)
265 for ( ; wm
; wm
= wm
->prev
)
267 if ( !(wm
->flags
& WINE_MODREF_PROCESS_ATTACHED
) )
269 if ( wm
->flags
& WINE_MODREF_NO_DLL_CALLS
)
272 MODULE_InitDLL( wm
, DLL_THREAD_ATTACH
, lpReserved
);
278 /*************************************************************************
279 * MODULE_DllThreadDetach
281 * Send DLL thread detach notifications. These are sent in the
282 * same sequence as process detach notification.
285 void MODULE_DllThreadDetach( LPVOID lpReserved
)
289 /* don't do any detach calls if process is exiting */
290 if (process_detaching
) return;
291 /* FIXME: there is still a race here */
295 for ( wm
= MODULE_modref_list
; wm
; wm
= wm
->next
)
297 if ( !(wm
->flags
& WINE_MODREF_PROCESS_ATTACHED
) )
299 if ( wm
->flags
& WINE_MODREF_NO_DLL_CALLS
)
302 MODULE_InitDLL( wm
, DLL_THREAD_DETACH
, lpReserved
);
308 /****************************************************************************
309 * DisableThreadLibraryCalls (KERNEL32.74)
311 * Don't call DllEntryPoint for DLL_THREAD_{ATTACH,DETACH} if set.
313 BOOL WINAPI
DisableThreadLibraryCalls( HMODULE hModule
)
320 wm
= MODULE32_LookupHMODULE( hModule
);
324 wm
->flags
|= WINE_MODREF_NO_DLL_CALLS
;
332 /***********************************************************************
333 * MODULE_CreateDummyModule
335 * Create a dummy NE module for Win32 or Winelib.
337 HMODULE
MODULE_CreateDummyModule( LPCSTR filename
, HMODULE module32
)
341 SEGTABLEENTRY
*pSegment
;
344 const char* basename
;
348 /* Extract base filename */
349 basename
= strrchr(filename
, '\\');
350 if (!basename
) basename
= filename
;
352 len
= strlen(basename
);
353 if ((s
= strchr(basename
, '.'))) len
= s
- basename
;
355 /* Allocate module */
356 of_size
= sizeof(OFSTRUCT
) - sizeof(ofs
->szPathName
)
357 + strlen(filename
) + 1;
358 size
= sizeof(NE_MODULE
) +
359 /* loaded file info */
360 ((of_size
+ 3) & ~3) +
361 /* segment table: DS,CS */
362 2 * sizeof(SEGTABLEENTRY
) +
365 /* several empty tables */
368 hModule
= GlobalAlloc16( GMEM_MOVEABLE
| GMEM_ZEROINIT
, size
);
369 if (!hModule
) return (HMODULE
)11; /* invalid exe */
371 FarSetOwner16( hModule
, hModule
);
372 pModule
= (NE_MODULE
*)GlobalLock16( hModule
);
374 /* Set all used entries */
375 pModule
->magic
= IMAGE_OS2_SIGNATURE
;
382 pModule
->heap_size
= 0;
383 pModule
->stack_size
= 0;
384 pModule
->seg_count
= 2;
385 pModule
->modref_count
= 0;
386 pModule
->nrname_size
= 0;
387 pModule
->fileinfo
= sizeof(NE_MODULE
);
388 pModule
->os_flags
= NE_OSFLAGS_WINDOWS
;
389 pModule
->self
= hModule
;
390 pModule
->module32
= module32
;
392 /* Set version and flags */
395 pModule
->expected_version
=
396 ((PE_HEADER(module32
)->OptionalHeader
.MajorSubsystemVersion
& 0xff) << 8 ) |
397 (PE_HEADER(module32
)->OptionalHeader
.MinorSubsystemVersion
& 0xff);
398 pModule
->flags
|= NE_FFLAGS_WIN32
;
399 if (PE_HEADER(module32
)->FileHeader
.Characteristics
& IMAGE_FILE_DLL
)
400 pModule
->flags
|= NE_FFLAGS_LIBMODULE
| NE_FFLAGS_SINGLEDATA
;
403 /* Set loaded file information */
404 ofs
= (OFSTRUCT
*)(pModule
+ 1);
405 memset( ofs
, 0, of_size
);
406 ofs
->cBytes
= of_size
< 256 ? of_size
: 255; /* FIXME */
407 strcpy( ofs
->szPathName
, filename
);
409 pSegment
= (SEGTABLEENTRY
*)((char*)(pModule
+ 1) + ((of_size
+ 3) & ~3));
410 pModule
->seg_table
= (int)pSegment
- (int)pModule
;
413 pSegment
->flags
= NE_SEGFLAGS_DATA
;
414 pSegment
->minsize
= 0x1000;
421 pStr
= (char *)pSegment
;
422 pModule
->name_table
= (int)pStr
- (int)pModule
;
425 lstrcpynA( pStr
+1, basename
, len
+1 );
428 /* All tables zero terminated */
429 pModule
->res_table
= pModule
->import_table
= pModule
->entry_table
=
430 (int)pStr
- (int)pModule
;
432 NE_RegisterModule( pModule
);
437 /**********************************************************************
440 * Find a (loaded) win32 module depending on path
443 * the module handle if found
446 WINE_MODREF
*MODULE_FindModule(
447 LPCSTR path
/* [in] pathname of module/library to be found */
450 char dllname
[260], *p
;
452 /* Append .DLL to name if no extension present */
453 strcpy( dllname
, path
);
454 if (!(p
= strrchr( dllname
, '.')) || strchr( p
, '/' ) || strchr( p
, '\\'))
455 strcat( dllname
, ".DLL" );
457 for ( wm
= MODULE_modref_list
; wm
; wm
= wm
->next
)
459 if ( !FILE_strcasecmp( dllname
, wm
->modname
) )
461 if ( !FILE_strcasecmp( dllname
, wm
->filename
) )
463 if ( !FILE_strcasecmp( dllname
, wm
->short_modname
) )
465 if ( !FILE_strcasecmp( dllname
, wm
->short_filename
) )
473 /* Check whether a file is an OS/2 or a very old Windows executable
474 * by testing on import of KERNEL.
476 * FIXME: is reading the module imports the only way of discerning
477 * old Windows binaries from OS/2 ones ? At least it seems so...
479 static DWORD
MODULE_Decide_OS2_OldWin(HANDLE hfile
, IMAGE_DOS_HEADER
*mz
, IMAGE_OS2_HEADER
*ne
)
481 DWORD currpos
= SetFilePointer( hfile
, 0, NULL
, SEEK_CUR
);
482 DWORD type
= SCS_OS216_BINARY
;
483 LPWORD modtab
= NULL
;
484 LPSTR nametab
= NULL
;
488 /* read modref table */
489 if ( (SetFilePointer( hfile
, mz
->e_lfanew
+ ne
->ne_modtab
, NULL
, SEEK_SET
) == -1)
490 || (!(modtab
= HeapAlloc( GetProcessHeap(), 0, ne
->ne_cmod
*sizeof(WORD
))))
491 || (!(ReadFile(hfile
, modtab
, ne
->ne_cmod
*sizeof(WORD
), &len
, NULL
)))
492 || (len
!= ne
->ne_cmod
*sizeof(WORD
)) )
495 /* read imported names table */
496 if ( (SetFilePointer( hfile
, mz
->e_lfanew
+ ne
->ne_imptab
, NULL
, SEEK_SET
) == -1)
497 || (!(nametab
= HeapAlloc( GetProcessHeap(), 0, ne
->ne_enttab
- ne
->ne_imptab
)))
498 || (!(ReadFile(hfile
, nametab
, ne
->ne_enttab
- ne
->ne_imptab
, &len
, NULL
)))
499 || (len
!= ne
->ne_enttab
- ne
->ne_imptab
) )
502 for (i
=0; i
< ne
->ne_cmod
; i
++)
504 LPSTR module
= &nametab
[modtab
[i
]];
505 TRACE("modref: %.*s\n", module
[0], &module
[1]);
506 if (!(strncmp(&module
[1], "KERNEL", module
[0])))
507 { /* very old Windows file */
508 MESSAGE("This seems to be a very old (pre-3.0) Windows executable. Expect crashes, especially if this is a real-mode binary !\n");
509 type
= SCS_WOW_BINARY
;
515 ERR("Hmm, an error occurred. Is this binary file broken ?\n");
518 HeapFree( GetProcessHeap(), 0, modtab
);
519 HeapFree( GetProcessHeap(), 0, nametab
);
520 SetFilePointer( hfile
, currpos
, NULL
, SEEK_SET
); /* restore filepos */
524 /***********************************************************************
525 * MODULE_GetBinaryType
527 * The GetBinaryType function determines whether a file is executable
528 * or not and if it is it returns what type of executable it is.
529 * The type of executable is a property that determines in which
530 * subsystem an executable file runs under.
532 * Binary types returned:
533 * SCS_32BIT_BINARY: A Win32 based application
534 * SCS_DOS_BINARY: An MS-Dos based application
535 * SCS_WOW_BINARY: A Win16 based application
536 * SCS_PIF_BINARY: A PIF file that executes an MS-Dos based app
537 * SCS_POSIX_BINARY: A POSIX based application ( Not implemented )
538 * SCS_OS216_BINARY: A 16bit OS/2 based application
540 * Returns TRUE if the file is an executable in which case
541 * the value pointed by lpBinaryType is set.
542 * Returns FALSE if the file is not an executable or if the function fails.
544 * To do so it opens the file and reads in the header information
545 * if the extended header information is not present it will
546 * assume that the file is a DOS executable.
547 * If the extended header information is present it will
548 * determine if the file is a 16 or 32 bit Windows executable
549 * by check the flags in the header.
551 * Note that .COM and .PIF files are only recognized by their
552 * file name extension; but Windows does it the same way ...
554 static BOOL
MODULE_GetBinaryType( HANDLE hfile
, LPCSTR filename
, LPDWORD lpBinaryType
)
556 IMAGE_DOS_HEADER mz_header
;
560 /* Seek to the start of the file and read the DOS header information.
562 if ( SetFilePointer( hfile
, 0, NULL
, SEEK_SET
) != -1
563 && ReadFile( hfile
, &mz_header
, sizeof(mz_header
), &len
, NULL
)
564 && len
== sizeof(mz_header
) )
566 /* Now that we have the header check the e_magic field
567 * to see if this is a dos image.
569 if ( mz_header
.e_magic
== IMAGE_DOS_SIGNATURE
)
571 BOOL lfanewValid
= FALSE
;
572 /* We do have a DOS image so we will now try to seek into
573 * the file by the amount indicated by the field
574 * "Offset to extended header" and read in the
575 * "magic" field information at that location.
576 * This will tell us if there is more header information
579 /* But before we do we will make sure that header
580 * structure encompasses the "Offset to extended header"
583 if ( (mz_header
.e_cparhdr
<<4) >= sizeof(IMAGE_DOS_HEADER
) )
584 if ( ( mz_header
.e_crlc
== 0 ) ||
585 ( mz_header
.e_lfarlc
>= sizeof(IMAGE_DOS_HEADER
) ) )
586 if ( mz_header
.e_lfanew
>= sizeof(IMAGE_DOS_HEADER
)
587 && SetFilePointer( hfile
, mz_header
.e_lfanew
, NULL
, SEEK_SET
) != -1
588 && ReadFile( hfile
, magic
, sizeof(magic
), &len
, NULL
)
589 && len
== sizeof(magic
) )
594 /* If we cannot read this "extended header" we will
595 * assume that we have a simple DOS executable.
597 *lpBinaryType
= SCS_DOS_BINARY
;
602 /* Reading the magic field succeeded so
603 * we will try to determine what type it is.
605 if ( *(DWORD
*)magic
== IMAGE_NT_SIGNATURE
)
607 /* This is an NT signature.
609 *lpBinaryType
= SCS_32BIT_BINARY
;
612 else if ( *(WORD
*)magic
== IMAGE_OS2_SIGNATURE
)
614 /* The IMAGE_OS2_SIGNATURE indicates that the
615 * "extended header is a Windows executable (NE)
616 * header." This can mean either a 16-bit OS/2
617 * or a 16-bit Windows or even a DOS program
618 * (running under a DOS extender). To decide
619 * which, we'll have to read the NE header.
623 if ( SetFilePointer( hfile
, mz_header
.e_lfanew
, NULL
, SEEK_SET
) != -1
624 && ReadFile( hfile
, &ne
, sizeof(ne
), &len
, NULL
)
625 && len
== sizeof(ne
) )
627 switch ( ne
.ne_exetyp
)
629 case 2: *lpBinaryType
= SCS_WOW_BINARY
; return TRUE
;
630 case 5: *lpBinaryType
= SCS_DOS_BINARY
; return TRUE
;
631 default: *lpBinaryType
=
632 MODULE_Decide_OS2_OldWin(hfile
, &mz_header
, &ne
);
636 /* Couldn't read header, so abort. */
641 /* Unknown extended header, but this file is nonetheless
644 *lpBinaryType
= SCS_DOS_BINARY
;
651 /* If we get here, we don't even have a correct MZ header.
652 * Try to check the file extension for known types ...
654 ptr
= strrchr( filename
, '.' );
655 if ( ptr
&& !strchr( ptr
, '\\' ) && !strchr( ptr
, '/' ) )
657 if ( !FILE_strcasecmp( ptr
, ".COM" ) )
659 *lpBinaryType
= SCS_DOS_BINARY
;
663 if ( !FILE_strcasecmp( ptr
, ".PIF" ) )
665 *lpBinaryType
= SCS_PIF_BINARY
;
673 /***********************************************************************
674 * GetBinaryTypeA [KERNEL32.280]
676 BOOL WINAPI
GetBinaryTypeA( LPCSTR lpApplicationName
, LPDWORD lpBinaryType
)
681 TRACE_(win32
)("%s\n", lpApplicationName
);
685 if ( lpApplicationName
== NULL
|| lpBinaryType
== NULL
)
688 /* Open the file indicated by lpApplicationName for reading.
690 hfile
= CreateFileA( lpApplicationName
, GENERIC_READ
, FILE_SHARE_READ
,
691 NULL
, OPEN_EXISTING
, 0, 0 );
692 if ( hfile
== INVALID_HANDLE_VALUE
)
697 ret
= MODULE_GetBinaryType( hfile
, lpApplicationName
, lpBinaryType
);
701 CloseHandle( hfile
);
706 /***********************************************************************
707 * GetBinaryTypeW [KERNEL32.281]
709 BOOL WINAPI
GetBinaryTypeW( LPCWSTR lpApplicationName
, LPDWORD lpBinaryType
)
714 TRACE_(win32
)("%s\n", debugstr_w(lpApplicationName
) );
718 if ( lpApplicationName
== NULL
|| lpBinaryType
== NULL
)
721 /* Convert the wide string to a ascii string.
723 strNew
= HEAP_strdupWtoA( GetProcessHeap(), 0, lpApplicationName
);
725 if ( strNew
!= NULL
)
727 ret
= GetBinaryTypeA( strNew
, lpBinaryType
);
729 /* Free the allocated string.
731 HeapFree( GetProcessHeap(), 0, strNew
);
738 /***********************************************************************
739 * WinExec16 (KERNEL.166)
741 HINSTANCE16 WINAPI
WinExec16( LPCSTR lpCmdLine
, UINT16 nCmdShow
)
743 LPCSTR p
, args
= NULL
;
744 LPCSTR name_beg
, name_end
;
748 char buffer
[MAX_PATH
];
750 if (*lpCmdLine
== '"') /* has to be only one and only at beginning ! */
752 name_beg
= lpCmdLine
+1;
753 p
= strchr ( lpCmdLine
+1, '"' );
757 args
= strchr ( p
, ' ' );
759 else /* yes, even valid with trailing '"' missing */
760 name_end
= lpCmdLine
+strlen(lpCmdLine
);
764 name_beg
= lpCmdLine
;
765 args
= strchr( lpCmdLine
, ' ' );
766 name_end
= args
? args
: lpCmdLine
+strlen(lpCmdLine
);
769 if ((name_beg
== lpCmdLine
) && (!args
))
770 { /* just use the original cmdline string as file name */
771 name
= (LPSTR
)lpCmdLine
;
775 if (!(name
= HeapAlloc( GetProcessHeap(), 0, name_end
- name_beg
+ 1 )))
776 return ERROR_NOT_ENOUGH_MEMORY
;
777 memcpy( name
, name_beg
, name_end
- name_beg
);
778 name
[name_end
- name_beg
] = '\0';
784 arglen
= strlen(args
);
785 cmdline
= SEGPTR_ALLOC( 2 + arglen
);
786 cmdline
[0] = (BYTE
)arglen
;
787 strcpy( cmdline
+ 1, args
);
791 cmdline
= SEGPTR_ALLOC( 2 );
792 cmdline
[0] = cmdline
[1] = 0;
795 TRACE("name: '%s', cmdline: '%.*s'\n", name
, cmdline
[0], &cmdline
[1]);
797 if (SearchPathA( NULL
, name
, ".exe", sizeof(buffer
), buffer
, NULL
))
800 WORD
*showCmd
= SEGPTR_ALLOC( 2*sizeof(WORD
) );
802 showCmd
[1] = nCmdShow
;
804 params
.hEnvironment
= 0;
805 params
.cmdLine
= SEGPTR_GET(cmdline
);
806 params
.showCmd
= SEGPTR_GET(showCmd
);
809 ret
= LoadModule16( buffer
, ¶ms
);
811 SEGPTR_FREE( showCmd
);
812 SEGPTR_FREE( cmdline
);
814 else ret
= GetLastError();
816 if (name
!= lpCmdLine
) HeapFree( GetProcessHeap(), 0, name
);
818 if (ret
== 21) /* 32-bit module */
821 ReleaseThunkLock( &count
);
822 ret
= WinExec( lpCmdLine
, nCmdShow
);
823 RestoreThunkLock( count
);
828 /***********************************************************************
829 * WinExec (KERNEL32.566)
831 HINSTANCE WINAPI
WinExec( LPCSTR lpCmdLine
, UINT nCmdShow
)
833 PROCESS_INFORMATION info
;
834 STARTUPINFOA startup
;
838 memset( &startup
, 0, sizeof(startup
) );
839 startup
.cb
= sizeof(startup
);
840 startup
.dwFlags
= STARTF_USESHOWWINDOW
;
841 startup
.wShowWindow
= nCmdShow
;
843 /* cmdline needs to be writeable for CreateProcess */
844 if (!(cmdline
= HEAP_strdupA( GetProcessHeap(), 0, lpCmdLine
))) return 0;
846 if (CreateProcessA( NULL
, cmdline
, NULL
, NULL
, FALSE
,
847 0, NULL
, NULL
, &startup
, &info
))
849 /* Give 30 seconds to the app to come up */
850 if (Callout
.WaitForInputIdle
&&
851 Callout
.WaitForInputIdle( info
.hProcess
, 30000 ) == 0xFFFFFFFF)
852 WARN("WaitForInputIdle failed: Error %ld\n", GetLastError() );
854 /* Close off the handles */
855 CloseHandle( info
.hThread
);
856 CloseHandle( info
.hProcess
);
858 else if ((hInstance
= GetLastError()) >= 32)
860 FIXME("Strange error set by CreateProcess: %d\n", hInstance
);
863 HeapFree( GetProcessHeap(), 0, cmdline
);
867 /**********************************************************************
868 * LoadModule (KERNEL32.499)
870 HINSTANCE WINAPI
LoadModule( LPCSTR name
, LPVOID paramBlock
)
872 LOADPARAMS
*params
= (LOADPARAMS
*)paramBlock
;
873 PROCESS_INFORMATION info
;
874 STARTUPINFOA startup
;
877 char filename
[MAX_PATH
];
880 if (!name
) return ERROR_FILE_NOT_FOUND
;
882 if (!SearchPathA( NULL
, name
, ".exe", sizeof(filename
), filename
, NULL
) &&
883 !SearchPathA( NULL
, name
, NULL
, sizeof(filename
), filename
, NULL
))
884 return GetLastError();
886 len
= (BYTE
)params
->lpCmdLine
[0];
887 if (!(cmdline
= HeapAlloc( GetProcessHeap(), 0, strlen(filename
) + len
+ 2 )))
888 return ERROR_NOT_ENOUGH_MEMORY
;
890 strcpy( cmdline
, filename
);
891 p
= cmdline
+ strlen(cmdline
);
893 memcpy( p
, params
->lpCmdLine
+ 1, len
);
896 memset( &startup
, 0, sizeof(startup
) );
897 startup
.cb
= sizeof(startup
);
898 if (params
->lpCmdShow
)
900 startup
.dwFlags
= STARTF_USESHOWWINDOW
;
901 startup
.wShowWindow
= params
->lpCmdShow
[1];
904 if (CreateProcessA( filename
, cmdline
, NULL
, NULL
, FALSE
, 0,
905 params
->lpEnvAddress
, NULL
, &startup
, &info
))
907 /* Give 30 seconds to the app to come up */
908 if (Callout
.WaitForInputIdle
&&
909 Callout
.WaitForInputIdle( info
.hProcess
, 30000 ) == 0xFFFFFFFF )
910 WARN("WaitForInputIdle failed: Error %ld\n", GetLastError() );
912 /* Close off the handles */
913 CloseHandle( info
.hThread
);
914 CloseHandle( info
.hProcess
);
916 else if ((hInstance
= GetLastError()) >= 32)
918 FIXME("Strange error set by CreateProcess: %d\n", hInstance
);
922 HeapFree( GetProcessHeap(), 0, cmdline
);
927 /*************************************************************************
930 * Helper for CreateProcess: retrieve the file name to load from the
931 * app name and command line. Store the file name in buffer, and
932 * return a possibly modified command line.
934 static LPSTR
get_file_name( LPCSTR appname
, LPSTR cmdline
, LPSTR buffer
, int buflen
)
936 char *name
, *pos
, *ret
= NULL
;
939 /* if we have an app name, everything is easy */
943 /* use the unmodified app name as file name */
944 lstrcpynA( buffer
, appname
, buflen
);
945 if (!(ret
= cmdline
))
947 /* no command-line, create one */
948 if ((ret
= HeapAlloc( GetProcessHeap(), 0, strlen(appname
) + 3 )))
949 sprintf( ret
, "\"%s\"", appname
);
956 SetLastError( ERROR_INVALID_PARAMETER
);
960 /* first check for a quoted file name */
962 if ((cmdline
[0] == '"') && ((p
= strchr( cmdline
+ 1, '"' ))))
964 int len
= p
- cmdline
- 1;
965 /* extract the quoted portion as file name */
966 if (!(name
= HeapAlloc( GetProcessHeap(), 0, len
+ 1 ))) return NULL
;
967 memcpy( name
, cmdline
+ 1, len
);
970 if (SearchPathA( NULL
, name
, ".exe", buflen
, buffer
, NULL
) ||
971 SearchPathA( NULL
, name
, NULL
, buflen
, buffer
, NULL
))
972 ret
= cmdline
; /* no change necessary */
976 /* now try the command-line word by word */
978 if (!(name
= HeapAlloc( GetProcessHeap(), 0, strlen(cmdline
) + 1 ))) return NULL
;
984 do *pos
++ = *p
++; while (*p
&& *p
!= ' ');
986 TRACE("trying '%s'\n", name
);
987 if (SearchPathA( NULL
, name
, ".exe", buflen
, buffer
, NULL
) ||
988 SearchPathA( NULL
, name
, NULL
, buflen
, buffer
, NULL
))
995 if (!ret
|| !strchr( name
, ' ' )) goto done
; /* no change necessary */
997 /* now build a new command-line with quotes */
999 if (!(ret
= HeapAlloc( GetProcessHeap(), 0, strlen(cmdline
) + 3 ))) goto done
;
1000 sprintf( ret
, "\"%s\"%s", name
, p
);
1003 HeapFree( GetProcessHeap(), 0, name
);
1008 /**********************************************************************
1009 * CreateProcessA (KERNEL32.171)
1011 BOOL WINAPI
CreateProcessA( LPCSTR lpApplicationName
, LPSTR lpCommandLine
,
1012 LPSECURITY_ATTRIBUTES lpProcessAttributes
,
1013 LPSECURITY_ATTRIBUTES lpThreadAttributes
,
1014 BOOL bInheritHandles
, DWORD dwCreationFlags
,
1015 LPVOID lpEnvironment
, LPCSTR lpCurrentDirectory
,
1016 LPSTARTUPINFOA lpStartupInfo
,
1017 LPPROCESS_INFORMATION lpProcessInfo
)
1022 char name
[MAX_PATH
];
1025 /* Process the AppName and/or CmdLine to get module name and path */
1027 TRACE("app '%s' cmdline '%s'\n", lpApplicationName
, lpCommandLine
);
1029 if (!(tidy_cmdline
= get_file_name( lpApplicationName
, lpCommandLine
, name
, sizeof(name
) )))
1032 /* Warn if unsupported features are used */
1034 if (dwCreationFlags
& DETACHED_PROCESS
)
1035 FIXME("(%s,...): DETACHED_PROCESS ignored\n", name
);
1036 if (dwCreationFlags
& CREATE_NEW_CONSOLE
)
1037 FIXME("(%s,...): CREATE_NEW_CONSOLE ignored\n", name
);
1038 if (dwCreationFlags
& NORMAL_PRIORITY_CLASS
)
1039 FIXME("(%s,...): NORMAL_PRIORITY_CLASS ignored\n", name
);
1040 if (dwCreationFlags
& IDLE_PRIORITY_CLASS
)
1041 FIXME("(%s,...): IDLE_PRIORITY_CLASS ignored\n", name
);
1042 if (dwCreationFlags
& HIGH_PRIORITY_CLASS
)
1043 FIXME("(%s,...): HIGH_PRIORITY_CLASS ignored\n", name
);
1044 if (dwCreationFlags
& REALTIME_PRIORITY_CLASS
)
1045 FIXME("(%s,...): REALTIME_PRIORITY_CLASS ignored\n", name
);
1046 if (dwCreationFlags
& CREATE_NEW_PROCESS_GROUP
)
1047 FIXME("(%s,...): CREATE_NEW_PROCESS_GROUP ignored\n", name
);
1048 if (dwCreationFlags
& CREATE_UNICODE_ENVIRONMENT
)
1049 FIXME("(%s,...): CREATE_UNICODE_ENVIRONMENT ignored\n", name
);
1050 if (dwCreationFlags
& CREATE_SEPARATE_WOW_VDM
)
1051 FIXME("(%s,...): CREATE_SEPARATE_WOW_VDM ignored\n", name
);
1052 if (dwCreationFlags
& CREATE_SHARED_WOW_VDM
)
1053 FIXME("(%s,...): CREATE_SHARED_WOW_VDM ignored\n", name
);
1054 if (dwCreationFlags
& CREATE_DEFAULT_ERROR_MODE
)
1055 FIXME("(%s,...): CREATE_DEFAULT_ERROR_MODE ignored\n", name
);
1056 if (dwCreationFlags
& CREATE_NO_WINDOW
)
1057 FIXME("(%s,...): CREATE_NO_WINDOW ignored\n", name
);
1058 if (dwCreationFlags
& PROFILE_USER
)
1059 FIXME("(%s,...): PROFILE_USER ignored\n", name
);
1060 if (dwCreationFlags
& PROFILE_KERNEL
)
1061 FIXME("(%s,...): PROFILE_KERNEL ignored\n", name
);
1062 if (dwCreationFlags
& PROFILE_SERVER
)
1063 FIXME("(%s,...): PROFILE_SERVER ignored\n", name
);
1064 if (lpStartupInfo
->lpDesktop
)
1065 FIXME("(%s,...): lpStartupInfo->lpDesktop %s ignored\n",
1066 name
, lpStartupInfo
->lpDesktop
);
1067 if (lpStartupInfo
->lpTitle
)
1068 FIXME("(%s,...): lpStartupInfo->lpTitle %s ignored\n",
1069 name
, lpStartupInfo
->lpTitle
);
1070 if (lpStartupInfo
->dwFlags
& STARTF_USECOUNTCHARS
)
1071 FIXME("(%s,...): STARTF_USECOUNTCHARS (%ld,%ld) ignored\n",
1072 name
, lpStartupInfo
->dwXCountChars
, lpStartupInfo
->dwYCountChars
);
1073 if (lpStartupInfo
->dwFlags
& STARTF_USEFILLATTRIBUTE
)
1074 FIXME("(%s,...): STARTF_USEFILLATTRIBUTE %lx ignored\n",
1075 name
, lpStartupInfo
->dwFillAttribute
);
1076 if (lpStartupInfo
->dwFlags
& STARTF_RUNFULLSCREEN
)
1077 FIXME("(%s,...): STARTF_RUNFULLSCREEN ignored\n", name
);
1078 if (lpStartupInfo
->dwFlags
& STARTF_FORCEONFEEDBACK
)
1079 FIXME("(%s,...): STARTF_FORCEONFEEDBACK ignored\n", name
);
1080 if (lpStartupInfo
->dwFlags
& STARTF_FORCEOFFFEEDBACK
)
1081 FIXME("(%s,...): STARTF_FORCEOFFFEEDBACK ignored\n", name
);
1082 if (lpStartupInfo
->dwFlags
& STARTF_USEHOTKEY
)
1083 FIXME("(%s,...): STARTF_USEHOTKEY ignored\n", name
);
1085 /* Open file and determine executable type */
1087 hFile
= CreateFileA( name
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0, 0 );
1088 if (hFile
== INVALID_HANDLE_VALUE
) goto done
;
1090 if ( !MODULE_GetBinaryType( hFile
, name
, &type
) )
1092 CloseHandle( hFile
);
1093 retv
= PROCESS_Create( 0, name
, tidy_cmdline
, lpEnvironment
,
1094 lpProcessAttributes
, lpThreadAttributes
,
1095 bInheritHandles
, dwCreationFlags
,
1096 lpStartupInfo
, lpProcessInfo
, lpCurrentDirectory
);
1100 /* Create process */
1104 case SCS_32BIT_BINARY
:
1105 case SCS_WOW_BINARY
:
1106 case SCS_DOS_BINARY
:
1107 retv
= PROCESS_Create( hFile
, name
, tidy_cmdline
, lpEnvironment
,
1108 lpProcessAttributes
, lpThreadAttributes
,
1109 bInheritHandles
, dwCreationFlags
,
1110 lpStartupInfo
, lpProcessInfo
, lpCurrentDirectory
);
1113 case SCS_PIF_BINARY
:
1114 case SCS_POSIX_BINARY
:
1115 case SCS_OS216_BINARY
:
1116 FIXME("Unsupported executable type: %ld\n", type
);
1120 SetLastError( ERROR_BAD_FORMAT
);
1123 CloseHandle( hFile
);
1126 if (tidy_cmdline
!= lpCommandLine
) HeapFree( GetProcessHeap(), 0, tidy_cmdline
);
1130 /**********************************************************************
1131 * CreateProcessW (KERNEL32.172)
1133 * lpReserved is not converted
1135 BOOL WINAPI
CreateProcessW( LPCWSTR lpApplicationName
, LPWSTR lpCommandLine
,
1136 LPSECURITY_ATTRIBUTES lpProcessAttributes
,
1137 LPSECURITY_ATTRIBUTES lpThreadAttributes
,
1138 BOOL bInheritHandles
, DWORD dwCreationFlags
,
1139 LPVOID lpEnvironment
, LPCWSTR lpCurrentDirectory
,
1140 LPSTARTUPINFOW lpStartupInfo
,
1141 LPPROCESS_INFORMATION lpProcessInfo
)
1143 STARTUPINFOA StartupInfoA
;
1145 LPSTR lpApplicationNameA
= HEAP_strdupWtoA (GetProcessHeap(),0,lpApplicationName
);
1146 LPSTR lpCommandLineA
= HEAP_strdupWtoA (GetProcessHeap(),0,lpCommandLine
);
1147 LPSTR lpCurrentDirectoryA
= HEAP_strdupWtoA (GetProcessHeap(),0,lpCurrentDirectory
);
1149 memcpy (&StartupInfoA
, lpStartupInfo
, sizeof(STARTUPINFOA
));
1150 StartupInfoA
.lpDesktop
= HEAP_strdupWtoA (GetProcessHeap(),0,lpStartupInfo
->lpDesktop
);
1151 StartupInfoA
.lpTitle
= HEAP_strdupWtoA (GetProcessHeap(),0,lpStartupInfo
->lpTitle
);
1153 TRACE_(win32
)("(%s,%s,...)\n", debugstr_w(lpApplicationName
), debugstr_w(lpCommandLine
));
1155 if (lpStartupInfo
->lpReserved
)
1156 FIXME_(win32
)("StartupInfo.lpReserved is used, please report (%s)\n", debugstr_w(lpStartupInfo
->lpReserved
));
1158 ret
= CreateProcessA( lpApplicationNameA
, lpCommandLineA
,
1159 lpProcessAttributes
, lpThreadAttributes
,
1160 bInheritHandles
, dwCreationFlags
,
1161 lpEnvironment
, lpCurrentDirectoryA
,
1162 &StartupInfoA
, lpProcessInfo
);
1164 HeapFree( GetProcessHeap(), 0, lpCurrentDirectoryA
);
1165 HeapFree( GetProcessHeap(), 0, lpCommandLineA
);
1166 HeapFree( GetProcessHeap(), 0, StartupInfoA
.lpDesktop
);
1167 HeapFree( GetProcessHeap(), 0, StartupInfoA
.lpTitle
);
1172 /***********************************************************************
1173 * GetModuleHandleA (KERNEL32.237)
1175 HMODULE WINAPI
GetModuleHandleA(LPCSTR module
)
1179 if ( module
== NULL
)
1182 wm
= MODULE_FindModule( module
);
1184 return wm
? wm
->module
: 0;
1187 /***********************************************************************
1190 HMODULE WINAPI
GetModuleHandleW(LPCWSTR module
)
1193 LPSTR modulea
= HEAP_strdupWtoA( GetProcessHeap(), 0, module
);
1194 hModule
= GetModuleHandleA( modulea
);
1195 HeapFree( GetProcessHeap(), 0, modulea
);
1200 /***********************************************************************
1201 * GetModuleFileNameA (KERNEL32.235)
1203 * GetModuleFileNameA seems to *always* return the long path;
1204 * it's only GetModuleFileName16 that decides between short/long path
1205 * by checking if exe version >= 4.0.
1206 * (SDK docu doesn't mention this)
1208 DWORD WINAPI
GetModuleFileNameA(
1209 HMODULE hModule
, /* [in] module handle (32bit) */
1210 LPSTR lpFileName
, /* [out] filenamebuffer */
1211 DWORD size
) /* [in] size of filenamebuffer */
1215 RtlAcquirePebLock();
1218 if ((wm
= MODULE32_LookupHMODULE( hModule
)))
1219 lstrcpynA( lpFileName
, wm
->filename
, size
);
1221 RtlReleasePebLock();
1222 TRACE("%s\n", lpFileName
);
1223 return strlen(lpFileName
);
1227 /***********************************************************************
1228 * GetModuleFileNameW (KERNEL32.236)
1230 DWORD WINAPI
GetModuleFileNameW( HMODULE hModule
, LPWSTR lpFileName
,
1233 LPSTR fnA
= (char*)HeapAlloc( GetProcessHeap(), 0, size
);
1234 DWORD res
= GetModuleFileNameA( hModule
, fnA
, size
);
1235 if (size
> 0 && !MultiByteToWideChar( CP_ACP
, 0, fnA
, -1, lpFileName
, size
))
1236 lpFileName
[size
-1] = 0;
1237 HeapFree( GetProcessHeap(), 0, fnA
);
1242 /***********************************************************************
1243 * LoadLibraryExA (KERNEL32)
1245 HMODULE WINAPI
LoadLibraryExA(LPCSTR libname
, HANDLE hfile
, DWORD flags
)
1251 SetLastError(ERROR_INVALID_PARAMETER
);
1255 if (flags
& LOAD_LIBRARY_AS_DATAFILE
)
1260 /* This method allows searching for the 'native' libraries only */
1261 if (SearchPathA( NULL
, libname
, ".dll", sizeof(filename
), filename
, NULL
))
1263 /* FIXME: maybe we should use the hfile parameter instead */
1264 HANDLE hFile
= CreateFileA( filename
, GENERIC_READ
, FILE_SHARE_READ
,
1265 NULL
, OPEN_EXISTING
, 0, 0 );
1266 if (hFile
!= INVALID_HANDLE_VALUE
)
1268 hmod
= PE_LoadImage( hFile
, filename
, flags
);
1269 CloseHandle( hFile
);
1271 if (hmod
) return hmod
;
1273 flags
|= DONT_RESOLVE_DLL_REFERENCES
; /* Just in case */
1274 /* Fallback to normal behaviour */
1277 RtlAcquirePebLock();
1279 wm
= MODULE_LoadLibraryExA( libname
, hfile
, flags
);
1282 if ( !MODULE_DllProcessAttach( wm
, NULL
) )
1284 WARN_(module
)("Attach failed for module '%s', \n", libname
);
1285 MODULE_FreeLibrary(wm
);
1286 SetLastError(ERROR_DLL_INIT_FAILED
);
1291 RtlReleasePebLock();
1292 return wm
? wm
->module
: 0;
1295 /***********************************************************************
1296 * MODULE_LoadLibraryExA (internal)
1298 * Load a PE style module according to the load order.
1300 * The HFILE parameter is not used and marked reserved in the SDK. I can
1301 * only guess that it should force a file to be mapped, but I rather
1302 * ignore the parameter because it would be extremely difficult to
1303 * integrate this with different types of module represenations.
1306 WINE_MODREF
*MODULE_LoadLibraryExA( LPCSTR libname
, HFILE hfile
, DWORD flags
)
1308 DWORD err
= GetLastError();
1311 enum loadorder_type loadorder
[LOADORDER_NTYPES
];
1313 const char *filetype
= "";
1315 if ( !libname
) return NULL
;
1317 filename
= HeapAlloc ( GetProcessHeap(), 0, MAX_PATH
+ 1 );
1318 if ( !filename
) return NULL
;
1320 /* build the modules filename */
1321 if (!SearchPathA( NULL
, libname
, ".dll", MAX_PATH
, filename
, NULL
))
1323 if ( ! GetSystemDirectoryA ( filename
, MAX_PATH
) )
1326 /* if the library name contains a path and can not be found, return an error.
1327 exception: if the path is the system directory, proceed, so that modules,
1328 which are not PE-modules can be loaded
1330 if the library name does not contain a path and can not be found, assume the
1331 system directory is meant */
1333 if ( ! FILE_strncasecmp ( filename
, libname
, strlen ( filename
) ))
1334 strcpy ( filename
, libname
);
1337 if ( strchr ( libname
, '\\' ) || strchr ( libname
, ':') || strchr ( libname
, '/' ) )
1341 strcat ( filename
, "\\" );
1342 strcat ( filename
, libname
);
1346 /* if the filename doesn't have an extension append .DLL */
1347 if (!(p
= strrchr( filename
, '.')) || strchr( p
, '/' ) || strchr( p
, '\\'))
1348 strcat( filename
, ".DLL" );
1351 RtlAcquirePebLock();
1353 /* Check for already loaded module */
1354 if (!(pwm
= MODULE_FindModule(filename
)) &&
1355 /* no path in libpath */
1356 !strchr( libname
, '\\' ) && !strchr( libname
, ':') && !strchr( libname
, '/' ))
1358 LPSTR fn
= HeapAlloc ( GetProcessHeap(), 0, MAX_PATH
+ 1 );
1361 /* since the default loading mechanism uses a more detailed algorithm
1362 * than SearchPath (like using PATH, which can even be modified between
1363 * two attempts of loading the same DLL), the look-up above (with
1364 * SearchPath) can have put the file in system directory, whereas it
1365 * has already been loaded but with a different path. So do a specific
1366 * look-up with filename (without any path)
1368 strcpy ( fn
, libname
);
1369 /* if the filename doesn't have an extension append .DLL */
1370 if (!strrchr( fn
, '.')) strcat( fn
, ".dll" );
1371 if ((pwm
= MODULE_FindModule( fn
)) != NULL
)
1372 strcpy( filename
, fn
);
1373 HeapFree( GetProcessHeap(), 0, fn
);
1378 if(!(pwm
->flags
& WINE_MODREF_MARKER
))
1381 if ((pwm
->flags
& WINE_MODREF_DONT_RESOLVE_REFS
) &&
1382 !(flags
& DONT_RESOLVE_DLL_REFERENCES
))
1384 extern DWORD
fixup_imports(WINE_MODREF
*wm
); /*FIXME*/
1385 pwm
->flags
&= ~WINE_MODREF_DONT_RESOLVE_REFS
;
1386 fixup_imports( pwm
);
1388 TRACE("Already loaded module '%s' at 0x%08x, count=%d, \n", filename
, pwm
->module
, pwm
->refCount
);
1389 RtlReleasePebLock();
1390 HeapFree ( GetProcessHeap(), 0, filename
);
1394 MODULE_GetLoadOrder( loadorder
, filename
, TRUE
);
1396 for(i
= 0; i
< LOADORDER_NTYPES
; i
++)
1398 if (loadorder
[i
] == LOADORDER_INVALID
) break;
1399 SetLastError( ERROR_FILE_NOT_FOUND
);
1401 switch(loadorder
[i
])
1404 TRACE("Trying native dll '%s'\n", filename
);
1405 pwm
= PE_LoadLibraryExA(filename
, flags
);
1406 filetype
= "native";
1410 TRACE("Trying so-library '%s'\n", filename
);
1411 pwm
= ELF_LoadLibraryExA(filename
, flags
);
1416 TRACE("Trying built-in '%s'\n", filename
);
1417 pwm
= BUILTIN32_LoadLibraryExA(filename
, flags
);
1418 filetype
= "builtin";
1428 /* Initialize DLL just loaded */
1429 TRACE("Loaded module '%s' at 0x%08x, \n", filename
, pwm
->module
);
1430 if (!TRACE_ON(module
))
1431 TRACE_(loaddll
)("Loaded module '%s' : %s\n", filename
, filetype
);
1432 /* Set the refCount here so that an attach failure will */
1433 /* decrement the dependencies through the MODULE_FreeLibrary call. */
1436 RtlReleasePebLock();
1437 SetLastError( err
); /* restore last error */
1438 HeapFree ( GetProcessHeap(), 0, filename
);
1442 if(GetLastError() != ERROR_FILE_NOT_FOUND
)
1446 RtlReleasePebLock();
1448 WARN("Failed to load module '%s'; error=0x%08lx, \n", filename
, GetLastError());
1449 HeapFree ( GetProcessHeap(), 0, filename
);
1453 /***********************************************************************
1454 * LoadLibraryA (KERNEL32)
1456 HMODULE WINAPI
LoadLibraryA(LPCSTR libname
) {
1457 return LoadLibraryExA(libname
,0,0);
1460 /***********************************************************************
1461 * LoadLibraryW (KERNEL32)
1463 HMODULE WINAPI
LoadLibraryW(LPCWSTR libnameW
)
1465 return LoadLibraryExW(libnameW
,0,0);
1468 /***********************************************************************
1469 * LoadLibrary32_16 (KERNEL.452)
1471 HMODULE WINAPI
LoadLibrary32_16( LPCSTR libname
)
1476 ReleaseThunkLock( &count
);
1477 hModule
= LoadLibraryA( libname
);
1478 RestoreThunkLock( count
);
1482 /***********************************************************************
1483 * LoadLibraryExW (KERNEL32)
1485 HMODULE WINAPI
LoadLibraryExW(LPCWSTR libnameW
,HANDLE hfile
,DWORD flags
)
1487 LPSTR libnameA
= HEAP_strdupWtoA( GetProcessHeap(), 0, libnameW
);
1488 HMODULE ret
= LoadLibraryExA( libnameA
, hfile
, flags
);
1490 HeapFree( GetProcessHeap(), 0, libnameA
);
1494 /***********************************************************************
1495 * MODULE_FlushModrefs
1497 * NOTE: Assumes that the process critical section is held!
1499 * Remove all unused modrefs and call the internal unloading routines
1500 * for the library type.
1502 static void MODULE_FlushModrefs(void)
1504 WINE_MODREF
*wm
, *next
;
1506 for(wm
= MODULE_modref_list
; wm
; wm
= next
)
1513 /* Unlink this modref from the chain */
1515 wm
->next
->prev
= wm
->prev
;
1517 wm
->prev
->next
= wm
->next
;
1518 if(wm
== MODULE_modref_list
)
1519 MODULE_modref_list
= wm
->next
;
1521 TRACE(" unloading %s\n", wm
->filename
);
1522 VirtualFree( (LPVOID
)wm
->module
, 0, MEM_RELEASE
);
1523 if (wm
->dlhandle
) wine_dll_unload( wm
->dlhandle
);
1524 FreeLibrary16(wm
->hDummyMod
);
1525 HeapFree( GetProcessHeap(), 0, wm
->deps
);
1526 HeapFree( GetProcessHeap(), 0, wm
->filename
);
1527 HeapFree( GetProcessHeap(), 0, wm
->short_filename
);
1528 HeapFree( GetProcessHeap(), 0, wm
);
1532 /***********************************************************************
1535 BOOL WINAPI
FreeLibrary(HINSTANCE hLibModule
)
1540 RtlAcquirePebLock();
1543 wm
= MODULE32_LookupHMODULE( hLibModule
);
1544 if ( !wm
|| !hLibModule
)
1545 SetLastError( ERROR_INVALID_HANDLE
);
1547 retv
= MODULE_FreeLibrary( wm
);
1550 RtlReleasePebLock();
1555 /***********************************************************************
1556 * MODULE_DecRefCount
1558 * NOTE: Assumes that the process critical section is held!
1560 static void MODULE_DecRefCount( WINE_MODREF
*wm
)
1564 if ( wm
->flags
& WINE_MODREF_MARKER
)
1567 if ( wm
->refCount
<= 0 )
1571 TRACE("(%s) refCount: %d\n", wm
->modname
, wm
->refCount
);
1573 if ( wm
->refCount
== 0 )
1575 wm
->flags
|= WINE_MODREF_MARKER
;
1577 for ( i
= 0; i
< wm
->nDeps
; i
++ )
1579 MODULE_DecRefCount( wm
->deps
[i
] );
1581 wm
->flags
&= ~WINE_MODREF_MARKER
;
1585 /***********************************************************************
1586 * MODULE_FreeLibrary
1588 * NOTE: Assumes that the process critical section is held!
1590 BOOL
MODULE_FreeLibrary( WINE_MODREF
*wm
)
1592 TRACE("(%s) - START\n", wm
->modname
);
1594 /* Recursively decrement reference counts */
1595 MODULE_DecRefCount( wm
);
1597 /* Call process detach notifications */
1598 if ( free_lib_count
<= 1 )
1600 MODULE_DllProcessDetach( FALSE
, NULL
);
1601 SERVER_START_REQ( unload_dll
)
1603 req
->base
= (void *)wm
->module
;
1607 MODULE_FlushModrefs();
1616 /***********************************************************************
1617 * FreeLibraryAndExitThread
1619 VOID WINAPI
FreeLibraryAndExitThread(HINSTANCE hLibModule
, DWORD dwExitCode
)
1621 FreeLibrary(hLibModule
);
1622 ExitThread(dwExitCode
);
1625 /***********************************************************************
1626 * PrivateLoadLibrary (KERNEL32)
1628 * FIXME: rough guesswork, don't know what "Private" means
1630 HINSTANCE WINAPI
PrivateLoadLibrary(LPCSTR libname
)
1632 return (HINSTANCE
)LoadLibrary16(libname
);
1637 /***********************************************************************
1638 * PrivateFreeLibrary (KERNEL32)
1640 * FIXME: rough guesswork, don't know what "Private" means
1642 void WINAPI
PrivateFreeLibrary(HINSTANCE handle
)
1644 FreeLibrary16((HINSTANCE16
)handle
);
1648 /***********************************************************************
1649 * WIN32_GetProcAddress16 (KERNEL32.36)
1650 * Get procaddress in 16bit module from win32... (kernel32 undoc. ordinal func)
1652 FARPROC16 WINAPI
WIN32_GetProcAddress16( HMODULE hModule
, LPCSTR name
)
1655 WARN("hModule may not be 0!\n");
1656 return (FARPROC16
)0;
1658 if (HIWORD(hModule
))
1660 WARN("hModule is Win32 handle (%08x)\n", hModule
);
1661 return (FARPROC16
)0;
1663 return GetProcAddress16( hModule
, name
);
1666 /***********************************************************************
1667 * GetProcAddress16 (KERNEL.50)
1669 FARPROC16 WINAPI
GetProcAddress16( HMODULE16 hModule
, LPCSTR name
)
1674 if (!hModule
) hModule
= GetCurrentTask();
1675 hModule
= GetExePtr( hModule
);
1677 if (HIWORD(name
) != 0)
1679 ordinal
= NE_GetOrdinal( hModule
, name
);
1680 TRACE("%04x '%s'\n", hModule
, name
);
1684 ordinal
= LOWORD(name
);
1685 TRACE("%04x %04x\n", hModule
, ordinal
);
1687 if (!ordinal
) return (FARPROC16
)0;
1689 ret
= NE_GetEntryPoint( hModule
, ordinal
);
1691 TRACE("returning %08x\n", (UINT
)ret
);
1696 /***********************************************************************
1697 * GetProcAddress (KERNEL32.257)
1699 FARPROC WINAPI
GetProcAddress( HMODULE hModule
, LPCSTR function
)
1701 return MODULE_GetProcAddress( hModule
, function
, TRUE
);
1704 /***********************************************************************
1705 * GetProcAddress32 (KERNEL.453)
1707 FARPROC WINAPI
GetProcAddress32_16( HMODULE hModule
, LPCSTR function
)
1709 return MODULE_GetProcAddress( hModule
, function
, FALSE
);
1712 /***********************************************************************
1713 * MODULE_GetProcAddress (internal)
1715 FARPROC
MODULE_GetProcAddress(
1716 HMODULE hModule
, /* [in] current module handle */
1717 LPCSTR function
, /* [in] function to be looked up */
1721 FARPROC retproc
= 0;
1723 if (HIWORD(function
))
1724 TRACE_(win32
)("(%08lx,%s)\n",(DWORD
)hModule
,function
);
1726 TRACE_(win32
)("(%08lx,%p)\n",(DWORD
)hModule
,function
);
1728 RtlAcquirePebLock();
1729 if ((wm
= MODULE32_LookupHMODULE( hModule
)))
1731 retproc
= wm
->find_export( wm
, function
, snoop
);
1732 if (!retproc
) SetLastError(ERROR_PROC_NOT_FOUND
);
1734 RtlReleasePebLock();
1739 /***************************************************************************
1740 * HasGPHandler (KERNEL.338)
1743 #include "pshpack1.h"
1744 typedef struct _GPHANDLERDEF
1751 #include "poppack.h"
1753 SEGPTR WINAPI
HasGPHandler16( SEGPTR address
)
1758 GPHANDLERDEF
*gpHandler
;
1760 if ( (hModule
= FarGetOwner16( SELECTOROF(address
) )) != 0
1761 && (gpOrdinal
= NE_GetOrdinal( hModule
, "__GP" )) != 0
1762 && (gpPtr
= (SEGPTR
)NE_GetEntryPointEx( hModule
, gpOrdinal
, FALSE
)) != 0
1763 && !IsBadReadPtr16( gpPtr
, sizeof(GPHANDLERDEF
) )
1764 && (gpHandler
= MapSL( gpPtr
)) != NULL
)
1766 while (gpHandler
->selector
)
1768 if ( SELECTOROF(address
) == gpHandler
->selector
1769 && OFFSETOF(address
) >= gpHandler
->rangeStart
1770 && OFFSETOF(address
) < gpHandler
->rangeEnd
)
1771 return MAKESEGPTR( gpHandler
->selector
, gpHandler
->handler
);