ISAPIApplicationHost.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / Hosting / ISAPIApplicationHost.cs / 3 / ISAPIApplicationHost.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

/* 
 * Application host for IIS 5.0 and 6.0 
 *
 * Copyright (c) 1999 Microsoft Corporation 
 */

namespace System.Web.Hosting {
    using Microsoft.Win32; 
    using System.IO;
    using System.Text; 
    using System.Web; 
    using System.Web.Configuration;
    using System.Web.Util; 
    using System.Web.Management;


    // helper class to implement AppHost based on ISAPI 
    internal class ISAPIApplicationHost : MarshalByRefObject, IApplicationHost {
        private String _appId; 
        private String _siteID; 
        private String _siteName;
        private VirtualPath _virtualPath; 
        private String _physicalPath;
        private IProcessHostSupportFunctions _functions;

        private const int MAX_PATH = 260; 
        private const string LMW3SVC_PREFIX = "/LM/W3SVC/";
        private const string DEFAULT_SITEID = "1"; 
        private const string DEFAULT_APPID_PREFIX = "/LM/W3SVC/1/ROOT"; 

        internal ISAPIApplicationHost(string appIdOrVirtualPath, string physicalPath, bool validatePhysicalPath, IProcessHostSupportFunctions functions) { 
            // appIdOrVirtualPath is either a full metabase path, or just a virtual path
            // e.g. /LM/W3SVC/1/Root/MyApp ot /MyApp
            // Figure out which one we have, and get the other one from it
            _functions = functions; 

            // make sure the functions are set in the default domain 
            if (null == _functions) { 
                ProcessHost h = ProcessHost.DefaultHost;
 
                if (null != h) {
                    _functions = h.SupportFunctions;

                    if (null != _functions) { 
                        HostingEnvironment.SupportFunctions = _functions;
                    } 
                } 
            }
 
            IServerConfig serverConfig = ServerConfig.GetInstance();

            if (StringUtil.StringStartsWithIgnoreCase(appIdOrVirtualPath, LMW3SVC_PREFIX)) {
                _appId = appIdOrVirtualPath; 
                _virtualPath = VirtualPath.Create(ExtractVPathFromAppId(_appId));
                _siteID = ExtractSiteIdFromAppId(_appId); 
                _siteName = serverConfig.GetSiteNameFromSiteID(_siteID); 
            }
            else { 
                _virtualPath = VirtualPath.Create(appIdOrVirtualPath);
                _appId = GetDefaultAppIdFromVPath(_virtualPath.VirtualPathString);
                _siteID = DEFAULT_SITEID;
                _siteName = serverConfig.GetSiteNameFromSiteID(_siteID); 
            }
 
            // Get the physical path from the virtual path if it wasn't passed in 
            if (physicalPath == null) {
                _physicalPath = serverConfig.MapPath(this, _virtualPath); 
            }
            else {
                _physicalPath = physicalPath;
            } 

            if (validatePhysicalPath) { 
                if (!Directory.Exists(_physicalPath)) { 
                    throw new HttpException(SR.GetString(SR.Invalid_IIS_app, appIdOrVirtualPath));
                } 
            }
        }

        internal ISAPIApplicationHost(string appIdOrVirtualPath, string physicalPath, bool validatePhysicalPath) 
            :this(appIdOrVirtualPath, physicalPath, validatePhysicalPath, null)
        {} 
 
        public override Object InitializeLifetimeService() {
            return null; // never expire lease 
        }

        // IApplicationHost implementation
        string IApplicationHost.GetVirtualPath() { 
            return _virtualPath.VirtualPathString;
        } 
 
        String IApplicationHost.GetPhysicalPath() {
            return _physicalPath; 
        }

        IConfigMapPathFactory IApplicationHost.GetConfigMapPathFactory() {
            return new ISAPIConfigMapPathFactory(); 
        }
 
        IntPtr IApplicationHost.GetConfigToken() { 
            if (null != _functions) {
                return _functions.GetConfigToken(_appId); 
            }
            IntPtr token = IntPtr.Zero;

            String username; 
            String password;
            IServerConfig serverConfig = ServerConfig.GetInstance(); 
            bool hasUncUser = serverConfig.GetUncUser(this, _virtualPath, out username, out password); 
            if (hasUncUser) {
                try { 
                    String error;
                    token = IdentitySection.CreateUserToken(username, password, out error);
                }
                catch { 
                }
            } 
 
            return token;
        } 

        String IApplicationHost.GetSiteName() {
            return _siteName;
        } 

        String IApplicationHost.GetSiteID() { 
            return _siteID; 
        }
 
        void IApplicationHost.MessageReceived() {
        // make this method call a no-op
        // it will be removed soon altogether
        } 

        internal string AppId { 
            get { return _appId; } 
        }
 
        private static String ExtractVPathFromAppId(string id) {
            // app id is /LM/W3SVC/1/ROOT for root or /LM/W3SVC/1/ROOT/VDIR

            // find fifth / (assuming it starts with /) 
            int si = 0;
            for (int i = 1; i < 5; i++) { 
                si = id.IndexOf('/', si+1); 
                if (si < 0)
                    break; 
            }

            if (si < 0) // root?
                return "/"; 
            else
                return id.Substring(si); 
        } 

        private static String GetDefaultAppIdFromVPath(string virtualPath) { 
            if (virtualPath.Length == 1 && virtualPath[0] == '/') {
                return DEFAULT_APPID_PREFIX;
            }
            else { 
                return DEFAULT_APPID_PREFIX + virtualPath;
            } 
        } 

        private static String ExtractSiteIdFromAppId(string id) { 
            // app id is /LM/W3SVC/1/ROOT for root or /LM/W3SVC/1/ROOT/VDIR
            // the site id is right after prefix
            int offset = LMW3SVC_PREFIX.Length;
            int si = id.IndexOf('/', offset); 
            return (si > 0) ? id.Substring(offset, si - offset) : DEFAULT_SITEID;
        } 
 
        internal IProcessHostSupportFunctions SupportFunctions {
            get { 
                return _functions;
            }
        }
 
        internal string ResolveRootWebConfigPath() {
            string rootWebConfigPath = null; 
 
            if (null != _functions) {
                rootWebConfigPath = _functions.GetRootWebConfigFilename(); 
            }

            return rootWebConfigPath;
        } 

 
    } 

    // 
    // Create an instance of IConfigMapPath in the worker appdomain.
    // By making the class Serializable, the call to IConfigMapPathFactory.Create()
    // will execute in the worker appdomain.
    // 
    [Serializable()]
    internal class ISAPIConfigMapPathFactory : IConfigMapPathFactory { 
        IConfigMapPath IConfigMapPathFactory.Create(string virtualPath, string physicalPath) { 
            return IISMapPath.GetInstance();
        } 
    }
}
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK