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 <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	CSIDL_CONTACTS   0x0043
#define	CSIDL_DOWNLOADS   0x0047
#define	CSIDL_LINKS   0x004d
#define	CSIDL_APPDATA_LOCALLOW   0x004e
#define	CSIDL_SAVED_GAMES   0x0062
#define	CSIDL_SEARCHES   0x0063

Typedefs
typedef enum _CSIDL_Type	CSIDL_Type

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

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
static BOOL WINAPI	PathSearchOnExtensionsW (LPWSTR pszPath, LPCWSTR *ppszDirs, BOOL bDoSearch, DWORD dwWhich)
static BOOL WINAPI	PathIsAbsoluteW (LPCWSTR path)
static BOOL WINAPI	PathMakeAbsoluteW (LPWSTR path)
static DWORD	GetShortPathNameAbsentW (LPCWSTR pszLong, LPWSTR pszShort, DWORD cchShort)
BOOL WINAPI	IsLFNDriveW (LPCWSTR lpszPath)
static VOID WINAPI	PathQualifyExW (LPWSTR pszPath, LPCWSTR pszDir, DWORD dwFlags)
BOOL WINAPI	PathAppendAW (LPVOID lpszPath1, LPCVOID lpszPath2)
static LPSTR	PathGetExtensionA (LPCSTR lpszPath)
static LPWSTR	PathGetExtensionW (LPCWSTR lpszPath)
LPVOID WINAPI	SHPathGetExtensionW (LPCWSTR lpszPath, DWORD void1, DWORD void2)
BOOL WINAPI	PathRemoveFileSpecAW (LPVOID lpszPath)
static void	PathGetShortPathA (LPSTR pszPath)
static void	PathGetShortPathW (LPWSTR pszPath)
VOID WINAPI	PathGetShortPathAW (LPVOID pszPath)
BOOL WINAPI	PathIsRootAW (LPCVOID lpszPath)
static BOOL	PathIsExeA (LPCSTR lpszPath)
BOOL	PathIsExeW (LPCWSTR lpszPath)
BOOL WINAPI	PathIsExeAW (LPCVOID path)
BOOL WINAPI	PathFileExistsAW (LPCVOID lpszPath)
BOOL WINAPI	IsLFNDriveA (LPCSTR lpszPath)
BOOL WINAPI	IsLFNDriveAW (LPCVOID lpszPath)
static BOOL	PathMakeUniqueNameA (LPSTR lpszBuffer, DWORD dwBuffSize, LPCSTR lpszShortName, LPCSTR lpszLongName, LPCSTR lpszPathName)
static BOOL	PathMakeUniqueNameW (LPWSTR lpszBuffer, DWORD dwBuffSize, LPCWSTR lpszShortName, LPCWSTR lpszLongName, LPCWSTR lpszPathName)
BOOL WINAPI	PathMakeUniqueNameAW (LPVOID lpszBuffer, DWORD dwBuffSize, LPCVOID lpszShortName, LPCVOID lpszLongName, LPCVOID lpszPathName)
BOOL WINAPI	PathYetAnotherMakeUniqueName (LPWSTR buffer, LPCWSTR path, LPCWSTR shortname, LPCWSTR longname)
int WINAPI	PathCleanupSpec (LPCWSTR lpszPathW, LPWSTR lpszFileW)
VOID WINAPI	PathQualifyA (LPSTR pszPath)
VOID WINAPI	PathQualifyW (LPWSTR pszPath)
VOID WINAPI	PathQualifyAW (LPVOID pszPath)
BOOL WINAPI	PathResolveA (LPSTR path, LPCSTR *dirs, DWORD flags)
BOOL WINAPI	PathResolveW (LPWSTR path, LPCWSTR *dirs, DWORD flags)
BOOL WINAPI	PathResolveAW (LPVOID path, LPCVOID *paths, DWORD flags)
static LONG	PathProcessCommandA (LPCSTR lpszPath, LPSTR lpszBuff, DWORD dwBuffSize, DWORD dwFlags)
static LONG	PathProcessCommandW (LPCWSTR lpszPath, LPWSTR lpszBuff, DWORD dwBuffSize, DWORD dwFlags)
LONG WINAPI	PathProcessCommandAW (LPCVOID lpszPath, LPVOID lpszBuff, DWORD dwBuffSize, DWORD dwFlags)
static HRESULT	_SHExpandEnvironmentStrings (LPCWSTR szSrc, LPWSTR szDest)
static HRESULT	_SHGetUserShellFolderPath (HKEY rootKey, LPCWSTR userPrefix, LPCWSTR value, LPWSTR path)
BOOL	_SHGetUserProfileDirectoryW (HANDLE hToken, LPWSTR szPath, LPDWORD lpcchPath)
static HRESULT	_SHGetDefaultValue (BYTE folder, LPWSTR pszPath)
static HRESULT	_SHGetCurrentVersionPath (DWORD dwFlags, BYTE folder, LPWSTR pszPath)
static LPWSTR	_GetUserSidStringFromToken (HANDLE Token)
static HRESULT	_SHGetUserProfilePath (HANDLE hToken, DWORD dwFlags, BYTE folder, LPWSTR pszPath)
static HRESULT	_SHGetAllUsersProfilePath (DWORD dwFlags, BYTE folder, LPWSTR pszPath)
static HRESULT	_SHOpenProfilesKey (PHKEY pKey)
static HRESULT	_SHGetProfilesValue (HKEY profilesKey, LPCWSTR szValueName, LPWSTR szValue, LPCWSTR szDefault)
HRESULT WINAPI	SHGetFolderPathW (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath)
HRESULT WINAPI	SHGetFolderPathAndSubDirA (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPCSTR pszSubPath, LPSTR pszPath)
HRESULT WINAPI	SHGetFolderPathAndSubDirW (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPCWSTR pszSubPath, LPWSTR pszPath)
HRESULT WINAPI	SHGetFolderPathA (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPSTR pszPath)
static HRESULT	_SHRegisterFolders (HKEY hRootKey, HANDLE hToken, LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[], UINT foldersLen)
static HRESULT	_SHRegisterUserShellFolders (BOOL bDefault)
static HRESULT	_SHRegisterCommonShellFolders (void)
HRESULT	SHELL_RegisterShellFolders (void)
BOOL WINAPI	SHGetSpecialFolderPathA (HWND hwndOwner, LPSTR szPath, int nFolder, BOOL bCreate)
BOOL WINAPI	SHGetSpecialFolderPathW (HWND hwndOwner, LPWSTR szPath, int nFolder, BOOL bCreate)
HRESULT WINAPI	SHGetFolderLocation (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwReserved, LPITEMIDLIST *ppidl)
HRESULT WINAPI	SHGetSpecialFolderLocation (HWND hwndOwner, INT nFolder, LPITEMIDLIST *ppidl)

Variables
static const BOOL	is_win64 = sizeof(void *) > sizeof(int)
static const WCHAR	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 54 of file shellpath.c.

COBJMACROS

#define COBJMACROS

Definition at line 30 of file shellpath.c.

CSIDL_APPDATA_LOCALLOW

#define CSIDL_APPDATA_LOCALLOW   0x004e

Definition at line 856 of file shellpath.c.

CSIDL_CONTACTS

#define CSIDL_CONTACTS   0x0043

Definition at line 853 of file shellpath.c.

CSIDL_DOWNLOADS

#define CSIDL_DOWNLOADS   0x0047

Definition at line 854 of file shellpath.c.

CSIDL_LINKS

#define CSIDL_LINKS   0x004d

Definition at line 855 of file shellpath.c.

CSIDL_SAVED_GAMES

#define CSIDL_SAVED_GAMES   0x0062

Definition at line 857 of file shellpath.c.

CSIDL_SEARCHES

#define CSIDL_SEARCHES   0x0063

Definition at line 858 of file shellpath.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 28 of file shellpath.c.

Typedef Documentation

CSIDL_Type

typedef enum _CSIDL_Type CSIDL_Type

Enumeration Type Documentation

_CSIDL_Type

enum _CSIDL_Type

Enumerator
CSIDL_Type_User
CSIDL_Type_AllUsers
CSIDL_Type_CurrVer
CSIDL_Type_Disallowed
CSIDL_Type_NonExistent
CSIDL_Type_WindowsPath
CSIDL_Type_SystemPath
CSIDL_Type_SystemX86Path

Definition at line 837 of file shellpath.c.

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

Function Documentation

_GetUserSidStringFromToken()

static LPWSTR _GetUserSidStringFromToken ( HANDLE  Token )

static

Definition at line 1961 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 2196 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 2091 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 1892 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 1776 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 2146 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 1740 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 2002 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 1657 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 2131 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 2795 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 2625 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 2727 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().

GetShortPathNameAbsentW()

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

static

Definition at line 151 of file shellpath.c.

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

Referenced by PathQualifyExW().

IsLFNDriveA()

BOOL WINAPI IsLFNDriveA

(

LPCSTR

lpszPath

)

Definition at line 408 of file shellpath.c.

{
    DWORD   fnlen;

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

Referenced by IsLFNDriveAW().

IsLFNDriveAW()

BOOL WINAPI IsLFNDriveAW

(

LPCVOID

lpszPath

)

Definition at line 432 of file shellpath.c.

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

IsLFNDriveW()

BOOL WINAPI IsLFNDriveW

(

LPCWSTR

lpszPath

)

Definition at line 420 of file shellpath.c.

{
    DWORD   fnlen;

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

Referenced by IsLFNDriveAW(), and PathQualifyExW().

PathAppendAW()

BOOL WINAPI PathAppendAW	(	LPVOID	lpszPath1,
		LPCVOID	lpszPath2
	)

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

{
    int i = 0;
    DWORD rc = 0;
    int length = 0;

    if (SHELL_OsIsUnicode())
    {
        LPWSTR p = lpszFileW;

        TRACE("Cleanup %s\n",debugstr_w(lpszFileW));

        if (lpszPathW)
            length = strlenW(lpszPathW);

        while (*p)
        {
            int gct = PathGetCharTypeW(*p);
            if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
            {
                lpszFileW[i]='-';
                rc |= PCS_REPLACEDCHAR;
            }
            else
                lpszFileW[i]=*p;
            i++;
            p++;
            if (length + i == MAX_PATH)
            {
                rc |= PCS_FATAL | PCS_PATHTOOLONG;
                break;
            }
        }
        lpszFileW[i]=0;
    }
    else
    {
        LPSTR lpszFileA = (LPSTR)lpszFileW;
        LPCSTR lpszPathA = (LPCSTR)lpszPathW;
        LPSTR p = lpszFileA;

        TRACE("Cleanup %s\n",debugstr_a(lpszFileA));

        if (lpszPathA)
            length = strlen(lpszPathA);

        while (*p)
        {
            int gct = PathGetCharTypeA(*p);
            if (gct == GCT_INVALID || gct == GCT_WILD || gct == GCT_SEPARATOR)
            {
                lpszFileA[i]='-';
                rc |= PCS_REPLACEDCHAR;
            }
            else
                lpszFileA[i]=*p;
            i++;
            p++;
            if (length + i == MAX_PATH)
            {
                rc |= PCS_FATAL | PCS_PATHTOOLONG;
                break;
            }
        }
        lpszFileA[i]=0;
    }
    return rc;
}

PathFileExistsAW()

BOOL WINAPI PathFileExistsAW

(

LPCVOID

lpszPath

)

Definition at line 398 of file shellpath.c.

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

PathGetExtensionA()

static LPSTR PathGetExtensionA ( LPCSTR  lpszPath )

static

Definition at line 254 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 265 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 298 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 328 of file shellpath.c.

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

PathGetShortPathW()

static void PathGetShortPathW ( LPWSTR  pszPath )

static

Definition at line 313 of file shellpath.c.

{
    WCHAR path[MAX_PATH];

    TRACE("%s\n", debugstr_w(pszPath));

    if (GetShortPathNameW(pszPath, path, MAX_PATH))
    {
      lstrcpyW(pszPath, path);
    }
}

Referenced by PathGetShortPathAW().

PathIsAbsoluteW()

static BOOL WINAPI PathIsAbsoluteW ( LPCWSTR  path )

static

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

{
    LPCSTR lpszExtension = PathGetExtensionA(lpszPath);
        int i;
        static const char * const lpszExtensions[] =
            {"exe", "com", "pif", "cmd", "bat", "scf", "scr", NULL };

    TRACE("path=%s\n",lpszPath);

    for(i=0; lpszExtensions[i]; i++)
      if (!lstrcmpiA(lpszExtension,lpszExtensions[i])) return TRUE;

    return FALSE;
}

Referenced by PathIsExeAW().

PathIsExeAW()

BOOL WINAPI PathIsExeAW

(

LPCVOID

path

)

Definition at line 388 of file shellpath.c.

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

PathIsExeW()

BOOL PathIsExeW

(

LPCWSTR

lpszPath

)

Definition at line 370 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 CFileDefExt::InitGeneralPage(), COpenWithMenu::Initialize(), PathIsExeAW(), and SHELL_execute().

PathIsRootAW()

BOOL WINAPI PathIsRootAW

(

LPCVOID

lpszPath

)

Definition at line 342 of file shellpath.c.

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

PathMakeAbsoluteW()

static BOOL WINAPI PathMakeAbsoluteW ( LPWSTR  path )

static

Definition at line 135 of file shellpath.c.

{
    WCHAR path1[MAX_PATH];
    DWORD cch;

    if (path == NULL)
        return FALSE;
    cch = GetCurrentDirectoryW(_countof(path1), path1);
    if (!cch || cch > _countof(path1))
        return FALSE;
    return (PathCombineW(path, path1, path) != NULL);
}

Referenced by PathResolveW().

PathMakeUniqueNameA()

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

static

Definition at line 445 of file shellpath.c.

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

Referenced by PathMakeUniqueNameAW().

PathMakeUniqueNameAW()

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

Definition at line 477 of file shellpath.c.

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

PathMakeUniqueNameW()

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

static

Definition at line 461 of file shellpath.c.

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

Referenced by PathMakeUniqueNameAW().

PathProcessCommandA()

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

static

Definition at line 767 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 799 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 783 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 601 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 622 of file shellpath.c.

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

PathQualifyExW()

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

static

Definition at line 161 of file shellpath.c.

{
    WCHAR szRoot[MAX_PATH], szCopy[MAX_PATH], szCurDir[MAX_PATH];
    LPWSTR pch;
    LONG cch;
    BOOL bCheckLFN;

    if (FAILED(StringCchCopyW(szCopy, _countof(szCopy), pszPath)))
        return;

    FixSlashesAndColonW(szCopy);

    if (pszDir)
    {
        cch = GetCurrentDirectoryW(_countof(szCurDir), szCurDir);
        if (cch <= 0 || cch >= _countof(szCurDir) || !SetCurrentDirectoryW(pszDir))
            pszDir = NULL;
    }

    if (!GetFullPathNameW(szCopy, _countof(szRoot), szRoot, NULL))
        goto Quit;

    if (PathIsUNCW(szRoot)) /* it begins with double backslash */
    {
        pch = StrChrW(&szRoot[2], L'\\');
        if (pch)
        {
            pch = StrChrW(&pch[1], L'\\');
            if (pch)
                *pch = 0;
            if (!PathAddBackslashW(szRoot))
                goto Quit;
            /* szRoot is like \\MyServer\MyShare\ */
            bCheckLFN = TRUE;
        }
        else
        {
            bCheckLFN = FALSE;
        }
    }
    else
    {
        if (!PathStripToRootW(szRoot) || !PathAddBackslashW(szRoot))
            goto Quit;
        /* szRoot is like X:\ */
        bCheckLFN = TRUE;
    }

    if (bCheckLFN && !IsLFNDriveW(szRoot)) /* not a long filename drive */
    {
        if (!GetFullPathNameW(szCopy, _countof(szRoot), szRoot, NULL))
            goto Quit;
        if (!GetShortPathNameW(szRoot, szCopy, _countof(szCopy)) &&
            !GetShortPathNameAbsentW(szRoot, szCopy, _countof(szCopy)))
        {
            goto Quit;
        }
    }

    PathRemoveBackslashW(szCopy);
    StringCchCopyW(pszPath, MAX_PATH, szCopy);

    if ((dwFlags & 1) == 0)
    {
        cch = lstrlenW(pszPath);
        if (cch > 0 && pszPath[cch - 1] == L'.')
            pszPath[cch - 1] = 0;
    }

Quit:
    if (pszDir)
        SetCurrentDirectoryW(szCurDir);
}

Referenced by PathQualifyW(), and PathResolveW().

PathQualifyW()

VOID WINAPI PathQualifyW

(

LPWSTR

pszPath

)

Definition at line 613 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 284 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 630 of file shellpath.c.

{
    BOOL ret = FALSE;
    LPWSTR *dirsW = NULL;
    DWORD iDir, cDirs, cbDirs;
    WCHAR pathW[MAX_PATH];

    TRACE("PathResolveA(%s,%p,0x%08x)\n", debugstr_a(path), dirs, flags);

    if (dirs)
    {
        for (cDirs = 0; dirs[cDirs]; ++cDirs)
            ;

        cbDirs = (cDirs + 1) * sizeof(LPWSTR);
        dirsW = SHAlloc(cbDirs);
        if (!dirsW)
            goto Cleanup;

        ZeroMemory(dirsW, cbDirs);
        for (iDir = 0; iDir < cDirs; ++iDir)
        {
            __SHCloneStrAtoW(&dirsW[iDir], dirs[iDir]);
            if (dirsW[iDir] == NULL)
                goto Cleanup;
        }
    }

    SHAnsiToUnicode(path, pathW, _countof(pathW));

    ret = PathResolveW(pathW, (LPCWSTR*)dirsW, flags);
    if (ret)
        SHUnicodeToAnsi(pathW, path, MAX_PATH);

Cleanup:
    if (dirsW)
    {
        for (iDir = 0; iDir < cDirs; ++iDir)
        {
            SHFree(dirsW[iDir]);
        }
        SHFree(dirsW);
    }
    return ret;
}

Referenced by PathResolveAW().

PathResolveAW()

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

Definition at line 756 of file shellpath.c.

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

PathResolveW()

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

Definition at line 676 of file shellpath.c.

{
    DWORD dwWhich = ((flags & PRF_DONTFINDLNK) ? (WHICH_DEFAULT & ~WHICH_LNK) : WHICH_DEFAULT);

    TRACE("PathResolveW(%s,%p,0x%08x)\n", debugstr_w(path), dirs, flags);

    if (flags & PRF_VERIFYEXISTS)
        SetLastError(ERROR_FILE_NOT_FOUND);

    PathUnquoteSpacesW(path);

    if (PathIsRootW(path))
    {
        if ((path[0] == L'\\' && path[1] == 0) ||
            PathIsUNCServerW(path) || PathIsUNCServerShareW(path))
        {
            if (flags & PRF_FIRSTDIRDEF)
                PathQualifyExW(path, dirs[0], 0);
            else
                PathQualifyExW(path, NULL, 0);
        }

        if (flags & PRF_VERIFYEXISTS)
            return PathFileExistsAndAttributesW(path, NULL);
        return TRUE;
    }
    else if (PathIsFileSpecW(path))
    {
        if ((flags & PRF_TRYPROGRAMEXTENSIONS) && PathSearchOnExtensionsW(path, dirs, TRUE, dwWhich))
            return TRUE;

        if (PathFindOnPathW(path, dirs))
        {
#if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
            if (!(flags & PRF_REQUIREABSOLUTE))
                return TRUE;

            if (!PathIsAbsoluteW(path))
                return PathMakeAbsoluteW(path) && PathFileExistsAndAttributesW(path, NULL);
#else
            return TRUE;
#endif
        }
    }
    else if (!PathIsURLW(path))
    {
        if (flags & PRF_FIRSTDIRDEF)
            PathQualifyExW(path, *dirs, 1);
        else
            PathQualifyExW(path, NULL, 1);

        if (flags & PRF_VERIFYEXISTS)
        {
            if ((flags & PRF_TRYPROGRAMEXTENSIONS) &&
                PathSearchOnExtensionsW(path, dirs, FALSE, dwWhich))
            {
                return TRUE;
            }
            else if (!PathFileExistsAndAttributesW(path, NULL))
            {
                return FALSE;
            }
        }

#if (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
        if (flags & PRF_REQUIREABSOLUTE)
        {
            if (!PathIsAbsoluteW(path))
                return PathMakeAbsoluteW(path) && PathFileExistsAndAttributesW(path, NULL);
        }
#endif
        return TRUE;
    }

    return FALSE;
}

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

PathSearchOnExtensionsW()

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

static

Definition at line 116 of file shellpath.c.

{
    if (*PathFindExtensionW(pszPath) != 0)
        return FALSE;

    if (bDoSearch)
        return PathFindOnPathExW(pszPath, ppszDirs, dwWhich);
    else
        return PathFileExistsDefExtW(pszPath, dwWhich);
}

Referenced by PathResolveW().

PathYetAnotherMakeUniqueName()

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

Definition at line 492 of file shellpath.c.

{
    WCHAR pathW[MAX_PATH], retW[MAX_PATH];
    const WCHAR *file, *ext;
    int i = 2;

    TRACE("(%p, %s, %s, %s)\n", buffer, debugstr_w(path), debugstr_w(shortname), debugstr_w(longname));

    file = longname ? longname : shortname;
    PathCombineW(pathW, path, file);
    strcpyW(retW, pathW);
    PathRemoveExtensionW(pathW);

    ext = PathFindExtensionW(file);

    /* now try to make it unique */
    while (PathFileExistsW(retW))
    {
        sprintfW(retW, L"%s (%d)%s", pathW, i, ext);
        i++;
    }

    strcpyW(buffer, retW);
    TRACE("ret - %s\n", debugstr_w(buffer));

    return TRUE;
}

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

SHELL_RegisterShellFolders()

HRESULT SHELL_RegisterShellFolders

(

void

)

Definition at line 2823 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 2883 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;

        default:
        {
            WCHAR szPath[MAX_PATH];

            hr = SHGetFolderPathW(hwndOwner, nFolder, hToken,
             SHGFP_TYPE_CURRENT, szPath);
            if (SUCCEEDED(hr))
            {
                DWORD attributes=0;

                TRACE("Value=%s\n", debugstr_w(szPath));
                hr = SHILCreateFromPathW(szPath, ppidl, &attributes);
            }
            else if (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
            {
                /* unlike SHGetFolderPath, SHGetFolderLocation in shell32
                 * version 6.0 returns E_FAIL for nonexistent paths
                 */
                hr = E_FAIL;
            }
        }
    }
    if(*ppidl)
        hr = S_OK;

    TRACE("-- (new pidl %p)\n",*ppidl);
    return hr;
}

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

SHGetFolderPathA()

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

Definition at line 2595 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 2361 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 2413 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 2348 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 _SHRegisterFolders(), AutoStartupApplications(), BrsFolder_NewFolder(), CJournaledTestList::CJournaledTestList(), create_ie_menu(), create_profile_directory(), CreateObjectsFromPersistFolder(), DllRegisterServer(), FILEDLG95_InitControls(), FillDefaultSettings(), format_filelist_filename(), GetDefaultUserSendTo(), Initialize(), CFontExt::Initialize(), LoadThemes(), OnAddStartMenuItems(), OnAdvancedStartMenuItems(), OnBrowseButton(), OnClearRecentItems(), RegisterTypeLibraries(), set_installer_properties(), Settings_GetOutputPath(), SHGetFolderLocation(), SHGetFolderPathA(), SHGetSpecialFolderPathW(), test_namespace(), TestDefaultFormat(), and testRegStoreSavedCerts().

SHGetSpecialFolderLocation()

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

Definition at line 2984 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(), DoGetPidl(), DoInitAliasPIDLs(), DoTestEntry(), ebrowser_browse_to_desktop(), FILEDLG95_InitControls(), FILEDLG95_LOOKIN_Init(), FILEDLG95_OnWMCommand(), filedlg_collect_places_pidls(), GetFavoritesFolder(), GetMergedFolder(), CSendToMenu::GetSpecialFolder(), IShellBrowserImpl_Construct(), loadShell32(), CACListISF::NextLocation(), CShellBrowser::OnOrganizeFavorites(), PidlBrowse(), CAddressEditBox::PopulateComboBox(), RSHELL_CStartMenu_CreateInstance(), SHAddToRecentDocs(), SHCloneSpecialIDList(), SHExplorerParseCmdLine(), SpecialFolderPath::SpecialFolderPath(), 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 2838 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 2851 of file shellpath.c.

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

Referenced by cache_containers_init(), CreateSendToMyDocuments(), delhist_on_command(), CCopyToMenu::DoRealCopy(), CMoveToMenu::DoRealMove(), CMyDocsDropHandler::Drop(), CDeskLinkDropHandler::Drop(), CDesktopFolder::FinalConstruct(), get_csidl_dir(), GetStorageDirectory(), CFSFolder::InitializeEx(), InitPropertyBag_IPropertyBag_Read(), CShellMenuCallback::InsertRecentItem(), 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 276 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 816 of file shellpath.c.

CSIDL_Data

const CSIDL_DATA CSIDL_Data[]

static

Definition at line 870 of file shellpath.c.

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

is_win64

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

static

Definition at line 58 of file shellpath.c.

Referenced by _SHGetCurrentVersionPath(), _SHGetDefaultValue(), get_classes_root_hkey(), test_CoGetPSClsid(), and test_SHGetFolderPathA().

Local_Settings_Application_DataW

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

static

Definition at line 817 of file shellpath.c.

Local_Settings_HistoryW

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

static

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

MusicW

const WCHAR MusicW[] = L"Music"

static

Definition at line 820 of file shellpath.c.

PicturesW

const WCHAR PicturesW[] = L"Pictures"

static

Definition at line 821 of file shellpath.c.

Program_Files_Common_FilesW

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

static

Definition at line 823 of file shellpath.c.

Program_FilesW

const WCHAR Program_FilesW[] = L"Program Files"

static

Definition at line 822 of file shellpath.c.

Start_Menu_Admin_ToolsW

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

static

Definition at line 825 of file shellpath.c.

Start_Menu_ProgramsW

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

static

Definition at line 824 of file shellpath.c.

Start_Menu_StartupW

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

static

Definition at line 826 of file shellpath.c.

szKnownFolderDescriptions

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

static

Definition at line 833 of file shellpath.c.

szKnownFolderRedirections

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

static

Definition at line 834 of file shellpath.c.

szSHFolders

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

static

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

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