2 * Process environment management
4 * Copyright 1996, 1998 Alexandre Julliard
15 #include "selectors.h"
17 /* Win32 process environment database */
20 LPSTR environ
; /* 00 Process environment strings */
21 DWORD unknown1
; /* 04 Unknown */
22 LPSTR cmd_line
; /* 08 Command line */
23 LPSTR cur_dir
; /* 0c Current directory */
24 STARTUPINFOA
*startup_info
; /* 10 Startup information */
25 HANDLE hStdin
; /* 14 Handle for standard input */
26 HANDLE hStdout
; /* 18 Handle for standard output */
27 HANDLE hStderr
; /* 1c Handle for standard error */
28 DWORD unknown2
; /* 20 Unknown */
29 DWORD inherit_console
; /* 24 Inherit console flag */
30 DWORD break_type
; /* 28 Console events flag */
31 void *break_sem
; /* 2c SetConsoleCtrlHandler semaphore */
32 void *break_event
; /* 30 SetConsoleCtrlHandler event */
33 void *break_thread
; /* 34 SetConsoleCtrlHandler thread */
34 void *break_handlers
; /* 38 List of console handlers */
38 /* Format of an environment block:
39 * ASCIIZ string 1 (xx=yy format)
44 * ASCIIZ program name (e.g. C:\WINDOWS\SYSTEM\KRNL386.EXE)
47 * - contrary to Microsoft docs, the environment strings do not appear
48 * to be sorted on Win95 (although they are on NT); so we don't bother
49 * to sort them either.
52 static const char ENV_program_name
[] = "C:\\WINDOWS\\SYSTEM\\KRNL386.EXE";
54 /* Maximum length of a Win16 environment string (including NULL) */
55 #define MAX_WIN16_LEN 128
57 /* Extra bytes to reserve at the end of an environment */
58 #define EXTRA_ENV_SIZE (sizeof(BYTE) + sizeof(WORD) + sizeof(ENV_program_name))
60 /* Fill the extra bytes with the program name and stuff */
61 #define FILL_EXTRA_ENV(p) \
63 PUT_UA_WORD( (p) + 1, 1 ); \
64 strcpy( (p) + 3, ENV_program_name );
66 STARTUPINFOA current_startupinfo
=
68 sizeof(STARTUPINFOA
), /* cb */
76 0, /* dwXCountChars */
77 0, /* dwYCountChars */
78 0, /* dwFillAttribute */
94 ¤t_startupinfo
, /* startup_info */
99 0, /* inherit_console */
103 0, /* break_thread */
104 0 /* break_handlers */
108 static WCHAR
*cmdlineW
; /* Unicode command line */
109 static WORD env_sel
; /* selector to the environment */
111 /***********************************************************************
114 * Find a variable in the environment and return a pointer to the value.
115 * Helper function for GetEnvironmentVariable and ExpandEnvironmentStrings.
117 static LPCSTR
ENV_FindVariable( LPCSTR env
, LPCSTR name
, INT len
)
121 if (!strncasecmp( name
, env
, len
) && (env
[len
] == '='))
122 return env
+ len
+ 1;
123 env
+= strlen(env
) + 1;
129 /***********************************************************************
130 * ENV_BuildEnvironment
132 * Build the environment for the initial process
134 ENVDB
*ENV_BuildEnvironment(void)
136 extern char **environ
;
140 /* Compute the total size of the Unix environment */
142 size
= EXTRA_ENV_SIZE
;
143 for (e
= environ
; *e
; e
++) size
+= strlen(*e
) + 1;
145 /* Now allocate the environment */
147 if (!(p
= HeapAlloc( GetProcessHeap(), 0, size
))) return NULL
;
148 current_envdb
.environ
= p
;
149 env_sel
= SELECTOR_AllocBlock( p
, 0x10000, WINE_LDT_FLAGS_DATA
);
151 /* And fill it with the Unix environment */
153 for (e
= environ
; *e
; e
++)
159 /* Now add the program name */
162 return ¤t_envdb
;
166 /***********************************************************************
167 * ENV_BuildCommandLine
169 * Build the command line of a process from the argv array.
171 * Note that it does NOT necessarily include the file name.
172 * Sometimes we don't even have any command line options at all.
174 BOOL
ENV_BuildCommandLine( char **argv
)
179 for (arg
= argv
, len
= 0; *arg
; arg
++) len
+= strlen(*arg
) + 1;
180 if ((argv
[0]) && (quote
= (strchr( argv
[0], ' ' ) != NULL
))) len
+= 2;
181 if (!(p
= current_envdb
.cmd_line
= HeapAlloc( GetProcessHeap(), 0, len
))) return FALSE
;
199 if (p
> current_envdb
.cmd_line
) p
--; /* remove last space */
201 /* now allocate the Unicode version */
202 len
= MultiByteToWideChar( CP_ACP
, 0, current_envdb
.cmd_line
, -1, NULL
, 0 );
203 if (!(cmdlineW
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) )))
205 MultiByteToWideChar( CP_ACP
, 0, current_envdb
.cmd_line
, -1, cmdlineW
, len
);
210 /***********************************************************************
211 * GetCommandLineA (KERNEL32.@)
213 LPSTR WINAPI
GetCommandLineA(void)
215 return current_envdb
.cmd_line
;
218 /***********************************************************************
219 * GetCommandLineW (KERNEL32.@)
221 LPWSTR WINAPI
GetCommandLineW(void)
227 /***********************************************************************
228 * GetEnvironmentStrings (KERNEL32.@)
229 * GetEnvironmentStringsA (KERNEL32.@)
231 LPSTR WINAPI
GetEnvironmentStringsA(void)
233 return current_envdb
.environ
;
237 /***********************************************************************
238 * GetEnvironmentStringsW (KERNEL32.@)
240 LPWSTR WINAPI
GetEnvironmentStringsW(void)
246 size
= HeapSize( GetProcessHeap(), 0, current_envdb
.environ
);
247 if ((ret
= HeapAlloc( GetProcessHeap(), 0, size
* sizeof(WCHAR
) )) != NULL
)
249 LPSTR pA
= current_envdb
.environ
;
251 while (size
--) *pW
++ = (WCHAR
)(BYTE
)*pA
++;
258 /***********************************************************************
259 * FreeEnvironmentStringsA (KERNEL32.@)
261 BOOL WINAPI
FreeEnvironmentStringsA( LPSTR ptr
)
263 if (ptr
!= current_envdb
.environ
)
265 SetLastError( ERROR_INVALID_PARAMETER
);
272 /***********************************************************************
273 * FreeEnvironmentStringsW (KERNEL32.@)
275 BOOL WINAPI
FreeEnvironmentStringsW( LPWSTR ptr
)
277 return HeapFree( GetProcessHeap(), 0, ptr
);
281 /***********************************************************************
282 * GetEnvironmentVariableA (KERNEL32.@)
284 DWORD WINAPI
GetEnvironmentVariableA( LPCSTR name
, LPSTR value
, DWORD size
)
291 SetLastError( ERROR_INVALID_PARAMETER
);
295 if ((p
= ENV_FindVariable( current_envdb
.environ
, name
, strlen(name
) )))
300 /* If not enough room, include the terminating null
301 * in the returned size and return an empty string */
303 if (value
) *value
= '\0';
305 else if (value
) strcpy( value
, p
);
309 SetLastError( ERROR_ENVVAR_NOT_FOUND
);
314 /***********************************************************************
315 * GetEnvironmentVariableW (KERNEL32.@)
317 DWORD WINAPI
GetEnvironmentVariableW( LPCWSTR nameW
, LPWSTR valW
, DWORD size
)
319 LPSTR name
= HEAP_strdupWtoA( GetProcessHeap(), 0, nameW
);
320 LPSTR val
= valW
? HeapAlloc( GetProcessHeap(), 0, size
) : NULL
;
321 DWORD res
= GetEnvironmentVariableA( name
, val
, size
);
322 HeapFree( GetProcessHeap(), 0, name
);
325 if (size
> 0 && !MultiByteToWideChar( CP_ACP
, 0, val
, -1, valW
, size
))
327 HeapFree( GetProcessHeap(), 0, val
);
333 /***********************************************************************
334 * SetEnvironmentVariableA (KERNEL32.@)
336 BOOL WINAPI
SetEnvironmentVariableA( LPCSTR name
, LPCSTR value
)
338 INT old_size
, len
, res
;
339 LPSTR p
, env
, new_env
;
343 env
= p
= current_envdb
.environ
;
345 /* Find a place to insert the string */
351 if (!strncasecmp( name
, p
, len
) && (p
[len
] == '=')) break;
354 if (!value
&& !*p
) goto done
; /* Value to remove doesn't exist */
356 /* Realloc the buffer */
358 len
= value
? strlen(name
) + strlen(value
) + 2 : 0;
359 if (*p
) len
-= strlen(p
) + 1; /* The name already exists */
360 old_size
= HeapSize( GetProcessHeap(), 0, env
);
363 LPSTR next
= p
+ strlen(p
) + 1; /* We know there is a next one */
364 memmove( next
+ len
, next
, old_size
- (next
- env
) );
366 if (!(new_env
= HeapReAlloc( GetProcessHeap(), 0, env
, old_size
+ len
)))
368 if (env_sel
) env_sel
= SELECTOR_ReallocBlock( env_sel
, new_env
, old_size
+ len
);
369 p
= new_env
+ (p
- env
);
370 if (len
> 0) memmove( p
+ len
, p
, old_size
- (p
- new_env
) );
372 /* Set the new string */
380 current_envdb
.environ
= new_env
;
389 /***********************************************************************
390 * SetEnvironmentVariableW (KERNEL32.@)
392 BOOL WINAPI
SetEnvironmentVariableW( LPCWSTR name
, LPCWSTR value
)
394 LPSTR nameA
= HEAP_strdupWtoA( GetProcessHeap(), 0, name
);
395 LPSTR valueA
= HEAP_strdupWtoA( GetProcessHeap(), 0, value
);
396 BOOL ret
= SetEnvironmentVariableA( nameA
, valueA
);
397 HeapFree( GetProcessHeap(), 0, nameA
);
398 HeapFree( GetProcessHeap(), 0, valueA
);
403 /***********************************************************************
404 * ExpandEnvironmentStringsA (KERNEL32.@)
406 * Note: overlapping buffers are not supported; this is how it should be.
408 DWORD WINAPI
ExpandEnvironmentStringsA( LPCSTR src
, LPSTR dst
, DWORD count
)
410 DWORD len
, total_size
= 1; /* 1 for terminating '\0' */
413 if (!count
) dst
= NULL
;
420 if ((p
= strchr( src
, '%' ))) len
= p
- src
;
421 else len
= strlen(src
);
425 else /* we are at the start of a variable */
427 if ((p
= strchr( src
+ 1, '%' )))
429 len
= p
- src
- 1; /* Length of the variable name */
430 if ((var
= ENV_FindVariable( current_envdb
.environ
,
433 src
+= len
+ 2; /* Skip the variable name */
438 var
= src
; /* Copy original name instead */
443 else /* unfinished variable name, ignore it */
446 len
= strlen(src
); /* Copy whole string */
453 if (count
< len
) len
= count
;
454 memcpy( dst
, var
, len
);
461 /* Null-terminate the string */
471 /***********************************************************************
472 * ExpandEnvironmentStringsW (KERNEL32.@)
474 DWORD WINAPI
ExpandEnvironmentStringsW( LPCWSTR src
, LPWSTR dst
, DWORD len
)
476 LPSTR srcA
= HEAP_strdupWtoA( GetProcessHeap(), 0, src
);
477 LPSTR dstA
= dst
? HeapAlloc( GetProcessHeap(), 0, len
) : NULL
;
478 DWORD ret
= ExpandEnvironmentStringsA( srcA
, dstA
, len
);
481 ret
= MultiByteToWideChar( CP_ACP
, 0, dstA
, -1, dst
, len
);
482 HeapFree( GetProcessHeap(), 0, dstA
);
484 HeapFree( GetProcessHeap(), 0, srcA
);
489 /***********************************************************************
490 * GetDOSEnvironment (KERNEL.131)
491 * GetDOSEnvironment16 (KERNEL32.@)
493 SEGPTR WINAPI
GetDOSEnvironment16(void)
495 return MAKESEGPTR( env_sel
, 0 );
499 /***********************************************************************
500 * GetStdHandle (KERNEL32.@)
502 HANDLE WINAPI
GetStdHandle( DWORD std_handle
)
506 case STD_INPUT_HANDLE
: return current_envdb
.hStdin
;
507 case STD_OUTPUT_HANDLE
: return current_envdb
.hStdout
;
508 case STD_ERROR_HANDLE
: return current_envdb
.hStderr
;
510 SetLastError( ERROR_INVALID_PARAMETER
);
511 return INVALID_HANDLE_VALUE
;
515 /***********************************************************************
516 * SetStdHandle (KERNEL32.@)
518 BOOL WINAPI
SetStdHandle( DWORD std_handle
, HANDLE handle
)
522 case STD_INPUT_HANDLE
: current_envdb
.hStdin
= handle
; return TRUE
;
523 case STD_OUTPUT_HANDLE
: current_envdb
.hStdout
= handle
; return TRUE
;
524 case STD_ERROR_HANDLE
: current_envdb
.hStderr
= handle
; return TRUE
;
526 SetLastError( ERROR_INVALID_PARAMETER
);
531 /***********************************************************************
532 * GetStartupInfoA (KERNEL32.@)
534 VOID WINAPI
GetStartupInfoA( LPSTARTUPINFOA info
)
536 *info
= current_startupinfo
;
540 /***********************************************************************
541 * GetStartupInfoW (KERNEL32.@)
543 VOID WINAPI
GetStartupInfoW( LPSTARTUPINFOW info
)
545 info
->cb
= sizeof(STARTUPINFOW
);
546 info
->dwX
= current_startupinfo
.dwX
;
547 info
->dwY
= current_startupinfo
.dwY
;
548 info
->dwXSize
= current_startupinfo
.dwXSize
;
549 info
->dwXCountChars
= current_startupinfo
.dwXCountChars
;
550 info
->dwYCountChars
= current_startupinfo
.dwYCountChars
;
551 info
->dwFillAttribute
= current_startupinfo
.dwFillAttribute
;
552 info
->dwFlags
= current_startupinfo
.dwFlags
;
553 info
->wShowWindow
= current_startupinfo
.wShowWindow
;
554 info
->cbReserved2
= current_startupinfo
.cbReserved2
;
555 info
->lpReserved2
= current_startupinfo
.lpReserved2
;
556 info
->hStdInput
= current_startupinfo
.hStdInput
;
557 info
->hStdOutput
= current_startupinfo
.hStdOutput
;
558 info
->hStdError
= current_startupinfo
.hStdError
;
559 info
->lpReserved
= HEAP_strdupAtoW (GetProcessHeap(), 0, current_startupinfo
.lpReserved
);
560 info
->lpDesktop
= HEAP_strdupAtoW (GetProcessHeap(), 0, current_startupinfo
.lpDesktop
);
561 info
->lpTitle
= HEAP_strdupAtoW (GetProcessHeap(), 0, current_startupinfo
.lpTitle
);