dlls/userenv/userenv_main.c

   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
  36 WINE_DEFAULT_DEBUG_CHANNEL( userenv );
  37
  38 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  39 {
  40     TRACE("%p %d %p\n", hinstDLL, fdwReason, lpvReserved);
  41
  42     switch (fdwReason)
  43     {
  44     case DLL_WINE_PREATTACH:
  45         return FALSE;  /* prefer native version */
  46     case DLL_PROCESS_ATTACH:
  47         DisableThreadLibraryCalls(hinstDLL);
  48         break;
  49     }
  50     return TRUE;
  51 }
  52
  53 static BOOL get_reg_value(WCHAR *env, HKEY hkey, const WCHAR *name, WCHAR *val, DWORD size)
  54 {
  55     DWORD type, res_size=0;
  56
  57     if (RegQueryValueExW(hkey, name, 0, &type, NULL, &res_size) != ERROR_SUCCESS)
  58         return FALSE;
  59
  60     if (type == REG_SZ)
  61     {
  62         if (res_size > size)
  63             return FALSE;
  64
  65         return RegQueryValueExW(hkey, name, 0, NULL, (BYTE*)val, &size) == ERROR_SUCCESS;
  66     }
  67     else if (type == REG_EXPAND_SZ)
  68     {
  69         UNICODE_STRING us_buf, us_expanded;
  70         WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, res_size);
  71         if (!buf)
  72             return FALSE;
  73
  74         if (RegQueryValueExW(hkey, name, 0, NULL, (BYTE*)buf, &res_size) != ERROR_SUCCESS)
  75         {
  76             HeapFree(GetProcessHeap(), 0, buf);
  77             return FALSE;
  78         }
  79
  80         RtlInitUnicodeString(&us_buf, buf);
  81         us_expanded.Buffer = val;
  82         us_expanded.MaximumLength = size;
  83         if (RtlExpandEnvironmentStrings_U(env, &us_buf, &us_expanded, &size) != STATUS_SUCCESS)
  84         {
  85             HeapFree(GetProcessHeap(), 0, buf);
  86             return FALSE;
  87         }
  88
  89         HeapFree(GetProcessHeap(), 0, buf);
  90         return TRUE;
  91     }
  92
  93     return FALSE;
  94 }
  95
  96 static void set_env_var( WCHAR **env, const WCHAR *name, const WCHAR *val )
  97 {
  98     UNICODE_STRING nameW, valW;
  99
 100     RtlInitUnicodeString( &nameW, name );
 101     RtlInitUnicodeString( &valW, val );
 102     RtlSetEnvironmentVariable( env, &nameW, &valW );
 103 }
 104
 105 static void set_registry_variables(WCHAR **env, HKEY hkey, DWORD type, BOOL set_path)
 106 {
 107     UNICODE_STRING us_name, us_value;
 108     WCHAR name[1024], value[1024];
 109     DWORD ret, index, size;
 110
 111     for (index = 0; ; index++)
 112     {
 113         size = ARRAY_SIZE(name);
 114         ret = RegEnumValueW(hkey, index, name, &size, NULL, NULL, NULL, NULL);
 115         if (ret != ERROR_SUCCESS)
 116             break;
 117
 118         if (!wcsicmp(name, L"SystemRoot")) continue;
 119         if (!wcsicmp(name, L"SystemDrive")) continue;
 120
 121         RtlInitUnicodeString(&us_name, name);
 122         us_value.Buffer = value;
 123         us_value.MaximumLength = sizeof(value);
 124         if (!wcsicmp(name, L"PATH") &&
 125                 !RtlQueryEnvironmentVariable_U(*env, &us_name, &us_value))
 126         {
 127             if (!set_path)
 128                 continue;
 129
 130             size = lstrlenW(value)+1;
 131             if (!get_reg_value(*env, hkey, name, value+size,
 132                         sizeof(value)-size*sizeof(WCHAR)))
 133                 continue;
 134
 135             value[size] = ';';
 136             set_env_var(env, name, value);
 137             continue;
 138         }
 139
 140         if (get_reg_value(*env, hkey, name, value, sizeof(value)) && value[0])
 141             set_env_var(env, name, value);
 142     }
 143 }
 144
 145 static void set_wow64_environment(WCHAR **env)
 146 {
 147     WCHAR buf[64];
 148     HKEY hkey;
 149     BOOL is_win64 = (sizeof(void *) > sizeof(int));
 150     BOOL is_wow64;
 151
 152     IsWow64Process( GetCurrentProcess(), &is_wow64 );
 153
 154     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion",
 155             0, KEY_READ|KEY_WOW64_64KEY, &hkey))
 156         return;
 157
 158     /* set the ProgramFiles variables */
 159
 160     if (get_reg_value(*env, hkey, L"ProgramFilesDir", buf, sizeof(buf)))
 161     {
 162         if (is_win64 || is_wow64) set_env_var(env, L"ProgramW6432", buf);
 163         if (is_win64 || !is_wow64) set_env_var(env, L"ProgramFiles", buf);
 164     }
 165     if (get_reg_value(*env, hkey, L"ProgramFilesDir (x86)", buf, sizeof(buf)))
 166     {
 167         if (is_win64 || is_wow64) set_env_var(env, L"ProgramFiles(x86)", buf);
 168         if (is_wow64) set_env_var(env, L"ProgramFiles", buf);
 169     }
 170
 171     /* set the CommonProgramFiles variables */
 172
 173     if (get_reg_value(*env, hkey, L"CommonFilesDir", buf, sizeof(buf)))
 174     {
 175         if (is_win64 || is_wow64) set_env_var(env, L"CommonProgramW6432", buf);
 176         if (is_win64 || !is_wow64) set_env_var(env, L"CommonProgramFiles", buf);
 177     }
 178     if (get_reg_value(*env, hkey, L"CommonFilesDir (x86)", buf, sizeof(buf)))
 179     {
 180         if (is_win64 || is_wow64) set_env_var(env, L"CommonProgramFiles(x86)", buf);
 181         if (is_wow64) set_env_var(env, L"CommonProgramFiles", buf);
 182     }
 183
 184     RegCloseKey(hkey);
 185 }
 186
 187 BOOL WINAPI CreateEnvironmentBlock( LPVOID* lpEnvironment,
 188                      HANDLE hToken, BOOL bInherit )
 189 {
 190     static const WCHAR env_keyW[] = L"System\\CurrentControlSet\\Control\\Session Manager\\Environment";
 191     static const WCHAR profile_keyW[] = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList";
 192
 193     WCHAR *env, buf[UNICODE_STRING_MAX_CHARS], profiles_dir[MAX_PATH];
 194     DWORD len;
 195     HKEY hkey, hsubkey;
 196
 197     TRACE("%p %p %d\n", lpEnvironment, hToken, bInherit );
 198
 199     if (!lpEnvironment)
 200         return FALSE;
 201
 202     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, env_keyW, 0, KEY_READ, &hkey) != ERROR_SUCCESS)
 203         return FALSE;
 204
 205     if (RtlCreateEnvironment(bInherit, &env) != STATUS_SUCCESS)
 206     {
 207         RegCloseKey(hkey);
 208         return FALSE;
 209     }
 210
 211     if (!GetEnvironmentVariableW(L"SystemRoot", buf, UNICODE_STRING_MAX_CHARS))
 212     {
 213         if (!get_reg_value(env, hkey, L"SystemRoot", buf, UNICODE_STRING_MAX_CHARS))
 214         {
 215             buf[0] = 0;
 216             WARN("SystemRoot variable not set\n");
 217         }
 218     }
 219     set_env_var(&env, L"SystemRoot", buf);
 220
 221     if (!GetEnvironmentVariableW(L"SystemDrive", buf, UNICODE_STRING_MAX_CHARS))
 222     {
 223         if (!get_reg_value(env, hkey, L"SystemDrive", buf, UNICODE_STRING_MAX_CHARS))
 224         {
 225             buf[0] = 0;
 226             WARN("SystemDrive variable not set\n");
 227         }
 228     }
 229     set_env_var(&env, L"SystemDrive", buf);
 230
 231     set_registry_variables(&env, hkey, REG_SZ, !bInherit);
 232     set_registry_variables(&env, hkey, REG_EXPAND_SZ, !bInherit);
 233
 234     if (RegOpenKeyExW(hkey, L"Environment", 0, KEY_READ, &hsubkey) == ERROR_SUCCESS)
 235     {
 236         set_registry_variables(&env, hsubkey, REG_SZ, !bInherit);
 237         set_registry_variables(&env, hsubkey, REG_EXPAND_SZ, !bInherit);
 238         RegCloseKey(hsubkey);
 239     }
 240
 241     if (RegOpenKeyExW(hkey, L"Volatile Environment", 0, KEY_READ, &hsubkey) == ERROR_SUCCESS)
 242     {
 243         set_registry_variables(&env, hsubkey, REG_SZ, !bInherit);
 244         set_registry_variables(&env, hsubkey, REG_EXPAND_SZ, !bInherit);
 245         RegCloseKey(hsubkey);
 246     }
 247     RegCloseKey(hkey);
 248
 249     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, profile_keyW, 0, KEY_READ, &hkey) == ERROR_SUCCESS)
 250     {
 251         if (get_reg_value(env, hkey, L"ProfilesDirectory", profiles_dir, MAX_PATH - sizeof(WCHAR)))
 252         {
 253             len = lstrlenW(profiles_dir);
 254             if (profiles_dir[len-1] != '\\')
 255             {
 256                 profiles_dir[len++] = '\\';
 257                 profiles_dir[len] = '\0';
 258             }
 259
 260             if (get_reg_value(env, hkey, L"Public", buf, UNICODE_STRING_MAX_CHARS))
 261                 set_env_var(&env, L"ALLUSERSPROFILE", buf);
 262         }
 263         else
 264         {
 265             profiles_dir[0] = 0;
 266         }
 267
 268         RegCloseKey(hkey);
 269     }
 270
 271     len = ARRAY_SIZE(buf);
 272     if (GetComputerNameW(buf, &len))
 273         set_env_var(&env, L"COMPUTERNAME", buf);
 274
 275     set_wow64_environment(&env);
 276
 277     if (!hToken)
 278     {
 279         if (profiles_dir[0])
 280         {
 281             len = lstrlenW(profiles_dir);
 282             if (len * sizeof(WCHAR) + sizeof(L"Default") < sizeof(buf))
 283             {
 284                 wcscpy(buf, profiles_dir);
 285                 wcscat(buf, L"Default");
 286                 set_env_var(&env, L"USERPROFILE", buf);
 287             }
 288         }
 289
 290         wcscpy(buf, L".Default");
 291     }
 292     else
 293     {
 294         TOKEN_USER *token_user = NULL;
 295         SID_NAME_USE use;
 296         WCHAR *sidW;
 297         DWORD size, tmp=0;
 298
 299         if (GetTokenInformation(hToken, TokenUser, NULL, 0, &len) ||
 300                 GetLastError()!=ERROR_INSUFFICIENT_BUFFER ||
 301                 !(token_user = HeapAlloc(GetProcessHeap(), 0, len)) ||
 302                 !GetTokenInformation(hToken, TokenUser, token_user, len, &len) ||
 303                 !ConvertSidToStringSidW(token_user->User.Sid, &sidW))
 304         {
 305             HeapFree(GetProcessHeap(), 0, token_user);
 306             RtlDestroyEnvironment(env);
 307             return FALSE;
 308         }
 309
 310         len = lstrlenW(profiles_dir);
 311         memcpy(buf, profiles_dir, len*sizeof(WCHAR));
 312
 313         size = UNICODE_STRING_MAX_CHARS-len;
 314         if (LookupAccountSidW(NULL, token_user->User.Sid,
 315                     buf+len, &size, NULL, &tmp, &use))
 316         {
 317             set_env_var(&env, L"USERNAME", buf+len);
 318             if (len) set_env_var(&env, L"USERPROFILE", buf);
 319         }
 320
 321         HeapFree(GetProcessHeap(), 0, token_user);
 322         lstrcpyW(buf, sidW);
 323         LocalFree(sidW);
 324     }
 325
 326     if (RegOpenKeyExW(HKEY_USERS, buf, 0, KEY_READ, &hkey) == ERROR_SUCCESS)
 327     {
 328         if (RegOpenKeyExW(hkey, L"Environment", 0, KEY_READ, &hsubkey) == ERROR_SUCCESS)
 329         {
 330             set_registry_variables(&env, hsubkey, REG_SZ, !bInherit);
 331             set_registry_variables(&env, hsubkey, REG_EXPAND_SZ, !bInherit);
 332             RegCloseKey(hsubkey);
 333         }
 334
 335         if (RegOpenKeyExW(hkey, L"Volatile Environment", 0, KEY_READ, &hsubkey) == ERROR_SUCCESS)
 336         {
 337             set_registry_variables(&env, hsubkey, REG_SZ, !bInherit);
 338             set_registry_variables(&env, hsubkey, REG_EXPAND_SZ, !bInherit);
 339             RegCloseKey(hsubkey);
 340         }
 341         RegCloseKey(hkey);
 342     }
 343
 344     *lpEnvironment = env;
 345     return TRUE;
 346 }
 347
 348 BOOL WINAPI DestroyEnvironmentBlock(LPVOID lpEnvironment)
 349 {
 350     NTSTATUS r;
 351
 352     TRACE("%p\n", lpEnvironment);
 353     r = RtlDestroyEnvironment(lpEnvironment);
 354     if (r == STATUS_SUCCESS)
 355         return TRUE;
 356     return FALSE;
 357 }
 358
 359 BOOL WINAPI ExpandEnvironmentStringsForUserA( HANDLE hToken, LPCSTR lpSrc,
 360                      LPSTR lpDest, DWORD dwSize )
 361 {
 362     BOOL ret;
 363
 364     TRACE("%p %s %p %d\n", hToken, debugstr_a(lpSrc), lpDest, dwSize);
 365
 366     ret = ExpandEnvironmentStringsA( lpSrc, lpDest, dwSize );
 367     TRACE("<- %s\n", debugstr_a(lpDest));
 368     return ret;
 369 }
 370
 371 BOOL WINAPI ExpandEnvironmentStringsForUserW( HANDLE hToken, LPCWSTR lpSrc,
 372                      LPWSTR lpDest, DWORD dwSize )
 373 {
 374     BOOL ret;
 375
 376     TRACE("%p %s %p %d\n", hToken, debugstr_w(lpSrc), lpDest, dwSize);
 377
 378     ret = ExpandEnvironmentStringsW( lpSrc, lpDest, dwSize );
 379     TRACE("<- %s\n", debugstr_w(lpDest));
 380     return ret;
 381 }
 382
 383 BOOL WINAPI GetDefaultUserProfileDirectoryA( LPSTR lpProfileDir, LPDWORD lpcchSize )
 384 {
 385     FIXME("%p %p\n", lpProfileDir, lpcchSize );
 386     return FALSE;
 387 }
 388
 389 BOOL WINAPI GetDefaultUserProfileDirectoryW( LPWSTR lpProfileDir, LPDWORD lpcchSize )
 390 {
 391     FIXME("%p %p\n", lpProfileDir, lpcchSize );
 392     return FALSE;
 393 }
 394
 395 BOOL WINAPI GetUserProfileDirectoryA( HANDLE hToken, LPSTR lpProfileDir,
 396                      LPDWORD lpcchSize )
 397 {
 398     BOOL ret;
 399     WCHAR *dirW = NULL;
 400
 401     TRACE( "%p %p %p\n", hToken, lpProfileDir, lpcchSize );
 402
 403     if (!lpProfileDir || !lpcchSize)
 404     {
 405         SetLastError( ERROR_INVALID_PARAMETER );
 406         return FALSE;
 407     }
 408     if (!(dirW = HeapAlloc( GetProcessHeap(), 0, *lpcchSize * sizeof(WCHAR) )))
 409         return FALSE;
 410
 411     if ((ret = GetUserProfileDirectoryW( hToken, dirW, lpcchSize )))
 412         WideCharToMultiByte( CP_ACP, 0, dirW, *lpcchSize, lpProfileDir, *lpcchSize, NULL, NULL );
 413
 414     HeapFree( GetProcessHeap(), 0, dirW );
 415     return ret;
 416 }
 417
 418 BOOL WINAPI GetUserProfileDirectoryW( HANDLE hToken, LPWSTR lpProfileDir,
 419                      LPDWORD lpcchSize )
 420 {
 421     static const WCHAR slashW[] = {'\\',0};
 422     TOKEN_USER *t;
 423     WCHAR *userW = NULL, *dirW = NULL;
 424     DWORD len, dir_len, domain_len;
 425     SID_NAME_USE use;
 426     BOOL ret = FALSE;
 427
 428     TRACE( "%p %p %p\n", hToken, lpProfileDir, lpcchSize );
 429
 430     if (!lpcchSize)
 431     {
 432         SetLastError( ERROR_INVALID_PARAMETER );
 433         return FALSE;
 434     }
 435
 436     len = 0;
 437     GetTokenInformation( hToken, TokenUser, NULL, 0, &len );
 438     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return FALSE;
 439     if (!(t = HeapAlloc( GetProcessHeap(), 0, len ))) return FALSE;
 440     if (!GetTokenInformation( hToken, TokenUser, t, len, &len )) goto done;
 441
 442     len = domain_len = 0;
 443     LookupAccountSidW( NULL, t->User.Sid, NULL, &len, NULL, &domain_len, NULL );
 444     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) goto done;
 445     if (!(userW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) goto done;
 446     if (!LookupAccountSidW( NULL, t->User.Sid, userW, &len, NULL, &domain_len, &use )) goto done;
 447
 448     dir_len = 0;
 449     GetProfilesDirectoryW( NULL, &dir_len );
 450     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) goto done;
 451     if (!(dirW = HeapAlloc( GetProcessHeap(), 0, (dir_len + 1) * sizeof(WCHAR) ))) goto done;
 452     if (!GetProfilesDirectoryW( dirW, &dir_len )) goto done;
 453
 454     len += dir_len + 2;
 455     if (*lpcchSize < len)
 456     {
 457         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 458         *lpcchSize = len;
 459         goto done;
 460     }
 461     lstrcpyW( lpProfileDir, dirW );
 462     lstrcatW( lpProfileDir, slashW );
 463     lstrcatW( lpProfileDir, userW );
 464     *lpcchSize = len;
 465     ret = TRUE;
 466
 467 done:
 468     HeapFree( GetProcessHeap(), 0, t );
 469     HeapFree( GetProcessHeap(), 0, userW );
 470     HeapFree( GetProcessHeap(), 0, dirW );
 471     return ret;
 472 }
 473
 474 static const char ProfileListA[] = "Software\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList";
 475
 476 BOOL WINAPI GetProfilesDirectoryA( LPSTR lpProfilesDir, LPDWORD lpcchSize )
 477 {
 478     static const char ProfilesDirectory[] = "ProfilesDirectory";
 479     LONG l;
 480     HKEY key;
 481     BOOL ret = FALSE;
 482     DWORD len = 0, expanded_len;
 483     LPSTR unexpanded_profiles_dir = NULL;
 484
 485     TRACE("%p %p\n", lpProfilesDir, lpcchSize );
 486
 487     if (!lpProfilesDir || !lpcchSize)
 488     {
 489         SetLastError(ERROR_INVALID_PARAMETER);
 490         return FALSE;
 491     }
 492
 493     l = RegOpenKeyExA(HKEY_LOCAL_MACHINE, ProfileListA, 0, KEY_READ, &key);
 494     if (l)
 495     {
 496         SetLastError(l);
 497         return FALSE;
 498     }
 499     l = RegQueryValueExA(key, ProfilesDirectory, NULL, NULL, NULL, &len);
 500     if (l)
 501     {
 502         SetLastError(l);
 503         goto end;
 504     }
 505     unexpanded_profiles_dir = HeapAlloc(GetProcessHeap(), 0, len);
 506     if (!unexpanded_profiles_dir)
 507     {
 508         SetLastError(ERROR_OUTOFMEMORY);
 509         goto end;
 510     }
 511     l = RegQueryValueExA(key, ProfilesDirectory, NULL, NULL,
 512                              (BYTE *)unexpanded_profiles_dir, &len);
 513     if (l)
 514     {
 515         SetLastError(l);
 516         goto end;
 517     }
 518     expanded_len = ExpandEnvironmentStringsA(unexpanded_profiles_dir, NULL, 0);
 519     /* The returned length doesn't include the NULL terminator. */
 520     if (*lpcchSize < expanded_len - 1)
 521     {
 522         *lpcchSize = expanded_len - 1;
 523         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 524         goto end;
 525     }
 526     *lpcchSize = expanded_len - 1;
 527     /* The return value is also the expected length. */
 528     ret = ExpandEnvironmentStringsA(unexpanded_profiles_dir, lpProfilesDir,
 529                                     expanded_len) - 1;
 530 end:
 531     HeapFree(GetProcessHeap(), 0, unexpanded_profiles_dir);
 532     RegCloseKey(key);
 533     return ret;
 534 }
 535
 536 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};
 537
 538 BOOL WINAPI GetProfilesDirectoryW( LPWSTR lpProfilesDir, LPDWORD lpcchSize )
 539 {
 540     static const WCHAR ProfilesDirectory[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
 541     LONG l;
 542     HKEY key;
 543     BOOL ret = FALSE;
 544     DWORD len = 0, expanded_len;
 545     LPWSTR unexpanded_profiles_dir = NULL;
 546
 547     TRACE("%p %p\n", lpProfilesDir, lpcchSize );
 548
 549     if (!lpcchSize)
 550     {
 551         SetLastError(ERROR_INVALID_PARAMETER);
 552         return FALSE;
 553     }
 554
 555     l = RegOpenKeyExW(HKEY_LOCAL_MACHINE, ProfileListW, 0, KEY_READ, &key);
 556     if (l)
 557     {
 558         SetLastError(l);
 559         return FALSE;
 560     }
 561     l = RegQueryValueExW(key, ProfilesDirectory, NULL, NULL, NULL, &len);
 562     if (l)
 563     {
 564         SetLastError(l);
 565         goto end;
 566     }
 567     unexpanded_profiles_dir = HeapAlloc(GetProcessHeap(), 0, len);
 568     if (!unexpanded_profiles_dir)
 569     {
 570         SetLastError(ERROR_OUTOFMEMORY);
 571         goto end;
 572     }
 573     l = RegQueryValueExW(key, ProfilesDirectory, NULL, NULL,
 574                              (BYTE *)unexpanded_profiles_dir, &len);
 575     if (l)
 576     {
 577         SetLastError(l);
 578         goto end;
 579     }
 580     expanded_len = ExpandEnvironmentStringsW(unexpanded_profiles_dir, NULL, 0);
 581     /* The returned length doesn't include the NULL terminator. */
 582     if (*lpcchSize < expanded_len - 1 || !lpProfilesDir)
 583     {
 584         *lpcchSize = expanded_len - 1;
 585         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 586         goto end;
 587     }
 588     *lpcchSize = expanded_len - 1;
 589     /* The return value is also the expected length. */
 590     ret = ExpandEnvironmentStringsW(unexpanded_profiles_dir, lpProfilesDir,
 591                                     expanded_len) - 1;
 592 end:
 593     HeapFree(GetProcessHeap(), 0, unexpanded_profiles_dir);
 594     RegCloseKey(key);
 595     return ret;
 596 }
 597
 598 BOOL WINAPI GetAllUsersProfileDirectoryA( LPSTR lpProfileDir, LPDWORD lpcchSize )
 599 {
 600     FIXME("%p %p\n", lpProfileDir, lpcchSize);
 601     return FALSE;
 602 }
 603
 604 BOOL WINAPI GetAllUsersProfileDirectoryW( LPWSTR lpProfileDir, LPDWORD lpcchSize )
 605 {
 606     FIXME("%p %p\n", lpProfileDir, lpcchSize);
 607     return FALSE;
 608 }
 609
 610 BOOL WINAPI GetProfileType( DWORD *pdwFlags )
 611 {
 612     FIXME("%p\n", pdwFlags );
 613     *pdwFlags = 0;
 614     return TRUE;
 615 }
 616
 617 BOOL WINAPI LoadUserProfileA( HANDLE hToken, LPPROFILEINFOA lpProfileInfo )
 618 {
 619     FIXME("%p %p\n", hToken, lpProfileInfo );
 620     lpProfileInfo->hProfile = HKEY_CURRENT_USER;
 621     return TRUE;
 622 }
 623
 624 BOOL WINAPI LoadUserProfileW( HANDLE hToken, LPPROFILEINFOW lpProfileInfo )
 625 {
 626     FIXME("%p %p\n", hToken, lpProfileInfo );
 627     lpProfileInfo->hProfile = HKEY_CURRENT_USER;
 628     return TRUE;
 629 }
 630
 631 BOOL WINAPI RegisterGPNotification( HANDLE event, BOOL machine )
 632 {
 633     FIXME("%p %d\n", event, machine );
 634     return TRUE;
 635 }
 636
 637 BOOL WINAPI UnregisterGPNotification( HANDLE event )
 638 {
 639     FIXME("%p\n", event );
 640     return TRUE;
 641 }
 642
 643 BOOL WINAPI UnloadUserProfile( HANDLE hToken, HANDLE hProfile )
 644 {
 645     FIXME("(%p, %p): stub\n", hToken, hProfile);
 646     return FALSE;
 647 }
 648
 649 HANDLE WINAPI EnterCriticalPolicySection(BOOL bMachine)
 650 {
 651     FIXME("(%x)\n", bMachine);
 652     SetLastError(ERROR_ACCESS_DENIED);
 653     return NULL;
 654 }
 655
 656 BOOL WINAPI LeaveCriticalPolicySection(HANDLE hSection)
 657 {
 658     FIXME("(%p)\n", hSection);
 659     return TRUE;
 660 }
 661
 662 DWORD WINAPI GetAppliedGPOListW(DWORD dwFlags, LPCWSTR pMachineName, PSID pSidUser, GUID *pGuidExtension,
 663         PGROUP_POLICY_OBJECTW *ppGPOList)
 664 {
 665     FIXME("(%x %s %p %s %p)\n", dwFlags, debugstr_w(pMachineName), pSidUser, debugstr_guid(pGuidExtension), ppGPOList);
 666     return ERROR_ACCESS_DENIED;
 667 }
 668
 669 /******************************************************************************
 670  *              USERENV.138
 671  *
 672  * Create .lnk file
 673  *
 674  * PARAMETERS
 675  *   int     csidl               [in] well-known directory location to create link in
 676  *   LPCSTR lnk_dir              [in] directory (relative to directory specified by csidl) to create link in
 677  *   LPCSTR lnk_filename         [in] filename of the link file without .lnk extension
 678  *   LPCSTR lnk_target           [in] file/directory pointed to by link
 679  *   LPCSTR lnk_iconfile         [in] link icon resource filename
 680  *   DWORD   lnk_iconid          [in] link icon resource id in file referred by lnk_iconfile
 681  *   LPCSTR work_directory       [in] link target's work directory
 682  *   WORD    hotkey              [in] link hotkey (virtual key id)
 683  *   DWORD   win_state           [in] initial window size (SW_SHOWMAXIMIZED to start maximized,
 684  *                                     SW_SHOWMINNOACTIVE to start minimized, everything else is default state)
 685  *   LPCSTR comment              [in] comment - link's comment
 686  *   LPCSTR loc_filename_resfile [in] resource file which holds localized filename for this link file
 687  *   DWORD   loc_filename_resid  [in] resource id for this link file's localized filename
 688  *
 689  * RETURNS
 690  *    TRUE:  Link file was successfully created
 691  *    FALSE: Link file was not created
 692  */
 693 BOOL WINAPI USERENV_138( int csidl, LPCSTR lnk_dir, LPCSTR lnk_filename,
 694             LPCSTR lnk_target, LPCSTR lnk_iconfile, DWORD lnk_iconid,
 695             LPCSTR work_directory, WORD hotkey, DWORD win_state, LPCSTR comment,
 696             LPCSTR loc_filename_resfile, DWORD loc_filename_resid)
 697 {
 698     FIXME("(%d,%s,%s,%s,%s,%d,%s,0x%x,%d,%s,%s,%d) - stub\n", csidl, debugstr_a(lnk_dir),
 699             debugstr_a(lnk_filename), debugstr_a(lnk_target), debugstr_a(lnk_iconfile),
 700             lnk_iconid, debugstr_a(work_directory), hotkey, win_state,
 701             debugstr_a(comment), debugstr_a(loc_filename_resfile), loc_filename_resid );
 702
 703     return FALSE;
 704 }