//+============================================================================ // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1994 - 1998. // // File: hntfsstg.cxx // // This file provides the NFF (NTFS Flat File) IStorage implementation. // // History: // 5/6/98 MikeHill // - Use CoTaskMem rather than new/delete. // - Split the Init method into two methods, one which is // file name based and the other which is handle based. // 5/18/98 MikeHill // - Use the cleaned up CPropertySetStorage & CPropertyBagEx // constructors. // //+============================================================================ #include #include "expparam.hxx" EXTERN_C const IID IID_IFlatStorage = { /* b29d6138-b92f-11d1-83ee-00c04fc2c6d4 */ 0xb29d6138, 0xb92f, 0x11d1, {0x83, 0xee, 0x00, 0xc0, 0x4f, 0xc2, 0xc6, 0xd4} }; #define UNSUPPORTED_STGM_BITS ( STGM_CONVERT | \ STGM_TRANSACTED | \ STGM_PRIORITY | \ STGM_SIMPLE | \ STGM_DELETEONRELEASE ) WCHAR GetDriveLetter (WCHAR const *pwcsName); BOOL IsDataStream( const PFILE_STREAM_INFORMATION pFileStreamInformation ); //----------------------------------------------------------- // // NFFOpen(); // // Routine for the rest of Storage to use to open NFF files // without knowing a lot of details. // //----------------------------------------------------------- HRESULT NFFOpen(const WCHAR *pwcsName, DWORD grfMode, DWORD dwFlags, BOOL fCreateAPI, REFIID riid, void **ppv) { CNtfsStorage* pnffstg=NULL; IUnknown *punk=NULL; HRESULT sc=S_OK; nffDebug(( DEB_TRACE | DEB_INFO | DEB_OPENS, "NFFOpen(\"%ws\", %x, %x, &iid=%x, %x)\n", pwcsName, grfMode, fCreateAPI, &riid, ppv)); if( 0 != ( grfMode & UNSUPPORTED_STGM_BITS ) ) nffErr( EH_Err, STG_E_INVALIDFLAG ); // // We don't support Write only storage (yet) // if( STGM_WRITE == (grfMode & STGM_RDWR_MASK) ) nffErr( EH_Err, STG_E_INVALIDFLAG ); nffMem( pnffstg = new CNtfsStorage( grfMode )); nffChk( pnffstg->InitFromName( pwcsName, fCreateAPI, dwFlags ) ); nffChk( pnffstg->QueryInterface( riid, (void**)&punk ) ); *ppv = punk; punk = NULL; EH_Err: RELEASE_INTERFACE( pnffstg ); RELEASE_INTERFACE( punk ); // Compatibilty with Docfile: Multiple opens with incompatible // STGM_ modes returns LOCK vio not SHARE vio. We use file SHARE'ing // Docfile used file LOCK'ing. // if(STG_E_SHAREVIOLATION == sc) sc = STG_E_LOCKVIOLATION; nffDebug(( DEB_TRACE, "NFFOpen() sc=%x\n", sc )); return(sc); } //+---------------------------------------------------------------------------- // // Function: NFFOpenOnHandle // // Create or open an NFF IStorage (or QI-able interface) on a given // handle. // //+---------------------------------------------------------------------------- HRESULT NFFOpenOnHandle( BOOL fCreateAPI, DWORD grfMode, DWORD stgfmt, HANDLE* phStream, REFIID riid, void ** ppv) { HRESULT sc=S_OK; CNtfsStorage *pnffstg=NULL; IUnknown *punk=NULL; nffDebug(( DEB_TRACE | DEB_INFO | DEB_OPENS, "NFFOpenOnHandle(%x, %x, %x, %x, &iid=%x, %x)\n", fCreateAPI, grfMode, stgfmt, *phStream, &riid, ppv)); if( 0 != ( grfMode & UNSUPPORTED_STGM_BITS ) ) nffErr( EH_Err, STG_E_INVALIDFLAG ); if( fCreateAPI ) nffErr( EH_Err, STG_E_INVALIDPARAMETER ); nffMem( pnffstg = new CNtfsStorage( grfMode )); nffChk( pnffstg->InitFromMainStreamHandle( phStream, NULL, fCreateAPI, NFFOPEN_NORMAL, stgfmt ) ); nffAssert( INVALID_HANDLE_VALUE == *phStream ); nffChk( pnffstg->QueryInterface( riid, (void**)&punk ) ); *ppv = punk; punk = NULL; EH_Err: RELEASE_INTERFACE(pnffstg); RELEASE_INTERFACE(punk); return( sc ); } // OpenNFFOnHandle //+---------------------------------------------------------------------------- // // CNtfsStorage IUnknown::QueryInterface // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::QueryInterface( REFIID riid, void ** ppvObject ) { nffXTrace( "CNtfsStorage::QueryInterface" ); HRESULT sc = S_OK; NFF_VALIDATE( QueryInterface( riid, ppvObject ) ); if( IID_IStorage == riid ) { nffDebug(( DEB_ERROR, "STGFMT_FILE IID_IStorage is not supported\n" )); return E_NOINTERFACE; //*ppvObject = static_cast(this); //AddRef(); } else if( IID_IUnknown == riid || IID_IFlatStorage == riid ) { *ppvObject = static_cast(this); AddRef(); } else if( IID_IPropertySetStorage == riid ) { *ppvObject = static_cast(this); AddRef(); } else if( IID_IBlockingLock == riid ) { *ppvObject = static_cast(this); AddRef(); } else if( IID_ITimeAndNoticeControl == riid ) { *ppvObject = static_cast(this); AddRef(); } else if( IID_IPropertyBagEx == riid ) { *ppvObject = static_cast(&_PropertyBagEx); AddRef(); } else if( IID_IPropertyBag == riid ) { *ppvObject = static_cast(&_PropertyBagEx); AddRef(); } #if DBG else if( IID_IStorageTest == riid ) { *ppvObject = static_cast(this); AddRef(); } #endif // #if DBG else return E_NOINTERFACE ; return sc; } //+---------------------------------------------------------------------------- // // CNtfsStorage IUnknown::AddRef // //+---------------------------------------------------------------------------- ULONG STDMETHODCALLTYPE CNtfsStorage::AddRef(void) { LONG lRet; lRet = InterlockedIncrement( &_cReferences ); nffDebug(( DEB_REFCOUNT, "CNtfsStorage::AddRef(this==%x) == %d\n", this, lRet)); return( lRet ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IUnknown::Release // //+---------------------------------------------------------------------------- ULONG STDMETHODCALLTYPE CNtfsStorage::Release(void) { LONG lRet; lRet = InterlockedDecrement( &_cReferences ); if( 0 == lRet ) { delete this; } nffDebug((DEB_REFCOUNT, "CNtfsStorage::Release(this=%x) == %d\n", this, lRet)); return( lRet ); } #ifdef OLE2ANSI #error CNtfsStorage requires OLECHAR to be UNICODE #endif //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::CreateStream // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::CreateStream( const OLECHAR* pwcsName, DWORD grfMode, DWORD res1, DWORD res2, IStream** ppstm) { HRESULT sc=S_OK; CNtfsStream *pstm = NULL; CNtfsStream *pstmPrevious = NULL; // // Prop code passed streams names with DOCF_ UPDR_ prefix and are too long. // MikeHill and BChapman agree that the docfile in a stream code should // be moved into this object's (currenly unimplemented) CreateStorage. // So for the moment since this IStorage is not exposed, we will remove // the parameter validation. // // NFF_VALIDATE( CreateStream( pwcsName, grfMode, res1, res2, ppstm ) ); Lock( INFINITE ); nffChk( CheckReverted() ); nffDebug(( DEB_INFO | DEB_OPENS | DEB_TRACE, "CreateStream(\"%ws\", %x)\n", pwcsName, grfMode)); if( STGM_CONVERT & grfMode ) nffErr( EH_Err, STG_E_INVALIDFLAG ); if( FindAlreadyOpenStream( pwcsName, &pstmPrevious ) ) { // If the stream is already open then return Access Denied because // streams are always opened Exclusive. But if we are CREATE'ing // then revert the old one and make a new one. if( 0 == (STGM_CREATE & grfMode) ) { nffErr( EH_Err, STG_E_ACCESSDENIED ); } else { pstmPrevious->ShutDown(); pstmPrevious->Release(); // FindAOS() Addref'ed, so release here pstmPrevious = NULL; } } nffChk( NewCNtfsStream( pwcsName, grfMode, TRUE, &pstm )); // ------------------ // Set Out Parameters // ------------------ *ppstm = static_cast(pstm); pstm = NULL; EH_Err: if( NULL != pstm ) pstm->Release(); if( NULL != pstmPrevious ) pstmPrevious->Release(); Unlock(); nffDebug(( DEB_TRACE, "CreateStream() sc=%x\n", sc )); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::OpenStream // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::OpenStream( const OLECHAR* pwcsName, void* res1, DWORD grfMode, DWORD res2, IStream** ppstm) { HRESULT sc=S_OK; CNtfsStream *pstm = NULL; // // Prop code passed streams names with DOCF_ UPDR_ prefix and are too long. // MikeHill and BChapman agree that the docfile in a stream code should // be moved into this object's (currenly unimplemented) OpenStorage. // So for the moment since this IStorage is not exposed, we will remove // the parameter validation. // // NFF_VALIDATE( OpenStream( pwcsName, res1, grfMode, res2, ppstm ) ); Lock( INFINITE ); nffChk( CheckReverted() ); nffDebug(( DEB_INFO | DEB_OPENS | DEB_TRACE, "OpenStream(\"%ws\", grf=0x%x);\n", pwcsName, grfMode )); if( FindAlreadyOpenStream( pwcsName, &pstm ) ) nffErr( EH_Err, STG_E_ACCESSDENIED ); nffChk( NewCNtfsStream( pwcsName, grfMode, FALSE, &pstm )); *ppstm = static_cast(pstm); pstm = NULL; EH_Err: if( NULL != pstm ) pstm->Release(); Unlock(); nffDebug(( DEB_TRACE, "OpenStream() sc=%x\n", sc )); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::CreateStorage // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::CreateStorage( const OLECHAR* pwcsName, DWORD grfMode, DWORD reserved1, DWORD reserved2, IStorage** ppstg) { nffXTrace( "CNtfsStorage::CreateStorage" ); // Not supported return( E_NOTIMPL ); } // CNtfsStorage::CreateStorage //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::OpenStorage // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::OpenStorage( const OLECHAR* pwcsName, IStorage* pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage** ppstg) { nffXTrace( "CNtfsStorage::OpenStorage" ); // Not supported return( E_NOTIMPL ); } // CNtfsStorage::OpenStorage //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::CopyTo // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::CopyTo( DWORD ciidExclude, const IID* rgiidExclude, SNB snbExclude, IStorage* pstgDest) { nffXTrace( "CNtfsStorage::CopyTo" ); HRESULT sc=S_OK; IEnumSTATSTG *penum=NULL; STATSTG statstg = { NULL }; IStream *pstmSource=NULL; IStream *pstmDest =NULL; CULargeInteger cbRead =0; CULargeInteger cbWritten=0; NFF_VALIDATE( CopyTo( ciidExclude, rgiidExclude, snbExclude, pstgDest ) ); Lock( INFINITE ); nffChk( CheckReverted() ); if( 0 != ciidExclude || NULL != rgiidExclude || NULL != snbExclude ) nffErr( EH_Err, E_NOTIMPL ); if( NULL == pstgDest) nffErr( EH_Err, STG_E_INVALIDPARAMETER ); // Get the state bits & clsid from the source nffChk( this->Stat( &statstg, STATFLAG_NONAME )); // Set the state bits & clsid on the destination nffChk( pstgDest->SetStateBits( statstg.grfStateBits, static_cast(-1) )); nffChk( pstgDest->SetClass( statstg.clsid )); // Start an enumeration of the source streams nffChk( EnumElements( 0, NULL, 0, &penum ) ); sc = penum->Next( 1, &statstg, NULL ); // Loop through the source streams and copy while( S_OK == sc ) { // Create the destination nffChk( pstgDest->CreateStream( statstg.pwcsName, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &pstmDest )); // Open the source nffChk( this->OpenStream( statstg.pwcsName, NULL, STGM_SHARE_EXCLUSIVE|STGM_READ, 0, &pstmSource )); // Copy nffChk( pstmSource->CopyTo( pstmDest, CLargeInteger(static_cast(MAXLONGLONG)), &cbRead, &cbWritten )); DfpAssert( cbRead == cbWritten ); pstmDest->Release(); pstmDest = NULL; pstmSource->Release(); pstmSource = NULL; // Move on to the next source stream CoTaskMemFree( statstg.pwcsName ); statstg.pwcsName = NULL; sc = penum->Next( 1, &statstg, NULL ); } nffChk(sc); // Normalize all success codes to S_OK sc = S_OK; EH_Err: if( NULL != penum ) penum->Release(); if( NULL != pstmDest ) pstmDest->Release(); if( NULL != pstmSource ) pstmSource->Release(); if( NULL != statstg.pwcsName ) CoTaskMemFree( statstg.pwcsName ); Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::MoveElementTo // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::MoveElementTo( const OLECHAR* pwcsName, IStorage* pstgDest, const OLECHAR* pwcsNewName, DWORD grfFlags) { nffXTrace( "CNtfsStorage::MoveElementTo" ); HRESULT sc=S_OK; NFF_VALIDATE( MoveElementTo( pwcsName, pstgDest, pwcsNewName, grfFlags ) ); Lock( INFINITE ); nffChk( CheckReverted() ); // MoveElementTo not supported. Use CopyTo and DestroyElement EH_Err: Unlock(); return( E_NOTIMPL ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::Commit // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::Commit( DWORD grfCommitFlags ) { nffXTrace( "CNtfsStorage::Commit" ); CNtfsStream *pstm = NULL; HRESULT sc=S_OK; NFF_VALIDATE( Commit( grfCommitFlags ) ); Lock( INFINITE ); nffChk( CheckReverted() ); nffChk( _PropertyBagEx.Commit( grfCommitFlags )); if( NULL != _pstmOpenList ) // Skip the head sentinal; pstm = _pstmOpenList->_pnffstmNext; while(NULL != pstm) { sc = pstm->Commit ( grfCommitFlags ); if( S_OK != sc ) break; pstm = pstm->_pnffstmNext; } EH_Err: Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::Revert // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::Revert( void ) { nffXTrace( "CNtfsStorage::Revert" ); // We don't support transactioning, so we must be in direct mode. // In direct mode, return S_OK on Revert. return( S_OK ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::EnumElements // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::EnumElements( DWORD res1, void* res2, DWORD res3, IEnumSTATSTG** ppenum ) { nffXTrace( "CNtfsStorage::EnumElements" ); CNtfsEnumSTATSTG *pNtfsEnumSTATSTG = NULL; HRESULT sc=S_OK; NFF_VALIDATE( EnumElements( res1, res2, res3, ppenum ) ); Lock( INFINITE ); nffChk( CheckReverted() ); // Create the enumerator pNtfsEnumSTATSTG = new CNtfsEnumSTATSTG( static_cast(_pTreeMutex) ); if( NULL == pNtfsEnumSTATSTG ) { sc = E_OUTOFMEMORY; goto EH_Err; } // Initialize the enumerator nffChk( pNtfsEnumSTATSTG->Init( _hFileMainStream )); // ---- // Exit // ---- *ppenum = static_cast(pNtfsEnumSTATSTG); pNtfsEnumSTATSTG = NULL; sc = S_OK; EH_Err: if( NULL != pNtfsEnumSTATSTG ) delete pNtfsEnumSTATSTG; Unlock(); return( sc ); } // CNtfsStorage::EnumElements //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::DestroyElement // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::DestroyElement( const OLECHAR* pwcsName ) { nffXTrace( "CNtfsStorage::DestroyElement" ); HRESULT sc=S_OK; NFF_VALIDATE( DestroyElement( pwcsName ) ); Lock( INFINITE ); nffChk( CheckReverted() ); // // We don't allow Destroying the CONTENT Stream. // if( IsContentStream( pwcsName ) ) nffErr( EH_Err, STG_E_INVALIDFUNCTION ); nffDebug((DEB_INFO, "CNtfsStorage::DestroyElement(\"%ws\", %x)\n", pwcsName)); sc = DestroyStreamElement( pwcsName ); if( STG_E_PATHNOTFOUND == sc || STG_E_FILENOTFOUND == sc ) sc = DestroyStreamElement( CDocfileStreamName(pwcsName) ); nffChk(sc); CNtfsStream *pstm; if( FindAlreadyOpenStream( pwcsName, &pstm ) ) // revert open stream pstm->ShutDown(); EH_Err: Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::RenameElement // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::RenameElement( const OLECHAR* pwcsOldName, const OLECHAR* pwcsNewName) { HRESULT sc=S_OK; CNtfsStream *pstm = NULL; nffXTrace( "CNtfsStorage::RenameElement" ); //NFF_VALIDATE( RenameElement( pwcsOldName, pwcsNewName ) ); Lock( INFINITE ); nffChk( CheckReverted() ); // // We don't allow Renaming the CONTENT Stream. // if( IsContentStream( pwcsOldName ) ) nffErr( EH_Err, STG_E_INVALIDFUNCTION ); nffChk( NewCNtfsStream( pwcsOldName, STGM_READWRITE|STGM_SHARE_EXCLUSIVE, FALSE, &pstm ) ); nffChk( pstm->Rename( pwcsNewName, FALSE )); nffVerify( 0 == pstm->Release() ); pstm = NULL; EH_Err: if( NULL != pstm ) nffVerify( 0 == pstm->Release() ); Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::SetElementTimes // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::SetElementTimes( const OLECHAR* pwcsName, const FILETIME* pctime, const FILETIME* patime, const FILETIME* pmtime) { nffXTrace( "CNtfsStorage::SetElementTimes" ); HRESULT sc=S_OK; NFF_VALIDATE( SetElementTimes( pwcsName, pctime, patime, pmtime ) ); if(NULL != pwcsName) return S_OK; Lock ( INFINITE ); nffChk( CheckReverted() ); nffDebug((DEB_INFO, "CNtfsStorage::SetElementTimes(\"%ws\")\n", pwcsName)); // If user mode code sets the last modified times on a handle, // then WriteFile()s no longer changes the last modified time sc = SetAllStreamsTimes(pctime, patime, pmtime); EH_Err: Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::SetClass // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::SetClass( REFCLSID clsid) { nffXTrace( "CNtfsStorage::SetClass" ); CLSID clsidOld = _clsidStgClass; HRESULT sc = S_OK; NFF_VALIDATE( SetClass( clsid ) ); Lock( INFINITE ); nffChk( CheckReverted() ); _clsidStgClass = clsid; nffChk( WriteControlStream() ); EH_Err: if (FAILED(sc)) _clsidStgClass = clsidOld; Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::SetStateBits // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::SetStateBits( DWORD grfStateBits, DWORD grfMask) { nffXTrace( "CNtfsStorage::SetStateBits" ); HRESULT sc = S_OK; NFF_VALIDATE( SetStateBits( grfStateBits, grfMask ) ); Lock( INFINITE ); nffChk( CheckReverted() ); _dwStgStateBits = (grfStateBits & grfMask); nffChk( WriteControlStream() ); EH_Err: Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IStorage::Stat // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::Stat( STATSTG *pstatstg, DWORD grfStatFlag) { nffXTrace( "CNtfsStorage::Stat" ); HRESULT sc = S_OK; BY_HANDLE_FILE_INFORMATION ByHandleFileInformation; WCHAR* pwszPath=NULL; STATSTG statstg; NFF_VALIDATE( Stat( pstatstg, grfStatFlag ) ); statstg.pwcsName = NULL; Lock( INFINITE ); nffChk( CheckReverted() ); nffDebug((DEB_INFO, "CNtfsStorage::Stat()\n")); // Does the caller want a name? if( (STATFLAG_NONAME & grfStatFlag) ) pwszPath = NULL; else nffChk( GetFilePath( &pwszPath ) ); // Get the type statstg.type = STGTY_STORAGE; // Get the size & times. if( !GetFileInformationByHandle( _hFileMainStream, &ByHandleFileInformation )) { nffErr( EH_Err, LAST_SCODE ); } statstg.cbSize.LowPart = ByHandleFileInformation.nFileSizeLow; statstg.cbSize.HighPart = ByHandleFileInformation.nFileSizeHigh; statstg.mtime = ByHandleFileInformation.ftLastWriteTime; statstg.atime = ByHandleFileInformation.ftLastAccessTime; statstg.ctime = ByHandleFileInformation.ftCreationTime; statstg.grfLocksSupported = 0; // no locks supported // Get the STGM modes statstg.grfMode = _grfMode & ~STGM_CREATE; // Get the clsid & state bits statstg.grfStateBits = _dwStgStateBits; statstg.clsid = _clsidStgClass; sc = S_OK; statstg.pwcsName = pwszPath; pwszPath = NULL; *pstatstg = statstg; EH_Err: if(NULL != pwszPath) CoTaskMemFree( pwszPath); Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IBlockingLock::Lock // //+---------------------------------------------------------------------------- inline HRESULT CNtfsStorage::Lock( DWORD dwTimeout ) { // Don't trace at this level. The noice is too great! // nffCDbgTrace dbg(DEB_ITRACE, "CNtfsStorage::Lock"); nffAssert( INFINITE == dwTimeout ); if( INFINITE != dwTimeout ) return( E_NOTIMPL ); // If there was an error during Initialize(), we may not have created the tree // mutex. if( NULL == _pTreeMutex ) return( E_NOTIMPL ); else return _pTreeMutex->Lock( dwTimeout ); } //+---------------------------------------------------------------------------- // // CNtfsStorage IBlockingLock::Unlock // //+---------------------------------------------------------------------------- inline HRESULT CNtfsStorage::Unlock() { // Don't trace at this level. The noice is too great! // nffCDbgTrace dbg(DEB_ITRACE, "CNtfsStorage::Unlock"); // If there was an error during Initialize(), we may not have created the tree // mutex. if( NULL == _pTreeMutex ) return( E_NOTIMPL ); else return _pTreeMutex->Unlock(); } //+---------------------------------------------------------------------------- // // CNtfsStorage ITimeAndNoticeControl::SuppressChanges // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::SuppressChanges( DWORD res1, DWORD res2) { HRESULT sc=S_OK; FILETIME mtime; nffDebug(( DEB_TRACE | DEB_STATCTRL, "CNtfsStorage::SuppressChanges(%d,%d)\n", res1, res2 )); if( 0 != res2 ) nffErr( EH_Err, STG_E_INVALIDPARAMETER ); if( 0 != res1 && NFF_SUPPRESS_NOTIFY != res1) nffErr( EH_Err, STG_E_INVALIDPARAMETER ); Lock( INFINITE ); nffChk( CheckReverted() ); if( 0 == res1 ) { nffBool(::GetFileTime( _hFileMainStream, NULL, NULL, &mtime)); _filetime = mtime; nffChk( SetAllStreamsTimes( NULL, NULL, &_filetime ) ); _dwState |= NFF_NO_TIME_CHANGE; } else if( NFF_SUPPRESS_NOTIFY == res1 ) { nffChk( MarkAllStreamsAux() ); _dwState |= NFF_MARK_AUX; _filetime.dwLowDateTime = -1; _filetime.dwHighDateTime = -1; nffChk( SetAllStreamsTimes( NULL, NULL, &_filetime ) ); _dwState |= NFF_NO_TIME_CHANGE; } EH_Err: Unlock(); return sc; } //+---------------------------------------------------------------------------- // End of Interface Methods // ------------- // Start of C++ Methods. //+---------------------------------------------------------------------------- //+---------------------------------------------------------------------------- // // CNtfsStorage Constructor // //+---------------------------------------------------------------------------- inline CNtfsStorage::CNtfsStorage( DWORD grfMode ) : _sig(NTFSSTORAGE_SIG), CPropertySetStorage( MAPPED_STREAM_QI ), _PropertyBagEx( grfMode ) { nffITrace("CNtfsStorage::CNtfsStorage"); _grfMode = grfMode; _pstmOpenList = NULL; _hFileMainStream = INVALID_HANDLE_VALUE; _hFileControlStream = INVALID_HANDLE_VALUE; _hFileOplock = INVALID_HANDLE_VALUE; _wcDriveLetter = 0; _dwState = 0; _hsmStatus = 0; _dwStgStateBits = 0; _clsidStgClass = CLSID_NULL; _pTreeMutex = NULL; _filetime.dwHighDateTime = 0; _filetime.dwLowDateTime = 0; _ovlpOplock.Internal = _ovlpOplock.InternalHigh = 0; _ovlpOplock.Offset = _ovlpOplock.OffsetHigh = 0; _ovlpOplock.hEvent = NULL; _mhi.UsnSourceInfo = -1; _mhi.VolumeHandle = INVALID_HANDLE_VALUE; _hOplockThread = NULL; // Finish initialization the property set objects. _NtfsStorageForPropSetStg.Init( this ); // Not add-refed CPropertySetStorage::Init( static_cast(&_NtfsStorageForPropSetStg), static_cast(this), FALSE ); // fControlLifetimes (=> don't addref) // These are also not add-refed _PropertyBagEx.Init( static_cast(this), static_cast(this) ); }; //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::IsNffAppropriate // // Synopsis: Looks for Control stream and Docfile Header given a filename // // Arguments: [pwszName] - Filename. // // History: 22-July-98 BChapman Created // 10-Nov-98 BChapman Added global routine so it can be // called by code that doesn't include // CNtfsStorage/CNtfsStream definitions. //+---------------------------------------------------------------------------- HRESULT IsNffAppropriate( const LPCWSTR pwcsName ) { return CNtfsStorage::IsNffAppropriate( pwcsName ); } HRESULT CNtfsStorage::IsNffAppropriate( const LPCWSTR pwcsName ) { UNICODE_STRING usNtfsName; LPWSTR pFreeBuffer=NULL; HANDLE hFile=INVALID_HANDLE_VALUE; HRESULT sc=S_OK; if (NULL == pwcsName) nffErr (EH_Err, STG_E_INVALIDNAME); if (!RtlDosPathNameToNtPathName_U(pwcsName, &usNtfsName, NULL, NULL)) nffErr(EH_Err, STG_E_INVALIDNAME); // This buffer will need free'ing later pFreeBuffer = usNtfsName.Buffer; // When Checking file state always open the main stream ReadOnly share // everything. We allow opening Directories. // nffChk( OpenNtFileHandle( usNtfsName, NULL, // No Parent File Handle STGM_READ | STGM_SHARE_DENY_NONE, NFFOPEN_NORMAL, FALSE, // Not a Create API &hFile ) ); nffChk( IsNffAppropriate( hFile, pwcsName ) ); EH_Err: if (NULL != pFreeBuffer) RtlFreeHeap(RtlProcessHeap(), 0, pFreeBuffer); if( INVALID_HANDLE_VALUE != hFile ) NtClose( hFile ); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::IsNffAppropriate // // Synopsis: Looks for Control stream and Docfile Header given a HFILE // // Arguments: [hFile] - readable File Handle to the main stream. // // History: 22-July-98 BChapman Created //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::IsNffAppropriate( HANDLE hFile, const WCHAR* wcszPath ) { PFILE_STREAM_INFORMATION pfsiBuf = NULL; ULONG cbBuf; OVERLAPPED olpTemp; HANDLE ev=NULL; HRESULT sc=S_OK; olpTemp.hEvent = NULL; // Check that we are on NTFS by doing a stream enum. // This is also useful later when looking for a control stream. // PERF we should cache the fsi (reload every create or delete) // sc = EnumNtStreams( hFile, &pfsiBuf, &cbBuf, TRUE ); if( FAILED(sc) ) { nffDebug((DEB_IWARN, "EnumNtStreams Failed. Not NTFS.\n" )); nffErr( EH_Err, STG_E_INVALIDFUNCTION ); } // If the control stream exists then the file is NFF. // if( IsControlStreamExtant( pfsiBuf ) ) { // This is a kludge test for nt4-pre-sp4 system over the RDR. nffChk( TestNt4StreamNameBug( pfsiBuf, wcszPath ) ); goto EH_Err; // return S_OK; } // Don't read HSM migrated Files. // If the test fails in any way, assume it is not an HSM file. // if( S_OK == IsOfflineFile( hFile ) ) nffErr( EH_Err, STG_E_INCOMPLETE ); // Check that the file is not a Storage File. Docfile and NSS don't // want this implementation making NTFS streams on their files. // // To do this we need to read the main stream. ZeroMemory( &olpTemp, sizeof(OVERLAPPED) ); // Create the Event for the Overlapped structure. // ev = CreateEvent( NULL, // Security Attributes. TRUE, // Manual Reset Flag. FALSE, // Inital State = Signaled, Flag. NULL ); // Name if( NULL == ev) nffErr( EH_Err, LAST_SCODE ); olpTemp.hEvent = ev; nffChk( StgIsStorageFileHandle( hFile, &olpTemp ) ); if( S_OK == sc ) nffErr (EH_Err, STG_E_INVALIDFUNCTION); nffAssert(S_FALSE == sc); nffChk( TestNt4StreamNameBug( pfsiBuf, wcszPath ) ); sc = S_OK; EH_Err: if( NULL != pfsiBuf ) delete [] (BYTE *)pfsiBuf; if( NULL != olpTemp.hEvent ) CloseHandle( olpTemp.hEvent ); return sc; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::TestNt4StreamNameBug // // Synopsis: Check if a stream with a \005 in the name can be opened. // This routine added an extra NTCreateFile to the NFF Open // path. And limits the length of the filename component to // MAX_PATH - StrLen(PropSetName(). This routine should be // eliminated as soon as NT4 Sp3 is history. // The bug this looking for was fixed in nt4 sp4 and Nt5. // // Returns: S_OK if the system is working correctly // STG_E_INVALIDFUNCTION if a \005 stream cannot be opened // // Arguments: [pfsiBuf] - Buffer of Enumerated Stream Names. // [wcszPath] - Full Pathname of file. // // History: 12-Oct-98 BChapman Created //+---------------------------------------------------------------------------- FMTID FMTID_NT4Check = { /* ffc11011-5e3b-11d2-8a3e-00c04f8eedad */ 0xffc11011, 0x5e3b, 0x11d2, {0x8a, 0x3e, 0x00, 0xc0, 0x4f, 0x8e, 0xed, 0xad} }; HRESULT CNtfsStorage::TestNt4StreamNameBug( PFILE_STREAM_INFORMATION pfsiBuf, const WCHAR* pwcszPath ) { const WCHAR* pwcszNtStreamName=NULL; WCHAR* pwszPathBuf=NULL; int ccBufSize=0; HANDLE hFile; UNICODE_STRING usNtfsName; OBJECT_ATTRIBUTES object_attributes; IO_STATUS_BLOCK iostatusblock; ACCESS_MASK accessmask=0; ULONG ulAttrs=0; ULONG ulSharing=0; ULONG ulCreateDisp=0; ULONG ulCreateOpt = 0; NTSTATUS status; HRESULT sc=S_OK; // If there is no pathname (and in some calling paths there isn't) // then we can't do the test. // if( NULL == pwcszPath ) goto EH_Err; // S_OK // last ditch optimization to prevent having to do // the NT4 pre-sp4 stream name bug tests. // if( AreAnyNtPropertyStreamsExtant( pfsiBuf ) ) goto EH_Err; // S_OK // // OK here is the deal.... // Try to open READONLY a stream that doesn't exist with a \005 in // the name. If the system supports such stream names then it will // return filenotfound, on NT4 before sp4 it will return INVALIDNAME. // { CPropSetName psn( FMTID_NT4Check ); CNtfsStreamName nsn( psn.GetPropSetName() ); pwcszNtStreamName = nsn; // // Use the NT API so we don't have to worry about the length // of the name. We have to convert the name while it is less // than MAX_PATH. // if (!RtlDosPathNameToNtPathName_U(pwcszPath, &usNtfsName, NULL, NULL)) nffErr(EH_Err, STG_E_INVALIDNAME); // // Build a buffer with the Path + Stream name. Free the // allocated UNICODE_STRING name and point at the buffer. // ccBufSize = usNtfsName.Length/sizeof(WCHAR)+ wcslen(pwcszNtStreamName) + 1; pwszPathBuf = (WCHAR*) alloca( ccBufSize*sizeof(WCHAR) ); wcsncpy( pwszPathBuf, usNtfsName.Buffer, ccBufSize ); wcscat( pwszPathBuf, pwcszNtStreamName ); RtlFreeHeap(RtlProcessHeap(), 0, usNtfsName.Buffer); usNtfsName.Buffer = pwszPathBuf; usNtfsName.Length = wcslen(pwszPathBuf)*sizeof(WCHAR); usNtfsName.MaximumLength = (USHORT)(ccBufSize*sizeof(WCHAR)); InitializeObjectAttributes(&object_attributes, &usNtfsName, OBJ_CASE_INSENSITIVE, NULL, NULL); nffChk( ModeToNtFlags( STGM_READ|STGM_SHARE_DENY_NONE, 0, FALSE, &accessmask, &ulAttrs, &ulSharing, &ulCreateDisp, &ulCreateOpt ) ); status = NtCreateFile( &hFile, accessmask, &object_attributes, &iostatusblock, NULL, ulAttrs, ulSharing, ulCreateDisp, ulCreateOpt, NULL, 0); nffAssert( NULL == hFile && "NFF Property TestNt4StreamNameBug" ); if( NULL != hFile ) CloseHandle( hFile ); // The system doesn't support \005. // if( STATUS_OBJECT_NAME_INVALID == status ) { nffDebug(( DEB_OPENS, "Nt4File: file=(%x) \"%ws\"\n", pwszPathBuf, pwszPathBuf )); nffErr( EH_Err, STG_E_INVALIDFUNCTION ); } // NOT_FOUND is the expected status for good systems. // if( STATUS_OBJECT_NAME_NOT_FOUND != status ) { nffDebug(( DEB_IWARN, "NT4Chk Create Stream status 0x%x\n", status )); nffErr(EH_Err, STG_E_INVALIDFUNCTION); } } EH_Err: return sc; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::IsOfflineFile // // Synopsis: Check for FILE_ATTRIBUTE_OFFLINE in the file attributes. // // Returns: S_OK if the file attributes have the bit set. // S_FALSE if the file attributes do not have the bit set. // E_* if an error occured while accessing the attributes. // // Arguments: [hFile] - Attribute Readable file handle // // History: 27-July-98 BChapman Created //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::IsOfflineFile( HANDLE hFile ) { HRESULT sc=S_OK; NTSTATUS status; IO_STATUS_BLOCK iostatblk; FILE_BASIC_INFORMATION fbi; status = NtQueryInformationFile( hFile, &iostatblk, (PVOID) &fbi, sizeof(FILE_BASIC_INFORMATION), FileBasicInformation ); if( !NT_SUCCESS(status) ) { nffDebug(( DEB_IERROR, "Query FileAttributeTagInformation file=%x, failed stat=%x\n", hFile, status )); nffErr( EH_Err, NtStatusToScode( status ) ); } // If it does not have a reparse tag, it is not HighLatency // if( 0==( FILE_ATTRIBUTE_OFFLINE & fbi.FileAttributes) ) { sc = S_FALSE; goto EH_Err; } EH_Err: return sc; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::InitFromName // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::InitFromName( const WCHAR *pwcsName, BOOL fCreateAPI, DWORD dwOpenFlags ) { nffITrace( "CNtfsStorage::Init (name)" ); HANDLE hFile = INVALID_HANDLE_VALUE; UNICODE_STRING usNtfsName; WCHAR* pFreeBuffer=NULL; DWORD dwTid; HRESULT sc=S_OK; DWORD fCreateOrNot=0; if (!RtlDosPathNameToNtPathName_U(pwcsName, &usNtfsName, NULL, NULL)) nffErr(EH_Err, STG_E_INVALIDNAME); // This buffer will need free'ing later pFreeBuffer = usNtfsName.Buffer; if( NFFOPEN_OPLOCK & dwOpenFlags ) nffChk( TakeOplock( usNtfsName ) ); // Regardless of _grfMode, always open the unnamed stream read-only share // everything. We allow opening Directories. We use this handle to // dup-open all the other streams. // if( fCreateAPI && (STGM_CREATE & _grfMode) ) fCreateOrNot = STGM_CREATE; nffChk( OpenNtFileHandle( usNtfsName, NULL, // No Parent File Handle STGM_READ | STGM_SHARE_DENY_NONE | fCreateOrNot, dwOpenFlags & ~NFFOPEN_OPLOCK, fCreateAPI, &hFile ) ); // Cache the drive letter so that in Stat we can compose a // complete path name _wcDriveLetter = GetDriveLetter( pwcsName ); nffChk( InitFromMainStreamHandle( &hFile, pwcsName, fCreateAPI, dwOpenFlags, STGFMT_ANY ) ); // hFile now belongs to the object. nffAssert( INVALID_HANDLE_VALUE == hFile ); // // If the file was sucessfull Oplocked then // start the thread that waits for the OPLOCK to break; // if( _dwState & NFF_OPLOCKED ) { _hOplockThread = CreateThread(NULL, 0, CNtfsStorage::OplockWait, this, 0, &dwTid); if( NULL == _hOplockThread ) nffErr( EH_Err, LAST_SCODE ); } EH_Err: if (NULL != pFreeBuffer) RtlFreeHeap(RtlProcessHeap(), 0, pFreeBuffer); if( INVALID_HANDLE_VALUE != hFile ) NtClose( hFile ); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::InitFromMainStreamHandle // // Synopsis: Opens NFF file from a handle. // // Arguments: [hFileMainStream] - ReadOnly DenyNone file handle. // [fCreateAPI] - Called from a Create API (vs. Open) // [fmtKnown] - STGFMT_FILE if IsNffAppropriate has // already been called. STGFMT_ANY otherwise // // History: 05-Jun-98 BChapman Created //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::InitFromMainStreamHandle( HANDLE* phFileMainStream, const WCHAR* wcszPath, BOOL fCreateAPI, DWORD dwOpenFlags, DWORD fmtKnown ) { nffITrace( "CNtfsStorage::InitFromMainStreamHandle(HANDLE)" ); HRESULT sc = S_OK; CNtfsStream* pstmHeadSentinal= NULL; CNFFTreeMutex* pTreeMutex = NULL; // Check that this file should be opened by NFF. // Skip the check if the caller has already figured it out. // if( STGFMT_FILE != fmtKnown ) { nffChk( IsNffAppropriate( *phFileMainStream, wcszPath ) ); fmtKnown = STGFMT_FILE; } // // Load the Main Stream Handle here so member functions (below) // can use it. // _hFileMainStream = *phFileMainStream; *phFileMainStream = INVALID_HANDLE_VALUE; // If requested, suppress changes, starting with the main stream handle // we just accepted. All subsequent stream opens/creates (including the // Control stream) will be marked similarly. // if( NFFOPEN_SUPPRESS_CHANGES & dwOpenFlags ) nffChk( SuppressChanges(1, 0) ); // Open the ControlPropertySet and place the SHARE MODE locks there // nffChk( OpenControlStream( fCreateAPI ) ); // Create a Mutex to Serialize access to the NFF File // nffMem( pTreeMutex = new CNFFTreeMutex() ); nffChk( pTreeMutex->Init() ); // Create an Head Sentinal for the Open Stream List // nffMem( pstmHeadSentinal = new CNtfsStream( this, pTreeMutex ) ); // Success! _dwState |= NFF_INIT_COMPLETED; _pTreeMutex = pTreeMutex; pTreeMutex = NULL; _pstmOpenList = pstmHeadSentinal; pstmHeadSentinal = NULL; EH_Err: if( NULL != pTreeMutex ) pTreeMutex->Release(); if( NULL != pstmHeadSentinal ) pstmHeadSentinal->Release(); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage Destructor // //+---------------------------------------------------------------------------- inline CNtfsStorage::~CNtfsStorage() { nffITrace("CNtfsStorage::~CNtfsStorage"); DWORD rc, hrThread=S_OK; HANDLE thread; nffDebug(( DEB_REFCOUNT, "~CNtfsStorage\n" )); ShutDownStorage(); // // If there is an Oplock Thread it is either still wating and will wake // up during the above call to Shutdown, when the Content Stream's file // handle is closed. Or it woke up previously on when the Oplock Broke // and has long since terminated. // In either case it has awoken and we can safely wait on its // completion status here. // // The Oplock thread will call Shutdown (and take the tree lock) when it // wakes so we must NOT be holding the lock while we wait for him! // if( NULL != _hOplockThread ) { rc = WaitForSingleObject( _hOplockThread, INFINITE ); if( !GetExitCodeThread( _hOplockThread, &hrThread ) ) { nffDebug(( DEB_ERROR, "GetExitCode for OplockThread failed %x\n", GetLastError() )); } if( FAILED( hrThread ) ) { nffDebug(( DEB_ERROR, "OplockThread exitcode %x\n", hrThread )); } CloseHandle( _hOplockThread ); _hOplockThread = NULL; } if( NULL != _pTreeMutex ) _pTreeMutex->Release(); if(NULL != _ovlpOplock.hEvent) CloseHandle( _ovlpOplock.hEvent ); if( INVALID_HANDLE_VALUE != _mhi.VolumeHandle ) CloseHandle( _mhi.VolumeHandle ); nffAssert( NULL == _pstmOpenList ); _sig = NTFSSTORAGE_SIGDEL; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::ShutDownStorage // // Flush data, Close File handle and mark the objects as reverted. // This is called when the Oplock Breaks and when the Storage is released. // In neither case does the caller hold the tree mutex. So we take it here. // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::ShutDownStorage() { nffITrace( "CNtfsStorage::ShutDownStorage" ); HRESULT sc, scAccum=S_OK; CNtfsStream *pstm = NULL; CNtfsStream *pstmNext = NULL; PFILE_STREAM_INFORMATION pfsiBuf = NULL; ULONG cbBuf; Lock( INFINITE ); if(NFF_FILE_CLOSED & _dwState) goto EH_Err; _dwState |= NFF_FILE_CLOSED; nffDebug(( DEB_INFO, "CNtfsStorage::Shutdown called\n" )); if(NFF_INIT_COMPLETED & _dwState) { if( FAILED(sc = _PropertyBagEx.ShutDown() )) scAccum = sc; nffAssert( NULL != _pstmOpenList ); // Skip the head sentinal; pstm = _pstmOpenList->_pnffstmNext; // // Shutdown all the streams. If there is a problem, make note of it // but continue until all the streams are shutdown. // while(NULL != pstm) { // ShutDown will cut itself from the list, so pick up the // Next pointer before calling it. // Let the streams go loose (don't delete or Release them) // the app still holds the reference (the list never had a reference) // pstmNext = pstm->_pnffstmNext; if( FAILED( sc = pstm->ShutDown() ) ) scAccum = sc; pstm = pstmNext; } // Delete the head sentinal because it is not a stream and the // app doesn't have a pointer to it. // nffAssert( NULL == _pstmOpenList->_pnffstmNext ); _pstmOpenList->Release(); _pstmOpenList = NULL; } nffDebug(( DEB_OPENS, "Closing Storage w/ _hFileMainStream=%x\n", _hFileMainStream )); if( INVALID_HANDLE_VALUE != _hFileControlStream ) { CloseHandle( _hFileControlStream ); _hFileControlStream = INVALID_HANDLE_VALUE; } if( INVALID_HANDLE_VALUE != _hFileMainStream ) { CloseHandle( _hFileMainStream ); _hFileMainStream = INVALID_HANDLE_VALUE; } if( INVALID_HANDLE_VALUE != _hFileOplock ) { CloseHandle( _hFileOplock ); _hFileOplock = INVALID_HANDLE_VALUE; } _dwState |= NFF_REVERTED; EH_Err: if( NULL != pfsiBuf ) delete[] pfsiBuf; Unlock(); return scAccum; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::GetStreamHandle // // This method gets the HANDLE for the named stream. // It understands grfModes and RelativeOpens of a main stream handle. // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::GetStreamHandle( HANDLE *phStream, const WCHAR * pwcsName, DWORD grfMode, BOOL fCreateAPI) { HANDLE hFileStream = INVALID_HANDLE_VALUE; HRESULT sc=S_OK; DWORD dwNffOpenFlags=0; CNtfsStreamName nsn( pwcsName ); nffDebug(( DEB_ITRACE | DEB_INFO, "GetStreamHandle(\"%ws\", grf=0x%x, %s)\n", pwcsName, grfMode, fCreateAPI?"Create":"Open" )); Lock( INFINITE ); if( IsContentStream( pwcsName ) ) { // The content (main) stream always exists // if( fCreateAPI && !( STGM_CREATE & grfMode ) ) nffErr( EH_Err, STG_E_FILEALREADYEXISTS ); if(NFF_OPLOCKED & _dwState) { // We don't allow creates of the Content Stream. // if( fCreateAPI ) nffErr( EH_Err, STG_E_ACCESSDENIED ); // We only allow Read Access to the Content Stream // in oplocked mode. DWORD grfRW = grfMode & STGM_RDWR_MASK; if( ( STGM_WRITE == grfRW ) || ( STGM_READWRITE == grfRW ) ) { nffDebug(( DEB_WARN, "Opening Oplocked Main Stream for Writing" " is not allowed\n" )); nffErr( EH_Err, STG_E_ACCESSDENIED ); // only allow read mode. // //grfMode &= ~STGM_RDWR_MASK; //grfMode |= STGM_READ; // zero flag. } } // only allow DenyNone mode. // grfMode &= ~STGM_SHARE_MASK; grfMode |= STGM_SHARE_DENY_NONE; // Its is already open for read. dwNffOpenFlags |= NFFOPEN_CONTENTSTREAM; } else // not the content stream { // Use the given access mode but // Use the container's Share mode. // grfMode &= ~STGM_SHARE_MASK; grfMode |= _grfMode & STGM_SHARE_MASK; } dwNffOpenFlags |= NFFOPEN_ASYNC; sc = OpenNtStream( nsn, // ":name:$DATA" grfMode, dwNffOpenFlags, fCreateAPI, &hFileStream ); #if DBG==1 if( STG_E_FILENOTFOUND == sc ) { nffDebug(( DEB_IWARN, "GetStreamHandle: stream '%ws' not found\n", (const WCHAR*)nsn )); goto EH_Err; } #endif DBG nffChk( sc ); *phStream = hFileStream; hFileStream = INVALID_HANDLE_VALUE; EH_Err: #if DBG==1 if( S_OK != sc ) { nffDebug(( DEB_OPENS|DEB_INFO, "Open on stream '%ws' Failed\n", pwcsName )); } #endif if( INVALID_HANDLE_VALUE != hFileStream ) NtClose( hFileStream ); Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::FileAlreadyOpenStream // // This routine finds the previously open stream by the given name. // //+---------------------------------------------------------------------------- BOOL CNtfsStorage::FindAlreadyOpenStream( const WCHAR* pwcsName, CNtfsStream** ppstm) { // Skip the head sentinal. CNtfsStream *pstm = _pstmOpenList->_pnffstmNext; while(NULL != pstm) { //if( 0 == _wcsicmp(pwcsName, pstm->GetName() ) ) if( 0 == dfwcsnicmp( pwcsName, pstm->GetName(), -1 )) { *ppstm = pstm; pstm->AddRef(); return TRUE; } pstm = pstm->_pnffstmNext; } return FALSE; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::NewCNtfsStream // // This method lumps together the three phases of creating a new stream // object (Constructor, Filesystem Open, and Object Initialization). And // it handles the special case of opening the "already open" CONTENTS stream. // This begs the question, why is there three phases. // 1) We can't put to much in the constructor because of the inability to // return errors. // 2) GetStreamHandle and InitCNtfsStream are broken apart because of the // the special needs in the Storage::Init routine. It opens the // CONTENT stream directly and calls InitCNtfsStream to finish. // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::NewCNtfsStream( const WCHAR *pwcsName, DWORD grfMode, BOOL fCreateAPI, CNtfsStream **ppstm ) { HRESULT sc=S_OK; HANDLE hStream = INVALID_HANDLE_VALUE; CNtfsStream *pstm = NULL; Lock( INFINITE ); nffMem( pstm = new CNtfsStream( this, (IBlockingLock*) _pTreeMutex ) ); nffChk( GetStreamHandle( &hStream, pwcsName, grfMode, fCreateAPI ) ); sc = InitCNtfsStream( pstm, hStream, grfMode, pwcsName ); hStream = INVALID_HANDLE_VALUE; // hStream now belongs the the object. nffChk(sc); if( fCreateAPI ) nffChk( pstm->SetSize( CULargeInteger(0) )); // Load Out parameters and clear working state *ppstm = pstm; pstm = NULL; EH_Err: nffDebug(( DEB_ITRACE | DEB_INFO, "NewCNtfsStream() sc=%x. hFile=0x%x\n", sc, FAILED(sc)?INVALID_HANDLE_VALUE:(*ppstm)->GetFileHandle() )); if( INVALID_HANDLE_VALUE != hStream ) NtClose( hStream ); if( NULL != pstm ) pstm->Release(); Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface ::DestroyStreamElement // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::DestroyStreamElement( const OLECHAR *pwcsName ) { nffXTrace( "CNtfsStorage::DestroyStreamElement" ); HANDLE hFileStream = INVALID_HANDLE_VALUE; HRESULT sc=S_OK; Lock( INFINITE ); nffChk( CheckReverted() ); nffDebug(( DEB_INFO | DEB_WRITE, "CNtfsStorage::DestroyStreamElement('%ws')\n", pwcsName)); // Open the handle with DELETE permissions. Write includes Delete. // nffChk( OpenNtStream( CNtfsStreamName(pwcsName), // ":name:$Data" STGM_WRITE | STGM_SHARE_DENY_NONE, // grfMode NFFOPEN_SYNC, FALSE, // not CreateAPI &hFileStream ) ); nffChk( CNtfsStream::DeleteStream( &hFileStream )); EH_Err: if( INVALID_HANDLE_VALUE != hFileStream ) { NtClose( hFileStream ); } Unlock(); return( sc ); } // CNtfsStorage::DestroyStreamElement //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface ::GetFilePath // Helper routine for Stat. // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::GetFilePath( WCHAR** ppwszPath ) { IO_STATUS_BLOCK IoStatusBlock; ULONG cbFileNameInfo = 2*(MAX_PATH+1)+sizeof(FILE_NAME_INFORMATION); PFILE_NAME_INFORMATION pFileNameInfo=NULL; WCHAR* pwsz=NULL; HRESULT sc; NTSTATUS status; // Query the handle for the "volume-relative" path. This isn't // actually volume-relative (e.g. on a UNC path), it's actually // the complete path without the leading "D:" or leading "\". pFileNameInfo = (PFILE_NAME_INFORMATION)CoTaskMemAlloc( cbFileNameInfo ); nffMem( pFileNameInfo ); // Get the file name status = NtQueryInformationFile( _hFileMainStream, &IoStatusBlock, pFileNameInfo, cbFileNameInfo, FileNameInformation ); if( !NT_SUCCESS(status) ) { if( STATUS_BUFFER_OVERFLOW == status ) nffErr( EH_Err, CO_E_PATHTOOLONG); nffErr( EH_Err, NtStatusToScode( status ) ); } if( 0 == pFileNameInfo->FileNameLength ) nffErr( EH_Err, STG_E_INVALIDHEADER ); // Allocate and copy this filename for the return. // int cbFileName; int cchPrefix; cbFileName = pFileNameInfo->FileNameLength + (sizeof(WCHAR) * 3); nffMem( pwsz = (WCHAR*) CoTaskMemAlloc( cbFileName ) ); // Start with the Drive Letter or "\" for UNC paths if (IsCharAlphaW(_wcDriveLetter)) { pwsz[0] = _wcDriveLetter; pwsz[1] = L':'; pwsz[2] = L'\0'; cchPrefix = 2; } else { nffAssert( L'\\' == _wcDriveLetter ); pwsz[0] = L'\\'; pwsz[1] = L'\0'; cchPrefix = 1; } // Copy in the File Path we got from NT. We have a length and it is // not necessarily NULL terminated. // CopyMemory(&pwsz[cchPrefix], &pFileNameInfo->FileName, pFileNameInfo->FileNameLength ); // NULL terminiate the string. Assuming we got the length allocation // right, then the NULL just goes at the end. // pwsz[ cchPrefix + pFileNameInfo->FileNameLength/sizeof(WCHAR) ] = L'\0'; // Copy the Out Params And Clear the Temporaries. *ppwszPath = pwsz; pwsz = NULL; EH_Err: if( NULL != pFileNameInfo ) CoTaskMemFree( pFileNameInfo ); if( NULL != pwsz ) CoTaskMemFree( pwsz ); return sc; } //+---------------------------------------------------------------------------- // // CNtfsStorage non-interface TakeOplock // // There is no documentation for how this works. I exchanged // Email with the Filesystem SDEs and the FileSys Test SDEs and // I wrote some test programs to explore the functionality. // I also looked at Content Indexing's code (query\fsci\indexing\cioplock.cxx) // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::TakeOplock( const UNICODE_STRING& usName ) { HANDLE ev=NULL; HANDLE hFile=INVALID_HANDLE_VALUE; HRESULT sc=S_OK; nffChk( CheckReverted() ); // // If the event exists then the Oplock is already Set. // if( NULL != _ovlpOplock.hEvent ) return S_OK; // If we have no event, we should have no waiting thread. // nffAssert( NULL == _hOplockThread ); // Create the Event for the Oplock Wait Call. // ev = CreateEvent( NULL, // Security Attributes. TRUE, // Manual Reset Flag. FALSE, // Inital State = Signaled, Flag. NULL ); // Name if( NULL == ev) nffErr( EH_Err, LAST_SCODE ); _ovlpOplock.hEvent = ev; ev = NULL; nffChk( OpenNtFileHandle( usName, NULL, // No Parent File Handle STGM_READ_ATTRIBUTE, // Not a Real Flag. NFFOPEN_OPLOCK, FALSE, &hFile ) ); nffDebug(( DEB_ITRACE | DEB_OPLOCK, "Taking Oplock hFile=%x\n", hFile )); // // We should get FALSE / ERROR_IO_PENDING if the Oplock is taken // on the file. // if( DeviceIoControl( hFile, FSCTL_REQUEST_FILTER_OPLOCK, 0, 0, 0, 0, 0, &_ovlpOplock) ) { nffErr( EH_Err, E_UNEXPECTED); } else { if( ERROR_IO_PENDING != GetLastError() ) nffErr( EH_Err, LAST_SCODE ); } _hFileOplock = hFile; hFile = INVALID_HANDLE_VALUE; _dwState |= NFF_OPLOCKED; EH_Err: if( NULL != ev ) CloseHandle( ev ); if( INVALID_HANDLE_VALUE != hFile ) CloseHandle( hFile ); // If we couldn't get the oplock, treat it as a sharing violation if( NtStatusToScode(STATUS_OPLOCK_NOT_GRANTED) == sc ) sc = STG_E_SHAREVIOLATION; return sc; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::OplockWait // // The CNtfsStorage destructor will wait for this thread to finish, so we // know pThis-> still exists when we return from WaitForSingleObject(). // // We take the tree lock before calling ShutDownStorage. // //+---------------------------------------------------------------------------- DWORD WINAPI CNtfsStorage::OplockWait(PVOID pvThis) { nffXTrace( "CNtfsStorage::OplockWait" ); CNtfsStorage *pThis = static_cast(pvThis); DWORD dwReason; DWORD dwStatus; HRESULT sc=S_OK; BOOL rc; nffDebug(( DEB_OPLOCK, "Waiting on Oplock\n" )); rc = GetOverlappedResult( pThis->_hFileOplock, &(pThis->_ovlpOplock), &dwStatus, TRUE); #if DBG==1 WCHAR* pwcsPath=NULL; pThis->GetFilePath( &pwcsPath ); nffDebug(( DEB_OPLOCK, "Oplock Broke(%x,%x) '%ws'\n", rc, dwStatus, pwcsPath )); if(NULL != pwcsPath) CoTaskMemFree(pwcsPath); #endif pThis->Lock( INFINITE ); if( FALSE == rc ) { nffDebug(( DEB_ERROR, "Oplock thread broke for unknown status\n" )); sc = GetLastError(); // For Debugging; nffErr( EH_Err, E_UNEXPECTED ); } switch(dwStatus) { // Someone opened for read. case FILE_OPLOCK_BROKEN_TO_LEVEL_2: // File Opened for write or handle was closed. case FILE_OPLOCK_BROKEN_TO_NONE: break; default: nffDebug(( DEB_ERROR, "OplockWait, GetOLResult returned strange status %x\n", dwStatus )); break; } EH_Err: sc = pThis->ShutDownStorage(); pThis->Unlock(); return sc; } BOOL CNtfsStorage::IsControlStreamExtant( PFILE_STREAM_INFORMATION pfsiBuf ) { return IsNtStreamExtant( pfsiBuf, CNtfsStreamName( GetControlStreamName() )); } BOOL CNtfsStorage::AreAnyNtPropertyStreamsExtant( PFILE_STREAM_INFORMATION pfsiBuf ) { return FindStreamPrefixInFSI( pfsiBuf, L":\005" ); } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::OpenControlStream // // This stream is not a property set at the moment. Because we put one of // these on every file and it normally doesn't actually contain _any_ data we // feel that the overhead of 88 bytes for an empty PPSet was too great. // // An important role of the control property set is to the be first stream // (after the main stream) to be opened. The share mode of the container is // is expressed by the share mode of the control property set stream. //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::OpenControlStream( BOOL fCreateAPI ) { nffITrace( "CNtfsStorage::OpenControlPropertySet" ); HRESULT sc = S_OK; HANDLE hFile=INVALID_HANDLE_VALUE; NFFCONTROLBITS nffControlBits; DWORD cbDidRead=0; DWORD grfModeOpen=0; CNtfsStreamName ntfsnameControlStream( GetControlStreamName() ); CNtfsStreamName ntfsnameContentStream( GetContentStreamName() ); // We shouldn't be called more than once. // But we can handle it correctly here. // if( INVALID_HANDLE_VALUE != _hFileControlStream ) goto EH_Err; // Add STGM_CREATE flag in the open path (this is an internal only mode // that uses NT's OPEN_IF). // Don't add it in the Create path because that would mean OverWrite. // Don't add it in the ReadOnly case because it would create a stream. // grfModeOpen = _grfMode; if( !fCreateAPI && GrfModeIsWriteable( _grfMode ) ) grfModeOpen |= STGM_CREATE; sc = OpenNtStream( ntfsnameControlStream, grfModeOpen, NFFOPEN_SYNC, fCreateAPI, &hFile ); // // If we are a ReadOnly Open, then it is OK to not have a // control stream. // if( STG_E_FILENOTFOUND == sc ) { if( !fCreateAPI && !GrfModeIsWriteable( _grfMode ) ) { sc = S_OK; goto EH_Err; } } // // If we are not holding an Oplock then if we got a share vio then // try to break any other oplock that might be present. // Then try to open the control stream again. // if( 0 == (_dwState & NFF_OPLOCKED) ) { if( STG_E_SHAREVIOLATION == sc ) { // Open to break the lock. sc = OpenNtStream( ntfsnameContentStream, STGM_READWRITE | STGM_SHARE_DENY_NONE, NFFOPEN_CONTENTSTREAM, FALSE, // Not Create, just "Open" API &hFile ); // We don't really care if it succeeded or not. // But sure to close the file. if( SUCCEEDED(sc) ) { CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; } // Now try to really open again. Don't use OPEN_IF cause if we are // fighting over the stream then it must already exist. sc = OpenNtStream( ntfsnameControlStream, _grfMode, NFFOPEN_SYNC, fCreateAPI, &hFile ); } } // Catch any non-shareVio errors from the first OpenNtStream. // nffChk(sc); // If we're suppressing time and/or USN updates, // handle that suppression now. if( GrfModeIsWriteable( _grfMode ) ) { if(_dwState & NFF_NO_TIME_CHANGE) { nffAssert(_filetime.dwHighDateTime != 0); nffChk( CNtfsStream::SetFileHandleTime( hFile, NULL, NULL, &_filetime )); } if(_dwState & NFF_MARK_AUX) { // Assert that the AUX_DATA request data is init'ed correctly. // nffAssert( USN_SOURCE_AUXILIARY_DATA == _mhi.UsnSourceInfo ); nffChk( CNtfsStream::MarkFileHandleAux( hFile, _mhi )); } } // Set buffer to Zero so short reads are OK. ZeroMemory(&nffControlBits, sizeof(NFFCONTROLBITS) ); if( !ReadFile( hFile, &nffControlBits, sizeof(nffControlBits), &cbDidRead, NULL) ) { nffErr(EH_Err, LAST_SCODE); } // Currently we only support version 0 control streams. // Note: a zero length stream is a version zero stream. // if( 0 != nffControlBits.sig) nffErr(EH_Err, STG_E_INVALIDHEADER); _dwStgStateBits = nffControlBits.bits; _clsidStgClass = nffControlBits.clsid; _hsmStatus = nffControlBits.hsmStatus; _hFileControlStream = hFile; hFile = INVALID_HANDLE_VALUE; EH_Err: if(INVALID_HANDLE_VALUE != hFile) NtClose(hFile); return( sc ); } // CNtfsStorage::OpenControlPropertySet //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::DeleteControlStream // // Delete the control stream. // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::DeleteControlStream() { HRESULT sc = S_OK; HANDLE hStream = INVALID_HANDLE_VALUE; if( INVALID_HANDLE_VALUE != _hFileControlStream ) { if( !(_dwState & NFF_MARK_AUX) ) { nffChk( InitUsnInfo() ); nffChk( CNtfsStream::MarkFileHandleAux( _hFileControlStream, _mhi )); } nffChk( CNtfsStream::DeleteStream( &_hFileControlStream )); } else { nffChk( OpenNtStream( CNtfsStreamName( GetControlStreamName() ), STGM_READWRITE|STGM_SHARE_EXCLUSIVE, NFFOPEN_SYNC, FALSE, // Open API &hStream )); nffChk( InitUsnInfo() ); nffChk( CNtfsStream::MarkFileHandleAux( hStream, _mhi )); sc = CNtfsStream::DeleteStream( &hStream ); nffChk( sc ); } EH_Err: if( INVALID_HANDLE_VALUE != hStream ) NtClose( hStream ); return( sc ); } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::WriteControlStream // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::WriteControlStream() { NFFCONTROLBITS nffcb; LONG cbToWrite=0; ULONG cbDidWrite=0; HRESULT sc=S_OK; nffAssert( INVALID_HANDLE_VALUE != _hFileControlStream ); nffcb.sig = 0; nffcb.hsmStatus = _hsmStatus; nffcb.bits = _dwStgStateBits; nffcb.clsid = _clsidStgClass; // Try to save some space in the file by not writing the CLSID // if it is all zeros. // if( IsEqualGUID(_clsidStgClass, CLSID_NULL) ) { cbToWrite = FIELD_OFFSET(NFFCONTROLBITS, clsid); // Assert that clsid is the last thing in the struct. nffAssert( sizeof(NFFCONTROLBITS) == cbToWrite+sizeof(CLSID) ); } else cbToWrite = sizeof(NFFCONTROLBITS); if( -1 == SetFilePointer( _hFileControlStream, 0, NULL, FILE_BEGIN ) ) nffErr( EH_Err, LAST_SCODE ); if( !WriteFile( _hFileControlStream, &nffcb, cbToWrite, &cbDidWrite, NULL) ) { nffErr(EH_Err, LAST_SCODE); } EH_Err: return sc; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::StreamExists // The right way to do this is with enumeration. // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::StreamExists( const WCHAR *pwcsName ) { nffITrace( "CNtfsStorage::StreamExists" ); HANDLE hFileStream = NULL; HRESULT sc = S_OK; if( IsContentStream( pwcsName ) ) { // The Contents stream always exists sc = S_OK; } else { sc = OpenNtStream( CNtfsStreamName(pwcsName), STGM_READ_ATTRIBUTE | STGM_SHARE_DENY_NONE, NFFOPEN_NORMAL, FALSE, // Not a create API. &hFileStream); if( S_OK == sc ) { NtClose( hFileStream ); } else sc = S_FALSE; } return sc; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::SetAllStreamsTimes // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::SetAllStreamsTimes( const FILETIME *pctime, const FILETIME *patime, const FILETIME *pmtime) { HRESULT sc=S_OK; HRESULT scAccum=S_OK; CNtfsStream *pstm = NULL; nffDebug(( DEB_INFO | DEB_STATCTRL | DEB_ITRACE, "CNtfsStorage::SetAllStreamsTimes()\n" )); // Set the time on the main control stream. if( INVALID_HANDLE_VALUE != _hFileControlStream ) { sc = CNtfsStream::SetFileHandleTime( _hFileControlStream, pctime, patime, pmtime ); if( S_OK != sc ) scAccum = sc; } // We don't set time stamps on _hFileMainStream and _hFileOplock // Because they are readonly. (and _hFileOplock is not always open) // Now set the time on any CNtfsStream objects we have open. if( NULL != _pstmOpenList ) // Skip the head sentinal; pstm = _pstmOpenList->_pnffstmNext; while(NULL != pstm) { sc = pstm->SetStreamTime( pctime, patime, pmtime ); if( S_OK != sc ) scAccum = sc; pstm = pstm->_pnffstmNext; } return scAccum; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::MarkAllStreamsAux // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::MarkAllStreamsAux() { HRESULT sc=S_OK; HRESULT scAccum=S_OK; CNtfsStream *pstm = NULL; DWORD cbReturned=0; nffDebug(( DEB_INFO | DEB_STATCTRL | DEB_ITRACE, "CNtfsStorage::MarkAllStreamsAux()\n" )); // Initialize _mhi and _filetime sc = InitUsnInfo(); if( FAILED(sc) ) { scAccum = sc; goto EH_Err; } // Mark each of the handles we have open (not including // handles that are held by CNtfsStream objects). if( INVALID_HANDLE_VALUE != _hFileMainStream ) { sc = CNtfsStream::MarkFileHandleAux( _hFileMainStream, _mhi ); if( S_OK != sc ) scAccum = sc; } if( INVALID_HANDLE_VALUE != _hFileControlStream ) { sc = CNtfsStream::MarkFileHandleAux( _hFileControlStream, _mhi ); if( S_OK != sc ) scAccum = sc; } if( INVALID_HANDLE_VALUE != _hFileOplock ) { sc = CNtfsStream::MarkFileHandleAux( _hFileOplock, _mhi ); if( S_OK != sc ) scAccum = sc; } // Now give the open CNtfsStream objects an opportunity // to mark the aux bit. if( NULL != _pstmOpenList ) // Skip the head sentinal; pstm = _pstmOpenList->_pnffstmNext; while( NULL != pstm ) { sc = pstm->MarkStreamAux( _mhi ); if( S_OK != sc ) scAccum = sc; pstm = pstm->_pnffstmNext; } EH_Err: return scAccum; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::InitUsnInfo // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::InitUsnInfo() { HANDLE hVolume; WCHAR wszVolume[]=L"\\\\.\\Z:"; HRESULT sc=S_OK; if( USN_SOURCE_AUXILIARY_DATA == _mhi.UsnSourceInfo) return S_OK; if(L'\\' == _wcDriveLetter) nffErr( EH_Err, HRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION) ); wszVolume[4] = _wcDriveLetter; hVolume = CreateFile( wszVolume, FILE_WRITE_ATTRIBUTES, // Desired Access FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, // Security OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if(INVALID_HANDLE_VALUE == hVolume) { nffDebug(( DEB_ERROR, "Failed to Open Volume Handle. Aux Marking will Fail.\n" )); nffErr( EH_Err, LAST_SCODE ); } _mhi.UsnSourceInfo = USN_SOURCE_AUXILIARY_DATA; _mhi.VolumeHandle = hVolume; _mhi.HandleInfo = 0; EH_Err: return sc; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::InitCNtfsStream // // Create and Init an CNtfsStream Object. // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::InitCNtfsStream( CNtfsStream *pstm, HANDLE hStream, DWORD grfMode, const WCHAR * pwcsName ) { nffITrace("CNtfsStorage::InitCNtfsStream"); HRESULT sc=S_OK; // Attach the File Stream to the Stream Object nffChk( pstm->Init( hStream, grfMode, pwcsName, _pstmOpenList ) ); if( ( ( STGM_RDWR & grfMode ) == STGM_WRITE ) ||( ( STGM_RDWR & grfMode ) == STGM_READWRITE ) ) { // Note: modification time suppression is done per handle // so if that is turned on do that now. if(_dwState & NFF_NO_TIME_CHANGE) { nffAssert(_filetime.dwHighDateTime != 0); sc = pstm->SetStreamTime( NULL, NULL, &_filetime ); if(FAILED(sc)) { nffDebug(( 0 == dfwcsnicmp( pwcsName, GetContentStreamName(), -1 ) ? DEB_IERROR : DEB_ERROR, "Trouble %x Setting FileTime '%ws'\n", sc, pwcsName)); } } // Note: AUX_DATA marking is done per handle // so if that feature is turned on then do that now. if(_dwState & NFF_MARK_AUX) { // Assert that the AUX_DATA request data is init'ed correctly. // nffAssert( USN_SOURCE_AUXILIARY_DATA == _mhi.UsnSourceInfo ); sc = pstm->MarkStreamAux( _mhi ); if(FAILED(sc)) { nffDebug(( DEB_ERROR, "Trouble %x Setting AUX_DATA for '%ws'\n", sc, pwcsName)); } } } sc = S_OK; EH_Err: return sc; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::ModeToNtFlags // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::ModeToNtFlags(DWORD grfMode, DWORD dwFlags, BOOL fCreateAPI, ACCESS_MASK *pam, ULONG *pulAttributes, ULONG *pulSharing, ULONG *pulCreateDisposition, ULONG *pulCreateOptions) { SCODE sc=S_OK; nffDebug((DEB_ITRACE, "In ModeToNtFlags(" "%lX, %d %d, %p, %p, %p, %p, %p)\n", grfMode, dwFlags, fCreateAPI, pam, pulAttributes, pulSharing, pulCreateDisposition, pulCreateOptions)); *pam = 0; *pulAttributes = 0; *pulSharing = 0; *pulCreateDisposition = 0; *pulCreateOptions = 0; switch(grfMode & (STGM_READ | STGM_WRITE | STGM_READWRITE | STGM_READ_ATTRIBUTE)) { case STGM_READ: *pam = FILE_GENERIC_READ; break; case STGM_WRITE: *pam = FILE_GENERIC_WRITE; if( 0 == (NFFOPEN_CONTENTSTREAM & dwFlags) ) *pam |= DELETE; break; case STGM_READWRITE: *pam = FILE_GENERIC_READ | FILE_GENERIC_WRITE; if( 0 == (NFFOPEN_CONTENTSTREAM & dwFlags) ) *pam |= DELETE; break; case STGM_READ_ATTRIBUTE: *pam = FILE_READ_ATTRIBUTES; break; default: nffErr(EH_Err, STG_E_INVALIDFLAG); break; } switch(grfMode & (STGM_SHARE_DENY_NONE | STGM_SHARE_DENY_READ | STGM_SHARE_DENY_WRITE | STGM_SHARE_EXCLUSIVE)) { case STGM_SHARE_DENY_READ: *pulSharing = FILE_SHARE_WRITE | FILE_SHARE_DELETE; break; case STGM_SHARE_DENY_WRITE: *pulSharing = FILE_SHARE_READ; break; case STGM_SHARE_EXCLUSIVE: *pulSharing = 0; break; case STGM_SHARE_DENY_NONE: case 0: *pulSharing = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE; break; default: nffErr(EH_Err, STG_E_INVALIDFLAG); break; } switch(grfMode & (STGM_CREATE | STGM_FAILIFTHERE | STGM_CONVERT)) { case STGM_CREATE: if (fCreateAPI) *pulCreateDisposition = FILE_OVERWRITE_IF; else *pulCreateDisposition = FILE_OPEN_IF; // Illegal but used internaly break; case STGM_FAILIFTHERE: // this is a 0 flag if (fCreateAPI) *pulCreateDisposition = FILE_CREATE; else *pulCreateDisposition = FILE_OPEN; break; case STGM_CONVERT: nffDebug(( DEB_ERROR, "STGM_CONVERT illegal flag to NFF" )); nffErr(EH_Err, STG_E_INVALIDFLAG); break; default: nffErr(EH_Err, STG_E_INVALIDFLAG); break; } if( NFFOPEN_SYNC & dwFlags ) *pulCreateOptions |= FILE_SYNCHRONOUS_IO_NONALERT; if( NFFOPEN_OPLOCK & dwFlags ) *pulCreateOptions |= FILE_RESERVE_OPFILTER; *pulAttributes = FILE_ATTRIBUTE_NORMAL; sc = S_OK; nffDebug((DEB_ITRACE, "Out ModeToNtFlags\n")); EH_Err: return sc; } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::OpenNtStream // Used by NFF to open a named stream, relative to an exiting main // stream handle. // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::OpenNtStream( const CNtfsStreamName& nsnName, DWORD grfMode, DWORD dwFlags, BOOL fCreateAPI, HANDLE* phFile ) { UNICODE_STRING usNtfsStreamName; RtlInitUnicodeString(&usNtfsStreamName, (const WCHAR*)nsnName); return OpenNtFileHandle( usNtfsStreamName, _hFileMainStream, grfMode, dwFlags, fCreateAPI, phFile); } //+---------------------------------------------------------------------------- // // CNtfsStorage Non-Interface::OpenNtFileHandle // Common sub-code for OpenNtFile and OpenNtStream // //+---------------------------------------------------------------------------- HRESULT CNtfsStorage::OpenNtFileHandle( const UNICODE_STRING& usNtfsStreamName, HANDLE hParent, DWORD grfMode, DWORD dwFlags, BOOL fCreateAPI, HANDLE *phFile) { OBJECT_ATTRIBUTES object_attributes; IO_STATUS_BLOCK iostatusblock; HANDLE hStream; ACCESS_MASK accessmask=0; ULONG ulAttrs=0; ULONG ulSharing=0; ULONG ulCreateDisp=0; ULONG ulCreateOpt = 0; SCODE sc; NTSTATUS status; nffDebug(( DEB_ITRACE | DEB_OPENS, "OpenNtStream(%ws, %p, %lX, %d, %p)\n", usNtfsStreamName.Buffer, hParent, grfMode, fCreateAPI, phFile )); InitializeObjectAttributes(&object_attributes, (PUNICODE_STRING) &usNtfsStreamName, // cast away const OBJ_CASE_INSENSITIVE, hParent, NULL); nffChk( ModeToNtFlags( grfMode, dwFlags, fCreateAPI, &accessmask, &ulAttrs, &ulSharing, &ulCreateDisp, &ulCreateOpt ) ); status = NtCreateFile( &hStream, accessmask, &object_attributes, &iostatusblock, NULL, ulAttrs, ulSharing, ulCreateDisp, ulCreateOpt, NULL, 0); if (NT_SUCCESS(status)) { *phFile = hStream; sc = S_OK; } else sc = NtStatusToScode(status); EH_Err: nffDebug(( DEB_ITRACE | DEB_OPENS, "OpenNtFileHandle returns hFile=%x sc=%x status=%x\n", *phFile, sc, status)); return sc; } ////////////////////////////////////////////////////////////////////////// // // CNFFTreeMutex // ////////////////////////////////////////////////////////////////////////// //+---------------------------------------------------------------------------- // // CNFFTreeMutex IUnknown::QueryInterface // //+---------------------------------------------------------------------------- HRESULT CNFFTreeMutex::QueryInterface( REFIID riid, void ** ppvObject ) { //nffITrace( "CNFFTreeMutex::QueryInterface"); HRESULT sc = S_OK; // ---------- // Validation // ---------- VDATEREADPTRIN( &riid, IID ); VDATEPTROUT( ppvObject, void* ); *ppvObject = NULL; // ----- // Query // ----- if( IID_IUnknown == riid || IID_IBlockingLock == riid ) { *ppvObject = static_cast(this); AddRef(); } else sc = E_NOINTERFACE; return( sc ); } //+---------------------------------------------------------------------------- // // CNFFTreeMutex IUnknown::AddRef // //+---------------------------------------------------------------------------- ULONG STDMETHODCALLTYPE CNFFTreeMutex::AddRef(void) { LONG lRet; lRet = InterlockedIncrement( &_cRefs ); nffDebug(( DEB_REFCOUNT, "CNFFTreeMutex::AddRef(this==%x) == %d\n", this, lRet)); return( lRet ); } //+---------------------------------------------------------------------------- // // CNFFTreeMutex IUnknown::Release // //+---------------------------------------------------------------------------- ULONG STDMETHODCALLTYPE CNFFTreeMutex::Release(void) { LONG lRet; lRet = InterlockedDecrement( &_cRefs ); if( 0 == lRet ) delete this; nffDebug((DEB_REFCOUNT, "CNFFTreeMutex::Release(this=%x) == %d\n", this, lRet)); return( lRet ); } //+---------------------------------------------------------------------------- // // CNFFTreeMutex IBlockingLock::Lock // //+---------------------------------------------------------------------------- inline HRESULT CNFFTreeMutex::Lock( DWORD dwTimeout ) { // Don't trace at this level. The noice is too great! // nffCDbgTrace dbg(DEB_ITRACE, "CNFFTreeMutex::Lock"); nffAssert (_fInitialized == TRUE); nffAssert( INFINITE == dwTimeout ); if( INFINITE != dwTimeout ) return( E_NOTIMPL ); EnterCriticalSection( &_cs ); nffDebug(( DEB_ITRACE, "Tree Locked. cnt=%d\n", _cs.RecursionCount )); return( S_OK ); } //+---------------------------------------------------------------------------- // // CNFFTreeMutex IBlockingLock::Unlock // //+---------------------------------------------------------------------------- inline HRESULT CNFFTreeMutex::Unlock() { // Don't trace at this level. The noice is too great! //nffCDbgTrace dbg(DEB_ITRACE, "CNFFTreeMutex::Unlock"); nffAssert (_fInitialized == TRUE); LeaveCriticalSection( &_cs ); nffDebug(( DEB_ITRACE, "Tree Unlocked. cnt=%d\n", _cs.RecursionCount )); return( S_OK ); } #if DBG LONG CNFFTreeMutex::GetLockCount() { return( _cs.LockCount + 1 ); } #endif // #if DBG ////////////////////////////////////////////////////////////////////////// // // CNtfsEnumSTATSTG // ////////////////////////////////////////////////////////////////////////// //+---------------------------------------------------------------------------- // // Method: CNtfsEnumSTATSTG::QueryInterface (IUnknown) // //+---------------------------------------------------------------------------- HRESULT CNtfsEnumSTATSTG::QueryInterface( REFIID riid, void ** ppvObject ) { nffXTrace( "CNtfsEnumSTATSTG::QueryInterface" ); HRESULT sc = S_OK; // ---------- // Validation // ---------- VDATEREADPTRIN( &riid, IID ); VDATEPTROUT( ppvObject, void* ); // ----- // Query // ----- if( IID_IUnknown == riid || IID_IEnumSTATSTG == riid ) { *ppvObject = static_cast(this); AddRef(); } else { *ppvObject = NULL; sc = E_NOINTERFACE; } return( sc ); } //+---------------------------------------------------------------------------- // // Method: CNtfsEnumSTATSTG::AddRef (IUnknown) // //+---------------------------------------------------------------------------- ULONG CNtfsEnumSTATSTG::AddRef(void) { LONG lRet; lRet = InterlockedIncrement( &_cRefs ); nffDebug(( DEB_REFCOUNT, "CNtfsEnumSTATSTG::AddRef(this==%x) == %d\n", this, lRet)); return( lRet ); } //+---------------------------------------------------------------------------- // // Method: CNtfsEnumSTATSTG::Release (IUnknown) // //+---------------------------------------------------------------------------- ULONG CNtfsEnumSTATSTG::Release(void) { LONG lRet; lRet = InterlockedDecrement( &_cRefs ); nffAssert( 0 <= lRet ); if( 0 == lRet ) delete this; nffDebug((DEB_REFCOUNT, "CNtfsEnumSTATSTG::Release(this=%x) == %d\n", this, lRet)); return( lRet ); } //+---------------------------------------------------------------------------- // // Method: CNtfsEnumSTATSTG::Next (IEnumSTATSTG) // //+---------------------------------------------------------------------------- HRESULT STDMETHODCALLTYPE CNtfsEnumSTATSTG::Next(ULONG celt, STATSTG *prgstatstg, ULONG *pcFetched) { nffXTrace( "CNtfsEnumSTATSTG::Next" ); HRESULT sc = S_OK; NFF_VALIDATE( Next(celt, prgstatstg, pcFetched ) ); if( NULL != pcFetched ) *pcFetched = 0; // Compatibility requires we return S_OK when 0 elements are requested. if( 0 == celt ) return S_OK; _pBlockingLock->Lock( INFINITE ); sc = _pstatstgarray->NextAt( _istatNextToRead, prgstatstg, &celt ); if( FAILED(sc) ) goto Exit; _istatNextToRead += celt; if( NULL != pcFetched ) *pcFetched = celt; Exit: _pBlockingLock->Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // Method: CNtfsEnumSTATSTG::Skip (IEnumSTATSTG) // //+---------------------------------------------------------------------------- HRESULT STDMETHODCALLTYPE CNtfsEnumSTATSTG::Skip(ULONG celt) { nffXTrace( "CNtfsEnumSTATSTG::Skip" ); HRESULT sc = S_OK; NFF_VALIDATE( Skip( celt ) ); _pBlockingLock->Lock( INFINITE ); // Advance the index, but not past the end of the array if( _istatNextToRead + celt > _pstatstgarray->GetCount() ) { _istatNextToRead = _pstatstgarray->GetCount(); sc = S_FALSE; } else _istatNextToRead += celt; _pBlockingLock->Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // Method: CNtfsEnumSTATSTG::Reset (IEnumSTATSTG) // //+---------------------------------------------------------------------------- HRESULT STDMETHODCALLTYPE CNtfsEnumSTATSTG::Reset() { nffXTrace( "CNtfsEnumSTATSTG::Reset" ); _pBlockingLock->Lock( INFINITE ); _istatNextToRead = 0; _pBlockingLock->Unlock(); return( S_OK ); } //+---------------------------------------------------------------------------- // // Method: CNtfsEnumSTATSTG::Clone (IEnumSTATSTG) // //+---------------------------------------------------------------------------- HRESULT STDMETHODCALLTYPE CNtfsEnumSTATSTG::Clone(IEnumSTATSTG **ppenum) { nffXTrace( "CNtfsEnumSTATSTG::Clone" ); HRESULT sc = S_OK; NFF_VALIDATE( Clone( ppenum ) ); _pBlockingLock->Lock( INFINITE ); CNtfsEnumSTATSTG *pNtfsEnumSTATSTG = new CNtfsEnumSTATSTG(*this); if( NULL == pNtfsEnumSTATSTG ) { sc = E_OUTOFMEMORY; goto Exit; } *ppenum = static_cast(pNtfsEnumSTATSTG); pNtfsEnumSTATSTG = NULL; Exit: _pBlockingLock->Unlock(); if( NULL != pNtfsEnumSTATSTG ) delete pNtfsEnumSTATSTG; return( sc ); } //+---------------------------------------------------------------------------- // // Method: CNtfsEnumSTATSTG::ReadFileStreamInfo (private) // // This method reads the FileStreamInformation from the ContentStream. It // puts this buffer into a member pointer, for use in Next, etc. // //+---------------------------------------------------------------------------- HRESULT CNtfsSTATSTGArray::ReadFileStreamInfo( HANDLE hFile ) { nffITrace( "CNtfsStorage::ReadFileStreamInfo" ); PFILE_STREAM_INFORMATION pStreamInfo=NULL; PFILE_STREAM_INFORMATION pFSI=NULL; ULONG cbBuffer=0; ULONG cStreams=0; HRESULT sc=S_OK; sc = EnumNtStreams( hFile, &pStreamInfo, &cbBuffer, TRUE ); if( FAILED(sc) ) return sc; for(pFSI=pStreamInfo ; NULL != pFSI; pFSI=NextFSI( pFSI ) ) cStreams++; _pFileStreamInformation = pStreamInfo; _cFileStreamInformation = cStreams; return S_OK; } //+---------------------------------------------------------------------------- // // Method: CNtfsSTATSTGArray::Init (Internal method) // //+---------------------------------------------------------------------------- HRESULT CNtfsSTATSTGArray::Init( HANDLE hFile ) { nffITrace( "CNtfsSTATSTGArray::Init" ); HRESULT hr = S_OK; DfpAssert( NULL != _pBlockingLock ); _pBlockingLock->Lock( INFINITE ); if( NULL != _pFileStreamInformation ) { CoTaskMemFree( _pFileStreamInformation ); _pFileStreamInformation = NULL; _cFileStreamInformation = 0; } // Snapshot the stream information in _pFileStreamInformation hr = ReadFileStreamInfo( hFile ); if( FAILED(hr) ) goto Exit; Exit: _pBlockingLock->Unlock(); return( hr ); } //+---------------------------------------------------------------------------- // // Method: CNtfsSTATSTGArray::NextAt // //+---------------------------------------------------------------------------- HRESULT CNtfsSTATSTGArray::NextAt( ULONG iNext, STATSTG *prgstatstg, ULONG *pcFetched ) { nffITrace( "CNtfsSTATSTGArray::NextAt" ); HRESULT sc=S_OK; ULONG cFetched=0; ULONG cVisibleDataStreams=0; PFILE_STREAM_INFORMATION pFSI=NULL; const WCHAR* pwName=NULL; ULONG cbAlloc=0, cchLength=0; _pBlockingLock->Lock( INFINITE ); // If there is nothing to do skip out early. if( iNext >= _cFileStreamInformation ) { sc = S_FALSE; *pcFetched = 0; goto EH_Err; } // Loop through the cached stream info in _pFileStreamInformation for( pFSI=_pFileStreamInformation; NULL != pFSI; pFSI = NextFSI(pFSI) ) { if( cFetched >= *pcFetched ) break; // We are done. // We only handle data streams // if( !IsDataStream( pFSI ) ) continue; // We hide some of the streams (like the Control Stream) // if( IsHiddenStream( pFSI ) ) { continue; } // We are counting up to the requested streams. // if( iNext > cVisibleDataStreams++) continue; // Now lets unmangle the name no memory is allocated yet we just // move the pointer past the first ':' and return a shortened length. // Must be a $DATA Stream. Also invent "CONTENTS" if necessary. // pwName is not null terminated. // GetNtfsUnmangledNameInfo(pFSI, &pwName, &cchLength); // Yes, this is a data stream that we need to return. // Allocate a buffer for the stream name in the statstg. If this is // the unnamed stream, then we'll return it to the caller with the // name "Contents". cbAlloc = (cchLength + 1) * sizeof(WCHAR); // Allocate memory, copy and null terminate the string from the FSI. // nffMem( prgstatstg[cFetched].pwcsName = (WCHAR*) CoTaskMemAlloc( cbAlloc ) ); memcpy( prgstatstg[cFetched].pwcsName, pwName, cchLength*sizeof(WCHAR) ); prgstatstg[cFetched].pwcsName[ cchLength ] = L'\0'; // But Wait !!! // If this stream is really a non-simple property set, it's actually // a docfile, so let's return it as a STGTY_STORAGE, without the // name munging. if( IsDocfileStream( prgstatstg[cFetched].pwcsName )) { wcscpy( prgstatstg[cFetched].pwcsName, UnmangleDocfileStreamName( prgstatstg[cFetched].pwcsName )); prgstatstg[cFetched].type = STGTY_STORAGE; } else prgstatstg[cFetched].type = STGTY_STREAM; // Fill in the rest of the stream information. prgstatstg[cFetched].cbSize.QuadPart = static_cast(pFSI->StreamSize.QuadPart); // streams don't support timestamps yet prgstatstg[cFetched].mtime = prgstatstg[cFetched].ctime = prgstatstg[cFetched].atime = CFILETIME(0); prgstatstg[cFetched].grfMode = 0; prgstatstg[cFetched].grfLocksSupported = 0; // no locks supported prgstatstg[cFetched].grfStateBits = 0; prgstatstg[cFetched].clsid = CLSID_NULL; prgstatstg[cFetched].reserved = 0; // Advance the index of the next index the caller wants retrieved iNext++; // Advance the count of entries read cFetched++; } // ---- // Exit // ---- if( cFetched == *pcFetched ) sc = S_OK; else sc = S_FALSE; *pcFetched = cFetched; EH_Err: _pBlockingLock->Unlock(); return( sc ); } //+---------------------------------------------------------------------------- // // Routine GetDriveLetter // Return the drive letter from a path, or '\' for UNC paths. // //+---------------------------------------------------------------------------- WCHAR GetDriveLetter (WCHAR const *pwcsName) { nffITrace( "GetDriveLetter" ); if( pwcsName == NULL ) return( L'\0' ); if( pwcsName[0] != L'\0' ) { if( 0 == dfwcsnicmp( pwcsName, L"\\\\?\\", 4 ) && pwcsName[4] != L'\0' ) { if( pwcsName[5] == L':' ) return( pwcsName[4] ); else if( 0 == dfwcsnicmp( pwcsName, L"\\\\?\\UNC\\", -1 )) return( L'\\' ); } if( pwcsName[1] == L':' || pwcsName[0] == L'\\' && pwcsName[1] == L'\\' ) { return( pwcsName[0] ); } } // No drive letter in pathname, get current drive instead WCHAR wcsPath[MAX_PATH]; NTSTATUS nts = RtlGetCurrentDirectory_U (MAX_PATH*sizeof(WCHAR),wcsPath); if (NT_SUCCESS(nts)) return( wcsPath[0] ); return( L'\0' ); }; #if DBG HRESULT STDMETHODCALLTYPE CNtfsStorage::UseNTFS4Streams( BOOL fUseNTFS4Streams ) { return( E_NOTIMPL ); } #endif // #if DBG #if DBG HRESULT STDMETHODCALLTYPE CNtfsStorage::GetFormatVersion(WORD *pw) { return( E_NOTIMPL ); } #endif // #if DBG #if DBG HRESULT STDMETHODCALLTYPE CNtfsStorage::SimulateLowMemory( BOOL fSimulate ) { return( E_NOTIMPL ); } #endif // #if DBG #if DBG HRESULT STDMETHODCALLTYPE CNtfsStorage::GetLockCount() { return( _pTreeMutex->GetLockCount() ); } #endif // #if DBG #if DBG HRESULT STDMETHODCALLTYPE CNtfsStorage::IsDirty() { return( E_NOTIMPL ); } #endif // #if DBG //+--------------------------------------------------------------------------- // // Function: EnumNtStreams // // Synopsis: Enumerate NT stream information // // Arguments: [h] -- Handle to rename // [ppfsi] -- buffer to hold stream information // [pulBufferSize] -- size of output buffer // [fGrow] -- FALSE for fixed size buffer // // Returns: Appropriate status code // // Notes : // // History: 1-Apr-98 HenryLee Created // //---------------------------------------------------------------------------- HRESULT EnumNtStreams (HANDLE h, FILE_STREAM_INFORMATION ** ppfsi, ULONG *pulBufferSize, BOOL fGrow) { HRESULT sc = S_OK; NTSTATUS nts; IO_STATUS_BLOCK iosb; nffAssert (pulBufferSize != NULL); ULONG ulStreamInfoSize = 2048; FILE_STREAM_INFORMATION *pfsi; *ppfsi = NULL; *pulBufferSize = 0; do { nffMem (pfsi = (FILE_STREAM_INFORMATION*) new BYTE[ulStreamInfoSize]); nts = NtQueryInformationFile(h, &iosb, (VOID*) pfsi, ulStreamInfoSize - sizeof (L'\0'), FileStreamInformation ); if ( !NT_SUCCESS(nts) ) { // We failed the call. Free up the previous buffer and set up // for another pass with a buffer twice as large delete [] (BYTE *)pfsi; pfsi = NULL; ulStreamInfoSize *= 2; } if (fGrow == FALSE) break; } while (nts == STATUS_BUFFER_OVERFLOW || nts == STATUS_BUFFER_TOO_SMALL); if (NT_SUCCESS(nts)) { if (iosb.Information == 0) // no data returned { delete [] (BYTE *) pfsi; *ppfsi = NULL; *pulBufferSize = 0; } else { *ppfsi = pfsi; *pulBufferSize = iosb.Status; } } else { sc = NtStatusToScode(nts); } EH_Err: return sc; } //+--------------------------------------------------------------------------- // // Function: FindStreamInFSI // // Synopsis: Find a Stream name in a provided Enumeration Buffer // // Arguments: [ppfsi] -- buffer that holds the stream enumeration. // [pwszNtStreamName] -- Name to look for, in :*:$DATA form. // // Returns: Pointer to the found element, or NULL otherwise // //---------------------------------------------------------------------------- const FILE_STREAM_INFORMATION * FindStreamInFSI( IN const FILE_STREAM_INFORMATION *pfsi, IN const WCHAR *pwszNtStreamName // In :*:$data format ) { ULONG cchLength = wcslen(pwszNtStreamName); for( ; NULL != pfsi; pfsi= NextFSI(pfsi) ) { if( cchLength*sizeof(WCHAR) != pfsi->StreamNameLength ) continue; if( 0 == dfwcsnicmp( pwszNtStreamName, pfsi->StreamName, cchLength )) break; } return( pfsi ); } //+--------------------------------------------------------------------------- // // Function: IsStreamPrefixInFSI // // Synopsis: Find a Stream with the given prefix in a provided // Enumeration Buffer // // Arguments: [ppfsi] -- buffer that holds the stream enumeration. // [pwszPrefix] -- Prefix to find. // // Returns: TRUE if it finds it, FALSE otherwise. // //---------------------------------------------------------------------------- BOOL FindStreamPrefixInFSI( IN const FILE_STREAM_INFORMATION *pfsi, IN const WCHAR *pwszPrefix ) { ULONG cchLength = wcslen(pwszPrefix); for( ; NULL != pfsi; pfsi= NextFSI(pfsi) ) { if( cchLength*sizeof(WCHAR) > pfsi->StreamNameLength ) continue; if( 0 == dfwcsnicmp( pwszPrefix, pfsi->StreamName, cchLength )) return TRUE; } return FALSE; }