OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
7507d3c0e1
Windows-Server-2003/inetsrv/query/bigtable/svcproxy.cxx

1372 lines
43 KiB
C++
Raw Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
//+-------------------------------------------------------------------------
//
// 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(), cbCursors );
//
// 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
Copy Permalink