dlls/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 #define COBJMACROS
  28
  29 #include "config.h"
  30 #include "wine/port.h"
  31
  32 #include <stdio.h>
  33 #include <stdarg.h>
  34 #include <string.h>
  35 #include <ctype.h>
  36 #include "wine/debug.h"
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "winnls.h"
  40 #include "winreg.h"
  41 #include "wingdi.h"
  42 #include "winuser.h"
  43
  44 #include "shlobj.h"
  45 #include "shtypes.h"
  46 #include "shresdef.h"
  47 #include "shell32_main.h"
  48 #include "undocshell.h"
  49 #include "pidl.h"
  50 #include "wine/unicode.h"
  51 #include "shlwapi.h"
  52 #include "xdg.h"
  53 #include "sddl.h"
  54 #include "knownfolders.h"
  55 #include "initguid.h"
  56 #include "shobjidl.h"
  57
  58 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  59
  60 static const BOOL is_win64 = sizeof(void *) > sizeof(int);
  61
  62 /*
  63         ########## Combining and Constructing paths ##########
  64 */
  65
  66 /*************************************************************************
  67  * PathAppend           [SHELL32.36]
  68  */
  69 BOOL WINAPI PathAppendAW(
  70         LPVOID lpszPath1,
  71         LPCVOID lpszPath2)
  72 {
  73         if (SHELL_OsIsUnicode())
  74           return PathAppendW(lpszPath1, lpszPath2);
  75         return PathAppendA(lpszPath1, lpszPath2);
  76 }
  77
  78 /*************************************************************************
  79  * PathCombine   [SHELL32.37]
  80  */
  81 LPVOID WINAPI PathCombineAW(
  82         LPVOID szDest,
  83         LPCVOID lpszDir,
  84         LPCVOID lpszFile)
  85 {
  86         if (SHELL_OsIsUnicode())
  87           return PathCombineW( szDest, lpszDir, lpszFile );
  88         return PathCombineA( szDest, lpszDir, lpszFile );
  89 }
  90
  91 /*************************************************************************
  92  * PathAddBackslash             [SHELL32.32]
  93  */
  94 LPVOID WINAPI PathAddBackslashAW(LPVOID lpszPath)
  95 {
  96         if(SHELL_OsIsUnicode())
  97           return PathAddBackslashW(lpszPath);
  98         return PathAddBackslashA(lpszPath);
  99 }
 100
 101 /*************************************************************************
 102  * PathBuildRoot                [SHELL32.30]
 103  */
 104 LPVOID WINAPI PathBuildRootAW(LPVOID lpszPath, int drive)
 105 {
 106         if(SHELL_OsIsUnicode())
 107           return PathBuildRootW(lpszPath, drive);
 108         return PathBuildRootA(lpszPath, drive);
 109 }
 110
 111 /*
 112         Extracting Component Parts
 113 */
 114
 115 /*************************************************************************
 116  * PathFindFileName     [SHELL32.34]
 117  */
 118 LPVOID WINAPI PathFindFileNameAW(LPCVOID lpszPath)
 119 {
 120         if(SHELL_OsIsUnicode())
 121           return PathFindFileNameW(lpszPath);
 122         return PathFindFileNameA(lpszPath);
 123 }
 124
 125 /*************************************************************************
 126  * PathFindExtension            [SHELL32.31]
 127  */
 128 LPVOID WINAPI PathFindExtensionAW(LPCVOID lpszPath)
 129 {
 130         if (SHELL_OsIsUnicode())
 131           return PathFindExtensionW(lpszPath);
 132         return PathFindExtensionA(lpszPath);
 133
 134 }
 135
 136 /*************************************************************************
 137  * PathGetExtensionA            [internal]
 138  *
 139  * NOTES
 140  *  exported by ordinal
 141  *  return value points to the first char after the dot
 142  */
 143 static LPSTR PathGetExtensionA(LPCSTR lpszPath)
 144 {
 145         TRACE("(%s)\n",lpszPath);
 146
 147         lpszPath = PathFindExtensionA(lpszPath);
 148         return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
 149 }
 150
 151 /*************************************************************************
 152  * PathGetExtensionW            [internal]
 153  */
 154 static LPWSTR PathGetExtensionW(LPCWSTR lpszPath)
 155 {
 156         TRACE("(%s)\n",debugstr_w(lpszPath));
 157
 158         lpszPath = PathFindExtensionW(lpszPath);
 159         return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
 160 }
 161
 162 /*************************************************************************
 163  * PathGetExtension             [SHELL32.158]
 164  */
 165 LPVOID WINAPI PathGetExtensionAW(LPCVOID lpszPath,DWORD void1, DWORD void2)
 166 {
 167         if (SHELL_OsIsUnicode())
 168           return PathGetExtensionW(lpszPath);
 169         return PathGetExtensionA(lpszPath);
 170 }
 171
 172 /*************************************************************************
 173  * PathGetArgs  [SHELL32.52]
 174  */
 175 LPVOID WINAPI PathGetArgsAW(LPVOID lpszPath)
 176 {
 177         if (SHELL_OsIsUnicode())
 178           return PathGetArgsW(lpszPath);
 179         return PathGetArgsA(lpszPath);
 180 }
 181
 182 /*************************************************************************
 183  * PathGetDriveNumber   [SHELL32.57]
 184  */
 185 int WINAPI PathGetDriveNumberAW(LPVOID lpszPath)
 186 {
 187         if (SHELL_OsIsUnicode())
 188           return PathGetDriveNumberW(lpszPath);
 189         return PathGetDriveNumberA(lpszPath);
 190 }
 191
 192 /*************************************************************************
 193  * PathRemoveFileSpec [SHELL32.35]
 194  */
 195 BOOL WINAPI PathRemoveFileSpecAW(LPVOID lpszPath)
 196 {
 197         if (SHELL_OsIsUnicode())
 198           return PathRemoveFileSpecW(lpszPath);
 199         return PathRemoveFileSpecA(lpszPath);
 200 }
 201
 202 /*************************************************************************
 203  * PathStripPath        [SHELL32.38]
 204  */
 205 void WINAPI PathStripPathAW(LPVOID lpszPath)
 206 {
 207         if (SHELL_OsIsUnicode())
 208             PathStripPathW(lpszPath);
 209         else
 210             PathStripPathA(lpszPath);
 211 }
 212
 213 /*************************************************************************
 214  * PathStripToRoot      [SHELL32.50]
 215  */
 216 BOOL WINAPI PathStripToRootAW(LPVOID lpszPath)
 217 {
 218         if (SHELL_OsIsUnicode())
 219           return PathStripToRootW(lpszPath);
 220         return PathStripToRootA(lpszPath);
 221 }
 222
 223 /*************************************************************************
 224  * PathRemoveArgs       [SHELL32.251]
 225  */
 226 void WINAPI PathRemoveArgsAW(LPVOID lpszPath)
 227 {
 228         if (SHELL_OsIsUnicode())
 229             PathRemoveArgsW(lpszPath);
 230         else
 231             PathRemoveArgsA(lpszPath);
 232 }
 233
 234 /*************************************************************************
 235  * PathRemoveExtension  [SHELL32.250]
 236  */
 237 void WINAPI PathRemoveExtensionAW(LPVOID lpszPath)
 238 {
 239         if (SHELL_OsIsUnicode())
 240             PathRemoveExtensionW(lpszPath);
 241         else
 242             PathRemoveExtensionA(lpszPath);
 243 }
 244
 245
 246 /*
 247         Path Manipulations
 248 */
 249
 250 /*************************************************************************
 251  * PathGetShortPathA [internal]
 252  */
 253 static void PathGetShortPathA(LPSTR pszPath)
 254 {
 255         CHAR path[MAX_PATH];
 256
 257         TRACE("%s\n", pszPath);
 258
 259         if (GetShortPathNameA(pszPath, path, MAX_PATH))
 260         {
 261           lstrcpyA(pszPath, path);
 262         }
 263 }
 264
 265 /*************************************************************************
 266  * PathGetShortPathW [internal]
 267  */
 268 static void PathGetShortPathW(LPWSTR pszPath)
 269 {
 270         WCHAR path[MAX_PATH];
 271
 272         TRACE("%s\n", debugstr_w(pszPath));
 273
 274         if (GetShortPathNameW(pszPath, path, MAX_PATH))
 275         {
 276           lstrcpyW(pszPath, path);
 277         }
 278 }
 279
 280 /*************************************************************************
 281  * PathGetShortPath [SHELL32.92]
 282  */
 283 VOID WINAPI PathGetShortPathAW(LPVOID pszPath)
 284 {
 285         if(SHELL_OsIsUnicode())
 286           PathGetShortPathW(pszPath);
 287         PathGetShortPathA(pszPath);
 288 }
 289
 290 /*************************************************************************
 291  * PathRemoveBlanks [SHELL32.33]
 292  */
 293 void WINAPI PathRemoveBlanksAW(LPVOID str)
 294 {
 295         if(SHELL_OsIsUnicode())
 296             PathRemoveBlanksW(str);
 297         else
 298             PathRemoveBlanksA(str);
 299 }
 300
 301 /*************************************************************************
 302  * PathQuoteSpaces [SHELL32.55]
 303  */
 304 VOID WINAPI PathQuoteSpacesAW (LPVOID lpszPath)
 305 {
 306         if(SHELL_OsIsUnicode())
 307             PathQuoteSpacesW(lpszPath);
 308         else
 309             PathQuoteSpacesA(lpszPath);
 310 }
 311
 312 /*************************************************************************
 313  * PathUnquoteSpaces [SHELL32.56]
 314  */
 315 VOID WINAPI PathUnquoteSpacesAW(LPVOID str)
 316 {
 317         if(SHELL_OsIsUnicode())
 318           PathUnquoteSpacesW(str);
 319         else
 320           PathUnquoteSpacesA(str);
 321 }
 322
 323 /*************************************************************************
 324  * PathParseIconLocation        [SHELL32.249]
 325  */
 326 int WINAPI PathParseIconLocationAW (LPVOID lpszPath)
 327 {
 328         if(SHELL_OsIsUnicode())
 329           return PathParseIconLocationW(lpszPath);
 330         return PathParseIconLocationA(lpszPath);
 331 }
 332
 333 /*
 334         ########## Path Testing ##########
 335 */
 336 /*************************************************************************
 337  * PathIsUNC            [SHELL32.39]
 338  */
 339 BOOL WINAPI PathIsUNCAW (LPCVOID lpszPath)
 340 {
 341         if (SHELL_OsIsUnicode())
 342           return PathIsUNCW( lpszPath );
 343         return PathIsUNCA( lpszPath );
 344 }
 345
 346 /*************************************************************************
 347  *  PathIsRelative      [SHELL32.40]
 348  */
 349 BOOL WINAPI PathIsRelativeAW (LPCVOID lpszPath)
 350 {
 351         if (SHELL_OsIsUnicode())
 352           return PathIsRelativeW( lpszPath );
 353         return PathIsRelativeA( lpszPath );
 354 }
 355
 356 /*************************************************************************
 357  * PathIsRoot           [SHELL32.29]
 358  */
 359 BOOL WINAPI PathIsRootAW(LPCVOID lpszPath)
 360 {
 361         if (SHELL_OsIsUnicode())
 362           return PathIsRootW(lpszPath);
 363         return PathIsRootA(lpszPath);
 364 }
 365
 366 /*************************************************************************
 367  *  PathIsExeA          [internal]
 368  */
 369 static BOOL PathIsExeA (LPCSTR lpszPath)
 370 {
 371         LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
 372         int i;
 373         static const char * const lpszExtensions[] =
 374             {"exe", "com", "pif", "cmd", "bat", "scf", "scr", NULL };
 375
 376         TRACE("path=%s\n",lpszPath);
 377
 378         for(i=0; lpszExtensions[i]; i++)
 379           if (!lstrcmpiA(lpszExtension,lpszExtensions[i])) return TRUE;
 380
 381         return FALSE;
 382 }
 383
 384 /*************************************************************************
 385  *  PathIsExeW          [internal]
 386  */
 387 static BOOL PathIsExeW (LPCWSTR lpszPath)
 388 {
 389         LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
 390         int i;
 391         static const WCHAR lpszExtensions[][4] =
 392             {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','f','\0'},
 393              {'c','m','d','\0'}, {'b','a','t','\0'}, {'s','c','f','\0'},
 394              {'s','c','r','\0'}, {'\0'} };
 395
 396         TRACE("path=%s\n",debugstr_w(lpszPath));
 397
 398         for(i=0; lpszExtensions[i][0]; i++)
 399           if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
 400
 401         return FALSE;
 402 }
 403
 404 /*************************************************************************
 405  *  PathIsExe           [SHELL32.43]
 406  */
 407 BOOL WINAPI PathIsExeAW (LPCVOID path)
 408 {
 409         if (SHELL_OsIsUnicode())
 410           return PathIsExeW (path);
 411         return PathIsExeA(path);
 412 }
 413
 414 /*************************************************************************
 415  * PathIsDirectory      [SHELL32.159]
 416  */
 417 BOOL WINAPI PathIsDirectoryAW (LPCVOID lpszPath)
 418 {
 419         if (SHELL_OsIsUnicode())
 420           return PathIsDirectoryW (lpszPath);
 421         return PathIsDirectoryA (lpszPath);
 422 }
 423
 424 /*************************************************************************
 425  * PathFileExists       [SHELL32.45]
 426  */
 427 BOOL WINAPI PathFileExistsAW (LPCVOID lpszPath)
 428 {
 429         if (SHELL_OsIsUnicode())
 430           return PathFileExistsW (lpszPath);
 431         return PathFileExistsA (lpszPath);
 432 }
 433
 434 /*************************************************************************
 435  * PathMatchSpec        [SHELL32.46]
 436  */
 437 BOOL WINAPI PathMatchSpecAW(LPVOID name, LPVOID mask)
 438 {
 439         if (SHELL_OsIsUnicode())
 440           return PathMatchSpecW( name, mask );
 441         return PathMatchSpecA( name, mask );
 442 }
 443
 444 /*************************************************************************
 445  * PathIsSameRoot       [SHELL32.650]
 446  */
 447 BOOL WINAPI PathIsSameRootAW(LPCVOID lpszPath1, LPCVOID lpszPath2)
 448 {
 449         if (SHELL_OsIsUnicode())
 450           return PathIsSameRootW(lpszPath1, lpszPath2);
 451         return PathIsSameRootA(lpszPath1, lpszPath2);
 452 }
 453
 454 /*************************************************************************
 455  * IsLFNDriveA          [SHELL32.41]
 456  */
 457 BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath)
 458 {
 459     DWORD       fnlen;
 460
 461     if (!GetVolumeInformationA(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
 462         return FALSE;
 463     return fnlen > 12;
 464 }
 465
 466 /*************************************************************************
 467  * IsLFNDriveW          [SHELL32.42]
 468  */
 469 BOOL WINAPI IsLFNDriveW(LPCWSTR lpszPath)
 470 {
 471     DWORD       fnlen;
 472
 473     if (!GetVolumeInformationW(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
 474         return FALSE;
 475     return fnlen > 12;
 476 }
 477
 478 /*************************************************************************
 479  * IsLFNDrive           [SHELL32.119]
 480  */
 481 BOOL WINAPI IsLFNDriveAW(LPCVOID lpszPath)
 482 {
 483         if (SHELL_OsIsUnicode())
 484           return IsLFNDriveW(lpszPath);
 485         return IsLFNDriveA(lpszPath);
 486 }
 487
 488 /*
 489         ########## Creating Something Unique ##########
 490 */
 491 /*************************************************************************
 492  * PathMakeUniqueNameA  [internal]
 493  */
 494 static BOOL PathMakeUniqueNameA(
 495         LPSTR lpszBuffer,
 496         DWORD dwBuffSize,
 497         LPCSTR lpszShortName,
 498         LPCSTR lpszLongName,
 499         LPCSTR lpszPathName)
 500 {
 501         FIXME("%p %u %s %s %s stub\n",
 502          lpszBuffer, dwBuffSize, debugstr_a(lpszShortName),
 503          debugstr_a(lpszLongName), debugstr_a(lpszPathName));
 504         return TRUE;
 505 }
 506
 507 /*************************************************************************
 508  * PathMakeUniqueNameW  [internal]
 509  */
 510 static BOOL PathMakeUniqueNameW(
 511         LPWSTR lpszBuffer,
 512         DWORD dwBuffSize,
 513         LPCWSTR lpszShortName,
 514         LPCWSTR lpszLongName,
 515         LPCWSTR lpszPathName)
 516 {
 517         FIXME("%p %u %s %s %s stub\n",
 518          lpszBuffer, dwBuffSize, debugstr_w(lpszShortName),
 519          debugstr_w(lpszLongName), debugstr_w(lpszPathName));
 520         return TRUE;
 521 }
 522
 523 /*************************************************************************
 524  * PathMakeUniqueName   [SHELL32.47]
 525  */
 526 BOOL WINAPI PathMakeUniqueNameAW(
 527         LPVOID lpszBuffer,
 528         DWORD dwBuffSize,
 529         LPCVOID lpszShortName,
 530         LPCVOID lpszLongName,
 531         LPCVOID lpszPathName)
 532 {
 533         if (SHELL_OsIsUnicode())
 534           return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
 535         return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
 536 }
 537
 538 /*************************************************************************
 539  * PathYetAnotherMakeUniqueName [SHELL32.75]
 540  *
 541  * NOTES
 542  *     exported by ordinal
 543  */
 544 BOOL WINAPI PathYetAnotherMakeUniqueName(
 545         LPWSTR lpszBuffer,
 546         LPCWSTR lpszPathName,
 547         LPCWSTR lpszShortName,
 548         LPCWSTR lpszLongName)
 549 {
 550     FIXME("(%p, %s, %s ,%s):stub.\n",
 551           lpszBuffer, debugstr_w(lpszPathName), debugstr_w(lpszShortName), debugstr_w(lpszLongName));
 552     return TRUE;
 553 }
 554
 555
 556 /*
 557         ########## cleaning and resolving paths ##########
 558  */
 559
 560 /*************************************************************************
 561  * PathFindOnPath       [SHELL32.145]
 562  */
 563 BOOL WINAPI PathFindOnPathAW(LPVOID sFile, LPCVOID *sOtherDirs)
 564 {
 565         if (SHELL_OsIsUnicode())
 566           return PathFindOnPathW(sFile, (LPCWSTR *)sOtherDirs);
 567         return PathFindOnPathA(sFile, (LPCSTR *)sOtherDirs);
 568 }
 569
 570 /*************************************************************************
 571  * PathCleanupSpec      [SHELL32.171]
 572  *
 573  * lpszFile is changed in place.
 574  */
 575 int WINAPI PathCleanupSpec( LPCWSTR lpszPathW, LPWSTR lpszFileW )
 576 {
 577     int i = 0;
 578     DWORD rc = 0;
 579     int length = 0;
 580
 581     if (SHELL_OsIsUnicode())
 582     {
 583         LPWSTR p = lpszFileW;
 584
 585         TRACE("Cleanup %s\n",debugstr_w(lpszFileW));
 586
 587         if (lpszPathW)
 588             length = strlenW(lpszPathW);
 589
 590         while (*p)
 591         {
 592             int gct = PathGetCharTypeW(*p);
 593             if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
 594             {
 595                 lpszFileW[i]='-';
 596                 rc |= PCS_REPLACEDCHAR;
 597             }
 598             else
 599                 lpszFileW[i]=*p;
 600             i++;
 601             p++;
 602             if (length + i == MAX_PATH)
 603             {
 604                 rc |= PCS_FATAL | PCS_PATHTOOLONG;
 605                 break;
 606             }
 607         }
 608         lpszFileW[i]=0;
 609     }
 610     else
 611     {
 612         LPSTR lpszFileA = (LPSTR)lpszFileW;
 613         LPCSTR lpszPathA = (LPCSTR)lpszPathW;
 614         LPSTR p = lpszFileA;
 615
 616         TRACE("Cleanup %s\n",debugstr_a(lpszFileA));
 617
 618         if (lpszPathA)
 619             length = strlen(lpszPathA);
 620
 621         while (*p)
 622         {
 623             int gct = PathGetCharTypeA(*p);
 624             if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
 625             {
 626                 lpszFileA[i]='-';
 627                 rc |= PCS_REPLACEDCHAR;
 628             }
 629             else
 630                 lpszFileA[i]=*p;
 631             i++;
 632             p++;
 633             if (length + i == MAX_PATH)
 634             {
 635                 rc |= PCS_FATAL | PCS_PATHTOOLONG;
 636                 break;
 637             }
 638         }
 639         lpszFileA[i]=0;
 640     }
 641     return rc;
 642 }
 643
 644 /*************************************************************************
 645  * PathQualifyA         [SHELL32]
 646  */
 647 static BOOL PathQualifyA(LPCSTR pszPath)
 648 {
 649         FIXME("%s\n",pszPath);
 650         return 0;
 651 }
 652
 653 /*************************************************************************
 654  * PathQualifyW         [SHELL32]
 655  */
 656 static BOOL PathQualifyW(LPCWSTR pszPath)
 657 {
 658         FIXME("%s\n",debugstr_w(pszPath));
 659         return 0;
 660 }
 661
 662 /*************************************************************************
 663  * PathQualify  [SHELL32.49]
 664  */
 665 BOOL WINAPI PathQualifyAW(LPCVOID pszPath)
 666 {
 667         if (SHELL_OsIsUnicode())
 668           return PathQualifyW(pszPath);
 669         return PathQualifyA(pszPath);
 670 }
 671
 672 static BOOL PathResolveA(LPSTR path, LPCSTR *paths, DWORD flags)
 673 {
 674     FIXME("(%s,%p,0x%08x),stub!\n", debugstr_a(path), paths, flags);
 675     return FALSE;
 676 }
 677
 678 static BOOL PathResolveW(LPWSTR path, LPCWSTR *paths, DWORD flags)
 679 {
 680     FIXME("(%s,%p,0x%08x),stub!\n", debugstr_w(path), paths, flags);
 681     return FALSE;
 682 }
 683
 684 /*************************************************************************
 685  * PathResolve [SHELL32.51]
 686  */
 687 BOOL WINAPI PathResolveAW(LPVOID path, LPCVOID *paths, DWORD flags)
 688 {
 689     if (SHELL_OsIsUnicode())
 690         return PathResolveW(path, (LPCWSTR*)paths, flags);
 691     else
 692         return PathResolveA(path, (LPCSTR*)paths, flags);
 693 }
 694
 695 /*************************************************************************
 696 *       PathProcessCommandA
 697 */
 698 static LONG PathProcessCommandA (
 699         LPCSTR lpszPath,
 700         LPSTR lpszBuff,
 701         DWORD dwBuffSize,
 702         DWORD dwFlags)
 703 {
 704         FIXME("%s %p 0x%04x 0x%04x stub\n",
 705         lpszPath, lpszBuff, dwBuffSize, dwFlags);
 706         if(!lpszPath) return -1;
 707         if(lpszBuff) strcpy(lpszBuff, lpszPath);
 708         return strlen(lpszPath);
 709 }
 710
 711 /*************************************************************************
 712 *       PathProcessCommandW
 713 */
 714 static LONG PathProcessCommandW (
 715         LPCWSTR lpszPath,
 716         LPWSTR lpszBuff,
 717         DWORD dwBuffSize,
 718         DWORD dwFlags)
 719 {
 720         FIXME("(%s, %p, 0x%04x, 0x%04x) stub\n",
 721         debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
 722         if(!lpszPath) return -1;
 723         if(lpszBuff) strcpyW(lpszBuff, lpszPath);
 724         return strlenW(lpszPath);
 725 }
 726
 727 /*************************************************************************
 728 *       PathProcessCommand (SHELL32.653)
 729 */
 730 LONG WINAPI PathProcessCommandAW (
 731         LPCVOID lpszPath,
 732         LPVOID lpszBuff,
 733         DWORD dwBuffSize,
 734         DWORD dwFlags)
 735 {
 736         if (SHELL_OsIsUnicode())
 737           return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
 738         return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
 739 }
 740
 741 /*
 742         ########## special ##########
 743 */
 744
 745 /*************************************************************************
 746  * PathSetDlgItemPath (SHELL32.48)
 747  */
 748 VOID WINAPI PathSetDlgItemPathAW(HWND hDlg, int id, LPCVOID pszPath)
 749 {
 750         if (SHELL_OsIsUnicode())
 751             PathSetDlgItemPathW(hDlg, id, pszPath);
 752         else
 753             PathSetDlgItemPathA(hDlg, id, pszPath);
 754 }
 755
 756 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'};
 757 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'};
 758 static const WCHAR AppDataW[] = {'A','p','p','D','a','t','a','\0'};
 759 static const WCHAR CacheW[] = {'C','a','c','h','e','\0'};
 760 static const WCHAR CD_BurningW[] = {'C','D',' ','B','u','r','n','i','n','g','\0'};
 761 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'};
 762 static const WCHAR Common_AppDataW[] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'};
 763 static const WCHAR Common_DesktopW[] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'};
 764 static const WCHAR Common_DocumentsW[] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'};
 765 static const WCHAR Common_FavoritesW[] = {'C','o','m','m','o','n',' ','F','a','v','o','r','i','t','e','s','\0'};
 766 static const WCHAR CommonFilesDirW[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'};
 767 static const WCHAR CommonFilesDirX86W[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',' ','(','x','8','6',')','\0'};
 768 static const WCHAR CommonMusicW[] = {'C','o','m','m','o','n','M','u','s','i','c','\0'};
 769 static const WCHAR CommonPicturesW[] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'};
 770 static const WCHAR Common_ProgramsW[] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'};
 771 static const WCHAR Common_StartUpW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'};
 772 static const WCHAR Common_Start_MenuW[] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'};
 773 static const WCHAR Common_TemplatesW[] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'};
 774 static const WCHAR CommonVideoW[] = {'C','o','m','m','o','n','V','i','d','e','o','\0'};
 775 static const WCHAR ContactsW[] = {'C','o','n','t','a','c','t','s','\0'};
 776 static const WCHAR CookiesW[] = {'C','o','o','k','i','e','s','\0'};
 777 static const WCHAR DesktopW[] = {'D','e','s','k','t','o','p','\0'};
 778 static const WCHAR FavoritesW[] = {'F','a','v','o','r','i','t','e','s','\0'};
 779 static const WCHAR FontsW[] = {'F','o','n','t','s','\0'};
 780 static const WCHAR HistoryW[] = {'H','i','s','t','o','r','y','\0'};
 781 static const WCHAR Local_AppDataW[] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'};
 782 static const WCHAR My_MusicW[] = {'M','y',' ','M','u','s','i','c','\0'};
 783 static const WCHAR My_PicturesW[] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'};
 784 static const WCHAR My_VideoW[] = {'M','y',' ','V','i','d','e','o','s','\0'};
 785 static const WCHAR NetHoodW[] = {'N','e','t','H','o','o','d','\0'};
 786 static const WCHAR PersonalW[] = {'P','e','r','s','o','n','a','l','\0'};
 787 static const WCHAR PrintHoodW[] = {'P','r','i','n','t','H','o','o','d','\0'};
 788 static const WCHAR ProgramFilesDirW[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'};
 789 static const WCHAR ProgramFilesDirX86W[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r',' ','(','x','8','6',')','\0'};
 790 static const WCHAR ProgramsW[] = {'P','r','o','g','r','a','m','s','\0'};
 791 static const WCHAR RecentW[] = {'R','e','c','e','n','t','\0'};
 792 static const WCHAR ResourcesW[] = {'R','e','s','o','u','r','c','e','s','\0'};
 793 static const WCHAR SendToW[] = {'S','e','n','d','T','o','\0'};
 794 static const WCHAR StartUpW[] = {'S','t','a','r','t','U','p','\0'};
 795 static const WCHAR Start_MenuW[] = {'S','t','a','r','t',' ','M','e','n','u','\0'};
 796 static const WCHAR TemplatesW[] = {'T','e','m','p','l','a','t','e','s','\0'};
 797 static const WCHAR UsersW[] = {'U','s','e','r','s','\0'};
 798 static const WCHAR UsersPublicW[] = {'U','s','e','r','s','\\','P','u','b','l','i','c','\0'};
 799 static const WCHAR DefaultW[] = {'.','D','e','f','a','u','l','t','\0'};
 800 static const WCHAR AllUsersProfileW[] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%','\0'};
 801 static const WCHAR UserProfileW[] = {'%','U','S','E','R','P','R','O','F','I','L','E','%','\0'};
 802 static const WCHAR SystemDriveW[] = {'%','S','y','s','t','e','m','D','r','i','v','e','%','\0'};
 803 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};
 804 static const WCHAR ProfilesDirectoryW[] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0};
 805 static const WCHAR AllUsersProfileValueW[] = {'A','l','l','U','s','e','r','s','P','r','o','f','i','l','e','\0'};
 806 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'};
 807 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'};
 808 static const WCHAR szDefaultProfileDirW[] = {'u','s','e','r','s',0};
 809 static const WCHAR szKnownFolderDescriptions[] = {'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','\\','F','o','l','d','e','r','D','e','s','c','r','i','p','t','i','o','n','s','\0'};
 810 static const WCHAR szKnownFolderRedirections[] = {'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};
 811 static const WCHAR AllUsersW[] = {'P','u','b','l','i','c',0};
 812
 813 typedef enum _CSIDL_Type {
 814     CSIDL_Type_User,
 815     CSIDL_Type_AllUsers,
 816     CSIDL_Type_CurrVer,
 817     CSIDL_Type_Disallowed,
 818     CSIDL_Type_NonExistent,
 819     CSIDL_Type_WindowsPath,
 820     CSIDL_Type_SystemPath,
 821     CSIDL_Type_SystemX86Path,
 822 } CSIDL_Type;
 823
 824 typedef struct
 825 {
 826     const KNOWNFOLDERID *id;
 827     CSIDL_Type type;
 828     LPCWSTR    szValueName;
 829     LPCWSTR    szDefaultPath; /* fallback string or resource ID */
 830 } CSIDL_DATA;
 831
 832 static const CSIDL_DATA CSIDL_Data[] =
 833 {
 834     { /* 0x00 - CSIDL_DESKTOP */
 835         &FOLDERID_Desktop,
 836         CSIDL_Type_User,
 837         DesktopW,
 838         MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
 839     },
 840     { /* 0x01 - CSIDL_INTERNET */
 841         &FOLDERID_InternetFolder,
 842         CSIDL_Type_Disallowed,
 843         NULL,
 844         NULL
 845     },
 846     { /* 0x02 - CSIDL_PROGRAMS */
 847         &FOLDERID_Programs,
 848         CSIDL_Type_User,
 849         ProgramsW,
 850         MAKEINTRESOURCEW(IDS_PROGRAMS)
 851     },
 852     { /* 0x03 - CSIDL_CONTROLS (.CPL files) */
 853         &FOLDERID_ControlPanelFolder,
 854         CSIDL_Type_SystemPath,
 855         NULL,
 856         NULL
 857     },
 858     { /* 0x04 - CSIDL_PRINTERS */
 859         &FOLDERID_PrintersFolder,
 860         CSIDL_Type_SystemPath,
 861         NULL,
 862         NULL
 863     },
 864     { /* 0x05 - CSIDL_PERSONAL */
 865         &FOLDERID_Documents,
 866         CSIDL_Type_User,
 867         PersonalW,
 868         MAKEINTRESOURCEW(IDS_PERSONAL)
 869     },
 870     { /* 0x06 - CSIDL_FAVORITES */
 871         &FOLDERID_Favorites,
 872         CSIDL_Type_User,
 873         FavoritesW,
 874         MAKEINTRESOURCEW(IDS_FAVORITES)
 875     },
 876     { /* 0x07 - CSIDL_STARTUP */
 877         &FOLDERID_Startup,
 878         CSIDL_Type_User,
 879         StartUpW,
 880         MAKEINTRESOURCEW(IDS_STARTUP)
 881     },
 882     { /* 0x08 - CSIDL_RECENT */
 883         &FOLDERID_Recent,
 884         CSIDL_Type_User,
 885         RecentW,
 886         MAKEINTRESOURCEW(IDS_RECENT)
 887     },
 888     { /* 0x09 - CSIDL_SENDTO */
 889         &FOLDERID_SendTo,
 890         CSIDL_Type_User,
 891         SendToW,
 892         MAKEINTRESOURCEW(IDS_SENDTO)
 893     },
 894     { /* 0x0a - CSIDL_BITBUCKET - Recycle Bin */
 895         &FOLDERID_RecycleBinFolder,
 896         CSIDL_Type_Disallowed,
 897         NULL,
 898         NULL,
 899     },
 900     { /* 0x0b - CSIDL_STARTMENU */
 901         &FOLDERID_StartMenu,
 902         CSIDL_Type_User,
 903         Start_MenuW,
 904         MAKEINTRESOURCEW(IDS_STARTMENU)
 905     },
 906     { /* 0x0c - CSIDL_MYDOCUMENTS */
 907         &GUID_NULL,
 908         CSIDL_Type_Disallowed, /* matches WinXP--can't get its path */
 909         NULL,
 910         NULL
 911     },
 912     { /* 0x0d - CSIDL_MYMUSIC */
 913         &FOLDERID_Music,
 914         CSIDL_Type_User,
 915         My_MusicW,
 916         MAKEINTRESOURCEW(IDS_MYMUSIC)
 917     },
 918     { /* 0x0e - CSIDL_MYVIDEO */
 919         &FOLDERID_Videos,
 920         CSIDL_Type_User,
 921         My_VideoW,
 922         MAKEINTRESOURCEW(IDS_MYVIDEO)
 923     },
 924     { /* 0x0f - unassigned */
 925         &GUID_NULL,
 926         CSIDL_Type_Disallowed,
 927         NULL,
 928         NULL,
 929     },
 930     { /* 0x10 - CSIDL_DESKTOPDIRECTORY */
 931         &FOLDERID_Desktop,
 932         CSIDL_Type_User,
 933         DesktopW,
 934         MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
 935     },
 936     { /* 0x11 - CSIDL_DRIVES */
 937         &FOLDERID_ComputerFolder,
 938         CSIDL_Type_Disallowed,
 939         NULL,
 940         NULL,
 941     },
 942     { /* 0x12 - CSIDL_NETWORK */
 943         &FOLDERID_NetworkFolder,
 944         CSIDL_Type_Disallowed,
 945         NULL,
 946         NULL,
 947     },
 948     { /* 0x13 - CSIDL_NETHOOD */
 949         &FOLDERID_NetHood,
 950         CSIDL_Type_User,
 951         NetHoodW,
 952         MAKEINTRESOURCEW(IDS_NETHOOD)
 953     },
 954     { /* 0x14 - CSIDL_FONTS */
 955         &FOLDERID_Fonts,
 956         CSIDL_Type_WindowsPath,
 957         FontsW,
 958         FontsW
 959     },
 960     { /* 0x15 - CSIDL_TEMPLATES */
 961         &FOLDERID_Templates,
 962         CSIDL_Type_User,
 963         TemplatesW,
 964         MAKEINTRESOURCEW(IDS_TEMPLATES)
 965     },
 966     { /* 0x16 - CSIDL_COMMON_STARTMENU */
 967         &FOLDERID_CommonStartMenu,
 968         CSIDL_Type_AllUsers,
 969         Common_Start_MenuW,
 970         MAKEINTRESOURCEW(IDS_STARTMENU)
 971     },
 972     { /* 0x17 - CSIDL_COMMON_PROGRAMS */
 973         &FOLDERID_CommonPrograms,
 974         CSIDL_Type_AllUsers,
 975         Common_ProgramsW,
 976         MAKEINTRESOURCEW(IDS_PROGRAMS)
 977     },
 978     { /* 0x18 - CSIDL_COMMON_STARTUP */
 979         &FOLDERID_CommonStartup,
 980         CSIDL_Type_AllUsers,
 981         Common_StartUpW,
 982         MAKEINTRESOURCEW(IDS_STARTUP)
 983     },
 984     { /* 0x19 - CSIDL_COMMON_DESKTOPDIRECTORY */
 985         &FOLDERID_PublicDesktop,
 986         CSIDL_Type_AllUsers,
 987         Common_DesktopW,
 988         MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY)
 989     },
 990     { /* 0x1a - CSIDL_APPDATA */
 991         &FOLDERID_RoamingAppData,
 992         CSIDL_Type_User,
 993         AppDataW,
 994         MAKEINTRESOURCEW(IDS_APPDATA)
 995     },
 996     { /* 0x1b - CSIDL_PRINTHOOD */
 997         &FOLDERID_PrintHood,
 998         CSIDL_Type_User,
 999         PrintHoodW,
1000         MAKEINTRESOURCEW(IDS_PRINTHOOD)
1001     },
1002     { /* 0x1c - CSIDL_LOCAL_APPDATA */
1003         &FOLDERID_LocalAppData,
1004         CSIDL_Type_User,
1005         Local_AppDataW,
1006         MAKEINTRESOURCEW(IDS_LOCAL_APPDATA)
1007     },
1008     { /* 0x1d - CSIDL_ALTSTARTUP */
1009         &GUID_NULL,
1010         CSIDL_Type_NonExistent,
1011         NULL,
1012         NULL
1013     },
1014     { /* 0x1e - CSIDL_COMMON_ALTSTARTUP */
1015         &GUID_NULL,
1016         CSIDL_Type_NonExistent,
1017         NULL,
1018         NULL
1019     },
1020     { /* 0x1f - CSIDL_COMMON_FAVORITES */
1021         &FOLDERID_Favorites,
1022         CSIDL_Type_AllUsers,
1023         Common_FavoritesW,
1024         MAKEINTRESOURCEW(IDS_FAVORITES)
1025     },
1026     { /* 0x20 - CSIDL_INTERNET_CACHE */
1027         &FOLDERID_InternetCache,
1028         CSIDL_Type_User,
1029         CacheW,
1030         MAKEINTRESOURCEW(IDS_INTERNET_CACHE)
1031     },
1032     { /* 0x21 - CSIDL_COOKIES */
1033         &FOLDERID_Cookies,
1034         CSIDL_Type_User,
1035         CookiesW,
1036         MAKEINTRESOURCEW(IDS_COOKIES)
1037     },
1038     { /* 0x22 - CSIDL_HISTORY */
1039         &FOLDERID_History,
1040         CSIDL_Type_User,
1041         HistoryW,
1042         MAKEINTRESOURCEW(IDS_HISTORY)
1043     },
1044     { /* 0x23 - CSIDL_COMMON_APPDATA */
1045         &FOLDERID_ProgramData,
1046         CSIDL_Type_AllUsers,
1047         Common_AppDataW,
1048         MAKEINTRESOURCEW(IDS_APPDATA)
1049     },
1050     { /* 0x24 - CSIDL_WINDOWS */
1051         &FOLDERID_Windows,
1052         CSIDL_Type_WindowsPath,
1053         NULL,
1054         NULL
1055     },
1056     { /* 0x25 - CSIDL_SYSTEM */
1057         &FOLDERID_System,
1058         CSIDL_Type_SystemPath,
1059         NULL,
1060         NULL
1061     },
1062     { /* 0x26 - CSIDL_PROGRAM_FILES */
1063         &FOLDERID_ProgramFiles,
1064         CSIDL_Type_CurrVer,
1065         ProgramFilesDirW,
1066         MAKEINTRESOURCEW(IDS_PROGRAM_FILES)
1067     },
1068     { /* 0x27 - CSIDL_MYPICTURES */
1069         &FOLDERID_Pictures,
1070         CSIDL_Type_User,
1071         My_PicturesW,
1072         MAKEINTRESOURCEW(IDS_MYPICTURES)
1073     },
1074     { /* 0x28 - CSIDL_PROFILE */
1075         &FOLDERID_Profile,
1076         CSIDL_Type_User,
1077         NULL,
1078         NULL
1079     },
1080     { /* 0x29 - CSIDL_SYSTEMX86 */
1081         &FOLDERID_SystemX86,
1082         CSIDL_Type_SystemX86Path,
1083         NULL,
1084         NULL
1085     },
1086     { /* 0x2a - CSIDL_PROGRAM_FILESX86 */
1087         &FOLDERID_ProgramFilesX86,
1088         CSIDL_Type_CurrVer,
1089         ProgramFilesDirX86W,
1090         MAKEINTRESOURCEW(IDS_PROGRAM_FILESX86)
1091     },
1092     { /* 0x2b - CSIDL_PROGRAM_FILES_COMMON */
1093         &FOLDERID_ProgramFilesCommon,
1094         CSIDL_Type_CurrVer,
1095         CommonFilesDirW,
1096         MAKEINTRESOURCEW(IDS_PROGRAM_FILES_COMMON)
1097     },
1098     { /* 0x2c - CSIDL_PROGRAM_FILES_COMMONX86 */
1099         &FOLDERID_ProgramFilesCommonX86,
1100         CSIDL_Type_CurrVer,
1101         CommonFilesDirX86W,
1102         MAKEINTRESOURCEW(IDS_PROGRAM_FILES_COMMONX86)
1103     },
1104     { /* 0x2d - CSIDL_COMMON_TEMPLATES */
1105         &FOLDERID_CommonTemplates,
1106         CSIDL_Type_AllUsers,
1107         Common_TemplatesW,
1108         MAKEINTRESOURCEW(IDS_TEMPLATES)
1109     },
1110     { /* 0x2e - CSIDL_COMMON_DOCUMENTS */
1111         &FOLDERID_PublicDocuments,
1112         CSIDL_Type_AllUsers,
1113         Common_DocumentsW,
1114         MAKEINTRESOURCEW(IDS_COMMON_DOCUMENTS)
1115     },
1116     { /* 0x2f - CSIDL_COMMON_ADMINTOOLS */
1117         &FOLDERID_CommonAdminTools,
1118         CSIDL_Type_AllUsers,
1119         Common_Administrative_ToolsW,
1120         MAKEINTRESOURCEW(IDS_ADMINTOOLS)
1121     },
1122     { /* 0x30 - CSIDL_ADMINTOOLS */
1123         &FOLDERID_AdminTools,
1124         CSIDL_Type_User,
1125         Administrative_ToolsW,
1126         MAKEINTRESOURCEW(IDS_ADMINTOOLS)
1127     },
1128     { /* 0x31 - CSIDL_CONNECTIONS */
1129         &FOLDERID_ConnectionsFolder,
1130         CSIDL_Type_Disallowed,
1131         NULL,
1132         NULL
1133     },
1134     { /* 0x32 - unassigned */
1135         &GUID_NULL,
1136         CSIDL_Type_Disallowed,
1137         NULL,
1138         NULL
1139     },
1140     { /* 0x33 - unassigned */
1141         &GUID_NULL,
1142         CSIDL_Type_Disallowed,
1143         NULL,
1144         NULL
1145     },
1146     { /* 0x34 - unassigned */
1147         &GUID_NULL,
1148         CSIDL_Type_Disallowed,
1149         NULL,
1150         NULL
1151     },
1152     { /* 0x35 - CSIDL_COMMON_MUSIC */
1153         &FOLDERID_PublicMusic,
1154         CSIDL_Type_AllUsers,
1155         CommonMusicW,
1156         MAKEINTRESOURCEW(IDS_COMMON_MUSIC)
1157     },
1158     { /* 0x36 - CSIDL_COMMON_PICTURES */
1159         &FOLDERID_PublicPictures,
1160         CSIDL_Type_AllUsers,
1161         CommonPicturesW,
1162         MAKEINTRESOURCEW(IDS_COMMON_PICTURES)
1163     },
1164     { /* 0x37 - CSIDL_COMMON_VIDEO */
1165         &FOLDERID_PublicVideos,
1166         CSIDL_Type_AllUsers,
1167         CommonVideoW,
1168         MAKEINTRESOURCEW(IDS_COMMON_VIDEO)
1169     },
1170     { /* 0x38 - CSIDL_RESOURCES */
1171         &FOLDERID_ResourceDir,
1172         CSIDL_Type_WindowsPath,
1173         NULL,
1174         ResourcesW
1175     },
1176     { /* 0x39 - CSIDL_RESOURCES_LOCALIZED */
1177         &FOLDERID_LocalizedResourcesDir,
1178         CSIDL_Type_NonExistent,
1179         NULL,
1180         NULL
1181     },
1182     { /* 0x3a - CSIDL_COMMON_OEM_LINKS */
1183         &FOLDERID_CommonOEMLinks,
1184         CSIDL_Type_AllUsers,
1185         NULL,
1186         MAKEINTRESOURCEW(IDS_COMMON_OEM_LINKS)
1187     },
1188     { /* 0x3b - CSIDL_CDBURN_AREA */
1189         &FOLDERID_CDBurning,
1190         CSIDL_Type_User,
1191         CD_BurningW,
1192         MAKEINTRESOURCEW(IDS_CDBURN_AREA)
1193     },
1194     { /* 0x3c unassigned */
1195         &GUID_NULL,
1196         CSIDL_Type_Disallowed,
1197         NULL,
1198         NULL
1199     },
1200     { /* 0x3d - CSIDL_COMPUTERSNEARME */
1201         &GUID_NULL,
1202         CSIDL_Type_Disallowed, /* FIXME */
1203         NULL,
1204         NULL
1205     },
1206     { /* 0x3e - CSIDL_PROFILES */
1207         &GUID_NULL,
1208         CSIDL_Type_Disallowed, /* oddly, this matches WinXP */
1209         NULL,
1210         NULL
1211     },
1212     { /* 0x3f */
1213         &FOLDERID_AddNewPrograms,
1214         CSIDL_Type_Disallowed,
1215         NULL,
1216         NULL
1217     },
1218     { /* 0x40 */
1219         &FOLDERID_AppUpdates,
1220         CSIDL_Type_Disallowed,
1221         NULL,
1222         NULL
1223     },
1224     { /* 0x41 */
1225         &FOLDERID_ChangeRemovePrograms,
1226         CSIDL_Type_Disallowed,
1227         NULL,
1228         NULL
1229     },
1230     { /* 0x42 */
1231         &FOLDERID_ConflictFolder,
1232         CSIDL_Type_Disallowed,
1233         NULL,
1234         NULL
1235     },
1236     { /* 0x43 */
1237         &FOLDERID_Contacts,
1238         CSIDL_Type_User,
1239         ContactsW,
1240         MAKEINTRESOURCEW(IDS_CONTACTS)
1241     },
1242     { /* 0x44 */
1243         &FOLDERID_DeviceMetadataStore,
1244         CSIDL_Type_Disallowed, /* FIXME */
1245         NULL,
1246         NULL
1247     },
1248     { /* 0x45 */
1249         &GUID_NULL,
1250         CSIDL_Type_User,
1251         NULL,
1252         MAKEINTRESOURCEW(IDS_DOCUMENTS)
1253     },
1254     { /* 0x46 */
1255         &FOLDERID_DocumentsLibrary,
1256         CSIDL_Type_Disallowed, /* FIXME */
1257         NULL,
1258         NULL
1259     },
1260     { /* 0x47 */
1261         &FOLDERID_Downloads,
1262         CSIDL_Type_User,
1263         NULL,
1264         MAKEINTRESOURCEW(IDS_DOWNLOADS)
1265     },
1266     { /* 0x48 */
1267         &FOLDERID_Games,
1268         CSIDL_Type_Disallowed,
1269         NULL,
1270         NULL
1271     },
1272     { /* 0x49 */
1273         &FOLDERID_GameTasks,
1274         CSIDL_Type_Disallowed, /* FIXME */
1275         NULL,
1276         NULL
1277     },
1278     { /* 0x4a */
1279         &FOLDERID_HomeGroup,
1280         CSIDL_Type_Disallowed,
1281         NULL,
1282         NULL
1283     },
1284     { /* 0x4b */
1285         &FOLDERID_ImplicitAppShortcuts,
1286         CSIDL_Type_Disallowed, /* FIXME */
1287         NULL,
1288         NULL
1289     },
1290     { /* 0x4c */
1291         &FOLDERID_Libraries,
1292         CSIDL_Type_Disallowed, /* FIXME */
1293         NULL,
1294         NULL
1295     },
1296     { /* 0x4d */
1297         &FOLDERID_Links,
1298         CSIDL_Type_User,
1299         NULL,
1300         MAKEINTRESOURCEW(IDS_LINKS)
1301     },
1302     { /* 0x4e */
1303         &FOLDERID_LocalAppDataLow,
1304         CSIDL_Type_User,
1305         NULL,
1306         MAKEINTRESOURCEW(IDS_LOCAL_APPDATA_LOW)
1307     },
1308     { /* 0x4f */
1309         &FOLDERID_MusicLibrary,
1310         CSIDL_Type_Disallowed, /* FIXME */
1311         NULL,
1312         NULL
1313     },
1314     { /* 0x50 */
1315         &FOLDERID_OriginalImages,
1316         CSIDL_Type_Disallowed, /* FIXME */
1317         NULL,
1318         NULL
1319     },
1320     { /* 0x51 */
1321         &FOLDERID_PhotoAlbums,
1322         CSIDL_Type_User,
1323         NULL,
1324         MAKEINTRESOURCEW(IDS_PHOTO_ALBUMS)
1325     },
1326     { /* 0x52 */
1327         &FOLDERID_PicturesLibrary,
1328         CSIDL_Type_Disallowed, /* FIXME */
1329         NULL,
1330         NULL
1331     },
1332     { /* 0x53 */
1333         &FOLDERID_Playlists,
1334         CSIDL_Type_User,
1335         NULL,
1336         MAKEINTRESOURCEW(IDS_PLAYLISTS)
1337     },
1338     { /* 0x54 */
1339         &FOLDERID_ProgramFilesX64,
1340         CSIDL_Type_NonExistent,
1341         NULL,
1342         NULL
1343     },
1344     { /* 0x55 */
1345         &FOLDERID_ProgramFilesCommonX64,
1346         CSIDL_Type_NonExistent,
1347         NULL,
1348         NULL
1349     },
1350     { /* 0x56 */
1351         &FOLDERID_Public,
1352         CSIDL_Type_CurrVer, /* FIXME */
1353         NULL,
1354         UsersPublicW
1355     },
1356     { /* 0x57 */
1357         &FOLDERID_PublicDownloads,
1358         CSIDL_Type_AllUsers,
1359         NULL,
1360         MAKEINTRESOURCEW(IDS_PUBLIC_DOWNLOADS)
1361     },
1362     { /* 0x58 */
1363         &FOLDERID_PublicGameTasks,
1364         CSIDL_Type_AllUsers,
1365         NULL,
1366         MAKEINTRESOURCEW(IDS_PUBLIC_GAME_TASKS)
1367     },
1368     { /* 0x59 */
1369         &FOLDERID_PublicLibraries,
1370         CSIDL_Type_AllUsers,
1371         NULL,
1372         MAKEINTRESOURCEW(IDS_PUBLIC_LIBRARIES)
1373     },
1374     { /* 0x5a */
1375         &FOLDERID_PublicRingtones,
1376         CSIDL_Type_AllUsers,
1377         NULL,
1378         MAKEINTRESOURCEW(IDS_PUBLIC_RINGTONES)
1379     },
1380     { /* 0x5b */
1381         &FOLDERID_QuickLaunch,
1382         CSIDL_Type_Disallowed, /* FIXME */
1383         NULL,
1384         NULL
1385     },
1386     { /* 0x5c */
1387         &FOLDERID_RecordedTVLibrary,
1388         CSIDL_Type_Disallowed, /* FIXME */
1389         NULL,
1390         NULL
1391     },
1392     { /* 0x5d */
1393         &FOLDERID_Ringtones,
1394         CSIDL_Type_Disallowed, /* FIXME */
1395         NULL,
1396         NULL
1397     },
1398     { /* 0x5e */
1399         &FOLDERID_SampleMusic,
1400         CSIDL_Type_AllUsers,
1401         NULL,
1402         MAKEINTRESOURCEW(IDS_SAMPLE_MUSIC)
1403     },
1404     { /* 0x5f */
1405         &FOLDERID_SamplePictures,
1406         CSIDL_Type_AllUsers,
1407         NULL,
1408         MAKEINTRESOURCEW(IDS_SAMPLE_PICTURES)
1409     },
1410     { /* 0x60 */
1411         &FOLDERID_SamplePlaylists,
1412         CSIDL_Type_AllUsers,
1413         NULL,
1414         MAKEINTRESOURCEW(IDS_SAMPLE_PLAYLISTS)
1415     },
1416     { /* 0x61 */
1417         &FOLDERID_SampleVideos,
1418         CSIDL_Type_AllUsers,
1419         NULL,
1420         MAKEINTRESOURCEW(IDS_SAMPLE_VIDEOS)
1421     },
1422     { /* 0x62 */
1423         &FOLDERID_SavedGames,
1424         CSIDL_Type_User,
1425         NULL,
1426         MAKEINTRESOURCEW(IDS_SAVED_GAMES)
1427     },
1428     { /* 0x63 */
1429         &FOLDERID_SavedSearches,
1430         CSIDL_Type_User,
1431         NULL,
1432         MAKEINTRESOURCEW(IDS_SAVED_SEARCHES)
1433     },
1434     { /* 0x64 */
1435         &FOLDERID_SEARCH_CSC,
1436         CSIDL_Type_Disallowed,
1437         NULL,
1438         NULL
1439     },
1440     { /* 0x65 */
1441         &FOLDERID_SEARCH_MAPI,
1442         CSIDL_Type_Disallowed,
1443         NULL,
1444         NULL
1445     },
1446     { /* 0x66 */
1447         &FOLDERID_SearchHome,
1448         CSIDL_Type_Disallowed,
1449         NULL,
1450         NULL
1451     },
1452     { /* 0x67 */
1453         &FOLDERID_SidebarDefaultParts,
1454         CSIDL_Type_Disallowed, /* FIXME */
1455         NULL,
1456         NULL
1457     },
1458     { /* 0x68 */
1459         &FOLDERID_SidebarParts,
1460         CSIDL_Type_Disallowed, /* FIXME */
1461         NULL,
1462         NULL
1463     },
1464     { /* 0x69 */
1465         &FOLDERID_SyncManagerFolder,
1466         CSIDL_Type_Disallowed,
1467         NULL,
1468         NULL
1469     },
1470     { /* 0x6a */
1471         &FOLDERID_SyncResultsFolder,
1472         CSIDL_Type_Disallowed,
1473         NULL,
1474         NULL
1475     },
1476     { /* 0x6b */
1477         &FOLDERID_SyncSetupFolder,
1478         CSIDL_Type_Disallowed,
1479         NULL,
1480         NULL
1481     },
1482     { /* 0x6c */
1483         &FOLDERID_UserPinned,
1484         CSIDL_Type_Disallowed, /* FIXME */
1485         NULL,
1486         NULL
1487     },
1488     { /* 0x6d */
1489         &FOLDERID_UserProfiles,
1490         CSIDL_Type_CurrVer,
1491         UsersW,
1492         MAKEINTRESOURCEW(IDS_USER_PROFILES)
1493     },
1494     { /* 0x6e */
1495         &FOLDERID_UserProgramFiles,
1496         CSIDL_Type_Disallowed, /* FIXME */
1497         NULL,
1498         NULL
1499     },
1500     { /* 0x6f */
1501         &FOLDERID_UserProgramFilesCommon,
1502         CSIDL_Type_Disallowed, /* FIXME */
1503         NULL,
1504         NULL
1505     },
1506     { /* 0x70 */
1507         &FOLDERID_UsersFiles,
1508         CSIDL_Type_Disallowed,
1509         NULL,
1510         NULL
1511     },
1512     { /* 0x71 */
1513         &FOLDERID_UsersLibraries,
1514         CSIDL_Type_Disallowed,
1515         NULL,
1516         NULL
1517     },
1518     { /* 0x72 */
1519         &FOLDERID_VideosLibrary,
1520         CSIDL_Type_Disallowed, /* FIXME */
1521         NULL,
1522         NULL
1523     }
1524 };
1525
1526 static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest);
1527
1528 /* Gets the value named value from the registry key
1529  * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
1530  * (or from rootKey\userPrefix\... if userPrefix is not NULL) into path, which
1531  * is assumed to be MAX_PATH WCHARs in length.
1532  * If it exists, expands the value and writes the expanded value to
1533  * rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
1534  * Returns successful error code if the value was retrieved from the registry,
1535  * and a failure otherwise.
1536  */
1537 static HRESULT _SHGetUserShellFolderPath(HKEY rootKey, LPCWSTR userPrefix,
1538  LPCWSTR value, LPWSTR path)
1539 {
1540     HRESULT hr;
1541     WCHAR shellFolderPath[MAX_PATH], userShellFolderPath[MAX_PATH];
1542     LPCWSTR pShellFolderPath, pUserShellFolderPath;
1543     DWORD dwType, dwPathLen = MAX_PATH;
1544     HKEY userShellFolderKey, shellFolderKey;
1545
1546     TRACE("%p,%s,%s,%p\n",rootKey, debugstr_w(userPrefix), debugstr_w(value),
1547      path);
1548
1549     if (userPrefix)
1550     {
1551         strcpyW(shellFolderPath, userPrefix);
1552         PathAddBackslashW(shellFolderPath);
1553         strcatW(shellFolderPath, szSHFolders);
1554         pShellFolderPath = shellFolderPath;
1555         strcpyW(userShellFolderPath, userPrefix);
1556         PathAddBackslashW(userShellFolderPath);
1557         strcatW(userShellFolderPath, szSHUserFolders);
1558         pUserShellFolderPath = userShellFolderPath;
1559     }
1560     else
1561     {
1562         pUserShellFolderPath = szSHUserFolders;
1563         pShellFolderPath = szSHFolders;
1564     }
1565
1566     if (RegCreateKeyW(rootKey, pShellFolderPath, &shellFolderKey))
1567     {
1568         TRACE("Failed to create %s\n", debugstr_w(pShellFolderPath));
1569         return E_FAIL;
1570     }
1571     if (RegCreateKeyW(rootKey, pUserShellFolderPath, &userShellFolderKey))
1572     {
1573         TRACE("Failed to create %s\n",
1574          debugstr_w(pUserShellFolderPath));
1575         RegCloseKey(shellFolderKey);
1576         return E_FAIL;
1577     }
1578
1579     if (!RegQueryValueExW(userShellFolderKey, value, NULL, &dwType,
1580      (LPBYTE)path, &dwPathLen) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ))
1581     {
1582         LONG ret;
1583
1584         path[dwPathLen / sizeof(WCHAR)] = '\0';
1585         if (dwType == REG_EXPAND_SZ && path[0] == '%')
1586         {
1587             WCHAR szTemp[MAX_PATH];
1588
1589             _SHExpandEnvironmentStrings(path, szTemp);
1590             lstrcpynW(path, szTemp, MAX_PATH);
1591         }
1592         ret = RegSetValueExW(shellFolderKey, value, 0, REG_SZ, (LPBYTE)path,
1593          (strlenW(path) + 1) * sizeof(WCHAR));
1594         if (ret != ERROR_SUCCESS)
1595             hr = HRESULT_FROM_WIN32(ret);
1596         else
1597             hr = S_OK;
1598     }
1599     else
1600         hr = E_FAIL;
1601     RegCloseKey(shellFolderKey);
1602     RegCloseKey(userShellFolderKey);
1603     TRACE("returning 0x%08x\n", hr);
1604     return hr;
1605 }
1606
1607 /* Gets a 'semi-expanded' default value of the CSIDL with index folder into
1608  * pszPath, based on the entries in CSIDL_Data.  By semi-expanded, I mean:
1609  * - The entry's szDefaultPath may be either a string value or an integer
1610  *   resource identifier.  In the latter case, the string value of the resource
1611  *   is written.
1612  * - Depending on the entry's type, the path may begin with an (unexpanded)
1613  *   environment variable name.  The caller is responsible for expanding
1614  *   environment strings if so desired.
1615  *   The types that are prepended with environment variables are:
1616  *   CSIDL_Type_User:     %USERPROFILE%
1617  *   CSIDL_Type_AllUsers: %ALLUSERSPROFILE%
1618  *   CSIDL_Type_CurrVer:  %SystemDrive%
1619  *   (Others might make sense too, but as yet are unneeded.)
1620  */
1621 static HRESULT _SHGetDefaultValue(BYTE folder, LPWSTR pszPath)
1622 {
1623     HRESULT hr;
1624     WCHAR resourcePath[MAX_PATH];
1625     LPCWSTR pDefaultPath = NULL;
1626
1627     TRACE("0x%02x,%p\n", folder, pszPath);
1628
1629     if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1630         return E_INVALIDARG;
1631     if (!pszPath)
1632         return E_INVALIDARG;
1633
1634     if (!is_win64)
1635     {
1636         BOOL is_wow64;
1637
1638         switch (folder)
1639         {
1640         case CSIDL_PROGRAM_FILES:
1641         case CSIDL_PROGRAM_FILESX86:
1642             IsWow64Process( GetCurrentProcess(), &is_wow64 );
1643             folder = is_wow64 ? CSIDL_PROGRAM_FILESX86 : CSIDL_PROGRAM_FILES;
1644             break;
1645         case CSIDL_PROGRAM_FILES_COMMON:
1646         case CSIDL_PROGRAM_FILES_COMMONX86:
1647             IsWow64Process( GetCurrentProcess(), &is_wow64 );
1648             folder = is_wow64 ? CSIDL_PROGRAM_FILES_COMMONX86 : CSIDL_PROGRAM_FILES_COMMON;
1649             break;
1650         }
1651     }
1652
1653     if (CSIDL_Data[folder].szDefaultPath &&
1654      IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath))
1655     {
1656         if (LoadStringW(shell32_hInstance,
1657          LOWORD(CSIDL_Data[folder].szDefaultPath), resourcePath, MAX_PATH))
1658         {
1659             hr = S_OK;
1660             pDefaultPath = resourcePath;
1661         }
1662         else
1663         {
1664             FIXME("(%d,%s), LoadString failed, missing translation?\n", folder,
1665              debugstr_w(pszPath));
1666             hr = E_FAIL;
1667         }
1668     }
1669     else
1670     {
1671         hr = S_OK;
1672         pDefaultPath = CSIDL_Data[folder].szDefaultPath;
1673     }
1674     if (SUCCEEDED(hr))
1675     {
1676         switch (CSIDL_Data[folder].type)
1677         {
1678             case CSIDL_Type_User:
1679                 strcpyW(pszPath, UserProfileW);
1680                 break;
1681             case CSIDL_Type_AllUsers:
1682                 strcpyW(pszPath, AllUsersProfileW);
1683                 break;
1684             case CSIDL_Type_CurrVer:
1685                 strcpyW(pszPath, SystemDriveW);
1686                 break;
1687             default:
1688                 ; /* no corresponding env. var, do nothing */
1689         }
1690         if (pDefaultPath)
1691         {
1692             PathAddBackslashW(pszPath);
1693             strcatW(pszPath, pDefaultPath);
1694         }
1695     }
1696     TRACE("returning 0x%08x\n", hr);
1697     return hr;
1698 }
1699
1700 /* Gets the (unexpanded) value of the folder with index folder into pszPath.
1701  * The folder's type is assumed to be CSIDL_Type_CurrVer.  Its default value
1702  * can be overridden in the HKLM\\szCurrentVersion key.
1703  * If dwFlags has SHGFP_TYPE_DEFAULT set or if the value isn't overridden in
1704  * the registry, uses _SHGetDefaultValue to get the value.
1705  */
1706 static HRESULT _SHGetCurrentVersionPath(DWORD dwFlags, BYTE folder,
1707  LPWSTR pszPath)
1708 {
1709     HRESULT hr;
1710
1711     TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
1712
1713     if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1714         return E_INVALIDARG;
1715     if (CSIDL_Data[folder].type != CSIDL_Type_CurrVer)
1716         return E_INVALIDARG;
1717     if (!pszPath)
1718         return E_INVALIDARG;
1719
1720     if (dwFlags & SHGFP_TYPE_DEFAULT)
1721         hr = _SHGetDefaultValue(folder, pszPath);
1722     else
1723     {
1724         HKEY hKey;
1725
1726         if (RegCreateKeyW(HKEY_LOCAL_MACHINE, szCurrentVersion, &hKey))
1727             hr = E_FAIL;
1728         else
1729         {
1730             DWORD dwType, dwPathLen = MAX_PATH * sizeof(WCHAR);
1731
1732             if (RegQueryValueExW(hKey, CSIDL_Data[folder].szValueName, NULL,
1733              &dwType, (LPBYTE)pszPath, &dwPathLen) ||
1734              (dwType != REG_SZ && dwType != REG_EXPAND_SZ))
1735             {
1736                 hr = _SHGetDefaultValue(folder, pszPath);
1737                 dwType = REG_EXPAND_SZ;
1738                 switch (folder)
1739                 {
1740                 case CSIDL_PROGRAM_FILESX86:
1741                 case CSIDL_PROGRAM_FILES_COMMONX86:
1742                     /* these two should never be set on 32-bit setups */
1743                     if (!is_win64)
1744                     {
1745                         BOOL is_wow64;
1746                         IsWow64Process( GetCurrentProcess(), &is_wow64 );
1747                         if (!is_wow64) break;
1748                     }
1749                     /* fall through */
1750                 default:
1751                     RegSetValueExW(hKey, CSIDL_Data[folder].szValueName, 0, dwType,
1752                                    (LPBYTE)pszPath, (strlenW(pszPath)+1)*sizeof(WCHAR));
1753                 }
1754             }
1755             else
1756             {
1757                 pszPath[dwPathLen / sizeof(WCHAR)] = '\0';
1758                 hr = S_OK;
1759             }
1760             RegCloseKey(hKey);
1761         }
1762     }
1763     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1764     return hr;
1765 }
1766
1767 static LPWSTR _GetUserSidStringFromToken(HANDLE Token)
1768 {
1769     char InfoBuffer[64];
1770     PTOKEN_USER UserInfo;
1771     DWORD InfoSize;
1772     LPWSTR SidStr;
1773
1774     UserInfo = (PTOKEN_USER) InfoBuffer;
1775     if (! GetTokenInformation(Token, TokenUser, InfoBuffer, sizeof(InfoBuffer),
1776                               &InfoSize))
1777     {
1778         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1779             return NULL;
1780         UserInfo = HeapAlloc(GetProcessHeap(), 0, InfoSize);
1781         if (UserInfo == NULL)
1782             return NULL;
1783         if (! GetTokenInformation(Token, TokenUser, UserInfo, InfoSize,
1784                                   &InfoSize))
1785         {
1786             HeapFree(GetProcessHeap(), 0, UserInfo);
1787             return NULL;
1788         }
1789     }
1790
1791     if (! ConvertSidToStringSidW(UserInfo->User.Sid, &SidStr))
1792         SidStr = NULL;
1793
1794     if (UserInfo != (PTOKEN_USER) InfoBuffer)
1795         HeapFree(GetProcessHeap(), 0, UserInfo);
1796
1797     return SidStr;
1798 }
1799
1800 /* Gets the user's path (unexpanded) for the CSIDL with index folder:
1801  * If SHGFP_TYPE_DEFAULT is set, calls _SHGetDefaultValue for it.  Otherwise
1802  * calls _SHGetUserShellFolderPath for it.  Where it looks depends on hToken:
1803  * - if hToken is -1, looks in HKEY_USERS\.Default
1804  * - otherwise looks first in HKEY_CURRENT_USER, followed by HKEY_LOCAL_MACHINE
1805  *   if HKEY_CURRENT_USER doesn't contain any entries.  If both fail, finally
1806  *   calls _SHGetDefaultValue for it.
1807  */
1808 static HRESULT _SHGetUserProfilePath(HANDLE hToken, DWORD dwFlags, BYTE folder,
1809  LPWSTR pszPath)
1810 {
1811     HRESULT hr;
1812
1813     TRACE("%p,0x%08x,0x%02x,%p\n", hToken, dwFlags, folder, pszPath);
1814
1815     if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1816         return E_INVALIDARG;
1817     if (CSIDL_Data[folder].type != CSIDL_Type_User)
1818         return E_INVALIDARG;
1819     if (!pszPath)
1820         return E_INVALIDARG;
1821
1822     if (dwFlags & SHGFP_TYPE_DEFAULT)
1823     {
1824         if (hToken != NULL && hToken != (HANDLE)-1)
1825         {
1826             FIXME("unsupported for user other than current or default\n");
1827             return E_FAIL;
1828         }
1829         hr = _SHGetDefaultValue(folder, pszPath);
1830     }
1831     else
1832     {
1833         LPCWSTR userPrefix = NULL;
1834         HKEY hRootKey;
1835
1836         if (hToken == (HANDLE)-1)
1837         {
1838             hRootKey = HKEY_USERS;
1839             userPrefix = DefaultW;
1840         }
1841         else if (hToken == NULL)
1842             hRootKey = HKEY_CURRENT_USER;
1843         else
1844         {
1845             hRootKey = HKEY_USERS;
1846             userPrefix = _GetUserSidStringFromToken(hToken);
1847             if (userPrefix == NULL)
1848             {
1849                 hr = E_FAIL;
1850                 goto error;
1851             }
1852         }
1853         hr = _SHGetUserShellFolderPath(hRootKey, userPrefix,
1854          CSIDL_Data[folder].szValueName, pszPath);
1855         if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
1856             hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
1857              CSIDL_Data[folder].szValueName, pszPath);
1858         if (FAILED(hr))
1859             hr = _SHGetDefaultValue(folder, pszPath);
1860         if (userPrefix != NULL && userPrefix != DefaultW)
1861             LocalFree((HLOCAL) userPrefix);
1862     }
1863 error:
1864     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1865     return hr;
1866 }
1867
1868 /* Gets the (unexpanded) path for the CSIDL with index folder.  If dwFlags has
1869  * SHGFP_TYPE_DEFAULT set, calls _SHGetDefaultValue.  Otherwise calls
1870  * _SHGetUserShellFolderPath for it, looking only in HKEY_LOCAL_MACHINE.
1871  * If this fails, falls back to _SHGetDefaultValue.
1872  */
1873 static HRESULT _SHGetAllUsersProfilePath(DWORD dwFlags, BYTE folder,
1874  LPWSTR pszPath)
1875 {
1876     HRESULT hr;
1877
1878     TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
1879
1880     if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
1881         return E_INVALIDARG;
1882     if (CSIDL_Data[folder].type != CSIDL_Type_AllUsers)
1883         return E_INVALIDARG;
1884     if (!pszPath)
1885         return E_INVALIDARG;
1886
1887     if (dwFlags & SHGFP_TYPE_DEFAULT)
1888         hr = _SHGetDefaultValue(folder, pszPath);
1889     else
1890     {
1891         hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
1892          CSIDL_Data[folder].szValueName, pszPath);
1893         if (FAILED(hr))
1894             hr = _SHGetDefaultValue(folder, pszPath);
1895     }
1896     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
1897     return hr;
1898 }
1899
1900 static HRESULT _SHOpenProfilesKey(PHKEY pKey)
1901 {
1902     LONG lRet;
1903     DWORD disp;
1904
1905     lRet = RegCreateKeyExW(HKEY_LOCAL_MACHINE, ProfileListW, 0, NULL, 0,
1906      KEY_ALL_ACCESS, NULL, pKey, &disp);
1907     return HRESULT_FROM_WIN32(lRet);
1908 }
1909
1910 /* Reads the value named szValueName from the key profilesKey (assumed to be
1911  * opened by _SHOpenProfilesKey) into szValue, which is assumed to be MAX_PATH
1912  * WCHARs in length.  If it doesn't exist, returns szDefault (and saves
1913  * szDefault to the registry).
1914  */
1915 static HRESULT _SHGetProfilesValue(HKEY profilesKey, LPCWSTR szValueName,
1916  LPWSTR szValue, LPCWSTR szDefault)
1917 {
1918     HRESULT hr;
1919     DWORD type, dwPathLen = MAX_PATH * sizeof(WCHAR);
1920     LONG lRet;
1921
1922     TRACE("%p,%s,%p,%s\n", profilesKey, debugstr_w(szValueName), szValue,
1923      debugstr_w(szDefault));
1924     lRet = RegQueryValueExW(profilesKey, szValueName, NULL, &type,
1925      (LPBYTE)szValue, &dwPathLen);
1926     if (!lRet && (type == REG_SZ || type == REG_EXPAND_SZ) && dwPathLen
1927      && *szValue)
1928     {
1929         dwPathLen /= sizeof(WCHAR);
1930         szValue[dwPathLen] = '\0';
1931         hr = S_OK;
1932     }
1933     else
1934     {
1935         /* Missing or invalid value, set a default */
1936         lstrcpynW(szValue, szDefault, MAX_PATH);
1937         TRACE("Setting missing value %s to %s\n", debugstr_w(szValueName),
1938                                                   debugstr_w(szValue));
1939         lRet = RegSetValueExW(profilesKey, szValueName, 0, REG_EXPAND_SZ,
1940                               (LPBYTE)szValue,
1941                               (strlenW(szValue) + 1) * sizeof(WCHAR));
1942         if (lRet)
1943             hr = HRESULT_FROM_WIN32(lRet);
1944         else
1945             hr = S_OK;
1946     }
1947     TRACE("returning 0x%08x (output value is %s)\n", hr, debugstr_w(szValue));
1948     return hr;
1949 }
1950
1951 /* Attempts to expand environment variables from szSrc into szDest, which is
1952  * assumed to be MAX_PATH characters in length.  Before referring to the
1953  * environment, handles a few variables directly, because the environment
1954  * variables may not be set when this is called (as during Wine's installation
1955  * when default values are being written to the registry).
1956  * The directly handled environment variables, and their source, are:
1957  * - ALLUSERSPROFILE, USERPROFILE: reads from the registry
1958  * - SystemDrive: uses GetSystemDirectoryW and uses the drive portion of its
1959  *   path
1960  * If one of the directly handled environment variables is expanded, only
1961  * expands a single variable, and only in the beginning of szSrc.
1962  */
1963 static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest)
1964 {
1965     HRESULT hr;
1966     WCHAR szTemp[MAX_PATH], szProfilesPrefix[MAX_PATH] = { 0 };
1967     HKEY key = NULL;
1968
1969     TRACE("%s, %p\n", debugstr_w(szSrc), szDest);
1970
1971     if (!szSrc || !szDest) return E_INVALIDARG;
1972
1973     /* short-circuit if there's nothing to expand */
1974     if (szSrc[0] != '%')
1975     {
1976         strcpyW(szDest, szSrc);
1977         hr = S_OK;
1978         goto end;
1979     }
1980     /* Get the profile prefix, we'll probably be needing it */
1981     hr = _SHOpenProfilesKey(&key);
1982     if (SUCCEEDED(hr))
1983     {
1984         WCHAR def_val[MAX_PATH];
1985
1986         /* get the system drive */
1987         GetSystemDirectoryW(def_val, MAX_PATH);
1988         if (def_val[1] == ':') strcpyW( def_val + 3, szDefaultProfileDirW );
1989         else FIXME("non-drive system paths unsupported\n");
1990
1991         hr = _SHGetProfilesValue(key, ProfilesDirectoryW, szProfilesPrefix, def_val );
1992     }
1993
1994     *szDest = 0;
1995     strcpyW(szTemp, szSrc);
1996     while (SUCCEEDED(hr) && szTemp[0] == '%')
1997     {
1998         if (!strncmpiW(szTemp, AllUsersProfileW, strlenW(AllUsersProfileW)))
1999         {
2000             WCHAR szAllUsers[MAX_PATH];
2001
2002             strcpyW(szDest, szProfilesPrefix);
2003             hr = _SHGetProfilesValue(key, AllUsersProfileValueW,
2004              szAllUsers, AllUsersW);
2005             PathAppendW(szDest, szAllUsers);
2006             PathAppendW(szDest, szTemp + strlenW(AllUsersProfileW));
2007         }
2008         else if (!strncmpiW(szTemp, UserProfileW, strlenW(UserProfileW)))
2009         {
2010             WCHAR userName[MAX_PATH];
2011             DWORD userLen = MAX_PATH;
2012
2013             strcpyW(szDest, szProfilesPrefix);
2014             GetUserNameW(userName, &userLen);
2015             PathAppendW(szDest, userName);
2016             PathAppendW(szDest, szTemp + strlenW(UserProfileW));
2017         }
2018         else if (!strncmpiW(szTemp, SystemDriveW, strlenW(SystemDriveW)))
2019         {
2020             GetSystemDirectoryW(szDest, MAX_PATH);
2021             if (szDest[1] != ':')
2022             {
2023                 FIXME("non-drive system paths unsupported\n");
2024                 hr = E_FAIL;
2025             }
2026             else
2027             {
2028                 strcpyW(szDest + 3, szTemp + strlenW(SystemDriveW) + 1);
2029                 hr = S_OK;
2030             }
2031         }
2032         else
2033         {
2034             DWORD ret = ExpandEnvironmentStringsW(szSrc, szDest, MAX_PATH);
2035
2036             if (ret > MAX_PATH)
2037                 hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
2038             else if (ret == 0)
2039                 hr = HRESULT_FROM_WIN32(GetLastError());
2040             else
2041                 hr = S_OK;
2042         }
2043         if (SUCCEEDED(hr) && szDest[0] == '%')
2044             strcpyW(szTemp, szDest);
2045         else
2046         {
2047             /* terminate loop */
2048             szTemp[0] = '\0';
2049         }
2050     }
2051 end:
2052     if (key)
2053         RegCloseKey(key);
2054     TRACE("returning 0x%08x (input was %s, output is %s)\n", hr,
2055      debugstr_w(szSrc), debugstr_w(szDest));
2056     return hr;
2057 }
2058
2059 /*************************************************************************
2060  * SHGetFolderPathW                     [SHELL32.@]
2061  *
2062  * Convert nFolder to path.
2063  *
2064  * RETURNS
2065  *  Success: S_OK
2066  *  Failure: standard HRESULT error codes.
2067  *
2068  * NOTES
2069  * Most values can be overridden in either
2070  * HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
2071  * or in the same location in HKLM.
2072  * The "Shell Folders" registry key was used in NT4 and earlier systems.
2073  * Beginning with Windows 2000, the "User Shell Folders" key is used, so
2074  * changes made to it are made to the former key too.  This synchronization is
2075  * done on-demand: not until someone requests the value of one of these paths
2076  * (by calling one of the SHGet functions) is the value synchronized.
2077  * Furthermore, the HKCU paths take precedence over the HKLM paths.
2078  */
2079 HRESULT WINAPI SHGetFolderPathW(
2080         HWND hwndOwner,    /* [I] owner window */
2081         int nFolder,       /* [I] CSIDL identifying the folder */
2082         HANDLE hToken,     /* [I] access token */
2083         DWORD dwFlags,     /* [I] which path to return */
2084         LPWSTR pszPath)    /* [O] converted path */
2085 {
2086     HRESULT hr =  SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, NULL, pszPath);
2087     if(HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) == hr)
2088         hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
2089     return hr;
2090 }
2091
2092 HRESULT WINAPI SHGetFolderPathAndSubDirA(
2093         HWND hwndOwner,    /* [I] owner window */
2094         int nFolder,       /* [I] CSIDL identifying the folder */
2095         HANDLE hToken,     /* [I] access token */
2096         DWORD dwFlags,     /* [I] which path to return */
2097         LPCSTR pszSubPath, /* [I] sub directory of the specified folder */
2098         LPSTR pszPath)     /* [O] converted path */
2099 {
2100     int length;
2101     HRESULT hr = S_OK;
2102     LPWSTR pszSubPathW = NULL;
2103     LPWSTR pszPathW = NULL;
2104     TRACE("%08x,%08x,%s\n",nFolder, dwFlags, debugstr_w(pszSubPathW));
2105
2106     if(pszPath) {
2107         pszPathW = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
2108         if(!pszPathW) {
2109             hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
2110             goto cleanup;
2111         }
2112     }
2113     TRACE("%08x,%08x,%s\n",nFolder, dwFlags, debugstr_w(pszSubPathW));
2114
2115     /* SHGetFolderPathAndSubDirW does not distinguish if pszSubPath isn't
2116      * set (null), or an empty string.therefore call it without the parameter set
2117      * if pszSubPath is an empty string
2118      */
2119     if (pszSubPath && pszSubPath[0]) {
2120         length = MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, NULL, 0);
2121         pszSubPathW = HeapAlloc(GetProcessHeap(), 0, length * sizeof(WCHAR));
2122         if(!pszSubPathW) {
2123             hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
2124             goto cleanup;
2125         }
2126         MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, pszSubPathW, length);
2127     }
2128
2129     hr = SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, pszSubPathW, pszPathW);
2130
2131     if (SUCCEEDED(hr) && pszPath)
2132         WideCharToMultiByte(CP_ACP, 0, pszPathW, -1, pszPath, MAX_PATH, NULL, NULL);
2133
2134 cleanup:
2135     HeapFree(GetProcessHeap(), 0, pszPathW);
2136     HeapFree(GetProcessHeap(), 0, pszSubPathW);
2137     return hr;
2138 }
2139
2140 /*************************************************************************
2141  * SHGetFolderPathAndSubDirW            [SHELL32.@]
2142  */
2143 HRESULT WINAPI SHGetFolderPathAndSubDirW(
2144         HWND hwndOwner,    /* [I] owner window */
2145         int nFolder,       /* [I] CSIDL identifying the folder */
2146         HANDLE hToken,     /* [I] access token */
2147         DWORD dwFlags,     /* [I] which path to return */
2148         LPCWSTR pszSubPath,/* [I] sub directory of the specified folder */
2149         LPWSTR pszPath)    /* [O] converted path */
2150 {
2151     HRESULT    hr;
2152     WCHAR      szBuildPath[MAX_PATH], szTemp[MAX_PATH];
2153     DWORD      folder = nFolder & CSIDL_FOLDER_MASK;
2154     CSIDL_Type type;
2155     int        ret;
2156
2157     TRACE("%p,%p,nFolder=0x%04x,%s\n", hwndOwner,pszPath,nFolder,debugstr_w(pszSubPath));
2158
2159     /* Windows always NULL-terminates the resulting path regardless of success
2160      * or failure, so do so first
2161      */
2162     if (pszPath)
2163         *pszPath = '\0';
2164
2165     if (folder >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
2166         return E_INVALIDARG;
2167     if ((SHGFP_TYPE_CURRENT != dwFlags) && (SHGFP_TYPE_DEFAULT != dwFlags))
2168         return E_INVALIDARG;
2169     szTemp[0] = 0;
2170     type = CSIDL_Data[folder].type;
2171     switch (type)
2172     {
2173         case CSIDL_Type_Disallowed:
2174             hr = E_INVALIDARG;
2175             break;
2176         case CSIDL_Type_NonExistent:
2177             hr = S_FALSE;
2178             break;
2179         case CSIDL_Type_WindowsPath:
2180             GetWindowsDirectoryW(szTemp, MAX_PATH);
2181             if (CSIDL_Data[folder].szDefaultPath &&
2182              !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
2183              *CSIDL_Data[folder].szDefaultPath)
2184             {
2185                 PathAddBackslashW(szTemp);
2186                 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
2187             }
2188             hr = S_OK;
2189             break;
2190         case CSIDL_Type_SystemPath:
2191             GetSystemDirectoryW(szTemp, MAX_PATH);
2192             if (CSIDL_Data[folder].szDefaultPath &&
2193              !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
2194              *CSIDL_Data[folder].szDefaultPath)
2195             {
2196                 PathAddBackslashW(szTemp);
2197                 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
2198             }
2199             hr = S_OK;
2200             break;
2201         case CSIDL_Type_SystemX86Path:
2202             if (!GetSystemWow64DirectoryW(szTemp, MAX_PATH)) GetSystemDirectoryW(szTemp, MAX_PATH);
2203             if (CSIDL_Data[folder].szDefaultPath &&
2204              !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
2205              *CSIDL_Data[folder].szDefaultPath)
2206             {
2207                 PathAddBackslashW(szTemp);
2208                 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
2209             }
2210             hr = S_OK;
2211             break;
2212         case CSIDL_Type_CurrVer:
2213             hr = _SHGetCurrentVersionPath(dwFlags, folder, szTemp);
2214             break;
2215         case CSIDL_Type_User:
2216             hr = _SHGetUserProfilePath(hToken, dwFlags, folder, szTemp);
2217             break;
2218         case CSIDL_Type_AllUsers:
2219             hr = _SHGetAllUsersProfilePath(dwFlags, folder, szTemp);
2220             break;
2221         default:
2222             FIXME("bogus type %d, please fix\n", type);
2223             hr = E_INVALIDARG;
2224             break;
2225     }
2226
2227     /* Expand environment strings if necessary */
2228     if (*szTemp == '%')
2229         hr = _SHExpandEnvironmentStrings(szTemp, szBuildPath);
2230     else
2231         strcpyW(szBuildPath, szTemp);
2232
2233     if (FAILED(hr)) goto end;
2234
2235     if(pszSubPath) {
2236         /* make sure the new path does not exceed th bufferlength
2237          * rememebr to backslash and the termination */
2238         if(MAX_PATH < (lstrlenW(szBuildPath) + lstrlenW(pszSubPath) + 2)) {
2239             hr = HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
2240             goto end;
2241         }
2242         PathAppendW(szBuildPath, pszSubPath);
2243         PathRemoveBackslashW(szBuildPath);
2244     }
2245     /* Copy the path if it's available before we might return */
2246     if (SUCCEEDED(hr) && pszPath)
2247         strcpyW(pszPath, szBuildPath);
2248
2249     /* if we don't care about existing directories we are ready */
2250     if(nFolder & CSIDL_FLAG_DONT_VERIFY) goto end;
2251
2252     if (PathFileExistsW(szBuildPath)) goto end;
2253
2254     /* not existing but we are not allowed to create it.  The return value
2255      * is verified against shell32 version 6.0.
2256      */
2257     if (!(nFolder & CSIDL_FLAG_CREATE))
2258     {
2259         hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
2260         goto end;
2261     }
2262
2263     /* create directory/directories */
2264     ret = SHCreateDirectoryExW(hwndOwner, szBuildPath, NULL);
2265     if (ret && ret != ERROR_ALREADY_EXISTS)
2266     {
2267         ERR("Failed to create directory %s.\n", debugstr_w(szBuildPath));
2268         hr = E_FAIL;
2269         goto end;
2270     }
2271
2272     TRACE("Created missing system directory %s\n", debugstr_w(szBuildPath));
2273 end:
2274     TRACE("returning 0x%08x (final path is %s)\n", hr, debugstr_w(szBuildPath));
2275     return hr;
2276 }
2277
2278 /*************************************************************************
2279  * SHGetFolderPathA                     [SHELL32.@]
2280  *
2281  * See SHGetFolderPathW.
2282  */
2283 HRESULT WINAPI SHGetFolderPathA(
2284         HWND hwndOwner,
2285         int nFolder,
2286         HANDLE hToken,
2287         DWORD dwFlags,
2288         LPSTR pszPath)
2289 {
2290     WCHAR szTemp[MAX_PATH];
2291     HRESULT hr;
2292
2293     TRACE("%p,%p,nFolder=0x%04x\n",hwndOwner,pszPath,nFolder);
2294
2295     if (pszPath)
2296         *pszPath = '\0';
2297     hr = SHGetFolderPathW(hwndOwner, nFolder, hToken, dwFlags, szTemp);
2298     if (SUCCEEDED(hr) && pszPath)
2299         WideCharToMultiByte(CP_ACP, 0, szTemp, -1, pszPath, MAX_PATH, NULL,
2300          NULL);
2301
2302     return hr;
2303 }
2304
2305 /* For each folder in folders, if its value has not been set in the registry,
2306  * calls _SHGetUserProfilePath or _SHGetAllUsersProfilePath (depending on the
2307  * folder's type) to get the unexpanded value first.
2308  * Writes the unexpanded value to User Shell Folders, and queries it with
2309  * SHGetFolderPathW to force the creation of the directory if it doesn't
2310  * already exist.  SHGetFolderPathW also returns the expanded value, which
2311  * this then writes to Shell Folders.
2312  */
2313 static HRESULT _SHRegisterFolders(HKEY hRootKey, HANDLE hToken,
2314  LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[],
2315  UINT foldersLen)
2316 {
2317     UINT i;
2318     WCHAR path[MAX_PATH];
2319     HRESULT hr = S_OK;
2320     HKEY hUserKey = NULL, hKey = NULL;
2321     DWORD dwType, dwPathLen;
2322     LONG ret;
2323
2324     TRACE("%p,%p,%s,%p,%u\n", hRootKey, hToken,
2325      debugstr_w(szUserShellFolderPath), folders, foldersLen);
2326
2327     ret = RegCreateKeyW(hRootKey, szUserShellFolderPath, &hUserKey);
2328     if (ret)
2329         hr = HRESULT_FROM_WIN32(ret);
2330     else
2331     {
2332         ret = RegCreateKeyW(hRootKey, szShellFolderPath, &hKey);
2333         if (ret)
2334             hr = HRESULT_FROM_WIN32(ret);
2335     }
2336     for (i = 0; SUCCEEDED(hr) && i < foldersLen; i++)
2337     {
2338         dwPathLen = MAX_PATH * sizeof(WCHAR);
2339         if (RegQueryValueExW(hUserKey, CSIDL_Data[folders[i]].szValueName, NULL,
2340          &dwType, (LPBYTE)path, &dwPathLen) || (dwType != REG_SZ &&
2341          dwType != REG_EXPAND_SZ))
2342         {
2343             *path = '\0';
2344             if (CSIDL_Data[folders[i]].type == CSIDL_Type_User)
2345                 _SHGetUserProfilePath(hToken, SHGFP_TYPE_DEFAULT, folders[i],
2346                  path);
2347             else if (CSIDL_Data[folders[i]].type == CSIDL_Type_AllUsers)
2348                 _SHGetAllUsersProfilePath(SHGFP_TYPE_DEFAULT, folders[i], path);
2349             else if (CSIDL_Data[folders[i]].type == CSIDL_Type_WindowsPath)
2350             {
2351                 GetWindowsDirectoryW(path, MAX_PATH);
2352                 if (CSIDL_Data[folders[i]].szDefaultPath &&
2353                     !IS_INTRESOURCE(CSIDL_Data[folders[i]].szDefaultPath))
2354                 {
2355                     PathAddBackslashW(path);
2356                     strcatW(path, CSIDL_Data[folders[i]].szDefaultPath);
2357                 }
2358             }
2359             else
2360                 hr = E_FAIL;
2361             if (*path)
2362             {
2363                 ret = RegSetValueExW(hUserKey,
2364                  CSIDL_Data[folders[i]].szValueName, 0, REG_EXPAND_SZ,
2365                  (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
2366                 if (ret)
2367                     hr = HRESULT_FROM_WIN32(ret);
2368                 else
2369                 {
2370                     hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
2371                      hToken, SHGFP_TYPE_DEFAULT, path);
2372                     ret = RegSetValueExW(hKey,
2373                      CSIDL_Data[folders[i]].szValueName, 0, REG_SZ,
2374                      (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
2375                     if (ret)
2376                         hr = HRESULT_FROM_WIN32(ret);
2377                 }
2378             }
2379         }
2380     }
2381     if (hUserKey)
2382         RegCloseKey(hUserKey);
2383     if (hKey)
2384         RegCloseKey(hKey);
2385
2386     TRACE("returning 0x%08x\n", hr);
2387     return hr;
2388 }
2389
2390 static HRESULT _SHRegisterUserShellFolders(BOOL bDefault)
2391 {
2392     static const UINT folders[] = {
2393      CSIDL_PROGRAMS,
2394      CSIDL_PERSONAL,
2395      CSIDL_FAVORITES,
2396      CSIDL_APPDATA,
2397      CSIDL_STARTUP,
2398      CSIDL_RECENT,
2399      CSIDL_SENDTO,
2400      CSIDL_STARTMENU,
2401      CSIDL_MYMUSIC,
2402      CSIDL_MYVIDEO,
2403      CSIDL_DESKTOPDIRECTORY,
2404      CSIDL_NETHOOD,
2405      CSIDL_TEMPLATES,
2406      CSIDL_PRINTHOOD,
2407      CSIDL_LOCAL_APPDATA,
2408      CSIDL_INTERNET_CACHE,
2409      CSIDL_COOKIES,
2410      CSIDL_HISTORY,
2411      CSIDL_MYPICTURES,
2412      CSIDL_FONTS
2413     };
2414     WCHAR userShellFolderPath[MAX_PATH], shellFolderPath[MAX_PATH];
2415     LPCWSTR pUserShellFolderPath, pShellFolderPath;
2416     HRESULT hr = S_OK;
2417     HKEY hRootKey;
2418     HANDLE hToken;
2419
2420     TRACE("%s\n", bDefault ? "TRUE" : "FALSE");
2421     if (bDefault)
2422     {
2423         hToken = (HANDLE)-1;
2424         hRootKey = HKEY_USERS;
2425         strcpyW(userShellFolderPath, DefaultW);
2426         PathAddBackslashW(userShellFolderPath);
2427         strcatW(userShellFolderPath, szSHUserFolders);
2428         pUserShellFolderPath = userShellFolderPath;
2429         strcpyW(shellFolderPath, DefaultW);
2430         PathAddBackslashW(shellFolderPath);
2431         strcatW(shellFolderPath, szSHFolders);
2432         pShellFolderPath = shellFolderPath;
2433     }
2434     else
2435     {
2436         hToken = NULL;
2437         hRootKey = HKEY_CURRENT_USER;
2438         pUserShellFolderPath = szSHUserFolders;
2439         pShellFolderPath = szSHFolders;
2440     }
2441
2442     hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath,
2443      pShellFolderPath, folders, sizeof(folders) / sizeof(folders[0]));
2444     TRACE("returning 0x%08x\n", hr);
2445     return hr;
2446 }
2447
2448 static HRESULT _SHRegisterCommonShellFolders(void)
2449 {
2450     static const UINT folders[] = {
2451      CSIDL_COMMON_STARTMENU,
2452      CSIDL_COMMON_PROGRAMS,
2453      CSIDL_COMMON_STARTUP,
2454      CSIDL_COMMON_DESKTOPDIRECTORY,
2455      CSIDL_COMMON_FAVORITES,
2456      CSIDL_COMMON_APPDATA,
2457      CSIDL_COMMON_TEMPLATES,
2458      CSIDL_COMMON_DOCUMENTS,
2459      CSIDL_COMMON_ADMINTOOLS,
2460      CSIDL_COMMON_MUSIC,
2461      CSIDL_COMMON_PICTURES,
2462      CSIDL_COMMON_VIDEO,
2463     };
2464     HRESULT hr;
2465
2466     TRACE("\n");
2467     hr = _SHRegisterFolders(HKEY_LOCAL_MACHINE, NULL, szSHUserFolders,
2468      szSHFolders, folders, sizeof(folders) / sizeof(folders[0]));
2469     TRACE("returning 0x%08x\n", hr);
2470     return hr;
2471 }
2472
2473 /******************************************************************************
2474  * _SHAppendToUnixPath  [Internal]
2475  *
2476  * Helper function for _SHCreateSymbolicLinks. Appends pwszSubPath (or the
2477  * corresponding resource, if IS_INTRESOURCE) to the unix base path 'szBasePath'
2478  * and replaces backslashes with slashes.
2479  *
2480  * PARAMS
2481  *  szBasePath  [IO] The unix base path, which will be appended to (CP_UNXICP).
2482  *  pwszSubPath [I]  Sub-path or resource id (use MAKEINTRESOURCEW).
2483  *
2484  * RETURNS
2485  *  Success: TRUE,
2486  *  Failure: FALSE
2487  */
2488 static inline BOOL _SHAppendToUnixPath(char *szBasePath, LPCWSTR pwszSubPath) {
2489     WCHAR wszSubPath[MAX_PATH];
2490     int cLen = strlen(szBasePath);
2491     char *pBackslash;
2492
2493     if (IS_INTRESOURCE(pwszSubPath)) {
2494         if (!LoadStringW(shell32_hInstance, LOWORD(pwszSubPath), wszSubPath, MAX_PATH)) {
2495             /* Fall back to hard coded defaults. */
2496             switch (LOWORD(pwszSubPath)) {
2497                 case IDS_PERSONAL:
2498                     lstrcpyW(wszSubPath, PersonalW);
2499                     break;
2500                 case IDS_MYMUSIC:
2501                     lstrcpyW(wszSubPath, My_MusicW);
2502                     break;
2503                 case IDS_MYPICTURES:
2504                     lstrcpyW(wszSubPath, My_PicturesW);
2505                     break;
2506                 case IDS_MYVIDEO:
2507                     lstrcpyW(wszSubPath, My_VideoW);
2508                     break;
2509                 default:
2510                     ERR("LoadString(%d) failed!\n", LOWORD(pwszSubPath));
2511                     return FALSE;
2512             }
2513         }
2514     } else {
2515         lstrcpyW(wszSubPath, pwszSubPath);
2516     }
2517
2518     if (szBasePath[cLen-1] != '/') szBasePath[cLen++] = '/';
2519
2520     if (!WideCharToMultiByte(CP_UNIXCP, 0, wszSubPath, -1, szBasePath + cLen,
2521                              FILENAME_MAX - cLen, NULL, NULL))
2522     {
2523         return FALSE;
2524     }
2525
2526     pBackslash = szBasePath + cLen;
2527     while ((pBackslash = strchr(pBackslash, '\\'))) *pBackslash = '/';
2528
2529     return TRUE;
2530 }
2531
2532 /******************************************************************************
2533  * _SHCreateSymbolicLinks  [Internal]
2534  *
2535  * Sets up symbol links for various shell folders to point into the users home
2536  * directory. We do an educated guess about what the user would probably want:
2537  * - If there is a 'My Documents' directory in $HOME, the user probably wants
2538  *   wine's 'My Documents' to point there. Furthermore, we imply that the user
2539  *   is a Windows lover and has no problem with wine creating 'My Pictures',
2540  *   'My Music' and 'My Video' subfolders under '$HOME/My Documents', if those
2541  *   do not already exits. We put appropriate symbolic links in place for those,
2542  *   too.
2543  * - If there is no 'My Documents' directory in $HOME, we let 'My Documents'
2544  *   point directly to $HOME. We assume the user to be a unix hacker who does not
2545  *   want wine to create anything anywhere besides the .wine directory. So, if
2546  *   there already is a 'My Music' directory in $HOME, we symlink the 'My Music'
2547  *   shell folder to it. But if not, then we check XDG_MUSIC_DIR - "well known"
2548  *   directory, and try to link to that. If that fails, then we symlink to
2549  *   $HOME directly. The same holds fo 'My Pictures' and 'My Video'.
2550  * - The Desktop shell folder is symlinked to XDG_DESKTOP_DIR. If that does not
2551  *   exist, then we try '$HOME/Desktop'. If that does not exist, then we leave
2552  *   it alone.
2553  * ('My Music',... above in fact means LoadString(IDS_MYMUSIC))
2554  */
2555 static void _SHCreateSymbolicLinks(void)
2556 {
2557     UINT aidsMyStuff[] = { IDS_MYPICTURES, IDS_MYVIDEO, IDS_MYMUSIC }, i;
2558     int acsidlMyStuff[] = { CSIDL_MYPICTURES, CSIDL_MYVIDEO, CSIDL_MYMUSIC };
2559     static const char * const xdg_dirs[] = { "PICTURES", "VIDEOS", "MUSIC", "DESKTOP" };
2560     static const unsigned int num = sizeof(xdg_dirs) / sizeof(xdg_dirs[0]);
2561     WCHAR wszTempPath[MAX_PATH];
2562     char szPersonalTarget[FILENAME_MAX], *pszPersonal;
2563     char szMyStuffTarget[FILENAME_MAX], *pszMyStuff;
2564     char szDesktopTarget[FILENAME_MAX], *pszDesktop;
2565     struct stat statFolder;
2566     const char *pszHome;
2567     HRESULT hr;
2568     char ** xdg_results;
2569     char * xdg_desktop_dir;
2570
2571     /* Create all necessary profile sub-dirs up to 'My Documents' and get the unix path. */
2572     hr = SHGetFolderPathW(NULL, CSIDL_PERSONAL|CSIDL_FLAG_CREATE, NULL,
2573                           SHGFP_TYPE_DEFAULT, wszTempPath);
2574     if (FAILED(hr)) return;
2575     pszPersonal = wine_get_unix_file_name(wszTempPath);
2576     if (!pszPersonal) return;
2577
2578     hr = XDG_UserDirLookup(xdg_dirs, num, &xdg_results);
2579     if (FAILED(hr)) xdg_results = NULL;
2580
2581     pszHome = getenv("HOME");
2582     if (pszHome && !stat(pszHome, &statFolder) && S_ISDIR(statFolder.st_mode)) {
2583         strcpy(szPersonalTarget, pszHome);
2584         if (_SHAppendToUnixPath(szPersonalTarget, MAKEINTRESOURCEW(IDS_PERSONAL)) &&
2585             !stat(szPersonalTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
2586         {
2587             /* '$HOME/My Documents' exists. Create 'My Pictures', 'My Videos' and
2588              * 'My Music' subfolders or fail silently if they already exist. */
2589             for (i = 0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
2590                 strcpy(szMyStuffTarget, szPersonalTarget);
2591                 if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])))
2592                     mkdir(szMyStuffTarget, 0777);
2593             }
2594         }
2595         else
2596         {
2597             /* '$HOME/My Documents' doesn't exists, but '$HOME' does. */
2598             strcpy(szPersonalTarget, pszHome);
2599         }
2600
2601         /* Replace 'My Documents' directory with a symlink of fail silently if not empty. */
2602         rmdir(pszPersonal);
2603         symlink(szPersonalTarget, pszPersonal);
2604     }
2605     else
2606     {
2607         /* '$HOME' doesn't exist. Create 'My Pictures', 'My Videos' and 'My Music' subdirs
2608          * in '%USERPROFILE%\\My Documents' or fail silently if they already exist. */
2609         strcpy(szPersonalTarget, pszPersonal);
2610         for (i = 0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
2611             strcpy(szMyStuffTarget, szPersonalTarget);
2612             if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])))
2613                 mkdir(szMyStuffTarget, 0777);
2614         }
2615     }
2616
2617     /* Create symbolic links for 'My Pictures', 'My Video' and 'My Music'. */
2618     for (i=0; i < sizeof(aidsMyStuff)/sizeof(aidsMyStuff[0]); i++) {
2619         /* Create the current 'My Whatever' folder and get it's unix path. */
2620         hr = SHGetFolderPathW(NULL, acsidlMyStuff[i]|CSIDL_FLAG_CREATE, NULL,
2621                               SHGFP_TYPE_DEFAULT, wszTempPath);
2622         if (FAILED(hr)) continue;
2623         pszMyStuff = wine_get_unix_file_name(wszTempPath);
2624         if (!pszMyStuff) continue;
2625
2626         strcpy(szMyStuffTarget, szPersonalTarget);
2627         if (_SHAppendToUnixPath(szMyStuffTarget, MAKEINTRESOURCEW(aidsMyStuff[i])) &&
2628             !stat(szMyStuffTarget, &statFolder) && S_ISDIR(statFolder.st_mode))
2629         {
2630             /* If there's a 'My Whatever' directory where 'My Documents' links to, link to it. */
2631             rmdir(pszMyStuff);
2632             symlink(szMyStuffTarget, pszMyStuff);
2633         }
2634         else
2635         {
2636             rmdir(pszMyStuff);
2637             if (xdg_results && xdg_results[i])
2638             {
2639                 /* the folder specified by XDG_XXX_DIR exists, link to it. */
2640                 symlink(xdg_results[i], pszMyStuff);
2641             }
2642             else
2643             {
2644                 /* Else link to where 'My Documents' itself links to. */
2645                 symlink(szPersonalTarget, pszMyStuff);
2646             }
2647         }
2648         HeapFree(GetProcessHeap(), 0, pszMyStuff);
2649     }
2650
2651     /* Last but not least, the Desktop folder */
2652     if (pszHome)
2653         strcpy(szDesktopTarget, pszHome);
2654     else
2655         strcpy(szDesktopTarget, pszPersonal);
2656     HeapFree(GetProcessHeap(), 0, pszPersonal);
2657
2658     xdg_desktop_dir = xdg_results ? xdg_results[num - 1] : NULL;
2659     if (xdg_desktop_dir ||
2660         (_SHAppendToUnixPath(szDesktopTarget, DesktopW) &&
2661         !stat(szDesktopTarget, &statFolder) && S_ISDIR(statFolder.st_mode)))
2662     {
2663         hr = SHGetFolderPathW(NULL, CSIDL_DESKTOPDIRECTORY|CSIDL_FLAG_CREATE, NULL,
2664                               SHGFP_TYPE_DEFAULT, wszTempPath);
2665         if (SUCCEEDED(hr) && (pszDesktop = wine_get_unix_file_name(wszTempPath)))
2666         {
2667             rmdir(pszDesktop);
2668             if (xdg_desktop_dir)
2669                 symlink(xdg_desktop_dir, pszDesktop);
2670             else
2671                 symlink(szDesktopTarget, pszDesktop);
2672             HeapFree(GetProcessHeap(), 0, pszDesktop);
2673         }
2674     }
2675
2676     /* Free resources allocated by XDG_UserDirLookup() */
2677     if (xdg_results)
2678     {
2679         for (i = 0; i < num; i++)
2680             HeapFree(GetProcessHeap(), 0, xdg_results[i]);
2681         HeapFree(GetProcessHeap(), 0, xdg_results);
2682     }
2683 }
2684
2685 /******************************************************************************
2686  * create_extra_folders  [Internal]
2687  *
2688  * Create some extra folders that don't have a standard CSIDL definition.
2689  */
2690 static HRESULT create_extra_folders(void)
2691 {
2692     static const WCHAR environW[] = {'E','n','v','i','r','o','n','m','e','n','t',0};
2693     static const WCHAR TempW[]    = {'T','e','m','p',0};
2694     static const WCHAR TEMPW[]    = {'T','E','M','P',0};
2695     static const WCHAR TMPW[]     = {'T','M','P',0};
2696     WCHAR path[MAX_PATH+5];
2697     HRESULT hr;
2698     HKEY hkey;
2699     DWORD type, size, ret;
2700
2701     ret = RegCreateKeyW( HKEY_CURRENT_USER, environW, &hkey );
2702     if (ret) return HRESULT_FROM_WIN32( ret );
2703
2704     /* FIXME: should be under AppData, but we don't want spaces in the temp path */
2705     hr = SHGetFolderPathAndSubDirW( 0, CSIDL_PROFILE | CSIDL_FLAG_CREATE, NULL,
2706                                     SHGFP_TYPE_DEFAULT, TempW, path );
2707     if (SUCCEEDED(hr))
2708     {
2709         size = sizeof(path);
2710         if (RegQueryValueExW( hkey, TEMPW, NULL, &type, (LPBYTE)path, &size ))
2711             RegSetValueExW( hkey, TEMPW, 0, REG_SZ, (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR) );
2712         size = sizeof(path);
2713         if (RegQueryValueExW( hkey, TMPW, NULL, &type, (LPBYTE)path, &size ))
2714             RegSetValueExW( hkey, TMPW, 0, REG_SZ, (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR) );
2715     }
2716     RegCloseKey( hkey );
2717     return hr;
2718 }
2719
2720
2721 /******************************************************************************
2722  * set_folder_attributes
2723  *
2724  * Set the various folder attributes registry keys.
2725  */
2726 static HRESULT set_folder_attributes(void)
2727 {
2728     static const WCHAR clsidW[] = {'C','L','S','I','D','\\',0 };
2729     static const WCHAR shellfolderW[] = {'\\','S','h','e','l','l','F','o','l','d','e','r', 0 };
2730     static const WCHAR wfparsingW[] = {'W','a','n','t','s','F','O','R','P','A','R','S','I','N','G',0};
2731     static const WCHAR wfdisplayW[] = {'W','a','n','t','s','F','O','R','D','I','S','P','L','A','Y',0};
2732     static const WCHAR hideasdeleteW[] = {'H','i','d','e','A','s','D','e','l','e','t','e','P','e','r','U','s','e','r',0};
2733     static const WCHAR attributesW[] = {'A','t','t','r','i','b','u','t','e','s',0};
2734     static const WCHAR cfattributesW[] = {'C','a','l','l','F','o','r','A','t','t','r','i','b','u','t','e','s',0};
2735     static const WCHAR emptyW[] = {0};
2736
2737     static const struct
2738     {
2739         const CLSID *clsid;
2740         BOOL wfparsing : 1;
2741         BOOL wfdisplay : 1;
2742         BOOL hideasdel : 1;
2743         DWORD attr;
2744         DWORD call_for_attr;
2745     } folders[] =
2746     {
2747         { &CLSID_UnixFolder, TRUE, FALSE, FALSE },
2748         { &CLSID_UnixDosFolder, TRUE, FALSE, FALSE,
2749           SFGAO_FILESYSANCESTOR|SFGAO_FOLDER|SFGAO_HASSUBFOLDER, SFGAO_FILESYSTEM },
2750         { &CLSID_FolderShortcut, FALSE, FALSE, FALSE,
2751           SFGAO_FILESYSTEM|SFGAO_FOLDER|SFGAO_LINK,
2752           SFGAO_HASSUBFOLDER|SFGAO_FILESYSTEM|SFGAO_FOLDER|SFGAO_FILESYSANCESTOR },
2753         { &CLSID_MyDocuments, TRUE, FALSE, FALSE,
2754           SFGAO_FILESYSANCESTOR|SFGAO_FOLDER|SFGAO_HASSUBFOLDER, SFGAO_FILESYSTEM },
2755         { &CLSID_RecycleBin, FALSE, FALSE, FALSE,
2756           SFGAO_FOLDER|SFGAO_DROPTARGET|SFGAO_HASPROPSHEET },
2757         { &CLSID_ControlPanel, FALSE, TRUE, TRUE,
2758           SFGAO_FOLDER|SFGAO_HASSUBFOLDER }
2759     };
2760
2761     unsigned int i;
2762     WCHAR buffer[39 + (sizeof(clsidW) + sizeof(shellfolderW)) / sizeof(WCHAR)];
2763     LONG res;
2764     HKEY hkey;
2765
2766     for (i = 0; i < sizeof(folders)/sizeof(folders[0]); i++)
2767     {
2768         strcpyW( buffer, clsidW );
2769         StringFromGUID2( folders[i].clsid, buffer + strlenW(buffer), 39 );
2770         strcatW( buffer, shellfolderW );
2771         res = RegCreateKeyExW( HKEY_CLASSES_ROOT, buffer, 0, NULL, 0,
2772                                KEY_READ | KEY_WRITE, NULL, &hkey, NULL);
2773         if (res) return HRESULT_FROM_WIN32( res );
2774         if (folders[i].wfparsing)
2775             res = RegSetValueExW( hkey, wfparsingW, 0, REG_SZ, (const BYTE *)emptyW, sizeof(emptyW) );
2776         if (folders[i].wfdisplay)
2777             res = RegSetValueExW( hkey, wfdisplayW, 0, REG_SZ, (const BYTE *)emptyW, sizeof(emptyW) );
2778         if (folders[i].hideasdel)
2779             res = RegSetValueExW( hkey, hideasdeleteW, 0, REG_SZ, (const BYTE *)emptyW, sizeof(emptyW) );
2780         if (folders[i].attr)
2781             res = RegSetValueExW( hkey, attributesW, 0, REG_DWORD,
2782                                   (const BYTE *)&folders[i].attr, sizeof(DWORD));
2783         if (folders[i].call_for_attr)
2784             res = RegSetValueExW( hkey, cfattributesW, 0, REG_DWORD,
2785                                  (const BYTE *)&folders[i].call_for_attr, sizeof(DWORD));
2786         RegCloseKey( hkey );
2787     }
2788     return S_OK;
2789 }
2790
2791
2792 /* Register the default values in the registry, as some apps seem to depend
2793  * on their presence.  The set registered was taken from Windows XP.
2794  */
2795 HRESULT SHELL_RegisterShellFolders(void)
2796 {
2797     HRESULT hr;
2798
2799     /* Set up '$HOME' targeted symlinks for 'My Documents', 'My Pictures',
2800      * 'My Video', 'My Music' and 'Desktop' in advance, so that the
2801      * _SHRegister*ShellFolders() functions will find everything nice and clean
2802      * and thus will not attempt to create them in the profile directory. */
2803     _SHCreateSymbolicLinks();
2804
2805     hr = _SHRegisterUserShellFolders(TRUE);
2806     if (SUCCEEDED(hr))
2807         hr = _SHRegisterUserShellFolders(FALSE);
2808     if (SUCCEEDED(hr))
2809         hr = _SHRegisterCommonShellFolders();
2810     if (SUCCEEDED(hr))
2811         hr = create_extra_folders();
2812     if (SUCCEEDED(hr))
2813         hr = set_folder_attributes();
2814     return hr;
2815 }
2816
2817 /*************************************************************************
2818  * SHGetSpecialFolderPathA [SHELL32.@]
2819  */
2820 BOOL WINAPI SHGetSpecialFolderPathA (
2821         HWND hwndOwner,
2822         LPSTR szPath,
2823         int nFolder,
2824         BOOL bCreate)
2825 {
2826         return (SHGetFolderPathA(
2827                 hwndOwner,
2828                 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
2829                 NULL,
2830                 0,
2831                 szPath)) == S_OK ? TRUE : FALSE;
2832 }
2833
2834 /*************************************************************************
2835  * SHGetSpecialFolderPathW
2836  */
2837 BOOL WINAPI SHGetSpecialFolderPathW (
2838         HWND hwndOwner,
2839         LPWSTR szPath,
2840         int nFolder,
2841         BOOL bCreate)
2842 {
2843         return (SHGetFolderPathW(
2844                 hwndOwner,
2845                 nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0),
2846                 NULL,
2847                 0,
2848                 szPath)) == S_OK ? TRUE : FALSE;
2849 }
2850
2851 /*************************************************************************
2852  * SHGetSpecialFolderPath (SHELL32.175)
2853  */
2854 BOOL WINAPI SHGetSpecialFolderPathAW (
2855         HWND hwndOwner,
2856         LPVOID szPath,
2857         int nFolder,
2858         BOOL bCreate)
2859
2860 {
2861         if (SHELL_OsIsUnicode())
2862           return SHGetSpecialFolderPathW (hwndOwner, szPath, nFolder, bCreate);
2863         return SHGetSpecialFolderPathA (hwndOwner, szPath, nFolder, bCreate);
2864 }
2865
2866 /*************************************************************************
2867  * SHGetFolderLocation [SHELL32.@]
2868  *
2869  * Gets the folder locations from the registry and creates a pidl.
2870  *
2871  * PARAMS
2872  *   hwndOwner  [I]
2873  *   nFolder    [I] CSIDL_xxxxx
2874  *   hToken     [I] token representing user, or NULL for current user, or -1 for
2875  *                  default user
2876  *   dwReserved [I] must be zero
2877  *   ppidl      [O] PIDL of a special folder
2878  *
2879  * RETURNS
2880  *  Success: S_OK
2881  *  Failure: Standard OLE-defined error result, S_FALSE or E_INVALIDARG
2882  *
2883  * NOTES
2884  *  Creates missing reg keys and directories.
2885  *  Mostly forwards to SHGetFolderPathW, but a few values of nFolder return
2886  *  virtual folders that are handled here.
2887  */
2888 HRESULT WINAPI SHGetFolderLocation(
2889         HWND hwndOwner,
2890         int nFolder,
2891         HANDLE hToken,
2892         DWORD dwReserved,
2893         LPITEMIDLIST *ppidl)
2894 {
2895     HRESULT hr = E_INVALIDARG;
2896
2897     TRACE("%p 0x%08x %p 0x%08x %p\n",
2898      hwndOwner, nFolder, hToken, dwReserved, ppidl);
2899
2900     if (!ppidl)
2901         return E_INVALIDARG;
2902     if (dwReserved)
2903         return E_INVALIDARG;
2904
2905     /* The virtual folders' locations are not user-dependent */
2906     *ppidl = NULL;
2907     switch (nFolder & CSIDL_FOLDER_MASK)
2908     {
2909         case CSIDL_DESKTOP:
2910             *ppidl = _ILCreateDesktop();
2911             break;
2912
2913         case CSIDL_PERSONAL:
2914             *ppidl = _ILCreateMyDocuments();
2915             break;
2916
2917         case CSIDL_INTERNET:
2918             *ppidl = _ILCreateIExplore();
2919             break;
2920
2921         case CSIDL_CONTROLS:
2922             *ppidl = _ILCreateControlPanel();
2923             break;
2924
2925         case CSIDL_PRINTERS:
2926             *ppidl = _ILCreatePrinters();
2927             break;
2928
2929         case CSIDL_BITBUCKET:
2930             *ppidl = _ILCreateBitBucket();
2931             break;
2932
2933         case CSIDL_DRIVES:
2934             *ppidl = _ILCreateMyComputer();
2935             break;
2936
2937         case CSIDL_NETWORK:
2938             *ppidl = _ILCreateNetwork();
2939             break;
2940
2941         default:
2942         {
2943             WCHAR szPath[MAX_PATH];
2944
2945             hr = SHGetFolderPathW(hwndOwner, nFolder, hToken,
2946              SHGFP_TYPE_CURRENT, szPath);
2947             if (SUCCEEDED(hr))
2948             {
2949                 DWORD attributes=0;
2950
2951                 TRACE("Value=%s\n", debugstr_w(szPath));
2952                 hr = SHILCreateFromPathW(szPath, ppidl, &attributes);
2953             }
2954             else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
2955             {
2956                 /* unlike SHGetFolderPath, SHGetFolderLocation in shell32
2957                  * version 6.0 returns E_FAIL for nonexistent paths
2958                  */
2959                 hr = E_FAIL;
2960             }
2961         }
2962     }
2963     if(*ppidl)
2964         hr = NOERROR;
2965
2966     TRACE("-- (new pidl %p)\n",*ppidl);
2967     return hr;
2968 }
2969
2970 /*************************************************************************
2971  * SHGetSpecialFolderLocation           [SHELL32.@]
2972  *
2973  * NOTES
2974  *   In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
2975  *   directory.
2976  */
2977 HRESULT WINAPI SHGetSpecialFolderLocation(
2978         HWND hwndOwner,
2979         INT nFolder,
2980         LPITEMIDLIST * ppidl)
2981 {
2982     HRESULT hr = E_INVALIDARG;
2983
2984     TRACE("(%p,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
2985
2986     if (!ppidl)
2987         return E_INVALIDARG;
2988
2989     hr = SHGetFolderLocation(hwndOwner, nFolder, NULL, 0, ppidl);
2990     return hr;
2991 }
2992
2993 static int csidl_from_id( const KNOWNFOLDERID *id )
2994 {
2995     int i;
2996     for (i = 0; i < sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]); i++)
2997         if (IsEqualGUID( CSIDL_Data[i].id, id )) return i;
2998     return -1;
2999 }
3000
3001 /*************************************************************************
3002  * SHGetKnownFolderPath           [SHELL32.@]
3003  */
3004 HRESULT WINAPI SHGetKnownFolderPath(REFKNOWNFOLDERID rfid, DWORD flags, HANDLE token, PWSTR *path)
3005 {
3006     HRESULT hr;
3007     WCHAR folder[MAX_PATH];
3008     int index = csidl_from_id( rfid );
3009
3010     TRACE("%s, 0x%08x, %p, %p\n", debugstr_guid(rfid), flags, token, path);
3011
3012     if (index < 0)
3013         return E_INVALIDARG;
3014
3015     if (flags & KF_FLAG_CREATE)
3016         index |= CSIDL_FLAG_CREATE;
3017
3018     if (flags & KF_FLAG_DONT_VERIFY)
3019         index |= CSIDL_FLAG_DONT_VERIFY;
3020
3021     if (flags & KF_FLAG_NO_ALIAS)
3022         index |= CSIDL_FLAG_NO_ALIAS;
3023
3024     if (flags & KF_FLAG_INIT)
3025         index |= CSIDL_FLAG_PER_USER_INIT;
3026
3027     if (flags & ~(KF_FLAG_CREATE|KF_FLAG_DONT_VERIFY|KF_FLAG_NO_ALIAS|KF_FLAG_INIT))
3028     {
3029         FIXME("flags 0x%08x not supported\n", flags);
3030         return E_INVALIDARG;
3031     }
3032
3033     hr = SHGetFolderPathW( NULL, index, token, 0, folder );
3034     if (SUCCEEDED(hr))
3035     {
3036         *path = CoTaskMemAlloc( (strlenW( folder ) + 1) * sizeof(WCHAR) );
3037         if (!*path)
3038             return E_OUTOFMEMORY;
3039         strcpyW( *path, folder );
3040     }
3041     return hr;
3042 }
3043
3044 /*************************************************************************
3045  * SHGetFolderPathEx           [SHELL32.@]
3046  */
3047 HRESULT WINAPI SHGetFolderPathEx(REFKNOWNFOLDERID rfid, DWORD flags, HANDLE token, LPWSTR path, DWORD len)
3048 {
3049     HRESULT hr;
3050     WCHAR *buffer;
3051
3052     TRACE("%s, 0x%08x, %p, %p, %u\n", debugstr_guid(rfid), flags, token, path, len);
3053
3054     if (!path || !len) return E_INVALIDARG;
3055
3056     hr = SHGetKnownFolderPath( rfid, flags, token, &buffer );
3057     if (SUCCEEDED( hr ))
3058     {
3059         if (strlenW( buffer ) + 1 > len)
3060         {
3061             CoTaskMemFree( buffer );
3062             return HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER );
3063         }
3064         strcpyW( path, buffer );
3065         CoTaskMemFree( buffer );
3066     }
3067     return hr;
3068 }
3069
3070 /* constant values used by known folder functions */
3071 static const WCHAR szCategory[] = {'C','a','t','e','g','o','r','y',0};
3072 static const WCHAR szName[] = {'N','a','m','e',0};
3073 static const WCHAR szRelativePath[] = {'R','e','l','a','t','i','v','e','P','a','t','h',0};
3074 static const WCHAR szParentFolder[] = {'P','a','r','e','n','t','F','o','l','d','e','r',0};
3075
3076 /*
3077  * Internal function to convert known folder identifier to path of registry key
3078  * associated with known folder.
3079  *
3080  * Parameters:
3081  *  rfid            [I] pointer to known folder identifier (may be NULL)
3082  *  lpStringGuid    [I] string with known folder identifier (used when rfid is NULL)
3083  *  lpPath          [O] place to store string address. String should be
3084  *                      later freed using HeapFree(GetProcessHeap(),0, ... )
3085  */
3086 static HRESULT get_known_folder_registry_path(
3087     REFKNOWNFOLDERID rfid,
3088     LPWSTR lpStringGuid,
3089     LPWSTR *lpPath)
3090 {
3091     static const WCHAR sBackslash[] = {'\\',0};
3092     HRESULT hr = S_OK;
3093     int length;
3094     WCHAR sGuid[50];
3095
3096     TRACE("(%s, %s, %p)\n", debugstr_guid(rfid), debugstr_w(lpStringGuid), lpPath);
3097
3098     if(rfid)
3099         StringFromGUID2(rfid, sGuid, sizeof(sGuid)/sizeof(sGuid[0]));
3100     else
3101         lstrcpyW(sGuid, lpStringGuid);
3102
3103     length = lstrlenW(szKnownFolderDescriptions)+51;
3104     *lpPath = HeapAlloc(GetProcessHeap(), 0, length*sizeof(WCHAR));
3105     if(!(*lpPath))
3106         hr = E_OUTOFMEMORY;
3107
3108     if(SUCCEEDED(hr))
3109     {
3110         lstrcpyW(*lpPath, szKnownFolderDescriptions);
3111         lstrcatW(*lpPath, sBackslash);
3112         lstrcatW(*lpPath, sGuid);
3113     }
3114
3115     return hr;
3116 }
3117
3118 /*
3119  * Internal function to get place where folder redirection information are stored.
3120  *
3121  * Parameters:
3122  *  rfid            [I] pointer to known folder identifier (may be NULL)
3123  *  rootKey         [O] root key where the redirection information are stored
3124  *                      It can be HKLM for COMMON folders, and HKCU for PERUSER folders.
3125  *                      However, besides root key, path is always that same, and is stored
3126  *                      as "szKnownFolderRedirections" constant
3127  */
3128 static HRESULT get_known_folder_redirection_place(
3129     REFKNOWNFOLDERID rfid,
3130     HKEY *rootKey)
3131 {
3132     HRESULT hr;
3133     LPWSTR lpRegistryPath = NULL;
3134     KF_CATEGORY category;
3135     DWORD dwSize;
3136
3137     /* first, get known folder's category */
3138     hr = get_known_folder_registry_path(rfid, NULL, &lpRegistryPath);
3139
3140     if(SUCCEEDED(hr))
3141     {
3142         dwSize = sizeof(category);
3143         hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, lpRegistryPath, szCategory, RRF_RT_DWORD, NULL, &category, &dwSize));
3144     }
3145
3146     if(SUCCEEDED(hr))
3147     {
3148         if(category == KF_CATEGORY_COMMON)
3149         {
3150             *rootKey = HKEY_LOCAL_MACHINE;
3151             hr = S_OK;
3152         }
3153         else if(category == KF_CATEGORY_PERUSER)
3154         {
3155             *rootKey = HKEY_CURRENT_USER;
3156             hr = S_OK;
3157         }
3158         else
3159             hr = E_FAIL;
3160     }
3161
3162     HeapFree(GetProcessHeap(), 0, lpRegistryPath);
3163     return hr;
3164 }
3165
3166 static HRESULT get_known_folder_path_by_id(REFKNOWNFOLDERID folderId, LPWSTR lpRegistryPath, DWORD dwFlags, LPWSTR *ppszPath);
3167
3168 static HRESULT get_known_folder_category(
3169     LPWSTR registryPath,
3170     KF_CATEGORY* pCategory)
3171 {
3172     DWORD dwSize = sizeof(DWORD);
3173     DWORD dwType;
3174     return HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, szCategory, RRF_RT_DWORD, &dwType, pCategory, &dwSize));
3175 }
3176
3177 static HRESULT redirect_known_folder(
3178     REFKNOWNFOLDERID rfid,
3179     HWND hwnd,
3180     KF_REDIRECT_FLAGS flags,
3181     LPCWSTR pszTargetPath,
3182     UINT cFolders,
3183     KNOWNFOLDERID const *pExclusion,
3184     LPWSTR *ppszError)
3185 {
3186     HRESULT hr;
3187     HKEY rootKey = HKEY_LOCAL_MACHINE, hKey;
3188     WCHAR sGuid[39];
3189     LPWSTR lpRegistryPath = NULL, lpSrcPath = NULL;
3190     TRACE("(%s, %p, 0x%08x, %s, %d, %p, %p)\n", debugstr_guid(rfid), hwnd, flags, debugstr_w(pszTargetPath), cFolders, pExclusion, ppszError);
3191
3192     if (ppszError) *ppszError = NULL;
3193
3194     hr = get_known_folder_registry_path(rfid, NULL, &lpRegistryPath);
3195
3196     if(SUCCEEDED(hr))
3197         hr = get_known_folder_path_by_id(rfid, lpRegistryPath, 0, &lpSrcPath);
3198
3199     HeapFree(GetProcessHeap(), 0, lpRegistryPath);
3200
3201     /* get path to redirection storage */
3202     if(SUCCEEDED(hr))
3203         hr = get_known_folder_redirection_place(rfid, &rootKey);
3204
3205     /* write redirection information */
3206     if(SUCCEEDED(hr))
3207         hr = HRESULT_FROM_WIN32(RegCreateKeyExW(rootKey, szKnownFolderRedirections, 0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL));
3208
3209     if(SUCCEEDED(hr))
3210     {
3211         StringFromGUID2(rfid, sGuid, sizeof(sGuid)/sizeof(sGuid[0]));
3212
3213         hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, sGuid, 0, REG_SZ, (LPBYTE)pszTargetPath, (lstrlenW(pszTargetPath)+1)*sizeof(WCHAR)));
3214
3215         RegCloseKey(hKey);
3216     }
3217
3218     /* make sure destination path exists */
3219     SHCreateDirectory(NULL, pszTargetPath);
3220
3221     /* copy content if required */
3222     if(SUCCEEDED(hr) && (flags & KF_REDIRECT_COPY_CONTENTS) )
3223     {
3224         static const WCHAR sWildcard[] = {'\\','*',0};
3225         WCHAR srcPath[MAX_PATH+1], dstPath[MAX_PATH+1];
3226         SHFILEOPSTRUCTW fileOp;
3227
3228         ZeroMemory(srcPath, sizeof(srcPath));
3229         lstrcpyW(srcPath, lpSrcPath);
3230         lstrcatW(srcPath, sWildcard);
3231
3232         ZeroMemory(dstPath, sizeof(dstPath));
3233         lstrcpyW(dstPath, pszTargetPath);
3234
3235         ZeroMemory(&fileOp, sizeof(fileOp));
3236
3237         if(flags & KF_REDIRECT_DEL_SOURCE_CONTENTS)
3238             fileOp.wFunc = FO_MOVE;
3239         else
3240             fileOp.wFunc = FO_COPY;
3241
3242         fileOp.pFrom = srcPath;
3243         fileOp.pTo = dstPath;
3244         fileOp.fFlags = FOF_NO_UI;
3245
3246         hr = (SHFileOperationW(&fileOp)==0 ? S_OK : E_FAIL);
3247
3248         if(flags & KF_REDIRECT_DEL_SOURCE_CONTENTS)
3249         {
3250             ZeroMemory(srcPath, sizeof(srcPath));
3251             lstrcpyW(srcPath, lpSrcPath);
3252
3253             ZeroMemory(&fileOp, sizeof(fileOp));
3254             fileOp.wFunc = FO_DELETE;
3255             fileOp.pFrom = srcPath;
3256             fileOp.fFlags = FOF_NO_UI;
3257
3258             hr = (SHFileOperationW(&fileOp)==0 ? S_OK : E_FAIL);
3259         }
3260     }
3261
3262     CoTaskMemFree(lpSrcPath);
3263
3264     return hr;
3265 }
3266
3267
3268 struct knownfolder
3269 {
3270     IKnownFolder IKnownFolder_iface;
3271     LONG refs;
3272     KNOWNFOLDERID id;
3273     LPWSTR registryPath;
3274 };
3275
3276 static inline struct knownfolder *impl_from_IKnownFolder( IKnownFolder *iface )
3277 {
3278     return CONTAINING_RECORD( iface, struct knownfolder, IKnownFolder_iface );
3279 }
3280
3281 static ULONG WINAPI knownfolder_AddRef(
3282     IKnownFolder *iface )
3283 {
3284     struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
3285     return InterlockedIncrement( &knownfolder->refs );
3286 }
3287
3288 static ULONG WINAPI knownfolder_Release(
3289     IKnownFolder *iface )
3290 {
3291     struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
3292     LONG refs = InterlockedDecrement( &knownfolder->refs );
3293     if (!refs)
3294     {
3295         TRACE("destroying %p\n", knownfolder);
3296         HeapFree( GetProcessHeap(), 0, knownfolder->registryPath);
3297         HeapFree( GetProcessHeap(), 0, knownfolder );
3298     }
3299     return refs;
3300 }
3301
3302 static HRESULT WINAPI knownfolder_QueryInterface(
3303     IKnownFolder *iface,
3304     REFIID riid,
3305     void **ppv )
3306 {
3307     struct knownfolder *This = impl_from_IKnownFolder( iface );
3308
3309     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppv );
3310
3311     if ( IsEqualGUID( riid, &IID_IKnownFolder ) ||
3312          IsEqualGUID( riid, &IID_IUnknown ) )
3313     {
3314         *ppv = iface;
3315     }
3316     else
3317     {
3318         FIXME("interface %s not implemented\n", debugstr_guid(riid));
3319         return E_NOINTERFACE;
3320     }
3321     IKnownFolder_AddRef( iface );
3322     return S_OK;
3323 }
3324
3325 static HRESULT knownfolder_set_id(
3326     struct knownfolder *knownfolder,
3327     const KNOWNFOLDERID *kfid)
3328 {
3329     HKEY hKey;
3330     HRESULT hr;
3331
3332     TRACE("%s\n", debugstr_guid(kfid));
3333
3334     knownfolder->id = *kfid;
3335
3336     /* check is it registry-registered folder */
3337     hr = get_known_folder_registry_path(kfid, NULL, &knownfolder->registryPath);
3338     if(SUCCEEDED(hr))
3339         hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_LOCAL_MACHINE, knownfolder->registryPath, 0, 0, &hKey));
3340
3341     if(SUCCEEDED(hr))
3342     {
3343         hr = S_OK;
3344         RegCloseKey(hKey);
3345     }
3346     else
3347     {
3348         /* This known folder is not registered. To mark it, we set registryPath to NULL */
3349         HeapFree(GetProcessHeap(), 0, knownfolder->registryPath);
3350         knownfolder->registryPath = NULL;
3351         hr = S_OK;
3352     }
3353
3354     return hr;
3355 }
3356
3357 static HRESULT WINAPI knownfolder_GetId(
3358     IKnownFolder *iface,
3359     KNOWNFOLDERID *pkfid)
3360 {
3361     struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
3362
3363     TRACE("%p\n", pkfid);
3364
3365     *pkfid = knownfolder->id;
3366     return S_OK;
3367 }
3368
3369 static HRESULT WINAPI knownfolder_GetCategory(
3370     IKnownFolder *iface,
3371     KF_CATEGORY *pCategory)
3372 {
3373     struct knownfolder *knownfolder = impl_from_IKnownFolder(iface);
3374     HRESULT hr = S_OK;
3375
3376     TRACE("%p, %p\n", knownfolder, pCategory);
3377
3378     /* we cannot get a category for a folder which is not registered */
3379     if(!knownfolder->registryPath)
3380         hr = E_FAIL;
3381
3382     if(SUCCEEDED(hr))
3383         hr = get_known_folder_category(knownfolder->registryPath, pCategory);
3384
3385     return hr;
3386 }
3387
3388 static HRESULT WINAPI knownfolder_GetShellItem(
3389     IKnownFolder *iface,
3390     DWORD dwFlags,
3391     REFIID riid,
3392     void **ppv)
3393 {
3394     FIXME("0x%08x, %s, %p\n", dwFlags, debugstr_guid(riid), ppv);
3395     return E_NOTIMPL;
3396 }
3397
3398 static HRESULT get_known_folder_path(
3399     LPWSTR sFolderId,
3400     LPWSTR registryPath,
3401     LPWSTR *ppszPath)
3402 {
3403     static const WCHAR sBackslash[] = {'\\',0};
3404     HRESULT hr;
3405     DWORD dwSize, dwType;
3406     WCHAR path[MAX_PATH] = {0};
3407     WCHAR parentGuid[39];
3408     KF_CATEGORY category;
3409     LPWSTR parentRegistryPath, parentPath;
3410     HKEY hRedirectionRootKey = NULL;
3411
3412     TRACE("(%s, %p)\n", debugstr_w(registryPath), ppszPath);
3413     *ppszPath = NULL;
3414
3415     /* check if folder has parent */
3416     dwSize = sizeof(parentGuid);
3417     hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, szParentFolder, RRF_RT_REG_SZ, &dwType, parentGuid, &dwSize));
3418     if(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) hr = S_FALSE;
3419
3420     if(hr == S_OK)
3421     {
3422         /* get parent's known folder path (recursive) */
3423         hr = get_known_folder_registry_path(NULL, parentGuid, &parentRegistryPath);
3424         if(FAILED(hr)) return hr;
3425
3426         hr = get_known_folder_path(parentGuid, parentRegistryPath, &parentPath);
3427         if(FAILED(hr)) {
3428             HeapFree(GetProcessHeap(), 0, parentRegistryPath);
3429             return hr;
3430         }
3431
3432         lstrcatW(path, parentPath);
3433         lstrcatW(path, sBackslash);
3434
3435         HeapFree(GetProcessHeap(), 0, parentRegistryPath);
3436         HeapFree(GetProcessHeap(), 0, parentPath);
3437     }
3438
3439     /* check, if folder was redirected */
3440     if(SUCCEEDED(hr))
3441         hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, szCategory, RRF_RT_REG_DWORD, NULL, &category, &dwSize));
3442
3443     if(SUCCEEDED(hr))
3444     {
3445         if(category == KF_CATEGORY_COMMON)
3446             hRedirectionRootKey = HKEY_LOCAL_MACHINE;
3447         else if(category == KF_CATEGORY_PERUSER)
3448             hRedirectionRootKey = HKEY_CURRENT_USER;
3449
3450         if(hRedirectionRootKey)
3451         {
3452             hr = HRESULT_FROM_WIN32(RegGetValueW(hRedirectionRootKey, szKnownFolderRedirections, sFolderId, RRF_RT_REG_SZ, NULL, NULL, &dwSize));
3453
3454             if(SUCCEEDED(hr))
3455             {
3456                 *ppszPath = CoTaskMemAlloc(dwSize+(lstrlenW(path)+1)*sizeof(WCHAR));
3457                 if(!*ppszPath) hr = E_OUTOFMEMORY;
3458             }
3459
3460             if(SUCCEEDED(hr))
3461             {
3462                 lstrcpyW(*ppszPath, path);
3463                 hr = HRESULT_FROM_WIN32(RegGetValueW(hRedirectionRootKey, szKnownFolderRedirections, sFolderId, RRF_RT_REG_SZ, NULL, *ppszPath + lstrlenW(path), &dwSize));
3464             }
3465         }
3466
3467         if(!*ppszPath)
3468         {
3469             /* no redirection, use previous way - read the relative path from folder definition */
3470             hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, szRelativePath, RRF_RT_REG_SZ, &dwType, NULL, &dwSize));
3471
3472             if(SUCCEEDED(hr))
3473             {
3474                 *ppszPath = CoTaskMemAlloc(dwSize+(lstrlenW(path)+1)*sizeof(WCHAR));
3475                 if(!*ppszPath) hr = E_OUTOFMEMORY;
3476             }
3477
3478             if(SUCCEEDED(hr))
3479             {
3480                 lstrcpyW(*ppszPath, path);
3481                 hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, szRelativePath, RRF_RT_REG_SZ, &dwType, *ppszPath + lstrlenW(path), &dwSize));
3482             }
3483         }
3484     }
3485
3486     TRACE("returning path: %s\n", debugstr_w(*ppszPath));
3487     return hr;
3488 }
3489
3490 static HRESULT get_known_folder_path_by_id(
3491     REFKNOWNFOLDERID folderId,
3492     LPWSTR lpRegistryPath,
3493     DWORD dwFlags,
3494     LPWSTR *ppszPath)
3495 {
3496     HRESULT hr;
3497     WCHAR sGuid[39];
3498     DWORD dwAttributes;
3499
3500     TRACE("(%s, %s, 0x%08x, %p)\n", debugstr_guid(folderId), debugstr_w(lpRegistryPath), dwFlags, ppszPath);
3501
3502     /* if this is registry-registered known folder, get path from registry */
3503     if(lpRegistryPath)
3504     {
3505         StringFromGUID2(folderId, sGuid, sizeof(sGuid)/sizeof(sGuid[0]));
3506
3507         hr = get_known_folder_path(sGuid, lpRegistryPath, ppszPath);
3508     }
3509     /* in other case, use older way */
3510     else
3511         hr = SHGetKnownFolderPath( folderId, dwFlags, NULL, ppszPath );
3512
3513     /* check if known folder really exists */
3514     dwAttributes = GetFileAttributesW(*ppszPath);
3515     if(dwAttributes == INVALID_FILE_ATTRIBUTES || !(dwAttributes & FILE_ATTRIBUTE_DIRECTORY) )
3516     {
3517         TRACE("directory %s not found\n", debugstr_w(*ppszPath));
3518         CoTaskMemFree(*ppszPath);
3519         *ppszPath = NULL;
3520         hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
3521     }
3522
3523     return hr;
3524 }
3525
3526 static HRESULT WINAPI knownfolder_GetPath(
3527     IKnownFolder *iface,
3528     DWORD dwFlags,
3529     LPWSTR *ppszPath)
3530 {
3531     struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
3532     TRACE("(%p, 0x%08x, %p)\n", knownfolder, dwFlags, ppszPath);
3533
3534     return get_known_folder_path_by_id(&knownfolder->id, knownfolder->registryPath, dwFlags, ppszPath);
3535 }
3536
3537 static HRESULT WINAPI knownfolder_SetPath(
3538     IKnownFolder *iface,
3539     DWORD dwFlags,
3540     LPCWSTR pszPath)
3541 {
3542     struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
3543     HRESULT hr = S_OK;
3544
3545     TRACE("(%p, 0x%08x, %p)\n", knownfolder, dwFlags, debugstr_w(pszPath));
3546
3547     /* check if the known folder is registered */
3548     if(!knownfolder->registryPath)
3549         hr = E_FAIL;
3550
3551     if(SUCCEEDED(hr))
3552         hr = redirect_known_folder(&knownfolder->id, NULL, 0, pszPath, 0, NULL, NULL);
3553
3554     return hr;
3555 }
3556
3557 static HRESULT WINAPI knownfolder_GetIDList(
3558     IKnownFolder *iface,
3559     DWORD dwFlags,
3560     PIDLIST_ABSOLUTE *ppidl)
3561 {
3562     FIXME("0x%08x, %p\n", dwFlags, ppidl);
3563     return E_NOTIMPL;
3564 }
3565
3566 static HRESULT WINAPI knownfolder_GetFolderType(
3567     IKnownFolder *iface,
3568     FOLDERTYPEID *pftid)
3569 {
3570     FIXME("%p\n", pftid);
3571     return E_NOTIMPL;
3572 }
3573
3574 static HRESULT WINAPI knownfolder_GetRedirectionCapabilities(
3575     IKnownFolder *iface,
3576     KF_REDIRECTION_CAPABILITIES *pCapabilities)
3577 {
3578     FIXME("%p\n", pCapabilities);
3579     return E_NOTIMPL;
3580 }
3581
3582 static HRESULT WINAPI knownfolder_GetFolderDefinition(
3583     IKnownFolder *iface,
3584     KNOWNFOLDER_DEFINITION *pKFD)
3585 {
3586     struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
3587     HRESULT hr;
3588     DWORD dwSize;
3589     TRACE("(%p, %p)\n", knownfolder, pKFD);
3590
3591     if(!pKFD) return E_INVALIDARG;
3592
3593     ZeroMemory(pKFD, sizeof(*pKFD));
3594
3595     hr = get_known_folder_category(knownfolder->registryPath, &pKFD->category);
3596
3597     if(SUCCEEDED(hr))
3598         hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, knownfolder->registryPath, szName, RRF_RT_REG_SZ, NULL, NULL, &dwSize));
3599
3600     if(SUCCEEDED(hr))
3601     {
3602         pKFD->pszName = CoTaskMemAlloc(dwSize);
3603         if(!pKFD->pszName) hr = E_OUTOFMEMORY;
3604     }
3605
3606     if(SUCCEEDED(hr))
3607         hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, knownfolder->registryPath, szName, RRF_RT_REG_SZ, NULL, pKFD->pszName, &dwSize));
3608
3609     return hr;
3610 }
3611
3612 static const struct IKnownFolderVtbl knownfolder_vtbl =
3613 {
3614     knownfolder_QueryInterface,
3615     knownfolder_AddRef,
3616     knownfolder_Release,
3617     knownfolder_GetId,
3618     knownfolder_GetCategory,
3619     knownfolder_GetShellItem,
3620     knownfolder_GetPath,
3621     knownfolder_SetPath,
3622     knownfolder_GetIDList,
3623     knownfolder_GetFolderType,
3624     knownfolder_GetRedirectionCapabilities,
3625     knownfolder_GetFolderDefinition
3626 };
3627
3628 static HRESULT knownfolder_create( struct knownfolder **knownfolder )
3629 {
3630     struct knownfolder *kf;
3631
3632     kf = HeapAlloc( GetProcessHeap(), 0, sizeof(*kf) );
3633     if (!kf) return E_OUTOFMEMORY;
3634
3635     kf->IKnownFolder_iface.lpVtbl = &knownfolder_vtbl;
3636     kf->refs = 1;
3637     memset( &kf->id, 0, sizeof(kf->id) );
3638     kf->registryPath = NULL;
3639
3640     *knownfolder = kf;
3641
3642     TRACE("returning iface %p\n", &kf->IKnownFolder_iface);
3643     return S_OK;
3644 }
3645
3646 struct foldermanager
3647 {
3648     IKnownFolderManager IKnownFolderManager_iface;
3649     LONG refs;
3650     UINT num_ids;
3651     KNOWNFOLDERID *ids;
3652 };
3653
3654 static inline struct foldermanager *impl_from_IKnownFolderManager( IKnownFolderManager *iface )
3655 {
3656     return CONTAINING_RECORD( iface, struct foldermanager, IKnownFolderManager_iface );
3657 }
3658
3659 static ULONG WINAPI foldermanager_AddRef(
3660     IKnownFolderManager *iface )
3661 {
3662     struct foldermanager *foldermanager = impl_from_IKnownFolderManager( iface );
3663     return InterlockedIncrement( &foldermanager->refs );
3664 }
3665
3666 static ULONG WINAPI foldermanager_Release(
3667     IKnownFolderManager *iface )
3668 {
3669     struct foldermanager *foldermanager = impl_from_IKnownFolderManager( iface );
3670     LONG refs = InterlockedDecrement( &foldermanager->refs );
3671     if (!refs)
3672     {
3673         TRACE("destroying %p\n", foldermanager);
3674         HeapFree( GetProcessHeap(), 0, foldermanager->ids );
3675         HeapFree( GetProcessHeap(), 0, foldermanager );
3676     }
3677     return refs;
3678 }
3679
3680 static HRESULT WINAPI foldermanager_QueryInterface(
3681     IKnownFolderManager *iface,
3682     REFIID riid,
3683     void **ppv )
3684 {
3685     struct foldermanager *This = impl_from_IKnownFolderManager( iface );
3686
3687     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppv );
3688
3689     if ( IsEqualGUID( riid, &IID_IKnownFolderManager ) ||
3690          IsEqualGUID( riid, &IID_IUnknown ) )
3691     {
3692         *ppv = iface;
3693     }
3694     else
3695     {
3696         FIXME("interface %s not implemented\n", debugstr_guid(riid));
3697         return E_NOINTERFACE;
3698     }
3699     IKnownFolderManager_AddRef( iface );
3700     return S_OK;
3701 }
3702
3703 static HRESULT WINAPI foldermanager_FolderIdFromCsidl(
3704     IKnownFolderManager *iface,
3705     int nCsidl,
3706     KNOWNFOLDERID *pfid)
3707 {
3708     TRACE("%d, %p\n", nCsidl, pfid);
3709
3710     if (nCsidl >= sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]))
3711         return E_INVALIDARG;
3712     *pfid = *CSIDL_Data[nCsidl].id;
3713     return S_OK;
3714 }
3715
3716 static HRESULT WINAPI foldermanager_FolderIdToCsidl(
3717     IKnownFolderManager *iface,
3718     REFKNOWNFOLDERID rfid,
3719     int *pnCsidl)
3720 {
3721     int csidl;
3722
3723     TRACE("%s, %p\n", debugstr_guid(rfid), pnCsidl);
3724
3725     csidl = csidl_from_id( rfid );
3726     if (csidl == -1) return E_INVALIDARG;
3727     *pnCsidl = csidl;
3728     return S_OK;
3729 }
3730
3731 static HRESULT WINAPI foldermanager_GetFolderIds(
3732     IKnownFolderManager *iface,
3733     KNOWNFOLDERID **ppKFId,
3734     UINT *pCount)
3735 {
3736     struct foldermanager *fm = impl_from_IKnownFolderManager( iface );
3737
3738     TRACE("%p, %p\n", ppKFId, pCount);
3739
3740     *ppKFId = fm->ids;
3741     *pCount = fm->num_ids;
3742     return S_OK;
3743 }
3744
3745 static BOOL is_knownfolder( struct foldermanager *fm, const KNOWNFOLDERID *id )
3746 {
3747     UINT i;
3748     HRESULT hr;
3749     LPWSTR registryPath = NULL;
3750     HKEY hKey;
3751
3752     /* TODO: move all entries from "CSIDL_Data" static array to registry known folder descriptions */
3753     for (i = 0; i < fm->num_ids; i++)
3754         if (IsEqualGUID( &fm->ids[i], id )) return TRUE;
3755
3756     hr = get_known_folder_registry_path(id, NULL, &registryPath);
3757     if(SUCCEEDED(hr))
3758         hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_LOCAL_MACHINE, registryPath, 0, 0, &hKey));
3759
3760     if(SUCCEEDED(hr))
3761     {
3762         hr = S_OK;
3763         RegCloseKey(hKey);
3764     }
3765
3766     return hr == S_OK;
3767 }
3768
3769 static HRESULT WINAPI foldermanager_GetFolder(
3770     IKnownFolderManager *iface,
3771     REFKNOWNFOLDERID rfid,
3772     IKnownFolder **ppkf)
3773 {
3774     struct foldermanager *fm = impl_from_IKnownFolderManager( iface );
3775     struct knownfolder *kf;
3776     HRESULT hr;
3777
3778     TRACE("%s, %p\n", debugstr_guid(rfid), ppkf);
3779
3780     if (!is_knownfolder( fm, rfid ))
3781     {
3782         WARN("unknown folder\n");
3783         return E_INVALIDARG;
3784     }
3785     hr = knownfolder_create( &kf );
3786     if (SUCCEEDED( hr ))
3787     {
3788         hr = knownfolder_set_id( kf, rfid );
3789         *ppkf = &kf->IKnownFolder_iface;
3790     }
3791     else
3792         *ppkf = NULL;
3793
3794     return hr;
3795 }
3796
3797 static HRESULT WINAPI foldermanager_GetFolderByName(
3798     IKnownFolderManager *iface,
3799     LPCWSTR pszCanonicalName,
3800     IKnownFolder **ppkf)
3801 {
3802     FIXME("%s, %p\n", debugstr_w(pszCanonicalName), ppkf);
3803     return E_NOTIMPL;
3804 }
3805
3806 static HRESULT WINAPI foldermanager_RegisterFolder(
3807     IKnownFolderManager *iface,
3808     REFKNOWNFOLDERID rfid,
3809     KNOWNFOLDER_DEFINITION const *pKFD)
3810 {
3811     HRESULT hr;
3812     HKEY hKey = NULL;
3813     DWORD dwDisp;
3814     LPWSTR registryPath = NULL;
3815     TRACE("(%p, %s, %p)\n", iface, debugstr_guid(rfid), pKFD);
3816
3817     hr = get_known_folder_registry_path(rfid, NULL, &registryPath);
3818     TRACE("registry path: %s\n", debugstr_w(registryPath));
3819
3820     if(SUCCEEDED(hr))
3821         hr = HRESULT_FROM_WIN32(RegCreateKeyExW(HKEY_LOCAL_MACHINE, registryPath, 0, NULL, 0, KEY_WRITE, 0, &hKey, &dwDisp));
3822
3823     if(SUCCEEDED(hr))
3824     {
3825         if(dwDisp == REG_OPENED_EXISTING_KEY)
3826             hr = E_FAIL;
3827
3828         if(SUCCEEDED(hr))
3829             hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, szCategory, 0, REG_DWORD, (LPBYTE)&pKFD->category, sizeof(pKFD->category)));
3830
3831         if(SUCCEEDED(hr))
3832             hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, szName, 0, REG_SZ, (LPBYTE)pKFD->pszName, (lstrlenW(pKFD->pszName)+1)*sizeof(WCHAR) ));
3833
3834         if(SUCCEEDED(hr) && !IsEqualGUID(&pKFD->fidParent, &GUID_NULL))
3835         {
3836             WCHAR sParentGuid[39];
3837             StringFromGUID2(&pKFD->fidParent, sParentGuid, sizeof(sParentGuid)/sizeof(sParentGuid[0]));
3838
3839             /* this known folder has parent folder */
3840             hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, szParentFolder, 0, REG_SZ, (LPBYTE)sParentGuid, sizeof(sParentGuid)));
3841         }
3842
3843         if(SUCCEEDED(hr) && pKFD->category != KF_CATEGORY_VIRTUAL)
3844         {
3845             if(!pKFD->pszRelativePath)
3846                 hr = E_INVALIDARG;
3847
3848             if(SUCCEEDED(hr))
3849                 hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, szRelativePath, 0, REG_SZ, (LPBYTE)pKFD->pszRelativePath, (lstrlenW(pKFD->pszRelativePath)+1)*sizeof(WCHAR) ));
3850         }
3851
3852         RegCloseKey(hKey);
3853
3854         if(FAILED(hr))
3855             SHDeleteKeyW(HKEY_LOCAL_MACHINE, registryPath);
3856     }
3857
3858     HeapFree(GetProcessHeap(), 0, registryPath);
3859     return hr;
3860 }
3861
3862 static HRESULT WINAPI foldermanager_UnregisterFolder(
3863     IKnownFolderManager *iface,
3864     REFKNOWNFOLDERID rfid)
3865 {
3866     HRESULT hr;
3867     LPWSTR registryPath = NULL;
3868     TRACE("(%p, %s)\n", iface, debugstr_guid(rfid));
3869
3870     hr = get_known_folder_registry_path(rfid, NULL, &registryPath);
3871
3872     if(SUCCEEDED(hr))
3873         hr = HRESULT_FROM_WIN32(SHDeleteKeyW(HKEY_LOCAL_MACHINE, registryPath));
3874
3875     HeapFree(GetProcessHeap(), 0, registryPath);
3876     return hr;
3877 }
3878
3879 static HRESULT WINAPI foldermanager_FindFolderFromPath(
3880     IKnownFolderManager *iface,
3881     LPCWSTR pszPath,
3882     FFFP_MODE mode,
3883     IKnownFolder **ppkf)
3884 {
3885     FIXME("%s, 0x%08x, %p\n", debugstr_w(pszPath), mode, ppkf);
3886     return E_NOTIMPL;
3887 }
3888
3889 static HRESULT WINAPI foldermanager_FindFolderFromIDList(
3890     IKnownFolderManager *iface,
3891     PCIDLIST_ABSOLUTE pidl,
3892     IKnownFolder **ppkf)
3893 {
3894     FIXME("%p, %p\n", pidl, ppkf);
3895     return E_NOTIMPL;
3896 }
3897
3898 static HRESULT WINAPI foldermanager_Redirect(
3899     IKnownFolderManager *iface,
3900     REFKNOWNFOLDERID rfid,
3901     HWND hwnd,
3902     KF_REDIRECT_FLAGS flags,
3903     LPCWSTR pszTargetPath,
3904     UINT cFolders,
3905     KNOWNFOLDERID const *pExclusion,
3906     LPWSTR *ppszError)
3907 {
3908     return redirect_known_folder(rfid, hwnd, flags, pszTargetPath, cFolders, pExclusion, ppszError);
3909 }
3910
3911 static const struct IKnownFolderManagerVtbl foldermanager_vtbl =
3912 {
3913     foldermanager_QueryInterface,
3914     foldermanager_AddRef,
3915     foldermanager_Release,
3916     foldermanager_FolderIdFromCsidl,
3917     foldermanager_FolderIdToCsidl,
3918     foldermanager_GetFolderIds,
3919     foldermanager_GetFolder,
3920     foldermanager_GetFolderByName,
3921     foldermanager_RegisterFolder,
3922     foldermanager_UnregisterFolder,
3923     foldermanager_FindFolderFromPath,
3924     foldermanager_FindFolderFromIDList,
3925     foldermanager_Redirect
3926 };
3927
3928 static HRESULT foldermanager_create( void **ppv )
3929 {
3930     UINT i, j;
3931     struct foldermanager *fm;
3932
3933     fm = HeapAlloc( GetProcessHeap(), 0, sizeof(*fm) );
3934     if (!fm) return E_OUTOFMEMORY;
3935
3936     fm->IKnownFolderManager_iface.lpVtbl = &foldermanager_vtbl;
3937     fm->refs = 1;
3938     fm->num_ids = 0;
3939
3940     for (i = 0; i < sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]); i++)
3941     {
3942         if (!IsEqualGUID( CSIDL_Data[i].id, &GUID_NULL )) fm->num_ids++;
3943     }
3944     fm->ids = HeapAlloc( GetProcessHeap(), 0, fm->num_ids * sizeof(KNOWNFOLDERID) );
3945     if (!fm->ids)
3946     {
3947         HeapFree( GetProcessHeap(), 0, fm );
3948         return E_OUTOFMEMORY;
3949     }
3950     for (i = j = 0; i < sizeof(CSIDL_Data) / sizeof(CSIDL_Data[0]); i++)
3951     {
3952         if (!IsEqualGUID( CSIDL_Data[i].id, &GUID_NULL ))
3953         {
3954             fm->ids[j] = *CSIDL_Data[i].id;
3955             j++;
3956         }
3957     }
3958     TRACE("found %u known folders\n", fm->num_ids);
3959     *ppv = &fm->IKnownFolderManager_iface;
3960
3961     TRACE("returning iface %p\n", *ppv);
3962     return S_OK;
3963 }
3964
3965 HRESULT WINAPI KnownFolderManager_Constructor( IUnknown *punk, REFIID riid, void **ppv )
3966 {
3967     TRACE("%p, %s, %p\n", punk, debugstr_guid(riid), ppv);
3968
3969     if (!ppv)
3970         return E_POINTER;
3971     if (punk)
3972         return CLASS_E_NOAGGREGATION;
3973
3974     return foldermanager_create( ppv );
3975 }