public static void DecodeFramingFault(Microsoft.ServiceBus.Channels.ClientFramingDecoder decoder, Microsoft.ServiceBus.Channels.IConnection connection, Uri via, string contentType, ref Microsoft.ServiceBus.Common.TimeoutHelper timeoutHelper)
{
Microsoft.ServiceBus.Channels.ConnectionUpgradeHelper.ValidateReadingFaultString(decoder);
int num = 0;
byte[] numArray = Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.Utility.AllocateByteArray(256);
int num1 = connection.Read(numArray, num, (int)numArray.Length, timeoutHelper.RemainingTime());
while (num1 > 0)
{
int num2 = decoder.Decode(numArray, num, num1);
num = num + num2;
num1 = num1 - num2;
if (decoder.CurrentState == Microsoft.ServiceBus.Channels.ClientFramingDecoderState.Fault)
{
Microsoft.ServiceBus.Channels.ConnectionUtilities.CloseNoThrow(connection, timeoutHelper.RemainingTime());
throw Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.ThrowHelperError(Microsoft.ServiceBus.Channels.FaultStringDecoder.GetFaultException(decoder.Fault, via.ToString(), contentType));
}
if (decoder.CurrentState != Microsoft.ServiceBus.Channels.ClientFramingDecoderState.ReadingFaultString)
{
throw Fx.AssertAndThrow("invalid framing client state machine");
}
if (num1 != 0)
{
continue;
}
num = 0;
num1 = connection.Read(numArray, num, (int)numArray.Length, timeoutHelper.RemainingTime());
}
throw Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.ThrowHelperError(decoder.CreatePrematureEOFException());
}
private Microsoft.ServiceBus.Channels.IConnection SendPreamble(Microsoft.ServiceBus.Channels.IConnection connection, ref Microsoft.ServiceBus.Common.TimeoutHelper timeoutHelper, Microsoft.ServiceBus.Channels.ClientFramingDecoder decoder, out SecurityMessageProperty remoteSecurity)
{
connection.Write(this.Preamble, 0, (int)this.Preamble.Length, true, timeoutHelper.RemainingTime());
if (this.upgrade == null)
{
remoteSecurity = null;
}
else
{
StreamUpgradeInitiator streamUpgradeInitiator = this.upgrade.CreateUpgradeInitiator(base.RemoteAddress, base.Via);
if (!Microsoft.ServiceBus.Channels.ConnectionUpgradeHelper.InitiateUpgrade(streamUpgradeInitiator, ref connection, decoder, this, ref timeoutHelper))
{
Microsoft.ServiceBus.Channels.ConnectionUpgradeHelper.DecodeFramingFault(decoder, connection, base.Via, this.messageEncoder.ContentType, ref timeoutHelper);
}
if (!(streamUpgradeInitiator is StreamSecurityUpgradeInitiator))
{
remoteSecurity = null;
}
else
{
remoteSecurity = ((StreamSecurityUpgradeInitiator)streamUpgradeInitiator).GetRemoteSecurity();
}
connection.Write(Microsoft.ServiceBus.Channels.ClientSingletonEncoder.PreambleEndBytes, 0, (int)Microsoft.ServiceBus.Channels.ClientSingletonEncoder.PreambleEndBytes.Length, true, timeoutHelper.RemainingTime());
}
byte[] numArray = new byte[1];
if (!Microsoft.ServiceBus.Channels.ConnectionUpgradeHelper.ValidatePreambleResponse(numArray, connection.Read(numArray, 0, (int)numArray.Length, timeoutHelper.RemainingTime()), decoder, base.Via))
{
Microsoft.ServiceBus.Channels.ConnectionUpgradeHelper.DecodeFramingFault(decoder, connection, base.Via, this.messageEncoder.ContentType, ref timeoutHelper);
}
return(connection);
}
public static bool InitiateUpgrade(StreamUpgradeInitiator upgradeInitiator, ref Microsoft.ServiceBus.Channels.IConnection connection, Microsoft.ServiceBus.Channels.ClientFramingDecoder decoder, IDefaultCommunicationTimeouts defaultTimeouts, ref Microsoft.ServiceBus.Common.TimeoutHelper timeoutHelper)
{
for (string i = upgradeInitiator.GetNextUpgrade(); i != null; i = upgradeInitiator.GetNextUpgrade())
{
Microsoft.ServiceBus.Channels.EncodedUpgrade encodedUpgrade = new Microsoft.ServiceBus.Channels.EncodedUpgrade(i);
connection.Write(encodedUpgrade.EncodedBytes, 0, (int)encodedUpgrade.EncodedBytes.Length, true, timeoutHelper.RemainingTime());
byte[] numArray = new byte[1];
if (!Microsoft.ServiceBus.Channels.ConnectionUpgradeHelper.ValidateUpgradeResponse(numArray, connection.Read(numArray, 0, (int)numArray.Length, timeoutHelper.RemainingTime()), decoder))
{
return(false);
}
Microsoft.ServiceBus.Channels.ConnectionStream connectionStream = new Microsoft.ServiceBus.Channels.ConnectionStream(connection, defaultTimeouts);
connection = new Microsoft.ServiceBus.Channels.StreamConnection(upgradeInitiator.InitiateUpgrade(connectionStream), connectionStream);
}
return(true);
}
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());
}
internal static void SendFault(Microsoft.ServiceBus.Channels.IConnection connection, string faultString, byte[] drainBuffer, TimeSpan sendTimeout, int maxRead)
{
Microsoft.ServiceBus.Channels.EncodedFault encodedFault = new Microsoft.ServiceBus.Channels.EncodedFault(faultString);
TimeoutHelper timeoutHelper = new TimeoutHelper(sendTimeout);
try
{
connection.Write(encodedFault.EncodedBytes, 0, (int)encodedFault.EncodedBytes.Length, true, timeoutHelper.RemainingTime());
connection.Shutdown(timeoutHelper.RemainingTime());
}
catch (CommunicationException communicationException1)
{
CommunicationException communicationException = communicationException1;
if (Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ShouldTraceInformation)
{
Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.TraceHandledException(communicationException, TraceEventType.Information);
}
connection.Abort();
return;
}
catch (TimeoutException timeoutException1)
{
TimeoutException timeoutException = timeoutException1;
if (Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ShouldTraceInformation)
{
Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.TraceHandledException(timeoutException, TraceEventType.Information);
}
connection.Abort();
return;
}
int num = 0;
int num1 = 0;
do
{
try
{
num = connection.Read(drainBuffer, 0, (int)drainBuffer.Length, timeoutHelper.RemainingTime());
}
catch (CommunicationException communicationException3)
{
CommunicationException communicationException2 = communicationException3;
if (Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ShouldTraceInformation)
{
Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.TraceHandledException(communicationException2, TraceEventType.Information);
}
connection.Abort();
return;
}
catch (TimeoutException timeoutException3)
{
TimeoutException timeoutException2 = timeoutException3;
if (Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ShouldTraceInformation)
{
Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.TraceHandledException(timeoutException2, TraceEventType.Information);
}
connection.Abort();
return;
}
if (num == 0)
{
Microsoft.ServiceBus.Channels.ConnectionUtilities.CloseNoThrow(connection, timeoutHelper.RemainingTime());
return;
}
num1 = num1 + num;
}while (num1 <= maxRead && !(timeoutHelper.RemainingTime() <= TimeSpan.Zero));
connection.Abort();
}
private Microsoft.ServiceBus.Channels.IConnection SendPreamble(Microsoft.ServiceBus.Channels.IConnection connection, ArraySegment <byte> preamble, ref Microsoft.ServiceBus.Common.TimeoutHelper timeoutHelper)
{
this.decoder = new Microsoft.ServiceBus.Channels.ClientDuplexDecoder((long)0);
byte[] numArray = new byte[1];
connection.Write(preamble.Array, preamble.Offset, preamble.Count, true, timeoutHelper.RemainingTime());
if (this.upgrade != null)
{
StreamUpgradeInitiator streamUpgradeInitiator = this.upgrade.CreateUpgradeInitiator(this.RemoteAddress, this.Via);
Type type = streamUpgradeInitiator.GetType();
object[] objArray = new object[] { timeoutHelper.RemainingTime() };
InvokeHelper.InvokeInstanceMethod(type, streamUpgradeInitiator, "Open", objArray);
if (!Microsoft.ServiceBus.Channels.ConnectionUpgradeHelper.InitiateUpgrade(streamUpgradeInitiator, ref connection, this.decoder, this, ref timeoutHelper))
{
Microsoft.ServiceBus.Channels.ConnectionUpgradeHelper.DecodeFramingFault(this.decoder, connection, this.Via, base.MessageEncoder.ContentType, ref timeoutHelper);
}
this.SetRemoteSecurity(streamUpgradeInitiator);
Type type1 = streamUpgradeInitiator.GetType();
object[] objArray1 = new object[] { timeoutHelper.RemainingTime() };
InvokeHelper.InvokeInstanceMethod(type1, streamUpgradeInitiator, "Close", objArray1);
connection.Write(Microsoft.ServiceBus.Channels.SessionEncoder.PreambleEndBytes, 0, (int)Microsoft.ServiceBus.Channels.SessionEncoder.PreambleEndBytes.Length, true, timeoutHelper.RemainingTime());
}
if (!Microsoft.ServiceBus.Channels.ConnectionUpgradeHelper.ValidatePreambleResponse(numArray, connection.Read(numArray, 0, (int)numArray.Length, timeoutHelper.RemainingTime()), this.decoder, this.Via))
{
Microsoft.ServiceBus.Channels.ConnectionUpgradeHelper.DecodeFramingFault(this.decoder, connection, this.Via, base.MessageEncoder.ContentType, ref timeoutHelper);
}
return(connection);
}
