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

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1996 - 2000.
//
//  File:       svcproxy.cxx
//
//  Contents:   Proxy to cisvc encapsulating all the context for a
//              running query, including the query execution context, the
//              cached query results, and all cursors over the results.
//
//  Classes:    CSvcQueryProxy
//
//  History:    13 Sept 96  dlee created (mostly copied) from queryprx.cxx
//              22 Aug  99  KLam Win64->Win32 support
//
//--------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#include <query.hxx>
#include <pickle.hxx>
#include <memser.hxx>
#include <sizeser.hxx>
#include <propvar.h>
#include <proxymsg.hxx>
#include <tblvarnt.hxx>
#include <tgrow.hxx>
#include <pmalloc.hxx>

#include "tabledbg.hxx"
#include "rowseek.hxx"

//+---------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::CSvcQueryProxy, public
//
//  Synopsis:   Creates a locally accessible Query
//
//  Arguments:  [client]     - Proxy for talking to remote process
//              [cols]       - Columns that may be bound to
//              [rst]        - Query restriction
//              [pso]        - Sort order of the query
//              [pcateg]     - Categorization specification
//              [RstProp]    - Rowset properties for rowset(s) created
//              [pidmap]     - Property ID mapper
//              [cCursors]   - count of cursors expected to be created
//              [aCursors]   - returns handles to cursors created
//
//  History:    13 Sept 96  dlee created
//
//----------------------------------------------------------------------------

CSvcQueryProxy::CSvcQueryProxy(
    CRequestClient &           client,
    CColumnSet const &         cols,
    CRestriction const &       rst,
    CSortSet const *           pso,
    CCategorizationSet const * pcateg,
    CRowsetProperties const &  RstProp,
    CPidMapper const &         pidmap ,
    ULONG                      cCursors,
    ULONG *                    aCursors )
        : _ref( 0 ),
          _client( client ),
          _fTrueSequential( FALSE ),
          _fWorkIdUnique( FALSE ),
          _xQuery( ),
          _xBindings( )
{
    tbDebugOut(( DEB_PROXY, "CSvcQueryProxy\n" ));

    // DSO property IDs change with version 5

    if ( _client.GetServerVersion() < 5 )
       THROW( CException( STATUS_INVALID_PARAMETER_MIX ) );

    _aCursors.Init( cCursors );

    ULONG cbIn = PickledSize( _client.GetServerVersion(),
                              &cols,
                              &rst,
                              pso,
                              pcateg,
                              &RstProp,
                              &pidmap );
    cbIn = AlignBlock( cbIn, sizeof ULONG );
    XArray<BYTE> xQuery( cbIn + sizeof CPMCreateQueryIn );
    BYTE * pbPickledQuery = xQuery.GetPointer() + sizeof CPMCreateQueryIn;
    Pickle( _client.GetServerVersion(),
            &cols,
            &rst,
            pso,
            pcateg,
            &RstProp,
            &pidmap,
            pbPickledQuery,
            cbIn );

    CPMCreateQueryIn & request = * ( new( xQuery.Get() ) CPMCreateQueryIn );

    request.SetCheckSum( xQuery.SizeOf() );

    const unsigned cbCursors = sizeof ULONG * cCursors;
    const unsigned cbReply = sizeof CPMCreateQueryOut + cbCursors;
    XGrowable<BYTE, 200> xReply( cbReply );
    CPMCreateQueryOut * pReply = new( xReply.Get() ) CPMCreateQueryOut();

    ULONG cbRead;
    _client.DataWriteRead( &request,
                           xQuery.SizeOf(),
                           pReply,
                           cbReply,
                           cbRead );

    // DataWriteRead throws both connection problems and request problems

    Win4Assert( SUCCEEDED( pReply->GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || cbReply == cbRead );

    _fTrueSequential = pReply->IsTrueSequential();
    _fWorkIdUnique = pReply->IsWorkIdUnique();
    _ulServerCookie = pReply->GetServerCookie();

    RtlCopyMemory( aCursors, pReply->GetCursors(), cbCursors );

    //
    // Preserve xQuery for RestartPosition on sequential queries
    //
    if ( _fTrueSequential )
    {
        unsigned cElems = xQuery.Count();
        _xQuery.Set( cElems, xQuery.Acquire() );

        // The assumption here is that for a seq query the cursor does not
        // change.  If this becomes different at a later date, the rowset
        // will have an old cursor after RestartPosition.

        RtlCopyMemory( _aCursors.Get(), aCursors, cbCursors );
    }

    #if CIDBG == 1
        for ( ULONG i = 0; i < cCursors; i++ )
            Win4Assert( 0 != aCursors[i] );
    #endif // CIDBG == 1

    AddRef();
} //CSvcQueryProxy

//+---------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::~CSvcQueryProxy, public
//
//  Synopsis:   Destroy the query.  Nothing to do -- all of the cursors
//              have been freed by now.
//
//  History:    13 Sept 96  dlee created
//
//----------------------------------------------------------------------------

CSvcQueryProxy::~CSvcQueryProxy()
{
    tbDebugOut(( DEB_PROXY, "~CSvcQueryProxy\n\n" ));
    Win4Assert( 0 == _ref );

    // don't _client.Disconnect() here -- keep it open for more queries

} //~CSvcQueryProxy

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::AddRef, public
//
//  Synopsis:   Reference the query.
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

ULONG CSvcQueryProxy::AddRef()
{
    return InterlockedIncrement( & _ref );
} //AddRef

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::Release, public
//
//  Synopsis:   De-Reference the query.
//
//  Effects:    If the ref count goes to 0 then the query is deleted.
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

ULONG CSvcQueryProxy::Release()
{
    long l = InterlockedDecrement( & _ref );

    if ( l <= 0 )
    {
        tbDebugOut(( DEB_PROXY, "CSvcQueryProxy unreferenced.  Deleting.\n" ));
        delete this;
        return 0;
    }

    return l;
} //Release

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::FreeCursor, public
//
//  Synopsis:   Free a handle to a CTableCursor
//
//  Arguments:  [hCursor] - handle to the cursor to be freed
//
//  Returns:    # of cursors remaining
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

unsigned CSvcQueryProxy::FreeCursor(
    ULONG hCursor )
{
    tbDebugOut(( DEB_PROXY, "FreeCursor\n" ));
    Win4Assert( 0 != hCursor );

    // If FreeCursor fails (likely because the system is out of memory),
    // terminate the connection with cisvc so query resources are freed.

    TRY
    {
        CPMFreeCursorIn request( hCursor );
        CPMFreeCursorOut reply;
        ULONG cbRead;
        _client.DataWriteRead( &request,
                               sizeof request,
                               &reply,
                               sizeof reply,
                               cbRead );

        Win4Assert( SUCCEEDED( reply.GetStatus() ) );
        Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );

        return reply.CursorsRemaining();
    }
    CATCH( CException, e )
    {
        prxDebugOut(( DEB_IWARN,
                      "freecursor failed 0x%x, rudely terminating connection\n",
                      e.GetErrorCode() ));

        _client.TerminateRudelyNoThrow();

        RETHROW();
    }
    END_CATCH

    return 0;
} //FreeCursor

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::GetRows, public
//
//  Synopsis:   Retrieve row data for a table cursor
//
//  Arguments:  [hCursor] - the handle of the cursor to fetch data for
//              [rSeekDesc] - row seek operation to be done before fetch
//              [pGetRowsParams] - row fetch parameters and buffer pointers
//              [pSeekDescOut] - row seek description for restart
//
//  Returns:    SCODE - the status of the operation.
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

SCODE CSvcQueryProxy::GetRows(
    ULONG                       hCursor,
    const CRowSeekDescription & rSeekDesc,
    CGetRowsParams &            rGetRowsParams,
    XPtr<CRowSeekDescription> & pSeekDescOut)
{
    tbDebugOut(( DEB_PROXY,
                 "GetRows 0x%x\n",
                 rGetRowsParams.RowsToTransfer() ));

    unsigned cbSeek = rSeekDesc.MarshalledSize();
    unsigned cbInput = sizeof CPMGetRowsIn + cbSeek;
    unsigned cbReserved = AlignBlock( sizeof CPMGetRowsOut + cbSeek,
                                      sizeof LONGLONG );
    XArray<BYTE> xIn( cbInput );
    CPMGetRowsIn *pRequest = new( xIn.Get() )
                             CPMGetRowsIn( hCursor,
                                           rGetRowsParams.RowsToTransfer(),
                                           rGetRowsParams.GetFwdFetch(),
                                           rGetRowsParams.GetRowWidth(),
                                           cbSeek,
                                           cbReserved );
    // serialize the seek description

    CMemSerStream stmMem( pRequest->GetDesc(), cbSeek );
    rSeekDesc.Marshall( stmMem );

    // Make an allocator for the output.  Scale the buffer size based
    // on the # of rows to be retrieved (just a heuristic).  Large buffers
    // are more expensive since the entire buffer must be sent over the
    // pipe (since var data grows down from the end of the buffer).

    // For 10 rows in a typical web query, it takes about 7-10k.  Any way
    // to squeeze it so it always fits in 8k?  Eg:
    // filename,size,characterization,vpath,doctitle,write
    // filename -- 20
    // abstract -- 640
    // props+variants -- 16*6
    // vpath -- 100
    // title -- 80
    // total: 936 * 10 rows = 9360 bytes

    const unsigned cbGetRowsGranularity = 512;
    const unsigned cbBigRow = 1000;
    const unsigned cbNormalRow = 300;
    unsigned cbOut = rGetRowsParams.RowsToTransfer() * cbBigRow;
    cbOut = __max( rGetRowsParams.GetRowWidth(), cbOut );
    cbOut = __min( cbOut, cbMaxProxyBuffer );
    XArray<BYTE> xOut;

    // loop until at least 1 row fits in a buffer

    CPMGetRowsOut *pReply = 0;
    NTSTATUS Status = 0;
    DWORD cbRead;
    do
    {
        cbOut = AlignBlock( cbOut, cbGetRowsGranularity );
        Win4Assert( cbOut <= cbMaxProxyBuffer );
        xOut.ReSize( cbOut );

        pReply = (CPMGetRowsOut *) xOut.GetPointer();
        pRequest->SetReadBufferSize( cbOut );

#ifdef _WIN64
        //
        // If a Win64 client is talking to a Win32 server set the base in the sent
        // buffer to 0 so that the values returned are offsets and remember what the
        // real pointer is.
        // Otherwise, be sure to set the reply base pointer to zero to indicate to the
        // rowset that no munging has to be done.
        //
       if ( !_client.IsServer64() )
       {
            pRequest->SetClientBase ( 0 );
            rGetRowsParams.SetReplyBase ( (BYTE *) pReply );
       }
       else
       {
            pRequest->SetClientBase( (ULONG_PTR) pReply );
       }
#else 
        pRequest->SetClientBase( (ULONG_PTR) pReply );
#endif

        pRequest->SetCheckSum( cbInput );

        TRY
        {
            _client.DataWriteRead( pRequest,
                                   cbInput,
                                   pReply,
                                   cbOut,
                                   cbRead );

            Status = pReply->GetStatus();
        }
        CATCH( CException, e )
        {
            Status = e.GetErrorCode();
        }
        END_CATCH;
    } while ( ( Status == STATUS_BUFFER_TOO_SMALL ) &&
              ( cbOut++ < cbMaxProxyBuffer ) );

    prxDebugOut(( DEB_ITRACE, "Status at end of getrows: 0x%x\n", Status ));
    Win4Assert( pReply == (CPMGetRowsOut *) xOut.GetPointer() );

    SCODE scResult = 0;

    if ( NT_SUCCESS( Status ) )
    {
        rGetRowsParams.SetRowsTransferred( pReply->RowsReturned() );

        CMemDeSerStream stmDeser( pReply->GetSeekDesc(), cbReserved );
        UnmarshallRowSeekDescription( stmDeser,
                                      _client.GetServerVersion(),
                                      pSeekDescOut,
                                      TRUE );

        // Hand off the block to the allocator made in CRowset

        Win4Assert( pReply == (CPMGetRowsOut *) xOut.GetPointer() );
        PFixedVarAllocator & rAlloc = rGetRowsParams.GetFixedVarAllocator();
        rAlloc.ReInit( TRUE, cbReserved, xOut.Acquire(), cbOut );

        // we have pointers already, not offsets

        rAlloc.SetBase( 0 );

        scResult = Status;  // ok, endOfRowset, blockLimitedRows, etc.
    }
    else
    {
        if ( DB_E_BADRATIO != Status && DB_E_BADSTARTPOSITION != Status) {
            prxDebugOut(( DEB_ERROR, "GetRows returned 0x%x\n", Status ));
        }

        if ( NT_WARNING( Status ) )
            scResult = Status;      // presumably, status is an SCODE
        else
            scResult = E_FAIL;
    }

    return scResult;
} //GetRows

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::ReExecuteSequentialQuery, private
//
//  Synopsis:   Simulates re-execution of a sequential query by shutting down
//              the query object on the server, recreating it and setting up
//              the bindings from cached values
//
//  Arguments:
//
//  History:    02-28-98    danleg      Created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::ReExecuteSequentialQuery()
{
    tbDebugOut(( DEB_PROXY, "ReExecuteSequentialQuery\n" ));

    // SPECDEVIATION: if we have heirarchical rowsets, all current positions
    // will be reset.

    //
    // Shutdown the existing PQuery on the server first
    //
    for ( unsigned i=0; i<_aCursors.Count(); i++ )
        FreeCursor( _aCursors[i] );

    //
    // Recreate PQuery on the server
    //
    CPMCreateQueryIn * pCreateReq =  (CPMCreateQueryIn *) _xQuery.Get();

    const unsigned cbCursors = sizeof ULONG * _aCursors.Count();
    const unsigned cbReply = sizeof CPMCreateQueryOut + cbCursors;

    XGrowable<BYTE, 200> xReply( cbReply );
    CPMCreateQueryOut * pReply = new( xReply.Get() ) CPMCreateQueryOut();

    ULONG cbRead;
    _client.DataWriteRead( pCreateReq,
                           _xQuery.SizeOf(),
                           pReply,
                           cbReply,
                           cbRead );

    // DataWriteRead throws both connection problems and request problems
    Win4Assert( SUCCEEDED( pReply->GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || cbReply == cbRead );

    _fTrueSequential = pReply->IsTrueSequential();
    _fWorkIdUnique = pReply->IsWorkIdUnique();
    _ulServerCookie = pReply->GetServerCookie();

    RtlCopyMemory( _aCursors.Get(), pReply->GetCursors(), _aCursors.Count() );

    //
    // Recreate bindings
    //
    CProxyMessage reply;
    CPMSetBindingsIn *pBindReq = (CPMSetBindingsIn *) _xBindings.Get();

    ULONG cbRequest = sizeof CPMSetBindingsIn + pBindReq->GetBindingDescLength();
    cbRequest = AlignBlock( cbRequest, sizeof ULONG );

    _client.DataWriteRead( pBindReq,
                           cbRequest,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );

} // ReExecuteSequentialQuery

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::RestartPosition, public
//
//  Synopsis:   Reset the fetch position for the chapter back to the start
//
//  Arguments:  [hCursor]       - handle of the cursor
//              [chapt]         - chapter
//
//  History:    17 Apr 97   emilyb      created
//              02-01-98    danleg      restart for seq queries
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::RestartPosition(
    ULONG        hCursor,
    CI_TBL_CHAPT chapt )
{
    tbDebugOut(( DEB_PROXY, "RestartPosition\n" ));

    //
    // If sequential, re-execute the query
    //
    if ( _fTrueSequential )
        ReExecuteSequentialQuery();
    else
    {
        CPMRestartPositionIn request( hCursor, chapt );
        CProxyMessage reply;
        DWORD cbRead;
        _client.DataWriteRead( &request,
                               sizeof request,
                               &reply,
                               sizeof reply,
                               cbRead );

        Win4Assert( SUCCEEDED( reply.GetStatus() ) );
        Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );
    }
} //RestartPosition

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::StopAsync, public
//
//  Synopsis:   Stop processing of async rowset
//
//  Arguments:  [hCursor]       - handle of the cursor
//
//  History:    17 Apr 97  emilyb   created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::StopAsynch(
    ULONG        hCursor )
{
    tbDebugOut(( DEB_PROXY, "Stop\n" ));

    CPMStopAsynchIn request( hCursor );
    CProxyMessage reply;
    DWORD cbRead;
    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );
} //StopAsynch

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::StartWatching, public
//
//  Synopsis:   Start watch all behavior for rowset
//
//  Arguments:  [hCursor]       - handle of the cursor
//
//  History:    17 Apr 97  emilyb   created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::StartWatching(
    ULONG        hCursor )
{
    tbDebugOut(( DEB_PROXY, "StartWatching\n" ));

    CPMStartWatchingIn request( hCursor );
    CProxyMessage reply;
    DWORD cbRead;
    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );
} //StartWatching

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::StopWatching, public
//
//  Synopsis:   Stop watch all behavior for rowset
//
//  Arguments:  [hCursor]       - handle of the cursor
//
//  History:    17 Apr 97  emilyb   created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::StopWatching(
    ULONG        hCursor )
{
    tbDebugOut(( DEB_PROXY, "StopWatching\n" ));

    CPMStopWatchingIn request( hCursor );
    CProxyMessage reply;
    DWORD cbRead;
    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );
} //StopWatching

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::RatioFinished, public
//
//  Synopsis:   Return the completion status as a fraction
//
//  Arguments:  [hCursor]        - handle of the cursor to check
//              [rulDenominator] - on return, denominator of fraction
//              [rulNumerator]   - on return, numerator of fraction
//              [rcRows]         - on return, number of rows in cursor
//              [rfNewRows]      - on return, TRUE if new rows available
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::RatioFinished(
    ULONG   hCursor,
    DBCOUNTITEM & rulDenominator,
    DBCOUNTITEM & rulNumerator,
    DBCOUNTITEM & rcRows,
    BOOL &  rfNewRows )
{
    tbDebugOut(( DEB_PROXY, "RatioFinished\n" ));
    SCODE sc = S_OK;

    CPMRatioFinishedIn request( hCursor, TRUE );
    CPMRatioFinishedOut reply;
    DWORD cbReply;
    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbReply );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbReply );

    rulDenominator = reply.Denominator();
    rulNumerator = reply.Numerator();
    rcRows = reply.RowCount();
    rfNewRows = reply.NewRows();

    // the values must be good by now or we would have thrown

    Win4Assert( 0 != rulDenominator );
    Win4Assert( rulDenominator >= rulNumerator );
} //RatioFinished

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::RatioFinished, public
//
//  Synopsis:   Return the completion status as a fraction
//
//  Arguments:  [rSync]          - notification synchronization info
//              [hCursor]        - handle of the cursor to check
//              [rulDenominator] - on return, denominator of fraction
//              [rulNumerator]   - on return, numerator of fraction
//              [rcRows]         - on return, number of rows in cursor
//              [rfNewRows]      - on return, TRUE if new rows available
//
//  Returns:    S_OK or STATUS_CANCELLED if rSync's cancel event signalled.
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

SCODE CSvcQueryProxy::RatioFinished(
    CNotificationSync & rSync,
    ULONG   hCursor,
    DBCOUNTITEM & rulDenominator,
    DBCOUNTITEM & rulNumerator,
    DBCOUNTITEM & rcRows,
    BOOL &  rfNewRows )
{
    tbDebugOut(( DEB_PROXY, "RatioFinished\n" ));
    SCODE sc = S_OK;

    CPMRatioFinishedIn request( hCursor, TRUE );
    CPMRatioFinishedOut reply;
    DWORD cbReply;
    if ( _client.NotifyWriteRead( rSync.GetCancelEvent(),
                                  &request,
                                  sizeof request,
                                  &reply,
                                  sizeof reply,
                                  cbReply ) )
        sc = STATUS_CANCELLED;
    else
    {
        Win4Assert( SUCCEEDED( reply.GetStatus() ) );
        Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbReply );

        rulDenominator = reply.Denominator();
        rulNumerator = reply.Numerator();
        rcRows = reply.RowCount();
        rfNewRows = reply.NewRows();

        // the values must be good by now or we would have thrown

        Win4Assert( 0 != rulDenominator );
        Win4Assert( rulDenominator >= rulNumerator );
    }
    return sc;
} //RatioFinished (notify version)

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::Compare, public
//
//  Synopsis:   Return the approximate current position as a fraction
//
//  Arguments:  [hCursor]       - handle of the cursor used to compare
//              [chapt]         - chapter of bookmarks
//              [bmkFirst]      - First bookmark to compare
//              [bmkSecond]     - Second bookmark to compare
//              [rdwComparison] - on return, comparison value
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::Compare(
    ULONG        hCursor,
    CI_TBL_CHAPT chapt,
    CI_TBL_BMK   bmkFirst,
    CI_TBL_BMK   bmkSecond,
    DWORD &      rdwComparison )
{
    tbDebugOut(( DEB_PROXY, "Compare\n" ));

    CPMCompareBmkIn request( hCursor, chapt, bmkFirst, bmkSecond );
    CPMCompareBmkOut reply;

    DWORD cbRead;
    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );

    rdwComparison = reply.Comparison();
} //Compare

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::GetApproximatePosition, public
//
//  Synopsis:   Return the approximate current position as a fraction
//
//  Arguments:  [hCursor]        - cursor handle used to retrieve info
//              [chapt]          - chapter requested
//              [bmk]            - table bookmark for position
//              [pulNumerator]   - on return, numerator of fraction
//              [pulDenominator] - on return, denominator of fraction
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::GetApproximatePosition(
    ULONG        hCursor,
    CI_TBL_CHAPT chapt,
    CI_TBL_BMK   bmk,
    DBCOUNTITEM * pulNumerator,
    DBCOUNTITEM * pulDenominator )
{
    tbDebugOut(( DEB_PROXY, "GAP\n" ));

    CPMGetApproximatePositionIn request( hCursor, chapt, bmk );
    CPMGetApproximatePositionOut reply;

    DWORD cbRead;
    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );

    *pulNumerator = reply.Numerator();
    *pulDenominator = reply.Denominator();
} //GetApproximatePosition

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::SetBindings, public
//
//  Synopsis:   Set column bindings into a cursor
//
//  Arguments:  [hCursor]     - handle of the cursor to set bindings on
//              [cbRowLength] - the width of an output row
//              [cols]        - a description of column bindings to be set
//              [pids]        - a PID mapper which maps fake pids in cols to
//                              column IDs.
//
//  History:    13 Sept 96  dlee created
//              22 Aug 99   klam Win64 client -> Win32 server
//              09 Feb 2000 KLam Win64: Reset variant size when done
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::SetBindings(
    ULONG             hCursor,
    ULONG             cbRowLength,
    CTableColumnSet & cols,
    CPidMapper &      pids )
{
    tbDebugOut(( DEB_PROXY, "SetBindings\n" ));

#ifdef _WIN64

    // WIN64 client and servers mark the low bit of the hi-word of the
    // version to indicate it is a 64 bit machine.

    if ( !_client.IsServer64() )
    {
        tbDebugOut(( DEB_PROXY, "64bit client querying 32bit server!\n" ));

        // If there is a PROPVARIANT stored, adjust its size
      
        for (unsigned i = 0; i < cols.Count(); i++)
        {
            CTableColumn *pColumn = cols.Get(i);
            tbDebugOut(( DEB_PROXY, "\tFound type: %d width: %d\n",pColumn->GetStoredType(), pColumn->GetValueSize())); 
            if ( VT_VARIANT == pColumn->GetStoredType() )
            {
                pColumn->SetValueField( VT_VARIANT,
                                        pColumn->GetValueOffset(),
                                        SizeOfWin32PROPVARIANT );

                tbDebugOut(( DEB_PROXY, "\tReplacing variant with size %d and offset 0x%x \n", 
                             SizeOfWin32PROPVARIANT, pColumn->GetValueOffset() ));
            }
        }
    }

#endif

    // determine the size of the serialized column set

    CSizeSerStream stmSize;
    cols.Marshall( stmSize, pids );
    ULONG cbRequest = sizeof CPMSetBindingsIn + stmSize.Size();
    cbRequest = AlignBlock( cbRequest, sizeof ULONG );

    XArray<BYTE> xIn( cbRequest );
    CPMSetBindingsIn *pRequest = new( xIn.Get() )
                                 CPMSetBindingsIn( hCursor,
                                                   cbRowLength,
                                                   stmSize.Size() );

    // serialize the column set

    CMemSerStream stmMem( pRequest->GetDescription(), stmSize.Size() );
    cols.Marshall( stmMem, pids );

    pRequest->SetCheckSum( cbRequest );

    CProxyMessage reply;
    DWORD cbRead;

    _client.DataWriteRead( pRequest,
                           cbRequest,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );

#ifdef _WIN64

    if ( !IsCi64(_client.GetServerVersion()) )
    {
        tbDebugOut(( DEB_PROXY, "...64bit client finished querying 32bit server.\n" ));

        //
        // If there is a PROPVARIANT stored, readjust its size back to its original size
        //
        for (unsigned i = 0; i < cols.Count(); i++)
        {
            CTableColumn *pColumn = cols.Get(i);
            tbDebugOut(( DEB_PROXY, "\tFound type: %d width: %d\n",pColumn->GetStoredType(), pColumn->GetValueSize())); 
            if ( VT_VARIANT == pColumn->GetStoredType() )
            {
                pColumn->SetValueField( VT_VARIANT,
                                        pColumn->GetValueOffset(),
                                        sizeof ( PROPVARIANT ) );

                tbDebugOut(( DEB_PROXY, "\tReseting variant with size %d and offset 0x%x \n", 
                             sizeof ( PROPVARIANT ), pColumn->GetValueOffset() ));
            }
        }
    }

#endif

    //
    // Preserve binding stream if sequential for RestartPosition
    //
    if ( _fTrueSequential )
    {
        unsigned cElems = xIn.Count();
        _xBindings.Set( cElems, xIn.Acquire() );
    }

} //SetBindings

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::GetNotifications, public
//
//  Synopsis:   Gets notification information, when available.
//
//  Arguments:  [rSync]      -- notification synchronization info
//              [changeType] -- returns notification data info
//
//  Returns:    S_OK or STATUS_CANCELLED if rSync's cancel event signalled.
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

SCODE CSvcQueryProxy::GetNotifications(
    CNotificationSync & rSync,
    DBWATCHNOTIFY     & changeType)
{
    tbDebugOut(( DEB_PROXY, "GetNotifications\n" ));
    SCODE sc = S_OK;

    CProxyMessage request( pmGetNotify );
    CPMSendNotifyOut reply(0);
    DWORD cbReply;

    if ( _client.NotifyWriteRead( rSync.GetCancelEvent(),
                                  &request,
                                  sizeof request,
                                  &reply,
                                  sizeof reply,
                                  cbReply ) )
        sc = STATUS_CANCELLED;
    else
        changeType = reply.WatchNotify();

    tbDebugOut(( DEB_PROXY, "GetNotifications %d, sc %lx\n", changeType, sc ));
    return sc;
} //GetNotifications

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::SetWatchMode
//
//  Synopsis:   Stub implementation
//
//  Arguments:  [phRegion] - in/out region handle
//              [mode]     - watch mode
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::SetWatchMode(
    HWATCHREGION * phRegion,
    ULONG          mode )
{
    tbDebugOut (( DEB_PROXY, "Calling SetWatchMode\n" ));

    CPMSetWatchModeIn request( *phRegion, mode );
    CPMSetWatchModeOut reply;
    DWORD cbRead;

    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );

    *phRegion = reply.Region();
} //SetWatchMode

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::GetWatchInfo
//
//  Synopsis:   Stub implementation
//
//  Arguments:  [hRegion]   -- handle to watch region
//              [pMode]     -- watch mode
//              [pChapter]  -- chapter
//              [pBookmark] -- bookmark
//              [pcRows]    -- number of rows
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::GetWatchInfo (
    HWATCHREGION   hRegion,
    ULONG *        pMode,
    CI_TBL_CHAPT * pChapter,
    CI_TBL_BMK *   pBookmark,
    DBCOUNTITEM *  pcRows)
{
    tbDebugOut (( DEB_PROXY, "Calling GetWatchInfo\n" ));

    // prepare for failure

    *pBookmark = 0;
    *pChapter = 0;
    *pMode = 0;
    *pcRows = 0;

    CPMGetWatchInfoIn request( hRegion );
    CPMGetWatchInfoOut reply;
    DWORD cbRead;

    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );

    *pMode = reply.Mode();
    *pChapter = reply.Chapter();
    *pBookmark = reply.Bookmark();
    *pcRows = reply.RowCount();
} //GetWatchInfo

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::ShrinkWatchRegion
//
//  Synopsis:   Stub implementation
//
//  Arguments:  [hRegion]  -- handle to watch region
//              [chapter]  -- chapter
//              [bookmark] -- size of bookmark
//              [cRows]    -- number of rows
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::ShrinkWatchRegion (
    HWATCHREGION hRegion,
    CI_TBL_CHAPT chapter,
    CI_TBL_BMK   bookmark,
    LONG         cRows )
{
    tbDebugOut (( DEB_PROXY, " Calling ShrinkWatchRegion\n" ));

    CPMShrinkWatchRegionIn request( hRegion, chapter, bookmark, cRows );
    CProxyMessage reply;
    DWORD cbRead;

    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );
} //ShrinkWatchRegion

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::Refresh
//
//  Synopsis:   Stub implementation
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::Refresh()
{
    tbDebugOut(( DEB_PROXY, "Refresh\n" ));

    CProxyMessage request( pmRefresh );
    CProxyMessage reply;
    DWORD cbRead;

    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );
    tbDebugOut(( DEB_PROXY, "Refresh (end)\n" ));
} //Refresh

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::GetQueryStatus, public
//
//  Synopsis:   Return the query status
//
//  Arguments:  [hCursor]   - handle of the cursor to check
//              [rdwStatus] - on return, the query status
//
//  History:    13 Sept 96  dlee created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::GetQueryStatus(
    ULONG   hCursor,
    DWORD & rdwStatus )
{
    tbDebugOut(( DEB_PROXY, "GetQueryStatus\n" ));

    CPMGetQueryStatusIn request( hCursor );
    CPMGetQueryStatusOut reply;
    DWORD cbRead;

    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );

    rdwStatus = reply.QueryStatus();
} //GetQueryStatus

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::GetQueryStatusEx, public
//
//  Synopsis:   Return the query status plus bonus information.  It's kind
//              of an odd assortment of info, but it saves net trips.
//
//  Arguments:  [hCursor] - handle of the cursor to check completion for
//              [rdwStatus] - returns the query status
//              [rcFilteredDocuments] - returns # of filtered docs
//              [rcDocumentsToFilter] - returns # of docs to filter
//              [rdwRatioFinishedDenominator] - ratio finished denom
//              [rdwRatioFinishedNumerator]   - ratio finished num
//              [bmk]                         - bmk to find
//              [riRowBmk]                    - index of bmk row
//              [rcRowsTotal]                 - # of rows in table
//
//  History:    Nov-9-96   dlee    Created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::GetQueryStatusEx(
    ULONG            hCursor,
    DWORD &          rdwStatus,
    DWORD &          rcFilteredDocuments,
    DWORD &          rcDocumentsToFilter,
    DBCOUNTITEM &    rdwRatioFinishedDenominator,
    DBCOUNTITEM &    rdwRatioFinishedNumerator,
    CI_TBL_BMK       bmk,
    DBCOUNTITEM &    riRowBmk,
    DBCOUNTITEM &    rcRowsTotal )
{
    tbDebugOut(( DEB_PROXY, "GetQueryStatusEx\n" ));

    CPMGetQueryStatusExIn request( hCursor, bmk );
    CPMGetQueryStatusExOut reply;
    DWORD cbRead;

    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           sizeof reply,
                           cbRead );

    Win4Assert( SUCCEEDED( reply.GetStatus() ) );
    Win4Assert( _client.IsPipeTracingEnabled() || sizeof reply == cbRead );

    rdwStatus = reply.QueryStatus();
    rcFilteredDocuments = reply.FilteredDocuments();
    rcDocumentsToFilter = reply.DocumentsToFilter();
    rdwRatioFinishedDenominator = reply.RatioFinishedDenominator();
    rdwRatioFinishedNumerator = reply.RatioFinishedNumerator();
    riRowBmk = reply.RowBmk();
    rcRowsTotal = reply.RowsTotal();
} //GetQueryStatusEx

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::FetchDeferredValue, public
//
//  Synopsis:   Returns a property value for a workid from the property cache
//
//  Arguments:  [wid] - workid for which property value is retrieved
//              [ps]] - prop spec identifying value to be retrieved
//              [var] - returns the value if available
//
//  Returns:    TRUE if a value was retrieved or FALSE otherwise
//
//  History:    30 Sept 96  dlee created
//
//--------------------------------------------------------------------------

BOOL CSvcQueryProxy::FetchDeferredValue(
    WORKID                wid,
    CFullPropSpec const & ps,
    PROPVARIANT &         var )
{
    tbDebugOut(( DEB_PROXY, "FetchValue\n" ));
    CLock lock( _mutexFetchValue );

    XArray<BYTE> xValue;
    XArray<BYTE> xResult( cbMaxProxyBuffer );

    // cbChunk is the size of the output buffer including CPMFetchValueOut

    const DWORD cbChunk = cbMaxProxyBuffer;

    // Since the value might be large and each proxy buffer is limited to
    // cbMaxProxyBuffer, iterate until the entire value is retrieved.

    do
    {
        // only send the propspec once

        DWORD cbPropSpec = 0;
        if ( 0 == xValue.SizeOf() )
        {
            CSizeSerStream stmSize;
            ps.Marshall( stmSize );
            cbPropSpec = stmSize.Size();
        }

        ULONG cbRequest = AlignBlock( sizeof CPMFetchValueIn + cbPropSpec,
                                      sizeof ULONG );
        XArray<BYTE> xRequest( cbRequest );
        CPMFetchValueIn *pRequest = new( xRequest.Get() )
            CPMFetchValueIn( wid, xValue.SizeOf(), cbPropSpec, cbChunk );

        if ( 0 == xValue.SizeOf() )
        {
            CMemSerStream stmMem( pRequest->GetPS(), cbPropSpec );
            ps.Marshall( stmMem );
        }

        pRequest->SetCheckSum( xRequest.SizeOf() );

        DWORD cbReply;
        _client.DataWriteRead( pRequest,
                               xRequest.SizeOf(),
                               xResult.Get(),
                               xResult.SizeOf(),
                               cbReply );
        CPMFetchValueOut &result = * (CPMFetchValueOut *) xResult.Get();

        if ( !result.ValueExists() )
            return FALSE;

        // append the next portion of the value

        DWORD cbOld = xValue.SizeOf();
        Win4Assert( 0 != result.ValueSize() );
        xValue.ReSize( cbOld + result.ValueSize() );
        RtlCopyMemory( xValue.Get() + cbOld,
                       result.Value(),
                       result.ValueSize() );

        // all done?

        if ( !result.MoreExists() )
            break;
    } while ( TRUE );

    CCoTaskMemAllocator tbaAlloc;

    StgConvertPropertyToVariant( (SERIALIZEDPROPERTYVALUE *) xValue.Get(),
                                 CP_WINUNICODE,
                                 &var,
                                 &tbaAlloc );
    Win4Assert( (var.vt & 0x0fff) <= VT_CLSID );

    return TRUE;
} //FetchValue

//+-------------------------------------------------------------------------
//
//  Member:     CSvcQueryProxy::WorkIdToPath, public
//
//  Synopsis:   Converts a wid to a path
//
//  Arguments:  [wid]       -- wid to convert
//              [funnyPath] -- resulting path
//
//  History:    30 Sept 96  dlee created
//
//--------------------------------------------------------------------------

void CSvcQueryProxy::WorkIdToPath(
    WORKID          wid,
    CFunnyPath & funnyPath )
{
    tbDebugOut(( DEB_PROXY, "WorkIdToPath\n" ));

    CPMWorkIdToPathIn request( wid );
    XArray<WCHAR> xReply( cbMaxProxyBuffer );
    CPMWorkIdToPathOut &reply = * (CPMWorkIdToPathOut *) xReply.Get();

    DWORD cbRead;
    _client.DataWriteRead( &request,
                           sizeof request,
                           &reply,
                           cbMaxProxyBuffer,
                           cbRead );
    Win4Assert( SUCCEEDED( reply.GetStatus() ) );

    if ( reply.Any() )
    {
        funnyPath.SetPath( reply.Path() );
    }
} //WorkIdToPath