?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Avoid using wine_get_user_name() from libwine.
[wine.git] / dlls / ntdll / env.c
blobff0c8fbe906034c5ef38047f34d898fab2ae108e
1 /*
2 * Ntdll environment functions
3 *
4 * Copyright 1996, 1998 Alexandre Julliard
5 * Copyright 2003 Eric Pouech
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21 #include "config.h"
22
23 #include <assert.h>
24 #include <errno.h>
25 #include <stdarg.h>
26 #include <sys/types.h>
27 #ifdef HAVE_SYS_STAT_H
28 # include <sys/stat.h>
29 #endif
30 #ifdef HAVE_PWD_H
31 # include <pwd.h>
32 #endif
33 #ifdef HAVE_UNISTD_H
34 # include <unistd.h>
35 #endif
36
37 #include "ntstatus.h"
38 #define WIN32_NO_STATUS
39 #include "windef.h"
40 #include "winternl.h"
41 #include "wine/library.h"
42 #include "wine/debug.h"
43 #include "ntdll_misc.h"
44 #include "winnt.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(environ);
47
48 static WCHAR empty[] = {0};
49 static const UNICODE_STRING empty_str = { 0, sizeof(empty), empty };
50 static const UNICODE_STRING null_str = { 0, 0, NULL };
51
52 static const BOOL is_win64 = (sizeof(void *) > sizeof(int));
53
54 static const WCHAR windows_dir[] = {'C',':','\\','w','i','n','d','o','w','s',0};
55
56 static BOOL first_prefix_start; /* first ever process start in this prefix? */
57
58 static inline SIZE_T get_env_length( const WCHAR *env )
59 {
60 const WCHAR *end = env;
61 while (*end) end += wcslen(end) + 1;
62 return end + 1 - env;
63 }
64
65 #ifdef __APPLE__
66 extern char **__wine_get_main_environment(void);
67 #else
68 extern char **__wine_main_environ;
69 static char **__wine_get_main_environment(void) { return __wine_main_environ; }
70 #endif
71
72
73 /***********************************************************************
74 * is_special_env_var
75 *
76 * Check if an environment variable needs to be handled specially when
77 * passed through the Unix environment (i.e. prefixed with "WINE").
78 */
79 static inline BOOL is_special_env_var( const char *var )
80 {
81 return (!strncmp( var, "PATH=", sizeof("PATH=")-1 ) ||
82 !strncmp( var, "PWD=", sizeof("PWD=")-1 ) ||
83 !strncmp( var, "HOME=", sizeof("HOME=")-1 ) ||
84 !strncmp( var, "TEMP=", sizeof("TEMP=")-1 ) ||
85 !strncmp( var, "TMP=", sizeof("TMP=")-1 ) ||
86 !strncmp( var, "QT_", sizeof("QT_")-1 ) ||
87 !strncmp( var, "VK_", sizeof("VK_")-1 ));
88 }
89
90
91 /***********************************************************************
92 * set_env_var
93 */
94 static void set_env_var( WCHAR **env, const WCHAR *name, const WCHAR *val )
95 {
96 UNICODE_STRING nameW, valW;
97
98 RtlInitUnicodeString( &nameW, name );
99 RtlInitUnicodeString( &valW, val );
100 RtlSetEnvironmentVariable( env, &nameW, &valW );
101 }
102
103
104 /***********************************************************************
105 * set_registry_variables
106 *
107 * Set environment variables by enumerating the values of a key;
108 * helper for set_registry_environment().
109 * Note that Windows happily truncates the value if it's too big.
110 */
111 static void set_registry_variables( WCHAR **env, HANDLE hkey, ULONG type )
112 {
113 static const WCHAR pathW[] = {'P','A','T','H'};
114 static const WCHAR sep[] = {';',0};
115 UNICODE_STRING env_name, env_value;
116 NTSTATUS status;
117 DWORD size;
118 int index;
119 char buffer[1024*sizeof(WCHAR) + sizeof(KEY_VALUE_FULL_INFORMATION)];
120 WCHAR tmpbuf[1024];
121 UNICODE_STRING tmp;
122 KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
123
124 tmp.Buffer = tmpbuf;
125 tmp.MaximumLength = sizeof(tmpbuf);
126
127 for (index = 0; ; index++)
128 {
129 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
130 buffer, sizeof(buffer), &size );
131 if (status != STATUS_SUCCESS && status != STATUS_BUFFER_OVERFLOW) break;
132 if (info->Type != type) continue;
133 env_name.Buffer = info->Name;
134 env_name.Length = env_name.MaximumLength = info->NameLength;
135 env_value.Buffer = (WCHAR *)(buffer + info->DataOffset);
136 env_value.Length = info->DataLength;
137 env_value.MaximumLength = sizeof(buffer) - info->DataOffset;
138 if (env_value.Length && !env_value.Buffer[env_value.Length/sizeof(WCHAR)-1])
139 env_value.Length -= sizeof(WCHAR); /* don't count terminating null if any */
140 if (!env_value.Length) continue;
141 if (info->Type == REG_EXPAND_SZ)
142 {
143 status = RtlExpandEnvironmentStrings_U( *env, &env_value, &tmp, NULL );
144 if (status != STATUS_SUCCESS && status != STATUS_BUFFER_OVERFLOW) continue;
145 RtlCopyUnicodeString( &env_value, &tmp );
146 }
147 /* PATH is magic */
148 if (env_name.Length == sizeof(pathW) &&
149 !wcsnicmp( env_name.Buffer, pathW, ARRAY_SIZE( pathW )) &&
150 !RtlQueryEnvironmentVariable_U( *env, &env_name, &tmp ))
151 {
152 RtlAppendUnicodeToString( &tmp, sep );
153 if (RtlAppendUnicodeStringToString( &tmp, &env_value )) continue;
154 RtlCopyUnicodeString( &env_value, &tmp );
155 }
156 RtlSetEnvironmentVariable( env, &env_name, &env_value );
157 }
158 }
159
160
161 /***********************************************************************
162 * set_registry_environment
163 *
164 * Set the environment variables specified in the registry.
165 *
166 * Note: Windows handles REG_SZ and REG_EXPAND_SZ in one pass with the
167 * consequence that REG_EXPAND_SZ cannot be used reliably as it depends
168 * on the order in which the variables are processed. But on Windows it
169 * does not really matter since they only use %SystemDrive% and
170 * %SystemRoot% which are predefined. But Wine defines these in the
171 * registry, so we need two passes.
172 */
173 static BOOL set_registry_environment( WCHAR **env, BOOL first_time )
174 {
175 static const WCHAR env_keyW[] = {'\\','R','e','g','i','s','t','r','y','\\',
176 'M','a','c','h','i','n','e','\\',
177 'S','y','s','t','e','m','\\',
178 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
179 'C','o','n','t','r','o','l','\\',
180 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
181 'E','n','v','i','r','o','n','m','e','n','t',0};
182 static const WCHAR envW[] = {'E','n','v','i','r','o','n','m','e','n','t',0};
183 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};
184
185 OBJECT_ATTRIBUTES attr;
186 UNICODE_STRING nameW;
187 HANDLE hkey;
188 BOOL ret = FALSE;
189
190 /* first the system environment variables */
191 InitializeObjectAttributes( &attr, &nameW, 0, 0, NULL );
192 RtlInitUnicodeString( &nameW, env_keyW );
193 if (first_time && !NtOpenKey( &hkey, KEY_READ, &attr ))
194 {
195 set_registry_variables( env, hkey, REG_SZ );
196 set_registry_variables( env, hkey, REG_EXPAND_SZ );
197 NtClose( hkey );
198 }
199 else ret = TRUE;
200
201 /* then the ones for the current user */
202 if (RtlOpenCurrentUser( KEY_READ, &attr.RootDirectory ) != STATUS_SUCCESS) return ret;
203 RtlInitUnicodeString( &nameW, envW );
204 if (first_time && !NtOpenKey( &hkey, KEY_READ, &attr ))
205 {
206 set_registry_variables( env, hkey, REG_SZ );
207 set_registry_variables( env, hkey, REG_EXPAND_SZ );
208 NtClose( hkey );
209 }
210
211 RtlInitUnicodeString( &nameW, volatile_envW );
212 if (!NtOpenKey( &hkey, KEY_READ, &attr ))
213 {
214 set_registry_variables( env, hkey, REG_SZ );
215 set_registry_variables( env, hkey, REG_EXPAND_SZ );
216 NtClose( hkey );
217 }
218
219 NtClose( attr.RootDirectory );
220 return ret;
221 }
222
223
224 /***********************************************************************
225 * get_registry_value
226 */
227 static WCHAR *get_registry_value( WCHAR *env, HKEY hkey, const WCHAR *name )
228 {
229 char buffer[1024 * sizeof(WCHAR) + sizeof(KEY_VALUE_PARTIAL_INFORMATION)];
230 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
231 DWORD len, size = sizeof(buffer);
232 WCHAR *ret = NULL;
233 UNICODE_STRING nameW;
234
235 RtlInitUnicodeString( &nameW, name );
236 if (NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, buffer, size, &size ))
237 return NULL;
238
239 if (size <= FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data )) return NULL;
240 len = (size - FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data )) / sizeof(WCHAR);
241
242 if (info->Type == REG_EXPAND_SZ)
243 {
244 UNICODE_STRING value, expanded;
245
246 value.MaximumLength = len * sizeof(WCHAR);
247 value.Buffer = (WCHAR *)info->Data;
248 if (!value.Buffer[len - 1]) len--; /* don't count terminating null if any */
249 value.Length = len * sizeof(WCHAR);
250 expanded.Length = expanded.MaximumLength = 1024 * sizeof(WCHAR);
251 if (!(expanded.Buffer = RtlAllocateHeap( GetProcessHeap(), 0, expanded.MaximumLength )))
252 return NULL;
253 if (!RtlExpandEnvironmentStrings_U( env, &value, &expanded, NULL )) ret = expanded.Buffer;
254 else RtlFreeUnicodeString( &expanded );
255 }
256 else if (info->Type == REG_SZ)
257 {
258 if ((ret = RtlAllocateHeap( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) )))
259 {
260 memcpy( ret, info->Data, len * sizeof(WCHAR) );
261 ret[len] = 0;
262 }
263 }
264 return ret;
265 }
266
267
268 /***********************************************************************
269 * set_additional_environment
270 *
271 * Set some additional environment variables not specified in the registry.
272 */
273 static void set_additional_environment( WCHAR **env )
274 {
275 static const WCHAR profile_keyW[] = {'\\','R','e','g','i','s','t','r','y','\\',
276 'M','a','c','h','i','n','e','\\',
277 'S','o','f','t','w','a','r','e','\\',
278 'M','i','c','r','o','s','o','f','t','\\',
279 'W','i','n','d','o','w','s',' ','N','T','\\',
280 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
281 'P','r','o','f','i','l','e','L','i','s','t',0};
282 static const WCHAR computer_keyW[] = {'\\','R','e','g','i','s','t','r','y','\\',
283 'M','a','c','h','i','n','e','\\',
284 'S','y','s','t','e','m','\\',
285 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
286 'C','o','n','t','r','o','l','\\',
287 'C','o','m','p','u','t','e','r','N','a','m','e','\\',
288 'A','c','t','i','v','e','C','o','m','p','u','t','e','r','N','a','m','e',0};
289 static const WCHAR computer_valueW[] = {'C','o','m','p','u','t','e','r','N','a','m','e',0};
290 static const WCHAR public_valueW[] = {'P','u','b','l','i','c',0};
291 static const WCHAR computernameW[] = {'C','O','M','P','U','T','E','R','N','A','M','E',0};
292 static const WCHAR allusersW[] = {'A','L','L','U','S','E','R','S','P','R','O','F','I','L','E',0};
293 static const WCHAR programdataW[] = {'P','r','o','g','r','a','m','D','a','t','a',0};
294 static const WCHAR publicW[] = {'P','U','B','L','I','C',0};
295 OBJECT_ATTRIBUTES attr;
296 UNICODE_STRING nameW;
297 WCHAR *val;
298 HANDLE hkey;
299
300 /* set the user profile variables */
301
302 InitializeObjectAttributes( &attr, &nameW, 0, 0, NULL );
303 RtlInitUnicodeString( &nameW, profile_keyW );
304 if (!NtOpenKey( &hkey, KEY_READ, &attr ))
305 {
306 if ((val = get_registry_value( *env, hkey, programdataW )))
307 {
308 set_env_var( env, allusersW, val );
309 set_env_var( env, programdataW, val );
310 RtlFreeHeap( GetProcessHeap(), 0, val );
311 }
312 if ((val = get_registry_value( *env, hkey, public_valueW )))
313 {
314 set_env_var( env, publicW, val );
315 RtlFreeHeap( GetProcessHeap(), 0, val );
316 }
317 NtClose( hkey );
318 }
319
320 /* set the computer name */
321
322 RtlInitUnicodeString( &nameW, computer_keyW );
323 if (!NtOpenKey( &hkey, KEY_READ, &attr ))
324 {
325 if ((val = get_registry_value( *env, hkey, computer_valueW )))
326 {
327 set_env_var( env, computernameW, val );
328 RtlFreeHeap( GetProcessHeap(), 0, val );
329 }
330 NtClose( hkey );
331 }
332 }
333
334
335 /* set an environment variable for one of the wine path variables */
336 static void set_wine_path_variable( WCHAR **env, const WCHAR *name, const char *unix_path )
337 {
338 UNICODE_STRING nt_name, var_name;
339 ANSI_STRING unix_name;
340
341 RtlInitUnicodeString( &var_name, name );
342 if (unix_path)
343 {
344 RtlInitAnsiString( &unix_name, unix_path );
345 if (wine_unix_to_nt_file_name( &unix_name, &nt_name )) return;
346 RtlSetEnvironmentVariable( env, &var_name, &nt_name );
347 RtlFreeUnicodeString( &nt_name );
348 }
349 else RtlSetEnvironmentVariable( env, &var_name, NULL );
350 }
351
352
353 /***********************************************************************
354 * set_wow64_environment
355 *
356 * Set the environment variables that change across 32/64/Wow64.
357 */
358 static void set_wow64_environment( WCHAR **env )
359 {
360 static WCHAR archW[] = {'P','R','O','C','E','S','S','O','R','_','A','R','C','H','I','T','E','C','T','U','R','E',0};
361 static WCHAR arch6432W[] = {'P','R','O','C','E','S','S','O','R','_','A','R','C','H','I','T','E','W','6','4','3','2',0};
362 static const WCHAR x86W[] = {'x','8','6',0};
363 static const WCHAR versionW[] = {'\\','R','e','g','i','s','t','r','y','\\',
364 'M','a','c','h','i','n','e','\\',
365 'S','o','f','t','w','a','r','e','\\',
366 'M','i','c','r','o','s','o','f','t','\\',
367 'W','i','n','d','o','w','s','\\',
368 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
369 static const WCHAR progdirW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r',0};
370 static const WCHAR progdir86W[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r',' ','(','x','8','6',')',0};
371 static const WCHAR progfilesW[] = {'P','r','o','g','r','a','m','F','i','l','e','s',0};
372 static const WCHAR progfiles86W[] = {'P','r','o','g','r','a','m','F','i','l','e','s','(','x','8','6',')',0};
373 static const WCHAR progw6432W[] = {'P','r','o','g','r','a','m','W','6','4','3','2',0};
374 static const WCHAR commondirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',0};
375 static const WCHAR commondir86W[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',' ','(','x','8','6',')',0};
376 static const WCHAR commonfilesW[] = {'C','o','m','m','o','n','P','r','o','g','r','a','m','F','i','l','e','s',0};
377 static const WCHAR commonfiles86W[] = {'C','o','m','m','o','n','P','r','o','g','r','a','m','F','i','l','e','s','(','x','8','6',')',0};
378 static const WCHAR commonw6432W[] = {'C','o','m','m','o','n','P','r','o','g','r','a','m','W','6','4','3','2',0};
379 static const WCHAR winedlldirW[] = {'W','I','N','E','D','L','L','D','I','R','%','u',0};
380 static const WCHAR winehomedirW[] = {'W','I','N','E','H','O','M','E','D','I','R',0};
381 static const WCHAR winedatadirW[] = {'W','I','N','E','D','A','T','A','D','I','R',0};
382 static const WCHAR winebuilddirW[] = {'W','I','N','E','B','U','I','L','D','D','I','R',0};
383 static const WCHAR wineusernameW[] = {'W','I','N','E','U','S','E','R','N','A','M','E',0};
384 static const WCHAR wineconfigdirW[] = {'W','I','N','E','C','O','N','F','I','G','D','I','R',0};
385
386 WCHAR buf[256];
387 UNICODE_STRING arch_strW = { sizeof(archW) - sizeof(WCHAR), sizeof(archW), archW };
388 UNICODE_STRING arch6432_strW = { sizeof(arch6432W) - sizeof(WCHAR), sizeof(arch6432W), arch6432W };
389 UNICODE_STRING valW = { 0, sizeof(buf), buf };
390 OBJECT_ATTRIBUTES attr;
391 UNICODE_STRING nameW;
392 const char *p;
393 const char *home = getenv( "HOME" );
394 const char *name = getenv( "USER" );
395 WCHAR *val;
396 HANDLE hkey;
397 DWORD i;
398
399 if (!home || !name)
400 {
401 struct passwd *pwd = getpwuid( getuid() );
402 if (pwd)
403 {
404 if (!home) home = pwd->pw_dir;
405 if (!name) name = pwd->pw_name;
406 }
407 }
408
409 /* set the Wine paths */
410
411 set_wine_path_variable( env, winedatadirW, wine_get_data_dir() );
412 set_wine_path_variable( env, winehomedirW, home );
413 set_wine_path_variable( env, winebuilddirW, wine_get_build_dir() );
414 set_wine_path_variable( env, wineconfigdirW, config_dir );
415 for (i = 0; (p = wine_dll_enum_load_path( i )); i++)
416 {
417 NTDLL_swprintf( buf, winedlldirW, i );
418 set_wine_path_variable( env, buf, p );
419 }
420 NTDLL_swprintf( buf, winedlldirW, i );
421 set_wine_path_variable( env, buf, NULL );
422
423 /* set user name */
424
425 if (!name) name = "wine";
426 if ((p = strrchr( name, '/' ))) name = p + 1;
427 if ((p = strrchr( name, '\\' ))) name = p + 1;
428 ntdll_umbstowcs( name, strlen(name) + 1, buf, ARRAY_SIZE(buf) );
429 set_env_var( env, wineusernameW, buf );
430
431 /* set the PROCESSOR_ARCHITECTURE variable */
432
433 if (!RtlQueryEnvironmentVariable_U( *env, &arch6432_strW, &valW ))
434 {
435 if (is_win64)
436 {
437 RtlSetEnvironmentVariable( env, &arch_strW, &valW );
438 RtlSetEnvironmentVariable( env, &arch6432_strW, NULL );
439 }
440 }
441 else if (!RtlQueryEnvironmentVariable_U( *env, &arch_strW, &valW ))
442 {
443 if (is_wow64)
444 {
445 RtlSetEnvironmentVariable( env, &arch6432_strW, &valW );
446 RtlInitUnicodeString( &nameW, x86W );
447 RtlSetEnvironmentVariable( env, &arch_strW, &nameW );
448 }
449 }
450
451 InitializeObjectAttributes( &attr, &nameW, 0, 0, NULL );
452 RtlInitUnicodeString( &nameW, versionW );
453 if (NtOpenKey( &hkey, KEY_READ | KEY_WOW64_64KEY, &attr )) return;
454
455 /* set the ProgramFiles variables */
456
457 if ((val = get_registry_value( *env, hkey, progdirW )))
458 {
459 if (is_win64 || is_wow64) set_env_var( env, progw6432W, val );
460 if (is_win64 || !is_wow64) set_env_var( env, progfilesW, val );
461 RtlFreeHeap( GetProcessHeap(), 0, val );
462 }
463 if ((val = get_registry_value( *env, hkey, progdir86W )))
464 {
465 if (is_win64 || is_wow64) set_env_var( env, progfiles86W, val );
466 if (is_wow64) set_env_var( env, progfilesW, val );
467 RtlFreeHeap( GetProcessHeap(), 0, val );
468 }
469
470 /* set the CommonProgramFiles variables */
471
472 if ((val = get_registry_value( *env, hkey, commondirW )))
473 {
474 if (is_win64 || is_wow64) set_env_var( env, commonw6432W, val );
475 if (is_win64 || !is_wow64) set_env_var( env, commonfilesW, val );
476 RtlFreeHeap( GetProcessHeap(), 0, val );
477 }
478 if ((val = get_registry_value( *env, hkey, commondir86W )))
479 {
480 if (is_win64 || is_wow64) set_env_var( env, commonfiles86W, val );
481 if (is_wow64) set_env_var( env, commonfilesW, val );
482 RtlFreeHeap( GetProcessHeap(), 0, val );
483 }
484 NtClose( hkey );
485 }
486
487
488 /***********************************************************************
489 * build_initial_environment
490 *
491 * Build the Win32 environment from the Unix environment
492 */
493 static WCHAR *build_initial_environment( char **env )
494 {
495 SIZE_T size = 1;
496 char **e;
497 WCHAR *p, *ptr;
498
499 /* compute the total size of the Unix environment */
500
501 for (e = env; *e; e++)
502 {
503 if (is_special_env_var( *e )) continue;
504 size += strlen(*e) + 1;
505 }
506
507 if (!(ptr = RtlAllocateHeap( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return NULL;
508 p = ptr;
509
510 /* and fill it with the Unix environment */
511
512 for (e = env; *e; e++)
513 {
514 char *str = *e;
515
516 /* skip Unix special variables and use the Wine variants instead */
517 if (!strncmp( str, "WINE", 4 ))
518 {
519 if (is_special_env_var( str + 4 )) str += 4;
520 else if (!strncmp( str, "WINEPRELOADRESERVE=", 19 )) continue; /* skip it */
521 }
522 else if (is_special_env_var( str )) continue; /* skip it */
523
524 ntdll_umbstowcs( str, strlen(str) + 1, p, size - (p - ptr) );
525 p += wcslen(p) + 1;
526 }
527 *p = 0;
528 first_prefix_start = set_registry_environment( &ptr, TRUE );
529 set_additional_environment( &ptr );
530 return ptr;
531 }
532
533
534 /***********************************************************************
535 * build_envp
536 *
537 * Build the environment of a new child process.
538 */
539 char **build_envp( const WCHAR *envW )
540 {
541 static const char * const unix_vars[] = { "PATH", "TEMP", "TMP", "HOME" };
542 char **envp;
543 char *env, *p;
544 int count = 1, length, lenW;
545 unsigned int i;
546
547 lenW = get_env_length( envW );
548 if (!(env = RtlAllocateHeap( GetProcessHeap(), 0, lenW * 3 ))) return NULL;
549 length = ntdll_wcstoumbs( envW, lenW, env, lenW * 3, FALSE );
550
551 for (p = env; *p; p += strlen(p) + 1, count++)
552 if (is_special_env_var( p )) length += 4; /* prefix it with "WINE" */
553
554 for (i = 0; i < ARRAY_SIZE( unix_vars ); i++)
555 {
556 if (!(p = getenv(unix_vars[i]))) continue;
557 length += strlen(unix_vars[i]) + strlen(p) + 2;
558 count++;
559 }
560
561 if ((envp = RtlAllocateHeap( GetProcessHeap(), 0, count * sizeof(*envp) + length )))
562 {
563 char **envptr = envp;
564 char *dst = (char *)(envp + count);
565
566 /* some variables must not be modified, so we get them directly from the unix env */
567 for (i = 0; i < ARRAY_SIZE( unix_vars ); i++)
568 {
569 if (!(p = getenv( unix_vars[i] ))) continue;
570 *envptr++ = strcpy( dst, unix_vars[i] );
571 strcat( dst, "=" );
572 strcat( dst, p );
573 dst += strlen(dst) + 1;
574 }
575
576 /* now put the Windows environment strings */
577 for (p = env; *p; p += strlen(p) + 1)
578 {
579 if (*p == '=') continue; /* skip drive curdirs, this crashes some unix apps */
580 if (!strncmp( p, "WINEPRELOADRESERVE=", sizeof("WINEPRELOADRESERVE=")-1 )) continue;
581 if (!strncmp( p, "WINELOADERNOEXEC=", sizeof("WINELOADERNOEXEC=")-1 )) continue;
582 if (!strncmp( p, "WINESERVERSOCKET=", sizeof("WINESERVERSOCKET=")-1 )) continue;
583 if (is_special_env_var( p )) /* prefix it with "WINE" */
584 {
585 *envptr++ = strcpy( dst, "WINE" );
586 strcat( dst, p );
587 }
588 else
589 {
590 *envptr++ = strcpy( dst, p );
591 }
592 dst += strlen(dst) + 1;
593 }
594 *envptr = 0;
595 }
596 RtlFreeHeap( GetProcessHeap(), 0, env );
597 return envp;
598 }
599
600
601 /***********************************************************************
602 * get_current_directory
603 *
604 * Initialize the current directory from the Unix cwd.
605 */
606 static void get_current_directory( UNICODE_STRING *dir )
607 {
608 const char *pwd;
609 char *cwd;
610 int size;
611
612 dir->Length = 0;
613
614 /* try to get it from the Unix cwd */
615
616 for (size = 1024; ; size *= 2)
617 {
618 if (!(cwd = RtlAllocateHeap( GetProcessHeap(), 0, size ))) break;
619 if (getcwd( cwd, size )) break;
620 RtlFreeHeap( GetProcessHeap(), 0, cwd );
621 if (errno == ERANGE) continue;
622 cwd = NULL;
623 break;
624 }
625
626 /* try to use PWD if it is valid, so that we don't resolve symlinks */
627
628 pwd = getenv( "PWD" );
629 if (cwd)
630 {
631 struct stat st1, st2;
632
633 if (!pwd || stat( pwd, &st1 ) == -1 ||
634 (!stat( cwd, &st2 ) && (st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino)))
635 pwd = cwd;
636 }
637
638 if (pwd)
639 {
640 ANSI_STRING unix_name;
641 UNICODE_STRING nt_name;
642
643 RtlInitAnsiString( &unix_name, pwd );
644 if (!wine_unix_to_nt_file_name( &unix_name, &nt_name ))
645 {
646 /* skip the \??\ prefix */
647 if (nt_name.Length > 6 * sizeof(WCHAR) && nt_name.Buffer[5] == ':')
648 {
649 dir->Length = nt_name.Length - 4 * sizeof(WCHAR);
650 memcpy( dir->Buffer, nt_name.Buffer + 4, dir->Length );
651 }
652 else /* change \??\ to \\?\ */
653 {
654 dir->Length = nt_name.Length;
655 memcpy( dir->Buffer, nt_name.Buffer, dir->Length );
656 dir->Buffer[1] = '\\';
657 }
658 RtlFreeUnicodeString( &nt_name );
659 }
660 }
661
662 if (!dir->Length) /* still not initialized */
663 {
664 MESSAGE("Warning: could not find DOS drive for current working directory '%s', "
665 "starting in the Windows directory.\n", cwd ? cwd : "" );
666 dir->Length = wcslen( windows_dir ) * sizeof(WCHAR);
667 memcpy( dir->Buffer, windows_dir, dir->Length );
668 }
669 RtlFreeHeap( GetProcessHeap(), 0, cwd );
670
671 /* add trailing backslash */
672 if (dir->Buffer[dir->Length / sizeof(WCHAR) - 1] != '\\')
673 {
674 dir->Buffer[dir->Length / sizeof(WCHAR)] = '\\';
675 dir->Length += sizeof(WCHAR);
676 }
677 dir->Buffer[dir->Length / sizeof(WCHAR)] = 0;
678 }
679
680
681 /***********************************************************************
682 * is_path_prefix
683 */
684 static inline BOOL is_path_prefix( const WCHAR *prefix, const WCHAR *path, const WCHAR *file )
685 {
686 DWORD len = wcslen( prefix );
687
688 if (wcsnicmp( path, prefix, len )) return FALSE;
689 while (path[len] == '\\') len++;
690 return path + len == file;
691 }
692
693
694 /***********************************************************************
695 * get_image_path
696 */
697 static void get_image_path( const char *argv0, UNICODE_STRING *path )
698 {
699 static const WCHAR exeW[] = {'.','e','x','e',0};
700 WCHAR *load_path, *file_part, *name, full_name[MAX_PATH];
701 DWORD len = strlen(argv0) + 1;
702
703 if (!(name = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) goto failed;
704 ntdll_umbstowcs( argv0, len, name, len );
705
706 if (RtlDetermineDosPathNameType_U( name ) != RELATIVE_PATH ||
707 wcschr( name, '/' ) || wcschr( name, '\\' ))
708 {
709 len = RtlGetFullPathName_U( name, sizeof(full_name), full_name, &file_part );
710 if (!len || len > sizeof(full_name)) goto failed;
711 /* try first without extension */
712 if (RtlDoesFileExists_U( full_name )) goto done;
713 if (len < (MAX_PATH - 4) * sizeof(WCHAR) && !wcschr( file_part, '.' ))
714 {
715 wcscat( file_part, exeW );
716 if (RtlDoesFileExists_U( full_name )) goto done;
717 }
718 /* check for builtin path inside system directory */
719 if (!is_path_prefix( system_dir, full_name, file_part ))
720 {
721 if (!is_win64 && !is_wow64) goto failed;
722 if (!is_path_prefix( syswow64_dir, full_name, file_part )) goto failed;
723 }
724 }
725 else
726 {
727 RtlGetExePath( name, &load_path );
728 len = RtlDosSearchPath_U( load_path, name, exeW, sizeof(full_name), full_name, &file_part );
729 RtlReleasePath( load_path );
730 if (!len || len > sizeof(full_name))
731 {
732 /* build builtin path inside system directory */
733 len = wcslen( system_dir );
734 if (wcslen( name ) >= MAX_PATH - 4 - len) goto failed;
735 wcscpy( full_name, system_dir );
736 wcscat( full_name, name );
737 if (!wcschr( name, '.' )) wcscat( full_name, exeW );
738 }
739 }
740 done:
741 RtlCreateUnicodeString( path, full_name );
742 RtlFreeHeap( GetProcessHeap(), 0, name );
743 return;
744
745 failed:
746 MESSAGE( "wine: cannot find '%s'\n", argv0 );
747 RtlExitUserProcess( GetLastError() );
748 }
749
750
751 /***********************************************************************
752 * set_library_wargv
753 *
754 * Set the Wine library Unicode argv global variables.
755 */
756 static void set_library_wargv( char **argv, const UNICODE_STRING *image )
757 {
758 int argc;
759 WCHAR *p, **wargv;
760 DWORD total = 0;
761
762 if (image) total += 1 + image->Length / sizeof(WCHAR);
763 for (argc = (image != NULL); argv[argc]; argc++) total += strlen(argv[argc]) + 1;
764
765 wargv = RtlAllocateHeap( GetProcessHeap(), 0,
766 total * sizeof(WCHAR) + (argc + 1) * sizeof(*wargv) );
767 p = (WCHAR *)(wargv + argc + 1);
768 if (image)
769 {
770 wcscpy( p, image->Buffer );
771 wargv[0] = p;
772 p += 1 + image->Length / sizeof(WCHAR);
773 total -= 1 + image->Length / sizeof(WCHAR);
774 }
775 for (argc = (image != NULL); argv[argc]; argc++)
776 {
777 DWORD reslen = ntdll_umbstowcs( argv[argc], strlen(argv[argc]) + 1, p, total );
778 wargv[argc] = p;
779 p += reslen;
780 total -= reslen;
781 }
782 wargv[argc] = NULL;
783
784 __wine_main_argc = argc;
785 __wine_main_wargv = wargv;
786 }
787
788
789 /***********************************************************************
790 * build_command_line
791 *
792 * Build the command line of a process from the argv array.
793 *
794 * Note that it does NOT necessarily include the file name.
795 * Sometimes we don't even have any command line options at all.
796 *
797 * We must quote and escape characters so that the argv array can be rebuilt
798 * from the command line:
799 * - spaces and tabs must be quoted
800 * 'a b' -> '"a b"'
801 * - quotes must be escaped
802 * '"' -> '\"'
803 * - if '\'s are followed by a '"', they must be doubled and followed by '\"',
804 * resulting in an odd number of '\' followed by a '"'
805 * '\"' -> '\\\"'
806 * '\\"' -> '\\\\\"'
807 * - '\'s are followed by the closing '"' must be doubled,
808 * resulting in an even number of '\' followed by a '"'
809 * ' \' -> '" \\"'
810 * ' \\' -> '" \\\\"'
811 * - '\'s that are not followed by a '"' can be left as is
812 * 'a\b' == 'a\b'
813 * 'a\\b' == 'a\\b'
814 */
815 static void build_command_line( WCHAR **argv, UNICODE_STRING *cmdline )
816 {
817 int len;
818 WCHAR **arg;
819 LPWSTR p;
820
821 len = 1;
822 for (arg = argv; *arg; arg++) len += 3 + 2 * wcslen( *arg );
823 cmdline->MaximumLength = len * sizeof(WCHAR);
824 if (!(cmdline->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, cmdline->MaximumLength ))) return;
825
826 p = cmdline->Buffer;
827 for (arg = argv; *arg; arg++)
828 {
829 BOOL has_space, has_quote;
830 int i, bcount;
831 WCHAR *a;
832
833 /* check for quotes and spaces in this argument */
834 if (arg == argv || !**arg) has_space = TRUE;
835 else has_space = wcschr( *arg, ' ' ) || wcschr( *arg, '\t' );
836 has_quote = wcschr( *arg, '"' ) != NULL;
837
838 /* now transfer it to the command line */
839 if (has_space) *p++ = '"';
840 if (has_quote || has_space)
841 {
842 bcount = 0;
843 for (a = *arg; *a; a++)
844 {
845 if (*a == '\\') bcount++;
846 else
847 {
848 if (*a == '"') /* double all the '\\' preceding this '"', plus one */
849 for (i = 0; i <= bcount; i++) *p++ = '\\';
850 bcount = 0;
851 }
852 *p++ = *a;
853 }
854 }
855 else
856 {
857 wcscpy( p, *arg );
858 p += wcslen( p );
859 }
860 if (has_space)
861 {
862 /* Double all the '\' preceding the closing quote */
863 for (i = 0; i < bcount; i++) *p++ = '\\';
864 *p++ = '"';
865 }
866 *p++ = ' ';
867 }
868 if (p > cmdline->Buffer) p--; /* remove last space */
869 *p = 0;
870 cmdline->Length = (p - cmdline->Buffer) * sizeof(WCHAR);
871 }
872
873
874 /******************************************************************************
875 * NtQuerySystemEnvironmentValue [NTDLL.@]
876 */
877 NTSYSAPI NTSTATUS WINAPI NtQuerySystemEnvironmentValue(PUNICODE_STRING VariableName,
878 PWCHAR Value,
879 ULONG ValueBufferLength,
880 PULONG RequiredLength)
881 {
882 FIXME("(%s, %p, %u, %p), stub\n", debugstr_us(VariableName), Value, ValueBufferLength, RequiredLength);
883 return STATUS_NOT_IMPLEMENTED;
884 }
885
886 /******************************************************************************
887 * NtQuerySystemEnvironmentValueEx [NTDLL.@]
888 */
889 NTSYSAPI NTSTATUS WINAPI NtQuerySystemEnvironmentValueEx(PUNICODE_STRING name, LPGUID vendor,
890 PVOID value, PULONG retlength, PULONG attrib)
891 {
892 FIXME("(%s, %s, %p, %p, %p), stub\n", debugstr_us(name), debugstr_guid(vendor), value, retlength, attrib);
893 return STATUS_NOT_IMPLEMENTED;
894 }
895
896 /******************************************************************************
897 * RtlCreateEnvironment [NTDLL.@]
898 */
899 NTSTATUS WINAPI RtlCreateEnvironment(BOOLEAN inherit, PWSTR* env)
900 {
901 SIZE_T size;
902
903 TRACE("(%u,%p)!\n", inherit, env);
904
905 if (inherit)
906 {
907 RtlAcquirePebLock();
908 size = get_env_length( NtCurrentTeb()->Peb->ProcessParameters->Environment ) * sizeof(WCHAR);
909 if ((*env = RtlAllocateHeap( GetProcessHeap(), 0, size )))
910 memcpy( *env, NtCurrentTeb()->Peb->ProcessParameters->Environment, size );
911 RtlReleasePebLock();
912 }
913 else *env = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR) );
914
915 return *env ? STATUS_SUCCESS : STATUS_NO_MEMORY;
916 }
917
918 /******************************************************************************
919 * RtlDestroyEnvironment [NTDLL.@]
920 */
921 NTSTATUS WINAPI RtlDestroyEnvironment(PWSTR env)
922 {
923 RtlFreeHeap( GetProcessHeap(), 0, env );
924 return STATUS_SUCCESS;
925 }
926
927 static LPCWSTR ENV_FindVariable(PCWSTR var, PCWSTR name, unsigned namelen)
928 {
929 while (*var)
930 {
931 /* match var names, but avoid setting a var with a name including a '='
932 * (a starting '=' is valid though)
933 */
934 unsigned int len = wcslen( var );
935 if (len > namelen &&
936 var[namelen] == '=' &&
937 !RtlCompareUnicodeStrings( var, namelen, name, namelen, TRUE ) &&
938 wcschr(var + 1, '=') == var + namelen)
939 {
940 return var + namelen + 1;
941 }
942 var += len + 1;
943 }
944 return NULL;
945 }
946
947 /******************************************************************
948 * RtlQueryEnvironmentVariable_U [NTDLL.@]
949 *
950 * NOTES: when the buffer is too small, the string is not written, but if the
951 * terminating null char is the only char that cannot be written, then
952 * all chars (except the null) are written and success is returned
953 * (behavior of Win2k at least)
954 */
955 NTSTATUS WINAPI RtlQueryEnvironmentVariable_U(PWSTR env,
956 PUNICODE_STRING name,
957 PUNICODE_STRING value)
958 {
959 NTSTATUS nts = STATUS_VARIABLE_NOT_FOUND;
960 PCWSTR var;
961 unsigned namelen;
962
963 TRACE("%p %s %p\n", env, debugstr_us(name), value);
964
965 value->Length = 0;
966 namelen = name->Length / sizeof(WCHAR);
967 if (!namelen) return nts;
968
969 if (!env)
970 {
971 RtlAcquirePebLock();
972 var = NtCurrentTeb()->Peb->ProcessParameters->Environment;
973 }
974 else var = env;
975
976 var = ENV_FindVariable(var, name->Buffer, namelen);
977 if (var != NULL)
978 {
979 value->Length = wcslen(var) * sizeof(WCHAR);
980
981 if (value->Length <= value->MaximumLength)
982 {
983 memmove(value->Buffer, var, min(value->Length + sizeof(WCHAR), value->MaximumLength));
984 nts = STATUS_SUCCESS;
985 }
986 else nts = STATUS_BUFFER_TOO_SMALL;
987 }
988
989 if (!env) RtlReleasePebLock();
990
991 return nts;
992 }
993
994 /******************************************************************
995 * RtlSetCurrentEnvironment [NTDLL.@]
996 *
997 */
998 void WINAPI RtlSetCurrentEnvironment(PWSTR new_env, PWSTR* old_env)
999 {
1000 TRACE("(%p %p)\n", new_env, old_env);
1001
1002 RtlAcquirePebLock();
1003
1004 if (old_env) *old_env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
1005 NtCurrentTeb()->Peb->ProcessParameters->Environment = new_env;
1006
1007 RtlReleasePebLock();
1008 }
1009
1010
1011 /******************************************************************************
1012 * RtlSetEnvironmentVariable [NTDLL.@]
1013 */
1014 NTSTATUS WINAPI RtlSetEnvironmentVariable(PWSTR* penv, PUNICODE_STRING name,
1015 PUNICODE_STRING value)
1016 {
1017 INT varlen, len, old_size;
1018 LPWSTR p, env;
1019 NTSTATUS nts = STATUS_VARIABLE_NOT_FOUND;
1020
1021 TRACE("(%p, %s, %s)\n", penv, debugstr_us(name), debugstr_us(value));
1022
1023 if (!name || !name->Buffer || !name->Length)
1024 return STATUS_INVALID_PARAMETER_1;
1025
1026 len = name->Length / sizeof(WCHAR);
1027
1028 /* variable names can't contain a '=' except as a first character */
1029 for (p = name->Buffer + 1; p < name->Buffer + len; p++)
1030 if (*p == '=') return STATUS_INVALID_PARAMETER;
1031
1032 if (!penv)
1033 {
1034 RtlAcquirePebLock();
1035 env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
1036 } else env = *penv;
1037
1038 old_size = get_env_length( env );
1039
1040 /* Find a place to insert the string */
1041 for (p = env; *p; p += varlen + 1)
1042 {
1043 varlen = wcslen(p);
1044 if (varlen > len && p[len] == '=' &&
1045 !RtlCompareUnicodeStrings( name->Buffer, len, p, len, TRUE )) break;
1046 }
1047 if (!value && !*p) goto done; /* Value to remove doesn't exist */
1048
1049 /* Realloc the buffer */
1050 len = value ? len + value->Length / sizeof(WCHAR) + 2 : 0;
1051 if (*p) len -= wcslen(p) + 1; /* The name already exists */
1052
1053 if (len < 0)
1054 {
1055 LPWSTR next = p + wcslen(p) + 1; /* We know there is a next one */
1056 memmove(next + len, next, (old_size - (next - env)) * sizeof(WCHAR));
1057 }
1058
1059 if ((old_size + len) * sizeof(WCHAR) > RtlSizeHeap( GetProcessHeap(), 0, env ))
1060 {
1061 SIZE_T new_size = max( old_size * 2, old_size + len ) * sizeof(WCHAR);
1062 LPWSTR new_env = RtlAllocateHeap( GetProcessHeap(), 0, new_size );
1063
1064 if (!new_env)
1065 {
1066 nts = STATUS_NO_MEMORY;
1067 goto done;
1068 }
1069 memmove(new_env, env, (p - env) * sizeof(WCHAR));
1070 assert(len > 0);
1071 memmove(new_env + (p - env) + len, p, (old_size - (p - env)) * sizeof(WCHAR));
1072 p = new_env + (p - env);
1073
1074 RtlDestroyEnvironment(env);
1075 if (!penv) NtCurrentTeb()->Peb->ProcessParameters->Environment = new_env;
1076 else *penv = new_env;
1077 }
1078 else
1079 {
1080 if (len > 0) memmove(p + len, p, (old_size - (p - env)) * sizeof(WCHAR));
1081 }
1082
1083 /* Set the new string */
1084 if (value)
1085 {
1086 memcpy( p, name->Buffer, name->Length );
1087 p += name->Length / sizeof(WCHAR);
1088 *p++ = '=';
1089 memcpy( p, value->Buffer, value->Length );
1090 p[value->Length / sizeof(WCHAR)] = 0;
1091 }
1092 nts = STATUS_SUCCESS;
1093
1094 done:
1095 if (!penv) RtlReleasePebLock();
1096
1097 return nts;
1098 }
1099
1100 /******************************************************************************
1101 * RtlExpandEnvironmentStrings (NTDLL.@)
1102 */
1103 NTSTATUS WINAPI RtlExpandEnvironmentStrings( const WCHAR *renv, WCHAR *src, SIZE_T src_len,
1104 WCHAR *dst, SIZE_T count, SIZE_T *plen )
1105 {
1106 SIZE_T len, total_size = 1; /* 1 for terminating '\0' */
1107 LPCWSTR env, var;
1108
1109 if (!renv)
1110 {
1111 RtlAcquirePebLock();
1112 env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
1113 }
1114 else env = renv;
1115
1116 while (src_len)
1117 {
1118 if (*src != '%')
1119 {
1120 for (len = 0; len < src_len; len++) if (src[len] == '%') break;
1121 var = src;
1122 src += len;
1123 src_len -= len;
1124 }
1125 else /* we are at the start of a variable */
1126 {
1127 for (len = 1; len < src_len; len++) if (src[len] == '%') break;
1128 if (len < src_len)
1129 {
1130 if ((var = ENV_FindVariable( env, src + 1, len - 1 )))
1131 {
1132 src += len + 1; /* Skip the variable name */
1133 src_len -= len + 1;
1134 len = wcslen(var);
1135 }
1136 else
1137 {
1138 var = src; /* Copy original name instead */
1139 len++;
1140 src += len;
1141 src_len -= len;
1142 }
1143 }
1144 else /* unfinished variable name, ignore it */
1145 {
1146 var = src;
1147 src += len;
1148 src_len = 0;
1149 }
1150 }
1151 total_size += len;
1152 if (dst)
1153 {
1154 if (count < len) len = count;
1155 memcpy(dst, var, len * sizeof(WCHAR));
1156 count -= len;
1157 dst += len;
1158 }
1159 }
1160
1161 if (!renv) RtlReleasePebLock();
1162
1163 if (dst && count) *dst = '\0';
1164 if (plen) *plen = total_size;
1165
1166 return (count) ? STATUS_SUCCESS : STATUS_BUFFER_TOO_SMALL;
1167 }
1168
1169 /******************************************************************
1170 * RtlExpandEnvironmentStrings_U (NTDLL.@)
1171 */
1172 NTSTATUS WINAPI RtlExpandEnvironmentStrings_U( const WCHAR *env, const UNICODE_STRING *src,
1173 UNICODE_STRING *dst, ULONG *plen )
1174 {
1175 SIZE_T len;
1176 NTSTATUS ret;
1177
1178 ret = RtlExpandEnvironmentStrings( env, src->Buffer, src->Length / sizeof(WCHAR),
1179 dst->Buffer, dst->MaximumLength / sizeof(WCHAR), &len );
1180 if (plen) *plen = len * sizeof(WCHAR); /* FIXME: check for overflow? */
1181 if (len > UNICODE_STRING_MAX_CHARS) ret = STATUS_BUFFER_TOO_SMALL;
1182 if (!ret) dst->Length = (len - 1) * sizeof(WCHAR);
1183 return ret;
1184 }
1185
1186 static inline void normalize( void *base, WCHAR **ptr )
1187 {
1188 if (*ptr) *ptr = (WCHAR *)((char *)base + (UINT_PTR)*ptr);
1189 }
1190
1191 /******************************************************************************
1192 * RtlNormalizeProcessParams [NTDLL.@]
1193 */
1194 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlNormalizeProcessParams( RTL_USER_PROCESS_PARAMETERS *params )
1195 {
1196 if (params && !(params->Flags & PROCESS_PARAMS_FLAG_NORMALIZED))
1197 {
1198 normalize( params, &params->CurrentDirectory.DosPath.Buffer );
1199 normalize( params, &params->DllPath.Buffer );
1200 normalize( params, &params->ImagePathName.Buffer );
1201 normalize( params, &params->CommandLine.Buffer );
1202 normalize( params, &params->WindowTitle.Buffer );
1203 normalize( params, &params->Desktop.Buffer );
1204 normalize( params, &params->ShellInfo.Buffer );
1205 normalize( params, &params->RuntimeInfo.Buffer );
1206 params->Flags |= PROCESS_PARAMS_FLAG_NORMALIZED;
1207 }
1208 return params;
1209 }
1210
1211
1212 static inline void denormalize( const void *base, WCHAR **ptr )
1213 {
1214 if (*ptr) *ptr = (WCHAR *)(UINT_PTR)((char *)*ptr - (const char *)base);
1215 }
1216
1217 /******************************************************************************
1218 * RtlDeNormalizeProcessParams [NTDLL.@]
1219 */
1220 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlDeNormalizeProcessParams( RTL_USER_PROCESS_PARAMETERS *params )
1221 {
1222 if (params && (params->Flags & PROCESS_PARAMS_FLAG_NORMALIZED))
1223 {
1224 denormalize( params, &params->CurrentDirectory.DosPath.Buffer );
1225 denormalize( params, &params->DllPath.Buffer );
1226 denormalize( params, &params->ImagePathName.Buffer );
1227 denormalize( params, &params->CommandLine.Buffer );
1228 denormalize( params, &params->WindowTitle.Buffer );
1229 denormalize( params, &params->Desktop.Buffer );
1230 denormalize( params, &params->ShellInfo.Buffer );
1231 denormalize( params, &params->RuntimeInfo.Buffer );
1232 params->Flags &= ~PROCESS_PARAMS_FLAG_NORMALIZED;
1233 }
1234 return params;
1235 }
1236
1237
1238 #define ROUND_SIZE(size) (((size) + sizeof(void *) - 1) & ~(sizeof(void *) - 1))
1239
1240 /* append a unicode string to the process params data; helper for RtlCreateProcessParameters */
1241 static void append_unicode_string( void **data, const UNICODE_STRING *src,
1242 UNICODE_STRING *dst )
1243 {
1244 dst->Length = src->Length;
1245 dst->MaximumLength = src->MaximumLength;
1246 if (dst->MaximumLength)
1247 {
1248 dst->Buffer = *data;
1249 memcpy( dst->Buffer, src->Buffer, dst->Length );
1250 *data = (char *)dst->Buffer + ROUND_SIZE( dst->MaximumLength );
1251 }
1252 else dst->Buffer = NULL;
1253 }
1254
1255
1256 /******************************************************************************
1257 * RtlCreateProcessParametersEx [NTDLL.@]
1258 */
1259 NTSTATUS WINAPI RtlCreateProcessParametersEx( RTL_USER_PROCESS_PARAMETERS **result,
1260 const UNICODE_STRING *ImagePathName,
1261 const UNICODE_STRING *DllPath,
1262 const UNICODE_STRING *CurrentDirectoryName,
1263 const UNICODE_STRING *CommandLine,
1264 PWSTR Environment,
1265 const UNICODE_STRING *WindowTitle,
1266 const UNICODE_STRING *Desktop,
1267 const UNICODE_STRING *ShellInfo,
1268 const UNICODE_STRING *RuntimeInfo,
1269 ULONG flags )
1270 {
1271 UNICODE_STRING curdir;
1272 const RTL_USER_PROCESS_PARAMETERS *cur_params;
1273 SIZE_T size, env_size = 0;
1274 void *ptr;
1275 NTSTATUS status = STATUS_SUCCESS;
1276
1277 RtlAcquirePebLock();
1278 cur_params = NtCurrentTeb()->Peb->ProcessParameters;
1279 if (!DllPath) DllPath = &cur_params->DllPath;
1280 if (!CurrentDirectoryName)
1281 {
1282 if (NtCurrentTeb()->Tib.SubSystemTib) /* FIXME: hack */
1283 curdir = ((WIN16_SUBSYSTEM_TIB *)NtCurrentTeb()->Tib.SubSystemTib)->curdir.DosPath;
1284 else
1285 curdir = cur_params->CurrentDirectory.DosPath;
1286 }
1287 else curdir = *CurrentDirectoryName;
1288 curdir.MaximumLength = MAX_PATH * sizeof(WCHAR);
1289
1290 if (!CommandLine) CommandLine = ImagePathName;
1291 if (!Environment && cur_params) Environment = cur_params->Environment;
1292 if (!WindowTitle) WindowTitle = &empty_str;
1293 if (!Desktop) Desktop = &empty_str;
1294 if (!ShellInfo) ShellInfo = &empty_str;
1295 if (!RuntimeInfo) RuntimeInfo = &null_str;
1296
1297 if (Environment) env_size = get_env_length( Environment ) * sizeof(WCHAR);
1298
1299 size = (sizeof(RTL_USER_PROCESS_PARAMETERS)
1300 + ROUND_SIZE( ImagePathName->MaximumLength )
1301 + ROUND_SIZE( DllPath->MaximumLength )
1302 + ROUND_SIZE( curdir.MaximumLength )
1303 + ROUND_SIZE( CommandLine->MaximumLength )
1304 + ROUND_SIZE( WindowTitle->MaximumLength )
1305 + ROUND_SIZE( Desktop->MaximumLength )
1306 + ROUND_SIZE( ShellInfo->MaximumLength )
1307 + ROUND_SIZE( RuntimeInfo->MaximumLength ));
1308
1309 if ((ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, size + ROUND_SIZE(env_size) )))
1310 {
1311 RTL_USER_PROCESS_PARAMETERS *params = ptr;
1312 params->AllocationSize = size;
1313 params->Size = size;
1314 params->Flags = PROCESS_PARAMS_FLAG_NORMALIZED;
1315 if (cur_params) params->ConsoleFlags = cur_params->ConsoleFlags;
1316 /* all other fields are zero */
1317
1318 ptr = params + 1;
1319 append_unicode_string( &ptr, &curdir, &params->CurrentDirectory.DosPath );
1320 append_unicode_string( &ptr, DllPath, &params->DllPath );
1321 append_unicode_string( &ptr, ImagePathName, &params->ImagePathName );
1322 append_unicode_string( &ptr, CommandLine, &params->CommandLine );
1323 append_unicode_string( &ptr, WindowTitle, &params->WindowTitle );
1324 append_unicode_string( &ptr, Desktop, &params->Desktop );
1325 append_unicode_string( &ptr, ShellInfo, &params->ShellInfo );
1326 append_unicode_string( &ptr, RuntimeInfo, &params->RuntimeInfo );
1327 if (Environment) params->Environment = memcpy( ptr, Environment, env_size );
1328 *result = params;
1329 if (!(flags & PROCESS_PARAMS_FLAG_NORMALIZED)) RtlDeNormalizeProcessParams( params );
1330 }
1331 else status = STATUS_NO_MEMORY;
1332
1333 RtlReleasePebLock();
1334 return status;
1335 }
1336
1337
1338 /******************************************************************************
1339 * RtlCreateProcessParameters [NTDLL.@]
1340 */
1341 NTSTATUS WINAPI RtlCreateProcessParameters( RTL_USER_PROCESS_PARAMETERS **result,
1342 const UNICODE_STRING *image,
1343 const UNICODE_STRING *dllpath,
1344 const UNICODE_STRING *curdir,
1345 const UNICODE_STRING *cmdline,
1346 PWSTR env,
1347 const UNICODE_STRING *title,
1348 const UNICODE_STRING *desktop,
1349 const UNICODE_STRING *shellinfo,
1350 const UNICODE_STRING *runtime )
1351 {
1352 return RtlCreateProcessParametersEx( result, image, dllpath, curdir, cmdline,
1353 env, title, desktop, shellinfo, runtime, 0 );
1354 }
1355
1356
1357 /******************************************************************************
1358 * RtlDestroyProcessParameters [NTDLL.@]
1359 */
1360 void WINAPI RtlDestroyProcessParameters( RTL_USER_PROCESS_PARAMETERS *params )
1361 {
1362 RtlFreeHeap( GetProcessHeap(), 0, params );
1363 }
1364
1365
1366 static inline void get_unicode_string( UNICODE_STRING *str, WCHAR **src, UINT len )
1367 {
1368 str->Buffer = *src;
1369 str->Length = len;
1370 str->MaximumLength = len + sizeof(WCHAR);
1371 *src += len / sizeof(WCHAR);
1372 }
1373
1374
1375 /***********************************************************************
1376 * run_wineboot
1377 */
1378 static void run_wineboot( WCHAR **env )
1379 {
1380 static const WCHAR wineboot_eventW[] = {'\\','K','e','r','n','e','l','O','b','j','e','c','t','s',
1381 '\\','_','_','w','i','n','e','b','o','o','t','_','e','v','e','n','t',0};
1382 static const WCHAR wineboot[] = {'\\','?','?','\\','C',':','\\','w','i','n','d','o','w','s','\\',
1383 's','y','s','t','e','m','3','2','\\',
1384 'w','i','n','e','b','o','o','t','.','e','x','e',0};
1385 static const WCHAR cmdline[] = {'C',':','\\','w','i','n','d','o','w','s','\\',
1386 's','y','s','t','e','m','3','2','\\',
1387 'w','i','n','e','b','o','o','t','.','e','x','e',' ',
1388 '-','-','i','n','i','t',0};
1389 UNICODE_STRING nameW, cmdlineW, dllpathW;
1390 RTL_USER_PROCESS_PARAMETERS *params;
1391 RTL_USER_PROCESS_INFORMATION info;
1392 WCHAR *load_path, *dummy;
1393 OBJECT_ATTRIBUTES attr;
1394 LARGE_INTEGER timeout;
1395 HANDLE handles[2];
1396 NTSTATUS status;
1397 ULONG redir = 0;
1398 int count = 1;
1399
1400 RtlInitUnicodeString( &nameW, wineboot_eventW );
1401 InitializeObjectAttributes( &attr, &nameW, OBJ_OPENIF, 0, NULL );
1402
1403 status = NtCreateEvent( &handles[0], EVENT_ALL_ACCESS, &attr, NotificationEvent, 0 );
1404 if (status == STATUS_OBJECT_NAME_EXISTS) goto wait;
1405 if (status)
1406 {
1407 ERR( "failed to create wineboot event, expect trouble\n" );
1408 return;
1409 }
1410 LdrGetDllPath( wineboot + 4, LOAD_WITH_ALTERED_SEARCH_PATH, &load_path, &dummy );
1411 RtlInitUnicodeString( &nameW, wineboot + 4 );
1412 RtlInitUnicodeString( &dllpathW, load_path );
1413 RtlInitUnicodeString( &cmdlineW, cmdline );
1414 RtlCreateProcessParametersEx( &params, &nameW, &dllpathW, NULL, &cmdlineW, *env, NULL, NULL,
1415 NULL, NULL, PROCESS_PARAMS_FLAG_NORMALIZED );
1416 params->hStdInput = 0;
1417 params->hStdOutput = 0;
1418 params->hStdError = NtCurrentTeb()->Peb->ProcessParameters->hStdError;
1419
1420 RtlInitUnicodeString( &nameW, wineboot );
1421 RtlWow64EnableFsRedirectionEx( TRUE, &redir );
1422 status = RtlCreateUserProcess( &nameW, OBJ_CASE_INSENSITIVE, params,
1423 NULL, NULL, 0, FALSE, 0, 0, &info );
1424 RtlWow64EnableFsRedirection( !redir );
1425 RtlReleasePath( load_path );
1426 RtlDestroyProcessParameters( params );
1427 if (status)
1428 {
1429 ERR( "failed to start wineboot %x\n", status );
1430 NtClose( handles[0] );
1431 return;
1432 }
1433 NtResumeThread( info.Thread, NULL );
1434 NtClose( info.Thread );
1435 handles[count++] = info.Process;
1436
1437 wait:
1438 timeout.QuadPart = (ULONGLONG)(first_prefix_start ? 5 : 2) * 60 * 1000 * -10000;
1439 if (NtWaitForMultipleObjects( count, handles, TRUE, FALSE, &timeout ) == WAIT_TIMEOUT)
1440 ERR( "boot event wait timed out\n" );
1441 while (count) NtClose( handles[--count] );
1442
1443 /* reload environment now that wineboot has run */
1444 set_registry_environment( env, first_prefix_start );
1445 set_additional_environment( env );
1446 }
1447
1448
1449 /***********************************************************************
1450 * init_user_process_params
1451 *
1452 * Fill the initial RTL_USER_PROCESS_PARAMETERS structure from the server.
1453 */
1454 void init_user_process_params( SIZE_T data_size )
1455 {
1456 WCHAR *src, *load_path, *dummy;
1457 SIZE_T info_size, env_size;
1458 NTSTATUS status;
1459 startup_info_t *info = NULL;
1460 RTL_USER_PROCESS_PARAMETERS *params = NULL;
1461 UNICODE_STRING curdir, dllpath, imagepath, cmdline, title, desktop, shellinfo, runtime;
1462
1463 if (!data_size)
1464 {
1465 RTL_USER_PROCESS_PARAMETERS initial_params = {0};
1466 WCHAR *env, curdir_buffer[MAX_PATH];
1467
1468 NtCurrentTeb()->Peb->ProcessParameters = &initial_params;
1469 initial_params.Environment = build_initial_environment( __wine_get_main_environment() );
1470 curdir.Buffer = curdir_buffer;
1471 curdir.MaximumLength = sizeof(curdir_buffer);
1472 get_current_directory( &curdir );
1473 initial_params.CurrentDirectory.DosPath = curdir;
1474 get_image_path( __wine_main_argv[0], &initial_params.ImagePathName );
1475 set_library_wargv( __wine_main_argv, &initial_params.ImagePathName );
1476 build_command_line( __wine_main_wargv, &cmdline );
1477 LdrGetDllPath( initial_params.ImagePathName.Buffer, 0, &load_path, &dummy );
1478 RtlInitUnicodeString( &dllpath, load_path );
1479
1480 env = initial_params.Environment;
1481 initial_params.Environment = NULL; /* avoid copying it */
1482 if (RtlCreateProcessParametersEx( &params, &initial_params.ImagePathName, &dllpath, &curdir,
1483 &cmdline, NULL, &initial_params.ImagePathName, NULL, NULL, NULL,
1484 PROCESS_PARAMS_FLAG_NORMALIZED ))
1485 return;
1486
1487 params->Environment = env;
1488 NtCurrentTeb()->Peb->ProcessParameters = params;
1489 RtlFreeUnicodeString( &initial_params.ImagePathName );
1490 RtlFreeUnicodeString( &cmdline );
1491 RtlReleasePath( load_path );
1492
1493 if (isatty(0) || isatty(1) || isatty(2))
1494 params->ConsoleHandle = (HANDLE)2; /* see kernel32/kernel_private.h */
1495 if (!isatty(0))
1496 wine_server_fd_to_handle( 0, GENERIC_READ|SYNCHRONIZE, OBJ_INHERIT, &params->hStdInput );
1497 if (!isatty(1))
1498 wine_server_fd_to_handle( 1, GENERIC_WRITE|SYNCHRONIZE, OBJ_INHERIT, &params->hStdOutput );
1499 if (!isatty(2))
1500 wine_server_fd_to_handle( 2, GENERIC_WRITE|SYNCHRONIZE, OBJ_INHERIT, &params->hStdError );
1501 params->wShowWindow = 1; /* SW_SHOWNORMAL */
1502
1503 run_wineboot( &params->Environment );
1504 goto done;
1505 }
1506
1507 if (!(info = RtlAllocateHeap( GetProcessHeap(), 0, data_size ))) return;
1508
1509 SERVER_START_REQ( get_startup_info )
1510 {
1511 wine_server_set_reply( req, info, data_size );
1512 if (!(status = wine_server_call( req )))
1513 {
1514 data_size = wine_server_reply_size( reply );
1515 info_size = reply->info_size;
1516 env_size = data_size - info_size;
1517 }
1518 }
1519 SERVER_END_REQ;
1520 if (status) goto done;
1521
1522 src = (WCHAR *)(info + 1);
1523 get_unicode_string( &curdir, &src, info->curdir_len );
1524 get_unicode_string( &dllpath, &src, info->dllpath_len );
1525 get_unicode_string( &imagepath, &src, info->imagepath_len );
1526 get_unicode_string( &cmdline, &src, info->cmdline_len );
1527 get_unicode_string( &title, &src, info->title_len );
1528 get_unicode_string( &desktop, &src, info->desktop_len );
1529 get_unicode_string( &shellinfo, &src, info->shellinfo_len );
1530 get_unicode_string( &runtime, &src, info->runtime_len );
1531
1532 runtime.MaximumLength = runtime.Length; /* runtime info isn't a real string */
1533
1534 if (RtlCreateProcessParametersEx( &params, &imagepath, &dllpath, &curdir, &cmdline, NULL,
1535 &title, &desktop, &shellinfo, &runtime,
1536 PROCESS_PARAMS_FLAG_NORMALIZED ))
1537 goto done;
1538
1539 NtCurrentTeb()->Peb->ProcessParameters = params;
1540 params->DebugFlags = info->debug_flags;
1541 params->ConsoleHandle = wine_server_ptr_handle( info->console );
1542 params->ConsoleFlags = info->console_flags;
1543 params->hStdInput = wine_server_ptr_handle( info->hstdin );
1544 params->hStdOutput = wine_server_ptr_handle( info->hstdout );
1545 params->hStdError = wine_server_ptr_handle( info->hstderr );
1546 params->dwX = info->x;
1547 params->dwY = info->y;
1548 params->dwXSize = info->xsize;
1549 params->dwYSize = info->ysize;
1550 params->dwXCountChars = info->xchars;
1551 params->dwYCountChars = info->ychars;
1552 params->dwFillAttribute = info->attribute;
1553 params->dwFlags = info->flags;
1554 params->wShowWindow = info->show;
1555
1556 /* environment needs to be a separate memory block */
1557 if ((params->Environment = RtlAllocateHeap( GetProcessHeap(), 0, max( env_size, sizeof(WCHAR) ))))
1558 {
1559 if (env_size) memcpy( params->Environment, (char *)info + info_size, env_size );
1560 else params->Environment[0] = 0;
1561 }
1562
1563 set_library_wargv( __wine_main_argv, NULL );
1564
1565 done:
1566 RtlFreeHeap( GetProcessHeap(), 0, info );
1567 if (RtlSetCurrentDirectory_U( &params->CurrentDirectory.DosPath ))
1568 {
1569 MESSAGE("wine: could not open working directory %s, starting in the Windows directory.\n",
1570 debugstr_w( params->CurrentDirectory.DosPath.Buffer ));
1571 RtlInitUnicodeString( &curdir, windows_dir );
1572 RtlSetCurrentDirectory_U( &curdir );
1573 }
1574 if (!params->CurrentDirectory.Handle) chdir("/"); /* avoid locking removable devices */
1575 set_wow64_environment( &params->Environment );
1576 }
Windows API implementation