dubey/WindowsXP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
WindowsXP/inetsrv/iis/iisrearc/iisplus/ulw3/isapi_handler.cxx
Tanishq Dubey cb60ae51e5
Initial Commit
2025-04-27 07:49:33 -04:00

2000 lines
50 KiB
C++
Raw Blame History

/*++
Copyright (c) 1999 Microsoft Corporation
Module Name :
isapi_handler.cxx
Abstract:
Handle ISAPI extension requests
Author:
Taylor Weiss (TaylorW) 27-Jan-2000
Environment:
Win32 - User Mode
Project:
ULW3.DLL
--*/
#include <initguid.h>
#include "precomp.hxx"
#include "isapi_handler.h"
#include <wmrgexp.h>
#include <iisextp.h>
HMODULE W3_ISAPI_HANDLER::sm_hIsapiModule;
PFN_ISAPI_TERM_MODULE W3_ISAPI_HANDLER::sm_pfnTermIsapiModule;
PFN_ISAPI_PROCESS_REQUEST W3_ISAPI_HANDLER::sm_pfnProcessIsapiRequest;
PFN_ISAPI_PROCESS_COMPLETION W3_ISAPI_HANDLER::sm_pfnProcessIsapiCompletion;
W3_INPROC_ISAPI_HASH * W3_ISAPI_HANDLER::sm_pInprocIsapiHash;
CRITICAL_SECTION W3_ISAPI_HANDLER::sm_csInprocHashLock;
CRITICAL_SECTION W3_ISAPI_HANDLER::sm_csBigHurkinWamRegLock;
WAM_PROCESS_MANAGER * W3_ISAPI_HANDLER::sm_pWamProcessManager;
BOOL W3_ISAPI_HANDLER::sm_fWamActive;
CHAR W3_ISAPI_HANDLER::sm_szInstanceId[SIZE_CLSID_STRING];
ALLOC_CACHE_HANDLER * W3_ISAPI_HANDLER::sm_pachIsapiHandlers;
BOOL sg_Initialized = FALSE;
/***********************************************************************
Local Declarations
***********************************************************************/
VOID
AddFiltersToMultiSz(
IN const MB & mb,
IN LPCWSTR szFilterPath,
IN OUT MULTISZ * pmsz
);
VOID
AddAllFiltersToMultiSz(
IN const MB & mb,
IN OUT MULTISZ * pmsz
);
/***********************************************************************
Module Definitions
***********************************************************************/
CONTEXT_STATUS
W3_ISAPI_HANDLER::DoWork(
VOID
)
/*++
Routine Description:
Main ISAPI handler routine
Return Value:
CONTEXT_STATUS_PENDING if async pending,
else CONTEXT_STATUS_CONTINUE
--*/
{
W3_CONTEXT *pW3Context = QueryW3Context();
DBG_ASSERT( pW3Context != NULL );
HRESULT hr;
BOOL fComplete = FALSE;
W3_REQUEST *pRequest = pW3Context->QueryRequest();
//
// Preload entity if needed
//
hr = pRequest->PreloadEntityBody( pW3Context,
&fComplete );
if ( FAILED( hr ) )
{
pW3Context->SetErrorStatus( hr );
pW3Context->QueryResponse()->SetStatus( HttpStatusServerError );
return CONTEXT_STATUS_CONTINUE;
}
if ( !fComplete )
{
//
// Async read pending. Just bail
//
return CONTEXT_STATUS_PENDING;
}
_fEntityBodyPreloadComplete = TRUE;
_State = ISAPI_STATE_INITIALIZING;
return IsapiDoWork( pW3Context );
}
CONTEXT_STATUS
W3_ISAPI_HANDLER::IsapiDoWork(
W3_CONTEXT * pW3Context
)
/*++
Routine Description:
Called to execute an ISAPI. This routine must be called only after
we have preloaded entity for the request
Arguments:
pW3Context - Context for this request
Return Value:
CONTEXT_STATUS_PENDING if async pending,
else CONTEXT_STATUS_CONTINUE
--*/
{
DWORD dwHseResult;
HRESULT hr = NOERROR;
HANDLE hOopToken;
URL_CONTEXT * pUrlContext;
BOOL fIsVrToken;
//
// We must have preloaded entity by the time this is called
//
DBG_ASSERT( _State == ISAPI_STATE_INITIALIZING );
DBG_ASSERT( _fEntityBodyPreloadComplete );
DBG_ASSERT( sm_pfnProcessIsapiRequest );
DBG_ASSERT( sm_pfnProcessIsapiCompletion );
DBG_REQUIRE( pUrlContext = pW3Context->QueryUrlContext() );
IF_DEBUG( ISAPI )
{
DBGPRINTF((
DBG_CONTEXT,
"IsapiDoWork called for new request.\r\n"
));
}
//
// Initialize the ISAPI_CORE_DATA and ISAPI_CORE_INTERFACE
// for this request
//
if ( FAILED( hr = InitCoreData( &fIsVrToken ) ) )
{
goto ErrorExit;
}
DBG_ASSERT( _pCoreData );
_pIsapiRequest = new ISAPI_REQUEST( pW3Context, _pCoreData->fIsOop );
if ( _pIsapiRequest == NULL )
{
hr = E_OUTOFMEMORY;
goto ErrorExit;
}
if ( FAILED( hr = _pIsapiRequest->Create() ) )
{
goto ErrorExit;
}
//
// If the request should run OOP, get the WAM process and
// duplicate the impersonation token
//
if ( _pCoreData->fIsOop )
{
DWORD dwAuthType;
DBG_ASSERT( sm_pWamProcessManager );
DBG_ASSERT( _pCoreData->szWamClsid[0] != L'\0' );
hr = sm_pWamProcessManager->GetWamProcess(
(LPCWSTR)&_pCoreData->szWamClsid,
&_pWamProcess,
sm_szInstanceId
);
if ( FAILED( hr ) )
{
goto ErrorExit;
}
//
// For SSPI and Digest authenticated requests, we have to
// modify the token that we're passing to the OOP process.
//
// We don't need to do this in the case of Anonymous or
// Basic because the token cache will take care of it.
//
dwAuthType = pW3Context->QueryUserContext()->QueryAuthType();
if ( ( dwAuthType == MD_AUTH_MD5 ||
dwAuthType == MD_AUTH_NT ) &&
fIsVrToken == FALSE )
{
hr = GrantWpgAccessToToken( _pCoreData->hToken );
if ( FAILED( hr ) )
{
goto ErrorExit;
}
hr = AddWpgToTokenDefaultDacl( _pCoreData->hToken );
if ( FAILED( hr ) )
{
goto ErrorExit;
}
}
if ( DuplicateHandle( GetCurrentProcess(), _pCoreData->hToken,
_pWamProcess->QueryProcess(), &hOopToken,
0, FALSE, DUPLICATE_SAME_ACCESS ) )
{
_pCoreData->hToken = hOopToken;
}
else
{
hr = HRESULT_FROM_WIN32( GetLastError() );
//
// CODEWORK - If the target process has exited, then
// DuplicateHandle fails with ERROR_ACCESS_DENIED. This
// will confuse our error handling logic because it'll
// thing that we really got this error attempting to
// process the request.
//
// For the time being, we'll detect this error and let
// it call into ProcessRequest. If the process really
// has exited, this will cause the WAM_PROCESS cleanup
// code to recover everything.
//
// In the future, we should consider waiting on the
// process handle to detect steady-state crashes of
// OOP hosts so that we don't have to discover the
// problem only when something trys to talk to the
// process.
//
// Another thing to consider is that we could trigger
// the crash recovery directly and call GetWamProcess
// again to get a new process. This would make the
// crash completely transparent to the client, which
// would be an improvement over the current solution
// (and IIS 4 and 5) which usually waits until a client
// request fails before recovering.
//
_pCoreData->hToken = NULL;
if ( hr != HRESULT_FROM_WIN32( ERROR_ACCESS_DENIED ) )
{
goto ErrorExit;
}
}
}
//
// Handle the request
//
_State = ISAPI_STATE_PENDING;
if ( !_pCoreData->fIsOop )
{
IF_DEBUG( ISAPI )
{
DBGPRINTF((
DBG_CONTEXT,
"Processing ISAPI_REQUEST %p OOP.\r\n",
_pIsapiRequest
));
}
hr = sm_pfnProcessIsapiRequest(
_pIsapiRequest,
_pCoreData,
&dwHseResult
);
}
else
{
hr = _pWamProcess->ProcessRequest(
_pIsapiRequest,
_pCoreData,
&dwHseResult
);
}
if ( FAILED( hr ) )
{
_State = ISAPI_STATE_FAILED;
goto ErrorExit;
}
//
// Determine whether the extension was synchronous or pending.
// We need to do this before releasing our reference on the
// ISAPI_REQUEST since the final release will check the state
// to determine if an additional completion is necessary.
//
// In either case, we should just return with the appropriate
// return code after setting the state.
//
if ( dwHseResult != HSE_STATUS_PENDING &&
_pCoreData->fIsOop == FALSE )
{
_State = ISAPI_STATE_DONE;
//
// This had better be the final release...
//
LONG Refs = _pIsapiRequest->Release();
DBGPRINTF((
DBG_CONTEXT,
"Sync request detected. Release returned %d.\r\n",
Refs
));
DBG_ASSERT( Refs == 0 );
return CONTEXT_STATUS_CONTINUE;
}
//
// This may or may not be the final release...
//
_pIsapiRequest->Release();
return CONTEXT_STATUS_PENDING;
ErrorExit:
DBG_ASSERT( FAILED( hr ) );
//
// Spew on failure.
//
if ( FAILED( hr ) )
{
DBGPRINTF((
DBG_CONTEXT,
"Attempt to process ISAPI request failed. Error 0x%08x.\r\n",
hr
));
}
//
// Set the error status now.
//
pW3Context->SetErrorStatus( hr );
//
// If we've failed, and the state is ISAPI_STATE_INITIALIZING, then
// we never made the call out to the extension. It's therefore
// safe to handle the error and advance the state machine.
//
// It's also safe to advance the state machine in the special case
// error where the attempt to call the extension results in
// ERROR_ACCESS_DENIED.
//
if ( _State == ISAPI_STATE_INITIALIZING ||
hr == HRESULT_FROM_WIN32( ERROR_ACCESS_DENIED) )
{
//
// Setting the state to ISAPI_STATE_DONE will cause the
// next completion to advance the state machine.
//
_State = ISAPI_STATE_DONE;
//
// The _pWamProcess and _pCoreData members are cleaned up
// by the destructor. We don't need to worry about them.
// We also don't need to worry about any tokens that we
// are using. The tokens local to this process are owned
// by W3_USER_CONTEXT; any duplicates for OOP are the
// responsibility of the dllhost process (if it still
// exists).
//
// We do need to clean up the _pIsapiRequest if we've
// created it. This had better well be the final release.
//
if ( _pIsapiRequest )
{
DBG_REQUIRE( _pIsapiRequest->Release() == 0 );
}
//
// Set the HTTP status and send it asynchronously.
// This will ultimately trigger the completion that
// advances the state machine.
//
if ( hr == HRESULT_FROM_WIN32( ERROR_ACCESS_DENIED ) )
{
pW3Context->QueryResponse()->SetStatus( HttpStatusUnauthorized,
Http401Resource );
}
else
{
pW3Context->QueryResponse()->SetStatus( HttpStatusServerError );
}
hr = pW3Context->SendResponse( W3_FLAG_ASYNC );
if ( SUCCEEDED( hr ) )
{
return CONTEXT_STATUS_PENDING;
}
//
// Ouch - couldn't send the error page...
//
_State = ISAPI_STATE_FAILED;
return CONTEXT_STATUS_CONTINUE;
}
//
// If we get here, then an error has occured during or after
// our call into the extension. Because it's possible for an
// OOP call to fail after entering the extension, we can't
// generally know our state.
//
// Because of this, we'll assume that the extension has
// outstanding references to the ISAPI_REQUEST on its behalf.
// We'll set the state to ISAPI_STATE_PENDING and let the
// destructor on the ISAPI_REQUEST trigger the final
// completion.
//
// Also, we'll set the error status, just in case the extension
// didn't get a response off before it failed.
//
// CODEWORK - Is this safe? What if an OOP crashes while a SendResponse
// call is running through the core?
pW3Context->QueryResponse()->SetStatus( HttpStatusServerError );
_State = ISAPI_STATE_PENDING;
//
// This may or may not be the final release on the ISAPI_REQUEST.
//
// It had better be non-NULL if we got past ISAPI_STATE_INITIALIZING.
//
DBG_ASSERT( _pIsapiRequest );
_pIsapiRequest->Release();
return CONTEXT_STATUS_PENDING;
}
CONTEXT_STATUS
W3_ISAPI_HANDLER::OnCompletion(
DWORD cbCompletion,
DWORD dwCompletionStatus
)
/*++
Routine Description:
ISAPI async completion handler.
Arguments:
cbCompletion - Number of bytes in an async completion
dwCompletionStatus - Error status of a completion
Return Value:
CONTEXT_STATUS_PENDING if async pending,
else CONTEXT_STATUS_CONTINUE
--*/
{
HRESULT hr;
W3_CONTEXT * pW3Context;
pW3Context = QueryW3Context();
DBG_ASSERT( pW3Context != NULL );
//
// Is this completion for the entity body preload? If so note the
// number of bytes and start handling the ISAPI request
//
if ( !_fEntityBodyPreloadComplete )
{
BOOL fComplete = FALSE;
//
// This completion is for entity body preload
//
W3_REQUEST *pRequest = pW3Context->QueryRequest();
hr = pRequest->PreloadCompletion(pW3Context,
cbCompletion,
dwCompletionStatus,
&fComplete);
if ( FAILED( hr ) )
{
pW3Context->SetErrorStatus( hr );
pW3Context->QueryResponse()->SetStatus( HttpStatusServerError );
return CONTEXT_STATUS_CONTINUE;
}
if (!fComplete)
{
return CONTEXT_STATUS_PENDING;
}
_fEntityBodyPreloadComplete = TRUE;
_State = ISAPI_STATE_INITIALIZING;
//
// Finally we can call the ISAPI
//
return IsapiDoWork( pW3Context );
}
DBG_ASSERT( _fEntityBodyPreloadComplete );
return IsapiOnCompletion( cbCompletion, dwCompletionStatus );
}
CONTEXT_STATUS
W3_ISAPI_HANDLER::IsapiOnCompletion(
DWORD cbCompletion,
DWORD dwCompletionStatus
)
/*++
Routine Description:
Funnels a completion to an ISAPI
Arguments:
cbCompletion - Bytes of completion
dwCompletionStatus - Win32 Error status of completion
Return Value:
CONTEXT_STATUS_PENDING if async pending,
else CONTEXT_STATUS_CONTINUE
--*/
{
DWORD64 IsapiContext;
HRESULT hr = NO_ERROR;
DBG_ASSERT( _pCoreData );
DBG_ASSERT( _pIsapiRequest );
//
// If the state is ISAPI_STATE_DONE, then we should
// advance the state machine now.
//
if ( _State == ISAPI_STATE_DONE ||
_State == ISAPI_STATE_FAILED )
{
return CONTEXT_STATUS_CONTINUE;
}
//
// If we get here, then this completion should be passed
// along to the extension.
//
IsapiContext = _pIsapiRequest->QueryIsapiContext();
DBG_ASSERT( IsapiContext != 0 );
//
// Process the completion.
//
_pIsapiRequest->AddRef();
if ( !_pCoreData->fIsOop )
{
//
// Need to reset the ISAPI context in case the extension
// does another async operation before the below call returns
//
_pIsapiRequest->ResetIsapiContext();
hr = sm_pfnProcessIsapiCompletion(
IsapiContext,
cbCompletion,
dwCompletionStatus
);
}
else
{
DBG_ASSERT( _pWamProcess );
//
// _pWamProcess->ProcessCompletion depends on the ISAPI
// context, so it will make the Reset call.
//
hr = _pWamProcess->ProcessCompletion(
_pIsapiRequest,
IsapiContext,
cbCompletion,
dwCompletionStatus
);
}
_pIsapiRequest->Release();
return CONTEXT_STATUS_PENDING;
}
HRESULT
W3_ISAPI_HANDLER::InitCoreData(
BOOL * pfIsVrToken
)
/*++
Routine Description:
Initializes the ISAPI_CORE_DATA for a request
Arguments:
None
Return Value:
HRESULT
--*/
{
DWORD cbSizeNeeded;
DWORD cbString;
HRESULT hr = NO_ERROR;
W3_CONTEXT * pW3Context;
URL_CONTEXT * pUrlContext;
W3_URL_INFO * pUrlInfo;
W3_METADATA * pMetadata;
CHAR * szHeaderTemp;
STACK_STRU( struPathInfo, 128);
STACK_STRU( struPathTranslated, 128);
STACK_STRA( straMethod, 16);
STACK_STRA( straQueryString, 128);
STACK_STRA( straContentType, 32);
STACK_STRA( straUserAgent, 128);
STACK_STRA( straApplMdPath, 128);
STACK_STRA( straCookie, 128);
STACK_STRA( straConnection, 32);
STACK_STRU( struApplMdPathW, 128);
STACK_STRU( struWamClsid, SIZE_CLSID_STRING);
STACK_STRA( straPhysicalPath, 128);
STACK_STRA( straPathInfo, 128);
STACK_STRA( straPathTranslated, 128);
STRU * pstruGatewayImage;
STRU * pstruPhysicalPath;
STRU * pstruWamClsid;
DWORD cbAvailableEntity;
PVOID pbAvailableEntity;
BOOL fIsOop = FALSE;
ISAPI_CORE_DATA icdTemp;
W3_REQUEST * pRequest = NULL;
CHAR * szContentLength;
DBG_REQUIRE( pW3Context = QueryW3Context() );
DBG_REQUIRE( pRequest = pW3Context->QueryRequest() );
DBG_REQUIRE( pUrlContext = pW3Context->QueryUrlContext() );
DBG_REQUIRE( pUrlInfo = pUrlContext->QueryUrlInfo() );
DBG_REQUIRE( pMetadata = pUrlContext->QueryMetaData() );
//
// Collect the core data that we'll need
//
// Physical Path
pstruPhysicalPath = pUrlContext->QueryPhysicalPath();
if (FAILED(hr = straPhysicalPath.CopyW( pstruPhysicalPath->QueryStr(),
pstruPhysicalPath->QueryCCH() )))
{
goto ErrorExit;
}
// Gateway Image
//
// If this is a DAV request, then the gateway image should be DAV's dll,
// else if this is a script mapped request, then the image should be
// the executable associated with the script map. If it's not DAV and
// not script mapped, then the gateway image is just the physical path
// associated with the URL.
if ( _fIsDavRequest )
{
pstruGatewayImage = &_strDavIsapiImage;
}
else if ( QueryScriptMapEntry() )
{
pstruGatewayImage = QueryScriptMapEntry()->QueryExecutable();
}
else
{
pstruGatewayImage = pUrlContext->QueryPhysicalPath();
}
//
// ApplMdPath
//
hr = GetServerVariableApplMdPath( pW3Context, &straApplMdPath );
if( FAILED(hr) )
{
goto ErrorExit;
}
//
// If WAM is active, then we need to determine if this is
// an OOP request.
//
if ( sm_fWamActive )
{
switch ( pMetadata->QueryAppIsolated() )
{
case APP_INPROC:
fIsOop = FALSE;
break;
case APP_ISOLATED:
fIsOop = TRUE;
pstruWamClsid = pMetadata->QueryWamClsId();
DBG_ASSERT( pstruWamClsid );
if ( pstruWamClsid == NULL )
{
goto ErrorExit;
}
hr = struWamClsid.Copy( pstruWamClsid->QueryStr() );
if ( FAILED( hr ) )
{
goto ErrorExit;
}
break;
case APP_POOL:
fIsOop = TRUE;
hr = struWamClsid.Copy( POOL_WAM_CLSID );
if ( FAILED( hr ) )
{
goto ErrorExit;
}
default:
//
// We'll only get here if someone has hand-edited their
// metabase. In this case, we'll treat it as an inproc
// application.
//
break;
}
//
//
// If the extension is on the InProcessIsapiApps list,
// then it's going to be inproc, regardless
//
if ( fIsOop && IsInprocIsapi( pstruGatewayImage->QueryStr() ) )
{
fIsOop = FALSE;
}
}
// Path info
//
// Set path info to be the URL if the target URL is a script
// unless the AllowPathInfoForScriptMappings key is set on the site.
// This makes us compatible with earlier versions of IIS, and DAV
// depends on this.
//
BOOL fUsePathInfo;
if ( ( QueryScriptMapEntry() &&
!pW3Context->QuerySite()->QueryAllowPathInfoForScriptMappings() ) ||
_fIsDavRequest )
{
hr = pRequest->GetUrl( &struPathInfo );
if ( FAILED( hr ) )
{
goto ErrorExit;
}
fUsePathInfo = FALSE;
}
else
{
//
// This is a new virtual path to have filters map
//
hr = struPathInfo.Copy( *pUrlInfo->QueryPathInfo() );
if ( FAILED( hr ) )
{
goto ErrorExit;
}
fUsePathInfo = TRUE;
}
if (FAILED(hr = straPathInfo.CopyW( struPathInfo.QueryStr(),
struPathInfo.QueryCCH() )))
{
goto ErrorExit;
}
hr = pUrlInfo->GetPathTranslated( pW3Context,
fUsePathInfo,
&struPathTranslated );
if ( FAILED( hr ) )
{
goto ErrorExit;
}
if (FAILED(hr = straPathTranslated.CopyW( struPathTranslated.QueryStr(),
struPathTranslated.QueryCCH() )))
{
goto ErrorExit;
}
// Request method
hr = pRequest->GetVerbString( &straMethod );
if (FAILED( hr ) )
{
goto ErrorExit;
}
// Query string
hr = pRequest->GetQueryStringA( &straQueryString );
if (FAILED( hr ) )
{
goto ErrorExit;
}
// Content type
szHeaderTemp = pRequest->GetHeader( HttpHeaderContentType );
hr = straContentType.Copy( szHeaderTemp ? szHeaderTemp : "" );
if (FAILED( hr ) )
{
goto ErrorExit;
}
// UserAgent
szHeaderTemp = pRequest->GetHeader( HttpHeaderUserAgent );
hr = straUserAgent.Copy( szHeaderTemp ? szHeaderTemp : "" );
if (FAILED( hr ) )
{
goto ErrorExit;
}
// Cookie
szHeaderTemp = pRequest->GetHeader( HttpHeaderCookie );
hr = straCookie.Copy( szHeaderTemp ? szHeaderTemp : "" );
if (FAILED( hr ) )
{
goto ErrorExit;
}
// Connection
szHeaderTemp = pRequest->GetHeader( HttpHeaderConnection );
hr = straConnection.Copy( szHeaderTemp ? szHeaderTemp : "" );
if ( FAILED( hr ) )
{
goto ErrorExit;
}
//
// Calculate the size of buffer that we will need to
// hold the ISAPI_CORE_STATE and any associated data
// and allocate it.
//
icdTemp.cbSize = sizeof(ISAPI_CORE_DATA);
icdTemp.cbSize += ( icdTemp.cbGatewayImage = pstruGatewayImage->QueryCB() + sizeof(WCHAR) );
icdTemp.cbSize += ( icdTemp.cbPhysicalPath = straPhysicalPath.QueryCCH() + 1 );
icdTemp.cbSize += ( icdTemp.cbPathInfo = straPathInfo.QueryCCH() + 1 );
icdTemp.cbSize += ( icdTemp.cbMethod = straMethod.QueryCCH() + 1 );
icdTemp.cbSize += ( icdTemp.cbQueryString = straQueryString.QueryCCH() + 1 );
icdTemp.cbSize += ( icdTemp.cbPathTranslated = straPathTranslated.QueryCCH() + 1 );
icdTemp.cbSize += ( icdTemp.cbContentType = straContentType.QueryCCH() + 1 );
icdTemp.cbSize += ( icdTemp.cbConnection = straConnection.QueryCCH() + 1 );
icdTemp.cbSize += ( icdTemp.cbUserAgent = straUserAgent.QueryCCH() + 1 );
icdTemp.cbSize += ( icdTemp.cbCookie = straCookie.QueryCCH() + 1 );
icdTemp.cbSize += ( icdTemp.cbApplMdPath = straApplMdPath.QueryCCH() + 1 );
if ( fIsOop )
{
hr = GetServerVariableApplMdPathW( pW3Context, &struApplMdPathW );
if ( FAILED( hr ) )
{
goto ErrorExit;
}
icdTemp.cbSize += ( icdTemp.cbApplMdPathW = ( struApplMdPathW.QueryCCH() + 1 ) * sizeof( WCHAR ) );
icdTemp.cbSize += ( icdTemp.cbPathTranslatedW = ( struPathTranslated.QueryCCH() + 1 ) * sizeof( WCHAR ) );
}
else
{
icdTemp.cbSize += ( icdTemp.cbApplMdPathW = sizeof( WCHAR ) );
icdTemp.cbSize += ( icdTemp.cbPathTranslatedW = sizeof( WCHAR ) );
}
pW3Context->QueryAlreadyAvailableEntity( &pbAvailableEntity,
&cbAvailableEntity );
icdTemp.cbAvailableEntity = cbAvailableEntity;
if ( fIsOop )
{
icdTemp.cbSize += icdTemp.cbAvailableEntity;
}
//
// Allocate space for core data now that we know its size
//
if ( !_buffCoreData.Resize( icdTemp.cbSize ) )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
goto ErrorExit;
}
_pCoreData = (ISAPI_CORE_DATA*) _buffCoreData.QueryPtr();
DBG_ASSERT( _pCoreData != NULL );
//
// Populate the core state
//
memcpy( _pCoreData, &icdTemp, sizeof( ISAPI_CORE_DATA ) );
// OOP flag
_pCoreData->fIsOop = fIsOop;
// Secure flag
_pCoreData->fSecure = pRequest->IsSecureRequest();
// Client major and minor version
_pCoreData->dwVersionMajor = pRequest->QueryVersion().MajorVersion;
_pCoreData->dwVersionMinor = pRequest->QueryVersion().MinorVersion;
// ImpersonationToken
_pCoreData->hToken = pW3Context->QueryImpersonationToken( pfIsVrToken );
// Sid (if available and inproc to avoid buffer copying)
if ( !fIsOop )
{
_pCoreData->pSid = pW3Context->QueryUserContext()->QuerySid();
}
else
{
_pCoreData->pSid = NULL;
}
DBG_ASSERT( _pCoreData->hToken );
// InstanceID
_pCoreData->dwInstanceId = pRequest->QuerySiteId();
// Content length
if ( pRequest->IsChunkedRequest() )
{
_pCoreData->dwContentLength = (DWORD) -1;
}
else
{
szContentLength = pRequest->GetHeader( HttpHeaderContentLength );
if ( szContentLength != NULL )
{
_pCoreData->dwContentLength = atol( szContentLength );
}
else
{
_pCoreData->dwContentLength = 0;
}
}
// WAM CLSID
wcscpy( _pCoreData->szWamClsid, struWamClsid.QueryStr() );
//
// Set the pointers so that they point into a reasonable offset into
// the additional buffer space.
//
//
// All the extra data begins right at the end of _pCoreData, start
// pointing there.
//
// Note that we should included the UNICODE data before the ANSI
// strings to avoid byte alignment issues on IA64...
//
_pCoreData->szGatewayImage = (LPWSTR)(_pCoreData + 1);
_pCoreData->szApplMdPathW = (LPWSTR)((LPSTR)_pCoreData->szGatewayImage + _pCoreData->cbGatewayImage);
_pCoreData->szPathTranslatedW = (LPWSTR)((LPSTR)_pCoreData->szApplMdPathW + _pCoreData->cbApplMdPathW);
_pCoreData->szPhysicalPath = (LPSTR)_pCoreData->szPathTranslatedW + _pCoreData->cbPathTranslatedW;
_pCoreData->szPathInfo = _pCoreData->szPhysicalPath + _pCoreData->cbPhysicalPath;
_pCoreData->szMethod = _pCoreData->szPathInfo + _pCoreData->cbPathInfo;
_pCoreData->szQueryString = _pCoreData->szMethod + _pCoreData->cbMethod;
_pCoreData->szPathTranslated = _pCoreData->szQueryString + _pCoreData->cbQueryString;
_pCoreData->szContentType = _pCoreData->szPathTranslated + _pCoreData->cbPathTranslated;
_pCoreData->szConnection = _pCoreData->szContentType + _pCoreData->cbContentType;
_pCoreData->szUserAgent = _pCoreData->szConnection + _pCoreData->cbConnection;
_pCoreData->szCookie = _pCoreData->szUserAgent + _pCoreData->cbUserAgent;
_pCoreData->szApplMdPath = _pCoreData->szCookie + _pCoreData->cbCookie;
//
// If this request is OOP, then we need to package the entity that we already
// have with the core data buffer.
//
if ( fIsOop )
{
_pCoreData->pAvailableEntity = _pCoreData->szApplMdPath + _pCoreData->cbApplMdPath;
memcpy( _pCoreData->pAvailableEntity, pbAvailableEntity, _pCoreData->cbAvailableEntity );
}
else
{
_pCoreData->pAvailableEntity = pbAvailableEntity;
}
//
// Now go ahead and stuff the data into our buffers. We're not checking
// return codes because we've presumably allocated enough space and these
// shouldn't fail...
//
pstruGatewayImage->CopyToBuffer( _pCoreData->szGatewayImage, &_pCoreData->cbGatewayImage );
if ( fIsOop )
{
struApplMdPathW.CopyToBuffer( _pCoreData->szApplMdPathW, &_pCoreData->cbApplMdPathW );
struPathTranslated.CopyToBuffer( _pCoreData->szPathTranslatedW, &_pCoreData->cbPathTranslatedW );
}
else
{
*_pCoreData->szApplMdPathW = L'\0';
*_pCoreData->szPathTranslatedW = L'\0';
}
straPhysicalPath.CopyToBuffer( _pCoreData->szPhysicalPath, &_pCoreData->cbPhysicalPath );
straPathInfo.CopyToBuffer( _pCoreData->szPathInfo, &_pCoreData->cbPathInfo );
straMethod.CopyToBuffer( _pCoreData->szMethod, &_pCoreData->cbMethod );
straQueryString.CopyToBuffer( _pCoreData->szQueryString, &_pCoreData->cbQueryString );
straPathTranslated.CopyToBuffer( _pCoreData->szPathTranslated, &_pCoreData->cbPathTranslated );
straContentType.CopyToBuffer( _pCoreData->szContentType, &_pCoreData->cbContentType );
straConnection.CopyToBuffer( _pCoreData->szConnection, &_pCoreData->cbConnection );
straUserAgent.CopyToBuffer( _pCoreData->szUserAgent, &_pCoreData->cbUserAgent );
straCookie.CopyToBuffer( _pCoreData->szCookie, &_pCoreData->cbCookie );
straApplMdPath.CopyToBuffer( _pCoreData->szApplMdPath, &_pCoreData->cbApplMdPath );
DBG_ASSERT( SUCCEEDED( hr ) );
return hr;
ErrorExit:
DBG_ASSERT( FAILED( hr ) );
_pCoreData = NULL;
return hr;
}
HRESULT
W3_ISAPI_HANDLER::DuplicateWamProcessHandleForLocalUse(
HANDLE hWamProcessHandle,
HANDLE * phLocalHandle
)
/*++
Routine Description:
Duplicates a handle defined in a WAM process to a local
handle useful in the IIS core
Arguments:
hWamProcessHandle - The value of the handle from the WAM process
phLocalHandle - Upon successful return, the handle useable in
the core process
Return Value:
HRESULT
--*/
{
HANDLE hWamProcess;
HRESULT hr = NOERROR;
DBG_ASSERT( _pWamProcess );
DBG_REQUIRE( hWamProcess = _pWamProcess->QueryProcess() );
if ( !DuplicateHandle( hWamProcess, hWamProcessHandle, GetCurrentProcess(),
phLocalHandle, 0, FALSE, DUPLICATE_SAME_ACCESS ) )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
}
return hr;
}
HRESULT
W3_ISAPI_HANDLER::MarshalAsyncReadBuffer(
DWORD_PTR pWamExecInfo,
LPBYTE pBuffer,
DWORD cbBuffer
)
/*++
Routine Description:
Pushes a buffer into a WAM process. This function is called
to copy a local read buffer into the WAM process just prior
to notifying the I/O completion function of an OOP extension.
Arguments:
pWamExecInfo - A WAM_EXEC_INFO pointer that identifies the request
to the OOP host.
pBuffer - The buffer to copy
cbBuffer - The amount of data in pBuffer
Return Value:
HRESULT
--*/
{
DBG_ASSERT( sm_fWamActive );
DBG_ASSERT( _pWamProcess );
return _pWamProcess->MarshalAsyncReadBuffer( pWamExecInfo, pBuffer,
cbBuffer );
}
VOID
W3_ISAPI_HANDLER::IsapiRequestFinished(
VOID
)
/*++
Routine Description:
This function is called by the destructor for the
ISAPI_REQUEST associated with this request. If the
current state of the W3_ISAPI_HANDLER is
ISAPI_STATE_PENDING, then it will advance the core
state machine.
Arguments:
None
Return Value:
None
--*/
{
if ( _State == ISAPI_STATE_PENDING )
{
RestartCoreStateMachine();
}
}
VOID
W3_ISAPI_HANDLER::RestartCoreStateMachine(
VOID
)
/*++
Routine Description:
Advances the core state machine by setting state
to ISAPI_STATE_DONE and triggering an I/O completion.
Note that this function is only expected to be called
if the object state is ISAPI_STATE_PENDING.
Arguments:
None
Return Value:
None
--*/
{
W3_CONTEXT * pW3Context = QueryW3Context();
BOOL fResult;
DBG_ASSERT( pW3Context );
DBG_ASSERT( _State == ISAPI_STATE_PENDING );
//
// Need to set state to ISAPI_STATE_DONE so that the
// resulting completion does the advance for us.
//
_State = ISAPI_STATE_DONE;
fResult = ThreadPoolPostCompletion(
0,
W3_MAIN_CONTEXT::OnPostedCompletion,
(LPOVERLAPPED)pW3Context->QueryMainContext()
);
DBG_ASSERT( fResult );
}
//static
HRESULT
W3_ISAPI_HANDLER::Initialize(
VOID
)
/*++
Routine Description:
Initializes W3_ISAPI_HANDLER
Arguments:
None
Return Value:
HRESULT
--*/
{
ALLOC_CACHE_CONFIGURATION acConfig;
HRESULT hr = NOERROR;
DBGPRINTF(( DBG_CONTEXT, "W3_ISAPI_HANDLER::Initialize()\n" ));
//
// Initialize lookaside
//
acConfig.nConcurrency = 1;
acConfig.nThreshold = 100;
acConfig.cbSize = sizeof( W3_ISAPI_HANDLER );
DBG_ASSERT( sm_pachIsapiHandlers == NULL );
sm_pachIsapiHandlers = new ALLOC_CACHE_HANDLER( "W3_ISAPI_HANDLER",
&acConfig );
if ( sm_pachIsapiHandlers == NULL )
{
hr = HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );
goto error_exit;
}
//
// For debugging purposes, create a unique instance ID for this
// instance of the handler.
//
#ifdef DBG
UUID uuid;
RPC_STATUS rpcStatus;
unsigned char * szRpcString;
rpcStatus = UuidCreate( &uuid );
if ( (rpcStatus != RPC_S_OK) && (rpcStatus != RPC_S_UUID_LOCAL_ONLY) )
{
SetLastError( rpcStatus );
goto error_exit;
}
rpcStatus = UuidToStringA( &uuid, &szRpcString );
if ( rpcStatus != RPC_S_OK )
{
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
goto error_exit;
}
strncpy( sm_szInstanceId, (LPSTR)szRpcString, SIZE_CLSID_STRING );
sm_szInstanceId[SIZE_CLSID_STRING - 1] = '\0';
RpcStringFreeA( &szRpcString );
DBGPRINTF((
DBG_CONTEXT,
"W3_ISAPI_HANDLER initialized instance %s.\r\n",
sm_szInstanceId
));
#else
sm_szInstanceId[0] = '\0';
#endif _DBG
PFN_ISAPI_INIT_MODULE pfnInit = NULL;
sm_hIsapiModule = LoadLibrary( ISAPI_MODULE_NAME );
if( sm_hIsapiModule == NULL )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
goto error_exit;
}
sm_pfnTermIsapiModule =
(PFN_ISAPI_TERM_MODULE)GetProcAddress( sm_hIsapiModule,
ISAPI_TERM_MODULE
);
sm_pfnProcessIsapiRequest =
(PFN_ISAPI_PROCESS_REQUEST)GetProcAddress( sm_hIsapiModule,
ISAPI_PROCESS_REQUEST
);
sm_pfnProcessIsapiCompletion =
(PFN_ISAPI_PROCESS_COMPLETION)GetProcAddress( sm_hIsapiModule,
ISAPI_PROCESS_COMPLETION
);
if( !sm_pfnTermIsapiModule ||
!sm_pfnProcessIsapiRequest ||
!sm_pfnProcessIsapiCompletion )
{
hr = E_FAIL;
goto error_exit;
}
pfnInit =
(PFN_ISAPI_INIT_MODULE)GetProcAddress( sm_hIsapiModule,
ISAPI_INIT_MODULE
);
if( !pfnInit )
{
hr = E_FAIL;
goto error_exit;
}
hr = pfnInit(
NULL,
sm_szInstanceId,
GetCurrentProcessId()
);
if( FAILED(hr) )
{
goto error_exit;
}
DBG_REQUIRE( ISAPI_REQUEST::InitClass() );
sm_pInprocIsapiHash = NULL;
//
// If we're running in backward compatibility mode, initialize
// the WAM process manager and inprocess ISAPI app list
//
if ( g_pW3Server->QueryInBackwardCompatibilityMode() )
{
WCHAR szIsapiModule[MAX_PATH];
//
// Store away the full path to the loaded ISAPI module
// so that we can pass it to OOP processes so that they
// know how to load it
//
if ( GetModuleFileNameW(
GetModuleHandleW( ISAPI_MODULE_NAME ),
szIsapiModule,
MAX_PATH
) == 0 )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
goto error_exit;
}
DBG_ASSERT( szIsapiModule[0] != '\0' );
//
// Initialize the WAM_PROCESS_MANAGER
//
sm_pWamProcessManager = new WAM_PROCESS_MANAGER( szIsapiModule );
if ( !sm_pWamProcessManager )
{
goto error_exit;
}
hr = sm_pWamProcessManager->Create();
if ( FAILED( hr ) )
{
sm_pWamProcessManager->Release();
sm_pWamProcessManager = NULL;
goto error_exit;
}
//
// Hook up wamreg
//
hr = WamReg_RegisterSinkNotify( W3SVC_WamRegSink );
if ( FAILED( hr ) )
{
goto error_exit;
}
INITIALIZE_CRITICAL_SECTION( &sm_csInprocHashLock );
UpdateInprocIsapiHash();
INITIALIZE_CRITICAL_SECTION( &sm_csBigHurkinWamRegLock );
sm_fWamActive = TRUE;
}
else
{
sm_pWamProcessManager = NULL;
sm_fWamActive = FALSE;
}
sg_Initialized = TRUE;
return hr;
error_exit:
DBGPRINTF(( DBG_CONTEXT,
"W3_ISAPI_HANDLER::Initialize() Error=%08x\n",
hr
));
if ( sm_hIsapiModule )
{
FreeLibrary( sm_hIsapiModule );
sm_hIsapiModule = NULL;
}
if ( sm_pachIsapiHandlers != NULL )
{
delete sm_pachIsapiHandlers;
sm_pachIsapiHandlers = NULL;
}
sm_pfnTermIsapiModule = NULL;
return hr;
}
//static
VOID
W3_ISAPI_HANDLER::Terminate(
VOID
)
/*++
Routine Description:
Terminates W3_ISAPI_HANDLER
Arguments:
None
Return Value:
None
--*/
{
DBGPRINTF(( DBG_CONTEXT, "W3_ISAPI_HANDLER::Terminate()\n" ));
sg_Initialized = FALSE;
DBG_ASSERT( sm_pfnTermIsapiModule );
DBG_ASSERT( sm_hIsapiModule );
if( sm_pfnTermIsapiModule )
{
sm_pfnTermIsapiModule();
sm_pfnTermIsapiModule = NULL;
}
if( sm_hIsapiModule )
{
FreeLibrary( sm_hIsapiModule );
sm_hIsapiModule = NULL;
}
if ( sm_pInprocIsapiHash )
{
delete sm_pInprocIsapiHash;
}
if ( sm_fWamActive )
{
//
// Disconnect wamreg
//
WamReg_UnRegisterSinkNotify();
if ( sm_pWamProcessManager )
{
sm_pWamProcessManager->Shutdown();
sm_pWamProcessManager->Release();
sm_pWamProcessManager = NULL;
}
DeleteCriticalSection( &sm_csInprocHashLock );
DeleteCriticalSection( &sm_csBigHurkinWamRegLock );
}
if ( sm_pachIsapiHandlers != NULL )
{
delete sm_pachIsapiHandlers;
sm_pachIsapiHandlers = NULL;
}
ISAPI_REQUEST::CleanupClass();
}
// static
HRESULT
W3_ISAPI_HANDLER::W3SVC_WamRegSink(
LPCSTR szAppPath,
const DWORD dwCommand,
DWORD * pdwResult
)
{
HRESULT hr = NOERROR;
WAM_PROCESS * pWamProcess = NULL;
WAM_APP_INFO * pWamAppInfo = NULL;
BOOL fIsLoaded = FALSE;
//
// Scary monsters live in the land where this function
// is allowed to run willy nilly
//
LockWamReg();
DBG_ASSERT( szAppPath );
DBG_ASSERT( sm_pWamProcessManager );
DBGPRINTF((
DBG_CONTEXT,
"WAM_PROCESS_MANAGER received a Sink Notify on MD path %S, cmd = %d.\r\n",
(LPCWSTR)szAppPath,
dwCommand
));
*pdwResult = APPSTATUS_UnLoaded;
switch ( dwCommand )
{
case APPCMD_UNLOAD:
case APPCMD_DELETE:
case APPCMD_CHANGETOINPROC:
case APPCMD_CHANGETOOUTPROC:
//
// Unload the specified wam process.
//
// Note that we're casting the incoming app path to
// UNICODE. This is because wamreg would normally
// convert the MD path (which is nativly UNICODE) to
// MBCS in IIS 5.x. It's smart enough to know that
// for 6.0 we want to work directly with UNICODE.
//
hr = sm_pWamProcessManager->GetWamProcessInfo(
reinterpret_cast<LPCWSTR>(szAppPath),
&pWamAppInfo,
&fIsLoaded
);
if ( FAILED( hr ) )
{
goto Done;
}
DBG_ASSERT( pWamAppInfo );
//
// If the app has not been loaded by the WAM_PROCESS_MANAGER
// then there is nothing more to do.
//
if ( fIsLoaded == FALSE )
{
break;
}
hr = sm_pWamProcessManager->GetWamProcess(
pWamAppInfo->_szClsid,
&pWamProcess,
sm_szInstanceId
);
if ( FAILED( hr ) )
{
//
// Hey, this app was loaded just a moment ago!
//
DBG_ASSERT( FALSE );
goto Done;
}
DBG_ASSERT( pWamProcess );
hr = pWamProcess->Unload( 0 );
if ( FAILED( hr ) )
{
goto Done;
}
break;
case APPCMD_GETSTATUS:
hr = sm_pWamProcessManager->GetWamProcessInfo(
reinterpret_cast<LPCWSTR>(szAppPath),
&pWamAppInfo,
&fIsLoaded
);
if ( SUCCEEDED( hr ) )
{
if ( fIsLoaded )
{
*pdwResult = APPSTATUS_Running;
}
else
{
*pdwResult = APPSTATUS_Stopped;
}
}
break;
}
Done:
UnlockWamReg();
if ( pWamAppInfo )
{
pWamAppInfo->Release();
pWamAppInfo = NULL;
}
if ( pWamProcess )
{
pWamProcess->Release();
pWamProcess = NULL;
}
if ( FAILED( hr ) )
{
*pdwResult = APPSTATUS_Error;
}
return hr;
}
// static
HRESULT
W3_ISAPI_HANDLER::UpdateInprocIsapiHash(
VOID
)
/*++
Routine Description:
Updates the table of InProcessIsapiApps
Arguments:
None
Return Value:
HRESULT
--*/
{
MB mb( g_pW3Server->QueryMDObject() );
W3_INPROC_ISAPI_HASH * pNewTable = NULL;
W3_INPROC_ISAPI_HASH * pOldTable = NULL;
DWORD i;
LPWSTR psz;
HRESULT hr = NOERROR;
LK_RETCODE lkr = LK_SUCCESS;
//
// Allocate a new table and populate it.
//
pNewTable = new W3_INPROC_ISAPI_HASH;
if ( !pNewTable )
{
hr = HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );
goto ErrorExit;
}
if ( !mb.Open( L"/LM/W3SVC/" ) )
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto ErrorExit;
}
if ( !mb.GetMultisz( L"",
MD_IN_PROCESS_ISAPI_APPS,
IIS_MD_UT_SERVER,
&pNewTable->_mszImages) )
{
hr = HRESULT_FROM_WIN32(GetLastError());
mb.Close();
goto ErrorExit;
}
//
// Merge ISAPI filter images into the list
//
AddAllFiltersToMultiSz( mb, &pNewTable->_mszImages );
mb.Close();
//
// Now that we have a complete list, add them to the
// hash table.
//
for ( i = 0, psz = (LPWSTR)pNewTable->_mszImages.First();
psz != NULL;
i++, psz = (LPWSTR)pNewTable->_mszImages.Next( psz ) )
{
W3_INPROC_ISAPI * pNewRecord;
//
// Allocate a new W3_INPROC_ISAPI object and add
// it to the table
//
pNewRecord = new W3_INPROC_ISAPI;
if ( !pNewRecord )
{
hr = HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );
goto ErrorExit;
}
hr = pNewRecord->Create( psz );
if ( FAILED( hr ) )
{
pNewRecord->DereferenceInprocIsapi();
pNewRecord = NULL;
goto ErrorExit;
}
lkr = pNewTable->InsertRecord( pNewRecord, TRUE );
pNewRecord->DereferenceInprocIsapi();
pNewRecord = NULL;
if ( lkr != LK_SUCCESS && lkr != LK_KEY_EXISTS )
{
hr = E_FAIL;
goto ErrorExit;
}
}
//
// Now swap in the new table and delete the old one
//
EnterCriticalSection( &sm_csInprocHashLock );
pOldTable = sm_pInprocIsapiHash;
sm_pInprocIsapiHash = pNewTable;
LeaveCriticalSection( &sm_csInprocHashLock );
if ( pOldTable )
{
delete pOldTable;
}
DBG_ASSERT( SUCCEEDED( hr ) );
return hr;
ErrorExit:
DBG_ASSERT( FAILED( hr ) );
if ( pNewTable )
{
delete pNewTable;
};
return hr;
}
VOID
AddFiltersToMultiSz(
IN const MB & mb,
IN LPCWSTR szFilterPath,
IN OUT MULTISZ * pmsz
)
/*++
Description:
Add the ISAPI filters at the specified metabase path to pmsz.
Called by AddAllFiltersToMultiSz.
Arguments:
mb metabase key open to /LM/W3SVC
szFilterPath path of /Filters key relative to /LM/W3SVC
pmsz multisz containing the in proc dlls
Return:
Nothing - failure cases ignored.
--*/
{
WCHAR szKeyName[MAX_PATH + 1];
STRU strFilterPath;
STRU strFullKeyName;
INT pchFilterPath = wcslen( szFilterPath );
if ( FAILED( strFullKeyName.Copy( szFilterPath ) ) )
{
return;
}
DWORD i = 0;
if( SUCCEEDED( strFullKeyName.Append( L"/", 1 ) ) )
{
while ( const_cast<MB &>(mb).EnumObjects( szFilterPath,
szKeyName,
i++ ) )
{
if( SUCCEEDED( strFullKeyName.Append( szKeyName ) ) )
{
if( const_cast<MB &>(mb).GetStr( strFullKeyName.QueryStr(),
MD_FILTER_IMAGE_PATH,
IIS_MD_UT_SERVER,
&strFilterPath ) )
{
pmsz->Append( strFilterPath );
}
}
strFullKeyName.SetLen( pchFilterPath + 1 );
}
}
}
VOID
AddAllFiltersToMultiSz(
IN const MB & mb,
IN OUT MULTISZ * pmsz
)
/*++
Description:
This is designed to prevent ISAPI extension/filter
combination dlls from running out of process.
Add the base set of filters defined for the service to pmsz.
Iterate through the sites and add the filters defined for
each site.
Arguments:
mb metabase key open to /LM/W3SVC
pmsz multisz containing the in proc dlls
Return:
Nothing - failure cases ignored.
--*/
{
WCHAR szKeyName[MAX_PATH + 1];
STRU strFullKeyName;
DWORD i = 0;
DWORD dwInstanceId = 0;
if ( FAILED( strFullKeyName.Copy( L"/" ) ) )
{
return;
}
AddFiltersToMultiSz( mb, L"/Filters", pmsz );
while ( const_cast<MB &>(mb).EnumObjects( L"",
szKeyName,
i++ ) )
{
dwInstanceId = _wtoi( szKeyName );
if( 0 != dwInstanceId )
{
// This is a site.
if( SUCCEEDED( strFullKeyName.Append( szKeyName ) ) &&
SUCCEEDED( strFullKeyName.Append( L"/Filters" ) ) )
{
AddFiltersToMultiSz( mb, strFullKeyName.QueryStr(), pmsz );
}
strFullKeyName.SetLen( 1 );
}
}
}
Reference in New Issue View Git Blame Copy Permalink