MetabaseSettingsIis7.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / WasHosting / System / ServiceModel / WasHosting / MetabaseSettingsIis7.cs / 1 / MetabaseSettingsIis7.cs
                        

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

namespace System.ServiceModel.WasHosting 
{
    using System.Collections.Generic; 
    using System.Configuration; 
    using System.Diagnostics;
    using System.Security.Principal; 
    using System.ServiceModel.Activation;
    using System.ServiceModel.Channels;
    using System.Web.Hosting;
    using System.Web; 
    using Microsoft.Web.Administration;
    using System.Runtime.CompilerServices; 
    using System.Reflection; 
    using System.Security.Permissions;
 
    internal static class MetabaseSettingsIis7Constants
    {
        internal const string SitesSectionName = "system.applicationHost/sites";
        internal const string ClientCertMapAuthenticationName = "system.webServer/security/authentication/clientCertificateMappingAuthentication"; 
        internal const string IisClientCertMapAuthenticationName = "system.webServer/security/authentication/iisClientCertificateMappingAuthentication";
        internal const string AnonymousAuthenticationSectionName = "system.webServer/security/authentication/anonymousAuthentication"; 
        internal const string BasicAuthenticationSectionName = "system.webServer/security/authentication/basicAuthentication"; 
        internal const string DigestAuthenticationSectionName = "system.webServer/security/authentication/digestAuthentication";
        internal const string WindowsAuthenticationSectionName = "system.webServer/security/authentication/windowsAuthentication"; 
        internal const string SecurityAccessSectionName = "system.webServer/security/access";

        internal const string EnabledAttributeName = "enabled";
        internal const string RealmAttributeName = "realm"; 
        internal const string ValueAttributeName = "value";
        internal const string SslFlagsAttributeName = "sslFlags"; 
        internal const string ProviderElementName = "providers"; 
        internal const string BindingsElementName = "bindings";
        internal const string ProtocolAttributeName = "protocol"; 
        internal const string BindingInfoAttributeName = "bindingInformation";
        internal const string PathAttributeName = "path";
        internal const string EnabledProtocolsAttributeName = "enabledProtocols";
        internal const string NameAttributeName = "name"; 

        internal const string CommaSeparator = ","; 
 
        internal const string WebConfigGetSectionMethodName = "GetSection";
    } 

    // MetabaseSettingsIis7 use ServerManager class to get Metabase settings. ServerManager
    // does not work in Longhorn Sever/SP1 builds.
    internal class MetabaseSettingsIis7 : MetabaseSettingsIis 
    {
        internal MetabaseSettingsIis7() 
            : base() 
        {
            if (!Iis7Helper.IsIis7) 
            {
                DiagnosticUtility.DebugAssert("MetabaseSettingsIis7 constructor must not be called when running outside of IIS7");
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(true);
            } 

            PopulateSiteProperties(); 
        } 

        void PopulateSiteProperties() 
        {
            Site site = ServerManagerWrapper.GetSite(HostingEnvironment.SiteName);
            DiagnosticUtility.DebugAssert(site != null, "Unable to find site.");
 
            //
            // Build up the binding table. 
            // 
            IDictionary> bindingList = ServerManagerWrapper.GetProtocolBindingTable(site);
 
            // Convert to string arrays
            foreach (KeyValuePair> entry in bindingList)
            {
                this.Bindings.Add(entry.Key, entry.Value.ToArray()); 
                entry.Value.Clear();
            } 
 
            // Clear the temporary buffer
            bindingList.Clear(); 

            //
            // Build up the protocol list.
            // 
            foreach (string protocolValue in ServerManagerWrapper.GetEnabledProtocols(site).Split(MetabaseSettingsIis7Constants.CommaSeparator.ToCharArray()))
            { 
                string protocol = protocolValue.ToLowerInvariant(); 

                if (this.Protocols.Contains(protocol)) 
                {
                    // Ignore duplicates.
                    continue;
                } 
                else if (string.Compare(protocol,Uri.UriSchemeHttp,StringComparison.OrdinalIgnoreCase)==0 ||
                         string.Compare(protocol,Uri.UriSchemeHttps,StringComparison.OrdinalIgnoreCase)==0) 
                { 
                    // Special casing HTTPS. If HTTP is enabled, it means that
                    // both HTTP and HTTPS are enabled. 
                    if (this.Bindings.ContainsKey(Uri.UriSchemeHttp))
                    {
                        this.Protocols.Add(Uri.UriSchemeHttp);
                    } 

                    if (this.Bindings.ContainsKey(Uri.UriSchemeHttps)) 
                    { 
                        this.Protocols.Add(Uri.UriSchemeHttps);
                    } 
                }
                else if (this.Bindings.ContainsKey(protocol))
                {
                    // We only take the protocols that have bindings. 
                    this.Protocols.Add(protocol);
                } 
            } 
        }
 
        protected override HostedServiceTransportSettings CreateTransportSettings(string relativeVirtualPath)
        {
            Debug.Print("MetabaseSettingsIis7.CreateTransportSettings() calling ServerManager.GetWebConfiguration() virtualPath: " + relativeVirtualPath);
 
            string absolutePath = VirtualPathUtility.ToAbsolute(relativeVirtualPath, HostingEnvironmentWrapper.ApplicationVirtualPath);
 
            Configuration config = 
                    ServerManagerWrapper.GetWebConfiguration(
                    HostingEnvironment.SiteName, 
                    absolutePath);

            HostedServiceTransportSettings transportSettings = new HostedServiceTransportSettings();
 
            ProcessAnonymousAuthentication(config, ref transportSettings);
            ProcessBasicAuthentication(config, ref transportSettings); 
            ProcessWindowsAuthentication(config, ref transportSettings); 
            ProcessDigestAuthentication(config, ref transportSettings);
            ProcessSecurityAccess(config, ref transportSettings); 

            return transportSettings;
        }
 
        void ProcessAnonymousAuthentication(Configuration config, ref HostedServiceTransportSettings transportSettings)
        { 
            ConfigurationSection section = ServerManagerWrapper.GetSection(config, MetabaseSettingsIis7Constants.AnonymousAuthenticationSectionName); 

            if ((section != null) && 
                ((bool)ServerManagerWrapper.GetAttributeValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName))
                )
            {
                transportSettings.AuthFlags = transportSettings.AuthFlags | AuthFlags.AuthAnonymous; 
            }
        } 
 
        void ProcessBasicAuthentication(Configuration config, ref HostedServiceTransportSettings transportSettings)
        { 
            ConfigurationSection section = ServerManagerWrapper.GetSection(config, MetabaseSettingsIis7Constants.BasicAuthenticationSectionName);

            if ((section != null) &&
                ((bool)ServerManagerWrapper.GetAttributeValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName)) 
                )
            { 
                transportSettings.AuthFlags = transportSettings.AuthFlags | AuthFlags.AuthBasic; 
                transportSettings.Realm = (string)ServerManagerWrapper.GetAttributeValue(section, MetabaseSettingsIis7Constants.RealmAttributeName);
            } 
        }

        void ProcessWindowsAuthentication(Configuration config, ref HostedServiceTransportSettings transportSettings)
        { 
            ConfigurationSection section = ServerManagerWrapper.GetSection(config, MetabaseSettingsIis7Constants.WindowsAuthenticationSectionName);
 
            if ((section != null) && 
                ((bool)ServerManagerWrapper.GetAttributeValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName))
                ) 
            {
                transportSettings.AuthFlags = transportSettings.AuthFlags | AuthFlags.AuthNTLM;

                List providerList = ServerManagerWrapper.GetProviders(section, MetabaseSettingsIis7Constants.ProviderElementName, 
                    MetabaseSettingsIis7Constants.ValueAttributeName);
 
                if (providerList.Count != 0) 
                {
                    transportSettings.AuthProviders = providerList.ToArray(); 
                }
            }
        }
 
        void ProcessDigestAuthentication(Configuration config, ref HostedServiceTransportSettings transportSettings)
        { 
            ConfigurationSection section = ServerManagerWrapper.GetSection(config, MetabaseSettingsIis7Constants.DigestAuthenticationSectionName); 

            if ((section != null) && 
                ((bool)ServerManagerWrapper.GetAttributeValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName))
                )
            {
                transportSettings.AuthFlags = transportSettings.AuthFlags | AuthFlags.AuthMD5; 
            }
        } 
 
        void ProcessSecurityAccess(Configuration config, ref HostedServiceTransportSettings transportSettings)
        { 
            ConfigurationSection section = ServerManagerWrapper.GetSection(config, MetabaseSettingsIis7Constants.SecurityAccessSectionName);

            // Check SSL Flags.
            if (section != null) 
            {
                int sslFlags = (int)ServerManagerWrapper.GetAttributeValue(section, MetabaseSettingsIis7Constants.SslFlagsAttributeName); 
                transportSettings.AccessSslFlags = (HttpAccessSslFlags)sslFlags; 

                // Clear SslMapCert field, which should not contain any useful data now. 
                transportSettings.AccessSslFlags &= ~(HttpAccessSslFlags.SslMapCert);
            }

            // Check whether IIS client certificate mapping is enabled. 
            section = ServerManagerWrapper.GetSection(config, MetabaseSettingsIis7Constants.IisClientCertMapAuthenticationName);
            if ((section != null) && 
               ((bool)ServerManagerWrapper.GetAttributeValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName)) 
                )
            { 
                transportSettings.AccessSslFlags |= HttpAccessSslFlags.SslMapCert;
            }
            else
            { 
                // Check whether Active Directory client certification mapping is enabled.
                section = ServerManagerWrapper.GetSection(config, MetabaseSettingsIis7Constants.ClientCertMapAuthenticationName); 
                if ((section != null) && 
                   ((bool)ServerManagerWrapper.GetAttributeValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName))
                    ) 
                {
                    transportSettings.AccessSslFlags |= HttpAccessSslFlags.SslMapCert;
                }
            } 
        }
 
        // wraps calls to ServerManager with Asserts as necessary to support partial trust scenarios 
        [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
        static class ServerManagerWrapper 
        {
            static internal Site GetSite(string name)
            {
                return new ServerManager().Sites[name]; 
            }
 
            static internal Configuration GetWebConfiguration(string siteName, string absolutePath) 
            {
                return new ServerManager().GetWebConfiguration(siteName, absolutePath); 
            }

            static internal ConfigurationSection GetSection(Configuration config, string sectionName)
            { 
                return config.GetSection(sectionName);
            } 
 
            static internal List GetProviders(ConfigurationSection section, string providerElementName, string valueAttributeName)
            { 
                List providerList = new List();
                foreach (ConfigurationElement element in section.GetCollection(providerElementName))
                {
                    providerList.Add((string)ServerManagerWrapper.GetAttributeValue(element, valueAttributeName)); 
                }
                return providerList; 
            } 

            static internal object GetAttributeValue(ConfigurationSection section, string attributeName) 
            {
                return section.GetAttribute(attributeName).Value;
            }
 
            static internal object GetAttributeValue(ConfigurationElement element, string attributeName)
            { 
                return element.GetAttribute(attributeName).Value; 
            }
 
            static internal IDictionary> GetProtocolBindingTable(Site site)
            {
                IDictionary> bindingList = new Dictionary>();
                foreach (Microsoft.Web.Administration.Binding binding in site.Bindings) 
                {
                    string protocol = binding.Protocol.ToLowerInvariant(); 
                    string bindingInformation = binding.BindingInformation; 
                    Debug.Print("MetabaseSettingsIis7.ctor() adding Protocol: " + protocol + " BindingInformation: " + bindingInformation);
 
                    if (!bindingList.ContainsKey(protocol))
                    {
                        bindingList.Add(protocol, new List());
                    } 
                    bindingList[protocol].Add(bindingInformation);
                } 
                return bindingList; 
            }
 
            static internal string GetEnabledProtocols(Site site)
            {
                Application application = site.Applications[HostingEnvironmentWrapper.ApplicationVirtualPath];
                DiagnosticUtility.DebugAssert(application != null, "Unable to find application."); 

                return application.EnabledProtocols; 
            } 
        }
    } 

    // MetabaseSettingsIis7V2 use WebConfigurationManager to get Metabase settings, we depend on
    // some methods which only availble in Longhorn Server/SP1 build.
    internal class MetabaseSettingsIis7V2 : MetabaseSettingsIis 
    {
        static MethodInfo getSectionMethod; 
 
        internal MetabaseSettingsIis7V2()
            : base() 
        {
            if (!Iis7Helper.IsIis7)
            {
                DiagnosticUtility.DebugAssert("MetabaseSettingsIis7V2 constructor must not be called when running outside of IIS7"); 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(true);
            } 
 
            PopulateSiteProperties();
        } 

        static internal MethodInfo GetSectionMethod
        {
            get 
            {
                if (getSectionMethod == null) 
                { 
                    Type type = typeof(WebConfigurationManager);
 
                    getSectionMethod = type.GetMethod(
                        MetabaseSettingsIis7Constants.WebConfigGetSectionMethodName,
                        new Type[3] { typeof(string), typeof(string), typeof(string) }
                        ); 
                }
                return getSectionMethod; 
            } 
        }
 
        void PopulateSiteProperties()
        {
            ConfigurationElement site = WebConfigurationManagerWrapper.GetSite(HostingEnvironment.SiteName);
            // 
            // Build up the binding table.
            // 
            IDictionary> bindingList = WebConfigurationManagerWrapper.GetProtocolBindingTable(site); 

            // Convert to string arrays 
            foreach (KeyValuePair> entry in bindingList)
            {
                this.Bindings.Add(entry.Key, entry.Value.ToArray());
                entry.Value.Clear(); 
            }
 
            // Clear the temporary buffer 
            bindingList.Clear();
 
            //
            // Build up the protocol list.
            //
 
            foreach (string protocolValue in WebConfigurationManagerWrapper.GetEnabledProtocols(site).Split(MetabaseSettingsIis7Constants.CommaSeparator.ToCharArray()))
            { 
                string protocol = protocolValue.ToLowerInvariant(); 

                if (this.Protocols.Contains(protocol)) 
                {
                    // Ignore duplicates.
                    continue;
                } 
                else if (string.Compare(protocol,Uri.UriSchemeHttp,StringComparison.OrdinalIgnoreCase) == 0 ||
                         string.Compare(protocol,Uri.UriSchemeHttps,StringComparison.OrdinalIgnoreCase) == 0) 
                { 
                    // Special casing HTTPS. If HTTP is enabled, it means that
                    // both HTTP and HTTPS are enabled. 
                    if (this.Bindings.ContainsKey(Uri.UriSchemeHttp))
                    {
                        this.Protocols.Add(Uri.UriSchemeHttp);
                    } 

                    if (this.Bindings.ContainsKey(Uri.UriSchemeHttps)) 
                    { 
                        this.Protocols.Add(Uri.UriSchemeHttps);
                    } 
                }
                else if (this.Bindings.ContainsKey(protocol))
                {
                    // We only take the protocols that have bindings. 
                    this.Protocols.Add(protocol);
                } 
            } 
        }
 
        protected override HostedServiceTransportSettings CreateTransportSettings(string relativeVirtualPath)
        {
            Debug.Print("MetabaseSettingsIis7.CreateTransportSettings() calling ServerManager.GetWebConfiguration() virtualPath: " + relativeVirtualPath);
 
            string absolutePath = VirtualPathUtility.ToAbsolute(relativeVirtualPath, HostingEnvironment.ApplicationVirtualPath);
 
            HostedServiceTransportSettings transportSettings = new HostedServiceTransportSettings(); 
            string siteName = HostingEnvironment.SiteName;
 
            ProcessAnonymousAuthentication(siteName, absolutePath, ref transportSettings);
            ProcessBasicAuthentication(siteName, absolutePath, ref transportSettings);
            ProcessWindowsAuthentication(siteName, absolutePath, ref transportSettings);
            ProcessDigestAuthentication(siteName, absolutePath, ref transportSettings); 
            ProcessSecurityAccess(siteName, absolutePath, ref transportSettings);
 
            return transportSettings; 
        }
 
        void ProcessAnonymousAuthentication(string siteName, string virtualPath, ref HostedServiceTransportSettings transportSettings)
        {
            ConfigurationSection section = WebConfigurationManagerWrapper.WebConfigGetSection(siteName, virtualPath, MetabaseSettingsIis7Constants.AnonymousAuthenticationSectionName);
 
            if ((section != null) &&
                ((bool)WebConfigurationManagerWrapper.GetValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName)) 
                ) 
            {
                transportSettings.AuthFlags = transportSettings.AuthFlags | AuthFlags.AuthAnonymous; 
            }
        }

        void ProcessBasicAuthentication(string siteName, string virtualPath, ref HostedServiceTransportSettings transportSettings) 
        {
            ConfigurationSection section = WebConfigurationManagerWrapper.WebConfigGetSection(siteName, virtualPath, MetabaseSettingsIis7Constants.BasicAuthenticationSectionName); 
 
            if ((section != null) &&
                ((bool)WebConfigurationManagerWrapper.GetValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName)) 
                )
            {
                transportSettings.AuthFlags = transportSettings.AuthFlags | AuthFlags.AuthBasic;
                transportSettings.Realm = (string)section.GetAttribute(MetabaseSettingsIis7Constants.RealmAttributeName).Value; 
            }
        } 
 
        void ProcessWindowsAuthentication(string siteName, string virtualPath, ref HostedServiceTransportSettings transportSettings)
        { 
            ConfigurationSection section = WebConfigurationManagerWrapper.WebConfigGetSection(siteName, virtualPath, MetabaseSettingsIis7Constants.WindowsAuthenticationSectionName);

            if ((section != null) &&
                ((bool)WebConfigurationManagerWrapper.GetValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName)) 
                )
            { 
                transportSettings.AuthFlags = transportSettings.AuthFlags | AuthFlags.AuthNTLM; 

                List providerList = WebConfigurationManagerWrapper.GetProviderList(section); 

                if (providerList.Count != 0)
                {
                    transportSettings.AuthProviders = providerList.ToArray(); 
                }
            } 
        } 

        void ProcessDigestAuthentication(string siteName, string virtualPath, ref HostedServiceTransportSettings transportSettings) 
        {
            ConfigurationSection section = WebConfigurationManagerWrapper.WebConfigGetSection(siteName, virtualPath, MetabaseSettingsIis7Constants.DigestAuthenticationSectionName);

            if ((section != null) && 
                ((bool)WebConfigurationManagerWrapper.GetValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName))
                ) 
            { 
                transportSettings.AuthFlags = transportSettings.AuthFlags | AuthFlags.AuthMD5;
            } 
        }

        void ProcessSecurityAccess(string siteName, string virtualPath, ref HostedServiceTransportSettings transportSettings)
        { 
            ConfigurationSection section = WebConfigurationManagerWrapper.WebConfigGetSection(siteName, virtualPath, MetabaseSettingsIis7Constants.SecurityAccessSectionName);
 
            // Check SSL Flags. 
            if (section != null)
            { 
                int sslFlags = (int)WebConfigurationManagerWrapper.GetValue(section, MetabaseSettingsIis7Constants.SslFlagsAttributeName);
                transportSettings.AccessSslFlags = (HttpAccessSslFlags)sslFlags;

                // Clear SslMapCert field, which should not contain any useful data now. 
                transportSettings.AccessSslFlags &= ~(HttpAccessSslFlags.SslMapCert);
            } 
 
            // Check whether IIS client certificate mapping is enabled.
            section = WebConfigurationManagerWrapper.WebConfigGetSection(siteName, virtualPath, MetabaseSettingsIis7Constants.IisClientCertMapAuthenticationName); 
            if ((section != null) &&
               ((bool)WebConfigurationManagerWrapper.GetValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName))
                )
            { 
                transportSettings.AccessSslFlags |= HttpAccessSslFlags.SslMapCert;
            } 
            else 
            {
                // Check whether Active Directory client certification mapping is enabled. 
                section = WebConfigurationManagerWrapper.WebConfigGetSection(siteName, virtualPath, MetabaseSettingsIis7Constants.ClientCertMapAuthenticationName);
                if ((section != null) &&
                   ((bool)WebConfigurationManagerWrapper.GetValue(section, MetabaseSettingsIis7Constants.EnabledAttributeName))
                    ) 
                {
                    transportSettings.AccessSslFlags |= HttpAccessSslFlags.SslMapCert; 
                } 
            }
        } 

        [PermissionSet(SecurityAction.Assert, Unrestricted=true)]
        static class WebConfigurationManagerWrapper
        { 
            // Helper Method to get a site configuration
            static internal ConfigurationElement GetSite(string siteName) 
            { 
                ConfigurationSection sitesSection = WebConfigGetSection(null, null, MetabaseSettingsIis7Constants.SitesSectionName);
                ConfigurationElementCollection sitesCollection = sitesSection.GetCollection(); 

                return FindElement(sitesCollection, MetabaseSettingsIis7Constants.NameAttributeName, siteName);
            }
 
            // Helper method to find element based on an string attribute.
            static internal ConfigurationElement FindElement(ConfigurationElementCollection collection, string attributeName, string value) 
            { 
                foreach (ConfigurationElement element in collection)
                { 
                    if (String.Equals((string)element[attributeName], value, StringComparison.OrdinalIgnoreCase))
                    {
                        return element;
                    } 
                }
 
                return null; 
            }
 
            static internal ConfigurationSection WebConfigGetSection(string siteName, string virtualPath, string sectionName)
            {
                return (ConfigurationSection)GetSectionMethod.Invoke(null, new object[] { siteName, virtualPath, sectionName });
            } 

            static internal object GetValue(ConfigurationSection section, string name) 
            { 
                return section[name];
            } 

            static internal IDictionary> GetProtocolBindingTable(ConfigurationElement site)
            {
                IDictionary> bindingList = new Dictionary>(); 
                foreach (ConfigurationElement binding in site.GetCollection(MetabaseSettingsIis7Constants.BindingsElementName))
                { 
                    string protocol = ((string)binding[MetabaseSettingsIis7Constants.ProtocolAttributeName]).ToLowerInvariant(); 
                    string bindingInformation = (string)binding[MetabaseSettingsIis7Constants.BindingInfoAttributeName];
                    Debug.Print("MetabaseSettingsIis7V2.ctor() adding Protocol: " + protocol + " BindingInformation: " + bindingInformation); 

                    if (!bindingList.ContainsKey(protocol))
                    {
                        bindingList.Add(protocol, new List()); 
                    }
                    bindingList[protocol].Add(bindingInformation); 
                } 
                return bindingList;
            } 

            static internal string GetEnabledProtocols(ConfigurationElement site)
            {
                ConfigurationElement application = FindElement( 
                    site.GetCollection(),
                    MetabaseSettingsIis7Constants.PathAttributeName, 
                    HostingEnvironment.ApplicationVirtualPath 
                    );
                DiagnosticUtility.DebugAssert(application != null, "Unable to find application."); 

                return (string)application[MetabaseSettingsIis7Constants.EnabledProtocolsAttributeName];
            }
 
            static internal List GetProviderList(ConfigurationElement section)
            { 
                List providerList = new List(); 
                foreach (ConfigurationElement element in section.GetCollection(MetabaseSettingsIis7Constants.ProviderElementName))
                { 
                    providerList.Add((string)element[MetabaseSettingsIis7Constants.ValueAttributeName]);
                }
                return providerList;
            } 
        }
    } 
 
    // Note: There is a dependency on this class name and CreateMetabaseSettings
    // method name from System.ServiceModel.dll 
    internal class MetabaseSettingsIis7Factory
    {
        internal static MetabaseSettings CreateMetabaseSettings()
        { 
            MethodInfo method = MetabaseSettingsIis7V2.GetSectionMethod;
            if (method != null) 
            { 
                return new MetabaseSettingsIis7V2();
            } 

            return new MetabaseSettingsIis7();
        }
    } 
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

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