protected override void ProcessMessage(WsrmMessageInfo info)
{
if (base.ReliableSession.ProcessInfo(info, null) && base.ReliableSession.VerifyDuplexProtocolElements(info, null))
{
if (info.CreateSequenceInfo == null)
{
base.ProcessDuplexMessage(info);
}
else
{
EndpointAddress address;
if (WsrmUtilities.ValidateCreateSequence <IDuplexSessionChannel>(info, this.listener, base.Binder.Channel, out address))
{
Message response = WsrmUtilities.CreateCreateSequenceResponse(base.Settings.MessageVersion, base.Settings.ReliableMessagingVersion, true, info.CreateSequenceInfo, base.Settings.Ordered, base.ReliableSession.InputID, address);
using (info.Message)
{
using (response)
{
if (((IServerReliableChannelBinder)base.Binder).AddressResponse(info.Message, response))
{
base.Binder.Send(response, base.DefaultSendTimeout);
}
}
return;
}
}
base.ReliableSession.OnLocalFault(info.FaultException, info.FaultReply, null);
}
}
}
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();
}
}
}
public static WsrmFault ValidateFinalAck(ChannelReliableSession session, WsrmMessageInfo info, long last)
{
WsrmAcknowledgmentInfo acknowledgementInfo = info.AcknowledgementInfo;
WsrmFault fault = ValidateFinalAckExists(session, acknowledgementInfo);
if (fault != null)
{
return(fault);
}
SequenceRangeCollection ranges = acknowledgementInfo.Ranges;
if (last == 0L)
{
if (ranges.Count == 0)
{
return(null);
}
}
else if (ranges.Count == 1)
{
SequenceRange range = ranges[0];
if (range.Lower == 1L)
{
SequenceRange range2 = ranges[0];
if (range2.Upper == last)
{
return(null);
}
}
}
return(new InvalidAcknowledgementFault(session.OutputID, acknowledgementInfo.Ranges));
}
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);
}
protected override bool HandleReceiveComplete(IAsyncResult result)
{
RequestContext context;
if (!base.Binder.EndTryReceive(result, out context))
{
return(true);
}
if (context == null)
{
bool flag2 = false;
lock (base.ThisLock)
{
flag2 = base.Connection.Terminate();
}
if (!flag2 && (base.Binder.State == CommunicationState.Opened))
{
Exception e = new CommunicationException(System.ServiceModel.SR.GetString("EarlySecurityClose"));
base.ReliableSession.OnLocalFault(e, (Message)null, null);
}
return(false);
}
WsrmMessageInfo info = WsrmMessageInfo.Get(base.Listener.MessageVersion, base.Listener.ReliableMessagingVersion, base.Binder.Channel, base.Binder.GetInnerSession(), context.RequestMessage);
base.StartReceiving(false);
this.ProcessRequest(context, info);
return(false);
}
protected override void ProcessMessage(WsrmMessageInfo info)
{
if (base.ReliableSession.ProcessInfo(info, null) && base.ReliableSession.VerifyDuplexProtocolElements(info, null))
{
base.ProcessDuplexMessage(info);
}
}
protected override WsrmFault VerifySimplexProtocolElements(WsrmMessageInfo info)
{
if ((info.AcknowledgementInfo != null) && (info.AcknowledgementInfo.SequenceID != base.OutputID))
{
return(new UnknownSequenceFault(info.AcknowledgementInfo.SequenceID));
}
if (info.AckRequestedInfo != null)
{
return(SequenceTerminatedFault.CreateProtocolFault(base.OutputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedAckRequested"), System.ServiceModel.SR.GetString("UnexpectedAckRequested")));
}
if (info.CreateSequenceInfo != null)
{
return(SequenceTerminatedFault.CreateProtocolFault(base.OutputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedCS"), System.ServiceModel.SR.GetString("UnexpectedCS")));
}
if (info.SequencedMessageInfo != null)
{
return(new UnknownSequenceFault(info.SequencedMessageInfo.SequenceID));
}
if (info.TerminateSequenceInfo != null)
{
if (base.Settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
return(SequenceTerminatedFault.CreateProtocolFault(base.OutputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedTerminateSequence"), System.ServiceModel.SR.GetString("UnexpectedTerminateSequence")));
}
if (info.TerminateSequenceInfo.Identifier == base.OutputID)
{
return(null);
}
return(new UnknownSequenceFault(info.TerminateSequenceInfo.Identifier));
}
if (info.TerminateSequenceResponseInfo != null)
{
WsrmUtilities.AssertWsrm11(base.Settings.ReliableMessagingVersion);
if (info.TerminateSequenceResponseInfo.Identifier == base.OutputID)
{
return(null);
}
return(new UnknownSequenceFault(info.TerminateSequenceResponseInfo.Identifier));
}
if (info.CloseSequenceInfo != null)
{
WsrmUtilities.AssertWsrm11(base.Settings.ReliableMessagingVersion);
if (info.CloseSequenceInfo.Identifier == base.OutputID)
{
return(SequenceTerminatedFault.CreateProtocolFault(base.OutputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnsupportedClose"), System.ServiceModel.SR.GetString("UnsupportedCloseExceptionString")));
}
return(new UnknownSequenceFault(info.CloseSequenceInfo.Identifier));
}
if (info.CloseSequenceResponseInfo == null)
{
return(null);
}
WsrmUtilities.AssertWsrm11(base.Settings.ReliableMessagingVersion);
if (info.CloseSequenceResponseInfo.Identifier == base.OutputID)
{
return(null);
}
return(new UnknownSequenceFault(info.CloseSequenceResponseInfo.Identifier));
}
private void EndProcessItem(TItem item, WsrmMessageInfo info, TReliableChannel channel, bool dispatch)
{
this.ProcessSequencedItem(channel, item, info);
if (dispatch)
{
base.Dispatch();
}
}
private bool BeginProcessItem(TItem item, WsrmMessageInfo info, TInnerChannel channel, out TReliableChannel reliableChannel, out bool newChannel, out bool dispatch)
{
Message faultReply;
dispatch = false;
reliableChannel = default(TReliableChannel);
newChannel = false;
if (info.FaultReply != null)
{
faultReply = info.FaultReply;
}
else if (info.CreateSequenceInfo == null)
{
UniqueId id;
reliableChannel = base.GetChannel(info, out id);
if (((TReliableChannel)reliableChannel) != null)
{
return(true);
}
if (id == null)
{
this.DisposeItem(item);
return(true);
}
faultReply = new UnknownSequenceFault(id).CreateMessage(base.MessageVersion, base.ReliableMessagingVersion);
}
else
{
reliableChannel = base.ProcessCreateSequence(info, channel, out dispatch, out newChannel);
if (((TReliableChannel)reliableChannel) != null)
{
return(true);
}
faultReply = info.FaultReply;
}
try
{
this.SendReply(faultReply, channel, item);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
if (!base.HandleException(exception, channel))
{
channel.Abort();
return(false);
}
}
finally
{
faultReply.Close();
this.DisposeItem(item);
}
return(true);
}
public override void SetInfo(WsrmMessageInfo info)
{
lock (this.ThisLock)
{
if (!this.replied && (this.replyInfo == null))
{
this.replyInfo = info;
}
}
}
public override void SetInfo(WsrmMessageInfo info)
{
lock (this.ThisLock)
{
if (!this.replied && (this.replyInfo == null))
{
this.replyInfo = info;
}
}
}
public override void SetInfo(WsrmMessageInfo info)
{
lock (this.ThisLock)
{
if (this.replied || (this.replyInfo != null))
{
return;
}
this.replyInfo = info;
}
this.replyHandle.Set();
}
protected override WsrmFault VerifySimplexProtocolElements(WsrmMessageInfo info)
{
if (info.AcknowledgementInfo != null)
{
return SequenceTerminatedFault.CreateProtocolFault(base.InputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedAcknowledgement"), System.ServiceModel.SR.GetString("UnexpectedAcknowledgement"));
}
if ((info.AckRequestedInfo != null) && (info.AckRequestedInfo.SequenceID != base.InputID))
{
return new UnknownSequenceFault(info.AckRequestedInfo.SequenceID);
}
if (info.CreateSequenceResponseInfo != null)
{
return SequenceTerminatedFault.CreateProtocolFault(base.InputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedCSR"), System.ServiceModel.SR.GetString("UnexpectedCSR"));
}
if ((info.SequencedMessageInfo != null) && (info.SequencedMessageInfo.SequenceID != base.InputID))
{
return new UnknownSequenceFault(info.SequencedMessageInfo.SequenceID);
}
if ((info.TerminateSequenceInfo != null) && (info.TerminateSequenceInfo.Identifier != base.InputID))
{
return new UnknownSequenceFault(info.TerminateSequenceInfo.Identifier);
}
if (info.TerminateSequenceResponseInfo != null)
{
WsrmUtilities.AssertWsrm11(base.Settings.ReliableMessagingVersion);
if (info.TerminateSequenceResponseInfo.Identifier == base.InputID)
{
return SequenceTerminatedFault.CreateProtocolFault(base.InputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedTerminateSequenceResponse"), System.ServiceModel.SR.GetString("UnexpectedTerminateSequenceResponse"));
}
return new UnknownSequenceFault(info.TerminateSequenceResponseInfo.Identifier);
}
if (info.CloseSequenceInfo != null)
{
WsrmUtilities.AssertWsrm11(base.Settings.ReliableMessagingVersion);
if (info.CloseSequenceInfo.Identifier == base.InputID)
{
return null;
}
return new UnknownSequenceFault(info.CloseSequenceInfo.Identifier);
}
if (info.CloseSequenceResponseInfo == null)
{
return null;
}
WsrmUtilities.AssertWsrm11(base.Settings.ReliableMessagingVersion);
if (info.CloseSequenceResponseInfo.Identifier == base.InputID)
{
return SequenceTerminatedFault.CreateProtocolFault(base.InputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedCloseSequenceResponse"), System.ServiceModel.SR.GetString("UnexpectedCloseSequenceResponse"));
}
return new UnknownSequenceFault(info.CloseSequenceResponseInfo.Identifier);
}
private bool HandleReceiveComplete(TItem item, TInnerChannel channel)
{
Message message = null;
TReliableChannel local;
bool flag;
bool flag2;
try
{
message = this.GetMessage(item);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
if (!base.HandleException(exception, this))
{
throw;
}
item.Dispose();
return(true);
}
WsrmMessageInfo info = WsrmMessageInfo.Get(base.MessageVersion, base.ReliableMessagingVersion, channel, null, message);
if (info.ParsingException != null)
{
this.DisposeItem(item);
return(true);
}
if (!this.BeginProcessItem(item, info, channel, out local, out flag, out flag2))
{
return(false);
}
if (local == null)
{
this.DisposeItem(item);
return(true);
}
if (flag2 || !flag)
{
this.StartReceiving(channel, false);
this.EndProcessItem(item, info, local, flag2);
return(false);
}
this.EndProcessItem(item, info, local, flag2);
return(true);
}
public void ProcessDemuxedMessage(WsrmMessageInfo info)
{
try
{
this.ProcessMessage(info);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
base.ReliableSession.OnUnknownException(exception);
}
}
public void ProcessDemuxedRequest(RequestContext context, WsrmMessageInfo info)
{
try
{
this.ProcessRequest(context, info);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
base.ReliableSession.OnUnknownException(exception);
}
}
public void ProcessDemuxedRequest(RequestContext context, WsrmMessageInfo info)
{
try
{
this.ProcessRequest(context, info);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
base.ReliableSession.OnUnknownException(exception);
}
}
protected override WsrmFault VerifyDuplexProtocolElements(WsrmMessageInfo info)
{
WsrmFault fault = base.VerifyDuplexProtocolElements(info);
if (fault != null)
{
return fault;
}
if ((info.CreateSequenceInfo != null) && (info.CreateSequenceInfo.OfferIdentifier != base.OutputID))
{
return SequenceTerminatedFault.CreateProtocolFault(base.OutputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedCSOfferId"), System.ServiceModel.SR.GetString("UnexpectedCSOfferId"));
}
if (info.CreateSequenceResponseInfo != null)
{
return SequenceTerminatedFault.CreateProtocolFault(base.OutputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedCSR"), System.ServiceModel.SR.GetString("UnexpectedCSR"));
}
return null;
}
public bool VerifyDuplexProtocolElements(WsrmMessageInfo info, RequestContext context, bool throwException)
{
WsrmFault fault = this.VerifyDuplexProtocolElements(info);
if (fault == null)
{
return(true);
}
if (throwException)
{
Exception exception = fault.CreateException();
this.OnLocalFault(null, fault, context);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception);
}
this.OnLocalFault(fault.CreateException(), fault, context);
return(false);
}
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.");
}
}
protected TReliableChannel GetChannel(WsrmMessageInfo info, out UniqueId id)
{
id = WsrmUtilities.GetInputId(info);
lock (base.ThisLock)
{
TReliableChannel local = default(TReliableChannel);
if (((id == null) || !this.channelsByInput.TryGetValue(id, out local)) && this.Duplex)
{
UniqueId outputId = WsrmUtilities.GetOutputId(base.ReliableMessagingVersion, info);
if (outputId != null)
{
id = outputId;
this.channelsByOutput.TryGetValue(id, out local);
}
}
return(local);
}
}
protected override WsrmFault VerifyDuplexProtocolElements(WsrmMessageInfo info)
{
WsrmFault fault = base.VerifyDuplexProtocolElements(info);
if (fault != null)
{
return(fault);
}
if ((info.CreateSequenceInfo != null) && (info.CreateSequenceInfo.OfferIdentifier != base.OutputID))
{
return(SequenceTerminatedFault.CreateProtocolFault(base.OutputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedCSOfferId"), System.ServiceModel.SR.GetString("UnexpectedCSOfferId")));
}
if (info.CreateSequenceResponseInfo != null)
{
return(SequenceTerminatedFault.CreateProtocolFault(base.OutputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedCSR"), System.ServiceModel.SR.GetString("UnexpectedCSR")));
}
return(null);
}
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();
}
}
private Message GetReply(Message reply, bool last)
{
lock (this.ThisLock)
{
if ((reply != null) && (this.replyInfo != null))
{
this.replyInfo = null;
}
else if ((reply == null) && (this.replyInfo != null))
{
reply = this.replyInfo.Message;
}
if ((reply == null) && !last)
{
return(reply);
}
this.replied = true;
}
return(reply);
}
private Message GetReply(Message reply, bool last)
{
lock (this.ThisLock)
{
if ((reply != null) && (this.replyInfo != null))
{
this.replyInfo = null;
}
else if ((reply == null) && (this.replyInfo != null))
{
reply = this.replyInfo.Message;
}
if ((reply == null) && !last)
{
return reply;
}
this.replied = true;
}
return reply;
}
protected override WsrmFault VerifyDuplexProtocolElements(WsrmMessageInfo info)
{
WsrmFault fault = base.VerifyDuplexProtocolElements(info);
if (fault != null)
{
return(fault);
}
else if (info.CreateSequenceInfo != null && info.CreateSequenceInfo.OfferIdentifier != this.OutputID)
{
return(SequenceTerminatedFault.CreateProtocolFault(this.OutputID, SR.GetString(SR.SequenceTerminatedUnexpectedCSOfferId), SR.GetString(SR.UnexpectedCSOfferId)));
}
else if (info.CreateSequenceResponseInfo != null)
{
return(SequenceTerminatedFault.CreateProtocolFault(this.OutputID, SR.GetString(SR.SequenceTerminatedUnexpectedCSR), SR.GetString(SR.UnexpectedCSR)));
}
else
{
return(null);
}
}
public static void ValidateCreateSequenceHeaders(MessageVersion messageVersion, ISecureConversationSession securitySession, WsrmMessageInfo info)
{
string reason = null;
if (info.UsesSequenceSSLInfo != null)
{
reason = System.ServiceModel.SR.GetString("CSRefusedSSLNotSupported");
}
else if ((info.UsesSequenceSTRInfo != null) && (securitySession == null))
{
reason = System.ServiceModel.SR.GetString("CSRefusedSTRNoWSSecurity");
}
else if ((info.UsesSequenceSTRInfo == null) && (securitySession != null))
{
reason = System.ServiceModel.SR.GetString("CSRefusedNoSTRWSSecurity");
}
if (reason != null)
{
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, ReliableMessagingVersion.WSReliableMessaging11, reason);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
}
}
protected TReliableChannel ProcessCreateSequence(WsrmMessageInfo info, TInnerChannel channel, out bool dispatch, out bool newChannel)
{
EndpointAddress address;
dispatch = false;
newChannel = false;
CreateSequenceInfo createSequenceInfo = info.CreateSequenceInfo;
if (!WsrmUtilities.ValidateCreateSequence <TChannel>(info, this, channel, out address))
{
return(default(TReliableChannel));
}
lock (base.ThisLock)
{
TReliableChannel local = default(TReliableChannel);
if (((createSequenceInfo.OfferIdentifier == null) || !this.Duplex) || !this.channelsByOutput.TryGetValue(createSequenceInfo.OfferIdentifier, out local))
{
if (!base.IsAccepting)
{
info.FaultReply = WsrmUtilities.CreateEndpointNotFoundFault(base.MessageVersion, System.ServiceModel.SR.GetString("RMEndpointNotFoundReason", new object[] { this.Uri }));
return(default(TReliableChannel));
}
if (this.inputQueueChannelAcceptor.PendingCount >= base.MaxPendingChannels)
{
info.FaultReply = WsrmUtilities.CreateCSRefusedServerTooBusyFault(base.MessageVersion, base.ReliableMessagingVersion, System.ServiceModel.SR.GetString("ServerTooBusy", new object[] { this.Uri }));
return(default(TReliableChannel));
}
UniqueId id = WsrmUtilities.NextSequenceId();
local = this.CreateChannel(id, createSequenceInfo, this.CreateBinder(channel, address, createSequenceInfo.ReplyTo));
this.channelsByInput.Add(id, local);
if (this.Duplex)
{
this.channelsByOutput.Add(createSequenceInfo.OfferIdentifier, local);
}
dispatch = this.EnqueueWithoutDispatch((TChannel)local);
newChannel = true;
}
return(local);
}
}
public static void ValidateCreateSequenceHeaders(MessageVersion messageVersion, ISecureConversationSession securitySession, WsrmMessageInfo info)
{
string reason = null;
if (info.UsesSequenceSSLInfo != null)
{
reason = System.ServiceModel.SR.GetString("CSRefusedSSLNotSupported");
}
else if ((info.UsesSequenceSTRInfo != null) && (securitySession == null))
{
reason = System.ServiceModel.SR.GetString("CSRefusedSTRNoWSSecurity");
}
else if ((info.UsesSequenceSTRInfo == null) && (securitySession != null))
{
reason = System.ServiceModel.SR.GetString("CSRefusedNoSTRWSSecurity");
}
if (reason != null)
{
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, ReliableMessagingVersion.WSReliableMessaging11, reason);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
}
}
internal static UniqueId GetInputId(WsrmMessageInfo info)
{
if (info.TerminateSequenceInfo != null)
{
return(info.TerminateSequenceInfo.Identifier);
}
if (info.SequencedMessageInfo != null)
{
return(info.SequencedMessageInfo.SequenceID);
}
if (info.AckRequestedInfo != null)
{
return(info.AckRequestedInfo.SequenceID);
}
if ((info.WsrmHeaderFault != null) && info.WsrmHeaderFault.FaultsInput)
{
return(info.WsrmHeaderFault.SequenceID);
}
if (info.CloseSequenceInfo != null)
{
return(info.CloseSequenceInfo.Identifier);
}
return(null);
}
public bool VerifySimplexProtocolElements(WsrmMessageInfo info, RequestContext context, bool throwException)
{
WsrmFault fault = this.VerifySimplexProtocolElements(info);
if (fault == null)
{
return true;
}
info.Message.Close();
if (throwException)
{
Exception e = fault.CreateException();
this.OnLocalFault(null, fault, context);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e);
}
else
{
this.OnLocalFault(fault.CreateException(), fault, context);
return false;
}
}
public bool ProcessInfo(WsrmMessageInfo info, RequestContext context, bool throwException)
{
Exception e;
if (info.ParsingException != null)
{
WsrmFault fault;
if (this.SequenceID != null)
{
string reason = SR.GetString(SR.CouldNotParseWithAction, info.Action);
fault = SequenceTerminatedFault.CreateProtocolFault(this.SequenceID, reason, null);
}
else
{
fault = null;
}
e = new ProtocolException(SR.GetString(SR.MessageExceptionOccurred), info.ParsingException);
this.OnLocalFault(throwException ? null : e, fault, context);
}
else if (info.FaultReply != null)
{
e = info.FaultException;
this.OnLocalFault(throwException ? null : e, info.FaultReply, context);
}
else if ((info.WsrmHeaderFault != null) && (info.WsrmHeaderFault.SequenceID != this.InputID)
&& (info.WsrmHeaderFault.SequenceID != this.OutputID))
{
e = new ProtocolException(SR.GetString(SR.WrongIdentifierFault, FaultException.GetSafeReasonText(info.WsrmHeaderFault.Reason)));
this.OnLocalFault(throwException ? null : e, (Message)null, context);
}
else if (info.FaultInfo != null)
{
if (this.isSessionClosed)
{
UnknownSequenceFault unknownSequenceFault = info.FaultInfo as UnknownSequenceFault;
if (unknownSequenceFault != null)
{
UniqueId sequenceId = unknownSequenceFault.SequenceID;
if (((this.OutputID != null) && (this.OutputID == sequenceId))
|| ((this.InputID != null) && (this.InputID == sequenceId)))
{
if (this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
info.Message.Close();
return false;
}
else if (this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
return true;
}
else
{
throw Fx.AssertAndThrow("Unknown version.");
}
}
}
}
e = info.FaultException;
if (context != null)
context.Close();
this.OnRemoteFault(throwException ? null : e);
}
else
{
return true;
}
info.Message.Close();
if (throwException)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e);
else
return false;
}
public bool VerifySimplexProtocolElements(WsrmMessageInfo info, RequestContext context)
{
return this.VerifySimplexProtocolElements(info, context, false);
}
protected virtual WsrmFault VerifyDuplexProtocolElements(WsrmMessageInfo info)
{
if ((info.AcknowledgementInfo != null) && (info.AcknowledgementInfo.SequenceID != this.OutputID))
{
return new UnknownSequenceFault(info.AcknowledgementInfo.SequenceID);
}
if ((info.AckRequestedInfo != null) && (info.AckRequestedInfo.SequenceID != this.InputID))
{
return new UnknownSequenceFault(info.AckRequestedInfo.SequenceID);
}
if ((info.SequencedMessageInfo != null) && (info.SequencedMessageInfo.SequenceID != this.InputID))
{
return new UnknownSequenceFault(info.SequencedMessageInfo.SequenceID);
}
if ((info.TerminateSequenceInfo != null) && (info.TerminateSequenceInfo.Identifier != this.InputID))
{
if (this.Settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
return SequenceTerminatedFault.CreateProtocolFault(this.OutputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedTerminateSequence"), System.ServiceModel.SR.GetString("UnexpectedTerminateSequence"));
}
if (info.TerminateSequenceInfo.Identifier == this.OutputID)
{
return null;
}
return new UnknownSequenceFault(info.TerminateSequenceInfo.Identifier);
}
if (info.TerminateSequenceResponseInfo != null)
{
WsrmUtilities.AssertWsrm11(this.settings.ReliableMessagingVersion);
if (info.TerminateSequenceResponseInfo.Identifier == this.OutputID)
{
return null;
}
return new UnknownSequenceFault(info.TerminateSequenceResponseInfo.Identifier);
}
if (info.CloseSequenceInfo != null)
{
WsrmUtilities.AssertWsrm11(this.settings.ReliableMessagingVersion);
if (info.CloseSequenceInfo.Identifier == this.InputID)
{
return null;
}
if (info.CloseSequenceInfo.Identifier == this.OutputID)
{
return SequenceTerminatedFault.CreateProtocolFault(this.OutputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnsupportedClose"), System.ServiceModel.SR.GetString("UnsupportedCloseExceptionString"));
}
return new UnknownSequenceFault(info.CloseSequenceInfo.Identifier);
}
if (info.CloseSequenceResponseInfo == null)
{
return null;
}
WsrmUtilities.AssertWsrm11(this.settings.ReliableMessagingVersion);
if (info.CloseSequenceResponseInfo.Identifier == this.OutputID)
{
return null;
}
if (info.CloseSequenceResponseInfo.Identifier == this.InputID)
{
return SequenceTerminatedFault.CreateProtocolFault(this.InputID, System.ServiceModel.SR.GetString("SequenceTerminatedUnexpectedCloseSequenceResponse"), System.ServiceModel.SR.GetString("UnexpectedCloseSequenceResponse"));
}
return new UnknownSequenceFault(info.CloseSequenceResponseInfo.Identifier);
}
// returns true if the info does not fault the session.
public bool ProcessInfo(WsrmMessageInfo info, RequestContext context)
{
return this.ProcessInfo(info, context, false);
}
protected override WsrmFault VerifySimplexProtocolElements(WsrmMessageInfo info)
{
if (info.AcknowledgementInfo != null && info.AcknowledgementInfo.SequenceID != this.OutputID)
return new UnknownSequenceFault(info.AcknowledgementInfo.SequenceID);
else if (info.AckRequestedInfo != null)
return SequenceTerminatedFault.CreateProtocolFault(this.OutputID, SR.GetString(SR.SequenceTerminatedUnexpectedAckRequested), SR.GetString(SR.UnexpectedAckRequested));
else if (info.CreateSequenceInfo != null)
return SequenceTerminatedFault.CreateProtocolFault(this.OutputID, SR.GetString(SR.SequenceTerminatedUnexpectedCS), SR.GetString(SR.UnexpectedCS));
else if (info.SequencedMessageInfo != null)
return new UnknownSequenceFault(info.SequencedMessageInfo.SequenceID);
else if (info.TerminateSequenceInfo != null)
{
if (this.Settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
return SequenceTerminatedFault.CreateProtocolFault(this.OutputID, SR.GetString(SR.SequenceTerminatedUnexpectedTerminateSequence), SR.GetString(SR.UnexpectedTerminateSequence));
else if (info.TerminateSequenceInfo.Identifier == this.OutputID)
return null;
else
return new UnknownSequenceFault(info.TerminateSequenceInfo.Identifier);
}
else if (info.TerminateSequenceResponseInfo != null)
{
WsrmUtilities.AssertWsrm11(this.Settings.ReliableMessagingVersion);
if (info.TerminateSequenceResponseInfo.Identifier == this.OutputID)
return null;
else
return new UnknownSequenceFault(info.TerminateSequenceResponseInfo.Identifier);
}
else if (info.CloseSequenceInfo != null)
{
WsrmUtilities.AssertWsrm11(this.Settings.ReliableMessagingVersion);
if (info.CloseSequenceInfo.Identifier == this.OutputID)
return SequenceTerminatedFault.CreateProtocolFault(this.OutputID, SR.GetString(SR.SequenceTerminatedUnsupportedClose), SR.GetString(SR.UnsupportedCloseExceptionString));
else
return new UnknownSequenceFault(info.CloseSequenceInfo.Identifier);
}
else if (info.CloseSequenceResponseInfo != null)
{
WsrmUtilities.AssertWsrm11(this.Settings.ReliableMessagingVersion);
if (info.CloseSequenceResponseInfo.Identifier == this.OutputID)
return null;
else
return new UnknownSequenceFault(info.CloseSequenceResponseInfo.Identifier);
}
else
return null;
}
void ProcessReply(Message reply, IReliableRequest request, Int64 requestSequenceNumber)
{
WsrmMessageInfo messageInfo = WsrmMessageInfo.Get(this.settings.MessageVersion,
this.settings.ReliableMessagingVersion, this.binder.Channel, this.binder.GetInnerSession(), reply);
if (!this.session.ProcessInfo(messageInfo, null))
{
return;
}
if (!this.session.VerifyDuplexProtocolElements(messageInfo, null))
{
return;
}
bool wsrm11 = this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
if (messageInfo.WsrmHeaderFault != null)
{
// Close message now, going to stop processing in all cases.
messageInfo.Message.Close();
if (!(messageInfo.WsrmHeaderFault is UnknownSequenceFault))
{
throw Fx.AssertAndThrow("Fault must be UnknownSequence fault.");
}
if (this.terminateRequestor == null)
{
throw Fx.AssertAndThrow("If we start getting UnknownSequence, terminateRequestor cannot be null.");
}
this.terminateRequestor.SetInfo(messageInfo);
return;
}
if (messageInfo.AcknowledgementInfo == null)
{
WsrmFault fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
SR.GetString(SR.SequenceTerminatedReplyMissingAcknowledgement),
SR.GetString(SR.ReplyMissingAcknowledgement));
messageInfo.Message.Close();
this.session.OnLocalFault(fault.CreateException(), fault, null);
return;
}
if (wsrm11 && (messageInfo.TerminateSequenceInfo != null))
{
UniqueId faultId = (messageInfo.TerminateSequenceInfo.Identifier == this.session.OutputID)
? this.session.InputID
: this.session.OutputID;
WsrmFault fault = SequenceTerminatedFault.CreateProtocolFault(faultId,
SR.GetString(SR.SequenceTerminatedUnsupportedTerminateSequence),
SR.GetString(SR.UnsupportedTerminateSequenceExceptionString));
messageInfo.Message.Close();
this.session.OnLocalFault(fault.CreateException(), fault, null);
return;
}
else if (wsrm11 && messageInfo.AcknowledgementInfo.Final)
{
// Close message now, going to stop processing in all cases.
messageInfo.Message.Close();
if (this.closeRequestor == null)
{
// Remote endpoint signaled Close, this is not allowed so we fault.
string exceptionString = SR.GetString(SR.UnsupportedCloseExceptionString);
string faultString = SR.GetString(SR.SequenceTerminatedUnsupportedClose);
WsrmFault fault = SequenceTerminatedFault.CreateProtocolFault(this.session.OutputID, faultString,
exceptionString);
this.session.OnLocalFault(fault.CreateException(), fault, null);
}
else
{
WsrmFault fault = WsrmUtilities.ValidateFinalAck(this.session, messageInfo, this.connection.Last);
if (fault == null)
{
// Received valid final ack after sending Close, inform the close thread.
this.closeRequestor.SetInfo(messageInfo);
}
else
{
// Received invalid final ack after sending Close, fault.
this.session.OnLocalFault(fault.CreateException(), fault, null);
}
}
return;
}
int bufferRemaining = -1;
if (this.settings.FlowControlEnabled)
{
bufferRemaining = messageInfo.AcknowledgementInfo.BufferRemaining;
}
// We accept no more than MaxSequenceRanges ranges to limit the serialized ack size and
// the amount of memory taken up by the ack ranges. Since request reply uses the presence of
// a reply as an acknowledgement we cannot call ProcessTransferred (which stops retrying the
// request) if we intend to drop the message. This means the limit is not strict since we do
// not check for the limit and merge the ranges atomically. The limit + the number of
// concurrent threads is a sufficient mitigation.
if ((messageInfo.SequencedMessageInfo != null) &&
!ReliableInputConnection.CanMerge(messageInfo.SequencedMessageInfo.SequenceNumber, this.ranges))
{
messageInfo.Message.Close();
return;
}
bool exitGuard = this.replyAckConsistencyGuard != null?this.replyAckConsistencyGuard.Enter() : false;
try
{
this.connection.ProcessTransferred(requestSequenceNumber,
messageInfo.AcknowledgementInfo.Ranges, bufferRemaining);
this.session.OnRemoteActivity(this.connection.Strategy.QuotaRemaining == 0);
if (messageInfo.SequencedMessageInfo != null)
{
lock (this.ThisLock)
{
this.ranges = this.ranges.MergeWith(messageInfo.SequencedMessageInfo.SequenceNumber);
}
}
}
finally
{
if (exitGuard)
{
this.replyAckConsistencyGuard.Exit();
}
}
if (request != null)
{
if (WsrmUtilities.IsWsrmAction(this.settings.ReliableMessagingVersion, messageInfo.Action))
{
messageInfo.Message.Close();
request.Set(null);
}
else
{
request.Set(messageInfo.Message);
}
}
// The termination mechanism in the TerminateSequence fails with RequestReply.
// Since the ack ranges are updated after ProcessTransferred is called and
// ProcessTransferred potentially signals the Termination process, this channel
// winds up sending a message with the ack for last message missing.
// Thus we send the termination after we update the ranges.
if ((this.shutdownHandle != null) && this.connection.CheckForTermination())
{
this.shutdownHandle.Set();
}
if (request != null)
{
request.Complete();
}
}
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(SR.GetString(SR.NoActionNoSequenceHeaderReason), messageVersion.Addressing.Namespace, AddressingStrings.Action, false));
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
CreateWsrmRequiredException(messageVersion));
}
}
if (messageInfo.sequencedMessageInfo == null && message.IsFault)
{
messageInfo.faultInfo = MessageFault.CreateFault(message, TransportDefaults.MaxRMFaultSize);
WsrmHeaderFault wsrmFault;
if (soap11)
{
if (WsrmHeaderFault.TryCreateFault11(reliableMessagingVersion, message, messageInfo.faultInfo, sequenceFaultIndex, out wsrmFault))
{
messageInfo.faultInfo = wsrmFault;
messageInfo.faultException = WsrmHeaderFault.CreateException(wsrmFault);
}
}
else
{
if (WsrmHeaderFault.TryCreateFault12(reliableMessagingVersion, message, messageInfo.faultInfo, out wsrmFault))
{
messageInfo.faultInfo = 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.faultInfo, out messageInfo.faultException))
{
messageInfo.faultException = new ProtocolException(SR.GetString(SR.UnrecognizedFaultReceived, messageInfo.faultInfo.Code.Namespace, messageInfo.faultInfo.Code.Name, System.ServiceModel.FaultException.GetSafeReasonText(messageInfo.faultInfo)));
}
}
foundAction = true;
}
if (!foundHeader && !foundAction)
{
if (wsrmFeb2005)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ActionNotSupportedException(SR.GetString(SR.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(SR.GetString(SR.MessageExceptionOccurred), exception);
}
else
{
messageInfo.parsingException = new ProtocolException(SR.GetString(SR.MessageExceptionOccurred), exception);
}
}
catch (XmlException exception)
{
if (DiagnosticUtility.ShouldTraceInformation)
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);
messageInfo.parsingException = new ProtocolException(SR.GetString(SR.MessageExceptionOccurred), exception);
}
return messageInfo;
}
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 override void SetInfo(WsrmMessageInfo info)
{
throw Fx.AssertAndThrow("Not Supported.");
}
public bool ProcessInfo(WsrmMessageInfo info, RequestContext context, bool throwException)
{
Exception faultException;
if (info.ParsingException != null)
{
WsrmFault fault;
if (this.SequenceID != null)
{
string faultReason = System.ServiceModel.SR.GetString("CouldNotParseWithAction", new object[] { info.Action });
fault = SequenceTerminatedFault.CreateProtocolFault(this.SequenceID, faultReason, null);
}
else
{
fault = null;
}
faultException = new ProtocolException(System.ServiceModel.SR.GetString("MessageExceptionOccurred"), info.ParsingException);
this.OnLocalFault(throwException ? null : faultException, fault, context);
}
else if (info.FaultReply != null)
{
faultException = info.FaultException;
this.OnLocalFault(throwException ? null : faultException, info.FaultReply, context);
}
else if (((info.WsrmHeaderFault != null) && (info.WsrmHeaderFault.SequenceID != this.InputID)) && (info.WsrmHeaderFault.SequenceID != this.OutputID))
{
faultException = new ProtocolException(System.ServiceModel.SR.GetString("WrongIdentifierFault", new object[] { FaultException.GetSafeReasonText(info.WsrmHeaderFault.Reason) }));
this.OnLocalFault(throwException ? null : faultException, (Message) null, context);
}
else
{
if (info.FaultInfo == null)
{
return true;
}
if (this.isSessionClosed)
{
UnknownSequenceFault faultInfo = info.FaultInfo as UnknownSequenceFault;
if (faultInfo != null)
{
UniqueId sequenceID = faultInfo.SequenceID;
if (((this.OutputID != null) && (this.OutputID == sequenceID)) || ((this.InputID != null) && (this.InputID == sequenceID)))
{
if (this.settings.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
info.Message.Close();
return false;
}
if (this.settings.ReliableMessagingVersion != ReliableMessagingVersion.WSReliableMessaging11)
{
throw Fx.AssertAndThrow("Unknown version.");
}
return true;
}
}
}
faultException = info.FaultException;
if (context != null)
{
context.Close();
}
this.OnRemoteFault(throwException ? null : faultException);
}
info.Message.Close();
if (throwException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(faultException);
}
return false;
}
public void ProcessDemuxedMessage(WsrmMessageInfo info)
{
try
{
this.ProcessMessage(info);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
base.ReliableSession.OnUnknownException(exception);
}
}
protected override void ProcessMessage(WsrmMessageInfo info)
{
if (base.ReliableSession.ProcessInfo(info, null) && base.ReliableSession.VerifyDuplexProtocolElements(info, null))
{
if (info.CreateSequenceInfo == null)
{
base.ProcessDuplexMessage(info);
}
else
{
EndpointAddress address;
if (WsrmUtilities.ValidateCreateSequence<IDuplexSessionChannel>(info, this.listener, base.Binder.Channel, out address))
{
Message response = WsrmUtilities.CreateCreateSequenceResponse(base.Settings.MessageVersion, base.Settings.ReliableMessagingVersion, true, info.CreateSequenceInfo, base.Settings.Ordered, base.ReliableSession.InputID, address);
using (info.Message)
{
using (response)
{
if (((IServerReliableChannelBinder) base.Binder).AddressResponse(info.Message, response))
{
base.Binder.Send(response, base.DefaultSendTimeout);
}
}
return;
}
}
base.ReliableSession.OnLocalFault(info.FaultException, info.FaultReply, null);
}
}
}
protected override WsrmFault ProcessRequestorResponse(ReliableRequestor requestor, string requestName, WsrmMessageInfo info)
{
if (requestor != null)
{
requestor.SetInfo(info);
return null;
}
string faultReason = System.ServiceModel.SR.GetString("ReceivedResponseBeforeRequestFaultString", new object[] { requestName });
string exceptionMessage = System.ServiceModel.SR.GetString("ReceivedResponseBeforeRequestExceptionString", new object[] { requestName });
return SequenceTerminatedFault.CreateProtocolFault(base.ReliableSession.OutputID, faultReason, exceptionMessage);
}
protected abstract WsrmFault VerifySimplexProtocolElements(WsrmMessageInfo info);
protected abstract WsrmFault ProcessRequestorResponse(ReliableRequestor requestor, string requestName, WsrmMessageInfo info);
protected override WsrmFault VerifyDuplexProtocolElements(WsrmMessageInfo info)
{
WsrmFault fault = base.VerifyDuplexProtocolElements(info);
if (fault != null)
return fault;
else if (info.CreateSequenceInfo != null)
return SequenceTerminatedFault.CreateProtocolFault(this.OutputID, SR.GetString(SR.SequenceTerminatedUnexpectedCS), SR.GetString(SR.UnexpectedCS));
else if (info.CreateSequenceResponseInfo != null && info.CreateSequenceResponseInfo.Identifier != this.OutputID)
return SequenceTerminatedFault.CreateProtocolFault(this.OutputID, SR.GetString(SR.SequenceTerminatedUnexpectedCSROfferId), SR.GetString(SR.UnexpectedCSROfferId));
else
return null;
}
protected override WsrmFault ProcessRequestorResponse(ReliableRequestor requestor, string requestName, WsrmMessageInfo info)
{
if (requestor != null)
{
requestor.SetInfo(info);
return(null);
}
else
{
string faultString = SR.Format(SR.ReceivedResponseBeforeRequestFaultString, requestName);
string exceptionString = SR.Format(SR.ReceivedResponseBeforeRequestExceptionString, requestName);
return(SequenceTerminatedFault.CreateProtocolFault(ReliableSession.OutputID, faultString, exceptionString));
}
}
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.");
}
}
public static CreateSequenceInfo Create(MessageVersion messageVersion,
ReliableMessagingVersion reliableMessagingVersion, ISecureConversationSession securitySession,
XmlDictionaryReader reader)
{
if (reader == null)
{
Fx.Assert("Argument reader cannot be null.");
}
try
{
CreateSequenceInfo info = new CreateSequenceInfo();
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
reader.ReadStartElement(wsrmFeb2005Dictionary.CreateSequence, wsrmNs);
info.AcksTo = EndpointAddress.ReadFrom(messageVersion.Addressing, reader, wsrmFeb2005Dictionary.AcksTo, wsrmNs);
if (reader.IsStartElement(wsrmFeb2005Dictionary.Expires, wsrmNs))
{
info.Expires = reader.ReadElementContentAsTimeSpan();
}
if (reader.IsStartElement(wsrmFeb2005Dictionary.Offer, wsrmNs))
{
reader.ReadStartElement();
reader.ReadStartElement(wsrmFeb2005Dictionary.Identifier, wsrmNs);
info.OfferIdentifier = reader.ReadContentAsUniqueId();
reader.ReadEndElement();
bool wsrm11 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
Wsrm11Dictionary wsrm11Dictionary = wsrm11 ? DXD.Wsrm11Dictionary : null;
if (wsrm11)
{
EndpointAddress endpoint = EndpointAddress.ReadFrom(messageVersion.Addressing, reader,
wsrm11Dictionary.Endpoint, wsrmNs);
if (endpoint.Uri != info.AcksTo.Uri)
{
string reason = SR.GetString(SR.CSRefusedAcksToMustEqualEndpoint);
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
}
}
if (reader.IsStartElement(wsrmFeb2005Dictionary.Expires, wsrmNs))
{
info.OfferExpires = reader.ReadElementContentAsTimeSpan();
}
if (wsrm11)
{
if (reader.IsStartElement(wsrm11Dictionary.IncompleteSequenceBehavior, wsrmNs))
{
string incompleteSequenceBehavior = reader.ReadElementContentAsString();
if ((incompleteSequenceBehavior != Wsrm11Strings.DiscardEntireSequence) &&
(incompleteSequenceBehavior != Wsrm11Strings.DiscardFollowingFirstGap) &&
(incompleteSequenceBehavior != Wsrm11Strings.NoDiscard))
{
string reason = SR.GetString(SR.CSRefusedInvalidIncompleteSequenceBehavior);
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
WsrmMessageInfo.CreateInternalFaultException(faultReply, reason,
new ProtocolException(reason)));
}
// Otherwise ignore the value.
}
}
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
}
// Check for security only if we expect a soap security session.
if (securitySession != null)
{
bool hasValidToken = false;
// Since the security element is amongst the extensible elements (i.e. there is no
// gaurantee of ordering or placement), a loop is required to attempt to parse the
// security element.
while (reader.IsStartElement())
{
if (securitySession.TryReadSessionTokenIdentifier(reader))
{
hasValidToken = true;
break;
}
reader.Skip();
}
if (!hasValidToken)
{
string reason = SR.GetString(SR.CSRefusedRequiredSecurityElementMissing);
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
}
}
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
if (reader.IsStartElement())
{
string reason = SR.GetString(SR.CSRefusedUnexpectedElementAtEndOfCSMessage);
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
}
return(info);
}
catch (XmlException e)
{
string reason = SR.GetString(SR.CouldNotParseWithAction, WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion));
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason, e)));
}
}
protected override void ProcessSequencedItem(IReplySessionChannel channel, RequestContext context, ReliableInputSessionChannelOverReply reliableChannel, WsrmMessageInfo info, bool newChannel)
{
if (!newChannel && !reliableChannel.Binder.UseNewChannel(channel))
{
context.RequestMessage.Close();
context.Abort();
channel.Abort();
}
else
{
reliableChannel.ProcessDemuxedRequest(reliableChannel.Binder.WrapRequestContext(context), info);
}
}
private void ProcessRequest(RequestContext context, WsrmMessageInfo info)
{
bool flag = true;
bool flag2 = true;
try
{
EndpointAddress address;
bool flag3;
if (!base.ReliableSession.ProcessInfo(info, context))
{
flag = false;
flag2 = false;
return;
}
if (!base.ReliableSession.VerifySimplexProtocolElements(info, context))
{
flag = false;
flag2 = false;
return;
}
base.ReliableSession.OnRemoteActivity(false);
if (info.CreateSequenceInfo == null)
{
goto Label_0104;
}
if (WsrmUtilities.ValidateCreateSequence<IInputSessionChannel>(info, base.Listener, base.Binder.Channel, out address))
{
Message response = WsrmUtilities.CreateCreateSequenceResponse(base.Listener.MessageVersion, base.Listener.ReliableMessagingVersion, false, info.CreateSequenceInfo, base.Listener.Ordered, base.ReliableSession.InputID, address);
using (context)
{
using (response)
{
if (base.Binder.AddressResponse(info.Message, response))
{
context.Reply(response, base.DefaultSendTimeout);
}
}
goto Label_00FB;
}
}
base.ReliableSession.OnLocalFault(info.FaultException, info.FaultReply, context);
Label_00FB:
flag = false;
flag2 = false;
return;
Label_0104:
flag3 = false;
bool allAdded = false;
bool flag5 = false;
WsrmFault fault = null;
Message message2 = null;
Exception e = null;
bool flag6 = base.Listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
bool flag7 = base.Listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
bool flag8 = info.AckRequestedInfo != null;
if (info.SequencedMessageInfo != null)
{
lock (base.ThisLock)
{
if (base.Aborted || (base.State == CommunicationState.Faulted))
{
return;
}
long sequenceNumber = info.SequencedMessageInfo.SequenceNumber;
bool isLast = flag6 && info.SequencedMessageInfo.LastMessage;
if (!base.Connection.IsValid(sequenceNumber, isLast))
{
if (flag6)
{
fault = new LastMessageNumberExceededFault(base.ReliableSession.InputID);
}
else
{
message2 = new SequenceClosedFault(base.ReliableSession.InputID).CreateMessage(base.Listener.MessageVersion, base.Listener.ReliableMessagingVersion);
if (PerformanceCounters.PerformanceCountersEnabled)
{
PerformanceCounters.MessageDropped(base.perfCounterId);
}
}
}
else if (base.Connection.Ranges.Contains(sequenceNumber))
{
if (PerformanceCounters.PerformanceCountersEnabled)
{
PerformanceCounters.MessageDropped(base.perfCounterId);
}
}
else if (flag6 && (info.Action == "http://schemas.xmlsoap.org/ws/2005/02/rm/LastMessage"))
{
base.Connection.Merge(sequenceNumber, isLast);
allAdded = base.Connection.AllAdded;
}
else if (base.State == CommunicationState.Closing)
{
if (flag6)
{
fault = SequenceTerminatedFault.CreateProtocolFault(base.ReliableSession.InputID, System.ServiceModel.SR.GetString("SequenceTerminatedSessionClosedBeforeDone"), System.ServiceModel.SR.GetString("SessionClosedBeforeDone"));
}
else
{
message2 = new SequenceClosedFault(base.ReliableSession.InputID).CreateMessage(base.Listener.MessageVersion, base.Listener.ReliableMessagingVersion);
if (PerformanceCounters.PerformanceCountersEnabled)
{
PerformanceCounters.MessageDropped(base.perfCounterId);
}
}
}
else if (base.DeliveryStrategy.CanEnqueue(sequenceNumber) && (base.Listener.Ordered || base.Connection.CanMerge(sequenceNumber)))
{
base.Connection.Merge(sequenceNumber, isLast);
flag3 = base.DeliveryStrategy.Enqueue(info.Message, sequenceNumber);
allAdded = base.Connection.AllAdded;
flag2 = false;
}
else if (PerformanceCounters.PerformanceCountersEnabled)
{
PerformanceCounters.MessageDropped(base.perfCounterId);
}
goto Label_05CE;
}
}
if (flag6 && (info.TerminateSequenceInfo != null))
{
bool flag11;
lock (base.ThisLock)
{
flag11 = !base.Connection.Terminate();
}
if (!flag11)
{
return;
}
fault = SequenceTerminatedFault.CreateProtocolFault(base.ReliableSession.InputID, System.ServiceModel.SR.GetString("SequenceTerminatedEarlyTerminateSequence"), System.ServiceModel.SR.GetString("EarlyTerminateSequence"));
}
else if (flag7 && ((info.TerminateSequenceInfo != null) || (info.CloseSequenceInfo != null)))
{
bool flag13 = info.TerminateSequenceInfo != null;
WsrmRequestInfo info2 = flag13 ? ((WsrmRequestInfo) info.TerminateSequenceInfo) : ((WsrmRequestInfo) info.CloseSequenceInfo);
long last = flag13 ? info.TerminateSequenceInfo.LastMsgNumber : info.CloseSequenceInfo.LastMsgNumber;
if (!WsrmUtilities.ValidateWsrmRequest(base.ReliableSession, info2, base.Binder, context))
{
flag2 = false;
flag = false;
return;
}
bool isLastLargeEnough = true;
bool flag15 = true;
lock (base.ThisLock)
{
if (!base.Connection.IsLastKnown)
{
if (flag13)
{
if (base.Connection.SetTerminateSequenceLast(last, out isLastLargeEnough))
{
allAdded = true;
}
else if (isLastLargeEnough)
{
e = new ProtocolException(System.ServiceModel.SR.GetString("EarlyTerminateSequence"));
}
}
else
{
allAdded = base.Connection.SetCloseSequenceLast(last);
isLastLargeEnough = allAdded;
}
if (allAdded)
{
base.ReliableSession.SetFinalAck(base.Connection.Ranges);
base.DeliveryStrategy.Dispose();
}
}
else
{
flag15 = last == base.Connection.Last;
if ((flag13 && flag15) && base.Connection.IsSequenceClosed)
{
flag5 = true;
}
}
}
if (!isLastLargeEnough)
{
fault = SequenceTerminatedFault.CreateProtocolFault(base.ReliableSession.InputID, System.ServiceModel.SR.GetString("SequenceTerminatedSmallLastMsgNumber"), System.ServiceModel.SR.GetString("SmallLastMsgNumberExceptionString"));
}
else if (!flag15)
{
fault = SequenceTerminatedFault.CreateProtocolFault(base.ReliableSession.InputID, System.ServiceModel.SR.GetString("SequenceTerminatedInconsistentLastMsgNumber"), System.ServiceModel.SR.GetString("InconsistentLastMsgNumberExceptionString"));
}
else
{
message2 = flag13 ? WsrmUtilities.CreateTerminateResponseMessage(base.Listener.MessageVersion, info2.MessageId, base.ReliableSession.InputID) : WsrmUtilities.CreateCloseSequenceResponse(base.Listener.MessageVersion, info2.MessageId, base.ReliableSession.InputID);
flag8 = true;
}
}
Label_05CE:
if (fault != null)
{
base.ReliableSession.OnLocalFault(fault.CreateException(), fault, context);
flag2 = false;
flag = false;
}
else
{
if ((message2 != null) && flag8)
{
base.AddAcknowledgementHeader(message2);
}
else if (message2 == null)
{
message2 = base.CreateAcknowledgmentMessage();
}
using (message2)
{
context.Reply(message2);
}
if (flag5)
{
lock (base.ThisLock)
{
base.Connection.Terminate();
}
}
if (e != null)
{
base.ReliableSession.OnRemoteFault(e);
}
else
{
if (flag3)
{
base.Dispatch();
}
if (allAdded)
{
ActionItem.Schedule(new Action<object>(this.ShutdownCallback), null);
}
}
}
}
finally
{
if (flag2)
{
info.Message.Close();
}
if (flag)
{
context.Close();
}
}
}
