windows-xp/Source/XPSP1/NT/inetsrv/query/cifrmwrk/dll/srequest.cxx

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1996 - 2000
//
//  File:       srequest.cxx
//
//  Contents:   Server side of catalog/query requests
//
//  Classes:    CPipeServer
//              CRequestServer
//              CRequestQueue
//
//  Functions:  StartCiSvcWork
//              StopCiSvcWork
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#include <cci.hxx>
#include <query.hxx>
#include <rstprop.hxx>
#include <pickle.hxx>
#include <worker.hxx>
#include <propspec.hxx>
#include <seqquery.hxx>
#include <rowseek.hxx>
#include <srequest.hxx>
#include <propvar.h>
#include <ciregkey.hxx>
#include <regacc.hxx>
#include <imprsnat.hxx>
#include <driveinf.hxx>

#include <qparse.hxx>
#include <dbprputl.hxx>
#include <cidbprop.hxx>
#include <ciframe.hxx>
#include <cisvcfrm.hxx>
#include <lang.hxx>

#include <fsciexps.hxx>
#include <pidcvt.hxx>
#include <cisvcex.hxx>

#include <fsciclnt.h>

#include "secutil.hxx"

extern CLocateDocStore g_svcDocStoreLocator;
extern CStaticMutexSem g_mtxStartStop;

CRequestQueue * g_pRequestQueue = 0;

const CRequestServer::ProxyMessageFunction CRequestServer::_aMsgFunctions[] =
{
    DoConnect,
    DoDisconnect,
    DoCreateQuery,
    DoFreeCursor,
    DoGetRows,
    DoRatioFinished,
    DoCompareBmk,
    DoGetApproximatePosition,
    DoSetBindings,
    DoGetNotify,
    DoSendNotify,
    DoSetWatchMode,
    DoGetWatchInfo,
    DoShrinkWatchRegion,
    DoRefresh,
    DoGetQueryStatus,
    DoObsolete,                  //WidToPath
    DoCiState,
    DoObsolete,                  //BeginCacheTransaction
    DoObsolete,                  //SetupCache
    DoObsolete,                  //EndCacheTransaction
    DoObsolete,                  //AddScope
    DoObsolete,                  //RemoveScope
    DoObsolete,                  //AddVirtualScope
    DoObsolete,                  //RemoveVirtualScope
    DoForceMerge,
    DoAbortMerge,
    DoObsolete,                  //SetPartition
    DoFetchValue,
    DoWorkIdToPath,
    DoUpdateDocuments,
    DoGetQueryStatusEx,
    DoRestartPosition,
    DoStopAsynch,
    DoStartWatching,
    DoStopWatching,
    DoSetCatState
};

const BOOL CRequestServer::_afImpersonate[] =
{
    TRUE,   //    DoConnect,
    FALSE,  //    DoDisconnect,
    TRUE,   //    DoCreateQuery,
    FALSE,  //    DoFreeCursor,
    TRUE,   //    DoGetRows,
    FALSE,  //    DoRatioFinished,
    FALSE,  //    DoCompareBmk,
    FALSE,  //    DoGetApproximatePosition,
    FALSE,  //    DoSetBindings,
    FALSE,  //    DoGetNotify,
    FALSE,  //    DoSendNotify,
    FALSE,  //    DoSetWatchMode,
    FALSE,  //    DoGetWatchInfo,
    FALSE,  //    DoShrinkWatchRegion,
    FALSE,  //    DoRefresh,
    FALSE,  //    DoGetQueryStatus,
    FALSE,  //    DoObsolete,                  //DoWidToPath,
    FALSE,  //    DoCiState,
    TRUE,   //    DoBeginCacheTransaction,
    TRUE,   //    DoSetupCache,
    TRUE,   //    DoEndCacheTransaction,
    FALSE,  //    DoObsolete,                  //AddScope
    FALSE,  //    DoObsolete,                  //RemoveScope
    FALSE,  //    DoObsolete,                  //AddVirtualScope
    FALSE,  //    DoObsolete,                  //RemoveVirtualScope
    TRUE,   //    DoForceMerge,
    TRUE,   //    DoAbortMerge,
    FALSE,  //    DoObsolete,                  //SetPartition
    TRUE,   //    DoFetchValue,
    TRUE,   //    DoWorkIdToPath,
    TRUE,   //    DoUpdateDocuments,
    FALSE,  //    DoGetQueryStatusEx,
    FALSE,  //    DoRestartPosition,
    FALSE,  //    DoStopAsynch,
    FALSE,  //    DoStartWatching,
    FALSE,  //    DoStopWatching,
    TRUE,   //    DoSetCatState
};

//+-------------------------------------------------------------------------
//
//  Member:     CPipeServer::CPipeServer, public
//
//  Synopsis:   Constructor for a server pipe.  The pipe is created such
//              that any client can connect.
//
//  Arguments:  [pwcName]                 - Name for the pipe
//              [cmsDefaultClientTimeout] - Default timeout for clients
//                                          trying to get a pipe instance
//              [pSecurityDescriptor]     - Security for the pipe
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

CPipeServer::CPipeServer(
    const WCHAR *         pwcName,
    ULONG                 cmsDefaultClientTimeout,
    SECURITY_DESCRIPTOR * pSecurityDescriptor ) :
    _eventWrite( (HANDLE) 0 ) // defer creation of the notification event
{
    RtlZeroMemory( &_overlapped, sizeof _overlapped );

    SECURITY_ATTRIBUTES saPipeSecurity;
    saPipeSecurity.nLength = sizeof SECURITY_ATTRIBUTES;
    saPipeSecurity.bInheritHandle = FALSE;
    saPipeSecurity.lpSecurityDescriptor = pSecurityDescriptor;

    // note: the read/write buffers are allocated from non-paged pool,
    //       and are grown if too small to reflect usage

    _hPipe = CreateNamedPipe( pwcName,
                              PIPE_ACCESS_DUPLEX |
                                  FILE_FLAG_OVERLAPPED,
                              PIPE_TYPE_MESSAGE |
                                  PIPE_READMODE_MESSAGE |
                                  PIPE_WAIT,
                              PIPE_UNLIMITED_INSTANCES,
                              1024,      // read buffer size
                              2048,      // write buffer size
                              cmsDefaultClientTimeout,
                              &saPipeSecurity );

    if ( INVALID_HANDLE_VALUE == _hPipe )
        THROW( CException() );

    prxDebugOut(( DEB_ITRACE, "created pipe 0x%x\n", _hPipe ));
} //CPipeServer

//+-------------------------------------------------------------------------
//
//  Member:     CPipeServer::Connect, public
//
//  Synopsis:   Enables a client to connect to the pipe.
//
//  Returns:    TRUE if connected, FALSE if GetEvent() will be signalled
//              on connection, or throws on error.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

BOOL CPipeServer::Connect()
{
    prxDebugOut(( DEB_ITRACE, "connecting from pipe 0x%x\n", _hPipe ));

    _overlapped.hEvent = _event.GetHandle();
    BOOL fEventWait = ConnectNamedPipe( _hPipe, &_overlapped );

    if ( !fEventWait )
    {
        DWORD dwError = GetLastError();

        prxDebugOut(( DEB_ITRACE, "CPipeServer::Connect.. GetLastError() == %d\n", dwError ));

        if ( ERROR_PIPE_CONNECTED == dwError )
            return TRUE;
        else if ( ERROR_IO_PENDING != dwError )
            THROW( CException() );
    }

    return FALSE;
} //Connect

//+-------------------------------------------------------------------------
//
//  Member:     CPipeServer::ReadRemainingSync, public
//
//  Synopsis:   Reads the remainder of a message from the pipe (if any)
//
//  Arguments:  [pvSoFar]  - Part of the message read so far
//              [cbSoFar]  - in:  # of bytes read so far for the message
//                           out: # bytes total in message
//
//  Returns:    Pointer to memory containing entire message or 0 if
//              there really wasn't anything more to read
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

BYTE * CPipeServer::ReadRemainingSync(
    void *  pvSoFar,
    DWORD & cbSoFar )
{
    DWORD cbLeft;

    if ( ! PeekNamedPipe( _hPipe, 0, 0, 0, 0, &cbLeft ) )
        THROW( CException() );

    if ( 0 == cbLeft )
    {
        prxDebugOut(( DEB_WARN, "peek says no more to read\n" ));
        return 0;
    }

    XArray<BYTE> xMsg( cbSoFar + cbLeft );
    RtlCopyMemory( xMsg.Get(), pvSoFar, cbSoFar );

    CEventSem evt;
    OVERLAPPED o;
    RtlZeroMemory( &o, sizeof o );
    o.hEvent = evt.GetHandle();

    DWORD cbRead;
    if ( ! ReadFile( _hPipe,
                     xMsg.Get() + cbSoFar,
                     cbLeft,
                     &cbRead,
                     &o ) )
    {
        if ( ERROR_IO_PENDING == GetLastError() )
        {
            if ( !GetOverlappedResult( _hPipe,
                                       &o,
                                       &cbRead,
                                       TRUE ) )
                THROW( CException() );
        }
        else
            THROW( CException() );
    }

    Win4Assert( cbRead == cbLeft );
    cbSoFar += cbLeft;
    return xMsg.Acquire();
} //ReadRemainingSync

//+-------------------------------------------------------------------------
//
//  Member:     CPipeServer::WriteSync, public
//
//  Synopsis:   Does a synchronous write to a pipe.  There can be at most
//              one caller at a time to this method.
//
//  Arguments:  [pv] - Buffer to write
//              [cb] - # of bytes to write
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

void CPipeServer::WriteSync(
    void * pv,
    DWORD  cb )
{
    prxDebugOut(( DEB_ITRACE, "WriteSync on this 0x%x, pipe 0x%x\n",
                  this, _hPipe ));

    OVERLAPPED o;
    RtlZeroMemory( &o, sizeof o );

    // Create and keep the event, since if we do it once (for notifications)
    // we'll likely do it again soon.

    if ( 0 == _eventWrite.GetHandle() )
        _eventWrite.Create();

    o.hEvent = _eventWrite.GetHandle();

    if ( ! WriteFile( _hPipe, pv, cb, 0, &o ) )
    {
        if ( ERROR_IO_PENDING == GetLastError() )
        {
            DWORD cbWritten;
            if ( !GetOverlappedResult( _hPipe,
                                       &o,
                                       &cbWritten,
                                       TRUE ) )
                THROW( CException() );

            Win4Assert( cbWritten == cb );
        }
        else
            THROW( CException() );
    }
    prxDebugOut(( DEB_ITRACE, "WriteSync completed on this 0x%x, pipe 0x%x\n",
                  this, _hPipe ));
} //WriteSync

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::CRequestServer, public
//
//  Synopsis:   Constructor for the request server
//
//  Arguments:  [pwcPipe]                 - Name of the pipe to use
//              [cmsDefaultClientTimeout] - Timeout for clients waiting for
//                                          and instance
//              [requestQueue]            - The 1 and only request queue
//              [workQueue]               - The work queue
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

CRequestServer::CRequestServer(
    const WCHAR *   pwcPipe,
    ULONG           cmsDefaultClientTimeout,
    CRequestQueue & requestQueue,
    CWorkQueue &    workQueue ) :
    CPipeServer( pwcPipe,
                 cmsDefaultClientTimeout,
                 requestQueue.GetSecurityDescriptor() ),
    PWorkItem( sigCRequestServer ),
    _state( pipeStateNone ),
    _cRefs( 1 ),
    _iClientVersion( 0 ),
    _pQuery( 0 ),
    _fClientIsRemote( FALSE ),
    _pWorkThread( 0 ),
    _hWorkThread( INVALID_HANDLE_VALUE ),
    _cbFetchedValueSoFar( 0 ),
    _cbPendingWrite( 0 ),
    _scPendingStatus( S_OK ),
    _requestQueue( requestQueue ),
    _workQueue( workQueue ),
    _pevtDone( 0 ),
    _dwLastTouched( GetTickCount() )
{
    requestQueue.AddToListNoThrow( this );
} //CRequestServer

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::Release, public
//
//  Synopsis:   Releases and if approprate deletes the object
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

void CRequestServer::Release()
{
    Win4Assert( 0 != _cRefs );

    CLock lock( _requestQueue.GetTheMutex() );

    // Since the AddRef() is not done under lock (and we don't want to)
    // InterlockedDecrement is used even though we're under lock.

    if ( 0 == InterlockedDecrement( & _cRefs ) )
    {
        _requestQueue.RemoveFromListNoThrow( this );

        // If someone is waiting for this to go out of the list,
        // tell them now.

        if ( 0 != _pevtDone )
        {
            _pevtDone->Set();
            _pevtDone = 0;
        }

        delete this;
    }
} //Release

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoIt, public
//
//  Synopsis:   Implements the work queue DoIt method by scheduling
//              the first read from the client of the pipe.  The work queue
//              is needed since apc completion routines must be run by
//              the thread that submitted the i/o.
//
//  Arguments:  [pThread] - Thread being used (for refcounting)
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

void CRequestServer::DoIt(
    CWorkThread *pThread )
{
    TRY
    {
        Win4Assert( pipeStateNone == _state );
        Win4Assert( 0 == _pWorkThread );
        Win4Assert( INVALID_HANDLE_VALUE == _hWorkThread );
        prxDebugOut(( DEB_ITRACE, "doit CRequestServer %p\n", this ));

        _pWorkThread = pThread;
        _hWorkThread = pThread->GetThreadHandle();
        _workQueue.AddRef( pThread );
        _state = pipeStateRead;

        Read( _Buffer(), _BufferSize(), APCRoutine );

        if ( IsBeingRemoved() )
            CancelIO();
    }
    CATCH( CException, ex )
    {
        prxDebugOut(( DEB_ITRACE,
                      "failed initial read error 0x%x, pipe %p\n",
                      ex.GetErrorCode(),
                      GetPipe() ));

        _state = pipeStateNone;
        _requestQueue.RecycleRequestServerNoThrow( this );
    }
    END_CATCH;
} //DoIt

//+-------------------------------------------------------------------------
//
//  Function:   TranslateOldPropsToNewProps
//
//  Synopsis:   Translates ver 5 client properties into version 6+ props
//
//  Arguments:  [oldProps]    - source of translated values
//              [newProps]    - destination of translated values
//
//  History:    31-May-97   dlee       Created.
//
//--------------------------------------------------------------------------

void TranslateOldPropsToNewProps(
    CDbProperties & oldProps,
    CDbProperties & newProps )
{
    const GUID guidFsClientPropset = DBPROPSET_FSCIFRMWRK_EXT;
    const GUID guidQueryCorePropset = DBPROPSET_CIFRMWRKCORE_EXT;

    // pluck out the catalog and scope information from the old set

    WCHAR *pwcCatalog = 0;
    BSTR bstrMachine = 0;
    CDynArrayInPlace<ULONG> aDepths(2);
    CDynArrayInPlace<WCHAR *> aScopes(2);
    LONG lQueryType = 0;

    for ( ULONG i = 0; i < oldProps.Count(); i++ )
    {
        CDbPropSet & propSet = oldProps.GetPropSet( i );
        DBPROPSET *pSet = propSet.CastToStruct();

        if ( guidQueryCorePropset == pSet->guidPropertySet )
        {
            ULONG cProp = pSet->cProperties;
            DBPROP * pProp = pSet->rgProperties;

            for ( ULONG p = 0; p < pSet->cProperties; p++, pProp++ )
            {
                PROPVARIANT &v = (PROPVARIANT &) pProp->vValue;
                switch ( pProp->dwPropertyID )
                {
                    case DBPROP_MACHINE :
                    {
                        Win4Assert( VT_BSTR == v.vt );
                        if ( VT_BSTR == v.vt )
                            bstrMachine = v.bstrVal;
                        break;
                    }
                }
            }
        }
        else if ( guidFsClientPropset == pSet->guidPropertySet )
        {
            ULONG cProp = pSet->cProperties;
            DBPROP * pProp = pSet->rgProperties;

            for ( ULONG p = 0; p < pSet->cProperties; p++, pProp++ )
            {
                PROPVARIANT &v = (PROPVARIANT &) pProp->vValue;
                switch ( pProp->dwPropertyID )
                {
                    case DBPROP_CI_INCLUDE_SCOPES :
                    {
                        Win4Assert( (VT_VECTOR|VT_LPWSTR) == v.vt );
                        if ( (VT_VECTOR|VT_LPWSTR) == v.vt )
                            for ( ULONG s = 0; s < v.calpwstr.cElems; s++ )
                                aScopes[s] = v.calpwstr.pElems[s];
                        break;
                    }
                    case DBPROP_CI_DEPTHS :
                    {
                        Win4Assert( (VT_VECTOR|VT_I4) == v.vt );
                        if ( (VT_VECTOR|VT_I4) == v.vt )
                            for ( ULONG s = 0; s < v.cal.cElems; s++ )
                                aDepths[s] = v.cal.pElems[s];
                        break;
                    }
                    case DBPROP_CI_CATALOG_NAME :
                    {
                        Win4Assert( VT_LPWSTR == v.vt );
                        if ( VT_LPWSTR == v.vt )
                            pwcCatalog = v.pwszVal;
                        break;
                    }
                    case DBPROP_CI_QUERY_TYPE :
                    {
                        Win4Assert( VT_I4 == v.vt );
                        lQueryType = v.lVal;
                        break;
                    }
                }
            }
        }
    }

    if ( 0 == pwcCatalog ||
         0 == bstrMachine )
        THROW( CException( STATUS_INVALID_PARAMETER_MIX ) );

    prxDebugOut(( DEB_ITRACE,
                  "Converting old props to new props, catalog '%ws'",
                  pwcCatalog ));

    prxDebugOut(( DEB_ITRACE,
                  "type %d, %d scopes, %d depths\n",
                  lQueryType,
                  aScopes.Count(),
                  aDepths.Count() ));

    // create a new set of properties based on the old info

    CDynArrayInPlace<BSTR> aBSTR( aScopes.Count() + 2 );

    DBPROPSET aNewSet[2];
    DBPROP aFSProps[4];
    RtlZeroMemory( aFSProps, sizeof aFSProps );
    aNewSet[0].cProperties = 0;
    aNewSet[0].guidPropertySet = guidFsClientPropset;
    aNewSet[0].rgProperties = aFSProps;

    aFSProps[0].dwPropertyID = DBPROP_CI_CATALOG_NAME;
    aFSProps[0].vValue.vt = VT_BSTR;
    aFSProps[0].vValue.bstrVal = SysAllocString( pwcCatalog );
    aBSTR[ aBSTR.Count() ] = aFSProps[0].vValue.bstrVal;
    aNewSet[0].cProperties++;

    aFSProps[1].dwPropertyID = DBPROP_CI_QUERY_TYPE;
    aFSProps[1].vValue.vt = VT_I4;
    aFSProps[1].vValue.lVal = lQueryType;
    aNewSet[0].cProperties++;

    DBPROP & propDepth = aFSProps[ aNewSet[0].cProperties ];

    propDepth.dwPropertyID = DBPROP_CI_DEPTHS;

    SAFEARRAY saDepth = { 1,                      // Dimension
                          FADF_AUTO,              // Flags: on stack
                          sizeof(LONG),           // Size of an element
                          1,                      // Lock count.  1 for safety.
                          (void *)aDepths.GetPointer(), // The data
                          { aDepths.Count(), 0 } };       // Bounds (element count, low bound)

    if ( 1 == aDepths.Count() )
    {
        propDepth.vValue.vt = VT_I4;
        propDepth.vValue.lVal = aDepths[0];
        aNewSet[0].cProperties++;
    }
    else if ( aDepths.Count() > 1 )
    {
        propDepth.vValue.vt = ( VT_ARRAY | VT_I4 );
        propDepth.vValue.parray = & saDepth;
        aNewSet[0].cProperties++;
    }

    DBPROP & propScope = aFSProps[ aNewSet[0].cProperties ];

    propScope.dwPropertyID = DBPROP_CI_INCLUDE_SCOPES;

    SAFEARRAY saScope = { 1,                      // Dimension
                          FADF_AUTO | FADF_BSTR,  // Flags: on stack, contains BSTRs
                          sizeof(BSTR),           // Size of an element
                          1,                      // Lock count.  1 for safety.
                          (void *)0, // The data
                          { aScopes.Count(), 0 } };       // Bounds (element count, low bound)

    if ( 1 == aScopes.Count() )
    {
        propScope.vValue.vt = VT_BSTR;
        BSTR bstr = SysAllocString( aScopes[ 0 ] );
        aBSTR[ aBSTR.Count() ] = bstr;
        propScope.vValue.bstrVal = bstr;
        aNewSet[0].cProperties++;
    }
    else if ( aScopes.Count() > 1 )
    {
        propScope.vValue.vt = ( VT_ARRAY | VT_BSTR );
        propScope.vValue.parray = & saScope;

        BSTR * pBSTR = (BSTR *) aBSTR.GetPointer();
        pBSTR += aBSTR.Count();

        for ( ULONG x = 0; x < aScopes.Count(); x++ )
            aBSTR[ aBSTR.Count() ] = SysAllocString( aScopes[ x ] );

        saScope.pvData = (void *) pBSTR;
        aNewSet[0].cProperties++;
    }

    DBPROP aQueryProps[1];
    RtlZeroMemory( aQueryProps, sizeof aQueryProps );
    aNewSet[1].cProperties = 1;
    aNewSet[1].guidPropertySet = guidQueryCorePropset;
    aNewSet[1].rgProperties = aQueryProps;

    aQueryProps[0].dwPropertyID = DBPROP_MACHINE;
    aQueryProps[0].vValue.vt = VT_BSTR;
    aQueryProps[0].vValue.bstrVal = bstrMachine;

    // Verify all the bstrs were allocated

    for ( ULONG iBstr = 0; iBstr < aBSTR.Count(); iBstr++ )
    {
        if ( 0 == aBSTR[ iBstr ] )
        {
            for ( ULONG i = 0; i < aBSTR.Count(); i++ )
            {
                if ( 0 != aBSTR[ i ] )
                    SysFreeString( aBSTR[ i ] );
            }

            THROW( CException( E_OUTOFMEMORY ) );
        }
    }

    SCODE sc = newProps.SetProperties( 2, aNewSet );

    for ( ULONG ibstr = 0; ibstr < aBSTR.Count(); ibstr++ )
        SysFreeString( aBSTR[ ibstr ] );

    if ( FAILED( sc ) )
        THROW( CException( sc ) );
} //TranslateOldPropsToNewProps

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoConnect, private
//
//  Synopsis:   Handles a connect message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoConnect(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    CPMConnectIn &request = * (CPMConnectIn *) _ActiveBuffer();
    XPtrST<BYTE> xTemp( _xTempBuffer.Acquire() );

    Win4Assert( pmConnect == request.GetMessage() );

    // guard against attack

    Win4Assert( 0 == _pQuery );
    Win4Assert( _xDocStore.IsNull() );
    if ( !_xDocStore.IsNull() )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    // save the client version, isRemote, machine name, and user name

    _iClientVersion = request.GetClientVersion();

    // don't support old clients

    if ( GetClientVersion() < 5 )
        THROW( CException( STATUS_INVALID_PARAMETER_MIX ) );

    request.ValidateCheckSum( GetClientVersion(), cbRequest );

    _fClientIsRemote = request.IsClientRemote();
    WCHAR *pwcMachine = request.GetClientMachineName();
    ULONG cwcMachine = 1 + wcslen( pwcMachine );

    // Check if the machine name looks mal-formed

    if ( ( cwcMachine * sizeof WCHAR ) >= __min( 1024, cbRequest ) )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    WCHAR *pwcUser = request.GetClientUserName();
    ULONG cwcUser = 1 + wcslen( pwcUser );

    // Check if the user name looks mal-formed

    if ( ( ( cwcMachine + cwcUser ) * sizeof WCHAR ) >= __min( 1024, cbRequest ) )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    _xClientMachine.Init( cwcMachine );
    RtlCopyMemory( _xClientMachine.Get(),
                   pwcMachine,
                   _xClientMachine.SizeOf() );

    _xClientUser.Init( cwcUser );
    RtlCopyMemory( _xClientUser.Get(),
                   pwcUser,
                   _xClientUser.SizeOf() );

    //
    // Retreive the db properties.
    //

    if ( 5 == GetClientVersion() )
    {
        // unmarshall the old-style properties, and translate into
        // the new-style properties

        if ( request.GetBlobSize() > 0 )
        {
            if ( request.GetBlobSize() >= cbRequest )
                THROW( CException( STATUS_INVALID_PARAMETER ) );

            CMemDeSerStream stmDeser( request.GetBlobStartAddr(),
                                      request.GetBlobSize() );

            XInterface<CDbProperties> xOldDbP( new CDbProperties );
            if ( xOldDbP.IsNull() || ! xOldDbP->UnMarshall( stmDeser ) )
                THROW( CException( E_OUTOFMEMORY ) );

            XInterface<CDbProperties> xNewDbP( new CDbProperties );
            if ( xNewDbP.IsNull() )
                THROW( CException( E_OUTOFMEMORY ) );
            TranslateOldPropsToNewProps( xOldDbP.GetReference(),
                                         xNewDbP.GetReference() );
            _xDbProperties.Set( xNewDbP.Acquire() );
        }
    }
    else
    {
        Win4Assert( GetClientVersion() >= 6 );

        if ( GetClientVersion() < 5 )
            THROW( CException( STATUS_INVALID_PARAMETER ) );

        if ( request.GetBlob2Size() > 0 )
        {
            if ( ( 0 == request.GetBlob2StartAddr() ) ||
                 ( ( request.GetBlobSize() + request.GetBlob2Size() ) >= cbRequest ) )
                THROW( CException( STATUS_INVALID_PARAMETER ) );

            CMemDeSerStream stmDeser( request.GetBlob2StartAddr(),
                                      request.GetBlob2Size() );

            XInterface<CDbProperties> xDbP( new CDbProperties );
            if ( xDbP.IsNull() || !xDbP->UnMarshall( stmDeser ) )
                THROW( CException( E_OUTOFMEMORY ) );

            _xDbProperties.Set( xDbP.Acquire() );
        }
    }

    prxDebugOut(( DEB_ITRACE|DEB_PRX_LOG,
                  "connect clientver %d, remote %d, machine '%ws', user '%ws'\n",
                  _iClientVersion,
                  _fClientIsRemote,
                  pwcMachine,
                  pwcUser ));

    XInterface<ICiCDocStoreLocator> xLocator( _requestQueue.DocStoreLocator() );
    Win4Assert( !xLocator.IsNull() );

    CPMConnectOut & reply = *(CPMConnectOut *) _Buffer();
    cbToWrite = sizeof reply;
    reply.ServerVersion() = pmServerVersion;

    //
    // Never fault in the docstore since docstores have been opened by now.
    //

    Win4Assert( _requestQueue.AreDocStoresOpen() );

    ICiCDocStore * pDocStore = 0;
    SCODE sc = xLocator->LookUpDocStore( _xDbProperties.GetPointer(),
                                         &pDocStore,
                                         TRUE );

    if ( SUCCEEDED(sc) )
    {
        // sc will be CI_S_NO_DOCSTORE if this is the CIADMIN catalog

        if ( 0 != pDocStore )
        {
            _xDocStore.Set( pDocStore );

            // This QI is just about guaranteed to work.

            XInterface<ICiCAdviseStatus> xAdviseStatus;
            sc = pDocStore->QueryInterface( IID_ICiCAdviseStatus,
                                            xAdviseStatus.GetQIPointer() );
            if ( S_OK != sc )
                THROW( CException(sc) );

            xAdviseStatus->IncrementPerfCounterValue( CI_PERF_RUNNING_QUERIES );
        }
    }
    else
        reply.SetStatus( CI_E_NO_CATALOG );

    return stateContinue;
} //DoConnect

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoDisconnect, private
//
//  Synopsis:   Handles a disconnect message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  Returns:    stateDisconnect -- the connection will be closed
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoDisconnect(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    CProxyMessage &msg = * (CProxyMessage *) _Buffer();
    Win4Assert( pmDisconnect == msg.GetMessage() );

    return stateDisconnect;
} //DoDisconnect

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoCreateQuery, private
//
//  Synopsis:   Handles a create query message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoCreateQuery(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    // if this hits, there is probably a cursor refcounting bug

    Win4Assert( 0 == _pQuery );

    if ( _xDocStore.IsNull() ||
         ( 0 != _pQuery ) )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    XInterface<ICiCDocStoreEx>  xDocStoreEx;

    SCODE sc = _xDocStore->QueryInterface( IID_ICiCDocStoreEx,
                                           xDocStoreEx.GetQIPointer() );

    if ( SUCCEEDED(sc) )
    {
        BOOL fNoQuery = FALSE;

        sc = xDocStoreEx->IsNoQuery( &fNoQuery );

        if ( S_OK == sc )
        {
            if ( fNoQuery )
                THROW( CException( QUERY_S_NO_QUERY ) );
        }
        else
            THROW ( CException( sc ) );

    }
    else
        THROW ( CException( sc ) );

    RequestState state = stateContinue;

    // The request is either in the standard buffer or the temp buffer.
    // Take ownership of the temp buffer.

    CPMCreateQueryIn &request = * (CPMCreateQueryIn *) _ActiveBuffer();
    XPtrST<BYTE> xTemp( _xTempBuffer.Acquire() );

    // marshalling / unmarshalling is inconsistent if alignment is different

    Win4Assert( isQWordAligned( &request ) );
    Win4Assert( isQWordAligned( request.Data() ) );

    request.ValidateCheckSum( GetClientVersion(), cbRequest );

    // unpickle the query

    XColumnSet         cols;
    XRestriction       rst;
    XSortSet           sort;
    XCategorizationSet categ;
    CRowsetProperties  Props;
    XPidMapper         pidmap;

    UnPickle( GetClientVersion(),
              cols,
              rst,
              sort,
              categ,
              Props,
              pidmap,
              (BYTE *) request.Data(),
              cbRequest - sizeof CProxyMessage );

    if ( Props.GetMaxResults() > 0 && Props.GetFirstRows() > 0 )
        THROW( CException( E_INVALIDARG ) );
 
    // Compute # of cursors to create and where to put them

    unsigned cCursors = 1;
    if ( 0 != categ.GetPointer() )
        cCursors += categ->Size();

    // verify the output buffer is large enough

    if ( _BufferSize() <
         ( cCursors * sizeof ULONG + sizeof CPMCreateQueryOut ) )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    // get reference to CLangList to pass to CQParse objects...

    XInterface<ICiManager> xICiManager;

    sc = _xDocStore->GetContentIndex( xICiManager.GetPPointer() );
    if ( FAILED(sc) )
        THROW( CException(sc) );

    XInterface<ICiFrameworkQuery> xICiFrameworkQuery;
    sc = xICiManager->QueryInterface( IID_ICiFrameworkQuery,
                                      xICiFrameworkQuery.GetQIPointer() );
    if ( FAILED(sc) )
        THROW( CException(sc) );

    CLangList * pLangList = 0;
    sc = xICiFrameworkQuery->GetLangList((void**)&pLangList);
    if ( FAILED(sc) )
        THROW( CException(sc) );

    //
    // Set up a property mapper.  Used for restriction parsing and sort/output
    // column translation.
    //

    XInterface<IPropertyMapper> xPropMapper;
    sc = _xDocStore->GetPropertyMapper( xPropMapper.GetPPointer() );

    if ( FAILED( sc ) )
    {
         vqDebugOut(( DEB_ERROR, "CRequestServer::DoCreateQuery, GetPropertyMapper failed\n" ));
         THROW( CException( sc ) );
    }

    //
    // Adjust pidmap to translate properties.
    //

    CPidConverter PidConverter( xPropMapper.GetPointer() );
    pidmap->SetPidConverter( &PidConverter );

    // parse the query -- expand phrases, etc.

    XRestriction rstParsed;
    DWORD dwQueryStatus = 0;
    if ( !rst.IsNull() )
    {
        CQParse qparse( pidmap.GetReference(), *pLangList );
        rstParsed.Set( qparse.Parse( rst.GetPointer() ) );

        DWORD dwParseStatus = qparse.GetStatus();

        if ( ( 0 != ( dwParseStatus & CI_NOISE_PHRASE ) ) &&
             ( rst->Type() != RTVector ) &&
             ( rst->Type() != RTOr ) )
        {
            vqDebugOut(( DEB_WARN, "Query contains phrase composed "
                                   "entirely of noise words.\n" ));
            THROW( CException( QUERY_E_ALLNOISE ) );
        }

        const DWORD dwCiNoise = CI_NOISE_IN_PHRASE | CI_NOISE_PHRASE;
        if ( 0 != ( dwCiNoise & dwParseStatus ) )
            dwQueryStatus |= STAT_NOISE_WORDS;
    }

    //
    // Re-map property ids.
    //

    //
    // TODO: Get rid of this whole pid remap thing.  We should
    //       really be able to do it earlier now that the pidmap
    //       can be set up to convert fake to real pids.
    //

    XInterface<CPidRemapper> pidremap( new CPidRemapper( pidmap.GetReference(),
                                                         xPropMapper,
                                                         0, // rstParsed.GetPointer(),
                                                         cols.GetPointer(),
                                                         sort.GetPointer() ) );

    //
    // WorkID may be added to the columns requested in SetBindings.
    // Be sure it's in the pidremap from the beginning.
    //

    CFullPropSpec psWorkId( guidQuery, DISPID_QUERY_WORKID );
    pidremap->NameToReal( &psWorkId );

    XInterface<ICiQueryPropertyMapper> xQueryPropMapper;
    sc = pidremap->QueryInterface( IID_ICiQueryPropertyMapper,
                                   xQueryPropMapper.GetQIPointer() );
    if ( FAILED(sc) )
    {
        vqDebugOut(( DEB_ERROR, "DoCreateQuery - QI for property mapper failed 0x%x\n", sc ));
        THROW ( CException( sc ) ) ;
    }

    XInterface<ICiCQuerySession> xQuerySession;
    sc = _xDocStore->GetQuerySession( xQuerySession.GetPPointer() );
    if ( FAILED(sc) )
    {
        vqDebugOut(( DEB_ERROR, "DoCreateQuery - GetQuerySession failed 0x%x\n", sc ));
        THROW ( CException( sc ) ) ;
    }

    //
    // Initialize the query session
    //
    sc = xQuerySession->Init( 0,
                              0,
                              _xDbProperties.GetPointer(),
                              xQueryPropMapper.GetPointer() );
    if ( FAILED( sc ) )
        THROW( CException( sc ) );

    //
    // Optimize the query
    //

    XQueryOptimizer xqopt( new CQueryOptimizer( xQuerySession,
                                                _xDocStore.GetPointer(),
                                                rstParsed,
                                                cols.GetReference(),
                                                sort.GetPointer(),
                                                pidremap.GetReference(),
                                                Props,
                                                dwQueryStatus ) );

    prxDebugOut(( DEB_ITRACE, "Query has %s1 component%s\n",
                  xqopt->IsMultiCursor() ? "> " : "",
                  xqopt->IsMultiCursor() ? "s" : "" ));
    prxDebugOut(( DEB_ITRACE, "Current component of query %s fully sorted\n",
                  xqopt->IsFullySorted() ? "is" : "is not" ));
    prxDebugOut(( DEB_ITRACE, "Current component of query %s positionable\n",
                  xqopt->IsPositionable() ? "is" : "is not" ));
    prxDebugOut(( DEB_ITRACE, "Rowset props flags: 0x%x\n",
                  Props.GetPropertyFlags() ));
    prxDebugOut(( DEB_ITRACE, "Rowset props maxresults: %d\n",
                  Props.GetMaxResults() ));
    prxDebugOut(( DEB_ITRACE, "Rowset props cmdtimeout: %d\n",
                  Props.GetCommandTimeout() ));

    CPMCreateQueryOut &reply = * (CPMCreateQueryOut *) _Buffer();
    ULONG *aCursors = reply.GetCursors();

    reply.IsWorkIdUnique() = xqopt->IsWorkidUnique();

    reply.SetServerCookie( (ULONG_PTR) this );

    // create either a true sequential or bigtable query

    if ( ( (Props.GetPropertyFlags() & eLocatable) == 0) &&
         ( !xqopt->IsMultiCursor() )             &&
         ( xqopt->IsFullySorted() )              &&
         ( 0 == categ.GetPointer() ) )
    {
        _pQuery = new CSeqQuery( xqopt,
                                 cols,
                                 aCursors,
                                 pidremap,
                                 _xDocStore.GetPointer() );
        reply.IsTrueSequential() = TRUE;
    }
    else
    {
        reply.IsTrueSequential() = FALSE;

        // If we've been instructed to create a synchronous cursor,
        // put the request into a pending state

        BOOL fSync = ( 0 == ( Props.GetPropertyFlags() & eAsynchronous ) );

        XInterface<CRequestServer> xMe;

        if ( fSync )
        {
            // Refcount ourselves in case the async write fails and
            // the request server is recycled before this thread returns.

            AddRef();
            xMe.Set( this );
            state = statePending;
            _state = pipeStatePending;
            _scPendingStatus = S_OK;
            _cbPendingWrite = sizeof CPMCreateQueryOut +
                              ( sizeof ULONG * cCursors );
        }

        TRY
        {
            CRequestQueue & requestQueue = _requestQueue;

            PQuery *pQ = new CAsyncQuery( xqopt,
                                          cols,
                                          sort,
                                          categ,
                                          cCursors,
                                          aCursors,
                                          pidremap,
                                          (Props.GetPropertyFlags() & eWatchable) != 0,
                                          _xDocStore.GetPointer(),
                                          fSync ? this : 0 );

            // If synchronous, the query may be done and freed
            // by the client app by now.  the CRequestServer is still
            // valid due to the AddRef above.

            if ( fSync )
                requestQueue.IncrementPendingItems();
            else
                _pQuery = pQ;
        }
        CATCH( CException, e )
        {
            _pQuery = 0;
            _state = pipeStateRead;
            RETHROW();
        }
        END_CATCH
    }

    cbToWrite = sizeof CPMCreateQueryOut + ( sizeof ULONG * cCursors );

    return state;
} //DoCreateQuery

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoFreeCursor, private
//
//  Synopsis:   Handles a free cursor message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoFreeCursor(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMFreeCursorIn &request = * (CPMFreeCursorIn *) _Buffer();
    CPMFreeCursorOut &reply = * (CPMFreeCursorOut *) _Buffer();

    reply.CursorsRemaining() = _pQuery->FreeCursor( request.GetCursor() );

    // The client is allowed to serially do multiple queries on 1 connection.
    // The way a query is released is by freeing all of its cursors.
    // If this is the last cursor reference to the query, delete the query.

    if ( 0 == reply.CursorsRemaining() )
        FreeQuery();

    cbToWrite = sizeof reply;

    return stateContinue;
} //DoFreeCursor

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoGetRows, private
//
//  Synopsis:   Handles a get rows message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//              12-Nov-99   KLam       Adjust results for Win64 server to
//                                     Win32 client.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoGetRows(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMGetRowsIn & request = * (CPMGetRowsIn *) _Buffer();
    request.ValidateCheckSum( GetClientVersion(), cbRequest );

    //  The input buffer must be as large as the parameter buffer
    //  plus the size of the serialized seek description.

    Win4Assert( _BufferSize() >= sizeof CPMGetRowsOut + request.GetSeekSize() );

    if ( _BufferSize() < sizeof CPMGetRowsOut + request.GetSeekSize() )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    unsigned cbReserved = request.GetReservedSize();
    unsigned cbRowWidth = request.GetRowWidth();
    unsigned cbClientRead = request.GetReadBufferSize();
    unsigned cRowsToTransfer = request.GetRowsToTransfer();
    BOOL fFwdFetch = request.GetFwdFetch();
    ULONG_PTR ulClientBase = request.GetClientBase();
    ULONG hCursor = request.GetCursor();

    // validate params agains attack

    if ( 0 == cbRowWidth ||
         cbRowWidth > cbClientRead ||
         cbReserved >= cbClientRead )
    {
        Win4Assert( 0 != cbRowWidth );
        Win4Assert( cbRowWidth <= cbClientRead );
        Win4Assert( cbReserved < cbClientRead );
        THROW( CException( STATUS_INVALID_PARAMETER ) );
    }

    // Deserialize the row seek description

    Win4Assert( isQWordAligned( (void*) UIntToPtr( cbReserved ) ) );
    Win4Assert( isQWordAligned( request.GetDesc() ) );
    CMemDeSerStream stmDeser( request.GetDesc(), request.GetSeekSize() );
    XPtr<CRowSeekDescription> pRowSeek;
    UnmarshallRowSeekDescription( stmDeser, GetClientVersion(), pRowSeek, FALSE );

    CPMGetRowsOut *pReply;

    // use a temporary buffer if the client is doing a large read

    if ( cbClientRead <= _BufferSize() )
    {
        pReply = (CPMGetRowsOut *) _Buffer();
    }
    else
    {
        _xTempBuffer.Init( cbClientRead );
        pReply = new( _xTempBuffer.Get() ) CPMGetRowsOut;
    }

    #if CIDBG == 1
        RtlFillMemory( ( (BYTE *) pReply ) + sizeof CPMGetRowsOut,
                         cbClientRead - sizeof CPMGetRowsOut,
                         0xca );
    #endif // CIDBG == 1

    // cbReserved includes room for the the CPMGetRowsOut and the marshalled
    // seek description.  All other space in the buffer is for row data.

    unsigned cbRealRowWidth = cbRowWidth;

#ifdef _WIN64
    if ( !IsClient64() ) // replying to a 32 bit client
        cbRealRowWidth = _cbRowWidth64;
#endif

    CFixedVarBufferAllocator Alloc( pReply,
                                    ulClientBase,
                                    cbClientRead,
                                    cbRealRowWidth,
                                    cbReserved );

    CGetRowsParams Fetch( cRowsToTransfer,
                          fFwdFetch,
                          cbRealRowWidth,
                          Alloc );
    XPtr<CRowSeekDescription> xRowSeekOut;

    SCODE scRet = _pQuery->GetRows( hCursor,
                                    pRowSeek.GetReference(),
                                    Fetch,
                                    xRowSeekOut );

    if ( ( SUCCEEDED( scRet ) ) ||
         ( ( STATUS_BUFFER_TOO_SMALL == scRet ) && ( Fetch.RowsTransferred() > 0 ) ) )
    {
        if ( STATUS_BUFFER_TOO_SMALL == scRet )
            pReply->SetStatus( DB_S_BLOCKLIMITEDROWS );
        else
            pReply->SetStatus( scRet );

        pReply->RowsReturned() = Fetch.RowsTransferred();

#ifdef _WIN64
        if ( !IsClient64() ) // replying to a 32 bit client
        {
            // Reply + CPMGetRowsOut + seek info => table info
            BYTE *pbResults = ((BYTE *)pReply) + cbReserved;

            unsigned cbResults = cbClientRead - cbReserved;
            unsigned cRows = Fetch.RowsTransferred();
            
            //
            // Adjust the sizes of the results to fit for a Win32 client
            //
            FixRows ( (BYTE *)pReply, pbResults, cbResults,
                      ulClientBase, cRows, cbRowWidth );
        }
#endif

        //
        // We can't say everything is ok and fetch 0 rows.  This assert was
        // added because we hit this situation on the client side during
        // stress.
        //

        Win4Assert( ! ( ( S_OK == scRet ) &&
                        ( 0 == Fetch.RowsTransferred() ) ) );

        if ( xRowSeekOut.IsNull() )
        {
            ULONG *pul = (ULONG *) pReply->GetSeekDesc();
            *pul = 0;
        }
        else
        {
            Win4Assert( ( xRowSeekOut->MarshalledSize() +
                          sizeof CPMGetRowsOut ) <= cbReserved );
            CMemSerStream stmMem( pReply->GetSeekDesc(),
                                  xRowSeekOut->MarshalledSize() );
            xRowSeekOut->Marshall( stmMem );
        }

        // Have to transfer the entire buffer since variable data is
        // written from the top of the buffer down, and fixed data from
        // the bottom of the buffer up.

        cbToWrite = cbClientRead;
    }
    else
    {
        // This exception is too commmon in testing...

        QUIETTHROW( CException( scRet ) );
    }

    prxDebugOut(( DEB_ITRACE, "status at end of getrows: 0x%x\n",
                  pReply->GetStatus() ));

    return stateContinue;
} //DoGetRows

#ifdef _WIN64

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::FixRows, private
//
//  Synopsis:   Adjusts Win64 rows into Win32 rows.
//
//  Arguments:  [pbReply]       - Reply buffer
//              [pbResults]     - Buffer containting result data
//              [cbResults]     - Number of bytes in results buffer
//              [ulpClientBase] - Offset of buffer on the client
//              [cRows]         - Count of rows
//              [cbRowWidth]    - Bytes in a row
//
//  History:    12-Nov-99   KLam     created
//
//--------------------------------------------------------------------------
void CRequestServer::FixRows ( BYTE * pbReply,
                               BYTE * pbResults,
                               ULONG cbResults,
                               ULONG_PTR ulpClientBase,
                               ULONG cRows,
                               ULONG cbRowWidth )
{
    prxDebugOut(( DEB_ITRACE,
                  "64bit server replying to 32bit client, fixing rows!\n" ));

    Win4Assert( !IsClient64() );

    unsigned cCols = _xCols64->Count();
    
    // Save the result buffer
    BYTE *pbCurrentResults = new BYTE[cbResults];
    XPtrST<BYTE> xbCurrentResults( pbCurrentResults );

    prxDebugOut(( DEB_ITRACE, 
                  "\tCopying %d bytes from 0x%I64x to 0x%I64x\n",
                  cbResults, pbResults, pbCurrentResults ));

    memcpy( pbCurrentResults, pbResults, cbResults );

#if CIDBG == 1
    RtlFillMemory( pbResults,
                   cRows * _cbRowWidth64,
                   0xba );
#endif  // CIDBG == 1

    prxDebugOut(( DEB_ITRACE, 
                  "\tReturning %d rows and %d cols each row being %d bytes (32bit: %d) for a total of %d in a %d bytes buffer\n",
                  cRows, cCols, _cbRowWidth64, cbRowWidth, cRows * _cbRowWidth64, cbResults ));

    prxDebugOut(( DEB_ITRACE, 
                  "\t64bit results are at: 0x%I64x 32bit results will be at: 0x%I64x\n",
                  pbCurrentResults, pbResults ));

    // Fix the results
    for ( unsigned iRow = 0; iRow < cRows; iRow++ )
    {
        prxDebugOut(( DEB_ITRACE, "\n\tRow: %d   Reply Buffer: 0x%I64x  Data Buffer: 0x%I64x\n",
                      iRow, pbCurrentResults, pbResults ));
        for ( unsigned iCol = 0; iCol < cCols; iCol++ )
        {
            prxDebugOut(( DEB_ITRACE, "\n\t\tColumn: %d\n", iCol ));
            prxDebugOut(( DEB_ITRACE, "\t\t_xCols64 0x%I64x\t_xCols32 0x%I64x\n", 
                          _xCols64.GetPointer(), _xCols32.GetPointer() ));

            CTableColumn *pCol64 = _xCols64->Get(iCol);
            CTableColumn *pCol32 = _xCols32->Get(iCol);

            if ( pCol64->IsValueStored() )
            {
                ULONG cbSize32 = 0;
                if ( pCol64->GetStoredType() == VT_VARIANT )
                {
                    PROPVARIANT *pVar64 = (PROPVARIANT *) (pbCurrentResults + pCol64->GetValueOffset());
                    PROPVARIANT32 *pVar32 = (PROPVARIANT32 *) (pbResults + pCol32->GetValueOffset());

                    prxDebugOut(( DEB_ITRACE,
                                  "\t\t Col64 Data: 0x%I64x Offset: %d Col32 Data: 0x%I64x Offset: %d\n", 
                                  pVar64, pCol64->GetValueOffset(), pVar32, pCol32->GetValueOffset() ));

                    cbSize32 = sizeof( PROPVARIANT32 ) + 
                               ((CTableVariant *)pVar64)->VarDataSize32( pbReply, ulpClientBase );
                    pVar32->wReserved2 = (WORD) cbSize32;

                    FixVariantPointers ( pVar32, pVar64, pbReply, ulpClientBase );
                }
                else if ( pCol64->GetStoredType() == VT_I4 )
                {
                    ULONG *pul64 = (ULONG *) (pbCurrentResults + pCol64->GetValueOffset());
                    ULONG *pul32 = (ULONG *) (pbResults + pCol32->GetValueOffset());

                    prxDebugOut(( DEB_ITRACE,
                                  "\t\t VT_I4: %d Col64 Data: 0x%I64x Offset: %d Col32 Data: 0x%I64x Offset: %d\n", 
                                  *pul64, pul64, pCol64->GetValueOffset(), pul32, pCol32->GetValueOffset() ));

                    cbSize32 = 4;
                    *pul32 = *pul64;
                }
                else
                {
                    // Unhandled type
                    Win4Assert ( pCol64->GetStoredType() == VT_I4 ||
                                 pCol64->GetStoredType() == VT_VARIANT );

                }

                if ( pCol64->IsStatusStored() )
                {
                    BYTE *pbStatus64 = (BYTE *) (pbCurrentResults + pCol64->GetStatusOffset());
                    BYTE *pbStatus32 = (BYTE *) (pbResults + pCol32->GetStatusOffset());
                    *pbStatus32 = *pbStatus64;
                    prxDebugOut (( DEB_ITRACE, "\t\tStatus = 0x%x\n", *pbStatus32 ));
                }

                if ( pCol64->IsLengthStored() )
                {
                    LONG *plLength64 = (LONG *) (pbCurrentResults + pCol64->GetLengthOffset());
                    LONG *plLength32 = (LONG *) (pbResults + pCol32->GetLengthOffset());
                    prxDebugOut (( DEB_ITRACE, "\t\tSize32 = %d Size64 = %d\n", cbSize32, *plLength64  ));
                    *plLength32 = cbSize32;
                    prxDebugOut (( DEB_ITRACE, "\t\tLength = %d\n", *plLength32 ));
                }
            }
        }
        
        // Move to the next row
        pbResults += cbRowWidth;
        pbCurrentResults += _cbRowWidth64;
    }
}  // FixRows

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::FixVariantPointers, private
//
//  Synopsis:   Adjusts Win64 variants to fit into Win32 variants.
//
//  Arguments:  [pVar32]        - Pointer to 32 bit variant
//              [pVar64]        - Pointer to 64 bit variant
//              [pbResults]     - Buffer containing variant data
//              [ulClientBase]  - Offset of buffer on the client
//
//  History:    21-Oct-99   KLam     created
//              13-Feb-2000 KLam     assert needed to check element not pointer
//              15-Feb-2000 DLee     DECIMAL is special case (16 bits)
//
//--------------------------------------------------------------------------

void CRequestServer::FixVariantPointers ( PROPVARIANT32 *pVar32,
                                          PROPVARIANT *pVar64,
                                          BYTE *pbResults,
                                          ULONG_PTR ulClientBase )
{
    pVar32->vt = pVar64->vt;

    // reference or a vector or an array
    if ( CTableVariant::IsByRef ( pVar64->vt ) || 0 != (pVar64->vt & (VT_VECTOR | VT_ARRAY)) )
    {
        // blob used here as a generic holder for a size and pointer
        pVar32->blob.cbSize = pVar64->blob.cbSize;
        pVar32->blob.pBlob = (PTR32)(UINT_PTR) (pVar64->blob.pBlobData);

        prxDebugOut(( DEB_ITRACE,
                      "\t\t Fixing reference. ClientBase: 0x%I64x Buffer: 0x%I64x at 0x%x\n", 
                      ulClientBase, pbResults, pVar32->blob.pBlob ));

        if ( VT_LPWSTR == pVar64->vt ||
             VT_LPSTR == pVar64->vt ||
             VT_BSTR == pVar64->vt )
            prxDebugOut(( DEB_ITRACE, "\t\tvt: %d pStr: 0x%I64x\n",
                          pVar64->vt,
                          ((UINT_PTR)pVar64->calpwstr.pElems - ulClientBase) + pbResults ));
        else
            prxDebugOut(( DEB_ITRACE, "\t\tvt: %d size: 0x%I64x pBlob: 0x%I64x\n",
                          pVar64->vt, pVar64->blob.cbSize, pVar64->blob.pBlobData ));

        // Vector of strings
        if ( (VT_VECTOR|VT_LPWSTR) == pVar64->vt ||
             (VT_VECTOR|VT_LPSTR) == pVar64->vt ||
             (VT_VECTOR|VT_BSTR) == pVar64->vt )
        {
            // Get a pointer to the vector in the variable section of the return buffer
            void ** ppvVector = (void **)( ((UINT_PTR)pVar64->calpwstr.pElems - ulClientBase ) + pbResults );
            ULONG * pulVector = (ULONG *) ppvVector;

            prxDebugOut(( DEB_ITRACE, "\t\t Fixing vector 0x%I64x\n", ppvVector ));

            for ( unsigned iElement = 0; iElement < pVar64->calpwstr.cElems; ++iElement )
                pulVector[iElement] = (ULONG) (UINT_PTR) (ppvVector[iElement]);
        }
        // Vector of variants
        else if ( (VT_VARIANT|VT_VECTOR) == pVar64->vt ) // not currently supported
        {
            PROPVARIANT * pVarVector64 = (PROPVARIANT *)( ((UINT_PTR)pVar64->capropvar.pElems - ulClientBase ) + pbResults );
            PROPVARIANT32 * pVarVector32 = (PROPVARIANT32 *) pVarVector64;

            // Recursively fix each variant in the vector
            for ( unsigned iVarElement = 0; iVarElement < pVar64->capropvar.cElems; ++iVarElement )
                FixVariantPointers ( &pVarVector32[iVarElement],
                                     &pVarVector64[iVarElement],
                                     pbResults,
                                     ulClientBase );
        }
        // Arrays (Safearrays)
        else if ( ( 0 != (VT_ARRAY & pVar64->vt) ) || 
                  ( VT_SAFEARRAY == (pVar64->vt & VT_TYPEMASK) ) )
        {
            // Get a pointer to the vector in the variable section of the return buffer
            SAFEARRAY * psa = (SAFEARRAY *)(( (UINT_PTR)pVar64->pparray - ulClientBase ) + pbResults );
            SAFEARRAY32 * psa32 = (SAFEARRAY32 *) psa;
            psa32->pvData = (PTR32) (UINT_PTR) psa->pvData;
            // memmove is smart enough to move the overlapping bytes first
            memmove ( psa32->rgsabound, 
                      psa->rgsabound, 
                      psa32->cDims * sizeof (SAFEARRAYBOUND) );

            if ( VT_BSTR == (pVar64->vt & VT_TYPEMASK) )
            {
                // Pointing to an array of 32bit pointers so adjust the size
                psa32->cbElements = sizeof ( PTR32 ); 

                // Get the number of elements in the safe array
                unsigned cBstrElements = psa32->rgsabound[0].cElements;
                for ( unsigned j = 1; j < psa32->cDims; j++ )
                    cBstrElements *= psa32->rgsabound[j].cElements;

                ULONG *pulBstr = (ULONG *) ((psa32->pvData - ulClientBase) + pbResults );
                void **ppvBstr = (void **) pulBstr;

                for ( j = 0; j < cBstrElements; j++ )
                {
                    // Make sure Win64 isn't passing to big of a pointer
                    if ( 0 != (((ULONG_PTR)ppvBstr[j]) & 0xFFFFFFFF00000000) )
                    {
                        prxDebugOut(( DEB_ERROR, "Non 32 bit pointer 0x%I64x !!!\n",
                                      (ULONG_PTR)ppvBstr[j] ));
                        Win4Assert( 0 == (((ULONG_PTR)ppvBstr[j]) & 0xFFFFFFFF00000000) );
                    }

                    pulBstr[j] = (ULONG) (ULONG_PTR) ppvBstr[j];
                }
            }
            else if ( VT_VARIANT == (pVar64->vt & VT_TYPEMASK) )
            {
                // Pointing to an array of 32bit variants so adjust the size
                psa32->cbElements = sizeof ( PROPVARIANT32 ); 

                // Get the number of elements in the safe array
                unsigned cVariants = psa32->rgsabound[0].cElements;
                for ( unsigned j = 1; j < psa32->cDims; j++ )
                    cVariants *= psa32->rgsabound[j].cElements;

                PROPVARIANT * avar64 = (PROPVARIANT *) ((psa32->pvData - ulClientBase) + pbResults );
                PROPVARIANT32 * avar32 = (PROPVARIANT32 *) avar64;

                prxDebugOut(( DEB_ITRACE, "\t\t Found %d Variants at 0x%I64x\n", cVariants, avar64 ));

                // Recursively fix each variant in the array
                for ( unsigned v = 0; v < cVariants; v++ )
                    FixVariantPointers ( &avar32[v],
                                         &avar64[v],
                                         pbResults,
                                         ulClientBase );
            }
        }
    }
    else if ( VT_DECIMAL == pVar64->vt )
    {
        RtlCopyMemory ( pVar32, pVar64, sizeof PROPVARIANT32 );
    }
    else
    {
        pVar32->uhVal = (ULONGLONG)(UINT_PTR) pVar64->pulVal;

        prxDebugOut(( DEB_ITRACE, "\t\tvt: %d value: 0x%I64x\n\n",
                      pVar64->vt, pVar64->uhVal ));
    }
} //FixVariantPointers
#endif // _WIN64

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoRestartPosition, private
//
//  Synopsis:   Handles a restart position message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    17-Apr-97   emilyb     created
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoRestartPosition(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMRestartPositionIn & request = * (CPMRestartPositionIn *) _Buffer();

    _pQuery->RestartPosition( request.GetCursor(),
                              request.GetChapter() );

    return stateContinue;
} //DoRestartPosition

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoStopAsynch, private
//
//  Synopsis:   Handles a stop processing of async rowset message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    17-Apr-97   emilyb     created
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoStopAsynch(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMStopAsynchIn & request = * (CPMStopAsynchIn *) _Buffer();

    _pQuery->StopAsynch( request.GetCursor() );

    return stateContinue;
} //DoStopAsynch

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoStartWatching, private
//
//  Synopsis:   Handles a start watch all behavior for rowset message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    17-Apr-97   emilyb     created
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoStartWatching(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMStartWatchingIn & request = * (CPMStartWatchingIn *) _Buffer();

    _pQuery->StartWatching( request.GetCursor() );

    return stateContinue;
} //DoStartWatching

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoStopWatching, private
//
//  Synopsis:   Handles a stop watch all behavior for rowset message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    17-Apr-97   emilyb     created
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoStopWatching(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMStopWatchingIn & request = * (CPMStopWatchingIn *) _Buffer();

    _pQuery->StopWatching( request.GetCursor() );

    return stateContinue;
} //DoStopWatching

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoRatioFinished, private
//
//  Synopsis:   Handles a ratio finished message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoRatioFinished(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMRatioFinishedIn &request = * (CPMRatioFinishedIn *) _Buffer();
    CPMRatioFinishedOut &reply = * (CPMRatioFinishedOut *) _Buffer();

    DBCOUNTITEM den, num, rows;

    _pQuery->RatioFinished( request.GetCursor(),
                            den,
                            num,
                            rows,
                            reply.NewRows() );

    reply.Denominator() = (ULONG) den;
    reply.Numerator() = (ULONG) num;
    reply.RowCount() = (ULONG) rows;

    cbToWrite = sizeof reply;
    return stateContinue;
} //DoRatioFinished

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoCompareBmk, private
//
//  Synopsis:   Handles a compare bookmark message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoCompareBmk(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMCompareBmkIn &request = * (CPMCompareBmkIn *) _Buffer();
    CPMCompareBmkOut &reply = * (CPMCompareBmkOut *) _Buffer();

    _pQuery->Compare( request.GetCursor(),
                      request.GetChapter(),
                      request.GetBmkFirst(),
                      request.GetBmkSecond(),
                      reply.Comparison() );

    cbToWrite = sizeof reply;
    return stateContinue;
} //DoCompareBmk

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoGetApproximatePosition, private
//
//  Synopsis:   Handles a get approximate position message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoGetApproximatePosition(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMGetApproximatePositionIn &request = * (CPMGetApproximatePositionIn *)_Buffer();
    CPMGetApproximatePositionOut &reply = * (CPMGetApproximatePositionOut *)_Buffer();

    DBCOUNTITEM cNum,cDen;

    _pQuery->GetApproximatePosition( request.GetCursor(),
                                     request.GetChapter(),
                                     request.GetBmk(),
                                     & cNum,
                                     & cDen );

    reply.Numerator() = (ULONG) cNum;
    reply.Denominator() = (ULONG) cDen;

    cbToWrite = sizeof reply;
    return stateContinue;
} //DoGetApproximatePosition

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoSetBindings, private
//
//  Synopsis:   Handles a set bindings message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//              05-Oct-99   KLam       Handle Win32 client to Win64 server
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoSetBindings(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    Win4Assert( 0 != _pQuery || IsBeingRemoved() );

    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    // The request is either in the standard buffer or the temp buffer.
    // Take ownership of the temp buffer.

    CPMSetBindingsIn &request = * (CPMSetBindingsIn *) _ActiveBuffer();
    XPtrST<BYTE> xTemp( _xTempBuffer.Acquire() );

    Win4Assert( isQWordAligned( request.GetDescription() ) );

    request.ValidateCheckSum( GetClientVersion(), cbRequest );

    CMemDeSerStream stmDeser( request.GetDescription(),
                              request.GetBindingDescLength() );

    XPtr<CPidMapper> Pidmap( new CPidMapper() );

    XPtr<CTableColumnSet> Cols( new CTableColumnSet ( stmDeser,
                                                      Pidmap.GetReference() ) );

#ifdef _WIN64    

    // Create a new TableColumnSet with 64-bit sizes
    if ( !IsClient64() )
    {
        prxDebugOut(( DEB_ITRACE, "32bit client querying 64bit server, fixing columns!\n" ));

        //
        // The client gave us a 32-bit column description
        // Fix the column descriptions to work on Win64
        //
        FixColumns ( Cols.Acquire() );

        _cbRowWidth32 = request.GetRowLength();

        // SetBindings with the 64 bit table
        _pQuery->SetBindings( request.GetCursor(),
                              _cbRowWidth64,
                              _xCols64.GetReference(),
                              Pidmap.GetReference() );

        prxDebugOut(( DEB_ITRACE, "\tRow Length: Win32 %d Win64 %d\n", _cbRowWidth32, _cbRowWidth64 ));
        prxDebugOut(( DEB_ITRACE, "\t\t_xCols64 0x%I64x\n\t\t_xCols32 0x%I64x\n", 
                      _xCols64.GetPointer(), _xCols32.GetPointer() ));
    }
    else
    {
#endif

    _pQuery->SetBindings( request.GetCursor(),
                          request.GetRowLength(),
                          Cols.GetReference(),
                          Pidmap.GetReference() );

#ifdef _WIN64
    }
#endif

    return stateContinue;


} //DoSetBindings

#ifdef _WIN64
//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::FixColumns, private
//
//  Synopsis:   Adjusts a Win32 column description to a Win64 column description
//              and saves both descriptions
//
//  Arguments:  [pCols32]   - 32 bit table column set description
//
//  History:    12-Nov-99   KLam       Created.
//
//--------------------------------------------------------------------------

void CRequestServer::FixColumns ( CTableColumnSet * pCols32 )
{
    USHORT iEnd = 0;
    USHORT iAlignment;

    // Make sure these were freed from FreeQuery
    if ( !_xCols64.IsNull() && !_xCols32.IsNull() )
        THROW ( CException( STATUS_INVALID_PARAMETER ) );

    // Create a 64 bit column description
    _xCols64.Set( new CTableColumnSet ( pCols32->Count() ) );
    _xCols32.Set( pCols32 );

    for (unsigned iCol = 0; iCol < _xCols32->Count(); iCol++)
    {
        CTableColumn *pColumn = _xCols32->Get(iCol);

        VARTYPE vt = pColumn->GetStoredType();

        Win4Assert ( VT_VARIANT == vt|| VT_I4 == vt );

        XPtr<CTableColumn> xColumn64 (new CTableColumn( iCol ));

        if ( pColumn->IsValueStored() )
        {

            prxDebugOut(( DEB_ITRACE, 
                          "\n\tFound value type: %d width: %d offset: %d\n",
                          pColumn->GetStoredType(), pColumn->GetValueSize(), pColumn->GetValueOffset() ));

            if ( VT_VARIANT == vt )
            {
                iAlignment = (USHORT)AlignBlock ( iEnd, sizeof(LONGLONG) );
                iEnd = iAlignment + sizeof (PROPVARIANT);

                xColumn64->SetValueField( VT_VARIANT,
                                          iAlignment,
                                          sizeof (PROPVARIANT) );
            }
            else if ( VT_I4 == vt )
            {
                iAlignment = (USHORT)AlignBlock ( iEnd, sizeof(ULONG) );
                iEnd = iAlignment + sizeof (ULONG);

                xColumn64->SetValueField( VT_I4,
                                          iAlignment,
                                          sizeof (ULONG) );
            }

            prxDebugOut(( DEB_ITRACE, 
                          "\t  Replacing with width: %d offset: %d\n",
                          xColumn64->GetValueSize(), xColumn64->GetValueOffset() )); 
        }

        if ( pColumn->IsStatusStored() )
        {
            prxDebugOut(( DEB_ITRACE, 
                          "\tFound status width: %d offset: %d\n",
                          pColumn->GetStatusSize(), pColumn->GetStatusOffset() ));

            iAlignment = (USHORT)AlignBlock ( iEnd, sizeof (BYTE) );
            iEnd = iAlignment + sizeof (BYTE);

            xColumn64->SetStatusField( iAlignment, sizeof (BYTE) );

            prxDebugOut(( DEB_ITRACE, 
                          "\t  Replacing with width: %d offset: %d\n",
                          xColumn64->GetStatusSize(), xColumn64->GetStatusOffset() )); 
        }

        if ( pColumn->IsLengthStored() )
        {
            prxDebugOut(( DEB_ITRACE, 
                          "\tFound length width: %d offset: %d\n",
                          pColumn->GetLengthSize(), pColumn->GetLengthOffset() ));

            iAlignment = (USHORT)AlignBlock ( iEnd, sizeof (ULONG) );
            iEnd = iAlignment + sizeof (ULONG);

            xColumn64->SetLengthField( iAlignment, sizeof (ULONG) );

            prxDebugOut(( DEB_ITRACE, 
                          "\t  Replacing with width: %d offset: %d\n",
                          xColumn64->GetLengthSize(), xColumn64->GetLengthOffset() )); 
        }

        // Store the column in the column set
        _xCols64->Add( xColumn64.GetPointer(), iCol );
        xColumn64.Acquire();
    }

    _cbRowWidth64 = AlignBlock( iEnd, sizeof(ULONGLONG) );

} // FixColumns
#endif // _WIN64

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoGetNotify, private
//
//  Synopsis:   Handles a get notify message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoGetNotify(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    // _pQuery will be zero if the notify thread comes in after the last
    // FreeCursor.  This is a rare non-fatal condition and it is ok to
    // throw an error.

    if ( 0 == _pQuery )
        QUIETTHROW( CException( STATUS_INVALID_PARAMETER ) );

    CProxyMessage &msg = * (CProxyMessage *) _Buffer();
    Win4Assert( pmGetNotify == msg.GetMessage() );

    CNotificationSync sync( this );
    DBWATCHNOTIFY wn;
    SCODE sc = _pQuery->GetNotifications( sync, wn );

    // If STATUS_PENDING, just return the pmGetNotify and the client will
    // be expecting 0 or 1 pmSendNotify messages at some later time.
    // Otherwise, the notification is available and it is returned here.

    if ( STATUS_PENDING != sc )
    {
        Win4Assert( S_OK == sc ); // GetNotifications throws on failure

        CPMSendNotifyOut *pReply = new( _Buffer() ) CPMSendNotifyOut( wn );
        cbToWrite = sizeof CPMSendNotifyOut;
    }

    return stateContinue;
} //DoGetNotify

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoSendNotify, private
//
//  Synopsis:   Handles a send notify message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoSendNotify(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    Win4Assert( FALSE && !"pmSendNotify is server to client only!" );
    return stateDisconnect;
} //DoSendNotify

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoSetWatchMode, private
//
//  Synopsis:   Handles a set watch mode message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoSetWatchMode(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMSetWatchModeIn &request = * (CPMSetWatchModeIn *) _Buffer();

    HWATCHREGION hRegion = request.GetRegion();
    _pQuery->SetWatchMode( &hRegion, request.GetMode() );

    CPMSetWatchModeOut &reply = * (CPMSetWatchModeOut *) _Buffer();
    reply.Region() = hRegion;
    cbToWrite = sizeof reply;

    return stateContinue;
} //DoSetWatchMode

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoGetWatchInfo, private
//
//  Synopsis:   Handles a get watch info message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoGetWatchInfo(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMGetWatchInfoIn &request = * (CPMGetWatchInfoIn *) _Buffer();
    CPMGetWatchInfoOut &reply = * (CPMGetWatchInfoOut *) _Buffer();

    DBCOUNTITEM cRows;

    _pQuery->GetWatchInfo( request.GetRegion(),
                           & reply.Mode(),
                           & reply.Chapter(),
                           & reply.Bookmark(),
                           & cRows );

    reply.RowCount() = (ULONG) cRows;

    cbToWrite = sizeof reply;
    return stateContinue;
} //DoGetWatchInfo

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoShrinkWatchRegion, private
//
//  Synopsis:   Handles a shrink watch region message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoShrinkWatchRegion(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMShrinkWatchRegionIn &request = * (CPMShrinkWatchRegionIn *) _Buffer();

    _pQuery->ShrinkWatchRegion( request.GetRegion(),
                                request.GetChapter(),
                                request.GetBookmark(),
                                request.GetRowCount() );

    return stateContinue;
} //DoShrinkWatchRegion

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoRefresh, private
//
//  Synopsis:   Handles a refresh message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoRefresh(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    _pQuery->Refresh();

    return stateContinue;
} //DoRefresh

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoGetQueryStatus, private
//
//  Synopsis:   Handles a get query status message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoGetQueryStatus(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMGetQueryStatusIn &request = * (CPMGetQueryStatusIn *) _Buffer();
    CPMGetQueryStatusOut &reply = * (CPMGetQueryStatusOut *) _Buffer();

    _pQuery->GetQueryStatus( request.GetCursor(),
                             reply.QueryStatus() );

    cbToWrite = sizeof reply;
    return stateContinue;
} //DoGetQueryStatus

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoGetQueryStatusEx, private
//
//  Synopsis:   Handles a get query status message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoGetQueryStatusEx(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMGetQueryStatusExIn &request = * (CPMGetQueryStatusExIn *) _Buffer();
    CPMGetQueryStatusExOut &reply = * (CPMGetQueryStatusExOut *) _Buffer();

    DBCOUNTITEM den, num, iBmk, cRows;

    _pQuery->GetQueryStatusEx( request.GetCursor(),
                               reply.QueryStatus(),
                               reply.FilteredDocuments(),
                               reply.DocumentsToFilter(),
                               den,
                               num,
                               request.GetBookmark(),
                               iBmk,
                               cRows );

    reply.RatioFinishedDenominator() = (ULONG) den;
    reply.RatioFinishedNumerator() = (ULONG) num;
    reply.RowBmk() = (ULONG) iBmk;
    reply.RowsTotal() = (ULONG) cRows;

    cbToWrite = sizeof reply;
    return stateContinue;
} //DoGetQueryStatusEx

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoCiState, private
//
//  Synopsis:   Handles a ci state message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoCiState(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    CPMCiStateInOut &request = * (CPMCiStateInOut *) _Buffer();

    if ( _xDocStore.IsNull() )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    XInterface<IFsCiAdmin> xFsCiAdmin;
    SCODE sc = _xDocStore->QueryInterface( IID_IFsCiAdmin,
                                           xFsCiAdmin.GetQIPointer() );

    if ( S_OK == sc )
    {
        sc = xFsCiAdmin->CiState( &(request.GetState()) );
        request.SetStatus( sc );
    }

    cbToWrite = sizeof CProxyMessage + request.GetState().cbStruct;
    return stateContinue;
} //DoCiState

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoObsolete, private
//
//  Synopsis:   Handles an obsolete message
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoObsolete(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    // This request is obsolete

    THROW( CException( STATUS_INVALID_PARAMETER ) );
    return stateDisconnect;
} //DoObsolete

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoForceMerge, private
//
//  Synopsis:   Handles a force merge message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoForceMerge(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    VerifyThreadHasAdminPrivilege();

    if ( _xDocStore.IsNull() )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMForceMergeIn &request = * (CPMForceMergeIn *) _Buffer();

    XInterface<IFsCiAdmin> xFsCiAdmin;
    SCODE sc = _xDocStore->QueryInterface( IID_IFsCiAdmin,
                                           xFsCiAdmin.GetQIPointer() );

    if ( SUCCEEDED(sc) )
        sc = xFsCiAdmin->ForceMerge( request.GetPartID() );

    if ( !SUCCEEDED(sc) )
        THROW( CException(sc) );

    return stateContinue;
} //DoForceMerge

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoAbortMerge, private
//
//  Synopsis:   Handles an abort merge message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoAbortMerge(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    VerifyThreadHasAdminPrivilege();

    if ( _xDocStore.IsNull() )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMAbortMergeIn &request = * (CPMAbortMergeIn *) _Buffer();

    XInterface<IFsCiAdmin> xFsCiAdmin;
    SCODE sc = _xDocStore->QueryInterface( IID_IFsCiAdmin,
                                           xFsCiAdmin.GetQIPointer() );

    if ( SUCCEEDED(sc) )
        sc = xFsCiAdmin->AbortMerge( request.GetPartID() );

    if ( !SUCCEEDED(sc) )
        THROW( CException(sc) );

    return stateContinue;
} //DoAbortMerge

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoSetCatState, private
//
//  Synopsis:   Handles a SetCiCatState message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    14-Apr-98   kitmanh       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoSetCatState(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    ciDebugOut(( DEB_ITRACE, "DoSetCatState is called\n" ));
    VerifyThreadHasAdminPrivilege();

    CPMSetCatStateIn &request = * (CPMSetCatStateIn *) _Buffer();
    CPMSetCatStateOut &reply = * (CPMSetCatStateOut *) _Buffer();

    XInterface<ICiCDocStoreLocator> xLocator( _requestQueue.DocStoreLocator() );
    Win4Assert( !xLocator.IsNull() );

    BOOL fAbsUnWritable = FALSE; //temp value
    DWORD dwOldState;

    // hack to check if all catalogs are up, catalog name is ignored
    if ( CICAT_ALL_OPENED == request.GetNewState() )
    {
        reply.GetOldState() = _requestQueue.AreDocStoresOpen(); // make a constant
        cbToWrite = sizeof reply;
        return stateContinue;
    }
    // end of hack

    ICiCDocStore * pDocStore = 0;

    // Make sure we have a valid catalog name

    WCHAR *szCatalog = request.GetCatName();

    if ( 0 == szCatalog )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    unsigned cwc = wcslen( szCatalog );

    if ( ( 0 == cwc) || ( cwc >= ( MAX_PATH-1 ) ) )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    // check old state of docstore

    SCODE sc = xLocator->GetDocStoreState( szCatalog,
                                           &pDocStore,
                                           &dwOldState );
    reply.GetOldState() = dwOldState;

    if ( SUCCEEDED(sc) )
    {
        _xDocStore.Set( pDocStore );

        if ( 0 != pDocStore )
        {
            // This QI is just about guaranteed to work.

            XInterface<ICiCAdviseStatus> xAdviseStatus;

            sc = pDocStore->QueryInterface( IID_ICiCAdviseStatus,
                                            xAdviseStatus.GetQIPointer() );
            if ( S_OK != sc )
                THROW( CException(sc) );

            xAdviseStatus->IncrementPerfCounterValue( CI_PERF_RUNNING_QUERIES );
        }

        //Push an item onto the _stateChangeArray for the (make this a function name DoDisConnect

        SCWorkItem newItem;

        ciDebugOut(( DEB_ITRACE, "request.GetNewState == %d\n", request.GetNewState() ));

        switch ( request.GetNewState() )
        {
            case CICAT_GET_STATE:
                break;
            case CICAT_STOPPED:
                if ( 0 == (CICAT_STOPPED & dwOldState) )
                {
                    newItem.type = eStopCat;
                    newItem.pDocStore = _xDocStore.GetPointer();
                    _requestQueue.AddSCItem( &newItem , 0 );
                    xLocator->AddStoppedCat( dwOldState, request.GetCatName() );
                    CLock lock( g_mtxStartStop );
                    sc = StopFWCiSvcWork( eStopCat );
                }

                break;

            case CICAT_READONLY:
                ciDebugOut(( DEB_ITRACE, "New state is CICAT_READONLY\n" ));
                if ( 0 == (CICAT_READONLY & dwOldState) )
                {
                    newItem.type = eCatRO;
                    newItem.pDocStore = _xDocStore.GetPointer();

                    if ( 0 != (CICAT_STOPPED & dwOldState) )
                    {
                        ciDebugOut(( DEB_ITRACE, "DoSetCatState, restarting a stopped cat\n" ));
                        ciDebugOut(( DEB_ITRACE, "DoSetCatState.. newItem.StoppedCat is %ws\n", request.GetCatName() ));
                        _requestQueue.AddSCItem( &newItem, request.GetCatName() );
                    }
                    else
                        _requestQueue.AddSCItem( &newItem , 0 );

                    CLock lock( g_mtxStartStop );
                    sc = StopFWCiSvcWork( eCatRO );
                }

                ciDebugOut(( DEB_ITRACE, "Done setting CICAT_READONLY\n" ));
                break;

            case CICAT_WRITABLE:

                if ( 0 == (CICAT_WRITABLE & dwOldState) )
                {
                    sc = xLocator->IsMarkedReadOnly( request.GetCatName(), &fAbsUnWritable );
                    if ( FAILED(sc) )
                        THROW( CException(sc) );

                    ciDebugOut(( DEB_ITRACE, "DoSetCatState.. IsMarkedReadOnly is %d\n", fAbsUnWritable ));

                    if ( CICAT_STOPPED == dwOldState )
                    {
                        if ( !fAbsUnWritable )
                        {
                            sc = xLocator->IsVolumeOrDirRO( request.GetCatName(), &fAbsUnWritable );
                            if ( FAILED(sc) )
                                THROW( CException(sc) );
                        }

                        ciDebugOut(( DEB_ITRACE, "DoSetCatState.. fAbsUnWritable is %d\n", fAbsUnWritable ));
                    }

                    if ( fAbsUnWritable )
                    {
                        //Catalog cannot be open for r/w, open as r/o instead
                        //can't throw, must finish work
                        newItem.type = eCatRO;
                    }
                    else
                        newItem.type = eCatW;

                    newItem.pDocStore = _xDocStore.GetPointer();
                    if ( CICAT_STOPPED == dwOldState )
                    {
                        ciDebugOut(( DEB_ITRACE, "DoSetCatState, restarting a stopped cat\n" ));
                        ciDebugOut(( DEB_ITRACE, "DoSetCatState.. newItem.StoppedCat is %ws\n", request.GetCatName() ));
                        _requestQueue.AddSCItem( &newItem, request.GetCatName() );
                    }
                    else
                        _requestQueue.AddSCItem( &newItem, 0 );

                    CLock lock( g_mtxStartStop );
                    sc = StopFWCiSvcWork( newItem.type );
                }

                break;

            case CICAT_NO_QUERY:
                if ( 0 == (CICAT_NO_QUERY & dwOldState) )
                {
                    newItem.type = eNoQuery;

                    sc = xLocator->IsMarkedReadOnly( request.GetCatName(), &fAbsUnWritable );
                    if ( FAILED(sc) )
                        THROW( CException(sc) );

                    ciDebugOut(( DEB_ITRACE, "DoSetCatState.. IsMarkedReadOnly is %d\n", fAbsUnWritable ));

                    if ( 0 != (CICAT_STOPPED & dwOldState) )
                    {
                        if ( !fAbsUnWritable )
                        {
                            sc = xLocator->IsVolumeOrDirRO( request.GetCatName(), &fAbsUnWritable );
                            if ( FAILED(sc) )
                                THROW( CException(sc) );
                        }
                        ciDebugOut(( DEB_ITRACE, "DoSetCatState(NoQuery).. fAbsUnWritable is %d\n", fAbsUnWritable ));
                    }

                    if ( fAbsUnWritable )
                    {
                        //The catalog is absolutely unwritable, opening for ReadOnly instead
                        //can't throw here, since work needs to be done.
                        newItem.fNoQueryRW = FALSE;
                    }
                    else
                        newItem.fNoQueryRW = TRUE;

                    newItem.pDocStore = _xDocStore.GetPointer();
                    if ( 0 != (CICAT_STOPPED & dwOldState) )
                        _requestQueue.AddSCItem( &newItem, request.GetCatName() );
                    else
                        _requestQueue.AddSCItem( &newItem, 0 );

                    CLock lock( g_mtxStartStop );
                    sc = StopFWCiSvcWork( newItem.type );
                }
                break;

            default:
                THROW( CException( STATUS_INVALID_PARAMETER ) );
        }
    }

    ciDebugOut(( DEB_ITRACE, "DoSetCatState sc is %d or %#x\n", sc ));

    if ( !SUCCEEDED(sc) )
        THROW( CException(sc) );

    cbToWrite = sizeof reply;
    return stateContinue;
} //DoSetCatState


//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoFetchValue, private
//
//  Synopsis:   Retrieves a value from the property cache
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoFetchValue(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMFetchValueIn &request = * (CPMFetchValueIn *) _Buffer();
    request.ValidateCheckSum( GetClientVersion(), cbRequest );

    WORKID wid = request.GetWID();
    DWORD cbSoFar = request.GetSoFar();
    DWORD cbPropSpec = request.GetPSSize();
    DWORD cbChunk = request.GetChunkSize();

    // if this is the first request for the value, fetch the value

    if ( 0 == cbSoFar )
    {
        _xFetchedValue.Free();
        _cbFetchedValueSoFar = 0;

        Win4Assert( isQWordAligned( request.GetPS() ) );
        CMemDeSerStream stmDeser( request.GetPS(), cbPropSpec );
        CFullPropSpec ps( stmDeser );
        if ( !ps.IsValid() )
            THROW( CException( E_OUTOFMEMORY ) );

        PROPVARIANT var;
        if ( !_pQuery->FetchDeferredValue( wid, ps, var ) || var.vt == VT_EMPTY )
        {
            //
            // FetchDeferredValue does a security check to make sure the client has access
            // to this wid.  A hacker could pass in a wid not returned in a query.
            //
            CPMFetchValueOut &reply = * (CPMFetchValueOut *) _Buffer();
            reply.ValueExists() = FALSE;
            cbToWrite = sizeof reply;
            return stateContinue;
        }

        // marshall the property value and save it in _xFetchedValue

        SPropVariant xvar( &var );
        ULONG cb = 0;
        StgConvertVariantToProperty( &var,
                                     CP_WINUNICODE,
                                     0,
                                     &cb,
                                     pidInvalid,
                                     FALSE,
                                     0 );
        _xFetchedValue.Init( cb );
        StgConvertVariantToProperty( &var,
                                     CP_WINUNICODE,
                                     (SERIALIZEDPROPERTYVALUE *)_xFetchedValue.Get(),
                                     &cb,
                                     pidInvalid,
                                     FALSE,
                                     0 );
    }

    // send a chunk (or all) of the marshalled property value

    Win4Assert( cbSoFar == _cbFetchedValueSoFar );
    Win4Assert( 0 != _xFetchedValue.Get() );

    DWORD cbToGo = _xFetchedValue.SizeOf() - _cbFetchedValueSoFar;
    Win4Assert( sizeof CPMFetchValueOut < cbChunk );
    DWORD cbValToWrite = __min( cbChunk - sizeof CPMFetchValueOut, cbToGo );
    cbToWrite = sizeof CPMFetchValueOut + cbValToWrite;

    CPMFetchValueOut *pReply;
    if ( cbToWrite <= _BufferSize() )
    {
        pReply = (CPMFetchValueOut *) _Buffer();
    }
    else
    {
        _xTempBuffer.Init( cbToWrite );
        pReply = new( _xTempBuffer.Get() ) CPMFetchValueOut;
    }

    pReply->ValueExists() = TRUE;
    pReply->ValueSize() = cbValToWrite;
    pReply->MoreExists() = ( cbValToWrite != cbToGo );
    RtlCopyMemory( pReply->Value(),
                   _xFetchedValue.Get() + _cbFetchedValueSoFar,
                   cbValToWrite );
    _cbFetchedValueSoFar += cbValToWrite;

    if ( !pReply->MoreExists() )
    {
        _xFetchedValue.Free();
        _cbFetchedValueSoFar = 0;
    }

    return stateContinue;
} //DoFetchValue

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoWorkIdToPath, private
//
//  Synopsis:   Converts a wid to a path.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoWorkIdToPath(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    if ( 0 == _pQuery )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMWorkIdToPathIn &request = * (CPMWorkIdToPathIn *) _Buffer();
    CFunnyPath funnyPath;

    _pQuery->WorkIdToPath( request.GetWorkId(), funnyPath );

    CPMWorkIdToPathOut &reply = * (CPMWorkIdToPathOut *) _Buffer();

    cbToWrite = sizeof reply;
    if ( 0 != funnyPath.GetActualLength() )
    {
        reply.Any() = TRUE;
        ULONG cbPath = (funnyPath.GetActualLength()+1) * sizeof(WCHAR);
        RtlCopyMemory( reply.Path(), funnyPath.GetActualPath(), cbPath );
        cbToWrite += cbPath;
    }
    else
    {
        reply.Any() = FALSE;
    }

    return stateContinue;
} //DoWorkIdToPath

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoUpdateDocuments, private
//
//  Synopsis:   Handles an update documents message.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::DoUpdateDocuments(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    VerifyThreadHasAdminPrivilege();

    if ( _xDocStore.IsNull() )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    CPMUpdateDocumentsIn &request = * (CPMUpdateDocumentsIn *) _Buffer();

    XInterface<IFsCiAdmin> xFsCiAdmin;
    SCODE sc = _xDocStore->QueryInterface( IID_IFsCiAdmin,
                                           xFsCiAdmin.GetQIPointer() );

    if ( wcslen( request.GetRootPath() ) >= MAX_PATH )
        THROW( CException( STATUS_INVALID_PARAMETER ) );

    if ( SUCCEEDED(sc) )
        sc = xFsCiAdmin->UpdateDocuments( request.GetRootPath(),
                                          request.GetFlag() );

    if ( !SUCCEEDED(sc) )
        THROW( CException(sc) );

    return stateContinue;
} //DoUpdateDocuments

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::HandleRequestNoThrow, private
//
//  Synopsis:   Processes a request.  This method can't throw.  If there
//              is any problem with the request, set the status code
//              in the message to reflect the problem.
//
//  Arguments:  [cbRequest] - Size of the request in _Buffer()
//              [cbToWrite] - On output, set to the # of bytes to write if
//                            other than sizeof CProxyMessage.
//
//  Returns:    FALSE if the connection with the client should be terminated,
//              TRUE otherwise.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

RequestState CRequestServer::HandleRequestNoThrow(
    DWORD   cbRequest,
    DWORD & cbToWrite )
{
    // buffers must be 8-byte aligned on both sides of the proxy or the
    // marshalling/unmarshalling will be inconsistent.

    Win4Assert( isQWordAligned( _Buffer() ) );

    CProxyMessage &msg = * (CProxyMessage *) _Buffer();

    // Require that messages sent from clients have status set to S_OK,
    // as the reply message is in the same buffer and there is no need
    // to re-write the S_OK.

    Win4Assert( S_OK == msg.GetStatus() );

    RequestState state = stateContinue;

    TRY
    {
        Win4Assert( _xTempBuffer.SizeOf() > _BufferSize() ||
                    _xTempBuffer.IsNull() );

        int iMsg = msg.GetMessage() - pmConnect;

        if ( ( iMsg < 0 ) || ( iMsg >= cProxyMessages ) )
            THROW( CException( STATUS_INVALID_PARAMETER ) );

        // Don't impersonate when not necessary -- it's slow

        XPipeImpersonation impersonate;

        if ( _afImpersonate[ iMsg ] )
            impersonate.Impersonate( GetPipe() );

        SetLastTouchedTime( GetTickCount() );

        state = ( this->*( _aMsgFunctions[ iMsg ] ) )( cbRequest,
                                                       cbToWrite );

        prxDebugOut(( DEB_ITRACE,
                      "finish msg %d, cb %d, sc 0x%x, to pipe 0x%x\n",
                      msg.GetMessage(),
                      cbToWrite,
                      msg.GetStatus(),
                      GetPipe() ));
    }
    CATCH( CException, ex )
    {
        prxDebugOut(( DEB_ITRACE,
                      "HandleRequestNoThrow rs 0x%x msg %d caught 0x%x\n",
                      this,
                      msg.GetMessage(),
                      ex.GetErrorCode() ));

        msg.SetStatus( ex.GetErrorCode() );
        cbToWrite = sizeof CProxyMessage;

        _xTempBuffer.Free();
    }
    END_CATCH;

    return state;
} //HandleRequestNoThrow

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::DoAPC, private
//
//  Synopsis:   This method is called when an i/o operation is completed,
//              whether successfully or not.  If there was an error,
//              this method terminates the connection.
//
//  Arguments:  [dwError]       - Win32 error code for i/o operation
//              [cbTransferred] - # of bytes read or written
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

void CRequestServer::DoAPC(
    DWORD dwError,
    DWORD cbTransferred )
{
    prxDebugOut(( DEB_ITRACE, "apc %s t 0x%x p 0x%x msg %d cb %d err %d\n",
                  pipeStateRead == _state ? "read" :
                      pipeStateWrite == _state ? "write" : "none",
                  GetCurrentThreadId(),
                  GetPipe(),
                  * (int *) _Buffer(),
                  cbTransferred,
                  dwError ));

    // Ownership of the item is with the apc:  either issue another i/o
    // or recycle the request server.

    TRY
    {
        // if the apc operation completed with an error, abort the connection

        if ( 0 != dwError )
            QUIETTHROW( CException( HRESULT_FROM_WIN32( dwError ) ) );

        if ( IsBeingRemoved() )
            THROW( CException( STATUS_TOO_LATE ) );

        if ( pipeStateRead == _state )
        {
            // if the entire message didn't fit in the buffer (eg, there was
            // a large restriction) read the rest of the message.

            if ( _BufferSize() == cbTransferred )
            {
                prxDebugOut(( DEB_ITRACE, "more data available\n" ));
                BYTE *p = ReadRemainingSync( _Buffer(), cbTransferred );

                //
                // ReadRemainingSync returns 0 if there was an exact fit
                // into _Buffer, so there was nothing left to read.
                //

                if ( 0 != p )
                {
                    _xTempBuffer.Set( cbTransferred, p );
                    prxDebugOut(( DEB_ITRACE, "total msg cb: %d\n",
                                  cbTransferred ));

                    // Only certain msgs expect the input buffer to be in
                    // _xTempBuffer.  Fail if it's not one of these msgs.

                    int pm = * (int *)  _xTempBuffer.Get();
                    Win4Assert( ( pmCreateQuery == pm ) ||
                                ( pmConnect     == pm ) ||
                                ( pmSetBindings == pm ) );

                    if ( pmCreateQuery != pm &&
                         pmConnect     != pm &&
                         pmSetBindings != pm )
                        THROW( CException( STATUS_INVALID_PARAMETER ) );
                }
            }

            #if CIDBG == 1
                prxDebugOut(( DEB_PRX_MSGS,
                              "proxy read %d bytes at %p\n",
                              cbTransferred, _ActiveBuffer() ));
            #endif // CIDBG == 1

            #if CI_PIPE_TESTING
            
                if ( 0 != _requestQueue._pTraceRead )
                    (*_requestQueue._pTraceRead)( GetPipe(),
                                                  cbTransferred,
                                                  _ActiveBuffer() );
            
            #endif // CI_PIPE_TESTING
            
            // The read completed, process the request

            DWORD cbToWrite = sizeof CProxyMessage;
            RequestState state = HandleRequestNoThrow( cbTransferred, cbToWrite );

            if ( stateContinue == state )
            {
                Win4Assert( cbToWrite >= sizeof CProxyMessage );
                Win4Assert( ( cbToWrite <= _BufferSize() ) ||
                            ( !_xTempBuffer.IsNull() ) );
                Win4Assert( ( cbToWrite > _BufferSize() ) ||
                            ( _xTempBuffer.IsNull() ) );
                Win4Assert( ( _xTempBuffer.IsNull() ) ||
                            ( cbToWrite == _xTempBuffer.SizeOf() ) );

                _state = pipeStateWrite;

                #if CIDBG == 1
                    prxDebugOut(( DEB_PRX_MSGS,
                                  "proxy writing %d bytes at %p\n",
                                  cbToWrite, _ActiveBuffer() ));
                #endif // CIDBG == 1

                void * pvToWrite = _ActiveBuffer();

                #if CI_PIPE_TESTING
                
                    void * pvToWriteOrg = pvToWrite;
                    DWORD cbToWriteOrg = cbToWrite;

                    if ( 0 != _requestQueue._pTraceBefore )
                        (*_requestQueue._pTraceBefore)( GetPipe(),
                                                        cbToWriteOrg,
                                                        pvToWriteOrg,
                                                        cbToWrite,
                                                        pvToWrite );

                
                #endif // CI_PIPE_TESTING

                Write( pvToWrite, cbToWrite, APCRoutine );

                #if CI_PIPE_TESTING
                
                    if ( 0 != _requestQueue._pTraceAfter )
                        (*_requestQueue._pTraceAfter)( GetPipe(),
                                                       cbToWriteOrg,
                                                       pvToWriteOrg,
                                                       cbToWrite,
                                                       pvToWrite );
                
                #endif // CI_PIPE_TESTING
                
                if ( IsBeingRemoved() )
                    CancelIO();
            }
            else if ( stateDisconnect == state )
            {
                Win4Assert( _xTempBuffer.IsNull() );
                _state = pipeStateNone;
                _requestQueue.RecycleRequestServerNoThrow( this );
            }
            else
            {
                Win4Assert( statePending == state );
            }
        }
        else
        {
            Win4Assert( pipeStateWrite == _state );

            // cleanup temp buffer if allocated for the write

            _xTempBuffer.Free();

            // the write completed, so schedule another read

            _state = pipeStateRead;
            Read( _Buffer(), _BufferSize(), APCRoutine );

            if ( IsBeingRemoved() )
                CancelIO();
        }
    }
    CATCH( CException, ex )
    {
        prxDebugOut(( DEB_WARN,
                      "exception in APC error %#x, this %#x, pipe %#x\n",
                      ex.GetErrorCode(),
                      this,
                      GetPipe() ));

        // disconnect the pipe (and the query if it exists)

        _state = pipeStateNone;
        _requestQueue.RecycleRequestServerNoThrow( this );
    }
    END_CATCH;
} //DoAPC

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::APCRoutine, private, static
//
//  Synopsis:   This method is called when an i/o operation is completed.
//
//  Arguments:  [dwError]       - Win32 error code for i/o operation
//              [cbTransferred] - # of bytes read or written
//              [pOverlapped]   - Points to the overlapped for the i/o
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

void WINAPI CRequestServer::APCRoutine(
    DWORD        dwError,
    DWORD        cbTransferred,
    LPOVERLAPPED pOverlapped )
{

    // It would be a programming error to take an exception here, and it
    // has never been hit.  Leave the check in for checked builds.

#if CIDBG == 1
    TRY
    {
#endif

        // The request server was saved in the hEvent field, which the
        // Win32 doc says is a good place for a user's APC data

        CRequestServer &serv = * (CRequestServer *) (CPipeServer *)
                               ( pOverlapped->hEvent );
        serv.DoAPC( dwError, cbTransferred );

#if CIDBG == 1
    }
    CATCH( CException, e )
    {
        prxDebugOut(( DEB_ERROR, "exception in APCRoutine: 0x%x\n",
                      e.GetErrorCode() ));
        Win4Assert( !"caught an unexpected exception in an apc" );
    }
    END_CATCH;
#endif
} //APCRoutine

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::CancelAPCRoutine, private/static
//
//  Synopsis:   Called in an APC when a connection should be cancelled
//
//  Arguments:  [dwParam] - The request server
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

void WINAPI CRequestServer::CancelAPCRoutine(
    DWORD_PTR dwParam )
{
    TRY
    {
        CRequestServer * pServer = (CRequestServer *) dwParam;
        XInterface<CRequestServer> xServer( pServer );

        prxDebugOut(( DEB_ITRACE,
                      "Canceling server 0x%x io pipe 0x%x\n",
                      pServer, pServer->GetPipe() ));

        // Freeing a pending query will result in the request server
        // being cleaned up, since _fShutdown/BeingRemoved is TRUE.
        // Cancelling pending IO will cause the IO APC routine to be
        // called with an error completion status, which will clean up
        // the request server.

        if ( pipeStatePending == pServer->_state )
            pServer->FreeQuery();
        else if ( pipeStateNone != pServer->_state )
            pServer->CancelIO();
    }
    CATCH( CException, e )
    {
        prxDebugOut(( DEB_ERROR, "cancelapc caught 0x%x\n",
                      e.GetErrorCode() ));
        Win4Assert( !"CancelAPC caught an exception" );
    }
    END_CATCH
} //CancelAPCRoutine

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::Quiesce, private
//
//  Synopsis:   Called by the APC when a query with notifications quiesces
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

void CRequestServer::Quiesce()
{
    TRY
    {
        prxDebugOut(( DEB_ITRACE,
                      "Quiescing server 0x%x io pipe 0x%x\n",
                      this, GetPipe() ));

        Win4Assert( pipeStatePending == _state );

        // If we're shutting down or the server is disconnecting the client
        // for being idle for too long, abort now.

        if ( _requestQueue.IsShutdown() || IsBeingRemoved() )
            THROW( CException( STATUS_TOO_LATE ) );

        // the long-running operation completed, so do the write

        _xTempBuffer.Free();

        Win4Assert( 0 != _pQuery );
        _state = pipeStateWrite;

        //
        // If the first call to Quiesce is to tell us that the asynch
        // query execution failed, free the query.
        //

        if ( FAILED ( _scPendingStatus ) )
            FreeQuery();

        CProxyMessage &msg = * (CProxyMessage *) _Buffer();
        msg.SetStatus( _scPendingStatus );

        Write( (BYTE *) _Buffer(), _cbPendingWrite, APCRoutine );

        // Note that the state of these may have changed after the check above

        if ( IsBeingRemoved() )
            CancelIO();
    }
    CATCH( CException, ex )
    {
        prxDebugOut(( DEB_ITRACE,
                      "quiesce write error 0x%x, pipe 0x%x\n",
                      ex.GetErrorCode(),
                      GetPipe() ));

        _state = pipeStateNone;
        _requestQueue.RecycleRequestServerNoThrow( this );
    }
    END_CATCH;
} //Quiesce

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::QuiesceAPCRoutine, private/static
//
//  Synopsis:   Called in an APC when a query with notifications quiesces
//
//  Arguments:  [dwParam] - The request server
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

void WINAPI CRequestServer::QuiesceAPCRoutine(
    ULONG_PTR dwParam )
{
    CRequestServer & Server = * (CRequestServer *) dwParam;
    Server.Quiesce();
} //QuiesceAPCRoutine

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::QueryQuiesced, public
//
//  Synopsis:   Called when a synchronous query is quiesced, so the pending
//              request can be completed by the thread that created the query.
//
//  History:    16-Feb-97   dlee       Created.
//
//--------------------------------------------------------------------------

void CRequestServer::QueryQuiesced(
    BOOL  fSuccess,
    SCODE sc )
{
    // only complete the work if the query is truly quiesced

    if ( fSuccess || _requestQueue.IsShutdown() || IsBeingRemoved() )
    {
        Win4Assert( IsBeingRemoved() || 0 != _pQuery || _requestQueue.IsShutdown() );
        Win4Assert( pipeStatePending == _state );

        _scPendingStatus = sc;
        _requestQueue.DecrementPendingItems();

        QueueUserAPC( CRequestServer::QuiesceAPCRoutine,
                      GetWorkerThreadHandle(),
                      (ULONG_PTR) this );
    }
} //QueryQuiesced

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::CompleteNotification, public
//
//  Synopsis:   This is called by a query worker thread when a notification
//              should be delivered to the client.
//
//  Arguments:  [dwChangeType] - The notification
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

void CRequestServer::CompleteNotification(
    DWORD dwChangeType )
{
    // _pQuery can be 0 if the query is in the process of being deleted,
    // since _pQuery is set to 0 before it's actually deleted in FreeQuery(),
    // and queries that haven't quiesced yet always quiesce on destruction.

    if ( 0 != _pQuery )
    {
        CPMSendNotifyOut notify( dwChangeType );
        WriteSync( &notify, sizeof notify );
    }
} //CompleteNotification

//+-------------------------------------------------------------------------
//
//  Member:     CRequestServer::Cleanup, public
//
//  Synopsis:   Frees data and refcounts associated with the request server.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

void CRequestServer::Cleanup()
{
    FreeQuery();
    _xTempBuffer.Free();
    _fClientIsRemote = FALSE;
    _state = pipeStateNone;
    _cbPendingWrite = 0;
    _scPendingStatus = S_OK;

    _xClientMachine.Free();
    _xClientUser.Free();

    // Remove the refcount on the thread since it no longer has to process
    // APCs on behalf of this request server.

    if ( 0 != _pWorkThread )
    {
        _hWorkThread = INVALID_HANDLE_VALUE;
        _workQueue.Release( _pWorkThread );
        _pWorkThread = 0;
    }

    _xDbProperties.Free();

    if ( !_xDocStore.IsNull() )
    {
        XInterface<ICiCAdviseStatus> xAdviseStatus;
        SCODE sc = _xDocStore->QueryInterface( IID_ICiCAdviseStatus,
                                               xAdviseStatus.GetQIPointer() );

        // It would be a bug if this QI actually failed.

        if ( S_OK == sc )
            xAdviseStatus->DecrementPerfCounterValue( CI_PERF_RUNNING_QUERIES );

        _xDocStore.Free();
    }
} //Cleanup

//+-------------------------------------------------------------------------
//
//  Member:     CRequestQueue::CRequestQueue, public
//
//  Synopsis:   Constructs a request queue
//
//  Arguments:  [cMaxCachedServerItems]    -- max # of cached pipe objects
//              [cMaxSimultaneousRequests] -- max # of simultaneous pipes
//
//  History:    16-Sep-96   dlee       Created.
//              30-Mar-98   kitmanh    Initialized _fNetPause
//                                     and _fNetContinue to FALSE
//
//--------------------------------------------------------------------------

CRequestQueue::CRequestQueue(
    unsigned     cMaxCachedServerItems,
    unsigned     cMaxSimultaneousRequests,
    unsigned     cmsDefaultClientTimeout,
    BOOL         fMinimizeWorkingSet,
    unsigned     cMinClientIdleTime,
    unsigned     cmsStartupDelay,
    const GUID & guidDocStoreClient ) :
    _guidDocStoreClient( guidDocStoreClient ),
    _cMaxSimultaneousRequests( cMaxSimultaneousRequests ),
    _cmsDefaultClientTimeout( cmsDefaultClientTimeout ),
    _fMinimizeWorkingSet( fMinimizeWorkingSet ),
    _cMinClientIdleTime( cMinClientIdleTime ),
    _cmsStartupDelay( cmsStartupDelay ),
    _fDocStoresOpen( FALSE ),
    _fShutdown( FALSE ),
    _cBusyItems( 0 ),
    _cPendingItems( 0 ),
    _workQueue( 1, CWorkQueue::workQueueRequest ),
    _tableActiveServers( cMaxSimultaneousRequests ),
    _queueCachedServers( cMaxCachedServerItems ),
    _fNetPause( FALSE ),
    _fNetContinue( FALSE ),
    _fNetStop( FALSE )
{

#if CI_PIPE_TESTING

    _pTraceBefore = 0;
    _pTraceAfter = 0;
    _pTraceRead = 0;
    _hTraceDll = LoadLibraryEx( L"cipipetrace.dll", 0,
                                LOAD_WITH_ALTERED_SEARCH_PATH );

    if ( 0 != _hTraceDll )
    {
        _pTraceBefore = (PipeTraceServerBeforeCall)
                        GetProcAddress( _hTraceDll, "ServerBefore" );
        _pTraceAfter = (PipeTraceServerAfterCall)
                        GetProcAddress( _hTraceDll, "ServerAfter" );
        _pTraceRead = (PipeTraceServerReadCall)
                        GetProcAddress( _hTraceDll, "ServerRead" );
    }

#endif // CI_PIPE_TESTING

    _workQueue.Init();

    //
    // Read the worker queue registry settings in the SYSTEM context
    // and initialize the parameters.
    //
    ULONG cMaxActiveThreads, cMinIdleThreads;
    _workQueue.GetWorkQueueRegParams( cMaxActiveThreads,
                                      cMinIdleThreads );
    _workQueue.RefreshParams( cMaxActiveThreads, cMinIdleThreads );

    //
    // The security checks for the pipe are done in this order:
    //   The system account can create instances of this pipe.
    //   No-one can write DAC or OWNER, or create pipe instances.
    //   Everyone can read, write, and synchronize around this pipe.
    //
    // Actual query result and admin security checking is done when the
    // requests are made, and are based on the pipe impersonation.
    //
    // This data really is const, but the Win32 security APIs don't do const.
    //

    static SID sidLocalSystem = { SID_REVISION,
                                  1,
                                  SECURITY_NT_AUTHORITY,
                                  SECURITY_LOCAL_SYSTEM_RID };
    static SID sidWorld = { SID_REVISION,
                            1,
                            SECURITY_WORLD_SID_AUTHORITY,
                            SECURITY_WORLD_RID };

    // NTRAID#DB-NTBUG9-83834-2000/07/31-dlee No way to protect Indexing Service named pipes.
    // FILE_CREATE_PIPE_INSTANCE no longer works, so we can't include
    // it in the AceData.  There is no good way to secure the pipe.

    ACE_DATA AceData[] =
    {
        //{ ACCESS_ALLOWED_ACE_TYPE, 0, 0,
        //  FILE_CREATE_PIPE_INSTANCE,
        //  &sidLocalSystem },
        { ACCESS_DENIED_ACE_TYPE, 0, 0,
          WRITE_DAC | WRITE_OWNER /*| FILE_CREATE_PIPE_INSTANCE */,
          &sidWorld },
        { ACCESS_ALLOWED_ACE_TYPE, 0, 0,
          GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
          &sidWorld },
    };
    const ULONG cAces = sizeof AceData / sizeof ACE_DATA;

    CiCreateSecurityDescriptor( AceData,
                                cAces,
                                &sidLocalSystem,
                                &sidLocalSystem,
                                _xSecurityDescriptor );
} //CRequestQueue

//+-------------------------------------------------------------------------
//
//  Member:     CRequestQueue::RecycleRequestServerNoThrow, public
//
//  Synopsis:   A request server has become available.  Either delete it
//              or cache it for use later.  There is a transfer of ownership.
//
//  Arguments:  [pServer] - The request server to be reused or deleted
//
//  History:    16-Sep-96   dlee       Created.
//
//  Notes:      This method must not throw.
//
//--------------------------------------------------------------------------

void CRequestQueue::RecycleRequestServerNoThrow(
    CRequestServer * pServer )
{
    Win4Assert( pServer->NoOutstandingAPCs() );

    CServerItem item( pServer );

    BOOL fDisconnectOk = pServer->Disconnect();
    if ( !fDisconnectOk )
    {
        prxDebugOut(( DEB_WARN, "Disconnect of server 0x%x failed %d\n",
                      pServer, GetLastError() ));
    }

    pServer->Cleanup();

    // Only try to reuse the server if the refcount is 1 (it's available).
    // The only reason the refcount might not be 1 is if we took an exception
    // in DoIt(). Wake up the main thread if a request server is available.

    if ( pServer->IsAvailable() )
    {
        // The Add will fail if the cache is full or there is an admin
        // operation like shutdown going on.

        if ( _queueCachedServers.Add( item ) )
            _event.Set();
    }

    long cCurrent = InterlockedDecrement( &_cBusyItems );

    // If no request servers are to be cached and we've fallen just
    // under the ceiling on the # of items, set the event so the main
    // thread can wake up and create another request server.

    if ( ( !_fShutdown ) &&
         ( 0 == _queueCachedServers.MaxRequests() ) &&
         ( cCurrent == (long) ( _cMaxSimultaneousRequests - 1 ) ) )
        _event.Set();
} //RecycleRequestServerNoThrow

//+-------------------------------------------------------------------------
//
//  Member:     CRequestQueue::OpenAllDocStores, private
//
//  Synopsis:   Tells the DocStore admin to open all docstores if they
//              aren't open yet.
//
//  History:    19-Jun-98   dlee       Created.
//
//--------------------------------------------------------------------------

void CRequestQueue::OpenAllDocStores()
{
    if ( !_fDocStoresOpen )
    {
        XInterface<ICiCDocStoreLocator> xLocator( DocStoreLocator() );
        Win4Assert( !xLocator.IsNull() );

        // Ignore failures to open docstores -- the docstore is responsible

        xLocator->OpenAllDocStores();

        _fDocStoresOpen = TRUE;
    }
} //OpenAllDocStores

//+-------------------------------------------------------------------------
//
//  Member:     CRequestQueue::DocStoreLocator, public
//
//  Synopsis:   Retrieves the Doc Store Locator for the client
//
//  History:    19-Jun-98   dlee       Created.
//
//--------------------------------------------------------------------------

ICiCDocStoreLocator * CRequestQueue::DocStoreLocator()
{
    return g_svcDocStoreLocator.Get( _guidDocStoreClient );
} //DocStoreLocator

//+-------------------------------------------------------------------------
//
//  Member:     CRequestQueue::DoWork, public
//
//  Synopsis:   This is the main loop for the CI service.  It makes
//              available pipes to which clients can connect.  When the
//              _evtStateChange event is triggered, the method exits.
//
//  History:    16-Sep-96   dlee       Created.
//
//--------------------------------------------------------------------------

void CRequestQueue::DoWork()
{
    // Throw away all that startup code

    SetProcessWorkingSetSize( GetCurrentProcess(), ~0, ~0 );

    HANDLE ah[2];
    ah[0] = _evtStateChange.GetHandle();

    do
    {
        CServerItem item;

        TRY
        {
            // If a cached server item is available, use it.  Otherwise,
            // create a non-cached item if we are under the limit.

            prxDebugOut(( DEB_ITRACE, "cached/busy items: %d / %d\n",
                          _queueCachedServers.Count(), _cBusyItems ));

            if ( ( !_queueCachedServers.AcquireTop( item ) ) &&
                 ( _cBusyItems < (LONG) _cMaxSimultaneousRequests ) )
                item.Create( CI_SERVER_PIPE_NAME,
                             _cmsDefaultClientTimeout,
                             *this,
                             _workQueue );

            if ( 0 != item.Get() )
            {
                // make sure it doesn't get thrown away right away

                item.Get()->SetLastTouchedTime( GetTickCount() );
                InterlockedIncrement( & _cBusyItems );
                BOOL fConnected = item.Get()->Connect();

                // if it's not connected yet, we have to wait on an event

                if ( !fConnected )
                {
                    prxDebugOut(( DEB_ITRACE,
                                  "waiting for connect of pipe 0x%x\n",
                                  item.Get()->GetPipe() ));

                    ah[1] = item.Get()->GetEvent();
                    DWORD dwTimeout = _fMinimizeWorkingSet ? 30000 : INFINITE;

                    DWORD dw;
                    do
                    {
                        //
                        // If catalogs haven't been opened yet due to the
                        // startup delay and it's a good time, open them.
                        //

                        if ( !_fDocStoresOpen )
                        {
                            if ( GetTickCount() >= _cmsStartupDelay )
                            {
                                OpenAllDocStores();
                            }
                            else
                            {
                                dwTimeout = 0;
                                DWORD dwTC = GetTickCount();
                                if ( _cmsStartupDelay > dwTC )
                                    dwTimeout += ( _cmsStartupDelay - dwTC );
                            }
                        }

                        // event 0 -- shutdown
                        // event 1 -- a client connected

                        dw = WaitForMultipleObjectsEx( 2,
                                                       ah,
                                                       FALSE,
                                                       dwTimeout,
                                                       FALSE );

                        // if an event triggered, handle it

                        if ( WAIT_TIMEOUT != dw )
                            break;

                        // If there isn't anything else going on, trim our
                        // working set, and back off on the next time

                        if ( 1 == _cBusyItems )
                        {
                            dwTimeout = 120000; // 2 minutes
                            SetProcessWorkingSetSize( GetCurrentProcess(), ~0, ~0 );
                        }
                    } while ( TRUE );

                    Win4Assert( ( 0 == dw ) || ( 1 == dw ) );

                    if ( 0 == dw )
                    {
                        item.Free();
                        InterlockedDecrement( & _cBusyItems );
                        break; // out of the do loop
                    }
                    else if ( 1 != dw )
                        THROW( CException() );

                    item.Get()->ResetEvent();
                }

                //
                // Open the docstores now since the connection will not
                // force in a catalog if it's for administration.
                //

                OpenAllDocStores();

                _workQueue.Add( item.Get() );
                item.Acquire();

                //
                // Fix for 123796. If we have no more request servers left
                // we should attempt to free one from an idle client.
                //

                if ( _cBusyItems == (LONG) _cMaxSimultaneousRequests )
                    WrestReqServerFromIdleClient();
            }
            else
            {
                //
                // Wait for a request server to become available, either
                // in the cache or under the max ceiling.
                // event 0 -- shutdown
                // event 1 -- request server is available
                // timeout: look for an idle connection to destroy
                //

                prxDebugOut(( DEB_ITRACE, "wait for RequestServer\n" ));

                DWORD dwTimeout = ( _cBusyItems == (LONG) _cMaxSimultaneousRequests ) ?
                                  10000 : INFINITE;

                ah[1] = _event.GetHandle();
                DWORD dw = WaitForMultipleObjectsEx( 2,
                                                     ah,
                                                     FALSE,
                                                     dwTimeout,
                                                     FALSE );

                prxDebugOut(( DEB_ITRACE, "wfsoex wakeup: %d\n", dw ));

                Win4Assert(( 0 == dw || 1 == dw || WAIT_TIMEOUT == dw));

                if ( WAIT_TIMEOUT == dw )
                    WrestReqServerFromIdleClient();
                else if ( 0 == dw )
                    break; // out of the do loop
                else if ( 1 != dw )
                    THROW( CException() );
            }
        }
        CATCH( CException, ex )
        {
            prxDebugOut(( DEB_WARN, "DoWork exception error 0x%x\n",
                          ex.GetErrorCode() ));

            if ( 0 != item.Get() )
            {
                item.Free();
                InterlockedDecrement( & _cBusyItems );
            }
        }
        END_CATCH;
    } while ( TRUE );

    Shutdown();
} //DoWork

//+-------------------------------------------------------------------------
//
//  Member:     CRequestQueue::WrestReqServerFromIdleClient, private
//
//  Synopsis:   Looks for connection that have been idle for more than
//              a predetermined amt of time. Flags the worst offender
//              and kicks it off to pave way for a new connection.
//
//  History:    03-Feb-98   KrishnaN       Created.
//
//--------------------------------------------------------------------------

void CRequestQueue::WrestReqServerFromIdleClient()
{
    // look for the most idle connection that crossed the threshold

    //
    // We could be a little more efficient if we kick out the
    // first eligible idle client instead of looking for the most
    // idle one.  But this is infrequent enough and not a big enough
    // problem that it's worth fixing.
    //

    XInterface<CRequestServer> xIdle;

    {
        CRequestServer * pMostIdleServer = 0;
        DWORD dwCurrentTick = GetTickCount();
        DWORD dwMaxIdleTime = 0;

        CLock lock( _mutex );
    
        for ( ULONG i = 0; i < _tableActiveServers.Size(); i++ )
        {
            CRequestServer *pServer = _tableActiveServers.GetEntry( i );
    
            if ( !_tableActiveServers.IsFree( pServer ) &&
                 INVALID_HANDLE_VALUE != pServer->GetWorkerThreadHandle() )
            {
                DWORD dwLast = pServer->GetLastTouchedTime();
    
                // The windows tick count wraps around every 50 days.
                // Unsigned arithmetic accounts for that, so we don't have to.
    
                DWORD dwIdleTime = dwCurrentTick - dwLast;
    
                if ( dwIdleTime > _cMinClientIdleTime &&
                     dwIdleTime > dwMaxIdleTime )
                {
                    dwMaxIdleTime = dwIdleTime;
                    pMostIdleServer = pServer;
                }
            }
        }

        if ( 0 != pMostIdleServer )
        {
            pMostIdleServer->AddRef();
            xIdle.Set( pMostIdleServer );
        }
    }

    if ( !xIdle.IsNull() )
    {
        // Make sure this isn't in the cache or it won't get deleted

        _queueCachedServers.DisableAdditions();
        FreeCachedServers();

        // Disconnect this most-idle connection
    
        CEventSem evt;
        xIdle->BeingRemoved( &evt );
    
        // Attempt to cancel it if it's still associated with a worker thread

        HANDLE hThrd = xIdle->GetWorkerThreadHandle();
        if ( INVALID_HANDLE_VALUE != hThrd )
        {
            DWORD dwRet = QueueUserAPC( CRequestServer::CancelAPCRoutine,
                                        hThrd,
                                        (ULONG_PTR) xIdle.GetPointer() );
            Win4Assert( 0 != dwRet );

            xIdle.Acquire();
        }

        // Wait for the connection to completely go away

        xIdle.Free();
        evt.Wait();

        _queueCachedServers.EnableAdditions();

        prxDebugOut(( DEB_ITRACE, "Successfully disconnected an idle client.\n" ));
    }
} //WrestReqServerFromIdleClient

//+-------------------------------------------------------------------------
//
//  Member:     CRequestQueue::FreeCachedServers, private
//
//  Synopsis:   Removes all cached request servers
//
//  History:    01-July-99   dlee       Created from existing code
//
//--------------------------------------------------------------------------

void CRequestQueue::FreeCachedServers()
{
    CServerItem item;
    while ( _queueCachedServers.AcquireTop( item ) )
        item.Free();
} //FreeCachedServers

//+-------------------------------------------------------------------------
//
//  Member:     CRequestQueue::ShutdownActiveServers, private
//
//  Synopsis:   Cancels pending IO on each active request server.  It may
//              be that a given request server has no IO pending, and
//              that will be taken care of when the IO is requested.
//
//  Arguments:  [pDocStore] - pointer to a docstore
//              if pDocStore == NULL, shutdown all active servers
//
//  History:    19-May-97   dlee       Created.
//              24-Apr-98   kitmanh    Shut down active servers associated
//                                     with the specified docstore
//
//  Note:       Always addref to everyone in the first loop, since the
//              in the 2nd loop, the smart pointer xServer will release
//              the pServer when it's out of scope, whether the docstore
//              matches or not.
//
//--------------------------------------------------------------------------

void CRequestQueue::ShutdownActiveServers( ICiCDocStore * pDocStore )
{
    ciDebugOut(( DEB_ITRACE, "ShutdownActiveServers is called\n" ));

    // AddRef all outstanding request servers so they won't go away

    {
        CLock lock( _mutex );

        for ( ULONG i = 0; i < _tableActiveServers.Size(); i++ )
        {
            CRequestServer *pServer = _tableActiveServers.GetEntry( i );

            if ( !_tableActiveServers.IsFree( pServer ) )
                pServer->AddRef();
        }
    }

    // Make sure whatever request servers are freed aren't in the cache

    _queueCachedServers.DisableAdditions();
    FreeCachedServers();

    //
    // For each of the active request servers, file an APC so that the io
    // for that thread will be canceled by that thread, and so that
    // pending queries are cancelled.  No items will be added to
    // _tableActiveServers during this loop, but items may be deleted.
    //

    for ( ULONG i = 0; i < _tableActiveServers.Size(); i++ )
    {
        CRequestServer *pServer = _tableActiveServers.GetEntry( i );

        if ( !_tableActiveServers.IsFree( pServer ) )
        {
            XInterface<CRequestServer> xServer( pServer );

            // The thread handle will be invalid if no worker thread is yet
            // associated or the association has been terminated.  In either
            // case by definition there can be no outstanding APCs.

            // Note that the thread can't go away from under us since all
            // threads in the worker pool were addref'ed earlier

            // Disconnect it even if it has no docstore since it may be
            // processing a connect and be about to get a docstore.

            if ( ( 0 == pDocStore ) ||
                 ( pServer->GetDocStore() == 0 ) ||
                 ( pServer->GetDocStore() == pDocStore ) )
            {
                CEventSem evt;
                pServer->BeingRemoved( &evt );

                HANDLE hThread = pServer->GetWorkerThreadHandle();

                if ( INVALID_HANDLE_VALUE != hThread &&
                     QueueUserAPC( CRequestServer::CancelAPCRoutine,
                                   hThread,
                                   (ULONG_PTR) pServer ) )
                    xServer.Acquire();

                // Wait for the client to stop using the docstore

                xServer.Free();
                evt.Wait();
            }
        }
    }

    _queueCachedServers.EnableAdditions();
} //ShutdownActiveServers

//+-------------------------------------------------------------------------
//
//  Method:     CRequestQueue::Shutdown
//
//  Synopsis:   Cleans up after the request queue.  Can't throw.
//              handles both net stop and net pause
//
//  History:    16-Sep-96   dlee       Created.
//              30-Mar-98   kitmanh    Don't shutdown workqueue if we're
//                                     doing a net pause or a net continue
//              06-25-98    kitmanh    Update
//
//--------------------------------------------------------------------------

void CRequestQueue::Shutdown()
{
    prxDebugOut(( DEB_ITRACE, "Shutdown\n" ));

    // Make sure the worker threads don't go away

    _workQueue.AddRefWorkThreads();

    unsigned i = 0;
    SCWorkItem WorkItem;

    {
        CLock lock( _mutex );

        if ( _fNetStop )
            _fShutdown = TRUE;

        if ( _stateChangeArray.Count() > 0 )
            WorkItem = _stateChangeArray.Get(i);
        else
        {
            ciDebugOut(( DEB_ITRACE, "Shutdown:: eNetStop\n" ));

            // No workitems exist, must be net stop, pause or continue
            // create a stop work item with NULL docstore

            WorkItem.type = eNetStop;  // note: workitem.type is not really
                                       // important here

            ciDebugOut(( DEB_ITRACE, "WorkItem.type is %d\n", WorkItem.type ));
            WorkItem.pDocStore = 0;
            WorkItem.StoppedCat = 0;
        }
    }

    ciDebugOut(( DEB_ITRACE, "WorkItem.Count is %d\n", _stateChangeArray.Count() ));

    do
    {
        ciDebugOut(( DEB_ITRACE, "i is %d\n", i ));

        // now loop thru the workitem list and do the work

        i++;

        if ( 0 == WorkItem.StoppedCat )
            ShutdownActiveServers( WorkItem.pDocStore );

        {
            CLock lock( _mutex );

            if ( i < _stateChangeArray.Count() )
                WorkItem = _stateChangeArray.Get(i);
        }
    } while ( i < _stateChangeArray.Count() );

    if ( _fNetStop || _fNetPause || _fNetContinue )
    {
        if ( _stateChangeArray.Count() > 0 )
        {
            // No workitem has been created at the top of the function,
            // thus need to run ShutdownActiveServers here

            ShutdownActiveServers( 0 );
        }

        Win4Assert( !_queueCachedServers.Any() );
        Win4Assert( !_tableActiveServers.Any() );
        Win4Assert( 0 == _cBusyItems );
        Win4Assert( 0 == _cPendingItems );
    }

    _workQueue.ReleaseWorkThreads();

    if ( _fNetStop )
        _workQueue.Shutdown();
} //Shutdown

//+---------------------------------------------------------------------------
//
//  Function:   StartFWCiSvcWork
//
//  Synopsis:   Is the main server loop. Is called by the cisvc to receive
//              requests and demultiplex on them.
//
//  Arguments:  [lock] -- to be released when it's ok to call StopFWCiSvcWork
//
//  History:    1-30-97   srikants   Created
//              4-13-98   kitmanh    Moved the creation of CRequestQueue to
//                                   StartCisvcWork and passed the pointer
//                                   in from StartCisvcWork to initialize
//                                   g_pRequestQueue
//
//  Notes:      Must be called in the SYSTEM context without any impersonation.
//
//----------------------------------------------------------------------------

SCODE StartFWCiSvcWork( CReleasableLock & lock,
                        CRequestQueue * pRequestQueue,
                        CEventSem & evt )
{
    ciDebugOut(( DEB_ITRACE, "StartFWCiSvcWork is called\n" ));

    SCODE sc = S_OK;

    TRY
    {
        ciDebugOut(( DEB_ITRACE, "NetPaused == %d and NetContinued == %d\n",
                     pRequestQueue->IsNetPause(), pRequestQueue->IsNetContinue() ));

        g_pRequestQueue = pRequestQueue;
        evt.Set();
        lock.Release();

        ciDebugOut(( DEB_ITRACE, "evtPauseContinue is set\n" ));
        ciDebugOut(( DEB_ITRACE, "StartFWCisvcWork.. About to DoWork()\n" ));

        g_pRequestQueue->DoWork();

        ciDebugOut(( DEB_ITRACE, "StartFWCisvcWork.. Just fell out from DoWork\n" ));
        ciDebugOut(( DEB_ITRACE, "g_pRequestQueue->IsShutdown() is %d\n",
                     g_pRequestQueue->IsShutdown() ));

        // Check if a netpause or netcontinue is requested during DoWork()
        if ( g_pRequestQueue->IsShutdown() &&
             ! ( g_pRequestQueue->IsNetPause() || g_pRequestQueue->IsNetContinue() ) )
        {
            g_svcDocStoreLocator.Shutdown();

            //
            // Shutdown the Content Index work queue.
            //

            TheWorkQueue.Shutdown();
        }
    }
    CATCH( CException,e )
    {
        ciDebugOut(( DEB_ERROR,
                     "Terminating - DoCiSvcServerWork(). Error 0x%X\n",
                     e.GetErrorCode() ));

        sc = e.GetErrorCode();
    }
    END_CATCH

    ciDebugOut(( DEB_ITRACE, "Request lock for resetting g_pRequestQueue to 0\n" ));
    lock.Request();
    ciDebugOut(( DEB_ITRACE, "Got lock\n" ));
    g_pRequestQueue = 0;
    ciDebugOut(( DEB_ITRACE, "About to release lock\n" ));
    lock.Release();

    return sc;
} //StartFWCiSvcWork

//+---------------------------------------------------------------------------
//
//  Function:   StopFWCiSvcWork
//
//  Synopsis:   Stops the server work. It is the Shutdown method called by
//              cisvc to stop the work.
//
//  Arguments:  [type]  -- type of work to do
//              [wcVol] -- volume letter (for eLockVol only)
//
//  History:    1-30-97   srikants   Created
//              3-30-98   kitmanh    If we're doing a net pause, set
//                                   _fNetPause member in the CRequestQueue
//
//----------------------------------------------------------------------------

SCODE StopFWCiSvcWork( ECiSvcActionType type, 
                       CReleasableLock * pLock, 
                       CEventSem * pEvt,
                       WCHAR wcVol )
{
    ciDebugOut(( DEB_ITRACE, "StopFWCiSvcWork.. type == %d\n", type ));
    
    SCODE sc = S_OK;

    // for the case where a shutdown occurs while the service is restarting
    // for pausing, continuing, stopping a catalog

    if ( eNetStop == type && 0 == g_pRequestQueue ) 
    {
       //block until g_pRequestQueue is non-zero
       ciDebugOut(( DEB_ITRACE, "0 == g_pRequestQueue\n" ));
       ciDebugOut(( DEB_ITRACE, "StopFWCiSvcWork: Release the lock\n" ));
       ciDebugOut(( DEB_ITRACE, "Block on g_pevtPauseContinue for eNetStop\n" ));
       
       //this lock need to be released, so the lock can be grabbed by the
       //thread just done shutting down to finish restarting (calling 
       //StartFWCiSvcWork)
       pLock->Release();
       pEvt->Wait();
       ciDebugOut(( DEB_ITRACE, "Done waiting on g_pevtPauseContinue\n" ));
       pLock->Request();
       ciDebugOut(( DEB_ITRACE, "StopFWCiSvcWork requested the lock\n" ));
    }

    if ( 0 != g_pRequestQueue )
    {
        ciDebugOut(( DEB_ITRACE, "0 != g_pRequestQueue\n" ));
        ciDebugOut(( DEB_ITRACE, "g_pRequestQueue->IsShutdown() is %d\n", g_pRequestQueue->IsShutdown()  ));        
        
        // Ignore all events if shutdown is initialized
        if ( g_pRequestQueue->IsShutdown() )
            return STATUS_TOO_LATE;

        XInterface<ICiCDocStoreLocator> xLocator( g_pRequestQueue->DocStoreLocator() );
        Win4Assert( !xLocator.IsNull() );

        switch ( type )
        {
        case eNetPause:
            g_pRequestQueue->SetNetPause();
            break;

        case eNetContinue:
            g_pRequestQueue->SetNetContinue();
            break;

        case eNetStop:
            g_pRequestQueue->SetNetStop();
            break;

        case eCatRO:
        case eCatW:
        case eStopCat:
        case eNoQuery:
            break;

        case eLockVol:
            sc = xLocator->StopCatalogsOnVol( wcVol, g_pRequestQueue );
            ciDebugOut(( DEB_ITRACE, "After StopCatalogsOnVol\n" ));
            break;

        case eUnLockVol:
            sc = xLocator->StartCatalogsOnVol( wcVol, g_pRequestQueue );
            ciDebugOut(( DEB_ITRACE, "After StartCatalogsOnVol\n" ));
            break;

        default:
            Win4Assert( !"StopFWCiSvcWork is called with invalid ECisvcActionType" );
        }
        ciDebugOut(( DEB_ITRACE, "Time to WakeForStateChange; type = %d\n", type ));
        g_pRequestQueue->WakeForStateChange();
    }
    else
    {
        ciDebugOut(( DEB_ITRACE, "g_pRequestQueue->IsShutdown() is 0\n" ));        
    }

    return sc;
} //StopFWCiSvcWork