Add async support to SftpClient and SftpFileStream

src/Renci.SshNet/Abstractions/DnsAbstraction.cs

@@ -2,10 +2,13 @@
 using System.Net;
 using System.Net.Sockets;
 
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
+
 #if FEATURE_DNS_SYNC
 #elif FEATURE_DNS_APM
 using Renci.SshNet.Common;
-#elif FEATURE_DNS_TAP
 #elif FEATURE_DEVICEINFORMATION_APM
 using System.Collections.Generic;
 using System.Linq;
@@ -42,8 +45,6 @@ public static IPAddress[] GetHostAddresses(string hostNameOrAddress)
             if (!asyncResult.AsyncWaitHandle.WaitOne(Session.InfiniteTimeSpan))
                 throw new SshOperationTimeoutException("Timeout resolving host name.");
             return Dns.EndGetHostAddresses(asyncResult);
-#elif FEATURE_DNS_TAP
-            return Dns.GetHostAddressesAsync(hostNameOrAddress).GetAwaiter().GetResult();
 #else
             IPAddress address;
             if (IPAddress.TryParse(hostNameOrAddress, out address))
@@ -87,5 +88,23 @@ public static IPAddress[] GetHostAddresses(string hostNameOrAddress)
 #endif // FEATURE_DEVICEINFORMATION_APM
 #endif
         }
+
+#if FEATURE_TAP
+        /// <summary>
+        /// Returns the Internet Protocol (IP) addresses for the specified host.
+        /// </summary>
+        /// <param name="hostNameOrAddress">The host name or IP address to resolve</param>
+        /// <returns>
+        /// A task with result of an array of type <see cref="IPAddress"/> that holds the IP addresses for the host that
+        /// is specified by the <paramref name="hostNameOrAddress"/> parameter.
+        /// </returns>
+        /// <exception cref="ArgumentNullException"><paramref name="hostNameOrAddress"/> is <c>null</c>.</exception>
+        /// <exception cref="SocketException">An error is encountered when resolving <paramref name="hostNameOrAddress"/>.</exception>
+        public static Task<IPAddress[]> GetHostAddressesAsync(string hostNameOrAddress)
+        {
+            return Dns.GetHostAddressesAsync(hostNameOrAddress);
+        }
+#endif
+
     }
 }

src/Renci.SshNet/Abstractions/SocketAbstraction.cs

@@ -3,6 +3,9 @@
 using System.Net;
 using System.Net.Sockets;
 using System.Threading;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
 using Renci.SshNet.Common;
 using Renci.SshNet.Messages.Transport;
 
@@ -59,15 +62,22 @@ public static void Connect(Socket socket, IPEndPoint remoteEndpoint, TimeSpan co
             ConnectCore(socket, remoteEndpoint, connectTimeout, false);
         }
 
+#if FEATURE_TAP
+        public static Task ConnectAsync(Socket socket, IPEndPoint remoteEndpoint, CancellationToken cancellationToken)
+        {
+            return socket.ConnectAsync(remoteEndpoint, cancellationToken);
+        }
+#endif
+
         private static void ConnectCore(Socket socket, IPEndPoint remoteEndpoint, TimeSpan connectTimeout, bool ownsSocket)
         {
 #if FEATURE_SOCKET_EAP
             var connectCompleted = new ManualResetEvent(false);
             var args = new SocketAsyncEventArgs
-                {
-                    UserToken = connectCompleted,
-                    RemoteEndPoint = remoteEndpoint
-                };
+            {
+                UserToken = connectCompleted,
+                RemoteEndPoint = remoteEndpoint
+            };
             args.Completed += ConnectCompleted;
 
             if (socket.ConnectAsync(args))
@@ -97,7 +107,7 @@ private static void ConnectCore(Socket socket, IPEndPoint remoteEndpoint, TimeSp
 
             if (args.SocketError != SocketError.Success)
             {
-                var socketError = (int) args.SocketError;
+                var socketError = (int)args.SocketError;
 
                 if (ownsSocket)
                 {
@@ -124,7 +134,7 @@ private static void ConnectCore(Socket socket, IPEndPoint remoteEndpoint, TimeSp
                 throw new SshOperationTimeoutException(string.Format(CultureInfo.InvariantCulture,
                     "Connection failed to establish within {0:F0} milliseconds.", connectTimeout.TotalMilliseconds));
 #else
-            #error Connecting to a remote endpoint is not implemented.
+#error Connecting to a remote endpoint is not implemented.
 #endif
         }
 
@@ -144,7 +154,7 @@ public static void ClearReadBuffer(Socket socket)
         public static int ReadPartial(Socket socket, byte[] buffer, int offset, int size, TimeSpan timeout)
         {
 #if FEATURE_SOCKET_SYNC
-            socket.ReceiveTimeout = (int) timeout.TotalMilliseconds;
+            socket.ReceiveTimeout = (int)timeout.TotalMilliseconds;
 
             try
             {
@@ -197,7 +207,7 @@ public static int ReadPartial(Socket socket, byte[] buffer, int offset, int size
                 receiveCompleted.Dispose();
             }
 #else
-            #error Receiving data from a Socket is not implemented.
+#error Receiving data from a Socket is not implemented.
 #endif
         }
 
@@ -259,7 +269,7 @@ public static void ReadContinuous(Socket socket, byte[] buffer, int offset, int
             if (readToken.Exception != null)
                 throw readToken.Exception;
 #else
-            #error Receiving data from a Socket is not implemented.
+#error Receiving data from a Socket is not implemented.
 #endif
         }
 
@@ -290,7 +300,7 @@ public static int ReadByte(Socket socket, TimeSpan timeout)
         /// <exception cref="SocketException">The write failed.</exception>
         public static void SendByte(Socket socket, byte value)
         {
-            var buffer = new[] {value};
+            var buffer = new[] { value };
             Send(socket, buffer, 0, 1);
         }
 
@@ -317,6 +327,13 @@ public static byte[] Read(Socket socket, int size, TimeSpan timeout)
             return buffer;
         }
 
+#if FEATURE_TAP
+        public static Task<int> ReadAsync(Socket socket, byte[] buffer, int offset, int length, CancellationToken cancellationToken)
+        {
+            return socket.ReceiveAsync(buffer, offset, length, cancellationToken);
+        }
+#endif
+
         /// <summary>
         /// Receives data from a bound <see cref="Socket"/> into a receive buffer.
         /// </summary>
@@ -369,7 +386,7 @@ public static int Read(Socket socket, byte[] buffer, int offset, int size, TimeS
                         throw new SshOperationTimeoutException(string.Format(CultureInfo.InvariantCulture,
                             "Socket read operation has timed out after {0:F0} milliseconds.", readTimeout.TotalMilliseconds));
 
-                     throw;
+                    throw;
                 }
             }
             while (totalBytesRead < totalBytesToRead);
@@ -488,7 +505,7 @@ public static void Send(Socket socket, byte[] data, int offset, int size)
                 sendCompleted.Dispose();
             }
 #else
-            #error Sending data to a Socket is not implemented.
+#error Sending data to a Socket is not implemented.
 #endif
         }
 
@@ -508,7 +525,7 @@ public static bool IsErrorResumable(SocketError socketError)
 #if FEATURE_SOCKET_EAP
         private static void ConnectCompleted(object sender, SocketAsyncEventArgs e)
         {
-            var eventWaitHandle = (ManualResetEvent) e.UserToken;
+            var eventWaitHandle = (ManualResetEvent)e.UserToken;
             if (eventWaitHandle != null)
                 eventWaitHandle.Set();
         }

src/Renci.SshNet/Abstractions/SocketExtensions.cs

@@ -0,0 +1,119 @@
+#if FEATURE_TAP
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Renci.SshNet.Abstractions
+{
+    // Async helpers based on https://devblogs.microsoft.com/pfxteam/awaiting-socket-operations/
+
+    internal static class SocketExtensions
+    {
+        sealed class SocketAsyncEventArgsAwaitable : SocketAsyncEventArgs, INotifyCompletion
+        {
+            private readonly static Action SENTINEL = () => { };
+
+            private bool isCancelled;
+            private Action continuationAction;
+
+            public SocketAsyncEventArgsAwaitable()
+            {
+                Completed += delegate { SetCompleted(); };
+            }
+
+            public SocketAsyncEventArgsAwaitable ExecuteAsync(Func<SocketAsyncEventArgs, bool> func)
+            {
+                if (!func(this))
+                {
+                    SetCompleted();
+                }
+                return this;
+            }
+
+            public void SetCompleted()
+            {
+                IsCompleted = true;
+                var continuation = continuationAction ?? Interlocked.CompareExchange(ref continuationAction, SENTINEL, null);
+                if (continuation != null)
+                {
+                    continuation();
+                }
+            }
+
+            public void SetCancelled()
+            {
+                isCancelled = true;
+                SetCompleted();
+            }
+
+            public SocketAsyncEventArgsAwaitable GetAwaiter() { return this; }
+
+            public bool IsCompleted { get; private set; }
+
+            void INotifyCompletion.OnCompleted(Action continuation)
+            {
+                if (continuationAction == SENTINEL || Interlocked.CompareExchange(ref continuationAction, continuation, null) == SENTINEL)
+                {
+                    // We have already completed; run continuation asynchronously
+                    Task.Run(continuation);
+                }
+            }
+
+            public void GetResult()
+            {
+                if (isCancelled)
+                {
+                    throw new TaskCanceledException();
+                }
+                else if (IsCompleted)
+                {
+                    if (SocketError != SocketError.Success)
+                    {
+                        throw new SocketException((int)SocketError);
+                    }
+                }
+                else
+                {
+                    // We don't support sync/async
+                    throw new InvalidOperationException("The asynchronous operation has not yet completed.");
+                }
+            }
+        }
+
+        public static async Task ConnectAsync(this Socket socket, IPEndPoint remoteEndpoint, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            using (var args = new SocketAsyncEventArgsAwaitable())
+            {
+                args.RemoteEndPoint = remoteEndpoint;
+
+                using (cancellationToken.Register(o => ((SocketAsyncEventArgsAwaitable)o).SetCancelled(), args, false))
+                {
+                    await args.ExecuteAsync(socket.ConnectAsync);
+                }
+            }
+        }
+
+        public static async Task<int> ReceiveAsync(this Socket socket, byte[] buffer, int offset, int length, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            using (var args = new SocketAsyncEventArgsAwaitable())
+            {
+                args.SetBuffer(buffer, offset, length);
+
+                using (cancellationToken.Register(o => ((SocketAsyncEventArgsAwaitable)o).SetCancelled(), args, false))
+                {
+                    await args.ExecuteAsync(socket.ReceiveAsync);
+                }
+
+                return args.BytesTransferred;
+            }
+        }
+    }
+}
+#endif