xref: /dports/lang/mono/mono-5.10.1.57/mcs/class/referencesource/System.Web/Hosting/HostingEnvironment.cs

//------------------------------------------------------------------------------
// <copyright file="HostingEnvironment.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Web.Hosting {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.Specialized;
    using System.Configuration;
    using System.Configuration.Provider;
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization;
    using System.IO;
    using System.Runtime.Caching;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;
    using System.Runtime.Remoting;
    using System.Runtime.Remoting.Messaging;
    using System.Security;
    using System.Security.Permissions;
    using System.Security.Policy;
    using System.Security.Principal;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Web;
    using System.Web.Caching;
    using System.Web.Compilation;
    using System.Web.Configuration;
    using System.Web.Management;
    using System.Web.Util;
    using System.Web.WebSockets;
    using Microsoft.Win32;

    [Flags]
    internal enum HostingEnvironmentFlags {
        Default = 0,
        HideFromAppManager = 1,
        ThrowHostingInitErrors = 2,
        DontCallAppInitialize = 4,
        ClientBuildManager = 8,
        SupportsMultiTargeting = 16,
    }

    [Serializable]
    internal class HostingEnvironmentParameters {
        private HostingEnvironmentFlags _hostingFlags;
        private ClientBuildManagerParameter _clientBuildManagerParameter;
        private string _precompTargetPhysicalDir;
        private string _iisExpressVersion;

        public HostingEnvironmentFlags HostingFlags {
            get { return _hostingFlags; }
            set { _hostingFlags = value; }
        }

        // Directory where the precompiled site is placed
        public string PrecompilationTargetPhysicalDirectory {
            get { return _precompTargetPhysicalDir; }
            set {
                _precompTargetPhysicalDir = FileUtil.FixUpPhysicalDirectory(value);
            }
        }

        // Determines the behavior of the precompilation
        public ClientBuildManagerParameter ClientBuildManagerParameter {
            get { return _clientBuildManagerParameter; }
            set { _clientBuildManagerParameter = value; }
        }

        // Determines which config system to load
        public string IISExpressVersion {
            get { return _iisExpressVersion; }
            set { _iisExpressVersion = value; }
        }

        // Determines what FileChangeMonitor mode to use
        public FcnMode FcnMode {
            get;
            set;
        }

        // Should FileChangesMonitor skip reading and caching DACLs?
        public bool FcnSkipReadAndCacheDacls {
            get;
            set;
        }

        public KeyValuePair<string, bool>[] ClrQuirksSwitches {
            get;
            set;
        }
    }

    public sealed class HostingEnvironment : MarshalByRefObject {

        private static HostingEnvironment _theHostingEnvironment;
        private EventHandler _onAppDomainUnload;
        private ApplicationManager _appManager;
        private HostingEnvironmentParameters _hostingParameters;
        private IApplicationHost _appHost;
        private bool _externalAppHost;
        private IConfigMapPath _configMapPath;
        private IConfigMapPath2 _configMapPath2;
        private IntPtr _configToken;

        private IdentitySection _appIdentity;
        private IntPtr _appIdentityToken;
        private bool _appIdentityTokenSet;

        private String _appId;
        private VirtualPath _appVirtualPath;
        private String _appPhysicalPath;
        private String _siteName;
        private String _siteID;
        private String _appConfigPath;

        private bool   _isBusy;
        private int    _busyCount;

        private volatile static bool _stopListeningWasCalled; // static since it's process-wide
        private bool _removedFromAppManager;
        private bool _appDomainShutdownStarted;
        private bool _shutdownInitiated;
        private bool _shutdownInProgress;
        private String _shutDownStack;

        private static NameValueCollection _cacheProviderSettings;
        private int _inTrimCache;
        private ObjectCacheHost _objectCacheHost;

        // table of well know objects keyed by type
        private Hashtable _wellKnownObjects = new Hashtable();

        // list of registered IRegisteredObject instances, suspend listeners, and background work items
        private Hashtable _registeredObjects = new Hashtable();
        private SuspendManager _suspendManager = new SuspendManager();
        private ApplicationMonitors _applicationMonitors;
        private BackgroundWorkScheduler _backgroundWorkScheduler = null; // created on demand
        private static readonly Task<object> _completedTask = Task.FromResult<object>(null);

        // callback to make InitiateShutdown non-blocking
        private WaitCallback _initiateShutdownWorkItemCallback;

        // inside app domain idle shutdown logic
        private IdleTimeoutMonitor _idleTimeoutMonitor;

        private static IProcessHostSupportFunctions _functions;
        private static bool _hasBeenRemovedFromAppManangerTable;

        private const string TemporaryVirtualPathProviderKey = "__TemporaryVirtualPathProvider__";

        // Determines what FileChangeMonitor mode to use
        internal static FcnMode FcnMode {
            get {
                if (_theHostingEnvironment != null && _theHostingEnvironment._hostingParameters != null) {
                    return _theHostingEnvironment._hostingParameters.FcnMode;
                }
                return FcnMode.NotSet;
            }
        }

        internal static bool FcnSkipReadAndCacheDacls {
            get {
                if (_theHostingEnvironment != null && _theHostingEnvironment._hostingParameters != null) {
                    return _theHostingEnvironment._hostingParameters.FcnSkipReadAndCacheDacls;
                }
                return false;
            }
        }

        public override Object InitializeLifetimeService() {
            return null; // never expire lease
        }

        /// <internalonly/>
        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public HostingEnvironment() {
            if (_theHostingEnvironment != null)
                throw new InvalidOperationException(SR.GetString(SR.Only_1_HostEnv));

            // remember singleton HostingEnvironment in a static
            _theHostingEnvironment = this;

            // start watching for app domain unloading
            _onAppDomainUnload = new EventHandler(OnAppDomainUnload);
            Thread.GetDomain().DomainUnload += _onAppDomainUnload;

            // VSO 160528: We used to listen to the default AppDomain's UnhandledException only.
            // However, non-serializable exceptions cannot be passed to the default domain. Therefore
            // we should try to log exceptions in application AppDomains.
            Thread.GetDomain().UnhandledException += new UnhandledExceptionEventHandler(ApplicationManager.OnUnhandledException);
        }

        internal static long TrimCache(int percent)
        {
            if (_theHostingEnvironment != null)
                return _theHostingEnvironment.TrimCacheInternal(percent);
            return 0;
        }

        private long TrimCacheInternal(int percent)
        {
            if (Interlocked.Exchange(ref _inTrimCache, 1) != 0)
                return 0;
            try {
                long trimmedOrExpired = 0;
                // do nothing if we're shutting down
                if (!_shutdownInitiated) {
                    var iCache = HttpRuntime.Cache.GetInternalCache(createIfDoesNotExist: false);
                    var oCache = HttpRuntime.Cache.GetObjectCache(createIfDoesNotExist: false);
                    if (oCache != null) {
                        trimmedOrExpired = oCache.Trim(percent);
                    }
                    if (iCache != null && !iCache.Equals(oCache)) {
                        trimmedOrExpired += iCache.Trim(percent);
                    }
                    if (_objectCacheHost != null && !_shutdownInitiated) {
                        trimmedOrExpired += _objectCacheHost.TrimCache(percent);
                    }
                }
                return trimmedOrExpired;
            }
            finally {
                Interlocked.Exchange(ref _inTrimCache, 0);
            }
        }

        private void OnAppDomainUnload(Object unusedObject, EventArgs unusedEventArgs) {
            Debug.Trace("PipelineRuntime", "HE.OnAppDomainUnload");

            Thread.GetDomain().DomainUnload -= _onAppDomainUnload;

            // check for unexpected shutdown
            if (!_removedFromAppManager) {
                RemoveThisAppDomainFromAppManagerTableOnce();
            }

            HttpRuntime.RecoverFromUnexceptedAppDomainUnload();

            // call Stop on all registered objects with immediate = true
            StopRegisteredObjects(true);

            // notify app manager
            if (_appManager != null) {
                // disconnect the real app host and substitute it with a bogus one
                // to avoid exceptions later when app host is called (it normally wouldn't)
                IApplicationHost originalAppHost = null;

                if (_externalAppHost) {
                    originalAppHost = _appHost;
                    _appHost = new SimpleApplicationHost(_appVirtualPath, _appPhysicalPath);
                    _externalAppHost = false;
                }

                IDisposable configSystem = _configMapPath2 as IDisposable;
                if (configSystem != null) {
                    configSystem.Dispose();
                }

                _appManager.HostingEnvironmentShutdownComplete(_appId, originalAppHost);
            }

            // free the config access token
            if (_configToken != IntPtr.Zero) {
                UnsafeNativeMethods.CloseHandle(_configToken);
                _configToken = IntPtr.Zero;
            }
        }

        //
        // Initialization
        //

        // called from app manager right after app domain (and hosting env) is created
        internal void Initialize(ApplicationManager appManager, IApplicationHost appHost, IConfigMapPathFactory configMapPathFactory, HostingEnvironmentParameters hostingParameters, PolicyLevel policyLevel) {
            Initialize(appManager, appHost, configMapPathFactory, hostingParameters, policyLevel, null);
        }

        [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "We carefully control this method's callers.")]
        internal void Initialize(ApplicationManager appManager, IApplicationHost appHost, IConfigMapPathFactory configMapPathFactory,
            HostingEnvironmentParameters hostingParameters, PolicyLevel policyLevel,
            Exception appDomainCreationException) {

            _hostingParameters = hostingParameters;

            HostingEnvironmentFlags hostingFlags = HostingEnvironmentFlags.Default;
            if (_hostingParameters != null) {
                hostingFlags = _hostingParameters.HostingFlags;
                if (_hostingParameters.IISExpressVersion != null) {
                    ServerConfig.IISExpressVersion = _hostingParameters.IISExpressVersion;
                }
            }

            // Keep track of the app manager, unless HideFromAppManager flag was passed
            if ((hostingFlags & HostingEnvironmentFlags.HideFromAppManager) == 0)
                _appManager = appManager;

            if ((hostingFlags & HostingEnvironmentFlags.ClientBuildManager) != 0) {
                BuildManagerHost.InClientBuildManager = true;
            }

            if ((hostingFlags & HostingEnvironmentFlags.SupportsMultiTargeting) != 0) {
                BuildManagerHost.SupportsMultiTargeting = true;
            }

            // Set CLR quirks switches before the config system is initialized since config might depend on them
            if (_hostingParameters != null && _hostingParameters.ClrQuirksSwitches != null && _hostingParameters.ClrQuirksSwitches.Length > 0) {
                SetClrQuirksSwitches(_hostingParameters.ClrQuirksSwitches);
            }

            //
            // init config system using private config if applicable
            //
            if (appHost is ISAPIApplicationHost && !ServerConfig.UseMetabase) {
                string rootWebConfigPath = ((ISAPIApplicationHost)appHost).ResolveRootWebConfigPath();
                if (!String.IsNullOrEmpty(rootWebConfigPath)) {
                    Debug.Assert(File.Exists(rootWebConfigPath), "File.Exists(rootWebConfigPath)");
                    HttpConfigurationSystem.RootWebConfigurationFilePath = rootWebConfigPath;
                }

                // we need to explicit create a COM proxy in this app domain
                // so we don't go back to the default domain or have lifetime issues
                // remember support functions
                IProcessHostSupportFunctions proxyFunctions = ((ISAPIApplicationHost)appHost).SupportFunctions;
                if (null != proxyFunctions) {
                    _functions = Misc.CreateLocalSupportFunctions(proxyFunctions);
                }
            }

            _appId = HttpRuntime.AppDomainAppId;
            _appVirtualPath = HttpRuntime.AppDomainAppVirtualPathObject;
            _appPhysicalPath = HttpRuntime.AppDomainAppPathInternal;
            _appHost = appHost;

            _configMapPath = configMapPathFactory.Create(_appVirtualPath.VirtualPathString, _appPhysicalPath);
            HttpConfigurationSystem.EnsureInit(_configMapPath, true, false);

            // attempt to cache and use IConfigMapPath2 provider
            // which supports VirtualPath's to save on conversions
            _configMapPath2 = _configMapPath as IConfigMapPath2;


            _initiateShutdownWorkItemCallback = new WaitCallback(this.InitiateShutdownWorkItemCallback);

            // notify app manager
            if (_appManager != null) {
                _appManager.HostingEnvironmentActivated();
            }

            // make sure there is always app host
            if (_appHost == null) {
                _appHost = new SimpleApplicationHost(_appVirtualPath, _appPhysicalPath);
            }
            else {
                _externalAppHost = true;
            }

            // remember the token to access config
            _configToken = _appHost.GetConfigToken();

            // Start with a MapPath based virtual path provider
            _mapPathBasedVirtualPathProvider = new MapPathBasedVirtualPathProvider();
            _virtualPathProvider = _mapPathBasedVirtualPathProvider;

            // initiaze HTTP-independent features
            HttpRuntime.InitializeHostingFeatures(hostingFlags, policyLevel, appDomainCreationException);

            // VSWhidbey 393259. Do not monitor idle timeout for CBM since Venus
            // will always restart a new appdomain if old one is shutdown.
            if (!BuildManagerHost.InClientBuildManager) {
                // start monitoring for idle inside app domain
                StartMonitoringForIdleTimeout();
            }

            // notify app manager if the app domain limit is violated
            EnforceAppDomainLimit();

            // get application identity (for explicit impersonation mode)
            GetApplicationIdentity();

            _applicationMonitors = new ApplicationMonitors();

            // call AppInitialize, unless the flag says not to do it (e.g. CBM scenario).
            // Also, don't call it if HostingInit failed (VSWhidbey 210495)
            if(!HttpRuntime.HostingInitFailed) {
                try {
                    BuildManager.ExecutePreAppStart();
                    if ((hostingFlags & HostingEnvironmentFlags.DontCallAppInitialize) == 0) {
                        BuildManager.CallAppInitializeMethod();
                    }
                }
                catch (Exception e) {
                    // could throw compilation errors in 'code' - report them with first http request
                    HttpRuntime.InitializationException = e;

                    if ((hostingFlags & HostingEnvironmentFlags.ThrowHostingInitErrors) != 0) {
                        throw;
                    }
                }
            }
        }

        private void InitializeObjectCacheHostPrivate() {
            // set ObjectCacheHost if the Host is not already set
            if (ObjectCache.Host == null) {
                ObjectCacheHost objectCacheHost = new ObjectCacheHost();
                ObjectCache.Host = objectCacheHost;
                _objectCacheHost = objectCacheHost;
            }
        }

        internal static void InitializeObjectCacheHost() {
            if (_theHostingEnvironment != null) {
                _theHostingEnvironment.InitializeObjectCacheHostPrivate();
            }
        }

        private void StartMonitoringForIdleTimeout() {
            HostingEnvironmentSection hostEnvConfig = RuntimeConfig.GetAppLKGConfig().HostingEnvironment;

            TimeSpan idleTimeout = (hostEnvConfig != null) ? hostEnvConfig.IdleTimeout : HostingEnvironmentSection.DefaultIdleTimeout;

            // always create IdleTimeoutMonitor (even if config value is TimeSpan.MaxValue (infinite)
            // IdleTimeoutMonitor is also needed to keep the last event for app domain set trimming
            // and the timer is used to trim the application instances
            _idleTimeoutMonitor = new IdleTimeoutMonitor(idleTimeout);
        }

        // enforce app domain limit
        private void EnforceAppDomainLimit() {
            if (_appManager == null)  /// detached app domain
                return;

            int limit = 0;

            try {
                ProcessModelSection pmConfig = RuntimeConfig.GetMachineConfig().ProcessModel;
                limit = pmConfig.MaxAppDomains;
            }
            catch {
            }

            if (limit > 0 && _appManager.AppDomainsCount >= limit) {
                // current app domain doesn't count yet (not in the table)
                // that's why '>=' above
                _appManager.ReduceAppDomainsCount(limit);
            }
        }

        private void GetApplicationIdentity() {
            // if the explicit impersonation is set, use it instead of UNC identity
            try {
                IdentitySection c = RuntimeConfig.GetAppConfig().Identity;
                if (c.Impersonate && c.ImpersonateToken != IntPtr.Zero) {
                    _appIdentity = c;
                    _appIdentityToken = c.ImpersonateToken;
                }
                else {
                    _appIdentityToken = _configToken;
                }
                _appIdentityTokenSet = true;
            }
            catch {
            }
        }

        private static void SetClrQuirksSwitches(KeyValuePair<string, bool>[] switches) {
            // First, see if the static API AppContext.SetSwitch even exists.
            // Type.GetType will return null if the type doesn't exist; it will throw on catastrophic failure.

            Type appContextType = Type.GetType("System.AppContext, " + AssemblyRef.Mscorlib);
            if (appContextType == null) {
                return; // wrong version of mscorlib - do nothing
            }

            Action<string, bool> setter = (Action<string, bool>)Delegate.CreateDelegate(
                typeof(Action<string, bool>),
                appContextType,
                "SetSwitch",
                ignoreCase: false,
                throwOnBindFailure: false);
            if (setter == null) {
                return; // wrong version of mscorlib - do nothing
            }

            // Finally, set each switch individually.

            foreach (var sw in switches) {
                setter(sw.Key, sw.Value);
            }
        }


        // If an exception was thrown during initialization, return it.
        public static Exception InitializationException {
            get {
                return HttpRuntime.InitializationException;
            }
        }

        // called from app manager (from management APIs)
        internal ApplicationInfo GetApplicationInfo() {
            return new ApplicationInfo(_appId, _appVirtualPath, _appPhysicalPath);
        }

        //
        // Shutdown logic
        //
        [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
        private void StopRegisteredObjects(bool immediate) {
            if (_registeredObjects.Count > 0) {
                ArrayList list = new ArrayList();

                lock (this) {
                    foreach (DictionaryEntry e in _registeredObjects) {
                        Object x = e.Key;

                        // well-known objects first
                        if (IsWellKnownObject(x)) {
                            list.Insert(0, x);
                        }
                        else {
                            list.Add(x);
                        }
                    }
                }

                foreach (IRegisteredObject obj in list) {
                    try {
                        obj.Stop(immediate);
                    }
                    catch {
                    }
                }
            }
        }

        private void InitiateShutdownWorkItemCallback(Object state /*not used*/) {
            Debug.Trace("HostingEnvironmentShutdown", "Shutting down: appId=" + _appId);

            // no registered objects -- shutdown
            if (_registeredObjects.Count == 0) {
                Debug.Trace("HostingEnvironmentShutdown", "No registered objects");
                ShutdownThisAppDomainOnce();
                return;
            }

            // call Stop on all registered objects with immediate = false
            StopRegisteredObjects(false);

            // no registered objects -- shutdown now
            if (_registeredObjects.Count == 0) {
                Debug.Trace("HostingEnvironmentShutdown", "All registered objects gone after Stop(false)");
                ShutdownThisAppDomainOnce();
                return;
            }

            // if not everything shutdown synchronously give it some time.
            int shutdownTimeoutSeconds = HostingEnvironmentSection.DefaultShutdownTimeout;
            HostingEnvironmentSection hostEnvConfig = RuntimeConfig.GetAppLKGConfig().HostingEnvironment;
            if (hostEnvConfig != null) {
                shutdownTimeoutSeconds = (int) hostEnvConfig.ShutdownTimeout.TotalSeconds;
            }
            Debug.Trace("HostingEnvironmentShutdown", "Waiting for " + shutdownTimeoutSeconds + " sec...");

            DateTime waitUntil = DateTime.UtcNow.AddSeconds(shutdownTimeoutSeconds);
            while (_registeredObjects.Count > 0 && DateTime.UtcNow < waitUntil) {
                Thread.Sleep(100);
            }

            Debug.Trace("HostingEnvironmentShutdown", "Shutdown timeout (" + shutdownTimeoutSeconds + " sec) expired");

            // call Stop on all registered objects with immediate = true
            StopRegisteredObjects(true);

            // no registered objects -- shutdown now
            if (_registeredObjects.Count == 0) {
                Debug.Trace("HostingEnvironmentShutdown", "All registered objects gone after Stop(true)");
                ShutdownThisAppDomainOnce();
                return;
            }

            // shutdown regardless
            Debug.Trace("HostingEnvironmentShutdown", "Forced shutdown: " + _registeredObjects.Count + " registered objects left");
            _registeredObjects = new Hashtable();
            ShutdownThisAppDomainOnce();
        }

        // app domain shutdown logic
        internal void InitiateShutdownInternal() {
#if DBG
            try {
#endif
            Debug.Trace("AppManager", "HostingEnvironment.InitiateShutdownInternal appId=" + _appId);

            bool proceed = false;

            if (!_shutdownInitiated) {
                lock (this) {
                    if (!_shutdownInitiated) {
                        _shutdownInProgress = true;
                        proceed = true;
                        _shutdownInitiated = true;
                    }
                }
            }

            if (!proceed) {
                return;
            }

            HttpRuntime.SetShutdownReason(ApplicationShutdownReason.HostingEnvironment, "HostingEnvironment initiated shutdown");

            // Avoid calling Environment.StackTrace if we are in the ClientBuildManager (Dev10 bug 824659)
            if (!BuildManagerHost.InClientBuildManager) {
                new EnvironmentPermission(PermissionState.Unrestricted).Assert();
                try {
                    _shutDownStack = Environment.StackTrace;
                }
                finally {
                    CodeAccessPermission.RevertAssert();
                }
            }

            // waitChangeNotification need not be honored in ClientBuildManager (Dev11 bug 264894)
            if (!BuildManagerHost.InClientBuildManager) {
                // this should only be called once, before the cache is disposed, and
                // the config records are released.
                HttpRuntime.CoalesceNotifications();
            }

            RemoveThisAppDomainFromAppManagerTableOnce();

            // stop all registered objects without blocking
            ThreadPool.QueueUserWorkItem(this._initiateShutdownWorkItemCallback);
#if DBG
            } catch (Exception ex) {
                HandleExceptionFromInitiateShutdownInternal(ex);
                throw;
            }
#endif
        }

#if DBG
        // InitiateShutdownInternal should never throw an exception, but we have seen cases where
        // CLR bugs can cause it to fail without running to completion. This could cause an ASP.NET
        // AppDomain never to unload. If we detect that an exception is thrown, we should DebugBreak
        // so that the fundamentals team can investigate. Taking the Exception object as a parameter
        // makes it easy to locate when looking at a stack dump.
        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        private static void HandleExceptionFromInitiateShutdownInternal(Exception ex) {
            Debug.Break();
        }
#endif

        internal bool HasBeenRemovedFromAppManagerTable {
            get {
                return _hasBeenRemovedFromAppManangerTable;
            }
            set {
                _hasBeenRemovedFromAppManangerTable = value;
            }
        }

        private void RemoveThisAppDomainFromAppManagerTableOnce() {
            bool proceed = false;
            if (!_removedFromAppManager) {
                lock (this) {
                    if (!_removedFromAppManager) {
                        proceed = true;
                        _removedFromAppManager = true;
                    }
                }
            }

            if (!proceed)
                return;

            if (_appManager != null) {
                Debug.Trace("AppManager", "Removing HostingEnvironment from AppManager table, appId=" + _appId);
                _appManager.HostingEnvironmentShutdownInitiated(_appId, this);
            }
#if DBG
            Debug.Trace("FileChangesMonitorIgnoreSubdirChange",
                        "*** REMOVE APPMANAGER TABLE" + DateTime.Now.ToString("hh:mm:ss.fff", CultureInfo.InvariantCulture)
                        + ": _appId=" + _appId);
#endif
        }

        private void ShutdownThisAppDomainOnce() {
            bool proceed = false;

            if (!_appDomainShutdownStarted) {
                lock (this) {
                    if (!_appDomainShutdownStarted) {
                        proceed = true;
                        _appDomainShutdownStarted = true;
                    }
                }
            }

            if (!proceed)
                return;

            Debug.Trace("AppManager", "HostingEnvironment - shutting down AppDomain, appId=" + _appId);

            // stop the timer used for idle timeout
            if (_idleTimeoutMonitor != null) {
                _idleTimeoutMonitor.Stop();
                _idleTimeoutMonitor = null;
            }

            while (_inTrimCache == 1) {
                Thread.Sleep(100);
            }

            // close all outstanding WebSocket connections and begin winding down code that consumes them
            AspNetWebSocketManager.Current.AbortAllAndWait();

            //
            HttpRuntime.SetUserForcedShutdown();

            //WOS 1400290: CantUnloadAppDomainException in ISAPI mode, wait until HostingEnvironment.ShutdownThisAppDomainOnce completes
            _shutdownInProgress = false;

            HttpRuntime.ShutdownAppDomainWithStackTrace(ApplicationShutdownReason.HostingEnvironment,
                                                        SR.GetString(SR.Hosting_Env_Restart),
                                                        _shutDownStack);
        }

        //
        // internal methods called by app manager
        //

        // helper for app manager to implement AppHost.CreateAppHost
        [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
        internal ObjectHandle CreateInstance(String assemblyQualifiedName) {
            Type type = Type.GetType(assemblyQualifiedName, true);
            return new ObjectHandle(Activator.CreateInstance(type));
        }

        // start well known object
        [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
        internal ObjectHandle CreateWellKnownObjectInstance(String assemblyQualifiedName, bool failIfExists) {
            Type type = Type.GetType(assemblyQualifiedName, true);
            IRegisteredObject obj = null;
            String key = type.FullName;
            bool exists = false;

            lock (this) {
                obj = _wellKnownObjects[key] as IRegisteredObject;

                if (obj == null) {
                    obj = (IRegisteredObject)Activator.CreateInstance(type);
                    _wellKnownObjects[key] = obj;
                }
                else {
                    exists = true;
                }
            }

            if (exists && failIfExists) {
                throw new InvalidOperationException(SR.GetString(SR.Wellknown_object_already_exists, key));
            }

            return new ObjectHandle(obj);
        }

        // check if well known object
        private bool IsWellKnownObject(Object obj) {
            bool found = false;
            String key = obj.GetType().FullName;

            lock (this) {
                if (_wellKnownObjects[key] == obj) {
                    found = true;
                }
            }

            return found;
        }

        // find well known object by type
        internal ObjectHandle FindWellKnownObject(String assemblyQualifiedName) {
            Type type = Type.GetType(assemblyQualifiedName, true);
            IRegisteredObject obj = null;
            String key = type.FullName;

            lock (this) {
                obj = _wellKnownObjects[key] as IRegisteredObject;
            }

            return (obj != null) ? new ObjectHandle(obj) : null;
        }

        // stop well known object by type
        [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
        internal void StopWellKnownObject(String assemblyQualifiedName) {
            Type type = Type.GetType(assemblyQualifiedName, true);
            IRegisteredObject obj = null;
            String key = type.FullName;

            lock (this) {
                obj = _wellKnownObjects[key] as IRegisteredObject;
                if (obj != null) {
                    _wellKnownObjects.Remove(key);
                    obj.Stop(false);
                }
            }
        }

        internal bool IsIdle() {
            bool isBusy = _isBusy;
            _isBusy = false;
            return (!isBusy && _busyCount == 0);
        }

        internal bool GetIdleValue() {
            return (!_isBusy && _busyCount == 0);
        }

        internal void IncrementBusyCountInternal() {
            _isBusy = true;
            Interlocked.Increment(ref _busyCount);
        }

        internal void DecrementBusyCountInternal() {
            _isBusy = true;
            Interlocked.Decrement(ref _busyCount);

            // Notify idle timeout monitor
            IdleTimeoutMonitor itm = _idleTimeoutMonitor;
            if (itm != null) {
                itm.LastEvent = DateTime.UtcNow;
            }
        }
        internal void IsUnloaded()
        {
            return;
        }

        private void MessageReceivedInternal() {
            _isBusy = true;

            IdleTimeoutMonitor itm = _idleTimeoutMonitor;
            if (itm != null) {
                itm.LastEvent = DateTime.UtcNow;
            }
        }

        // the busier the app domain the higher the score
        internal int LruScore {
            get {
                if (_busyCount > 0)
                    return _busyCount;

                IdleTimeoutMonitor itm = _idleTimeoutMonitor;

                if (itm == null)
                    return 0;

                // return negative number of seconds since last activity
                return -(int)(DateTime.UtcNow - itm.LastEvent).TotalSeconds;
            }
        }

        internal static ApplicationManager GetApplicationManager() {
            if (_theHostingEnvironment == null)
                return null;

            return _theHostingEnvironment._appManager;
        }

        //
        // private helpers
        //

        // register protocol handler with hosting environment
        private void RegisterRunningObjectInternal(IRegisteredObject obj) {
            lock (this) {
                _registeredObjects[obj] = obj;

                ISuspendibleRegisteredObject suspendibleObject = obj as ISuspendibleRegisteredObject;
                if (suspendibleObject != null) {
                    _suspendManager.RegisterObject(suspendibleObject);
                }
            }
        }

        // unregister protocol handler from hosting environment
        private void UnregisterRunningObjectInternal(IRegisteredObject obj) {
            bool lastOne = false;

            lock (this) {
                // if it is a well known object, remove it from that table as well
                String key = obj.GetType().FullName;
                if (_wellKnownObjects[key] == obj) {
                    _wellKnownObjects.Remove(key);
                }

                // remove from running objects list
                _registeredObjects.Remove(obj);

                ISuspendibleRegisteredObject suspendibleObject = obj as ISuspendibleRegisteredObject;
                if (suspendibleObject != null) {
                    _suspendManager.UnregisterObject(suspendibleObject);
                }

                if (_registeredObjects.Count == 0)
                    lastOne = true;
            }

            if (!lastOne)
                return;

            // shutdown app domain after last protocol handler is gone

            InitiateShutdownInternal();
        }

        // site name
        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "This method is not dangerous.")]
        private String GetSiteName() {
            if (_siteName == null) {
                lock (this) {
                    if (_siteName == null) {
                        String s = null;

                        if (_appHost != null) {
                            //
                            InternalSecurityPermissions.Unrestricted.Assert();
                            try {
                                s = _appHost.GetSiteName();
                            }
                            finally {
                                CodeAccessPermission.RevertAssert();
                            }
                        }

                        if (s == null)
                            s = WebConfigurationHost.DefaultSiteName;

                        _siteName = s;
                    }
                }
            }

            return _siteName;
        }

        // site ID
        [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "This method is not dangerous.")]
        private String GetSiteID() {
            if (_siteID == null) {
                lock (this) {
                    if (_siteID == null) {
                        String s = null;

                        if (_appHost != null) {
                            //
                            InternalSecurityPermissions.Unrestricted.Assert();
                            try {
                                s = _appHost.GetSiteID();
                            }
                            finally {
                                CodeAccessPermission.RevertAssert();
                            }
                        }

                        if (s == null)
                            s = WebConfigurationHost.DefaultSiteID;

                        _siteID = s.ToLower(CultureInfo.InvariantCulture);
                    }
                }
            }

            return _siteID;
        }

        // Return the configPath for the app, e.g. "machine/webroot/1/myapp"
        private String GetAppConfigPath() {
            if (_appConfigPath == null) {
                _appConfigPath = WebConfigurationHost.GetConfigPathFromSiteIDAndVPath(SiteID, ApplicationVirtualPathObject);
            }

            return _appConfigPath;
        }

        // Return the call context slot name to use for a virtual path
        private static string GetFixedMappingSlotName(VirtualPath virtualPath) {
            return "MapPath_" + virtualPath.VirtualPathString.ToLowerInvariant().GetHashCode().ToString(CultureInfo.InvariantCulture);
        }

        /*
         * Map a virtual path to a physical path.  i.e. the physicalPath will be returned
         * when MapPath is called on the virtual path, bypassing the IApplicationHost
         */
        private static string GetVirtualPathToFileMapping(VirtualPath virtualPath) {
            return CallContext.GetData(GetFixedMappingSlotName(virtualPath)) as string;
        }

        /*
         * Map a virtual path to a physical path.  i.e. the physicalPath will be returned
         * when MapPath is called on the virtual path, bypassing the IApplicationHost
         */
        internal static object AddVirtualPathToFileMapping(
            VirtualPath virtualPath, string physicalPath) {

            // Save the mapping in the call context, using a key derived from the
            // virtual path.  The mapping is only valid for the duration of the request.
            CallContext.SetData(GetFixedMappingSlotName(virtualPath), physicalPath);

            // Return a mapping object to keep track of the virtual path, and of the current
            // virtualPathProvider.
            VirtualPathToFileMappingState state = new VirtualPathToFileMappingState();
            state.VirtualPath = virtualPath;
            state.VirtualPathProvider = _theHostingEnvironment._virtualPathProvider;

            // Always use the MapPathBasedVirtualPathProvider, otherwise the mapping mechanism
            // doesn't work (VSWhidbey 420702)
            // Set/Get the VPP on the call context so as not to affect other concurrent requests  (Dev10 852255)
            CallContext.SetData(TemporaryVirtualPathProviderKey, _theHostingEnvironment._mapPathBasedVirtualPathProvider);

            return state;
        }

        internal static void ClearVirtualPathToFileMapping(object state) {

            VirtualPathToFileMappingState mapping = (VirtualPathToFileMappingState)state;

            // Clear the mapping from the call context
            CallContext.SetData(GetFixedMappingSlotName(mapping.VirtualPath), null);

            // Restore the previous VirtualPathProvider
            // Set/Get the VPP on the call context so as not to affect other concurrent requests  (Dev10 852255)
            CallContext.SetData(TemporaryVirtualPathProviderKey, null);
        }

        private string MapPathActual(VirtualPath virtualPath, bool permitNull)
        {
            string result = null;

            Debug.Assert(virtualPath != null);

            virtualPath.FailIfRelativePath();

            VirtualPath reqpath = virtualPath;

            if (String.CompareOrdinal(reqpath.VirtualPathString, _appVirtualPath.VirtualPathString) == 0) {
                // for application path don't need to call app host
                Debug.Trace("MapPath", reqpath  +" is the app path");
                result = _appPhysicalPath;
            }
            else {
                using (new ProcessImpersonationContext()) {
                    // If there is a mapping for this virtual path in the call context, use it
                    result = GetVirtualPathToFileMapping(reqpath);

                    if (result == null) {
                        // call host's mappath
                        if (_configMapPath == null) {
                            Debug.Trace("MapPath", "Missing _configMapPath");
                            throw new InvalidOperationException(SR.GetString(SR.Cannot_map_path, reqpath));
                        }
                        Debug.Trace("MapPath", "call ConfigMapPath (" + reqpath + ")");

                        // see if the IConfigMapPath provider implements the interface
                        // with VirtualPath
                        try {
                            if (null != _configMapPath2) {
                                result = _configMapPath2.MapPath(GetSiteID(), reqpath);
                            }
                            else {
                                result = _configMapPath.MapPath(GetSiteID(), reqpath.VirtualPathString);
                            }
                            if (HttpRuntime.IsMapPathRelaxed)
                                result = HttpRuntime.GetRelaxedMapPathResult(result);
                        } catch {
                            if (HttpRuntime.IsMapPathRelaxed)
                                result = HttpRuntime.GetRelaxedMapPathResult(null);
                            else
                                throw;
                        }
                    }
                }
            }

            if (String.IsNullOrEmpty(result)) {
                Debug.Trace("MapPath", "null Result");
                if (!permitNull) {
                    if (HttpRuntime.IsMapPathRelaxed)
                        result = HttpRuntime.GetRelaxedMapPathResult(null);
                    else
                        throw new InvalidOperationException(SR.GetString(SR.Cannot_map_path, reqpath));
                }
            }
            else {
                // ensure extra '\\' in the physical path if the virtual path had extra '/'
                // and the other way -- no extra '\\' in physical if virtual didn't have it.
                if (virtualPath.HasTrailingSlash) {
                    if (!UrlPath.PathEndsWithExtraSlash(result) && !UrlPath.PathIsDriveRoot(result))
                        result = result + "\\";
                }
                else {
                    if (UrlPath.PathEndsWithExtraSlash(result) && !UrlPath.PathIsDriveRoot(result))
                        result = result.Substring(0, result.Length - 1);
                }

                Debug.Trace("MapPath", "    result=" + result);
            }

            return result;
        }

        //
        // public static methods
        //


        // register protocol handler with hosting environment
        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public static void RegisterObject(IRegisteredObject obj) {
            if (_theHostingEnvironment != null)
                _theHostingEnvironment.RegisterRunningObjectInternal(obj);
        }


        // unregister protocol handler from hosting environment
        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public static void UnregisterObject(IRegisteredObject obj) {
            if (_theHostingEnvironment != null)
                _theHostingEnvironment.UnregisterRunningObjectInternal(obj);
        }

        // Schedules a task which can run in the background, independent of any request.
        // This differs from a normal ThreadPool work item in that ASP.NET can keep track
        // of how many work items registered through this API are currently running, and
        // the ASP.NET runtime will try not to delay AppDomain shutdown until these work
        // items have finished executing.
        //
        // Usage notes:
        // - This API cannot be called outside of an ASP.NET-managed AppDomain.
        // - The caller's ExecutionContext is not flowed to the work item.
        // - Scheduled work items are not guaranteed to ever execute, e.g., when AppDomain
        //   shutdown has already started by the time this API was called.
        // - The provided CancellationToken will be signaled when the application is
        //   shutting down. The work item should make every effort to honor this token.
        //   If a work item does not honor this token and continues executing it will
        //   eventually be considered rogue, and the ASP.NET runtime will rudely unload
        //   the AppDomain without waiting for the work item to finish.
        //
        // This overload of QueueBackgroundWorkItem takes a void-returning callback; the
        // work item will be considered finished when the callback returns.
        [SecurityPermission(SecurityAction.LinkDemand, Unrestricted = true)]
        public static void QueueBackgroundWorkItem(Action<CancellationToken> workItem) {
            if (workItem == null) {
                throw new ArgumentNullException("workItem");
            }

            QueueBackgroundWorkItem(ct => { workItem(ct); return _completedTask; });
        }

        // See documentation on the other overload for a general API overview.
        //
        // This overload of QueueBackgroundWorkItem takes a Task-returning callback; the
        // work item will be considered finished when the returned Task transitions to a
        // terminal state.
        [SecurityPermission(SecurityAction.LinkDemand, Unrestricted = true)]
        public static void QueueBackgroundWorkItem(Func<CancellationToken, Task> workItem) {
            if (workItem == null) {
                throw new ArgumentNullException("workItem");
            }
            if (_theHostingEnvironment == null) {
                throw new InvalidOperationException(); // can only be called within an ASP.NET AppDomain
            }

            _theHostingEnvironment.QueueBackgroundWorkItemInternal(workItem);
        }

        private void QueueBackgroundWorkItemInternal(Func<CancellationToken, Task> workItem) {
            Debug.Assert(workItem != null);

            BackgroundWorkScheduler scheduler = Volatile.Read(ref _backgroundWorkScheduler);

            // If the scheduler doesn't exist, lazily create it, but only allow one instance to ever be published to the backing field
            if (scheduler == null) {
                BackgroundWorkScheduler newlyCreatedScheduler = new BackgroundWorkScheduler(UnregisterObject, Misc.WriteUnhandledExceptionToEventLog);
                scheduler = Interlocked.CompareExchange(ref _backgroundWorkScheduler, newlyCreatedScheduler, null) ?? newlyCreatedScheduler;
                if (scheduler == newlyCreatedScheduler) {
                    RegisterObject(scheduler); // Only call RegisterObject if we just created the "winning" one
                }
            }

            scheduler.ScheduleWorkItem(workItem);
        }

        // This event is a simple way to hook IStopListeningRegisteredObject.StopListening
        // without needing to call RegisterObject. The same restrictions which apply to
        // that method apply to this event.
        public static event EventHandler StopListening;

        //
        // public static methods for the user code to call
        //


        public static void IncrementBusyCount() {
            if (_theHostingEnvironment != null)
                _theHostingEnvironment.IncrementBusyCountInternal();
        }


        public static void DecrementBusyCount() {
            if (_theHostingEnvironment != null)
                _theHostingEnvironment.DecrementBusyCountInternal();
        }


        public static void MessageReceived() {
            if (_theHostingEnvironment != null)
                _theHostingEnvironment.MessageReceivedInternal();
        }

        public static bool InClientBuildManager {
            get {
                return BuildManagerHost.InClientBuildManager;
            }
        }

        public static bool IsHosted {
            get {
                return (_theHostingEnvironment != null);
            }
        }

        internal static bool IsUnderIISProcess {
            get {
                String process = VersionInfo.ExeName;

                return process == "aspnet_wp" ||
                       process == "w3wp" ||
                       process == "inetinfo";
            }
        }

        internal static bool IsUnderIIS6Process {
            get {
                return VersionInfo.ExeName == "w3wp";
            }
        }

        public static IApplicationHost ApplicationHost {
            //DevDivBugs 109864: ASP.NET: path discovery issue - In low trust, it is possible to get the physical path of any virtual path on the machine
            [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
            get {
                if (_theHostingEnvironment == null)
                    return null;

                return _theHostingEnvironment._appHost;
            }
        }

       internal static IApplicationHost ApplicationHostInternal {
            get {
                if (_theHostingEnvironment == null)
                    return null;

                return _theHostingEnvironment._appHost;
            }
        }

        internal IApplicationHost InternalApplicationHost {
            get {
                return _appHost;
            }
        }

        /// <devdoc>
        ///    <para>A group of repleacable monitor objects used by ASP.Net subsystems to maintain
        ///       application health.</para>
        /// </devdoc>
        public static ApplicationMonitors ApplicationMonitors {
            get {
                if (_theHostingEnvironment == null)
                    return null;

                return _theHostingEnvironment._applicationMonitors;
            }
        }

        internal static int BusyCount {
            get {
                if (_theHostingEnvironment == null)
                    return 0;

                return _theHostingEnvironment._busyCount;
            }
        }

        internal static bool ShutdownInitiated {
            get {
                if (_theHostingEnvironment == null)
                    return false;

                return _theHostingEnvironment._shutdownInitiated;
            }
        }


        internal static bool ShutdownInProgress {
            get {
                if (_theHostingEnvironment == null)
                    return false;

                return _theHostingEnvironment._shutdownInProgress;
            }
        }


        /// <devdoc>
        ///    <para>The application ID (metabase path in IIS hosting).</para>
        /// </devdoc>
        public static String ApplicationID {
            get {
                if (_theHostingEnvironment == null)
                    return null;

                InternalSecurityPermissions.AspNetHostingPermissionLevelHigh.Demand();
                return _theHostingEnvironment._appId;
            }
        }

        internal static String ApplicationIDNoDemand {
            get {
                if (_theHostingEnvironment == null) {
                    return null;
                }

                return _theHostingEnvironment._appId;
            }
        }


        /// <devdoc>
        ///    <para>Physical path to the application root.</para>
        /// </devdoc>
        public static String ApplicationPhysicalPath {
            get {
                if (_theHostingEnvironment == null)
                    return null;

                InternalSecurityPermissions.AppPathDiscovery.Demand();
                return _theHostingEnvironment._appPhysicalPath;
            }
        }


        /// <devdoc>
        ///    <para>Virtual path to the application root.</para>
        /// </devdoc>
        public static String ApplicationVirtualPath {
            get {
                return VirtualPath.GetVirtualPathStringNoTrailingSlash(ApplicationVirtualPathObject);
            }
        }

        internal static VirtualPath ApplicationVirtualPathObject {
            get {
                if (_theHostingEnvironment == null)
                    return null;

                return _theHostingEnvironment._appVirtualPath;
            }
        }


        /// <devdoc>
        ///    <para>Site name.</para>
        /// </devdoc>
        public static String SiteName {
            get {
                if (_theHostingEnvironment == null)
                    return null;

                InternalSecurityPermissions.AspNetHostingPermissionLevelMedium.Demand();
                return _theHostingEnvironment.GetSiteName();
            }
        }

        internal static String SiteNameNoDemand {
            get {
                if (_theHostingEnvironment == null)
                    return null;

                return _theHostingEnvironment.GetSiteName();
            }
        }

        internal static String SiteID {
            get {
                if (_theHostingEnvironment == null)
                    return null;

                return _theHostingEnvironment.GetSiteID();
            }
        }

        internal static IConfigMapPath ConfigMapPath {
            get {
                if (_theHostingEnvironment == null)
                    return null;

                return _theHostingEnvironment._configMapPath;
            }
        }

        internal static String AppConfigPath {
            get {
                if (_theHostingEnvironment == null) {
                    return null;
                }

                return _theHostingEnvironment.GetAppConfigPath();
            }
        }

        // See comments in ApplicationManager.CreateAppDomainWithHostingEnvironment. This is the public API to access the
        // information we determined in that method. Defaults to 'false' if our AppDomain data isn't present.
        public static bool IsDevelopmentEnvironment {
            get {
                return (AppDomain.CurrentDomain.GetData(".devEnvironment") as bool?) == true;
            }
        }


        /// <devdoc>
        ///    <para>
        ///       Gets a reference to the System.Web.Cache.Cache object for the current request.
        ///    </para>
        /// </devdoc>
        public static Cache Cache {
            get { return HttpRuntime.Cache; }
        }

        internal static NameValueCollection CacheStoreProviderSettings {
            get {
                if (_cacheProviderSettings == null) {
                    if (AppDomain.CurrentDomain.IsDefaultAppDomain()) {
                        Configuration webConfig = WebConfigurationManager.OpenWebConfiguration(null /* root web.config */);
                        CacheSection cacheConfig = (CacheSection)webConfig.GetSection("system.web/caching/cache");
                        if (cacheConfig != null && cacheConfig.DefaultProvider != null && !String.IsNullOrWhiteSpace(cacheConfig.DefaultProvider)) {
                            ProviderSettingsCollection cacheProviders = cacheConfig.Providers;
                            if (cacheProviders == null || cacheProviders.Count < 1) {
                                throw new ProviderException(SR.GetString(SR.Def_provider_not_found));
                            }

                            ProviderSettings cacheProviderSettings = cacheProviders[cacheConfig.DefaultProvider];
                            if (cacheProviderSettings == null) {
                                throw new ProviderException(SR.GetString(SR.Def_provider_not_found));
                            }

                            NameValueCollection settings = cacheProviderSettings.Parameters;
                            settings["name"] = cacheProviderSettings.Name;
                            settings["type"] = cacheProviderSettings.Type;
                            _cacheProviderSettings = settings;
                        }
                    }
                    else {
                        _cacheProviderSettings = AppDomain.CurrentDomain.GetData(".defaultObjectCacheProvider") as NameValueCollection;
                    }
                }

                // Return a copy, so the consumer can't mess with our copy of the settings
                if (_cacheProviderSettings != null)
                    return new NameValueCollection(_cacheProviderSettings);

                return null;
            }
        }

        // count of all app domain from app manager
        internal static int AppDomainsCount {
            get {
                ApplicationManager appManager = GetApplicationManager();
                return (appManager != null) ? appManager.AppDomainsCount : 0;
            }
        }

        internal static HostingEnvironmentParameters HostingParameters {
            get {
                if (_theHostingEnvironment == null)
                    return null;

                return _theHostingEnvironment._hostingParameters;
            }
        }

        // Return an integer that is unique for each appdomain.  This can be used
        // to create things like once-per-appdomain temp files without having different
        // processes/appdomains step on each other
        private static int s_appDomainUniqueInteger;
        internal static int AppDomainUniqueInteger {
            get {
                if (s_appDomainUniqueInteger == 0) {
                    s_appDomainUniqueInteger = Guid.NewGuid().GetHashCode();
                }

                return s_appDomainUniqueInteger;
            }
        }

        public static ApplicationShutdownReason ShutdownReason {
            get { return HttpRuntime.ShutdownReason; }
        }

        // Was CGlobalModule::OnGlobalStopListening called?
        internal static bool StopListeningWasCalled {
            get {
                return _stopListeningWasCalled;
            }
        }

        [SuppressMessage("Microsoft.Reliability", "CA2004:RemoveCallsToGCKeepAlive", Justification = "See comment in function.")]
        internal static void SetupStopListeningHandler() {
            StopListeningWaitHandle waitHandle = new StopListeningWaitHandle();

            RegisteredWaitHandle registeredWaitHandle = null;
            registeredWaitHandle = ThreadPool.UnsafeRegisterWaitForSingleObject(waitHandle, (_, __) => {
                // Referencing the field from within the callback should be sufficient to keep the GC
                // from reclaiming the RegisteredWaitHandle; the race condition is fine.
                GC.KeepAlive(registeredWaitHandle);
                OnGlobalStopListening();
            }, null, Timeout.Infinite, executeOnlyOnce: true);
        }

        private static void OnGlobalStopListening() {
            _stopListeningWasCalled = true;

            EventHandler eventHandler = StopListening;
            if (eventHandler != null) {
                eventHandler(null /* static means no sender */, EventArgs.Empty);
            }

            if (_theHostingEnvironment != null) {
                _theHostingEnvironment.FireStopListeningHandlers();
            }
        }

        [SuppressMessage("Microsoft.Reliability", "CA2002:DoNotLockOnObjectsWithWeakIdentity", Justification = "'this' always has strong identity.")]
        private void FireStopListeningHandlers() {
            List<IStopListeningRegisteredObject> listeners = new List<IStopListeningRegisteredObject>();
            lock (this) {
                foreach (DictionaryEntry e in _registeredObjects) {
                    IStopListeningRegisteredObject listener = e.Key as IStopListeningRegisteredObject;
                    if (listener != null) {
                        listeners.Add(listener);
                    }
                }
            }

            foreach (var listener in listeners) {
                listener.StopListening();
            }
        }

        /// <devdoc>
        ///    <para>Initiate app domain unloading for the current app.</para>
        /// </devdoc>
        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public static void InitiateShutdown() {
            if (_theHostingEnvironment != null)
                _theHostingEnvironment.InitiateShutdownInternal();
        }

        internal static void InitiateShutdownWithoutDemand() {
            if (_theHostingEnvironment != null)
                _theHostingEnvironment.InitiateShutdownInternal();
        }

        //
        // Internal methods for the ApplicationManager to suspend / resume this application.
        // Using GCHandle instead of ObjectHandle means we don't need to worry about lease lifetimes.
        //

        internal IntPtr SuspendApplication() {
            var state = _suspendManager.Suspend();
            return GCUtil.RootObject(state);
        }

        internal void ResumeApplication(IntPtr state) {
            var unwrappedState = GCUtil.UnrootObject(state);
            _suspendManager.Resume(unwrappedState);
        }

        /// <devdoc>
        ///    <para>Maps a virtual path to a physical path.</para>
        /// </devdoc>
        public static string MapPath(string virtualPath) {
            return MapPath(VirtualPath.Create(virtualPath));
        }

        internal static string MapPath(VirtualPath virtualPath) {
            if (_theHostingEnvironment == null)
                return null;

            String path = MapPathInternal(virtualPath);

            if (path != null)
                InternalSecurityPermissions.PathDiscovery(path).Demand();

            return path;
        }

        internal static String MapPathInternal(string virtualPath) {
            return MapPathInternal(VirtualPath.Create(virtualPath));
        }

        internal static String MapPathInternal(VirtualPath virtualPath) {
            if (_theHostingEnvironment == null) {
                return null;
            }

            return _theHostingEnvironment.MapPathActual(virtualPath, false);
        }

        internal static String MapPathInternal(string virtualPath, bool permitNull) {
            return MapPathInternal(VirtualPath.Create(virtualPath), permitNull);
        }

        internal static String MapPathInternal(VirtualPath virtualPath, bool permitNull) {
            if (_theHostingEnvironment == null) {
                return null;
            }

            return _theHostingEnvironment.MapPathActual(virtualPath, permitNull);
        }

        internal static string MapPathInternal(string virtualPath, string baseVirtualDir, bool allowCrossAppMapping) {
            return MapPathInternal(VirtualPath.Create(virtualPath),
                VirtualPath.CreateNonRelative(baseVirtualDir), allowCrossAppMapping);
        }

        internal static string MapPathInternal(VirtualPath virtualPath, VirtualPath baseVirtualDir, bool allowCrossAppMapping) {
            Debug.Assert(baseVirtualDir != null, "baseVirtualDir != null");

            // Combine it with the base and reduce
            virtualPath = baseVirtualDir.Combine(virtualPath);

            if (!allowCrossAppMapping && !virtualPath.IsWithinAppRoot)
                throw new ArgumentException(SR.GetString(SR.Cross_app_not_allowed, virtualPath));

            return MapPathInternal(virtualPath);
        }

        internal static WebApplicationLevel GetPathLevel(String path) {
            WebApplicationLevel pathLevel = WebApplicationLevel.AboveApplication;

            if (_theHostingEnvironment != null && !String.IsNullOrEmpty(path)) {
                String appPath = ApplicationVirtualPath;

                if (appPath == "/") {
                    if (path == "/") {
                        pathLevel = WebApplicationLevel.AtApplication;
                    }
                    else if (path[0] == '/') {
                        pathLevel = WebApplicationLevel.BelowApplication;
                    }
                }
                else {
                    if (StringUtil.EqualsIgnoreCase(appPath, path)) {
                        pathLevel = WebApplicationLevel.AtApplication;
                    }
                    else if (path.Length > appPath.Length && path[appPath.Length] == '/' &&
                        StringUtil.StringStartsWithIgnoreCase(path, appPath)) {

                        pathLevel = WebApplicationLevel.BelowApplication;
                    }
                }
            }

            return pathLevel;
        }


        //
        // Impersonation helpers
        //
        // user token for the app (hosting / unc)
        internal static IntPtr ApplicationIdentityToken {
            get {
                if (_theHostingEnvironment == null) {
                    return IntPtr.Zero;
                }
                else {
                    if (_theHostingEnvironment._appIdentityTokenSet)
                        return _theHostingEnvironment._appIdentityToken;
                    else
                        return _theHostingEnvironment._configToken;
                }
            }
        }


        // check if application impersonation != process impersonation
        internal static bool HasHostingIdentity {
            get {
                return (ApplicationIdentityToken != IntPtr.Zero);
            }
        }

        // impersonate application identity
        [SecurityPermission(SecurityAction.Demand, ControlPrincipal = true)]
        public static IDisposable Impersonate() {
            return new ApplicationImpersonationContext();
        }

        // impersonate the given user identity
        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public static IDisposable Impersonate(IntPtr token) {
            if (token == IntPtr.Zero) {
                return new ProcessImpersonationContext();
            }
            else {
                return new ImpersonationContext(token);
            }
        }

        // impersonate as configured for a given path
        [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
        public static IDisposable Impersonate(IntPtr userToken, String virtualPath) {
            virtualPath = UrlPath.MakeVirtualPathAppAbsoluteReduceAndCheck(virtualPath);

            if (_theHostingEnvironment == null) {
                return Impersonate(userToken);
            }

            IdentitySection c = RuntimeConfig.GetConfig(virtualPath).Identity;
            if (c.Impersonate) {
                if (c.ImpersonateToken != IntPtr.Zero) {
                    return new ImpersonationContext(c.ImpersonateToken);
                }
                else {
                    return new ImpersonationContext(userToken);
                }
            }
            else {
                return new ApplicationImpersonationContext();
            }
        }

        //
        //  Culture helpers
        //

        public static IDisposable SetCultures() {
            return SetCultures(RuntimeConfig.GetAppLKGConfig().Globalization);
        }

        public static IDisposable SetCultures(string virtualPath) {
            virtualPath = UrlPath.MakeVirtualPathAppAbsoluteReduceAndCheck(virtualPath);
            return SetCultures(RuntimeConfig.GetConfig(virtualPath).Globalization);
        }

        private static IDisposable SetCultures(GlobalizationSection gs) {
            CultureContext c = new CultureContext();

            if (gs != null) {
                CultureInfo culture = null;
                CultureInfo uiCulture = null;

                if (gs.Culture != null && gs.Culture.Length > 0) {
                    try {
                        culture = HttpServerUtility.CreateReadOnlyCultureInfo(gs.Culture);
                    }
                    catch {
                    }
                }

                if (gs.UICulture != null && gs.UICulture.Length > 0) {
                    try {
                        uiCulture = HttpServerUtility.CreateReadOnlyCultureInfo(gs.UICulture);
                    }
                    catch {
                    }
                }

                c.SetCultures(culture, uiCulture);
            }

            return c;
        }


        class CultureContext : IDisposable {
            CultureInfo _savedCulture;
            CultureInfo _savedUICulture;

            internal CultureContext() {
            }

            void IDisposable.Dispose() {
                RestoreCultures();
            }

            internal void SetCultures(CultureInfo culture, CultureInfo uiCulture) {
                CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
                CultureInfo currentUICulture = Thread.CurrentThread.CurrentUICulture;

                if (culture != null && culture != currentCulture) {
                    Thread.CurrentThread.CurrentCulture = culture;
                    _savedCulture = currentCulture;
                }

                if (uiCulture != null && uiCulture != currentCulture) {
                    Thread.CurrentThread.CurrentUICulture = uiCulture;
                    _savedUICulture = currentUICulture;
                }
            }

            internal void RestoreCultures() {
                if (_savedCulture != null && _savedCulture != Thread.CurrentThread.CurrentCulture) {
                    Thread.CurrentThread.CurrentCulture = _savedCulture;
                    _savedCulture = null;
                }

                if (_savedUICulture != null && _savedUICulture != Thread.CurrentThread.CurrentUICulture) {
                    Thread.CurrentThread.CurrentUICulture = _savedUICulture;
                    _savedUICulture = null;
                }
            }
        }

        //
        // VirtualPathProvider related code
        //

        private VirtualPathProvider _virtualPathProvider;
        private VirtualPathProvider _mapPathBasedVirtualPathProvider;


        public static VirtualPathProvider VirtualPathProvider {
            get {
                if (_theHostingEnvironment == null)
                    return null;

                // Set/Get the VPP on the call context so as not to affect other concurrent requests  (Dev10 852255)
                var tempVPP = CallContext.GetData(TemporaryVirtualPathProviderKey);
                if (tempVPP != null) {
                    return tempVPP as VirtualPathProvider;
                }

                return _theHostingEnvironment._virtualPathProvider;
            }
        }

        internal static bool UsingMapPathBasedVirtualPathProvider {
            get {
                if (_theHostingEnvironment == null)
                    return true;

                return (_theHostingEnvironment._virtualPathProvider ==
                    _theHostingEnvironment._mapPathBasedVirtualPathProvider);
            }
        }

        // [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.High)]
        // Removed the above LinkDemand for AspNetHostingPermissionLevel.High. If we decide to add VPP
        // support for config in the future, we should have a separate API with a demand for registering
        // VPPs supporting configuration.
        public static void RegisterVirtualPathProvider(VirtualPathProvider virtualPathProvider) {

            if (_theHostingEnvironment == null)
                throw new InvalidOperationException();

            // Ignore the VirtualPathProvider on precompiled sites (VSWhidbey 368169,404844)
            if (BuildManager.IsPrecompiledApp)
                return;

            RegisterVirtualPathProviderInternal(virtualPathProvider);
        }

        internal static void RegisterVirtualPathProviderInternal(VirtualPathProvider virtualPathProvider) {
            VirtualPathProvider previous = _theHostingEnvironment._virtualPathProvider;
            _theHostingEnvironment._virtualPathProvider = virtualPathProvider;

            // Give it the previous provider so it can delegate if needed
            virtualPathProvider.Initialize(previous);
        }

        // Helper class used to keep track of state when using
        // AddVirtualPathToFileMapping & ClearVirtualPathToFileMapping
        internal class VirtualPathToFileMappingState {
            internal VirtualPath VirtualPath;
            internal VirtualPathProvider VirtualPathProvider;
        }

        internal static IProcessHostSupportFunctions SupportFunctions {
            get {
                return _functions;
            }
            set {
                _functions = value;
            }
        }

        [SuppressMessage("Microsoft.Naming", "CA1705:LongAcronymsShouldBePascalCased",
                         Justification="matches casing of config attribute")]
        public static int MaxConcurrentRequestsPerCPU {
            get {
                if (!HttpRuntime.UseIntegratedPipeline) {
                    throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
                }
                return UnsafeIISMethods.MgdGetMaxConcurrentRequestsPerCPU();
            }
            [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
            set {
                if (!HttpRuntime.UseIntegratedPipeline) {
                    throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
                }
                int hr = UnsafeIISMethods.MgdSetMaxConcurrentRequestsPerCPU(value);
                switch (hr) {
                    case HResults.S_FALSE:
                        // Because "maxConcurrentRequestsPerCPU" is currently zero, we cannot set the value, since that would
                        // enable the feature, which can only be done via configuration.
                        throw new InvalidOperationException(SR.GetString(SR.Queue_limit_is_zero, "maxConcurrentRequestsPerCPU"));
                    case HResults.E_INVALIDARG:
                        // The value must be greater than zero.  A value of zero would disable the feature, but this can only be done via configuration.
                        throw new ArgumentException(SR.GetString(SR.Invalid_queue_limit));
                }
            }
        }

        [SuppressMessage("Microsoft.Naming", "CA1705:LongAcronymsShouldBePascalCased",
                         Justification="matches casing of config attribute")]
        public static int MaxConcurrentThreadsPerCPU {
            get {
                if (!HttpRuntime.UseIntegratedPipeline) {
                    throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
                }
                return UnsafeIISMethods.MgdGetMaxConcurrentThreadsPerCPU();
            }
            [SecurityPermission(SecurityAction.Demand, Unrestricted = true)]
            set {
                if (!HttpRuntime.UseIntegratedPipeline) {
                    throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
                }
                int hr = UnsafeIISMethods.MgdSetMaxConcurrentThreadsPerCPU(value);
                switch (hr) {
                    case HResults.S_FALSE:
                        // Because "maxConcurrentThreadsPerCPU" is currently zero, we cannot set the value, since that would
                        // enable the feature, which can only be done via configuration.
                        throw new InvalidOperationException(SR.GetString(SR.Queue_limit_is_zero, "maxConcurrentThreadsPerCPU"));
                    case HResults.E_INVALIDARG:
                        // The value must be greater than zero.  A value of zero would disable the feature, but this can only be done via configuration.
                        throw new ArgumentException(SR.GetString(SR.Invalid_queue_limit));
                }
            }
        }

        /// <summary>
        /// Returns the ASP.NET hosted domain.
        /// </summary>
        internal AppDomain HostedAppDomain {
            get {
                return AppDomain.CurrentDomain;
            }
        }

    }
}