reactos/dll/win32/shell32/shellpath.c

   1 /*
   2  * Path Functions
   3  *
   4  * Copyright 1998, 1999, 2000 Juergen Schmied
   5  * Copyright 2004 Juan Lang
   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  * NOTES:
  22  *
  23  * Many of these functions are in SHLWAPI.DLL also
  24  *
  25  */
  26
  27 #include <precomp.h>
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  30
  31 /*
  32         ########## Combining and Constructing paths ##########
  33 */
  34
  35 /*************************************************************************
  36  * PathAppend           [SHELL32.36]
  37  */
  38 BOOL WINAPI PathAppendAW(
  39         LPVOID lpszPath1,
  40         LPCVOID lpszPath2)
  41 {
  42         if (SHELL_OsIsUnicode())
  43           return PathAppendW(lpszPath1, lpszPath2);
  44         return PathAppendA(lpszPath1, lpszPath2);
  45 }
  46
  47 /*************************************************************************
  48  * PathBuildRoot                [SHELL32.30]
  49  */
  50 LPVOID WINAPI PathBuildRootAW(LPVOID lpszPath, int drive)
  51 {
  52         if(SHELL_OsIsUnicode())
  53           return PathBuildRootW(lpszPath, drive);
  54         return PathBuildRootA(lpszPath, drive);
  55 }
  56
  57 /*************************************************************************
  58  * PathGetExtensionA            [internal]
  59  *
  60  * NOTES
  61  *  exported by ordinal
  62  *  return value points to the first char after the dot
  63  */
  64 static LPSTR PathGetExtensionA(LPCSTR lpszPath)
  65 {
  66         TRACE("(%s)\n",lpszPath);
  67
  68         lpszPath = PathFindExtensionA(lpszPath);
  69         return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
  70 }
  71
  72 /*************************************************************************
  73  * PathGetExtensionW            [internal]
  74  */
  75 LPWSTR PathGetExtensionW(LPCWSTR lpszPath)
  76 {
  77         TRACE("(%s)\n",debugstr_w(lpszPath));
  78
  79         lpszPath = PathFindExtensionW(lpszPath);
  80         return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
  81 }
  82
  83 /*************************************************************************
  84  * SHPathGetExtension           [SHELL32.158]
  85  */
  86 LPVOID WINAPI SHPathGetExtensionW(LPCWSTR lpszPath, DWORD void1, DWORD void2)
  87 {
  88         return PathGetExtensionW(lpszPath);
  89 }
  90
  91 /*************************************************************************
  92  * PathRemoveFileSpec [SHELL32.35]
  93  */
  94 BOOL WINAPI PathRemoveFileSpecAW(LPVOID lpszPath)
  95 {
  96         if (SHELL_OsIsUnicode())
  97           return PathRemoveFileSpecW(lpszPath);
  98         return PathRemoveFileSpecA(lpszPath);
  99 }
 100
 101 /*
 102         Path Manipulations
 103 */
 104
 105 /*************************************************************************
 106  * PathGetShortPathA [internal]
 107  */
 108 static void PathGetShortPathA(LPSTR pszPath)
 109 {
 110         CHAR path[MAX_PATH];
 111
 112         TRACE("%s\n", pszPath);
 113
 114         if (GetShortPathNameA(pszPath, path, MAX_PATH))
 115         {
 116           lstrcpyA(pszPath, path);
 117         }
 118 }
 119
 120 /*************************************************************************
 121  * PathGetShortPathW [internal]
 122  */
 123 static void PathGetShortPathW(LPWSTR pszPath)
 124 {
 125         WCHAR path[MAX_PATH];
 126
 127         TRACE("%s\n", debugstr_w(pszPath));
 128
 129         if (GetShortPathNameW(pszPath, path, MAX_PATH))
 130         {
 131           wcscpy(pszPath, path);
 132         }
 133 }
 134
 135 /*************************************************************************
 136  * PathGetShortPath [SHELL32.92]
 137  */
 138 VOID WINAPI PathGetShortPathAW(LPVOID pszPath)
 139 {
 140         if(SHELL_OsIsUnicode())
 141           PathGetShortPathW(pszPath);
 142         PathGetShortPathA(pszPath);
 143 }
 144
 145 /*
 146         ########## Path Testing ##########
 147 */
 148
 149 /*************************************************************************
 150  * PathIsRoot           [SHELL32.29]
 151  */
 152 BOOL WINAPI PathIsRootAW(LPCVOID lpszPath)
 153 {
 154         if (SHELL_OsIsUnicode())
 155           return PathIsRootW(lpszPath);
 156         return PathIsRootA(lpszPath);
 157 }
 158
 159 /*************************************************************************
 160  *  PathIsExeA          [internal]
 161  */
 162 static BOOL PathIsExeA (LPCSTR lpszPath)
 163 {
 164         LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
 165         int i;
 166         static const char * const lpszExtensions[] =
 167             {"exe", "com", "pif", "cmd", "bat", "scf", "scr", NULL };
 168
 169         TRACE("path=%s\n",lpszPath);
 170
 171         for(i=0; lpszExtensions[i]; i++)
 172           if (!lstrcmpiA(lpszExtension,lpszExtensions[i])) return TRUE;
 173
 174         return FALSE;
 175 }
 176
 177 /*************************************************************************
 178  *  PathIsExeW          [internal]
 179  */
 180 static BOOL PathIsExeW (LPCWSTR lpszPath)
 181 {
 182         LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
 183         int i;
 184         static const WCHAR lpszExtensions[][4] =
 185             {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','f','\0'},
 186              {'c','m','d','\0'}, {'b','a','t','\0'}, {'s','c','f','\0'},
 187              {'s','c','r','\0'}, {'\0'} };
 188
 189         TRACE("path=%s\n",debugstr_w(lpszPath));
 190
 191         for(i=0; lpszExtensions[i][0]; i++)
 192           if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
 193
 194         return FALSE;
 195 }
 196
 197 /*************************************************************************
 198  *  PathIsExe           [SHELL32.43]
 199  */
 200 BOOL WINAPI PathIsExeAW (LPCVOID path)
 201 {
 202         if (SHELL_OsIsUnicode())
 203           return PathIsExeW (path);
 204         return PathIsExeA(path);
 205 }
 206
 207 /*************************************************************************
 208  * PathFileExists       [SHELL32.45]
 209  */
 210 BOOL WINAPI PathFileExistsAW (LPCVOID lpszPath)
 211 {
 212         if (SHELL_OsIsUnicode())
 213           return PathFileExistsW (lpszPath);
 214         return PathFileExistsA (lpszPath);
 215 }
 216
 217 /*************************************************************************
 218  * PathIsSameRoot       [SHELL32.650]
 219  */
 220 BOOL WINAPI PathIsSameRootAW(LPCVOID lpszPath1, LPCVOID lpszPath2)
 221 {
 222         if (SHELL_OsIsUnicode())
 223           return PathIsSameRootW(lpszPath1, lpszPath2);
 224         return PathIsSameRootA(lpszPath1, lpszPath2);
 225 }
 226
 227 /*************************************************************************
 228  * IsLFNDriveA          [SHELL32.41]
 229  */
 230 BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath)
 231 {
 232     DWORD       fnlen;
 233
 234     if (!GetVolumeInformationA(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
 235         return FALSE;
 236     return fnlen > 12;
 237 }
 238
 239 /*************************************************************************
 240  * IsLFNDriveW          [SHELL32.42]
 241  */
 242 BOOL WINAPI IsLFNDriveW(LPCWSTR lpszPath)
 243 {
 244     DWORD       fnlen;
 245
 246     if (!GetVolumeInformationW(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
 247         return FALSE;
 248     return fnlen > 12;
 249 }
 250
 251 /*************************************************************************
 252  * IsLFNDrive           [SHELL32.119]
 253  */
 254 BOOL WINAPI IsLFNDriveAW(LPCVOID lpszPath)
 255 {
 256         if (SHELL_OsIsUnicode())
 257           return IsLFNDriveW(lpszPath);
 258         return IsLFNDriveA(lpszPath);
 259 }
 260
 261 /*
 262         ########## Creating Something Unique ##########
 263 */
 264 /*************************************************************************
 265  * PathMakeUniqueNameA  [internal]
 266  */
 267 BOOL WINAPI PathMakeUniqueNameA(
 268         LPSTR lpszBuffer,
 269         DWORD dwBuffSize,
 270         LPCSTR lpszShortName,
 271         LPCSTR lpszLongName,
 272         LPCSTR lpszPathName)
 273 {
 274         FIXME("%p %u %s %s %s stub\n",
 275          lpszBuffer, dwBuffSize, debugstr_a(lpszShortName),
 276          debugstr_a(lpszLongName), debugstr_a(lpszPathName));
 277         return TRUE;
 278 }
 279
 280 /*************************************************************************
 281  * PathMakeUniqueNameW  [internal]
 282  */
 283 BOOL WINAPI PathMakeUniqueNameW(
 284         LPWSTR lpszBuffer,
 285         DWORD dwBuffSize,
 286         LPCWSTR lpszShortName,
 287         LPCWSTR lpszLongName,
 288         LPCWSTR lpszPathName)
 289 {
 290         FIXME("%p %u %s %s %s stub\n",
 291          lpszBuffer, dwBuffSize, debugstr_w(lpszShortName),
 292          debugstr_w(lpszLongName), debugstr_w(lpszPathName));
 293         return TRUE;
 294 }
 295
 296 /*************************************************************************
 297  * PathMakeUniqueName   [SHELL32.47]
 298  */
 299 BOOL WINAPI PathMakeUniqueNameAW(
 300         LPVOID lpszBuffer,
 301         DWORD dwBuffSize,
 302         LPCVOID lpszShortName,
 303         LPCVOID lpszLongName,
 304         LPCVOID lpszPathName)
 305 {
 306         if (SHELL_OsIsUnicode())
 307           return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
 308         return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
 309 }
 310
 311 /*************************************************************************
 312  * PathYetAnotherMakeUniqueName [SHELL32.75]
 313  *
 314  * NOTES
 315  *     exported by ordinal
 316  */
 317 BOOL WINAPI PathYetAnotherMakeUniqueName(
 318         LPWSTR lpszBuffer,
 319         LPCWSTR lpszPathName,
 320         LPCWSTR lpszShortName,
 321         LPCWSTR lpszLongName)
 322 {
 323     FIXME("(%p, %s, %s ,%s):stub.\n",
 324           lpszBuffer, debugstr_w(lpszPathName), debugstr_w(lpszShortName), debugstr_w(lpszLongName));
 325     return TRUE;
 326 }
 327
 328
 329 /*
 330         ########## cleaning and resolving paths ##########
 331  */
 332
 333 /*************************************************************************
 334  * PathCleanupSpec      [SHELL32.171]
 335  *
 336  * lpszFile is changed in place.
 337  */
 338 int WINAPI PathCleanupSpec( LPCWSTR lpszPathW, LPWSTR lpszFileW )
 339 {
 340     int i = 0;
 341     DWORD rc = 0;
 342     int length = 0;
 343
 344     if (SHELL_OsIsUnicode())
 345     {
 346         LPWSTR p = lpszFileW;
 347
 348         TRACE("Cleanup %s\n",debugstr_w(lpszFileW));
 349
 350         if (lpszPathW)
 351             length = wcslen(lpszPathW);
 352
 353         while (*p)
 354         {
 355             int gct = PathGetCharTypeW(*p);
 356             if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
 357             {
 358                 lpszFileW[i]='-';
 359                 rc |= PCS_REPLACEDCHAR;
 360             }
 361             else
 362                 lpszFileW[i]=*p;
 363             i++;
 364             p++;
 365             if (length + i == MAX_PATH)
 366             {
 367                 rc |= PCS_FATAL | PCS_PATHTOOLONG;
 368                 break;
 369             }
 370         }
 371         lpszFileW[i]=0;
 372     }
 373     else
 374     {
 375         LPSTR lpszFileA = (LPSTR)lpszFileW;
 376         LPCSTR lpszPathA = (LPCSTR)lpszPathW;
 377         LPSTR p = lpszFileA;
 378
 379         TRACE("Cleanup %s\n",debugstr_a(lpszFileA));
 380
 381         if (lpszPathA)
 382             length = strlen(lpszPathA);
 383
 384         while (*p)
 385         {
 386             int gct = PathGetCharTypeA(*p);
 387             if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
 388             {
 389                 lpszFileA[i]='-';
 390                 rc |= PCS_REPLACEDCHAR;
 391             }
 392             else
 393                 lpszFileA[i]=*p;
 394             i++;
 395             p++;
 396             if (length + i == MAX_PATH)
 397             {
 398                 rc |= PCS_FATAL | PCS_PATHTOOLONG;
 399                 break;
 400             }
 401         }
 402         lpszFileA[i]=0;
 403     }
 404     return rc;
 405 }
 406
 407 /*************************************************************************
 408  * PathQualifyA         [SHELL32]
 409  */
 410 BOOL WINAPI PathQualifyA(LPCSTR pszPath)
 411 {
 412         FIXME("%s\n",pszPath);
 413         return 0;
 414 }
 415
 416 /*************************************************************************
 417  * PathQualifyW         [SHELL32]
 418  */
 419 BOOL WINAPI PathQualifyW(LPCWSTR pszPath)
 420 {
 421         FIXME("%s\n",debugstr_w(pszPath));
 422         return 0;
 423 }
 424
 425 /*************************************************************************
 426  * PathQualify  [SHELL32.49]
 427  */
 428 BOOL WINAPI PathQualifyAW(LPCVOID pszPath)
 429 {
 430         if (SHELL_OsIsUnicode())
 431           return PathQualifyW(pszPath);
 432         return PathQualifyA(pszPath);
 433 }
 434
 435 /*************************************************************************
 436  * PathResolveA [SHELL32.51]
 437  */
 438 BOOL WINAPI PathResolveA(
 439         LPSTR lpszPath,
 440         LPCSTR *alpszPaths,
 441         DWORD dwFlags)
 442 {
 443         FIXME("(%s,%p,0x%08x),stub!\n",
 444           lpszPath, *alpszPaths, dwFlags);
 445         return 0;
 446 }
 447
 448 /*************************************************************************
 449  * PathResolveW [SHELL32]
 450  */
 451 BOOL WINAPI PathResolveW(
 452         LPWSTR lpszPath,
 453         LPCWSTR *alpszPaths,
 454         DWORD dwFlags)
 455 {
 456         FIXME("(%s,%p,0x%08x),stub!\n",
 457           debugstr_w(lpszPath), debugstr_w(*alpszPaths), dwFlags);
 458         return 0;
 459 }
 460
 461 /*************************************************************************
 462  * PathResolve [SHELL32.51]
 463  */
 464 BOOL WINAPI PathResolveAW(
 465         LPVOID lpszPath,
 466         LPCVOID *alpszPaths,
 467         DWORD dwFlags)
 468 {
 469         if (SHELL_OsIsUnicode())
 470           return PathResolveW(lpszPath, (LPCWSTR*)alpszPaths, dwFlags);
 471         return PathResolveA(lpszPath, (LPCSTR*)alpszPaths, dwFlags);
 472 }
 473
 474 /*************************************************************************
 475 *       PathProcessCommandA     [SHELL32.653]
 476 */
 477 LONG WINAPI PathProcessCommandA (
 478         LPCSTR lpszPath,
 479         LPSTR lpszBuff,
 480         DWORD dwBuffSize,
 481         DWORD dwFlags)
 482 {
 483         FIXME("%s %p 0x%04x 0x%04x stub\n",
 484         lpszPath, lpszBuff, dwBuffSize, dwFlags);
 485         if(!lpszPath) return -1;
 486         if(lpszBuff) strcpy(lpszBuff, lpszPath);
 487         return strlen(lpszPath);
 488 }
 489
 490 /*************************************************************************
 491 *       PathProcessCommandW
 492 */
 493 LONG WINAPI PathProcessCommandW (
 494         LPCWSTR lpszPath,
 495         LPWSTR lpszBuff,
 496         DWORD dwBuffSize,
 497         DWORD dwFlags)
 498 {
 499         FIXME("(%s, %p, 0x%04x, 0x%04x) stub\n",
 500         debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
 501         if(!lpszPath) return -1;
 502         if(lpszBuff) wcscpy(lpszBuff, lpszPath);
 503         return wcslen(lpszPath);
 504 }
 505
 506 /*************************************************************************
 507 *       PathProcessCommand (SHELL32.653)
 508 */
 509 LONG WINAPI PathProcessCommandAW (
 510         LPCVOID lpszPath,
 511         LPVOID lpszBuff,
 512         DWORD dwBuffSize,
 513         DWORD dwFlags)
 514 {
 515         if (SHELL_OsIsUnicode())
 516           return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
 517         return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
 518 }
 519
 520 /*
 521         ########## special ##########
 522 */
 523
 524 static const WCHAR szCurrentVersion[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0'};
 525 static const WCHAR Administrative_ToolsW[] = {'A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'};
 526 static const WCHAR AppDataW[] = {'A','p','p','D','a','t','a','\0'};
 527 static const WCHAR CacheW[] = {'C','a','c','h','e','\0'};
 528 static const WCHAR CD_BurningW[] = {'C','D',' ','B','u','r','n','i','n','g','\0'};
 529 static const WCHAR Common_Administrative_ToolsW[] = {'C','o','m','m','o','n',' ','A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'};
 530 static const WCHAR Common_AppDataW[] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'};
 531 static const WCHAR Common_DesktopW[] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'};
 532 static const WCHAR Common_DocumentsW[] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'};
 533 static const WCHAR CommonFilesDirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'};
 534 static const WCHAR CommonMusicW[] = {'C','o','m','m','o','n','M','u','s','i','c','\0'};
 535 static const WCHAR CommonPicturesW[] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'};
 536 static const WCHAR Common_ProgramsW[] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'};
 537 static const WCHAR Common_StartUpW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'};
 538 static const WCHAR Common_Start_MenuW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'};
 539 static const WCHAR Common_TemplatesW[] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'};
 540 static const WCHAR CommonVideoW[] = {'C','o','m','m','o','n','V','i','d','e','o','\0'};
 541 static const WCHAR CookiesW[] = {'C','o','o','k','i','e','s','\0'};
 542 static const WCHAR DesktopW[] = {'D','e','s','k','t','o','p','\0'};
 543 static const WCHAR FavoritesW[] = {'F','a','v','o','r','i','t','e','s','\0'};
 544 static const WCHAR FontsW[] = {'F','o','n','t','s','\0'};
 545 static const WCHAR HistoryW[] = {'H','i','s','t','o','r','y','\0'};
 546 static const WCHAR Local_AppDataW[] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'};
 547 static const WCHAR My_MusicW[] = {'M','y',' ','M','u','s','i','c','\0'};
 548 static const WCHAR My_PicturesW[] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'};
 549 static const WCHAR My_VideoW[] = {'M','y',' ','V','i','d','e','o','\0'};
 550 static const WCHAR NetHoodW[] = {'N','e','t','H','o','o','d','\0'};
 551 static const WCHAR PersonalW[] = {'P','e','r','s','o','n','a','l','\0'};
 552 static const WCHAR PrintHoodW[] = {'P','r','i','n','t','H','o','o','d','\0'};
 553 static const WCHAR ProgramFilesDirW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'};
 554 static const WCHAR ProgramsW[] = {'P','r','o','g','r','a','m','s','\0'};
 555 static const WCHAR RecentW[] = {'R','e','c','e','n','t','\0'};
 556 static const WCHAR ResourcesW[] = {'R','e','s','o','u','r','c','e','s','\0'};
 557 static const WCHAR SendToW[] = {'S','e','n','d','T','o','\0'};
 558 static const WCHAR StartUpW[] = {'S','t','a','r','t','U','p','\0'};
 559 static const WCHAR Start_MenuW[] = {'S','t','a','r','t',' ','M','e','n','u','\0'};
 560 static const WCHAR TemplatesW[] = {'T','e','m','p','l','a','t','e','s','\0'};
 561 static const WCHAR DefaultW[] = {'.','D','e','f','a','u','l','t','\0'};
 562 static const WCHAR AllUsersProfileW[] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%','\0'};
 563 static const WCHAR UserProfileW[] = {'%','U','S','E','R','P','R','O','F','I','L','E','%','\0'};
 564 static const WCHAR SystemDriveW[] = {'%','S','y','s','t','e','m','D','r','i','v','e','%','\0'};
 565 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};
 566 static const WCHAR ProfilesDirectoryW[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
 567 static const WCHAR AllUsersProfileValueW[] = {'A','l','l','U','s','e','r','s','P','r','o','f','i','l','e','\0'};
 568 static const WCHAR szSHFolders[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','S','h','e','l','l',' ','F','o','l','d','e','r','s','\0'};
 569 static const WCHAR szSHUserFolders[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','E','x','p','l','o','r','e','r','\\','U','s','e','r',' ','S','h','e','l','l',' ','F','o','l','d','e','r','s','\0'};
 570 /* This defaults to L"Documents and Settings" on Windows 2000/XP, but we're
 571  * acting more Windows 9x-like for now.
 572  */
 573 static const WCHAR szDefaultProfileDirW[] = {'p','r','o','f','i','l','e','s','\0'};
 574 static const WCHAR AllUsersW[] = {'A','l','l',' ','U','s','e','r','s','\0'};
 575
 576 typedef enum _CSIDL_Type {
 577     CSIDL_Type_User,
 578     CSIDL_Type_AllUsers,
 579     CSIDL_Type_CurrVer,
 580     CSIDL_Type_Disallowed,
 581     CSIDL_Type_NonExistent,
 582     CSIDL_Type_WindowsPath,
 583     CSIDL_Type_SystemPath,
 584 } CSIDL_Type;
 585
 586 typedef struct
 587 {
 588     CSIDL_Type type;
 589     LPCWSTR    szValueName;
 590     LPCWSTR    szDefaultPath; /* fallback string or resource ID */
 591 } CSIDL_DATA;
 592
 593 static const CSIDL_DATA CSIDL_Data[] =
 594 {
 595     { /* 0x00 - CSIDL_DESKTOP */
 596         CSIDL_Type_User,
 597         DesktopW,
 598         MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
 599     },
 600     { /* 0x01 - CSIDL_INTERNET */
 601         CSIDL_Type_Disallowed,
 602         NULL,
 603         NULL
 604     },
 605     { /* 0x02 - CSIDL_PROGRAMS */
 606         CSIDL_Type_User,
 607         ProgramsW,
 608         MAKEINTRESOURCEW(IDS_PROGRAMS)
 609     },
 610     { /* 0x03 - CSIDL_CONTROLS (.CPL files) */
 611         CSIDL_Type_SystemPath,
 612         NULL,
 613         NULL
 614     },
 615     { /* 0x04 - CSIDL_PRINTERS */
 616         CSIDL_Type_SystemPath,
 617         NULL,
 618         NULL
 619     },
 620     { /* 0x05 - CSIDL_PERSONAL */
 621         CSIDL_Type_User,
 622         PersonalW,
 623         MAKEINTRESOURCEW(IDS_PERSONAL)
 624     },
 625     { /* 0x06 - CSIDL_FAVORITES */
 626         CSIDL_Type_User,
 627         FavoritesW,
 628         MAKEINTRESOURCEW(IDS_FAVORITES)
 629     },
 630     { /* 0x07 - CSIDL_STARTUP */
 631         CSIDL_Type_User,
 632         StartUpW,
 633         MAKEINTRESOURCEW(IDS_STARTUP)
 634     },
 635     { /* 0x08 - CSIDL_RECENT */
 636         CSIDL_Type_User,
 637         RecentW,
 638         MAKEINTRESOURCEW(IDS_RECENT)
 639     },
 640     { /* 0x09 - CSIDL_SENDTO */
 641         CSIDL_Type_User,
 642         SendToW,
 643         MAKEINTRESOURCEW(IDS_SENDTO)
 644     },
 645     { /* 0x0a - CSIDL_BITBUCKET - Recycle Bin */
 646         CSIDL_Type_Disallowed,
 647         NULL,
 648         NULL,
 649     },
 650     { /* 0x0b - CSIDL_STARTMENU */
 651         CSIDL_Type_User,
 652         Start_MenuW,
 653         MAKEINTRESOURCEW(IDS_STARTMENU)
 654     },
 655     { /* 0x0c - CSIDL_MYDOCUMENTS */
 656         CSIDL_Type_Disallowed, /* matches WinXP--can't get its path */
 657         NULL,
 658         NULL
 659     },
 660     { /* 0x0d - CSIDL_MYMUSIC */
 661         CSIDL_Type_User,
 662         My_MusicW,
 663         MAKEINTRESOURCEW(IDS_MYMUSIC)
 664     },
 665     { /* 0x0e - CSIDL_MYVIDEO */
 666         CSIDL_Type_User,
 667         My_VideoW,
 668         MAKEINTRESOURCEW(IDS_MYVIDEO)
 669     },
 670     { /* 0x0f - unassigned */
 671         CSIDL_Type_Disallowed,
 672         NULL,
 673         NULL,
 674     },
 675     { /* 0x10 - CSIDL_DESKTOPDIRECTORY */
 676         CSIDL_Type_User,
 677         DesktopW,
 678         MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
 679     },
 680     { /* 0x11 - CSIDL_DRIVES */
 681         CSIDL_Type_Disallowed,
 682         NULL,
 683         NULL,
 684     },
 685     { /* 0x12 - CSIDL_NETWORK */
 686         CSIDL_Type_Disallowed,
 687         NULL,
 688         NULL,
 689     },
 690     { /* 0x13 - CSIDL_NETHOOD */
 691         CSIDL_Type_User,
 692         NetHoodW,
 693         MAKEINTRESOURCEW(IDS_NETHOOD)
 694     },
 695     { /* 0x14 - CSIDL_FONTS */
 696         CSIDL_Type_WindowsPath,
 697         FontsW,
 698         FontsW
 699     },
 700     { /* 0x15 - CSIDL_TEMPLATES */
 701         CSIDL_Type_User,
 702         TemplatesW,
 703         MAKEINTRESOURCEW(IDS_TEMPLATES)
 704     },
 705     { /* 0x16 - CSIDL_COMMON_STARTMENU */
 706         CSIDL_Type_AllUsers,
 707         Common_Start_MenuW,
 708         MAKEINTRESOURCEW(IDS_STARTMENU)
 709     },
 710     { /* 0x17 - CSIDL_COMMON_PROGRAMS */
 711         CSIDL_Type_AllUsers,
 712         Common_ProgramsW,
 713         MAKEINTRESOURCEW(IDS_PROGRAMS)
 714     },
 715     { /* 0x18 - CSIDL_COMMON_STARTUP */
 716         CSIDL_Type_AllUsers,
 717         Common_StartUpW,
 718         MAKEINTRESOURCEW(IDS_STARTUP)
 719     },
 720     { /* 0x19 - CSIDL_COMMON_DESKTOPDIRECTORY */
 721         CSIDL_Type_AllUsers,
 722         Common_DesktopW,
 723         MAKEINTRESOURCEW(IDS_DESKTOP)
 724     },
 725     { /* 0x1a - CSIDL_APPDATA */
 726         CSIDL_Type_User,
 727         AppDataW,
 728         MAKEINTRESOURCEW(IDS_APPDATA)
 729     },
 730     { /* 0x1b - CSIDL_PRINTHOOD */
 731         CSIDL_Type_User,
 732         PrintHoodW,
 733         MAKEINTRESOURCEW(IDS_PRINTHOOD)
 734     },
 735     { /* 0x1c - CSIDL_LOCAL_APPDATA */
 736         CSIDL_Type_User,
 737         Local_AppDataW,
 738         MAKEINTRESOURCEW(IDS_LOCAL_APPDATA)
 739     },
 740     { /* 0x1d - CSIDL_ALTSTARTUP */
 741         CSIDL_Type_NonExistent,
 742         NULL,
 743         NULL
 744     },
 745     { /* 0x1e - CSIDL_COMMON_ALTSTARTUP */
 746         CSIDL_Type_NonExistent,
 747         NULL,
 748         NULL
 749     },
 750     { /* 0x1f - CSIDL_COMMON_FAVORITES */
 751         CSIDL_Type_AllUsers,
 752         FavoritesW,
 753         MAKEINTRESOURCEW(IDS_FAVORITES)
 754     },
 755     { /* 0x20 - CSIDL_INTERNET_CACHE */
 756         CSIDL_Type_User,
 757         CacheW,
 758         MAKEINTRESOURCEW(IDS_INTERNET_CACHE)
 759     },
 760     { /* 0x21 - CSIDL_COOKIES */
 761         CSIDL_Type_User,
 762         CookiesW,
 763         MAKEINTRESOURCEW(IDS_COOKIES)
 764     },
 765     { /* 0x22 - CSIDL_HISTORY */
 766         CSIDL_Type_User,
 767         HistoryW,
 768         MAKEINTRESOURCEW(IDS_HISTORY)
 769     },
 770     { /* 0x23 - CSIDL_COMMON_APPDATA */
 771         CSIDL_Type_AllUsers,
 772         Common_AppDataW,
 773         MAKEINTRESOURCEW(IDS_APPDATA)
 774     },
 775     { /* 0x24 - CSIDL_WINDOWS */
 776         CSIDL_Type_WindowsPath,
 777         NULL,
 778         NULL
 779     },
 780     { /* 0x25 - CSIDL_SYSTEM */
 781         CSIDL_Type_SystemPath,
 782         NULL,
 783         NULL
 784     },
 785     { /* 0x26 - CSIDL_PROGRAM_FILES */
 786         CSIDL_Type_CurrVer,
 787         ProgramFilesDirW,
 788         MAKEINTRESOURCEW(IDS_PROGRAM_FILES)
 789     },
 790     { /* 0x27 - CSIDL_MYPICTURES */
 791         CSIDL_Type_User,
 792         My_PicturesW,
 793         MAKEINTRESOURCEW(IDS_MYPICTURES)
 794     },
 795     { /* 0x28 - CSIDL_PROFILE */
 796         CSIDL_Type_User,
 797         NULL,
 798         NULL
 799     },
 800     { /* 0x29 - CSIDL_SYSTEMX86 */
 801         CSIDL_Type_NonExistent,
 802         NULL,
 803         NULL
 804     },
 805     { /* 0x2a - CSIDL_PROGRAM_FILESX86 */
 806         CSIDL_Type_NonExistent,
 807         NULL,
 808         NULL
 809     },
 810     { /* 0x2b - CSIDL_PROGRAM_FILES_COMMON */
 811         CSIDL_Type_CurrVer,
 812         CommonFilesDirW,
 813         MAKEINTRESOURCEW(IDS_PROGRAM_FILES_COMMON)
 814     },
 815     { /* 0x2c - CSIDL_PROGRAM_FILES_COMMONX86 */
 816         CSIDL_Type_NonExistent,
 817         NULL,
 818         NULL
 819     },
 820     { /* 0x2d - CSIDL_COMMON_TEMPLATES */
 821         CSIDL_Type_AllUsers,
 822         Common_TemplatesW,
 823         MAKEINTRESOURCEW(IDS_TEMPLATES)
 824     },
 825     { /* 0x2e - CSIDL_COMMON_DOCUMENTS */
 826         CSIDL_Type_AllUsers,
 827         Common_DocumentsW,
 828         MAKEINTRESOURCEW(IDS_COMMON_DOCUMENTS)
 829     },
 830     { /* 0x2f - CSIDL_COMMON_ADMINTOOLS */
 831         CSIDL_Type_AllUsers,
 832         Common_Administrative_ToolsW,
 833         MAKEINTRESOURCEW(IDS_ADMINTOOLS)
 834     },
 835     { /* 0x30 - CSIDL_ADMINTOOLS */
 836         CSIDL_Type_User,
 837         Administrative_ToolsW,
 838         MAKEINTRESOURCEW(IDS_ADMINTOOLS)
 839     },
 840     { /* 0x31 - CSIDL_CONNECTIONS */
 841         CSIDL_Type_Disallowed,
 842         NULL,
 843         NULL
 844     },
 845     { /* 0x32 - unassigned */
 846         CSIDL_Type_Disallowed,
 847         NULL,
 848         NULL
 849     },
 850     { /* 0x33 - unassigned */
 851         CSIDL_Type_Disallowed,
 852         NULL,
 853         NULL
 854     },
 855     { /* 0x34 - unassigned */
 856         CSIDL_Type_Disallowed,
 857         NULL,
 858         NULL
 859     },
 860     { /* 0x35 - CSIDL_COMMON_MUSIC */
 861         CSIDL_Type_AllUsers,
 862         CommonMusicW,
 863         MAKEINTRESOURCEW(IDS_COMMON_MUSIC)
 864     },
 865     { /* 0x36 - CSIDL_COMMON_PICTURES */
 866         CSIDL_Type_AllUsers,
 867         CommonPicturesW,
 868         MAKEINTRESOURCEW(IDS_COMMON_PICTURES)
 869     },
 870     { /* 0x37 - CSIDL_COMMON_VIDEO */
 871         CSIDL_Type_AllUsers,
 872         CommonVideoW,
 873         MAKEINTRESOURCEW(IDS_COMMON_VIDEO)
 874     },
 875     { /* 0x38 - CSIDL_RESOURCES */
 876         CSIDL_Type_WindowsPath,
 877         NULL,
 878         ResourcesW
 879     },
 880     { /* 0x39 - CSIDL_RESOURCES_LOCALIZED */
 881         CSIDL_Type_NonExistent,
 882         NULL,
 883         NULL
 884     },
 885     { /* 0x3a - CSIDL_COMMON_OEM_LINKS */
 886         CSIDL_Type_NonExistent,
 887         NULL,
 888         NULL
 889     },
 890     { /* 0x3b - CSIDL_CDBURN_AREA */
 891         CSIDL_Type_User,
 892         CD_BurningW,
 893         MAKEINTRESOURCEW(IDS_CDBURN_AREA)
 894     },
 895     { /* 0x3c unassigned */
 896         CSIDL_Type_Disallowed,
 897         NULL,
 898         NULL
 899     },
 900     { /* 0x3d - CSIDL_COMPUTERSNEARME */
 901         CSIDL_Type_Disallowed, /* FIXME */
 902         NULL,
 903         NULL
 904     },
 905     { /* 0x3e - CSIDL_PROFILES */
 906         CSIDL_Type_Disallowed, /* oddly, this matches WinXP */
 907         NULL,
 908         NULL
 909     }
 910 };
 911
 912 /* Gets the value named value from the registry key
 913  * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
 914  * (or from rootKey\userPrefix\... if userPrefix is not NULL) into path, which
 915  * is assumed to be MAX_PATH WCHARs in length.
 916  * If it exists, expands the value and writes the expanded value to
 917  * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
 918  * Returns successful error code if the value was retrieved from the registry,
 919  * and a failure otherwise.
 920  */
 921 static HRESULT _SHGetUserShellFolderPath(HKEY rootKey, LPCWSTR userPrefix,
 922  LPCWSTR value, LPWSTR path)
 923 {
 924     HRESULT hr;
 925     WCHAR shellFolderPath[MAX_PATH], userShellFolderPath[MAX_PATH];
 926     LPCWSTR pShellFolderPath, pUserShellFolderPath;
 927     DWORD dwDisp, dwType, dwPathLen;
 928     HKEY userShellFolderKey, shellFolderKey;
 929
 930     TRACE("%p,%s,%s,%p\n",rootKey, debugstr_w(userPrefix), debugstr_w(value),
 931      path);
 932
 933     if (userPrefix)
 934     {
 935         wcscpy(shellFolderPath, userPrefix);
 936         PathAddBackslashW(shellFolderPath);
 937         wcscat(shellFolderPath, szSHFolders);
 938         pShellFolderPath = shellFolderPath;
 939         wcscpy(userShellFolderPath, userPrefix);
 940         PathAddBackslashW(userShellFolderPath);
 941         wcscat(userShellFolderPath, szSHUserFolders);
 942         pUserShellFolderPath = userShellFolderPath;
 943     }
 944     else
 945     {
 946         pUserShellFolderPath = szSHUserFolders;
 947         pShellFolderPath = szSHFolders;
 948     }
 949
 950     if (RegCreateKeyExW(rootKey, pShellFolderPath, 0, NULL, 0, KEY_SET_VALUE,
 951      NULL, &shellFolderKey, &dwDisp))
 952     {
 953         TRACE("Failed to create %s\n", debugstr_w(pShellFolderPath));
 954         return E_FAIL;
 955     }
 956     if (RegCreateKeyExW(rootKey, pUserShellFolderPath, 0, NULL, 0,
 957      KEY_QUERY_VALUE, NULL, &userShellFolderKey, &dwDisp))
 958     {
 959         TRACE("Failed to create %s\n",
 960          debugstr_w(pUserShellFolderPath));
 961         RegCloseKey(shellFolderKey);
 962         return E_FAIL;
 963     }
 964
 965     dwPathLen = MAX_PATH * sizeof(WCHAR);
 966
 967     if (!RegQueryValueExW(userShellFolderKey, value, NULL, &dwType,
 968      (LPBYTE)path, &dwPathLen) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ))
 969     {
 970         LONG ret;
 971
 972         dwPathLen /= sizeof(WCHAR);
 973
 974         path[dwPathLen] = '\0';
 975         if (dwType == REG_EXPAND_SZ && path[0] == '%')
 976         {
 977             WCHAR szTemp[MAX_PATH];
 978
 979             dwPathLen = ExpandEnvironmentStringsW(path, szTemp, MAX_PATH);
 980             lstrcpynW(path, szTemp, dwPathLen);
 981         }
 982
 983         ret = RegSetValueExW(shellFolderKey, value, 0, REG_SZ, (LPBYTE)path, dwPathLen * sizeof(WCHAR));
 984         if (ret != ERROR_SUCCESS)
 985             hr = HRESULT_FROM_WIN32(ret);
 986         else
 987             hr = S_OK;
 988     }
 989     else
 990         hr = E_FAIL;
 991
 992     RegCloseKey(shellFolderKey);
 993     RegCloseKey(userShellFolderKey);
 994     TRACE("returning 0x%08x\n", hr);
 995     return hr;
 996 }
 997
 998 /* Gets a 'semi-expanded' default value of the CSIDL with index folder into
 999  * pszPath, based on the entries in CSIDL_Data.  By semi-expanded, I mean:
1000  * - The entry's szDefaultPath may be either a string value or an integer
1001  *   resource identifier.  In the latter case, the string value of the resource
1002  *   is written.
1003  * - Depending on the entry's type, the path may begin with an (unexpanded)
1004  *   environment variable name.  The caller is responsible for expanding
1005  *   environment strings if so desired.
1006  *   The types that are prepended with environment variables are:
1007  *   CSIDL_Type_User:     %USERPROFILE%
1008  *   CSIDL_Type_AllUsers: %ALLUSERSPROFILE%
1009  *   CSIDL_Type_CurrVer:  %SystemDrive%
1010  *   (Others might make sense too, but as yet are unneeded.)
1011  */
1012 static HRESULT _SHGetDefaultValue(BYTE folder, LPWSTR pszPath)
1013 {
1014     DWORD dwSize;
1015     HRESULT hr;
1016     HKEY hKey;
1017     WCHAR resourcePath[MAX_PATH];
1018     LPCWSTR pDefaultPath = NULL;
1019
1020     TRACE("0x%02x,%p\n", folder, pszPath);
1021
1022     if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1023         return E_INVALIDARG;
1024     if (!pszPath)
1025         return E_INVALIDARG;
1026
1027     if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
1028     {
1029         /* FIXME assume MAX_PATH size */
1030         dwSize = MAX_PATH * sizeof(WCHAR);
1031         if (RegQueryValueExW(hKey, CSIDL_Data[folder].szValueName, NULL, NULL, (LPBYTE)pszPath, &dwSize) == ERROR_SUCCESS)
1032         {
1033             RegCloseKey(hKey);
1034             return S_OK;
1035         }
1036         RegCloseKey(hKey);
1037     }
1038
1039     if (CSIDL_Data[folder].szDefaultPath &&
1040      IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath))
1041     {
1042         if (LoadStringW(shell32_hInstance,
1043          LOWORD(CSIDL_Data[folder].szDefaultPath), resourcePath, MAX_PATH))
1044         {
1045             hr = S_OK;
1046             pDefaultPath = resourcePath;
1047         }
1048         else
1049         {
1050             FIXME("(%d,%s), LoadString failed, missing translation?\n", folder,
1051              debugstr_w(pszPath));
1052             hr = E_FAIL;
1053         }
1054     }
1055     else
1056     {
1057         hr = S_OK;
1058         pDefaultPath = CSIDL_Data[folder].szDefaultPath;
1059     }
1060     if (SUCCEEDED(hr))
1061     {
1062         switch (CSIDL_Data[folder].type)
1063         {
1064             case CSIDL_Type_User:
1065                 wcscpy(pszPath, UserProfileW);
1066                 break;
1067             case CSIDL_Type_AllUsers:
1068                 wcscpy(pszPath, AllUsersProfileW);
1069                 break;
1070             case CSIDL_Type_CurrVer:
1071                 wcscpy(pszPath, SystemDriveW);
1072                 break;
1073             default:
1074                 ; /* no corresponding env. var, do nothing */
1075         }
1076         if (pDefaultPath)
1077         {
1078             PathAddBackslashW(pszPath);
1079             wcscat(pszPath, pDefaultPath);
1080         }
1081     }
1082     TRACE("returning 0x%08x\n", hr);
1083     return hr;
1084 }
1085
1086 /* Gets the (unexpanded) value of the folder with index folder into pszPath.
1087  * The folder's type is assumed to be CSIDL_Type_CurrVer.  Its default value
1088  * can be overridden in the HKLM\\szCurrentVersion key.
1089  * If dwFlags has SHGFP_TYPE_DEFAULT set or if the value isn't overridden in
1090  * the registry, uses _SHGetDefaultValue to get the value.
1091  */
1092 static HRESULT _SHGetCurrentVersionPath(DWORD dwFlags, BYTE folder,
1093  LPWSTR pszPath)
1094 {
1095     HRESULT hr;
1096
1097     TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
1098
1099     if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1100         return E_INVALIDARG;
1101     if (CSIDL_Data[folder].type != CSIDL_Type_CurrVer)
1102         return E_INVALIDARG;
1103     if (!pszPath)
1104         return E_INVALIDARG;
1105
1106     if (dwFlags & SHGFP_TYPE_DEFAULT)
1107         hr = _SHGetDefaultValue(folder, pszPath);
1108     else
1109     {
1110         HKEY hKey;
1111         DWORD dwDisp;
1112
1113         if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, szCurrentVersion, 0,
1114          NULL, 0, KEY_ALL_ACCESS, NULL, &hKey, &dwDisp))
1115             hr = E_FAIL;
1116         else
1117         {
1118             DWORD dwType, dwPathLen = MAX_PATH * sizeof(WCHAR);
1119
1120             if (RegQueryValueExW(hKey, CSIDL_Data[folder].szValueName, NULL,
1121              &dwType, (LPBYTE)pszPath, &dwPathLen) ||
1122              (dwType != REG_SZ && dwType != REG_EXPAND_SZ))
1123             {
1124                 hr = _SHGetDefaultValue(folder, pszPath);
1125                 dwType = REG_EXPAND_SZ;
1126                 RegSetValueExW(hKey, CSIDL_Data[folder].szValueName, 0, dwType,
1127                  (LPBYTE)pszPath, (wcslen(pszPath)+1)*sizeof(WCHAR));
1128             }
1129             else
1130             {
1131                 pszPath[dwPathLen / sizeof(WCHAR)] = '\0';
1132                 hr = S_OK;
1133             }
1134             RegCloseKey(hKey);
1135         }
1136     }
1137     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1138     return hr;
1139 }
1140
1141 /* Gets the user's path (unexpanded) for the CSIDL with index folder:
1142  * If SHGFP_TYPE_DEFAULT is set, calls _SHGetDefaultValue for it.  Otherwise
1143  * calls _SHGetUserShellFolderPath for it.  Where it looks depends on hToken:
1144  * - if hToken is -1, looks in HKEY_USERS\.Default
1145  * - otherwise looks first in HKEY_CURRENT_USER, followed by HKEY_LOCAL_MACHINE
1146  *   if HKEY_CURRENT_USER doesn't contain any entries.  If both fail, finally
1147  *   calls _SHGetDefaultValue for it.
1148  */
1149 static HRESULT _SHGetUserProfilePath(HANDLE hToken, DWORD dwFlags, BYTE folder,
1150  LPWSTR pszPath)
1151 {
1152     HRESULT hr;
1153
1154     TRACE("%p,0x%08x,0x%02x,%p\n", hToken, dwFlags, folder, pszPath);
1155
1156     if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1157         return E_INVALIDARG;
1158
1159     if (CSIDL_Data[folder].type != CSIDL_Type_User)
1160         return E_INVALIDARG;
1161
1162     if (!pszPath)
1163         return E_INVALIDARG;
1164
1165     if (dwFlags & SHGFP_TYPE_DEFAULT)
1166     {
1167         hr = _SHGetDefaultValue(folder, pszPath);
1168     }
1169     else
1170     {
1171         LPWSTR userPrefix;
1172         HKEY hRootKey;
1173
1174         if (hToken == (HANDLE)-1)
1175         {
1176             /* Get the folder of the default user */
1177             hRootKey = HKEY_USERS;
1178             userPrefix = (LPWSTR)DefaultW;
1179         }
1180         else if(!hToken)
1181         {
1182             /* Get the folder of the current user */
1183             hRootKey = HKEY_CURRENT_USER;
1184             userPrefix = NULL;
1185         }
1186         else
1187         {
1188             /* Get the folder of the specified user */
1189             DWORD InfoLength;
1190             PTOKEN_USER UserInfo;
1191
1192             hRootKey = HKEY_USERS;
1193
1194             GetTokenInformation(hToken, TokenUser, NULL, 0, &InfoLength);
1195             UserInfo = (PTOKEN_USER)HeapAlloc(GetProcessHeap(), 0, InfoLength);
1196
1197             if(!GetTokenInformation(hToken, TokenUser, UserInfo, InfoLength, &InfoLength))
1198             {
1199                 WARN("GetTokenInformation failed for %x!\n", hToken);
1200                 HeapFree(GetProcessHeap(), 0, UserInfo);
1201                 return E_FAIL;
1202             }
1203
1204             if(!ConvertSidToStringSidW(UserInfo->User.Sid, &userPrefix))
1205             {
1206                 WARN("ConvertSidToStringSidW failed for %x!\n", hToken);
1207                 HeapFree(GetProcessHeap(), 0, UserInfo);
1208                 return E_FAIL;
1209             }
1210
1211             HeapFree(GetProcessHeap(), 0, UserInfo);
1212         }
1213
1214         hr = _SHGetUserShellFolderPath(hRootKey, userPrefix, CSIDL_Data[folder].szValueName, pszPath);
1215
1216         /* Free the memory allocated by ConvertSidToStringSidW */
1217         if(hToken && hToken != (HANDLE)-1)
1218             LocalFree(userPrefix);
1219
1220         if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
1221             hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL, CSIDL_Data[folder].szValueName, pszPath);
1222
1223         if (FAILED(hr))
1224             hr = _SHGetDefaultValue(folder, pszPath);
1225     }
1226
1227     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1228     return hr;
1229 }
1230
1231 /* Gets the (unexpanded) path for the CSIDL with index folder.  If dwFlags has
1232  * SHGFP_TYPE_DEFAULT set, calls _SHGetDefaultValue.  Otherwise calls
1233  * _SHGetUserShellFolderPath for it, looking only in HKEY_LOCAL_MACHINE.
1234  * If this fails, falls back to _SHGetDefaultValue.
1235  */
1236 static HRESULT _SHGetAllUsersProfilePath(DWORD dwFlags, BYTE folder,
1237  LPWSTR pszPath)
1238 {
1239     HRESULT hr;
1240
1241     TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
1242
1243     if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1244         return E_INVALIDARG;
1245     if (CSIDL_Data[folder].type != CSIDL_Type_AllUsers)
1246         return E_INVALIDARG;
1247     if (!pszPath)
1248         return E_INVALIDARG;
1249
1250     if (dwFlags & SHGFP_TYPE_DEFAULT)
1251         hr = _SHGetDefaultValue(folder, pszPath);
1252     else
1253     {
1254         hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
1255          CSIDL_Data[folder].szValueName, pszPath);
1256         if (FAILED(hr))
1257             hr = _SHGetDefaultValue(folder, pszPath);
1258     }
1259     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1260     return hr;
1261 }
1262
1263 /*************************************************************************
1264  * SHGetFolderPathW                     [SHELL32.@]
1265  *
1266  * Convert nFolder to path.
1267  *
1268  * RETURNS
1269  *  Success: S_OK
1270  *  Failure: standard HRESULT error codes.
1271  *
1272  * NOTES
1273  * Most values can be overridden in either
1274  * HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
1275  * or in the same location in HKLM.
1276  * The "Shell Folders" registry key was used in NT4 and earlier systems.
1277  * Beginning with Windows 2000, the "User Shell Folders" key is used, so
1278  * changes made to it are made to the former key too.  This synchronization is
1279  * done on-demand: not until someone requests the value of one of these paths
1280  * (by calling one of the SHGet functions) is the value synchronized.
1281  * Furthermore, the HKCU paths take precedence over the HKLM paths.
1282  */
1283 HRESULT WINAPI SHGetFolderPathW(
1284         HWND hwndOwner,    /* [I] owner window */
1285         int nFolder,       /* [I] CSIDL identifying the folder */
1286         HANDLE hToken,     /* [I] access token */
1287         DWORD dwFlags,     /* [I] which path to return */
1288         LPWSTR pszPath)    /* [O] converted path */
1289 {
1290     HRESULT hr =  SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, NULL, pszPath);
1291     if(HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) == hr)
1292         hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
1293     return hr;
1294 }
1295
1296 HRESULT WINAPI SHGetFolderPathAndSubDirA(
1297         HWND hwndOwner,    /* [I] owner window */
1298         int nFolder,       /* [I] CSIDL identifying the folder */
1299         HANDLE hToken,     /* [I] access token */
1300         DWORD dwFlags,     /* [I] which path to return */
1301         LPCSTR pszSubPath, /* [I] sub directory of the specified folder */
1302         LPSTR pszPath)     /* [O] converted path */
1303 {
1304     int length;
1305     HRESULT hr = S_OK;
1306     LPWSTR pszSubPathW = NULL;
1307     LPWSTR pszPathW = NULL;
1308     TRACE("%08x,%08x,%s\n",nFolder, dwFlags, debugstr_w(pszSubPathW));
1309
1310     if(pszPath) {
1311         pszPathW = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
1312         if(!pszPathW) {
1313             hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
1314             goto cleanup;
1315         }
1316     }
1317     TRACE("%08x,%08x,%s\n",nFolder, dwFlags, debugstr_w(pszSubPathW));
1318
1319     /* SHGetFolderPathAndSubDirW does not distinguish if pszSubPath isn't
1320      * set (null), or an empty string.therefore call it without the parameter set
1321      * if pszSubPath is an empty string
1322      */
1323     if (pszSubPath && pszSubPath[0]) {
1324         length = MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, NULL, 0);
1325         pszSubPathW = HeapAlloc(GetProcessHeap(), 0, length * sizeof(WCHAR));
1326         if(!pszSubPathW) {
1327             hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
1328             goto cleanup;
1329         }
1330         MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, pszSubPathW, length);
1331     }
1332
1333     hr = SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, pszSubPathW, pszPathW);
1334
1335     if (SUCCEEDED(hr) && pszPath)
1336         WideCharToMultiByte(CP_ACP, 0, pszPathW, -1, pszPath, MAX_PATH, NULL, NULL);
1337
1338 cleanup:
1339     HeapFree(GetProcessHeap(), 0, pszPathW);
1340     HeapFree(GetProcessHeap(), 0, pszSubPathW);
1341     return hr;
1342 }
1343
1344 HRESULT WINAPI SHGetFolderPathAndSubDirW(
1345         HWND hwndOwner,    /* [I] owner window */
1346         int nFolder,       /* [I] CSIDL identifying the folder */
1347         HANDLE hToken,     /* [I] access token */
1348         DWORD dwFlags,     /* [I] which path to return */
1349         LPCWSTR pszSubPath,/* [I] sub directory of the specified folder */
1350         LPWSTR pszPath)    /* [O] converted path */
1351 {
1352     HRESULT    hr;
1353     WCHAR      szBuildPath[MAX_PATH], szTemp[MAX_PATH];
1354     DWORD      folder = nFolder & CSIDL_FOLDER_MASK; //FIXME
1355     CSIDL_Type type;
1356     int        ret;
1357
1358     TRACE("%p,%p,nFolder=0x%04x,%s\n", hwndOwner,pszPath,nFolder,debugstr_w(pszSubPath));
1359
1360     /* Windows always NULL-terminates the resulting path regardless of success
1361      * or failure, so do so first
1362      */
1363     if (pszPath)
1364         *pszPath = '\0';
1365
1366     if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1367         return E_INVALIDARG;
1368     if ((SHGFP_TYPE_CURRENT != dwFlags) && (SHGFP_TYPE_DEFAULT != dwFlags))
1369         return E_INVALIDARG;
1370     szTemp[0] = 0;
1371     type = CSIDL_Data[folder].type;
1372     switch (type)
1373     {
1374         case CSIDL_Type_Disallowed:
1375             hr = E_INVALIDARG;
1376             break;
1377         case CSIDL_Type_NonExistent:
1378             hr = S_FALSE;
1379             break;
1380         case CSIDL_Type_WindowsPath:
1381             GetWindowsDirectoryW(szTemp, MAX_PATH);
1382             if (CSIDL_Data[folder].szDefaultPath &&
1383              !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
1384              *CSIDL_Data[folder].szDefaultPath)
1385             {
1386                 PathAddBackslashW(szTemp);
1387                 wcscat(szTemp, CSIDL_Data[folder].szDefaultPath);
1388             }
1389             hr = S_OK;
1390             break;
1391         case CSIDL_Type_SystemPath:
1392             GetSystemDirectoryW(szTemp, MAX_PATH);
1393             if (CSIDL_Data[folder].szDefaultPath &&
1394              !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
1395              *CSIDL_Data[folder].szDefaultPath)
1396             {
1397                 PathAddBackslashW(szTemp);
1398                 wcscat(szTemp, CSIDL_Data[folder].szDefaultPath);
1399             }
1400             hr = S_OK;
1401             break;
1402         case CSIDL_Type_CurrVer:
1403             hr = _SHGetCurrentVersionPath(dwFlags, folder, szTemp);
1404             break;
1405         case CSIDL_Type_User:
1406             hr = _SHGetUserProfilePath(hToken, dwFlags, folder, szTemp);
1407             break;
1408         case CSIDL_Type_AllUsers:
1409             hr = _SHGetAllUsersProfilePath(dwFlags, folder, szTemp);
1410             break;
1411         default:
1412             FIXME("bogus type %d, please fix\n", type);
1413             hr = E_INVALIDARG;
1414             break;
1415     }
1416
1417     /* Expand environment strings if necessary */
1418     if (*szTemp == '%')
1419     {
1420         DWORD ExpandRet = ExpandEnvironmentStringsW(szTemp, szBuildPath, MAX_PATH);
1421
1422         if (ExpandRet > MAX_PATH)
1423             hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
1424         else if (ExpandRet == 0)
1425             hr = HRESULT_FROM_WIN32(GetLastError());
1426         else
1427             hr = S_OK;
1428     }
1429     else
1430     {
1431         wcscpy(szBuildPath, szTemp);
1432     }
1433
1434     if (FAILED(hr)) goto end;
1435
1436     if(pszSubPath) {
1437         /* make sure the new path does not exceed th bufferlength
1438          * rememebr to backslash and the termination */
1439         if(MAX_PATH < (wcslen(szBuildPath) + wcslen(pszSubPath) + 2)) {
1440             hr = HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
1441             goto end;
1442         }
1443         PathAppendW(szBuildPath, pszSubPath);
1444         PathRemoveBackslashW(szBuildPath);
1445     }
1446     /* Copy the path if it's available before we might return */
1447     if (SUCCEEDED(hr) && pszPath)
1448         wcscpy(pszPath, szBuildPath);
1449
1450     /* if we don't care about existing directories we are ready */
1451     if(nFolder & CSIDL_FLAG_DONT_VERIFY) goto end;
1452
1453     if (PathFileExistsW(szBuildPath)) goto end;
1454
1455     /* not existing but we are not allowed to create it.  The return value
1456      * is verified against shell32 version 6.0.
1457      */
1458     if (!(nFolder & CSIDL_FLAG_CREATE))
1459     {
1460         hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
1461         goto end;
1462     }
1463
1464     /* create directory/directories */
1465     ret = SHCreateDirectoryExW(hwndOwner, szBuildPath, NULL);
1466     if (ret && ret != ERROR_ALREADY_EXISTS)
1467     {
1468         ERR("Failed to create directory %s.\n", debugstr_w(szBuildPath));
1469         hr = E_FAIL;
1470         goto end;
1471     }
1472
1473     TRACE("Created missing system directory %s\n", debugstr_w(szBuildPath));
1474 end:
1475     TRACE("returning 0x%08x (final path is %s)\n", hr, debugstr_w(szBuildPath));
1476     return hr;
1477 }
1478
1479 /*************************************************************************
1480  * SHGetFolderPathA                     [SHELL32.@]
1481  *
1482  * See SHGetFolderPathW.
1483  */
1484 HRESULT WINAPI SHGetFolderPathA(
1485         HWND hwndOwner,
1486         int nFolder,
1487         HANDLE hToken,
1488         DWORD dwFlags,
1489         LPSTR pszPath)
1490 {
1491     WCHAR szTemp[MAX_PATH];
1492     HRESULT hr;
1493
1494     TRACE("%p,%p,nFolder=0x%04x\n",hwndOwner,pszPath,nFolder);
1495
1496     if (pszPath)
1497         *pszPath = '\0';
1498     hr = SHGetFolderPathW(hwndOwner, nFolder, hToken, dwFlags, szTemp);
1499     if (SUCCEEDED(hr) && pszPath)
1500         WideCharToMultiByte(CP_ACP, 0, szTemp, -1, pszPath, MAX_PATH, NULL,
1501          NULL);
1502
1503     return hr;
1504 }
1505
1506 /* For each folder in folders, if its value has not been set in the registry,
1507  * calls _SHGetUserProfilePath or _SHGetAllUsersProfilePath (depending on the
1508  * folder's type) to get the unexpanded value first.
1509  * Writes the unexpanded value to User Shell Folders, and queries it with
1510  * SHGetFolderPathW to force the creation of the directory if it doesn't
1511  * already exist.  SHGetFolderPathW also returns the expanded value, which
1512  * this then writes to Shell Folders.
1513  */
1514 static HRESULT _SHRegisterFolders(HKEY hRootKey, HANDLE hToken,
1515  LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[],
1516  UINT foldersLen)
1517 {
1518     UINT i;
1519     WCHAR path[MAX_PATH];
1520     HRESULT hr = S_OK;
1521     HKEY hUserKey = NULL, hKey = NULL;
1522     DWORD dwDisp, dwType, dwPathLen;
1523     LONG ret;
1524
1525     TRACE("%p,%p,%s,%p,%u\n", hRootKey, hToken,
1526      debugstr_w(szUserShellFolderPath), folders, foldersLen);
1527
1528     ret = RegCreateKeyExW(hRootKey, szUserShellFolderPath, 0, NULL, 0,
1529      KEY_ALL_ACCESS, NULL, &hUserKey, &dwDisp);
1530     if (ret)
1531         hr = HRESULT_FROM_WIN32(ret);
1532     else
1533     {
1534         ret = RegCreateKeyExW(hRootKey, szShellFolderPath, 0, NULL, 0,
1535          KEY_ALL_ACCESS, NULL, &hKey, &dwDisp);
1536         if (ret)
1537             hr = HRESULT_FROM_WIN32(ret);
1538     }
1539     for (i = 0; SUCCEEDED(hr) && i < foldersLen; i++)
1540     {
1541         dwPathLen = MAX_PATH * sizeof(WCHAR);
1542         if (RegQueryValueExW(hUserKey, CSIDL_Data[folders[i]].szValueName, NULL,
1543          &dwType, (LPBYTE)path, &dwPathLen) || (dwType != REG_SZ &&
1544          dwType != REG_EXPAND_SZ))
1545         {
1546             *path = '\0';
1547             if (CSIDL_Data[folders[i]].type == CSIDL_Type_User)
1548                 _SHGetUserProfilePath(hToken, SHGFP_TYPE_DEFAULT, folders[i],
1549                  path);
1550             else if (CSIDL_Data[folders[i]].type == CSIDL_Type_AllUsers)
1551                 _SHGetAllUsersProfilePath(SHGFP_TYPE_DEFAULT, folders[i], path);
1552             else if (CSIDL_Data[folders[i]].type == CSIDL_Type_WindowsPath)
1553                 GetWindowsDirectoryW(path, MAX_PATH);
1554             else
1555                 hr = E_FAIL;
1556             if (*path)
1557             {
1558                 ret = RegSetValueExW(hUserKey,
1559                  CSIDL_Data[folders[i]].szValueName, 0, REG_EXPAND_SZ,
1560                  (LPBYTE)path, (wcslen(path) + 1) * sizeof(WCHAR));
1561                 if (ret)
1562                     hr = HRESULT_FROM_WIN32(ret);
1563                 else
1564                 {
1565                     hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
1566                      hToken, SHGFP_TYPE_DEFAULT, path);
1567                     ret = RegSetValueExW(hKey,
1568                      CSIDL_Data[folders[i]].szValueName, 0, REG_SZ,
1569                      (LPBYTE)path, (wcslen(path) + 1) * sizeof(WCHAR));
1570                     if (ret)
1571                         hr = HRESULT_FROM_WIN32(ret);
1572                 }
1573             }
1574         }
1575     }
1576     if (hUserKey)
1577         RegCloseKey(hUserKey);
1578     if (hKey)
1579         RegCloseKey(hKey);
1580
1581     TRACE("returning 0x%08x\n", hr);
1582     return hr;
1583 }
1584
1585 static HRESULT _SHRegisterUserShellFolders(BOOL bDefault)
1586 {
1587     static const UINT folders[] = {
1588      CSIDL_PROGRAMS,
1589      CSIDL_PERSONAL,
1590      CSIDL_FAVORITES,
1591      CSIDL_APPDATA,
1592      CSIDL_STARTUP,
1593      CSIDL_RECENT,
1594      CSIDL_SENDTO,
1595      CSIDL_STARTMENU,
1596      CSIDL_MYMUSIC,
1597      CSIDL_MYVIDEO,
1598      CSIDL_DESKTOPDIRECTORY,
1599      CSIDL_NETHOOD,
1600      CSIDL_TEMPLATES,
1601      CSIDL_PRINTHOOD,
1602      CSIDL_LOCAL_APPDATA,
1603      CSIDL_INTERNET_CACHE,
1604      CSIDL_COOKIES,
1605      CSIDL_HISTORY,
1606      CSIDL_MYPICTURES,
1607      CSIDL_FONTS
1608     };
1609     WCHAR userShellFolderPath[MAX_PATH], shellFolderPath[MAX_PATH];
1610     LPCWSTR pUserShellFolderPath, pShellFolderPath;
1611     HRESULT hr = S_OK;
1612     HKEY hRootKey;
1613     HANDLE hToken;
1614
1615     TRACE("%s\n", bDefault ? "TRUE" : "FALSE");
1616     if (bDefault)
1617     {
1618         hToken = (HANDLE)-1;
1619         hRootKey = HKEY_USERS;
1620         wcscpy(userShellFolderPath, DefaultW);
1621         PathAddBackslashW(userShellFolderPath);
1622         wcscat(userShellFolderPath, szSHUserFolders);
1623         pUserShellFolderPath = userShellFolderPath;
1624         wcscpy(shellFolderPath, DefaultW);
1625         PathAddBackslashW(shellFolderPath);
1626         wcscat(shellFolderPath, szSHFolders);
1627         pShellFolderPath = shellFolderPath;
1628     }
1629     else
1630     {
1631         hToken = NULL;
1632         hRootKey = HKEY_CURRENT_USER;
1633         pUserShellFolderPath = szSHUserFolders;
1634         pShellFolderPath = szSHFolders;
1635     }
1636
1637     hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath,
1638      pShellFolderPath, folders, sizeof(folders) / sizeof(folders[0]));
1639     TRACE("returning 0x%08x\n", hr);
1640     return hr;
1641 }
1642
1643 static HRESULT _SHRegisterCommonShellFolders(void)
1644 {
1645     static const UINT folders[] = {
1646      CSIDL_COMMON_STARTMENU,
1647      CSIDL_COMMON_PROGRAMS,
1648      CSIDL_COMMON_STARTUP,
1649      CSIDL_COMMON_DESKTOPDIRECTORY,
1650      CSIDL_COMMON_FAVORITES,
1651      CSIDL_COMMON_APPDATA,
1652      CSIDL_COMMON_TEMPLATES,
1653      CSIDL_COMMON_DOCUMENTS,
1654     };
1655     HRESULT hr;
1656
1657     TRACE("\n");
1658     hr = _SHRegisterFolders(HKEY_LOCAL_MACHINE, NULL, szSHUserFolders,
1659      szSHFolders, folders, sizeof(folders) / sizeof(folders[0]));
1660     TRACE("returning 0x%08x\n", hr);
1661     return hr;
1662 }
1663
1664 /******************************************************************************
1665  * _SHAppendToUnixPath  [Internal]
1666  *
1667  * Helper function for _SHCreateSymbolicLinks. Appends pwszSubPath (or the
1668  * corresponding resource, if IS_INTRESOURCE) to the unix base path 'szBasePath'
1669  * and replaces backslashes with slashes.
1670  *
1671  * PARAMS
1672  *  szBasePath  [IO] The unix base path, which will be appended to (CP_UNXICP).
1673  *  pwszSubPath [I]  Sub-path or resource id (use MAKEINTRESOURCEW).
1674  *
1675  * RETURNS
1676  *  Success: TRUE,
1677  *  Failure: FALSE
1678  */
1679 static BOOL __inline _SHAppendToUnixPath(char *szBasePath, LPCWSTR pwszSubPath) {
1680     WCHAR wszSubPath[MAX_PATH];
1681     int cLen = strlen(szBasePath);
1682     char *pBackslash;
1683
1684     if (IS_INTRESOURCE(pwszSubPath)) {
1685         if (!LoadStringW(shell32_hInstance, LOWORD(pwszSubPath), wszSubPath, MAX_PATH)) {
1686             /* Fall back to hard coded defaults. */
1687             switch (LOWORD(pwszSubPath)) {
1688                 case IDS_PERSONAL:
1689                     wcscpy(wszSubPath, PersonalW);
1690                     break;
1691                 case IDS_MYMUSIC:
1692                     wcscpy(wszSubPath, My_MusicW);
1693                     break;
1694                 case IDS_MYPICTURES:
1695                     wcscpy(wszSubPath, My_PicturesW);
1696                     break;
1697                 case IDS_MYVIDEO:
1698                     wcscpy(wszSubPath, My_VideoW);
1699                     break;
1700                 default:
1701                     ERR("LoadString(%d) failed!\n", LOWORD(pwszSubPath));
1702                     return FALSE;
1703             }
1704         }
1705     } else {
1706         wcscpy(wszSubPath, pwszSubPath);
1707     }
1708
1709     if (szBasePath[cLen-1] != '/') szBasePath[cLen++] = '/';
1710
1711     if (!WideCharToMultiByte(CP_ACP, 0, wszSubPath, -1, szBasePath + cLen,
1712                              FILENAME_MAX - cLen, NULL, NULL))
1713     {
1714         return FALSE;
1715     }
1716
1717     pBackslash = szBasePath + cLen;
1718     while ((pBackslash = strchr(pBackslash, '\\'))) *pBackslash = '/';
1719
1720     return TRUE;
1721 }
1722 #if 0
1723 /******************************************************************************
1724  * _SHCreateSymbolicLinks  [Internal]
1725  *
1726  * Sets up symbol links for various shell folders to point into the users home
1727  * directory. We do an educated guess about what the user would probably want:
1728  * - If there is a 'My Documents' directory in $HOME, the user probably wants
1729  *   wine's 'My Documents' to point there. Furthermore, we imply that the user
1730  *   is a Windows lover and has no problem with wine creating 'My Pictures',
1731  *   'My Music' and 'My Video' subfolders under '$HOME/My Documents', if those
1732  *   do not already exits. We put appropriate symbolic links in place for those,
1733  *   too.
1734  * - If there is no 'My Documents' directory in $HOME, we let 'My Documents'
1735  *   point directly to $HOME. We assume the user to be a unix hacker who does not
1736  *   want wine to create anything anywhere besides the .wine directory. So, if
1737  *   there already is a 'My Music' directory in $HOME, we symlink the 'My Music'
1738  *   shell folder to it. But if not, we symlink it to $HOME directly. The same
1739  *   holds fo 'My Pictures' and 'My Video'.
1740  * - The Desktop shell folder is symlinked to '$HOME/Desktop', if that does
1741  *   exists and left alone if not.
1742  * ('My Music',... above in fact means LoadString(IDS_MYMUSIC))
1743  */
1744 static void _SHCreateSymbolicLinks(void)
1745 {
1746     UINT aidsMyStuff[] = { IDS_MYPICTURES, IDS_MYVIDEO, IDS_MYMUSIC }, i;
1747     int acsidlMyStuff[] = { CSIDL_MYPICTURES, CSIDL_MYVIDEO, CSIDL_MYMUSIC };
1748     WCHAR wszTempPath[MAX_PATH];
1749     char szPersonalTarget[FILENAME_MAX], *pszPersonal;
1750     char szMyStuffTarget[FILENAME_MAX], *pszMyStuff;
1751     char szDesktopTarget[FILENAME_MAX], *pszDesktop;
1752     struct stat statFolder;
1753     const char *pszHome;
1754     HRESULT hr;
1755
1756     /* Create all necessary profile sub-dirs up to 'My Documents' and get the unix path. */
1757     hr = SHGetFolderPathW(NULL, CSIDL_PERSONAL|CSIDL_FLAG_CREATE, NULL,
1758                           SHGFP_TYPE_DEFAULT, wszTempPath);
1759     if (FAILED(hr)) return;
1760     pszPersonal = wine_get_unix_file_name(wszTempPath);
1761     if (!pszPersonal) return;
1762
1763     pszHome = getenv("HOME");
1764     if (pszHome && !stat(pszHome, &statFolder) && S_ISDIR(statFolder.st_mode)) {
1765         strcpy(szPersonalTarget, pszHome);
1766         if (_SHAppendToUnixPath(szPersonalTarget, MAKEINTRESOURCEW(IDS_PERSONAL)) &&
1767             !stat(szPersonalTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
1768         {
1769             /* '$HOME/My Documents' exists. Create 'My Pictures', 'My Videos' and
1770              * 'My Music' subfolders or fail silently if they already exist. */
1771             for (i = 0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
1772                 strcpy(szMyStuffTarget, szPersonalTarget);
1773                 if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])))
1774                     mkdir(szMyStuffTarget);
1775             }
1776         }
1777         else
1778         {
1779             /* '$HOME/My Documents' doesn't exists, but '$HOME' does. */
1780             strcpy(szPersonalTarget, pszHome);
1781         }
1782
1783         /* Replace 'My Documents' directory with a symlink of fail silently if not empty. */
1784         rmdir(pszPersonal);
1785         symlink(szPersonalTarget, pszPersonal);
1786     }
1787     else
1788     {
1789         /* '$HOME' doesn't exist. Create 'My Pictures', 'My Videos' and 'My Music' subdirs
1790          * in '%USERPROFILE%\\My Documents' or fail silently if they already exist. */
1791         strcpy(szPersonalTarget, pszPersonal);
1792         for (i = 0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
1793             strcpy(szMyStuffTarget, szPersonalTarget);
1794             if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])))
1795                 mkdir(szMyStuffTarget);
1796         }
1797     }
1798
1799     /* Create symbolic links for 'My Pictures', 'My Video' and 'My Music'. */
1800     for (i=0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
1801         /* Create the current 'My Whatever' folder and get it's unix path. */
1802         hr = SHGetFolderPathW(NULL, acsidlMyStuff[i]|CSIDL_FLAG_CREATE, NULL,
1803                               SHGFP_TYPE_DEFAULT, wszTempPath);
1804         if (FAILED(hr)) continue;
1805         pszMyStuff = wine_get_unix_file_name(wszTempPath);
1806         if (!pszMyStuff) continue;
1807
1808         strcpy(szMyStuffTarget, szPersonalTarget);
1809         if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])) &&
1810             !stat(szMyStuffTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
1811         {
1812             /* If there's a 'My Whatever' directory where 'My Documents' links to, link to it. */
1813             rmdir(pszMyStuff);
1814             symlink(szMyStuffTarget, pszMyStuff);
1815         }
1816         else
1817         {
1818             /* Else link to where 'My Documents' itself links to. */
1819             rmdir(pszMyStuff);
1820             symlink(szPersonalTarget, pszMyStuff);
1821         }
1822         HeapFree(GetProcessHeap(), 0, pszMyStuff);
1823     }
1824
1825     /* Last but not least, the Desktop folder */
1826     if (pszHome)
1827         strcpy(szDesktopTarget, pszHome);
1828     else
1829         strcpy(szDesktopTarget, pszPersonal);
1830     HeapFree(GetProcessHeap(), 0, pszPersonal);
1831
1832     if (_SHAppendToUnixPath(szDesktopTarget, DesktopW) &&
1833         !stat(szDesktopTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
1834     {
1835         hr = SHGetFolderPathW(NULL, CSIDL_DESKTOPDIRECTORY|CSIDL_FLAG_CREATE, NULL,
1836                               SHGFP_TYPE_DEFAULT, wszTempPath);
1837         if (SUCCEEDED(hr) && (pszDesktop = wine_get_unix_file_name(wszTempPath)))
1838         {
1839             rmdir(pszDesktop);
1840             symlink(szDesktopTarget, pszDesktop);
1841             HeapFree(GetProcessHeap(), 0, pszDesktop);
1842         }
1843     }
1844 }
1845 #endif
1846
1847 /* Register the default values in the registry, as some apps seem to depend
1848  * on their presence.  The set registered was taken from Windows XP.
1849  */
1850 HRESULT SHELL_RegisterShellFolders(void)
1851 {
1852     HRESULT hr;
1853
1854     /* Set up '$HOME' targeted symlinks for 'My Documents', 'My Pictures',
1855      * 'My Video', 'My Music' and 'Desktop' in advance, so that the
1856      * _SHRegister*ShellFolders() functions will find everything nice and clean
1857      * and thus will not attempt to create them in the profile directory. */
1858 #if 0
1859     _SHCreateSymbolicLinks();
1860 #endif
1861
1862     hr = _SHRegisterUserShellFolders(TRUE);
1863     if (SUCCEEDED(hr))
1864         hr = _SHRegisterUserShellFolders(FALSE);
1865     if (SUCCEEDED(hr))
1866         hr = _SHRegisterCommonShellFolders();
1867     return hr;
1868 }
1869
1870 /*************************************************************************
1871  * SHGetSpecialFolderPathA [SHELL32.@]
1872  */
1873 BOOL WINAPI SHGetSpecialFolderPathA (
1874         HWND hwndOwner,
1875         LPSTR szPath,
1876         int nFolder,
1877         BOOL bCreate)
1878 {
1879         return (SHGetFolderPathA(
1880                 hwndOwner,
1881                 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
1882                 NULL,
1883                 0,
1884                 szPath)) == S_OK ? TRUE : FALSE;
1885 }
1886
1887 /*************************************************************************
1888  * SHGetSpecialFolderPathW
1889  */
1890 BOOL WINAPI SHGetSpecialFolderPathW (
1891         HWND hwndOwner,
1892         LPWSTR szPath,
1893         int nFolder,
1894         BOOL bCreate)
1895 {
1896         return (SHGetFolderPathW(
1897                 hwndOwner,
1898                 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
1899                 NULL,
1900                 0,
1901                 szPath)) == S_OK ? TRUE : FALSE;
1902 }
1903
1904 /*************************************************************************
1905  * SHGetFolderLocation [SHELL32.@]
1906  *
1907  * Gets the folder locations from the registry and creates a pidl.
1908  *
1909  * PARAMS
1910  *   hwndOwner  [I]
1911  *   nFolder    [I] CSIDL_xxxxx
1912  *   hToken     [I] token representing user, or NULL for current user, or -1 for
1913  *                  default user
1914  *   dwReserved [I] must be zero
1915  *   ppidl      [O] PIDL of a special folder
1916  *
1917  * RETURNS
1918  *  Success: S_OK
1919  *  Failure: Standard OLE-defined error result, S_FALSE or E_INVALIDARG
1920  *
1921  * NOTES
1922  *  Creates missing reg keys and directories.
1923  *  Mostly forwards to SHGetFolderPathW, but a few values of nFolder return
1924  *  virtual folders that are handled here.
1925  */
1926 HRESULT WINAPI SHGetFolderLocation(
1927         HWND hwndOwner,
1928         int nFolder,
1929         HANDLE hToken,
1930         DWORD dwReserved,
1931         LPITEMIDLIST *ppidl)
1932 {
1933     HRESULT hr = E_INVALIDARG;
1934
1935     TRACE("%p 0x%08x %p 0x%08x %p\n",
1936      hwndOwner, nFolder, hToken, dwReserved, ppidl);
1937
1938     if (!ppidl)
1939         return E_INVALIDARG;
1940     if (dwReserved)
1941         return E_INVALIDARG;
1942
1943     /* The virtual folders' locations are not user-dependent */
1944     *ppidl = NULL;
1945     switch (nFolder)
1946     {
1947         case CSIDL_DESKTOP:
1948             *ppidl = _ILCreateDesktop();
1949             break;
1950
1951         case CSIDL_PERSONAL:
1952             *ppidl = _ILCreateMyDocuments();
1953             break;
1954
1955         case CSIDL_INTERNET:
1956             *ppidl = _ILCreateIExplore();
1957             break;
1958
1959         case CSIDL_CONTROLS:
1960             *ppidl = _ILCreateControlPanel();
1961             break;
1962
1963         case CSIDL_PRINTERS:
1964             *ppidl = _ILCreatePrinters();
1965             break;
1966
1967         case CSIDL_BITBUCKET:
1968             *ppidl = _ILCreateBitBucket();
1969             break;
1970
1971         case CSIDL_DRIVES:
1972             *ppidl = _ILCreateMyComputer();
1973             break;
1974
1975         case CSIDL_NETWORK:
1976             *ppidl = _ILCreateNetwork();
1977             break;
1978
1979         default:
1980         {
1981             WCHAR szPath[MAX_PATH];
1982
1983             hr = SHGetFolderPathW(hwndOwner, nFolder, hToken,
1984              SHGFP_TYPE_CURRENT, szPath);
1985             if (SUCCEEDED(hr))
1986             {
1987                 DWORD attributes=0;
1988
1989                 TRACE("Value=%s\n", debugstr_w(szPath));
1990                 hr = SHILCreateFromPathW(szPath, ppidl, &attributes);
1991             }
1992             else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
1993             {
1994                 /* unlike SHGetFolderPath, SHGetFolderLocation in shell32
1995                  * version 6.0 returns E_FAIL for nonexistent paths
1996                  */
1997                 hr = E_FAIL;
1998             }
1999         }
2000     }
2001     if(*ppidl)
2002         hr = NOERROR;
2003
2004     TRACE("-- (new pidl %p)\n",*ppidl);
2005     return hr;
2006 }
2007
2008 /*************************************************************************
2009  * SHGetSpecialFolderLocation           [SHELL32.@]
2010  *
2011  * NOTES
2012  *   In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
2013  *   directory.
2014  */
2015 HRESULT WINAPI SHGetSpecialFolderLocation(
2016         HWND hwndOwner,
2017         INT nFolder,
2018         LPITEMIDLIST * ppidl)
2019 {
2020     HRESULT hr = E_INVALIDARG;
2021
2022     TRACE("(%p,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
2023
2024     if (!ppidl)
2025         return E_INVALIDARG;
2026
2027     hr = SHGetFolderLocation(hwndOwner, nFolder, NULL, 0, ppidl);
2028     return hr;
2029 }