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
  25 #include "winternl.h"
  26 #include "wine/unicode.h"
  27 #include "wine/debug.h"
  28 #include "ntdll_misc.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(environ);
  31
  32 /******************************************************************************
  33  *  RtlCreateEnvironment                [NTDLL.@]
  34  */
  35 NTSTATUS WINAPI RtlCreateEnvironment(BOOLEAN inherit, PWSTR* env)
  36 {
  37     NTSTATUS    nts;
  38
  39     TRACE("(%u,%p)!\n", inherit, env);
  40
  41     if (inherit)
  42     {
  43         MEMORY_BASIC_INFORMATION        mbi;
  44
  45         RtlAcquirePebLock();
  46
  47         nts = NtQueryVirtualMemory(NtCurrentProcess(), ntdll_get_process_pmts()->Environment,
  48                                    0, &mbi, sizeof(mbi), NULL);
  49         if (nts == STATUS_SUCCESS)
  50         {
  51             *env = NULL;
  52             nts = NtAllocateVirtualMemory(NtCurrentProcess(), (void**)env, 0, &mbi.RegionSize,
  53                                           MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
  54             if (nts == STATUS_SUCCESS)
  55                 memcpy(*env, ntdll_get_process_pmts()->Environment, mbi.RegionSize);
  56             else *env = NULL;
  57         }
  58         RtlReleasePebLock();
  59     }
  60     else
  61     {
  62         ULONG       size = 1;
  63         nts = NtAllocateVirtualMemory(NtCurrentProcess(), (void**)env, 0, &size,
  64                                       MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
  65         if (nts == STATUS_SUCCESS)
  66             memset(*env, 0, size);
  67     }
  68
  69     return nts;
  70 }
  71
  72 /******************************************************************************
  73  *  RtlDestroyEnvironment               [NTDLL.@]
  74  */
  75 NTSTATUS WINAPI RtlDestroyEnvironment(PWSTR env)
  76 {
  77     ULONG size = 0;
  78
  79     TRACE("(%p)!\n", env);
  80
  81     return NtFreeVirtualMemory(NtCurrentProcess(), (void**)&env, &size, MEM_RELEASE);
  82 }
  83
  84 /******************************************************************
  85  *              RtlQueryEnvironmentVariable_U   [NTDLL.@]
  86  *
  87  */
  88 NTSTATUS WINAPI RtlQueryEnvironmentVariable_U(PWSTR env,
  89                                               PUNICODE_STRING name,
  90                                               PUNICODE_STRING value)
  91 {
  92     NTSTATUS    nts = STATUS_VARIABLE_NOT_FOUND;
  93     PWSTR       var;
  94     unsigned    namelen, varlen;
  95
  96     TRACE("%s %s %p\n", debugstr_w(env), debugstr_w(name->Buffer), value);
  97
  98     value->Length = 0;
  99     namelen = name->Length / sizeof(WCHAR);
 100     if (!namelen) return nts;
 101
 102     if (!env)
 103     {
 104         RtlAcquirePebLock();
 105         var = ntdll_get_process_pmts()->Environment;
 106     }
 107     else var = env;
 108
 109     for (; *var; var += varlen + 1)
 110     {
 111         varlen = strlenW(var);
 112         /* match var names, but avoid setting a var with a name including a '='
 113          * (a starting '=' is valid though)
 114          */
 115         if (strncmpiW(var, name->Buffer, namelen) == 0 && var[namelen] == '=' &&
 116             strchrW(var + 1, '=') == var + namelen)
 117         {
 118             value->Length = (varlen - namelen - 1) * sizeof(WCHAR);
 119             if (value->Length <= value->MaximumLength)
 120             {
 121                 memmove(value->Buffer, var + namelen + 1, value->Length + sizeof(WCHAR));
 122                 nts = STATUS_SUCCESS;
 123             }
 124             else nts = STATUS_BUFFER_TOO_SMALL;
 125             break;
 126         }
 127     }
 128
 129     if (!env) RtlReleasePebLock();
 130
 131     return nts;
 132 }
 133
 134 /******************************************************************
 135  *              RtlSetCurrentEnvironment        [NTDLL.@]
 136  *
 137  */
 138 void WINAPI RtlSetCurrentEnvironment(PWSTR new_env, PWSTR* old_env)
 139 {
 140     TRACE("(%p %p)\n", new_env, old_env);
 141
 142     RtlAcquirePebLock();
 143
 144     if (old_env) *old_env = ntdll_get_process_pmts()->Environment;
 145     ntdll_get_process_pmts()->Environment = new_env;
 146
 147     RtlReleasePebLock();
 148 }
 149
 150
 151 /******************************************************************************
 152  *  RtlSetEnvironmentVariable           [NTDLL.@]
 153  */
 154 NTSTATUS WINAPI RtlSetEnvironmentVariable(PWSTR* penv, PUNICODE_STRING name,
 155                                           PUNICODE_STRING value)
 156 {
 157     INT         len, old_size;
 158     LPWSTR      p, env;
 159     NTSTATUS    nts = STATUS_VARIABLE_NOT_FOUND;
 160     MEMORY_BASIC_INFORMATION mbi;
 161
 162     TRACE("(%p,%s,%s): stub!\n", penv, debugstr_w(name->Buffer), debugstr_w(value->Buffer));
 163
 164     if (!name || !name->Buffer || !name->Buffer[0])
 165         return STATUS_INVALID_PARAMETER_1;
 166     /* variable names can't contain a '=' except as a first character */
 167     if (strchrW(name->Buffer + 1, '=')) return STATUS_INVALID_PARAMETER;
 168
 169     if (!penv)
 170     {
 171         RtlAcquirePebLock();
 172         env = ntdll_get_process_pmts()->Environment;
 173     } else env = *penv;
 174
 175     len = name->Length / sizeof(WCHAR);
 176
 177     /* compute current size of environment */
 178     for (p = env; *p; p += strlenW(p) + 1);
 179     old_size = p + 1 - env;
 180
 181     /* Find a place to insert the string */
 182     for (p = env; *p; p += strlenW(p) + 1)
 183     {
 184         if (!strncmpiW(name->Buffer, p, len) && (p[len] == '=')) break;
 185     }
 186     if (!value && !*p) goto done;  /* Value to remove doesn't exist */
 187
 188     /* Realloc the buffer */
 189     len = value ? len + value->Length / sizeof(WCHAR) + 2 : 0;
 190     if (*p) len -= strlenW(p) + 1;  /* The name already exists */
 191
 192     if (len < 0)
 193     {
 194         LPWSTR next = p + strlenW(p) + 1;  /* We know there is a next one */
 195         memmove(next + len, next, (old_size - (next - env)) * sizeof(WCHAR));
 196     }
 197
 198     nts = NtQueryVirtualMemory(NtCurrentProcess(), env, 0,
 199                                &mbi, sizeof(mbi), NULL);
 200     if (nts != STATUS_SUCCESS) goto done;
 201
 202     if ((old_size + len) * sizeof(WCHAR) > mbi.RegionSize)
 203     {
 204         LPWSTR  new_env;
 205         ULONG   new_size = (old_size + len) * sizeof(WCHAR);
 206
 207         new_env = NULL;
 208         nts = NtAllocateVirtualMemory(NtCurrentProcess(), (void**)&new_env, 0,
 209                                       &new_size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
 210         if (nts != STATUS_SUCCESS) goto done;
 211
 212         memmove(new_env, env, (p - env) * sizeof(WCHAR));
 213         assert(len > 0);
 214         memmove(new_env + (p - env) + len, p, (old_size - (p - env)) * sizeof(WCHAR));
 215         p = new_env + (p - env);
 216
 217         RtlDestroyEnvironment(env);
 218         if (!penv) ntdll_get_process_pmts()->Environment = new_env;
 219         else *penv = new_env;
 220         env = new_env;
 221     }
 222     else
 223     {
 224         if (len > 0) memmove(p + len, p, (old_size - (p - env)) * sizeof(WCHAR));
 225     }
 226
 227     /* Set the new string */
 228     if (value)
 229     {
 230         static const WCHAR equalW[] = {'=',0};
 231
 232         strcpyW(p, name->Buffer);
 233         strcatW(p, equalW);
 234         strcatW(p, value->Buffer);
 235     }
 236
 237 done:
 238     if (!penv) RtlReleasePebLock();
 239
 240     return nts;
 241 }
 242
 243 /***********************************************************************
 244  *           build_environment
 245  *
 246  * Build the Win32 environment from the Unix environment
 247  */
 248 BOOL build_initial_environment(void)
 249 {
 250     extern char **environ;
 251     LPSTR*      e, te;
 252     LPWSTR      p;
 253     ULONG       size;
 254     NTSTATUS    nts;
 255     int         len;
 256
 257     /* Compute the total size of the Unix environment */
 258     size = sizeof(BYTE);
 259     for (e = environ; *e; e++)
 260     {
 261         if (!memcmp(*e, "PATH=", 5)) continue;
 262         size += strlen(*e) + 1;
 263     }
 264     size *= sizeof(WCHAR);
 265
 266     /* Now allocate the environment */
 267     nts = NtAllocateVirtualMemory(NtCurrentProcess(), (void**)&p, 0, &size,
 268                                   MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
 269     if (nts != STATUS_SUCCESS) return FALSE;
 270
 271     ntdll_get_process_pmts()->Environment = p;
 272     /* And fill it with the Unix environment */
 273     for (e = environ; *e; e++)
 274     {
 275         /* skip Unix PATH and store WINEPATH as PATH */
 276         if (!memcmp(*e, "PATH=", 5)) continue;
 277         if (!memcmp(*e, "WINEPATH=", 9 )) te = *e + 4; else te = *e;
 278         len = strlen(te);
 279         RtlMultiByteToUnicodeN(p, len * sizeof(WCHAR), NULL, te, len);
 280         p[len] = 0;
 281         p += len + 1;
 282     }
 283     *p = 0;
 284
 285     return TRUE;
 286 }