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
4845 lines
202 KiB
C#
4845 lines
202 KiB
C#
//----------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Security
|
|
{
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IdentityModel.Claims;
|
|
using System.IdentityModel.Selectors;
|
|
using System.IdentityModel.Tokens;
|
|
using System.Runtime;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.ServiceModel.Dispatcher;
|
|
using System.ServiceModel.Security.Tokens;
|
|
using System.Threading;
|
|
using System.Xml;
|
|
using System.Globalization;
|
|
using System.ServiceModel.Diagnostics.Application;
|
|
|
|
// Please use 'sdv //depot/devdiv/private/indigo_xws/ndp/indigo/src/ServiceModel/System/ServiceModel/Security/SecuritySessionListenerFactory.cs'
|
|
// to see version history before the file was renamed
|
|
// This class is named Settings since the only public APIs are for
|
|
// settings; however, this class also manages all functionality
|
|
// for session channels through internal APIs
|
|
sealed class SecuritySessionServerSettings : IListenerSecureConversationSessionSettings, ISecurityCommunicationObject
|
|
{
|
|
internal const string defaultKeyRenewalIntervalString = "15:00:00";
|
|
internal const string defaultKeyRolloverIntervalString = "00:05:00";
|
|
internal const string defaultInactivityTimeoutString = "00:02:00";
|
|
|
|
internal static readonly TimeSpan defaultKeyRenewalInterval = TimeSpan.Parse(defaultKeyRenewalIntervalString, CultureInfo.InvariantCulture);
|
|
internal static readonly TimeSpan defaultKeyRolloverInterval = TimeSpan.Parse(defaultKeyRolloverIntervalString, CultureInfo.InvariantCulture);
|
|
internal const bool defaultTolerateTransportFailures = true;
|
|
internal const int defaultMaximumPendingSessions = 128;
|
|
internal static readonly TimeSpan defaultInactivityTimeout = TimeSpan.Parse(defaultInactivityTimeoutString, CultureInfo.InvariantCulture);
|
|
|
|
int maximumPendingSessions;
|
|
Dictionary<UniqueId, IServerReliableChannelBinder> pendingSessions1;
|
|
Dictionary<UniqueId, IServerReliableChannelBinder> pendingSessions2;
|
|
IOThreadTimer inactivityTimer;
|
|
TimeSpan inactivityTimeout;
|
|
bool tolerateTransportFailures;
|
|
TimeSpan maximumKeyRenewalInterval;
|
|
TimeSpan keyRolloverInterval;
|
|
int maximumPendingKeysPerSession;
|
|
SecurityProtocolFactory sessionProtocolFactory;
|
|
ICommunicationObject channelAcceptor;
|
|
Dictionary<UniqueId, IServerSecuritySessionChannel> activeSessions;
|
|
ChannelListenerBase securityChannelListener;
|
|
ChannelBuilder channelBuilder;
|
|
SecurityStandardsManager standardsManager;
|
|
SecurityTokenParameters issuedTokenParameters;
|
|
SecurityTokenAuthenticator sessionTokenAuthenticator;
|
|
ISecurityContextSecurityTokenCache sessionTokenCache;
|
|
SecurityTokenResolver sessionTokenResolver;
|
|
WrapperSecurityCommunicationObject communicationObject;
|
|
volatile bool acceptNewWork;
|
|
MessageVersion messageVersion;
|
|
TimeSpan closeTimeout;
|
|
TimeSpan openTimeout;
|
|
TimeSpan sendTimeout;
|
|
Uri listenUri;
|
|
SecurityListenerSettingsLifetimeManager settingsLifetimeManager;
|
|
bool canRenewSession = true;
|
|
object thisLock = new object();
|
|
|
|
public SecuritySessionServerSettings()
|
|
{
|
|
activeSessions = new Dictionary<UniqueId, IServerSecuritySessionChannel>();
|
|
|
|
this.maximumKeyRenewalInterval = defaultKeyRenewalInterval;
|
|
this.maximumPendingKeysPerSession = 5;
|
|
this.keyRolloverInterval = defaultKeyRolloverInterval;
|
|
this.inactivityTimeout = defaultInactivityTimeout;
|
|
this.tolerateTransportFailures = defaultTolerateTransportFailures;
|
|
this.maximumPendingSessions = defaultMaximumPendingSessions;
|
|
this.communicationObject = new WrapperSecurityCommunicationObject(this);
|
|
}
|
|
|
|
internal ChannelBuilder ChannelBuilder
|
|
{
|
|
get
|
|
{
|
|
return this.channelBuilder;
|
|
}
|
|
set
|
|
{
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.channelBuilder = value;
|
|
}
|
|
}
|
|
|
|
internal SecurityListenerSettingsLifetimeManager SettingsLifetimeManager
|
|
{
|
|
get
|
|
{
|
|
return this.settingsLifetimeManager;
|
|
}
|
|
set
|
|
{
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.settingsLifetimeManager = value;
|
|
}
|
|
}
|
|
|
|
internal ChannelListenerBase SecurityChannelListener
|
|
{
|
|
get
|
|
{
|
|
return this.securityChannelListener;
|
|
}
|
|
set
|
|
{
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.securityChannelListener = value;
|
|
}
|
|
}
|
|
|
|
Uri Uri
|
|
{
|
|
get
|
|
{
|
|
this.communicationObject.ThrowIfNotOpened();
|
|
return this.listenUri;
|
|
}
|
|
}
|
|
|
|
object ThisLock
|
|
{
|
|
get
|
|
{
|
|
return this.thisLock;
|
|
}
|
|
}
|
|
|
|
public SecurityTokenAuthenticator SessionTokenAuthenticator
|
|
{
|
|
get
|
|
{
|
|
return this.sessionTokenAuthenticator;
|
|
}
|
|
}
|
|
|
|
public ISecurityContextSecurityTokenCache SessionTokenCache
|
|
{
|
|
get
|
|
{
|
|
return this.sessionTokenCache;
|
|
}
|
|
}
|
|
|
|
public SecurityTokenResolver SessionTokenResolver
|
|
{
|
|
get
|
|
{
|
|
return this.sessionTokenResolver;
|
|
}
|
|
}
|
|
|
|
public SecurityTokenParameters IssuedSecurityTokenParameters
|
|
{
|
|
get
|
|
{
|
|
return this.issuedTokenParameters;
|
|
}
|
|
set
|
|
{
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.issuedTokenParameters = value;
|
|
}
|
|
}
|
|
|
|
public SecurityStandardsManager SecurityStandardsManager
|
|
{
|
|
get
|
|
{
|
|
return this.standardsManager;
|
|
}
|
|
set
|
|
{
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.standardsManager = value;
|
|
}
|
|
}
|
|
|
|
public bool TolerateTransportFailures
|
|
{
|
|
get
|
|
{
|
|
return this.tolerateTransportFailures;
|
|
}
|
|
set
|
|
{
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.tolerateTransportFailures = value;
|
|
}
|
|
}
|
|
|
|
public bool CanRenewSession
|
|
{
|
|
get
|
|
{
|
|
return this.canRenewSession;
|
|
}
|
|
set
|
|
{
|
|
this.canRenewSession = value;
|
|
}
|
|
}
|
|
|
|
public int MaximumPendingSessions
|
|
{
|
|
get
|
|
{
|
|
return this.maximumPendingSessions;
|
|
}
|
|
set
|
|
{
|
|
if (value <= 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
|
|
}
|
|
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.maximumPendingSessions = value;
|
|
}
|
|
}
|
|
|
|
public TimeSpan InactivityTimeout
|
|
{
|
|
get
|
|
{
|
|
return this.inactivityTimeout;
|
|
}
|
|
set
|
|
{
|
|
if (value <= TimeSpan.Zero)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", SR.GetString(SR.TimeSpanMustbeGreaterThanTimeSpanZero)));
|
|
}
|
|
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.inactivityTimeout = value;
|
|
}
|
|
}
|
|
|
|
public TimeSpan MaximumKeyRenewalInterval
|
|
{
|
|
get
|
|
{
|
|
return this.maximumKeyRenewalInterval;
|
|
}
|
|
set
|
|
{
|
|
if (value <= TimeSpan.Zero)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", SR.GetString(SR.TimeSpanMustbeGreaterThanTimeSpanZero)));
|
|
}
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.maximumKeyRenewalInterval = value;
|
|
}
|
|
}
|
|
|
|
public TimeSpan KeyRolloverInterval
|
|
{
|
|
get
|
|
{
|
|
return this.keyRolloverInterval;
|
|
}
|
|
set
|
|
{
|
|
if (value <= TimeSpan.Zero)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", SR.GetString(SR.TimeSpanMustbeGreaterThanTimeSpanZero)));
|
|
}
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.keyRolloverInterval = value;
|
|
}
|
|
}
|
|
|
|
public int MaximumPendingKeysPerSession
|
|
{
|
|
get
|
|
{
|
|
return this.maximumPendingKeysPerSession;
|
|
}
|
|
set
|
|
{
|
|
if (value <= 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", SR.GetString(SR.ValueMustBeGreaterThanZero)));
|
|
}
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.maximumPendingKeysPerSession = value;
|
|
}
|
|
}
|
|
|
|
public SecurityProtocolFactory SessionProtocolFactory
|
|
{
|
|
get
|
|
{
|
|
return this.sessionProtocolFactory;
|
|
}
|
|
set
|
|
{
|
|
this.communicationObject.ThrowIfDisposedOrImmutable();
|
|
this.sessionProtocolFactory = value;
|
|
}
|
|
}
|
|
|
|
public MessageVersion MessageVersion
|
|
{
|
|
get
|
|
{
|
|
return this.messageVersion;
|
|
}
|
|
}
|
|
|
|
public TimeSpan OpenTimeout
|
|
{
|
|
get
|
|
{
|
|
return this.openTimeout;
|
|
}
|
|
}
|
|
|
|
public TimeSpan CloseTimeout
|
|
{
|
|
get
|
|
{
|
|
return this.closeTimeout;
|
|
}
|
|
}
|
|
|
|
public TimeSpan SendTimeout
|
|
{
|
|
get
|
|
{
|
|
return this.sendTimeout;
|
|
}
|
|
}
|
|
|
|
|
|
// ISecurityCommunicationObject members
|
|
public TimeSpan DefaultOpenTimeout
|
|
{
|
|
get { return ServiceDefaults.OpenTimeout; }
|
|
}
|
|
|
|
public TimeSpan DefaultCloseTimeout
|
|
{
|
|
get { return ServiceDefaults.CloseTimeout; }
|
|
}
|
|
|
|
public IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new OperationWithTimeoutAsyncResult(new OperationWithTimeoutCallback(this.OnClose), timeout, callback, state);
|
|
}
|
|
|
|
public IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new OperationWithTimeoutAsyncResult(new OperationWithTimeoutCallback(this.OnOpen), timeout, callback, state);
|
|
}
|
|
|
|
public void OnClosed()
|
|
{
|
|
}
|
|
|
|
public void OnClosing()
|
|
{
|
|
}
|
|
|
|
public void OnEndClose(IAsyncResult result)
|
|
{
|
|
OperationWithTimeoutAsyncResult.End(result);
|
|
}
|
|
|
|
public void OnEndOpen(IAsyncResult result)
|
|
{
|
|
OperationWithTimeoutAsyncResult.End(result);
|
|
}
|
|
|
|
public void OnFaulted()
|
|
{
|
|
}
|
|
|
|
public void OnOpened()
|
|
{
|
|
}
|
|
|
|
public void OnOpening()
|
|
{
|
|
}
|
|
|
|
public void OnAbort()
|
|
{
|
|
this.AbortPendingChannels();
|
|
this.OnAbortCore();
|
|
}
|
|
|
|
public void OnClose(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
this.ClosePendingChannels(timeoutHelper.RemainingTime());
|
|
this.OnCloseCore(timeoutHelper.RemainingTime());
|
|
}
|
|
|
|
internal void Close(TimeSpan timeout)
|
|
{
|
|
this.communicationObject.Close(timeout);
|
|
}
|
|
|
|
internal IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return this.communicationObject.BeginClose(timeout, callback, state);
|
|
}
|
|
|
|
internal void EndClose(IAsyncResult result)
|
|
{
|
|
this.communicationObject.EndClose(result);
|
|
}
|
|
|
|
internal void Abort()
|
|
{
|
|
this.communicationObject.Abort();
|
|
}
|
|
|
|
internal void Open(TimeSpan timeout)
|
|
{
|
|
this.communicationObject.Open(timeout);
|
|
}
|
|
|
|
internal IAsyncResult BeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return this.communicationObject.BeginOpen(timeout, callback, state);
|
|
}
|
|
|
|
internal void EndOpen(IAsyncResult result)
|
|
{
|
|
this.communicationObject.EndOpen(result);
|
|
}
|
|
|
|
void OnCloseCore(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
if (this.inactivityTimer != null)
|
|
{
|
|
this.inactivityTimer.Cancel();
|
|
}
|
|
if (this.sessionProtocolFactory != null)
|
|
{
|
|
this.sessionProtocolFactory.Close(false, timeoutHelper.RemainingTime());
|
|
}
|
|
if (this.sessionTokenAuthenticator != null)
|
|
{
|
|
SecurityUtils.CloseTokenAuthenticatorIfRequired(this.sessionTokenAuthenticator, timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
|
|
void OnAbortCore()
|
|
{
|
|
if (this.inactivityTimer != null)
|
|
{
|
|
this.inactivityTimer.Cancel();
|
|
}
|
|
if (this.sessionProtocolFactory != null)
|
|
{
|
|
this.sessionProtocolFactory.Close(true, TimeSpan.Zero);
|
|
}
|
|
if (this.sessionTokenAuthenticator != null)
|
|
{
|
|
SecurityUtils.AbortTokenAuthenticatorIfRequired(this.sessionTokenAuthenticator);
|
|
}
|
|
}
|
|
|
|
void SetupSessionTokenAuthenticator()
|
|
{
|
|
RecipientServiceModelSecurityTokenRequirement requirement = new RecipientServiceModelSecurityTokenRequirement();
|
|
this.issuedTokenParameters.InitializeSecurityTokenRequirement(requirement);
|
|
requirement.KeyUsage = SecurityKeyUsage.Signature;
|
|
requirement.ListenUri = this.listenUri;
|
|
requirement.SecurityBindingElement = this.sessionProtocolFactory.SecurityBindingElement;
|
|
requirement.SecurityAlgorithmSuite = this.sessionProtocolFactory.IncomingAlgorithmSuite;
|
|
requirement.SupportSecurityContextCancellation = true;
|
|
requirement.MessageSecurityVersion = sessionProtocolFactory.MessageSecurityVersion.SecurityTokenVersion;
|
|
requirement.AuditLogLocation = sessionProtocolFactory.AuditLogLocation;
|
|
requirement.SuppressAuditFailure = sessionProtocolFactory.SuppressAuditFailure;
|
|
requirement.MessageAuthenticationAuditLevel = sessionProtocolFactory.MessageAuthenticationAuditLevel;
|
|
requirement.Properties[ServiceModelSecurityTokenRequirement.MessageDirectionProperty] = MessageDirection.Input;
|
|
if (sessionProtocolFactory.EndpointFilterTable != null)
|
|
{
|
|
requirement.Properties[ServiceModelSecurityTokenRequirement.EndpointFilterTableProperty] = sessionProtocolFactory.EndpointFilterTable;
|
|
}
|
|
this.sessionTokenAuthenticator = this.sessionProtocolFactory.SecurityTokenManager.CreateSecurityTokenAuthenticator(requirement, out this.sessionTokenResolver);
|
|
if (!(this.sessionTokenAuthenticator is IIssuanceSecurityTokenAuthenticator))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SecuritySessionRequiresIssuanceAuthenticator, typeof(IIssuanceSecurityTokenAuthenticator), this.sessionTokenAuthenticator.GetType())));
|
|
}
|
|
if (sessionTokenResolver == null || (!(sessionTokenResolver is ISecurityContextSecurityTokenCache)))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SecuritySessionRequiresSecurityContextTokenCache, this.sessionTokenResolver.GetType(), typeof(ISecurityContextSecurityTokenCache))));
|
|
}
|
|
this.sessionTokenCache = (ISecurityContextSecurityTokenCache)this.sessionTokenResolver;
|
|
}
|
|
|
|
|
|
public void OnOpen(TimeSpan timeout)
|
|
{
|
|
if (this.sessionProtocolFactory == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SecuritySessionProtocolFactoryShouldBeSetBeforeThisOperation)));
|
|
}
|
|
if (this.standardsManager == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SecurityStandardsManagerNotSet, this.GetType())));
|
|
}
|
|
if (this.issuedTokenParameters == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.IssuedSecurityTokenParametersNotSet, this.GetType())));
|
|
}
|
|
if (this.maximumKeyRenewalInterval < this.keyRolloverInterval)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.KeyRolloverGreaterThanKeyRenewal)));
|
|
}
|
|
if (this.securityChannelListener == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SecurityChannelListenerNotSet, this.GetType())));
|
|
}
|
|
if (this.settingsLifetimeManager == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SecuritySettingsLifetimeManagerNotSet, this.GetType())));
|
|
}
|
|
|
|
this.messageVersion = this.channelBuilder.Binding.MessageVersion;
|
|
this.listenUri = this.securityChannelListener.Uri;
|
|
this.openTimeout = this.securityChannelListener.InternalOpenTimeout;
|
|
this.closeTimeout = this.securityChannelListener.InternalCloseTimeout;
|
|
this.sendTimeout = this.securityChannelListener.InternalSendTimeout;
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
this.pendingSessions1 = new Dictionary<UniqueId, IServerReliableChannelBinder>();
|
|
this.pendingSessions2 = new Dictionary<UniqueId, IServerReliableChannelBinder>();
|
|
if (this.inactivityTimeout < TimeSpan.MaxValue)
|
|
{
|
|
this.inactivityTimer = new IOThreadTimer(new Action<object>(this.OnTimer), this, false);
|
|
this.inactivityTimer.Set(this.inactivityTimeout);
|
|
}
|
|
this.ConfigureSessionSecurityProtocolFactory();
|
|
this.sessionProtocolFactory.Open(false, timeoutHelper.RemainingTime());
|
|
SetupSessionTokenAuthenticator();
|
|
((IIssuanceSecurityTokenAuthenticator)this.sessionTokenAuthenticator).IssuedSecurityTokenHandler = this.OnTokenIssued;
|
|
((IIssuanceSecurityTokenAuthenticator)this.sessionTokenAuthenticator).RenewedSecurityTokenHandler = this.OnTokenRenewed;
|
|
this.acceptNewWork = true;
|
|
SecurityUtils.OpenTokenAuthenticatorIfRequired(this.sessionTokenAuthenticator, timeoutHelper.RemainingTime());
|
|
}
|
|
|
|
public void StopAcceptingNewWork()
|
|
{
|
|
this.acceptNewWork = false;
|
|
}
|
|
|
|
int GetPendingSessionCount()
|
|
{
|
|
return this.pendingSessions1.Count + this.pendingSessions2.Count + ((IInputQueueChannelAcceptor)this.channelAcceptor).PendingCount;
|
|
}
|
|
|
|
void AbortPendingChannels()
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (this.pendingSessions1 != null)
|
|
{
|
|
foreach (IServerReliableChannelBinder pendingChannelBinder in pendingSessions1.Values)
|
|
{
|
|
pendingChannelBinder.Abort();
|
|
}
|
|
}
|
|
if (this.pendingSessions2 != null)
|
|
{
|
|
foreach (IServerReliableChannelBinder pendingChannelBinder in pendingSessions2.Values)
|
|
{
|
|
pendingChannelBinder.Abort();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ClosePendingChannels(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
lock (ThisLock)
|
|
{
|
|
foreach (IServerReliableChannelBinder pendingChannelBinder in pendingSessions1.Values)
|
|
{
|
|
pendingChannelBinder.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
foreach (IServerReliableChannelBinder pendingChannelBinder in pendingSessions2.Values)
|
|
{
|
|
pendingChannelBinder.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
}
|
|
|
|
void ConfigureSessionSecurityProtocolFactory()
|
|
{
|
|
if (this.sessionProtocolFactory is SessionSymmetricMessageSecurityProtocolFactory)
|
|
{
|
|
AddressingVersion addressing = MessageVersion.Default.Addressing;
|
|
if (this.channelBuilder != null)
|
|
{
|
|
MessageEncodingBindingElement encoding = this.channelBuilder.Binding.Elements.Find<MessageEncodingBindingElement>();
|
|
if (encoding != null)
|
|
{
|
|
addressing = encoding.MessageVersion.Addressing;
|
|
}
|
|
}
|
|
|
|
if (addressing != AddressingVersion.WSAddressing10 && addressing != AddressingVersion.WSAddressingAugust2004)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new ProtocolException(SR.GetString(SR.AddressingVersionNotSupported, addressing)));
|
|
}
|
|
|
|
SessionSymmetricMessageSecurityProtocolFactory messagePf = (SessionSymmetricMessageSecurityProtocolFactory)this.sessionProtocolFactory;
|
|
if (!messagePf.ApplyIntegrity || !messagePf.RequireIntegrity)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SecuritySessionRequiresMessageIntegrity)));
|
|
}
|
|
MessagePartSpecification bodyPart = new MessagePartSpecification(true);
|
|
messagePf.ProtectionRequirements.IncomingSignatureParts.AddParts(bodyPart, this.SecurityStandardsManager.SecureConversationDriver.CloseAction);
|
|
messagePf.ProtectionRequirements.IncomingSignatureParts.AddParts(bodyPart, this.SecurityStandardsManager.SecureConversationDriver.CloseResponseAction);
|
|
messagePf.ProtectionRequirements.OutgoingSignatureParts.AddParts(bodyPart, this.SecurityStandardsManager.SecureConversationDriver.CloseResponseAction);
|
|
messagePf.ProtectionRequirements.OutgoingSignatureParts.AddParts(bodyPart, this.SecurityStandardsManager.SecureConversationDriver.CloseAction);
|
|
messagePf.ProtectionRequirements.OutgoingSignatureParts.AddParts(bodyPart, addressing.FaultAction);
|
|
messagePf.ProtectionRequirements.OutgoingSignatureParts.AddParts(bodyPart, addressing.DefaultFaultAction);
|
|
messagePf.ProtectionRequirements.OutgoingSignatureParts.AddParts(bodyPart, DotNetSecurityStrings.SecuritySessionFaultAction);
|
|
if (messagePf.ApplyConfidentiality)
|
|
{
|
|
messagePf.ProtectionRequirements.OutgoingEncryptionParts.AddParts(MessagePartSpecification.NoParts, this.SecurityStandardsManager.SecureConversationDriver.CloseResponseAction);
|
|
messagePf.ProtectionRequirements.OutgoingEncryptionParts.AddParts(MessagePartSpecification.NoParts, this.SecurityStandardsManager.SecureConversationDriver.CloseAction);
|
|
messagePf.ProtectionRequirements.OutgoingEncryptionParts.AddParts(bodyPart, addressing.FaultAction);
|
|
messagePf.ProtectionRequirements.OutgoingEncryptionParts.AddParts(bodyPart, addressing.DefaultFaultAction);
|
|
messagePf.ProtectionRequirements.OutgoingEncryptionParts.AddParts(bodyPart, DotNetSecurityStrings.SecuritySessionFaultAction);
|
|
}
|
|
if (messagePf.RequireConfidentiality)
|
|
{
|
|
messagePf.ProtectionRequirements.IncomingEncryptionParts.AddParts(MessagePartSpecification.NoParts, this.SecurityStandardsManager.SecureConversationDriver.CloseAction);
|
|
messagePf.ProtectionRequirements.IncomingEncryptionParts.AddParts(MessagePartSpecification.NoParts, this.SecurityStandardsManager.SecureConversationDriver.CloseResponseAction);
|
|
}
|
|
messagePf.SecurityTokenParameters = this.IssuedSecurityTokenParameters;
|
|
}
|
|
else if (this.sessionProtocolFactory is SessionSymmetricTransportSecurityProtocolFactory)
|
|
{
|
|
SessionSymmetricTransportSecurityProtocolFactory transportPf = (SessionSymmetricTransportSecurityProtocolFactory)this.sessionProtocolFactory;
|
|
transportPf.AddTimestamp = true;
|
|
transportPf.SecurityTokenParameters = this.IssuedSecurityTokenParameters;
|
|
transportPf.SecurityTokenParameters.RequireDerivedKeys = false;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
|
|
}
|
|
}
|
|
|
|
internal IChannelAcceptor<TChannel> CreateAcceptor<TChannel>()
|
|
where TChannel : class, IChannel
|
|
{
|
|
if (this.channelAcceptor != null)
|
|
{
|
|
Fx.Assert("SecuritySessionServerSettings.CreateAcceptor (this.channelAcceptor != null)");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SSSSCreateAcceptor)));
|
|
}
|
|
object listenerSecurityState = this.sessionProtocolFactory.CreateListenerSecurityState();
|
|
if (typeof(TChannel) == typeof(IReplySessionChannel))
|
|
{
|
|
this.channelAcceptor = new SecuritySessionChannelAcceptor<IReplySessionChannel>(this.SecurityChannelListener, listenerSecurityState);
|
|
}
|
|
else if (typeof(TChannel) == typeof(IDuplexSessionChannel))
|
|
{
|
|
this.channelAcceptor = new SecuritySessionChannelAcceptor<IDuplexSessionChannel>(this.SecurityChannelListener, listenerSecurityState);
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
|
|
}
|
|
return (IChannelAcceptor<TChannel>)this.channelAcceptor;
|
|
}
|
|
|
|
internal IChannelListener CreateInnerChannelListener()
|
|
{
|
|
if (this.ChannelBuilder.CanBuildChannelListener<IDuplexSessionChannel>())
|
|
{
|
|
return this.ChannelBuilder.BuildChannelListener<IDuplexSessionChannel>(new MatchNoneMessageFilter(), int.MinValue);
|
|
}
|
|
else if (this.ChannelBuilder.CanBuildChannelListener<IDuplexChannel>())
|
|
{
|
|
return this.ChannelBuilder.BuildChannelListener<IDuplexChannel>(new MatchNoneMessageFilter(), int.MinValue);
|
|
}
|
|
else if (this.ChannelBuilder.CanBuildChannelListener<IReplyChannel>())
|
|
{
|
|
return this.ChannelBuilder.BuildChannelListener<IReplyChannel>(new MatchNoneMessageFilter(), int.MinValue);
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
|
|
}
|
|
}
|
|
|
|
void OnTokenRenewed(SecurityToken newToken, SecurityToken oldToken)
|
|
{
|
|
this.communicationObject.ThrowIfClosed();
|
|
if (!this.acceptNewWork)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new EndpointNotFoundException(SR.GetString(SR.SecurityListenerClosing)));
|
|
}
|
|
SecurityContextSecurityToken newSecurityContextToken = newToken as SecurityContextSecurityToken;
|
|
if (newSecurityContextToken == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.SessionTokenIsNotSecurityContextToken, newToken.GetType(), typeof(SecurityContextSecurityToken))));
|
|
}
|
|
SecurityContextSecurityToken oldSecurityContextToken = oldToken as SecurityContextSecurityToken;
|
|
if (oldSecurityContextToken == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.SessionTokenIsNotSecurityContextToken, oldToken.GetType(), typeof(SecurityContextSecurityToken))));
|
|
}
|
|
IServerSecuritySessionChannel sessionChannel = this.FindSessionChannel(newSecurityContextToken.ContextId);
|
|
if (sessionChannel == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new MessageSecurityException(SR.GetString(SR.CannotFindSecuritySession, newSecurityContextToken.ContextId)));
|
|
}
|
|
sessionChannel.RenewSessionToken(newSecurityContextToken, oldSecurityContextToken);
|
|
}
|
|
|
|
IServerReliableChannelBinder CreateChannelBinder(SecurityContextSecurityToken sessionToken, EndpointAddress remoteAddress)
|
|
{
|
|
IServerReliableChannelBinder result = null;
|
|
MessageFilter sctFilter = new SecuritySessionFilter(sessionToken.ContextId, this.sessionProtocolFactory.StandardsManager, (this.sessionProtocolFactory.SecurityHeaderLayout == SecurityHeaderLayout.Strict), this.SecurityStandardsManager.SecureConversationDriver.RenewAction.Value, this.SecurityStandardsManager.SecureConversationDriver.RenewResponseAction.Value);
|
|
int sctPriority = Int32.MaxValue;
|
|
TolerateFaultsMode faultMode = this.TolerateTransportFailures ? TolerateFaultsMode.Always : TolerateFaultsMode.Never;
|
|
lock (ThisLock)
|
|
{
|
|
if (this.ChannelBuilder.CanBuildChannelListener<IDuplexSessionChannel>())
|
|
{
|
|
result = ServerReliableChannelBinder<IDuplexSessionChannel>.CreateBinder(this.ChannelBuilder, remoteAddress, sctFilter, sctPriority, faultMode,
|
|
this.CloseTimeout, this.SendTimeout);
|
|
}
|
|
else if (this.ChannelBuilder.CanBuildChannelListener<IDuplexChannel>())
|
|
{
|
|
result = ServerReliableChannelBinder<IDuplexChannel>.CreateBinder(this.ChannelBuilder, remoteAddress, sctFilter, sctPriority, faultMode,
|
|
this.CloseTimeout, this.SendTimeout);
|
|
}
|
|
else if (this.ChannelBuilder.CanBuildChannelListener<IReplyChannel>())
|
|
{
|
|
result = ServerReliableChannelBinder<IReplyChannel>.CreateBinder(this.ChannelBuilder, remoteAddress, sctFilter, sctPriority, faultMode,
|
|
this.CloseTimeout, this.SendTimeout);
|
|
}
|
|
}
|
|
if (result == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
|
|
}
|
|
|
|
result.Open(this.OpenTimeout);
|
|
SessionInitiationMessageHandler handler = new SessionInitiationMessageHandler(result, this, sessionToken);
|
|
handler.BeginReceive(TimeSpan.MaxValue);
|
|
return result;
|
|
}
|
|
|
|
void OnTokenIssued(SecurityToken issuedToken, EndpointAddress tokenRequestor)
|
|
{
|
|
this.communicationObject.ThrowIfClosed();
|
|
if (!this.acceptNewWork)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new EndpointNotFoundException(SR.GetString(SR.SecurityListenerClosing)));
|
|
}
|
|
SecurityContextSecurityToken issuedSecurityContextToken = issuedToken as SecurityContextSecurityToken;
|
|
if (issuedSecurityContextToken == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.SessionTokenIsNotSecurityContextToken, issuedToken.GetType(), typeof(SecurityContextSecurityToken))));
|
|
}
|
|
IServerReliableChannelBinder channelBinder = CreateChannelBinder(issuedSecurityContextToken, tokenRequestor ?? EndpointAddress.AnonymousAddress);
|
|
bool wasSessionAdded = false;
|
|
try
|
|
{
|
|
this.AddPendingSession(issuedSecurityContextToken.ContextId, channelBinder);
|
|
wasSessionAdded = true;
|
|
}
|
|
finally
|
|
{
|
|
if (!wasSessionAdded)
|
|
{
|
|
channelBinder.Abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnTimer(object state)
|
|
{
|
|
if (this.communicationObject.State == CommunicationState.Closed
|
|
|| this.communicationObject.State == CommunicationState.Faulted)
|
|
{
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
this.ClearPendingSessions();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (this.communicationObject.State != CommunicationState.Closed
|
|
&& this.communicationObject.State != CommunicationState.Closing
|
|
&& this.communicationObject.State != CommunicationState.Faulted)
|
|
{
|
|
this.inactivityTimer.Set(this.inactivityTimeout);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AddPendingSession(UniqueId sessionId, IServerReliableChannelBinder channelBinder)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if ((GetPendingSessionCount() + 1) > this.MaximumPendingSessions)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QuotaExceededException(SR.GetString(SR.SecuritySessionLimitReached)));
|
|
}
|
|
if (this.pendingSessions1.ContainsKey(sessionId) || this.pendingSessions2.ContainsKey(sessionId))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new MessageSecurityException(SR.GetString(SR.SecuritySessionAlreadyPending, sessionId)));
|
|
}
|
|
this.pendingSessions1.Add(sessionId, channelBinder);
|
|
}
|
|
SecurityTraceRecordHelper.TracePendingSessionAdded(sessionId, this.Uri);
|
|
if (TD.SecuritySessionRatioIsEnabled())
|
|
{
|
|
TD.SecuritySessionRatio(GetPendingSessionCount(), this.MaximumPendingSessions);
|
|
}
|
|
}
|
|
|
|
void TryCloseBinder(IServerReliableChannelBinder binder, TimeSpan timeout)
|
|
{
|
|
bool abortBinder = false;
|
|
try
|
|
{
|
|
binder.Close(timeout);
|
|
}
|
|
catch (CommunicationException e)
|
|
{
|
|
abortBinder = true;
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
abortBinder = true;
|
|
|
|
if (TD.CloseTimeoutIsEnabled())
|
|
{
|
|
TD.CloseTimeout(e.Message);
|
|
}
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
|
}
|
|
finally
|
|
{
|
|
if (abortBinder)
|
|
{
|
|
binder.Abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
// this method should be called by the timer under ThisLock
|
|
void ClearPendingSessions()
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (this.pendingSessions1.Count == 0 && this.pendingSessions2.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
foreach (UniqueId sessionId in this.pendingSessions2.Keys)
|
|
{
|
|
IServerReliableChannelBinder channelBinder = this.pendingSessions2[sessionId];
|
|
try
|
|
{
|
|
TryCloseBinder(channelBinder, this.CloseTimeout);
|
|
this.SessionTokenCache.RemoveAllContexts(sessionId);
|
|
}
|
|
catch (CommunicationException e)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
if (TD.CloseTimeoutIsEnabled())
|
|
{
|
|
TD.CloseTimeout(e.Message);
|
|
}
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
|
}
|
|
catch (ObjectDisposedException e)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
|
}
|
|
SecurityTraceRecordHelper.TracePendingSessionClosed(sessionId, this.Uri);
|
|
}
|
|
this.pendingSessions2.Clear();
|
|
Dictionary<UniqueId, IServerReliableChannelBinder> temp = this.pendingSessions2;
|
|
this.pendingSessions2 = this.pendingSessions1;
|
|
this.pendingSessions1 = temp;
|
|
}
|
|
}
|
|
|
|
bool RemovePendingSession(UniqueId sessionId)
|
|
{
|
|
bool result;
|
|
lock (ThisLock)
|
|
{
|
|
if (this.pendingSessions1.ContainsKey(sessionId))
|
|
{
|
|
this.pendingSessions1.Remove(sessionId);
|
|
result = true;
|
|
}
|
|
else if (pendingSessions2.ContainsKey(sessionId))
|
|
{
|
|
this.pendingSessions2.Remove(sessionId);
|
|
result = true;
|
|
}
|
|
else
|
|
{
|
|
result = false;
|
|
}
|
|
}
|
|
if (result)
|
|
{
|
|
SecurityTraceRecordHelper.TracePendingSessionActivated(sessionId, this.Uri);
|
|
if (TD.SecuritySessionRatioIsEnabled())
|
|
{
|
|
TD.SecuritySessionRatio(GetPendingSessionCount(), this.MaximumPendingSessions);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
IServerSecuritySessionChannel FindSessionChannel(UniqueId sessionId)
|
|
{
|
|
IServerSecuritySessionChannel result;
|
|
lock (ThisLock)
|
|
{
|
|
this.activeSessions.TryGetValue(sessionId, out result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void AddSessionChannel(UniqueId sessionId, IServerSecuritySessionChannel channel)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
this.activeSessions.Add(sessionId, channel);
|
|
}
|
|
}
|
|
|
|
void RemoveSessionChannel(string sessionId)
|
|
{
|
|
RemoveSessionChannel(new UniqueId(sessionId));
|
|
}
|
|
|
|
void RemoveSessionChannel(UniqueId sessionId)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
this.activeSessions.Remove(sessionId);
|
|
}
|
|
SecurityTraceRecordHelper.TraceActiveSessionRemoved(sessionId, this.Uri);
|
|
}
|
|
|
|
class SessionInitiationMessageHandler
|
|
{
|
|
static AsyncCallback receiveCallback = Fx.ThunkCallback(new AsyncCallback(ReceiveCallback));
|
|
IServerReliableChannelBinder channelBinder;
|
|
SecuritySessionServerSettings settings;
|
|
SecurityContextSecurityToken sessionToken;
|
|
bool processedInitiation = false;
|
|
|
|
public SessionInitiationMessageHandler(IServerReliableChannelBinder channelBinder, SecuritySessionServerSettings settings, SecurityContextSecurityToken sessionToken)
|
|
{
|
|
this.channelBinder = channelBinder;
|
|
this.settings = settings;
|
|
this.sessionToken = sessionToken;
|
|
}
|
|
|
|
public IAsyncResult BeginReceive(TimeSpan timeout)
|
|
{
|
|
return this.channelBinder.BeginTryReceive(timeout, receiveCallback, this);
|
|
}
|
|
|
|
public void ProcessMessage(IAsyncResult result)
|
|
{
|
|
bool threwException = false;
|
|
try
|
|
{
|
|
RequestContext requestContext;
|
|
if (!this.channelBinder.EndTryReceive(result, out requestContext))
|
|
{
|
|
// we should never have timed out since the receive was called with an Infinite timeout
|
|
// if we did then do a BeginReceive and return
|
|
this.BeginReceive(TimeSpan.MaxValue);
|
|
return;
|
|
}
|
|
|
|
if (requestContext == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Message message = requestContext.RequestMessage;
|
|
lock (this.settings.ThisLock)
|
|
{
|
|
if (this.settings.communicationObject.State != CommunicationState.Opened)
|
|
{
|
|
((IDisposable)requestContext).Dispose();
|
|
return;
|
|
}
|
|
if (this.processedInitiation)
|
|
{
|
|
return;
|
|
}
|
|
this.processedInitiation = true;
|
|
}
|
|
if (!this.settings.RemovePendingSession(this.sessionToken.ContextId))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new CommunicationException(SR.GetString(SR.SecuritySessionNotPending, this.sessionToken.ContextId)));
|
|
}
|
|
if (this.settings.channelAcceptor is SecuritySessionChannelAcceptor<IReplySessionChannel>)
|
|
{
|
|
SecuritySessionChannelAcceptor<IReplySessionChannel> replyAcceptor = ((SecuritySessionChannelAcceptor<IReplySessionChannel>)this.settings.channelAcceptor);
|
|
SecurityReplySessionChannel replySessionChannel = new SecurityReplySessionChannel(this.settings,
|
|
this.channelBinder,
|
|
sessionToken,
|
|
replyAcceptor.ListenerSecurityState,
|
|
this.settings.SettingsLifetimeManager);
|
|
settings.AddSessionChannel(this.sessionToken.ContextId, replySessionChannel);
|
|
replySessionChannel.StartReceiving(requestContext);
|
|
replyAcceptor.EnqueueAndDispatch(replySessionChannel);
|
|
}
|
|
else if (this.settings.channelAcceptor is SecuritySessionChannelAcceptor<IDuplexSessionChannel>)
|
|
{
|
|
SecuritySessionChannelAcceptor<IDuplexSessionChannel> duplexAcceptor = ((SecuritySessionChannelAcceptor<IDuplexSessionChannel>)this.settings.channelAcceptor);
|
|
ServerSecurityDuplexSessionChannel duplexSessionChannel = new ServerSecurityDuplexSessionChannel(this.settings,
|
|
this.channelBinder,
|
|
sessionToken,
|
|
duplexAcceptor.ListenerSecurityState,
|
|
this.settings.SettingsLifetimeManager);
|
|
settings.AddSessionChannel(this.sessionToken.ContextId, duplexSessionChannel);
|
|
duplexSessionChannel.StartReceiving(requestContext);
|
|
duplexAcceptor.EnqueueAndDispatch(duplexSessionChannel);
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new EndpointNotFoundException(SR.GetString(SR.SecuritySessionListenerNotFound, message.Headers.Action)));
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
threwException = true;
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
|
}
|
|
finally
|
|
{
|
|
if (threwException)
|
|
{
|
|
this.channelBinder.Abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ReceiveCallback(IAsyncResult result)
|
|
{
|
|
((SessionInitiationMessageHandler)result.AsyncState).ProcessMessage(result);
|
|
}
|
|
}
|
|
|
|
interface IInputQueueChannelAcceptor
|
|
{
|
|
int PendingCount { get; }
|
|
}
|
|
|
|
class SecuritySessionChannelAcceptor<T> : InputQueueChannelAcceptor<T>, IInputQueueChannelAcceptor
|
|
where T : class, IChannel
|
|
{
|
|
object listenerState;
|
|
|
|
public SecuritySessionChannelAcceptor(ChannelListenerBase manager, object listenerState)
|
|
: base(manager)
|
|
{
|
|
this.listenerState = listenerState;
|
|
}
|
|
|
|
public object ListenerSecurityState
|
|
{
|
|
get
|
|
{
|
|
return this.listenerState;
|
|
}
|
|
}
|
|
|
|
int IInputQueueChannelAcceptor.PendingCount
|
|
{
|
|
get { return this.PendingCount; }
|
|
}
|
|
}
|
|
|
|
interface IServerSecuritySessionChannel
|
|
{
|
|
void RenewSessionToken(SecurityContextSecurityToken newToken, SecurityContextSecurityToken supportingToken);
|
|
}
|
|
|
|
abstract class ServerSecuritySessionChannel : ChannelBase, IServerSecuritySessionChannel
|
|
{
|
|
FaultCode renewFaultCode;
|
|
FaultReason renewFaultReason;
|
|
FaultCode sessionAbortedFaultCode;
|
|
FaultReason sessionAbortedFaultReason;
|
|
|
|
// Double-checked locking pattern requires volatile for read/write synchronization
|
|
volatile bool areFaultCodesInitialized;
|
|
IServerReliableChannelBinder channelBinder;
|
|
SecurityProtocol securityProtocol;
|
|
// This is used to sign outgoing messages
|
|
SecurityContextSecurityToken currentSessionToken;
|
|
UniqueId sessionId;
|
|
// These are renewed tokens that have not been used as yet
|
|
List<SecurityContextSecurityToken> futureSessionTokens;
|
|
SecuritySessionServerSettings settings;
|
|
RequestContext initialRequestContext;
|
|
volatile bool isInputClosed;
|
|
ThreadNeutralSemaphore receiveLock;
|
|
MessageVersion messageVersion;
|
|
SecurityListenerSettingsLifetimeManager settingsLifetimeManager;
|
|
volatile bool hasSecurityStateReference;
|
|
|
|
protected ServerSecuritySessionChannel(SecuritySessionServerSettings settings,
|
|
IServerReliableChannelBinder channelBinder,
|
|
SecurityContextSecurityToken sessionToken,
|
|
object listenerSecurityProtocolState,
|
|
SecurityListenerSettingsLifetimeManager settingsLifetimeManager)
|
|
: base(settings.SecurityChannelListener)
|
|
{
|
|
this.settings = settings;
|
|
this.channelBinder = channelBinder;
|
|
this.messageVersion = settings.MessageVersion;
|
|
this.channelBinder.Faulted += this.OnInnerFaulted;
|
|
this.securityProtocol = this.Settings.SessionProtocolFactory.CreateSecurityProtocol(null, null, listenerSecurityProtocolState, true, TimeSpan.Zero);
|
|
if (!(this.securityProtocol is IAcceptorSecuritySessionProtocol))
|
|
{
|
|
Fx.Assert("Security protocol must be IAcceptorSecuritySessionProtocol.");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ProtocolMisMatch, "IAcceptorSecuritySessionProtocol", this.GetType().ToString())));
|
|
}
|
|
this.currentSessionToken = sessionToken;
|
|
this.sessionId = sessionToken.ContextId;
|
|
this.futureSessionTokens = new List<SecurityContextSecurityToken>(1);
|
|
((IAcceptorSecuritySessionProtocol)this.securityProtocol).SetOutgoingSessionToken(sessionToken);
|
|
((IAcceptorSecuritySessionProtocol)this.securityProtocol).SetSessionTokenAuthenticator(this.sessionId, this.settings.SessionTokenAuthenticator, this.settings.SessionTokenResolver);
|
|
this.settingsLifetimeManager = settingsLifetimeManager;
|
|
this.receiveLock = new ThreadNeutralSemaphore(1);
|
|
}
|
|
|
|
protected SecuritySessionServerSettings Settings
|
|
{
|
|
get
|
|
{
|
|
return this.settings;
|
|
}
|
|
}
|
|
|
|
protected virtual bool CanDoSecurityCorrelation
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal IServerReliableChannelBinder ChannelBinder
|
|
{
|
|
get
|
|
{
|
|
return this.channelBinder;
|
|
}
|
|
}
|
|
|
|
internal TimeSpan InternalSendTimeout
|
|
{
|
|
get
|
|
{
|
|
return this.DefaultSendTimeout;
|
|
}
|
|
}
|
|
|
|
public EndpointAddress LocalAddress
|
|
{
|
|
get
|
|
{
|
|
return this.channelBinder.LocalAddress;
|
|
}
|
|
}
|
|
|
|
protected override void OnOpen(TimeSpan timeout)
|
|
{
|
|
this.securityProtocol.Open(timeout);
|
|
if (this.CanDoSecurityCorrelation)
|
|
{
|
|
((IAcceptorSecuritySessionProtocol)this.securityProtocol).ReturnCorrelationState = true;
|
|
}
|
|
lock (ThisLock)
|
|
{
|
|
// if an abort happened concurrently with the open, then return
|
|
if (this.State == CommunicationState.Closed || this.State == CommunicationState.Closing)
|
|
{
|
|
return;
|
|
}
|
|
this.settingsLifetimeManager.AddReference();
|
|
this.hasSecurityStateReference = true;
|
|
}
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
OnOpen(timeout);
|
|
return new CompletedAsyncResult(callback, state);
|
|
}
|
|
|
|
protected override void OnEndOpen(IAsyncResult result)
|
|
{
|
|
CompletedAsyncResult.End(result);
|
|
}
|
|
|
|
protected virtual void AbortCore()
|
|
{
|
|
if (this.channelBinder != null)
|
|
{
|
|
this.channelBinder.Abort();
|
|
}
|
|
if (this.securityProtocol != null)
|
|
{
|
|
this.securityProtocol.Close(true, TimeSpan.Zero);
|
|
}
|
|
this.Settings.SessionTokenCache.RemoveAllContexts(this.currentSessionToken.ContextId);
|
|
bool abortLifetimeManager = false;
|
|
lock (ThisLock)
|
|
{
|
|
if (hasSecurityStateReference)
|
|
{
|
|
abortLifetimeManager = true;
|
|
hasSecurityStateReference = false;
|
|
}
|
|
}
|
|
if (abortLifetimeManager)
|
|
{
|
|
this.settingsLifetimeManager.Abort();
|
|
}
|
|
}
|
|
|
|
protected virtual void CloseCore(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
|
|
try
|
|
{
|
|
if (this.channelBinder != null)
|
|
{
|
|
this.channelBinder.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
if (this.securityProtocol != null)
|
|
{
|
|
this.securityProtocol.Close(false, timeoutHelper.RemainingTime());
|
|
}
|
|
bool closeLifetimeManager = false;
|
|
lock (ThisLock)
|
|
{
|
|
if (hasSecurityStateReference)
|
|
{
|
|
closeLifetimeManager = true;
|
|
hasSecurityStateReference = false;
|
|
}
|
|
}
|
|
if (closeLifetimeManager)
|
|
{
|
|
this.settingsLifetimeManager.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
// a parallel thread aborted the channel. Ignore the exception
|
|
}
|
|
|
|
this.Settings.SessionTokenCache.RemoveAllContexts(this.currentSessionToken.ContextId);
|
|
}
|
|
|
|
protected virtual IAsyncResult BeginCloseCore(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new CloseCoreAsyncResult(this, timeout, callback, state);
|
|
}
|
|
|
|
protected virtual void EndCloseCore(IAsyncResult result)
|
|
{
|
|
CloseCoreAsyncResult.End(result);
|
|
}
|
|
|
|
protected abstract void OnCloseMessageReceived(RequestContext requestContext, Message message, SecurityProtocolCorrelationState correlationState, TimeSpan timeout);
|
|
|
|
protected abstract void OnCloseResponseMessageReceived(RequestContext requestContext, Message message, SecurityProtocolCorrelationState correlationState, TimeSpan timeout);
|
|
|
|
public void RenewSessionToken(SecurityContextSecurityToken newToken, SecurityContextSecurityToken supportingToken)
|
|
{
|
|
ThrowIfClosedOrNotOpen();
|
|
// enforce that the token being renewed is the current session token
|
|
lock (ThisLock)
|
|
{
|
|
if (supportingToken.ContextId != this.currentSessionToken.ContextId || supportingToken.KeyGeneration != this.currentSessionToken.KeyGeneration)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new MessageSecurityException(SR.GetString(SR.CurrentSessionTokenNotRenewed, supportingToken.KeyGeneration, this.currentSessionToken.KeyGeneration)));
|
|
}
|
|
if (this.futureSessionTokens.Count == this.Settings.MaximumPendingKeysPerSession)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new MessageSecurityException(SR.GetString(SR.TooManyPendingSessionKeys)));
|
|
}
|
|
this.futureSessionTokens.Add(newToken);
|
|
}
|
|
SecurityTraceRecordHelper.TraceNewServerSessionKeyIssued(newToken, supportingToken, GetLocalUri());
|
|
}
|
|
|
|
protected Uri GetLocalUri()
|
|
{
|
|
if (this.channelBinder.LocalAddress == null)
|
|
return null;
|
|
else
|
|
return this.channelBinder.LocalAddress.Uri;
|
|
}
|
|
|
|
void OnInnerFaulted(IReliableChannelBinder sender, Exception exception)
|
|
{
|
|
this.Fault(exception);
|
|
}
|
|
|
|
SecurityContextSecurityToken GetSessionToken(SecurityMessageProperty securityProperty)
|
|
{
|
|
SecurityContextSecurityToken sct = (securityProperty.ProtectionToken != null) ? securityProperty.ProtectionToken.SecurityToken as SecurityContextSecurityToken : null;
|
|
if (sct != null && sct.ContextId == this.sessionId)
|
|
{
|
|
return sct;
|
|
}
|
|
if (securityProperty.HasIncomingSupportingTokens)
|
|
{
|
|
for (int i = 0; i < securityProperty.IncomingSupportingTokens.Count; ++i)
|
|
{
|
|
if (securityProperty.IncomingSupportingTokens[i].SecurityTokenAttachmentMode == SecurityTokenAttachmentMode.Endorsing)
|
|
{
|
|
sct = (securityProperty.IncomingSupportingTokens[i].SecurityToken as SecurityContextSecurityToken);
|
|
if (sct != null && sct.ContextId == this.sessionId)
|
|
{
|
|
return sct;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
bool CheckIncomingToken(RequestContext requestContext, Message message, SecurityProtocolCorrelationState correlationState, TimeSpan timeout)
|
|
{
|
|
SecurityMessageProperty securityProperty = message.Properties.Security;
|
|
// this is guaranteed to be non-null and matches the session ID since the binding checked it
|
|
SecurityContextSecurityToken incomingToken = GetSessionToken(securityProperty);
|
|
if (incomingToken == null)
|
|
{
|
|
throw TraceUtility.ThrowHelperWarning(new MessageSecurityException(SR.GetString(SR.NoSessionTokenPresentInMessage)), message);
|
|
}
|
|
// the incoming token's key should have been issued within keyRenewalPeriod time in the past
|
|
// if not, send back a renewal fault. However if this is a session close message then its ok to not require the client
|
|
// to renew the key in order to send the close.
|
|
if (incomingToken.KeyExpirationTime < DateTime.UtcNow &&
|
|
message.Headers.Action != this.settings.SecurityStandardsManager.SecureConversationDriver.CloseAction.Value)
|
|
{
|
|
if (this.settings.CanRenewSession)
|
|
{
|
|
SendRenewFault(requestContext, correlationState, timeout);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new SessionKeyExpiredException(SR.GetString(SR.SecurityContextKeyExpired, incomingToken.ContextId, incomingToken.KeyGeneration)));
|
|
}
|
|
}
|
|
// this is a valid token. If it corresponds to a newly issued session token, make it the current
|
|
// session token.
|
|
lock (ThisLock)
|
|
{
|
|
if (this.futureSessionTokens.Count > 0 && incomingToken.KeyGeneration != this.currentSessionToken.KeyGeneration)
|
|
{
|
|
bool changedCurrentSessionToken = false;
|
|
for (int i = 0; i < this.futureSessionTokens.Count; ++i)
|
|
{
|
|
if (futureSessionTokens[i].KeyGeneration == incomingToken.KeyGeneration)
|
|
{
|
|
// let the current token expire after KeyRollover time interval
|
|
DateTime keyRolloverTime = TimeoutHelper.Add(DateTime.UtcNow, this.settings.KeyRolloverInterval);
|
|
this.settings.SessionTokenCache.UpdateContextCachingTime(this.currentSessionToken, keyRolloverTime);
|
|
this.currentSessionToken = futureSessionTokens[i];
|
|
futureSessionTokens.RemoveAt(i);
|
|
((IAcceptorSecuritySessionProtocol)this.securityProtocol).SetOutgoingSessionToken(this.currentSessionToken);
|
|
changedCurrentSessionToken = true;
|
|
break;
|
|
}
|
|
}
|
|
if (changedCurrentSessionToken)
|
|
{
|
|
SecurityTraceRecordHelper.TraceServerSessionKeyUpdated(this.currentSessionToken, GetLocalUri());
|
|
// remove all renewed tokens that will never be used.
|
|
for (int i = 0; i < futureSessionTokens.Count; ++i)
|
|
{
|
|
this.Settings.SessionTokenCache.RemoveContext(futureSessionTokens[i].ContextId, futureSessionTokens[i].KeyGeneration);
|
|
}
|
|
this.futureSessionTokens.Clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void StartReceiving(RequestContext initialRequestContext)
|
|
{
|
|
if (this.initialRequestContext != null)
|
|
{
|
|
Fx.Assert("The initial request context was already specified.");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.AttemptToCreateMultipleRequestContext)));
|
|
}
|
|
this.initialRequestContext = initialRequestContext;
|
|
}
|
|
|
|
public RequestContext ReceiveRequest()
|
|
{
|
|
return this.ReceiveRequest(this.DefaultReceiveTimeout);
|
|
}
|
|
|
|
public RequestContext ReceiveRequest(TimeSpan timeout)
|
|
{
|
|
RequestContext requestContext;
|
|
if (this.TryReceiveRequest(timeout, out requestContext))
|
|
{
|
|
return requestContext;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException());
|
|
}
|
|
}
|
|
|
|
public IAsyncResult BeginReceiveRequest(AsyncCallback callback, object state)
|
|
{
|
|
return this.BeginReceiveRequest(this.DefaultReceiveTimeout, callback, state);
|
|
}
|
|
|
|
public IAsyncResult BeginReceiveRequest(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return this.BeginTryReceiveRequest(timeout, callback, state);
|
|
}
|
|
|
|
public RequestContext EndReceiveRequest(IAsyncResult result)
|
|
{
|
|
RequestContext requestContext;
|
|
if (this.EndTryReceiveRequest(result, out requestContext))
|
|
{
|
|
return requestContext;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException());
|
|
}
|
|
}
|
|
|
|
public IAsyncResult BeginTryReceiveRequest(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new ReceiveRequestAsyncResult(this, timeout, callback, state);
|
|
}
|
|
|
|
public bool EndTryReceiveRequest(IAsyncResult result, out RequestContext requestContext)
|
|
{
|
|
return ReceiveRequestAsyncResult.EndAsRequestContext(result, out requestContext);
|
|
}
|
|
|
|
public bool TryReceiveRequest(TimeSpan timeout, out RequestContext requestContext)
|
|
{
|
|
ThrowIfFaulted();
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
|
|
if (!this.receiveLock.TryEnter(timeoutHelper.RemainingTime()))
|
|
{
|
|
requestContext = null;
|
|
return false;
|
|
}
|
|
try
|
|
{
|
|
while (true)
|
|
{
|
|
if (isInputClosed || this.State == CommunicationState.Faulted)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// schedule another Receive if the timeout has not been reached
|
|
if (timeoutHelper.RemainingTime() == TimeSpan.Zero)
|
|
{
|
|
requestContext = null;
|
|
return false;
|
|
}
|
|
|
|
RequestContext innerRequestContext;
|
|
if (initialRequestContext != null)
|
|
{
|
|
innerRequestContext = initialRequestContext;
|
|
initialRequestContext = null;
|
|
}
|
|
else
|
|
{
|
|
if (!channelBinder.TryReceive(timeoutHelper.RemainingTime(), out innerRequestContext))
|
|
{
|
|
requestContext = null;
|
|
return false;
|
|
}
|
|
}
|
|
if (innerRequestContext == null)
|
|
{
|
|
// the channel could have been aborted or closed
|
|
break;
|
|
}
|
|
if (this.isInputClosed && innerRequestContext.RequestMessage != null)
|
|
{
|
|
Message message = innerRequestContext.RequestMessage;
|
|
try
|
|
{
|
|
ProtocolException error = ProtocolException.ReceiveShutdownReturnedNonNull(message);
|
|
throw TraceUtility.ThrowHelperWarning(error, message);
|
|
}
|
|
finally
|
|
{
|
|
message.Close();
|
|
innerRequestContext.Abort();
|
|
}
|
|
}
|
|
SecurityProtocolCorrelationState correlationState = null;
|
|
bool isSecurityProcessingFailure;
|
|
Message requestMessage = ProcessRequestContext(innerRequestContext, timeoutHelper.RemainingTime(), out correlationState, out isSecurityProcessingFailure);
|
|
if (requestMessage != null)
|
|
{
|
|
requestContext = new SecuritySessionRequestContext(innerRequestContext, requestMessage, correlationState, this);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
this.receiveLock.Exit();
|
|
}
|
|
ThrowIfFaulted();
|
|
requestContext = null;
|
|
return true;
|
|
}
|
|
|
|
public Message Receive()
|
|
{
|
|
return this.Receive(this.DefaultReceiveTimeout);
|
|
}
|
|
|
|
public Message Receive(TimeSpan timeout)
|
|
{
|
|
Message message;
|
|
if (this.TryReceive(timeout, out message))
|
|
{
|
|
return message;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException());
|
|
}
|
|
}
|
|
|
|
public IAsyncResult BeginReceive(AsyncCallback callback, object state)
|
|
{
|
|
return this.BeginReceive(this.DefaultReceiveTimeout, callback, state);
|
|
}
|
|
|
|
public IAsyncResult BeginReceive(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return this.BeginTryReceive(timeout, callback, state);
|
|
}
|
|
|
|
public Message EndReceive(IAsyncResult result)
|
|
{
|
|
Message message;
|
|
if (this.EndTryReceive(result, out message))
|
|
{
|
|
return message;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException());
|
|
}
|
|
}
|
|
|
|
public IAsyncResult BeginTryReceive(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new ReceiveRequestAsyncResult(this, timeout, callback, state);
|
|
}
|
|
|
|
public bool EndTryReceive(IAsyncResult result, out Message message)
|
|
{
|
|
return ReceiveRequestAsyncResult.EndAsMessage(result, out message);
|
|
}
|
|
|
|
public bool TryReceive(TimeSpan timeout, out Message message)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
RequestContext requestContext;
|
|
|
|
if (this.TryReceiveRequest(timeoutHelper.RemainingTime(), out requestContext))
|
|
{
|
|
if (requestContext != null)
|
|
{
|
|
message = requestContext.RequestMessage;
|
|
try
|
|
{
|
|
requestContext.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, System.Diagnostics.TraceEventType.Information);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
message = null;
|
|
}
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
message = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override T GetProperty<T>()
|
|
{
|
|
if (typeof(T) == typeof(FaultConverter) && (this.channelBinder != null))
|
|
{
|
|
return new SecurityChannelFaultConverter(this.channelBinder.Channel) as T;
|
|
}
|
|
|
|
T result = base.GetProperty<T>();
|
|
if ((result == null) && (channelBinder != null) && (channelBinder.Channel != null))
|
|
{
|
|
result = channelBinder.Channel.GetProperty<T>();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void SendFaultIfRequired(Exception e, Message unverifiedMessage, RequestContext requestContext, TimeSpan timeout)
|
|
{
|
|
try
|
|
{
|
|
// return if the underlying channel does not implement IDuplexSession or IReply
|
|
if (!(this.channelBinder.Channel is IReplyChannel) && !(this.channelBinder.Channel is IDuplexSessionChannel))
|
|
{
|
|
return;
|
|
}
|
|
|
|
MessageFault fault = SecurityUtils.CreateSecurityMessageFault(e, this.securityProtocol.SecurityProtocolFactory.StandardsManager);
|
|
if (fault == null)
|
|
{
|
|
return;
|
|
}
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
try
|
|
{
|
|
using (Message faultMessage = Message.CreateMessage(unverifiedMessage.Version, fault, unverifiedMessage.Version.Addressing.DefaultFaultAction))
|
|
{
|
|
if (unverifiedMessage.Headers.MessageId != null)
|
|
faultMessage.InitializeReply(unverifiedMessage);
|
|
requestContext.Reply(faultMessage, timeoutHelper.RemainingTime());
|
|
requestContext.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
catch (CommunicationException ex)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(ex, TraceEventType.Information);
|
|
}
|
|
catch (TimeoutException ex)
|
|
{
|
|
if (TD.CloseTimeoutIsEnabled())
|
|
{
|
|
TD.CloseTimeout(e.Message);
|
|
}
|
|
DiagnosticUtility.TraceHandledException(ex, TraceEventType.Information);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
unverifiedMessage.Close();
|
|
requestContext.Abort();
|
|
}
|
|
}
|
|
|
|
bool ShouldWrapException(Exception e)
|
|
{
|
|
return ((e is FormatException) || (e is XmlException));
|
|
}
|
|
|
|
Message ProcessRequestContext(RequestContext requestContext, TimeSpan timeout, out SecurityProtocolCorrelationState correlationState, out bool isSecurityProcessingFailure)
|
|
{
|
|
correlationState = null;
|
|
isSecurityProcessingFailure = false;
|
|
if (requestContext == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
Message result = null;
|
|
Message message = requestContext.RequestMessage;
|
|
bool cleanupContextState = true;
|
|
try
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
Message unverifiedMessage = message;
|
|
Exception securityException = null;
|
|
try
|
|
{
|
|
correlationState = VerifyIncomingMessage(ref message, timeoutHelper.RemainingTime());
|
|
}
|
|
catch (MessageSecurityException e)
|
|
{
|
|
isSecurityProcessingFailure = true;
|
|
securityException = e;
|
|
}
|
|
if (securityException != null)
|
|
{
|
|
// SendFaultIfRequired closes the unverified message and context
|
|
SendFaultIfRequired(securityException, unverifiedMessage, requestContext, timeoutHelper.RemainingTime());
|
|
cleanupContextState = false;
|
|
return null;
|
|
}
|
|
else if (CheckIncomingToken(requestContext, message, correlationState, timeoutHelper.RemainingTime()))
|
|
{
|
|
if (message.Headers.Action == this.Settings.SecurityStandardsManager.SecureConversationDriver.CloseAction.Value)
|
|
{
|
|
SecurityTraceRecordHelper.TraceServerSessionCloseReceived(this.currentSessionToken, GetLocalUri());
|
|
this.isInputClosed = true;
|
|
// OnCloseMessageReceived is responsible for closing the message and requestContext if required.
|
|
this.OnCloseMessageReceived(requestContext, message, correlationState, timeoutHelper.RemainingTime());
|
|
correlationState = null;
|
|
}
|
|
else if (message.Headers.Action == this.Settings.SecurityStandardsManager.SecureConversationDriver.CloseResponseAction.Value)
|
|
{
|
|
SecurityTraceRecordHelper.TraceServerSessionCloseResponseReceived(this.currentSessionToken, GetLocalUri());
|
|
this.isInputClosed = true;
|
|
// OnCloseResponseMessageReceived is responsible for closing the message and requestContext if required.
|
|
this.OnCloseResponseMessageReceived(requestContext, message, correlationState, timeoutHelper.RemainingTime());
|
|
correlationState = null;
|
|
}
|
|
else
|
|
{
|
|
result = message;
|
|
}
|
|
cleanupContextState = false;
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if ((e is CommunicationException) || (e is TimeoutException) || (Fx.IsFatal(e)) || !ShouldWrapException(e))
|
|
{
|
|
throw;
|
|
}
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new MessageSecurityException(SR.GetString(SR.MessageSecurityVerificationFailed), e));
|
|
}
|
|
finally
|
|
{
|
|
if (cleanupContextState)
|
|
{
|
|
if (requestContext.RequestMessage != null)
|
|
{
|
|
requestContext.RequestMessage.Close();
|
|
}
|
|
requestContext.Abort();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
internal void CheckOutgoingToken()
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (this.currentSessionToken.KeyExpirationTime < DateTime.UtcNow)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SessionKeyExpiredException(SR.GetString(SR.SecuritySessionKeyIsStale)));
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void SecureApplicationMessage(ref Message message, TimeSpan timeout, SecurityProtocolCorrelationState correlationState)
|
|
{
|
|
ThrowIfFaulted();
|
|
ThrowIfClosedOrNotOpen();
|
|
CheckOutgoingToken();
|
|
this.securityProtocol.SecureOutgoingMessage(ref message, timeout, correlationState);
|
|
}
|
|
|
|
internal SecurityProtocolCorrelationState VerifyIncomingMessage(ref Message message, TimeSpan timeout)
|
|
{
|
|
return this.securityProtocol.VerifyIncomingMessage(ref message, timeout, null);
|
|
}
|
|
|
|
void PrepareReply(Message request, Message reply)
|
|
{
|
|
if (request.Headers.ReplyTo != null)
|
|
{
|
|
request.Headers.ReplyTo.ApplyTo(reply);
|
|
}
|
|
else if (request.Headers.From != null)
|
|
{
|
|
request.Headers.From.ApplyTo(reply);
|
|
}
|
|
if (request.Headers.MessageId != null)
|
|
{
|
|
reply.Headers.RelatesTo = request.Headers.MessageId;
|
|
}
|
|
TraceUtility.CopyActivity(request, reply);
|
|
if (TraceUtility.PropagateUserActivity || TraceUtility.ShouldPropagateActivity)
|
|
{
|
|
TraceUtility.AddActivityHeader(reply);
|
|
}
|
|
}
|
|
|
|
protected void InitializeFaultCodesIfRequired()
|
|
{
|
|
if (!areFaultCodesInitialized)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (!areFaultCodesInitialized)
|
|
{
|
|
SecurityStandardsManager standardsManager = this.securityProtocol.SecurityProtocolFactory.StandardsManager;
|
|
SecureConversationDriver scDriver = standardsManager.SecureConversationDriver;
|
|
renewFaultCode = FaultCode.CreateSenderFaultCode(scDriver.RenewNeededFaultCode.Value, scDriver.Namespace.Value);
|
|
renewFaultReason = new FaultReason(SR.GetString(SR.SecurityRenewFaultReason), System.Globalization.CultureInfo.InvariantCulture);
|
|
sessionAbortedFaultCode = FaultCode.CreateSenderFaultCode(DotNetSecurityStrings.SecuritySessionAbortedFault, DotNetSecurityStrings.Namespace);
|
|
sessionAbortedFaultReason = new FaultReason(SR.GetString(SR.SecuritySessionAbortedFaultReason), System.Globalization.CultureInfo.InvariantCulture);
|
|
areFaultCodesInitialized = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SendRenewFault(RequestContext requestContext, SecurityProtocolCorrelationState correlationState, TimeSpan timeout)
|
|
{
|
|
Message message = requestContext.RequestMessage;
|
|
try
|
|
{
|
|
InitializeFaultCodesIfRequired();
|
|
MessageFault renewFault = MessageFault.CreateFault(renewFaultCode, renewFaultReason);
|
|
Message response;
|
|
if (message.Headers.MessageId != null)
|
|
{
|
|
response = Message.CreateMessage(message.Version, renewFault, DotNetSecurityStrings.SecuritySessionFaultAction);
|
|
response.InitializeReply(message);
|
|
}
|
|
else
|
|
{
|
|
response = Message.CreateMessage(message.Version, renewFault, DotNetSecurityStrings.SecuritySessionFaultAction);
|
|
}
|
|
try
|
|
{
|
|
PrepareReply(message, response);
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
this.securityProtocol.SecureOutgoingMessage(ref response, timeoutHelper.RemainingTime(), correlationState);
|
|
response.Properties.AllowOutputBatching = false;
|
|
SendMessage(requestContext, response, timeoutHelper.RemainingTime());
|
|
}
|
|
finally
|
|
{
|
|
response.Close();
|
|
}
|
|
SecurityTraceRecordHelper.TraceSessionRenewalFaultSent(this.currentSessionToken, GetLocalUri(), message);
|
|
}
|
|
catch (CommunicationException e)
|
|
{
|
|
SecurityTraceRecordHelper.TraceRenewFaultSendFailure(this.currentSessionToken, GetLocalUri(), e);
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
SecurityTraceRecordHelper.TraceRenewFaultSendFailure(this.currentSessionToken, GetLocalUri(), e);
|
|
}
|
|
}
|
|
|
|
Message ProcessCloseRequest(Message request)
|
|
{
|
|
RequestSecurityToken rst;
|
|
XmlDictionaryReader bodyReader = request.GetReaderAtBodyContents();
|
|
using (bodyReader)
|
|
{
|
|
rst = this.Settings.SecurityStandardsManager.TrustDriver.CreateRequestSecurityToken(bodyReader);
|
|
request.ReadFromBodyContentsToEnd(bodyReader);
|
|
}
|
|
if (rst.RequestType != null && rst.RequestType != this.Settings.SecurityStandardsManager.TrustDriver.RequestTypeClose)
|
|
{
|
|
throw TraceUtility.ThrowHelperWarning(new MessageSecurityException(SR.GetString(SR.InvalidRstRequestType, rst.RequestType)), request);
|
|
}
|
|
if (rst.CloseTarget == null)
|
|
{
|
|
throw TraceUtility.ThrowHelperWarning(new MessageSecurityException(SR.GetString(SR.NoCloseTargetSpecified)), request);
|
|
}
|
|
SecurityContextKeyIdentifierClause sctSkiClause = rst.CloseTarget as SecurityContextKeyIdentifierClause;
|
|
if (sctSkiClause == null || !SecuritySessionSecurityTokenAuthenticator.DoesSkiClauseMatchSigningToken(sctSkiClause, request))
|
|
{
|
|
throw TraceUtility.ThrowHelperWarning(new MessageSecurityException(SR.GetString(SR.BadCloseTarget, rst.CloseTarget)), request);
|
|
}
|
|
RequestSecurityTokenResponse rstr = new RequestSecurityTokenResponse(this.Settings.SecurityStandardsManager);
|
|
rstr.Context = rst.Context;
|
|
rstr.IsRequestedTokenClosed = true;
|
|
rstr.MakeReadOnly();
|
|
BodyWriter bodyWriter = rstr;
|
|
if (this.Settings.SecurityStandardsManager.MessageSecurityVersion.TrustVersion == TrustVersion.WSTrust13)
|
|
{
|
|
List<RequestSecurityTokenResponse> rstrList = new List<RequestSecurityTokenResponse>(1);
|
|
rstrList.Add(rstr);
|
|
RequestSecurityTokenResponseCollection rstrc = new RequestSecurityTokenResponseCollection(rstrList, this.Settings.SecurityStandardsManager);
|
|
bodyWriter = rstrc;
|
|
}
|
|
Message response = Message.CreateMessage(request.Version, ActionHeader.Create(this.Settings.SecurityStandardsManager.SecureConversationDriver.CloseResponseAction, request.Version.Addressing), bodyWriter);
|
|
PrepareReply(request, response);
|
|
return response;
|
|
}
|
|
|
|
internal Message CreateCloseResponse(Message message, SecurityProtocolCorrelationState correlationState, TimeSpan timeout)
|
|
{
|
|
using (message)
|
|
{
|
|
Message response = this.ProcessCloseRequest(message);
|
|
this.securityProtocol.SecureOutgoingMessage(ref response, timeout, correlationState);
|
|
response.Properties.AllowOutputBatching = false;
|
|
return response;
|
|
}
|
|
}
|
|
|
|
internal void TraceSessionClosedResponseSuccess()
|
|
{
|
|
SecurityTraceRecordHelper.TraceSessionClosedResponseSent(this.currentSessionToken, GetLocalUri());
|
|
}
|
|
|
|
internal void TraceSessionClosedResponseFailure(Exception e)
|
|
{
|
|
SecurityTraceRecordHelper.TraceSessionClosedResponseSendFailure(this.currentSessionToken, GetLocalUri(), e);
|
|
}
|
|
|
|
internal void TraceSessionClosedSuccess()
|
|
{
|
|
SecurityTraceRecordHelper.TraceSessionClosedSent(this.currentSessionToken, GetLocalUri());
|
|
}
|
|
|
|
internal void TraceSessionClosedFailure(Exception e)
|
|
{
|
|
SecurityTraceRecordHelper.TraceSessionCloseSendFailure(this.currentSessionToken, GetLocalUri(), e);
|
|
}
|
|
|
|
// SendCloseResponse closes the message and underlying context if the operation completes successfully
|
|
protected void SendCloseResponse(RequestContext requestContext, Message closeResponse, TimeSpan timeout)
|
|
{
|
|
try
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
using (closeResponse)
|
|
{
|
|
SendMessage(requestContext, closeResponse, timeoutHelper.RemainingTime());
|
|
}
|
|
TraceSessionClosedResponseSuccess();
|
|
}
|
|
catch (CommunicationException e)
|
|
{
|
|
TraceSessionClosedResponseFailure(e);
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
TraceSessionClosedResponseFailure(e);
|
|
}
|
|
}
|
|
|
|
// BeginSendCloseResponse closes the message and underlying context if the operation completes successfully
|
|
internal IAsyncResult BeginSendCloseResponse(RequestContext requestContext, Message closeResponse, TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
try
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
return this.BeginSendMessage(requestContext, closeResponse, timeoutHelper.RemainingTime(), callback, state);
|
|
}
|
|
catch (CommunicationException e)
|
|
{
|
|
TraceSessionClosedResponseFailure(e);
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
TraceSessionClosedResponseFailure(e);
|
|
}
|
|
return new CompletedAsyncResult(callback, state);
|
|
}
|
|
|
|
// EndSendCloseResponse closes the message and underlying context if the operation completes successfully
|
|
internal void EndSendCloseResponse(IAsyncResult result)
|
|
{
|
|
if (result is CompletedAsyncResult)
|
|
{
|
|
CompletedAsyncResult.End(result);
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
this.EndSendMessage(result);
|
|
}
|
|
catch (CommunicationException e)
|
|
{
|
|
TraceSessionClosedResponseFailure(e);
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
TraceSessionClosedResponseFailure(e);
|
|
}
|
|
}
|
|
|
|
internal Message CreateCloseMessage(TimeSpan timeout)
|
|
{
|
|
RequestSecurityToken rst = new RequestSecurityToken(this.Settings.SecurityStandardsManager);
|
|
rst.RequestType = this.Settings.SecurityStandardsManager.TrustDriver.RequestTypeClose;
|
|
rst.CloseTarget = this.Settings.IssuedSecurityTokenParameters.CreateKeyIdentifierClause(this.currentSessionToken, SecurityTokenReferenceStyle.External);
|
|
rst.MakeReadOnly();
|
|
Message closeMessage = Message.CreateMessage(this.messageVersion, ActionHeader.Create(this.Settings.SecurityStandardsManager.SecureConversationDriver.CloseAction, this.messageVersion.Addressing), rst);
|
|
RequestReplyCorrelator.PrepareRequest(closeMessage);
|
|
if (this.LocalAddress != null)
|
|
{
|
|
closeMessage.Headers.ReplyTo = this.LocalAddress;
|
|
}
|
|
else
|
|
{
|
|
if (closeMessage.Version.Addressing == AddressingVersion.WSAddressing10)
|
|
{
|
|
closeMessage.Headers.ReplyTo = null;
|
|
}
|
|
else if (closeMessage.Version.Addressing == AddressingVersion.WSAddressingAugust2004)
|
|
{
|
|
closeMessage.Headers.ReplyTo = EndpointAddress.AnonymousAddress;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new ProtocolException(SR.GetString(SR.AddressingVersionNotSupported, closeMessage.Version.Addressing)));
|
|
}
|
|
}
|
|
this.securityProtocol.SecureOutgoingMessage(ref closeMessage, timeout, null);
|
|
closeMessage.Properties.AllowOutputBatching = false;
|
|
return closeMessage;
|
|
}
|
|
|
|
protected void SendClose(TimeSpan timeout)
|
|
{
|
|
try
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
using (Message closeMessage = CreateCloseMessage(timeoutHelper.RemainingTime()))
|
|
{
|
|
SendMessage(null, closeMessage, timeoutHelper.RemainingTime());
|
|
}
|
|
TraceSessionClosedSuccess();
|
|
}
|
|
catch (CommunicationException e)
|
|
{
|
|
TraceSessionClosedFailure(e);
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
TraceSessionClosedFailure(e);
|
|
}
|
|
}
|
|
|
|
internal IAsyncResult BeginSendClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
try
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
Message closeMessage = CreateCloseMessage(timeoutHelper.RemainingTime());
|
|
return this.BeginSendMessage(null, closeMessage, timeoutHelper.RemainingTime(), callback, state);
|
|
}
|
|
catch (CommunicationException e)
|
|
{
|
|
TraceSessionClosedFailure(e);
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
TraceSessionClosedFailure(e);
|
|
}
|
|
return new CompletedAsyncResult(callback, state);
|
|
}
|
|
|
|
internal void EndSendClose(IAsyncResult result)
|
|
{
|
|
if (result is CompletedAsyncResult)
|
|
{
|
|
CompletedAsyncResult.End(result);
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
this.EndSendMessage(result);
|
|
}
|
|
catch (CommunicationException e)
|
|
{
|
|
TraceSessionClosedFailure(e);
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
TraceSessionClosedFailure(e);
|
|
}
|
|
}
|
|
|
|
protected void SendMessage(RequestContext requestContext, Message message, TimeSpan timeout)
|
|
{
|
|
if (this.channelBinder.CanSendAsynchronously)
|
|
{
|
|
this.channelBinder.Send(message, timeout);
|
|
}
|
|
else if (requestContext != null)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
requestContext.Reply(message, timeoutHelper.RemainingTime());
|
|
requestContext.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
|
|
internal IAsyncResult BeginSendMessage(RequestContext requestContext, Message response, TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new SendMessageAsyncResult(this, requestContext, response, timeout, callback, state);
|
|
}
|
|
|
|
internal void EndSendMessage(IAsyncResult result)
|
|
{
|
|
SendMessageAsyncResult.End(result);
|
|
}
|
|
|
|
class SendMessageAsyncResult : AsyncResult
|
|
{
|
|
static AsyncCallback sendCallback = Fx.ThunkCallback(new AsyncCallback(SendCallback));
|
|
ServerSecuritySessionChannel sessionChannel;
|
|
TimeoutHelper timeoutHelper;
|
|
RequestContext requestContext;
|
|
Message message;
|
|
|
|
public SendMessageAsyncResult(ServerSecuritySessionChannel sessionChannel, RequestContext requestContext, Message message, TimeSpan timeout, AsyncCallback callback,
|
|
object state)
|
|
: base(callback, state)
|
|
{
|
|
this.sessionChannel = sessionChannel;
|
|
this.timeoutHelper = new TimeoutHelper(timeout);
|
|
this.requestContext = requestContext;
|
|
this.message = message;
|
|
|
|
bool closeMessage = true;
|
|
try
|
|
{
|
|
IAsyncResult result = this.BeginSend(message);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
closeMessage = false;
|
|
return;
|
|
}
|
|
this.EndSend(result);
|
|
closeMessage = false;
|
|
}
|
|
finally
|
|
{
|
|
if (closeMessage)
|
|
{
|
|
this.message.Close();
|
|
}
|
|
}
|
|
Complete(true);
|
|
}
|
|
|
|
IAsyncResult BeginSend(Message response)
|
|
{
|
|
if (this.sessionChannel.channelBinder.CanSendAsynchronously)
|
|
{
|
|
return this.sessionChannel.channelBinder.BeginSend(response, timeoutHelper.RemainingTime(), sendCallback, this);
|
|
}
|
|
else if (requestContext != null)
|
|
{
|
|
return requestContext.BeginReply(response, sendCallback, this);
|
|
}
|
|
else
|
|
{
|
|
return new SendCompletedAsyncResult(sendCallback, this);
|
|
}
|
|
}
|
|
|
|
void EndSend(IAsyncResult result)
|
|
{
|
|
try
|
|
{
|
|
if (result is SendCompletedAsyncResult)
|
|
{
|
|
SendCompletedAsyncResult.End(result);
|
|
}
|
|
else if (this.sessionChannel.channelBinder.CanSendAsynchronously)
|
|
{
|
|
this.sessionChannel.channelBinder.EndSend(result);
|
|
}
|
|
else
|
|
{
|
|
this.requestContext.EndReply(result);
|
|
this.requestContext.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (this.message != null)
|
|
{
|
|
this.message.Close();
|
|
}
|
|
}
|
|
}
|
|
|
|
static void SendCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
SendMessageAsyncResult self = (SendMessageAsyncResult)(result.AsyncState);
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
self.EndSend(result);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
completionException = e;
|
|
}
|
|
self.Complete(false, completionException);
|
|
}
|
|
|
|
public static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<SendMessageAsyncResult>(result);
|
|
}
|
|
|
|
class SendCompletedAsyncResult : CompletedAsyncResult
|
|
{
|
|
public SendCompletedAsyncResult(AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
}
|
|
|
|
new public static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<SendCompletedAsyncResult>(result);
|
|
}
|
|
}
|
|
}
|
|
|
|
class CloseCoreAsyncResult : AsyncResult
|
|
{
|
|
static AsyncCallback channelBinderCloseCallback = Fx.ThunkCallback(new AsyncCallback(ChannelBinderCloseCallback));
|
|
static AsyncCallback settingsLifetimeManagerCloseCallback = Fx.ThunkCallback(new AsyncCallback(SettingsLifetimeManagerCloseCallback));
|
|
|
|
ServerSecuritySessionChannel channel;
|
|
TimeoutHelper timeoutHelper;
|
|
|
|
public CloseCoreAsyncResult(ServerSecuritySessionChannel channel, TimeSpan timeout, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
this.channel = channel;
|
|
this.timeoutHelper = new TimeoutHelper(timeout);
|
|
bool completeSelf = false;
|
|
if (this.channel.channelBinder != null)
|
|
{
|
|
try
|
|
{
|
|
IAsyncResult result = this.channel.channelBinder.BeginClose(timeoutHelper.RemainingTime(), channelBinderCloseCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
this.channel.channelBinder.EndClose(result);
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.channel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
else
|
|
{
|
|
completeSelf = true;
|
|
}
|
|
}
|
|
}
|
|
if (!completeSelf)
|
|
{
|
|
completeSelf = this.OnChannelBinderClosed();
|
|
}
|
|
if (completeSelf)
|
|
{
|
|
RemoveSessionTokenFromCache();
|
|
Complete(true);
|
|
}
|
|
}
|
|
|
|
void RemoveSessionTokenFromCache()
|
|
{
|
|
this.channel.Settings.SessionTokenCache.RemoveAllContexts(this.channel.currentSessionToken.ContextId);
|
|
}
|
|
|
|
static void ChannelBinderCloseCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseCoreAsyncResult self = (CloseCoreAsyncResult)(result.AsyncState);
|
|
bool completeSelf = false;
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
try
|
|
{
|
|
self.channel.channelBinder.EndClose(result);
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (self.channel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
completeSelf = true;
|
|
}
|
|
if (!completeSelf)
|
|
{
|
|
completeSelf = self.OnChannelBinderClosed();
|
|
}
|
|
if (completeSelf)
|
|
{
|
|
self.RemoveSessionTokenFromCache();
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
completeSelf = true;
|
|
completionException = e;
|
|
}
|
|
if (completeSelf)
|
|
{
|
|
self.Complete(false, completionException);
|
|
}
|
|
}
|
|
|
|
bool OnChannelBinderClosed()
|
|
{
|
|
try
|
|
{
|
|
if (this.channel.securityProtocol != null)
|
|
{
|
|
this.channel.securityProtocol.Close(false, timeoutHelper.RemainingTime());
|
|
}
|
|
bool closeLifetimeManager = false;
|
|
lock (this.channel.ThisLock)
|
|
{
|
|
if (this.channel.hasSecurityStateReference)
|
|
{
|
|
closeLifetimeManager = true;
|
|
this.channel.hasSecurityStateReference = false;
|
|
}
|
|
}
|
|
if (!closeLifetimeManager)
|
|
{
|
|
return true;
|
|
}
|
|
IAsyncResult result = this.channel.settingsLifetimeManager.BeginClose(timeoutHelper.RemainingTime(), settingsLifetimeManagerCloseCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return false;
|
|
}
|
|
this.channel.settingsLifetimeManager.EndClose(result);
|
|
return true;
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (channel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static void SettingsLifetimeManagerCloseCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseCoreAsyncResult self = (CloseCoreAsyncResult)(result.AsyncState);
|
|
bool removeSessionToken = false;
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
self.channel.settingsLifetimeManager.EndClose(result);
|
|
removeSessionToken = true;
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (self.channel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
removeSessionToken = true;
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
completionException = e;
|
|
}
|
|
finally
|
|
{
|
|
if (removeSessionToken)
|
|
{
|
|
self.RemoveSessionTokenFromCache();
|
|
}
|
|
}
|
|
self.Complete(false, completionException);
|
|
}
|
|
|
|
public static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<CloseCoreAsyncResult>(result);
|
|
}
|
|
}
|
|
|
|
protected class SoapSecurityInputSession : ISecureConversationSession, IInputSession
|
|
{
|
|
ServerSecuritySessionChannel channel;
|
|
UniqueId securityContextTokenId;
|
|
EndpointIdentity remoteIdentity;
|
|
SecurityKeyIdentifierClause sessionTokenIdentifier;
|
|
SecurityStandardsManager standardsManager;
|
|
|
|
public SoapSecurityInputSession(SecurityContextSecurityToken sessionToken,
|
|
SecuritySessionServerSettings settings, ServerSecuritySessionChannel channel)
|
|
{
|
|
this.channel = channel;
|
|
this.securityContextTokenId = sessionToken.ContextId;
|
|
Claim identityClaim = SecurityUtils.GetPrimaryIdentityClaim(sessionToken.AuthorizationPolicies);
|
|
if (identityClaim != null)
|
|
{
|
|
this.remoteIdentity = EndpointIdentity.CreateIdentity(identityClaim);
|
|
}
|
|
this.sessionTokenIdentifier = settings.IssuedSecurityTokenParameters.CreateKeyIdentifierClause(sessionToken, SecurityTokenReferenceStyle.External);
|
|
this.standardsManager = settings.SessionProtocolFactory.StandardsManager;
|
|
}
|
|
|
|
public string Id
|
|
{
|
|
get
|
|
{
|
|
return this.securityContextTokenId.ToString();
|
|
}
|
|
}
|
|
|
|
public EndpointIdentity RemoteIdentity
|
|
{
|
|
get
|
|
{
|
|
return this.remoteIdentity;
|
|
}
|
|
}
|
|
|
|
public void WriteSessionTokenIdentifier(XmlDictionaryWriter writer)
|
|
{
|
|
this.channel.ThrowIfDisposedOrNotOpen();
|
|
this.standardsManager.SecurityTokenSerializer.WriteKeyIdentifierClause(writer, this.sessionTokenIdentifier);
|
|
}
|
|
|
|
public bool TryReadSessionTokenIdentifier(XmlReader reader)
|
|
{
|
|
this.channel.ThrowIfDisposedOrNotOpen();
|
|
if (!this.standardsManager.SecurityTokenSerializer.CanReadKeyIdentifierClause(reader))
|
|
{
|
|
return false;
|
|
}
|
|
SecurityContextKeyIdentifierClause incomingTokenIdentifier = this.standardsManager.SecurityTokenSerializer.ReadKeyIdentifierClause(reader) as SecurityContextKeyIdentifierClause;
|
|
return incomingTokenIdentifier != null && incomingTokenIdentifier.Matches(this.securityContextTokenId, null);
|
|
}
|
|
}
|
|
|
|
class ReceiveRequestAsyncResult : AsyncResult
|
|
{
|
|
static FastAsyncCallback onWait = new FastAsyncCallback(OnWait);
|
|
static AsyncCallback onReceive = Fx.ThunkCallback(new AsyncCallback(OnReceive));
|
|
ServerSecuritySessionChannel channel;
|
|
RequestContext innerRequestContext;
|
|
Message requestMessage;
|
|
SecurityProtocolCorrelationState correlationState;
|
|
bool expired;
|
|
TimeoutHelper timeoutHelper;
|
|
|
|
public ReceiveRequestAsyncResult(ServerSecuritySessionChannel channel, TimeSpan timeout, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
channel.ThrowIfFaulted();
|
|
this.timeoutHelper = new TimeoutHelper(timeout);
|
|
this.channel = channel;
|
|
if (!channel.receiveLock.EnterAsync(this.timeoutHelper.RemainingTime(), onWait, this))
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool completeSelf = false;
|
|
bool throwing = true;
|
|
try
|
|
{
|
|
completeSelf = WaitComplete();
|
|
throwing = false;
|
|
}
|
|
finally
|
|
{
|
|
if (throwing)
|
|
{
|
|
this.channel.receiveLock.Exit();
|
|
}
|
|
}
|
|
|
|
if (completeSelf)
|
|
{
|
|
Complete(true);
|
|
}
|
|
}
|
|
|
|
static void OnWait(object state, Exception asyncException)
|
|
{
|
|
ReceiveRequestAsyncResult self = (ReceiveRequestAsyncResult)state;
|
|
bool completeSelf = false;
|
|
Exception completionException = asyncException;
|
|
if (completionException != null)
|
|
{
|
|
completeSelf = true;
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
completeSelf = self.WaitComplete();
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
completeSelf = true;
|
|
completionException = e;
|
|
}
|
|
}
|
|
|
|
if (completeSelf)
|
|
{
|
|
self.Complete(false, completionException);
|
|
}
|
|
}
|
|
|
|
bool WaitComplete()
|
|
{
|
|
if (channel.isInputClosed)
|
|
{
|
|
return true;
|
|
}
|
|
channel.ThrowIfFaulted();
|
|
|
|
ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity &&
|
|
channel.initialRequestContext != null ?
|
|
TraceUtility.ExtractActivity(channel.initialRequestContext.RequestMessage) : null;
|
|
|
|
using (ServiceModelActivity.BoundOperation(activity))
|
|
{
|
|
if (channel.initialRequestContext != null)
|
|
{
|
|
innerRequestContext = channel.initialRequestContext;
|
|
channel.initialRequestContext = null;
|
|
bool isSecurityProcessingFailure;
|
|
requestMessage = channel.ProcessRequestContext(innerRequestContext, timeoutHelper.RemainingTime(), out this.correlationState, out isSecurityProcessingFailure);
|
|
if (requestMessage != null || channel.isInputClosed)
|
|
{
|
|
this.expired = false;
|
|
return true;
|
|
}
|
|
}
|
|
if (this.timeoutHelper.RemainingTime() == TimeSpan.Zero)
|
|
{
|
|
this.expired = true;
|
|
return true;
|
|
}
|
|
IAsyncResult result = channel.ChannelBinder.BeginTryReceive(this.timeoutHelper.RemainingTime(), onReceive, this);
|
|
if (!result.CompletedSynchronously)
|
|
return false;
|
|
|
|
return CompleteReceive(result);
|
|
}
|
|
}
|
|
|
|
bool CompleteReceive(IAsyncResult result)
|
|
{
|
|
while (true)
|
|
{
|
|
this.expired = !channel.ChannelBinder.EndTryReceive(result, out this.innerRequestContext);
|
|
if (this.expired || innerRequestContext == null)
|
|
break;
|
|
|
|
bool isSecurityProcessingFailure;
|
|
requestMessage = channel.ProcessRequestContext(innerRequestContext, timeoutHelper.RemainingTime(), out this.correlationState, out isSecurityProcessingFailure);
|
|
if (requestMessage != null)
|
|
{
|
|
if (channel.isInputClosed)
|
|
{
|
|
ProtocolException error = ProtocolException.ReceiveShutdownReturnedNonNull(requestMessage);
|
|
try
|
|
{
|
|
throw TraceUtility.ThrowHelperWarning(error, requestMessage);
|
|
}
|
|
finally
|
|
{
|
|
requestMessage.Close();
|
|
innerRequestContext.Abort();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (channel.isInputClosed || channel.State == CommunicationState.Faulted)
|
|
break;
|
|
|
|
// retry the receive unless the timeout is reached
|
|
if (this.timeoutHelper.RemainingTime() == TimeSpan.Zero)
|
|
{
|
|
this.expired = true;
|
|
break;
|
|
}
|
|
|
|
result = channel.ChannelBinder.BeginTryReceive(this.timeoutHelper.RemainingTime(), onReceive, this);
|
|
|
|
if (!result.CompletedSynchronously)
|
|
return false;
|
|
}
|
|
this.channel.ThrowIfFaulted();
|
|
return true;
|
|
}
|
|
|
|
new void Complete(bool synchronous)
|
|
{
|
|
try
|
|
{
|
|
this.channel.receiveLock.Exit();
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
if (DiagnosticUtility.ShouldTraceWarning)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.AsyncCallbackThrewException, SR.GetString(SR.TraceCodeAsyncCallbackThrewException), e.ToString());
|
|
}
|
|
|
|
}
|
|
|
|
base.Complete(synchronous);
|
|
}
|
|
|
|
new void Complete(bool synchronous, Exception exception)
|
|
{
|
|
try
|
|
{
|
|
this.channel.receiveLock.Exit();
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
if (DiagnosticUtility.ShouldTraceWarning)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.AsyncCallbackThrewException, SR.GetString(SR.TraceCodeAsyncCallbackThrewException), e.ToString());
|
|
}
|
|
|
|
}
|
|
|
|
base.Complete(synchronous, exception);
|
|
}
|
|
|
|
static ReceiveRequestAsyncResult End(IAsyncResult result)
|
|
{
|
|
return AsyncResult.End<ReceiveRequestAsyncResult>(result);
|
|
}
|
|
|
|
public static bool EndAsMessage(IAsyncResult result, out Message message)
|
|
{
|
|
ReceiveRequestAsyncResult receiveResult = End(result);
|
|
message = receiveResult.requestMessage;
|
|
// if the message is not null, then dispose the inner request context
|
|
// if the message is null its either a close or protocol fault in which case the request context
|
|
// will be closed by the channel
|
|
if (message != null)
|
|
{
|
|
if (receiveResult.innerRequestContext != null)
|
|
{
|
|
try
|
|
{
|
|
receiveResult.innerRequestContext.Close(receiveResult.timeoutHelper.RemainingTime());
|
|
}
|
|
catch (TimeoutException e)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, System.Diagnostics.TraceEventType.Information);
|
|
}
|
|
}
|
|
}
|
|
return !receiveResult.expired;
|
|
}
|
|
|
|
public static bool EndAsRequestContext(IAsyncResult result, out RequestContext requestContext)
|
|
{
|
|
ReceiveRequestAsyncResult receiveResult = End(result);
|
|
|
|
if (receiveResult.requestMessage == null)
|
|
{
|
|
requestContext = null;
|
|
}
|
|
else
|
|
{
|
|
requestContext = new SecuritySessionRequestContext(receiveResult.innerRequestContext, receiveResult.requestMessage, receiveResult.correlationState, receiveResult.channel);
|
|
}
|
|
|
|
return !receiveResult.expired;
|
|
}
|
|
|
|
static void OnReceive(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
return;
|
|
|
|
ReceiveRequestAsyncResult self = (ReceiveRequestAsyncResult)result.AsyncState;
|
|
bool completeSelf = false;
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
completeSelf = self.CompleteReceive(result);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
completeSelf = true;
|
|
completionException = e;
|
|
}
|
|
if (completeSelf)
|
|
{
|
|
self.Complete(false, completionException);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
abstract class ServerSecuritySimplexSessionChannel : ServerSecuritySessionChannel
|
|
{
|
|
SoapSecurityInputSession session;
|
|
bool receivedClose;
|
|
bool canSendCloseResponse;
|
|
bool sentCloseResponse;
|
|
RequestContext closeRequestContext;
|
|
Message closeResponse;
|
|
InterruptibleWaitObject inputSessionClosedHandle = new InterruptibleWaitObject(false);
|
|
|
|
public ServerSecuritySimplexSessionChannel(
|
|
SecuritySessionServerSettings settings,
|
|
IServerReliableChannelBinder channelBinder,
|
|
SecurityContextSecurityToken sessionToken,
|
|
object listenerSecurityState, SecurityListenerSettingsLifetimeManager settingsLifetimeManager)
|
|
: base(settings, channelBinder, sessionToken, listenerSecurityState, settingsLifetimeManager)
|
|
{
|
|
this.session = new SoapSecurityInputSession(sessionToken, settings, this);
|
|
}
|
|
|
|
public IInputSession Session
|
|
{
|
|
get
|
|
{
|
|
return this.session;
|
|
}
|
|
}
|
|
|
|
void CleanupPendingCloseState()
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (this.closeResponse != null)
|
|
{
|
|
this.closeResponse.Close();
|
|
this.closeResponse = null;
|
|
}
|
|
if (this.closeRequestContext != null)
|
|
{
|
|
this.closeRequestContext.Abort();
|
|
this.closeRequestContext = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void AbortCore()
|
|
{
|
|
base.AbortCore();
|
|
this.Settings.RemoveSessionChannel(this.session.Id);
|
|
CleanupPendingCloseState();
|
|
}
|
|
|
|
protected override void CloseCore(TimeSpan timeout)
|
|
{
|
|
base.CloseCore(timeout);
|
|
this.inputSessionClosedHandle.Abort(this);
|
|
this.Settings.RemoveSessionChannel(this.session.Id);
|
|
}
|
|
|
|
protected override void EndCloseCore(IAsyncResult result)
|
|
{
|
|
base.EndCloseCore(result);
|
|
this.inputSessionClosedHandle.Abort(this);
|
|
this.Settings.RemoveSessionChannel(this.session.Id);
|
|
}
|
|
|
|
protected override void OnAbort()
|
|
{
|
|
AbortCore();
|
|
this.inputSessionClosedHandle.Abort(this);
|
|
}
|
|
|
|
protected override void OnFaulted()
|
|
{
|
|
this.AbortCore();
|
|
this.inputSessionClosedHandle.Fault(this);
|
|
base.OnFaulted();
|
|
}
|
|
|
|
bool ShouldSendCloseResponseOnClose(out RequestContext pendingCloseRequestContext, out Message pendingCloseResponse)
|
|
{
|
|
bool sendCloseResponse = false;
|
|
lock (ThisLock)
|
|
{
|
|
this.canSendCloseResponse = true;
|
|
if (!this.sentCloseResponse && this.receivedClose && this.closeResponse != null)
|
|
{
|
|
this.sentCloseResponse = true;
|
|
sendCloseResponse = true;
|
|
pendingCloseRequestContext = this.closeRequestContext;
|
|
pendingCloseResponse = this.closeResponse;
|
|
this.closeResponse = null;
|
|
this.closeRequestContext = null;
|
|
}
|
|
else
|
|
{
|
|
canSendCloseResponse = false;
|
|
pendingCloseRequestContext = null;
|
|
pendingCloseResponse = null;
|
|
}
|
|
}
|
|
return sendCloseResponse;
|
|
}
|
|
|
|
bool SendCloseResponseOnCloseIfRequired(TimeSpan timeout)
|
|
{
|
|
bool aborted = false;
|
|
RequestContext pendingCloseRequestContext;
|
|
Message pendingCloseResponse;
|
|
bool sendCloseResponse = ShouldSendCloseResponseOnClose(out pendingCloseRequestContext, out pendingCloseResponse);
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
bool cleanupCloseState = true;
|
|
if (sendCloseResponse)
|
|
{
|
|
try
|
|
{
|
|
this.SendCloseResponse(pendingCloseRequestContext, pendingCloseResponse, timeoutHelper.RemainingTime());
|
|
this.inputSessionClosedHandle.Set();
|
|
cleanupCloseState = false;
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
aborted = true;
|
|
}
|
|
finally
|
|
{
|
|
if (cleanupCloseState)
|
|
{
|
|
if (pendingCloseResponse != null)
|
|
{
|
|
pendingCloseResponse.Close();
|
|
}
|
|
if (pendingCloseRequestContext != null)
|
|
{
|
|
pendingCloseRequestContext.Abort();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return aborted;
|
|
}
|
|
|
|
protected override void OnClose(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
|
|
// send a close response if one was not sent yet
|
|
bool wasAborted = SendCloseResponseOnCloseIfRequired(timeoutHelper.RemainingTime());
|
|
if (wasAborted)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool wasInputSessionClosed = this.WaitForInputSessionClose(timeoutHelper.RemainingTime(), out wasAborted);
|
|
if (wasAborted)
|
|
{
|
|
return;
|
|
}
|
|
if (!wasInputSessionClosed)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new TimeoutException(SR.GetString(SR.ServiceSecurityCloseTimeout, timeoutHelper.OriginalTimeout)));
|
|
}
|
|
else
|
|
{
|
|
this.CloseCore(timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
RequestContext pendingCloseRequestContext;
|
|
Message pendingCloseResponse;
|
|
bool sendCloseResponse = ShouldSendCloseResponseOnClose(out pendingCloseRequestContext, out pendingCloseResponse);
|
|
return new CloseAsyncResult(this, sendCloseResponse, pendingCloseRequestContext, pendingCloseResponse, timeout, callback, state);
|
|
}
|
|
|
|
protected override void OnEndClose(IAsyncResult result)
|
|
{
|
|
CloseAsyncResult.End(result);
|
|
}
|
|
|
|
bool WaitForInputSessionClose(TimeSpan timeout, out bool wasAborted)
|
|
{
|
|
Message message;
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
wasAborted = false;
|
|
try
|
|
{
|
|
if (this.TryReceive(timeoutHelper.RemainingTime(), out message))
|
|
{
|
|
if (message != null)
|
|
{
|
|
using (message)
|
|
{
|
|
ProtocolException error = ProtocolException.ReceiveShutdownReturnedNonNull(message);
|
|
throw TraceUtility.ThrowHelperWarning(error, message);
|
|
}
|
|
}
|
|
return this.inputSessionClosedHandle.Wait(timeoutHelper.RemainingTime(), false);
|
|
}
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
wasAborted = true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
protected override void OnCloseResponseMessageReceived(RequestContext requestContext, Message message, SecurityProtocolCorrelationState correlationState, TimeSpan timeout)
|
|
{
|
|
// we dont expect a close-response for non-duplex security session
|
|
message.Close();
|
|
requestContext.Abort();
|
|
this.Fault(new ProtocolException(SR.GetString(SR.UnexpectedSecuritySessionCloseResponse)));
|
|
}
|
|
|
|
protected override void OnCloseMessageReceived(RequestContext requestContext, Message message, SecurityProtocolCorrelationState correlationState, TimeSpan timeout)
|
|
{
|
|
if (this.State == CommunicationState.Created)
|
|
{
|
|
Fx.Assert("ServerSecuritySimplexSessionChannel.OnCloseMessageReceived (this.State == Created)");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ServerReceivedCloseMessageStateIsCreated, this.GetType().ToString())));
|
|
}
|
|
|
|
if (SendCloseResponseOnCloseReceivedIfRequired(requestContext, message, correlationState, timeout))
|
|
{
|
|
this.inputSessionClosedHandle.Set();
|
|
}
|
|
}
|
|
|
|
bool SendCloseResponseOnCloseReceivedIfRequired(RequestContext requestContext, Message message, SecurityProtocolCorrelationState correlationState, TimeSpan timeout)
|
|
{
|
|
bool sendCloseResponse = false;
|
|
ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? TraceUtility.ExtractActivity(message) : null;
|
|
bool cleanupContext = true;
|
|
try
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
Message localCloseResponse = null;
|
|
lock (ThisLock)
|
|
{
|
|
if (!this.receivedClose)
|
|
{
|
|
this.receivedClose = true;
|
|
localCloseResponse = CreateCloseResponse(message, correlationState, timeoutHelper.RemainingTime());
|
|
if (canSendCloseResponse)
|
|
{
|
|
this.sentCloseResponse = true;
|
|
sendCloseResponse = true;
|
|
}
|
|
else
|
|
{
|
|
// save the close requestContext to reply later
|
|
this.closeRequestContext = requestContext;
|
|
this.closeResponse = localCloseResponse;
|
|
cleanupContext = false;
|
|
}
|
|
}
|
|
}
|
|
if (sendCloseResponse)
|
|
{
|
|
this.SendCloseResponse(requestContext, localCloseResponse, timeoutHelper.RemainingTime());
|
|
cleanupContext = false;
|
|
}
|
|
else if (cleanupContext)
|
|
{
|
|
requestContext.Close(timeoutHelper.RemainingTime());
|
|
cleanupContext = false;
|
|
}
|
|
return sendCloseResponse;
|
|
}
|
|
finally
|
|
{
|
|
message.Close();
|
|
if (cleanupContext)
|
|
{
|
|
requestContext.Abort();
|
|
}
|
|
if (DiagnosticUtility.ShouldUseActivity && (activity != null))
|
|
{
|
|
activity.Stop();
|
|
}
|
|
}
|
|
}
|
|
|
|
class CloseAsyncResult : AsyncResult
|
|
{
|
|
static readonly AsyncCallback sendCloseResponseCallback = Fx.ThunkCallback(new AsyncCallback(SendCloseResponseCallback));
|
|
static readonly AsyncCallback receiveCallback = Fx.ThunkCallback(new AsyncCallback(ReceiveCallback));
|
|
static readonly AsyncCallback waitCallback = Fx.ThunkCallback(new AsyncCallback(WaitForInputSessionCloseCallback));
|
|
static readonly AsyncCallback closeCoreCallback = Fx.ThunkCallback(new AsyncCallback(CloseCoreCallback));
|
|
|
|
ServerSecuritySimplexSessionChannel sessionChannel;
|
|
TimeoutHelper timeoutHelper;
|
|
RequestContext closeRequestContext;
|
|
Message closeResponse;
|
|
|
|
public CloseAsyncResult(ServerSecuritySimplexSessionChannel sessionChannel, bool sendCloseResponse, RequestContext closeRequestContext, Message closeResponse, TimeSpan timeout, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
this.timeoutHelper = new TimeoutHelper(timeout);
|
|
this.sessionChannel = sessionChannel;
|
|
this.closeRequestContext = closeRequestContext;
|
|
this.closeResponse = closeResponse;
|
|
bool wasChannelAborted = false;
|
|
bool completeSelf = this.OnSendCloseResponse(sendCloseResponse, out wasChannelAborted);
|
|
if (wasChannelAborted || completeSelf)
|
|
{
|
|
Complete(true);
|
|
}
|
|
}
|
|
|
|
bool OnSendCloseResponse(bool shouldSendCloseResponse, out bool wasChannelAborted)
|
|
{
|
|
wasChannelAborted = false;
|
|
try
|
|
{
|
|
if (shouldSendCloseResponse)
|
|
{
|
|
bool cleanupCloseState = true;
|
|
try
|
|
{
|
|
IAsyncResult result = this.sessionChannel.BeginSendCloseResponse(closeRequestContext, closeResponse, timeoutHelper.RemainingTime(), sendCloseResponseCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
cleanupCloseState = false;
|
|
return false;
|
|
}
|
|
this.sessionChannel.EndSendCloseResponse(result);
|
|
this.sessionChannel.inputSessionClosedHandle.Set();
|
|
}
|
|
finally
|
|
{
|
|
if (cleanupCloseState)
|
|
{
|
|
CleanupCloseState();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
wasChannelAborted = true;
|
|
}
|
|
if (wasChannelAborted)
|
|
{
|
|
return true;
|
|
}
|
|
return this.OnReceiveNullMessage(out wasChannelAborted);
|
|
}
|
|
|
|
void CleanupCloseState()
|
|
{
|
|
if (this.closeResponse != null)
|
|
{
|
|
this.closeResponse.Close();
|
|
}
|
|
if (this.closeRequestContext != null)
|
|
{
|
|
this.closeRequestContext.Abort();
|
|
}
|
|
}
|
|
|
|
static void SendCloseResponseCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseAsyncResult thisResult = (CloseAsyncResult)result.AsyncState;
|
|
bool completeSelf = false;
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
bool wasAborted = false;
|
|
try
|
|
{
|
|
thisResult.sessionChannel.EndSendCloseResponse(result);
|
|
thisResult.sessionChannel.inputSessionClosedHandle.Set();
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (thisResult.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
wasAborted = true;
|
|
completeSelf = true;
|
|
}
|
|
finally
|
|
{
|
|
thisResult.CleanupCloseState();
|
|
}
|
|
if (!wasAborted)
|
|
{
|
|
completeSelf = thisResult.OnReceiveNullMessage(out wasAborted);
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
completeSelf = true;
|
|
completionException = e;
|
|
}
|
|
if (completeSelf)
|
|
{
|
|
thisResult.Complete(false, completionException);
|
|
}
|
|
}
|
|
|
|
bool OnReceiveNullMessage(out bool wasChannelAborted)
|
|
{
|
|
wasChannelAborted = false;
|
|
bool receivedMessage = false;
|
|
Message message = null;
|
|
try
|
|
{
|
|
IAsyncResult result = this.sessionChannel.BeginTryReceive(this.timeoutHelper.RemainingTime(), receiveCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return false;
|
|
}
|
|
receivedMessage = this.sessionChannel.EndTryReceive(result, out message);
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
// another thread aborted the channel
|
|
wasChannelAborted = true;
|
|
}
|
|
if (wasChannelAborted)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (receivedMessage)
|
|
{
|
|
return this.OnMessageReceived(message);
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.GetString(SR.ServiceSecurityCloseTimeout, timeoutHelper.OriginalTimeout)));
|
|
}
|
|
}
|
|
|
|
static void ReceiveCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseAsyncResult thisResult = (CloseAsyncResult)result.AsyncState;
|
|
bool completeSelf = false;
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
Message message = null;
|
|
bool wasAborted = false;
|
|
bool receivedMessage = false;
|
|
try
|
|
{
|
|
receivedMessage = thisResult.sessionChannel.EndTryReceive(result, out message);
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (thisResult.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
wasAborted = true;
|
|
completeSelf = true;
|
|
}
|
|
if (!wasAborted)
|
|
{
|
|
if (receivedMessage)
|
|
{
|
|
completeSelf = thisResult.OnMessageReceived(message);
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.GetString(SR.ServiceSecurityCloseTimeout, thisResult.timeoutHelper.OriginalTimeout)));
|
|
}
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
completeSelf = true;
|
|
completionException = e;
|
|
}
|
|
if (completeSelf)
|
|
{
|
|
thisResult.Complete(false, completionException);
|
|
}
|
|
}
|
|
|
|
bool OnMessageReceived(Message message)
|
|
{
|
|
if (message != null)
|
|
{
|
|
using (message)
|
|
{
|
|
ProtocolException error = ProtocolException.ReceiveShutdownReturnedNonNull(message);
|
|
throw TraceUtility.ThrowHelperWarning(error, message);
|
|
}
|
|
}
|
|
bool inputSessionClosed = false;
|
|
try
|
|
{
|
|
IAsyncResult result = this.sessionChannel.inputSessionClosedHandle.BeginWait(this.timeoutHelper.RemainingTime(), true, waitCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return false;
|
|
}
|
|
this.sessionChannel.inputSessionClosedHandle.EndWait(result);
|
|
inputSessionClosed = true;
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
// a parallel thread aborted the channel
|
|
return true;
|
|
}
|
|
catch (TimeoutException)
|
|
{
|
|
inputSessionClosed = false;
|
|
}
|
|
|
|
return this.OnWaitOver(inputSessionClosed);
|
|
}
|
|
|
|
static void WaitForInputSessionCloseCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseAsyncResult thisResult = (CloseAsyncResult)result.AsyncState;
|
|
bool completeSelf = false;
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
bool inputSessionClosed = false;
|
|
bool wasChannelAborted = false;
|
|
try
|
|
{
|
|
thisResult.sessionChannel.inputSessionClosedHandle.EndWait(result);
|
|
inputSessionClosed = true;
|
|
}
|
|
catch (TimeoutException)
|
|
{
|
|
inputSessionClosed = false;
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (thisResult.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
wasChannelAborted = true;
|
|
completeSelf = true;
|
|
}
|
|
if (!wasChannelAborted)
|
|
{
|
|
completeSelf = thisResult.OnWaitOver(inputSessionClosed);
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
completeSelf = true;
|
|
completionException = e;
|
|
}
|
|
if (completeSelf)
|
|
{
|
|
thisResult.Complete(false, completionException);
|
|
}
|
|
}
|
|
|
|
bool OnWaitOver(bool closeCompleted)
|
|
{
|
|
if (closeCompleted)
|
|
{
|
|
IAsyncResult result = this.sessionChannel.BeginCloseCore(this.timeoutHelper.RemainingTime(), closeCoreCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return false;
|
|
}
|
|
this.sessionChannel.EndCloseCore(result);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new TimeoutException(SR.GetString(SR.ServiceSecurityCloseTimeout, this.timeoutHelper.OriginalTimeout)));
|
|
}
|
|
}
|
|
|
|
static void CloseCoreCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseAsyncResult self = (CloseAsyncResult)(result.AsyncState);
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
self.sessionChannel.EndCloseCore(result);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
completionException = e;
|
|
}
|
|
self.Complete(false, completionException);
|
|
}
|
|
|
|
public static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<CloseAsyncResult>(result);
|
|
}
|
|
}
|
|
}
|
|
|
|
class SecurityReplySessionChannel : ServerSecuritySimplexSessionChannel, IReplySessionChannel
|
|
{
|
|
public SecurityReplySessionChannel(
|
|
SecuritySessionServerSettings settings,
|
|
IServerReliableChannelBinder channelBinder,
|
|
SecurityContextSecurityToken sessionToken,
|
|
object listenerSecurityState, SecurityListenerSettingsLifetimeManager settingsLifetimeManager)
|
|
: base(settings, channelBinder, sessionToken, listenerSecurityState, settingsLifetimeManager)
|
|
{
|
|
}
|
|
|
|
protected override bool CanDoSecurityCorrelation
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool WaitForRequest(TimeSpan timeout)
|
|
{
|
|
return this.ChannelBinder.WaitForRequest(timeout);
|
|
}
|
|
|
|
public IAsyncResult BeginWaitForRequest(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return this.ChannelBinder.BeginWaitForRequest(timeout, callback, state);
|
|
}
|
|
|
|
public bool EndWaitForRequest(IAsyncResult result)
|
|
{
|
|
return this.ChannelBinder.EndWaitForRequest(result);
|
|
}
|
|
}
|
|
|
|
class SecuritySessionRequestContext : RequestContextBase
|
|
{
|
|
RequestContext requestContext;
|
|
ServerSecuritySessionChannel channel;
|
|
SecurityProtocolCorrelationState correlationState;
|
|
|
|
public SecuritySessionRequestContext(RequestContext requestContext, Message requestMessage, SecurityProtocolCorrelationState correlationState, ServerSecuritySessionChannel channel)
|
|
: base(requestMessage, channel.InternalCloseTimeout, channel.InternalSendTimeout)
|
|
{
|
|
this.requestContext = requestContext;
|
|
this.correlationState = correlationState;
|
|
this.channel = channel;
|
|
}
|
|
|
|
protected override void OnAbort()
|
|
{
|
|
this.requestContext.Abort();
|
|
}
|
|
|
|
protected override void OnClose(TimeSpan timeout)
|
|
{
|
|
this.requestContext.Close(timeout);
|
|
}
|
|
|
|
protected override void OnReply(Message message, TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
if (message != null)
|
|
{
|
|
this.channel.SecureApplicationMessage(ref message, timeoutHelper.RemainingTime(), correlationState);
|
|
}
|
|
this.requestContext.Reply(message, timeoutHelper.RemainingTime());
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginReply(Message message, TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
if (message != null)
|
|
{
|
|
this.channel.SecureApplicationMessage(ref message, timeoutHelper.RemainingTime(), correlationState);
|
|
}
|
|
return this.requestContext.BeginReply(message, timeoutHelper.RemainingTime(), callback, state);
|
|
}
|
|
|
|
protected override void OnEndReply(IAsyncResult result)
|
|
{
|
|
this.requestContext.EndReply(result);
|
|
}
|
|
}
|
|
|
|
class ServerSecurityDuplexSessionChannel : ServerSecuritySessionChannel, IDuplexSessionChannel
|
|
{
|
|
SoapSecurityServerDuplexSession session;
|
|
bool isInputClosed;
|
|
bool isOutputClosed;
|
|
bool sentClose;
|
|
bool receivedClose;
|
|
RequestContext closeRequestContext;
|
|
Message closeResponseMessage;
|
|
InterruptibleWaitObject outputSessionCloseHandle = new InterruptibleWaitObject(true);
|
|
InterruptibleWaitObject inputSessionCloseHandle = new InterruptibleWaitObject(false);
|
|
|
|
public ServerSecurityDuplexSessionChannel(
|
|
SecuritySessionServerSettings settings,
|
|
IServerReliableChannelBinder channelBinder,
|
|
SecurityContextSecurityToken sessionToken,
|
|
object listenerSecurityState, SecurityListenerSettingsLifetimeManager settingsLifetimeManager)
|
|
: base(settings, channelBinder, sessionToken, listenerSecurityState, settingsLifetimeManager)
|
|
{
|
|
this.session = new SoapSecurityServerDuplexSession(sessionToken, settings, this);
|
|
}
|
|
|
|
public EndpointAddress RemoteAddress
|
|
{
|
|
get
|
|
{
|
|
return this.ChannelBinder.RemoteAddress;
|
|
}
|
|
}
|
|
|
|
public Uri Via
|
|
{
|
|
get
|
|
{
|
|
return this.RemoteAddress.Uri;
|
|
}
|
|
}
|
|
|
|
public IDuplexSession Session
|
|
{
|
|
get
|
|
{
|
|
return this.session;
|
|
}
|
|
}
|
|
|
|
public void Send(Message message)
|
|
{
|
|
this.Send(message, this.DefaultSendTimeout);
|
|
}
|
|
|
|
public void Send(Message message, TimeSpan timeout)
|
|
{
|
|
CheckOutputOpen();
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
this.SecureApplicationMessage(ref message, timeoutHelper.RemainingTime(), null);
|
|
this.ChannelBinder.Send(message, timeoutHelper.RemainingTime());
|
|
}
|
|
|
|
public IAsyncResult BeginSend(Message message, AsyncCallback callback, object state)
|
|
{
|
|
return this.BeginSend(message, this.DefaultSendTimeout, callback, state);
|
|
}
|
|
|
|
public IAsyncResult BeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
CheckOutputOpen();
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
this.SecureApplicationMessage(ref message, timeoutHelper.RemainingTime(), null);
|
|
return this.ChannelBinder.BeginSend(message, timeoutHelper.RemainingTime(), callback, state);
|
|
}
|
|
|
|
public void EndSend(IAsyncResult result)
|
|
{
|
|
this.ChannelBinder.EndSend(result);
|
|
}
|
|
|
|
protected override void AbortCore()
|
|
{
|
|
base.AbortCore();
|
|
this.Settings.RemoveSessionChannel(this.session.Id);
|
|
CleanupPendingCloseState();
|
|
}
|
|
|
|
void CleanupPendingCloseState()
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (this.closeResponseMessage != null)
|
|
{
|
|
this.closeResponseMessage.Close();
|
|
this.closeResponseMessage = null;
|
|
}
|
|
if (this.closeRequestContext != null)
|
|
{
|
|
this.closeRequestContext.Abort();
|
|
this.closeRequestContext = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnAbort()
|
|
{
|
|
AbortCore();
|
|
this.inputSessionCloseHandle.Abort(this);
|
|
this.outputSessionCloseHandle.Abort(this);
|
|
}
|
|
|
|
protected override void OnFaulted()
|
|
{
|
|
this.AbortCore();
|
|
this.inputSessionCloseHandle.Fault(this);
|
|
this.outputSessionCloseHandle.Fault(this);
|
|
base.OnFaulted();
|
|
}
|
|
|
|
protected override void CloseCore(TimeSpan timeout)
|
|
{
|
|
base.CloseCore(timeout);
|
|
this.inputSessionCloseHandle.Abort(this);
|
|
this.outputSessionCloseHandle.Abort(this);
|
|
this.Settings.RemoveSessionChannel(this.session.Id);
|
|
}
|
|
|
|
protected override void EndCloseCore(IAsyncResult result)
|
|
{
|
|
base.EndCloseCore(result);
|
|
this.inputSessionCloseHandle.Abort(this);
|
|
this.outputSessionCloseHandle.Abort(this);
|
|
this.Settings.RemoveSessionChannel(this.session.Id);
|
|
}
|
|
|
|
protected void CheckOutputOpen()
|
|
{
|
|
ThrowIfClosedOrNotOpen();
|
|
lock (ThisLock)
|
|
{
|
|
if (this.isOutputClosed)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new CommunicationException(SR.GetString(SR.OutputNotExpected)));
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new CloseAsyncResult(this, timeout, callback, state);
|
|
}
|
|
|
|
protected override void OnEndClose(IAsyncResult result)
|
|
{
|
|
CloseAsyncResult.End(result);
|
|
}
|
|
|
|
internal bool WaitForOutputSessionClose(TimeSpan timeout, out bool wasAborted)
|
|
{
|
|
wasAborted = false;
|
|
try
|
|
{
|
|
return this.outputSessionCloseHandle.Wait(timeout, false);
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.State != CommunicationState.Closed) throw;
|
|
wasAborted = true;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
protected override void OnClose(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
|
|
// step 1: close output session
|
|
this.CloseOutputSession(timeoutHelper.RemainingTime());
|
|
|
|
// if the channel was aborted while closing the output session, return
|
|
if (this.State == CommunicationState.Closed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// step 2: wait for input session to be closed
|
|
bool wasAborted;
|
|
bool didInputSessionClose = this.WaitForInputSessionClose(timeoutHelper.RemainingTime(), out wasAborted);
|
|
if (wasAborted)
|
|
{
|
|
return;
|
|
}
|
|
if (!didInputSessionClose)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new TimeoutException(SR.GetString(SR.ServiceSecurityCloseTimeout, timeoutHelper.OriginalTimeout)));
|
|
}
|
|
|
|
// wait for any concurrent CloseOutputSessions to finish
|
|
bool didOutputSessionClose = this.WaitForOutputSessionClose(timeoutHelper.RemainingTime(), out wasAborted);
|
|
if (wasAborted)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!didOutputSessionClose)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new TimeoutException(SR.GetString(SR.ServiceSecurityCloseOutputSessionTimeout, timeoutHelper.OriginalTimeout)));
|
|
}
|
|
|
|
this.CloseCore(timeoutHelper.RemainingTime());
|
|
}
|
|
|
|
bool WaitForInputSessionClose(TimeSpan timeout, out bool wasAborted)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
Message message;
|
|
wasAborted = false;
|
|
try
|
|
{
|
|
if (!this.TryReceive(timeoutHelper.RemainingTime(), out message))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (message != null)
|
|
{
|
|
using (message)
|
|
{
|
|
ProtocolException error = ProtocolException.ReceiveShutdownReturnedNonNull(message);
|
|
throw TraceUtility.ThrowHelperWarning(error, message);
|
|
}
|
|
}
|
|
|
|
// wait for remote close
|
|
if (!this.inputSessionCloseHandle.Wait(timeoutHelper.RemainingTime(), false))
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (!(this.isInputClosed))
|
|
{
|
|
Fx.Assert("Shutdown request was not received.");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ShutdownRequestWasNotReceived)));
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
wasAborted = true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
protected override void OnCloseMessageReceived(RequestContext requestContext, Message message, SecurityProtocolCorrelationState correlationState, TimeSpan timeout)
|
|
{
|
|
if (this.State == CommunicationState.Created)
|
|
{
|
|
Fx.Assert("ServerSecurityDuplexSessionChannel.OnCloseMessageReceived (this.State == Created)");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ServerReceivedCloseMessageStateIsCreated, this.GetType().ToString())));
|
|
}
|
|
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
bool setInputSessionCloseHandle = false;
|
|
bool cleanupContext = true;
|
|
try
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
this.receivedClose = true;
|
|
if (!this.isInputClosed)
|
|
{
|
|
this.isInputClosed = true;
|
|
setInputSessionCloseHandle = true;
|
|
|
|
if (!this.isOutputClosed)
|
|
{
|
|
this.closeRequestContext = requestContext;
|
|
// CreateCloseResponse closes the message passed in
|
|
this.closeResponseMessage = CreateCloseResponse(message, null, timeoutHelper.RemainingTime());
|
|
cleanupContext = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (setInputSessionCloseHandle)
|
|
{
|
|
this.inputSessionCloseHandle.Set();
|
|
}
|
|
if (cleanupContext)
|
|
{
|
|
requestContext.Close(timeoutHelper.RemainingTime());
|
|
cleanupContext = false;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
message.Close();
|
|
if (cleanupContext)
|
|
{
|
|
requestContext.Abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnCloseResponseMessageReceived(RequestContext requestContext, Message message, SecurityProtocolCorrelationState correlationState, TimeSpan timeout)
|
|
{
|
|
bool cleanupContext = true;
|
|
try
|
|
{
|
|
bool isCloseResponseExpected = false;
|
|
bool setInputSessionCloseHandle = false;
|
|
lock (ThisLock)
|
|
{
|
|
isCloseResponseExpected = this.sentClose;
|
|
if (isCloseResponseExpected && !this.isInputClosed)
|
|
{
|
|
this.isInputClosed = true;
|
|
setInputSessionCloseHandle = true;
|
|
}
|
|
}
|
|
if (!isCloseResponseExpected)
|
|
{
|
|
this.Fault(new ProtocolException(SR.GetString(SR.UnexpectedSecuritySessionCloseResponse)));
|
|
return;
|
|
}
|
|
if (setInputSessionCloseHandle)
|
|
{
|
|
this.inputSessionCloseHandle.Set();
|
|
}
|
|
|
|
requestContext.Close(timeout);
|
|
cleanupContext = false;
|
|
}
|
|
finally
|
|
{
|
|
message.Close();
|
|
if (cleanupContext)
|
|
{
|
|
requestContext.Abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
void DetermineCloseOutputSessionMessage(out bool sendClose, out bool sendCloseResponse, out Message pendingCloseResponseMessage, out RequestContext pendingCloseRequestContext)
|
|
{
|
|
sendClose = false;
|
|
sendCloseResponse = false;
|
|
pendingCloseResponseMessage = null;
|
|
pendingCloseRequestContext = null;
|
|
lock (ThisLock)
|
|
{
|
|
if (!this.isOutputClosed)
|
|
{
|
|
this.isOutputClosed = true;
|
|
if (this.receivedClose)
|
|
{
|
|
if (this.closeResponseMessage != null)
|
|
{
|
|
pendingCloseResponseMessage = this.closeResponseMessage;
|
|
pendingCloseRequestContext = this.closeRequestContext;
|
|
this.closeResponseMessage = null;
|
|
this.closeRequestContext = null;
|
|
sendCloseResponse = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendClose = true;
|
|
this.sentClose = true;
|
|
}
|
|
this.outputSessionCloseHandle.Reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CloseOutputSession(TimeSpan timeout)
|
|
{
|
|
bool sendClose = false;
|
|
bool sendCloseResponse = false;
|
|
Message pendingCloseResponseMessage;
|
|
RequestContext pendingCloseRequestContext;
|
|
try
|
|
{
|
|
DetermineCloseOutputSessionMessage(out sendClose, out sendCloseResponse, out pendingCloseResponseMessage, out pendingCloseRequestContext);
|
|
if (sendCloseResponse)
|
|
{
|
|
bool cleanupCloseState = true;
|
|
try
|
|
{
|
|
this.SendCloseResponse(pendingCloseRequestContext, pendingCloseResponseMessage, timeout);
|
|
cleanupCloseState = false;
|
|
}
|
|
finally
|
|
{
|
|
if (cleanupCloseState)
|
|
{
|
|
pendingCloseResponseMessage.Close();
|
|
pendingCloseRequestContext.Abort();
|
|
}
|
|
}
|
|
}
|
|
else if (sendClose)
|
|
{
|
|
this.SendClose(timeout);
|
|
}
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.State != CommunicationState.Closed) throw;
|
|
// a parallel thread aborted the channel. ignore the exception
|
|
}
|
|
finally
|
|
{
|
|
if (sendClose || sendCloseResponse)
|
|
{
|
|
this.outputSessionCloseHandle.Set();
|
|
}
|
|
}
|
|
}
|
|
|
|
IAsyncResult BeginCloseOutputSession(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new CloseOutputSessionAsyncResult(this, timeout, callback, state);
|
|
}
|
|
|
|
void EndCloseOutputSession(IAsyncResult result)
|
|
{
|
|
CloseOutputSessionAsyncResult.End(result);
|
|
}
|
|
|
|
public bool WaitForMessage(TimeSpan timeout)
|
|
{
|
|
return this.ChannelBinder.WaitForRequest(timeout);
|
|
}
|
|
|
|
public IAsyncResult BeginWaitForMessage(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return this.ChannelBinder.BeginWaitForRequest(timeout, callback, state);
|
|
}
|
|
|
|
public bool EndWaitForMessage(IAsyncResult result)
|
|
{
|
|
return this.ChannelBinder.EndWaitForRequest(result);
|
|
}
|
|
|
|
class CloseOutputSessionAsyncResult : AsyncResult
|
|
{
|
|
static AsyncCallback sendCallback = Fx.ThunkCallback(new AsyncCallback(SendCallback));
|
|
ServerSecurityDuplexSessionChannel sessionChannel;
|
|
TimeoutHelper timeoutHelper;
|
|
bool sendClose;
|
|
bool sendCloseResponse;
|
|
Message closeResponseMessage;
|
|
RequestContext closeRequestContext;
|
|
|
|
public CloseOutputSessionAsyncResult(ServerSecurityDuplexSessionChannel sessionChannel, TimeSpan timeout, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
this.sessionChannel = sessionChannel;
|
|
this.timeoutHelper = new TimeoutHelper(timeout);
|
|
this.sessionChannel.DetermineCloseOutputSessionMessage(out sendClose, out sendCloseResponse, out closeResponseMessage, out closeRequestContext);
|
|
if (!sendClose && !sendCloseResponse)
|
|
{
|
|
Complete(true);
|
|
return;
|
|
}
|
|
bool doCleanup = true;
|
|
try
|
|
{
|
|
IAsyncResult result = this.BeginSend(sendCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
doCleanup = false;
|
|
return;
|
|
}
|
|
this.EndSend(result);
|
|
}
|
|
finally
|
|
{
|
|
if (doCleanup)
|
|
{
|
|
Cleanup();
|
|
}
|
|
}
|
|
Complete(true);
|
|
}
|
|
|
|
static void SendCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseOutputSessionAsyncResult self = (CloseOutputSessionAsyncResult)(result.AsyncState);
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
self.EndSend(result);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
completionException = e;
|
|
}
|
|
self.Cleanup();
|
|
self.Complete(false, completionException);
|
|
}
|
|
|
|
IAsyncResult BeginSend(AsyncCallback callback, object state)
|
|
{
|
|
if (this.sendClose)
|
|
{
|
|
return this.sessionChannel.BeginSendClose(timeoutHelper.RemainingTime(), callback, state);
|
|
}
|
|
else
|
|
{
|
|
return this.sessionChannel.BeginSendCloseResponse(this.closeRequestContext, this.closeResponseMessage, this.timeoutHelper.RemainingTime(), callback, state);
|
|
}
|
|
}
|
|
|
|
void EndSend(IAsyncResult result)
|
|
{
|
|
if (this.sendClose)
|
|
{
|
|
this.sessionChannel.EndSendClose(result);
|
|
}
|
|
else
|
|
{
|
|
this.sessionChannel.EndSendCloseResponse(result);
|
|
}
|
|
}
|
|
|
|
void Cleanup()
|
|
{
|
|
if (this.closeResponseMessage != null)
|
|
{
|
|
this.closeResponseMessage.Close();
|
|
}
|
|
if (this.closeRequestContext != null)
|
|
{
|
|
this.closeRequestContext.Abort();
|
|
}
|
|
this.sessionChannel.outputSessionCloseHandle.Set();
|
|
}
|
|
|
|
public static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<CloseOutputSessionAsyncResult>(result);
|
|
}
|
|
}
|
|
|
|
class CloseAsyncResult : AsyncResult
|
|
{
|
|
static readonly AsyncCallback receiveCallback = Fx.ThunkCallback(new AsyncCallback(ReceiveCallback));
|
|
static readonly AsyncCallback inputSessionWaitCallback = Fx.ThunkCallback(new AsyncCallback(WaitForInputSessionCloseCallback));
|
|
static readonly AsyncCallback closeOutputSessionCallback = Fx.ThunkCallback(new AsyncCallback(CloseOutputSessionCallback));
|
|
static readonly AsyncCallback outputSessionWaitCallback = Fx.ThunkCallback(new AsyncCallback(WaitForOutputSessionCloseCallback));
|
|
static readonly AsyncCallback closeCoreCallback = Fx.ThunkCallback(new AsyncCallback(CloseCoreCallback));
|
|
ServerSecurityDuplexSessionChannel sessionChannel;
|
|
TimeoutHelper timeoutHelper;
|
|
|
|
public CloseAsyncResult(ServerSecurityDuplexSessionChannel sessionChannel, TimeSpan timeout, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
this.timeoutHelper = new TimeoutHelper(timeout);
|
|
this.sessionChannel = sessionChannel;
|
|
|
|
bool wasAborted = false;
|
|
try
|
|
{
|
|
IAsyncResult result = this.sessionChannel.BeginCloseOutputSession(timeoutHelper.RemainingTime(), closeOutputSessionCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
this.sessionChannel.EndCloseOutputSession(result);
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (sessionChannel.State != CommunicationState.Closed) throw;
|
|
// a parallel thread must have aborted the channel. No need to close
|
|
wasAborted = true;
|
|
}
|
|
if (wasAborted || this.OnOutputSessionClosed())
|
|
{
|
|
Complete(true);
|
|
}
|
|
}
|
|
|
|
static void CloseOutputSessionCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseAsyncResult thisResult = (CloseAsyncResult)result.AsyncState;
|
|
bool completeSelf = false;
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
bool wasAborted = false;
|
|
try
|
|
{
|
|
thisResult.sessionChannel.Session.EndCloseOutputSession(result);
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (thisResult.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
completeSelf = true;
|
|
wasAborted = true;
|
|
}
|
|
if (!wasAborted)
|
|
{
|
|
completeSelf = thisResult.OnOutputSessionClosed();
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
completeSelf = true;
|
|
completionException = e;
|
|
}
|
|
if (completeSelf)
|
|
{
|
|
thisResult.Complete(false, completionException);
|
|
}
|
|
}
|
|
|
|
bool OnOutputSessionClosed()
|
|
{
|
|
bool wasAborted = false;
|
|
Message message = null;
|
|
bool receivedMessage = false;
|
|
try
|
|
{
|
|
IAsyncResult result = this.sessionChannel.BeginTryReceive(this.timeoutHelper.RemainingTime(), receiveCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return false;
|
|
}
|
|
receivedMessage = this.sessionChannel.EndTryReceive(result, out message);
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
wasAborted = true;
|
|
}
|
|
if (wasAborted)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (receivedMessage)
|
|
{
|
|
return this.OnMessageReceived(message);
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.GetString(SR.ServiceSecurityCloseTimeout, this.timeoutHelper.OriginalTimeout)));
|
|
}
|
|
}
|
|
|
|
static void ReceiveCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseAsyncResult thisResult = (CloseAsyncResult)result.AsyncState;
|
|
bool completeSelf = false;
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
Message message = null;
|
|
bool receivedRequest = false;
|
|
bool wasAborted = false;
|
|
try
|
|
{
|
|
receivedRequest = thisResult.sessionChannel.EndTryReceive(result, out message);
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (thisResult.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
completeSelf = true;
|
|
wasAborted = true;
|
|
}
|
|
if (!wasAborted)
|
|
{
|
|
if (receivedRequest)
|
|
{
|
|
completeSelf = thisResult.OnMessageReceived(message);
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.GetString(SR.ServiceSecurityCloseTimeout, thisResult.timeoutHelper.OriginalTimeout)));
|
|
}
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
completeSelf = true;
|
|
completionException = e;
|
|
}
|
|
if (completeSelf)
|
|
{
|
|
thisResult.Complete(false, completionException);
|
|
}
|
|
}
|
|
|
|
bool OnMessageReceived(Message message)
|
|
{
|
|
if (message != null)
|
|
{
|
|
using (message)
|
|
{
|
|
ProtocolException error = ProtocolException.ReceiveShutdownReturnedNonNull(message);
|
|
throw TraceUtility.ThrowHelperWarning(error, message);
|
|
}
|
|
}
|
|
bool wasAborted = false;
|
|
bool inputSessionClosed = false;
|
|
try
|
|
{
|
|
IAsyncResult result = this.sessionChannel.inputSessionCloseHandle.BeginWait(this.timeoutHelper.RemainingTime(), inputSessionWaitCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return false;
|
|
}
|
|
try
|
|
{
|
|
this.sessionChannel.inputSessionCloseHandle.EndWait(result);
|
|
inputSessionClosed = true;
|
|
}
|
|
catch (TimeoutException)
|
|
{
|
|
inputSessionClosed = false;
|
|
}
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
wasAborted = true;
|
|
}
|
|
if (wasAborted)
|
|
{
|
|
return true;
|
|
}
|
|
return this.OnInputSessionWaitOver(inputSessionClosed);
|
|
}
|
|
|
|
static void WaitForInputSessionCloseCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseAsyncResult thisResult = (CloseAsyncResult)result.AsyncState;
|
|
bool completeSelf = false;
|
|
Exception completionException = null;
|
|
bool inputSessionClosed = false;
|
|
try
|
|
{
|
|
bool wasAborted = false;
|
|
try
|
|
{
|
|
thisResult.sessionChannel.inputSessionCloseHandle.EndWait(result);
|
|
inputSessionClosed = true;
|
|
}
|
|
catch (TimeoutException)
|
|
{
|
|
inputSessionClosed = false;
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (thisResult.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
wasAborted = true;
|
|
completeSelf = true;
|
|
}
|
|
if (!wasAborted)
|
|
{
|
|
completeSelf = thisResult.OnInputSessionWaitOver(inputSessionClosed);
|
|
}
|
|
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
completeSelf = true;
|
|
completionException = e;
|
|
}
|
|
if (completeSelf)
|
|
{
|
|
thisResult.Complete(false, completionException);
|
|
}
|
|
}
|
|
|
|
bool OnInputSessionWaitOver(bool inputSessionClosed)
|
|
{
|
|
if (inputSessionClosed)
|
|
{
|
|
lock (this.sessionChannel.ThisLock)
|
|
{
|
|
if (!(this.sessionChannel.isInputClosed))
|
|
{
|
|
Fx.Assert("Shutdown request was not received.");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ShutdownRequestWasNotReceived)));
|
|
}
|
|
}
|
|
bool outputSessionClosed = false;
|
|
bool wasAborted = false;
|
|
try
|
|
{
|
|
IAsyncResult result = this.sessionChannel.outputSessionCloseHandle.BeginWait(timeoutHelper.RemainingTime(), true, outputSessionWaitCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return false;
|
|
}
|
|
this.sessionChannel.outputSessionCloseHandle.EndWait(result);
|
|
outputSessionClosed = true;
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (this.sessionChannel.State != CommunicationState.Closed) throw;
|
|
wasAborted = true;
|
|
}
|
|
catch (TimeoutException)
|
|
{
|
|
outputSessionClosed = false;
|
|
}
|
|
if (wasAborted)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return this.OnOutputSessionWaitOver(outputSessionClosed);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new TimeoutException(SR.GetString(SR.ServiceSecurityCloseTimeout, timeoutHelper.OriginalTimeout)));
|
|
}
|
|
}
|
|
|
|
static void WaitForOutputSessionCloseCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseAsyncResult thisResult = (CloseAsyncResult)result.AsyncState;
|
|
bool completeSelf = false;
|
|
Exception completionException = null;
|
|
bool outputSessionClosed = false;
|
|
try
|
|
{
|
|
bool wasAborted = false;
|
|
try
|
|
{
|
|
thisResult.sessionChannel.outputSessionCloseHandle.EndWait(result);
|
|
outputSessionClosed = true;
|
|
}
|
|
catch (CommunicationObjectAbortedException)
|
|
{
|
|
if (thisResult.sessionChannel.State != CommunicationState.Closed)
|
|
{
|
|
throw;
|
|
}
|
|
wasAborted = true;
|
|
completeSelf = true;
|
|
}
|
|
catch (TimeoutException)
|
|
{
|
|
outputSessionClosed = false;
|
|
}
|
|
if (!wasAborted)
|
|
{
|
|
completeSelf = thisResult.OnOutputSessionWaitOver(outputSessionClosed);
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
completeSelf = true;
|
|
completionException = e;
|
|
}
|
|
if (completeSelf)
|
|
{
|
|
thisResult.Complete(false, completionException);
|
|
}
|
|
}
|
|
|
|
bool OnOutputSessionWaitOver(bool outputSessionClosed)
|
|
{
|
|
if (outputSessionClosed)
|
|
{
|
|
IAsyncResult result = this.sessionChannel.BeginCloseCore(this.timeoutHelper.RemainingTime(), closeCoreCallback, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return false;
|
|
}
|
|
this.sessionChannel.EndCloseCore(result);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new TimeoutException(SR.GetString(SR.ServiceSecurityCloseOutputSessionTimeout, timeoutHelper.OriginalTimeout)));
|
|
}
|
|
}
|
|
|
|
static void CloseCoreCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
CloseAsyncResult self = (CloseAsyncResult)(result.AsyncState);
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
self.sessionChannel.EndCloseCore(result);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
completionException = e;
|
|
}
|
|
self.Complete(false, completionException);
|
|
}
|
|
|
|
public static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<CloseAsyncResult>(result);
|
|
}
|
|
}
|
|
|
|
class SoapSecurityServerDuplexSession : SoapSecurityInputSession, IDuplexSession
|
|
{
|
|
ServerSecurityDuplexSessionChannel channel;
|
|
|
|
public SoapSecurityServerDuplexSession(SecurityContextSecurityToken sessionToken, SecuritySessionServerSettings settings, ServerSecurityDuplexSessionChannel channel)
|
|
: base(sessionToken, settings, channel)
|
|
{
|
|
this.channel = channel;
|
|
}
|
|
|
|
public void CloseOutputSession()
|
|
{
|
|
this.CloseOutputSession(this.channel.DefaultCloseTimeout);
|
|
}
|
|
|
|
public void CloseOutputSession(TimeSpan timeout)
|
|
{
|
|
this.channel.ThrowIfFaulted();
|
|
this.channel.ThrowIfNotOpened();
|
|
Exception pendingException = null;
|
|
try
|
|
{
|
|
this.channel.CloseOutputSession(timeout);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
pendingException = e;
|
|
}
|
|
if (pendingException != null)
|
|
{
|
|
this.channel.Fault(pendingException);
|
|
if (pendingException is CommunicationException)
|
|
{
|
|
throw pendingException;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(pendingException);
|
|
}
|
|
}
|
|
}
|
|
|
|
public IAsyncResult BeginCloseOutputSession(AsyncCallback callback, object state)
|
|
{
|
|
return this.BeginCloseOutputSession(this.channel.DefaultCloseTimeout, callback, state);
|
|
}
|
|
|
|
public IAsyncResult BeginCloseOutputSession(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
this.channel.ThrowIfFaulted();
|
|
this.channel.ThrowIfNotOpened();
|
|
Exception pendingException = null;
|
|
try
|
|
{
|
|
return this.channel.BeginCloseOutputSession(timeout, callback, state);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
pendingException = e;
|
|
}
|
|
if (pendingException != null)
|
|
{
|
|
this.channel.Fault(pendingException);
|
|
if (pendingException is CommunicationException)
|
|
{
|
|
throw pendingException;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(pendingException);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void EndCloseOutputSession(IAsyncResult result)
|
|
{
|
|
Exception pendingException = null;
|
|
try
|
|
{
|
|
this.channel.EndCloseOutputSession(result);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
pendingException = e;
|
|
}
|
|
if (pendingException != null)
|
|
{
|
|
this.channel.Fault(pendingException);
|
|
if (pendingException is CommunicationException)
|
|
{
|
|
throw pendingException;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(pendingException);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class SecuritySessionDemuxFailureHandler : IChannelDemuxFailureHandler
|
|
{
|
|
SecurityStandardsManager standardsManager;
|
|
|
|
public SecuritySessionDemuxFailureHandler(SecurityStandardsManager standardsManager)
|
|
{
|
|
if (standardsManager == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("standardsManager");
|
|
}
|
|
this.standardsManager = standardsManager;
|
|
}
|
|
|
|
public void HandleDemuxFailure(Message message)
|
|
{
|
|
if (message == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
|
|
}
|
|
if (DiagnosticUtility.ShouldTraceWarning)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionDemuxFailure, SR.GetString(SR.TraceCodeSecuritySessionDemuxFailure), message);
|
|
}
|
|
}
|
|
|
|
public Message CreateSessionDemuxFaultMessage(Message message)
|
|
{
|
|
MessageFault fault = SecurityUtils.CreateSecurityContextNotFoundFault(this.standardsManager, message.Headers.Action);
|
|
Message faultMessage = Message.CreateMessage(message.Version, fault, message.Version.Addressing.DefaultFaultAction);
|
|
if (message.Headers.MessageId != null)
|
|
{
|
|
faultMessage.InitializeReply(message);
|
|
}
|
|
return faultMessage;
|
|
}
|
|
|
|
IAsyncResult BeginHandleDemuxFailure<TFaultContext>(Message message, TFaultContext faultContext, AsyncCallback callback, object state)
|
|
{
|
|
this.HandleDemuxFailure(message);
|
|
Message fault = CreateSessionDemuxFaultMessage(message);
|
|
return new SendFaultAsyncResult<TFaultContext>(fault, faultContext, callback, state);
|
|
}
|
|
|
|
public IAsyncResult BeginHandleDemuxFailure(Message message, RequestContext faultContext, AsyncCallback callback, object state)
|
|
{
|
|
return BeginHandleDemuxFailure<RequestContext>(message, faultContext, callback, state);
|
|
}
|
|
|
|
public IAsyncResult BeginHandleDemuxFailure(Message message, IOutputChannel faultContext, AsyncCallback callback, object state)
|
|
{
|
|
return BeginHandleDemuxFailure<IOutputChannel>(message, faultContext, callback, state);
|
|
}
|
|
|
|
public void EndHandleDemuxFailure(IAsyncResult result)
|
|
{
|
|
if (result is SendFaultAsyncResult<RequestContext>)
|
|
{
|
|
SendFaultAsyncResult<RequestContext>.End(result);
|
|
}
|
|
else if (result is SendFaultAsyncResult<IOutputChannel>)
|
|
{
|
|
SendFaultAsyncResult<IOutputChannel>.End(result);
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.InvalidAsyncResult), "result"));
|
|
}
|
|
}
|
|
|
|
class SendFaultAsyncResult<TFaultContext> : AsyncResult
|
|
{
|
|
Message message;
|
|
static AsyncCallback sendCallback = Fx.ThunkCallback(new AsyncCallback(SendCallback));
|
|
TFaultContext faultContext;
|
|
|
|
public SendFaultAsyncResult(Message fault, TFaultContext faultContext, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
this.faultContext = faultContext;
|
|
this.message = fault;
|
|
IAsyncResult result = BeginSend(fault);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
EndSend(result);
|
|
Complete(true);
|
|
}
|
|
|
|
IAsyncResult BeginSend(Message message)
|
|
{
|
|
bool throwing = true;
|
|
try
|
|
{
|
|
IAsyncResult result = null;
|
|
if (faultContext is RequestContext)
|
|
{
|
|
result = ((RequestContext)(object)faultContext).BeginReply(message, sendCallback, this);
|
|
}
|
|
else
|
|
{
|
|
result = ((IOutputChannel)faultContext).BeginSend(message, sendCallback, this);
|
|
}
|
|
throwing = false;
|
|
return result;
|
|
}
|
|
finally
|
|
{
|
|
if (throwing && message != null)
|
|
{
|
|
message.Close();
|
|
}
|
|
}
|
|
}
|
|
|
|
void EndSend(IAsyncResult result)
|
|
{
|
|
using (this.message)
|
|
{
|
|
if (faultContext is RequestContext)
|
|
{
|
|
((RequestContext)(object)faultContext).EndReply(result);
|
|
}
|
|
else
|
|
{
|
|
((IOutputChannel)faultContext).EndSend(result);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void SendCallback(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
SendFaultAsyncResult<TFaultContext> self = (SendFaultAsyncResult<TFaultContext>)result.AsyncState;
|
|
Exception completionException = null;
|
|
try
|
|
{
|
|
self.EndSend(result);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
completionException = e;
|
|
}
|
|
self.Complete(false, completionException);
|
|
}
|
|
|
|
internal static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<SendFaultAsyncResult<TFaultContext>>(result);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|