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); }