private static WebExceptionStatus GetStatusFromExceptionHelper(HttpRequestException ex) { SocketException?socketEx = ex.InnerException as SocketException; if (socketEx is null) { return(WebExceptionStatus.UnknownError); } WebExceptionStatus status; switch (socketEx.SocketErrorCode) { case SocketError.NoData: case SocketError.HostNotFound: status = WebExceptionStatus.NameResolutionFailure; break; default: status = WebExceptionStatus.UnknownError; break; } return(status); }
public static String Format(this SocketException?instance) { return(instance.Format(( StringBuilder buffer ) => { if (instance is not null) { buffer.AppendLine($"HResult: { String.Format( "0x{0:X8}", instance.HResult ) }"); buffer.AppendLine($"Error code: { instance.ErrorCode }"); buffer.AppendLine($"Socket error code: { instance.SocketErrorCode }"); buffer.AppendLine(instance.StackTrace); } })); }
private void SyncFail(Exception e) { OnFail(false); if (_internalArgs != null) { _internalArgs.Dispose(); } SocketException?socketException = e as SocketException; if (socketException != null) { _userArgs !.FinishConnectByNameSyncFailure(socketException, 0, SocketFlags.None); } else { ExceptionDispatchInfo.Throw(e); } }
// Callback which fires when an internal connection attempt completes. // If it failed and there are more addresses to try, do it. // Returns true if the operation is pending, false if it completed synchronously. private bool DoConnectCallback(SocketAsyncEventArgs args, bool sync) { Exception?exception = null; Debug.Assert(!Monitor.IsEntered(_lockObject)); lock (_lockObject) { if (_state == State.Canceled) { // If Cancel was called before we got the lock, the Socket will be closed soon. We need to report // OperationAborted (even though the connection actually completed), or the user will try to use a // closed Socket. exception = new SocketException((int)SocketError.OperationAborted); } else { while (true) { Debug.Assert(_state == State.ConnectAttempt); if (args.SocketError == SocketError.Success) { // The connection attempt succeeded; go to the completed state. // The callback will be called outside the lock. _state = State.Completed; break; } else if (args.SocketError == SocketError.OperationAborted) { // The socket was closed while the connect was in progress. This can happen if the user // closes the socket, and is equivalent to a call to CancelConnectAsync exception = new SocketException((int)SocketError.OperationAborted); _state = State.Canceled; break; } else { // Keep track of this because it will be overwritten by AttemptConnection SocketError currentFailure = args.SocketError; (Exception? connectException, bool pending) = AttemptConnection(); if (connectException == null) { if (pending) { // don't call the callback, another connection attempt is successfully started return(true); } // We have a sync completion from AttemptConnection. // Loop around and process its results. } else { SocketException?socketException = connectException as SocketException; if (socketException != null && socketException.SocketErrorCode == SocketError.NoData) { // If the error is NoData, that means there are no more IPAddresses to attempt // a connection to. Return the last error from an actual connection instead. exception = new SocketException((int)currentFailure); } else { exception = connectException; } _state = State.Completed; break; } } } } } if (exception != null) { return(Fail(sync, exception)); } else { return(Succeed(sync)); } }
public SocketOperationResult(SocketException exception) { SocketError = exception; BytesTransferred = 0; }
public SocketOperationResult(int bytesTransferred) { SocketError = null; BytesTransferred = bytesTransferred; }
// Callback which fires when an internal connection attempt completes. // If it failed and there are more addresses to try, do it. private void InternalConnectCallback(object?sender, SocketAsyncEventArgs args) { Exception?exception = null; lock (_lockObject) { if (_state == State.Canceled) { // If Cancel was called before we got the lock, the Socket will be closed soon. We need to report // OperationAborted (even though the connection actually completed), or the user will try to use a // closed Socket. exception = new SocketException((int)SocketError.OperationAborted); } else { Debug.Assert(_state == State.ConnectAttempt); if (args.SocketError == SocketError.Success) { // The connection attempt succeeded; go to the completed state. // The callback will be called outside the lock. _state = State.Completed; } else if (args.SocketError == SocketError.OperationAborted) { // The socket was closed while the connect was in progress. This can happen if the user // closes the socket, and is equivalent to a call to CancelConnectAsync exception = new SocketException((int)SocketError.OperationAborted); _state = State.Canceled; } else { // Keep track of this because it will be overwritten by AttemptConnection SocketError currentFailure = args.SocketError; Exception? connectException = AttemptConnection(); if (connectException == null) { // don't call the callback, another connection attempt is successfully started return; } else { SocketException?socketException = connectException as SocketException; if (socketException != null && socketException.SocketErrorCode == SocketError.NoData) { // If the error is NoData, that means there are no more IPAddresses to attempt // a connection to. Return the last error from an actual connection instead. exception = new SocketException((int)currentFailure); } else { exception = connectException; } _state = State.Completed; } } } } if (exception == null) { Succeed(); } else { AsyncFail(exception); } }