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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
30 #include "wine/winbase16.h"
31 #include "wine/server.h"
34 #include "selectors.h"
36 /* Win32 process environment database */
39 LPSTR environ
; /* 00 Process environment strings */
40 DWORD unknown1
; /* 04 Unknown */
41 LPSTR cmd_line
; /* 08 Command line */
42 LPSTR cur_dir
; /* 0c Current directory */
43 STARTUPINFOA
*startup_info
; /* 10 Startup information */
44 HANDLE hStdin
; /* 14 Handle for standard input */
45 HANDLE hStdout
; /* 18 Handle for standard output */
46 HANDLE hStderr
; /* 1c Handle for standard error */
47 DWORD unknown2
; /* 20 Unknown */
48 DWORD inherit_console
; /* 24 Inherit console flag */
49 DWORD break_type
; /* 28 Console events flag */
50 void *break_sem
; /* 2c SetConsoleCtrlHandler semaphore */
51 void *break_event
; /* 30 SetConsoleCtrlHandler event */
52 void *break_thread
; /* 34 SetConsoleCtrlHandler thread */
53 void *break_handlers
; /* 38 List of console handlers */
57 /* Format of an environment block:
58 * ASCIIZ string 1 (xx=yy format)
63 * ASCIIZ program name (e.g. C:\WINDOWS\SYSTEM\KRNL386.EXE)
66 * - contrary to Microsoft docs, the environment strings do not appear
67 * to be sorted on Win95 (although they are on NT); so we don't bother
68 * to sort them either.
71 static const char ENV_program_name
[] = "C:\\WINDOWS\\SYSTEM\\KRNL386.EXE";
73 /* Maximum length of a Win16 environment string (including NULL) */
74 #define MAX_WIN16_LEN 128
76 /* Extra bytes to reserve at the end of an environment */
77 #define EXTRA_ENV_SIZE (sizeof(BYTE) + sizeof(WORD) + sizeof(ENV_program_name))
79 /* Fill the extra bytes with the program name and stuff */
80 #define FILL_EXTRA_ENV(p) \
82 PUT_UA_WORD( (p) + 1, 1 ); \
83 strcpy( (p) + 3, ENV_program_name );
85 STARTUPINFOA current_startupinfo
=
87 sizeof(STARTUPINFOA
), /* cb */
95 0, /* dwXCountChars */
96 0, /* dwYCountChars */
97 0, /* dwFillAttribute */
107 ENVDB current_envdb
=
113 ¤t_startupinfo
, /* startup_info */
118 0, /* inherit_console */
122 0, /* break_thread */
123 0 /* break_handlers */
127 static WCHAR
*cmdlineW
; /* Unicode command line */
128 static WORD env_sel
; /* selector to the environment */
130 /***********************************************************************
133 * Find a variable in the environment and return a pointer to the value.
134 * Helper function for GetEnvironmentVariable and ExpandEnvironmentStrings.
136 static LPCSTR
ENV_FindVariable( LPCSTR env
, LPCSTR name
, INT len
)
140 if (!strncasecmp( name
, env
, len
) && (env
[len
] == '='))
141 return env
+ len
+ 1;
142 env
+= strlen(env
) + 1;
148 /***********************************************************************
151 * Build the environment for the initial process
153 static BOOL
build_environment(void)
155 extern char **environ
;
159 /* Compute the total size of the Unix environment */
161 size
= EXTRA_ENV_SIZE
;
162 for (e
= environ
; *e
; e
++) size
+= strlen(*e
) + 1;
164 /* Now allocate the environment */
166 if (!(p
= HeapAlloc( GetProcessHeap(), 0, size
))) return FALSE
;
167 current_envdb
.environ
= p
;
168 env_sel
= SELECTOR_AllocBlock( p
, 0x10000, WINE_LDT_FLAGS_DATA
);
170 /* And fill it with the Unix environment */
172 for (e
= environ
; *e
; e
++)
178 /* Now add the program name */
185 /***********************************************************************
188 * Small helper for ENV_InitStartupInfo.
190 inline static char *copy_str( char **dst
, const char **src
, size_t len
)
194 if (!len
) return NULL
;
196 memcpy( ret
, *src
, len
);
204 /***********************************************************************
205 * ENV_InitStartupInfo
207 * Fill the startup info structure from the server.
209 ENVDB
*ENV_InitStartupInfo( handle_t info_handle
, size_t info_size
,
210 char *main_exe_name
, size_t main_exe_size
)
218 if (!build_environment()) return NULL
;
219 if (!info_size
) return ¤t_envdb
; /* nothing to retrieve */
221 if (!(data
= HeapAlloc( GetProcessHeap(), 0, info_size
))) return NULL
;
223 SERVER_START_REQ( get_startup_info
)
225 req
->info
= info_handle
;
227 wine_server_set_reply( req
, data
, info_size
);
228 wine_server_call( req
);
229 info_size
= wine_server_reply_size( reply
);
232 if (info_size
< sizeof(info
.size
)) goto done
;
233 len
= min( info_size
, ((startup_info_t
*)data
)->size
);
234 memset( &info
, 0, sizeof(info
) );
235 memcpy( &info
, data
, len
);
236 src
= (char *)data
+ len
;
239 /* fixup the lengths */
240 if (info
.filename_len
> info_size
) info
.filename_len
= info_size
;
241 info_size
-= info
.filename_len
;
242 if (info
.cmdline_len
> info_size
) info
.cmdline_len
= info_size
;
243 info_size
-= info
.cmdline_len
;
244 if (info
.desktop_len
> info_size
) info
.desktop_len
= info_size
;
245 info_size
-= info
.desktop_len
;
246 if (info
.title_len
> info_size
) info
.title_len
= info_size
;
248 /* store the filename */
249 if (info
.filename_len
)
251 len
= min( info
.filename_len
, main_exe_size
-1 );
252 memcpy( main_exe_name
, src
, len
);
253 main_exe_name
[len
] = 0;
254 src
+= info
.filename_len
;
257 /* copy the other strings */
258 len
= info
.cmdline_len
+ info
.desktop_len
+ info
.title_len
;
259 if (len
&& (dst
= HeapAlloc( GetProcessHeap(), 0, len
+ 3 )))
261 current_envdb
.cmd_line
= copy_str( &dst
, &src
, info
.cmdline_len
);
262 current_startupinfo
.lpDesktop
= copy_str( &dst
, &src
, info
.desktop_len
);
263 current_startupinfo
.lpTitle
= copy_str( &dst
, &src
, info
.title_len
);
266 current_startupinfo
.dwX
= info
.x
;
267 current_startupinfo
.dwY
= info
.y
;
268 current_startupinfo
.dwXSize
= info
.cx
;
269 current_startupinfo
.dwYSize
= info
.cy
;
270 current_startupinfo
.dwXCountChars
= info
.x_chars
;
271 current_startupinfo
.dwYCountChars
= info
.y_chars
;
272 current_startupinfo
.dwFillAttribute
= info
.attribute
;
273 current_startupinfo
.wShowWindow
= info
.cmd_show
;
274 current_startupinfo
.dwFlags
= info
.flags
;
276 HeapFree( GetProcessHeap(), 0, data
);
277 return ¤t_envdb
;
281 /***********************************************************************
282 * ENV_BuildCommandLine
284 * Build the command line of a process from the argv array.
286 * Note that it does NOT necessarily include the file name.
287 * Sometimes we don't even have any command line options at all.
289 * We must quote and escape characters so that the argv array can be rebuilt
290 * from the command line:
291 * - spaces and tabs must be quoted
293 * - quotes must be escaped
295 * - if '\'s are followed by a '"', they must be doubled and followed by '\"',
296 * resulting in an odd number of '\' followed by a '"'
299 * - '\'s that are not followed by a '"' can be left as is
303 BOOL
ENV_BuildCommandLine( char **argv
)
308 if (current_envdb
.cmd_line
) goto done
; /* already got it from the server */
311 for (arg
= argv
; *arg
; arg
++)
313 int has_space
,bcount
;
323 if (*a
==' ' || *a
=='\t') {
325 } else if (*a
=='"') {
326 /* doubling of '\' preceeding a '"',
327 * plus escaping of said '"'
335 len
+=(a
-*arg
)+1 /* for the separating space */;
337 len
+=2; /* for the quotes */
340 if (!(current_envdb
.cmd_line
= HeapAlloc( GetProcessHeap(), 0, len
)))
343 p
= current_envdb
.cmd_line
;
344 for (arg
= argv
; *arg
; arg
++)
346 int has_space
,has_quote
;
349 /* Check for quotes and spaces in this argument */
350 has_space
=has_quote
=0;
353 if (*a
==' ' || *a
=='\t') {
357 } else if (*a
=='"') {
365 /* Now transfer it to the command line */
382 /* Double all the '\\' preceeding this '"', plus one */
383 for (i
=0;i
<=bcount
;i
++)
401 if (p
> current_envdb
.cmd_line
)
402 p
--; /* remove last space */
405 /* now allocate the Unicode version */
407 len
= MultiByteToWideChar( CP_ACP
, 0, current_envdb
.cmd_line
, -1, NULL
, 0 );
408 if (!(cmdlineW
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
410 MultiByteToWideChar( CP_ACP
, 0, current_envdb
.cmd_line
, -1, cmdlineW
, len
);
415 /***********************************************************************
416 * GetCommandLineA (KERNEL32.@)
418 * WARNING: there's a Windows incompatibility lurking here !
419 * Win32s always includes the full path of the program file,
420 * whereas Windows NT only returns the full file path plus arguments
421 * in case the program has been started with a full path.
422 * Win9x seems to have inherited NT behaviour.
424 * Note that both Start Menu Execute and Explorer start programs with
425 * fully specified quoted app file paths, which is why probably the only case
426 * where you'll see single file names is in case of direct launch
427 * via CreateProcess or WinExec.
429 * Perhaps we should take care of Win3.1 programs here (Win32s "feature").
431 * References: MS KB article q102762.txt (special Win32s handling)
433 LPSTR WINAPI
GetCommandLineA(void)
435 return current_envdb
.cmd_line
;
438 /***********************************************************************
439 * GetCommandLineW (KERNEL32.@)
441 LPWSTR WINAPI
GetCommandLineW(void)
447 /***********************************************************************
448 * GetEnvironmentStrings (KERNEL32.@)
449 * GetEnvironmentStringsA (KERNEL32.@)
451 LPSTR WINAPI
GetEnvironmentStringsA(void)
453 return current_envdb
.environ
;
457 /***********************************************************************
458 * GetEnvironmentStringsW (KERNEL32.@)
460 LPWSTR WINAPI
GetEnvironmentStringsW(void)
466 size
= HeapSize( GetProcessHeap(), 0, current_envdb
.environ
);
467 if ((ret
= HeapAlloc( GetProcessHeap(), 0, size
* sizeof(WCHAR
) )) != NULL
)
469 LPSTR pA
= current_envdb
.environ
;
471 while (size
--) *pW
++ = (WCHAR
)(BYTE
)*pA
++;
478 /***********************************************************************
479 * FreeEnvironmentStringsA (KERNEL32.@)
481 BOOL WINAPI
FreeEnvironmentStringsA( LPSTR ptr
)
483 if (ptr
!= current_envdb
.environ
)
485 SetLastError( ERROR_INVALID_PARAMETER
);
492 /***********************************************************************
493 * FreeEnvironmentStringsW (KERNEL32.@)
495 BOOL WINAPI
FreeEnvironmentStringsW( LPWSTR ptr
)
497 return HeapFree( GetProcessHeap(), 0, ptr
);
501 /***********************************************************************
502 * GetEnvironmentVariableA (KERNEL32.@)
504 DWORD WINAPI
GetEnvironmentVariableA( LPCSTR name
, LPSTR value
, DWORD size
)
511 SetLastError( ERROR_INVALID_PARAMETER
);
515 if ((p
= ENV_FindVariable( current_envdb
.environ
, name
, strlen(name
) )))
520 /* If not enough room, include the terminating null
521 * in the returned size and return an empty string */
523 if (value
) *value
= '\0';
525 else if (value
) strcpy( value
, p
);
529 SetLastError( ERROR_ENVVAR_NOT_FOUND
);
534 /***********************************************************************
535 * GetEnvironmentVariableW (KERNEL32.@)
537 DWORD WINAPI
GetEnvironmentVariableW( LPCWSTR nameW
, LPWSTR valW
, DWORD size
)
539 LPSTR name
= HEAP_strdupWtoA( GetProcessHeap(), 0, nameW
);
540 LPSTR val
= valW
? HeapAlloc( GetProcessHeap(), 0, size
) : NULL
;
541 DWORD res
= GetEnvironmentVariableA( name
, val
, size
);
542 HeapFree( GetProcessHeap(), 0, name
);
545 if (size
> 0 && !MultiByteToWideChar( CP_ACP
, 0, val
, -1, valW
, size
))
547 HeapFree( GetProcessHeap(), 0, val
);
553 /***********************************************************************
554 * SetEnvironmentVariableA (KERNEL32.@)
556 BOOL WINAPI
SetEnvironmentVariableA( LPCSTR name
, LPCSTR value
)
558 INT old_size
, len
, res
;
559 LPSTR p
, env
, new_env
;
563 env
= p
= current_envdb
.environ
;
565 /* Find a place to insert the string */
571 if (!strncasecmp( name
, p
, len
) && (p
[len
] == '=')) break;
574 if (!value
&& !*p
) goto done
; /* Value to remove doesn't exist */
576 /* Realloc the buffer */
578 len
= value
? strlen(name
) + strlen(value
) + 2 : 0;
579 if (*p
) len
-= strlen(p
) + 1; /* The name already exists */
580 old_size
= HeapSize( GetProcessHeap(), 0, env
);
583 LPSTR next
= p
+ strlen(p
) + 1; /* We know there is a next one */
584 memmove( next
+ len
, next
, old_size
- (next
- env
) );
586 if (!(new_env
= HeapReAlloc( GetProcessHeap(), 0, env
, old_size
+ len
)))
588 if (env_sel
) env_sel
= SELECTOR_ReallocBlock( env_sel
, new_env
, old_size
+ len
);
589 p
= new_env
+ (p
- env
);
590 if (len
> 0) memmove( p
+ len
, p
, old_size
- (p
- new_env
) );
592 /* Set the new string */
600 current_envdb
.environ
= new_env
;
609 /***********************************************************************
610 * SetEnvironmentVariableW (KERNEL32.@)
612 BOOL WINAPI
SetEnvironmentVariableW( LPCWSTR name
, LPCWSTR value
)
614 LPSTR nameA
= HEAP_strdupWtoA( GetProcessHeap(), 0, name
);
615 LPSTR valueA
= HEAP_strdupWtoA( GetProcessHeap(), 0, value
);
616 BOOL ret
= SetEnvironmentVariableA( nameA
, valueA
);
617 HeapFree( GetProcessHeap(), 0, nameA
);
618 HeapFree( GetProcessHeap(), 0, valueA
);
623 /***********************************************************************
624 * ExpandEnvironmentStringsA (KERNEL32.@)
626 * Note: overlapping buffers are not supported; this is how it should be.
628 DWORD WINAPI
ExpandEnvironmentStringsA( LPCSTR src
, LPSTR dst
, DWORD count
)
630 DWORD len
, total_size
= 1; /* 1 for terminating '\0' */
633 if (!count
) dst
= NULL
;
640 if ((p
= strchr( src
, '%' ))) len
= p
- src
;
641 else len
= strlen(src
);
645 else /* we are at the start of a variable */
647 if ((p
= strchr( src
+ 1, '%' )))
649 len
= p
- src
- 1; /* Length of the variable name */
650 if ((var
= ENV_FindVariable( current_envdb
.environ
,
653 src
+= len
+ 2; /* Skip the variable name */
658 var
= src
; /* Copy original name instead */
663 else /* unfinished variable name, ignore it */
666 len
= strlen(src
); /* Copy whole string */
673 if (count
< len
) len
= count
;
674 memcpy( dst
, var
, len
);
681 /* Null-terminate the string */
691 /***********************************************************************
692 * ExpandEnvironmentStringsW (KERNEL32.@)
694 DWORD WINAPI
ExpandEnvironmentStringsW( LPCWSTR src
, LPWSTR dst
, DWORD len
)
696 LPSTR srcA
= HEAP_strdupWtoA( GetProcessHeap(), 0, src
);
697 LPSTR dstA
= dst
? HeapAlloc( GetProcessHeap(), 0, len
) : NULL
;
698 DWORD ret
= ExpandEnvironmentStringsA( srcA
, dstA
, len
);
701 ret
= MultiByteToWideChar( CP_ACP
, 0, dstA
, -1, dst
, len
);
702 HeapFree( GetProcessHeap(), 0, dstA
);
704 HeapFree( GetProcessHeap(), 0, srcA
);
709 /***********************************************************************
710 * GetDOSEnvironment (KERNEL.131)
711 * GetDOSEnvironment16 (KERNEL32.@)
713 SEGPTR WINAPI
GetDOSEnvironment16(void)
715 return MAKESEGPTR( env_sel
, 0 );
719 /***********************************************************************
720 * GetStdHandle (KERNEL32.@)
722 HANDLE WINAPI
GetStdHandle( DWORD std_handle
)
726 case STD_INPUT_HANDLE
: return current_envdb
.hStdin
;
727 case STD_OUTPUT_HANDLE
: return current_envdb
.hStdout
;
728 case STD_ERROR_HANDLE
: return current_envdb
.hStderr
;
730 SetLastError( ERROR_INVALID_PARAMETER
);
731 return INVALID_HANDLE_VALUE
;
735 /***********************************************************************
736 * SetStdHandle (KERNEL32.@)
738 BOOL WINAPI
SetStdHandle( DWORD std_handle
, HANDLE handle
)
742 case STD_INPUT_HANDLE
: current_envdb
.hStdin
= handle
; return TRUE
;
743 case STD_OUTPUT_HANDLE
: current_envdb
.hStdout
= handle
; return TRUE
;
744 case STD_ERROR_HANDLE
: current_envdb
.hStderr
= handle
; return TRUE
;
746 SetLastError( ERROR_INVALID_PARAMETER
);
751 /***********************************************************************
752 * GetStartupInfoA (KERNEL32.@)
754 VOID WINAPI
GetStartupInfoA( LPSTARTUPINFOA info
)
756 *info
= current_startupinfo
;
760 /***********************************************************************
761 * GetStartupInfoW (KERNEL32.@)
763 VOID WINAPI
GetStartupInfoW( LPSTARTUPINFOW info
)
765 info
->cb
= sizeof(STARTUPINFOW
);
766 info
->dwX
= current_startupinfo
.dwX
;
767 info
->dwY
= current_startupinfo
.dwY
;
768 info
->dwXSize
= current_startupinfo
.dwXSize
;
769 info
->dwXCountChars
= current_startupinfo
.dwXCountChars
;
770 info
->dwYCountChars
= current_startupinfo
.dwYCountChars
;
771 info
->dwFillAttribute
= current_startupinfo
.dwFillAttribute
;
772 info
->dwFlags
= current_startupinfo
.dwFlags
;
773 info
->wShowWindow
= current_startupinfo
.wShowWindow
;
774 info
->cbReserved2
= current_startupinfo
.cbReserved2
;
775 info
->lpReserved2
= current_startupinfo
.lpReserved2
;
776 info
->hStdInput
= current_startupinfo
.hStdInput
;
777 info
->hStdOutput
= current_startupinfo
.hStdOutput
;
778 info
->hStdError
= current_startupinfo
.hStdError
;
779 info
->lpReserved
= HEAP_strdupAtoW (GetProcessHeap(), 0, current_startupinfo
.lpReserved
);
780 info
->lpDesktop
= HEAP_strdupAtoW (GetProcessHeap(), 0, current_startupinfo
.lpDesktop
);
781 info
->lpTitle
= HEAP_strdupAtoW (GetProcessHeap(), 0, current_startupinfo
.lpTitle
);