mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
1271 lines
48 KiB
C#
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();
|
|
}
|
|
}
|
|
}
|
|
}
|