|
|
/*++
� 1998 Seagate Software, Inc. All rights reserved.
Module Name:
fsaitem.cpp
Abstract:
This class contains represents a scan item (i.e. file or directory) for NTFS 5.0.
Author:
Chuck Bardeen [cbardeen] 1-Dec-1996
Revision History:
--*/
#include "stdafx.h"
#define WSB_TRACE_IS WSB_TRACE_BIT_FSA
#include "wsb.h"
#include "wsbtrak.h"
#include "fsa.h"
#include "mover.h"
#include "fsaitem.h"
#include "fsaprem.h"
static USHORT iCountItem = 0; // Count of existing objects
HRESULT CFsaScanItem::CompareTo( IN IUnknown* pUnknown, OUT SHORT* pResult )
/*++
Implements:
IWsbCollectable::CompareTo().
--*/ { HRESULT hr = S_OK; CComPtr<IFsaScanItem> pScanItem;
WsbTraceIn(OLESTR("CFsaScanItem::CompareTo"), OLESTR(""));
try {
// Did they give us a valid item to compare to?
WsbAssert(0 != pUnknown, E_POINTER);
// We need the IWsbBool interface to get the value of the object.
WsbAffirmHr(pUnknown->QueryInterface(IID_IFsaScanItem, (void**) &pScanItem));
// Compare the rules.
hr = CompareToIScanItem(pScanItem, pResult);
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::CompareTo"), OLESTR("hr = <%ls>, result = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pResult));
return(hr); }
HRESULT CFsaScanItem::CompareToIScanItem( IN IFsaScanItem* pScanItem, OUT SHORT* pResult )
/*++
Implements:
IFsaScanItem::CompareToIScanItem().
--*/ { HRESULT hr = S_OK; CWsbStringPtr path; CWsbStringPtr name;
WsbTraceIn(OLESTR("CFsaScanItem::CompareToIScanItem"), OLESTR(""));
try {
// Did they give us a valid item to compare to?
WsbAssert(0 != pScanItem, E_POINTER);
// Either compare the name or the id.
WsbAffirmHr(pScanItem->GetPath(&path, 0)); WsbAffirmHr(pScanItem->GetName(&name, 0)); hr = CompareToPathAndName(path, name, pResult);
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::CompareToIScanItem"), OLESTR("hr = <%ls>, result = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pResult));
return(hr); }
HRESULT CFsaScanItem::CompareToPathAndName( IN OLECHAR* path, IN OLECHAR* name, OUT SHORT* pResult )
/*++
Implements:
IFsaScanItem::CompareToPathAndName().
--*/ { HRESULT hr = S_OK; SHORT aResult = 0;
WsbTraceIn(OLESTR("CFsaScanItem::CompareToPathAndName"), OLESTR(""));
try {
// Compare the path.
aResult = (SHORT) _wcsicmp(m_path, path);
// Compare the name.
if (0 == aResult) { aResult = (SHORT) _wcsicmp(m_findData.cFileName, name); }
if (0 != aResult) { hr = S_FALSE; }
if (0 != pResult) { *pResult = aResult; }
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::CompareToPathAndName"), OLESTR("hr = <%ls>, result = <%u>"), WsbHrAsString(hr), aResult);
return(hr); }
HRESULT CFsaScanItem::Copy( IN OLECHAR* dest, IN BOOL /*retainHierarcy*/, IN BOOL /*expandPlaceholders*/, IN BOOL overwriteExisting )
/*++
Implements:
IFsaScanItem::Copy().
--*/ { HRESULT hr = S_OK;
try {
// NOTE : This default behavior causes placeholders
// to be expanded and probably doesn't retain the heirarchy.
WsbAssert(0 != dest, E_POINTER); WsbAssert(CopyFile(m_findData.cFileName, dest, overwriteExisting), E_FAIL);
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::CreateLocalStream( OUT IStream **ppStream )
/*++
Implements:
IFsaScanItem::CreateLocalStream().
--*/ { HRESULT hr = S_OK; LARGE_INTEGER fileSize; CWsbStringPtr volName;
WsbTraceIn(OLESTR("CFsaScanItem::CreateLocalStream"), OLESTR("")); try { CWsbStringPtr localName;
if ( !m_gotPlaceholder) { //
// Get the placeholder info
//
fileSize.LowPart = m_findData.nFileSizeLow; fileSize.HighPart = m_findData.nFileSizeHigh; WsbAffirmHr(IsManaged(0, fileSize.QuadPart)); }
WsbAssert( 0 != ppStream, E_POINTER); WsbAffirmHr( CoCreateInstance( CLSID_CNtFileIo, 0, CLSCTX_SERVER, IID_IDataMover, (void **)&m_pDataMover ) ); //
// Set the device name for the mover so it can set the source infor for the USN journal.
//
WsbAffirmHr(m_pResource->GetPath(&volName, 0)); WsbAffirmHr( m_pDataMover->SetDeviceName(volName)); //WsbAffirmHr(GetFullPathAndName( NULL, 0, &localName, 0));
WsbAffirmHr(GetFullPathAndName( OLESTR("\\\\?\\"), 0, &localName, 0)); WsbAffirmHr( m_pDataMover->CreateLocalStream( localName, MVR_MODE_WRITE | MVR_FLAG_HSM_SEMANTICS | MVR_FLAG_POSIX_SEMANTICS, &m_pStream ) );
LARGE_INTEGER seekTo; ULARGE_INTEGER pos; seekTo.QuadPart = m_placeholder.dataStreamStart; WsbAffirmHr( m_pStream->Seek( seekTo, STREAM_SEEK_SET, &pos ) ); *ppStream = m_pStream; m_pStream->AddRef();
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::CreateLocalStream"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr); }
HRESULT CFsaScanItem::Delete( void )
/*++
Implements:
IFsaScanItem::Delete().
--*/ { HRESULT hr = S_OK; CWsbStringPtr tmpString; HANDLE fileHandle;
try {
// This is the name of the file we want to delete.
WsbAffirmHr(GetFullPathAndName(OLESTR("\\\\?\\"), 0, &tmpString, 0));
// Since we want to be POSIX compliant, we can't use DeleteFile() and instead will
// open with the delete on close flag. This doesn't handle read-only files, so we
// have to change that ourselves.
WsbAffirmHr(MakeReadWrite());
fileHandle = CreateFile(tmpString, GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_POSIX_SEMANTICS | FILE_FLAG_DELETE_ON_CLOSE, 0);
if (INVALID_HANDLE_VALUE == fileHandle) { WsbThrow(HRESULT_FROM_WIN32(GetLastError())); } else { if (!CloseHandle(fileHandle)) { WsbThrow(HRESULT_FROM_WIN32(GetLastError())); } }
} WsbCatch(hr);
return(hr); } #pragma optimize("g", off)
HRESULT CFsaScanItem::FinalConstruct( void )
/*++
Implements:
CComObjectRoot::FinalConstruct().
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaScanItem::FinalConstruct"), OLESTR(""));
try {
WsbAffirmHr(CComObjectRoot::FinalConstruct());
m_handle = INVALID_HANDLE_VALUE; m_gotPhysicalSize = FALSE; m_physicalSize.QuadPart = 0; m_gotPlaceholder = FALSE; m_changedAttributes = FALSE; m_handleRPI = 0;
// Add class to object table
WSB_OBJECT_ADD(CLSID_CFsaScanItemNTFS, this);
} WsbCatch(hr);
iCountItem++;
WsbTraceOut(OLESTR("CFsaScanItem::FinalConstruct"), OLESTR("hr = <%ls>, Count is <%d>"), WsbHrAsString(hr), iCountItem);
return(hr); } #pragma optimize("", on)
void CFsaScanItem::FinalRelease( void )
/*++
Implements:
CComObjectRoot::FinalRelease().
--*/ { WsbTraceIn(OLESTR("CFsaScanItem::FinalRelease"), OLESTR(""));
// Subtract class from object table
WSB_OBJECT_SUB(CLSID_CFsaScanItemNTFS, this);
// Terminate the scan and free the path memory.
if (INVALID_HANDLE_VALUE != m_handle) { FindClose(m_handle); m_handle = INVALID_HANDLE_VALUE; } if (0 != m_handleRPI) { CloseHandle(m_handleRPI); m_handleRPI = 0; }
if (m_pUnmanageDb != NULL) { // Db must be open
(void)m_pUnmanageDb->Close(m_pDbSession); m_pDbSession = 0; m_pUnmanageRec = 0; }
if (TRUE == m_changedAttributes) { //
// We changed it from read only to read/write - put it back.
//
RestoreAttributes(); }
//
// Detach the data mover stream
if (m_pDataMover != 0) { WsbAffirmHr( m_pDataMover->CloseStream() ); }
// Let the parent class do his thing.
CComObjectRoot::FinalRelease();
iCountItem--; WsbTraceOut(OLESTR("CFsaScanItem::FinalRelease"), OLESTR("Count is <%d>"), iCountItem); }
HRESULT CFsaScanItem::FindFirst( IN IFsaResource* pResource, IN OLECHAR* path, IN IHsmSession* pSession )
/*++
Implements:
IFsaScanItem::FindFirst().
--*/ { HRESULT hr = S_OK; CWsbStringPtr findPath; CWsbStringPtr searchName; OLECHAR* slashPtr; DWORD lErr;
WsbTraceIn(OLESTR("CFsaScanItem::FindFirst"), OLESTR("path = <%ls>"), path);
try {
WsbAssert(0 != pResource, E_POINTER); WsbAssert(0 != path, E_POINTER);
// Store off some of the scan information.
m_pResource = pResource; m_pSession = pSession;
// Break up the incoming path into a path and a name.
m_path = path; slashPtr = wcsrchr(m_path, L'\\');
// We could try to support relative path stuff (i.e. current
// directory, but I am not going to do it for now.
WsbAffirm(slashPtr != 0, E_FAIL); searchName = &(slashPtr[1]); slashPtr[1] = 0;
// Get a path that can be used by the find function.
WsbAffirmHr(GetPathForFind(searchName, &findPath, 0));
// Scan starting at the specified path.
m_handle = FindFirstFileEx(findPath, FindExInfoStandard, &m_findData, FindExSearchNameMatch, 0, FIND_FIRST_EX_CASE_SENSITIVE);
lErr = GetLastError();
// If we found a file, then remember the scan handle and
// return the scan item.
WsbAffirm(INVALID_HANDLE_VALUE != m_handle, WSB_E_NOTFOUND);
m_gotPhysicalSize = FALSE; m_physicalSize.QuadPart = 0; m_gotPlaceholder = FALSE;
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::FindFirst"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaScanItem::FindNext( void )
/*++
Implements:
IFsaScanItem::FindNext().
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaScanItem::FindNext"), OLESTR(""));
try {
WsbAssert(INVALID_HANDLE_VALUE != m_handle, E_FAIL);
if (TRUE == m_changedAttributes) { //
// We changed it from read only to read/write - put it back.
//
RestoreAttributes(); }
// Continue the scan.
WsbAffirm(FindNextFile(m_handle, &m_findData), WSB_E_NOTFOUND);
m_gotPhysicalSize = FALSE; m_physicalSize.QuadPart = 0; m_gotPlaceholder = FALSE;
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::FindNext"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaScanItem::GetAccessTime( OUT FILETIME* pTime )
/*++
Implements:
IFsaScanItem::GetAccessTime().
--*/ { HRESULT hr = S_OK;
try {
WsbAssert(0 != pTime, E_POINTER); *pTime = m_findData.ftLastAccessTime;
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetGroup( OUT OLECHAR** /*pGroup*/, IN ULONG /*bufferSize*/ )
/*++
Implements:
IFsaScanItem::GetGroup().
--*/ { HRESULT hr = S_OK;
try {
hr = E_NOTIMPL;
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetLogicalSize( OUT LONGLONG* pSize )
/*++
Implements:
IFsaScanItem::GetLogicalSize().
--*/ { HRESULT hr = S_OK; LARGE_INTEGER logSize;
try {
WsbAssert(0 != pSize, E_POINTER); logSize.LowPart = m_findData.nFileSizeLow; logSize.HighPart = m_findData.nFileSizeHigh; *pSize = logSize.QuadPart;
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetModifyTime( OUT FILETIME* pTime )
/*++
Implements:
IFsaScanItem::GetModifyTime().
--*/ { HRESULT hr = S_OK;
try {
WsbAssert(0 != pTime, E_POINTER); *pTime = m_findData.ftLastWriteTime;
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetName( OUT OLECHAR** pName, IN ULONG bufferSize )
/*++
Implements:
IFsaScanItem::GetName().
--*/ { HRESULT hr = S_OK; CWsbStringPtr tmpString = m_findData.cFileName;
try {
WsbAssert(0 != pName, E_POINTER); WsbAffirmHr(tmpString.CopyTo(pName, bufferSize));
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetOwner( OUT OLECHAR** /*pOwner*/, IN ULONG /*bufferSize*/ )
/*++
Implements:
IFsaScanItem::GetOwner().
--*/ { HRESULT hr = S_OK;
try {
hr = E_NOTIMPL;
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetPath( OUT OLECHAR** pPath, IN ULONG bufferSize )
/*++
Implements:
IFsaScanItem::GetPath().
--*/ { HRESULT hr = S_OK;
try {
WsbAssert(0 != pPath, E_POINTER); WsbAffirmHr(m_path.CopyTo(pPath, bufferSize));
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetPathForFind( IN OLECHAR* searchName, OUT OLECHAR** pPath, IN ULONG bufferSize )
/*++
Implements:
IFsaScanItem::GetPathForFind().
--*/ { HRESULT hr = S_OK; CWsbStringPtr tmpString;
try {
WsbAssert(0 != pPath, E_POINTER);
// Get a buffer.
WsbAffirmHr(tmpString.TakeFrom(*pPath, bufferSize));
try {
// Get the path to the resource of the resource.
//
WsbAffirmHr(m_pResource->GetPath(&tmpString, 0)); WsbAffirmHr(tmpString.Prepend(OLESTR("\\\\?\\"))); //WsbAffirmHr(tmpString.Append(OLESTR("\\")));
// Copy in the path.
//WsbAffirmHr(tmpString.Prepend(OLESTR("\\\\?\\")));
WsbAffirmHr(tmpString.Append(&(m_path[1]))); WsbAffirmHr(tmpString.Append(searchName));
} WsbCatch(hr);
WsbAffirmHr(tmpString.GiveTo(pPath));
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetPathAndName( IN OLECHAR* appendix, OUT OLECHAR** pPath, IN ULONG bufferSize )
/*++
Implements:
IFsaScanItem::GetPathAndName().
--*/ { HRESULT hr = S_OK; CWsbStringPtr tmpString;
try {
WsbAssert(0 != pPath, E_POINTER);
// Get a buffer.
WsbAffirmHr(tmpString.TakeFrom(*pPath, bufferSize));
try {
tmpString = m_path; tmpString.Append(m_findData.cFileName);
if (0 != appendix) { tmpString.Append(appendix); }
} WsbCatch(hr);
// Give responsibility for freeing the memory back to the caller.
WsbAffirmHr(tmpString.GiveTo(pPath));
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetFullPathAndName( IN OLECHAR* prependix, IN OLECHAR* appendix, OUT OLECHAR** pPath, IN ULONG bufferSize )
/*++
Implements:
IFsaScanItem::GetFullPathAndName().
--*/ { HRESULT hr = S_OK; CWsbStringPtr tmpString; CWsbStringPtr tmpString2;
try {
WsbAssert(0 != pPath, E_POINTER);
// Get a buffer.
WsbAffirmHr(tmpString.TakeFrom(*pPath, bufferSize));
try { if (0 != prependix) { tmpString = prependix; // Get the path to the resource of the resource.
WsbAffirmHr(m_pResource->GetPath(&tmpString2, 0)); WsbAffirmHr(tmpString.Append(tmpString2)); } else { WsbAffirmHr(m_pResource->GetPath(&tmpString, 0)); }
// Copy in the path.
WsbAffirmHr(tmpString.Append(&(m_path[1]))); WsbAffirmHr(tmpString.Append(m_findData.cFileName)); if (0 != appendix) { WsbAffirmHr(tmpString.Append(appendix)); }
} WsbCatch(hr);
// Give responsibility for freeing the memory back to the caller.
WsbAffirmHr(tmpString.GiveTo(pPath));
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetPhysicalSize( OUT LONGLONG* pSize )
/*++
Implements:
IFsaScanItem::GetPhysicalSize().
--*/ { HRESULT hr = S_OK; CWsbStringPtr path;
try {
WsbAssert(0 != pSize, E_POINTER);
//WsbAssertHr(GetFullPathAndName(NULL, 0, &path, 0));
WsbAssertHr(GetFullPathAndName(OLESTR("\\\\?\\"), 0, &path, 0));
// Only read this value in once, but wait until it is asked for
// before reading it in (since this call takes time and many scans
// won't need the information.
if (!m_gotPhysicalSize) { m_physicalSize.LowPart = GetCompressedFileSize(path, &m_physicalSize.HighPart); if (MAXULONG == m_physicalSize.LowPart) { // Have to check last error since MAXULONG could be a valid
// value for the low part of the size.
DWORD err = GetLastError();
if (err != NO_ERROR) { WsbTrace(OLESTR("CFsaScanItem::GetPhysicalSize of %ws Last error = %u\n"), (WCHAR *) path, err); }
WsbAffirm(NO_ERROR == err, E_FAIL); } m_gotPhysicalSize = TRUE; }
*pSize = m_physicalSize.QuadPart;
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetPremigratedUsn( OUT LONGLONG* pFileUsn )
/*++
Implements:
Routine Description:
Get the USN Journal number for this file from the premigrated list.
Arguments:
pFileUsn - Pointer to File USN to be returned.
Return Value:
S_OK - success
--*/ { HRESULT hr = S_OK;
try { CComPtr<IWsbDbSession> pDbSession; CComPtr<IFsaPremigratedDb> pPremDb; CComPtr<IFsaResourcePriv> pResourcePriv;
WsbAssert(pFileUsn, E_POINTER);
// Get the premigrated list DB
WsbAffirmHr(m_pResource->QueryInterface(IID_IFsaResourcePriv, (void**) &pResourcePriv)); WsbAffirmHr(pResourcePriv->GetPremigrated(IID_IFsaPremigratedDb, (void**) &pPremDb));
// Open the premigration list
WsbAffirmHr(pPremDb->Open(&pDbSession));
try { FSA_PLACEHOLDER PlaceHolder; CComPtr<IFsaPremigratedRec> pPremRec; LONGLONG usn;
// Get a DB entity for the search
WsbAffirmHr(pPremDb->GetEntity(pDbSession, PREMIGRATED_REC_TYPE, IID_IFsaPremigratedRec, (void**) &pPremRec)); WsbAffirmHr(pPremRec->UseKey(PREMIGRATED_BAGID_OFFSETS_KEY_TYPE));
// Find the record
WsbAffirmHr(GetPlaceholder(0, 0, &PlaceHolder)); WsbAffirmHr(pPremRec->SetBagId(PlaceHolder.bagId)); WsbAffirmHr(pPremRec->SetBagOffset(PlaceHolder.fileStart)); WsbAffirmHr(pPremRec->SetOffset(PlaceHolder.dataStreamStart)); WsbAffirmHr(pPremRec->FindEQ());
// Get the stored USN
WsbAffirmHr(pPremRec->GetFileUSN(&usn)); *pFileUsn = usn; } WsbCatch(hr);
// Close the DB
pPremDb->Close(pDbSession);
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetSession( OUT IHsmSession** ppSession )
/*++
Implements:
IFsaScanItem::GetSession().
--*/ { HRESULT hr = S_OK;
try {
WsbAssert(0 != ppSession, E_POINTER);
*ppSession = m_pSession; m_pSession->AddRef();
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::GetUncPathAndName( IN OLECHAR* prependix, IN OLECHAR* appendix, OUT OLECHAR** pPath, IN ULONG bufferSize )
/*++
Implements:
IFsaScanItem::GetUncPathAndName().
--*/ { HRESULT hr = S_OK; CWsbStringPtr tmpString; CWsbStringPtr tmpString2;
try {
WsbAssert(0 != pPath, E_POINTER);
// Get a buffer.
WsbAffirmHr(tmpString.TakeFrom(*pPath, bufferSize));
try { if (0 != prependix) { tmpString = prependix; // Get the path to the resource of the resource.
WsbAffirmHr(m_pResource->GetUncPath(&tmpString2, 0)); WsbAffirmHr(tmpString.Append(tmpString2)); } else { WsbAffirmHr(m_pResource->GetPath(&tmpString, 0)); }
// Copy in the path.
WsbAffirmHr(tmpString.Append(&(m_path[1]))); WsbAffirmHr(tmpString.Append(m_findData.cFileName)); if (0 != appendix) { WsbAffirmHr(tmpString.Append(appendix)); }
} WsbCatch(hr);
// Give responsibility for freeing the memory back to the caller.
WsbAffirmHr(tmpString.GiveTo(pPath));
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::IsAParent( void )
/*++
Implements:
IFsaScanItem::IsAParent().
--*/ { HRESULT hr = S_FALSE;
if ((m_findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) { hr = S_OK; }
return(hr); }
HRESULT CFsaScanItem::IsARelativeParent( void )
/*++
Implements:
IFsaScanItem::IsARelativeParent().
--*/ { HRESULT hr = S_FALSE;
if ((m_findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
// looking for "."
if (m_findData.cFileName[0] == L'.') {
if (m_findData.cFileName[1] == 0) { hr = S_OK; }
// looking for "."
else if (m_findData.cFileName[1] == L'.') {
if (m_findData.cFileName[2] == 0) { hr = S_OK; } } } }
return(hr); }
HRESULT CFsaScanItem::IsCompressed( void )
/*++
Implements:
IFsaScanItem::IsCompressed().
--*/ { HRESULT hr = S_FALSE;
if ((m_findData.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) != 0) { hr = S_OK; }
return(hr); }
HRESULT CFsaScanItem::IsEncrypted( void )
/*++
Implements:
IFsaScanItem::IsEncrypted().
--*/ { HRESULT hr = S_FALSE;
if ((m_findData.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED) != 0) { hr = S_OK; }
return(hr); }
HRESULT CFsaScanItem::IsDeleteOK( IN IFsaPostIt *pPostIt )
/*++
Implements:
IFsaScanItem::IsDeleteOK().
--*/ { HRESULT hr = S_OK; WsbTraceIn(OLESTR("CFsaScanItem::IsDeleteOK"), OLESTR(""));
try { //
// Get the version ID from the FSA Post it. This is the
// version of the file at the time of the migrate request
//
LONGLONG workVersionId; WsbAffirmHr(pPostIt->GetFileVersionId(&workVersionId));
//
// Get the version of the file at the time of this scan
//
LONGLONG scanVersionId; WsbAffirmHr(GetVersionId(&scanVersionId));
//
// See if the versions match
//
WsbTrace(OLESTR("CFsaScanItem::IsDeleteOK: workVersionId:<%I64u> scanVersionId:<%I64u>\n"), workVersionId, scanVersionId);
if (workVersionId != scanVersionId) { WsbTrace(OLESTR("CFsaScanItem::IsDeleteOK: File version has changed!\n")); WsbThrow(FSA_E_FILE_CHANGED); }
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::IsDeleteOk"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr); }
HRESULT CFsaScanItem::IsGroupMemberOf( OLECHAR* /*group*/ )
/*++
Implements:
IFsaScanItem::IsGroupMemberOf().
--*/ { HRESULT hr = S_FALSE;
hr = E_NOTIMPL;
return(hr); }
HRESULT CFsaScanItem::IsHidden( void )
/*++
Implements:
IFsaScanItem::IsHidden().
--*/ { HRESULT hr = S_FALSE;
if ((m_findData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0) { hr = S_OK; }
return(hr); }
HRESULT CFsaScanItem::IsManageable( IN LONGLONG offset, IN LONGLONG size )
/*++
Implements:
IFsaScanItem::IsManageable().
--*/ { HRESULT hr = S_FALSE; HRESULT hr2; LONGLONG logicalSize; LONGLONG managableSize; FILETIME time; FILETIME managableTime; BOOL isRelative;
//
// Get some strings for logging and tracing
//
CWsbStringPtr fileName; CWsbStringPtr jobName; try { WsbAffirmHr(GetFullPathAndName( 0, 0, &fileName, 0)); WsbAffirmHr(m_pSession->GetName(&jobName, 0)); } WsbCatch( hr );
WsbTraceIn(OLESTR("CFsaScanItem::IsManageable"), OLESTR("<%ls>"), (OLECHAR *)fileName); try {
// To be managable the item:
// - can't already be managed (premigratted or truncated)
// - can't be a link
// - can't be encrypted
// - can't be sparse
// - can't have extended attributes (reparse point limitation)
// - must have a size bigger than the resource's default size
// - must have a last access time older than the resource's default time
// Managed?
hr2 = IsManaged(offset, size); if (S_FALSE == hr2) {
// A link?
hr2 = IsALink(); if (S_FALSE == hr2) {
// Encrypted?
hr2 = IsEncrypted(); if (S_FALSE == hr2) {
// A sparse?
hr2 = IsSparse(); if (S_FALSE == hr2) {
// A sparse?
hr2 = HasExtendedAttributes(); if (S_FALSE == hr2) {
// Big enough?
WsbAffirmHr(GetLogicalSize(&logicalSize)); WsbAffirmHr(m_pResource->GetManageableItemLogicalSize(&managableSize)); if (logicalSize >= managableSize) {
// Old enough?
WsbAffirmHr(GetAccessTime(&time)); WsbAffirmHr(m_pResource->GetManageableItemAccessTime(&isRelative, &managableTime)); if (WsbCompareFileTimes(time, managableTime, isRelative, FALSE) >= 0) {
// It can be managed!!
hr = S_OK; } else { WsbLogEvent(FSA_MESSAGE_FILESKIPPED_ISACCESSED, 0, NULL, (OLECHAR*) jobName, WsbAbbreviatePath(fileName, 120), WsbHrAsString(hr), NULL); } } else { WsbLogEvent(FSA_MESSAGE_FILESKIPPED_ISTOOSMALL, 0, NULL, (OLECHAR*) jobName, WsbAbbreviatePath(fileName, 120), WsbHrAsString(hr), NULL); WsbTrace( OLESTR("LogicalSize is %I64d; ManagableSize is %I64d\n"), logicalSize, managableSize); } } else { WsbLogEvent(FSA_MESSAGE_FILESKIPPED_HASEA, 0, NULL, (OLECHAR*) jobName, WsbAbbreviatePath(fileName, 120), WsbHrAsString(hr), NULL); } } else { WsbLogEvent(FSA_MESSAGE_FILESKIPPED_ISSPARSE, 0, NULL, (OLECHAR*) jobName, WsbAbbreviatePath(fileName, 120), WsbHrAsString(hr), NULL); } } else { WsbLogEvent(FSA_MESSAGE_FILESKIPPED_ISENCRYPTED, 0, NULL, (OLECHAR*) jobName, WsbAbbreviatePath(fileName, 120), WsbHrAsString(hr), NULL); } } else { WsbLogEvent(FSA_MESSAGE_FILESKIPPED_ISALINK, 0, NULL, (OLECHAR*) jobName, WsbAbbreviatePath(fileName, 120), WsbHrAsString(hr), NULL); } } else { WsbLogEvent(FSA_MESSAGE_FILESKIPPED_ISMANAGED, 0, NULL, (OLECHAR*) jobName, WsbAbbreviatePath(fileName, 120), WsbHrAsString(hr), NULL); }
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::IsManageable"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr); }
HRESULT CFsaScanItem::IsMigrateOK( IN IFsaPostIt *pPostIt )
/*++
Implements:
IFsaScanItem::IsMigrateOK().
--*/ { HRESULT hr = S_OK; WsbTraceIn(OLESTR("CFsaScanItem::IsMigrateOK"), OLESTR(""));
try { //
// Make sure the file isn't already managed. This could happen if two jobs were scanning
// the same volume.
//
LONGLONG offset; LONGLONG size;
WsbAffirmHr(pPostIt->GetRequestOffset(&offset)); WsbAffirmHr(pPostIt->GetRequestSize(&size)); if (IsManaged(offset, size) == S_OK) { //
// The file is already managed so skip it
//
WsbTrace(OLESTR("A manage request for an already managed file - skip it!\n")); WsbThrow(FSA_E_FILE_ALREADY_MANAGED); }
//
// Get the version ID from the FSA Post it. This is the
// version of the file at the time of the migrate request
//
LONGLONG workVersionId; WsbAffirmHr(pPostIt->GetFileVersionId(&workVersionId));
//
// Get the version of the file at the time of this scan
//
LONGLONG scanVersionId; WsbAffirmHr(GetVersionId(&scanVersionId));
//
// See if the versions match
//
WsbTrace(OLESTR("CFsaScanItem::IsMigrateOK: workVersionId:<%I64u> scanVersionId:<%I64u>\n"), workVersionId, scanVersionId);
if (workVersionId != scanVersionId) { WsbTrace(OLESTR("CFsaScanItem::IsMigrateOK: File version has changed!\n")); WsbThrow(FSA_E_FILE_CHANGED); }
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::IsMigrateOK"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr); }
HRESULT CFsaScanItem::IsMbit( void )
/*++
Implements:
IFsaScanItem::IsMbit().
--*/ { HRESULT hr = S_FALSE;
if ((m_findData.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) != 0) { hr = S_OK; }
return(hr); }
HRESULT CFsaScanItem::IsOffline( void ) /*++
Implements:
IFsaScanItem::IsOffline().
--*/ { HRESULT hr = S_FALSE;
if ((m_findData.dwFileAttributes & FILE_ATTRIBUTE_OFFLINE) != 0) { hr = S_OK; }
return(hr); }
HRESULT CFsaScanItem::IsOwnerMemberOf( OLECHAR* /*group*/ )
/*++
Implements:
IFsaScanItem::IsOwnerMemberOf().
--*/ { HRESULT hr = S_FALSE;
hr = E_NOTIMPL;
return(hr); }
HRESULT CFsaScanItem::IsReadOnly( void )
/*++
Implements:
IFsaScanItem::IsReadOnly().
--*/ { HRESULT hr = S_FALSE;
if ((m_findData.dwFileAttributes & FILE_ATTRIBUTE_READONLY) != 0) { hr = S_OK; }
return(hr); }
HRESULT CFsaScanItem::IsRecallOK( IN IFsaPostIt *pPostIt )
/*++
Implements:
IFsaScanItem::IsRecallOK().
--*/ { HRESULT hr = S_OK; WsbTraceIn(OLESTR("CFsaScanItem::IsRecallOK"), OLESTR(""));
try { LONGLONG offset; LONGLONG size; //
// Make sure the file is still truncated
//
WsbAffirmHr(pPostIt->GetRequestOffset(&offset)); WsbAffirmHr(pPostIt->GetRequestSize(&size)); hr = IsTruncated(offset, size); if (S_OK != hr) { //
// The file is not truncated, so skip it
//
WsbTrace(OLESTR("CFsaScanItem::IsRecallOK - file isn't truncated.\n")); WsbThrow(FSA_E_FILE_NOT_TRUNCATED); }
// Get the version ID from the FSA Post it. This is the
// version of the file at the time of the migrate request
//
LONGLONG workVersionId; WsbAffirmHr(pPostIt->GetFileVersionId(&workVersionId));
//
// Get the version of the file
//
LONGLONG scanVersionId; WsbAffirmHr(GetVersionId(&scanVersionId));
//
// See if the versions match
//
WsbTrace(OLESTR("CFsaScanItem::IsRecallOK: workVersionId:<%I64u> scanVersionId:<%I64u>\n"), workVersionId, scanVersionId);
if (workVersionId != scanVersionId) { WsbTrace(OLESTR("CFsaScanItem::IsRecallOK: File version has changed!\n"));
//
// If the use has changed alternate data streams
// the file version ID may have changed but it is
// OK to recall the file. So if the version ID's
// don't match, then check to see if the truncated
// part of the file is OK. If so, allow the recall
// to happen.
//
//
// Check to see if the whole file is still sparse
//
if (IsTotallySparse() == S_OK) { //
// The file is OK so far to recall but we need
// to make the last modify dates match
//
FSA_PLACEHOLDER placeholder; WsbAffirmHr(pPostIt->GetPlaceholder(&placeholder));; placeholder.fileVersionId = scanVersionId; WsbAffirmHr(pPostIt->SetPlaceholder(&placeholder)); } else { //
// The file has been changed, recalling data will
// overwrite something that has been added since the
// truncation occurred. So don't do anything.
//
WsbTrace(OLESTR("File is no longer sparse.!\n")); WsbThrow(FSA_E_FILE_CHANGED); }
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::IsRecallOK"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr); }
HRESULT CFsaScanItem::IsSparse( void )
/*++
Implements:
IFsaScanItem::IsSparse().
--*/ { HRESULT hr = S_FALSE; LONGLONG size;
WsbTraceIn(OLESTR("CFsaScanItem::IsSparse"), OLESTR("")); if ((m_findData.dwFileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) != 0) { hr = GetLogicalSize( &size ) ; if ( S_OK == hr ) { hr = CheckIfSparse(0, size ); if ( (FSA_E_FILE_IS_TOTALLY_SPARSE == hr) || (FSA_E_FILE_IS_PARTIALLY_SPARSE == hr) ) { hr = S_OK; } else { hr = S_FALSE; } } } WsbTraceOut(OLESTR("CFsaScanItem::IsSparse"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr); }
HRESULT CFsaScanItem::IsTotallySparse( void )
/*++
Implements:
IFsaScanItem::IsTotallySparse().
--*/ { HRESULT hr = S_FALSE; LONGLONG size;
WsbTraceIn(OLESTR("CFsaScanItem::IsTotallySparse"), OLESTR("")); if ((m_findData.dwFileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) != 0) { hr = GetLogicalSize( &size ) ; if ( S_OK == hr ) { hr = CheckIfSparse(0, size ); if (FSA_E_FILE_IS_TOTALLY_SPARSE == hr) { hr = S_OK; } else { hr = S_FALSE; } } }
WsbTraceOut(OLESTR("CFsaScanItem::IsTotallySparse"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr); }
HRESULT CFsaScanItem::Manage( IN LONGLONG offset, IN LONGLONG size, IN GUID storagePoolId, IN BOOL truncate )
/*++
Implements:
IFsaScanItem::Manage().
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaScanItem::Manage"), OLESTR(""));
try {
WsbAssert(GUID_NULL != storagePoolId, E_INVALIDARG); WsbAffirmHr(m_pResource->Manage((IFsaScanItem*) this, offset, size, storagePoolId, truncate));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::Manage"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaScanItem::Move( OLECHAR* dest, BOOL /*retainHierarcy*/, BOOL /*expandPlaceholders*/, BOOL overwriteExisting )
/*++
Implements:
IFsaScanItem::Move().
--*/ { HRESULT hr = S_OK; DWORD mode = MOVEFILE_COPY_ALLOWED;
try {
// NOTE : This default behavior causes placeholders
// to be expanded when moving to another volume and probably doesn't
// retain the heirarchy.
WsbAssert(0 != dest, E_POINTER);
if (overwriteExisting) { mode |= MOVEFILE_REPLACE_EXISTING; }
WsbAssert(MoveFileEx(m_findData.cFileName, dest, mode), E_FAIL);
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::Recall( IN LONGLONG offset, IN LONGLONG size, IN BOOL deletePlaceholder )
/*++
Implements:
IFsaScanItem::Recall().
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaScanItem::Recall"), OLESTR(""));
try {
WsbAffirmHr(m_pResource->Recall((IFsaScanItem*) this, offset, size, deletePlaceholder));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::Recall"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaScanItem::Recycle( void )
/*++
Implements:
IFsaScanItem::Recycle().
--*/ { HRESULT hr = S_OK;
try {
// Probably need to look at SHFileOperation().
hr = E_NOTIMPL;
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::IsSystem( void )
/*++
Implements:
IFsaScanItem::IsSystem().
--*/ { HRESULT hr = S_FALSE;
if ((m_findData.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) != 0) { hr = S_OK; }
return(hr); }
HRESULT CFsaScanItem::Test( USHORT* passed, USHORT* failed )
/*++
Implements:
IWsbTestable::Test().
--*/ { HRESULT hr = S_OK;
try {
WsbAssert(0 != passed, E_POINTER); WsbAssert(0 != failed, E_POINTER);
*passed = 0; *failed = 0;
} WsbCatch(hr);
return(hr); }
HRESULT CFsaScanItem::Unmanage( IN LONGLONG offset, IN LONGLONG size )
/*++
Implements:
IFsaScanItem::Unmanage().
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaScanItem::Unmanage"), OLESTR("<%ls>"), WsbAbbreviatePath(m_path, 120));
try {
// We only need to worry about files that have placeholder information.
if (IsManaged(offset, size) == S_OK) {
// If the file is truncated, then we need to recall the data
// before deleting the placeholder information.
// NOTE: We set a flag on the Recall so the placeholder will
// be deleted after the file is recalled.
if (IsTruncated(offset, size) == S_OK) { WsbAffirmHr(Recall(offset, size, TRUE)); } else {
// For disaster recovery, it would be better to delete the placeholder
// and THEN remove this file from the premigration list. Unfortunately,
// after deleting the placeholder, the RemovePremigrated call fails
// because it needs to get some information from the placeholder (which
// is gone). So we do it in this order.
hr = m_pResource->RemovePremigrated((IFsaScanItem*) this, offset, size); if (WSB_E_NOTFOUND == hr) { // It's no tragedy if this file wasn't in the list since we were
// going to delete it anyway (although it shouldn't happen) so
// let's continue anyway
hr = S_OK; } WsbAffirmHr(hr); WsbAffirmHr(DeletePlaceholder(offset, size)); } }
} WsbCatch(hr); WsbTraceOut(OLESTR("CFsaScanItem::Unmanage"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaScanItem::Validate( IN LONGLONG offset, IN LONGLONG size )
/*++
Implements:
IFsaScanItem::Validate().
--*/ { HRESULT hr = S_OK; BOOL fileIsTruncated = FALSE; LONGLONG usn = 0;
WsbTraceIn(OLESTR("CFsaScanItem::Validate"), OLESTR("offset = <%I64u>, size = <%I64u>"), offset, size); try { //
// Do some local validation before calling the engine.
//
// We only need to worry about files that have placeholder information.
if (IsManaged(offset, size) == S_OK) { //
// If the file is marked as truncated, make sure it is still truncated.
//
if (IsTruncated(offset, size) == S_OK) { //
// Check to see if the file is totally sparse to see if it is truncated.
//
if (IsTotallySparse() != S_OK) { //
// The file is marked as truncated but is not truncated
// Make it truncated.
//
WsbAffirmHr(Truncate(offset,size)); WsbLogEvent(FSA_MESSAGE_VALIDATE_TRUNCATED_FILE, 0, NULL, WsbAbbreviatePath(m_path, 120), WsbHrAsString(hr), NULL); } fileIsTruncated = TRUE; } }
//
// The last modify date may be updated on a file if the named data streams
// have been modified. So check to see if the dates match. If they don't,
// if the file is trunctated, see if it is still truncated, if so, update the
// modify date in the placeholder to the file's modify date. If the file is
// premigrated and the modify dates don't match, delete the placeholder.
// Get the version ID from the file
LONGLONG scanVersionId; WsbAffirmHr(GetVersionId(&scanVersionId));
// Get the version ID from the placeholder
FSA_PLACEHOLDER scanPlaceholder; WsbAffirmHr(GetPlaceholder(offset, size, &scanPlaceholder));
if (TRUE == fileIsTruncated) {
// Check to see if the dates match
if (scanPlaceholder.fileVersionId != scanVersionId) { WsbTrace(OLESTR("CFsaScanItem::Validate - placeholer version ID = <%I64u>, file version Id = <%I64u>"), scanPlaceholder.fileVersionId, scanVersionId); //
// Update the placeholder information on the reparse point
//
LONGLONG afterPhUsn; scanPlaceholder.fileVersionId = scanVersionId; WsbAffirmHr(CreatePlaceholder(offset, size, scanPlaceholder, FALSE, 0, &afterPhUsn)); WsbLogEvent(FSA_MESSAGE_VALIDATE_RESET_PH_MODIFY_TIME, 0, NULL, WsbAbbreviatePath(m_path, 120), WsbHrAsString(hr), NULL); } } else { // The file is pre-migrated. Verify that it has not changed since we managed it and if it has then unmanage it.
if (Verify(offset, size) != S_OK) { WsbAffirmHr(Unmanage(offset, size)); WsbLogEvent(FSA_MESSAGE_VALIDATE_UNMANAGED_FILE, 0, NULL, WsbAbbreviatePath(m_path, 120), WsbHrAsString(hr), NULL); } }
// Now that all of this stuff is OK, call the engine
if (IsManaged(offset, size) == S_OK) { WsbAffirmHr(m_pResource->Validate((IFsaScanItem*) this, offset, size, usn)); }
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::Validate"), OLESTR("hr = <%ls>"), WsbHrAsString(hr)); return(hr); }
HRESULT CFsaScanItem::FindFirstInDbIndex( IN IFsaResource* pResource, IN IHsmSession* pSession )
/*++
Implements:
IFsaScanItemPriv::FindFirstInDbIndex().
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaScanItem::FindFirstInDbIndex"), OLESTR(""));
try { CComPtr<IFsaResourcePriv> pResourcePriv;
WsbAssert(0 != pResource, E_POINTER);
// Store off some of the scan information.
m_pResource = pResource; m_pSession = pSession;
// If Db is already present (could happen if somebody calls First() twice in a row),
// we close the Db and reopen since we cannot be sure that the resource is the same!
if (m_pUnmanageDb != NULL) { // Db must be open
(void)m_pUnmanageDb->Close(m_pDbSession); m_pDbSession = 0; m_pUnmanageRec = 0; m_pUnmanageDb = 0; }
// Get and open the Unmanage db
// (Note: if this scanning is ever extended to use another DB,
// this method should get additional parameter for which DB to scan)
WsbAffirmHr(m_pResource->QueryInterface(IID_IFsaResourcePriv, (void**) &pResourcePriv)); hr = pResourcePriv->GetUnmanageDb(IID_IFsaUnmanageDb, (void**) &m_pUnmanageDb); if (WSB_E_RESOURCE_UNAVAILABLE == hr) { // Db was not created ==> no files to scan
hr = WSB_E_NOTFOUND; } WsbAffirmHr(hr);
hr = m_pUnmanageDb->Open(&m_pDbSession); if (S_OK != hr) { m_pUnmanageDb = NULL; WsbAffirmHr(hr); }
// Get a record to traverse with and set for sequential traversing
WsbAffirmHr(m_pUnmanageDb->GetEntity(m_pDbSession, UNMANAGE_REC_TYPE, IID_IFsaUnmanageRec, (void**)&m_pUnmanageRec)); WsbAffirmHr(m_pUnmanageRec->SetSequentialScan());
// Get file information
WsbAffirmHr(GetFromDbIndex(TRUE));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaScanItem::FindFirstInDbIndex"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaScanItem::FindNextInDbIndex( void )
/*++
Implements:
IFsaScanItemPriv::FindNextInDbIndex().
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaScanItem::FindNextInDbIndex"), OLESTR(""));
try { WsbAssert(m_pUnmanageDb != NULL, E_FAIL);
// Get file information
WsbAffirmHr(GetFromDbIndex(FALSE));
} WsbCatch(hr); WsbTraceOut(OLESTR("CFsaScanItem::FindNextInDbIndex"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaScanItem::GetFromDbIndex( BOOL first )
/*
Implements:
CFsaScanItem::GetFromDbIndex().
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaScanItem::GetFromDbIndex"), OLESTR(""));
try { IFsaScanItem* pScanItem; HRESULT hrFindFileId = S_OK; LONGLONG fileId; BOOL bCont;
WsbAssert(m_pUnmanageDb != NULL, E_FAIL); WsbAssert(m_pUnmanageRec != NULL, E_FAIL);
do { bCont = FALSE;
// Get first/next record
if (first) { hr = m_pUnmanageRec->First(); } else { hr = m_pUnmanageRec->Next(); } WsbAffirm(S_OK == hr, WSB_E_NOTFOUND);
// Get file id
WsbAffirmHr(m_pUnmanageRec->GetFileId(&fileId)); // Reset some items in case this isn't the first call to FindFileId
// (FindFileId actually "attach" the object to a different file)
if (INVALID_HANDLE_VALUE != m_handle) { FindClose(m_handle); m_handle = INVALID_HANDLE_VALUE; } if (TRUE == m_changedAttributes) { RestoreAttributes(); }
// Find the file from the ID
pScanItem = this; hrFindFileId = m_pResource->FindFileId(fileId, m_pSession, &pScanItem);
// If the FindFileId failed, we just skip that item and get the
// next one. This is to keep the scan from just stopping on this
// item. FindFileId could fail because the file has been deleted
// or open exclusively by somebody else
if (!SUCCEEDED(hrFindFileId)) { WsbTrace(OLESTR("CFsaScanItem::GetFromDbIndex: file id %I64d skipped since FindFileId failed with hr = <%ls>\n"), fileId, WsbHrAsString(hrFindFileId)); first = FALSE; bCont = TRUE; } } while (bCont);
WsbAffirmHr(pScanItem->Release()); // Get rid of extra ref. count (we get extra ref count only when FindFileId succeeds)
} WsbCatch(hr); WsbTraceOut(OLESTR("CFsaScanItem::GetFromDbIndex"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
|