2 * Process environment management
4 * Copyright 1996, 1998 Alexandre Julliard
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.
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.
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
22 #include "wine/port.h"
30 #define WIN32_NO_STATUS
34 #include "wine/library.h"
36 #include "wine/unicode.h"
37 #include "wine/debug.h"
39 #include "kernel_private.h"
41 WINE_DEFAULT_DEBUG_CHANNEL(environ
);
44 * - contrary to Microsoft docs, the environment strings do not appear
45 * to be sorted on Win95 (although they are on NT); so we don't bother
46 * to sort them either.
49 static STARTUPINFOW startup_infoW
;
50 static STARTUPINFOA startup_infoA
;
53 /***********************************************************************
54 * GetCommandLineA (KERNEL32.@)
56 * WARNING: there's a Windows incompatibility lurking here !
57 * Win32s always includes the full path of the program file,
58 * whereas Windows NT only returns the full file path plus arguments
59 * in case the program has been started with a full path.
60 * Win9x seems to have inherited NT behaviour.
62 * Note that both Start Menu Execute and Explorer start programs with
63 * fully specified quoted app file paths, which is why probably the only case
64 * where you'll see single file names is in case of direct launch
65 * via CreateProcess or WinExec.
67 * Perhaps we should take care of Win3.1 programs here (Win32s "feature").
69 * References: MS KB article q102762.txt (special Win32s handling)
71 LPSTR WINAPI
GetCommandLineA(void)
73 static char *cmdlineA
; /* ASCII command line */
75 if (!cmdlineA
) /* make an ansi version if we don't have it */
80 cmdlineA
= (RtlUnicodeStringToAnsiString( &ansi
, &NtCurrentTeb()->Peb
->ProcessParameters
->CommandLine
, TRUE
) == STATUS_SUCCESS
) ?
87 /***********************************************************************
88 * GetCommandLineW (KERNEL32.@)
90 LPWSTR WINAPI
GetCommandLineW(void)
92 return NtCurrentTeb()->Peb
->ProcessParameters
->CommandLine
.Buffer
;
96 /***********************************************************************
97 * GetEnvironmentStringsA (KERNEL32.@)
98 * GetEnvironmentStrings (KERNEL32.@)
100 LPSTR WINAPI
GetEnvironmentStringsA(void)
110 ptrW
= NtCurrentTeb()->Peb
->ProcessParameters
->Environment
;
113 slen
= strlenW(ptrW
) + 1;
114 len
+= WideCharToMultiByte( CP_ACP
, 0, ptrW
, slen
, NULL
, 0, NULL
, NULL
);
118 if ((ret
= HeapAlloc( GetProcessHeap(), 0, len
)) != NULL
)
120 ptrW
= NtCurrentTeb()->Peb
->ProcessParameters
->Environment
;
124 slen
= strlenW(ptrW
) + 1;
125 WideCharToMultiByte( CP_ACP
, 0, ptrW
, slen
, ptrA
, len
, NULL
, NULL
);
127 ptrA
+= strlen(ptrA
) + 1;
137 /***********************************************************************
138 * GetEnvironmentStringsW (KERNEL32.@)
140 LPWSTR WINAPI
GetEnvironmentStringsW(void)
142 return NtCurrentTeb()->Peb
->ProcessParameters
->Environment
;
146 /***********************************************************************
147 * FreeEnvironmentStringsA (KERNEL32.@)
149 BOOL WINAPI
FreeEnvironmentStringsA( LPSTR ptr
)
151 return HeapFree( GetProcessHeap(), 0, ptr
);
155 /***********************************************************************
156 * FreeEnvironmentStringsW (KERNEL32.@)
158 BOOL WINAPI
FreeEnvironmentStringsW( LPWSTR ptr
)
164 /***********************************************************************
165 * GetEnvironmentVariableA (KERNEL32.@)
167 DWORD WINAPI
GetEnvironmentVariableA( LPCSTR name
, LPSTR value
, DWORD size
)
169 UNICODE_STRING us_name
;
175 SetLastError(ERROR_ENVVAR_NOT_FOUND
);
179 if (!(valueW
= HeapAlloc(GetProcessHeap(), 0, size
* sizeof(WCHAR
))))
182 RtlCreateUnicodeStringFromAsciiz( &us_name
, name
);
184 ret
= GetEnvironmentVariableW( us_name
.Buffer
, valueW
, size
);
185 if (ret
&& ret
< size
)
187 WideCharToMultiByte( CP_ACP
, 0, valueW
, ret
+ 1, value
, size
, NULL
, NULL
);
189 /* this is needed to tell, with 0 as a return value, the difference between:
190 * - an error (GetLastError() != 0)
191 * - returning an empty string (in this case, we need to update the buffer)
193 if (ret
== 0 && size
&& GetLastError() == 0)
196 RtlFreeUnicodeString( &us_name
);
197 HeapFree(GetProcessHeap(), 0, valueW
);
203 /***********************************************************************
204 * GetEnvironmentVariableW (KERNEL32.@)
206 DWORD WINAPI
GetEnvironmentVariableW( LPCWSTR name
, LPWSTR val
, DWORD size
)
208 UNICODE_STRING us_name
;
209 UNICODE_STRING us_value
;
213 TRACE("(%s %p %u)\n", debugstr_w(name
), val
, size
);
217 SetLastError(ERROR_ENVVAR_NOT_FOUND
);
221 RtlInitUnicodeString(&us_name
, name
);
223 us_value
.MaximumLength
= (size
? size
- 1 : 0) * sizeof(WCHAR
);
224 us_value
.Buffer
= val
;
226 status
= RtlQueryEnvironmentVariable_U(NULL
, &us_name
, &us_value
);
227 len
= us_value
.Length
/ sizeof(WCHAR
);
228 if (status
!= STATUS_SUCCESS
)
230 SetLastError( RtlNtStatusToDosError(status
) );
231 return (status
== STATUS_BUFFER_TOO_SMALL
) ? len
+ 1 : 0;
233 if (size
) val
[len
] = '\0';
235 return us_value
.Length
/ sizeof(WCHAR
);
239 /***********************************************************************
240 * SetEnvironmentVariableA (KERNEL32.@)
242 BOOL WINAPI
SetEnvironmentVariableA( LPCSTR name
, LPCSTR value
)
244 UNICODE_STRING us_name
;
249 SetLastError(ERROR_ENVVAR_NOT_FOUND
);
253 RtlCreateUnicodeStringFromAsciiz( &us_name
, name
);
256 UNICODE_STRING us_value
;
258 RtlCreateUnicodeStringFromAsciiz( &us_value
, value
);
259 ret
= SetEnvironmentVariableW( us_name
.Buffer
, us_value
.Buffer
);
260 RtlFreeUnicodeString( &us_value
);
262 else ret
= SetEnvironmentVariableW( us_name
.Buffer
, NULL
);
264 RtlFreeUnicodeString( &us_name
);
270 /***********************************************************************
271 * SetEnvironmentVariableW (KERNEL32.@)
273 BOOL WINAPI
SetEnvironmentVariableW( LPCWSTR name
, LPCWSTR value
)
275 UNICODE_STRING us_name
;
278 TRACE("(%s %s)\n", debugstr_w(name
), debugstr_w(value
));
282 SetLastError(ERROR_ENVVAR_NOT_FOUND
);
286 RtlInitUnicodeString(&us_name
, name
);
289 UNICODE_STRING us_value
;
291 RtlInitUnicodeString(&us_value
, value
);
292 status
= RtlSetEnvironmentVariable(NULL
, &us_name
, &us_value
);
294 else status
= RtlSetEnvironmentVariable(NULL
, &us_name
, NULL
);
296 if (status
!= STATUS_SUCCESS
)
298 SetLastError( RtlNtStatusToDosError(status
) );
305 /***********************************************************************
306 * ExpandEnvironmentStringsA (KERNEL32.@)
308 * See ExpandEnvironmentStringsW.
310 * Note: overlapping buffers are not supported; this is how it should be.
311 * FIXME: return value is wrong for MBCS
313 DWORD WINAPI
ExpandEnvironmentStringsA( LPCSTR src
, LPSTR dst
, DWORD count
)
315 UNICODE_STRING us_src
;
319 RtlCreateUnicodeStringFromAsciiz( &us_src
, src
);
322 if (!(dstW
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(WCHAR
))))
324 ret
= ExpandEnvironmentStringsW( us_src
.Buffer
, dstW
, count
);
326 WideCharToMultiByte( CP_ACP
, 0, dstW
, ret
, dst
, count
, NULL
, NULL
);
328 else ret
= ExpandEnvironmentStringsW( us_src
.Buffer
, NULL
, 0);
330 RtlFreeUnicodeString( &us_src
);
331 HeapFree(GetProcessHeap(), 0, dstW
);
337 /***********************************************************************
338 * ExpandEnvironmentStringsW (KERNEL32.@)
340 * Replaces references to environment variables of the form '%EnvVar%'
341 * by their value. If the environment variable does not exist, then the
342 * reference is left as is.
345 * src [I] The string to be expanded.
346 * dst [O] The buffer in which to put the expanded string.
347 * len [I] The buffer size, in characters.
350 * The number of characters copied into the buffer. If the buffer is
351 * too small, then the required buffer size, in characters including the
352 * trailing '\0', is returned.
353 * If the function fails for some other reason, then it returns 0.
355 DWORD WINAPI
ExpandEnvironmentStringsW( LPCWSTR src
, LPWSTR dst
, DWORD len
)
357 UNICODE_STRING us_src
;
358 UNICODE_STRING us_dst
;
362 TRACE("(%s %p %u)\n", debugstr_w(src
), dst
, len
);
364 RtlInitUnicodeString(&us_src
, src
);
366 /* make sure we don't overflow the maximum UNICODE_STRING size */
367 if (len
> UNICODE_STRING_MAX_CHARS
)
368 len
= UNICODE_STRING_MAX_CHARS
;
371 us_dst
.MaximumLength
= len
* sizeof(WCHAR
);
375 status
= RtlExpandEnvironmentStrings_U(NULL
, &us_src
, &us_dst
, &res
);
376 res
/= sizeof(WCHAR
);
377 if (status
!= STATUS_SUCCESS
)
379 SetLastError( RtlNtStatusToDosError(status
) );
380 if (status
!= STATUS_BUFFER_TOO_SMALL
) return 0;
381 if (len
&& dst
) dst
[len
- 1] = '\0';
388 /***********************************************************************
389 * GetStdHandle (KERNEL32.@)
391 HANDLE WINAPI
GetStdHandle( DWORD std_handle
)
395 case STD_INPUT_HANDLE
: return NtCurrentTeb()->Peb
->ProcessParameters
->hStdInput
;
396 case STD_OUTPUT_HANDLE
: return NtCurrentTeb()->Peb
->ProcessParameters
->hStdOutput
;
397 case STD_ERROR_HANDLE
: return NtCurrentTeb()->Peb
->ProcessParameters
->hStdError
;
399 SetLastError( ERROR_INVALID_PARAMETER
);
400 return INVALID_HANDLE_VALUE
;
404 /***********************************************************************
405 * SetStdHandle (KERNEL32.@)
407 BOOL WINAPI
SetStdHandle( DWORD std_handle
, HANDLE handle
)
411 case STD_INPUT_HANDLE
: NtCurrentTeb()->Peb
->ProcessParameters
->hStdInput
= handle
; return TRUE
;
412 case STD_OUTPUT_HANDLE
: NtCurrentTeb()->Peb
->ProcessParameters
->hStdOutput
= handle
; return TRUE
;
413 case STD_ERROR_HANDLE
: NtCurrentTeb()->Peb
->ProcessParameters
->hStdError
= handle
; return TRUE
;
415 SetLastError( ERROR_INVALID_PARAMETER
);
419 /***********************************************************************
420 * GetStartupInfoA (KERNEL32.@)
422 VOID WINAPI
GetStartupInfoA( LPSTARTUPINFOA info
)
424 *info
= startup_infoA
;
428 /***********************************************************************
429 * GetStartupInfoW (KERNEL32.@)
431 VOID WINAPI
GetStartupInfoW( LPSTARTUPINFOW info
)
433 *info
= startup_infoW
;
436 /******************************************************************
437 * ENV_CopyStartupInformation (internal)
439 * Creates the STARTUPINFO information from the ntdll information
441 void ENV_CopyStartupInformation(void)
443 RTL_USER_PROCESS_PARAMETERS
* rupp
;
448 rupp
= NtCurrentTeb()->Peb
->ProcessParameters
;
450 startup_infoW
.cb
= sizeof(startup_infoW
);
451 startup_infoW
.lpReserved
= NULL
;
452 startup_infoW
.lpDesktop
= rupp
->Desktop
.Buffer
;
453 startup_infoW
.lpTitle
= rupp
->WindowTitle
.Buffer
;
454 startup_infoW
.dwX
= rupp
->dwX
;
455 startup_infoW
.dwY
= rupp
->dwY
;
456 startup_infoW
.dwXSize
= rupp
->dwXSize
;
457 startup_infoW
.dwYSize
= rupp
->dwYSize
;
458 startup_infoW
.dwXCountChars
= rupp
->dwXCountChars
;
459 startup_infoW
.dwYCountChars
= rupp
->dwYCountChars
;
460 startup_infoW
.dwFillAttribute
= rupp
->dwFillAttribute
;
461 startup_infoW
.dwFlags
= rupp
->dwFlags
;
462 startup_infoW
.wShowWindow
= rupp
->wShowWindow
;
463 startup_infoW
.cbReserved2
= rupp
->RuntimeInfo
.MaximumLength
;
464 startup_infoW
.lpReserved2
= rupp
->RuntimeInfo
.MaximumLength
? (void*)rupp
->RuntimeInfo
.Buffer
: NULL
;
465 startup_infoW
.hStdInput
= rupp
->hStdInput
;
466 startup_infoW
.hStdOutput
= rupp
->hStdOutput
;
467 startup_infoW
.hStdError
= rupp
->hStdError
;
469 startup_infoA
.cb
= sizeof(startup_infoA
);
470 startup_infoA
.lpReserved
= NULL
;
471 startup_infoA
.lpDesktop
= RtlUnicodeStringToAnsiString( &ansi
, &rupp
->Desktop
, TRUE
) == STATUS_SUCCESS
?
473 startup_infoA
.lpTitle
= RtlUnicodeStringToAnsiString( &ansi
, &rupp
->WindowTitle
, TRUE
) == STATUS_SUCCESS
?
475 startup_infoA
.dwX
= rupp
->dwX
;
476 startup_infoA
.dwY
= rupp
->dwY
;
477 startup_infoA
.dwXSize
= rupp
->dwXSize
;
478 startup_infoA
.dwYSize
= rupp
->dwYSize
;
479 startup_infoA
.dwXCountChars
= rupp
->dwXCountChars
;
480 startup_infoA
.dwYCountChars
= rupp
->dwYCountChars
;
481 startup_infoA
.dwFillAttribute
= rupp
->dwFillAttribute
;
482 startup_infoA
.dwFlags
= rupp
->dwFlags
;
483 startup_infoA
.wShowWindow
= rupp
->wShowWindow
;
484 startup_infoA
.cbReserved2
= rupp
->RuntimeInfo
.MaximumLength
;
485 startup_infoA
.lpReserved2
= rupp
->RuntimeInfo
.MaximumLength
? (void*)rupp
->RuntimeInfo
.Buffer
: NULL
;
486 startup_infoA
.hStdInput
= rupp
->hStdInput
;
487 startup_infoA
.hStdOutput
= rupp
->hStdOutput
;
488 startup_infoA
.hStdError
= rupp
->hStdError
;