Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

1271 lines
48 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections.Generic;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Diagnostics;
using System.Threading;
using System.Xml;
abstract class ReliableInputSessionChannel : InputChannel, IInputSessionChannel
{
bool advertisedZero = false;
IServerReliableChannelBinder binder;
ReliableInputConnection connection;
DeliveryStrategy<Message> deliveryStrategy;
ReliableChannelListenerBase<IInputSessionChannel> listener;
ServerReliableSession session;
protected string perfCounterId;
static Action<object> asyncReceiveComplete = new Action<object>(AsyncReceiveCompleteStatic);
static AsyncCallback onReceiveCompleted = Fx.ThunkCallback(new AsyncCallback(OnReceiveCompletedStatic));
protected ReliableInputSessionChannel(
ReliableChannelListenerBase<IInputSessionChannel> listener,
IServerReliableChannelBinder binder,
FaultHelper faultHelper,
UniqueId inputID)
: base(listener, binder.LocalAddress)
{
this.binder = binder;
this.listener = listener;
this.connection = new ReliableInputConnection();
this.connection.ReliableMessagingVersion = listener.ReliableMessagingVersion;
this.session = new ServerReliableSession(this, listener, binder, faultHelper, inputID, null);
this.session.UnblockChannelCloseCallback = this.UnblockClose;
if (listener.Ordered)
this.deliveryStrategy = new OrderedDeliveryStrategy<Message>(this, listener.MaxTransferWindowSize, false);
else
this.deliveryStrategy = new UnorderedDeliveryStrategy<Message>(this, listener.MaxTransferWindowSize);
this.binder.Faulted += OnBinderFaulted;
this.binder.OnException += OnBinderException;
this.session.Open(TimeSpan.Zero);
if (PerformanceCounters.PerformanceCountersEnabled)
this.perfCounterId = this.listener.Uri.ToString().ToUpperInvariant();
}
protected bool AdvertisedZero
{
get
{
return this.advertisedZero;
}
set
{
this.advertisedZero = value;
}
}
public IServerReliableChannelBinder Binder
{
get
{
return this.binder;
}
}
protected ReliableInputConnection Connection
{
get
{
return this.connection;
}
}
protected DeliveryStrategy<Message> DeliveryStrategy
{
get
{
return this.deliveryStrategy;
}
}
protected ReliableChannelListenerBase<IInputSessionChannel> Listener
{
get
{
return this.listener;
}
}
protected ChannelReliableSession ReliableSession
{
get
{
return this.session;
}
}
public IInputSession Session
{
get
{
return this.session;
}
}
protected virtual void AggregateAsyncCloseOperations(List<OperationWithTimeoutBeginCallback> beginOperations, List<OperationEndCallback> endOperations)
{
beginOperations.Add(new OperationWithTimeoutBeginCallback(this.session.BeginClose));
endOperations.Add(new OperationEndCallback(this.session.EndClose));
}
static void AsyncReceiveCompleteStatic(object state)
{
IAsyncResult result = (IAsyncResult)state;
ReliableInputSessionChannel channel = (ReliableInputSessionChannel)(result.AsyncState);
try
{
if (channel.HandleReceiveComplete(result))
{
channel.StartReceiving(true);
}
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
channel.ReliableSession.OnUnknownException(e);
}
}
static void OnReceiveCompletedStatic(IAsyncResult result)
{
if (result.CompletedSynchronously)
return;
ReliableInputSessionChannel channel = (ReliableInputSessionChannel)(result.AsyncState);
try
{
if (channel.HandleReceiveComplete(result))
{
channel.StartReceiving(true);
}
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
channel.ReliableSession.OnUnknownException(e);
}
}
protected abstract bool HandleReceiveComplete(IAsyncResult result);
protected virtual void AbortGuards()
{
}
protected void AddAcknowledgementHeader(Message message)
{
int bufferRemaining = -1;
if (this.Listener.FlowControlEnabled)
{
bufferRemaining = this.Listener.MaxTransferWindowSize - this.deliveryStrategy.EnqueuedCount;
this.AdvertisedZero = (bufferRemaining == 0);
}
WsrmUtilities.AddAcknowledgementHeader(this.listener.ReliableMessagingVersion, message,
this.session.InputID, this.connection.Ranges, this.connection.IsLastKnown, bufferRemaining);
}
IAsyncResult BeginCloseBinder(TimeSpan timeout, AsyncCallback callback, object state)
{
return this.binder.BeginClose(timeout, MaskingMode.Handled, callback, state);
}
protected virtual IAsyncResult BeginCloseGuards(TimeSpan timeout, AsyncCallback callback, object state)
{
return new CompletedAsyncResult(callback, state);
}
IAsyncResult BeginUnregisterChannel(TimeSpan timeout, AsyncCallback callback, object state)
{
return this.listener.OnReliableChannelBeginClose(this.ReliableSession.InputID, null,
timeout, callback, state);
}
protected override void OnClosed()
{
base.OnClosed();
this.binder.Faulted -= this.OnBinderFaulted;
this.deliveryStrategy.Dispose();
}
protected virtual void CloseGuards(TimeSpan timeout)
{
}
protected Message CreateAcknowledgmentMessage()
{
int bufferRemaining = -1;
if (this.Listener.FlowControlEnabled)
{
bufferRemaining = this.Listener.MaxTransferWindowSize - this.deliveryStrategy.EnqueuedCount;
this.AdvertisedZero = (bufferRemaining == 0);
}
Message message = WsrmUtilities.CreateAcknowledgmentMessage(
this.listener.MessageVersion,
this.listener.ReliableMessagingVersion,
this.session.InputID,
this.connection.Ranges,
this.connection.IsLastKnown,
bufferRemaining);
return message;
}
void EndCloseBinder(IAsyncResult result)
{
this.binder.EndClose(result);
}
protected virtual void EndCloseGuards(IAsyncResult result)
{
CompletedAsyncResult.End(result);
}
void EndUnregisterChannel(IAsyncResult result)
{
this.listener.OnReliableChannelEndClose(result);
}
public override T GetProperty<T>()
{
if (typeof(T) == typeof(IInputSessionChannel))
{
return (T)(object)this;
}
T baseProperty = base.GetProperty<T>();
if (baseProperty != null)
{
return baseProperty;
}
T innerProperty = this.binder.Channel.GetProperty<T>();
if ((innerProperty == null) && (typeof(T) == typeof(FaultConverter)))
{
return (T)(object)FaultConverter.GetDefaultFaultConverter(this.listener.MessageVersion);
}
else
{
return innerProperty;
}
}
protected override void OnAbort()
{
this.connection.Abort(this);
this.AbortGuards();
this.session.Abort();
this.listener.OnReliableChannelAbort(this.ReliableSession.InputID, null);
base.OnAbort();
}
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
{
this.ThrowIfCloseInvalid();
OperationWithTimeoutBeginCallback[] beginOperations = new OperationWithTimeoutBeginCallback[]
{
this.connection.BeginClose,
this.session.BeginClose,
this.BeginCloseGuards,
this.BeginCloseBinder,
this.BeginUnregisterChannel,
base.OnBeginClose
};
OperationEndCallback[] endOperations = new OperationEndCallback[]
{
this.connection.EndClose,
this.session.EndClose,
this.EndCloseGuards,
this.EndCloseBinder,
this.EndUnregisterChannel,
base.OnEndClose
};
return OperationWithTimeoutComposer.BeginComposeAsyncOperations(timeout,
beginOperations, endOperations, callback, state);
}
void OnBinderException(IReliableChannelBinder sender, Exception exception)
{
if (exception is QuotaExceededException)
this.session.OnLocalFault(exception, SequenceTerminatedFault.CreateQuotaExceededFault(this.session.OutputID), null);
else
this.EnqueueAndDispatch(exception, null, false);
}
void OnBinderFaulted(IReliableChannelBinder sender, Exception exception)
{
this.binder.Abort();
exception = new CommunicationException(SR.GetString(SR.EarlySecurityFaulted), exception);
this.session.OnLocalFault(exception, (Message)null, null);
}
protected override void OnClose(TimeSpan timeout)
{
this.ThrowIfCloseInvalid();
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
this.connection.Close(timeoutHelper.RemainingTime());
this.session.Close(timeoutHelper.RemainingTime());
this.CloseGuards(timeoutHelper.RemainingTime());
this.binder.Close(timeoutHelper.RemainingTime(), MaskingMode.Handled);
this.listener.OnReliableChannelClose(this.ReliableSession.InputID, null,
timeoutHelper.RemainingTime());
base.OnClose(timeoutHelper.RemainingTime());
}
protected override void OnEndClose(IAsyncResult result)
{
OperationWithTimeoutComposer.EndComposeAsyncOperations(result);
}
protected override void OnFaulted()
{
this.session.OnFaulted();
this.UnblockClose();
base.OnFaulted();
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.SessionFaulted(this.perfCounterId);
}
protected virtual void OnQuotaAvailable()
{
}
protected void ShutdownCallback(object state)
{
this.Shutdown();
}
protected void StartReceiving(bool canBlock)
{
while (true)
{
IAsyncResult result = this.Binder.BeginTryReceive(TimeSpan.MaxValue, onReceiveCompleted, this);
if (!result.CompletedSynchronously)
return;
if (!canBlock)
{
ActionItem.Schedule(asyncReceiveComplete, result);
return;
}
if (!this.HandleReceiveComplete(result))
break;
}
}
void ThrowIfCloseInvalid()
{
bool shouldFault = false;
if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
{
if (this.DeliveryStrategy.EnqueuedCount > 0 || this.Connection.Ranges.Count > 1)
{
shouldFault = true;
}
}
else if (this.listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
{
if (this.DeliveryStrategy.EnqueuedCount > 0)
{
shouldFault = true;
}
}
if (shouldFault)
{
WsrmFault fault = SequenceTerminatedFault.CreateProtocolFault(this.session.InputID,
SR.GetString(SR.SequenceTerminatedSessionClosedBeforeDone), SR.GetString(SR.SessionClosedBeforeDone));
this.session.OnLocalFault(null, fault, null);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(fault.CreateException());
}
}
void UnblockClose()
{
this.connection.Fault(this);
}
}
sealed class ReliableInputSessionChannelOverDuplex : ReliableInputSessionChannel
{
TimeSpan acknowledgementInterval;
bool acknowledgementScheduled = false;
IOThreadTimer acknowledgementTimer;
Guard guard = new Guard(Int32.MaxValue);
int pendingAcknowledgements = 0;
public ReliableInputSessionChannelOverDuplex(
ReliableChannelListenerBase<IInputSessionChannel> listener,
IServerReliableChannelBinder binder, FaultHelper faultHelper,
UniqueId inputID)
: base(listener, binder, faultHelper, inputID)
{
this.acknowledgementInterval = listener.AcknowledgementInterval;
this.acknowledgementTimer = new IOThreadTimer(new Action<object>(this.OnAcknowledgementTimeoutElapsed), null, true);
this.DeliveryStrategy.DequeueCallback = this.OnDeliveryStrategyItemDequeued;
if (binder.HasSession)
{
try
{
this.StartReceiving(false);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.ReliableSession.OnUnknownException(e);
}
}
}
protected override void AbortGuards()
{
this.guard.Abort();
}
protected override IAsyncResult BeginCloseGuards(TimeSpan timeout, AsyncCallback callback, object state)
{
return this.guard.BeginClose(timeout, callback, state);
}
protected override void CloseGuards(TimeSpan timeout)
{
this.guard.Close(timeout);
}
protected override void EndCloseGuards(IAsyncResult result)
{
this.guard.EndClose(result);
}
protected override bool HandleReceiveComplete(IAsyncResult result)
{
RequestContext context;
if (this.Binder.EndTryReceive(result, out context))
{
if (context == null)
{
bool terminated = false;
lock (this.ThisLock)
{
terminated = this.Connection.Terminate();
}
if (!terminated && (this.Binder.State == CommunicationState.Opened))
{
Exception e = new CommunicationException(SR.GetString(SR.EarlySecurityClose));
this.ReliableSession.OnLocalFault(e, (Message)null, null);
}
return false;
}
Message message = context.RequestMessage;
context.Close();
WsrmMessageInfo info = WsrmMessageInfo.Get(this.Listener.MessageVersion,
this.Listener.ReliableMessagingVersion, this.Binder.Channel, this.Binder.GetInnerSession(),
message);
this.StartReceiving(false);
this.ProcessMessage(info);
return false;
}
return true;
}
void OnAcknowledgementTimeoutElapsed(object state)
{
lock (this.ThisLock)
{
this.acknowledgementScheduled = false;
this.pendingAcknowledgements = 0;
if (this.State == CommunicationState.Closing
|| this.State == CommunicationState.Closed
|| this.State == CommunicationState.Faulted)
return;
}
if (this.guard.Enter())
{
try
{
using (Message message = CreateAcknowledgmentMessage())
{
this.Binder.Send(message, this.DefaultSendTimeout);
}
}
finally
{
this.guard.Exit();
}
}
}
void OnDeliveryStrategyItemDequeued()
{
if (this.AdvertisedZero)
this.OnAcknowledgementTimeoutElapsed(null);
}
protected override void OnClosing()
{
base.OnClosing();
this.acknowledgementTimer.Cancel();
}
protected override void OnQuotaAvailable()
{
this.OnAcknowledgementTimeoutElapsed(null);
}
public void ProcessDemuxedMessage(WsrmMessageInfo info)
{
try
{
this.ProcessMessage(info);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
this.ReliableSession.OnUnknownException(e);
}
}
void ProcessMessage(WsrmMessageInfo info)
{
bool closeMessage = true;
try
{
if (!this.ReliableSession.ProcessInfo(info, null))
{
closeMessage = false;
return;
}
if (!this.ReliableSession.VerifySimplexProtocolElements(info, null))
{
closeMessage = false;
return;
}
this.ReliableSession.OnRemoteActivity(false);
if (info.CreateSequenceInfo != null)
{
EndpointAddress acksTo;
if (WsrmUtilities.ValidateCreateSequence<IInputSessionChannel>(info, this.Listener, this.Binder.Channel, out acksTo))
{
Message response = WsrmUtilities.CreateCreateSequenceResponse(this.Listener.MessageVersion,
this.Listener.ReliableMessagingVersion, false, info.CreateSequenceInfo,
this.Listener.Ordered, this.ReliableSession.InputID, acksTo);
using (response)
{
if (this.Binder.AddressResponse(info.Message, response))
this.Binder.Send(response, this.DefaultSendTimeout);
}
}
else
{
this.ReliableSession.OnLocalFault(info.FaultException, info.FaultReply, null);
}
return;
}
bool needDispatch = false;
bool scheduleShutdown = false;
bool tryAckNow = (info.AckRequestedInfo != null);
bool terminate = false;
Message message = null;
WsrmFault fault = null;
Exception remoteFaultException = null;
bool wsrmFeb2005 = this.Listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
bool wsrm11 = this.Listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
if (info.SequencedMessageInfo != null)
{
lock (this.ThisLock)
{
if (this.Aborted || this.State == CommunicationState.Faulted)
{
return;
}
Int64 sequenceNumber = info.SequencedMessageInfo.SequenceNumber;
bool isLast = wsrmFeb2005 && info.SequencedMessageInfo.LastMessage;
if (!this.Connection.IsValid(sequenceNumber, isLast))
{
if (wsrmFeb2005)
{
fault = new LastMessageNumberExceededFault(this.ReliableSession.InputID);
}
else
{
message = new SequenceClosedFault(this.ReliableSession.InputID).CreateMessage(
this.Listener.MessageVersion, this.Listener.ReliableMessagingVersion);
tryAckNow = true;
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
}
}
else if (this.Connection.Ranges.Contains(sequenceNumber))
{
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
tryAckNow = true;
}
else if (wsrmFeb2005 && info.Action == WsrmFeb2005Strings.LastMessageAction)
{
this.Connection.Merge(sequenceNumber, isLast);
if (this.Connection.AllAdded)
{
scheduleShutdown = true;
this.ReliableSession.CloseSession();
}
}
else if (this.State == CommunicationState.Closing)
{
if (wsrmFeb2005)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.ReliableSession.InputID,
SR.GetString(SR.SequenceTerminatedSessionClosedBeforeDone),
SR.GetString(SR.SessionClosedBeforeDone));
}
else
{
message = new SequenceClosedFault(this.ReliableSession.InputID).CreateMessage(
this.Listener.MessageVersion, this.Listener.ReliableMessagingVersion);
tryAckNow = true;
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
}
}
// In the unordered case we accept no more than MaxSequenceRanges ranges to limit the
// serialized ack size and the amount of memory taken by the ack ranges. In the
// ordered case, the delivery strategy MaxTransferWindowSize quota mitigates this
// threat.
else if (this.DeliveryStrategy.CanEnqueue(sequenceNumber)
&& (this.Listener.Ordered || this.Connection.CanMerge(sequenceNumber)))
{
this.Connection.Merge(sequenceNumber, isLast);
needDispatch = this.DeliveryStrategy.Enqueue(info.Message, sequenceNumber);
closeMessage = false;
this.pendingAcknowledgements++;
if (this.pendingAcknowledgements == this.Listener.MaxTransferWindowSize)
tryAckNow = true;
if (this.Connection.AllAdded)
{
scheduleShutdown = true;
this.ReliableSession.CloseSession();
}
}
else
{
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
}
if (this.Connection.IsLastKnown)
tryAckNow = true;
if (!tryAckNow && this.pendingAcknowledgements > 0 && !this.acknowledgementScheduled && fault == null)
{
this.acknowledgementScheduled = true;
this.acknowledgementTimer.Set(this.acknowledgementInterval);
}
}
}
else if (wsrmFeb2005 && info.TerminateSequenceInfo != null)
{
bool isTerminateEarly;
lock (this.ThisLock)
{
isTerminateEarly = !this.Connection.Terminate();
}
if (isTerminateEarly)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.ReliableSession.InputID,
SR.GetString(SR.SequenceTerminatedEarlyTerminateSequence),
SR.GetString(SR.EarlyTerminateSequence));
}
}
else if (wsrm11 && ((info.TerminateSequenceInfo != null) || info.CloseSequenceInfo != null))
{
bool isTerminate = info.TerminateSequenceInfo != null;
WsrmRequestInfo requestInfo = isTerminate
? (WsrmRequestInfo)info.TerminateSequenceInfo
: (WsrmRequestInfo)info.CloseSequenceInfo;
Int64 last = isTerminate ? info.TerminateSequenceInfo.LastMsgNumber : info.CloseSequenceInfo.LastMsgNumber;
if (!WsrmUtilities.ValidateWsrmRequest(this.ReliableSession, requestInfo, this.Binder, null))
{
return;
}
bool isLastLargeEnough = true;
bool isLastConsistent = true;
lock (this.ThisLock)
{
if (!this.Connection.IsLastKnown)
{
if (isTerminate)
{
if (this.Connection.SetTerminateSequenceLast(last, out isLastLargeEnough))
{
scheduleShutdown = true;
}
else if (isLastLargeEnough)
{
remoteFaultException = new ProtocolException(SR.GetString(SR.EarlyTerminateSequence));
}
}
else
{
scheduleShutdown = this.Connection.SetCloseSequenceLast(last);
isLastLargeEnough = scheduleShutdown;
}
if (scheduleShutdown)
{
this.ReliableSession.SetFinalAck(this.Connection.Ranges);
this.DeliveryStrategy.Dispose();
}
}
else
{
isLastConsistent = (last == this.Connection.Last);
// Have seen CloseSequence already, TerminateSequence means cleanup.
if (isTerminate && isLastConsistent && this.Connection.IsSequenceClosed)
{
terminate = true;
}
}
}
if (!isLastLargeEnough)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.ReliableSession.InputID,
SR.GetString(SR.SequenceTerminatedSmallLastMsgNumber),
SR.GetString(SR.SmallLastMsgNumberExceptionString));
}
else if (!isLastConsistent)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.ReliableSession.InputID,
SR.GetString(SR.SequenceTerminatedInconsistentLastMsgNumber),
SR.GetString(SR.InconsistentLastMsgNumberExceptionString));
}
else
{
message = isTerminate
? WsrmUtilities.CreateTerminateResponseMessage(this.Listener.MessageVersion,
requestInfo.MessageId, this.ReliableSession.InputID)
: WsrmUtilities.CreateCloseSequenceResponse(this.Listener.MessageVersion,
requestInfo.MessageId, this.ReliableSession.InputID);
tryAckNow = true;
}
}
if (fault != null)
{
this.ReliableSession.OnLocalFault(fault.CreateException(), fault, null);
}
else
{
if (tryAckNow)
{
lock (this.ThisLock)
{
if (this.acknowledgementScheduled)
{
this.acknowledgementTimer.Cancel();
this.acknowledgementScheduled = false;
}
this.pendingAcknowledgements = 0;
}
if (message != null)
{
this.AddAcknowledgementHeader(message);
}
else
{
message = this.CreateAcknowledgmentMessage();
}
}
if (message != null)
{
using (message)
{
if (this.guard.Enter())
{
try
{
this.Binder.Send(message, this.DefaultSendTimeout);
}
finally
{
this.guard.Exit();
}
}
}
}
if (terminate)
{
lock (this.ThisLock)
{
this.Connection.Terminate();
}
}
if (remoteFaultException != null)
{
this.ReliableSession.OnRemoteFault(remoteFaultException);
return;
}
if (needDispatch)
{
this.Dispatch();
}
if (scheduleShutdown)
{
ActionItem.Schedule(this.ShutdownCallback, null);
}
}
}
finally
{
if (closeMessage)
{
info.Message.Close();
}
}
}
}
sealed class ReliableInputSessionChannelOverReply : ReliableInputSessionChannel
{
public ReliableInputSessionChannelOverReply(
ReliableChannelListenerBase<IInputSessionChannel> listener,
IServerReliableChannelBinder binder, FaultHelper faultHelper,
UniqueId inputID)
: base(listener, binder, faultHelper, inputID)
{
if (binder.HasSession)
{
try
{
this.StartReceiving(false);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.ReliableSession.OnUnknownException(e);
}
}
}
protected override bool HandleReceiveComplete(IAsyncResult result)
{
RequestContext context;
bool timeoutOkay = this.Binder.EndTryReceive(result, out context);
if (timeoutOkay)
{
if (context == null)
{
bool terminated = false;
lock (this.ThisLock)
{
terminated = this.Connection.Terminate();
}
if (!terminated && (this.Binder.State == CommunicationState.Opened))
{
Exception e = new CommunicationException(SR.GetString(SR.EarlySecurityClose));
this.ReliableSession.OnLocalFault(e, (Message)null, null);
}
return false;
}
WsrmMessageInfo info = WsrmMessageInfo.Get(this.Listener.MessageVersion,
this.Listener.ReliableMessagingVersion, this.Binder.Channel, this.Binder.GetInnerSession(),
context.RequestMessage);
this.StartReceiving(false);
this.ProcessRequest(context, info);
return false;
}
return true;
}
public void ProcessDemuxedRequest(RequestContext context, WsrmMessageInfo info)
{
try
{
this.ProcessRequest(context, info);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
this.ReliableSession.OnUnknownException(e);
}
}
void ProcessRequest(RequestContext context, WsrmMessageInfo info)
{
bool closeContext = true;
bool closeMessage = true;
try
{
if (!this.ReliableSession.ProcessInfo(info, context))
{
closeContext = false;
closeMessage = false;
return;
}
if (!this.ReliableSession.VerifySimplexProtocolElements(info, context))
{
closeContext = false;
closeMessage = false;
return;
}
this.ReliableSession.OnRemoteActivity(false);
if (info.CreateSequenceInfo != null)
{
EndpointAddress acksTo;
if (WsrmUtilities.ValidateCreateSequence<IInputSessionChannel>(info, this.Listener, this.Binder.Channel, out acksTo))
{
Message response = WsrmUtilities.CreateCreateSequenceResponse(this.Listener.MessageVersion,
this.Listener.ReliableMessagingVersion, false, info.CreateSequenceInfo,
this.Listener.Ordered, this.ReliableSession.InputID, acksTo);
using (context)
{
using (response)
{
if (this.Binder.AddressResponse(info.Message, response))
context.Reply(response, this.DefaultSendTimeout);
}
}
}
else
{
this.ReliableSession.OnLocalFault(info.FaultException, info.FaultReply, context);
}
closeContext = false;
closeMessage = false;
return;
}
bool needDispatch = false;
bool scheduleShutdown = false;
bool terminate = false;
WsrmFault fault = null;
Message message = null;
Exception remoteFaultException = null;
bool wsrmFeb2005 = this.Listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
bool wsrm11 = this.Listener.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
bool addAck = info.AckRequestedInfo != null;
if (info.SequencedMessageInfo != null)
{
lock (this.ThisLock)
{
if (this.Aborted || (this.State == CommunicationState.Faulted))
{
return;
}
Int64 sequenceNumber = info.SequencedMessageInfo.SequenceNumber;
bool isLast = wsrmFeb2005 && info.SequencedMessageInfo.LastMessage;
if (!this.Connection.IsValid(sequenceNumber, isLast))
{
if (wsrmFeb2005)
{
fault = new LastMessageNumberExceededFault(this.ReliableSession.InputID);
}
else
{
message = new SequenceClosedFault(this.ReliableSession.InputID).CreateMessage(
this.Listener.MessageVersion, this.Listener.ReliableMessagingVersion);
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
}
}
else if (this.Connection.Ranges.Contains(sequenceNumber))
{
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
}
else if (wsrmFeb2005 && info.Action == WsrmFeb2005Strings.LastMessageAction)
{
this.Connection.Merge(sequenceNumber, isLast);
scheduleShutdown = this.Connection.AllAdded;
}
else if (this.State == CommunicationState.Closing)
{
if (wsrmFeb2005)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.ReliableSession.InputID,
SR.GetString(SR.SequenceTerminatedSessionClosedBeforeDone),
SR.GetString(SR.SessionClosedBeforeDone));
}
else
{
message = new SequenceClosedFault(this.ReliableSession.InputID).CreateMessage(
this.Listener.MessageVersion, this.Listener.ReliableMessagingVersion);
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
}
}
// In the unordered case we accept no more than MaxSequenceRanges ranges to limit the
// serialized ack size and the amount of memory taken by the ack ranges. In the
// ordered case, the delivery strategy MaxTransferWindowSize quota mitigates this
// threat.
else if (this.DeliveryStrategy.CanEnqueue(sequenceNumber)
&& (this.Listener.Ordered || this.Connection.CanMerge(sequenceNumber)))
{
this.Connection.Merge(sequenceNumber, isLast);
needDispatch = this.DeliveryStrategy.Enqueue(info.Message, sequenceNumber);
scheduleShutdown = this.Connection.AllAdded;
closeMessage = false;
}
else
{
if (PerformanceCounters.PerformanceCountersEnabled)
PerformanceCounters.MessageDropped(this.perfCounterId);
}
}
}
else if (wsrmFeb2005 && info.TerminateSequenceInfo != null)
{
bool isTerminateEarly;
lock (this.ThisLock)
{
isTerminateEarly = !this.Connection.Terminate();
}
if (isTerminateEarly)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.ReliableSession.InputID,
SR.GetString(SR.SequenceTerminatedEarlyTerminateSequence),
SR.GetString(SR.EarlyTerminateSequence));
}
else
{
// In the normal case, TerminateSequence is a one-way operation, returning (the finally
// block will close the context).
return;
}
}
else if (wsrm11 && ((info.TerminateSequenceInfo != null) || (info.CloseSequenceInfo != null)))
{
bool isTerminate = (info.TerminateSequenceInfo != null);
WsrmRequestInfo requestInfo = isTerminate
? (WsrmRequestInfo)info.TerminateSequenceInfo
: (WsrmRequestInfo)info.CloseSequenceInfo;
Int64 last = isTerminate ? info.TerminateSequenceInfo.LastMsgNumber : info.CloseSequenceInfo.LastMsgNumber;
if (!WsrmUtilities.ValidateWsrmRequest(this.ReliableSession, requestInfo, this.Binder, context))
{
closeMessage = false;
closeContext = false;
return;
}
bool isLastLargeEnough = true;
bool isLastConsistent = true;
lock (this.ThisLock)
{
if (!this.Connection.IsLastKnown)
{
if (isTerminate)
{
if (this.Connection.SetTerminateSequenceLast(last, out isLastLargeEnough))
{
scheduleShutdown = true;
}
else if (isLastLargeEnough)
{
remoteFaultException = new ProtocolException(SR.GetString(SR.EarlyTerminateSequence));
}
}
else
{
scheduleShutdown = this.Connection.SetCloseSequenceLast(last);
isLastLargeEnough = scheduleShutdown;
}
if (scheduleShutdown)
{
this.ReliableSession.SetFinalAck(this.Connection.Ranges);
this.DeliveryStrategy.Dispose();
}
}
else
{
isLastConsistent = (last == this.Connection.Last);
// Have seen CloseSequence already, TerminateSequence means cleanup.
if (isTerminate && isLastConsistent && this.Connection.IsSequenceClosed)
{
terminate = true;
}
}
}
if (!isLastLargeEnough)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.ReliableSession.InputID,
SR.GetString(SR.SequenceTerminatedSmallLastMsgNumber),
SR.GetString(SR.SmallLastMsgNumberExceptionString));
}
else if (!isLastConsistent)
{
fault = SequenceTerminatedFault.CreateProtocolFault(this.ReliableSession.InputID,
SR.GetString(SR.SequenceTerminatedInconsistentLastMsgNumber),
SR.GetString(SR.InconsistentLastMsgNumberExceptionString));
}
else
{
message = isTerminate
? WsrmUtilities.CreateTerminateResponseMessage(this.Listener.MessageVersion,
requestInfo.MessageId, this.ReliableSession.InputID)
: WsrmUtilities.CreateCloseSequenceResponse(this.Listener.MessageVersion,
requestInfo.MessageId, this.ReliableSession.InputID);
addAck = true;
}
}
if (fault != null)
{
this.ReliableSession.OnLocalFault(fault.CreateException(), fault, context);
closeMessage = false;
closeContext = false;
return;
}
if (message != null && addAck)
{
this.AddAcknowledgementHeader(message);
}
else if (message == null)
{
message = this.CreateAcknowledgmentMessage();
}
using (message)
{
context.Reply(message);
}
if (terminate)
{
lock (this.ThisLock)
{
this.Connection.Terminate();
}
}
if (remoteFaultException != null)
{
this.ReliableSession.OnRemoteFault(remoteFaultException);
return;
}
if (needDispatch)
{
this.Dispatch();
}
if (scheduleShutdown)
{
ActionItem.Schedule(this.ShutdownCallback, null);
}
}
finally
{
if (closeMessage)
info.Message.Close();
if (closeContext)
context.Close();
}
}
}
}