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 #include "config.h"
  22
  23 #include <assert.h>
  24 #include <stdarg.h>
  25
  26 #include "ntstatus.h"
  27 #define WIN32_NO_STATUS
  28 #include "windef.h"
  29 #include "winternl.h"
  30 #include "wine/unicode.h"
  31 #include "wine/debug.h"
  32 #include "thread.h"
  33 #include "ntdll_misc.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(environ);
  36
  37 /******************************************************************************
  38  *  RtlCreateEnvironment                [NTDLL.@]
  39  */
  40 NTSTATUS WINAPI RtlCreateEnvironment(BOOLEAN inherit, PWSTR* env)
  41 {
  42     NTSTATUS    nts;
  43
  44     TRACE("(%u,%p)!\n", inherit, env);
  45
  46     if (inherit)
  47     {
  48         MEMORY_BASIC_INFORMATION        mbi;
  49
  50         RtlAcquirePebLock();
  51
  52         nts = NtQueryVirtualMemory(NtCurrentProcess(),
  53                                    NtCurrentTeb()->Peb->ProcessParameters->Environment,
  54                                    0, &mbi, sizeof(mbi), NULL);
  55         if (nts == STATUS_SUCCESS)
  56         {
  57             *env = NULL;
  58             nts = NtAllocateVirtualMemory(NtCurrentProcess(), (void**)env, 0, &mbi.RegionSize,
  59                                           MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
  60             if (nts == STATUS_SUCCESS)
  61                 memcpy(*env, NtCurrentTeb()->Peb->ProcessParameters->Environment, mbi.RegionSize);
  62             else *env = NULL;
  63         }
  64         RtlReleasePebLock();
  65     }
  66     else
  67     {
  68         SIZE_T      size = 1;
  69         PVOID       addr = NULL;
  70         nts = NtAllocateVirtualMemory(NtCurrentProcess(), &addr, 0, &size,
  71                                       MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
  72         if (nts == STATUS_SUCCESS) *env = addr;
  73     }
  74
  75     return nts;
  76 }
  77
  78 /******************************************************************************
  79  *  RtlDestroyEnvironment               [NTDLL.@]
  80  */
  81 NTSTATUS WINAPI RtlDestroyEnvironment(PWSTR env)
  82 {
  83     SIZE_T size = 0;
  84
  85     TRACE("(%p)!\n", env);
  86
  87     return NtFreeVirtualMemory(NtCurrentProcess(), (void**)&env, &size, MEM_RELEASE);
  88 }
  89
  90 static LPCWSTR ENV_FindVariable(PCWSTR var, PCWSTR name, unsigned namelen)
  91 {
  92     for (; *var; var += strlenW(var) + 1)
  93     {
  94         /* match var names, but avoid setting a var with a name including a '='
  95          * (a starting '=' is valid though)
  96          */
  97         if (strncmpiW(var, name, namelen) == 0 && var[namelen] == '=' &&
  98             strchrW(var + 1, '=') == var + namelen)
  99         {
 100             return var + namelen + 1;
 101         }
 102     }
 103     return NULL;
 104 }
 105
 106 /******************************************************************
 107  *              RtlQueryEnvironmentVariable_U   [NTDLL.@]
 108  *
 109  * NOTES: when the buffer is too small, the string is not written, but if the
 110  *      terminating null char is the only char that cannot be written, then
 111  *      all chars (except the null) are written and success is returned
 112  *      (behavior of Win2k at least)
 113  */
 114 NTSTATUS WINAPI RtlQueryEnvironmentVariable_U(PWSTR env,
 115                                               PUNICODE_STRING name,
 116                                               PUNICODE_STRING value)
 117 {
 118     NTSTATUS    nts = STATUS_VARIABLE_NOT_FOUND;
 119     PCWSTR      var;
 120     unsigned    namelen;
 121
 122     TRACE("%p %s %p\n", env, debugstr_us(name), value);
 123
 124     value->Length = 0;
 125     namelen = name->Length / sizeof(WCHAR);
 126     if (!namelen) return nts;
 127
 128     if (!env)
 129     {
 130         RtlAcquirePebLock();
 131         var = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 132     }
 133     else var = env;
 134
 135     var = ENV_FindVariable(var, name->Buffer, namelen);
 136     if (var != NULL)
 137     {
 138         value->Length = strlenW(var) * sizeof(WCHAR);
 139
 140         if (value->Length <= value->MaximumLength)
 141         {
 142             memmove(value->Buffer, var, min(value->Length + sizeof(WCHAR), value->MaximumLength));
 143             nts = STATUS_SUCCESS;
 144         }
 145         else nts = STATUS_BUFFER_TOO_SMALL;
 146     }
 147
 148     if (!env) RtlReleasePebLock();
 149
 150     return nts;
 151 }
 152
 153 /******************************************************************
 154  *              RtlSetCurrentEnvironment        [NTDLL.@]
 155  *
 156  */
 157 void WINAPI RtlSetCurrentEnvironment(PWSTR new_env, PWSTR* old_env)
 158 {
 159     TRACE("(%p %p)\n", new_env, old_env);
 160
 161     RtlAcquirePebLock();
 162
 163     if (old_env) *old_env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 164     NtCurrentTeb()->Peb->ProcessParameters->Environment = new_env;
 165
 166     RtlReleasePebLock();
 167 }
 168
 169
 170 /******************************************************************************
 171  *  RtlSetEnvironmentVariable           [NTDLL.@]
 172  */
 173 NTSTATUS WINAPI RtlSetEnvironmentVariable(PWSTR* penv, PUNICODE_STRING name,
 174                                           PUNICODE_STRING value)
 175 {
 176     INT         len, old_size;
 177     LPWSTR      p, env;
 178     NTSTATUS    nts = STATUS_VARIABLE_NOT_FOUND;
 179     MEMORY_BASIC_INFORMATION mbi;
 180
 181     TRACE("(%p, %s, %s)\n", penv, debugstr_us(name), debugstr_us(value));
 182
 183     if (!name || !name->Buffer || !name->Length)
 184         return STATUS_INVALID_PARAMETER_1;
 185
 186     len = name->Length / sizeof(WCHAR);
 187
 188     /* variable names can't contain a '=' except as a first character */
 189     for (p = name->Buffer + 1; p < name->Buffer + len; p++)
 190         if (*p == '=') return STATUS_INVALID_PARAMETER;
 191
 192     if (!penv)
 193     {
 194         RtlAcquirePebLock();
 195         env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 196     } else env = *penv;
 197
 198     /* compute current size of environment */
 199     for (p = env; *p; p += strlenW(p) + 1);
 200     old_size = p + 1 - env;
 201
 202     /* Find a place to insert the string */
 203     for (p = env; *p; p += strlenW(p) + 1)
 204     {
 205         if (!strncmpiW(name->Buffer, p, len) && (p[len] == '=')) break;
 206     }
 207     if (!value && !*p) goto done;  /* Value to remove doesn't exist */
 208
 209     /* Realloc the buffer */
 210     len = value ? len + value->Length / sizeof(WCHAR) + 2 : 0;
 211     if (*p) len -= strlenW(p) + 1;  /* The name already exists */
 212
 213     if (len < 0)
 214     {
 215         LPWSTR next = p + strlenW(p) + 1;  /* We know there is a next one */
 216         memmove(next + len, next, (old_size - (next - env)) * sizeof(WCHAR));
 217     }
 218
 219     nts = NtQueryVirtualMemory(NtCurrentProcess(), env, 0,
 220                                &mbi, sizeof(mbi), NULL);
 221     if (nts != STATUS_SUCCESS) goto done;
 222
 223     if ((old_size + len) * sizeof(WCHAR) > mbi.RegionSize)
 224     {
 225         LPWSTR  new_env;
 226         SIZE_T  new_size = (old_size + len) * sizeof(WCHAR);
 227
 228         new_env = NULL;
 229         nts = NtAllocateVirtualMemory(NtCurrentProcess(), (void**)&new_env, 0,
 230                                       &new_size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
 231         if (nts != STATUS_SUCCESS) goto done;
 232
 233         memmove(new_env, env, (p - env) * sizeof(WCHAR));
 234         assert(len > 0);
 235         memmove(new_env + (p - env) + len, p, (old_size - (p - env)) * sizeof(WCHAR));
 236         p = new_env + (p - env);
 237
 238         RtlDestroyEnvironment(env);
 239         if (!penv) NtCurrentTeb()->Peb->ProcessParameters->Environment = new_env;
 240         else *penv = new_env;
 241         env = new_env;
 242     }
 243     else
 244     {
 245         if (len > 0) memmove(p + len, p, (old_size - (p - env)) * sizeof(WCHAR));
 246     }
 247
 248     /* Set the new string */
 249     if (value)
 250     {
 251         memcpy( p, name->Buffer, name->Length );
 252         p += name->Length / sizeof(WCHAR);
 253         *p++ = '=';
 254         memcpy( p, value->Buffer, value->Length );
 255         p[value->Length / sizeof(WCHAR)] = 0;
 256     }
 257 done:
 258     if (!penv) RtlReleasePebLock();
 259
 260     return nts;
 261 }
 262
 263 /******************************************************************
 264  *              RtlExpandEnvironmentStrings_U (NTDLL.@)
 265  *
 266  */
 267 NTSTATUS WINAPI RtlExpandEnvironmentStrings_U(PCWSTR renv, const UNICODE_STRING* us_src,
 268                                               PUNICODE_STRING us_dst, PULONG plen)
 269 {
 270     DWORD src_len, len, count, total_size = 1;  /* 1 for terminating '\0' */
 271     LPCWSTR     env, src, p, var;
 272     LPWSTR      dst;
 273
 274     src = us_src->Buffer;
 275     src_len = us_src->Length / sizeof(WCHAR);
 276     count = us_dst->MaximumLength / sizeof(WCHAR);
 277     dst = count ? us_dst->Buffer : NULL;
 278
 279     if (!renv)
 280     {
 281         RtlAcquirePebLock();
 282         env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
 283     }
 284     else env = renv;
 285
 286     while (src_len)
 287     {
 288         if (*src != '%')
 289         {
 290             if ((p = memchrW( src, '%', src_len ))) len = p - src;
 291             else len = src_len;
 292             var = src;
 293             src += len;
 294             src_len -= len;
 295         }
 296         else  /* we are at the start of a variable */
 297         {
 298             if ((p = memchrW( src + 1, '%', src_len - 1 )))
 299             {
 300                 len = p - src - 1;  /* Length of the variable name */
 301                 if ((var = ENV_FindVariable( env, src + 1, len )))
 302                 {
 303                     src += len + 2;  /* Skip the variable name */
 304                     src_len -= len + 2;
 305                     len = strlenW(var);
 306                 }
 307                 else
 308                 {
 309                     var = src;  /* Copy original name instead */
 310                     len += 2;
 311                     src += len;
 312                     src_len -= len;
 313                 }
 314             }
 315             else  /* unfinished variable name, ignore it */
 316             {
 317                 var = src;
 318                 len = src_len;  /* Copy whole string */
 319                 src += len;
 320                 src_len = 0;
 321             }
 322         }
 323         total_size += len;
 324         if (dst)
 325         {
 326             if (count < len) len = count;
 327             memcpy(dst, var, len * sizeof(WCHAR));
 328             count -= len;
 329             dst += len;
 330         }
 331     }
 332
 333     if (!renv) RtlReleasePebLock();
 334
 335     /* Null-terminate the string */
 336     if (dst && count) *dst = '\0';
 337
 338     us_dst->Length = (dst) ? (dst - us_dst->Buffer) * sizeof(WCHAR) : 0;
 339     if (plen) *plen = total_size * sizeof(WCHAR);
 340
 341     return (count) ? STATUS_SUCCESS : STATUS_BUFFER_TOO_SMALL;
 342 }
 343
 344
 345 static inline void normalize( void *base, WCHAR **ptr )
 346 {
 347     if (*ptr) *ptr = (WCHAR *)((char *)base + (UINT_PTR)*ptr);
 348 }
 349
 350 /******************************************************************************
 351  *  RtlNormalizeProcessParams  [NTDLL.@]
 352  */
 353 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlNormalizeProcessParams( RTL_USER_PROCESS_PARAMETERS *params )
 354 {
 355     if (params && !(params->Flags & PROCESS_PARAMS_FLAG_NORMALIZED))
 356     {
 357         normalize( params, &params->CurrentDirectory.DosPath.Buffer );
 358         normalize( params, &params->DllPath.Buffer );
 359         normalize( params, &params->ImagePathName.Buffer );
 360         normalize( params, &params->CommandLine.Buffer );
 361         normalize( params, &params->WindowTitle.Buffer );
 362         normalize( params, &params->Desktop.Buffer );
 363         normalize( params, &params->ShellInfo.Buffer );
 364         normalize( params, &params->RuntimeInfo.Buffer );
 365         params->Flags |= PROCESS_PARAMS_FLAG_NORMALIZED;
 366     }
 367     return params;
 368 }
 369
 370
 371 static inline void denormalize( const void *base, WCHAR **ptr )
 372 {
 373     if (*ptr) *ptr = (WCHAR *)(UINT_PTR)((char *)*ptr - (const char *)base);
 374 }
 375
 376 /******************************************************************************
 377  *  RtlDeNormalizeProcessParams  [NTDLL.@]
 378  */
 379 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlDeNormalizeProcessParams( RTL_USER_PROCESS_PARAMETERS *params )
 380 {
 381     if (params && (params->Flags & PROCESS_PARAMS_FLAG_NORMALIZED))
 382     {
 383         denormalize( params, &params->CurrentDirectory.DosPath.Buffer );
 384         denormalize( params, &params->DllPath.Buffer );
 385         denormalize( params, &params->ImagePathName.Buffer );
 386         denormalize( params, &params->CommandLine.Buffer );
 387         denormalize( params, &params->WindowTitle.Buffer );
 388         denormalize( params, &params->Desktop.Buffer );
 389         denormalize( params, &params->ShellInfo.Buffer );
 390         denormalize( params, &params->RuntimeInfo.Buffer );
 391         params->Flags &= ~PROCESS_PARAMS_FLAG_NORMALIZED;
 392     }
 393     return params;
 394 }
 395
 396
 397 /* append a unicode string to the process params data; helper for RtlCreateProcessParameters */
 398 static void append_unicode_string( void **data, const UNICODE_STRING *src,
 399                                    UNICODE_STRING *dst )
 400 {
 401     dst->Length = src->Length;
 402     dst->MaximumLength = src->MaximumLength;
 403     dst->Buffer = *data;
 404     memcpy( dst->Buffer, src->Buffer, dst->MaximumLength );
 405     *data = (char *)dst->Buffer + dst->MaximumLength;
 406 }
 407
 408
 409 /******************************************************************************
 410  *  RtlCreateProcessParameters  [NTDLL.@]
 411  */
 412 NTSTATUS WINAPI RtlCreateProcessParameters( RTL_USER_PROCESS_PARAMETERS **result,
 413                                             const UNICODE_STRING *ImagePathName,
 414                                             const UNICODE_STRING *DllPath,
 415                                             const UNICODE_STRING *CurrentDirectoryName,
 416                                             const UNICODE_STRING *CommandLine,
 417                                             PWSTR Environment,
 418                                             const UNICODE_STRING *WindowTitle,
 419                                             const UNICODE_STRING *Desktop,
 420                                             const UNICODE_STRING *ShellInfo,
 421                                             const UNICODE_STRING *RuntimeInfo )
 422 {
 423     static WCHAR empty[] = {0};
 424     static const UNICODE_STRING empty_str = { 0, sizeof(empty), empty };
 425     static const UNICODE_STRING null_str = { 0, 0, NULL };
 426
 427     const RTL_USER_PROCESS_PARAMETERS *cur_params;
 428     SIZE_T size, total_size;
 429     void *ptr;
 430     NTSTATUS status;
 431
 432     RtlAcquirePebLock();
 433     cur_params = NtCurrentTeb()->Peb->ProcessParameters;
 434     if (!DllPath) DllPath = &cur_params->DllPath;
 435     if (!CurrentDirectoryName)
 436     {
 437         if (NtCurrentTeb()->Tib.SubSystemTib)  /* FIXME: hack */
 438             CurrentDirectoryName = &((WIN16_SUBSYSTEM_TIB *)NtCurrentTeb()->Tib.SubSystemTib)->curdir.DosPath;
 439         else
 440             CurrentDirectoryName = &cur_params->CurrentDirectory.DosPath;
 441     }
 442     if (!CommandLine) CommandLine = ImagePathName;
 443     if (!Environment) Environment = cur_params->Environment;
 444     if (!WindowTitle) WindowTitle = &empty_str;
 445     if (!Desktop) Desktop = &empty_str;
 446     if (!ShellInfo) ShellInfo = &empty_str;
 447     if (!RuntimeInfo) RuntimeInfo = &null_str;
 448
 449     size = (sizeof(RTL_USER_PROCESS_PARAMETERS)
 450             + ImagePathName->MaximumLength
 451             + DllPath->MaximumLength
 452             + CurrentDirectoryName->MaximumLength
 453             + CommandLine->MaximumLength
 454             + WindowTitle->MaximumLength
 455             + Desktop->MaximumLength
 456             + ShellInfo->MaximumLength
 457             + RuntimeInfo->MaximumLength);
 458
 459     total_size = size;
 460     ptr = NULL;
 461     if ((status = NtAllocateVirtualMemory( NtCurrentProcess(), &ptr, 0, &total_size,
 462                                            MEM_COMMIT, PAGE_READWRITE )) == STATUS_SUCCESS)
 463     {
 464         RTL_USER_PROCESS_PARAMETERS *params = ptr;
 465         params->AllocationSize = total_size;
 466         params->Size           = size;
 467         params->Flags          = PROCESS_PARAMS_FLAG_NORMALIZED;
 468         params->ConsoleFlags   = cur_params->ConsoleFlags;
 469         params->Environment    = Environment;
 470         /* all other fields are zero */
 471
 472         ptr = params + 1;
 473         append_unicode_string( &ptr, CurrentDirectoryName, &params->CurrentDirectory.DosPath );
 474         append_unicode_string( &ptr, DllPath, &params->DllPath );
 475         append_unicode_string( &ptr, ImagePathName, &params->ImagePathName );
 476         append_unicode_string( &ptr, CommandLine, &params->CommandLine );
 477         append_unicode_string( &ptr, WindowTitle, &params->WindowTitle );
 478         append_unicode_string( &ptr, Desktop, &params->Desktop );
 479         append_unicode_string( &ptr, ShellInfo, &params->ShellInfo );
 480         append_unicode_string( &ptr, RuntimeInfo, &params->RuntimeInfo );
 481         *result = RtlDeNormalizeProcessParams( params );
 482     }
 483     RtlReleasePebLock();
 484     return status;
 485 }
 486
 487
 488 /******************************************************************************
 489  *  RtlDestroyProcessParameters  [NTDLL.@]
 490  */
 491 void WINAPI RtlDestroyProcessParameters( RTL_USER_PROCESS_PARAMETERS *params )
 492 {
 493     void *ptr = params;
 494     SIZE_T size = 0;
 495     NtFreeVirtualMemory( NtCurrentProcess(), &ptr, &size, MEM_RELEASE );
 496 }