Added support for calling the TLS callback functions.
[wine] / 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 }