You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4400 lines
147 KiB
4400 lines
147 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1997 - 1999
|
|
//
|
|
// File: update.cpp
|
|
//
|
|
// Authors;
|
|
// Jeff Saathoff (jeffreys)
|
|
//
|
|
// Notes;
|
|
// SyncMgr integration
|
|
//--------------------------------------------------------------------------
|
|
#include "pch.h"
|
|
#include "msgbox.h" // CscWin32Message
|
|
#include "folder.h"
|
|
#include <openfile.h> // OpenOfflineFile
|
|
#include "cscst.h" // PostToSystray
|
|
#include "fopendlg.h" // OpenFilesWarningDialog
|
|
#include "nopin.h"
|
|
#include "statdlg.h" // ReconnectServers
|
|
#include "security.h"
|
|
#include "strings.h"
|
|
|
|
#define RAS_CONNECT_DELAY (10 * 1000)
|
|
|
|
// Maximum length of username
|
|
#define MAX_USERNAME_CHARS 64
|
|
|
|
// SYNCTHREADDATA.dwSyncStatus flags
|
|
#define SDS_SYNC_OUT 0x00000001 // CSCMergeShare
|
|
#define SDS_SYNC_IN_QUICK 0x00000002 // CSCFillSparseFiles(FALSE)
|
|
#define SDS_SYNC_IN_FULL 0x00000004 // CSCFillSparseFiles(TRUE)
|
|
#define SDS_SYNC_FORCE_INWARD 0x00000008
|
|
#define SDS_SYNC_RAS_CONNECTED 0x00000010
|
|
#define SDS_SYNC_RESTART_MERGE 0x00000020
|
|
#define SDS_SYNC_DELETE_DELETE 0x00000040
|
|
#define SDS_SYNC_DELETE_RESTORE 0x00000080
|
|
#define SDS_SYNC_AUTOCACHE 0x00000100
|
|
#define SDS_SYNC_CONFLICT_KEEPLOCAL 0x00000200
|
|
#define SDS_SYNC_CONFLICT_KEEPNET 0x00000400
|
|
#define SDS_SYNC_CONFLICT_KEEPBOTH 0x00000800
|
|
#define SDS_SYNC_STARTED 0x00010000
|
|
#define SDS_SYNC_ERROR 0x00020000
|
|
#define SDS_SYNC_CANCELLED 0x00040000
|
|
#define SDS_SYNC_FILE_SKIPPED 0x00080000
|
|
|
|
#define SDS_SYNC_DELETE_CONFLICT_MASK (SDS_SYNC_DELETE_DELETE | SDS_SYNC_DELETE_RESTORE)
|
|
#define SDS_SYNC_FILE_CONFLICT_MASK (SDS_SYNC_CONFLICT_KEEPLOCAL | SDS_SYNC_CONFLICT_KEEPNET | SDS_SYNC_CONFLICT_KEEPBOTH)
|
|
|
|
|
|
// Sync Flags used internally by CCscUpdate
|
|
#define CSC_SYNC_OUT 0x00000001L
|
|
#define CSC_SYNC_IN_QUICK 0x00000002L
|
|
#define CSC_SYNC_IN_FULL 0x00000004L
|
|
#define CSC_SYNC_SETTINGS 0x00000008L
|
|
#define CSC_SYNC_MAYBOTHERUSER 0x00000010L
|
|
#define CSC_SYNC_NOTIFY_SYSTRAY 0x00000020L
|
|
#define CSC_SYNC_LOGOFF 0x00000040L
|
|
#define CSC_SYNC_LOGON 0x00000080L
|
|
#define CSC_SYNC_IDLE 0x00000100L
|
|
#define CSC_SYNC_NONET 0x00000200L
|
|
#define CSC_SYNC_PINFILES 0x00000400L
|
|
#define CSC_SYNC_PIN_RECURSE 0x00000800L
|
|
#define CSC_SYNC_OFWARNINGDONE 0x00001000L
|
|
#define CSC_SYNC_CANCELLED 0x00002000L
|
|
#define CSC_SYNC_SHOWUI_ALWAYS 0x00004000L
|
|
#define CSC_SYNC_IGNORE_ACCESS 0x00008000L
|
|
#define CSC_SYNC_EFS_PIN_NONE 0x00010000L
|
|
#define CSC_SYNC_EFS_PIN_ALL 0x00020000L
|
|
#define CSC_SYNC_RECONNECT 0x00040000L
|
|
|
|
#define CSC_LOCALLY_MODIFIED (FLAG_CSC_COPY_STATUS_DATA_LOCALLY_MODIFIED \
|
|
| FLAG_CSC_COPY_STATUS_LOCALLY_DELETED \
|
|
| FLAG_CSC_COPY_STATUS_LOCALLY_CREATED)
|
|
|
|
HICON g_hCscIcon = NULL;
|
|
|
|
// Used for marshalling data into the SyncMgr process
|
|
typedef struct _CSC_UPDATE_DATA
|
|
{
|
|
DWORD dwUpdateFlags;
|
|
DWORD dwFileBufferOffset;
|
|
} CSC_UPDATE_DATA, *PCSC_UPDATE_DATA;
|
|
|
|
|
|
LPTSTR GetErrorText(DWORD dwErr)
|
|
{
|
|
UINT idString = (UINT)-1;
|
|
LPTSTR pszError = NULL;
|
|
|
|
switch (dwErr)
|
|
{
|
|
case ERROR_INVALID_NAME:
|
|
// "Files of this type cannot be made available offline."
|
|
idString = IDS_CACHING_DISALLOWED;
|
|
break;
|
|
}
|
|
|
|
if ((UINT)-1 != idString)
|
|
{
|
|
LoadStringAlloc(&pszError, g_hInstance, idString);
|
|
}
|
|
else if (NOERROR != dwErr)
|
|
{
|
|
FormatSystemError(&pszError, dwErr);
|
|
}
|
|
return pszError;
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//
|
|
// CscUpdateCache
|
|
//
|
|
// Purpose: Invoke SyncMgr to update the CSC cache
|
|
//
|
|
// Parameters: pNamelist - list of files passed to the CSC SyncMgr handler
|
|
//
|
|
//
|
|
// Return: HRESULT
|
|
//
|
|
//*************************************************************
|
|
HRESULT
|
|
CscUpdateCache(DWORD dwUpdateFlags, CscFilenameList *pfnl)
|
|
{
|
|
HRESULT hr;
|
|
HRESULT hrComInit = E_FAIL;
|
|
ISyncMgrSynchronizeInvoke *pSyncInvoke = NULL;
|
|
DWORD dwSyncMgrFlags = 0;
|
|
ULONG cbDataLength = sizeof(CSC_UPDATE_DATA);
|
|
PCSC_UPDATE_DATA pUpdateData = NULL;
|
|
PCSC_NAMELIST_HDR pNamelist = NULL;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CscUpdateCache");
|
|
|
|
hrComInit = CoInitialize(NULL);
|
|
hr = CoCreateInstance(CLSID_SyncMgr,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_ISyncMgrSynchronizeInvoke,
|
|
(LPVOID*)&pSyncInvoke);
|
|
FailGracefully(hr, "Unable to create SyncMgr object");
|
|
|
|
if (dwUpdateFlags & CSC_UPDATE_SELECTION)
|
|
{
|
|
if (NULL == pfnl || (0 == (CSC_UPDATE_SHOWUI_ALWAYS & dwUpdateFlags) && 0 == pfnl->GetShareCount()))
|
|
ExitGracefully(hr, E_INVALIDARG, "CSC_UPDATE_SELECTION with no selection");
|
|
|
|
pNamelist = pfnl->CreateListBuffer();
|
|
if (!pNamelist)
|
|
ExitGracefully(hr, E_OUTOFMEMORY, "Unable to create namelist buffer");
|
|
|
|
cbDataLength += pNamelist->cbSize;
|
|
}
|
|
|
|
//
|
|
// Alloc a buffer for the cookie data
|
|
//
|
|
pUpdateData = (PCSC_UPDATE_DATA)LocalAlloc(LPTR, cbDataLength);
|
|
if (!pUpdateData)
|
|
ExitGracefully(hr, E_OUTOFMEMORY, "LocalAlloc failed");
|
|
|
|
pUpdateData->dwUpdateFlags = dwUpdateFlags;
|
|
if (pNamelist)
|
|
{
|
|
pUpdateData->dwFileBufferOffset = sizeof(CSC_UPDATE_DATA);
|
|
CopyMemory(ByteOffset(pUpdateData, pUpdateData->dwFileBufferOffset),
|
|
pNamelist,
|
|
pNamelist->cbSize);
|
|
}
|
|
|
|
if (dwUpdateFlags & CSC_UPDATE_STARTNOW)
|
|
dwSyncMgrFlags |= SYNCMGRINVOKE_STARTSYNC;
|
|
|
|
//
|
|
// Start SyncMgr
|
|
//
|
|
hr = pSyncInvoke->UpdateItems(dwSyncMgrFlags,
|
|
CLSID_CscUpdateHandler,
|
|
cbDataLength,
|
|
(LPBYTE)pUpdateData);
|
|
|
|
exit_gracefully:
|
|
|
|
if (pNamelist)
|
|
CscFilenameList::FreeListBuffer(pNamelist);
|
|
|
|
if (pUpdateData)
|
|
LocalFree(pUpdateData);
|
|
|
|
DoRelease(pSyncInvoke);
|
|
|
|
if (SUCCEEDED(hrComInit))
|
|
CoUninitialize();
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//
|
|
// GetNewVersionName
|
|
//
|
|
// Purpose: Create unique names for copies of a file
|
|
//
|
|
// Parameters: LPTSTR pszUNCPath - fully qualified UNC name of file
|
|
// LPTSTR pszShare - \\server\share that file lives on
|
|
// LPTSTR pszDrive - drive mapping to use for net operations
|
|
// LPTSTR *ppszNewName - filename for new version returned here (must free)
|
|
//
|
|
// Return: Win32 error code
|
|
//
|
|
//*************************************************************
|
|
DWORD
|
|
GetNewVersionName(LPCTSTR pszUNCPath,
|
|
LPCTSTR pszShare,
|
|
LPCTSTR pszDrive,
|
|
LPTSTR *ppszNewName)
|
|
{
|
|
DWORD dwErr = NOERROR;
|
|
LPTSTR pszDriveLetterPath = NULL;
|
|
LPTSTR pszPath = NULL;
|
|
LPTSTR pszFile = NULL;
|
|
LPTSTR pszExt = NULL;
|
|
LPTSTR pszWildCardName = NULL;
|
|
TCHAR szUserName[MAX_USERNAME_CHARS];
|
|
ULONG nLength;
|
|
ULONG nMaxVersion = 0;
|
|
ULONG cOlderVersions = 0;
|
|
HANDLE hFind = INVALID_HANDLE_VALUE;
|
|
WIN32_FIND_DATA fd;
|
|
LPTSTR pszT;
|
|
|
|
TraceEnter(TRACE_UPDATE, "GetNewVersionName");
|
|
TraceAssert(pszUNCPath != NULL);
|
|
TraceAssert(ppszNewName != NULL);
|
|
|
|
*ppszNewName = NULL;
|
|
|
|
// 1. Split the path into components.
|
|
// 2. Build wildcard name "X:\dir\foo (johndoe v*).txt"
|
|
// 3. Do a findfirst/findnext loop to get the min & max version #
|
|
// and count the number of old versions.
|
|
// 4. Increment the max version # and build the new filename as:
|
|
// "foo (johndoe v<max+1>).txt"
|
|
|
|
// Assume that the UNC name contains more than the share
|
|
TraceAssert(!StrCmpNI(pszUNCPath, pszShare, lstrlen(pszShare)));
|
|
TraceAssert(lstrlen(pszUNCPath) > lstrlen(pszShare));
|
|
|
|
// Copy the path (without \\server\share)
|
|
if (!LocalAllocString(&pszPath, pszUNCPath + lstrlen(pszShare)))
|
|
ExitGracefully(dwErr, ERROR_OUTOFMEMORY, "LocalAllocString failed");
|
|
|
|
// Find the file part of the name
|
|
pszT = PathFindFileName(pszPath);
|
|
if (!pszT)
|
|
ExitGracefully(dwErr, ERROR_INVALID_PARAMETER, "Incomplete path");
|
|
|
|
// Copy the filename
|
|
if (!LocalAllocString(&pszFile, pszT))
|
|
ExitGracefully(dwErr, ERROR_OUTOFMEMORY, "LocalAllocString failed");
|
|
|
|
// Look for the file extension
|
|
pszT = PathFindExtension(pszFile);
|
|
if (pszT)
|
|
{
|
|
// Copy the extension and truncate the file root at this point
|
|
LocalAllocString(&pszExt, pszT);
|
|
*pszT = TEXT('\0');
|
|
}
|
|
|
|
// Truncate the path
|
|
PathRemoveFileSpec(pszPath);
|
|
|
|
// Get the user name
|
|
nLength = ARRAYSIZE(szUserName);
|
|
if (!GetUserName(szUserName, &nLength))
|
|
LoadString(g_hInstance, IDS_UNKNOWN_USER, szUserName, ARRAYSIZE(szUserName));
|
|
|
|
// Build the wildcard path "foo (johndoe v*).txt"
|
|
|
|
nLength = FormatStringID(&pszWildCardName, g_hInstance, IDS_VERSION_FORMAT, pszFile, szUserName, c_szStar, pszExt);
|
|
if (!nLength)
|
|
ExitGracefully(dwErr, GetLastError(), "Unable to format string");
|
|
|
|
pszDriveLetterPath = (LPTSTR)LocalAlloc(LPTR, MAX_PATH_BYTES);
|
|
if (!pszDriveLetterPath)
|
|
ExitGracefully(dwErr, ERROR_OUTOFMEMORY, "LocalAlloc failed");
|
|
|
|
if (!PathCombine(pszDriveLetterPath, pszDrive, pszPath) ||
|
|
!PathAppend(pszDriveLetterPath, pszWildCardName))
|
|
{
|
|
ExitGracefully(dwErr, ERROR_FILENAME_EXCED_RANGE, "Path too long");
|
|
}
|
|
nLength = (ULONG)(StrStr(pszWildCardName, c_szStar) - pszWildCardName); // remember where the '*' is
|
|
|
|
// Search for existing versions of the file with this username
|
|
hFind = FindFirstFile(pszDriveLetterPath, &fd);
|
|
|
|
if (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
ULONG nVersion;
|
|
|
|
do
|
|
{
|
|
nVersion = StrToLong(&fd.cFileName[nLength]);
|
|
|
|
if (nVersion > nMaxVersion)
|
|
{
|
|
nMaxVersion = nVersion;
|
|
}
|
|
|
|
cOlderVersions++;
|
|
}
|
|
while (FindNextFile(hFind, &fd));
|
|
|
|
FindClose(hFind);
|
|
}
|
|
|
|
// Build the new file name to return to the caller.
|
|
// This one is version nMaxVersion+1.
|
|
ULongToString(nMaxVersion+1, pszDriveLetterPath, MAX_PATH);
|
|
nLength = FormatStringID(ppszNewName, g_hInstance, IDS_VERSION_FORMAT, pszFile, szUserName, pszDriveLetterPath, pszExt);
|
|
if (!nLength)
|
|
ExitGracefully(dwErr, GetLastError(), "Unable to format string");
|
|
|
|
exit_gracefully:
|
|
|
|
LocalFreeString(&pszDriveLetterPath);
|
|
LocalFreeString(&pszPath);
|
|
LocalFreeString(&pszFile);
|
|
LocalFreeString(&pszExt);
|
|
LocalFreeString(&pszWildCardName);
|
|
|
|
if (NOERROR != dwErr)
|
|
{
|
|
LocalFreeString(ppszNewName);
|
|
}
|
|
|
|
TraceLeaveValue(dwErr);
|
|
}
|
|
|
|
|
|
//*************************************************************
|
|
//
|
|
// ConflictDlgCallback
|
|
//
|
|
// Purpose: Display local or remote file from conflict dialog
|
|
//
|
|
// Parameters: hWnd - conflict dialog handle (used as parent for UI)
|
|
// uMsg - one of RFCCM_*
|
|
// wParam - depends on uMsg (unused)
|
|
// lParam - pointer to context data (RFCDLGPARAM)
|
|
//
|
|
//
|
|
// Return: TRUE on success, FALSE otherwise
|
|
//
|
|
//*************************************************************
|
|
|
|
typedef struct _CONFLICT_DATA
|
|
{
|
|
LPCTSTR pszShare;
|
|
LPCTSTR pszDrive;
|
|
} CONFLICT_DATA;
|
|
|
|
BOOL
|
|
ConflictDlgCallback(HWND hWnd, UINT uMsg, WPARAM /*wParam*/, LPARAM lParam)
|
|
{
|
|
RFCDLGPARAM *pdlgParam = (RFCDLGPARAM*)lParam;
|
|
CONFLICT_DATA cd = {0};
|
|
LPTSTR pszTmpName = NULL;
|
|
ULONG cchShare = 0;
|
|
LPTSTR szFile;
|
|
DWORD dwErr = NOERROR;
|
|
|
|
TraceEnter(TRACE_UPDATE, "ConflictDlgCallback");
|
|
|
|
if (NULL == pdlgParam)
|
|
{
|
|
TraceAssert(FALSE);
|
|
TraceLeaveValue(FALSE);
|
|
}
|
|
|
|
szFile = (LPTSTR)LocalAlloc(LMEM_FIXED,
|
|
MAX(StringByteSize(pdlgParam->pszLocation)
|
|
+ StringByteSize(pdlgParam->pszFilename), MAX_PATH_BYTES));
|
|
if (!szFile)
|
|
TraceLeaveValue(FALSE);
|
|
|
|
if (pdlgParam->lCallerData)
|
|
cd = *(CONFLICT_DATA*)pdlgParam->lCallerData;
|
|
if (cd.pszShare)
|
|
cchShare = lstrlen(cd.pszShare);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case RFCCM_VIEWLOCAL:
|
|
// Build UNC path and view what's in the cache
|
|
if (PathCombine(szFile, pdlgParam->pszLocation, pdlgParam->pszFilename))
|
|
{
|
|
dwErr = OpenOfflineFile(szFile);
|
|
}
|
|
else
|
|
{
|
|
dwErr = ERROR_FILENAME_EXCED_RANGE;
|
|
}
|
|
break;
|
|
|
|
case RFCCM_VIEWNETWORK:
|
|
// Build drive letter (non-UNC) path and ShellExecute it
|
|
if (PathCombine(szFile, cd.pszDrive, pdlgParam->pszLocation + cchShare)
|
|
&& PathAppend(szFile, pdlgParam->pszFilename))
|
|
{
|
|
SHELLEXECUTEINFO si = {0};
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SEE_MASK_FLAG_NO_UI;
|
|
si.hwnd = hWnd;
|
|
si.lpFile = szFile;
|
|
si.nShow = SW_NORMAL;
|
|
|
|
Trace((TEXT("ShellExecuting \"%s\""), szFile));
|
|
if (!ShellExecuteEx(&si))
|
|
dwErr = GetLastError();
|
|
}
|
|
else
|
|
{
|
|
dwErr = ERROR_FILENAME_EXCED_RANGE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (NOERROR != dwErr)
|
|
CscWin32Message(hWnd, dwErr, CSCUI::SEV_ERROR);
|
|
|
|
LocalFree(szFile);
|
|
TraceLeaveValue(TRUE);
|
|
}
|
|
|
|
//*************************************************************
|
|
//
|
|
// ShowConflictDialog
|
|
//
|
|
// Purpose: Invoke the conflict resolution dialog
|
|
//
|
|
// Parameters: hWndParent - dialog parent window
|
|
// pszUNCPath - full UNC of file that conflicts
|
|
// pszNewName - filespec to use for new copy of file (e.g. "foo (johndoe v1).txt"
|
|
// pszShare - "\\server\share"
|
|
// pszDrive - "X:" drive mapping of remote connection
|
|
// pfdLocal - Information about local file
|
|
// pfdRemote - Information about remote file
|
|
//
|
|
//
|
|
// Return: HRESULT
|
|
//
|
|
//*************************************************************
|
|
|
|
typedef int (WINAPI *PFNSYNCMGRRESOLVECONFLICT)(HWND hWndParent, RFCDLGPARAM *pdlgParam);
|
|
TCHAR const c_szSyncMgrDll[] = TEXT("mobsync.dll");
|
|
CHAR const c_szResolveConflict[] = "SyncMgrResolveConflictW";
|
|
|
|
BOOL FileHasAssociation(LPCTSTR pszFile)
|
|
{
|
|
HRESULT hr = HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
|
|
if (pszFile)
|
|
{
|
|
pszFile = PathFindExtension(pszFile);
|
|
if (pszFile && *pszFile)
|
|
{
|
|
IQueryAssociations *pAssoc = NULL;
|
|
hr = AssocCreate(CLSID_QueryAssociations,
|
|
IID_IQueryAssociations,
|
|
(LPVOID*)&pAssoc);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pAssoc->Init(ASSOCF_IGNOREBASECLASS, pszFile, NULL, NULL);
|
|
pAssoc->Release();
|
|
}
|
|
}
|
|
}
|
|
return SUCCEEDED(hr);
|
|
}
|
|
|
|
int
|
|
ShowConflictDialog(HWND hWndParent,
|
|
LPCTSTR pszUNCPath,
|
|
LPCTSTR pszNewName,
|
|
LPCTSTR pszShare,
|
|
LPCTSTR pszDrive,
|
|
LPWIN32_FIND_DATA pfdLocal,
|
|
LPWIN32_FIND_DATA pfdRemote)
|
|
{
|
|
int nResult = 0;
|
|
TCHAR szUser[MAX_USERNAME_CHARS];
|
|
LPTSTR pszPath = NULL;
|
|
LPTSTR pszFile = NULL;
|
|
TCHAR szRemoteDate[MAX_PATH];
|
|
TCHAR szLocalDate[MAX_PATH];
|
|
ULONG nLength;
|
|
RFCDLGPARAM dp = {0};
|
|
CONFLICT_DATA cd;
|
|
BOOL bLocalIsDir = FALSE;
|
|
BOOL bRemoteIsDir = FALSE;
|
|
|
|
static PFNSYNCMGRRESOLVECONFLICT pfnResolveConflict = NULL;
|
|
|
|
TraceEnter(TRACE_UPDATE, "ShowConflictDialog");
|
|
TraceAssert(pszUNCPath);
|
|
|
|
if (NULL == pfnResolveConflict)
|
|
{
|
|
// The CSC Update handler is loaded by SyncMgr, so assume the SyncMgr
|
|
// dll is already loaded. We don't want to link to the LIB to keep
|
|
// SyncMgr from loading every time our context menu or icon overlay
|
|
// handler is loaded (for example).
|
|
HMODULE hSyncMgrDll = GetModuleHandle(c_szSyncMgrDll);
|
|
if (NULL != hSyncMgrDll)
|
|
pfnResolveConflict = (PFNSYNCMGRRESOLVECONFLICT)GetProcAddress(hSyncMgrDll,
|
|
c_szResolveConflict);
|
|
if (NULL == pfnResolveConflict)
|
|
return 0;
|
|
}
|
|
TraceAssert(NULL != pfnResolveConflict);
|
|
|
|
szUser[0] = TEXT('\0');
|
|
nLength = ARRAYSIZE(szUser);
|
|
GetUserName(szUser, &nLength);
|
|
|
|
szRemoteDate[0] = TEXT('\0');
|
|
if (NULL != pfdRemote)
|
|
{
|
|
DWORD dwFlags = FDTF_DEFAULT;
|
|
SHFormatDateTime(&pfdRemote->ftLastWriteTime, &dwFlags, szRemoteDate, ARRAYSIZE(szRemoteDate));
|
|
|
|
if (pfdRemote->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
bRemoteIsDir = TRUE;
|
|
}
|
|
|
|
szLocalDate[0] = TEXT('\0');
|
|
if (NULL != pfdLocal)
|
|
{
|
|
DWORD dwFlags = FDTF_DEFAULT;
|
|
SHFormatDateTime(&pfdLocal->ftLastWriteTime, &dwFlags, szLocalDate, ARRAYSIZE(szLocalDate));
|
|
|
|
if (pfdLocal->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
bLocalIsDir = TRUE;
|
|
}
|
|
|
|
if (!LocalAllocString(&pszPath, pszUNCPath))
|
|
ExitGracefully(nResult, 0, "LocalAllocString failed");
|
|
pszFile = PathFindFileName(pszUNCPath);
|
|
PathRemoveFileSpec(pszPath);
|
|
|
|
dp.dwFlags = RFCF_APPLY_ALL;
|
|
dp.pszFilename = pszFile;
|
|
dp.pszLocation = pszPath;
|
|
dp.pszNewName = pszNewName;
|
|
dp.pszNetworkModifiedBy = NULL;
|
|
dp.pszLocalModifiedBy = szUser;
|
|
dp.pszNetworkModifiedOn = szRemoteDate;
|
|
dp.pszLocalModifiedOn = szLocalDate;
|
|
dp.pfnCallBack = NULL;
|
|
dp.lCallerData = 0;
|
|
|
|
// Only turn on the View buttons (set a callback) if we're
|
|
// dealing with files that have associations.
|
|
if (!(bLocalIsDir || bRemoteIsDir) && FileHasAssociation(pszFile))
|
|
{
|
|
// Save both the share name and drive letter for building paths to view files
|
|
cd.pszShare = pszShare;
|
|
cd.pszDrive = pszDrive;
|
|
|
|
dp.pfnCallBack = ConflictDlgCallback;
|
|
dp.lCallerData = (LPARAM)&cd;
|
|
}
|
|
|
|
nResult = (*pfnResolveConflict)(hWndParent, &dp);
|
|
|
|
exit_gracefully:
|
|
|
|
LocalFreeString(&pszPath);
|
|
// No need to free pszFile
|
|
|
|
TraceLeaveValue(nResult);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// SyncMgr integration implementation //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
CCscUpdate::CCscUpdate() : m_cRef(1), m_bCSInited(FALSE),
|
|
m_pSyncMgrCB(NULL), m_hSyncThreads(NULL),
|
|
m_pFileList(NULL), m_hSyncItems(NULL), m_hwndDlgParent(NULL),
|
|
m_hgcSyncInProgress(NULL), m_pConflictPinList(NULL),
|
|
m_pSilentFolderList(NULL), m_pSpecialFolderList(NULL),
|
|
m_bCacheIsEncrypted(IsCacheEncrypted(NULL))
|
|
{
|
|
DllAddRef();
|
|
if (!g_hCscIcon)
|
|
g_hCscIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_CSCUI_ICON));
|
|
}
|
|
|
|
|
|
CCscUpdate::~CCscUpdate()
|
|
{
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::~CCscUpdate");
|
|
|
|
SyncCompleted();
|
|
TraceAssert(NULL == m_hgcSyncInProgress);
|
|
|
|
// We should never get here while a sync thread is still running
|
|
TraceAssert(NULL == m_hSyncThreads || 0 == DPA_GetPtrCount(m_hSyncThreads));
|
|
DPA_Destroy(m_hSyncThreads);
|
|
|
|
if (m_bCSInited)
|
|
{
|
|
DeleteCriticalSection(&m_csThreadList);
|
|
}
|
|
|
|
DSA_Destroy(m_hSyncItems);
|
|
|
|
DoRelease(m_pSyncMgrCB);
|
|
|
|
delete m_pFileList;
|
|
delete m_pConflictPinList;
|
|
delete m_pSilentFolderList;
|
|
delete m_pSpecialFolderList;
|
|
|
|
if (NULL != m_hSyncMutex)
|
|
CloseHandle(m_hSyncMutex);
|
|
|
|
DllRelease();
|
|
TraceLeaveVoid();
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CCscUpdate::_Init()
|
|
{
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::_Init");
|
|
|
|
HRESULT hr = m_ShareLog.Initialize(HKEY_CURRENT_USER, c_szCSCShareKey);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_bCSInited = InitializeCriticalSectionAndSpinCount(&m_csThreadList, 0);
|
|
if (m_bCSInited)
|
|
{
|
|
m_hSyncMutex = CreateMutex(NULL, FALSE, c_szSyncMutex);
|
|
if (NULL == m_hSyncMutex)
|
|
{
|
|
hr = ResultFromLastError();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = ResultFromLastError();
|
|
}
|
|
}
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
HRESULT WINAPI
|
|
CCscUpdate::CreateInstance(REFIID riid, LPVOID *ppv)
|
|
{
|
|
HRESULT hr;
|
|
CCscUpdate *pThis;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::CreateInstance");
|
|
TraceAssert(IsCSCEnabled());
|
|
|
|
pThis = new CCscUpdate;
|
|
|
|
if (pThis)
|
|
{
|
|
hr = pThis->_Init();
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pThis->QueryInterface(riid, ppv);
|
|
}
|
|
pThis->Release();
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// SyncMgr integration implementation (IUnknown) //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
STDMETHODIMP CCscUpdate::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] =
|
|
{
|
|
QITABENT(CCscUpdate, ISyncMgrSynchronize),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CCscUpdate::AddRef()
|
|
{
|
|
return InterlockedIncrement(&m_cRef);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CCscUpdate::Release()
|
|
{
|
|
ASSERT( 0 != m_cRef );
|
|
ULONG cRef = InterlockedDecrement(&m_cRef);
|
|
if ( 0 == cRef )
|
|
{
|
|
delete this;
|
|
}
|
|
return cRef;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Sync Manager integration implementation (ISyncMgrSynchronize) //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
STDMETHODIMP
|
|
CCscUpdate::Initialize(DWORD /*dwReserved*/,
|
|
DWORD dwSyncFlags,
|
|
DWORD cbCookie,
|
|
const BYTE *pCookie)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL bNoNet = TRUE;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::Initialize");
|
|
TraceAssert(IsCSCEnabled());
|
|
|
|
if (!(SYNCMGRFLAG_SETTINGS & dwSyncFlags) && ::IsSyncInProgress())
|
|
{
|
|
//
|
|
// We need to guard against running multiple syncs at the
|
|
// same time. User notification in the UI is handled where
|
|
// the UI code calls CscUpdate(). This is so that the UI
|
|
// message contains the proper context with respect to what
|
|
// the user is doing.
|
|
//
|
|
TraceLeaveResult(E_FAIL);
|
|
}
|
|
|
|
m_dwSyncFlags = 0;
|
|
delete m_pFileList;
|
|
m_pFileList = NULL;
|
|
delete m_pConflictPinList;
|
|
m_pConflictPinList = NULL;
|
|
|
|
// We used to get the tray status to check for NoNet, but
|
|
// there's a timing problem at logon (the tray window may not
|
|
// be created yet). So ask RDR instead. If this call fails,
|
|
// then RDR must be dead, so bNoNet defaults to TRUE.
|
|
CSCIsServerOffline(NULL, &bNoNet);
|
|
|
|
switch (dwSyncFlags & SYNCMGRFLAG_EVENTMASK)
|
|
{
|
|
case SYNCMGRFLAG_CONNECT: // Logon
|
|
if (bNoNet)
|
|
ExitGracefully(hr, E_FAIL, "No Logon sync when no net");
|
|
m_dwSyncFlags = CSC_SYNC_OUT | CSC_SYNC_LOGON | CSC_SYNC_NOTIFY_SYSTRAY; // | CSC_SYNC_RECONNECT;
|
|
if (CConfig::eSyncFull == CConfig::GetSingleton().SyncAtLogon())
|
|
{
|
|
m_dwSyncFlags |= CSC_SYNC_IN_FULL;
|
|
}
|
|
break;
|
|
|
|
case SYNCMGRFLAG_PENDINGDISCONNECT: // Logoff
|
|
if (bNoNet)
|
|
ExitGracefully(hr, E_FAIL, "No Logoff sync when no net");
|
|
m_dwSyncFlags = CSC_SYNC_LOGOFF;
|
|
if (CConfig::eSyncFull == CConfig::GetSingleton().SyncAtLogoff())
|
|
m_dwSyncFlags |= CSC_SYNC_OUT | CSC_SYNC_IN_FULL;
|
|
else
|
|
m_dwSyncFlags |= CSC_SYNC_IN_QUICK;
|
|
break;
|
|
|
|
case SYNCMGRFLAG_INVOKE: // CscUpdateCache
|
|
if (pCookie != NULL && cbCookie > 0)
|
|
{
|
|
PCSC_UPDATE_DATA pUpdateData = (PCSC_UPDATE_DATA)pCookie;
|
|
|
|
TraceAssert(cbCookie >= sizeof(CSC_UPDATE_DATA));
|
|
|
|
DWORD dwUpdateFlags = pUpdateData->dwUpdateFlags;
|
|
|
|
if (dwUpdateFlags & CSC_UPDATE_SELECTION)
|
|
{
|
|
TraceAssert(cbCookie > sizeof(CSC_UPDATE_DATA));
|
|
|
|
// Create the filelist from the selection provided
|
|
m_pFileList = new CscFilenameList((PCSC_NAMELIST_HDR)ByteOffset(pUpdateData, pUpdateData->dwFileBufferOffset),
|
|
true);
|
|
|
|
if (!m_pFileList)
|
|
ExitGracefully(hr, E_OUTOFMEMORY, "Unable to create CscFilenameList object");
|
|
|
|
if (!m_pFileList->IsValid())
|
|
ExitGracefully(hr, E_FAIL, "Unable to initialize CscFilenameList object");
|
|
|
|
if (CSC_UPDATE_SHOWUI_ALWAYS & dwUpdateFlags)
|
|
{
|
|
m_dwSyncFlags |= CSC_SYNC_SHOWUI_ALWAYS;
|
|
}
|
|
else if (0 == m_pFileList->GetShareCount())
|
|
ExitGracefully(hr, E_UNEXPECTED, "CSC_UPDATE_SELECTION with no selection");
|
|
}
|
|
|
|
if (dwUpdateFlags & CSC_UPDATE_RECONNECT)
|
|
{
|
|
m_dwSyncFlags |= CSC_SYNC_RECONNECT;
|
|
}
|
|
|
|
if (dwUpdateFlags & CSC_UPDATE_UNATTENDED)
|
|
{
|
|
dwSyncFlags &= ~SYNCMGRFLAG_MAYBOTHERUSER;
|
|
}
|
|
|
|
if (dwUpdateFlags & CSC_UPDATE_NOTIFY_DONE)
|
|
{
|
|
//
|
|
// Caller of CscUpdateCache want's systray notification
|
|
// when sync is complete.
|
|
//
|
|
m_dwSyncFlags |= CSC_SYNC_NOTIFY_SYSTRAY;
|
|
}
|
|
|
|
if (dwUpdateFlags & CSC_UPDATE_FILL_ALL)
|
|
m_dwSyncFlags |= CSC_SYNC_IN_FULL;
|
|
else if (dwUpdateFlags & CSC_UPDATE_FILL_QUICK)
|
|
m_dwSyncFlags |= CSC_SYNC_IN_QUICK;
|
|
|
|
if (dwUpdateFlags & CSC_UPDATE_REINT)
|
|
m_dwSyncFlags |= CSC_SYNC_OUT;
|
|
|
|
if (dwUpdateFlags & CSC_UPDATE_PIN_RECURSE)
|
|
m_dwSyncFlags |= CSC_SYNC_PINFILES | CSC_SYNC_PIN_RECURSE | CSC_SYNC_IN_QUICK;
|
|
else if (dwUpdateFlags & CSC_UPDATE_PINFILES)
|
|
m_dwSyncFlags |= CSC_SYNC_PINFILES | CSC_SYNC_IN_QUICK;
|
|
|
|
if (dwUpdateFlags & CSC_UPDATE_IGNORE_ACCESS)
|
|
m_dwSyncFlags |= CSC_SYNC_IGNORE_ACCESS;
|
|
}
|
|
break;
|
|
|
|
case SYNCMGRFLAG_IDLE: // Auto-sync at idle time
|
|
if (bNoNet)
|
|
ExitGracefully(hr, E_FAIL, "No idle sync when no net");
|
|
m_dwSyncFlags = CSC_SYNC_OUT | CSC_SYNC_IN_QUICK | CSC_SYNC_IDLE | CSC_SYNC_NOTIFY_SYSTRAY;
|
|
break;
|
|
|
|
case SYNCMGRFLAG_MANUAL: // Run "mobsync.exe"
|
|
m_dwSyncFlags = CSC_SYNC_OUT | CSC_SYNC_IN_FULL | CSC_SYNC_NOTIFY_SYSTRAY | CSC_SYNC_RECONNECT;
|
|
break;
|
|
|
|
case SYNCMGRFLAG_SCHEDULED: // User scheduled sync
|
|
m_dwSyncFlags = CSC_SYNC_OUT | CSC_SYNC_IN_FULL | CSC_SYNC_NOTIFY_SYSTRAY;
|
|
break;
|
|
}
|
|
|
|
if (!(m_dwSyncFlags & CSC_SYNC_PINFILES))
|
|
m_dwSyncFlags |= CSC_SYNC_EFS_PIN_NONE; // skip EFS if not pinning
|
|
|
|
if (dwSyncFlags & SYNCMGRFLAG_SETTINGS)
|
|
m_dwSyncFlags |= CSC_SYNC_SETTINGS;
|
|
|
|
if (!m_dwSyncFlags)
|
|
ExitGracefully(hr, E_UNEXPECTED, "Nothing to do");
|
|
|
|
if (dwSyncFlags & SYNCMGRFLAG_MAYBOTHERUSER)
|
|
m_dwSyncFlags |= CSC_SYNC_MAYBOTHERUSER;
|
|
|
|
if (bNoNet)
|
|
m_dwSyncFlags |= CSC_SYNC_NONET;
|
|
|
|
hr = GetSilentFolderList();
|
|
if (FAILED(hr))
|
|
{
|
|
m_dwSyncFlags = 0;
|
|
}
|
|
|
|
exit_gracefully:
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CCscUpdate::GetHandlerInfo(LPSYNCMGRHANDLERINFO *ppSyncMgrHandlerInfo)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPSYNCMGRHANDLERINFO pHandlerInfo;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::GetHandlerInfo");
|
|
|
|
if (NULL == ppSyncMgrHandlerInfo)
|
|
TraceLeaveResult(E_INVALIDARG);
|
|
|
|
*ppSyncMgrHandlerInfo = NULL;
|
|
|
|
pHandlerInfo = (LPSYNCMGRHANDLERINFO)CoTaskMemAlloc(sizeof(SYNCMGRHANDLERINFO));
|
|
if (NULL == pHandlerInfo)
|
|
ExitGracefully(hr, E_OUTOFMEMORY, "LocalAlloc failed");
|
|
|
|
pHandlerInfo->cbSize = sizeof(SYNCMGRHANDLERINFO);
|
|
pHandlerInfo->hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_CSCUI_ICON));
|
|
pHandlerInfo->SyncMgrHandlerFlags = (m_dwSyncFlags & CSC_SYNC_LOGOFF) ? 0 :
|
|
(SYNCMGRHANDLER_HASPROPERTIES | SYNCMGRHANDLER_MAYESTABLISHCONNECTION);
|
|
LoadStringW(g_hInstance,
|
|
IDS_APPLICATION,
|
|
pHandlerInfo->wszHandlerName,
|
|
ARRAYSIZE(pHandlerInfo->wszHandlerName));
|
|
|
|
*ppSyncMgrHandlerInfo = pHandlerInfo;
|
|
|
|
exit_gracefully:
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CCscUpdate::EnumSyncMgrItems(LPSYNCMGRENUMITEMS *ppenum)
|
|
{
|
|
HRESULT hr;
|
|
PUPDATEENUM pNewEnum;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::EnumSyncMgrItems");
|
|
|
|
*ppenum = NULL;
|
|
|
|
pNewEnum = new CUpdateEnumerator(this);
|
|
if (pNewEnum)
|
|
{
|
|
hr = pNewEnum->QueryInterface(IID_ISyncMgrEnumItems, (LPVOID*)ppenum);
|
|
pNewEnum->Release();
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CCscUpdate::GetItemObject(REFSYNCMGRITEMID /*rItemID*/, REFIID /*riid*/, LPVOID * /*ppv*/)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CCscUpdate::ShowProperties(HWND hWndParent, REFSYNCMGRITEMID rItemID)
|
|
{
|
|
COfflineFilesFolder::Open();
|
|
|
|
// Notify SyncMgr that the ShowProperties is done.
|
|
if (NULL != m_pSyncMgrCB)
|
|
m_pSyncMgrCB->ShowPropertiesCompleted(S_OK);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CCscUpdate::SetProgressCallback(LPSYNCMGRSYNCHRONIZECALLBACK pCallback)
|
|
{
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::SetProgressCallback");
|
|
|
|
DoRelease(m_pSyncMgrCB);
|
|
|
|
m_pSyncMgrCB = pCallback;
|
|
|
|
if (m_pSyncMgrCB)
|
|
m_pSyncMgrCB->AddRef();
|
|
|
|
TraceLeaveResult(S_OK);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CCscUpdate::PrepareForSync(ULONG cNumItems,
|
|
SYNCMGRITEMID *pItemID,
|
|
HWND /*hWndParent*/,
|
|
DWORD /*dwReserved*/)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::PrepareForSync");
|
|
TraceAssert(0 != cNumItems);
|
|
TraceAssert(NULL != pItemID);
|
|
|
|
//
|
|
// Copy the list of item ID's
|
|
//
|
|
if (NULL == m_hSyncItems)
|
|
{
|
|
m_hSyncItems = DSA_Create(sizeof(SYNCMGRITEMID), 4);
|
|
if (NULL == m_hSyncItems)
|
|
ExitGracefully(hr, E_OUTOFMEMORY, "Unable to create DSA for SYNCMGRITEMID list");
|
|
}
|
|
else
|
|
DSA_DeleteAllItems(m_hSyncItems);
|
|
|
|
while (cNumItems--)
|
|
DSA_AppendItem(m_hSyncItems, pItemID++);
|
|
|
|
exit_gracefully:
|
|
|
|
// ISyncMgrSynchronize::PrepareForSync is now an asynchronous call
|
|
// so we could create another thread to do the work and return from
|
|
// this call immediately. However, since all we do is copy the list
|
|
// of Item IDs, let's do it here and call
|
|
// m_pSyncMgrCB->PrepareForSyncCompleted before returning.
|
|
|
|
if (NULL != m_pSyncMgrCB)
|
|
m_pSyncMgrCB->PrepareForSyncCompleted(hr);
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CCscUpdate::Synchronize(HWND hWndParent)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
ULONG cItems = 0;
|
|
BOOL bConnectionEstablished = FALSE;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::Synchronize");
|
|
|
|
if (NULL != m_hSyncItems)
|
|
cItems = DSA_GetItemCount(m_hSyncItems);
|
|
|
|
//
|
|
// Don't want systray UI updates while syncing.
|
|
// Whenever the systray UI is updated, the code checks first
|
|
// for this global counter object. If it's non-zero, the
|
|
// systray knows there's a sync in progress and the UI isn't
|
|
// updated.
|
|
//
|
|
TraceAssert(NULL == m_hgcSyncInProgress);
|
|
m_hgcSyncInProgress = SHGlobalCounterCreateNamed(c_szSyncInProgCounter, 0);
|
|
if (m_hgcSyncInProgress)
|
|
{
|
|
SHGlobalCounterIncrement(m_hgcSyncInProgress);
|
|
}
|
|
|
|
if (0 == cItems)
|
|
{
|
|
ExitGracefully(hr, E_UNEXPECTED, "Nothing to synchronize");
|
|
}
|
|
else if (1 == cItems)
|
|
{
|
|
SYNCMGRITEMID *pItemID = (SYNCMGRITEMID*)DSA_GetItemPtr(m_hSyncItems, 0);
|
|
if (NULL != pItemID && IsEqualGUID(GUID_CscNullSyncItem, *pItemID))
|
|
{
|
|
//
|
|
// A single item in the DSA and it's our "null sync" GUID.
|
|
// This means we really have nothing to sync but the invoker
|
|
// of the sync wants to see some SyncMgr progress UI. In
|
|
// this scenario the update item enumerator already enumerated
|
|
// the "null sync" item. Here we set this single item's progress
|
|
// UI info to 100% complete and skip any sync activity.
|
|
//
|
|
SYNCMGRPROGRESSITEM spi = {0};
|
|
spi.mask = SYNCMGRPROGRESSITEM_STATUSTYPE |
|
|
SYNCMGRPROGRESSITEM_STATUSTEXT |
|
|
SYNCMGRPROGRESSITEM_PROGVALUE |
|
|
SYNCMGRPROGRESSITEM_MAXVALUE;
|
|
|
|
spi.cbSize = sizeof(spi);
|
|
spi.dwStatusType = SYNCMGRSTATUS_SUCCEEDED;
|
|
spi.lpcStatusText = L" ";
|
|
spi.iProgValue = 1;
|
|
spi.iMaxValue = 1;
|
|
m_pSyncMgrCB->Progress(GUID_CscNullSyncItem, &spi);
|
|
m_pSyncMgrCB->SynchronizeCompleted(S_OK);
|
|
|
|
if (CSC_SYNC_RECONNECT & m_dwSyncFlags)
|
|
{
|
|
//
|
|
// We have nothing to sync but one or more servers
|
|
// may still be offline. The user's expectation is that the
|
|
// sync will transition these to online regardless of link
|
|
// speed. Add them to the "reconnect" list.
|
|
//
|
|
_BuildOfflineShareList(&m_ReconnectList);
|
|
}
|
|
ExitGracefully(hr, NOERROR, "Nothing to sync. Progress UI displayed");
|
|
}
|
|
}
|
|
|
|
m_hwndDlgParent = hWndParent;
|
|
|
|
// We can pin autocached files without a net (no sync required);
|
|
// otherwise we need to establish a RAS connection to do anything.
|
|
if ((m_dwSyncFlags & CSC_SYNC_NONET) && !(m_dwSyncFlags & CSC_SYNC_PINFILES))
|
|
{
|
|
hr = m_pSyncMgrCB->EstablishConnection(NULL, 0);
|
|
FailGracefully(hr, "Unable to establish RAS connection");
|
|
|
|
bConnectionEstablished = TRUE;
|
|
}
|
|
|
|
// For each share, kick off a thread to do the work
|
|
while (cItems > 0)
|
|
{
|
|
SYNCMGRITEMID *pItemID;
|
|
CSCEntry *pShareEntry;
|
|
|
|
--cItems;
|
|
pItemID = (SYNCMGRITEMID*)DSA_GetItemPtr(m_hSyncItems, cItems);
|
|
|
|
pShareEntry = m_ShareLog.Get(*pItemID);
|
|
|
|
// We don't enumerate shares to SyncMgr unless a share entry
|
|
// exists in the registry, so m_ShareLog.Get should never fail here.
|
|
if (NULL == pShareEntry)
|
|
ExitGracefully(hr, E_UNEXPECTED, "No share entry");
|
|
|
|
hr = SynchronizeShare(pItemID, pShareEntry->Name(), bConnectionEstablished);
|
|
DSA_DeleteItem(m_hSyncItems, cItems);
|
|
FailGracefully(hr, "Unable to create sync thread");
|
|
}
|
|
|
|
TraceAssert(0 == DSA_GetItemCount(m_hSyncItems));
|
|
|
|
exit_gracefully:
|
|
|
|
if (FAILED(hr))
|
|
SetItemStatus(GUID_NULL, SYNCMGRSTATUS_STOPPED);
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
//
|
|
// Try to reconnect any server that is currently offline.
|
|
//
|
|
void
|
|
CCscUpdate::_BuildOfflineShareList(
|
|
CscFilenameList *pfnl
|
|
)
|
|
{
|
|
WIN32_FIND_DATA fd;
|
|
DWORD dwStatus = 0;
|
|
CCscFindHandle hFind = CacheFindFirst(NULL, &fd, &dwStatus, NULL, NULL, NULL);
|
|
if (hFind.IsValid())
|
|
{
|
|
do
|
|
{
|
|
if (FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & dwStatus)
|
|
{
|
|
CscFilenameList::HSHARE hShare;
|
|
pfnl->AddShare(fd.cFileName, &hShare);
|
|
}
|
|
}
|
|
while(CacheFindNext(hFind, &fd, &dwStatus, NULL, NULL, NULL));
|
|
}
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CCscUpdate::SetItemStatus(REFSYNCMGRITEMID rItemID,
|
|
DWORD dwSyncMgrStatus)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
ULONG cItems;
|
|
BOOL bAllItems;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::SetItemStatus");
|
|
|
|
if (SYNCMGRSTATUS_SKIPPED != dwSyncMgrStatus && SYNCMGRSTATUS_STOPPED != dwSyncMgrStatus)
|
|
TraceLeaveResult(E_NOTIMPL);
|
|
|
|
bAllItems = FALSE;
|
|
if (SYNCMGRSTATUS_STOPPED == dwSyncMgrStatus)
|
|
{
|
|
bAllItems = TRUE;
|
|
m_dwSyncFlags |= CSC_SYNC_CANCELLED;
|
|
}
|
|
|
|
// SetItemStatus can be called between PrepareForSync and Synchronize, in
|
|
// in which case the correct thing to do is remove the item from m_hSyncItems.
|
|
if (NULL != m_hSyncItems)
|
|
{
|
|
cItems = DSA_GetItemCount(m_hSyncItems);
|
|
|
|
while (cItems > 0)
|
|
{
|
|
SYNCMGRITEMID *pItemID;
|
|
|
|
--cItems;
|
|
pItemID = (SYNCMGRITEMID*)DSA_GetItemPtr(m_hSyncItems, cItems);
|
|
|
|
if (bAllItems || (NULL != pItemID && IsEqualGUID(rItemID, *pItemID)))
|
|
{
|
|
// Remove the item from the list of items to sync
|
|
DSA_DeleteItem(m_hSyncItems, cItems);
|
|
if (!bAllItems)
|
|
ExitGracefully(hr, S_OK, "Skipping item");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Lookup the thread for the item ID and set its status
|
|
// to cause it to terminate.
|
|
hr = SetSyncThreadStatus(SyncStop, bAllItems ? GUID_NULL : rItemID);
|
|
|
|
exit_gracefully:
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CCscUpdate::ShowError(HWND /*hWndParent*/ , REFSYNCMGRERRORID /*ErrorID*/)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CCscUpdate::SynchronizeShare(SYNCMGRITEMID *pItemID, LPCTSTR pszShareName, BOOL bRasConnected)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwThreadID;
|
|
PSYNCTHREADDATA pThreadData;
|
|
ULONG cbShareName = 0;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::SynchronizeShare");
|
|
TraceAssert(NULL != pItemID);
|
|
TraceAssert(NULL != pszShareName);
|
|
TraceAssert(*pszShareName);
|
|
|
|
EnterCriticalSection(&m_csThreadList);
|
|
if (NULL == m_hSyncThreads)
|
|
m_hSyncThreads = DPA_Create(4);
|
|
LeaveCriticalSection(&m_csThreadList);
|
|
|
|
if (NULL == m_hSyncThreads)
|
|
ExitGracefully(hr, E_OUTOFMEMORY, "Unable to create DPA for threads");
|
|
|
|
cbShareName = StringByteSize(pszShareName);
|
|
pThreadData = (PSYNCTHREADDATA)LocalAlloc(LPTR, sizeof(SYNCTHREADDATA) + cbShareName);
|
|
|
|
if (!pThreadData)
|
|
ExitGracefully(hr, E_OUTOFMEMORY, "LocalAlloc failed");
|
|
|
|
pThreadData->pThis = this;
|
|
pThreadData->ItemID = *pItemID;
|
|
pThreadData->pszShareName = (LPTSTR)(pThreadData + 1);
|
|
CopyMemory(pThreadData->pszShareName, pszShareName, cbShareName);
|
|
|
|
//
|
|
// If we established a RAS connection, then it will go away
|
|
// right after the sync completes, so there's no point trying
|
|
// to reconnect. That is, only check CSC_SYNC_RECONNECT and
|
|
// add the share to the reconnect list if we aren't doing RAS.
|
|
//
|
|
if (bRasConnected)
|
|
{
|
|
pThreadData->dwSyncStatus |= SDS_SYNC_RAS_CONNECTED;
|
|
}
|
|
else if (m_dwSyncFlags & CSC_SYNC_RECONNECT)
|
|
{
|
|
CscFilenameList::HSHARE hShare;
|
|
m_ReconnectList.AddShare(pszShareName, &hShare);
|
|
}
|
|
|
|
// Give the thread a reference to this object and the DLL
|
|
AddRef();
|
|
LoadLibrary(c_szDllName);
|
|
|
|
pThreadData->hThread = CreateThread(NULL,
|
|
0,
|
|
_SyncThread,
|
|
pThreadData,
|
|
CREATE_SUSPENDED,
|
|
&dwThreadID);
|
|
|
|
if (NULL != pThreadData->hThread)
|
|
{
|
|
EnterCriticalSection(&m_csThreadList);
|
|
DPA_AppendPtr(m_hSyncThreads, pThreadData);
|
|
LeaveCriticalSection(&m_csThreadList);
|
|
|
|
ResumeThread(pThreadData->hThread);
|
|
}
|
|
else
|
|
{
|
|
DWORD dwErr = GetLastError();
|
|
|
|
LocalFree(pThreadData);
|
|
|
|
LPTSTR pszErr = GetErrorText(GetLastError());
|
|
LogError(*pItemID,
|
|
SYNCMGRLOGLEVEL_ERROR,
|
|
IDS_FILL_SPARSE_FILES_ERROR,
|
|
pszShareName,
|
|
pszErr);
|
|
LocalFreeString(&pszErr);
|
|
hr = HRESULT_FROM_WIN32(dwErr);
|
|
|
|
Release();
|
|
FreeLibrary(g_hInstance);
|
|
}
|
|
|
|
exit_gracefully:
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
void
|
|
CCscUpdate::SetLastSyncTime(LPCTSTR pszShareName)
|
|
{
|
|
HKEY hKey = NULL;
|
|
|
|
hKey = m_ShareLog.OpenKey(pszShareName, KEY_SET_VALUE);
|
|
if (hKey)
|
|
{
|
|
FILETIME ft = {0};
|
|
GetSystemTimeAsFileTime(&ft);
|
|
RegSetValueEx(hKey, c_szLastSync, 0, REG_BINARY, (LPBYTE)&ft, sizeof(ft));
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
|
|
|
|
DWORD
|
|
CCscUpdate::GetLastSyncTime(LPCTSTR pszShareName, LPFILETIME pft)
|
|
{
|
|
DWORD dwResult = ERROR_PATH_NOT_FOUND;
|
|
HKEY hKey = NULL;
|
|
|
|
hKey = m_ShareLog.OpenKey(pszShareName, KEY_QUERY_VALUE);
|
|
if (hKey)
|
|
{
|
|
DWORD dwSize = sizeof(*pft);
|
|
dwResult = RegQueryValueEx(hKey, c_szLastSync, NULL, NULL, (LPBYTE)pft, &dwSize);
|
|
RegCloseKey(hKey);
|
|
}
|
|
return dwResult;
|
|
}
|
|
|
|
|
|
void
|
|
CCscUpdate::SyncThreadCompleted(PSYNCTHREADDATA pSyncData)
|
|
{
|
|
int iThread;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::SyncThreadCompleted");
|
|
TraceAssert(NULL != pSyncData);
|
|
TraceAssert(NULL != m_hSyncThreads);
|
|
|
|
EnterCriticalSection(&m_csThreadList);
|
|
|
|
iThread = DPA_GetPtrIndex(m_hSyncThreads, pSyncData);
|
|
TraceAssert(-1 != iThread);
|
|
|
|
DPA_DeletePtr(m_hSyncThreads, iThread);
|
|
CloseHandle(pSyncData->hThread);
|
|
pSyncData->hThread = NULL;
|
|
|
|
iThread = DPA_GetPtrCount(m_hSyncThreads);
|
|
|
|
LeaveCriticalSection(&m_csThreadList);
|
|
|
|
if (0 == iThread)
|
|
{
|
|
SyncCompleted();
|
|
}
|
|
|
|
TraceLeaveVoid();
|
|
}
|
|
|
|
|
|
void
|
|
CCscUpdate::SyncCompleted(void)
|
|
{
|
|
|
|
if ((m_dwSyncFlags & CSC_SYNC_RECONNECT) &&
|
|
!(m_dwSyncFlags & CSC_SYNC_CANCELLED))
|
|
{
|
|
m_dwSyncFlags &= ~CSC_SYNC_RECONNECT;
|
|
ReconnectServers(&m_ReconnectList, FALSE, FALSE);
|
|
}
|
|
|
|
if (NULL != m_hgcSyncInProgress)
|
|
{
|
|
// We're not syncing so reset the global event
|
|
SHGlobalCounterDecrement(m_hgcSyncInProgress);
|
|
SHGlobalCounterDestroy(m_hgcSyncInProgress);
|
|
m_hgcSyncInProgress = NULL;
|
|
}
|
|
|
|
if (m_dwSyncFlags & CSC_SYNC_NOTIFY_SYSTRAY)
|
|
{
|
|
// Notify systray that we're done
|
|
PostToSystray(CSCWM_DONESYNCING, 0, 0);
|
|
m_dwSyncFlags &= ~CSC_SYNC_NOTIFY_SYSTRAY;
|
|
}
|
|
|
|
// Notify SyncMgr that the sync is done
|
|
if (NULL != m_pSyncMgrCB)
|
|
{
|
|
m_pSyncMgrCB->SynchronizeCompleted(S_OK);
|
|
}
|
|
|
|
HANDLE hEvent = OpenEvent(EVENT_MODIFY_STATE, FALSE, c_szSyncCompleteEvent);
|
|
if (NULL != hEvent)
|
|
{
|
|
//
|
|
// Let anyone interested know that the sync is complete.
|
|
//
|
|
SetEvent(hEvent);
|
|
CloseHandle(hEvent);
|
|
}
|
|
}
|
|
|
|
|
|
UINT
|
|
GetErrorFormat(DWORD dwErr, BOOL bMerging = FALSE)
|
|
{
|
|
UINT idString = 0;
|
|
|
|
// These are all just initial guesses. Not sure
|
|
// which error codes we'll get from CSC.
|
|
|
|
switch (dwErr)
|
|
{
|
|
case ERROR_DISK_FULL:
|
|
// "The server disk is full."
|
|
// "The local disk is full."
|
|
idString = bMerging ? IDS_SERVER_FULL_ERROR : IDS_LOCAL_DISK_FULL_ERROR;
|
|
break;
|
|
|
|
case ERROR_LOCK_VIOLATION:
|
|
case ERROR_SHARING_VIOLATION:
|
|
case ERROR_OPEN_FILES:
|
|
case ERROR_ACTIVE_CONNECTIONS:
|
|
case ERROR_DEVICE_IN_USE:
|
|
// "'%1' is in use on %2"
|
|
idString = IDS_FILE_OPEN_ERROR;
|
|
break;
|
|
|
|
case ERROR_BAD_NETPATH:
|
|
case ERROR_DEV_NOT_EXIST:
|
|
case ERROR_NETNAME_DELETED:
|
|
case ERROR_BAD_NET_NAME:
|
|
case ERROR_SHARING_PAUSED:
|
|
case ERROR_REQ_NOT_ACCEP:
|
|
case ERROR_REDIR_PAUSED:
|
|
case ERROR_BAD_DEVICE:
|
|
case ERROR_CONNECTION_UNAVAIL:
|
|
case ERROR_NO_NET_OR_BAD_PATH:
|
|
case ERROR_NO_NETWORK:
|
|
case ERROR_CONNECTION_REFUSED:
|
|
case ERROR_GRACEFUL_DISCONNECT:
|
|
case ERROR_NETWORK_UNREACHABLE:
|
|
case ERROR_HOST_UNREACHABLE:
|
|
case ERROR_PROTOCOL_UNREACHABLE:
|
|
case ERROR_PORT_UNREACHABLE:
|
|
case ERROR_LOGON_FAILURE:
|
|
// "Unable to connect to '%1.' %2"
|
|
idString = IDS_SHARE_CONNECT_ERROR;
|
|
break;
|
|
|
|
case ERROR_OPEN_FAILED:
|
|
case ERROR_UNEXP_NET_ERR:
|
|
case ERROR_NETWORK_BUSY:
|
|
case ERROR_BAD_NET_RESP:
|
|
// "Unable to access '%1' on %2. %3"
|
|
idString = IDS_NET_ERROR;
|
|
break;
|
|
|
|
case ERROR_ACCESS_DENIED:
|
|
case ERROR_NETWORK_ACCESS_DENIED:
|
|
// "Access to '%1' is denied on %2"
|
|
idString = IDS_ACCESS_ERROR;
|
|
break;
|
|
|
|
case ERROR_BAD_FORMAT:
|
|
// "The Offline Files cache is corrupt. Restart the computer to correct the cache."
|
|
idString = IDS_CACHE_CORRUPT;
|
|
break;
|
|
|
|
default:
|
|
// "Error accessing '%1' on %2. %3"
|
|
idString = IDS_UNKNOWN_SYNC_ERROR;
|
|
break;
|
|
}
|
|
|
|
return idString;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CCscUpdate::LogError(REFSYNCMGRITEMID rItemID,
|
|
LPCTSTR pszText,
|
|
DWORD dwLogLevel,
|
|
REFSYNCMGRERRORID ErrorID)
|
|
{
|
|
HRESULT hr;
|
|
SYNCMGRLOGERRORINFO slei;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::LogError");
|
|
|
|
if (NULL == m_pSyncMgrCB)
|
|
TraceLeaveResult(E_UNEXPECTED);
|
|
|
|
slei.cbSize = sizeof(slei);
|
|
slei.mask = SYNCMGRLOGERROR_ITEMID | SYNCMGRLOGERROR_ERRORID;
|
|
slei.ItemID = rItemID;
|
|
slei.ErrorID = ErrorID;
|
|
|
|
// if we have a jumptext associated with this item then
|
|
// set the enable jumptext flag
|
|
if (ErrorID != GUID_NULL)
|
|
{
|
|
slei.mask |= SYNCMGRLOGERROR_ERRORFLAGS;
|
|
slei.dwSyncMgrErrorFlags = SYNCMGRERRORFLAG_ENABLEJUMPTEXT;
|
|
}
|
|
|
|
Trace((pszText));
|
|
hr = m_pSyncMgrCB->LogError(dwLogLevel, pszText, &slei);
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
DWORD
|
|
CCscUpdate::LogError(REFSYNCMGRITEMID rItemID,
|
|
DWORD dwLogLevel,
|
|
UINT nFormatID,
|
|
...)
|
|
{
|
|
LPTSTR pszError = NULL;
|
|
va_list args;
|
|
va_start(args, nFormatID);
|
|
if (vFormatStringID(&pszError, g_hInstance, nFormatID, &args))
|
|
{
|
|
LogError(rItemID, pszError, dwLogLevel);
|
|
LocalFree(pszError);
|
|
}
|
|
va_end(args);
|
|
return 0;
|
|
}
|
|
|
|
void _CopyParentPathForDisplay(LPTSTR pszDest, size_t cchDest, LPCTSTR pszSrc)
|
|
{
|
|
ASSERT(pszDest != NULL && cchDest != 0);
|
|
*pszDest = TEXT('\0');
|
|
if (pszSrc)
|
|
{
|
|
StringCchCopy(pszDest, cchDest, pszSrc);
|
|
PathRemoveFileSpec(pszDest);
|
|
}
|
|
if (TEXT('\0') == *pszDest)
|
|
{
|
|
StringCchCopy(pszDest, cchDest, TEXT("\\"));
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
CCscUpdate::LogError(REFSYNCMGRITEMID rItemID,
|
|
UINT nFormatID,
|
|
LPCTSTR pszName,
|
|
DWORD dwErr,
|
|
DWORD dwLogLevel)
|
|
{
|
|
//
|
|
// Break the filename into "file" and "path" components
|
|
//
|
|
TCHAR szPath[MAX_PATH] = TEXT("\\");
|
|
_CopyParentPathForDisplay(szPath, ARRAYSIZE(szPath), pszName);
|
|
|
|
//
|
|
// Get the system error text and format the error
|
|
//
|
|
LPTSTR pszErr = GetErrorText(dwErr);
|
|
LogError(rItemID,
|
|
dwLogLevel,
|
|
nFormatID,
|
|
PathFindFileName(pszName),
|
|
szPath,
|
|
pszErr);
|
|
LocalFreeString(&pszErr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
BOOL
|
|
MakeDriveLetterPath(LPCTSTR pszUNC,
|
|
LPCTSTR pszShare,
|
|
LPCTSTR pszDrive,
|
|
LPTSTR *ppszResult)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
ULONG cchShare;
|
|
|
|
if (!pszUNC || !pszShare || !ppszResult)
|
|
return FALSE;
|
|
|
|
*ppszResult = NULL;
|
|
|
|
cchShare = lstrlen(pszShare);
|
|
|
|
// If the path is on the share, use the drive letter instead
|
|
if (pszDrive && *pszDrive &&
|
|
0 == StrCmpNI(pszUNC, pszShare, cchShare))
|
|
{
|
|
// We now know that pszUNC is at least as long as pszShare, since
|
|
// they are identical up to that point. But we need to avoid this:
|
|
// pszShare = \\server\share
|
|
// pszUNC = \\server\share2 <-- not a match
|
|
if (pszUNC[cchShare] == TEXT('\0') || pszUNC[cchShare] == TEXT('\\'))
|
|
{
|
|
*ppszResult = (LPTSTR)LocalAlloc(LPTR, MAX(StringByteSize(pszUNC), MAX_PATH_BYTES));
|
|
if (*ppszResult)
|
|
{
|
|
if (PathCombine(*ppszResult, pszDrive, pszUNC + cchShare))
|
|
{
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
{
|
|
LocalFreeString(ppszResult);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
|
|
DWORD
|
|
CCscUpdate::CopyLocalFileWithDriveMapping(LPCTSTR pszSrc,
|
|
LPCTSTR pszDst,
|
|
LPCTSTR pszShare,
|
|
LPCTSTR pszDrive,
|
|
BOOL bDirectory)
|
|
{
|
|
DWORD dwErr = NOERROR;
|
|
LPTSTR szDst = NULL;
|
|
|
|
if (!pszSrc || !pszDst || !pszShare)
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
// If the destination is on the share, use the drive letter instead
|
|
if (MakeDriveLetterPath(pszDst, pszShare, pszDrive, &szDst))
|
|
pszDst = szDst;
|
|
|
|
if (bDirectory)
|
|
{
|
|
// We don't need to copy the directory contents here, just create
|
|
// the tree structure on the server.
|
|
dwErr = SHCreateDirectory(NULL, pszDst);
|
|
if (ERROR_ALREADY_EXISTS == dwErr)
|
|
dwErr = NOERROR;
|
|
}
|
|
else
|
|
{
|
|
LPTSTR pszTmpName = NULL;
|
|
|
|
if (CSCCopyReplica(pszSrc, &pszTmpName))
|
|
{
|
|
if (!MoveFileEx(pszTmpName,
|
|
pszDst,
|
|
MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH))
|
|
{
|
|
dwErr = GetLastError();
|
|
|
|
if (ERROR_PATH_NOT_FOUND == dwErr)
|
|
{
|
|
// The parent directory doesn't exist, create it now.
|
|
TCHAR szParent[MAX_PATH];
|
|
if (SUCCEEDED(StringCchCopy(szParent, ARRAYSIZE(szParent), pszDst))
|
|
&& PathRemoveFileSpec(szParent))
|
|
{
|
|
dwErr = SHCreateDirectory(NULL, szParent);
|
|
|
|
// If that worked, retry the original operation.
|
|
if (NOERROR == dwErr)
|
|
dwErr = CopyLocalFileWithDriveMapping(pszSrc, pszDst, pszShare, NULL, bDirectory);
|
|
}
|
|
}
|
|
}
|
|
|
|
DeleteFile(pszTmpName);
|
|
LocalFree(pszTmpName);
|
|
}
|
|
else
|
|
{
|
|
dwErr = GetLastError();
|
|
}
|
|
}
|
|
|
|
LocalFreeString(&szDst);
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
BOOL
|
|
HandleConflictLocally(PSYNCTHREADDATA pSyncData,
|
|
LPCTSTR pszPath,
|
|
DWORD dwCscStatus,
|
|
DWORD dwLocalAttr,
|
|
DWORD dwRemoteAttr = 0)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
LPTSTR szParent = NULL;
|
|
|
|
// If it's super-hidden or not modified locally, we can always
|
|
// handle the conflict locally.
|
|
if (!(dwCscStatus & CSC_LOCALLY_MODIFIED) || IsHiddenSystem(dwLocalAttr) || IsHiddenSystem(dwRemoteAttr))
|
|
return TRUE;
|
|
|
|
// If we're dealing with 2 folders, the worst that happens is that the
|
|
// underlying files/folders get merged.
|
|
if ((FILE_ATTRIBUTE_DIRECTORY & dwLocalAttr) && (FILE_ATTRIBUTE_DIRECTORY & dwRemoteAttr))
|
|
return TRUE;
|
|
|
|
//
|
|
// Next, check whether the parent path is super-hidden.
|
|
//
|
|
// For example, recycle bin makes super-hidden folders and puts
|
|
// metadata files in them.
|
|
//
|
|
// Do this on the server, since CSC has exclusive access to the database
|
|
// while merging, causing GetFileAttributes to fail with Access Denied.
|
|
//
|
|
//
|
|
// Do this on the server, since CSC has exclusive access to the database
|
|
// while merging, causing GetFileAttributes to fail with Access Denied.
|
|
//
|
|
if (MakeDriveLetterPath(pszPath, pSyncData->pszShareName, pSyncData->szDrive, &szParent))
|
|
{
|
|
//
|
|
// Don't check attributes at the root, just stop.
|
|
// WinSE 16781.
|
|
//
|
|
for(PathRemoveFileSpec(szParent); !PathIsRoot(szParent); PathRemoveFileSpec(szParent))
|
|
{
|
|
dwRemoteAttr = GetFileAttributes(szParent);
|
|
|
|
if ((DWORD)-1 == dwRemoteAttr)
|
|
{
|
|
// Path doesn't exist, access denied, etc.
|
|
break;
|
|
}
|
|
|
|
if (IsHiddenSystem(dwRemoteAttr))
|
|
{
|
|
bResult = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
LocalFreeString(&szParent);
|
|
|
|
return bResult;
|
|
}
|
|
|
|
DWORD
|
|
CCscUpdate::HandleFileConflict(PSYNCTHREADDATA pSyncData,
|
|
LPCTSTR pszName,
|
|
DWORD dwStatus,
|
|
DWORD dwHintFlags,
|
|
LPWIN32_FIND_DATA pFind32)
|
|
{
|
|
DWORD dwResult = CSCPROC_RETURN_CONTINUE;
|
|
DWORD dwErr = NOERROR;
|
|
int nErrorResolution = RFC_KEEPBOTH;
|
|
LPTSTR pszNewName = NULL;
|
|
LPTSTR szFullPath = NULL;
|
|
BOOL bApplyToAll = FALSE;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::HandleFileConflict");
|
|
Trace((TEXT("File conflict: %s"), pszName));
|
|
TraceAssert(pSyncData->dwSyncStatus & SDS_SYNC_OUT);
|
|
|
|
szFullPath = (LPTSTR)LocalAlloc(LPTR, MAX_PATH_BYTES);
|
|
if (!szFullPath)
|
|
{
|
|
dwErr = ERROR_OUTOFMEMORY;
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_SKIP, "LocalAlloc failed");
|
|
}
|
|
|
|
HANDLE hFind;
|
|
WIN32_FIND_DATA fdRemote;
|
|
|
|
if (!PathCombine(szFullPath, pSyncData->szDrive, pszName + lstrlen(pSyncData->pszShareName)))
|
|
{
|
|
dwErr = ERROR_FILENAME_EXCED_RANGE;
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_SKIP, "Full path is too long");
|
|
}
|
|
|
|
hFind = FindFirstFile(szFullPath, &fdRemote);
|
|
|
|
// Does the net version still exist?
|
|
if (hFind == INVALID_HANDLE_VALUE)
|
|
ExitGracefully(dwResult, HandleDeleteConflict(pSyncData, pszName, dwStatus, dwHintFlags, pFind32), "Net file deleted");
|
|
|
|
// Still exists, continue
|
|
FindClose(hFind);
|
|
|
|
// If only the attributes or file times were modified locally,
|
|
// or if the file is hidden+system, keep the server copy and
|
|
// don't bother the user. (e.g. desktop.ini)
|
|
if (HandleConflictLocally(pSyncData, pszName, dwStatus, pFind32->dwFileAttributes, fdRemote.dwFileAttributes))
|
|
{
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_FORCE_INWARD, "Ignoring conflict");
|
|
}
|
|
else if (IsSilentFolder(pszName))
|
|
{
|
|
// It's in a per-user shell special folder. Last writer wins.
|
|
if (CompareFileTime(&pFind32->ftLastWriteTime, &fdRemote.ftLastWriteTime) < 0)
|
|
{
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_FORCE_INWARD, "Handling special folder conflict - server copy wins");
|
|
}
|
|
else
|
|
{
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_FORCE_OUTWARD, "Handling special folder conflict - local copy wins");
|
|
}
|
|
}
|
|
|
|
dwErr = GetNewVersionName(pszName,
|
|
pSyncData->pszShareName,
|
|
pSyncData->szDrive,
|
|
&pszNewName);
|
|
if (NOERROR != dwErr)
|
|
{
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_SKIP, "GetNewVersionName failed");
|
|
}
|
|
|
|
switch (SDS_SYNC_FILE_CONFLICT_MASK & pSyncData->dwSyncStatus)
|
|
{
|
|
case 0:
|
|
if (CSC_SYNC_MAYBOTHERUSER & m_dwSyncFlags)
|
|
{
|
|
nErrorResolution = ShowConflictDialog(m_hwndDlgParent,
|
|
pszName,
|
|
pszNewName,
|
|
pSyncData->pszShareName,
|
|
pSyncData->szDrive,
|
|
pFind32,
|
|
&fdRemote);
|
|
if (RFC_APPLY_TO_ALL & nErrorResolution)
|
|
{
|
|
bApplyToAll = TRUE;
|
|
nErrorResolution &= ~RFC_APPLY_TO_ALL;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SDS_SYNC_CONFLICT_KEEPLOCAL:
|
|
nErrorResolution = RFC_KEEPLOCAL;
|
|
break;
|
|
|
|
case SDS_SYNC_CONFLICT_KEEPNET:
|
|
nErrorResolution = RFC_KEEPNETWORK;
|
|
break;
|
|
|
|
case SDS_SYNC_CONFLICT_KEEPBOTH:
|
|
nErrorResolution = RFC_KEEPBOTH;
|
|
break;
|
|
}
|
|
|
|
switch (nErrorResolution)
|
|
{
|
|
default:
|
|
case RFC_KEEPBOTH:
|
|
if (bApplyToAll)
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_CONFLICT_KEEPBOTH;
|
|
if (SUCCEEDED(StringCchCopy(szFullPath, MAX_PATH, pszName))
|
|
&& PathRemoveFileSpec(szFullPath))
|
|
{
|
|
if (FILE_ATTRIBUTE_DIRECTORY & pFind32->dwFileAttributes)
|
|
{
|
|
// Rename the local version in the cache and merge again.
|
|
if (FAILED(StringCchCopy(pFind32->cFileName, ARRAYSIZE(pFind32->cFileName), pszNewName)))
|
|
{
|
|
dwErr = ERROR_FILENAME_EXCED_RANGE;
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_SKIP, "CSCDoLocalRenameEx failed");
|
|
}
|
|
if (!CSCDoLocalRenameEx(pszName, szFullPath, pFind32, TRUE, TRUE))
|
|
{
|
|
dwErr = GetLastError();
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_SKIP, "CSCDoLocalRenameEx failed");
|
|
}
|
|
// Because CSCDoLocalRenameEx and CSCMergeShare are separate operations,
|
|
// we have to abort the current merge operation and start over.
|
|
// Otherwise, the current merge operation fails due to the "left
|
|
// hand not knowing what the right hande is doing".
|
|
Trace((TEXT("Restarting merge on: %s"), pSyncData->pszShareName));
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_RESTART_MERGE;
|
|
dwResult = CSCPROC_RETURN_ABORT;
|
|
}
|
|
else
|
|
{
|
|
// Note that CSCDoLocalRenameEx would work for files also, but we
|
|
// prefer to avoid restarting CSCMergeShare so do these ourselves.
|
|
if (!PathAppend(szFullPath, pszNewName))
|
|
{
|
|
dwErr = ERROR_FILENAME_EXCED_RANGE;
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_SKIP, "Full path is too long");
|
|
}
|
|
dwErr = CopyLocalFileWithDriveMapping(pszName,
|
|
szFullPath,
|
|
pSyncData->pszShareName,
|
|
pSyncData->szDrive);
|
|
if (NOERROR != dwErr)
|
|
{
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_SKIP, "CopyLocalFileWithDriveMapping failed");
|
|
}
|
|
|
|
// If the original file was pinned, we want to pin the copy also.
|
|
// Unfortunately, we can't reliably pin during a merge, so we have
|
|
// to remember these in a list and pin them later.
|
|
if (dwHintFlags & (FLAG_CSC_HINT_PIN_USER | FLAG_CSC_HINT_PIN_ADMIN))
|
|
{
|
|
if (!m_pConflictPinList)
|
|
m_pConflictPinList = new CscFilenameList;
|
|
if (m_pConflictPinList)
|
|
{
|
|
m_pConflictPinList->AddFile(szFullPath,
|
|
!!(pFind32->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY));
|
|
}
|
|
}
|
|
|
|
// Tell CSCMergeShare to copy the server copy to the cache
|
|
// (with the old name). This clears the dirty cache.
|
|
dwResult = CSCPROC_RETURN_FORCE_INWARD;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dwErr = ERROR_INVALID_NAME;
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_SKIP, "Invalid path");
|
|
}
|
|
break;
|
|
|
|
case RFC_KEEPNETWORK:
|
|
// Tell CSCMergeShare to copy the server copy to the cache
|
|
dwResult = CSCPROC_RETURN_FORCE_INWARD;
|
|
if (bApplyToAll)
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_CONFLICT_KEEPNET;
|
|
break;
|
|
|
|
case RFC_KEEPLOCAL:
|
|
// Tell CSCMergeShare to push the local copy to the server
|
|
dwResult = CSCPROC_RETURN_FORCE_OUTWARD;
|
|
if (bApplyToAll)
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_CONFLICT_KEEPLOCAL;
|
|
break;
|
|
|
|
case RFC_CANCEL:
|
|
TraceMsg("HandleFileConflict: Cancelling sync - user bailed");
|
|
SetItemStatus(GUID_NULL, SYNCMGRSTATUS_STOPPED);
|
|
dwResult = CSCPROC_RETURN_ABORT;
|
|
break;
|
|
}
|
|
|
|
exit_gracefully:
|
|
|
|
if (CSCPROC_RETURN_FORCE_INWARD == dwResult)
|
|
{
|
|
// CSCMergeShare truncates (makes sparse) the
|
|
// file if we return this. We'd like to fill
|
|
// it during this sync.
|
|
pSyncData->cFilesToSync++;
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_FORCE_INWARD;
|
|
}
|
|
|
|
if (NOERROR != dwErr)
|
|
{
|
|
pszName += lstrlen(pSyncData->pszShareName);
|
|
if (*pszName == TEXT('\\'))
|
|
pszName++;
|
|
LogError(pSyncData->ItemID,
|
|
IDS_NAME_CONFLICT_ERROR,
|
|
pszName,
|
|
dwErr);
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_ERROR;
|
|
}
|
|
|
|
LocalFreeString(&szFullPath);
|
|
LocalFreeString(&pszNewName);
|
|
|
|
TraceLeaveResult(dwResult);
|
|
}
|
|
|
|
|
|
// Returns values for the Resolve Delete Conflict dialog
|
|
#define RDC_CANCEL 0x00
|
|
#define RDC_DELETE 0x01
|
|
#define RDC_RESTORE 0x02
|
|
#define RDC_APPLY_ALL 0x04
|
|
#define RDC_DELETE_ALL (RDC_APPLY_ALL | RDC_DELETE)
|
|
#define RDC_RESTORE_ALL (RDC_APPLY_ALL | RDC_RESTORE)
|
|
|
|
TCHAR const c_szDeleteSelection[] = TEXT("DeleteConflictSelection");
|
|
|
|
INT_PTR CALLBACK
|
|
DeleteConflictProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
int nResult;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
TCHAR szShare[MAX_PATH];
|
|
LPCTSTR pszPath = (LPCTSTR)lParam;
|
|
LPTSTR pszT = NULL;
|
|
|
|
szShare[0] = TEXT('\0');
|
|
StringCchCopy(szShare, ARRAYSIZE(szShare), pszPath);
|
|
PathStripToRoot(szShare);
|
|
|
|
// Format the file name
|
|
PathSetDlgItemPath(hDlg, IDC_FILENAME, pszPath);
|
|
|
|
// Build the "Do this for all on <this share>" string
|
|
FormatStringID(&pszT, g_hInstance, IDS_FMT_DELETE_APPLY_ALL, szShare);
|
|
if (pszT)
|
|
{
|
|
SetDlgItemText(hDlg, IDC_APPLY_TO_ALL, pszT);
|
|
LocalFreeString(&pszT);
|
|
}
|
|
// else default text is OK (no share name)
|
|
|
|
// Select whatever the user chose last time, default is "restore"
|
|
DWORD dwPrevSelection = RDC_RESTORE;
|
|
DWORD dwType;
|
|
DWORD cbData = sizeof(dwPrevSelection);
|
|
SHGetValue(HKEY_CURRENT_USER,
|
|
c_szCSCKey,
|
|
c_szDeleteSelection,
|
|
&dwType,
|
|
&dwPrevSelection,
|
|
&cbData);
|
|
dwPrevSelection = (RDC_DELETE == dwPrevSelection ? IDC_DELETE_LOCAL : IDC_KEEP_LOCAL);
|
|
CheckRadioButton(hDlg, IDC_KEEP_LOCAL, IDC_DELETE_LOCAL, dwPrevSelection);
|
|
|
|
// Get the file-type icon
|
|
pszT = PathFindExtension(pszPath);
|
|
if (pszT)
|
|
{
|
|
SHFILEINFO sfi = {0};
|
|
SHGetFileInfo(pszT, 0, &sfi, sizeof(sfi), SHGFI_ICON);
|
|
if (sfi.hIcon)
|
|
{
|
|
SendDlgItemMessage(hDlg,
|
|
IDC_DLGTYPEICON,
|
|
STM_SETICON,
|
|
(WPARAM)sfi.hIcon,
|
|
0L);
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
nResult = -1;
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDCANCEL:
|
|
nResult = RDC_CANCEL;
|
|
break;
|
|
|
|
case IDOK:
|
|
if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_DELETE_LOCAL))
|
|
nResult = RDC_DELETE;
|
|
else
|
|
nResult = RDC_RESTORE;
|
|
// Remember the selection for next time
|
|
SHSetValue(HKEY_CURRENT_USER,
|
|
c_szCSCKey,
|
|
c_szDeleteSelection,
|
|
REG_DWORD,
|
|
&nResult,
|
|
sizeof(nResult));
|
|
if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_APPLY_TO_ALL))
|
|
nResult |= RDC_APPLY_ALL;
|
|
break;
|
|
}
|
|
if (-1 != nResult)
|
|
{
|
|
EndDialog(hDlg, nResult);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL CALLBACK
|
|
ConflictPurgeCallback(LPCWSTR /*pszFile*/, LPARAM lParam)
|
|
{
|
|
PSYNCTHREADDATA pSyncData = (PSYNCTHREADDATA)lParam;
|
|
return !(SDS_SYNC_CANCELLED & pSyncData->dwSyncStatus);
|
|
}
|
|
|
|
|
|
DWORD
|
|
CCscUpdate::HandleDeleteConflict(PSYNCTHREADDATA pSyncData,
|
|
LPCTSTR pszName,
|
|
DWORD dwStatus,
|
|
DWORD dwHintFlags,
|
|
LPWIN32_FIND_DATA pFind32)
|
|
{
|
|
DWORD dwResult = CSCPROC_RETURN_CONTINUE;
|
|
int nErrorResolution = RDC_DELETE; // default action
|
|
BOOL bDirectory = (FILE_ATTRIBUTE_DIRECTORY & pFind32->dwFileAttributes);
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::HandleDeleteConflict");
|
|
Trace((TEXT("Net file deleted: %s"), pszName));
|
|
|
|
//
|
|
// We already know that the net file was deleted, or HandleDeleteConflict
|
|
// wouldn't be called. If the local copy was also deleted, then there
|
|
// isn't really a conflict and we can continue without prompting.
|
|
//
|
|
// Handle the conflict silently if only attributes changed or it's super-hidden.
|
|
//
|
|
// Finally, if the file lives in certain special folder locations,
|
|
// such as AppData, handle the conflict silently.
|
|
//
|
|
// If we get past all that, ask the user what to do, but only bother
|
|
// the user as a last resort.
|
|
//
|
|
if ( !(dwStatus & FLAG_CSC_COPY_STATUS_LOCALLY_DELETED)
|
|
&& !HandleConflictLocally(pSyncData, pszName, dwStatus, pFind32->dwFileAttributes)
|
|
&& !IsSilentFolder(pszName)
|
|
)
|
|
{
|
|
// The file is either pinned or modified locally, so
|
|
// default action is now "restore".
|
|
nErrorResolution = RDC_RESTORE;
|
|
|
|
switch (SDS_SYNC_DELETE_CONFLICT_MASK & pSyncData->dwSyncStatus)
|
|
{
|
|
case 0:
|
|
if (CSC_SYNC_MAYBOTHERUSER & m_dwSyncFlags)
|
|
{
|
|
int idDialog = (bDirectory ? IDD_FOLDER_CONFLICT_DELETE : IDD_FILE_CONFLICT_DELETE);
|
|
nErrorResolution = (int)DialogBoxParam(g_hInstance,
|
|
MAKEINTRESOURCE(idDialog),
|
|
m_hwndDlgParent,
|
|
DeleteConflictProc,
|
|
(LPARAM)pszName);
|
|
if (RDC_DELETE_ALL == nErrorResolution)
|
|
{
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_DELETE_DELETE;
|
|
nErrorResolution = RDC_DELETE;
|
|
}
|
|
else if (RDC_RESTORE_ALL == nErrorResolution)
|
|
{
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_DELETE_RESTORE;
|
|
nErrorResolution = RDC_RESTORE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SDS_SYNC_DELETE_DELETE:
|
|
nErrorResolution = RDC_DELETE;
|
|
break;
|
|
|
|
case SDS_SYNC_DELETE_RESTORE:
|
|
nErrorResolution = RDC_RESTORE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (nErrorResolution)
|
|
{
|
|
default:
|
|
case RDC_RESTORE:
|
|
Trace((TEXT("HandleDeleteConflict: restoring %s"), pszName));
|
|
// Tell CSCMergeShare to push the local copy to the server
|
|
dwResult = CSCPROC_RETURN_FORCE_OUTWARD;
|
|
break;
|
|
|
|
case RDC_DELETE:
|
|
Trace((TEXT("HandleDeleteConflict: deleting %s"), pszName));
|
|
if (bDirectory)
|
|
{
|
|
// Deep delete
|
|
CSCUIRemoveFolderFromCache(pszName, 0, ConflictPurgeCallback, (LPARAM)pSyncData);
|
|
}
|
|
else
|
|
{
|
|
if (ERROR_SUCCESS == CscDelete(pszName))
|
|
{
|
|
ShellChangeNotify(pszName, pFind32, TRUE, SHCNE_DELETE);
|
|
}
|
|
}
|
|
dwResult = CSCPROC_RETURN_SKIP;
|
|
break;
|
|
|
|
case RDC_CANCEL:
|
|
TraceMsg("HandleDeleteConflict: Cancelling sync - user bailed");
|
|
SetItemStatus(GUID_NULL, SYNCMGRSTATUS_STOPPED);
|
|
dwResult = CSCPROC_RETURN_ABORT;
|
|
break;
|
|
}
|
|
|
|
TraceLeaveResult(dwResult);
|
|
}
|
|
|
|
DWORD
|
|
CCscUpdate::CscCallback(PSYNCTHREADDATA pSyncData,
|
|
LPCTSTR pszName,
|
|
DWORD dwStatus,
|
|
DWORD dwHintFlags,
|
|
DWORD dwPinCount,
|
|
LPWIN32_FIND_DATA pFind32,
|
|
DWORD dwReason,
|
|
DWORD dwParam1,
|
|
DWORD dwParam2)
|
|
{
|
|
DWORD dwResult = CSCPROC_RETURN_CONTINUE;
|
|
SYNCMGRPROGRESSITEM spi = { sizeof(spi), 0 };
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::CscCallback");
|
|
TraceAssert(pSyncData != NULL);
|
|
TraceAssert(pSyncData->pThis == this);
|
|
|
|
// Check for Cancel
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
{
|
|
TraceMsg("Cancelling sync operation");
|
|
TraceLeaveValue(CSCPROC_RETURN_ABORT);
|
|
}
|
|
|
|
switch (dwReason)
|
|
{
|
|
case CSCPROC_REASON_BEGIN:
|
|
// First thing to do is determine if this is for the entire share
|
|
// or an individual file in the share.
|
|
if (!(pSyncData->dwSyncStatus & SDS_SYNC_STARTED))
|
|
{
|
|
// SHARE BEGIN
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_STARTED;
|
|
|
|
TraceAssert(!lstrcmpi(pszName, pSyncData->pszShareName));
|
|
Trace((TEXT("Share begin: %s"), pszName));
|
|
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_OUT)
|
|
{
|
|
// Save the drive letter to use for net operations
|
|
Trace((TEXT("Drive %s"), pFind32->cFileName));
|
|
StringCchCopy(pSyncData->szDrive, ARRAYSIZE(pSyncData->szDrive), pFind32->cFileName);
|
|
}
|
|
else
|
|
{
|
|
pSyncData->szDrive[0] = TEXT('\0');
|
|
}
|
|
|
|
// Remember whether it's an autocache share or not
|
|
switch (dwStatus & FLAG_CSC_SHARE_STATUS_CACHING_MASK)
|
|
{
|
|
case FLAG_CSC_SHARE_STATUS_AUTO_REINT:
|
|
case FLAG_CSC_SHARE_STATUS_VDO:
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_AUTOCACHE;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// FILE BEGIN
|
|
BOOL bSkipFile = FALSE;
|
|
|
|
TraceAssert(lstrlen(pszName) > lstrlen(pSyncData->pszShareName));
|
|
|
|
if (!(pFind32->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
// If we're updating a file selection and this file
|
|
// isn't part of the selection, skip it.
|
|
if (m_pFileList && !m_pFileList->FileExists(pszName, false))
|
|
{
|
|
bSkipFile = TRUE;
|
|
}
|
|
else if (!(pSyncData->dwSyncStatus & (SDS_SYNC_AUTOCACHE | SDS_SYNC_OUT)) &&
|
|
!(dwHintFlags & (FLAG_CSC_HINT_PIN_USER | FLAG_CSC_HINT_PIN_ADMIN)) &&
|
|
!IsSpecialFolder(pszName))
|
|
{
|
|
// Skip autocached files when filling on a
|
|
// non-autocache share. Raid #341786
|
|
bSkipFile = TRUE;
|
|
}
|
|
else if (!(pSyncData->dwSyncStatus & CSC_SYNC_IGNORE_ACCESS))
|
|
{
|
|
// dwReserved0 is the current user's access mask
|
|
// dwReserved1 is the Guest access mask
|
|
DWORD dwCurrentAccess = pFind32->dwReserved0 | pFind32->dwReserved1;
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_OUT)
|
|
{
|
|
//
|
|
// If the current user doesn't have sufficient access
|
|
// to merge offline changes, then don't bother trying.
|
|
// (It must be some other user's file.)
|
|
//
|
|
|
|
// Have the attributes changed offline?
|
|
if (FLAG_CSC_COPY_STATUS_ATTRIB_LOCALLY_MODIFIED & dwStatus)
|
|
{
|
|
// Yes. Continue if the current user has
|
|
// write-attribute access.
|
|
bSkipFile = !(dwCurrentAccess & FILE_WRITE_ATTRIBUTES);
|
|
}
|
|
|
|
// Have the contents changed offline?
|
|
if (!bSkipFile &&
|
|
((FLAG_CSC_COPY_STATUS_DATA_LOCALLY_MODIFIED
|
|
| FLAG_CSC_COPY_STATUS_LOCALLY_CREATED
|
|
| FLAG_CSC_COPY_STATUS_LOCALLY_DELETED) & dwStatus))
|
|
{
|
|
// Yes. Continue if the current user has
|
|
// write-data access.
|
|
bSkipFile = !(dwCurrentAccess & FILE_WRITE_DATA);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We're filling. Continue if the current user has
|
|
// read-data access, otherwise skip.
|
|
//
|
|
bSkipFile = !(dwCurrentAccess & FILE_READ_DATA);
|
|
}
|
|
}
|
|
}
|
|
else if (!(pSyncData->dwSyncStatus & SDS_SYNC_OUT))
|
|
{
|
|
// It's a directory and we're in CSCFillSparseFiles.
|
|
//
|
|
// Note that we never skip directories when merging (we may be
|
|
// interested in a file further down the tree) although we
|
|
// can skip directories when filling.
|
|
|
|
// If it's not in the file selection, skip it.
|
|
if (m_pFileList && !m_pFileList->FileExists(pszName, false))
|
|
{
|
|
bSkipFile = TRUE;
|
|
}
|
|
}
|
|
|
|
if (bSkipFile)
|
|
{
|
|
Trace((TEXT("Skipping: %s"), pszName));
|
|
dwResult = CSCPROC_RETURN_SKIP;
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_FILE_SKIPPED;
|
|
break;
|
|
}
|
|
|
|
Trace((TEXT("File begin: %s"), pszName));
|
|
|
|
//
|
|
// Since we sometimes don't skip directories, even when it turns
|
|
// out they have nothing that the current user is interested in,
|
|
// don't display directory names in SyncMgr.
|
|
//
|
|
// If we sync a file farther down the tree, we will display the
|
|
// filename and the intervening directory names will be visible
|
|
// at that time.
|
|
//
|
|
if (!(pFind32->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
// Tell SyncMgr what we're doing
|
|
spi.mask = SYNCMGRPROGRESSITEM_STATUSTEXT;
|
|
spi.lpcStatusText = pszName + lstrlen(pSyncData->pszShareName) + 1;
|
|
NotifySyncMgr(pSyncData, &spi);
|
|
}
|
|
|
|
// dwParam1 is non-zero when there is a conflict, i.e. both the
|
|
// local and remote versions of the file have been modified.
|
|
if (dwParam1)
|
|
{
|
|
if (dwParam2) // indicates server file deleted
|
|
{
|
|
Trace((TEXT("Delete conflict: %d"), dwParam2));
|
|
dwResult = HandleDeleteConflict(pSyncData, pszName, dwStatus, dwHintFlags, pFind32);
|
|
}
|
|
else
|
|
{
|
|
Trace((TEXT("Update conflict: %d"), dwParam1));
|
|
dwResult = HandleFileConflict(pSyncData, pszName, dwStatus, dwHintFlags, pFind32);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CSCPROC_REASON_END:
|
|
// dwParam2 == error code (winerror.h)
|
|
if (3000 <= dwParam2 && dwParam2 <= 3200)
|
|
{
|
|
// Private error codes used in cscdll
|
|
Trace((TEXT("CSC error: %d"), dwParam2));
|
|
dwParam2 = NOERROR;
|
|
}
|
|
else if (ERROR_OPERATION_ABORTED == dwParam2)
|
|
{
|
|
// We returned CSCPROC_RETURN_ABORT for some reason.
|
|
// Whatever it was, we already reported it.
|
|
dwParam2 = NOERROR;
|
|
dwResult = CSCPROC_RETURN_ABORT;
|
|
}
|
|
if (lstrlen(pszName) == lstrlen(pSyncData->pszShareName))
|
|
{
|
|
// SHARE END
|
|
TraceAssert(!lstrcmpi(pszName, pSyncData->pszShareName));
|
|
Trace((TEXT("Share end: %s"), pszName));
|
|
|
|
pSyncData->dwSyncStatus &= ~SDS_SYNC_STARTED;
|
|
}
|
|
else
|
|
{
|
|
BOOL bUpdateProgress = FALSE;
|
|
|
|
// FILE END
|
|
if (!(pSyncData->dwSyncStatus & SDS_SYNC_FILE_SKIPPED))
|
|
{
|
|
Trace((TEXT("File end: %s"), pszName));
|
|
|
|
bUpdateProgress = TRUE;
|
|
|
|
// Special case errors
|
|
switch (dwParam2)
|
|
{
|
|
case ERROR_ACCESS_DENIED:
|
|
if (FILE_ATTRIBUTE_DIRECTORY & pFind32->dwFileAttributes)
|
|
{
|
|
// 317751 directories are not per-user, so if a
|
|
// different user syncs, we can hit this. Don't want
|
|
// to show an error message unless we are ignoring
|
|
// access (when the user explicitly selected something
|
|
// to pin/sync).
|
|
//
|
|
// 394362 BrianV hit this running as an admin, so don't
|
|
// show this error for admins either.
|
|
//
|
|
if (!(pSyncData->dwSyncStatus & CSC_SYNC_IGNORE_ACCESS))
|
|
{
|
|
TraceMsg("Suppressing ERROR_ACCESS_DENIED on folder");
|
|
dwParam2 = NOERROR;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ERROR_GEN_FAILURE:
|
|
TraceMsg("Received ERROR_GEN_FAILURE from cscdll");
|
|
if (dwStatus & FLAG_CSC_COPY_STATUS_FILE_IN_USE)
|
|
dwParam2 = ERROR_OPEN_FILES;
|
|
break;
|
|
|
|
case ERROR_FILE_NOT_FOUND:
|
|
case ERROR_PATH_NOT_FOUND:
|
|
// We either handle the error here or the user is
|
|
// prompted, so no need for another error message.
|
|
dwParam2 = NOERROR;
|
|
// If this is an autocache file and has not been modified
|
|
// offline, nuke it now. Otherwise, prompt for action.
|
|
if (CSCPROC_RETURN_FORCE_OUTWARD == HandleDeleteConflict(pSyncData,
|
|
pszName,
|
|
dwStatus,
|
|
dwHintFlags,
|
|
pFind32))
|
|
{
|
|
dwParam2 = CopyLocalFileWithDriveMapping(pszName,
|
|
pszName,
|
|
pSyncData->pszShareName,
|
|
pSyncData->szDrive,
|
|
(FILE_ATTRIBUTE_DIRECTORY & pFind32->dwFileAttributes));
|
|
}
|
|
break;
|
|
|
|
case ERROR_DISK_FULL:
|
|
// There's no point continuing
|
|
dwResult = CSCPROC_RETURN_ABORT;
|
|
break;
|
|
|
|
default:
|
|
// nothing
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pSyncData->dwSyncStatus &= ~SDS_SYNC_FILE_SKIPPED;
|
|
dwParam2 = NOERROR;
|
|
|
|
// If doing full sync, then we count progress for skipped
|
|
// files as well. Not true for quick fill or merge.
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_IN_FULL)
|
|
bUpdateProgress = TRUE;
|
|
}
|
|
|
|
// Update progress in SyncMgr
|
|
if (bUpdateProgress)
|
|
{
|
|
pSyncData->cFilesDone++;
|
|
|
|
spi.mask = SYNCMGRPROGRESSITEM_PROGVALUE;
|
|
spi.iProgValue = min(pSyncData->cFilesDone, pSyncData->cFilesToSync - 1);
|
|
Trace((TEXT("%d of %d files done"), spi.iProgValue, pSyncData->cFilesToSync));
|
|
NotifySyncMgr(pSyncData, &spi);
|
|
}
|
|
}
|
|
if (dwParam2 != NOERROR)
|
|
{
|
|
UINT idsError = GetErrorFormat(dwParam2, boolify(pSyncData->dwSyncStatus & SDS_SYNC_OUT));
|
|
if (IDS_SHARE_CONNECT_ERROR == idsError)
|
|
{
|
|
LPTSTR pszErr = GetErrorText(dwParam2);
|
|
//
|
|
// Special-case the "can't connect to share" error.
|
|
// Display only the share name in the error message
|
|
// and abort the synchronization of this share.
|
|
//
|
|
LogError(pSyncData->ItemID,
|
|
SYNCMGRLOGLEVEL_ERROR,
|
|
idsError,
|
|
pSyncData->pszShareName,
|
|
pszErr ? pszErr : TEXT(""));
|
|
|
|
LocalFreeString(&pszErr);
|
|
dwResult = CSCPROC_RETURN_ABORT;
|
|
}
|
|
else
|
|
{
|
|
LogError(pSyncData->ItemID,
|
|
idsError,
|
|
pszName,
|
|
dwParam2);
|
|
}
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_ERROR;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Check for Cancel
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
{
|
|
TraceMsg("Cancelling sync operation");
|
|
dwResult = CSCPROC_RETURN_ABORT;
|
|
}
|
|
|
|
TraceLeaveValue(dwResult);
|
|
}
|
|
|
|
|
|
void
|
|
CCscUpdate::NotifySyncMgr(PSYNCTHREADDATA pSyncData, LPSYNCMGRPROGRESSITEM pspi)
|
|
{
|
|
LPSYNCMGRSYNCHRONIZECALLBACK pSyncMgr = pSyncData->pThis->m_pSyncMgrCB;
|
|
|
|
if (pSyncMgr)
|
|
{
|
|
HRESULT hr = pSyncMgr->Progress(pSyncData->ItemID, pspi);
|
|
|
|
if (hr == S_SYNCMGR_CANCELITEM || hr == S_SYNCMGR_CANCELALL)
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_CANCELLED;
|
|
}
|
|
}
|
|
|
|
|
|
DWORD WINAPI
|
|
CCscUpdate::_CscCallback(LPCTSTR pszName,
|
|
DWORD dwStatus,
|
|
DWORD dwHintFlags,
|
|
DWORD dwPinCount,
|
|
LPWIN32_FIND_DATA pFind32,
|
|
DWORD dwReason,
|
|
DWORD dwParam1,
|
|
DWORD dwParam2,
|
|
DWORD_PTR dwContext)
|
|
{
|
|
DWORD dwResult = CSCPROC_RETURN_ABORT;
|
|
PSYNCTHREADDATA pSyncData = (PSYNCTHREADDATA)dwContext;
|
|
|
|
if (pSyncData != NULL && pSyncData->pThis != NULL)
|
|
dwResult = pSyncData->pThis->CscCallback(pSyncData,
|
|
pszName,
|
|
dwStatus,
|
|
dwHintFlags,
|
|
dwPinCount,
|
|
pFind32,
|
|
dwReason,
|
|
dwParam1,
|
|
dwParam2);
|
|
return dwResult;
|
|
}
|
|
|
|
|
|
BOOL
|
|
CCscUpdate::PinLinkTarget(LPCTSTR pszName, PSYNCTHREADDATA pSyncData)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
LPTSTR pszTarget = NULL;
|
|
|
|
TraceEnter(TRACE_SHELLEX, "PinLinkTarget");
|
|
|
|
GetLinkTarget(pszName, &pszTarget);
|
|
if (pszTarget)
|
|
{
|
|
DWORD dwAttr = GetFileAttributes(pszTarget);
|
|
if ((DWORD)-1 == dwAttr)
|
|
ExitGracefully(bResult, FALSE, "Link target not found");
|
|
|
|
TraceAssert(!(dwAttr & FILE_ATTRIBUTE_DIRECTORY));
|
|
|
|
// Check for EFS
|
|
if ((FILE_ATTRIBUTE_ENCRYPTED & dwAttr) && SkipEFSPin(pSyncData, pszTarget))
|
|
ExitGracefully(bResult, FALSE, "Skipping EFS link target");
|
|
|
|
if (!(pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED))
|
|
{
|
|
HRESULT hr = m_NoPinList.IsPinAllowed(pszTarget);
|
|
if (S_OK == hr)
|
|
{
|
|
if (CSCPinFile(pszTarget, pSyncData->dwPinHints, NULL, NULL, NULL))
|
|
{
|
|
WIN32_FIND_DATA fd = {0};
|
|
fd.dwFileAttributes = dwAttr;
|
|
StringCchCopy(fd.cFileName, ARRAYSIZE(fd.cFileName), PathFindFileName(pszTarget));
|
|
|
|
ShellChangeNotify(pszTarget, &fd, FALSE);
|
|
|
|
bResult = TRUE;
|
|
|
|
if ((FILE_ATTRIBUTE_ENCRYPTED & dwAttr) && !m_bCacheIsEncrypted)
|
|
{
|
|
LogError(pSyncData->ItemID,
|
|
IDS_PIN_ENCRYPT_WARNING,
|
|
pszTarget,
|
|
NOERROR,
|
|
SYNCMGRLOGLEVEL_WARNING);
|
|
}
|
|
}
|
|
}
|
|
else if (S_FALSE == hr)
|
|
{
|
|
if (FILE_ATTRIBUTE_DIRECTORY & dwAttr)
|
|
{
|
|
LogError(pSyncData->ItemID,
|
|
SYNCMGRLOGLEVEL_WARNING,
|
|
IDS_PIN_NOPINFOLDER_POLICY_WARNING,
|
|
pszTarget);
|
|
}
|
|
else
|
|
{
|
|
LogError(pSyncData->ItemID,
|
|
IDS_PIN_NOPINFILE_POLICY_WARNING,
|
|
pszTarget,
|
|
NOERROR,
|
|
SYNCMGRLOGLEVEL_WARNING);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
exit_gracefully:
|
|
|
|
LocalFreeString(&pszTarget);
|
|
TraceLeaveValue(bResult);
|
|
}
|
|
|
|
|
|
BOOL
|
|
CCscUpdate::ShouldPinRecurse(LPCTSTR pszName)
|
|
{
|
|
//
|
|
// NTRAID#NTBUG9-508029-2001/12/18-jeffreys
|
|
//
|
|
// If CSC_SYNC_PIN_RECURSE is set, the answer is always TRUE. Otherwise,
|
|
// if we're not pinning files (typically running the FrankAr code), we
|
|
// automatically recurse on special folders.
|
|
//
|
|
return ((m_dwSyncFlags & CSC_SYNC_PIN_RECURSE) ||
|
|
(!(m_dwSyncFlags & CSC_SYNC_PINFILES) && !CConfig::GetSingleton().NoAdminPinSpecialFolders() && IsSpecialFolder(pszName)));
|
|
}
|
|
|
|
|
|
DWORD WINAPI
|
|
CCscUpdate::_PinNewFilesW32Callback(LPCTSTR pszName,
|
|
ENUM_REASON eReason,
|
|
LPWIN32_FIND_DATA pFind32,
|
|
LPARAM lpContext)
|
|
{
|
|
DWORD dwResult = CSCPROC_RETURN_CONTINUE;
|
|
PSYNCTHREADDATA pSyncData = (PSYNCTHREADDATA)lpContext;
|
|
DWORD dwHintFlags = 0;
|
|
DWORD dwErr = NOERROR;
|
|
LPTSTR pszConnectionName = NULL;
|
|
|
|
// This callback is used when enumerating a pinned folder looking
|
|
// for new files on the server. Since the parent folder is pinned,
|
|
// any files in it that aren't pinned get pinned here.
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::_PinNewFilesW32Callback");
|
|
TraceAssert(pSyncData != NULL);
|
|
|
|
// Check for Cancel
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
{
|
|
TraceMsg("Cancelling sync operation");
|
|
TraceLeaveValue(CSCPROC_RETURN_ABORT);
|
|
}
|
|
|
|
// Always ignore folder_end and ignore folder_begin if we
|
|
// aren't doing a recursive pin operation.
|
|
if (eReason == ENUM_REASON_FOLDER_END ||
|
|
(eReason == ENUM_REASON_FOLDER_BEGIN && !pSyncData->pThis->ShouldPinRecurse(pszName)))
|
|
{
|
|
TraceLeaveValue(CSCPROC_RETURN_SKIP);
|
|
}
|
|
|
|
if (eReason == ENUM_REASON_FOLDER_BEGIN)
|
|
{
|
|
DWORD dwShareStatus = 0;
|
|
|
|
// Folders may be DFS junctions, so make sure it's cacheable.
|
|
if (!ShareIsCacheable(pszName, FALSE, &pszConnectionName, &dwShareStatus))
|
|
{
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_SKIP, "Skipping no-cache folder");
|
|
}
|
|
}
|
|
|
|
if (S_FALSE == pSyncData->pThis->m_NoPinList.IsPinAllowed(pszName))
|
|
{
|
|
if (FILE_ATTRIBUTE_DIRECTORY & pFind32->dwFileAttributes)
|
|
{
|
|
pSyncData->pThis->LogError(pSyncData->ItemID,
|
|
SYNCMGRLOGLEVEL_WARNING,
|
|
IDS_PIN_NOPINFOLDER_POLICY_WARNING,
|
|
pszName);
|
|
}
|
|
else
|
|
{
|
|
pSyncData->pThis->LogError(pSyncData->ItemID,
|
|
IDS_PIN_NOPINFILE_POLICY_WARNING,
|
|
pszName,
|
|
NOERROR,
|
|
SYNCMGRLOGLEVEL_WARNING);
|
|
}
|
|
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_SKIP, "Skipping per no-pin policy");
|
|
}
|
|
|
|
// At this point, we either have 1) a file or 2) folder_begin + recurse,
|
|
// so pin anything that isn't pinned.
|
|
|
|
// Is this file already pinned?
|
|
if (!CSCQueryFileStatus(pszName, NULL, NULL, &dwHintFlags))
|
|
dwErr = GetLastError();
|
|
|
|
if (ERROR_FILE_NOT_FOUND == dwErr ||
|
|
(NOERROR == dwErr && !(dwHintFlags & (FLAG_CSC_HINT_PIN_USER | FLAG_CSC_HINT_PIN_ADMIN))))
|
|
{
|
|
// Check for EFS
|
|
BOOL bIsEFSFile = (FILE_ATTRIBUTE_ENCRYPTED & pFind32->dwFileAttributes) &&
|
|
!(FILE_ATTRIBUTE_DIRECTORY & pFind32->dwFileAttributes);
|
|
|
|
if (bIsEFSFile && pSyncData->pThis->SkipEFSPin(pSyncData, pszName))
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_SKIP, "Skipping EFS file");
|
|
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
ExitGracefully(dwResult, CSCPROC_RETURN_ABORT, "Sync cancelled");
|
|
|
|
// Pin it now.
|
|
if (CSCPinFile(pszName, pSyncData->dwPinHints, NULL, NULL, NULL))
|
|
{
|
|
|
|
pSyncData->cFilesToSync++;
|
|
ShellChangeNotify(pszName, pFind32, FALSE);
|
|
|
|
if (bIsEFSFile && !pSyncData->pThis->m_bCacheIsEncrypted)
|
|
{
|
|
pSyncData->pThis->LogError(pSyncData->ItemID,
|
|
IDS_PIN_ENCRYPT_WARNING,
|
|
pszName,
|
|
NOERROR,
|
|
SYNCMGRLOGLEVEL_WARNING);
|
|
}
|
|
|
|
// If this is a link file, pin the target (if appropriate)
|
|
LPTSTR pszExtn = PathFindExtension(pszName);
|
|
if (pszExtn && !lstrcmpi(pszExtn, c_szLNK))
|
|
{
|
|
if (pSyncData->pThis->PinLinkTarget(pszName, pSyncData))
|
|
pSyncData->cFilesToSync++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DWORD dwError = GetLastError();
|
|
UINT idsError = GetErrorFormat(dwError);
|
|
if (IDS_SHARE_CONNECT_ERROR == idsError)
|
|
{
|
|
LPTSTR pszErr = GetErrorText(dwError);
|
|
//
|
|
// Special-case the "can't connect to share" error.
|
|
// Display only the share name in the error message
|
|
// and abort the pinning of this share.
|
|
//
|
|
pSyncData->pThis->LogError(pSyncData->ItemID,
|
|
SYNCMGRLOGLEVEL_ERROR,
|
|
idsError,
|
|
pSyncData->pszShareName,
|
|
pszErr ? pszErr : TEXT(""));
|
|
|
|
LocalFreeString(&pszErr);
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_CANCELLED;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwSyncMgrLogLevel = SYNCMGRLOGLEVEL_ERROR;
|
|
if (ERROR_INVALID_NAME == dwError)
|
|
{
|
|
//
|
|
// File type is in the exclusion list.
|
|
// This is a warning, not an error.
|
|
//
|
|
dwSyncMgrLogLevel = SYNCMGRLOGLEVEL_WARNING;
|
|
}
|
|
pSyncData->pThis->LogError(pSyncData->ItemID,
|
|
IDS_PIN_FILE_ERROR,
|
|
pszName,
|
|
dwError,
|
|
dwSyncMgrLogLevel);
|
|
}
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_ERROR;
|
|
}
|
|
|
|
LPTSTR pszScanMsg = NULL;
|
|
SYNCMGRPROGRESSITEM spi;
|
|
spi.cbSize = sizeof(spi);
|
|
spi.mask = SYNCMGRPROGRESSITEM_STATUSTEXT;
|
|
spi.lpcStatusText = L" ";
|
|
|
|
// Skip the share name
|
|
TraceAssert(PathIsPrefix(pSyncData->pszShareName, pszName));
|
|
pszName += lstrlen(pSyncData->pszShareName);
|
|
if (*pszName == TEXT('\\'))
|
|
pszName++;
|
|
|
|
TCHAR szPath[MAX_PATH] = TEXT("\\");
|
|
_CopyParentPathForDisplay(szPath, ARRAYSIZE(szPath), pszName);
|
|
|
|
// If we still have a name, build a string like
|
|
// "scanning: dir\foo.txt" to display in SyncMgr
|
|
if (FormatStringID(&pszScanMsg, g_hInstance, IDS_NEW_SCAN, PathFindFileName(pszName), szPath))
|
|
{
|
|
spi.lpcStatusText = pszScanMsg;
|
|
}
|
|
|
|
NotifySyncMgr(pSyncData, &spi);
|
|
|
|
LocalFreeString(&pszScanMsg);
|
|
}
|
|
else if ((dwHintFlags & (FLAG_CSC_HINT_PIN_USER | FLAG_CSC_HINT_PIN_ADMIN)) &&
|
|
(pSyncData->pThis->m_dwSyncFlags & CSC_SYNC_PINFILES))
|
|
{
|
|
// FLAG_CSC_HINT_PIN_USER being set implies that CSCQueryFileStatus
|
|
// succeeded above.
|
|
|
|
// The item was already pinned. Save it in the undo exclusion list.
|
|
if (!pSyncData->pUndoExclusionList)
|
|
pSyncData->pUndoExclusionList = new CscFilenameList;
|
|
|
|
if (pSyncData->pUndoExclusionList)
|
|
pSyncData->pUndoExclusionList->AddFile(pszName);
|
|
}
|
|
|
|
exit_gracefully:
|
|
|
|
if (pszConnectionName)
|
|
{
|
|
WNetCancelConnection2(pszConnectionName, 0, FALSE);
|
|
LocalFreeString(&pszConnectionName);
|
|
}
|
|
|
|
TraceLeaveValue(dwResult);
|
|
}
|
|
|
|
|
|
DWORD WINAPI
|
|
CCscUpdate::_PinNewFilesCSCCallback(LPCTSTR pszName,
|
|
ENUM_REASON eReason,
|
|
DWORD /*dwStatus*/,
|
|
DWORD dwHintFlags,
|
|
DWORD /*dwPinCount*/,
|
|
LPWIN32_FIND_DATA /*pFind32*/,
|
|
LPARAM lpContext)
|
|
{
|
|
PSYNCTHREADDATA pSyncData = (PSYNCTHREADDATA)lpContext;
|
|
PCSCUPDATE pThis;
|
|
|
|
// This callback is used when enumerating the CSC database looking
|
|
// for pinned folders, with the intention of pinning new files
|
|
// in those folders on the server.
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::_PinNewFilesCSCCallback");
|
|
TraceAssert(pSyncData != NULL);
|
|
TraceAssert(pSyncData->pThis != NULL);
|
|
|
|
pThis = pSyncData->pThis;
|
|
|
|
// Check for Cancel
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
{
|
|
TraceMsg("Cancelling sync operation");
|
|
TraceLeaveValue(CSCPROC_RETURN_ABORT);
|
|
}
|
|
|
|
// If this isn't a directory with the user hint flag, keep looking.
|
|
if (eReason != ENUM_REASON_FOLDER_BEGIN ||
|
|
!(dwHintFlags & (FLAG_CSC_HINT_PIN_USER | FLAG_CSC_HINT_PIN_ADMIN)))
|
|
{
|
|
TraceLeaveValue(CSCPROC_RETURN_CONTINUE);
|
|
}
|
|
|
|
// If we have a file list and this directory isn't in the list,
|
|
// continue without doing anything here.
|
|
if (pSyncData->pThis->m_pFileList &&
|
|
!pSyncData->pThis->m_pFileList->FileExists(pszName, false))
|
|
{
|
|
TraceLeaveValue(CSCPROC_RETURN_CONTINUE);
|
|
}
|
|
|
|
// Ok, we've found a directory with the user hint flag set. Walk
|
|
// this directory on the server, pinning any files that aren't pinned.
|
|
pSyncData->dwPinHints = dwHintFlags;
|
|
_Win32EnumFolder(pszName,
|
|
FALSE,
|
|
_PinNewFilesW32Callback,
|
|
(LPARAM)pSyncData);
|
|
|
|
TraceLeaveValue(CSCPROC_RETURN_CONTINUE);
|
|
}
|
|
|
|
|
|
DWORD WINAPI
|
|
CCscUpdate::_SyncThread(LPVOID pThreadData)
|
|
{
|
|
PSYNCTHREADDATA pSyncData = (PSYNCTHREADDATA)pThreadData;
|
|
PCSCUPDATE pThis;
|
|
HRESULT hrComInit = E_FAIL;
|
|
SYNCMGRPROGRESSITEM spi = {0};
|
|
DWORD dwErr = NOERROR;
|
|
CSCSHARESTATS shareStats;
|
|
CSCGETSTATSINFO si = { SSEF_NONE,
|
|
SSUF_NONE,
|
|
false, // No access info reqd (faster).
|
|
false };
|
|
ULONG cDirtyFiles = 0;
|
|
ULONG cStaleFiles = 0;
|
|
DWORD dwShareStatus = 0;
|
|
BOOL bShareOnline = FALSE;
|
|
DWORD dwConnectionSpeed = 0;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::_SyncThread");
|
|
|
|
TraceAssert(pSyncData);
|
|
TraceAssert(pSyncData->pThis);
|
|
TraceAssert(pSyncData->pszShareName && *pSyncData->pszShareName);
|
|
|
|
pThis = pSyncData->pThis;
|
|
|
|
spi.cbSize = sizeof(spi);
|
|
|
|
hrComInit = CoInitialize(NULL);
|
|
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
ExitGracefully(dwErr, NOERROR, "Cancelling sync operation");
|
|
|
|
// Figure out how many files need updating
|
|
pSyncData->cFilesDone = 0;
|
|
pSyncData->cFilesToSync = 0;
|
|
_GetShareStatisticsForUser(pSyncData->pszShareName, &si, &shareStats);
|
|
|
|
// Get share status
|
|
CSCQueryFileStatus(pSyncData->pszShareName, &dwShareStatus, NULL, NULL);
|
|
|
|
// The root of a special folder is pinned with a pin count, but
|
|
// not the user-hint flag, so _GetShareStats doesn't count it.
|
|
// We need to count this for some of the checks below.
|
|
// (If the share is manual-cache, these look exactly like the
|
|
// Siemens scenario in 341786, but we want to sync them.)
|
|
if (shareStats.cTotal && pThis->IsSpecialFolderShare(pSyncData->pszShareName))
|
|
{
|
|
shareStats.cPinned++;
|
|
|
|
//
|
|
// At logoff, we want to run the FrankAr code on all
|
|
// 'special' folder shares.
|
|
// Customers expect folder redirection of special folders
|
|
// to ensure all contents are cached.
|
|
//
|
|
if (pThis->m_dwSyncFlags & CSC_SYNC_LOGOFF)
|
|
{
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_FORCE_INWARD;
|
|
}
|
|
}
|
|
|
|
if (pThis->m_dwSyncFlags & CSC_SYNC_OUT)
|
|
{
|
|
cDirtyFiles = shareStats.cModified;
|
|
|
|
//
|
|
// Force the merge code if there are open files, so we are
|
|
// sure to do the open file warning. The danger here is that we
|
|
// don't warn because the share with open files has nothing dirty,
|
|
// but we merge changes on another share and then transition online.
|
|
// We don't want to transition online without warning about open files.
|
|
//
|
|
if (0 == cDirtyFiles)
|
|
{
|
|
if ((FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & dwShareStatus) &&
|
|
(FLAG_CSC_SHARE_STATUS_FILES_OPEN & dwShareStatus))
|
|
{
|
|
cDirtyFiles++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pThis->m_dwSyncFlags & CSC_SYNC_IN_FULL)
|
|
{
|
|
// For full inward sync, always set cStaleFiles to at least 1 to force
|
|
// a call to CSCFillSparseFiles.
|
|
// Also, we get callbacks for each file and folder, even if they
|
|
// are not sparse or stale, so go with cTotal here to make
|
|
// the progress bar look right.
|
|
cStaleFiles = max(shareStats.cTotal, 1);
|
|
}
|
|
else if (pThis->m_dwSyncFlags & CSC_SYNC_IN_QUICK)
|
|
{
|
|
cStaleFiles = shareStats.cSparse;
|
|
|
|
// If we're pinning, then it's possible that nothing is sparse yet,
|
|
// but we'll need to call CSCFillSparseFiles.
|
|
if (pThis->m_dwSyncFlags & CSC_SYNC_PINFILES)
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_FORCE_INWARD;
|
|
}
|
|
|
|
if (dwShareStatus & FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP)
|
|
{
|
|
// Can't call CSCFillSparseFiles when disconnected (it just fails)
|
|
cStaleFiles = 0;
|
|
}
|
|
else if ((dwShareStatus & FLAG_CSC_SHARE_STATUS_CACHING_MASK) == FLAG_CSC_SHARE_STATUS_MANUAL_REINT
|
|
&& 0 == shareStats.cPinned
|
|
&& !(pThis->m_dwSyncFlags & CSC_SYNC_PINFILES))
|
|
{
|
|
// On a manual share, if nothing is pinned (and we aren't pinning)
|
|
// then we prefer not to call CSCFillSparseFiles on the share.
|
|
// Raid #341786
|
|
Trace((TEXT("Manual cache share '%s' has only autocached files"), pSyncData->pszShareName));
|
|
cStaleFiles = 0;
|
|
}
|
|
|
|
pSyncData->cFilesToSync = cDirtyFiles + cStaleFiles;
|
|
|
|
//
|
|
// At this point, if pSyncData->cFilesToSync is nonzero, then we are doing
|
|
// a sync, and will be calling CSCBeginSynchronization to connect to the
|
|
// share (with prompt for credentials if necessary).
|
|
//
|
|
// If SDS_SYNC_FORCE_INWARD is on, then we are pinning files. We will only
|
|
// call CSCFillSparseFiles is the server is in connected mode, and we will
|
|
// only call CSCBeginSynchronization if pSyncData->cFilesToSync is nonzero
|
|
// (to pin something, you must already have a connection to the share).
|
|
//
|
|
|
|
if (0 == pSyncData->cFilesToSync && !(pSyncData->dwSyncStatus & SDS_SYNC_FORCE_INWARD))
|
|
ExitGracefully(dwErr, NOERROR, "Nothing to synchronize");
|
|
|
|
// Tell SyncMgr how many files we're updating
|
|
spi.mask = SYNCMGRPROGRESSITEM_STATUSTYPE
|
|
| SYNCMGRPROGRESSITEM_PROGVALUE | SYNCMGRPROGRESSITEM_MAXVALUE;
|
|
spi.dwStatusType = SYNCMGRSTATUS_UPDATING;
|
|
spi.iProgValue = 0;
|
|
spi.iMaxValue = pSyncData->cFilesToSync;
|
|
Trace((TEXT("%d files to sync on %s"), spi.iMaxValue, pSyncData->pszShareName));
|
|
NotifySyncMgr(pSyncData, &spi);
|
|
|
|
if (pSyncData->cFilesToSync)
|
|
{
|
|
//
|
|
// CSCBeginSynchronization makes a net connection to the share
|
|
// using the "interactive" flag. This causes a credential popup
|
|
// if the current user doesn't have access to the share.
|
|
// Use the sync mutex to avoid multiple concurrent popups.
|
|
//
|
|
WaitForSingleObject(pThis->m_hSyncMutex, INFINITE);
|
|
bShareOnline = CSCBeginSynchronization(pSyncData->pszShareName,
|
|
&dwConnectionSpeed,
|
|
&pSyncData->dwCscContext);
|
|
ReleaseMutex(pThis->m_hSyncMutex);
|
|
}
|
|
|
|
if (pSyncData->cFilesToSync && !bShareOnline)
|
|
{
|
|
// The share isn't reachable, so there's no point in continuing.
|
|
dwErr = GetLastError();
|
|
|
|
if (ERROR_CANCELLED == dwErr)
|
|
{
|
|
// The user cancelled the credential popup
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_CANCELLED;
|
|
ExitGracefully(dwErr, NOERROR, "User cancelled sync");
|
|
}
|
|
|
|
LPTSTR pszErr = GetErrorText(dwErr);
|
|
pThis->LogError(pSyncData->ItemID,
|
|
SYNCMGRLOGLEVEL_ERROR,
|
|
IDS_SHARE_CONNECT_ERROR,
|
|
pSyncData->pszShareName,
|
|
pszErr);
|
|
LocalFreeString(&pszErr);
|
|
ExitGracefully(dwErr, dwErr, "Share not reachable");
|
|
}
|
|
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
ExitGracefully(dwErr, NOERROR, "Cancelling sync operation");
|
|
|
|
// Note the time of this sync
|
|
pThis->SetLastSyncTime(pSyncData->pszShareName);
|
|
|
|
// Merge
|
|
if (0 != cDirtyFiles)
|
|
{
|
|
dwErr = pThis->MergeShare(pSyncData);
|
|
if (NOERROR != dwErr)
|
|
{
|
|
LPTSTR pszErr = GetErrorText(dwErr);
|
|
pThis->LogError(pSyncData->ItemID,
|
|
SYNCMGRLOGLEVEL_ERROR,
|
|
IDS_MERGE_SHARE_ERROR,
|
|
pSyncData->pszShareName,
|
|
pszErr);
|
|
LocalFreeString(&pszErr);
|
|
ExitGracefully(dwErr, dwErr, "Aborting due to merge error");
|
|
}
|
|
}
|
|
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
ExitGracefully(dwErr, NOERROR, "Cancelling sync operation");
|
|
|
|
// Fill
|
|
if (0 != cStaleFiles || (pSyncData->dwSyncStatus & SDS_SYNC_FORCE_INWARD))
|
|
{
|
|
dwErr = pThis->FillShare(pSyncData, shareStats.cPinned, dwConnectionSpeed);
|
|
}
|
|
|
|
exit_gracefully:
|
|
|
|
// If we called CSCBeginSynchronization and it succeeded,
|
|
// we need to call CSCEndSynchronization.
|
|
if (bShareOnline)
|
|
CSCEndSynchronization(pSyncData->pszShareName, pSyncData->dwCscContext);
|
|
|
|
// Tell SyncMgr that we're done (succeeded, failed, or stopped)
|
|
spi.mask = SYNCMGRPROGRESSITEM_STATUSTYPE | SYNCMGRPROGRESSITEM_STATUSTEXT
|
|
| SYNCMGRPROGRESSITEM_PROGVALUE | SYNCMGRPROGRESSITEM_MAXVALUE;
|
|
spi.dwStatusType = SYNCMGRSTATUS_SUCCEEDED; // Assume success
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
spi.dwStatusType = SYNCMGRSTATUS_STOPPED;
|
|
if (NOERROR != dwErr || (pSyncData->dwSyncStatus & SDS_SYNC_ERROR))
|
|
spi.dwStatusType = SYNCMGRSTATUS_FAILED;
|
|
spi.lpcStatusText = L" ";
|
|
spi.iProgValue = spi.iMaxValue = pSyncData->cFilesToSync; // This tells syncmgr that the item is done
|
|
|
|
NotifySyncMgr(pSyncData, &spi);
|
|
|
|
if ((pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
&& (pThis->m_dwSyncFlags & CSC_SYNC_PINFILES))
|
|
{
|
|
// We cancelled a pin operation, roll back to the previous state
|
|
CscUnpinFileList(pThis->m_pFileList,
|
|
(pThis->m_dwSyncFlags & CSC_SYNC_PIN_RECURSE),
|
|
(FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & dwShareStatus),
|
|
pSyncData->pszShareName,
|
|
_UndoProgress,
|
|
(LPARAM)pSyncData);
|
|
}
|
|
|
|
// Tell the Update Handler that this thread is exiting
|
|
// This may use OLE to notify SyncMgr that the sync is done,
|
|
// so do this before CoUninitialize.
|
|
Trace((TEXT("%s finished"), pSyncData->pszShareName));
|
|
pThis->SyncThreadCompleted(pSyncData);
|
|
|
|
if (SUCCEEDED(hrComInit))
|
|
CoUninitialize();
|
|
|
|
delete pSyncData->pUndoExclusionList;
|
|
LocalFree(pSyncData);
|
|
|
|
// Release our ref on the object
|
|
// (also release our ref on the DLL)
|
|
pThis->Release();
|
|
|
|
TraceLeave();
|
|
FreeLibraryAndExitThread(g_hInstance, dwErr);
|
|
return 0;
|
|
}
|
|
|
|
DWORD
|
|
CCscUpdate::MergeShare(PSYNCTHREADDATA pSyncData)
|
|
{
|
|
DWORD dwErr = NOERROR;
|
|
BOOL bMergeResult = TRUE;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::MergeShare");
|
|
|
|
// CSCMergeShare fails if another thread (or process) is
|
|
// currently merging. This is because CSCMergeShare uses
|
|
// a drive letter connection to the share to bypass CSC,
|
|
// and we don't want to use up all of the drive letters.
|
|
// So let's protect the call to CSCMergeShare with a mutex
|
|
// (rather than dealing with failure and retrying, etc.)
|
|
|
|
WaitForSingleObject(m_hSyncMutex, INFINITE);
|
|
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
ExitGracefully(dwErr, NOERROR, "Merge cancelled");
|
|
|
|
//
|
|
// It would be nice to skip the open file warning if we knew
|
|
// that the open files were on a "silent folder". The best
|
|
// we can do, though, is detect that the open files are on
|
|
// the same share as a silent folder. There's no guarantee
|
|
// that the open files are not from a different folder on
|
|
// the same share, so we have to show the warning.
|
|
//
|
|
//if (!IsSilentShare(pSyncData->pszShareName))
|
|
{
|
|
DWORD dwShareStatus = 0;
|
|
CSCQueryFileStatus(pSyncData->pszShareName, &dwShareStatus, NULL, NULL);
|
|
if (FLAG_CSC_SHARE_STATUS_FILES_OPEN & dwShareStatus)
|
|
{
|
|
if (CSC_SYNC_MAYBOTHERUSER & m_dwSyncFlags)
|
|
{
|
|
// Only show this warning once per sync (not per thread)
|
|
if (!(CSC_SYNC_OFWARNINGDONE & m_dwSyncFlags))
|
|
{
|
|
m_dwSyncFlags |= CSC_SYNC_OFWARNINGDONE;
|
|
//
|
|
// This dialog we're going to display can use one of
|
|
// two templates.
|
|
//
|
|
// 1. Single user logged on. Tell user to close all files.
|
|
// Dialog provides [OK] and [Cancel] options. User can
|
|
// choose to continue or cancel.
|
|
//
|
|
// 2. Multiple users logged on. Tell user that sync cannot
|
|
// be performed with multiple users logged on. Dialog
|
|
// presents only an [OK] button. However, it's ID is
|
|
// IDCANCEL so pressing it will cause us to stop the
|
|
// merge.
|
|
//
|
|
if (IDOK != OpenFilesWarningDialog())
|
|
{
|
|
TraceMsg("Cancelling sync - user bailed at open file warning");
|
|
SetItemStatus(GUID_NULL, SYNCMGRSTATUS_STOPPED);
|
|
}
|
|
}
|
|
// else we already put up the warning on another thread. If the
|
|
// user cancelled, SDS_SYNC_CANCELLED will be set.
|
|
}
|
|
else
|
|
{
|
|
// Don't merge, but continue otherwise.
|
|
LogError(pSyncData->ItemID,
|
|
SYNCMGRLOGLEVEL_WARNING,
|
|
IDS_OPENFILE_MERGE_WARNING,
|
|
pSyncData->pszShareName);
|
|
ExitGracefully(dwErr, NOERROR, "Skipping merge due to open files");
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Conflict resolution may require stopping and restarting CSCMergeShare,
|
|
// so do this in a loop
|
|
//
|
|
while (!(pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED))
|
|
{
|
|
Trace((TEXT("Calling CSCMergeShare(%s)"), pSyncData->pszShareName));
|
|
|
|
pSyncData->dwSyncStatus = SDS_SYNC_OUT;
|
|
bMergeResult = CSCMergeShare(pSyncData->pszShareName,
|
|
CCscUpdate::_CscCallback,
|
|
(DWORD_PTR)pSyncData);
|
|
|
|
Trace((TEXT("CSCMergeShare(%s) returned"), pSyncData->pszShareName));
|
|
|
|
// Do we need to merge again?
|
|
if (!(SDS_SYNC_RESTART_MERGE & pSyncData->dwSyncStatus))
|
|
break;
|
|
}
|
|
|
|
if (!(pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED) && !bMergeResult)
|
|
{
|
|
dwErr = GetLastError();
|
|
if (ERROR_OPERATION_ABORTED == dwErr)
|
|
dwErr = NOERROR;
|
|
}
|
|
|
|
exit_gracefully:
|
|
|
|
ReleaseMutex(m_hSyncMutex);
|
|
|
|
TraceLeaveValue(dwErr);
|
|
}
|
|
|
|
DWORD
|
|
CCscUpdate::FillShare(PSYNCTHREADDATA pSyncData, int cPinned, DWORD dwConnectionSpeed)
|
|
{
|
|
DWORD dwErr = NOERROR;
|
|
DWORD dwShareStatus = 0;
|
|
DWORD dwShareHints = 0;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::FillShare");
|
|
|
|
CSCQueryFileStatus(pSyncData->pszShareName, &dwShareStatus, NULL, &dwShareHints);
|
|
|
|
//
|
|
// At logoff, we want to run the FrankAr code on all
|
|
// 'special' folder shares.
|
|
// Customers expect folder redirection of special folders
|
|
// to ensure all contents are cached.
|
|
//
|
|
if ((m_dwSyncFlags & CSC_SYNC_IN_FULL) ||
|
|
((m_dwSyncFlags & CSC_SYNC_LOGOFF) && IsSpecialFolderShare(pSyncData->pszShareName)))
|
|
{
|
|
pSyncData->dwSyncStatus = SDS_SYNC_IN_FULL;
|
|
|
|
Trace((TEXT("Full sync at %d00 bps"), dwConnectionSpeed));
|
|
|
|
//
|
|
// Check the server for new files that should be pinned.
|
|
//
|
|
// We can't do this when disconnected. Also, this is
|
|
// time consuming, so don't do it on a slow connection.
|
|
//
|
|
if (!(FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & dwShareStatus)
|
|
&& cPinned && !_PathIsSlow(dwConnectionSpeed))
|
|
{
|
|
//
|
|
// Look for pinned folders on this share by enumerating
|
|
// in the CSC database. Go out to the server only if/when
|
|
// we find a pinned folder.
|
|
//
|
|
TraceMsg("Running FrankAr code");
|
|
//
|
|
if (CConfig::GetSingleton().AlwaysPinSubFolders())
|
|
{
|
|
//
|
|
// If the "AlwaysPinSubFolders" policy is set, we
|
|
// do a recursive pin. This will cause any content
|
|
// (including folders) of a pinned folder to become pinned.
|
|
//
|
|
pSyncData->pThis->m_dwSyncFlags |= CSC_SYNC_PIN_RECURSE;
|
|
}
|
|
|
|
// First check the root folder
|
|
if (_PinNewFilesCSCCallback(pSyncData->pszShareName,
|
|
ENUM_REASON_FOLDER_BEGIN,
|
|
0,
|
|
dwShareHints,
|
|
0,
|
|
NULL,
|
|
(LPARAM)pSyncData) == CSCPROC_RETURN_CONTINUE)
|
|
{
|
|
_CSCEnumDatabase(pSyncData->pszShareName,
|
|
TRUE,
|
|
_PinNewFilesCSCCallback,
|
|
(LPARAM)pSyncData);
|
|
}
|
|
|
|
TraceMsg("FrankAr code complete");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pSyncData->dwSyncStatus = SDS_SYNC_IN_QUICK;
|
|
|
|
if (m_dwSyncFlags & CSC_SYNC_PINFILES)
|
|
{
|
|
//
|
|
// Enumerate the file list and pin everything, checking with
|
|
// SyncMgr periodically.
|
|
//
|
|
PinFiles(pSyncData);
|
|
}
|
|
}
|
|
|
|
if (m_pConflictPinList)
|
|
{
|
|
// Make sure that any files we created because of merge
|
|
// conflicts are pinned.
|
|
PinFiles(pSyncData, TRUE);
|
|
}
|
|
|
|
// Can't fill when disconnected
|
|
if (!(FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & dwShareStatus))
|
|
{
|
|
// Clear the status text and update the max count in case we
|
|
// pinned somthing above
|
|
SYNCMGRPROGRESSITEM spi;
|
|
spi.cbSize = sizeof(spi);
|
|
spi.mask = SYNCMGRPROGRESSITEM_STATUSTEXT | SYNCMGRPROGRESSITEM_MAXVALUE;
|
|
spi.lpcStatusText = L" ";
|
|
spi.iMaxValue = pSyncData->cFilesToSync;
|
|
Trace((TEXT("%d files to sync on %s"), spi.iMaxValue, pSyncData->pszShareName));
|
|
NotifySyncMgr(pSyncData, &spi);
|
|
|
|
if (!(pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED))
|
|
{
|
|
Trace((TEXT("Calling CSCFillSparseFiles(%s, %s)"), pSyncData->pszShareName, (pSyncData->dwSyncStatus & SDS_SYNC_IN_FULL) ? TEXT("full") : TEXT("quick")));
|
|
if (!CSCFillSparseFiles(pSyncData->pszShareName,
|
|
!!(pSyncData->dwSyncStatus & SDS_SYNC_IN_FULL),
|
|
CCscUpdate::_CscCallback,
|
|
(DWORD_PTR)pSyncData))
|
|
{
|
|
dwErr = GetLastError();
|
|
if (ERROR_OPERATION_ABORTED == dwErr)
|
|
dwErr = NOERROR;
|
|
}
|
|
Trace((TEXT("CSCFillSparseFiles(%s) complete"), pSyncData->pszShareName));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Trace((TEXT("Skipping CSCFillSparseFiles(%s) - server is offline"), pSyncData->pszShareName));
|
|
}
|
|
|
|
TraceLeaveValue(dwErr);
|
|
}
|
|
|
|
void
|
|
CCscUpdate::PinFiles(PSYNCTHREADDATA pSyncData, BOOL bConflictPinList)
|
|
{
|
|
CscFilenameList *pfnl;
|
|
CscFilenameList::HSHARE hShare;
|
|
LPCTSTR pszFile;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::PinFiles");
|
|
TraceAssert((m_dwSyncFlags & CSC_SYNC_PINFILES) || bConflictPinList);
|
|
|
|
pfnl = m_pFileList;
|
|
|
|
if (bConflictPinList)
|
|
{
|
|
pfnl = m_pConflictPinList;
|
|
}
|
|
|
|
if (!pfnl ||
|
|
!pfnl->GetShareHandle(pSyncData->pszShareName, &hShare))
|
|
{
|
|
TraceLeaveVoid();
|
|
}
|
|
|
|
CscFilenameList::FileIter fi = pfnl->CreateFileIterator(hShare);
|
|
|
|
// Iterate over the filenames associated with the share.
|
|
while (pszFile = fi.Next())
|
|
{
|
|
TCHAR szFullPath[MAX_PATH];
|
|
WIN32_FIND_DATA fd;
|
|
|
|
// Check for Cancel
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
break;
|
|
|
|
ZeroMemory(&fd, sizeof(fd));
|
|
|
|
// Build the full path
|
|
if (!PathCombine(szFullPath, pSyncData->pszShareName, pszFile))
|
|
continue;
|
|
|
|
// Directories have a trailing "\*"
|
|
if (StrChr(pszFile, TEXT('*')))
|
|
{
|
|
// It's a directory. Trim off the "\*"
|
|
PathRemoveFileSpec(szFullPath);
|
|
}
|
|
|
|
// Get attributes and test for existence
|
|
fd.dwFileAttributes = GetFileAttributes(szFullPath);
|
|
if ((DWORD)-1 == fd.dwFileAttributes)
|
|
continue;
|
|
|
|
if (S_FALSE == m_NoPinList.IsPinAllowed(szFullPath))
|
|
{
|
|
//
|
|
// Policy says don't pin this file/folder.
|
|
//
|
|
if (FILE_ATTRIBUTE_DIRECTORY & fd.dwFileAttributes)
|
|
{
|
|
LogError(pSyncData->ItemID,
|
|
SYNCMGRLOGLEVEL_WARNING,
|
|
IDS_PIN_NOPINFOLDER_POLICY_WARNING,
|
|
szFullPath);
|
|
}
|
|
else
|
|
{
|
|
LogError(pSyncData->ItemID,
|
|
IDS_PIN_NOPINFILE_POLICY_WARNING,
|
|
szFullPath,
|
|
NOERROR,
|
|
SYNCMGRLOGLEVEL_WARNING);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Check for EFS
|
|
BOOL bIsEFSFile;
|
|
bIsEFSFile = (FILE_ATTRIBUTE_ENCRYPTED & fd.dwFileAttributes) &&
|
|
!(FILE_ATTRIBUTE_DIRECTORY & fd.dwFileAttributes);
|
|
|
|
if (bIsEFSFile && SkipEFSPin(pSyncData, szFullPath))
|
|
continue;
|
|
|
|
if (pSyncData->dwSyncStatus & SDS_SYNC_CANCELLED)
|
|
break;
|
|
|
|
// Pin it
|
|
pSyncData->dwPinHints = FLAG_CSC_HINT_PIN_USER | FLAG_CSC_HINT_PIN_INHERIT_USER;
|
|
if (CSCPinFile(szFullPath, pSyncData->dwPinHints, NULL, NULL, NULL))
|
|
{
|
|
if (bConflictPinList && m_pFileList)
|
|
m_pFileList->AddFile(szFullPath, !!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY));
|
|
pSyncData->cFilesToSync++;
|
|
StringCchCopy(fd.cFileName, ARRAYSIZE(fd.cFileName), PathFindFileName(szFullPath));
|
|
ShellChangeNotify(szFullPath, &fd, FALSE);
|
|
if (bIsEFSFile && !m_bCacheIsEncrypted)
|
|
{
|
|
LogError(pSyncData->ItemID,
|
|
IDS_PIN_ENCRYPT_WARNING,
|
|
szFullPath,
|
|
NOERROR,
|
|
SYNCMGRLOGLEVEL_WARNING);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DWORD dwError = GetLastError();
|
|
UINT idsError = GetErrorFormat(dwError);
|
|
if (IDS_SHARE_CONNECT_ERROR == idsError)
|
|
{
|
|
LPTSTR pszErr = GetErrorText(dwError);
|
|
//
|
|
// Special-case the "can't connect to share" error.
|
|
// Display only the share name in the error message
|
|
// and abort the pinning of this share.
|
|
//
|
|
LogError(pSyncData->ItemID,
|
|
SYNCMGRLOGLEVEL_ERROR,
|
|
idsError,
|
|
pSyncData->pszShareName,
|
|
pszErr ? pszErr : TEXT(""));
|
|
|
|
LocalFreeString(&pszErr);
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_CANCELLED;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwSyncMgrLogLevel = SYNCMGRLOGLEVEL_ERROR;
|
|
if (ERROR_INVALID_NAME == dwError)
|
|
{
|
|
//
|
|
// File type is in the exclusion list.
|
|
// This is a warning, not an error.
|
|
//
|
|
dwSyncMgrLogLevel = SYNCMGRLOGLEVEL_WARNING;
|
|
}
|
|
LogError(pSyncData->ItemID,
|
|
IDS_PIN_FILE_ERROR,
|
|
szFullPath,
|
|
dwError,
|
|
dwSyncMgrLogLevel);
|
|
}
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_ERROR;
|
|
}
|
|
|
|
// If it's a directory, pin its contents
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
{
|
|
_Win32EnumFolder(szFullPath,
|
|
!bConflictPinList && ShouldPinRecurse(szFullPath),
|
|
CCscUpdate::_PinNewFilesW32Callback,
|
|
(LPARAM)pSyncData);
|
|
}
|
|
}
|
|
|
|
// Flush the shell notify queue
|
|
ShellChangeNotify(NULL, TRUE);
|
|
TraceLeaveVoid();
|
|
}
|
|
|
|
|
|
void
|
|
CCscUpdate::NotifyUndo(PSYNCTHREADDATA pSyncData, LPCTSTR pszName)
|
|
{
|
|
LPTSTR pszMsg;
|
|
SYNCMGRPROGRESSITEM spi;
|
|
spi.cbSize = sizeof(spi);
|
|
spi.mask = SYNCMGRPROGRESSITEM_STATUSTEXT;
|
|
|
|
spi.lpcStatusText = L" ";
|
|
|
|
// Skip the share name
|
|
if (PathIsPrefix(pSyncData->pszShareName, pszName))
|
|
{
|
|
pszName += lstrlen(pSyncData->pszShareName);
|
|
if (*pszName == TEXT('\\'))
|
|
pszName++;
|
|
}
|
|
|
|
TCHAR szPath[MAX_PATH] = TEXT("\\");
|
|
_CopyParentPathForDisplay(szPath, ARRAYSIZE(szPath), pszName);
|
|
|
|
// If we still have a name, build a string like
|
|
// "undo: dir\foo.txt" to display in SyncMgr
|
|
if (FormatStringID(&pszMsg, g_hInstance, IDS_UNDO_SCAN, PathFindFileName(pszName), szPath))
|
|
{
|
|
spi.lpcStatusText = pszMsg;
|
|
}
|
|
|
|
NotifySyncMgr(pSyncData, &spi);
|
|
|
|
LocalFreeString(&pszMsg);
|
|
}
|
|
|
|
|
|
DWORD WINAPI
|
|
CCscUpdate::_UndoProgress(LPCTSTR pszItem, LPARAM lpContext)
|
|
{
|
|
PSYNCTHREADDATA pSyncData = reinterpret_cast<PSYNCTHREADDATA>(lpContext);
|
|
|
|
if (pSyncData->pUndoExclusionList &&
|
|
pSyncData->pUndoExclusionList->FileExists(pszItem))
|
|
{
|
|
return CSCPROC_RETURN_SKIP;
|
|
}
|
|
|
|
// Update SyncMgr
|
|
pSyncData->pThis->NotifyUndo(pSyncData, pszItem);
|
|
|
|
return CSCPROC_RETURN_CONTINUE;
|
|
}
|
|
|
|
//
|
|
// The user's response to the "confirm pin encrypted" dialog is encoded
|
|
// to fit into the return value from EndDialog. The PINEFS_XXXXX macros
|
|
// describe this encoding.
|
|
//
|
|
// Bits 0 and 1 represent the user's [Yes][No][Cancel] choice.
|
|
//
|
|
#define PINEFS_YES 0x00000001
|
|
#define PINEFS_NO 0x00000002
|
|
#define PINEFS_CANCEL 0x00000003
|
|
#define PINEFS_YNC_MASK 0x00000003
|
|
//
|
|
// Bit 31 indicates if the user checked the "Apply to all" checkbox.
|
|
//
|
|
#define PINEFS_APPLYTOALL 0x80000000
|
|
//
|
|
// Convenience macros for indicating yes-to-all and no-to-all.
|
|
//
|
|
#define PINEFS_NO_TOALL (PINEFS_NO | PINEFS_APPLYTOALL)
|
|
#define PINEFS_YES_TOALL (PINEFS_YES | PINEFS_APPLYTOALL)
|
|
|
|
|
|
//
|
|
// Returns (by way of EndDialog) one of the PINEFS_XXXXXX codes.
|
|
//
|
|
// PINEFS_YES - Pin this file but ask again on the next.
|
|
// PINEFS_YES_TOALL - Pin this file and all encrypted files encountered.
|
|
// PINEFS_NO - Don't pin this file but ask again on the next.
|
|
// PINEFS_NO_TOALL - Don't pin this file nor any other encrypted files.
|
|
// PINEFS_CANCEL - Don't pin this file. Cancel entire operation.
|
|
//
|
|
INT_PTR CALLBACK
|
|
ConfirmEFSPinProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
INT_PTR nResult = 0;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
LPTSTR pszMsg = NULL;
|
|
LPCTSTR pszFile = PathFindFileName((LPCTSTR)lParam);
|
|
FormatStringID(&pszMsg, g_hInstance, IDS_FMT_PIN_EFS_MSG, pszFile);
|
|
if (pszMsg)
|
|
{
|
|
SetDlgItemText(hDlg, IDC_EFS_MSG, pszMsg);
|
|
LocalFree(pszMsg);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Let's be safe. On failure we won't pin an encrypted file
|
|
// to a non-encrypted cache.
|
|
//
|
|
EndDialog(hDlg, PINEFS_NO_TOALL);
|
|
}
|
|
}
|
|
nResult = TRUE;
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDYES:
|
|
EndDialog(hDlg, BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_PINEFS_APPLYTOALL) ? PINEFS_YES_TOALL : PINEFS_YES);
|
|
nResult = TRUE;
|
|
break;
|
|
|
|
case IDNO:
|
|
EndDialog(hDlg, BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_PINEFS_APPLYTOALL) ? PINEFS_NO_TOALL : PINEFS_NO);
|
|
nResult = TRUE;
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, PINEFS_CANCEL);
|
|
nResult = TRUE;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return nResult;
|
|
}
|
|
|
|
BOOL
|
|
CCscUpdate::SkipEFSPin(PSYNCTHREADDATA pSyncData, LPCTSTR pszItem)
|
|
{
|
|
BOOL bSkip = FALSE;
|
|
|
|
if (!m_bCacheIsEncrypted)
|
|
{
|
|
int iResult;
|
|
EnterCriticalSection(&m_csThreadList);
|
|
|
|
if ((CSC_SYNC_EFS_PIN_NONE & m_dwSyncFlags) ||
|
|
!(CSC_SYNC_MAYBOTHERUSER & m_dwSyncFlags))
|
|
{
|
|
iResult = PINEFS_NO;
|
|
}
|
|
else if (CSC_SYNC_EFS_PIN_ALL & m_dwSyncFlags)
|
|
{
|
|
iResult = PINEFS_YES;
|
|
}
|
|
else
|
|
{
|
|
// Suspend the other sync threads
|
|
SetSyncThreadStatus(SyncPause, pSyncData->ItemID);
|
|
|
|
iResult = (int)DialogBoxParam(g_hInstance,
|
|
MAKEINTRESOURCE(IDD_CONFIRM_PIN_EFS),
|
|
m_hwndDlgParent,
|
|
ConfirmEFSPinProc,
|
|
(LPARAM)pszItem);
|
|
|
|
if (PINEFS_APPLYTOALL & iResult)
|
|
{
|
|
//
|
|
// User checked the "apply to all" checkbox.
|
|
// Persist a [Yes][No] button selection.
|
|
//
|
|
if (PINEFS_NO == (PINEFS_YNC_MASK & iResult))
|
|
{
|
|
m_dwSyncFlags |= CSC_SYNC_EFS_PIN_NONE;
|
|
}
|
|
else if (PINEFS_YES == (PINEFS_YNC_MASK & iResult))
|
|
{
|
|
m_dwSyncFlags |= CSC_SYNC_EFS_PIN_ALL;
|
|
}
|
|
}
|
|
|
|
// Resume syncing
|
|
SetSyncThreadStatus(SyncResume, pSyncData->ItemID);
|
|
}
|
|
LeaveCriticalSection(&m_csThreadList);
|
|
|
|
switch (PINEFS_YNC_MASK & iResult)
|
|
{
|
|
default:
|
|
case PINEFS_NO:
|
|
bSkip = TRUE;
|
|
break;
|
|
|
|
case PINEFS_YES:
|
|
// continue
|
|
break;
|
|
|
|
case PINEFS_CANCEL:
|
|
// stop all threads
|
|
SetItemStatus(GUID_NULL, SYNCMGRSTATUS_STOPPED);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return bSkip;
|
|
}
|
|
|
|
HRESULT
|
|
CCscUpdate::SetSyncThreadStatus(eSetSyncStatus status, REFGUID rItemID)
|
|
{
|
|
// Assume success here. If we don't find the thread,
|
|
// it's probably already finished.
|
|
HRESULT hr = S_OK;
|
|
BOOL bOneItem;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CCscUpdate::SetSyncThreadStatus");
|
|
|
|
bOneItem = (SyncStop == status && !IsEqualGUID(rItemID, GUID_NULL));
|
|
|
|
EnterCriticalSection(&m_csThreadList);
|
|
|
|
if (NULL != m_hSyncThreads)
|
|
{
|
|
int cItems = DPA_GetPtrCount(m_hSyncThreads);
|
|
SYNCMGRPROGRESSITEM spi = {0};
|
|
DWORD (WINAPI *pfnStartStop)(HANDLE);
|
|
|
|
pfnStartStop = ResumeThread;
|
|
|
|
spi.cbSize = sizeof(spi);
|
|
spi.mask = SYNCMGRPROGRESSITEM_STATUSTYPE | SYNCMGRPROGRESSITEM_STATUSTEXT;
|
|
spi.lpcStatusText = L" ";
|
|
spi.dwStatusType = SYNCMGRSTATUS_UPDATING;
|
|
if (SyncPause == status)
|
|
{
|
|
spi.dwStatusType = SYNCMGRSTATUS_PAUSED;
|
|
pfnStartStop = SuspendThread;
|
|
}
|
|
|
|
while (cItems > 0)
|
|
{
|
|
PSYNCTHREADDATA pSyncData;
|
|
|
|
--cItems;
|
|
pSyncData = (PSYNCTHREADDATA)DPA_FastGetPtr(m_hSyncThreads, cItems);
|
|
TraceAssert(NULL != pSyncData);
|
|
|
|
if (SyncStop == status)
|
|
{
|
|
// Tell the thread to abort
|
|
if (!bOneItem || IsEqualGUID(rItemID, pSyncData->ItemID))
|
|
{
|
|
pSyncData->dwSyncStatus |= SDS_SYNC_CANCELLED;
|
|
if (bOneItem)
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Suspend or resume the thread if it's not the current thread
|
|
if (!IsEqualGUID(rItemID, pSyncData->ItemID))
|
|
(*pfnStartStop)(pSyncData->hThread);
|
|
m_pSyncMgrCB->Progress(pSyncData->ItemID, &spi);
|
|
}
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(&m_csThreadList);
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
CCscUpdate::GetSilentFolderList(void)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
delete m_pSilentFolderList;
|
|
m_pSilentFolderList = new CscFilenameList;
|
|
|
|
delete m_pSpecialFolderList;
|
|
m_pSpecialFolderList = new CscFilenameList;
|
|
|
|
if (NULL == m_pSilentFolderList || NULL == m_pSpecialFolderList)
|
|
{
|
|
delete m_pSilentFolderList;
|
|
m_pSilentFolderList = NULL;
|
|
delete m_pSpecialFolderList;
|
|
m_pSpecialFolderList = NULL;
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
BuildSilentFolderList(m_pSilentFolderList, m_pSpecialFolderList);
|
|
|
|
if (0 == m_pSilentFolderList->GetShareCount())
|
|
{
|
|
delete m_pSilentFolderList;
|
|
m_pSilentFolderList = NULL;
|
|
}
|
|
|
|
if (0 == m_pSpecialFolderList->GetShareCount())
|
|
{
|
|
delete m_pSpecialFolderList;
|
|
m_pSpecialFolderList = NULL;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
void
|
|
BuildSilentFolderList(CscFilenameList *pfnlSilentFolders,
|
|
CscFilenameList *pfnlSpecialFolders)
|
|
{
|
|
//
|
|
// We will silently handle sync conflicts in any of the folders
|
|
// below that have a '1' after them.
|
|
//
|
|
// If we get complaints about conflicts in folders that we
|
|
// think we can handle silently and safely, add them.
|
|
//
|
|
// Note that CSIDL_PERSONAL (MyDocs) and CSIDL_MYPICTURES
|
|
// should probably never be silent, since the user
|
|
// interacts with them directly.
|
|
//
|
|
// This list corresponds to the list of shell folders that may
|
|
// be redirected. See also
|
|
// HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
|
|
//
|
|
static const int s_csidlFolders[][2] =
|
|
{
|
|
{ CSIDL_PROGRAMS, 0 },
|
|
{ CSIDL_PERSONAL, 0 },
|
|
{ CSIDL_FAVORITES, 0 },
|
|
{ CSIDL_STARTUP, 0 },
|
|
{ CSIDL_RECENT, 1 },
|
|
{ CSIDL_SENDTO, 0 },
|
|
{ CSIDL_STARTMENU, 1 },
|
|
{ CSIDL_DESKTOPDIRECTORY, 0 },
|
|
{ CSIDL_NETHOOD, 0 },
|
|
{ CSIDL_TEMPLATES, 0 },
|
|
{ CSIDL_APPDATA, 1 },
|
|
{ CSIDL_PRINTHOOD, 0 },
|
|
{ CSIDL_MYPICTURES, 0 },
|
|
{ CSIDL_PROFILE, 1 },
|
|
{ CSIDL_ADMINTOOLS, 0 },
|
|
};
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
for (int i = 0; i < ARRAYSIZE(s_csidlFolders); i++)
|
|
{
|
|
if (SHGetSpecialFolderPath(NULL,
|
|
szPath,
|
|
s_csidlFolders[i][0] | CSIDL_FLAG_DONT_VERIFY,
|
|
FALSE))
|
|
{
|
|
// We only want UNC net paths
|
|
LPTSTR pszUNC = NULL;
|
|
GetRemotePath(szPath, &pszUNC);
|
|
if (!pszUNC)
|
|
continue;
|
|
|
|
if (s_csidlFolders[i][1])
|
|
{
|
|
if (pfnlSilentFolders)
|
|
pfnlSilentFolders->AddFile(pszUNC, true);
|
|
}
|
|
else
|
|
{
|
|
if (pfnlSpecialFolders)
|
|
pfnlSpecialFolders->AddFile(pszUNC, true);
|
|
}
|
|
|
|
LocalFreeString(&pszUNC);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// SyncMgr integration (ISyncMgrEnumItems) //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
CUpdateEnumerator::CUpdateEnumerator(PCSCUPDATE pUpdate)
|
|
: m_cRef(1),
|
|
m_pUpdate(pUpdate),
|
|
m_hFind(INVALID_HANDLE_VALUE),
|
|
m_bEnumFileSelection(FALSE),
|
|
m_cCheckedItemsEnumerated(0)
|
|
{
|
|
DllAddRef();
|
|
|
|
if (m_pUpdate)
|
|
{
|
|
m_pUpdate->AddRef();
|
|
|
|
if (m_pUpdate->m_pFileList)
|
|
{
|
|
m_bEnumFileSelection = TRUE;
|
|
m_SelectionIterator = m_pUpdate->m_pFileList->CreateShareIterator();
|
|
}
|
|
}
|
|
}
|
|
|
|
CUpdateEnumerator::~CUpdateEnumerator()
|
|
{
|
|
if (m_hFind != INVALID_HANDLE_VALUE)
|
|
CSCFindClose(m_hFind);
|
|
|
|
DoRelease(m_pUpdate);
|
|
DllRelease();
|
|
}
|
|
|
|
|
|
STDMETHODIMP CUpdateEnumerator::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] =
|
|
{
|
|
QITABENT(CUpdateEnumerator, ISyncMgrEnumItems),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CUpdateEnumerator::AddRef()
|
|
{
|
|
return InterlockedIncrement(&m_cRef);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CUpdateEnumerator::Release()
|
|
{
|
|
ASSERT( 0 != m_cRef );
|
|
ULONG cRef = InterlockedDecrement(&m_cRef);
|
|
if ( 0 == cRef )
|
|
{
|
|
delete this;
|
|
}
|
|
return cRef;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CUpdateEnumerator::Next(ULONG celt, LPSYNCMGRITEM rgelt, PULONG pceltFetched)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG cFetched = 0;
|
|
LPSYNCMGRITEM pItem = rgelt;
|
|
WIN32_FIND_DATA fd = {0};
|
|
DWORD dwShareStatus = 0;
|
|
DWORD dwSyncFlags;
|
|
CscFilenameList::HSHARE hShare;
|
|
LPCTSTR pszShareName = NULL;
|
|
|
|
TraceEnter(TRACE_UPDATE, "CUpdateEnumerator::Next");
|
|
TraceAssert(m_pUpdate != NULL);
|
|
|
|
if (NULL == rgelt)
|
|
TraceLeaveResult(E_INVALIDARG);
|
|
|
|
dwSyncFlags = m_pUpdate->m_dwSyncFlags;
|
|
|
|
while (cFetched < celt)
|
|
{
|
|
CSCEntry *pShareEntry;
|
|
CSCSHARESTATS shareStats;
|
|
CSCGETSTATSINFO si = { SSEF_NONE,
|
|
SSUF_TOTAL | SSUF_PINNED | SSUF_MODIFIED | SSUF_SPARSE | SSUF_DIRS,
|
|
false,
|
|
false };
|
|
|
|
if (m_bEnumFileSelection)
|
|
{
|
|
if (!m_SelectionIterator.Next(&hShare))
|
|
break;
|
|
|
|
pszShareName = m_pUpdate->m_pFileList->GetShareName(hShare);
|
|
|
|
CSCQueryFileStatus(pszShareName, &dwShareStatus, NULL, NULL);
|
|
fd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
|
|
StringCchCopy(fd.cFileName, ARRAYSIZE(fd.cFileName), pszShareName);
|
|
}
|
|
else
|
|
{
|
|
if (m_hFind == INVALID_HANDLE_VALUE)
|
|
{
|
|
m_hFind = CacheFindFirst(NULL, &fd, &dwShareStatus, NULL, NULL, NULL);
|
|
|
|
if (m_hFind == INVALID_HANDLE_VALUE)
|
|
{
|
|
// The database is empty, so there's nothing to enumerate..
|
|
break;
|
|
}
|
|
|
|
pszShareName = fd.cFileName;
|
|
}
|
|
else if (CacheFindNext(m_hFind, &fd, &dwShareStatus, NULL, NULL, NULL))
|
|
{
|
|
pszShareName = fd.cFileName;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
TraceAssert(pszShareName);
|
|
|
|
//
|
|
// This was proposed as a fix for part of 383011. However,
|
|
// that bug only applies in a multi-user scenario, and if there
|
|
// are more than 3 users using the machine, this would cause a
|
|
// user whose SID had been expelled from the CSC database to not
|
|
// be able to sync a share where they do indeed have access.
|
|
//
|
|
// // If the current user has no access to the share, don't enumerate it.
|
|
// if (!(CscAccessUser(dwShareStatus) || CscAccessGuest(dwShareStatus)))
|
|
// continue;
|
|
|
|
// Count the # of pinned files, sparse files, etc.
|
|
_GetShareStatisticsForUser(pszShareName, &si, &shareStats);
|
|
|
|
// The root of a special folder is pinned with a pin count, but
|
|
// not the user-hint flag, so _GetShareStats doesn't count it.
|
|
// We need to count this for some of the checks below.
|
|
// (If the share is manual-cache, these look exactly like the
|
|
// Siemens scenario in 341786, but we want to sync them.)
|
|
if (shareStats.cTotal && m_pUpdate->IsSpecialFolderShare(pszShareName))
|
|
{
|
|
shareStats.cPinned++;
|
|
if (dwSyncFlags & CSC_SYNC_LOGOFF)
|
|
{
|
|
//
|
|
// At logoff, we want to run the FrankAr code on all
|
|
// 'special' folder shares.
|
|
// Customers expect folder redirection of special folders
|
|
// to ensure all contents are cached.
|
|
//
|
|
dwSyncFlags |= CSC_SYNC_IN_FULL;
|
|
}
|
|
}
|
|
|
|
// If we're pinning, then even if nothing is sparse now,
|
|
// there will be sparse files after we pin them.
|
|
if (dwSyncFlags & CSC_SYNC_PINFILES)
|
|
{
|
|
shareStats.cSparse++;
|
|
shareStats.cTotal++;
|
|
}
|
|
|
|
// If there's nothing cached on this share, then don't even
|
|
// enumerate it to SyncMgr. This avoids listing extra junk
|
|
// in SyncMgr.
|
|
if ((0 == shareStats.cTotal) ||
|
|
(shareStats.cTotal == shareStats.cDirs && 0 == shareStats.cPinned))
|
|
{
|
|
// Either there is nothing cached for this share, or the only
|
|
// things found were unpinned dirs (no files, no pinned dirs).
|
|
// The second case can happen if you delete files from the viewer,
|
|
// in which case you think you deleted everything but the viewer
|
|
// doesn't show directories, so they weren't deleted.
|
|
Trace((TEXT("Nothing cached on %s, not enumerating"), pszShareName));
|
|
continue;
|
|
}
|
|
|
|
if ((dwShareStatus & FLAG_CSC_SHARE_STATUS_CACHING_MASK) == FLAG_CSC_SHARE_STATUS_NO_CACHING)
|
|
{
|
|
//
|
|
// Don't enumerate "no-cache" shares if there's nothing to merge.
|
|
//
|
|
// These can exist in the cache if the share was previously
|
|
// cacheable, but has since been changed to "no caching".
|
|
//
|
|
// If there's something to merge, we should still sync it to
|
|
// get everything squared away.
|
|
//
|
|
if (!((dwSyncFlags & CSC_SYNC_OUT) && (shareStats.cModified)))
|
|
{
|
|
Trace((TEXT("Not enumerating no-cache share %s"), pszShareName));
|
|
continue;
|
|
}
|
|
Trace((TEXT("Enumerating no-cache share %s with offline changes."), pszShareName));
|
|
}
|
|
|
|
// Explorer has shut down by the time we do a logoff sync. Hide the
|
|
// Properties button at logoff so we don't end up restarting Explorer.
|
|
pItem->dwFlags = (dwSyncFlags & CSC_SYNC_LOGOFF) ? 0 : SYNCMGRITEM_HASPROPERTIES;
|
|
|
|
if ((dwShareStatus & FLAG_CSC_SHARE_STATUS_CACHING_MASK) == FLAG_CSC_SHARE_STATUS_MANUAL_REINT
|
|
&& 0 == shareStats.cPinned
|
|
&& !(dwSyncFlags & CSC_SYNC_PINFILES))
|
|
{
|
|
// On a manual share, if nothing is pinned (and we aren't pinning)
|
|
// then we don't want to call CSCFillSparseFiles on the share.
|
|
// Raid #341786
|
|
Trace((TEXT("Manual cache share '%s' has only autocached files"), pszShareName));
|
|
|
|
// However, if there is something to merge, then we need to sync.
|
|
if (!((dwSyncFlags & CSC_SYNC_OUT) && shareStats.cModified))
|
|
{
|
|
Trace((TEXT("Not enumerating manual-cache share %s"), pszShareName));
|
|
continue;
|
|
}
|
|
|
|
// There is something to merge, so enumerate the share but
|
|
// tell SyncMgr that it's temporary so it doesn't save state
|
|
// for this share.
|
|
pItem->dwFlags |= SYNCMGRITEM_TEMPORARY;
|
|
}
|
|
|
|
//
|
|
// In some circumstances, we may want to merge even if there
|
|
// are no modified files, in order to show the open files warning.
|
|
//
|
|
// See comments in CCscUpdate::_SyncThread
|
|
//
|
|
if (0 == shareStats.cModified)
|
|
{
|
|
if ((FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & dwShareStatus) &&
|
|
(FLAG_CSC_SHARE_STATUS_FILES_OPEN & dwShareStatus))
|
|
{
|
|
shareStats.cModified++;
|
|
}
|
|
}
|
|
|
|
// Enumerate this share
|
|
cFetched++;
|
|
|
|
// Get existing share entry or create a new one
|
|
pShareEntry = m_pUpdate->m_ShareLog.Add(pszShareName);
|
|
if (!pShareEntry)
|
|
TraceLeaveResult(E_OUTOFMEMORY);
|
|
|
|
pItem->cbSize = sizeof(SYNCMGRITEM);
|
|
pItem->ItemID = pShareEntry->Guid();
|
|
pItem->hIcon = g_hCscIcon;
|
|
// SYNCMGRITEM_TEMPORARY causes items to not show up in
|
|
// SyncMgr's logon/logoff settings page. Raid #237288
|
|
//if (0 == shareStats.cPinned)
|
|
// pItem->dwFlags |= SYNCMGRITEM_TEMPORARY;
|
|
if (ERROR_SUCCESS == m_pUpdate->GetLastSyncTime(pszShareName, &pItem->ftLastUpdate))
|
|
pItem->dwFlags |= SYNCMGRITEM_LASTUPDATETIME;
|
|
|
|
//
|
|
// Determine whether this share needs syncing.
|
|
//
|
|
// At settings time, assume everything needs syncing (check everything)
|
|
//
|
|
// If outbound, shares with modified files are checked
|
|
// If inbound (full), shares with sparse or pinned files are checked
|
|
// If inbound (quick), shares with sparse files are checked
|
|
//
|
|
// Anything else doesn't need to be sync'ed at this time (unchecked)
|
|
//
|
|
pItem->dwItemState = SYNCMGRITEMSTATE_CHECKED;
|
|
if (!(dwSyncFlags & CSC_SYNC_SETTINGS) &&
|
|
!((dwSyncFlags & CSC_SYNC_OUT) && shareStats.cModified) &&
|
|
!((dwSyncFlags & CSC_SYNC_IN_FULL) && shareStats.cTotal ) &&
|
|
!((dwSyncFlags & CSC_SYNC_IN_QUICK) && shareStats.cSparse ))
|
|
{
|
|
pItem->dwItemState = SYNCMGRITEMSTATE_UNCHECKED;
|
|
}
|
|
|
|
// Get friendly share name here
|
|
LPITEMIDLIST pidl = NULL;
|
|
SHFILEINFO sfi = {0};
|
|
if (SUCCEEDED(SHSimpleIDListFromFindData(pszShareName, &fd, &pidl)))
|
|
{
|
|
SHGetFileInfo((LPCTSTR)pidl,
|
|
0,
|
|
&sfi,
|
|
sizeof(sfi),
|
|
SHGFI_PIDL | SHGFI_DISPLAYNAME);
|
|
SHFree(pidl);
|
|
}
|
|
if (TEXT('\0') != sfi.szDisplayName[0])
|
|
pszShareName = sfi.szDisplayName;
|
|
|
|
SHTCharToUnicode((LPTSTR)pszShareName, pItem->wszItemName, ARRAYSIZE(pItem->wszItemName));
|
|
if (SYNCMGRITEMSTATE_CHECKED == pItem->dwItemState)
|
|
{
|
|
m_cCheckedItemsEnumerated++;
|
|
Trace((TEXT("Enumerating %s, checked"), pszShareName));
|
|
}
|
|
else
|
|
{
|
|
Trace((TEXT("Enumerating %s, unchecked"), pszShareName));
|
|
}
|
|
|
|
pItem++;
|
|
}
|
|
|
|
|
|
if (pceltFetched)
|
|
*pceltFetched = cFetched;
|
|
|
|
if (cFetched != celt)
|
|
hr = S_FALSE;
|
|
|
|
if ((S_FALSE == hr) &&
|
|
0 == m_cCheckedItemsEnumerated &&
|
|
(CSC_SYNC_SHOWUI_ALWAYS & dwSyncFlags))
|
|
{
|
|
//
|
|
// Special-case where we're synching nothing but still
|
|
// want to display SyncMgr progress UI. We enumerate a
|
|
// special string rather than a share name for display in
|
|
// the status UI. Force hr == S_OK so the caller will accept
|
|
// this "dummy" item. Next() will be called once more but
|
|
// m_cCheckedItemsEnumerated will be 1 so this block won't be
|
|
// entered and we'll return S_FALSE indicating the end of the
|
|
// enumeration.
|
|
//
|
|
pItem->cbSize = sizeof(SYNCMGRITEM);
|
|
pItem->hIcon = g_hCscIcon;
|
|
pItem->dwFlags = 0;
|
|
pItem->dwItemState = SYNCMGRITEMSTATE_CHECKED;
|
|
pItem->ItemID = GUID_CscNullSyncItem;
|
|
|
|
UINT idString = IDS_NULLSYNC_ITEMNAME;
|
|
if ((CSC_SYNC_OUT & dwSyncFlags) &&
|
|
!((CSC_SYNC_IN_QUICK | CSC_SYNC_IN_FULL) & dwSyncFlags))
|
|
{
|
|
// Use different text if we are only merging
|
|
idString = IDS_NULLMERGE_ITEMNAME;
|
|
}
|
|
|
|
LoadStringW(g_hInstance,
|
|
idString,
|
|
pItem->wszItemName,
|
|
ARRAYSIZE(pItem->wszItemName));
|
|
m_cCheckedItemsEnumerated = 1;
|
|
|
|
TraceMsg("Enumerating NULL item");
|
|
hr = S_OK;
|
|
}
|
|
|
|
TraceLeaveResult(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CUpdateEnumerator::Skip(ULONG celt)
|
|
{
|
|
return Next(celt, NULL, NULL);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CUpdateEnumerator::Reset()
|
|
{
|
|
m_cCheckedItemsEnumerated = 0;
|
|
if (m_bEnumFileSelection)
|
|
{
|
|
m_SelectionIterator.Reset();
|
|
}
|
|
else if (m_hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
CSCFindClose(m_hFind);
|
|
m_hFind = INVALID_HANDLE_VALUE;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CUpdateEnumerator::Clone(LPSYNCMGRENUMITEMS *ppenum)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|