private static HandshakeDelegate BuildHandshakeDelegateForDispatcher(IServiceDispatcher dispatcher)
{
var be = dispatcher.Binding.CreateBindingElements();
var mebe = be.Find <MessageEncodingBindingElement>();
MessageEncoderFactory mefact = mebe.CreateMessageEncoderFactory();
var tbe = be.Find <TransportBindingElement>();
int maxReceivedMessageSize = (int)Math.Min(tbe.MaxReceivedMessageSize, int.MaxValue);
var bufferManager = BufferManager.CreateBufferManager(tbe.MaxBufferPoolSize, maxReceivedMessageSize);
var upgradeBindingElements = (from element in be where element is StreamUpgradeBindingElement select element).Cast <StreamUpgradeBindingElement>().ToList();
StreamUpgradeProvider streamUpgradeProvider = null;
ISecurityCapabilities securityCapabilities = null;
if (upgradeBindingElements.Count > 1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.MultipleStreamUpgradeProvidersInParameters));
}
// TODO: Limit NamedPipes to prevent it using SslStreamSecurityUpgradeProvider
else if ((upgradeBindingElements.Count == 1) /*&& this.SupportsUpgrade(upgradeBindingElements[0])*/)
{
var bindingContext = new BindingContext(new CustomBinding(dispatcher.Binding), new BindingParameterCollection());
streamUpgradeProvider = upgradeBindingElements[0].BuildServerStreamUpgradeProvider(bindingContext);
streamUpgradeProvider.OpenAsync().GetAwaiter().GetResult();
securityCapabilities = upgradeBindingElements[0].GetProperty <ISecurityCapabilities>(bindingContext);
}
return((connection) =>
{
connection.MessageEncoderFactory = mefact;
connection.StreamUpgradeAcceptor = streamUpgradeProvider?.CreateUpgradeAcceptor();
connection.SecurityCapabilities = securityCapabilities;
connection.ServiceDispatcher = dispatcher;
connection.BufferManager = bufferManager;
return Task.CompletedTask;
});
}
public ClientFramingDuplexSessionChannel(ChannelManagerBase factory, Microsoft.ServiceBus.Channels.IConnectionOrientedTransportChannelFactorySettings settings, EndpointAddress remoteAddresss, Uri via, Microsoft.ServiceBus.Channels.IConnectionInitiator connectionInitiator, Microsoft.ServiceBus.Channels.ConnectionPool connectionPool, bool exposeConnectionProperty) : base(factory, settings, remoteAddresss, via, exposeConnectionProperty)
{
this.settings = settings;
base.MessageEncoder = settings.MessageEncoderFactory.CreateSessionEncoder();
this.upgrade = settings.Upgrade;
this.connectionPoolHelper = new Microsoft.ServiceBus.Channels.ClientFramingDuplexSessionChannel.DuplexConnectionPoolHelper(this, connectionPool, connectionInitiator);
}
private bool GetUpgradeAndConnectionPool(out StreamUpgradeProvider upgradeCopy, out Microsoft.ServiceBus.Channels.ConnectionPool poolCopy)
{
bool flag;
if (this.upgrade != null || this.connectionPool != null)
{
lock (base.ThisLock)
{
if (this.upgrade != null || this.connectionPool != null)
{
upgradeCopy = this.upgrade;
poolCopy = this.connectionPool;
this.upgrade = null;
this.connectionPool = null;
flag = true;
}
else
{
upgradeCopy = null;
poolCopy = null;
return(false);
}
}
return(flag);
}
upgradeCopy = null;
poolCopy = null;
return(false);
}
internal ConnectionOrientedTransportChannelFactory(Microsoft.ServiceBus.Channels.ConnectionOrientedTransportBindingElement bindingElement, BindingContext context, string connectionPoolGroupName, TimeSpan idleTimeout, int maxOutboundConnectionsPerEndpoint) : base(bindingElement, context)
{
if (bindingElement.TransferMode == System.ServiceModel.TransferMode.Buffered && bindingElement.MaxReceivedMessageSize > (long)2147483647)
{
throw Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("bindingElement.MaxReceivedMessageSize", Microsoft.ServiceBus.SR.GetString(Resources.MaxReceivedMessageSizeMustBeInIntegerRange, new object[0])));
}
this.connectionBufferSize = bindingElement.ConnectionBufferSize;
this.connectionPoolGroupName = connectionPoolGroupName;
this.exposeConnectionProperty = bindingElement.ExposeConnectionProperty;
this.idleTimeout = idleTimeout;
this.maxBufferSize = bindingElement.MaxBufferSize;
this.maxOutboundConnectionsPerEndpoint = maxOutboundConnectionsPerEndpoint;
this.maxOutputDelay = bindingElement.MaxOutputDelay;
this.transferMode = bindingElement.TransferMode;
Collection <StreamUpgradeBindingElement> streamUpgradeBindingElements = context.BindingParameters.FindAll <StreamUpgradeBindingElement>();
if (streamUpgradeBindingElements.Count > 1)
{
throw Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(Microsoft.ServiceBus.SR.GetString(Resources.MultipleStreamUpgradeProvidersInParameters, new object[0])));
}
if (streamUpgradeBindingElements.Count == 1)
{
this.upgrade = streamUpgradeBindingElements[0].BuildClientStreamUpgradeProvider(context);
context.BindingParameters.Remove <StreamUpgradeBindingElement>();
this.securityCapabilities = streamUpgradeBindingElements[0].GetProperty <ISecurityCapabilities>(context);
}
}
public StreamedFramingRequestChannel(ChannelManagerBase factory, Microsoft.ServiceBus.Channels.IConnectionOrientedTransportChannelFactorySettings settings, EndpointAddress remoteAddresss, Uri via, Microsoft.ServiceBus.Channels.IConnectionInitiator connectionInitiator, Microsoft.ServiceBus.Channels.ConnectionPool connectionPool) : base(factory, remoteAddresss, via, settings.ManualAddressing)
{
this.settings = settings;
this.connectionInitiator = connectionInitiator;
this.connectionPool = connectionPool;
this.messageEncoder = settings.MessageEncoderFactory.Encoder;
this.upgrade = settings.Upgrade;
this.Activity = new EventTraceActivity();
}
protected override void OnOpen(TimeSpan timeout)
{
StreamUpgradeProvider upgrade = this.Upgrade;
if (upgrade != null)
{
upgrade.Open(timeout);
}
}
protected override void OnAbort()
{
StreamUpgradeProvider upgrade = this.GetUpgrade();
if (upgrade != null)
{
upgrade.Abort();
}
base.OnAbort();
}
protected override void OnOpen(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
base.OnOpen(timeoutHelper.RemainingTime());
StreamUpgradeProvider upgrade = this.Upgrade;
if (upgrade != null)
{
upgrade.Open(timeoutHelper.RemainingTime());
}
}
protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
{
StreamUpgradeProvider upgrade = this.Upgrade;
if (upgrade == null)
{
return(base.OnBeginOpen(timeout, callback, state));
}
Microsoft.ServiceBus.Common.ChainedBeginHandler chainedBeginHandler = new Microsoft.ServiceBus.Common.ChainedBeginHandler(this.OnBeginOpen);
Microsoft.ServiceBus.Common.ChainedEndHandler chainedEndHandler = new Microsoft.ServiceBus.Common.ChainedEndHandler(this.OnEndOpen);
ICommunicationObject[] communicationObjectArray = new ICommunicationObject[] { upgrade };
return(new Microsoft.ServiceBus.Channels.ChainedOpenAsyncResult(timeout, callback, state, chainedBeginHandler, chainedEndHandler, communicationObjectArray));
}
protected override void OnClose(TimeSpan timeout)
{
StreamUpgradeProvider upgrade = this.GetUpgrade();
if (upgrade == null)
{
base.OnClose(timeout);
return;
}
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
upgrade.Close(timeoutHelper.RemainingTime());
base.OnClose(timeoutHelper.RemainingTime());
}
private StreamUpgradeProvider GetUpgrade()
{
StreamUpgradeProvider streamUpgradeProvider = null;
lock (base.ThisLock)
{
if (this.ownUpgrade)
{
streamUpgradeProvider = this.upgrade;
this.ownUpgrade = false;
}
}
return(streamUpgradeProvider);
}
public bool TransferUpgrade(StreamUpgradeProvider upgrade)
{
bool flag;
lock (base.ThisLock)
{
if (base.State == CommunicationState.Opened)
{
this.upgrade = upgrade;
flag = true;
}
else
{
flag = false;
}
}
return(flag);
}
public ServerFramingDuplexSessionChannel(Microsoft.ServiceBus.Channels.ConnectionOrientedTransportChannelListener channelListener, Microsoft.ServiceBus.Channels.ServerSessionPreambleConnectionReader preambleReader, EndpointAddress localAddress, bool exposeConnectionProperty, Microsoft.ServiceBus.Channels.ConnectionDemuxer connectionDemuxer) : base(channelListener, localAddress, preambleReader.Via, exposeConnectionProperty)
{
this.channelListener = channelListener;
this.connectionDemuxer = connectionDemuxer;
base.Connection = preambleReader.Connection;
this.decoder = preambleReader.Decoder;
this.connectionBuffer = preambleReader.connectionBuffer;
this.offset = preambleReader.BufferOffset;
this.size = preambleReader.BufferSize;
this.rawConnection = preambleReader.RawConnection;
StreamUpgradeProvider upgrade = channelListener.Upgrade;
if (upgrade != null)
{
this.upgradeAcceptor = upgrade.CreateUpgradeAcceptor();
}
MessagingClientEtwProvider.Provider.RelayChannelConnectionTransfer(base.Activity, base.Connection.Activity);
}
protected ConnectionOrientedTransportChannelListener(Microsoft.ServiceBus.Channels.ConnectionOrientedTransportBindingElement bindingElement, BindingContext context) : base(bindingElement, context, bindingElement.HostNameComparisonMode)
{
if (bindingElement.TransferMode == System.ServiceModel.TransferMode.Buffered)
{
if (bindingElement.MaxReceivedMessageSize > (long)2147483647)
{
throw Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("bindingElement.MaxReceivedMessageSize", Microsoft.ServiceBus.SR.GetString(Resources.MaxReceivedMessageSizeMustBeInIntegerRange, new object[0])));
}
if ((long)bindingElement.MaxBufferSize != bindingElement.MaxReceivedMessageSize)
{
throw Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("bindingElement", Microsoft.ServiceBus.SR.GetString(Resources.MaxBufferSizeMustMatchMaxReceivedMessageSize, new object[0]));
}
}
else if ((long)bindingElement.MaxBufferSize > bindingElement.MaxReceivedMessageSize)
{
throw Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("bindingElement", Microsoft.ServiceBus.SR.GetString(Resources.MaxBufferSizeMustNotExceedMaxReceivedMessageSize, new object[0]));
}
this.connectionBufferSize = bindingElement.ConnectionBufferSize;
this.exposeConnectionProperty = bindingElement.ExposeConnectionProperty;
base.InheritBaseAddressSettings = bindingElement.InheritBaseAddressSettings;
this.channelInitializationTimeout = bindingElement.ChannelInitializationTimeout;
this.maxBufferSize = bindingElement.MaxBufferSize;
this.maxPendingConnections = bindingElement.MaxPendingConnections;
this.maxOutputDelay = bindingElement.MaxOutputDelay;
this.maxPendingAccepts = bindingElement.MaxPendingAccepts;
this.transferMode = bindingElement.TransferMode;
Collection <StreamUpgradeBindingElement> streamUpgradeBindingElements = context.BindingParameters.FindAll <StreamUpgradeBindingElement>();
if (streamUpgradeBindingElements.Count > 1)
{
throw Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(Microsoft.ServiceBus.SR.GetString(Resources.MultipleStreamUpgradeProvidersInParameters, new object[0])));
}
if (streamUpgradeBindingElements.Count == 1)
{
this.upgrade = streamUpgradeBindingElements[0].BuildServerStreamUpgradeProvider(context);
this.ownUpgrade = true;
context.BindingParameters.Remove <StreamUpgradeBindingElement>();
this.securityCapabilities = streamUpgradeBindingElements[0].GetProperty <ISecurityCapabilities>(context);
}
}
public static Microsoft.ServiceBus.Channels.FramingDuplexSessionChannel.ConnectionDuplexSession CreateSession(Microsoft.ServiceBus.Channels.FramingDuplexSessionChannel channel, StreamUpgradeProvider upgrade)
{
if (!(upgrade is StreamSecurityUpgradeProvider))
{
return(new Microsoft.ServiceBus.Channels.FramingDuplexSessionChannel.ConnectionDuplexSession(channel));
}
return(new Microsoft.ServiceBus.Channels.FramingDuplexSessionChannel.ConnectionDuplexSession.SecureConnectionDuplexSession(channel));
}
public Microsoft.ServiceBus.Channels.IConnection CompletePreamble(TimeSpan timeout)
{
Microsoft.ServiceBus.Common.TimeoutHelper timeoutHelper = new Microsoft.ServiceBus.Common.TimeoutHelper(timeout);
if (!this.transportSettings.MessageEncoderFactory.Encoder.IsContentTypeSupported(this.decoder.ContentType))
{
this.SendFault("http://schemas.microsoft.com/ws/2006/05/framing/faults/ContentTypeInvalid", ref timeoutHelper);
ExceptionUtility exceptionUtility = Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility;
string contentTypeMismatch = Resources.ContentTypeMismatch;
object[] contentType = new object[] { this.decoder.ContentType, this.transportSettings.MessageEncoderFactory.Encoder.ContentType };
throw exceptionUtility.ThrowHelperError(new ProtocolException(Microsoft.ServiceBus.SR.GetString(contentTypeMismatch, contentType)));
}
StreamUpgradeAcceptor streamUpgradeAcceptor = null;
StreamUpgradeProvider upgrade = this.transportSettings.Upgrade;
if (upgrade != null)
{
streamUpgradeAcceptor = upgrade.CreateUpgradeAcceptor();
}
Microsoft.ServiceBus.Channels.IConnection connection = base.Connection;
while (true)
{
if (this.size == 0)
{
this.offset = 0;
this.size = connection.Read(this.connectionBuffer, 0, (int)this.connectionBuffer.Length, timeoutHelper.RemainingTime());
if (this.size == 0)
{
break;
}
}
do
{
int num = this.decoder.Decode(this.connectionBuffer, this.offset, this.size);
if (num > 0)
{
Microsoft.ServiceBus.Channels.ServerSingletonPreambleConnectionReader serverSingletonPreambleConnectionReader = this;
serverSingletonPreambleConnectionReader.offset = serverSingletonPreambleConnectionReader.offset + num;
Microsoft.ServiceBus.Channels.ServerSingletonPreambleConnectionReader serverSingletonPreambleConnectionReader1 = this;
serverSingletonPreambleConnectionReader1.size = serverSingletonPreambleConnectionReader1.size - num;
}
switch (this.decoder.CurrentState)
{
case Microsoft.ServiceBus.Channels.ServerSingletonDecoder.State.UpgradeRequest:
{
if (streamUpgradeAcceptor == null)
{
this.SendFault("http://schemas.microsoft.com/ws/2006/05/framing/faults/UpgradeInvalid", ref timeoutHelper);
ExceptionUtility exceptionUtility1 = Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility;
string upgradeRequestToNonupgradableService = Resources.UpgradeRequestToNonupgradableService;
object[] objArray = new object[] { this.decoder.Upgrade };
throw exceptionUtility1.ThrowHelperError(new ProtocolException(Microsoft.ServiceBus.SR.GetString(upgradeRequestToNonupgradableService, objArray)));
}
if (!streamUpgradeAcceptor.CanUpgrade(this.decoder.Upgrade))
{
this.SendFault("http://schemas.microsoft.com/ws/2006/05/framing/faults/UpgradeInvalid", ref timeoutHelper);
ExceptionUtility exceptionUtility2 = Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility;
string upgradeProtocolNotSupported = Resources.UpgradeProtocolNotSupported;
object[] upgrade1 = new object[] { this.decoder.Upgrade };
throw exceptionUtility2.ThrowHelperError(new ProtocolException(Microsoft.ServiceBus.SR.GetString(upgradeProtocolNotSupported, upgrade1)));
}
connection.Write(Microsoft.ServiceBus.Channels.ServerSingletonEncoder.UpgradeResponseBytes, 0, (int)Microsoft.ServiceBus.Channels.ServerSingletonEncoder.UpgradeResponseBytes.Length, true, timeoutHelper.RemainingTime());
Microsoft.ServiceBus.Channels.IConnection preReadConnection = connection;
if (this.size > 0)
{
preReadConnection = new Microsoft.ServiceBus.Channels.PreReadConnection(preReadConnection, this.connectionBuffer, this.offset, this.size);
}
try
{
connection = Microsoft.ServiceBus.Channels.InitialServerConnectionReader.UpgradeConnection(preReadConnection, streamUpgradeAcceptor, this.transportSettings);
this.connectionBuffer = connection.AsyncReadBuffer;
continue;
}
catch (Exception exception1)
{
Exception exception = exception1;
if (Fx.IsFatal(exception))
{
throw;
}
this.WriteAuditFailure(streamUpgradeAcceptor as StreamSecurityUpgradeAcceptor, exception);
throw;
}
break;
}
case Microsoft.ServiceBus.Channels.ServerSingletonDecoder.State.Start:
{
this.SetupSecurityIfNecessary(streamUpgradeAcceptor);
connection.Write(Microsoft.ServiceBus.Channels.ServerSessionEncoder.AckResponseBytes, 0, (int)Microsoft.ServiceBus.Channels.ServerSessionEncoder.AckResponseBytes.Length, true, timeoutHelper.RemainingTime());
return(connection);
}
default:
{
continue;
}
}
}while (this.size != 0);
}
throw Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.decoder.CreatePrematureEOFException());
}
public ConnectionOrientedTransportReplyChannelAcceptor(Microsoft.ServiceBus.Channels.ConnectionOrientedTransportChannelListener listener) : base(listener)
{
this.upgrade = listener.GetUpgrade();
}
