windows-xp/Source/XPSP1/NT/inetsrv/query/h/catalog.hxx

//+---------------------------------------------------------------------------
//
//  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<WCHAR> & xBuf );

    virtual unsigned WorkIdToVirtualPath( CCompositePropRecord & propRec,
                                          unsigned cSkip,
                                          XGrowable<WCHAR> & xBuf )
    {
        if ( 0 != xBuf.Count() )
            xBuf[0] = 0;
        return 0;
    }

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

    virtual BOOL VirtualToAllPhysicalRoots( WCHAR const * pwcVPath,
                                            unsigned ccVPath,
                                            XGrowable<WCHAR> & 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<WCHAR> & 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<WCHAR> & xBuf )
{
    // Default: No support for virtual paths

    return 0;
}

inline BOOL PCatalog::VirtualToPhysicalRoot( WCHAR const * pwcVPath,
                                             unsigned ccVPath,
                                             XGrowable<WCHAR> & 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<WCHAR> & xwcsVRoot,
                                                 unsigned & ccVRoot,
                                                 CLowerFunnyPath & lcaseFunnyPRoot,
                                                 unsigned & ccPRoot,
                                                 ULONG & ulType,
                                                 unsigned & iBmk )
{
    // Default: No support for virtual paths

    return FALSE;
}

inline ULONG PCatalog::EnumerateVRoot( XGrowable<WCHAR> & 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;
};