public static GetStatus ( [ hresult ) : SocketErrorStatus | ||
hresult | [ | |
리턴 | SocketErrorStatus |
private void OnReceiveAsync(Task <int> antecedent) { this.CancelReceiveTimer(); try { _asyncReadSize = antecedent.Result; } catch (Exception exception) { if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown) { SocketException socketException = new SocketException(exception.HResult & 0x0000FFFF); _asyncReadException = ConvertReceiveException(socketException, TimeSpan.MaxValue); } else { if (Fx.IsFatal(exception)) { throw; } _asyncReadException = exception; } } FinishRead(); }
private void OnSendAsync(Task antecedent) { Contract.Assert(antecedent != null, "Argument 'antecedent' cannot be NULL."); this.CancelSendTimer(); try { antecedent.GetAwaiter().GetResult(); } catch (Exception exception) { if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown) { SocketException socketException = new SocketException(exception.HResult & 0x0000FFFF); _asyncWriteException = ConvertSendException(socketException, TimeSpan.MaxValue); } else { if (Fx.IsFatal(exception)) { throw; } _asyncWriteException = exception; } } this.FinishWrite(); }
protected override void ShutdownCore(TimeSpan timeout) { try { // All the steps of a socket shutdown are not possible with StreamSocket. As part of a socket shutdown // any pending data to write is given the chance to be sent so we'll attempt that. var toh = new TimeoutHelper(timeout); _outputStream.FlushAsync(toh.GetCancellationToken()).GetAwaiter().GetResult(); } catch (ObjectDisposedException objectDisposedException) { Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Undefined); if (object.ReferenceEquals(exceptionToThrow, objectDisposedException)) { throw; } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow); } } catch (Exception exception) { if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown) { SocketException socketException = new SocketException(exception.HResult & 0x0000FFFF); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( ConvertSendException(socketException, TimeSpan.MaxValue)); } throw; } }
internal static async Task <IPAddress[]> LookupHostName(string hostName) { try { IReadOnlyList <EndpointPair> data = await DatagramSocket.GetEndpointPairsAsync(new HostName(hostName), "0").AsTask(); List <IPAddress> addresses = new List <IPAddress>(data.Count); if (data != null && data.Count > 0) { foreach (EndpointPair item in data) { if (item != null && item.RemoteHostName != null && (item.RemoteHostName.Type == HostNameType.Ipv4 || item.RemoteHostName.Type == HostNameType.Ipv6)) { IPAddress address; if (IPAddress.TryParse(item.RemoteHostName.CanonicalName, out address)) { addresses.Add(address); } } } } return(addresses.ToArray()); } catch (Exception exception) { if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown) { throw new SocketException(exception.HResult & 0x0000FFFF); } throw; } }
protected override AsyncCompletionResult BeginReadCore(int offset, int size, TimeSpan timeout, Action <object> callback, object state) { bool abortRead = true; lock (ThisLock) { this.ThrowIfClosed(); _asyncReadState = state; _asyncReadCallback = callback; _asyncReadPending = true; this.SetReadTimeout(timeout, false, false); } try { Task <int> readTask = _inputStream.ReadAsync(AsyncReadBuffer, offset, size, _receiveCts.Token); if (!readTask.IsCompleted) { readTask.ContinueWith(s_onReceiveAsyncCompleted, this, CancellationToken.None); abortRead = false; return(AsyncCompletionResult.Queued); } _asyncReadSize = readTask.Result; abortRead = false; return(AsyncCompletionResult.Completed); } catch (ObjectDisposedException objectDisposedException) { Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Read); if (object.ReferenceEquals(exceptionToThrow, objectDisposedException)) { throw; } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow); } } catch (Exception exception) { if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown) { SocketException socketException = new SocketException(exception.HResult & 0x0000FFFF); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ConvertReceiveException(socketException, TimeSpan.MaxValue)); } throw; } finally { if (abortRead) { AbortRead(); } } }
protected override void WriteCore(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout) { // as per http://support.microsoft.com/default.aspx?scid=kb%3ben-us%3b201213 // we shouldn't write more than 64K synchronously to a socket const int maxSocketWrite = 64 * 1024; ConnectionUtilities.ValidateBufferBounds(buffer, offset, size); TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); try { int bytesToWrite = size; using (timeoutHelper.GetCancellationToken().Register(OnSendTimeout, this)) { while (bytesToWrite > 0) { size = Math.Min(bytesToWrite, maxSocketWrite); _outputStream.Write(buffer, offset, size); if (immediate) { _outputStream.Flush(); } bytesToWrite -= size; offset += size; } } } catch (ObjectDisposedException objectDisposedException) { Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Write); if (object.ReferenceEquals(exceptionToThrow, objectDisposedException)) { throw; } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow); } } catch (Exception exception) { if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown) { SocketException socketException = new SocketException(exception.HResult & 0x0000FFFF); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( ConvertSendException(socketException, timeoutHelper.RemainingTime())); } throw; } }
protected override IConnection CreateConnection(IPAddress address, int port) { StreamSocket socket = null; try { socket = new StreamSocket(); socket.Control.OutboundBufferSizeInBytes = (uint)_connectionBufferPool.BufferSize; socket.ConnectAsync(new HostName(address.ToString()), port.ToString()).AsTask().GetAwaiter().GetResult(); return(new RTSocketConnection(socket, _connectionBufferPool)); } catch (Exception exception) { socket.Dispose(); if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown) { throw new SocketException(exception.HResult & 0x0000FFFF); } throw; } }
protected override int ReadCore(byte[] buffer, int offset, int size, TimeSpan timeout, bool closing) { int bytesRead = 0; TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); try { using (timeoutHelper.GetCancellationToken().Register(OnReceiveTimeout, this)) { bytesRead = _inputStream.Read(buffer, offset, size); } } catch (ObjectDisposedException objectDisposedException) { Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Read); if (object.ReferenceEquals(exceptionToThrow, objectDisposedException)) { throw; } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow); } } catch (Exception exception) { if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown) { SocketException socketException = new SocketException(exception.HResult & 0x0000FFFF); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( ConvertReceiveException(socketException, timeoutHelper.RemainingTime())); } throw; } return(bytesRead); }
protected override AsyncCompletionResult BeginWriteCore(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout, Action <object> callback, object state) { ConnectionUtilities.ValidateBufferBounds(buffer, offset, size); bool abortWrite = true; try { lock (ThisLock) { Contract.Assert(!_asyncWritePending, "Called BeginWrite twice."); this.ThrowIfClosed(); SetWriteTimeout(timeout, false); _asyncWritePending = true; _asyncWriteCallback = callback; _asyncWriteState = state; } Task writeTask = _outputStream.WriteAsync(buffer, offset, size, _sendCts.Token); if (immediate) { writeTask = writeTask.ContinueWith(s_flushWriteImmedaite, this, CancellationToken.None).Unwrap(); } if (!writeTask.IsCompleted) { writeTask.ContinueWith(s_onSendAsyncCompleted, this, CancellationToken.None); abortWrite = false; return(AsyncCompletionResult.Queued); } writeTask.GetAwaiter().GetResult(); abortWrite = false; return(AsyncCompletionResult.Completed); } catch (ObjectDisposedException objectDisposedException) { Exception exceptionToThrow = ConvertObjectDisposedException(objectDisposedException, TransferOperation.Write); if (object.ReferenceEquals(exceptionToThrow, objectDisposedException)) { throw; } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exceptionToThrow); } } catch (Exception exception) { if (RTSocketError.GetStatus(exception.HResult) != SocketErrorStatus.Unknown) { SocketException socketException = new SocketException(exception.HResult & 0x0000FFFF); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( ConvertSendException(socketException, TimeSpan.MaxValue)); } throw; } finally { if (abortWrite) { this.AbortWrite(); } } }