windows-xp/Source/XPSP1/NT/inetsrv/query/restrict/pidremap.cxx

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 2000.
//
//  File:       pidmap.cxx
//
//  Contents:   Maps pid <--> property name.
//
//  History:    31-Jan-93 KyleP     Created
//
//--------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#include <pidremap.hxx>
#include <coldesc.hxx>

//+-------------------------------------------------------------------------
//
//  Member:     CPidRemapper::CPidRemapper, public
//
//  Synopsis:   Creates a prop id remapper.  Translates input arguments
//              'fake' propids to real propids.
//
//  Arguments:  [pidmap]      - input prop ID mapping array
//              [xPropMapper] - property mapper for real pid lookup
//              [prst]        - optional restriction, pids will be mapped
//              [pcol]        - optional output columns, pids will be mapped
//              [pso]         - optional sort specification, pids will be mapped
//
//  History:    31-Jan-93 KyleP     Created
//
//--------------------------------------------------------------------------

CPidRemapper::CPidRemapper( const CPidMapper & pidmap,
                            XInterface<IPropertyMapper> & xPropMapper,
                            CRestriction * prst,
                            CColumnSet * pcol,
                            CSortSet * pso )
        : _xPropMapper( xPropMapper.Acquire() ),
          _fAnyStatProps( FALSE ),
          _fContentProp ( FALSE ),
          _fRankVectorProp( FALSE ),
          _cRefs( 1 )
{
    _cpidReal = pidmap.Count();
    _xaPidReal.Set( _cpidReal, new PROPID[ _cpidReal ] );

    //
    // Iterate through the list
    //

    for ( unsigned i = 0; i < _cpidReal; i++ )
    {
        PROPID pid;
        FULLPROPSPEC const * pFullPropSpec =  pidmap.Get(i)->CastToStruct();
        SCODE sc = _xPropMapper->PropertyToPropid( pFullPropSpec, TRUE, &pid );
        if ( FAILED( sc ) )
            THROW( CException( sc ) );

        _xaPidReal[i] = pid;

        if ( IsUserDefinedPid( _xaPidReal[i] ) )
        {
            //
            // Any user-defined property is a content property.
            // Note that the document characterization is a user-defined prop.
            //
            _fContentProp = TRUE;
        }
        else
        {
            if ( _xaPidReal[i] == pidContents )
                _fContentProp = TRUE;
            else
                _fAnyStatProps = TRUE;

            if ( _xaPidReal[i] == pidRankVector )
                _fRankVectorProp = TRUE;
        }

#if CIDBG == 1
        if ( vqInfoLevel & DEB_ITRACE )
        {
            CFullPropSpec const & ps = *pidmap.Get(i);

            GUID const & guid = ps.GetPropSet();

            char szGuid[50];

            sprintf( szGuid,
                     "%08lX-%04X-%04X-%02X%02X%02X%02X%02X%02X%02X%02X\\",
                     guid.Data1,
                     guid.Data2,
                     guid.Data3,
                     guid.Data4[0], guid.Data4[1],
                     guid.Data4[2], guid.Data4[3],
                     guid.Data4[4], guid.Data4[5],
                     guid.Data4[6], guid.Data4[7] );

            vqDebugOut(( DEB_ITRACE, szGuid ));

            if ( ps.IsPropertyName() )
                vqDebugOut(( DEB_ITRACE | DEB_NOCOMPNAME,
                             "%ws ",
                             ps.GetPropertyName() ));
            else
                vqDebugOut(( DEB_ITRACE | DEB_NOCOMPNAME,
                             "0x%x ",
                             ps.GetPropertyPropid() ));

            vqDebugOut(( DEB_ITRACE | DEB_NOCOMPNAME, " --> pid 0x%x\n",
                         _xaPidReal[i] ));

        }
#endif // CIDBG == 1

        CFullPropSpec * ppsFull = new CFullPropSpec( *pidmap.Get(i) );

        XPtr<CFullPropSpec> xpps(ppsFull);

        if ( xpps.IsNull() || !xpps->IsValid() )
        {
            THROW( CException( STATUS_NO_MEMORY ) );
        }

        _propNames.Add( ppsFull, i );
        xpps.Acquire();

        Win4Assert( _xaPidReal[i] != pidInvalid );
    }

    if ( prst )
        RemapPropid( prst );

    if ( pcol )
        RemapPropid( pcol );

    if ( pso )
        RemapPropid( pso );
}


//+-------------------------------------------------------------------------
//
//  Member:     CPidRemapper::CPidRemapper, public
//
//  Synopsis:   Creates a prop id remapper.
//
//  Arguments:  [xPropMapper] - Property mapper for real pid lookup
//
//  History:    12-Mar-95   DwightKr    Created
//
//--------------------------------------------------------------------------
CPidRemapper::CPidRemapper( XInterface<IPropertyMapper> & xPropMapper )
        : _xPropMapper( xPropMapper.Acquire() ),
          _cpidReal( 0 ),
          _cRefs( 1 )
{
}


//+-------------------------------------------------------------------------
//
//  Member:     CPidRemapper::~CPidRemapper, public
//
//  History:    15-Feb-93 KyleP     Created
//
//--------------------------------------------------------------------------

CPidRemapper::~CPidRemapper()
{
}


//+-------------------------------------------------------------------------
//
//  Member:     CPidRemapper::RealToName, public
//
//  Effects:    Convert a PROPID to a propspec
//
//  Arguments:  [pid] - Given pid
//
//  History:    22-Jan-97     SitaramR         Added header
//
//--------------------------------------------------------------------------

CFullPropSpec const * CPidRemapper::RealToName( PROPID pid ) const
{
    Win4Assert( ! _xaPidReal.IsNull() );

    //
    // Just linear search
    //
    for ( unsigned i = 0;
          i < _cpidReal && _xaPidReal[i] != pid;
          i++
        )
    {
        continue;
    }

    Win4Assert( i < _cpidReal );

    //
    // This can happen if a hacker tries to munge query requests
    //

    if ( i == _cpidReal )
        THROW( CException( E_ABORT ) );

    return( _propNames.Get( i ) );
}


//+-------------------------------------------------------------------------
//
//  Member:     CPidRemapper::NameToReal, public
//
//  Effects:    Convert a property which is not necessarily in the pid map
//              to a PROPID.
//
//  Arguments:  [pProperty] - pointer to the propspec.
//
//  Returns:    PROPID - the mapped property ID or pidInvalid.
//
//  History:    28 Jun 94       AlanW   Created
//
//--------------------------------------------------------------------------

PROPID CPidRemapper::NameToReal( CFullPropSpec const * pProperty )
{
    for (unsigned i = 0; i < _cpidReal; i++)
    {
        if (*pProperty == *_propNames.Get(i))
        {
            return _xaPidReal[ i ];
        }
    }

    //
    //  Property is not in the mapping array.  Add it.
    //
    PROPID Prop;
    FULLPROPSPEC const * pFullPropSpec =  pProperty->CastToStruct();
    SCODE sc = _xPropMapper->PropertyToPropid( pFullPropSpec, TRUE, &Prop );
    if ( FAILED( sc ) )
        THROW( CException( sc ) );

    if (Prop != pidInvalid)
    {
        PROPID *ppidReal = new PROPID[ _cpidReal+1 ];
        memcpy(ppidReal, _xaPidReal.GetPointer(), _cpidReal * sizeof (PROPID));

        //
        // No lock is needed here to prevent races with RealToName since in current
        // usage everything is added in the query path by a single thread before
        // reads happen from multiple threads.
        //

        PROPID *ppidTemp = _xaPidReal.Acquire();
        _xaPidReal.Set( _cpidReal+1, ppidReal );
        delete [] ppidTemp;

        CFullPropSpec * ppsFull = new CFullPropSpec( *pProperty );

        XPtr<CFullPropSpec> xpps(ppsFull);

        if ( xpps.IsNull() || !xpps->IsValid() )
        {
            THROW( CException( STATUS_NO_MEMORY ) );
        }

        _propNames.Add( ppsFull, _cpidReal );
        xpps.Acquire();

        Win4Assert(*_propNames.Get(_cpidReal) == *pProperty);
        _xaPidReal[_cpidReal] = Prop;

        _cpidReal++;
    }

    return Prop;
}

//+-------------------------------------------------------------------------
//
//  Member:     CPidRemapper::RemapPropid, public
//
//  Effects:    Traverses [pRst], converting 'fake' propid to 'real'
//
//  Arguments:  [pRst] -- Restriction
//
//  History:    15-Feb-93 KyleP     Created
//
//--------------------------------------------------------------------------

void CPidRemapper::RemapPropid( CRestriction * pRst )
{
    Win4Assert ( pRst != 0 );

    switch( pRst->Type() )
    {
    case RTInternalProp:
    {
        CInternalPropertyRestriction * pPropRst =
            (CInternalPropertyRestriction *)pRst;

        pPropRst->SetPid( FakeToReal( pPropRst->Pid() ) );
        if ( 0 != pPropRst->GetContentHelper() )
            RemapPropid( pPropRst->GetContentHelper() );
        break;
    }

    case RTWord:
    {
        CWordRestriction * pWordRst = (CWordRestriction *)pRst;
        pWordRst->SetPid( FakeToReal( pWordRst->Pid() ) );
        break;
    }

    case RTSynonym:
    {
        CSynRestriction * pSynRst = (CSynRestriction *)pRst;
        CKeyArray & keys = pSynRst->GetKeys();

        for ( int i = keys.Count() - 1; i >= 0; i-- )
        {
            CKey & key = keys.Get(i);
            key.SetPid( FakeToReal( key.Pid() ) );
        }
        break;
    }

    case RTNot:
    {
        CNotRestriction * pnrst = (CNotRestriction *)pRst;

        RemapPropid( pnrst->GetChild() );
        break;
    }

    case RTAnd:
    case RTOr:
    case RTVector:
    case RTProximity:
    case RTPhrase:
    {
        CNodeRestriction * pNodeRst = pRst->CastToNode();

        for ( int i = pNodeRst->Count() - 1; i >= 0; i-- )
        {
            RemapPropid( pNodeRst->GetChild( i ) );
        }
        break;
    }
    case RTRange:
    case RTNone:   // probably a noise word in a vector query
        break;

    default:
        Win4Assert( !"RemapPropid: Unknown type." );
        break;

    }
}

//+-------------------------------------------------------------------------
//
//  Member:     CPidRemapper::RemapPropid, public
//
//  Effects:    Traverses [pColumns], converting 'fake' propid to 'real'
//
//  Arguments:  [pColumns] -- Output columns
//
//  History:    22-Jun-93 KyleP     Created
//
//--------------------------------------------------------------------------

void CPidRemapper::RemapPropid( CColumnSet * pColumns )
{
    for ( unsigned i = 0; i < pColumns->Count(); i++ )
    {
        pColumns->Get(i) = FakeToReal( pColumns->Get(i) );
    }
}


//+-------------------------------------------------------------------------
//
//  Member:     CPidRemapper::RemapPropid, public
//
//  Effects:    Traverses [pSort], converting 'fake' propid to 'real'
//
//  Arguments:  [pSort] -- Restriction
//
//  History:    15-Feb-93 KyleP     Created
//
//--------------------------------------------------------------------------

void CPidRemapper::RemapPropid( CSortSet * pSort )
{
    for ( unsigned i = 0; i < pSort->Count(); i++ )
    {
        pSort->Get(i).pidColumn = FakeToReal( pSort->Get(i).pidColumn );
    }
}


//+-------------------------------------------------------------------------
//--------------------------------------------------------------------------
void CPidRemapper::ReBuild( const CPidMapper & pidmap )
{
    if ( _cpidReal < pidmap.Count() )
    {
        delete [] _xaPidReal.Acquire();

        _cpidReal = 0;

        _xaPidReal.Set( pidmap.Count(), new PROPID[ pidmap.Count() ] );
    }

    _cpidReal = pidmap.Count();

    //
    // Iterate through the list
    //

    for ( unsigned i = 0; i < _cpidReal; i++ )
    {
        PROPID pid;
        FULLPROPSPEC const * pFullPropSpec =  pidmap.Get(i)->CastToStruct();
        SCODE sc = _xPropMapper->PropertyToPropid( pFullPropSpec, TRUE, &pid );
        if ( FAILED( sc ) )
            THROW( CException( sc ) );

        _xaPidReal[i] = pid;

        Win4Assert( _xaPidReal[i] != pidInvalid );
    }
}


//+-------------------------------------------------------------------------
//--------------------------------------------------------------------------
void CPidRemapper::Set( XArray<PROPID> & aPids )
{
    delete [] _xaPidReal.Acquire();

    _cpidReal = aPids.Count();
    _xaPidReal.Set( _cpidReal, aPids.Acquire() );
}

//
// This has to go somewhere...
//

UNICODECALLOUTS UnicodeCallouts = { WIN32_UNICODECALLOUTS };



//+-------------------------------------------------------------------------
//
//  Method:     CPidRemapper::AddRef
//
//  Synopsis:   Increments refcount
//
//  History:    22-Jan-1997      SitaramR       Created
//
//--------------------------------------------------------------------------

ULONG STDMETHODCALLTYPE CPidRemapper::AddRef()
{
    return InterlockedIncrement( (long *) &_cRefs );
}

//+-------------------------------------------------------------------------
//
//  Method:     CPidRemapper::Release
//
//  Synopsis:   Decrement refcount.  Delete if necessary.
//
//  History:    22-Jan-1997     SitaramR        Created
//
//--------------------------------------------------------------------------

ULONG STDMETHODCALLTYPE CPidRemapper::Release()
{
    Win4Assert( _cRefs > 0 );

    ULONG uTmp = InterlockedDecrement( (long *) &_cRefs );

    if ( 0 == uTmp )
        delete this;

    return(uTmp);
}



//+-------------------------------------------------------------------------
//
//  Method:     CPidRemapper::QueryInterface
//
//  Synopsis:   Rebind to other interface
//
//  Arguments:  [riid]      -- IID of new interface
//              [ppvObject] -- New interface * returned here
//
//  Returns:    S_OK if bind succeeded, E_NOINTERFACE if bind failed
//
//  History:    22-Jan-1997     SitaramR   Created
//
//--------------------------------------------------------------------------

SCODE STDMETHODCALLTYPE CPidRemapper::QueryInterface(
    REFIID riid,
    void ** ppvObject)
{
    if ( IID_ICiQueryPropertyMapper == riid )
        *ppvObject = (ICiQueryPropertyMapper *)this;
    else if ( IID_IUnknown == riid )
        *ppvObject = (IUnknown *)this;
    else
    {
        *ppvObject = 0;
        return E_NOINTERFACE;
    }

    AddRef();
    return S_OK;
}

//+-------------------------------------------------------------------------
//
//  Method:     CPidRemapper::PropertyToPropid
//
//  Synopsis:   Convert propspec to pid
//
//  Arguments:  [pFullPropSpec] -- propspec to convert
//              [pPropId]       -- pid returned here
//
//  History:    22-Jan-1997     SitaramR   Created
//
//--------------------------------------------------------------------------

SCODE STDMETHODCALLTYPE CPidRemapper::PropertyToPropid( const FULLPROPSPEC *pFullPropSpec,
                                                        PROPID *pPropId)
{
    SCODE sc = S_OK;

    TRY
    {
        CFullPropSpec const * pProperty = (CFullPropSpec const *) pFullPropSpec;
        *pPropId = NameToReal( pProperty );
    }
    CATCH( CException, e )
    {
        sc = e.GetErrorCode();

        vqDebugOut(( DEB_ERROR,
                     "CPidRemapper:PropertyToPropid - Exception caught 0x%x\n",
                     sc ));
    }
    END_CATCH;

    return sc;
}



//+-------------------------------------------------------------------------
//
//  Method:     CPidRemapper::PropidToProperty
//
//  Synopsis:   Convert pid to propspec
//
//  Arguments:  [pPropId]       -- pid to convert
//              [pFullPropSpec] -- propspec returned here
//
//  Notes:      *ppFullPropSpec is owned by CPidRemapper
//
//  History:    22-Jan-1997     SitaramR   Created
//
//--------------------------------------------------------------------------

SCODE STDMETHODCALLTYPE CPidRemapper::PropidToProperty( PROPID propId,
                                                        FULLPROPSPEC const **ppFullPropSpec )
{
    SCODE sc = S_OK;

    TRY
    {
        *ppFullPropSpec = RealToName( propId )->CastToStruct();
    }
    CATCH( CException, e )
    {
        sc = e.GetErrorCode();

        vqDebugOut(( DEB_ERROR,
                     "CPidRemapper:PropidToProperty - Exception caught 0x%x\n",
                     sc ));
    }
    END_CATCH;

    return sc;
}