|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Net.Sockets;
using System.Net;
using System.Runtime;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Threading;
using System.Runtime.InteropServices;
using System.Drawing;
namespace System.ServiceModel.Channels
{
internal class SocketConnection : IConnection
{
//// common state
private Socket _socket;
private TimeSpan _asyncSendTimeout;
private TimeSpan _readFinTimeout;
private TimeSpan _asyncReceiveTimeout;
private CloseState _closeState;
private bool _isShutdown;
private bool _aborted;
//// close state
private TimeoutHelper _closeTimeoutHelper;
//private static Action<object> s_onWaitForFinComplete = new Action<object>(OnWaitForFinComplete);
//// read state
//private int _asyncReadSize;
private SocketAwaitableEventArgs _asyncReadEventArgs;
private bool _asyncReadPending;
//// write state
private SocketAwaitableEventArgs _asyncWriteEventArgs;
private bool _asyncWritePending;
private Timer _receiveTimer;
private bool _receiveTimerEnabled;
private DateTime _lastReceiveTimeoutDeadline;
private static TimerCallback s_onReceiveTimeout = OnReceiveTimeout;
private Timer _sendTimer;
private bool _sendTimerEnabled;
private DateTime _lastSendTimeoutDeadline;
private static TimerCallback s_onSendTimeout = OnSendTimeout;
private string _timeoutErrorString;
private TransferOperation _timeoutErrorTransferOperation;
private UnixDomainSocketEndPoint _remoteEndpoint;
//private ConnectionBufferPool _connectionBufferPool;
private string _remoteEndpointAddress;
public SocketConnection(Socket socket, int bufferSize)
{
_socket = socket ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(socket));
ConnectionBufferSize = bufferSize;
_closeState = CloseState.Open;
_socket.SendBufferSize = _socket.ReceiveBufferSize = bufferSize;
_sendTimer = CreateTimer(s_onSendTimeout);
_receiveTimer = CreateTimer(s_onReceiveTimeout);
_asyncReadEventArgs = new SocketAwaitableEventArgs();
_asyncWriteEventArgs = new SocketAwaitableEventArgs();
_remoteEndpoint = null;
}
private object ThisLock => this;
public int ConnectionBufferSize { get; }
public void Abort()
{
Abort(null, TransferOperation.Undefined);
}
private void Abort(string timeoutErrorString, TransferOperation transferOperation)
{
// we could be timing out a cached connection
Abort(TraceEventType.Warning, timeoutErrorString, transferOperation);
}
private void Abort(TraceEventType traceEventType, string timeoutErrorString, TransferOperation transferOperation)
{
lock (ThisLock)
{
if (_closeState == CloseState.Closed)
{
return;
}
_timeoutErrorString = timeoutErrorString;
_timeoutErrorTransferOperation = transferOperation;
_aborted = true;
_closeState = CloseState.Closed;
if (_asyncReadPending)
{
CancelReceiveTimer();
}
else
{
DisposeReadEventArgs();
}
if (_asyncWritePending)
{
CancelSendTimer();
}
else
{
DisposeWriteEventArgs();
}
}
_socket.Close(0);
}
private void AbortRead()
{
lock (ThisLock)
{
if (_asyncReadPending)
{
if (_closeState != CloseState.Closed)
{
_asyncReadPending = false;
CancelReceiveTimer(dispose: true);
}
else
{
DisposeReadEventArgs();
}
}
}
}
private void AbortWrite()
{
lock (ThisLock)
{
if (_asyncWritePending)
{
if (_closeState != CloseState.Closed)
{
_asyncWritePending = false;
CancelSendTimer(dispose: true);
}
else
{
DisposeWriteEventArgs();
}
}
}
}
public ValueTask<int> ReadAsync(Memory<byte> buffer, TimeSpan timeout)
{
if (buffer.Length < 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(buffer.Length), buffer.Length, SR.ValueMustBeNonNegative));
}
ThrowIfNotOpen();
return ReadCoreAsync(buffer, timeout, false);
}
private async ValueTask<int> ReadCoreAsync(Memory<byte> buffer, TimeSpan timeout, bool closing)
{
int bytesRead = 0;
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
bool abortRead = true;
lock (ThisLock)
{
_asyncReadPending = true;
SetReadTimeout(timeout, closing);
}
bool restoreFlow = false;
try
{
if (!ExecutionContext.IsFlowSuppressed())
{
ExecutionContext.SuppressFlow();
restoreFlow = true;
}
var resultTask = _asyncReadEventArgs.ReceiveAsync(_socket, buffer);
if (restoreFlow)
{
restoreFlow = false;
ExecutionContext.RestoreFlow();
}
bytesRead = await resultTask;
abortRead = false;
if (WcfEventSource.Instance.SocketReadStopIsEnabled())
{
WcfEventSource.Instance.SocketAsyncReadStop((_socket != null) ? _socket.GetHashCode() : -1, bytesRead, this.RemoteEndpointAddress);
}
}
catch (SocketException socketException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
ConvertReceiveException(socketException, timeoutHelper.RemainingTime(), timeout));
}
catch (ObjectDisposedException objectDisposedException)
{
Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Read);
if (ReferenceEquals(exceptionToThrow, objectDisposedException))
throw;
else
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow);
}
finally
{
CancelReceiveTimer();
// Restore the current ExecutionContext
if (restoreFlow)
ExecutionContext.RestoreFlow();
if (abortRead)
{
AbortRead();
}
}
lock (ThisLock)
{
_asyncReadPending = false;
if (_closeState == CloseState.Closed)
{
DisposeReadEventArgs();
}
}
return bytesRead;
}
public async ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, bool immediate, TimeSpan timeout)
{
if (buffer.Length <= 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(buffer.Length), buffer.Length, SR.ValueMustBePositive));
}
bool abortWrite = true;
if (WcfEventSource.Instance.SocketAsyncWriteStartIsEnabled())
{
WcfEventSource.Instance.SocketAsyncWriteStart(_socket.GetHashCode(), buffer.Length, RemoteEndpointAddress);
}
lock (ThisLock)
{
Fx.Assert(!_asyncWritePending, "Called BeginWrite twice.");
ThrowIfClosed();
SetWriteTimeout(timeout);
_asyncWritePending = true;
}
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
bool restoreFlow = false;
try
{
if (!ExecutionContext.IsFlowSuppressed())
{
ExecutionContext.SuppressFlow();
restoreFlow = true;
}
var resultTask = _asyncWriteEventArgs.SendAsync(_socket, buffer);
if (restoreFlow)
{
restoreFlow = false;
ExecutionContext.RestoreFlow();
}
await resultTask;
abortWrite = false;
}
catch (SocketException socketException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
ConvertSendException(socketException, timeoutHelper.RemainingTime(), timeout));
}
catch (ObjectDisposedException objectDisposedException)
{
Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Write);
if (ReferenceEquals(exceptionToThrow, objectDisposedException))
{
throw;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow);
}
}
finally
{
_asyncWritePending = false;
CancelSendTimer();
// Restore the current ExecutionContext
if (restoreFlow)
ExecutionContext.RestoreFlow();
if (abortWrite)
{
AbortWrite();
}
}
}
public async ValueTask CloseAsync(TimeSpan timeout)
{
lock (ThisLock)
{
if (_closeState == CloseState.Closing || _closeState == CloseState.Closed)
{
// already closing or closed, so just return
return;
}
_closeState = CloseState.Closing;
}
// first we shutdown our send-side
_closeTimeoutHelper = new TimeoutHelper(timeout);
Shutdown(_closeTimeoutHelper.RemainingTime());
_readFinTimeout = _closeTimeoutHelper.RemainingTime();
try
{
// A FIN (shutdown) packet has already been sent to the remote host and we're waiting for the remote
// host to send a FIN back. A pending read on a socket will complete returning zero bytes when a FIN
// packet is received.
byte[] dummy = Fx.AllocateByteArray(1);
int bytesRead = await ReadCoreAsync(dummy, _readFinTimeout, true);
if (bytesRead > 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new CommunicationException(SR.Format(SR.SocketCloseReadReceivedData, _socket.RemoteEndPoint)));
}
}
catch (TimeoutException timeoutException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(
SR.Format(SR.SocketCloseReadTimeout, _socket.RemoteEndPoint, _readFinTimeout), timeoutException));
}
_socket.Close(TimeoutHelper.ToMilliseconds(_closeTimeoutHelper.RemainingTime()));
lock (ThisLock)
{
// Abort could have been called on a separate thread and cleaned up
// our buffers/completion here
if (_closeState != CloseState.Closed)
{
if (!_asyncReadPending)
{
DisposeReadEventArgs();
}
if (!_asyncWritePending)
{
DisposeWriteEventArgs();
}
}
_closeState = CloseState.Closed;
}
}
private void Shutdown(TimeSpan timeout)
{
lock (ThisLock)
{
if (_isShutdown)
{
return;
}
_isShutdown = true;
}
try
{
_socket.Shutdown(SocketShutdown.Send);
}
catch (SocketException socketException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
ConvertSendException(socketException, TimeSpan.MaxValue, _asyncSendTimeout));
}
catch (ObjectDisposedException objectDisposedException)
{
Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Undefined);
if (ReferenceEquals(exceptionToThrow, objectDisposedException))
{
throw;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow);
}
}
}
private string RemoteEndpointAddress
{
get
{
if (_remoteEndpointAddress == null)
{
try
{
if (TryGetEndpoints(out UnixDomainSocketEndPoint remote))
{
_remoteEndpointAddress = remote.ToString();
}
else
{
//null indicates not initialized.
_remoteEndpointAddress = string.Empty;
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
}
}
return _remoteEndpointAddress;
}
}
private bool TryGetEndpoints(out UnixDomainSocketEndPoint remoteIPEndpoint)
{
remoteIPEndpoint = null;
if (_closeState == CloseState.Open)
{
try
{
remoteIPEndpoint = _remoteEndpoint ?? (UnixDomainSocketEndPoint)_socket.RemoteEndPoint;
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
}
}
return remoteIPEndpoint != null;
}
// This method should be called inside ThisLock
private void DisposeReadEventArgs()
{
_asyncReadEventArgs.Dispose();
}
// This method should be called inside ThisLock
private void DisposeWriteEventArgs()
{
_asyncWriteEventArgs.Dispose();
}
private void ThrowIfNotOpen()
{
if (_closeState == CloseState.Closing || _closeState == CloseState.Closed)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
ConvertObjectDisposedException(new ObjectDisposedException(
GetType().ToString(), SR.SocketConnectionDisposed), TransferOperation.Undefined));
}
}
private void ThrowIfClosed()
{
if (_closeState == CloseState.Closed)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
ConvertObjectDisposedException(new ObjectDisposedException(
GetType().ToString(), SR.SocketConnectionDisposed), TransferOperation.Undefined));
}
}
private void SetReadTimeout(TimeSpan timeout, bool closing)
{
if (timeout <= TimeSpan.Zero)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new TimeoutException(SR.Format(SR.UDSConnectionTimedOut, timeout)));
}
_asyncReceiveTimeout = timeout;
if (timeout == TimeSpan.MaxValue)
{
CancelReceiveTimer();
}
else
{
if (ShouldUpdateTimeout(_lastReceiveTimeoutDeadline, timeout))
{
lock (ThisLock)
{
if (!closing || _closeState != CloseState.Closing)
{
ThrowIfNotOpen();
}
_lastReceiveTimeoutDeadline = DateTime.UtcNow + timeout;
_receiveTimer.Change(timeout, Timeout.InfiniteTimeSpan);
}
}
_receiveTimerEnabled = true;
}
}
private void CancelReceiveTimer(bool dispose = false)
{
// Don't change the timer as modifing the Timer is expensive. It's most likely going to be set
// to another future time before it actually fires. By using a bool to make the fired timer a
// no-op we only modify the Timer, if at all. Multiple receives are often part of a single
// compound operation with the same ultimate final timeout deadline. This means multiple calls
// to ReceiveAsync will have the same deadline and we can avoid modifying the timer by not
// changing it when a receive completes and just making it a no-op.
if (_receiveTimerEnabled)
{
_receiveTimerEnabled = false;
}
if (dispose)
{
_receiveTimer.Dispose();
}
}
private void SetWriteTimeout(TimeSpan timeout)
{
if (timeout <= TimeSpan.Zero)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new TimeoutException(SR.Format(SR.UDSConnectionTimedOut, timeout)));
}
_asyncSendTimeout = timeout;
if (timeout == TimeSpan.MaxValue)
{
CancelSendTimer();
}
else
{
if (ShouldUpdateTimeout(_lastSendTimeoutDeadline, timeout))
{
lock (ThisLock)
{
ThrowIfNotOpen();
_lastSendTimeoutDeadline = DateTime.UtcNow + timeout;
_sendTimer.Change(timeout, Timeout.InfiniteTimeSpan);
}
}
_sendTimerEnabled = true;
}
}
private void CancelSendTimer(bool dispose = false)
{
// See CancelReceiveTimer for rationale of not cancelling the underlying timer.
if (_sendTimerEnabled)
{
_sendTimerEnabled = false;
}
if (dispose)
{
_sendTimer.Dispose();
}
}
private bool ShouldUpdateTimeout(DateTime oldTimeoutDeadline, TimeSpan newTimeout)
{
var oldTimeout = oldTimeoutDeadline - DateTime.UtcNow;
if (oldTimeout < TimeSpan.Zero) // Expired already
return true;
long threshold = oldTimeout.Ticks >> 4; // >> 4 is the same as / 16. Are the timeouts within 6.25% of each other
long delta = oldTimeout.Ticks > newTimeout.Ticks ? oldTimeout.Ticks - newTimeout.Ticks : newTimeout.Ticks - oldTimeout.Ticks;
return delta > threshold;
}
private static void OnReceiveTimeout(object state)
{
SocketConnection thisPtr = (SocketConnection)state;
if (thisPtr._receiveTimerEnabled)
{
thisPtr.Abort(SR.Format(SR.SocketAbortedReceiveTimedOut, thisPtr._asyncReceiveTimeout), TransferOperation.Read);
}
}
private static void OnSendTimeout(object state)
{
SocketConnection thisPtr = (SocketConnection)state;
if (thisPtr._sendTimerEnabled)
{
thisPtr.Abort(TraceEventType.Warning, SR.Format(SR.SocketAbortedSendTimedOut, thisPtr._asyncSendTimeout), TransferOperation.Write);
}
}
private Exception ConvertObjectDisposedException(ObjectDisposedException originalException, TransferOperation transferOperation)
{
if (_timeoutErrorString != null)
{
return ConvertTimeoutErrorException(originalException, transferOperation, _timeoutErrorString, _timeoutErrorTransferOperation);
}
else if (_aborted)
{
return new CommunicationObjectAbortedException(SR.SocketConnectionDisposed, originalException);
}
else
{
return originalException;
}
}
private Exception ConvertSendException(SocketException socketException, TimeSpan remainingTime, TimeSpan timeout)
{
return ConvertTransferException(socketException, timeout, socketException,
TransferOperation.Write, _aborted, _timeoutErrorString, _timeoutErrorTransferOperation, this, remainingTime);
}
private Exception ConvertReceiveException(SocketException socketException, TimeSpan remainingTime, TimeSpan timeout)
{
return ConvertTransferException(socketException, timeout, socketException,
TransferOperation.Read, _aborted, _timeoutErrorString, _timeoutErrorTransferOperation, this, remainingTime);
}
private static Exception ConvertTransferException(SocketException socketException, TimeSpan timeout, Exception originalException,
TransferOperation transferOperation, bool aborted, string timeoutErrorString, TransferOperation timeoutErrorTransferOperation,
SocketConnection socketConnection, TimeSpan remainingTime)
{
if (socketException.ErrorCode == UnsafeNativeMethods.ERROR_INVALID_HANDLE)
{
return new CommunicationObjectAbortedException(socketException.Message, socketException);
}
if (timeoutErrorString != null)
{
return ConvertTimeoutErrorException(originalException, transferOperation, timeoutErrorString, timeoutErrorTransferOperation);
}
// 10053 can occur due to our timeout sockopt firing, so map to TimeoutException in that case
if (socketException.ErrorCode == UnsafeNativeMethods.WSAECONNABORTED &&
remainingTime <= TimeSpan.Zero)
{
TimeoutException timeoutException = new TimeoutException(SR.Format(SR.UDSConnectionTimedOut, timeout), originalException);
return timeoutException;
}
if (socketException.ErrorCode == UnsafeNativeMethods.WSAENETRESET ||
socketException.ErrorCode == UnsafeNativeMethods.WSAECONNABORTED ||
socketException.ErrorCode == UnsafeNativeMethods.WSAECONNRESET)
{
if (aborted)
{
return new CommunicationObjectAbortedException(SR.UDSLocalConnectionAborted, originalException);
}
else
{
CommunicationException communicationException = new CommunicationException(SR.Format(SR.UDSConnectionResetError, timeout), originalException);
return communicationException;
}
}
else if (socketException.ErrorCode == UnsafeNativeMethods.WSAETIMEDOUT)
{
TimeoutException timeoutException = new TimeoutException(SR.Format(SR.UDSConnectionTimedOut, timeout), originalException);
return timeoutException;
}
else
{
if (aborted)
{
return new CommunicationObjectAbortedException(SR.Format(SR.UDSTransferError, socketException.ErrorCode, socketException.Message), originalException);
}
else
{
CommunicationException communicationException = new CommunicationException(SR.Format(SR.UDSTransferError, socketException.ErrorCode, socketException.Message), originalException);
return communicationException;
}
}
}
private static Exception ConvertTimeoutErrorException(Exception originalException,
TransferOperation transferOperation, string timeoutErrorString, TransferOperation timeoutErrorTransferOperation)
{
if (timeoutErrorString == null)
{
Fx.Assert("Argument timeoutErrorString must not be null.");
}
if (transferOperation == timeoutErrorTransferOperation)
{
return new TimeoutException(timeoutErrorString, originalException);
}
else
{
return new CommunicationException(timeoutErrorString, originalException);
}
}
// Avoid rooting any values stored in asynclocals.
private Timer CreateTimer(TimerCallback callback)
{
if (callback == null)
{
throw new ArgumentNullException(nameof(callback));
}
// Don't capture the current ExecutionContext and its AsyncLocals onto the timer
bool restoreFlow = false;
try
{
if (!ExecutionContext.IsFlowSuppressed())
{
ExecutionContext.SuppressFlow();
restoreFlow = true;
}
return new Timer(callback, this, Timeout.Infinite, Timeout.Infinite);
}
finally
{
// Restore the current ExecutionContext
if (restoreFlow)
{
ExecutionContext.RestoreFlow();
}
}
}
private enum CloseState
{
Open,
Closing,
Closed,
}
private enum TransferOperation
{
Write,
Read,
Undefined,
}
}
internal class SocketConnectionInitiator : IConnectionInitiator
{
private int _bufferSize;
public SocketConnectionInitiator(int bufferSize)
{
_bufferSize = bufferSize;
}
private async Task<IConnection> CreateConnectionAsync(Uri uriPath)
{
Socket socket = null;
try
{
AddressFamily addressFamily = AddressFamily.Unix;
socket = new Socket(addressFamily, SocketType.Stream, ProtocolType.IP);
var endpoint = new UnixDomainSocketEndPoint(uriPath.LocalPath);
await socket.ConnectAsync(endpoint);
return new SocketConnection(socket, _bufferSize);
}
catch
{
socket.Dispose();
throw;
}
}
public static Exception ConvertConnectException(SocketException socketException, Uri remoteUri, TimeSpan timeSpent, Exception innerException)
{
if ((int)socketException.SocketErrorCode == UnsafeNativeMethods.ERROR_INVALID_HANDLE)
{
return new CommunicationObjectAbortedException(socketException.Message, socketException);
}
if ((int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAEADDRNOTAVAIL ||
(int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAECONNREFUSED ||
(int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAENETDOWN ||
(int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAENETUNREACH ||
(int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAEHOSTDOWN ||
(int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAEHOSTUNREACH ||
(int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAETIMEDOUT)
{
if (timeSpent == TimeSpan.MaxValue)
{
return new EndpointNotFoundException(SR.Format(SR.UDSConnectError, remoteUri.AbsoluteUri, (int)socketException.SocketErrorCode, socketException.Message), innerException);
}
else
{
return new EndpointNotFoundException(SR.Format(SR.UDSConnectErrorWithTimeSpan, remoteUri.AbsoluteUri, (int)socketException.SocketErrorCode, socketException.Message, timeSpent), innerException);
}
}
else if ((int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAENOBUFS)
{
return new InsufficientMemoryException(SR.UDSConnectNoBufs, innerException);
}
else if ((int)socketException.SocketErrorCode == UnsafeNativeMethods.ERROR_NOT_ENOUGH_MEMORY ||
(int)socketException.SocketErrorCode == UnsafeNativeMethods.ERROR_NO_SYSTEM_RESOURCES ||
(int)socketException.SocketErrorCode == UnsafeNativeMethods.ERROR_OUTOFMEMORY)
{
return new InsufficientMemoryException(SR.InsufficentMemory, socketException);
}
else
{
if (timeSpent == TimeSpan.MaxValue)
{
return new CommunicationException(SR.Format(SR.UDSConnectError, remoteUri.AbsoluteUri, (int)socketException.SocketErrorCode, socketException.Message), innerException);
}
else
{
return new CommunicationException(SR.Format(SR.UDSConnectErrorWithTimeSpan, remoteUri.AbsoluteUri, (int)socketException.SocketErrorCode, socketException.Message, timeSpent), innerException);
}
}
}
private static TimeoutException CreateTimeoutException(Uri uri, TimeSpan timeout, SocketException innerException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException("Timed out while connecting to Unix domain socket", innerException));
}
public async ValueTask<IConnection> ConnectAsync(Uri uri, TimeSpan timeout)
{
IConnection socketConnection = null;
SocketException lastException = null;
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
if (timeoutHelper.RemainingTime() == TimeSpan.Zero)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
CreateTimeoutException(uri, timeoutHelper.OriginalTimeout, lastException));
}
try
{
socketConnection = await CreateConnectionAsync(uri);
}
catch (SocketException socketException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
SocketConnectionInitiator.ConvertConnectException(socketException, uri,
timeoutHelper.ElapsedTime(), socketException));
}
return socketConnection;
}
}
}
|