in src/System.ServiceModel.Primitives/src/System/ServiceModel/Channels/WsrmMessageInfo.cs [125:559]
public static WsrmMessageInfo Get(MessageVersion messageVersion,
ReliableMessagingVersion reliableMessagingVersion, IChannel channel, ISession session, Message message,
bool csrOnly)
{
WsrmMessageInfo messageInfo = new WsrmMessageInfo();
messageInfo.Message = message;
bool isFault = true;
try
{
isFault = message.IsFault;
MessageHeaders headers = message.Headers;
string action = headers.Action;
messageInfo.Action = action;
bool foundAction = false;
bool wsrmFeb2005 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
bool wsrm11 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
bool csOnly = false;
if (action == WsrmIndex.GetCreateSequenceResponseActionString(reliableMessagingVersion))
{
messageInfo.CreateSequenceResponseInfo = CreateSequenceResponseInfo.ReadMessage(messageVersion,
reliableMessagingVersion, message, headers);
ValidateMustUnderstand(messageVersion, message);
return messageInfo;
}
if (csrOnly)
return messageInfo;
if (action == WsrmIndex.GetTerminateSequenceActionString(reliableMessagingVersion))
{
messageInfo.TerminateSequenceInfo = TerminateSequenceInfo.ReadMessage(messageVersion,
reliableMessagingVersion, message, headers);
foundAction = true;
}
else if (action == WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion))
{
messageInfo.CreateSequenceInfo = CreateSequenceInfo.ReadMessage(messageVersion,
reliableMessagingVersion, session as ISecureConversationSession, message, headers);
if (wsrmFeb2005)
{
ValidateMustUnderstand(messageVersion, message);
return messageInfo;
}
csOnly = true;
}
else if (wsrm11)
{
if (action == Wsrm11Strings.CloseSequenceAction)
{
messageInfo.CloseSequenceInfo = CloseSequenceInfo.ReadMessage(messageVersion, message,
headers);
foundAction = true;
}
else if (action == Wsrm11Strings.CloseSequenceResponseAction)
{
messageInfo.CloseSequenceResponseInfo = CloseSequenceResponseInfo.ReadMessage(messageVersion,
message, headers);
foundAction = true;
}
else if (action == WsrmIndex.GetTerminateSequenceResponseActionString(reliableMessagingVersion))
{
messageInfo.TerminateSequenceResponseInfo = TerminateSequenceResponseInfo.ReadMessage(messageVersion,
message, headers);
foundAction = true;
}
}
string wsrmNs = WsrmIndex.GetNamespaceString(reliableMessagingVersion);
bool soap11 = messageVersion.Envelope == EnvelopeVersion.Soap11;
bool foundHeader = false;
int foundTooManyIndex = -1;
int sequenceIndex = -1;
int ackIndex = -1;
int ackRequestedIndex = -1;
int maxIndex = -1;
int minIndex = -1;
int sequenceFaultIndex = -1;
int usesSequenceSSLIndex = -1;
int usesSequenceSTRIndex = -1;
for (int index = 0; index < headers.Count; index++)
{
MessageHeaderInfo header = headers[index];
if (!messageVersion.Envelope.IsUltimateDestinationActor(header.Actor))
continue;
if (header.Namespace == wsrmNs)
{
bool setIndex = true;
if (csOnly)
{
if (wsrm11 && (header.Name == Wsrm11Strings.UsesSequenceSSL))
{
if (usesSequenceSSLIndex != -1)
{
foundTooManyIndex = index;
break;
}
usesSequenceSSLIndex = index;
}
else if (wsrm11 && (header.Name == Wsrm11Strings.UsesSequenceSTR))
{
if (usesSequenceSTRIndex != -1)
{
foundTooManyIndex = index;
break;
}
usesSequenceSTRIndex = index;
}
else
{
setIndex = false;
}
}
else
{
if (header.Name == WsrmFeb2005Strings.Sequence)
{
if (sequenceIndex != -1)
{
foundTooManyIndex = index;
break;
}
sequenceIndex = index;
}
else if (header.Name == WsrmFeb2005Strings.SequenceAcknowledgement)
{
if (ackIndex != -1)
{
foundTooManyIndex = index;
break;
}
ackIndex = index;
}
else if (header.Name == WsrmFeb2005Strings.AckRequested)
{
if (ackRequestedIndex != -1)
{
foundTooManyIndex = index;
break;
}
ackRequestedIndex = index;
}
else if (soap11 && (header.Name == WsrmFeb2005Strings.SequenceFault))
{
if (sequenceFaultIndex != -1)
{
foundTooManyIndex = index;
break;
}
sequenceFaultIndex = index;
}
else
{
setIndex = false;
}
}
if (setIndex)
{
if (index > maxIndex)
maxIndex = index;
if (minIndex == -1)
minIndex = index;
}
}
}
if (foundTooManyIndex != -1)
{
Collection<MessageHeaderInfo> notUnderstoodHeaders = new Collection<MessageHeaderInfo>();
notUnderstoodHeaders.Add(headers[foundTooManyIndex]);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new MustUnderstandSoapException(notUnderstoodHeaders, messageVersion.Envelope));
}
if (maxIndex > -1)
{
BufferedMessage bufferedMessage = message as BufferedMessage;
if (bufferedMessage != null && bufferedMessage.Headers.ContainsOnlyBufferedMessageHeaders)
{
foundHeader = true;
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(minIndex))
{
for (int index = minIndex; index <= maxIndex; index++)
{
MessageHeaderInfo header = headers[index];
if (csOnly)
{
if (wsrm11 && (index == usesSequenceSSLIndex))
{
messageInfo.UsesSequenceSSLInfo = WsrmUsesSequenceSSLInfo.ReadHeader(
reader, header);
headers.UnderstoodHeaders.Add(header);
}
else if (wsrm11 && (index == usesSequenceSTRIndex))
{
messageInfo.UsesSequenceSTRInfo = WsrmUsesSequenceSTRInfo.ReadHeader(
reader, header);
headers.UnderstoodHeaders.Add(header);
}
else
{
reader.Skip();
}
}
else
{
if (index == sequenceIndex)
{
messageInfo.SequencedMessageInfo = WsrmSequencedMessageInfo.ReadHeader(
reliableMessagingVersion, reader, header);
headers.UnderstoodHeaders.Add(header);
}
else if (index == ackIndex)
{
messageInfo.AcknowledgementInfo = WsrmAcknowledgmentInfo.ReadHeader(
reliableMessagingVersion, reader, header);
headers.UnderstoodHeaders.Add(header);
}
else if (index == ackRequestedIndex)
{
messageInfo.AckRequestedInfo = WsrmAckRequestedInfo.ReadHeader(
reliableMessagingVersion, reader, header);
headers.UnderstoodHeaders.Add(header);
}
else
{
reader.Skip();
}
}
}
}
}
}
if (maxIndex > -1 && !foundHeader)
{
foundHeader = true;
if (csOnly)
{
if (usesSequenceSSLIndex != -1)
{
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(usesSequenceSSLIndex))
{
MessageHeaderInfo header = headers[usesSequenceSSLIndex];
messageInfo.UsesSequenceSSLInfo = WsrmUsesSequenceSSLInfo.ReadHeader(
reader, header);
headers.UnderstoodHeaders.Add(header);
}
}
if (usesSequenceSTRIndex != -1)
{
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(usesSequenceSTRIndex))
{
MessageHeaderInfo header = headers[usesSequenceSTRIndex];
messageInfo.UsesSequenceSTRInfo = WsrmUsesSequenceSTRInfo.ReadHeader(
reader, header);
headers.UnderstoodHeaders.Add(header);
}
}
}
else
{
if (sequenceIndex != -1)
{
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(sequenceIndex))
{
MessageHeaderInfo header = headers[sequenceIndex];
messageInfo.SequencedMessageInfo = WsrmSequencedMessageInfo.ReadHeader(
reliableMessagingVersion, reader, header);
headers.UnderstoodHeaders.Add(header);
}
}
if (ackIndex != -1)
{
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(ackIndex))
{
MessageHeaderInfo header = headers[ackIndex];
messageInfo.AcknowledgementInfo = WsrmAcknowledgmentInfo.ReadHeader(
reliableMessagingVersion, reader, header);
headers.UnderstoodHeaders.Add(header);
}
}
if (ackRequestedIndex != -1)
{
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(ackRequestedIndex))
{
MessageHeaderInfo header = headers[ackRequestedIndex];
messageInfo.AckRequestedInfo = WsrmAckRequestedInfo.ReadHeader(reliableMessagingVersion,
reader, header);
headers.UnderstoodHeaders.Add(header);
}
}
}
}
if (csOnly)
{
CreateSequenceInfo.ValidateCreateSequenceHeaders(messageVersion,
session as ISecureConversationSession, messageInfo);
ValidateMustUnderstand(messageVersion, message);
return messageInfo;
}
if (messageInfo.SequencedMessageInfo == null && messageInfo.Action == null)
{
if (wsrmFeb2005)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(SRP.NoActionNoSequenceHeaderReason, messageVersion.Addressing.Namespace, AddressingStrings.Action, false));
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
CreateWsrmRequiredException(messageVersion));
}
}
if (messageInfo.SequencedMessageInfo == null && message.IsFault)
{
messageInfo.MessageFault = MessageFault.CreateFault(message, TransportDefaults.MaxRMFaultSize);
WsrmHeaderFault wsrmFault;
if (soap11)
{
if (WsrmHeaderFault.TryCreateFault11(reliableMessagingVersion, message, messageInfo.MessageFault, sequenceFaultIndex, out wsrmFault))
{
messageInfo.MessageFault = wsrmFault;
messageInfo._faultException = WsrmHeaderFault.CreateException(wsrmFault);
}
}
else
{
if (WsrmHeaderFault.TryCreateFault12(reliableMessagingVersion, message, messageInfo.MessageFault, out wsrmFault))
{
messageInfo.MessageFault = wsrmFault;
messageInfo._faultException = WsrmHeaderFault.CreateException(wsrmFault);
}
}
// Not a wsrm fault, maybe it is another fault we should understand (i.e. addressing or soap fault).
if (wsrmFault == null)
{
FaultConverter faultConverter = channel.GetProperty<FaultConverter>();
if (faultConverter == null)
{
faultConverter = FaultConverter.GetDefaultFaultConverter(messageVersion);
}
if (!faultConverter.TryCreateException(message, messageInfo.MessageFault, out messageInfo._faultException))
{
messageInfo._faultException = new ProtocolException(SRP.Format(SRP.UnrecognizedFaultReceived, messageInfo.MessageFault.Code.Namespace, messageInfo.MessageFault.Code.Name, System.ServiceModel.FaultException.GetSafeReasonText(messageInfo.MessageFault)));
}
}
foundAction = true;
}
if (!foundHeader && !foundAction)
{
if (wsrmFeb2005)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ActionNotSupportedException(SRP.Format(SRP.NonWsrmFeb2005ActionNotSupported, action)));
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
CreateWsrmRequiredException(messageVersion));
}
}
if (foundAction || WsrmUtilities.IsWsrmAction(reliableMessagingVersion, action))
{
ValidateMustUnderstand(messageVersion, message);
}
}
catch (InternalFaultException exception)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);
messageInfo.FaultReply = exception.FaultReply;
messageInfo._faultException = exception.InnerException;
}
catch (CommunicationException exception)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);
if (isFault)
{
messageInfo.ParsingException = exception;
return messageInfo;
}
FaultConverter faultConverter = channel.GetProperty<FaultConverter>();
if (faultConverter == null)
faultConverter = FaultConverter.GetDefaultFaultConverter(messageVersion);
if (faultConverter.TryCreateFaultMessage(exception, out messageInfo._faultReply))
{
messageInfo._faultException = new ProtocolException(SRP.MessageExceptionOccurred, exception);
}
else
{
messageInfo.ParsingException = new ProtocolException(SRP.MessageExceptionOccurred, exception);
}
}
catch (XmlException exception)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);
messageInfo.ParsingException = new ProtocolException(SRP.MessageExceptionOccurred, exception);
}
return messageInfo;
}