ntdll: Move the LDT section to ntdll and make it an uninterruptible section.
[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., 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 "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         SIZE_T      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     SIZE_T 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("%p %s %p\n", env, debugstr_us(name), 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", penv, debugstr_us(name), debugstr_us(value));
181
182     if (!name || !name->Buffer || !name->Length)
183         return STATUS_INVALID_PARAMETER_1;
184
185     len = name->Length / sizeof(WCHAR);
186
187     /* variable names can't contain a '=' except as a first character */
188     for (p = name->Buffer + 1; p < name->Buffer + len; p++)
189         if (*p == '=') return STATUS_INVALID_PARAMETER;
190
191     if (!penv)
192     {
193         RtlAcquirePebLock();
194         env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
195     } else env = *penv;
196
197     /* compute current size of environment */
198     for (p = env; *p; p += strlenW(p) + 1);
199     old_size = p + 1 - env;
200
201     /* Find a place to insert the string */
202     for (p = env; *p; p += strlenW(p) + 1)
203     {
204         if (!strncmpiW(name->Buffer, p, len) && (p[len] == '=')) break;
205     }
206     if (!value && !*p) goto done;  /* Value to remove doesn't exist */
207
208     /* Realloc the buffer */
209     len = value ? len + value->Length / sizeof(WCHAR) + 2 : 0;
210     if (*p) len -= strlenW(p) + 1;  /* The name already exists */
211
212     if (len < 0)
213     {
214         LPWSTR next = p + strlenW(p) + 1;  /* We know there is a next one */
215         memmove(next + len, next, (old_size - (next - env)) * sizeof(WCHAR));
216     }
217
218     nts = NtQueryVirtualMemory(NtCurrentProcess(), env, 0,
219                                &mbi, sizeof(mbi), NULL);
220     if (nts != STATUS_SUCCESS) goto done;
221
222     if ((old_size + len) * sizeof(WCHAR) > mbi.RegionSize)
223     {
224         LPWSTR  new_env;
225         SIZE_T  new_size = (old_size + len) * sizeof(WCHAR);
226
227         new_env = NULL;
228         nts = NtAllocateVirtualMemory(NtCurrentProcess(), (void**)&new_env, 0,
229                                       &new_size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
230         if (nts != STATUS_SUCCESS) goto done;
231
232         memmove(new_env, env, (p - env) * sizeof(WCHAR));
233         assert(len > 0);
234         memmove(new_env + (p - env) + len, p, (old_size - (p - env)) * sizeof(WCHAR));
235         p = new_env + (p - env);
236
237         RtlDestroyEnvironment(env);
238         if (!penv) NtCurrentTeb()->Peb->ProcessParameters->Environment = new_env;
239         else *penv = new_env;
240         env = new_env;
241     }
242     else
243     {
244         if (len > 0) memmove(p + len, p, (old_size - (p - env)) * sizeof(WCHAR));
245     }
246
247     /* Set the new string */
248     if (value)
249     {
250         memcpy( p, name->Buffer, name->Length );
251         p += name->Length / sizeof(WCHAR);
252         *p++ = '=';
253         memcpy( p, value->Buffer, value->Length );
254         p[value->Length / sizeof(WCHAR)] = 0;
255     }
256 done:
257     if (!penv) RtlReleasePebLock();
258
259     return nts;
260 }
261
262 /******************************************************************
263  *              RtlExpandEnvironmentStrings_U (NTDLL.@)
264  *
265  */
266 NTSTATUS WINAPI RtlExpandEnvironmentStrings_U(PWSTR renv, const UNICODE_STRING* us_src,
267                                               PUNICODE_STRING us_dst, PULONG plen)
268 {
269     DWORD src_len, len, count, total_size = 1;  /* 1 for terminating '\0' */
270     LPCWSTR     env, src, p, var;
271     LPWSTR      dst;
272
273     src = us_src->Buffer;
274     src_len = us_src->Length / sizeof(WCHAR);
275     count = us_dst->MaximumLength / sizeof(WCHAR);
276     dst = count ? us_dst->Buffer : NULL;
277
278     if (!renv)
279     {
280         RtlAcquirePebLock();
281         env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
282     }
283     else env = renv;
284
285     while (src_len)
286     {
287         if (*src != '%')
288         {
289             if ((p = memchrW( src, '%', src_len ))) len = p - src;
290             else len = src_len;
291             var = src;
292             src += len;
293             src_len -= len;
294         }
295         else  /* we are at the start of a variable */
296         {
297             if ((p = memchrW( src + 1, '%', src_len - 1 )))
298             {
299                 len = p - src - 1;  /* Length of the variable name */
300                 if ((var = ENV_FindVariable( env, src + 1, len )))
301                 {
302                     src += len + 2;  /* Skip the variable name */
303                     src_len -= len + 2;
304                     len = strlenW(var);
305                 }
306                 else
307                 {
308                     var = src;  /* Copy original name instead */
309                     len += 2;
310                     src += len;
311                     src_len -= len;
312                 }
313             }
314             else  /* unfinished variable name, ignore it */
315             {
316                 var = src;
317                 len = src_len;  /* Copy whole string */
318                 src += len;
319                 src_len = 0;
320             }
321         }
322         total_size += len;
323         if (dst)
324         {
325             if (count < len) len = count;
326             memcpy(dst, var, len * sizeof(WCHAR));
327             count -= len;
328             dst += len;
329         }
330     }
331
332     if (!renv) RtlReleasePebLock();
333
334     /* Null-terminate the string */
335     if (dst && count) *dst = '\0';
336
337     us_dst->Length = (dst) ? (dst - us_dst->Buffer) * sizeof(WCHAR) : 0;
338     if (plen) *plen = total_size * sizeof(WCHAR);
339
340     return (count) ? STATUS_SUCCESS : STATUS_BUFFER_TOO_SMALL;
341 }
342
343
344 static inline void normalize( void *base, WCHAR **ptr )
345 {
346     if (*ptr) *ptr = (WCHAR *)((char *)base + (UINT_PTR)*ptr);
347 }
348
349 /******************************************************************************
350  *  RtlNormalizeProcessParams  [NTDLL.@]
351  */
352 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlNormalizeProcessParams( RTL_USER_PROCESS_PARAMETERS *params )
353 {
354     if (params && !(params->Flags & PROCESS_PARAMS_FLAG_NORMALIZED))
355     {
356         normalize( params, &params->CurrentDirectory.DosPath.Buffer );
357         normalize( params, &params->DllPath.Buffer );
358         normalize( params, &params->ImagePathName.Buffer );
359         normalize( params, &params->CommandLine.Buffer );
360         normalize( params, &params->WindowTitle.Buffer );
361         normalize( params, &params->Desktop.Buffer );
362         normalize( params, &params->ShellInfo.Buffer );
363         normalize( params, &params->RuntimeInfo.Buffer );
364         params->Flags |= PROCESS_PARAMS_FLAG_NORMALIZED;
365     }
366     return params;
367 }
368
369
370 static inline void denormalize( void *base, WCHAR **ptr )
371 {
372     if (*ptr) *ptr = (WCHAR *)(UINT_PTR)((char *)*ptr - (char *)base);
373 }
374
375 /******************************************************************************
376  *  RtlDeNormalizeProcessParams  [NTDLL.@]
377  */
378 PRTL_USER_PROCESS_PARAMETERS WINAPI RtlDeNormalizeProcessParams( RTL_USER_PROCESS_PARAMETERS *params )
379 {
380     if (params && (params->Flags & PROCESS_PARAMS_FLAG_NORMALIZED))
381     {
382         denormalize( params, &params->CurrentDirectory.DosPath.Buffer );
383         denormalize( params, &params->DllPath.Buffer );
384         denormalize( params, &params->ImagePathName.Buffer );
385         denormalize( params, &params->CommandLine.Buffer );
386         denormalize( params, &params->WindowTitle.Buffer );
387         denormalize( params, &params->Desktop.Buffer );
388         denormalize( params, &params->ShellInfo.Buffer );
389         denormalize( params, &params->RuntimeInfo.Buffer );
390         params->Flags &= ~PROCESS_PARAMS_FLAG_NORMALIZED;
391     }
392     return params;
393 }
394
395
396 /* append a unicode string to the process params data; helper for RtlCreateProcessParameters */
397 static void append_unicode_string( void **data, const UNICODE_STRING *src,
398                                    UNICODE_STRING *dst )
399 {
400     dst->Length = src->Length;
401     dst->MaximumLength = src->MaximumLength;
402     dst->Buffer = *data;
403     memcpy( dst->Buffer, src->Buffer, dst->MaximumLength );
404     *data = (char *)dst->Buffer + dst->MaximumLength;
405 }
406
407
408 /******************************************************************************
409  *  RtlCreateProcessParameters  [NTDLL.@]
410  */
411 NTSTATUS WINAPI RtlCreateProcessParameters( RTL_USER_PROCESS_PARAMETERS **result,
412                                             const UNICODE_STRING *ImagePathName,
413                                             const UNICODE_STRING *DllPath,
414                                             const UNICODE_STRING *CurrentDirectoryName,
415                                             const UNICODE_STRING *CommandLine,
416                                             PWSTR Environment,
417                                             const UNICODE_STRING *WindowTitle,
418                                             const UNICODE_STRING *Desktop,
419                                             const UNICODE_STRING *ShellInfo,
420                                             const UNICODE_STRING *RuntimeInfo )
421 {
422     static WCHAR empty[] = {0};
423     static const UNICODE_STRING empty_str = { 0, sizeof(empty), empty };
424     static const UNICODE_STRING null_str = { 0, 0, NULL };
425
426     const RTL_USER_PROCESS_PARAMETERS *cur_params;
427     SIZE_T size, total_size;
428     void *ptr;
429     NTSTATUS status;
430
431     RtlAcquirePebLock();
432     cur_params = NtCurrentTeb()->Peb->ProcessParameters;
433     if (!DllPath) DllPath = &cur_params->DllPath;
434     if (!CurrentDirectoryName) CurrentDirectoryName = &cur_params->CurrentDirectory.DosPath;
435     if (!CommandLine) CommandLine = ImagePathName;
436     if (!Environment) Environment = cur_params->Environment;
437     if (!WindowTitle) WindowTitle = &empty_str;
438     if (!Desktop) Desktop = &empty_str;
439     if (!ShellInfo) ShellInfo = &empty_str;
440     if (!RuntimeInfo) RuntimeInfo = &null_str;
441
442     size = (sizeof(RTL_USER_PROCESS_PARAMETERS)
443             + ImagePathName->MaximumLength
444             + DllPath->MaximumLength
445             + CurrentDirectoryName->MaximumLength
446             + CommandLine->MaximumLength
447             + WindowTitle->MaximumLength
448             + Desktop->MaximumLength
449             + ShellInfo->MaximumLength
450             + RuntimeInfo->MaximumLength);
451
452     total_size = size;
453     ptr = NULL;
454     if ((status = NtAllocateVirtualMemory( NtCurrentProcess(), &ptr, 0, &total_size,
455                                            MEM_COMMIT, PAGE_READWRITE )) == STATUS_SUCCESS)
456     {
457         RTL_USER_PROCESS_PARAMETERS *params = ptr;
458         params->AllocationSize = total_size;
459         params->Size           = size;
460         params->Flags          = PROCESS_PARAMS_FLAG_NORMALIZED;
461         params->ConsoleFlags   = cur_params->ConsoleFlags;
462         params->Environment    = Environment;
463         /* all other fields are zero */
464
465         ptr = params + 1;
466         append_unicode_string( &ptr, CurrentDirectoryName, &params->CurrentDirectory.DosPath );
467         append_unicode_string( &ptr, DllPath, &params->DllPath );
468         append_unicode_string( &ptr, ImagePathName, &params->ImagePathName );
469         append_unicode_string( &ptr, CommandLine, &params->CommandLine );
470         append_unicode_string( &ptr, WindowTitle, &params->WindowTitle );
471         append_unicode_string( &ptr, Desktop, &params->Desktop );
472         append_unicode_string( &ptr, ShellInfo, &params->ShellInfo );
473         append_unicode_string( &ptr, RuntimeInfo, &params->RuntimeInfo );
474         *result = RtlDeNormalizeProcessParams( params );
475     }
476     RtlReleasePebLock();
477     return status;
478 }
479
480
481 /******************************************************************************
482  *  RtlDestroyProcessParameters  [NTDLL.@]
483  */
484 void WINAPI RtlDestroyProcessParameters( RTL_USER_PROCESS_PARAMETERS *params )
485 {
486     void *ptr = params;
487     SIZE_T size = 0;
488     NtFreeVirtualMemory( NtCurrentProcess(), &ptr, &size, MEM_RELEASE );
489 }