windows-xp/Source/XPSP1/NT/inetsrv/iis/svcs/w3/server/wamexec.cxx

/*-----------------------------------------------------------------------------

   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 ***********************/