memory/environ.c

   1 /*
   2  * Process environment management
   3  *
   4  * Copyright 1996, 1998 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include "windef.h"
  10 #include "winnls.h"
  11 #include "winerror.h"
  12 #include "process.h"
  13 #include "heap.h"
  14 #include "selectors.h"
  15
  16 /* Format of an environment block:
  17  * ASCIIZ   string 1 (xx=yy format)
  18  * ...
  19  * ASCIIZ   string n
  20  * BYTE     0
  21  * WORD     1
  22  * ASCIIZ   program name (e.g. C:\WINDOWS\SYSTEM\KRNL386.EXE)
  23  *
  24  * Notes:
  25  * - contrary to Microsoft docs, the environment strings do not appear
  26  *   to be sorted on Win95 (although they are on NT); so we don't bother
  27  *   to sort them either.
  28  */
  29
  30 static const char ENV_program_name[] = "C:\\WINDOWS\\SYSTEM\\KRNL386.EXE";
  31
  32 /* Maximum length of a Win16 environment string (including NULL) */
  33 #define MAX_WIN16_LEN  128
  34
  35 /* Extra bytes to reserve at the end of an environment */
  36 #define EXTRA_ENV_SIZE (sizeof(BYTE) + sizeof(WORD) + sizeof(ENV_program_name))
  37
  38 /* Fill the extra bytes with the program name and stuff */
  39 #define FILL_EXTRA_ENV(p) \
  40     *(p) = '\0'; \
  41     PUT_WORD( (p) + 1, 1 ); \
  42     strcpy( (p) + 3, ENV_program_name );
  43
  44 STARTUPINFOA current_startupinfo =
  45 {
  46     sizeof(STARTUPINFOA),    /* cb */
  47     0,                       /* lpReserved */
  48     0,                       /* lpDesktop */
  49     0,                       /* lpTitle */
  50     0,                       /* dwX */
  51     0,                       /* dwY */
  52     0,                       /* dwXSize */
  53     0,                       /* dwYSize */
  54     0,                       /* dwXCountChars */
  55     0,                       /* dwYCountChars */
  56     0,                       /* dwFillAttribute */
  57     0,                       /* dwFlags */
  58     0,                       /* wShowWindow */
  59     0,                       /* cbReserved2 */
  60     0,                       /* lpReserved2 */
  61     0,                       /* hStdInput */
  62     0,                       /* hStdOutput */
  63     0                        /* hStdError */
  64 };
  65
  66 ENVDB current_envdb =
  67 {
  68     0,                       /* environ */
  69     0,                       /* unknown1 */
  70     0,                       /* cmd_line */
  71     0,                       /* cur_dir */
  72     &current_startupinfo,    /* startup_info */
  73     0,                       /* hStdin */
  74     0,                       /* hStdout */
  75     0,                       /* hStderr */
  76     0,                       /* unknown2 */
  77     0,                       /* inherit_console */
  78     0,                       /* break_type */
  79     0,                       /* break_sem */
  80     0,                       /* break_event */
  81     0,                       /* break_thread */
  82     0,                       /* break_handlers */
  83     CRITICAL_SECTION_INIT,   /* section */
  84     0,                       /* cmd_lineW */
  85     0                        /* env_sel */
  86 };
  87
  88 /***********************************************************************
  89  *           ENV_FindVariable
  90  *
  91  * Find a variable in the environment and return a pointer to the value.
  92  * Helper function for GetEnvironmentVariable and ExpandEnvironmentStrings.
  93  */
  94 static LPCSTR ENV_FindVariable( LPCSTR env, LPCSTR name, INT len )
  95 {
  96     while (*env)
  97     {
  98         if (!strncasecmp( name, env, len ) && (env[len] == '='))
  99             return env + len + 1;
 100         env += strlen(env) + 1;
 101     }
 102     return NULL;
 103 }
 104
 105
 106 /***********************************************************************
 107  *           ENV_BuildEnvironment
 108  *
 109  * Build the environment for the initial process
 110  */
 111 BOOL ENV_BuildEnvironment(void)
 112 {
 113     extern char **environ;
 114     LPSTR p, *e;
 115     int size;
 116
 117     /* Compute the total size of the Unix environment */
 118
 119     size = EXTRA_ENV_SIZE;
 120     for (e = environ; *e; e++) size += strlen(*e) + 1;
 121
 122     /* Now allocate the environment */
 123
 124     if (!(p = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
 125     current_envdb.environ = p;
 126     current_envdb.env_sel = SELECTOR_AllocBlock( p, 0x10000, WINE_LDT_FLAGS_DATA );
 127
 128     /* And fill it with the Unix environment */
 129
 130     for (e = environ; *e; e++)
 131     {
 132         strcpy( p, *e );
 133         p += strlen(p) + 1;
 134     }
 135
 136     /* Now add the program name */
 137
 138     FILL_EXTRA_ENV( p );
 139     return TRUE;
 140 }
 141
 142
 143 /***********************************************************************
 144  *           GetCommandLineA      (KERNEL32.289)
 145  */
 146 LPSTR WINAPI GetCommandLineA(void)
 147 {
 148     return current_envdb.cmd_line;
 149 }
 150
 151 /***********************************************************************
 152  *           GetCommandLineW      (KERNEL32.290)
 153  */
 154 LPWSTR WINAPI GetCommandLineW(void)
 155 {
 156     EnterCriticalSection( &current_envdb.section );
 157     if (!current_envdb.cmd_lineW)
 158         current_envdb.cmd_lineW = HEAP_strdupAtoW( GetProcessHeap(), 0,
 159                                                   current_envdb.cmd_line );
 160     LeaveCriticalSection( &current_envdb.section );
 161     return current_envdb.cmd_lineW;
 162 }
 163
 164
 165 /***********************************************************************
 166  *           GetEnvironmentStringsA   (KERNEL32.319) (KERNEL32.320)
 167  */
 168 LPSTR WINAPI GetEnvironmentStringsA(void)
 169 {
 170     return current_envdb.environ;
 171 }
 172
 173
 174 /***********************************************************************
 175  *           GetEnvironmentStringsW   (KERNEL32.321)
 176  */
 177 LPWSTR WINAPI GetEnvironmentStringsW(void)
 178 {
 179     INT size;
 180     LPWSTR ret;
 181
 182     EnterCriticalSection( &current_envdb.section );
 183     size = HeapSize( GetProcessHeap(), 0, current_envdb.environ );
 184     if ((ret = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) )) != NULL)
 185     {
 186         LPSTR pA = current_envdb.environ;
 187         LPWSTR pW = ret;
 188         while (size--) *pW++ = (WCHAR)(BYTE)*pA++;
 189     }
 190     LeaveCriticalSection( &current_envdb.section );
 191     return ret;
 192 }
 193
 194
 195 /***********************************************************************
 196  *           FreeEnvironmentStringsA   (KERNEL32.268)
 197  */
 198 BOOL WINAPI FreeEnvironmentStringsA( LPSTR ptr )
 199 {
 200     if (ptr != current_envdb.environ)
 201     {
 202         SetLastError( ERROR_INVALID_PARAMETER );
 203         return FALSE;
 204     }
 205     return TRUE;
 206 }
 207
 208
 209 /***********************************************************************
 210  *           FreeEnvironmentStringsW   (KERNEL32.269)
 211  */
 212 BOOL WINAPI FreeEnvironmentStringsW( LPWSTR ptr )
 213 {
 214     return HeapFree( GetProcessHeap(), 0, ptr );
 215 }
 216
 217
 218 /***********************************************************************
 219  *           GetEnvironmentVariableA   (KERNEL32.322)
 220  */
 221 DWORD WINAPI GetEnvironmentVariableA( LPCSTR name, LPSTR value, DWORD size )
 222 {
 223     LPCSTR p;
 224     INT ret = 0;
 225
 226     if (!name || !*name)
 227     {
 228         SetLastError( ERROR_INVALID_PARAMETER );
 229         return 0;
 230     }
 231     EnterCriticalSection( &current_envdb.section );
 232     if ((p = ENV_FindVariable( current_envdb.environ, name, strlen(name) )))
 233     {
 234         ret = strlen(p);
 235         if (size <= ret)
 236         {
 237             /* If not enough room, include the terminating null
 238              * in the returned size and return an empty string */
 239             ret++;
 240             if (value) *value = '\0';
 241         }
 242         else if (value) strcpy( value, p );
 243     }
 244     LeaveCriticalSection( &current_envdb.section );
 245     if (!ret)
 246         SetLastError( ERROR_ENVVAR_NOT_FOUND );
 247     return ret;
 248 }
 249
 250
 251 /***********************************************************************
 252  *           GetEnvironmentVariableW   (KERNEL32.323)
 253  */
 254 DWORD WINAPI GetEnvironmentVariableW( LPCWSTR nameW, LPWSTR valW, DWORD size)
 255 {
 256     LPSTR name = HEAP_strdupWtoA( GetProcessHeap(), 0, nameW );
 257     LPSTR val  = valW ? HeapAlloc( GetProcessHeap(), 0, size ) : NULL;
 258     DWORD res  = GetEnvironmentVariableA( name, val, size );
 259     HeapFree( GetProcessHeap(), 0, name );
 260     if (val)
 261     {
 262         if (size > 0 && !MultiByteToWideChar( CP_ACP, 0, val, -1, valW, size ))
 263             valW[size-1] = 0;
 264         HeapFree( GetProcessHeap(), 0, val );
 265     }
 266     return res;
 267 }
 268
 269
 270 /***********************************************************************
 271  *           SetEnvironmentVariableA   (KERNEL32.641)
 272  */
 273 BOOL WINAPI SetEnvironmentVariableA( LPCSTR name, LPCSTR value )
 274 {
 275     INT old_size, len, res;
 276     LPSTR p, env, new_env;
 277     BOOL ret = FALSE;
 278
 279     EnterCriticalSection( &current_envdb.section );
 280     env = p = current_envdb.environ;
 281
 282     /* Find a place to insert the string */
 283
 284     res = -1;
 285     len = strlen(name);
 286     while (*p)
 287     {
 288         if (!strncasecmp( name, p, len ) && (p[len] == '=')) break;
 289         p += strlen(p) + 1;
 290     }
 291     if (!value && !*p) goto done;  /* Value to remove doesn't exist */
 292
 293     /* Realloc the buffer */
 294
 295     len = value ? strlen(name) + strlen(value) + 2 : 0;
 296     if (*p) len -= strlen(p) + 1;  /* The name already exists */
 297     old_size = HeapSize( GetProcessHeap(), 0, env );
 298     if (len < 0)
 299     {
 300         LPSTR next = p + strlen(p) + 1;  /* We know there is a next one */
 301         memmove( next + len, next, old_size - (next - env) );
 302     }
 303     if (!(new_env = HeapReAlloc( GetProcessHeap(), 0, env, old_size + len )))
 304         goto done;
 305     if (current_envdb.env_sel)
 306         current_envdb.env_sel = SELECTOR_ReallocBlock( current_envdb.env_sel,
 307                                                        new_env, old_size + len );
 308     p = new_env + (p - env);
 309     if (len > 0) memmove( p + len, p, old_size - (p - new_env) );
 310
 311     /* Set the new string */
 312
 313     if (value)
 314     {
 315         strcpy( p, name );
 316         strcat( p, "=" );
 317         strcat( p, value );
 318     }
 319     current_envdb.environ = new_env;
 320     ret = TRUE;
 321
 322 done:
 323     LeaveCriticalSection( &current_envdb.section );
 324     return ret;
 325 }
 326
 327
 328 /***********************************************************************
 329  *           SetEnvironmentVariableW   (KERNEL32.642)
 330  */
 331 BOOL WINAPI SetEnvironmentVariableW( LPCWSTR name, LPCWSTR value )
 332 {
 333     LPSTR nameA  = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 334     LPSTR valueA = HEAP_strdupWtoA( GetProcessHeap(), 0, value );
 335     BOOL ret = SetEnvironmentVariableA( nameA, valueA );
 336     HeapFree( GetProcessHeap(), 0, nameA );
 337     HeapFree( GetProcessHeap(), 0, valueA );
 338     return ret;
 339 }
 340
 341
 342 /***********************************************************************
 343  *           ExpandEnvironmentStringsA   (KERNEL32.216)
 344  *
 345  * Note: overlapping buffers are not supported; this is how it should be.
 346  */
 347 DWORD WINAPI ExpandEnvironmentStringsA( LPCSTR src, LPSTR dst, DWORD count )
 348 {
 349     DWORD len, total_size = 1;  /* 1 for terminating '\0' */
 350     LPCSTR p, var;
 351
 352     if (!count) dst = NULL;
 353     EnterCriticalSection( &current_envdb.section );
 354
 355     while (*src)
 356     {
 357         if (*src != '%')
 358         {
 359             if ((p = strchr( src, '%' ))) len = p - src;
 360             else len = strlen(src);
 361             var = src;
 362             src += len;
 363         }
 364         else  /* we are at the start of a variable */
 365         {
 366             if ((p = strchr( src + 1, '%' )))
 367             {
 368                 len = p - src - 1;  /* Length of the variable name */
 369                 if ((var = ENV_FindVariable( current_envdb.environ,
 370                                              src + 1, len )))
 371                 {
 372                     src += len + 2;  /* Skip the variable name */
 373                     len = strlen(var);
 374                 }
 375                 else
 376                 {
 377                     var = src;  /* Copy original name instead */
 378                     len += 2;
 379                     src += len;
 380                 }
 381             }
 382             else  /* unfinished variable name, ignore it */
 383             {
 384                 var = src;
 385                 len = strlen(src);  /* Copy whole string */
 386                 src += len;
 387             }
 388         }
 389         total_size += len;
 390         if (dst)
 391         {
 392             if (count < len) len = count;
 393             memcpy( dst, var, len );
 394             dst += len;
 395             count -= len;
 396         }
 397     }
 398     LeaveCriticalSection( &current_envdb.section );
 399
 400     /* Null-terminate the string */
 401     if (dst)
 402     {
 403         if (!count) dst--;
 404         *dst = '\0';
 405     }
 406     return total_size;
 407 }
 408
 409
 410 /***********************************************************************
 411  *           ExpandEnvironmentStringsW   (KERNEL32.217)
 412  */
 413 DWORD WINAPI ExpandEnvironmentStringsW( LPCWSTR src, LPWSTR dst, DWORD len )
 414 {
 415     LPSTR srcA = HEAP_strdupWtoA( GetProcessHeap(), 0, src );
 416     LPSTR dstA = dst ? HeapAlloc( GetProcessHeap(), 0, len ) : NULL;
 417     DWORD ret  = ExpandEnvironmentStringsA( srcA, dstA, len );
 418     if (dstA)
 419     {
 420         ret = MultiByteToWideChar( CP_ACP, 0, dstA, -1, dst, len );
 421         HeapFree( GetProcessHeap(), 0, dstA );
 422     }
 423     HeapFree( GetProcessHeap(), 0, srcA );
 424     return ret;
 425 }
 426
 427
 428 /***********************************************************************
 429  *           GetStdHandle    (KERNEL32.276)
 430  */
 431 HANDLE WINAPI GetStdHandle( DWORD std_handle )
 432 {
 433     switch(std_handle)
 434     {
 435         case STD_INPUT_HANDLE:  return current_envdb.hStdin;
 436         case STD_OUTPUT_HANDLE: return current_envdb.hStdout;
 437         case STD_ERROR_HANDLE:  return current_envdb.hStderr;
 438     }
 439     SetLastError( ERROR_INVALID_PARAMETER );
 440     return INVALID_HANDLE_VALUE;
 441 }
 442
 443
 444 /***********************************************************************
 445  *           SetStdHandle    (KERNEL32.506)
 446  */
 447 BOOL WINAPI SetStdHandle( DWORD std_handle, HANDLE handle )
 448 {
 449     switch(std_handle)
 450     {
 451         case STD_INPUT_HANDLE:  current_envdb.hStdin = handle;  return TRUE;
 452         case STD_OUTPUT_HANDLE: current_envdb.hStdout = handle; return TRUE;
 453         case STD_ERROR_HANDLE:  current_envdb.hStderr = handle; return TRUE;
 454     }
 455     SetLastError( ERROR_INVALID_PARAMETER );
 456     return FALSE;
 457 }
 458
 459
 460 /***********************************************************************
 461  *              GetStartupInfoA         (KERNEL32.273)
 462  */
 463 VOID WINAPI GetStartupInfoA( LPSTARTUPINFOA info )
 464 {
 465     *info = current_startupinfo;
 466 }
 467
 468
 469 /***********************************************************************
 470  *              GetStartupInfoW         (KERNEL32.274)
 471  */
 472 VOID WINAPI GetStartupInfoW( LPSTARTUPINFOW info )
 473 {
 474     info->cb              = sizeof(STARTUPINFOW);
 475     info->dwX             = current_startupinfo.dwX;
 476     info->dwY             = current_startupinfo.dwY;
 477     info->dwXSize         = current_startupinfo.dwXSize;
 478     info->dwXCountChars   = current_startupinfo.dwXCountChars;
 479     info->dwYCountChars   = current_startupinfo.dwYCountChars;
 480     info->dwFillAttribute = current_startupinfo.dwFillAttribute;
 481     info->dwFlags         = current_startupinfo.dwFlags;
 482     info->wShowWindow     = current_startupinfo.wShowWindow;
 483     info->cbReserved2     = current_startupinfo.cbReserved2;
 484     info->lpReserved2     = current_startupinfo.lpReserved2;
 485     info->hStdInput       = current_startupinfo.hStdInput;
 486     info->hStdOutput      = current_startupinfo.hStdOutput;
 487     info->hStdError       = current_startupinfo.hStdError;
 488     info->lpReserved = HEAP_strdupAtoW (GetProcessHeap(), 0, current_startupinfo.lpReserved );
 489     info->lpDesktop  = HEAP_strdupAtoW (GetProcessHeap(), 0, current_startupinfo.lpDesktop );
 490     info->lpTitle    = HEAP_strdupAtoW (GetProcessHeap(), 0, current_startupinfo.lpTitle );
 491 }