Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

740 lines
36 KiB
C#

//----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
namespace System.ServiceModel.WasHosting
{
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.Authentication;
using System.Security.Authentication.ExtendedProtection;
using System.Security.Permissions;
using System.Security.Principal;
using System.ServiceModel.Activation;
using System.ServiceModel.Activation.Diagnostics;
using System.ServiceModel.Channels;
using System.Web;
using System.Web.Hosting;
using Microsoft.Web.Administration;
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 ExtendedProtectionElementName = "extendedProtection";
internal const string TokenCheckingAttributeName = "tokenChecking";
internal const string FlagsAttributeName = "flags";
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.
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();
}
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode,
Justification = "called by MetabaseSettingsIis7 constructor")]
void PopulateSiteProperties()
{
Site site = ServerManagerWrapper.GetSite(HostingEnvironment.SiteName);
DiagnosticUtility.DebugAssert(site != null, "Unable to find site.");
//
// Build up the binding table.
//
IDictionary<string, List<string>> bindingList = ServerManagerWrapper.GetProtocolBindingTable(site);
// Convert to string arrays
foreach (KeyValuePair<string, List<string>> 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.
//
string[] protocols = ServerManagerWrapper.GetEnabledProtocols(site).Split(MetabaseSettingsIis7Constants.CommaSeparator.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
foreach (string protocolValue in protocols)
{
string protocol = protocolValue.Trim();
protocol = protocol.ToLowerInvariant();
if (string.IsNullOrEmpty(protocol) || this.Protocols.Contains(protocol))
{
// Ignore duplicates and empty protocols
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<string> providerList = ServerManagerWrapper.GetProviders(section, MetabaseSettingsIis7Constants.ProviderElementName,
MetabaseSettingsIis7Constants.ValueAttributeName);
if (providerList.Count != 0)
{
transportSettings.AuthProviders = providerList.ToArray();
}
}
try
{
ConfigurationElement element = section.GetChildElement(MetabaseSettingsIis7Constants.ExtendedProtectionElementName);
if (element != null)
{
ExtendedProtectionTokenChecking tokenChecking;
ExtendedProtectionFlags flags;
List<string> spnList;
ServerManagerWrapper.ReadIisExtendedProtectionPolicy(element, out tokenChecking, out flags, out spnList);
transportSettings.IisExtendedProtectionPolicy = BuildExtendedProtectionPolicy(tokenChecking, flags, spnList);
}
}
catch (COMException e)
{
// hit this exception only when IIS does not support CBT
// safe for us to igore this COMException so that services not using CBT still can be activated
// if a service does use CBT in binding, channel listener will catch it when comparing IIS setting against WCF (on CBT) and throw exception
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.WebHostNoCBTSupport,
SR.TraceCodeWebHostNoCBTSupport, this, e);
}
}
}
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;
}
}
}
protected override IEnumerable<string> GetSiteApplicationPaths()
{
return ServerManagerWrapper.GetApplicationPaths();
}
// wraps calls to ServerManager with Asserts as necessary to support partial trust scenarios
[PermissionSet(SecurityAction.Assert, Unrestricted = true)]
static class ServerManagerWrapper
{
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode,
Justification = "Called by MetabaseSettingsIis7.PopulateSiteProperties")]
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<string> GetProviders(ConfigurationSection section, string providerElementName, string valueAttributeName)
{
List<string> providerList = new List<string>();
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;
}
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode,
Justification = "Called by MetabaseSettingsIis7.PopulateSiteProperties")]
static internal IDictionary<string, List<string>> GetProtocolBindingTable(Site site)
{
IDictionary<string, List<string>> bindingList = new Dictionary<string, List<string>>();
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<string>());
}
bindingList[protocol].Add(bindingInformation);
}
return bindingList;
}
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode,
Justification = "Called by MetabaseSettingsIis7.PopulateSiteProperties")]
static internal string GetEnabledProtocols(Site site)
{
Application application = site.Applications[HostingEnvironmentWrapper.ApplicationVirtualPath];
DiagnosticUtility.DebugAssert(application != null, "Unable to find application.");
return application.EnabledProtocols;
}
static internal void ReadIisExtendedProtectionPolicy(ConfigurationElement element, out ExtendedProtectionTokenChecking tokenChecking,
out ExtendedProtectionFlags flags, out List<string> spnList)
{
tokenChecking = (ExtendedProtectionTokenChecking)element.GetAttributeValue(MetabaseSettingsIis7Constants.TokenCheckingAttributeName);
flags = (ExtendedProtectionFlags)element.GetAttributeValue(MetabaseSettingsIis7Constants.FlagsAttributeName);
spnList = new List<string>();
foreach (ConfigurationElement configElement in element.GetCollection())
{
spnList.Add((string)configElement[MetabaseSettingsIis7Constants.NameAttributeName]);
}
}
static internal IEnumerable<string> GetApplicationPaths()
{
//Get the site ourselves instead of calling GetSite() because we should dispose of the ServerManager
using (ServerManager serverManager = new ServerManager())
{
List<string> appPaths = new List<string>();
Site site = serverManager.Sites[HostingEnvironment.SiteName];
foreach (Application app in site.Applications)
{
appPaths.Add(app.Path);
}
return appPaths;
}
}
}
}
// MetabaseSettingsIis7V2 use WebConfigurationManager to get Metabase settings, we depend on
// some methods which only availble in Longhorn Server/SP1 build.
class MetabaseSettingsIis7V2 : MetabaseSettingsIis
{
static MethodInfo getSectionMethod;
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode,
Justification = "Called by MetabaseSettingsIis7Factory.CreateMetabaseSettings")]
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;
}
}
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode,
Justification = "Called by MetabaseSettingsIis7V2 constructor")]
void PopulateSiteProperties()
{
ConfigurationElement site = WebConfigurationManagerWrapper.GetSite(HostingEnvironment.SiteName);
//
// Build up the binding table.
//
IDictionary<string, List<string>> bindingList = WebConfigurationManagerWrapper.GetProtocolBindingTable(site);
// Convert to string arrays
foreach (KeyValuePair<string, List<string>> 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.
//
string[] protocols = WebConfigurationManagerWrapper.GetEnabledProtocols(site).Split(MetabaseSettingsIis7Constants.CommaSeparator.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
foreach (string protocolValue in protocols)
{
string protocol = protocolValue.Trim();
protocol = protocol.ToLowerInvariant();
if (string.IsNullOrEmpty(protocol) || this.Protocols.Contains(protocol))
{
// Ignore duplicates and empty protocols
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<string> providerList = WebConfigurationManagerWrapper.GetProviderList(section);
if (providerList.Count != 0)
{
transportSettings.AuthProviders = providerList.ToArray();
}
// Check the CBT configuration
try
{
ConfigurationElement element = section.GetChildElement(MetabaseSettingsIis7Constants.ExtendedProtectionElementName);
if (element != null)
{
ExtendedProtectionTokenChecking tokenChecking;
ExtendedProtectionFlags flags;
List<string> spnList;
WebConfigurationManagerWrapper.ReadIisExtendedProtectionPolicy(element, out tokenChecking, out flags, out spnList);
transportSettings.IisExtendedProtectionPolicy = BuildExtendedProtectionPolicy(tokenChecking, flags, spnList);
}
}
catch (COMException e)
{
// hit this exception only when IIS does not support CBT
// safe for us to igore this COMException so that services not using CBT still can be activated
// if a service does use CBT in binding, channel listener will catch it when comparing IIS setting against WCF (on CBT) and throw exception
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.WebHostNoCBTSupport,
SR.TraceCodeWebHostNoCBTSupport, this, e);
}
}
}
}
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;
}
}
}
protected override IEnumerable<string> GetSiteApplicationPaths()
{
ConfigurationElement site = WebConfigurationManagerWrapper.GetSite(HostingEnvironment.SiteName);
return WebConfigurationManagerWrapper.GetApplicationPaths(site);
}
[PermissionSet(SecurityAction.Assert, Unrestricted = true)]
static class WebConfigurationManagerWrapper
{
// Helper Method to get a site configuration
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode,
Justification = "Called by MetabaseSettingsIis7V2.PopulateSiteProperties")]
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.
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode,
Justification = "Called by GetSite")]
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];
}
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode,
Justification = "Called by MetabaseSettingsIis7V2.PopulateSiteProperties")]
static internal IDictionary<string, List<string>> GetProtocolBindingTable(ConfigurationElement site)
{
IDictionary<string, List<string>> bindingList = new Dictionary<string, List<string>>();
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<string>());
}
bindingList[protocol].Add(bindingInformation);
}
return bindingList;
}
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode,
Justification = "Called by MetabaseSettingsIis7V2.PopulateSiteProperties")]
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<string> GetProviderList(ConfigurationElement section)
{
List<string> providerList = new List<string>();
foreach (ConfigurationElement element in section.GetCollection(MetabaseSettingsIis7Constants.ProviderElementName))
{
providerList.Add((string)element[MetabaseSettingsIis7Constants.ValueAttributeName]);
}
return providerList;
}
// translate IIS setting on extended protection to NCL object
static internal void ReadIisExtendedProtectionPolicy(ConfigurationElement element, out ExtendedProtectionTokenChecking tokenChecking,
out ExtendedProtectionFlags flags, out List<string> spnList)
{
tokenChecking = (ExtendedProtectionTokenChecking)element.GetAttributeValue(MetabaseSettingsIis7Constants.TokenCheckingAttributeName);
flags = (ExtendedProtectionFlags)element.GetAttributeValue(MetabaseSettingsIis7Constants.FlagsAttributeName);
spnList = new List<string>();
foreach (ConfigurationElement configElement in element.GetCollection())
{
spnList.Add((string)configElement[MetabaseSettingsIis7Constants.NameAttributeName]);
}
}
static internal IEnumerable<string> GetApplicationPaths(ConfigurationElement site)
{
List<string> appPaths = new List<string>();
ConfigurationElementCollection applications = site.GetCollection();
foreach (ConfigurationElement application in applications)
{
string appPath = (string)application["path"];
appPaths.Add(appPath);
}
return appPaths;
}
}
}
// Note: There is a dependency on this class name and CreateMetabaseSettings
// method name from System.ServiceModel.dll
[SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUninstantiatedInternalClasses,
Justification = "Instantiated by System.ServiceModel")]
internal class MetabaseSettingsIis7Factory
{
internal static MetabaseSettings CreateMetabaseSettings()
{
MethodInfo method = MetabaseSettingsIis7V2.GetSectionMethod;
if (method != null)
{
return new MetabaseSettingsIis7V2();
}
return new MetabaseSettingsIis7();
}
}
}