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