public static CreateSequenceResponseInfo ReadMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion, Message message, MessageHeaders headers)
{
CreateSequenceResponseInfo info;
if (message.IsEmpty)
{
string str = System.ServiceModel.SR.GetString("NonEmptyWsrmMessageIsEmpty", new object[] { WsrmIndex.GetCreateSequenceResponseActionString(reliableMessagingVersion) });
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(str));
}
if (headers.RelatesTo == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(System.ServiceModel.SR.GetString("MissingRelatesToOnWsrmResponseReason", new object[] { XD.WsrmFeb2005Dictionary.CreateSequenceResponse }), messageVersion.Addressing.Namespace, "RelatesTo", false));
}
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
{
info = CreateSequenceResponse.Create(messageVersion.Addressing, reliableMessagingVersion, reader);
message.ReadFromBodyContentsToEnd(reader);
}
info.RelatesTo = headers.RelatesTo;
return(info);
}
void ProcessCreateSequenceResponse(Message response, DateTime start)
{
CreateSequenceResponseInfo createResponse = null;
using (response)
{
if (response.IsFault)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmUtilities.CreateCSFaultException(
this.Settings.MessageVersion, this.Settings.ReliableMessagingVersion, response,
this.binder.Channel));
}
else
{
WsrmMessageInfo info = WsrmMessageInfo.Get(this.Settings.MessageVersion,
this.Settings.ReliableMessagingVersion, this.binder.Channel, this.binder.GetInnerSession(),
response, true);
if (info.ParsingException != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SR.GetString(SR.UnparsableCSResponse), info.ParsingException));
}
// this throws and sends a fault if something is wrong with the info
this.ProcessInfo(info, null, true);
createResponse = info.CreateSequenceResponseInfo;
string exceptionReason = null;
string faultReason = null;
if (createResponse == null)
{
exceptionReason = SR.GetString(SR.InvalidWsrmResponseChannelNotOpened,
WsrmFeb2005Strings.CreateSequence, info.Action,
WsrmIndex.GetCreateSequenceResponseActionString(this.Settings.ReliableMessagingVersion));
}
else if (!object.Equals(createResponse.RelatesTo, this.requestor.MessageId))
{
exceptionReason = SR.GetString(SR.WsrmMessageWithWrongRelatesToExceptionString, WsrmFeb2005Strings.CreateSequence);
faultReason = SR.GetString(SR.WsrmMessageWithWrongRelatesToFaultString, WsrmFeb2005Strings.CreateSequence);
}
else if ((createResponse.AcceptAcksTo == null) && (this.InputID != null))
{
if (this.Settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
exceptionReason = SR.GetString(SR.CSResponseWithoutOffer);
faultReason = SR.GetString(SR.CSResponseWithoutOfferReason);
}
else if (this.Settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
exceptionReason = SR.GetString(SR.CSResponseOfferRejected);
faultReason = SR.GetString(SR.CSResponseOfferRejectedReason);
}
else
{
throw Fx.AssertAndThrow("Reliable messaging version not supported.");
}
}
else if ((createResponse.AcceptAcksTo != null) && (this.InputID == null))
{
exceptionReason = SR.GetString(SR.CSResponseWithOffer);
faultReason = SR.GetString(SR.CSResponseWithOfferReason);
}
else if (createResponse.AcceptAcksTo != null && (createResponse.AcceptAcksTo.Uri != this.binder.RemoteAddress.Uri))
{
exceptionReason = SR.GetString(SR.AcksToMustBeSameAsRemoteAddress);
faultReason = SR.GetString(SR.AcksToMustBeSameAsRemoteAddressReason);
}
if ((faultReason != null) && (createResponse != null))
{
UniqueId sequenceId = createResponse.Identifier;
WsrmFault fault = SequenceTerminatedFault.CreateProtocolFault(sequenceId, faultReason, null);
this.OnLocalFault(null, fault, null);
}
if (exceptionReason != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(exceptionReason));
}
}
}
this.InitiationTime = DateTime.UtcNow - start;
this.OutputID = createResponse.Identifier;
this.pollingTimer.Set(this.GetPollingInterval());
base.StartInactivityTimer();
}
private void ProcessCreateSequenceResponse(Message response, DateTime start)
{
CreateSequenceResponseInfo createSequenceResponseInfo = null;
using (response)
{
if (response.IsFault)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmUtilities.CreateCSFaultException(base.Settings.MessageVersion, base.Settings.ReliableMessagingVersion, response, this.binder.Channel));
}
WsrmMessageInfo info2 = WsrmMessageInfo.Get(base.Settings.MessageVersion, base.Settings.ReliableMessagingVersion, this.binder.Channel, this.binder.GetInnerSession(), response, true);
if (info2.ParsingException != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(System.ServiceModel.SR.GetString("UnparsableCSResponse"), info2.ParsingException));
}
base.ProcessInfo(info2, null, true);
createSequenceResponseInfo = info2.CreateSequenceResponseInfo;
string message = null;
string faultReason = null;
if (createSequenceResponseInfo == null)
{
message = System.ServiceModel.SR.GetString("InvalidWsrmResponseChannelNotOpened", new object[] { "CreateSequence", info2.Action, WsrmIndex.GetCreateSequenceResponseActionString(base.Settings.ReliableMessagingVersion) });
}
else if (!object.Equals(createSequenceResponseInfo.RelatesTo, this.requestor.MessageId))
{
message = System.ServiceModel.SR.GetString("WsrmMessageWithWrongRelatesToExceptionString", new object[] { "CreateSequence" });
faultReason = System.ServiceModel.SR.GetString("WsrmMessageWithWrongRelatesToFaultString", new object[] { "CreateSequence" });
}
else if ((createSequenceResponseInfo.AcceptAcksTo == null) && (base.InputID != null))
{
if (base.Settings.ReliableMessagingVersion != ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (base.Settings.ReliableMessagingVersion != ReliableMessagingVersion.WSReliableMessaging11)
{
throw Fx.AssertAndThrow("Reliable messaging version not supported.");
}
message = System.ServiceModel.SR.GetString("CSResponseOfferRejected");
faultReason = System.ServiceModel.SR.GetString("CSResponseOfferRejectedReason");
}
else
{
message = System.ServiceModel.SR.GetString("CSResponseWithoutOffer");
faultReason = System.ServiceModel.SR.GetString("CSResponseWithoutOfferReason");
}
}
else if ((createSequenceResponseInfo.AcceptAcksTo != null) && (base.InputID == null))
{
message = System.ServiceModel.SR.GetString("CSResponseWithOffer");
faultReason = System.ServiceModel.SR.GetString("CSResponseWithOfferReason");
}
else if ((createSequenceResponseInfo.AcceptAcksTo != null) && (createSequenceResponseInfo.AcceptAcksTo.Uri != this.binder.RemoteAddress.Uri))
{
message = System.ServiceModel.SR.GetString("AcksToMustBeSameAsRemoteAddress");
faultReason = System.ServiceModel.SR.GetString("AcksToMustBeSameAsRemoteAddressReason");
}
if ((faultReason != null) && (createSequenceResponseInfo != null))
{
WsrmFault fault = SequenceTerminatedFault.CreateProtocolFault(createSequenceResponseInfo.Identifier, faultReason, null);
base.OnLocalFault(null, fault, null);
}
if (message != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(message));
}
}
base.InitiationTime = (TimeSpan)(DateTime.UtcNow - start);
base.OutputID = createSequenceResponseInfo.Identifier;
this.pollingTimer.Set(this.GetPollingInterval());
base.StartInactivityTimer();
}
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);
}
