windows-server-2003/inetsrv/query/cicat/vmap.hxx

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1991 - 2000.
//
//  File:       VMap.hxx
//
//  Contents:   Virtual <--> physical path map.
//
//  Classes:    CVMap
//
//  History:    05-Feb-96   KyleP       Created
//
//----------------------------------------------------------------------------

#pragma once

#include <catalog.hxx>
#include <prcstob.hxx>
#include <smatch.hxx>
#include <cimbmgr.hxx>

const unsigned INVALID_VMAP_INDEX = 0xFFFFFFFF;

//+-------------------------------------------------------------------------
//
//  Class:      CVMapDesc
//
//  Purpose:    Description of single scope mapping
//
//  History:    05-Feb-96   KyleP       Created
//
//--------------------------------------------------------------------------

class CVMapDesc
{
public:

    inline CVMapDesc();

    void Init( WCHAR const * pVRoot,
               ULONG ccVRoot,
               WCHAR const * pPRoot,
               ULONG ccPRoot,
               ULONG idParent,
               BOOL fAutomatic,
               CiVRootTypeEnum eType,
               BOOL fIsIndexed,
               BOOL fNonIndexedVDir );

    inline unsigned PhysicalMatchLen( WCHAR const * path ) const;
    inline BOOL     IsInPhysicalScope( WCHAR const * root, unsigned cc ) const;

    BOOL IsVirtualMatch( WCHAR const * pVPath, unsigned ccVPath ) const;
    BOOL IsPhysicalMatch( WCHAR const * pVPath, unsigned ccVPath ) const;

    inline ULONG Parent() const              { return _idParent; }
    inline void  SetParent( ULONG idParent ) { _idParent = idParent; }

    inline BOOL  IsFree()                    { return (0 == _ccVScope); }
    inline void  Delete()                    { _ccVScope = 0; }

    inline WCHAR const * PhysicalPath() const { return _wcPScope; }
    inline ULONG PhysicalLength() const       { return _ccPScope; }

    inline WCHAR const * VirtualPath() const  { return _wcVScope; }
    inline ULONG VirtualLength() const        { return _ccVScope; }

    inline void SetAutomatic()                { _Type |= PCatalog::AutomaticRoot; }
    inline void ClearAutomatic()              { _Type &= ~PCatalog::AutomaticRoot; }
    inline BOOL IsAutomatic() const           { return (_Type & PCatalog::AutomaticRoot); }

    inline void SetManual()                   { _Type |= PCatalog::ManualRoot; }
    inline void ClearManual()                 { _Type &= ~PCatalog::ManualRoot; }
    inline BOOL IsManual() const              { return (_Type & PCatalog::ManualRoot); }

    inline void ClearInUse()                  { _Type &= ~PCatalog::UsedRoot; }
    inline BOOL IsInUse() const               { return (_Type & PCatalog::UsedRoot); }

    inline BOOL IsNNTP() const                { return 0 != (_Type & PCatalog::NNTPRoot); }
    inline BOOL IsIMAP() const                { return 0 != (_Type & PCatalog::IMAPRoot); }
    inline BOOL IsW3() const                  { return !IsNNTP() && !IsIMAP(); }

    inline BOOL IsNonIndexedVDir() const      { return 0 != (_Type & PCatalog::NonIndexedVDir); }
    inline void SetNonIndexedVDir()           { _Type |= PCatalog::NonIndexedVDir; }
    inline void ClearNonIndexedVDir()         { _Type &= ~PCatalog::NonIndexedVDir; }

    inline ULONG RootType()                   { return _Type; }

private:

    ULONG _ccVScope;
    WCHAR _wcVScope[MAX_PATH];       // Virtual scope

    // IIS currently doesn't allow paths greater
    // than MAX_PATH. This is not a good reason for we to also not
    // support, but there are lot of complications right now, like 
    // in place serialization of variable data, so currently we have the
    // MAX_PATH restriction of VPaths and for scopes.

    ULONG _ccPScope;
    WCHAR _wcPScope[MAX_PATH];       // Physical scope

    ULONG _idParent;                 // Link to parent (INVALID_VMAP_INDEX --> top level)

    ULONG _Type;
};

//+-------------------------------------------------------------------------
//
//  Class:      CVMap
//
//  Purpose:    Virtual/Physical path map
//
//  History:    05-Feb-96   KyleP       Created
//
//--------------------------------------------------------------------------

class CVMap
{
public:

    CVMap();

    BOOL Init( PRcovStorageObj * obj );
    void Empty();

    BOOL Add( WCHAR const * vroot,
              WCHAR const * root,
              BOOL fAutomatic,
              ULONG & idNew,
              CiVRootTypeEnum eType,
              BOOL fVRoot,
              BOOL fIsIndexed );

    BOOL Remove( WCHAR const * vroot,
                 BOOL fOnlyIfAutomatic,
                 ULONG & idOld,
                 ULONG & idNew,
                 CiVRootTypeEnum eType,
                 BOOL fVRoot );

    void MarkClean();
    BOOL IsClean() const { return !_fDirty; }

    inline BOOL IsInPhysicalScope( ULONG id, WCHAR const * root, unsigned cc );

    ULONG PhysicalPathToId( WCHAR const * path );

    BOOL VirtualToPhysicalRoot( WCHAR const * pwcVRoot,
                                unsigned ccVRoot,
                                CLowerFunnyPath & lcaseFunnyPRoot,
                                unsigned & ccPRoot );

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

    BOOL DoesPhysicalRootExist( WCHAR const * pwcPRoot );

    inline CVMapDesc const & GetDesc( ULONG id ) const;

    //
    // Path chaining.
    //

    inline ULONG Parent( ULONG id ) const;

    inline ULONG FindNthRemoved( ULONG id, unsigned cSkip ) const;

    BOOL IsNonIndexedVDir( ULONG id ) const
    {
        if ( INVALID_VMAP_INDEX == id )
            return FALSE;

        return _aMap[id].IsNonIndexedVDir();
    }

    ULONG GetExcludeParent( ULONG id ) const
    {
        Win4Assert( id < _aExcludeParent.Count() );
        return _aExcludeParent[ id ];
    }

    BOOL IsAnExcludeParent( ULONG id ) const
    {
        if ( INVALID_VMAP_INDEX == id )
            return FALSE;

        for ( unsigned x = 0; x < _aExcludeParent.Count(); x++ )
            if ( _aExcludeParent[x] == id )
                return TRUE;

        return FALSE;
    }

private:

    ULONG PhysicalPathToId( WCHAR const * path, BOOL fNonIndexedVDirs );

    void DumpVMap();
    void RecomputeNonIndexedInfo();

    BOOL                        _fDirty;     // TRUE if vmap went down dirty

    CMutexSem                   _mutex;

    CDynArrayInPlace<CVMapDesc> _aMap;

    CDynArrayInPlace<ULONG>     _aExcludeParent;

    XPtr<PRcovStorageObj>       _xrsoMap;
};

//+-------------------------------------------------------------------------
//
//  Member:     CVMapDesc::PhysicalMatchLen, private
//
//  Synopsis:   Compares input with physical path
//
//  Arguments:  [pPPath] -- Physical path.
//
//  Returns:    0 if [pPPath] does not match physical path complete to
//              the end of the short of the two.  On success returns
//              length of physical path.
//
//  History:    07-Feb-96   KyleP       Created.
//
//--------------------------------------------------------------------------

inline unsigned CVMapDesc::PhysicalMatchLen( WCHAR const * pPPath ) const
{
    Win4Assert( *pPPath );

    //
    // Compare strings.
    //

    unsigned i = 0;

    while ( *pPPath && i < _ccPScope && *pPPath == _wcPScope[i] )
    {
        i++;
        pPPath++;
    }

    //
    // Adjust for possible lack of terminating backslash.
    //

    if ( 0 == *pPPath )
    {
        if ( *(pPPath - 1) == L'\\' )
            return _ccPScope;
        else
        {
            if ( _wcPScope[i] == L'\\' )
                return _ccPScope;
            else
                return 0;
        }
    }
    else
    {
        if ( i >= _ccPScope )
            return _ccPScope;
        else
            return 0;
    }
}

//+-------------------------------------------------------------------------
//
//  Member:     CVMapDesc::CVMapDesc, private
//
//  Synopsis:   Constructor
//
//  History:    07-Feb-96   KyleP       Created.
//
//--------------------------------------------------------------------------

inline CVMapDesc::CVMapDesc()
        : _ccVScope( 0 ),
          _ccPScope( 0 )
{
}

//+-------------------------------------------------------------------------
//
//  Member:     CVMapDesc::IsInPhysicalScope, public
//
//  Synopsis:   Compares input with physical path
//
//  Arguments:  [root] -- Physical path.
//              [cc]   -- Size, in chars, of [root]
//
//  Returns:    TRUE if [root] is within physical scope.
//
//  History:    07-Feb-96   KyleP       Created.
//
//--------------------------------------------------------------------------

inline BOOL CVMapDesc::IsInPhysicalScope( WCHAR const * root, unsigned cc ) const
{
    Win4Assert( root[cc-1] != L'\\' );

    CScopeMatch Match( _wcPScope, _ccPScope );

    //
    // Be careful not to match root of scope.
    //

    return Match.IsInScope( root, cc ) && (_ccPScope != cc + 1);
}

//+-------------------------------------------------------------------------
//
//  Member:     CVMap::IsInPhysicalScope, public
//
//  Synopsis:   Compares input with physical path
//
//  Arguments:  [id]   -- Id of virtual/physical scope
//              [root] -- Physical path.
//              [cc]   -- Size, in chars, of [root]
//
//  Returns:    TRUE if [root] is within physical scope.
//
//  History:    07-Feb-96   KyleP       Created.
//
//--------------------------------------------------------------------------

inline BOOL CVMap::IsInPhysicalScope( ULONG id, WCHAR const * root, unsigned cc )
{
    CLock   lock(_mutex);

    Win4Assert( id < _aMap.Count() );

    return _aMap[id].IsInPhysicalScope( root, cc );
}

//+-------------------------------------------------------------------------
//
//  Member:     CVMap::Parent, public
//
//  Arguments:  [id]   -- Id of virtual/physical scope
//
//  Returns:    Virtual/physical id of parent.
//
//  History:    07-Feb-96   KyleP       Created.
//
//--------------------------------------------------------------------------

inline ULONG CVMap::Parent( ULONG id ) const
{
    Win4Assert( id < _aMap.Count() );

    return _aMap[id].Parent();
}

//+-------------------------------------------------------------------------
//
//  Member:     CVMap::FindNthRemoved, public
//
//  Synopsis:   Walks up virtual root chain to the Nth link.
//
//  Arguments:  [id]    -- Id of starting virtual/physical scope
//              [cSkip] -- Number of links to skip
//
//  Returns:    Virtual/physical id of Nth parent.
//
//  History:    07-Feb-96   KyleP       Created.
//
//--------------------------------------------------------------------------

inline ULONG CVMap::FindNthRemoved( ULONG id, unsigned cSkip ) const
{
    Win4Assert( id == INVALID_VMAP_INDEX || id < _aMap.Count() );

    while ( id != INVALID_VMAP_INDEX && !_aMap[id].IsFree() && cSkip > 0 )
    {
        id = _aMap[id].Parent();

        cSkip--;
    }

    if ( INVALID_VMAP_INDEX != id && _aMap[id].IsFree() )
        id = INVALID_VMAP_INDEX;

    return id;
}

//+-------------------------------------------------------------------------
//
//  Member:     CVMap::GetDesc, public
//
//  Arguments:  [id]    -- Id of virtual/physical scope
//
//  Returns:    Scope descriptor for [id]
//
//  History:    07-Feb-96   KyleP       Created.
//
//--------------------------------------------------------------------------

inline CVMapDesc const & CVMap::GetDesc( ULONG id ) const
{
    Win4Assert( id < _aMap.Count() );

    return _aMap[id];
}