dlls/ntdll/env.c

   1 /*
   2  * Ntdll environment functions
   3  *
   4  * Copyright 1996, 1998 Alexandre Julliard
   5  * Copyright 2003       Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <assert.h>
  23 #include <stdarg.h>
  24 #include <sys/types.h>
  25
  26 #include "ntstatus.h"
  27 #define WIN32_NO_STATUS
  28 #include "windef.h"
  29 #include "winternl.h"
  30 #include "wine/debug.h"
  31 #include "ntdll_misc.h"
  32 #include "winnt.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(environ);
  35
  36 static WCHAR empty[] = L"";
  37 static const UNICODE_STRING empty_str = { 0, sizeof(empty), empty };
  38 static const UNICODE_STRING null_str = { 0, 0, NULL };
  39
  40 static const BOOL is_win64 = (sizeof(void *) > sizeof(int));
  41
  42 static inline SIZE_T get_env_length( const WCHAR *env )
  43 {
  44     const WCHAR *end = env;
  45     while (*end) end += wcslen(end) + 1;
  46     return end + 1 - env;
  47 }
  48
  49
  50 /***********************************************************************
  51  *           set_wow64_environment
  52  *
  53  * Set the environment variables that change across 32/64/Wow64.
  54  */
  55 static void set_wow64_environment( WCHAR **env )
  56 {
  57     WCHAR buf[256];
  58     UNICODE_STRING arch_strW = RTL_CONSTANT_STRING( L"PROCESSOR_ARCHITECTURE" );
  59     UNICODE_STRING arch6432_strW = RTL_CONSTANT_STRING( L"PROCESSOR_ARCHITEW6432" );
  60     UNICODE_STRING valW = { 0, sizeof(buf), buf };
  61     UNICODE_STRING nameW;
  62
  63     /* set the PROCESSOR_ARCHITECTURE variable */
  64
  65     if (!RtlQueryEnvironmentVariable_U( *env, &arch6432_strW, &valW ))
  66     {
  67         if (is_win64)
  68         {
  69             RtlSetEnvironmentVariable( env, &arch_strW, &valW );
  70             RtlSetEnvironmentVariable( env, &arch6432_strW, NULL );
  71         }
  72     }
  73     else if (NtCurrentTeb64() && !RtlQueryEnvironmentVariable_U( *env, &arch_strW, &valW ))
  74     {
  75         RtlSetEnvironmentVariable( env, &arch6432_strW, &valW );
  76         RtlInitUnicodeString( &nameW, L"x86" );
  77         RtlSetEnvironmentVariable( env, &arch_strW, &nameW );
  78     }
  79
  80     /* set the ProgramFiles variables */
  81
  82     RtlInitUnicodeString( &nameW, is_win64 ? L"ProgramW6432" : L"ProgramFiles(x86)" );
  83     if (!RtlQueryEnvironmentVariable_U( *env, &nameW, &valW ))
  84     {
  85         RtlInitUnicodeString( &nameW, L"ProgramFiles" );
  86         RtlSetEnvironmentVariable( env, &nameW, &valW );
  87     }
  88
  89     /* set the CommonProgramFiles variables */
  90
  91     RtlInitUnicodeString( &nameW, is_win64 ? L"CommonProgramW6432" : L"CommonProgramFiles(x86)" );
  92     if (!RtlQueryEnvironmentVariable_U( *env, &nameW, &valW ))
  93     {
  94         RtlInitUnicodeString( &nameW, L"CommonProgramFiles" );
  95         RtlSetEnvironmentVariable( env, &nameW, &valW );
  96     }
  97
  98     RtlReAllocateHeap( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, *env,
  99                        get_env_length(*env) * sizeof(WCHAR) );
 100 }
 101
 102
 103 /******************************************************************************
 104  *  RtlCreateEnvironment                [NTDLL.@]
 105  */
 106 NTSTATUS WINAPI RtlCreateEnvironment(BOOLEAN inherit, PWSTR* env)
 107 {
 108     SIZE_T size;
 109
 110     TRACE("(%u,%p)!\n", inherit, env);
 111
 112     if (inherit)
 113     {
 114         RtlAcquirePebLock();
 115         size = get_env_length( NtCurrentTeb()->Peb->ProcessParameters->Environment ) * sizeof(WCHAR);
 116         if ((*env = RtlAllocateHeap( GetProcessHeap(), 0, size )))
 117             memcpy( *env, NtCurrentTeb()->Peb->ProcessParameters->Environment, size );
 118         RtlReleasePebLock();
 119     }
 120     else *env = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR) );
 121
 122     return *env ? STATUS_SUCCESS : STATUS_NO_MEMORY;
 123 }
 124
 125 /******************************************************************************
 126  *  RtlDestroyEnvironment               [NTDLL.@]
 127  */
 128 NTSTATUS WINAPI RtlDestroyEnvironment(PWSTR env)
 129 {
 130     RtlFreeHeap( GetProcessHeap(), 0, env );
 131     return STATUS_SUCCESS;
 132 }
 133
 134 static LPCWSTR ENV_FindVariable(PCWSTR var, PCWSTR name, unsigned namelen)
 135 {
 136     while (*var)
 137     {
 138         /* match var names, but avoid setting a var with a name including a '='
 139          * (a starting '=' is valid though)
 140          */
 141         unsigned int len = wcslen( var );
 142         if (len > namelen &&
 143             var[namelen] == '=' &&
 144             !RtlCompareUnicodeStrings( var, namelen, name, namelen, TRUE ) &&
 145             wcschr(var + 1, '=') == var + namelen)
 146         {
 147             return var + namelen + 1;
 148         }
 149         var += len + 1;
 150     }
 151     return NULL;
 152 }
 153
 154 /******************************************************************
 155  *              RtlQueryEnvironmentVariable_U   [NTDLL.@]
 156  *
 157  * NOTES: when the buffer is too small, the string is not written, but if the
 158  *      terminating null char is the only char that cannot be written, then
 159  *      all chars (except the null) are written and success is returned
 160  *      (behavior of Win2k at least)
 161  */
 162 NTSTATUS WINAPI RtlQueryEnvironmentVariable_U(PWSTR env,
 163                                               PUNICODE_STRING name,
 164                                               PUNICODE_STRING value)
 165 {
 166     NTSTATUS    nts = STATUS_VARIABLE_NOT_FOUND;
 167     PCWSTR      var;
 168     unsigned    namelen;
 169
 170     TRACE("%p %s %p\n", env, debugstr_us(name), value);
 171
 172     value->Length = 0;
 173     namelen = name->Length / sizeof(WCHAR);
 174     if (!namelen) return nts;
 175
 176     if (!env)
 177     {
 178         RtlAcquirePebLock();
 179         var = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 180     }
 181     else var = env;
 182
 183     var = ENV_FindVariable(var, name->Buffer, namelen);
 184     if (var != NULL)
 185     {
 186         value->Length = wcslen(var) * sizeof(WCHAR);
 187
 188         if (value->Length <= value->MaximumLength)
 189         {
 190             memmove(value->Buffer, var, min(value->Length + sizeof(WCHAR), value->MaximumLength));
 191             nts = STATUS_SUCCESS;
 192         }
 193         else nts = STATUS_BUFFER_TOO_SMALL;
 194     }
 195
 196     if (!env) RtlReleasePebLock();
 197
 198     return nts;
 199 }
 200
 201
 202 /******************************************************************
 203  *              RtlQueryEnvironmentVariable   [NTDLL.@]
 204  */
 205 NTSTATUS WINAPI RtlQueryEnvironmentVariable( WCHAR *env, const WCHAR *name, SIZE_T namelen,
 206                                              WCHAR *value, SIZE_T value_length, SIZE_T *return_length )
 207 {
 208     NTSTATUS nts = STATUS_VARIABLE_NOT_FOUND;
 209     SIZE_T len = 0;
 210     const WCHAR *var;
 211
 212     if (!namelen) return nts;
 213
 214     if (!env)
 215     {
 216         RtlAcquirePebLock();
 217         var = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 218     }
 219     else var = env;
 220
 221     var = ENV_FindVariable(var, name, namelen);
 222     if (var != NULL)
 223     {
 224         len = wcslen(var);
 225         if (len <= value_length)
 226         {
 227             memcpy(value, var, min(len + 1, value_length) * sizeof(WCHAR));
 228             nts = STATUS_SUCCESS;
 229         }
 230         else
 231         {
 232             len++;
 233             nts = STATUS_BUFFER_TOO_SMALL;
 234         }
 235     }
 236     *return_length = len;
 237
 238     if (!env) RtlReleasePebLock();
 239
 240     return nts;
 241 }
 242
 243 /******************************************************************
 244  *              RtlSetCurrentEnvironment        [NTDLL.@]
 245  *
 246  */
 247 void WINAPI RtlSetCurrentEnvironment(PWSTR new_env, PWSTR* old_env)
 248 {
 249     WCHAR *prev;
 250
 251     TRACE("(%p %p)\n", new_env, old_env);
 252
 253     RtlAcquirePebLock();
 254
 255     prev = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 256     NtCurrentTeb()->Peb->ProcessParameters->Environment = new_env;
 257     NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize = RtlSizeHeap( GetProcessHeap(), 0, new_env );
 258
 259     RtlReleasePebLock();
 260
 261     if (old_env)
 262         *old_env = prev;
 263     else
 264         RtlDestroyEnvironment( prev );
 265 }
 266
 267
 268 /******************************************************************************
 269  *  RtlSetEnvironmentVariable           [NTDLL.@]
 270  */
 271 NTSTATUS WINAPI RtlSetEnvironmentVariable(PWSTR* penv, PUNICODE_STRING name,
 272                                           PUNICODE_STRING value)
 273 {
 274     INT varlen, len, old_size;
 275     LPWSTR      p, env;
 276     NTSTATUS    nts = STATUS_SUCCESS;
 277
 278     TRACE("(%p, %s, %s)\n", penv, debugstr_us(name), debugstr_us(value));
 279
 280     if (!name || !name->Buffer || !name->Length)
 281         return STATUS_INVALID_PARAMETER_1;
 282
 283     len = name->Length / sizeof(WCHAR);
 284
 285     /* variable names can't contain a '=' except as a first character */
 286     for (p = name->Buffer + 1; p < name->Buffer + len; p++)
 287         if (*p == '=') return STATUS_INVALID_PARAMETER;
 288
 289     if (!penv)
 290     {
 291         RtlAcquirePebLock();
 292         env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 293     } else env = *penv;
 294
 295     old_size = get_env_length( env );
 296
 297     /* Find a place to insert the string */
 298     for (p = env; *p; p += varlen + 1)
 299     {
 300         varlen = wcslen(p);
 301         if (varlen > len && p[len] == '=' &&
 302             !RtlCompareUnicodeStrings( name->Buffer, len, p, len, TRUE )) break;
 303     }
 304     if (!value && !*p) goto done;  /* Value to remove doesn't exist */
 305
 306     /* Realloc the buffer */
 307     len = value ? len + value->Length / sizeof(WCHAR) + 2 : 0;
 308     if (*p) len -= wcslen(p) + 1;  /* The name already exists */
 309
 310     if (len < 0)
 311     {
 312         LPWSTR next = p + wcslen(p) + 1;  /* We know there is a next one */
 313         memmove(next + len, next, (old_size - (next - env)) * sizeof(WCHAR));
 314     }
 315
 316     if ((old_size + len) * sizeof(WCHAR) > RtlSizeHeap( GetProcessHeap(), 0, env ))
 317     {
 318         SIZE_T new_size = (old_size + len) * sizeof(WCHAR);
 319         LPWSTR new_env = RtlAllocateHeap( GetProcessHeap(), 0, new_size );
 320
 321         if (!new_env)
 322         {
 323             nts = STATUS_NO_MEMORY;
 324             goto done;
 325         }
 326         memcpy(new_env, env, (p - env) * sizeof(WCHAR));
 327         memcpy(new_env + (p - env) + len, p, (old_size - (p - env)) * sizeof(WCHAR));
 328         p = new_env + (p - env);
 329
 330         RtlDestroyEnvironment(env);
 331         if (!penv)
 332         {
 333             NtCurrentTeb()->Peb->ProcessParameters->Environment = new_env;
 334             NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize = new_size;
 335         }
 336         else *penv = new_env;
 337     }
 338     else
 339     {
 340         if (len > 0) memmove(p + len, p, (old_size - (p - env)) * sizeof(WCHAR));
 341     }
 342
 343     /* Set the new string */
 344     if (value)
 345     {
 346         memcpy( p, name->Buffer, name->Length );
 347         p += name->Length / sizeof(WCHAR);
 348         *p++ = '=';
 349         memcpy( p, value->Buffer, value->Length );
 350         p[value->Length / sizeof(WCHAR)] = 0;
 351     }
 352
 353 done:
 354     if (!penv) RtlReleasePebLock();
 355
 356     return nts;
 357 }
 358
 359 /******************************************************************************
 360  *              RtlExpandEnvironmentStrings (NTDLL.@)
 361  */
 362 NTSTATUS WINAPI RtlExpandEnvironmentStrings( const WCHAR *renv, WCHAR *src, SIZE_T src_len,
 363                                              WCHAR *dst, SIZE_T count, SIZE_T *plen )
 364 {
 365     SIZE_T len, total_size = 1;  /* 1 for terminating '\0' */
 366     LPCWSTR env, var;
 367
 368     if (!renv)
 369     {
 370         RtlAcquirePebLock();
 371         env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 372     }
 373     else env = renv;
 374
 375     while (src_len)
 376     {
 377         if (*src != '%')
 378         {
 379             for (len = 0; len < src_len; len++) if (src[len] == '%') break;
 380             var = src;
 381             src += len;
 382             src_len -= len;
 383         }
 384         else  /* we are at the start of a variable */
 385         {
 386             for (len = 1; len < src_len; len++) if (src[len] == '%') break;
 387             if (len < src_len)
 388             {
 389                 if ((var = ENV_FindVariable( env, src + 1, len - 1 )))
 390                 {
 391                     src += len + 1;  /* Skip the variable name */
 392                     src_len -= len + 1;
 393                     len = wcslen(var);
 394                 }
 395                 else
 396                 {
 397                     var = src;  /* Copy original name instead */
 398                     len++;
 399                     src += len;
 400                     src_len -= len;
 401                 }
 402             }
 403             else  /* unfinished variable name, ignore it */
 404             {
 405                 var = src;
 406                 src += len;
 407                 src_len = 0;
 408             }
 409         }
 410         total_size += len;
 411         if (dst)
 412         {
 413             if (count < len) len = count;
 414             memcpy(dst, var, len * sizeof(WCHAR));
 415             count -= len;
 416             dst += len;
 417         }
 418     }
 419
 420     if (!renv) RtlReleasePebLock();
 421
 422     if (dst && count) *dst = '\0';
 423     if (plen) *plen = total_size;
 424
 425     return (count) ? STATUS_SUCCESS : STATUS_BUFFER_TOO_SMALL;
 426 }
 427
 428 /******************************************************************
 429  *              RtlExpandEnvironmentStrings_U (NTDLL.@)
 430  */
 431 NTSTATUS WINAPI RtlExpandEnvironmentStrings_U( const WCHAR *env, const UNICODE_STRING *src,
 432                                                UNICODE_STRING *dst, ULONG *plen )
 433 {
 434     SIZE_T len;
 435     NTSTATUS ret;
 436
 437     ret = RtlExpandEnvironmentStrings( env, src->Buffer, src->Length / sizeof(WCHAR),
 438                                        dst->Buffer, dst->MaximumLength / sizeof(WCHAR), &len );
 439     if (plen) *plen = len * sizeof(WCHAR);  /* FIXME: check for overflow? */
 440     if (len > UNICODE_STRING_MAX_CHARS) ret = STATUS_BUFFER_TOO_SMALL;
 441     if (!ret) dst->Length = (len - 1) * sizeof(WCHAR);
 442     return ret;
 443 }
 444
 445 static inline void normalize( void *base, WCHAR **ptr )
 446 {
 447     if (*ptr) *ptr = (WCHAR *)((char *)base + (UINT_PTR)*ptr);
 448 }
 449
 450 /******************************************************************************
 451  *  RtlNormalizeProcessParams  [NTDLL.@]
 452  */
 453 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlNormalizeProcessParams( RTL_USER_PROCESS_PARAMETERS *params )
 454 {
 455     if (params && !(params->Flags & PROCESS_PARAMS_FLAG_NORMALIZED))
 456     {
 457         normalize( params, &params->CurrentDirectory.DosPath.Buffer );
 458         normalize( params, &params->DllPath.Buffer );
 459         normalize( params, &params->ImagePathName.Buffer );
 460         normalize( params, &params->CommandLine.Buffer );
 461         normalize( params, &params->WindowTitle.Buffer );
 462         normalize( params, &params->Desktop.Buffer );
 463         normalize( params, &params->ShellInfo.Buffer );
 464         normalize( params, &params->RuntimeInfo.Buffer );
 465         params->Flags |= PROCESS_PARAMS_FLAG_NORMALIZED;
 466     }
 467     return params;
 468 }
 469
 470
 471 static inline void denormalize( const void *base, WCHAR **ptr )
 472 {
 473     if (*ptr) *ptr = (WCHAR *)(UINT_PTR)((char *)*ptr - (const char *)base);
 474 }
 475
 476 /******************************************************************************
 477  *  RtlDeNormalizeProcessParams  [NTDLL.@]
 478  */
 479 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlDeNormalizeProcessParams( RTL_USER_PROCESS_PARAMETERS *params )
 480 {
 481     if (params && (params->Flags & PROCESS_PARAMS_FLAG_NORMALIZED))
 482     {
 483         denormalize( params, &params->CurrentDirectory.DosPath.Buffer );
 484         denormalize( params, &params->DllPath.Buffer );
 485         denormalize( params, &params->ImagePathName.Buffer );
 486         denormalize( params, &params->CommandLine.Buffer );
 487         denormalize( params, &params->WindowTitle.Buffer );
 488         denormalize( params, &params->Desktop.Buffer );
 489         denormalize( params, &params->ShellInfo.Buffer );
 490         denormalize( params, &params->RuntimeInfo.Buffer );
 491         params->Flags &= ~PROCESS_PARAMS_FLAG_NORMALIZED;
 492     }
 493     return params;
 494 }
 495
 496
 497 #define ROUND_SIZE(size,align) (((size) + (align) - 1) & ~((align) - 1))
 498
 499 /* append a unicode string to the process params data; helper for RtlCreateProcessParameters */
 500 static void append_unicode_string( void **data, const UNICODE_STRING *src,
 501                                    UNICODE_STRING *dst, size_t align )
 502 {
 503     dst->Length = src->Length;
 504     dst->MaximumLength = src->MaximumLength;
 505     if (dst->MaximumLength)
 506     {
 507         dst->Buffer = *data;
 508         memcpy( dst->Buffer, src->Buffer, dst->Length );
 509         *data = (char *)dst->Buffer + ROUND_SIZE( dst->MaximumLength, align );
 510     }
 511     else dst->Buffer = NULL;
 512 }
 513
 514 static RTL_USER_PROCESS_PARAMETERS *alloc_process_params( size_t align,
 515                                                           const UNICODE_STRING *image,
 516                                                           const UNICODE_STRING *dllpath,
 517                                                           const UNICODE_STRING *curdir,
 518                                                           const UNICODE_STRING *cmdline,
 519                                                           const WCHAR *env,
 520                                                           const UNICODE_STRING *title,
 521                                                           const UNICODE_STRING *desktop,
 522                                                           const UNICODE_STRING *shell,
 523                                                           const UNICODE_STRING *runtime )
 524 {
 525     RTL_USER_PROCESS_PARAMETERS *params;
 526     SIZE_T size, env_size = 0;
 527     void *ptr;
 528
 529     if (env) env_size = get_env_length( env ) * sizeof(WCHAR);
 530
 531     size = (sizeof(RTL_USER_PROCESS_PARAMETERS)
 532             + ROUND_SIZE( image->MaximumLength, align )
 533             + ROUND_SIZE( dllpath->MaximumLength, align )
 534             + ROUND_SIZE( curdir->MaximumLength, align )
 535             + ROUND_SIZE( cmdline->MaximumLength, align )
 536             + ROUND_SIZE( title->MaximumLength, align )
 537             + ROUND_SIZE( desktop->MaximumLength, align )
 538             + ROUND_SIZE( shell->MaximumLength, align )
 539             + ROUND_SIZE( runtime->MaximumLength, align ));
 540
 541     if (!(ptr = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, size + ROUND_SIZE( env_size, align ))))
 542         return NULL;
 543
 544     params = ptr;
 545     params->AllocationSize  = size;
 546     params->Size            = size;
 547     params->Flags           = PROCESS_PARAMS_FLAG_NORMALIZED;
 548     params->EnvironmentSize = ROUND_SIZE( env_size, align );
 549     /* all other fields are zero */
 550
 551     ptr = params + 1;
 552     append_unicode_string( &ptr, curdir, &params->CurrentDirectory.DosPath, align );
 553     append_unicode_string( &ptr, dllpath, &params->DllPath, align );
 554     append_unicode_string( &ptr, image, &params->ImagePathName, align );
 555     append_unicode_string( &ptr, cmdline, &params->CommandLine, align );
 556     append_unicode_string( &ptr, title, &params->WindowTitle, align );
 557     append_unicode_string( &ptr, desktop, &params->Desktop, align );
 558     append_unicode_string( &ptr, shell, &params->ShellInfo, align );
 559     append_unicode_string( &ptr, runtime, &params->RuntimeInfo, align );
 560     if (env) params->Environment = memcpy( ptr, env, env_size );
 561     return params;
 562 }
 563
 564
 565 /******************************************************************************
 566  *  RtlCreateProcessParametersEx  [NTDLL.@]
 567  */
 568 NTSTATUS WINAPI RtlCreateProcessParametersEx( RTL_USER_PROCESS_PARAMETERS **result,
 569                                               const UNICODE_STRING *ImagePathName,
 570                                               const UNICODE_STRING *DllPath,
 571                                               const UNICODE_STRING *CurrentDirectoryName,
 572                                               const UNICODE_STRING *CommandLine,
 573                                               PWSTR Environment,
 574                                               const UNICODE_STRING *WindowTitle,
 575                                               const UNICODE_STRING *Desktop,
 576                                               const UNICODE_STRING *ShellInfo,
 577                                               const UNICODE_STRING *RuntimeInfo,
 578                                               ULONG flags )
 579 {
 580     UNICODE_STRING curdir;
 581     const RTL_USER_PROCESS_PARAMETERS *cur_params;
 582     NTSTATUS status = STATUS_SUCCESS;
 583
 584     RtlAcquirePebLock();
 585     cur_params = NtCurrentTeb()->Peb->ProcessParameters;
 586     if (!DllPath) DllPath = &null_str;
 587     if (!CurrentDirectoryName)
 588     {
 589         if (NtCurrentTeb()->Tib.SubSystemTib)  /* FIXME: hack */
 590             curdir = ((WIN16_SUBSYSTEM_TIB *)NtCurrentTeb()->Tib.SubSystemTib)->curdir.DosPath;
 591         else
 592             curdir = cur_params->CurrentDirectory.DosPath;
 593     }
 594     else curdir = *CurrentDirectoryName;
 595     curdir.MaximumLength = MAX_PATH * sizeof(WCHAR);
 596
 597     if (!CommandLine) CommandLine = ImagePathName;
 598     if (!Environment && cur_params) Environment = cur_params->Environment;
 599     if (!WindowTitle) WindowTitle = &empty_str;
 600     if (!Desktop) Desktop = &empty_str;
 601     if (!ShellInfo) ShellInfo = &empty_str;
 602     if (!RuntimeInfo) RuntimeInfo = &null_str;
 603
 604     if ((*result = alloc_process_params( sizeof(void *), ImagePathName, DllPath, &curdir, CommandLine,
 605                                          Environment, WindowTitle, Desktop, ShellInfo, RuntimeInfo )))
 606     {
 607         if (cur_params) (*result)->ConsoleFlags = cur_params->ConsoleFlags;
 608         if (!(flags & PROCESS_PARAMS_FLAG_NORMALIZED)) RtlDeNormalizeProcessParams( *result );
 609     }
 610     else status = STATUS_NO_MEMORY;
 611
 612     RtlReleasePebLock();
 613     return status;
 614 }
 615
 616
 617 /******************************************************************************
 618  *  RtlCreateProcessParameters  [NTDLL.@]
 619  */
 620 NTSTATUS WINAPI RtlCreateProcessParameters( RTL_USER_PROCESS_PARAMETERS **result,
 621                                             const UNICODE_STRING *image,
 622                                             const UNICODE_STRING *dllpath,
 623                                             const UNICODE_STRING *curdir,
 624                                             const UNICODE_STRING *cmdline,
 625                                             PWSTR env,
 626                                             const UNICODE_STRING *title,
 627                                             const UNICODE_STRING *desktop,
 628                                             const UNICODE_STRING *shellinfo,
 629                                             const UNICODE_STRING *runtime )
 630 {
 631     return RtlCreateProcessParametersEx( result, image, dllpath, curdir, cmdline,
 632                                          env, title, desktop, shellinfo, runtime, 0 );
 633 }
 634
 635
 636 /******************************************************************************
 637  *  RtlDestroyProcessParameters  [NTDLL.@]
 638  */
 639 void WINAPI RtlDestroyProcessParameters( RTL_USER_PROCESS_PARAMETERS *params )
 640 {
 641     RtlFreeHeap( GetProcessHeap(), 0, params );
 642 }
 643
 644
 645 /***********************************************************************
 646  *           init_user_process_params
 647  *
 648  * Fill the initial RTL_USER_PROCESS_PARAMETERS structure from the server.
 649  */
 650 void init_user_process_params(void)
 651 {
 652     WCHAR *env;
 653     SIZE_T size = 0, env_size;
 654     RTL_USER_PROCESS_PARAMETERS *new_params, *params = NtCurrentTeb()->Peb->ProcessParameters;
 655     UNICODE_STRING curdir;
 656
 657     /* environment needs to be a separate memory block */
 658     env_size = params->EnvironmentSize;
 659     if ((env = RtlAllocateHeap( GetProcessHeap(), 0, max( env_size, sizeof(WCHAR) ))))
 660     {
 661         if (env_size) memcpy( env, params->Environment, env_size );
 662         else env[0] = 0;
 663     }
 664
 665     if (!(new_params = alloc_process_params( 1, &params->ImagePathName, &params->DllPath,
 666                                              &params->CurrentDirectory.DosPath, &params->CommandLine,
 667                                              NULL, &params->WindowTitle, &params->Desktop,
 668                                              &params->ShellInfo, &params->RuntimeInfo )))
 669         return;
 670
 671     new_params->Environment     = env;
 672     new_params->DebugFlags      = params->DebugFlags;
 673     new_params->ConsoleHandle   = params->ConsoleHandle;
 674     new_params->ConsoleFlags    = params->ConsoleFlags;
 675     new_params->hStdInput       = params->hStdInput;
 676     new_params->hStdOutput      = params->hStdOutput;
 677     new_params->hStdError       = params->hStdError;
 678     new_params->dwX             = params->dwX;
 679     new_params->dwY             = params->dwY;
 680     new_params->dwXSize         = params->dwXSize;
 681     new_params->dwYSize         = params->dwYSize;
 682     new_params->dwXCountChars   = params->dwXCountChars;
 683     new_params->dwYCountChars   = params->dwYCountChars;
 684     new_params->dwFillAttribute = params->dwFillAttribute;
 685     new_params->dwFlags         = params->dwFlags;
 686     new_params->wShowWindow     = params->wShowWindow;
 687     new_params->ProcessGroupId  = params->ProcessGroupId;
 688
 689     NtCurrentTeb()->Peb->ProcessParameters = new_params;
 690     NtFreeVirtualMemory( GetCurrentProcess(), (void **)&params, &size, MEM_RELEASE );
 691
 692     if (RtlSetCurrentDirectory_U( &new_params->CurrentDirectory.DosPath ))
 693     {
 694         MESSAGE("wine: could not open working directory %s, starting in the Windows directory.\n",
 695                 debugstr_w( new_params->CurrentDirectory.DosPath.Buffer ));
 696         RtlInitUnicodeString( &curdir, windows_dir );
 697         RtlSetCurrentDirectory_U( &curdir );
 698     }
 699     set_wow64_environment( &new_params->Environment );
 700     new_params->EnvironmentSize = RtlSizeHeap( GetProcessHeap(), 0, new_params->Environment );
 701 }