mirror of
https://github.com/reactos/reactos.git
synced 2024-08-20 18:35:32 +00:00
![Katayama Hirofumi MZ](/assets/img/avatar_default.png)
- Fix IsLFNDriveA and IsLFNDriveW functions. - Add IsRemovableDrive helper function. - Fix PathQualifyExW by using IsLFNDriveW. CORE-11335
3209 lines
89 KiB
C
3209 lines
89 KiB
C
/*
|
|
* Path Functions
|
|
*
|
|
* Copyright 1998, 1999, 2000 Juergen Schmied
|
|
* Copyright 2004 Juan Lang
|
|
* Copyright 2018-2022 Katayama Hirofumi MZ
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*
|
|
* NOTES:
|
|
*
|
|
* Many of these functions are in SHLWAPI.DLL also
|
|
*
|
|
*/
|
|
|
|
#define WIN32_NO_STATUS
|
|
#define _INC_WINDOWS
|
|
#define COBJMACROS
|
|
|
|
#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"
|
|
|
|
#undef _WIN32_WINNT
|
|
#define _WIN32_WINNT _WIN32_WINNT_WS03
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(shell);
|
|
|
|
static const BOOL is_win64 = sizeof(void *) > sizeof(int);
|
|
|
|
/* FIXME: Remove this */
|
|
typedef enum _NT_PRODUCT_TYPE
|
|
{
|
|
NtProductWinNt = 1,
|
|
NtProductLanManNt,
|
|
NtProductServer
|
|
} NT_PRODUCT_TYPE, *PNT_PRODUCT_TYPE;
|
|
|
|
/* FIXME: We cannot refresh the RtlGetNtProductType value before reboot. */
|
|
static BOOL
|
|
DoGetProductType(PNT_PRODUCT_TYPE ProductType)
|
|
{
|
|
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;
|
|
}
|
|
|
|
BOOL APIENTRY IsRemovableDrive(DWORD iDrive)
|
|
{
|
|
WCHAR szRoot[] = L"C:\\";
|
|
assert(L'A' + iDrive <= L'Z');
|
|
szRoot[0] = (WCHAR)(L'A' + iDrive);
|
|
return GetDriveTypeW(szRoot) == DRIVE_REMOVABLE;
|
|
}
|
|
|
|
/*
|
|
########## Combining and Constructing paths ##########
|
|
*/
|
|
|
|
static BOOL WINAPI
|
|
PathSearchOnExtensionsW(
|
|
_Inout_ LPWSTR pszPath,
|
|
_In_opt_ LPCWSTR *ppszDirs,
|
|
_In_ BOOL bDoSearch,
|
|
_In_ DWORD dwWhich)
|
|
{
|
|
if (*PathFindExtensionW(pszPath) != 0)
|
|
return FALSE;
|
|
|
|
if (bDoSearch)
|
|
return PathFindOnPathExW(pszPath, ppszDirs, dwWhich);
|
|
else
|
|
return PathFileExistsDefExtW(pszPath, dwWhich);
|
|
}
|
|
|
|
#if (_WIN32_WINNT >= _WIN32_WINNT_WS03)
|
|
static BOOL WINAPI PathIsAbsoluteW(_In_ LPCWSTR path)
|
|
{
|
|
return PathIsUNCW(path) || (PathGetDriveNumberW(path) != -1 && path[2] == L'\\');
|
|
}
|
|
|
|
static BOOL WINAPI PathMakeAbsoluteW(_Inout_ LPWSTR path)
|
|
{
|
|
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);
|
|
}
|
|
#endif
|
|
|
|
BOOL WINAPI IsLFNDriveW(LPCWSTR lpszPath);
|
|
|
|
static VOID WINAPI
|
|
PathQualifyExW(_Inout_ LPWSTR pszPath, _Inout_opt_ LPCWSTR pszDir, _In_ DWORD dwFlags)
|
|
{
|
|
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 PATH_CHAR_CLASS_DOT 0x00000004
|
|
#define PATH_CHAR_CLASS_BACKSLASH 0x00000008
|
|
#define PATH_CHAR_CLASS_COLON 0x00000010
|
|
#define PATH_CHAR_CLASS_OTHER_VALID 0x00000100
|
|
#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;
|
|
}
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathAppend [SHELL32.36]
|
|
*/
|
|
BOOL WINAPI PathAppendAW(
|
|
LPVOID lpszPath1,
|
|
LPCVOID lpszPath2)
|
|
{
|
|
if (SHELL_OsIsUnicode())
|
|
return PathAppendW(lpszPath1, lpszPath2);
|
|
return PathAppendA(lpszPath1, lpszPath2);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathGetExtensionA [internal]
|
|
*
|
|
* NOTES
|
|
* exported by ordinal
|
|
* return value points to the first char after the dot
|
|
*/
|
|
static LPSTR PathGetExtensionA(LPCSTR lpszPath)
|
|
{
|
|
TRACE("(%s)\n",lpszPath);
|
|
|
|
lpszPath = PathFindExtensionA(lpszPath);
|
|
return (LPSTR)(*lpszPath?(lpszPath+1):lpszPath);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathGetExtensionW [internal]
|
|
*/
|
|
static LPWSTR PathGetExtensionW(LPCWSTR lpszPath)
|
|
{
|
|
TRACE("(%s)\n",debugstr_w(lpszPath));
|
|
|
|
lpszPath = PathFindExtensionW(lpszPath);
|
|
return (LPWSTR)(*lpszPath?(lpszPath+1):lpszPath);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* SHPathGetExtension [SHELL32.158]
|
|
*/
|
|
LPVOID WINAPI SHPathGetExtensionW(LPCWSTR lpszPath, DWORD void1, DWORD void2)
|
|
{
|
|
return PathGetExtensionW(lpszPath);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathRemoveFileSpec [SHELL32.35]
|
|
*/
|
|
BOOL WINAPI PathRemoveFileSpecAW(LPVOID lpszPath)
|
|
{
|
|
if (SHELL_OsIsUnicode())
|
|
return PathRemoveFileSpecW(lpszPath);
|
|
return PathRemoveFileSpecA(lpszPath);
|
|
}
|
|
|
|
/*
|
|
Path Manipulations
|
|
*/
|
|
|
|
/*************************************************************************
|
|
* PathGetShortPathA [internal]
|
|
*/
|
|
static void PathGetShortPathA(LPSTR pszPath)
|
|
{
|
|
CHAR path[MAX_PATH];
|
|
|
|
TRACE("%s\n", pszPath);
|
|
|
|
if (GetShortPathNameA(pszPath, path, MAX_PATH))
|
|
{
|
|
lstrcpyA(pszPath, path);
|
|
}
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathGetShortPathW [internal]
|
|
*/
|
|
static void PathGetShortPathW(LPWSTR pszPath)
|
|
{
|
|
WCHAR path[MAX_PATH];
|
|
|
|
TRACE("%s\n", debugstr_w(pszPath));
|
|
|
|
if (GetShortPathNameW(pszPath, path, MAX_PATH))
|
|
{
|
|
lstrcpyW(pszPath, path);
|
|
}
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathGetShortPath [SHELL32.92]
|
|
*/
|
|
VOID WINAPI PathGetShortPathAW(LPVOID pszPath)
|
|
{
|
|
if(SHELL_OsIsUnicode())
|
|
PathGetShortPathW(pszPath);
|
|
PathGetShortPathA(pszPath);
|
|
}
|
|
|
|
/*
|
|
########## Path Testing ##########
|
|
*/
|
|
|
|
/*************************************************************************
|
|
* PathIsRoot [SHELL32.29]
|
|
*/
|
|
BOOL WINAPI PathIsRootAW(LPCVOID lpszPath)
|
|
{
|
|
if (SHELL_OsIsUnicode())
|
|
return PathIsRootW(lpszPath);
|
|
return PathIsRootA(lpszPath);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathIsExeA [internal]
|
|
*/
|
|
static BOOL PathIsExeA (LPCSTR lpszPath)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathIsExeW [internal]
|
|
*/
|
|
BOOL PathIsExeW (LPCWSTR lpszPath)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathIsExe [SHELL32.43]
|
|
*/
|
|
BOOL WINAPI PathIsExeAW (LPCVOID path)
|
|
{
|
|
if (SHELL_OsIsUnicode())
|
|
return PathIsExeW (path);
|
|
return PathIsExeA(path);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathFileExists [SHELL32.45]
|
|
*/
|
|
BOOL WINAPI PathFileExistsAW (LPCVOID lpszPath)
|
|
{
|
|
if (SHELL_OsIsUnicode())
|
|
return PathFileExistsW (lpszPath);
|
|
return PathFileExistsA (lpszPath);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* IsLFNDriveA [SHELL32.41]
|
|
*/
|
|
BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath)
|
|
{
|
|
WCHAR szBuffW[MAX_PATH], *pszW = NULL;
|
|
if (lpszPath)
|
|
{
|
|
SHAnsiToUnicode(lpszPath, szBuffW, _countof(szBuffW));
|
|
pszW = szBuffW;
|
|
}
|
|
return IsLFNDriveW(pszW);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* IsLFNDriveW [SHELL32.42]
|
|
*/
|
|
BOOL WINAPI IsLFNDriveW(LPCWSTR lpszPath)
|
|
{
|
|
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
|
|
{
|
|
assert(!PathIsRelativeW(lpszPath)); /* Assuming absolute path... */
|
|
|
|
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;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* IsLFNDrive [SHELL32.119]
|
|
*/
|
|
BOOL WINAPI IsLFNDriveAW(LPCVOID lpszPath)
|
|
{
|
|
if (SHELL_OsIsUnicode())
|
|
return IsLFNDriveW(lpszPath);
|
|
return IsLFNDriveA(lpszPath);
|
|
}
|
|
|
|
/*
|
|
########## Creating Something Unique ##########
|
|
*/
|
|
/*************************************************************************
|
|
* PathMakeUniqueNameA [internal]
|
|
*/
|
|
static BOOL PathMakeUniqueNameA(
|
|
LPSTR lpszBuffer,
|
|
DWORD dwBuffSize,
|
|
LPCSTR lpszShortName,
|
|
LPCSTR lpszLongName,
|
|
LPCSTR lpszPathName)
|
|
{
|
|
FIXME("%p %u %s %s %s stub\n",
|
|
lpszBuffer, dwBuffSize, debugstr_a(lpszShortName),
|
|
debugstr_a(lpszLongName), debugstr_a(lpszPathName));
|
|
return TRUE;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathMakeUniqueNameW [internal]
|
|
*/
|
|
static BOOL PathMakeUniqueNameW(
|
|
LPWSTR lpszBuffer,
|
|
DWORD dwBuffSize,
|
|
LPCWSTR lpszShortName,
|
|
LPCWSTR lpszLongName,
|
|
LPCWSTR lpszPathName)
|
|
{
|
|
FIXME("%p %u %s %s %s stub\n",
|
|
lpszBuffer, dwBuffSize, debugstr_w(lpszShortName),
|
|
debugstr_w(lpszLongName), debugstr_w(lpszPathName));
|
|
return TRUE;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathMakeUniqueName [SHELL32.47]
|
|
*/
|
|
BOOL WINAPI PathMakeUniqueNameAW(
|
|
LPVOID lpszBuffer,
|
|
DWORD dwBuffSize,
|
|
LPCVOID lpszShortName,
|
|
LPCVOID lpszLongName,
|
|
LPCVOID lpszPathName)
|
|
{
|
|
if (SHELL_OsIsUnicode())
|
|
return PathMakeUniqueNameW(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
|
|
return PathMakeUniqueNameA(lpszBuffer,dwBuffSize, lpszShortName,lpszLongName,lpszPathName);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathYetAnotherMakeUniqueName [SHELL32.75]
|
|
*/
|
|
BOOL WINAPI PathYetAnotherMakeUniqueName(LPWSTR buffer, LPCWSTR path, LPCWSTR shortname, LPCWSTR longname)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*
|
|
########## cleaning and resolving paths ##########
|
|
*/
|
|
|
|
/*************************************************************************
|
|
* PathCleanupSpec [SHELL32.171]
|
|
*
|
|
* lpszFile is changed in place.
|
|
*/
|
|
int WINAPI PathCleanupSpec( LPCWSTR lpszPathW, LPWSTR lpszFileW )
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathQualifyA [SHELL32]
|
|
*/
|
|
VOID WINAPI PathQualifyA(LPSTR pszPath)
|
|
{
|
|
WCHAR szPath[MAX_PATH];
|
|
TRACE("%s\n",pszPath);
|
|
SHAnsiToUnicode(pszPath, szPath, _countof(szPath));
|
|
PathQualifyW(szPath);
|
|
SHUnicodeToAnsi(szPath, pszPath, MAX_PATH);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathQualifyW [SHELL32]
|
|
*/
|
|
VOID WINAPI PathQualifyW(LPWSTR pszPath)
|
|
{
|
|
TRACE("%s\n",debugstr_w(pszPath));
|
|
PathQualifyExW(pszPath, NULL, 0);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathQualify [SHELL32.49]
|
|
*/
|
|
VOID WINAPI PathQualifyAW(LPVOID pszPath)
|
|
{
|
|
if (SHELL_OsIsUnicode())
|
|
PathQualifyW(pszPath);
|
|
else
|
|
PathQualifyA(pszPath);
|
|
}
|
|
|
|
BOOL WINAPI PathResolveA(LPSTR path, LPCSTR *dirs, DWORD flags)
|
|
{
|
|
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;
|
|
}
|
|
|
|
BOOL WINAPI PathResolveW(_Inout_ LPWSTR path, _Inout_opt_ LPCWSTR *dirs, _In_ DWORD flags)
|
|
{
|
|
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
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathResolve [SHELL32.51]
|
|
*/
|
|
BOOL WINAPI PathResolveAW(LPVOID path, LPCVOID *paths, DWORD flags)
|
|
{
|
|
if (SHELL_OsIsUnicode())
|
|
return PathResolveW(path, (LPCWSTR*)paths, flags);
|
|
else
|
|
return PathResolveA(path, (LPCSTR*)paths, flags);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathProcessCommandA
|
|
*/
|
|
static LONG PathProcessCommandA (
|
|
LPCSTR lpszPath,
|
|
LPSTR lpszBuff,
|
|
DWORD dwBuffSize,
|
|
DWORD dwFlags)
|
|
{
|
|
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);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathProcessCommandW
|
|
*/
|
|
static LONG PathProcessCommandW (
|
|
LPCWSTR lpszPath,
|
|
LPWSTR lpszBuff,
|
|
DWORD dwBuffSize,
|
|
DWORD dwFlags)
|
|
{
|
|
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);
|
|
}
|
|
|
|
/*************************************************************************
|
|
* PathProcessCommand (SHELL32.653)
|
|
*/
|
|
LONG WINAPI PathProcessCommandAW (
|
|
LPCVOID lpszPath,
|
|
LPVOID lpszBuff,
|
|
DWORD dwBuffSize,
|
|
DWORD dwFlags)
|
|
{
|
|
if (SHELL_OsIsUnicode())
|
|
return PathProcessCommandW(lpszPath, lpszBuff, dwBuffSize, dwFlags);
|
|
return PathProcessCommandA(lpszPath, lpszBuff, dwBuffSize, dwFlags);
|
|
}
|
|
|
|
/*
|
|
########## special ##########
|
|
*/
|
|
|
|
/* !! MISSING Win2k3-compatible paths from the list below; absent from Wine !! */
|
|
#ifndef __REACTOS__
|
|
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";
|
|
#endif
|
|
|
|
/* Long strings that are repeated many times: keep them here */
|
|
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";
|
|
#ifndef __REACTOS__
|
|
static const WCHAR szKnownFolderDescriptions[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FolderDescriptions";
|
|
static const WCHAR szKnownFolderRedirections[] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders";
|
|
#endif
|
|
|
|
typedef enum _CSIDL_Type {
|
|
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;
|
|
|
|
/* Cannot use #if _WIN32_WINNT >= 0x0600 because _WIN32_WINNT == 0x0600 here. */
|
|
#ifndef __REACTOS__
|
|
#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
|
|
#endif
|
|
|
|
typedef struct
|
|
{
|
|
const KNOWNFOLDERID *id;
|
|
CSIDL_Type type;
|
|
LPCWSTR szValueName;
|
|
LPCWSTR szDefaultPath; /* fallback string or resource ID */
|
|
INT nShell32IconIndex;
|
|
} CSIDL_DATA;
|
|
|
|
static const CSIDL_DATA CSIDL_Data[] =
|
|
{
|
|
{ /* 0x00 - CSIDL_DESKTOP */
|
|
&FOLDERID_Desktop,
|
|
CSIDL_Type_User,
|
|
L"Desktop",
|
|
MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY),
|
|
#ifdef __REACTOS__
|
|
0
|
|
#else
|
|
-IDI_SHELL_DESKTOP
|
|
#endif
|
|
},
|
|
{ /* 0x01 - CSIDL_INTERNET */
|
|
&FOLDERID_InternetFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x02 - CSIDL_PROGRAMS */
|
|
&FOLDERID_Programs,
|
|
CSIDL_Type_User,
|
|
L"Programs",
|
|
MAKEINTRESOURCEW(IDS_PROGRAMS),
|
|
#ifdef __REACTOS__
|
|
0
|
|
#else
|
|
-IDI_SHELL_PROGRAMS_FOLDER
|
|
#endif
|
|
},
|
|
{ /* 0x03 - CSIDL_CONTROLS (.CPL files) */
|
|
&FOLDERID_ControlPanelFolder,
|
|
CSIDL_Type_SystemPath,
|
|
NULL,
|
|
NULL,
|
|
-IDI_SHELL_CONTROL_PANEL
|
|
},
|
|
{ /* 0x04 - CSIDL_PRINTERS */
|
|
&FOLDERID_PrintersFolder,
|
|
CSIDL_Type_SystemPath,
|
|
NULL,
|
|
NULL,
|
|
-IDI_SHELL_PRINTERS_FOLDER
|
|
},
|
|
{ /* 0x05 - CSIDL_PERSONAL */
|
|
&FOLDERID_Documents,
|
|
CSIDL_Type_User,
|
|
L"Personal",
|
|
MAKEINTRESOURCEW(IDS_PERSONAL),
|
|
-IDI_SHELL_MY_DOCUMENTS
|
|
},
|
|
{ /* 0x06 - CSIDL_FAVORITES */
|
|
&FOLDERID_Favorites,
|
|
CSIDL_Type_User,
|
|
L"Favorites",
|
|
MAKEINTRESOURCEW(IDS_FAVORITES),
|
|
-IDI_SHELL_FAVORITES
|
|
},
|
|
{ /* 0x07 - CSIDL_STARTUP */
|
|
&FOLDERID_Startup,
|
|
CSIDL_Type_User,
|
|
L"StartUp",
|
|
MAKEINTRESOURCEW(IDS_STARTUP)
|
|
},
|
|
{ /* 0x08 - CSIDL_RECENT */
|
|
&FOLDERID_Recent,
|
|
CSIDL_Type_User,
|
|
L"Recent",
|
|
MAKEINTRESOURCEW(IDS_RECENT),
|
|
-IDI_SHELL_RECENT_DOCUMENTS
|
|
},
|
|
{ /* 0x09 - CSIDL_SENDTO */
|
|
&FOLDERID_SendTo,
|
|
CSIDL_Type_User,
|
|
L"SendTo",
|
|
MAKEINTRESOURCEW(IDS_SENDTO)
|
|
},
|
|
{ /* 0x0a - CSIDL_BITBUCKET - Recycle Bin */
|
|
&FOLDERID_RecycleBinFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x0b - CSIDL_STARTMENU */
|
|
&FOLDERID_StartMenu,
|
|
CSIDL_Type_User,
|
|
L"Start Menu",
|
|
MAKEINTRESOURCEW(IDS_STARTMENU),
|
|
-IDI_SHELL_TSKBAR_STARTMENU
|
|
},
|
|
{ /* 0x0c - CSIDL_MYDOCUMENTS */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed, /* matches WinXP--can't get its path */
|
|
NULL,
|
|
NULL,
|
|
-IDI_SHELL_MY_DOCUMENTS
|
|
},
|
|
{ /* 0x0d - CSIDL_MYMUSIC */
|
|
&FOLDERID_Music,
|
|
#ifdef __REACTOS__
|
|
CSIDL_Type_InMyDocuments,
|
|
#else
|
|
CSIDL_Type_User,
|
|
#endif
|
|
L"My Music",
|
|
MAKEINTRESOURCEW(IDS_MYMUSIC),
|
|
-IDI_SHELL_MY_MUSIC
|
|
},
|
|
{ /* 0x0e - CSIDL_MYVIDEO */
|
|
&FOLDERID_Videos,
|
|
#ifdef __REACTOS__
|
|
CSIDL_Type_InMyDocuments,
|
|
#else
|
|
CSIDL_Type_User,
|
|
#endif
|
|
L"My Video",
|
|
MAKEINTRESOURCEW(IDS_MYVIDEO),
|
|
-IDI_SHELL_MY_MOVIES
|
|
},
|
|
{ /* 0x0f - unassigned */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
},
|
|
{ /* 0x10 - CSIDL_DESKTOPDIRECTORY */
|
|
&FOLDERID_Desktop,
|
|
CSIDL_Type_User,
|
|
L"Desktop",
|
|
MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY),
|
|
#ifdef __REACTOS__
|
|
0
|
|
#else
|
|
-IDI_SHELL_DESKTOP
|
|
#endif
|
|
},
|
|
{ /* 0x11 - CSIDL_DRIVES */
|
|
&FOLDERID_ComputerFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
-IDI_SHELL_COMPUTER_FOLDER
|
|
},
|
|
{ /* 0x12 - CSIDL_NETWORK */
|
|
&FOLDERID_NetworkFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
-IDI_SHELL_NETWORK_FOLDER
|
|
},
|
|
{ /* 0x13 - CSIDL_NETHOOD */
|
|
&FOLDERID_NetHood,
|
|
CSIDL_Type_User,
|
|
L"NetHood",
|
|
MAKEINTRESOURCEW(IDS_NETHOOD),
|
|
-IDI_SHELL_NETWORK
|
|
},
|
|
{ /* 0x14 - CSIDL_FONTS */
|
|
&FOLDERID_Fonts,
|
|
CSIDL_Type_WindowsPath,
|
|
L"Fonts",
|
|
L"Fonts",
|
|
-IDI_SHELL_FONTS_FOLDER
|
|
},
|
|
{ /* 0x15 - CSIDL_TEMPLATES */
|
|
&FOLDERID_Templates,
|
|
CSIDL_Type_User,
|
|
L"Templates",
|
|
MAKEINTRESOURCEW(IDS_TEMPLATES)
|
|
},
|
|
{ /* 0x16 - CSIDL_COMMON_STARTMENU */
|
|
&FOLDERID_CommonStartMenu,
|
|
CSIDL_Type_AllUsers,
|
|
L"Common Start Menu",
|
|
MAKEINTRESOURCEW(IDS_STARTMENU),
|
|
-IDI_SHELL_TSKBAR_STARTMENU
|
|
},
|
|
{ /* 0x17 - CSIDL_COMMON_PROGRAMS */
|
|
&FOLDERID_CommonPrograms,
|
|
CSIDL_Type_AllUsers,
|
|
L"Common Programs",
|
|
MAKEINTRESOURCEW(IDS_PROGRAMS),
|
|
#ifdef __REACTOS__
|
|
0
|
|
#else
|
|
-IDI_SHELL_PROGRAMS_FOLDER
|
|
#endif
|
|
},
|
|
{ /* 0x18 - CSIDL_COMMON_STARTUP */
|
|
&FOLDERID_CommonStartup,
|
|
CSIDL_Type_AllUsers,
|
|
L"Common StartUp",
|
|
MAKEINTRESOURCEW(IDS_STARTUP)
|
|
},
|
|
{ /* 0x19 - CSIDL_COMMON_DESKTOPDIRECTORY */
|
|
&FOLDERID_PublicDesktop,
|
|
CSIDL_Type_AllUsers,
|
|
L"Common Desktop",
|
|
MAKEINTRESOURCEW(IDS_DESKTOPDIRECTORY),
|
|
#ifdef __REACTOS__
|
|
0
|
|
#else
|
|
-IDI_SHELL_DESKTOP
|
|
#endif
|
|
},
|
|
{ /* 0x1a - CSIDL_APPDATA */
|
|
&FOLDERID_RoamingAppData,
|
|
CSIDL_Type_User,
|
|
L"AppData",
|
|
MAKEINTRESOURCEW(IDS_APPDATA)
|
|
},
|
|
{ /* 0x1b - CSIDL_PRINTHOOD */
|
|
&FOLDERID_PrintHood,
|
|
CSIDL_Type_User,
|
|
L"PrintHood",
|
|
MAKEINTRESOURCEW(IDS_PRINTHOOD),
|
|
-IDI_SHELL_PRINTERS_FOLDER
|
|
},
|
|
{ /* 0x1c - CSIDL_LOCAL_APPDATA */
|
|
&FOLDERID_LocalAppData,
|
|
CSIDL_Type_User,
|
|
L"Local AppData",
|
|
MAKEINTRESOURCEW(IDS_LOCAL_APPDATA)
|
|
},
|
|
{ /* 0x1d - CSIDL_ALTSTARTUP */
|
|
&GUID_NULL,
|
|
CSIDL_Type_NonExistent,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x1e - CSIDL_COMMON_ALTSTARTUP */
|
|
&GUID_NULL,
|
|
CSIDL_Type_NonExistent,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x1f - CSIDL_COMMON_FAVORITES */
|
|
&FOLDERID_Favorites,
|
|
CSIDL_Type_AllUsers,
|
|
L"Common Favorites",
|
|
MAKEINTRESOURCEW(IDS_FAVORITES),
|
|
-IDI_SHELL_FAVORITES
|
|
},
|
|
{ /* 0x20 - CSIDL_INTERNET_CACHE */
|
|
&FOLDERID_InternetCache,
|
|
CSIDL_Type_User,
|
|
L"Cache",
|
|
MAKEINTRESOURCEW(IDS_INTERNET_CACHE)
|
|
},
|
|
{ /* 0x21 - CSIDL_COOKIES */
|
|
&FOLDERID_Cookies,
|
|
CSIDL_Type_User,
|
|
L"Cookies",
|
|
MAKEINTRESOURCEW(IDS_COOKIES)
|
|
},
|
|
{ /* 0x22 - CSIDL_HISTORY */
|
|
&FOLDERID_History,
|
|
CSIDL_Type_User,
|
|
L"History",
|
|
MAKEINTRESOURCEW(IDS_HISTORY)
|
|
},
|
|
{ /* 0x23 - CSIDL_COMMON_APPDATA */
|
|
&FOLDERID_ProgramData,
|
|
CSIDL_Type_AllUsers,
|
|
L"Common AppData",
|
|
MAKEINTRESOURCEW(IDS_APPDATA)
|
|
},
|
|
{ /* 0x24 - CSIDL_WINDOWS */
|
|
&FOLDERID_Windows,
|
|
CSIDL_Type_WindowsPath,
|
|
NULL,
|
|
NULL,
|
|
-IDI_SHELL_SYSTEM_GEAR
|
|
},
|
|
{ /* 0x25 - CSIDL_SYSTEM */
|
|
&FOLDERID_System,
|
|
CSIDL_Type_SystemPath,
|
|
NULL,
|
|
NULL,
|
|
-IDI_SHELL_SYSTEM_GEAR
|
|
},
|
|
{ /* 0x26 - CSIDL_PROGRAM_FILES */
|
|
&FOLDERID_ProgramFiles,
|
|
CSIDL_Type_CurrVer,
|
|
L"ProgramFilesDir",
|
|
MAKEINTRESOURCEW(IDS_PROGRAM_FILES),
|
|
#ifdef __REACTOS__
|
|
0
|
|
#else
|
|
-IDI_SHELL_PROGRAMS_FOLDER
|
|
#endif
|
|
},
|
|
{ /* 0x27 - CSIDL_MYPICTURES */
|
|
&FOLDERID_Pictures,
|
|
#ifdef __REACTOS__
|
|
CSIDL_Type_InMyDocuments,
|
|
#else
|
|
CSIDL_Type_User,
|
|
#endif
|
|
L"My Pictures",
|
|
MAKEINTRESOURCEW(IDS_MYPICTURES),
|
|
-IDI_SHELL_MY_PICTURES
|
|
},
|
|
{ /* 0x28 - CSIDL_PROFILE */
|
|
&FOLDERID_Profile,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x29 - CSIDL_SYSTEMX86 */
|
|
&FOLDERID_SystemX86,
|
|
CSIDL_Type_SystemX86Path,
|
|
NULL,
|
|
NULL,
|
|
-IDI_SHELL_SYSTEM_GEAR
|
|
},
|
|
{ /* 0x2a - CSIDL_PROGRAM_FILESX86 */
|
|
&FOLDERID_ProgramFilesX86,
|
|
CSIDL_Type_CurrVer,
|
|
L"ProgramFilesDir (x86)",
|
|
L"Program Files (x86)",
|
|
-IDI_SHELL_PROGRAMS_FOLDER
|
|
},
|
|
{ /* 0x2b - CSIDL_PROGRAM_FILES_COMMON */
|
|
&FOLDERID_ProgramFilesCommon,
|
|
CSIDL_Type_CurrVer,
|
|
L"CommonFilesDir",
|
|
MAKEINTRESOURCEW(IDS_PROGRAM_FILES_COMMON),
|
|
-IDI_SHELL_PROGRAMS_FOLDER
|
|
},
|
|
{ /* 0x2c - CSIDL_PROGRAM_FILES_COMMONX86 */
|
|
&FOLDERID_ProgramFilesCommonX86,
|
|
CSIDL_Type_CurrVer,
|
|
L"CommonFilesDir (x86)",
|
|
L"Program Files (x86)\\Common Files",
|
|
-IDI_SHELL_PROGRAMS_FOLDER
|
|
},
|
|
{ /* 0x2d - CSIDL_COMMON_TEMPLATES */
|
|
&FOLDERID_CommonTemplates,
|
|
CSIDL_Type_AllUsers,
|
|
L"Common Templates",
|
|
MAKEINTRESOURCEW(IDS_TEMPLATES)
|
|
},
|
|
{ /* 0x2e - CSIDL_COMMON_DOCUMENTS */
|
|
&FOLDERID_PublicDocuments,
|
|
CSIDL_Type_AllUsers,
|
|
L"Common Documents",
|
|
MAKEINTRESOURCEW(IDS_PERSONAL),
|
|
-IDI_SHELL_MY_DOCUMENTS
|
|
},
|
|
{ /* 0x2f - CSIDL_COMMON_ADMINTOOLS */
|
|
&FOLDERID_CommonAdminTools,
|
|
CSIDL_Type_AllUsers,
|
|
L"Common Administrative Tools",
|
|
MAKEINTRESOURCEW(IDS_ADMINTOOLS)
|
|
},
|
|
{ /* 0x30 - CSIDL_ADMINTOOLS */
|
|
&FOLDERID_AdminTools,
|
|
CSIDL_Type_User,
|
|
L"Administrative Tools",
|
|
MAKEINTRESOURCEW(IDS_ADMINTOOLS)
|
|
},
|
|
{ /* 0x31 - CSIDL_CONNECTIONS */
|
|
&FOLDERID_ConnectionsFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL,
|
|
-IDI_SHELL_NETWORK_CONNECTIONS
|
|
},
|
|
{ /* 0x32 - unassigned */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x33 - unassigned */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x34 - unassigned */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x35 - CSIDL_COMMON_MUSIC */
|
|
&FOLDERID_PublicMusic,
|
|
CSIDL_Type_AllUsers,
|
|
L"CommonMusic",
|
|
MAKEINTRESOURCEW(IDS_COMMON_MUSIC),
|
|
-IDI_SHELL_MY_MUSIC
|
|
},
|
|
{ /* 0x36 - CSIDL_COMMON_PICTURES */
|
|
&FOLDERID_PublicPictures,
|
|
CSIDL_Type_AllUsers,
|
|
L"CommonPictures",
|
|
MAKEINTRESOURCEW(IDS_COMMON_PICTURES),
|
|
-IDI_SHELL_MY_PICTURES
|
|
},
|
|
{ /* 0x37 - CSIDL_COMMON_VIDEO */
|
|
&FOLDERID_PublicVideos,
|
|
CSIDL_Type_AllUsers,
|
|
L"CommonVideo",
|
|
MAKEINTRESOURCEW(IDS_COMMON_VIDEO),
|
|
-IDI_SHELL_MY_MOVIES
|
|
},
|
|
{ /* 0x38 - CSIDL_RESOURCES */
|
|
&FOLDERID_ResourceDir,
|
|
CSIDL_Type_WindowsPath,
|
|
NULL,
|
|
L"Resources"
|
|
},
|
|
{ /* 0x39 - CSIDL_RESOURCES_LOCALIZED */
|
|
&FOLDERID_LocalizedResourcesDir,
|
|
CSIDL_Type_NonExistent,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x3a - CSIDL_COMMON_OEM_LINKS */
|
|
&FOLDERID_CommonOEMLinks,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
L"OEM Links"
|
|
},
|
|
{ /* 0x3b - CSIDL_CDBURN_AREA */
|
|
&FOLDERID_CDBurning,
|
|
CSIDL_Type_User,
|
|
L"CD Burning",
|
|
L"Local Settings\\Application Data\\Microsoft\\CD Burning"
|
|
},
|
|
{ /* 0x3c unassigned */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x3d - CSIDL_COMPUTERSNEARME */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x3e - CSIDL_PROFILES */
|
|
&GUID_NULL,
|
|
CSIDL_Type_Disallowed, /* oddly, this matches WinXP */
|
|
NULL,
|
|
NULL
|
|
},
|
|
/* Cannot use #if _WIN32_WINNT >= 0x0600 because _WIN32_WINNT == 0x0600 here. */
|
|
#ifndef __REACTOS__
|
|
{ /* 0x3f */
|
|
&FOLDERID_AddNewPrograms,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x40 */
|
|
&FOLDERID_AppUpdates,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x41 */
|
|
&FOLDERID_ChangeRemovePrograms,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x42 */
|
|
&FOLDERID_ConflictFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x43 - CSIDL_CONTACTS */
|
|
&FOLDERID_Contacts,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
L"Contacts"
|
|
},
|
|
{ /* 0x44 */
|
|
&FOLDERID_DeviceMetadataStore,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x45 */
|
|
&GUID_NULL,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
L"Documents"
|
|
},
|
|
{ /* 0x46 */
|
|
&FOLDERID_DocumentsLibrary,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x47 - CSIDL_DOWNLOADS */
|
|
&FOLDERID_Downloads,
|
|
#ifdef __REACTOS__
|
|
CSIDL_Type_InMyDocuments,
|
|
#else
|
|
CSIDL_Type_User,
|
|
#endif
|
|
NULL,
|
|
L"Downloads"
|
|
},
|
|
{ /* 0x48 */
|
|
&FOLDERID_Games,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x49 */
|
|
&FOLDERID_GameTasks,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x4a */
|
|
&FOLDERID_HomeGroup,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x4b */
|
|
&FOLDERID_ImplicitAppShortcuts,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x4c */
|
|
&FOLDERID_Libraries,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x4d - CSIDL_LINKS */
|
|
&FOLDERID_Links,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
L"Links"
|
|
},
|
|
{ /* 0x4e - CSIDL_APPDATA_LOCALLOW */
|
|
&FOLDERID_LocalAppDataLow,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
L"AppData\\LocalLow"
|
|
},
|
|
{ /* 0x4f */
|
|
&FOLDERID_MusicLibrary,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x50 */
|
|
&FOLDERID_OriginalImages,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x51 */
|
|
&FOLDERID_PhotoAlbums,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
L"Pictures\\Slide Shows"
|
|
},
|
|
{ /* 0x52 */
|
|
&FOLDERID_PicturesLibrary,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x53 */
|
|
&FOLDERID_Playlists,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
L"Music\\Playlists"
|
|
},
|
|
{ /* 0x54 */
|
|
&FOLDERID_ProgramFilesX64,
|
|
CSIDL_Type_NonExistent,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x55 */
|
|
&FOLDERID_ProgramFilesCommonX64,
|
|
CSIDL_Type_NonExistent,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x56 */
|
|
&FOLDERID_Public,
|
|
CSIDL_Type_CurrVer, /* FIXME */
|
|
NULL,
|
|
L"Users\\Public"
|
|
},
|
|
{ /* 0x57 */
|
|
&FOLDERID_PublicDownloads,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
L"Downloads"
|
|
},
|
|
{ /* 0x58 */
|
|
&FOLDERID_PublicGameTasks,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
L"Microsoft\\Windows\\GameExplorer"
|
|
},
|
|
{ /* 0x59 */
|
|
&FOLDERID_PublicLibraries,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
L"Microsoft\\Windows\\Libraries"
|
|
},
|
|
{ /* 0x5a */
|
|
&FOLDERID_PublicRingtones,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
L"Microsoft\\Windows\\Ringtones"
|
|
},
|
|
{ /* 0x5b */
|
|
&FOLDERID_QuickLaunch,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x5c */
|
|
&FOLDERID_RecordedTVLibrary,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x5d */
|
|
&FOLDERID_Ringtones,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x5e */
|
|
&FOLDERID_SampleMusic,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
L"Music\\Sample Music"
|
|
},
|
|
{ /* 0x5f */
|
|
&FOLDERID_SamplePictures,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
L"Pictures\\Sample Pictures"
|
|
},
|
|
{ /* 0x60 */
|
|
&FOLDERID_SamplePlaylists,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
L"Music\\Sample Playlists"
|
|
},
|
|
{ /* 0x61 */
|
|
&FOLDERID_SampleVideos,
|
|
CSIDL_Type_AllUsers,
|
|
NULL,
|
|
L"Videos\\Sample Videos"
|
|
},
|
|
{ /* 0x62 - CSIDL_SAVED_GAMES */
|
|
&FOLDERID_SavedGames,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
L"Saved Games"
|
|
},
|
|
{ /* 0x63 - CSIDL_SEARCHES */
|
|
&FOLDERID_SavedSearches,
|
|
CSIDL_Type_User,
|
|
NULL,
|
|
L"Searches"
|
|
},
|
|
{ /* 0x64 */
|
|
&FOLDERID_SEARCH_CSC,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x65 */
|
|
&FOLDERID_SEARCH_MAPI,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x66 */
|
|
&FOLDERID_SearchHome,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x67 */
|
|
&FOLDERID_SidebarDefaultParts,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x68 */
|
|
&FOLDERID_SidebarParts,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x69 */
|
|
&FOLDERID_SyncManagerFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x6a */
|
|
&FOLDERID_SyncResultsFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x6b */
|
|
&FOLDERID_SyncSetupFolder,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x6c */
|
|
&FOLDERID_UserPinned,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x6d */
|
|
&FOLDERID_UserProfiles,
|
|
CSIDL_Type_CurrVer,
|
|
L"Users",
|
|
L"Users"
|
|
},
|
|
{ /* 0x6e */
|
|
&FOLDERID_UserProgramFiles,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x6f */
|
|
&FOLDERID_UserProgramFilesCommon,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x70 */
|
|
&FOLDERID_UsersFiles,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x71 */
|
|
&FOLDERID_UsersLibraries,
|
|
CSIDL_Type_Disallowed,
|
|
NULL,
|
|
NULL
|
|
},
|
|
{ /* 0x72 */
|
|
&FOLDERID_VideosLibrary,
|
|
CSIDL_Type_Disallowed, /* FIXME */
|
|
NULL,
|
|
NULL
|
|
}
|
|
#endif
|
|
};
|
|
|
|
#ifndef __REACTOS__
|
|
static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest);
|
|
#else
|
|
static HRESULT _SHExpandEnvironmentStrings(HANDLE hToken, LPCWSTR szSrc, LPWSTR szDest, DWORD cchDest);
|
|
#endif
|
|
|
|
/* Gets the value named value from the registry key
|
|
* rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
|
|
* (or from rootKey\userPrefix\... if userPrefix is not NULL) into path, which
|
|
* is assumed to be MAX_PATH WCHARs in length.
|
|
* If it exists, expands the value and writes the expanded value to
|
|
* rootKey\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
|
|
* Returns successful error code if the value was retrieved from the registry,
|
|
* and a failure otherwise.
|
|
*/
|
|
#ifndef __REACTOS__
|
|
static HRESULT _SHGetUserShellFolderPath(HKEY rootKey, LPCWSTR userPrefix,
|
|
#else
|
|
static HRESULT _SHGetUserShellFolderPath(HKEY rootKey, HANDLE hToken, LPCWSTR userPrefix,
|
|
#endif
|
|
LPCWSTR value, LPWSTR path)
|
|
{
|
|
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;
|
|
}
|
|
|
|
BOOL _SHGetUserProfileDirectoryW(HANDLE hToken, LPWSTR szPath, LPDWORD lpcchPath)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/* Gets a 'semi-expanded' default value of the CSIDL with index folder into
|
|
* pszPath, based on the entries in CSIDL_Data. By semi-expanded, I mean:
|
|
* - The entry's szDefaultPath may be either a string value or an integer
|
|
* resource identifier. In the latter case, the string value of the resource
|
|
* is written.
|
|
* - Depending on the entry's type, the path may begin with an (unexpanded)
|
|
* environment variable name. The caller is responsible for expanding
|
|
* environment strings if so desired.
|
|
* The types that are prepended with environment variables are:
|
|
* CSIDL_Type_User: %USERPROFILE%
|
|
* CSIDL_Type_AllUsers: %ALLUSERSPROFILE%
|
|
* CSIDL_Type_CurrVer: %SystemDrive%
|
|
* (Others might make sense too, but as yet are unneeded.)
|
|
*/
|
|
#ifndef __REACTOS__
|
|
static HRESULT _SHGetDefaultValue(BYTE folder, LPWSTR pszPath)
|
|
#else
|
|
static HRESULT _SHGetDefaultValue(HANDLE hToken, BYTE folder, LPWSTR pszPath)
|
|
#endif
|
|
{
|
|
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;
|
|
}
|
|
|
|
/* Gets the (unexpanded) value of the folder with index folder into pszPath.
|
|
* The folder's type is assumed to be CSIDL_Type_CurrVer. Its default value
|
|
* can be overridden in the HKLM\\Software\\Microsoft\\Windows\\CurrentVersion key.
|
|
* If dwFlags has SHGFP_TYPE_DEFAULT set or if the value isn't overridden in
|
|
* the registry, uses _SHGetDefaultValue to get the value.
|
|
*/
|
|
static HRESULT _SHGetCurrentVersionPath(DWORD dwFlags, BYTE folder,
|
|
LPWSTR pszPath)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static LPWSTR _GetUserSidStringFromToken(HANDLE Token)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/* Gets the user's path (unexpanded) for the CSIDL with index folder:
|
|
* If SHGFP_TYPE_DEFAULT is set, calls _SHGetDefaultValue for it. Otherwise
|
|
* calls _SHGetUserShellFolderPath for it. Where it looks depends on hToken:
|
|
* - if hToken is -1, looks in HKEY_USERS\.Default
|
|
* - otherwise looks first in HKEY_CURRENT_USER, followed by HKEY_LOCAL_MACHINE
|
|
* if HKEY_CURRENT_USER doesn't contain any entries. If both fail, finally
|
|
* calls _SHGetDefaultValue for it.
|
|
*/
|
|
static HRESULT _SHGetUserProfilePath(HANDLE hToken, DWORD dwFlags, BYTE folder,
|
|
LPWSTR pszPath)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/* Gets the (unexpanded) path for the CSIDL with index folder. If dwFlags has
|
|
* SHGFP_TYPE_DEFAULT set, calls _SHGetDefaultValue. Otherwise calls
|
|
* _SHGetUserShellFolderPath for it, looking only in HKEY_LOCAL_MACHINE.
|
|
* If this fails, falls back to _SHGetDefaultValue.
|
|
*/
|
|
static HRESULT _SHGetAllUsersProfilePath(DWORD dwFlags, BYTE folder,
|
|
LPWSTR pszPath)
|
|
{
|
|
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;
|
|
}
|
|
|
|
#ifndef __REACTOS__
|
|
static HRESULT _SHOpenProfilesKey(PHKEY pKey)
|
|
{
|
|
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);
|
|
}
|
|
|
|
/* Reads the value named szValueName from the key profilesKey (assumed to be
|
|
* opened by _SHOpenProfilesKey) into szValue, which is assumed to be MAX_PATH
|
|
* WCHARs in length. If it doesn't exist, returns szDefault (and saves
|
|
* szDefault to the registry).
|
|
*/
|
|
static HRESULT _SHGetProfilesValue(HKEY profilesKey, LPCWSTR szValueName,
|
|
LPWSTR szValue, LPCWSTR szDefault)
|
|
{
|
|
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;
|
|
}
|
|
#endif
|
|
|
|
/* Attempts to expand environment variables from szSrc into szDest, which is
|
|
* assumed to be MAX_PATH characters in length. Before referring to the
|
|
* environment, handles a few variables directly, because the environment
|
|
* variables may not be set when this is called (as during Wine's installation
|
|
* when default values are being written to the registry).
|
|
* The directly handled environment variables, and their source, are:
|
|
* - ALLUSERSPROFILE, USERPROFILE: reads from the registry
|
|
* - SystemDrive: uses GetSystemDirectoryW and uses the drive portion of its
|
|
* path
|
|
* If one of the directly handled environment variables is expanded, only
|
|
* expands a single variable, and only in the beginning of szSrc.
|
|
*/
|
|
#ifndef __REACTOS__
|
|
static HRESULT _SHExpandEnvironmentStrings(LPCWSTR szSrc, LPWSTR szDest)
|
|
#else
|
|
static HRESULT _SHExpandEnvironmentStrings(HANDLE hToken, LPCWSTR szSrc, LPWSTR szDest, DWORD cchDest)
|
|
#endif
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* SHGetFolderPathW [SHELL32.@]
|
|
*
|
|
* Convert nFolder to path.
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK
|
|
* Failure: standard HRESULT error codes.
|
|
*
|
|
* NOTES
|
|
* Most values can be overridden in either
|
|
* HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
|
|
* or in the same location in HKLM.
|
|
* The "Shell Folders" registry key was used in NT4 and earlier systems.
|
|
* Beginning with Windows 2000, the "User Shell Folders" key is used, so
|
|
* changes made to it are made to the former key too. This synchronization is
|
|
* done on-demand: not until someone requests the value of one of these paths
|
|
* (by calling one of the SHGet functions) is the value synchronized.
|
|
* Furthermore, the HKCU paths take precedence over the HKLM paths.
|
|
*/
|
|
HRESULT WINAPI SHGetFolderPathW(
|
|
HWND hwndOwner, /* [I] owner window */
|
|
int nFolder, /* [I] CSIDL identifying the folder */
|
|
HANDLE hToken, /* [I] access token */
|
|
DWORD dwFlags, /* [I] which path to return */
|
|
LPWSTR pszPath) /* [O] converted path */
|
|
{
|
|
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;
|
|
}
|
|
|
|
HRESULT WINAPI SHGetFolderPathAndSubDirA(
|
|
HWND hwndOwner, /* [I] owner window */
|
|
int nFolder, /* [I] CSIDL identifying the folder */
|
|
HANDLE hToken, /* [I] access token */
|
|
DWORD dwFlags, /* [I] which path to return */
|
|
LPCSTR pszSubPath, /* [I] sub directory of the specified folder */
|
|
LPSTR pszPath) /* [O] converted path */
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* SHGetFolderPathAndSubDirW [SHELL32.@]
|
|
*/
|
|
HRESULT WINAPI SHGetFolderPathAndSubDirW(
|
|
HWND hwndOwner, /* [I] owner window */
|
|
int nFolder, /* [I] CSIDL identifying the folder */
|
|
HANDLE hToken, /* [I] access token */
|
|
DWORD dwFlags, /* [I] which path to return */
|
|
LPCWSTR pszSubPath,/* [I] sub directory of the specified folder */
|
|
LPWSTR pszPath) /* [O] converted path */
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* SHGetFolderPathA [SHELL32.@]
|
|
*
|
|
* See SHGetFolderPathW.
|
|
*/
|
|
HRESULT WINAPI SHGetFolderPathA(
|
|
HWND hwndOwner,
|
|
int nFolder,
|
|
HANDLE hToken,
|
|
DWORD dwFlags,
|
|
LPSTR pszPath)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/* For each folder in folders, if its value has not been set in the registry,
|
|
* calls _SHGetUserProfilePath or _SHGetAllUsersProfilePath (depending on the
|
|
* folder's type) to get the unexpanded value first.
|
|
* Writes the unexpanded value to User Shell Folders, and queries it with
|
|
* SHGetFolderPathW to force the creation of the directory if it doesn't
|
|
* already exist. SHGetFolderPathW also returns the expanded value, which
|
|
* this then writes to Shell Folders.
|
|
*/
|
|
static HRESULT _SHRegisterFolders(HKEY hRootKey, HANDLE hToken,
|
|
LPCWSTR szUserShellFolderPath, LPCWSTR szShellFolderPath, const UINT folders[],
|
|
UINT foldersLen)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static HRESULT _SHRegisterUserShellFolders(BOOL bDefault)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static HRESULT _SHRegisterCommonShellFolders(void)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/* Register the default values in the registry, as some apps seem to depend
|
|
* on their presence. The set registered was taken from Windows XP.
|
|
*/
|
|
HRESULT SHELL_RegisterShellFolders(void)
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = _SHRegisterUserShellFolders(TRUE);
|
|
if (SUCCEEDED(hr))
|
|
hr = _SHRegisterUserShellFolders(FALSE);
|
|
if (SUCCEEDED(hr))
|
|
hr = _SHRegisterCommonShellFolders();
|
|
return hr;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* SHGetSpecialFolderPathA [SHELL32.@]
|
|
*/
|
|
BOOL WINAPI SHGetSpecialFolderPathA (
|
|
HWND hwndOwner,
|
|
LPSTR szPath,
|
|
int nFolder,
|
|
BOOL bCreate)
|
|
{
|
|
return SHGetFolderPathA(hwndOwner, nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0), NULL, 0,
|
|
szPath) == S_OK;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* SHGetSpecialFolderPathW
|
|
*/
|
|
BOOL WINAPI SHGetSpecialFolderPathW (
|
|
HWND hwndOwner,
|
|
LPWSTR szPath,
|
|
int nFolder,
|
|
BOOL bCreate)
|
|
{
|
|
return SHGetFolderPathW(hwndOwner, nFolder + (bCreate ? CSIDL_FLAG_CREATE : 0), NULL, 0,
|
|
szPath) == S_OK;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* SHGetFolderLocation [SHELL32.@]
|
|
*
|
|
* Gets the folder locations from the registry and creates a pidl.
|
|
*
|
|
* PARAMS
|
|
* hwndOwner [I]
|
|
* nFolder [I] CSIDL_xxxxx
|
|
* hToken [I] token representing user, or NULL for current user, or -1 for
|
|
* default user
|
|
* dwReserved [I] must be zero
|
|
* ppidl [O] PIDL of a special folder
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK
|
|
* Failure: Standard OLE-defined error result, S_FALSE or E_INVALIDARG
|
|
*
|
|
* NOTES
|
|
* Creates missing reg keys and directories.
|
|
* Mostly forwards to SHGetFolderPathW, but a few values of nFolder return
|
|
* virtual folders that are handled here.
|
|
*/
|
|
HRESULT WINAPI SHGetFolderLocation(
|
|
HWND hwndOwner,
|
|
int nFolder,
|
|
HANDLE hToken,
|
|
DWORD dwReserved,
|
|
LPITEMIDLIST *ppidl)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* SHGetSpecialFolderLocation [SHELL32.@]
|
|
*
|
|
* NOTES
|
|
* In NT5, SHGetSpecialFolderLocation needs the <winntdir>/Recent
|
|
* directory.
|
|
*/
|
|
HRESULT WINAPI SHGetSpecialFolderLocation(
|
|
HWND hwndOwner,
|
|
INT nFolder,
|
|
LPITEMIDLIST * ppidl)
|
|
{
|
|
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;
|
|
}
|