?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mfplat: Implement IMFAttributes::GetItemByIndex().
[wine.git] / dlls / userenv / userenv_main.c
blob11a4f756543974bc8322e17a68099814b2358c02
1 /*
2 * Implementation of userenv.dll
3 *
4 * Copyright 2006 Mike McCormack for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22
23 #include "ntstatus.h"
24 #define WIN32_NO_STATUS
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winreg.h"
28 #include "winternl.h"
29 #include "winnls.h"
30 #include "sddl.h"
31 #include "objbase.h"
32 #include "userenv.h"
33
34 #include "wine/debug.h"
35 #include "wine/unicode.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL( userenv );
38
39 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
40 {
41 TRACE("%p %d %p\n", hinstDLL, fdwReason, lpvReserved);
42
43 switch (fdwReason)
44 {
45 case DLL_WINE_PREATTACH:
46 return FALSE; /* prefer native version */
47 case DLL_PROCESS_ATTACH:
48 DisableThreadLibraryCalls(hinstDLL);
49 break;
50 }
51 return TRUE;
52 }
53
54 static BOOL get_reg_value(WCHAR *env, HKEY hkey, const WCHAR *name, WCHAR *val, DWORD size)
55 {
56 DWORD type, res_size=0;
57
58 if (RegQueryValueExW(hkey, name, 0, &type, NULL, &res_size) != ERROR_SUCCESS)
59 return FALSE;
60
61 if (type == REG_SZ)
62 {
63 if (res_size > size)
64 return FALSE;
65
66 return RegQueryValueExW(hkey, name, 0, NULL, (BYTE*)val, &size) == ERROR_SUCCESS;
67 }
68 else if (type == REG_EXPAND_SZ)
69 {
70 UNICODE_STRING us_buf, us_expanded;
71 WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, res_size);
72 if (!buf)
73 return FALSE;
74
75 if (RegQueryValueExW(hkey, name, 0, NULL, (BYTE*)buf, &res_size) != ERROR_SUCCESS)
76 {
77 HeapFree(GetProcessHeap(), 0, buf);
78 return FALSE;
79 }
80
81 RtlInitUnicodeString(&us_buf, buf);
82 us_expanded.Buffer = val;
83 us_expanded.MaximumLength = size;
84 if (RtlExpandEnvironmentStrings_U(env, &us_buf, &us_expanded, &size) != STATUS_SUCCESS)
85 {
86 HeapFree(GetProcessHeap(), 0, buf);
87 return FALSE;
88 }
89
90 HeapFree(GetProcessHeap(), 0, buf);
91 return TRUE;
92 }
93
94 return FALSE;
95 }
96
97 static void set_registry_variables(WCHAR **env, HKEY hkey, DWORD type, BOOL set_path)
98 {
99 static const WCHAR SystemRootW[] = {'S','y','s','t','e','m','R','o','o','t',0};
100 static const WCHAR SystemDriveW[] = {'S','y','s','t','e','m','D','r','i','v','e',0};
101 static const WCHAR PATHW[] = {'P','A','T','H'};
102
103 UNICODE_STRING us_name, us_value;
104 WCHAR name[1024], value[1024];
105 DWORD ret, index, size;
106
107 for (index = 0; ; index++)
108 {
109 size = ARRAY_SIZE(name);
110 ret = RegEnumValueW(hkey, index, name, &size, NULL, NULL, NULL, NULL);
111 if (ret != ERROR_SUCCESS)
112 break;
113
114 if (!memicmpW(name, SystemRootW, ARRAY_SIZE(SystemRootW)))
115 continue;
116 if (!memicmpW(name, SystemDriveW, ARRAY_SIZE(SystemDriveW)))
117 continue;
118
119 RtlInitUnicodeString(&us_name, name);
120 us_value.Buffer = value;
121 us_value.MaximumLength = sizeof(value);
122 if (!memicmpW(name, PATHW, ARRAY_SIZE(PATHW)) &&
123 !RtlQueryEnvironmentVariable_U(*env, &us_name, &us_value))
124 {
125 if (!set_path)
126 continue;
127
128 size = strlenW(value)+1;
129 if (!get_reg_value(*env, hkey, name, value+size,
130 sizeof(value)-size*sizeof(WCHAR)))
131 continue;
132
133 value[size] = ';';
134 RtlInitUnicodeString(&us_value, value);
135 RtlSetEnvironmentVariable(env, &us_name, &us_value);
136 continue;
137 }
138
139 if (!get_reg_value(*env, hkey, name, value, sizeof(value)))
140 continue;
141
142 if(!value[0])
143 continue;
144
145 RtlInitUnicodeString(&us_value, value);
146 RtlSetEnvironmentVariable(env, &us_name, &us_value);
147 }
148 }
149
150 static void set_wow64_environment(WCHAR **env)
151 {
152 static const WCHAR versionW[] = {'S','o','f','t','w','a','r','e','\\',
153 'M','i','c','r','o','s','o','f','t','\\',
154 'W','i','n','d','o','w','s','\\',
155 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
156 static const WCHAR progdirW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r',0};
157 static const WCHAR progdir86W[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r',' ','(','x','8','6',')',0};
158 static const WCHAR progfilesW[] = {'P','r','o','g','r','a','m','F','i','l','e','s',0};
159 static const WCHAR progw6432W[] = {'P','r','o','g','r','a','m','W','6','4','3','2',0};
160 static const WCHAR commondirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',0};
161 static const WCHAR commondir86W[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',' ','(','x','8','6',')',0};
162 static const WCHAR commonfilesW[] = {'C','o','m','m','o','n','P','r','o','g','r','a','m','F','i','l','e','s',0};
163 static const WCHAR commonw6432W[] = {'C','o','m','m','o','n','P','r','o','g','r','a','m','W','6','4','3','2',0};
164
165 UNICODE_STRING nameW, valueW;
166 WCHAR buf[64];
167 HKEY hkey;
168 BOOL is_win64 = (sizeof(void *) > sizeof(int));
169 BOOL is_wow64;
170
171 IsWow64Process( GetCurrentProcess(), &is_wow64 );
172
173 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, versionW, 0,
174 KEY_READ|KEY_WOW64_64KEY, &hkey))
175 return;
176
177 /* set the ProgramFiles variables */
178
179 if (get_reg_value(*env, hkey, progdirW, buf, sizeof(buf)))
180 {
181 if (is_win64 || is_wow64)
182 {
183 RtlInitUnicodeString(&nameW, progw6432W);
184 RtlInitUnicodeString(&valueW, buf);
185 RtlSetEnvironmentVariable(env, &nameW, &valueW);
186 }
187 if (is_win64 || !is_wow64)
188 {
189 RtlInitUnicodeString(&nameW, progfilesW);
190 RtlInitUnicodeString(&valueW, buf);
191 RtlSetEnvironmentVariable(env, &nameW, &valueW);
192 }
193 }
194 if (is_wow64 && get_reg_value(*env, hkey, progdir86W, buf, sizeof(buf)))
195 {
196 RtlInitUnicodeString(&nameW, progfilesW);
197 RtlInitUnicodeString(&valueW, buf);
198 RtlSetEnvironmentVariable(env, &nameW, &valueW);
199 }
200
201 /* set the CommonProgramFiles variables */
202
203 if (get_reg_value(*env, hkey, commondirW, buf, sizeof(buf)))
204 {
205 if (is_win64 || is_wow64)
206 {
207 RtlInitUnicodeString(&nameW, commonw6432W);
208 RtlInitUnicodeString(&valueW, buf);
209 RtlSetEnvironmentVariable(env, &nameW, &valueW);
210 }
211 if (is_win64 || !is_wow64)
212 {
213 RtlInitUnicodeString(&nameW, commonfilesW);
214 RtlInitUnicodeString(&valueW, buf);
215 RtlSetEnvironmentVariable(env, &nameW, &valueW);
216 }
217 }
218 if (is_wow64 && get_reg_value(*env, hkey, commondir86W, buf, sizeof(buf)))
219 {
220 RtlInitUnicodeString(&nameW, commonfilesW);
221 RtlInitUnicodeString(&valueW, buf);
222 RtlSetEnvironmentVariable(env, &nameW, &valueW);
223 }
224
225 RegCloseKey(hkey);
226 }
227
228 BOOL WINAPI CreateEnvironmentBlock( LPVOID* lpEnvironment,
229 HANDLE hToken, BOOL bInherit )
230 {
231 static const WCHAR env_keyW[] = {'S','y','s','t','e','m','\\',
232 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
233 'C','o','n','t','r','o','l','\\',
234 'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r','\\',
235 'E','n','v','i','r','o','n','m','e','n','t',0};
236 static const WCHAR profile_keyW[] = {'S','o','f','t','w','a','r','e','\\',
237 'M','i','c','r','o','s','o','f','t','\\',
238 'W','i','n','d','o','w','s',' ','N','T','\\',
239 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
240 'P','r','o','f','i','l','e','L','i','s','t',0};
241 static const WCHAR envW[] = {'E','n','v','i','r','o','n','m','e','n','t',0};
242 static const WCHAR volatile_envW[] = {'V','o','l','a','t','i','l','e',' ','E','n','v','i','r','o','n','m','e','n','t',0};
243 static const WCHAR ProfilesDirectoryW[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
244
245 static const WCHAR SystemRootW[] = {'S','y','s','t','e','m','R','o','o','t',0};
246 static const WCHAR SystemDriveW[] = {'S','y','s','t','e','m','D','r','i','v','e',0};
247 static const WCHAR PublicW[] = {'P','u','b','l','i','c',0};
248 static const WCHAR ALLUSERSPROFILEW[] = {'A','L','L','U','S','E','R','S','P','R','O','F','I','L','E',0};
249 static const WCHAR USERNAMEW[] = {'U','S','E','R','N','A','M','E',0};
250 static const WCHAR USERPROFILEW[] = {'U','S','E','R','P','R','O','F','I','L','E',0};
251 static const WCHAR DefaultW[] = {'D','e','f','a','u','l','t',0};
252 static const WCHAR COMPUTERNAMEW[] = {'C','O','M','P','U','T','E','R','N','A','M','E',0};
253
254 WCHAR *env, buf[UNICODE_STRING_MAX_CHARS], profiles_dir[MAX_PATH];
255 UNICODE_STRING us_name, us_val;
256 DWORD len;
257 HKEY hkey, hsubkey;
258
259 TRACE("%p %p %d\n", lpEnvironment, hToken, bInherit );
260
261 if (!lpEnvironment)
262 return FALSE;
263
264 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, env_keyW, 0, KEY_READ, &hkey) != ERROR_SUCCESS)
265 return FALSE;
266
267 if (RtlCreateEnvironment(bInherit, &env) != STATUS_SUCCESS)
268 {
269 RegCloseKey(hkey);
270 return FALSE;
271 }
272
273 if (!GetEnvironmentVariableW(SystemRootW, buf, UNICODE_STRING_MAX_CHARS))
274 {
275 if (!get_reg_value(env, hkey, SystemRootW, buf, UNICODE_STRING_MAX_CHARS))
276 {
277 buf[0] = 0;
278 WARN("SystemRoot variable not set\n");
279 }
280 }
281 RtlInitUnicodeString(&us_name, SystemRootW);
282 RtlInitUnicodeString(&us_val, buf);
283 RtlSetEnvironmentVariable(&env, &us_name, &us_val);
284
285 if (!GetEnvironmentVariableW(SystemDriveW, buf, UNICODE_STRING_MAX_CHARS))
286 {
287 if (!get_reg_value(env, hkey, SystemRootW, buf, UNICODE_STRING_MAX_CHARS))
288 {
289 buf[0] = 0;
290 WARN("SystemDrive variable not set\n");
291 }
292 }
293 RtlInitUnicodeString(&us_name, SystemDriveW);
294 RtlInitUnicodeString(&us_val, buf);
295 RtlSetEnvironmentVariable(&env, &us_name, &us_val);
296
297 set_registry_variables(&env, hkey, REG_SZ, !bInherit);
298 set_registry_variables(&env, hkey, REG_EXPAND_SZ, !bInherit);
299
300 if (RegOpenKeyExW(hkey, envW, 0, KEY_READ, &hsubkey) == ERROR_SUCCESS)
301 {
302 set_registry_variables(&env, hsubkey, REG_SZ, !bInherit);
303 set_registry_variables(&env, hsubkey, REG_EXPAND_SZ, !bInherit);
304 RegCloseKey(hsubkey);
305 }
306
307 if (RegOpenKeyExW(hkey, volatile_envW, 0, KEY_READ, &hsubkey) == ERROR_SUCCESS)
308 {
309 set_registry_variables(&env, hsubkey, REG_SZ, !bInherit);
310 set_registry_variables(&env, hsubkey, REG_EXPAND_SZ, !bInherit);
311 RegCloseKey(hsubkey);
312 }
313 RegCloseKey(hkey);
314
315 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, profile_keyW, 0, KEY_READ, &hkey) == ERROR_SUCCESS)
316 {
317 if (get_reg_value(env, hkey, ProfilesDirectoryW, profiles_dir, MAX_PATH-sizeof(WCHAR)))
318 {
319 len = strlenW(profiles_dir);
320 if (profiles_dir[len-1] != '\\')
321 {
322 profiles_dir[len++] = '\\';
323 profiles_dir[len] = '\0';
324 }
325
326 if (get_reg_value(env, hkey, PublicW, buf, UNICODE_STRING_MAX_CHARS))
327 {
328 RtlInitUnicodeString(&us_name, ALLUSERSPROFILEW);
329 RtlInitUnicodeString(&us_val, buf);
330 RtlSetEnvironmentVariable(&env, &us_name, &us_val);
331 }
332 }
333 else
334 {
335 profiles_dir[0] = 0;
336 }
337
338 RegCloseKey(hkey);
339 }
340
341 len = ARRAY_SIZE(buf);
342 if (GetComputerNameW(buf, &len))
343 {
344 RtlInitUnicodeString(&us_name, COMPUTERNAMEW);
345 RtlInitUnicodeString(&us_val, buf);
346 RtlSetEnvironmentVariable(&env, &us_name, &us_val);
347 }
348
349 set_wow64_environment(&env);
350
351 if (!hToken)
352 {
353 if (profiles_dir[0])
354 {
355 len = strlenW(profiles_dir);
356 if (len*sizeof(WCHAR)+sizeof(DefaultW) < sizeof(buf))
357 {
358 memcpy(buf, profiles_dir, len*sizeof(WCHAR));
359 memcpy(buf+len, DefaultW, sizeof(DefaultW));
360 RtlInitUnicodeString(&us_name, USERPROFILEW);
361 RtlInitUnicodeString(&us_val, buf);
362 RtlSetEnvironmentVariable(&env, &us_name, &us_val);
363 }
364 }
365
366 buf[0] = '.';
367 memcpy(buf+1, DefaultW, sizeof(DefaultW));
368 }
369 else
370 {
371 TOKEN_USER *token_user = NULL;
372 SID_NAME_USE use;
373 WCHAR *sidW;
374 DWORD size, tmp=0;
375
376 if (GetTokenInformation(hToken, TokenUser, NULL, 0, &len) ||
377 GetLastError()!=ERROR_INSUFFICIENT_BUFFER ||
378 !(token_user = HeapAlloc(GetProcessHeap(), 0, len)) ||
379 !GetTokenInformation(hToken, TokenUser, token_user, len, &len) ||
380 !ConvertSidToStringSidW(token_user->User.Sid, &sidW))
381 {
382 HeapFree(GetProcessHeap(), 0, token_user);
383 RtlDestroyEnvironment(env);
384 return FALSE;
385 }
386
387 len = strlenW(profiles_dir);
388 memcpy(buf, profiles_dir, len*sizeof(WCHAR));
389
390 size = UNICODE_STRING_MAX_CHARS-len;
391 if (LookupAccountSidW(NULL, token_user->User.Sid,
392 buf+len, &size, NULL, &tmp, &use))
393 {
394 RtlInitUnicodeString(&us_name, USERNAMEW);
395 RtlInitUnicodeString(&us_val, buf+len);
396 RtlSetEnvironmentVariable(&env, &us_name, &us_val);
397
398 if (len)
399 {
400 RtlInitUnicodeString(&us_name, USERPROFILEW);
401 RtlInitUnicodeString(&us_val, buf);
402 RtlSetEnvironmentVariable(&env, &us_name, &us_val);
403 }
404 }
405
406 HeapFree(GetProcessHeap(), 0, token_user);
407 strcpyW(buf, sidW);
408 LocalFree(sidW);
409 }
410
411 if (RegOpenKeyExW(HKEY_USERS, buf, 0, KEY_READ, &hkey) == ERROR_SUCCESS)
412 {
413 if (RegOpenKeyExW(hkey, envW, 0, KEY_READ, &hsubkey) == ERROR_SUCCESS)
414 {
415 set_registry_variables(&env, hsubkey, REG_SZ, !bInherit);
416 set_registry_variables(&env, hsubkey, REG_EXPAND_SZ, !bInherit);
417 RegCloseKey(hsubkey);
418 }
419
420 if (RegOpenKeyExW(hkey, volatile_envW, 0, KEY_READ, &hsubkey) == ERROR_SUCCESS)
421 {
422 set_registry_variables(&env, hsubkey, REG_SZ, !bInherit);
423 set_registry_variables(&env, hsubkey, REG_EXPAND_SZ, !bInherit);
424 RegCloseKey(hsubkey);
425 }
426 RegCloseKey(hkey);
427 }
428
429 *lpEnvironment = env;
430 return TRUE;
431 }
432
433 BOOL WINAPI DestroyEnvironmentBlock(LPVOID lpEnvironment)
434 {
435 NTSTATUS r;
436
437 TRACE("%p\n", lpEnvironment);
438 r = RtlDestroyEnvironment(lpEnvironment);
439 if (r == STATUS_SUCCESS)
440 return TRUE;
441 return FALSE;
442 }
443
444 BOOL WINAPI ExpandEnvironmentStringsForUserA( HANDLE hToken, LPCSTR lpSrc,
445 LPSTR lpDest, DWORD dwSize )
446 {
447 BOOL ret;
448
449 TRACE("%p %s %p %d\n", hToken, debugstr_a(lpSrc), lpDest, dwSize);
450
451 ret = ExpandEnvironmentStringsA( lpSrc, lpDest, dwSize );
452 TRACE("<- %s\n", debugstr_a(lpDest));
453 return ret;
454 }
455
456 BOOL WINAPI ExpandEnvironmentStringsForUserW( HANDLE hToken, LPCWSTR lpSrc,
457 LPWSTR lpDest, DWORD dwSize )
458 {
459 BOOL ret;
460
461 TRACE("%p %s %p %d\n", hToken, debugstr_w(lpSrc), lpDest, dwSize);
462
463 ret = ExpandEnvironmentStringsW( lpSrc, lpDest, dwSize );
464 TRACE("<- %s\n", debugstr_w(lpDest));
465 return ret;
466 }
467
468 BOOL WINAPI GetDefaultUserProfileDirectoryA( LPSTR lpProfileDir, LPDWORD lpcchSize )
469 {
470 FIXME("%p %p\n", lpProfileDir, lpcchSize );
471 return FALSE;
472 }
473
474 BOOL WINAPI GetDefaultUserProfileDirectoryW( LPWSTR lpProfileDir, LPDWORD lpcchSize )
475 {
476 FIXME("%p %p\n", lpProfileDir, lpcchSize );
477 return FALSE;
478 }
479
480 BOOL WINAPI GetUserProfileDirectoryA( HANDLE hToken, LPSTR lpProfileDir,
481 LPDWORD lpcchSize )
482 {
483 BOOL ret;
484 WCHAR *dirW = NULL;
485
486 TRACE( "%p %p %p\n", hToken, lpProfileDir, lpcchSize );
487
488 if (!lpProfileDir || !lpcchSize)
489 {
490 SetLastError( ERROR_INVALID_PARAMETER );
491 return FALSE;
492 }
493 if (!(dirW = HeapAlloc( GetProcessHeap(), 0, *lpcchSize * sizeof(WCHAR) )))
494 return FALSE;
495
496 if ((ret = GetUserProfileDirectoryW( hToken, dirW, lpcchSize )))
497 WideCharToMultiByte( CP_ACP, 0, dirW, *lpcchSize, lpProfileDir, *lpcchSize, NULL, NULL );
498
499 HeapFree( GetProcessHeap(), 0, dirW );
500 return ret;
501 }
502
503 BOOL WINAPI GetUserProfileDirectoryW( HANDLE hToken, LPWSTR lpProfileDir,
504 LPDWORD lpcchSize )
505 {
506 static const WCHAR slashW[] = {'\\',0};
507 TOKEN_USER *t;
508 WCHAR *userW = NULL, *dirW = NULL;
509 DWORD len, dir_len, domain_len;
510 SID_NAME_USE use;
511 BOOL ret = FALSE;
512
513 TRACE( "%p %p %p\n", hToken, lpProfileDir, lpcchSize );
514
515 if (!lpcchSize)
516 {
517 SetLastError( ERROR_INVALID_PARAMETER );
518 return FALSE;
519 }
520
521 len = 0;
522 GetTokenInformation( hToken, TokenUser, NULL, 0, &len );
523 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return FALSE;
524 if (!(t = HeapAlloc( GetProcessHeap(), 0, len ))) return FALSE;
525 if (!GetTokenInformation( hToken, TokenUser, t, len, &len )) goto done;
526
527 len = domain_len = 0;
528 LookupAccountSidW( NULL, t->User.Sid, NULL, &len, NULL, &domain_len, NULL );
529 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) goto done;
530 if (!(userW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) goto done;
531 if (!LookupAccountSidW( NULL, t->User.Sid, userW, &len, NULL, &domain_len, &use )) goto done;
532
533 dir_len = 0;
534 GetProfilesDirectoryW( NULL, &dir_len );
535 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) goto done;
536 if (!(dirW = HeapAlloc( GetProcessHeap(), 0, (dir_len + 1) * sizeof(WCHAR) ))) goto done;
537 if (!GetProfilesDirectoryW( dirW, &dir_len )) goto done;
538
539 len += dir_len + 2;
540 if (*lpcchSize < len)
541 {
542 SetLastError( ERROR_INSUFFICIENT_BUFFER );
543 *lpcchSize = len;
544 goto done;
545 }
546 strcpyW( lpProfileDir, dirW );
547 strcatW( lpProfileDir, slashW );
548 strcatW( lpProfileDir, userW );
549 *lpcchSize = len;
550 ret = TRUE;
551
552 done:
553 HeapFree( GetProcessHeap(), 0, t );
554 HeapFree( GetProcessHeap(), 0, userW );
555 HeapFree( GetProcessHeap(), 0, dirW );
556 return ret;
557 }
558
559 static const char ProfileListA[] = "Software\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList";
560
561 BOOL WINAPI GetProfilesDirectoryA( LPSTR lpProfilesDir, LPDWORD lpcchSize )
562 {
563 static const char ProfilesDirectory[] = "ProfilesDirectory";
564 LONG l;
565 HKEY key;
566 BOOL ret = FALSE;
567 DWORD len = 0, expanded_len;
568 LPSTR unexpanded_profiles_dir = NULL;
569
570 TRACE("%p %p\n", lpProfilesDir, lpcchSize );
571
572 if (!lpProfilesDir || !lpcchSize)
573 {
574 SetLastError(ERROR_INVALID_PARAMETER);
575 return FALSE;
576 }
577
578 l = RegOpenKeyExA(HKEY_LOCAL_MACHINE, ProfileListA, 0, KEY_READ, &key);
579 if (l)
580 {
581 SetLastError(l);
582 return FALSE;
583 }
584 l = RegQueryValueExA(key, ProfilesDirectory, NULL, NULL, NULL, &len);
585 if (l)
586 {
587 SetLastError(l);
588 goto end;
589 }
590 unexpanded_profiles_dir = HeapAlloc(GetProcessHeap(), 0, len);
591 if (!unexpanded_profiles_dir)
592 {
593 SetLastError(ERROR_OUTOFMEMORY);
594 goto end;
595 }
596 l = RegQueryValueExA(key, ProfilesDirectory, NULL, NULL,
597 (BYTE *)unexpanded_profiles_dir, &len);
598 if (l)
599 {
600 SetLastError(l);
601 goto end;
602 }
603 expanded_len = ExpandEnvironmentStringsA(unexpanded_profiles_dir, NULL, 0);
604 /* The returned length doesn't include the NULL terminator. */
605 if (*lpcchSize < expanded_len - 1)
606 {
607 *lpcchSize = expanded_len - 1;
608 SetLastError(ERROR_INSUFFICIENT_BUFFER);
609 goto end;
610 }
611 *lpcchSize = expanded_len - 1;
612 /* The return value is also the expected length. */
613 ret = ExpandEnvironmentStringsA(unexpanded_profiles_dir, lpProfilesDir,
614 expanded_len) - 1;
615 end:
616 HeapFree(GetProcessHeap(), 0, unexpanded_profiles_dir);
617 RegCloseKey(key);
618 return ret;
619 }
620
621 static const WCHAR ProfileListW[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','P','r','o','f','i','l','e','L','i','s','t',0};
622
623 BOOL WINAPI GetProfilesDirectoryW( LPWSTR lpProfilesDir, LPDWORD lpcchSize )
624 {
625 static const WCHAR ProfilesDirectory[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
626 LONG l;
627 HKEY key;
628 BOOL ret = FALSE;
629 DWORD len = 0, expanded_len;
630 LPWSTR unexpanded_profiles_dir = NULL;
631
632 TRACE("%p %p\n", lpProfilesDir, lpcchSize );
633
634 if (!lpcchSize)
635 {
636 SetLastError(ERROR_INVALID_PARAMETER);
637 return FALSE;
638 }
639
640 l = RegOpenKeyExW(HKEY_LOCAL_MACHINE, ProfileListW, 0, KEY_READ, &key);
641 if (l)
642 {
643 SetLastError(l);
644 return FALSE;
645 }
646 l = RegQueryValueExW(key, ProfilesDirectory, NULL, NULL, NULL, &len);
647 if (l)
648 {
649 SetLastError(l);
650 goto end;
651 }
652 unexpanded_profiles_dir = HeapAlloc(GetProcessHeap(), 0, len);
653 if (!unexpanded_profiles_dir)
654 {
655 SetLastError(ERROR_OUTOFMEMORY);
656 goto end;
657 }
658 l = RegQueryValueExW(key, ProfilesDirectory, NULL, NULL,
659 (BYTE *)unexpanded_profiles_dir, &len);
660 if (l)
661 {
662 SetLastError(l);
663 goto end;
664 }
665 expanded_len = ExpandEnvironmentStringsW(unexpanded_profiles_dir, NULL, 0);
666 /* The returned length doesn't include the NULL terminator. */
667 if (*lpcchSize < expanded_len - 1 || !lpProfilesDir)
668 {
669 *lpcchSize = expanded_len - 1;
670 SetLastError(ERROR_INSUFFICIENT_BUFFER);
671 goto end;
672 }
673 *lpcchSize = expanded_len - 1;
674 /* The return value is also the expected length. */
675 ret = ExpandEnvironmentStringsW(unexpanded_profiles_dir, lpProfilesDir,
676 expanded_len) - 1;
677 end:
678 HeapFree(GetProcessHeap(), 0, unexpanded_profiles_dir);
679 RegCloseKey(key);
680 return ret;
681 }
682
683 BOOL WINAPI GetAllUsersProfileDirectoryA( LPSTR lpProfileDir, LPDWORD lpcchSize )
684 {
685 FIXME("%p %p\n", lpProfileDir, lpcchSize);
686 return FALSE;
687 }
688
689 BOOL WINAPI GetAllUsersProfileDirectoryW( LPWSTR lpProfileDir, LPDWORD lpcchSize )
690 {
691 FIXME("%p %p\n", lpProfileDir, lpcchSize);
692 return FALSE;
693 }
694
695 BOOL WINAPI GetProfileType( DWORD *pdwFlags )
696 {
697 FIXME("%p\n", pdwFlags );
698 *pdwFlags = 0;
699 return TRUE;
700 }
701
702 BOOL WINAPI LoadUserProfileA( HANDLE hToken, LPPROFILEINFOA lpProfileInfo )
703 {
704 FIXME("%p %p\n", hToken, lpProfileInfo );
705 lpProfileInfo->hProfile = HKEY_CURRENT_USER;
706 return TRUE;
707 }
708
709 BOOL WINAPI LoadUserProfileW( HANDLE hToken, LPPROFILEINFOW lpProfileInfo )
710 {
711 FIXME("%p %p\n", hToken, lpProfileInfo );
712 lpProfileInfo->hProfile = HKEY_CURRENT_USER;
713 return TRUE;
714 }
715
716 BOOL WINAPI RegisterGPNotification( HANDLE event, BOOL machine )
717 {
718 FIXME("%p %d\n", event, machine );
719 return TRUE;
720 }
721
722 BOOL WINAPI UnregisterGPNotification( HANDLE event )
723 {
724 FIXME("%p\n", event );
725 return TRUE;
726 }
727
728 BOOL WINAPI UnloadUserProfile( HANDLE hToken, HANDLE hProfile )
729 {
730 FIXME("(%p, %p): stub\n", hToken, hProfile);
731 return FALSE;
732 }
733
734 HANDLE WINAPI EnterCriticalPolicySection(BOOL bMachine)
735 {
736 FIXME("(%x)\n", bMachine);
737 SetLastError(ERROR_ACCESS_DENIED);
738 return NULL;
739 }
740
741 BOOL WINAPI LeaveCriticalPolicySection(HANDLE hSection)
742 {
743 FIXME("(%p)\n", hSection);
744 return TRUE;
745 }
746
747 DWORD WINAPI GetAppliedGPOListW(DWORD dwFlags, LPCWSTR pMachineName, PSID pSidUser, GUID *pGuidExtension,
748 PGROUP_POLICY_OBJECTW *ppGPOList)
749 {
750 FIXME("(%x %s %p %s %p)\n", dwFlags, debugstr_w(pMachineName), pSidUser, debugstr_guid(pGuidExtension), ppGPOList);
751 return ERROR_ACCESS_DENIED;
752 }
753
754 /******************************************************************************
755 * USERENV.138
756 *
757 * Create .lnk file
758 *
759 * PARAMETERS
760 * int csidl [in] well-known directory location to create link in
761 * LPCSTR lnk_dir [in] directory (relative to directory specified by csidl) to create link in
762 * LPCSTR lnk_filename [in] filename of the link file without .lnk extension
763 * LPCSTR lnk_target [in] file/directory pointed to by link
764 * LPCSTR lnk_iconfile [in] link icon resource filename
765 * DWORD lnk_iconid [in] link icon resource id in file referred by lnk_iconfile
766 * LPCSTR work_directory [in] link target's work directory
767 * WORD hotkey [in] link hotkey (virtual key id)
768 * DWORD win_state [in] initial window size (SW_SHOWMAXIMIZED to start maximized,
769 * SW_SHOWMINNOACTIVE to start minimized, everything else is default state)
770 * LPCSTR comment [in] comment - link's comment
771 * LPCSTR loc_filename_resfile [in] resource file which holds localized filename for this link file
772 * DWORD loc_filename_resid [in] resource id for this link file's localized filename
773 *
774 * RETURNS
775 * TRUE: Link file was successfully created
776 * FALSE: Link file was not created
777 */
778 BOOL WINAPI USERENV_138( int csidl, LPCSTR lnk_dir, LPCSTR lnk_filename,
779 LPCSTR lnk_target, LPCSTR lnk_iconfile, DWORD lnk_iconid,
780 LPCSTR work_directory, WORD hotkey, DWORD win_state, LPCSTR comment,
781 LPCSTR loc_filename_resfile, DWORD loc_filename_resid)
782 {
783 FIXME("(%d,%s,%s,%s,%s,%d,%s,0x%x,%d,%s,%s,%d) - stub\n", csidl, debugstr_a(lnk_dir),
784 debugstr_a(lnk_filename), debugstr_a(lnk_target), debugstr_a(lnk_iconfile),
785 lnk_iconid, debugstr_a(work_directory), hotkey, win_state,
786 debugstr_a(comment), debugstr_a(loc_filename_resfile), loc_filename_resid );
787
788 return FALSE;
789 }
Windows API implementation