?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pop 7b3ecd624d768eecb2eda237f54815110f480faa
[wine/hacks.git] / dlls / kernel32 / process.c
blob9a1f2f5242649957a2decc5c93fc1ed8f8f9ccb6
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 <signal.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <time.h>
31 #ifdef HAVE_SYS_TIME_H
32 # include <sys/time.h>
33 #endif
34 #ifdef HAVE_SYS_IOCTL_H
35 #include <sys/ioctl.h>
36 #endif
37 #ifdef HAVE_SYS_SOCKET_H
38 #include <sys/socket.h>
39 #endif
40 #ifdef HAVE_SYS_PRCTL_H
41 # include <sys/prctl.h>
42 #endif
43 #include <sys/types.h>
44
45 #include "ntstatus.h"
46 #define WIN32_NO_STATUS
47 #include "winternl.h"
48 #include "kernel_private.h"
49 #include "wine/library.h"
50 #include "wine/server.h"
51 #include "wine/unicode.h"
52 #include "wine/debug.h"
53
54 WINE_DEFAULT_DEBUG_CHANNEL(process);
55 WINE_DECLARE_DEBUG_CHANNEL(file);
56 WINE_DECLARE_DEBUG_CHANNEL(relay);
57
58 #ifdef __APPLE__
59 extern char **__wine_get_main_environment(void);
60 #else
61 extern char **__wine_main_environ;
62 static char **__wine_get_main_environment(void) { return __wine_main_environ; }
63 #endif
64
65 typedef struct
66 {
67 LPSTR lpEnvAddress;
68 LPSTR lpCmdLine;
69 LPSTR lpCmdShow;
70 DWORD dwReserved;
71 } LOADPARMS32;
72
73 static UINT process_error_mode;
74
75 static DWORD shutdown_flags = 0;
76 static DWORD shutdown_priority = 0x280;
77 static BOOL is_wow64;
78 static const int is_win64 = (sizeof(void *) > sizeof(int));
79
80 HMODULE kernel32_handle = 0;
81
82 const WCHAR *DIR_Windows = NULL;
83 const WCHAR *DIR_System = NULL;
84 const WCHAR *DIR_SysWow64 = NULL;
85
86 /* Process flags */
87 #define PDB32_DEBUGGED 0x0001 /* Process is being debugged */
88 #define PDB32_WIN16_PROC 0x0008 /* Win16 process */
89 #define PDB32_DOS_PROC 0x0010 /* Dos process */
90 #define PDB32_CONSOLE_PROC 0x0020 /* Console process */
91 #define PDB32_FILE_APIS_OEM 0x0040 /* File APIs are OEM */
92 #define PDB32_WIN32S_PROC 0x8000 /* Win32s process */
93
94 static const WCHAR exeW[] = {'.','e','x','e',0};
95 static const WCHAR comW[] = {'.','c','o','m',0};
96 static const WCHAR batW[] = {'.','b','a','t',0};
97 static const WCHAR cmdW[] = {'.','c','m','d',0};
98 static const WCHAR pifW[] = {'.','p','i','f',0};
99 static const WCHAR winevdmW[] = {'w','i','n','e','v','d','m','.','e','x','e',0};
100
101 static void exec_process( LPCWSTR name );
102
103 extern void SHELL_LoadRegistry(void);
104
105
106 /***********************************************************************
107 * contains_path
108 */
109 static inline int contains_path( LPCWSTR name )
110 {
111 return ((*name && (name[1] == ':')) || strchrW(name, '/') || strchrW(name, '\\'));
112 }
113
114
115 /***********************************************************************
116 * is_special_env_var
117 *
118 * Check if an environment variable needs to be handled specially when
119 * passed through the Unix environment (i.e. prefixed with "WINE").
120 */
121 static inline int is_special_env_var( const char *var )
122 {
123 return (!strncmp( var, "PATH=", sizeof("PATH=")-1 ) ||
124 !strncmp( var, "PWD=", sizeof("PWD=")-1 ) ||
125 !strncmp( var, "HOME=", sizeof("HOME=")-1 ) ||
126 !strncmp( var, "TEMP=", sizeof("TEMP=")-1 ) ||
127 !strncmp( var, "TMP=", sizeof("TMP=")-1 ));
128 }
129
130
131 /***********************************************************************
132 * is_path_prefix
133 */
134 static inline unsigned int is_path_prefix( const WCHAR *prefix, const WCHAR *filename )
135 {
136 unsigned int len = strlenW( prefix );
137
138 if (strncmpiW( filename, prefix, len ) || filename[len] != '\\') return 0;
139 while (filename[len] == '\\') len++;
140 return len;
141 }
142
143
144 /***************************************************************************
145 * get_builtin_path
146 *
147 * Get the path of a builtin module when the native file does not exist.
148 */
149 static BOOL get_builtin_path( const WCHAR *libname, const WCHAR *ext, WCHAR *filename,
150 UINT size, struct binary_info *binary_info )
151 {
152 WCHAR *file_part;
153 UINT len;
154 void *redir_disabled = 0;
155 unsigned int flags = (sizeof(void*) > sizeof(int) ? BINARY_FLAG_64BIT : 0);
156
157 /* builtin names cannot be empty or contain spaces */
158 if (!libname[0] || strchrW( libname, ' ' ) || strchrW( libname, '\t' )) return FALSE;
159
160 if (is_wow64 && Wow64DisableWow64FsRedirection( &redir_disabled ))
161 Wow64RevertWow64FsRedirection( redir_disabled );
162
163 if (contains_path( libname ))
164 {
165 if (RtlGetFullPathName_U( libname, size * sizeof(WCHAR),
166 filename, &file_part ) > size * sizeof(WCHAR))
167 return FALSE; /* too long */
168
169 if ((len = is_path_prefix( DIR_System, filename )))
170 {
171 if (is_wow64 && redir_disabled) flags = BINARY_FLAG_64BIT;
172 }
173 else if (DIR_SysWow64 && (len = is_path_prefix( DIR_SysWow64, filename )))
174 {
175 flags = 0;
176 }
177 else return FALSE;
178
179 if (filename + len != file_part) return FALSE;
180 }
181 else
182 {
183 len = strlenW( DIR_System );
184 if (strlenW(libname) + len + 2 >= size) return FALSE; /* too long */
185 memcpy( filename, DIR_System, len * sizeof(WCHAR) );
186 file_part = filename + len;
187 if (file_part > filename && file_part[-1] != '\\') *file_part++ = '\\';
188 strcpyW( file_part, libname );
189 if (is_wow64 && redir_disabled) flags = BINARY_FLAG_64BIT;
190 }
191 if (ext && !strchrW( file_part, '.' ))
192 {
193 if (file_part + strlenW(file_part) + strlenW(ext) + 1 > filename + size)
194 return FALSE; /* too long */
195 strcatW( file_part, ext );
196 }
197 binary_info->type = BINARY_UNIX_LIB;
198 binary_info->flags = flags;
199 binary_info->res_start = NULL;
200 binary_info->res_end = NULL;
201 return TRUE;
202 }
203
204
205 /***********************************************************************
206 * open_exe_file
207 *
208 * Open a specific exe file, taking load order into account.
209 * Returns the file handle or 0 for a builtin exe.
210 */
211 static HANDLE open_exe_file( const WCHAR *name, struct binary_info *binary_info )
212 {
213 HANDLE handle;
214
215 TRACE("looking for %s\n", debugstr_w(name) );
216
217 if ((handle = CreateFileW( name, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_DELETE,
218 NULL, OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE)
219 {
220 WCHAR buffer[MAX_PATH];
221 /* file doesn't exist, check for builtin */
222 if (contains_path( name ) && get_builtin_path( name, NULL, buffer, sizeof(buffer), binary_info ))
223 handle = 0;
224 }
225 else MODULE_get_binary_info( handle, binary_info );
226
227 return handle;
228 }
229
230
231 /***********************************************************************
232 * find_exe_file
233 *
234 * Open an exe file, and return the full name and file handle.
235 * Returns FALSE if file could not be found.
236 * If file exists but cannot be opened, returns TRUE and set handle to INVALID_HANDLE_VALUE.
237 * If file is a builtin exe, returns TRUE and sets handle to 0.
238 */
239 static BOOL find_exe_file( const WCHAR *name, WCHAR *buffer, int buflen,
240 HANDLE *handle, struct binary_info *binary_info )
241 {
242 TRACE("looking for %s\n", debugstr_w(name) );
243
244 if (!SearchPathW( NULL, name, exeW, buflen, buffer, NULL ))
245 {
246 if (contains_path( name ) && get_builtin_path( name, exeW, buffer, buflen, binary_info ))
247 {
248 *handle = 0;
249 return TRUE;
250 }
251 /* no builtin found, try native without extension in case it is a Unix app */
252 if (!SearchPathW( NULL, name, NULL, buflen, buffer, NULL )) return FALSE;
253 }
254
255 TRACE( "Trying native exe %s\n", debugstr_w(buffer) );
256 if ((*handle = CreateFileW( buffer, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_DELETE,
257 NULL, OPEN_EXISTING, 0, 0 )) != INVALID_HANDLE_VALUE)
258 {
259 MODULE_get_binary_info( *handle, binary_info );
260 return TRUE;
261 }
262 return FALSE;
263 }
264
265
266 /***********************************************************************
267 * build_initial_environment
268 *
269 * Build the Win32 environment from the Unix environment
270 */
271 static BOOL build_initial_environment(void)
272 {
273 SIZE_T size = 1;
274 char **e;
275 WCHAR *p, *endptr;
276 void *ptr;
277 char **env = __wine_get_main_environment();
278
279 /* Compute the total size of the Unix environment */
280 for (e = env; *e; e++)
281 {
282 if (is_special_env_var( *e )) continue;
283 size += MultiByteToWideChar( CP_UNIXCP, 0, *e, -1, NULL, 0 );
284 }
285 size *= sizeof(WCHAR);
286
287 /* Now allocate the environment */
288 ptr = NULL;
289 if (NtAllocateVirtualMemory(NtCurrentProcess(), &ptr, 0, &size,
290 MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE) != STATUS_SUCCESS)
291 return FALSE;
292
293 NtCurrentTeb()->Peb->ProcessParameters->Environment = p = ptr;
294 endptr = p + size / sizeof(WCHAR);
295
296 /* And fill it with the Unix environment */
297 for (e = env; *e; e++)
298 {
299 char *str = *e;
300
301 /* skip Unix special variables and use the Wine variants instead */
302 if (!strncmp( str, "WINE", 4 ))
303 {
304 if (is_special_env_var( str + 4 )) str += 4;
305 else if (!strncmp( str, "WINEPRELOADRESERVE=", 19 )) continue; /* skip it */
306 }
307 else if (is_special_env_var( str )) continue; /* skip it */
308
309 MultiByteToWideChar( CP_UNIXCP, 0, str, -1, p, endptr - p );
310 p += strlenW(p) + 1;
311 }
312 *p = 0;
313 return TRUE;
314 }
315
316
317 /***********************************************************************
318 * set_registry_variables
319 *
320 * Set environment variables by enumerating the values of a key;
321 * helper for set_registry_environment().
322 * Note that Windows happily truncates the value if it's too big.
323 */
324 static void set_registry_variables( HANDLE hkey, ULONG type )
325 {
326 static const WCHAR pathW[] = {'P','A','T','H'};
327 static const WCHAR sep[] = {';',0};
328 UNICODE_STRING env_name, env_value;
329 NTSTATUS status;
330 DWORD size;
331 int index;
332 char buffer[1024*sizeof(WCHAR) + sizeof(KEY_VALUE_FULL_INFORMATION)];
333 WCHAR tmpbuf[1024];
334 UNICODE_STRING tmp;
335 KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
336
337 tmp.Buffer = tmpbuf;
338 tmp.MaximumLength = sizeof(tmpbuf);
339
340 for (index = 0; ; index++)
341 {
342 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
343 buffer, sizeof(buffer), &size );
344 if (status != STATUS_SUCCESS && status != STATUS_BUFFER_OVERFLOW)
345 break;
346 if (info->Type != type)
347 continue;
348 env_name.Buffer = info->Name;
349 env_name.Length = env_name.MaximumLength = info->NameLength;
350 env_value.Buffer = (WCHAR *)(buffer + info->DataOffset);
351 env_value.Length = info->DataLength;
352 env_value.MaximumLength = sizeof(buffer) - info->DataOffset;
353 if (env_value.Length && !env_value.Buffer[env_value.Length/sizeof(WCHAR)-1])
354 env_value.Length -= sizeof(WCHAR); /* don't count terminating null if any */
355 if (!env_value.Length) continue;
356 if (info->Type == REG_EXPAND_SZ)
357 {
358 status = RtlExpandEnvironmentStrings_U( NULL, &env_value, &tmp, NULL );
359 if (status != STATUS_SUCCESS && status != STATUS_BUFFER_OVERFLOW) continue;
360 RtlCopyUnicodeString( &env_value, &tmp );
361 }
362 /* PATH is magic */
363 if (env_name.Length == sizeof(pathW) &&
364 !memicmpW( env_name.Buffer, pathW, sizeof(pathW)/sizeof(WCHAR) ) &&
365 !RtlQueryEnvironmentVariable_U( NULL, &env_name, &tmp ))
366 {
367 RtlAppendUnicodeToString( &tmp, sep );
368 if (RtlAppendUnicodeStringToString( &tmp, &env_value )) continue;
369 RtlCopyUnicodeString( &env_value, &tmp );
370 }
371 RtlSetEnvironmentVariable( NULL, &env_name, &env_value );
372 }
373 }
374
375
376 /***********************************************************************
377 * set_registry_environment
378 *
379 * Set the environment variables specified in the registry.
380 *
381 * Note: Windows handles REG_SZ and REG_EXPAND_SZ in one pass with the
382 * consequence that REG_EXPAND_SZ cannot be used reliably as it depends
383 * on the order in which the variables are processed. But on Windows it
384 * does not really matter since they only use %SystemDrive% and
385 * %SystemRoot% which are predefined. But Wine defines these in the
386 * registry, so we need two passes.
387 */
388 static BOOL set_registry_environment( BOOL volatile_only )
389 {
390 static const WCHAR env_keyW[] = {'M','a','c','h','i','n','e','\\',
391 'S','y','s','t','e','m','\\',
392 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
393 'C','o','n','t','r','o','l','\\',
394 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
395 'E','n','v','i','r','o','n','m','e','n','t',0};
396 static const WCHAR envW[] = {'E','n','v','i','r','o','n','m','e','n','t',0};
397 static const WCHAR volatile_envW[] = {'V','o','l','a','t','i','l','e',' ','E','n','v','i','r','o','n','m','e','n','t',0};
398
399 OBJECT_ATTRIBUTES attr;
400 UNICODE_STRING nameW;
401 HANDLE hkey;
402 BOOL ret = FALSE;
403
404 attr.Length = sizeof(attr);
405 attr.RootDirectory = 0;
406 attr.ObjectName = &nameW;
407 attr.Attributes = 0;
408 attr.SecurityDescriptor = NULL;
409 attr.SecurityQualityOfService = NULL;
410
411 /* first the system environment variables */
412 RtlInitUnicodeString( &nameW, env_keyW );
413 if (!volatile_only && NtOpenKey( &hkey, KEY_READ, &attr ) == STATUS_SUCCESS)
414 {
415 set_registry_variables( hkey, REG_SZ );
416 set_registry_variables( hkey, REG_EXPAND_SZ );
417 NtClose( hkey );
418 ret = TRUE;
419 }
420
421 /* then the ones for the current user */
422 if (RtlOpenCurrentUser( KEY_READ, &attr.RootDirectory ) != STATUS_SUCCESS) return ret;
423 RtlInitUnicodeString( &nameW, envW );
424 if (!volatile_only && NtOpenKey( &hkey, KEY_READ, &attr ) == STATUS_SUCCESS)
425 {
426 set_registry_variables( hkey, REG_SZ );
427 set_registry_variables( hkey, REG_EXPAND_SZ );
428 NtClose( hkey );
429 }
430
431 RtlInitUnicodeString( &nameW, volatile_envW );
432 if (NtOpenKey( &hkey, KEY_READ, &attr ) == STATUS_SUCCESS)
433 {
434 set_registry_variables( hkey, REG_SZ );
435 set_registry_variables( hkey, REG_EXPAND_SZ );
436 NtClose( hkey );
437 }
438
439 NtClose( attr.RootDirectory );
440 return ret;
441 }
442
443
444 /***********************************************************************
445 * get_reg_value
446 */
447 static WCHAR *get_reg_value( HKEY hkey, const WCHAR *name )
448 {
449 char buffer[1024 * sizeof(WCHAR) + sizeof(KEY_VALUE_PARTIAL_INFORMATION)];
450 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
451 DWORD len, size = sizeof(buffer);
452 WCHAR *ret = NULL;
453 UNICODE_STRING nameW;
454
455 RtlInitUnicodeString( &nameW, name );
456 if (NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, buffer, size, &size ))
457 return NULL;
458
459 if (size <= FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data )) return NULL;
460 len = (size - FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data )) / sizeof(WCHAR);
461
462 if (info->Type == REG_EXPAND_SZ)
463 {
464 UNICODE_STRING value, expanded;
465
466 value.MaximumLength = len * sizeof(WCHAR);
467 value.Buffer = (WCHAR *)info->Data;
468 if (!value.Buffer[len - 1]) len--; /* don't count terminating null if any */
469 value.Length = len * sizeof(WCHAR);
470 expanded.Length = expanded.MaximumLength = 1024 * sizeof(WCHAR);
471 if (!(expanded.Buffer = HeapAlloc( GetProcessHeap(), 0, expanded.MaximumLength ))) return NULL;
472 if (!RtlExpandEnvironmentStrings_U( NULL, &value, &expanded, NULL )) ret = expanded.Buffer;
473 else RtlFreeUnicodeString( &expanded );
474 }
475 else if (info->Type == REG_SZ)
476 {
477 if ((ret = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) )))
478 {
479 memcpy( ret, info->Data, len * sizeof(WCHAR) );
480 ret[len] = 0;
481 }
482 }
483 return ret;
484 }
485
486
487 /***********************************************************************
488 * set_additional_environment
489 *
490 * Set some additional environment variables not specified in the registry.
491 */
492 static void set_additional_environment(void)
493 {
494 static const WCHAR profile_keyW[] = {'M','a','c','h','i','n','e','\\',
495 'S','o','f','t','w','a','r','e','\\',
496 'M','i','c','r','o','s','o','f','t','\\',
497 'W','i','n','d','o','w','s',' ','N','T','\\',
498 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
499 'P','r','o','f','i','l','e','L','i','s','t',0};
500 static const WCHAR profiles_valueW[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
501 static const WCHAR all_users_valueW[] = {'A','l','l','U','s','e','r','s','P','r','o','f','i','l','e','\0'};
502 static const WCHAR allusersW[] = {'A','L','L','U','S','E','R','S','P','R','O','F','I','L','E',0};
503 OBJECT_ATTRIBUTES attr;
504 UNICODE_STRING nameW;
505 WCHAR *profile_dir = NULL, *all_users_dir = NULL;
506 HANDLE hkey;
507 DWORD len;
508
509 /* set the ALLUSERSPROFILE variables */
510
511 attr.Length = sizeof(attr);
512 attr.RootDirectory = 0;
513 attr.ObjectName = &nameW;
514 attr.Attributes = 0;
515 attr.SecurityDescriptor = NULL;
516 attr.SecurityQualityOfService = NULL;
517 RtlInitUnicodeString( &nameW, profile_keyW );
518 if (!NtOpenKey( &hkey, KEY_READ, &attr ))
519 {
520 profile_dir = get_reg_value( hkey, profiles_valueW );
521 all_users_dir = get_reg_value( hkey, all_users_valueW );
522 NtClose( hkey );
523 }
524
525 if (profile_dir && all_users_dir)
526 {
527 WCHAR *value, *p;
528
529 len = strlenW(profile_dir) + strlenW(all_users_dir) + 2;
530 value = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
531 strcpyW( value, profile_dir );
532 p = value + strlenW(value);
533 if (p > value && p[-1] != '\\') *p++ = '\\';
534 strcpyW( p, all_users_dir );
535 SetEnvironmentVariableW( allusersW, value );
536 HeapFree( GetProcessHeap(), 0, value );
537 }
538
539 HeapFree( GetProcessHeap(), 0, all_users_dir );
540 HeapFree( GetProcessHeap(), 0, profile_dir );
541 }
542
543 /***********************************************************************
544 * set_library_wargv
545 *
546 * Set the Wine library Unicode argv global variables.
547 */
548 static void set_library_wargv( char **argv )
549 {
550 int argc;
551 char *q;
552 WCHAR *p;
553 WCHAR **wargv;
554 DWORD total = 0;
555
556 for (argc = 0; argv[argc]; argc++)
557 total += MultiByteToWideChar( CP_UNIXCP, 0, argv[argc], -1, NULL, 0 );
558
559 wargv = RtlAllocateHeap( GetProcessHeap(), 0,
560 total * sizeof(WCHAR) + (argc + 1) * sizeof(*wargv) );
561 p = (WCHAR *)(wargv + argc + 1);
562 for (argc = 0; argv[argc]; argc++)
563 {
564 DWORD reslen = MultiByteToWideChar( CP_UNIXCP, 0, argv[argc], -1, p, total );
565 wargv[argc] = p;
566 p += reslen;
567 total -= reslen;
568 }
569 wargv[argc] = NULL;
570
571 /* convert argv back from Unicode since it has to be in the Ansi codepage not the Unix one */
572
573 for (argc = 0; wargv[argc]; argc++)
574 total += WideCharToMultiByte( CP_ACP, 0, wargv[argc], -1, NULL, 0, NULL, NULL );
575
576 argv = RtlAllocateHeap( GetProcessHeap(), 0, total + (argc + 1) * sizeof(*argv) );
577 q = (char *)(argv + argc + 1);
578 for (argc = 0; wargv[argc]; argc++)
579 {
580 DWORD reslen = WideCharToMultiByte( CP_ACP, 0, wargv[argc], -1, q, total, NULL, NULL );
581 argv[argc] = q;
582 q += reslen;
583 total -= reslen;
584 }
585 argv[argc] = NULL;
586
587 __wine_main_argc = argc;
588 __wine_main_argv = argv;
589 __wine_main_wargv = wargv;
590 }
591
592
593 /***********************************************************************
594 * update_library_argv0
595 *
596 * Update the argv[0] global variable with the binary we have found.
597 */
598 static void update_library_argv0( const WCHAR *argv0 )
599 {
600 DWORD len = strlenW( argv0 );
601
602 if (len > strlenW( __wine_main_wargv[0] ))
603 {
604 __wine_main_wargv[0] = RtlAllocateHeap( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
605 }
606 strcpyW( __wine_main_wargv[0], argv0 );
607
608 len = WideCharToMultiByte( CP_ACP, 0, argv0, -1, NULL, 0, NULL, NULL );
609 if (len > strlen( __wine_main_argv[0] ) + 1)
610 {
611 __wine_main_argv[0] = RtlAllocateHeap( GetProcessHeap(), 0, len );
612 }
613 WideCharToMultiByte( CP_ACP, 0, argv0, -1, __wine_main_argv[0], len, NULL, NULL );
614 }
615
616
617 /***********************************************************************
618 * build_command_line
619 *
620 * Build the command line of a process from the argv array.
621 *
622 * Note that it does NOT necessarily include the file name.
623 * Sometimes we don't even have any command line options at all.
624 *
625 * We must quote and escape characters so that the argv array can be rebuilt
626 * from the command line:
627 * - spaces and tabs must be quoted
628 * 'a b' -> '"a b"'
629 * - quotes must be escaped
630 * '"' -> '\"'
631 * - if '\'s are followed by a '"', they must be doubled and followed by '\"',
632 * resulting in an odd number of '\' followed by a '"'
633 * '\"' -> '\\\"'
634 * '\\"' -> '\\\\\"'
635 * - '\'s that are not followed by a '"' can be left as is
636 * 'a\b' == 'a\b'
637 * 'a\\b' == 'a\\b'
638 */
639 static BOOL build_command_line( WCHAR **argv )
640 {
641 int len;
642 WCHAR **arg;
643 LPWSTR p;
644 RTL_USER_PROCESS_PARAMETERS* rupp = NtCurrentTeb()->Peb->ProcessParameters;
645
646 if (rupp->CommandLine.Buffer) return TRUE; /* already got it from the server */
647
648 len = 0;
649 for (arg = argv; *arg; arg++)
650 {
651 int has_space,bcount;
652 WCHAR* a;
653
654 has_space=0;
655 bcount=0;
656 a=*arg;
657 if( !*a ) has_space=1;
658 while (*a!='\0') {
659 if (*a=='\\') {
660 bcount++;
661 } else {
662 if (*a==' ' || *a=='\t') {
663 has_space=1;
664 } else if (*a=='"') {
665 /* doubling of '\' preceding a '"',
666 * plus escaping of said '"'
667 */
668 len+=2*bcount+1;
669 }
670 bcount=0;
671 }
672 a++;
673 }
674 len+=(a-*arg)+1 /* for the separating space */;
675 if (has_space)
676 len+=2; /* for the quotes */
677 }
678
679 if (!(rupp->CommandLine.Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR))))
680 return FALSE;
681
682 p = rupp->CommandLine.Buffer;
683 rupp->CommandLine.Length = (len - 1) * sizeof(WCHAR);
684 rupp->CommandLine.MaximumLength = len * sizeof(WCHAR);
685 for (arg = argv; *arg; arg++)
686 {
687 int has_space,has_quote;
688 WCHAR* a;
689
690 /* Check for quotes and spaces in this argument */
691 has_space=has_quote=0;
692 a=*arg;
693 if( !*a ) has_space=1;
694 while (*a!='\0') {
695 if (*a==' ' || *a=='\t') {
696 has_space=1;
697 if (has_quote)
698 break;
699 } else if (*a=='"') {
700 has_quote=1;
701 if (has_space)
702 break;
703 }
704 a++;
705 }
706
707 /* Now transfer it to the command line */
708 if (has_space)
709 *p++='"';
710 if (has_quote) {
711 int bcount;
712 WCHAR* a;
713
714 bcount=0;
715 a=*arg;
716 while (*a!='\0') {
717 if (*a=='\\') {
718 *p++=*a;
719 bcount++;
720 } else {
721 if (*a=='"') {
722 int i;
723
724 /* Double all the '\\' preceding this '"', plus one */
725 for (i=0;i<=bcount;i++)
726 *p++='\\';
727 *p++='"';
728 } else {
729 *p++=*a;
730 }
731 bcount=0;
732 }
733 a++;
734 }
735 } else {
736 WCHAR* x = *arg;
737 while ((*p=*x++)) p++;
738 }
739 if (has_space)
740 *p++='"';
741 *p++=' ';
742 }
743 if (p > rupp->CommandLine.Buffer)
744 p--; /* remove last space */
745 *p = '\0';
746
747 return TRUE;
748 }
749
750
751 /***********************************************************************
752 * init_current_directory
753 *
754 * Initialize the current directory from the Unix cwd or the parent info.
755 */
756 static void init_current_directory( CURDIR *cur_dir )
757 {
758 UNICODE_STRING dir_str;
759 const char *pwd;
760 char *cwd;
761 int size;
762
763 /* if we received a cur dir from the parent, try this first */
764
765 if (cur_dir->DosPath.Length)
766 {
767 if (RtlSetCurrentDirectory_U( &cur_dir->DosPath ) == STATUS_SUCCESS) goto done;
768 }
769
770 /* now try to get it from the Unix cwd */
771
772 for (size = 256; ; size *= 2)
773 {
774 if (!(cwd = HeapAlloc( GetProcessHeap(), 0, size ))) break;
775 if (getcwd( cwd, size )) break;
776 HeapFree( GetProcessHeap(), 0, cwd );
777 if (errno == ERANGE) continue;
778 cwd = NULL;
779 break;
780 }
781
782 /* try to use PWD if it is valid, so that we don't resolve symlinks */
783
784 pwd = getenv( "PWD" );
785 if (cwd)
786 {
787 struct stat st1, st2;
788
789 if (!pwd || stat( pwd, &st1 ) == -1 ||
790 (!stat( cwd, &st2 ) && (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino)))
791 pwd = cwd;
792 }
793
794 if (pwd)
795 {
796 ANSI_STRING unix_name;
797 UNICODE_STRING nt_name;
798 RtlInitAnsiString( &unix_name, pwd );
799 if (!wine_unix_to_nt_file_name( &unix_name, &nt_name ))
800 {
801 UNICODE_STRING dos_path;
802 /* skip the \??\ prefix, nt_name is 0 terminated */
803 RtlInitUnicodeString( &dos_path, nt_name.Buffer + 4 );
804 RtlSetCurrentDirectory_U( &dos_path );
805 RtlFreeUnicodeString( &nt_name );
806 }
807 }
808
809 if (!cur_dir->DosPath.Length) /* still not initialized */
810 {
811 MESSAGE("Warning: could not find DOS drive for current working directory '%s', "
812 "starting in the Windows directory.\n", cwd ? cwd : "" );
813 RtlInitUnicodeString( &dir_str, DIR_Windows );
814 RtlSetCurrentDirectory_U( &dir_str );
815 }
816 HeapFree( GetProcessHeap(), 0, cwd );
817
818 done:
819 if (!cur_dir->Handle) chdir("/"); /* change to root directory so as not to lock cdroms */
820 TRACE( "starting in %s %p\n", debugstr_w( cur_dir->DosPath.Buffer ), cur_dir->Handle );
821 }
822
823
824 /***********************************************************************
825 * init_windows_dirs
826 *
827 * Initialize the windows and system directories from the environment.
828 */
829 static void init_windows_dirs(void)
830 {
831 extern void CDECL __wine_init_windows_dir( const WCHAR *windir, const WCHAR *sysdir );
832
833 static const WCHAR windirW[] = {'w','i','n','d','i','r',0};
834 static const WCHAR winsysdirW[] = {'w','i','n','s','y','s','d','i','r',0};
835 static const WCHAR default_windirW[] = {'C',':','\\','w','i','n','d','o','w','s',0};
836 static const WCHAR default_sysdirW[] = {'\\','s','y','s','t','e','m','3','2',0};
837 static const WCHAR default_syswow64W[] = {'\\','s','y','s','w','o','w','6','4',0};
838
839 DWORD len;
840 WCHAR *buffer;
841
842 if ((len = GetEnvironmentVariableW( windirW, NULL, 0 )))
843 {
844 buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
845 GetEnvironmentVariableW( windirW, buffer, len );
846 DIR_Windows = buffer;
847 }
848 else DIR_Windows = default_windirW;
849
850 if ((len = GetEnvironmentVariableW( winsysdirW, NULL, 0 )))
851 {
852 buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
853 GetEnvironmentVariableW( winsysdirW, buffer, len );
854 DIR_System = buffer;
855 }
856 else
857 {
858 len = strlenW( DIR_Windows );
859 buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) + sizeof(default_sysdirW) );
860 memcpy( buffer, DIR_Windows, len * sizeof(WCHAR) );
861 memcpy( buffer + len, default_sysdirW, sizeof(default_sysdirW) );
862 DIR_System = buffer;
863 }
864
865 if (!CreateDirectoryW( DIR_Windows, NULL ) && GetLastError() != ERROR_ALREADY_EXISTS)
866 ERR( "directory %s could not be created, error %u\n",
867 debugstr_w(DIR_Windows), GetLastError() );
868 if (!CreateDirectoryW( DIR_System, NULL ) && GetLastError() != ERROR_ALREADY_EXISTS)
869 ERR( "directory %s could not be created, error %u\n",
870 debugstr_w(DIR_System), GetLastError() );
871
872 if (is_win64 || is_wow64) /* SysWow64 is always defined on 64-bit */
873 {
874 len = strlenW( DIR_Windows );
875 buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) + sizeof(default_syswow64W) );
876 memcpy( buffer, DIR_Windows, len * sizeof(WCHAR) );
877 memcpy( buffer + len, default_syswow64W, sizeof(default_syswow64W) );
878 DIR_SysWow64 = buffer;
879 if (!CreateDirectoryW( DIR_SysWow64, NULL ) && GetLastError() != ERROR_ALREADY_EXISTS)
880 ERR( "directory %s could not be created, error %u\n",
881 debugstr_w(DIR_SysWow64), GetLastError() );
882 }
883
884 TRACE_(file)( "WindowsDir = %s\n", debugstr_w(DIR_Windows) );
885 TRACE_(file)( "SystemDir = %s\n", debugstr_w(DIR_System) );
886
887 /* set the directories in ntdll too */
888 __wine_init_windows_dir( DIR_Windows, DIR_System );
889 }
890
891
892 /***********************************************************************
893 * start_wineboot
894 *
895 * Start the wineboot process if necessary. Return the handles to wait on.
896 */
897 static void start_wineboot( HANDLE handles[2] )
898 {
899 static const WCHAR wineboot_eventW[] = {'_','_','w','i','n','e','b','o','o','t','_','e','v','e','n','t',0};
900
901 handles[1] = 0;
902 if (!(handles[0] = CreateEventW( NULL, TRUE, FALSE, wineboot_eventW )))
903 {
904 ERR( "failed to create wineboot event, expect trouble\n" );
905 return;
906 }
907 if (GetLastError() != ERROR_ALREADY_EXISTS) /* we created it */
908 {
909 static const WCHAR wineboot[] = {'\\','w','i','n','e','b','o','o','t','.','e','x','e',0};
910 static const WCHAR args[] = {' ','-','-','i','n','i','t',0};
911 STARTUPINFOW si;
912 PROCESS_INFORMATION pi;
913 void *redir;
914 WCHAR app[MAX_PATH];
915 WCHAR cmdline[MAX_PATH + (sizeof(wineboot) + sizeof(args)) / sizeof(WCHAR)];
916
917 memset( &si, 0, sizeof(si) );
918 si.cb = sizeof(si);
919 si.dwFlags = STARTF_USESTDHANDLES;
920 si.hStdInput = 0;
921 si.hStdOutput = 0;
922 si.hStdError = GetStdHandle( STD_ERROR_HANDLE );
923
924 GetSystemDirectoryW( app, MAX_PATH - sizeof(wineboot)/sizeof(WCHAR) );
925 lstrcatW( app, wineboot );
926
927 Wow64DisableWow64FsRedirection( &redir );
928 strcpyW( cmdline, app );
929 strcatW( cmdline, args );
930 if (CreateProcessW( app, cmdline, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &si, &pi ))
931 {
932 TRACE( "started wineboot pid %04x tid %04x\n", pi.dwProcessId, pi.dwThreadId );
933 CloseHandle( pi.hThread );
934 handles[1] = pi.hProcess;
935 }
936 else
937 {
938 ERR( "failed to start wineboot, err %u\n", GetLastError() );
939 CloseHandle( handles[0] );
940 handles[0] = 0;
941 }
942 Wow64RevertWow64FsRedirection( redir );
943 }
944 }
945
946
947 /***********************************************************************
948 * start_process
949 *
950 * Startup routine of a new process. Runs on the new process stack.
951 */
952 static DWORD WINAPI start_process( PEB *peb )
953 {
954 IMAGE_NT_HEADERS *nt;
955 LPTHREAD_START_ROUTINE entry;
956
957 nt = RtlImageNtHeader( peb->ImageBaseAddress );
958 entry = (LPTHREAD_START_ROUTINE)((char *)peb->ImageBaseAddress +
959 nt->OptionalHeader.AddressOfEntryPoint);
960
961 if (!nt->OptionalHeader.AddressOfEntryPoint)
962 {
963 ERR( "%s doesn't have an entry point, it cannot be executed\n",
964 debugstr_w(peb->ProcessParameters->ImagePathName.Buffer) );
965 ExitThread( 1 );
966 }
967
968 if (TRACE_ON(relay))
969 DPRINTF( "%04x:Starting process %s (entryproc=%p)\n", GetCurrentThreadId(),
970 debugstr_w(peb->ProcessParameters->ImagePathName.Buffer), entry );
971
972 SetLastError( 0 ); /* clear error code */
973 if (peb->BeingDebugged) DbgBreakPoint();
974 return entry( peb );
975 }
976
977
978 /***********************************************************************
979 * set_process_name
980 *
981 * Change the process name in the ps output.
982 */
983 static void set_process_name( int argc, char *argv[] )
984 {
985 #ifdef HAVE_SETPROCTITLE
986 setproctitle("-%s", argv[1]);
987 #endif
988
989 #ifdef HAVE_PRCTL
990 int i, offset;
991 char *p, *prctl_name = argv[1];
992 char *end = argv[argc-1] + strlen(argv[argc-1]) + 1;
993
994 #ifndef PR_SET_NAME
995 # define PR_SET_NAME 15
996 #endif
997
998 if ((p = strrchr( prctl_name, '\\' ))) prctl_name = p + 1;
999 if ((p = strrchr( prctl_name, '/' ))) prctl_name = p + 1;
1000
1001 if (prctl( PR_SET_NAME, prctl_name ) != -1)
1002 {
1003 offset = argv[1] - argv[0];
1004 memmove( argv[1] - offset, argv[1], end - argv[1] );
1005 memset( end - offset, 0, offset );
1006 for (i = 1; i < argc; i++) argv[i-1] = argv[i] - offset;
1007 argv[i-1] = NULL;
1008 }
1009 else
1010 #endif /* HAVE_PRCTL */
1011 {
1012 /* remove argv[0] */
1013 memmove( argv, argv + 1, argc * sizeof(argv[0]) );
1014 }
1015 }
1016
1017
1018 /***********************************************************************
1019 * __wine_kernel_init
1020 *
1021 * Wine initialisation: load and start the main exe file.
1022 */
1023 void CDECL __wine_kernel_init(void)
1024 {
1025 static const WCHAR kernel32W[] = {'k','e','r','n','e','l','3','2',0};
1026 static const WCHAR dotW[] = {'.',0};
1027
1028 WCHAR *p, main_exe_name[MAX_PATH+1];
1029 PEB *peb = NtCurrentTeb()->Peb;
1030 RTL_USER_PROCESS_PARAMETERS *params = peb->ProcessParameters;
1031 HANDLE boot_events[2];
1032 BOOL got_environment = TRUE;
1033
1034 /* Initialize everything */
1035
1036 setbuf(stdout,NULL);
1037 setbuf(stderr,NULL);
1038 kernel32_handle = GetModuleHandleW(kernel32W);
1039 IsWow64Process( GetCurrentProcess(), &is_wow64 );
1040
1041 LOCALE_Init();
1042
1043 if (!params->Environment)
1044 {
1045 /* Copy the parent environment */
1046 if (!build_initial_environment()) exit(1);
1047
1048 /* convert old configuration to new format */
1049 convert_old_config();
1050
1051 got_environment = set_registry_environment( FALSE );
1052 set_additional_environment();
1053 }
1054
1055 init_windows_dirs();
1056 init_current_directory( &params->CurrentDirectory );
1057
1058 set_process_name( __wine_main_argc, __wine_main_argv );
1059 set_library_wargv( __wine_main_argv );
1060 boot_events[0] = boot_events[1] = 0;
1061
1062 if (peb->ProcessParameters->ImagePathName.Buffer)
1063 {
1064 strcpyW( main_exe_name, peb->ProcessParameters->ImagePathName.Buffer );
1065 }
1066 else
1067 {
1068 struct binary_info binary_info;
1069
1070 if (!SearchPathW( NULL, __wine_main_wargv[0], exeW, MAX_PATH, main_exe_name, NULL ) &&
1071 !get_builtin_path( __wine_main_wargv[0], exeW, main_exe_name, MAX_PATH, &binary_info ))
1072 {
1073 MESSAGE( "wine: cannot find '%s'\n", __wine_main_argv[0] );
1074 ExitProcess( GetLastError() );
1075 }
1076 update_library_argv0( main_exe_name );
1077 if (!build_command_line( __wine_main_wargv )) goto error;
1078 start_wineboot( boot_events );
1079 }
1080
1081 /* if there's no extension, append a dot to prevent LoadLibrary from appending .dll */
1082 p = strrchrW( main_exe_name, '.' );
1083 if (!p || strchrW( p, '/' ) || strchrW( p, '\\' )) strcatW( main_exe_name, dotW );
1084
1085 TRACE( "starting process name=%s argv[0]=%s\n",
1086 debugstr_w(main_exe_name), debugstr_w(__wine_main_wargv[0]) );
1087
1088 RtlInitUnicodeString( &NtCurrentTeb()->Peb->ProcessParameters->DllPath,
1089 MODULE_get_dll_load_path(main_exe_name) );
1090
1091 if (boot_events[0])
1092 {
1093 DWORD timeout = 2 * 60 * 1000, count = 1;
1094
1095 if (boot_events[1]) count++;
1096 if (!got_environment) timeout = 5 * 60 * 1000; /* initial prefix creation can take longer */
1097 if (WaitForMultipleObjects( count, boot_events, FALSE, timeout ) == WAIT_TIMEOUT)
1098 ERR( "boot event wait timed out\n" );
1099 CloseHandle( boot_events[0] );
1100 if (boot_events[1]) CloseHandle( boot_events[1] );
1101 /* reload environment now that wineboot has run */
1102 set_registry_environment( got_environment );
1103 set_additional_environment();
1104 }
1105
1106 if (!(peb->ImageBaseAddress = LoadLibraryExW( main_exe_name, 0, DONT_RESOLVE_DLL_REFERENCES )))
1107 {
1108 DWORD_PTR args[1];
1109 WCHAR msgW[1024];
1110 char msg[1024];
1111 DWORD error = GetLastError();
1112
1113 /* if Win16/DOS format, or unavailable address, exec a new process with the proper setup */
1114 if (error == ERROR_BAD_EXE_FORMAT ||
1115 error == ERROR_INVALID_ADDRESS ||
1116 error == ERROR_NOT_ENOUGH_MEMORY)
1117 {
1118 if (!getenv("WINEPRELOADRESERVE")) exec_process( main_exe_name );
1119 /* if we get back here, it failed */
1120 }
1121 else if (error == ERROR_MOD_NOT_FOUND)
1122 {
1123 if ((p = strrchrW( main_exe_name, '\\' ))) p++;
1124 else p = main_exe_name;
1125 if (!strcmpiW( p, winevdmW ) && __wine_main_argc > 3)
1126 {
1127 /* args 1 and 2 are --app-name full_path */
1128 MESSAGE( "wine: could not run %s: 16-bit/DOS support missing\n",
1129 debugstr_w(__wine_main_wargv[3]) );
1130 ExitProcess( ERROR_BAD_EXE_FORMAT );
1131 }
1132 MESSAGE( "wine: cannot find %s\n", debugstr_w(main_exe_name) );
1133 ExitProcess( ERROR_FILE_NOT_FOUND );
1134 }
1135 args[0] = (DWORD_PTR)main_exe_name;
1136 FormatMessageW( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY,
1137 NULL, error, 0, msgW, sizeof(msgW)/sizeof(WCHAR), (__ms_va_list *)args );
1138 WideCharToMultiByte( CP_ACP, 0, msgW, -1, msg, sizeof(msg), NULL, NULL );
1139 MESSAGE( "wine: %s", msg );
1140 ExitProcess( error );
1141 }
1142
1143 LdrInitializeThunk( start_process, 0, 0, 0 );
1144
1145 error:
1146 ExitProcess( GetLastError() );
1147 }
1148
1149
1150 /***********************************************************************
1151 * build_argv
1152 *
1153 * Build an argv array from a command-line.
1154 * 'reserved' is the number of args to reserve before the first one.
1155 */
1156 static char **build_argv( const WCHAR *cmdlineW, int reserved )
1157 {
1158 int argc;
1159 char** argv;
1160 char *arg,*s,*d,*cmdline;
1161 int in_quotes,bcount,len;
1162
1163 len = WideCharToMultiByte( CP_UNIXCP, 0, cmdlineW, -1, NULL, 0, NULL, NULL );
1164 if (!(cmdline = HeapAlloc( GetProcessHeap(), 0, len ))) return NULL;
1165 WideCharToMultiByte( CP_UNIXCP, 0, cmdlineW, -1, cmdline, len, NULL, NULL );
1166
1167 argc=reserved+1;
1168 bcount=0;
1169 in_quotes=0;
1170 s=cmdline;
1171 while (1) {
1172 if (*s=='\0' || ((*s==' ' || *s=='\t') && !in_quotes)) {
1173 /* space */
1174 argc++;
1175 /* skip the remaining spaces */
1176 while (*s==' ' || *s=='\t') {
1177 s++;
1178 }
1179 if (*s=='\0')
1180 break;
1181 bcount=0;
1182 continue;
1183 } else if (*s=='\\') {
1184 /* '\', count them */
1185 bcount++;
1186 } else if ((*s=='"') && ((bcount & 1)==0)) {
1187 /* unescaped '"' */
1188 in_quotes=!in_quotes;
1189 bcount=0;
1190 } else {
1191 /* a regular character */
1192 bcount=0;
1193 }
1194 s++;
1195 }
1196 if (!(argv = HeapAlloc( GetProcessHeap(), 0, argc*sizeof(*argv) + len )))
1197 {
1198 HeapFree( GetProcessHeap(), 0, cmdline );
1199 return NULL;
1200 }
1201
1202 arg = d = s = (char *)(argv + argc);
1203 memcpy( d, cmdline, len );
1204 bcount=0;
1205 in_quotes=0;
1206 argc=reserved;
1207 while (*s) {
1208 if ((*s==' ' || *s=='\t') && !in_quotes) {
1209 /* Close the argument and copy it */
1210 *d=0;
1211 argv[argc++]=arg;
1212
1213 /* skip the remaining spaces */
1214 do {
1215 s++;
1216 } while (*s==' ' || *s=='\t');
1217
1218 /* Start with a new argument */
1219 arg=d=s;
1220 bcount=0;
1221 } else if (*s=='\\') {
1222 /* '\\' */
1223 *d++=*s++;
1224 bcount++;
1225 } else if (*s=='"') {
1226 /* '"' */
1227 if ((bcount & 1)==0) {
1228 /* Preceded by an even number of '\', this is half that
1229 * number of '\', plus a '"' which we discard.
1230 */
1231 d-=bcount/2;
1232 s++;
1233 in_quotes=!in_quotes;
1234 } else {
1235 /* Preceded by an odd number of '\', this is half that
1236 * number of '\' followed by a '"'
1237 */
1238 d=d-bcount/2-1;
1239 *d++='"';
1240 s++;
1241 }
1242 bcount=0;
1243 } else {
1244 /* a regular character */
1245 *d++=*s++;
1246 bcount=0;
1247 }
1248 }
1249 if (*arg) {
1250 *d='\0';
1251 argv[argc++]=arg;
1252 }
1253 argv[argc]=NULL;
1254
1255 HeapFree( GetProcessHeap(), 0, cmdline );
1256 return argv;
1257 }
1258
1259
1260 /***********************************************************************
1261 * build_envp
1262 *
1263 * Build the environment of a new child process.
1264 */
1265 static char **build_envp( const WCHAR *envW )
1266 {
1267 static const char * const unix_vars[] = { "PATH", "TEMP", "TMP", "HOME" };
1268
1269 const WCHAR *end;
1270 char **envp;
1271 char *env, *p;
1272 int count = 1, length;
1273 unsigned int i;
1274
1275 for (end = envW; *end; count++) end += strlenW(end) + 1;
1276 end++;
1277 length = WideCharToMultiByte( CP_UNIXCP, 0, envW, end - envW, NULL, 0, NULL, NULL );
1278 if (!(env = HeapAlloc( GetProcessHeap(), 0, length ))) return NULL;
1279 WideCharToMultiByte( CP_UNIXCP, 0, envW, end - envW, env, length, NULL, NULL );
1280
1281 for (p = env; *p; p += strlen(p) + 1)
1282 if (is_special_env_var( p )) length += 4; /* prefix it with "WINE" */
1283
1284 for (i = 0; i < sizeof(unix_vars)/sizeof(unix_vars[0]); i++)
1285 {
1286 if (!(p = getenv(unix_vars[i]))) continue;
1287 length += strlen(unix_vars[i]) + strlen(p) + 2;
1288 count++;
1289 }
1290
1291 if ((envp = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*envp) + length )))
1292 {
1293 char **envptr = envp;
1294 char *dst = (char *)(envp + count);
1295
1296 /* some variables must not be modified, so we get them directly from the unix env */
1297 for (i = 0; i < sizeof(unix_vars)/sizeof(unix_vars[0]); i++)
1298 {
1299 if (!(p = getenv(unix_vars[i]))) continue;
1300 *envptr++ = strcpy( dst, unix_vars[i] );
1301 strcat( dst, "=" );
1302 strcat( dst, p );
1303 dst += strlen(dst) + 1;
1304 }
1305
1306 /* now put the Windows environment strings */
1307 for (p = env; *p; p += strlen(p) + 1)
1308 {
1309 if (*p == '=') continue; /* skip drive curdirs, this crashes some unix apps */
1310 if (!strncmp( p, "WINEPRELOADRESERVE=", sizeof("WINEPRELOADRESERVE=")-1 )) continue;
1311 if (!strncmp( p, "WINELOADERNOEXEC=", sizeof("WINELOADERNOEXEC=")-1 )) continue;
1312 if (!strncmp( p, "WINESERVERSOCKET=", sizeof("WINESERVERSOCKET=")-1 )) continue;
1313 if (is_special_env_var( p )) /* prefix it with "WINE" */
1314 {
1315 *envptr++ = strcpy( dst, "WINE" );
1316 strcat( dst, p );
1317 }
1318 else
1319 {
1320 *envptr++ = strcpy( dst, p );
1321 }
1322 dst += strlen(dst) + 1;
1323 }
1324 *envptr = 0;
1325 }
1326 HeapFree( GetProcessHeap(), 0, env );
1327 return envp;
1328 }
1329
1330
1331 /***********************************************************************
1332 * fork_and_exec
1333 *
1334 * Fork and exec a new Unix binary, checking for errors.
1335 */
1336 static int fork_and_exec( const char *filename, const WCHAR *cmdline, const WCHAR *env,
1337 const char *newdir, DWORD flags, STARTUPINFOW *startup )
1338 {
1339 int fd[2], stdin_fd = -1, stdout_fd = -1;
1340 int pid, err;
1341 char **argv, **envp;
1342
1343 if (!env) env = GetEnvironmentStringsW();
1344
1345 #ifdef HAVE_PIPE2
1346 if (pipe2( fd, O_CLOEXEC ) == -1)
1347 #endif
1348 {
1349 if (pipe(fd) == -1)
1350 {
1351 SetLastError( ERROR_TOO_MANY_OPEN_FILES );
1352 return -1;
1353 }
1354 fcntl( fd[0], F_SETFD, FD_CLOEXEC );
1355 fcntl( fd[1], F_SETFD, FD_CLOEXEC );
1356 }
1357
1358 if (!(flags & (CREATE_NEW_PROCESS_GROUP | CREATE_NEW_CONSOLE | DETACHED_PROCESS)))
1359 {
1360 HANDLE hstdin, hstdout;
1361
1362 if (startup->dwFlags & STARTF_USESTDHANDLES)
1363 {
1364 hstdin = startup->hStdInput;
1365 hstdout = startup->hStdOutput;
1366 }
1367 else
1368 {
1369 hstdin = GetStdHandle(STD_INPUT_HANDLE);
1370 hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
1371 }
1372
1373 if (is_console_handle( hstdin ))
1374 hstdin = wine_server_ptr_handle( console_handle_unmap( hstdin ));
1375 if (is_console_handle( hstdout ))
1376 hstdout = wine_server_ptr_handle( console_handle_unmap( hstdout ));
1377 wine_server_handle_to_fd( hstdin, FILE_READ_DATA, &stdin_fd, NULL );
1378 wine_server_handle_to_fd( hstdout, FILE_WRITE_DATA, &stdout_fd, NULL );
1379 }
1380
1381 argv = build_argv( cmdline, 0 );
1382 envp = build_envp( env );
1383
1384 if (!(pid = fork())) /* child */
1385 {
1386 close( fd[0] );
1387
1388 if (flags & (CREATE_NEW_PROCESS_GROUP | CREATE_NEW_CONSOLE | DETACHED_PROCESS))
1389 {
1390 int pid;
1391 if (!(pid = fork()))
1392 {
1393 int fd = open( "/dev/null", O_RDWR );
1394 setsid();
1395 /* close stdin and stdout */
1396 if (fd != -1)
1397 {
1398 dup2( fd, 0 );
1399 dup2( fd, 1 );
1400 close( fd );
1401 }
1402 }
1403 else if (pid != -1) _exit(0); /* parent */
1404 }
1405 else
1406 {
1407 if (stdin_fd != -1)
1408 {
1409 dup2( stdin_fd, 0 );
1410 close( stdin_fd );
1411 }
1412 if (stdout_fd != -1)
1413 {
1414 dup2( stdout_fd, 1 );
1415 close( stdout_fd );
1416 }
1417 }
1418
1419 /* Reset signals that we previously set to SIG_IGN */
1420 signal( SIGPIPE, SIG_DFL );
1421 signal( SIGCHLD, SIG_DFL );
1422
1423 if (newdir) chdir(newdir);
1424
1425 if (argv && envp) execve( filename, argv, envp );
1426 err = errno;
1427 write( fd[1], &err, sizeof(err) );
1428 _exit(1);
1429 }
1430 HeapFree( GetProcessHeap(), 0, argv );
1431 HeapFree( GetProcessHeap(), 0, envp );
1432 if (stdin_fd != -1) close( stdin_fd );
1433 if (stdout_fd != -1) close( stdout_fd );
1434 close( fd[1] );
1435 if ((pid != -1) && (read( fd[0], &err, sizeof(err) ) > 0)) /* exec failed */
1436 {
1437 errno = err;
1438 pid = -1;
1439 }
1440 if (pid == -1) FILE_SetDosError();
1441 close( fd[0] );
1442 return pid;
1443 }
1444
1445
1446 static inline DWORD append_string( void **ptr, const WCHAR *str )
1447 {
1448 DWORD len = strlenW( str );
1449 memcpy( *ptr, str, len * sizeof(WCHAR) );
1450 *ptr = (WCHAR *)*ptr + len;
1451 return len * sizeof(WCHAR);
1452 }
1453
1454 /***********************************************************************
1455 * create_startup_info
1456 */
1457 static startup_info_t *create_startup_info( LPCWSTR filename, LPCWSTR cmdline,
1458 LPCWSTR cur_dir, LPWSTR env, DWORD flags,
1459 const STARTUPINFOW *startup, DWORD *info_size )
1460 {
1461 const RTL_USER_PROCESS_PARAMETERS *cur_params;
1462 startup_info_t *info;
1463 DWORD size;
1464 void *ptr;
1465 UNICODE_STRING newdir;
1466 WCHAR imagepath[MAX_PATH];
1467 HANDLE hstdin, hstdout, hstderr;
1468
1469 if(!GetLongPathNameW( filename, imagepath, MAX_PATH ))
1470 lstrcpynW( imagepath, filename, MAX_PATH );
1471 if(!GetFullPathNameW( imagepath, MAX_PATH, imagepath, NULL ))
1472 lstrcpynW( imagepath, filename, MAX_PATH );
1473
1474 cur_params = NtCurrentTeb()->Peb->ProcessParameters;
1475
1476 newdir.Buffer = NULL;
1477 if (cur_dir)
1478 {
1479 if (RtlDosPathNameToNtPathName_U( cur_dir, &newdir, NULL, NULL ))
1480 cur_dir = newdir.Buffer + 4; /* skip \??\ prefix */
1481 else
1482 cur_dir = NULL;
1483 }
1484 if (!cur_dir)
1485 {
1486 if (NtCurrentTeb()->Tib.SubSystemTib) /* FIXME: hack */
1487 cur_dir = ((WIN16_SUBSYSTEM_TIB *)NtCurrentTeb()->Tib.SubSystemTib)->curdir.DosPath.Buffer;
1488 else
1489 cur_dir = cur_params->CurrentDirectory.DosPath.Buffer;
1490 }
1491
1492 size = sizeof(*info);
1493 size += strlenW( cur_dir ) * sizeof(WCHAR);
1494 size += cur_params->DllPath.Length;
1495 size += strlenW( imagepath ) * sizeof(WCHAR);
1496 size += strlenW( cmdline ) * sizeof(WCHAR);
1497 if (startup->lpTitle) size += strlenW( startup->lpTitle ) * sizeof(WCHAR);
1498 if (startup->lpDesktop) size += strlenW( startup->lpDesktop ) * sizeof(WCHAR);
1499 /* FIXME: shellinfo */
1500 if (startup->lpReserved2 && startup->cbReserved2) size += startup->cbReserved2;
1501 size = (size + 1) & ~1;
1502 *info_size = size;
1503
1504 if (!(info = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size ))) goto done;
1505
1506 info->console_flags = cur_params->ConsoleFlags;
1507 if (flags & CREATE_NEW_PROCESS_GROUP) info->console_flags = 1;
1508 if (flags & CREATE_NEW_CONSOLE) info->console = (obj_handle_t)1; /* FIXME: cf. kernel_main.c */
1509
1510 if (startup->dwFlags & STARTF_USESTDHANDLES)
1511 {
1512 hstdin = startup->hStdInput;
1513 hstdout = startup->hStdOutput;
1514 hstderr = startup->hStdError;
1515 }
1516 else
1517 {
1518 hstdin = GetStdHandle( STD_INPUT_HANDLE );
1519 hstdout = GetStdHandle( STD_OUTPUT_HANDLE );
1520 hstderr = GetStdHandle( STD_ERROR_HANDLE );
1521 }
1522 info->hstdin = wine_server_obj_handle( hstdin );
1523 info->hstdout = wine_server_obj_handle( hstdout );
1524 info->hstderr = wine_server_obj_handle( hstderr );
1525 if ((flags & (CREATE_NEW_CONSOLE | DETACHED_PROCESS)) != 0)
1526 {
1527 /* this is temporary (for console handles). We have no way to control that the handle is invalid in child process otherwise */
1528 if (is_console_handle(hstdin)) info->hstdin = wine_server_obj_handle( INVALID_HANDLE_VALUE );
1529 if (is_console_handle(hstdout)) info->hstdout = wine_server_obj_handle( INVALID_HANDLE_VALUE );
1530 if (is_console_handle(hstderr)) info->hstderr = wine_server_obj_handle( INVALID_HANDLE_VALUE );
1531 }
1532 else
1533 {
1534 if (is_console_handle(hstdin)) info->hstdin = console_handle_unmap(hstdin);
1535 if (is_console_handle(hstdout)) info->hstdout = console_handle_unmap(hstdout);
1536 if (is_console_handle(hstderr)) info->hstderr = console_handle_unmap(hstderr);
1537 }
1538
1539 info->x = startup->dwX;
1540 info->y = startup->dwY;
1541 info->xsize = startup->dwXSize;
1542 info->ysize = startup->dwYSize;
1543 info->xchars = startup->dwXCountChars;
1544 info->ychars = startup->dwYCountChars;
1545 info->attribute = startup->dwFillAttribute;
1546 info->flags = startup->dwFlags;
1547 info->show = startup->wShowWindow;
1548
1549 ptr = info + 1;
1550 info->curdir_len = append_string( &ptr, cur_dir );
1551 info->dllpath_len = cur_params->DllPath.Length;
1552 memcpy( ptr, cur_params->DllPath.Buffer, cur_params->DllPath.Length );
1553 ptr = (char *)ptr + cur_params->DllPath.Length;
1554 info->imagepath_len = append_string( &ptr, imagepath );
1555 info->cmdline_len = append_string( &ptr, cmdline );
1556 if (startup->lpTitle) info->title_len = append_string( &ptr, startup->lpTitle );
1557 if (startup->lpDesktop) info->desktop_len = append_string( &ptr, startup->lpDesktop );
1558 if (startup->lpReserved2 && startup->cbReserved2)
1559 {
1560 info->runtime_len = startup->cbReserved2;
1561 memcpy( ptr, startup->lpReserved2, startup->cbReserved2 );
1562 }
1563
1564 done:
1565 RtlFreeUnicodeString( &newdir );
1566 return info;
1567 }
1568
1569 /***********************************************************************
1570 * get_alternate_loader
1571 *
1572 * Get the name of the alternate (32 or 64 bit) Wine loader.
1573 */
1574 static const char *get_alternate_loader( char **ret_env )
1575 {
1576 char *env;
1577 const char *loader = NULL;
1578 const char *loader_env = getenv( "WINELOADER" );
1579
1580 *ret_env = NULL;
1581
1582 if (wine_get_build_dir()) loader = is_win64 ? "loader/wine32" : "server/../loader/wine";
1583
1584 if (loader_env)
1585 {
1586 int len = strlen( loader_env );
1587 if (is_win64)
1588 {
1589 if (!(env = HeapAlloc( GetProcessHeap(), 0, sizeof("WINELOADER=") + len + 2 ))) return NULL;
1590 strcpy( env, "WINELOADER=" );
1591 strcat( env, loader_env );
1592 strcat( env, "32" );
1593 }
1594 else
1595 {
1596 if (!(env = HeapAlloc( GetProcessHeap(), 0, sizeof("WINELOADER=") + len ))) return NULL;
1597 strcpy( env, "WINELOADER=" );
1598 strcat( env, loader_env );
1599 len += sizeof("WINELOADER=") - 1;
1600 if (!strcmp( env + len - 2, "32" )) env[len - 2] = 0;
1601 }
1602 if (!loader)
1603 {
1604 if ((loader = strrchr( env, '/' ))) loader++;
1605 else loader = env;
1606 }
1607 *ret_env = env;
1608 }
1609 if (!loader) loader = is_win64 ? "wine32" : "wine";
1610 return loader;
1611 }
1612
1613 /***********************************************************************
1614 * create_process
1615 *
1616 * Create a new process. If hFile is a valid handle we have an exe
1617 * file, otherwise it is a Winelib app.
1618 */
1619 static BOOL create_process( HANDLE hFile, LPCWSTR filename, LPWSTR cmd_line, LPWSTR env,
1620 LPCWSTR cur_dir, LPSECURITY_ATTRIBUTES psa, LPSECURITY_ATTRIBUTES tsa,
1621 BOOL inherit, DWORD flags, LPSTARTUPINFOW startup,
1622 LPPROCESS_INFORMATION info, LPCSTR unixdir,
1623 const struct binary_info *binary_info, int exec_only )
1624 {
1625 BOOL ret, success = FALSE;
1626 HANDLE process_info;
1627 WCHAR *env_end;
1628 char *winedebug = NULL;
1629 char *wineloader = NULL;
1630 const char *loader = NULL;
1631 char **argv;
1632 startup_info_t *startup_info;
1633 DWORD startup_info_size;
1634 int socketfd[2], stdin_fd = -1, stdout_fd = -1;
1635 pid_t pid;
1636 int err;
1637
1638 if (!is_win64 && !is_wow64 && (binary_info->flags & BINARY_FLAG_64BIT))
1639 {
1640 ERR( "starting 64-bit process %s not supported on this platform\n", debugstr_w(filename) );
1641 SetLastError( ERROR_BAD_EXE_FORMAT );
1642 return FALSE;
1643 }
1644
1645 RtlAcquirePebLock();
1646
1647 if (!(startup_info = create_startup_info( filename, cmd_line, cur_dir, env, flags, startup,
1648 &startup_info_size )))
1649 {
1650 RtlReleasePebLock();
1651 return FALSE;
1652 }
1653 if (!env) env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
1654 env_end = env;
1655 while (*env_end)
1656 {
1657 static const WCHAR WINEDEBUG[] = {'W','I','N','E','D','E','B','U','G','=',0};
1658 if (!winedebug && !strncmpW( env_end, WINEDEBUG, sizeof(WINEDEBUG)/sizeof(WCHAR) - 1 ))
1659 {
1660 DWORD len = WideCharToMultiByte( CP_UNIXCP, 0, env_end, -1, NULL, 0, NULL, NULL );
1661 if ((winedebug = HeapAlloc( GetProcessHeap(), 0, len )))
1662 WideCharToMultiByte( CP_UNIXCP, 0, env_end, -1, winedebug, len, NULL, NULL );
1663 }
1664 env_end += strlenW(env_end) + 1;
1665 }
1666 env_end++;
1667
1668 /* create the socket for the new process */
1669
1670 if (socketpair( PF_UNIX, SOCK_STREAM, 0, socketfd ) == -1)
1671 {
1672 RtlReleasePebLock();
1673 HeapFree( GetProcessHeap(), 0, winedebug );
1674 HeapFree( GetProcessHeap(), 0, startup_info );
1675 SetLastError( ERROR_TOO_MANY_OPEN_FILES );
1676 return FALSE;
1677 }
1678 wine_server_send_fd( socketfd[1] );
1679 close( socketfd[1] );
1680
1681 /* create the process on the server side */
1682
1683 SERVER_START_REQ( new_process )
1684 {
1685 req->inherit_all = inherit;
1686 req->create_flags = flags;
1687 req->socket_fd = socketfd[1];
1688 req->exe_file = wine_server_obj_handle( hFile );
1689 req->process_access = PROCESS_ALL_ACCESS;
1690 req->process_attr = (psa && (psa->nLength >= sizeof(*psa)) && psa->bInheritHandle) ? OBJ_INHERIT : 0;
1691 req->thread_access = THREAD_ALL_ACCESS;
1692 req->thread_attr = (tsa && (tsa->nLength >= sizeof(*tsa)) && tsa->bInheritHandle) ? OBJ_INHERIT : 0;
1693 req->info_size = startup_info_size;
1694
1695 wine_server_add_data( req, startup_info, startup_info_size );
1696 wine_server_add_data( req, env, (env_end - env) * sizeof(WCHAR) );
1697 if ((ret = !wine_server_call_err( req )))
1698 {
1699 info->dwProcessId = (DWORD)reply->pid;
1700 info->dwThreadId = (DWORD)reply->tid;
1701 info->hProcess = wine_server_ptr_handle( reply->phandle );
1702 info->hThread = wine_server_ptr_handle( reply->thandle );
1703 }
1704 process_info = wine_server_ptr_handle( reply->info );
1705 }
1706 SERVER_END_REQ;
1707
1708 RtlReleasePebLock();
1709 if (!ret)
1710 {
1711 close( socketfd[0] );
1712 HeapFree( GetProcessHeap(), 0, startup_info );
1713 HeapFree( GetProcessHeap(), 0, winedebug );
1714 return FALSE;
1715 }
1716
1717 if (!(flags & (CREATE_NEW_CONSOLE | DETACHED_PROCESS)))
1718 {
1719 if (startup_info->hstdin)
1720 wine_server_handle_to_fd( wine_server_ptr_handle(startup_info->hstdin),
1721 FILE_READ_DATA, &stdin_fd, NULL );
1722 if (startup_info->hstdout)
1723 wine_server_handle_to_fd( wine_server_ptr_handle(startup_info->hstdout),
1724 FILE_WRITE_DATA, &stdout_fd, NULL );
1725 }
1726 HeapFree( GetProcessHeap(), 0, startup_info );
1727
1728 /* create the child process */
1729 argv = build_argv( cmd_line, 1 );
1730
1731 if (!is_win64 ^ !(binary_info->flags & BINARY_FLAG_64BIT))
1732 loader = get_alternate_loader( &wineloader );
1733
1734 if (exec_only || !(pid = fork())) /* child */
1735 {
1736 char preloader_reserve[64], socket_env[64];
1737
1738 if (flags & (CREATE_NEW_PROCESS_GROUP | CREATE_NEW_CONSOLE | DETACHED_PROCESS))
1739 {
1740 if (!(pid = fork()))
1741 {
1742 int fd = open( "/dev/null", O_RDWR );
1743 setsid();
1744 /* close stdin and stdout */
1745 if (fd != -1)
1746 {
1747 dup2( fd, 0 );
1748 dup2( fd, 1 );
1749 close( fd );
1750 }
1751 }
1752 else if (pid != -1) _exit(0); /* parent */
1753 }
1754 else
1755 {
1756 if (stdin_fd != -1) dup2( stdin_fd, 0 );
1757 if (stdout_fd != -1) dup2( stdout_fd, 1 );
1758 }
1759
1760 if (stdin_fd != -1) close( stdin_fd );
1761 if (stdout_fd != -1) close( stdout_fd );
1762
1763 /* Reset signals that we previously set to SIG_IGN */
1764 signal( SIGPIPE, SIG_DFL );
1765 signal( SIGCHLD, SIG_DFL );
1766
1767 sprintf( socket_env, "WINESERVERSOCKET=%u", socketfd[0] );
1768 sprintf( preloader_reserve, "WINEPRELOADRESERVE=%lx-%lx",
1769 (unsigned long)binary_info->res_start, (unsigned long)binary_info->res_end );
1770
1771 putenv( preloader_reserve );
1772 putenv( socket_env );
1773 if (winedebug) putenv( winedebug );
1774 if (wineloader) putenv( wineloader );
1775 if (unixdir) chdir(unixdir);
1776
1777 if (argv) wine_exec_wine_binary( loader, argv, getenv("WINELOADER") );
1778 _exit(1);
1779 }
1780
1781 /* this is the parent */
1782
1783 if (stdin_fd != -1) close( stdin_fd );
1784 if (stdout_fd != -1) close( stdout_fd );
1785 close( socketfd[0] );
1786 HeapFree( GetProcessHeap(), 0, argv );
1787 HeapFree( GetProcessHeap(), 0, winedebug );
1788 HeapFree( GetProcessHeap(), 0, wineloader );
1789 if (pid == -1)
1790 {
1791 FILE_SetDosError();
1792 goto error;
1793 }
1794
1795 /* wait for the new process info to be ready */
1796
1797 WaitForSingleObject( process_info, INFINITE );
1798 SERVER_START_REQ( get_new_process_info )
1799 {
1800 req->info = wine_server_obj_handle( process_info );
1801 wine_server_call( req );
1802 success = reply->success;
1803 err = reply->exit_code;
1804 }
1805 SERVER_END_REQ;
1806
1807 if (!success)
1808 {
1809 SetLastError( err ? err : ERROR_INTERNAL_ERROR );
1810 goto error;
1811 }
1812 CloseHandle( process_info );
1813 return success;
1814
1815 error:
1816 CloseHandle( process_info );
1817 CloseHandle( info->hProcess );
1818 CloseHandle( info->hThread );
1819 info->hProcess = info->hThread = 0;
1820 info->dwProcessId = info->dwThreadId = 0;
1821 return FALSE;
1822 }
1823
1824
1825 /***********************************************************************
1826 * create_vdm_process
1827 *
1828 * Create a new VDM process for a 16-bit or DOS application.
1829 */
1830 static BOOL create_vdm_process( LPCWSTR filename, LPWSTR cmd_line, LPWSTR env, LPCWSTR cur_dir,
1831 LPSECURITY_ATTRIBUTES psa, LPSECURITY_ATTRIBUTES tsa,
1832 BOOL inherit, DWORD flags, LPSTARTUPINFOW startup,
1833 LPPROCESS_INFORMATION info, LPCSTR unixdir,
1834 const struct binary_info *binary_info, int exec_only )
1835 {
1836 static const WCHAR argsW[] = {'%','s',' ','-','-','a','p','p','-','n','a','m','e',' ','"','%','s','"',' ','%','s',0};
1837
1838 BOOL ret;
1839 LPWSTR new_cmd_line = HeapAlloc( GetProcessHeap(), 0,
1840 (strlenW(filename) + strlenW(cmd_line) + 30) * sizeof(WCHAR) );
1841
1842 if (!new_cmd_line)
1843 {
1844 SetLastError( ERROR_OUTOFMEMORY );
1845 return FALSE;
1846 }
1847 sprintfW( new_cmd_line, argsW, winevdmW, filename, cmd_line );
1848 ret = create_process( 0, winevdmW, new_cmd_line, env, cur_dir, psa, tsa, inherit,
1849 flags, startup, info, unixdir, binary_info, exec_only );
1850 HeapFree( GetProcessHeap(), 0, new_cmd_line );
1851 return ret;
1852 }
1853
1854
1855 /***********************************************************************
1856 * create_cmd_process
1857 *
1858 * Create a new cmd shell process for a .BAT file.
1859 */
1860 static BOOL create_cmd_process( LPCWSTR filename, LPWSTR cmd_line, LPVOID env, LPCWSTR cur_dir,
1861 LPSECURITY_ATTRIBUTES psa, LPSECURITY_ATTRIBUTES tsa,
1862 BOOL inherit, DWORD flags, LPSTARTUPINFOW startup,
1863 LPPROCESS_INFORMATION info )
1864
1865 {
1866 static const WCHAR comspecW[] = {'C','O','M','S','P','E','C',0};
1867 static const WCHAR slashcW[] = {' ','/','c',' ',0};
1868 WCHAR comspec[MAX_PATH];
1869 WCHAR *newcmdline;
1870 BOOL ret;
1871
1872 if (!GetEnvironmentVariableW( comspecW, comspec, sizeof(comspec)/sizeof(WCHAR) ))
1873 return FALSE;
1874 if (!(newcmdline = HeapAlloc( GetProcessHeap(), 0,
1875 (strlenW(comspec) + 4 + strlenW(cmd_line) + 1) * sizeof(WCHAR))))
1876 return FALSE;
1877
1878 strcpyW( newcmdline, comspec );
1879 strcatW( newcmdline, slashcW );
1880 strcatW( newcmdline, cmd_line );
1881 ret = CreateProcessW( comspec, newcmdline, psa, tsa, inherit,
1882 flags, env, cur_dir, startup, info );
1883 HeapFree( GetProcessHeap(), 0, newcmdline );
1884 return ret;
1885 }
1886
1887
1888 /*************************************************************************
1889 * get_file_name
1890 *
1891 * Helper for CreateProcess: retrieve the file name to load from the
1892 * app name and command line. Store the file name in buffer, and
1893 * return a possibly modified command line.
1894 * Also returns a handle to the opened file if it's a Windows binary.
1895 */
1896 static LPWSTR get_file_name( LPCWSTR appname, LPWSTR cmdline, LPWSTR buffer,
1897 int buflen, HANDLE *handle, struct binary_info *binary_info )
1898 {
1899 static const WCHAR quotesW[] = {'"','%','s','"',0};
1900
1901 WCHAR *name, *pos, *first_space, *ret = NULL;
1902 const WCHAR *p;
1903
1904 /* if we have an app name, everything is easy */
1905
1906 if (appname)
1907 {
1908 /* use the unmodified app name as file name */
1909 lstrcpynW( buffer, appname, buflen );
1910 *handle = open_exe_file( buffer, binary_info );
1911 if (!(ret = cmdline) || !cmdline[0])
1912 {
1913 /* no command-line, create one */
1914 if ((ret = HeapAlloc( GetProcessHeap(), 0, (strlenW(appname) + 3) * sizeof(WCHAR) )))
1915 sprintfW( ret, quotesW, appname );
1916 }
1917 return ret;
1918 }
1919
1920 /* first check for a quoted file name */
1921
1922 if ((cmdline[0] == '"') && ((p = strchrW( cmdline + 1, '"' ))))
1923 {
1924 int len = p - cmdline - 1;
1925 /* extract the quoted portion as file name */
1926 if (!(name = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return NULL;
1927 memcpy( name, cmdline + 1, len * sizeof(WCHAR) );
1928 name[len] = 0;
1929
1930 if (!find_exe_file( name, buffer, buflen, handle, binary_info ))
1931 {
1932 if (!get_builtin_path( name, exeW, buffer, buflen, binary_info )) goto done;
1933 *handle = 0;
1934 }
1935 ret = cmdline; /* no change necessary */
1936 goto done;
1937 }
1938
1939 /* now try the command-line word by word */
1940
1941 if (!(name = HeapAlloc( GetProcessHeap(), 0, (strlenW(cmdline) + 1) * sizeof(WCHAR) )))
1942 return NULL;
1943 pos = name;
1944 p = cmdline;
1945 first_space = NULL;
1946
1947 for (;;)
1948 {
1949 while (*p && *p != ' ' && *p != '\t') *pos++ = *p++;
1950 *pos = 0;
1951 if (find_exe_file( name, buffer, buflen, handle, binary_info ))
1952 {
1953 ret = cmdline;
1954 break;
1955 }
1956 if (!first_space) first_space = pos;
1957 if (!(*pos++ = *p++)) break;
1958 }
1959
1960 if (!ret)
1961 {
1962 if (first_space) *first_space = 0; /* try only the first word as a builtin */
1963 if (get_builtin_path( name, exeW, buffer, buflen, binary_info ))
1964 {
1965 *handle = 0;
1966 ret = cmdline;
1967 }
1968 else SetLastError( ERROR_FILE_NOT_FOUND );
1969 }
1970 else if (first_space) /* build a new command-line with quotes */
1971 {
1972 if (!(ret = HeapAlloc( GetProcessHeap(), 0, (strlenW(cmdline) + 3) * sizeof(WCHAR) )))
1973 goto done;
1974 sprintfW( ret, quotesW, name );
1975 strcatW( ret, p );
1976 }
1977
1978 done:
1979 HeapFree( GetProcessHeap(), 0, name );
1980 return ret;
1981 }
1982
1983
1984 /**********************************************************************
1985 * CreateProcessA (KERNEL32.@)
1986 */
1987 BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessA( LPCSTR app_name, LPSTR cmd_line, LPSECURITY_ATTRIBUTES process_attr,
1988 LPSECURITY_ATTRIBUTES thread_attr, BOOL inherit,
1989 DWORD flags, LPVOID env, LPCSTR cur_dir,
1990 LPSTARTUPINFOA startup_info, LPPROCESS_INFORMATION info )
1991 {
1992 BOOL ret = FALSE;
1993 WCHAR *app_nameW = NULL, *cmd_lineW = NULL, *cur_dirW = NULL;
1994 UNICODE_STRING desktopW, titleW;
1995 STARTUPINFOW infoW;
1996
1997 desktopW.Buffer = NULL;
1998 titleW.Buffer = NULL;
1999 if (app_name && !(app_nameW = FILE_name_AtoW( app_name, TRUE ))) goto done;
2000 if (cmd_line && !(cmd_lineW = FILE_name_AtoW( cmd_line, TRUE ))) goto done;
2001 if (cur_dir && !(cur_dirW = FILE_name_AtoW( cur_dir, TRUE ))) goto done;
2002
2003 if (startup_info->lpDesktop) RtlCreateUnicodeStringFromAsciiz( &desktopW, startup_info->lpDesktop );
2004 if (startup_info->lpTitle) RtlCreateUnicodeStringFromAsciiz( &titleW, startup_info->lpTitle );
2005
2006 memcpy( &infoW, startup_info, sizeof(infoW) );
2007 infoW.lpDesktop = desktopW.Buffer;
2008 infoW.lpTitle = titleW.Buffer;
2009
2010 if (startup_info->lpReserved)
2011 FIXME("StartupInfo.lpReserved is used, please report (%s)\n",
2012 debugstr_a(startup_info->lpReserved));
2013
2014 ret = CreateProcessW( app_nameW, cmd_lineW, process_attr, thread_attr,
2015 inherit, flags, env, cur_dirW, &infoW, info );
2016 done:
2017 HeapFree( GetProcessHeap(), 0, app_nameW );
2018 HeapFree( GetProcessHeap(), 0, cmd_lineW );
2019 HeapFree( GetProcessHeap(), 0, cur_dirW );
2020 RtlFreeUnicodeString( &desktopW );
2021 RtlFreeUnicodeString( &titleW );
2022 return ret;
2023 }
2024
2025
2026 /**********************************************************************
2027 * CreateProcessW (KERNEL32.@)
2028 */
2029 BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessW( LPCWSTR app_name, LPWSTR cmd_line, LPSECURITY_ATTRIBUTES process_attr,
2030 LPSECURITY_ATTRIBUTES thread_attr, BOOL inherit, DWORD flags,
2031 LPVOID env, LPCWSTR cur_dir, LPSTARTUPINFOW startup_info,
2032 LPPROCESS_INFORMATION info )
2033 {
2034 BOOL retv = FALSE;
2035 HANDLE hFile = 0;
2036 char *unixdir = NULL;
2037 WCHAR name[MAX_PATH];
2038 WCHAR *tidy_cmdline, *p, *envW = env;
2039 struct binary_info binary_info;
2040
2041 /* Process the AppName and/or CmdLine to get module name and path */
2042
2043 TRACE("app %s cmdline %s\n", debugstr_w(app_name), debugstr_w(cmd_line) );
2044
2045 if (!(tidy_cmdline = get_file_name( app_name, cmd_line, name, sizeof(name)/sizeof(WCHAR),
2046 &hFile, &binary_info )))
2047 return FALSE;
2048 if (hFile == INVALID_HANDLE_VALUE) goto done;
2049
2050 /* Warn if unsupported features are used */
2051
2052 if (flags & (IDLE_PRIORITY_CLASS | HIGH_PRIORITY_CLASS | REALTIME_PRIORITY_CLASS |
2053 CREATE_NEW_PROCESS_GROUP | CREATE_SEPARATE_WOW_VDM | CREATE_SHARED_WOW_VDM |
2054 CREATE_DEFAULT_ERROR_MODE | CREATE_NO_WINDOW |
2055 PROFILE_USER | PROFILE_KERNEL | PROFILE_SERVER))
2056 WARN("(%s,...): ignoring some flags in %x\n", debugstr_w(name), flags);
2057
2058 if (cur_dir)
2059 {
2060 if (!(unixdir = wine_get_unix_file_name( cur_dir )))
2061 {
2062 SetLastError(ERROR_DIRECTORY);
2063 goto done;
2064 }
2065 }
2066 else
2067 {
2068 WCHAR buf[MAX_PATH];
2069 if (GetCurrentDirectoryW(MAX_PATH, buf)) unixdir = wine_get_unix_file_name( buf );
2070 }
2071
2072 if (env && !(flags & CREATE_UNICODE_ENVIRONMENT)) /* convert environment to unicode */
2073 {
2074 char *p = env;
2075 DWORD lenW;
2076
2077 while (*p) p += strlen(p) + 1;
2078 p++; /* final null */
2079 lenW = MultiByteToWideChar( CP_ACP, 0, env, p - (char*)env, NULL, 0 );
2080 envW = HeapAlloc( GetProcessHeap(), 0, lenW * sizeof(WCHAR) );
2081 MultiByteToWideChar( CP_ACP, 0, env, p - (char*)env, envW, lenW );
2082 flags |= CREATE_UNICODE_ENVIRONMENT;
2083 }
2084
2085 info->hThread = info->hProcess = 0;
2086 info->dwProcessId = info->dwThreadId = 0;
2087
2088 if (binary_info.flags & BINARY_FLAG_DLL)
2089 {
2090 TRACE( "not starting %s since it is a dll\n", debugstr_w(name) );
2091 SetLastError( ERROR_BAD_EXE_FORMAT );
2092 }
2093 else switch (binary_info.type)
2094 {
2095 case BINARY_PE:
2096 TRACE( "starting %s as Win%d binary (%p-%p)\n",
2097 debugstr_w(name), (binary_info.flags & BINARY_FLAG_64BIT) ? 64 : 32,
2098 binary_info.res_start, binary_info.res_end );
2099 retv = create_process( hFile, name, tidy_cmdline, envW, cur_dir, process_attr, thread_attr,
2100 inherit, flags, startup_info, info, unixdir, &binary_info, FALSE );
2101 break;
2102 case BINARY_OS216:
2103 case BINARY_WIN16:
2104 case BINARY_DOS:
2105 TRACE( "starting %s as Win16/DOS binary\n", debugstr_w(name) );
2106 retv = create_vdm_process( name, tidy_cmdline, envW, cur_dir, process_attr, thread_attr,
2107 inherit, flags, startup_info, info, unixdir, &binary_info, FALSE );
2108 break;
2109 case BINARY_UNIX_LIB:
2110 TRACE( "starting %s as %d-bit Winelib app\n",
2111 debugstr_w(name), (binary_info.flags & BINARY_FLAG_64BIT) ? 64 : 32 );
2112 retv = create_process( hFile, name, tidy_cmdline, envW, cur_dir, process_attr, thread_attr,
2113 inherit, flags, startup_info, info, unixdir, &binary_info, FALSE );
2114 break;
2115 case BINARY_UNKNOWN:
2116 /* check for .com or .bat extension */
2117 if ((p = strrchrW( name, '.' )))
2118 {
2119 if (!strcmpiW( p, comW ) || !strcmpiW( p, pifW ))
2120 {
2121 TRACE( "starting %s as DOS binary\n", debugstr_w(name) );
2122 retv = create_vdm_process( name, tidy_cmdline, envW, cur_dir, process_attr, thread_attr,
2123 inherit, flags, startup_info, info, unixdir,
2124 &binary_info, FALSE );
2125 break;
2126 }
2127 if (!strcmpiW( p, batW ) || !strcmpiW( p, cmdW ) )
2128 {
2129 TRACE( "starting %s as batch binary\n", debugstr_w(name) );
2130 retv = create_cmd_process( name, tidy_cmdline, envW, cur_dir, process_attr, thread_attr,
2131 inherit, flags, startup_info, info );
2132 break;
2133 }
2134 }
2135 /* fall through */
2136 case BINARY_UNIX_EXE:
2137 {
2138 /* unknown file, try as unix executable */
2139 char *unix_name;
2140
2141 TRACE( "starting %s as Unix binary\n", debugstr_w(name) );
2142
2143 if ((unix_name = wine_get_unix_file_name( name )))
2144 {
2145 retv = (fork_and_exec( unix_name, tidy_cmdline, envW, unixdir, flags, startup_info ) != -1);
2146 HeapFree( GetProcessHeap(), 0, unix_name );
2147 }
2148 }
2149 break;
2150 }
2151 if (hFile) CloseHandle( hFile );
2152
2153 done:
2154 if (tidy_cmdline != cmd_line) HeapFree( GetProcessHeap(), 0, tidy_cmdline );
2155 if (envW != env) HeapFree( GetProcessHeap(), 0, envW );
2156 HeapFree( GetProcessHeap(), 0, unixdir );
2157 if (retv)
2158 TRACE( "started process pid %04x tid %04x\n", info->dwProcessId, info->dwThreadId );
2159 return retv;
2160 }
2161
2162
2163 /**********************************************************************
2164 * exec_process
2165 */
2166 static void exec_process( LPCWSTR name )
2167 {
2168 HANDLE hFile;
2169 WCHAR *p;
2170 STARTUPINFOW startup_info;
2171 PROCESS_INFORMATION info;
2172 struct binary_info binary_info;
2173
2174 hFile = open_exe_file( name, &binary_info );
2175 if (!hFile || hFile == INVALID_HANDLE_VALUE) return;
2176
2177 memset( &startup_info, 0, sizeof(startup_info) );
2178 startup_info.cb = sizeof(startup_info);
2179
2180 /* Determine executable type */
2181
2182 if (binary_info.flags & BINARY_FLAG_DLL) return;
2183 switch (binary_info.type)
2184 {
2185 case BINARY_PE:
2186 TRACE( "starting %s as Win%d binary (%p-%p)\n",
2187 debugstr_w(name), (binary_info.flags & BINARY_FLAG_64BIT) ? 64 : 32,
2188 binary_info.res_start, binary_info.res_end );
2189 create_process( hFile, name, GetCommandLineW(), NULL, NULL, NULL, NULL,
2190 FALSE, 0, &startup_info, &info, NULL, &binary_info, TRUE );
2191 break;
2192 case BINARY_UNIX_LIB:
2193 TRACE( "%s is a Unix library, starting as Winelib app\n", debugstr_w(name) );
2194 create_process( hFile, name, GetCommandLineW(), NULL, NULL, NULL, NULL,
2195 FALSE, 0, &startup_info, &info, NULL, &binary_info, TRUE );
2196 break;
2197 case BINARY_UNKNOWN:
2198 /* check for .com or .pif extension */
2199 if (!(p = strrchrW( name, '.' ))) break;
2200 if (strcmpiW( p, comW ) && strcmpiW( p, pifW )) break;
2201 /* fall through */
2202 case BINARY_OS216:
2203 case BINARY_WIN16:
2204 case BINARY_DOS:
2205 TRACE( "starting %s as Win16/DOS binary\n", debugstr_w(name) );
2206 create_vdm_process( name, GetCommandLineW(), NULL, NULL, NULL, NULL,
2207 FALSE, 0, &startup_info, &info, NULL, &binary_info, TRUE );
2208 break;
2209 default:
2210 break;
2211 }
2212 CloseHandle( hFile );
2213 }
2214
2215
2216 /***********************************************************************
2217 * wait_input_idle
2218 *
2219 * Wrapper to call WaitForInputIdle USER function
2220 */
2221 typedef DWORD (WINAPI *WaitForInputIdle_ptr)( HANDLE hProcess, DWORD dwTimeOut );
2222
2223 static DWORD wait_input_idle( HANDLE process, DWORD timeout )
2224 {
2225 HMODULE mod = GetModuleHandleA( "user32.dll" );
2226 if (mod)
2227 {
2228 WaitForInputIdle_ptr ptr = (WaitForInputIdle_ptr)GetProcAddress( mod, "WaitForInputIdle" );
2229 if (ptr) return ptr( process, timeout );
2230 }
2231 return 0;
2232 }
2233
2234
2235 /***********************************************************************
2236 * WinExec (KERNEL32.@)
2237 */
2238 UINT WINAPI WinExec( LPCSTR lpCmdLine, UINT nCmdShow )
2239 {
2240 PROCESS_INFORMATION info;
2241 STARTUPINFOA startup;
2242 char *cmdline;
2243 UINT ret;
2244
2245 memset( &startup, 0, sizeof(startup) );
2246 startup.cb = sizeof(startup);
2247 startup.dwFlags = STARTF_USESHOWWINDOW;
2248 startup.wShowWindow = nCmdShow;
2249
2250 /* cmdline needs to be writable for CreateProcess */
2251 if (!(cmdline = HeapAlloc( GetProcessHeap(), 0, strlen(lpCmdLine)+1 ))) return 0;
2252 strcpy( cmdline, lpCmdLine );
2253
2254 if (CreateProcessA( NULL, cmdline, NULL, NULL, FALSE,
2255 0, NULL, NULL, &startup, &info ))
2256 {
2257 /* Give 30 seconds to the app to come up */
2258 if (wait_input_idle( info.hProcess, 30000 ) == WAIT_FAILED)
2259 WARN("WaitForInputIdle failed: Error %d\n", GetLastError() );
2260 ret = 33;
2261 /* Close off the handles */
2262 CloseHandle( info.hThread );
2263 CloseHandle( info.hProcess );
2264 }
2265 else if ((ret = GetLastError()) >= 32)
2266 {
2267 FIXME("Strange error set by CreateProcess: %d\n", ret );
2268 ret = 11;
2269 }
2270 HeapFree( GetProcessHeap(), 0, cmdline );
2271 return ret;
2272 }
2273
2274
2275 /**********************************************************************
2276 * LoadModule (KERNEL32.@)
2277 */
2278 HINSTANCE WINAPI LoadModule( LPCSTR name, LPVOID paramBlock )
2279 {
2280 LOADPARMS32 *params = paramBlock;
2281 PROCESS_INFORMATION info;
2282 STARTUPINFOA startup;
2283 HINSTANCE hInstance;
2284 LPSTR cmdline, p;
2285 char filename[MAX_PATH];
2286 BYTE len;
2287
2288 if (!name) return (HINSTANCE)ERROR_FILE_NOT_FOUND;
2289
2290 if (!SearchPathA( NULL, name, ".exe", sizeof(filename), filename, NULL ) &&
2291 !SearchPathA( NULL, name, NULL, sizeof(filename), filename, NULL ))
2292 return ULongToHandle(GetLastError());
2293
2294 len = (BYTE)params->lpCmdLine[0];
2295 if (!(cmdline = HeapAlloc( GetProcessHeap(), 0, strlen(filename) + len + 2 )))
2296 return (HINSTANCE)ERROR_NOT_ENOUGH_MEMORY;
2297
2298 strcpy( cmdline, filename );
2299 p = cmdline + strlen(cmdline);
2300 *p++ = ' ';
2301 memcpy( p, params->lpCmdLine + 1, len );
2302 p[len] = 0;
2303
2304 memset( &startup, 0, sizeof(startup) );
2305 startup.cb = sizeof(startup);
2306 if (params->lpCmdShow)
2307 {
2308 startup.dwFlags = STARTF_USESHOWWINDOW;
2309 startup.wShowWindow = ((WORD *)params->lpCmdShow)[1];
2310 }
2311
2312 if (CreateProcessA( filename, cmdline, NULL, NULL, FALSE, 0,
2313 params->lpEnvAddress, NULL, &startup, &info ))
2314 {
2315 /* Give 30 seconds to the app to come up */
2316 if (wait_input_idle( info.hProcess, 30000 ) == WAIT_FAILED)
2317 WARN("WaitForInputIdle failed: Error %d\n", GetLastError() );
2318 hInstance = (HINSTANCE)33;
2319 /* Close off the handles */
2320 CloseHandle( info.hThread );
2321 CloseHandle( info.hProcess );
2322 }
2323 else if ((hInstance = ULongToHandle(GetLastError())) >= (HINSTANCE)32)
2324 {
2325 FIXME("Strange error set by CreateProcess: %p\n", hInstance );
2326 hInstance = (HINSTANCE)11;
2327 }
2328
2329 HeapFree( GetProcessHeap(), 0, cmdline );
2330 return hInstance;
2331 }
2332
2333
2334 /******************************************************************************
2335 * TerminateProcess (KERNEL32.@)
2336 *
2337 * Terminates a process.
2338 *
2339 * PARAMS
2340 * handle [I] Process to terminate.
2341 * exit_code [I] Exit code.
2342 *
2343 * RETURNS
2344 * Success: TRUE.
2345 * Failure: FALSE, check GetLastError().
2346 */
2347 BOOL WINAPI TerminateProcess( HANDLE handle, DWORD exit_code )
2348 {
2349 NTSTATUS status = NtTerminateProcess( handle, exit_code );
2350 if (status) SetLastError( RtlNtStatusToDosError(status) );
2351 return !status;
2352 }
2353
2354 /***********************************************************************
2355 * ExitProcess (KERNEL32.@)
2356 *
2357 * Exits the current process.
2358 *
2359 * PARAMS
2360 * status [I] Status code to exit with.
2361 *
2362 * RETURNS
2363 * Nothing.
2364 */
2365 #ifdef __i386__
2366 __ASM_STDCALL_FUNC( ExitProcess, 4, /* Shrinker depend on this particular ExitProcess implementation */
2367 "pushl %ebp\n\t"
2368 ".byte 0x8B, 0xEC\n\t" /* movl %esp, %ebp */
2369 ".byte 0x6A, 0x00\n\t" /* pushl $0 */
2370 ".byte 0x68, 0x00, 0x00, 0x00, 0x00\n\t" /* pushl $0 - 4 bytes immediate */
2371 "pushl 8(%ebp)\n\t"
2372 "call " __ASM_NAME("process_ExitProcess") __ASM_STDCALL(4) "\n\t"
2373 "leave\n\t"
2374 "ret $4" )
2375
2376 void WINAPI process_ExitProcess( DWORD status )
2377 {
2378 LdrShutdownProcess();
2379 NtTerminateProcess(GetCurrentProcess(), status);
2380 exit(status);
2381 }
2382
2383 #else
2384
2385 void WINAPI ExitProcess( DWORD status )
2386 {
2387 LdrShutdownProcess();
2388 NtTerminateProcess(GetCurrentProcess(), status);
2389 exit(status);
2390 }
2391
2392 #endif
2393
2394 /***********************************************************************
2395 * GetExitCodeProcess [KERNEL32.@]
2396 *
2397 * Gets termination status of specified process.
2398 *
2399 * PARAMS
2400 * hProcess [in] Handle to the process.
2401 * lpExitCode [out] Address to receive termination status.
2402 *
2403 * RETURNS
2404 * Success: TRUE
2405 * Failure: FALSE
2406 */
2407 BOOL WINAPI GetExitCodeProcess( HANDLE hProcess, LPDWORD lpExitCode )
2408 {
2409 NTSTATUS status;
2410 PROCESS_BASIC_INFORMATION pbi;
2411
2412 status = NtQueryInformationProcess(hProcess, ProcessBasicInformation, &pbi,
2413 sizeof(pbi), NULL);
2414 if (status == STATUS_SUCCESS)
2415 {
2416 if (lpExitCode) *lpExitCode = pbi.ExitStatus;
2417 return TRUE;
2418 }
2419 SetLastError( RtlNtStatusToDosError(status) );
2420 return FALSE;
2421 }
2422
2423
2424 /***********************************************************************
2425 * SetErrorMode (KERNEL32.@)
2426 */
2427 UINT WINAPI SetErrorMode( UINT mode )
2428 {
2429 UINT old = process_error_mode;
2430 process_error_mode = mode;
2431 return old;
2432 }
2433
2434 /***********************************************************************
2435 * GetErrorMode (KERNEL32.@)
2436 */
2437 UINT WINAPI GetErrorMode( void )
2438 {
2439 return process_error_mode;
2440 }
2441
2442 /**********************************************************************
2443 * TlsAlloc [KERNEL32.@]
2444 *
2445 * Allocates a thread local storage index.
2446 *
2447 * RETURNS
2448 * Success: TLS index.
2449 * Failure: 0xFFFFFFFF
2450 */
2451 DWORD WINAPI TlsAlloc( void )
2452 {
2453 DWORD index;
2454 PEB * const peb = NtCurrentTeb()->Peb;
2455
2456 RtlAcquirePebLock();
2457 index = RtlFindClearBitsAndSet( peb->TlsBitmap, 1, 0 );
2458 if (index != ~0U) NtCurrentTeb()->TlsSlots[index] = 0; /* clear the value */
2459 else
2460 {
2461 index = RtlFindClearBitsAndSet( peb->TlsExpansionBitmap, 1, 0 );
2462 if (index != ~0U)
2463 {
2464 if (!NtCurrentTeb()->TlsExpansionSlots &&
2465 !(NtCurrentTeb()->TlsExpansionSlots = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
2466 8 * sizeof(peb->TlsExpansionBitmapBits) * sizeof(void*) )))
2467 {
2468 RtlClearBits( peb->TlsExpansionBitmap, index, 1 );
2469 index = ~0U;
2470 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
2471 }
2472 else
2473 {
2474 NtCurrentTeb()->TlsExpansionSlots[index] = 0; /* clear the value */
2475 index += TLS_MINIMUM_AVAILABLE;
2476 }
2477 }
2478 else SetLastError( ERROR_NO_MORE_ITEMS );
2479 }
2480 RtlReleasePebLock();
2481 return index;
2482 }
2483
2484
2485 /**********************************************************************
2486 * TlsFree [KERNEL32.@]
2487 *
2488 * Releases a thread local storage index, making it available for reuse.
2489 *
2490 * PARAMS
2491 * index [in] TLS index to free.
2492 *
2493 * RETURNS
2494 * Success: TRUE
2495 * Failure: FALSE
2496 */
2497 BOOL WINAPI TlsFree( DWORD index )
2498 {
2499 BOOL ret;
2500
2501 RtlAcquirePebLock();
2502 if (index >= TLS_MINIMUM_AVAILABLE)
2503 {
2504 ret = RtlAreBitsSet( NtCurrentTeb()->Peb->TlsExpansionBitmap, index - TLS_MINIMUM_AVAILABLE, 1 );
2505 if (ret) RtlClearBits( NtCurrentTeb()->Peb->TlsExpansionBitmap, index - TLS_MINIMUM_AVAILABLE, 1 );
2506 }
2507 else
2508 {
2509 ret = RtlAreBitsSet( NtCurrentTeb()->Peb->TlsBitmap, index, 1 );
2510 if (ret) RtlClearBits( NtCurrentTeb()->Peb->TlsBitmap, index, 1 );
2511 }
2512 if (ret) NtSetInformationThread( GetCurrentThread(), ThreadZeroTlsCell, &index, sizeof(index) );
2513 else SetLastError( ERROR_INVALID_PARAMETER );
2514 RtlReleasePebLock();
2515 return ret;
2516 }
2517
2518
2519 /**********************************************************************
2520 * TlsGetValue [KERNEL32.@]
2521 *
2522 * Gets value in a thread's TLS slot.
2523 *
2524 * PARAMS
2525 * index [in] TLS index to retrieve value for.
2526 *
2527 * RETURNS
2528 * Success: Value stored in calling thread's TLS slot for index.
2529 * Failure: 0 and GetLastError() returns NO_ERROR.
2530 */
2531 LPVOID WINAPI TlsGetValue( DWORD index )
2532 {
2533 LPVOID ret;
2534
2535 if (index < TLS_MINIMUM_AVAILABLE)
2536 {
2537 ret = NtCurrentTeb()->TlsSlots[index];
2538 }
2539 else
2540 {
2541 index -= TLS_MINIMUM_AVAILABLE;
2542 if (index >= 8 * sizeof(NtCurrentTeb()->Peb->TlsExpansionBitmapBits))
2543 {
2544 SetLastError( ERROR_INVALID_PARAMETER );
2545 return NULL;
2546 }
2547 if (!NtCurrentTeb()->TlsExpansionSlots) ret = NULL;
2548 else ret = NtCurrentTeb()->TlsExpansionSlots[index];
2549 }
2550 SetLastError( ERROR_SUCCESS );
2551 return ret;
2552 }
2553
2554
2555 /**********************************************************************
2556 * TlsSetValue [KERNEL32.@]
2557 *
2558 * Stores a value in the thread's TLS slot.
2559 *
2560 * PARAMS
2561 * index [in] TLS index to set value for.
2562 * value [in] Value to be stored.
2563 *
2564 * RETURNS
2565 * Success: TRUE
2566 * Failure: FALSE
2567 */
2568 BOOL WINAPI TlsSetValue( DWORD index, LPVOID value )
2569 {
2570 if (index < TLS_MINIMUM_AVAILABLE)
2571 {
2572 NtCurrentTeb()->TlsSlots[index] = value;
2573 }
2574 else
2575 {
2576 index -= TLS_MINIMUM_AVAILABLE;
2577 if (index >= 8 * sizeof(NtCurrentTeb()->Peb->TlsExpansionBitmapBits))
2578 {
2579 SetLastError( ERROR_INVALID_PARAMETER );
2580 return FALSE;
2581 }
2582 if (!NtCurrentTeb()->TlsExpansionSlots &&
2583 !(NtCurrentTeb()->TlsExpansionSlots = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
2584 8 * sizeof(NtCurrentTeb()->Peb->TlsExpansionBitmapBits) * sizeof(void*) )))
2585 {
2586 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
2587 return FALSE;
2588 }
2589 NtCurrentTeb()->TlsExpansionSlots[index] = value;
2590 }
2591 return TRUE;
2592 }
2593
2594
2595 /***********************************************************************
2596 * GetProcessFlags (KERNEL32.@)
2597 */
2598 DWORD WINAPI GetProcessFlags( DWORD processid )
2599 {
2600 IMAGE_NT_HEADERS *nt;
2601 DWORD flags = 0;
2602
2603 if (processid && processid != GetCurrentProcessId()) return 0;
2604
2605 if ((nt = RtlImageNtHeader( NtCurrentTeb()->Peb->ImageBaseAddress )))
2606 {
2607 if (nt->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI)
2608 flags |= PDB32_CONSOLE_PROC;
2609 }
2610 if (!AreFileApisANSI()) flags |= PDB32_FILE_APIS_OEM;
2611 if (IsDebuggerPresent()) flags |= PDB32_DEBUGGED;
2612 return flags;
2613 }
2614
2615
2616 /***********************************************************************
2617 * GetProcessDword (KERNEL32.18)
2618 */
2619 DWORD WINAPI GetProcessDword( DWORD dwProcessID, INT offset )
2620 {
2621 FIXME( "(%d, %d): not supported\n", dwProcessID, offset );
2622 return 0;
2623 }
2624
2625
2626 /*********************************************************************
2627 * OpenProcess (KERNEL32.@)
2628 *
2629 * Opens a handle to a process.
2630 *
2631 * PARAMS
2632 * access [I] Desired access rights assigned to the returned handle.
2633 * inherit [I] Determines whether or not child processes will inherit the handle.
2634 * id [I] Process identifier of the process to get a handle to.
2635 *
2636 * RETURNS
2637 * Success: Valid handle to the specified process.
2638 * Failure: NULL, check GetLastError().
2639 */
2640 HANDLE WINAPI OpenProcess( DWORD access, BOOL inherit, DWORD id )
2641 {
2642 NTSTATUS status;
2643 HANDLE handle;
2644 OBJECT_ATTRIBUTES attr;
2645 CLIENT_ID cid;
2646
2647 cid.UniqueProcess = ULongToHandle(id);
2648 cid.UniqueThread = 0; /* FIXME ? */
2649
2650 attr.Length = sizeof(OBJECT_ATTRIBUTES);
2651 attr.RootDirectory = NULL;
2652 attr.Attributes = inherit ? OBJ_INHERIT : 0;
2653 attr.SecurityDescriptor = NULL;
2654 attr.SecurityQualityOfService = NULL;
2655 attr.ObjectName = NULL;
2656
2657 if (GetVersion() & 0x80000000) access = PROCESS_ALL_ACCESS;
2658
2659 status = NtOpenProcess(&handle, access, &attr, &cid);
2660 if (status != STATUS_SUCCESS)
2661 {
2662 SetLastError( RtlNtStatusToDosError(status) );
2663 return NULL;
2664 }
2665 return handle;
2666 }
2667
2668
2669 /*********************************************************************
2670 * GetProcessId (KERNEL32.@)
2671 *
2672 * Gets the a unique identifier of a process.
2673 *
2674 * PARAMS
2675 * hProcess [I] Handle to the process.
2676 *
2677 * RETURNS
2678 * Success: TRUE.
2679 * Failure: FALSE, check GetLastError().
2680 *
2681 * NOTES
2682 *
2683 * The identifier is unique only on the machine and only until the process
2684 * exits (including system shutdown).
2685 */
2686 DWORD WINAPI GetProcessId( HANDLE hProcess )
2687 {
2688 NTSTATUS status;
2689 PROCESS_BASIC_INFORMATION pbi;
2690
2691 status = NtQueryInformationProcess(hProcess, ProcessBasicInformation, &pbi,
2692 sizeof(pbi), NULL);
2693 if (status == STATUS_SUCCESS) return pbi.UniqueProcessId;
2694 SetLastError( RtlNtStatusToDosError(status) );
2695 return 0;
2696 }
2697
2698
2699 /*********************************************************************
2700 * CloseHandle (KERNEL32.@)
2701 *
2702 * Closes a handle.
2703 *
2704 * PARAMS
2705 * handle [I] Handle to close.
2706 *
2707 * RETURNS
2708 * Success: TRUE.
2709 * Failure: FALSE, check GetLastError().
2710 */
2711 BOOL WINAPI CloseHandle( HANDLE handle )
2712 {
2713 NTSTATUS status;
2714
2715 /* stdio handles need special treatment */
2716 if ((handle == (HANDLE)STD_INPUT_HANDLE) ||
2717 (handle == (HANDLE)STD_OUTPUT_HANDLE) ||
2718 (handle == (HANDLE)STD_ERROR_HANDLE))
2719 handle = GetStdHandle( HandleToULong(handle) );
2720
2721 if (is_console_handle(handle))
2722 return CloseConsoleHandle(handle);
2723
2724 status = NtClose( handle );
2725 if (status) SetLastError( RtlNtStatusToDosError(status) );
2726 return !status;
2727 }
2728
2729
2730 /*********************************************************************
2731 * GetHandleInformation (KERNEL32.@)
2732 */
2733 BOOL WINAPI GetHandleInformation( HANDLE handle, LPDWORD flags )
2734 {
2735 OBJECT_DATA_INFORMATION info;
2736 NTSTATUS status = NtQueryObject( handle, ObjectDataInformation, &info, sizeof(info), NULL );
2737
2738 if (status) SetLastError( RtlNtStatusToDosError(status) );
2739 else if (flags)
2740 {
2741 *flags = 0;
2742 if (info.InheritHandle) *flags |= HANDLE_FLAG_INHERIT;
2743 if (info.ProtectFromClose) *flags |= HANDLE_FLAG_PROTECT_FROM_CLOSE;
2744 }
2745 return !status;
2746 }
2747
2748
2749 /*********************************************************************
2750 * SetHandleInformation (KERNEL32.@)
2751 */
2752 BOOL WINAPI SetHandleInformation( HANDLE handle, DWORD mask, DWORD flags )
2753 {
2754 OBJECT_DATA_INFORMATION info;
2755 NTSTATUS status;
2756
2757 /* if not setting both fields, retrieve current value first */
2758 if ((mask & (HANDLE_FLAG_INHERIT | HANDLE_FLAG_PROTECT_FROM_CLOSE)) !=
2759 (HANDLE_FLAG_INHERIT | HANDLE_FLAG_PROTECT_FROM_CLOSE))
2760 {
2761 if ((status = NtQueryObject( handle, ObjectDataInformation, &info, sizeof(info), NULL )))
2762 {
2763 SetLastError( RtlNtStatusToDosError(status) );
2764 return FALSE;
2765 }
2766 }
2767 if (mask & HANDLE_FLAG_INHERIT)
2768 info.InheritHandle = (flags & HANDLE_FLAG_INHERIT) != 0;
2769 if (mask & HANDLE_FLAG_PROTECT_FROM_CLOSE)
2770 info.ProtectFromClose = (flags & HANDLE_FLAG_PROTECT_FROM_CLOSE) != 0;
2771
2772 status = NtSetInformationObject( handle, ObjectDataInformation, &info, sizeof(info) );
2773 if (status) SetLastError( RtlNtStatusToDosError(status) );
2774 return !status;
2775 }
2776
2777
2778 /*********************************************************************
2779 * DuplicateHandle (KERNEL32.@)
2780 */
2781 BOOL WINAPI DuplicateHandle( HANDLE source_process, HANDLE source,
2782 HANDLE dest_process, HANDLE *dest,
2783 DWORD access, BOOL inherit, DWORD options )
2784 {
2785 NTSTATUS status;
2786
2787 if (is_console_handle(source))
2788 {
2789 /* FIXME: this test is not sufficient, we need to test process ids, not handles */
2790 if (source_process != dest_process ||
2791 source_process != GetCurrentProcess())
2792 {
2793 SetLastError(ERROR_INVALID_PARAMETER);
2794 return FALSE;
2795 }
2796 *dest = DuplicateConsoleHandle( source, access, inherit, options );
2797 return (*dest != INVALID_HANDLE_VALUE);
2798 }
2799 status = NtDuplicateObject( source_process, source, dest_process, dest,
2800 access, inherit ? OBJ_INHERIT : 0, options );
2801 if (status) SetLastError( RtlNtStatusToDosError(status) );
2802 return !status;
2803 }
2804
2805
2806 /***********************************************************************
2807 * ConvertToGlobalHandle (KERNEL32.@)
2808 */
2809 HANDLE WINAPI ConvertToGlobalHandle(HANDLE hSrc)
2810 {
2811 HANDLE ret = INVALID_HANDLE_VALUE;
2812 DuplicateHandle( GetCurrentProcess(), hSrc, GetCurrentProcess(), &ret, 0, FALSE,
2813 DUP_HANDLE_MAKE_GLOBAL | DUP_HANDLE_SAME_ACCESS | DUP_HANDLE_CLOSE_SOURCE );
2814 return ret;
2815 }
2816
2817
2818 /***********************************************************************
2819 * SetHandleContext (KERNEL32.@)
2820 */
2821 BOOL WINAPI SetHandleContext(HANDLE hnd,DWORD context)
2822 {
2823 FIXME("(%p,%d), stub. In case this got called by WSOCK32/WS2_32: "
2824 "the external WINSOCK DLLs won't work with WINE, don't use them.\n",hnd,context);
2825 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2826 return FALSE;
2827 }
2828
2829
2830 /***********************************************************************
2831 * GetHandleContext (KERNEL32.@)
2832 */
2833 DWORD WINAPI GetHandleContext(HANDLE hnd)
2834 {
2835 FIXME("(%p), stub. In case this got called by WSOCK32/WS2_32: "
2836 "the external WINSOCK DLLs won't work with WINE, don't use them.\n",hnd);
2837 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2838 return 0;
2839 }
2840
2841
2842 /***********************************************************************
2843 * CreateSocketHandle (KERNEL32.@)
2844 */
2845 HANDLE WINAPI CreateSocketHandle(void)
2846 {
2847 FIXME("(), stub. In case this got called by WSOCK32/WS2_32: "
2848 "the external WINSOCK DLLs won't work with WINE, don't use them.\n");
2849 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2850 return INVALID_HANDLE_VALUE;
2851 }
2852
2853
2854 /***********************************************************************
2855 * SetPriorityClass (KERNEL32.@)
2856 */
2857 BOOL WINAPI SetPriorityClass( HANDLE hprocess, DWORD priorityclass )
2858 {
2859 NTSTATUS status;
2860 PROCESS_PRIORITY_CLASS ppc;
2861
2862 ppc.Foreground = FALSE;
2863 switch (priorityclass)
2864 {
2865 case IDLE_PRIORITY_CLASS:
2866 ppc.PriorityClass = PROCESS_PRIOCLASS_IDLE; break;
2867 case BELOW_NORMAL_PRIORITY_CLASS:
2868 ppc.PriorityClass = PROCESS_PRIOCLASS_BELOW_NORMAL; break;
2869 case NORMAL_PRIORITY_CLASS:
2870 ppc.PriorityClass = PROCESS_PRIOCLASS_NORMAL; break;
2871 case ABOVE_NORMAL_PRIORITY_CLASS:
2872 ppc.PriorityClass = PROCESS_PRIOCLASS_ABOVE_NORMAL; break;
2873 case HIGH_PRIORITY_CLASS:
2874 ppc.PriorityClass = PROCESS_PRIOCLASS_HIGH; break;
2875 case REALTIME_PRIORITY_CLASS:
2876 ppc.PriorityClass = PROCESS_PRIOCLASS_REALTIME; break;
2877 default:
2878 SetLastError(ERROR_INVALID_PARAMETER);
2879 return FALSE;
2880 }
2881
2882 status = NtSetInformationProcess(hprocess, ProcessPriorityClass,
2883 &ppc, sizeof(ppc));
2884
2885 if (status != STATUS_SUCCESS)
2886 {
2887 SetLastError( RtlNtStatusToDosError(status) );
2888 return FALSE;
2889 }
2890 return TRUE;
2891 }
2892
2893
2894 /***********************************************************************
2895 * GetPriorityClass (KERNEL32.@)
2896 */
2897 DWORD WINAPI GetPriorityClass(HANDLE hProcess)
2898 {
2899 NTSTATUS status;
2900 PROCESS_BASIC_INFORMATION pbi;
2901
2902 status = NtQueryInformationProcess(hProcess, ProcessBasicInformation, &pbi,
2903 sizeof(pbi), NULL);
2904 if (status != STATUS_SUCCESS)
2905 {
2906 SetLastError( RtlNtStatusToDosError(status) );
2907 return 0;
2908 }
2909 switch (pbi.BasePriority)
2910 {
2911 case PROCESS_PRIOCLASS_IDLE: return IDLE_PRIORITY_CLASS;
2912 case PROCESS_PRIOCLASS_BELOW_NORMAL: return BELOW_NORMAL_PRIORITY_CLASS;
2913 case PROCESS_PRIOCLASS_NORMAL: return NORMAL_PRIORITY_CLASS;
2914 case PROCESS_PRIOCLASS_ABOVE_NORMAL: return ABOVE_NORMAL_PRIORITY_CLASS;
2915 case PROCESS_PRIOCLASS_HIGH: return HIGH_PRIORITY_CLASS;
2916 case PROCESS_PRIOCLASS_REALTIME: return REALTIME_PRIORITY_CLASS;
2917 }
2918 SetLastError( ERROR_INVALID_PARAMETER );
2919 return 0;
2920 }
2921
2922
2923 /***********************************************************************
2924 * SetProcessAffinityMask (KERNEL32.@)
2925 */
2926 BOOL WINAPI SetProcessAffinityMask( HANDLE hProcess, DWORD_PTR affmask )
2927 {
2928 NTSTATUS status;
2929
2930 status = NtSetInformationProcess(hProcess, ProcessAffinityMask,
2931 &affmask, sizeof(DWORD_PTR));
2932 if (status)
2933 {
2934 SetLastError( RtlNtStatusToDosError(status) );
2935 return FALSE;
2936 }
2937 return TRUE;
2938 }
2939
2940
2941 /**********************************************************************
2942 * GetProcessAffinityMask (KERNEL32.@)
2943 */
2944 BOOL WINAPI GetProcessAffinityMask( HANDLE hProcess,
2945 PDWORD_PTR lpProcessAffinityMask,
2946 PDWORD_PTR lpSystemAffinityMask )
2947 {
2948 PROCESS_BASIC_INFORMATION pbi;
2949 NTSTATUS status;
2950
2951 status = NtQueryInformationProcess(hProcess,
2952 ProcessBasicInformation,
2953 &pbi, sizeof(pbi), NULL);
2954 if (status)
2955 {
2956 SetLastError( RtlNtStatusToDosError(status) );
2957 return FALSE;
2958 }
2959 if (lpProcessAffinityMask) *lpProcessAffinityMask = pbi.AffinityMask;
2960 if (lpSystemAffinityMask) *lpSystemAffinityMask = (1 << NtCurrentTeb()->Peb->NumberOfProcessors) - 1;
2961 return TRUE;
2962 }
2963
2964
2965 /***********************************************************************
2966 * GetProcessVersion (KERNEL32.@)
2967 */
2968 DWORD WINAPI GetProcessVersion( DWORD pid )
2969 {
2970 HANDLE process;
2971 NTSTATUS status;
2972 PROCESS_BASIC_INFORMATION pbi;
2973 SIZE_T count;
2974 PEB peb;
2975 IMAGE_DOS_HEADER dos;
2976 IMAGE_NT_HEADERS nt;
2977 DWORD ver = 0;
2978
2979 if (!pid || pid == GetCurrentProcessId())
2980 {
2981 IMAGE_NT_HEADERS *nt;
2982
2983 if ((nt = RtlImageNtHeader( NtCurrentTeb()->Peb->ImageBaseAddress )))
2984 return ((nt->OptionalHeader.MajorSubsystemVersion << 16) |
2985 nt->OptionalHeader.MinorSubsystemVersion);
2986 return 0;
2987 }
2988
2989 process = OpenProcess(PROCESS_VM_READ | PROCESS_QUERY_INFORMATION, FALSE, pid);
2990 if (!process) return 0;
2991
2992 status = NtQueryInformationProcess(process, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
2993 if (status) goto err;
2994
2995 status = NtReadVirtualMemory(process, pbi.PebBaseAddress, &peb, sizeof(peb), &count);
2996 if (status || count != sizeof(peb)) goto err;
2997
2998 memset(&dos, 0, sizeof(dos));
2999 status = NtReadVirtualMemory(process, peb.ImageBaseAddress, &dos, sizeof(dos), &count);
3000 if (status || count != sizeof(dos)) goto err;
3001 if (dos.e_magic != IMAGE_DOS_SIGNATURE) goto err;
3002
3003 memset(&nt, 0, sizeof(nt));
3004 status = NtReadVirtualMemory(process, (char *)peb.ImageBaseAddress + dos.e_lfanew, &nt, sizeof(nt), &count);
3005 if (status || count != sizeof(nt)) goto err;
3006 if (nt.Signature != IMAGE_NT_SIGNATURE) goto err;
3007
3008 ver = MAKELONG(nt.OptionalHeader.MinorSubsystemVersion, nt.OptionalHeader.MajorSubsystemVersion);
3009
3010 err:
3011 CloseHandle(process);
3012
3013 if (status != STATUS_SUCCESS)
3014 SetLastError(RtlNtStatusToDosError(status));
3015
3016 return ver;
3017 }
3018
3019
3020 /***********************************************************************
3021 * SetProcessWorkingSetSize [KERNEL32.@]
3022 * Sets the min/max working set sizes for a specified process.
3023 *
3024 * PARAMS
3025 * hProcess [I] Handle to the process of interest
3026 * minset [I] Specifies minimum working set size
3027 * maxset [I] Specifies maximum working set size
3028 *
3029 * RETURNS
3030 * Success: TRUE
3031 * Failure: FALSE
3032 */
3033 BOOL WINAPI SetProcessWorkingSetSize(HANDLE hProcess, SIZE_T minset,
3034 SIZE_T maxset)
3035 {
3036 WARN("(%p,%ld,%ld): stub - harmless\n",hProcess,minset,maxset);
3037 if(( minset == (SIZE_T)-1) && (maxset == (SIZE_T)-1)) {
3038 /* Trim the working set to zero */
3039 /* Swap the process out of physical RAM */
3040 }
3041 return TRUE;
3042 }
3043
3044 /***********************************************************************
3045 * GetProcessWorkingSetSize (KERNEL32.@)
3046 */
3047 BOOL WINAPI GetProcessWorkingSetSize(HANDLE hProcess, PSIZE_T minset,
3048 PSIZE_T maxset)
3049 {
3050 FIXME("(%p,%p,%p): stub\n",hProcess,minset,maxset);
3051 /* 32 MB working set size */
3052 if (minset) *minset = 32*1024*1024;
3053 if (maxset) *maxset = 32*1024*1024;
3054 return TRUE;
3055 }
3056
3057
3058 /***********************************************************************
3059 * SetProcessShutdownParameters (KERNEL32.@)
3060 */
3061 BOOL WINAPI SetProcessShutdownParameters(DWORD level, DWORD flags)
3062 {
3063 FIXME("(%08x, %08x): partial stub.\n", level, flags);
3064 shutdown_flags = flags;
3065 shutdown_priority = level;
3066 return TRUE;
3067 }
3068
3069
3070 /***********************************************************************
3071 * GetProcessShutdownParameters (KERNEL32.@)
3072 *
3073 */
3074 BOOL WINAPI GetProcessShutdownParameters( LPDWORD lpdwLevel, LPDWORD lpdwFlags )
3075 {
3076 *lpdwLevel = shutdown_priority;
3077 *lpdwFlags = shutdown_flags;
3078 return TRUE;
3079 }
3080
3081
3082 /***********************************************************************
3083 * GetProcessPriorityBoost (KERNEL32.@)
3084 */
3085 BOOL WINAPI GetProcessPriorityBoost(HANDLE hprocess,PBOOL pDisablePriorityBoost)
3086 {
3087 FIXME("(%p,%p): semi-stub\n", hprocess, pDisablePriorityBoost);
3088
3089 /* Report that no boost is present.. */
3090 *pDisablePriorityBoost = FALSE;
3091
3092 return TRUE;
3093 }
3094
3095 /***********************************************************************
3096 * SetProcessPriorityBoost (KERNEL32.@)
3097 */
3098 BOOL WINAPI SetProcessPriorityBoost(HANDLE hprocess,BOOL disableboost)
3099 {
3100 FIXME("(%p,%d): stub\n",hprocess,disableboost);
3101 /* Say we can do it. I doubt the program will notice that we don't. */
3102 return TRUE;
3103 }
3104
3105
3106 /***********************************************************************
3107 * ReadProcessMemory (KERNEL32.@)
3108 */
3109 BOOL WINAPI ReadProcessMemory( HANDLE process, LPCVOID addr, LPVOID buffer, SIZE_T size,
3110 SIZE_T *bytes_read )
3111 {
3112 NTSTATUS status = NtReadVirtualMemory( process, addr, buffer, size, bytes_read );
3113 if (status) SetLastError( RtlNtStatusToDosError(status) );
3114 return !status;
3115 }
3116
3117
3118 /***********************************************************************
3119 * WriteProcessMemory (KERNEL32.@)
3120 */
3121 BOOL WINAPI WriteProcessMemory( HANDLE process, LPVOID addr, LPCVOID buffer, SIZE_T size,
3122 SIZE_T *bytes_written )
3123 {
3124 NTSTATUS status = NtWriteVirtualMemory( process, addr, buffer, size, bytes_written );
3125 if (status) SetLastError( RtlNtStatusToDosError(status) );
3126 return !status;
3127 }
3128
3129
3130 /****************************************************************************
3131 * FlushInstructionCache (KERNEL32.@)
3132 */
3133 BOOL WINAPI FlushInstructionCache(HANDLE hProcess, LPCVOID lpBaseAddress, SIZE_T dwSize)
3134 {
3135 NTSTATUS status;
3136 status = NtFlushInstructionCache( hProcess, lpBaseAddress, dwSize );
3137 if (status) SetLastError( RtlNtStatusToDosError(status) );
3138 return !status;
3139 }
3140
3141
3142 /******************************************************************
3143 * GetProcessIoCounters (KERNEL32.@)
3144 */
3145 BOOL WINAPI GetProcessIoCounters(HANDLE hProcess, PIO_COUNTERS ioc)
3146 {
3147 NTSTATUS status;
3148
3149 status = NtQueryInformationProcess(hProcess, ProcessIoCounters,
3150 ioc, sizeof(*ioc), NULL);
3151 if (status) SetLastError( RtlNtStatusToDosError(status) );
3152 return !status;
3153 }
3154
3155 /******************************************************************
3156 * GetProcessHandleCount (KERNEL32.@)
3157 */
3158 BOOL WINAPI GetProcessHandleCount(HANDLE hProcess, DWORD *cnt)
3159 {
3160 NTSTATUS status;
3161
3162 status = NtQueryInformationProcess(hProcess, ProcessHandleCount,
3163 cnt, sizeof(*cnt), NULL);
3164 if (status) SetLastError( RtlNtStatusToDosError(status) );
3165 return !status;
3166 }
3167
3168 /******************************************************************
3169 * QueryFullProcessImageNameA (KERNEL32.@)
3170 */
3171 BOOL WINAPI QueryFullProcessImageNameA(HANDLE hProcess, DWORD dwFlags, LPSTR lpExeName, PDWORD pdwSize)
3172 {
3173 BOOL retval;
3174 DWORD pdwSizeW = *pdwSize;
3175 LPWSTR lpExeNameW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *pdwSize * sizeof(WCHAR));
3176
3177 retval = QueryFullProcessImageNameW(hProcess, dwFlags, lpExeNameW, &pdwSizeW);
3178
3179 if(retval)
3180 retval = (0 != WideCharToMultiByte(CP_ACP, 0, lpExeNameW, -1,
3181 lpExeName, *pdwSize, NULL, NULL));
3182 if(retval)
3183 *pdwSize = strlen(lpExeName);
3184
3185 HeapFree(GetProcessHeap(), 0, lpExeNameW);
3186 return retval;
3187 }
3188
3189 /******************************************************************
3190 * QueryFullProcessImageNameW (KERNEL32.@)
3191 */
3192 BOOL WINAPI QueryFullProcessImageNameW(HANDLE hProcess, DWORD dwFlags, LPWSTR lpExeName, PDWORD pdwSize)
3193 {
3194 BYTE buffer[sizeof(UNICODE_STRING) + MAX_PATH*sizeof(WCHAR)]; /* this buffer should be enough */
3195 UNICODE_STRING *dynamic_buffer = NULL;
3196 UNICODE_STRING nt_path;
3197 UNICODE_STRING *result = NULL;
3198 NTSTATUS status;
3199 DWORD needed;
3200
3201 RtlInitUnicodeStringEx(&nt_path, NULL);
3202 /* FIXME: On Windows, ProcessImageFileName return an NT path. We rely that it being a DOS path,
3203 * as this is on Wine. */
3204 status = NtQueryInformationProcess(hProcess, ProcessImageFileName, buffer,
3205 sizeof(buffer) - sizeof(WCHAR), &needed);
3206 if (status == STATUS_INFO_LENGTH_MISMATCH)
3207 {
3208 dynamic_buffer = HeapAlloc(GetProcessHeap(), 0, needed + sizeof(WCHAR));
3209 status = NtQueryInformationProcess(hProcess, ProcessImageFileName, (LPBYTE)dynamic_buffer, needed, &needed);
3210 result = dynamic_buffer;
3211 }
3212 else
3213 result = (PUNICODE_STRING)buffer;
3214
3215 if (status) goto cleanup;
3216
3217 if (dwFlags & PROCESS_NAME_NATIVE)
3218 {
3219 result->Buffer[result->Length / sizeof(WCHAR)] = 0;
3220 if (!RtlDosPathNameToNtPathName_U(result->Buffer, &nt_path, NULL, NULL))
3221 {
3222 status = STATUS_OBJECT_PATH_NOT_FOUND;
3223 goto cleanup;
3224 }
3225 result = &nt_path;
3226 }
3227
3228 if (result->Length/sizeof(WCHAR) + 1 > *pdwSize)
3229 {
3230 status = STATUS_BUFFER_TOO_SMALL;
3231 goto cleanup;
3232 }
3233
3234 *pdwSize = result->Length/sizeof(WCHAR);
3235 memcpy( lpExeName, result->Buffer, result->Length );
3236 lpExeName[*pdwSize] = 0;
3237
3238 cleanup:
3239 HeapFree(GetProcessHeap(), 0, dynamic_buffer);
3240 RtlFreeUnicodeString(&nt_path);
3241 if (status) SetLastError( RtlNtStatusToDosError(status) );
3242 return !status;
3243 }
3244
3245 /***********************************************************************
3246 * ProcessIdToSessionId (KERNEL32.@)
3247 * This function is available on Terminal Server 4SP4 and Windows 2000
3248 */
3249 BOOL WINAPI ProcessIdToSessionId( DWORD procid, DWORD *sessionid_ptr )
3250 {
3251 /* According to MSDN, if the calling process is not in a terminal
3252 * services environment, then the sessionid returned is zero.
3253 */
3254 *sessionid_ptr = 0;
3255 return TRUE;
3256 }
3257
3258
3259 /***********************************************************************
3260 * RegisterServiceProcess (KERNEL32.@)
3261 *
3262 * A service process calls this function to ensure that it continues to run
3263 * even after a user logged off.
3264 */
3265 DWORD WINAPI RegisterServiceProcess(DWORD dwProcessId, DWORD dwType)
3266 {
3267 /* I don't think that Wine needs to do anything in this function */
3268 return 1; /* success */
3269 }
3270
3271
3272 /**********************************************************************
3273 * IsWow64Process (KERNEL32.@)
3274 */
3275 BOOL WINAPI IsWow64Process(HANDLE hProcess, PBOOL Wow64Process)
3276 {
3277 ULONG pbi;
3278 NTSTATUS status;
3279
3280 status = NtQueryInformationProcess( hProcess, ProcessWow64Information, &pbi, sizeof(pbi), NULL );
3281
3282 if (status != STATUS_SUCCESS)
3283 {
3284 SetLastError( RtlNtStatusToDosError( status ) );
3285 return FALSE;
3286 }
3287 *Wow64Process = (pbi != 0);
3288 return TRUE;
3289 }
3290
3291
3292 /***********************************************************************
3293 * GetCurrentProcess (KERNEL32.@)
3294 *
3295 * Get a handle to the current process.
3296 *
3297 * PARAMS
3298 * None.
3299 *
3300 * RETURNS
3301 * A handle representing the current process.
3302 */
3303 #undef GetCurrentProcess
3304 HANDLE WINAPI GetCurrentProcess(void)
3305 {
3306 return (HANDLE)~(ULONG_PTR)0;
3307 }
3308
3309 /***********************************************************************
3310 * CmdBatNotification (KERNEL32.@)
3311 *
3312 * Notifies the system that a batch file has started or finished.
3313 *
3314 * PARAMS
3315 * bBatchRunning [I] TRUE if a batch file has started or
3316 * FALSE if a batch file has finished executing.
3317 *
3318 * RETURNS
3319 * Unknown.
3320 */
3321 BOOL WINAPI CmdBatNotification( BOOL bBatchRunning )
3322 {
3323 FIXME("%d\n", bBatchRunning);
3324 return FALSE;
3325 }
3326
3327
3328 /***********************************************************************
3329 * RegisterApplicationRestart (KERNEL32.@)
3330 */
3331 HRESULT WINAPI RegisterApplicationRestart(PCWSTR pwzCommandLine, DWORD dwFlags)
3332 {
3333 FIXME("(%s,%d)\n", debugstr_w(pwzCommandLine), dwFlags);
3334
3335 return S_OK;
3336 }
3337
3338 /**********************************************************************
3339 * WTSGetActiveConsoleSessionId (KERNEL32.@)
3340 */
3341 DWORD WINAPI WTSGetActiveConsoleSessionId(void)
3342 {
3343 FIXME("stub\n");
3344 return 0;
3345 }
useful hacks and other patches not (yet) suitable for mainline