mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
399 lines
18 KiB
C#
399 lines
18 KiB
C#
//----------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//----------------------------------------------------------------
|
|
|
|
//Turn on to log info about the before and after headers/messages
|
|
//#define DEBUG_MARSHALING
|
|
|
|
namespace System.ServiceModel.Routing
|
|
{
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Dispatcher;
|
|
using System.Runtime;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Configuration;
|
|
using System.ServiceModel.Security;
|
|
using System.Xml;
|
|
using SR2 = System.ServiceModel.Routing.SR;
|
|
|
|
public class SoapProcessingBehavior : IEndpointBehavior
|
|
{
|
|
const string IncomingViaName = "IncomingVia";
|
|
const string IncomingHttpRequestName = "IncomingHttpRequest";
|
|
|
|
public SoapProcessingBehavior()
|
|
{
|
|
this.ProcessMessages = true;
|
|
}
|
|
|
|
public bool ProcessMessages
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
|
|
{
|
|
}
|
|
|
|
public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
|
|
{
|
|
if (endpoint == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("endpoint");
|
|
}
|
|
|
|
if (this.ProcessMessages)
|
|
{
|
|
SoapProcessingInspector inspector = new SoapProcessingInspector(endpoint, clientRuntime);
|
|
clientRuntime.MessageInspectors.Add(inspector);
|
|
clientRuntime.CallbackDispatchRuntime.MessageInspectors.Add(inspector);
|
|
foreach (ClientOperation clientOp in clientRuntime.Operations)
|
|
{
|
|
clientOp.ParameterInspectors.Add(inspector);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
|
|
{
|
|
throw FxTrace.Exception.AsError(new NotSupportedException(SR2.MarshalingBehaviorNotSupported));
|
|
}
|
|
|
|
public void Validate(ServiceEndpoint endpoint)
|
|
{
|
|
}
|
|
|
|
class SoapProcessingInspector : IClientMessageInspector, IDispatchMessageInspector, IParameterInspector
|
|
{
|
|
static HashSet<string> addressingHeadersToFlow = InitializeHeadersToFlow();
|
|
|
|
bool manualAddressing;
|
|
MessageVersion sourceMessageVersion;
|
|
MessageVersion sendMessageVersion;
|
|
|
|
public SoapProcessingInspector(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
|
|
{
|
|
Fx.Assert(endpoint != null, "endpoint cannot be null");
|
|
this.sendMessageVersion = endpoint.Binding.MessageVersion;
|
|
this.manualAddressing = clientRuntime.ManualAddressing;
|
|
}
|
|
|
|
void IParameterInspector.AfterCall(string operationName, object[] outputs, object returnValue, object correlationState)
|
|
{
|
|
// This call occurs AFTER IClientMessageInspector.AfterReceiveReply.
|
|
// We don't need to do any additional marshaling here.
|
|
}
|
|
|
|
object IParameterInspector.BeforeCall(string operationName, object[] inputs)
|
|
{
|
|
if (inputs == null || inputs.Length == 0)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNullOrEmpty("inputs");
|
|
}
|
|
|
|
//We have to remove some addressing headers to avoid errors before the
|
|
//Soap Processing MessageInspector gets called. See CSDMain 117167.
|
|
Message request = (Message)inputs[0];
|
|
this.PreProcess(request);
|
|
return null;
|
|
}
|
|
|
|
void IClientMessageInspector.AfterReceiveReply(ref Message reply, object correlationState)
|
|
{
|
|
if (reply != null)
|
|
{
|
|
Message originalMessage = (Message)correlationState;
|
|
MessageHeaders originalHeaders = originalMessage.Headers;
|
|
Uri to = originalHeaders.To;
|
|
MessageVersion version = originalMessage.Version;
|
|
reply = MarshalMessage(reply, to, version);
|
|
|
|
//BasicHttpContext looks at the original request message when
|
|
//constructing the Set-Cookie header, need to put these back.
|
|
Uri incomingVia;
|
|
MessageProperties originalProperties = originalMessage.Properties;
|
|
if (originalProperties.TryGetValue<Uri>(IncomingViaName, out incomingVia))
|
|
{
|
|
originalProperties.Via = incomingVia;
|
|
}
|
|
object incomingHttpRequest;
|
|
if (originalProperties.TryGetValue(IncomingHttpRequestName, out incomingHttpRequest))
|
|
{
|
|
originalProperties[HttpRequestMessageProperty.Name] = incomingHttpRequest;
|
|
}
|
|
|
|
//Reponses from BasicHttp (Addressing.None) don't have any action. If we're marshaling
|
|
//to any addressing version other than none, we create a ReplyAction here
|
|
MessageHeaders replyHeaders = reply.Headers;
|
|
if (replyHeaders.Action == null &&
|
|
version.Addressing != AddressingVersion.None &&
|
|
originalHeaders.Action != null)
|
|
{
|
|
replyHeaders.Action = originalHeaders.Action + "Response";
|
|
}
|
|
}
|
|
}
|
|
|
|
object IClientMessageInspector.BeforeSendRequest(ref Message request, IClientChannel channel)
|
|
{
|
|
Message originalRequest = request;
|
|
if (this.sourceMessageVersion == null)
|
|
{
|
|
this.sourceMessageVersion = originalRequest.Version;
|
|
}
|
|
request = MarshalMessage(request, request.Headers.To, sendMessageVersion);
|
|
return originalRequest;
|
|
}
|
|
|
|
object IDispatchMessageInspector.AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
|
|
{
|
|
request = MarshalMessage(request, request.Headers.To, this.sourceMessageVersion);
|
|
return null;
|
|
}
|
|
|
|
void IDispatchMessageInspector.BeforeSendReply(ref Message reply, object correlationState)
|
|
{
|
|
if (reply != null)
|
|
{
|
|
reply = MarshalMessage(reply, reply.Headers.To, sendMessageVersion);
|
|
}
|
|
}
|
|
|
|
static HashSet<string> InitializeHeadersToFlow()
|
|
{
|
|
HashSet<string> headersToFlow = new HashSet<string>(StringComparer.Ordinal);
|
|
headersToFlow.Add("Action");
|
|
headersToFlow.Add("MessageID");
|
|
headersToFlow.Add("RelatesTo");
|
|
headersToFlow.Add("To");
|
|
return headersToFlow;
|
|
}
|
|
|
|
void PreProcess(Message message)
|
|
{
|
|
//If the user does not have manual addressing enabled then clear these out
|
|
if (!this.manualAddressing)
|
|
{
|
|
MessageHeaders headers = message.Headers;
|
|
string addressingNamespace = RoutingUtilities.GetAddressingNamespace(headers.MessageVersion.Addressing);
|
|
|
|
//Go through in reverse to reduce shifting after RemoveAt(i)
|
|
for (int i = headers.Count - 1; i >= 0; --i)
|
|
{
|
|
MessageHeaderInfo header = headers[i];
|
|
if (string.Equals(header.Namespace, addressingNamespace, StringComparison.Ordinal))
|
|
{
|
|
if (!addressingHeadersToFlow.Contains(header.Name))
|
|
{
|
|
headers.RemoveAt(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal Message MarshalMessage(Message source, Uri to, MessageVersion targetVersion)
|
|
{
|
|
Message result;
|
|
MessageHeaders sourceHeaders = source.Headers;
|
|
MessageVersion sourceVersion = source.Version;
|
|
UnderstoodHeaders understoodHeaders = sourceHeaders.UnderstoodHeaders;
|
|
HashSet<string> understoodHeadersSet = CreateKeys(understoodHeaders);
|
|
|
|
#if DEBUG_MARSHALING
|
|
System.Text.StringBuilder details = new System.Text.StringBuilder();
|
|
details.AppendFormat("Original Message:\r\n{0}\r\n", source);
|
|
details.AppendLine("Understood Headers:");
|
|
foreach (MessageHeaderInfo understoodHeader in understoodHeaders)
|
|
{
|
|
details.AppendFormat("\t{0}\t({1})\r\n", understoodHeader.Name, understoodHeader.Namespace);
|
|
}
|
|
details.AppendLine("Properties:");
|
|
foreach (KeyValuePair<string, object> item in source.Properties)
|
|
{
|
|
details.AppendFormat("\t{0}\t({1})\r\n", item.Key, item.Value);
|
|
}
|
|
#endif //DEBUG_MARSHALING
|
|
|
|
|
|
//if we've understood and verified the security of the message, we need to create a new message
|
|
if (sourceVersion == targetVersion && !RoutingUtilities.IsMessageUsingWSSecurity(understoodHeaders))
|
|
{
|
|
FilterHeaders(sourceHeaders, understoodHeadersSet);
|
|
FilterProperties(source.Properties);
|
|
result = source;
|
|
}
|
|
else
|
|
{
|
|
if (source.IsFault)
|
|
{
|
|
MessageFault messageFault = MessageFault.CreateFault(source, int.MaxValue);
|
|
string action = sourceHeaders.Action;
|
|
if (string.Equals(action, sourceVersion.Addressing.DefaultFaultAction, StringComparison.Ordinal))
|
|
{
|
|
//The action was the default for the sourceVersion set it to the default for the targetVersion.
|
|
action = targetVersion.Addressing.DefaultFaultAction;
|
|
}
|
|
result = Message.CreateMessage(targetVersion, messageFault, action);
|
|
}
|
|
else if (source.IsEmpty)
|
|
{
|
|
result = Message.CreateMessage(targetVersion, sourceHeaders.Action);
|
|
}
|
|
else
|
|
{
|
|
XmlDictionaryReader bodyReader = source.GetReaderAtBodyContents();
|
|
result = Message.CreateMessage(targetVersion, sourceHeaders.Action, bodyReader);
|
|
}
|
|
|
|
CloneHeaders(result.Headers, sourceHeaders, to, understoodHeadersSet);
|
|
CloneProperties(result.Properties, source.Properties);
|
|
}
|
|
|
|
#if DEBUG_MARSHALING
|
|
details.AppendFormat("\r\nMarshaled Message:\r\n{0}\r\n", result);
|
|
details.AppendLine("Properties:");
|
|
foreach (KeyValuePair<string, object> item in result.Properties)
|
|
{
|
|
details.AppendFormat("\t{0}\t({1})\r\n", item.Key, item.Value);
|
|
}
|
|
System.Diagnostics.Trace.WriteLine(details);
|
|
TD.RoutingServiceDisplayConfig(details.ToString(), "");
|
|
#endif //DEBUG_MARSHALING
|
|
|
|
return result;
|
|
}
|
|
|
|
static HashSet<string> CreateKeys(UnderstoodHeaders headers)
|
|
{
|
|
HashSet<string> toReturn = new HashSet<string>();
|
|
foreach (MessageHeaderInfo header in headers)
|
|
{
|
|
toReturn.Add(MessageHeaderKey(header));
|
|
}
|
|
return toReturn;
|
|
}
|
|
|
|
static string MessageHeaderKey(MessageHeaderInfo header)
|
|
{
|
|
return header.Name + "+" + header.Namespace;
|
|
}
|
|
|
|
void FilterHeaders(MessageHeaders headers, HashSet<string> understoodHeadersSet)
|
|
{
|
|
string addressingNamespace = RoutingUtilities.GetAddressingNamespace(headers.MessageVersion.Addressing);
|
|
|
|
//Go in reverse to reduce shifting after RemoveAt(i)
|
|
for (int i = headers.Count - 1; i >= 0; --i)
|
|
{
|
|
MessageHeaderInfo header = headers[i];
|
|
bool removeHeader = false;
|
|
|
|
if (string.Equals(header.Namespace, addressingNamespace, StringComparison.Ordinal) &&
|
|
(addressingHeadersToFlow.Contains(header.Name) || this.manualAddressing))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (understoodHeadersSet.Contains(MessageHeaderKey(header)))
|
|
{
|
|
// This header was understood at this endpoint, do _not_ flow it
|
|
removeHeader = true;
|
|
}
|
|
else if (ActorIsNextDestination(header, headers.MessageVersion))
|
|
{
|
|
//This was a header targeted at the SOAP Intermediary ("actor/next", which is us)
|
|
//It can explicitly tell us to relay this header when we don't understand it.
|
|
if (!header.Relay)
|
|
{
|
|
removeHeader = true;
|
|
}
|
|
}
|
|
|
|
if (removeHeader)
|
|
{
|
|
headers.RemoveAt(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool ActorIsNextDestination(MessageHeaderInfo header, MessageVersion messageVersion)
|
|
{
|
|
return (header.Actor != null && string.Equals(header.Actor, messageVersion.Envelope.NextDestinationActorValue));
|
|
}
|
|
|
|
void CloneHeaders(MessageHeaders targetHeaders, MessageHeaders sourceHeaders, Uri to, HashSet<string> understoodHeadersSet)
|
|
{
|
|
for (int i = 0; i < sourceHeaders.Count; ++i)
|
|
{
|
|
MessageHeaderInfo header = sourceHeaders[i];
|
|
if (!understoodHeadersSet.Contains(MessageHeaderKey(header)))
|
|
{
|
|
//If Actor is SOAP Intermediary ("*actor/next" which is us) check the Relay flag
|
|
if (!ActorIsNextDestination(header, sourceHeaders.MessageVersion) || header.Relay)
|
|
{
|
|
//Always wrap the header because BufferedHeader isn't smart enough to allow custom
|
|
//headers to switch message versions
|
|
MessageHeader messageHeader = new DelegatingHeader(header, sourceHeaders);
|
|
targetHeaders.Add(messageHeader);
|
|
}
|
|
}
|
|
}
|
|
|
|
// To and Action (already specified) are 'special' and may be set even with AddressingVersion.None
|
|
targetHeaders.To = to;
|
|
if (targetHeaders.MessageVersion.Addressing != AddressingVersion.None)
|
|
{
|
|
//These are used as correlation IDs. Copy these regardless of manual addressing.
|
|
targetHeaders.MessageId = sourceHeaders.MessageId;
|
|
targetHeaders.RelatesTo = sourceHeaders.RelatesTo;
|
|
|
|
if (this.manualAddressing)
|
|
{
|
|
//These are addresses, only copy when ManualAddressing is enabled
|
|
targetHeaders.FaultTo = sourceHeaders.FaultTo;
|
|
targetHeaders.ReplyTo = sourceHeaders.ReplyTo;
|
|
targetHeaders.From = sourceHeaders.From;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void CloneProperties(MessageProperties destination, MessageProperties source)
|
|
{
|
|
MessageEncoder encoder = destination.Encoder;
|
|
destination.CopyProperties(source);
|
|
destination.Encoder = encoder;
|
|
FilterProperties(destination);
|
|
}
|
|
|
|
static void FilterProperties(MessageProperties destination)
|
|
{
|
|
// We have the clear out the HTTP Req/Resp props, so we don't accidentally
|
|
// tell the outbound binding to use whatever Content-Type/Method/QueryString
|
|
// that the inboudnd message/response used. Otherwise BasicHttp<->WsHttp won't work.
|
|
object incomingHttpRequest;
|
|
if (destination.TryGetValue(HttpRequestMessageProperty.Name, out incomingHttpRequest))
|
|
{
|
|
//Store the inbound value for later retoration
|
|
destination[IncomingHttpRequestName] = incomingHttpRequest;
|
|
destination.Remove(HttpRequestMessageProperty.Name);
|
|
}
|
|
destination.Remove(HttpResponseMessageProperty.Name);
|
|
|
|
//Preserve the Via on the outbound message, HTTP Context using cookies looks at this value
|
|
//on the original request when sending the response "Set-Cookie" header.
|
|
Uri incomingVia = destination.Via;
|
|
if (incomingVia != null)
|
|
{
|
|
destination[IncomingViaName] = incomingVia;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|