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

378 lines
17 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Web
{
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.ServiceModel.Channels;
using System.ServiceModel.Configuration;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Web.Configuration;
public class WebServiceHost : ServiceHost
{
static readonly Type WebHttpBindingType = typeof(WebHttpBinding);
static readonly string WebHttpEndpointKind = "webHttpEndpoint";
public WebServiceHost()
: base()
{
}
public WebServiceHost(object singletonInstance, params Uri[] baseAddresses)
: base(singletonInstance, baseAddresses)
{
}
public WebServiceHost(Type serviceType, params Uri[] baseAddresses) :
base(serviceType, baseAddresses)
{
}
// This method adds automatic endpoints at the base addresses, 1 per site binding (http or https). It only configures
// the security on the binding. It does not add any behaviors.
// If there are no base addresses, or if endpoints have been configured explicitly, it does not add any
// automatic endpoints.
// If it adds automatic endpoints, it validates that the service implements a single contract
internal static void AddAutomaticWebHttpBindingEndpoints(ServiceHost host, IDictionary<string, ContractDescription> implementedContracts, string multipleContractsErrorMessage, string noContractErrorMessage, string standardEndpointKind)
{
bool enableAutoEndpointCompat = AppSettings.EnableAutomaticEndpointsCompatibility;
// We do not add an automatic endpoint if an explicit endpoint has been configured unless
// the user has specifically opted into compat mode. See CSDMain bugs 176157 & 262728 for history
if (host.Description.Endpoints != null
&& host.Description.Endpoints.Count > 0
&& !enableAutoEndpointCompat)
{
return;
}
AuthenticationSchemes supportedSchemes = AuthenticationSchemes.None;
if (host.BaseAddresses.Count > 0)
{
supportedSchemes = AspNetEnvironment.Current.GetAuthenticationSchemes(host.BaseAddresses[0]);
if (AspNetEnvironment.Current.IsSimpleApplicationHost)
{
// Cassini always reports the auth scheme as anonymous or Ntlm. Map this to Ntlm, except when forms auth
// is requested
if (supportedSchemes == (AuthenticationSchemes.Anonymous | AuthenticationSchemes.Ntlm))
{
if (AspNetEnvironment.Current.IsWindowsAuthenticationConfigured())
{
supportedSchemes = AuthenticationSchemes.Ntlm;
}
else
{
supportedSchemes = AuthenticationSchemes.Anonymous;
}
}
}
}
Type contractType = null;
// add an endpoint with the contract at each base address
foreach (Uri baseAddress in host.BaseAddresses)
{
string uriScheme = baseAddress.Scheme;
// HTTP and HTTPs are only supported schemes
if (Object.ReferenceEquals(uriScheme, Uri.UriSchemeHttp) || Object.ReferenceEquals(uriScheme, Uri.UriSchemeHttps))
{
// bypass adding the automatic endpoint if there's already one at the base address
bool isExplicitEndpointConfigured = false;
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
if (endpoint.Address != null && EndpointAddress.UriEquals(endpoint.Address.Uri, baseAddress, true, false))
{
isExplicitEndpointConfigured = true;
break;
}
}
if (isExplicitEndpointConfigured)
{
continue;
}
if (contractType == null)
{
if (implementedContracts.Count > 1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(multipleContractsErrorMessage));
}
else if (implementedContracts.Count == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(noContractErrorMessage));
}
foreach (ContractDescription contract in implementedContracts.Values)
{
contractType = contract.ContractType;
break;
}
}
// Get the default web endpoint
ConfigLoader configLoader = new ConfigLoader(host.GetContractResolver(implementedContracts));
ServiceEndpointElement serviceEndpointElement = new ServiceEndpointElement();
serviceEndpointElement.Contract = contractType.FullName;
// Check for a protocol mapping
ProtocolMappingItem protocolMappingItem = ConfigLoader.LookupProtocolMapping(baseAddress.Scheme);
if (protocolMappingItem != null &&
string.Equals(protocolMappingItem.Binding, WebHttpBinding.WebHttpBindingConfigurationStrings.WebHttpBindingCollectionElementName, StringComparison.Ordinal))
{
serviceEndpointElement.BindingConfiguration = protocolMappingItem.BindingConfiguration;
}
serviceEndpointElement.Kind = standardEndpointKind;
// LookupEndpoint will not set the Endpoint address and listenUri
// because omitSettingEndpointAddress is set to true.
// We will set them after setting the binding security
ServiceEndpoint automaticEndpoint = configLoader.LookupEndpoint(serviceEndpointElement, null, host, host.Description, true /*omitSettingEndpointAddress*/);
WebHttpBinding binding = automaticEndpoint.Binding as WebHttpBinding;
bool automaticallyConfigureSecurity = !binding.Security.IsModeSet;
if (automaticallyConfigureSecurity)
{
if (Object.ReferenceEquals(uriScheme, Uri.UriSchemeHttps))
{
binding.Security.Mode = WebHttpSecurityMode.Transport;
}
else if (supportedSchemes != AuthenticationSchemes.None && supportedSchemes != AuthenticationSchemes.Anonymous)
{
binding.Security.Mode = WebHttpSecurityMode.TransportCredentialOnly;
}
else
{
binding.Security.Mode = WebHttpSecurityMode.None;
}
}
if (automaticallyConfigureSecurity && AspNetEnvironment.Enabled)
{
SetBindingCredentialBasedOnHostedEnvironment(automaticEndpoint, supportedSchemes);
}
// Setting the Endpoint address and listenUri now that we've set the binding security
ConfigLoader.ConfigureEndpointAddress(serviceEndpointElement, host, automaticEndpoint);
ConfigLoader.ConfigureEndpointListenUri(serviceEndpointElement, host, automaticEndpoint);
host.AddServiceEndpoint(automaticEndpoint);
}
}
}
internal static void SetRawContentTypeMapperIfNecessary(ServiceEndpoint endpoint, bool isDispatch)
{
Binding binding = endpoint.Binding;
ContractDescription contract = endpoint.Contract;
if (binding == null)
{
return;
}
CustomBinding customBinding = new CustomBinding(binding);
BindingElementCollection bec = customBinding.Elements;
WebMessageEncodingBindingElement encodingElement = bec.Find<WebMessageEncodingBindingElement>();
if (encodingElement == null || encodingElement.ContentTypeMapper != null)
{
return;
}
bool areAllOperationsRawMapperCompatible = true;
int numStreamOperations = 0;
foreach (OperationDescription operation in contract.Operations)
{
bool isCompatible = (isDispatch) ? IsRawContentMapperCompatibleDispatchOperation(operation, ref numStreamOperations) : IsRawContentMapperCompatibleClientOperation(operation, ref numStreamOperations);
if (!isCompatible)
{
areAllOperationsRawMapperCompatible = false;
break;
}
}
if (areAllOperationsRawMapperCompatible && numStreamOperations > 0)
{
encodingElement.ContentTypeMapper = RawContentTypeMapper.Instance;
endpoint.Binding = customBinding;
}
}
protected override void OnOpening()
{
if (this.Description == null)
{
return;
}
// disable other things that listen for GET at base address and may conflict with auto-endpoints
ServiceDebugBehavior sdb = this.Description.Behaviors.Find<ServiceDebugBehavior>();
if (sdb != null)
{
sdb.HttpHelpPageEnabled = false;
sdb.HttpsHelpPageEnabled = false;
}
ServiceMetadataBehavior smb = this.Description.Behaviors.Find<ServiceMetadataBehavior>();
if (smb != null)
{
smb.HttpGetEnabled = false;
smb.HttpsGetEnabled = false;
}
AddAutomaticWebHttpBindingEndpoints(this, this.ImplementedContracts, SR2.GetString(SR2.HttpTransferServiceHostMultipleContracts, this.Description.Name), SR2.GetString(SR2.HttpTransferServiceHostNoContract, this.Description.Name), WebHttpEndpointKind);
// for both user-defined and automatic endpoints, ensure they have the right behavior and content type mapper added
foreach (ServiceEndpoint serviceEndpoint in this.Description.Endpoints)
{
if (serviceEndpoint.Binding != null && serviceEndpoint.Binding.CreateBindingElements().Find<WebMessageEncodingBindingElement>() != null)
{
SetRawContentTypeMapperIfNecessary(serviceEndpoint, true);
if (serviceEndpoint.Behaviors.Find<WebHttpBehavior>() == null)
{
ConfigLoader.LoadDefaultEndpointBehaviors(serviceEndpoint);
if (serviceEndpoint.Behaviors.Find<WebHttpBehavior>() == null)
{
serviceEndpoint.Behaviors.Add(new WebHttpBehavior());
}
}
}
}
base.OnOpening();
}
static bool IsRawContentMapperCompatibleClientOperation(OperationDescription operation, ref int numStreamOperations)
{
// An operation is raw encoder compatible on the client side iff the response is a Stream or void
// The request is driven by the format property on the message and not by the content type
if (operation.Messages.Count > 1 & !IsResponseStreamOrVoid(operation, ref numStreamOperations))
{
return false;
}
return true;
}
static bool IsRawContentMapperCompatibleDispatchOperation(OperationDescription operation, ref int numStreamOperations)
{
// An operation is raw encoder compatible on the dispatch side iff the request body is a Stream or void
// The response is driven by the format property on the message and not by the content type
UriTemplateDispatchFormatter throwAway = new UriTemplateDispatchFormatter(operation, null, new QueryStringConverter(), operation.DeclaringContract.Name, new Uri("http://localhost"));
int numUriVariables = throwAway.pathMapping.Count + throwAway.queryMapping.Count;
bool isRequestCompatible = false;
if (numUriVariables > 0)
{
// we need the local variable tmp because ref parameters are not allowed to be passed into
// anonymous methods by the compiler.
int tmp = 0;
WebHttpBehavior.HideRequestUriTemplateParameters(operation, throwAway, delegate()
{
isRequestCompatible = IsRequestStreamOrVoid(operation, ref tmp);
});
numStreamOperations += tmp;
}
else
{
isRequestCompatible = IsRequestStreamOrVoid(operation, ref numStreamOperations);
}
return isRequestCompatible;
}
static bool IsRequestStreamOrVoid(OperationDescription operation, ref int numStreamOperations)
{
MessageDescription message = operation.Messages[0];
if (WebHttpBehavior.IsTypedMessage(message) || WebHttpBehavior.IsUntypedMessage(message))
{
return false;
}
if (message.Body.Parts.Count == 0)
{
return true;
}
else if (message.Body.Parts.Count == 1)
{
if (IsStreamPart(message.Body.Parts[0].Type))
{
++numStreamOperations;
return true;
}
else if (IsVoidPart(message.Body.Parts[0].Type))
{
return true;
}
}
return false;
}
static bool IsResponseStreamOrVoid(OperationDescription operation, ref int numStreamOperations)
{
if (operation.Messages.Count <= 1)
{
return true;
}
MessageDescription message = operation.Messages[1];
if (WebHttpBehavior.IsTypedMessage(message) || WebHttpBehavior.IsUntypedMessage(message))
{
return false;
}
if (message.Body.Parts.Count == 0)
{
if (message.Body.ReturnValue == null || IsVoidPart(message.Body.ReturnValue.Type))
{
return true;
}
else if (IsStreamPart(message.Body.ReturnValue.Type))
{
++numStreamOperations;
return true;
}
}
return false;
}
static bool IsStreamPart(Type type)
{
return (type == typeof(Stream));
}
static bool IsVoidPart(Type type)
{
return (type == null || type == typeof(void));
}
// For automatic endpoints, in the hosted case we configure a credential type based on the vdir settings.
// For IIS, in IntegratedWindowsAuth mode we pick Negotiate.
static void SetBindingCredentialBasedOnHostedEnvironment(ServiceEndpoint serviceEndpoint, AuthenticationSchemes supportedSchemes)
{
WebHttpBinding whb = serviceEndpoint.Binding as WebHttpBinding;
Fx.Assert(whb != null, "Automatic endpoint must be WebHttpBinding");
switch (supportedSchemes)
{
case AuthenticationSchemes.Digest:
whb.Security.Transport.ClientCredentialType = HttpClientCredentialType.Digest;
break;
case AuthenticationSchemes.IntegratedWindowsAuthentication:
// fall through to Negotiate
case AuthenticationSchemes.Negotiate:
whb.Security.Transport.ClientCredentialType = HttpClientCredentialType.Windows;
break;
case AuthenticationSchemes.Ntlm:
whb.Security.Transport.ClientCredentialType = HttpClientCredentialType.Ntlm;
break;
case AuthenticationSchemes.Basic:
whb.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
break;
case AuthenticationSchemes.Anonymous:
whb.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
break;
default:
whb.Security.Transport.ClientCredentialType = HttpClientCredentialType.InheritedFromHost;
break;
}
}
}
}