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.
2135 lines
61 KiB
2135 lines
61 KiB
/*-----------------------------------------------------------------------------
|
|
|
|
Copyright (c) 1995-1997 Microsoft Corporation
|
|
|
|
Module Name :
|
|
wamexec.cxx
|
|
|
|
Abstract:
|
|
This module executes a wam request
|
|
|
|
Author:
|
|
David Kaplan ( DaveK ) 11-Mar-1997
|
|
Lei Jin (leijin) 24-Apr-1997 (WamInfo & WamDictator)
|
|
|
|
Environment:
|
|
User Mode - Win32
|
|
|
|
Project:
|
|
W3 services DLL
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
#include <w3p.hxx>
|
|
#include "wamexec.hxx"
|
|
#include "wamreq.hxx"
|
|
#include <wmrgexp.h>
|
|
#include <ole2.h>
|
|
#include <imd.h>
|
|
#include <mb.hxx>
|
|
#include <issched.hxx>
|
|
|
|
#define dwMDDefaultTimeOut 2000
|
|
|
|
#define PERIODIC_RESTART_TIME_DEFAULT 0
|
|
#define PERIODIC_RESTART_REQUESTS_DEFAULT 0
|
|
#define SHUTDOWN_TIME_LIMIT_DEFAULT 600
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
Globals
|
|
-----------------------------------------------------------------------------*/
|
|
WAM_DICTATOR * g_pWamDictator; // global wam dictator
|
|
PFN_INTERLOCKED_COMPARE_EXCHANGE g_pfnInterlockedCompareExchange = NULL;
|
|
static VOID UnloadNTApis(VOID);
|
|
static VOID LoadNTApis(VOID);
|
|
|
|
// Default Package name, defined in wamreg.h, shared by wamreg.dll.
|
|
WCHAR g_szIISInProcWAMCLSID[] = W3_INPROC_WAM_CLSID;
|
|
WCHAR g_szIISOOPPoolWAMCLSID[] = W3_OOP_POOL_WAM_CLSID;
|
|
WCHAR g_szIISOOPPoolPackageID[] = W3_OOP_POOL_PACKAGE_ID;
|
|
// Sink function at wamreg.dll
|
|
// This function will get called when user change application configuration on the fly.
|
|
//
|
|
HRESULT W3SVC_WamRegSink( LPCSTR szAppPath,
|
|
const DWORD dwCommand,
|
|
DWORD* pdwResult
|
|
);
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
CreateWamRequestInstance
|
|
Similar to CoCreateInstance followed by QueryInterface
|
|
|
|
Arguments:
|
|
pHttpRequest - pointer to the HTTP REQUEST object containing all information
|
|
about the current request.
|
|
pExec - Execution descriptor block
|
|
pstrPath - Fully qualified path to Isapi DLL
|
|
pWamInfo - pointer to wam-info which will process this request
|
|
ppWamRequestOut -pointer to a pointer that contains the return WamRequest.
|
|
|
|
Return Value:
|
|
HRESULT
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
CreateWamRequestInstance
|
|
(
|
|
HTTP_REQUEST * pHttpRequest,
|
|
EXEC_DESCRIPTOR * pExec,
|
|
const STR * pstrPath,
|
|
CWamInfo * pWamInfo,
|
|
WAM_REQUEST ** ppWamRequestOut
|
|
)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
WAM_REQUEST * pWamRequest =
|
|
new WAM_REQUEST(
|
|
pHttpRequest
|
|
, pExec
|
|
, pWamInfo
|
|
);
|
|
|
|
*ppWamRequestOut = NULL;
|
|
if( pWamRequest == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto LExit;
|
|
}
|
|
|
|
// Init the wam req
|
|
hr = pWamRequest->InitWamRequest( pstrPath );
|
|
|
|
if ( FAILED( hr ) )
|
|
{
|
|
|
|
DBGPRINTF((
|
|
DBG_CONTEXT
|
|
, "CreateWamRequestInstance - "
|
|
"failed to init wam request. "
|
|
"pHttpRequest(%08x) "
|
|
"pWamInfo(%08x) "
|
|
"pstrPath(%s) "
|
|
"hr(%d) "
|
|
"\n"
|
|
, pHttpRequest
|
|
, pWamInfo
|
|
, pstrPath
|
|
, hr
|
|
));
|
|
|
|
delete pWamRequest;
|
|
pWamRequest = NULL;
|
|
goto LExit;
|
|
|
|
}
|
|
|
|
pWamRequest->AddRef();
|
|
|
|
*ppWamRequestOut = pWamRequest;
|
|
|
|
LExit:
|
|
return hr;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::ProcessWamRequest
|
|
This function finds a WamInfo and makes a call to the WamInfo to process a Http Server
|
|
Extension Request.
|
|
It uses the HTTP_REQUEST passed in as well as the EXEC_DESCRIPTOR.
|
|
|
|
Arguments:
|
|
pHttpRequest - pointer to the HTTP REQUEST object containing all information
|
|
about the current request.
|
|
pExec - Execution descriptor block
|
|
pstrPath - Fully qualified path to Module (DLL or ComIsapi ProgId)
|
|
pfHandled - Indicates we handled this request
|
|
pfFinished - Indicates no further processing is required
|
|
|
|
Return Value:
|
|
HRESULT
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::ProcessWamRequest
|
|
(
|
|
HTTP_REQUEST * pHttpRequest,
|
|
EXEC_DESCRIPTOR * pExec,
|
|
const STR * pstrPath,
|
|
BOOL * pfHandled,
|
|
BOOL * pfFinished
|
|
)
|
|
{
|
|
|
|
HRESULT hr = NOERROR;
|
|
CWamInfo* pWamInfo = NULL;
|
|
STR * pstrAppPath = NULL;
|
|
CLSID clsidWam;
|
|
BOOL fRet = FALSE;
|
|
|
|
DBG_ASSERT(pHttpRequest);
|
|
DBG_ASSERT(pExec);
|
|
|
|
if (m_fShutdownInProgress)
|
|
{
|
|
DBGPRINTF((DBG_CONTEXT, "Wam Dictator: Shut down in progress, stops serving requests.\n"));
|
|
|
|
// Signal the child event to indicate that the request should terminate.
|
|
if ( pExec->IsChild() ) {
|
|
pExec->SetChildEvent();
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
pstrAppPath = pExec->QueryAppPath();
|
|
|
|
if (pstrAppPath == NULL)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
|
|
goto LExit;
|
|
}
|
|
|
|
hr = GetWamInfo( pstrAppPath, pHttpRequest, &pWamInfo );
|
|
if ( FAILED(hr) )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"WAM_DICTATOR::ProcessWamRequest: GetWamInfo failed, hr = %08x\n",
|
|
hr
|
|
));
|
|
|
|
//
|
|
// For Child execution just return the error and don't
|
|
// disconnect, otherwise a race ensues between SSI and the disconnect
|
|
// cleanup
|
|
//
|
|
|
|
if ( pExec->IsChild() )
|
|
{
|
|
SetLastError( hr );
|
|
goto LExit;
|
|
}
|
|
|
|
//
|
|
// Since WAM_DICTATOR is going to send some message to the browser, we need
|
|
// to set pfHandled = TRUE here.
|
|
//
|
|
*pfHandled = TRUE;
|
|
|
|
if (W3PlatformType == PtWindows95)
|
|
{
|
|
pHttpRequest->SetLogStatus( HT_SERVER_ERROR, hr);
|
|
// Win95 platform, no event log, special message without mention EventLog.
|
|
pHttpRequest->Disconnect(HT_SERVER_ERROR, IDS_WAM_FAILTOLOADONW95_ERROR, TRUE, pfFinished);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Log to Event Log first.
|
|
//
|
|
const CHAR *pszEventLog[2];
|
|
CHAR szErrorDescription[2048];
|
|
CHAR * pszErrorDescription = NULL;
|
|
HANDLE hMetabase = GetModuleHandle( "METADATA.DLL" );
|
|
|
|
if(FormatMessage(
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
FORMAT_MESSAGE_FROM_HMODULE |
|
|
FORMAT_MESSAGE_FROM_SYSTEM |
|
|
FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
hMetabase,
|
|
hr,
|
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
(LPTSTR) &pszErrorDescription,
|
|
sizeof(szErrorDescription) - 1,
|
|
NULL
|
|
) && pszErrorDescription )
|
|
{
|
|
strcpy(szErrorDescription, pszErrorDescription);
|
|
LocalFree(pszErrorDescription);
|
|
|
|
} else {
|
|
wsprintf(szErrorDescription, "%08x", hr);
|
|
}
|
|
|
|
pszEventLog[0] = pstrAppPath->QueryStr();
|
|
pszEventLog[1] = szErrorDescription;
|
|
// Event log
|
|
g_pInetSvc->LogEvent(W3_EVENT_FAIL_LOADWAM,
|
|
2,
|
|
pszEventLog,
|
|
0);
|
|
|
|
pHttpRequest->SetLogStatus( HT_SERVER_ERROR, hr);
|
|
pHttpRequest->Disconnect(HT_SERVER_ERROR, IDS_WAM_FAILTOLOAD_ERROR, TRUE, pfFinished);
|
|
}
|
|
//
|
|
// Since we already called Disconnect, WAM_DICTATOR should return TRUE to high level.
|
|
//
|
|
hr = NOERROR;
|
|
goto LExit;
|
|
}
|
|
|
|
hr = pWamInfo->ProcessWamRequest(pHttpRequest, pExec, pstrPath, pfHandled,pfFinished);
|
|
|
|
LExit:
|
|
return hr;
|
|
} // WAM_DICTATOR::ProcessWamRequest()
|
|
|
|
/*-----------------------------------------------------------------------------*
|
|
WAM_DICTATOR::WAM_DICTATOR
|
|
Constructor
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Return Value:
|
|
None
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
WAM_DICTATOR::WAM_DICTATOR
|
|
(
|
|
)
|
|
:
|
|
//m_pPackageCtl(NULL),
|
|
m_cRef(0),
|
|
m_pMetabase(NULL),
|
|
m_fCleanupInProgress(FALSE),
|
|
m_fShutdownInProgress(FALSE),
|
|
m_hW3Svc ( (HANDLE)NULL ),
|
|
m_dwScheduledId (0),
|
|
m_strRootAppPath("/LM/W3SVC"),
|
|
m_HashTable(LK_DFLT_MAXLOAD, LK_DFLT_INITSIZE, LK_DFLT_NUM_SUBTBLS),
|
|
m_pidInetInfo(0)
|
|
{
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((DBG_CONTEXT, "WAM_DICTATOR::WAM_DICTATOR\n"));
|
|
|
|
InitializeListHead(&m_DyingListHead);
|
|
|
|
INITIALIZE_CRITICAL_SECTION(&m_csWamCreation);
|
|
INITIALIZE_CRITICAL_SECTION(&m_csDyingList);
|
|
|
|
m_PTable.Init();
|
|
//
|
|
// Init wamreq allocation cache
|
|
//
|
|
|
|
DBG_REQUIRE( WAM_REQUEST::InitClass() );
|
|
|
|
}//WAM_DICTATOR::WAM_DICTATOR
|
|
|
|
|
|
/*-----------------------------------------------------------------------------*
|
|
WAM_DICTATOR::~WAM_DICTATOR
|
|
Destructor
|
|
|
|
Arguments:
|
|
None
|
|
// (only interesting if out of process)
|
|
Return Value:
|
|
None
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
WAM_DICTATOR::~WAM_DICTATOR
|
|
(
|
|
)
|
|
{
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((DBG_CONTEXT, "WAM_DICTATOR::~WAM_DICTATOR\n"));
|
|
|
|
DBG_ASSERT(m_cRef == 0);
|
|
|
|
DeleteCriticalSection(&m_csWamCreation);
|
|
DeleteCriticalSection(&m_csDyingList);
|
|
|
|
m_PTable.UnInit();
|
|
//
|
|
// Uninit wamreq allocation cache
|
|
//
|
|
WAM_REQUEST::CleanupClass();
|
|
}//WAM_DICTATOR::~WAMDICTATOR
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::InitWamDictator
|
|
Initializes Wam dictator
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Return Value:
|
|
HRESULT
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::InitWamDictator
|
|
(
|
|
)
|
|
{
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((DBG_CONTEXT, "WAM_DICTATOR::InitWamDictator\n"));
|
|
|
|
HRESULT hr = NOERROR;
|
|
IMDCOM * pMetabase;
|
|
|
|
|
|
DBG_ASSERT(g_pInetSvc->QueryMDObject());
|
|
|
|
m_pMetabase = new MB( (IMDCOM*) g_pInetSvc->QueryMDObject() );
|
|
if (m_pMetabase == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto LExit;
|
|
}
|
|
|
|
// Save the handle of the W3Svc process for use when copying tokens to out of proc Wam's
|
|
// NOTE: this is actually a "pseudo-handle", which is good enough. Note that pseudo-handles
|
|
// do NOT need to be closed. CloseHandle is a no-op on a pseudo-handle.
|
|
m_hW3Svc = GetCurrentProcess();
|
|
|
|
|
|
//
|
|
// Get the process id for inetinfo. Under some circumstances com
|
|
// svcs my get hosed. This causes object activation to happen in
|
|
// process even if the object is registered to be launched in the
|
|
// surrogate. In order to prevent inetinfo from AV'ing we want to
|
|
// prevent these applications from running.
|
|
//
|
|
m_pidInetInfo = GetCurrentProcessId();
|
|
|
|
DBG_REQUIRE( m_ServerVariableMap.Initialize() );
|
|
|
|
// Register the Sink function at WamReg.
|
|
WamReg_RegisterSinkNotify(W3SVC_WamRegSink);
|
|
|
|
LoadNTApis();
|
|
|
|
// Make the reference count to 1.
|
|
Reference();
|
|
LExit:
|
|
return hr;
|
|
}//WAM_DICTATOR::InitWamDictator
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::
|
|
|
|
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
LK_PREDICATE
|
|
WAM_DICTATOR::DeleteInShutdown
|
|
(
|
|
CWamInfo* pWamInfo,
|
|
void* pvState
|
|
)
|
|
{
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((DBG_CONTEXT, "WAM_DICTATOR::DeleteInShutdown\n"));
|
|
|
|
DWORD dwPriorState;
|
|
|
|
dwPriorState = pWamInfo->ChangeToState(WIS_SHUTDOWN);
|
|
|
|
DBGPRINTF((DBG_CONTEXT, "Start shutdown, change state to WIS_SHUTDOWN\n"));
|
|
DBG_REQUIRE(dwPriorState == WIS_RUNNING || dwPriorState == WIS_PAUSE || dwPriorState == WIS_CPUPAUSE);
|
|
|
|
// remove from the hash table here. and clean up later.
|
|
g_pWamDictator->InsertDyingList(pWamInfo, TRUE);
|
|
|
|
return LKP_PERFORM;
|
|
}//WAM_DICTATOR::DeleteInShutdown
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::StartShutdown
|
|
Starts to shutdown Wam dictator
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Return Value:
|
|
HRESULT
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::StartShutdown
|
|
(
|
|
)
|
|
{
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((DBG_CONTEXT, "WAM_DICTATOR::StartShutdown\n"));
|
|
|
|
HRESULT hr = NOERROR;
|
|
CWamInfo* pWamInfo;
|
|
DWORD dwErr;
|
|
DWORD dwPriorState;
|
|
|
|
InterlockedExchange((LPLONG)&m_fShutdownInProgress, (LONG)TRUE);
|
|
|
|
WamReg_UnRegisterSinkNotify();
|
|
|
|
m_HashTable.DeleteIf(DeleteInShutdown, NULL);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------*
|
|
WAM_DICTATOR::UninitWamDictator
|
|
Un-initializes Wam dictator
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Return Value:
|
|
HRESULT
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::UninitWamDictator
|
|
(
|
|
)
|
|
{
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((DBG_CONTEXT, "WAM_DICTATOR::UninitWamDictator\n"));
|
|
|
|
HRESULT hr = NOERROR;
|
|
|
|
// UNDONE leijin thinks we can get rid of this RemoveWorkItem code???
|
|
ScheduledId_Lock();
|
|
if (m_dwScheduledId != 0)
|
|
{
|
|
DBGPRINTF((DBG_CONTEXT, "remove work item %d\n", m_dwScheduledId));
|
|
// Cancel the ScheduleWorkItem
|
|
RemoveWorkItem(m_dwScheduledId);
|
|
m_dwScheduledId = 0;
|
|
}
|
|
ScheduledId_UnLock();
|
|
DBG_ASSERT(m_dwScheduledId == 0);
|
|
|
|
// Clean up the dying list.
|
|
CleanUpDyingList();
|
|
|
|
// After the CleanUpDyingList() call, this should be an empty list.
|
|
//
|
|
DBG_ASSERT(IsListEmpty(&m_DyingListHead));
|
|
|
|
//
|
|
// Allow all other references to WAM_DICTATOR to drain away.
|
|
// This loop is especially important in shutdown during stress scenario.
|
|
// Unload Application while w3svc is still running, a busy application might
|
|
// still have some outstanding HTTPREQUEST unfinished which hold the reference to
|
|
// this WAM_DICTATOR.
|
|
//
|
|
while (m_cRef != 1)
|
|
{
|
|
DBGPRINTF((DBG_CONTEXT, "Still have out-standing reference(%d) to this WAM_DICTATOR\n",
|
|
m_cRef));
|
|
Sleep(20);
|
|
}
|
|
|
|
// Delete m_pMetabase
|
|
// pMetabase should be there
|
|
DBG_REQUIRE(m_pMetabase);
|
|
delete m_pMetabase;
|
|
m_pMetabase = NULL;
|
|
|
|
UnloadNTApis();
|
|
|
|
//
|
|
// Dereference to balance the reference in InitWamDictator. after
|
|
// this Dereference, ref count of WAM_DICTATOR should be 0.
|
|
//
|
|
Dereference();
|
|
DBGPRINTF((DBG_CONTEXT, "Wam Dictator Exits.\n"));
|
|
return hr;
|
|
}//WAM_DICTATOR::UninitWamDictator
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::MDGetAppVariables
|
|
|
|
Giving a Metabase Path, find out the Application Path, WAM CLSID, and Context of WAM object of
|
|
the application that apply to the metabase path.
|
|
|
|
Argument:
|
|
szMetabasePath: [in] A metabase path.
|
|
pfAllowApptoRun: [out] True, if application is enabled to run.
|
|
pclsidWam: [out] a pointer to the buffer for WAM CLSID
|
|
pfInProcess: [out] a pointer to DWORD for Context
|
|
pfEnableTryExcept [out] a pointer to DWORD for EnableTryExcept flag
|
|
|
|
Return:
|
|
HRESULT
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::MDGetAppVariables
|
|
(
|
|
LPCSTR szMetabasePath,
|
|
BOOL* pfAllowAppToRun,
|
|
CLSID* pclsidWam,
|
|
BOOL* pfInProcess,
|
|
BOOL* pfInPool,
|
|
BOOL* pfEnableTryExcept,
|
|
DWORD *pdwOOPCrashThreshold,
|
|
BOOL* pfJobEnabled,
|
|
WCHAR* wszPackageID,
|
|
DWORD* pdwPeriodicRestartRequests,
|
|
DWORD* pdwPeriodicRestartTime,
|
|
MULTISZ*pmszPeriodicRestartSchedule,
|
|
DWORD* pdwShutdownTimeLimit
|
|
)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
METADATA_RECORD recMetaData;
|
|
DWORD dwRequiredLen;
|
|
CHAR szclsidWam[uSizeCLSIDStr];
|
|
WCHAR wszclsidWam[uSizeCLSIDStr];
|
|
BOOL fKeyOpen = FALSE;
|
|
DWORD dwAppMode = 0;
|
|
BOOL fEnableTryExcept = TRUE;
|
|
DWORD dwAppState = 0;
|
|
|
|
DBG_ASSERT(szMetabasePath);
|
|
DBG_ASSERT(pfAllowAppToRun);
|
|
DBG_ASSERT(pclsidWam);
|
|
DBG_ASSERT(pfInProcess);
|
|
DBG_ASSERT(pfInPool);
|
|
DBG_ASSERT(pfEnableTryExcept);
|
|
DBG_ASSERT(pdwOOPCrashThreshold);
|
|
DBG_ASSERT(pfJobEnabled);
|
|
DBG_ASSERT(m_pMetabase);
|
|
DBG_ASSERT(wszPackageID);
|
|
DBG_ASSERT(pdwPeriodicRestartRequests);
|
|
DBG_ASSERT(pdwPeriodicRestartTime);
|
|
DBG_ASSERT(pmszPeriodicRestartSchedule);
|
|
DBG_ASSERT(pdwShutdownTimeLimit);
|
|
|
|
wszPackageID[0] = L'\0';
|
|
// Open Key
|
|
if (!m_pMetabase->Open(szMetabasePath, METADATA_PERMISSION_READ))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
goto LErrExit;
|
|
}
|
|
fKeyOpen = TRUE;
|
|
|
|
// if MD_APP_STATE exists, and is defined with a value APPSTATUS_PAUSE,
|
|
// then, fAllowAppToRun is set to FALSE
|
|
// otherwise, fAllowAppToRun is set to TRUE
|
|
if (m_pMetabase->GetDword("", MD_APP_STATE, IIS_MD_UT_WAM, (DWORD *)&dwAppState, METADATA_INHERIT))
|
|
{
|
|
if (dwAppState == APPSTATUS_PAUSE)
|
|
{
|
|
*pfAllowAppToRun = FALSE;
|
|
goto LErrExit;
|
|
}
|
|
}
|
|
|
|
*pfAllowAppToRun = TRUE;
|
|
if (!m_pMetabase->GetDword("", MD_APP_ISOLATED, IIS_MD_UT_WAM, &dwAppMode, METADATA_INHERIT))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
goto LErrExit;
|
|
}
|
|
|
|
*pfInProcess = ( dwAppMode == eAppInProc) ? TRUE : FALSE;
|
|
*pfInPool = ( dwAppMode == eAppInProc || dwAppMode == eAppOOPPool ) ? TRUE : FALSE;
|
|
|
|
if (dwAppMode == eAppOOPIsolated)
|
|
{
|
|
DWORD dwRet = 0;
|
|
CHAR szPackageID[uSizeCLSIDStr];
|
|
|
|
//
|
|
// Disable job objects for IIS5.1, original code would read the MD_CPU_APP_ENABLED
|
|
// property from metabase
|
|
//
|
|
*pfJobEnabled = FALSE;
|
|
|
|
dwRequiredLen= uSizeCLSIDStr;
|
|
if (!m_pMetabase->GetString("", MD_APP_PACKAGE_ID, IIS_MD_UT_WAM, szPackageID, &dwRequiredLen, METADATA_INHERIT))
|
|
{
|
|
DBG_ASSERT(dwRequiredLen <= uSizeCLSIDStr);
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
goto LErrExit;
|
|
}
|
|
|
|
dwRet = MultiByteToWideChar(CP_ACP, 0, szPackageID, -1, wszPackageID, uSizeCLSIDStr);
|
|
DBG_ASSERT(dwRet != 0);
|
|
}
|
|
else if (dwAppMode == eAppOOPPool)
|
|
{
|
|
wcsncpy(wszPackageID, g_szIISOOPPoolPackageID, sizeof(g_szIISOOPPoolPackageID)/sizeof(WCHAR));
|
|
// Always disable Job object for pool process.
|
|
*pfJobEnabled = FALSE;
|
|
}
|
|
else
|
|
{
|
|
*pfJobEnabled = FALSE;
|
|
}
|
|
|
|
|
|
// If not present assume the default (TRUE) (For Debug builds set default to FALSE)
|
|
if (m_pMetabase->GetDword("", MD_ASP_EXCEPTIONCATCHENABLE, ASP_MD_UT_APP, (DWORD *)&fEnableTryExcept, METADATA_INHERIT))
|
|
{
|
|
*pfEnableTryExcept = fEnableTryExcept ? TRUE : FALSE;
|
|
}
|
|
else
|
|
{
|
|
#if DBG
|
|
*pfEnableTryExcept = FALSE;
|
|
#else
|
|
*pfEnableTryExcept = TRUE;
|
|
#endif
|
|
}
|
|
|
|
DWORD dwThreshold;
|
|
|
|
if (dwAppMode == eAppInProc)
|
|
{
|
|
hr = CLSIDFromString((LPOLESTR) g_szIISInProcWAMCLSID, (LPCLSID)pclsidWam);
|
|
}
|
|
else if (dwAppMode == eAppOOPPool)
|
|
{
|
|
hr = CLSIDFromString((LPOLESTR) g_szIISOOPPoolWAMCLSID, (LPCLSID)pclsidWam);
|
|
|
|
*pdwOOPCrashThreshold = 0XFFFFFFFF;
|
|
}
|
|
else
|
|
{
|
|
if (m_pMetabase->GetDword("", MD_APP_OOP_RECOVER_LIMIT, IIS_MD_UT_WAM, (DWORD *)&dwThreshold, METADATA_INHERIT))
|
|
{
|
|
// It used to be OOP_CRASH_LIMIT (range 1 - 5)
|
|
// Now, the name is changed to RECOVER_LIMIT with range of (0-xxx).
|
|
// 0 means no recovery, same as 1 in crash limit, 1 crash, and it's over, (0 recovery).
|
|
// Add 1 because internally this threshold is implemented in crash_limit concept.
|
|
// 0xFFFFFFFF is unlimited.
|
|
|
|
// Changed to default to unlimited - Bug 240012. The idea of making this time
|
|
// dependent seems much smarter than making it infinite. But no one was willing
|
|
// to step up and decide what the right parameters were.
|
|
if (dwThreshold != 0xFFFFFFFF)
|
|
{
|
|
dwThreshold++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dwThreshold = APP_OOP_RECOVER_LIMIT_DEFAULT;
|
|
}
|
|
|
|
*pdwOOPCrashThreshold = dwThreshold;
|
|
|
|
dwRequiredLen= uSizeCLSIDStr;
|
|
if (!m_pMetabase->GetString("", MD_APP_WAM_CLSID, IIS_MD_UT_WAM, szclsidWam, &dwRequiredLen, METADATA_INHERIT))
|
|
{
|
|
DBG_ASSERT(dwRequiredLen <= uSizeCLSIDStr);
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
goto LErrExit;
|
|
}
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, szclsidWam, -1, wszclsidWam, uSizeCLSIDStr);
|
|
|
|
hr = CLSIDFromString((LPOLESTR)wszclsidWam, (LPCLSID)pclsidWam);
|
|
}
|
|
|
|
if ( dwAppMode != eAppInProc )
|
|
{
|
|
//
|
|
// Get the application recycle settings
|
|
//
|
|
|
|
//
|
|
// Disable wam recycling for IIS5.1, original code would read these properties
|
|
// from metabase
|
|
//
|
|
*pdwPeriodicRestartTime = PERIODIC_RESTART_TIME_DEFAULT;
|
|
|
|
*pdwPeriodicRestartRequests = PERIODIC_RESTART_REQUESTS_DEFAULT;
|
|
|
|
*pdwShutdownTimeLimit = SHUTDOWN_TIME_LIMIT_DEFAULT;
|
|
|
|
pmszPeriodicRestartSchedule->Reset();
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
goto LErrExit;
|
|
|
|
LErrExit:
|
|
|
|
if (fKeyOpen)
|
|
{
|
|
m_pMetabase->Close();
|
|
}
|
|
|
|
return hr;
|
|
}//WAM_DICTATOR::MDGetAppVariables
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::GetWamInfo
|
|
Returns the interface pointer for a wam, NULL if wam not found
|
|
|
|
Arguments:
|
|
pstrPath [in] wam key: path to extension dll, prog id, etc.
|
|
fInProc [in] run the wam in-proc?
|
|
ppIWam [out] interface pointer for the wam
|
|
|
|
Return Value:
|
|
TRUE or FALSE
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::GetWamInfo
|
|
(
|
|
const STR* pstrAppPath,
|
|
const HTTP_REQUEST * pHttpRequest,
|
|
CWamInfo ** ppWamInfo
|
|
)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
INT AppState;
|
|
CWamInfo* pWamInfo = NULL;
|
|
|
|
DBG_ASSERT(pstrAppPath);
|
|
|
|
AppState = FindWamInfo(pstrAppPath, &pWamInfo);
|
|
if (-1 == AppState)
|
|
{
|
|
//
|
|
// Lock the Creation process
|
|
// to avoid multiple threads try to create the same WAMInfo,
|
|
// (init WAM object, very expensive in out-proc cases)
|
|
//
|
|
CreateWam_Lock();
|
|
|
|
//
|
|
// Try to find it again, in case another thread already created it.
|
|
// This check is better that creating another WamInfo.
|
|
//
|
|
AppState = FindWamInfo(pstrAppPath, &pWamInfo);
|
|
if (-1 == AppState)
|
|
{
|
|
//
|
|
// We are out of luck in our search for a valid Wam Info
|
|
// Let us just create a new one and make it happen.
|
|
// Note: Creation also adds the WamInfo to the hashtable
|
|
//
|
|
DBG_ASSERT(pHttpRequest != NULL);
|
|
hr = CreateWamInfo( *pstrAppPath, &pWamInfo, pHttpRequest->QueryW3Instance());
|
|
}
|
|
CreateWam_UnLock();
|
|
}
|
|
|
|
if (m_fShutdownInProgress && pWamInfo != NULL)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_SHUTDOWN_IN_PROGRESS);
|
|
pWamInfo->Dereference();
|
|
pWamInfo = NULL;
|
|
}
|
|
|
|
*ppWamInfo = pWamInfo;
|
|
return hr;
|
|
}//WAM_DICTATOR::GetWamInfo
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
|
|
WAM_DICTATOR::CreateWamInfo()
|
|
|
|
Description:
|
|
Creates a new CWamInfo object for the specified application root path.
|
|
On successful creation, it adds the object to the hash table internal
|
|
to the WAM_DICTATOR that contains the active WamInfos.
|
|
Finally, it returns the object via the pointer supplied.
|
|
|
|
Arguments:
|
|
strAppRootPath - string containing the metabase path for for the
|
|
Application Root
|
|
ppWamInfo - pointer to pointer to CWamInfo object. On successful
|
|
return this contains the pointer to the new
|
|
created CWamInfo
|
|
|
|
Returns:
|
|
HRESULT
|
|
NOERROR - on success
|
|
and specific error codes on failure
|
|
|
|
Note:
|
|
This function should be called with the WAM_DICTATOR WamInfo lock held.
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::CreateWamInfo
|
|
(
|
|
const STR & strAppRootPath,
|
|
CWamInfo ** ppWamInfo,
|
|
PW3_SERVER_INSTANCE pwsiInstance
|
|
)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
CLSID clsidWam;
|
|
BOOL fInProcess;
|
|
BOOL fEnableTryExcept;
|
|
CWamInfo * pWamInfo;
|
|
DWORD dwThreshold; // OOP crash threshold
|
|
BOOL fAllowAppToRun;
|
|
BOOL fJobEnabled;
|
|
BOOL fInPool;
|
|
WCHAR wszPackageID[uSizeCLSIDStr];
|
|
DWORD dwPeriodicRestartRequests;
|
|
DWORD dwPeriodicRestartTime;
|
|
DWORD dwShutdownTimeLimit;
|
|
MULTISZ mzPeriodicRestartSchedule;
|
|
|
|
DBG_ASSERT( NULL != ppWamInfo );
|
|
DBG_ASSERT( NULL == *ppWamInfo);
|
|
|
|
// Get the latest Application path, CLSID, and inproc/out-of-proc flag
|
|
hr = MDGetAppVariables(strAppRootPath.QueryStr(),
|
|
&fAllowAppToRun,
|
|
&clsidWam,
|
|
&fInProcess,
|
|
&fInPool,
|
|
&fEnableTryExcept,
|
|
&dwThreshold,
|
|
&fJobEnabled,
|
|
wszPackageID,
|
|
&dwPeriodicRestartRequests,
|
|
&dwPeriodicRestartTime,
|
|
&mzPeriodicRestartSchedule,
|
|
&dwShutdownTimeLimit
|
|
);
|
|
|
|
if ( SUCCEEDED( hr) && fAllowAppToRun)
|
|
{
|
|
//
|
|
// Create a New CWamInfo
|
|
//
|
|
if (fInProcess)
|
|
{
|
|
pWamInfo = new CWamInfo( strAppRootPath,
|
|
fInProcess,
|
|
fInPool,
|
|
fEnableTryExcept,
|
|
clsidWam
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Check to see if we have scheduled restart times. If so,
|
|
// set the restart time to the earlier of the configured
|
|
// restart time, or the earliest scheduled time.
|
|
//
|
|
|
|
if ( mzPeriodicRestartSchedule.QueryStringCount() )
|
|
{
|
|
SYSTEMTIME st;
|
|
DWORD dwTimeOfDayInMinutes;
|
|
DWORD dwScheduleInMinutes;
|
|
LPSTR szHour;
|
|
LPSTR szMinute;
|
|
|
|
GetLocalTime( &st );
|
|
dwTimeOfDayInMinutes = st.wHour * 60 + st.wMinute;
|
|
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((
|
|
DBG_CONTEXT,
|
|
"Current Time is %d.\r\n",
|
|
dwTimeOfDayInMinutes
|
|
));
|
|
|
|
szHour = mzPeriodicRestartSchedule.QueryStrA();
|
|
|
|
DBG_ASSERT( szHour );
|
|
|
|
while ( *szHour )
|
|
{
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((
|
|
DBG_CONTEXT,
|
|
"Considering recycle at %s.\r\n",
|
|
szHour
|
|
));
|
|
|
|
szMinute = strchr( szHour, ':' );
|
|
|
|
if ( !szMinute )
|
|
{
|
|
//
|
|
// Parsing error - hour and minute not separated
|
|
// by a ':'
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
szMinute++;
|
|
|
|
dwScheduleInMinutes = atol( szHour ) * 60;
|
|
dwScheduleInMinutes += atol( szMinute );
|
|
|
|
if ( dwScheduleInMinutes <= dwTimeOfDayInMinutes )
|
|
{
|
|
dwScheduleInMinutes += 24 * 60;
|
|
}
|
|
|
|
dwScheduleInMinutes -= dwTimeOfDayInMinutes;
|
|
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((
|
|
DBG_CONTEXT,
|
|
"Scheduled time is %d minutes from now.\r\n",
|
|
dwScheduleInMinutes
|
|
));
|
|
|
|
//
|
|
// If the scheduled time is earlier than the current
|
|
// dwPeriodicRestartTime, then replace the existing
|
|
// value.
|
|
//
|
|
|
|
if ( dwScheduleInMinutes < dwPeriodicRestartTime ||
|
|
dwPeriodicRestartTime == 0 )
|
|
{
|
|
dwPeriodicRestartTime = dwScheduleInMinutes;
|
|
}
|
|
|
|
szHour += strlen( szHour ) + 1;
|
|
}
|
|
}
|
|
|
|
if ( dwPeriodicRestartRequests || dwPeriodicRestartTime )
|
|
{
|
|
DBGPRINTF((
|
|
DBG_CONTEXT,
|
|
"Recycling will occur in %d minutes. or when %d requests have been served.\r\n",
|
|
dwPeriodicRestartTime,
|
|
dwPeriodicRestartRequests
|
|
));
|
|
}
|
|
|
|
pWamInfo = new CWamInfoOutProc(strAppRootPath,
|
|
fInProcess,
|
|
fInPool,
|
|
fEnableTryExcept,
|
|
clsidWam,
|
|
dwThreshold,
|
|
pwsiInstance,
|
|
fJobEnabled,
|
|
dwPeriodicRestartRequests,
|
|
dwPeriodicRestartTime,
|
|
dwShutdownTimeLimit
|
|
);
|
|
}
|
|
|
|
if (pWamInfo)
|
|
{
|
|
//
|
|
// This is WAM_DICTATOR's reference on the CWamInfo. In "normal"
|
|
// operations, this will be the last reference.
|
|
//
|
|
|
|
pWamInfo->Reference();
|
|
|
|
BOOL fInitialize = (fInProcess || !fJobEnabled || !pwsiInstance->AreProcsCPUStopped());
|
|
if (fInitialize)
|
|
{
|
|
//
|
|
//Init the CWamInfo. this call will CoCreateInstance WAM object.
|
|
//
|
|
hr = pWamInfo->Init( wszPackageID, m_pidInetInfo );
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pWamInfo->ChangeToState(WIS_RUNNING);
|
|
}
|
|
else
|
|
{
|
|
pWamInfo->UnInit();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pWamInfo->ChangeToState(WIS_CPUPAUSE);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
|
|
if ( LK_SUCCESS != m_HashTable.InsertRecord(pWamInfo))
|
|
{
|
|
if (fInitialize)
|
|
{
|
|
pWamInfo->UnInit();
|
|
}
|
|
pWamInfo->Dereference(); // should be last reference
|
|
//delete pWamInfo;
|
|
hr = E_FAIL; // NYI: What is the right failure code?
|
|
}
|
|
else
|
|
{
|
|
|
|
//
|
|
// Finally we are successful with a valid WAmInfo.
|
|
// Return this. Will be balanced by a DeleteRecord
|
|
// in CProcessTable::RemoveWamInfoFromProcessTable
|
|
//
|
|
pWamInfo->Reference();
|
|
*ppWamInfo = pWamInfo;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DBG_ASSERT( NOERROR != hr);
|
|
pWamInfo->Dereference();
|
|
//delete pWamInfo;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// pWamInfo == NULL
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_SERVER_DISABLED);
|
|
*ppWamInfo = NULL;
|
|
}
|
|
//
|
|
// NYI: Isn't pstrNewPath going away?
|
|
// Should I bother deleting pstrNewPath ??
|
|
//
|
|
}
|
|
|
|
//
|
|
// Either we should be returning an error or send back the proper pointer
|
|
//
|
|
DBG_ASSERT( (hr != NOERROR) || (*ppWamInfo != NULL));
|
|
|
|
return ( hr);
|
|
} // WAM_DICTATOR::CreateWamInfo()
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::FindWamInfo
|
|
Returns the interface pointer for a wam, NULL if wam not found
|
|
|
|
Arguments:
|
|
pstrPath - [in] wam key: path to extension dll, prog id, etc.
|
|
ppIWam - [out] interface pointer for the wam
|
|
|
|
Return Value:
|
|
TRUE or FALSE
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
INT
|
|
WAM_DICTATOR::FindWamInfo
|
|
(
|
|
const STR* pstrMetabasePath,
|
|
CWamInfo** ppWamInfo
|
|
)
|
|
{
|
|
INT AppState = -1;
|
|
CWamInfo* pWamInfo = NULL;
|
|
char* pszKey;
|
|
|
|
DBG_ASSERT(pstrMetabasePath);
|
|
DBG_ASSERT(ppWamInfo);
|
|
|
|
pszKey = pstrMetabasePath->QueryStr();
|
|
|
|
HashReadLock();
|
|
m_HashTable.FindKey(pszKey, &pWamInfo);
|
|
HashReadUnlock();
|
|
|
|
if (pWamInfo)
|
|
{
|
|
AppState = pWamInfo->QueryState();
|
|
|
|
DBG_ASSERT(AppState != WIS_START || AppState != WIS_END);
|
|
}
|
|
|
|
*ppWamInfo = pWamInfo;
|
|
return AppState;
|
|
}//WAM_DICTATOR::FindWamInfo
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::UnLoadWamInfo
|
|
Unload an OOP Wam.
|
|
|
|
Arguments:
|
|
pstrWamPath - [in] wam key: path to extension dll, prog id, etc.
|
|
fCPUPause - [in] If true, CPU pauses the WAM. Kills the process
|
|
but keeps the info around.
|
|
pfAppCpuUnloaded - [out] If nonNULL, set to TRUE iff an app was killed.
|
|
|
|
Return Value:
|
|
|
|
HRESULT - Error code.
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::UnLoadWamInfo
|
|
(
|
|
STR *pstrAppPath,
|
|
BOOL fCPUPause,
|
|
BOOL *pfAppCpuUnloaded
|
|
)
|
|
{
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((DBG_CONTEXT, "WAM_DICTATOR::UnLoadWamInfo\n"));
|
|
|
|
int iAppState;
|
|
CWamInfo* pWamInfo = NULL;
|
|
DWORD eWISPrevState;
|
|
DWORD eWISState;
|
|
HRESULT hr = NOERROR;
|
|
BOOL fInProc;
|
|
BOOL fAppCpuUnloaded = FALSE;
|
|
|
|
CreateWam_Lock();
|
|
|
|
iAppState = FindWamInfo(pstrAppPath,
|
|
&pWamInfo);
|
|
|
|
CreateWam_UnLock();
|
|
|
|
if (iAppState != -1)
|
|
{
|
|
bool fRet = FALSE;
|
|
|
|
CProcessEntry* pProcEntry = NULL;
|
|
|
|
|
|
fInProc = pWamInfo->FInProcess();
|
|
pProcEntry = pWamInfo->QueryProcessEntry();
|
|
DBG_ASSERT(pProcEntry != NULL);
|
|
|
|
pProcEntry->AddRef();
|
|
|
|
while (pWamInfo != NULL)
|
|
{
|
|
eWISState = (fCPUPause == TRUE) ? WIS_CPUPAUSE : WIS_SHUTDOWN;
|
|
eWISPrevState = pWamInfo->ChangeToState(WIS_RUNNING, eWISState);
|
|
//
|
|
// Terminate process and kill off current requests.
|
|
//
|
|
|
|
if (WIS_RUNNING == eWISPrevState)
|
|
{
|
|
DBG_ASSERT(pWamInfo->HWamProcess() != NULL);
|
|
|
|
hr = ShutdownWamInfo(pWamInfo,
|
|
HASH_TABLE_REF + FIND_KEY_REF
|
|
);
|
|
|
|
if (!fCPUPause)
|
|
{
|
|
LK_RETCODE LkReturn;
|
|
|
|
LkReturn = m_HashTable.DeleteKey(
|
|
pWamInfo->QueryApplicationPath().QueryStr());
|
|
DBG_ASSERT(LK_SUCCESS == LkReturn);
|
|
//
|
|
// Release FIND_KEY_REF
|
|
//
|
|
pWamInfo->Dereference();
|
|
if (LK_SUCCESS == LkReturn)
|
|
{
|
|
pWamInfo->Dereference();
|
|
//delete pWamInfo;
|
|
pWamInfo = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Application is running. Kill It
|
|
//
|
|
DBG_ASSERT(!pWamInfo->FInProcess());
|
|
//
|
|
// Get rid of the shutting down flag
|
|
//
|
|
pWamInfo->ClearMembers();
|
|
//
|
|
// Release FIND_KEY_REF
|
|
//
|
|
pWamInfo->Dereference();
|
|
|
|
fAppCpuUnloaded = TRUE;
|
|
|
|
}
|
|
}
|
|
|
|
if (fInProc)
|
|
{
|
|
pWamInfo = NULL;
|
|
}
|
|
else
|
|
{
|
|
fRet = m_PTable.FindWamInfo(pProcEntry,&pWamInfo);
|
|
DBG_ASSERT(fRet == TRUE);
|
|
}
|
|
}
|
|
|
|
pProcEntry->Release();
|
|
}
|
|
|
|
if (pfAppCpuUnloaded != NULL) {
|
|
*pfAppCpuUnloaded = fAppCpuUnloaded;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::CPUResumeWamInfo
|
|
Resumes a CPU Paused OOP Wam.
|
|
|
|
Arguments:
|
|
pstrWamPath - [in] wam key: path to extension dll, prog id, etc.
|
|
|
|
Return Value:
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
VOID
|
|
WAM_DICTATOR::CPUResumeWamInfo
|
|
(
|
|
STR *pstrWamPath
|
|
)
|
|
{
|
|
int iAppState;
|
|
CWamInfo* pWICurrentApplication = NULL;
|
|
DWORD eWISPrevState;
|
|
CLSID clsidWam;
|
|
BOOL fInProcess;
|
|
BOOL fInPool;
|
|
BOOL fEnableTryExcept;
|
|
DWORD dwThreshold; // OOP crash threshold
|
|
BOOL fAllowAppToRun;
|
|
BOOL fJobEnabled;
|
|
WCHAR wszPackageID[uSizeCLSIDStr];
|
|
DWORD dwPeriodicRestartRequests;
|
|
DWORD dwPeriodicRestartTime;
|
|
DWORD dwShutdownTimeLimit;
|
|
MULTISZ mzPeriodicRestartSchedule;
|
|
HRESULT hr;
|
|
|
|
|
|
CreateWam_Lock();
|
|
|
|
iAppState = FindWamInfo(pstrWamPath,
|
|
&pWICurrentApplication);
|
|
|
|
CreateWam_UnLock();
|
|
|
|
if (iAppState != -1)
|
|
{
|
|
// Application may not be loaded. This method is called for every
|
|
// application defined under the site being paused.
|
|
|
|
// Get the latest Application path, CLSID, and inproc/out-of-proc flag
|
|
hr = MDGetAppVariables(pWICurrentApplication->QueryApplicationPath().QueryStr(),
|
|
&fAllowAppToRun,
|
|
&clsidWam,
|
|
&fInProcess,
|
|
&fInPool,
|
|
&fEnableTryExcept,
|
|
&dwThreshold,
|
|
&fJobEnabled,
|
|
wszPackageID,
|
|
&dwPeriodicRestartRequests,
|
|
&dwPeriodicRestartTime,
|
|
&mzPeriodicRestartSchedule,
|
|
&dwShutdownTimeLimit);
|
|
|
|
|
|
if (iAppState == WIS_CPUPAUSE && SUCCEEDED(hr))
|
|
{
|
|
if (SUCCEEDED(pWICurrentApplication->Init(wszPackageID, m_pidInetInfo)))
|
|
{
|
|
pWICurrentApplication->ChangeToState(WIS_CPUPAUSE, WIS_RUNNING);
|
|
}
|
|
}
|
|
|
|
//
|
|
// FindWamInfo References this, so dereference it.
|
|
//
|
|
pWICurrentApplication->Dereference();
|
|
}
|
|
|
|
}//WAM_DICTATOR::CPUResumeWamInfo
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::ShutdownWamInfo
|
|
This function currently can only call a blocking method of WAM, UnInitWam.
|
|
In the future, this function might support a non-blocking method provided by WAM in
|
|
case of IIS shutdown.
|
|
|
|
Arguments:
|
|
pWamInfo [in] a pointer to WamInfo
|
|
cIgnoreRef [in] The reference count that need to be ignored in StartShutdown.
|
|
|
|
Return Value:
|
|
TRUE or FALSE
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::ShutdownWamInfo
|
|
(
|
|
CWamInfo* pWamInfo,
|
|
INT cIgnoreRefs
|
|
)
|
|
{
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((DBG_CONTEXT, "WAM_DICTATOR::ShutdownWamInfo\n"));
|
|
|
|
HRESULT hr = NOERROR;
|
|
WCHAR szPackageID[uSizeCLSIDStr];
|
|
|
|
DBG_ASSERT(pWamInfo);
|
|
|
|
LPCSTR pszAppPath = (pWamInfo->QueryApplicationPath()).QueryStr();
|
|
|
|
|
|
// Might create IPackageUtil * for later use.
|
|
DBGPRINTF((DBG_CONTEXT, "Shutting down WamInfo %08p, Inproc(%d), AppRoot(%s).\n",
|
|
pWamInfo,
|
|
pWamInfo->FInProcess(),
|
|
pszAppPath));
|
|
|
|
|
|
hr = pWamInfo->StartShutdown(cIgnoreRefs);
|
|
hr = pWamInfo->UnInit();
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
const CHAR *pszEventLog[2];
|
|
char szErr[20];
|
|
|
|
pszEventLog[0] = pszAppPath;
|
|
wsprintf(szErr, "0x%08X", hr);
|
|
pszEventLog[1] = szErr;
|
|
|
|
// Event login
|
|
g_pInetSvc->LogEvent(W3_EVENT_FAIL_SHUTDOWN,
|
|
2,
|
|
pszEventLog,
|
|
0);
|
|
}
|
|
|
|
//delete pWamInfo;
|
|
//pWamInfo = NULL;
|
|
return hr;
|
|
} // wAM_DICTATOR::ShutdownWamInfo
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::CPUUpdateWamInfo
|
|
Arguments:
|
|
|
|
Return Value:
|
|
TRUE or FALSE
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
void
|
|
WAM_DICTATOR::CPUUpdateWamInfo
|
|
(
|
|
STR *pstrAppPath
|
|
)
|
|
{
|
|
CWamInfo* pWamInfo = NULL;
|
|
INT AppState;
|
|
|
|
DBG_ASSERT(pstrAppPath != NULL);
|
|
|
|
// Find the WamInfo.
|
|
AppState = FindWamInfo(pstrAppPath, &pWamInfo);
|
|
if (-1 != AppState)
|
|
{
|
|
BOOL fWasShutDown = FALSE;
|
|
DWORD eWISPrevState;
|
|
|
|
if ( !pWamInfo->FInProcess() )
|
|
{
|
|
//
|
|
// It's out of process and the job state has changed
|
|
// Shut it down so new value will get picked up
|
|
//
|
|
|
|
//
|
|
// change the state of the WamInfo
|
|
//
|
|
|
|
eWISPrevState = pWamInfo->ChangeToState(WIS_RUNNING, WIS_SHUTDOWN);
|
|
|
|
//
|
|
// Need to shutdown the Application
|
|
// remove from the hash table here. and clean up later.
|
|
if (WIS_RUNNING == eWISPrevState)
|
|
{
|
|
|
|
ShutdownWamInfo(pWamInfo, HASH_TABLE_REF + FIND_KEY_REF);
|
|
|
|
// NoNeed to go through the Dying List.
|
|
// But since we already have the Dying List, we might just used those functions.
|
|
// this means we might release other old WamInfo in the Dying List as well.
|
|
m_HashTable.DeleteKey(pstrAppPath->QueryStr());
|
|
|
|
fWasShutDown = TRUE;
|
|
|
|
}
|
|
}
|
|
pWamInfo->Dereference();
|
|
if (fWasShutDown)
|
|
{
|
|
pWamInfo->Dereference();
|
|
//delete pWamInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
HRESULT
|
|
WAM_DICTATOR::WamRegSink
|
|
Argument:
|
|
szAppPath [in] Application Path.
|
|
dwCommand [in] Delete, Change, Stop..etc.
|
|
|
|
Return:
|
|
HRESULT
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::WamRegSink
|
|
(
|
|
LPCSTR szAppPath,
|
|
const DWORD dwCommand,
|
|
DWORD* pdwResult
|
|
)
|
|
{
|
|
CWamInfo* pWamInfo = NULL;
|
|
INT AppState;
|
|
HRESULT hrReturn = NOERROR;
|
|
|
|
DBG_ASSERT(szAppPath != NULL);
|
|
|
|
*pdwResult = APPSTATUS_UnLoaded;
|
|
|
|
//
|
|
// Set up the Application Path
|
|
//
|
|
STR* pstrAppPath = new STR(szAppPath);
|
|
|
|
if (NULL == pstrAppPath)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
Reference();
|
|
DBGPRINTF((DBG_CONTEXT,
|
|
"Wam Dictator received a SinkNotify on MD Path %s, cmd = %d\n",
|
|
szAppPath,
|
|
dwCommand));
|
|
|
|
if (dwCommand == APPCMD_UNLOAD)
|
|
{
|
|
hrReturn = UnLoadWamInfo(pstrAppPath, FALSE);
|
|
*pdwResult = (SUCCEEDED(hrReturn)) ? APPSTATUS_UnLoaded : APPSTATUS_Error;
|
|
}
|
|
else
|
|
{
|
|
// Find the WamInfo.
|
|
AppState = FindWamInfo(pstrAppPath, &pWamInfo);
|
|
if (-1 != AppState)
|
|
{
|
|
LK_RETCODE LkReturn;
|
|
DWORD eWISPrevState;
|
|
|
|
if (dwCommand == APPCMD_DELETE ||
|
|
dwCommand == APPCMD_CHANGETOINPROC ||
|
|
dwCommand == APPCMD_CHANGETOOUTPROC)
|
|
{
|
|
eWISPrevState = pWamInfo->ChangeToState(WIS_RUNNING, WIS_SHUTDOWN);
|
|
|
|
if (WIS_RUNNING == eWISPrevState)
|
|
{
|
|
LkReturn = m_HashTable.DeleteKey(pstrAppPath->QueryStr());
|
|
DBG_ASSERT(LK_SUCCESS == LkReturn);
|
|
|
|
if (LK_SUCCESS == LkReturn)
|
|
{
|
|
DyingList_Lock();
|
|
InsertDyingList(pWamInfo, FALSE);
|
|
DyingList_UnLock();
|
|
|
|
ScheduledId_Lock();
|
|
if (m_dwScheduledId == 0)
|
|
{
|
|
// DebugBreak();
|
|
m_dwScheduledId = ScheduleWorkItem
|
|
(
|
|
WAM_DICTATOR::CleanupScheduled,
|
|
NULL,
|
|
0,
|
|
FALSE
|
|
);
|
|
DBGPRINTF((DBG_CONTEXT, "add schedule item %d\n", m_dwScheduledId));
|
|
DBG_ASSERT(m_dwScheduledId);
|
|
}
|
|
ScheduledId_UnLock();
|
|
|
|
*pdwResult = (SUCCEEDED(hrReturn)) ? APPSTATUS_UnLoaded : APPSTATUS_Error;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Previous state is not running state. Leave it alone.
|
|
//
|
|
pWamInfo->Dereference();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// AppGetStatus
|
|
if (WIS_RUNNING == pWamInfo->QueryState())
|
|
{
|
|
*pdwResult = APPSTATUS_Running;
|
|
}
|
|
else
|
|
{
|
|
*pdwResult = APPSTATUS_Stopped;
|
|
}
|
|
|
|
pWamInfo->Dereference();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// This Application is not loaded.
|
|
*pdwResult = APPSTATUS_NotFoundInW3SVC;
|
|
}
|
|
}
|
|
|
|
Dereference();
|
|
return hrReturn;
|
|
}//WAM_DICTATOR::WamRegSink
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::InsertDyingList
|
|
This function insert an invalid WamInfo into DyingList. No blocking.
|
|
|
|
Arguments:
|
|
pWamInfo [in] a pointer to WamInfo
|
|
fNeedReference [in] if TRUE, then we Rereference the WamInfo. Because we get the WamInfo by
|
|
Hashtable's Interator or LookUp. When we get a WamInfo from Hash Table by
|
|
hash table's interator or LookUp call, the Hash table does a AddRef to
|
|
WamInfo. Therefore, this parameter tells whether we need to balance that
|
|
Addref or not.
|
|
Return Value:
|
|
NOERROR.
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::InsertDyingList
|
|
(
|
|
CWamInfo* pWamInfo,
|
|
BOOL fNeedReference
|
|
)
|
|
{
|
|
DBG_ASSERT(pWamInfo);
|
|
|
|
DyingList_Lock();
|
|
//
|
|
// Note: Delete Dereference WamInfo. This Dereference() within Delete() balances
|
|
// the AddRef() in Insert() call to the hash table.
|
|
//
|
|
InsertHeadList(&m_DyingListHead, &pWamInfo->ListEntry);
|
|
//
|
|
// Unfortunately, I can not move this Dereference() out of Critical Section.
|
|
// If I move the Dereference() after the Critical Section, then, since the WamInfo is
|
|
// already on the DyingList. therefore, any other thread happens to do the CleanUpDyingList()
|
|
// call before this Dereference() will have an unbalanced reference to the CWamInfo.
|
|
//
|
|
if (fNeedReference)
|
|
{
|
|
pWamInfo->Reference();
|
|
}
|
|
|
|
DyingList_UnLock();
|
|
|
|
return NOERROR;
|
|
}//WAM_DICTATOR::InsertDyingList
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::CleanUpDyingList
|
|
This function clean up any remaining WamInfo on the dying list.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
HRESULT
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
HRESULT
|
|
WAM_DICTATOR::CleanUpDyingList
|
|
(
|
|
VOID
|
|
)
|
|
{
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((DBG_CONTEXT, "WAM_DICTATOR::CleanUpDyingList\n"));
|
|
|
|
CWamInfo * pWamInfo = NULL;
|
|
HRESULT hr = NOERROR;
|
|
PLIST_ENTRY pleTemp;
|
|
BOOL fNeedCleanupAction = FALSE;
|
|
|
|
DyingList_Lock();
|
|
if (!IsListEmpty(&m_DyingListHead))
|
|
{
|
|
if (!m_fCleanupInProgress)
|
|
{
|
|
m_fCleanupInProgress = TRUE;
|
|
fNeedCleanupAction = TRUE;
|
|
}
|
|
}
|
|
|
|
DBGPRINTF((DBG_CONTEXT, "Clean up dying list. (ScheduledId:%d).\n",
|
|
m_dwScheduledId));
|
|
|
|
DyingList_UnLock();
|
|
|
|
if (!fNeedCleanupAction)
|
|
{
|
|
goto Egress;
|
|
}
|
|
|
|
// From now on, only one thread is working on the killing dying list.
|
|
while (!IsListEmpty(&m_DyingListHead))
|
|
{
|
|
DyingList_Lock();
|
|
pleTemp = RemoveHeadList(&m_DyingListHead);
|
|
DyingList_UnLock();
|
|
|
|
DBG_ASSERT(pleTemp);
|
|
pWamInfo = CONTAINING_RECORD(
|
|
pleTemp,
|
|
CWamInfo,
|
|
ListEntry);
|
|
|
|
ShutdownWamInfo(pWamInfo, DYING_LIST_REF);
|
|
|
|
pWamInfo->Dereference();
|
|
|
|
pWamInfo->Dereference();
|
|
//delete pWamInfo;
|
|
pWamInfo = NULL;
|
|
}
|
|
|
|
InterlockedExchange((LPLONG)&m_fCleanupInProgress, (LONG)FALSE);
|
|
|
|
DBGPRINTF((DBG_CONTEXT, "CleanupDyingList done, ScheduledId(%d)\n", m_dwScheduledId));
|
|
|
|
Egress:
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((DBG_CONTEXT, "WAM_DICTATOR::CleanUpDyingList done\n"));
|
|
|
|
m_dwScheduledId = 0;
|
|
return hr;
|
|
}//WAM_DICTATOR::CleanUpDyingList
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::StopAplicationsByInstance
|
|
|
|
Unload out-proc applications for a particular w3 server instance.
|
|
|
|
Arguments:
|
|
W3_SERVER_INSTANCE *pInstance
|
|
pointer to W3 Server Instance object. Used to query the server instance
|
|
metabase path.
|
|
|
|
Return Value:
|
|
none
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
VOID
|
|
WAM_DICTATOR::StopApplicationsByInstance
|
|
(
|
|
VOID *pContext //W3_SERVER_INSTANCE *pInstance
|
|
)
|
|
{
|
|
IF_DEBUG( WAM_ISA_CALLS )
|
|
DBGPRINTF((DBG_CONTEXT, "WAM_DICTATOR::StopApplicationsByInstance\n"));
|
|
|
|
BUFFER bufDataPaths;
|
|
MB mb( (IMDCOM*) g_pInetSvc->QueryMDObject() );
|
|
LPSTR pszCurrentPath;
|
|
STR strPath;
|
|
W3_SERVER_INSTANCE *pInstance;
|
|
|
|
DBG_ASSERT(pContext != NULL);
|
|
DBG_ASSERT(g_pWamDictator != NULL);
|
|
|
|
pInstance = (W3_SERVER_INSTANCE *)pContext;
|
|
|
|
g_pWamDictator->Reference();
|
|
if (!g_pWamDictator->FIsShutdown())
|
|
{
|
|
if ( mb.Open( pInstance->QueryMDPath(),
|
|
METADATA_PERMISSION_READ ) )
|
|
{
|
|
//
|
|
// First find the OOP Applications
|
|
//
|
|
if (mb.GetDataPaths(NULL,
|
|
MD_APP_WAM_CLSID,
|
|
STRING_METADATA,
|
|
&bufDataPaths))
|
|
{
|
|
//
|
|
// For each OOP Application
|
|
//
|
|
mb.Close();
|
|
for (pszCurrentPath = (LPSTR)bufDataPaths.QueryPtr();
|
|
*pszCurrentPath != '\0';
|
|
pszCurrentPath += (strlen(pszCurrentPath) + 1))
|
|
{
|
|
strPath.Copy(pInstance->QueryMDPath());
|
|
strPath.Append(pszCurrentPath);
|
|
strPath.SetLen(strlen(strPath.QueryStr()) - 1);
|
|
g_pWamDictator->UnLoadWamInfo(&strPath, FALSE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mb.Close();
|
|
}
|
|
}
|
|
} // WamDictator is in shutdown
|
|
g_pWamDictator->Dereference();
|
|
|
|
}
|
|
|
|
BOOL
|
|
WAM_DICTATOR::DeleteWamInfoFromHashTable
|
|
(
|
|
CWamInfo * pWamInfo
|
|
)
|
|
{
|
|
LK_RETCODE lkReturn;
|
|
const CHAR * szKey;
|
|
|
|
DBG_ASSERT( pWamInfo );
|
|
|
|
szKey = m_HashTable.ExtractKey( pWamInfo );
|
|
|
|
if ( !szKey )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
lkReturn = m_HashTable.DeleteKey( szKey );
|
|
|
|
return ( lkReturn == LK_SUCCESS );
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
WAM_DICTATOR::DumpWamDictatorInfo
|
|
|
|
Description:
|
|
This function dumps the stats on all WAMs for diagnostics
|
|
|
|
Arguments:
|
|
pchBuffer - pointer to buffer that will contain the html results
|
|
lpcchBuffer - pointer to DWORD containing the size of buffer on entry
|
|
On return this contains the # of bytes written out to buffer
|
|
|
|
Return:
|
|
TRUE for success and FALSE for failure
|
|
Look at GetLastError() for the error code.
|
|
-----------------------------------------------------------------------------*/
|
|
BOOL
|
|
WAM_DICTATOR::DumpWamDictatorInfo
|
|
(
|
|
OUT CHAR * pchBuffer,
|
|
IN OUT LPDWORD lpcchBuffer
|
|
)
|
|
{
|
|
LIST_ENTRY * pEntry;
|
|
DWORD iCount, cch;
|
|
BOOL fRet = TRUE;
|
|
|
|
if ( lpcchBuffer == NULL )
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER);
|
|
return ( FALSE);
|
|
}
|
|
|
|
|
|
if ( 200 < *lpcchBuffer )
|
|
{
|
|
// Print the header blob
|
|
cch = wsprintf( pchBuffer,
|
|
" Wam Director Table (%x)<br>"
|
|
"<TABLE BORDER> <TR> "
|
|
"<TH> Wam Instance </TH> "
|
|
"<TH> Total Reqs </TH> "
|
|
"<TH> Current Reqs </TH> "
|
|
"<TH> Max Reqs </TH> "
|
|
" </TR>"
|
|
,
|
|
this
|
|
);
|
|
}
|
|
else
|
|
{
|
|
cch = 200;
|
|
}
|
|
|
|
//
|
|
// For now there is only ONE WAM. Later use a loop to iterate thru WAMs
|
|
//
|
|
|
|
iCount = 0;
|
|
|
|
CWamInfoHash::CIterator iter;
|
|
LK_RETCODE lkReturn = m_HashTable.InitializeIterator(&iter);
|
|
WAM_STATISTICS_INFO wsi;
|
|
CWamInfo* pWamInfo;
|
|
DWORD dwErr;
|
|
HRESULT hr;
|
|
|
|
ZeroMemory( (PVOID ) &wsi, sizeof(wsi));
|
|
|
|
while (LK_SUCCESS == lkReturn)
|
|
{
|
|
CWamInfoHash::Record *pRec = iter.Record();
|
|
|
|
pWamInfo = (CWamInfo *)pRec;
|
|
|
|
hr = pWamInfo->GetStatistics( 0, &wsi);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT, " Wam(%08x)::GetStatistics( %08x) => %08x\n",
|
|
pWamInfo->QueryIWam(), &wsi, hr));
|
|
|
|
if ( (cch + 150 ) < *lpcchBuffer)
|
|
{
|
|
cch += wsprintf( pchBuffer + cch,
|
|
" <TR> <TD> [%d] %s </TD> "
|
|
" <TD> %4d </TD>"
|
|
" <TD> %4d </TD>"
|
|
" <TD> %4d </TD>"
|
|
" </TR>"
|
|
,
|
|
iCount,
|
|
pWamInfo->QueryKey(),
|
|
wsi.WamStats0.TotalWamRequests,
|
|
wsi.WamStats0.CurrentWamRequests,
|
|
wsi.WamStats0.MaxWamRequests
|
|
);
|
|
iCount++;
|
|
}
|
|
else
|
|
{
|
|
cch += 150;
|
|
}
|
|
}
|
|
|
|
lkReturn = m_HashTable.IncrementIterator(&iter);
|
|
} // while()
|
|
|
|
DBG_ASSERT(lkReturn == LK_NO_MORE_ELEMENTS);
|
|
|
|
lkReturn = m_HashTable.CloseIterator(&iter);
|
|
|
|
DBG_REQUIRE(lkReturn == LK_SUCCESS);
|
|
|
|
//
|
|
// dump the final summary
|
|
//
|
|
if ( (cch + 100 ) < *lpcchBuffer)
|
|
{
|
|
cch += wsprintf( pchBuffer + cch,
|
|
" </TABLE>"
|
|
);
|
|
}
|
|
else
|
|
{
|
|
cch += 100;
|
|
}
|
|
|
|
if ( *lpcchBuffer < cch )
|
|
{
|
|
SetLastError( ERROR_INSUFFICIENT_BUFFER);
|
|
fRet = FALSE;
|
|
}
|
|
|
|
*lpcchBuffer = cch;
|
|
|
|
return (fRet);
|
|
} // WAM_DICTATOR::DumpWamDictatorInfo()
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
Description:
|
|
Thunk so that we can dll export DumpWamDictatorInfo.
|
|
|
|
-----------------------------------------------------------------------------*/
|
|
extern "C"
|
|
BOOL WamDictatorDumpInfo
|
|
(
|
|
OUT CHAR * pch,
|
|
IN OUT LPDWORD lpcchBuff
|
|
)
|
|
{
|
|
return ( g_pWamDictator->DumpWamDictatorInfo( pch, lpcchBuff));
|
|
} // WamDictatorDumpInfo()
|
|
|
|
HRESULT W3SVC_WamRegSink
|
|
(
|
|
LPCSTR szAppPath,
|
|
const DWORD dwCommand,
|
|
DWORD* pdwResult
|
|
)
|
|
{
|
|
return (g_pWamDictator->WamRegSink(szAppPath, dwCommand, pdwResult));
|
|
} // W3SVCDictatorDumpInfo()
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
Thunks for Fake NT APIs
|
|
-----------------------------------------------------------------------------*/
|
|
CRITICAL_SECTION g_csNonNTAPIs;
|
|
LONG FakeInterlockedCompareExchange(
|
|
LONG *Destination,
|
|
LONG Exchange,
|
|
LONG Comperand
|
|
);
|
|
|
|
LONG
|
|
FakeInterlockedCompareExchange(
|
|
LONG *Destination,
|
|
LONG Exchange,
|
|
LONG Comperand
|
|
)
|
|
/*-----------------------------------------------------------------------------
|
|
Description:
|
|
This function fakes the interlocked compare exchange operation for non NT
|
|
platforms
|
|
See WAMLoadNTApis() for details
|
|
|
|
Returns:
|
|
returns the old value at Destination
|
|
-----------------------------------------------------------------------------*/
|
|
{
|
|
LONG oldValue;
|
|
|
|
EnterCriticalSection( &g_csNonNTAPIs);
|
|
|
|
oldValue = *Destination;
|
|
|
|
if ( oldValue == Comperand ) {
|
|
*Destination = Exchange;
|
|
}
|
|
|
|
LeaveCriticalSection( &g_csNonNTAPIs);
|
|
|
|
return( oldValue);
|
|
} // FakeInterlockedCompareExchange()
|
|
|
|
|
|
static VOID
|
|
LoadNTApis(VOID)
|
|
/*-----------------------------------------------------------------------------
|
|
Description:
|
|
This function loads the entry point for functions from
|
|
Kernel32.dll. If the entry point is missing, the function
|
|
pointer will point to a fake routine which does nothing. Otherwise,
|
|
it will point to the real function.
|
|
|
|
It dynamically loads the kernel32.dll to find the entry ponit and then
|
|
unloads it after getting the address. For the resulting function
|
|
pointer to work correctly one has to ensure that the kernel32.dll is
|
|
linked with the dll/exe which links to this file.
|
|
-----------------------------------------------------------------------------*/
|
|
{
|
|
// Initialize the critical section for non NT API support, in case if we need this
|
|
INITIALIZE_CRITICAL_SECTION( &g_csNonNTAPIs);
|
|
|
|
if ( g_pfnInterlockedCompareExchange == NULL )
|
|
{
|
|
HINSTANCE tmpInstance;
|
|
//
|
|
// load kernel32 and get NT specific entry points
|
|
//
|
|
|
|
tmpInstance = LoadLibrary("kernel32.dll");
|
|
if ( tmpInstance != NULL )
|
|
{
|
|
|
|
// For some reason the original function is _InterlockedCompareExchange!
|
|
g_pfnInterlockedCompareExchange = (PFN_INTERLOCKED_COMPARE_EXCHANGE )
|
|
GetProcAddress( tmpInstance, "InterlockedCompareExchange");
|
|
|
|
if ( g_pfnInterlockedCompareExchange == NULL )
|
|
{
|
|
// the function is not available
|
|
// Just thunk it.
|
|
g_pfnInterlockedCompareExchange = FakeInterlockedCompareExchange;
|
|
}
|
|
|
|
//
|
|
// We can free this because we are statically linked to it
|
|
//
|
|
|
|
FreeLibrary(tmpInstance);
|
|
}
|
|
}
|
|
|
|
return;
|
|
} // WAMLoadNTApis()
|
|
|
|
static void
|
|
UnloadNTApis(VOID)
|
|
{
|
|
DeleteCriticalSection( &g_csNonNTAPIs);
|
|
|
|
return;
|
|
} // WAMUnloadNTApis()
|
|
|
|
VOID
|
|
RecycleCallback(
|
|
VOID * pvContext
|
|
)
|
|
{
|
|
CWamInfo * pWamInfo = (CWamInfo*)pvContext;
|
|
|
|
DBG_ASSERT( pWamInfo );
|
|
|
|
pWamInfo->m_fRecycled = TRUE;
|
|
|
|
if (!g_pWamDictator->m_PTable.RecycleWamInfo( pWamInfo ) )
|
|
{
|
|
DBGPRINTF((
|
|
DBG_CONTEXT,
|
|
"[RecycleCallback] failed to recycle CWamInfo 0x%08x.\r\n"
|
|
));
|
|
}
|
|
|
|
pWamInfo->Dereference();
|
|
|
|
return;
|
|
}
|
|
|
|
/************************ End of File ***********************/
|
|
|