?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Changed LdrLoadDll to only search for the dll in the specified path,
[wine/hacks.git] / dlls / kernel / process.c
blob60e1ccd09f46c64272d9e6156cfac2e799885bb4
1 /*
2 * Win32 processes
3 *
4 * Copyright 1996, 1998 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <ctype.h>
26 #include <errno.h>
27 #include <locale.h>
28 #include <signal.h>
29 #include <stdio.h>
30
31 #include "wine/winbase16.h"
32 #include "wine/winuser16.h"
33 #include "ntstatus.h"
34 #include "thread.h"
35 #include "drive.h"
36 #include "file.h"
37 #include "heap.h"
38 #include "module.h"
39 #include "options.h"
40 #include "kernel_private.h"
41 #include "wine/server.h"
42 #include "wine/debug.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(process);
45 WINE_DECLARE_DEBUG_CHANNEL(server);
46 WINE_DECLARE_DEBUG_CHANNEL(relay);
47 WINE_DECLARE_DEBUG_CHANNEL(snoop);
48
49 /* Win32 process database */
50 typedef struct _PDB
51 {
52 LONG header[2]; /* 00 Kernel object header */
53 HMODULE module; /* 08 Main exe module (NT) */
54 PPEB_LDR_DATA LdrData; /* 0c Pointer to loader information */
55 RTL_USER_PROCESS_PARAMETERS *ProcessParameters; /* 10 Process parameters */
56 DWORD unknown2; /* 14 Unknown */
57 HANDLE heap; /* 18 Default process heap */
58 HANDLE mem_context; /* 1c Process memory context */
59 DWORD flags; /* 20 Flags */
60 void *pdb16; /* 24 DOS PSP */
61 WORD PSP_sel; /* 28 Selector to DOS PSP */
62 WORD imte; /* 2a IMTE for the process module */
63 WORD threads; /* 2c Number of threads */
64 WORD running_threads; /* 2e Number of running threads */
65 WORD free_lib_count; /* 30 Recursion depth of FreeLibrary calls */
66 WORD ring0_threads; /* 32 Number of ring 0 threads */
67 HANDLE system_heap; /* 34 System heap to allocate handles */
68 HTASK task; /* 38 Win16 task */
69 void *mem_map_files; /* 3c Pointer to mem-mapped files */
70 struct _ENVDB *env_db; /* 40 Environment database */
71 void *handle_table; /* 44 Handle table */
72 struct _PDB *parent; /* 48 Parent process */
73 void *modref_list; /* 4c MODREF list */
74 void *thread_list; /* 50 List of threads */
75 void *debuggee_CB; /* 54 Debuggee context block */
76 void *local_heap_free; /* 58 Head of local heap free list */
77 DWORD unknown4; /* 5c Unknown */
78 CRITICAL_SECTION crit_section; /* 60 Critical section */
79 DWORD unknown5[3]; /* 78 Unknown */
80 void *console; /* 84 Console */
81 DWORD tls_bits[2]; /* 88 TLS in-use bits */
82 DWORD process_dword; /* 90 Unknown */
83 struct _PDB *group; /* 94 Process group */
84 void *exe_modref; /* 98 MODREF for the process EXE */
85 void *top_filter; /* 9c Top exception filter */
86 DWORD priority; /* a0 Priority level */
87 HANDLE heap_list; /* a4 Head of process heap list */
88 void *heap_handles; /* a8 Head of heap handles list */
89 DWORD unknown6; /* ac Unknown */
90 void *console_provider; /* b0 Console provider (??) */
91 WORD env_selector; /* b4 Selector to process environment */
92 WORD error_mode; /* b6 Error mode */
93 HANDLE load_done_evt; /* b8 Event for process loading done */
94 void *UTState; /* bc Head of Univeral Thunk list */
95 DWORD unknown8; /* c0 Unknown (NT) */
96 LCID locale; /* c4 Locale to be queried by GetThreadLocale (NT) */
97 } PDB;
98
99 PDB current_process;
100
101 static RTL_USER_PROCESS_PARAMETERS process_pmts;
102 static PEB_LDR_DATA process_ldr;
103
104 static HANDLE main_exe_file;
105 static DWORD shutdown_flags = 0;
106 static DWORD shutdown_priority = 0x280;
107 static DWORD process_dword;
108 static BOOL oem_file_apis;
109
110 extern unsigned int server_startticks;
111 int main_create_flags = 0;
112
113 /* Process flags */
114 #define PDB32_DEBUGGED 0x0001 /* Process is being debugged */
115 #define PDB32_WIN16_PROC 0x0008 /* Win16 process */
116 #define PDB32_DOS_PROC 0x0010 /* Dos process */
117 #define PDB32_CONSOLE_PROC 0x0020 /* Console process */
118 #define PDB32_FILE_APIS_OEM 0x0040 /* File APIs are OEM */
119 #define PDB32_WIN32S_PROC 0x8000 /* Win32s process */
120
121 /* dlls/ntdll/env.c */
122 extern BOOL init_user_process_pmts( size_t );
123 extern BOOL build_command_line( char **argv );
124
125 extern void RELAY_InitDebugLists(void);
126 extern void SHELL_LoadRegistry(void);
127 extern void VERSION_Init( const char *appname );
128 extern void MODULE_InitLoadPath(void);
129
130 /***********************************************************************
131 * get_basename
132 */
133 inline static const char *get_basename( const char *name )
134 {
135 char *p;
136
137 if ((p = strrchr( name, '/' ))) name = p + 1;
138 if ((p = strrchr( name, '\\' ))) name = p + 1;
139 return name;
140 }
141
142
143 /***********************************************************************
144 * open_builtin_exe_file
145 *
146 * Open an exe file for a builtin exe.
147 */
148 static void *open_builtin_exe_file( const char *name, char *error, int error_size,
149 int test_only, int *file_exists )
150 {
151 char exename[MAX_PATH], *p;
152 const char *basename = get_basename(name);
153
154 if (strlen(basename) >= sizeof(exename)) return NULL;
155 strcpy( exename, basename );
156 for (p = exename; *p; p++) *p = FILE_tolower(*p);
157 return wine_dll_load_main_exe( exename, error, error_size, test_only, file_exists );
158 }
159
160
161 /***********************************************************************
162 * open_exe_file
163 *
164 * Open a specific exe file, taking load order into account.
165 * Returns the file handle or 0 for a builtin exe.
166 */
167 static HANDLE open_exe_file( const char *name )
168 {
169 enum loadorder_type loadorder[LOADORDER_NTYPES];
170 char buffer[MAX_PATH];
171 HANDLE handle;
172 int i, file_exists;
173
174 TRACE("looking for %s\n", debugstr_a(name) );
175
176 if ((handle = CreateFileA( name, GENERIC_READ, FILE_SHARE_READ,
177 NULL, OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE)
178 {
179 /* file doesn't exist, check for builtin */
180 if (!FILE_contains_path( name )) goto error;
181 if (!MODULE_GetBuiltinPath( name, "", buffer, sizeof(buffer) )) goto error;
182 name = buffer;
183 }
184
185 MODULE_GetLoadOrderA( loadorder, NULL, name, TRUE );
186
187 for(i = 0; i < LOADORDER_NTYPES; i++)
188 {
189 if (loadorder[i] == LOADORDER_INVALID) break;
190 switch(loadorder[i])
191 {
192 case LOADORDER_DLL:
193 TRACE( "Trying native exe %s\n", debugstr_a(name) );
194 if (handle != INVALID_HANDLE_VALUE) return handle;
195 break;
196 case LOADORDER_BI:
197 TRACE( "Trying built-in exe %s\n", debugstr_a(name) );
198 open_builtin_exe_file( name, NULL, 0, 1, &file_exists );
199 if (file_exists)
200 {
201 if (handle != INVALID_HANDLE_VALUE) CloseHandle(handle);
202 return 0;
203 }
204 default:
205 break;
206 }
207 }
208 if (handle != INVALID_HANDLE_VALUE) CloseHandle(handle);
209
210 error:
211 SetLastError( ERROR_FILE_NOT_FOUND );
212 return INVALID_HANDLE_VALUE;
213 }
214
215
216 /***********************************************************************
217 * find_exe_file
218 *
219 * Open an exe file, and return the full name and file handle.
220 * Returns FALSE if file could not be found.
221 * If file exists but cannot be opened, returns TRUE and set handle to INVALID_HANDLE_VALUE.
222 * If file is a builtin exe, returns TRUE and sets handle to 0.
223 */
224 static BOOL find_exe_file( const char *name, char *buffer, int buflen, HANDLE *handle )
225 {
226 enum loadorder_type loadorder[LOADORDER_NTYPES];
227 int i, file_exists;
228
229 TRACE("looking for %s\n", debugstr_a(name) );
230
231 if (!SearchPathA( NULL, name, ".exe", buflen, buffer, NULL ) &&
232 !MODULE_GetBuiltinPath( name, ".exe", buffer, buflen ))
233 {
234 /* no builtin found, try native without extension in case it is a Unix app */
235
236 if (SearchPathA( NULL, name, NULL, buflen, buffer, NULL ))
237 {
238 TRACE( "Trying native/Unix binary %s\n", debugstr_a(buffer) );
239 if ((*handle = CreateFileA( buffer, GENERIC_READ, FILE_SHARE_READ,
240 NULL, OPEN_EXISTING, 0, 0 )) != INVALID_HANDLE_VALUE)
241 return TRUE;
242 }
243 return FALSE;
244 }
245
246 MODULE_GetLoadOrderA( loadorder, NULL, buffer, TRUE );
247
248 for(i = 0; i < LOADORDER_NTYPES; i++)
249 {
250 if (loadorder[i] == LOADORDER_INVALID) break;
251 switch(loadorder[i])
252 {
253 case LOADORDER_DLL:
254 TRACE( "Trying native exe %s\n", debugstr_a(buffer) );
255 if ((*handle = CreateFileA( buffer, GENERIC_READ, FILE_SHARE_READ,
256 NULL, OPEN_EXISTING, 0, 0 )) != INVALID_HANDLE_VALUE)
257 return TRUE;
258 if (GetLastError() != ERROR_FILE_NOT_FOUND) return TRUE;
259 break;
260 case LOADORDER_BI:
261 TRACE( "Trying built-in exe %s\n", debugstr_a(buffer) );
262 open_builtin_exe_file( buffer, NULL, 0, 1, &file_exists );
263 if (file_exists)
264 {
265 *handle = 0;
266 return TRUE;
267 }
268 break;
269 default:
270 break;
271 }
272 }
273 SetLastError( ERROR_FILE_NOT_FOUND );
274 return FALSE;
275 }
276
277
278 /**********************************************************************
279 * load_pe_exe
280 *
281 * Load a PE format EXE file.
282 */
283 static HMODULE load_pe_exe( HANDLE file )
284 {
285 IMAGE_NT_HEADERS *nt;
286 HANDLE mapping;
287 void *module;
288 OBJECT_ATTRIBUTES attr;
289 LARGE_INTEGER size;
290 DWORD len = 0;
291
292 attr.Length = sizeof(attr);
293 attr.RootDirectory = 0;
294 attr.ObjectName = NULL;
295 attr.Attributes = 0;
296 attr.SecurityDescriptor = NULL;
297 attr.SecurityQualityOfService = NULL;
298 size.QuadPart = 0;
299
300 if (NtCreateSection( &mapping, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
301 &attr, &size, 0, SEC_IMAGE, file ) != STATUS_SUCCESS)
302 return NULL;
303
304 module = NULL;
305 if (NtMapViewOfSection( mapping, GetCurrentProcess(), &module, 0, 0, &size, &len,
306 ViewShare, 0, PAGE_READONLY ) != STATUS_SUCCESS)
307 return NULL;
308
309 NtClose( mapping );
310
311 /* virus check */
312 nt = RtlImageNtHeader( module );
313 if (nt->OptionalHeader.AddressOfEntryPoint)
314 {
315 if (!RtlImageRvaToSection( nt, module, nt->OptionalHeader.AddressOfEntryPoint ))
316 MESSAGE("VIRUS WARNING: PE module has an invalid entrypoint (0x%08lx) "
317 "outside all sections (possibly infected by Tchernobyl/SpaceFiller virus)!\n",
318 nt->OptionalHeader.AddressOfEntryPoint );
319 }
320 return module;
321 }
322
323 /***********************************************************************
324 * process_init
325 *
326 * Main process initialisation code
327 */
328 static BOOL process_init( char *argv[] )
329 {
330 BOOL ret;
331 size_t info_size = 0;
332
333 setbuf(stdout,NULL);
334 setbuf(stderr,NULL);
335 setlocale(LC_CTYPE,"");
336
337 /* store the program name */
338 argv0 = argv[0];
339
340 /* Fill the initial process structure */
341 current_process.threads = 1;
342 current_process.running_threads = 1;
343 current_process.ring0_threads = 1;
344 current_process.group = &current_process;
345 current_process.priority = 8; /* Normal */
346 current_process.ProcessParameters = &process_pmts;
347 current_process.LdrData = &process_ldr;
348 InitializeListHead(&process_ldr.InLoadOrderModuleList);
349 InitializeListHead(&process_ldr.InMemoryOrderModuleList);
350 InitializeListHead(&process_ldr.InInitializationOrderModuleList);
351
352 /* Setup the server connection */
353 wine_server_init_thread();
354
355 /* Retrieve startup info from the server */
356 SERVER_START_REQ( init_process )
357 {
358 req->ldt_copy = &wine_ldt_copy;
359 if ((ret = !wine_server_call_err( req )))
360 {
361 main_exe_file = reply->exe_file;
362 main_create_flags = reply->create_flags;
363 info_size = reply->info_size;
364 server_startticks = reply->server_start;
365 process_pmts.hStdInput = reply->hstdin;
366 process_pmts.hStdOutput = reply->hstdout;
367 process_pmts.hStdError = reply->hstderr;
368 }
369 }
370 SERVER_END_REQ;
371 if (!ret) return FALSE;
372
373 /* Create the process heap */
374 current_process.heap = RtlCreateHeap( HEAP_GROWABLE, NULL, 0, 0, NULL, NULL );
375
376 if (info_size == 0)
377 {
378 /* This is wine specific: we have no parent (we're started from unix)
379 * so, create a simple console with bare handles to unix stdio
380 * input & output streams (aka simple console)
381 */
382 wine_server_fd_to_handle( 0, GENERIC_READ|SYNCHRONIZE, TRUE, &process_pmts.hStdInput );
383 wine_server_fd_to_handle( 1, GENERIC_WRITE|SYNCHRONIZE, TRUE, &process_pmts.hStdOutput );
384 wine_server_fd_to_handle( 2, GENERIC_WRITE|SYNCHRONIZE, TRUE, &process_pmts.hStdError );
385 }
386 else
387 {
388 /* convert value from server:
389 * + 0 => INVALID_HANDLE_VALUE
390 * + console handle need to be mapped
391 */
392 if (!process_pmts.hStdInput)
393 process_pmts.hStdInput = INVALID_HANDLE_VALUE;
394 else if (VerifyConsoleIoHandle(console_handle_map(process_pmts.hStdInput)))
395 process_pmts.hStdInput = console_handle_map(process_pmts.hStdInput);
396 if (!process_pmts.hStdOutput)
397 process_pmts.hStdOutput = INVALID_HANDLE_VALUE;
398 else if (VerifyConsoleIoHandle(console_handle_map(process_pmts.hStdOutput)))
399 process_pmts.hStdOutput = console_handle_map(process_pmts.hStdOutput);
400 if (!process_pmts.hStdError)
401 process_pmts.hStdError = INVALID_HANDLE_VALUE;
402 else if (VerifyConsoleIoHandle(console_handle_map(process_pmts.hStdError)))
403 process_pmts.hStdError = console_handle_map(process_pmts.hStdError);
404 }
405
406 /* Copy the parent environment */
407 if (!init_user_process_pmts( info_size )) return FALSE;
408
409 /* Parse command line arguments */
410 OPTIONS_ParseOptions( !info_size ? argv : NULL );
411
412 /* <hack: to be changed later on> */
413 process_pmts.CurrentDirectoryName.Length = 3 * sizeof(WCHAR);
414 process_pmts.CurrentDirectoryName.MaximumLength = RtlGetLongestNtPathLength() * sizeof(WCHAR);
415 process_pmts.CurrentDirectoryName.Buffer = RtlAllocateHeap( GetProcessHeap(), 0, process_pmts.CurrentDirectoryName.MaximumLength);
416 process_pmts.CurrentDirectoryName.Buffer[0] = 'C';
417 process_pmts.CurrentDirectoryName.Buffer[1] = ':';
418 process_pmts.CurrentDirectoryName.Buffer[2] = '\\';
419 process_pmts.CurrentDirectoryName.Buffer[3] = '\0';
420 /* </hack: to be changed later on> */
421
422 /* initialise DOS drives */
423 if (!DRIVE_Init()) return FALSE;
424
425 /* initialise DOS directories */
426 if (!DIR_Init()) return FALSE;
427
428 /* registry initialisation */
429 SHELL_LoadRegistry();
430
431 /* global boot finished, the rest is process-local */
432 SERVER_START_REQ( boot_done )
433 {
434 req->debug_level = TRACE_ON(server);
435 wine_server_call( req );
436 }
437 SERVER_END_REQ;
438
439 if (TRACE_ON(relay) || TRACE_ON(snoop)) RELAY_InitDebugLists();
440
441 return TRUE;
442 }
443
444
445 /***********************************************************************
446 * start_process
447 *
448 * Startup routine of a new process. Runs on the new process stack.
449 */
450 static void start_process( void *arg )
451 {
452 __TRY
453 {
454 LPTHREAD_START_ROUTINE entry;
455 HANDLE main_file = main_exe_file;
456 IMAGE_NT_HEADERS *nt;
457 PEB *peb = NtCurrentTeb()->Peb;
458 UNICODE_STRING *main_exe_name = &peb->ProcessParameters->ImagePathName;
459
460 if (main_file)
461 {
462 UINT drive_type = GetDriveTypeW( main_exe_name->Buffer );
463 /* don't keep the file handle open on removable media */
464 if (drive_type == DRIVE_REMOVABLE || drive_type == DRIVE_CDROM) main_file = 0;
465 }
466
467 /* Retrieve entry point address */
468 nt = RtlImageNtHeader( peb->ImageBaseAddress );
469 entry = (LPTHREAD_START_ROUTINE)((char*)peb->ImageBaseAddress +
470 nt->OptionalHeader.AddressOfEntryPoint);
471
472 /* Install signal handlers; this cannot be done before, since we cannot
473 * send exceptions to the debugger before the create process event that
474 * is sent by REQ_INIT_PROCESS_DONE.
475 * We do need the handlers in place by the time the request is over, so
476 * we set them up here. If we segfault between here and the server call
477 * something is very wrong... */
478 if (!SIGNAL_Init()) goto error;
479
480 /* Signal the parent process to continue */
481 SERVER_START_REQ( init_process_done )
482 {
483 req->module = peb->ImageBaseAddress;
484 req->module_size = nt->OptionalHeader.SizeOfImage;
485 req->entry = entry;
486 /* API requires a double indirection */
487 req->name = &main_exe_name->Buffer;
488 req->exe_file = main_file;
489 req->gui = (nt->OptionalHeader.Subsystem != IMAGE_SUBSYSTEM_WINDOWS_CUI);
490 wine_server_add_data( req, main_exe_name->Buffer, main_exe_name->Length );
491 wine_server_call( req );
492 peb->BeingDebugged = reply->debugged;
493 }
494 SERVER_END_REQ;
495
496 /* create the main modref and load dependencies */
497 if (main_exe_file) CloseHandle( main_exe_file ); /* we no longer need it */
498 if (MODULE_DllProcessAttach( NULL, (LPVOID)1 ) != STATUS_SUCCESS)
499 {
500 ERR( "Main exe initialization failed\n" );
501 goto error;
502 }
503
504 if (TRACE_ON(relay))
505 DPRINTF( "%04lx:Starting process %s (entryproc=%p)\n",
506 GetCurrentThreadId(), debugstr_w(main_exe_name->Buffer), entry );
507 if (peb->BeingDebugged) DbgBreakPoint();
508 SetLastError(0); /* clear error code */
509 ExitThread( entry( NtCurrentTeb()->Peb ) );
510
511 error:
512 ExitProcess( GetLastError() );
513 }
514 __EXCEPT(UnhandledExceptionFilter)
515 {
516 TerminateThread( GetCurrentThread(), GetExceptionCode() );
517 }
518 __ENDTRY
519 }
520
521
522 /***********************************************************************
523 * __wine_process_init
524 *
525 * Wine initialisation: load and start the main exe file.
526 */
527 void __wine_process_init( int argc, char *argv[] )
528 {
529 char main_exe_name[MAX_PATH];
530 char error[1024], *p;
531 DWORD stack_size = 0;
532 int file_exists;
533
534 /* Initialize everything */
535 if (!process_init( argv )) exit(1);
536
537 argv++; /* remove argv[0] (wine itself) */
538
539 if (process_pmts.ImagePathName.Buffer)
540 {
541 WideCharToMultiByte( CP_ACP, 0, process_pmts.ImagePathName.Buffer, -1,
542 main_exe_name, sizeof(main_exe_name), NULL, NULL );
543 }
544 else
545 {
546 if (!argv[0]) OPTIONS_Usage();
547
548 if (!find_exe_file( argv[0], main_exe_name, sizeof(main_exe_name), &main_exe_file ))
549 {
550 MESSAGE( "%s: cannot find '%s'\n", argv0, argv[0] );
551 ExitProcess(1);
552 }
553 if (main_exe_file == INVALID_HANDLE_VALUE)
554 {
555 MESSAGE( "%s: cannot open '%s'\n", argv0, main_exe_name );
556 ExitProcess(1);
557 }
558 RtlCreateUnicodeStringFromAsciiz( &NtCurrentTeb()->Peb->ProcessParameters->ImagePathName,
559 main_exe_name );
560 }
561
562 TRACE( "starting process name=%s file=%p argv[0]=%s\n",
563 debugstr_a(main_exe_name), main_exe_file, debugstr_a(argv[0]) );
564
565 MODULE_InitLoadPath();
566 VERSION_Init( main_exe_name );
567
568 if (!main_exe_file) /* no file handle -> Winelib app */
569 {
570 TRACE( "starting Winelib app %s\n", debugstr_a(main_exe_name) );
571 if (open_builtin_exe_file( main_exe_name, error, sizeof(error), 0, &file_exists ))
572 goto found;
573 MESSAGE( "%s: cannot open builtin library for '%s': %s\n", argv0, main_exe_name, error );
574 ExitProcess(1);
575 }
576
577 switch( MODULE_GetBinaryType( main_exe_file ))
578 {
579 case BINARY_PE_EXE:
580 TRACE( "starting Win32 binary %s\n", debugstr_a(main_exe_name) );
581 if ((current_process.module = load_pe_exe( main_exe_file ))) goto found;
582 MESSAGE( "%s: could not load '%s' as Win32 binary\n", argv0, main_exe_name );
583 ExitProcess(1);
584 case BINARY_PE_DLL:
585 MESSAGE( "%s: '%s' is a DLL, not an executable\n", argv0, main_exe_name );
586 ExitProcess(1);
587 case BINARY_UNKNOWN:
588 /* check for .com extension */
589 if (!(p = strrchr( main_exe_name, '.' )) || FILE_strcasecmp( p, ".com" ))
590 {
591 MESSAGE( "%s: cannot determine executable type for '%s'\n", argv0, main_exe_name );
592 ExitProcess(1);
593 }
594 /* fall through */
595 case BINARY_WIN16:
596 case BINARY_DOS:
597 TRACE( "starting Win16/DOS binary %s\n", debugstr_a(main_exe_name) );
598 CloseHandle( main_exe_file );
599 main_exe_file = 0;
600 argv--;
601 argv[0] = "winevdm.exe";
602 if (open_builtin_exe_file( "winevdm.exe", error, sizeof(error), 0, &file_exists ))
603 goto found;
604 MESSAGE( "%s: trying to run '%s', cannot open builtin library for 'winevdm.exe': %s\n",
605 argv0, main_exe_name, error );
606 ExitProcess(1);
607 case BINARY_OS216:
608 MESSAGE( "%s: '%s' is an OS/2 binary, not supported\n", argv0, main_exe_name );
609 ExitProcess(1);
610 case BINARY_UNIX_EXE:
611 MESSAGE( "%s: '%s' is a Unix binary, not supported\n", argv0, main_exe_name );
612 ExitProcess(1);
613 case BINARY_UNIX_LIB:
614 {
615 DOS_FULL_NAME full_name;
616 const char *name = main_exe_name;
617 UNICODE_STRING nameW;
618
619 TRACE( "starting Winelib app %s\n", debugstr_a(main_exe_name) );
620 RtlCreateUnicodeStringFromAsciiz(&nameW, name);
621 if (DOSFS_GetFullName( nameW.Buffer, TRUE, &full_name )) name = full_name.long_name;
622 RtlFreeUnicodeString(&nameW);
623 CloseHandle( main_exe_file );
624 main_exe_file = 0;
625 if (wine_dlopen( name, RTLD_NOW, error, sizeof(error) ))
626 {
627 if ((p = strrchr( main_exe_name, '.' )) && !strcmp( p, ".so" )) *p = 0;
628 goto found;
629 }
630 MESSAGE( "%s: could not load '%s': %s\n", argv0, main_exe_name, error );
631 ExitProcess(1);
632 }
633 }
634
635 found:
636 /* build command line */
637 if (!build_command_line( argv )) goto error;
638
639 /* create 32-bit module for main exe */
640 if (!(current_process.module = BUILTIN32_LoadExeModule( current_process.module ))) goto error;
641 stack_size = RtlImageNtHeader(current_process.module)->OptionalHeader.SizeOfStackReserve;
642
643 /* allocate main thread stack */
644 if (!THREAD_InitStack( NtCurrentTeb(), stack_size )) goto error;
645
646 /* switch to the new stack */
647 wine_switch_to_stack( start_process, NULL, NtCurrentTeb()->Tib.StackBase );
648
649 error:
650 ExitProcess( GetLastError() );
651 }
652
653
654 /***********************************************************************
655 * build_argv
656 *
657 * Build an argv array from a command-line.
658 * The command-line is modified to insert nulls.
659 * 'reserved' is the number of args to reserve before the first one.
660 */
661 static char **build_argv( char *cmdline, int reserved )
662 {
663 int argc;
664 char** argv;
665 char *arg,*s,*d;
666 int in_quotes,bcount;
667
668 argc=reserved+1;
669 bcount=0;
670 in_quotes=0;
671 s=cmdline;
672 while (1) {
673 if (*s=='\0' || ((*s==' ' || *s=='\t') && !in_quotes)) {
674 /* space */
675 argc++;
676 /* skip the remaining spaces */
677 while (*s==' ' || *s=='\t') {
678 s++;
679 }
680 if (*s=='\0')
681 break;
682 bcount=0;
683 continue;
684 } else if (*s=='\\') {
685 /* '\', count them */
686 bcount++;
687 } else if ((*s=='"') && ((bcount & 1)==0)) {
688 /* unescaped '"' */
689 in_quotes=!in_quotes;
690 bcount=0;
691 } else {
692 /* a regular character */
693 bcount=0;
694 }
695 s++;
696 }
697 argv=malloc(argc*sizeof(*argv));
698 if (!argv)
699 return NULL;
700
701 arg=d=s=cmdline;
702 bcount=0;
703 in_quotes=0;
704 argc=reserved;
705 while (*s) {
706 if ((*s==' ' || *s=='\t') && !in_quotes) {
707 /* Close the argument and copy it */
708 *d=0;
709 argv[argc++]=arg;
710
711 /* skip the remaining spaces */
712 do {
713 s++;
714 } while (*s==' ' || *s=='\t');
715
716 /* Start with a new argument */
717 arg=d=s;
718 bcount=0;
719 } else if (*s=='\\') {
720 /* '\\' */
721 *d++=*s++;
722 bcount++;
723 } else if (*s=='"') {
724 /* '"' */
725 if ((bcount & 1)==0) {
726 /* Preceeded by an even number of '\', this is half that
727 * number of '\', plus a '"' which we discard.
728 */
729 d-=bcount/2;
730 s++;
731 in_quotes=!in_quotes;
732 } else {
733 /* Preceeded by an odd number of '\', this is half that
734 * number of '\' followed by a '"'
735 */
736 d=d-bcount/2-1;
737 *d++='"';
738 s++;
739 }
740 bcount=0;
741 } else {
742 /* a regular character */
743 *d++=*s++;
744 bcount=0;
745 }
746 }
747 if (*arg) {
748 *d='\0';
749 argv[argc++]=arg;
750 }
751 argv[argc]=NULL;
752
753 return argv;
754 }
755
756
757 /***********************************************************************
758 * build_envp
759 *
760 * Build the environment of a new child process.
761 */
762 static char **build_envp( const char *env, const char *extra_env )
763 {
764 const char *p;
765 char **envp;
766 int count = 0;
767
768 if (extra_env) for (p = extra_env; *p; count++) p += strlen(p) + 1;
769 for (p = env; *p; count++) p += strlen(p) + 1;
770 count += 3;
771
772 if ((envp = malloc( count * sizeof(*envp) )))
773 {
774 extern char **environ;
775 char **envptr = envp;
776 char **unixptr = environ;
777 /* first the extra strings */
778 if (extra_env) for (p = extra_env; *p; p += strlen(p) + 1) *envptr++ = (char *)p;
779 /* then put PATH, HOME and WINEPREFIX from the unix env */
780 for (unixptr = environ; unixptr && *unixptr; unixptr++)
781 if (!memcmp( *unixptr, "PATH=", 5 ) ||
782 !memcmp( *unixptr, "HOME=", 5 ) ||
783 !memcmp( *unixptr, "WINEPREFIX=", 11 )) *envptr++ = *unixptr;
784 /* now put the Windows environment strings */
785 for (p = env; *p; p += strlen(p) + 1)
786 {
787 if (!memcmp( p, "PATH=", 5 )) /* store PATH as WINEPATH */
788 {
789 char *winepath = malloc( strlen(p) + 5 );
790 strcpy( winepath, "WINE" );
791 strcpy( winepath + 4, p );
792 *envptr++ = winepath;
793 }
794 else if (memcmp( p, "HOME=", 5 ) &&
795 memcmp( p, "WINEPATH=", 9 ) &&
796 memcmp( p, "WINEPREFIX=", 11 )) *envptr++ = (char *)p;
797 }
798 *envptr = 0;
799 }
800 return envp;
801 }
802
803
804 /***********************************************************************
805 * exec_wine_binary
806 *
807 * Locate the Wine binary to exec for a new Win32 process.
808 */
809 static void exec_wine_binary( char **argv, char **envp )
810 {
811 const char *path, *pos, *ptr;
812
813 /* first, try for a WINELOADER environment variable */
814 argv[0] = getenv("WINELOADER");
815 if (argv[0])
816 execve( argv[0], argv, envp );
817
818 /* next, try bin directory */
819 argv[0] = BINDIR "/wine";
820 execve( argv[0], argv, envp );
821
822 /* now try the path of argv0 of the current binary */
823 if (!(argv[0] = malloc( strlen(full_argv0) + 6 ))) return;
824 if ((ptr = strrchr( full_argv0, '/' )))
825 {
826 memcpy( argv[0], full_argv0, ptr - full_argv0 );
827 strcpy( argv[0] + (ptr - full_argv0), "/wine" );
828 execve( argv[0], argv, envp );
829 }
830 free( argv[0] );
831
832 /* now search in the Unix path */
833 if ((path = getenv( "PATH" )))
834 {
835 if (!(argv[0] = malloc( strlen(path) + 6 ))) return;
836 pos = path;
837 for (;;)
838 {
839 while (*pos == ':') pos++;
840 if (!*pos) break;
841 if (!(ptr = strchr( pos, ':' ))) ptr = pos + strlen(pos);
842 memcpy( argv[0], pos, ptr - pos );
843 strcpy( argv[0] + (ptr - pos), "/wine" );
844 execve( argv[0], argv, envp );
845 pos = ptr;
846 }
847 }
848 free( argv[0] );
849 }
850
851
852 /***********************************************************************
853 * fork_and_exec
854 *
855 * Fork and exec a new Unix binary, checking for errors.
856 */
857 static int fork_and_exec( const char *filename, char *cmdline,
858 const char *env, const char *newdir )
859 {
860 int fd[2];
861 int pid, err;
862
863 if (!env) env = GetEnvironmentStringsA();
864
865 if (pipe(fd) == -1)
866 {
867 FILE_SetDosError();
868 return -1;
869 }
870 fcntl( fd[1], F_SETFD, 1 ); /* set close on exec */
871 if (!(pid = fork())) /* child */
872 {
873 char **argv = build_argv( cmdline, 0 );
874 char **envp = build_envp( env, NULL );
875 close( fd[0] );
876
877 /* Reset signals that we previously set to SIG_IGN */
878 signal( SIGPIPE, SIG_DFL );
879 signal( SIGCHLD, SIG_DFL );
880
881 if (newdir) chdir(newdir);
882
883 if (argv && envp) execve( filename, argv, envp );
884 err = errno;
885 write( fd[1], &err, sizeof(err) );
886 _exit(1);
887 }
888 close( fd[1] );
889 if ((pid != -1) && (read( fd[0], &err, sizeof(err) ) > 0)) /* exec failed */
890 {
891 errno = err;
892 pid = -1;
893 }
894 if (pid == -1) FILE_SetDosError();
895 close( fd[0] );
896 return pid;
897 }
898
899
900 /***********************************************************************
901 * create_process
902 *
903 * Create a new process. If hFile is a valid handle we have an exe
904 * file, otherwise it is a Winelib app.
905 */
906 static BOOL create_process( HANDLE hFile, LPCSTR filename, LPSTR cmd_line, LPCSTR env,
907 LPSECURITY_ATTRIBUTES psa, LPSECURITY_ATTRIBUTES tsa,
908 BOOL inherit, DWORD flags, LPSTARTUPINFOA startup,
909 LPPROCESS_INFORMATION info, LPCSTR unixdir )
910 {
911 BOOL ret, success = FALSE;
912 HANDLE process_info;
913 startup_info_t startup_info;
914 char *extra_env = NULL;
915 int startfd[2];
916 int execfd[2];
917 pid_t pid;
918 int err;
919 char dummy = 0;
920
921 if (!env)
922 {
923 env = GetEnvironmentStringsA();
924 extra_env = DRIVE_BuildEnv();
925 }
926
927 /* create the synchronization pipes */
928
929 if (pipe( startfd ) == -1)
930 {
931 FILE_SetDosError();
932 return FALSE;
933 }
934 if (pipe( execfd ) == -1)
935 {
936 close( startfd[0] );
937 close( startfd[1] );
938 FILE_SetDosError();
939 return FALSE;
940 }
941 fcntl( execfd[1], F_SETFD, 1 ); /* set close on exec */
942
943 /* create the child process */
944
945 if (!(pid = fork())) /* child */
946 {
947 char **argv = build_argv( cmd_line, 1 );
948 char **envp = build_envp( env, extra_env );
949
950 close( startfd[1] );
951 close( execfd[0] );
952
953 /* wait for parent to tell us to start */
954 if (read( startfd[0], &dummy, 1 ) != 1) _exit(1);
955
956 close( startfd[0] );
957 /* Reset signals that we previously set to SIG_IGN */
958 signal( SIGPIPE, SIG_DFL );
959 signal( SIGCHLD, SIG_DFL );
960
961 if (unixdir) chdir(unixdir);
962
963 if (argv && envp) exec_wine_binary( argv, envp );
964
965 err = errno;
966 write( execfd[1], &err, sizeof(err) );
967 _exit(1);
968 }
969
970 /* this is the parent */
971
972 close( startfd[0] );
973 close( execfd[1] );
974 if (extra_env) HeapFree( GetProcessHeap(), 0, extra_env );
975 if (pid == -1)
976 {
977 close( startfd[1] );
978 close( execfd[0] );
979 FILE_SetDosError();
980 return FALSE;
981 }
982
983 /* fill the startup info structure */
984
985 startup_info.size = sizeof(startup_info);
986 /* startup_info.filename_len is set below */
987 startup_info.cmdline_len = cmd_line ? strlen(cmd_line) : 0;
988 startup_info.desktop_len = startup->lpDesktop ? strlen(startup->lpDesktop) : 0;
989 startup_info.title_len = startup->lpTitle ? strlen(startup->lpTitle) : 0;
990 startup_info.x = startup->dwX;
991 startup_info.y = startup->dwY;
992 startup_info.cx = startup->dwXSize;
993 startup_info.cy = startup->dwYSize;
994 startup_info.x_chars = startup->dwXCountChars;
995 startup_info.y_chars = startup->dwYCountChars;
996 startup_info.attribute = startup->dwFillAttribute;
997 startup_info.cmd_show = startup->wShowWindow;
998 startup_info.flags = startup->dwFlags;
999
1000 /* create the process on the server side */
1001
1002 SERVER_START_REQ( new_process )
1003 {
1004 char buf[MAX_PATH];
1005 LPCSTR nameptr;
1006
1007 req->inherit_all = inherit;
1008 req->create_flags = flags;
1009 req->unix_pid = pid;
1010 req->exe_file = hFile;
1011 if (startup->dwFlags & STARTF_USESTDHANDLES)
1012 {
1013 req->hstdin = startup->hStdInput;
1014 req->hstdout = startup->hStdOutput;
1015 req->hstderr = startup->hStdError;
1016 }
1017 else
1018 {
1019 req->hstdin = GetStdHandle( STD_INPUT_HANDLE );
1020 req->hstdout = GetStdHandle( STD_OUTPUT_HANDLE );
1021 req->hstderr = GetStdHandle( STD_ERROR_HANDLE );
1022 }
1023
1024 if ((flags & (CREATE_NEW_CONSOLE | DETACHED_PROCESS)) != 0)
1025 {
1026 /* this is temporary (for console handles). We have no way to control that the handle is invalid in child process otherwise */
1027 if (is_console_handle(req->hstdin)) req->hstdin = INVALID_HANDLE_VALUE;
1028 if (is_console_handle(req->hstdout)) req->hstdout = INVALID_HANDLE_VALUE;
1029 if (is_console_handle(req->hstderr)) req->hstderr = INVALID_HANDLE_VALUE;
1030 }
1031 else
1032 {
1033 if (is_console_handle(req->hstdin)) req->hstdin = console_handle_unmap(req->hstdin);
1034 if (is_console_handle(req->hstdout)) req->hstdout = console_handle_unmap(req->hstdout);
1035 if (is_console_handle(req->hstderr)) req->hstderr = console_handle_unmap(req->hstderr);
1036 }
1037
1038 if (GetLongPathNameA( filename, buf, MAX_PATH ))
1039 nameptr = buf;
1040 else
1041 nameptr = filename;
1042
1043 startup_info.filename_len = strlen(nameptr);
1044 wine_server_add_data( req, &startup_info, sizeof(startup_info) );
1045 wine_server_add_data( req, nameptr, startup_info.filename_len );
1046 wine_server_add_data( req, cmd_line, startup_info.cmdline_len );
1047 wine_server_add_data( req, startup->lpDesktop, startup_info.desktop_len );
1048 wine_server_add_data( req, startup->lpTitle, startup_info.title_len );
1049
1050 ret = !wine_server_call_err( req );
1051 process_info = reply->info;
1052 }
1053 SERVER_END_REQ;
1054
1055 if (!ret)
1056 {
1057 close( startfd[1] );
1058 close( execfd[0] );
1059 return FALSE;
1060 }
1061
1062 /* tell child to start and wait for it to exec */
1063
1064 write( startfd[1], &dummy, 1 );
1065 close( startfd[1] );
1066
1067 if (read( execfd[0], &err, sizeof(err) ) > 0) /* exec failed */
1068 {
1069 errno = err;
1070 FILE_SetDosError();
1071 close( execfd[0] );
1072 CloseHandle( process_info );
1073 return FALSE;
1074 }
1075
1076 /* wait for the new process info to be ready */
1077
1078 WaitForSingleObject( process_info, INFINITE );
1079 SERVER_START_REQ( get_new_process_info )
1080 {
1081 req->info = process_info;
1082 req->pinherit = (psa && (psa->nLength >= sizeof(*psa)) && psa->bInheritHandle);
1083 req->tinherit = (tsa && (tsa->nLength >= sizeof(*tsa)) && tsa->bInheritHandle);
1084 if ((ret = !wine_server_call_err( req )))
1085 {
1086 info->dwProcessId = (DWORD)reply->pid;
1087 info->dwThreadId = (DWORD)reply->tid;
1088 info->hProcess = reply->phandle;
1089 info->hThread = reply->thandle;
1090 success = reply->success;
1091 }
1092 }
1093 SERVER_END_REQ;
1094
1095 if (ret && !success) /* new process failed to start */
1096 {
1097 DWORD exitcode;
1098 if (GetExitCodeProcess( info->hProcess, &exitcode )) SetLastError( exitcode );
1099 CloseHandle( info->hThread );
1100 CloseHandle( info->hProcess );
1101 ret = FALSE;
1102 }
1103 CloseHandle( process_info );
1104 return ret;
1105 }
1106
1107
1108 /***********************************************************************
1109 * create_vdm_process
1110 *
1111 * Create a new VDM process for a 16-bit or DOS application.
1112 */
1113 static BOOL create_vdm_process( LPCSTR filename, LPSTR cmd_line, LPCSTR env,
1114 LPSECURITY_ATTRIBUTES psa, LPSECURITY_ATTRIBUTES tsa,
1115 BOOL inherit, DWORD flags, LPSTARTUPINFOA startup,
1116 LPPROCESS_INFORMATION info, LPCSTR unixdir )
1117 {
1118 BOOL ret;
1119 LPSTR new_cmd_line = HeapAlloc( GetProcessHeap(), 0, strlen(filename) + strlen(cmd_line) + 30 );
1120
1121 if (!new_cmd_line)
1122 {
1123 SetLastError( ERROR_OUTOFMEMORY );
1124 return FALSE;
1125 }
1126 sprintf( new_cmd_line, "winevdm.exe --app-name \"%s\" %s", filename, cmd_line );
1127 ret = create_process( 0, "winevdm.exe", new_cmd_line, env, psa, tsa, inherit,
1128 flags, startup, info, unixdir );
1129 HeapFree( GetProcessHeap(), 0, new_cmd_line );
1130 return ret;
1131 }
1132
1133
1134 /*************************************************************************
1135 * get_file_name
1136 *
1137 * Helper for CreateProcess: retrieve the file name to load from the
1138 * app name and command line. Store the file name in buffer, and
1139 * return a possibly modified command line.
1140 * Also returns a handle to the opened file if it's a Windows binary.
1141 */
1142 static LPSTR get_file_name( LPCSTR appname, LPSTR cmdline, LPSTR buffer,
1143 int buflen, HANDLE *handle )
1144 {
1145 char *name, *pos, *ret = NULL;
1146 const char *p;
1147
1148 /* if we have an app name, everything is easy */
1149
1150 if (appname)
1151 {
1152 /* use the unmodified app name as file name */
1153 lstrcpynA( buffer, appname, buflen );
1154 *handle = open_exe_file( buffer );
1155 if (!(ret = cmdline) || !cmdline[0])
1156 {
1157 /* no command-line, create one */
1158 if ((ret = HeapAlloc( GetProcessHeap(), 0, strlen(appname) + 3 )))
1159 sprintf( ret, "\"%s\"", appname );
1160 }
1161 return ret;
1162 }
1163
1164 if (!cmdline)
1165 {
1166 SetLastError( ERROR_INVALID_PARAMETER );
1167 return NULL;
1168 }
1169
1170 /* first check for a quoted file name */
1171
1172 if ((cmdline[0] == '"') && ((p = strchr( cmdline + 1, '"' ))))
1173 {
1174 int len = p - cmdline - 1;
1175 /* extract the quoted portion as file name */
1176 if (!(name = HeapAlloc( GetProcessHeap(), 0, len + 1 ))) return NULL;
1177 memcpy( name, cmdline + 1, len );
1178 name[len] = 0;
1179
1180 if (find_exe_file( name, buffer, buflen, handle ))
1181 ret = cmdline; /* no change necessary */
1182 goto done;
1183 }
1184
1185 /* now try the command-line word by word */
1186
1187 if (!(name = HeapAlloc( GetProcessHeap(), 0, strlen(cmdline) + 1 ))) return NULL;
1188 pos = name;
1189 p = cmdline;
1190
1191 while (*p)
1192 {
1193 do *pos++ = *p++; while (*p && *p != ' ');
1194 *pos = 0;
1195 if (find_exe_file( name, buffer, buflen, handle ))
1196 {
1197 ret = cmdline;
1198 break;
1199 }
1200 }
1201
1202 if (!ret || !strchr( name, ' ' )) goto done; /* no change necessary */
1203
1204 /* now build a new command-line with quotes */
1205
1206 if (!(ret = HeapAlloc( GetProcessHeap(), 0, strlen(cmdline) + 3 ))) goto done;
1207 sprintf( ret, "\"%s\"%s", name, p );
1208
1209 done:
1210 HeapFree( GetProcessHeap(), 0, name );
1211 return ret;
1212 }
1213
1214
1215 /**********************************************************************
1216 * CreateProcessA (KERNEL32.@)
1217 */
1218 BOOL WINAPI CreateProcessA( LPCSTR app_name, LPSTR cmd_line, LPSECURITY_ATTRIBUTES process_attr,
1219 LPSECURITY_ATTRIBUTES thread_attr, BOOL inherit,
1220 DWORD flags, LPVOID env, LPCSTR cur_dir,
1221 LPSTARTUPINFOA startup_info, LPPROCESS_INFORMATION info )
1222 {
1223 BOOL retv = FALSE;
1224 HANDLE hFile = 0;
1225 const char *unixdir = NULL;
1226 DOS_FULL_NAME full_dir;
1227 char name[MAX_PATH];
1228 LPSTR tidy_cmdline;
1229 char *p;
1230
1231 /* Process the AppName and/or CmdLine to get module name and path */
1232
1233 TRACE("app %s cmdline %s\n", debugstr_a(app_name), debugstr_a(cmd_line) );
1234
1235 if (!(tidy_cmdline = get_file_name( app_name, cmd_line, name, sizeof(name), &hFile )))
1236 return FALSE;
1237 if (hFile == INVALID_HANDLE_VALUE) goto done;
1238
1239 /* Warn if unsupported features are used */
1240
1241 if (flags & NORMAL_PRIORITY_CLASS)
1242 FIXME("(%s,...): NORMAL_PRIORITY_CLASS ignored\n", name);
1243 if (flags & IDLE_PRIORITY_CLASS)
1244 FIXME("(%s,...): IDLE_PRIORITY_CLASS ignored\n", name);
1245 if (flags & HIGH_PRIORITY_CLASS)
1246 FIXME("(%s,...): HIGH_PRIORITY_CLASS ignored\n", name);
1247 if (flags & REALTIME_PRIORITY_CLASS)
1248 FIXME("(%s,...): REALTIME_PRIORITY_CLASS ignored\n", name);
1249 if (flags & CREATE_NEW_PROCESS_GROUP)
1250 FIXME("(%s,...): CREATE_NEW_PROCESS_GROUP ignored\n", name);
1251 if (flags & CREATE_UNICODE_ENVIRONMENT)
1252 FIXME("(%s,...): CREATE_UNICODE_ENVIRONMENT ignored\n", name);
1253 if (flags & CREATE_SEPARATE_WOW_VDM)
1254 FIXME("(%s,...): CREATE_SEPARATE_WOW_VDM ignored\n", name);
1255 if (flags & CREATE_SHARED_WOW_VDM)
1256 FIXME("(%s,...): CREATE_SHARED_WOW_VDM ignored\n", name);
1257 if (flags & CREATE_DEFAULT_ERROR_MODE)
1258 FIXME("(%s,...): CREATE_DEFAULT_ERROR_MODE ignored\n", name);
1259 if (flags & CREATE_NO_WINDOW)
1260 FIXME("(%s,...): CREATE_NO_WINDOW ignored\n", name);
1261 if (flags & PROFILE_USER)
1262 FIXME("(%s,...): PROFILE_USER ignored\n", name);
1263 if (flags & PROFILE_KERNEL)
1264 FIXME("(%s,...): PROFILE_KERNEL ignored\n", name);
1265 if (flags & PROFILE_SERVER)
1266 FIXME("(%s,...): PROFILE_SERVER ignored\n", name);
1267 if (startup_info->lpDesktop)
1268 FIXME("(%s,...): startup_info->lpDesktop %s ignored\n",
1269 name, debugstr_a(startup_info->lpDesktop));
1270 if (startup_info->dwFlags & STARTF_RUNFULLSCREEN)
1271 FIXME("(%s,...): STARTF_RUNFULLSCREEN ignored\n", name);
1272 if (startup_info->dwFlags & STARTF_FORCEONFEEDBACK)
1273 FIXME("(%s,...): STARTF_FORCEONFEEDBACK ignored\n", name);
1274 if (startup_info->dwFlags & STARTF_FORCEOFFFEEDBACK)
1275 FIXME("(%s,...): STARTF_FORCEOFFFEEDBACK ignored\n", name);
1276 if (startup_info->dwFlags & STARTF_USEHOTKEY)
1277 FIXME("(%s,...): STARTF_USEHOTKEY ignored\n", name);
1278
1279 if (cur_dir)
1280 {
1281 UNICODE_STRING cur_dirW;
1282 RtlCreateUnicodeStringFromAsciiz(&cur_dirW, cur_dir);
1283 if (DOSFS_GetFullName( cur_dirW.Buffer, TRUE, &full_dir ))
1284 unixdir = full_dir.long_name;
1285 RtlFreeUnicodeString(&cur_dirW);
1286 }
1287 else
1288 {
1289 WCHAR buf[MAX_PATH];
1290 if (GetCurrentDirectoryW(MAX_PATH, buf))
1291 {
1292 if (DOSFS_GetFullName( buf, TRUE, &full_dir )) unixdir = full_dir.long_name;
1293 }
1294 }
1295
1296 info->hThread = info->hProcess = 0;
1297 info->dwProcessId = info->dwThreadId = 0;
1298
1299 /* Determine executable type */
1300
1301 if (!hFile) /* builtin exe */
1302 {
1303 TRACE( "starting %s as Winelib app\n", debugstr_a(name) );
1304 retv = create_process( 0, name, tidy_cmdline, env, process_attr, thread_attr,
1305 inherit, flags, startup_info, info, unixdir );
1306 goto done;
1307 }
1308
1309 switch( MODULE_GetBinaryType( hFile ))
1310 {
1311 case BINARY_PE_EXE:
1312 TRACE( "starting %s as Win32 binary\n", debugstr_a(name) );
1313 retv = create_process( hFile, name, tidy_cmdline, env, process_attr, thread_attr,
1314 inherit, flags, startup_info, info, unixdir );
1315 break;
1316 case BINARY_WIN16:
1317 case BINARY_DOS:
1318 TRACE( "starting %s as Win16/DOS binary\n", debugstr_a(name) );
1319 retv = create_vdm_process( name, tidy_cmdline, env, process_attr, thread_attr,
1320 inherit, flags, startup_info, info, unixdir );
1321 break;
1322 case BINARY_OS216:
1323 FIXME( "%s is OS/2 binary, not supported\n", debugstr_a(name) );
1324 SetLastError( ERROR_BAD_EXE_FORMAT );
1325 break;
1326 case BINARY_PE_DLL:
1327 TRACE( "not starting %s since it is a dll\n", debugstr_a(name) );
1328 SetLastError( ERROR_BAD_EXE_FORMAT );
1329 break;
1330 case BINARY_UNIX_LIB:
1331 TRACE( "%s is a Unix library, starting as Winelib app\n", debugstr_a(name) );
1332 retv = create_process( hFile, name, tidy_cmdline, env, process_attr, thread_attr,
1333 inherit, flags, startup_info, info, unixdir );
1334 break;
1335 case BINARY_UNKNOWN:
1336 /* check for .com or .bat extension */
1337 if ((p = strrchr( name, '.' )))
1338 {
1339 if (!FILE_strcasecmp( p, ".com" ))
1340 {
1341 TRACE( "starting %s as DOS binary\n", debugstr_a(name) );
1342 retv = create_vdm_process( name, tidy_cmdline, env, process_attr, thread_attr,
1343 inherit, flags, startup_info, info, unixdir );
1344 break;
1345 }
1346 if (!FILE_strcasecmp( p, ".bat" ))
1347 {
1348 char comspec[MAX_PATH];
1349 if (GetEnvironmentVariableA("COMSPEC", comspec, sizeof(comspec)))
1350 {
1351 char *newcmdline;
1352 if ((newcmdline = HeapAlloc( GetProcessHeap(), 0,
1353 strlen(comspec) + 4 + strlen(tidy_cmdline) + 1)))
1354 {
1355 sprintf( newcmdline, "%s /c %s", comspec, tidy_cmdline);
1356 TRACE( "starting %s as batch binary: %s\n",
1357 debugstr_a(name), debugstr_a(newcmdline) );
1358 retv = CreateProcessA( comspec, newcmdline, process_attr, thread_attr,
1359 inherit, flags, env, cur_dir, startup_info, info );
1360 HeapFree( GetProcessHeap(), 0, newcmdline );
1361 break;
1362 }
1363 }
1364 }
1365 }
1366 /* fall through */
1367 case BINARY_UNIX_EXE:
1368 {
1369 /* unknown file, try as unix executable */
1370 UNICODE_STRING nameW;
1371 DOS_FULL_NAME full_name;
1372 const char *unixfilename = name;
1373
1374 TRACE( "starting %s as Unix binary\n", debugstr_a(name) );
1375
1376 RtlCreateUnicodeStringFromAsciiz(&nameW, name);
1377 if (DOSFS_GetFullName( nameW.Buffer, TRUE, &full_name )) unixfilename = full_name.long_name;
1378 RtlFreeUnicodeString(&nameW);
1379 retv = (fork_and_exec( unixfilename, tidy_cmdline, env, unixdir ) != -1);
1380 }
1381 break;
1382 }
1383 CloseHandle( hFile );
1384
1385 done:
1386 if (tidy_cmdline != cmd_line) HeapFree( GetProcessHeap(), 0, tidy_cmdline );
1387 return retv;
1388 }
1389
1390
1391 /**********************************************************************
1392 * CreateProcessW (KERNEL32.@)
1393 * NOTES
1394 * lpReserved is not converted
1395 */
1396 BOOL WINAPI CreateProcessW( LPCWSTR app_name, LPWSTR cmd_line, LPSECURITY_ATTRIBUTES process_attr,
1397 LPSECURITY_ATTRIBUTES thread_attr, BOOL inherit, DWORD flags,
1398 LPVOID env, LPCWSTR cur_dir, LPSTARTUPINFOW startup_info,
1399 LPPROCESS_INFORMATION info )
1400 {
1401 BOOL ret;
1402 STARTUPINFOA StartupInfoA;
1403
1404 LPSTR app_nameA = HEAP_strdupWtoA (GetProcessHeap(),0,app_name);
1405 LPSTR cmd_lineA = HEAP_strdupWtoA (GetProcessHeap(),0,cmd_line);
1406 LPSTR cur_dirA = HEAP_strdupWtoA (GetProcessHeap(),0,cur_dir);
1407
1408 memcpy (&StartupInfoA, startup_info, sizeof(STARTUPINFOA));
1409 StartupInfoA.lpDesktop = HEAP_strdupWtoA (GetProcessHeap(),0,startup_info->lpDesktop);
1410 StartupInfoA.lpTitle = HEAP_strdupWtoA (GetProcessHeap(),0,startup_info->lpTitle);
1411
1412 TRACE("(%s,%s,...)\n", debugstr_w(app_name), debugstr_w(cmd_line));
1413
1414 if (startup_info->lpReserved)
1415 FIXME("StartupInfo.lpReserved is used, please report (%s)\n",
1416 debugstr_w(startup_info->lpReserved));
1417
1418 ret = CreateProcessA( app_nameA, cmd_lineA, process_attr, thread_attr,
1419 inherit, flags, env, cur_dirA, &StartupInfoA, info );
1420
1421 HeapFree( GetProcessHeap(), 0, cur_dirA );
1422 HeapFree( GetProcessHeap(), 0, cmd_lineA );
1423 HeapFree( GetProcessHeap(), 0, StartupInfoA.lpDesktop );
1424 HeapFree( GetProcessHeap(), 0, StartupInfoA.lpTitle );
1425
1426 return ret;
1427 }
1428
1429
1430 /***********************************************************************
1431 * wait_input_idle
1432 *
1433 * Wrapper to call WaitForInputIdle USER function
1434 */
1435 typedef DWORD (WINAPI *WaitForInputIdle_ptr)( HANDLE hProcess, DWORD dwTimeOut );
1436
1437 static DWORD wait_input_idle( HANDLE process, DWORD timeout )
1438 {
1439 HMODULE mod = GetModuleHandleA( "user32.dll" );
1440 if (mod)
1441 {
1442 WaitForInputIdle_ptr ptr = (WaitForInputIdle_ptr)GetProcAddress( mod, "WaitForInputIdle" );
1443 if (ptr) return ptr( process, timeout );
1444 }
1445 return 0;
1446 }
1447
1448
1449 /***********************************************************************
1450 * WinExec (KERNEL32.@)
1451 */
1452 UINT WINAPI WinExec( LPCSTR lpCmdLine, UINT nCmdShow )
1453 {
1454 PROCESS_INFORMATION info;
1455 STARTUPINFOA startup;
1456 char *cmdline;
1457 UINT ret;
1458
1459 memset( &startup, 0, sizeof(startup) );
1460 startup.cb = sizeof(startup);
1461 startup.dwFlags = STARTF_USESHOWWINDOW;
1462 startup.wShowWindow = nCmdShow;
1463
1464 /* cmdline needs to be writeable for CreateProcess */
1465 if (!(cmdline = HeapAlloc( GetProcessHeap(), 0, strlen(lpCmdLine)+1 ))) return 0;
1466 strcpy( cmdline, lpCmdLine );
1467
1468 if (CreateProcessA( NULL, cmdline, NULL, NULL, FALSE,
1469 0, NULL, NULL, &startup, &info ))
1470 {
1471 /* Give 30 seconds to the app to come up */
1472 if (wait_input_idle( info.hProcess, 30000 ) == 0xFFFFFFFF)
1473 WARN("WaitForInputIdle failed: Error %ld\n", GetLastError() );
1474 ret = 33;
1475 /* Close off the handles */
1476 CloseHandle( info.hThread );
1477 CloseHandle( info.hProcess );
1478 }
1479 else if ((ret = GetLastError()) >= 32)
1480 {
1481 FIXME("Strange error set by CreateProcess: %d\n", ret );
1482 ret = 11;
1483 }
1484 HeapFree( GetProcessHeap(), 0, cmdline );
1485 return ret;
1486 }
1487
1488
1489 /**********************************************************************
1490 * LoadModule (KERNEL32.@)
1491 */
1492 HINSTANCE WINAPI LoadModule( LPCSTR name, LPVOID paramBlock )
1493 {
1494 LOADPARAMS *params = (LOADPARAMS *)paramBlock;
1495 PROCESS_INFORMATION info;
1496 STARTUPINFOA startup;
1497 HINSTANCE hInstance;
1498 LPSTR cmdline, p;
1499 char filename[MAX_PATH];
1500 BYTE len;
1501
1502 if (!name) return (HINSTANCE)ERROR_FILE_NOT_FOUND;
1503
1504 if (!SearchPathA( NULL, name, ".exe", sizeof(filename), filename, NULL ) &&
1505 !SearchPathA( NULL, name, NULL, sizeof(filename), filename, NULL ))
1506 return (HINSTANCE)GetLastError();
1507
1508 len = (BYTE)params->lpCmdLine[0];
1509 if (!(cmdline = HeapAlloc( GetProcessHeap(), 0, strlen(filename) + len + 2 )))
1510 return (HINSTANCE)ERROR_NOT_ENOUGH_MEMORY;
1511
1512 strcpy( cmdline, filename );
1513 p = cmdline + strlen(cmdline);
1514 *p++ = ' ';
1515 memcpy( p, params->lpCmdLine + 1, len );
1516 p[len] = 0;
1517
1518 memset( &startup, 0, sizeof(startup) );
1519 startup.cb = sizeof(startup);
1520 if (params->lpCmdShow)
1521 {
1522 startup.dwFlags = STARTF_USESHOWWINDOW;
1523 startup.wShowWindow = params->lpCmdShow[1];
1524 }
1525
1526 if (CreateProcessA( filename, cmdline, NULL, NULL, FALSE, 0,
1527 params->lpEnvAddress, NULL, &startup, &info ))
1528 {
1529 /* Give 30 seconds to the app to come up */
1530 if (wait_input_idle( info.hProcess, 30000 ) == 0xFFFFFFFF )
1531 WARN("WaitForInputIdle failed: Error %ld\n", GetLastError() );
1532 hInstance = (HINSTANCE)33;
1533 /* Close off the handles */
1534 CloseHandle( info.hThread );
1535 CloseHandle( info.hProcess );
1536 }
1537 else if ((hInstance = (HINSTANCE)GetLastError()) >= (HINSTANCE)32)
1538 {
1539 FIXME("Strange error set by CreateProcess: %p\n", hInstance );
1540 hInstance = (HINSTANCE)11;
1541 }
1542
1543 HeapFree( GetProcessHeap(), 0, cmdline );
1544 return hInstance;
1545 }
1546
1547
1548 /******************************************************************************
1549 * TerminateProcess (KERNEL32.@)
1550 */
1551 BOOL WINAPI TerminateProcess( HANDLE handle, DWORD exit_code )
1552 {
1553 NTSTATUS status = NtTerminateProcess( handle, exit_code );
1554 if (status) SetLastError( RtlNtStatusToDosError(status) );
1555 return !status;
1556 }
1557
1558
1559 /***********************************************************************
1560 * GetExitCodeProcess [KERNEL32.@]
1561 *
1562 * Gets termination status of specified process
1563 *
1564 * RETURNS
1565 * Success: TRUE
1566 * Failure: FALSE
1567 */
1568 BOOL WINAPI GetExitCodeProcess(
1569 HANDLE hProcess, /* [in] handle to the process */
1570 LPDWORD lpExitCode) /* [out] address to receive termination status */
1571 {
1572 BOOL ret;
1573 SERVER_START_REQ( get_process_info )
1574 {
1575 req->handle = hProcess;
1576 ret = !wine_server_call_err( req );
1577 if (ret && lpExitCode) *lpExitCode = reply->exit_code;
1578 }
1579 SERVER_END_REQ;
1580 return ret;
1581 }
1582
1583
1584 /***********************************************************************
1585 * SetErrorMode (KERNEL32.@)
1586 */
1587 UINT WINAPI SetErrorMode( UINT mode )
1588 {
1589 UINT old = current_process.error_mode;
1590 current_process.error_mode = mode;
1591 return old;
1592 }
1593
1594
1595 /**********************************************************************
1596 * TlsAlloc [KERNEL32.@] Allocates a TLS index.
1597 *
1598 * Allocates a thread local storage index
1599 *
1600 * RETURNS
1601 * Success: TLS Index
1602 * Failure: 0xFFFFFFFF
1603 */
1604 DWORD WINAPI TlsAlloc( void )
1605 {
1606 DWORD i, mask, ret = 0;
1607 DWORD *bits = current_process.tls_bits;
1608 RtlAcquirePebLock();
1609 if (*bits == 0xffffffff)
1610 {
1611 bits++;
1612 ret = 32;
1613 if (*bits == 0xffffffff)
1614 {
1615 RtlReleasePebLock();
1616 SetLastError( ERROR_NO_MORE_ITEMS );
1617 return 0xffffffff;
1618 }
1619 }
1620 for (i = 0, mask = 1; i < 32; i++, mask <<= 1) if (!(*bits & mask)) break;
1621 *bits |= mask;
1622 RtlReleasePebLock();
1623 NtCurrentTeb()->TlsSlots[ret+i] = 0; /* clear the value */
1624 return ret + i;
1625 }
1626
1627
1628 /**********************************************************************
1629 * TlsFree [KERNEL32.@] Releases a TLS index.
1630 *
1631 * Releases a thread local storage index, making it available for reuse
1632 *
1633 * RETURNS
1634 * Success: TRUE
1635 * Failure: FALSE
1636 */
1637 BOOL WINAPI TlsFree(
1638 DWORD index) /* [in] TLS Index to free */
1639 {
1640 DWORD mask = (1 << (index & 31));
1641 DWORD *bits = current_process.tls_bits;
1642 if (index >= 64)
1643 {
1644 SetLastError( ERROR_INVALID_PARAMETER );
1645 return FALSE;
1646 }
1647 if (index >= 32) bits++;
1648 RtlAcquirePebLock();
1649 if (!(*bits & mask)) /* already free? */
1650 {
1651 RtlReleasePebLock();
1652 SetLastError( ERROR_INVALID_PARAMETER );
1653 return FALSE;
1654 }
1655 *bits &= ~mask;
1656 NtSetInformationThread( GetCurrentThread(), ThreadZeroTlsCell, &index, sizeof(index) );
1657 RtlReleasePebLock();
1658 return TRUE;
1659 }
1660
1661
1662 /**********************************************************************
1663 * TlsGetValue [KERNEL32.@] Gets value in a thread's TLS slot
1664 *
1665 * RETURNS
1666 * Success: Value stored in calling thread's TLS slot for index
1667 * Failure: 0 and GetLastError returns NO_ERROR
1668 */
1669 LPVOID WINAPI TlsGetValue(
1670 DWORD index) /* [in] TLS index to retrieve value for */
1671 {
1672 if (index >= 64)
1673 {
1674 SetLastError( ERROR_INVALID_PARAMETER );
1675 return NULL;
1676 }
1677 SetLastError( ERROR_SUCCESS );
1678 return NtCurrentTeb()->TlsSlots[index];
1679 }
1680
1681
1682 /**********************************************************************
1683 * TlsSetValue [KERNEL32.@] Stores a value in the thread's TLS slot.
1684 *
1685 * RETURNS
1686 * Success: TRUE
1687 * Failure: FALSE
1688 */
1689 BOOL WINAPI TlsSetValue(
1690 DWORD index, /* [in] TLS index to set value for */
1691 LPVOID value) /* [in] Value to be stored */
1692 {
1693 if (index >= 64)
1694 {
1695 SetLastError( ERROR_INVALID_PARAMETER );
1696 return FALSE;
1697 }
1698 NtCurrentTeb()->TlsSlots[index] = value;
1699 return TRUE;
1700 }
1701
1702
1703 /***********************************************************************
1704 * GetProcessFlags (KERNEL32.@)
1705 */
1706 DWORD WINAPI GetProcessFlags( DWORD processid )
1707 {
1708 IMAGE_NT_HEADERS *nt;
1709 DWORD flags = 0;
1710
1711 if (processid && processid != GetCurrentProcessId()) return 0;
1712
1713 if ((nt = RtlImageNtHeader( NtCurrentTeb()->Peb->ImageBaseAddress )))
1714 {
1715 if (nt->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI)
1716 flags |= PDB32_CONSOLE_PROC;
1717 }
1718 if (!AreFileApisANSI()) flags |= PDB32_FILE_APIS_OEM;
1719 if (IsDebuggerPresent()) flags |= PDB32_DEBUGGED;
1720 return flags;
1721 }
1722
1723
1724 /***********************************************************************
1725 * GetProcessDword (KERNEL.485)
1726 * GetProcessDword (KERNEL32.18)
1727 * 'Of course you cannot directly access Windows internal structures'
1728 */
1729 DWORD WINAPI GetProcessDword( DWORD dwProcessID, INT offset )
1730 {
1731 DWORD x, y;
1732 STARTUPINFOW siw;
1733
1734 TRACE("(%ld, %d)\n", dwProcessID, offset );
1735
1736 if (dwProcessID && dwProcessID != GetCurrentProcessId())
1737 {
1738 ERR("%d: process %lx not accessible\n", offset, dwProcessID);
1739 return 0;
1740 }
1741
1742 switch ( offset )
1743 {
1744 case GPD_APP_COMPAT_FLAGS:
1745 return GetAppCompatFlags16(0);
1746 case GPD_LOAD_DONE_EVENT:
1747 return 0;
1748 case GPD_HINSTANCE16:
1749 return GetTaskDS16();
1750 case GPD_WINDOWS_VERSION:
1751 return GetExeVersion16();
1752 case GPD_THDB:
1753 return (DWORD)NtCurrentTeb() - 0x10 /* FIXME */;
1754 case GPD_PDB:
1755 return (DWORD)NtCurrentTeb()->Peb;
1756 case GPD_STARTF_SHELLDATA: /* return stdoutput handle from startupinfo ??? */
1757 GetStartupInfoW(&siw);
1758 return (DWORD)siw.hStdOutput;
1759 case GPD_STARTF_HOTKEY: /* return stdinput handle from startupinfo ??? */
1760 GetStartupInfoW(&siw);
1761 return (DWORD)siw.hStdInput;
1762 case GPD_STARTF_SHOWWINDOW:
1763 GetStartupInfoW(&siw);
1764 return siw.wShowWindow;
1765 case GPD_STARTF_SIZE:
1766 GetStartupInfoW(&siw);
1767 x = siw.dwXSize;
1768 if ( (INT)x == CW_USEDEFAULT ) x = CW_USEDEFAULT16;
1769 y = siw.dwYSize;
1770 if ( (INT)y == CW_USEDEFAULT ) y = CW_USEDEFAULT16;
1771 return MAKELONG( x, y );
1772 case GPD_STARTF_POSITION:
1773 GetStartupInfoW(&siw);
1774 x = siw.dwX;
1775 if ( (INT)x == CW_USEDEFAULT ) x = CW_USEDEFAULT16;
1776 y = siw.dwY;
1777 if ( (INT)y == CW_USEDEFAULT ) y = CW_USEDEFAULT16;
1778 return MAKELONG( x, y );
1779 case GPD_STARTF_FLAGS:
1780 GetStartupInfoW(&siw);
1781 return siw.dwFlags;
1782 case GPD_PARENT:
1783 return 0;
1784 case GPD_FLAGS:
1785 return GetProcessFlags(0);
1786 case GPD_USERDATA:
1787 return process_dword;
1788 default:
1789 ERR("Unknown offset %d\n", offset );
1790 return 0;
1791 }
1792 }
1793
1794 /***********************************************************************
1795 * SetProcessDword (KERNEL.484)
1796 * 'Of course you cannot directly access Windows internal structures'
1797 */
1798 void WINAPI SetProcessDword( DWORD dwProcessID, INT offset, DWORD value )
1799 {
1800 TRACE("(%ld, %d)\n", dwProcessID, offset );
1801
1802 if (dwProcessID && dwProcessID != GetCurrentProcessId())
1803 {
1804 ERR("%d: process %lx not accessible\n", offset, dwProcessID);
1805 return;
1806 }
1807
1808 switch ( offset )
1809 {
1810 case GPD_APP_COMPAT_FLAGS:
1811 case GPD_LOAD_DONE_EVENT:
1812 case GPD_HINSTANCE16:
1813 case GPD_WINDOWS_VERSION:
1814 case GPD_THDB:
1815 case GPD_PDB:
1816 case GPD_STARTF_SHELLDATA:
1817 case GPD_STARTF_HOTKEY:
1818 case GPD_STARTF_SHOWWINDOW:
1819 case GPD_STARTF_SIZE:
1820 case GPD_STARTF_POSITION:
1821 case GPD_STARTF_FLAGS:
1822 case GPD_PARENT:
1823 case GPD_FLAGS:
1824 ERR("Not allowed to modify offset %d\n", offset );
1825 break;
1826 case GPD_USERDATA:
1827 process_dword = value;
1828 break;
1829 default:
1830 ERR("Unknown offset %d\n", offset );
1831 break;
1832 }
1833 }
1834
1835
1836 /***********************************************************************
1837 * ExitProcess (KERNEL.466)
1838 */
1839 void WINAPI ExitProcess16( WORD status )
1840 {
1841 DWORD count;
1842 ReleaseThunkLock( &count );
1843 ExitProcess( status );
1844 }
1845
1846
1847 /*********************************************************************
1848 * OpenProcess (KERNEL32.@)
1849 */
1850 HANDLE WINAPI OpenProcess( DWORD access, BOOL inherit, DWORD id )
1851 {
1852 HANDLE ret = 0;
1853 SERVER_START_REQ( open_process )
1854 {
1855 req->pid = id;
1856 req->access = access;
1857 req->inherit = inherit;
1858 if (!wine_server_call_err( req )) ret = reply->handle;
1859 }
1860 SERVER_END_REQ;
1861 return ret;
1862 }
1863
1864
1865 /*********************************************************************
1866 * MapProcessHandle (KERNEL.483)
1867 */
1868 DWORD WINAPI MapProcessHandle( HANDLE handle )
1869 {
1870 DWORD ret = 0;
1871 SERVER_START_REQ( get_process_info )
1872 {
1873 req->handle = handle;
1874 if (!wine_server_call_err( req )) ret = reply->pid;
1875 }
1876 SERVER_END_REQ;
1877 return ret;
1878 }
1879
1880
1881 /***********************************************************************
1882 * SetPriorityClass (KERNEL32.@)
1883 */
1884 BOOL WINAPI SetPriorityClass( HANDLE hprocess, DWORD priorityclass )
1885 {
1886 BOOL ret;
1887 SERVER_START_REQ( set_process_info )
1888 {
1889 req->handle = hprocess;
1890 req->priority = priorityclass;
1891 req->mask = SET_PROCESS_INFO_PRIORITY;
1892 ret = !wine_server_call_err( req );
1893 }
1894 SERVER_END_REQ;
1895 return ret;
1896 }
1897
1898
1899 /***********************************************************************
1900 * GetPriorityClass (KERNEL32.@)
1901 */
1902 DWORD WINAPI GetPriorityClass(HANDLE hprocess)
1903 {
1904 DWORD ret = 0;
1905 SERVER_START_REQ( get_process_info )
1906 {
1907 req->handle = hprocess;
1908 if (!wine_server_call_err( req )) ret = reply->priority;
1909 }
1910 SERVER_END_REQ;
1911 return ret;
1912 }
1913
1914
1915 /***********************************************************************
1916 * SetProcessAffinityMask (KERNEL32.@)
1917 */
1918 BOOL WINAPI SetProcessAffinityMask( HANDLE hProcess, DWORD affmask )
1919 {
1920 BOOL ret;
1921 SERVER_START_REQ( set_process_info )
1922 {
1923 req->handle = hProcess;
1924 req->affinity = affmask;
1925 req->mask = SET_PROCESS_INFO_AFFINITY;
1926 ret = !wine_server_call_err( req );
1927 }
1928 SERVER_END_REQ;
1929 return ret;
1930 }
1931
1932
1933 /**********************************************************************
1934 * GetProcessAffinityMask (KERNEL32.@)
1935 */
1936 BOOL WINAPI GetProcessAffinityMask( HANDLE hProcess,
1937 LPDWORD lpProcessAffinityMask,
1938 LPDWORD lpSystemAffinityMask )
1939 {
1940 BOOL ret = FALSE;
1941 SERVER_START_REQ( get_process_info )
1942 {
1943 req->handle = hProcess;
1944 if (!wine_server_call_err( req ))
1945 {
1946 if (lpProcessAffinityMask) *lpProcessAffinityMask = reply->process_affinity;
1947 if (lpSystemAffinityMask) *lpSystemAffinityMask = reply->system_affinity;
1948 ret = TRUE;
1949 }
1950 }
1951 SERVER_END_REQ;
1952 return ret;
1953 }
1954
1955
1956 /***********************************************************************
1957 * GetProcessVersion (KERNEL32.@)
1958 */
1959 DWORD WINAPI GetProcessVersion( DWORD processid )
1960 {
1961 IMAGE_NT_HEADERS *nt;
1962
1963 if (processid && processid != GetCurrentProcessId())
1964 {
1965 FIXME("should use ReadProcessMemory\n");
1966 return 0;
1967 }
1968 if ((nt = RtlImageNtHeader( NtCurrentTeb()->Peb->ImageBaseAddress )))
1969 return ((nt->OptionalHeader.MajorSubsystemVersion << 16) |
1970 nt->OptionalHeader.MinorSubsystemVersion);
1971 return 0;
1972 }
1973
1974
1975 /***********************************************************************
1976 * SetProcessWorkingSetSize [KERNEL32.@]
1977 * Sets the min/max working set sizes for a specified process.
1978 *
1979 * PARAMS
1980 * hProcess [I] Handle to the process of interest
1981 * minset [I] Specifies minimum working set size
1982 * maxset [I] Specifies maximum working set size
1983 *
1984 * RETURNS STD
1985 */
1986 BOOL WINAPI SetProcessWorkingSetSize(HANDLE hProcess, SIZE_T minset,
1987 SIZE_T maxset)
1988 {
1989 FIXME("(%p,%ld,%ld): stub - harmless\n",hProcess,minset,maxset);
1990 if(( minset == (SIZE_T)-1) && (maxset == (SIZE_T)-1)) {
1991 /* Trim the working set to zero */
1992 /* Swap the process out of physical RAM */
1993 }
1994 return TRUE;
1995 }
1996
1997 /***********************************************************************
1998 * GetProcessWorkingSetSize (KERNEL32.@)
1999 */
2000 BOOL WINAPI GetProcessWorkingSetSize(HANDLE hProcess, PSIZE_T minset,
2001 PSIZE_T maxset)
2002 {
2003 FIXME("(%p,%p,%p): stub\n",hProcess,minset,maxset);
2004 /* 32 MB working set size */
2005 if (minset) *minset = 32*1024*1024;
2006 if (maxset) *maxset = 32*1024*1024;
2007 return TRUE;
2008 }
2009
2010
2011 /***********************************************************************
2012 * SetProcessShutdownParameters (KERNEL32.@)
2013 */
2014 BOOL WINAPI SetProcessShutdownParameters(DWORD level, DWORD flags)
2015 {
2016 FIXME("(%08lx, %08lx): partial stub.\n", level, flags);
2017 shutdown_flags = flags;
2018 shutdown_priority = level;
2019 return TRUE;
2020 }
2021
2022
2023 /***********************************************************************
2024 * GetProcessShutdownParameters (KERNEL32.@)
2025 *
2026 */
2027 BOOL WINAPI GetProcessShutdownParameters( LPDWORD lpdwLevel, LPDWORD lpdwFlags )
2028 {
2029 *lpdwLevel = shutdown_priority;
2030 *lpdwFlags = shutdown_flags;
2031 return TRUE;
2032 }
2033
2034
2035 /***********************************************************************
2036 * GetProcessPriorityBoost (KERNEL32.@)
2037 */
2038 BOOL WINAPI GetProcessPriorityBoost(HANDLE hprocess,PBOOL pDisablePriorityBoost)
2039 {
2040 FIXME("(%p,%p): semi-stub\n", hprocess, pDisablePriorityBoost);
2041
2042 /* Report that no boost is present.. */
2043 *pDisablePriorityBoost = FALSE;
2044
2045 return TRUE;
2046 }
2047
2048 /***********************************************************************
2049 * SetProcessPriorityBoost (KERNEL32.@)
2050 */
2051 BOOL WINAPI SetProcessPriorityBoost(HANDLE hprocess,BOOL disableboost)
2052 {
2053 FIXME("(%p,%d): stub\n",hprocess,disableboost);
2054 /* Say we can do it. I doubt the program will notice that we don't. */
2055 return TRUE;
2056 }
2057
2058
2059 /***********************************************************************
2060 * ReadProcessMemory (KERNEL32.@)
2061 */
2062 BOOL WINAPI ReadProcessMemory( HANDLE process, LPCVOID addr, LPVOID buffer, SIZE_T size,
2063 SIZE_T *bytes_read )
2064 {
2065 NTSTATUS status = NtReadVirtualMemory( process, addr, buffer, size, bytes_read );
2066 if (status) SetLastError( RtlNtStatusToDosError(status) );
2067 return !status;
2068 }
2069
2070
2071 /***********************************************************************
2072 * WriteProcessMemory (KERNEL32.@)
2073 */
2074 BOOL WINAPI WriteProcessMemory( HANDLE process, LPVOID addr, LPCVOID buffer, SIZE_T size,
2075 SIZE_T *bytes_written )
2076 {
2077 NTSTATUS status = NtWriteVirtualMemory( process, addr, buffer, size, bytes_written );
2078 if (status) SetLastError( RtlNtStatusToDosError(status) );
2079 return !status;
2080 }
2081
2082
2083 /****************************************************************************
2084 * FlushInstructionCache (KERNEL32.@)
2085 */
2086 BOOL WINAPI FlushInstructionCache(HANDLE hProcess, LPCVOID lpBaseAddress, SIZE_T dwSize)
2087 {
2088 if (GetVersion() & 0x80000000) return TRUE; /* not NT, always TRUE */
2089 FIXME("(%p,%p,0x%08lx): stub\n",hProcess, lpBaseAddress, dwSize);
2090 return TRUE;
2091 }
2092
2093
2094 /******************************************************************
2095 * GetProcessIoCounters (KERNEL32.@)
2096 */
2097 BOOL WINAPI GetProcessIoCounters(HANDLE hProcess, PIO_COUNTERS ioc)
2098 {
2099 NTSTATUS status;
2100
2101 status = NtQueryInformationProcess(hProcess, ProcessIoCounters,
2102 ioc, sizeof(*ioc), NULL);
2103 if (status) SetLastError( RtlNtStatusToDosError(status) );
2104 return !status;
2105 }
2106
2107 /***********************************************************************
2108 * ProcessIdToSessionId (KERNEL32.@)
2109 * This function is available on Terminal Server 4SP4 and Windows 2000
2110 */
2111 BOOL WINAPI ProcessIdToSessionId( DWORD procid, DWORD *sessionid_ptr )
2112 {
2113 /* According to MSDN, if the calling process is not in a terminal
2114 * services environment, then the sessionid returned is zero.
2115 */
2116 *sessionid_ptr = 0;
2117 return TRUE;
2118 }
2119
2120
2121 /***********************************************************************
2122 * RegisterServiceProcess (KERNEL.491)
2123 * RegisterServiceProcess (KERNEL32.@)
2124 *
2125 * A service process calls this function to ensure that it continues to run
2126 * even after a user logged off.
2127 */
2128 DWORD WINAPI RegisterServiceProcess(DWORD dwProcessId, DWORD dwType)
2129 {
2130 /* I don't think that Wine needs to do anything in that function */
2131 return 1; /* success */
2132 }
2133
2134
2135 /**************************************************************************
2136 * SetFileApisToOEM (KERNEL32.@)
2137 */
2138 VOID WINAPI SetFileApisToOEM(void)
2139 {
2140 oem_file_apis = TRUE;
2141 }
2142
2143
2144 /**************************************************************************
2145 * SetFileApisToANSI (KERNEL32.@)
2146 */
2147 VOID WINAPI SetFileApisToANSI(void)
2148 {
2149 oem_file_apis = FALSE;
2150 }
2151
2152
2153 /******************************************************************************
2154 * AreFileApisANSI [KERNEL32.@] Determines if file functions are using ANSI
2155 *
2156 * RETURNS
2157 * TRUE: Set of file functions is using ANSI code page
2158 * FALSE: Set of file functions is using OEM code page
2159 */
2160 BOOL WINAPI AreFileApisANSI(void)
2161 {
2162 return !oem_file_apis;
2163 }
2164
2165
2166 /***********************************************************************
2167 * GetCurrentProcess (KERNEL32.@)
2168 */
2169 #undef GetCurrentProcess
2170 HANDLE WINAPI GetCurrentProcess(void)
2171 {
2172 return (HANDLE)0xffffffff;
2173 }
useful hacks and other patches not (yet) suitable for mainline