2359 lines
64 KiB
C
2359 lines
64 KiB
C
//---------------------------------------------------------------------------
|
|
//
|
|
// 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(¬, NEWOBJECTTWIN);
|
|
not.ulSize = sizeof(NEWOBJECTTWIN);
|
|
not.pcszFolder1 = szPath;
|
|
not.pcszFolder2 = pszTargetDir;
|
|
not.pcszName = pszFile;
|
|
|
|
SetHourglass();
|
|
Sync_Dump(¬, NEWOBJECTTWIN);
|
|
tr = Sync_AddObject(pcbs->hbrf, ¬, &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
|
|
}
|
|
|
|
|
|
|