private void ProcessCloseOrTerminateReply(bool close, Message reply)
{
if (reply == null)
{
throw Fx.AssertAndThrow("Argument reply cannot be null.");
}
ReliableRequestor requestor = close ? this.closeRequestor : this.terminateRequestor;
if (requestor.GetInfo() == null)
{
try
{
WsrmMessageInfo info = WsrmMessageInfo.Get(this.Settings.MessageVersion, this.Settings.ReliableMessagingVersion, this.binder.Channel, this.binder.GetInnerSession(), reply);
this.ReliableSession.ProcessInfo(info, null, true);
this.ReliableSession.VerifyDuplexProtocolElements(info, null, true);
WsrmFault fault = close ? WsrmUtilities.ValidateCloseSequenceResponse(this.session, requestor.MessageId, info, this.connection.Last) : WsrmUtilities.ValidateTerminateSequenceResponse(this.session, requestor.MessageId, info, this.connection.Last);
if (fault != null)
{
this.ReliableSession.OnLocalFault(null, fault, null);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(fault.CreateException());
}
}
finally
{
reply.Close();
}
}
}
private void ProcessCloseOrTerminateReply(bool close, Message reply)
{
if (reply == null)
{
throw Fx.AssertAndThrow("Argument reply cannot be null.");
}
ReliableMessagingVersion reliableMessagingVersion = this.settings.ReliableMessagingVersion;
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (close)
{
throw Fx.AssertAndThrow("Close does not exist in Feb2005.");
}
reply.Close();
}
else
{
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
if (this.closeRequestor.GetInfo() != null)
{
return;
}
try
{
WsrmMessageInfo info = WsrmMessageInfo.Get(this.settings.MessageVersion, reliableMessagingVersion, this.binder.Channel, this.binder.GetInnerSession(), reply);
this.session.ProcessInfo(info, null, true);
this.session.VerifyDuplexProtocolElements(info, null, true);
WsrmFault fault = close ? WsrmUtilities.ValidateCloseSequenceResponse(this.session, this.closeRequestor.MessageId, info, this.connection.Last) : WsrmUtilities.ValidateTerminateSequenceResponse(this.session, this.terminateRequestor.MessageId, info, this.connection.Last);
if (fault != null)
{
this.session.OnLocalFault(null, fault, null);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(fault.CreateException());
}
return;
}
finally
{
reply.Close();
}
}
throw Fx.AssertAndThrow("Reliable messaging version not supported.");
}
}
private void ProcessCloseOrTerminateReply(bool close, Message reply)
{
if (reply == null)
{
// In the close case, the requestor is configured to throw TimeoutException instead of returning null.
// In the terminate case, this value can be null, but the caller should not call this method.
throw Fx.AssertAndThrow("Argument reply cannot be null.");
}
ReliableRequestor requestor = close ? _closeRequestor : _terminateRequestor;
WsrmMessageInfo info = requestor.GetInfo();
// Some other thread has verified and cleaned up the reply, no more work to do.
if (info != null)
{
return;
}
try
{
info = WsrmMessageInfo.Get(Settings.MessageVersion, Settings.ReliableMessagingVersion,
_binder.Channel, _binder.GetInnerSession(), reply);
ReliableSession.ProcessInfo(info, null, true);
ReliableSession.VerifyDuplexProtocolElements(info, null, true);
WsrmFault fault = close
? WsrmUtilities.ValidateCloseSequenceResponse(_session, requestor.MessageId, info,
Connection.Last)
: WsrmUtilities.ValidateTerminateSequenceResponse(_session, requestor.MessageId, info,
Connection.Last);
if (fault != null)
{
ReliableSession.OnLocalFault(null, fault, null);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(fault.CreateException());
}
}
finally
{
reply.Close();
}
}
void ProcessCloseOrTerminateReply(bool close, Message reply)
{
if (reply == null)
{
// In the close case, the requestor is configured to throw TimeoutException instead of returning null.
// In the terminate case, this value can be null, but the caller should not call this method.
throw Fx.AssertAndThrow("Argument reply cannot be null.");
}
ReliableMessagingVersion reliableMessagingVersion = this.settings.ReliableMessagingVersion;
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (close)
{
throw Fx.AssertAndThrow("Close does not exist in Feb2005.");
}
reply.Close();
}
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
WsrmMessageInfo info = this.closeRequestor.GetInfo();
// Close - Final ack made it.
// Terminate - UnknownSequence.
// Either way, message has been verified and does not belong to this thread.
if (info != null)
{
return;
}
try
{
info = WsrmMessageInfo.Get(this.settings.MessageVersion, reliableMessagingVersion,
this.binder.Channel, this.binder.GetInnerSession(), reply);
this.session.ProcessInfo(info, null, true);
this.session.VerifyDuplexProtocolElements(info, null, true);
WsrmFault fault = close
? WsrmUtilities.ValidateCloseSequenceResponse(this.session, this.closeRequestor.MessageId, info,
this.connection.Last)
: WsrmUtilities.ValidateTerminateSequenceResponse(this.session, this.terminateRequestor.MessageId,
info, this.connection.Last);
if (fault != null)
{
this.session.OnLocalFault(null, fault, null);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(fault.CreateException());
}
}
finally
{
reply.Close();
}
}
else
{
throw Fx.AssertAndThrow("Reliable messaging version not supported.");
}
}
protected async Task ProcessMessageAsync(Message message)
{
bool closeMessage = true;
WsrmMessageInfo messageInfo = WsrmMessageInfo.Get(Settings.MessageVersion,
Settings.ReliableMessagingVersion, _binder.Channel, _binder.GetInnerSession(), message);
bool wsrm11 = Settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
try
{
if (!_session.ProcessInfo(messageInfo, null))
{
closeMessage = false;
return;
}
if (!ReliableSession.VerifySimplexProtocolElements(messageInfo, null))
{
closeMessage = false;
return;
}
bool final = false;
if (messageInfo.AcknowledgementInfo != null)
{
final = wsrm11 && messageInfo.AcknowledgementInfo.Final;
int bufferRemaining = -1;
if (Settings.FlowControlEnabled)
{
bufferRemaining = messageInfo.AcknowledgementInfo.BufferRemaining;
}
Connection.ProcessTransferred(messageInfo.AcknowledgementInfo.Ranges, bufferRemaining);
}
if (wsrm11)
{
WsrmFault fault = null;
if (messageInfo.TerminateSequenceResponseInfo != null)
{
fault = WsrmUtilities.ValidateTerminateSequenceResponse(_session,
_terminateRequestor.MessageId, messageInfo, Connection.Last);
if (fault == null)
{
fault = ProcessRequestorResponse(_terminateRequestor, WsrmFeb2005Strings.TerminateSequence, messageInfo);
}
}
else if (messageInfo.CloseSequenceResponseInfo != null)
{
fault = WsrmUtilities.ValidateCloseSequenceResponse(_session,
_closeRequestor.MessageId, messageInfo, Connection.Last);
if (fault == null)
{
fault = ProcessRequestorResponse(_closeRequestor, Wsrm11Strings.CloseSequence, messageInfo);
}
}
else if (messageInfo.TerminateSequenceInfo != null)
{
if (!WsrmUtilities.ValidateWsrmRequest(_session, messageInfo.TerminateSequenceInfo, _binder, null))
{
return;
}
WsrmAcknowledgmentInfo ackInfo = messageInfo.AcknowledgementInfo;
fault = WsrmUtilities.ValidateFinalAckExists(_session, ackInfo);
if ((fault == null) && !Connection.IsFinalAckConsistent(ackInfo.Ranges))
{
fault = new InvalidAcknowledgementFault(_session.OutputID, ackInfo.Ranges);
}
if (fault == null)
{
Message response = WsrmUtilities.CreateTerminateResponseMessage(
Settings.MessageVersion,
messageInfo.TerminateSequenceInfo.MessageId,
_session.OutputID);
try
{
await OnConnectionSendAsync(response, DefaultSendTimeout, false, true);
}
finally
{
response.Close();
}
_session.OnRemoteFault(new ProtocolException(SR.UnsupportedTerminateSequenceExceptionString));
return;
}
}
else if (final)
{
if (_closeRequestor == null)
{
string exceptionString = SR.UnsupportedCloseExceptionString;
string faultString = SR.SequenceTerminatedUnsupportedClose;
fault = SequenceTerminatedFault.CreateProtocolFault(_session.OutputID, faultString,
exceptionString);
}
else
{
fault = WsrmUtilities.ValidateFinalAck(_session, messageInfo, Connection.Last);
if (fault == null)
{
_closeRequestor.SetInfo(messageInfo);
}
}
}
else if (messageInfo.WsrmHeaderFault != null)
{
if (!(messageInfo.WsrmHeaderFault is UnknownSequenceFault))
{
throw Fx.AssertAndThrow("Fault must be UnknownSequence fault.");
}
if (_terminateRequestor == null)
{
throw Fx.AssertAndThrow("In wsrm11, if we start getting UnknownSequence, terminateRequestor cannot be null.");
}
_terminateRequestor.SetInfo(messageInfo);
}
if (fault != null)
{
_session.OnLocalFault(fault.CreateException(), fault, null);
return;
}
}
_session.OnRemoteActivity(Connection.Strategy.QuotaRemaining == 0);
}
finally
{
if (closeMessage)
{
messageInfo.Message.Close();
}
}
}
protected void ProcessMessage(Message message)
{
bool flag = true;
WsrmMessageInfo info = WsrmMessageInfo.Get(this.settings.MessageVersion, this.settings.ReliableMessagingVersion, this.binder.Channel, this.binder.GetInnerSession(), message);
bool flag2 = this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
try
{
if (!this.session.ProcessInfo(info, null))
{
flag = false;
return;
}
if (!this.ReliableSession.VerifySimplexProtocolElements(info, null))
{
flag = false;
return;
}
bool flag3 = false;
if (info.AcknowledgementInfo != null)
{
flag3 = flag2 && info.AcknowledgementInfo.Final;
int quotaRemaining = -1;
if (this.settings.FlowControlEnabled)
{
quotaRemaining = info.AcknowledgementInfo.BufferRemaining;
}
this.connection.ProcessTransferred(info.AcknowledgementInfo.Ranges, quotaRemaining);
}
if (!flag2)
{
goto Label_0300;
}
WsrmFault fault = null;
if (info.TerminateSequenceResponseInfo != null)
{
fault = WsrmUtilities.ValidateTerminateSequenceResponse(this.session, this.terminateRequestor.MessageId, info, this.connection.Last);
if (fault == null)
{
fault = this.ProcessRequestorResponse(this.terminateRequestor, "TerminateSequence", info);
}
}
else if (info.CloseSequenceResponseInfo != null)
{
fault = WsrmUtilities.ValidateCloseSequenceResponse(this.session, this.closeRequestor.MessageId, info, this.connection.Last);
if (fault == null)
{
fault = this.ProcessRequestorResponse(this.closeRequestor, "CloseSequence", info);
}
}
else
{
if (info.TerminateSequenceInfo != null)
{
if (WsrmUtilities.ValidateWsrmRequest(this.session, info.TerminateSequenceInfo, this.binder, null))
{
WsrmAcknowledgmentInfo acknowledgementInfo = info.AcknowledgementInfo;
fault = WsrmUtilities.ValidateFinalAckExists(this.session, acknowledgementInfo);
if ((fault == null) && !this.connection.IsFinalAckConsistent(acknowledgementInfo.Ranges))
{
fault = new InvalidAcknowledgementFault(this.session.OutputID, acknowledgementInfo.Ranges);
}
if (fault != null)
{
goto Label_02E5;
}
Message message2 = WsrmUtilities.CreateTerminateResponseMessage(this.settings.MessageVersion, info.TerminateSequenceInfo.MessageId, this.session.OutputID);
try
{
this.OnConnectionSend(message2, base.DefaultSendTimeout, false, true);
}
finally
{
message2.Close();
}
this.session.OnRemoteFault(new ProtocolException(System.ServiceModel.SR.GetString("UnsupportedTerminateSequenceExceptionString")));
}
return;
}
if (flag3)
{
if (this.closeRequestor == null)
{
string exceptionMessage = System.ServiceModel.SR.GetString("UnsupportedCloseExceptionString");
string faultReason = System.ServiceModel.SR.GetString("SequenceTerminatedUnsupportedClose");
fault = SequenceTerminatedFault.CreateProtocolFault(this.session.OutputID, faultReason, exceptionMessage);
}
else
{
fault = WsrmUtilities.ValidateFinalAck(this.session, info, this.connection.Last);
if (fault == null)
{
this.closeRequestor.SetInfo(info);
}
}
}
else if (info.WsrmHeaderFault != null)
{
if (!(info.WsrmHeaderFault is UnknownSequenceFault))
{
throw Fx.AssertAndThrow("Fault must be UnknownSequence fault.");
}
if (this.terminateRequestor == null)
{
throw Fx.AssertAndThrow("In wsrm11, if we start getting UnknownSequence, terminateRequestor cannot be null.");
}
this.terminateRequestor.SetInfo(info);
}
}
Label_02E5:
if (fault != null)
{
this.session.OnLocalFault(fault.CreateException(), fault, null);
return;
}
Label_0300:
this.session.OnRemoteActivity(this.connection.Strategy.QuotaRemaining == 0);
}
finally
{
if (flag)
{
info.Message.Close();
}
}
}
