mirror of https://github.com/tongzx/nt5src
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.
1814 lines
40 KiB
1814 lines
40 KiB
/*---------------------------------------------------------------------*
|
|
|
|
Copyright (c) 1995-1996 Microsoft Corporation
|
|
|
|
Module Name :
|
|
|
|
wamxinfo.cxx (formerly seinfo.cxx)
|
|
|
|
Abstract:
|
|
|
|
Implementation of WAM_EXEC_INFO object.
|
|
|
|
Authors:
|
|
|
|
Murali R. Krishnan ( MuraliK ) 18-July-1996
|
|
David Kaplan ( DaveK ) 10-July-1997
|
|
|
|
Environment:
|
|
|
|
User Mode - Win32
|
|
|
|
Project:
|
|
|
|
Wam DLL
|
|
--*/
|
|
|
|
|
|
/************************************************************
|
|
* Include Headers
|
|
************************************************************/
|
|
# include <isapip.hxx>
|
|
# include "wamxinfo.hxx"
|
|
# include "WReqCore.hxx"
|
|
# include "setable.hxx"
|
|
# include "gip.h"
|
|
# include "WamW3.hxx"
|
|
|
|
// MIDL-generated
|
|
# include "iwr.h"
|
|
|
|
// allocation cache for the WAM_EXEC_INFO objects
|
|
ALLOC_CACHE_HANDLER * WAM_EXEC_INFO::sm_pachExecInfo;
|
|
# define WAM_EXEC_INFO_CACHE_THRESHOLD (400) // UNDONE: Empirically vary
|
|
|
|
#if DBG
|
|
PTRACE_LOG WAM_EXEC_INFO::sm_pDbgRefTraceLog;
|
|
#endif
|
|
|
|
SV_CACHE_MAP * WAM_EXEC_INFO::sm_pSVCacheMap = NULL;
|
|
|
|
//
|
|
// Ref count trace log sizes for per-request log and global log
|
|
// (used for debugging ref count problems)
|
|
//
|
|
// NOTE these are large because WAM_EXEC_INFO can have a lot of
|
|
// ref/deref activity
|
|
//
|
|
|
|
#define C_REFTRACES_PER_REQUEST 128
|
|
#define C_REFTRACES_GLOBAL 4096
|
|
|
|
|
|
/************************************************************
|
|
* Functions
|
|
************************************************************/
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::WAM_EXEC_INFO
|
|
Constructor
|
|
|
|
Arguments:
|
|
pWam - ptr to wam
|
|
|
|
Returns:
|
|
Nothing
|
|
|
|
*/
|
|
WAM_EXEC_INFO::WAM_EXEC_INFO(
|
|
PWAM pWam
|
|
)
|
|
{
|
|
_cRefs = 1;
|
|
m_pWam= pWam;
|
|
_psExtension = NULL;
|
|
_FirstThread = FT_NULL;
|
|
m_dwSignature = WAM_EXEC_INFO_SIGNATURE;
|
|
|
|
DBG_ASSERT( m_pWam );
|
|
|
|
m_fInProcess = m_pWam->FInProcess();
|
|
m_fInPool = m_pWam->FInPool();
|
|
|
|
m_fDisconnected = FALSE;
|
|
|
|
InitializeListHead( &_ListEntry);
|
|
|
|
IF_DEBUG( WAM_EXEC ) {
|
|
|
|
DBGPRINTF(( DBG_CONTEXT, "WAM_EXEC_INFO(%p) Ctor : %d -> %d\n",
|
|
this, _cRefs-1, _cRefs ));
|
|
|
|
}
|
|
|
|
#if DBG
|
|
// create ref trace log
|
|
m_pDbgRefTraceLog = CreateRefTraceLog( C_REFTRACES_PER_REQUEST, 0 );
|
|
#endif
|
|
|
|
} // WAM_EXEC_INFO::WAM_EXEC_INFO
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::~WAM_EXEC_INFO
|
|
Destructor
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Returns:
|
|
Nothing
|
|
|
|
*/
|
|
WAM_EXEC_INFO::~WAM_EXEC_INFO(
|
|
)
|
|
{
|
|
|
|
IF_DEBUG( WAM_EXEC ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "WAM_EXEC_INFO(%p) Dtor \n"
|
|
, this
|
|
));
|
|
}
|
|
|
|
m_dwSignature = WAM_EXEC_INFO_SIGNATURE_FREE;
|
|
|
|
#if DBG
|
|
// write thread id into second dword of this object's memory
|
|
// (alloc cache stores next-ptr in 1st dword, so we use 2nd slot)
|
|
*( (DWORD *)this + 1 ) = GetCurrentThreadId();
|
|
|
|
// destroy ref trace log
|
|
if( m_pDbgRefTraceLog != NULL ) {
|
|
DestroyRefTraceLog( m_pDbgRefTraceLog );
|
|
}
|
|
|
|
#endif
|
|
|
|
} // WAM_EXEC_INFO::~WAM_EXEC_INFO
|
|
|
|
|
|
|
|
#define WRC_F _WamReqCore.m_WamReqCoreFixed
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::InitWamExecInfo
|
|
Initializes the wamexec info
|
|
|
|
Arguments:
|
|
cbWrcStrings - number of bytes required by strings buffer
|
|
dwChildFlags - flags for child execution (HSE_EXEC_???)
|
|
|
|
Returns:
|
|
HRESULT
|
|
|
|
*/
|
|
HRESULT
|
|
WAM_EXEC_INFO::InitWamExecInfo
|
|
(
|
|
IWamRequest * pIWamRequest,
|
|
DWORD cbWrcStrings,
|
|
OOP_CORE_STATE * pOopCoreState
|
|
)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
|
|
DBG_ASSERT( pIWamRequest );
|
|
|
|
IF_DEBUG( WAM_EXEC ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "WAM_EXEC_INFO(%p)::InitWamExecInfo "
|
|
"pIWamRequest(%p) "
|
|
"cbWrcStrings(%d) "
|
|
"m_fInProcess(%d) "
|
|
"\n"
|
|
, this
|
|
, pIWamRequest
|
|
, cbWrcStrings
|
|
, m_fInProcess
|
|
));
|
|
|
|
}
|
|
|
|
|
|
if ( FAILED( hr = InitWamExecBase( pIWamRequest ) ) ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "InitWamExecBase failed "
|
|
"hr(%x) "
|
|
"\n"
|
|
, hr
|
|
));
|
|
|
|
goto LExit;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Init wamreq core - contains stuff needed by ecb
|
|
//
|
|
|
|
if ( FAILED( hr = _WamReqCore.InitWamReqCore(
|
|
cbWrcStrings
|
|
, pIWamRequest
|
|
, pOopCoreState
|
|
, m_fInProcess
|
|
) ) )
|
|
{
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "InitWamReqCore failed "
|
|
"hr(%x) "
|
|
"\n"
|
|
, hr
|
|
));
|
|
|
|
goto LExit;
|
|
}
|
|
|
|
//
|
|
// If this is a child ISA, set appropriate flags
|
|
//
|
|
|
|
_dwChildExecFlags = _WamReqCore.m_WamReqCoreFixed.m_dwChildExecFlags;
|
|
|
|
|
|
IF_DEBUG( WAM_EXEC ) {
|
|
|
|
Print();
|
|
}
|
|
|
|
//
|
|
// begin Reset_Code
|
|
// [the following code was formerly WAM_EXEC_INFO::Reset]
|
|
//
|
|
|
|
_dwFlags = SE_PRIV_FLAG_IN_CALLBACK;
|
|
_AsyncIoInfo._pfnHseIO = NULL;
|
|
_AsyncIoInfo._pvHseIOContext = NULL;
|
|
_AsyncIoInfo._dwOutstandingIO = ASYNC_IO_TYPE_NONE;
|
|
_AsyncIoInfo._cbLastAsyncIO = 0;
|
|
_AsyncIoInfo._pvAsyncReadBuffer = NULL;
|
|
|
|
// we are either inproc-valid or oop-valid, not both
|
|
DBG_ASSERT(
|
|
( m_fInProcess && AssertInpValid() && !AssertOopValid() )
|
|
||
|
|
(!m_fInProcess && !AssertInpValid() && AssertOopValid() )
|
|
);
|
|
|
|
ecb.cbSize = sizeof(EXTENSION_CONTROL_BLOCK);
|
|
|
|
//
|
|
// dwVersion is hardcoded because the iisext.h file that defines
|
|
// HSE_VERSION_MAJOR and HSE_VERSION_MINOR is shipped as a part of
|
|
// the SDK, and the compiler variable that distinguishes 5.1 from
|
|
// 6.0 builds is internal. The #if directive wouldn't make sense
|
|
// in a file exposed to the public.
|
|
//
|
|
|
|
ecb.dwVersion = MAKELONG( 1, 5 );
|
|
|
|
// keep in sync with HT_OK in basereq.hxx
|
|
#define HT_OK 200
|
|
|
|
ecb.dwHttpStatusCode = HT_OK;
|
|
ecb.lpszLogData[0] = '\0';
|
|
|
|
//
|
|
// note that function pointers are set in isplocal.cxx before
|
|
// executing the request using ECB
|
|
//
|
|
|
|
ecb.ConnID = (HCONN) this;
|
|
ecb.lpszMethod = _WamReqCore.GetSz( WRC_I_METHOD );
|
|
ecb.lpszQueryString = _WamReqCore.GetSz( WRC_I_QUERY );
|
|
ecb.lpszPathInfo = _WamReqCore.GetSz( WRC_I_PATHINFO );
|
|
ecb.lpszContentType = _WamReqCore.GetSz( WRC_I_CONTENTTYPE );
|
|
ecb.lpszPathTranslated = _WamReqCore.GetSz( WRC_I_PATHTRANS );
|
|
ecb.cbTotalBytes = WRC_F.m_cbClientContent;
|
|
|
|
//
|
|
// Clients can send more bytes then are indicated in their
|
|
// Content-Length header. Adjust byte counts so they match
|
|
//
|
|
|
|
ecb.cbAvailable = (WRC_F.m_cbEntityBody > WRC_F.m_cbClientContent)
|
|
? WRC_F.m_cbClientContent
|
|
: WRC_F.m_cbEntityBody
|
|
;
|
|
|
|
ecb.lpbData = _WamReqCore.m_pbEntityBody;
|
|
|
|
//
|
|
// end Reset_Code
|
|
// [the preceding code was formerly WAM_EXEC_INFO::Reset]
|
|
//
|
|
|
|
|
|
LExit:
|
|
return hr;
|
|
|
|
} // WAM_EXEC_INFO::InitWamExecInfo
|
|
|
|
HRESULT
|
|
WAM_EXEC_INFO::GetInfoForName
|
|
(
|
|
IWamRequest * pIWamRequest,
|
|
const unsigned char * szVarName,
|
|
unsigned char * pchBuffer,
|
|
DWORD cchBuffer,
|
|
DWORD * pcchRequired
|
|
)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
BOOL fCacheHit = FALSE;
|
|
|
|
if( !m_fInProcess )
|
|
{
|
|
// Lookup server variable in the cache.
|
|
|
|
DBG_ASSERT( sm_pSVCacheMap );
|
|
|
|
LPCSTR szTempVarName = (LPSTR)szVarName;
|
|
DWORD dwOrdinal;
|
|
|
|
if( sm_pSVCacheMap->FindOrdinal( szTempVarName,
|
|
strlen(szTempVarName),
|
|
&dwOrdinal
|
|
) )
|
|
{
|
|
DBG_ASSERT( dwOrdinal < SVID_COUNT );
|
|
|
|
DWORD dwOffset = _WamReqCore.m_rgSVOffsets[dwOrdinal];
|
|
|
|
if( dwOffset != SV_DATA_INVALID_OFFSET )
|
|
{
|
|
DBG_ASSERT( _WamReqCore.m_pbSVData );
|
|
|
|
// We have a value cached.
|
|
fCacheHit = TRUE;
|
|
|
|
if( SUCCEEDED(dwOffset) )
|
|
{
|
|
// The offset is an actual offset into our data buffer iff
|
|
// the high bit isn't set.
|
|
LPSTR szValue = (LPSTR)(_WamReqCore.m_pbSVData + dwOffset);
|
|
DWORD cchValue = strlen( szValue ) + 1;
|
|
|
|
if( cchValue > cchBuffer || pchBuffer == NULL )
|
|
{
|
|
// Insufficient buffer
|
|
SetLastError( ERROR_INSUFFICIENT_BUFFER );
|
|
hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
|
|
}
|
|
else
|
|
{
|
|
CopyMemory( pchBuffer, szValue, cchValue );
|
|
}
|
|
*pcchRequired = cchValue;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// In the event that HTTP_REQUEST::GetInfoForName
|
|
// failed because of missing data the error code
|
|
// returned is stored in dwOffset.
|
|
//
|
|
DBG_ASSERT( FAILED(dwOffset) );
|
|
|
|
// Rely on BoolFromHresult to do the SetLastError...
|
|
hr = dwOffset;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !fCacheHit )
|
|
{
|
|
// Moved from isplocal.cxx - GetServerVariable()
|
|
|
|
HANDLE hCurrentUser = NULL;
|
|
|
|
if( !m_fInProcess )
|
|
{
|
|
hCurrentUser = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
DoRevertHack( &hCurrentUser );
|
|
|
|
hr = pIWamRequest->GetInfoForName( szVarName,
|
|
pchBuffer,
|
|
cchBuffer,
|
|
pcchRequired
|
|
);
|
|
|
|
UndoRevertHack( &hCurrentUser );
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::TransmitFile
|
|
|
|
This function transmits the file contents as specified in the
|
|
pHseTfi. It also sets up the call back functions for
|
|
processing the request when it completes.
|
|
|
|
Arguments:
|
|
pHseTfi - pointer to Server Extension Transmit File information
|
|
|
|
Returns:
|
|
TRUE on success and FALSE on failure
|
|
|
|
*/
|
|
BOOL
|
|
WAM_EXEC_INFO::TransmitFile(
|
|
IN LPHSE_TF_INFO pHseTfi
|
|
)
|
|
{
|
|
|
|
BOOL fReturn = FALSE;
|
|
IWamRequest * pIWamRequest = NULL;
|
|
|
|
|
|
IF_DEBUG( WAM_ISA_CALLS ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "WAM_EXEC_INFO(%p)::TransmitFile "
|
|
"pHseTfi(%p) "
|
|
"\n"
|
|
, this
|
|
, pHseTfi
|
|
));
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// It is unlikely that ISAPI applications will post
|
|
// multiple outstanding IOs. However we have the state
|
|
// pAsyncIoInfo->_fOutstandingIO to secure ourselves against this.
|
|
// I have not used any critical sections to protect against
|
|
// multiple threads for performance reasons.
|
|
// Today we support only Async IO transfers
|
|
//
|
|
|
|
if ( pHseTfi == NULL
|
|
|| _AsyncIoInfo._dwOutstandingIO
|
|
|| ((pHseTfi->dwFlags & HSE_IO_ASYNC) == 0) ) {
|
|
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return ( FALSE );
|
|
}
|
|
|
|
|
|
if ( pHseTfi->hFile == INVALID_HANDLE_VALUE) {
|
|
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return ( FALSE );
|
|
}
|
|
|
|
//
|
|
// If there is no file being transfered, then having a non-zero
|
|
// offset or BytesToWrite will be bad.
|
|
//
|
|
if( (pHseTfi->hFile == NULL) &&
|
|
(pHseTfi->BytesToWrite != 0 || pHseTfi->Offset != 0) )
|
|
{
|
|
// Consider: We could just set these to 0, ie ignore them
|
|
// if the hFile is NULL.
|
|
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return ( FALSE );
|
|
}
|
|
|
|
|
|
//
|
|
// Record the number of bytes to complete the IO with
|
|
//
|
|
|
|
if ( pHseTfi->BytesToWrite > 0 ) {
|
|
|
|
DBG_ASSERT( pHseTfi->hFile );
|
|
|
|
_AsyncIoInfo._cbLastAsyncIO = pHseTfi->BytesToWrite;
|
|
|
|
} else {
|
|
|
|
//
|
|
// If a zero-size was passed in, get size from file
|
|
//
|
|
|
|
if( pHseTfi->hFile )
|
|
{
|
|
|
|
BY_HANDLE_FILE_INFORMATION hfi;
|
|
|
|
if ( !GetFileInformationByHandle( pHseTfi->hFile, &hfi )) {
|
|
|
|
// CONSIDER something besides ERROR_INVALID_HANDLE???
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return ( FALSE );
|
|
}
|
|
|
|
if ( hfi.nFileSizeHigh ) {
|
|
|
|
SetLastError( ERROR_NOT_SUPPORTED );
|
|
return ( FALSE );
|
|
}
|
|
|
|
_AsyncIoInfo._cbLastAsyncIO = hfi.nFileSizeLow;
|
|
}
|
|
else
|
|
{
|
|
// We want to allow TransmitFile without a file handle
|
|
_AsyncIoInfo._cbLastAsyncIO = 0;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Set the callback function. Override old one
|
|
//
|
|
|
|
if ( pHseTfi->pfnHseIO != NULL) {
|
|
|
|
_AsyncIoInfo._pfnHseIO = pHseTfi->pfnHseIO;
|
|
}
|
|
|
|
|
|
if ( NULL == _AsyncIoInfo._pfnHseIO) {
|
|
|
|
// No callback specified. return error
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return ( FALSE );
|
|
}
|
|
|
|
|
|
if ( pHseTfi->pContext != NULL) {
|
|
|
|
// Override the old context
|
|
_AsyncIoInfo._pvHseIOContext = pHseTfi->pContext;
|
|
}
|
|
|
|
|
|
if ( FAILED( GetIWamRequest( &pIWamRequest ) ) ) {
|
|
|
|
// CONSIDER something besides ERROR_INVALID_FUNCTION???
|
|
SetLastError( ERROR_INVALID_FUNCTION );
|
|
return FALSE;
|
|
}
|
|
|
|
DBG_ASSERT( pIWamRequest );
|
|
|
|
|
|
//
|
|
// Finally, call appropriate transmit-file version
|
|
// based on in-proc vs. oop.
|
|
//
|
|
// First, we init async i/o processing. In normal (success) case,
|
|
// i/o completion thread will call balancing uninit. In failure
|
|
// case, we call it below.
|
|
//
|
|
|
|
InitAsyncIO( ASYNC_IO_TYPE_WRITE );
|
|
|
|
|
|
if ( m_fInProcess ) {
|
|
|
|
//
|
|
// call in-proc interface (fastest)
|
|
//
|
|
|
|
fReturn = BoolFromHresult(
|
|
pIWamRequest->TransmitFileInProc(
|
|
#ifdef _WIN64
|
|
(UINT64) this
|
|
#else
|
|
(ULONG_PTR) this
|
|
#endif
|
|
, (unsigned char *) pHseTfi
|
|
) );
|
|
|
|
} else {
|
|
|
|
//
|
|
// call out-of-proc interface
|
|
//
|
|
|
|
unsigned char * pszStatusCode = NULL;
|
|
DWORD cbStatusCode = 0;
|
|
|
|
//
|
|
// if send-headers flag is set, get status code from struct
|
|
//
|
|
|
|
if ( pHseTfi->dwFlags & HSE_IO_SEND_HEADERS ) {
|
|
|
|
DBG_ASSERT( pHseTfi->pszStatusCode );
|
|
|
|
pszStatusCode = (unsigned char *) pHseTfi->pszStatusCode;
|
|
cbStatusCode = lstrlen( pHseTfi->pszStatusCode ) + 1;
|
|
}
|
|
|
|
HANDLE hCurrentUser = INVALID_HANDLE_VALUE;
|
|
DoRevertHack( &hCurrentUser );
|
|
|
|
fReturn = BoolFromHresult(
|
|
pIWamRequest->TransmitFileOutProc(
|
|
#ifdef _WIN64
|
|
(UINT64) this
|
|
, (UINT64) pHseTfi->hFile
|
|
#else
|
|
(ULONG_PTR) this
|
|
, (ULONG_PTR) pHseTfi->hFile
|
|
#endif
|
|
, pszStatusCode
|
|
, cbStatusCode
|
|
, pHseTfi->BytesToWrite
|
|
, pHseTfi->Offset
|
|
, (unsigned char *) pHseTfi->pHead
|
|
, pHseTfi->HeadLength
|
|
, (unsigned char *) pHseTfi->pTail
|
|
, pHseTfi->TailLength
|
|
, pHseTfi->dwFlags
|
|
) );
|
|
|
|
UndoRevertHack( &hCurrentUser );
|
|
|
|
}
|
|
|
|
|
|
if ( !fReturn ) {
|
|
|
|
UninitAsyncIO();
|
|
}
|
|
|
|
|
|
ReleaseIWamRequest( pIWamRequest );
|
|
|
|
|
|
return fReturn;
|
|
|
|
} // WAM_EXEC_INFO::TransmitFile()
|
|
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::AsyncReadClient
|
|
|
|
Description:
|
|
|
|
This function performs an async read of client (browser) data
|
|
on behalf of the ISA
|
|
|
|
Arguments:
|
|
|
|
pvBuff - Data buffer to read into
|
|
pcbToRead - Number of bytes to read, set to number of bytes read if
|
|
request is not Async
|
|
dwFlags - Receive flags
|
|
|
|
Notes:
|
|
|
|
The initial design for AsyncRead was inadequate when the isapi is
|
|
running out of process. The problem was that the data buffer was
|
|
marshalled over to inetinfo and back during the AsyncRead call.
|
|
Since the completion will happen on another thread the ISAPI could
|
|
get the completion before the data was completely marshalled back
|
|
or the address in inetinfo could be invalidated before the read was
|
|
complete. The solution is to add a separate path for oop async reads
|
|
and marshall the data on the io completion and copy it into the
|
|
client's buffer then.
|
|
|
|
Returns:
|
|
|
|
TRUE on success and FALSE on failure
|
|
|
|
*/
|
|
BOOL
|
|
WAM_EXEC_INFO::AsyncReadClient(
|
|
IN OUT PVOID pvBuff
|
|
, IN OUT DWORD *pcbToRead
|
|
, IN DWORD dwFlags
|
|
)
|
|
{
|
|
BOOL fReturn = FALSE;
|
|
|
|
DBG_ASSERT( pvBuff );
|
|
DBG_ASSERT( pcbToRead );
|
|
|
|
IF_DEBUG( WAM_ISA_CALLS ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "WAM_EXEC_INFO(%p)::AsyncReadClient\t"
|
|
"Bytes to read = %d\n"
|
|
, this
|
|
, *pcbToRead
|
|
));
|
|
}
|
|
|
|
|
|
DBG_ASSERT( dwFlags & HSE_IO_ASYNC );
|
|
|
|
//
|
|
// It is unlikely that ISAPI applications will post
|
|
// multiple outstanding IOs. However we have the state
|
|
// _AsyncIoInfo._dwOutstandingIO to secure ourselves against such cases.
|
|
// I have not used any critical sections to protect against
|
|
// multiple threads for performance reasons.
|
|
// Today we support only Async IO transfers
|
|
//
|
|
|
|
|
|
if ( _AsyncIoInfo._dwOutstandingIO ||
|
|
((dwFlags & HSE_IO_ASYNC) == 0) ) {
|
|
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return ( FALSE);
|
|
}
|
|
|
|
if ( NULL == _AsyncIoInfo._pfnHseIO) {
|
|
|
|
// No callback specified. return error
|
|
SetLastError( ERROR_INVALID_PARAMETER);
|
|
return (FALSE);
|
|
}
|
|
|
|
//
|
|
// Setup stage for and execute AsyncReadClient operation
|
|
//
|
|
|
|
//
|
|
// If callback function exists and flags indicate Async IO, do it.
|
|
// Also there should be no outstanding Async IO operation.
|
|
//
|
|
|
|
if ( dwFlags & HSE_IO_ASYNC) {
|
|
|
|
//
|
|
// 1. Set Request state to be async IO from ISAPI client
|
|
// 2. Submit Async IOP
|
|
// 3. return to the ISAPI application
|
|
//
|
|
|
|
IWamRequest * pIWamRequest = NULL;
|
|
|
|
if ( FAILED( GetIWamRequest( &pIWamRequest ) ) ) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
InitAsyncIO( ASYNC_IO_TYPE_READ );
|
|
|
|
if( m_fInProcess )
|
|
{
|
|
fReturn = BoolFromHresult( pIWamRequest->AsyncReadClientExt(
|
|
#ifdef _WIN64
|
|
(UINT64) this
|
|
#else
|
|
(ULONG_PTR) this
|
|
#endif
|
|
, (unsigned char *) pvBuff
|
|
, *pcbToRead
|
|
) );
|
|
}
|
|
else
|
|
{
|
|
DBG_ASSERT( _AsyncIoInfo._pvAsyncReadBuffer == NULL );
|
|
_AsyncIoInfo._pvAsyncReadBuffer = pvBuff;
|
|
|
|
fReturn = BoolFromHresult( pIWamRequest->AsyncReadClientOop(
|
|
#ifdef _WIN64
|
|
(UINT64) this
|
|
#else
|
|
(ULONG_PTR) this
|
|
#endif
|
|
, *pcbToRead
|
|
) );
|
|
if( !fReturn )
|
|
{
|
|
_AsyncIoInfo._pvAsyncReadBuffer = NULL;
|
|
}
|
|
}
|
|
|
|
ReleaseIWamRequest( pIWamRequest );
|
|
|
|
|
|
if ( !fReturn ) {
|
|
UninitAsyncIO();
|
|
}
|
|
|
|
} else {
|
|
|
|
DBG_ASSERT( FALSE );
|
|
|
|
}
|
|
|
|
return ( fReturn);
|
|
} // WAM_EXEC_INFO::AsyncReadClient()
|
|
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::ProcessAsyncIO
|
|
|
|
Description:
|
|
|
|
Completes an async i/o by calling the ISA's i/o completion callback
|
|
|
|
Arguments:
|
|
|
|
Returns:
|
|
BOOL
|
|
|
|
*/
|
|
BOOL
|
|
WAM_EXEC_INFO::ProcessAsyncIO(
|
|
DWORD dwStatus
|
|
, DWORD cbWritten
|
|
)
|
|
{
|
|
|
|
DBG_ASSERT( _AsyncIoInfo._pfnHseIO );
|
|
DBG_ASSERT( _AsyncIoInfo._dwOutstandingIO );
|
|
|
|
IF_DEBUG( WAM_ISA_CALLS ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT,
|
|
"WAM_EXEC_INFO[%p]::ProcessAsyncIO(IOStatus=%d, %d bytes)\n"
|
|
, this, dwStatus, cbWritten
|
|
));
|
|
}
|
|
|
|
|
|
BOOL fRet = TRUE;
|
|
BOOL fImpersonated = FALSE;
|
|
DWORD dwIOType = ASYNC_IO_TYPE_NONE;
|
|
|
|
//
|
|
// 1.
|
|
// We are in the return from an async io completion.
|
|
// We will be making a call into the ISAPI DLL to notify that
|
|
// the IO operation completed.
|
|
// This callback has to occur within the bounds of ref/deref
|
|
// of the WAM_EXEC_INFO otherwise following race condition can occur:
|
|
// - isapi's completion function calls done-with-session;
|
|
// if that release got rid of last ref, this WAM_EXEC_INFO
|
|
// gets destroyed
|
|
// - isapi's completion function continues doing other work
|
|
// - an unrelated shutdown command comes in asynchronously
|
|
// - if isapi has no TerminateExtension (or a non-robust one),
|
|
// isapi gets summarily unloaded
|
|
// - any of a number of terrible things can happen
|
|
//
|
|
// If you HAVE temptations to optimize this,
|
|
// please first talk to MuraliK
|
|
//
|
|
AddRef();
|
|
|
|
//
|
|
// 2.
|
|
// Un-init async i/o - balances init we did before requesting i/o
|
|
//
|
|
// NOTE we do this before calling the isapi's completion function
|
|
// Reasons:
|
|
// WAM_EXEC_INFO maintians state that an async IO operation is going on
|
|
// UninitAsyncIO resets this state and other associated ref-counts.
|
|
// This way we ensure that any further async IO callbacks made during
|
|
// the call to the ISAPI DLL will be honored properly.
|
|
//
|
|
|
|
// Only call this in success case.
|
|
if (dwStatus == 0)
|
|
{
|
|
dwIOType = _AsyncIoInfo._dwOutstandingIO;
|
|
UninitAsyncIO();
|
|
}
|
|
|
|
//
|
|
// 3.
|
|
// Impersonate before making ISAPI callback
|
|
//
|
|
|
|
if ( !m_pWam->FWin95() )
|
|
{
|
|
HANDLE hToken = _WamReqCore.m_WamReqCoreFixed.m_hUserToken;
|
|
|
|
if ( !( fImpersonated = ImpersonateLoggedOnUser( hToken ) ) )
|
|
{
|
|
|
|
DBGPRINTF((DBG_CONTEXT,
|
|
"WAM_EXEC_INFO(%p) ImpersonateLoggedOnUser(%x)"
|
|
"failed[err %d]\n",
|
|
this, hToken, GetLastError()));
|
|
|
|
fRet = FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// 4.
|
|
// call isapi if we are successful so far
|
|
//
|
|
|
|
if ( fRet ) {
|
|
|
|
__try {
|
|
|
|
//
|
|
// Adjust bytes written for async writes -
|
|
// otherwise filter adjusted bytes show up
|
|
// which confuses some ISAPI Applications
|
|
//
|
|
|
|
if ( dwIOType == ASYNC_IO_TYPE_WRITE
|
|
&& dwStatus == ERROR_SUCCESS ) {
|
|
|
|
cbWritten = _AsyncIoInfo._cbLastAsyncIO;
|
|
|
|
_AsyncIoInfo._cbLastAsyncIO = 0;
|
|
}
|
|
|
|
|
|
//
|
|
// Make the ISAPI callback to indicate that the I/O completed
|
|
//
|
|
|
|
(*_AsyncIoInfo._pfnHseIO)(
|
|
&ecb,
|
|
_AsyncIoInfo._pvHseIOContext,
|
|
cbWritten,
|
|
dwStatus
|
|
);
|
|
|
|
}
|
|
__except ( g_fEnableTryExcept ?
|
|
WAMExceptionFilter( GetExceptionInformation(),
|
|
WAM_EVENT_EXTENSION_EXCEPTION,
|
|
this ) :
|
|
EXCEPTION_CONTINUE_SEARCH )
|
|
{
|
|
fRet = FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// 5.
|
|
// Revert back if we were impersonated before making ISAPI DLL callback
|
|
//
|
|
|
|
if ( fImpersonated )
|
|
{
|
|
::RevertToSelf( );
|
|
fImpersonated = FALSE;
|
|
}
|
|
|
|
if (dwStatus != 0)
|
|
{
|
|
UninitAsyncIO();
|
|
}
|
|
//
|
|
// Complimentary release for the AddRef() done in Step (1) above
|
|
//
|
|
Release();
|
|
|
|
|
|
return fRet;
|
|
|
|
} // ProcessAsyncIO()
|
|
|
|
BOOL
|
|
WAM_EXEC_INFO::ProcessAsyncReadOop
|
|
(
|
|
DWORD dwStatus,
|
|
DWORD cbRead,
|
|
unsigned char * lpDataRead
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
|
|
Handle callback for out of process AsyncRead
|
|
|
|
Arguments:
|
|
|
|
dwStatus - IO status
|
|
cbRead - Number of bytes read
|
|
lpDataRead - Marshalled data read
|
|
|
|
Return Value:
|
|
|
|
Notes:
|
|
|
|
The initial design for AsyncRead was inadequate when the isapi is
|
|
running out of process. The problem was that the data buffer was
|
|
marshalled over to inetinfo and back during the AsyncRead call.
|
|
Since the completion will happen on another thread the ISAPI could
|
|
get the completion before the data was completely marshalled back
|
|
or the address in inetinfo could be invalidated before the read was
|
|
complete. The solution is to add a separate path for oop async reads
|
|
and marshall the data on the io completion and copy it into the
|
|
client's buffer then.
|
|
|
|
--*/
|
|
{
|
|
DBG_ASSERT( !m_fInProcess );
|
|
DBG_ASSERT( _AsyncIoInfo._pvAsyncReadBuffer != NULL );
|
|
|
|
// Copy the marshalled data into the client's buffer.
|
|
|
|
if( dwStatus == STATUS_SUCCESS )
|
|
{
|
|
//
|
|
// Is there more we can do to protect this?
|
|
//
|
|
// We'd have problems anyway if the client's buffer wasn't large
|
|
// enough to hold the data and cbRead should always be <= than the
|
|
// size the client specified.
|
|
//
|
|
CopyMemory( _AsyncIoInfo._pvAsyncReadBuffer, lpDataRead, cbRead );
|
|
}
|
|
|
|
_AsyncIoInfo._pvAsyncReadBuffer = NULL;
|
|
return ProcessAsyncIO( dwStatus, cbRead );
|
|
}
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::InitAsyncIO
|
|
Initilializes members before requesting async i/o
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Returns:
|
|
Nothing
|
|
|
|
*/
|
|
VOID
|
|
WAM_EXEC_INFO::InitAsyncIO( DWORD dwIOType )
|
|
{
|
|
|
|
IF_DEBUG( WAM_ISA_CALLS ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "WAM_EXEC_INFO(%p)::InitAsyncIO "
|
|
"\n"
|
|
, this
|
|
));
|
|
|
|
}
|
|
|
|
DBG_ASSERT( dwIOType == ASYNC_IO_TYPE_READ || dwIOType == ASYNC_IO_TYPE_WRITE );
|
|
DBG_ASSERT( _AsyncIoInfo._dwOutstandingIO == ASYNC_IO_TYPE_NONE );
|
|
DBG_ASSERT( _AsyncIoInfo._pfnHseIO != NULL);
|
|
DBG_ASSERT( _AsyncIoInfo._pvAsyncReadBuffer == NULL );
|
|
|
|
|
|
AddRef();
|
|
_AsyncIoInfo._dwOutstandingIO = dwIOType;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::UninitAsyncIO
|
|
Un-initilializes members before completing async i/o
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Returns:
|
|
Nothing
|
|
|
|
*/
|
|
VOID
|
|
WAM_EXEC_INFO::UninitAsyncIO()
|
|
{
|
|
|
|
IF_DEBUG( WAM_ISA_CALLS ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "WAM_EXEC_INFO(%p)::UninitAsyncIO "
|
|
"\n"
|
|
, this
|
|
));
|
|
|
|
}
|
|
|
|
|
|
_AsyncIoInfo._dwOutstandingIO = ASYNC_IO_TYPE_NONE;
|
|
Release();
|
|
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::IsValid
|
|
Is this a valid object?
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Returns:
|
|
BOOL
|
|
|
|
*/
|
|
BOOL
|
|
WAM_EXEC_INFO::IsValid( )
|
|
{
|
|
//
|
|
// CONSIDER more thorough error checking
|
|
//
|
|
return (m_dwSignature == WAM_EXEC_INFO_SIGNATURE);
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::AddRef
|
|
Add refs
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Returns:
|
|
Ref count
|
|
|
|
*/
|
|
ULONG
|
|
WAM_EXEC_INFO::AddRef( )
|
|
{
|
|
|
|
IF_DEBUG( WAM_REFCOUNTS ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "WAM_EXEC_INFO(%p) AddRef : %d -> %d\n"
|
|
, this
|
|
, _cRefs
|
|
, _cRefs + 1
|
|
));
|
|
}
|
|
|
|
|
|
LONG cRefs = InterlockedIncrement( &_cRefs );
|
|
|
|
|
|
#if DBG
|
|
|
|
//
|
|
// Write to both this request's trace log and global trace log
|
|
//
|
|
|
|
if( m_pDbgRefTraceLog != NULL ) {
|
|
|
|
WriteRefTraceLog(
|
|
m_pDbgRefTraceLog
|
|
, cRefs
|
|
, (PVOID) this
|
|
);
|
|
}
|
|
|
|
if( sm_pDbgRefTraceLog != NULL ) {
|
|
|
|
WriteRefTraceLog(
|
|
sm_pDbgRefTraceLog
|
|
, cRefs
|
|
, (PVOID) this
|
|
);
|
|
}
|
|
|
|
#endif
|
|
|
|
return cRefs;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::CleanupAndRelease
|
|
|
|
Description:
|
|
Calls wamreq's (prep)cleanup, then releases this wamexecinfo.
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Returns:
|
|
Nothing
|
|
|
|
*/
|
|
void
|
|
WAM_EXEC_INFO::CleanupAndRelease(
|
|
BOOL fFullCleanup
|
|
)
|
|
{
|
|
|
|
//
|
|
// Prep wamreq's cleanup
|
|
//
|
|
// This method should only be called from the IIS thread
|
|
//
|
|
|
|
DBG_ASSERT( m_dwThreadIdIIS == GetCurrentThreadId() );
|
|
|
|
//
|
|
// While on IIS thread m_pIWamReqIIS must be a valid pointer
|
|
//
|
|
|
|
DBG_ASSERT( m_pIWamReqIIS );
|
|
|
|
//
|
|
// The skip wamreq cleanup is only set by ASP after returning
|
|
// a status pending
|
|
//
|
|
|
|
//
|
|
// init hr's to failure - these will drive cleanup logic below,
|
|
// but only if calls are successful
|
|
//
|
|
|
|
HRESULT hrCoInitEx = E_FAIL;
|
|
HRESULT hrGetIWamReq = E_FAIL;
|
|
IWamRequest * pIWamRequest = NULL;
|
|
|
|
|
|
if ( m_fInProcess ) {
|
|
|
|
//
|
|
// inproc case, use our cached ptr.
|
|
|
|
pIWamRequest = m_pIWamReqIIS;
|
|
|
|
} else {
|
|
|
|
|
|
//
|
|
// in oop case,
|
|
// an isapi might have changed the thread's mode on us
|
|
// (for example, by coinit'ing single-threaded).
|
|
// if so, we need to get an interface pointer from gip,
|
|
// since our cached ptr will no longer be valid.
|
|
//
|
|
// NOTE we test this by calling coinit, which is cheap.
|
|
// if this succeeds, we plough ahead with our cached ptr.
|
|
// else if mode changed, we get an interface ptr from gip.
|
|
//
|
|
|
|
hrCoInitEx = CoInitializeEx(NULL, COINIT_MULTITHREADED);
|
|
|
|
|
|
if ( hrCoInitEx == RPC_E_CHANGED_MODE ) {
|
|
|
|
hrGetIWamReq = GetIWamRequest( &pIWamRequest );
|
|
|
|
} else {
|
|
|
|
//
|
|
// NOTE in most cases we are here because we succeeded
|
|
// in others we forge ahead and hope for the best ...
|
|
// at any rate, we cannot be worse off than before
|
|
// we added the above co-init call
|
|
//
|
|
|
|
pIWamRequest = m_pIWamReqIIS;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( pIWamRequest != NULL ) {
|
|
|
|
HANDLE hCurrentUser = m_fInProcess ? NULL : INVALID_HANDLE_VALUE;
|
|
DoRevertHack( &hCurrentUser );
|
|
|
|
if ( fFullCleanup ) {
|
|
|
|
//
|
|
// we are doing full cleanup
|
|
//
|
|
|
|
pIWamRequest->CleanupWamRequest(
|
|
(unsigned char*) ecb.lpszLogData
|
|
, lstrlen( ecb.lpszLogData ) + 1
|
|
, ecb.dwHttpStatusCode
|
|
, _dwIsaKeepConn
|
|
);
|
|
|
|
} else {
|
|
|
|
//
|
|
// we are not doing full cleanup, so call 'Prep' only
|
|
//
|
|
|
|
pIWamRequest->PrepCleanupWamRequest(
|
|
(unsigned char*) ecb.lpszLogData
|
|
, lstrlen( ecb.lpszLogData ) + 1
|
|
, ecb.dwHttpStatusCode
|
|
, _dwIsaKeepConn
|
|
);
|
|
|
|
}
|
|
|
|
UndoRevertHack( &hCurrentUser );
|
|
}
|
|
|
|
|
|
//
|
|
// if we got a ptr from gip, release it
|
|
//
|
|
|
|
if ( SUCCEEDED( hrGetIWamReq ) ) {
|
|
|
|
ReleaseIWamRequest( pIWamRequest );
|
|
}
|
|
|
|
|
|
//
|
|
// if we co-init'ed, co-uninit
|
|
//
|
|
|
|
if ( hrCoInitEx == S_OK ) {
|
|
|
|
CoUninitialize( );
|
|
}
|
|
|
|
|
|
//
|
|
// Release this
|
|
//
|
|
|
|
Release( );
|
|
|
|
|
|
return;
|
|
|
|
} // CleanupAndRelease
|
|
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::Release
|
|
Releases
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Returns:
|
|
Ref count
|
|
|
|
*/
|
|
ULONG
|
|
WAM_EXEC_INFO::Release(
|
|
)
|
|
|
|
{
|
|
|
|
IF_DEBUG( WAM_REFCOUNTS ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "WAM_EXEC_INFO(%p) Release: %d -> %d\n"
|
|
, this
|
|
, _cRefs
|
|
, _cRefs-1
|
|
));
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Write the trace log BEFORE the decrement operation :(
|
|
// If we write it after the decrement, we will run into potential
|
|
// race conditions in this object getting freed up accidentally
|
|
// by another thread
|
|
//
|
|
|
|
#if DBG
|
|
|
|
//
|
|
// Write to both this request's trace log and global trace log
|
|
//
|
|
|
|
if( m_pDbgRefTraceLog != NULL ) {
|
|
|
|
WriteRefTraceLog(
|
|
m_pDbgRefTraceLog
|
|
, _cRefs - 1 // ref count AFTER decrement happens
|
|
, (PVOID) this
|
|
);
|
|
}
|
|
|
|
if( sm_pDbgRefTraceLog != NULL ) {
|
|
|
|
WriteRefTraceLog(
|
|
sm_pDbgRefTraceLog
|
|
, _cRefs - 1 // ref count AFTER decrement happens
|
|
, (PVOID) this
|
|
);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
LONG cRefs = InterlockedDecrement( &_cRefs );
|
|
|
|
|
|
if( cRefs == 0) {
|
|
|
|
IF_DEBUG( WAM_REFCOUNTS ) {
|
|
|
|
DBGPRINTF(( DBG_CONTEXT, "... dying ...\n\n" ));
|
|
}
|
|
|
|
|
|
CleanupWamExecInfo( );
|
|
|
|
//
|
|
// Finally, delete ourselves.
|
|
//
|
|
|
|
delete this;
|
|
return 0;
|
|
|
|
}
|
|
|
|
return cRefs;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::CleanupWamExecInfo
|
|
Cleans up this object prior to its destruction
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Returns:
|
|
Nothing
|
|
|
|
*/
|
|
VOID
|
|
WAM_EXEC_INFO::CleanupWamExecInfo(
|
|
)
|
|
|
|
{
|
|
|
|
//
|
|
// remove this from its list
|
|
//
|
|
|
|
m_pWam->RemoveFromList( &_ListEntry);
|
|
|
|
|
|
if ( !m_fInProcess & !(m_pWam->FWin95()) ) {
|
|
|
|
//
|
|
// If oop, close the impersonation token
|
|
// (dup'ed in w3svc!HGetOopImpersonationToken)
|
|
//
|
|
// NOTE ignore if in-proc or win95 because we never dup'ed
|
|
// handle in the first place
|
|
//
|
|
|
|
DBG_ASSERT( _WamReqCore.m_WamReqCoreFixed.m_hUserToken
|
|
!= (HANDLE)0 );
|
|
|
|
CloseHandle( _WamReqCore.m_WamReqCoreFixed.m_hUserToken );
|
|
_WamReqCore.m_WamReqCoreFixed.m_hUserToken = (HANDLE)0;
|
|
}
|
|
|
|
if ( _psExtension != NULL) {
|
|
// release the extension object
|
|
g_psextensions->ReleaseExtension( _psExtension);
|
|
_psExtension = NULL;
|
|
}
|
|
|
|
|
|
DBG_ASSERT( QueryPWam());
|
|
QueryPWam()->QueryWamStats().DecrCurrentWamRequests();
|
|
|
|
|
|
CleanupWamExecBase();
|
|
|
|
|
|
return;
|
|
|
|
} // WAM_EXEC_INFO::CleanupWamExecInfo
|
|
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
WAM_EXEC_INFO::ISAThreadNotify
|
|
Notifies WAM_EXEC_BASE that an ISAPI thread is about to
|
|
start/stop using it. Allows to cache IWamRequest* in the
|
|
OOP case.
|
|
|
|
NOTE this method is on WAM_EXEC_INFO (rather than WAM_EXEC_BASE)
|
|
because it must addref and release.
|
|
|
|
Arguments:
|
|
fStart thread start (TRUE) / thread end (FALSE)
|
|
|
|
Returns:
|
|
HRESULT
|
|
|
|
*/
|
|
HRESULT
|
|
WAM_EXEC_INFO::ISAThreadNotify(
|
|
BOOL fStart
|
|
)
|
|
{
|
|
|
|
if ( m_fInProcess ) {
|
|
|
|
//
|
|
// In-proc: no-op
|
|
//
|
|
|
|
return NOERROR;
|
|
|
|
}
|
|
|
|
IF_DEBUG( WAM_THREADID ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "WAM_EXEC_INFO(%p)::ISAThreadNotify(%d) Thread(%d)\n"
|
|
, this
|
|
, fStart
|
|
, GetCurrentThreadId()
|
|
));
|
|
}
|
|
|
|
HRESULT hr = NOERROR;
|
|
|
|
if ( fStart ) {
|
|
|
|
//
|
|
// Out-of-proc: when starting the ISA's single-thread
|
|
// sequence, cache ISA-thread ptr we get from gip-master.
|
|
//
|
|
|
|
if ( SUCCEEDED( hr = GetInterfaceForThread( ) ) ) {
|
|
|
|
AddRef();
|
|
}
|
|
|
|
DBG_ASSERT( AssertSmartISAValid() || (hr != NOERROR) );
|
|
|
|
|
|
} else {
|
|
|
|
//
|
|
// Out-of-proc: when ending the ISA's single-thread
|
|
// sequence, release ISA-thread ptr
|
|
//
|
|
|
|
hr = ReleaseInterfaceForThread( );
|
|
|
|
Release();
|
|
|
|
}
|
|
|
|
return hr;
|
|
|
|
} // WAM_EXEC_INFO::ISAThreadNotify
|
|
|
|
|
|
/*---------------------------------------------------------------------*
|
|
Debug methods
|
|
|
|
*/
|
|
|
|
#if DBG
|
|
|
|
VOID
|
|
WAM_EXEC_INFO::Print( VOID) const
|
|
{
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "WAM_EXEC_INFO(%p): Method: %s; Query: %s;\n"
|
|
"PathInfo: %s; PathTrans: %s; ContentType: %s;\n"
|
|
"URL: %s; ISA DLL path: %s;\n"
|
|
"In-Proc = %d; m_pIWamReqInproc = %p; "
|
|
"m_gipIWamRequest = %p; m_pIWamReqSmartISA = %p\n"
|
|
"Flags = %x; ChildExecFlags = %x; RefCount = %d\n"
|
|
"Extension = %p; OutstandingIO = %d; "
|
|
"IoCompletion() = %p; IoContext = %p\n"
|
|
, this
|
|
, _WamReqCore.GetSz( WRC_I_METHOD )
|
|
, _WamReqCore.GetSz( WRC_I_QUERY )
|
|
, _WamReqCore.GetSz( WRC_I_PATHINFO )
|
|
, _WamReqCore.GetSz( WRC_I_PATHTRANS )
|
|
, _WamReqCore.GetSz( WRC_I_CONTENTTYPE )
|
|
, _WamReqCore.GetSz( WRC_I_URL )
|
|
, _WamReqCore.GetSz( WRC_I_ISADLLPATH )
|
|
, m_fInProcess
|
|
, m_pIWamReqInproc
|
|
, m_gipIWamRequest
|
|
, m_pIWamReqSmartISA
|
|
, _dwFlags
|
|
, _dwChildExecFlags
|
|
, _cRefs
|
|
, _psExtension
|
|
, _AsyncIoInfo._dwOutstandingIO
|
|
, _AsyncIoInfo._pfnHseIO
|
|
, _AsyncIoInfo._pvHseIOContext
|
|
));
|
|
|
|
return;
|
|
} // WAM_EXEC_INFO::Print()
|
|
|
|
#else
|
|
|
|
VOID WAM_EXEC_INFO::Print( VOID) const { }
|
|
|
|
#endif //DBG
|
|
|
|
|
|
|
|
#if DBG
|
|
|
|
void
|
|
DbgWamreqRefcounts
|
|
(
|
|
char* szPrefix,
|
|
WAM_EXEC_INFO * pWamExecInfo,
|
|
long cRefsWamRequest,
|
|
long cRefsWamReqContext
|
|
)
|
|
{
|
|
|
|
IWamRequest * pIWamRequest = NULL;
|
|
pWamExecInfo->GetIWamRequest( &pIWamRequest );
|
|
DBG_ASSERT( pIWamRequest );
|
|
|
|
IF_DEBUG( WAM_REFCOUNTS ) {
|
|
DBGPRINTF(( DBG_CONTEXT, szPrefix ));
|
|
DBGPRINTF(( DBG_CONTEXT, "\n" ));
|
|
}
|
|
|
|
HANDLE hCurrentUser = pWamExecInfo->FInProcess() ? NULL : INVALID_HANDLE_VALUE;
|
|
DoRevertHack( &hCurrentUser );
|
|
|
|
if( cRefsWamRequest != -1) {
|
|
|
|
DBG_ASSERT( cRefsWamRequest
|
|
== (long) pIWamRequest->DbgRefCount() );
|
|
}
|
|
|
|
if( cRefsWamReqContext != -1) {
|
|
DBG_ASSERT( cRefsWamReqContext
|
|
== (long) pWamExecInfo->DbgRefCount() );
|
|
}
|
|
|
|
IF_DEBUG( WAM_REFCOUNTS ) {
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "IWamRequest(%p): RefCount = %d\n"
|
|
, pIWamRequest
|
|
, pIWamRequest->DbgRefCount()
|
|
));
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "WAM_EXEC_INFO(%p): RefCount = %d\n"
|
|
, pWamExecInfo, pWamExecInfo->DbgRefCount()
|
|
));
|
|
|
|
}
|
|
|
|
UndoRevertHack( &hCurrentUser );
|
|
|
|
pWamExecInfo->ReleaseIWamRequest( pIWamRequest );
|
|
|
|
} // WAM_EXEC_INFO::DbgWamreqRefcounts
|
|
#endif // DBG
|
|
|
|
|
|
/************************************************************
|
|
* Static Member Functions of WAM_EXEC_INFO
|
|
************************************************************/
|
|
|
|
|
|
BOOL
|
|
WAM_EXEC_INFO::InitClass( VOID)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ALLOC_CACHE_CONFIGURATION acConfig = {
|
|
1
|
|
, WAM_EXEC_INFO_CACHE_THRESHOLD
|
|
, sizeof(WAM_EXEC_INFO)
|
|
};
|
|
|
|
if ( NULL != sm_pachExecInfo) {
|
|
|
|
// already initialized
|
|
return ( TRUE );
|
|
}
|
|
|
|
hr = g_GIPAPI.Init();
|
|
if( FAILED( hr ) ) {
|
|
DBGPRINTF( (DBG_CONTEXT, "GIPAPI::Init Failed: %8.8x\n", hr) );
|
|
return ( FALSE );
|
|
}
|
|
|
|
sm_pachExecInfo = new ALLOC_CACHE_HANDLER( "WamExecInfo",
|
|
&acConfig);
|
|
|
|
#if DBG
|
|
sm_pDbgRefTraceLog = CreateRefTraceLog( C_REFTRACES_GLOBAL, 0 );
|
|
#endif
|
|
|
|
return ( NULL != sm_pachExecInfo);
|
|
} // WAM_EXEC_INFO::InitClass()
|
|
|
|
|
|
VOID
|
|
WAM_EXEC_INFO::CleanupClass( VOID)
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = g_GIPAPI.UnInit();
|
|
|
|
if( FAILED( hr ) ) {
|
|
DBGPRINTF( (DBG_CONTEXT, "GIPAPI::UnInit returned %8.8x\n", hr ) );
|
|
}
|
|
|
|
if ( NULL != sm_pachExecInfo) {
|
|
|
|
delete sm_pachExecInfo;
|
|
sm_pachExecInfo = NULL;
|
|
}
|
|
|
|
#if DBG
|
|
DestroyRefTraceLog( sm_pDbgRefTraceLog );
|
|
#endif
|
|
|
|
return;
|
|
} // WAM_EXEC_INFO::CleanupClass()
|
|
|
|
|
|
void *
|
|
WAM_EXEC_INFO::operator new( size_t s)
|
|
{
|
|
DBG_ASSERT( s == sizeof( WAM_EXEC_INFO));
|
|
|
|
// allocate from allocation cache.
|
|
DBG_ASSERT( NULL != sm_pachExecInfo);
|
|
return (sm_pachExecInfo->Alloc());
|
|
} // WAM_EXEC_INFO::operator new()
|
|
|
|
void
|
|
WAM_EXEC_INFO::operator delete( void * psi)
|
|
{
|
|
DBG_ASSERT( NULL != psi);
|
|
|
|
// free to the allocation pool
|
|
DBG_ASSERT( NULL != sm_pachExecInfo);
|
|
DBG_REQUIRE( sm_pachExecInfo->Free(psi));
|
|
|
|
return;
|
|
} // WAM_EXEC_INFO::operator delete()
|
|
|
|
|
|
|
|
/************************ End of File *********************************/
|