internal virtual XmlDictionaryReader GetReaderAtHeader()
{
XmlBuffer buffer = new XmlBuffer(0x7fffffff);
XmlDictionaryWriter writer = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
this.WriteStartEnvelope(writer);
MessageHeaders headers = this.Headers;
for (int i = 0; i < headers.Count; i++)
{
headers.WriteHeader(i, writer);
}
writer.WriteEndElement();
writer.WriteEndElement();
buffer.CloseSection();
buffer.Close();
XmlDictionaryReader reader = buffer.GetReader(0);
reader.ReadStartElement();
reader.MoveToStartElement();
return(reader);
}
private static void CopyPropertiesToMessage(Message message, IDictionary <string, object> properties)
{
Fx.Assert(message != null, "The 'message' parameter should not be null.");
Fx.Assert(properties != null, "The 'properties' parameter should not be null.");
foreach (KeyValuePair <string, object> property in properties)
{
MessageHeaders messageHeaders = property.Value as MessageHeaders;
if (messageHeaders != null &&
messageHeaders.MessageVersion == MessageVersion.None &&
string.Equals(property.Key, MessageHeadersPropertyKey, StringComparison.Ordinal))
{
foreach (MessageHeader header in messageHeaders)
{
message.Headers.Add(header);
}
}
else
{
message.Properties.Add(property.Key, property.Value);
}
}
}
public BufferedMessage(IBufferedMessageData messageData, System.ServiceModel.Channels.RecycledMessageState recycledMessageState, bool[] understoodHeaders, bool understoodHeadersModified)
{
bool flag = true;
try
{
this.recycledMessageState = recycledMessageState;
this.messageData = messageData;
this.properties = recycledMessageState.TakeProperties();
if (this.properties == null)
{
this.properties = new MessageProperties();
}
XmlDictionaryReader messageReader = messageData.GetMessageReader();
MessageVersion messageVersion = messageData.MessageEncoder.MessageVersion;
if (messageVersion.Envelope == EnvelopeVersion.None)
{
this.reader = messageReader;
this.headers = new MessageHeaders(messageVersion);
}
else
{
EnvelopeVersion envelopeVersion = ReceivedMessage.ReadStartEnvelope(messageReader);
if (messageVersion.Envelope != envelopeVersion)
{
Exception innerException = new ArgumentException(System.ServiceModel.SR.GetString("EncoderEnvelopeVersionMismatch", new object[] { envelopeVersion, messageVersion.Envelope }), "reader");
throw TraceUtility.ThrowHelperError(new CommunicationException(innerException.Message, innerException), this);
}
if (ReceivedMessage.HasHeaderElement(messageReader, envelopeVersion))
{
this.headers = recycledMessageState.TakeHeaders();
if (this.headers == null)
{
this.headers = new MessageHeaders(messageVersion, messageReader, messageData, recycledMessageState, understoodHeaders, understoodHeadersModified);
}
else
{
this.headers.Init(messageVersion, messageReader, messageData, recycledMessageState, understoodHeaders, understoodHeadersModified);
}
}
else
{
this.headers = new MessageHeaders(messageVersion);
}
ReceivedMessage.VerifyStartBody(messageReader, envelopeVersion);
int maxSizeOfHeaders = 0x7fffffff;
this.bodyAttributes = XmlAttributeHolder.ReadAttributes(messageReader, ref maxSizeOfHeaders);
if (maxSizeOfHeaders < 0x7fffefff)
{
this.bodyAttributes = null;
}
if (base.ReadStartBody(messageReader))
{
this.reader = messageReader;
}
else
{
messageReader.Close();
}
}
flag = false;
}
finally
{
if (flag && MessageLogger.LoggingEnabled)
{
MessageLogger.LogMessage(messageData.Buffer, MessageLoggingSource.Malformed);
}
}
}
public BodyWriterMessage(MessageVersion version, ActionHeader actionHeader, System.ServiceModel.Channels.BodyWriter bodyWriter) : this(bodyWriter)
{
this.headers = new MessageHeaders(version);
this.headers.SetActionHeader(actionHeader);
}
public MessageHeaders(MessageHeaders headers)
: this(headers.MessageVersion)
{
CopyHeadersFrom(headers);
}
internal UnderstoodHeaders(MessageHeaders messageHeaders, bool modified)
{
_messageHeaders = messageHeaders;
_modified = modified;
}
public static bool WasHeaderNotUnderstood(MessageHeaders headers, string name, string ns)
{
return(default(bool));
}
internal UnderstoodHeaders(MessageHeaders messageHeaders, bool modified)
{
this.messageHeaders = messageHeaders;
this.modified = modified;
}
public static CreateSequenceInfo ReadMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion, ISecureConversationSession securitySession, Message message, MessageHeaders headers)
{
CreateSequenceInfo info;
if (message.IsEmpty)
{
string reason = System.ServiceModel.SR.GetString("NonEmptyWsrmMessageIsEmpty", new object[] { WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion) });
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
}
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
{
info = CreateSequence.Create(messageVersion, reliableMessagingVersion, securitySession, reader);
message.ReadFromBodyContentsToEnd(reader);
}
info.SetMessageId(messageVersion, headers);
info.SetReplyTo(messageVersion, headers);
if (info.AcksTo.Uri != info.ReplyTo.Uri)
{
string str2 = System.ServiceModel.SR.GetString("CSRefusedAcksToMustEqualReplyTo");
Message message3 = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, str2);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(message3, str2, new ProtocolException(str2)));
}
info.to = message.Headers.To;
if ((info.to == null) && (messageVersion.Addressing == AddressingVersion.WSAddressing10))
{
info.to = messageVersion.Addressing.AnonymousUri;
}
return(info);
}
public static CloseSequenceInfo ReadMessage(MessageVersion messageVersion, Message message, MessageHeaders headers)
{
CloseSequenceInfo info;
if (message.IsEmpty)
{
string str = System.ServiceModel.SR.GetString("NonEmptyWsrmMessageIsEmpty", new object[] { "http://docs.oasis-open.org/ws-rx/wsrm/200702/CloseSequence" });
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(str));
}
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
{
info = CloseSequence.Create(reader);
message.ReadFromBodyContentsToEnd(reader);
}
info.SetMessageId(messageVersion, headers);
info.SetReplyTo(messageVersion, headers);
return(info);
}
internal DefaultMessageBuffer(MessageHeaders headers, MessageProperties properties)
: this(0, headers, properties, null, false)
{
}
public MessageHeaders(MessageHeaders collection)
: this(collection.MessageVersion)
{
CopyHeadersFrom(collection);
}
public static WsrmMessageInfo Get(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion, IChannel channel, ISession session, System.ServiceModel.Channels.Message message, bool csrOnly)
{
WsrmMessageInfo info = new WsrmMessageInfo {
message = message
};
bool isFault = true;
try
{
isFault = message.IsFault;
MessageHeaders headers = message.Headers;
string action = headers.Action;
info.action = action;
bool flag2 = false;
bool flag3 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
bool flag4 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
bool flag5 = false;
if (action == WsrmIndex.GetCreateSequenceResponseActionString(reliableMessagingVersion))
{
info.createSequenceResponseInfo = System.ServiceModel.Channels.CreateSequenceResponseInfo.ReadMessage(messageVersion, reliableMessagingVersion, message, headers);
ValidateMustUnderstand(messageVersion, message);
return(info);
}
if (csrOnly)
{
return(info);
}
if (action == WsrmIndex.GetTerminateSequenceActionString(reliableMessagingVersion))
{
info.terminateSequenceInfo = System.ServiceModel.Channels.TerminateSequenceInfo.ReadMessage(messageVersion, reliableMessagingVersion, message, headers);
flag2 = true;
}
else if (action == WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion))
{
info.createSequenceInfo = System.ServiceModel.Channels.CreateSequenceInfo.ReadMessage(messageVersion, reliableMessagingVersion, session as ISecureConversationSession, message, headers);
if (flag3)
{
ValidateMustUnderstand(messageVersion, message);
return(info);
}
flag5 = true;
}
else if (flag4)
{
if (action == "http://docs.oasis-open.org/ws-rx/wsrm/200702/CloseSequence")
{
info.closeSequenceInfo = System.ServiceModel.Channels.CloseSequenceInfo.ReadMessage(messageVersion, message, headers);
flag2 = true;
}
else if (action == "http://docs.oasis-open.org/ws-rx/wsrm/200702/CloseSequenceResponse")
{
info.closeSequenceResponseInfo = System.ServiceModel.Channels.CloseSequenceResponseInfo.ReadMessage(messageVersion, message, headers);
flag2 = true;
}
else if (action == WsrmIndex.GetTerminateSequenceResponseActionString(reliableMessagingVersion))
{
info.terminateSequenceResponseInfo = System.ServiceModel.Channels.TerminateSequenceResponseInfo.ReadMessage(messageVersion, message, headers);
flag2 = true;
}
}
string namespaceString = WsrmIndex.GetNamespaceString(reliableMessagingVersion);
bool flag6 = messageVersion.Envelope == EnvelopeVersion.Soap11;
bool flag7 = false;
int num = -1;
int headerIndex = -1;
int num3 = -1;
int num4 = -1;
int num5 = -1;
int num6 = -1;
int index = -1;
int num8 = -1;
int num9 = -1;
for (int i = 0; i < headers.Count; i++)
{
MessageHeaderInfo info2 = headers[i];
if (messageVersion.Envelope.IsUltimateDestinationActor(info2.Actor) && (info2.Namespace == namespaceString))
{
bool flag8 = true;
if (flag5)
{
if (flag4 && (info2.Name == "UsesSequenceSSL"))
{
if (num8 != -1)
{
num = i;
break;
}
num8 = i;
}
else if (flag4 && (info2.Name == "UsesSequenceSTR"))
{
if (num9 != -1)
{
num = i;
break;
}
num9 = i;
}
else
{
flag8 = false;
}
}
else if (info2.Name == "Sequence")
{
if (headerIndex != -1)
{
num = i;
break;
}
headerIndex = i;
}
else if (info2.Name == "SequenceAcknowledgement")
{
if (num3 != -1)
{
num = i;
break;
}
num3 = i;
}
else if (info2.Name == "AckRequested")
{
if (num4 != -1)
{
num = i;
break;
}
num4 = i;
}
else if (flag6 && (info2.Name == "SequenceFault"))
{
if (index != -1)
{
num = i;
break;
}
index = i;
}
else
{
flag8 = false;
}
if (flag8)
{
if (i > num5)
{
num5 = i;
}
if (num6 == -1)
{
num6 = i;
}
}
}
}
if (num != -1)
{
Collection <MessageHeaderInfo> notUnderstoodHeaders = new Collection <MessageHeaderInfo> {
headers[num]
};
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MustUnderstandSoapException(notUnderstoodHeaders, messageVersion.Envelope));
}
if (num5 > -1)
{
BufferedMessage message2 = message as BufferedMessage;
if ((message2 != null) && message2.Headers.ContainsOnlyBufferedMessageHeaders)
{
flag7 = true;
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(num6))
{
for (int j = num6; j <= num5; j++)
{
MessageHeaderInfo header = headers[j];
if (flag5)
{
if (flag4 && (j == num8))
{
info.usesSequenceSSLInfo = WsrmUsesSequenceSSLInfo.ReadHeader(reader, header);
headers.UnderstoodHeaders.Add(header);
}
else if (flag4 && (j == num9))
{
info.usesSequenceSTRInfo = WsrmUsesSequenceSTRInfo.ReadHeader(reader, header);
headers.UnderstoodHeaders.Add(header);
}
else
{
reader.Skip();
}
}
else if (j == headerIndex)
{
info.sequencedMessageInfo = WsrmSequencedMessageInfo.ReadHeader(reliableMessagingVersion, reader, header);
headers.UnderstoodHeaders.Add(header);
}
else if (j == num3)
{
info.acknowledgementInfo = WsrmAcknowledgmentInfo.ReadHeader(reliableMessagingVersion, reader, header);
headers.UnderstoodHeaders.Add(header);
}
else if (j == num4)
{
info.ackRequestedInfo = WsrmAckRequestedInfo.ReadHeader(reliableMessagingVersion, reader, header);
headers.UnderstoodHeaders.Add(header);
}
else
{
reader.Skip();
}
}
}
}
}
if ((num5 > -1) && !flag7)
{
flag7 = true;
if (flag5)
{
if (num8 != -1)
{
using (XmlDictionaryReader reader2 = headers.GetReaderAtHeader(num8))
{
MessageHeaderInfo info4 = headers[num8];
info.usesSequenceSSLInfo = WsrmUsesSequenceSSLInfo.ReadHeader(reader2, info4);
headers.UnderstoodHeaders.Add(info4);
}
}
if (num9 == -1)
{
goto Label_05CB;
}
using (XmlDictionaryReader reader3 = headers.GetReaderAtHeader(num9))
{
MessageHeaderInfo info5 = headers[num9];
info.usesSequenceSTRInfo = WsrmUsesSequenceSTRInfo.ReadHeader(reader3, info5);
headers.UnderstoodHeaders.Add(info5);
goto Label_05CB;
}
}
if (headerIndex != -1)
{
using (XmlDictionaryReader reader4 = headers.GetReaderAtHeader(headerIndex))
{
MessageHeaderInfo info6 = headers[headerIndex];
info.sequencedMessageInfo = WsrmSequencedMessageInfo.ReadHeader(reliableMessagingVersion, reader4, info6);
headers.UnderstoodHeaders.Add(info6);
}
}
if (num3 != -1)
{
using (XmlDictionaryReader reader5 = headers.GetReaderAtHeader(num3))
{
MessageHeaderInfo info7 = headers[num3];
info.acknowledgementInfo = WsrmAcknowledgmentInfo.ReadHeader(reliableMessagingVersion, reader5, info7);
headers.UnderstoodHeaders.Add(info7);
}
}
if (num4 != -1)
{
using (XmlDictionaryReader reader6 = headers.GetReaderAtHeader(num4))
{
MessageHeaderInfo info8 = headers[num4];
info.ackRequestedInfo = WsrmAckRequestedInfo.ReadHeader(reliableMessagingVersion, reader6, info8);
headers.UnderstoodHeaders.Add(info8);
}
}
}
Label_05CB:
if (flag5)
{
System.ServiceModel.Channels.CreateSequenceInfo.ValidateCreateSequenceHeaders(messageVersion, session as ISecureConversationSession, info);
ValidateMustUnderstand(messageVersion, message);
return(info);
}
if ((info.sequencedMessageInfo == null) && (info.action == null))
{
if (flag3)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(System.ServiceModel.SR.GetString("NoActionNoSequenceHeaderReason"), messageVersion.Addressing.Namespace, "Action", false));
}
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateWsrmRequiredException(messageVersion));
}
if ((info.sequencedMessageInfo == null) && message.IsFault)
{
System.ServiceModel.Channels.WsrmHeaderFault fault;
info.faultInfo = System.ServiceModel.Channels.MessageFault.CreateFault(message, 0x10000);
if (flag6)
{
if (System.ServiceModel.Channels.WsrmHeaderFault.TryCreateFault11(reliableMessagingVersion, message, info.faultInfo, index, out fault))
{
info.faultInfo = fault;
info.faultException = WsrmFault.CreateException(fault);
}
}
else if (System.ServiceModel.Channels.WsrmHeaderFault.TryCreateFault12(reliableMessagingVersion, message, info.faultInfo, out fault))
{
info.faultInfo = fault;
info.faultException = WsrmFault.CreateException(fault);
}
if (fault == null)
{
FaultConverter property = channel.GetProperty <FaultConverter>();
if (property == null)
{
property = FaultConverter.GetDefaultFaultConverter(messageVersion);
}
if (!property.TryCreateException(message, info.faultInfo, out info.faultException))
{
info.faultException = new ProtocolException(System.ServiceModel.SR.GetString("UnrecognizedFaultReceived", new object[] { info.faultInfo.Code.Namespace, info.faultInfo.Code.Name, System.ServiceModel.FaultException.GetSafeReasonText(info.faultInfo) }));
}
}
flag2 = true;
}
if (!flag7 && !flag2)
{
if (flag3)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ActionNotSupportedException(System.ServiceModel.SR.GetString("NonWsrmFeb2005ActionNotSupported", new object[] { action })));
}
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateWsrmRequiredException(messageVersion));
}
if (!flag2 && !WsrmUtilities.IsWsrmAction(reliableMessagingVersion, action))
{
return(info);
}
ValidateMustUnderstand(messageVersion, message);
}
catch (InternalFaultException exception)
{
if (System.ServiceModel.DiagnosticUtility.ShouldTraceInformation)
{
System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Information);
}
info.FaultReply = exception.FaultReply;
info.faultException = exception.InnerException;
}
catch (CommunicationException exception2)
{
if (System.ServiceModel.DiagnosticUtility.ShouldTraceInformation)
{
System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Information);
}
if (isFault)
{
info.parsingException = exception2;
return(info);
}
FaultConverter defaultFaultConverter = channel.GetProperty <FaultConverter>();
if (defaultFaultConverter == null)
{
defaultFaultConverter = FaultConverter.GetDefaultFaultConverter(messageVersion);
}
if (defaultFaultConverter.TryCreateFaultMessage(exception2, out info.faultReply))
{
info.faultException = new ProtocolException(System.ServiceModel.SR.GetString("MessageExceptionOccurred"), exception2);
return(info);
}
info.parsingException = new ProtocolException(System.ServiceModel.SR.GetString("MessageExceptionOccurred"), exception2);
}
catch (XmlException exception3)
{
if (System.ServiceModel.DiagnosticUtility.ShouldTraceInformation)
{
System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Information);
}
info.parsingException = new ProtocolException(System.ServiceModel.SR.GetString("MessageExceptionOccurred"), exception3);
}
return(info);
}
public BodyWriterMessage(MessageVersion version, string action, System.ServiceModel.Channels.BodyWriter bodyWriter) : this(bodyWriter)
{
this.headers = new MessageHeaders(version);
this.headers.Action = action;
}
public ByteStreamMessageBuffer(ByteStreamBufferedMessageData messageData, MessageHeaders headers, MessageProperties properties, XmlDictionaryReaderQuotas quotas, bool moveBodyReaderToContent)
: base()
{
this.messageData = messageData;
this.headers = new MessageHeaders(headers);
this.properties = new MessageProperties(properties);
this.quotas = new XmlDictionaryReaderQuotas();
quotas.CopyTo(this.quotas);
this.moveBodyReaderToContent = moveBodyReaderToContent;
this.messageData.Open();
}
public static CloseSequenceResponseInfo ReadMessage(MessageVersion messageVersion, Message message, MessageHeaders headers)
{
CloseSequenceResponseInfo info;
if (headers.RelatesTo == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(System.ServiceModel.SR.GetString("MissingRelatesToOnWsrmResponseReason", new object[] { DXD.Wsrm11Dictionary.CloseSequenceResponse }), messageVersion.Addressing.Namespace, "RelatesTo", false));
}
if (message.IsEmpty)
{
string str = System.ServiceModel.SR.GetString("NonEmptyWsrmMessageIsEmpty", new object[] { "http://docs.oasis-open.org/ws-rx/wsrm/200702/CloseSequenceResponse" });
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(str));
}
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
{
info = CloseSequenceResponse.Create(reader);
message.ReadFromBodyContentsToEnd(reader);
}
info.relatesTo = headers.RelatesTo;
return(info);
}
public void CopyHeaderFrom(MessageHeaders collection, int headerIndex)
{
l.Add(collection [headerIndex]);
}
public BodyWriterMessageBuffer(MessageHeaders headers, KeyValuePair <string, object>[] properties, System.ServiceModel.Channels.BodyWriter bodyWriter)
{
this.bodyWriter = bodyWriter;
this.headers = new MessageHeaders(headers);
this.properties = properties;
}
public PatternMessage(IBufferedMessageData messageData, MessageVersion messageVersion, KeyValuePair <string, object>[] properties, MessageHeaders headers)
{
this.messageData = messageData;
this.messageData.Open();
this.recycledMessageState = this.messageData.TakeMessageState();
if (this.recycledMessageState == null)
{
this.recycledMessageState = new System.ServiceModel.Channels.RecycledMessageState();
}
this.properties = this.recycledMessageState.TakeProperties();
if (this.properties == null)
{
this.properties = new MessageProperties();
}
if (properties != null)
{
this.properties.CopyProperties(properties);
}
this.headers = this.recycledMessageState.TakeHeaders();
if (this.headers == null)
{
this.headers = new MessageHeaders(messageVersion);
}
if (headers != null)
{
this.headers.CopyHeadersFrom(headers);
}
XmlDictionaryReader messageReader = messageData.GetMessageReader();
messageReader.ReadStartElement();
ReceivedMessage.VerifyStartBody(messageReader, messageVersion.Envelope);
base.ReadStartBody(messageReader);
this.reader = messageReader;
}
internal DefaultMessageBuffer(MessageHeaders headers, MessageProperties properties, AttributeCollection attributes)
: this(0, headers, properties, null, false, attributes)
{
}
public PatternMessageBuffer(IBufferedMessageData messageDataAtBody, MessageVersion messageVersion, KeyValuePair <string, object>[] properties, MessageHeaders headers)
{
this.messageDataAtBody = messageDataAtBody;
this.messageDataAtBody.Open();
this.recycledMessageState = this.messageDataAtBody.TakeMessageState();
if (this.recycledMessageState == null)
{
this.recycledMessageState = new RecycledMessageState();
}
this.headers = this.recycledMessageState.TakeHeaders();
if (this.headers == null)
{
this.headers = new MessageHeaders(messageVersion);
}
this.headers.CopyHeadersFrom(headers);
this.properties = properties;
this.messageVersion = messageVersion;
}
public static TerminateSequenceResponseInfo ReadMessage(MessageVersion messageVersion, Message message, MessageHeaders headers)
{
TerminateSequenceResponseInfo info;
if (headers.RelatesTo == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(System.ServiceModel.SR.GetString("MissingRelatesToOnWsrmResponseReason", new object[] { DXD.Wsrm11Dictionary.TerminateSequenceResponse }), messageVersion.Addressing.Namespace, "RelatesTo", false));
}
if (message.IsEmpty)
{
string str = System.ServiceModel.SR.GetString("NonEmptyWsrmMessageIsEmpty", new object[] { WsrmIndex.GetTerminateSequenceResponseActionString(ReliableMessagingVersion.WSReliableMessaging11) });
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(str));
}
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
{
info = TerminateSequenceResponse.Create(reader);
message.ReadFromBodyContentsToEnd(reader);
}
info.relatesTo = headers.RelatesTo;
return(info);
}
public Message TryCreateMessage(byte[] buffer, int offset, int size, BufferManager bufferManager, BufferedMessageData messageData)
{
RelatesToHeader header;
MessageIDHeader header2;
XmlDictionaryString anonymous;
int num6;
XmlDictionaryString str2;
int num = offset;
int num2 = size;
int num3 = BinaryFormatParser.MatchBytes(buffer, num, num2, commonFragment);
if (num3 == 0)
{
return(null);
}
num += num3;
num2 -= num3;
num3 = BinaryFormatParser.MatchKey(buffer, num, num2);
if (num3 == 0)
{
return(null);
}
int num4 = num;
int num5 = num3;
num += num3;
num2 -= num3;
num3 = BinaryFormatParser.MatchBytes(buffer, num, num2, requestFragment1);
if (num3 != 0)
{
num += num3;
num2 -= num3;
num3 = BinaryFormatParser.MatchUniqueID(buffer, num, num2);
if (num3 == 0)
{
return(null);
}
int num7 = num;
int num8 = num3;
num += num3;
num2 -= num3;
num3 = BinaryFormatParser.MatchBytes(buffer, num, num2, requestFragment2);
if (num3 == 0)
{
return(null);
}
num += num3;
num2 -= num3;
if (BinaryFormatParser.MatchAttributeNode(buffer, num, num2))
{
return(null);
}
header2 = MessageIDHeader.Create(BinaryFormatParser.ParseUniqueID(buffer, num7, num8), this.messageVersion.Addressing);
header = null;
if (!this.readerSession.TryLookup(1, out anonymous))
{
return(null);
}
num6 = (requestFragment1.Length + num8) + requestFragment2.Length;
}
else
{
num3 = BinaryFormatParser.MatchBytes(buffer, num, num2, responseFragment1);
if (num3 == 0)
{
return(null);
}
num += num3;
num2 -= num3;
num3 = BinaryFormatParser.MatchUniqueID(buffer, num, num2);
if (num3 == 0)
{
return(null);
}
int num9 = num;
int num10 = num3;
num += num3;
num2 -= num3;
num3 = BinaryFormatParser.MatchBytes(buffer, num, num2, responseFragment2);
if (num3 == 0)
{
return(null);
}
num += num3;
num2 -= num3;
if (BinaryFormatParser.MatchAttributeNode(buffer, num, num2))
{
return(null);
}
header = RelatesToHeader.Create(BinaryFormatParser.ParseUniqueID(buffer, num9, num10), this.messageVersion.Addressing);
header2 = null;
anonymous = XD.Addressing10Dictionary.Anonymous;
num6 = (responseFragment1.Length + num10) + responseFragment2.Length;
}
num6 += commonFragment.Length + num5;
int key = BinaryFormatParser.ParseKey(buffer, num4, num5);
if (!this.TryLookupKey(key, out str2))
{
return(null);
}
ActionHeader actionHeader = ActionHeader.Create(str2, this.messageVersion.Addressing);
if (this.toHeader == null)
{
this.toHeader = ToHeader.Create(new Uri(anonymous.Value), this.messageVersion.Addressing);
}
int num12 = num6 - bodyFragment.Length;
offset += num12;
size -= num12;
Buffer.BlockCopy(bodyFragment, 0, buffer, offset, bodyFragment.Length);
messageData.Open(new ArraySegment <byte>(buffer, offset, size), bufferManager);
PatternMessage message = new PatternMessage(messageData, this.messageVersion);
MessageHeaders headers = message.Headers;
headers.AddActionHeader(actionHeader);
if (header2 != null)
{
headers.AddMessageIDHeader(header2);
headers.AddReplyToHeader(ReplyToHeader.AnonymousReplyTo10);
}
else
{
headers.AddRelatesToHeader(header);
}
headers.AddToHeader(this.toHeader);
return(message);
}
protected ContentOnlyMessage()
{
_headers = new MessageHeaders(MessageVersion.None);
}
public static TerminateSequenceInfo ReadMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion, Message message, MessageHeaders headers)
{
TerminateSequenceInfo info;
if (message.IsEmpty)
{
string str = System.ServiceModel.SR.GetString("NonEmptyWsrmMessageIsEmpty", new object[] { WsrmIndex.GetTerminateSequenceActionString(reliableMessagingVersion) });
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(str));
}
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
{
info = TerminateSequence.Create(reliableMessagingVersion, reader);
message.ReadFromBodyContentsToEnd(reader);
}
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
info.SetMessageId(messageVersion, headers);
info.SetReplyTo(messageVersion, headers);
}
return(info);
}
public void CopyHeaderFrom(MessageHeaders headers, int index)
{
l.Add(headers [index]);
}
public BodyWriterMessage(MessageHeaders headers, KeyValuePair <string, object>[] properties, System.ServiceModel.Channels.BodyWriter bodyWriter) : this(bodyWriter)
{
this.headers = new MessageHeaders(headers);
this.properties = new MessageProperties(properties);
}
