4 * Copyright 1996, 1998 Alexandre Julliard
15 #include "wine/winbase16.h"
16 #include "wine/exception.h"
17 #include "wine/library.h"
28 #include "debugtools.h"
30 DEFAULT_DEBUG_CHANNEL(process
);
31 DECLARE_DEBUG_CHANNEL(relay
);
32 DECLARE_DEBUG_CHANNEL(win32
);
36 /* Win32 process database */
39 LONG header
[2]; /* 00 Kernel object header */
40 HMODULE module
; /* 08 Main exe module (NT) */
41 void *event
; /* 0c Pointer to an event object (unused) */
42 DWORD exit_code
; /* 10 Process exit code */
43 DWORD unknown2
; /* 14 Unknown */
44 HANDLE heap
; /* 18 Default process heap */
45 HANDLE mem_context
; /* 1c Process memory context */
46 DWORD flags
; /* 20 Flags */
47 void *pdb16
; /* 24 DOS PSP */
48 WORD PSP_sel
; /* 28 Selector to DOS PSP */
49 WORD imte
; /* 2a IMTE for the process module */
50 WORD threads
; /* 2c Number of threads */
51 WORD running_threads
; /* 2e Number of running threads */
52 WORD free_lib_count
; /* 30 Recursion depth of FreeLibrary calls */
53 WORD ring0_threads
; /* 32 Number of ring 0 threads */
54 HANDLE system_heap
; /* 34 System heap to allocate handles */
55 HTASK task
; /* 38 Win16 task */
56 void *mem_map_files
; /* 3c Pointer to mem-mapped files */
57 struct _ENVDB
*env_db
; /* 40 Environment database */
58 void *handle_table
; /* 44 Handle table */
59 struct _PDB
*parent
; /* 48 Parent process */
60 void *modref_list
; /* 4c MODREF list */
61 void *thread_list
; /* 50 List of threads */
62 void *debuggee_CB
; /* 54 Debuggee context block */
63 void *local_heap_free
; /* 58 Head of local heap free list */
64 DWORD unknown4
; /* 5c Unknown */
65 CRITICAL_SECTION crit_section
; /* 60 Critical section */
66 DWORD unknown5
[3]; /* 78 Unknown */
67 void *console
; /* 84 Console */
68 DWORD tls_bits
[2]; /* 88 TLS in-use bits */
69 DWORD process_dword
; /* 90 Unknown */
70 struct _PDB
*group
; /* 94 Process group */
71 void *exe_modref
; /* 98 MODREF for the process EXE */
72 void *top_filter
; /* 9c Top exception filter */
73 DWORD priority
; /* a0 Priority level */
74 HANDLE heap_list
; /* a4 Head of process heap list */
75 void *heap_handles
; /* a8 Head of heap handles list */
76 DWORD unknown6
; /* ac Unknown */
77 void *console_provider
; /* b0 Console provider (??) */
78 WORD env_selector
; /* b4 Selector to process environment */
79 WORD error_mode
; /* b6 Error mode */
80 HANDLE load_done_evt
; /* b8 Event for process loading done */
81 void *UTState
; /* bc Head of Univeral Thunk list */
82 DWORD unknown8
; /* c0 Unknown (NT) */
83 LCID locale
; /* c4 Locale to be queried by GetThreadLocale (NT) */
89 #define PDB32_DEBUGGED 0x0001 /* Process is being debugged */
90 #define PDB32_WIN16_PROC 0x0008 /* Win16 process */
91 #define PDB32_DOS_PROC 0x0010 /* Dos process */
92 #define PDB32_CONSOLE_PROC 0x0020 /* Console process */
93 #define PDB32_FILE_APIS_OEM 0x0040 /* File APIs are OEM */
94 #define PDB32_WIN32S_PROC 0x8000 /* Win32s process */
96 static char **main_exe_argv
;
97 static char main_exe_name
[MAX_PATH
];
98 static HANDLE main_exe_file
= INVALID_HANDLE_VALUE
;
100 unsigned int server_startticks
;
102 /* memory/environ.c */
103 extern struct _ENVDB
*ENV_BuildEnvironment(void);
104 extern BOOL
ENV_BuildCommandLine( char **argv
);
105 extern STARTUPINFOA current_startupinfo
;
107 extern BOOL
MAIN_MainInit(void);
110 /***********************************************************************
111 * PROCESS_CallUserSignalProc
113 * FIXME: Some of the signals aren't sent correctly!
115 * The exact meaning of the USER signals is undocumented, but this
116 * should cover the basic idea:
118 * USIG_DLL_UNLOAD_WIN16
119 * This is sent when a 16-bit module is unloaded.
121 * USIG_DLL_UNLOAD_WIN32
122 * This is sent when a 32-bit module is unloaded.
124 * USIG_DLL_UNLOAD_ORPHANS
125 * This is sent after the last Win3.1 module is unloaded,
126 * to allow removal of orphaned menus.
128 * USIG_FAULT_DIALOG_PUSH
129 * USIG_FAULT_DIALOG_POP
130 * These are called to allow USER to prepare for displaying a
131 * fault dialog, even though the fault might have happened while
132 * inside a USER critical section.
135 * This is called from the context of a new thread, as soon as it
136 * has started to run.
139 * This is called, still in its context, just before a thread is
140 * about to terminate.
142 * USIG_PROCESS_CREATE
143 * This is called, in the parent process context, after a new process
147 * This is called in the new process context, just after the main thread
148 * has started execution (after the main thread's USIG_THREAD_INIT has
151 * USIG_PROCESS_LOADED
152 * This is called after the executable file has been loaded into the
153 * new process context.
155 * USIG_PROCESS_RUNNING
156 * This is called immediately before the main entry point is called.
159 * This is called in the context of a process that is about to
160 * terminate (but before the last thread's USIG_THREAD_EXIT has
163 * USIG_PROCESS_DESTROY
164 * This is called after a process has terminated.
167 * The meaning of the dwFlags bits is as follows:
170 * Current process is 32-bit.
173 * Current process is a (Win32) GUI process.
175 * USIG_FLAGS_FEEDBACK
176 * Current process needs 'feedback' (determined from the STARTUPINFO
177 * flags STARTF_FORCEONFEEDBACK / STARTF_FORCEOFFFEEDBACK).
180 * The signal is being sent due to a fault.
182 void PROCESS_CallUserSignalProc( UINT uCode
, HMODULE hModule
)
184 DWORD flags
= current_process
.flags
;
185 DWORD startup_flags
= current_startupinfo
.dwFlags
;
188 /* Determine dwFlags */
190 if ( !(flags
& PDB32_WIN16_PROC
) ) dwFlags
|= USIG_FLAGS_WIN32
;
192 if ( !(flags
& PDB32_CONSOLE_PROC
) ) dwFlags
|= USIG_FLAGS_GUI
;
194 if ( dwFlags
& USIG_FLAGS_GUI
)
196 /* Feedback defaults to ON */
197 if ( !(startup_flags
& STARTF_FORCEOFFFEEDBACK
) )
198 dwFlags
|= USIG_FLAGS_FEEDBACK
;
202 /* Feedback defaults to OFF */
203 if (startup_flags
& STARTF_FORCEONFEEDBACK
)
204 dwFlags
|= USIG_FLAGS_FEEDBACK
;
207 /* Convert module handle to 16-bit */
209 if ( HIWORD( hModule
) )
210 hModule
= MapHModuleLS( hModule
);
212 /* Call USER signal proc */
214 if ( Callout
.UserSignalProc
)
216 if ( uCode
== USIG_THREAD_INIT
|| uCode
== USIG_THREAD_EXIT
)
217 Callout
.UserSignalProc( uCode
, GetCurrentThreadId(), dwFlags
, hModule
);
219 Callout
.UserSignalProc( uCode
, GetCurrentProcessId(), dwFlags
, hModule
);
224 /***********************************************************************
227 * Main process initialisation code
229 static BOOL
process_init( char *argv
[] )
233 /* store the program name */
235 main_exe_argv
= argv
;
237 /* Fill the initial process structure */
238 current_process
.exit_code
= STILL_ACTIVE
;
239 current_process
.threads
= 1;
240 current_process
.running_threads
= 1;
241 current_process
.ring0_threads
= 1;
242 current_process
.group
= ¤t_process
;
243 current_process
.priority
= 8; /* Normal */
245 /* Setup the server connection */
246 NtCurrentTeb()->socket
= CLIENT_InitServer();
247 if (CLIENT_InitThread()) return FALSE
;
249 /* Retrieve startup info from the server */
252 struct init_process_request
*req
= server_alloc_req( sizeof(*req
),
253 sizeof(main_exe_name
)-1 );
255 req
->ldt_copy
= &wine_ldt_copy
;
256 req
->ppid
= getppid();
257 if ((ret
= !server_call( REQ_INIT_PROCESS
)))
259 size_t len
= server_data_size( req
);
260 memcpy( main_exe_name
, server_data_ptr(req
), len
);
261 main_exe_name
[len
] = 0;
262 main_exe_file
= req
->exe_file
;
263 current_startupinfo
.dwFlags
= req
->start_flags
;
264 server_startticks
= req
->server_start
;
265 current_startupinfo
.wShowWindow
= req
->cmd_show
;
266 current_startupinfo
.hStdInput
= req
->hstdin
;
267 current_startupinfo
.hStdOutput
= req
->hstdout
;
268 current_startupinfo
.hStdError
= req
->hstderr
;
269 SetStdHandle( STD_INPUT_HANDLE
, current_startupinfo
.hStdInput
);
270 SetStdHandle( STD_OUTPUT_HANDLE
, current_startupinfo
.hStdOutput
);
271 SetStdHandle( STD_ERROR_HANDLE
, current_startupinfo
.hStdError
);
275 if (!ret
) return FALSE
;
277 /* Create the system and process heaps */
278 if (!HEAP_CreateSystemHeap()) return FALSE
;
279 current_process
.heap
= HeapCreate( HEAP_GROWABLE
, 0, 0 );
281 /* Copy the parent environment */
282 if (!(current_process
.env_db
= ENV_BuildEnvironment())) return FALSE
;
284 /* Parse command line arguments */
285 OPTIONS_ParseOptions( argv
);
287 return MAIN_MainInit();
291 /***********************************************************************
294 * Startup routine of a new process. Runs on the new process stack.
296 static void start_process(void)
298 int debugged
, console_app
;
299 LPTHREAD_START_ROUTINE entry
;
302 /* build command line */
303 if (!ENV_BuildCommandLine( main_exe_argv
)) goto error
;
305 /* create 32-bit module for main exe */
306 if (!(current_process
.module
= BUILTIN32_LoadExeModule( current_process
.module
))) goto error
;
308 /* use original argv[0] as name for the main module */
309 if (!main_exe_name
[0])
311 if (!GetLongPathNameA( full_argv0
, main_exe_name
, sizeof(main_exe_name
) ))
312 lstrcpynA( main_exe_name
, full_argv0
, sizeof(main_exe_name
) );
315 /* Retrieve entry point address */
316 entry
= (LPTHREAD_START_ROUTINE
)((char*)current_process
.module
+
317 PE_HEADER(current_process
.module
)->OptionalHeader
.AddressOfEntryPoint
);
318 console_app
= (PE_HEADER(current_process
.module
)->OptionalHeader
.Subsystem
== IMAGE_SUBSYSTEM_WINDOWS_CUI
);
319 if (console_app
) current_process
.flags
|= PDB32_CONSOLE_PROC
;
321 /* Signal the parent process to continue */
324 struct init_process_done_request
*req
= server_alloc_req( sizeof(*req
), 0 );
325 req
->module
= (void *)current_process
.module
;
327 req
->name
= main_exe_name
;
328 req
->gui
= !console_app
;
329 server_call( REQ_INIT_PROCESS_DONE
);
330 debugged
= req
->debugged
;
334 /* Install signal handlers; this cannot be done before, since we cannot
335 * send exceptions to the debugger before the create process event that
336 * is sent by REQ_INIT_PROCESS_DONE */
337 if (!SIGNAL_Init()) goto error
;
339 /* create the main modref and load dependencies */
340 if (!(wm
= PE_CreateModule( current_process
.module
, main_exe_name
, 0, main_exe_file
, FALSE
)))
346 MODULE_DllProcessAttach( NULL
, (LPVOID
)1 );
349 /* Get pointers to USER routines called by KERNEL */
352 /* Call FinalUserInit routine */
353 if (Callout
.FinalUserInit16
) Callout
.FinalUserInit16();
355 /* Note: The USIG_PROCESS_CREATE signal is supposed to be sent in the
356 * context of the parent process. Actually, the USER signal proc
357 * doesn't really care about that, but it *does* require that the
358 * startup parameters are correctly set up, so that GetProcessDword
359 * works. Furthermore, before calling the USER signal proc the
360 * 16-bit stack must be set up, which it is only after TASK_Create
361 * in the case of a 16-bit process. Thus, we send the signal here.
363 PROCESS_CallUserSignalProc( USIG_PROCESS_CREATE
, 0 );
364 PROCESS_CallUserSignalProc( USIG_THREAD_INIT
, 0 );
365 PROCESS_CallUserSignalProc( USIG_PROCESS_INIT
, 0 );
366 PROCESS_CallUserSignalProc( USIG_PROCESS_LOADED
, 0 );
367 /* Call UserSignalProc ( USIG_PROCESS_RUNNING ... ) only for non-GUI win32 apps */
368 if (console_app
) PROCESS_CallUserSignalProc( USIG_PROCESS_RUNNING
, 0 );
370 TRACE_(relay
)( "Starting Win32 process %s (entryproc=%p)\n", main_exe_name
, entry
);
371 if (debugged
) DbgBreakPoint();
372 /* FIXME: should use _PEB as parameter for NT 3.5 programs !
373 * Dunno about other OSs */
374 SetLastError(0); /* clear error code */
375 ExitThread( entry(NULL
) );
378 ExitProcess( GetLastError() );
382 /***********************************************************************
385 * Try to open the Winelib app .so file based on argv[0] or WINEPRELOAD.
387 void *open_winelib_app( char *argv
[] )
393 if ((name
= getenv( "WINEPRELOAD" )))
395 if (!(ret
= wine_dll_load_main_exe( name
, 0 )))
397 MESSAGE( "%s: could not load '%s' as specified in the WINEPRELOAD environment variable\n",
404 /* if argv[0] is "wine", don't try to load anything */
405 if (!(name
= strrchr( argv
[0], '/' ))) name
= argv
[0];
407 if (!strcmp( name
, "wine" )) return NULL
;
409 /* now try argv[0] with ".so" appended */
410 if ((tmp
= HeapAlloc( GetProcessHeap(), 0, strlen(argv
[0]) + 4 )))
412 strcpy( tmp
, argv
[0] );
413 strcat( tmp
, ".so" );
414 /* search in PATH only if there was no '/' in argv[0] */
415 ret
= wine_dll_load_main_exe( tmp
, (name
== argv
[0]) );
416 if (!ret
&& !argv
[1])
418 /* if no argv[1], this will be better than displaying usage */
419 MESSAGE( "%s: could not load library '%s' as Winelib application\n",
423 HeapFree( GetProcessHeap(), 0, tmp
);
429 /***********************************************************************
432 * Wine initialisation: load and start the main exe file.
434 void PROCESS_InitWine( int argc
, char *argv
[] )
436 DWORD stack_size
= 0;
438 /* Initialize everything */
439 if (!process_init( argv
)) exit(1);
441 if (open_winelib_app( argv
)) goto found
; /* try to open argv[0] as a winelib app */
443 main_exe_argv
= ++argv
; /* remove argv[0] (wine itself) */
445 if (!main_exe_name
[0])
447 if (!argv
[0]) OPTIONS_Usage();
449 /* open the exe file */
450 if (!SearchPathA( NULL
, argv
[0], ".exe", sizeof(main_exe_name
), main_exe_name
, NULL
) &&
451 !SearchPathA( NULL
, argv
[0], NULL
, sizeof(main_exe_name
), main_exe_name
, NULL
))
453 MESSAGE( "%s: cannot find '%s'\n", argv0
, argv
[0] );
458 if (main_exe_file
== INVALID_HANDLE_VALUE
)
460 if ((main_exe_file
= CreateFileA( main_exe_name
, GENERIC_READ
, FILE_SHARE_READ
,
461 NULL
, OPEN_EXISTING
, 0, -1 )) == INVALID_HANDLE_VALUE
)
463 MESSAGE( "%s: cannot open '%s'\n", argv0
, main_exe_name
);
468 /* first try Win32 format; this will fail if the file is not a PE binary */
469 if ((current_process
.module
= PE_LoadImage( main_exe_file
, main_exe_name
, 0 )))
471 if (PE_HEADER(current_process
.module
)->FileHeader
.Characteristics
& IMAGE_FILE_DLL
)
472 ExitProcess( ERROR_BAD_EXE_FORMAT
);
473 stack_size
= PE_HEADER(current_process
.module
)->OptionalHeader
.SizeOfStackReserve
;
477 /* it must be 16-bit or DOS format */
478 NtCurrentTeb()->tibflags
&= ~TEBF_WIN32
;
479 current_process
.flags
|= PDB32_WIN16_PROC
;
480 main_exe_name
[0] = 0;
481 CloseHandle( main_exe_file
);
482 main_exe_file
= INVALID_HANDLE_VALUE
;
486 /* allocate main thread stack */
487 if (!THREAD_InitStack( NtCurrentTeb(), stack_size
, TRUE
)) goto error
;
489 /* switch to the new stack */
490 SYSDEPS_SwitchToThreadStack( start_process
);
493 ExitProcess( GetLastError() );
497 /***********************************************************************
498 * PROCESS_InitWinelib
500 * Initialisation of a new Winelib process.
502 void PROCESS_InitWinelib( int argc
, char *argv
[] )
504 if (!process_init( argv
)) exit(1);
506 /* allocate main thread stack */
507 if (!THREAD_InitStack( NtCurrentTeb(), 0, TRUE
)) ExitProcess( GetLastError() );
509 /* switch to the new stack */
510 SYSDEPS_SwitchToThreadStack( start_process
);
514 /***********************************************************************
517 * Build an argv array from a command-line.
518 * The command-line is modified to insert nulls.
519 * 'reserved' is the number of args to reserve before the first one.
521 static char **build_argv( char *cmdline
, int reserved
)
524 int count
= reserved
+ 1;
527 /* if first word is quoted store it as a single arg */
528 if (*cmdline
== '\"')
530 if ((p
= strchr( cmdline
+ 1, '\"' )))
539 while (*p
&& isspace(*p
)) p
++;
542 while (*p
&& !isspace(*p
)) p
++;
545 if ((argv
= malloc( count
* sizeof(*argv
) )))
547 char **argvptr
= argv
+ reserved
;
549 if (*cmdline
== '\"')
551 if ((p
= strchr( cmdline
+ 1, '\"' )))
553 *argvptr
++ = cmdline
+ 1;
560 while (*p
&& isspace(*p
)) *p
++ = 0;
563 while (*p
&& !isspace(*p
)) p
++;
571 /***********************************************************************
574 * Build the environment of a new child process.
576 static char **build_envp( const char *env
, const char *extra_env
)
582 if (extra_env
) for (p
= extra_env
; *p
; count
++) p
+= strlen(p
) + 1;
583 for (p
= env
; *p
; count
++) p
+= strlen(p
) + 1;
586 if ((envp
= malloc( count
* sizeof(*envp
) )))
588 extern char **environ
;
589 char **envptr
= envp
;
590 char **unixptr
= environ
;
591 /* first the extra strings */
592 if (extra_env
) for (p
= extra_env
; *p
; p
+= strlen(p
) + 1) *envptr
++ = (char *)p
;
593 /* then put PATH, HOME and WINEPREFIX from the unix env */
594 for (unixptr
= environ
; unixptr
&& *unixptr
; unixptr
++)
595 if (!memcmp( *unixptr
, "PATH=", 5 ) ||
596 !memcmp( *unixptr
, "HOME=", 5 ) ||
597 !memcmp( *unixptr
, "WINEPREFIX=", 11 )) *envptr
++ = *unixptr
;
598 /* now put the Windows environment strings */
599 for (p
= env
; *p
; p
+= strlen(p
) + 1)
601 if (memcmp( p
, "PATH=", 5 ) &&
602 memcmp( p
, "HOME=", 5 ) &&
603 memcmp( p
, "WINEPRELOAD=", 12 ) &&
604 memcmp( p
, "WINEPREFIX=", 11 )) *envptr
++ = (char *)p
;
612 /***********************************************************************
615 * Locate the Wine binary to exec for a new Win32 process.
617 static void exec_wine_binary( char **argv
, char **envp
)
619 const char *path
, *pos
, *ptr
;
621 /* first, try for a WINELOADER environment variable */
622 argv
[0] = getenv("WINELOADER");
624 execve( argv
[0], argv
, envp
);
626 /* next, try bin directory */
627 argv
[0] = BINDIR
"/wine";
628 execve( argv
[0], argv
, envp
);
630 /* now try the path of argv0 of the current binary */
631 if (!(argv
[0] = malloc( strlen(full_argv0
) + 6 ))) return;
632 if ((ptr
= strrchr( full_argv0
, '/' )))
634 memcpy( argv
[0], full_argv0
, ptr
- full_argv0
);
635 strcpy( argv
[0] + (ptr
- full_argv0
), "/wine" );
636 execve( argv
[0], argv
, envp
);
640 /* now search in the Unix path */
641 if ((path
= getenv( "PATH" )))
643 if (!(argv
[0] = malloc( strlen(path
) + 6 ))) return;
647 while (*pos
== ':') pos
++;
649 if (!(ptr
= strchr( pos
, ':' ))) ptr
= pos
+ strlen(pos
);
650 memcpy( argv
[0], pos
, ptr
- pos
);
651 strcpy( argv
[0] + (ptr
- pos
), "/wine" );
652 execve( argv
[0], argv
, envp
);
658 /* finally try the current directory */
660 execve( argv
[0], argv
, envp
);
664 /***********************************************************************
667 * Fork and exec a new Unix process, checking for errors.
669 static int fork_and_exec( const char *filename
, char *cmdline
,
670 const char *env
, const char *newdir
)
674 char *extra_env
= NULL
;
678 env
= GetEnvironmentStringsA();
679 extra_env
= DRIVE_BuildEnv();
687 fcntl( fd
[1], F_SETFD
, 1 ); /* set close on exec */
688 if (!(pid
= fork())) /* child */
690 char **argv
= build_argv( cmdline
, filename
? 0 : 2 );
691 char **envp
= build_envp( env
, extra_env
);
694 if (newdir
) chdir(newdir
);
701 exec_wine_binary( argv
, envp
);
703 else execve( filename
, argv
, envp
);
706 write( fd
[1], &err
, sizeof(err
) );
710 if ((pid
!= -1) && (read( fd
[0], &err
, sizeof(err
) ) > 0)) /* exec failed */
715 if (pid
== -1) FILE_SetDosError();
717 if (extra_env
) HeapFree( GetProcessHeap(), 0, extra_env
);
722 /***********************************************************************
725 * Create a new process. If hFile is a valid handle we have an exe
726 * file, and we exec a new copy of wine to load it; otherwise we
727 * simply exec the specified filename as a Unix process.
729 BOOL
PROCESS_Create( HFILE hFile
, LPCSTR filename
, LPSTR cmd_line
, LPCSTR env
,
730 LPSECURITY_ATTRIBUTES psa
, LPSECURITY_ATTRIBUTES tsa
,
731 BOOL inherit
, DWORD flags
, LPSTARTUPINFOA startup
,
732 LPPROCESS_INFORMATION info
, LPCSTR lpCurrentDirectory
)
736 const char *unixfilename
= NULL
;
737 const char *unixdir
= NULL
;
738 DOS_FULL_NAME full_name
;
739 HANDLE load_done_evt
= (HANDLE
)-1;
741 info
->hThread
= info
->hProcess
= INVALID_HANDLE_VALUE
;
743 if (lpCurrentDirectory
)
745 if (DOSFS_GetFullName( lpCurrentDirectory
, TRUE
, &full_name
))
746 unixdir
= full_name
.long_name
;
751 if (GetCurrentDirectoryA(sizeof(buf
),buf
))
753 if (DOSFS_GetFullName( buf
, TRUE
, &full_name
))
754 unixdir
= full_name
.long_name
;
758 /* create the process on the server side */
762 size_t len
= (hFile
== -1) ? 0 : MAX_PATH
;
763 struct new_process_request
*req
= server_alloc_req( sizeof(*req
), len
);
764 req
->inherit_all
= inherit
;
765 req
->create_flags
= flags
;
766 req
->start_flags
= startup
->dwFlags
;
767 req
->exe_file
= hFile
;
768 if (startup
->dwFlags
& STARTF_USESTDHANDLES
)
770 req
->hstdin
= startup
->hStdInput
;
771 req
->hstdout
= startup
->hStdOutput
;
772 req
->hstderr
= startup
->hStdError
;
776 req
->hstdin
= GetStdHandle( STD_INPUT_HANDLE
);
777 req
->hstdout
= GetStdHandle( STD_OUTPUT_HANDLE
);
778 req
->hstderr
= GetStdHandle( STD_ERROR_HANDLE
);
780 req
->cmd_show
= startup
->wShowWindow
;
782 if (hFile
== -1) /* unix process */
784 unixfilename
= filename
;
785 if (DOSFS_GetFullName( filename
, TRUE
, &full_name
))
786 unixfilename
= full_name
.long_name
;
788 else /* new wine process */
790 if (!GetLongPathNameA( filename
, server_data_ptr(req
), MAX_PATH
))
791 lstrcpynA( server_data_ptr(req
), filename
, MAX_PATH
);
793 ret
= !server_call( REQ_NEW_PROCESS
);
796 if (!ret
) return FALSE
;
798 /* fork and execute */
800 pid
= fork_and_exec( unixfilename
, cmd_line
, env
, unixdir
);
804 struct wait_process_request
*req
= server_alloc_req( sizeof(*req
), 0 );
805 req
->cancel
= (pid
== -1);
806 req
->pinherit
= (psa
&& (psa
->nLength
>= sizeof(*psa
)) && psa
->bInheritHandle
);
807 req
->tinherit
= (tsa
&& (tsa
->nLength
>= sizeof(*tsa
)) && tsa
->bInheritHandle
);
809 if ((ret
= !server_call( REQ_WAIT_PROCESS
)) && (pid
!= -1))
811 info
->dwProcessId
= (DWORD
)req
->pid
;
812 info
->dwThreadId
= (DWORD
)req
->tid
;
813 info
->hProcess
= req
->phandle
;
814 info
->hThread
= req
->thandle
;
815 load_done_evt
= req
->event
;
819 if (!ret
|| (pid
== -1)) goto error
;
821 /* Wait until process is initialized (or initialization failed) */
822 if (load_done_evt
!= (HANDLE
)-1)
827 handles
[0] = info
->hProcess
;
828 handles
[1] = load_done_evt
;
829 res
= WaitForMultipleObjects( 2, handles
, FALSE
, INFINITE
);
830 CloseHandle( load_done_evt
);
831 if (res
== STATUS_WAIT_0
) /* the process died */
834 if (GetExitCodeProcess( info
->hProcess
, &exitcode
)) SetLastError( exitcode
);
835 CloseHandle( info
->hThread
);
836 CloseHandle( info
->hProcess
);
843 if (load_done_evt
!= (HANDLE
)-1) CloseHandle( load_done_evt
);
844 if (info
->hThread
!= INVALID_HANDLE_VALUE
) CloseHandle( info
->hThread
);
845 if (info
->hProcess
!= INVALID_HANDLE_VALUE
) CloseHandle( info
->hProcess
);
850 /***********************************************************************
851 * ExitProcess (KERNEL32.100)
853 void WINAPI
ExitProcess( DWORD status
)
855 MODULE_DllProcessDetach( TRUE
, (LPVOID
)1 );
858 struct terminate_process_request
*req
= server_alloc_req( sizeof(*req
), 0 );
859 /* send the exit code to the server */
860 req
->handle
= GetCurrentProcess();
861 req
->exit_code
= status
;
862 server_call( REQ_TERMINATE_PROCESS
);
868 /***********************************************************************
869 * ExitProcess16 (KERNEL.466)
871 void WINAPI
ExitProcess16( WORD status
)
874 ReleaseThunkLock( &count
);
875 ExitProcess( status
);
878 /******************************************************************************
879 * TerminateProcess (KERNEL32.684)
881 BOOL WINAPI
TerminateProcess( HANDLE handle
, DWORD exit_code
)
883 NTSTATUS status
= NtTerminateProcess( handle
, exit_code
);
884 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
889 /***********************************************************************
890 * GetProcessDword (KERNEL32.18) (KERNEL.485)
891 * 'Of course you cannot directly access Windows internal structures'
893 DWORD WINAPI
GetProcessDword( DWORD dwProcessID
, INT offset
)
898 TRACE_(win32
)("(%ld, %d)\n", dwProcessID
, offset
);
900 if (dwProcessID
&& dwProcessID
!= GetCurrentProcessId())
902 ERR("%d: process %lx not accessible\n", offset
, dwProcessID
);
908 case GPD_APP_COMPAT_FLAGS
:
909 pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
910 return pTask
? pTask
->compat_flags
: 0;
912 case GPD_LOAD_DONE_EVENT
:
913 return current_process
.load_done_evt
;
915 case GPD_HINSTANCE16
:
916 pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
917 return pTask
? pTask
->hInstance
: 0;
919 case GPD_WINDOWS_VERSION
:
920 pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
921 return pTask
? pTask
->version
: 0;
924 return (DWORD
)NtCurrentTeb() - 0x10 /* FIXME */;
927 return (DWORD
)¤t_process
;
929 case GPD_STARTF_SHELLDATA
: /* return stdoutput handle from startupinfo ??? */
930 return current_startupinfo
.hStdOutput
;
932 case GPD_STARTF_HOTKEY
: /* return stdinput handle from startupinfo ??? */
933 return current_startupinfo
.hStdInput
;
935 case GPD_STARTF_SHOWWINDOW
:
936 return current_startupinfo
.wShowWindow
;
938 case GPD_STARTF_SIZE
:
939 x
= current_startupinfo
.dwXSize
;
940 if ( (INT
)x
== CW_USEDEFAULT
) x
= CW_USEDEFAULT16
;
941 y
= current_startupinfo
.dwYSize
;
942 if ( (INT
)y
== CW_USEDEFAULT
) y
= CW_USEDEFAULT16
;
943 return MAKELONG( x
, y
);
945 case GPD_STARTF_POSITION
:
946 x
= current_startupinfo
.dwX
;
947 if ( (INT
)x
== CW_USEDEFAULT
) x
= CW_USEDEFAULT16
;
948 y
= current_startupinfo
.dwY
;
949 if ( (INT
)y
== CW_USEDEFAULT
) y
= CW_USEDEFAULT16
;
950 return MAKELONG( x
, y
);
952 case GPD_STARTF_FLAGS
:
953 return current_startupinfo
.dwFlags
;
959 return current_process
.flags
;
962 return current_process
.process_dword
;
965 ERR_(win32
)("Unknown offset %d\n", offset
);
970 /***********************************************************************
971 * SetProcessDword (KERNEL.484)
972 * 'Of course you cannot directly access Windows internal structures'
974 void WINAPI
SetProcessDword( DWORD dwProcessID
, INT offset
, DWORD value
)
976 TRACE_(win32
)("(%ld, %d)\n", dwProcessID
, offset
);
978 if (dwProcessID
&& dwProcessID
!= GetCurrentProcessId())
980 ERR("%d: process %lx not accessible\n", offset
, dwProcessID
);
986 case GPD_APP_COMPAT_FLAGS
:
987 case GPD_LOAD_DONE_EVENT
:
988 case GPD_HINSTANCE16
:
989 case GPD_WINDOWS_VERSION
:
992 case GPD_STARTF_SHELLDATA
:
993 case GPD_STARTF_HOTKEY
:
994 case GPD_STARTF_SHOWWINDOW
:
995 case GPD_STARTF_SIZE
:
996 case GPD_STARTF_POSITION
:
997 case GPD_STARTF_FLAGS
:
1000 ERR_(win32
)("Not allowed to modify offset %d\n", offset
);
1004 current_process
.process_dword
= value
;
1008 ERR_(win32
)("Unknown offset %d\n", offset
);
1014 /*********************************************************************
1015 * OpenProcess (KERNEL32.543)
1017 HANDLE WINAPI
OpenProcess( DWORD access
, BOOL inherit
, DWORD id
)
1022 struct open_process_request
*req
= server_alloc_req( sizeof(*req
), 0 );
1024 req
->pid
= (void *)id
;
1025 req
->access
= access
;
1026 req
->inherit
= inherit
;
1027 if (!server_call( REQ_OPEN_PROCESS
)) ret
= req
->handle
;
1033 /*********************************************************************
1034 * MapProcessHandle (KERNEL.483)
1036 DWORD WINAPI
MapProcessHandle( HANDLE handle
)
1041 struct get_process_info_request
*req
= server_alloc_req( sizeof(*req
), 0 );
1042 req
->handle
= handle
;
1043 if (!server_call( REQ_GET_PROCESS_INFO
)) ret
= (DWORD
)req
->pid
;
1049 /***********************************************************************
1050 * SetPriorityClass (KERNEL32.503)
1052 BOOL WINAPI
SetPriorityClass( HANDLE hprocess
, DWORD priorityclass
)
1057 struct set_process_info_request
*req
= server_alloc_req( sizeof(*req
), 0 );
1058 req
->handle
= hprocess
;
1059 req
->priority
= priorityclass
;
1060 req
->mask
= SET_PROCESS_INFO_PRIORITY
;
1061 ret
= !server_call( REQ_SET_PROCESS_INFO
);
1068 /***********************************************************************
1069 * GetPriorityClass (KERNEL32.250)
1071 DWORD WINAPI
GetPriorityClass(HANDLE hprocess
)
1076 struct get_process_info_request
*req
= server_alloc_req( sizeof(*req
), 0 );
1077 req
->handle
= hprocess
;
1078 if (!server_call( REQ_GET_PROCESS_INFO
)) ret
= req
->priority
;
1085 /***********************************************************************
1086 * SetProcessAffinityMask (KERNEL32.662)
1088 BOOL WINAPI
SetProcessAffinityMask( HANDLE hProcess
, DWORD affmask
)
1093 struct set_process_info_request
*req
= server_alloc_req( sizeof(*req
), 0 );
1094 req
->handle
= hProcess
;
1095 req
->affinity
= affmask
;
1096 req
->mask
= SET_PROCESS_INFO_AFFINITY
;
1097 ret
= !server_call( REQ_SET_PROCESS_INFO
);
1103 /**********************************************************************
1104 * GetProcessAffinityMask (KERNEL32.373)
1106 BOOL WINAPI
GetProcessAffinityMask( HANDLE hProcess
,
1107 LPDWORD lpProcessAffinityMask
,
1108 LPDWORD lpSystemAffinityMask
)
1113 struct get_process_info_request
*req
= server_alloc_req( sizeof(*req
), 0 );
1114 req
->handle
= hProcess
;
1115 if (!server_call( REQ_GET_PROCESS_INFO
))
1117 if (lpProcessAffinityMask
) *lpProcessAffinityMask
= req
->process_affinity
;
1118 if (lpSystemAffinityMask
) *lpSystemAffinityMask
= req
->system_affinity
;
1127 /***********************************************************************
1128 * GetProcessVersion (KERNEL32)
1130 DWORD WINAPI
GetProcessVersion( DWORD processid
)
1132 IMAGE_NT_HEADERS
*nt
;
1134 if (processid
&& processid
!= GetCurrentProcessId())
1136 FIXME("should use ReadProcessMemory\n");
1139 if ((nt
= RtlImageNtHeader( current_process
.module
)))
1140 return ((nt
->OptionalHeader
.MajorSubsystemVersion
<< 16) |
1141 nt
->OptionalHeader
.MinorSubsystemVersion
);
1145 /***********************************************************************
1146 * GetProcessFlags (KERNEL32)
1148 DWORD WINAPI
GetProcessFlags( DWORD processid
)
1150 if (processid
&& processid
!= GetCurrentProcessId()) return 0;
1151 return current_process
.flags
;
1155 /***********************************************************************
1156 * SetProcessWorkingSetSize [KERNEL32.662]
1157 * Sets the min/max working set sizes for a specified process.
1160 * hProcess [I] Handle to the process of interest
1161 * minset [I] Specifies minimum working set size
1162 * maxset [I] Specifies maximum working set size
1166 BOOL WINAPI
SetProcessWorkingSetSize(HANDLE hProcess
,DWORD minset
,
1169 FIXME("(0x%08x,%ld,%ld): stub - harmless\n",hProcess
,minset
,maxset
);
1170 if(( minset
== (DWORD
)-1) && (maxset
== (DWORD
)-1)) {
1171 /* Trim the working set to zero */
1172 /* Swap the process out of physical RAM */
1177 /***********************************************************************
1178 * GetProcessWorkingSetSize (KERNEL32)
1180 BOOL WINAPI
GetProcessWorkingSetSize(HANDLE hProcess
,LPDWORD minset
,
1183 FIXME("(0x%08x,%p,%p): stub\n",hProcess
,minset
,maxset
);
1184 /* 32 MB working set size */
1185 if (minset
) *minset
= 32*1024*1024;
1186 if (maxset
) *maxset
= 32*1024*1024;
1190 /***********************************************************************
1191 * SetProcessShutdownParameters (KERNEL32)
1193 * CHANGED - James Sutherland (JamesSutherland@gmx.de)
1194 * Now tracks changes made (but does not act on these changes)
1196 static DWORD shutdown_flags
= 0;
1197 static DWORD shutdown_priority
= 0x280;
1199 BOOL WINAPI
SetProcessShutdownParameters(DWORD level
, DWORD flags
)
1201 FIXME("(%08lx, %08lx): partial stub.\n", level
, flags
);
1202 shutdown_flags
= flags
;
1203 shutdown_priority
= level
;
1208 /***********************************************************************
1209 * GetProcessShutdownParameters (KERNEL32)
1212 BOOL WINAPI
GetProcessShutdownParameters( LPDWORD lpdwLevel
, LPDWORD lpdwFlags
)
1214 *lpdwLevel
= shutdown_priority
;
1215 *lpdwFlags
= shutdown_flags
;
1220 /***********************************************************************
1221 * SetProcessPriorityBoost (KERNEL32)
1223 BOOL WINAPI
SetProcessPriorityBoost(HANDLE hprocess
,BOOL disableboost
)
1225 FIXME("(%d,%d): stub\n",hprocess
,disableboost
);
1226 /* Say we can do it. I doubt the program will notice that we don't. */
1231 /***********************************************************************
1232 * ReadProcessMemory (KERNEL32)
1234 BOOL WINAPI
ReadProcessMemory( HANDLE process
, LPCVOID addr
, LPVOID buffer
, DWORD size
,
1235 LPDWORD bytes_read
)
1237 unsigned int offset
= (unsigned int)addr
% sizeof(int);
1238 unsigned int pos
= 0, len
, max
;
1241 if (bytes_read
) *bytes_read
= size
;
1243 /* first time, read total length to check for permissions */
1244 len
= (size
+ offset
+ sizeof(int) - 1) / sizeof(int);
1245 max
= min( REQUEST_MAX_VAR_SIZE
, len
* sizeof(int) );
1251 struct read_process_memory_request
*req
= server_alloc_req( sizeof(*req
), max
);
1252 req
->handle
= process
;
1253 req
->addr
= (char *)addr
+ pos
- offset
;
1255 if (!(res
= server_call( REQ_READ_PROCESS_MEMORY
)))
1257 size_t result
= server_data_size( req
);
1258 if (result
> size
+ offset
) result
= size
+ offset
;
1259 memcpy( (char *)buffer
+ pos
, server_data_ptr(req
) + offset
, result
- offset
);
1260 size
-= result
- offset
;
1261 pos
+= result
- offset
;
1267 if (bytes_read
) *bytes_read
= 0;
1270 if (!size
) return TRUE
;
1271 max
= min( REQUEST_MAX_VAR_SIZE
, size
);
1272 len
= (max
+ sizeof(int) - 1) / sizeof(int);
1278 /***********************************************************************
1279 * WriteProcessMemory (KERNEL32)
1281 BOOL WINAPI
WriteProcessMemory( HANDLE process
, LPVOID addr
, LPVOID buffer
, DWORD size
,
1282 LPDWORD bytes_written
)
1284 unsigned int first_offset
, last_offset
;
1285 unsigned int pos
= 0, len
, max
, first_mask
, last_mask
;
1290 SetLastError( ERROR_INVALID_PARAMETER
);
1293 if (bytes_written
) *bytes_written
= size
;
1295 /* compute the mask for the first int */
1297 first_offset
= (unsigned int)addr
% sizeof(int);
1298 memset( &first_mask
, 0, first_offset
);
1300 /* compute the mask for the last int */
1301 last_offset
= (size
+ first_offset
) % sizeof(int);
1303 memset( &last_mask
, 0xff, last_offset
? last_offset
: sizeof(int) );
1305 /* for the first request, use the total length */
1306 len
= (size
+ first_offset
+ sizeof(int) - 1) / sizeof(int);
1307 max
= min( REQUEST_MAX_VAR_SIZE
, len
* sizeof(int) );
1313 struct write_process_memory_request
*req
= server_alloc_req( sizeof(*req
), max
);
1314 req
->handle
= process
;
1315 req
->addr
= (char *)addr
- first_offset
+ pos
;
1317 req
->first_mask
= (!pos
) ? first_mask
: ~0;
1318 if (size
+ first_offset
<= max
) /* last round */
1320 req
->last_mask
= last_mask
;
1321 max
= size
+ first_offset
;
1323 else req
->last_mask
= ~0;
1325 memcpy( (char *)server_data_ptr(req
) + first_offset
, (char *)buffer
+ pos
,
1326 max
- first_offset
);
1327 if (!(res
= server_call( REQ_WRITE_PROCESS_MEMORY
)))
1329 pos
+= max
- first_offset
;
1330 size
-= max
- first_offset
;
1336 if (bytes_written
) *bytes_written
= 0;
1339 if (!size
) return TRUE
;
1341 len
= min( size
+ sizeof(int) - 1, REQUEST_MAX_VAR_SIZE
) / sizeof(int);
1342 max
= len
* sizeof(int);
1347 /***********************************************************************
1348 * RegisterServiceProcess (KERNEL, KERNEL32)
1350 * A service process calls this function to ensure that it continues to run
1351 * even after a user logged off.
1353 DWORD WINAPI
RegisterServiceProcess(DWORD dwProcessId
, DWORD dwType
)
1355 /* I don't think that Wine needs to do anything in that function */
1356 return 1; /* success */
1359 /***********************************************************************
1360 * GetExitCodeProcess [KERNEL32.325]
1362 * Gets termination status of specified process
1368 BOOL WINAPI
GetExitCodeProcess(
1369 HANDLE hProcess
, /* [in] handle to the process */
1370 LPDWORD lpExitCode
) /* [out] address to receive termination status */
1375 struct get_process_info_request
*req
= server_alloc_req( sizeof(*req
), 0 );
1376 req
->handle
= hProcess
;
1377 ret
= !server_call( REQ_GET_PROCESS_INFO
);
1378 if (ret
&& lpExitCode
) *lpExitCode
= req
->exit_code
;
1385 /***********************************************************************
1386 * SetErrorMode (KERNEL32.486)
1388 UINT WINAPI
SetErrorMode( UINT mode
)
1390 UINT old
= current_process
.error_mode
;
1391 current_process
.error_mode
= mode
;
1396 /**********************************************************************
1397 * TlsAlloc [KERNEL32.530] Allocates a TLS index.
1399 * Allocates a thread local storage index
1402 * Success: TLS Index
1403 * Failure: 0xFFFFFFFF
1405 DWORD WINAPI
TlsAlloc( void )
1407 DWORD i
, mask
, ret
= 0;
1408 DWORD
*bits
= current_process
.tls_bits
;
1409 RtlAcquirePebLock();
1410 if (*bits
== 0xffffffff)
1414 if (*bits
== 0xffffffff)
1416 RtlReleasePebLock();
1417 SetLastError( ERROR_NO_MORE_ITEMS
);
1421 for (i
= 0, mask
= 1; i
< 32; i
++, mask
<<= 1) if (!(*bits
& mask
)) break;
1423 RtlReleasePebLock();
1428 /**********************************************************************
1429 * TlsFree [KERNEL32.531] Releases a TLS index.
1431 * Releases a thread local storage index, making it available for reuse
1437 BOOL WINAPI
TlsFree(
1438 DWORD index
) /* [in] TLS Index to free */
1440 DWORD mask
= (1 << (index
& 31));
1441 DWORD
*bits
= current_process
.tls_bits
;
1444 SetLastError( ERROR_INVALID_PARAMETER
);
1447 if (index
>= 32) bits
++;
1448 RtlAcquirePebLock();
1449 if (!(*bits
& mask
)) /* already free? */
1451 RtlReleasePebLock();
1452 SetLastError( ERROR_INVALID_PARAMETER
);
1456 NtCurrentTeb()->tls_array
[index
] = 0;
1457 /* FIXME: should zero all other thread values */
1458 RtlReleasePebLock();
1463 /**********************************************************************
1464 * TlsGetValue [KERNEL32.532] Gets value in a thread's TLS slot
1467 * Success: Value stored in calling thread's TLS slot for index
1468 * Failure: 0 and GetLastError returns NO_ERROR
1470 LPVOID WINAPI
TlsGetValue(
1471 DWORD index
) /* [in] TLS index to retrieve value for */
1475 SetLastError( ERROR_INVALID_PARAMETER
);
1478 SetLastError( ERROR_SUCCESS
);
1479 return NtCurrentTeb()->tls_array
[index
];
1483 /**********************************************************************
1484 * TlsSetValue [KERNEL32.533] Stores a value in the thread's TLS slot.
1490 BOOL WINAPI
TlsSetValue(
1491 DWORD index
, /* [in] TLS index to set value for */
1492 LPVOID value
) /* [in] Value to be stored */
1496 SetLastError( ERROR_INVALID_PARAMETER
);
1499 NtCurrentTeb()->tls_array
[index
] = value
;
1504 /***********************************************************************
1505 * GetCurrentProcess (KERNEL32.198)
1507 #undef GetCurrentProcess
1508 HANDLE WINAPI
GetCurrentProcess(void)