archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/inetsrv/query/cifrmwrk/indexing/dmnproxy.cxx

729 lines
20 KiB
Raw Permalink Blame History

//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 2000.
//
// File: dlproxy.cxx
//
// Contents: Proxy class which is used by the Daemon process
// to communicate with the CI process.
//
// History: 1-30-96 srikants Created
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <dmnproxy.hxx>
#include <memser.hxx>
#include <memdeser.hxx>
#include <sizeser.hxx>
#include <ciole.hxx>
//+---------------------------------------------------------------------------
//
// Member: CFilterStoreValueLayout::Init
//
// History: 1-30-96 srikants Created
//
//----------------------------------------------------------------------------
SCODE CFilterStoreValueLayout::Init( ULONG cbMax, WORKID widFake,
CFullPropSpec const & ps,
CStorageVariant const & var )
{
_sig5 = eFilterSig5;
_cbMax = cbMax - FIELD_OFFSET( CFilterStoreValueLayout, _ab );
_widFake = widFake;
CSizeSerStream sizeSer;
_fSuccess = FALSE;
ps.Marshall( sizeSer );
var.Marshall( sizeSer );
if ( sizeSer.Size() > _cbMax )
{
return STATUS_BUFFER_TOO_SMALL;
}
_cb = sizeSer.Size();
CMemSerStream ser( GetBuffer(), _cb );
ps.Marshall( ser );
var.Marshall( ser );
ser.AcqBuf();
return S_OK;
} //Init
//+---------------------------------------------------------------------------
//
// Member: CFilterStoreSecurityLayout::Init
//
// Synopsis: Initialize a buffer for the FilterStoreSecurity call
//
// Arguments: [cbMax] - size in bytes of [this]
// [widFake] - fake WORKID of file to apply security to
// [pSD] - pointer to a self-relative security descriptor
// [cbSD] - size in bytes of [pSD]
//
// History: 06 Feb 96 AlanW Created
//
//----------------------------------------------------------------------------
void CFilterStoreSecurityLayout::Init( ULONG cbMax,
WORKID widFake,
PSECURITY_DESCRIPTOR pSD,
ULONG cbSD )
{
_sig8 = (ULONG) eFilterSig8;
_cbMax = cbMax - FIELD_OFFSET( CFilterStoreSecurityLayout, _ab );
_widFake = widFake;
_fSuccess = FALSE;
_sdid = 0;
if ( cbSD > _cbMax )
{
THROW( CException( STATUS_BUFFER_TOO_SMALL ) );
}
_cb = cbSD;
RtlCopyMemory( &_ab, pSD, cbSD );
} //Init
//+---------------------------------------------------------------------------
//
// Member: CFilterStoreValueLayout::Get
//
// History: 1-30-96 srikants Created
//
//----------------------------------------------------------------------------
void CFilterStoreValueLayout::Get( WORKID & widFake, CFullPropSpec & ps,
CStorageVariant & var )
{
Win4Assert( IsValid() );
widFake = _widFake;
CMemDeSerStream deSer( GetBuffer(), _cb );
// It's a little slow to do this, but it doesn't dominate filter time.
CFullPropSpec psLocal( deSer );
CStorageVariant varLocal( deSer );
ps = psLocal;
var = varLocal;
} //Get
//+---------------------------------------------------------------------------
//
// Member: CFPSToPROPIDLayout::Init, public
//
// Synopsis: Initialize buffer for transfer (FPSToPROPID operation)
//
// Arguments: [cbMax] -- Size of buffer used in later marshalling
// [fps] -- Propspec to be marshalled
//
// History: 30-Dec-1997 KyleP Created
//
//----------------------------------------------------------------------------
void CFPSToPROPIDLayout::Init( ULONG cbMax, CFullPropSpec const & fps )
{
_sig6 = eFilterSig6;
_cbMax = cbMax - FIELD_OFFSET( CFPSToPROPIDLayout, _ab );
//
// Serialize the pidmap
//
CSizeSerStream sizeSer;
fps.Marshall( sizeSer );
if ( sizeSer.Size() > _cbMax )
{
THROW( CException( STATUS_BUFFER_TOO_SMALL ) );
}
Win4Assert( cbMax >= sizeof(PROPID) );
_cb = sizeSer.Size();
CMemSerStream ser( GetBuffer(), _cb );
fps.Marshall( ser );
} //Init
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::CGenericCiProxy
//
// Synopsis: Constructor for the proxy object used by Ci Daemon Process
// to communicate with ContentIndex (in a different process).
//
// History: 2-02-96 srikants Created
//
// Notes: All the above handles are of the objects created by the
// parent CI process with an "inheritable" attribute. The handles
// are communicated to the daemon process as command line args
// and used here.
//
//----------------------------------------------------------------------------
CGenericCiProxy::CGenericCiProxy(
CSharedNameGen & nameGen,
DWORD dwMemSize,
DWORD parentId )
:_mutex( nameGen.GetMutexName() ),
_sharedMem( nameGen.GetSharedMemName(), dwMemSize ),
_evtCi( 0, nameGen.GetCiEventName() ),
_evtDaemon( 0, nameGen.GetDaemonEventName() ),
_cHandles(2)
{
_pLayout = (CFilterSharedMemLayout *) _sharedMem.Map();
Win4Assert( _pLayout->IsValid() );
_aWait[iDaemon] = _evtDaemon.GetHandle();
HANDLE hParent = OpenProcess( SYNCHRONIZE, FALSE, parentId );
if ( 0 == hParent )
{
DWORD dwError = GetLastError();
ciDebugOut(( DEB_ERROR,
"Failed to get parent process handle. Error %d\n",
dwError ));
THROW( CException( HRESULT_FROM_WIN32(dwError) ) );
}
_aWait[iParent] = hParent;
_evtDaemon.Reset();
} //CGenericCiProxy
CGenericCiProxy::~CGenericCiProxy()
{
CloseHandle( _aWait[iParent] );
} //~CGenericCiProxy
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::_WaitForResponse
//
// Synopsis: Waits on the parent handle and the work done event. If the
// parent handle signals, then an exception will be thrown.
//
// History: 2-02-96 srikants Created
// 18-Dec-97 KLam Added call to CCIOle::FlushIdle when wait
// times out.
//----------------------------------------------------------------------------
void CGenericCiProxy::_WaitForResponse()
{
const DWORD dwWSTimeout = 20000;
DWORD dwTimeout = TRUE ? dwWSTimeout : INFINITE;
BOOL fFirstIdle = TRUE;
do
{
//
// Since ill-behaved filters and anything that uses mshtml creates
// windows, we have to process messages or broadcast messages
// will hang.
//
DWORD status = MsgWaitForMultipleObjects( _cHandles, // num handles
_aWait, // array of handles
FALSE, // wake up if any is set
dwTimeout, // Timeout
QS_ALLEVENTS );
DWORD iStatus = status - WAIT_OBJECT_0;
if ( iStatus == _cHandles )
{
// Deal with the window message for this thread.
MSG msg;
while ( PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}
else if ( WAIT_TIMEOUT == status )
{
// Throw away IFilters we haven't used in awhile
CCiOle::FlushIdle();
if ( fFirstIdle )
{
//
// Unload dlls like mshtml that get dragged in via thumbmail
// generation.
//
CoFreeUnusedLibraries();
// Throw ourselves out of the working set.
SetProcessWorkingSetSize( GetCurrentProcess(), -1, -1 );
dwTimeout = 2 * 60 * 1000;
fFirstIdle = FALSE;
}
}
else if ( WAIT_FAILED == status )
{
DWORD dwError = GetLastError();
ciDebugOut(( DEB_ERROR, "Daemon - WaitFailed. Error %d\n", dwError ));
THROW( CException() );
}
else if ( iParent == iStatus )
{
ciDebugOut(( DEB_ERROR, "Daemon - Parent process died abruptly\n" ));
THROW( CException( STATUS_NOT_FOUND ) );
}
else
{
Win4Assert( iDaemon == iStatus );
_evtDaemon.Reset();
break;
}
}
while( TRUE );
} //_WaitForResponse
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::FilterReady
//
// History: 1-30-96 srikants Created
//
//----------------------------------------------------------------------------
SCODE CGenericCiProxy::FilterReady( BYTE * docBuffer, ULONG & cb,
ULONG cMaxDocs )
{
ProbeForParentProcess();
Win4Assert( _pLayout );
{
CIPLock lock(_mutex);
CFilterReadyLayout & data = _pLayout->GetFilterReady();
data.Init( _pLayout->GetMaxVarDataSize(), cb, cMaxDocs );
_LokGiveWork( CFilterSharedMemLayout::eFilterReady );
}
_WaitForResponse();
SCODE status;
{
CIPLock lock(_mutex);
CFilterReadyLayout & data = _pLayout->GetFilterReady();
Win4Assert( data.IsValid() );
status = _pLayout->GetStatus();
if ( NT_SUCCESS(status) )
{
if ( data.GetCount() <= cb )
{
cb = data.GetCount();
RtlCopyMemory( docBuffer, data.GetBuffer(), cb );
}
else
{
// need more memory
cb = data.GetCount();
}
}
else
{
THROW( CException(status) );
}
}
return status;
}
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::FilterDataReady
//
// History: 1-30-96 srikants Created
//
//----------------------------------------------------------------------------
SCODE CGenericCiProxy::FilterDataReady( BYTE const * pEntryBuf, ULONG cb )
{
ProbeForParentProcess();
Win4Assert( _pLayout );
{
CIPLock lock(_mutex);
CFilterDataLayout & data = _pLayout->GetFilterDataReady();
data.Init( pEntryBuf, cb );
_LokGiveWork( CFilterSharedMemLayout::eFilterDataReady );
}
_WaitForResponse();
SCODE status;
{
CIPLock lock(_mutex);
CFilterDataLayout & data = _pLayout->GetFilterDataReady();
Win4Assert( data.IsValid() );
status = _pLayout->GetStatus();
}
return status;
}
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::FilterMore
//
// History: 1-30-96 srikants Created
//
//----------------------------------------------------------------------------
SCODE CGenericCiProxy::FilterMore( STATUS const * aStatus, ULONG cStatus )
{
ProbeForParentProcess();
Win4Assert( _pLayout );
{
CIPLock lock(_mutex);
CFilterMoreDoneLayout & data = _pLayout->GetFilterMore();
data.Init( aStatus, cStatus );
_LokGiveWork( CFilterSharedMemLayout::eFilterMore );
}
_WaitForResponse();
SCODE status;
{
CIPLock lock(_mutex);
CFilterMoreDoneLayout & data = _pLayout->GetFilterMore();
Win4Assert( data.IsValid() );
status = _pLayout->GetStatus();
}
return status;
}
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::FilterDone
//
// History: 1-30-96 srikants Created
//
//----------------------------------------------------------------------------
SCODE CGenericCiProxy::FilterDone( STATUS const * aStatus, ULONG cStatus )
{
ProbeForParentProcess();
Win4Assert( _pLayout );
{
CIPLock lock(_mutex);
CFilterMoreDoneLayout & data = _pLayout->GetFilterDone();
data.Init( aStatus, cStatus );
_LokGiveWork( CFilterSharedMemLayout::eFilterDone );
}
_WaitForResponse();
SCODE status;
{
CIPLock lock(_mutex);
CFilterMoreDoneLayout & data = _pLayout->GetFilterDone();
Win4Assert( data.IsValid() );
status = _pLayout->GetStatus();
}
return status;
}
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::FilterStoreValue
//
// History: 1-30-96 srikants Created
//
//----------------------------------------------------------------------------
SCODE CGenericCiProxy::FilterStoreValue( WORKID widFake,
CFullPropSpec const & ps,
CStorageVariant const & var,
BOOL & fCanStore )
{
ProbeForParentProcess();
Win4Assert( _pLayout );
{
CIPLock lock(_mutex);
CFilterStoreValueLayout & data = _pLayout->GetFilterStoreValueLayout();
SCODE sc = data.Init( _pLayout->GetMaxVarDataSize(), widFake, ps, var );
if ( S_OK != sc )
{
fCanStore = TRUE; // We are not sure if this property can be stored
// or not in the cache - err on the assumption that
// it can be stored.
return sc;
}
_LokGiveWork( CFilterSharedMemLayout::eFilterStoreValue );
}
_WaitForResponse();
SCODE status;
{
CIPLock lock(_mutex);
CFilterStoreValueLayout & data = _pLayout->GetFilterStoreValueLayout();
Win4Assert( data.IsValid() );
fCanStore = data.GetStatus();
status = _pLayout->GetStatus();
}
return status;
}
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::FilterStoreSecurity
//
// History: 06 Feb 96 AlanW Created
//
//----------------------------------------------------------------------------
SCODE CGenericCiProxy::FilterStoreSecurity( WORKID widFake,
PSECURITY_DESCRIPTOR pSD,
ULONG cbSD,
BOOL & fCanStore )
{
ProbeForParentProcess();
Win4Assert( _pLayout );
{
CIPLock lock(_mutex);
CFilterStoreSecurityLayout & data =
_pLayout->GetFilterStoreSecurityLayout();
data.Init( _pLayout->GetMaxVarDataSize(), widFake, pSD, cbSD );
_LokGiveWork( CFilterSharedMemLayout::eFilterStoreSecurity );
}
_WaitForResponse();
SCODE status;
{
CIPLock lock(_mutex);
CFilterStoreSecurityLayout & data = _pLayout->GetFilterStoreSecurityLayout();
Win4Assert( data.IsValid() );
fCanStore = data.GetStatus();
status = _pLayout->GetStatus();
}
return status;
} //FilterStoreSecurity
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::FPSToPROPID, public
//
// Synopsis: Converts FULLPROPSPEC to PROPID
//
// Arguments: [fps] -- FULLPROPSPEC representing property
// [pid] -- PROPID written here on success
//
// Returns: S_OK on success
//
// History: 29-Dec-1997 KyleP Created
//
//----------------------------------------------------------------------------
SCODE CGenericCiProxy::FPSToPROPID( CFullPropSpec const & fps, PROPID & pid )
{
ProbeForParentProcess();
Win4Assert( _pLayout );
{
CIPLock lock(_mutex);
CFPSToPROPIDLayout & data = _pLayout->GetFPSToPROPID();
data.Init( _pLayout->GetMaxVarDataSize(), fps );
_LokGiveWork( CFilterSharedMemLayout::eFPSToPROPID );
}
_WaitForResponse();
SCODE status = S_OK;
{
CIPLock lock(_mutex);
CFPSToPROPIDLayout & data = _pLayout->GetFPSToPROPID();
status = _pLayout->GetStatus();
if ( SUCCEEDED(status) )
{
ULONG cb = data.GetCount();
Win4Assert( data.IsValid() );
pid = data.GetPROPID();
}
else
{
Win4Assert( STATUS_BUFFER_TOO_SMALL != status );
THROW( CException(status) );
}
}
return status;
} //PidMapToPidRemap
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::GetStartupData
//
// Synopsis: Retrieves the startup data from the main process. This will
// be handed over to the client.
//
// History: 12-19-96 srikants Created
//
//----------------------------------------------------------------------------
BYTE const * CGenericCiProxy::GetStartupData( GUID & clsidClientMgr,
ULONG & cbData )
{
ProbeForParentProcess();
Win4Assert( _pLayout );
{
CIPLock lock(_mutex);
CFilterStartupDataLayout & data = _pLayout->GetStartupData();
data.Init();
_LokGiveWork( CFilterSharedMemLayout::eFilterStartupData );
}
_WaitForResponse();
SCODE status;
BYTE const * pbData = 0;
{
CIPLock lock(_mutex);
CFilterStartupDataLayout & data = _pLayout->GetStartupData();
Win4Assert( data.IsValid() );
status = _pLayout->GetStatus();
if ( S_OK == status )
{
pbData = data.GetData( cbData );
clsidClientMgr = data.GetClientMgrCLSID();
}
}
return pbData;
}
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::SetPriority
//
// Synopsis: Sets the priority class of the process and this thread's priority
// based upon the values passed in.
//
// History: 12-19-96 srikants Created
//
//----------------------------------------------------------------------------
void CGenericCiProxy::SetPriority( ULONG priClass, ULONG priThread )
{
SetPriorityClass( GetCurrentProcess(), priClass );
SetThreadPriority( GetCurrentThread(), priThread );
}
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::GetEntryBuffer
//
// Synopsis: Returns the shared memory buffer that will be used by
// the daemon to pass the "FilterDataReady".
// This is an optimization to avoid data copying (128K) for
// every call to "FilterDataReady".
//
// Arguments: [cb] - On output, will have the size of the buffer.
//
// History: 2-21-96 srikants Created
//
//----------------------------------------------------------------------------
BYTE * CGenericCiProxy::GetEntryBuffer( ULONG & cbMax )
{
CIPLock lock(_mutex);
CFilterDataLayout & data = _pLayout->GetFilterDataReady();
cbMax = data.GetMaxSize();
return data.GetBuffer();
} //GetEntryBuffer
//+---------------------------------------------------------------------------
//
// Member: CGenericCiProxy::ProbeForParentProcess
//
// Synopsis: Checks if the parent process (cisvc.exe) is still alive
//
// History: 12-Aug-97 SitaramR Created
//
//----------------------------------------------------------------------------
void CGenericCiProxy::ProbeForParentProcess()
{
DWORD status = WaitForSingleObject( _aWait[iParent], 0 );
if ( WAIT_FAILED == status )
{
DWORD dwError = GetLastError();
ciDebugOut(( DEB_ERROR, "DLDaemon - WaitFailed. Error 0x%X\n", dwError ));
THROW( CException( HRESULT_FROM_WIN32( dwError ) ) );
}
if ( WAIT_TIMEOUT == status )
return;
else
{
ciDebugOut(( DEB_ERROR, "DLDaemon - Parent process died abruptly\n" ));
THROW( CException(FDAEMON_E_FATALERROR ) );
}
}