dlls/kernel32/environ.c

   1 /*
   2  * Process environment management
   3  *
   4  * Copyright 1996, 1998 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdarg.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <assert.h>
  28
  29 #include "ntstatus.h"
  30 #define WIN32_NO_STATUS
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winerror.h"
  34 #include "wine/library.h"
  35 #include "winternl.h"
  36 #include "wine/unicode.h"
  37 #include "wine/debug.h"
  38
  39 #include "kernel_private.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(environ);
  42
  43 /* Notes:
  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.
  47  */
  48
  49 static STARTUPINFOW startup_infoW;
  50 static STARTUPINFOA startup_infoA;
  51
  52
  53 /***********************************************************************
  54  *           GetCommandLineA      (KERNEL32.@)
  55  *
  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.
  61  *
  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.
  66  *
  67  * Perhaps we should take care of Win3.1 programs here (Win32s "feature").
  68  *
  69  * References: MS KB article q102762.txt (special Win32s handling)
  70  */
  71 LPSTR WINAPI GetCommandLineA(void)
  72 {
  73     static char *cmdlineA;  /* ASCII command line */
  74
  75     if (!cmdlineA) /* make an ansi version if we don't have it */
  76     {
  77         ANSI_STRING     ansi;
  78         RtlAcquirePebLock();
  79
  80         cmdlineA = (RtlUnicodeStringToAnsiString( &ansi, &NtCurrentTeb()->Peb->ProcessParameters->CommandLine, TRUE) == STATUS_SUCCESS) ?
  81             ansi.Buffer : NULL;
  82         RtlReleasePebLock();
  83     }
  84     return cmdlineA;
  85 }
  86
  87 /***********************************************************************
  88  *           GetCommandLineW      (KERNEL32.@)
  89  */
  90 LPWSTR WINAPI GetCommandLineW(void)
  91 {
  92     return NtCurrentTeb()->Peb->ProcessParameters->CommandLine.Buffer;
  93 }
  94
  95
  96 /***********************************************************************
  97  *           GetEnvironmentStringsA   (KERNEL32.@)
  98  *           GetEnvironmentStrings    (KERNEL32.@)
  99  */
 100 LPSTR WINAPI GetEnvironmentStringsA(void)
 101 {
 102     LPWSTR      ptrW;
 103     unsigned    len, slen;
 104     LPSTR       ret, ptrA;
 105
 106     RtlAcquirePebLock();
 107
 108     len = 1;
 109
 110     ptrW = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 111     while (*ptrW)
 112     {
 113         slen = strlenW(ptrW) + 1;
 114         len += WideCharToMultiByte( CP_ACP, 0, ptrW, slen, NULL, 0, NULL, NULL );
 115         ptrW += slen;
 116     }
 117
 118     if ((ret = HeapAlloc( GetProcessHeap(), 0, len )) != NULL)
 119     {
 120         ptrW = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 121         ptrA = ret;
 122         while (*ptrW)
 123         {
 124             slen = strlenW(ptrW) + 1;
 125             WideCharToMultiByte( CP_ACP, 0, ptrW, slen, ptrA, len, NULL, NULL );
 126             ptrW += slen;
 127             ptrA += strlen(ptrA) + 1;
 128         }
 129         *ptrA = 0;
 130     }
 131
 132     RtlReleasePebLock();
 133     return ret;
 134 }
 135
 136
 137 /***********************************************************************
 138  *           GetEnvironmentStringsW   (KERNEL32.@)
 139  */
 140 LPWSTR WINAPI GetEnvironmentStringsW(void)
 141 {
 142     return NtCurrentTeb()->Peb->ProcessParameters->Environment;
 143 }
 144
 145
 146 /***********************************************************************
 147  *           FreeEnvironmentStringsA   (KERNEL32.@)
 148  */
 149 BOOL WINAPI FreeEnvironmentStringsA( LPSTR ptr )
 150 {
 151     return HeapFree( GetProcessHeap(), 0, ptr );
 152 }
 153
 154
 155 /***********************************************************************
 156  *           FreeEnvironmentStringsW   (KERNEL32.@)
 157  */
 158 BOOL WINAPI FreeEnvironmentStringsW( LPWSTR ptr )
 159 {
 160     return TRUE;
 161 }
 162
 163
 164 /***********************************************************************
 165  *           GetEnvironmentVariableA   (KERNEL32.@)
 166  */
 167 DWORD WINAPI GetEnvironmentVariableA( LPCSTR name, LPSTR value, DWORD size )
 168 {
 169     UNICODE_STRING      us_name;
 170     PWSTR               valueW;
 171     DWORD               ret;
 172
 173     if (!name || !*name)
 174     {
 175         SetLastError(ERROR_ENVVAR_NOT_FOUND);
 176         return 0;
 177     }
 178
 179     /* limit the size to sane values */
 180     size = min(size, 32767);
 181     if (!(valueW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR))))
 182         return 0;
 183
 184     RtlCreateUnicodeStringFromAsciiz( &us_name, name );
 185     SetLastError(0);
 186     ret = GetEnvironmentVariableW( us_name.Buffer, valueW, size);
 187     if (ret && ret < size)
 188     {
 189         WideCharToMultiByte( CP_ACP, 0, valueW, ret + 1, value, size, NULL, NULL );
 190     }
 191     /* this is needed to tell, with 0 as a return value, the difference between:
 192      * - an error (GetLastError() != 0)
 193      * - returning an empty string (in this case, we need to update the buffer)
 194      */
 195     if (ret == 0 && size && GetLastError() == 0)
 196         value[0] = '\0';
 197
 198     RtlFreeUnicodeString( &us_name );
 199     HeapFree(GetProcessHeap(), 0, valueW);
 200
 201     return ret;
 202 }
 203
 204
 205 /***********************************************************************
 206  *           GetEnvironmentVariableW   (KERNEL32.@)
 207  */
 208 DWORD WINAPI GetEnvironmentVariableW( LPCWSTR name, LPWSTR val, DWORD size )
 209 {
 210     UNICODE_STRING      us_name;
 211     UNICODE_STRING      us_value;
 212     NTSTATUS            status;
 213     unsigned            len;
 214
 215     TRACE("(%s %p %u)\n", debugstr_w(name), val, size);
 216
 217     if (!name || !*name)
 218     {
 219         SetLastError(ERROR_ENVVAR_NOT_FOUND);
 220         return 0;
 221     }
 222
 223     RtlInitUnicodeString(&us_name, name);
 224     us_value.Length = 0;
 225     us_value.MaximumLength = (size ? size - 1 : 0) * sizeof(WCHAR);
 226     us_value.Buffer = val;
 227
 228     status = RtlQueryEnvironmentVariable_U(NULL, &us_name, &us_value);
 229     len = us_value.Length / sizeof(WCHAR);
 230     if (status != STATUS_SUCCESS)
 231     {
 232         SetLastError( RtlNtStatusToDosError(status) );
 233         return (status == STATUS_BUFFER_TOO_SMALL) ? len + 1 : 0;
 234     }
 235     if (size) val[len] = '\0';
 236
 237     return us_value.Length / sizeof(WCHAR);
 238 }
 239
 240
 241 /***********************************************************************
 242  *           SetEnvironmentVariableA   (KERNEL32.@)
 243  */
 244 BOOL WINAPI SetEnvironmentVariableA( LPCSTR name, LPCSTR value )
 245 {
 246     UNICODE_STRING      us_name;
 247     BOOL                ret;
 248
 249     if (!name)
 250     {
 251         SetLastError(ERROR_ENVVAR_NOT_FOUND);
 252         return FALSE;
 253     }
 254
 255     RtlCreateUnicodeStringFromAsciiz( &us_name, name );
 256     if (value)
 257     {
 258         UNICODE_STRING      us_value;
 259
 260         RtlCreateUnicodeStringFromAsciiz( &us_value, value );
 261         ret = SetEnvironmentVariableW( us_name.Buffer, us_value.Buffer );
 262         RtlFreeUnicodeString( &us_value );
 263     }
 264     else ret = SetEnvironmentVariableW( us_name.Buffer, NULL );
 265
 266     RtlFreeUnicodeString( &us_name );
 267
 268     return ret;
 269 }
 270
 271
 272 /***********************************************************************
 273  *           SetEnvironmentVariableW   (KERNEL32.@)
 274  */
 275 BOOL WINAPI SetEnvironmentVariableW( LPCWSTR name, LPCWSTR value )
 276 {
 277     UNICODE_STRING      us_name;
 278     NTSTATUS            status;
 279
 280     TRACE("(%s %s)\n", debugstr_w(name), debugstr_w(value));
 281
 282     if (!name)
 283     {
 284         SetLastError(ERROR_ENVVAR_NOT_FOUND);
 285         return FALSE;
 286     }
 287
 288     RtlInitUnicodeString(&us_name, name);
 289     if (value)
 290     {
 291         UNICODE_STRING      us_value;
 292
 293         RtlInitUnicodeString(&us_value, value);
 294         status = RtlSetEnvironmentVariable(NULL, &us_name, &us_value);
 295     }
 296     else status = RtlSetEnvironmentVariable(NULL, &us_name, NULL);
 297
 298     if (status != STATUS_SUCCESS)
 299     {
 300         SetLastError( RtlNtStatusToDosError(status) );
 301         return FALSE;
 302     }
 303     return TRUE;
 304 }
 305
 306
 307 /***********************************************************************
 308  *           ExpandEnvironmentStringsA   (KERNEL32.@)
 309  *
 310  * See ExpandEnvironmentStringsW.
 311  *
 312  * Note: overlapping buffers are not supported; this is how it should be.
 313  * FIXME: return value is wrong for MBCS
 314  */
 315 DWORD WINAPI ExpandEnvironmentStringsA( LPCSTR src, LPSTR dst, DWORD count )
 316 {
 317     UNICODE_STRING      us_src;
 318     PWSTR               dstW = NULL;
 319     DWORD               ret;
 320
 321     RtlCreateUnicodeStringFromAsciiz( &us_src, src );
 322     if (count)
 323     {
 324         if (!(dstW = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR))))
 325             return 0;
 326         ret = ExpandEnvironmentStringsW( us_src.Buffer, dstW, count);
 327         if (ret)
 328             WideCharToMultiByte( CP_ACP, 0, dstW, ret, dst, count, NULL, NULL );
 329     }
 330     else ret = ExpandEnvironmentStringsW( us_src.Buffer, NULL, 0);
 331
 332     RtlFreeUnicodeString( &us_src );
 333     HeapFree(GetProcessHeap(), 0, dstW);
 334
 335     return ret;
 336 }
 337
 338
 339 /***********************************************************************
 340  *           ExpandEnvironmentStringsW   (KERNEL32.@)
 341  *
 342  * Replaces references to environment variables of the form '%EnvVar%'
 343  * by their value. If the environment variable does not exist, then the
 344  * reference is left as is.
 345  *
 346  * PARAMS
 347  *  src       [I] The string to be expanded.
 348  *  dst       [O] The buffer in which to put the expanded string.
 349  *  len       [I] The buffer size, in characters.
 350  *
 351  * RETURNS
 352  *  The number of characters copied into the buffer. If the buffer is
 353  *  too small, then the required buffer size, in characters including the
 354  *  trailing '\0', is returned.
 355  *  If the function fails for some other reason, then it returns 0.
 356  */
 357 DWORD WINAPI ExpandEnvironmentStringsW( LPCWSTR src, LPWSTR dst, DWORD len )
 358 {
 359     UNICODE_STRING      us_src;
 360     UNICODE_STRING      us_dst;
 361     NTSTATUS            status;
 362     DWORD               res;
 363
 364     TRACE("(%s %p %u)\n", debugstr_w(src), dst, len);
 365
 366     RtlInitUnicodeString(&us_src, src);
 367
 368     /* make sure we don't overflow the maximum UNICODE_STRING size */
 369     if (len > UNICODE_STRING_MAX_CHARS)
 370         len = UNICODE_STRING_MAX_CHARS;
 371
 372     us_dst.Length = 0;
 373     us_dst.MaximumLength = len * sizeof(WCHAR);
 374     us_dst.Buffer = dst;
 375
 376     res = 0;
 377     status = RtlExpandEnvironmentStrings_U(NULL, &us_src, &us_dst, &res);
 378     res /= sizeof(WCHAR);
 379     if (status != STATUS_SUCCESS)
 380     {
 381         SetLastError( RtlNtStatusToDosError(status) );
 382         if (status != STATUS_BUFFER_TOO_SMALL) return 0;
 383         if (len && dst) dst[len - 1] = '\0';
 384     }
 385
 386     return res;
 387 }
 388
 389
 390 /***********************************************************************
 391  *           GetStdHandle    (KERNEL32.@)
 392  */
 393 HANDLE WINAPI GetStdHandle( DWORD std_handle )
 394 {
 395     switch (std_handle)
 396     {
 397         case STD_INPUT_HANDLE:  return NtCurrentTeb()->Peb->ProcessParameters->hStdInput;
 398         case STD_OUTPUT_HANDLE: return NtCurrentTeb()->Peb->ProcessParameters->hStdOutput;
 399         case STD_ERROR_HANDLE:  return NtCurrentTeb()->Peb->ProcessParameters->hStdError;
 400     }
 401     SetLastError( ERROR_INVALID_HANDLE );
 402     return INVALID_HANDLE_VALUE;
 403 }
 404
 405
 406 /***********************************************************************
 407  *           SetStdHandle    (KERNEL32.@)
 408  */
 409 BOOL WINAPI SetStdHandle( DWORD std_handle, HANDLE handle )
 410 {
 411     switch (std_handle)
 412     {
 413         case STD_INPUT_HANDLE:  NtCurrentTeb()->Peb->ProcessParameters->hStdInput = handle;  return TRUE;
 414         case STD_OUTPUT_HANDLE: NtCurrentTeb()->Peb->ProcessParameters->hStdOutput = handle; return TRUE;
 415         case STD_ERROR_HANDLE:  NtCurrentTeb()->Peb->ProcessParameters->hStdError = handle;  return TRUE;
 416     }
 417     SetLastError( ERROR_INVALID_HANDLE );
 418     return FALSE;
 419 }
 420
 421 /***********************************************************************
 422  *              GetStartupInfoA         (KERNEL32.@)
 423  */
 424 VOID WINAPI GetStartupInfoA( LPSTARTUPINFOA info )
 425 {
 426     *info = startup_infoA;
 427 }
 428
 429
 430 /***********************************************************************
 431  *              GetStartupInfoW         (KERNEL32.@)
 432  */
 433 VOID WINAPI GetStartupInfoW( LPSTARTUPINFOW info )
 434 {
 435     *info = startup_infoW;
 436 }
 437
 438 /******************************************************************
 439  *              ENV_CopyStartupInformation (internal)
 440  *
 441  * Creates the STARTUPINFO information from the ntdll information
 442  */
 443 void ENV_CopyStartupInformation(void)
 444 {
 445     RTL_USER_PROCESS_PARAMETERS* rupp;
 446     ANSI_STRING         ansi;
 447
 448     RtlAcquirePebLock();
 449
 450     rupp = NtCurrentTeb()->Peb->ProcessParameters;
 451
 452     startup_infoW.cb                   = sizeof(startup_infoW);
 453     startup_infoW.lpReserved           = NULL;
 454     startup_infoW.lpDesktop            = rupp->Desktop.Buffer;
 455     startup_infoW.lpTitle              = rupp->WindowTitle.Buffer;
 456     startup_infoW.dwX                  = rupp->dwX;
 457     startup_infoW.dwY                  = rupp->dwY;
 458     startup_infoW.dwXSize              = rupp->dwXSize;
 459     startup_infoW.dwYSize              = rupp->dwYSize;
 460     startup_infoW.dwXCountChars        = rupp->dwXCountChars;
 461     startup_infoW.dwYCountChars        = rupp->dwYCountChars;
 462     startup_infoW.dwFillAttribute      = rupp->dwFillAttribute;
 463     startup_infoW.dwFlags              = rupp->dwFlags;
 464     startup_infoW.wShowWindow          = rupp->wShowWindow;
 465     startup_infoW.cbReserved2          = rupp->RuntimeInfo.MaximumLength;
 466     startup_infoW.lpReserved2          = rupp->RuntimeInfo.MaximumLength ? (void*)rupp->RuntimeInfo.Buffer : NULL;
 467     startup_infoW.hStdInput            = rupp->hStdInput ? rupp->hStdInput : INVALID_HANDLE_VALUE;
 468     startup_infoW.hStdOutput           = rupp->hStdOutput ? rupp->hStdOutput : INVALID_HANDLE_VALUE;
 469     startup_infoW.hStdError            = rupp->hStdError ? rupp->hStdError : INVALID_HANDLE_VALUE;
 470
 471     startup_infoA.cb                   = sizeof(startup_infoA);
 472     startup_infoA.lpReserved           = NULL;
 473     startup_infoA.lpDesktop = RtlUnicodeStringToAnsiString( &ansi, &rupp->Desktop, TRUE ) == STATUS_SUCCESS ?
 474         ansi.Buffer : NULL;
 475     startup_infoA.lpTitle = RtlUnicodeStringToAnsiString( &ansi, &rupp->WindowTitle, TRUE ) == STATUS_SUCCESS ?
 476         ansi.Buffer : NULL;
 477     startup_infoA.dwX                  = rupp->dwX;
 478     startup_infoA.dwY                  = rupp->dwY;
 479     startup_infoA.dwXSize              = rupp->dwXSize;
 480     startup_infoA.dwYSize              = rupp->dwYSize;
 481     startup_infoA.dwXCountChars        = rupp->dwXCountChars;
 482     startup_infoA.dwYCountChars        = rupp->dwYCountChars;
 483     startup_infoA.dwFillAttribute      = rupp->dwFillAttribute;
 484     startup_infoA.dwFlags              = rupp->dwFlags;
 485     startup_infoA.wShowWindow          = rupp->wShowWindow;
 486     startup_infoA.cbReserved2          = rupp->RuntimeInfo.MaximumLength;
 487     startup_infoA.lpReserved2          = rupp->RuntimeInfo.MaximumLength ? (void*)rupp->RuntimeInfo.Buffer : NULL;
 488     startup_infoA.hStdInput            = rupp->hStdInput ? rupp->hStdInput : INVALID_HANDLE_VALUE;
 489     startup_infoA.hStdOutput           = rupp->hStdOutput ? rupp->hStdOutput : INVALID_HANDLE_VALUE;
 490     startup_infoA.hStdError            = rupp->hStdError ? rupp->hStdError : INVALID_HANDLE_VALUE;
 491
 492     RtlReleasePebLock();
 493 }
 494
 495 /***********************************************************************
 496  *              GetFirmwareEnvironmentVariableA         (KERNEL32.@)
 497  */
 498 DWORD WINAPI GetFirmwareEnvironmentVariableA(LPCSTR name, LPCSTR guid, PVOID buffer, DWORD size)
 499 {
 500     FIXME("stub: %s %s %p %u\n", debugstr_a(name), debugstr_a(guid), buffer, size);
 501     SetLastError(ERROR_INVALID_FUNCTION);
 502     return 0;
 503 }
 504
 505 /***********************************************************************
 506  *              GetFirmwareEnvironmentVariableW         (KERNEL32.@)
 507  */
 508 DWORD WINAPI GetFirmwareEnvironmentVariableW(LPCWSTR name, LPCWSTR guid, PVOID buffer, DWORD size)
 509 {
 510     FIXME("stub: %s %s %p %u\n", debugstr_w(name), debugstr_w(guid), buffer, size);
 511     SetLastError(ERROR_INVALID_FUNCTION);
 512     return 0;
 513 }