windows-xp/Source/XPSP1/NT/inetsrv/query/cicat/cicat.hxx

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1991 - 2000.
//
//  File:       CICAT.HXX
//
//  Contents:   File catalog
//
//  History:    09-Mar-92   BartoszM    Created
//              15-Mar-93   BartoszM    Converted to memory mapped streams
//
//----------------------------------------------------------------------------

#pragma once

#include <dynstrm.hxx>
#include <catalog.hxx>
#include <spropmap.hxx>
#include <secstore.hxx>
#include <doclist.hxx>
#include <imprsnat.hxx>
#include <ciintf.h>
#include <workman.hxx>
#include <cistore.hxx>
#include <pidtable.hxx>
#include <prpstmgr.hxx>
#include <ntopen.hxx>
#include <notifary.hxx>

#include "statmon.hxx"
#include "chash.hxx"
#include "notifmgr.hxx"
#include "scopetbl.hxx"
#include "scanmgr.hxx"
#include "scpfixup.hxx"
#include "signore.hxx"
#include "usnlist.hxx"
#include "usnmgr.hxx"
#include "filidmap.hxx"
#include "volinfo.hxx"

class CClientDocStore;
class CCompositePropRecord;
class CPrimaryPropRecord;
class CDynLoadNetApi32;

#include "strings.hxx"

WCHAR const CAT_DIR[]          = L"\\catalog.wci";
WCHAR const SETUP_DIR_PREFIX[] = L"\\$WIN_NT$.~";

//
// The path given for the catalog should leave room for \Catalog.Wci\8.3
// Leave room for 2 8.3 names with a backslash.
//
const MAX_CAT_PATH = MAX_PATH - 13*2;

void  UpdateDuringRecovery( WORKID wid, BOOL fDelete, void const *pUserData );

//+---------------------------------------------------------------------------
//
//  Class:      CScopeEntry
//
//  Purpose:    Maintains a scope entry to rescan
//
//  History:    4/3/98      mohamedn    created
//----------------------------------------------------------------------------

class CScopeEntry
{
public:

    CScopeEntry(WCHAR const * pwszScope);

    BOOL SetToParentDirectory(void);

    BOOL ContainsSpecialChar(void) { return _fContainsSpecialChar; }

    WCHAR const * Get(void) { return _xwcsPath.Get(); }

private:

    WCHAR *   GetSpecialCharLocation(void);
    BOOL      IsSpecialChar(WCHAR c);
    BOOL      IsRoot(void);

    BOOL      _fContainsSpecialChar;
    XGrowable<WCHAR> _xwcsPath;
    unsigned  _cclen;

};


//+---------------------------------------------------------------------------
//
//  Class:      CiCat
//
//  Purpose:    Catalog for downlevel media used by content index
//
//  History:    10-Mar-92       BartoszM               Created
//              17-Feb-98       KitmanH                Added public function
//                                                     IsReadOnly()
//----------------------------------------------------------------------------

class CiCat: public PCatalog
{
    friend class CUpdate;
    friend class CRegistryScopesCallBackAdd;
    friend class CRegistryScopesCallBackFixups;
    friend class CRegistryScopesCallBackRemoveAlias;
    friend class CUserPropCallback;

    friend class CClientDocStore;
    friend class CGibCallBack;

public:

    CiCat ( CClientDocStore & docStore,
            CWorkManager & workMan,
            const WCHAR* wcsCatPath,
            BOOL &fVersionChange,
            BOOL fOpenForReadOnly,
            CDrvNotifArray & DrvNotifArray,
            const WCHAR * pwcName,
            BOOL fLeaveCorruptCatalog );

    ~CiCat ();

    const WCHAR * GetName() { return _xName.Get(); }
    const WCHAR * GetCatalogName() { return _xName.Get(); }
    const WCHAR * GetScopesKey() { return _xScopesKey.Get(); }

    PROPID PropertyToPropId ( CFullPropSpec const & ps, BOOL fCreate = FALSE );

    unsigned WorkIdToPath ( WORKID wid, CFunnyPath & funnyPath );

    unsigned WorkIdToAccuratePath ( WORKID wid, CLowerFunnyPath & funnyPath );

    BOOL PropertyRecordToFileId( CCompositePropRecord & PropRec,
                                 FILEID & fileId,
                                 VOLUMEID & volumeId );


    WORKID PathToWorkId ( const CLowerFunnyPath & lcaseFunnyPath,
                          BOOL fCreate,
                          BOOL & fNew,
                          FILETIME * pftLastSeen,
                          ESeenArrayType eType,
                          FILEID fileId,
                          WORKID widParent = widInvalid,
                          BOOL fGuaranteedNew = FALSE );

    WORKID PathToWorkId( const CLowerFunnyPath & lcaseFunnyPath,
                         const BOOL fCreate )
    {
        BOOL fNew;
        return PathToWorkId( lcaseFunnyPath, fCreate, fNew, 0, eScansArray, fileIdInvalid );
    }

    WORKID PathToWorkId ( const CLowerFunnyPath & lcaseFunnyPath,
                          ESeenArrayType eType,
                          FILEID fileId = fileIdInvalid )
    {
        BOOL fNew;
        return PathToWorkId( lcaseFunnyPath, TRUE, fNew, 0, eType, fileId );
    }

    void  RenameFile( const CLowerFunnyPath & lcaseFunnyOldName,
                      const CLowerFunnyPath & lcaseFunnyNewName,
                      ULONG         ulFileAttrib,
                      VOLUMEID      volumeId,
                      FILEID        fileId,
                      WORKID        widParent = widInvalid );

    void WriteFileAttributes( WORKID wid, ULONG ulFileAttrib )
    {
         PROPVARIANT propVar;

         propVar.vt = VT_UI4;
         propVar.ulVal = ulFileAttrib;
         _propstoremgr.WriteProperty( wid,
                                      pidAttrib,
                                      *(CStorageVariant const *)(ULONG_PTR)&propVar );
    }

    PStorage& GetStorage ();

    void FlushPropertyStore()
    {
        if ( _propstoremgr.IsBackedUpMode() )
            _propstoremgr.Flush();
    }

    void  Update( const CLowerFunnyPath & lowerFunnyPath,
                  BOOL fDeleted,
                  FILETIME const & ftLastSeen,
                  ULONG ulFileAttrib );
    void  Update( const CLowerFunnyPath & lowerFunnyPath,
                  FILEID fileId,
                  WORKID widParent,
                  USN usn,
                  CUsnVolume *pUsnVolume,
                  BOOL fDeleted,
                  CReleasableLock * pLock = 0 );

    void LokMarkForDeletion( FILEID fileId,
                             WORKID wid );

    void  AddDocuments( CDocList const & docList );

    void  ReScanPath( WCHAR const * wcsPath, BOOL fDelayed );

    BOOL  EnumerateProperty( CFullPropSpec & ps, unsigned & cbInCache,
                             ULONG & type, DWORD & dwStoreLevel,
                             BOOL & fIsModifiable, unsigned & iBmk );

    void  ClearNonStoragePropertiesForWid( WORKID wid );

    //
    // Cache metadata changes
    //

    ULONG_PTR BeginCacheTransaction();

    void  SetupCache( CFullPropSpec const & ps,
                     ULONG vt,
                     ULONG cbMaxLen,
                     ULONG_PTR ulToken,
                     BOOL  fCanBeModified,
                     DWORD dwStoreLevel );

    void  EndCacheTransaction( ULONG_PTR ulToken, BOOL fCommit );

    BOOL IsPropertyCached( CFullPropSpec const & ps )
    {
        Win4Assert( !"Not Yet Implemented" );
        return FALSE;
    }

    BOOL StoreValue( WORKID wid,
                     CFullPropSpec const & ps,
                     CStorageVariant const & var );

    BOOL FetchValue( WORKID wid,
                     PROPID pid,
                     PROPVARIANT * pbData,
                     unsigned * pcb );

    BOOL FetchValue( CCompositePropRecord & Rec,
                     PROPID pid,
                     PROPVARIANT * pbData,
                     BYTE * pbExtra,
                     unsigned * pcb );

    BOOL FetchValue( WORKID wid,
                     CFullPropSpec const & ps,
                     PROPVARIANT & var );

    BOOL FetchValue( CCompositePropRecord * pRec,
                     PROPID pid,
                     PROPVARIANT * pbData,
                     unsigned * pcb );

    BOOL FetchValue( CCompositePropRecord * pRec,
                     PROPID pid,
                     PROPVARIANT & var );

    CCompositePropRecord * OpenValueRecord( WORKID wid, BYTE * pb );
    void CloseValueRecord( CCompositePropRecord * pRec );

    BOOL  StoreSecurity( WORKID wid,
                         PSECURITY_DESCRIPTOR pSD,
                         ULONG cbSD );

    SDID  FetchSDID( CCompositePropRecord * pRec,
                     WORKID wid );

    void  MarkUnReachable( WORKID wid );    // virtual

    BOOL  AccessCheck( SDID   sdid,
                       HANDLE hToken,
                       ACCESS_MASK am,
                       BOOL & fGranted );

    void  Delete( WORKID wid, USN usn ) {}
    void  UpdateDocuments ( WCHAR const* rootPath=0, ULONG flag=UPD_FULL );

    void CatalogState( ULONG & cDocuments, ULONG & cPendingScans, ULONG & fState );

    void  AddScopeToCI( WCHAR const * rootPath, BOOL fFromVirtual = FALSE )
    {
        ScanOrAddScope( rootPath, TRUE, UPD_FULL, FALSE, TRUE, fFromVirtual );
    }

    DWORD ReScanCIScope( WCHAR const * rootPath, BOOL fFull );

    void ScanOrAddScope( WCHAR const * rootPath,
                         BOOL fAdd,
                         ULONG flag,
                         BOOL fDoDeletions,
                         BOOL fScanIfNotNew,
                         BOOL fCreateShadow = FALSE );

    void RemoveScopeFromCI( WCHAR const * rootPath, BOOL fForceRemovalScan );

    void  RemovePathsFromCiCat( WCHAR const * rootPath, ESeenArrayType eType );

    BOOL IsScopeInCI( WCHAR const * wcsScope );

    BOOL AddVirtualScope( WCHAR const * vroot,
                          WCHAR const * root,
                          BOOL          fAutomatic,
                          CiVRootTypeEnum eType,
                          BOOL          fIsVRoot,
                          BOOL          fIsIndexed );

    BOOL RemoveVirtualScope( WCHAR const * vroot,
                             BOOL          fOnlyIfAutomatic,
                             CiVRootTypeEnum eType,
                             BOOL            fIsVRoot,
                             BOOL            fForceVPathFixing = FALSE );

    unsigned WorkIdToVirtualPath( WORKID wid,
                                  unsigned cSkip,
                                  XGrowable<WCHAR> & xBuf );

    unsigned WorkIdToVirtualPath( CCompositePropRecord & propRec,
                                  unsigned cSkip,
                                  XGrowable<WCHAR> & xBuf );

    BOOL VirtualToPhysicalRoot( WCHAR const * pwcVPath,
                                unsigned ccVPath,
                                XGrowable<WCHAR> & xwcsVRoot,
                                unsigned & ccVRoot,
                                CLowerFunnyPath & lcaseFunnyPRoot,
                                unsigned & ccPRoot,
                                unsigned & iBmk );

    inline BOOL VirtualToAllPhysicalRoots( WCHAR const * pwcVPath,
                                           unsigned ccVPath,
                                           XGrowable<WCHAR> & xwcsVRoot,
                                           unsigned & ccVRoot,
                                           CLowerFunnyPath & lcaseFunnyPRoot,
                                           unsigned & ccPRoot,
                                           ULONG & ulType,
                                           unsigned & iBmk );

    ULONG EnumerateVRoot( XGrowable<WCHAR> & xwcVRoot,
                          unsigned & ccVRoot,
                          CLowerFunnyPath & lcaseFunnyPRoot,
                          unsigned & ccPRoot,
                          unsigned & iBmk );

    virtual SCODE CreateContentIndex();
    virtual void  EmptyContentIndex();
    virtual void  ShutdownPhase1();
    virtual void  ShutdownPhase2();

    NTSTATUS ForceMerge( PARTITIONID partID );
    NTSTATUS AbortMerge( PARTITIONID partID );

    void DumpWorkId( WORKID wid, ULONG iid, BYTE * pb, ULONG cb );

    void  StartUpdate ( FILETIME* time,
                        WCHAR const * pwcsScope,
                        BOOL fDoDeletions,
                        ESeenArrayType eType );

    void  Touch ( WORKID wid, ESeenArrayType eType );

    void  EndUpdate ( BOOL doDeletions, ESeenArrayType eType );

    WCHAR * GetDriveName();

    CRWStore * ComputeRelevantWords(ULONG cRows,ULONG cRW,
                                    WORKID *pwid,PARTITIONID partid);

    CRWStore * RetrieveRelevantWords(BOOL fAcquire,PARTITIONID partid);

    void SetPartition( PARTITIONID PartId ) { _PartId = PartId; }
    PARTITIONID GetPartition() const { return _PartId; }

    void PidMapToPidRemap( const CPidMapper & pidMap,
                           CPidRemapper & pidRemap );

    SCODE CiState( CI_STATE & state );

    void  DoUpdate( WCHAR const* rootPath,
                    ULONG flag,
                    BOOL fDoDeletions,
                    BOOL & fAbort,
                    BOOL fProcessRoot );

    void  DoUpdate( CScanInfoList & scopes, CCiScanMgr & scanMgr, BOOL & fAbort );

    void  ProcessScansComplete( BOOL fForce, BOOL & fShortWait );

    void  IncrementUpdateCount( ULONG nUpdates  )
    {
        _notify.IncrementUpdateCount( nUpdates );
    }

    BOOL  IsEligibleForFiltering( WCHAR const* wcsDirPath );
    BOOL  IsEligibleForFiltering( const CLowcaseBuf & LcaseDirPath );
    BOOL  IsEligibleForFiltering( const CLowerFunnyPath & lowerFunnyPath );

    void  SynchWithIIS( BOOL fRescanTC = TRUE, BOOL fSleep = TRUE );
    void  SynchWithRegistryScopes( BOOL fRescanTC = TRUE );
    void  SetupScopeFixups();
    void  SynchShares();

    void DoRecovery();

    void SetRecoveryCompleted();
    BOOL IsRecoveryCompleted() { return _fRecoveryCompleted; }

    void SignalPhase2Completion() { _evtPh2Init.Set(); };

    void StartScansAndNotifies();

    void HandleError( NTSTATUS status ); // virtual

    BOOL IsDirectory( const CLowerFunnyPath * pOldFunnyPath, const CLowerFunnyPath * pNewFunnyPath );


    static BOOL IsUNCName( WCHAR const * pwszPath );

    BOOL IsReadOnly() { return _fIsReadOnly; }

    void SetEvtInitialized() { _evtInitialized.Set(); }

    void SetEvtPh2Init() { _evtPh2Init.Set(); }

    // Disk full processing
    void NoLokProcessDiskFull();
    void NoLokClearDiskFull();

    BOOL IsLowOnDisk() const { return _statusMonitor.IsLowOnDisk(); }

    BOOL IsCorrupt( ) const
    {
        return _statusMonitor.IsCorrupt();
    }

    // Scan support
    void MarkFullScanNeeded();
    void MarkIncrScanNeeded();

    // Changes Flush Support
    void ProcessChangesFlush( FILETIME const & ftFlushed,
                              ULONG cEntries,
                              USN_FLUSH_INFO const * const * ppUsnEntries );
    void ScheduleSerializeChanges();
    void SerializeChangesInfo();

    static BOOL IsDiskLowError( DWORD status );

    static void FillMaxTime( FILETIME & ft );
    static BOOL IsMaxTime( const FILETIME & ft );

    //
    // Support for CiFramework.
    //
    void StartupCiFrameWork( ICiManager * pCiManager );

    unsigned FixupPath( WCHAR const * pwcOriginal,
                        WCHAR *       pwcResult,
                        unsigned      cwcResult,
                        unsigned      cSkip )
    {
        return _scopeFixup.Fixup( pwcOriginal, pwcResult, cwcResult, cSkip );
    }

    void InverseFixupPath( CLowerFunnyPath & lcaseFunnyPath )
    {
        _scopeFixup.InverseFixup( lcaseFunnyPath );
    }

    CCiScopeTable * GetScopeTable() { return & _scopeTable; }

    CScopeFixup * GetScopeFixup()
    {
        return &_scopeFixup;
    }

    CImpersonationTokenCache * GetImpersonationTokenCache()
        { return & _impersonationTokenCache; }

    void RefreshRegistryParams();

    WCHAR const * GetCatDir() const { return _wcsCatDir; }

    CWorkManager & GetWorkMan() { return _workMan; }

    void MakeBackupOfPropStore( WCHAR const * pwszDir,
                                IProgressNotify * pIProgressNotify,
                                BOOL & fAbort,
                                ICiEnumWorkids * pIWorkIds );

    BOOL ProcessFile( const CLowerFunnyPath & lcaseFunnyPath,
                      FILEID fileId,
                      VOLUMEID volumeId,
                      WORKID widParent,
                      DWORD dwFileAttributes,
                      WORKID & wid );

    WORKID FileIdToWorkId( FILEID fileId, VOLUMEID volumeId )
    {
        CLock lock( _mutex );

        return _fileIdMap.LokFind( fileId, volumeId );
    }

    void FileIdToPath( FILEID fileId,
                       CUsnVolume *pUsnVolume,
                       CLowerFunnyPath & lcaseFunnyPath,
                       BOOL & fPathInScope );

    unsigned FileIdToPath( FILEID &          fileId,
                           VOLUMEID          volumeId,
                           CLowerFunnyPath & funnyPath );

    void UsnRecordToPathUsingParentId( USN_RECORD *pUsnRec,
                                       CUsnVolume *pUsnVolume,
                                       CLowerFunnyPath & lowerFunnyPath,
                                       BOOL &fPathInScope,
                                       WORKID & widParent,
                                       BOOL fParentMayNotBeIndexed );

    BOOL        VolumeSupportsUsns( WCHAR wcVolume );
    BOOL        IsOnUsnVolume( WCHAR const *pwszPath );

    VOLUMEID    MapPathToVolumeId( const WCHAR *pwszPath );

    ULONGLONG const & GetJournalId( const WCHAR *pwszPath );
    ULONGLONG const & GetVolumeCreationTime( const WCHAR *pwszPath );
    ULONG             GetVolumeSerialNumber( const WCHAR *pwszPath );

    void InitUsnTreeScan( WCHAR const *pwszPath );
    void SetUsnTreeScanComplete( WCHAR const *pwszPath,
                                 USN usnMax );

    void SetTreeScanComplete( WCHAR const *pwszPath );
#if CIDBG==1
    void CheckUsnTreeScan( WCHAR const *pwszPath );
#endif

    ICiManager *CiManager()
    {
        Win4Assert( _xCiManager.GetPointer() );
        return _xCiManager.GetPointer();
    }

    BOOL HasChanged( WORKID wid, FILETIME const & ft );

    CCiRegParams * GetRegParams() { return & _regParams; }

    PROPID StandardPropertyToPropId ( CFullPropSpec const & ps )
    {
        return _propMapper.StandardPropertyToPropId( ps );
    }

    unsigned ReserveUpdate( WORKID wid ) { Win4Assert( FALSE ); return 0; }
    void Update( unsigned iHint, WORKID wid, PARTITIONID partid, USN usn, ULONG flags )
        { Win4Assert( FALSE ); }
    void FlushScanStatus() {}
    BOOL IsNullCatalog() { return FALSE; }

    CMutexSem & GetMutex() { return _mutex; }

private:

    friend void  UpdateDuringRecovery( WORKID wid, BOOL fDelete, void const *pUserData );

    BOOL _IsEligibleForFiltering( const WCHAR * pwcsPath, unsigned ccPath );

    void ScanThisScope(WCHAR const * pwszPath);

    void RemoveThisScope(WCHAR const * pwszPath, BOOL fForceRemovalScan );

    void OnIgnoredScopeDelete(WCHAR const * pwcRoot, unsigned & iBmk, CRegAccess & regScopes);

    void OnIndexedScopeDelete(WCHAR const * pwcRoot, unsigned & iBmk, CRegAccess & regScopes);

    BOOL RemoveMatchingScopeTableEntries( WCHAR const * pwszRegXScope );

    void ScanScopeTableEntry (WCHAR const * pwszScopeToRescan);

    SCODE Update( WORKID wid, PARTITIONID partid, VOLUMEID volumeId, USN usn, ULONG flags );

    void SignalDaemonRescanTC() { _evtRescanTC->Set(); }

    void EvtLogIISAdminNotAvailable();

    void SetName( const WCHAR *pwc )
    {
        _xName.Init( wcslen( pwc ) + 1 );
        RtlCopyMemory( _xName.Get(), pwc, _xName.SizeOf() );
    }

    void EnableUpdateNotifies();

    CPidLookupTable & GetPidLookupTable() { return _PidTable; }

    void LokWriteFileUsnInfo( WORKID wid,
                              FILEID fileId,
                              BOOL fWriteToPropStore,
                              VOLUMEID volumeId,
                              WORKID widParent,
                              DWORD dwFileAttributes );

    void PersistMaxUSNs( void );
    
    void  RenameFileInternal( const CLowerFunnyPath & lcaseFunnyOldName,
                              const CLowerFunnyPath & lcaseFunnyNewName,
                              ULONG         ulFileAttrib,
                              VOLUMEID      volumeId,
                              FILEID        fileId,
                              WORKID        widParent);
                              
    WORKID PathToWorkIdInternal
                        ( const CLowerFunnyPath & lcaseFunnyPath,
                          BOOL fCreate,
                          BOOL & fNew,
                          FILETIME * pftLastSeen,
                          ESeenArrayType eType,
                          FILEID fileId,
                          WORKID widParent,
                          BOOL fGuaranteedNew);

#if CIDBG==1
    void        DebugPrintWidInfo( WORKID wid );
#endif

    BOOL        IsInit() { return eStarting != _state; }

    BOOL        LokExists();
    void        LokCreate();
    void        LokInit();

    void        InitOrCreate();

    void        InitIf( BOOL fLeaveCorruptCatalog = FALSE );
    void        CreateIf();

    void        AbortWorkItems();

    void        LogCiFailure( NTSTATUS status );

    BOOL        IsIgnoreNotification( WORKID wid,
                                      const CFunnyPath & funnyPath,
                                      ULONG ulFileAttrib );

    void        AddShadowScopes();

    BOOL        IsStarting() const { return (eStarting == _state || eQueryOnly == _state); }

    BOOL        IsStarted() const { return (eStarted == _state || eQueryOnly == _state); }

    BOOL        IsShuttingDown() const { return (eShutdownPhase1 == _state); }

    BOOL        IsShutdown() const { return (eShutdown == _state); }

    BOOL        IsCiDataCorrupt() const
    {
        return _scopeTable.IsCiDataCorrupt();
    }

    void        ClearCiDataCorrupt()
    {
        _scopeTable.ClearCiDataCorrupt();
    }

    BOOL        IsFsCiDataCorrupt() const
    {
        return _scopeTable.IsFsCiDataCorrupt();
    }

    void        LogEvent( CCiStatusMonitor::EMessageType eType,
                          DWORD status = STATUS_SUCCESS,
                          ULONG val = 0 )
    {
        _statusMonitor.LogEvent( eType, status, val );
    }

    //
    // Helper routines for properties
    //

    void        RecoverUserProperties( ULONG_PTR ulToken, DWORD dwStoreLevel );

    void        DeleteUserProperty( CFullPropSpec const & fps );

    FILEID      PathToFileId( const CFunnyPath & pwcPath );

    WORKID      LokLookupWid( const CLowerFunnyPath & lcaseFunnyPath, FILEID & fileId );

    void   AddShares( CDynLoadNetApi32 & dlNetApi32 );

    void RefreshIfShadowAlias( WCHAR const * pwcsScope,
                               WCHAR const * pwcsAlias,
                               HKEY hkey );

    void AddShadowAlias( WCHAR const * pwcsScope,
                         WCHAR const * pwcsAlias,
                         unsigned iSlot,
                         HKEY hkey );

    void DeleteIfShadowAlias( WCHAR const * pwcsScope, WCHAR const * pwcsAlias );


    enum EState
    {
        eStarting,
        eQueryOnly,
        eStarted,
        eShutdownPhase1,
        eShutdown
    };


    ULONG               _ulSignature;            // Signature of start of privates

    CCiRegParams        _regParams;
    CStandardPropMapper _propMapper;

    CScopeMatch         _CatDir;                 // skip indexing catalog directory

    BOOL                _fIsReadOnly;            // TRUE if catalog is read-only
    BOOL                _fDiskPerfEnabled;       // TRUE if DiskPerf.sys is loaded

    CiStorage*          _pStorage;               // Allocates storage

    EState              _state;

    CImpersonationTokenCache _impersonationTokenCache;

    CScopeFixup         _scopeFixup;             // path fixup for remote clients
    CScopesIgnored      _scopesIgnored;          // paths that shouldn't be filtered

    CClientDocStore &   _docStore;               // Document store interface

    XGrowable<WCHAR>    _xwcsDriveName;          // Large buffer for UNC drive

    WCHAR               _wcsCatDir[MAX_PATH];    // path to catalog directory

    CCiStatusMonitor    _statusMonitor;          // CI Status monitoring

    BOOL                _fInitialized;           // Set to true when fully initilaized.
                                                 // Optimization - test before doing a wait.

    CEventSem           _evtInitialized;         // Event set when initialization is
                                                 // completed.

    CEventSem           _evtPh2Init;             // Phase2 initialization

    CPropStoreManager   _propstoremgr;           // Property values cached through this.
    CStrings            _strings;                // pointers to strings and hash table
    CFileIdMap          _fileIdMap;              // File id to wid map
    CPidLookupTable     _PidTable;               // PROPID mapping table
    CSdidLookupTable    _SecStore;               // SDID mapping table

    CMutexSem           _mutex;
    CMutexSem           _mtxAdmin;               // Lock for admin operations.

    PARTITIONID         _PartId;                 // partitions are not supported

    CWorkManager &      _workMan;                // Asynchronous work item manager

    CMutexSem           _mtxIISSynch;            // IIS Synch protection
    long                _cIISSynchThreads;

    CCiScanMgr          _scanMgr;                // Scanning thread manager
    CUsnMgr             _usnMgr;                 // Usn thread manager
    CCiNotifyMgr        _notify;                 // Change notifications.
    CCiScopeTable       _scopeTable;             // Table of all scopes in CI
    BOOL                _fRecovering;            // TRUE if in midst of dirty shutdown recovery
    BOOL                _fRecoveryCompleted;     // TRUE AFTER recovery has successfully completed

    BOOL                _fAutoAlias;             // TRUE if all net shares should be added as fixups

    BOOL                _fIndexW3Roots;          // TRUE if should grovel W3 roots
    BOOL                _fIndexNNTPRoots;        // TRUE if should grovel NNTP roots
    BOOL                _fIndexIMAPRoots;        // TRUE if should grovel IMAP roots

    ULONG               _W3SvcInstance;          // instance # of w3svc
    ULONG               _NNTPSvcInstance;        // instance # of nntpsvc
    ULONG               _IMAPSvcInstance;        // instance # of imapsvc

    BOOL                _fIsIISAdminAlive;       // TRUE if the iisadmin svc is up

    FILETIME            _ftLastCLFlush;          // Last ChangeLog Flush time

    CUsnFlushInfoList   _usnFlushInfoList;       // List of usn info
    CVolumeInfo         _aUsnVolumes[ RTL_MAX_DRIVE_LETTERS ]; // Info about each usn volume
    unsigned            _cUsnVolumes;
    CDrvNotifArray &    _DrvNotifArray;

    //
    // CI Framework support.
    //
    XInterface<ICiManager>         _xCiManager;    // ContentIndex manager
    XInterface<ICiCAdviseStatus>   _xAdviseStatus;

    XPtr<CEventSem>     _evtRescanTC;            // Rescan token cache

    XArray<WCHAR>       _xName;                  // friendly name of catalog
    XArray<WCHAR>       _xScopesKey;             // handy registry key
};

inline BOOL CiCat::IsDiskLowError( DWORD status )
{
    return STATUS_DISK_FULL == status ||
           ERROR_DISK_FULL  == status ||
           HRESULT_FROM_WIN32(ERROR_DISK_FULL) == status ||
           FILTER_S_DISK_FULL == status ||
           CI_E_CONFIG_DISK_FULL == status;
}

inline void CiCat::FillMaxTime( FILETIME & ft )
{
    ft.dwLowDateTime  = 0xFFFFFFFF;
    ft.dwHighDateTime = 0xFFFFFFFF;
}

inline BOOL CiCat::IsMaxTime( const FILETIME & ft )
{
    return 0xFFFFFFFF == ft.dwLowDateTime &&
           0xFFFFFFFF == ft.dwHighDateTime;
}

inline BOOL CiCat::VirtualToAllPhysicalRoots( WCHAR const * pwcVPath,
                                              unsigned ccVPath,
                                              XGrowable<WCHAR> & xwcsVRoot,
                                              unsigned & ccVRoot,
                                              CLowerFunnyPath & lcaseFunnyPRoot,
                                              unsigned & ccPRoot,
                                              ULONG & ulType,
                                              unsigned & iBmk )
{
    return _strings.VirtualToAllPhysicalRoots( pwcVPath,
                                               ccVPath,
                                               xwcsVRoot,
                                               ccVRoot,
                                               lcaseFunnyPRoot,
                                               ccPRoot,
                                               ulType,
                                               iBmk );
}

//+---------------------------------------------------------------------------
//
//  Class:      CReferenceCount
//
//  Purpose:    Counts references
//
//  History:    23-Sep-97       dlee            Created
//
//----------------------------------------------------------------------------

class CReferenceCount
{
public:
    CReferenceCount( long & lCount, BOOL fInc = TRUE ) :
        _lCount( lCount ), _fInc( fInc )
    {
        if ( fInc )
            InterlockedIncrement( &_lCount );
    }

    long Increment()
    {
        Win4Assert( !_fInc );
        _fInc = TRUE;
        return InterlockedIncrement( &_lCount );
    }

    long Decrement()
    {
        Win4Assert( _fInc );
        _fInc = FALSE;
        return InterlockedDecrement( &_lCount );
    }

    ~CReferenceCount()
    {
        if ( _fInc )
            InterlockedDecrement( &_lCount );
    }

private:
    long & _lCount;
    BOOL   _fInc;
};