dlls/kernel/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winerror.h"
  33 #include "thread.h"
  34 #include "wine/server.h"
  35 #include "wine/library.h"
  36 #include "winternl.h"
  37 #include "wine/unicode.h"
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(environ);
  41
  42 /* Notes:
  43  * - contrary to Microsoft docs, the environment strings do not appear
  44  *   to be sorted on Win95 (although they are on NT); so we don't bother
  45  *   to sort them either.
  46  */
  47
  48 static STARTUPINFOW startup_infoW;
  49 static STARTUPINFOA startup_infoA;
  50
  51
  52 /***********************************************************************
  53  *           GetCommandLineA      (KERNEL32.@)
  54  *
  55  * WARNING: there's a Windows incompatibility lurking here !
  56  * Win32s always includes the full path of the program file,
  57  * whereas Windows NT only returns the full file path plus arguments
  58  * in case the program has been started with a full path.
  59  * Win9x seems to have inherited NT behaviour.
  60  *
  61  * Note that both Start Menu Execute and Explorer start programs with
  62  * fully specified quoted app file paths, which is why probably the only case
  63  * where you'll see single file names is in case of direct launch
  64  * via CreateProcess or WinExec.
  65  *
  66  * Perhaps we should take care of Win3.1 programs here (Win32s "feature").
  67  *
  68  * References: MS KB article q102762.txt (special Win32s handling)
  69  */
  70 LPSTR WINAPI GetCommandLineA(void)
  71 {
  72     static char *cmdlineA;  /* ASCII command line */
  73
  74     if (!cmdlineA) /* make an ansi version if we don't have it */
  75     {
  76         ANSI_STRING     ansi;
  77         RtlAcquirePebLock();
  78
  79         cmdlineA = (RtlUnicodeStringToAnsiString( &ansi, &NtCurrentTeb()->Peb->ProcessParameters->CommandLine, TRUE) == STATUS_SUCCESS) ?
  80             ansi.Buffer : NULL;
  81         RtlReleasePebLock();
  82     }
  83     return cmdlineA;
  84 }
  85
  86 /***********************************************************************
  87  *           GetCommandLineW      (KERNEL32.@)
  88  */
  89 LPWSTR WINAPI GetCommandLineW(void)
  90 {
  91     return NtCurrentTeb()->Peb->ProcessParameters->CommandLine.Buffer;
  92 }
  93
  94
  95 /***********************************************************************
  96  *           GetEnvironmentStrings    (KERNEL32.@)
  97  *           GetEnvironmentStringsA   (KERNEL32.@)
  98  */
  99 LPSTR WINAPI GetEnvironmentStringsA(void)
 100 {
 101     LPWSTR      ptrW;
 102     unsigned    len, slen;
 103     LPSTR       ret, ptrA;
 104
 105     RtlAcquirePebLock();
 106
 107     len = 1;
 108
 109     ptrW = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 110     while (*ptrW)
 111     {
 112         slen = strlenW(ptrW) + 1;
 113         len += WideCharToMultiByte( CP_ACP, 0, ptrW, slen, NULL, 0, NULL, NULL );
 114         ptrW += slen;
 115     }
 116
 117     if ((ret = HeapAlloc( GetProcessHeap(), 0, len )) != NULL)
 118     {
 119         ptrW = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 120         ptrA = ret;
 121         while (*ptrW)
 122         {
 123             slen = strlenW(ptrW) + 1;
 124             WideCharToMultiByte( CP_ACP, 0, ptrW, slen, ptrA, len, NULL, NULL );
 125             ptrW += slen;
 126             ptrA += strlen(ptrA) + 1;
 127         }
 128         *ptrA = 0;
 129     }
 130
 131     RtlReleasePebLock();
 132     return ret;
 133 }
 134
 135
 136 /***********************************************************************
 137  *           GetEnvironmentStringsW   (KERNEL32.@)
 138  */
 139 LPWSTR WINAPI GetEnvironmentStringsW(void)
 140 {
 141     return NtCurrentTeb()->Peb->ProcessParameters->Environment;
 142 }
 143
 144
 145 /***********************************************************************
 146  *           FreeEnvironmentStringsA   (KERNEL32.@)
 147  */
 148 BOOL WINAPI FreeEnvironmentStringsA( LPSTR ptr )
 149 {
 150     return HeapFree( GetProcessHeap(), 0, ptr );
 151 }
 152
 153
 154 /***********************************************************************
 155  *           FreeEnvironmentStringsW   (KERNEL32.@)
 156  */
 157 BOOL WINAPI FreeEnvironmentStringsW( LPWSTR ptr )
 158 {
 159     return TRUE;
 160 }
 161
 162
 163 /***********************************************************************
 164  *           GetEnvironmentVariableA   (KERNEL32.@)
 165  */
 166 DWORD WINAPI GetEnvironmentVariableA( LPCSTR name, LPSTR value, DWORD size )
 167 {
 168     UNICODE_STRING      us_name;
 169     PWSTR               valueW;
 170     DWORD               ret;
 171
 172     if (!name || !*name)
 173     {
 174         SetLastError(ERROR_ENVVAR_NOT_FOUND);
 175         return 0;
 176     }
 177
 178     if (!(valueW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR))))
 179         return 0;
 180
 181     RtlCreateUnicodeStringFromAsciiz( &us_name, name );
 182     SetLastError(0);
 183     ret = GetEnvironmentVariableW( us_name.Buffer, valueW, size);
 184     if (ret && ret < size)
 185     {
 186         WideCharToMultiByte( CP_ACP, 0, valueW, ret + 1, value, size, NULL, NULL );
 187     }
 188     /* this is needed to tell, with 0 as a return value, the difference between:
 189      * - an error (GetLastError() != 0)
 190      * - returning an empty string (in this case, we need to update the buffer)
 191      */
 192     if (ret == 0 && size && GetLastError() == 0)
 193         value[0] = '\0';
 194
 195     RtlFreeUnicodeString( &us_name );
 196     HeapFree(GetProcessHeap(), 0, valueW);
 197
 198     return ret;
 199 }
 200
 201
 202 /***********************************************************************
 203  *           GetEnvironmentVariableW   (KERNEL32.@)
 204  */
 205 DWORD WINAPI GetEnvironmentVariableW( LPCWSTR name, LPWSTR val, DWORD size )
 206 {
 207     UNICODE_STRING      us_name;
 208     UNICODE_STRING      us_value;
 209     NTSTATUS            status;
 210     unsigned            len;
 211
 212     TRACE("(%s %p %lu)\n", debugstr_w(name), val, size);
 213
 214     if (!name || !*name)
 215     {
 216         SetLastError(ERROR_ENVVAR_NOT_FOUND);
 217         return 0;
 218     }
 219
 220     RtlInitUnicodeString(&us_name, name);
 221     us_value.Length = 0;
 222     us_value.MaximumLength = (size ? size - 1 : 0) * sizeof(WCHAR);
 223     us_value.Buffer = val;
 224
 225     status = RtlQueryEnvironmentVariable_U(NULL, &us_name, &us_value);
 226     len = us_value.Length / sizeof(WCHAR);
 227     if (status != STATUS_SUCCESS)
 228     {
 229         SetLastError( RtlNtStatusToDosError(status) );
 230         return (status == STATUS_BUFFER_TOO_SMALL) ? len + 1 : 0;
 231     }
 232     if (size) val[len] = '\0';
 233
 234     return us_value.Length / sizeof(WCHAR);
 235 }
 236
 237
 238 /***********************************************************************
 239  *           SetEnvironmentVariableA   (KERNEL32.@)
 240  */
 241 BOOL WINAPI SetEnvironmentVariableA( LPCSTR name, LPCSTR value )
 242 {
 243     UNICODE_STRING      us_name;
 244     BOOL                ret;
 245
 246     if (!name)
 247     {
 248         SetLastError(ERROR_ENVVAR_NOT_FOUND);
 249         return 0;
 250     }
 251
 252     RtlCreateUnicodeStringFromAsciiz( &us_name, name );
 253     if (value)
 254     {
 255         UNICODE_STRING      us_value;
 256
 257         RtlCreateUnicodeStringFromAsciiz( &us_value, value );
 258         ret = SetEnvironmentVariableW( us_name.Buffer, us_value.Buffer );
 259         RtlFreeUnicodeString( &us_value );
 260     }
 261     else ret = SetEnvironmentVariableW( us_name.Buffer, NULL );
 262
 263     RtlFreeUnicodeString( &us_name );
 264
 265     return ret;
 266 }
 267
 268
 269 /***********************************************************************
 270  *           SetEnvironmentVariableW   (KERNEL32.@)
 271  */
 272 BOOL WINAPI SetEnvironmentVariableW( LPCWSTR name, LPCWSTR value )
 273 {
 274     UNICODE_STRING      us_name;
 275     NTSTATUS            status;
 276
 277     TRACE("(%s %s)\n", debugstr_w(name), debugstr_w(value));
 278
 279     if (!name)
 280     {
 281         SetLastError(ERROR_ENVVAR_NOT_FOUND);
 282         return 0;
 283     }
 284
 285     RtlInitUnicodeString(&us_name, name);
 286     if (value)
 287     {
 288         UNICODE_STRING      us_value;
 289
 290         RtlInitUnicodeString(&us_value, value);
 291         status = RtlSetEnvironmentVariable(NULL, &us_name, &us_value);
 292     }
 293     else status = RtlSetEnvironmentVariable(NULL, &us_name, NULL);
 294
 295     if (status != STATUS_SUCCESS)
 296     {
 297         SetLastError( RtlNtStatusToDosError(status) );
 298         return FALSE;
 299     }
 300     return TRUE;
 301 }
 302
 303
 304 /***********************************************************************
 305  *           ExpandEnvironmentStringsA   (KERNEL32.@)
 306  *
 307  * Note: overlapping buffers are not supported; this is how it should be.
 308  * FIXME: return value is wrong for MBCS
 309  */
 310 DWORD WINAPI ExpandEnvironmentStringsA( LPCSTR src, LPSTR dst, DWORD count )
 311 {
 312     UNICODE_STRING      us_src;
 313     PWSTR               dstW = NULL;
 314     DWORD               ret;
 315
 316     RtlCreateUnicodeStringFromAsciiz( &us_src, src );
 317     if (count)
 318     {
 319         if (!(dstW = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR))))
 320             return 0;
 321         ret = ExpandEnvironmentStringsW( us_src.Buffer, dstW, count);
 322         if (ret)
 323             WideCharToMultiByte( CP_ACP, 0, dstW, ret, dst, count, NULL, NULL );
 324     }
 325     else ret = ExpandEnvironmentStringsW( us_src.Buffer, NULL, 0);
 326
 327     RtlFreeUnicodeString( &us_src );
 328     HeapFree(GetProcessHeap(), 0, dstW);
 329
 330     return ret;
 331 }
 332
 333
 334 /***********************************************************************
 335  *           ExpandEnvironmentStringsW   (KERNEL32.@)
 336  */
 337 DWORD WINAPI ExpandEnvironmentStringsW( LPCWSTR src, LPWSTR dst, DWORD len )
 338 {
 339     UNICODE_STRING      us_src;
 340     UNICODE_STRING      us_dst;
 341     NTSTATUS            status;
 342     DWORD               res;
 343
 344     TRACE("(%s %p %lu)\n", debugstr_w(src), dst, len);
 345
 346     RtlInitUnicodeString(&us_src, src);
 347     us_dst.Length = 0;
 348     us_dst.MaximumLength = len * sizeof(WCHAR);
 349     us_dst.Buffer = dst;
 350
 351     res = 0;
 352     status = RtlExpandEnvironmentStrings_U(NULL, &us_src, &us_dst, &res);
 353     res /= sizeof(WCHAR);
 354     if (status != STATUS_SUCCESS)
 355     {
 356         SetLastError( RtlNtStatusToDosError(status) );
 357         if (status != STATUS_BUFFER_TOO_SMALL) return 0;
 358         if (len && dst) dst[len - 1] = '\0';
 359     }
 360
 361     return res;
 362 }
 363
 364
 365 /***********************************************************************
 366  *           GetStdHandle    (KERNEL32.@)
 367  */
 368 HANDLE WINAPI GetStdHandle( DWORD std_handle )
 369 {
 370     switch (std_handle)
 371     {
 372         case STD_INPUT_HANDLE:  return NtCurrentTeb()->Peb->ProcessParameters->hStdInput;
 373         case STD_OUTPUT_HANDLE: return NtCurrentTeb()->Peb->ProcessParameters->hStdOutput;
 374         case STD_ERROR_HANDLE:  return NtCurrentTeb()->Peb->ProcessParameters->hStdError;
 375     }
 376     SetLastError( ERROR_INVALID_PARAMETER );
 377     return INVALID_HANDLE_VALUE;
 378 }
 379
 380
 381 /***********************************************************************
 382  *           SetStdHandle    (KERNEL32.@)
 383  */
 384 BOOL WINAPI SetStdHandle( DWORD std_handle, HANDLE handle )
 385 {
 386     switch (std_handle)
 387     {
 388         case STD_INPUT_HANDLE:  NtCurrentTeb()->Peb->ProcessParameters->hStdInput = handle;  return TRUE;
 389         case STD_OUTPUT_HANDLE: NtCurrentTeb()->Peb->ProcessParameters->hStdOutput = handle; return TRUE;
 390         case STD_ERROR_HANDLE:  NtCurrentTeb()->Peb->ProcessParameters->hStdError = handle;  return TRUE;
 391     }
 392     SetLastError( ERROR_INVALID_PARAMETER );
 393     return FALSE;
 394 }
 395
 396 /***********************************************************************
 397  *              GetStartupInfoA         (KERNEL32.@)
 398  */
 399 VOID WINAPI GetStartupInfoA( LPSTARTUPINFOA info )
 400 {
 401     assert(startup_infoA.cb);
 402     memcpy(info, &startup_infoA, sizeof(startup_infoA));
 403 }
 404
 405
 406 /***********************************************************************
 407  *              GetStartupInfoW         (KERNEL32.@)
 408  */
 409 VOID WINAPI GetStartupInfoW( LPSTARTUPINFOW info )
 410 {
 411     assert(startup_infoW.cb);
 412     memcpy(info, &startup_infoW, sizeof(startup_infoW));
 413 }
 414
 415 /******************************************************************
 416  *              ENV_CopyStartupInformation (internal)
 417  *
 418  * Creates the STARTUPINFO information from the ntdll information
 419  */
 420 void ENV_CopyStartupInformation(void)
 421 {
 422     RTL_USER_PROCESS_PARAMETERS* rupp;
 423     ANSI_STRING         ansi;
 424
 425     RtlAcquirePebLock();
 426
 427     rupp = NtCurrentTeb()->Peb->ProcessParameters;
 428
 429     startup_infoW.cb                   = sizeof(startup_infoW);
 430     startup_infoW.lpReserved           = NULL;
 431     startup_infoW.lpDesktop            = rupp->Desktop.Buffer;
 432     startup_infoW.lpTitle              = rupp->WindowTitle.Buffer;
 433     startup_infoW.dwX                  = rupp->dwX;
 434     startup_infoW.dwY                  = rupp->dwY;
 435     startup_infoW.dwXSize              = rupp->dwXSize;
 436     startup_infoW.dwYSize              = rupp->dwYSize;
 437     startup_infoW.dwXCountChars        = rupp->dwXCountChars;
 438     startup_infoW.dwYCountChars        = rupp->dwYCountChars;
 439     startup_infoW.dwFillAttribute      = rupp->dwFillAttribute;
 440     startup_infoW.dwFlags              = rupp->dwFlags;
 441     startup_infoW.wShowWindow          = rupp->wShowWindow;
 442     startup_infoW.cbReserved2          = rupp->RuntimeInfo.MaximumLength;
 443     startup_infoW.lpReserved2          = rupp->RuntimeInfo.MaximumLength ? (void*)rupp->RuntimeInfo.Buffer : NULL;
 444     startup_infoW.hStdInput            = rupp->hStdInput;
 445     startup_infoW.hStdOutput           = rupp->hStdOutput;
 446     startup_infoW.hStdError            = rupp->hStdError;
 447
 448     startup_infoA.cb                   = sizeof(startup_infoA);
 449     startup_infoA.lpReserved           = NULL;
 450     startup_infoA.lpDesktop = (rupp->Desktop.Length &&
 451                                RtlUnicodeStringToAnsiString( &ansi, &rupp->Desktop, TRUE) == STATUS_SUCCESS) ?
 452         ansi.Buffer : NULL;
 453     startup_infoA.lpTitle = (rupp->WindowTitle.Length &&
 454                              RtlUnicodeStringToAnsiString( &ansi, &rupp->WindowTitle, TRUE) == STATUS_SUCCESS) ?
 455         ansi.Buffer : NULL;
 456     startup_infoA.dwX                  = rupp->dwX;
 457     startup_infoA.dwY                  = rupp->dwY;
 458     startup_infoA.dwXSize              = rupp->dwXSize;
 459     startup_infoA.dwYSize              = rupp->dwYSize;
 460     startup_infoA.dwXCountChars        = rupp->dwXCountChars;
 461     startup_infoA.dwYCountChars        = rupp->dwYCountChars;
 462     startup_infoA.dwFillAttribute      = rupp->dwFillAttribute;
 463     startup_infoA.dwFlags              = rupp->dwFlags;
 464     startup_infoA.wShowWindow          = rupp->wShowWindow;
 465     startup_infoA.cbReserved2          = rupp->RuntimeInfo.MaximumLength;
 466     startup_infoA.lpReserved2          = rupp->RuntimeInfo.MaximumLength ? (void*)rupp->RuntimeInfo.Buffer : NULL;
 467     startup_infoA.hStdInput            = rupp->hStdInput;
 468     startup_infoA.hStdOutput           = rupp->hStdOutput;
 469     startup_infoA.hStdError            = rupp->hStdError;
 470
 471     RtlReleasePebLock();
 472 }