2426 lines
65 KiB
C++
2426 lines
65 KiB
C++
#include "pch.h"
|
|
#include <shsemip.h> // ILClone, ILIsEmpty, etc.
|
|
#include <sddl.h>
|
|
#include "security.h"
|
|
#include "idlhelp.h"
|
|
#include "shguidp.h"
|
|
#include "folder.h"
|
|
#include "strings.h"
|
|
#include <ccstock.h>
|
|
|
|
#ifdef DEBUG
|
|
#define SZ_DEBUGINI "ccshell.ini"
|
|
#define SZ_DEBUGSECTION "CSC UI"
|
|
#define SZ_MODULE "CSCUI.DLL"
|
|
// (These are deliberately CHAR)
|
|
EXTERN_C const CHAR c_szCcshellIniFile[] = SZ_DEBUGINI;
|
|
EXTERN_C const CHAR c_szCcshellIniSecDebug[] = SZ_DEBUGSECTION;
|
|
|
|
EXTERN_C const WCHAR c_wszTrace[] = L"t " TEXTW(SZ_MODULE) L" ";
|
|
EXTERN_C const WCHAR c_wszErrorDbg[] = L"err " TEXTW(SZ_MODULE) L" ";
|
|
EXTERN_C const WCHAR c_wszWarningDbg[] = L"wn " TEXTW(SZ_MODULE) L" ";
|
|
EXTERN_C const WCHAR c_wszAssertMsg[] = TEXTW(SZ_MODULE) L" Assert: ";
|
|
EXTERN_C const WCHAR c_wszAssertFailed[] = TEXTW(SZ_MODULE) L" Assert %ls, line %d: (%ls)\r\n";
|
|
EXTERN_C const WCHAR c_wszRip[] = TEXTW(SZ_MODULE) L" RIP in %s at %s, line %d: (%s)\r\n";
|
|
EXTERN_C const WCHAR c_wszRipNoFn[] = TEXTW(SZ_MODULE) L" RIP at %s, line %d: (%s)\r\n";
|
|
|
|
// (These are deliberately CHAR)
|
|
EXTERN_C const CHAR c_szTrace[] = "t " SZ_MODULE " ";
|
|
EXTERN_C const CHAR c_szErrorDbg[] = "err " SZ_MODULE " ";
|
|
EXTERN_C const CHAR c_szWarningDbg[] = "wn " SZ_MODULE " ";
|
|
EXTERN_C const CHAR c_szAssertMsg[] = SZ_MODULE " Assert: ";
|
|
EXTERN_C const CHAR c_szAssertFailed[] = SZ_MODULE " Assert %s, line %d: (%s)\r\n";
|
|
EXTERN_C const CHAR c_szRip[] = SZ_MODULE " RIP in %s at %s, line %d: (%s)\r\n";
|
|
EXTERN_C const CHAR c_szRipNoFn[] = SZ_MODULE " RIP at %s, line %d: (%s)\r\n";
|
|
EXTERN_C const CHAR c_szRipMsg[] = SZ_MODULE " RIP: ";
|
|
#endif
|
|
|
|
//
|
|
// Purpose: Return UNC version of a path
|
|
//
|
|
// Parameters: pszInName - initial path
|
|
// ppszOutName - UNC path returned here
|
|
//
|
|
//
|
|
// Return: HRESULT
|
|
// S_OK - UNC path returned
|
|
// S_FALSE - drive not connected (UNC not returned)
|
|
// or failure code
|
|
//
|
|
// Notes: The function fails is the path is not a valid
|
|
// network path. If the path is already UNC,
|
|
// a copy is made without validating the path.
|
|
// *ppszOutName must be LocalFree'd by the caller.
|
|
//
|
|
|
|
HRESULT GetRemotePath(LPCTSTR pszInName, LPTSTR *ppszOutName)
|
|
{
|
|
HRESULT hr = HRESULT_FROM_WIN32(ERROR_BAD_PATHNAME);
|
|
|
|
*ppszOutName = NULL;
|
|
|
|
// Don't bother calling GetFullPathName first, since we always
|
|
// deal with full (complete) paths.
|
|
|
|
if (pszInName[1] == TEXT(':'))
|
|
{
|
|
TCHAR szLocalName[3];
|
|
|
|
szLocalName[0] = pszInName[0];
|
|
szLocalName[1] = pszInName[1];
|
|
szLocalName[2] = 0;
|
|
|
|
// Call GetDriveType before WNetGetConnection, to avoid loading
|
|
// MPR.DLL until absolutely necessary.
|
|
if (DRIVE_REMOTE == GetDriveType(szLocalName))
|
|
{
|
|
TCHAR szRemoteName[MAX_PATH];
|
|
DWORD dwLen = ARRAYSIZE(szRemoteName);
|
|
DWORD dwErr = WNetGetConnection(szLocalName, szRemoteName, &dwLen);
|
|
if (NO_ERROR == dwErr)
|
|
{
|
|
dwLen = lstrlen(szRemoteName);
|
|
// Skip the drive letter and add the length of the rest of the path
|
|
// (including NULL)
|
|
pszInName += 2;
|
|
dwLen += lstrlen(pszInName) + 1;
|
|
|
|
// We should never get incomplete paths, so we should always
|
|
// see a backslash after the "X:". If this isn't true, then
|
|
// we should call GetFullPathName above.
|
|
TraceAssert(TEXT('\\') == *pszInName);
|
|
|
|
// Allocate the return buffer
|
|
*ppszOutName = (LPTSTR)LocalAlloc(LPTR, dwLen * sizeof(TCHAR));
|
|
if (*ppszOutName)
|
|
{
|
|
lstrcpy(*ppszOutName, szRemoteName); // root part
|
|
lstrcat(*ppszOutName, pszInName); // rest of path
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else if (ERROR_NOT_CONNECTED == dwErr)
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(dwErr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
else if (PathIsUNC(pszInName))
|
|
{
|
|
// Just copy the path without validating it
|
|
hr = LocalAllocString(ppszOutName, pszInName) ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
PathRemoveBackslash(*ppszOutName);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Purpose: TCHAR version of itoa
|
|
//
|
|
// Parameters: UINT i - unsigned integer to convert
|
|
// LPTSTR psz - location to store string result
|
|
// UINT cchMax - size of buffer pointed to by psz
|
|
//
|
|
|
|
LPTSTR ULongToString(ULONG i, LPTSTR psz, ULONG cchMax)
|
|
{
|
|
wnsprintf(psz, cchMax, TEXT("%d%"), i);
|
|
return psz;
|
|
}
|
|
|
|
//
|
|
// Purpose: Free a string allocated with LocalAlloc[String]
|
|
//
|
|
// Parameters: LPTSTR *ppsz - location of pointer to string
|
|
//
|
|
|
|
void LocalFreeString(LPTSTR *ppsz)
|
|
{
|
|
if (ppsz && *ppsz)
|
|
{
|
|
LocalFree(*ppsz);
|
|
*ppsz = NULL;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Purpose: Copy a string into a newly allocated buffer
|
|
//
|
|
// Parameters: LPTSTR *ppszDest - location to store string copy
|
|
// LPCTSTR pszSrc - string to copy
|
|
//
|
|
// Return: BOOL - FALSE if LocalAlloc fails or invalid parameters
|
|
//
|
|
|
|
BOOL LocalAllocString(LPTSTR *ppszDest, LPCTSTR pszSrc)
|
|
{
|
|
if (!ppszDest)
|
|
return FALSE;
|
|
|
|
*ppszDest = StrDup(pszSrc);
|
|
return *ppszDest ? TRUE : FALSE;
|
|
}
|
|
|
|
//
|
|
// Purpose: Find the length (in chars) of a string resource
|
|
//
|
|
// Parameters: HINSTANCE hInstance - module containing the string
|
|
// UINT idStr - ID of string
|
|
//
|
|
//
|
|
// Return: UINT - # of chars in string, not including NULL
|
|
//
|
|
// Notes: Based on code from user32.
|
|
//
|
|
|
|
UINT SizeofStringResource(HINSTANCE hInstance, UINT idStr)
|
|
{
|
|
UINT cch = 0;
|
|
HRSRC hRes = FindResource(hInstance, (LPTSTR)((LONG_PTR)(((USHORT)idStr >> 4) + 1)), RT_STRING);
|
|
if (NULL != hRes)
|
|
{
|
|
HGLOBAL hStringSeg = LoadResource(hInstance, hRes);
|
|
if (NULL != hStringSeg)
|
|
{
|
|
LPWSTR psz = (LPWSTR)LockResource(hStringSeg);
|
|
if (NULL != psz)
|
|
{
|
|
idStr &= 0x0F;
|
|
while(true)
|
|
{
|
|
cch = *psz++;
|
|
if (idStr-- == 0)
|
|
break;
|
|
psz += cch;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return cch;
|
|
}
|
|
|
|
//
|
|
// Purpose: Loads a string resource into an alloc'd buffer
|
|
//
|
|
// Parameters: ppszResult - string resource returned here
|
|
// hInstance - module to load string from
|
|
// idStr - string resource ID
|
|
//
|
|
// Return: same as LoadString
|
|
//
|
|
// Notes: On successful return, the caller must
|
|
// LocalFree *ppszResult
|
|
//
|
|
|
|
int LoadStringAlloc(LPTSTR *ppszResult, HINSTANCE hInstance, UINT idStr)
|
|
{
|
|
int nResult = 0;
|
|
UINT cch = SizeofStringResource(hInstance, idStr);
|
|
if (cch)
|
|
{
|
|
cch++; // for NULL
|
|
*ppszResult = (LPTSTR)LocalAlloc(LPTR, cch * sizeof(TCHAR));
|
|
if (*ppszResult)
|
|
nResult = LoadString(hInstance, idStr, *ppszResult, cch);
|
|
}
|
|
return nResult;
|
|
}
|
|
|
|
//
|
|
// Purpose: Wrapper for SHChangeNotify
|
|
//
|
|
// Parameters: pszPath - path of file that changed
|
|
// bFlush - TRUE forces a flush of the shell's
|
|
// notify queue.
|
|
//
|
|
// Return: none
|
|
//
|
|
// Notes: SHCNF_PATH doesn't work outside of the shell,
|
|
// so we create a pidl and use SHCNF_IDLIST.
|
|
//
|
|
// Force a flush every 8 calls so the shell
|
|
// doesn't start ignoring notifications.
|
|
//
|
|
|
|
void
|
|
ShellChangeNotify(
|
|
LPCTSTR pszPath,
|
|
WIN32_FIND_DATA *pfd,
|
|
BOOL bFlush,
|
|
LONG nEvent
|
|
)
|
|
{
|
|
LPITEMIDLIST pidlFile = NULL;
|
|
LPCVOID pvItem = NULL;
|
|
UINT uFlags = 0;
|
|
|
|
static int cNoFlush = 0;
|
|
|
|
if (pszPath)
|
|
{
|
|
if ((pfd && SUCCEEDED(SHSimpleIDListFromFindData(pszPath, pfd, &pidlFile)))
|
|
|| (pidlFile = ILCreateFromPath(pszPath)))
|
|
{
|
|
uFlags = SHCNF_IDLIST;
|
|
pvItem = pidlFile;
|
|
}
|
|
else
|
|
{
|
|
// ILCreateFromPath sometimes fails when we're in disconnected
|
|
// mode, so try the path instead.
|
|
uFlags = SHCNF_PATH;
|
|
pvItem = pszPath;
|
|
}
|
|
if (0 == nEvent)
|
|
nEvent = SHCNE_UPDATEITEM;
|
|
}
|
|
else
|
|
nEvent = 0;
|
|
|
|
if (8 < cNoFlush++)
|
|
bFlush = TRUE;
|
|
|
|
if (bFlush)
|
|
{
|
|
uFlags |= (SHCNF_FLUSH | SHCNF_FLUSHNOWAIT);
|
|
cNoFlush = 0;
|
|
}
|
|
SHChangeNotify(nEvent, uFlags, pvItem, NULL);
|
|
|
|
if (pidlFile)
|
|
SHFree(pidlFile);
|
|
}
|
|
|
|
|
|
//
|
|
// Purpose: Get the path to the target file of a link
|
|
//
|
|
// Parameters: pszShortcut - name of link file
|
|
// ppszTarget - target path returned here
|
|
//
|
|
//
|
|
// Return: HRESULT
|
|
// S_OK - target file returned
|
|
// S_FALSE - target not returned
|
|
// or failure code
|
|
//
|
|
// Notes: COM must be initialized before calling.
|
|
// The function fails is the target is a folder.
|
|
// *ppszTarget must be LocalFree'd by the caller.
|
|
//
|
|
|
|
HRESULT GetLinkTarget(LPCTSTR pszShortcut, LPTSTR *ppszTarget, DWORD *pdwAttr)
|
|
{
|
|
*ppszTarget = NULL;
|
|
|
|
if (pdwAttr)
|
|
*pdwAttr = 0;
|
|
|
|
IShellLink *psl;
|
|
HRESULT hr = LoadFromFile(CLSID_ShellLink, pszShortcut, IID_PPV_ARG(IShellLink, &psl));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Get the pidl of the target
|
|
LPITEMIDLIST pidlTarget;
|
|
hr = psl->GetIDList(&pidlTarget);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = S_FALSE; // means no target returned
|
|
TCHAR szTarget[MAX_PATH];
|
|
DWORD dwAttr = SFGAO_FOLDER;
|
|
if (SUCCEEDED(SHGetNameAndFlags(pidlTarget, SHGDN_FORPARSING, szTarget, ARRAYSIZE(szTarget), &dwAttr)))
|
|
{
|
|
if (!(dwAttr & SFGAO_FOLDER))
|
|
{
|
|
if (pdwAttr)
|
|
{
|
|
*pdwAttr = GetFileAttributes(szTarget);
|
|
}
|
|
hr = GetRemotePath(szTarget, ppszTarget);
|
|
}
|
|
}
|
|
SHFree(pidlTarget);
|
|
}
|
|
psl->Release();
|
|
}
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//
|
|
// _CSCEnumDatabase
|
|
//
|
|
// Purpose: Enumerate CSC database recursively
|
|
//
|
|
// Parameters: pszFolder - name of folder to begin enumeration
|
|
// (can be NULL to enum shares)
|
|
// bRecurse - TRUE to recurse into child folders
|
|
// pfnCB - callback function called once for each child
|
|
// lpContext - extra data passed to callback function
|
|
//
|
|
// Return: One of CSCPROC_RETURN_*
|
|
//
|
|
// Notes: Return CSCPROC_RETURN_SKIP from the callback to prevent
|
|
// recursion into a child folder. CSCPROC_RETURN_ABORT
|
|
// will terminate the entire operation (unwind all recursive
|
|
// calls). CSCPROC_RETURN_CONTINUE will continue normally.
|
|
// Other CSCPROC_RETURN_* values are treated as ABORT.
|
|
//
|
|
//*************************************************************
|
|
#define PATH_BUFFER_SIZE 1024
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR szPath;
|
|
int cchPathBuffer;
|
|
BOOL bRecurse;
|
|
PFN_CSCENUMPROC pfnCB;
|
|
LPARAM lpContext;
|
|
} CSC_ENUM_CONTEXT, *PCSC_ENUM_CONTEXT;
|
|
|
|
DWORD
|
|
_CSCEnumDatabaseInternal(PCSC_ENUM_CONTEXT pContext)
|
|
{
|
|
DWORD dwResult = CSCPROC_RETURN_CONTINUE;
|
|
HANDLE hFind;
|
|
DWORD dwStatus = 0;
|
|
DWORD dwPinCount = 0;
|
|
DWORD dwHintFlags = 0;
|
|
LPTSTR pszPath;
|
|
int cchBuffer;
|
|
LPTSTR pszFind = NULL;
|
|
int cchDir = 0;
|
|
WIN32_FIND_DATA fd;
|
|
|
|
TraceEnter(TRACE_UTIL, "_CSCEnumDatabaseInternal");
|
|
TraceAssert(pContext);
|
|
TraceAssert(pContext->pfnCB);
|
|
TraceAssert(pContext->szPath);
|
|
TraceAssert(pContext->cchPathBuffer);
|
|
|
|
pszPath = pContext->szPath;
|
|
cchBuffer = pContext->cchPathBuffer;
|
|
|
|
if (*pszPath)
|
|
{
|
|
PathAddBackslash(pszPath);
|
|
cchDir = lstrlen(pszPath);
|
|
TraceAssert(TEXT('\\') == pszPath[cchDir-1]);
|
|
pszFind = pszPath;
|
|
}
|
|
|
|
// skips "." and ".."
|
|
hFind = CacheFindFirst(pszFind,
|
|
&fd,
|
|
&dwStatus,
|
|
&dwPinCount,
|
|
&dwHintFlags,
|
|
NULL);
|
|
if (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
int cchFile;
|
|
ENUM_REASON eReason = ENUM_REASON_FILE;
|
|
|
|
cchFile = lstrlen(fd.cFileName);
|
|
if (cchFile >= cchBuffer - cchDir)
|
|
{
|
|
// Realloc the path buffer
|
|
TraceMsg("Reallocating path buffer");
|
|
cchBuffer += max(PATH_BUFFER_SIZE, cchFile + 1);
|
|
pszPath = (LPTSTR)LocalReAlloc(pContext->szPath,
|
|
cchBuffer * sizeof(TCHAR),
|
|
LMEM_MOVEABLE);
|
|
if (pszPath)
|
|
{
|
|
pContext->szPath = pszPath;
|
|
pContext->cchPathBuffer = cchBuffer;
|
|
}
|
|
else
|
|
{
|
|
pszPath = pContext->szPath;
|
|
cchBuffer = pContext->cchPathBuffer;
|
|
TraceMsg("Unable to reallocate path buffer");
|
|
Trace((pszPath));
|
|
Trace((fd.cFileName));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Build full path
|
|
lstrcpyn(&pszPath[cchDir],
|
|
fd.cFileName,
|
|
cchBuffer - cchDir);
|
|
cchFile = lstrlen(pszPath);
|
|
|
|
if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) || !pszFind)
|
|
eReason = ENUM_REASON_FOLDER_BEGIN;
|
|
|
|
// Call the callback
|
|
dwResult = (*pContext->pfnCB)(pszPath,
|
|
eReason,
|
|
dwStatus,
|
|
dwHintFlags,
|
|
dwPinCount,
|
|
&fd,
|
|
pContext->lpContext);
|
|
|
|
// Recurse into folders
|
|
if (CSCPROC_RETURN_CONTINUE == dwResult &&
|
|
pContext->bRecurse &&
|
|
ENUM_REASON_FOLDER_BEGIN == eReason)
|
|
{
|
|
dwResult = _CSCEnumDatabaseInternal(pContext);
|
|
|
|
// Call the callback again
|
|
pszPath[cchFile] = 0;
|
|
dwResult = (*pContext->pfnCB)(pszPath,
|
|
ENUM_REASON_FOLDER_END,
|
|
0, // dwStatus, // these have probably changed
|
|
0, // dwHintFlags,
|
|
0, // dwPinCount,
|
|
&fd,
|
|
pContext->lpContext);
|
|
}
|
|
|
|
if (CSCPROC_RETURN_SKIP == dwResult)
|
|
dwResult = CSCPROC_RETURN_CONTINUE;
|
|
|
|
if (CSCPROC_RETURN_CONTINUE != dwResult)
|
|
break;
|
|
|
|
} while (CacheFindNext(hFind,
|
|
&fd,
|
|
&dwStatus,
|
|
&dwPinCount,
|
|
&dwHintFlags,
|
|
NULL));
|
|
CSCFindClose(hFind);
|
|
}
|
|
|
|
TraceLeaveValue(dwResult);
|
|
}
|
|
|
|
|
|
DWORD
|
|
_CSCEnumDatabase(LPCTSTR pszFolder,
|
|
BOOL bRecurse,
|
|
PFN_CSCENUMPROC pfnCB,
|
|
LPARAM lpContext)
|
|
{
|
|
DWORD dwResult = CSCPROC_RETURN_CONTINUE;
|
|
CSC_ENUM_CONTEXT ec;
|
|
|
|
TraceEnter(TRACE_UTIL, "_CSCEnumDatabase");
|
|
TraceAssert(pfnCB);
|
|
|
|
if (!pfnCB)
|
|
TraceLeaveValue(CSCPROC_RETURN_ABORT);
|
|
|
|
// Allocate the single buffer used for the entire enumeration.
|
|
// It will be reallocated later if necessary.
|
|
ec.cchPathBuffer = PATH_BUFFER_SIZE;
|
|
if (pszFolder)
|
|
ec.cchPathBuffer *= ((lstrlen(pszFolder)/PATH_BUFFER_SIZE) + 1);
|
|
ec.szPath = (LPTSTR)LocalAlloc(LMEM_FIXED, ec.cchPathBuffer*sizeof(TCHAR));
|
|
if (!ec.szPath)
|
|
TraceLeaveValue(CSCPROC_RETURN_ABORT);
|
|
|
|
ec.szPath[0] = 0;
|
|
|
|
// Assume pszFolder is valid a directory path or NULL
|
|
if (pszFolder)
|
|
lstrcpyn(ec.szPath, pszFolder, ec.cchPathBuffer);
|
|
|
|
ec.bRecurse = bRecurse;
|
|
ec.pfnCB = pfnCB;
|
|
ec.lpContext = lpContext;
|
|
|
|
dwResult = _CSCEnumDatabaseInternal(&ec);
|
|
|
|
LocalFree(ec.szPath);
|
|
|
|
TraceLeaveValue(dwResult);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//
|
|
// _Win32EnumFolder
|
|
//
|
|
// Purpose: Enumerate a directory recursively
|
|
//
|
|
// Parameters: pszFolder - name of folder to begin enumeration
|
|
// bRecurse - TRUE to recurse into child folders
|
|
// pfnCB - callback function called once for each child
|
|
// lpContext - extra data passed to callback function
|
|
//
|
|
// Return: One of CSCPROC_RETURN_*
|
|
//
|
|
// Notes: Same as _CSCEnumDatabase except using FindFirstFile
|
|
// instead of CSCFindFirstFile.
|
|
//
|
|
//*************************************************************
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR szPath;
|
|
int cchPathBuffer;
|
|
BOOL bRecurse;
|
|
PFN_WIN32ENUMPROC pfnCB;
|
|
LPARAM lpContext;
|
|
} W32_ENUM_CONTEXT, *PW32_ENUM_CONTEXT;
|
|
|
|
DWORD
|
|
_Win32EnumFolderInternal(PW32_ENUM_CONTEXT pContext)
|
|
{
|
|
DWORD dwResult = CSCPROC_RETURN_CONTINUE;
|
|
HANDLE hFind;
|
|
LPTSTR pszPath;
|
|
int cchBuffer;
|
|
int cchDir = 0;
|
|
WIN32_FIND_DATA fd;
|
|
|
|
TraceEnter(TRACE_UTIL, "_Win32EnumFolderInternal");
|
|
TraceAssert(pContext);
|
|
TraceAssert(pContext->pfnCB);
|
|
TraceAssert(pContext->szPath && pContext->szPath[0]);
|
|
TraceAssert(pContext->cchPathBuffer);
|
|
|
|
pszPath = pContext->szPath;
|
|
cchBuffer = pContext->cchPathBuffer;
|
|
|
|
// Build wildcard path
|
|
PathAddBackslash(pszPath);
|
|
cchDir = lstrlen(pszPath);
|
|
TraceAssert(TEXT('\\') == pszPath[cchDir-1]);
|
|
pszPath[cchDir] = TEXT('*');
|
|
pszPath[cchDir+1] = 0;
|
|
|
|
hFind = FindFirstFile(pszPath, &fd);
|
|
if (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
int cchFile;
|
|
ENUM_REASON eReason = ENUM_REASON_FILE;
|
|
|
|
// skip "." and ".."
|
|
if (PathIsDotOrDotDot(fd.cFileName))
|
|
continue;
|
|
|
|
cchFile = lstrlen(fd.cFileName);
|
|
if (cchFile >= cchBuffer - cchDir)
|
|
{
|
|
// Realloc the path buffer
|
|
TraceMsg("Reallocating path buffer");
|
|
cchBuffer += max(PATH_BUFFER_SIZE, cchFile + 1);
|
|
pszPath = (LPTSTR)LocalReAlloc(pContext->szPath,
|
|
cchBuffer * sizeof(TCHAR),
|
|
LMEM_MOVEABLE);
|
|
if (pszPath)
|
|
{
|
|
pContext->szPath = pszPath;
|
|
pContext->cchPathBuffer = cchBuffer;
|
|
}
|
|
else
|
|
{
|
|
pszPath = pContext->szPath;
|
|
cchBuffer = pContext->cchPathBuffer;
|
|
TraceMsg("Unable to reallocate path buffer");
|
|
Trace((pszPath));
|
|
Trace((fd.cFileName));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Build full path
|
|
lstrcpyn(&pszPath[cchDir],
|
|
fd.cFileName,
|
|
cchBuffer - cchDir);
|
|
cchFile = lstrlen(pszPath);
|
|
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
eReason = ENUM_REASON_FOLDER_BEGIN;
|
|
|
|
// Call the callback
|
|
dwResult = (*pContext->pfnCB)(pszPath,
|
|
eReason,
|
|
&fd,
|
|
pContext->lpContext);
|
|
|
|
// Recurse into folders
|
|
if (CSCPROC_RETURN_CONTINUE == dwResult &&
|
|
pContext->bRecurse &&
|
|
ENUM_REASON_FOLDER_BEGIN == eReason)
|
|
{
|
|
dwResult = _Win32EnumFolderInternal(pContext);
|
|
|
|
// Call the callback again
|
|
pszPath[cchFile] = 0;
|
|
dwResult = (*pContext->pfnCB)(pszPath,
|
|
ENUM_REASON_FOLDER_END,
|
|
&fd,
|
|
pContext->lpContext);
|
|
}
|
|
|
|
if (CSCPROC_RETURN_SKIP == dwResult)
|
|
dwResult = CSCPROC_RETURN_CONTINUE;
|
|
|
|
if (CSCPROC_RETURN_CONTINUE != dwResult)
|
|
break;
|
|
|
|
} while (FindNextFile(hFind, &fd));
|
|
|
|
FindClose(hFind);
|
|
}
|
|
|
|
TraceLeaveValue(dwResult);
|
|
}
|
|
|
|
|
|
DWORD
|
|
_Win32EnumFolder(LPCTSTR pszFolder,
|
|
BOOL bRecurse,
|
|
PFN_WIN32ENUMPROC pfnCB,
|
|
LPARAM lpContext)
|
|
{
|
|
DWORD dwResult = CSCPROC_RETURN_CONTINUE;
|
|
W32_ENUM_CONTEXT ec;
|
|
|
|
TraceEnter(TRACE_UTIL, "_Win32EnumFolder");
|
|
TraceAssert(pszFolder);
|
|
TraceAssert(pfnCB);
|
|
|
|
if (!pszFolder || !*pszFolder || !pfnCB)
|
|
TraceLeaveValue(CSCPROC_RETURN_ABORT);
|
|
|
|
// Allocate the single buffer used for the entire enumeration.
|
|
// It will be reallocated later if necessary.
|
|
ec.cchPathBuffer = ((lstrlen(pszFolder)/PATH_BUFFER_SIZE) + 1) * PATH_BUFFER_SIZE;
|
|
ec.szPath = (LPTSTR)LocalAlloc(LMEM_FIXED, ec.cchPathBuffer*sizeof(TCHAR));
|
|
if (!ec.szPath)
|
|
TraceLeaveValue(CSCPROC_RETURN_ABORT);
|
|
|
|
ec.szPath[0] = 0;
|
|
|
|
// Assume pszFolder is valid a directory path
|
|
lstrcpyn(ec.szPath, pszFolder, ec.cchPathBuffer);
|
|
|
|
ec.bRecurse = bRecurse;
|
|
ec.pfnCB = pfnCB;
|
|
ec.lpContext = lpContext;
|
|
|
|
dwResult = _Win32EnumFolderInternal(&ec);
|
|
|
|
LocalFree(ec.szPath);
|
|
|
|
TraceLeaveValue(dwResult);
|
|
}
|
|
|
|
CIDArray::~CIDArray()
|
|
{
|
|
DoRelease(m_psf);
|
|
if (m_pIDA)
|
|
{
|
|
GlobalUnlock(m_Medium.hGlobal);
|
|
m_pIDA = NULL;
|
|
}
|
|
ReleaseStgMedium(&m_Medium);
|
|
}
|
|
|
|
HRESULT CIDArray::Initialize(IDataObject *pdobj)
|
|
{
|
|
TraceAssert(NULL == m_pIDA);
|
|
FORMATETC fe = { g_cfShellIDList, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
|
|
HRESULT hr = pdobj->GetData(&fe, &m_Medium);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_pIDA = (LPIDA)GlobalLock(m_Medium.hGlobal);
|
|
if (m_pIDA)
|
|
{
|
|
LPCITEMIDLIST pidlFolder = (LPCITEMIDLIST)ByteOffset(m_pIDA, m_pIDA->aoffset[0]);
|
|
hr = SHBindToObjectEx(NULL, pidlFolder, NULL, IID_PPV_ARG(IShellFolder, &m_psf));
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CIDArray::GetItemPath(UINT iItem, LPTSTR pszPath, UINT cchPath, DWORD *pdwAttribs)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (m_psf && m_pIDA && (iItem < m_pIDA->cidl))
|
|
{
|
|
LPCITEMIDLIST pidlChild, pidl = (LPCITEMIDLIST)ByteOffset(m_pIDA, m_pIDA->aoffset[iItem + 1]);
|
|
IShellFolder *psf;
|
|
hr = SHBindToFolderIDListParent(m_psf, pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlChild);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pszPath)
|
|
{
|
|
hr = DisplayNameOf(psf, pidlChild, SHGDN_FORPARSING, pszPath, cchPath);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPTSTR pszRemote;
|
|
if (S_OK == GetRemotePath(pszPath, &pszRemote))
|
|
{
|
|
lstrcpyn(pszPath, pszRemote, cchPath);
|
|
LocalFree(pszRemote);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && pdwAttribs)
|
|
hr = psf->GetAttributesOf(1, &pidlChild, pdwAttribs);
|
|
|
|
psf->Release();
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CIDArray::GetFolderPath(LPTSTR pszPath, UINT cchPath)
|
|
{
|
|
HRESULT hr = GetItemPath(0, pszPath, cchPath, NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
PathRemoveFileSpec(pszPath);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//
|
|
// CCscFileHandle non-inline member functions.
|
|
//
|
|
//*************************************************************
|
|
CCscFindHandle&
|
|
CCscFindHandle::operator = (
|
|
const CCscFindHandle& rhs
|
|
)
|
|
{
|
|
if (this != &rhs)
|
|
{
|
|
Attach(rhs.Detach());
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
|
|
void
|
|
CCscFindHandle::Close(
|
|
void
|
|
)
|
|
{
|
|
if (m_bOwns && INVALID_HANDLE_VALUE != m_handle)
|
|
{
|
|
CSCFindClose(m_handle);
|
|
}
|
|
m_bOwns = false;
|
|
m_handle = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
|
|
|
|
//*************************************************************
|
|
//
|
|
// String formatting functions
|
|
//
|
|
//*************************************************************
|
|
|
|
DWORD
|
|
FormatStringID(LPTSTR *ppszResult, HINSTANCE hInstance, UINT idStr, ...)
|
|
{
|
|
DWORD dwResult;
|
|
va_list args;
|
|
va_start(args, idStr);
|
|
dwResult = vFormatStringID(ppszResult, hInstance, idStr, &args);
|
|
va_end(args);
|
|
return dwResult;
|
|
}
|
|
|
|
DWORD
|
|
FormatString(LPTSTR *ppszResult, LPCTSTR pszFormat, ...)
|
|
{
|
|
DWORD dwResult;
|
|
va_list args;
|
|
va_start(args, pszFormat);
|
|
dwResult = vFormatString(ppszResult, pszFormat, &args);
|
|
va_end(args);
|
|
return dwResult;
|
|
}
|
|
|
|
DWORD
|
|
vFormatStringID(LPTSTR *ppszResult, HINSTANCE hInstance, UINT idStr, va_list *pargs)
|
|
{
|
|
DWORD dwResult = 0;
|
|
LPTSTR pszFormat = NULL;
|
|
if (LoadStringAlloc(&pszFormat, hInstance, idStr))
|
|
{
|
|
dwResult = vFormatString(ppszResult, pszFormat, pargs);
|
|
LocalFree(pszFormat);
|
|
}
|
|
return dwResult;
|
|
}
|
|
|
|
DWORD
|
|
vFormatString(LPTSTR *ppszResult, LPCTSTR pszFormat, va_list *pargs)
|
|
{
|
|
return FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
|
|
pszFormat,
|
|
0,
|
|
0,
|
|
(LPTSTR)ppszResult,
|
|
1,
|
|
pargs);
|
|
}
|
|
|
|
DWORD
|
|
FormatSystemError(LPTSTR *ppszResult, DWORD dwSysError)
|
|
{
|
|
LPTSTR pszBuffer = NULL;
|
|
DWORD dwResult = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER,
|
|
NULL,
|
|
dwSysError,
|
|
0,
|
|
(LPTSTR)&pszBuffer,
|
|
1,
|
|
NULL);
|
|
|
|
if (NULL != pszBuffer)
|
|
{
|
|
*ppszResult = pszBuffer;
|
|
}
|
|
return dwResult;
|
|
}
|
|
|
|
//
|
|
// Center a window in it's parent.
|
|
// If hwndParent is NULL, the window's parent is used.
|
|
// If hwndParent is not NULL, hwnd is centered in it.
|
|
// If hwndParent is NULL and hwnd doesn't have a parent, it is centered
|
|
// on the desktop.
|
|
//
|
|
void
|
|
CenterWindow(
|
|
HWND hwnd,
|
|
HWND hwndParent
|
|
)
|
|
{
|
|
RECT rcScreen;
|
|
|
|
if (NULL != hwnd)
|
|
{
|
|
rcScreen.left = rcScreen.top = 0;
|
|
rcScreen.right = GetSystemMetrics(SM_CXSCREEN);
|
|
rcScreen.bottom = GetSystemMetrics(SM_CYSCREEN);
|
|
|
|
if (NULL == hwndParent)
|
|
{
|
|
hwndParent = GetParent(hwnd);
|
|
if (NULL == hwndParent)
|
|
hwndParent = GetDesktopWindow();
|
|
}
|
|
|
|
RECT rcWnd;
|
|
RECT rcParent;
|
|
|
|
GetWindowRect(hwnd, &rcWnd);
|
|
GetWindowRect(hwndParent, &rcParent);
|
|
|
|
INT cxWnd = rcWnd.right - rcWnd.left;
|
|
INT cyWnd = rcWnd.bottom - rcWnd.top;
|
|
INT cxParent = rcParent.right - rcParent.left;
|
|
INT cyParent = rcParent.bottom - rcParent.top;
|
|
POINT ptParentCtr;
|
|
|
|
ptParentCtr.x = rcParent.left + (cxParent / 2);
|
|
ptParentCtr.y = rcParent.top + (cyParent / 2);
|
|
|
|
if ((ptParentCtr.x + (cxWnd / 2)) > rcScreen.right)
|
|
{
|
|
//
|
|
// Window would run off the right edge of the screen.
|
|
//
|
|
rcWnd.left = rcScreen.right - cxWnd;
|
|
}
|
|
else if ((ptParentCtr.x - (cxWnd / 2)) < rcScreen.left)
|
|
{
|
|
//
|
|
// Window would run off the left edge of the screen.
|
|
//
|
|
rcWnd.left = rcScreen.left;
|
|
}
|
|
else
|
|
{
|
|
rcWnd.left = ptParentCtr.x - (cxWnd / 2);
|
|
}
|
|
|
|
if ((ptParentCtr.y + (cyWnd / 2)) > rcScreen.bottom)
|
|
{
|
|
//
|
|
// Window would run off the bottom edge of the screen.
|
|
//
|
|
rcWnd.top = rcScreen.bottom - cyWnd;
|
|
}
|
|
else if ((ptParentCtr.y - (cyWnd / 2)) < rcScreen.top)
|
|
{
|
|
//
|
|
// Window would run off the top edge of the screen.
|
|
//
|
|
rcWnd.top = rcScreen.top;
|
|
}
|
|
else
|
|
{
|
|
rcWnd.top = ptParentCtr.y - (cyWnd / 2);
|
|
}
|
|
|
|
MoveWindow(hwnd, rcWnd.left, rcWnd.top, cxWnd, cyWnd, TRUE);
|
|
}
|
|
}
|
|
|
|
//
|
|
// We have some extra stuff to pass to the stats callback so we wrap the
|
|
// CSCSHARESTATS in a larger structure.
|
|
//
|
|
typedef struct
|
|
{
|
|
CSCSHARESTATS ss; // The stats data.
|
|
DWORD dwUnityFlagsReq; // SSUF_XXXX flags set by user (requested).
|
|
DWORD dwUnityFlagsSum; // SSUF_XXXX flags set during enum (sum total).
|
|
DWORD dwExcludeFlags; // SSEF_XXXX flags.
|
|
bool bEnumAborted; // true if unity flags satisfied.
|
|
|
|
} CSCSHARESTATS_CBKINFO, *PCSCSHARESTATS_CBKINFO;
|
|
|
|
|
|
//
|
|
// Called by CSCEnumForStats for each CSC item enumerated.
|
|
//
|
|
DWORD
|
|
_CscShareStatisticsCallback(LPCTSTR lpszName,
|
|
DWORD dwStatus,
|
|
DWORD dwHintFlags,
|
|
DWORD dwPinCount,
|
|
WIN32_FIND_DATA *lpFind32,
|
|
DWORD dwReason,
|
|
DWORD dwParam1,
|
|
DWORD dwParam2,
|
|
DWORD_PTR dwContext)
|
|
{
|
|
DWORD dwResult = CSCPROC_RETURN_CONTINUE;
|
|
|
|
if (CSCPROC_REASON_BEGIN != dwReason && // Not "start of data" notification.
|
|
CSCPROC_REASON_END != dwReason && // Not "end of data" notification.
|
|
1 != dwParam2) // Not "share root" entry.
|
|
{
|
|
PCSCSHARESTATS_CBKINFO pssci = (PCSCSHARESTATS_CBKINFO)(dwContext);
|
|
PCSCSHARESTATS pss = &(pssci->ss);
|
|
const DWORD dwExcludeFlags = pssci->dwExcludeFlags;
|
|
const DWORD dwUnityFlagsReq = pssci->dwUnityFlagsReq;
|
|
const bool bIsDir = (0 == dwParam1);
|
|
const bool bAccessUser = CscAccessUser(dwStatus);
|
|
const bool bAccessGuest = CscAccessGuest(dwStatus);
|
|
const bool bAccessOther = CscAccessOther(dwStatus);
|
|
|
|
if (0 != dwExcludeFlags)
|
|
{
|
|
//
|
|
// Caller want's to exclude some items from the enumeration.
|
|
// If item is in "excluded" specification, return early.
|
|
//
|
|
if (0 != (dwExcludeFlags & (dwStatus & SSEF_CSCMASK)))
|
|
{
|
|
return dwResult;
|
|
}
|
|
if ((bIsDir && (dwExcludeFlags & SSEF_DIRECTORY)) ||
|
|
(!bIsDir && (dwExcludeFlags & SSEF_FILE)))
|
|
{
|
|
return dwResult;
|
|
}
|
|
|
|
const struct
|
|
{
|
|
DWORD fExclude;
|
|
bool bAccess;
|
|
BYTE fMask;
|
|
|
|
} rgExclAccess[] = {{ SSEF_NOACCUSER, bAccessUser, 0x01 },
|
|
{ SSEF_NOACCGUEST, bAccessGuest, 0x02 },
|
|
{ SSEF_NOACCOTHER, bAccessOther, 0x04 }};
|
|
|
|
BYTE fExcludeMask = 0;
|
|
BYTE fNoAccessMask = 0;
|
|
for (int i = 0; i < ARRAYSIZE(rgExclAccess); i++)
|
|
{
|
|
if (dwExcludeFlags & rgExclAccess[i].fExclude)
|
|
fExcludeMask |= rgExclAccess[i].fMask;
|
|
|
|
if (!rgExclAccess[i].bAccess)
|
|
fNoAccessMask |= rgExclAccess[i].fMask;
|
|
}
|
|
|
|
if (SSEF_NOACCAND & dwExcludeFlags)
|
|
{
|
|
//
|
|
// Treat all access exclusion flags as a single unit.
|
|
//
|
|
if (fExcludeMask == fNoAccessMask)
|
|
return dwResult;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Treat each access flag individually. Only one specified access
|
|
// condition must be true to exclude this file.
|
|
//
|
|
if (fExcludeMask & fNoAccessMask)
|
|
return dwResult;
|
|
}
|
|
}
|
|
|
|
if (0 == (SSEF_DIRECTORY & dwExcludeFlags) || !bIsDir)
|
|
{
|
|
pss->cTotal++;
|
|
pssci->dwUnityFlagsSum |= SSUF_TOTAL;
|
|
|
|
if (0 != (dwHintFlags & (FLAG_CSC_HINT_PIN_USER | FLAG_CSC_HINT_PIN_ADMIN)))
|
|
{
|
|
pss->cPinned++;
|
|
pssci->dwUnityFlagsSum |= SSUF_PINNED;
|
|
}
|
|
if (0 != (dwStatus & FLAG_CSCUI_COPY_STATUS_ALL_DIRTY))
|
|
{
|
|
//
|
|
// If the current user doesn't have sufficient access
|
|
// to merge offline changes, then someone else must have
|
|
// modified the file, so don't count it for this user.
|
|
//
|
|
if (bIsDir || CscCanUserMergeFile(dwStatus))
|
|
{
|
|
pss->cModified++;
|
|
pssci->dwUnityFlagsSum |= SSUF_MODIFIED;
|
|
}
|
|
}
|
|
|
|
const struct
|
|
{
|
|
DWORD flag;
|
|
int *pCount;
|
|
bool bAccess;
|
|
|
|
} rgUnity[] = {{ SSUF_ACCUSER, &pss->cAccessUser, bAccessUser },
|
|
{ SSUF_ACCGUEST, &pss->cAccessGuest, bAccessGuest },
|
|
{ SSUF_ACCOTHER, &pss->cAccessOther, bAccessOther }};
|
|
|
|
DWORD fUnityMask = 0;
|
|
DWORD fAccessMask = 0;
|
|
for (int i = 0; i < ARRAYSIZE(rgUnity); i++)
|
|
{
|
|
if (dwUnityFlagsReq & rgUnity[i].flag)
|
|
fUnityMask |= rgUnity[i].flag;
|
|
|
|
if (rgUnity[i].bAccess)
|
|
{
|
|
(*rgUnity[i].pCount)++;
|
|
fAccessMask |= rgUnity[i].flag;
|
|
}
|
|
}
|
|
if (SSUF_ACCAND & dwUnityFlagsReq)
|
|
{
|
|
//
|
|
// Treat all access unity flags as a single unit.
|
|
// We only signal unity if all of the specified access
|
|
// unity conditions are true.
|
|
//
|
|
if (fUnityMask == fAccessMask)
|
|
pssci->dwUnityFlagsSum |= fUnityMask;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Treat all access exclusion flags individually.
|
|
//
|
|
if (fUnityMask & fAccessMask)
|
|
{
|
|
if (SSUF_ACCOR & dwUnityFlagsReq)
|
|
pssci->dwUnityFlagsSum |= fUnityMask;
|
|
else
|
|
pssci->dwUnityFlagsSum |= fAccessMask;
|
|
}
|
|
}
|
|
|
|
if (bIsDir)
|
|
{
|
|
pss->cDirs++;
|
|
pssci->dwUnityFlagsSum |= SSUF_DIRS;
|
|
}
|
|
// Note the 'else': don't count dirs in the sparse total
|
|
else if (0 != (dwStatus & FLAG_CSC_COPY_STATUS_SPARSE))
|
|
{
|
|
pss->cSparse++;
|
|
pssci->dwUnityFlagsSum |= SSUF_SPARSE;
|
|
}
|
|
|
|
if (0 != dwUnityFlagsReq)
|
|
{
|
|
//
|
|
// Abort enumeration if all of the requested SSUF_XXXX unity flags
|
|
// have been set.
|
|
//
|
|
if (dwUnityFlagsReq == (dwUnityFlagsReq & pssci->dwUnityFlagsSum))
|
|
{
|
|
dwResult = CSCPROC_RETURN_ABORT;
|
|
pssci->bEnumAborted;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
//
|
|
// Enumerate all items for a given share and tally up the
|
|
// relevant information like file count, pinned count etc.
|
|
// Information is returned through *pss.
|
|
//
|
|
BOOL
|
|
_GetShareStatistics(
|
|
LPCTSTR pszShare,
|
|
PCSCGETSTATSINFO pi,
|
|
PCSCSHARESTATS pss
|
|
)
|
|
{
|
|
typedef BOOL (WINAPI * PFNENUMFORSTATS)(LPCTSTR, LPCSCPROC, DWORD_PTR);
|
|
|
|
CSCSHARESTATS_CBKINFO ssci;
|
|
BOOL bResult;
|
|
DWORD dwShareStatus = 0;
|
|
PFNENUMFORSTATS pfnEnumForStats = CSCEnumForStats;
|
|
|
|
ZeroMemory(&ssci, sizeof(ssci));
|
|
ssci.dwUnityFlagsReq = pi->dwUnityFlags;
|
|
ssci.dwExcludeFlags = pi->dwExcludeFlags;
|
|
|
|
if (pi->bAccessInfo ||
|
|
(pi->dwUnityFlags & (SSUF_ACCUSER | SSUF_ACCGUEST | SSUF_ACCOTHER)) ||
|
|
(pi->dwExcludeFlags & (SSEF_NOACCUSER | SSEF_NOACCGUEST | SSEF_NOACCOTHER)))
|
|
{
|
|
//
|
|
// If the enumeration requires access information, use the "ex" version
|
|
// of the EnumForStats CSC api. Only use it if necessary because gathering
|
|
// the access information has a perf cost.
|
|
//
|
|
pfnEnumForStats = CSCEnumForStatsEx;
|
|
}
|
|
|
|
pi->bEnumAborted = false;
|
|
|
|
bResult = (*pfnEnumForStats)(pszShare, _CscShareStatisticsCallback, (DWORD_PTR)&ssci);
|
|
*pss = ssci.ss;
|
|
|
|
if (CSCQueryFileStatus(pszShare, &dwShareStatus, NULL, NULL))
|
|
{
|
|
if (FLAG_CSC_SHARE_STATUS_FILES_OPEN & dwShareStatus)
|
|
{
|
|
pss->bOpenFiles = true;
|
|
}
|
|
if (FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & dwShareStatus)
|
|
{
|
|
pss->bOffline = true;
|
|
}
|
|
}
|
|
pi->bEnumAborted = ssci.bEnumAborted;
|
|
|
|
return bResult;
|
|
}
|
|
|
|
//
|
|
// Retrieve the statistics for the entire cache.
|
|
// This is a simple wrapper that calls _GetShareStatistics for each share
|
|
// in the cache then sums the results for the entire cache. It accepts
|
|
// the same unity and exclusion flags used by _GetShareStatistics.
|
|
//
|
|
BOOL
|
|
_GetCacheStatistics(
|
|
PCSCGETSTATSINFO pi,
|
|
PCSCCACHESTATS pcs
|
|
)
|
|
{
|
|
BOOL bResult = TRUE;
|
|
WIN32_FIND_DATA fd;
|
|
CSCSHARESTATS ss;
|
|
|
|
ZeroMemory(pcs, sizeof(*pcs));
|
|
|
|
pi->bEnumAborted = false;
|
|
|
|
CCscFindHandle hFind(CacheFindFirst(NULL, &fd, NULL, NULL, NULL, NULL));
|
|
if (hFind.IsValid())
|
|
{
|
|
do
|
|
{
|
|
pcs->cShares++;
|
|
if (bResult = _GetShareStatistics(fd.cFileName,
|
|
pi,
|
|
&ss))
|
|
{
|
|
pcs->cTotal += ss.cTotal;
|
|
pcs->cPinned += ss.cPinned;
|
|
pcs->cModified += ss.cModified;
|
|
pcs->cSparse += ss.cSparse;
|
|
pcs->cDirs += ss.cDirs;
|
|
pcs->cAccessUser += ss.cAccessUser;
|
|
pcs->cAccessGuest += ss.cAccessGuest;
|
|
pcs->cAccessOther += ss.cAccessOther;
|
|
pcs->cSharesOffline += int(ss.bOffline);
|
|
pcs->cSharesWithOpenFiles += int(ss.bOpenFiles);
|
|
}
|
|
}
|
|
while(bResult && !pi->bEnumAborted && CacheFindNext(hFind, &fd, NULL, NULL, NULL, NULL));
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//
|
|
// Sets the proper exclusion flags to report only on files accessible by the
|
|
// logged on user. Otherwise it's the same as calling _GetShareStatistics.
|
|
//
|
|
BOOL
|
|
_GetShareStatisticsForUser(
|
|
LPCTSTR pszShare,
|
|
PCSCGETSTATSINFO pi,
|
|
PCSCSHARESTATS pss
|
|
)
|
|
{
|
|
pi->dwExcludeFlags |= SSEF_NOACCUSER | SSEF_NOACCGUEST | SSEF_NOACCAND;
|
|
return _GetShareStatistics(pszShare, pi, pss);
|
|
}
|
|
|
|
|
|
//
|
|
// Sets the proper exclusion flags to report only on files accessible by the
|
|
// logged on user. Otherwise it's the same as calling _GetCacheStatistics.
|
|
//
|
|
BOOL
|
|
_GetCacheStatisticsForUser(
|
|
PCSCGETSTATSINFO pi,
|
|
PCSCCACHESTATS pcs
|
|
)
|
|
{
|
|
pi->dwExcludeFlags |= SSEF_NOACCUSER | SSEF_NOACCGUEST | SSEF_NOACCAND;
|
|
return _GetCacheStatistics(pi, pcs);
|
|
}
|
|
|
|
|
|
//
|
|
// CSCUI version of reboot. Requires security goo.
|
|
// This code was pattered after that found in \shell\shell32\restart.c
|
|
// function CommonRestart().
|
|
//
|
|
DWORD
|
|
CSCUIRebootSystem(
|
|
void
|
|
)
|
|
{
|
|
TraceEnter(TRACE_UTIL, "CSCUIRebootSystem");
|
|
DWORD dwOldState, dwStatus, dwSecError;
|
|
DWORD dwRebootError = ERROR_SUCCESS;
|
|
|
|
SetLastError(0); // Be really safe about last error value!
|
|
dwStatus = Security_SetPrivilegeAttrib(SE_SHUTDOWN_NAME,
|
|
SE_PRIVILEGE_ENABLED,
|
|
&dwOldState);
|
|
dwSecError = GetLastError(); // ERROR_NOT_ALL_ASSIGNED sometimes
|
|
|
|
if (!ExitWindowsEx(EWX_REBOOT, 0))
|
|
{
|
|
dwRebootError = GetLastError();
|
|
Trace((TEXT("Error %d rebooting system"), dwRebootError));
|
|
}
|
|
if (NT_SUCCESS(dwStatus))
|
|
{
|
|
if (ERROR_SUCCESS == dwSecError)
|
|
{
|
|
Security_SetPrivilegeAttrib(SE_SHUTDOWN_NAME, dwOldState, NULL);
|
|
}
|
|
else
|
|
{
|
|
Trace((TEXT("Error %d setting SE_SHUTDOWN_NAME privilege"), dwSecError));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Trace((TEXT("Error %d setting SE_SHUTDOWN_NAME privilege"), dwStatus));
|
|
}
|
|
TraceLeaveResult(dwRebootError);
|
|
}
|
|
|
|
|
|
//
|
|
// Retrieve location, size and file/directory count information for the
|
|
// CSC cache. If CSC is disabled, information is gathered about the
|
|
// system volume. That's where the CSC agent will put the cache when
|
|
// one is created.
|
|
//
|
|
void
|
|
GetCscSpaceUsageInfo(
|
|
CSCSPACEUSAGEINFO *psui
|
|
)
|
|
{
|
|
ULARGE_INTEGER ulTotalBytes = {0, 0};
|
|
ULARGE_INTEGER ulUsedBytes = {0, 0};
|
|
|
|
ZeroMemory(psui, sizeof(*psui));
|
|
CSCGetSpaceUsage(psui->szVolume,
|
|
ARRAYSIZE(psui->szVolume),
|
|
&ulTotalBytes.HighPart,
|
|
&ulTotalBytes.LowPart,
|
|
&ulUsedBytes.HighPart,
|
|
&ulUsedBytes.LowPart,
|
|
&psui->dwNumFilesInCache,
|
|
&psui->dwNumDirsInCache);
|
|
|
|
if (0 == psui->szVolume[0])
|
|
{
|
|
//
|
|
// CSCGetSpaceUsage didn't give us a volume name. Probably because
|
|
// CSC hasn't been enabled on the system. Default to the system
|
|
// drive because that's what CSC uses anyway.
|
|
//
|
|
GetSystemDirectory(psui->szVolume, ARRAYSIZE(psui->szVolume));
|
|
psui->dwNumFilesInCache = 0;
|
|
psui->dwNumDirsInCache = 0;
|
|
}
|
|
|
|
PathStripToRoot(psui->szVolume);
|
|
DWORD spc = 0; // Sectors per cluster.
|
|
DWORD bps = 0; // Bytes per sector.
|
|
DWORD fc = 0; // Free clusters.
|
|
DWORD nc = 0; // Total clusters.
|
|
GetDiskFreeSpace(psui->szVolume, &spc, &bps, &fc, &nc);
|
|
|
|
psui->llBytesOnVolume = (LONGLONG)nc * (LONGLONG)spc * (LONGLONG)bps;
|
|
psui->llBytesTotalInCache = ulTotalBytes.QuadPart;
|
|
psui->llBytesUsedInCache = ulUsedBytes.QuadPart;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This is code taken from shell32's utils.cpp file.
|
|
// We need the function SHSimpleIDListFromFindData() but it's not exported
|
|
// from shell32. Therefore, until it is, we just lifted the code.
|
|
// [brianau - 9/28/98]
|
|
//-----------------------------------------------------------------------------
|
|
class CFileSysBindData: public IFileSystemBindData
|
|
{
|
|
public:
|
|
CFileSysBindData();
|
|
|
|
// *** IUnknown methods ***
|
|
STDMETHODIMP QueryInterface(REFIID riid, void **ppvObj);
|
|
STDMETHODIMP_(ULONG) AddRef(void);
|
|
STDMETHODIMP_(ULONG) Release(void);
|
|
|
|
// IFileSystemBindData
|
|
STDMETHODIMP SetFindData(const WIN32_FIND_DATAW *pfd);
|
|
STDMETHODIMP GetFindData(WIN32_FIND_DATAW *pfd);
|
|
|
|
private:
|
|
~CFileSysBindData();
|
|
|
|
LONG _cRef;
|
|
WIN32_FIND_DATAW _fd;
|
|
};
|
|
|
|
|
|
CFileSysBindData::CFileSysBindData() : _cRef(1)
|
|
{
|
|
ZeroMemory(&_fd, sizeof(_fd));
|
|
}
|
|
|
|
CFileSysBindData::~CFileSysBindData()
|
|
{
|
|
}
|
|
|
|
HRESULT CFileSysBindData::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CFileSysBindData, IFileSystemBindData), // IID_IFileSystemBindData
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CFileSysBindData::AddRef(void)
|
|
{
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CFileSysBindData::Release()
|
|
{
|
|
if (InterlockedDecrement(&_cRef))
|
|
return _cRef;
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
HRESULT CFileSysBindData::SetFindData(const WIN32_FIND_DATAW *pfd)
|
|
{
|
|
_fd = *pfd;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CFileSysBindData::GetFindData(WIN32_FIND_DATAW *pfd)
|
|
{
|
|
*pfd = _fd;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
SHCreateFileSysBindCtx(
|
|
const WIN32_FIND_DATA *pfd,
|
|
IBindCtx **ppbc
|
|
)
|
|
{
|
|
HRESULT hres;
|
|
IFileSystemBindData *pfsbd = new CFileSysBindData();
|
|
if (pfsbd)
|
|
{
|
|
if (pfd)
|
|
{
|
|
WIN32_FIND_DATAW fdw;
|
|
memcpy(&fdw, pfd, FIELD_OFFSET(WIN32_FIND_DATAW, cFileName));
|
|
SHTCharToUnicode(pfd->cFileName, fdw.cFileName, ARRAYSIZE(fdw.cFileName));
|
|
SHTCharToUnicode(pfd->cAlternateFileName, fdw.cAlternateFileName, ARRAYSIZE(fdw.cAlternateFileName));
|
|
pfsbd->SetFindData(&fdw);
|
|
}
|
|
|
|
hres = CreateBindCtx(0, ppbc);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
BIND_OPTS bo = {sizeof(bo)}; // Requires size filled in.
|
|
bo.grfMode = STGM_CREATE;
|
|
(*ppbc)->SetBindOptions(&bo);
|
|
(*ppbc)->RegisterObjectParam(STR_FILE_SYS_BIND_DATA, pfsbd);
|
|
}
|
|
pfsbd->Release();
|
|
}
|
|
else
|
|
{
|
|
*ppbc = NULL;
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
SHSimpleIDListFromFindData(
|
|
LPCTSTR pszPath,
|
|
const WIN32_FIND_DATA *pfd,
|
|
LPITEMIDLIST *ppidl
|
|
)
|
|
{
|
|
IShellFolder *psfDesktop;
|
|
HRESULT hres = SHGetDesktopFolder(&psfDesktop);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
IBindCtx *pbc;
|
|
hres = SHCreateFileSysBindCtx(pfd, &pbc);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
WCHAR wszPath[MAX_PATH];
|
|
|
|
SHTCharToUnicode(pszPath, wszPath, ARRAYSIZE(wszPath));
|
|
|
|
hres = psfDesktop->ParseDisplayName(NULL, pbc, wszPath, NULL, ppidl, NULL);
|
|
pbc->Release();
|
|
}
|
|
psfDesktop->Release();
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
*ppidl = NULL;
|
|
return hres;
|
|
}
|
|
|
|
|
|
//
|
|
// Number of times a CSC API will be repeated if it fails.
|
|
// In particular, this is used for CSCDelete and CSCFillSparseFiles; both of
|
|
// which can fail on one call but succeed the next. This isn't designed
|
|
// behavior but it is reality. ShishirP knows about it and may be able to
|
|
// investigate later. [brianau - 4/2/98]
|
|
//
|
|
const int CSC_API_RETRIES = 3;
|
|
|
|
//
|
|
// Occasionally if a call to a CSC API fails with ERROR_ACCESS_DENIED,
|
|
// repeating the call will succeed.
|
|
// Here we wrap up the call to CSCDelete so that it is called multiple
|
|
// times in the case of these failures.
|
|
//
|
|
DWORD
|
|
CscDelete(
|
|
LPCTSTR pszPath
|
|
)
|
|
{
|
|
DWORD dwError = ERROR_SUCCESS;
|
|
int nRetries = CSC_API_RETRIES;
|
|
while(0 < nRetries--)
|
|
{
|
|
if (CSCDelete(pszPath))
|
|
return ERROR_SUCCESS;
|
|
|
|
dwError = GetLastError();
|
|
if (ERROR_ACCESS_DENIED != dwError)
|
|
return dwError;
|
|
}
|
|
if (ERROR_SUCCESS == dwError)
|
|
{
|
|
//
|
|
// Hack for some CSC APIs returning
|
|
// ERROR_SUCCESS even though they fail.
|
|
//
|
|
dwError = ERROR_GEN_FAILURE;
|
|
}
|
|
return dwError;
|
|
}
|
|
|
|
|
|
void
|
|
EnableDlgItems(
|
|
HWND hwndDlg,
|
|
const UINT* pCtlIds,
|
|
int cCtls,
|
|
bool bEnable
|
|
)
|
|
{
|
|
for (int i = 0; i < cCtls; i++)
|
|
{
|
|
EnableWindow(GetDlgItem(hwndDlg, *(pCtlIds + i)), bEnable);
|
|
}
|
|
}
|
|
|
|
void
|
|
ShowDlgItems(
|
|
HWND hwndDlg,
|
|
const UINT* pCtlIds,
|
|
int cCtls,
|
|
bool bShow
|
|
)
|
|
{
|
|
const int nCmdShow = bShow ? SW_NORMAL : SW_HIDE;
|
|
|
|
for (int i = 0; i < cCtls; i++)
|
|
{
|
|
ShowWindow(GetDlgItem(hwndDlg, *(pCtlIds + i)), nCmdShow);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Wrapper around GetVolumeInformation that accounts for mounted
|
|
// volumes. This was borrowed from shell32\mulprsht.c
|
|
//
|
|
BOOL GetVolumeFlags(LPCTSTR pszPath, DWORD *pdwFlags)
|
|
{
|
|
TraceAssert(NULL != pszPath);
|
|
TraceAssert(NULL != pdwFlags);
|
|
|
|
TCHAR szRoot[MAX_PATH];
|
|
|
|
*pdwFlags = NULL;
|
|
|
|
//
|
|
// Is this a mount point, e.g. c:\ or c:\hostfolder\
|
|
//
|
|
if (!GetVolumePathName(pszPath, szRoot, ARRAYSIZE(szRoot)))
|
|
{
|
|
//
|
|
// No. Use path provided by caller.
|
|
//
|
|
lstrcpy(szRoot, pszPath);
|
|
PathStripToRoot(szRoot);
|
|
}
|
|
//
|
|
// GetVolumeInformation requires a trailing backslash.
|
|
//
|
|
PathAddBackslash(szRoot);
|
|
return GetVolumeInformation(szRoot, NULL, 0, NULL, NULL, pdwFlags, NULL, 0);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// Determine if the parent net share for a given UNC path has an open
|
|
// connection on the local machine.
|
|
//
|
|
// Returns:
|
|
//
|
|
// S_OK = There is an open connection to the share.
|
|
// S_FALSE = No open connection to the share.
|
|
// other = Some error code.
|
|
//
|
|
HRESULT
|
|
IsOpenConnectionPathUNC(
|
|
LPCTSTR pszPathUNC
|
|
)
|
|
{
|
|
TCHAR szShare[MAX_PATH * 2];
|
|
lstrcpyn(szShare, pszPathUNC, ARRAYSIZE(szShare));
|
|
PathStripToRoot(szShare);
|
|
if (PathIsUNCServerShare(szShare))
|
|
return IsOpenConnectionShare(szShare);
|
|
return S_FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// Determine if a net share has an open connection on the local machine.
|
|
//
|
|
// Returns:
|
|
//
|
|
// S_OK = There is an open connection to the share.
|
|
// S_FALSE = No open connection to the share.
|
|
// other = Some error code.
|
|
//
|
|
HRESULT
|
|
IsOpenConnectionShare(
|
|
LPCTSTR pszShare
|
|
)
|
|
{
|
|
DWORD dwStatus;
|
|
if (CSCQueryFileStatus(pszShare, &dwStatus, NULL, NULL))
|
|
{
|
|
if (FLAG_CSC_SHARE_STATUS_CONNECTED & dwStatus)
|
|
return S_OK;
|
|
}
|
|
return S_FALSE;
|
|
}
|
|
|
|
|
|
// With this version of CSCIsCSCEnabled, we can delay all extra dll loads
|
|
// (including cscdll.dll) until we actually see a net file/folder.
|
|
#include <devioctl.h>
|
|
#include <shdcom.h>
|
|
static TCHAR const c_szShadowDevice[] = TEXT("\\\\.\\shadow");
|
|
|
|
BOOL IsCSCEnabled(void)
|
|
{
|
|
BOOL bIsCSCEnabled = FALSE;
|
|
if (!IsOS(OS_PERSONAL))
|
|
{
|
|
SHADOWINFO sSI = {0};
|
|
ULONG ulBytesReturned;
|
|
|
|
HANDLE hShadowDB = CreateFile(c_szShadowDevice,
|
|
FILE_EXECUTE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL);
|
|
if (INVALID_HANDLE_VALUE == hShadowDB)
|
|
return FALSE;
|
|
|
|
sSI.uStatus = SHADOW_SWITCH_SHADOWING;
|
|
sSI.uOp = SHADOW_SWITCH_GET_STATE;
|
|
|
|
if (DeviceIoControl(hShadowDB,
|
|
IOCTL_SWITCHES,
|
|
(void *)(&sSI),
|
|
0,
|
|
NULL,
|
|
0,
|
|
&ulBytesReturned,
|
|
NULL))
|
|
{
|
|
bIsCSCEnabled = (sSI.uStatus & SHADOW_SWITCH_SHADOWING);
|
|
}
|
|
CloseHandle(hShadowDB);
|
|
}
|
|
return bIsCSCEnabled;
|
|
}
|
|
|
|
|
|
//
|
|
// The bit-masking used by this function is dependent upon the way
|
|
// Shishir defined the database status flags in cscapi.h
|
|
//
|
|
// FLAG_DATABASESTATUS_ENCRYPTION_MASK 0x00000006 (0000 0110)
|
|
// FLAG_DATABASESTATUS_UNENCRYPTED 0x00000000 (0000 0000)
|
|
// FLAG_DATABASESTATUS_PARTIALLY_UNENCRYPTED 0x00000004 (0000 0100)
|
|
// FLAG_DATABASESTATUS_ENCRYPTED 0x00000002 (0000 0010)
|
|
// FLAG_DATABASESTATUS_PARTIALLY_ENCRYPTED 0x00000006 (0000 0110)
|
|
//
|
|
// Things to note:
|
|
// 1. Bit 1 == encryption status.
|
|
// 2. Bit 2 == partial completion status.
|
|
//
|
|
//
|
|
// Returns:
|
|
// TRUE == Database is encrypted. May be fully or partially encrypted.
|
|
// FALSE == Database is not encrypted. May be fully or partially not encrypted.
|
|
//
|
|
// *pbPartial == Indicates if state is "partial" or not.
|
|
//
|
|
// Partial encryption means an encryption operation was started
|
|
// but not successfully completed. All new files created will be encrypted.
|
|
// Partial decryption means a decryption operation was started
|
|
// but not successfully completed. All new files created will be unencrypted.
|
|
//
|
|
BOOL IsCacheEncrypted(BOOL *pbPartial)
|
|
{
|
|
ULONG ulStatus;
|
|
ULONG ulErrors;
|
|
BOOL bEncrypted = FALSE;
|
|
if (CSCQueryDatabaseStatus(&ulStatus, &ulErrors))
|
|
{
|
|
ulStatus &= FLAG_DATABASESTATUS_ENCRYPTION_MASK;
|
|
|
|
bEncrypted = (0 != (FLAG_DATABASESTATUS_ENCRYPTED & ulStatus));
|
|
if (NULL != pbPartial)
|
|
{
|
|
const ULONG FLAGS_PARTIAL = (FLAG_DATABASESTATUS_PARTIALLY_ENCRYPTED & FLAG_DATABASESTATUS_PARTIALLY_UNENCRYPTED);
|
|
*pbPartial = (0 != (FLAGS_PARTIAL & ulStatus));
|
|
}
|
|
}
|
|
return bEncrypted;
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
CscVolumeSupportsEncryption(
|
|
LPCTSTR pszPathIn // Path of CSC volume. Can be NULL.
|
|
)
|
|
{
|
|
TCHAR szPath[MAX_PATH]; // May need local copy to modify.
|
|
CSCSPACEUSAGEINFO sui;
|
|
LPTSTR psz;
|
|
DWORD dwVolFlags;
|
|
bool bSupportsEncryption = false;
|
|
|
|
if (NULL == pszPathIn)
|
|
{
|
|
//
|
|
// Caller didn't provide path of CSC volume.
|
|
// Get it from CSC.
|
|
//
|
|
sui.szVolume[0] = 0;
|
|
psz = sui.szVolume;
|
|
GetCscSpaceUsageInfo(&sui);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Caller provided path of CSC volume.
|
|
//
|
|
lstrcpyn(szPath, pszPathIn, ARRAYSIZE(szPath));
|
|
psz = szPath;
|
|
}
|
|
|
|
TraceAssert(NULL != psz);
|
|
|
|
if (GetVolumeFlags(psz, &dwVolFlags))
|
|
{
|
|
if (0 != (FILE_SUPPORTS_ENCRYPTION & dwVolFlags))
|
|
{
|
|
bSupportsEncryption = true;
|
|
}
|
|
}
|
|
return bSupportsEncryption;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Returns:
|
|
//
|
|
// NULL == Mutex is owned by another thread.
|
|
// non-NULL == Handle of mutex object. This thread now owns the mutex.
|
|
// Caller is responsible for releasing the mutex and closing
|
|
// the mutex handle.
|
|
//
|
|
// *pbAbandoned indicates if mutex was abandoned by its thread.
|
|
//
|
|
//
|
|
HANDLE
|
|
RequestNamedMutexOwnership(
|
|
LPCTSTR pszMutexName,
|
|
BOOL *pbAbandoned // [optional]
|
|
)
|
|
{
|
|
BOOL bAbandoned = FALSE;
|
|
|
|
HANDLE hMutex = CreateMutex(NULL, FALSE, pszMutexName);
|
|
if (NULL != hMutex)
|
|
{
|
|
//
|
|
// Whether we created or opened the mutex, wait on it
|
|
// to gain ownership.
|
|
//
|
|
switch(WaitForSingleObject(hMutex, 0))
|
|
{
|
|
case WAIT_ABANDONED:
|
|
bAbandoned = TRUE;
|
|
//
|
|
// Fall through...
|
|
//
|
|
case WAIT_OBJECT_0:
|
|
//
|
|
// Current thread now owns the mutex.
|
|
// We'll return the handle to the caller.
|
|
//
|
|
break;
|
|
|
|
case WAIT_TIMEOUT:
|
|
default:
|
|
//
|
|
// Couldn't gain ownership of the mutex.
|
|
// Close the handle.
|
|
//
|
|
CloseHandle(hMutex);
|
|
hMutex = NULL;
|
|
break;
|
|
}
|
|
}
|
|
if (NULL != pbAbandoned)
|
|
{
|
|
*pbAbandoned = bAbandoned;
|
|
}
|
|
return hMutex;
|
|
}
|
|
|
|
//
|
|
// Determine if a named mutex is currently owned by another thread
|
|
// or not. This function only determines ownership then immediately
|
|
// releases the mutex. If you need to determine ownership and want
|
|
// to retain ownership if previously unowned call
|
|
// RequestNamedMutexOwnership instead.
|
|
//
|
|
BOOL
|
|
IsNamedMutexOwned(
|
|
LPCTSTR pszMutexName,
|
|
BOOL *pbAbandoned
|
|
)
|
|
{
|
|
HANDLE hMutex = RequestNamedMutexOwnership(pszMutexName, pbAbandoned);
|
|
if (NULL != hMutex)
|
|
{
|
|
//
|
|
// Mutex was not owned (now owned by current thread).
|
|
// Since we're only interested in determining prior ownership
|
|
// we release it and close the handle.
|
|
//
|
|
ReleaseMutex(hMutex);
|
|
CloseHandle(hMutex);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL IsSyncInProgress(void)
|
|
{
|
|
return IsNamedMutexOwned(c_szSyncInProgMutex, NULL);
|
|
}
|
|
|
|
BOOL IsPurgeInProgress(void)
|
|
{
|
|
return IsNamedMutexOwned(c_szPurgeInProgMutex, NULL);
|
|
}
|
|
|
|
BOOL IsEncryptionInProgress(void)
|
|
{
|
|
return IsNamedMutexOwned(c_szEncryptionInProgMutex, NULL);
|
|
}
|
|
//
|
|
// Requests ownership of the global cache encryption mutex.
|
|
//
|
|
// Returns:
|
|
// NULL == Mutex already owned by another thread.
|
|
// Non-NULL == Mutex now owned by current thread.
|
|
// Caller is responsible for releasing the mutex
|
|
// and closing the mutex handle.
|
|
//
|
|
HANDLE RequestPermissionToEncryptCache(void)
|
|
{
|
|
return RequestNamedMutexOwnership(c_szEncryptionInProgMutex, NULL);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------
|
|
// DataObject helper functions.
|
|
// These are roughly taken from similar functions in
|
|
// shell\shell32\datautil.cpp
|
|
//---------------------------------------------------------------
|
|
HRESULT
|
|
DataObject_SetBlob(
|
|
IDataObject *pdtobj,
|
|
CLIPFORMAT cf,
|
|
LPCVOID pvBlob,
|
|
UINT cbBlob
|
|
)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
void * pv = GlobalAlloc(GPTR, cbBlob);
|
|
if (pv)
|
|
{
|
|
CopyMemory(pv, pvBlob, cbBlob);
|
|
hr = DataObject_SetGlobal(pdtobj, cf, pv);
|
|
|
|
if (FAILED(hr))
|
|
GlobalFree((HGLOBAL)pv);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
DataObject_GetBlob(
|
|
IDataObject *pdtobj,
|
|
CLIPFORMAT cf,
|
|
void * pvBlob,
|
|
UINT cbBlob
|
|
)
|
|
{
|
|
STGMEDIUM medium = {0};
|
|
FORMATETC fmte = {cf, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
|
|
HRESULT hr = pdtobj->GetData(&fmte, &medium);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
void * pv = GlobalLock(medium.hGlobal);
|
|
if (pv)
|
|
{
|
|
CopyMemory(pvBlob, pv, cbBlob);
|
|
GlobalUnlock(medium.hGlobal);
|
|
}
|
|
else
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
ReleaseStgMedium(&medium);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
DataObject_SetGlobal(
|
|
IDataObject *pdtobj,
|
|
CLIPFORMAT cf,
|
|
HGLOBAL hGlobal
|
|
)
|
|
{
|
|
FORMATETC fmte = {cf, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
|
|
STGMEDIUM medium;
|
|
|
|
medium.tymed = TYMED_HGLOBAL;
|
|
medium.hGlobal = hGlobal;
|
|
medium.pUnkForRelease = NULL;
|
|
|
|
return pdtobj->SetData(&fmte, &medium, TRUE);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
DataObject_SetDWORD(
|
|
IDataObject *pdtobj,
|
|
CLIPFORMAT cf,
|
|
DWORD dw
|
|
)
|
|
{
|
|
return DataObject_SetBlob(pdtobj, cf, &dw, sizeof(dw));
|
|
}
|
|
|
|
|
|
HRESULT
|
|
DataObject_GetDWORD(
|
|
IDataObject *pdtobj,
|
|
CLIPFORMAT cf,
|
|
DWORD *pdwOut
|
|
)
|
|
{
|
|
return DataObject_GetBlob(pdtobj, cf, pdwOut, sizeof(DWORD));
|
|
}
|
|
|
|
|
|
HRESULT
|
|
SetGetLogicalPerformedDropEffect(
|
|
IDataObject *pdtobj,
|
|
DWORD *pdwEffect,
|
|
bool bSet
|
|
)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
static CLIPFORMAT cf;
|
|
if ((CLIPFORMAT)0 == cf)
|
|
cf = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_LOGICALPERFORMEDDROPEFFECT);
|
|
|
|
if (bSet)
|
|
{
|
|
hr = DataObject_SetDWORD(pdtobj, cf, *pdwEffect);
|
|
}
|
|
else
|
|
{
|
|
*pdwEffect = DROPEFFECT_NONE;
|
|
DataObject_GetDWORD(pdtobj, cf, pdwEffect);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
DWORD
|
|
GetLogicalPerformedDropEffect(
|
|
IDataObject *pdtobj
|
|
)
|
|
{
|
|
DWORD dwEffect = DROPEFFECT_NONE;
|
|
SetGetLogicalPerformedDropEffect(pdtobj, &dwEffect, false);
|
|
return dwEffect;
|
|
}
|
|
|
|
HRESULT
|
|
SetLogicalPerformedDropEffect(
|
|
IDataObject *pdtobj,
|
|
DWORD dwEffect
|
|
)
|
|
{
|
|
return SetGetLogicalPerformedDropEffect(pdtobj, &dwEffect, true);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
SetGetPreferredDropEffect(
|
|
IDataObject *pdtobj,
|
|
DWORD *pdwEffect,
|
|
bool bSet
|
|
)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
static CLIPFORMAT cf;
|
|
if ((CLIPFORMAT)0 == cf)
|
|
cf = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_PREFERREDDROPEFFECT);
|
|
|
|
if (bSet)
|
|
{
|
|
hr = DataObject_SetDWORD(pdtobj, cf, *pdwEffect);
|
|
}
|
|
else
|
|
{
|
|
*pdwEffect = DROPEFFECT_NONE;
|
|
DataObject_GetDWORD(pdtobj, cf, pdwEffect);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
DWORD
|
|
GetPreferredDropEffect(
|
|
IDataObject *pdtobj
|
|
)
|
|
{
|
|
DWORD dwEffect = DROPEFFECT_NONE;
|
|
SetGetPreferredDropEffect(pdtobj, &dwEffect, false);
|
|
return dwEffect;
|
|
}
|
|
|
|
HRESULT
|
|
SetPreferredDropEffect(
|
|
IDataObject *pdtobj,
|
|
DWORD dwEffect
|
|
)
|
|
{
|
|
return SetGetPreferredDropEffect(pdtobj, &dwEffect, true);
|
|
}
|
|
|
|
|
|
//
|
|
// Wrap CSCFindFirstFile so we don't enumerate "." or "..".
|
|
// Wrapper also helps code readability.
|
|
//
|
|
HANDLE
|
|
CacheFindFirst(
|
|
LPCTSTR pszPath,
|
|
PSID psid,
|
|
WIN32_FIND_DATA *pfd,
|
|
DWORD *pdwStatus,
|
|
DWORD *pdwPinCount,
|
|
DWORD *pdwHintFlags,
|
|
FILETIME *pft
|
|
)
|
|
{
|
|
HANDLE hFind = CSCFindFirstFileForSid(pszPath,
|
|
psid,
|
|
pfd,
|
|
pdwStatus,
|
|
pdwPinCount,
|
|
pdwHintFlags,
|
|
pft);
|
|
|
|
while(INVALID_HANDLE_VALUE != hFind && PathIsDotOrDotDot(pfd->cFileName))
|
|
{
|
|
if (!CSCFindNextFile(hFind,
|
|
pfd,
|
|
pdwStatus,
|
|
pdwPinCount,
|
|
pdwHintFlags,
|
|
pft))
|
|
{
|
|
CSCFindClose(hFind);
|
|
hFind = INVALID_HANDLE_VALUE;
|
|
}
|
|
}
|
|
return hFind;
|
|
}
|
|
|
|
|
|
//
|
|
// Wrap CSCFindFirstFile so we don't enumerate "." or "..".
|
|
// Wrapper also helps code readability.
|
|
//
|
|
BOOL
|
|
CacheFindNext(
|
|
HANDLE hFind,
|
|
WIN32_FIND_DATA *pfd,
|
|
DWORD *pdwStatus,
|
|
DWORD *pdwPinCount,
|
|
DWORD *pdwHintFlags,
|
|
FILETIME *pft
|
|
)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
do
|
|
{
|
|
bResult = CSCFindNextFile(hFind,
|
|
pfd,
|
|
pdwStatus,
|
|
pdwPinCount,
|
|
pdwHintFlags,
|
|
pft);
|
|
}
|
|
while(bResult && PathIsDotOrDotDot(pfd->cFileName));
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//
|
|
// If there's a link to the Offline Files folder on the
|
|
// user's desktop, delete the link. This version checks a flag in the registry
|
|
// before enumerating all LNK's on the desktop. If the flag doesn't exist,
|
|
// we don't continue. This is a perf enhancement used at logon.
|
|
//
|
|
BOOL
|
|
DeleteOfflineFilesFolderLink_PerfSensitive(
|
|
HWND hwndParent
|
|
)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
//
|
|
// Before enumerating links on the desktop, check to see if the user
|
|
// has created a link.
|
|
//
|
|
DWORD dwValue;
|
|
DWORD cbValue = sizeof(dwValue);
|
|
DWORD dwType;
|
|
DWORD dwResult = SHGetValue(HKEY_CURRENT_USER,
|
|
REGSTR_KEY_OFFLINEFILES,
|
|
REGSTR_VAL_FOLDERSHORTCUTCREATED,
|
|
&dwType,
|
|
&dwValue,
|
|
&cbValue);
|
|
|
|
if (ERROR_SUCCESS == dwResult)
|
|
{
|
|
//
|
|
// We don't care about the value or it's type.
|
|
// Presence/absence of the value is all that matters.
|
|
//
|
|
bResult = DeleteOfflineFilesFolderLink(hwndParent);
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//
|
|
// This version of the "delete link" function does not check the
|
|
// flag in the registry. It finds the link file on the desktop and deletes it.
|
|
//
|
|
BOOL
|
|
DeleteOfflineFilesFolderLink(
|
|
HWND hwndParent
|
|
)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
TCHAR szLinkPath[MAX_PATH];
|
|
if (SUCCEEDED(COfflineFilesFolder::IsLinkOnDesktop(hwndParent, szLinkPath, ARRAYSIZE(szLinkPath))))
|
|
{
|
|
bResult = DeleteFile(szLinkPath);
|
|
}
|
|
//
|
|
// Remove the "folder shortcut created" flag from the registry.
|
|
//
|
|
SHDeleteValue(HKEY_CURRENT_USER, REGSTR_KEY_OFFLINEFILES, REGSTR_VAL_FOLDERSHORTCUTCREATED);
|
|
return bResult;
|
|
}
|
|
|
|
|
|
//
|
|
// This was taken from shell\shell32\util.cpp.
|
|
//
|
|
BOOL ShowSuperHidden(void)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
|
|
if (!SHRestricted(REST_DONTSHOWSUPERHIDDEN))
|
|
{
|
|
SHELLSTATE ss;
|
|
|
|
SHGetSetSettings(&ss, SSF_SHOWSUPERHIDDEN, FALSE);
|
|
bRet = ss.fShowSuperHidden;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
BOOL ShowHidden(void)
|
|
{
|
|
SHELLSTATE ss;
|
|
SHGetSetSettings(&ss, SSF_SHOWALLOBJECTS, FALSE);
|
|
return ss.fShowAllObjects;
|
|
}
|
|
|
|
|
|
BOOL IsSyncMgrInitialized(void)
|
|
{
|
|
//
|
|
// Is this the first time this user has used run CSCUI?
|
|
//
|
|
DWORD dwValue = 0;
|
|
DWORD cbData = sizeof(dwValue);
|
|
DWORD dwType;
|
|
SHGetValue(HKEY_CURRENT_USER,
|
|
c_szCSCKey,
|
|
c_szSyncMgrInitialized,
|
|
&dwType,
|
|
(void *)&dwValue,
|
|
&cbData);
|
|
|
|
return (0 != dwValue);
|
|
}
|
|
|
|
|
|
void SetSyncMgrInitialized(void)
|
|
{
|
|
|
|
//
|
|
// Set the "initialized" flag so our logoff code in cscst.cpp doesn't
|
|
// try to re-register for sync-at-logon/logoff.
|
|
//
|
|
DWORD dwSyncMgrInitialized = 1;
|
|
SHSetValue(HKEY_CURRENT_USER,
|
|
c_szCSCKey,
|
|
c_szSyncMgrInitialized,
|
|
REG_DWORD,
|
|
&dwSyncMgrInitialized,
|
|
sizeof(dwSyncMgrInitialized));
|
|
}
|
|
|
|
|
|
//
|
|
// Return the HWND for a standard progress dialog.
|
|
//
|
|
HWND GetProgressDialogWindow(IProgressDialog *ppd)
|
|
{
|
|
HWND hwndProgress = NULL;
|
|
//
|
|
// Get the progress dialog's window handle. We'll use
|
|
// it as a parent window for error UI.
|
|
//
|
|
HRESULT hr = IUnknown_GetWindow(ppd, &hwndProgress);
|
|
return hwndProgress;
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
CAutoWaitCursor::Reset(
|
|
void
|
|
)
|
|
{
|
|
ShowCursor(FALSE);
|
|
if (NULL != m_hCursor)
|
|
SetCursor(m_hCursor);
|
|
m_hCursor = NULL;
|
|
}
|
|
|
|
|
|
//
|
|
// Expand all environment strings in a text string.
|
|
//
|
|
HRESULT
|
|
ExpandStringInPlace(
|
|
LPTSTR psz,
|
|
DWORD cch
|
|
)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
LPTSTR pszCopy;
|
|
if (LocalAllocString(&pszCopy, psz))
|
|
{
|
|
DWORD cchExpanded = ExpandEnvironmentStrings(pszCopy, psz, cch);
|
|
if (0 == cchExpanded)
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
else if (cchExpanded > cch)
|
|
hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
|
|
else
|
|
hr = S_OK;
|
|
|
|
LocalFreeString(&pszCopy);
|
|
}
|
|
if (FAILED(hr) && 0 < cch)
|
|
{
|
|
*psz = 0;
|
|
}
|
|
return hr;
|
|
}
|