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

592 lines
21 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Globalization;
using System.IO;
using System.Runtime;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.Xml;
public abstract class MessageHeader : MessageHeaderInfo
{
const bool DefaultRelayValue = false;
const bool DefaultMustUnderstandValue = false;
const string DefaultActorValue = "";
public override string Actor
{
get { return ""; }
}
public override bool IsReferenceParameter
{
get { return false; }
}
public override bool MustUnderstand
{
get { return DefaultMustUnderstandValue; }
}
public override bool Relay
{
get { return DefaultRelayValue; }
}
public virtual bool IsMessageVersionSupported(MessageVersion messageVersion)
{
if (messageVersion == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageVersion");
}
return true;
}
public override string ToString()
{
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
XmlTextWriter textWriter = new XmlTextWriter(stringWriter);
textWriter.Formatting = Formatting.Indented;
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateDictionaryWriter(textWriter);
if (IsMessageVersionSupported(MessageVersion.Soap12WSAddressing10))
{
WriteHeader(writer, MessageVersion.Soap12WSAddressing10);
}
else if (IsMessageVersionSupported(MessageVersion.Soap12WSAddressingAugust2004))
{
WriteHeader(writer, MessageVersion.Soap12WSAddressingAugust2004);
}
else if (IsMessageVersionSupported(MessageVersion.Soap11WSAddressing10))
{
WriteHeader(writer, MessageVersion.Soap11WSAddressing10);
}
else if (IsMessageVersionSupported(MessageVersion.Soap11WSAddressingAugust2004))
{
WriteHeader(writer, MessageVersion.Soap11WSAddressingAugust2004);
}
else if (IsMessageVersionSupported(MessageVersion.Soap12))
{
WriteHeader(writer, MessageVersion.Soap12);
}
else if (IsMessageVersionSupported(MessageVersion.Soap11))
{
WriteHeader(writer, MessageVersion.Soap11);
}
else
{
WriteHeader(writer, MessageVersion.None);
}
writer.Flush();
return stringWriter.ToString();
}
public void WriteHeader(XmlWriter writer, MessageVersion messageVersion)
{
WriteHeader(XmlDictionaryWriter.CreateDictionaryWriter(writer), messageVersion);
}
public void WriteHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
if (writer == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("writer"));
if (messageVersion == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("messageVersion"));
OnWriteStartHeader(writer, messageVersion);
OnWriteHeaderContents(writer, messageVersion);
writer.WriteEndElement();
}
public void WriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
if (writer == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("writer"));
if (messageVersion == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("messageVersion"));
OnWriteStartHeader(writer, messageVersion);
}
protected virtual void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
writer.WriteStartElement(this.Name, this.Namespace);
WriteHeaderAttributes(writer, messageVersion);
}
public void WriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
if (writer == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("writer"));
if (messageVersion == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("messageVersion"));
OnWriteHeaderContents(writer, messageVersion);
}
protected abstract void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion);
protected void WriteHeaderAttributes(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
string actor = this.Actor;
if (actor.Length > 0)
writer.WriteAttributeString(messageVersion.Envelope.DictionaryActor, messageVersion.Envelope.DictionaryNamespace, actor);
if (this.MustUnderstand)
writer.WriteAttributeString(XD.MessageDictionary.MustUnderstand, messageVersion.Envelope.DictionaryNamespace, "1");
if (this.Relay && messageVersion.Envelope == EnvelopeVersion.Soap12)
writer.WriteAttributeString(XD.Message12Dictionary.Relay, XD.Message12Dictionary.Namespace, "1");
}
public static MessageHeader CreateHeader(string name, string ns, object value)
{
return CreateHeader(name, ns, value, DefaultMustUnderstandValue, DefaultActorValue, DefaultRelayValue);
}
public static MessageHeader CreateHeader(string name, string ns, object value, bool mustUnderstand)
{
return CreateHeader(name, ns, value, mustUnderstand, DefaultActorValue, DefaultRelayValue);
}
public static MessageHeader CreateHeader(string name, string ns, object value, bool mustUnderstand, string actor)
{
return CreateHeader(name, ns, value, mustUnderstand, actor, DefaultRelayValue);
}
public static MessageHeader CreateHeader(string name, string ns, object value, bool mustUnderstand, string actor, bool relay)
{
return new XmlObjectSerializerHeader(name, ns, value, null, mustUnderstand, actor, relay);
}
public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer)
{
return CreateHeader(name, ns, value, serializer, DefaultMustUnderstandValue, DefaultActorValue, DefaultRelayValue);
}
public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, bool mustUnderstand)
{
return CreateHeader(name, ns, value, serializer, mustUnderstand, DefaultActorValue, DefaultRelayValue);
}
public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, bool mustUnderstand, string actor)
{
return CreateHeader(name, ns, value, serializer, mustUnderstand, actor, DefaultRelayValue);
}
public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, bool mustUnderstand, string actor, bool relay)
{
if (serializer == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("serializer"));
return new XmlObjectSerializerHeader(name, ns, value, serializer, mustUnderstand, actor, relay);
}
internal static void GetHeaderAttributes(XmlDictionaryReader reader, MessageVersion version,
out string actor, out bool mustUnderstand, out bool relay, out bool isReferenceParameter)
{
int attributeCount = reader.AttributeCount;
if (attributeCount == 0)
{
mustUnderstand = false;
actor = string.Empty;
relay = false;
isReferenceParameter = false;
}
else
{
string mustUnderstandString = reader.GetAttribute(XD.MessageDictionary.MustUnderstand, version.Envelope.DictionaryNamespace);
if (mustUnderstandString != null && ToBoolean(mustUnderstandString))
mustUnderstand = true;
else
mustUnderstand = false;
if (mustUnderstand && attributeCount == 1)
{
actor = string.Empty;
relay = false;
}
else
{
actor = reader.GetAttribute(version.Envelope.DictionaryActor, version.Envelope.DictionaryNamespace);
if (actor == null)
actor = "";
if (version.Envelope == EnvelopeVersion.Soap12)
{
string relayString = reader.GetAttribute(XD.Message12Dictionary.Relay, version.Envelope.DictionaryNamespace);
if (relayString != null && ToBoolean(relayString))
relay = true;
else
relay = false;
}
else
{
relay = false;
}
}
isReferenceParameter = false;
if (version.Addressing == AddressingVersion.WSAddressing10)
{
string refParam = reader.GetAttribute(XD.AddressingDictionary.IsReferenceParameter, version.Addressing.DictionaryNamespace);
if (refParam != null)
isReferenceParameter = ToBoolean(refParam);
}
}
}
static bool ToBoolean(string value)
{
if (value.Length == 1)
{
char ch = value[0];
if (ch == '1')
{
return true;
}
if (ch == '0')
{
return false;
}
}
else
{
if (value == "true")
{
return true;
}
else if (value == "false")
{
return false;
}
}
try
{
return XmlConvert.ToBoolean(value);
}
catch (FormatException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(exception.Message, null));
}
}
}
abstract class DictionaryHeader : MessageHeader
{
public override string Name
{
get { return DictionaryName.Value; }
}
public override string Namespace
{
get { return DictionaryNamespace.Value; }
}
public abstract XmlDictionaryString DictionaryName { get; }
public abstract XmlDictionaryString DictionaryNamespace { get; }
protected override void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
writer.WriteStartElement(DictionaryName, DictionaryNamespace);
WriteHeaderAttributes(writer, messageVersion);
}
}
class XmlObjectSerializerHeader : MessageHeader
{
XmlObjectSerializer serializer;
bool mustUnderstand;
bool relay;
bool isOneTwoSupported;
bool isOneOneSupported;
bool isNoneSupported;
object objectToSerialize;
string name;
string ns;
string actor;
object syncRoot = new object();
XmlObjectSerializerHeader(XmlObjectSerializer serializer, bool mustUnderstand, string actor, bool relay)
{
if (actor == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("actor");
}
this.mustUnderstand = mustUnderstand;
this.relay = relay;
this.serializer = serializer;
this.actor = actor;
if (actor == EnvelopeVersion.Soap12.UltimateDestinationActor)
{
this.isOneOneSupported = false;
this.isOneTwoSupported = true;
}
else if (actor == EnvelopeVersion.Soap12.NextDestinationActorValue)
{
this.isOneOneSupported = false;
this.isOneTwoSupported = true;
}
else if (actor == EnvelopeVersion.Soap11.NextDestinationActorValue)
{
this.isOneOneSupported = true;
this.isOneTwoSupported = false;
}
else
{
this.isOneOneSupported = true;
this.isOneTwoSupported = true;
this.isNoneSupported = true;
}
}
public XmlObjectSerializerHeader(string name, string ns, object objectToSerialize, XmlObjectSerializer serializer, bool mustUnderstand, string actor, bool relay)
: this(serializer, mustUnderstand, actor, relay)
{
if (null == name)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("name"));
}
if (name.Length == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.SFXHeaderNameCannotBeNullOrEmpty), "name"));
}
if (ns == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("ns");
}
if (ns.Length > 0)
{
NamingHelper.CheckUriParameter(ns, "ns");
}
this.objectToSerialize = objectToSerialize;
this.name = name;
this.ns = ns;
}
public override bool IsMessageVersionSupported(MessageVersion messageVersion)
{
if (messageVersion == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageVersion");
}
if (messageVersion.Envelope == EnvelopeVersion.Soap12)
{
return this.isOneTwoSupported;
}
else if (messageVersion.Envelope == EnvelopeVersion.Soap11)
{
return this.isOneOneSupported;
}
else if (messageVersion.Envelope == EnvelopeVersion.None)
{
return this.isNoneSupported;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.EnvelopeVersionUnknown, messageVersion.Envelope.ToString())));
}
}
public override string Name
{
get { return name; }
}
public override string Namespace
{
get { return ns; }
}
public override bool MustUnderstand
{
get { return mustUnderstand; }
}
public override bool Relay
{
get { return relay; }
}
public override string Actor
{
get { return actor; }
}
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
lock (syncRoot)
{
if (serializer == null)
{
serializer = DataContractSerializerDefaults.CreateSerializer(
(objectToSerialize == null ? typeof(object) : objectToSerialize.GetType()), this.Name, this.Namespace, int.MaxValue/*maxItems*/);
}
serializer.WriteObjectContent(writer, objectToSerialize);
}
}
}
abstract class ReadableMessageHeader : MessageHeader
{
public abstract XmlDictionaryReader GetHeaderReader();
protected override void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
if (!IsMessageVersionSupported(messageVersion))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.MessageHeaderVersionNotSupported, this.GetType().FullName, messageVersion.ToString()), "version"));
XmlDictionaryReader reader = GetHeaderReader();
writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteAttributes(reader, false);
reader.Close();
}
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
XmlDictionaryReader reader = GetHeaderReader();
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
writer.WriteNode(reader, false);
reader.ReadEndElement();
reader.Close();
}
}
internal interface IMessageHeaderWithSharedNamespace
{
XmlDictionaryString SharedNamespace { get; }
XmlDictionaryString SharedPrefix { get; }
}
class BufferedHeader : ReadableMessageHeader
{
MessageVersion version;
XmlBuffer buffer;
int bufferIndex;
string actor;
bool relay;
bool mustUnderstand;
string name;
string ns;
bool streamed;
bool isRefParam;
public BufferedHeader(MessageVersion version, XmlBuffer buffer, int bufferIndex, string name, string ns, bool mustUnderstand, string actor, bool relay, bool isRefParam)
{
this.version = version;
this.buffer = buffer;
this.bufferIndex = bufferIndex;
this.name = name;
this.ns = ns;
this.mustUnderstand = mustUnderstand;
this.actor = actor;
this.relay = relay;
this.isRefParam = isRefParam;
}
public BufferedHeader(MessageVersion version, XmlBuffer buffer, int bufferIndex, MessageHeaderInfo headerInfo)
{
this.version = version;
this.buffer = buffer;
this.bufferIndex = bufferIndex;
actor = headerInfo.Actor;
relay = headerInfo.Relay;
name = headerInfo.Name;
ns = headerInfo.Namespace;
isRefParam = headerInfo.IsReferenceParameter;
mustUnderstand = headerInfo.MustUnderstand;
}
public BufferedHeader(MessageVersion version, XmlBuffer buffer, XmlDictionaryReader reader, XmlAttributeHolder[] envelopeAttributes, XmlAttributeHolder[] headerAttributes)
{
this.streamed = true;
this.buffer = buffer;
this.version = version;
GetHeaderAttributes(reader, version, out this.actor, out this.mustUnderstand, out this.relay, out this.isRefParam);
name = reader.LocalName;
ns = reader.NamespaceURI;
Fx.Assert(name != null, "");
Fx.Assert(ns != null, "");
bufferIndex = buffer.SectionCount;
XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
// Write an enclosing Envelope tag
writer.WriteStartElement(MessageStrings.Envelope);
if (envelopeAttributes != null)
XmlAttributeHolder.WriteAttributes(envelopeAttributes, writer);
// Write and enclosing Header tag
writer.WriteStartElement(MessageStrings.Header);
if (headerAttributes != null)
XmlAttributeHolder.WriteAttributes(headerAttributes, writer);
writer.WriteNode(reader, false);
writer.WriteEndElement();
writer.WriteEndElement();
buffer.CloseSection();
}
public override string Actor
{
get { return actor; }
}
public override bool IsReferenceParameter
{
get { return isRefParam; }
}
public override string Name
{
get { return name; }
}
public override string Namespace
{
get { return ns; }
}
public override bool MustUnderstand
{
get { return mustUnderstand; }
}
public override bool Relay
{
get { return relay; }
}
public override bool IsMessageVersionSupported(MessageVersion messageVersion)
{
if (messageVersion == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("messageVersion"));
return messageVersion == this.version;
}
public override XmlDictionaryReader GetHeaderReader()
{
XmlDictionaryReader reader = buffer.GetReader(bufferIndex);
// See if we need to move past the enclosing envelope/header
if (this.streamed)
{
reader.MoveToContent();
reader.Read(); // Envelope
reader.Read(); // Header
reader.MoveToContent();
}
return reader;
}
}
}