| public static GetStatus ( [ hresult ) : SocketErrorStatus | ||
| hresult | [ | |
| return | 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();
}
}
}
