shellpath.c File Reference

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include "windef.h"
#include "winbase.h"
#include "winternl.h"
#include "winnls.h"
#include "winreg.h"
#include "wingdi.h"
#include "winuser.h"
#include "winioctl.h"
#include "ddk/mountmgr.h"
#include "shlobj.h"
#include "shtypes.h"
#include "shresdef.h"
#include "shell32_main.h"
#include "pidl.h"
#include "shlwapi.h"
#include "sddl.h"
#include "knownfolders.h"
#include "initguid.h"
#include "shobjidl.h"
#include "wine/debug.h"

Include dependency graph for shellpath.c:

Go to the source code of this file.

Classes
struct	IApplicationDestinationsImpl
struct	IApplicationDocumentListsImpl
struct	CSIDL_DATA
struct	knownfolder
struct	foldermanager

Macros
#define	COBJMACROS
#define	WINE_MOUNTMGR_EXTENSIONS
#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 ,   CSIDL_Type_ProgramData }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
BOOL WINAPI	PathAppendAW (LPVOID lpszPath1, LPCVOID lpszPath2)
LPVOID WINAPI	PathCombineAW (LPVOID szDest, LPCVOID lpszDir, LPCVOID lpszFile)
LPVOID WINAPI	PathAddBackslashAW (LPVOID lpszPath)
LPVOID WINAPI	PathBuildRootAW (LPVOID lpszPath, int drive)
LPVOID WINAPI	PathFindFileNameAW (LPCVOID lpszPath)
LPVOID WINAPI	PathFindExtensionAW (LPCVOID lpszPath)
static LPSTR	PathGetExtensionA (LPCSTR lpszPath)
static LPWSTR	PathGetExtensionW (LPCWSTR lpszPath)
LPVOID WINAPI	PathGetExtensionAW (LPCVOID lpszPath, DWORD void1, DWORD void2)
LPVOID WINAPI	PathGetArgsAW (LPVOID lpszPath)
int WINAPI	PathGetDriveNumberAW (LPVOID lpszPath)
BOOL WINAPI	PathRemoveFileSpecAW (LPVOID lpszPath)
void WINAPI	PathStripPathAW (LPVOID lpszPath)
BOOL WINAPI	PathStripToRootAW (LPVOID lpszPath)
void WINAPI	PathRemoveArgsAW (LPVOID lpszPath)
void WINAPI	PathRemoveExtensionAW (LPVOID lpszPath)
static void	PathGetShortPathA (LPSTR pszPath)
static void	PathGetShortPathW (LPWSTR pszPath)
VOID WINAPI	PathGetShortPathAW (LPVOID pszPath)
void WINAPI	PathRemoveBlanksAW (LPVOID str)
VOID WINAPI	PathQuoteSpacesAW (LPVOID lpszPath)
VOID WINAPI	PathUnquoteSpacesAW (LPVOID str)
int WINAPI	PathParseIconLocationAW (LPVOID lpszPath)
BOOL WINAPI	PathIsUNCAW (LPCVOID lpszPath)
BOOL WINAPI	PathIsRelativeAW (LPCVOID lpszPath)
BOOL WINAPI	PathIsRootAW (LPCVOID lpszPath)
static BOOL	PathIsExeA (LPCSTR lpszPath)
static BOOL	PathIsExeW (LPCWSTR lpszPath)
BOOL WINAPI	PathIsExeAW (LPCVOID path)
BOOL WINAPI	PathIsDirectoryAW (LPCVOID lpszPath)
BOOL WINAPI	PathFileExistsAW (LPCVOID lpszPath)
BOOL WINAPI	PathMatchSpecAW (LPVOID name, LPVOID mask)
BOOL WINAPI	PathIsSameRootAW (LPCVOID lpszPath1, LPCVOID lpszPath2)
BOOL WINAPI	IsLFNDriveA (LPCSTR lpszPath)
BOOL WINAPI	IsLFNDriveW (LPCWSTR 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)
BOOL WINAPI	PathFindOnPathAW (LPVOID sFile, LPCVOID *sOtherDirs)
int WINAPI	PathCleanupSpec (LPCWSTR lpszPathW, LPWSTR lpszFileW)
static BOOL	PathQualifyA (LPCSTR pszPath)
static BOOL	PathQualifyW (LPCWSTR pszPath)
BOOL WINAPI	PathQualifyAW (LPCVOID pszPath)
static BOOL	PathResolveA (char *path, const char **dirs, DWORD flags)
BOOL WINAPI	PathResolveW (WCHAR *path, const WCHAR **dirs, DWORD flags)
BOOL WINAPI	PathResolveAW (void *path, const void **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)
VOID WINAPI	PathSetDlgItemPathAW (HWND hDlg, int id, LPCVOID pszPath)
static IApplicationDestinationsImpl *	impl_from_IApplicationDestinations (IApplicationDestinations *iface)
static HRESULT WINAPI	ApplicationDestinations_QueryInterface (IApplicationDestinations *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	ApplicationDestinations_AddRef (IApplicationDestinations *iface)
static ULONG WINAPI	ApplicationDestinations_Release (IApplicationDestinations *iface)
static HRESULT WINAPI	ApplicationDestinations_SetAppID (IApplicationDestinations *iface, const WCHAR *appid)
static HRESULT WINAPI	ApplicationDestinations_RemoveDestination (IApplicationDestinations *iface, IUnknown *punk)
static HRESULT WINAPI	ApplicationDestinations_RemoveAllDestinations (IApplicationDestinations *iface)
HRESULT WINAPI	ApplicationDestinations_Constructor (IUnknown *outer, REFIID riid, LPVOID *ppv)
static IApplicationDocumentListsImpl *	impl_from_IApplicationDocumentLists (IApplicationDocumentLists *iface)
static HRESULT WINAPI	ApplicationDocumentLists_QueryInterface (IApplicationDocumentLists *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	ApplicationDocumentLists_AddRef (IApplicationDocumentLists *iface)
static ULONG WINAPI	ApplicationDocumentLists_Release (IApplicationDocumentLists *iface)
static HRESULT WINAPI	ApplicationDocumentLists_SetAppID (IApplicationDocumentLists *iface, const WCHAR *appid)
static HRESULT WINAPI	ApplicationDocumentLists_GetList (IApplicationDocumentLists *iface, APPDOCLISTTYPE list_type, UINT item_count, REFIID riid, void **obj)
HRESULT WINAPI	ApplicationDocumentLists_Constructor (IUnknown *outer, REFIID riid, LPVOID *ppv)
static int	csidl_from_id (const KNOWNFOLDERID *id)
static HRESULT	_SHExpandEnvironmentStrings (LPCWSTR szSrc, LPWSTR szDest)
static HRESULT	_SHGetUserShellFolderPath (HKEY rootKey, LPCWSTR userPrefix, LPCWSTR value, LPWSTR path)
static void	append_relative_path (BYTE folder, WCHAR *pszPath)
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)
static BOOL WINAPI	init_xdg_dirs (INIT_ONCE *once, void *param, void **context)
static char *	get_xdg_path (const char *var)
static BOOL	link_folder (HANDLE mgr, const UNICODE_STRING *path, const char *link)
static void	create_link (const WCHAR *path, const char *xdg_name, const char *default_name)
static void	_SHCreateSymbolicLink (int nFolder, const WCHAR *path)
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)
static HRESULT	create_extra_folders (void)
static HRESULT	set_folder_attributes (void)
BOOL WINAPI	SHGetSpecialFolderPathA (HWND hwndOwner, LPSTR szPath, int nFolder, BOOL bCreate)
BOOL WINAPI	SHGetSpecialFolderPathW (HWND hwndOwner, LPWSTR szPath, int nFolder, BOOL bCreate)
BOOL WINAPI	SHGetSpecialFolderPathAW (HWND hwndOwner, LPVOID 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)
HRESULT WINAPI	SHGetKnownFolderPath (REFKNOWNFOLDERID rfid, DWORD flags, HANDLE token, WCHAR **ret_path)
HRESULT WINAPI	SHGetFolderPathEx (REFKNOWNFOLDERID rfid, DWORD flags, HANDLE token, LPWSTR path, DWORD len)
static HRESULT	get_known_folder_registry_path (REFKNOWNFOLDERID rfid, LPWSTR lpStringGuid, LPWSTR *lpPath)
static HRESULT	get_known_folder_wstr (const WCHAR *regpath, const WCHAR *value, WCHAR **out)
static HRESULT	get_known_folder_dword (const WCHAR *registryPath, const WCHAR *value, DWORD *out)
static HRESULT	get_known_folder_redirection_place (REFKNOWNFOLDERID rfid, HKEY *rootKey)
static HRESULT	get_known_folder_path_by_id (REFKNOWNFOLDERID folderId, LPWSTR lpRegistryPath, DWORD dwFlags, LPWSTR *ppszPath)
static HRESULT	redirect_known_folder (REFKNOWNFOLDERID rfid, HWND hwnd, KF_REDIRECT_FLAGS flags, LPCWSTR pszTargetPath, UINT cFolders, KNOWNFOLDERID const *pExclusion, LPWSTR *ppszError)
static struct knownfolder *	impl_from_IKnownFolder (IKnownFolder *iface)
static ULONG WINAPI	knownfolder_AddRef (IKnownFolder *iface)
static ULONG WINAPI	knownfolder_Release (IKnownFolder *iface)
static HRESULT WINAPI	knownfolder_QueryInterface (IKnownFolder *iface, REFIID riid, void **ppv)
static HRESULT	knownfolder_set_id (struct knownfolder *knownfolder, const KNOWNFOLDERID *kfid)
static HRESULT WINAPI	knownfolder_GetId (IKnownFolder *iface, KNOWNFOLDERID *pkfid)
static HRESULT WINAPI	knownfolder_GetCategory (IKnownFolder *iface, KF_CATEGORY *pCategory)
static HRESULT WINAPI	knownfolder_GetShellItem (IKnownFolder *iface, DWORD flags, REFIID riid, void **ppv)
static HRESULT	get_known_folder_path (LPWSTR sFolderId, LPWSTR registryPath, LPWSTR *ppszPath)
static HRESULT WINAPI	knownfolder_GetPath (IKnownFolder *iface, DWORD dwFlags, LPWSTR *ppszPath)
static HRESULT WINAPI	knownfolder_SetPath (IKnownFolder *iface, DWORD dwFlags, LPCWSTR pszPath)
static HRESULT WINAPI	knownfolder_GetIDList (IKnownFolder *iface, DWORD flags, PIDLIST_ABSOLUTE *ppidl)
static HRESULT WINAPI	knownfolder_GetFolderType (IKnownFolder *iface, FOLDERTYPEID *pftid)
static HRESULT WINAPI	knownfolder_GetRedirectionCapabilities (IKnownFolder *iface, KF_REDIRECTION_CAPABILITIES *pCapabilities)
static HRESULT WINAPI	knownfolder_GetFolderDefinition (IKnownFolder *iface, KNOWNFOLDER_DEFINITION *pKFD)
static HRESULT	knownfolder_create (struct knownfolder **knownfolder)
static struct foldermanager *	impl_from_IKnownFolderManager (IKnownFolderManager *iface)
static ULONG WINAPI	foldermanager_AddRef (IKnownFolderManager *iface)
static ULONG WINAPI	foldermanager_Release (IKnownFolderManager *iface)
static HRESULT WINAPI	foldermanager_QueryInterface (IKnownFolderManager *iface, REFIID riid, void **ppv)
static HRESULT WINAPI	foldermanager_FolderIdFromCsidl (IKnownFolderManager *iface, int nCsidl, KNOWNFOLDERID *pfid)
static HRESULT WINAPI	foldermanager_FolderIdToCsidl (IKnownFolderManager *iface, REFKNOWNFOLDERID rfid, int *pnCsidl)
static HRESULT WINAPI	foldermanager_GetFolderIds (IKnownFolderManager *iface, KNOWNFOLDERID **ppKFId, UINT *pCount)
static BOOL	is_knownfolder (struct foldermanager *fm, const KNOWNFOLDERID *id)
static HRESULT WINAPI	foldermanager_GetFolder (IKnownFolderManager *iface, REFKNOWNFOLDERID rfid, IKnownFolder **ppkf)
static HRESULT WINAPI	foldermanager_GetFolderByName (IKnownFolderManager *iface, LPCWSTR pszCanonicalName, IKnownFolder **ppkf)
static HRESULT	register_folder (const KNOWNFOLDERID *rfid, const KNOWNFOLDER_DEFINITION *pKFD)
static HRESULT WINAPI	foldermanager_RegisterFolder (IKnownFolderManager *iface, REFKNOWNFOLDERID rfid, KNOWNFOLDER_DEFINITION const *pKFD)
static HRESULT WINAPI	foldermanager_UnregisterFolder (IKnownFolderManager *iface, REFKNOWNFOLDERID rfid)
static HRESULT WINAPI	foldermanager_FindFolderFromPath (IKnownFolderManager *iface, LPCWSTR pszPath, FFFP_MODE mode, IKnownFolder **ppkf)
static HRESULT WINAPI	foldermanager_FindFolderFromIDList (IKnownFolderManager *iface, PCIDLIST_ABSOLUTE pidl, IKnownFolder **ppkf)
static HRESULT WINAPI	foldermanager_Redirect (IKnownFolderManager *iface, REFKNOWNFOLDERID rfid, HWND hwnd, KF_REDIRECT_FLAGS flags, LPCWSTR pszTargetPath, UINT cFolders, KNOWNFOLDERID const *pExclusion, LPWSTR *ppszError)
static HRESULT	foldermanager_create (void **ppv)
HRESULT WINAPI	KnownFolderManager_Constructor (IUnknown *punk, REFIID riid, void **ppv)
HRESULT WINAPI	SHGetKnownFolderIDList (REFKNOWNFOLDERID rfid, DWORD flags, HANDLE token, PIDLIST_ABSOLUTE *pidl)
HRESULT WINAPI	SHGetKnownFolderItem (REFKNOWNFOLDERID rfid, KNOWN_FOLDER_FLAG flags, HANDLE hToken, REFIID riid, void **ppv)
static void	register_system_knownfolders (void)
HRESULT	SHELL_RegisterShellFolders (void)

Variables
static const BOOL	is_win64 = sizeof(void *) > sizeof(int)
static const IApplicationDestinationsVtbl	ApplicationDestinationsVtbl
static const IApplicationDocumentListsVtbl	ApplicationDocumentListsVtbl
static const CSIDL_DATA	CSIDL_Data []
static char *	xdg_config
static DWORD	xdg_config_len
static const struct IKnownFolderVtbl	knownfolder_vtbl
static const struct IKnownFolderManagerVtbl	foldermanager_vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 59 of file shellpath.c.

CSIDL_APPDATA_LOCALLOW

#define CSIDL_APPDATA_LOCALLOW   0x004e

Definition at line 1572 of file shellpath.c.

CSIDL_CONTACTS

#define CSIDL_CONTACTS   0x0043

Definition at line 1569 of file shellpath.c.

CSIDL_DOWNLOADS

#define CSIDL_DOWNLOADS   0x0047

Definition at line 1570 of file shellpath.c.

CSIDL_LINKS

#define CSIDL_LINKS   0x004d

Definition at line 1571 of file shellpath.c.

CSIDL_SAVED_GAMES

#define CSIDL_SAVED_GAMES   0x0062

Definition at line 1573 of file shellpath.c.

CSIDL_SEARCHES

#define CSIDL_SEARCHES   0x0063

Definition at line 1574 of file shellpath.c.

WINE_MOUNTMGR_EXTENSIONS

#define WINE_MOUNTMGR_EXTENSIONS

Definition at line 74 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
CSIDL_Type_ProgramData

Definition at line 1557 of file shellpath.c.

                         {
    CSIDL_Type_User,
    CSIDL_Type_AllUsers,
    CSIDL_Type_CurrVer,
    CSIDL_Type_Disallowed,
    CSIDL_Type_NonExistent,
    CSIDL_Type_WindowsPath,
    CSIDL_Type_SystemPath,
    CSIDL_Type_SystemX86Path,
    CSIDL_Type_ProgramData
} CSIDL_Type;

Function Documentation

_GetUserSidStringFromToken()

static LPWSTR _GetUserSidStringFromToken ( HANDLE  Token )

static

Definition at line 3238 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 = malloc(InfoSize);
        if (UserInfo == NULL)
            return NULL;
        if (! GetTokenInformation(Token, TokenUser, UserInfo, InfoSize,
                                  &InfoSize))
        {
            free(UserInfo);
            return NULL;
        }
    }
 
    if (! ConvertSidToStringSidW(UserInfo->User.Sid, &SidStr))
        SidStr = NULL;
 
    if (UserInfo != (PTOKEN_USER) InfoBuffer)
        free(UserInfo);
 
    return SidStr;
}

Referenced by _SHGetUserProfilePath().

_SHCreateSymbolicLink()

static void _SHCreateSymbolicLink ( int  nFolder, const WCHAR *  path  )

static

Definition at line 3766 of file shellpath.c.

{
    DWORD folder = nFolder & CSIDL_FOLDER_MASK;
 
    switch (folder) {
        case CSIDL_PERSONAL:
            create_link( path, "XDG_DOCUMENTS_DIR", "$HOME/Documents" );
            break;
        case CSIDL_DESKTOPDIRECTORY:
            create_link( path, "XDG_DESKTOP_DIR", "$HOME/Desktop" );
            break;
        case CSIDL_MYPICTURES:
            create_link( path, "XDG_PICTURES_DIR", "$HOME/Pictures" );
            break;
        case CSIDL_MYVIDEO:
            create_link( path, "XDG_VIDEOS_DIR", "$HOME/Movies" );
            break;
        case CSIDL_MYMUSIC:
            create_link( path, "XDG_MUSIC_DIR", "$HOME/Music" );
            break;
        case CSIDL_DOWNLOADS:
            create_link( path, "XDG_DOWNLOAD_DIR", "$HOME/Downloads" );
            break;
        case CSIDL_TEMPLATES:
            create_link( path, "XDG_TEMPLATES_DIR", "$HOME/Templates" );
            break;
    }
}

Referenced by SHGetFolderPathAndSubDirW().

_SHExpandEnvironmentStrings()

static HRESULT _SHExpandEnvironmentStrings ( LPCWSTR  szSrc, LPWSTR  szDest  )

static

Definition at line 3469 of file shellpath.c.

{
    HRESULT hr;
    WCHAR szTemp[MAX_PATH], szProfilesPrefix[MAX_PATH] = { 0 };
    HKEY key = NULL;
 
    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] != '%')
    {
        lstrcpyW(szDest, szSrc);
        hr = S_OK;
        goto end;
    }
 
    /* 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);
        lstrcpyW( def_val + 3, L"users" );
 
        hr = _SHGetProfilesValue(key, L"ProfilesDirectory", szProfilesPrefix, def_val );
    }
 
    *szDest = 0;
    lstrcpyW(szTemp, szSrc);
    while (SUCCEEDED(hr) && szTemp[0] == '%')
    {
        if (!wcsnicmp(szTemp, L"%ALLUSERSPROFILE%", lstrlenW(L"%ALLUSERSPROFILE%")))
        {
#ifndef __REACTOS__
            WCHAR szAllUsers[MAX_PATH], def_val[MAX_PATH];
 
            GetSystemDirectoryW(def_val, MAX_PATH);
            lstrcpyW( def_val + 3, L"users\\Public" );
 
            hr = _SHGetProfilesValue(key, L"Public", szAllUsers, def_val);
            PathAppendW(szDest, szAllUsers);
#else
            DWORD cchSize = cchDest;
            if (!GetAllUsersProfileDirectoryW(szDest, &cchSize))
                goto fallback_expand;
#endif
            PathAppendW(szDest, szTemp + lstrlenW(L"%ALLUSERSPROFILE%"));
        }
        else if (!wcsnicmp(szTemp, L"%PUBLIC%", lstrlenW(L"%PUBLIC%")))
        {
            WCHAR szAllUsers[MAX_PATH], def_val[MAX_PATH];
 
            GetSystemDirectoryW(def_val, MAX_PATH);
            lstrcpyW( def_val + 3, L"users\\Public" );
 
            hr = _SHGetProfilesValue(key, L"Public", szAllUsers, def_val);
            PathAppendW(szDest, szAllUsers);
            PathAppendW(szDest, szTemp + lstrlenW(L"%PUBLIC%"));
        }
        else if (!wcsnicmp(szTemp, L"%ProgramData%", lstrlenW(L"%ProgramData%")))
        {
            WCHAR szProgramData[MAX_PATH], def_val[MAX_PATH];
            HKEY shellFolderKey;
            DWORD dwType, dwPathLen = sizeof(def_val);
            BOOL in_registry = FALSE;
 
            if (!RegCreateKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", &shellFolderKey))
            {
                if (!RegQueryValueExW(shellFolderKey, L"Common AppData", NULL, &dwType,
                    (LPBYTE)def_val, &dwPathLen) && (dwType == REG_EXPAND_SZ || dwType == REG_SZ))
                    in_registry = TRUE;
 
                RegCloseKey(shellFolderKey);
            }
 
            if (!in_registry)
            {
                GetSystemDirectoryW(def_val, MAX_PATH);
                lstrcpyW( def_val + 3, L"ProgramData" );
            }
 
            hr = _SHGetProfilesValue(key, L"ProgramData", szProgramData, def_val);
            PathAppendW(szDest, szProgramData);
            PathAppendW(szDest, szTemp + lstrlenW(L"%ProgramData%"));
        }
        else if (!wcsnicmp(szTemp, L"%USERPROFILE%", lstrlenW(L"%USERPROFILE%")))
        {
#ifndef __REACTOS__
            WCHAR userName[MAX_PATH];
            DWORD userLen = MAX_PATH;
 
            lstrcpyW(szDest, szProfilesPrefix);
            GetUserNameW(userName, &userLen);
            PathAppendW(szDest, userName);
#else
            DWORD cchSize = cchDest;
            if (!SHELL_GetUserProfileDirectoryW(hToken, szDest, &cchSize))
                goto fallback_expand;
#endif
            PathAppendW(szDest, szTemp + lstrlenW(L"%USERPROFILE%"));
        }
        else if (!wcsnicmp(szTemp, L"%SystemDrive%", lstrlenW(L"%SystemDrive%")))
        {
#ifndef __REACTOS__
            GetSystemDirectoryW(szDest, MAX_PATH);
#else
            if (!GetSystemDirectoryW(szDest, cchDest))
                goto fallback_expand;
#endif
            lstrcpyW(szDest + 3, szTemp + lstrlenW(L"%SystemDrive%") + 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 (!wcscmp( szTemp, szDest )) break;  /* nothing expanded */
        }
        if (SUCCEEDED(hr)) lstrcpyW(szTemp, szDest);
    }
end:
#ifndef __REACTOS__
    if (key)
        RegCloseKey(key);
#endif
    TRACE("returning 0x%08lx (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 3366 of file shellpath.c.

{
    HRESULT hr;
 
    TRACE("0x%08lx,0x%02x,%p\n", dwFlags, folder, pszPath);
 
    if (folder >= ARRAY_SIZE(CSIDL_Data))
        return E_INVALIDARG;
    if (CSIDL_Data[folder].type != CSIDL_Type_AllUsers && CSIDL_Data[folder].type != CSIDL_Type_ProgramData)
        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].value, pszPath);
        if (FAILED(hr))
#ifndef __REACTOS__
            hr = _SHGetDefaultValue(folder, pszPath);
#else
            hr = _SHGetDefaultValue(NULL, folder, pszPath);
#endif
    }
    TRACE("returning 0x%08lx (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 3169 of file shellpath.c.

{
    HRESULT hr;
 
    TRACE("0x%08lx,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, L"Software\\Microsoft\\Windows\\CurrentVersion", &hKey))
            hr = E_FAIL;
        else
        {
            DWORD dwType, dwPathLen = MAX_PATH * sizeof(WCHAR);
 
            if (RegQueryValueExW(hKey, CSIDL_Data[folder].value, 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].value, 0, dwType,
                                   (LPBYTE)pszPath, (lstrlenW(pszPath)+1)*sizeof(WCHAR));
                }
            }
            else
            {
                pszPath[dwPathLen / sizeof(WCHAR)] = '\0';
                hr = S_OK;
            }
            RegCloseKey(hKey);
        }
    }
    TRACE("returning 0x%08lx (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 3085 of file shellpath.c.

{
    HRESULT hr;
 
    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;
        }
    }
 
    if (!CSIDL_Data[folder].parent)
    {
        /* hit the root, sub in env var */
        switch (CSIDL_Data[folder].type)
        {
            case CSIDL_Type_User:
                lstrcpyW(pszPath, L"%USERPROFILE%");
                break;
            case CSIDL_Type_AllUsers:
                lstrcpyW(pszPath, L"%PUBLIC%");
                break;
            case CSIDL_Type_ProgramData:
                lstrcpyW(pszPath, L"%ProgramData%");
                break;
            case CSIDL_Type_CurrVer:
                lstrcpyW(pszPath, L"%SystemDrive%");
                break;
            default:
                ; /* no corresponding env. var, do nothing */
        }
        hr = S_OK;
    }else{
        /* prepend with parent */
#ifdef __REACTOS__
        hr = _SHGetDefaultValue(NULL, csidl_from_id(CSIDL_Data[folder].parent), pszPath);
#else
        hr = _SHGetDefaultValue(csidl_from_id(CSIDL_Data[folder].parent), pszPath);
#endif
    }
 
    if (SUCCEEDED(hr))
        append_relative_path(folder, pszPath);
 
    TRACE("returning 0x%08lx\n", hr);
    return hr;
}

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

_SHGetProfilesValue()

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

static

Definition at line 3420 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,
                              (lstrlenW(szValue) + 1) * sizeof(WCHAR));
        if (lRet)
            hr = HRESULT_FROM_WIN32(lRet);
        else
            hr = S_OK;
    }
    TRACE("returning 0x%08lx (output value is %s)\n", hr, debugstr_w(szValue));
    return hr;
}

Referenced by _SHExpandEnvironmentStrings().

_SHGetUserProfilePath()

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

static

Definition at line 3279 of file shellpath.c.

{
    const WCHAR *szValueName;
    WCHAR buffer[40];
    HRESULT hr;
 
    TRACE("%p,0x%08lx,0x%02x,%p\n", hToken, dwFlags, folder, pszPath);
 
    if (folder >= ARRAY_SIZE(CSIDL_Data))
        return E_INVALIDARG;
    if (CSIDL_Data[folder].type != CSIDL_Type_User)
        return E_INVALIDARG;
    if (!pszPath)
        return E_INVALIDARG;
 
    if (dwFlags & SHGFP_TYPE_DEFAULT)
    {
#ifndef __REACTOS__
        if (hToken != NULL && hToken != (HANDLE)-1)
        {
            FIXME("unsupported for user other than current or default\n");
            return E_FAIL;
        }
        hr = _SHGetDefaultValue(folder, pszPath);
#else
        hr = _SHGetDefaultValue(hToken, folder, pszPath);
#endif
    }
    else
    {
        static const WCHAR DefaultW[] = L".Default";
        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].value;
        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%08lx (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 2976 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)
    {
        lstrcpyW(shellFolderPath, userPrefix);
        PathAddBackslashW(shellFolderPath);
        lstrcatW(shellFolderPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders");
        pShellFolderPath = shellFolderPath;
        lstrcpyW(userShellFolderPath, userPrefix);
        PathAddBackslashW(userShellFolderPath);
        lstrcatW(userShellFolderPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders");
        pUserShellFolderPath = userShellFolderPath;
    }
    else
    {
        pUserShellFolderPath = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders";
        pShellFolderPath = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders";
    }
 
    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,
         (lstrlenW(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%08lx\n", hr);
    return hr;
}

Referenced by _SHGetAllUsersProfilePath(), and _SHGetUserProfilePath().

_SHOpenProfilesKey()

static HRESULT _SHOpenProfilesKey ( PHKEY  pKey )

static

Definition at line 3405 of file shellpath.c.

{
    LONG lRet;
    DWORD disp;
 
    lRet = RegCreateKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList", 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 4232 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,
                            L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders",
                            L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders",
                            folders, ARRAY_SIZE(folders));
    TRACE("returning 0x%08lx\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 4078 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]].value;
        if (!szValueName && CSIDL_Data[folders[i]].type == CSIDL_Type_User)
        {
            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))
        {
            *path = '\0';
            if (CSIDL_Data[folders[i]].type == CSIDL_Type_User)
                _SHGetUserProfilePath(hToken, SHGFP_TYPE_DEFAULT, folders[i],
                 path);
            else if (CSIDL_Data[folders[i]].type == CSIDL_Type_AllUsers ||
                     CSIDL_Data[folders[i]].type == CSIDL_Type_ProgramData)
                _SHGetAllUsersProfilePath(SHGFP_TYPE_DEFAULT, folders[i], path);
            else if (CSIDL_Data[folders[i]].type == CSIDL_Type_WindowsPath)
            {
                GetWindowsDirectoryW(path, MAX_PATH);
                append_relative_path(folders[i], path);
            }
            else
                hr = E_FAIL;
            if (*path)
            {
                ret = RegSetValueExW(hUserKey, szValueName, 0, REG_EXPAND_SZ,
                 (LPBYTE)path, (lstrlenW(path) + 1) * sizeof(WCHAR));
                if (ret)
                    hr = HRESULT_FROM_WIN32(ret);
                else
                {
                    hr = SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
                     hToken, SHGFP_TYPE_DEFAULT, path);
                    ret = RegSetValueExW(hKey, szValueName, 0, REG_SZ,
                     (LPBYTE)path, (lstrlenW(path) + 1) * sizeof(WCHAR));
                    if (ret)
                        hr = HRESULT_FROM_WIN32(ret);
                }
            }
        }
        else
        {
            /* create the default dir, which may be different from the path
             * stored in the registry. */
            SHGetFolderPathW(NULL, folders[i] | CSIDL_FLAG_CREATE,
             hToken, SHGFP_TYPE_DEFAULT, path);
        }
    }
    if (hUserKey)
        RegCloseKey(hUserKey);
    if (hKey)
        RegCloseKey(hKey);
 
    TRACE("returning 0x%08lx\n", hr);
    return hr;
}

Referenced by _SHRegisterCommonShellFolders(), and _SHRegisterUserShellFolders().

_SHRegisterUserShellFolders()

static HRESULT _SHRegisterUserShellFolders ( BOOL  bDefault )

static

Definition at line 4167 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,
     CSIDL_CONTACTS,
     CSIDL_DOWNLOADS,
     CSIDL_LINKS,
     CSIDL_APPDATA_LOCALLOW,
     CSIDL_SAVED_GAMES,
     CSIDL_SEARCHES
    };
    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;
        lstrcpyW(userShellFolderPath, L".Default");
        PathAddBackslashW(userShellFolderPath);
        lstrcatW(userShellFolderPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders");
        pUserShellFolderPath = userShellFolderPath;
        lstrcpyW(shellFolderPath, L".Default");
        PathAddBackslashW(shellFolderPath);
        lstrcatW(shellFolderPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders");
        pShellFolderPath = shellFolderPath;
    }
    else
    {
        hToken = NULL;
        hRootKey = HKEY_CURRENT_USER;
        pUserShellFolderPath = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders";
        pShellFolderPath = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders";
    }
 
    hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath,
     pShellFolderPath, folders, ARRAY_SIZE(folders));
    TRACE("returning 0x%08lx\n", hr);
    return hr;
}

Referenced by SHELL_RegisterShellFolders().

append_relative_path()

static void append_relative_path ( BYTE  folder, WCHAR *  pszPath  )

static

Definition at line 3059 of file shellpath.c.

{
    if (CSIDL_Data[folder].path)
    {
        PathAddBackslashW(pszPath);
        lstrcatW(pszPath, CSIDL_Data[folder].path);
    }
    else if (CSIDL_Data[folder].def_path)
    {
        PathAddBackslashW(pszPath);
        lstrcatW(pszPath, CSIDL_Data[folder].def_path);
    }
}

Referenced by _SHGetDefaultValue(), _SHRegisterFolders(), and SHGetFolderPathAndSubDirW().

ApplicationDestinations_AddRef()

static ULONG WINAPI ApplicationDestinations_AddRef ( IApplicationDestinations *  iface )

static

Definition at line 1612 of file shellpath.c.

{
    IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p), new refcount=%li\n", This, ref);
 
    return ref;
}

ApplicationDestinations_Constructor()

HRESULT WINAPI ApplicationDestinations_Constructor	(	IUnknown *	outer,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 1672 of file shellpath.c.

{
    IApplicationDestinationsImpl *This;
    HRESULT hr;
 
    TRACE("(%p, %s, %p)\n", outer, debugstr_guid(riid), ppv);
 
    if (outer)
        return CLASS_E_NOAGGREGATION;
 
    if (!(This = SHAlloc(sizeof(*This))))
        return E_OUTOFMEMORY;
 
    This->IApplicationDestinations_iface.lpVtbl = &ApplicationDestinationsVtbl;
    This->ref = 0;
 
    hr = IUnknown_QueryInterface(&This->IApplicationDestinations_iface, riid, ppv);
    if (FAILED(hr))
        SHFree(This);
 
    return hr;
}

ApplicationDestinations_QueryInterface()

static HRESULT WINAPI ApplicationDestinations_QueryInterface ( IApplicationDestinations *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 1587 of file shellpath.c.

{
    IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface);
 
    TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppv);
 
    if (ppv == NULL)
        return E_POINTER;
 
    if (IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IApplicationDestinations, riid))
    {
        *ppv = &This->IApplicationDestinations_iface;
        IUnknown_AddRef((IUnknown*)*ppv);
 
        TRACE("Returning IApplicationDestinations: %p\n", *ppv);
        return S_OK;
    }
 
    *ppv = NULL;
    FIXME("(%p)->(%s, %p) interface not supported.\n", This, debugstr_guid(riid), ppv);
 
    return E_NOINTERFACE;
}

ApplicationDestinations_Release()

static ULONG WINAPI ApplicationDestinations_Release ( IApplicationDestinations *  iface )

static

Definition at line 1622 of file shellpath.c.

{
    IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p), new refcount=%li\n", This, ref);
 
    if (ref == 0)
        free(This);
 
    return ref;
}

ApplicationDestinations_RemoveAllDestinations()

static HRESULT WINAPI ApplicationDestinations_RemoveAllDestinations ( IApplicationDestinations *  iface )

static

Definition at line 1653 of file shellpath.c.

{
    IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface);
 
    FIXME("(%p) stub!\n", This);
 
    return E_NOTIMPL;
}

ApplicationDestinations_RemoveDestination()

static HRESULT WINAPI ApplicationDestinations_RemoveDestination ( IApplicationDestinations *  iface, IUnknown *  punk  )

static

Definition at line 1644 of file shellpath.c.

{
    IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface);
 
    FIXME("(%p, %p) stub!\n", This, punk);
 
    return E_NOTIMPL;
}

ApplicationDestinations_SetAppID()

static HRESULT WINAPI ApplicationDestinations_SetAppID ( IApplicationDestinations *  iface, const WCHAR *  appid  )

static

Definition at line 1635 of file shellpath.c.

{
    IApplicationDestinationsImpl *This = impl_from_IApplicationDestinations(iface);
 
    FIXME("(%p, %s) stub!\n", This, debugstr_w(appid));
 
    return E_NOTIMPL;
}

ApplicationDocumentLists_AddRef()

static ULONG WINAPI ApplicationDocumentLists_AddRef ( IApplicationDocumentLists *  iface )

static

Definition at line 1731 of file shellpath.c.

{
    IApplicationDocumentListsImpl *This = impl_from_IApplicationDocumentLists(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p), new refcount=%li\n", This, ref);
 
    return ref;
}

ApplicationDocumentLists_Constructor()

HRESULT WINAPI ApplicationDocumentLists_Constructor	(	IUnknown *	outer,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 1784 of file shellpath.c.

{
    IApplicationDocumentListsImpl *This;
    HRESULT hr;
 
    TRACE("(%p, %s, %p)\n", outer, debugstr_guid(riid), ppv);
 
    if (outer)
        return CLASS_E_NOAGGREGATION;
 
    if (!(This = SHAlloc(sizeof(*This))))
        return E_OUTOFMEMORY;
 
    This->IApplicationDocumentLists_iface.lpVtbl = &ApplicationDocumentListsVtbl;
    This->ref = 0;
 
    hr = IUnknown_QueryInterface(&This->IApplicationDocumentLists_iface, riid, ppv);
    if (FAILED(hr))
        SHFree(This);
 
    return hr;
}

ApplicationDocumentLists_GetList()

static HRESULT WINAPI ApplicationDocumentLists_GetList ( IApplicationDocumentLists *  iface, APPDOCLISTTYPE  list_type, UINT  item_count, REFIID  riid, void **  obj  )

static

Definition at line 1764 of file shellpath.c.

{
    IApplicationDocumentListsImpl *This = impl_from_IApplicationDocumentLists(iface);
 
    FIXME("(%p, %u, %u, %s, %p): stub\n", This, list_type, item_count, debugstr_guid(riid), obj);
 
    return E_NOTIMPL;
}

ApplicationDocumentLists_QueryInterface()

static HRESULT WINAPI ApplicationDocumentLists_QueryInterface ( IApplicationDocumentLists *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 1706 of file shellpath.c.

{
    IApplicationDocumentListsImpl *This = impl_from_IApplicationDocumentLists(iface);
 
    TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppv);
 
    if (ppv == NULL)
        return E_POINTER;
 
    if (IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IApplicationDocumentLists, riid))
    {
        *ppv = &This->IApplicationDocumentLists_iface;
        IUnknown_AddRef((IUnknown*)*ppv);
 
        TRACE("Returning IApplicationDocumentLists: %p\n", *ppv);
        return S_OK;
    }
 
    *ppv = NULL;
    FIXME("(%p)->(%s, %p) interface not supported.\n", This, debugstr_guid(riid), ppv);
 
    return E_NOINTERFACE;
}

ApplicationDocumentLists_Release()

static ULONG WINAPI ApplicationDocumentLists_Release ( IApplicationDocumentLists *  iface )

static

Definition at line 1741 of file shellpath.c.

{
    IApplicationDocumentListsImpl *This = impl_from_IApplicationDocumentLists(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p), new refcount=%li\n", This, ref);
 
    if (ref == 0)
        free(This);
 
    return ref;
}

ApplicationDocumentLists_SetAppID()

static HRESULT WINAPI ApplicationDocumentLists_SetAppID ( IApplicationDocumentLists *  iface, const WCHAR *  appid  )

static

Definition at line 1754 of file shellpath.c.

{
    IApplicationDocumentListsImpl *This = impl_from_IApplicationDocumentLists(iface);
 
    FIXME("(%p, %s) stub!\n", This, debugstr_w(appid));
 
    return E_NOTIMPL;
}

create_extra_folders()

static HRESULT create_extra_folders ( void  )

static

Definition at line 4265 of file shellpath.c.

{
    WCHAR path[MAX_PATH+5];
    HRESULT hr;
    HKEY hkey;
    DWORD type, size, ret;
 
    ret = RegCreateKeyW( HKEY_CURRENT_USER, L"Environment", &hkey );
    if (ret) return HRESULT_FROM_WIN32( ret );
 
    hr = SHGetFolderPathAndSubDirW( 0, CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE, NULL,
                                    SHGFP_TYPE_DEFAULT, L"Temp", path );
    if (SUCCEEDED(hr))
    {
        size = sizeof(path);
        if (RegQueryValueExW( hkey, L"TEMP", NULL, &type, (LPBYTE)path, &size ))
            RegSetValueExW( hkey, L"TEMP", 0, REG_SZ, (LPBYTE)path, (lstrlenW(path) + 1) * sizeof(WCHAR) );
        size = sizeof(path);
        if (RegQueryValueExW( hkey, L"TMP", NULL, &type, (LPBYTE)path, &size ))
            RegSetValueExW( hkey, L"TMP", 0, REG_SZ, (LPBYTE)path, (lstrlenW(path) + 1) * sizeof(WCHAR) );
    }
    RegCloseKey( hkey );
 
    if (SUCCEEDED(hr))
    {
        hr = SHGetFolderPathAndSubDirW( 0, CSIDL_COMMON_APPDATA | CSIDL_FLAG_CREATE, NULL,
                                        SHGFP_TYPE_DEFAULT, L"Microsoft", path );
    }
    if (SUCCEEDED(hr))
    {
        hr = SHGetFolderPathAndSubDirW(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL,
                                       SHGFP_TYPE_DEFAULT, L"Microsoft\\Windows\\Themes", path);
    }
    if (SUCCEEDED(hr))
    {
        hr = SHGetFolderPathAndSubDirW(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL,
                                       SHGFP_TYPE_DEFAULT, L"Microsoft\\Windows\\AccountPictures", path);
    }
    if (SUCCEEDED(hr))
    {
        hr = SHGetFolderPathAndSubDirW(0, CSIDL_MYPICTURES | CSIDL_FLAG_CREATE, NULL,
                                       SHGFP_TYPE_DEFAULT, L"Screenshots", path);
    }
    return hr;
}

Referenced by SHELL_RegisterShellFolders().

create_link()

static void create_link ( const WCHAR *  path, const char *  xdg_name, const char *  default_name  )

static

Definition at line 3728 of file shellpath.c.

{
    UNICODE_STRING nt_name;
    char *target = NULL;
    HANDLE mgr;
 
    if ((mgr = CreateFileW( MOUNTMGR_DOS_DEVICE_NAME, GENERIC_READ | GENERIC_WRITE,
                            FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
                            0, 0 )) == INVALID_HANDLE_VALUE)
    {
        FIXME( "failed to connect to mount manager\n" );
        return;
    }
 
    nt_name.Buffer = NULL;
    if (!RtlDosPathNameToNtPathName_U( path, &nt_name, NULL, NULL )) goto done;
 
    if ((target = get_xdg_path( xdg_name )))
    {
        if (link_folder( mgr, &nt_name, target )) goto done;
    }
    link_folder( mgr, &nt_name, default_name );
 
done:
    RtlFreeUnicodeString( &nt_name );
    free( target );
    CloseHandle( mgr );
}

Referenced by _SHCreateSymbolicLink().

csidl_from_id()

static int csidl_from_id ( const KNOWNFOLDERID *  id )

static

Definition at line 2913 of file shellpath.c.

{
    int i;
    for (i = 0; i < ARRAY_SIZE(CSIDL_Data); i++)
        if (IsEqualGUID( CSIDL_Data[i].id, id )) return i;
    return -1;
}

Referenced by _SHGetDefaultValue(), foldermanager_FolderIdToCsidl(), and SHGetKnownFolderPath().

foldermanager_AddRef()

static ULONG WINAPI foldermanager_AddRef ( IKnownFolderManager *  iface )

static

Definition at line 5291 of file shellpath.c.

{
    struct foldermanager *foldermanager = impl_from_IKnownFolderManager( iface );
    return InterlockedIncrement( &foldermanager->refs );
}

foldermanager_create()

static HRESULT foldermanager_create ( void **  ppv )

static

Definition at line 5612 of file shellpath.c.

{
    UINT i, j;
    struct foldermanager *fm;
 
    fm = malloc( sizeof(*fm) );
    if (!fm) return E_OUTOFMEMORY;
 
    fm->IKnownFolderManager_iface.lpVtbl = &foldermanager_vtbl;
    fm->refs = 1;
    fm->num_ids = 0;
 
    for (i = 0; i < ARRAY_SIZE(CSIDL_Data); i++)
    {
        if (!IsEqualGUID( CSIDL_Data[i].id, &GUID_NULL )) fm->num_ids++;
    }
    fm->ids = malloc( fm->num_ids * sizeof(KNOWNFOLDERID) );
    if (!fm->ids)
    {
        free( fm );
        return E_OUTOFMEMORY;
    }
    for (i = j = 0; i < ARRAY_SIZE(CSIDL_Data); i++)
    {
        if (!IsEqualGUID( CSIDL_Data[i].id, &GUID_NULL ))
        {
            fm->ids[j] = *CSIDL_Data[i].id;
            j++;
        }
    }
    TRACE("found %u known folders\n", fm->num_ids);
    *ppv = &fm->IKnownFolderManager_iface;
 
    TRACE("returning iface %p\n", *ppv);
    return S_OK;
}

Referenced by KnownFolderManager_Constructor().

foldermanager_FindFolderFromIDList()

static HRESULT WINAPI foldermanager_FindFolderFromIDList ( IKnownFolderManager *  iface, PCIDLIST_ABSOLUTE  pidl, IKnownFolder **  ppkf  )

static

Definition at line 5573 of file shellpath.c.

{
    FIXME("%p, %p\n", pidl, ppkf);
    return E_NOTIMPL;
}

foldermanager_FindFolderFromPath()

static HRESULT WINAPI foldermanager_FindFolderFromPath ( IKnownFolderManager *  iface, LPCWSTR  pszPath, FFFP_MODE  mode, IKnownFolder **  ppkf  )

static

Definition at line 5563 of file shellpath.c.

{
    FIXME("%s, 0x%08x, %p\n", debugstr_w(pszPath), mode, ppkf);
    return E_NOTIMPL;
}

foldermanager_FolderIdFromCsidl()

static HRESULT WINAPI foldermanager_FolderIdFromCsidl ( IKnownFolderManager *  iface, int  nCsidl, KNOWNFOLDERID *  pfid  )

static

Definition at line 5341 of file shellpath.c.

{
    TRACE("%d, %p\n", nCsidl, pfid);
 
    if (nCsidl >= ARRAY_SIZE(CSIDL_Data))
        return E_INVALIDARG;
    *pfid = *CSIDL_Data[nCsidl].id;
    return S_OK;
}

foldermanager_FolderIdToCsidl()

static HRESULT WINAPI foldermanager_FolderIdToCsidl ( IKnownFolderManager *  iface, REFKNOWNFOLDERID  rfid, int *  pnCsidl  )

static

Definition at line 5354 of file shellpath.c.

{
    int csidl;
 
    TRACE("%s, %p\n", debugstr_guid(rfid), pnCsidl);
 
    csidl = csidl_from_id( rfid );
    if (csidl == -1) return E_INVALIDARG;
    *pnCsidl = csidl;
    return S_OK;
}

foldermanager_GetFolder()

static HRESULT WINAPI foldermanager_GetFolder ( IKnownFolderManager *  iface, REFKNOWNFOLDERID  rfid, IKnownFolder **  ppkf  )

static

Definition at line 5411 of file shellpath.c.

{
    struct foldermanager *fm = impl_from_IKnownFolderManager( iface );
    struct knownfolder *kf;
    HRESULT hr;
 
    TRACE("%s, %p\n", debugstr_guid(rfid), ppkf);
 
    if (!is_knownfolder( fm, rfid ))
    {
        WARN("unknown folder\n");
        return E_INVALIDARG;
    }
    hr = knownfolder_create( &kf );
    if (SUCCEEDED( hr ))
    {
        hr = knownfolder_set_id( kf, rfid );
        *ppkf = &kf->IKnownFolder_iface;
    }
    else
        *ppkf = NULL;
 
    return hr;
}

foldermanager_GetFolderByName()

static HRESULT WINAPI foldermanager_GetFolderByName ( IKnownFolderManager *  iface, LPCWSTR  pszCanonicalName, IKnownFolder **  ppkf  )

static

Definition at line 5439 of file shellpath.c.

{
    struct foldermanager *fm = impl_from_IKnownFolderManager( iface );
    struct knownfolder *kf;
    BOOL found = FALSE;
    HRESULT hr;
    UINT i;
 
    TRACE( "%s, %p\n", debugstr_w(pszCanonicalName), ppkf );
 
    for (i = 0; i < fm->num_ids; i++)
    {
        WCHAR *path, *name;
        hr = get_known_folder_registry_path( &fm->ids[i], NULL, &path );
        if (FAILED( hr )) return hr;
 
        hr = get_known_folder_wstr( path, L"Name", &name );
        free( path );
        if (FAILED( hr )) return hr;
 
        found = !wcsicmp( pszCanonicalName, name );
        CoTaskMemFree( name );
        if (found) break;
    }
 
    if (found)
    {
        hr = knownfolder_create( &kf );
        if (FAILED( hr )) return hr;
 
        hr = knownfolder_set_id( kf, &fm->ids[i] );
        if (FAILED( hr ))
        {
            IKnownFolder_Release( &kf->IKnownFolder_iface );
            return hr;
        }
        *ppkf = &kf->IKnownFolder_iface;
    }
    else
    {
        hr = HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND );
        *ppkf = NULL;
    }
 
    return hr;
}

foldermanager_GetFolderIds()

static HRESULT WINAPI foldermanager_GetFolderIds ( IKnownFolderManager *  iface, KNOWNFOLDERID **  ppKFId, UINT *  pCount  )

static

Definition at line 5369 of file shellpath.c.

{
    struct foldermanager *fm = impl_from_IKnownFolderManager( iface );
 
    TRACE("%p, %p\n", ppKFId, pCount);
 
    *ppKFId = CoTaskMemAlloc(fm->num_ids * sizeof(KNOWNFOLDERID));
    memcpy(*ppKFId, fm->ids, fm->num_ids * sizeof(KNOWNFOLDERID));
    *pCount = fm->num_ids;
    return S_OK;
}

foldermanager_QueryInterface()

static HRESULT WINAPI foldermanager_QueryInterface ( IKnownFolderManager *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 5312 of file shellpath.c.

{
    struct foldermanager *This = impl_from_IKnownFolderManager( iface );
 
    TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppv );
 
    *ppv = NULL;
    if ( IsEqualGUID( riid, &IID_IKnownFolderManager ) ||
         IsEqualGUID( riid, &IID_IUnknown ) )
    {
        *ppv = iface;
    }
    else if ( IsEqualGUID( riid, &IID_IMarshal ) )
    {
        TRACE("IID_IMarshal returning NULL.\n");
        return E_NOINTERFACE;
    }
    else
    {
        FIXME("interface %s not implemented\n", debugstr_guid(riid));
        return E_NOINTERFACE;
    }
    IKnownFolderManager_AddRef( iface );
    return S_OK;
}

foldermanager_Redirect()

static HRESULT WINAPI foldermanager_Redirect ( IKnownFolderManager *  iface, REFKNOWNFOLDERID  rfid, HWND  hwnd, KF_REDIRECT_FLAGS  flags, LPCWSTR  pszTargetPath, UINT  cFolders, KNOWNFOLDERID const *  pExclusion, LPWSTR *  ppszError  )

static

Definition at line 5582 of file shellpath.c.

{
    return redirect_known_folder(rfid, hwnd, flags, pszTargetPath, cFolders, pExclusion, ppszError);
}

foldermanager_RegisterFolder()

static HRESULT WINAPI foldermanager_RegisterFolder ( IKnownFolderManager *  iface, REFKNOWNFOLDERID  rfid, KNOWNFOLDER_DEFINITION const *  pKFD  )

static

Definition at line 5537 of file shellpath.c.

{
    TRACE("(%p, %s, %p)\n", iface, debugstr_guid(rfid), pKFD);
    return register_folder(rfid, pKFD);
}

foldermanager_Release()

static ULONG WINAPI foldermanager_Release ( IKnownFolderManager *  iface )

static

Definition at line 5298 of file shellpath.c.

{
    struct foldermanager *foldermanager = impl_from_IKnownFolderManager( iface );
    LONG refs = InterlockedDecrement( &foldermanager->refs );
    if (!refs)
    {
        TRACE("destroying %p\n", foldermanager);
        free( foldermanager->ids );
        free( foldermanager );
    }
    return refs;
}

foldermanager_UnregisterFolder()

static HRESULT WINAPI foldermanager_UnregisterFolder ( IKnownFolderManager *  iface, REFKNOWNFOLDERID  rfid  )

static

Definition at line 5546 of file shellpath.c.

{
    HRESULT hr;
    LPWSTR registryPath = NULL;
    TRACE("(%p, %s)\n", iface, debugstr_guid(rfid));
 
    hr = get_known_folder_registry_path(rfid, NULL, &registryPath);
 
    if(SUCCEEDED(hr))
        hr = HRESULT_FROM_WIN32(SHDeleteKeyW(HKEY_LOCAL_MACHINE, registryPath));
 
    free(registryPath);
    return hr;
}

get_known_folder_dword()

static HRESULT get_known_folder_dword ( const WCHAR *  registryPath, const WCHAR *  value, DWORD *  out  )

static

Definition at line 4734 of file shellpath.c.

{
    DWORD dwSize = sizeof(DWORD);
    DWORD dwType;
    return HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, value, RRF_RT_DWORD, &dwType, out, &dwSize));
}

Referenced by get_known_folder_path(), get_known_folder_redirection_place(), knownfolder_GetCategory(), and knownfolder_GetFolderDefinition().

get_known_folder_path()

static HRESULT get_known_folder_path ( LPWSTR  sFolderId, LPWSTR  registryPath, LPWSTR *  ppszPath  )

static

Definition at line 5012 of file shellpath.c.

{
    HRESULT hr;
    DWORD dwSize, dwType;
    WCHAR path[MAX_PATH] = {0};
    WCHAR parentGuid[39];
    DWORD category;
    LPWSTR parentRegistryPath, parentPath;
    HKEY hRedirectionRootKey = NULL;
 
    TRACE("(%s, %p)\n", debugstr_w(registryPath), ppszPath);
    *ppszPath = NULL;
 
    /* check if folder has parent */
    dwSize = sizeof(parentGuid);
    hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, L"ParentFolder", RRF_RT_REG_SZ, &dwType, parentGuid, &dwSize));
    if(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) hr = S_FALSE;
 
    if(hr == S_OK)
    {
        /* get parent's known folder path (recursive) */
        hr = get_known_folder_registry_path(NULL, parentGuid, &parentRegistryPath);
        if(FAILED(hr)) return hr;
 
        hr = get_known_folder_path(parentGuid, parentRegistryPath, &parentPath);
        if(FAILED(hr)) {
            free(parentRegistryPath);
            return hr;
        }
 
        lstrcatW(path, parentPath);
        lstrcatW(path, L"\\");
 
        free(parentRegistryPath);
        free(parentPath);
    }
 
    /* check, if folder was redirected */
    if(SUCCEEDED(hr))
        hr = get_known_folder_dword(registryPath, L"Category", &category);
 
    if(SUCCEEDED(hr))
    {
        if(category == KF_CATEGORY_COMMON)
            hRedirectionRootKey = HKEY_LOCAL_MACHINE;
        else if(category == KF_CATEGORY_PERUSER)
            hRedirectionRootKey = HKEY_CURRENT_USER;
 
        if(hRedirectionRootKey)
        {
            hr = HRESULT_FROM_WIN32(RegGetValueW(hRedirectionRootKey, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders", sFolderId, RRF_RT_REG_SZ, NULL, NULL, &dwSize));
 
            if(SUCCEEDED(hr))
            {
                *ppszPath = CoTaskMemAlloc(dwSize+(lstrlenW(path)+1)*sizeof(WCHAR));
                if(!*ppszPath) hr = E_OUTOFMEMORY;
            }
 
            if(SUCCEEDED(hr))
            {
                lstrcpyW(*ppszPath, path);
                hr = HRESULT_FROM_WIN32(RegGetValueW(hRedirectionRootKey, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders", sFolderId, RRF_RT_REG_SZ, NULL, *ppszPath + lstrlenW(path), &dwSize));
            }
        }
 
        if(!*ppszPath)
        {
            /* no redirection, use previous way - read the relative path from folder definition */
            hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, L"RelativePath", RRF_RT_REG_SZ, &dwType, NULL, &dwSize));
 
            if(SUCCEEDED(hr))
            {
                *ppszPath = CoTaskMemAlloc(dwSize+(lstrlenW(path)+1)*sizeof(WCHAR));
                if(!*ppszPath) hr = E_OUTOFMEMORY;
            }
 
            if(SUCCEEDED(hr))
            {
                lstrcpyW(*ppszPath, path);
                hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, registryPath, L"RelativePath", RRF_RT_REG_SZ, &dwType, *ppszPath + lstrlenW(path), &dwSize));
            }
        }
    }
 
    TRACE("returning path: %s\n", debugstr_w(*ppszPath));
    return hr;
}

Referenced by get_known_folder_path(), and get_known_folder_path_by_id().

get_known_folder_path_by_id()

static HRESULT get_known_folder_path_by_id ( REFKNOWNFOLDERID  folderId, LPWSTR  lpRegistryPath, DWORD  dwFlags, LPWSTR *  ppszPath  )

static

Definition at line 5103 of file shellpath.c.

{
    HRESULT hr = E_FAIL;
    WCHAR sGuid[39];
    DWORD dwAttributes;
 
    TRACE("(%s, %s, 0x%08lx, %p)\n", debugstr_guid(folderId), debugstr_w(lpRegistryPath), dwFlags, ppszPath);
 
    /* if this is registry-registered known folder, get path from registry */
    if(lpRegistryPath)
    {
        StringFromGUID2(folderId, sGuid, ARRAY_SIZE(sGuid));
 
        hr = get_known_folder_path(sGuid, lpRegistryPath, ppszPath);
    }
    /* in other case, use older way */
 
    if(FAILED(hr))
        hr = SHGetKnownFolderPath( folderId, dwFlags, NULL, ppszPath );
 
    if (FAILED(hr)) return hr;
 
    /* check if known folder really exists */
    dwAttributes = GetFileAttributesW(*ppszPath);
    if(dwAttributes == INVALID_FILE_ATTRIBUTES || !(dwAttributes & FILE_ATTRIBUTE_DIRECTORY) )
    {
        TRACE("directory %s not found\n", debugstr_w(*ppszPath));
        CoTaskMemFree(*ppszPath);
        *ppszPath = NULL;
        hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
    }
 
    return hr;
}

Referenced by knownfolder_GetPath(), and redirect_known_folder().

get_known_folder_redirection_place()

static HRESULT get_known_folder_redirection_place ( REFKNOWNFOLDERID  rfid, HKEY *  rootKey  )

static

Definition at line 4749 of file shellpath.c.

{
    HRESULT hr;
    LPWSTR lpRegistryPath = NULL;
    DWORD category;
 
    /* first, get known folder's category */
    hr = get_known_folder_registry_path(rfid, NULL, &lpRegistryPath);
 
    if(SUCCEEDED(hr))
        hr = get_known_folder_dword(lpRegistryPath, L"Category", &category);
 
    if(SUCCEEDED(hr))
    {
        if(category == KF_CATEGORY_COMMON)
        {
            *rootKey = HKEY_LOCAL_MACHINE;
            hr = S_OK;
        }
        else if(category == KF_CATEGORY_PERUSER)
        {
            *rootKey = HKEY_CURRENT_USER;
            hr = S_OK;
        }
        else
            hr = E_FAIL;
    }
 
    free(lpRegistryPath);
    return hr;
}

Referenced by redirect_known_folder().

get_known_folder_registry_path()

static HRESULT get_known_folder_registry_path ( REFKNOWNFOLDERID  rfid, LPWSTR  lpStringGuid, LPWSTR *  lpPath  )

static

Definition at line 4681 of file shellpath.c.

{
    HRESULT hr = S_OK;
    int length;
    WCHAR sGuid[50];
 
    TRACE("(%s, %s, %p)\n", debugstr_guid(rfid), debugstr_w(lpStringGuid), lpPath);
 
    if(rfid)
        StringFromGUID2(rfid, sGuid, ARRAY_SIZE(sGuid));
    else
        lstrcpyW(sGuid, lpStringGuid);
 
    length = lstrlenW(L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FolderDescriptions")+51;
    *lpPath = malloc(length * sizeof(WCHAR));
    if(!(*lpPath))
        hr = E_OUTOFMEMORY;
 
    if(SUCCEEDED(hr))
    {
        lstrcpyW(*lpPath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FolderDescriptions\\");
        lstrcatW(*lpPath, sGuid);
    }
 
    return hr;
}

Referenced by foldermanager_GetFolderByName(), foldermanager_UnregisterFolder(), get_known_folder_path(), get_known_folder_redirection_place(), is_knownfolder(), knownfolder_set_id(), redirect_known_folder(), and register_folder().

get_known_folder_wstr()

static HRESULT get_known_folder_wstr ( const WCHAR *  regpath, const WCHAR *  value, WCHAR **  out  )

static

Definition at line 4711 of file shellpath.c.

{
    DWORD size = 0;
    HRESULT hr;
 
    size = 0;
    hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, regpath, value, RRF_RT_REG_SZ, NULL, NULL, &size));
    if(FAILED(hr))
        return hr;
 
    *out = CoTaskMemAlloc(size);
    if(!*out)
        return E_OUTOFMEMORY;
 
    hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, regpath, value, RRF_RT_REG_SZ, NULL, *out, &size));
    if(FAILED(hr)){
        CoTaskMemFree(*out);
        *out = NULL;
    }
 
    return hr;
}

Referenced by foldermanager_GetFolderByName(), and knownfolder_GetFolderDefinition().

get_xdg_path()

static char * get_xdg_path ( const char *  var )

static

Definition at line 3664 of file shellpath.c.

{
    static INIT_ONCE once;
    char *p, *ret = NULL;
    int i;
 
    InitOnceExecuteOnce( &once, init_xdg_dirs, NULL, NULL );
    if (!xdg_config) return NULL;
 
    for (p = xdg_config; p < xdg_config + xdg_config_len; p += strlen(p) + 1)
    {
        while (*p == ' ' || *p == '\t') p++;
        if (strncmp( p, var, strlen(var) )) continue;
        p += strlen(var);
        while (*p == ' ' || *p == '\t') p++;
        if (*p != '=') continue;
        p++;
        while (*p == ' ' || *p == '\t') p++;
        if (*p != '"') continue;
        p++;
        if (*p != '/' && strncmp( p, "$HOME/", 6 )) continue;
 
        if (!(ret = malloc( strlen(p) + 1 ))) break;
        for (i = 0; *p && *p != '"'; i++, p++)
        {
            if (*p == '\\' && p[1]) p++;
            ret[i] = *p;
        }
        ret[i] = 0;
        if (*p != '"')
        {
            free( ret );
            ret = NULL;
        }
        break;
    }
    return ret;
}

Referenced by create_link().

impl_from_IApplicationDestinations()

static IApplicationDestinationsImpl * impl_from_IApplicationDestinations ( IApplicationDestinations *  iface )

inlinestatic

Definition at line 1582 of file shellpath.c.

{
    return CONTAINING_RECORD(iface, IApplicationDestinationsImpl, IApplicationDestinations_iface);
}

Referenced by ApplicationDestinations_AddRef(), ApplicationDestinations_QueryInterface(), ApplicationDestinations_Release(), ApplicationDestinations_RemoveAllDestinations(), ApplicationDestinations_RemoveDestination(), and ApplicationDestinations_SetAppID().

impl_from_IApplicationDocumentLists()

static IApplicationDocumentListsImpl * impl_from_IApplicationDocumentLists ( IApplicationDocumentLists *  iface )

inlinestatic

Definition at line 1701 of file shellpath.c.

{
    return CONTAINING_RECORD(iface, IApplicationDocumentListsImpl, IApplicationDocumentLists_iface);
}

Referenced by ApplicationDocumentLists_AddRef(), ApplicationDocumentLists_GetList(), ApplicationDocumentLists_QueryInterface(), ApplicationDocumentLists_Release(), and ApplicationDocumentLists_SetAppID().

impl_from_IKnownFolder()

static struct knownfolder * impl_from_IKnownFolder ( IKnownFolder *  iface )

inlinestatic

Definition at line 4883 of file shellpath.c.

{
    return CONTAINING_RECORD( iface, struct knownfolder, IKnownFolder_iface );
}

Referenced by knownfolder_AddRef(), knownfolder_GetCategory(), knownfolder_GetFolderDefinition(), knownfolder_GetId(), knownfolder_GetIDList(), knownfolder_GetPath(), knownfolder_GetShellItem(), knownfolder_QueryInterface(), knownfolder_Release(), and knownfolder_SetPath().

impl_from_IKnownFolderManager()

static struct foldermanager * impl_from_IKnownFolderManager ( IKnownFolderManager *  iface )

inlinestatic

Definition at line 5286 of file shellpath.c.

{
    return CONTAINING_RECORD( iface, struct foldermanager, IKnownFolderManager_iface );
}

Referenced by foldermanager_AddRef(), foldermanager_GetFolder(), foldermanager_GetFolderByName(), foldermanager_GetFolderIds(), foldermanager_QueryInterface(), and foldermanager_Release().

init_xdg_dirs()

static BOOL WINAPI init_xdg_dirs ( INIT_ONCE *  once, void *  param, void **  context  )

static

Definition at line 3624 of file shellpath.c.

{
    const WCHAR *var, *fmt = L"\\??\\unix%s/user-dirs.dirs";
    char *p;
    WCHAR *name, *ptr;
    HANDLE file;
    DWORD len;
 
    if (!(var = _wgetenv( L"WINE_HOST_XDG_CONFIG_HOME" )) || var[0] != '/')
    {
        if (!(var = _wgetenv( L"WINEHOMEDIR" ))) return TRUE;
        fmt = L"%s/.config/user-dirs.dirs";
    }
    len = lstrlenW(var) + lstrlenW(fmt);
    name = malloc( len * sizeof(WCHAR) );
    swprintf( name, len, fmt, var );
    name[1] = '\\';  /* change \??\ to \\?\ */
    for (ptr = name; *ptr; ptr++) if (*ptr == '/') *ptr = '\\';
 
    file = CreateFileW( name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
    free( name );
    if (file != INVALID_HANDLE_VALUE)
    {
        len = GetFileSize( file, NULL );
        if (!(xdg_config = malloc( len + 1 ))) return TRUE;
        if (!ReadFile( file, xdg_config, len, &xdg_config_len, NULL ))
        {
            free( xdg_config );
            xdg_config = NULL;
        }
        else
        {
            for (p = xdg_config; p < xdg_config + xdg_config_len; p++) if (*p == '\n') *p = 0;
            *p = 0;  /* append null to simplify string parsing */
        }
        CloseHandle( file );
    }
    return TRUE;
}

Referenced by get_xdg_path().

is_knownfolder()

static BOOL is_knownfolder ( struct foldermanager *  fm, const KNOWNFOLDERID *  id  )

static

Definition at line 5384 of file shellpath.c.

{
    UINT i;
    HRESULT hr;
    LPWSTR registryPath = NULL;
    HKEY hKey;
 
    /* TODO: move all entries from "CSIDL_Data" static array to registry known folder descriptions */
    for (i = 0; i < fm->num_ids; i++)
        if (IsEqualGUID( &fm->ids[i], id )) return TRUE;
 
    hr = get_known_folder_registry_path(id, NULL, &registryPath);
    if(SUCCEEDED(hr))
    {
        hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_LOCAL_MACHINE, registryPath, 0, KEY_ENUMERATE_SUB_KEYS, &hKey));
        free(registryPath);
    }
 
    if(SUCCEEDED(hr))
    {
        hr = S_OK;
        RegCloseKey(hKey);
    }
 
    return hr == S_OK;
}

Referenced by foldermanager_GetFolder().

IsLFNDriveA()

BOOL WINAPI IsLFNDriveA

(

LPCSTR

lpszPath

)

Definition at line 874 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 899 of file shellpath.c.

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

IsLFNDriveW()

BOOL WINAPI IsLFNDriveW

(

LPCWSTR

lpszPath

)

Definition at line 886 of file shellpath.c.

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

Referenced by IsLFNDriveAW().

knownfolder_AddRef()

static ULONG WINAPI knownfolder_AddRef ( IKnownFolder *  iface )

static

Definition at line 4888 of file shellpath.c.

{
    struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
    return InterlockedIncrement( &knownfolder->refs );
}

knownfolder_create()

static HRESULT knownfolder_create ( struct knownfolder **  knownfolder )

static

Definition at line 5260 of file shellpath.c.

{
    struct knownfolder *kf;
 
    kf = malloc( sizeof(*kf) );
    if (!kf) return E_OUTOFMEMORY;
 
    kf->IKnownFolder_iface.lpVtbl = &knownfolder_vtbl;
    kf->refs = 1;
    memset( &kf->id, 0, sizeof(kf->id) );
    kf->registryPath = NULL;
 
    *knownfolder = kf;
 
    TRACE("returning iface %p\n", &kf->IKnownFolder_iface);
    return S_OK;
}

Referenced by foldermanager_GetFolder(), and foldermanager_GetFolderByName().

knownfolder_GetCategory()

static HRESULT WINAPI knownfolder_GetCategory ( IKnownFolder *  iface, KF_CATEGORY *  pCategory  )

static

Definition at line 4982 of file shellpath.c.

{
    struct knownfolder *knownfolder = impl_from_IKnownFolder(iface);
    HRESULT hr = S_OK;
 
    TRACE("%p, %p\n", knownfolder, pCategory);
 
    /* we cannot get a category for a folder which is not registered */
    if(!knownfolder->registryPath)
        hr = E_FAIL;
 
    if(SUCCEEDED(hr))
        hr = get_known_folder_dword(knownfolder->registryPath, L"Category", (DWORD *)pCategory);
 
    return hr;
}

knownfolder_GetFolderDefinition()

static HRESULT WINAPI knownfolder_GetFolderDefinition ( IKnownFolder *  iface, KNOWNFOLDER_DEFINITION *  pKFD  )

static

Definition at line 5201 of file shellpath.c.

{
    struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
    HRESULT hr;
    DWORD dwSize;
    WCHAR parentGuid[39];
    TRACE("(%p, %p)\n", knownfolder, pKFD);
 
    if(!pKFD) return E_INVALIDARG;
 
    ZeroMemory(pKFD, sizeof(*pKFD));
 
    /* required fields */
    hr = get_known_folder_dword(knownfolder->registryPath, L"Category", (DWORD *)&pKFD->category);
    if(FAILED(hr))
        return hr;
 
    hr = get_known_folder_wstr(knownfolder->registryPath, L"Name", &pKFD->pszName);
    if(FAILED(hr))
        return hr;
 
    /* optional fields */
    dwSize = sizeof(parentGuid);
    hr = HRESULT_FROM_WIN32(RegGetValueW(HKEY_LOCAL_MACHINE, knownfolder->registryPath, L"ParentFolder",
                RRF_RT_REG_SZ, NULL, parentGuid, &dwSize));
    if(SUCCEEDED(hr))
    {
        hr = IIDFromString(parentGuid, &pKFD->fidParent);
        if(FAILED(hr))
            return hr;
    }
 
    get_known_folder_dword(knownfolder->registryPath, L"Attributes", &pKFD->dwAttributes);
 
    get_known_folder_wstr(knownfolder->registryPath, L"RelativePath", &pKFD->pszRelativePath);
 
    get_known_folder_wstr(knownfolder->registryPath, L"ParsingName", &pKFD->pszParsingName);
 
    return S_OK;
}

knownfolder_GetFolderType()

static HRESULT WINAPI knownfolder_GetFolderType ( IKnownFolder *  iface, FOLDERTYPEID *  pftid  )

static

Definition at line 5183 of file shellpath.c.

{
    FIXME("%p\n", pftid);
    return E_NOTIMPL;
}

knownfolder_GetId()

static HRESULT WINAPI knownfolder_GetId ( IKnownFolder *  iface, KNOWNFOLDERID *  pkfid  )

static

Definition at line 4970 of file shellpath.c.

{
    struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
 
    TRACE("%p\n", pkfid);
 
    *pkfid = knownfolder->id;
    return S_OK;
}

knownfolder_GetIDList()

static HRESULT WINAPI knownfolder_GetIDList ( IKnownFolder *  iface, DWORD  flags, PIDLIST_ABSOLUTE *  ppidl  )

static

Definition at line 5173 of file shellpath.c.

{
    struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
    TRACE("(%p, 0x%08lx, %p)\n", knownfolder, flags, ppidl);
    return SHGetKnownFolderIDList(&knownfolder->id, flags, NULL, ppidl);
}

knownfolder_GetPath()

static HRESULT WINAPI knownfolder_GetPath ( IKnownFolder *  iface, DWORD  dwFlags, LPWSTR *  ppszPath  )

static

Definition at line 5142 of file shellpath.c.

{
    struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
    TRACE("(%p, 0x%08lx, %p)\n", knownfolder, dwFlags, ppszPath);
 
    return get_known_folder_path_by_id(&knownfolder->id, knownfolder->registryPath, dwFlags, ppszPath);
}

knownfolder_GetRedirectionCapabilities()

static HRESULT WINAPI knownfolder_GetRedirectionCapabilities ( IKnownFolder *  iface, KF_REDIRECTION_CAPABILITIES *  pCapabilities  )

static

Definition at line 5191 of file shellpath.c.

{
    FIXME("%p stub\n", pCapabilities);
    if(!pCapabilities) return E_INVALIDARG;
    *pCapabilities = KF_REDIRECTION_CAPABILITIES_DENY_ALL;
    return S_OK;
}

knownfolder_GetShellItem()

static HRESULT WINAPI knownfolder_GetShellItem ( IKnownFolder *  iface, DWORD  flags, REFIID  riid, void **  ppv  )

static

Definition at line 5001 of file shellpath.c.

{
    struct knownfolder *knownfolder = impl_from_IKnownFolder(iface);
    TRACE("(%p, 0x%08lx, %s, %p)\n", knownfolder, flags, debugstr_guid(riid), ppv);
    return SHGetKnownFolderItem(&knownfolder->id, flags, NULL, riid, ppv);
}

knownfolder_QueryInterface()

static HRESULT WINAPI knownfolder_QueryInterface ( IKnownFolder *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 4909 of file shellpath.c.

{
    struct knownfolder *This = impl_from_IKnownFolder( iface );
 
    TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppv );
 
    *ppv = NULL;
    if ( IsEqualGUID( riid, &IID_IKnownFolder ) ||
         IsEqualGUID( riid, &IID_IUnknown ) )
    {
        *ppv = iface;
    }
    else if ( IsEqualGUID( riid, &IID_IMarshal ) )
    {
        TRACE("IID_IMarshal returning NULL.\n");
        return E_NOINTERFACE;
    }
    else
    {
        FIXME("interface %s not implemented\n", debugstr_guid(riid));
        return E_NOINTERFACE;
    }
    IKnownFolder_AddRef( iface );
    return S_OK;
}

knownfolder_Release()

static ULONG WINAPI knownfolder_Release ( IKnownFolder *  iface )

static

Definition at line 4895 of file shellpath.c.

{
    struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
    LONG refs = InterlockedDecrement( &knownfolder->refs );
    if (!refs)
    {
        TRACE("destroying %p\n", knownfolder);
        free( knownfolder->registryPath );
        free( knownfolder );
    }
    return refs;
}

knownfolder_set_id()

static HRESULT knownfolder_set_id ( struct knownfolder *  knownfolder, const KNOWNFOLDERID *  kfid  )

static

Definition at line 4938 of file shellpath.c.

{
    HKEY hKey;
    HRESULT hr;
 
    TRACE("%s\n", debugstr_guid(kfid));
 
    knownfolder->id = *kfid;
 
    /* check is it registry-registered folder */
    hr = get_known_folder_registry_path(kfid, NULL, &knownfolder->registryPath);
    if(SUCCEEDED(hr))
        hr = HRESULT_FROM_WIN32(RegOpenKeyExW(HKEY_LOCAL_MACHINE, knownfolder->registryPath, 0, KEY_ENUMERATE_SUB_KEYS, &hKey));
 
    if(SUCCEEDED(hr))
    {
        hr = S_OK;
        RegCloseKey(hKey);
    }
    else
    {
        /* This known folder is not registered. To mark it, we set registryPath to NULL */
        free(knownfolder->registryPath);
        knownfolder->registryPath = NULL;
        hr = S_OK;
    }
 
    return hr;
}

Referenced by foldermanager_GetFolder(), and foldermanager_GetFolderByName().

knownfolder_SetPath()

static HRESULT WINAPI knownfolder_SetPath ( IKnownFolder *  iface, DWORD  dwFlags, LPCWSTR  pszPath  )

static

Definition at line 5153 of file shellpath.c.

{
    struct knownfolder *knownfolder = impl_from_IKnownFolder( iface );
    HRESULT hr = S_OK;
 
    TRACE("(%p, 0x%08lx, %s)\n", knownfolder, dwFlags, debugstr_w(pszPath));
 
    /* check if the known folder is registered */
    if(!knownfolder->registryPath)
        hr = E_FAIL;
 
    if(SUCCEEDED(hr))
        hr = redirect_known_folder(&knownfolder->id, NULL, 0, pszPath, 0, NULL, NULL);
 
    return hr;
}

KnownFolderManager_Constructor()

HRESULT WINAPI KnownFolderManager_Constructor	(	IUnknown *	punk,
		REFIID	riid,
		void **	ppv
	)

Definition at line 5649 of file shellpath.c.

{
    TRACE("%p, %s, %p\n", punk, debugstr_guid(riid), ppv);
 
    if (!ppv)
        return E_POINTER;
    if (punk)
        return CLASS_E_NOAGGREGATION;
 
    return foldermanager_create( ppv );
}

link_folder()

static BOOL link_folder ( HANDLE  mgr, const UNICODE_STRING *  path, const char *  link  )

static

Definition at line 3703 of file shellpath.c.

{
    struct mountmgr_shell_folder *ioctl;
    DWORD len = sizeof(*ioctl) + path->Length + strlen(link) + 1;
    BOOL ret;
 
    if (!(ioctl = malloc( len ))) return FALSE;
    ioctl->create_backup = FALSE;
    ioctl->folder_offset = sizeof(*ioctl);
    ioctl->folder_size = path->Length;
    memcpy( (char *)ioctl + ioctl->folder_offset, path->Buffer, ioctl->folder_size );
    ioctl->symlink_offset = ioctl->folder_offset + ioctl->folder_size;
    strcpy( (char *)ioctl + ioctl->symlink_offset, link );
 
    ret = DeviceIoControl( mgr, IOCTL_MOUNTMGR_DEFINE_SHELL_FOLDER, ioctl, len, NULL, 0, NULL, NULL );
    free( ioctl );
    return ret;
}

Referenced by create_link(), and get_link_file().

PathAddBackslashAW()

LPVOID WINAPI PathAddBackslashAW

(

LPVOID

lpszPath

)

Definition at line 446 of file shellpath.c.

{
    if(SHELL_OsIsUnicode())
      return PathAddBackslashW(lpszPath);
    return PathAddBackslashA(lpszPath);
}

PathAppendAW()

BOOL WINAPI PathAppendAW	(	LPVOID	lpszPath1,
		LPCVOID	lpszPath2
	)

Definition at line 421 of file shellpath.c.

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

PathBuildRootAW()

LPVOID WINAPI PathBuildRootAW	(	LPVOID	lpszPath,
		int	drive
	)

Definition at line 456 of file shellpath.c.

{
    if(SHELL_OsIsUnicode())
      return PathBuildRootW(lpszPath, drive);
    return PathBuildRootA(lpszPath, drive);
}

PathCleanupSpec()

int WINAPI PathCleanupSpec	(	LPCWSTR	lpszPathW,
		LPWSTR	lpszFileW
	)

Definition at line 1155 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 = lstrlenW(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;
}

Referenced by FinishDlgProc().

PathCombineAW()

LPVOID WINAPI PathCombineAW	(	LPVOID	szDest,
		LPCVOID	lpszDir,
		LPCVOID	lpszFile
	)

Definition at line 433 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathCombineW( szDest, lpszDir, lpszFile );
    return PathCombineA( szDest, lpszDir, lpszFile );
}

PathFileExistsAW()

BOOL WINAPI PathFileExistsAW

(

LPCVOID

lpszPath

)

Definition at line 781 of file shellpath.c.

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

PathFindExtensionAW()

LPVOID WINAPI PathFindExtensionAW

(

LPCVOID

lpszPath

)

Definition at line 480 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathFindExtensionW(lpszPath);
    return PathFindExtensionA(lpszPath);
 
}

PathFindFileNameAW()

LPVOID WINAPI PathFindFileNameAW

(

LPCVOID

lpszPath

)

Definition at line 470 of file shellpath.c.

{
    if(SHELL_OsIsUnicode())
      return PathFindFileNameW(lpszPath);
    return PathFindFileNameA(lpszPath);
}

PathFindOnPathAW()

BOOL WINAPI PathFindOnPathAW	(	LPVOID	sFile,
		LPCVOID *	sOtherDirs
	)

Definition at line 1143 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathFindOnPathW(sFile, (LPCWSTR *)sOtherDirs);
    return PathFindOnPathA(sFile, (LPCSTR *)sOtherDirs);
}

PathGetArgsAW()

LPVOID WINAPI PathGetArgsAW

(

LPVOID

lpszPath

)

Definition at line 527 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathGetArgsW(lpszPath);
    return PathGetArgsA(lpszPath);
}

PathGetDriveNumberAW()

int WINAPI PathGetDriveNumberAW

(

LPVOID

lpszPath

)

Definition at line 537 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathGetDriveNumberW(lpszPath);
    return PathGetDriveNumberA(lpszPath);
}

PathGetExtensionA()

static LPSTR PathGetExtensionA ( LPCSTR  lpszPath )

static

Definition at line 495 of file shellpath.c.

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

Referenced by PathGetExtensionAW(), and PathIsExeA().

PathGetExtensionAW()

LPVOID WINAPI PathGetExtensionAW	(	LPCVOID	lpszPath,
		DWORD	void1,
		DWORD	void2
	)

Definition at line 517 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathGetExtensionW(lpszPath);
    return PathGetExtensionA(lpszPath);
}

PathGetExtensionW()

static LPWSTR PathGetExtensionW ( LPCWSTR  lpszPath )

static

Definition at line 506 of file shellpath.c.

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

Referenced by PathGetExtensionAW(), and PathIsExeW().

PathGetShortPathA()

static void PathGetShortPathA ( LPSTR  pszPath )

static

Definition at line 605 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 635 of file shellpath.c.

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

PathGetShortPathW()

static void PathGetShortPathW ( LPWSTR  pszPath )

static

Definition at line 620 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().

PathIsDirectoryAW()

BOOL WINAPI PathIsDirectoryAW

(

LPCVOID

lpszPath

)

Definition at line 771 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathIsDirectoryW (lpszPath);
    return PathIsDirectoryA (lpszPath);
}

PathIsExeA()

static BOOL PathIsExeA ( LPCSTR  lpszPath )

static

Definition at line 721 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 761 of file shellpath.c.

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

PathIsExeW()

static BOOL PathIsExeW ( LPCWSTR  lpszPath )

static

Definition at line 742 of file shellpath.c.

{
    LPCWSTR lpszExtension = PathGetExtensionW(lpszPath);
        int i;
        static const WCHAR lpszExtensions[][4] =
            {L"exe", L"com", L"pif",L"cmd", L"bat", L"scf",L"scr",L"" };
 
    TRACE("path=%s\n",debugstr_w(lpszPath));
 
    for(i=0; lpszExtensions[i][0]; i++)
      if (!wcsicmp(lpszExtension,lpszExtensions[i])) return TRUE;
 
    return FALSE;
}

Referenced by PathIsExeAW().

PathIsRelativeAW()

BOOL WINAPI PathIsRelativeAW

(

LPCVOID

lpszPath

)

Definition at line 701 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathIsRelativeW( lpszPath );
    return PathIsRelativeA( lpszPath );
}

PathIsRootAW()

BOOL WINAPI PathIsRootAW

(

LPCVOID

lpszPath

)

Definition at line 711 of file shellpath.c.

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

PathIsSameRootAW()

BOOL WINAPI PathIsSameRootAW	(	LPCVOID	lpszPath1,
		LPCVOID	lpszPath2
	)

Definition at line 801 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathIsSameRootW(lpszPath1, lpszPath2);
    return PathIsSameRootA(lpszPath1, lpszPath2);
}

PathIsUNCAW()

BOOL WINAPI PathIsUNCAW

(

LPCVOID

lpszPath

)

Definition at line 691 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathIsUNCW( lpszPath );
    return PathIsUNCA( lpszPath );
}

PathMakeUniqueNameA()

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

static

Definition at line 912 of file shellpath.c.

{
    FIXME("%p %lu %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 1093 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 1076 of file shellpath.c.

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

Referenced by PathMakeUniqueNameAW().

PathMatchSpecAW()

BOOL WINAPI PathMatchSpecAW	(	LPVOID	name,
		LPVOID	mask
	)

Definition at line 791 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathMatchSpecW( name, mask );
    return PathMatchSpecA( name, mask );
}

PathParseIconLocationAW()

int WINAPI PathParseIconLocationAW

(

LPVOID

lpszPath

)

Definition at line 678 of file shellpath.c.

{
    if(SHELL_OsIsUnicode())
      return PathParseIconLocationW(lpszPath);
    return PathParseIconLocationA(lpszPath);
}

PathProcessCommandA()

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

static

Definition at line 1497 of file shellpath.c.

{
    FIXME("%s %p 0x%04lx 0x%04lx 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 1531 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 1514 of file shellpath.c.

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

Referenced by PathProcessCommandAW().

PathQualifyA()

static BOOL PathQualifyA ( LPCSTR  pszPath )

static

Definition at line 1387 of file shellpath.c.

{
    FIXME("%s\n",pszPath);
    return FALSE;
}

Referenced by PathQualifyAW().

PathQualifyAW()

BOOL WINAPI PathQualifyAW

(

LPCVOID

pszPath

)

Definition at line 1405 of file shellpath.c.

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

PathQualifyW()

static BOOL PathQualifyW ( LPCWSTR  pszPath )

static

Definition at line 1396 of file shellpath.c.

{
    FIXME("%s\n",debugstr_w(pszPath));
    return FALSE;
}

Referenced by PathQualifyAW().

PathQuoteSpacesAW()

VOID WINAPI PathQuoteSpacesAW

(

LPVOID

lpszPath

)

Definition at line 656 of file shellpath.c.

{
    if(SHELL_OsIsUnicode())
            PathQuoteSpacesW(lpszPath);
        else
            PathQuoteSpacesA(lpszPath);
}

PathRemoveArgsAW()

void WINAPI PathRemoveArgsAW

(

LPVOID

lpszPath

)

Definition at line 578 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
            PathRemoveArgsW(lpszPath);
        else
            PathRemoveArgsA(lpszPath);
}

PathRemoveBlanksAW()

void WINAPI PathRemoveBlanksAW

(

LPVOID

str

)

Definition at line 645 of file shellpath.c.

{
    if(SHELL_OsIsUnicode())
            PathRemoveBlanksW(str);
        else
            PathRemoveBlanksA(str);
}

PathRemoveExtensionAW()

void WINAPI PathRemoveExtensionAW

(

LPVOID

lpszPath

)

Definition at line 589 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
            PathRemoveExtensionW(lpszPath);
        else
            PathRemoveExtensionA(lpszPath);
}

PathRemoveFileSpecAW()

BOOL WINAPI PathRemoveFileSpecAW

(

LPVOID

lpszPath

)

Definition at line 547 of file shellpath.c.

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

PathResolveA()

static BOOL PathResolveA ( char *  path, const char **  dirs, DWORD  flags  )

static

Definition at line 1412 of file shellpath.c.

{
    BOOL is_file_spec = PathIsFileSpecA(path);
    DWORD dwWhich = flags & PRF_DONTFINDLNK ? 0xf : 0xbf;
 
    TRACE("(%s,%p,0x%08lx)\n", debugstr_a(path), dirs, flags);
 
    if (flags & PRF_VERIFYEXISTS)
    {
        if (PathFindOnPathExA(path, dirs, dwWhich))
        {
            if (!PathIsFileSpecA(path)) GetFullPathNameA(path, MAX_PATH, path, NULL);
            return TRUE;
        }
        if (!is_file_spec)
        {
            GetFullPathNameA(path, MAX_PATH, path, NULL);
            if (PathFileExistsDefExtA(path, dwWhich))
                return TRUE;
        }
        SetLastError(ERROR_FILE_NOT_FOUND);
        return FALSE;
    }
 
    if (is_file_spec)
    {
        SetLastError(ERROR_FILE_NOT_FOUND);
        return FALSE;
    }
 
    GetFullPathNameA(path, MAX_PATH, path, NULL);
 
    return TRUE;
}

Referenced by PathResolveAW().

PathResolveAW()

BOOL WINAPI PathResolveAW	(	void *	path,
		const void **	paths,
		DWORD	flags
	)

Definition at line 1485 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
        return PathResolveW(path, (const WCHAR **)paths, flags);
    else
        return PathResolveA(path, (const char **)paths, flags);
}

PathResolveW()

BOOL WINAPI PathResolveW	(	WCHAR *	path,
		const WCHAR **	dirs,
		DWORD	flags
	)

Definition at line 1447 of file shellpath.c.

{
    BOOL is_file_spec = PathIsFileSpecW(path);
    DWORD dwWhich = flags & PRF_DONTFINDLNK ? 0xf : 0xbf;
 
    TRACE("(%s,%p,0x%08lx)\n", debugstr_w(path), dirs, flags);
 
    if (flags & PRF_VERIFYEXISTS)
    {
        if (PathFindOnPathExW(path, dirs, dwWhich))
        {
            if (!PathIsFileSpecW(path)) GetFullPathNameW(path, MAX_PATH, path, NULL);
            return TRUE;
        }
        if (!is_file_spec)
        {
            GetFullPathNameW(path, MAX_PATH, path, NULL);
            if (PathFileExistsDefExtW(path, dwWhich))
                return TRUE;
        }
        SetLastError(ERROR_FILE_NOT_FOUND);
        return FALSE;
    }
 
    if (is_file_spec)
    {
        SetLastError(ERROR_FILE_NOT_FOUND);
        return FALSE;
    }
 
    GetFullPathNameW(path, MAX_PATH, path, NULL);
 
    return TRUE;
}

Referenced by FindExecutableW(), PathProcessCommandW(), PathResolveAW(), CShellLink::SetTargetFromPIDLOrPath(), SH32_EvaluateValidExecApp(), and SHELL_FindExecutable().

PathSetDlgItemPathAW()

VOID WINAPI PathSetDlgItemPathAW	(	HWND	hDlg,
		int	id,
		LPCVOID	pszPath
	)

Definition at line 1549 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
            PathSetDlgItemPathW(hDlg, id, pszPath);
        else
            PathSetDlgItemPathA(hDlg, id, pszPath);
}

PathStripPathAW()

void WINAPI PathStripPathAW

(

LPVOID

lpszPath

)

Definition at line 557 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
            PathStripPathW(lpszPath);
        else
            PathStripPathA(lpszPath);
}

PathStripToRootAW()

BOOL WINAPI PathStripToRootAW

(

LPVOID

lpszPath

)

Definition at line 568 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return PathStripToRootW(lpszPath);
    return PathStripToRootA(lpszPath);
}

PathUnquoteSpacesAW()

VOID WINAPI PathUnquoteSpacesAW

(

LPVOID

str

)

Definition at line 667 of file shellpath.c.

{
    if(SHELL_OsIsUnicode())
      PathUnquoteSpacesW(str);
    else
      PathUnquoteSpacesA(str);
}

PathYetAnotherMakeUniqueName()

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

Definition at line 1108 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);
    lstrcpyW(retW, pathW);
    PathRemoveExtensionW(pathW);
 
    ext = PathFindExtensionW(file);
 
    /* now try to make it unique */
    while (PathFileExistsW(retW))
    {
        swprintf(retW, ARRAY_SIZE(retW), L"%s (%d)%s", pathW, i, ext);
        i++;
    }
 
    lstrcpyW(buffer, retW);
    TRACE("ret - %s\n", debugstr_w(buffer));
 
    return TRUE;
}

Referenced by BrFolder_NewFolder(), CNewMenu::CreateNewFolder(), CDefaultContextMenu::DoCreateNewFolder(), CDeskLinkDropHandler::Drop(), FinishDlgProc(), loadShell32(), and CNewMenu::NewItemByNonCommand().

redirect_known_folder()

static HRESULT redirect_known_folder ( REFKNOWNFOLDERID  rfid, HWND  hwnd, KF_REDIRECT_FLAGS  flags, LPCWSTR  pszTargetPath, UINT  cFolders, KNOWNFOLDERID const *  pExclusion, LPWSTR *  ppszError  )

static

Definition at line 4785 of file shellpath.c.

{
    HRESULT hr;
    HKEY rootKey = HKEY_LOCAL_MACHINE, hKey;
    WCHAR sGuid[39];
    LPWSTR lpRegistryPath = NULL, lpSrcPath = NULL;
    TRACE("(%s, %p, 0x%08x, %s, %d, %p, %p)\n", debugstr_guid(rfid), hwnd, flags, debugstr_w(pszTargetPath), cFolders, pExclusion, ppszError);
 
    if (ppszError) *ppszError = NULL;
 
    hr = get_known_folder_registry_path(rfid, NULL, &lpRegistryPath);
 
    if(SUCCEEDED(hr))
        hr = get_known_folder_path_by_id(rfid, lpRegistryPath, 0, &lpSrcPath);
 
    free(lpRegistryPath);
 
    /* get path to redirection storage */
    if(SUCCEEDED(hr))
        hr = get_known_folder_redirection_place(rfid, &rootKey);
 
    /* write redirection information */
    if(SUCCEEDED(hr))
        hr = HRESULT_FROM_WIN32(RegCreateKeyExW(rootKey, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders", 0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL));
 
    if(SUCCEEDED(hr))
    {
        StringFromGUID2(rfid, sGuid, ARRAY_SIZE(sGuid));
 
        hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, sGuid, 0, REG_SZ, (LPBYTE)pszTargetPath, (lstrlenW(pszTargetPath)+1)*sizeof(WCHAR)));
 
        RegCloseKey(hKey);
    }
 
    /* make sure destination path exists */
    SHCreateDirectory(NULL, pszTargetPath);
 
    /* copy content if required */
    if(SUCCEEDED(hr) && (flags & KF_REDIRECT_COPY_CONTENTS) )
    {
        WCHAR srcPath[MAX_PATH+1], dstPath[MAX_PATH+1];
        SHFILEOPSTRUCTW fileOp;
 
        ZeroMemory(srcPath, sizeof(srcPath));
        lstrcpyW(srcPath, lpSrcPath);
        lstrcatW(srcPath, L"\\*");
 
        ZeroMemory(dstPath, sizeof(dstPath));
        lstrcpyW(dstPath, pszTargetPath);
 
        ZeroMemory(&fileOp, sizeof(fileOp));
 
        if(flags & KF_REDIRECT_DEL_SOURCE_CONTENTS)
            fileOp.wFunc = FO_MOVE;
        else
            fileOp.wFunc = FO_COPY;
 
        fileOp.pFrom = srcPath;
        fileOp.pTo = dstPath;
        fileOp.fFlags = FOF_NO_UI;
 
        hr = (SHFileOperationW(&fileOp)==0 ? S_OK : E_FAIL);
 
        if(flags & KF_REDIRECT_DEL_SOURCE_CONTENTS)
        {
            ZeroMemory(srcPath, sizeof(srcPath));
            lstrcpyW(srcPath, lpSrcPath);
 
            ZeroMemory(&fileOp, sizeof(fileOp));
            fileOp.wFunc = FO_DELETE;
            fileOp.pFrom = srcPath;
            fileOp.fFlags = FOF_NO_UI;
 
            hr = (SHFileOperationW(&fileOp)==0 ? S_OK : E_FAIL);
        }
    }
 
    CoTaskMemFree(lpSrcPath);
 
    return hr;
}

Referenced by foldermanager_Redirect(), and knownfolder_SetPath().

register_folder()

static HRESULT register_folder ( const KNOWNFOLDERID *  rfid, const KNOWNFOLDER_DEFINITION *  pKFD  )

static

Definition at line 5489 of file shellpath.c.

{
    HRESULT hr;
    HKEY hKey = NULL;
    DWORD dwDisp;
    LPWSTR registryPath = NULL;
 
    hr = get_known_folder_registry_path(rfid, NULL, &registryPath);
    TRACE("registry path: %s\n", debugstr_w(registryPath));
 
    if(SUCCEEDED(hr))
        hr = HRESULT_FROM_WIN32(RegCreateKeyExW(HKEY_LOCAL_MACHINE, registryPath, 0, NULL, 0, KEY_WRITE, 0, &hKey, &dwDisp));
 
    if(SUCCEEDED(hr))
    {
        hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"Category", 0, REG_DWORD, (LPBYTE)&pKFD->category, sizeof(pKFD->category)));
 
        if(SUCCEEDED(hr) && pKFD->dwAttributes != 0)
            hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"Attributes", 0, REG_DWORD, (LPBYTE)&pKFD->dwAttributes, sizeof(pKFD->dwAttributes)));
 
        if(SUCCEEDED(hr))
            hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"Name", 0, REG_SZ, (LPBYTE)pKFD->pszName, (lstrlenW(pKFD->pszName)+1)*sizeof(WCHAR) ));
 
        if(SUCCEEDED(hr) && pKFD->pszParsingName)
            hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"ParsingName", 0, REG_SZ, (LPBYTE)pKFD->pszParsingName, (lstrlenW(pKFD->pszParsingName)+1)*sizeof(WCHAR) ));
 
        if(SUCCEEDED(hr) && !IsEqualGUID(&pKFD->fidParent, &GUID_NULL))
        {
            WCHAR sParentGuid[39];
            StringFromGUID2(&pKFD->fidParent, sParentGuid, ARRAY_SIZE(sParentGuid));
 
            /* this known folder has parent folder */
            hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"ParentFolder", 0, REG_SZ, (LPBYTE)sParentGuid, sizeof(sParentGuid)));
        }
 
        if(SUCCEEDED(hr) && pKFD->category != KF_CATEGORY_VIRTUAL && pKFD->pszRelativePath)
            hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"RelativePath", 0, REG_SZ, (LPBYTE)pKFD->pszRelativePath, (lstrlenW(pKFD->pszRelativePath)+1)*sizeof(WCHAR) ));
 
        RegCloseKey(hKey);
 
        if(FAILED(hr))
            SHDeleteKeyW(HKEY_LOCAL_MACHINE, registryPath);
    }
 
    free(registryPath);
    return hr;
}

Referenced by foldermanager_RegisterFolder(), and register_system_knownfolders().

register_system_knownfolders()

static void register_system_knownfolders ( void  )

static

Definition at line 5727 of file shellpath.c.

{
    int i;
 
    for (i = 0; i < ARRAY_SIZE(CSIDL_Data); ++i)
    {
        const CSIDL_DATA *folder = &CSIDL_Data[i];
        if(folder->name){
            KNOWNFOLDER_DEFINITION kfd;
 
            /* register_folder won't modify kfd, so cast away const instead of
             * reallocating */
            kfd.category         = folder->category;
            kfd.pszName          = (WCHAR *)folder->name;
            kfd.pszDescription   = NULL;
            kfd.fidParent        = folder->parent ? *folder->parent : GUID_NULL;
            kfd.pszRelativePath  = (WCHAR *)folder->path;
            kfd.pszParsingName   = (WCHAR *)folder->parsing;
            kfd.pszTooltip       = NULL;
            kfd.pszLocalizedName = NULL;
            kfd.pszIcon          = NULL;
            kfd.pszSecurity      = NULL;
            kfd.dwAttributes     = folder->attributes;
            kfd.kfdFlags         = folder->flags;
            kfd.ftidType         = folder->typeid ? *folder->typeid : GUID_NULL;
            register_folder(folder->id, &kfd);
        }
    }
}

Referenced by SHELL_RegisterShellFolders().

set_folder_attributes()

static HRESULT set_folder_attributes ( void  )

static

Definition at line 4318 of file shellpath.c.

{
    static const struct
    {
        const CLSID *clsid;
        unsigned int wfparsing : 1;
        unsigned int wfdisplay : 1;
        unsigned int hideasdel : 1;
        DWORD attr;
        DWORD call_for_attr;
    } folders[] =
    {
#ifndef __REACTOS__
        { &CLSID_UnixFolder, TRUE, FALSE, FALSE },
        { &CLSID_UnixDosFolder, TRUE, FALSE, FALSE,
          SFGAO_FILESYSANCESTOR|SFGAO_FOLDER|SFGAO_HASSUBFOLDER, SFGAO_FILESYSTEM },
#endif
        { &CLSID_FolderShortcut, FALSE, FALSE, FALSE,
          SFGAO_FILESYSTEM|SFGAO_FOLDER|SFGAO_LINK,
          SFGAO_HASSUBFOLDER|SFGAO_FILESYSTEM|SFGAO_FOLDER|SFGAO_FILESYSANCESTOR },
        { &CLSID_MyDocuments, TRUE, FALSE, FALSE,
          SFGAO_FILESYSANCESTOR|SFGAO_FOLDER|SFGAO_HASSUBFOLDER, SFGAO_FILESYSTEM },
        { &CLSID_RecycleBin, FALSE, FALSE, FALSE,
          SFGAO_FOLDER|SFGAO_DROPTARGET|SFGAO_HASPROPSHEET },
        { &CLSID_ControlPanel, FALSE, TRUE, TRUE,
          SFGAO_FOLDER|SFGAO_HASSUBFOLDER },
        { &CLSID_Printers, FALSE, FALSE, FALSE,
          SFGAO_FOLDER|SFGAO_CANLINK }
    };
 
    unsigned int i;
    WCHAR buffer[39 + ARRAY_SIZE(L"CLSID\\") + ARRAY_SIZE(L"\\ShellFolder")];
    LONG res;
    HKEY hkey;
 
    for (i = 0; i < ARRAY_SIZE(folders); i++)
    {
        lstrcpyW( buffer, L"CLSID\\" );
        StringFromGUID2( folders[i].clsid, buffer + lstrlenW(buffer), 39 );
        lstrcatW( buffer, L"\\ShellFolder" );
        res = RegCreateKeyExW( HKEY_CLASSES_ROOT, buffer, 0, NULL, 0,
                               KEY_READ | KEY_WRITE, NULL, &hkey, NULL);
        if (res) return HRESULT_FROM_WIN32( res );
        if (folders[i].wfparsing)
            res = RegSetValueExW( hkey, L"WantsFORPARSING", 0, REG_SZ, (const BYTE *)L"", sizeof(WCHAR) );
        if (folders[i].wfdisplay)
            res = RegSetValueExW( hkey, L"WantsFORDISPLAY", 0, REG_SZ, (const BYTE *)L"", sizeof(WCHAR) );
        if (folders[i].hideasdel)
            res = RegSetValueExW( hkey, L"HideAsDeletePerUser", 0, REG_SZ, (const BYTE *)L"", sizeof(WCHAR) );
        if (folders[i].attr)
            res = RegSetValueExW( hkey, L"Attributes", 0, REG_DWORD,
                                  (const BYTE *)&folders[i].attr, sizeof(DWORD));
        if (folders[i].call_for_attr)
            res = RegSetValueExW( hkey, L"CallForAttributes", 0, REG_DWORD,
                                 (const BYTE *)&folders[i].call_for_attr, sizeof(DWORD));
        RegCloseKey( hkey );
    }
    return S_OK;
}

Referenced by SHELL_RegisterShellFolders().

SHELL_RegisterShellFolders()

HRESULT SHELL_RegisterShellFolders

(

void

)

Definition at line 5757 of file shellpath.c.

{
    HRESULT hr;
 
    hr = _SHRegisterUserShellFolders(TRUE);
    if (SUCCEEDED(hr))
        hr = _SHRegisterUserShellFolders(FALSE);
    if (SUCCEEDED(hr))
        hr = _SHRegisterCommonShellFolders();
#ifndef __REACTOS__
    if (SUCCEEDED(hr))
        hr = create_extra_folders();
#endif
    if (SUCCEEDED(hr))
        hr = set_folder_attributes();
    if (SUCCEEDED(hr))
        register_system_knownfolders();
    return hr;
}

Referenced by DllRegisterServer().

SHGetFolderLocation()

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

Definition at line 4467 of file shellpath.c.

{
    HRESULT hr = E_INVALIDARG;
#ifdef __REACTOS__
    WCHAR szPath[MAX_PATH];
#endif
 
    TRACE("%p 0x%08x %p 0x%08lx %p\n",
     hwndOwner, nFolder, hToken, dwReserved, ppidl);
    
    if (!ppidl)
        return E_INVALIDARG;
    if (dwReserved)
        return E_INVALIDARG;
 
#ifdef __REACTOS__
    if ((nFolder & CSIDL_FLAG_NO_ALIAS) &&
        SHGetSpecialFolderPathW(hwndOwner, szPath, (nFolder & CSIDL_FOLDER_MASK), FALSE))
    {
        *ppidl = ILCreateFromPathW(szPath);
        if (*ppidl)
            return S_OK;
    }
#endif
    /* 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;
 
#ifdef __REACTOS__
        case CSIDL_CONNECTIONS:
            hr = SHGetFolderLocationHelper(hwndOwner, CSIDL_CONTROLS, &CLSID_NetworkConnections, ppidl);
            break;
#endif
 
        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(), CShellMenuCallback::AddStartMenuItems(), BrFolder_OnInitDialog(), LoadRdpSettingsFromFile(), loadShell32(), SaveRdpSettingsToFile(), SHCreateFromDesktop(), SHELL32_ReparentAsAliasPidl(), CDesktopFolder::ShellUrlParseDisplayName(), SHEmptyRecycleBinW(), SHGetSpecialFolderLocation(), START_TEST(), TestCommandLine(), and TestCompareIDList().

SHGetFolderPathA()

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

Definition at line 4048 of file shellpath.c.

{
    WCHAR szTemp[MAX_PATH];
    HRESULT hr;
 
    TRACE("%p,%d,%p,%#lx,%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 ini_absent(), ini_present(), loadShell32(), pf_exists(), ppc_present(), 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 3829 of file shellpath.c.

{
    int length;
    HRESULT hr = S_OK;
    LPWSTR pszSubPathW = NULL;
    LPWSTR pszPathW = NULL;
 
    TRACE("%p,%#x,%p,%#lx,%s,%p\n", hwndOwner, nFolder, hToken, dwFlags, debugstr_a(pszSubPath), pszPath);
 
    if(pszPath) {
        pszPathW = malloc(MAX_PATH * sizeof(WCHAR));
        if(!pszPathW) {
            hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
            goto cleanup;
        }
    }
    TRACE("%08x,%08lx,%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 = malloc(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:
    free(pszPathW);
    free(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 3881 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,%#lx,%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);
            append_relative_path(folder, szTemp);
            hr = S_OK;
            break;
        case CSIDL_Type_SystemPath:
            GetSystemDirectoryW(szTemp, MAX_PATH);
            append_relative_path(folder, szTemp);
            hr = S_OK;
            break;
        case CSIDL_Type_SystemX86Path:
            if (!GetSystemWow64DirectoryW(szTemp, MAX_PATH)) GetSystemDirectoryW(szTemp, MAX_PATH);
            append_relative_path(folder, szTemp);
            hr = S_OK;
            break;
        case CSIDL_Type_CurrVer:
            hr = _SHGetCurrentVersionPath(dwFlags, folder, szTemp);
            break;
        case CSIDL_Type_User:
            hr = _SHGetUserProfilePath(hToken, dwFlags, folder, szTemp);
            break;
        case CSIDL_Type_AllUsers:
        case CSIDL_Type_ProgramData:
            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
        lstrcpyW(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)
        lstrcpyW(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;
    }
 
#ifndef __REACTOS__
    /* create symbolic links rather than directories for specific
     * user shell folders */
    if (!pszSubPath)
        _SHCreateSymbolicLink(folder, szBuildPath);
#endif
 
    /* 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:
#ifdef __REACTOS__
    /* create desktop.ini for custom icon */
    if ((nFolder & CSIDL_FLAG_CREATE) &&
        CSIDL_Data[folder].nShell32IconIndex)
    {
        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),
                         L"%%SystemRoot%%\\system32\\shell32.dll,%d",
                         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);
    }
#endif
    TRACE("returning 0x%08lx (final path is %s)\n", hr, debugstr_w(szBuildPath));
    return hr;
}

Referenced by CBandSiteMenu::_GetQLaunchPidl(), create_extra_folders(), CreateShortcuts(), SHGetFolderPathAndSubDirA(), SHGetFolderPathW(), SHGetKnownFolderPath(), and ThemePageDlgProc().

SHGetFolderPathEx()

HRESULT WINAPI SHGetFolderPathEx	(	REFKNOWNFOLDERID	rfid,
		DWORD	flags,
		HANDLE	token,
		LPWSTR	path,
		DWORD	len
	)

Definition at line 4648 of file shellpath.c.

{
    HRESULT hr;
    WCHAR *buffer;
 
    TRACE("%s, 0x%08lx, %p, %p, %lu\n", debugstr_guid(rfid), flags, token, path, len);
 
    if (!path || !len) return E_INVALIDARG;
 
    hr = SHGetKnownFolderPath( rfid, flags, token, &buffer );
    if (SUCCEEDED( hr ))
    {
        if (lstrlenW( buffer ) + 1 > len)
        {
            CoTaskMemFree( buffer );
            return HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER );
        }
        lstrcpyW( path, buffer );
        CoTaskMemFree( buffer );
    }
    return hr;
}

Referenced by loadShell32().

SHGetFolderPathW()

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

Definition at line 3816 of file shellpath.c.

{
    HRESULT hr =  SHGetFolderPathAndSubDirW(hwndOwner, nFolder, hToken, dwFlags, NULL, pszPath);
    if(HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) == hr)
        hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
    return hr;
}

Referenced by _PathFindInFolder(), _PathMatchesSuspicious(), _SHRegisterFolders(), AutoStartupApplications(), BrFolder_NewFolder(), CJournaledTestList::CJournaledTestList(), create_ie_menu(), create_profile_directory(), CreateObjectsFromPersistFolder(), DllRegisterServer(), FILEDLG95_InitControls(), format_filelist_filename(), GetDefaultDownloadDirectory(), GetDefaultUserSendTo(), Initialize(), CFontExt::Initialize(), LoadThemes(), OnAddStartMenuItems(), OnAdvancedStartMenuItems(), OnBrowseButton(), RecentHasShortcut(), RegisterTypeLibraries(), set_installer_properties(), Settings_GetOutputPath(), RegistrySettings::SetWallpaper(), SHGetFolderLocation(), SHGetFolderPathA(), SHGetSpecialFolderPathW(), test_namespace(), TestDefaultFormat(), TestNameSpaceFolder(), and testRegStoreSavedCerts().

SHGetKnownFolderIDList()

HRESULT WINAPI SHGetKnownFolderIDList	(	REFKNOWNFOLDERID	rfid,
		DWORD	flags,
		HANDLE	token,
		PIDLIST_ABSOLUTE *	pidl
	)

Definition at line 5661 of file shellpath.c.

{
    TRACE("%s, 0x%08lx, %p, %p\n", debugstr_guid(rfid), flags, token, pidl);
 
    if (!pidl)
        return E_INVALIDARG;
 
    if (flags)
        FIXME("unsupported flags: 0x%08lx\n", flags);
 
    if (token)
        FIXME("user token is not used.\n");
 
    *pidl = NULL;
    if (IsEqualIID(rfid, &FOLDERID_Desktop))
        *pidl = _ILCreateDesktop();
    else if (IsEqualIID(rfid, &FOLDERID_RecycleBinFolder))
        *pidl = _ILCreateBitBucket();
    else if (IsEqualIID(rfid, &FOLDERID_ComputerFolder))
        *pidl = _ILCreateMyComputer();
    else if (IsEqualIID(rfid, &FOLDERID_PrintersFolder))
        *pidl = _ILCreatePrinters();
    else if (IsEqualIID(rfid, &FOLDERID_ControlPanelFolder))
        *pidl = _ILCreateControlPanel();
    else if (IsEqualIID(rfid, &FOLDERID_NetworkFolder))
        *pidl = _ILCreateNetwork();
    else if (IsEqualIID(rfid, &FOLDERID_Documents))
        *pidl = _ILCreateMyDocuments();
    else
    {
        DWORD attributes = 0;
        WCHAR *pathW;
        HRESULT hr;
 
        hr = SHGetKnownFolderPath(rfid, flags, token, &pathW);
        if (FAILED(hr))
            return hr;
 
        hr = SHILCreateFromPathW(pathW, pidl, &attributes);
        CoTaskMemFree(pathW);
        return hr;
    }
 
    return *pidl ? S_OK : E_FAIL;
}

Referenced by knownfolder_GetIDList(), loadShell32(), SHCreateItemInKnownFolder(), and SHGetKnownFolderItem().

SHGetKnownFolderItem()

HRESULT WINAPI SHGetKnownFolderItem	(	REFKNOWNFOLDERID	rfid,
		KNOWN_FOLDER_FLAG	flags,
		HANDLE	hToken,
		REFIID	riid,
		void **	ppv
	)

Definition at line 5707 of file shellpath.c.

{
    PIDLIST_ABSOLUTE pidl;
    HRESULT hr;
 
    TRACE("%s, 0x%08x, %p, %s, %p\n", debugstr_guid(rfid), flags, hToken, debugstr_guid(riid), ppv);
 
    hr = SHGetKnownFolderIDList(rfid, flags, hToken, &pidl);
    if (FAILED(hr))
    {
        *ppv = NULL;
        return hr;
    }
 
    hr = SHCreateItemFromIDList(pidl, riid, ppv);
    CoTaskMemFree(pidl);
    return hr;
}

Referenced by knownfolder_GetShellItem().

SHGetKnownFolderPath()

HRESULT WINAPI SHGetKnownFolderPath	(	REFKNOWNFOLDERID	rfid,
		DWORD	flags,
		HANDLE	token,
		WCHAR **	ret_path
	)

Definition at line 4593 of file shellpath.c.

{
    WCHAR pathW[MAX_PATH];
    HRESULT    hr;
    int folder = csidl_from_id(rfid), shgfp_flags;
 
    TRACE("%s, 0x%08lx, %p, %p\n", debugstr_guid(rfid), flags, token, ret_path);
 
    *ret_path = NULL;
 
    if (folder < 0)
        return HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND );
 
    if (flags & ~(KF_FLAG_CREATE|KF_FLAG_SIMPLE_IDLIST|KF_FLAG_DONT_UNEXPAND|
        KF_FLAG_DONT_VERIFY|KF_FLAG_NO_ALIAS|KF_FLAG_INIT|KF_FLAG_DEFAULT_PATH|KF_FLAG_NOT_PARENT_RELATIVE))
    {
        FIXME("flags 0x%08lx not supported\n", flags);
        return E_INVALIDARG;
    }
 
    if ((flags & (KF_FLAG_DEFAULT_PATH | KF_FLAG_NOT_PARENT_RELATIVE)) == KF_FLAG_NOT_PARENT_RELATIVE)
    {
        WARN("Invalid flags mask %#lx.\n", flags);
        return E_INVALIDARG;
    }
 
    if (flags & KF_FLAG_NOT_PARENT_RELATIVE)
    {
        FIXME("Ignoring KF_FLAG_NOT_PARENT_RELATIVE.\n");
        flags &= ~KF_FLAG_NOT_PARENT_RELATIVE;
    }
 
    folder |= flags & CSIDL_FLAG_MASK;
    shgfp_flags = flags & KF_FLAG_DEFAULT_PATH ? SHGFP_TYPE_DEFAULT : SHGFP_TYPE_CURRENT;
 
    hr = SHGetFolderPathAndSubDirW( 0, folder, token, shgfp_flags, NULL, pathW );
    if (FAILED( hr ))
    {
        TRACE("Failed to get folder path, %#lx.\n", hr);
        return hr;
    }
 
    TRACE("Final path is %s, %#lx\n", debugstr_w(pathW), hr);
 
    *ret_path = CoTaskMemAlloc((lstrlenW(pathW) + 1) * sizeof(WCHAR));
    if (!*ret_path)
        return E_OUTOFMEMORY;
    lstrcpyW(*ret_path, pathW);
 
    return hr;
}

Referenced by get_known_folder_path_by_id(), init_function_pointers(), loadShell32(), open_cached_revocation_file(), SHGetFolderPathEx(), and SHGetKnownFolderIDList().

SHGetSpecialFolderLocation()

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

Definition at line 4574 of file shellpath.c.

{
    HRESULT hr = E_INVALIDARG;
 
    TRACE("(%p,0x%x,%p)\n", hwndOwner,nFolder,ppidl);
 
    if (!ppidl)
        return E_INVALIDARG;
 
    hr = SHGetFolderLocation(hwndOwner, nFolder, NULL, 0, ppidl);
    return hr;
}

Referenced by _GetDocumentsPidl(), CShellMenuCallback::AddOrSetMenuItem(), CreateFolder2Instance(), DoGetPidl(), DoInitAliasPIDLs(), DoTestEntry(), DynamicSHGetSpecialFolderPathW(), ebrowser_browse_to_desktop(), FILEDLG95_InitControls(), FILEDLG95_LOOKIN_Init(), FILEDLG95_OnWMCommand(), filedlg_collect_places_pidls(), GetFavoritesFolder(), GetFavsLocation(), GetMergedFolder(), GetParsingName(), CSendToMenu::GetSpecialFolder(), CSearchBar::Invoke(), CFontBackgroundMenu::InvokeCommand(), IShellBrowserImpl_Construct(), loadShell32(), MRUList_PidlList_0(), CACListISF::NextLocation(), CShellMenuCallback::OnGetContextMenu(), PidlBrowse(), CAddressEditBox::PopulateComboBox(), CShellBrowser::RelayCommands(), RSHELL_CStartMenu_CreateInstance(), SHAddToRecentDocs(), SHCloneSpecialIDList(), Shell_ParsePrinterName(), SHELL_ShowItemIDListProperties(), SHExplorerParseCmdLine(), CRecycleBinCleaner::ShowProperties(), START_TEST(), test_ACListISF_FAVORITES(), test_ACListISF_MYCOMPUTER(), test_get_file_info_iconlist(), test_namespace(), test_parameters(), test_printers_folder(), test_SHCreateShellItem(), test_SHCreateShellItemArray(), test_ShellItemBindToHandler(), test_ShellItemGetAttributes(), test_SHGetIDListFromObject(), test_SHGetNameFromIDList(), test_SHGetPathFromIDList(), VariantToIdlist(), and WshCollection_Item().

SHGetSpecialFolderPathA()

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

Definition at line 4381 of file shellpath.c.

{
    return SHGetFolderPathA(hwndOwner, nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0), NULL, 0,
                            szPath) == S_OK;
}

Referenced by get_cache_path(), init_strings(), loadShell32(), main(), SHGetSpecialFolderPathAW(), test_BindToObject(), test_find_file(), and test_GetDisplayName().

SHGetSpecialFolderPathAW()

BOOL WINAPI SHGetSpecialFolderPathAW	(	HWND	hwndOwner,
		LPVOID	szPath,
		int	nFolder,
		BOOL	bCreate
	)

Definition at line 4433 of file shellpath.c.

{
    if (SHELL_OsIsUnicode())
      return SHGetSpecialFolderPathW (hwndOwner, szPath, nFolder, bCreate);
    return SHGetSpecialFolderPathA (hwndOwner, szPath, nFolder, bCreate);
}

SHGetSpecialFolderPathW()

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

Definition at line 4394 of file shellpath.c.

{
    return SHGetFolderPathW(hwndOwner, nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0), NULL, 0,
                            szPath) == S_OK;
}

Referenced by AddUrlToFavorites(), cache_containers_init(), CreateSendToMyDocuments(), delhist_on_command(), DoBuildFilesAndDirs(), DoGetPidl(), CCopyMoveToMenu::DoRealFileOp(), CMyDocsDropHandler::Drop(), CDeskLinkDropHandler::Drop(), CDesktopFolder::FinalConstruct(), get_csidl_dir(), GetDesktopLocations(), GetFsPathFromIDList(), GetSpecialPath(), GetStorageDirectory(), CFSFolder::InitializeEx(), InitPropertyBag_IPropertyBag_Read(), IsPidlPrograms(), CDesktopFolderViewCB::MessageSFVCB(), CShellMenuCallback::OnExec(), profile_items_callback(), SHAddToRecentDocs(), SHGetFolderLocation(), SHGetSpecialFolderPathAW(), START_TEST(), test_FolderShortcut(), test_ITEMIDLIST_format(), test_ParseDisplayName(), test_SHCreateShellItemArray(), and test_SHGetPathFromIDList().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)

Variable Documentation

ApplicationDestinationsVtbl

const IApplicationDestinationsVtbl ApplicationDestinationsVtbl

static

Initial value:

=
{
    ApplicationDestinations_QueryInterface,
    ApplicationDestinations_AddRef,
    ApplicationDestinations_Release,
    ApplicationDestinations_SetAppID,
    ApplicationDestinations_RemoveDestination,
    ApplicationDestinations_RemoveAllDestinations
}

Definition at line 1662 of file shellpath.c.

Referenced by ApplicationDestinations_Constructor().

ApplicationDocumentListsVtbl

const IApplicationDocumentListsVtbl ApplicationDocumentListsVtbl

static

Initial value:

=
{
    ApplicationDocumentLists_QueryInterface,
    ApplicationDocumentLists_AddRef,
    ApplicationDocumentLists_Release,
    ApplicationDocumentLists_SetAppID,
    ApplicationDocumentLists_GetList
}

Definition at line 1775 of file shellpath.c.

Referenced by ApplicationDocumentLists_Constructor().

CSIDL_Data

const CSIDL_DATA CSIDL_Data[]

static

Definition at line 1826 of file shellpath.c.

Referenced by _SHGetAllUsersProfilePath(), _SHGetCurrentVersionPath(), _SHGetDefaultValue(), _SHGetUserProfilePath(), _SHRegisterFolders(), append_relative_path(), csidl_from_id(), foldermanager_create(), foldermanager_FolderIdFromCsidl(), register_system_knownfolders(), and SHGetFolderPathAndSubDirW().

foldermanager_vtbl

const struct IKnownFolderManagerVtbl foldermanager_vtbl

static

Initial value:

=
{
    foldermanager_QueryInterface,
    foldermanager_AddRef,
    foldermanager_Release,
    foldermanager_FolderIdFromCsidl,
    foldermanager_FolderIdToCsidl,
    foldermanager_GetFolderIds,
    foldermanager_GetFolder,
    foldermanager_GetFolderByName,
    foldermanager_RegisterFolder,
    foldermanager_UnregisterFolder,
    foldermanager_FindFolderFromPath,
    foldermanager_FindFolderFromIDList,
    foldermanager_Redirect
}

Definition at line 5595 of file shellpath.c.

Referenced by foldermanager_create().

is_win64

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

static

Definition at line 92 of file shellpath.c.

Referenced by _SHGetCurrentVersionPath(), and _SHGetDefaultValue().

knownfolder_vtbl

const struct IKnownFolderVtbl knownfolder_vtbl

static

Initial value:

=
{
    knownfolder_QueryInterface,
    knownfolder_AddRef,
    knownfolder_Release,
    knownfolder_GetId,
    knownfolder_GetCategory,
    knownfolder_GetShellItem,
    knownfolder_GetPath,
    knownfolder_SetPath,
    knownfolder_GetIDList,
    knownfolder_GetFolderType,
    knownfolder_GetRedirectionCapabilities,
    knownfolder_GetFolderDefinition
}

Definition at line 5244 of file shellpath.c.

Referenced by knownfolder_create().

xdg_config

char* xdg_config

static

Definition at line 3621 of file shellpath.c.

Referenced by get_xdg_path(), and init_xdg_dirs().

xdg_config_len

DWORD xdg_config_len

static

Definition at line 3622 of file shellpath.c.

Referenced by get_xdg_path(), and init_xdg_dirs().