shellpath.c File Reference

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

Include dependency graph for shellpath.c:

Go to the source code of this file.

Classes
struct	CSIDL_DATA

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COBJMACROS
#define	_WIN32_WINNT   _WIN32_WINNT_WS03
#define	VALID_SHORT_PATH_CHAR_CLASSES
#define	MSDOS_8DOT3_LEN   12 /* MS-DOS 8.3 filename == length 12 */
#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 _NT_PRODUCT_TYPE	NT_PRODUCT_TYPE
typedef enum _NT_PRODUCT_TYPE *	PNT_PRODUCT_TYPE
typedef enum _CSIDL_Type	CSIDL_Type

Enumerations
enum	_NT_PRODUCT_TYPE {   NtProductWinNt = 1 , NtProductLanManNt , NtProductServer , NtProductWinNt = 1 ,   NtProductLanManNt , NtProductServer , NtProductWinNt = 1 , NtProductLanManNt ,   NtProductServer }
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)
static BOOL	DoGetProductType (PNT_PRODUCT_TYPE ProductType)
BOOL APIENTRY	IsRemovableDrive (DWORD iDrive)
static BOOL WINAPI	PathSearchOnExtensionsW (_Inout_ LPWSTR pszPath, _In_opt_ LPCWSTR *ppszDirs, _In_ BOOL bDoSearch, _In_ DWORD dwWhich)
static BOOL WINAPI	PathIsAbsoluteW (_In_ LPCWSTR path)
static BOOL WINAPI	PathMakeAbsoluteW (_Inout_ LPWSTR path)
BOOL WINAPI	IsLFNDriveW (LPCWSTR lpszPath)
static VOID WINAPI	PathQualifyExW (_Inout_ LPWSTR pszPath, _Inout_opt_ LPCWSTR pszDir, _In_ DWORD dwFlags)
BOOL WINAPI	PathAppendAW (LPVOID lpszPath1, LPCVOID lpszPath2)
static LPSTR	PathGetExtensionA (LPCSTR lpszPath)
static LPWSTR	PathGetExtensionW (LPCWSTR lpszPath)
LPVOID WINAPI	SHPathGetExtensionW (LPCWSTR lpszPath, DWORD void1, DWORD void2)
BOOL WINAPI	PathRemoveFileSpecAW (LPVOID lpszPath)
static void	PathGetShortPathA (LPSTR pszPath)
static void	PathGetShortPathW (LPWSTR pszPath)
VOID WINAPI	PathGetShortPathAW (LPVOID pszPath)
BOOL WINAPI	PathIsRootAW (LPCVOID lpszPath)
static BOOL	PathIsExeA (LPCSTR lpszPath)
BOOL	PathIsExeW (LPCWSTR lpszPath)
BOOL WINAPI	PathIsExeAW (LPCVOID path)
BOOL WINAPI	PathFileExistsAW (LPCVOID lpszPath)
BOOL WINAPI	IsLFNDriveA (LPCSTR lpszPath)
BOOL WINAPI	IsLFNDriveAW (LPCVOID lpszPath)
static BOOL	PathMakeUniqueNameA (LPSTR lpszBuffer, DWORD dwBuffSize, LPCSTR lpszShortName, LPCSTR lpszLongName, LPCSTR lpszPathName)
static BOOL	PathMakeUniqueNameW (LPWSTR lpszBuffer, DWORD dwBuffSize, LPCWSTR lpszShortName, LPCWSTR lpszLongName, LPCWSTR lpszPathName)
BOOL WINAPI	PathMakeUniqueNameAW (LPVOID lpszBuffer, DWORD dwBuffSize, LPCVOID lpszShortName, LPCVOID lpszLongName, LPCVOID lpszPathName)
BOOL WINAPI	PathYetAnotherMakeUniqueName (LPWSTR buffer, LPCWSTR path, LPCWSTR shortname, LPCWSTR longname)
int WINAPI	PathCleanupSpec (LPCWSTR lpszPathW, LPWSTR lpszFileW)
VOID WINAPI	PathQualifyA (LPSTR pszPath)
VOID WINAPI	PathQualifyW (LPWSTR pszPath)
VOID WINAPI	PathQualifyAW (LPVOID pszPath)
BOOL WINAPI	PathResolveA (LPSTR path, LPCSTR *dirs, DWORD flags)
BOOL WINAPI	PathResolveW (_Inout_ LPWSTR path, _Inout_opt_ LPCWSTR *dirs, _In_ DWORD flags)
BOOL WINAPI	PathResolveAW (LPVOID path, LPCVOID *paths, DWORD flags)
static LONG	PathProcessCommandA (LPCSTR lpszPath, LPSTR lpszBuff, DWORD dwBuffSize, DWORD dwFlags)
static LONG	PathProcessCommandW (LPCWSTR lpszPath, LPWSTR lpszBuff, DWORD dwBuffSize, DWORD dwFlags)
LONG WINAPI	PathProcessCommandAW (LPCVOID lpszPath, LPVOID lpszBuff, DWORD dwBuffSize, DWORD dwFlags)
INT	SHGetSpecialFolderID (_In_ LPCWSTR pszName)
INT	Shell_ParseSpecialFolder (_In_ LPCWSTR pszStart, _Out_ LPWSTR *ppch, _Out_ INT *pcch)
static HRESULT	_SHExpandEnvironmentStrings (LPCWSTR szSrc, LPWSTR szDest)
static HRESULT	_SHGetUserShellFolderPath (HKEY rootKey, LPCWSTR userPrefix, LPCWSTR value, LPWSTR path)
BOOL	_SHGetUserProfileDirectoryW (HANDLE hToken, LPWSTR szPath, LPDWORD lpcchPath)
static HRESULT	_SHGetDefaultValue (BYTE folder, LPWSTR pszPath)
static HRESULT	_SHGetCurrentVersionPath (DWORD dwFlags, BYTE folder, LPWSTR pszPath)
static LPWSTR	_GetUserSidStringFromToken (HANDLE Token)
static HRESULT	_SHGetUserProfilePath (HANDLE hToken, DWORD dwFlags, BYTE folder, LPWSTR pszPath)
static HRESULT	_SHGetAllUsersProfilePath (DWORD dwFlags, BYTE folder, LPWSTR pszPath)
static HRESULT	_SHOpenProfilesKey (PHKEY pKey)
static HRESULT	_SHGetProfilesValue (HKEY profilesKey, LPCWSTR szValueName, LPWSTR szValue, LPCWSTR szDefault)
HRESULT WINAPI	SHGetFolderPathW (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath)
HRESULT WINAPI	SHGetFolderPathAndSubDirA (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPCSTR pszSubPath, LPSTR pszPath)
HRESULT WINAPI	SHGetFolderPathAndSubDirW (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPCWSTR pszSubPath, LPWSTR pszPath)
HRESULT WINAPI	SHGetFolderPathA (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPSTR pszPath)
static HRESULT	_SHRegisterFolders (HKEY hRootKey, HANDLE hToken, LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[], UINT foldersLen)
static HRESULT	_SHRegisterUserShellFolders (BOOL bDefault)
static HRESULT	_SHRegisterCommonShellFolders (void)
HRESULT	SHELL_RegisterShellFolders (void)
BOOL WINAPI	SHGetSpecialFolderPathA (HWND hwndOwner, LPSTR szPath, int nFolder, BOOL bCreate)
BOOL WINAPI	SHGetSpecialFolderPathW (HWND hwndOwner, LPWSTR szPath, int nFolder, BOOL bCreate)
HRESULT WINAPI	SHGetFolderLocation (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwReserved, LPITEMIDLIST *ppidl)
HRESULT WINAPI	SHGetSpecialFolderLocation (HWND hwndOwner, INT nFolder, LPITEMIDLIST *ppidl)

Variables
static const BOOL	is_win64 = sizeof(void *) > sizeof(int)
static const WCHAR	Application_DataW [] = L"Application Data"
static const WCHAR	Local_Settings_Application_DataW [] = L"Local Settings\\Application Data"
static const WCHAR	Local_Settings_HistoryW [] = L"Local Settings\\History"
static const WCHAR	Local_Settings_Temporary_Internet_FilesW [] = L"Local Settings\\Temporary Internet Files"
static const WCHAR	MusicW [] = L"Music"
static const WCHAR	PicturesW [] = L"Pictures"
static const WCHAR	Program_FilesW [] = L"Program Files"
static const WCHAR	Program_Files_Common_FilesW [] = L"Program Files\\Common Files"
static const WCHAR	Start_Menu_ProgramsW [] = L"Start Menu\\Programs"
static const WCHAR	Start_Menu_Admin_ToolsW [] = L"Start Menu\\Programs\\Administrative Tools"
static const WCHAR	Start_Menu_StartupW [] = L"Start Menu\\Programs\\StartUp"
static const WCHAR	szSHFolders [] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"
static const WCHAR	szSHUserFolders [] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders"
static const WCHAR	szKnownFolderDescriptions [] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FolderDescriptions"
static const WCHAR	szKnownFolderRedirections [] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders"
static const CSIDL_DATA	CSIDL_Data []

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 29 of file shellpath.c.

_WIN32_WINNT

#define _WIN32_WINNT   _WIN32_WINNT_WS03

Definition at line 55 of file shellpath.c.

COBJMACROS

#define COBJMACROS

Definition at line 30 of file shellpath.c.

CSIDL_APPDATA_LOCALLOW

#define CSIDL_APPDATA_LOCALLOW   0x004e

Definition at line 1212 of file shellpath.c.

CSIDL_CONTACTS

#define CSIDL_CONTACTS   0x0043

Definition at line 1209 of file shellpath.c.

CSIDL_DOWNLOADS

#define CSIDL_DOWNLOADS   0x0047

Definition at line 1210 of file shellpath.c.

CSIDL_LINKS

#define CSIDL_LINKS   0x004d

Definition at line 1211 of file shellpath.c.

CSIDL_SAVED_GAMES

#define CSIDL_SAVED_GAMES   0x0062

Definition at line 1213 of file shellpath.c.

CSIDL_SEARCHES

#define CSIDL_SEARCHES   0x0063

Definition at line 1214 of file shellpath.c.

MSDOS_8DOT3_LEN

#define MSDOS_8DOT3_LEN   12 /* MS-DOS 8.3 filename == length 12 */

VALID_SHORT_PATH_CHAR_CLASSES

#define VALID_SHORT_PATH_CHAR_CLASSES

Value:

    ( \
    PATH_CHAR_CLASS_DOT | \
    PATH_CHAR_CLASS_BACKSLASH | \
    PATH_CHAR_CLASS_COLON | \
    PATH_CHAR_CLASS_OTHER_VALID \
)

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 28 of file shellpath.c.

Typedef Documentation

CSIDL_Type

typedef enum _CSIDL_Type CSIDL_Type

NT_PRODUCT_TYPE

typedef enum _NT_PRODUCT_TYPE NT_PRODUCT_TYPE

PNT_PRODUCT_TYPE

typedef enum _NT_PRODUCT_TYPE * PNT_PRODUCT_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 1192 of file shellpath.c.

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

_NT_PRODUCT_TYPE

enum _NT_PRODUCT_TYPE

Enumerator
NtProductWinNt
NtProductLanManNt
NtProductServer
NtProductWinNt
NtProductLanManNt
NtProductServer
NtProductWinNt
NtProductLanManNt
NtProductServer

Definition at line 62 of file shellpath.c.

{
    NtProductWinNt = 1,
    NtProductLanManNt,
    NtProductServer
} NT_PRODUCT_TYPE, *PNT_PRODUCT_TYPE;

Function Documentation

_GetUserSidStringFromToken()

static LPWSTR _GetUserSidStringFromToken ( HANDLE  Token )

static

Definition at line 2330 of file shellpath.c.

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

Referenced by _SHGetUserProfilePath().

_SHExpandEnvironmentStrings()

static HRESULT _SHExpandEnvironmentStrings ( LPCWSTR  szSrc, LPWSTR  szDest  )

static

Definition at line 2565 of file shellpath.c.

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

Referenced by _SHGetUserShellFolderPath(), and SHGetFolderPathAndSubDirW().

_SHGetAllUsersProfilePath()

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

static

Definition at line 2460 of file shellpath.c.

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

Referenced by _SHRegisterFolders(), and SHGetFolderPathAndSubDirW().

_SHGetCurrentVersionPath()

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

static

Definition at line 2261 of file shellpath.c.

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

Referenced by SHGetFolderPathAndSubDirW().

_SHGetDefaultValue()

static HRESULT _SHGetDefaultValue ( BYTE  folder, LPWSTR  pszPath  )

static

Definition at line 2145 of file shellpath.c.

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

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

_SHGetProfilesValue()

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

static

Definition at line 2515 of file shellpath.c.

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

Referenced by _SHExpandEnvironmentStrings().

_SHGetUserProfileDirectoryW()

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

Definition at line 2109 of file shellpath.c.

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

Referenced by _SHExpandEnvironmentStrings().

_SHGetUserProfilePath()

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

static

Definition at line 2371 of file shellpath.c.

{
    const WCHAR *szValueName;
    WCHAR buffer[40];
    HRESULT hr;
 
    TRACE("%p,0x%08x,0x%02x,%p\n", hToken, dwFlags, folder, pszPath);
 
    if (folder >= ARRAY_SIZE(CSIDL_Data))
        return E_INVALIDARG;
#ifdef __REACTOS__
    if (CSIDL_Data[folder].type != CSIDL_Type_User &&
        CSIDL_Data[folder].type != CSIDL_Type_InMyDocuments)
#else
    if (CSIDL_Data[folder].type != CSIDL_Type_User)
#endif
    {
        return E_INVALIDARG;
    }
    if (!pszPath)
        return E_INVALIDARG;
 
    if (dwFlags & SHGFP_TYPE_DEFAULT)
    {
#ifndef __REACTOS__
        hr = _SHGetDefaultValue(folder, pszPath);
#else
        hr = _SHGetDefaultValue(hToken, folder, pszPath);
#endif
    }
    else
    {
        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].szValueName;
        if (!szValueName)
        {
            StringFromGUID2( CSIDL_Data[folder].id, buffer, 39 );
            szValueName = &buffer[0];
        }
 
#ifndef __REACTOS__
        hr = _SHGetUserShellFolderPath(hRootKey, userPrefix, szValueName, pszPath);
        if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
            hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, NULL, szValueName, pszPath);
        if (FAILED(hr))
            hr = _SHGetDefaultValue(folder, pszPath);
#else
        hr = _SHGetUserShellFolderPath(hRootKey, hToken, userPrefix, szValueName, pszPath);
        if (FAILED(hr) && hRootKey != HKEY_LOCAL_MACHINE)
            hr = _SHGetUserShellFolderPath(HKEY_LOCAL_MACHINE, hToken, NULL, szValueName, pszPath);
        if (FAILED(hr))
            hr = _SHGetDefaultValue(hToken, folder, pszPath);
#endif
        if (userPrefix != NULL && userPrefix != DefaultW)
            LocalFree((HLOCAL) userPrefix);
    }
error:
    TRACE("returning 0x%08x (output path is %s)\n", hr, debugstr_w(pszPath));
    return hr;
}

Referenced by _SHRegisterFolders(), and SHGetFolderPathAndSubDirW().

_SHGetUserShellFolderPath()

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

static

Definition at line 2026 of file shellpath.c.

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

Referenced by _SHGetAllUsersProfilePath(), and _SHGetUserProfilePath().

_SHOpenProfilesKey()

static HRESULT _SHOpenProfilesKey ( PHKEY  pKey )

static

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

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

Referenced by SHELL_RegisterShellFolders().

_SHRegisterFolders()

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

static

Definition at line 2994 of file shellpath.c.

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

Referenced by _SHRegisterCommonShellFolders(), and _SHRegisterUserShellFolders().

_SHRegisterUserShellFolders()

static HRESULT _SHRegisterUserShellFolders ( BOOL  bDefault )

static

Definition at line 3096 of file shellpath.c.

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

Referenced by SHELL_RegisterShellFolders().

DoGetProductType()

static BOOL DoGetProductType ( PNT_PRODUCT_TYPE  ProductType )

static

Definition at line 71 of file shellpath.c.

{
    HKEY hKey;
    LONG error;
    WCHAR szValue[9];
    DWORD cbValue;
    static DWORD s_dwProductType = 0;
 
    if (s_dwProductType != 0)
    {
        *ProductType = s_dwProductType;
        return TRUE;
    }
 
    *ProductType = NtProductServer;
 
    error = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\ProductOptions", 0, KEY_READ, &hKey);
    if (error)
        return FALSE;
 
    cbValue = sizeof(szValue);
    error = RegGetValueW(hKey, NULL, L"ProductType", RRF_RT_REG_SZ, NULL, (PVOID)szValue, &cbValue);
    if (!error)
    {
        if (lstrcmpW(szValue, L"WinNT") == 0)
            *ProductType = NtProductWinNt;
        else if (lstrcmpW(szValue, L"LanmanNT") == 0)
            *ProductType = NtProductLanManNt;
    }
 
    s_dwProductType = *ProductType;
 
    RegCloseKey(hKey);
    return TRUE;
}

Referenced by _SHGetDefaultValue().

IsLFNDriveA()

BOOL WINAPI IsLFNDriveA

(

LPCSTR

lpszPath

)

Definition at line 577 of file shellpath.c.

{
    WCHAR szBuffW[MAX_PATH], *pszW = NULL;
    if (lpszPath)
    {
        SHAnsiToUnicode(lpszPath, szBuffW, _countof(szBuffW));
        pszW = szBuffW;
    }
    return IsLFNDriveW(pszW);
}

Referenced by IsLFNDriveAW().

IsLFNDriveAW()

BOOL WINAPI IsLFNDriveAW

(

LPCVOID

lpszPath

)

Definition at line 639 of file shellpath.c.

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

IsLFNDriveW()

BOOL WINAPI IsLFNDriveW

(

LPCWSTR

lpszPath

)

Definition at line 591 of file shellpath.c.

{
    DWORD cchMaxFileName, iDrive;
    WCHAR szRoot[MAX_PATH];
 
    if (lpszPath == NULL || lpszPath[0] == UNICODE_NULL)
    {
        szRoot[0] = 0;
        GetWindowsDirectoryW(szRoot, _countof(szRoot));
        lpszPath = szRoot;
    }
 
    if (PathIsUNCW(lpszPath))
    {
        StringCchCopyW(szRoot, _countof(szRoot), lpszPath);
        PathStripToRootW(szRoot);
 
        if (StrChrW(szRoot + 2, L'\\') == NULL)
            return TRUE; /* LFN */
 
        StringCchCatW(szRoot, _countof(szRoot), L"\\"); /* Add a backslash */
    }
    else
    {
        iDrive = ((lpszPath[0] - L'A') & 0x1F);
        PathBuildRootW(szRoot, iDrive);
 
        if (!IsRemovableDrive(iDrive))
        {
            /* FIXME: Cache correctly */
        }
    }
 
#define MSDOS_8DOT3_LEN 12 /* MS-DOS 8.3 filename == length 12 */
 
    /* GetVolumeInformation requires a root path */
    if (!GetVolumeInformationW(szRoot, NULL, 0, NULL, &cchMaxFileName, NULL, NULL, 0))
    {
        /* Don't return FALSE when GetVolumeInformationW fails. */
        return TRUE;
    }
 
    return cchMaxFileName > MSDOS_8DOT3_LEN;
}

Referenced by IsLFNDriveA(), IsLFNDriveAW(), and PathQualifyExW().

IsRemovableDrive()

BOOL APIENTRY IsRemovableDrive

(

DWORD

iDrive

)

Definition at line 107 of file shellpath.c.

{
    WCHAR szRoot[] = L"C:\\";
    assert(L'A' + iDrive <= L'Z');
    szRoot[0] = (WCHAR)(L'A' + iDrive);
    return GetDriveTypeW(szRoot) == DRIVE_REMOVABLE;
}

Referenced by IsLFNDriveW().

PathAppendAW()

BOOL WINAPI PathAppendAW	(	LPVOID	lpszPath1,
		LPCVOID	lpszPath2
	)

Definition at line 407 of file shellpath.c.

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

PathCleanupSpec()

int WINAPI PathCleanupSpec	(	LPCWSTR	lpszPathW,
		LPWSTR	lpszFileW
	)

Definition at line 885 of file shellpath.c.

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

Referenced by FinishDlgProc().

PathFileExistsAW()

BOOL WINAPI PathFileExistsAW

(

LPCVOID

lpszPath

)

Definition at line 567 of file shellpath.c.

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

PathGetExtensionA()

static LPSTR PathGetExtensionA ( LPCSTR  lpszPath )

static

Definition at line 423 of file shellpath.c.

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

Referenced by PathIsExeA().

PathGetExtensionW()

static LPWSTR PathGetExtensionW ( LPCWSTR  lpszPath )

static

Definition at line 434 of file shellpath.c.

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

Referenced by PathIsExeW(), and SHPathGetExtensionW().

PathGetShortPathA()

static void PathGetShortPathA ( LPSTR  pszPath )

static

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

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

PathGetShortPathW()

static void PathGetShortPathW ( LPWSTR  pszPath )

static

Definition at line 482 of file shellpath.c.

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

Referenced by PathGetShortPathAW().

PathIsAbsoluteW()

static BOOL WINAPI PathIsAbsoluteW ( _In_ LPCWSTR  path )

static

Definition at line 136 of file shellpath.c.

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

Referenced by PathResolveW().

PathIsExeA()

static BOOL PathIsExeA ( LPCSTR  lpszPath )

static

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

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

PathIsExeW()

BOOL PathIsExeW

(

LPCWSTR

lpszPath

)

Definition at line 539 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 FileTypesDlg_InsertToLV(), FindExecutableW(), COpenWithDialog::Init(), CFileDefExt::InitGeneralPage(), COpenWithMenu::Initialize(), PathIsExeAW(), and SHELL_execute().

PathIsRootAW()

BOOL WINAPI PathIsRootAW

(

LPCVOID

lpszPath

)

Definition at line 511 of file shellpath.c.

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

PathMakeAbsoluteW()

static BOOL WINAPI PathMakeAbsoluteW ( _Inout_ LPWSTR  path )

static

Definition at line 141 of file shellpath.c.

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

Referenced by PathResolveW().

PathMakeUniqueNameA()

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

static

Definition at line 652 of file shellpath.c.

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

Referenced by PathMakeUniqueNameAW().

PathMakeUniqueNameAW()

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

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

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

Referenced by PathMakeUniqueNameAW().

PathProcessCommandA()

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

static

Definition at line 1120 of file shellpath.c.

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

Referenced by PathProcessCommandAW().

PathProcessCommandAW()

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

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

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

Referenced by PathProcessCommandAW().

PathQualifyA()

VOID WINAPI PathQualifyA

(

LPSTR

pszPath

)

Definition at line 957 of file shellpath.c.

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

Referenced by PathQualifyAW().

PathQualifyAW()

VOID WINAPI PathQualifyAW

(

LPVOID

pszPath

)

Definition at line 978 of file shellpath.c.

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

PathQualifyExW()

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

static

Definition at line 158 of file shellpath.c.

{
    INT iDrive, cchPathLeft;
    WCHAR szTemp[MAX_PATH], szRoot[MAX_PATH];
    PWCHAR pchTemp = szTemp, pchPath;
    BOOL bLFN;
 
    TRACE("(%s,%s,0x%08x)\n", debugstr_w(pszPath), debugstr_w(pszDir), dwFlags);
 
    /* Save pszPath path into szTemp for rebuilding the path later */
    if (FAILED(StringCchCopyW(szTemp, _countof(szTemp), pszPath)))
        return;
 
    /* Replace every '/' by '\' */
    FixSlashesAndColonW(szTemp);
 
    cchPathLeft = MAX_PATH;
 
    /* Build the root-like path on pszPath, and set pchTemp */
    if (!PathIsUNCW(szTemp))
    {
        /*
         * Non-UNC path.
         * Determine and normalize the root drive.
         */
        iDrive = PathGetDriveNumberW(szTemp);
        if (iDrive == -1)
        {
            /*
             * No drive was specified in the path. Try to find one from the
             * optional directory (if this fails, fall back to the one of the
             * Windows directory).
             */
            if (!pszDir || FAILED(StringCchCopyW(szRoot, _countof(szRoot), pszDir)))
            {
                /* pszDir was invalid or NULL. Fall back to the
                 * Windows directory and find its root. */
                szRoot[0] = UNICODE_NULL;
                GetWindowsDirectoryW(szRoot, _countof(szRoot));
                iDrive = PathGetDriveNumberW(szRoot);
                if (iDrive != -1)
                    PathBuildRootW(szRoot, iDrive);
            }
 
            if (szTemp[0] == L'\\')
            {
                PathStripToRootW(szRoot);
            }
        }
        else
        {
            /*
             * A drive is specified in the path, that can be either of the
             * form 'C:\xxx' or of the form 'C:xxx' (relative path). Isolate
             * the root part 'C:' and the rest of the path 'xxx' in pchTemp.
             */
            PathBuildRootW(szRoot, iDrive);
            pchTemp += 2;
            if (*pchTemp == L'\\')
                ++pchTemp;
        }
 
        bLFN = IsLFNDriveW(szRoot);
        if (!bLFN)
        {
            PWCHAR pch;
            for (pch = pchTemp; *pch != UNICODE_NULL; ++pch)
            {
#define VALID_SHORT_PATH_CHAR_CLASSES ( \
    PATH_CHAR_CLASS_DOT | \
    PATH_CHAR_CLASS_BACKSLASH | \
    PATH_CHAR_CLASS_COLON | \
    PATH_CHAR_CLASS_OTHER_VALID \
)
                if (!PathIsValidCharW(*pch, VALID_SHORT_PATH_CHAR_CLASSES))
                {
                    *pch = L'_';
                }
            }
        }
 
        StringCchCopyW(pszPath, MAX_PATH, szRoot);
        cchPathLeft -= lstrlenW(pszPath) + 1;
    }
    else /* UNC path: Begins with double backslash */
    {
        bLFN = IsLFNDriveW(pchTemp);
        if (bLFN)
        {
            pszPath[2] = UNICODE_NULL; /* Cut off */
            cchPathLeft -= (2 + 1);
            pchTemp += 2;
        }
        else
        {
            PWCHAR pchSlash = StrChrW(pszPath + 2, L'\\');
            if (pchSlash)
                pchSlash = StrChrW(pchSlash + 1, L'\\');
 
            if (pchSlash)
            {
                *(pchSlash + 1) = UNICODE_NULL; /* Cut off */
                pchTemp += pchSlash - pszPath;
                cchPathLeft -= (INT)(SIZE_T)(pchSlash - pszPath) + 1;
            }
            else
            {
                bLFN = TRUE;
                pszPath[2] = UNICODE_NULL; /* Cut off */
                cchPathLeft -= 2;
                pchTemp += 2;
            }
        }
    }
    /* Now pszPath is a root-like path or an empty string. */
 
    /* Start appending the path components of szTemp to pszPath. */
    while (*pchTemp && cchPathLeft > 0)
    {
        /* Collapse any .\ and ..\ parts in the path */
        if (*pchTemp == L'.')
        {
            BOOL bDots = FALSE; /* '.' or '..' ? */
 
            if (pchTemp[1] == UNICODE_NULL || pchTemp[1] == L'\\')
            {
                /* Component '.' */
                bDots = TRUE;
            }
            else if (pchTemp[1] == L'.' && (pchTemp[2] == UNICODE_NULL || pchTemp[2] == L'\\'))
            {
                /* Component '..' */
                PathRemoveFileSpecW(pszPath); /* Remove the last component from pszPath */
                bDots = TRUE;
            }
 
            /* If a '.' or '..' was encountered, skip to the next component */
            if (bDots)
            {
                while (*pchTemp && *pchTemp != L'\\')
                {
                    ++pchTemp;
                }
 
                while (*pchTemp == L'\\')
                {
                    ++pchTemp;
                }
 
                continue;
            }
        }
 
        /* Otherwise, copy the other path component */
 
        if (!PathAddBackslashW(pszPath)) /* Append a backslash at the end */
            break;
 
        --cchPathLeft;
 
        pchPath = &pszPath[lstrlenW(pszPath)];
 
        if (!bLFN) /* Not LFN? */
        {
            /* Copy MS-DOS 8.3 filename */
            PWCHAR pchDot = NULL;
            INT ich;
            WCHAR szTitle[8 + 1] = L"";
            INT cchTitle = 0;
            WCHAR szDotExtension[1 + 3 + 1] = L"";
            INT cchDotExtension = 0;
 
            /* Copy the component to szTitle and szDotExtension... */
            while (*pchTemp && *pchTemp != L'\\')
            {
                if (*pchTemp == L'.')
                {
                    pchDot = pchTemp; /* Remember the last position */
 
                    /* Clear szDotExtension */
                    cchDotExtension = 0;
                    ZeroMemory(szDotExtension, sizeof(szDotExtension));
                }
 
                if (pchDot)
                {
                    if (cchDotExtension < 1 + 3)
                        szDotExtension[cchDotExtension++] = *pchTemp;
                }
                else
                {
                    if (cchTitle < 8)
                        szTitle[cchTitle++] = *pchTemp;
                }
 
                ++pchTemp;
            }
 
            /* Add file title 'szTitle' to pchPath */
            for (ich = 0; szTitle[ich] && cchPathLeft > 0; ++ich)
            {
                *pchPath++ = szTitle[ich];
                --cchPathLeft;
            }
 
            /* Add file extension 'szDotExtension' to pchPath */
            if (pchDot)
            {
                for (ich = 0; szDotExtension[ich] && cchPathLeft > 0; ++ich)
                {
                    *pchPath++ = szDotExtension[ich];
                    --cchPathLeft;
                }
            }
        }
        else /* LFN */
        {
            /* Copy the component up to the next separator */
            while (*pchTemp != UNICODE_NULL && *pchTemp != L'\\' && cchPathLeft > 0)
            {
                *pchPath++ = *pchTemp++;
                --cchPathLeft;
            }
        }
 
        /* Skip the backslashes */
        while (*pchTemp == L'\\')
        {
            ++pchTemp;
        }
 
        /* Keep null-terminated */
        *pchPath = UNICODE_NULL;
    }
 
    /* Remove any trailing backslash */
    PathRemoveBackslashW(pszPath);
 
    if (!(dwFlags & 1)) /* Remove the trailing dot? */
    {
        pchPath = CharPrevW(pszPath, pszPath + lstrlenW(pszPath));
        if (*pchPath == L'.')
            *pchPath = UNICODE_NULL;
    }
}

Referenced by PathQualifyW(), and PathResolveW().

PathQualifyW()

VOID WINAPI PathQualifyW

(

LPWSTR

pszPath

)

Definition at line 969 of file shellpath.c.

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

Referenced by PathQualifyA(), and PathQualifyAW().

PathRemoveFileSpecAW()

BOOL WINAPI PathRemoveFileSpecAW

(

LPVOID

lpszPath

)

Definition at line 453 of file shellpath.c.

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

PathResolveA()

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

Definition at line 986 of file shellpath.c.

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

Referenced by PathResolveAW().

PathResolveAW()

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

Definition at line 1109 of file shellpath.c.

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

PathResolveW()

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

Definition at line 1032 of file shellpath.c.

{
    DWORD dwWhich = WHICH_DEFAULT; /* The extensions to be searched */
 
    TRACE("(%s,%p,0x%08x)\n", debugstr_w(path), dirs, flags);
 
    if (flags & PRF_DONTFINDLNK)
        dwWhich &= ~WHICH_LNK; /* Don't search '.LNK' (shortcut) */
 
    if (flags & PRF_VERIFYEXISTS)
        SetLastError(ERROR_FILE_NOT_FOUND); /* We set this error code at first in verification */
 
    PathUnquoteSpacesW(path);
 
    if (PathIsRootW(path)) /* Root path */
    {
        if (path[0] == L'\\' && path[1] == UNICODE_NULL) /* '\' only? */
            PathQualifyExW(path, ((flags & PRF_FIRSTDIRDEF) ? *dirs : NULL), 0); /* Qualify */
 
        if (flags & PRF_VERIFYEXISTS)
            return PathFileExistsAndAttributesW(path, NULL); /* Check the existence */
 
        return TRUE;
    }
 
    if (PathIsFileSpecW(path)) /* Filename only */
    {
        /* Try to find the path with program extensions applied? */
        if ((flags & PRF_TRYPROGRAMEXTENSIONS) &&
            PathSearchOnExtensionsW(path, dirs, TRUE, dwWhich))
        {
            return TRUE; /* Found */
        }
 
        /* Try to find the filename in the directories */
        if (PathFindOnPathW(path, dirs))
            goto CheckAbsoluteAndFinish;
 
        return FALSE; /* Not found */
    }
 
    if (PathIsURLW(path)) /* URL? */
        return FALSE;
 
    /* Qualify the path */
    PathQualifyExW(path, ((flags & PRF_FIRSTDIRDEF) ? *dirs : NULL), 1);
 
    TRACE("(%s)\n", debugstr_w(path));
 
    if (!(flags & PRF_VERIFYEXISTS)) /* Don't verify the existence? */
        return TRUE;
 
    /* Try to find the path with program extensions applied? */
    if (!(flags & PRF_TRYPROGRAMEXTENSIONS) ||
        !PathSearchOnExtensionsW(path, dirs, FALSE, dwWhich))
    {
        if (!PathFileExistsAndAttributesW(path, NULL))
            return FALSE; /* Not found */
    }
 
CheckAbsoluteAndFinish:
#if (_WIN32_WINNT >= _WIN32_WINNT_WS03)
    if (!(flags & PRF_REQUIREABSOLUTE) || PathIsAbsoluteW(path))
        return TRUE;
 
    if (!PathMakeAbsoluteW(path))
        return FALSE;
 
    return PathFileExistsAndAttributesW(path, NULL);
#else
    return TRUE; /* Found */
#endif
}

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

PathSearchOnExtensionsW()

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

static

Definition at line 120 of file shellpath.c.

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

Referenced by PathResolveW().

PathYetAnotherMakeUniqueName()

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

Definition at line 848 of file shellpath.c.

{
    WCHAR pathW[MAX_PATH], retW[MAX_PATH];
    const WCHAR *file, *ext;
    int i = 2;
 
    TRACE("(%p, %s, %s, %s)\n", buffer, debugstr_w(path), debugstr_w(shortname), debugstr_w(longname));
 
    file = longname ? longname : shortname;
    PathCombineW(pathW, path, file);
    strcpyW(retW, pathW);
    PathRemoveExtensionW(pathW);
 
    ext = PathFindExtensionW(file);
 
    /* now try to make it unique */
    while (PathFileExistsW(retW))
    {
        sprintfW(retW, L"%s (%d)%s", pathW, i, ext);
        i++;
    }
 
    strcpyW(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().

Shell_ParseSpecialFolder()

INT Shell_ParseSpecialFolder	(	_In_ LPCWSTR	pszStart,
		_Out_ LPWSTR *	ppch,
		_Out_ INT *	pcch
	)

Definition at line 1987 of file shellpath.c.

{
    LPCWSTR pszPath, pchBackslash;
    WCHAR szPath[MAX_PATH];
 
    pchBackslash = StrChrW(pszStart, L'\\');
    if (pchBackslash)
    {
        *ppch = (LPWSTR)(pchBackslash + 1);
        *pcch = (pchBackslash - pszStart) + 1;
        StrCpyNW(szPath, pszStart, min(*pcch, _countof(szPath)));
        pszPath = szPath;
    }
    else
    {
        *ppch = NULL;
        *pcch = lstrlenW(pszStart);
        pszPath = pszStart;
    }
 
    return SHGetSpecialFolderID(pszPath);
}

Referenced by CDesktopFolder::ShellUrlParseDisplayName().

SHELL_RegisterShellFolders()

HRESULT SHELL_RegisterShellFolders

(

void

)

Definition at line 3192 of file shellpath.c.

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

Referenced by DllRegisterServer().

SHGetFolderLocation()

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

Definition at line 3278 of file shellpath.c.

{
    HRESULT hr = E_INVALIDARG;
#ifdef __REACTOS__
    WCHAR szPath[MAX_PATH];
#endif
 
    TRACE("%p 0x%08x %p 0x%08x %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 2964 of file shellpath.c.

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

Referenced by 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 2730 of file shellpath.c.

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

Referenced by test_SHGetFolderPathAndSubDirA().

SHGetFolderPathAndSubDirW()

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

Definition at line 2782 of file shellpath.c.

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

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

SHGetFolderPathW()

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

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

SHGetSpecialFolderID()

INT SHGetSpecialFolderID

(

_In_ LPCWSTR

pszName

)

Definition at line 1973 of file shellpath.c.

{
    UINT csidl;
 
    for (csidl = 0; csidl < _countof(CSIDL_Data); ++csidl)
    {
        const CSIDL_DATA *pData = &CSIDL_Data[csidl];
        if (pData->szValueName && lstrcmpiW(pszName, pData->szValueName) == 0)
            return csidl;
    }
 
    return -1;
}

Referenced by Shell_ParseSpecialFolder().

SHGetSpecialFolderLocation()

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

Definition at line 3385 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(), 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 3207 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(), test_BindToObject(), test_find_file(), and test_GetDisplayName().

SHGetSpecialFolderPathW()

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

Definition at line 3220 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(), START_TEST(), test_FolderShortcut(), test_ITEMIDLIST_format(), test_ParseDisplayName(), test_SHCreateShellItemArray(), and test_SHGetPathFromIDList().

SHPathGetExtensionW()

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

Definition at line 445 of file shellpath.c.

{
    return PathGetExtensionW(lpszPath);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)

Variable Documentation

Application_DataW

const WCHAR Application_DataW[] = L"Application Data"

static

Definition at line 1171 of file shellpath.c.

CSIDL_Data

const CSIDL_DATA CSIDL_Data[]

static

Definition at line 1226 of file shellpath.c.

Referenced by _SHGetAllUsersProfilePath(), _SHGetCurrentVersionPath(), _SHGetDefaultValue(), _SHGetUserProfilePath(), _SHRegisterFolders(), SHGetFolderPathAndSubDirW(), and SHGetSpecialFolderID().

is_win64

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

static

Definition at line 59 of file shellpath.c.

Referenced by _SHGetCurrentVersionPath(), and _SHGetDefaultValue().

Local_Settings_Application_DataW

const WCHAR Local_Settings_Application_DataW[] = L"Local Settings\\Application Data"

static

Definition at line 1172 of file shellpath.c.

Local_Settings_HistoryW

const WCHAR Local_Settings_HistoryW[] = L"Local Settings\\History"

static

Definition at line 1173 of file shellpath.c.

Local_Settings_Temporary_Internet_FilesW

const WCHAR Local_Settings_Temporary_Internet_FilesW[] = L"Local Settings\\Temporary Internet Files"

static

Definition at line 1174 of file shellpath.c.

MusicW

const WCHAR MusicW[] = L"Music"

static

Definition at line 1175 of file shellpath.c.

PicturesW

const WCHAR PicturesW[] = L"Pictures"

static

Definition at line 1176 of file shellpath.c.

Program_Files_Common_FilesW

const WCHAR Program_Files_Common_FilesW[] = L"Program Files\\Common Files"

static

Definition at line 1178 of file shellpath.c.

Program_FilesW

const WCHAR Program_FilesW[] = L"Program Files"

static

Definition at line 1177 of file shellpath.c.

Start_Menu_Admin_ToolsW

const WCHAR Start_Menu_Admin_ToolsW[] = L"Start Menu\\Programs\\Administrative Tools"

static

Definition at line 1180 of file shellpath.c.

Start_Menu_ProgramsW

const WCHAR Start_Menu_ProgramsW[] = L"Start Menu\\Programs"

static

Definition at line 1179 of file shellpath.c.

Start_Menu_StartupW

const WCHAR Start_Menu_StartupW[] = L"Start Menu\\Programs\\StartUp"

static

Definition at line 1181 of file shellpath.c.

szKnownFolderDescriptions

const WCHAR szKnownFolderDescriptions[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FolderDescriptions"

static

Definition at line 1188 of file shellpath.c.

szKnownFolderRedirections

const WCHAR szKnownFolderRedirections[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders"

static

Definition at line 1189 of file shellpath.c.

szSHFolders

const WCHAR szSHFolders[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"

static

Definition at line 1185 of file shellpath.c.

Referenced by _SHGetUserShellFolderPath(), _SHRegisterCommonShellFolders(), and _SHRegisterUserShellFolders().

szSHUserFolders

const WCHAR szSHUserFolders[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders"

static

Definition at line 1186 of file shellpath.c.

Referenced by _SHGetUserShellFolderPath(), _SHRegisterCommonShellFolders(), and _SHRegisterUserShellFolders().