public BufferedHeader(MessageVersion version, XmlBuffer buffer, XmlDictionaryReader reader, XmlAttributeHolder[] envelopeAttributes, XmlAttributeHolder[] headerAttributes)
{
this.streamed = true;
this.buffer = buffer;
this.version = version;
MessageHeader.GetHeaderAttributes(reader, version, out this.actor, out this.mustUnderstand, out this.relay, out this.isRefParam);
this.name = reader.LocalName;
this.ns = reader.NamespaceURI;
this.bufferIndex = buffer.SectionCount;
XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Envelope");
if (envelopeAttributes != null)
{
XmlAttributeHolder.WriteAttributes(envelopeAttributes, writer);
}
writer.WriteStartElement("Header");
if (headerAttributes != null)
{
XmlAttributeHolder.WriteAttributes(headerAttributes, writer);
}
writer.WriteNode(reader, false);
writer.WriteEndElement();
writer.WriteEndElement();
buffer.CloseSection();
}
public SecurityVerifiedMessage(Message messageToProcess, ReceiveSecurityHeader securityHeader)
: base(messageToProcess)
{
this.securityHeader = securityHeader;
if (securityHeader.RequireMessageProtection)
{
XmlDictionaryReader messageReader;
BufferedMessage bufferedMessage = this.InnerMessage as BufferedMessage;
if (bufferedMessage != null && this.Headers.ContainsOnlyBufferedMessageHeaders)
{
messageReader = bufferedMessage.GetMessageReader();
}
else
{
this.messageBuffer = new XmlBuffer(int.MaxValue);
XmlDictionaryWriter writer = this.messageBuffer.OpenSection(this.securityHeader.ReaderQuotas);
this.InnerMessage.WriteMessage(writer);
this.messageBuffer.CloseSection();
this.messageBuffer.Close();
messageReader = this.messageBuffer.GetReader(0);
}
MoveToSecurityHeader(messageReader, securityHeader.HeaderIndex, true);
this.cachedReaderAtSecurityHeader = messageReader;
this.state = BodyState.Buffered;
}
else
{
this.envelopeAttributes = XmlAttributeHolder.emptyArray;
this.headerAttributes = XmlAttributeHolder.emptyArray;
this.bodyAttributes = XmlAttributeHolder.emptyArray;
this.canDelegateCreateBufferedCopyToInnerMessage = true;
}
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, ResourceCollectionInfo collection)
{
if (collection == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("collection");
}
SyndicationFeedFormatter.CloseBuffer(buffer, writer);
collection.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, CategoriesDocument categories)
{
if (categories == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("categories");
}
SyndicationFeedFormatter.CloseBuffer(buffer, writer);
categories.LoadElementExtensions(buffer);
}
public BufferedAddressHeader(XmlDictionaryReader reader)
{
this.buffer = new XmlBuffer(0x7fffffff);
XmlDictionaryWriter writer = this.buffer.OpenSection(reader.Quotas);
this.name = reader.LocalName;
this.ns = reader.NamespaceURI;
writer.WriteNode(reader, false);
this.buffer.CloseSection();
this.buffer.Close();
this.isReferenceProperty = false;
}
public BufferedHeader(MessageVersion version, XmlBuffer buffer, int bufferIndex, MessageHeaderInfo headerInfo)
{
this.version = version;
this.buffer = buffer;
this.bufferIndex = bufferIndex;
this.actor = headerInfo.Actor;
this.relay = headerInfo.Relay;
this.name = headerInfo.Name;
this.ns = headerInfo.Namespace;
this.isRefParam = headerInfo.IsReferenceParameter;
this.mustUnderstand = headerInfo.MustUnderstand;
}
private static XmlDictionaryReader GetReaderAtSection(XmlBuffer buffer, int section)
{
if ((buffer == null) || (section < 0))
{
return(null);
}
XmlDictionaryReader reader = buffer.GetReader(section);
reader.MoveToContent();
reader.Read();
return(reader);
}
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;
}
internal BodyWriter OnCreateBufferedCopy(int maxBufferSize, XmlDictionaryReaderQuotas quotas)
{
XmlBuffer buffer = new XmlBuffer(maxBufferSize);
using (XmlDictionaryWriter writer = buffer.OpenSection(quotas))
{
writer.WriteStartElement("a");
this.OnWriteBodyContents(writer);
writer.WriteEndElement();
}
buffer.CloseSection();
buffer.Close();
return new BufferedBodyWriter(buffer);
}
internal static XmlBuffer ReadExtensions(XmlDictionaryReader reader, AddressingVersion version, XmlBuffer buffer, out EndpointIdentity identity, out int section)
{
if (reader == null)
{
identity = null;
section = -1;
return(buffer);
}
identity = null;
XmlDictionaryWriter writer = null;
reader.MoveToContent();
while (reader.IsStartElement())
{
if (reader.IsStartElement(XD.AddressingDictionary.Identity, XD.AddressingDictionary.IdentityExtensionNamespace))
{
if (identity != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, System.ServiceModel.SR.GetString("UnexpectedDuplicateElement", new object[] { XD.AddressingDictionary.Identity.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value })));
}
identity = EndpointIdentity.ReadIdentity(reader);
}
else
{
if ((version != null) && (reader.NamespaceURI == version.Namespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, System.ServiceModel.SR.GetString("AddressingExtensionInBadNS", new object[] { reader.LocalName, reader.NamespaceURI })));
}
if (writer == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
}
writer.WriteNode(reader, true);
}
reader.MoveToContent();
}
if (writer != null)
{
writer.WriteEndElement();
buffer.CloseSection();
section = buffer.SectionCount - 1;
return(buffer);
}
section = -1;
return(buffer);
}
public void SetMetadataReader(XmlDictionaryReader reader)
{
this.hasMetadata = true;
this.metadataBuffer = null;
if (reader != null)
{
this.metadataBuffer = new XmlBuffer(0x7fff);
XmlDictionaryWriter writer = this.metadataBuffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
EndpointAddress.Copy(writer, reader);
this.metadataBuffer.CloseSection();
this.metadataBuffer.Close();
}
}
public static XmlDictionaryReader GetReaderAtDetailContentsFeb2005(string detailName, string detailNamespace, XmlDictionaryReader headerReader)
{
XmlDictionaryReader reader;
try
{
WsrmFeb2005Dictionary dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString namespaceUri = dictionary.Namespace;
XmlBuffer buffer = null;
int sectionIndex = 0;
int depth = headerReader.Depth;
headerReader.ReadFullStartElement(dictionary.SequenceFault, namespaceUri);
while (headerReader.Depth > depth)
{
if (((headerReader.NodeType == XmlNodeType.Element) && (headerReader.NamespaceURI == detailNamespace)) && (headerReader.LocalName == detailName))
{
if (buffer != null)
{
return null;
}
buffer = new XmlBuffer(0x7fffffff);
try
{
sectionIndex = buffer.SectionCount;
buffer.OpenSection(headerReader.Quotas).WriteNode(headerReader, false);
continue;
}
finally
{
buffer.CloseSection();
}
}
if (headerReader.Depth == depth)
{
break;
}
headerReader.Read();
}
if (buffer == null)
{
return null;
}
buffer.Close();
reader = buffer.GetReader(sectionIndex);
}
finally
{
headerReader.Close();
}
return reader;
}
private static XmlDictionaryReader GetReaderAtSection(XmlBuffer buffer, int section)
{
if (buffer == null || section < 0)
{
return(null);
}
XmlDictionaryReader reader = buffer.GetReader(section);
reader.MoveToContent();
Fx.Assert(reader.Name == DummyName, "EndpointAddress: Expected dummy element not found");
reader.Read(); // consume the dummy wrapper element
return(reader);
}
public void SetMetadataReader(XmlDictionaryReader reader)
{
_hasMetadata = true;
_metadataBuffer = null;
if (reader != null)
{
_metadataBuffer = new XmlBuffer(short.MaxValue);
XmlDictionaryWriter writer = _metadataBuffer.OpenSection(reader.Quotas);
writer.WriteStartElement(EndpointAddress.DummyName, EndpointAddress.DummyNamespace);
EndpointAddress.Copy(writer, reader);
_metadataBuffer.CloseSection();
_metadataBuffer.Close();
}
}
public void SetExtensionReader(XmlDictionaryReader reader)
{
EndpointIdentity identity;
int num;
this.hasExtension = true;
this.extensionBuffer = EndpointAddress.ReadExtensions(reader, null, null, out identity, out num);
if (this.extensionBuffer != null)
{
this.extensionBuffer.Close();
}
if (identity != null)
{
this.identity = identity;
}
}
public void SetExtensionReader(XmlDictionaryReader reader)
{
_hasExtension = true;
EndpointIdentity identity;
int tmp;
_extensionBuffer = EndpointAddress.ReadExtensions(reader, null, null, out identity, out tmp);
if (_extensionBuffer != null)
{
_extensionBuffer.Close();
}
if (identity != null)
{
_identity = identity;
}
}
public void SetExtensionReader(XmlDictionaryReader reader)
{
EndpointIdentity identity;
int num;
this.hasExtension = true;
this.extensionBuffer = EndpointAddress.ReadExtensions(reader, null, null, out identity, out num);
if (this.extensionBuffer != null)
{
this.extensionBuffer.Close();
}
if (identity != null)
{
this.identity = identity;
}
}
private static XmlBuffer CreateXmlBuffer(XmlDictionaryReader unparsedExtensionsReader, int maxExtensionSize)
{
XmlBuffer buffer = new XmlBuffer(maxExtensionSize);
using (XmlDictionaryWriter writer = buffer.OpenSection(unparsedExtensionsReader.Quotas))
{
writer.WriteStartElement("extensionWrapper");
while (unparsedExtensionsReader.IsStartElement())
{
writer.WriteNode(unparsedExtensionsReader, false);
}
writer.WriteEndElement();
}
buffer.CloseSection();
buffer.Close();
return buffer;
}
public DefaultMessageBuffer(Message message, XmlBuffer msgBuffer)
{
this.msgBuffer = msgBuffer;
this.version = message.Version;
this.isNullMessage = message is NullMessage;
this.properties = new KeyValuePair<string, object>[message.Properties.Count];
((ICollection<KeyValuePair<string, object>>) message.Properties).CopyTo(this.properties, 0);
this.understoodHeaders = new bool[message.Headers.Count];
for (int i = 0; i < this.understoodHeaders.Length; i++)
{
this.understoodHeaders[i] = message.Headers.IsUnderstood(i);
}
if (this.version == MessageVersion.None)
{
this.to = message.Headers.To;
this.action = message.Headers.Action;
}
}
private void PossiblyPopulateBuffer(XmlDictionaryReader reader, ref XmlBuffer buffer, out int section)
{
if (reader == null)
{
section = -1;
}
else
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
section = buffer.SectionCount;
XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
Copy(writer, reader);
buffer.CloseSection();
}
}
private void PossiblyPopulateBuffer(XmlDictionaryReader reader, ref XmlBuffer buffer, out int section)
{
if (reader == null)
{
section = -1;
}
else
{
if (buffer == null)
{
buffer = new XmlBuffer(short.MaxValue);
}
section = buffer.SectionCount;
XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement(DummyName, DummyNamespace);
Copy(writer, reader);
buffer.CloseSection();
}
}
internal EndpointAddress(System.Uri uri, EndpointIdentity identity, AddressHeaderCollection headers, XmlDictionaryReader metadataReader, XmlDictionaryReader extensionReader, XmlDictionaryReader pspReader)
{
EndpointIdentity identity2;
int num;
if (uri == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("uri");
}
XmlBuffer buffer = null;
this.PossiblyPopulateBuffer(metadataReader, ref buffer, out this.metadataSection);
buffer = ReadExtensions(extensionReader, null, buffer, out identity2, out num);
if ((identity != null) && (identity2 != null))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("MultipleIdentities"), "extensionReader"));
}
this.PossiblyPopulateBuffer(pspReader, ref buffer, out this.pspSection);
if (buffer != null)
{
buffer.Close();
}
this.Init(uri, identity ?? identity2, headers, buffer, this.metadataSection, num, this.pspSection);
}
internal EndpointAddress(System.Uri uri, EndpointIdentity identity, AddressHeaderCollection headers, XmlDictionaryReader metadataReader, XmlDictionaryReader extensionReader, XmlDictionaryReader pspReader)
{
EndpointIdentity identity2;
int num;
if (uri == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("uri");
}
XmlBuffer buffer = null;
this.PossiblyPopulateBuffer(metadataReader, ref buffer, out this.metadataSection);
buffer = ReadExtensions(extensionReader, null, buffer, out identity2, out num);
if ((identity != null) && (identity2 != null))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("MultipleIdentities"), "extensionReader"));
}
this.PossiblyPopulateBuffer(pspReader, ref buffer, out this.pspSection);
if (buffer != null)
{
buffer.Close();
}
this.Init(uri, identity ?? identity2, headers, buffer, this.metadataSection, num, this.pspSection);
}
private static bool ReadContentsFrom10(XmlDictionaryReader reader, out Uri uri, out AddressHeaderCollection headers, out EndpointIdentity identity, out XmlBuffer buffer, out int metadataSection, out int extensionSection)
{
buffer = null;
extensionSection = -1;
metadataSection = -1;
// Cache address string
if (!reader.IsStartElement(XD.AddressingDictionary.Address, XD.Addressing10Dictionary.Namespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SR.Format(SR.UnexpectedElementExpectingElement, reader.LocalName, reader.NamespaceURI, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value)));
}
string address = reader.ReadElementContentAsString();
// Headers
if (reader.IsStartElement(XD.AddressingDictionary.ReferenceParameters, XD.Addressing10Dictionary.Namespace))
{
headers = AddressHeaderCollection.ReadServiceParameters(reader);
}
else
{
headers = null;
}
// Metadata
if (reader.IsStartElement(XD.Addressing10Dictionary.Metadata, XD.Addressing10Dictionary.Namespace))
{
reader.ReadFullStartElement(); // the wsa10:Metadata element is never stored in the buffer
buffer = new XmlBuffer(short.MaxValue);
metadataSection = 0;
XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement(DummyName, DummyNamespace);
while (reader.NodeType != XmlNodeType.EndElement && !reader.EOF)
{
writer.WriteNode(reader, true);
}
writer.Flush();
buffer.CloseSection();
reader.ReadEndElement();
}
// Extensions
buffer = ReadExtensions(reader, AddressingVersion.WSAddressing10, buffer, out identity, out extensionSection);
if (buffer != null)
{
buffer.Close();
}
// Process Address
if (address == Addressing10Strings.Anonymous)
{
uri = AddressingVersion.WSAddressing10.AnonymousUri;
if (headers == null && identity == null)
{
return(true);
}
}
else if (address == Addressing10Strings.NoneAddress)
{
uri = AddressingVersion.WSAddressing10.NoneUri;
return(false);
}
else
{
if (!Uri.TryCreate(address, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.InvalidUriValue, address, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value)));
}
}
return(false);
}
private void Init(System.Uri uri, EndpointIdentity identity, AddressHeaderCollection headers, XmlBuffer buffer, int metadataSection, int extensionSection, int pspSection)
{
this.Init(null, uri, identity, headers, buffer, metadataSection, extensionSection, pspSection);
}
private static bool ReadContentsFrom200408(XmlDictionaryReader reader, out System.Uri uri, out AddressHeaderCollection headers, out EndpointIdentity identity, out XmlBuffer buffer, out int metadataSection, out int extensionSection, out int pspSection)
{
buffer = null;
headers = null;
extensionSection = -1;
metadataSection = -1;
pspSection = -1;
reader.MoveToContent();
if (!reader.IsStartElement(XD.AddressingDictionary.Address, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, System.ServiceModel.SR.GetString("UnexpectedElementExpectingElement", new object[] { reader.LocalName, reader.NamespaceURI, XD.AddressingDictionary.Address.Value, XD.Addressing200408Dictionary.Namespace.Value })));
}
string uriString = reader.ReadElementContentAsString();
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.ReferenceProperties, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
headers = AddressHeaderCollection.ReadServiceParameters(reader, true);
}
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.ReferenceParameters, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
if (headers != null)
{
List <AddressHeader> addressHeaders = new List <AddressHeader>();
foreach (AddressHeader header in headers)
{
addressHeaders.Add(header);
}
foreach (AddressHeader header2 in AddressHeaderCollection.ReadServiceParameters(reader))
{
addressHeaders.Add(header2);
}
headers = new AddressHeaderCollection(addressHeaders);
}
else
{
headers = AddressHeaderCollection.ReadServiceParameters(reader);
}
}
XmlDictionaryWriter writer = null;
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.PortType, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
if (writer == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
}
writer.WriteNode(reader, true);
}
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.ServiceName, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
if (writer == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
}
writer.WriteNode(reader, true);
}
reader.MoveToContent();
while (reader.IsNamespaceUri(XD.PolicyDictionary.Namespace))
{
if (writer == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
}
writer.WriteNode(reader, true);
reader.MoveToContent();
}
if (writer != null)
{
writer.WriteEndElement();
buffer.CloseSection();
pspSection = buffer.SectionCount - 1;
writer = null;
}
else
{
pspSection = -1;
}
if (reader.IsStartElement("Metadata", "http://schemas.xmlsoap.org/ws/2004/09/mex"))
{
if (writer == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
}
writer.WriteNode(reader, true);
}
if (writer != null)
{
writer.WriteEndElement();
buffer.CloseSection();
metadataSection = buffer.SectionCount - 1;
writer = null;
}
else
{
metadataSection = -1;
}
reader.MoveToContent();
buffer = ReadExtensions(reader, AddressingVersion.WSAddressingAugust2004, buffer, out identity, out extensionSection);
if (buffer != null)
{
buffer.Close();
}
if (uriString == "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous")
{
uri = AddressingVersion.WSAddressingAugust2004.AnonymousUri;
if ((headers == null) && (identity == null))
{
return(true);
}
}
else if (!System.Uri.TryCreate(uriString, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidUriValue", new object[] { uriString, XD.AddressingDictionary.Address.Value, AddressingVersion.WSAddressingAugust2004.Namespace })));
}
return(false);
}
protected override void OnClose()
{
if (this.cachedDecryptedBodyContentReader != null)
{
try
{
this.cachedDecryptedBodyContentReader.Close();
}
catch (System.IO.IOException exception)
{
//
// We only want to catch and log the I/O exception here
// assuming reader only throw those exceptions
//
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Warning);
}
finally
{
this.cachedDecryptedBodyContentReader = null;
}
}
if (this.cachedReaderAtSecurityHeader != null)
{
try
{
this.cachedReaderAtSecurityHeader.Close();
}
catch (System.IO.IOException exception)
{
//
// We only want to catch and log the I/O exception here
// assuming reader only throw those exceptions
//
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Warning);
}
finally
{
this.cachedReaderAtSecurityHeader = null;
}
}
this.messageBuffer = null;
this.decryptedBuffer = null;
this.state = BodyState.Disposed;
this.InnerMessage.Close();
}
public static XmlDictionaryReader GetReaderAtDetailContentsFeb2005(string detailName, string detailNamespace,
XmlDictionaryReader headerReader)
{
try
{
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString wsrmNs = wsrmFeb2005Dictionary.Namespace;
XmlBuffer buffer = null;
int index = 0;
int depth = headerReader.Depth;
headerReader.ReadFullStartElement(wsrmFeb2005Dictionary.SequenceFault, wsrmNs);
while (headerReader.Depth > depth)
{
if ((headerReader.NodeType == XmlNodeType.Element)
&& (headerReader.NamespaceURI == detailNamespace)
&& (headerReader.LocalName == detailName))
{
if (buffer != null)
{
return null;
}
buffer = new XmlBuffer(int.MaxValue);
try
{
index = buffer.SectionCount;
XmlDictionaryWriter writer = buffer.OpenSection(headerReader.Quotas);
// WriteNode moves the reader to the next sibling.
writer.WriteNode(headerReader, false);
}
finally
{
buffer.CloseSection();
}
}
else
{
if (headerReader.Depth == depth)
break;
headerReader.Read();
}
}
// Ensure at least one detail is found;
if (buffer == null)
{
return null;
}
// Close causes a state change. It moves the buffer from Created to Reading.
buffer.Close();
XmlDictionaryReader detailReader = buffer.GetReader(index);
return detailReader;
}
finally
{
headerReader.Close();
}
}
private static bool ReadContentsFrom200408(XmlDictionaryReader reader, out Uri uri, out AddressHeaderCollection headers, out EndpointIdentity identity, out XmlBuffer buffer, out int metadataSection, out int extensionSection, out int pspSection)
{
buffer = null;
headers = null;
extensionSection = -1;
metadataSection = -1;
pspSection = -1;
// Cache address string
reader.MoveToContent();
if (!reader.IsStartElement(XD.AddressingDictionary.Address, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SR.Format(SR.UnexpectedElementExpectingElement, reader.LocalName, reader.NamespaceURI, XD.AddressingDictionary.Address.Value, XD.Addressing200408Dictionary.Namespace.Value)));
}
string address = reader.ReadElementContentAsString();
// ReferenceProperites
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.ReferenceProperties, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
headers = AddressHeaderCollection.ReadServiceParameters(reader, true);
}
// ReferenceParameters
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.ReferenceParameters, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
if (headers != null)
{
List <AddressHeader> headerList = new List <AddressHeader>();
foreach (AddressHeader ah in headers)
{
headerList.Add(ah);
}
AddressHeaderCollection tmp = AddressHeaderCollection.ReadServiceParameters(reader);
foreach (AddressHeader ah in tmp)
{
headerList.Add(ah);
}
headers = new AddressHeaderCollection(headerList);
}
else
{
headers = AddressHeaderCollection.ReadServiceParameters(reader);
}
}
XmlDictionaryWriter bufferWriter = null;
// PortType
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.PortType, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
if (bufferWriter == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(short.MaxValue);
}
bufferWriter = buffer.OpenSection(reader.Quotas);
bufferWriter.WriteStartElement(DummyName, DummyNamespace);
}
bufferWriter.WriteNode(reader, true);
}
// ServiceName
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.ServiceName, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
if (bufferWriter == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(short.MaxValue);
}
bufferWriter = buffer.OpenSection(reader.Quotas);
bufferWriter.WriteStartElement(DummyName, DummyNamespace);
}
bufferWriter.WriteNode(reader, true);
}
// Policy
reader.MoveToContent();
while (reader.IsNamespaceUri(PolicyStrings.Namespace))
{
if (bufferWriter == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(short.MaxValue);
}
bufferWriter = buffer.OpenSection(reader.Quotas);
bufferWriter.WriteStartElement(DummyName, DummyNamespace);
}
bufferWriter.WriteNode(reader, true);
reader.MoveToContent();
}
// Finish PSP
if (bufferWriter != null)
{
bufferWriter.WriteEndElement();
buffer.CloseSection();
pspSection = buffer.SectionCount - 1;
bufferWriter = null;
}
else
{
pspSection = -1;
}
// Metadata
if (reader.IsStartElement(System.ServiceModel.Description.MetadataStrings.MetadataExchangeStrings.Metadata,
System.ServiceModel.Description.MetadataStrings.MetadataExchangeStrings.Namespace))
{
if (bufferWriter == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(short.MaxValue);
}
bufferWriter = buffer.OpenSection(reader.Quotas);
bufferWriter.WriteStartElement(DummyName, DummyNamespace);
}
bufferWriter.WriteNode(reader, true);
}
// Finish metadata
if (bufferWriter != null)
{
bufferWriter.WriteEndElement();
buffer.CloseSection();
metadataSection = buffer.SectionCount - 1;
bufferWriter = null;
}
else
{
metadataSection = -1;
}
// Extensions
reader.MoveToContent();
buffer = ReadExtensions(reader, AddressingVersion.WSAddressingAugust2004, buffer, out identity, out extensionSection);
// Finished reading
if (buffer != null)
{
buffer.Close();
}
// Process Address
if (address == Addressing200408Strings.Anonymous)
{
uri = AddressingVersion.WSAddressingAugust2004.AnonymousUri;
if (headers == null && identity == null)
{
return(true);
}
}
else
{
if (!Uri.TryCreate(address, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.InvalidUriValue, address, XD.AddressingDictionary.Address.Value, AddressingVersion.WSAddressingAugust2004.Namespace)));
}
}
return(false);
}
private EndpointAddress(AddressingVersion version, System.Uri uri, EndpointIdentity identity, AddressHeaderCollection headers, XmlBuffer buffer, int metadataSection, int extensionSection, int pspSection)
{
this.Init(version, uri, identity, headers, buffer, metadataSection, extensionSection, pspSection);
}
private void Init(AddressingVersion version, Uri uri, EndpointIdentity identity, AddressHeaderCollection headers, XmlBuffer buffer, int metadataSection, int extensionSection, int pspSection)
{
if (!uri.IsAbsoluteUri)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("uri", SR.UriMustBeAbsolute);
}
_addressingVersion = version;
_uri = uri;
_identity = identity;
_headers = headers;
_buffer = buffer;
_metadataSection = metadataSection;
_extensionSection = extensionSection;
_pspSection = pspSection;
if (version != null)
{
_isAnonymous = uri == version.AnonymousUri;
_isNone = uri == version.NoneUri;
}
else
{
_isAnonymous = object.ReferenceEquals(uri, AnonymousUri) || uri == AnonymousUri;
_isNone = object.ReferenceEquals(uri, NoneUri) || uri == NoneUri;
}
if (_isAnonymous)
{
_uri = AnonymousUri;
}
if (_isNone)
{
_uri = NoneUri;
}
}
private static bool ReadContentsFrom10(XmlDictionaryReader reader, out System.Uri uri, out AddressHeaderCollection headers, out EndpointIdentity identity, out XmlBuffer buffer, out int metadataSection, out int extensionSection)
{
buffer = null;
extensionSection = -1;
metadataSection = -1;
if (!reader.IsStartElement(XD.AddressingDictionary.Address, XD.Addressing10Dictionary.Namespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, System.ServiceModel.SR.GetString("UnexpectedElementExpectingElement", new object[] { reader.LocalName, reader.NamespaceURI, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value })));
}
string uriString = reader.ReadElementContentAsString();
if (reader.IsStartElement(XD.AddressingDictionary.ReferenceParameters, XD.Addressing10Dictionary.Namespace))
{
headers = AddressHeaderCollection.ReadServiceParameters(reader);
}
else
{
headers = null;
}
if (reader.IsStartElement(XD.Addressing10Dictionary.Metadata, XD.Addressing10Dictionary.Namespace))
{
reader.ReadFullStartElement();
buffer = new XmlBuffer(0x7fff);
metadataSection = 0;
XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
while ((reader.NodeType != XmlNodeType.EndElement) && !reader.EOF)
{
writer.WriteNode(reader, true);
}
writer.Flush();
buffer.CloseSection();
reader.ReadEndElement();
}
buffer = ReadExtensions(reader, AddressingVersion.WSAddressing10, buffer, out identity, out extensionSection);
if (buffer != null)
{
buffer.Close();
}
if (uriString == "http://www.w3.org/2005/08/addressing/anonymous")
{
uri = AddressingVersion.WSAddressing10.AnonymousUri;
if ((headers == null) && (identity == null))
{
return true;
}
}
else
{
if (uriString == "http://www.w3.org/2005/08/addressing/none")
{
uri = AddressingVersion.WSAddressing10.NoneUri;
return false;
}
if (!System.Uri.TryCreate(uriString, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidUriValue", new object[] { uriString, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value })));
}
}
return false;
}
private void PossiblyPopulateBuffer(XmlDictionaryReader reader, ref XmlBuffer buffer, out int section)
{
if (reader == null)
{
section = -1;
}
else
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
section = buffer.SectionCount;
XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
Copy(writer, reader);
buffer.CloseSection();
}
}
private void Init(AddressingVersion version, System.Uri uri, EndpointIdentity identity, AddressHeaderCollection headers, XmlBuffer buffer, int metadataSection, int extensionSection, int pspSection)
{
if (!uri.IsAbsoluteUri)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("uri", System.ServiceModel.SR.GetString("UriMustBeAbsolute"));
}
this.uri = uri;
this.identity = identity;
this.headers = headers;
this.buffer = buffer;
this.metadataSection = metadataSection;
this.extensionSection = extensionSection;
this.pspSection = pspSection;
if (version != null)
{
this.isAnonymous = uri == version.AnonymousUri;
this.isNone = uri == version.NoneUri;
}
else
{
this.isAnonymous = object.ReferenceEquals(uri, AnonymousUri) || (uri == AnonymousUri);
this.isNone = object.ReferenceEquals(uri, NoneUri) || (uri == NoneUri);
}
if (this.isAnonymous)
{
this.uri = AnonymousUri;
}
if (this.isNone)
{
this.uri = NoneUri;
}
}
private void Init(System.Uri uri, EndpointIdentity identity, AddressHeaderCollection headers, XmlBuffer buffer, int metadataSection, int extensionSection, int pspSection)
{
this.Init(null, uri, identity, headers, buffer, metadataSection, extensionSection, pspSection);
}
private void Init(AddressingVersion version, System.Uri uri, EndpointIdentity identity, AddressHeaderCollection headers, XmlBuffer buffer, int metadataSection, int extensionSection, int pspSection)
{
if (!uri.IsAbsoluteUri)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("uri", System.ServiceModel.SR.GetString("UriMustBeAbsolute"));
}
this.uri = uri;
this.identity = identity;
this.headers = headers;
this.buffer = buffer;
this.metadataSection = metadataSection;
this.extensionSection = extensionSection;
this.pspSection = pspSection;
if (version != null)
{
this.isAnonymous = uri == version.AnonymousUri;
this.isNone = uri == version.NoneUri;
}
else
{
this.isAnonymous = object.ReferenceEquals(uri, AnonymousUri) || (uri == AnonymousUri);
this.isNone = object.ReferenceEquals(uri, NoneUri) || (uri == NoneUri);
}
if (this.isAnonymous)
{
this.uri = AnonymousUri;
}
if (this.isNone)
{
this.uri = NoneUri;
}
}
internal static XmlBuffer ReadExtensions(XmlDictionaryReader reader, AddressingVersion version, XmlBuffer buffer, out EndpointIdentity identity, out int section)
{
if (reader == null)
{
identity = null;
section = -1;
return(buffer);
}
// EndpointIdentity and extensions
identity = null;
XmlDictionaryWriter bufferWriter = null;
reader.MoveToContent();
while (reader.IsStartElement())
{
if (reader.IsStartElement(XD.AddressingDictionary.Identity, XD.AddressingDictionary.IdentityExtensionNamespace))
{
if (identity != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SR.Format(SR.UnexpectedDuplicateElement, XD.AddressingDictionary.Identity.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value)));
}
identity = EndpointIdentity.ReadIdentity(reader);
}
else if (version != null && reader.NamespaceURI == version.Namespace)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SR.Format(SR.AddressingExtensionInBadNS, reader.LocalName, reader.NamespaceURI)));
}
else
{
if (bufferWriter == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(short.MaxValue);
}
bufferWriter = buffer.OpenSection(reader.Quotas);
bufferWriter.WriteStartElement(DummyName, DummyNamespace);
}
bufferWriter.WriteNode(reader, true);
}
reader.MoveToContent();
}
if (bufferWriter != null)
{
bufferWriter.WriteEndElement();
buffer.CloseSection();
section = buffer.SectionCount - 1;
}
else
{
section = -1;
}
return(buffer);
}
private static bool ReadContentsFrom200408(XmlDictionaryReader reader, out System.Uri uri, out AddressHeaderCollection headers, out EndpointIdentity identity, out XmlBuffer buffer, out int metadataSection, out int extensionSection, out int pspSection)
{
buffer = null;
headers = null;
extensionSection = -1;
metadataSection = -1;
pspSection = -1;
reader.MoveToContent();
if (!reader.IsStartElement(XD.AddressingDictionary.Address, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, System.ServiceModel.SR.GetString("UnexpectedElementExpectingElement", new object[] { reader.LocalName, reader.NamespaceURI, XD.AddressingDictionary.Address.Value, XD.Addressing200408Dictionary.Namespace.Value })));
}
string uriString = reader.ReadElementContentAsString();
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.ReferenceProperties, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
headers = AddressHeaderCollection.ReadServiceParameters(reader, true);
}
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.ReferenceParameters, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
if (headers != null)
{
List<AddressHeader> addressHeaders = new List<AddressHeader>();
foreach (AddressHeader header in headers)
{
addressHeaders.Add(header);
}
foreach (AddressHeader header2 in AddressHeaderCollection.ReadServiceParameters(reader))
{
addressHeaders.Add(header2);
}
headers = new AddressHeaderCollection(addressHeaders);
}
else
{
headers = AddressHeaderCollection.ReadServiceParameters(reader);
}
}
XmlDictionaryWriter writer = null;
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.PortType, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
if (writer == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
}
writer.WriteNode(reader, true);
}
reader.MoveToContent();
if (reader.IsStartElement(XD.AddressingDictionary.ServiceName, AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
if (writer == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
}
writer.WriteNode(reader, true);
}
reader.MoveToContent();
while (reader.IsNamespaceUri(XD.PolicyDictionary.Namespace))
{
if (writer == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
}
writer.WriteNode(reader, true);
reader.MoveToContent();
}
if (writer != null)
{
writer.WriteEndElement();
buffer.CloseSection();
pspSection = buffer.SectionCount - 1;
writer = null;
}
else
{
pspSection = -1;
}
if (reader.IsStartElement("Metadata", "http://schemas.xmlsoap.org/ws/2004/09/mex"))
{
if (writer == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
}
writer.WriteNode(reader, true);
}
if (writer != null)
{
writer.WriteEndElement();
buffer.CloseSection();
metadataSection = buffer.SectionCount - 1;
writer = null;
}
else
{
metadataSection = -1;
}
reader.MoveToContent();
buffer = ReadExtensions(reader, AddressingVersion.WSAddressingAugust2004, buffer, out identity, out extensionSection);
if (buffer != null)
{
buffer.Close();
}
if (uriString == "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous")
{
uri = AddressingVersion.WSAddressingAugust2004.AnonymousUri;
if ((headers == null) && (identity == null))
{
return true;
}
}
else if (!System.Uri.TryCreate(uriString, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidUriValue", new object[] { uriString, XD.AddressingDictionary.Address.Value, AddressingVersion.WSAddressingAugust2004.Namespace })));
}
return false;
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, Workspace workspace)
{
if (workspace == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("workspace");
}
SyndicationFeedFormatter.CloseBuffer(buffer, writer);
workspace.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, ServiceDocument document)
{
if (document == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("document");
}
SyndicationFeedFormatter.CloseBuffer(buffer, writer);
document.LoadElementExtensions(buffer);
}
internal static XmlBuffer ReadExtensions(XmlDictionaryReader reader, AddressingVersion version, XmlBuffer buffer, out EndpointIdentity identity, out int section)
{
if (reader == null)
{
identity = null;
section = -1;
return buffer;
}
identity = null;
XmlDictionaryWriter writer = null;
reader.MoveToContent();
while (reader.IsStartElement())
{
if (reader.IsStartElement(XD.AddressingDictionary.Identity, XD.AddressingDictionary.IdentityExtensionNamespace))
{
if (identity != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, System.ServiceModel.SR.GetString("UnexpectedDuplicateElement", new object[] { XD.AddressingDictionary.Identity.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value })));
}
identity = EndpointIdentity.ReadIdentity(reader);
}
else
{
if ((version != null) && (reader.NamespaceURI == version.Namespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, System.ServiceModel.SR.GetString("AddressingExtensionInBadNS", new object[] { reader.LocalName, reader.NamespaceURI })));
}
if (writer == null)
{
if (buffer == null)
{
buffer = new XmlBuffer(0x7fff);
}
writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
}
writer.WriteNode(reader, true);
}
reader.MoveToContent();
}
if (writer != null)
{
writer.WriteEndElement();
buffer.CloseSection();
section = buffer.SectionCount - 1;
return buffer;
}
section = -1;
return buffer;
}
public BufferedBodyWriter(XmlBuffer buffer) : base(true)
{
this.buffer = buffer;
}
private EndpointAddress(AddressingVersion version, System.Uri uri, EndpointIdentity identity, AddressHeaderCollection headers, XmlBuffer buffer, int metadataSection, int extensionSection, int pspSection)
{
this.Init(version, uri, identity, headers, buffer, metadataSection, extensionSection, pspSection);
}
internal void LoadElementExtensions(XmlBuffer buffer)
{
this.extensions.LoadElementExtensions(buffer);
}
public DefaultMessageBuffer(Message message, XmlBuffer msgBuffer)
{
this.msgBuffer = msgBuffer;
this.version = message.Version;
this.isNullMessage = message is NullMessage;
properties = new KeyValuePair<string, object>[message.Properties.Count];
((ICollection<KeyValuePair<string, object>>)message.Properties).CopyTo(properties, 0);
understoodHeaders = new bool[message.Headers.Count];
for (int i = 0; i < understoodHeaders.Length; ++i)
understoodHeaders[i] = message.Headers.IsUnderstood(i);
//CSDMain 17837: CreateBufferedCopy should have code to copy over the To and Action headers
if (version == MessageVersion.None)
{
this.to = message.Headers.To;
this.action = message.Headers.Action;
}
}
string GetSignatureHash(MessageHeader header, string headerId, IPrefixGenerator prefixGenerator, XmlDictionaryWriter writer, out byte[] hash)
{
HashStream hashStream = TakeHashStream();
XmlDictionaryWriter effectiveWriter;
XmlBuffer canonicalBuffer = null;
if (writer.CanCanonicalize)
{
effectiveWriter = writer;
}
else
{
canonicalBuffer = new XmlBuffer(int.MaxValue);
effectiveWriter = canonicalBuffer.OpenSection(XmlDictionaryReaderQuotas.Max);
}
effectiveWriter.StartCanonicalization(hashStream, false, null);
header.WriteStartHeader(effectiveWriter, this.Version);
if (headerId == null)
{
headerId = GenerateId();
this.StandardsManager.IdManager.WriteIdAttribute(effectiveWriter, headerId);
}
header.WriteHeaderContents(effectiveWriter, this.Version);
effectiveWriter.WriteEndElement();
effectiveWriter.EndCanonicalization();
effectiveWriter.Flush();
if (!ReferenceEquals(effectiveWriter, writer))
{
Fx.Assert(canonicalBuffer != null, "Canonical buffer cannot be null.");
canonicalBuffer.CloseSection();
canonicalBuffer.Close();
XmlDictionaryReader dicReader = canonicalBuffer.GetReader(0);
writer.WriteNode(dicReader, false);
dicReader.Close();
}
hash = hashStream.FlushHashAndGetValue();
return headerId;
}
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();
}
private static XmlDictionaryReader GetReaderAtSection(XmlBuffer buffer, int section)
{
if ((buffer == null) || (section < 0))
{
return null;
}
XmlDictionaryReader reader = buffer.GetReader(section);
reader.MoveToContent();
reader.Read();
return reader;
}
private static bool ReadContentsFrom10(XmlDictionaryReader reader, out System.Uri uri, out AddressHeaderCollection headers, out EndpointIdentity identity, out XmlBuffer buffer, out int metadataSection, out int extensionSection)
{
buffer = null;
extensionSection = -1;
metadataSection = -1;
if (!reader.IsStartElement(XD.AddressingDictionary.Address, XD.Addressing10Dictionary.Namespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, System.ServiceModel.SR.GetString("UnexpectedElementExpectingElement", new object[] { reader.LocalName, reader.NamespaceURI, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value })));
}
string uriString = reader.ReadElementContentAsString();
if (reader.IsStartElement(XD.AddressingDictionary.ReferenceParameters, XD.Addressing10Dictionary.Namespace))
{
headers = AddressHeaderCollection.ReadServiceParameters(reader);
}
else
{
headers = null;
}
if (reader.IsStartElement(XD.Addressing10Dictionary.Metadata, XD.Addressing10Dictionary.Namespace))
{
reader.ReadFullStartElement();
buffer = new XmlBuffer(0x7fff);
metadataSection = 0;
XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
while ((reader.NodeType != XmlNodeType.EndElement) && !reader.EOF)
{
writer.WriteNode(reader, true);
}
writer.Flush();
buffer.CloseSection();
reader.ReadEndElement();
}
buffer = ReadExtensions(reader, AddressingVersion.WSAddressing10, buffer, out identity, out extensionSection);
if (buffer != null)
{
buffer.Close();
}
if (uriString == "http://www.w3.org/2005/08/addressing/anonymous")
{
uri = AddressingVersion.WSAddressing10.AnonymousUri;
if ((headers == null) && (identity == null))
{
return(true);
}
}
else
{
if (uriString == "http://www.w3.org/2005/08/addressing/none")
{
uri = AddressingVersion.WSAddressing10.NoneUri;
return(false);
}
if (!System.Uri.TryCreate(uriString, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidUriValue", new object[] { uriString, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value })));
}
}
return(false);
}
