Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/windows/rover/filesync/syncui/ibrfstg.c

2359 lines
64 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
//---------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation 1993-1994
//
// File: ibrfstg.c
//
// This files contains the IBriefcaseStg interface.
//
// History:
// 02-02-94 ScottH Converted from iface.c
//
//---------------------------------------------------------------------------
#include "brfprv.h" // common headers
#undef LODWORD // (because they are redefined by configmg.h)
#undef HIDWORD
#include <brfcasep.h>
#include "recact.h"
#include "res.h"
#include <help.h>
#ifdef WINNT
// BUGBUG - BobDay - We need some mechanism of determining dock state
#else
// Needed for dock state determination
#define Not_VxD
#define No_CM_Calls
#include <vmm.h>
#include <configmg.h>
#endif
//---------------------------------------------------------------------------
// BriefStg Class
//---------------------------------------------------------------------------
// An IBriefcaseStg interface instance is created for each
// folder the caller (the Shell) binds to, where the folder
// is known to be inside a briefcase storage. A briefcase
// storage is the overall storage area (the database) that
// starts at a given folder (called the "briefcase root")
// and extends onwards and below in the file-system.
//
// Internally, the briefcase storage holds the path to the
// folder that this instance is bound to, and it holds a
// cached briefcase structure (CBS), which itself holds a
// reference to the briefcase root.
//
typedef struct _BriefStg
{
IBriefcaseStg bs;
UINT cRef; // reference count
CBS * pcbs; // cached briefcase info
TCHAR szFolder[MAX_PATH]; // canonical path
HBRFCASEITER hbrfcaseiter; // handle to iterate briefcases
DWORD dwFlags; // BSTG_* flags
} BriefStg, * PBRIEFSTG;
// Flags for BriefStg
#define BSTG_SYNCFOLDER 0x00000001 // This folder has a sync copy
//---------------------------------------------------------------------------
// Supporting private code
//---------------------------------------------------------------------------
#ifdef DEBUG
/*----------------------------------------------------------
Purpose: Dump all the cache tables
Returns: --
Cond: --
*/
void PUBLIC DumpTables()
{
Atom_DumpAll();
CBS_DumpAll();
CRL_DumpAll();
}
#endif
/*----------------------------------------------------------
Purpose: Initialize the cache tables
Returns: --
Cond: --
*/
BOOL PRIVATE InitCacheTables()
{
ASSERT(Sync_IsEngineLoaded());
DEBUG_CODE( TRACE_MSG(TF_GENERAL, TEXT("Initialize cache tables")); )
if (!CBS_Init())
goto Init_Fail;
if (!CRL_Init())
goto Init_Fail;
return TRUE;
Init_Fail:
CRL_Term();
CBS_Term(NULL);
return FALSE;
}
/*----------------------------------------------------------
Purpose: Terminate the cache tables
Returns: --
Cond: --
*/
void PUBLIC TermCacheTables(void)
{
ASSERT(Sync_IsEngineLoaded());
DEBUG_CODE( TRACE_MSG(TF_GENERAL, TEXT("Terminate cache tables")); )
CRL_Term();
CBS_Term(NULL);
}
/*----------------------------------------------------------
Purpose: Returns TRUE if the path (a folder) has a sync copy.
Returns: see above
Cond: --
*/
BOOL PRIVATE HasFolderSyncCopy(
HBRFCASE hbrf,
LPCTSTR pszPath)
{
ASSERT(pszPath);
ASSERT(PathIsDirectory(pszPath));
return (S_OK == Sync_IsTwin(hbrf, pszPath, SF_ISFOLDER) ||
IsSubfolderTwin(hbrf, pszPath));
}
/*----------------------------------------------------------
Purpose: Open a folder that belongs to a briefcase storage.
The pszPath parameter is a folder, which is not necessarily
the briefcase root.
Returns: NOERROR on success
Cond: --
*/
HRESULT PRIVATE OpenBriefcaseStorage(
LPCTSTR pszPath,
CBS ** ppcbs,
HWND hwndOwner)
{
HRESULT hres;
UINT uLocality;
int atomBrf;
TCHAR szBrfPath[MAX_PATH];
TCHAR szBrfCanon[MAX_PATH];
ASSERT(pszPath);
ASSERT(ppcbs);
DBG_ENTER_SZ(TEXT("OpenBriefcaseStorage"), pszPath);
DEBUG_CODE( DEBUG_BREAK(BF_ONOPEN); )
// Get the root folder of the briefcase storage
// Get strictly up to the briefcase portion of path
//
uLocality = PathGetLocality(pszPath, szBrfPath);
if (PL_FALSE == uLocality)
{
// The only time we get here is if the caller had a legitimate
// reason to believe this folder was a briefcase storage,
// but no database exists (yet). Just continue on as normal,
// the database will get created later.
PathCanonicalize(pszPath, szBrfCanon);
}
else
{
PathCanonicalize(szBrfPath, szBrfCanon);
}
// Add this path to the atom list and add it to the
// cached briefcase structure table.
// (Reference count decrement happens in CloseBriefcase)
//
atomBrf = Atom_Add(szBrfCanon);
if (atomBrf != ATOM_ERR)
{
hres = CBS_Add(ppcbs, atomBrf, hwndOwner);
}
else
{
*ppcbs = NULL;
hres = ResultFromScode(E_OUTOFMEMORY);
}
DEBUG_CODE( DumpTables(); )
DBG_EXIT_HRES(TEXT("OpenBriefcaseStorage"), hres);
return hres;
}
/*----------------------------------------------------------
Purpose: Close a briefcase.
Returns: NOERROR on success
Cond: --
*/
HRESULT PRIVATE CloseBriefcaseStorage(
LPCTSTR pszPath)
{
int atomBrf;
TCHAR szBrfPath[MAX_PATH];
TCHAR szBrfCanon[MAX_PATH];
UINT uLocality;
ASSERT(pszPath);
ASSERT(*pszPath); // Should not be an emptry string
DBG_ENTER_SZ(TEXT("CloseBriefcaseStorage"), pszPath);
DEBUG_CODE( DEBUG_BREAK(BF_ONCLOSE); )
DEBUG_CODE( DumpTables(); )
// Save the briefcase and remove it from the cache
//
// Get the root folder of the briefcase storage
// Get strictly up to the briefcase portion of path
//
uLocality = PathGetLocality(pszPath, szBrfPath);
if (PL_FALSE == uLocality)
{
// The only time we get here is for a briefcase storage that
// has no database yet. Just continue on as normal,
// the database will get created very soon now.
PathCanonicalize(pszPath, szBrfCanon);
}
else
{
PathCanonicalize(szBrfPath, szBrfCanon);
}
atomBrf = Atom_Find(szBrfCanon);
ASSERT(atomBrf != ATOM_ERR);
CBS_Delete(atomBrf, NULL);
Atom_Delete(atomBrf); // for the Add in OpenBriefcaseStorage
DBG_EXIT_HRES(TEXT("CloseBriefcaseStorage"), NOERROR);
return NOERROR;
}
// Confirm button flags
#define CBF_YES 0x0001
#define CBF_NO 0x0002
#define CBF_TOALL 0x0004
#define CBF_CANCEL 0x0008
/*----------------------------------------------------------
Purpose: Checks to see if the given file/folder already exists
in the given directory. Prompts the user to confirm
replacing if this is true.
Returns: TRUE if path exists
confirm flag settings
Cond: --
*/
BOOL PRIVATE DoesPathAlreadyExist(
CBS * pcbs,
LPCTSTR pszPathOld,
LPCTSTR pszPathNew,
LPUINT puConfirmFlags, // CBF_*
UINT uFlags, // SF_ISFOLDER or SF_ISFILE
HWND hwndOwner,
BOOL bMultiDrop)
{
BOOL bRet;
BOOL bIsTwin;
ASSERT(puConfirmFlags);
// Retain settings of *puConfirmFlags coming in
bIsTwin = (S_OK == Sync_IsTwin(pcbs->hbrf, pszPathOld, uFlags));
if (bIsTwin)
uFlags |= SF_ISTWIN;
else
uFlags |= SF_ISNOTTWIN;
bRet = (FALSE != PathExists(pszPathOld));
// Does the path already exist?
if (!bRet)
{
// No; remove it from the database if it is in there so we
// don't add duplicates.
Sync_Split(pcbs->hbrf, pszPathOld, 1, hwndOwner, uFlags | SF_QUIET | SF_NOCONFIRM);
}
else
{
// Yes; has a "to all" previously been specified by the user?
if (IsFlagSet(*puConfirmFlags, CBF_TOALL))
{
// Yes; keep flags as they are
// (CBF_YES and CBF_NO flags are mutually exclusive)
ASSERT(IsFlagSet(*puConfirmFlags, CBF_YES) &&
IsFlagClear(*puConfirmFlags, CBF_NO | CBF_CANCEL) ||
IsFlagSet(*puConfirmFlags, CBF_NO) &&
IsFlagClear(*puConfirmFlags, CBF_YES | CBF_CANCEL));
}
else
{
// No; prompt the user
UINT uFlagsCRF = bMultiDrop ? CRF_MULTI : CRF_DEFAULT;
int id = ConfirmReplace_DoModal(hwndOwner, pszPathOld, pszPathNew, uFlagsCRF);
*puConfirmFlags = 0;
if (GetKeyState(VK_SHIFT) < 0)
SetFlag(*puConfirmFlags, CBF_TOALL);
if (IDYES == id)
SetFlag(*puConfirmFlags, CBF_YES);
else if (IDNO == id)
SetFlag(*puConfirmFlags, CBF_NO);
else if (IDC_YESTOALL == id)
SetFlag(*puConfirmFlags, CBF_YES | CBF_TOALL);
else
{
ASSERT(IDCANCEL == id);
SetFlag(*puConfirmFlags, CBF_CANCEL);
}
}
// Has the user chosen to replace the file?
if (IsFlagSet(*puConfirmFlags, CBF_YES))
{
// Yes; is this an existing twin?
if (bIsTwin)
{
// Yes; delete it from the database before we continue
Sync_Split(pcbs->hbrf, pszPathOld, 1, hwndOwner, SF_QUIET | SF_NOCONFIRM);
}
// Some merge-handlers need the unwanted file to be deleted
// first because they cannot tell the difference between
// a newly added file (that is replacing an existing file)
// and a one-way merge.
if (!PathIsDirectory(pszPathOld))
DeleteFile(pszPathOld);
}
}
return bRet;
}
/*----------------------------------------------------------
Purpose: Add the folder twin to the database, using the default
*.* wildcard settings.
Returns: standard result
Cond: --
*/
HRESULT PRIVATE AddDefaultFolderTwin(
HWND hwndOwner,
HBRFCASE hbrf,
HDPA hdpa, // Return: twin handle in array
LPCTSTR pszPathFrom, // Source path
LPCTSTR pszPathTo) // Target path
{
HRESULT hres;
int iTwin;
// First make sure we can add another handle to hdpa (set to zero for now)
if (DPA_ERR == (iTwin = DPA_InsertPtr(hdpa, DPA_APPEND, (LPVOID)NULL)))
{
hres = E_OUTOFMEMORY;
}
else
{
NEWFOLDERTWIN nft;
TWINRESULT tr;
HFOLDERTWIN hft;
RETRY_BEGIN(FALSE)
{
ZeroInit(&nft, NEWFOLDERTWIN);
nft.ulSize = sizeof(nft);
nft.pcszFolder1 = pszPathFrom;
nft.pcszFolder2 = pszPathTo;
nft.pcszName = c_szAllFiles;
nft.dwAttributes = OBJECT_TWIN_ATTRIBUTES;
nft.dwFlags = NFT_FL_SUBTREE;
// Add the twin
tr = Sync_AddFolder(hbrf, &nft, &hft);
hres = HRESULT_FROM_TR(tr);
if (FAILED(hres))
{
DWORD dwError = GetLastError();
int id;
extern SETbl const c_rgseInfo[4];
// Unavailable disk?
if (ERROR_INVALID_DATA == dwError || ERROR_ACCESS_DENIED == dwError)
{
// Yes
hres = E_TR_UNAVAILABLE_VOLUME;
}
id = SEMsgBox(hwndOwner, IDS_CAP_INFO, hres, c_rgseInfo, ARRAYSIZE(c_rgseInfo));
if (IDRETRY == id)
{
// Try the operation again
RETRY_SET();
}
}
}
RETRY_END()
if (FAILED(hres))
{
DPA_DeletePtr(hdpa, iTwin);
}
else
{
// Success
ASSERT(DPA_ERR != iTwin);
ASSERT(NULL != hft);
DPA_SetPtr(hdpa, iTwin, (LPVOID)(DWORD)hft);
}
}
return hres;
}
/*----------------------------------------------------------
Purpose: Create a twin relationship between a folder and
another folder.
Returns: standard hresult
handles to created twins in hdpa
confirm flag settings
Cond: --
*/
HRESULT PRIVATE CreateTwinOfFolder(
CBS * pcbs,
LPTSTR pszPath, // Dragged folder path
LPCTSTR pszDir, // Location to place twin
HDPA hdpaTwin, // array of twin handles
UINT uFlags, // AOF_*
PUINT puConfirmFlags, // CBF_*
HWND hwndOwner,
BOOL bMultiDrop) // TRUE: more than 1 file/folder was dropped
{
HRESULT hres;
TCHAR szPathB[MAX_PATH];
LPTSTR pszFile;
ASSERT(pszPath);
ASSERT(pszDir);
pszFile = PathFindFileName(pszPath);
// Will the path name be too long?
if (PathsTooLong(pszDir, pszFile))
{
// Yes; bail
MsgBox(hwndOwner, MAKEINTRESOURCE(IDS_ERR_ADDFOLDER_TOOLONG),
MAKEINTRESOURCE(IDS_CAP_ADD), NULL, MB_ERROR, pszFile);
hres = E_FAIL;
}
// Did the user drag another briefcase root into this briefcase?
else if (PathIsBriefcase(pszPath))
{
// Yes; we don't allow nested briefcases! Tell the user.
MsgBox(hwndOwner, MAKEINTRESOURCE(IDS_ERR_CANTADDBRIEFCASE),
MAKEINTRESOURCE(IDS_CAP_ADD), NULL, MB_WARNING);
hres = E_FAIL;
}
else
{
// No; check for an existing folder in the target folder.
BOOL bExists;
PathCombine(szPathB, pszDir, pszFile);
bExists = DoesPathAlreadyExist(pcbs, szPathB, pszPath, puConfirmFlags, SF_ISFOLDER, hwndOwner, bMultiDrop);
if (!bExists || IsFlagSet(*puConfirmFlags, CBF_YES))
{
ASSERT(IsFlagClear(*puConfirmFlags, CBF_NO) &&
IsFlagClear(*puConfirmFlags, CBF_CANCEL));
// Show 'Add Folder' dialog?
if (IsFlagSet(uFlags, AOF_FILTERPROMPT))
{
// Yes
hres = Info_DoModal(hwndOwner, pszPath, szPathB, hdpaTwin,
pcbs);
}
else
{
// No; just default to *.*
hres = AddDefaultFolderTwin(hwndOwner, pcbs->hbrf, hdpaTwin,
pszPath, szPathB);
}
}
else if (IsFlagSet(*puConfirmFlags, CBF_NO))
{
// The user said NO
ASSERT(IsFlagClear(*puConfirmFlags, CBF_YES) &&
IsFlagClear(*puConfirmFlags, CBF_CANCEL));
hres = NOERROR;
}
else
{
ASSERT(IsFlagSet(*puConfirmFlags, CBF_CANCEL));
ASSERT(IsFlagClear(*puConfirmFlags, CBF_YES) &&
IsFlagClear(*puConfirmFlags, CBF_NO));
hres = E_ABORT;
}
}
return hres;
}
/*----------------------------------------------------------
Purpose: Create a twin of a file.
Returns: standard result
twin handle in hdpa
Cond: --
*/
HRESULT PRIVATE CreateTwinOfFile(
CBS * pcbs,
LPCTSTR pszPath, // ptr to path to twin
LPCTSTR pszTargetDir, // ptr to dest dir
HDPA hdpa, // Return: twin handle in array
UINT uFlags, // AOF_*
PUINT puConfirmFlags, // CBF_*
HWND hwndOwner,
BOOL bMultiDrop) // TRUE: more than 1 file/folder was dropped
{
HRESULT hres;
int iTwin;
TCHAR szPath[MAX_PATH];
LPCTSTR pszFile;
HTWINFAMILY htfam = NULL;
ASSERT(pszPath);
ASSERT(pszTargetDir);
pszFile = PathFindFileName(pszPath);
// Will the path name be too long?
if (PathsTooLong(pszTargetDir, pszFile))
{
// Yes; bail
MsgBox(hwndOwner, MAKEINTRESOURCE(IDS_ERR_ADDFILE_TOOLONG),
MAKEINTRESOURCE(IDS_CAP_ADD), NULL, MB_ERROR, pszFile);
iTwin = DPA_ERR;
hres = E_FAIL;
}
// First make sure we can add another handle to hdpa (set to zero for now)
else if (DPA_ERR == (iTwin = DPA_InsertPtr(hdpa, DPA_APPEND, (LPVOID)NULL)))
{
hres = E_OUTOFMEMORY;
}
else
{
BOOL bExists;
// Confirm the replace if a file with the same name already exists.
//
PathCombine(szPath, pszTargetDir, pszFile);
bExists = DoesPathAlreadyExist(pcbs, szPath, pszPath, puConfirmFlags, SF_ISFILE, hwndOwner, bMultiDrop);
if (!bExists ||
IsFlagSet(*puConfirmFlags, CBF_YES))
{
NEWOBJECTTWIN not;
TWINRESULT tr;
DECLAREHOURGLASS;
ASSERT(IsFlagClear(*puConfirmFlags, CBF_NO) &&
IsFlagClear(*puConfirmFlags, CBF_CANCEL));
lstrcpy(szPath, pszPath);
PathRemoveFileSpec(szPath);
// User has either opted to continue adding this object to the
// database, or it does not exist in the destination folder.
RETRY_BEGIN(FALSE)
{
ZeroInit(&not, NEWOBJECTTWIN);
not.ulSize = sizeof(NEWOBJECTTWIN);
not.pcszFolder1 = szPath;
not.pcszFolder2 = pszTargetDir;
not.pcszName = pszFile;
SetHourglass();
Sync_Dump(&not, NEWOBJECTTWIN);
tr = Sync_AddObject(pcbs->hbrf, &not, &htfam);
ResetHourglass();
hres = HRESULT_FROM_TR(tr);
if (FAILED(hres))
{
DWORD dwError = GetLastError();
// Unavailable disk?
if (ERROR_INVALID_DATA == dwError || ERROR_ACCESS_DENIED == dwError)
{
// Yes; ask user to retry/cancel
int id = MsgBox(hwndOwner, MAKEINTRESOURCE(IDS_ERR_ADDFILE_UNAVAIL_VOL),
MAKEINTRESOURCE(IDS_CAP_ADD), NULL, MB_RETRYCANCEL | MB_ICONWARNING);
// Set specific error value
hres = E_TR_UNAVAILABLE_VOLUME;
if (IDRETRY == id)
{
RETRY_SET(); // Try again
}
}
}
}
RETRY_END()
}
else if (IsFlagSet(*puConfirmFlags, CBF_NO))
{
// The user said NO
ASSERT(IsFlagClear(*puConfirmFlags, CBF_YES) &&
IsFlagClear(*puConfirmFlags, CBF_CANCEL));
DPA_DeletePtr(hdpa, iTwin);
hres = NOERROR;
}
else
{
ASSERT(IsFlagSet(*puConfirmFlags, CBF_CANCEL));
ASSERT(IsFlagClear(*puConfirmFlags, CBF_YES) &&
IsFlagClear(*puConfirmFlags, CBF_NO));
hres = E_ABORT;
}
}
if (FAILED(hres))
{
if (DPA_ERR != iTwin)
{
DPA_DeletePtr(hdpa, iTwin);
}
}
else
{
// Success
ASSERT(DPA_ERR != iTwin);
if (htfam)
DPA_SetPtr(hdpa, iTwin, (LPVOID)(DWORD)htfam);
}
return hres;
}
/*----------------------------------------------------------
Purpose: Deletes the new twins
Returns: --
Cond: --
*/
void PRIVATE DeleteNewTwins(
CBS * pcbs,
HDPA hdpa)
{
int iItem;
int cItems;
ASSERT(pcbs);
ASSERT(hdpa);
cItems = DPA_GetPtrCount(hdpa);
for (iItem = 0; iItem < cItems; iItem++)
{
HTWIN htwin = DPA_FastGetPtr(hdpa, iItem);
if (htwin)
Sync_DeleteTwin(htwin);
}
}
/*----------------------------------------------------------
Purpose: Releases the twin handles
Returns: --
Cond: --
*/
void PRIVATE ReleaseNewTwins(
HDPA hdpa)
{
int i;
int cItems;
ASSERT(hdpa);
cItems = DPA_GetPtrCount(hdpa);
for (i = 0; i < cItems; i++)
{
HTWIN htwin = DPA_FastGetPtr(hdpa, i);
if (htwin)
Sync_ReleaseTwin(htwin);
}
}
/*----------------------------------------------------------
Purpose: Returns the count of nodes that do not have FS_COND_UNAVAILABLE.
Returns: see above
Cond: --
*/
UINT PRIVATE CountAvailableNodes(
PRECITEM pri)
{
UINT ucNodes = 0;
PRECNODE prn;
for (prn = pri->prnFirst; prn; prn = prn->prnNext)
{
if (FS_COND_UNAVAILABLE != prn->fsCurrent.fscond)
{
ucNodes++;
}
}
return ucNodes;
}
/*----------------------------------------------------------
Purpose: Returns the count of nodes that require some sort of
action.
Returns: see above
Cond: --
*/
UINT PRIVATE CountActionItem(
PRECLIST prl)
{
UINT uc = 0;
PRECITEM pri;
for (pri = prl->priFirst; pri; pri = pri->priNext)
{
if (RIA_NOTHING != pri->riaction)
{
uc++;
}
}
return uc;
}
/*----------------------------------------------------------
Purpose: Update the twins in the list
Returns:
Cond: --
*/
HRESULT PRIVATE MassageReclist(
CBS * pcbs,
PRECLIST prl,
LPCTSTR pszInsideDir,
BOOL bCopyIn,
HWND hwndOwner)
{
HRESULT hres = NOERROR;
PRECITEM pri;
BOOL bWarnUser = TRUE;
PRECNODE prnInside;
PRECNODE prnOutside;
// Make sure the direction of the reconciliation coincides
// with the direction of the user's action.
for (pri = prl->priFirst; pri; pri = pri->priNext)
{
if (RIA_NOTHING != pri->riaction)
{
UINT cAvailableNodes = CountAvailableNodes(pri);
// Is this a wierd multi-edged case (not including
// Sneakernet)?
if (2 < cAvailableNodes)
{
// Should never get here, but better safe than sorry
ASSERT(0);
}
else
{
// No; get the pair of nodes that we just added to the
// database.
hres = Sync_GetNodePair(pri, Atom_GetName(pcbs->atomBrf),
pszInsideDir, &prnInside, &prnOutside);
if (SUCCEEDED(hres))
{
ASSERT(prnInside);
ASSERT(prnOutside);
if (bCopyIn)
{
switch (prnOutside->rnstate)
{
case RNS_UNAVAILABLE:
case RNS_DOES_NOT_EXIST:
case RNS_DELETED:
break; // leave alone
default:
// Force the update to be a copy into the briefcase.
pri->riaction = RIA_COPY;
prnInside->rnaction = RNA_COPY_TO_ME;
prnOutside->rnaction = RNA_COPY_FROM_ME;
TRACE_MSG(TF_GENERAL, TEXT("Massaging reclist"));
break;
}
}
else
{
switch (prnInside->rnstate)
{
case RNS_UNAVAILABLE:
case RNS_DOES_NOT_EXIST:
case RNS_DELETED:
break; // leave alone
default:
// Force the update to be a copy out of the briefcase.
pri->riaction = RIA_COPY;
prnInside->rnaction = RNA_COPY_FROM_ME;
prnOutside->rnaction = RNA_COPY_TO_ME;
TRACE_MSG(TF_GENERAL, TEXT("Massaging reclist"));
break;
}
}
}
else
break; // Error
}
}
}
return hres;
}
/*----------------------------------------------------------
Purpose: Check for more than 2 available nodes in each recitem.
Remove the associated twin if we find such a case,
to prevent multiple sync copies.
Returns: S_OK if everything looks ok
S_FALSE if there were multiple sync copies introduced
Cond: --
*/
HRESULT PRIVATE VerifyTwins(
CBS * pcbs,
PRECLIST prl,
LPCTSTR pszTargetDir,
HWND hwndOwner)
{
HRESULT hres = NOERROR;
PRECITEM pri;
BOOL bWarnUser = TRUE;
BOOL bWarnUserFolder = TRUE;
TCHAR szPath[MAX_PATH];
// Look thru the reclist and pick out recitems that have more than
// 2 recnodes that are currently available.
// Scenarios when this can happen:
//
// 1) Foo.txt --> BC
// Foo.txt --> BC\Orphan Folder
//
// Expected result: delete BC\Orphan Folder\Foo.txt twin
//
// 2) Foo.txt --> BC\Orphan Folder
// Orphan Folder --> BC
//
// Expected result: delete BC\Orphan Folder twin
//
// 3) Foo.txt --> BC\Orphan Folder
// Foo.txt --> BC
//
// Expected result: delete BC\Foo.txt twin
//
for (pri = prl->priFirst; pri; pri = pri->priNext)
{
UINT cAvailableNodes = CountAvailableNodes(pri);
PRECNODE prn;
// Are there more than 2 available nodes?
if (2 < cAvailableNodes && *pri->pcszName)
{
BOOL bLookForFolders = TRUE;
// FIRST: Look for object twins that are not in folder twins.
for (prn = pri->prnFirst; prn; prn = prn->prnNext)
{
// Is this file here because the file was dragged in?
if (IsSzEqual(pszTargetDir, prn->pcszFolder))
{
// Yes; warn the user
if (bWarnUser)
{
MsgBox(hwndOwner,
MAKEINTRESOURCE(IDS_ERR_ADDFILE_TOOMANY),
MAKEINTRESOURCE(IDS_CAP_ADD),
NULL, MB_WARNING, pri->pcszName);
if (0 > GetKeyState(VK_SHIFT))
{
bWarnUser = FALSE;
}
}
// Try to remove the object twin
PathCombine(szPath, prn->pcszFolder, pri->pcszName);
hres = Sync_Split(pcbs->hbrf, szPath, 1, hwndOwner,
SF_QUIET | SF_NOCONFIRM);
TRACE_MSG(TF_GENERAL, TEXT("Deleted object twin for %s"), szPath);
ASSERT(FAILED(hres) || S_OK == hres);
bLookForFolders = FALSE;
break;
}
}
if (bLookForFolders)
{
// SECOND: Look for object twins that exist because of folder
// twins.
for (prn = pri->prnFirst; prn; prn = prn->prnNext)
{
lstrcpy(szPath, prn->pcszFolder);
PathRemoveFileSpec(szPath);
// Is this file here because it is in a folder that was
// dragged in?
if (IsSzEqual(pszTargetDir, szPath))
{
// Yes; warn the user
if (bWarnUserFolder && bWarnUser)
{
MsgBox(hwndOwner,
MAKEINTRESOURCE(IDS_ERR_ADDFOLDER_TOOMANY),
MAKEINTRESOURCE(IDS_CAP_ADD),
NULL, MB_WARNING, PathFindFileName(prn->pcszFolder));
// Hack: to prevent showing this messagebox for
// every file in this folder, set this flag
bWarnUserFolder = FALSE;
if (0 > GetKeyState(VK_SHIFT))
{
bWarnUser = FALSE;
}
}
// Remove the folder twin
hres = Sync_Split(pcbs->hbrf, prn->pcszFolder, 1, hwndOwner,
SF_ISFOLDER | SF_QUIET | SF_NOCONFIRM);
TRACE_MSG(TF_GENERAL, TEXT("Deleted folder twin for %s"), prn->pcszFolder);
ASSERT(FAILED(hres) || !bWarnUserFolder || S_OK == hres);
break;
}
}
}
hres = S_FALSE;
}
}
return hres;
}
#define STATE_VERIFY 0
#define STATE_UPDATE 1
#define STATE_STOP 2
/*----------------------------------------------------------
Purpose: This function updates the new files. Unlike the general
update function, this strictly updates file pairs. All
other incidental nodes are set to RNA_NOTHING.
In addition, to be safe, we force the update to always
perform a copy into the briefcase.
This function releases the twin handles when it is finished.
Returns: standard result
Cond: --
*/
HRESULT PRIVATE UpdateNewTwins(
CBS * pcbs,
LPCTSTR pszInsideDir,
LPCTSTR pszTargetDir,
BOOL bCopyIn,
HDPA hdpa,
HWND hwndOwner)
{
HRESULT hres = E_FAIL;
int iItem;
int cItems;
ASSERT(pcbs);
ASSERT(hdpa);
cItems = DPA_GetPtrCount(hdpa);
if (cItems > 0)
{
HTWINLIST htl;
PRECLIST prl;
TWINRESULT tr;
tr = Sync_CreateTwinList(pcbs->hbrf, &htl);
if (TR_SUCCESS != tr)
{
hres = HRESULT_FROM_TR(tr);
}
else
{
HWND hwndProgress;
UINT nState = STATE_VERIFY;
DEBUG_CODE( UINT nCount = 0; )
// State progression is simple:
// STATE_VERIFY --> STATE_UPDATE --> STATE_STOP
// Any questions?
hwndProgress = UpdBar_Show(hwndOwner, UB_CHECKING, DELAY_UPDBAR);
for (iItem = 0; iItem < cItems; iItem++)
{
HTWIN htwin = DPA_FastGetPtr(hdpa, iItem);
if (htwin)
Sync_AddToTwinList(htl, htwin);
}
do
{
ASSERT(STATE_VERIFY == nState || STATE_UPDATE == nState);
ASSERT(2 > nCount++); // Sanity check for infinite loop
// Create the reclist
hres = Sync_CreateRecListEx(htl, UpdBar_GetAbortEvt(hwndProgress), &prl);
DEBUG_CODE( Sync_DumpRecList(GET_TR(hres), prl, TEXT("Adding new twins")); )
if (SUCCEEDED(hres))
{
ASSERT(prl);
switch (nState)
{
case STATE_VERIFY:
hres = VerifyTwins(pcbs, prl, pszTargetDir, hwndOwner);
if (S_FALSE == hres)
nState = STATE_UPDATE;
else if (S_OK == hres)
goto Update;
else
nState = STATE_STOP;
break;
case STATE_UPDATE:
// After recreating the reclist, is there anything
// that needs updating?
if (0 < CountActionItems(prl))
{
// Yes
Update:
UpdBar_SetAvi(hwndProgress, UB_UPDATEAVI);
hres = MassageReclist(pcbs, prl, pszInsideDir, bCopyIn, hwndOwner);
if (SUCCEEDED(hres))
{
// Update these files
hres = Sync_ReconcileRecList(prl, Atom_GetName(pcbs->atomBrf),
hwndProgress, RF_ONADD);
}
}
nState = STATE_STOP;
break;
default:
ASSERT(0);
break;
}
Sync_DestroyRecList(prl);
}
} while (SUCCEEDED(hres) && STATE_UPDATE == nState);
Sync_DestroyTwinList(htl);
UpdBar_Kill(hwndProgress);
}
}
return hres;
}
#ifdef WINNT
// BUGBUG - BobDay - WinNT docking state determination code goes here.
#else
// This struct is used to carry stack data across address spaces
// for the configuration manager service call.
typedef struct tagCM_Get_Profile_Param {
CMAPI cmApi;
ULONG ulIndex;
PHWPROFILEINFO pHWProfileInfo;
ULONG ulFlags;
} CM_GET_PROFILE_PARAM;
#define HEAP_SHARED 0x04000000 /* put heap in shared memory */
#define CMHEAPSIZE 4096
/*----------------------------------------------------------
Purpose: Service call to get the profile info from the configuration
manager.
Returns: CONFIGRET
Cond: --
*/
CONFIGRET _cdecl CM_Get_Hardware_Profile_Info(
ULONG ulIndex,
PHWPROFILEINFO pHWProfileInfo,
ULONG ulFlags)
{
CONFIGRET crRetVal = CR_OUT_OF_MEMORY;
HANDLE hHeap;
// Allocate our shared heap. (This is expensive, but this function
// is rarely called.)
if (NULL != (hHeap = HeapCreate(HEAP_SHARED, 1, CMHEAPSIZE)))
{
DWORD dwRecipients = BSM_VXDS;
CM_GET_PROFILE_PARAM * pcm;
DWORD cbVarSize;
// Allocate CMAPI from our shared heap
cbVarSize = sizeof(*pHWProfileInfo);
pcm = (CM_GET_PROFILE_PARAM *)HeapAlloc(hHeap, HEAP_ZERO_MEMORY,
sizeof(CM_GET_PROFILE_PARAM) + cbVarSize);
if (NULL != pcm)
{
// Package the parameter list
pcm->cmApi.dwCMAPIRet = 0;
pcm->cmApi.dwCMAPIService = GetVxDServiceOrdinal(_CONFIGMG_Get_Hardware_Profile_Info);
pcm->cmApi.pCMAPIStack = (DWORD)(((LPBYTE)pcm) + sizeof(pcm->cmApi));
pcm->ulIndex = ulIndex;
pcm->pHWProfileInfo = (PHWPROFILEINFO)(pcm+1);
pcm->ulFlags = ulFlags;
// Do the job!
BroadcastSystemMessage(0, &dwRecipients, WM_DEVICECHANGE, 0x22, (LPARAM)pcm);
// Return values
crRetVal = (CONFIGRET)pcm->cmApi.dwCMAPIRet;
*pHWProfileInfo = *(pcm->pHWProfileInfo);
HeapFree(hHeap, 0, pcm);
}
HeapDestroy(hHeap);
}
return crRetVal;
}
#endif
/*----------------------------------------------------------
Purpose: Return TRUE if the machine is docked
Returns: See above.
Cond: --
*/
BOOL PRIVATE IsMachineDocked(void)
{
#ifdef WINNT
#ifndef BUGBUG_BOBDAY // On NT we don't know how to determine this yet.
return TRUE;
#endif
#else
HWPROFILEINFO hwprofileinfo;
BOOL bDocked;
if (CR_SUCCESS == CM_Get_Hardware_Profile_Info((ULONG)-1, &hwprofileinfo, 0))
{
bDocked = IsFlagSet(hwprofileinfo.HWPI_dwFlags, CM_HWPI_DOCKED);
}
else
{
// Error
bDocked = FALSE;
}
DEBUG_CODE( TRACE_MSG(TF_GENERAL, TEXT("Machine is %s"), bDocked ? (LPTSTR)TEXT("docked") : (LPTSTR)TEXT("not docked")); )
return bDocked;
#endif
}
//---------------------------------------------------------------------------
// IBriefcaseStg member functions
//---------------------------------------------------------------------------
/*----------------------------------------------------------
Purpose: IBriefcaseStg::Release
Returns: new reference count
Cond: --
*/
STDMETHODIMP_(UINT) BriefStg_Release(
LPBRIEFCASESTG pstg)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
DBG_ENTER(TEXT("BriefStg_Release"));
if (--this->cRef)
{
DBG_EXIT_UL(TEXT("BriefStg_Release"), this->cRef);
return this->cRef; // Return decremented reference count
}
if (this->pcbs)
{
// Release this briefcase storage instance
CloseBriefcaseStorage(this->szFolder);
}
if (this->hbrfcaseiter)
{
Sync_FindClose(this->hbrfcaseiter);
}
GFree(this);
ENTEREXCLUSIVE()
{
DecBriefSemaphore();
if (IsLastBriefSemaphore())
{
CommitIniFile();
DEBUG_CODE( DumpTables(); )
TermCacheTables();
}
}
LEAVEEXCLUSIVE()
DBG_EXIT_UL(TEXT("BriefStg_Release"), 0);
return 0;
}
/*----------------------------------------------------------
Purpose: IBriefcaseStg::AddRef
Returns: new reference count
Cond: --
*/
STDMETHODIMP_(UINT) BriefStg_AddRef(
LPBRIEFCASESTG pstg)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
UINT cRef;
DBG_ENTER(TEXT("BriefStg_AddRef"));
cRef = ++this->cRef;
DBG_EXIT_UL(TEXT("BriefStg_AddRef"), cRef);
return cRef;
}
/*----------------------------------------------------------
Purpose: IBriefcaseStg::QueryInterface
Returns: standard
Cond: --
*/
STDMETHODIMP BriefStg_QueryInterface(
LPBRIEFCASESTG pstg,
REFIID riid,
LPVOID * ppvOut)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
HRESULT hres;
DBG_ENTER_RIID(TEXT("BriefStg_QueryInterface"), riid);
if (IsEqualIID(riid, &IID_IUnknown) ||
IsEqualIID(riid, &IID_IBriefcaseStg))
{
// We use the bs field as our IUnknown as well
*ppvOut = &this->bs;
this->cRef++;
hres = NOERROR;
}
else
{
*ppvOut = NULL;
hres = ResultFromScode(E_NOINTERFACE);
}
DBG_EXIT_HRES(TEXT("BriefStg_QueryInterface"), hres);
return hres;
}
/*----------------------------------------------------------
Purpose: IBriefcaseStg::Initialize
Called to initialize a briefcase storage instance.
The pszFolder indicates the folder we are binding to,
which is in the briefcase storage (somewhere).
Returns: standard
Cond: --
*/
STDMETHODIMP BriefStg_Initialize(
LPBRIEFCASESTG pstg,
LPCTSTR pszPath,
HWND hwndOwner)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
HRESULT hres = ResultFromScode(E_FAIL);
DBG_ENTER_SZ(TEXT("BriefStg_Initialize"), pszPath);
ASSERT(pszPath);
// Only initialize once per interface instance
//
if (pszPath && NULL == this->pcbs)
{
BOOL bCancel = FALSE;
RETRY_BEGIN(FALSE)
{
// Unavailable disk?
if (!PathExists(pszPath))
{
// Yes; ask user to retry/cancel
int id = MsgBox(hwndOwner, MAKEINTRESOURCE(IDS_ERR_OPEN_UNAVAIL_VOL),
MAKEINTRESOURCE(IDS_CAP_OPEN), NULL, MB_RETRYCANCEL | MB_ICONWARNING);
if (IDRETRY == id)
RETRY_SET(); // Try again
else
bCancel = TRUE;
}
}
RETRY_END()
if (!bCancel)
{
PathCanonicalize(pszPath, this->szFolder);
if (PathExists(this->szFolder) && !PathIsDirectory(this->szFolder))
{
// (Store this as a path to a folder)
PathRemoveFileSpec(this->szFolder);
}
// Open the briefcase storage for this folder
//
hres = OpenBriefcaseStorage(this->szFolder, &this->pcbs, hwndOwner);
if (SUCCEEDED(hres))
{
// Is this folder a sync folder?
if (HasFolderSyncCopy(this->pcbs->hbrf, this->szFolder))
{
// Yes
SetFlag(this->dwFlags, BSTG_SYNCFOLDER);
}
else
{
// No (or error, in which case we default to no)
ClearFlag(this->dwFlags, BSTG_SYNCFOLDER);
}
}
// Run the wizard?
if (SUCCEEDED(hres) && IsFlagSet(this->pcbs->uFlags, CBSF_RUNWIZARD))
{
// Yes
RunDLLThread(hwndOwner, TEXT("SYNCUI.DLL,Briefcase_Intro"), SW_SHOW);
ClearFlag(this->pcbs->uFlags, CBSF_RUNWIZARD);
}
}
}
hres = MapToOfficialHresult(hres);
DBG_EXIT_HRES(TEXT("BriefStg_Initialize"), hres);
return hres;
}
/*----------------------------------------------------------
Purpose: Add an object or objects to the briefcase storage.
This function does the real work for BriefStg_AddObject.
Returns: standard result
NOERROR if the object(s) were added
S_FALSE if the object(s) should be handled by the caller
Cond: --
*/
HRESULT PRIVATE BriefStg_AddObjectPrivate(
LPBRIEFCASESTG pstg,
LPDATAOBJECT pdtobj,
LPCTSTR pszFolderEx, // optional (may be NULL)
UINT uFlags, // One of AOF_*
HWND hwndOwner)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
HRESULT hres;
LPTSTR pszList;
LPTSTR psz;
UINT i;
UINT cFiles;
TCHAR szCanon[MAX_PATH];
HDPA hdpa;
LPCTSTR pszTarget;
BOOL bMultiFiles;
#pragma data_seg(DATASEG_READONLY)
static SETbl const c_rgseAdd[] = {
{ E_OUTOFMEMORY, IDS_OOM_ADD, MB_ERROR },
{ E_TR_OUT_OF_MEMORY, IDS_OOM_ADD, MB_ERROR },
};
#pragma data_seg()
ASSERT(pdtobj);
// Verify that the folder of this briefcase storage is actually inside
// a briefcase. (szCanon is used as a dummy here.)
ASSERT( !PathExists(this->szFolder) || PL_FALSE != PathGetLocality(this->szFolder, szCanon) );
// Get list of files to add
hres = DataObj_QueryFileList(pdtobj, &pszList, &cFiles);
if (SUCCEEDED(hres))
{
// Grab the mutex to delay any further calculation in any
// Briefcase views' secondary threads until we're done
// processing here.
Delay_Own();
// Does the caller want to create sync copies of objects that are
// already in the briefcase to some other folder? (Sneakernet)
if (NULL != pszFolderEx)
{
// Yes
pszTarget = pszFolderEx;
}
else
{
// No
pszTarget = this->szFolder;
// Are the entities already in this briefcase?
//
// Based on the success return value of DataObj_QueryFileList,
// we can tell if the entities are already within a briefcase.
// Because of the nature of the shell, we assume the file
// list contains entities which all exist in the same folder,
// so we consider it an "all or nothing" sort of indicator.
// If the entities are indeed in a briefcase, we compare the
// roots of the source and destination briefcases, and BLOCK
// the addition if they are the same.
//
if (S_OK == hres)
{
// They are in *a* briefcase. Which one?
DataObj_QueryBriefPath(pdtobj, szCanon);
if (IsSzEqual(szCanon, Atom_GetName(this->pcbs->atomBrf)))
{
// This same one! Don't do anything.
// BUGBUG: display message box
hres = ResultFromScode(E_FAIL);
goto Error1;
}
}
}
bMultiFiles = (1 < cFiles);
// Create the temporary DPA list
if (NULL == (hdpa = DPA_Create(cFiles)))
{
hres = ResultFromScode(E_OUTOFMEMORY);
}
else
{
UINT uConfirmFlags = 0;
// Add all the objects to the briefcase storage
for (i = 0, psz = pszList; i < cFiles; i++)
{
// Get file/folder name that was dropped
PathCanonicalize(psz, szCanon);
if (PathIsDirectory(szCanon))
{
hres = CreateTwinOfFolder(this->pcbs, szCanon, pszTarget,
hdpa, uFlags, &uConfirmFlags,
hwndOwner, bMultiFiles);
}
else
{
hres = CreateTwinOfFile(this->pcbs, szCanon, pszTarget,
hdpa, uFlags, &uConfirmFlags,
hwndOwner, bMultiFiles);
}
if (FAILED(hres))
{
// An error occurred while attempting to add a twin
break;
}
DataObj_NextFile(psz); // Set psz to next file in list
}
if (FAILED(hres))
{
// Delete the twins that were added.
DeleteNewTwins(this->pcbs, hdpa);
}
else
{
// Update these new twins
hres = UpdateNewTwins(this->pcbs, this->szFolder, pszTarget, (NULL == pszFolderEx), hdpa, hwndOwner);
}
ReleaseNewTwins(hdpa);
DPA_Destroy(hdpa);
}
Error1:
DataObj_FreeList(pszList);
Delay_Release();
}
if (FAILED(hres))
{
SEMsgBox(hwndOwner, IDS_CAP_ADD, hres, c_rgseAdd, ARRAYSIZE(c_rgseAdd));
}
return hres;
}
/*----------------------------------------------------------
Purpose: IBriefcaseStg::AddObject
Add an object to the briefcase storage.
Returns: standard hresult
Cond: --
*/
STDMETHODIMP BriefStg_AddObject(
LPBRIEFCASESTG pstg,
LPDATAOBJECT pdtobj,
LPCTSTR pszFolderEx, // optional
UINT uFlags,
HWND hwndOwner)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
HRESULT hres = NOERROR;
LPCTSTR pszFolder;
UINT ids;
DEBUG_CODE( TCHAR szDbg[MAX_PATH]; )
DBG_ENTER_DTOBJ(TEXT("BriefStg_AddObject"), pdtobj, szDbg);
ASSERT(pdtobj);
ASSERT(this->pcbs);
// Is this sneakernet?
// Is this folder a sync folder?
if (pszFolderEx)
{
// Yes; is the source a sync folder already?
if (HasFolderSyncCopy(this->pcbs->hbrf, pszFolderEx))
{
// Yes; don't allow other sync copies into (or out of) it
ids = IDS_ERR_ADD_SYNCFOLDER;
pszFolder = PathFindFileName(pszFolderEx);
hres = E_FAIL;
}
// Is the source folder a sync folder already?
else if (IsFlagSet(this->dwFlags, BSTG_SYNCFOLDER))
{
// Yes; don't allow other sync copies into (or out of) it
ids = IDS_ERR_ADD_SYNCFOLDER_SRC;
pszFolder = PathFindFileName(this->szFolder);
hres = E_FAIL;
}
}
else if (IsFlagSet(this->dwFlags, BSTG_SYNCFOLDER))
{
// Yes; don't allow other sync copies into (or out of) it
ids = IDS_ERR_ADD_SYNCFOLDER;
pszFolder = PathFindFileName(this->szFolder);
hres = E_FAIL;
}
if (SUCCEEDED(hres))
{
hres = BriefStg_AddObjectPrivate(pstg, pdtobj, pszFolderEx, uFlags, hwndOwner);
}
else
{
MsgBox(hwndOwner,
MAKEINTRESOURCE(ids),
MAKEINTRESOURCE(IDS_CAP_ADD),
NULL,
MB_WARNING,
pszFolder);
}
DEBUG_CODE( DumpTables(); )
hres = MapToOfficialHresult(hres);
DBG_EXIT_HRES(TEXT("BriefStg_AddObject"), hres);
return hres;
}
/*----------------------------------------------------------
Purpose: Removes an object or objects from the briefcase storage.
Returns: standard hresult
Cond: --
*/
HRESULT PRIVATE ReleaseObject(
CBS * pcbs,
LPDATAOBJECT pdtobj,
HWND hwndOwner)
{
HRESULT hres;
LPTSTR pszList;
UINT cFiles;
ASSERT(pdtobj);
hres = DataObj_QueryFileList(pdtobj, &pszList, &cFiles);
if (SUCCEEDED(hres))
{
RETRY_BEGIN(FALSE)
{
hres = Sync_Split(pcbs->hbrf, pszList, cFiles, hwndOwner, 0);
// Unavailable disk?
if (E_TR_UNAVAILABLE_VOLUME == hres)
{
// Yes; ask user to retry/cancel
int id = MsgBox(hwndOwner, MAKEINTRESOURCE(IDS_ERR_UNAVAIL_VOL),
MAKEINTRESOURCE(IDS_CAP_Split), NULL, MB_RETRYCANCEL | MB_ICONWARNING);
if (IDRETRY == id)
RETRY_SET(); // Try again
}
}
RETRY_END()
DataObj_FreeList(pszList);
}
return hres;
}
/*----------------------------------------------------------
Purpose: IBriefcaseStg::ReleaseObject
Release an object from the briefcase storage.
Returns: standard hresult
Cond: --
*/
STDMETHODIMP BriefStg_ReleaseObject(
LPBRIEFCASESTG pstg,
LPDATAOBJECT pdtobj,
HWND hwndOwner)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
HRESULT hres;
DEBUG_CODE( TCHAR szDbg[MAX_PATH]; )
DBG_ENTER_DTOBJ(TEXT("BriefStg_ReleaseObject"), pdtobj, szDbg);
ASSERT(pdtobj);
ASSERT(this->pcbs);
hres = ReleaseObject(this->pcbs, pdtobj, hwndOwner);
DEBUG_CODE( DumpTables(); )
hres = MapToOfficialHresult(hres);
DBG_EXIT_HRES(TEXT("BriefStg_ReleaseObject"), hres);
return hres;
}
/*----------------------------------------------------------
Purpose: IBriefcaseStg::UpdateObject
Update an object in the briefcase storage.
Returns: standard hresult
Cond: --
*/
STDMETHODIMP BriefStg_UpdateObject(
LPBRIEFCASESTG pstg,
LPDATAOBJECT pdtobj,
HWND hwndOwner)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
HRESULT hres;
TCHAR szPath[MAX_PATH];
DEBUG_CODE( TCHAR szDbg[MAX_PATH]; )
DBG_ENTER_DTOBJ(TEXT("BriefStg_UpdateObject"), pdtobj, szDbg);
ASSERT(pdtobj);
ASSERT(this->pcbs);
// Determine whether this is an Update Selection or Update All.
hres = DataObj_QueryPath(pdtobj, szPath);
if (SUCCEEDED(hres))
{
// Is this a briefcase root?
if (PathIsBriefcase(szPath))
{
// Yes; do an Update All
hres = Upd_DoModal(hwndOwner, this->pcbs, NULL, 0, UF_ALL);
}
else
{
// No; do an Update Selection
LPTSTR pszList;
UINT cFiles;
hres = DataObj_QueryFileList(pdtobj, &pszList, &cFiles);
if (SUCCEEDED(hres))
{
hres = Upd_DoModal(hwndOwner, this->pcbs, pszList, cFiles, UF_SELECTION);
DataObj_FreeList(pszList);
}
}
}
DEBUG_CODE( DumpTables(); )
hres = MapToOfficialHresult(hres);
DBG_EXIT_HRES(TEXT("BriefStg_UpdateObject"), hres);
return hres;
}
/*----------------------------------------------------------
Purpose: Update a briefcase based on events
Returns: standard hresult
Cond: --
*/
HRESULT PRIVATE BriefStg_UpdateOnEvent(
LPBRIEFCASESTG pstg,
UINT uEvent,
HWND hwndOwner)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
HRESULT hres = NOERROR;
DBG_ENTER(TEXT("BriefStg_UpdateOnEvent"));
switch (uEvent)
{
case UOE_CONFIGCHANGED:
case UOE_QUERYCHANGECONFIG:
// Is the machine docked?
if (IsMachineDocked())
{
// Yes; does the user want to update?
TCHAR sz[MAX_PATH];
int ids = (UOE_CONFIGCHANGED == uEvent) ? IDS_MSG_UpdateOnDock : IDS_MSG_UpdateBeforeUndock;
LPCTSTR pszBrf = Atom_GetName(this->pcbs->atomBrf);
int id = MsgBox(hwndOwner,
MAKEINTRESOURCE(ids),
MAKEINTRESOURCE(IDS_CAP_UPDATE),
LoadIcon(g_hinst, MAKEINTRESOURCE(IDI_UPDATE_DOCK)),
MB_QUESTION,
PathGetDisplayName(pszBrf, sz));
if (IDYES == id)
{
// Yes; do an Update All
hres = Upd_DoModal(hwndOwner, this->pcbs, NULL, 0, UF_ALL);
}
}
break;
default:
hres = ResultFromScode(E_INVALIDARG);
break;
}
DEBUG_CODE( DumpTables(); )
hres = MapToOfficialHresult(hres);
DBG_EXIT_HRES(TEXT("BriefStg_UpdateOnEvent"), hres);
return hres;
}
/*----------------------------------------------------------
Purpose: IBriefcaseStg::Notify
Marks the path dirty in the briefcase storage cache.
(The path may not exist in the cache, in which case this
function does nothing.)
Returns: S_OK to force a refresh
S_FALSE to not force a refresh
Cond: --
*/
STDMETHODIMP BriefStg_Notify(
LPBRIEFCASESTG pstg,
LPCTSTR pszPath, // may be NULL
LONG lEvent, // one of NOE_ flags
UINT * puFlags, // returned NF_ flags
HWND hwndOwner)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
HRESULT hres = ResultFromScode(E_OUTOFMEMORY);
TCHAR szCanon[MAX_PATH];
int atom;
DBG_ENTER_SZ(TEXT("BriefStg_Notify"), pszPath);
ASSERT(this->pcbs);
ASSERT(puFlags);
DEBUG_CODE( TRACE_MSG(TF_GENERAL, TEXT("Received event %lx for %s"), lEvent, Dbg_SafeStr(pszPath)); )
*puFlags = 0;
// Dirty the entire cache?
if (NOE_DIRTYALL == lEvent)
{
// Yes
TRACE_MSG(TF_GENERAL, TEXT("Marking everything"));
CRL_DirtyAll(this->pcbs->atomBrf);
Sync_ClearBriefcaseCache(this->pcbs->hbrf);
hres = NOERROR;
}
else if (pszPath && 0 < lEvent)
{
// No
PathCanonicalize(pszPath, szCanon);
atom = Atom_Add(szCanon);
if (ATOM_ERR != atom)
{
int atomCab = Atom_Add(this->szFolder);
if (ATOM_ERR != atomCab)
{
// There are two actions we must determine: what gets marked dirty?
// and does this specific window get forcibly refreshed?
BOOL bRefresh;
BOOL bMarked;
bMarked = CRL_Dirty(atom, atomCab, lEvent, &bRefresh);
hres = NOERROR;
if (bMarked)
{
SetFlag(*puFlags, NF_ITEMMARKED);
}
if (bRefresh)
{
#if 0
SetFlag(*puFlags, NF_REDRAWWINDOW);
#endif
}
#ifdef DEBUG
if (bMarked && bRefresh)
{
TRACE_MSG(TF_GENERAL, TEXT("Marked and forcing refresh of window on %s"), (LPTSTR)this->szFolder);
}
else if (bMarked)
{
TRACE_MSG(TF_GENERAL, TEXT("Marked"));
}
#endif
Atom_Delete(atomCab);
}
Atom_Delete(atom);
}
}
DBG_EXIT_HRES(TEXT("BriefStg_Notify"), hres);
return hres;
}
/*----------------------------------------------------------
Purpose: Gets special info (status and origin) of a path.
Returns: --
Cond: --
*/
HRESULT PRIVATE BriefStg_GetSpecialInfoOf(
PBRIEFSTG this,
LPCTSTR pszName,
UINT uFlag,
LPTSTR pszBuf,
int cchBuf)
{
HRESULT hres = E_OUTOFMEMORY;
TCHAR szPath[MAX_PATH];
TCHAR szCanon[MAX_PATH];
int atom;
ASSERT(this);
ASSERT(pszName);
ASSERT(pszBuf);
ASSERT(this->pcbs);
*pszBuf = TEXT('\0');
// Would the path be too long if combined?
if (PathsTooLong(this->szFolder, pszName))
{
// Yes
hres = E_FAIL;
}
else
{
PathCombine(szPath, this->szFolder, pszName);
PathCanonicalize(szPath, szCanon);
atom = Atom_Add(szCanon);
if (ATOM_ERR != atom)
{
CRL * pcrl;
// The first CRL_Get call will get the reclist from the cache
// or get a fresh reclist if the dirty bit is set. If the cache
// item doesn't exist, add it. We add orphans to the cache too
// but they have no reclist.
// Does the cached item already exist?
hres = CRL_Get(atom, &pcrl);
if (FAILED(hres))
{
// No; add it
hres = CRL_Add(this->pcbs, atom);
if (SUCCEEDED(hres))
{
// Do another 'get' to offset the CRL_Delete at the end of
// this function. This will leave this new reclist in the
// cache upon exit. (We don't want to create a new reclist
// everytime this functin is called.) It will all get
// cleaned up when the CBS is freed.
//
hres = CRL_Get(atom, &pcrl);
}
}
ASSERT(FAILED(hres) || pcrl);
// Do we have a cache reclist entry to work with?
if (pcrl)
{
// Yes
if (GEI_ORIGIN == uFlag)
{
lstrcpyn(pszBuf, Atom_GetName(pcrl->atomOutside), cchBuf);
PathRemoveFileSpec(pszBuf);
}
else
{
ASSERT(GEI_STATUS == uFlag);
SzFromIDS(pcrl->idsStatus, pszBuf, cchBuf);
}
CRL_Delete(atom); // Decrement count
}
Atom_Delete(atom);
}
}
return hres;
}
/*----------------------------------------------------------
Purpose: IBriefcaseStg::GetExtraInfo
Returns: standard hresult
Cond: --
*/
STDMETHODIMP BriefStg_GetExtraInfo(
LPBRIEFCASESTG pstg,
LPCTSTR pszName,
UINT uInfo,
WPARAM wParam,
LPARAM lParam)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
HRESULT hres;
DBG_ENTER_SZ(TEXT("BriefStg_GetExtraInfo"), pszName);
ASSERT(this->pcbs);
switch (uInfo)
{
case GEI_ORIGIN:
case GEI_STATUS: {
LPTSTR pszBuf = (LPTSTR)lParam;
int cchBuf = wParam;
ASSERT(pszName);
ASSERT(pszBuf);
hres = BriefStg_GetSpecialInfoOf(this, pszName, uInfo, pszBuf, cchBuf);
}
break;
case GEI_DELAYHANDLE: {
HANDLE * phMutex = (HANDLE *)lParam;
ASSERT(phMutex);
*phMutex = g_hMutexDelay;
hres = NOERROR;
}
break;
case GEI_ROOT: {
LPTSTR pszBuf = (LPTSTR)lParam;
int cchBuf = wParam;
ASSERT(pszBuf);
lstrcpyn(pszBuf, Atom_GetName(this->pcbs->atomBrf), cchBuf);
#ifdef DEBUG
if (IsFlagSet(g_uDumpFlags, DF_PATHS))
{
TRACE_MSG(TF_ALWAYS, TEXT("Root is \"%s\""), pszBuf);
}
#endif
hres = NOERROR;
}
break;
case GEI_DATABASENAME: {
LPTSTR pszBuf = (LPTSTR)lParam;
int cchBuf = wParam;
LPCTSTR pszDBName;
ASSERT(pszBuf);
if (IsFlagSet(this->pcbs->uFlags, CBSF_LFNDRIVE))
pszDBName = g_szDBName;
else
pszDBName = g_szDBNameShort;
lstrcpyn(pszBuf, pszDBName, cchBuf);
hres = NOERROR;
}
break;
default:
hres = E_INVALIDARG;
break;
}
DBG_EXIT_HRES(TEXT("BriefStg_GetExtraInfo"), hres);
return hres;
}
/*----------------------------------------------------------
Purpose: IBriefcaseStg::FindFirst
Returns the location of the root of the first briefcase storage
in the system.
Returns: S_OK if a briefcase was found
S_FALSE to end enumeration
Cond: --
*/
STDMETHODIMP BriefStg_FindFirst(
LPBRIEFCASESTG pstg,
LPTSTR pszName,
int cchMaxName)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
HRESULT hres;
TWINRESULT tr;
BRFCASEINFO bcinfo;
DBG_ENTER(TEXT("BriefStg_FindFirst"));
ASSERT(pszName);
bcinfo.ulSize = sizeof(bcinfo);
tr = Sync_FindFirst(&this->hbrfcaseiter, &bcinfo);
switch (tr)
{
case TR_OUT_OF_MEMORY:
hres = ResultFromScode(E_OUTOFMEMORY);
break;
case TR_SUCCESS:
hres = ResultFromScode(S_OK);
lstrcpyn(pszName, bcinfo.rgchDatabasePath, cchMaxName);
break;
case TR_NO_MORE:
hres = ResultFromScode(S_FALSE);
break;
default:
hres = ResultFromScode(E_FAIL);
break;
}
DBG_EXIT_HRES(TEXT("BriefStg_FindFirst"), hres);
return hres;
}
/*----------------------------------------------------------
Purpose: IBriefcaseStg::FindNext
Returns the location of the root of the next briefcase storage
in the system.
Returns: S_OK if a briefcase was found
S_FALSE to end enumeration
Cond: --
*/
STDMETHODIMP BriefStg_FindNext(
LPBRIEFCASESTG pstg,
LPTSTR pszName,
int cchMaxName)
{
PBRIEFSTG this = IToClass(BriefStg, bs, pstg);
HRESULT hres;
TWINRESULT tr;
BRFCASEINFO bcinfo;
DBG_ENTER(TEXT("BriefStg_FindNext"));
ASSERT(pszName);
bcinfo.ulSize = sizeof(bcinfo);
tr = Sync_FindNext(this->hbrfcaseiter, &bcinfo);
switch (tr)
{
case TR_OUT_OF_MEMORY:
hres = ResultFromScode(E_OUTOFMEMORY);
break;
case TR_SUCCESS:
hres = ResultFromScode(S_OK);
lstrcpyn(pszName, bcinfo.rgchDatabasePath, cchMaxName);
break;
case TR_NO_MORE:
hres = ResultFromScode(S_FALSE);
break;
default:
hres = ResultFromScode(E_FAIL);
break;
}
DBG_EXIT_HRES(TEXT("BriefStg_FindNext"), hres);
return hres;
}
//---------------------------------------------------------------------------
// BriefStg class : Vtables
//---------------------------------------------------------------------------
#pragma data_seg(DATASEG_READONLY)
IBriefcaseStgVtbl c_BriefStg_BSVtbl =
{
BriefStg_QueryInterface,
BriefStg_AddRef,
BriefStg_Release,
BriefStg_Initialize,
BriefStg_AddObject,
BriefStg_ReleaseObject,
BriefStg_UpdateObject,
BriefStg_UpdateOnEvent,
BriefStg_GetExtraInfo,
BriefStg_Notify,
BriefStg_FindFirst,
BriefStg_FindNext,
};
#pragma data_seg()
/*----------------------------------------------------------
Purpose: This function is called back from within
IClassFactory::CreateInstance() of the default class
factory object, which is created by SHCreateClassObject.
Returns: standard
Cond: --
*/
HRESULT CALLBACK BriefStg_CreateInstance(
LPUNKNOWN punkOuter, // Should be NULL for us
REFIID riid,
LPVOID * ppvOut)
{
HRESULT hres = E_FAIL;
PBRIEFSTG this;
DBG_ENTER_RIID(TEXT("BriefStg_CreateInstance"), riid);
// Briefcase storage does not support aggregation.
//
if (punkOuter)
{
hres = CLASS_E_NOAGGREGATION;
*ppvOut = NULL;
goto Leave;
}
this = GAlloc(sizeof(*this));
if (!this)
{
hres = E_OUTOFMEMORY;
*ppvOut = NULL;
goto Leave;
}
this->bs.lpVtbl = &c_BriefStg_BSVtbl;
this->cRef = 1;
this->pcbs = NULL;
this->dwFlags = 0;
// Load the engine if it hasn't already been loaded
// (this only returns FALSE if something went wrong)
if (Sync_QueryVTable())
{
ENTEREXCLUSIVE()
{
// The decrement is in BriefStg_Release()
IncBriefSemaphore();
if (IsFirstBriefSemaphore())
{
ProcessIniFile(); // Load settings first
// Initialize cache
if (InitCacheTables())
hres = NOERROR;
else
hres = E_OUTOFMEMORY;
}
else
{
hres = NOERROR;
}
}
LEAVEEXCLUSIVE()
}
if (SUCCEEDED(hres))
{
// Note that the Release member will free the object, if
// QueryInterface failed.
//
hres = this->bs.lpVtbl->QueryInterface(&this->bs, riid, ppvOut);
this->bs.lpVtbl->Release(&this->bs);
}
else
{
*ppvOut = NULL;
}
Leave:
DBG_EXIT_HRES(TEXT("BriefStg_CreateInstance"), hres);
return hres; // S_OK or E_NOINTERFACE
}
Reference in New Issue Copy Permalink