Files
mono/mcs/class/referencesource/System.ServiceModel.Web/System/ServiceModel/Description/WebScriptEnablingBehavior.cs
T
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

492 lines
24 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
#pragma warning disable 1634, 1691
namespace System.ServiceModel.Description
{
using System;
using System.Diagnostics;
using System.Globalization;
using System.Net;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Security;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.ServiceModel.Channels;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Web;
using System.Xml;
public sealed class WebScriptEnablingBehavior : WebHttpBehavior
{
static readonly DataContractJsonSerializer jsonFaultSerializer = new DataContractJsonSerializer(typeof(JsonFaultDetail));
static readonly WebMessageBodyStyle webScriptBodyStyle = WebMessageBodyStyle.WrappedRequest;
static readonly WebMessageFormat webScriptDefaultMessageFormat = WebMessageFormat.Json;
const int MaxMetadataEndpointBufferSize = 2048;
WebMessageFormat requestMessageFormat = webScriptDefaultMessageFormat;
WebMessageFormat responseMessageFormat = webScriptDefaultMessageFormat;
public WebScriptEnablingBehavior()
{
}
public override WebMessageBodyStyle DefaultBodyStyle
{
get
{
return webScriptBodyStyle;
}
set
{
if (value != webScriptBodyStyle)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.BodyStyleNotSupportedByWebScript, value, this.GetType().Name, webScriptBodyStyle)));
}
}
}
public override WebMessageFormat DefaultOutgoingRequestFormat
{
get
{
return this.requestMessageFormat;
}
set
{
if (!WebMessageFormatHelper.IsDefined(value))
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
}
this.requestMessageFormat = value;
}
}
public override WebMessageFormat DefaultOutgoingResponseFormat
{
get
{
return this.responseMessageFormat;
}
set
{
if (!WebMessageFormatHelper.IsDefined(value))
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
}
this.responseMessageFormat = value;
}
}
public override bool HelpEnabled
{
get
{
return false;
}
set
{
if (value)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.HelpPageNotSupportedInScripts)));
}
}
}
public override bool AutomaticFormatSelectionEnabled
{
get
{
return false;
}
set
{
if (value)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.AutomaticFormatSelectionNotSupportedInScripts)));
}
}
}
public override bool FaultExceptionEnabled
{
get
{
return false;
}
set
{
if (value)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.FaultExceptionEnabledNotSupportedInScripts)));
}
}
}
public override void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{
base.ApplyClientBehavior(endpoint, clientRuntime);
#pragma warning disable 56506 // [....], clientRuntime.MessageInspectors is never null
clientRuntime.MessageInspectors.Add(new JsonClientMessageInspector());
#pragma warning restore 56506
}
public override void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
base.ApplyDispatchBehavior(endpoint, endpointDispatcher);
try
{
AddMetadataEndpoint(endpoint, endpointDispatcher, false); // debugMode
AddMetadataEndpoint(endpoint, endpointDispatcher, true); // debugMode
}
catch (XmlException exception)
{
// [....], need to reference this resource string although fix for 13332 was removed
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.InvalidXmlCharactersInNameUsedWithPOSTMethod, string.Empty, string.Empty, string.Empty), exception));
}
}
public override void Validate(ServiceEndpoint endpoint)
{
base.Validate(endpoint);
#pragma warning disable 56506 // [....], endpoint.Contract is never null
foreach (OperationDescription operation in endpoint.Contract.Operations)
#pragma warning restore 56506
{
if (operation.Behaviors.Find<XmlSerializerOperationBehavior>() != null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR2.GetString(SR2.WebScriptNotSupportedForXmlSerializerFormat, typeof(XmlSerializerFormatAttribute).Name, this.GetType().ToString())));
}
string method = WebHttpBehavior.GetWebMethod(operation);
if (method != WebHttpBehavior.GET
&& method != WebHttpBehavior.POST)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR2.GetString(SR2.WebScriptInvalidHttpRequestMethod, operation.Name,
endpoint.Contract.Name, method, this.GetType().ToString())));
}
WebGetAttribute webGetAttribute = operation.Behaviors.Find<WebGetAttribute>();
if (webGetAttribute != null && webGetAttribute.UriTemplate != null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR2.GetString(SR2.WebScriptNotSupportedForXmlSerializerFormat, typeof(UriTemplate).Name, this.GetType().ToString())));
}
WebInvokeAttribute webInvokeAttribute = operation.Behaviors.Find<WebInvokeAttribute>();
if (webInvokeAttribute != null && webInvokeAttribute.UriTemplate != null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR2.GetString(SR2.WebScriptNotSupportedForXmlSerializerFormat, typeof(UriTemplate).Name, this.GetType().ToString())));
}
WebMessageBodyStyle bodyStyle = GetBodyStyle(operation);
if (bodyStyle != webScriptBodyStyle)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.BodyStyleNotSupportedByWebScript, bodyStyle, this.GetType().Name, webScriptBodyStyle)));
}
foreach (MessageDescription messageDescription in operation.Messages)
{
if (!messageDescription.IsTypedMessage &&
(messageDescription.Direction == MessageDirection.Output) &&
(messageDescription.Body.Parts.Count > 0))
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR2.GetString(SR2.WebScriptOutRefOperationsNotSupported, operation.Name,
endpoint.Contract.Name)));
}
}
}
}
internal override DataContractJsonSerializerOperationFormatter CreateDataContractJsonSerializerOperationFormatter(OperationDescription od, DataContractSerializerOperationBehavior dcsob, bool isWrapped)
{
return new DataContractJsonSerializerOperationFormatter(od, dcsob.MaxItemsInObjectGraph, dcsob.IgnoreExtensionDataObject, dcsob.DataContractSurrogate, isWrapped, true, this.JavascriptCallbackParameterName);
}
internal override string GetWmiTypeName()
{
return "WebScriptEnablingBehavior";
}
internal override bool UseBareReplyFormatter(WebMessageBodyStyle style, OperationDescription operationDescription, WebMessageFormat responseFormat, out Type parameterType)
{
if (responseFormat == WebMessageFormat.Json)
{
parameterType = null;
return false;
}
return base.UseBareReplyFormatter(style, operationDescription, responseFormat, out parameterType);
}
protected override void AddClientErrorInspector(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
{
clientRuntime.MessageInspectors.Add(new JsonClientMessageInspector());
}
protected override void AddServerErrorHandlers(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
if (endpointDispatcher.ChannelDispatcher == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(
"endpointDispatcher", SR2.GetString(SR2.ChannelDispatcherMustBePresent));
}
#pragma warning disable 56506 // [....], endpointDispatcher.ChannelDispatcher.ErrorHandlers never null
endpointDispatcher.ChannelDispatcher.ErrorHandlers.Add(new JsonErrorHandler(endpoint, endpointDispatcher.ChannelDispatcher.IncludeExceptionDetailInFaults));
#pragma warning restore 56506
}
protected override QueryStringConverter GetQueryStringConverter(OperationDescription operationDescription)
{
return new JsonQueryStringConverter(operationDescription);
}
void AddMetadataEndpoint(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher, bool debugMode)
{
Uri baseAddress = endpoint.Address.Uri;
if (baseAddress == null)
{
return;
}
ServiceHostBase host = endpointDispatcher.ChannelDispatcher.Host;
UriBuilder builder = new UriBuilder(baseAddress);
builder.Path += builder.Path.EndsWith("/", StringComparison.OrdinalIgnoreCase)
? (WebScriptClientGenerator.GetMetadataEndpointSuffix(debugMode))
: ("/" + WebScriptClientGenerator.GetMetadataEndpointSuffix(debugMode));
EndpointAddress metadataAddress = new EndpointAddress(builder.Uri);
foreach (ServiceEndpoint serviceEndpoint in host.Description.Endpoints)
{
if (EndpointAddress.UriEquals(serviceEndpoint.Address.Uri, metadataAddress.Uri, true, false))// ignoreCase // includeHostNameInComparison
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR2.GetString(SR2.JsonNoEndpointAtMetadataAddress, this.GetType().ToString(), serviceEndpoint.Address, serviceEndpoint.Name, host.Description.Name)));
}
}
HttpTransportBindingElement transportBindingElement;
HttpTransportBindingElement existingTransportBindingElement = endpoint.Binding.CreateBindingElements().Find<HttpTransportBindingElement>();
if (existingTransportBindingElement != null)
{
transportBindingElement = (HttpTransportBindingElement)existingTransportBindingElement.Clone();
}
else
{
if (baseAddress.Scheme == "https")
{
transportBindingElement = new HttpsTransportBindingElement();
}
else
{
transportBindingElement = new HttpTransportBindingElement();
}
}
transportBindingElement.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard;
transportBindingElement.TransferMode = TransferMode.Buffered;
transportBindingElement.MaxBufferSize = MaxMetadataEndpointBufferSize;
transportBindingElement.MaxReceivedMessageSize = MaxMetadataEndpointBufferSize;
Binding metadataBinding = new CustomBinding(
new WebScriptMetadataMessageEncodingBindingElement(),
transportBindingElement);
BindingParameterCollection parameters = host.GetBindingParameters(endpoint);
// build endpoint dispatcher
ContractDescription metadataContract = ContractDescription.GetContract(typeof(ServiceMetadataExtension.IHttpGetMetadata));
OperationDescription metadataOperation = metadataContract.Operations[0];
EndpointDispatcher metadataEndpointDispatcher = new EndpointDispatcher(metadataAddress, metadataContract.Name, metadataContract.Namespace);
DispatchOperation dispatchOperation = new DispatchOperation(metadataEndpointDispatcher.DispatchRuntime, metadataOperation.Name, metadataOperation.Messages[0].Action, metadataOperation.Messages[1].Action);
dispatchOperation.Formatter = new WebScriptMetadataFormatter();
dispatchOperation.Invoker = new SyncMethodInvoker(metadataOperation.SyncMethod);
metadataEndpointDispatcher.DispatchRuntime.Operations.Add(dispatchOperation);
metadataEndpointDispatcher.DispatchRuntime.SingletonInstanceContext = new InstanceContext(host, new WebScriptClientGenerator(endpoint, debugMode, !String.IsNullOrEmpty(this.JavascriptCallbackParameterName)));
metadataEndpointDispatcher.DispatchRuntime.InstanceContextProvider = new SingletonInstanceContextProvider(metadataEndpointDispatcher.DispatchRuntime);
// build channel dispatcher
IChannelListener<IReplyChannel> listener = null;
if (metadataBinding.CanBuildChannelListener<IReplyChannel>(parameters))
{
listener = metadataBinding.BuildChannelListener<IReplyChannel>(metadataAddress.Uri, parameters);
}
ChannelDispatcher metadataChannelDispatcher = new ChannelDispatcher(listener);
metadataChannelDispatcher.MessageVersion = MessageVersion.None;
metadataChannelDispatcher.Endpoints.Add(metadataEndpointDispatcher);
host.ChannelDispatchers.Add(metadataChannelDispatcher);
}
class JsonClientMessageInspector : WebFaultClientMessageInspector
{
public override void AfterReceiveReply(ref Message reply, object correlationState)
{
bool callBase = true;
if (reply != null)
{
object responseProperty = reply.Properties[HttpResponseMessageProperty.Name];
if (responseProperty != null)
{
if (((HttpResponseMessageProperty)responseProperty).Headers[JsonGlobals.jsonerrorString] == JsonGlobals.trueString)
{
callBase = false;
XmlDictionaryReader reader = reply.GetReaderAtBodyContents();
JsonFaultDetail faultDetail = jsonFaultSerializer.ReadObject(reader) as JsonFaultDetail;
FaultCode faultCode = new FaultCode(FaultCodeConstants.Codes.InternalServiceFault, FaultCodeConstants.Namespaces.NetDispatch);
faultCode = FaultCode.CreateReceiverFaultCode(faultCode);
if (faultDetail != null)
{
if (faultDetail.ExceptionDetail != null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new FaultException<ExceptionDetail>(faultDetail.ExceptionDetail, faultDetail.Message, faultCode));
}
else
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new FaultException(MessageFault.CreateFault(faultCode, faultDetail.Message)));
}
}
else
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new FaultException(MessageFault.CreateFault(faultCode,
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInternalServerError))));
}
}
}
}
if (callBase)
{
base.AfterReceiveReply(ref reply, correlationState);
}
}
}
class JsonErrorHandler : IErrorHandler
{
bool includeExceptionDetailInFaults;
string outgoingContentType;
public JsonErrorHandler(ServiceEndpoint endpoint, bool includeExceptionDetailInFaults)
{
WebMessageEncodingBindingElement webMEBE = endpoint.Binding.CreateBindingElements().Find<WebMessageEncodingBindingElement>();
outgoingContentType = JsonMessageEncoderFactory.GetContentType(webMEBE);
this.includeExceptionDetailInFaults = includeExceptionDetailInFaults;
}
public bool HandleError(Exception error)
{
return false;
}
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
HttpResponseMessageProperty responseProperty;
if (fault == null)
{
FaultCode code = new FaultCode(FaultCodeConstants.Codes.InternalServiceFault, FaultCodeConstants.Namespaces.NetDispatch);
code = FaultCode.CreateReceiverFaultCode(code);
string action = FaultCodeConstants.Actions.NetDispatcher;
MessageFault innerFault;
innerFault = MessageFault.CreateFault(code, new FaultReason(error.Message, CultureInfo.CurrentCulture), new ExceptionDetail(error));
fault = Message.CreateMessage(version, action, new JsonFaultBodyWriter(innerFault, this.includeExceptionDetailInFaults));
responseProperty = new HttpResponseMessageProperty();
fault.Properties.Add(HttpResponseMessageProperty.Name, responseProperty);
}
else
{
MessageFault innerFault = MessageFault.CreateFault(fault, TransportDefaults.MaxFaultSize);
Message newMessage = Message.CreateMessage(version, fault.Headers.Action, new JsonFaultBodyWriter(innerFault, this.includeExceptionDetailInFaults));
newMessage.Headers.To = fault.Headers.To;
newMessage.Properties.CopyProperties(fault.Properties);
object property = null;
if (newMessage.Properties.TryGetValue(HttpResponseMessageProperty.Name, out property))
{
responseProperty = (HttpResponseMessageProperty)property;
}
else
{
responseProperty = new HttpResponseMessageProperty();
newMessage.Properties.Add(HttpResponseMessageProperty.Name, responseProperty);
}
fault.Close();
fault = newMessage;
}
responseProperty.Headers.Add(HttpResponseHeader.ContentType, outgoingContentType);
responseProperty.Headers.Add(JsonGlobals.jsonerrorString, JsonGlobals.trueString);
responseProperty.StatusCode = System.Net.HttpStatusCode.InternalServerError;
object bodyFormatPropertyObject;
if (fault.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatPropertyObject))
{
WebBodyFormatMessageProperty bodyFormatProperty = bodyFormatPropertyObject as WebBodyFormatMessageProperty;
if ((bodyFormatProperty == null) ||
(bodyFormatProperty.Format != WebContentFormat.Json))
{
fault.Properties[WebBodyFormatMessageProperty.Name] = WebBodyFormatMessageProperty.JsonProperty;
}
}
else
{
fault.Properties.Add(WebBodyFormatMessageProperty.Name, WebBodyFormatMessageProperty.JsonProperty);
}
}
class JsonFaultBodyWriter : BodyWriter
{
JsonFaultDetail faultDetail;
public JsonFaultBodyWriter(MessageFault fault, bool includeExceptionDetailInFaults)
: base(false)
{
faultDetail = new JsonFaultDetail();
if (includeExceptionDetailInFaults)
{
faultDetail.Message = fault.Reason.ToString();
if (fault.HasDetail)
{
try
{
ExceptionDetail originalFaultDetail = fault.GetDetail<ExceptionDetail>();
faultDetail.StackTrace = originalFaultDetail.StackTrace;
faultDetail.ExceptionType = originalFaultDetail.Type;
faultDetail.ExceptionDetail = originalFaultDetail;
}
catch (SerializationException exception)
{
System.ServiceModel.DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);
// A SerializationException will be thrown if the detail isn't of type ExceptionDetail
// In that case, we want to just move on.
}
catch (SecurityException exception)
{
System.ServiceModel.DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);
// A SecurityException will be thrown if the detail can't be obtained in partial trust
// (This is guaranteed to happen unless there's an Assert for MemberAccessPermission, since ExceptionDetail
// has DataMembers that have private setters.)
// In that case, we want to just move on.
}
}
}
else
{
faultDetail.Message = System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInternalServerError);
}
}
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
jsonFaultSerializer.WriteObject(writer, faultDetail);
}
}
}
}
}