Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
folder.c
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 70k
Category:

Windows Kernel

Development Platform:

Visual C++

folder.c：Code Content
  1. #include "shellprv.h"
  2. #pragma  hdrstop
  4. #include <userenv.h>
  5. #include "drives.h"
  6. #include "apithk.h"
  7. #include "folder.h"
  9. //---------------------------------------------------------------------------
  10. // Get the path for the CSIDL_ folders  and optionally create it if it
  11. // doesn't exist.
  12. //
  13. // Returns FALSE if the special folder given isn't one of those above or the
  14. // directory couldn't be created.
  15. // By default all the special folders are in the windows directory.
  16. // This can be overidden by a [.Shell Folders] section in win.ini with
  17. // entries like Desktop = c:stuffdesktop
  18. // This in turn can be overidden by a "per user" section in win.ini eg
  19. // [Shell Folder Ianel] - the user name for this section is the current
  20. // network user name, if this fails the default network user name is used
  21. // and if this fails the name given at setup time is used.
  22. //
  23. // "Shell Folders" is the key that records all the absolute paths to the
  24. // shell folders.  The values there are always supposed to be present.
  25. //
  26. // "User Shell Folders" is the key where the user's modifications from
  27. // the defaults are stored.  On Win9x, since we don't use env vars to encode
  28. // the path, If a folder is in the default location, the
  29. // corresponding value is not present under this key. this is to make roaming
  30. // work. on NT we use env vars so this is not an issue. it's only found
  31. // under "Shell Folders".
  32. //
  33. // When we need to find the location of a path, we look in "User Shell Folders"
  34. // first, and if that's not there, generate the default path.  In either
  35. // case we then write the absolute path under "Shell Folders" for other
  36. // apps to look at.  This is so that HKEY_CURRENT_USER can be propagated
  37. // to a machine with Windows installed in a different directory, and as
  38. // long as the user hasn't changed the setting, they won't have the other
  39. // Windows directory hard-coded in the registry.
  40. //   -- gregj, 11/10/94
  42. typedef enum {
  43.     SDIF_CREATE_IN_ROOT         = 0x00000001,   // create in root (not in profiles dir)
  44.     SDIF_CREATE_IN_WINDIR       = 0x00000002,   // create in the windows dir (not in profiles dir)
  45.     SDIF_CREATE_IN_ALLUSERS     = 0x00000003,   // create in "All Users" folder (not in profiles dir)
  46.     SDIF_CREATE_IN_MYDOCUMENTS  = 0x00000004,   // create in CSIDL_PERSONAL folder
  47.     SDIF_CREATE_IN_MASK         = 0x0000000F,   // mask for above values
  49.     SDIF_CAN_DELETE             = 0x00000010,
  50.     SDIF_SHORTCUT_RELATIVE      = 0x00000020,   // make shortcuts relative to this folder
  51.     SDIF_HIDE                   = 0x00000040,   // hide these when we create them
  52.     SDIF_EMPTY_IF_NOT_IN_REG    = 0x00000080,   // does not exist if nothing in the registry
  53.     SDIF_NOT_FILESYS            = 0x00000100,   // not a file system folder
  54.     SDIF_NOT_TRACKED            = 0x00000200,   // don't track this, it can't change
  55.     SDIF_CONST_IDLIST           = 0x00000400,   // don't alloc or free this
  56.     SDIF_REMOVABLE              = 0x00000800,   // Can exist on removable media
  57.     SDIF_CANT_MOVE_RENAME       = 0x00001000,   // can't move or rename this
  58.     SDIF_WX86                   = 0x00002000,   // do Wx86 thunking
  59.     SDIF_NETWORKABLE            = 0x00004000,   // Can be moved to the net
  60. } FOLDER_FLAGS;
  62. typedef struct {
  63.     int id;                     // CSIDL_ value
  64.     int idsDefault;             // string id of default folder name name
  65.     LPCTSTR pszValueName;       // reg key (not localized)
  66.     HKEY hKey;                  // HKCU or HKLM (Current User or Local Machine)
  67.     FOLDER_FLAGS dwFlags;
  68. } FOLDER_INFO;
  70. const FOLDER_INFO c_rgFolderInfo[] = 
  71. {
  72.     { CSIDL_DESKTOP,   IDS_CSIDL_DESKTOPDIRECTORY, TEXT("DesktopFolder"), NULL, SDIF_NOT_TRACKED | SDIF_CONST_IDLIST },
  73.     { CSIDL_NETWORK,   -1, TEXT("NetworkFolder"), NULL, SDIF_NOT_TRACKED | SDIF_NOT_FILESYS | SDIF_CONST_IDLIST },
  74.     { CSIDL_DRIVES,    -1, TEXT("DriveFolder"), NULL, SDIF_NOT_TRACKED | SDIF_NOT_FILESYS | SDIF_CONST_IDLIST },
  75.     { CSIDL_INTERNET,  -1, TEXT("InternetFolder"), NULL, SDIF_NOT_TRACKED | SDIF_NOT_FILESYS | SDIF_CONST_IDLIST },
  76.     { CSIDL_CONTROLS,  -1, TEXT("ControlPanelFolder"), NULL, SDIF_NOT_TRACKED | SDIF_NOT_FILESYS },
  77.     { CSIDL_PRINTERS,  -1, TEXT("PrintersFolder"), NULL, SDIF_NOT_TRACKED | SDIF_NOT_FILESYS } ,
  78.     { CSIDL_BITBUCKET, -1, TEXT("RecycleBinFolder"), NULL, SDIF_NOT_TRACKED | SDIF_NOT_FILESYS },
  79.     { CSIDL_CONNECTIONS, -1, TEXT("ConnectionsFolder"), NULL, SDIF_NOT_TRACKED | SDIF_NOT_FILESYS | SDIF_CONST_IDLIST },
  81.     { CSIDL_FONTS, IDS_CSIDL_FONTS, TEXT("Fonts"), HKEY_CURRENT_USER, SDIF_NOT_TRACKED | SDIF_CREATE_IN_WINDIR | SDIF_CANT_MOVE_RENAME },
  83.     { CSIDL_DESKTOPDIRECTORY, IDS_CSIDL_DESKTOPDIRECTORY, TEXT("Desktop"), HKEY_CURRENT_USER, SDIF_SHORTCUT_RELATIVE },
  85.     // _STARTUP is a subfolder of _PROGRAMS is a subfolder of _STARTMENU -- keep that order
  86.     { CSIDL_STARTUP,    IDS_CSIDL_STARTUP, TEXT("Startup"), HKEY_CURRENT_USER, 0 },
  87.     { CSIDL_PROGRAMS,   IDS_CSIDL_PROGRAMS, TEXT("Programs"), HKEY_CURRENT_USER, 0 },
  88.     { CSIDL_STARTMENU,  IDS_CSIDL_STARTMENU, TEXT("Start Menu"), HKEY_CURRENT_USER, SDIF_SHORTCUT_RELATIVE},
  90.     { CSIDL_RECENT,     IDS_CSIDL_RECENT, TEXT("Recent"), HKEY_CURRENT_USER, SDIF_HIDE | SDIF_CANT_MOVE_RENAME },
  92.     { CSIDL_SENDTO,     IDS_CSIDL_SENDTO, TEXT("SendTo"), HKEY_CURRENT_USER, SDIF_HIDE },
  93.     { CSIDL_PERSONAL,   IDS_CSIDL_PERSONAL, TEXT("Personal"), HKEY_CURRENT_USER, SDIF_SHORTCUT_RELATIVE | SDIF_NETWORKABLE | SDIF_REMOVABLE },
  94.     { CSIDL_FAVORITES,  IDS_CSIDL_FAVORITES, TEXT("Favorites"), HKEY_CURRENT_USER, 0 },
  96.     { CSIDL_NETHOOD,    IDS_CSIDL_NETHOOD, TEXT("NetHood"), HKEY_CURRENT_USER, SDIF_HIDE },
  97.     { CSIDL_PRINTHOOD,  IDS_CSIDL_PRINTHOOD, TEXT("PrintHood"), HKEY_CURRENT_USER, SDIF_HIDE },
  98.     { CSIDL_TEMPLATES,  IDS_CSIDL_TEMPLATES, TEXT("Templates"), HKEY_CURRENT_USER, SDIF_HIDE },
  100.     // Common special folders
  102.     // _STARTUP is a subfolder of _PROGRAMS is a subfolder of _STARTMENU -- keep that order
  104.     { CSIDL_COMMON_STARTUP,  IDS_CSIDL_STARTUP,    TEXT("Common Startup"), HKEY_LOCAL_MACHINE, SDIF_EMPTY_IF_NOT_IN_REG | SDIF_CREATE_IN_ALLUSERS | SDIF_CANT_MOVE_RENAME},
  105.     { CSIDL_COMMON_PROGRAMS,  IDS_CSIDL_PROGRAMS,  TEXT("Common Programs"), HKEY_LOCAL_MACHINE, SDIF_EMPTY_IF_NOT_IN_REG | SDIF_CREATE_IN_ALLUSERS },
  106.     { CSIDL_COMMON_STARTMENU, IDS_CSIDL_STARTMENU, TEXT("Common Start Menu"), HKEY_LOCAL_MACHINE, SDIF_EMPTY_IF_NOT_IN_REG | SDIF_SHORTCUT_RELATIVE | SDIF_CREATE_IN_ALLUSERS },
  107.     { CSIDL_COMMON_DESKTOPDIRECTORY, IDS_CSIDL_DESKTOPDIRECTORY, TEXT("Common Desktop"), HKEY_LOCAL_MACHINE, SDIF_EMPTY_IF_NOT_IN_REG | SDIF_SHORTCUT_RELATIVE | SDIF_CREATE_IN_ALLUSERS },
  108.     { CSIDL_COMMON_FAVORITES, IDS_CSIDL_FAVORITES, TEXT("Common Favorites"), HKEY_LOCAL_MACHINE, SDIF_EMPTY_IF_NOT_IN_REG | SDIF_CREATE_IN_ALLUSERS },
  110.     { CSIDL_COMMON_APPDATA,   IDS_CSIDL_APPDATA,   TEXT("Common AppData"),   HKEY_LOCAL_MACHINE, SDIF_SHORTCUT_RELATIVE | SDIF_CREATE_IN_ALLUSERS },
  111.     { CSIDL_COMMON_TEMPLATES, IDS_CSIDL_TEMPLATES, TEXT("Common Templates"), HKEY_LOCAL_MACHINE, SDIF_NOT_TRACKED | SDIF_CAN_DELETE | SDIF_CREATE_IN_ALLUSERS },
  112.     { CSIDL_COMMON_DOCUMENTS, IDS_CSIDL_ALLUSERS_DOCUMENTS, TEXT("Common Documents"), HKEY_LOCAL_MACHINE, SDIF_NOT_TRACKED | SDIF_CAN_DELETE | SDIF_CREATE_IN_ALLUSERS },
  114.     // Application Data special folder
  116.     { CSIDL_APPDATA, IDS_CSIDL_APPDATA, TEXT("AppData"), HKEY_CURRENT_USER, SDIF_SHORTCUT_RELATIVE },
  117.     { CSIDL_LOCAL_APPDATA, IDS_CSIDL_LOCAL_APPDATA, TEXT("Local AppData"), HKEY_CURRENT_USER, 0 },
  119.     // Non-localized startup folder (do not localize this folde name)
  120.     { CSIDL_ALTSTARTUP, IDS_CSIDL_ALTSTARTUP, TEXT("AltStartup"), HKEY_CURRENT_USER, SDIF_EMPTY_IF_NOT_IN_REG },
  122.     // Non-localized Common StartUp group (do not localize this folde name)
  123.     { CSIDL_COMMON_ALTSTARTUP, IDS_CSIDL_ALTSTARTUP, TEXT("Common AltStartup"), HKEY_LOCAL_MACHINE, SDIF_EMPTY_IF_NOT_IN_REG | SDIF_CREATE_IN_ALLUSERS },
  125.     // Per-user Internet-related folders
  127.     { CSIDL_INTERNET_CACHE, IDS_CSIDL_CACHE, TEXT("Cache"), HKEY_CURRENT_USER, 0 },
  128.     { CSIDL_COOKIES, IDS_CSIDL_COOKIES, TEXT("Cookies"), HKEY_CURRENT_USER, 0 },
  129.     { CSIDL_HISTORY, IDS_CSIDL_HISTORY, TEXT("History"), HKEY_CURRENT_USER, 0 },
  131.     { CSIDL_WINDOWS,                0, TEXT("Windows"), 0, SDIF_NOT_TRACKED | SDIF_SHORTCUT_RELATIVE | SDIF_CANT_MOVE_RENAME },
  132.     { CSIDL_SYSTEM,                 0, TEXT("System"), 0, SDIF_NOT_TRACKED | SDIF_CANT_MOVE_RENAME },
  133.     { CSIDL_PROGRAM_FILES,          0, TEXT("ProgramFiles"), 0, SDIF_NOT_TRACKED | SDIF_CAN_DELETE | SDIF_SHORTCUT_RELATIVE },
  134.     { CSIDL_PROGRAM_FILES_COMMON,   0, TEXT("CommonProgramFiles"), 0, SDIF_NOT_TRACKED | SDIF_CAN_DELETE },
  135.     { CSIDL_PROFILE,                0, TEXT("Profile"), 0, SDIF_NOT_TRACKED | SDIF_CANT_MOVE_RENAME },
  136.     { CSIDL_MYPICTURES, IDS_CSIDL_MYPICTURES, TEXT("My Pictures"), HKEY_CURRENT_USER, SDIF_CAN_DELETE | SDIF_NETWORKABLE | SDIF_REMOVABLE | SDIF_CREATE_IN_MYDOCUMENTS },
  138.     { CSIDL_SYSTEMX86, 0, TEXT("SystemX86"), 0, SDIF_NOT_TRACKED | SDIF_CANT_MOVE_RENAME | SDIF_WX86 },
  140. #ifdef WX86
  141.     { CSIDL_PROGRAM_FILESX86,          0, TEXT("ProgramFilesX86"), 0, SDIF_NOT_TRACKED | SDIF_CAN_DELETE | SDIF_SHORTCUT_RELATIVE|SDIF_WX86},
  142.     { CSIDL_PROGRAM_FILES_COMMONX86,   0, TEXT("CommonProgramFilesX86"), 0, SDIF_NOT_TRACKED | SDIF_CAN_DELETE | SDIF_WX86 },
  143. #else
  144.     { CSIDL_PROGRAM_FILESX86,          0, TEXT("ProgramFilesX86"), 0, SDIF_NOT_TRACKED | SDIF_CAN_DELETE | SDIF_SHORTCUT_RELATIVE},
  145.     { CSIDL_PROGRAM_FILES_COMMONX86,   0, TEXT("CommonProgramFilesX86"), 0, SDIF_NOT_TRACKED | SDIF_CAN_DELETE },
  146. #endif
  147.     { CSIDL_ADMINTOOLS,         IDS_CSIDL_ADMINTOOLS, TEXT("Administrative Tools"), HKEY_CURRENT_USER, 0 },
  148.     { CSIDL_COMMON_ADMINTOOLS,  IDS_CSIDL_ADMINTOOLS, TEXT("Common Administrative Tools"), HKEY_LOCAL_MACHINE, SDIF_CREATE_IN_ALLUSERS },
  150.     { -1, 0, NULL, 0, 0 },
  151. };
  153. // this array holds a cache of the valures of these folders. this cache can only
  154. // be used in the hToken == NULL case otherwise we would need a per user version
  155. // of this cache.
  157. #define SFENTRY(x)  { (LPTSTR)-1, (LPITEMIDLIST)x }
  159. EXTERN_C const IDREGITEM c_aidlConnections[];
  161. struct {
  162.     LPTSTR       psz;
  163.     LPITEMIDLIST pidl;
  164. } g_aFolderCache[] = {
  165.     SFENTRY(&c_idlDesktop),    // CSIDL_DESKTOP                   (0x0000)
  166.     SFENTRY(&c_idlInetRoot),   // CSIDL_INTERNET                  (0x0001)
  167.     SFENTRY(-1),               // CSIDL_PROGRAMS                  (0x0002)
  168.     SFENTRY(-1),               // CSIDL_CONTROLS                  (0x0003)
  169.     SFENTRY(-1),               // CSIDL_PRINTERS                  (0x0004)
  170.     SFENTRY(-1),               // CSIDL_PERSONAL                  (0x0005)
  171.     SFENTRY(-1),               // CSIDL_FAVORITES                 (0x0006)
  172.     SFENTRY(-1),               // CSIDL_STARTUP                   (0x0007)
  173.     SFENTRY(-1),               // CSIDL_RECENT                    (0x0008)
  174.     SFENTRY(-1),               // CSIDL_SENDTO                    (0x0009)
  175.     SFENTRY(-1),               // CSIDL_BITBUCKET                 (0x000a)
  176.     SFENTRY(-1),               // CSIDL_STARTMENU                 (0x000b)
  177.     SFENTRY(-1),               // <unused>                        (0x000c)
  178.     SFENTRY(-1),               // <unused>                        (0x000d)
  179.     SFENTRY(-1),               // <unused>                        (0x000e)
  180.     SFENTRY(-1),               // <unused>                        (0x000f)
  181.     SFENTRY(-1),               // CSIDL_DESKTOPDIRECTORY          (0x0010)
  182.     SFENTRY(&c_idlDrives),     // CSIDL_DRIVES                    (0x0011)
  183.     SFENTRY(&c_idlNet),        // CSIDL_NETWORK                   (0x0012)
  184.     SFENTRY(-1),               // CSIDL_NETHOOD                   (0x0013)
  185.     SFENTRY(-1),               // CSIDL_FONTS                     (0x0014)
  186.     SFENTRY(-1),               // CSIDL_TEMPLATES                 (0x0015)
  187.     SFENTRY(-1),               // CSIDL_COMMON_STARTMENU          (0x0016)
  188.     SFENTRY(-1),               // CSIDL_COMMON_PROGRAMS           (0X0017)
  189.     SFENTRY(-1),               // CSIDL_COMMON_STARTUP            (0x0018)
  190.     SFENTRY(-1),               // CSIDL_COMMON_DESKTOPDIRECTORY   (0x0019)
  191.     SFENTRY(-1),               // CSIDL_APPDATA                   (0x001a)
  192.     SFENTRY(-1),               // CSIDL_PRINTHOOD                 (0x001b)
  193.     SFENTRY(-1),               // CSIDL_LOCAL_APPDATA             (0x001c)
  194.     SFENTRY(-1),               // CSIDL_ALTSTARTUP                (0x001d)
  195.     SFENTRY(-1),               // CSIDL_COMMON_ALTSTARTUP         (0x001e)
  196.     SFENTRY(-1),               // CSIDL_COMMON_FAVORITES          (0x001f)
  197.     SFENTRY(-1),               // CSIDL_INTERNET_CACHE            (0x0020)
  198.     SFENTRY(-1),               // CSIDL_COOKIES                   (0x0021)
  199.     SFENTRY(-1),               // CSIDL_HISTORY                   (0x0022)
  200.     SFENTRY(-1),               // CSIDL_COMMON_APPDATA            (0x0023)
  201.     SFENTRY(-1),               // CSIDL_WINDOWS                   (0x0024)
  202.     SFENTRY(-1),               // CSIDL_SYSTEM                    (0x0025)
  203.     SFENTRY(-1),               // CSIDL_PROGRAM_FILES             (0x0026)
  204.     SFENTRY(-1),               // CSIDL_MYPICTURES                (0x0027)
  205.     SFENTRY(-1),               // CSIDL_PROFILE                   (0x0028)
  206.     SFENTRY(-1),               // CSIDL_SYSTEMX86                 (0x0029)
  207.     SFENTRY(-1),               // CSIDL_PROGRAM_FILESX86          (0x002a)
  208.     SFENTRY(-1),               // CSIDL_PROGRAM_FILES_COMMON      (0x002b)
  209.     SFENTRY(-1),               // CSIDL_PROGRAM_FILES_COMMONX86   (0x002c)
  210.     SFENTRY(-1),               // CSIDL_COMMON_TEMPLATES          (0x002d)
  211.     SFENTRY(-1),               // CSIDL_COMMON_DOCUMENTS          (0x002e)
  212.     SFENTRY(-1),               // CSIDL_COMMON_ADMINTOOLS         (0x002f)
  213.     SFENTRY(-1),               // CSIDL_ADMINTOOLS                (0x0030)
  214.     SFENTRY(c_aidlConnections), // CSIDL_CONNECTIONS              (0x0031)
  215. };
  217. HRESULT _OpenKeyForFolder(const FOLDER_INFO *pfi, HANDLE hToken, LPCTSTR pszSubKey, HKEY *phkey);
  218. void _UpdateShellFolderCache(void);
  219. BOOL GetUserProfileDir(HANDLE hToken, TCHAR *pszPath);
  220. HRESULT VerifyAndCreateFolder(HWND hwnd, const FOLDER_INFO *pfi, UINT uFlags, LPTSTR pszPath) ;
  223. #define _IsDefaultUserToken(hToken)     ((HANDLE)-1 == hToken)
  226. const FOLDER_INFO *_GetFolderInfo(int csidl)
  227. {
  228.     const FOLDER_INFO *pfi;
  230.     // make sure g_aFolderCache can be indexed by the CSIDL values
  232.     COMPILETIME_ASSERT((ARRAYSIZE(g_aFolderCache) - 1) == CSIDL_CONNECTIONS);
  234.     for (pfi = c_rgFolderInfo; pfi->id != -1; pfi++)
  235.     {
  236.         if (pfi->id == csidl)
  237.             return pfi;
  238.     }
  239.     return NULL;
  240. }
  243. // expand an individual enviornment variable
  244. // in:
  245. //      pszVar      "%USERPROFILE%
  246. //      pszValue    "c:winntprofilesuser"
  247. //
  248. // in/out:
  249. //      pszToExpand in: %USERPROFILE%My Docs", out: c:winntprofilesuserMy Docs"
  251. BOOL ExpandEnvVar(LPCTSTR pszVar, LPCTSTR pszValue, LPTSTR pszToExpand)
  252. {
  253.     TCHAR *pszStart = StrStrI(pszToExpand, pszVar);
  254.     if (pszStart)
  255.     {
  256.         TCHAR szAfter[MAX_PATH];
  258.         lstrcpy(szAfter, pszStart + lstrlen(pszVar));   // save the tail
  259.         lstrcpyn(pszStart, pszValue, (int) (MAX_PATH - (pszStart - pszToExpand)));
  260.         StrCatBuff(pszToExpand, szAfter, MAX_PATH);       // put the tail back on
  261.         return TRUE;
  262.     }
  263.     return FALSE;
  264. }
  266. HANDLE GetCurrentUserToken()
  267. {
  268.     HANDLE hToken;
  269.     if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_IMPERSONATE, TRUE, &hToken) ||
  270.         OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_IMPERSONATE, &hToken))
  271.         return hToken;
  272.     return NULL;
  273. }
  276. // like ExpandEnvironmentStrings but is robust to the enviornment variables
  277. // not being set. this works on...
  278. // %SYSTEMROOT%
  279. // %SYSTEMDRIVE%
  280. // %USERPROFILE%
  281. // %ALLUSERSPROFILE%
  282. //
  283. // in the rare case (Winstone!) that there is a NULL enviornment block
  285. DWORD ExpandEnvironmentStringsNoEnv(HANDLE hToken, LPCTSTR pszExpand, LPTSTR pszOut, UINT cchOut)
  286. {
  287.     TCHAR szPath[MAX_PATH];
  288. #ifdef WINNT
  289.     if (hToken && !_IsDefaultUserToken(hToken))
  290.     {
  291.         if (!ExpandEnvironmentStringsForUser(hToken, pszExpand, pszOut, cchOut))
  292.             lstrcpyn(pszOut, pszExpand, cchOut);
  293.     }
  294.     else if (hToken == NULL)
  295. #endif
  296.     {
  297.         // to debug env expansion failure...
  298.         // lstrcpyn(pszOut, pszExpand, cchOut);
  299.         SHExpandEnvironmentStrings(pszExpand, pszOut, cchOut);
  300.     }
  302.     // manually expand in this order since 
  303.     //  %USERPROFILE% -> %SYSTEMDRIVE%Docs & Settings
  305. #ifdef WINNT
  306.     if (StrChr(pszOut, TEXT('%')) && (hToken == NULL))
  307.     {
  308.         hToken = GetCurrentUserToken();
  309.         if (hToken)
  310.         {
  311.             // this does %USERPROFILE% and other per user stuff
  312.             ExpandEnvironmentStringsForUser(hToken, pszExpand, pszOut, cchOut);
  313.             CloseHandle(hToken);
  314.         }
  315.     }
  316.     else if (_IsDefaultUserToken(hToken) && StrChr(pszOut, TEXT('%')))
  317.     {
  318.         GetUserProfileDir(hToken, szPath);
  319.         ExpandEnvVar(TEXT("%USERPROFILE%"), szPath, pszOut);
  320.     }
  321. #endif
  323.     if (*pszOut == TEXT('%'))
  324.     {
  325.         GetAllUsersDirectory(szPath);
  326.         ExpandEnvVar(TEXT("%ALLUSERSPROFILE%"), szPath, pszOut);
  327.     }
  329.     if (*pszOut == TEXT('%'))
  330.     {
  331.         GetSystemWindowsDirectory(szPath, ARRAYSIZE(szPath));
  332.         ExpandEnvVar(TEXT("%SYSTEMROOT%"), szPath, pszOut);
  333.     }
  335.     if (*pszOut == TEXT('%'))
  336.     {
  337.         GetSystemWindowsDirectory(szPath, ARRAYSIZE(szPath));
  338.         ASSERT(szPath[1] == TEXT(':')); // this better not be a UNC!
  339.         szPath[2] = TEXT(''); // SYSTEMDRIVE = 'c:', not 'c:'
  340.         ExpandEnvVar(TEXT("%SYSTEMDRIVE%"), szPath, pszOut);
  341.     }
  343.     if (*pszOut == TEXT('%'))
  344.         *pszOut = 0;
  346.     return lstrlen(pszOut) + 1;    // +1 to cover the NULL
  347. }
  349. // get the user profile directory:
  350. // on Win9x: reads from the registry and FAILS if user profiles are not turned on
  351. // on NT: uses the hToken as needed to determine the proper user profile
  353. BOOL GetUserProfileDir(HANDLE hToken, TCHAR *pszPath)
  354. {
  355. #ifdef WINNT
  356.     DWORD dwcch = MAX_PATH;
  357.     HANDLE hClose = NULL;
  358.     BOOL fRet;
  359.     
  360.     *pszPath = 0;       // in case of error
  362.     if ( !hToken )
  363.     {
  364.         hClose = hToken = GetCurrentUserToken();
  365.     }
  366.     if (_IsDefaultUserToken(hToken) && g_bRunOnNT5)
  367.     {
  368.         fRet = GetDefaultUserProfileDirectory( pszPath, &dwcch );
  369.     }
  370.     else
  371.     {
  372.         fRet = GetUserProfileDirectory( hToken, pszPath, &dwcch );
  373.     }
  374.     if ( hClose )
  375.     {
  376.         CloseHandle( hClose );
  377.     }
  378.     return fRet;
  379. #else
  380.     DWORD cbData = MAX_PATH * SIZEOF(TCHAR);
  381.     *pszPath = 0;       // in case of error
  382.     SHGetValue(HKEY_CURRENT_USER, TEXT("Software\Microsoft\Windows\CurrentVersion\ProfileReconciliation"), 
  383.         TEXT("ProfileDirectory"), NULL, pszPath, &cbData);
  384. #endif
  385.     return (BOOL)*pszPath;
  386. }
  388. #ifdef WX86
  389. void SetUseKnownWx86Dll(const FOLDER_INFO *pfi, BOOL bValue)
  390. {
  391.     if (pfi->dwFlags & SDIF_WX86)
  392.     {
  393.         //  GetSystemDirectory() knows we're looking for the Wx86 system
  394.         //  directory when this flag is set.
  395.         NtCurrentTeb()->Wx86Thread.UseKnownWx86Dll = bValue ? TRUE : FALSE;
  396.     }
  397. }
  398. #else
  399. #define SetUseKnownWx86Dll(pfi, bValue)
  400. #endif
  402. // read from registry
  403. BOOL GetProgramFiles(LPCTSTR pszValue, LPTSTR pszPath)
  404. {
  405.     DWORD cbPath = MAX_PATH * sizeof(*pszPath);
  407.     *pszPath = 0;
  409.     SHGetValue(HKEY_LOCAL_MACHINE, TEXT("Software\Microsoft\Windows\CurrentVersion"), 
  410.         pszValue, NULL, pszPath, &cbPath);
  411.     return (BOOL)*pszPath;
  412. }
  414. void LoadDefaultString(int idString, LPTSTR lpBuffer, int cchBufferMax)
  415. {
  416. #ifdef WINNT
  417.     BOOL fSucceeded = FALSE;
  418.     HRSRC hResInfo;
  419.     HANDLE hStringSeg;
  420.     LPWSTR lpsz;
  421.     int    cch;
  422.     HMODULE hmod = GetModuleHandle(TEXT("SHELL32"));
  423.     
  424.     // Make sure the parms are valid.     
  425.     if (lpBuffer == NULL || cchBufferMax == 0) 
  426.     {
  427.         return;
  428.     }
  430.     cch = 0;
  431.     
  432.     // String Tables are broken up into 16 string segments.  Find the segment
  433.     // containing the string we are interested in.     
  434.     if (hResInfo = FindResourceExW(hmod, (LPCWSTR)RT_STRING,
  435.                                    (LPWSTR)((LONG)(((USHORT)idString >> 4) + 1)), GetSystemDefaultUILanguage())) 
  436.     {        
  437.         // Load that segment.        
  438.         hStringSeg = LoadResource(hmod, hResInfo);
  439.         
  440.         // Lock the resource.        
  441.         if (lpsz = (LPWSTR)LockResource(hStringSeg)) 
  442.         {            
  443.             // Move past the other strings in this segment.
  444.             // (16 strings in a segment -> & 0x0F)             
  445.             idString &= 0x0F;
  446.             while (TRUE) 
  447.             {
  448.                 cch = *((WORD *)lpsz++);   // PASCAL like string count
  449.                                             // first UTCHAR is count if TCHARs
  450.                 if (idString-- == 0) break;
  451.                 lpsz += cch;                // Step to start if next string
  452.              }
  453.             
  454.                             
  455.             // Account for the NULL                
  456.             cchBufferMax--;
  457.                 
  458.             // Don't copy more than the max allowed.                
  459.             if (cch > cchBufferMax)
  460.                 cch = cchBufferMax;
  461.                 
  462.             // Copy the string into the buffer.                
  463.             CopyMemory(lpBuffer, lpsz, cch*sizeof(WCHAR));
  465.             // Attach Null terminator.
  466.             lpBuffer[cch] = 0;
  468.             fSucceeded = TRUE;
  470.         }
  471.     }
  473.     if (!fSucceeded)
  474. #endif
  475.     {
  476.         LoadString(HINST_THISDLL, idString, lpBuffer, cchBufferMax);
  477.     }
  478. }
  481. // out:
  482. //      pszPath     fills in with the full path with no env gunk (MAX_PATH)
  484. HRESULT _GetFolderDefaultPath(const FOLDER_INFO *pfi, HANDLE hToken, LPTSTR pszPath)
  485. {
  486.     TCHAR szEntry[MAX_PATH];
  488.     *pszPath = 0;
  490.     switch (pfi->id)
  491.     {
  492.     case CSIDL_PROFILE:
  493.         GetUserProfileDir(hToken, pszPath);
  494.         break;
  496.     case CSIDL_PROGRAM_FILES:
  497.         GetProgramFiles(TEXT("ProgramFilesDir"), pszPath);
  498.         break;
  501.     case CSIDL_PROGRAM_FILES_COMMON:
  502.         GetProgramFiles(TEXT("CommonFilesDir"  ), pszPath);
  503.         break;
  505.     case CSIDL_PROGRAM_FILESX86:
  506.         GetProgramFiles(TEXT("ProgramFilesDir (x86)"), pszPath);
  507.         break;
  509.     case CSIDL_PROGRAM_FILES_COMMONX86:
  510.         GetProgramFiles(TEXT("CommonFilesDir (x86)"), pszPath);
  511.         break;
  513.     case CSIDL_SYSTEMX86:
  514.     case CSIDL_SYSTEM:
  515.         // tell GetSystemDirectory() we are know what we are doing
  516.         SetUseKnownWx86Dll(pfi, TRUE);
  517.         GetSystemDirectory(pszPath, MAX_PATH);
  518.         SetUseKnownWx86Dll(pfi, FALSE);
  519.         break;
  521.     case CSIDL_WINDOWS:
  522.         GetWindowsDirectory(pszPath, MAX_PATH);
  523.         break;
  525.     default:
  526.         switch (pfi->dwFlags & SDIF_CREATE_IN_MASK)
  527.         {
  528.         case SDIF_CREATE_IN_ROOT:
  529.             GetWindowsDirectory(pszPath, MAX_PATH);
  530.             PathStripToRoot(pszPath);
  531.             break;
  533.         case SDIF_CREATE_IN_ALLUSERS:
  534.             GetAllUsersDirectory(pszPath);
  535.             break;
  537.         case SDIF_CREATE_IN_WINDIR:
  538.             GetWindowsDirectory(pszPath, MAX_PATH);
  539.             break;
  541.         case SDIF_CREATE_IN_MYDOCUMENTS:
  542.         {
  543.             HRESULT hr = SHGetFolderPath(NULL, CSIDL_PERSONAL, hToken, SHGFP_TYPE_CURRENT, pszPath);
  544.             if (FAILED(hr))
  545.             {
  546.                 return hr;
  547.             }
  548.             break;
  549.         }
  551.         default:
  552.             if (!GetUserProfileDir(hToken, pszPath))
  553.             {
  554.                 // Win9x, failed to get user profile dir. Using windows directory...
  555.                 GetWindowsDirectory(pszPath, MAX_PATH);
  556.                 if (pfi->id == CSIDL_PERSONAL) 
  557.                 {
  558.                     PathStripToRoot(pszPath);
  559.                 }
  560.             }
  561.             break;
  562.         }
  564.         LoadDefaultString(pfi->idsDefault, szEntry, ARRAYSIZE(szEntry));
  565.         PathAppend(pszPath, szEntry);
  566.         break;
  567.     }
  568.     return *pszPath ? S_OK : E_FAIL;
  569. }
  572. void RegSetFolderPath(const FOLDER_INFO *pfi, LPCTSTR pszSubKey, LPCTSTR pszPath)
  573. {
  574.     HKEY hk;
  575.     if (SUCCEEDED(_OpenKeyForFolder(pfi, NULL, pszSubKey, &hk)))
  576.     {
  577.         if (pszPath)
  578.             RegSetValueEx(hk, pfi->pszValueName, 0, REG_SZ, (LPBYTE)pszPath, (1 + lstrlen(pszPath)) * SIZEOF(TCHAR));
  579.         else
  580.             RegDeleteValue(hk, pfi->pszValueName);
  581.         RegCloseKey(hk);
  582.     }
  583. }
  585. BOOL RegQueryPath(HKEY hk, LPCTSTR pszValue, LPTSTR pszPath)
  586. {
  587.     DWORD cbPath = MAX_PATH * SIZEOF(TCHAR);
  589.     *pszPath = 0;
  590.     SHQueryValueEx(hk, pszValue, 0, NULL, pszPath, &cbPath);
  591.     return (BOOL)*pszPath;
  592. }
  595. // More than 50 is silly
  596. #define MAX_TEMP_FILE_TRIES         50
  598. // returns:
  599. //      S_OK        the path exists and it is a folder
  600. //      FAILED()    result
  601. HRESULT _IsFolderNotFile(LPCTSTR pszFolder)
  602. {
  603.     HRESULT hr;
  604.     DWORD dwAttribs = GetFileAttributes(pszFolder);
  605.     if (dwAttribs == -1)
  606.     {
  607.         DWORD err = GetLastError();
  608.         hr = HRESULT_FROM_WIN32(err);
  609.     }
  610.     else
  611.     {
  612.         // see if it is a file, if so we need to rename that file
  613.         if (dwAttribs & FILE_ATTRIBUTE_DIRECTORY)
  614.         {
  615.             hr = S_OK;
  616.         }
  617.         else
  618.         {
  619.             int iExt = 0;
  620.             do
  621.             {
  622.                 TCHAR szExt[32], szDst[MAX_PATH];
  624.                 wsprintf(szExt, TEXT(".%03d"), iExt);
  625.                 lstrcpy(szDst, pszFolder);
  626.                 lstrcat(szDst, szExt);
  627.                 if (MoveFile(pszFolder, szDst))
  628.                     iExt = 0;
  629.                 else
  630.                 {
  631.                     // Normally we fail because .00x already exists but that may not be true.
  632.                     DWORD dwError = GetLastError();
  633.                     if (ERROR_ALREADY_EXISTS == dwError)
  634.                         iExt++;     // Try the next one...
  635.                     else
  636.                         iExt = 0;   // We have problems and need to give up. (No write access?)
  637.                 }
  639.             } while (iExt && (iExt < MAX_TEMP_FILE_TRIES));
  641.             hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
  642.         }
  643.     }
  644.     return hr;
  645. }
  647. HRESULT _OpenKeyForFolder(const FOLDER_INFO *pfi, HANDLE hToken, LPCTSTR pszSubKey, HKEY *phkey)
  648. {
  649.     TCHAR szRegPath[255];
  650.     LONG err;
  651.     HKEY hkRoot, hkeyToFree = NULL;
  653.     *phkey = NULL;
  655.     lstrcpy(szRegPath, TEXT("Software\Microsoft\Windows\CurrentVersion\Explorer\"));
  656.     lstrcat(szRegPath, pszSubKey);
  658. #ifdef  WINNT
  659.     if (_IsDefaultUserToken(hToken) && (pfi->hKey == HKEY_CURRENT_USER))
  660.     {
  661.         if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_USERS, TEXT(".Default"), 0, KEY_READ, &hkRoot))
  662.             hkeyToFree = hkRoot;
  663.         else
  664.             return E_FAIL;
  665.     }
  666.     else
  667. #endif
  668.     if (hToken && (pfi->hKey == HKEY_CURRENT_USER))
  669.     {
  670.         if (GetUserProfileKey(hToken, &hkRoot))
  671.             hkeyToFree = hkRoot;
  672.         else
  673.             return E_FAIL;
  674.     }
  675.     else
  676.         hkRoot = pfi->hKey;
  678.     err = RegCreateKeyEx(hkRoot, szRegPath, 0, NULL, REG_OPTION_NON_VOLATILE,
  679.                 MAXIMUM_ALLOWED, NULL, phkey, NULL);
  680.     
  681.     if (hkeyToFree)
  682.         RegCloseKey(hkeyToFree);
  684.     return HRESULT_FROM_WIN32(err);
  685. }
  687. // returns:
  688. //      S_OK        found in registry, path well formed
  689. //      S_FALSE     empty registry
  690. //      FAILED()    failure result
  692. HRESULT _GetFolderFromReg(const FOLDER_INFO *pfi, HANDLE hToken, LPTSTR pszPath)
  693. {
  694.     HKEY hkUSF;
  695.     HRESULT hr;
  697.     *pszPath = 0;
  699.     hr = _OpenKeyForFolder(pfi, hToken, TEXT("User Shell Folders"), &hkUSF);
  700.     if (SUCCEEDED(hr))
  701.     {
  702.         TCHAR szExpand[MAX_PATH];
  703.         DWORD dwType, cbPath = SIZEOF(szExpand);
  705.         if (RegQueryValueEx(hkUSF, pfi->pszValueName, 0, &dwType, (BYTE *)szExpand, &cbPath) == ERROR_SUCCESS)
  706.         {
  707.             if (REG_SZ == dwType)
  708.             {
  709.                 lstrcpyn(pszPath, szExpand, MAX_PATH);
  710.             }
  711.             else if (REG_EXPAND_SZ == dwType)
  712.             {
  713.                 ExpandEnvironmentStringsNoEnv(hToken, szExpand, pszPath, MAX_PATH);
  714.             }
  715.             TraceMsg(TF_PATH, "_CreateFolderPath 'User Shell Folders' %s = %s", pfi->pszValueName, pszPath);
  716.         }
  718.         if (*pszPath == 0)
  719.         {
  720.             hr = S_FALSE;     // empty registry, success but empty
  721.         }
  722.         else if ((PathGetDriveNumber(pszPath) != -1) || PathIsUNC(pszPath))
  723.         {
  724.             hr = S_OK;        // good reg path, fully qualified
  725.         }
  726.         else
  727.         {
  728.             *pszPath = 0;       // bad reg data
  729.             hr = E_INVALIDARG;
  730.         }
  732.         RegCloseKey(hkUSF);
  733.     }
  734.     return hr;
  735. }
  738. HRESULT _GetFolderPath(HWND hwnd, const FOLDER_INFO *pfi, HANDLE hToken, UINT uFlags, LPTSTR pszPath)
  739. {
  740.     HRESULT hr;
  742.     *pszPath = 0;       // assume failure
  744.     if (pfi->hKey)
  745.     {
  746.         hr = _GetFolderFromReg(pfi, hToken, pszPath);
  747.         if (SUCCEEDED(hr))
  748.         {
  749.             if (hr == S_FALSE)
  750.             {
  751.                 // empty registry, SDIF_EMPTY_IF_NOT_IN_REG means they don't exist
  752.                 // if the registry is not populated with a value. this lets us disable
  753.                 // the common items on platforms that don't want them
  755.                 if (pfi->dwFlags & SDIF_EMPTY_IF_NOT_IN_REG)
  756.                     return S_FALSE;     // success, but empty
  758.                 hr = _GetFolderDefaultPath(pfi, hToken, pszPath);
  759.             }
  762.             if (!(uFlags & CSIDL_FLAG_DONT_VERIFY))
  763.             {
  764.                hr = VerifyAndCreateFolder(hwnd, pfi, uFlags, pszPath) ;
  765.             }
  767.             if (hr != S_OK)
  768.                 *pszPath = 0;
  770.             if (!(uFlags & CSIDL_FLAG_DONT_VERIFY))
  771.             {
  772.                 HKEY hkey;
  773.                 // record value in "Shell Folders", even in the failure case
  775.                 // NOTE: we only do this for historical reasons. there may be some
  776.                 // apps that depend on these values being in the registry, but in general
  777.                 // the contetens here are unreliable as they are only written after someone
  778.                 // asks for the folder through this API.
  780.                 if (SUCCEEDED(_OpenKeyForFolder(pfi, hToken, TEXT("Shell Folders"), &hkey)))
  781.                 {
  782.                     RegSetValueEx(hkey, pfi->pszValueName, 0, REG_SZ, (LPBYTE)pszPath, (1 + lstrlen(pszPath)) * SIZEOF(TCHAR));
  783.                     RegCloseKey(hkey);
  784.                 }
  785.             }
  786.         }
  787.     }
  788.     else
  789.     {
  790.         hr = _GetFolderDefaultPath(pfi, hToken, pszPath);
  792.         if (S_OK == hr)
  793.         {
  794.             if (!(uFlags & CSIDL_FLAG_DONT_VERIFY))
  795.             {
  796.                 hr = VerifyAndCreateFolder(hwnd, pfi, uFlags, pszPath);
  797.             }
  798.         }
  799.         else
  800.         {
  801.             *pszPath = 0;
  802.         }
  803.     }
  804.     ASSERT(hr == S_OK ? *pszPath != 0 : *pszPath == 0);
  805.     return hr;
  806. }
  808. HRESULT VerifyAndCreateFolder(HWND hwnd, const FOLDER_INFO *pfi, UINT uFlags, LPTSTR pszPath)
  809. {
  810.     HRESULT hr ;
  812.     hr = _IsFolderNotFile(pszPath);
  814.     // 99/06/16 vtan: In the case of ERROR_ACCESS_DENIED don't
  815.     // even bother trying to do anything more with the directory.
  817.     if (hr == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED))
  818.     {
  819.         return(hr);
  820.     }
  822.     if ((hr != S_OK) && hwnd)
  823.     {
  824.         // we might be able to reconnect if this is a net path
  825.         if (PathIsUNC(pszPath))
  826.         {
  827.             if (SHValidateUNC(hwnd, pszPath, 0))
  828.                 hr = _IsFolderNotFile(pszPath);
  829.         }
  830.         else if (IsDisconnectedNetDrive(DRIVEID(pszPath)))
  831.         {
  832.             TCHAR szDrive[4];
  833.             PathBuildSimpleRoot(DRIVEID(pszPath), szDrive);
  835.             if (WNetRestoreConnection(hwnd, szDrive) == WN_SUCCESS)
  836.                 hr = _IsFolderNotFile(pszPath);
  837.          }
  838.     }
  840.     if ((hr != S_OK) && (uFlags & CSIDL_FLAG_CREATE))
  841.     {
  842.         DWORD err = SHCreateDirectory(NULL, pszPath);
  843.         hr = HRESULT_FROM_WIN32(err);
  844.         if (hr == S_OK)
  845.         {
  846. #ifdef DBG 
  847.             //  we want to fire this assert in checked builds, even when FULL_DEBUG is not on
  848.             if (StrChr(pszPath, TEXT('%')))
  849.                 DebugBreak();
  850. #endif
  851.             if (pfi->dwFlags & SDIF_HIDE)
  852.                 SetFileAttributes(pszPath, GetFileAttributes(pszPath) | FILE_ATTRIBUTE_HIDDEN);
  853.         }
  854.     }
  856.     return hr ;
  857. }
  859. void _SetPathCache(const FOLDER_INFO *pfi, LPCTSTR psz)
  860. {
  861.     LPTSTR pszOld;
  863.     AssertMsg(((LPCTSTR)-1 == psz) || (NULL == psz) || PathFileExistsAndAttributes(psz, NULL), TEXT("Caching non existant folder!"));
  865.     pszOld = (LPTSTR)InterlockedExchangePointer((void **)&g_aFolderCache[pfi->id].psz, (void *)psz);
  866.     if (pszOld && pszOld != (LPTSTR)-1)
  867.     {
  868.         // check for the concurent use... very rare case
  869.         LocalFree(pszOld);
  870.     }
  871. }
  874. HRESULT _GetFolderPathCached(HWND hwnd, const FOLDER_INFO *pfi, HANDLE hToken, UINT uFlags, LPTSTR pszPath)
  875. {
  876.     HRESULT hr;
  878.     *pszPath = 0;
  880.     // can only cache for the current user, hToken == NULL or per machine folders
  881.     if (!hToken || (pfi->hKey != HKEY_CURRENT_USER))
  882.     {
  883.         LPTSTR pszCache;
  885.         _UpdateShellFolderCache();
  887.         pszCache = (LPTSTR)InterlockedExchangePointer((void **)&g_aFolderCache[pfi->id].psz, (void *)-1);
  888.         if ((pszCache == (LPTSTR)-1) || (pszCache == NULL))
  889.         {
  890.             // either not cached or cached failed state
  891.             if ((pszCache == (LPTSTR)-1) || (uFlags & CSIDL_FLAG_CREATE))
  892.             {
  893.                 hr = _GetFolderPath(hwnd, pfi, hToken, uFlags, pszPath);
  895.                 // only set the cache value if CSIDL_FLAG_DONT_VERIFY was NOT passed
  896.                 if (!(uFlags & CSIDL_FLAG_DONT_VERIFY))
  897.                 {
  898.                     if (hr == S_OK)
  899.                     {
  900.                         // dupe the string so we can add it to the cache
  901.                         pszCache = StrDup(pszPath);
  902.                     }
  903.                     else
  904.                     {
  905.                         // we failed to get the folder path, null out the cache
  906.                         ASSERT(*pszPath == 0);
  907.                         pszCache = NULL;
  908.                     }
  909.                     _SetPathCache(pfi, pszCache);
  910.                 }
  912.                 
  913.             }
  914.             else
  915.             {
  916.                 // cache was null and user didnt pass create flag so we just fail
  917.                 ASSERT(pszCache == NULL);
  918.                 ASSERT(*pszPath == 0);
  919.                 hr = E_FAIL;
  920.             }
  921.         }
  922.         else
  923.         {
  924.             // cache hit case: copy the cached string and then restore the cached value back
  925.             lstrcpyn(pszPath, pszCache, MAX_PATH);
  926.             _SetPathCache(pfi, pszCache);
  927.             hr = S_OK;
  928.         }
  929.     }
  930.     else
  931.     {
  932.         hr = _GetFolderPath(hwnd, pfi, hToken, uFlags, pszPath);
  933.     }
  935.     return hr;
  936. }
  939. HRESULT _CreateFolderIDList(HWND hwnd, const FOLDER_INFO *pfi, HANDLE hToken, UINT uFlags, LPITEMIDLIST *ppidl)
  940. {
  941.     HRESULT hr = S_OK;
  943.     switch (pfi->id)
  944.     {
  945.     case CSIDL_PRINTERS:
  947.         if (SHGetAppCompatFlags(ACF_STAROFFICE5PRINTER))
  948.         {
  949.             // Star Office 5.0 relies on the fact that the printer pidl used to be like below.  They skip the 
  950.             // first simple pidl (My Computer) and do not check if there is anything else, they assume that the
  951.             // second simple pidl is the Printer folder one. (stephstm, 07/30/99)
  953.             // CLSID_MyComputer, CLSID_Printers
  954.             hr = SHILCreateFromPath(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\::{2227A280-3AEA-1069-A2DE-08002B30309D}"), ppidl, NULL);
  955.         }
  956.         else
  957.         {
  958.             // CLSID_MyComputer, CLSID_ControlPanel, CLSID_Printers
  959.             hr = SHILCreateFromPath(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\::{21EC2020-3AEA-1069-A2DD-08002B30309D}\::{2227A280-3AEA-1069-A2DE-08002B30309D}"), ppidl, NULL);
  960.         }
  961.         break;
  963.     case CSIDL_CONTROLS:
  964.         // CLSID_MyComputer, CLSID_ControlPanel
  965.         hr = SHILCreateFromPath(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\::{21EC2020-3AEA-1069-A2DD-08002B30309D}"), ppidl, NULL);
  966.         break;
  968.     case CSIDL_BITBUCKET:
  969.         // CLSID_RecycleBin
  970.         hr = SHILCreateFromPath(TEXT("::{645FF040-5081-101B-9F08-00AA002F954E}"), ppidl, NULL);
  971.         break;
  973.     default:
  974.         {
  975.             TCHAR szPath[MAX_PATH];
  976.             hr = _GetFolderPathCached(hwnd, pfi, hToken, uFlags, szPath);
  977.             if (hr == S_OK)
  978.             {
  979.                 HRESULT hrInit = SHCoInitialize();
  980.                 hr = ILCreateFromPathEx(szPath, NULL, ILCFP_FLAG_SKIPJUNCTIONS, ppidl, NULL);
  981.                 SHCoUninitialize(hrInit);
  982.             }
  983.             else
  984.             {
  985.                 *ppidl = NULL;      // assume failure or empty
  986.             }
  987.         }
  988.         break;
  989.     }
  990.     return hr;
  991. }
  993. void _SetIDListCache(const FOLDER_INFO *pfi, LPCITEMIDLIST pidl)
  994. {
  995.     if (!(pfi->dwFlags & SDIF_CONST_IDLIST))
  996.     {
  997.         LPITEMIDLIST pidlOld = (LPITEMIDLIST)InterlockedExchangePointer((void **)&g_aFolderCache[pfi->id].pidl, (void *)pidl);
  998.         if (pidlOld && pidlOld != (LPITEMIDLIST)-1)
  999.         {
  1000.             // check for the concurent use... very rare case
  1001.             // ASSERT(pidl == (LPCITEMIDLIST)-1);   // should not really be ASSERT
  1002.             ILFree(pidlOld);
  1003.         }
  1004.     }
  1005. }
  1007. // hold this lock for the minimal amout of time possible to avoid other users
  1008. // of this resource requring them to re-create the pidl
  1010. HRESULT _GetFolderIDListCached(HWND hwnd, const FOLDER_INFO *pfi, UINT uFlags, LPITEMIDLIST *ppidl)
  1011. {
  1012.     HRESULT hr;
  1014.     ASSERT(pfi->id < ARRAYSIZE(g_aFolderCache));
  1016.     if (pfi->dwFlags & SDIF_CONST_IDLIST)
  1017.     {
  1018.         // these are CONST, never change
  1019.         hr = SHILClone(g_aFolderCache[pfi->id].pidl, ppidl);     
  1020.     }
  1021.     else
  1022.     {
  1023.         LPITEMIDLIST pidlCache;
  1025.         _UpdateShellFolderCache();
  1027.         pidlCache = (LPITEMIDLIST)InterlockedExchangePointer((void **)&g_aFolderCache[pfi->id].pidl, (void *)-1);
  1028.         if ((pidlCache == (LPCITEMIDLIST)-1) || (pidlCache == NULL))
  1029.         {
  1030.             // either uninitalized cache state OR cached failure (NULL)
  1031.             if ((pidlCache == (LPCITEMIDLIST)-1) || (uFlags & CSIDL_FLAG_CREATE))
  1032.             {
  1033.                 // not initialized (or concurent use) try creating it for this use
  1034.                 hr = _CreateFolderIDList(hwnd, pfi, NULL, uFlags, ppidl);
  1035.                 if (S_OK == hr)
  1036.                     hr = SHILClone(*ppidl, &pidlCache); // create cache copy
  1037.                 else
  1038.                     pidlCache = NULL;
  1039.             }
  1040.             else
  1041.                 hr = E_FAIL;            // return cached failure
  1042.         }
  1043.         else
  1044.         {
  1045.             hr = SHILClone(pidlCache, ppidl);   // cache hit
  1046.         }
  1048.         // store back the PIDL if it is non NULL or they specified CREATE
  1049.         // and we failed to create it (cache the not existant state). this is needed
  1050.         // so we don't cache a NULL if the first callers don't ask for create and
  1051.         // subsequent callers do
  1052.         if (pidlCache || (uFlags & CSIDL_FLAG_CREATE))
  1053.             _SetIDListCache(pfi, pidlCache);
  1054.     }
  1056.     return hr;
  1057. }
  1059. void _ClearCacheEntry(const FOLDER_INFO *pfi)
  1060. {
  1061.     if (!(pfi->dwFlags & SDIF_CONST_IDLIST))
  1062.         _SetIDListCache(pfi, (LPCITEMIDLIST)-1);
  1063.     _SetPathCache(pfi, (LPCTSTR)-1);
  1064. }
  1066. void _ClearAllCacheEntrys()
  1067. {
  1068.     const FOLDER_INFO *pfi;
  1069.     for (pfi = c_rgFolderInfo; pfi->id != -1; pfi++)
  1070.     {
  1071.         _ClearCacheEntry(pfi);
  1072.     }
  1073. }
  1076. // Per instance count of mods to Special Folder cache.
  1077. HANDLE g_hCounter = NULL;   // Global count of mods to Special Folder cache.
  1078. int g_lPerProcessCount = 0;
  1081. //----------------------------------------------------------------------------
  1082. // Make sure the special folder cache is up to date.
  1083. void _UpdateShellFolderCache(void)
  1084. {
  1085.     long lGlobalCount;
  1086.     HANDLE hCounter = SHGetCachedGlobalCounter(&g_hCounter, &GUID_SystemPidlChange);
  1088.     // Is the cache up to date?
  1089.     lGlobalCount = SHGlobalCounterGetValue(hCounter);
  1090.     if (lGlobalCount != g_lPerProcessCount)
  1091.     {
  1092.         _ClearAllCacheEntrys();
  1093.         g_lPerProcessCount = lGlobalCount;
  1094.     }
  1095. }
  1097. STDAPI_(void) SHFlushSFCache(void)
  1098. {
  1099.     // Increment the shared variable;  the per-process versions will no
  1100.     // longer match, causing this and/or other processes to refresh their
  1101.     // pidl caches when they next need to access a folder.
  1102.     if (g_hCounter)
  1103.         SHGlobalCounterIncrement(g_hCounter);
  1104. }
  1106. // use SHGetFolderLocation() instead using CSIDL_FLAG_CREATE
  1108. STDAPI_(LPITEMIDLIST) SHCloneSpecialIDList(HWND hwnd, int csidl, BOOL fCreate)
  1109. {
  1110.     LPITEMIDLIST pidlReturn;
  1112.     if (fCreate)
  1113.         csidl |= CSIDL_FLAG_CREATE;
  1115.     SHGetSpecialFolderLocation(hwnd, csidl, &pidlReturn);
  1116.     return pidlReturn;
  1117. }
  1120. STDAPI SHGetSpecialFolderLocation(HWND hwnd, int csidl, LPITEMIDLIST *ppidl)
  1121. {
  1122.     HRESULT hr = SHGetFolderLocation(hwnd, csidl, NULL, 0, ppidl);
  1123.     if (hr == S_FALSE)
  1124.         hr = E_FAIL;        // mail empty case into failure for compat with this API
  1125.     return hr;
  1126. }
  1128. // return IDLIST for special folder
  1129. //      fCreate encoded in csidl with CSIDL_FLAG_CREATE (new for NT5)
  1130. //
  1131. //  in:
  1132. //      hwnd    should be NULL
  1133. //      csidl   CSIDL_ value with CSIDL_FLAG_ values ORed in as well
  1134. //      dwType  must be SHGFP_TYPE_CURRENT
  1135. //
  1136. //  out:
  1137. //      *ppild  NULL on failure or empty, PIDL to be freed by caller on success
  1138. //
  1139. //  returns:
  1140. //      S_OK        *ppidl is non NULL
  1141. //      S_FALISE    *ppidl is NULL, but valid csidl was passed (folder does not exist)
  1142. //      FAILED(hr)
  1144. STDAPI SHGetFolderLocation(HWND hwnd, int csidl, HANDLE hToken, DWORD dwType, LPITEMIDLIST *ppidl)
  1145. {
  1146.     const FOLDER_INFO *pfi;
  1147.     HRESULT hr;
  1149.     *ppidl = NULL;  // in case of error or empty
  1151.     // -1 is an invalid csidl
  1152.     if ((dwType != SHGFP_TYPE_CURRENT) || (-1 == csidl))
  1153.         return E_INVALIDARG;    // no flags used yet, validate this param
  1155.     pfi = _GetFolderInfo(csidl & ~CSIDL_FLAG_MASK);
  1156.     if (pfi)
  1157.     {
  1158.         HANDLE hTokenToFree = NULL;
  1160. #ifdef WINNT
  1161.         if (hToken == NULL && (pfi->hKey == HKEY_CURRENT_USER))
  1162.         {
  1163.             if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_IMPERSONATE, TRUE, &hToken))
  1164.                 hTokenToFree = hToken;
  1165.         }
  1166. #endif
  1167.         if (hToken && (pfi->hKey == HKEY_CURRENT_USER))
  1168.         {
  1169.             // we don't cache PIDLs for other users, do all of the work
  1170.             hr = _CreateFolderIDList(hwnd, pfi, hToken, csidl & CSIDL_FLAG_MASK, (LPITEMIDLIST *)ppidl);
  1171.         }
  1172.         else
  1173.         {
  1174.             hr = _GetFolderIDListCached(hwnd, pfi, csidl & CSIDL_FLAG_MASK, ppidl);
  1175.         }
  1177.         if (hTokenToFree)
  1178.             CloseHandle(hTokenToFree);
  1179.     }
  1180.     else
  1181.         hr = E_INVALIDARG;    // bad CSIDL (apps can check to veryify our support)
  1182.     return hr;
  1183. }
  1185. STDAPI_(BOOL) SHGetSpecialFolderPath(HWND hwnd, LPTSTR pszPath, int csidl, BOOL fCreate)
  1186. {
  1187.     if (fCreate)
  1188.         csidl |= CSIDL_FLAG_CREATE;
  1189.     return SHGetFolderPath(hwnd, csidl, NULL, 0, pszPath) == S_OK;
  1190. }
  1192. //  in:
  1193. //      hwnd    should be NULL
  1194. //      csidl   CSIDL_ value with CSIDL_FLAG_ values ORed in as well
  1195. //      dwType  must be SHGFP_TYPE_CURRENT
  1196. //
  1197. //  out:
  1198. //      *pszPath    MAX_PATH buffer to get path name, zeroed on failure or empty case
  1199. //
  1200. //  returns:
  1201. //      S_OK        filled in pszPath with path value
  1202. //      S_FALSE     pszPath is NULL, valid CSIDL value, but this folder does not exist
  1203. //      E_FAIL
  1205. STDAPI SHGetFolderPath(HWND hwnd, int csidl, HANDLE hToken, DWORD dwType, LPTSTR pszPath)
  1206. {
  1207.     HRESULT hr = E_INVALIDARG;
  1208.     const FOLDER_INFO *pfi;
  1210.     ASSERT(IS_VALID_WRITE_BUFFER(pszPath, TCHAR, MAX_PATH));
  1211.     *pszPath = 0;
  1213.     pfi = _GetFolderInfo(csidl & ~CSIDL_FLAG_MASK);
  1214.     if (pfi && !(pfi->dwFlags & SDIF_NOT_FILESYS))
  1215.     {
  1216.         switch (dwType)
  1217.         {
  1218.         case SHGFP_TYPE_DEFAULT:
  1219.             ASSERT((csidl & CSIDL_FLAG_MASK) == 0); // meaningless for default
  1220.             hr = _GetFolderDefaultPath(pfi, hToken, pszPath);
  1221.             break;
  1222.     
  1223.         case SHGFP_TYPE_CURRENT:
  1224.             {
  1225.                 HANDLE hTokenToFree = NULL;
  1226. #ifdef WINNT
  1227.                 if (hToken == NULL && (pfi->hKey == HKEY_CURRENT_USER))
  1228.                 {
  1229.                     if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_IMPERSONATE, TRUE, &hToken))
  1230.                         hTokenToFree = hToken;
  1231.                 }
  1232. #endif
  1233.                 hr = _GetFolderPathCached(hwnd, pfi, hToken, csidl & CSIDL_FLAG_MASK, pszPath);
  1235.                 if (hTokenToFree)
  1236.                     CloseHandle(hTokenToFree);
  1237.             }
  1238.             break;
  1239.         }
  1240.     }
  1241.     return hr;
  1242. }
  1244. #ifdef UNICODE
  1246. STDAPI SHGetFolderPathA(HWND hwnd, int csidl, HANDLE hToken, DWORD dwType, LPSTR pszPath)
  1247. {
  1248.     WCHAR wsz[MAX_PATH];
  1249.     HRESULT hr = SHGetFolderPath(hwnd, csidl, hToken, dwType, wsz);
  1251.     ASSERT(IS_VALID_WRITE_BUFFER(pszPath, CHAR, MAX_PATH));
  1253.     SHUnicodeToAnsi(wsz, pszPath, MAX_PATH);
  1254.     return hr;
  1255. }
  1257. STDAPI_(BOOL) SHGetSpecialFolderPathA(HWND hwnd, LPSTR pszPath, int csidl, BOOL fCreate)
  1258. {
  1259.     if (fCreate)
  1260.         csidl |= CSIDL_FLAG_CREATE;
  1261.     return SHGetFolderPathA(hwnd, csidl, NULL, 0, pszPath) == S_OK;
  1262. }
  1264. #else
  1266. STDAPI SHGetFolderPathW(HWND hwnd, int csidl, HANDLE hToken, DWORD dwType, LPWSTR pszPath)
  1267. {
  1268.     CHAR sz[MAX_PATH];
  1269.     HRESULT hr = SHGetFolderPath(hwnd, csidl, hToken, dwType, sz);
  1271.     ASSERT(IS_VALID_WRITE_BUFFER(pszPath, WCHAR, MAX_PATH));
  1273.     SHAnsiToUnicode(sz, pszPath, MAX_PATH);
  1274.     return hr;
  1275. }
  1277. STDAPI_(BOOL) SHGetSpecialFolderPathW(HWND hwnd, LPWSTR pszPath, int csidl, BOOL fCreate)
  1278. {
  1279.     if (fCreate)
  1280.         csidl |= CSIDL_FLAG_CREATE;
  1281.     return SHGetFolderPathW(hwnd, csidl, NULL, 0, pszPath) == S_OK;
  1282. }
  1284. #endif
  1286. //  HRESULT SHSetFolderPath (int csidl, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath)
  1287. //
  1288. //  in:
  1289. //      csidl       CSIDL_ value with CSIDL_FLAG_ values ORed in as well
  1290. //      dwFlags     reserved: should be 0x00000000
  1291. //      pszPath     path to change shell folder to (will optionally be unexpanded)
  1292. //
  1293. //  returns:
  1294. //      S_OK        function succeeded and flushed cache
  1296. STDAPI  SHSetFolderPath (int csidl, HANDLE hToken, DWORD dwFlags, LPCTSTR pszPath)
  1298. {
  1299.     HRESULT             hr;
  1300.     const FOLDER_INFO   *pfi;
  1302.     hr = E_INVALIDARG;
  1304.     // Validate csidl and dwFlags. Add extra valid flags as needed.
  1306.     RIPMSG(((csidl & CSIDL_FLAG_MASK) & ~(CSIDL_FLAG_DONT_UNEXPAND | 0x00000000)) == 0, "SHSetFolderPath: CSIDL flag(s) invalid");
  1307.     RIPMSG(dwFlags == 0, "SHSetFolderPath: dwFlags parameter must be 0x00000000");
  1309.     // Exit with E_INVALIDARG if bad parameters.
  1311.     if ((((csidl & CSIDL_FLAG_MASK) & ~(CSIDL_FLAG_DONT_UNEXPAND | 0x00000000)) != 0) ||
  1312.         (dwFlags != 0) ||
  1313.         (pszPath == NULL) ||
  1314.         (pszPath[0] == TEXT('')))
  1315.     {
  1316.         return(hr);
  1317.     }
  1319.     pfi = _GetFolderInfo(csidl & ~CSIDL_FLAG_MASK);
  1321.     // Only allow setting for SDIF_NOT_FILESYS is clear
  1322.     //                        SDIF_NOT_TRACKED is clear
  1323.     //                        SDIF_CANT_MOVE_RENAME is clear
  1324.     // and for non-NULL value
  1326.     // If HKLM is used then rely on security or registry restrictions
  1327.     // to enforce whether the change can be made.
  1329.     if ((pfi != NULL) &&
  1330.         ((pfi->dwFlags & (SDIF_NOT_FILESYS | SDIF_NOT_TRACKED | SDIF_CANT_MOVE_RENAME)) == 0))
  1331.     {
  1332.         BOOL    fSuccessfulUnexpand, fSuccessfulExpand, fEmptyOrNullPath;
  1333.         LONG    lError;
  1334.         HANDLE  hTokenToFree;
  1335.         TCHAR   szPath[MAX_PATH];
  1336.         TCHAR   szExpandedPath[MAX_PATH];   // holds expanded path for "Shell Folder" compat key
  1337.         LPCTSTR pszWritePath;
  1339.         hTokenToFree = NULL;
  1340. #ifdef WINNT
  1341.         if ((hToken == NULL) && (pfi->hKey == HKEY_CURRENT_USER))
  1342.         {
  1343.             if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_IMPERSONATE, TRUE, &hToken))
  1344.             {
  1345.                 hTokenToFree = hToken;
  1346.             }
  1347.         }
  1348. #endif
  1350.         fEmptyOrNullPath = ((pszPath == NULL) || (pszPath[0] == TEXT('')));
  1351.         if (fEmptyOrNullPath)
  1352.         {
  1353. #ifdef  WINNT
  1354.             HKEY    hKeyDefaultUser;
  1356.             pszWritePath = NULL;
  1357.             if (SUCCEEDED(_OpenKeyForFolder(pfi, (HANDLE)-1, TEXT("User Shell Folders"), &hKeyDefaultUser)))
  1358.             {
  1359.                 DWORD   dwPathSize;
  1361.                 dwPathSize = sizeof(szPath);
  1362.                 if (ERROR_SUCCESS == RegQueryValueEx(hKeyDefaultUser,
  1363.                                                      pfi->pszValueName,
  1364.                                                      NULL,
  1365.                                                      NULL,
  1366.                                                      (LPBYTE)szPath,
  1367.                                                      &dwPathSize))
  1368.                 {
  1369.                     pszWritePath = szPath;
  1370.                 }
  1371.                 RegCloseKey(hKeyDefaultUser);
  1372.             }
  1373. #else
  1374.             pszWritePath = NULL;
  1375. #endif
  1376.             fSuccessfulUnexpand = TRUE;
  1377.         }
  1378.         else if ((csidl & CSIDL_FLAG_DONT_UNEXPAND) != 0)
  1379.         {
  1381.             // Does the caller want to write the string as is? Leave
  1382.             // it alone if so.
  1384.             pszWritePath = pszPath;
  1385.             fSuccessfulUnexpand = TRUE;
  1386.         }
  1387.         else
  1388.         {
  1389.             if (pfi->hKey == HKEY_CURRENT_USER)
  1390.             {
  1391.                 fSuccessfulUnexpand = (PathUnExpandEnvStringsForUser(hToken, pszPath, szPath, ARRAYSIZE(szPath)) != FALSE);
  1392.             }
  1393.             pszWritePath = szPath;
  1394.         }
  1396.         if (fSuccessfulUnexpand)
  1397.         {
  1398.             HKEY    hKeyUser, hKeyUSF, hKeyToFree;
  1400.             // we also get the fully expanded path so that we can write it out to the "Shell Folders" key for lame apps that depend on
  1401.             // the old registry values
  1402.             fSuccessfulExpand = (SHExpandEnvironmentStringsForUser(hToken, pszPath, szExpandedPath, ARRAYSIZE(szExpandedPath)) != 0);
  1404.             // Get either the current users HKCU or HKUSID if a token
  1405.             // was specified and running in NT.
  1407.             if ((hToken != NULL) && (GetUserProfileKey(hToken, &hKeyUser) != FALSE))
  1408.             {
  1409.                 hKeyToFree = hKeyUser;
  1410.             }
  1411.             else
  1412.             {
  1413.                 hKeyUser = pfi->hKey;
  1414.                 hKeyToFree = NULL;
  1415.             }
  1417.             // Open the key to the User Shell Folders and write the string
  1418.             // there. Clear the shell folder cache.
  1420.             // NOTE: This functionality is duplicated in SetFolderPath but
  1421.             // that function deals with the USF key only. This function
  1422.             // requires HKUSID so while there is identical functionality
  1423.             // from the point of view of settings the USF value that is
  1424.             // where it ends. To make this function simple it just writes
  1425.             // the value to registry itself.
  1427.             // Additional note: there is a threading issue here with
  1428.             // clearing the cache entry incrementing the counter. This
  1429.             // should be locked access.
  1431.             lError = RegOpenKeyEx(hKeyUser,
  1432.                                   TEXT("Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders"),
  1433.                                   0,
  1434.                                   KEY_READ | KEY_WRITE,
  1435.                                   &hKeyUSF);
  1436.             if (lError == ERROR_SUCCESS)
  1437.             {
  1438.                 if (pszWritePath != NULL)
  1439.                 {
  1441.                     // vtan: Win98 SE supports writing whatever type of data
  1442.                     // you give it. It blindly gives back the same type. If
  1443.                     // this function writes REG_EXPAND_SZ any corresponding
  1444.                     // reading function (SHGetFolderPath) will automatically
  1445.                     // expand the variables so this doesn't appear to present
  1446.                     // a compatibility issue. If it does (I have foreseen
  1447.                     // incorrectly) it can be solved using an "#ifdef WINNT".
  1449.                     lError = RegSetValueEx(hKeyUSF,
  1450.                                            pfi->pszValueName,
  1451.                                            0,
  1452.                                            REG_EXPAND_SZ,
  1453.                                            (LPBYTE)pszWritePath,
  1454.                                            (lstrlen(pszWritePath) + sizeof('')) * sizeof(TCHAR));
  1455.                 }
  1456.                 else
  1457.                 {
  1458.                     lError = RegDeleteValue(hKeyUSF, pfi->pszValueName);
  1459.                 }
  1460.                 RegCloseKey(hKeyUSF);
  1461.                 _ClearCacheEntry(pfi);
  1462.                 g_lPerProcessCount = SHGlobalCounterIncrement(g_hCounter);
  1463.             }
  1465.             // update the old "Shell Folders" value for compat
  1466.             if ((lError == ERROR_SUCCESS) && fSuccessfulExpand)
  1467.             {
  1468.                 HKEY hkeySF;
  1470.                 if (RegOpenKeyEx(hKeyUser,
  1471.                                  TEXT("Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"),
  1472.                                  0,
  1473.                                  KEY_READ | KEY_WRITE,
  1474.                                  &hkeySF) == ERROR_SUCCESS)
  1475.                 {
  1476.                     if (pszWritePath != NULL)
  1477.                     {
  1478.                         RegSetValueEx(hkeySF,
  1479.                                       pfi->pszValueName,
  1480.                                       0,
  1481.                                       REG_SZ,
  1482.                                       (LPBYTE)szExpandedPath,
  1483.                                       (lstrlen(szExpandedPath) + sizeof('')) * sizeof(TCHAR));
  1484.                     }
  1485.                     else
  1486.                     {
  1487.                         RegDeleteValue(hkeySF, pfi->pszValueName);
  1488.                     }
  1490.                     RegCloseKey(hkeySF);
  1491.                 }
  1492.             }
  1494.             if ((lError == ERROR_SUCCESS) && (pfi->hKey == HKEY_CURRENT_USER))
  1495.             {
  1496.                 switch (csidl & ~CSIDL_FLAG_MASK)
  1497.                 {
  1498.                     case CSIDL_APPDATA:
  1499.                     {
  1500.                         HKEY    hKeyVolatileEnvironment;
  1502.                         // In the case of AppData there is a matching environment variable
  1503.                         // for this shell folder. Make sure the place in the registry where
  1504.                         // userenv.dll places this value is updated and correct so that when
  1505.                         // the user context is created by winlogon it will have the updated
  1506.                         // value.
  1508.                         // It's probably also a good thing to check for a %APPDATA% variable
  1509.                         // in the calling process' context but this would only be good for
  1510.                         // the life of the process. What is really required is a mechanism
  1511.                         // to change the environment variable for the entire logon session.
  1513.                         lError = RegOpenKeyEx(hKeyUser,
  1514.                                               TEXT("Volatile Environment"),
  1515.                                               0,
  1516.                                               KEY_READ | KEY_WRITE,
  1517.                                               &hKeyVolatileEnvironment);
  1518.                         if (lError == ERROR_SUCCESS)
  1519.                         {
  1520.                             if (SUCCEEDED(SHGetFolderPath(NULL,
  1521.                                                           csidl | CSIDL_FLAG_DONT_VERIFY,
  1522.                                                           hToken,
  1523.                                                           SHGFP_TYPE_CURRENT,
  1524.                                                           szPath)))
  1525.                             {
  1526.                                 lError = RegSetValueEx(hKeyVolatileEnvironment,
  1527.                                                        TEXT("APPDATA"),
  1528.                                                        0,
  1529.                                                        REG_SZ,
  1530.                                                        (LPBYTE)szPath,
  1531.                                                        (lstrlen(szPath) + sizeof('')) * sizeof(TCHAR));
  1532.                             }
  1533.                             RegCloseKey(hKeyVolatileEnvironment);
  1534.                         }
  1535.                         break;
  1536.                     }
  1538.                     default:
  1539.                     {
  1540.                         break;
  1541.                     }
  1542.                 }
  1543.             }
  1545.             if (hKeyToFree != NULL)
  1546.             {
  1547.                 RegCloseKey(hKeyToFree);
  1548.             }
  1550.             if (lError == ERROR_SUCCESS)
  1551.             {
  1552.                 hr = S_OK;
  1553.             }
  1554.             else
  1555.             {
  1556.                 hr = HRESULT_FROM_WIN32(lError);
  1557.             }
  1558.         }
  1559.         if (hTokenToFree != NULL)
  1560.         {
  1561.             CloseHandle(hTokenToFree);
  1562.         }
  1563.     }
  1565.     return(hr);
  1566. }
  1568. #ifdef UNICODE
  1570. STDAPI SHSetFolderPathA(int csidl, HANDLE hToken, DWORD dwType, LPCSTR pszPath)
  1571. {
  1572.     WCHAR       wsz[MAX_PATH];
  1574.     SHAnsiToUnicode(pszPath, wsz, MAX_PATH);
  1575.     return(SHSetFolderPath(csidl, hToken, dwType, wsz));
  1576. }
  1578. #else
  1580. STDAPI SHSetFolderPathW(int csidl, HANDLE hToken, DWORD dwType, LPCWSTR pszPath)
  1581. {
  1582.     CHAR        sz[MAX_PATH];
  1584.     SHUnicodeToAnsi(pszPath, sz, MAX_PATH);
  1585.     return(SHSetFolderPath(csidl, hToken, dwType, sz));
  1586. }
  1588. #endif
  1590. // NOTE: called from DllEntry
  1592. void SpecialFolderIDTerminate()
  1593. {
  1594.     ASSERTDLLENTRY      // does not require a critical section
  1596.     _ClearAllCacheEntrys();
  1598.     if (g_hCounter)
  1599.     {
  1600.         CloseHandle(g_hCounter);
  1601.         g_hCounter = NULL;
  1602.     }
  1603. }
  1605. // update our cache and the registry for pfi with pszPath. this also invalidates the
  1606. // cache in other processes so they stay in sync
  1608. void SetFolderPath(const FOLDER_INFO *pfi, LPCTSTR pszPath)
  1609. {
  1610.     _ClearCacheEntry(pfi);
  1611.     
  1612.     if (pszPath)
  1613.     {
  1614.         HKEY hk;
  1615.         if (SUCCEEDED(_OpenKeyForFolder(pfi, NULL, TEXT("User Shell Folders"), &hk)))
  1616.         {
  1617.             LONG err;
  1618.             TCHAR szDefaultPath[MAX_PATH];
  1619.             
  1620. #ifndef WINNT
  1621.             // If the path being set is the default, delete the custom
  1622.             // setting.  Otherwise, set the new path as the custom setting.
  1623.             
  1624.             _GetFolderDefaultPath(pfi, NULL, szDefaultPath);
  1625.             
  1626.             // There is no reason to delete the value on NT, since we are
  1627.             // able to write REG_EXPAND_SZ strings to the registry, which
  1628.             // handles the roaming case that this RegDeleteValue() attempts
  1629.             // to solve for Win9x
  1630.             
  1631.             // don't delete SDIF_EMPTY_IF_NOT_IN_REG entries, as that will make our
  1632.             // code think they are not to be used
  1633.             if (!(pfi->dwFlags & SDIF_EMPTY_IF_NOT_IN_REG) &&
  1634.                 lstrcmpi(szDefaultPath, pszPath) == 0)
  1635.             {
  1636.                 TraceMsg(TF_PATH, "deleting 'User Shell Folders' %s", pfi->pszValueName);
  1637.                 err = RegDeleteValue(hk, pfi->pszValueName);
  1638.             }
  1639.             else
  1640. #endif // ! WINNT
  1641.             {
  1642.                 // Check for an existing path, and if the unexpanded version
  1643.                 // of the existing path does not match the new path, then
  1644.                 // write the new path to the registry.
  1645.                 //
  1646.                 // RegQueryPath expands the environment variables for us
  1647.                 // so we can't just blindly set the new value to the registry.
  1648.                 //
  1649.                 
  1650.                 RegQueryPath(hk, pfi->pszValueName, szDefaultPath);
  1651.                 
  1652.                 if (lstrcmpi(szDefaultPath, pszPath) != 0)
  1653.                 {
  1654.                     // The paths are different. Write to the registry as file
  1655.                     // system path.
  1657.                     err = SHRegSetPath(hk, NULL, pfi->pszValueName, pszPath, 0);
  1658.                 } 
  1659.                 else
  1660.                     err = ERROR_SUCCESS;
  1661.             }
  1662.             
  1663.             // clear out any temp paths
  1664.             RegSetFolderPath(pfi, TEXT("User Shell Folders\New"), NULL);
  1665.             
  1666.             if (err == ERROR_SUCCESS)
  1667.             {
  1668.                 // this will force a new creation (see TRUE as fCreate).
  1669.                 // This will also copy the path from "User Shell Folders"
  1670.                 // to "Shell Folders".
  1671.                 LPITEMIDLIST pidl;
  1672.                 if (S_OK == _GetFolderIDListCached(NULL, pfi, CSIDL_FLAG_CREATE, &pidl))
  1673.                 {
  1674.                     ILFree(pidl);
  1675.                 }
  1676.                 else
  1677.                 {
  1678.                     // failed!  null out the entry.  this will go back to our default
  1679.                     RegDeleteValue(hk, pfi->pszValueName);
  1680.                     _ClearCacheEntry(pfi);
  1681.                 }
  1682.             }
  1683.             RegCloseKey(hk);
  1684.         }
  1685.     }
  1686.     else
  1687.     {
  1688.         RegSetFolderPath(pfi, TEXT("User Shell Folders"), NULL);
  1689.         // clear out any temp paths
  1690.         RegSetFolderPath(pfi, TEXT("User Shell Folders\New"), NULL);
  1691.     }
  1692.     
  1693.     // set the global different from the per process variable
  1694.     // to signal an update needs to happen other processes
  1695.     g_lPerProcessCount = SHGlobalCounterIncrement(g_hCounter);
  1696. }
  1699. // file system change notifies come in here AFTER the folders have been moved/deleted
  1700. // we fix up the registry to match what occured in the file system
  1702. void SFP_FSEvent(LONG lEvent, LPITEMIDLIST pidl, LPITEMIDLIST pidlExtra)
  1703. {
  1704.     const FOLDER_INFO *pfi;
  1705.     TCHAR szSrc[MAX_PATH];
  1707.     if (!(lEvent & (SHCNE_RENAMEFOLDER | SHCNE_RMDIR | SHCNE_MKDIR)) ||
  1708.         !SHGetPathFromIDList(pidl, szSrc)                            ||
  1709.         (pidlExtra && ILIsEqual(pidl, pidlExtra)))  // when volume label changes, pidl==pidlExtra so we detect this case and skip it for perf
  1710.     {
  1711.         return;
  1712.     }
  1714.     for (pfi = c_rgFolderInfo; pfi->id != -1; pfi++)
  1715.     {
  1716.         if (0 == (pfi->dwFlags & (SDIF_NOT_TRACKED | SDIF_NOT_FILESYS)))
  1717.         {
  1718.             TCHAR szCurrent[MAX_PATH];
  1719.             if (S_OK == _GetFolderPathCached(NULL, pfi, NULL, CSIDL_FLAG_DONT_VERIFY, szCurrent) &&
  1720.                 PathIsEqualOrSubFolder(szSrc, szCurrent))
  1721.             {
  1722.                 TCHAR szDest[MAX_PATH];
  1724.                 szDest[0] = 0;
  1726.                 if (lEvent & SHCNE_RMDIR)
  1727.                 {
  1728.                     // complete the "move accross volume" case
  1729.                     HKEY hk;
  1730.                     if (SUCCEEDED(_OpenKeyForFolder(pfi, NULL, TEXT("User Shell Folders\New"), &hk)))
  1731.                     {
  1732.                         RegQueryPath(hk, pfi->pszValueName, szDest);
  1733.                         RegCloseKey(hk);
  1734.                     }
  1735.                 }
  1736.                 else if (pidlExtra)
  1737.                 {
  1738.                     SHGetPathFromIDList(pidlExtra, szDest);
  1739.                 }
  1741.                 if (szDest[0])
  1742.                 {
  1743.                     // rename the specal folder
  1744.                     UINT cch = PathCommonPrefix(szCurrent, szSrc, NULL);
  1745.                     ASSERT(cch != 0);
  1746.                     
  1747.                     if (szCurrent[cch])
  1748.                     {
  1749.                         PathAppend(szDest, szCurrent + cch);
  1750.                     }
  1752.                     SetFolderPath(pfi, szDest);
  1753.                 }
  1754.             }
  1755.         }
  1756.     }
  1757. }
  1759. // returns the first special folder CSIDL_ id that is a parent
  1760. // of the passed in pidl or 0 if not found. only CSIDL_ entries marked as
  1761. // SDIF_SHORTCUT_RELATIVE are considered for this.
  1762. //
  1763. // returns:
  1764. //      CSIDL_ values
  1765. //      *pcbOffset  offset into pidl
  1767. int GetSpecialFolderParentIDAndOffset(LPCITEMIDLIST pidl, ULONG *pcbOffset)
  1768. {
  1769.     BOOL bFound = FALSE;
  1770.     const FOLDER_INFO *pfi;
  1772.     for (pfi = c_rgFolderInfo; pfi->id != -1; pfi++)
  1773.     {
  1774.         if (pfi->dwFlags & SDIF_SHORTCUT_RELATIVE)
  1775.         {
  1776.             LPITEMIDLIST pidlFolder;
  1777.             if (S_OK == _GetFolderIDListCached(NULL, pfi, 0, &pidlFolder))
  1778.             {
  1779.                 BOOL bParent = ILIsParent(pidlFolder, pidl, FALSE);
  1780.                 if (bParent)
  1781.                 {
  1782.                     LPCITEMIDLIST pidlT = pidl, pidlFolderT = pidlFolder;
  1784.                     while (!ILIsEmpty(pidlFolderT))
  1785.                     {
  1786.                         pidlFolderT = _ILNext(pidlFolderT);
  1787.                         pidlT = _ILNext(pidlT);
  1788.                     }
  1790.                     *pcbOffset = (ULONG)((LPBYTE)pidlT - (LPBYTE)pidl);
  1791.                     bFound = TRUE;
  1792.                 }
  1793.                 ILFree(pidlFolder);
  1794.             }
  1795.             if (bFound)
  1796.                 return pfi->id;
  1797.         }
  1798.     }
  1799.     return 0;
  1800. }
  1802. // this is copied from mydocs.dll so that we can completely enforce its DisablePersonalDirChange
  1803. // policy by blocking rename/move even when mydocs.dll isn't loaded
  1805. BOOL CanChangePersonalPath( void )
  1806. {
  1807.     return (ERROR_SUCCESS != SHGetValue(HKEY_CURRENT_USER,
  1808.                                         TEXT("Software\Microsoft\Windows\CurrentVersion\Policies\Explorer"),
  1809.                                         TEXT("DisablePersonalDirChange"),
  1810.                                         NULL,
  1811.                                         NULL,
  1812.                                         NULL));
  1813. }
  1815. // this is called from the copy engine (like all other copy hooks)
  1816. // this is where we put up UI blocking the delete/move of some special folders
  1818. int PathCopyHookCallback(HWND hwnd, UINT wFunc, LPCTSTR pszSrc, LPCTSTR pszDest)
  1819. {
  1820.     int ret = IDYES;
  1822.     if ((wFunc == FO_DELETE) || (wFunc == FO_MOVE) || (wFunc == FO_RENAME))
  1823.     {
  1824.         const FOLDER_INFO *pfi;
  1826.         // is one of our system directories being affected?
  1828.         for (pfi = c_rgFolderInfo; ret == IDYES && pfi->id != -1; pfi++)
  1829.         {
  1830.             // even non tracked folders (windows, system) come through here
  1831.             if (0 == (pfi->dwFlags & SDIF_NOT_FILESYS))
  1832.             {
  1833.                 TCHAR szCurrent[MAX_PATH];
  1834.                 if (S_OK == _GetFolderPathCached(NULL, pfi, NULL, CSIDL_FLAG_DONT_VERIFY, szCurrent) &&
  1835.                     PathIsEqualOrSubFolder(pszSrc, szCurrent))
  1836.                 {
  1837.                     // Yes
  1838.                     if (wFunc == FO_DELETE)
  1839.                     {
  1840.                         if (pfi->dwFlags & SDIF_CAN_DELETE)
  1841.                         {
  1842.                             SetFolderPath(pfi, NULL);  // Let them delete some folders
  1843.                         }
  1844.                         else
  1845.                         {
  1846.                             ShellMessageBox(HINST_THISDLL, hwnd, MAKEINTRESOURCE(IDS_CANTDELETESPECIALDIR),
  1847.                                             MAKEINTRESOURCE(IDS_DELETE), MB_OK | MB_ICONINFORMATION, PathFindFileName(pszSrc));
  1848.                             ret = IDNO;
  1849.                         }
  1850.                     }
  1851.                     else
  1852.                     {
  1853.                         int idSrc = PathGetDriveNumber(pszSrc);
  1854.                         int idDest = PathGetDriveNumber(pszDest);
  1856.                         ASSERT((wFunc == FO_MOVE) || (wFunc == FO_RENAME));
  1858.                         if ((pfi->dwFlags & SDIF_CANT_MOVE_RENAME) || 
  1859.                             (((idSrc != -1) && (idDest == -1) && !(pfi->dwFlags & SDIF_NETWORKABLE)) ||
  1860.                              ((idSrc != idDest) && PathIsRemovable(pszDest) && !(pfi->dwFlags & SDIF_REMOVABLE))) ||
  1861.                               ((CSIDL_PERSONAL == pfi->id) && !CanChangePersonalPath()))
  1862.                         {
  1863.                             ShellMessageBox(HINST_THISDLL, hwnd, MAKEINTRESOURCE(IDS_CANTMOVESPECIALDIRHERE),
  1864.                                 wFunc == FO_MOVE ? MAKEINTRESOURCE(IDS_MOVE) : MAKEINTRESOURCE(IDS_RENAME), 
  1865.                                 MB_ICONERROR, PathFindFileName(pszSrc));
  1866.                             ret = IDNO;
  1867.                         }
  1868.                         else
  1869.                         {
  1870.                             // if this is a logical move that is really conveted into
  1871.                             // a copy we detect that here. 2 cases, cross volume
  1872.                             if ((idSrc != idDest) || PathIsDirectory(pszDest))
  1873.                             {
  1874.                                 // this is going to be a move across volumes
  1875.                                 // which means a delete then a create notifications,
  1876.                                 // store this info here
  1877.                                 RegSetFolderPath(pfi, TEXT("User Shell Folders\New"), pszDest);
  1878.                             }
  1879.                         }
  1880.                     }
  1881.                 }
  1882.             }
  1883.         }
  1884.     }
  1885.     return ret;
  1886. }
  1888. STDAPI_(int) SHGetSpecialFolderID(LPCWSTR pszName)
  1889. {
  1890.     const FOLDER_INFO *pfi;
  1891.     USES_CONVERSION;
  1892.     LPCTSTR szPath = W2CT(pszName);
  1894.     // make sure g_aFolderCache can be indexed by the CSIDL values
  1896.     COMPILETIME_ASSERT((ARRAYSIZE(g_aFolderCache) - 1) == CSIDL_CONNECTIONS);
  1898.     for (pfi = c_rgFolderInfo; pfi->id != -1; pfi++)
  1899.     {
  1900.         if (0 == StrCmpI(szPath, pfi->pszValueName))
  1901.             return pfi->id;
  1902.     }
  1904.     return -1;
  1905. }
  1907. // Return the special folder ID, if this folder is one of them.
  1908. // At this point, we handle PROGRAMS folder only.
  1910. //
  1911. //  GetSpecialFolderID() 
  1912. //  this allows a list of CSIDLs to be passed in.
  1913. //  they will be searched in order for the specified csidl
  1914. //  and the path will be checked against it.
  1915. //  if -1 is specified as the csidl, then all of array entries should
  1916. //  be checked for a match with the folder.
  1917. //
  1918. int GetSpecialFolderID(LPCTSTR pszFolder, const int *rgcsidl, UINT count)
  1919. {
  1920.     UINT i;
  1921.     for (i = 0; i < count; i++)
  1922.     {
  1923.         int csidlSpecial = rgcsidl[i] & ~TEST_SUBFOLDER;
  1924.         TCHAR szPath[MAX_PATH];
  1925.         if (S_OK == SHGetFolderPath(NULL, csidlSpecial | CSIDL_FLAG_DONT_VERIFY, NULL, SHGFP_TYPE_CURRENT, szPath))
  1926.         {
  1927.             if (((rgcsidl[i] & TEST_SUBFOLDER) && PathIsEqualOrSubFolder(szPath, pszFolder)) ||
  1928.                 (lstrcmpi(szPath, pszFolder) == 0))
  1929.             {
  1930.                 return csidlSpecial;
  1931.             }
  1932.         }
  1933.     }
  1935.     return -1;
  1936. }