//+--------------------------------------------------------------------------- // // Microsoft Windows // Copyright (c) Microsoft Corporation, 1991 - 1999. // // File: catalog.hxx // // Contents: Catalog abstraction // // Classes: PCatalog -- The catalog abstraction // // History: 30-May-91 SethuR Created. // 14-Sep-92 AmyA Added AddSubObject(). // 08-Apr-98 KitmanH Added SetCatState(). // // Notes: For each of the classes defined in this file two methods // have been defined but not implemented. These methods are // declared as private methods of the class. In general for a // class CFoo the signatures of these methods are as follows. // // CFoo(const CFoo& foo); // CFoo& operator = (const CFoo& foo); // // This effectively implies that these classes cannot be copied // or references to this class cannot be used as a lvalue in a // assignment statement. If we desire to change this behaviour // for a specific class these methods should be made public for // those classes. // //---------------------------------------------------------------------------- #pragma once typedef ULONG SDID; const SDID sdidNull = 0; const SDID sdidInvalid = 0xFFFFFFFF; class PStorage; class CFullPropSpec; class CStorageVariant; class CRWStore; class CPidMapper; class CPidRemapper; class CCompositePropRecord; class CCiScopeTable; class CImpersonationTokenCache; class CScopeFixup; class CFunnyPath; #define CI_UPDATE_OBJ 0x0001 #define CI_UPDATE_PROPS 0x0002 #define CI_DELETE_OBJ 0x0004 #define CI_SCAN_UPDATE 0x8000 #define UPD_INCREM 0 #define UPD_FULL 1 #define UPD_INIT 2 class PCatalog { public: PCatalog() {} virtual ~PCatalog() {} virtual unsigned WorkIdToPath ( WORKID wid, CFunnyPath& funnyPath ) = 0; virtual unsigned WorkIdToAccuratePath ( WORKID wid, CLowerFunnyPath& funnyPath ); virtual WORKID PathToWorkId ( const CLowerFunnyPath & lcaseFunnyPath, const BOOL fCreate ) = 0; virtual PROPID PropertyToPropId ( CFullPropSpec const & ps, BOOL fCreate = FALSE ) = 0; virtual BOOL EnumerateProperty( CFullPropSpec & ps, unsigned & cbInCache, ULONG & type, DWORD & dwStoreLevel, BOOL & fModifiable, unsigned & iBmk ); virtual ULONG_PTR BeginCacheTransaction(); virtual void SetupCache( CFullPropSpec const & ps, ULONG vt, ULONG cbMaxLen, ULONG_PTR ulToken, DWORD dwStoreLevel ); virtual void EndCacheTransaction( ULONG_PTR ulToken, BOOL fCommit ); virtual BOOL StoreValue( WORKID wid, CFullPropSpec const & ps, CStorageVariant const & var ); virtual BOOL FetchValue( WORKID wid, PROPID pid, PROPVARIANT * pbData, unsigned * pcb ); virtual BOOL FetchValue( CCompositePropRecord & Rec, PROPID pid, PROPVARIANT * pbData, BYTE * pbExtra, unsigned * pcb ) { return FALSE; } virtual BOOL FetchValue( WORKID wid, CFullPropSpec const & ps, PROPVARIANT & var ); virtual BOOL FetchValue( CCompositePropRecord * pRec, PROPID pid, PROPVARIANT * pbData, unsigned * pcb ); virtual BOOL FetchValue( CCompositePropRecord * pRec, PROPID pid, PROPVARIANT & var ) { return FALSE; } virtual CCompositePropRecord * OpenValueRecord( WORKID wid, BYTE * pb ); virtual void CloseValueRecord( CCompositePropRecord * pRec ); virtual BOOL StoreSecurity( WORKID wid, PSECURITY_DESCRIPTOR pSD, ULONG cbSD ); virtual SDID FetchSDID( CCompositePropRecord * pRec, WORKID wid ); virtual BOOL AccessCheck( SDID sdid, HANDLE hToken, ACCESS_MASK am, BOOL & fGranted ); virtual void MarkUnReachable( WORKID wid ) {} virtual CRWStore * ComputeRelevantWords(ULONG cRows,ULONG cRW, WORKID *pwid, PARTITIONID partid) = 0; virtual CRWStore * RetrieveRelevantWords(BOOL fAcquire, PARTITIONID partid) = 0; virtual PStorage& GetStorage() = 0; virtual unsigned ReserveUpdate( WORKID wid ) = 0; virtual void Update( unsigned iHint, WORKID wid, PARTITIONID partid, USN usn, ULONG flags ) = 0; virtual void CatalogState( ULONG & cDocuments, ULONG & cPendingScans, ULONG & fState ); virtual void UpdateDocuments( WCHAR const* rootPath=0, ULONG flag=UPD_FULL ) = 0; virtual void AddScopeToCI( WCHAR const * rootPath ) {} virtual void RemoveScopeFromCI( WCHAR const * rootPath ) {} // // Centralized error handling during queries // virtual void HandleError( NTSTATUS status ) {} virtual unsigned WorkIdToVirtualPath( WORKID wid, unsigned cSkip, XGrowable & xBuf ); virtual unsigned WorkIdToVirtualPath( CCompositePropRecord & propRec, unsigned cSkip, XGrowable & xBuf ) { if ( 0 != xBuf.Count() ) xBuf[0] = 0; return 0; } virtual BOOL VirtualToPhysicalRoot( WCHAR const * pwcVPath, unsigned ccVPath, XGrowable & xwcsVRoot, unsigned & ccVRoot, CLowerFunnyPath & lcaseFunnyPRoot, unsigned & ccPRoot, unsigned & iBmk ); virtual BOOL VirtualToAllPhysicalRoots( WCHAR const * pwcVPath, unsigned ccVPath, XGrowable & xwcsVRoot, unsigned & ccVRoot, CLowerFunnyPath & lcaseFunnyPRoot, unsigned & ccPRoot, ULONG & ulType, unsigned & iBmk ); enum RootType { ManualRoot = 1, // Root added manually AutomaticRoot = 2, // Root in Gibraltar UsedRoot = 4, // Root in use for mapping NNTPRoot = 8, // Root from NNTP, not W3SVC NonIndexedVDir = 0x10, // Virtual Directory, not indexed IMAPRoot = 0x20, // Root from IMAP, not nntp or w3 EndRoot = 0xFFFFFFFF // End of iteration }; virtual ULONG EnumerateVRoot( XGrowable & xwcVRoot, unsigned & ccVRoot, CLowerFunnyPath & lcaseFunnyPRoot, unsigned & ccPRoot, unsigned & iBmk ); // // Partition support. // virtual void SetPartition( PARTITIONID PartId ) = 0; virtual PARTITIONID GetPartition() const = 0; virtual SCODE CreateContentIndex() = 0; virtual void EmptyContentIndex() = 0; virtual void ShutdownPhase1() {} virtual void ShutdownPhase2() {} virtual NTSTATUS ForceMerge( PARTITIONID partID ) { Win4Assert( !"Must be overriden" ); return 0; } virtual NTSTATUS AbortMerge( PARTITIONID partID ) { Win4Assert( !"Must be overriden" ); return 0; } virtual NTSTATUS SetCatState( PARTITIONID partID, DWORD dwNewState, DWORD * pdwOldState ) { Win4Assert( !"Must be overriden" ); return 0; } #if CIDBG == 1 virtual void DumpWorkId( WORKID wid, ULONG iid, BYTE * pb, ULONG cb ) {} #endif // Get the drive letter of the catalog path virtual WCHAR * GetDriveName() = 0; virtual void PidMapToPidRemap( const CPidMapper & pidMap, CPidRemapper & pidRemap ) = 0; virtual NTSTATUS CiState( CI_STATE & state ) = 0; virtual void FlushScanStatus() = 0; virtual BOOL IsEligibleForFiltering( WCHAR const* wcsDirPath ); virtual CCiRegParams * GetRegParams() = 0; virtual CScopeFixup * GetScopeFixup() = 0; virtual unsigned FixupPath( WCHAR const * pwcOriginal, WCHAR * pwcResult, unsigned cwcResult, unsigned cSkip ) { // default behavior -- just copy if there is room unsigned cwc = 1 + wcslen( pwcOriginal ); if ( cwcResult >= cwc ) { RtlCopyMemory( pwcResult, pwcOriginal, cwc * sizeof WCHAR ); return cwc; } return cwc; } virtual void InverseFixupPath( CLowerFunnyPath & lcaseFunnyPath ) { // do nothing } virtual CCiScopeTable * GetScopeTable() { Win4Assert( 0 && "not implemented" ); return 0; } virtual CImpersonationTokenCache * GetImpersonationTokenCache() { Win4Assert( 0 && "not implemented" ); return 0; } virtual WCHAR const * GetCatalogName() { return 0; } virtual BOOL IsNullCatalog() = 0; }; inline unsigned PCatalog::WorkIdToAccuratePath( WORKID wid, CLowerFunnyPath& funnyPath ) { // Default: Can't accurately translate wid to path. return WorkIdToPath( wid, funnyPath ); } inline void PCatalog::CatalogState( ULONG & cDocuments, ULONG & cPendingScans, ULONG & fState ) { // Default: Can't count. cDocuments = 0; cPendingScans = 0; fState = 0; } inline BOOL PCatalog::EnumerateProperty( CFullPropSpec & ps, unsigned & cbInCache, ULONG & type, DWORD & dwStoreLevel, BOOL & fModifiable, unsigned & iBmk ) { // Default: Can't enumerate return FALSE; } inline ULONG_PTR PCatalog::BeginCacheTransaction() { THROW( CException( STATUS_NOT_IMPLEMENTED ) ); return 0; } inline void PCatalog::SetupCache( CFullPropSpec const & ps, ULONG vt, ULONG cbMaxLen, ULONG_PTR ulToken, DWORD dwStoreLevel ) { THROW( CException( STATUS_NOT_IMPLEMENTED ) ); } inline void PCatalog::EndCacheTransaction( ULONG_PTR ulToken, BOOL fCommit ) { THROW( CException( STATUS_NOT_IMPLEMENTED ) ); } inline BOOL PCatalog::StoreValue( WORKID wid, CFullPropSpec const & ps, CStorageVariant const & var ) { // Default: Don't store values. return FALSE; } inline BOOL PCatalog::FetchValue( WORKID wid, PROPID pid, PROPVARIANT * pbData, unsigned * pcb ) { // Default: No property cache. return FALSE; } inline BOOL PCatalog::FetchValue( WORKID wid, CFullPropSpec const & ps, PROPVARIANT & var ) { // Default: No property cache. return FALSE; } inline BOOL PCatalog::FetchValue( CCompositePropRecord * pRec, PROPID pid, PROPVARIANT * pbData, unsigned * pcb ) { // Default: No property cache. return FALSE; } inline CCompositePropRecord * PCatalog::OpenValueRecord( WORKID wid, BYTE * pb ) { // Default: No property cache. return 0; } inline void PCatalog::CloseValueRecord( CCompositePropRecord * pRec ) { // Default: No property cache. } inline unsigned PCatalog::WorkIdToVirtualPath( WORKID wid, unsigned cSkip, XGrowable & xBuf ) { // Default: No support for virtual paths return 0; } inline BOOL PCatalog::VirtualToPhysicalRoot( WCHAR const * pwcVPath, unsigned ccVPath, XGrowable & xwcsVRoot, unsigned & ccVRoot, CLowerFunnyPath & lcaseFunnyPRoot, unsigned & ccPRoot, unsigned & iBmk ) { // Default: No support for virtual paths return FALSE; } inline BOOL PCatalog::VirtualToAllPhysicalRoots( WCHAR const * pwcVPath, unsigned ccVPath, XGrowable & xwcsVRoot, unsigned & ccVRoot, CLowerFunnyPath & lcaseFunnyPRoot, unsigned & ccPRoot, ULONG & ulType, unsigned & iBmk ) { // Default: No support for virtual paths return FALSE; } inline ULONG PCatalog::EnumerateVRoot( XGrowable & xwcVRoot, unsigned & ccVRoot, CLowerFunnyPath & lcaseFunnyPRoot, unsigned & ccPRoot, unsigned & iBmk ) { // Default: No support for virtual paths return (ULONG) PCatalog::EndRoot; } inline BOOL PCatalog::StoreSecurity( WORKID wid, PSECURITY_DESCRIPTOR pSD, ULONG cbSD ) { // Default: Don't store security information. return FALSE; } inline SDID PCatalog::FetchSDID( CCompositePropRecord * pRec, WORKID wid ) { // Default: No cached security descriptor. return sdidNull; } inline BOOL PCatalog::AccessCheck( SDID sdid, HANDLE hToken, ACCESS_MASK am, BOOL & fGranted ) { // Default: No cached security descriptor. return FALSE; } inline BOOL PCatalog::IsEligibleForFiltering( WCHAR const* wcsDirPath ) { // Default: All files eligible for filtering return TRUE; } class XCompositeRecord { public: XCompositeRecord( PCatalog & cat, CCompositePropRecord * pPropRec = 0 ) : _cat( cat ), _pPropRec( pPropRec ) {} XCompositeRecord( PCatalog & cat, WORKID wid, BYTE * pBuf ) : _cat( cat ) { _pPropRec = _cat.OpenValueRecord( wid, pBuf ); } ~XCompositeRecord() { Free(); } void Free() { if ( 0 != _pPropRec ) { _cat.CloseValueRecord( _pPropRec ); _pPropRec = 0; } } void Set( CCompositePropRecord * pPropRec ) { Win4Assert( 0 == _pPropRec ); _pPropRec = pPropRec; } CCompositePropRecord * Acquire() { CCompositePropRecord * p = _pPropRec; _pPropRec = 0; return p; } CCompositePropRecord * Get() { return _pPropRec; } private: CCompositePropRecord * _pPropRec; PCatalog & _cat; };