#include <wine/config.h>
#include <windef.h>
#include <winbase.h>
#include <shlobj.h>
#include <undocshell.h>
#include <shlwapi.h>
#include <sddl.h>
#include <strsafe.h>
#include <wine/debug.h>
#include <wine/unicode.h>
#include <shlwapi_undoc.h>
#include <shellutils.h>
#include <userenv.h>
#include "pidl.h"
#include "shell32_main.h"
#include "shresdef.h"

Include dependency graph for shellpath.c:

Classes
struct	CSIDL_DATA

Macros
#define	WIN32_NO_STATUS

#define	_INC_WINDOWS

#define	COBJMACROS

#define	_WIN32_WINNT _WIN32_WINNT_WS03

#define	CSIDL_CONTACTS 0x0043

#define	CSIDL_DOWNLOADS 0x0047

#define	CSIDL_LINKS 0x004d

#define	CSIDL_APPDATA_LOCALLOW 0x004e

#define	CSIDL_SAVED_GAMES 0x0062

#define	CSIDL_SEARCHES 0x0063

Typedefs
typedef enum _CSIDL_Type	CSIDL_Type

Enumerations
enum	_CSIDL_Type { CSIDL_Type_User, CSIDL_Type_AllUsers, CSIDL_Type_CurrVer, CSIDL_Type_Disallowed, CSIDL_Type_NonExistent, CSIDL_Type_WindowsPath, CSIDL_Type_SystemPath, CSIDL_Type_SystemX86Path }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)

static BOOL WINAPI	PathSearchOnExtensionsW (LPWSTR pszPath, LPCWSTR *ppszDirs, BOOL bDoSearch, DWORD dwWhich)

static BOOL WINAPI	PathIsAbsoluteW (LPCWSTR path)

static BOOL WINAPI	PathMakeAbsoluteW (LPWSTR path)

static DWORD	GetShortPathNameAbsentW (LPCWSTR pszLong, LPWSTR pszShort, DWORD cchShort)

BOOL WINAPI	IsLFNDriveW (LPCWSTR lpszPath)

static VOID WINAPI	PathQualifyExW (LPWSTR pszPath, LPCWSTR pszDir, DWORD dwFlags)

BOOL WINAPI	PathAppendAW (LPVOID lpszPath1, LPCVOID lpszPath2)

static LPSTR	PathGetExtensionA (LPCSTR lpszPath)

static LPWSTR	PathGetExtensionW (LPCWSTR lpszPath)

LPVOID WINAPI	SHPathGetExtensionW (LPCWSTR lpszPath, DWORD void1, DWORD void2)

BOOL WINAPI	PathRemoveFileSpecAW (LPVOID lpszPath)

static void	PathGetShortPathA (LPSTR pszPath)

static void	PathGetShortPathW (LPWSTR pszPath)

VOID WINAPI	PathGetShortPathAW (LPVOID pszPath)

BOOL WINAPI	PathIsRootAW (LPCVOID lpszPath)

static BOOL	PathIsExeA (LPCSTR lpszPath)

BOOL	PathIsExeW (LPCWSTR lpszPath)

BOOL WINAPI	PathIsExeAW (LPCVOID path)

BOOL WINAPI	PathFileExistsAW (LPCVOID lpszPath)

BOOL WINAPI	IsLFNDriveA (LPCSTR lpszPath)

BOOL WINAPI	IsLFNDriveAW (LPCVOID lpszPath)

static BOOL	PathMakeUniqueNameA (LPSTR lpszBuffer, DWORD dwBuffSize, LPCSTR lpszShortName, LPCSTR lpszLongName, LPCSTR lpszPathName)

static BOOL	PathMakeUniqueNameW (LPWSTR lpszBuffer, DWORD dwBuffSize, LPCWSTR lpszShortName, LPCWSTR lpszLongName, LPCWSTR lpszPathName)

BOOL WINAPI	PathMakeUniqueNameAW (LPVOID lpszBuffer, DWORD dwBuffSize, LPCVOID lpszShortName, LPCVOID lpszLongName, LPCVOID lpszPathName)

BOOL WINAPI	PathYetAnotherMakeUniqueName (LPWSTR buffer, LPCWSTR path, LPCWSTR shortname, LPCWSTR longname)

int WINAPI	PathCleanupSpec (LPCWSTR lpszPathW, LPWSTR lpszFileW)

VOID WINAPI	PathQualifyA (LPSTR pszPath)

VOID WINAPI	PathQualifyW (LPWSTR pszPath)

VOID WINAPI	PathQualifyAW (LPVOID pszPath)

BOOL WINAPI	PathResolveA (LPSTR path, LPCSTR *dirs, DWORD flags)

BOOL WINAPI	PathResolveW (LPWSTR path, LPCWSTR *dirs, DWORD flags)

BOOL WINAPI	PathResolveAW (LPVOID path, LPCVOID *paths, DWORD flags)

static LONG	PathProcessCommandA (LPCSTR lpszPath, LPSTR lpszBuff, DWORD dwBuffSize, DWORD dwFlags)

static LONG	PathProcessCommandW (LPCWSTR lpszPath, LPWSTR lpszBuff, DWORD dwBuffSize, DWORD dwFlags)

LONG WINAPI	PathProcessCommandAW (LPCVOID lpszPath, LPVOID lpszBuff, DWORD dwBuffSize, DWORD dwFlags)

static HRESULT	_SHExpandEnvironmentStrings (LPCWSTR szSrc, LPWSTR szDest)

static HRESULT	_SHGetUserShellFolderPath (HKEY rootKey, LPCWSTR userPrefix, LPCWSTR value, LPWSTR path)

BOOL	_SHGetUserProfileDirectoryW (HANDLE hToken, LPWSTR szPath, LPDWORD lpcchPath)

static HRESULT	_SHGetDefaultValue (BYTE folder, LPWSTR pszPath)

static HRESULT	_SHGetCurrentVersionPath (DWORD dwFlags, BYTE folder, LPWSTR pszPath)

static LPWSTR	_GetUserSidStringFromToken (HANDLE Token)

static HRESULT	_SHGetUserProfilePath (HANDLE hToken, DWORD dwFlags, BYTE folder, LPWSTR pszPath)

static HRESULT	_SHGetAllUsersProfilePath (DWORD dwFlags, BYTE folder, LPWSTR pszPath)

static HRESULT	_SHOpenProfilesKey (PHKEY pKey)

static HRESULT	_SHGetProfilesValue (HKEY profilesKey, LPCWSTR szValueName, LPWSTR szValue, LPCWSTR szDefault)

HRESULT WINAPI	SHGetFolderPathW (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath)

HRESULT WINAPI	SHGetFolderPathAndSubDirA (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPCSTR pszSubPath, LPSTR pszPath)

HRESULT WINAPI	SHGetFolderPathAndSubDirW (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPCWSTR pszSubPath, LPWSTR pszPath)

HRESULT WINAPI	SHGetFolderPathA (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPSTR pszPath)

static HRESULT	_SHRegisterFolders (HKEY hRootKey, HANDLE hToken, LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[], UINT foldersLen)

static HRESULT	_SHRegisterUserShellFolders (BOOL bDefault)

static HRESULT	_SHRegisterCommonShellFolders (void)

HRESULT	SHELL_RegisterShellFolders (void)

BOOL WINAPI	SHGetSpecialFolderPathA (HWND hwndOwner, LPSTR szPath, int nFolder, BOOL bCreate)

BOOL WINAPI	SHGetSpecialFolderPathW (HWND hwndOwner, LPWSTR szPath, int nFolder, BOOL bCreate)

HRESULT WINAPI	SHGetFolderLocation (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwReserved, LPITEMIDLIST *ppidl)

HRESULT WINAPI	SHGetSpecialFolderLocation (HWND hwndOwner, INT nFolder, LPITEMIDLIST *ppidl)

Variables
static const BOOL	is_win64 = sizeof(void *) > sizeof(int)

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'}

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'}

static const WCHAR	AppDataW [] = {'A','p','p','D','a','t','a','\0'}

static const WCHAR	AppData_LocalLowW [] = {'A','p','p','D','a','t','a','\\','L','o','c','a','l','L','o','w','\0'}

static const WCHAR	Application_DataW [] = {'A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'}

static const WCHAR	CacheW [] = {'C','a','c','h','e','\0'}

static const WCHAR	CD_BurningW [] = {'C','D',' ','B','u','r','n','i','n','g','\0'}

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'}

static const WCHAR	Common_AppDataW [] = {'C','o','m','m','o','n',' ','A','p','p','D','a','t','a','\0'}

static const WCHAR	Common_DesktopW [] = {'C','o','m','m','o','n',' ','D','e','s','k','t','o','p','\0'}

static const WCHAR	Common_DocumentsW [] = {'C','o','m','m','o','n',' ','D','o','c','u','m','e','n','t','s','\0'}

static const WCHAR	Common_FavoritesW [] = {'C','o','m','m','o','n',' ','F','a','v','o','r','i','t','e','s','\0'}

static const WCHAR	CommonFilesDirW [] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r','\0'}

static const WCHAR	CommonFilesDirX86W [] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',' ','(','x','8','6',')','\0'}

static const WCHAR	CommonMusicW [] = {'C','o','m','m','o','n','M','u','s','i','c','\0'}

static const WCHAR	CommonPicturesW [] = {'C','o','m','m','o','n','P','i','c','t','u','r','e','s','\0'}

static const WCHAR	Common_ProgramsW [] = {'C','o','m','m','o','n',' ','P','r','o','g','r','a','m','s','\0'}

static const WCHAR	Common_StartUpW [] = {'C','o','m','m','o','n',' ','S','t','a','r','t','U','p','\0'}

static const WCHAR	Common_Start_MenuW [] = {'C','o','m','m','o','n',' ','S','t','a','r','t',' ','M','e','n','u','\0'}

static const WCHAR	Common_TemplatesW [] = {'C','o','m','m','o','n',' ','T','e','m','p','l','a','t','e','s','\0'}

static const WCHAR	CommonVideoW [] = {'C','o','m','m','o','n','V','i','d','e','o','\0'}

static const WCHAR	ContactsW [] = {'C','o','n','t','a','c','t','s','\0'}

static const WCHAR	CookiesW [] = {'C','o','o','k','i','e','s','\0'}

static const WCHAR	DesktopW [] = {'D','e','s','k','t','o','p','\0'}

static const WCHAR	DocumentsW [] = {'D','o','c','u','m','e','n','t','s','\0'}

static const WCHAR	DownloadsW [] = {'D','o','w','n','l','o','a','d','s','\0'}

static const WCHAR	FavoritesW [] = {'F','a','v','o','r','i','t','e','s','\0'}

static const WCHAR	FontsW [] = {'F','o','n','t','s','\0'}

static const WCHAR	HistoryW [] = {'H','i','s','t','o','r','y','\0'}

static const WCHAR	LinksW [] = {'L','i','n','k','s','\0'}

static const WCHAR	Local_AppDataW [] = {'L','o','c','a','l',' ','A','p','p','D','a','t','a','\0'}

static const WCHAR	Local_Settings_Application_DataW [] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\','A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\0'}

static const WCHAR	Local_Settings_CD_BurningW [] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\','A','p','p','l','i','c','a','t','i','o','n',' ','D','a','t','a','\\','M','i','c','r','o','s','o','f','t','\\','C','D',' ','B','u','r','n','i','n','g','\0'}

static const WCHAR	Local_Settings_HistoryW [] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\','H','i','s','t','o','r','y','\0'}

static const WCHAR	Local_Settings_Temporary_Internet_FilesW [] = {'L','o','c','a','l',' ','S','e','t','t','i','n','g','s','\\','T','e','m','p','o','r','a','r','y',' ','I','n','t','e','r','n','e','t',' ','F','i','l','e','s','\0'}

static const WCHAR	Microsoft_Windows_GameExplorerW [] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','G','a','m','e','E','x','p','l','o','r','e','r','\0'}

static const WCHAR	Microsoft_Windows_LibrariesW [] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','L','i','b','r','a','r','i','e','s','\0'}

static const WCHAR	Microsoft_Windows_RingtonesW [] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','R','i','n','g','t','o','n','e','s','\0'}

static const WCHAR	MusicW [] = {'M','u','s','i','c','\0'}

static const WCHAR	Music_PlaylistsW [] = {'M','u','s','i','c','\\','P','l','a','y','l','i','s','t','s','\0'}

static const WCHAR	Music_Sample_MusicW [] = {'M','u','s','i','c','\\','S','a','m','p','l','e',' ','M','u','s','i','c','\0'}

static const WCHAR	Music_Sample_PlaylistsW [] = {'M','u','s','i','c','\\','S','a','m','p','l','e',' ','P','l','a','y','l','i','s','t','s','\0'}

static const WCHAR	My_MusicW [] = {'M','y',' ','M','u','s','i','c','\0'}

static const WCHAR	My_PicturesW [] = {'M','y',' ','P','i','c','t','u','r','e','s','\0'}

static const WCHAR	My_VideoW [] = {'M','y',' ','V','i','d','e','o','\0'}

static const WCHAR	NetHoodW [] = {'N','e','t','H','o','o','d','\0'}

static const WCHAR	OEM_LinksW [] = {'O','E','M',' ','L','i','n','k','s','\0'}

static const WCHAR	PersonalW [] = {'P','e','r','s','o','n','a','l','\0'}

static const WCHAR	PicturesW [] = {'P','i','c','t','u','r','e','s','\0'}

static const WCHAR	Pictures_Sample_PicturesW [] = {'P','i','c','t','u','r','e','s','\\','S','a','m','p','l','e',' ','P','i','c','t','u','r','e','s','\0'}

static const WCHAR	Pictures_Slide_ShowsW [] = {'P','i','c','t','u','r','e','s','\\','S','l','i','d','e',' ','S','h','o','w','s','\0'}

static const WCHAR	PrintHoodW [] = {'P','r','i','n','t','H','o','o','d','\0'}

static const WCHAR	Program_FilesW [] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s','\0'}

static const WCHAR	Program_Files_Common_FilesW [] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s','\\','C','o','m','m','o','n',' ','F','i','l','e','s','\0'}

static const WCHAR	Program_Files_x86W [] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s',' ','(','x','8','6',')','\0'}

static const WCHAR	Program_Files_x86_Common_FilesW [] = {'P','r','o','g','r','a','m',' ','F','i','l','e','s',' ','(','x','8','6',')','\\','C','o','m','m','o','n',' ','F','i','l','e','s','\0'}

static const WCHAR	ProgramFilesDirW [] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r','\0'}

static const WCHAR	ProgramFilesDirX86W [] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r',' ','(','x','8','6',')','\0'}

static const WCHAR	ProgramsW [] = {'P','r','o','g','r','a','m','s','\0'}

static const WCHAR	PublicW [] = {'P','u','b','l','i','c',0}

static const WCHAR	RecentW [] = {'R','e','c','e','n','t','\0'}

static const WCHAR	ResourcesW [] = {'R','e','s','o','u','r','c','e','s','\0'}

static const WCHAR	Saved_GamesW [] = {'S','a','v','e','d',' ','G','a','m','e','s','\0'}

static const WCHAR	SearchesW [] = {'S','e','a','r','c','h','e','s','\0'}

static const WCHAR	SendToW [] = {'S','e','n','d','T','o','\0'}

static const WCHAR	StartUpW [] = {'S','t','a','r','t','U','p','\0'}

static const WCHAR	Start_MenuW [] = {'S','t','a','r','t',' ','M','e','n','u','\0'}

static const WCHAR	Start_Menu_ProgramsW [] = {'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\0'}

static const WCHAR	Start_Menu_Admin_ToolsW [] = {'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\\','A','d','m','i','n','i','s','t','r','a','t','i','v','e',' ','T','o','o','l','s','\0'}

static const WCHAR	Start_Menu_StartupW [] = {'S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\\','S','t','a','r','t','U','p','\0'}

static const WCHAR	TemplatesW [] = {'T','e','m','p','l','a','t','e','s','\0'}

static const WCHAR	UsersW [] = {'U','s','e','r','s','\0'}

static const WCHAR	UsersPublicW [] = {'U','s','e','r','s','\\','P','u','b','l','i','c','\0'}

static const WCHAR	VideosW [] = {'V','i','d','e','o','s','\0'}

static const WCHAR	Videos_Sample_VideosW [] = {'V','i','d','e','o','s','\\','S','a','m','p','l','e',' ','V','i','d','e','o','s','\0'}

static const WCHAR	DefaultW [] = {'.','D','e','f','a','u','l','t','\0'}

static const WCHAR	AllUsersProfileW [] = {'%','A','L','L','U','S','E','R','S','P','R','O','F','I','L','E','%','\0'}

static const WCHAR	PublicProfileW [] = {'%','P','U','B','L','I','C','%',0}

static const WCHAR	UserProfileW [] = {'%','U','S','E','R','P','R','O','F','I','L','E','%','\0'}

static const WCHAR	SystemDriveW [] = {'%','S','y','s','t','e','m','D','r','i','v','e','%','\0'}

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}

static const WCHAR	ProfilesDirectoryW [] = {'P','r','o','f','i','l','e','s','D','i','r','e','c','t','o','r','y',0}

static const WCHAR	AllUsersProfileValueW [] = {'A','l','l','U','s','e','r','s','P','r','o','f','i','l','e','\0'}

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'}

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'}

static const WCHAR	szDefaultProfileDirW [] = {'u','s','e','r','s',0}

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'}

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}

static const WCHAR	AllUsersW [] = {'P','u','b','l','i','c',0}

static const CSIDL_DATA	CSIDL_Data []

Macro Definition Documentation

◆ _INC_WINDOWS

#define _INC_WINDOWS

Definition at line 29 of file shellpath.c.

◆ _WIN32_WINNT

#define _WIN32_WINNT _WIN32_WINNT_WS03

Definition at line 54 of file shellpath.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 30 of file shellpath.c.

◆ CSIDL_APPDATA_LOCALLOW

#define CSIDL_APPDATA_LOCALLOW 0x004e

Definition at line 955 of file shellpath.c.

◆ CSIDL_CONTACTS

#define CSIDL_CONTACTS 0x0043

Definition at line 952 of file shellpath.c.

◆ CSIDL_DOWNLOADS

#define CSIDL_DOWNLOADS 0x0047

Definition at line 953 of file shellpath.c.

◆ CSIDL_LINKS

#define CSIDL_LINKS 0x004d

Definition at line 954 of file shellpath.c.

◆ CSIDL_SAVED_GAMES

#define CSIDL_SAVED_GAMES 0x0062

Definition at line 956 of file shellpath.c.

◆ CSIDL_SEARCHES

#define CSIDL_SEARCHES 0x0063

Definition at line 957 of file shellpath.c.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 28 of file shellpath.c.

Typedef Documentation

◆ CSIDL_Type

typedef enum _CSIDL_Type CSIDL_Type

Enumeration Type Documentation

◆ _CSIDL_Type

enum _CSIDL_Type

Enumerator
CSIDL_Type_User
CSIDL_Type_AllUsers
CSIDL_Type_CurrVer
CSIDL_Type_Disallowed
CSIDL_Type_NonExistent
CSIDL_Type_WindowsPath
CSIDL_Type_SystemPath
CSIDL_Type_SystemX86Path

Definition at line 936 of file shellpath.c.

                          {
     CSIDL_Type_User,
 #ifdef __REACTOS__
     CSIDL_Type_InMyDocuments,
 #endif
     CSIDL_Type_AllUsers,
     CSIDL_Type_CurrVer,
     CSIDL_Type_Disallowed,
     CSIDL_Type_NonExistent,
     CSIDL_Type_WindowsPath,
     CSIDL_Type_SystemPath,
     CSIDL_Type_SystemX86Path,
 } CSIDL_Type;

Function Documentation

◆ _GetUserSidStringFromToken()

static LPWSTR _GetUserSidStringFromToken ( HANDLE Token )

static

Definition at line 2060 of file shellpath.c.

 {
     char InfoBuffer[64];
     PTOKEN_USER UserInfo;
     DWORD InfoSize;
     LPWSTR SidStr;
 
     UserInfo = (PTOKEN_USER) InfoBuffer;
     if (! GetTokenInformation(Token, TokenUser, InfoBuffer, sizeof(InfoBuffer),
                               &InfoSize))
     {
         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
             return NULL;
         UserInfo = HeapAlloc(GetProcessHeap(), 0, InfoSize);
         if (UserInfo == NULL)
             return NULL;
         if (! GetTokenInformation(Token, TokenUser, UserInfo, InfoSize,
                                   &InfoSize))
         {
             HeapFree(GetProcessHeap(), 0, UserInfo);
             return NULL;
         }
     }
 
     if (! ConvertSidToStringSidW(UserInfo->User.Sid, &SidStr))
         SidStr = NULL;
 
     if (UserInfo != (PTOKEN_USER) InfoBuffer)
         HeapFree(GetProcessHeap(), 0, UserInfo);
 
     return SidStr;
 }

Referenced by _SHGetUserProfilePath().

◆ _SHExpandEnvironmentStrings()

static HRESULT _SHExpandEnvironmentStrings	(	LPCWSTR	szSrc,
		LPWSTR	szDest
	)

static

Definition at line 2294 of file shellpath.c.

 {
     HRESULT hr;
 #ifndef __REACTOS__
     WCHAR szTemp[MAX_PATH], szProfilesPrefix[MAX_PATH] = { 0 };
     HKEY key = NULL;
 #else
     WCHAR szTemp[MAX_PATH];
 #endif
 
     TRACE("%s, %p\n", debugstr_w(szSrc), szDest);
 
     if (!szSrc || !szDest) return E_INVALIDARG;
 
     /* short-circuit if there's nothing to expand */
     if (szSrc[0] != '%')
     {
         strcpyW(szDest, szSrc);
         hr = S_OK;
         goto end;
     }
 #ifndef __REACTOS__
     /* Get the profile prefix, we'll probably be needing it */
     hr = _SHOpenProfilesKey(&key);
     if (SUCCEEDED(hr))
     {
         WCHAR def_val[MAX_PATH];
 
         /* get the system drive */
         GetSystemDirectoryW(def_val, MAX_PATH);
         strcpyW( def_val + 3, szDefaultProfileDirW );
 
         hr = _SHGetProfilesValue(key, ProfilesDirectoryW, szProfilesPrefix, def_val );
     }
 #else
     hr = S_OK;
 #endif
 
     *szDest = 0;
     strcpyW(szTemp, szSrc);
     while (SUCCEEDED(hr) && szTemp[0] == '%')
     {
         if (!strncmpiW(szTemp, AllUsersProfileW, strlenW(AllUsersProfileW)))
         {
 #ifndef __REACTOS__
             WCHAR szAllUsers[MAX_PATH];
 
             strcpyW(szDest, szProfilesPrefix);
             hr = _SHGetProfilesValue(key, AllUsersProfileValueW,
                                      szAllUsers, AllUsersW);
             PathAppendW(szDest, szAllUsers);
 #else
             DWORD cchSize = cchDest;
             if (!GetAllUsersProfileDirectoryW(szDest, &cchSize))
                 goto fallback_expand;
 #endif
             PathAppendW(szDest, szTemp + strlenW(AllUsersProfileW));
         }
 #ifndef __REACTOS__
         else if (!strncmpiW(szTemp, PublicProfileW, strlenW(PublicProfileW)))
         {
             WCHAR szAllUsers[MAX_PATH], def_val[MAX_PATH];
 
             GetSystemDirectoryW(def_val, MAX_PATH);
             strcpyW( def_val + 3, UsersPublicW );
 
             hr = _SHGetProfilesValue(key, PublicW, szAllUsers, def_val);
             PathAppendW(szDest, szAllUsers);
             PathAppendW(szDest, szTemp + strlenW(PublicProfileW));
         }
 #endif
         else if (!strncmpiW(szTemp, UserProfileW, strlenW(UserProfileW)))
         {
 #ifndef __REACTOS__
             WCHAR userName[MAX_PATH];
             DWORD userLen = MAX_PATH;
 
             strcpyW(szDest, szProfilesPrefix);
             GetUserNameW(userName, &userLen);
             PathAppendW(szDest, userName);
 #else
             DWORD cchSize = cchDest;
             if (!_SHGetUserProfileDirectoryW(hToken, szDest, &cchSize))
                 goto fallback_expand;
 #endif
             PathAppendW(szDest, szTemp + strlenW(UserProfileW));
         }
         else if (!strncmpiW(szTemp, SystemDriveW, strlenW(SystemDriveW)))
         {
 #ifndef __REACTOS__
             GetSystemDirectoryW(szDest, MAX_PATH);
 #else
             if (!GetSystemDirectoryW(szDest, cchDest))
                 goto fallback_expand;
 #endif
             strcpyW(szDest + 3, szTemp + strlenW(SystemDriveW) + 1);
         }
         else
 #ifdef __REACTOS__
 fallback_expand:
 #endif
         {
 #ifndef __REACTOS__
             DWORD ret = ExpandEnvironmentStringsW(szTemp, szDest, MAX_PATH);
 #else
             DWORD ret = SHExpandEnvironmentStringsForUserW(hToken, szTemp, szDest, cchDest);
 #endif
 
 #ifndef __REACTOS__
             if (ret > MAX_PATH)
 #else
             if (ret > cchDest)
 #endif
                 hr = E_NOT_SUFFICIENT_BUFFER;
             else if (ret == 0)
                 hr = HRESULT_FROM_WIN32(GetLastError());
             else if (!strcmpW( szTemp, szDest )) break;  /* nothing expanded */
         }
         if (SUCCEEDED(hr)) strcpyW(szTemp, szDest);
     }
 end:
 #ifndef __REACTOS__
     if (key)
         RegCloseKey(key);
 #endif
     TRACE("returning 0x%08x (input was %s, output is %s)\n", hr,
      debugstr_w(szSrc), debugstr_w(szDest));
     return hr;
 }

Referenced by _SHGetUserShellFolderPath(), and SHGetFolderPathAndSubDirW().

◆ _SHGetAllUsersProfilePath()

static HRESULT _SHGetAllUsersProfilePath	(	DWORD	dwFlags,
		BYTE	folder,
		LPWSTR	pszPath
	)

static

Definition at line 2189 of file shellpath.c.

 {
     HRESULT hr;
 
     TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
 
     if (folder >= ARRAY_SIZE(CSIDL_Data))
         return E_INVALIDARG;
     if (CSIDL_Data[folder].type != CSIDL_Type_AllUsers)
         return E_INVALIDARG;
     if (!pszPath)
         return E_INVALIDARG;
 
     if (dwFlags & SHGFP_TYPE_DEFAULT)
 #ifndef __REACTOS__
         hr = _SHGetDefaultValue(folder, pszPath);
 #else
         hr = _SHGetDefaultValue(NULL, folder, pszPath);
 #endif
     else
     {
 #ifndef __REACTOS__
         hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL,
 #else
         hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL, NULL,
 #endif
          CSIDL_Data[folder].szValueName, pszPath);
         if (FAILED(hr))
 #ifndef __REACTOS__
             hr = _SHGetDefaultValue(folder, pszPath);
 #else
             hr = _SHGetDefaultValue(NULL, folder, pszPath);
 #endif
     }
     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
     return hr;
 }

Referenced by _SHRegisterFolders(), and SHGetFolderPathAndSubDirW().

◆ _SHGetCurrentVersionPath()

static HRESULT _SHGetCurrentVersionPath	(	DWORD	dwFlags,
		BYTE	folder,
		LPWSTR	pszPath
	)

static

Definition at line 1991 of file shellpath.c.

 {
     HRESULT hr;
 
     TRACE("0x%08x,0x%02x,%p\n", dwFlags, folder, pszPath);
 
     if (folder >= ARRAY_SIZE(CSIDL_Data))
         return E_INVALIDARG;
     if (CSIDL_Data[folder].type != CSIDL_Type_CurrVer)
         return E_INVALIDARG;
     if (!pszPath)
         return E_INVALIDARG;
 
     if (dwFlags & SHGFP_TYPE_DEFAULT)
 #ifndef __REACTOS__
         hr = _SHGetDefaultValue(folder, pszPath);
 #else
         hr = _SHGetDefaultValue(NULL, folder, pszPath);
 #endif
     else
     {
         HKEY hKey;
 
         if (RegCreateKeyW(HKEY_LOCAL_MACHINE, szCurrentVersion, &hKey))
             hr = E_FAIL;
         else
         {
             DWORD dwType, dwPathLen = MAX_PATH * sizeof(WCHAR);
 
             if (RegQueryValueExW(hKey, CSIDL_Data[folder].szValueName, NULL,
              &dwType, (LPBYTE)pszPath, &dwPathLen) ||
              (dwType != REG_SZ && dwType != REG_EXPAND_SZ))
             {
 #ifndef __REACTOS__
                 hr = _SHGetDefaultValue(folder, pszPath);
 #else
                 hr = _SHGetDefaultValue(NULL, folder, pszPath);
 #endif
                 dwType = REG_EXPAND_SZ;
                 switch (folder)
                 {
                 case CSIDL_PROGRAM_FILESX86:
                 case CSIDL_PROGRAM_FILES_COMMONX86:
                     /* these two should never be set on 32-bit setups */
                     if (!is_win64)
                     {
                         BOOL is_wow64;
                         IsWow64Process( GetCurrentProcess(), &is_wow64 );
                         if (!is_wow64) break;
                     }
                     /* fall through */
                 default:
                     RegSetValueExW(hKey, CSIDL_Data[folder].szValueName, 0, dwType,
                                    (LPBYTE)pszPath, (strlenW(pszPath)+1)*sizeof(WCHAR));
                 }
             }
             else
             {
                 pszPath[dwPathLen / sizeof(WCHAR)] = '\0';
                 hr = S_OK;
             }
             RegCloseKey(hKey);
         }
     }
     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
     return hr;
 }

Referenced by SHGetFolderPathAndSubDirW().

◆ _SHGetDefaultValue()

static HRESULT _SHGetDefaultValue	(	BYTE	folder,
		LPWSTR	pszPath
	)

static

Definition at line 1875 of file shellpath.c.

 {
     HRESULT hr;
     WCHAR resourcePath[MAX_PATH];
 #ifdef __REACTOS__
     NT_PRODUCT_TYPE ProductType;
 #endif
 
     TRACE("0x%02x,%p\n", folder, pszPath);
 
     if (folder >= ARRAY_SIZE(CSIDL_Data))
         return E_INVALIDARG;
 
     if (!pszPath)
         return E_INVALIDARG;
 
 #ifdef __REACTOS__
     if (hToken != NULL && hToken != (HANDLE)-1)
     {
         FIXME("unsupported for user other than current or default\n");
     }
 #endif
 
     if (!is_win64)
     {
         BOOL is_wow64;
 
         switch (folder)
         {
         case CSIDL_PROGRAM_FILES:
         case CSIDL_PROGRAM_FILESX86:
             IsWow64Process( GetCurrentProcess(), &is_wow64 );
             folder = is_wow64 ? CSIDL_PROGRAM_FILESX86 : CSIDL_PROGRAM_FILES;
             break;
         case CSIDL_PROGRAM_FILES_COMMON:
         case CSIDL_PROGRAM_FILES_COMMONX86:
             IsWow64Process( GetCurrentProcess(), &is_wow64 );
             folder = is_wow64 ? CSIDL_PROGRAM_FILES_COMMONX86 : CSIDL_PROGRAM_FILES_COMMON;
             break;
         }
     }
 
     switch (CSIDL_Data[folder].type)
     {
         case CSIDL_Type_User:
             strcpyW(pszPath, UserProfileW);
             break;
 #ifdef __REACTOS__
         case CSIDL_Type_InMyDocuments:
             strcpyW(pszPath, UserProfileW);
             if (DoGetProductType(&ProductType) && ProductType == NtProductWinNt)
             {
                 if (IS_INTRESOURCE(CSIDL_Data[CSIDL_MYDOCUMENTS].szDefaultPath))
                 {
                     WCHAR szItem[MAX_PATH];
                     LoadStringW(shell32_hInstance,
                                 LOWORD(CSIDL_Data[CSIDL_MYDOCUMENTS].szDefaultPath),
                                 szItem, ARRAY_SIZE(szItem));
                     PathAppendW(pszPath, szItem);
                 }
                 else
                 {
                     PathAppendW(pszPath, CSIDL_Data[CSIDL_MYDOCUMENTS].szDefaultPath);
                 }
             }
             break;
 #endif
         case CSIDL_Type_AllUsers:
 #ifndef __REACTOS__
             strcpyW(pszPath, PublicProfileW);
 #else
             strcpyW(pszPath, AllUsersProfileW);
 #endif
             break;
         case CSIDL_Type_CurrVer:
             strcpyW(pszPath, SystemDriveW);
             break;
         default:
             ; /* no corresponding env. var, do nothing */
     }
 
     hr = S_OK;
     if (CSIDL_Data[folder].szDefaultPath)
     {
         if (IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath))
         {
             if (LoadStringW(shell32_hInstance,
                 LOWORD(CSIDL_Data[folder].szDefaultPath), resourcePath, MAX_PATH))
             {
                 PathAppendW(pszPath, resourcePath);
             }
             else
             {
                 ERR("(%d,%s), LoadString failed, missing translation?\n", folder,
                       debugstr_w(pszPath));
                 hr = E_FAIL;
             }
         }
         else
         {
             PathAppendW(pszPath, CSIDL_Data[folder].szDefaultPath);
         }
     }
     TRACE("returning 0x%08x\n", hr);
     return hr;
 }

Referenced by _SHGetAllUsersProfilePath(), _SHGetCurrentVersionPath(), and _SHGetUserProfilePath().

◆ _SHGetProfilesValue()

static HRESULT _SHGetProfilesValue	(	HKEY	profilesKey,
		LPCWSTR	szValueName,
		LPWSTR	szValue,
		LPCWSTR	szDefault
	)

static

Definition at line 2244 of file shellpath.c.

 {
     HRESULT hr;
     DWORD type, dwPathLen = MAX_PATH * sizeof(WCHAR);
     LONG lRet;
 
     TRACE("%p,%s,%p,%s\n", profilesKey, debugstr_w(szValueName), szValue,
      debugstr_w(szDefault));
     lRet = RegQueryValueExW(profilesKey, szValueName, NULL, &type,
      (LPBYTE)szValue, &dwPathLen);
     if (!lRet && (type == REG_SZ || type == REG_EXPAND_SZ) && dwPathLen
      && *szValue)
     {
         dwPathLen /= sizeof(WCHAR);
         szValue[dwPathLen] = '\0';
         hr = S_OK;
     }
     else
     {
         /* Missing or invalid value, set a default */
         lstrcpynW(szValue, szDefault, MAX_PATH);
         TRACE("Setting missing value %s to %s\n", debugstr_w(szValueName),
                                                   debugstr_w(szValue));
         lRet = RegSetValueExW(profilesKey, szValueName, 0, REG_EXPAND_SZ,
                               (LPBYTE)szValue,
                               (strlenW(szValue) + 1) * sizeof(WCHAR));
         if (lRet)
             hr = HRESULT_FROM_WIN32(lRet);
         else
             hr = S_OK;
     }
     TRACE("returning 0x%08x (output value is %s)\n", hr, debugstr_w(szValue));
     return hr;
 }

Referenced by _SHExpandEnvironmentStrings().

◆ _SHGetUserProfileDirectoryW()

BOOL _SHGetUserProfileDirectoryW	(	HANDLE	hToken,
		LPWSTR	szPath,
		LPDWORD	lpcchPath
	)

Definition at line 1839 of file shellpath.c.

 {
     BOOL result;
     if (!hToken)
     {
         OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken);
         result = GetUserProfileDirectoryW(hToken, szPath, lpcchPath);
         CloseHandle(hToken);
     }
     else if ((INT) hToken == -1)
     {
         result = GetDefaultUserProfileDirectoryW(szPath, lpcchPath);
     }
     else
     {
         result = GetUserProfileDirectoryW(hToken, szPath, lpcchPath);
     }
     TRACE("_SHGetUserProfileDirectoryW returning %S\n", szPath);
     return result;
 }

Referenced by _SHExpandEnvironmentStrings().

◆ _SHGetUserProfilePath()

static HRESULT _SHGetUserProfilePath	(	HANDLE	hToken,
		DWORD	dwFlags,
		BYTE	folder,
		LPWSTR	pszPath
	)

static

Definition at line 2101 of file shellpath.c.

 {
     const WCHAR *szValueName;
     WCHAR buffer[40];
     HRESULT hr;
 
     TRACE("%p,0x%08x,0x%02x,%p\n", hToken, dwFlags, folder, pszPath);
 
     if (folder >= ARRAY_SIZE(CSIDL_Data))
         return E_INVALIDARG;
 #ifdef __REACTOS__
     if (CSIDL_Data[folder].type != CSIDL_Type_User &&
         CSIDL_Data[folder].type != CSIDL_Type_InMyDocuments)
 #else
     if (CSIDL_Data[folder].type != CSIDL_Type_User)
 #endif
     {
         return E_INVALIDARG;
     }
     if (!pszPath)
         return E_INVALIDARG;
 
     if (dwFlags & SHGFP_TYPE_DEFAULT)
     {
 #ifndef __REACTOS__
         hr = _SHGetDefaultValue(folder, pszPath);
 #else
         hr = _SHGetDefaultValue(hToken, folder, pszPath);
 #endif
     }
     else
     {
         LPCWSTR userPrefix = NULL;
         HKEY hRootKey;
 
         if (hToken == (HANDLE)-1)
         {
             hRootKey = HKEY_USERS;
             userPrefix = DefaultW;
         }
         else if (hToken == NULL)
             hRootKey = HKEY_CURRENT_USER;
         else
         {
             hRootKey = HKEY_USERS;
             userPrefix = _GetUserSidStringFromToken(hToken);
             if (userPrefix == NULL)
             {
                 hr = E_FAIL;
                 goto error;
             }
         }
 
         /* For CSIDL_Type_User we also use the GUID if no szValueName is provided */
         szValueName = CSIDL_Data[folder].szValueName;
         if (!szValueName)
         {
             StringFromGUID2( CSIDL_Data[folder].id, buffer, 39 );
             szValueName = &buffer[0];
         }
 
 #ifndef __REACTOS__
         hr = _SHGetUserShellFolderPath(hRootKey, userPrefix, szValueName, pszPath);
         if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
             hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL, szValueName, pszPath);
         if (FAILED(hr))
             hr = _SHGetDefaultValue(folder, pszPath);
 #else
         hr = _SHGetUserShellFolderPath(hRootKey, hToken, userPrefix, szValueName, pszPath);
         if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
             hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, hToken, NULL, szValueName, pszPath);
         if (FAILED(hr))
             hr = _SHGetDefaultValue(hToken, folder, pszPath);
 #endif
         if (userPrefix != NULL && userPrefix != DefaultW)
             LocalFree((HLOCAL) userPrefix);
     }
 error:
     TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
     return hr;
 }

Referenced by _SHRegisterFolders(), and SHGetFolderPathAndSubDirW().

◆ _SHGetUserShellFolderPath()

static HRESULT _SHGetUserShellFolderPath	(	HKEY	rootKey,
		LPCWSTR	userPrefix,
		LPCWSTR	value,
		LPWSTR	path
	)

static

Definition at line 1756 of file shellpath.c.

 {
     HRESULT hr;
     WCHAR shellFolderPath[MAX_PATH], userShellFolderPath[MAX_PATH];
     LPCWSTR pShellFolderPath, pUserShellFolderPath;
     HKEY userShellFolderKey, shellFolderKey;
     DWORD dwType, dwPathLen;
 
     TRACE("%p,%s,%s,%p\n",rootKey, debugstr_w(userPrefix), debugstr_w(value),
      path);
 
     if (userPrefix)
     {
         strcpyW(shellFolderPath, userPrefix);
         PathAddBackslashW(shellFolderPath);
         strcatW(shellFolderPath, szSHFolders);
         pShellFolderPath = shellFolderPath;
         strcpyW(userShellFolderPath, userPrefix);
         PathAddBackslashW(userShellFolderPath);
         strcatW(userShellFolderPath, szSHUserFolders);
         pUserShellFolderPath = userShellFolderPath;
     }
     else
     {
         pUserShellFolderPath = szSHUserFolders;
         pShellFolderPath = szSHFolders;
     }
 
     if (RegCreateKeyW(rootKey, pShellFolderPath, &shellFolderKey))
     {
         TRACE("Failed to create %s\n", debugstr_w(pShellFolderPath));
         return E_FAIL;
     }
     if (RegCreateKeyW(rootKey, pUserShellFolderPath, &userShellFolderKey))
     {
         TRACE("Failed to create %s\n",
          debugstr_w(pUserShellFolderPath));
         RegCloseKey(shellFolderKey);
         return E_FAIL;
     }
 
     dwPathLen = MAX_PATH * sizeof(WCHAR);
     if (!RegQueryValueExW(userShellFolderKey, value, NULL, &dwType,
      (LPBYTE)path, &dwPathLen) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ))
     {
         LONG ret;
 
         path[dwPathLen / sizeof(WCHAR)] = '\0';
         if (dwType == REG_EXPAND_SZ && path[0] == '%')
         {
             WCHAR szTemp[MAX_PATH];
 
 #ifndef __REACTOS__
             _SHExpandEnvironmentStrings(path, szTemp);
 #else
             hr = _SHExpandEnvironmentStrings(hToken, path, szTemp, _countof(szTemp));
             if (FAILED(hr))
                 goto end;
 #endif
             lstrcpynW(path, szTemp, MAX_PATH);
         }
         ret = RegSetValueExW(shellFolderKey, value, 0, REG_SZ, (LPBYTE)path,
          (strlenW(path) + 1) * sizeof(WCHAR));
         if (ret != ERROR_SUCCESS)
             hr = HRESULT_FROM_WIN32(ret);
         else
             hr = S_OK;
     }
     else
         hr = E_FAIL;
 #ifdef __REACTOS__
 end:
 #endif
     RegCloseKey(shellFolderKey);
     RegCloseKey(userShellFolderKey);
     TRACE("returning 0x%08x\n", hr);
     return hr;
 }

Referenced by _SHGetAllUsersProfilePath(), and _SHGetUserProfilePath().

◆ _SHOpenProfilesKey()

static HRESULT _SHOpenProfilesKey ( PHKEY pKey )

static

Definition at line 2229 of file shellpath.c.

 {
     LONG lRet;
     DWORD disp;
 
     lRet = RegCreateKeyExW(HKEY_LOCAL_MACHINE, ProfileListW, 0, NULL, 0,
      KEY_ALL_ACCESS, NULL, pKey, &disp);
     return HRESULT_FROM_WIN32(lRet);
 }

Referenced by _SHExpandEnvironmentStrings().

◆ _SHRegisterCommonShellFolders()

static HRESULT _SHRegisterCommonShellFolders ( void )

static

Definition at line 2892 of file shellpath.c.

 {
     static const UINT folders[] = {
      CSIDL_COMMON_STARTMENU,
      CSIDL_COMMON_PROGRAMS,
      CSIDL_COMMON_STARTUP,
      CSIDL_COMMON_DESKTOPDIRECTORY,
      CSIDL_COMMON_FAVORITES,
      CSIDL_COMMON_APPDATA,
      CSIDL_COMMON_TEMPLATES,
      CSIDL_COMMON_DOCUMENTS,
      CSIDL_COMMON_ADMINTOOLS,
      CSIDL_COMMON_MUSIC,
      CSIDL_COMMON_PICTURES,
      CSIDL_COMMON_VIDEO,
     };
     HRESULT hr;
 
     TRACE("\n");
     hr = _SHRegisterFolders(HKEY_LOCAL_MACHINE, NULL, szSHUserFolders,
      szSHFolders, folders, ARRAY_SIZE(folders));
     TRACE("returning 0x%08x\n", hr);
     return hr;
 }

Referenced by SHELL_RegisterShellFolders().

◆ _SHRegisterFolders()

static HRESULT _SHRegisterFolders	(	HKEY	hRootKey,
		HANDLE	hToken,
		LPCWSTR	szUserShellFolderPath,
		LPCWSTR	szShellFolderPath,
		const UINT	folders[],
		UINT	foldersLen
	)

static

Definition at line 2722 of file shellpath.c.

 {
     const WCHAR *szValueName;
     WCHAR buffer[40];
     UINT i;
     WCHAR path[MAX_PATH];
     HRESULT hr = S_OK;
     HKEY hUserKey = NULL, hKey = NULL;
     DWORD dwType, dwPathLen;
     LONG ret;
 
     TRACE("%p,%p,%s,%p,%u\n", hRootKey, hToken,
      debugstr_w(szUserShellFolderPath), folders, foldersLen);
 
     ret = RegCreateKeyW(hRootKey, szUserShellFolderPath, &hUserKey);
     if (ret)
         hr = HRESULT_FROM_WIN32(ret);
     else
     {
         ret = RegCreateKeyW(hRootKey, szShellFolderPath, &hKey);
         if (ret)
             hr = HRESULT_FROM_WIN32(ret);
     }
     for (i = 0; SUCCEEDED(hr) && i < foldersLen; i++)
     {
         dwPathLen = MAX_PATH * sizeof(WCHAR);
 
         /* For CSIDL_Type_User we also use the GUID if no szValueName is provided */
         szValueName = CSIDL_Data[folders[i]].szValueName;
 #ifdef __REACTOS__
         if (!szValueName &&
             (CSIDL_Data[folders[i]].type == CSIDL_Type_User ||
              CSIDL_Data[folders[i]].type == CSIDL_Type_InMyDocuments))
 #else
         if (!szValueName && CSIDL_Data[folders[i]].type == CSIDL_Type_User)
 #endif
         {
             StringFromGUID2( CSIDL_Data[folders[i]].id, buffer, 39 );
             szValueName = &buffer[0];
         }
 
         if (!RegQueryValueExW(hUserKey, szValueName, NULL,
                               &dwType, (LPBYTE)path, &dwPathLen) &&
             (dwType == REG_SZ || dwType == REG_EXPAND_SZ))
         {
             hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
                                   hToken, SHGFP_TYPE_CURRENT, path);
         }
         else
         {
             *path = '\0';
 #ifdef __REACTOS__
             if (CSIDL_Data[folders[i]].type == CSIDL_Type_User ||
                 CSIDL_Data[folders[i]].type == CSIDL_Type_InMyDocuments)
 #else
             if (CSIDL_Data[folders[i]].type == CSIDL_Type_User)
 #endif
                 _SHGetUserProfilePath(hToken, SHGFP_TYPE_CURRENT, folders[i],
                  path);
             else if (CSIDL_Data[folders[i]].type == CSIDL_Type_AllUsers)
                 _SHGetAllUsersProfilePath(SHGFP_TYPE_CURRENT, folders[i], path);
             else if (CSIDL_Data[folders[i]].type == CSIDL_Type_WindowsPath)
             {
                 GetWindowsDirectoryW(path, MAX_PATH);
                 if (CSIDL_Data[folders[i]].szDefaultPath &&
                     !IS_INTRESOURCE(CSIDL_Data[folders[i]].szDefaultPath))
                 {
                     PathAddBackslashW(path);
                     strcatW(path, CSIDL_Data[folders[i]].szDefaultPath);
                 }
             }
             else
                 hr = E_FAIL;
             if (*path)
             {
                 ret = RegSetValueExW(hUserKey, szValueName, 0, REG_EXPAND_SZ,
                  (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
                 if (ret)
                     hr = HRESULT_FROM_WIN32(ret);
                 else
                 {
                     hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
                      hToken, SHGFP_TYPE_CURRENT, path);
                     ret = RegSetValueExW(hKey, szValueName, 0, REG_SZ,
                      (LPBYTE)path, (strlenW(path) + 1) * sizeof(WCHAR));
                     if (ret)
                         hr = HRESULT_FROM_WIN32(ret);
                 }
             }
         }
     }
     if (hUserKey)
         RegCloseKey(hUserKey);
     if (hKey)
         RegCloseKey(hKey);
 
     TRACE("returning 0x%08x\n", hr);
     return hr;
 }

Referenced by _SHRegisterCommonShellFolders(), and _SHRegisterUserShellFolders().

◆ _SHRegisterUserShellFolders()

static HRESULT _SHRegisterUserShellFolders ( BOOL bDefault )

static

Definition at line 2824 of file shellpath.c.

 {
     static const UINT folders[] = {
      CSIDL_PROGRAMS,
      CSIDL_PERSONAL,
      CSIDL_FAVORITES,
      CSIDL_APPDATA,
      CSIDL_STARTUP,
      CSIDL_RECENT,
      CSIDL_SENDTO,
      CSIDL_STARTMENU,
      CSIDL_MYMUSIC,
      CSIDL_MYVIDEO,
      CSIDL_DESKTOPDIRECTORY,
      CSIDL_NETHOOD,
      CSIDL_TEMPLATES,
      CSIDL_PRINTHOOD,
      CSIDL_LOCAL_APPDATA,
      CSIDL_INTERNET_CACHE,
      CSIDL_COOKIES,
      CSIDL_HISTORY,
      CSIDL_MYPICTURES,
      CSIDL_FONTS,
      CSIDL_ADMINTOOLS,
 /* Cannot use #if _WIN32_WINNT >= 0x0600 because _WIN32_WINNT == 0x0600 here. */
 #ifndef __REACTOS__
      CSIDL_CONTACTS,
      CSIDL_DOWNLOADS,
      CSIDL_LINKS,
      CSIDL_APPDATA_LOCALLOW,
      CSIDL_SAVED_GAMES,
      CSIDL_SEARCHES
 #endif
     };
     WCHAR userShellFolderPath[MAX_PATH], shellFolderPath[MAX_PATH];
     LPCWSTR pUserShellFolderPath, pShellFolderPath;
     HRESULT hr = S_OK;
     HKEY hRootKey;
     HANDLE hToken;
 
     TRACE("%s\n", bDefault ? "TRUE" : "FALSE");
     if (bDefault)
     {
         hToken = (HANDLE)-1;
         hRootKey = HKEY_USERS;
         strcpyW(userShellFolderPath, DefaultW);
         PathAddBackslashW(userShellFolderPath);
         strcatW(userShellFolderPath, szSHUserFolders);
         pUserShellFolderPath = userShellFolderPath;
         strcpyW(shellFolderPath, DefaultW);
         PathAddBackslashW(shellFolderPath);
         strcatW(shellFolderPath, szSHFolders);
         pShellFolderPath = shellFolderPath;
     }
     else
     {
         hToken = NULL;
         hRootKey = HKEY_CURRENT_USER;
         pUserShellFolderPath = szSHUserFolders;
         pShellFolderPath = szSHFolders;
     }
 
     hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath,
      pShellFolderPath, folders, ARRAY_SIZE(folders));
     TRACE("returning 0x%08x\n", hr);
     return hr;
 }

Referenced by SHELL_RegisterShellFolders().

◆ GetShortPathNameAbsentW()

static DWORD GetShortPathNameAbsentW	(	LPCWSTR	pszLong,
		LPWSTR	pszShort,
		DWORD	cchShort
	)

static

Definition at line 149 of file shellpath.c.

 {
     FIXME("GetShortPathNameAbsentW(%ls, %p, %ld): stub\n", pszLong, pszShort, cchShort);
     StringCchCopyW(pszShort, cchShort, pszLong);
     return lstrlenW(pszShort);
 }

Referenced by PathQualifyExW().

◆ IsLFNDriveA()

BOOL WINAPI IsLFNDriveA ( LPCSTR lpszPath )

Definition at line 408 of file shellpath.c.

 {
     DWORD   fnlen;
 
     if (!GetVolumeInformationA(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
     return FALSE;
     return fnlen > 12;
 }

Referenced by IsLFNDriveAW().

◆ IsLFNDriveAW()

BOOL WINAPI IsLFNDriveAW ( LPCVOID lpszPath )

Definition at line 432 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return IsLFNDriveW(lpszPath);
     return IsLFNDriveA(lpszPath);
 }

◆ IsLFNDriveW()

BOOL WINAPI IsLFNDriveW ( LPCWSTR lpszPath )

Definition at line 420 of file shellpath.c.

 {
     DWORD   fnlen;
 
     if (!GetVolumeInformationW(lpszPath, NULL, 0, NULL, &fnlen, NULL, NULL, 0))
     return FALSE;
     return fnlen > 12;
 }

Referenced by IsLFNDriveAW(), and PathQualifyExW().

◆ PathAppendAW()

BOOL WINAPI PathAppendAW	(	LPVOID	lpszPath1,
		LPCVOID	lpszPath2
	)

Definition at line 236 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathAppendW(lpszPath1, lpszPath2);
     return PathAppendA(lpszPath1, lpszPath2);
 }

◆ PathCleanupSpec()

int WINAPI PathCleanupSpec	(	LPCWSTR	lpszPathW,
		LPWSTR	lpszFileW
	)

Definition at line 531 of file shellpath.c.

 {
     int i = 0;
     DWORD rc = 0;
     int length = 0;
 
     if (SHELL_OsIsUnicode())
     {
         LPWSTR p = lpszFileW;
 
         TRACE("Cleanup %s\n",debugstr_w(lpszFileW));
 
         if (lpszPathW)
             length = strlenW(lpszPathW);
 
         while (*p)
         {
             int gct = PathGetCharTypeW(*p);
             if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
             {
                 lpszFileW[i]='-';
                 rc |= PCS_REPLACEDCHAR;
             }
             else
                 lpszFileW[i]=*p;
             i++;
             p++;
             if (length + i == MAX_PATH)
             {
                 rc |= PCS_FATAL | PCS_PATHTOOLONG;
                 break;
             }
         }
         lpszFileW[i]=0;
     }
     else
     {
         LPSTR lpszFileA = (LPSTR)lpszFileW;
         LPCSTR lpszPathA = (LPCSTR)lpszPathW;
         LPSTR p = lpszFileA;
 
         TRACE("Cleanup %s\n",debugstr_a(lpszFileA));
 
         if (lpszPathA)
             length = strlen(lpszPathA);
 
         while (*p)
         {
             int gct = PathGetCharTypeA(*p);
             if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
             {
                 lpszFileA[i]='-';
                 rc |= PCS_REPLACEDCHAR;
             }
             else
                 lpszFileA[i]=*p;
             i++;
             p++;
             if (length + i == MAX_PATH)
             {
                 rc |= PCS_FATAL | PCS_PATHTOOLONG;
                 break;
             }
         }
         lpszFileA[i]=0;
     }
     return rc;
 }

◆ PathFileExistsAW()

BOOL WINAPI PathFileExistsAW ( LPCVOID lpszPath )

Definition at line 398 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathFileExistsW (lpszPath);
     return PathFileExistsA (lpszPath);
 }

◆ PathGetExtensionA()

static LPSTR PathGetExtensionA ( LPCSTR lpszPath )

static

Definition at line 252 of file shellpath.c.

 {
     TRACE("(%s)\n",lpszPath);
 
     lpszPath = PathFindExtensionA(lpszPath);
     return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
 }

Referenced by PathIsExeA().

◆ PathGetExtensionW()

static LPWSTR PathGetExtensionW ( LPCWSTR lpszPath )

static

Definition at line 263 of file shellpath.c.

 {
     TRACE("(%s)\n",debugstr_w(lpszPath));
 
     lpszPath = PathFindExtensionW(lpszPath);
     return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
 }

Referenced by PathIsExeW(), and SHPathGetExtensionW().

◆ PathGetShortPathA()

static void PathGetShortPathA ( LPSTR pszPath )

static

Definition at line 296 of file shellpath.c.

 {
     CHAR path[MAX_PATH];
 
     TRACE("%s\n", pszPath);
 
     if (GetShortPathNameA(pszPath, path, MAX_PATH))
     {
       lstrcpyA(pszPath, path);
     }
 }

Referenced by PathGetShortPathAW().

◆ PathGetShortPathAW()

VOID WINAPI PathGetShortPathAW ( LPVOID pszPath )

Definition at line 326 of file shellpath.c.

 {
     if(SHELL_OsIsUnicode())
       PathGetShortPathW(pszPath);
     PathGetShortPathA(pszPath);
 }

◆ PathGetShortPathW()

static void PathGetShortPathW ( LPWSTR pszPath )

static

Definition at line 311 of file shellpath.c.

 {
     WCHAR path[MAX_PATH];
 
     TRACE("%s\n", debugstr_w(pszPath));
 
     if (GetShortPathNameW(pszPath, path, MAX_PATH))
     {
       lstrcpyW(pszPath, path);
     }
 }

Referenced by PathGetShortPathAW().

◆ PathIsAbsoluteW()

static BOOL WINAPI PathIsAbsoluteW ( LPCWSTR path )

static

Definition at line 127 of file shellpath.c.

 {
     return PathIsUNCW(path) || (PathGetDriveNumberW(path) != -1 && path[2] == L'\\');
 }

Referenced by PathResolveW().

◆ PathIsExeA()

static BOOL PathIsExeA ( LPCSTR lpszPath )

static

Definition at line 350 of file shellpath.c.

 {
     LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
         int i;
         static const char * const lpszExtensions[] =
             {"exe", "com", "pif", "cmd", "bat", "scf", "scr", NULL };
 
     TRACE("path=%s\n",lpszPath);
 
     for(i=0; lpszExtensions[i]; i++)
       if (!lstrcmpiA(lpszExtension,lpszExtensions[i])) return TRUE;
 
     return FALSE;
 }

Referenced by PathIsExeAW().

◆ PathIsExeAW()

BOOL WINAPI PathIsExeAW ( LPCVOID path )

Definition at line 388 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathIsExeW (path);
     return PathIsExeA(path);
 }

◆ PathIsExeW()

BOOL PathIsExeW ( LPCWSTR lpszPath )

Definition at line 368 of file shellpath.c.

 {
     LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
         int i;
         static const WCHAR lpszExtensions[][4] =
             {{'e','x','e','\0'}, {'c','o','m','\0'}, {'p','i','f','\0'},
              {'c','m','d','\0'}, {'b','a','t','\0'}, {'s','c','f','\0'},
              {'s','c','r','\0'}, {'\0'} };
 
     TRACE("path=%s\n",debugstr_w(lpszPath));
 
     for(i=0; lpszExtensions[i][0]; i++)
       if (!strcmpiW(lpszExtension,lpszExtensions[i])) return TRUE;
 
     return FALSE;
 }

Referenced by CFileDefExt::InitGeneralPage(), COpenWithMenu::Initialize(), and PathIsExeAW().

◆ PathIsRootAW()

BOOL WINAPI PathIsRootAW ( LPCVOID lpszPath )

Definition at line 340 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathIsRootW(lpszPath);
     return PathIsRootA(lpszPath);
 }

◆ PathMakeAbsoluteW()

static BOOL WINAPI PathMakeAbsoluteW ( LPWSTR path )

static

Definition at line 133 of file shellpath.c.

 {
     WCHAR path1[MAX_PATH];
     DWORD cch;
 
     if (path == NULL)
         return FALSE;
     cch = GetCurrentDirectoryW(_countof(path1), path1);
     if (!cch || cch > _countof(path1))
         return FALSE;
     return (PathCombineW(path, path1, path) != NULL);
 }

Referenced by PathResolveW().

◆ PathMakeUniqueNameA()

static BOOL PathMakeUniqueNameA	(	LPSTR	lpszBuffer,
		DWORD	dwBuffSize,
		LPCSTR	lpszShortName,
		LPCSTR	lpszLongName,
		LPCSTR	lpszPathName
	)

static

Definition at line 445 of file shellpath.c.

 {
     FIXME("%p %u %s %s %s stub\n",
      lpszBuffer, dwBuffSize, debugstr_a(lpszShortName),
      debugstr_a(lpszLongName), debugstr_a(lpszPathName));
     return TRUE;
 }

Referenced by PathMakeUniqueNameAW().

◆ PathMakeUniqueNameAW()

BOOL WINAPI PathMakeUniqueNameAW	(	LPVOID	lpszBuffer,
		DWORD	dwBuffSize,
		LPCVOID	lpszShortName,
		LPCVOID	lpszLongName,
		LPCVOID	lpszPathName
	)

Definition at line 477 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
     return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
 }

◆ PathMakeUniqueNameW()

static BOOL PathMakeUniqueNameW	(	LPWSTR	lpszBuffer,
		DWORD	dwBuffSize,
		LPCWSTR	lpszShortName,
		LPCWSTR	lpszLongName,
		LPCWSTR	lpszPathName
	)

static

Definition at line 461 of file shellpath.c.

 {
     FIXME("%p %u %s %s %s stub\n",
      lpszBuffer, dwBuffSize, debugstr_w(lpszShortName),
      debugstr_w(lpszLongName), debugstr_w(lpszPathName));
     return TRUE;
 }

Referenced by PathMakeUniqueNameAW().

◆ PathProcessCommandA()

static LONG PathProcessCommandA	(	LPCSTR	lpszPath,
		LPSTR	lpszBuff,
		DWORD	dwBuffSize,
		DWORD	dwFlags
	)

static

Definition at line 769 of file shellpath.c.

 {
     FIXME("%s %p 0x%04x 0x%04x stub\n",
     lpszPath, lpszBuff, dwBuffSize, dwFlags);
     if(!lpszPath) return -1;
     if(lpszBuff) strcpy(lpszBuff, lpszPath);
     return strlen(lpszPath);
 }

Referenced by PathProcessCommandAW().

◆ PathProcessCommandAW()

LONG WINAPI PathProcessCommandAW	(	LPCVOID	lpszPath,
		LPVOID	lpszBuff,
		DWORD	dwBuffSize,
		DWORD	dwFlags
	)

Definition at line 801 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
     return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
 }

◆ PathProcessCommandW()

static LONG PathProcessCommandW	(	LPCWSTR	lpszPath,
		LPWSTR	lpszBuff,
		DWORD	dwBuffSize,
		DWORD	dwFlags
	)

static

Definition at line 785 of file shellpath.c.

 {
     FIXME("(%s, %p, 0x%04x, 0x%04x) stub\n",
     debugstr_w(lpszPath), lpszBuff, dwBuffSize, dwFlags);
     if(!lpszPath) return -1;
     if(lpszBuff) strcpyW(lpszBuff, lpszPath);
     return strlenW(lpszPath);
 }

Referenced by PathProcessCommandAW().

◆ PathQualifyA()

VOID WINAPI PathQualifyA ( LPSTR pszPath )

Definition at line 603 of file shellpath.c.

 {
     WCHAR szPath[MAX_PATH];
     TRACE("%s\n",pszPath);
     SHAnsiToUnicode(pszPath, szPath, _countof(szPath));
     PathQualifyW(szPath);
     SHUnicodeToAnsi(szPath, pszPath, MAX_PATH);
 }

Referenced by PathQualifyAW().

◆ PathQualifyAW()

VOID WINAPI PathQualifyAW ( LPVOID pszPath )

Definition at line 624 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
         PathQualifyW(pszPath);
     else
         PathQualifyA(pszPath);
 }

◆ PathQualifyExW()

static VOID WINAPI PathQualifyExW	(	LPWSTR	pszPath,
		LPCWSTR	pszDir,
		DWORD	dwFlags
	)

static

Definition at line 159 of file shellpath.c.

 {
     WCHAR szRoot[MAX_PATH], szCopy[MAX_PATH], szCurDir[MAX_PATH];
     LPWSTR pch;
     LONG cch;
     BOOL bCheckLFN;
 
     if (FAILED(StringCchCopyW(szCopy, _countof(szCopy), pszPath)))
         return;
 
     FixSlashesAndColonW(szCopy);
 
     if (pszDir)
     {
         cch = GetCurrentDirectoryW(_countof(szCurDir), szCurDir);
         if (cch <= 0 || cch >= _countof(szCurDir) || !SetCurrentDirectoryW(pszDir))
             pszDir = NULL;
     }
 
     if (!GetFullPathNameW(szCopy, _countof(szRoot), szRoot, NULL))
         goto Quit;
 
     if (PathIsUNCW(szRoot)) /* it begins with double backslash */
     {
         pch = StrChrW(&szRoot[2], L'\\');
         if (pch)
         {
             pch = StrChrW(&pch[1], L'\\');
             if (pch)
                 *pch = 0;
             if (!PathAddBackslashW(szRoot))
                 goto Quit;
             /* szRoot is like \\MyServer\MyShare\ */
             bCheckLFN = TRUE;
         }
         else
         {
             bCheckLFN = FALSE;
         }
     }
     else
     {
         if (!PathStripToRootW(szRoot) || !PathAddBackslashW(szRoot))
             goto Quit;
         /* szRoot is like X:\ */
         bCheckLFN = TRUE;
     }
 
     if (bCheckLFN && !IsLFNDriveW(szRoot)) /* not a long filename drive */
     {
         if (!GetFullPathNameW(szCopy, _countof(szRoot), szRoot, NULL))
             goto Quit;
         if (!GetShortPathNameW(szRoot, szCopy, _countof(szCopy)) &&
             !GetShortPathNameAbsentW(szRoot, szCopy, _countof(szCopy)))
         {
             goto Quit;
         }
     }
 
     PathRemoveBackslashW(szCopy);
     StringCchCopyW(pszPath, MAX_PATH, szCopy);
 
     if ((dwFlags & 1) == 0)
     {
         cch = lstrlenW(pszPath);
         if (cch > 0 && pszPath[cch - 1] == L'.')
             pszPath[cch - 1] = 0;
     }
 
 Quit:
     if (pszDir)
         SetCurrentDirectoryW(szCurDir);
 }

Referenced by PathQualifyW(), and PathResolveW().

◆ PathQualifyW()

VOID WINAPI PathQualifyW ( LPWSTR pszPath )

Definition at line 615 of file shellpath.c.

 {
     TRACE("%s\n",debugstr_w(pszPath));
     PathQualifyExW(pszPath, NULL, 0);
 }

Referenced by PathQualifyA(), and PathQualifyAW().

◆ PathRemoveFileSpecAW()

BOOL WINAPI PathRemoveFileSpecAW ( LPVOID lpszPath )

Definition at line 282 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
       return PathRemoveFileSpecW(lpszPath);
     return PathRemoveFileSpecA(lpszPath);
 }

◆ PathResolveA()

BOOL WINAPI PathResolveA	(	LPSTR	path,
		LPCSTR *	dirs,
		DWORD	flags
	)

Definition at line 632 of file shellpath.c.

 {
     BOOL ret = FALSE;
     LPWSTR *dirsW = NULL;
     DWORD iDir, cDirs, cbDirs;
     WCHAR pathW[MAX_PATH];
 
     TRACE("PathResolveA(%s,%p,0x%08x)\n", debugstr_a(path), dirs, flags);
 
     if (dirs)
     {
         for (cDirs = 0; dirs[cDirs]; ++cDirs)
             ;
 
         cbDirs = (cDirs + 1) * sizeof(LPWSTR);
         dirsW = SHAlloc(cbDirs);
         if (!dirsW)
             goto Cleanup;
 
         ZeroMemory(dirsW, cbDirs);
         for (iDir = 0; iDir < cDirs; ++iDir)
         {
             __SHCloneStrAtoW(&dirsW[iDir], dirs[iDir]);
             if (dirsW[iDir] == NULL)
                 goto Cleanup;
         }
     }
 
     SHAnsiToUnicode(path, pathW, _countof(pathW));
 
     ret = PathResolveW(pathW, (LPCWSTR*)dirsW, flags);
     if (ret)
         SHUnicodeToAnsi(pathW, path, MAX_PATH);
 
 Cleanup:
     if (dirsW)
     {
         for (iDir = 0; iDir < cDirs; ++iDir)
         {
             SHFree(dirsW[iDir]);
         }
         SHFree(dirsW);
     }
     return ret;
 }

Referenced by PathResolveAW().

◆ PathResolveAW()

BOOL WINAPI PathResolveAW	(	LPVOID	path,
		LPCVOID *	paths,
		DWORD	flags
	)

Definition at line 758 of file shellpath.c.

 {
     if (SHELL_OsIsUnicode())
         return PathResolveW(path, (LPCWSTR*)paths, flags);
     else
         return PathResolveA(path, (LPCSTR*)paths, flags);
 }

◆ PathResolveW()

BOOL WINAPI PathResolveW	(	LPWSTR	path,
		LPCWSTR *	dirs,
		DWORD	flags
	)

Definition at line 678 of file shellpath.c.

 {
     DWORD dwWhich = ((flags & PRF_DONTFINDLNK) ? (WHICH_DEFAULT & ~WHICH_LNK) : WHICH_DEFAULT);
 
     TRACE("PathResolveW(%s,%p,0x%08x)\n", debugstr_w(path), dirs, flags);
 
     if (flags & PRF_VERIFYEXISTS)
         SetLastError(ERROR_FILE_NOT_FOUND);
 
     PathUnquoteSpacesW(path);
 
     if (PathIsRootW(path))
     {
         if ((path[0] == L'\\' && path[1] == 0) ||
             PathIsUNCServerW(path) || PathIsUNCServerShareW(path))
         {
             if (flags & PRF_FIRSTDIRDEF)
                 PathQualifyExW(path, dirs[0], 0);
             else
                 PathQualifyExW(path, NULL, 0);
         }
 
         if (flags & PRF_VERIFYEXISTS)
             return PathFileExistsAndAttributesW(path, NULL);
         return TRUE;
     }
     else if (PathIsFileSpecW(path))
     {
         if ((flags & PRF_TRYPROGRAMEXTENSIONS) && PathSearchOnExtensionsW(path, dirs, TRUE, dwWhich))
             return TRUE;
 
         if (PathFindOnPathW(path, dirs))
         {
 #if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
             if (!(flags & PRF_REQUIREABSOLUTE))
                 return TRUE;
 
             if (!PathIsAbsoluteW(path))
                 return PathMakeAbsoluteW(path) && PathFileExistsAndAttributesW(path, NULL);
 #else
             return TRUE;
 #endif
         }
     }
     else if (!PathIsURLW(path))
     {
         if (flags & PRF_FIRSTDIRDEF)
             PathQualifyExW(path, *dirs, 1);
         else
             PathQualifyExW(path, NULL, 1);
 
         if (flags & PRF_VERIFYEXISTS)
         {
             if ((flags & PRF_TRYPROGRAMEXTENSIONS) &&
                 PathSearchOnExtensionsW(path, dirs, FALSE, dwWhich))
             {
                 return TRUE;
             }
             else if (!PathFileExistsAndAttributesW(path, NULL))
             {
                 return FALSE;
             }
         }
 
 #if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
         if (flags & PRF_REQUIREABSOLUTE)
         {
             if (!PathIsAbsoluteW(path))
                 return PathMakeAbsoluteW(path) && PathFileExistsAndAttributesW(path, NULL);
         }
 #endif
         return TRUE;
     }
 
     return FALSE;
 }

Referenced by PathResolveA(), PathResolveAW(), and CShellLink::SetTargetFromPIDLOrPath().

◆ PathSearchOnExtensionsW()

static BOOL WINAPI PathSearchOnExtensionsW	(	LPWSTR	pszPath,
		LPCWSTR *	ppszDirs,
		BOOL	bDoSearch,
		DWORD	dwWhich
	)

static

Definition at line 114 of file shellpath.c.

 {
     if (*PathFindExtensionW(pszPath) != 0)
         return FALSE;
 
     if (bDoSearch)
         return PathFindOnPathExW(pszPath, ppszDirs, dwWhich);
     else
         return PathFileExistsDefExtW(pszPath, dwWhich);
 }

Referenced by PathResolveW().

◆ PathYetAnotherMakeUniqueName()

BOOL WINAPI PathYetAnotherMakeUniqueName	(	LPWSTR	buffer,
		LPCWSTR	path,
		LPCWSTR	shortname,
		LPCWSTR	longname
	)

Definition at line 492 of file shellpath.c.

 {
     WCHAR pathW[MAX_PATH], retW[MAX_PATH];
     const WCHAR *file, *ext;
     int i = 2;
 
     TRACE("(%p, %s, %s, %s)\n", buffer, debugstr_w(path), debugstr_w(shortname), debugstr_w(longname));
 
     file = longname ? longname : shortname;
     PathCombineW(pathW, path, file);
     strcpyW(retW, pathW);
     PathRemoveExtensionW(pathW);
 
     ext = PathFindExtensionW(file);
 
     /* now try to make it unique */
     while (PathFileExistsW(retW))
     {
         static const WCHAR fmtW[] = {'%','s',' ','(','%','d',')','%','s',0};
 
         sprintfW(retW, fmtW, pathW, i, ext);
         i++;
     }
 
     strcpyW(buffer, retW);
     TRACE("ret - %s\n", debugstr_w(buffer));
 
     return TRUE;
 }

Referenced by BrsFolder_NewFolder(), CNewMenu::CreateNewFolder(), CDefaultContextMenu::DoCreateNewFolder(), loadShell32(), and CNewMenu::NewItemByNonCommand().

◆ SHELL_RegisterShellFolders()

HRESULT SHELL_RegisterShellFolders ( void )

Definition at line 2920 of file shellpath.c.

 {
     HRESULT hr;
 
     hr = _SHRegisterUserShellFolders(TRUE);
     if (SUCCEEDED(hr))
         hr = _SHRegisterUserShellFolders(FALSE);
     if (SUCCEEDED(hr))
         hr = _SHRegisterCommonShellFolders();
     return hr;
 }

Referenced by DllRegisterServer().

◆ SHGetFolderLocation()

HRESULT WINAPI SHGetFolderLocation	(	HWND	hwndOwner,
		int	nFolder,
		HANDLE	hToken,
		DWORD	dwReserved,
		LPITEMIDLIST *	ppidl
	)

Definition at line 2980 of file shellpath.c.

 {
     HRESULT hr = E_INVALIDARG;
 
     TRACE("%p 0x%08x %p 0x%08x %p\n",
      hwndOwner, nFolder, hToken, dwReserved, ppidl);
     
     if (!ppidl)
         return E_INVALIDARG;
     if (dwReserved)
         return E_INVALIDARG;
 
     /* The virtual folders' locations are not user-dependent */
     *ppidl = NULL;
     switch (nFolder & CSIDL_FOLDER_MASK)
     {
         case CSIDL_DESKTOP:
             *ppidl = _ILCreateDesktop();
             break;
 
         case CSIDL_PERSONAL:
             *ppidl = _ILCreateMyDocuments();
             break;
 
         case CSIDL_INTERNET:
             *ppidl = _ILCreateIExplore();
             break;
 
         case CSIDL_CONTROLS:
             *ppidl = _ILCreateControlPanel();
             break;
 
         case CSIDL_PRINTERS:
             *ppidl = _ILCreatePrinters();
             break;
 
         case CSIDL_BITBUCKET:
             *ppidl = _ILCreateBitBucket();
             break;
 
         case CSIDL_DRIVES:
             *ppidl = _ILCreateMyComputer();
             break;
 
         case CSIDL_NETWORK:
             *ppidl = _ILCreateNetwork();
             break;
 
         default:
         {
             WCHAR szPath[MAX_PATH];
 
             hr = SHGetFolderPathW(hwndOwner, nFolder, hToken,
              SHGFP_TYPE_CURRENT, szPath);
             if (SUCCEEDED(hr))
             {
                 DWORD attributes=0;
 
                 TRACE("Value=%s\n", debugstr_w(szPath));
                 hr = SHILCreateFromPathW(szPath, ppidl, &attributes);
             }
             else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
             {
                 /* unlike SHGetFolderPath, SHGetFolderLocation in shell32
                  * version 6.0 returns E_FAIL for nonexistent paths
                  */
                 hr = E_FAIL;
             }
         }
     }
     if(*ppidl)
         hr = S_OK;
 
     TRACE("-- (new pidl %p)\n",*ppidl);
     return hr;
 }

Referenced by CBandSiteMenu::_CreateBuiltInISFBand(), BrsFolder_OnCreate(), ILIsParentOrSpecialParent(), CExplorerBand::InitializeExplorerBand(), CExplorerBand::InsertSubitems(), LoadRdpSettingsFromFile(), loadShell32(), CShellMenuCallback::OnGetSubMenu(), SaveRdpSettingsToFile(), SHCreateFromDesktop(), SHEmptyRecycleBinW(), SHGetSpecialFolderLocation(), START_TEST(), TestCommandLine(), and TestCompareIDList().

◆ SHGetFolderPathA()

HRESULT WINAPI SHGetFolderPathA	(	HWND	hwndOwner,
		int	nFolder,
		HANDLE	hToken,
		DWORD	dwFlags,
		LPSTR	pszPath
	)

Definition at line 2692 of file shellpath.c.

 {
     WCHAR szTemp[MAX_PATH];
     HRESULT hr;
 
     TRACE("%p,%d,%p,%#x,%p\n", hwndOwner, nFolder, hToken, dwFlags, pszPath);
 
     if (pszPath)
         *pszPath = '\0';
     hr = SHGetFolderPathW(hwndOwner, nFolder, hToken, dwFlags, szTemp);
     if (SUCCEEDED(hr) && pszPath)
         WideCharToMultiByte(CP_ACP, 0, szTemp, -1, pszPath, MAX_PATH, NULL,
          NULL);
 
     return hr;
 }

Referenced by init_functionpointers(), loadShell32(), SHGetSpecialFolderPathA(), test_profile_items(), test_SHGetFolderPathA(), and test_SHGetFolderPathAndSubDirA().

◆ SHGetFolderPathAndSubDirA()

HRESULT WINAPI SHGetFolderPathAndSubDirA	(	HWND	hwndOwner,
		int	nFolder,
		HANDLE	hToken,
		DWORD	dwFlags,
		LPCSTR	pszSubPath,
		LPSTR	pszPath
	)

Definition at line 2460 of file shellpath.c.

 {
     int length;
     HRESULT hr = S_OK;
     LPWSTR pszSubPathW = NULL;
     LPWSTR pszPathW = NULL;
 
     TRACE("%p,%#x,%p,%#x,%s,%p\n", hwndOwner, nFolder, hToken, dwFlags, debugstr_a(pszSubPath), pszPath);
 
     if(pszPath) {
         pszPathW = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
         if(!pszPathW) {
             hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
             goto cleanup;
         }
     }
     TRACE("%08x,%08x,%s\n",nFolder, dwFlags, debugstr_w(pszSubPathW));
 
     /* SHGetFolderPathAndSubDirW does not distinguish if pszSubPath isn't
      * set (null), or an empty string.therefore call it without the parameter set
      * if pszSubPath is an empty string
      */
     if (pszSubPath && pszSubPath[0]) {
         length = MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, NULL, 0);
         pszSubPathW = HeapAlloc(GetProcessHeap(), 0, length * sizeof(WCHAR));
         if(!pszSubPathW) {
             hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
             goto cleanup;
         }
         MultiByteToWideChar(CP_ACP, 0, pszSubPath, -1, pszSubPathW, length);
     }
 
     hr = SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, pszSubPathW, pszPathW);
 
     if (SUCCEEDED(hr) && pszPath)
         WideCharToMultiByte(CP_ACP, 0, pszPathW, -1, pszPath, MAX_PATH, NULL, NULL);
 
 cleanup:
     HeapFree(GetProcessHeap(), 0, pszPathW);
     HeapFree(GetProcessHeap(), 0, pszSubPathW);
     return hr;
 }

Referenced by test_SHGetFolderPathAndSubDirA().

◆ SHGetFolderPathAndSubDirW()

HRESULT WINAPI SHGetFolderPathAndSubDirW	(	HWND	hwndOwner,
		int	nFolder,
		HANDLE	hToken,
		DWORD	dwFlags,
		LPCWSTR	pszSubPath,
		LPWSTR	pszPath
	)

Definition at line 2512 of file shellpath.c.

 {
     HRESULT    hr;
     WCHAR      szBuildPath[MAX_PATH], szTemp[MAX_PATH];
     DWORD      folder = nFolder & CSIDL_FOLDER_MASK;
     CSIDL_Type type;
     int        ret;
     
     TRACE("%p,%#x,%p,%#x,%s,%p\n", hwndOwner, nFolder, hToken, dwFlags, debugstr_w(pszSubPath), pszPath);
 
     /* Windows always NULL-terminates the resulting path regardless of success
      * or failure, so do so first
      */
     if (pszPath)
         *pszPath = '\0';
 
     if (folder >= ARRAY_SIZE(CSIDL_Data))
         return E_INVALIDARG;
     if ((SHGFP_TYPE_CURRENT != dwFlags) && (SHGFP_TYPE_DEFAULT != dwFlags))
         return E_INVALIDARG;
     szTemp[0] = 0;
     type = CSIDL_Data[folder].type;
     switch (type)
     {
         case CSIDL_Type_Disallowed:
             hr = E_INVALIDARG;
             break;
         case CSIDL_Type_NonExistent:
             hr = S_FALSE;
             break;
         case CSIDL_Type_WindowsPath:
             GetWindowsDirectoryW(szTemp, MAX_PATH);
             if (CSIDL_Data[folder].szDefaultPath &&
              !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
              *CSIDL_Data[folder].szDefaultPath)
             {
                 PathAddBackslashW(szTemp);
                 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
             }
             hr = S_OK;
             break;
         case CSIDL_Type_SystemPath:
             GetSystemDirectoryW(szTemp, MAX_PATH);
             if (CSIDL_Data[folder].szDefaultPath &&
              !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
              *CSIDL_Data[folder].szDefaultPath)
             {
                 PathAddBackslashW(szTemp);
                 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
             }
             hr = S_OK;
             break;
         case CSIDL_Type_SystemX86Path:
             if (!GetSystemWow64DirectoryW(szTemp, MAX_PATH)) GetSystemDirectoryW(szTemp, MAX_PATH);
             if (CSIDL_Data[folder].szDefaultPath &&
              !IS_INTRESOURCE(CSIDL_Data[folder].szDefaultPath) &&
              *CSIDL_Data[folder].szDefaultPath)
             {
                 PathAddBackslashW(szTemp);
                 strcatW(szTemp, CSIDL_Data[folder].szDefaultPath);
             }
             hr = S_OK;
             break;
         case CSIDL_Type_CurrVer:
             hr = _SHGetCurrentVersionPath(dwFlags, folder, szTemp);
             break;
         case CSIDL_Type_User:
 #ifdef __REACTOS__
         case CSIDL_Type_InMyDocuments:
 #endif
             hr = _SHGetUserProfilePath(hToken, dwFlags, folder, szTemp);
             break;
         case CSIDL_Type_AllUsers:
             hr = _SHGetAllUsersProfilePath(dwFlags, folder, szTemp);
             break;
         default:
             FIXME("bogus type %d, please fix\n", type);
             hr = E_INVALIDARG;
             break;
     }
 
     /* Expand environment strings if necessary */
     if (*szTemp == '%')
 #ifndef __REACTOS__
         hr = _SHExpandEnvironmentStrings(szTemp, szBuildPath);
 #else
         hr = _SHExpandEnvironmentStrings(hToken, szTemp, szBuildPath, _countof(szBuildPath));
 #endif
     else
         strcpyW(szBuildPath, szTemp);
 
     if (FAILED(hr)) goto end;
 
     if(pszSubPath) {
         /* make sure the new path does not exceed the buffer length
          * and remember to backslash and terminate it */
         if(MAX_PATH < (lstrlenW(szBuildPath) + lstrlenW(pszSubPath) + 2)) {
             hr = HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
             goto end;
         }
         PathAppendW(szBuildPath, pszSubPath);
         PathRemoveBackslashW(szBuildPath);
     }
     /* Copy the path if it's available before we might return */
     if (SUCCEEDED(hr) && pszPath)
         strcpyW(pszPath, szBuildPath);
 
     /* if we don't care about existing directories we are ready */
     if(nFolder & CSIDL_FLAG_DONT_VERIFY) goto end;
 
     if (PathFileExistsW(szBuildPath)) goto end;
 
     /* not existing but we are not allowed to create it.  The return value
      * is verified against shell32 version 6.0.
      */
     if (!(nFolder & CSIDL_FLAG_CREATE))
     {
         hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
         goto end;
     }
 
     /* create directory/directories */
     ret = SHCreateDirectoryExW(hwndOwner, szBuildPath, NULL);
     if (ret && ret != ERROR_ALREADY_EXISTS)
     {
         ERR("Failed to create directory %s.\n", debugstr_w(szBuildPath));
         hr = E_FAIL;
         goto end;
     }
 
     TRACE("Created missing system directory %s\n", debugstr_w(szBuildPath));
 
 end:
     /* create desktop.ini for custom icon */
     if ((nFolder & CSIDL_FLAG_CREATE) &&
         CSIDL_Data[folder].nShell32IconIndex)
     {
         static const WCHAR s_szFormat[] = L"%%SystemRoot%%\\system32\\shell32.dll,%d";
         WCHAR szIconLocation[MAX_PATH];
         DWORD dwAttributes;
 
         /* make the directory a read-only folder */
         dwAttributes = GetFileAttributesW(szBuildPath);
         dwAttributes |= FILE_ATTRIBUTE_READONLY;
         SetFileAttributesW(szBuildPath, dwAttributes);
 
         /* build the desktop.ini file path */
         PathAppendW(szBuildPath, L"desktop.ini");
 
         /* build the icon location */
         StringCchPrintfW(szIconLocation, _countof(szIconLocation), s_szFormat,
                          CSIDL_Data[folder].nShell32IconIndex);
 
         /* write desktop.ini */
         WritePrivateProfileStringW(L".ShellClassInfo", L"IconResource", szIconLocation, szBuildPath);
 
         /* flush! */
         WritePrivateProfileStringW(NULL, NULL, NULL, szBuildPath);
 
         /* make the desktop.ini a system and hidden file */
         dwAttributes = GetFileAttributesW(szBuildPath);
         dwAttributes |= FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
         SetFileAttributesW(szBuildPath, dwAttributes);
     }
 
     TRACE("returning 0x%08x (final path is %s)\n", hr, debugstr_w(szBuildPath));
     return hr;
 }

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ _INC_WINDOWS

◆ _WIN32_WINNT

◆ COBJMACROS

◆ CSIDL_APPDATA_LOCALLOW

◆ CSIDL_CONTACTS

◆ CSIDL_DOWNLOADS

◆ CSIDL_LINKS

◆ CSIDL_SAVED_GAMES

◆ CSIDL_SEARCHES

◆ WIN32_NO_STATUS

Typedef Documentation

◆ CSIDL_Type

Enumeration Type Documentation

◆ _CSIDL_Type

Function Documentation

◆ _GetUserSidStringFromToken()

◆ _SHExpandEnvironmentStrings()

◆ _SHGetAllUsersProfilePath()

◆ _SHGetCurrentVersionPath()

◆ _SHGetDefaultValue()

◆ _SHGetProfilesValue()

◆ _SHGetUserProfileDirectoryW()

◆ _SHGetUserProfilePath()

◆ _SHGetUserShellFolderPath()

◆ _SHOpenProfilesKey()

◆ _SHRegisterCommonShellFolders()

◆ _SHRegisterFolders()

◆ _SHRegisterUserShellFolders()

◆ GetShortPathNameAbsentW()

◆ IsLFNDriveA()

◆ IsLFNDriveAW()

◆ IsLFNDriveW()

◆ PathAppendAW()

◆ PathCleanupSpec()

◆ PathFileExistsAW()

◆ PathGetExtensionA()

◆ PathGetExtensionW()

◆ PathGetShortPathA()

◆ PathGetShortPathAW()

◆ PathGetShortPathW()

◆ PathIsAbsoluteW()

◆ PathIsExeA()

◆ PathIsExeAW()

◆ PathIsExeW()

◆ PathIsRootAW()

◆ PathMakeAbsoluteW()

◆ PathMakeUniqueNameA()

◆ PathMakeUniqueNameAW()

◆ PathMakeUniqueNameW()

◆ PathProcessCommandA()

◆ PathProcessCommandAW()

◆ PathProcessCommandW()

◆ PathQualifyA()

◆ PathQualifyAW()

◆ PathQualifyExW()

◆ PathQualifyW()

◆ PathRemoveFileSpecAW()

◆ PathResolveA()

◆ PathResolveAW()

◆ PathResolveW()

◆ PathSearchOnExtensionsW()

◆ PathYetAnotherMakeUniqueName()

◆ SHELL_RegisterShellFolders()

◆ SHGetFolderLocation()

◆ SHGetFolderPathA()

◆ SHGetFolderPathAndSubDirA()

◆ SHGetFolderPathAndSubDirW()