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(PCWSTR 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, ¶ms->CurrentDirectory.DosPath.Buffer );
357 normalize( params, ¶ms->DllPath.Buffer );
358 normalize( params, ¶ms->ImagePathName.Buffer );
359 normalize( params, ¶ms->CommandLine.Buffer );
360 normalize( params, ¶ms->WindowTitle.Buffer );
361 normalize( params, ¶ms->Desktop.Buffer );
362 normalize( params, ¶ms->ShellInfo.Buffer );
363 normalize( params, ¶ms->RuntimeInfo.Buffer );
364 params->Flags |= PROCESS_PARAMS_FLAG_NORMALIZED;
365 }
366 return params;
367 }
368
369
370 static inline void denormalize( const void *base, WCHAR **ptr )
371 {
372 if (*ptr) *ptr = (WCHAR *)(UINT_PTR)((char *)*ptr - (const 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, ¶ms->CurrentDirectory.DosPath.Buffer );
383 denormalize( params, ¶ms->DllPath.Buffer );
384 denormalize( params, ¶ms->ImagePathName.Buffer );
385 denormalize( params, ¶ms->CommandLine.Buffer );
386 denormalize( params, ¶ms->WindowTitle.Buffer );
387 denormalize( params, ¶ms->Desktop.Buffer );
388 denormalize( params, ¶ms->ShellInfo.Buffer );
389 denormalize( params, ¶ms->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)
435 {
436 if (NtCurrentTeb()->Tib.SubSystemTib) /* FIXME: hack */
437 CurrentDirectoryName = &((WIN16_SUBSYSTEM_TIB *)NtCurrentTeb()->Tib.SubSystemTib)->curdir.DosPath;
438 else
439 CurrentDirectoryName = &cur_params->CurrentDirectory.DosPath;
440 }
441 if (!CommandLine) CommandLine = ImagePathName;
442 if (!Environment) Environment = cur_params->Environment;
443 if (!WindowTitle) WindowTitle = &empty_str;
444 if (!Desktop) Desktop = &empty_str;
445 if (!ShellInfo) ShellInfo = &empty_str;
446 if (!RuntimeInfo) RuntimeInfo = &null_str;
447
448 size = (sizeof(RTL_USER_PROCESS_PARAMETERS)
449 + ImagePathName->MaximumLength
450 + DllPath->MaximumLength
451 + CurrentDirectoryName->MaximumLength
452 + CommandLine->MaximumLength
453 + WindowTitle->MaximumLength
454 + Desktop->MaximumLength
455 + ShellInfo->MaximumLength
456 + RuntimeInfo->MaximumLength);
457
458 total_size = size;
459 ptr = NULL;
460 if ((status = NtAllocateVirtualMemory( NtCurrentProcess(), &ptr, 0, &total_size,
461 MEM_COMMIT, PAGE_READWRITE )) == STATUS_SUCCESS)
462 {
463 RTL_USER_PROCESS_PARAMETERS *params = ptr;
464 params->AllocationSize = total_size;
465 params->Size = size;
466 params->Flags = PROCESS_PARAMS_FLAG_NORMALIZED;
467 params->ConsoleFlags = cur_params->ConsoleFlags;
468 params->Environment = Environment;
469 /* all other fields are zero */
470
471 ptr = params + 1;
472 append_unicode_string( &ptr, CurrentDirectoryName, ¶ms->CurrentDirectory.DosPath );
473 append_unicode_string( &ptr, DllPath, ¶ms->DllPath );
474 append_unicode_string( &ptr, ImagePathName, ¶ms->ImagePathName );
475 append_unicode_string( &ptr, CommandLine, ¶ms->CommandLine );
476 append_unicode_string( &ptr, WindowTitle, ¶ms->WindowTitle );
477 append_unicode_string( &ptr, Desktop, ¶ms->Desktop );
478 append_unicode_string( &ptr, ShellInfo, ¶ms->ShellInfo );
479 append_unicode_string( &ptr, RuntimeInfo, ¶ms->RuntimeInfo );
480 *result = RtlDeNormalizeProcessParams( params );
481 }
482 RtlReleasePebLock();
483 return status;
484 }
485
486
487 /******************************************************************************
488 * RtlDestroyProcessParameters [NTDLL.@]
489 */
490 void WINAPI RtlDestroyProcessParameters( RTL_USER_PROCESS_PARAMETERS *params )
491 {
492 void *ptr = params;
493 SIZE_T size = 0;
494 NtFreeVirtualMemory( NtCurrentProcess(), &ptr, &size, MEM_RELEASE );
495 }
496
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.