windows-xp/Source/XPSP1/NT/inetsrv/query/bigtable/rownotfy.cxx

//----------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1994 - 2000
//
//  File:        rownotfy.cxx
//
//  Contents:    Rowset notification connection points
//
//  Classes:     CRowsetNotification
//               CRowsetAsynchNotification
//
//  History:     16 Feb 1998    AlanW   Created from conpt.cxx
//
//----------------------------------------------------------------------------

#include "pch.cxx"
#pragma hdrstop

#include <rownotfy.hxx>
#include <query.hxx>

#include "tabledbg.hxx"


/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
//////////////// CRowsetAsynchNotification methods ///////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////


//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::CRowsetAsynchNotification, public
//
//  Synopsis:   Constructor for connection point container class.
//
//  Arguments:  [query]       -- query object with notify info
//              [pRowset]     -- Rowset pointer
//              [ErrorObject] -- OLE-DB error object
//              [fWatch]      -- TRUE if watch notification to be done
//
//  History:    07-Oct-1994     dlee
//
//--------------------------------------------------------------------------

CRowsetAsynchNotification::CRowsetAsynchNotification(
            PQuery & query,
            ULONG hCursor,
            IRowset * pRowset,
            CCIOleDBError & ErrorObject,
            BOOL fWatch)
   : _query(query),
     _hCursor(hCursor),
     CRowsetNotification( ),
     _AsynchConnectionPoint ( IID_IDBAsynchNotify ),
     _WatchConnectionPoint ( IID_IRowsetWatchNotify ),
     _fDoWatch (fWatch),
     _fPopulationComplete (FALSE),
     _cAdvise( 0 ),
     _pRowset(pRowset),
     _threadNotify(0),
     _threadNotifyId( 0 )
{
     _AsynchConnectionPoint.SetContrUnk( (IUnknown *)this );
     if (_fDoWatch)
     {
         _WatchConnectionPoint.SetContrUnk( (IUnknown *)this );
     }
} //CRowsetAsynchNotification

//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::~CRowsetAsynchNotification, public
//
//  Synopsis:   Destructor for rowset watch notification class
//
//  History:    07-Oct-1994     dlee
//
//--------------------------------------------------------------------------

CRowsetAsynchNotification::~CRowsetAsynchNotification()
{
    Win4Assert( _cRefs == 0 && _pContainer == 0 );
    Win4Assert( _cAdvise == 0 );

    if ( 0 != _pContainer )
        StopNotifications();

} //~CRowsetAsynchNotification


//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::AddRef, public
//
//  Synopsis:   Increments aggregated object ref. count.
//
//  Returns:    ULONG
//
//  History:    07-Oct-1994     dlee
//
//--------------------------------------------------------------------------

STDMETHODIMP_(ULONG) CRowsetAsynchNotification::AddRef()
{
    return InterlockedIncrement( (long *) &_cRefs );
} //AddRef

//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::Release, public
//
//  Synopsis:   Decrements aggregated obj. ref. count, deletes on final release.
//
//  Returns:    ULONG
//
//  History:    07-Oct-1994     dlee
//
//--------------------------------------------------------------------------

STDMETHODIMP_(ULONG) CRowsetAsynchNotification::Release()
{
    long cRefs = InterlockedDecrement((long *) &_cRefs);

    tbDebugOut(( DEB_NOTIFY, "conpt: release, new crefs: %lx\n", _cRefs ));

    // If no references, make sure container doesn't know about me anymore
    if ( 0 == cRefs )
    {
        Win4Assert( 0 == _pContainer );

        if ( 0 != _pContainer )
        {
            // must have gotten here through excess client release
            StopNotifications();
        }

        delete this;
    }

    return cRefs;
} //Release


//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::StopNotifications
//
//  Synopsis:   Shuts down the notification thread (if any)
//
//  History:    07-Oct-1994     dlee
//
//--------------------------------------------------------------------------

void CRowsetAsynchNotification::StopNotifications()
{
    if ( GetCurrentThreadId() == _threadNotifyId )
    {
        Win4Assert( !"Notification thread used illegally" );
        return;
    }

    _EndNotifyThread();

    Disconnect();
    _AsynchConnectionPoint.Disconnect( );

    if (_fDoWatch)
        _WatchConnectionPoint.Disconnect( );
}


//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::_EndNotifyThread
//
//  Synopsis:   Shuts down the notification thread (if any)
//
//  History:    07-Oct-1994     dlee
//
//--------------------------------------------------------------------------

void CRowsetAsynchNotification::_EndNotifyThread()
{
    //
    // Is there a thread out there to close?
    //

    if (0 != _threadNotify)
    {
        // Signal the thread to die and wait for it to do so, or just kill
        // the thread if it looks like it might be lost in client code.

        tbDebugOut(( DEB_NOTIFY,
                     "set notify thread die event %lx\n",
                     _evtEndNotifyThread.GetHandle() ));

        _evtEndNotifyThread.Set();

        DWORD dw = WaitForSingleObject( _threadNotify, INFINITE );

        BOOL fCloseWorked = CloseHandle( _threadNotify );

        Win4Assert( fCloseWorked && "CloseHandle of notify thread failed" );

        _threadNotify = 0;

        tbDebugOut(( DEB_NOTIFY, "notify thread is history \n"));
    }
} //_EndNotifyThread

//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::_StartNotifyThread
//
//  Synopsis:   Starts the notification thread
//
//  History:    17 Mar 1998     AlanW
//
//--------------------------------------------------------------------------

inline void CRowsetAsynchNotification::_StartNotifyThread()
{
    tbDebugOut(( DEB_NOTIFY, "starting rowset notify thread\n" ));

    // First advise, create the thread
    Win4Assert(0 == _threadNotify);
    _threadNotify = CreateThread( 0, 65536,
                                  (LPTHREAD_START_ROUTINE) _NotifyThread,
                                  this, 0, & _threadNotifyId );

    if (0 == _threadNotify)
        THROW( CException() );
}

//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::_NotifyThread, private
//
//  Synopsis:   Entry point for notification thread
//
//  Arguments:  [self]             -- a container to call to do the work
//
//  Returns:    Thread exit code
//
//  Notes:      this function is "static"
//
//  History:    07-Oct-1994     dlee
//
//--------------------------------------------------------------------------

DWORD CRowsetAsynchNotification::_NotifyThread(
    CRowsetAsynchNotification *self)
{
    TRANSLATE_EXCEPTIONS;

    DWORD dw = self->_DoNotifications();

    UNTRANSLATE_EXCEPTIONS;

    return dw;
} //_NotifyThread

//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::_DoNotifications, private
//
//  Synopsis:   Collects notifications and passes them out to clients.
//              Loops sending notifications until event to end thread
//              arrives.
//
//  Returns:    Thread exit code
//
//  History:    07-Oct-1994     dlee
//
//--------------------------------------------------------------------------

DWORD CRowsetAsynchNotification::_DoNotifications()
{
    BOOL fContinue = TRUE;

    do
    {
        TRY
        {
            if (fContinue && _AsynchConnectionPoint.GetAdviseCount() )
                fContinue = _DoAsynchNotification();

            if (fContinue && _fDoWatch &&
                _WatchConnectionPoint.GetAdviseCount() )
                fContinue = _DoWatchNotification();

            if (_fPopulationComplete && !_fDoWatch)
                fContinue = FALSE;
        }
        CATCH( CException, e )
        {
            // don't want to 'break' out of a catch block, use variable

            fContinue = FALSE;
        }
        END_CATCH;

        // Sleep for a bit, but wake up if the thread is to go away,

        ULONG x = _evtEndNotifyThread.Wait( defNotificationSleepDuration,
                                            FALSE );

        if ( STATUS_WAIT_0 == x )
            fContinue = FALSE;
    } while ( fContinue );

    return 0;
} //_DoNotifications

//+-------------------------------------------------------------------------
//
//  Function:   IsLowResources
//
//  Synopsis:   Returns TRUE if it looks like the error is resource related.
//
//  Returns:    BOOL - TRUE if low on resources
//
//  History:    9  May 1999   dlee
//
//--------------------------------------------------------------------------

BOOL IsLowResources( SCODE sc )
{
    return E_OUTOFMEMORY == sc ||
           STATUS_NO_MEMORY == sc ||
           STATUS_COMMITMENT_LIMIT == sc ||
           STATUS_INSUFFICIENT_RESOURCES == sc ||
           HRESULT_FROM_WIN32( ERROR_COMMITMENT_LIMIT ) == sc ||
           HRESULT_FROM_WIN32( ERROR_NO_SYSTEM_RESOURCES ) == sc ||
           STG_E_INSUFFICIENTMEMORY == sc;
} //IsLowResources

//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::_DoAsynchNotification, private
//
//  Synopsis:   Collects asynch notifications and passes them out to clients.
//              Tracks whether rowset population is completed, after which
//              no more notifications are given (except for completion
//              notifications for new advises).
//
//  Returns:    BOOL - TRUE if notification thread should continue
//
//  History:    18 Mar 1998     AlanW
//
//--------------------------------------------------------------------------

inline DWORD MapAsynchPhaseAndOp( ULONG op, ULONG phase )
{
    Win4Assert( op == 0 && phase < 4 );
    return (((op+1) << 4) | (1 << phase));
}

#define ASYNC_PHASE_MASK 0x0F
#define ASYNC_OP_MASK    0xF0

BOOL CRowsetAsynchNotification::_DoAsynchNotification()
{
    DBCOUNTITEM ulDenominator = 0, ulNumerator = 0;
    DBCOUNTITEM cRows = 0;
    BOOL fNewRows = FALSE;
    SCODE sc = S_OK;

    TRY
    {
        CNotificationSync Sync( _evtEndNotifyThread.GetHandle() );
        sc = _query.RatioFinished( Sync,
                                   _hCursor,
                                   ulDenominator,
                                   ulNumerator,
                                   cRows,
                                   fNewRows );
    
        // Did the main thread tell this thread to go away?
    
        if ( SUCCEEDED( sc ) )
        {
            Win4Assert( ulDenominator > 0 && ulNumerator <= ulDenominator );
    
            if (fNewRows)
                OnRowChange( _pRowset, 0, 0, DBREASON_ROW_ASYNCHINSERT,
                             DBEVENTPHASE_DIDEVENT, TRUE );
    
            if (!_fPopulationComplete && (ulNumerator == ulDenominator))
            {
                OnRowsetChange( _pRowset, DBREASON_ROWSET_POPULATIONCOMPLETE,
                                DBEVENTPHASE_DIDEVENT, TRUE );
    
                _fPopulationComplete = TRUE;
            }
        }
    }
    CATCH( CException, e )
    {
        sc = e.GetErrorCode();
    }
    END_CATCH;

    if ( STATUS_CANCELLED == sc )
        return FALSE;

    BOOL fLowResources = IsLowResources( sc );

    if ( !fLowResources && !SUCCEEDED( sc ) )
        return FALSE;

    // Give notice to all active advises.
    // Need to be careful here to avoid deadlock.  The enumerator
    // grabs the CPC's mutex.  This limits what the client can do.

    ULONG ulAsynchPhase = DBASYNCHPHASE_POPULATION;
    if (_fPopulationComplete)
        ulAsynchPhase = DBASYNCHPHASE_COMPLETE;
    ULONG dwOpMask = MapAsynchPhaseAndOp( DBASYNCHOP_OPEN, ulAsynchPhase );

    CEnumConnectionsLite Enum( _AsynchConnectionPoint );
    CConnectionPointBase::CConnectionContext *pConnCtx = Enum.First();

    while ( 0 != pConnCtx )
    {
        IDBAsynchNotify *pNotifyAsynch = (IDBAsynchNotify *)(pConnCtx->_pIUnk);
        tbDebugOut(( DEB_NOTIFY, "rownotfy: pinging asynch client %x\n", pNotifyAsynch ));
        SCODE sc = S_OK;

        if ( fLowResources )
        {
            //
            // Let the client know we're really wedged and they might not
            // get more notifications consistently.
            //

            sc = pNotifyAsynch->OnLowResource( 0 );
        }
        else
        {
            if ( 0 == (pConnCtx->_dwSpare & dwOpMask) )
            {
                sc = pNotifyAsynch->OnProgress( DB_NULL_HCHAPTER,
                                                DBASYNCHOP_OPEN,
                                                ulNumerator, ulDenominator,
                                                ulAsynchPhase, 0);
            }

            BOOL fOnStop = FALSE;
            if ( _fPopulationComplete && S_OK == sc )
            {
                sc = DB_S_UNWANTEDPHASE;
                fOnStop = TRUE;
            }
    
            if (DB_S_UNWANTEDPHASE == sc)
                pConnCtx->_dwSpare |= (dwOpMask & ASYNC_PHASE_MASK);
            else if (DB_S_UNWANTEDOPERATION == sc)
                pConnCtx->_dwSpare |= (dwOpMask & ASYNC_OP_MASK);
            else if (E_NOTIMPL == sc)
                pConnCtx->_dwSpare |= (ASYNC_PHASE_MASK | ASYNC_OP_MASK);

            if ( fOnStop )
                pNotifyAsynch->OnStop( DB_NULL_HCHAPTER,
                                       DBASYNCHOP_OPEN,
                                       S_OK,
                                       0 );
        }

        tbDebugOut(( DEB_NOTIFY, "rownotfy:(end) pinging asynch client\n" ));
        pConnCtx = Enum.Next();
    }

    // Keep trying to get notifications even if fLowResources is TRUE

    return TRUE;
} //_DoAsynchNotification

//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::_DoWatchNotification, private
//
//  Synopsis:   Collects watch notifications and passes them out to clients.
//
//  Returns:    BOOL - TRUE if notification thread should continue
//
//  History:    18 Mar 1998     AlanW
//
//--------------------------------------------------------------------------

BOOL CRowsetAsynchNotification::_DoWatchNotification()
{
    // get notification information from the cursor

    CNotificationSync Sync( _evtEndNotifyThread.GetHandle() );
    DBWATCHNOTIFY changeType;

    SCODE sc = _query.GetNotifications( Sync, changeType );

    // Did the main thread tell this thread to go away?

    if (STATUS_CANCELLED == sc)
        return FALSE;

    if (!SUCCEEDED(sc))
        return FALSE;

    // got some, give them to all active advises
    // Need to be careful here to avoid deadlock.  The enumerator
    // grabs the CPC's mutex.  We need to break out of the loop
    // if the notify thread needs to go away...

    tbDebugOut(( DEB_NOTIFY, "rownotfy: watch type %d\n", changeType ));
    CEnumConnectionsLite Enum( _WatchConnectionPoint );
    CConnectionPointBase::CConnectionContext *pConnCtx = Enum.First();

    while ( pConnCtx )
    {
        IRowsetWatchNotify *pNotifyWatch =
                (IRowsetWatchNotify *)(pConnCtx->_pIUnk);
        tbDebugOut(( DEB_NOTIFY, "rownotfy: pinging watch client %x\n", pNotifyWatch ));
        pNotifyWatch->OnChange( _pRowset, changeType);
        tbDebugOut(( DEB_NOTIFY, "rownotfy:(end) pinging watch client\n" ));
        pConnCtx = Enum.Next();
    }

    return TRUE;
} //_DoWatchNotification

//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::AdviseHelper, private static
//
//  Synopsis:   Starts the notification thread if this is the first advise.
//
//  Arguments:  [pHelperContext] - "this" pointer
//              [pConnPt] - the connection point, either Async or Watch CP
//              [pConnCtx] - pointer to connection context
//
//  Notes:      CPC critical section is assumed to be held.
//
//  History:    17 Mar 1998     AlanW
//
//--------------------------------------------------------------------------

void CRowsetAsynchNotification::AdviseHelper( PVOID pHelperContext,
                                             CConnectionPointBase * pConnPt,
                                             CConnectionContext * pConnCtx )
{
    CRowsetAsynchNotification * pSelf =
        (CRowsetAsynchNotification *) pHelperContext;

    pSelf->_cAdvise++;
    if (1 == pSelf->_cAdvise)
    {
        // First advise, create the notification thread
        pSelf->_StartNotifyThread();
        Win4Assert(0 != pSelf->_threadNotify);
    }
}

//+-------------------------------------------------------------------------
//
//  Method:     CRowsetAsynchNotification::UnadviseHelper, private static
//
//  Synopsis:   Stops the notification thread if this is the last active advise.
//
//  Arguments:  [pHelperContext] -- "this" pointer
//              [pConnPt]        -- the connection point, either Async or
//                                  Watch CP
//              [pConnCtx]       -- pointer to connection context
//              [lock]           -- CPC lock
//
//  Notes:      CPC critical section is assumed to be held.
//
//  History:    17 Mar 1998     AlanW
//
//--------------------------------------------------------------------------

void CRowsetAsynchNotification::UnadviseHelper(
    PVOID pHelperContext,
    CConnectionPointBase * pConnPt,
    CConnectionContext * pConnCtx,
    CReleasableLock & lock )
{
    CRowsetAsynchNotification * pSelf =
        (CRowsetAsynchNotification *) pHelperContext;

    Win4Assert( pSelf->_cAdvise > 0 );
    if ( --pSelf->_cAdvise == 0 )
    {
        // Release the lock so the notify thread has a change to end
        // when we tell it to end.

        lock.Release();

        pSelf->_EndNotifyThread();
    }
}


//+-------------------------------------------------------------------------
//
//  Function:   MapPhaseAndReason, inline local
//
//  Synopsis:   Encode IRowsetNotify phase and reason into a bit mask
//              for supported phases and reasons.  Luckily, most supported
//              reasons have only a single phase.  Multi-phase reasons take
//              5 bits.
//
//  Returns:    DWORD - bit mask for the reason/phase combination
//
//  History:    18 Mar 1998     AlanW
//
//--------------------------------------------------------------------------

const maxSinglePhaseReasons = 8;
const maxMultiPhaseReasons = 4;
const maxPhases = 5;
const bitDidNotifyVote = 0x80000000;

inline DWORD MapPhaseAndReason( ULONG phase, ULONG reason )
{
    Win4Assert( reason <= 21 && phase <= 4 );

    BOOL fSinglePhase = TRUE;
    DWORD dwMappedReason = 0;

    switch (reason)
    {
    // single-phase reasons
    case DBREASON_ROW_ASYNCHINSERT:
        dwMappedReason = 0;     break;
    case DBREASON_ROWSET_RELEASE:
        dwMappedReason = 1;     break;
    case DBREASON_ROW_ACTIVATE:
        dwMappedReason = 2;     break;
    case DBREASON_ROW_RELEASE:
        dwMappedReason = 3;     break;
    case DBREASON_ROWSET_POPULATIONCOMPLETE:
        dwMappedReason = 4;     break;
    case DBREASON_ROWSET_POPULATIONSTOPPED:
        dwMappedReason = 5;     break;

    // multi-phase reasons
    case DBREASON_ROWSET_FETCHPOSITIONCHANGE:
        dwMappedReason = 0;     fSinglePhase = FALSE;   break;

    default:
        tbDebugOut(( DEB_ERROR, "MapPhaseAndReason - reason: %d phase: %d\n",
                     reason, phase ));
        Win4Assert( !"MapPhaseAndReason: unhandled reason" );
    }

    Win4Assert( FALSE == fSinglePhase || phase == DBEVENTPHASE_DIDEVENT );
    if (fSinglePhase)
    {
        Win4Assert( dwMappedReason < maxSinglePhaseReasons );
        dwMappedReason = (1 << dwMappedReason);
    }
    else
    {
        dwMappedReason = dwMappedReason*maxPhases + phase + maxSinglePhaseReasons;
        Win4Assert( dwMappedReason <= 30 );
        dwMappedReason = (1 << dwMappedReason);
    }

    return dwMappedReason;
}

//+-------------------------------------------------------------------------
//
//  Function:   MapAllPhases, inline local
//
//  Synopsis:   Return a bit mask that includes all bits for all supported
//              phases of the encoded reason.
//
//  Arguments:  [dwMappedReasonAndPhase] - a bit mask returned by
//                                         MapPhaseAndReason.
//
//  Returns:    DWORD - bit mask for all phases
//
//  History:    18 Mar 1998     AlanW
//
//--------------------------------------------------------------------------

inline DWORD MapAllPhases( DWORD dwMappedReasonAndPhase )
{
    Win4Assert( dwMappedReasonAndPhase != 0 );

    if (dwMappedReasonAndPhase < (1<<maxSinglePhaseReasons))
        return dwMappedReasonAndPhase;

    // dwMask == 0x00001F00
    DWORD dwMask = (((1<<maxPhases)-1) << maxSinglePhaseReasons);
    for (unsigned i=0; i<maxMultiPhaseReasons; i++)
    {
        if (dwMask & dwMappedReasonAndPhase)
            return (dwMappedReasonAndPhase | dwMask);

        dwMask = dwMask << maxPhases;
    }
    Win4Assert(! "MapAllPhases - fell out of loop!" );
    return 0;
}

//+-------------------------------------------------------------------------
//
//  Method:     IRowsetNotify::OnXxxxChange
//
//  Synopsis:   Dispatches CRowsetNotification notifications to clients.
//
//  Returns:    SCODE
//
//  History:    11 Mar 1998     AlanW
//
//--------------------------------------------------------------------------

SCODE CRowsetNotification::OnFieldChange (
    IRowset *    pRowset,
    HROW         hRow,
    DBORDINAL    cColumns,
    DBORDINAL    rgColumns[],
    DBREASON     eReason,
    DBEVENTPHASE ePhase,
    BOOL         fCantDeny )
{
    SCODE sc = S_OK;

    //  NOTE:  OnFieldChange is not generated by our rowsets.  This code
    //         doesn't handle unwanted phases or reasons.

    CEnumConnectionsLite Enum( *this );
    CConnectionPointBase::CConnectionContext *pConnCtx = Enum.First();

    while ( pConnCtx )
    {
        IRowsetNotify *pNotify = (IRowsetNotify *)(pConnCtx->_pIUnk);
        tbDebugOut(( DEB_NOTIFY, "rownotfy: pinging notify client %x\n", pNotify ));
        SCODE sc1 = pNotify->OnFieldChange( pRowset,
                                             hRow,
                                             cColumns,
                                             rgColumns,
                                             eReason,
                                             ePhase,
                                             fCantDeny );
        tbDebugOut(( DEB_NOTIFY, "rownotfy:(end) pinging notify client\n" ));
        pConnCtx = Enum.Next();
    }
    return sc;
}

SCODE CRowsetNotification::OnRowChange (
    IRowset *    pRowset,
    DBCOUNTITEM  cRows,
    const HROW   rghRows[],
    DBREASON     eReason,
    DBEVENTPHASE ePhase,
    BOOL         fCantDeny )
{
    // Note:  we don't generate any row notifications which can be denied.
    Win4Assert( fCantDeny && DBEVENTPHASE_DIDEVENT == ePhase );

    DWORD dwMask = MapPhaseAndReason( ePhase, eReason );
    CEnumConnectionsLite Enum( *this );
    CConnectionPointBase::CConnectionContext *pConnCtx = Enum.First();

    while ( pConnCtx )
    {
        if (0 == (pConnCtx->_dwSpare & dwMask))
        {
            IRowsetNotify *pNotify = (IRowsetNotify *)(pConnCtx->_pIUnk);
            tbDebugOut(( DEB_NOTIFY, "rownotfy: pinging notify client %x\n", pNotify ));
            SCODE sc1 = pNotify->OnRowChange( pRowset,
                                              cRows,
                                              rghRows,
                                              eReason,
                                              ePhase,
                                              fCantDeny );
            tbDebugOut(( DEB_NOTIFY, "rownotfy:(end) pinging notify client\n" ));
            if (DB_S_UNWANTEDPHASE == sc1)
                pConnCtx->_dwSpare |= dwMask;
            else if (DB_S_UNWANTEDREASON == sc1)
                pConnCtx->_dwSpare |= MapAllPhases(dwMask);
        }
        pConnCtx = Enum.Next();
    }
    return S_OK;
}

//+-------------------------------------------------------------------------
//
//  Method:     CRowsetNotification::DoRowsetChangeCallout, private
//
//  Synopsis:   Issues an OnRowsetChange notification to all active
//              advises.  If [fCantDeny] is FALSE, tracks which advises
//              were successfully notified and checks the votes.
//
//  Arguments:  [Enum]      - a connection context enumeration
//              [pRowset]   - the rowset issuing the notification
//              [eReason]   - the notification reason
//              [ePhase]    - the notification phase
//              [fCantDeny] - if TRUE, notification can't be denied
//
//  Notes:      CPC critical section is assumed to be held.
//
//  History:    08 Apr 1998     AlanW
//
//--------------------------------------------------------------------------

BOOL CRowsetNotification::DoRowsetChangeCallout (
    CEnumConnectionsLite & Enum,
    IRowset *    pRowset,
    DBREASON     eReason,
    DBEVENTPHASE ePhase,
    BOOL         fCantDeny )
{
    DWORD dwMask = MapPhaseAndReason( ePhase, eReason );
    CConnectionPointBase::CConnectionContext *pConnCtx;
    BOOL fVeto = FALSE;

    for ( pConnCtx = Enum.First(); pConnCtx; pConnCtx = Enum.Next() )
    {
        if ( 0 == (pConnCtx->_dwSpare & dwMask) )
        {
            IRowsetNotify *pNotify = (IRowsetNotify *)(pConnCtx->_pIUnk);
            tbDebugOut(( DEB_NOTIFY, "rownotfy: pinging notify client %x\n", pNotify ));
            SCODE sc1 = pNotify->OnRowsetChange( pRowset,
                                                 eReason,
                                                 ePhase,
                                                 fCantDeny );

            if ( !fCantDeny )
            {
                if (S_FALSE == sc1)
                {
                    tbDebugOut(( DEB_NOTIFY, "rownotfy: notify client veto'ed\n" ));
                    fVeto = TRUE;
                    break;
                }
                pConnCtx->_dwSpare |= bitDidNotifyVote;
            }
            if (DB_S_UNWANTEDPHASE == sc1)
                pConnCtx->_dwSpare |= dwMask;
            else if (DB_S_UNWANTEDREASON == sc1)
                pConnCtx->_dwSpare |= MapAllPhases(dwMask);

            tbDebugOut(( DEB_NOTIFY, "rownotfy:(end) pinging notify client\n" ));
        }
    }
    return fVeto;
}


SCODE CRowsetNotification::OnRowsetChange (
    IRowset *    pRowset,
    DBREASON     eReason,
    DBEVENTPHASE ePhase,
    BOOL         fCantDeny )
{
    // Note: we don't use SYNCHAFTER, and ABOUTTODO is done here after voting
    Win4Assert( DBEVENTPHASE_ABOUTTODO != ePhase &&
                DBEVENTPHASE_SYNCHAFTER != ePhase );

    BOOL fVeto = FALSE;
    CEnumConnectionsLite Enum( *this );

    if ( DBEVENTPHASE_OKTODO == ePhase )
    {
        Win4Assert( !fCantDeny );

        fVeto = DoRowsetChangeCallout( Enum, pRowset, eReason,
                                            DBEVENTPHASE_OKTODO, FALSE );
        if ( ! fVeto )
            fVeto = DoRowsetChangeCallout( Enum, pRowset, eReason,
                                                DBEVENTPHASE_ABOUTTODO, FALSE );

        DWORD dwMask = MapPhaseAndReason( DBEVENTPHASE_FAILEDTODO, eReason );
        CConnectionPointBase::CConnectionContext *pConnCtx;

        for ( pConnCtx = Enum.First(); pConnCtx; pConnCtx = Enum.Next() )
        {
            if (fVeto &&
                0 == (pConnCtx->_dwSpare & dwMask) &&
                0 != (pConnCtx->_dwSpare & bitDidNotifyVote) )
            {
                IRowsetNotify *pNotify = (IRowsetNotify *)(pConnCtx->_pIUnk);
                tbDebugOut(( DEB_NOTIFY, "rownotfy: pinging notify client %x for FAIL\n", pNotify ));
                SCODE sc1 = pNotify->OnRowsetChange( pRowset,
                                                     eReason,
                                                     DBEVENTPHASE_FAILEDTODO,
                                                     TRUE );
                tbDebugOut(( DEB_NOTIFY, "rownotfy:(end) pinging notify client for FAIL\n" ));

                if (DB_S_UNWANTEDPHASE == sc1)
                    pConnCtx->_dwSpare |= dwMask;
                else if (DB_S_UNWANTEDREASON == sc1)
                    pConnCtx->_dwSpare |= MapAllPhases(dwMask);
            }
            pConnCtx->_dwSpare &= ~bitDidNotifyVote;
        }
    }
    else
    {
        // a non-vetoable notification; just send the notifies
        Win4Assert( fCantDeny );
        DoRowsetChangeCallout( Enum, pRowset, eReason, ePhase, TRUE );
    }
    return fVeto ? S_FALSE : S_OK;
}