From ca1a59f6eb116c0e9d32c861df16f3506e39d384 Mon Sep 17 00:00:00 2001
From: Igor Milavec <igor.milavec@gmail.com>
Date: Tue, 4 May 2021 11:05:20 +0200
Subject: [PATCH 01/11] Add FEATURE_TAP and net46 target

---
 src/Renci.SshNet/Renci.SshNet.csproj | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/Renci.SshNet/Renci.SshNet.csproj b/src/Renci.SshNet/Renci.SshNet.csproj
index 124ce9d4b..24524f3d9 100644
--- a/src/Renci.SshNet/Renci.SshNet.csproj
+++ b/src/Renci.SshNet/Renci.SshNet.csproj
@@ -7,7 +7,7 @@
     <AssemblyOriginatorKeyFile>../Renci.SshNet.snk</AssemblyOriginatorKeyFile>
     <LangVersion>5</LangVersion>
     <SignAssembly>true</SignAssembly>
-    <TargetFrameworks>net35;net40;netstandard1.3;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net35;net40;net46;netstandard1.3;netstandard2.0</TargetFrameworks>
   </PropertyGroup>
 
   <!--
@@ -38,10 +38,13 @@
   <PropertyGroup Condition=" '$(TargetFramework)' == 'net40' ">
     <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_REGEX_COMPILE;FEATURE_BINARY_SERIALIZATION;FEATURE_RNG_CREATE;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_EAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_STREAM_APM;FEATURE_DNS_SYNC;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HASH_RIPEMD160_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_HMAC_RIPEMD160;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_ENCODING_ASCII;FEATURE_ECDSA</DefineConstants>
   </PropertyGroup>
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'net46' ">
+    <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_REGEX_COMPILE;FEATURE_BINARY_SERIALIZATION;FEATURE_RNG_CREATE;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_EAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_STREAM_APM;FEATURE_DNS_SYNC;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HASH_RIPEMD160_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_HMAC_RIPEMD160;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_ENCODING_ASCII;FEATURE_ECDSA;FEATURE_TAP</DefineConstants>
+  </PropertyGroup>
   <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard1.3' ">
-    <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_ENCODING_ASCII;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_DIRECTORYINFO_ENUMERATEFILES;FEATURE_MEMORYSTREAM_TRYGETBUFFER;FEATURE_REFLECTION_TYPEINFO;FEATURE_RNG_CREATE;FEATURE_SOCKET_TAP;FEATURE_SOCKET_EAP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_DNS_TAP;FEATURE_STREAM_TAP;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_TAP;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512</DefineConstants>
+    <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_ENCODING_ASCII;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_DIRECTORYINFO_ENUMERATEFILES;FEATURE_MEMORYSTREAM_TRYGETBUFFER;FEATURE_REFLECTION_TYPEINFO;FEATURE_RNG_CREATE;FEATURE_SOCKET_TAP;FEATURE_SOCKET_EAP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_DNS_TAP;FEATURE_STREAM_TAP;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_TAP;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_TAP</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'netstandard2.1' ">
-    <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_ENCODING_ASCII;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_DIRECTORYINFO_ENUMERATEFILES;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_MEMORYSTREAM_TRYGETBUFFER;FEATURE_RNG_CREATE;FEATURE_SOCKET_TAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_EAP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_DNS_SYNC;FEATURE_DNS_APM;FEATURE_DNS_TAP;FEATURE_STREAM_APM;FEATURE_STREAM_TAP;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_TAP;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_ECDSA</DefineConstants>
+    <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_ENCODING_ASCII;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_DIRECTORYINFO_ENUMERATEFILES;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_MEMORYSTREAM_TRYGETBUFFER;FEATURE_RNG_CREATE;FEATURE_SOCKET_TAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_EAP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_DNS_SYNC;FEATURE_DNS_APM;FEATURE_DNS_TAP;FEATURE_STREAM_APM;FEATURE_STREAM_TAP;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_TAP;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_ECDSA;FEATURE_TAP</DefineConstants>
   </PropertyGroup>
 </Project>

From 5f74049e9c99dcbdd309d01f741c142f9d075ed8 Mon Sep 17 00:00:00 2001
From: Igor Milavec <igor.milavec@gmail.com>
Date: Tue, 4 May 2021 11:06:24 +0200
Subject: [PATCH 02/11] Add TAP async support to SftpClient and SftpFileStream

---
 src/Renci.SshNet/ISftpClient.cs         | 128 +++++
 src/Renci.SshNet/Sftp/ISftpSession.cs   |  43 ++
 src/Renci.SshNet/Sftp/SftpFileStream.cs | 363 +++++++++++++-
 src/Renci.SshNet/Sftp/SftpSession.cs    | 604 ++++++++++++++++++------
 src/Renci.SshNet/SftpClient.cs          | 253 +++++++++-
 5 files changed, 1231 insertions(+), 160 deletions(-)

diff --git a/src/Renci.SshNet/ISftpClient.cs b/src/Renci.SshNet/ISftpClient.cs
index b1212cfea..a05e23d9b 100644
--- a/src/Renci.SshNet/ISftpClient.cs
+++ b/src/Renci.SshNet/ISftpClient.cs
@@ -2,8 +2,12 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using System.Threading;
 using Renci.SshNet.Sftp;
 using Renci.SshNet.Common;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
 
 namespace Renci.SshNet
 {
@@ -488,6 +492,22 @@ public interface ISftpClient
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         void DeleteFile(string path);
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously deletes remote file specified by path.
+        /// </summary>
+        /// <param name="path">File to be deleted path.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous delete operation.</returns>
+        /// <exception cref="ArgumentException"><paramref name="path"/> is <b>null</b> or contains only whitespace characters.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="SftpPathNotFoundException"><paramref name="path"/> was not found on the remote host.</exception>
+        /// <exception cref="SftpPermissionDeniedException">Permission to delete the file was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
+        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message"/> is the message from the remote host.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        Task DeleteFileAsync(string path, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Downloads remote file specified by the path into the stream.
         /// </summary>
@@ -506,6 +526,24 @@ public interface ISftpClient
         /// </remarks>
         void DownloadFile(string path, Stream output, Action<ulong> downloadCallback = null);
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously downloads remote file specified by the path into the stream.
+        /// </summary>
+        /// <param name="path">File to download.</param>
+        /// <param name="output">Stream to write the file into.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous download operation.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="output" /> is <b>null</b>.</exception>
+        /// <exception cref="ArgumentException"><paramref name="path" /> is <b>null</b> or contains only whitespace characters.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="SftpPermissionDeniedException">Permission to perform the operation was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
+        /// <exception cref="SftpPathNotFoundException"><paramref name="path"/> was not found on the remote host.</exception>/// 
+        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message" /> is the message from the remote host.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        Task DownloadFileAsync(string path, Stream output, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Ends an asynchronous file downloading into the stream.
         /// </summary>
@@ -653,6 +691,22 @@ public interface ISftpClient
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         SftpFileSytemInformation GetStatus(string path);
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously gets status using statvfs@openssh.com request.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>
+        /// A <see cref="Task{SftpFileSytemInformation}"/> that represents the status operation.
+        /// The task result contains the <see cref="SftpFileSytemInformation"/> instance that contains file status information.
+        /// </returns>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="path" /> is <b>null</b>.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        Task<SftpFileSytemInformation> GetStatusAsync(string path, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Retrieves list of files in remote directory.
         /// </summary>
@@ -668,6 +722,25 @@ public interface ISftpClient
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         IEnumerable<SftpFile> ListDirectory(string path, Action<int> listCallback = null);
 
+#if FEATURE_TAP
+
+        /// <summary>
+        /// Asynchronously retrieves list of files in remote directory.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>
+        /// A <see cref="Task{IEnumerable}"/> that represents the asynchronous list operation.
+        /// The task result contains an enumerable collection of <see cref="SftpFile"/> for the files in the directory specified by <paramref name="path" />.
+        /// </returns>
+        /// <exception cref="ArgumentNullException"><paramref name="path" /> is <b>null</b>.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="SftpPermissionDeniedException">Permission to list the contents of the directory was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
+        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message" /> is the message from the remote host.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        Task<IEnumerable<SftpFile>> ListDirectoryAsync(string path, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Opens a <see cref="SftpFileStream"/> on the specified path with read/write access.
         /// </summary>
@@ -695,6 +768,24 @@ public interface ISftpClient
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         SftpFileStream Open(string path, FileMode mode, FileAccess access);
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously opens a <see cref="SftpFileStream"/> on the specified path, with the specified mode and access.
+        /// </summary>
+        /// <param name="path">The file to open.</param>
+        /// <param name="mode">A <see cref="FileMode"/> value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten.</param>
+        /// <param name="access">A <see cref="FileAccess"/> value that specifies the operations that can be performed on the file.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>
+        /// A <see cref="Task{SftpFileStream}"/> that represents the asynchronous open operation.
+        /// The task result contains the <see cref="SftpFileStream"/> that provides access to the specified file, with the specified mode and access.
+        /// </returns>
+        /// <exception cref="ArgumentNullException"><paramref name="path"/> is <b>null</b>.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        Task<SftpFileStream> OpenAsync(string path, FileMode mode, FileAccess access, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Opens an existing file for reading.
         /// </summary>
@@ -833,6 +924,22 @@ public interface ISftpClient
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         void RenameFile(string oldPath, string newPath);
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously renames remote file from old path to new path.
+        /// </summary>
+        /// <param name="oldPath">Path to the old file location.</param>
+        /// <param name="newPath">Path to the new file location.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous rename operation.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="oldPath"/> is <b>null</b>. <para>-or-</para> or <paramref name="newPath"/> is <b>null</b>.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="SftpPermissionDeniedException">Permission to rename the file was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
+        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message"/> is the message from the remote host.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        Task RenameFileAsync(string oldPath, string newPath, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Renames remote file from old path to new path.
         /// </summary>
@@ -917,6 +1024,27 @@ public interface ISftpClient
         /// </remarks>
         void UploadFile(Stream input, string path, bool canOverride, Action<ulong> uploadCallback = null);
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously uploads stream into remote file.
+        /// </summary>
+        /// <param name="input">Data input stream.</param>
+        /// <param name="path">Remote file path.</param>
+        /// <param name="canOverride">if set to <c>true</c> then existing file will be overwritten.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous upload operation.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="input" /> is <b>null</b>.</exception>
+        /// <exception cref="ArgumentException"><paramref name="path" /> is <b>null</b> or contains only whitespace characters.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="SftpPermissionDeniedException">Permission to upload the file was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
+        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message" /> is the message from the remote host.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        /// <remarks>
+        /// Method calls made by this method to <paramref name="input" />, may under certain conditions result in exceptions thrown by the stream.
+        /// </remarks>
+        Task UploadFileAsync(Stream input, string path, bool canOverride, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Writes the specified byte array to the specified file, and closes the file.
         /// </summary>
diff --git a/src/Renci.SshNet/Sftp/ISftpSession.cs b/src/Renci.SshNet/Sftp/ISftpSession.cs
index 3d3993bbd..e246aa046 100644
--- a/src/Renci.SshNet/Sftp/ISftpSession.cs
+++ b/src/Renci.SshNet/Sftp/ISftpSession.cs
@@ -2,6 +2,9 @@
 using System.Collections.Generic;
 using System.Threading;
 using Renci.SshNet.Sftp.Responses;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
 
 namespace Renci.SshNet.Sftp
 {
@@ -38,6 +41,10 @@ internal interface ISftpSession : ISubsystemSession
         /// </returns>
         string GetCanonicalPath(string path);
 
+#if FEATURE_TAP
+        Task<string> GetCanonicalPathAsync(string path, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_FSTAT request.
         /// </summary>
@@ -124,6 +131,10 @@ internal interface ISftpSession : ISubsystemSession
         /// <returns>File handle.</returns>
         byte[] RequestOpen(string path, Flags flags, bool nullOnError = false);
 
+#if FEATURE_TAP
+        Task<byte[]> OpenAsync(string path, Flags flags, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_OPEN request
         /// </summary>
@@ -158,6 +169,10 @@ internal interface ISftpSession : ISubsystemSession
         /// <returns>File handle.</returns>
         byte[] RequestOpenDir(string path, bool nullOnError = false);
 
+#if FEATURE_TAP
+        Task<byte[]> RequestOpenDirAsync(string path, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Performs posix-rename@openssh.com extended request.
         /// </summary>
@@ -201,6 +216,10 @@ internal interface ISftpSession : ISubsystemSession
         /// <exception cref="ArgumentNullException"><paramref name="asyncResult"/> is <c>null</c>.</exception>
         byte[] EndRead(SftpReadAsyncResult asyncResult);
 
+#if FEATURE_TAP
+        Task<byte[]> ReadAsync(byte[] handle, ulong offset, uint length, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_READDIR request
         /// </summary>
@@ -208,6 +227,10 @@ internal interface ISftpSession : ISubsystemSession
         /// <returns></returns>
         KeyValuePair<string, SftpFileAttributes>[] RequestReadDir(byte[] handle);
 
+#if FEATURE_TAP
+        Task<KeyValuePair<string, SftpFileAttributes>[]> RequestReadDirAsync(byte[] handle, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_REALPATH request.
         /// </summary>
@@ -235,6 +258,10 @@ internal interface ISftpSession : ISubsystemSession
         /// <param name="path">The path.</param>
         void RequestRemove(string path);
 
+#if FEATURE_TAP
+        Task RequestRemoveAsync(string path, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_RENAME request.
         /// </summary>
@@ -242,6 +269,10 @@ internal interface ISftpSession : ISubsystemSession
         /// <param name="newPath">The new path.</param>
         void RequestRename(string oldPath, string newPath);
 
+#if FEATURE_TAP
+        Task RequestRenameAsync(string oldPath, string newPath, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_RMDIR request.
         /// </summary>
@@ -263,6 +294,10 @@ internal interface ISftpSession : ISubsystemSession
         /// <returns></returns>
         SftpFileSytemInformation RequestStatVfs(string path, bool nullOnError = false);
 
+#if FEATURE_TAP
+        Task<SftpFileSytemInformation> RequestStatVfsAsync(string path, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_SYMLINK request.
         /// </summary>
@@ -295,12 +330,20 @@ void RequestWrite(byte[] handle,
                           AutoResetEvent wait,
                           Action<SftpStatusResponse> writeCompleted = null);
 
+#if FEATURE_TAP
+        Task WriteAsync(byte[] handle, ulong serverOffset, byte[] data, int offset, int length, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_CLOSE request.
         /// </summary>
         /// <param name="handle">The handle.</param>
         void RequestClose(byte[] handle);
 
+#if FEATURE_TAP
+        Task CloseAsync(byte[] handle, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_CLOSE request.
         /// </summary>
diff --git a/src/Renci.SshNet/Sftp/SftpFileStream.cs b/src/Renci.SshNet/Sftp/SftpFileStream.cs
index 8f51250ce..46e87cce9 100644
--- a/src/Renci.SshNet/Sftp/SftpFileStream.cs
+++ b/src/Renci.SshNet/Sftp/SftpFileStream.cs
@@ -3,6 +3,9 @@
 using System.Threading;
 using System.Diagnostics.CodeAnalysis;
 using Renci.SshNet.Common;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
 
 namespace Renci.SshNet.Sftp
 {
@@ -166,6 +169,28 @@ public virtual byte[] Handle
         /// </value>
         public TimeSpan Timeout { get; set; }
 
+        private SftpFileStream(ISftpSession session, string path, FileAccess access, int bufferSize, byte[] handle, long position)
+        {
+            Timeout = TimeSpan.FromSeconds(30);
+            Name = path;
+
+            _session = session;
+            _canRead = (access & FileAccess.Read) != 0;
+            _canSeek = true;
+            _canWrite = (access & FileAccess.Write) != 0;
+
+            _handle = handle;
+
+            // instead of using the specified buffer size as is, we use it to calculate a buffer size
+            // that ensures we always receive or send the max. number of bytes in a single SSH_FXP_READ
+            // or SSH_FXP_WRITE message
+
+            _readBufferSize = (int)session.CalculateOptimalReadLength((uint)bufferSize);
+            _writeBufferSize = (int)session.CalculateOptimalWriteLength((uint)bufferSize, _handle);
+
+            _position = position;
+        }
+
         internal SftpFileStream(ISftpSession session, string path, FileMode mode, FileAccess access, int bufferSize)
         {
             if (session == null)
@@ -267,6 +292,110 @@ internal SftpFileStream(ISftpSession session, string path, FileMode mode, FileAc
             }
         }
 
+#if FEATURE_TAP
+        internal static async Task<SftpFileStream> OpenAsync(ISftpSession session, string path, FileMode mode, FileAccess access, int bufferSize, CancellationToken cancellationToken)
+        {
+            if (session == null)
+                throw new SshConnectionException("Client not connected.");
+            if (path == null)
+                throw new ArgumentNullException("path");
+            if (bufferSize <= 0)
+                throw new ArgumentOutOfRangeException("bufferSize");
+
+            var flags = Flags.None;
+
+            switch (access)
+            {
+                case FileAccess.Read:
+                    flags |= Flags.Read;
+                    break;
+                case FileAccess.Write:
+                    flags |= Flags.Write;
+                    break;
+                case FileAccess.ReadWrite:
+                    flags |= Flags.Read;
+                    flags |= Flags.Write;
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException("access");
+            }
+
+            if ((access & FileAccess.Read) != 0 && mode == FileMode.Append)
+            {
+                throw new ArgumentException(string.Format("{0} mode can be requested only when combined with write-only access.", mode.ToString("G")));
+            }
+
+            if ((access & FileAccess.Write) == 0)
+            {
+                if (mode == FileMode.Create || mode == FileMode.CreateNew || mode == FileMode.Truncate || mode == FileMode.Append)
+                {
+                    throw new ArgumentException(string.Format("Combining {0}: {1} with {2}: {3} is invalid.",
+                        typeof(FileMode).Name,
+                        mode,
+                        typeof(FileAccess).Name,
+                        access));
+                }
+            }
+
+            byte[] handle = null;
+
+            switch (mode)
+            {
+                case FileMode.Append:
+                    flags |= Flags.Append | Flags.CreateNewOrOpen;
+                    break;
+                case FileMode.Create:
+                    try
+                    {
+                        handle = await session.OpenAsync(path, flags | Flags.Truncate, cancellationToken).ConfigureAwait(false);
+                        flags |= Flags.Truncate;
+                    }
+                    catch (TaskCanceledException)// ToDo: when (cancellationToken.IsCancellationRequested)
+                    {
+                        throw;
+                    }
+                    catch (Exception)
+                    {
+                        flags |= Flags.CreateNew;
+                    }
+                    break;
+                case FileMode.CreateNew:
+                    flags |= Flags.CreateNew;
+                    break;
+                case FileMode.Open:
+                    break;
+                case FileMode.OpenOrCreate:
+                    flags |= Flags.CreateNewOrOpen;
+                    break;
+                case FileMode.Truncate:
+                    flags |= Flags.Truncate;
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException("mode");
+            }
+
+            if (handle == null)
+                handle = await session.OpenAsync(path, flags, cancellationToken).ConfigureAwait(false);
+
+            long position = 0;
+            if (mode == FileMode.Append)
+            {
+                try
+                {
+                    var attributes = session.RequestFStat(handle, false);  // ToDo: Async
+                    position = attributes.Size;
+                }
+                catch
+                {
+                    session.RequestClose(handle);  // ToDo: Async
+                    throw;
+                }
+            }
+
+            return new SftpFileStream(session, path, access, bufferSize, handle, position);
+        }
+#endif
+
         /// <summary>
         /// Releases unmanaged resources and performs other cleanup operations before the
         /// <see cref="SftpFileStream"/> is reclaimed by garbage collection.
@@ -298,6 +427,31 @@ public override void Flush()
             }
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously clears all buffers for this stream and causes any buffered data to be written to the file.
+        /// </summary>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous flush operation.</returns>
+        /// <exception cref="IOException">An I/O error occurs. </exception>
+        /// <exception cref="ObjectDisposedException">Stream is closed.</exception>
+        public override Task FlushAsync(CancellationToken cancellationToken)
+        {
+            CheckSessionIsOpen();
+
+            if (_bufferOwnedByWrite)
+            {
+                return FlushWriteBufferAsync(cancellationToken);
+            }
+            else
+            {
+                FlushReadBuffer();
+            }
+
+            return Task.CompletedTask;
+        }
+#endif
+
         /// <summary>
         /// Reads a sequence of bytes from the current stream and advances the position within the stream by the
         /// number of bytes read.
@@ -359,7 +513,7 @@ public override int Read(byte[] buffer, int offset, int count)
                     var bytesAvailableInBuffer = _bufferLen - _bufferPosition;
                     if (bytesAvailableInBuffer <= 0)
                     {
-                        var data = _session.RequestRead(_handle, (ulong) _position, (uint) _readBufferSize);
+                        var data = _session.RequestRead(_handle, (ulong)_position, (uint)_readBufferSize);
 
                         if (data.Length == 0)
                         {
@@ -438,6 +592,124 @@ public override int Read(byte[] buffer, int offset, int count)
             return readLen;
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the
+        /// number of bytes read.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between <paramref name="offset"/> and (<paramref name="offset"/> + <paramref name="count"/> - 1) replaced by the bytes read from the current source.</param>
+        /// <param name="offset">The zero-based byte offset in <paramref name="buffer"/> at which to begin storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken" /> to observe.</param>
+        /// <returns>A <see cref="Task" /> that represents the asynchronous read operation.</returns>
+        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            var readLen = 0;
+
+            if (buffer == null)
+                throw new ArgumentNullException("buffer");
+            if (offset < 0)
+                throw new ArgumentOutOfRangeException("offset");
+            if (count < 0)
+                throw new ArgumentOutOfRangeException("count");
+            if ((buffer.Length - offset) < count)
+                throw new ArgumentException("Invalid array range.");
+
+            // Lock down the file stream while we do this.
+            //lock (_lock)  Do we need to be thread safe?
+            {
+                CheckSessionIsOpen();
+
+                // Set up for the read operation.
+                SetupRead();
+
+                // Read data into the caller's buffer.
+                while (count > 0)
+                {
+                    // How much data do we have available in the buffer?
+                    var bytesAvailableInBuffer = _bufferLen - _bufferPosition;
+                    if (bytesAvailableInBuffer <= 0)
+                    {
+                        var data = await _session.ReadAsync(_handle, (ulong)_position, (uint)_readBufferSize, cancellationToken).ConfigureAwait(false);
+
+                        if (data.Length == 0)
+                        {
+                            _bufferPosition = 0;
+                            _bufferLen = 0;
+
+                            break;
+                        }
+
+                        var bytesToWriteToCallerBuffer = count;
+                        if (bytesToWriteToCallerBuffer >= data.Length)
+                        {
+                            // write all data read to caller-provided buffer
+                            bytesToWriteToCallerBuffer = data.Length;
+                            // reset buffer since we will skip buffering
+                            _bufferPosition = 0;
+                            _bufferLen = 0;
+                        }
+                        else
+                        {
+                            // determine number of bytes that we should write into read buffer
+                            var bytesToWriteToReadBuffer = data.Length - bytesToWriteToCallerBuffer;
+                            // write remaining bytes to read buffer
+                            Buffer.BlockCopy(data, count, GetOrCreateReadBuffer(), 0, bytesToWriteToReadBuffer);
+                            // update position in read buffer
+                            _bufferPosition = 0;
+                            // update number of bytes in read buffer
+                            _bufferLen = bytesToWriteToReadBuffer;
+                        }
+
+                        // write bytes to caller-provided buffer
+                        Buffer.BlockCopy(data, 0, buffer, offset, bytesToWriteToCallerBuffer);
+                        // update stream position
+                        _position += bytesToWriteToCallerBuffer;
+                        // record total number of bytes read into caller-provided buffer
+                        readLen += bytesToWriteToCallerBuffer;
+
+                        // break out of the read loop when the server returned less than the request number of bytes
+                        // as that *may* indicate that we've reached EOF
+                        //
+                        // doing this avoids reading from server twice to determine EOF: once in the read loop, and
+                        // once upon the next Read or ReadByte invocation by the caller
+                        if (data.Length < _readBufferSize)
+                        {
+                            break;
+                        }
+
+                        // advance offset to start writing bytes into caller-provided buffer
+                        offset += bytesToWriteToCallerBuffer;
+                        // update number of bytes left to read into caller-provided buffer
+                        count -= bytesToWriteToCallerBuffer;
+                    }
+                    else
+                    {
+                        // limit the number of bytes to use from read buffer to the caller-request number of bytes
+                        if (bytesAvailableInBuffer > count)
+                            bytesAvailableInBuffer = count;
+
+                        // copy data from read buffer to the caller-provided buffer
+                        Buffer.BlockCopy(GetOrCreateReadBuffer(), _bufferPosition, buffer, offset, bytesAvailableInBuffer);
+                        // update position in read buffer
+                        _bufferPosition += bytesAvailableInBuffer;
+                        // update stream position
+                        _position += bytesAvailableInBuffer;
+                        // record total number of bytes read into caller-provided buffer
+                        readLen += bytesAvailableInBuffer;
+                        // advance offset to start writing bytes into caller-provided buffer
+                        offset += bytesAvailableInBuffer;
+                        // update number of bytes left to read
+                        count -= bytesAvailableInBuffer;
+                    }
+                }
+            }
+
+            // return the number of bytes that were read to the caller.
+            return readLen;
+        }
+#endif
+
         /// <summary>
         /// Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.
         /// </summary>
@@ -740,6 +1012,84 @@ public override void Write(byte[] buffer, int offset, int count)
             }
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. This method copies <paramref name="count"/> bytes from <paramref name="buffer"/> to the current stream.</param>
+        /// <param name="offset">The zero-based byte offset in <paramref name="buffer"/> at which to begin copying bytes to the current stream.</param>
+        /// <param name="count">The number of bytes to be written to the current stream.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous write operation.</returns>
+        /// <exception cref="ArgumentException">The sum of <paramref name="offset"/> and <paramref name="count"/> is greater than the buffer length.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="offset"/> or <paramref name="count"/> is negative.</exception>
+        /// <exception cref="IOException">An I/O error occurs.</exception>
+        /// <exception cref="NotSupportedException">The stream does not support writing.</exception>
+        /// <exception cref="ObjectDisposedException">Methods were called after the stream was closed.</exception>
+        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            if (buffer == null)
+                throw new ArgumentNullException("buffer");
+            if (offset < 0)
+                throw new ArgumentOutOfRangeException("offset");
+            if (count < 0)
+                throw new ArgumentOutOfRangeException("count");
+            if ((buffer.Length - offset) < count)
+                throw new ArgumentException("Invalid array range.");
+
+            CheckSessionIsOpen();
+
+            // Setup this object for writing.
+            SetupWrite();
+
+            // Write data to the file stream.
+            while (count > 0)
+            {
+                // Determine how many bytes we can write to the buffer.
+                var tempLen = _writeBufferSize - _bufferPosition;
+                if (tempLen <= 0)
+                {
+                    // flush write buffer, and mark it empty
+                    await FlushWriteBufferAsync(cancellationToken).ConfigureAwait(false);
+                    // we can now write or buffer the full buffer size
+                    tempLen = _writeBufferSize;
+                }
+
+                // limit the number of bytes to write to the actual number of bytes requested
+                if (tempLen > count)
+                {
+                    tempLen = count;
+                }
+
+                // Can we short-cut the internal buffer?
+                if (_bufferPosition == 0 && tempLen == _writeBufferSize)
+                {
+                    await _session.WriteAsync(_handle, (ulong)_position, buffer, offset, tempLen, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    // No: copy the data to the write buffer first.
+                    Buffer.BlockCopy(buffer, offset, GetOrCreateWriteBuffer(), _bufferPosition, tempLen);
+                    _bufferPosition += tempLen;
+                }
+
+                // Advance the buffer and stream positions.
+                _position += tempLen;
+                offset += tempLen;
+                count -= tempLen;
+            }
+
+            // If the buffer is full, then do a speculative flush now,
+            // rather than waiting for the next call to this method.
+            if (_bufferPosition >= _writeBufferSize)
+            {
+                await _session.WriteAsync(_handle, (ulong)(_position - _bufferPosition), GetOrCreateWriteBuffer(), 0, _bufferPosition, cancellationToken).ConfigureAwait(false);
+                _bufferPosition = 0;
+            }
+        }
+#endif
+
         /// <summary>
         /// Writes a byte to the current position in the stream and advances the position within the stream by one byte.
         /// </summary>
@@ -857,6 +1207,17 @@ private void FlushWriteBuffer()
             }
         }
 
+#if FEATURE_TAP
+        private async Task FlushWriteBufferAsync(CancellationToken cancellationToken)
+        {
+            if (_bufferPosition > 0)
+            {
+                await _session.WriteAsync(_handle, (ulong)(_position - _bufferPosition), _writeBuffer, 0, _bufferPosition, cancellationToken);
+                _bufferPosition = 0;
+            }
+        }
+#endif
+
         /// <summary>
         /// Setups the read.
         /// </summary>
diff --git a/src/Renci.SshNet/Sftp/SftpSession.cs b/src/Renci.SshNet/Sftp/SftpSession.cs
index 283ff6179..8b57709ac 100644
--- a/src/Renci.SshNet/Sftp/SftpSession.cs
+++ b/src/Renci.SshNet/Sftp/SftpSession.cs
@@ -6,6 +6,9 @@
 using System.Globalization;
 using Renci.SshNet.Sftp.Responses;
 using Renci.SshNet.Sftp.Requests;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
 
 namespace Renci.SshNet.Sftp
 {
@@ -136,6 +139,56 @@ public string GetCanonicalPath(string path)
             return string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}", canonizedPath, slash, pathParts[pathParts.Length - 1]);
         }
 
+#if FEATURE_TAP
+        public async Task<string> GetCanonicalPathAsync(string path, CancellationToken cancellationToken)
+        {
+            var fullPath = GetFullRemotePath(path);
+
+            var canonizedPath = string.Empty;
+
+            var realPathFiles = await RequestRealPathAsync(fullPath, true, cancellationToken).ConfigureAwait(false);
+
+            if (realPathFiles != null)
+            {
+                canonizedPath = realPathFiles[0].Key;
+            }
+
+            if (!string.IsNullOrEmpty(canonizedPath))
+                return canonizedPath;
+
+            //  Check for special cases
+            if (fullPath.EndsWith("/.", StringComparison.OrdinalIgnoreCase) ||
+                fullPath.EndsWith("/..", StringComparison.OrdinalIgnoreCase) ||
+                fullPath.Equals("/", StringComparison.OrdinalIgnoreCase) ||
+                fullPath.IndexOf('/') < 0)
+                return fullPath;
+
+            var pathParts = fullPath.Split('/');
+
+            var partialFullPath = string.Join("/", pathParts, 0, pathParts.Length - 1);
+
+            if (string.IsNullOrEmpty(partialFullPath))
+                partialFullPath = "/";
+
+            realPathFiles = RequestRealPath(partialFullPath, true);
+
+            if (realPathFiles != null)
+            {
+                canonizedPath = realPathFiles[0].Key;
+            }
+
+            if (string.IsNullOrEmpty(canonizedPath))
+            {
+                return fullPath;
+            }
+
+            var slash = string.Empty;
+            if (canonizedPath[canonizedPath.Length - 1] != '/')
+                slash = "/";
+            return string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}", canonizedPath, slash, pathParts[pathParts.Length - 1]);
+        }
+#endif
+
         public ISftpFileReader CreateFileReader(byte[] handle, ISftpSession sftpSession, uint chunkSize, int maxPendingReads, long? fileSize)
         {
             return new SftpFileReader(handle, sftpSession, chunkSize, maxPendingReads, fileSize);
@@ -362,15 +415,15 @@ public byte[] RequestOpen(string path, Flags flags, bool nullOnError = false)
             {
                 var request = new SftpOpenRequest(ProtocolVersion, NextRequestId, path, Encoding, flags,
                     response =>
-                        {
-                            handle = response.Handle;
-                            wait.Set();
-                        },
+                    {
+                        handle = response.Handle;
+                        wait.Set();
+                    },
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -444,6 +497,24 @@ public byte[] EndOpen(SftpOpenAsyncResult asyncResult)
             }
         }
 
+#if FEATURE_TAP
+        public async Task<byte[]> OpenAsync(string path, Flags flags, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<byte[]> tcs = new TaskCompletionSource<byte[]>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<byte[]>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new SftpOpenRequest(ProtocolVersion, NextRequestId, path, Encoding, flags,
+                    response => tcs.TrySetResult(response.Handle),
+                    response => tcs.TrySetException(GetSftpException(response))));
+
+                return await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_CLOSE request.
         /// </summary>
@@ -456,10 +527,10 @@ public void RequestClose(byte[] handle)
             {
                 var request = new SftpCloseRequest(ProtocolVersion, NextRequestId, handle,
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -472,6 +543,34 @@ public void RequestClose(byte[] handle)
             }
         }
 
+#if FEATURE_TAP
+        public async Task CloseAsync(byte[] handle, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<bool>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new SftpCloseRequest(ProtocolVersion, NextRequestId, handle,
+                    response =>
+                    {
+                        if (response.StatusCode == StatusCodes.Ok)
+                        {
+                            tcs.TrySetResult(true);
+                        }
+                        else
+                        {
+                            tcs.TrySetException(GetSftpException(response));
+                        }
+                    }));
+
+                await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
+
         /// <summary>
         /// Performs SSH_FXP_CLOSE request.
         /// </summary>
@@ -605,22 +704,22 @@ public byte[] RequestRead(byte[] handle, ulong offset, uint length)
             {
                 var request = new SftpReadRequest(ProtocolVersion, NextRequestId, handle, offset, length,
                     response =>
-                        {
-                            data = response.Data;
-                            wait.Set();
-                        },
+                    {
+                        data = response.Data;
+                        wait.Set();
+                    },
                     response =>
+                    {
+                        if (response.StatusCode != StatusCodes.Eof)
                         {
-                            if (response.StatusCode != StatusCodes.Eof)
-                            {
-                                exception = GetSftpException(response);
-                            }
-                            else
-                            {
-                                data = Array<byte>.Empty;
-                            }
-                            wait.Set();
-                        });
+                            exception = GetSftpException(response);
+                        }
+                        else
+                        {
+                            data = Array<byte>.Empty;
+                        }
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -635,6 +734,34 @@ public byte[] RequestRead(byte[] handle, ulong offset, uint length)
             return data;
         }
 
+#if FEATURE_TAP
+        public async Task<byte[]> ReadAsync(byte[] handle, ulong offset, uint length, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<byte[]> tcs = new TaskCompletionSource<byte[]>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<byte[]>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new SftpReadRequest(ProtocolVersion, NextRequestId, handle, offset, length,
+                    response => tcs.TrySetResult(response.Data),
+                    response =>
+                    {
+                        if (response.StatusCode == StatusCodes.Eof)
+                        {
+                            tcs.TrySetResult(Array<byte>.Empty);
+                        }
+                        else
+                        {
+                            tcs.TrySetException(GetSftpException(response));
+                        }
+                    }));
+
+                return await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_WRITE request.
         /// </summary>
@@ -655,18 +782,18 @@ public void RequestWrite(byte[] handle,
         {
             SshException exception = null;
 
-            var request = new SftpWriteRequest(ProtocolVersion, NextRequestId, handle, serverOffset, data, offset,
-                length, response =>
+            var request = new SftpWriteRequest(ProtocolVersion, NextRequestId, handle, serverOffset, data, offset, length,
+                response =>
+                {
+                    if (writeCompleted != null)
                     {
-                        if (writeCompleted != null)
-                        {
-                            writeCompleted(response);
-                        }
+                        writeCompleted(response);
+                    }
 
-                        exception = GetSftpException(response);
-                        if (wait != null)
-                            wait.Set();
-                    });
+                    exception = GetSftpException(response);
+                    if (wait != null)
+                        wait.Set();
+                });
 
             SendRequest(request);
 
@@ -679,6 +806,33 @@ public void RequestWrite(byte[] handle,
             }
         }
 
+#if FEATURE_TAP
+        public async Task WriteAsync(byte[] handle, ulong serverOffset, byte[] data, int offset, int length, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<bool>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new SftpWriteRequest(ProtocolVersion, NextRequestId, handle, serverOffset, data, offset, length,
+                    response =>
+                    {
+                        if (response.StatusCode == StatusCodes.Ok)
+                        {
+                            tcs.TrySetResult(true);
+                        }
+                        else
+                        {
+                            tcs.TrySetException(GetSftpException(response));
+                        }
+                    }));
+
+                await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_LSTAT request.
         /// </summary>
@@ -695,15 +849,15 @@ public SftpFileAttributes RequestLStat(string path)
             {
                 var request = new SftpLStatRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                        {
-                            attributes = response.Attributes;
-                            wait.Set();
-                        },
+                    {
+                        attributes = response.Attributes;
+                        wait.Set();
+                    },
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -788,15 +942,15 @@ public SftpFileAttributes RequestFStat(byte[] handle, bool nullOnError)
             {
                 var request = new SftpFStatRequest(ProtocolVersion, NextRequestId, handle,
                     response =>
-                        {
-                            attributes = response.Attributes;
-                            wait.Set();
-                        },
+                    {
+                        attributes = response.Attributes;
+                        wait.Set();
+                    },
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -824,10 +978,10 @@ public void RequestSetStat(string path, SftpFileAttributes attributes)
             {
                 var request = new SftpSetStatRequest(ProtocolVersion, NextRequestId, path, Encoding, attributes,
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -853,10 +1007,10 @@ public void RequestFSetStat(byte[] handle, SftpFileAttributes attributes)
             {
                 var request = new SftpFSetStatRequest(ProtocolVersion, NextRequestId, handle, attributes,
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -885,15 +1039,15 @@ public byte[] RequestOpenDir(string path, bool nullOnError = false)
             {
                 var request = new SftpOpenDirRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                        {
-                            handle = response.Handle;
-                            wait.Set();
-                        },
+                    {
+                        handle = response.Handle;
+                        wait.Set();
+                    },
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -908,6 +1062,24 @@ public byte[] RequestOpenDir(string path, bool nullOnError = false)
             return handle;
         }
 
+#if FEATURE_TAP
+        public async Task<byte[]> RequestOpenDirAsync(string path, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<byte[]> tcs = new TaskCompletionSource<byte[]>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<byte[]>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new SftpOpenDirRequest(ProtocolVersion, NextRequestId, path, Encoding,
+                    response => tcs.TrySetResult(response.Handle),
+                    response => tcs.TrySetException(GetSftpException(response))));
+
+                return await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_READDIR request
         /// </summary>
@@ -923,18 +1095,18 @@ public KeyValuePair<string, SftpFileAttributes>[] RequestReadDir(byte[] handle)
             {
                 var request = new SftpReadDirRequest(ProtocolVersion, NextRequestId, handle,
                     response =>
-                        {
-                            result = response.Files;
-                            wait.Set();
-                        },
+                    {
+                        result = response.Files;
+                        wait.Set();
+                    },
                     response =>
+                    {
+                        if (response.StatusCode != StatusCodes.Eof)
                         {
-                            if (response.StatusCode != StatusCodes.Eof)
-                            {
-                                exception = GetSftpException(response);
-                            }
-                            wait.Set();
-                        });
+                            exception = GetSftpException(response);
+                        }
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -949,6 +1121,35 @@ public KeyValuePair<string, SftpFileAttributes>[] RequestReadDir(byte[] handle)
             return result;
         }
 
+#if FEATURE_TAP
+        public async Task<KeyValuePair<string, SftpFileAttributes>[]> RequestReadDirAsync(byte[] handle, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<KeyValuePair<string, SftpFileAttributes>[]> tcs = new TaskCompletionSource<KeyValuePair<string, SftpFileAttributes>[]>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<KeyValuePair<string, SftpFileAttributes>[]>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new SftpReadDirRequest(ProtocolVersion, NextRequestId, handle,
+                    response => tcs.TrySetResult(response.Files),
+                    response =>
+                    {
+                        if (response.StatusCode == StatusCodes.Eof)
+                        {
+                            tcs.TrySetResult(null);
+                        }
+                        else
+                        {
+                            tcs.TrySetException(GetSftpException(response));
+                        }
+                    }));
+
+                return await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
+
         /// <summary>
         /// Performs SSH_FXP_REMOVE request.
         /// </summary>
@@ -961,10 +1162,10 @@ public void RequestRemove(string path)
             {
                 var request = new SftpRemoveRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -977,6 +1178,34 @@ public void RequestRemove(string path)
             }
         }
 
+#if FEATURE_TAP
+        public async Task RequestRemoveAsync(string path, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<bool>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new SftpRemoveRequest(ProtocolVersion, NextRequestId, path, Encoding,
+                    response =>
+                    {
+                        if (response.StatusCode == StatusCodes.Ok)
+                        {
+                            tcs.TrySetResult(true);
+                        }
+                        else
+                        {
+                            tcs.TrySetException(GetSftpException(response));
+                        }
+                    }));
+
+                await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
+
         /// <summary>
         /// Performs SSH_FXP_MKDIR request.
         /// </summary>
@@ -989,10 +1218,10 @@ public void RequestMkDir(string path)
             {
                 var request = new SftpMkDirRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -1017,10 +1246,10 @@ public void RequestRmDir(string path)
             {
                 var request = new SftpRmDirRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -1051,15 +1280,15 @@ internal KeyValuePair<string, SftpFileAttributes>[] RequestRealPath(string path,
             {
                 var request = new SftpRealPathRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                        {
-                            result = response.Files;
-                            wait.Set();
-                        },
+                    {
+                        result = response.Files;
+                        wait.Set();
+                    },
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -1070,10 +1299,37 @@ internal KeyValuePair<string, SftpFileAttributes>[] RequestRealPath(string path,
             {
                 throw exception;
             }
-            
+
             return result;
         }
 
+#if FEATURE_TAP
+        internal async Task<KeyValuePair<string, SftpFileAttributes>[]> RequestRealPathAsync(string path, bool nullOnError, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<KeyValuePair<string, SftpFileAttributes>[]> tcs = new TaskCompletionSource<KeyValuePair<string, SftpFileAttributes>[]>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<KeyValuePair<string, SftpFileAttributes>[]>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new SftpRealPathRequest(ProtocolVersion, NextRequestId, path, Encoding,
+                    response => tcs.TrySetResult(response.Files),
+                    response => {
+                        if (nullOnError)
+                        {
+                            tcs.TrySetResult(null);
+                        }
+                        else
+                        {
+                            tcs.TrySetException(GetSftpException(response));
+                        }
+                    }));
+
+                return await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_REALPATH request.
         /// </summary>
@@ -1145,15 +1401,15 @@ public SftpFileAttributes RequestStat(string path, bool nullOnError = false)
             {
                 var request = new SftpStatRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                        {
-                            attributes = response.Attributes;
-                            wait.Set();
-                        },
+                    {
+                        attributes = response.Attributes;
+                        wait.Set();
+                    },
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -1239,10 +1495,10 @@ public void RequestRename(string oldPath, string newPath)
             {
                 var request = new SftpRenameRequest(ProtocolVersion, NextRequestId, oldPath, newPath, Encoding,
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -1255,6 +1511,34 @@ public void RequestRename(string oldPath, string newPath)
             }
         }
 
+
+#if FEATURE_TAP
+        public async Task RequestRenameAsync(string oldPath, string newPath, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<bool>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new SftpRenameRequest(ProtocolVersion, NextRequestId, oldPath, newPath, Encoding,
+                    response =>
+                    {
+                        if (response.StatusCode == StatusCodes.Ok)
+                        {
+                            tcs.TrySetResult(true);
+                        }
+                        else
+                        {
+                            tcs.TrySetException(GetSftpException(response));
+                        }
+                    }));
+
+                await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_READLINK request.
         /// </summary>
@@ -1276,15 +1560,15 @@ internal KeyValuePair<string, SftpFileAttributes>[] RequestReadLink(string path,
             {
                 var request = new SftpReadLinkRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                        {
-                            result = response.Files;
-                            wait.Set();
-                        },
+                    {
+                        result = response.Files;
+                        wait.Set();
+                    },
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -1317,10 +1601,10 @@ public void RequestSymLink(string linkpath, string targetpath)
             {
                 var request = new SftpSymLinkRequest(ProtocolVersion, NextRequestId, linkpath, targetpath, Encoding,
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 SendRequest(request);
 
@@ -1355,10 +1639,10 @@ public void RequestPosixRename(string oldPath, string newPath)
             {
                 var request = new PosixRenameRequest(ProtocolVersion, NextRequestId, oldPath, newPath, Encoding,
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 if (!_supportedExtensions.ContainsKey(request.Name))
                     throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "Extension method {0} currently not supported by the server.", request.Name));
@@ -1395,15 +1679,15 @@ public SftpFileSytemInformation RequestStatVfs(string path, bool nullOnError = f
             {
                 var request = new StatVfsRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                        {
-                            information = response.GetReply<StatVfsReplyInfo>().Information;
-                            wait.Set();
-                        },
+                    {
+                        information = response.GetReply<StatVfsReplyInfo>().Information;
+                        wait.Set();
+                    },
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 if (!_supportedExtensions.ContainsKey(request.Name))
                     throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "Extension method {0} currently not supported by the server.", request.Name));
@@ -1421,6 +1705,30 @@ public SftpFileSytemInformation RequestStatVfs(string path, bool nullOnError = f
             return information;
         }
 
+
+#if FEATURE_TAP
+        public async Task<SftpFileSytemInformation> RequestStatVfsAsync(string path, CancellationToken cancellationToken)
+        {
+            if (ProtocolVersion < 3)
+            {
+                throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "SSH_FXP_EXTENDED operation is not supported in {0} version that server operates in.", ProtocolVersion));
+            }
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<SftpFileSytemInformation> tcs = new TaskCompletionSource<SftpFileSytemInformation>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<SftpFileSytemInformation>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new StatVfsRequest(ProtocolVersion, NextRequestId, path, Encoding,
+                    response => tcs.TrySetResult(response.GetReply<StatVfsReplyInfo>().Information),
+                    response => tcs.TrySetException(GetSftpException(response))));
+
+                return await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
         /// <summary>
         /// Performs fstatvfs@openssh.com extended request.
         /// </summary>
@@ -1443,15 +1751,15 @@ internal SftpFileSytemInformation RequestFStatVfs(byte[] handle, bool nullOnErro
             {
                 var request = new FStatVfsRequest(ProtocolVersion, NextRequestId, handle,
                     response =>
-                        {
-                            information = response.GetReply<StatVfsReplyInfo>().Information;
-                            wait.Set();
-                        },
+                    {
+                        information = response.GetReply<StatVfsReplyInfo>().Information;
+                        wait.Set();
+                    },
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 if (!_supportedExtensions.ContainsKey(request.Name))
                     throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "Extension method {0} currently not supported by the server.", request.Name));
@@ -1460,7 +1768,7 @@ internal SftpFileSytemInformation RequestFStatVfs(byte[] handle, bool nullOnErro
 
                 WaitOnHandle(wait, OperationTimeout);
             }
-            
+
             if (!nullOnError && exception != null)
             {
                 throw exception;
@@ -1487,10 +1795,10 @@ internal void HardLink(string oldPath, string newPath)
             {
                 var request = new HardLinkRequest(ProtocolVersion, NextRequestId, oldPath, newPath,
                     response =>
-                        {
-                            exception = GetSftpException(response);
-                            wait.Set();
-                        });
+                    {
+                        exception = GetSftpException(response);
+                        wait.Set();
+                    });
 
                 if (!_supportedExtensions.ContainsKey(request.Name))
                     throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "Extension method {0} currently not supported by the server.", request.Name));
diff --git a/src/Renci.SshNet/SftpClient.cs b/src/Renci.SshNet/SftpClient.cs
index 3c22290d0..8281edadf 100644
--- a/src/Renci.SshNet/SftpClient.cs
+++ b/src/Renci.SshNet/SftpClient.cs
@@ -10,6 +10,9 @@
 using Renci.SshNet.Abstractions;
 using Renci.SshNet.Common;
 using Renci.SshNet.Sftp;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
 
 namespace Renci.SshNet
 {
@@ -373,6 +376,35 @@ public void DeleteFile(string path)
             _sftpSession.RequestRemove(fullPath);
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously deletes remote file specified by path.
+        /// </summary>
+        /// <param name="path">File to be deleted path.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous delete operation.</returns>
+        /// <exception cref="ArgumentException"><paramref name="path"/> is <b>null</b> or contains only whitespace characters.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="SftpPathNotFoundException"><paramref name="path"/> was not found on the remote host.</exception>
+        /// <exception cref="SftpPermissionDeniedException">Permission to delete the file was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
+        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message"/> is the message from the remote host.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        public async Task DeleteFileAsync(string path, CancellationToken cancellationToken)
+        {
+            if (path.IsNullOrWhiteSpace())
+                throw new ArgumentException("path");
+            CheckDisposed();
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
+
+            var fullPath = await _sftpSession.GetCanonicalPathAsync(path, cancellationToken).ConfigureAwait(false);
+
+            await _sftpSession.RequestRemoveAsync(fullPath, cancellationToken).ConfigureAwait(false);
+        }
+#endif
+
         /// <summary>
         /// Renames remote file from old path to new path.
         /// </summary>
@@ -388,6 +420,40 @@ public void RenameFile(string oldPath, string newPath)
             RenameFile(oldPath, newPath, false);
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously renames remote file from old path to new path.
+        /// </summary>
+        /// <param name="oldPath">Path to the old file location.</param>
+        /// <param name="newPath">Path to the new file location.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous rename operation.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="oldPath"/> is <b>null</b>. <para>-or-</para> or <paramref name="newPath"/> is <b>null</b>.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="SftpPermissionDeniedException">Permission to rename the file was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
+        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message"/> is the message from the remote host.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        public async Task RenameFileAsync(string oldPath, string newPath, CancellationToken cancellationToken)
+        {
+            if (oldPath == null)
+                throw new ArgumentNullException("oldPath");
+
+            if (newPath == null)
+                throw new ArgumentNullException("newPath");
+
+            CheckDisposed();
+            cancellationToken.ThrowIfCancellationRequested();
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
+
+            var oldFullPath = await _sftpSession.GetCanonicalPathAsync(oldPath, cancellationToken).ConfigureAwait(false);
+
+            var newFullPath = await _sftpSession.GetCanonicalPathAsync(newPath, cancellationToken).ConfigureAwait(false);
+
+            await _sftpSession.RequestRenameAsync(oldFullPath, newFullPath, cancellationToken).ConfigureAwait(false);
+        }
+#endif
+
         /// <summary>
         /// Renames remote file from old path to new path.
         /// </summary>
@@ -476,6 +542,62 @@ public IEnumerable<SftpFile> ListDirectory(string path, Action<int> listCallback
             return InternalListDirectory(path, listCallback);
         }
 
+#if FEATURE_TAP
+
+        /// <summary>
+        /// Asynchronously retrieves list of files in remote directory.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>
+        /// A <see cref="Task{IEnumerable}"/> that represents the asynchronous list operation.
+        /// The task result contains an enumerable collection of <see cref="SftpFile"/> for the files in the directory specified by <paramref name="path" />.
+        /// </returns>
+        /// <exception cref="ArgumentNullException"><paramref name="path" /> is <b>null</b>.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="SftpPermissionDeniedException">Permission to list the contents of the directory was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
+        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message" /> is the message from the remote host.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        public async Task<IEnumerable<SftpFile>> ListDirectoryAsync(string path, CancellationToken cancellationToken)
+        {
+            CheckDisposed();
+
+            if (path == null)
+                throw new ArgumentNullException("path");
+
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
+
+            var fullPath = await _sftpSession.GetCanonicalPathAsync(path, cancellationToken).ConfigureAwait(false);
+
+            var handle = await _sftpSession.RequestOpenDirAsync(fullPath, cancellationToken).ConfigureAwait(false);
+
+            var basePath = (fullPath[fullPath.Length - 1] == '/') ?
+                fullPath :
+                fullPath + '/';
+
+            var result = new List<SftpFile>();
+
+            while (true)
+            {
+                var files = await _sftpSession.RequestReadDirAsync(handle, cancellationToken).ConfigureAwait(false);
+                if (files == null)
+                {
+                    break;
+                }
+
+                foreach (var file in files)
+                {
+                    result.Add(new SftpFile(_sftpSession, basePath + file.Key, file.Value));
+                }
+            }
+
+            await _sftpSession.CloseAsync(handle, cancellationToken).ConfigureAwait(false);
+            return result;
+        }
+
+#endif
+
         /// <summary>
         /// Begins an asynchronous operation of retrieving list of files in remote directory.
         /// </summary>
@@ -640,6 +762,33 @@ public void DownloadFile(string path, Stream output, Action<ulong> downloadCallb
             InternalDownloadFile(path, output, null, downloadCallback);
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously downloads remote file specified by the path into the stream.
+        /// </summary>
+        /// <param name="path">File to download.</param>
+        /// <param name="output">Stream to write the file into.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous download operation.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="output" /> is <b>null</b>.</exception>
+        /// <exception cref="ArgumentException"><paramref name="path" /> is <b>null</b> or contains only whitespace characters.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="SftpPermissionDeniedException">Permission to perform the operation was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
+        /// <exception cref="SftpPathNotFoundException"><paramref name="path"/> was not found on the remote host.</exception>/// 
+        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message" /> is the message from the remote host.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        public async Task DownloadFileAsync(string path, Stream output, CancellationToken cancellationToken)
+        {
+            CheckDisposed();
+            cancellationToken.ThrowIfCancellationRequested();
+
+            using (SftpFileStream input = await SftpFileStream.OpenAsync(_sftpSession, path, FileMode.Open, FileAccess.Read, (int)_bufferSize, cancellationToken).ConfigureAwait(false))
+            {
+                await input.CopyToAsync(output, 81920, cancellationToken).ConfigureAwait(false);
+            }
+        }
+#endif
+
         /// <summary>
         /// Begins an asynchronous file downloading into the stream.
         /// </summary>
@@ -809,6 +958,35 @@ public void UploadFile(Stream input, string path, bool canOverride, Action<ulong
             InternalUploadFile(input, path, flags, null, uploadCallback);
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously uploads stream into remote file.
+        /// </summary>
+        /// <param name="input">Data input stream.</param>
+        /// <param name="path">Remote file path.</param>
+        /// <param name="canOverride">if set to <c>true</c> then existing file will be overwritten.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous upload operation.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="input" /> is <b>null</b>.</exception>
+        /// <exception cref="ArgumentException"><paramref name="path" /> is <b>null</b> or contains only whitespace characters.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="SftpPermissionDeniedException">Permission to upload the file was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
+        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message" /> is the message from the remote host.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        /// <remarks>
+        /// Method calls made by this method to <paramref name="input" />, may under certain conditions result in exceptions thrown by the stream.
+        /// </remarks>
+        public async Task UploadFileAsync(Stream input, string path, bool canOverride, CancellationToken cancellationToken)
+        {
+            CheckDisposed();
+            cancellationToken.ThrowIfCancellationRequested();
+
+            using (SftpFileStream output = await SftpFileStream.OpenAsync(_sftpSession, path, canOverride ? FileMode.Create : FileMode.CreateNew, FileAccess.Write, (int)_bufferSize, cancellationToken).ConfigureAwait(false))
+            {
+                await input.CopyToAsync(output, (int)_sftpSession.CalculateOptimalWriteLength(_bufferSize, output.Handle), cancellationToken).ConfigureAwait(false);
+            }
+        }
+#endif
         /// <summary>
         /// Begins an asynchronous uploading the stream into remote file.
         /// </summary>
@@ -1009,6 +1187,35 @@ public SftpFileSytemInformation GetStatus(string path)
             return _sftpSession.RequestStatVfs(fullPath);
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously gets status using statvfs@openssh.com request.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>
+        /// A <see cref="Task{SftpFileSytemInformation}"/> that represents the status operation.
+        /// The task result contains the <see cref="SftpFileSytemInformation"/> instance that contains file status information.
+        /// </returns>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="path" /> is <b>null</b>.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        public async Task<SftpFileSytemInformation> GetStatusAsync(string path, CancellationToken cancellationToken)
+        {
+            if (path == null)
+                throw new ArgumentNullException("path");
+
+            CheckDisposed();
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var fullPath = await _sftpSession.GetCanonicalPathAsync(path, cancellationToken).ConfigureAwait(false);
+
+            return await _sftpSession.RequestStatVfsAsync(fullPath, cancellationToken).ConfigureAwait(false);
+        }
+#endif
+
         #region File Methods
 
         /// <summary>
@@ -1356,6 +1563,30 @@ public SftpFileStream Open(string path, FileMode mode, FileAccess access)
             return new SftpFileStream(_sftpSession, path, mode, access, (int) _bufferSize);
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously opens a <see cref="SftpFileStream"/> on the specified path, with the specified mode and access.
+        /// </summary>
+        /// <param name="path">The file to open.</param>
+        /// <param name="mode">A <see cref="FileMode"/> value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten.</param>
+        /// <param name="access">A <see cref="FileAccess"/> value that specifies the operations that can be performed on the file.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>
+        /// A <see cref="Task{SftpFileStream}"/> that represents the asynchronous open operation.
+        /// The task result contains the <see cref="SftpFileStream"/> that provides access to the specified file, with the specified mode and access.
+        /// </returns>
+        /// <exception cref="ArgumentNullException"><paramref name="path"/> is <b>null</b>.</exception>
+        /// <exception cref="SshConnectionException">Client is not connected.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        public Task<SftpFileStream> OpenAsync(string path, FileMode mode, FileAccess access, CancellationToken cancellationToken)
+        {
+            CheckDisposed();
+            cancellationToken.ThrowIfCancellationRequested();
+
+            return SftpFileStream.OpenAsync(_sftpSession, path, mode, access, (int)_bufferSize, cancellationToken);
+        }
+#endif
+
         /// <summary>
         /// Opens an existing file for reading.
         /// </summary>
@@ -2126,20 +2357,20 @@ private void InternalUploadFile(Stream input, string path, Flags flags, SftpUplo
                     var writtenBytes = offset + (ulong) bytesRead;
 
                     _sftpSession.RequestWrite(handle, offset, buffer, 0, bytesRead, null, s =>
+                    {
+                        if (s.StatusCode == StatusCodes.Ok)
                         {
-                            if (s.StatusCode == StatusCodes.Ok)
+                            Interlocked.Decrement(ref expectedResponses);
+                            responseReceivedWaitHandle.Set();
+
+                            //  Call callback to report number of bytes written
+                            if (uploadCallback != null)
                             {
-                                Interlocked.Decrement(ref expectedResponses);
-                                responseReceivedWaitHandle.Set();
-
-                                //  Call callback to report number of bytes written
-                                if (uploadCallback != null)
-                                {
-                                    //  Execute callback on different thread
-                                    ThreadAbstraction.ExecuteThread(() => uploadCallback(writtenBytes));
-                                }
+                                //  Execute callback on different thread
+                                ThreadAbstraction.ExecuteThread(() => uploadCallback(writtenBytes));
                             }
-                        });
+                        }
+                    });
                     Interlocked.Increment(ref expectedResponses);
 
                     offset += (ulong) bytesRead;

From d5c80f56d1b1e7370891f0895aab3325ce9a39a0 Mon Sep 17 00:00:00 2001
From: Igor Milavec <igor.milavec@gmail.com>
Date: Tue, 11 May 2021 12:20:00 +0200
Subject: [PATCH 03/11] Add async support to DnsAbstraction and
 SocketAbstraction

---
 .../Abstractions/DnsAbstraction.cs            |  25 +++-
 .../Abstractions/SocketAbstraction.cs         |  43 +++++--
 .../Abstractions/SocketExtensions.cs          | 119 ++++++++++++++++++
 3 files changed, 171 insertions(+), 16 deletions(-)
 create mode 100644 src/Renci.SshNet/Abstractions/SocketExtensions.cs

diff --git a/src/Renci.SshNet/Abstractions/DnsAbstraction.cs b/src/Renci.SshNet/Abstractions/DnsAbstraction.cs
index 0af35aeed..6e090b0b8 100644
--- a/src/Renci.SshNet/Abstractions/DnsAbstraction.cs
+++ b/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
+
     }
 }
diff --git a/src/Renci.SshNet/Abstractions/SocketAbstraction.cs b/src/Renci.SshNet/Abstractions/SocketAbstraction.cs
index 287caea66..5bcb690db 100644
--- a/src/Renci.SshNet/Abstractions/SocketAbstraction.cs
+++ b/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();
         }
diff --git a/src/Renci.SshNet/Abstractions/SocketExtensions.cs b/src/Renci.SshNet/Abstractions/SocketExtensions.cs
new file mode 100644
index 000000000..d763e1a34
--- /dev/null
+++ b/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
\ No newline at end of file

From d578af792ab33101f22139d06a8b9418f70d2e50 Mon Sep 17 00:00:00 2001
From: Igor Milavec <igor.milavec@gmail.com>
Date: Tue, 11 May 2021 14:24:48 +0200
Subject: [PATCH 04/11] Add async support to *Connector and refactor the
 hierarchy

---
 src/Renci.SshNet/Connection/ConnectorBase.cs  | 45 ++++++++++++
 .../Connection/DirectConnector.cs             | 10 ++-
 src/Renci.SshNet/Connection/HttpConnector.cs  | 23 +-----
 src/Renci.SshNet/Connection/IConnector.cs     |  5 ++
 src/Renci.SshNet/Connection/ProxyConnector.cs | 72 +++++++++++++++++++
 .../Connection/Socks4Connector.cs             | 22 +-----
 .../Connection/Socks5Connector.cs             | 23 +-----
 7 files changed, 139 insertions(+), 61 deletions(-)
 create mode 100644 src/Renci.SshNet/Connection/ProxyConnector.cs

diff --git a/src/Renci.SshNet/Connection/ConnectorBase.cs b/src/Renci.SshNet/Connection/ConnectorBase.cs
index 6e9bed7af..ffa026750 100644
--- a/src/Renci.SshNet/Connection/ConnectorBase.cs
+++ b/src/Renci.SshNet/Connection/ConnectorBase.cs
@@ -4,6 +4,11 @@
 using System;
 using System.Net;
 using System.Net.Sockets;
+using System.Threading;
+
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
 
 namespace Renci.SshNet.Connection
 {
@@ -21,6 +26,10 @@ protected ConnectorBase(ISocketFactory socketFactory)
 
         public abstract Socket Connect(IConnectionInfo connectionInfo);
 
+#if FEATURE_TAP
+        public abstract Task<Socket> ConnectAsync(IConnectionInfo connectionInfo, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Establishes a socket connection to the specified host and port.
         /// </summary>
@@ -54,6 +63,42 @@ protected Socket SocketConnect(string host, int port, TimeSpan timeout)
             }
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Establishes a socket connection to the specified host and port.
+        /// </summary>
+        /// <param name="host">The host name of the server to connect to.</param>
+        /// <param name="port">The port to connect to.</param>
+        /// <param name="cancellationToken">The cancellation token to observe.</param>
+        /// <exception cref="SshOperationTimeoutException">The connection failed to establish within the configured <see cref="ConnectionInfo.Timeout"/>.</exception>
+        /// <exception cref="SocketException">An error occurred trying to establish the connection.</exception>
+        protected async Task<Socket> SocketConnectAsync(string host, int port, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var ipAddress = (await DnsAbstraction.GetHostAddressesAsync(host).ConfigureAwait(false))[0];
+            var ep = new IPEndPoint(ipAddress, port);
+
+            DiagnosticAbstraction.Log(string.Format("Initiating connection to '{0}:{1}'.", host, port));
+
+            var socket = SocketFactory.Create(ep.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
+            try
+            {
+                await SocketAbstraction.ConnectAsync(socket, ep, cancellationToken).ConfigureAwait(false);
+
+                const int socketBufferSize = 2 * Session.MaximumSshPacketSize;
+                socket.SendBufferSize = socketBufferSize;
+                socket.ReceiveBufferSize = socketBufferSize;
+                return socket;
+            }
+            catch (Exception)
+            {
+                socket.Dispose();
+                throw;
+            }
+        }
+#endif
+
         protected static byte SocketReadByte(Socket socket)
         {
             var buffer = new byte[1];
diff --git a/src/Renci.SshNet/Connection/DirectConnector.cs b/src/Renci.SshNet/Connection/DirectConnector.cs
index ec8464505..0d07bb936 100644
--- a/src/Renci.SshNet/Connection/DirectConnector.cs
+++ b/src/Renci.SshNet/Connection/DirectConnector.cs
@@ -1,8 +1,9 @@
 using System.Net.Sockets;
+using System.Threading;
 
 namespace Renci.SshNet.Connection
 {
-    internal class DirectConnector : ConnectorBase
+    internal sealed class DirectConnector : ConnectorBase
     {
         public DirectConnector(ISocketFactory socketFactory) : base(socketFactory)
         {
@@ -12,5 +13,12 @@ public override Socket Connect(IConnectionInfo connectionInfo)
         {
             return SocketConnect(connectionInfo.Host, connectionInfo.Port, connectionInfo.Timeout);
         }
+
+#if FEATURE_TAP
+        public override System.Threading.Tasks.Task<Socket> ConnectAsync(IConnectionInfo connectionInfo, CancellationToken cancellationToken)
+        {
+            return SocketConnectAsync(connectionInfo.Host, connectionInfo.Port, cancellationToken);
+        }
+#endif
     }
 }
diff --git a/src/Renci.SshNet/Connection/HttpConnector.cs b/src/Renci.SshNet/Connection/HttpConnector.cs
index b77f07345..62c4ae279 100644
--- a/src/Renci.SshNet/Connection/HttpConnector.cs
+++ b/src/Renci.SshNet/Connection/HttpConnector.cs
@@ -5,6 +5,7 @@
 using System.Net;
 using System.Net.Sockets;
 using System.Text.RegularExpressions;
+using System.Threading;
 
 namespace Renci.SshNet.Connection
 {
@@ -27,31 +28,13 @@ namespace Renci.SshNet.Connection
     ///   </item>
     /// </list>
     /// </remarks>
-    internal class HttpConnector : ConnectorBase
+    internal sealed class HttpConnector : ProxyConnector
     {
         public HttpConnector(ISocketFactory socketFactory) : base(socketFactory)
         {
         }
 
-        public override Socket Connect(IConnectionInfo connectionInfo)
-        {
-            var socket = SocketConnect(connectionInfo.ProxyHost, connectionInfo.ProxyPort, connectionInfo.Timeout);
-
-            try
-            {
-                HandleProxyConnect(connectionInfo, socket);
-                return socket;
-            }
-            catch (Exception)
-            {
-                socket.Shutdown(SocketShutdown.Both);
-                socket.Dispose();
-
-                throw;
-            }
-        }
-
-        private void HandleProxyConnect(IConnectionInfo connectionInfo, Socket socket)
+        protected override void HandleProxyConnect(IConnectionInfo connectionInfo, Socket socket)
         {
             var httpResponseRe = new Regex(@"HTTP/(?<version>\d[.]\d) (?<statusCode>\d{3}) (?<reasonPhrase>.+)$");
             var httpHeaderRe = new Regex(@"(?<fieldName>[^\[\]()<>@,;:\""/?={} \t]+):(?<fieldValue>.+)?");
diff --git a/src/Renci.SshNet/Connection/IConnector.cs b/src/Renci.SshNet/Connection/IConnector.cs
index 7efc5c5fa..9eccabe62 100644
--- a/src/Renci.SshNet/Connection/IConnector.cs
+++ b/src/Renci.SshNet/Connection/IConnector.cs
@@ -1,9 +1,14 @@
 using System.Net.Sockets;
+using System.Threading;
 
 namespace Renci.SshNet.Connection
 {
     internal interface IConnector
     {
         Socket Connect(IConnectionInfo connectionInfo);
+
+#if FEATURE_TAP
+        System.Threading.Tasks.Task<Socket> ConnectAsync(IConnectionInfo connectionInfo, CancellationToken cancellationToken);
+#endif
     }
 }
diff --git a/src/Renci.SshNet/Connection/ProxyConnector.cs b/src/Renci.SshNet/Connection/ProxyConnector.cs
new file mode 100644
index 000000000..2c19eaa3d
--- /dev/null
+++ b/src/Renci.SshNet/Connection/ProxyConnector.cs
@@ -0,0 +1,72 @@
+using Renci.SshNet.Common;
+using System;
+using System.Net.Sockets;
+using System.Threading;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
+
+namespace Renci.SshNet.Connection
+{
+    internal abstract class ProxyConnector : ConnectorBase
+    {
+        public ProxyConnector(ISocketFactory socketFactory) :
+            base(socketFactory)
+        {
+        }
+
+        protected abstract void HandleProxyConnect(IConnectionInfo connectionInfo, Socket socket);
+
+#if FEATURE_TAP
+        // ToDo: Performs async/sync fallback, true async version should be implemented in derived classes
+        protected virtual Task HandleProxyConnectAsync(IConnectionInfo connectionInfo, Socket socket, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            using (cancellationToken.Register(o => ((Socket)o).Dispose(), socket, false))
+            {
+                HandleProxyConnect(connectionInfo, socket);
+            }
+            return Task.CompletedTask;
+        }
+#endif
+
+        public override Socket Connect(IConnectionInfo connectionInfo)
+        {
+            var socket = SocketConnect(connectionInfo.ProxyHost, connectionInfo.ProxyPort, connectionInfo.Timeout);
+
+            try
+            {
+                HandleProxyConnect(connectionInfo, socket);
+                return socket;
+            }
+            catch (Exception)
+            {
+                socket.Shutdown(SocketShutdown.Both);
+                socket.Dispose();
+
+                throw;
+            }
+        }
+
+#if FEATURE_TAP
+        public override async Task<Socket> ConnectAsync(IConnectionInfo connectionInfo, CancellationToken cancellationToken)
+        {
+            var socket = await SocketConnectAsync(connectionInfo.ProxyHost, connectionInfo.ProxyPort, cancellationToken).ConfigureAwait(false);
+
+            try
+            {
+                await HandleProxyConnectAsync(connectionInfo, socket, cancellationToken).ConfigureAwait(false);
+                return socket;
+            }
+            catch (Exception)
+            {
+                socket.Shutdown(SocketShutdown.Both);
+                socket.Dispose();
+
+                throw;
+            }
+        }
+#endif
+    }
+}
diff --git a/src/Renci.SshNet/Connection/Socks4Connector.cs b/src/Renci.SshNet/Connection/Socks4Connector.cs
index 9154240f8..ccf4e1456 100644
--- a/src/Renci.SshNet/Connection/Socks4Connector.cs
+++ b/src/Renci.SshNet/Connection/Socks4Connector.cs
@@ -12,36 +12,18 @@ namespace Renci.SshNet.Connection
     /// <remarks>
     /// https://www.openssh.com/txt/socks4.protocol
     /// </remarks>
-    internal class Socks4Connector : ConnectorBase
+    internal sealed class Socks4Connector : ProxyConnector
     {
         public Socks4Connector(ISocketFactory socketFactory) : base(socketFactory)
         {
         }
 
-        public override Socket Connect(IConnectionInfo connectionInfo)
-        {
-            var socket = SocketConnect(connectionInfo.ProxyHost, connectionInfo.ProxyPort, connectionInfo.Timeout);
-
-            try
-            {
-                HandleProxyConnect(connectionInfo, socket);
-                return socket;
-            }
-            catch (Exception)
-            {
-                socket.Shutdown(SocketShutdown.Both);
-                socket.Dispose();
-
-                throw;
-            }
-        }
-
         /// <summary>
         /// Establishes a connection to the server via a SOCKS5 proxy.
         /// </summary>
         /// <param name="connectionInfo">The connection information.</param>
         /// <param name="socket">The <see cref="Socket"/>.</param>
-        private void HandleProxyConnect(IConnectionInfo connectionInfo, Socket socket)
+        protected override void HandleProxyConnect(IConnectionInfo connectionInfo, Socket socket)
         {
             var connectionRequest = CreateSocks4ConnectionRequest(connectionInfo.Host, (ushort)connectionInfo.Port, connectionInfo.ProxyUsername);
             SocketAbstraction.Send(socket, connectionRequest);
diff --git a/src/Renci.SshNet/Connection/Socks5Connector.cs b/src/Renci.SshNet/Connection/Socks5Connector.cs
index 720ac5004..0ff619493 100644
--- a/src/Renci.SshNet/Connection/Socks5Connector.cs
+++ b/src/Renci.SshNet/Connection/Socks5Connector.cs
@@ -2,6 +2,7 @@
 using Renci.SshNet.Common;
 using System;
 using System.Net.Sockets;
+using System.Threading;
 
 namespace Renci.SshNet.Connection
 {
@@ -11,36 +12,18 @@ namespace Renci.SshNet.Connection
     /// <remarks>
     /// https://en.wikipedia.org/wiki/SOCKS#SOCKS5
     /// </remarks>
-    internal class Socks5Connector : ConnectorBase
+    internal sealed class Socks5Connector : ProxyConnector
     {
         public Socks5Connector(ISocketFactory socketFactory) : base(socketFactory)
         {
         }
 
-        public override Socket Connect(IConnectionInfo connectionInfo)
-        {
-            var socket = SocketConnect(connectionInfo.ProxyHost, connectionInfo.ProxyPort, connectionInfo.Timeout);
-
-            try
-            {
-                HandleProxyConnect(connectionInfo, socket);
-                return socket;
-            }
-            catch (Exception)
-            {
-                socket.Shutdown(SocketShutdown.Both);
-                socket.Dispose();
-
-                throw;
-            }
-        }
-
         /// <summary>
         /// Establishes a connection to the server via a SOCKS5 proxy.
         /// </summary>
         /// <param name="connectionInfo">The connection information.</param>
         /// <param name="socket">The <see cref="Socket"/>.</param>
-        private void HandleProxyConnect(IConnectionInfo connectionInfo, Socket socket)
+        protected override void HandleProxyConnect(IConnectionInfo connectionInfo, Socket socket)
         {
             var greeting = new byte[]
                 {

From c37a884c725cd9bfaa830d19e00418c2aaa7e128 Mon Sep 17 00:00:00 2001
From: Igor Milavec <igor.milavec@gmail.com>
Date: Tue, 11 May 2021 14:26:32 +0200
Subject: [PATCH 05/11] Add ConnectAsync to BaseClient

---
 src/Renci.SshNet/BaseClient.cs                |  80 +++++++++++
 .../Connection/IProtocolVersionExchange.cs    |   4 +
 .../Connection/ProtocolVersionExchange.cs     | 103 +++++++++++++++
 src/Renci.SshNet/ISession.cs                  |  16 +++
 src/Renci.SshNet/Session.cs                   | 125 ++++++++++++++++++
 5 files changed, 328 insertions(+)

diff --git a/src/Renci.SshNet/BaseClient.cs b/src/Renci.SshNet/BaseClient.cs
index 5b0e01c90..4e0975b09 100644
--- a/src/Renci.SshNet/BaseClient.cs
+++ b/src/Renci.SshNet/BaseClient.cs
@@ -1,6 +1,9 @@
 using System;
 using System.Net.Sockets;
 using System.Threading;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
 using Renci.SshNet.Abstractions;
 using Renci.SshNet.Common;
 using Renci.SshNet.Messages.Transport;
@@ -239,6 +242,63 @@ public void Connect()
             StartKeepAliveTimer();
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously connects client to the server.
+        /// </summary>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous connect operation.
+        /// </returns>
+        /// <exception cref="InvalidOperationException">The client is already connected.</exception>
+        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
+        /// <exception cref="SocketException">Socket connection to the SSH server or proxy server could not be established, or an error occurred while resolving the hostname.</exception>
+        /// <exception cref="SshConnectionException">SSH session could not be established.</exception>
+        /// <exception cref="SshAuthenticationException">Authentication of SSH session failed.</exception>
+        /// <exception cref="ProxyException">Failed to establish proxy connection.</exception>
+        public async Task ConnectAsync(CancellationToken cancellationToken)
+        {
+            CheckDisposed();
+            cancellationToken.ThrowIfCancellationRequested();
+
+            // TODO (see issue #1758):
+            // we're not stopping the keep-alive timer and disposing the session here
+            // 
+            // we could do this but there would still be side effects as concrete
+            // implementations may still hang on to the original session
+            // 
+            // therefore it would be better to actually invoke the Disconnect method
+            // (and then the Dispose on the session) but even that would have side effects
+            // eg. it would remove all forwarded ports from SshClient
+            // 
+            // I think we should modify our concrete clients to better deal with a
+            // disconnect. In case of SshClient this would mean not removing the 
+            // forwarded ports on disconnect (but only on dispose ?) and link a
+            // forwarded port with a client instead of with a session
+            //
+            // To be discussed with Oleg (or whoever is interested)
+            if (IsSessionConnected())
+                throw new InvalidOperationException("The client is already connected.");
+
+            OnConnecting();
+
+            Session = await CreateAndConnectSessionAsync(cancellationToken).ConfigureAwait(false);
+            try
+            {
+                // Even though the method we invoke makes you believe otherwise, at this point only
+                // the SSH session itself is connected.
+                OnConnected();
+            }
+            catch
+            {
+                // Only dispose the session as Disconnect() would have side-effects (such as remove forwarded
+                // ports in SshClient).
+                DisposeSession();
+                throw;
+            }
+            StartKeepAliveTimer();
+        }
+#endif
+
         /// <summary>
         /// Disconnects client from the server.
         /// </summary>
@@ -473,6 +533,26 @@ private ISession CreateAndConnectSession()
             }
         }
 
+#if FEATURE_TAP
+        private async Task<ISession> CreateAndConnectSessionAsync(CancellationToken cancellationToken)
+        {
+            var session = _serviceFactory.CreateSession(ConnectionInfo, _serviceFactory.CreateSocketFactory());
+            session.HostKeyReceived += Session_HostKeyReceived;
+            session.ErrorOccured += Session_ErrorOccured;
+
+            try
+            {
+                await session.ConnectAsync(cancellationToken).ConfigureAwait(false);
+                return session;
+            }
+            catch
+            {
+                DisposeSession(session);
+                throw;
+            }
+        }
+#endif
+
         private void DisposeSession(ISession session)
         {
             session.ErrorOccured -= Session_ErrorOccured;
diff --git a/src/Renci.SshNet/Connection/IProtocolVersionExchange.cs b/src/Renci.SshNet/Connection/IProtocolVersionExchange.cs
index 77bcfbd33..c804c291f 100644
--- a/src/Renci.SshNet/Connection/IProtocolVersionExchange.cs
+++ b/src/Renci.SshNet/Connection/IProtocolVersionExchange.cs
@@ -18,5 +18,9 @@ internal interface IProtocolVersionExchange
         /// The SSH identification of the server.
         /// </returns>
         SshIdentification Start(string clientVersion, Socket socket, TimeSpan timeout);
+
+#if FEATURE_TAP
+        System.Threading.Tasks.Task<SshIdentification> StartAsync(string clientVersion, Socket socket, System.Threading.CancellationToken cancellationToken);
+#endif
     }
 }
diff --git a/src/Renci.SshNet/Connection/ProtocolVersionExchange.cs b/src/Renci.SshNet/Connection/ProtocolVersionExchange.cs
index 1d529a6d1..4e6957c10 100644
--- a/src/Renci.SshNet/Connection/ProtocolVersionExchange.cs
+++ b/src/Renci.SshNet/Connection/ProtocolVersionExchange.cs
@@ -7,6 +7,10 @@
 using System.Net.Sockets;
 using System.Text;
 using System.Text.RegularExpressions;
+using System.Threading;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
 
 namespace Renci.SshNet.Connection
 {
@@ -78,6 +82,51 @@ public SshIdentification Start(string clientVersion, Socket socket, TimeSpan tim
             }
         }
 
+#if FEATURE_TAP
+        public async Task<SshIdentification> StartAsync(string clientVersion, Socket socket, CancellationToken cancellationToken)
+        {
+            // Immediately send the identification string since the spec states both sides MUST send an identification string
+            // when the connection has been established
+            SocketAbstraction.Send(socket, Encoding.UTF8.GetBytes(clientVersion + "\x0D\x0A"));
+
+            var bytesReceived = new List<byte>();
+
+            // Get server version from the server,
+            // ignore text lines which are sent before if any
+            while (true)
+            {
+                var line = await SocketReadLineAsync(socket, cancellationToken, bytesReceived).ConfigureAwait(false);
+                if (line == null)
+                {
+                    if (bytesReceived.Count == 0)
+                    {
+                        throw new SshConnectionException(string.Format("The server response does not contain an SSH identification string.{0}" +
+                                                                       "The connection to the remote server was closed before any data was received.{0}{0}" +
+                                                                       "More information on the Protocol Version Exchange is available here:{0}" +
+                                                                       "https://tools.ietf.org/html/rfc4253#section-4.2",
+                                                                       Environment.NewLine),
+                                                         DisconnectReason.ConnectionLost);
+                    }
+
+                    throw new SshConnectionException(string.Format("The server response does not contain an SSH identification string:{0}{0}{1}{0}{0}" +
+                                                                   "More information on the Protocol Version Exchange is available here:{0}" +
+                                                                   "https://tools.ietf.org/html/rfc4253#section-4.2",
+                                                                   Environment.NewLine,
+                                                                   PacketDump.Create(bytesReceived, 2)),
+                                                     DisconnectReason.ProtocolError);
+                }
+
+                var identificationMatch = ServerVersionRe.Match(line);
+                if (identificationMatch.Success)
+                {
+                    return new SshIdentification(GetGroupValue(identificationMatch, "protoversion"),
+                                                 GetGroupValue(identificationMatch, "softwareversion"),
+                                                 GetGroupValue(identificationMatch, "comments"));
+                }
+            }
+        }
+#endif
+
         private static string GetGroupValue(Match match, string groupName)
         {
             var commentsGroup = match.Groups[groupName];
@@ -153,5 +202,59 @@ private static string SocketReadLine(Socket socket, TimeSpan timeout, List<byte>
 
             return null;
         }
+
+#if FEATURE_TAP
+        private static async Task<string> SocketReadLineAsync(Socket socket, CancellationToken cancellationToken, List<byte> buffer)
+        {
+            var data = new byte[1];
+
+            var startPosition = buffer.Count;
+
+            // Read data one byte at a time to find end of line and leave any unhandled information in the buffer
+            // to be processed by subsequent invocations.
+            while (true)
+            {
+                var bytesRead = await SocketAbstraction.ReadAsync(socket, data, 0, data.Length, cancellationToken).ConfigureAwait(false);
+                if (bytesRead == 0)
+                {
+                    throw new SshConnectionException("The connection was closed by the remote host.");
+                }
+
+                var byteRead = data[0];
+                buffer.Add(byteRead);
+
+                // The null character MUST NOT be sent
+                if (byteRead == Null)
+                {
+                    throw new SshConnectionException(string.Format(CultureInfo.InvariantCulture,
+                                                                   "The server response contains a null character at position 0x{0:X8}:{1}{1}{2}{1}{1}" +
+                                                                   "A server must not send a null character before the Protocol Version Exchange is complete.{1}{1}" +
+                                                                   "More information is available here:{1}" +
+                                                                   "https://tools.ietf.org/html/rfc4253#section-4.2",
+                                                                   buffer.Count,
+                                                                   Environment.NewLine,
+                                                                   PacketDump.Create(buffer.ToArray(), 2)));
+                }
+
+                if (byteRead == Session.LineFeed)
+                {
+                    if (buffer.Count > startPosition + 1 && buffer[buffer.Count - 2] == Session.CarriageReturn)
+                    {
+                        // Return current line without CRLF
+                        return Encoding.UTF8.GetString(buffer.ToArray(), startPosition, buffer.Count - (startPosition + 2));
+                    }
+                    else
+                    {
+                        // Even though RFC4253 clearly indicates that the identification string should be terminated
+                        // by a CR LF we also support banners and identification strings that are terminated by a LF
+
+                        // Return current line without LF
+                        return Encoding.UTF8.GetString(buffer.ToArray(), startPosition, buffer.Count - (startPosition + 1));
+                    }
+                }
+            }
+        }
+#endif
+
     }
 }
diff --git a/src/Renci.SshNet/ISession.cs b/src/Renci.SshNet/ISession.cs
index cd950da52..cde647a46 100644
--- a/src/Renci.SshNet/ISession.cs
+++ b/src/Renci.SshNet/ISession.cs
@@ -6,6 +6,9 @@
 using Renci.SshNet.Messages;
 using Renci.SshNet.Messages.Authentication;
 using Renci.SshNet.Messages.Connection;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
 
 namespace Renci.SshNet
 {
@@ -54,6 +57,19 @@ internal interface ISession : IDisposable
         /// <exception cref="ProxyException">Failed to establish proxy connection.</exception>
         void Connect();
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously connects to the server.
+        /// </summary>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous connect operation.</returns>
+        /// <exception cref="SocketException">Socket connection to the SSH server or proxy server could not be established, or an error occurred while resolving the hostname.</exception>
+        /// <exception cref="SshConnectionException">SSH session could not be established.</exception>
+        /// <exception cref="SshAuthenticationException">Authentication of SSH session failed.</exception>
+        /// <exception cref="ProxyException">Failed to establish proxy connection.</exception>
+        Task ConnectAsync(CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Create a new SSH session channel.
         /// </summary>
diff --git a/src/Renci.SshNet/Session.cs b/src/Renci.SshNet/Session.cs
index 0748b8dac..94dd1e30b 100644
--- a/src/Renci.SshNet/Session.cs
+++ b/src/Renci.SshNet/Session.cs
@@ -16,6 +16,9 @@
 using System.Linq;
 using Renci.SshNet.Abstractions;
 using Renci.SshNet.Security.Cryptography;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif
 
 namespace Renci.SshNet
 {
@@ -669,6 +672,128 @@ public void Connect()
             }
         }
 
+#if FEATURE_TAP
+        /// <summary>
+        /// Asynchronously connects to the server.
+        /// </summary>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
+        /// <returns>A <see cref="Task"/> that represents the asynchronous connect operation.</returns>
+        /// <exception cref="SocketException">Socket connection to the SSH server or proxy server could not be established, or an error occurred while resolving the hostname.</exception>
+        /// <exception cref="SshConnectionException">SSH session could not be established.</exception>
+        /// <exception cref="SshAuthenticationException">Authentication of SSH session failed.</exception>
+        /// <exception cref="ProxyException">Failed to establish proxy connection.</exception>
+        public async Task ConnectAsync(CancellationToken cancellationToken)
+        {
+            if (IsConnected)
+                return;
+
+            try
+            {
+                // ToDo: Migrate to SemaphoreSlim to enable async awaiting
+                // ToDo: SHould we really limit this globally here, or leave it to the app?
+                AuthenticationConnection.Wait();
+
+                if (IsConnected)
+                    return;
+
+                //lock (this)   // ToDo: Why do we need double locking at all?
+                {
+                    // If connected don't connect again
+                    if (IsConnected)
+                        return;
+
+                    // Reset connection specific information
+                    Reset();
+
+                    // Build list of available messages while connecting
+                    _sshMessageFactory = new SshMessageFactory();
+
+                    _socket = await _serviceFactory.CreateConnector(ConnectionInfo, _socketFactory)
+                                             .ConnectAsync(ConnectionInfo, cancellationToken).ConfigureAwait(false);
+
+                    var serverIdentification = await _serviceFactory.CreateProtocolVersionExchange()
+                                                              .StartAsync(ClientVersion, _socket, cancellationToken).ConfigureAwait(false);
+
+                    // Set connection versions
+                    ServerVersion = ConnectionInfo.ServerVersion = serverIdentification.ToString();
+                    ConnectionInfo.ClientVersion = ClientVersion;
+
+                    DiagnosticAbstraction.Log(string.Format("Server version '{0}' on '{1}'.", serverIdentification.ProtocolVersion, serverIdentification.SoftwareVersion));
+
+                    if (!(serverIdentification.ProtocolVersion.Equals("2.0") || serverIdentification.ProtocolVersion.Equals("1.99")))
+                    {
+                        throw new SshConnectionException(string.Format(CultureInfo.CurrentCulture, "Server version '{0}' is not supported.", serverIdentification.ProtocolVersion),
+                                                         DisconnectReason.ProtocolVersionNotSupported);
+                    }
+
+                    // Register Transport response messages
+                    RegisterMessage("SSH_MSG_DISCONNECT");
+                    RegisterMessage("SSH_MSG_IGNORE");
+                    RegisterMessage("SSH_MSG_UNIMPLEMENTED");
+                    RegisterMessage("SSH_MSG_DEBUG");
+                    RegisterMessage("SSH_MSG_SERVICE_ACCEPT");
+                    RegisterMessage("SSH_MSG_KEXINIT");
+                    RegisterMessage("SSH_MSG_NEWKEYS");
+
+                    // Some server implementations might sent this message first, prior to establishing encryption algorithm
+                    RegisterMessage("SSH_MSG_USERAUTH_BANNER");
+
+                    // Mark the message listener threads as started
+                    _messageListenerCompleted.Reset();
+
+                    // Start incoming request listener
+                    ThreadAbstraction.ExecuteThread(() => MessageListener());
+
+                    // Wait for key exchange to be completed
+                    WaitOnHandle(_keyExchangeCompletedWaitHandle);
+
+                    // If sessionId is not set then its not connected
+                    if (SessionId == null)
+                    {
+                        Disconnect();
+                        return;
+                    }
+
+                    // Request user authorization service
+                    SendMessage(new ServiceRequestMessage(ServiceName.UserAuthentication));
+
+                    // Wait for service to be accepted
+                    WaitOnHandle(_serviceAccepted);
+
+                    if (string.IsNullOrEmpty(ConnectionInfo.Username))
+                    {
+                        throw new SshException("Username is not specified.");
+                    }
+
+                    // Some servers send a global request immediately after successful authentication
+                    // Avoid race condition by already enabling SSH_MSG_GLOBAL_REQUEST before authentication
+                    RegisterMessage("SSH_MSG_GLOBAL_REQUEST");
+
+                    ConnectionInfo.Authenticate(this, _serviceFactory);
+                    _isAuthenticated = true;
+
+                    // Register Connection messages
+                    RegisterMessage("SSH_MSG_REQUEST_SUCCESS");
+                    RegisterMessage("SSH_MSG_REQUEST_FAILURE");
+                    RegisterMessage("SSH_MSG_CHANNEL_OPEN_CONFIRMATION");
+                    RegisterMessage("SSH_MSG_CHANNEL_OPEN_FAILURE");
+                    RegisterMessage("SSH_MSG_CHANNEL_WINDOW_ADJUST");
+                    RegisterMessage("SSH_MSG_CHANNEL_EXTENDED_DATA");
+                    RegisterMessage("SSH_MSG_CHANNEL_REQUEST");
+                    RegisterMessage("SSH_MSG_CHANNEL_SUCCESS");
+                    RegisterMessage("SSH_MSG_CHANNEL_FAILURE");
+                    RegisterMessage("SSH_MSG_CHANNEL_DATA");
+                    RegisterMessage("SSH_MSG_CHANNEL_EOF");
+                    RegisterMessage("SSH_MSG_CHANNEL_CLOSE");
+                }
+            }
+            finally
+            {
+                AuthenticationConnection.Release();
+            }
+        }
+#endif
+
         /// <summary>
         /// Disconnects from the server.
         /// </summary>

From ed8e7897c6baf559bba52e4a1fa2246472915a35 Mon Sep 17 00:00:00 2001
From: Igor Milavec <igor.milavec@gmail.com>
Date: Thu, 13 May 2021 10:10:53 +0200
Subject: [PATCH 06/11] Minor improvements and optimizations

---
 src/Renci.SshNet/Sftp/SftpSession.cs |  50 ++++++------
 src/Renci.SshNet/SftpClient.cs       | 111 +++++++++++++++------------
 2 files changed, 85 insertions(+), 76 deletions(-)

diff --git a/src/Renci.SshNet/Sftp/SftpSession.cs b/src/Renci.SshNet/Sftp/SftpSession.cs
index 8b57709ac..d213b71de 100644
--- a/src/Renci.SshNet/Sftp/SftpSession.cs
+++ b/src/Renci.SshNet/Sftp/SftpSession.cs
@@ -54,7 +54,7 @@ public uint NextRequestId
         {
             get
             {
-                return (uint) Interlocked.Increment(ref _requestId);
+                return (uint)Interlocked.Increment(ref _requestId);
             }
         }
 
@@ -145,9 +145,7 @@ public async Task<string> GetCanonicalPathAsync(string path, CancellationToken c
             var fullPath = GetFullRemotePath(path);
 
             var canonizedPath = string.Empty;
-
             var realPathFiles = await RequestRealPathAsync(fullPath, true, cancellationToken).ConfigureAwait(false);
-
             if (realPathFiles != null)
             {
                 canonizedPath = realPathFiles[0].Key;
@@ -157,9 +155,9 @@ public async Task<string> GetCanonicalPathAsync(string path, CancellationToken c
                 return canonizedPath;
 
             //  Check for special cases
-            if (fullPath.EndsWith("/.", StringComparison.OrdinalIgnoreCase) ||
-                fullPath.EndsWith("/..", StringComparison.OrdinalIgnoreCase) ||
-                fullPath.Equals("/", StringComparison.OrdinalIgnoreCase) ||
+            if (fullPath.EndsWith("/.", StringComparison.Ordinal) ||
+                fullPath.EndsWith("/..", StringComparison.Ordinal) ||
+                fullPath.Equals("/", StringComparison.Ordinal) ||
                 fullPath.IndexOf('/') < 0)
                 return fullPath;
 
@@ -170,7 +168,7 @@ public async Task<string> GetCanonicalPathAsync(string path, CancellationToken c
             if (string.IsNullOrEmpty(partialFullPath))
                 partialFullPath = "/";
 
-            realPathFiles = RequestRealPath(partialFullPath, true);
+            realPathFiles = await RequestRealPathAsync(partialFullPath, true, cancellationToken).ConfigureAwait(false);
 
             if (realPathFiles != null)
             {
@@ -185,7 +183,7 @@ public async Task<string> GetCanonicalPathAsync(string path, CancellationToken c
             var slash = string.Empty;
             if (canonizedPath[canonizedPath.Length - 1] != '/')
                 slash = "/";
-            return string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}", canonizedPath, slash, pathParts[pathParts.Length - 1]);
+            return canonizedPath + slash + pathParts[pathParts.Length - 1];
         }
 #endif
 
@@ -202,11 +200,11 @@ internal string GetFullRemotePath(string path)
             {
                 if (WorkingDirectory[WorkingDirectory.Length - 1] == '/')
                 {
-                    fullPath = string.Format(CultureInfo.InvariantCulture, "{0}{1}", WorkingDirectory, path);
+                    fullPath = WorkingDirectory + path;
                 }
                 else
                 {
-                    fullPath = string.Format(CultureInfo.InvariantCulture, "{0}/{1}", WorkingDirectory, path);
+                    fullPath = WorkingDirectory + '/' + path;
                 }
             }
             return fullPath;
@@ -546,25 +544,24 @@ public void RequestClose(byte[] handle)
 #if FEATURE_TAP
         public async Task CloseAsync(byte[] handle, CancellationToken cancellationToken)
         {
-            cancellationToken.ThrowIfCancellationRequested();
-
             TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            using (cancellationToken.Register((s) => ((TaskCompletionSource<bool>)s).TrySetCanceled(), tcs, false))
-            {
-                SendRequest(new SftpCloseRequest(ProtocolVersion, NextRequestId, handle,
-                    response =>
+            SendRequest(new SftpCloseRequest(ProtocolVersion, NextRequestId, handle,
+                response =>
+                {
+                    if (response.StatusCode == StatusCodes.Ok)
                     {
-                        if (response.StatusCode == StatusCodes.Ok)
-                        {
-                            tcs.TrySetResult(true);
-                        }
-                        else
-                        {
-                            tcs.TrySetException(GetSftpException(response));
-                        }
-                    }));
+                        tcs.TrySetResult(true);
+                    }
+                    else
+                    {
+                        tcs.TrySetException(GetSftpException(response));
+                    }
+                }));
 
+            cancellationToken.ThrowIfCancellationRequested();
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<bool>)s).TrySetCanceled(), tcs, false))
+            {
                 await tcs.Task.ConfigureAwait(false);
             }
         }
@@ -1314,7 +1311,8 @@ internal async Task<KeyValuePair<string, SftpFileAttributes>[]> RequestRealPathA
             {
                 SendRequest(new SftpRealPathRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response => tcs.TrySetResult(response.Files),
-                    response => {
+                    response =>
+                    {
                         if (nullOnError)
                         {
                             tcs.TrySetResult(null);
diff --git a/src/Renci.SshNet/SftpClient.cs b/src/Renci.SshNet/SftpClient.cs
index 8281edadf..1f9d5e000 100644
--- a/src/Renci.SshNet/SftpClient.cs
+++ b/src/Renci.SshNet/SftpClient.cs
@@ -64,7 +64,7 @@ public TimeSpan OperationTimeout
                 if (timeoutInMilliseconds < -1d || timeoutInMilliseconds > int.MaxValue)
                     throw new ArgumentOutOfRangeException("value", "The timeout must represent a value between -1 and Int32.MaxValue, inclusive.");
 
-                _operationTimeout = (int) timeoutInMilliseconds;
+                _operationTimeout = (int)timeoutInMilliseconds;
             }
         }
 
@@ -141,7 +141,7 @@ public int ProtocolVersion
                 CheckDisposed();
                 if (_sftpSession == null)
                     throw new SshConnectionException("Client not connected.");
-                return (int) _sftpSession.ProtocolVersion;
+                return (int)_sftpSession.ProtocolVersion;
             }
         }
 
@@ -393,14 +393,11 @@ public async Task DeleteFileAsync(string path, CancellationToken cancellationTok
         {
             if (path.IsNullOrWhiteSpace())
                 throw new ArgumentException("path");
-            CheckDisposed();
-            cancellationToken.ThrowIfCancellationRequested();
 
-            if (_sftpSession == null)
-                throw new SshConnectionException("Client not connected.");
+            CheckDisposedOrNotConnected();
+            cancellationToken.ThrowIfCancellationRequested();
 
             var fullPath = await _sftpSession.GetCanonicalPathAsync(path, cancellationToken).ConfigureAwait(false);
-
             await _sftpSession.RequestRemoveAsync(fullPath, cancellationToken).ConfigureAwait(false);
         }
 #endif
@@ -441,15 +438,11 @@ public async Task RenameFileAsync(string oldPath, string newPath, CancellationTo
             if (newPath == null)
                 throw new ArgumentNullException("newPath");
 
-            CheckDisposed();
+            CheckDisposedOrNotConnected();
             cancellationToken.ThrowIfCancellationRequested();
-            if (_sftpSession == null)
-                throw new SshConnectionException("Client not connected.");
 
             var oldFullPath = await _sftpSession.GetCanonicalPathAsync(oldPath, cancellationToken).ConfigureAwait(false);
-
             var newFullPath = await _sftpSession.GetCanonicalPathAsync(newPath, cancellationToken).ConfigureAwait(false);
-
             await _sftpSession.RequestRenameAsync(oldFullPath, newFullPath, cancellationToken).ConfigureAwait(false);
         }
 #endif
@@ -560,39 +553,42 @@ public IEnumerable<SftpFile> ListDirectory(string path, Action<int> listCallback
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         public async Task<IEnumerable<SftpFile>> ListDirectoryAsync(string path, CancellationToken cancellationToken)
         {
-            CheckDisposed();
-
             if (path == null)
                 throw new ArgumentNullException("path");
 
-            if (_sftpSession == null)
-                throw new SshConnectionException("Client not connected.");
+            CheckDisposedOrNotConnected();
+            cancellationToken.ThrowIfCancellationRequested();
 
             var fullPath = await _sftpSession.GetCanonicalPathAsync(path, cancellationToken).ConfigureAwait(false);
 
-            var handle = await _sftpSession.RequestOpenDirAsync(fullPath, cancellationToken).ConfigureAwait(false);
-
-            var basePath = (fullPath[fullPath.Length - 1] == '/') ?
-                fullPath :
-                fullPath + '/';
-
             var result = new List<SftpFile>();
-
-            while (true)
+            var handle = await _sftpSession.RequestOpenDirAsync(fullPath, cancellationToken).ConfigureAwait(false);
+            try
             {
-                var files = await _sftpSession.RequestReadDirAsync(handle, cancellationToken).ConfigureAwait(false);
-                if (files == null)
-                {
-                    break;
-                }
+                var basePath = (fullPath[fullPath.Length - 1] == '/') ?
+                    fullPath :
+                    fullPath + '/';
 
-                foreach (var file in files)
+                while (true)
                 {
-                    result.Add(new SftpFile(_sftpSession, basePath + file.Key, file.Value));
+                    var files = await _sftpSession.RequestReadDirAsync(handle, cancellationToken).ConfigureAwait(false);
+                    if (files == null)
+                    {
+                        break;
+                    }
+
+                    foreach (var file in files)
+                    {
+                        result.Add(new SftpFile(_sftpSession, basePath + file.Key, file.Value));
+                    }
                 }
+
+            }
+            finally
+            {
+                _sftpSession.CloseAsync(handle, cancellationToken);
             }
 
-            await _sftpSession.CloseAsync(handle, cancellationToken).ConfigureAwait(false);
             return result;
         }
 
@@ -770,8 +766,7 @@ public void DownloadFile(string path, Stream output, Action<ulong> downloadCallb
         /// <param name="output">Stream to write the file into.</param>
         /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
         /// <returns>A <see cref="Task"/> that represents the asynchronous download operation.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="output" /> is <b>null</b>.</exception>
-        /// <exception cref="ArgumentException"><paramref name="path" /> is <b>null</b> or contains only whitespace characters.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="path" /> is <b>null</b> -or- <paramref name="output" /> is <b>null</b>.</exception>
         /// <exception cref="SshConnectionException">Client is not connected.</exception>
         /// <exception cref="SftpPermissionDeniedException">Permission to perform the operation was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
         /// <exception cref="SftpPathNotFoundException"><paramref name="path"/> was not found on the remote host.</exception>/// 
@@ -779,7 +774,12 @@ public void DownloadFile(string path, Stream output, Action<ulong> downloadCallb
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         public async Task DownloadFileAsync(string path, Stream output, CancellationToken cancellationToken)
         {
-            CheckDisposed();
+            if (path == null)
+                throw new ArgumentNullException("path");
+            if (output == null)
+                throw new ArgumentNullException("output");
+
+            CheckDisposedOrNotConnected();
             cancellationToken.ThrowIfCancellationRequested();
 
             using (SftpFileStream input = await SftpFileStream.OpenAsync(_sftpSession, path, FileMode.Open, FileAccess.Read, (int)_bufferSize, cancellationToken).ConfigureAwait(false))
@@ -967,8 +967,7 @@ public void UploadFile(Stream input, string path, bool canOverride, Action<ulong
         /// <param name="canOverride">if set to <c>true</c> then existing file will be overwritten.</param>
         /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
         /// <returns>A <see cref="Task"/> that represents the asynchronous upload operation.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="input" /> is <b>null</b>.</exception>
-        /// <exception cref="ArgumentException"><paramref name="path" /> is <b>null</b> or contains only whitespace characters.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="input" /> is <b>null</b> -or- <paramref name="path" /> is <b>null</b>.</exception>
         /// <exception cref="SshConnectionException">Client is not connected.</exception>
         /// <exception cref="SftpPermissionDeniedException">Permission to upload the file was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
         /// <exception cref="SshException">A SSH error where <see cref="Exception.Message" /> is the message from the remote host.</exception>
@@ -978,7 +977,12 @@ public void UploadFile(Stream input, string path, bool canOverride, Action<ulong
         /// </remarks>
         public async Task UploadFileAsync(Stream input, string path, bool canOverride, CancellationToken cancellationToken)
         {
-            CheckDisposed();
+            if (input == null)
+                throw new ArgumentNullException("input");
+            if (path == null)
+                throw new ArgumentNullException("path");
+
+            CheckDisposedOrNotConnected();
             cancellationToken.ThrowIfCancellationRequested();
 
             using (SftpFileStream output = await SftpFileStream.OpenAsync(_sftpSession, path, canOverride ? FileMode.Create : FileMode.CreateNew, FileAccess.Write, (int)_bufferSize, cancellationToken).ConfigureAwait(false))
@@ -1205,13 +1209,10 @@ public async Task<SftpFileSytemInformation> GetStatusAsync(string path, Cancella
             if (path == null)
                 throw new ArgumentNullException("path");
 
-            CheckDisposed();
-            if (_sftpSession == null)
-                throw new SshConnectionException("Client not connected.");
+            CheckDisposedOrNotConnected();
             cancellationToken.ThrowIfCancellationRequested();
 
             var fullPath = await _sftpSession.GetCanonicalPathAsync(path, cancellationToken).ConfigureAwait(false);
-
             return await _sftpSession.RequestStatVfsAsync(fullPath, cancellationToken).ConfigureAwait(false);
         }
 #endif
@@ -1348,7 +1349,7 @@ public StreamWriter AppendText(string path, Encoding encoding)
             if (encoding == null)
                 throw new ArgumentNullException("encoding");
 
-            return new StreamWriter(new SftpFileStream(_sftpSession, path, FileMode.Append, FileAccess.Write, (int) _bufferSize), encoding);
+            return new StreamWriter(new SftpFileStream(_sftpSession, path, FileMode.Append, FileAccess.Write, (int)_bufferSize), encoding);
         }
 
         /// <summary>
@@ -1369,7 +1370,7 @@ public SftpFileStream Create(string path)
         {
             CheckDisposed();
 
-            return new SftpFileStream(_sftpSession, path, FileMode.Create, FileAccess.ReadWrite, (int) _bufferSize);
+            return new SftpFileStream(_sftpSession, path, FileMode.Create, FileAccess.ReadWrite, (int)_bufferSize);
         }
 
         /// <summary>
@@ -1560,7 +1561,7 @@ public SftpFileStream Open(string path, FileMode mode, FileAccess access)
         {
             CheckDisposed();
 
-            return new SftpFileStream(_sftpSession, path, mode, access, (int) _bufferSize);
+            return new SftpFileStream(_sftpSession, path, mode, access, (int)_bufferSize);
         }
 
 #if FEATURE_TAP
@@ -1580,7 +1581,10 @@ public SftpFileStream Open(string path, FileMode mode, FileAccess access)
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         public Task<SftpFileStream> OpenAsync(string path, FileMode mode, FileAccess access, CancellationToken cancellationToken)
         {
-            CheckDisposed();
+            if (path == null)
+                throw new ArgumentNullException("path");
+
+            CheckDisposedOrNotConnected();
             cancellationToken.ThrowIfCancellationRequested();
 
             return SftpFileStream.OpenAsync(_sftpSession, path, mode, access, (int)_bufferSize, cancellationToken);
@@ -1634,7 +1638,7 @@ public SftpFileStream OpenWrite(string path)
         {
             CheckDisposed();
 
-            return new SftpFileStream(_sftpSession, path, FileMode.OpenOrCreate, FileAccess.Write, (int) _bufferSize);
+            return new SftpFileStream(_sftpSession, path, FileMode.OpenOrCreate, FileAccess.Write, (int)_bufferSize);
         }
 
         /// <summary>
@@ -2297,7 +2301,7 @@ private void InternalDownloadFile(string path, Stream output, SftpDownloadAsyncR
 
                     output.Write(data, 0, data.Length);
 
-                    totalBytesRead += (ulong) data.Length;
+                    totalBytesRead += (ulong)data.Length;
 
                     if (downloadCallback != null)
                     {
@@ -2354,7 +2358,7 @@ private void InternalUploadFile(Stream input, string path, Flags flags, SftpUplo
 
                 if (bytesRead > 0)
                 {
-                    var writtenBytes = offset + (ulong) bytesRead;
+                    var writtenBytes = offset + (ulong)bytesRead;
 
                     _sftpSession.RequestWrite(handle, offset, buffer, 0, bytesRead, null, s =>
                     {
@@ -2373,7 +2377,7 @@ private void InternalUploadFile(Stream input, string path, Flags flags, SftpUplo
                     });
                     Interlocked.Increment(ref expectedResponses);
 
-                    offset += (ulong) bytesRead;
+                    offset += (ulong)bytesRead;
 
                     bytesRead = input.Read(buffer, 0, buffer.Length);
                 }
@@ -2433,6 +2437,13 @@ protected override void Dispose(bool disposing)
             }
         }
 
+        private void CheckDisposedOrNotConnected()
+        {
+            base.CheckDisposed();
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
+        }
+
         private ISftpSession CreateAndConnectToSftpSession()
         {
             var sftpSession = ServiceFactory.CreateSftpSession(Session,

From a33cab8291d570cf2df56db3d59a0a5b9a6d7063 Mon Sep 17 00:00:00 2001
From: Igor Milavec <igor.milavec@gmail.com>
Date: Thu, 4 Nov 2021 17:09:01 +0100
Subject: [PATCH 07/11] Add append support to UploadFileAsync

---
 src/Renci.SshNet/ISftpClient.cs         |  4 ++--
 src/Renci.SshNet/Sftp/ISftpSession.cs   |  4 ++++
 src/Renci.SshNet/Sftp/SftpFileStream.cs |  4 ++--
 src/Renci.SshNet/Sftp/SftpSession.cs    | 18 ++++++++++++++++++
 src/Renci.SshNet/Sftp/UploadMode.cs     | 23 +++++++++++++++++++++++
 src/Renci.SshNet/SftpClient.cs          |  6 +++---
 6 files changed, 52 insertions(+), 7 deletions(-)
 create mode 100644 src/Renci.SshNet/Sftp/UploadMode.cs

diff --git a/src/Renci.SshNet/ISftpClient.cs b/src/Renci.SshNet/ISftpClient.cs
index a05e23d9b..72640f1ac 100644
--- a/src/Renci.SshNet/ISftpClient.cs
+++ b/src/Renci.SshNet/ISftpClient.cs
@@ -1030,7 +1030,7 @@ public interface ISftpClient
         /// </summary>
         /// <param name="input">Data input stream.</param>
         /// <param name="path">Remote file path.</param>
-        /// <param name="canOverride">if set to <c>true</c> then existing file will be overwritten.</param>
+        /// <param name="createMode">Specifies how the file should be created.</param>
         /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
         /// <returns>A <see cref="Task"/> that represents the asynchronous upload operation.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="input" /> is <b>null</b>.</exception>
@@ -1042,7 +1042,7 @@ public interface ISftpClient
         /// <remarks>
         /// Method calls made by this method to <paramref name="input" />, may under certain conditions result in exceptions thrown by the stream.
         /// </remarks>
-        Task UploadFileAsync(Stream input, string path, bool canOverride, CancellationToken cancellationToken);
+        Task UploadFileAsync(Stream input, string path, UploadMode createMode, CancellationToken cancellationToken);
 #endif
 
         /// <summary>
diff --git a/src/Renci.SshNet/Sftp/ISftpSession.cs b/src/Renci.SshNet/Sftp/ISftpSession.cs
index e246aa046..6f6e2d030 100644
--- a/src/Renci.SshNet/Sftp/ISftpSession.cs
+++ b/src/Renci.SshNet/Sftp/ISftpSession.cs
@@ -55,6 +55,10 @@ internal interface ISftpSession : ISubsystemSession
         /// </returns>
         SftpFileAttributes RequestFStat(byte[] handle, bool nullOnError);
 
+#if FEATURE_TAP
+        Task<SftpFileAttributes> RequestFStatAsync(byte[] handle, CancellationToken cancellationToken);
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_STAT request.
         /// </summary>
diff --git a/src/Renci.SshNet/Sftp/SftpFileStream.cs b/src/Renci.SshNet/Sftp/SftpFileStream.cs
index 46e87cce9..5e982a667 100644
--- a/src/Renci.SshNet/Sftp/SftpFileStream.cs
+++ b/src/Renci.SshNet/Sftp/SftpFileStream.cs
@@ -382,12 +382,12 @@ internal static async Task<SftpFileStream> OpenAsync(ISftpSession session, strin
             {
                 try
                 {
-                    var attributes = session.RequestFStat(handle, false);  // ToDo: Async
+                    var attributes = await session.RequestFStatAsync(handle, cancellationToken).ConfigureAwait(false);
                     position = attributes.Size;
                 }
                 catch
                 {
-                    session.RequestClose(handle);  // ToDo: Async
+                    session.RequestClose(handle);
                     throw;
                 }
             }
diff --git a/src/Renci.SshNet/Sftp/SftpSession.cs b/src/Renci.SshNet/Sftp/SftpSession.cs
index d213b71de..46cf3ef06 100644
--- a/src/Renci.SshNet/Sftp/SftpSession.cs
+++ b/src/Renci.SshNet/Sftp/SftpSession.cs
@@ -962,6 +962,24 @@ public SftpFileAttributes RequestFStat(byte[] handle, bool nullOnError)
             return attributes;
         }
 
+#if FEATURE_TAP
+        public async Task<SftpFileAttributes> RequestFStatAsync(byte[] handle, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<SftpFileAttributes> tcs = new TaskCompletionSource<SftpFileAttributes>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<SftpFileAttributes>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new SftpFStatRequest(ProtocolVersion, NextRequestId, handle,
+                    response => tcs.TrySetResult(response.Attributes),
+                    response => tcs.TrySetException(GetSftpException(response))));
+
+                return await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_SETSTAT request.
         /// </summary>
diff --git a/src/Renci.SshNet/Sftp/UploadMode.cs b/src/Renci.SshNet/Sftp/UploadMode.cs
new file mode 100644
index 000000000..bedaa8c86
--- /dev/null
+++ b/src/Renci.SshNet/Sftp/UploadMode.cs
@@ -0,0 +1,23 @@
+namespace Renci.SshNet.Sftp
+{
+    /// <summary>
+    /// Specifies how the uploaded file should be created.
+    /// </summary>
+    public enum UploadMode
+    {
+        /// <summary>
+        /// A new file should be created. If the file already exists, an exception is thrown.
+        /// </summary>
+        CreateNew = 1,
+
+        /// <summary>
+        /// A new file should be created. If the file already exists, it will be overwritten.
+        /// </summary>
+        Overwrite = 2,
+
+        /// <summary>
+        /// Opens the file if it exists and seeks to the end of the file, or creates a new file.
+        /// </summary>
+        Append = 6
+    }
+}
diff --git a/src/Renci.SshNet/SftpClient.cs b/src/Renci.SshNet/SftpClient.cs
index 1f9d5e000..4b821e94f 100644
--- a/src/Renci.SshNet/SftpClient.cs
+++ b/src/Renci.SshNet/SftpClient.cs
@@ -964,7 +964,7 @@ public void UploadFile(Stream input, string path, bool canOverride, Action<ulong
         /// </summary>
         /// <param name="input">Data input stream.</param>
         /// <param name="path">Remote file path.</param>
-        /// <param name="canOverride">if set to <c>true</c> then existing file will be overwritten.</param>
+        /// <param name="createMode">Specifies how the file should be created.</param>
         /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
         /// <returns>A <see cref="Task"/> that represents the asynchronous upload operation.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="input" /> is <b>null</b> -or- <paramref name="path" /> is <b>null</b>.</exception>
@@ -975,7 +975,7 @@ public void UploadFile(Stream input, string path, bool canOverride, Action<ulong
         /// <remarks>
         /// Method calls made by this method to <paramref name="input" />, may under certain conditions result in exceptions thrown by the stream.
         /// </remarks>
-        public async Task UploadFileAsync(Stream input, string path, bool canOverride, CancellationToken cancellationToken)
+        public async Task UploadFileAsync(Stream input, string path, UploadMode createMode, CancellationToken cancellationToken)
         {
             if (input == null)
                 throw new ArgumentNullException("input");
@@ -985,7 +985,7 @@ public async Task UploadFileAsync(Stream input, string path, bool canOverride, C
             CheckDisposedOrNotConnected();
             cancellationToken.ThrowIfCancellationRequested();
 
-            using (SftpFileStream output = await SftpFileStream.OpenAsync(_sftpSession, path, canOverride ? FileMode.Create : FileMode.CreateNew, FileAccess.Write, (int)_bufferSize, cancellationToken).ConfigureAwait(false))
+            using (SftpFileStream output = await SftpFileStream.OpenAsync(_sftpSession, path, (FileMode)createMode, FileAccess.Write, (int)_bufferSize, cancellationToken).ConfigureAwait(false))
             {
                 await input.CopyToAsync(output, (int)_sftpSession.CalculateOptimalWriteLength(_bufferSize, output.Handle), cancellationToken).ConfigureAwait(false);
             }

From 22357561258c971fb28b8d394342ad255a0f3870 Mon Sep 17 00:00:00 2001
From: Igor Milavec <igor.milavec@gmail.com>
Date: Fri, 12 Nov 2021 17:51:44 +0100
Subject: [PATCH 08/11] Change MessageListener to use long running thread

---
 src/Renci.SshNet/Session.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Renci.SshNet/Session.cs b/src/Renci.SshNet/Session.cs
index 94dd1e30b..abe143e39 100644
--- a/src/Renci.SshNet/Session.cs
+++ b/src/Renci.SshNet/Session.cs
@@ -742,7 +742,8 @@ public async Task ConnectAsync(CancellationToken cancellationToken)
                     _messageListenerCompleted.Reset();
 
                     // Start incoming request listener
-                    ThreadAbstraction.ExecuteThread(() => MessageListener());
+                    // ToDo: Make message pump async, to not consume a thread for every session
+                    ThreadAbstraction.ExecuteThreadLongRunning(() => MessageListener());
 
                     // Wait for key exchange to be completed
                     WaitOnHandle(_keyExchangeCompletedWaitHandle);

From 6fb5be2d6d0b9c8d7a073115a4d601fef33f0d75 Mon Sep 17 00:00:00 2001
From: Igor Milavec <igor.milavec@gmail.com>
Date: Sun, 21 Nov 2021 19:17:25 +0100
Subject: [PATCH 09/11] Code cleanup as requested by review

---
 .vs/ProjectSettings.json                      |   3 +
 .vs/VSWorkspaceState.json                     |  10 +
 .vs/slnx.sqlite                               | Bin 0 -> 90112 bytes
 src/Renci.SshNet/Connection/ProxyConnector.cs |   6 +-
 .../Connection/Socks5Connector.cs             |   1 -
 src/Renci.SshNet/ISftpClient.cs               |   2 +-
 src/Renci.SshNet/Sftp/ISftpSession.cs         |   4 +-
 src/Renci.SshNet/Sftp/SftpFileStream.cs       | 173 +++++----
 src/Renci.SshNet/Sftp/SftpSession.cs          | 332 +++++++++---------
 src/Renci.SshNet/SftpClient.cs                |  78 ++--
 10 files changed, 313 insertions(+), 296 deletions(-)
 create mode 100644 .vs/ProjectSettings.json
 create mode 100644 .vs/VSWorkspaceState.json
 create mode 100644 .vs/slnx.sqlite

diff --git a/.vs/ProjectSettings.json b/.vs/ProjectSettings.json
new file mode 100644
index 000000000..f8b488856
--- /dev/null
+++ b/.vs/ProjectSettings.json
@@ -0,0 +1,3 @@
+{
+  "CurrentProjectSetting": null
+}
\ No newline at end of file
diff --git a/.vs/VSWorkspaceState.json b/.vs/VSWorkspaceState.json
new file mode 100644
index 000000000..5bfd8bcbe
--- /dev/null
+++ b/.vs/VSWorkspaceState.json
@@ -0,0 +1,10 @@
+{
+  "ExpandedNodes": [
+    "",
+    "\\src",
+    "\\src\\Renci.SshNet",
+    "\\src\\Renci.SshNet\\Sftp"
+  ],
+  "SelectedNode": "\\src\\Renci.SshNet.VS2019.sln",
+  "PreviewInSolutionExplorer": false
+}
\ No newline at end of file
diff --git a/.vs/slnx.sqlite b/.vs/slnx.sqlite
new file mode 100644
index 0000000000000000000000000000000000000000..70b0a3daa4edf46e514b0bc0eb2e15f4f7988928
GIT binary patch
literal 90112
zcmeI4&u<&Y6~{?Y*2<J<IzJp9bja2SV6m3u*sjwwL4Z=rmCcx@DE^QmC<L*h#_~4g
z(&jF03v~{(8v}^}13~|S-f|22M-)Bw)KjiK^wvXx0zodF+1=S6vrAEtQyEdeL?n?r
z@6EjTnfKn#%+jfEly!^9clv{#X319*XA{X};<vJ#NF-A9=PmlfUvJPi)BFSdn+&`k
z_coPS`IUT%31@#`GOuTUnEz(}?A*=ti__0%zmrlk8>z3SzMra1eLSuUT>se+m}QoZ
z-Z>-XZZ9WC8@jPe9@Y1IJN<5v+|do)()&i+d28&g>0MIVZI|MNvPw-YG*r1%DXO2y
z+lT6-l}XF=wO)zJx8%j`@UX4?=v+q1Db&pC@n%-E9*H;Z%mm|n%?Tzk!IrG7m&?r8
z%DPghtNAZJnwN6R%gL{nEp4YuMAya78P}LbVYRHrc%DfwI$R<UOS>(~x1nBFYjU+#
zx>cxc$v4$4xzKE^mnyW|TWY02t)f58a(T(^r8?+8(09oosLf>@5jF`mbxp0Q6-BMf
z+gw96EZy2~EqWJd7kOWW&ReruWFRO8rBGBuO+~e=`c2#z2ViBhP*ZLcYKvE{UCVn0
z3tYL%+OXT*-xz9L{f<s{<2ne>2iLnvqr~UMJ?5>2PKTJLzN2@Uiyl@{Oo+jVobPfF
zAWM|`zG;!3hfuu4P|CjcQCODy9gXE@t^aVm16)YycZWSADwj#;N0;WLT$|=q+s-T7
z(vD^rWT0rByQCd8-N`aha6X)6V)NL30y!t@(AbNP-pW61rtOS-*0M8B)Dl0>g)>fU
zrsMOB6PtoLbBK&{Cp6CHNaTbv&K`Giz`R_%@U#v(#p69>4Hxu+mtTnFe|(ZR_V3Xu
z$tx8ff@fYs?-A3|diPo~D;|x~Em}!wy<(BLd|Jv~$|s*>?MURqvi{oa7r)>bmUgGL
zSt)Hay*m$=@stAL#oJuR=skvCaZDBpiPySG1}06kNacT$n3Zz*eDdjsb{z7~obJP)
zPKRSK+!%;J-VmImLqwhv8J@w8JARpccVd<0<9e<hMww072a=Rim-&>5f!wZY17cWh
zR<^~q+1U9LrGh;KrcxAR3x>G6^Af$C*(QhzES5*BGg9s|TKV?<$`{B&cj%~Qp#BBK
zCD$K!2_&jb=xu^;2RL!=RB%}o8J1CrH+W`(!M^4M<Kn>QpWc{uinQVv=>RR!&Qsw8
z5t{=kA~qc@RUDiBC_ltXWb7RHwa%_%Y(2$ZM_3ZPT!k;0j7>{kEk&1sWzDqKcT6&P
zK<Ki_ue|PRQ7)=$g=V=ScZLHyV=Z2$X_EI-Qtt9Xa`d*HCUs(2y0K^Hw7cGRu1tsH
zDJo}&k-gk^6vicOzB)CNyLd6VWk-&ApRUnJ+a&jg#GtFT@W)grZiL1~g9iT+)y$8s
zC#BrNLh=c*`*dw{|4fDY*mkc5Le9N%Y>~F9b%%5wh3IV3z1nN(4E>!-|2>iYXZA1j
z4_+Vu0w4eaAOHd&00JQJ^CR$OFLf%R{P6-khWH)nSW4fxqwfs|_W5R=?pgE>`90ek
zop%LRhkAE6BxRoeK;Cw?Pqrl6fSteRbVr-cn}g1$pVsIGLSLzycPqqN*{olA_wtn$
zvum7p&!&8hhBnwE7S%K8>9gO;wiB$gBH0=4JuVpgvQllHcSil(75g!xUwfsa|N51V
z{+m}ddV?N6nnEnt*H$_v3z(xv!;ypGHr-hFADY#>eS^F&m=<a~E)y-v=s-K-Acigd
z36MT||Ggt6mtgr%IIS$zTXv$KuUp!{8s2jY5<7UYOOV^DIL9bqA-A4n(x3lgYC563
zW|tAC)R;|rG~*sKm^aD(cI&O=bmBs;PM^T^H1|~Y^2*hfYi$3Y%>Fw;|HBIeKmY_l
z00ck)1V8`;KmY_l00cnb<PexkrWTU!;Xo=){YquOO=SO;{Wklrlj9^j0Ra#I0T2KI
z5C8!X009sH0T2LzpD}^AQ%chPjzH-9O76FsQmp-e?*UAmO<g!0`Vs(p{!jnWKVBdJ
z0w4eaAOHd&00JNY0w4eaAOHd<m;ihJkNy7%o?y5J0w4eaAOHd&00JNY0w4eaAOHfC
z0QUa~0}ucK5C8!X009sH0T2KI5C8!XIQayy|3CS23=cs71V8`;KmY_l00ck)1V8`;
zKmh;#A29#|AOHd&00JNY0w4eaAOHd&00JkU0G|J!{5gh)AOHd&00JNY0w4eaAOHd&
z00JO@=l_TS5C8!X009sH0T2KI5C8!X009s<`2_I%|K!gxJOlv{009sH0T2KI5C8!X
z009sH0X+Xl41fR#fB*=900@8p2!H?xfB*=9z{w|o=l>^vj^QB)fB*=900@8p2!H?x
zfB*=900?0Jj~D;}5C8!X009sH0T2KI5C8!X0D+TF0N?*V`Ev{pK>!3m00ck)1V8`;
zKmY_l00cmQ?f=tKDv^Ef%s<YU^WV&$ox7QSar*h}cT#F*BlY#v_fxg0kHHB94o_hE
z&$-*n$<c;x?2<?I{oYQ$TO@aML$~z4(RSV%duw`^ly=*tIH9akQwt4ME>()^C-U~8
z`e<d+GJUOAqVg?yaXUP0D?d7yk#Y((^Lo6Q6|G0&jXN{JIA3#uNldUME9>Pl^R=?B
z6zXdJi;w1|-12hrt7S{u=@QX(@pHyCrcqcet1+Hu(u)q42*lEEi}G!#*VUR_t(9&S
zYFqM6bxSTZ8|$SC?e>;hX;7=^PqSQJa(k%``VaJ7G6-sO8ApUoLQP#$YidPN>+&|&
zPz_7B_FIeI1=>a4SE2LPtQHvvia{w9)lgGWEvtSLH^u>2*(}tQ8-?29m221Xp1}fF
zuCg}lcK0`iT35fLlij!u!t=rPZqg|6d2x?<YoXI2rm64fUFM>PRTL9qFe2x>90bS`
zrM_=kq~{?NFENy|uYDAj<$gzF`C02f9Pa=ZQu^It&xp!p()rP)IVsnsdDXV_%C@wl
z83q|BTIVilM@@IKOcb0CXPMYMwx2-Gi8?g)qNBI+Pn&5w<DRwbj1#rQ&vW676PxMy
zJmbWsV9p#O<J<|2vpEtup^US~og6SP7cV@mgHG{y4_U(nz2M~+BKaSm<c<A%v`X?y
z#fRXT*U)>!w6xy6mduJrqjZZ_Qd+NABrczpa+mVSCs{iZ`LL|NHv7ddIEJO&X>C?Y
z8%^)d!(}|BKzQ*s*D-pJ;a41!g+k)BZjymX6D?BtpCo3bTt1(C`k@_%yfdf!@Tb$^
z7z{TCB9J!(C+QH8=R}5Qu;Y$jX5XDyW%;<CtA|l$Q}%%*<<w<9Wnv(=tJ;7VR-2V=
zv28YX{zR!@4}qx^#n^%&?(V!qZ)dg%q5_NM(dvwp`;1n;eZTSrvd|qmsu`$%0ddLo
z$6W%6Y7=^!;M)OCoI4d<7Da|-RN@VunP9N5Il;I%@cE}Vrkx_K_(eKEOSJP;I6=hb
zK#GV>M@tpQW<Sagu@V_O2Y#)y>lj;4vDXon1TR<NOD1E}l2=R7Wnft|t@Ry~3?2}=
zEb=R_yIPcs>RO>$ZpfYCz|L5UmuZ^h{gjluypSBdZKp|{Se9<=**Wd5x1B4~;dqM5
z*<oZa_Z@|CNt>@u&Ezg#Om5kcW8SB0G}1Q7{UI^vsxAC66^a|7anYc`zeF|jqw7g2
zx3G|WLhL?W+uT1>p+2_VtAUVnuN+&XZED>iokt-$otvb+|4+O~WGnM8=KeFcK6_bu
zJoDG-a_Ud?;<3M;oqba}x4b<2{PqK#JY;M2s%G7_?|?cn#m_G1&60Xs7TaXa%%pFZ
z8aHU(D9u{Ew5djA3Uzm>#`3F9w-`!8j@ARYP?uLVGqeUT?JmjV5}3&=PTV^p&K;bo
zurd*9w(iPnwe?$(QT@!N>yh<}|IxA1|I93}uEdxZ7FnyW{CIOCUD)P7ek@=3^ny(P
zR98GVsUJbFt-HRi<DW2<OuFjJlqwav3;mexJ0m2R<XW9>>wRhJOw25O6tssG9gdxr
zoJ^X}ZhhsKOM=~|7Z{oJLB<}&NNVah+oE$s1M~*nCdUVhT&mj(+0o(~Qf@n+9Bm1!
zilSy|V|PJ5A13xzxRiz)$Mz9>n`YgyLhJXzF}L!6c=Woxfc^5KaF1q6z5@GnE?gtS
zje$}bZa7-S^!xBk^>4B64a*O%Biv?Ra_7w#%R%q>HYaq~=YozK2c4uGw3G601C!VB
zM_AUlH=Bm~N%-KXp$+zk6?YdJb5f)94U0TFj0W2{TzQS2I$RB%I@rs@8o5JgG3b!C
z_m0H_KX~+G!)tzXT(Wo)@m<BHi>E_p%X{w_KsO9m&Q3DANbV71S2L^$M!zxH=-93%
z8ZBtG^3N8sQts;2<nzF3NtkpD)3f8!-D47)^ImH-aSySJ<>x0nZQ}APKJU54<V5??
zN0uVbpSBYD?i}R^(8KKpsBhb=-H3$jVhh5S?3I@>#p8ciZM>7G@VS(G=Jd`P2@gL?
z?3qrWw1^Ka#_rVc@B<G&j&#!Tl1niDT;u=m;RpWx|FIu(U_cN60T2KI5C8!X009sH
z0T2KI5IA-M*#93patsIpAOHd&00JNY0w4eaAOHd&00PHO0RR8LV@HkwK>!3m00ck)
w1V8`;KmY_l00cnb*a_hI|FI*-fFJ+@AOHd&00JNY0w4eaAOHd&aO?#B3ytgc#{d8T

literal 0
HcmV?d00001

diff --git a/src/Renci.SshNet/Connection/ProxyConnector.cs b/src/Renci.SshNet/Connection/ProxyConnector.cs
index 2c19eaa3d..6cc2ac9d4 100644
--- a/src/Renci.SshNet/Connection/ProxyConnector.cs
+++ b/src/Renci.SshNet/Connection/ProxyConnector.cs
@@ -1,8 +1,10 @@
-using Renci.SshNet.Common;
+#if !FEATURE_SOCKET_DISPOSE
+using Renci.SshNet.Common;
+#endif
 using System;
 using System.Net.Sockets;
-using System.Threading;
 #if FEATURE_TAP
+using System.Threading;
 using System.Threading.Tasks;
 #endif
 
diff --git a/src/Renci.SshNet/Connection/Socks5Connector.cs b/src/Renci.SshNet/Connection/Socks5Connector.cs
index 0ff619493..e1b6859dc 100644
--- a/src/Renci.SshNet/Connection/Socks5Connector.cs
+++ b/src/Renci.SshNet/Connection/Socks5Connector.cs
@@ -2,7 +2,6 @@
 using Renci.SshNet.Common;
 using System;
 using System.Net.Sockets;
-using System.Threading;
 
 namespace Renci.SshNet.Connection
 {
diff --git a/src/Renci.SshNet/ISftpClient.cs b/src/Renci.SshNet/ISftpClient.cs
index 72640f1ac..dc3df9ba9 100644
--- a/src/Renci.SshNet/ISftpClient.cs
+++ b/src/Renci.SshNet/ISftpClient.cs
@@ -2,10 +2,10 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using System.Threading;
 using Renci.SshNet.Sftp;
 using Renci.SshNet.Common;
 #if FEATURE_TAP
+using System.Threading;
 using System.Threading.Tasks;
 #endif
 
diff --git a/src/Renci.SshNet/Sftp/ISftpSession.cs b/src/Renci.SshNet/Sftp/ISftpSession.cs
index 6f6e2d030..63696493a 100644
--- a/src/Renci.SshNet/Sftp/ISftpSession.cs
+++ b/src/Renci.SshNet/Sftp/ISftpSession.cs
@@ -136,7 +136,7 @@ internal interface ISftpSession : ISubsystemSession
         byte[] RequestOpen(string path, Flags flags, bool nullOnError = false);
 
 #if FEATURE_TAP
-        Task<byte[]> OpenAsync(string path, Flags flags, CancellationToken cancellationToken);
+        Task<byte[]> RequestOpenAsync(string path, Flags flags, CancellationToken cancellationToken);
 #endif
 
         /// <summary>
@@ -345,7 +345,7 @@ void RequestWrite(byte[] handle,
         void RequestClose(byte[] handle);
 
 #if FEATURE_TAP
-        Task CloseAsync(byte[] handle, CancellationToken cancellationToken);
+        Task RequestCloseAsync(byte[] handle, CancellationToken cancellationToken);
 #endif
 
         /// <summary>
diff --git a/src/Renci.SshNet/Sftp/SftpFileStream.cs b/src/Renci.SshNet/Sftp/SftpFileStream.cs
index 5e982a667..babceb226 100644
--- a/src/Renci.SshNet/Sftp/SftpFileStream.cs
+++ b/src/Renci.SshNet/Sftp/SftpFileStream.cs
@@ -12,6 +12,7 @@ namespace Renci.SshNet.Sftp
     /// <summary>
     /// Exposes a <see cref="Stream"/> around a remote SFTP file, supporting both synchronous and asynchronous read and write operations.
     /// </summary>
+    /// <threadsafety static="true" instance="false"/>
     public class SftpFileStream : Stream
     {
         //  TODO:   Add security method to set userid, groupid and other permission settings
@@ -198,7 +199,7 @@ internal SftpFileStream(ISftpSession session, string path, FileMode mode, FileAc
             if (path == null)
                 throw new ArgumentNullException("path");
             if (bufferSize <= 0)
-                throw new ArgumentOutOfRangeException("bufferSize");
+                throw new ArgumentOutOfRangeException("bufferSize", "Cannot be less than or equal to zero.");
 
             Timeout = TimeSpan.FromSeconds(30);
             Name = path;
@@ -282,8 +283,8 @@ internal SftpFileStream(ISftpSession session, string path, FileMode mode, FileAc
             // that ensures we always receive or send the max. number of bytes in a single SSH_FXP_READ
             // or SSH_FXP_WRITE message
 
-            _readBufferSize = (int) session.CalculateOptimalReadLength((uint) bufferSize);
-            _writeBufferSize = (int) session.CalculateOptimalWriteLength((uint) bufferSize, _handle);
+            _readBufferSize = (int)session.CalculateOptimalReadLength((uint)bufferSize);
+            _writeBufferSize = (int)session.CalculateOptimalWriteLength((uint)bufferSize, _handle);
 
             if (mode == FileMode.Append)
             {
@@ -300,7 +301,7 @@ internal static async Task<SftpFileStream> OpenAsync(ISftpSession session, strin
             if (path == null)
                 throw new ArgumentNullException("path");
             if (bufferSize <= 0)
-                throw new ArgumentOutOfRangeException("bufferSize");
+                throw new ArgumentOutOfRangeException("bufferSize", "Cannot be less than or equal to zero.");
 
             var flags = Flags.None;
 
@@ -347,7 +348,7 @@ internal static async Task<SftpFileStream> OpenAsync(ISftpSession session, strin
                 case FileMode.Create:
                     try
                     {
-                        handle = await session.OpenAsync(path, flags | Flags.Truncate, cancellationToken).ConfigureAwait(false);
+                        handle = await session.RequestOpenAsync(path, flags | Flags.Truncate, cancellationToken).ConfigureAwait(false);
                         flags |= Flags.Truncate;
                     }
                     catch (TaskCanceledException)// ToDo: when (cancellationToken.IsCancellationRequested)
@@ -375,7 +376,7 @@ internal static async Task<SftpFileStream> OpenAsync(ISftpSession session, strin
             }
 
             if (handle == null)
-                handle = await session.OpenAsync(path, flags, cancellationToken).ConfigureAwait(false);
+                handle = await session.RequestOpenAsync(path, flags, cancellationToken).ConfigureAwait(false);
 
             long position = 0;
             if (mode == FileMode.Append)
@@ -615,93 +616,89 @@ public override async Task<int> ReadAsync(byte[] buffer, int offset, int count,
             if ((buffer.Length - offset) < count)
                 throw new ArgumentException("Invalid array range.");
 
-            // Lock down the file stream while we do this.
-            //lock (_lock)  Do we need to be thread safe?
-            {
-                CheckSessionIsOpen();
+            CheckSessionIsOpen();
 
-                // Set up for the read operation.
-                SetupRead();
+            // Set up for the read operation.
+            SetupRead();
 
-                // Read data into the caller's buffer.
-                while (count > 0)
+            // Read data into the caller's buffer.
+            while (count > 0)
+            {
+                // How much data do we have available in the buffer?
+                var bytesAvailableInBuffer = _bufferLen - _bufferPosition;
+                if (bytesAvailableInBuffer <= 0)
                 {
-                    // How much data do we have available in the buffer?
-                    var bytesAvailableInBuffer = _bufferLen - _bufferPosition;
-                    if (bytesAvailableInBuffer <= 0)
-                    {
-                        var data = await _session.ReadAsync(_handle, (ulong)_position, (uint)_readBufferSize, cancellationToken).ConfigureAwait(false);
-
-                        if (data.Length == 0)
-                        {
-                            _bufferPosition = 0;
-                            _bufferLen = 0;
-
-                            break;
-                        }
-
-                        var bytesToWriteToCallerBuffer = count;
-                        if (bytesToWriteToCallerBuffer >= data.Length)
-                        {
-                            // write all data read to caller-provided buffer
-                            bytesToWriteToCallerBuffer = data.Length;
-                            // reset buffer since we will skip buffering
-                            _bufferPosition = 0;
-                            _bufferLen = 0;
-                        }
-                        else
-                        {
-                            // determine number of bytes that we should write into read buffer
-                            var bytesToWriteToReadBuffer = data.Length - bytesToWriteToCallerBuffer;
-                            // write remaining bytes to read buffer
-                            Buffer.BlockCopy(data, count, GetOrCreateReadBuffer(), 0, bytesToWriteToReadBuffer);
-                            // update position in read buffer
-                            _bufferPosition = 0;
-                            // update number of bytes in read buffer
-                            _bufferLen = bytesToWriteToReadBuffer;
-                        }
+                    var data = await _session.ReadAsync(_handle, (ulong)_position, (uint)_readBufferSize, cancellationToken).ConfigureAwait(false);
 
-                        // write bytes to caller-provided buffer
-                        Buffer.BlockCopy(data, 0, buffer, offset, bytesToWriteToCallerBuffer);
-                        // update stream position
-                        _position += bytesToWriteToCallerBuffer;
-                        // record total number of bytes read into caller-provided buffer
-                        readLen += bytesToWriteToCallerBuffer;
+                    if (data.Length == 0)
+                    {
+                        _bufferPosition = 0;
+                        _bufferLen = 0;
 
-                        // break out of the read loop when the server returned less than the request number of bytes
-                        // as that *may* indicate that we've reached EOF
-                        //
-                        // doing this avoids reading from server twice to determine EOF: once in the read loop, and
-                        // once upon the next Read or ReadByte invocation by the caller
-                        if (data.Length < _readBufferSize)
-                        {
-                            break;
-                        }
+                        break;
+                    }
 
-                        // advance offset to start writing bytes into caller-provided buffer
-                        offset += bytesToWriteToCallerBuffer;
-                        // update number of bytes left to read into caller-provided buffer
-                        count -= bytesToWriteToCallerBuffer;
+                    var bytesToWriteToCallerBuffer = count;
+                    if (bytesToWriteToCallerBuffer >= data.Length)
+                    {
+                        // write all data read to caller-provided buffer
+                        bytesToWriteToCallerBuffer = data.Length;
+                        // reset buffer since we will skip buffering
+                        _bufferPosition = 0;
+                        _bufferLen = 0;
                     }
                     else
                     {
-                        // limit the number of bytes to use from read buffer to the caller-request number of bytes
-                        if (bytesAvailableInBuffer > count)
-                            bytesAvailableInBuffer = count;
-
-                        // copy data from read buffer to the caller-provided buffer
-                        Buffer.BlockCopy(GetOrCreateReadBuffer(), _bufferPosition, buffer, offset, bytesAvailableInBuffer);
+                        // determine number of bytes that we should write into read buffer
+                        var bytesToWriteToReadBuffer = data.Length - bytesToWriteToCallerBuffer;
+                        // write remaining bytes to read buffer
+                        Buffer.BlockCopy(data, count, GetOrCreateReadBuffer(), 0, bytesToWriteToReadBuffer);
                         // update position in read buffer
-                        _bufferPosition += bytesAvailableInBuffer;
-                        // update stream position
-                        _position += bytesAvailableInBuffer;
-                        // record total number of bytes read into caller-provided buffer
-                        readLen += bytesAvailableInBuffer;
-                        // advance offset to start writing bytes into caller-provided buffer
-                        offset += bytesAvailableInBuffer;
-                        // update number of bytes left to read
-                        count -= bytesAvailableInBuffer;
+                        _bufferPosition = 0;
+                        // update number of bytes in read buffer
+                        _bufferLen = bytesToWriteToReadBuffer;
                     }
+
+                    // write bytes to caller-provided buffer
+                    Buffer.BlockCopy(data, 0, buffer, offset, bytesToWriteToCallerBuffer);
+                    // update stream position
+                    _position += bytesToWriteToCallerBuffer;
+                    // record total number of bytes read into caller-provided buffer
+                    readLen += bytesToWriteToCallerBuffer;
+
+                    // break out of the read loop when the server returned less than the request number of bytes
+                    // as that *may* indicate that we've reached EOF
+                    //
+                    // doing this avoids reading from server twice to determine EOF: once in the read loop, and
+                    // once upon the next Read or ReadByte invocation by the caller
+                    if (data.Length < _readBufferSize)
+                    {
+                        break;
+                    }
+
+                    // advance offset to start writing bytes into caller-provided buffer
+                    offset += bytesToWriteToCallerBuffer;
+                    // update number of bytes left to read into caller-provided buffer
+                    count -= bytesToWriteToCallerBuffer;
+                }
+                else
+                {
+                    // limit the number of bytes to use from read buffer to the caller-request number of bytes
+                    if (bytesAvailableInBuffer > count)
+                        bytesAvailableInBuffer = count;
+
+                    // copy data from read buffer to the caller-provided buffer
+                    Buffer.BlockCopy(GetOrCreateReadBuffer(), _bufferPosition, buffer, offset, bytesAvailableInBuffer);
+                    // update position in read buffer
+                    _bufferPosition += bytesAvailableInBuffer;
+                    // update stream position
+                    _position += bytesAvailableInBuffer;
+                    // record total number of bytes read into caller-provided buffer
+                    readLen += bytesAvailableInBuffer;
+                    // advance offset to start writing bytes into caller-provided buffer
+                    offset += bytesAvailableInBuffer;
+                    // update number of bytes left to read
+                    count -= bytesAvailableInBuffer;
                 }
             }
 
@@ -734,7 +731,7 @@ public override int ReadByte()
                 // Read more data into the internal buffer if necessary.
                 if (_bufferPosition >= _bufferLen)
                 {
-                    var data = _session.RequestRead(_handle, (ulong) _position, (uint) _readBufferSize);
+                    var data = _session.RequestRead(_handle, (ulong)_position, (uint)_readBufferSize);
                     if (data.Length == 0)
                     {
                         // We've reached EOF.
@@ -837,7 +834,7 @@ public override long Seek(long offset, SeekOrigin origin)
                         if (newPosn >= (_position - _bufferPosition) &&
                            newPosn < (_position - _bufferPosition + _bufferLen))
                         {
-                            _bufferPosition = (int) (newPosn - (_position - _bufferPosition));
+                            _bufferPosition = (int)(newPosn - (_position - _bufferPosition));
                             _position = newPosn;
                             return _position;
                         }
@@ -982,7 +979,7 @@ public override void Write(byte[] buffer, int offset, int count)
                     {
                         using (var wait = new AutoResetEvent(false))
                         {
-                            _session.RequestWrite(_handle, (ulong) _position, buffer, offset, tempLen, wait);
+                            _session.RequestWrite(_handle, (ulong)_position, buffer, offset, tempLen, wait);
                         }
                     }
                     else
@@ -1004,7 +1001,7 @@ public override void Write(byte[] buffer, int offset, int count)
                 {
                     using (var wait = new AutoResetEvent(false))
                     {
-                        _session.RequestWrite(_handle, (ulong) (_position - _bufferPosition), GetOrCreateWriteBuffer(), 0, _bufferPosition, wait);
+                        _session.RequestWrite(_handle, (ulong)(_position - _bufferPosition), GetOrCreateWriteBuffer(), 0, _bufferPosition, wait);
                     }
 
                     _bufferPosition = 0;
@@ -1114,7 +1111,7 @@ public override void WriteByte(byte value)
                 {
                     using (var wait = new AutoResetEvent(false))
                     {
-                        _session.RequestWrite(_handle, (ulong) (_position - _bufferPosition), writeBuffer, 0, _bufferPosition, wait);
+                        _session.RequestWrite(_handle, (ulong)(_position - _bufferPosition), writeBuffer, 0, _bufferPosition, wait);
                     }
 
                     _bufferPosition = 0;
@@ -1200,7 +1197,7 @@ private void FlushWriteBuffer()
             {
                 using (var wait = new AutoResetEvent(false))
                 {
-                    _session.RequestWrite(_handle, (ulong) (_position - _bufferPosition), _writeBuffer, 0, _bufferPosition, wait);
+                    _session.RequestWrite(_handle, (ulong)(_position - _bufferPosition), _writeBuffer, 0, _bufferPosition, wait);
                 }
 
                 _bufferPosition = 0;
diff --git a/src/Renci.SshNet/Sftp/SftpSession.cs b/src/Renci.SshNet/Sftp/SftpSession.cs
index 46cf3ef06..b0f7ea9e2 100644
--- a/src/Renci.SshNet/Sftp/SftpSession.cs
+++ b/src/Renci.SshNet/Sftp/SftpSession.cs
@@ -54,7 +54,7 @@ public uint NextRequestId
         {
             get
             {
-                return (uint)Interlocked.Increment(ref _requestId);
+                return (uint) Interlocked.Increment(ref _requestId);
             }
         }
 
@@ -413,15 +413,15 @@ public byte[] RequestOpen(string path, Flags flags, bool nullOnError = false)
             {
                 var request = new SftpOpenRequest(ProtocolVersion, NextRequestId, path, Encoding, flags,
                     response =>
-                    {
-                        handle = response.Handle;
-                        wait.Set();
-                    },
+                        {
+                            handle = response.Handle;
+                            wait.Set();
+                        },
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -436,6 +436,24 @@ public byte[] RequestOpen(string path, Flags flags, bool nullOnError = false)
             return handle;
         }
 
+#if FEATURE_TAP
+        public async Task<byte[]> RequestOpenAsync(string path, Flags flags, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<byte[]> tcs = new TaskCompletionSource<byte[]>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            using (cancellationToken.Register((s) => ((TaskCompletionSource<byte[]>)s).TrySetCanceled(), tcs, false))
+            {
+                SendRequest(new SftpOpenRequest(ProtocolVersion, NextRequestId, path, Encoding, flags,
+                    response => tcs.TrySetResult(response.Handle),
+                    response => tcs.TrySetException(GetSftpException(response))));
+
+                return await tcs.Task.ConfigureAwait(false);
+            }
+        }
+#endif
+
         /// <summary>
         /// Performs SSH_FXP_OPEN request
         /// </summary>
@@ -495,24 +513,6 @@ public byte[] EndOpen(SftpOpenAsyncResult asyncResult)
             }
         }
 
-#if FEATURE_TAP
-        public async Task<byte[]> OpenAsync(string path, Flags flags, CancellationToken cancellationToken)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            TaskCompletionSource<byte[]> tcs = new TaskCompletionSource<byte[]>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            using (cancellationToken.Register((s) => ((TaskCompletionSource<byte[]>)s).TrySetCanceled(), tcs, false))
-            {
-                SendRequest(new SftpOpenRequest(ProtocolVersion, NextRequestId, path, Encoding, flags,
-                    response => tcs.TrySetResult(response.Handle),
-                    response => tcs.TrySetException(GetSftpException(response))));
-
-                return await tcs.Task.ConfigureAwait(false);
-            }
-        }
-#endif
-
         /// <summary>
         /// Performs SSH_FXP_CLOSE request.
         /// </summary>
@@ -525,10 +525,10 @@ public void RequestClose(byte[] handle)
             {
                 var request = new SftpCloseRequest(ProtocolVersion, NextRequestId, handle,
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -542,7 +542,7 @@ public void RequestClose(byte[] handle)
         }
 
 #if FEATURE_TAP
-        public async Task CloseAsync(byte[] handle, CancellationToken cancellationToken)
+        public async Task RequestCloseAsync(byte[] handle, CancellationToken cancellationToken)
         {
             TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
 
@@ -701,22 +701,22 @@ public byte[] RequestRead(byte[] handle, ulong offset, uint length)
             {
                 var request = new SftpReadRequest(ProtocolVersion, NextRequestId, handle, offset, length,
                     response =>
-                    {
-                        data = response.Data;
-                        wait.Set();
-                    },
-                    response =>
-                    {
-                        if (response.StatusCode != StatusCodes.Eof)
                         {
-                            exception = GetSftpException(response);
-                        }
-                        else
+                            data = response.Data;
+                            wait.Set();
+                        },
+                    response =>
                         {
-                            data = Array<byte>.Empty;
-                        }
-                        wait.Set();
-                    });
+                            if (response.StatusCode != StatusCodes.Eof)
+                            {
+                                exception = GetSftpException(response);
+                            }
+                            else
+                            {
+                                data = Array<byte>.Empty;
+                            }
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -779,18 +779,18 @@ public void RequestWrite(byte[] handle,
         {
             SshException exception = null;
 
-            var request = new SftpWriteRequest(ProtocolVersion, NextRequestId, handle, serverOffset, data, offset, length,
-                response =>
-                {
-                    if (writeCompleted != null)
+            var request = new SftpWriteRequest(ProtocolVersion, NextRequestId, handle, serverOffset, data, offset,
+                length, response =>
                     {
-                        writeCompleted(response);
-                    }
+                        if (writeCompleted != null)
+                        {
+                            writeCompleted(response);
+                        }
 
-                    exception = GetSftpException(response);
-                    if (wait != null)
-                        wait.Set();
-                });
+                        exception = GetSftpException(response);
+                        if (wait != null)
+                            wait.Set();
+                    });
 
             SendRequest(request);
 
@@ -846,15 +846,15 @@ public SftpFileAttributes RequestLStat(string path)
             {
                 var request = new SftpLStatRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                    {
-                        attributes = response.Attributes;
-                        wait.Set();
-                    },
+                        {
+                            attributes = response.Attributes;
+                            wait.Set();
+                        },
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -939,15 +939,15 @@ public SftpFileAttributes RequestFStat(byte[] handle, bool nullOnError)
             {
                 var request = new SftpFStatRequest(ProtocolVersion, NextRequestId, handle,
                     response =>
-                    {
-                        attributes = response.Attributes;
-                        wait.Set();
-                    },
+                        {
+                            attributes = response.Attributes;
+                            wait.Set();
+                        },
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -993,10 +993,10 @@ public void RequestSetStat(string path, SftpFileAttributes attributes)
             {
                 var request = new SftpSetStatRequest(ProtocolVersion, NextRequestId, path, Encoding, attributes,
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1022,10 +1022,10 @@ public void RequestFSetStat(byte[] handle, SftpFileAttributes attributes)
             {
                 var request = new SftpFSetStatRequest(ProtocolVersion, NextRequestId, handle, attributes,
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1054,15 +1054,15 @@ public byte[] RequestOpenDir(string path, bool nullOnError = false)
             {
                 var request = new SftpOpenDirRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                    {
-                        handle = response.Handle;
-                        wait.Set();
-                    },
+                        {
+                            handle = response.Handle;
+                            wait.Set();
+                        },
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1110,18 +1110,18 @@ public KeyValuePair<string, SftpFileAttributes>[] RequestReadDir(byte[] handle)
             {
                 var request = new SftpReadDirRequest(ProtocolVersion, NextRequestId, handle,
                     response =>
-                    {
-                        result = response.Files;
-                        wait.Set();
-                    },
+                        {
+                            result = response.Files;
+                            wait.Set();
+                        },
                     response =>
-                    {
-                        if (response.StatusCode != StatusCodes.Eof)
                         {
-                            exception = GetSftpException(response);
-                        }
-                        wait.Set();
-                    });
+                            if (response.StatusCode != StatusCodes.Eof)
+                            {
+                                exception = GetSftpException(response);
+                            }
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1177,10 +1177,10 @@ public void RequestRemove(string path)
             {
                 var request = new SftpRemoveRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1233,10 +1233,10 @@ public void RequestMkDir(string path)
             {
                 var request = new SftpMkDirRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1261,10 +1261,10 @@ public void RequestRmDir(string path)
             {
                 var request = new SftpRmDirRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1295,15 +1295,15 @@ internal KeyValuePair<string, SftpFileAttributes>[] RequestRealPath(string path,
             {
                 var request = new SftpRealPathRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                    {
-                        result = response.Files;
-                        wait.Set();
-                    },
+                        {
+                            result = response.Files;
+                            wait.Set();
+                        },
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1417,15 +1417,15 @@ public SftpFileAttributes RequestStat(string path, bool nullOnError = false)
             {
                 var request = new SftpStatRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                    {
-                        attributes = response.Attributes;
-                        wait.Set();
-                    },
+                        {
+                            attributes = response.Attributes;
+                            wait.Set();
+                        },
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1511,10 +1511,10 @@ public void RequestRename(string oldPath, string newPath)
             {
                 var request = new SftpRenameRequest(ProtocolVersion, NextRequestId, oldPath, newPath, Encoding,
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1576,15 +1576,15 @@ internal KeyValuePair<string, SftpFileAttributes>[] RequestReadLink(string path,
             {
                 var request = new SftpReadLinkRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                    {
-                        result = response.Files;
-                        wait.Set();
-                    },
+                        {
+                            result = response.Files;
+                            wait.Set();
+                        },
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1617,10 +1617,10 @@ public void RequestSymLink(string linkpath, string targetpath)
             {
                 var request = new SftpSymLinkRequest(ProtocolVersion, NextRequestId, linkpath, targetpath, Encoding,
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 SendRequest(request);
 
@@ -1655,10 +1655,10 @@ public void RequestPosixRename(string oldPath, string newPath)
             {
                 var request = new PosixRenameRequest(ProtocolVersion, NextRequestId, oldPath, newPath, Encoding,
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 if (!_supportedExtensions.ContainsKey(request.Name))
                     throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "Extension method {0} currently not supported by the server.", request.Name));
@@ -1695,15 +1695,15 @@ public SftpFileSytemInformation RequestStatVfs(string path, bool nullOnError = f
             {
                 var request = new StatVfsRequest(ProtocolVersion, NextRequestId, path, Encoding,
                     response =>
-                    {
-                        information = response.GetReply<StatVfsReplyInfo>().Information;
-                        wait.Set();
-                    },
+                        {
+                            information = response.GetReply<StatVfsReplyInfo>().Information;
+                            wait.Set();
+                        },
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 if (!_supportedExtensions.ContainsKey(request.Name))
                     throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "Extension method {0} currently not supported by the server.", request.Name));
@@ -1767,15 +1767,15 @@ internal SftpFileSytemInformation RequestFStatVfs(byte[] handle, bool nullOnErro
             {
                 var request = new FStatVfsRequest(ProtocolVersion, NextRequestId, handle,
                     response =>
-                    {
-                        information = response.GetReply<StatVfsReplyInfo>().Information;
-                        wait.Set();
-                    },
+                        {
+                            information = response.GetReply<StatVfsReplyInfo>().Information;
+                            wait.Set();
+                        },
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 if (!_supportedExtensions.ContainsKey(request.Name))
                     throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "Extension method {0} currently not supported by the server.", request.Name));
@@ -1811,10 +1811,10 @@ internal void HardLink(string oldPath, string newPath)
             {
                 var request = new HardLinkRequest(ProtocolVersion, NextRequestId, oldPath, newPath,
                     response =>
-                    {
-                        exception = GetSftpException(response);
-                        wait.Set();
-                    });
+                        {
+                            exception = GetSftpException(response);
+                            wait.Set();
+                        });
 
                 if (!_supportedExtensions.ContainsKey(request.Name))
                     throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "Extension method {0} currently not supported by the server.", request.Name));
diff --git a/src/Renci.SshNet/SftpClient.cs b/src/Renci.SshNet/SftpClient.cs
index 4b821e94f..df2d0fb38 100644
--- a/src/Renci.SshNet/SftpClient.cs
+++ b/src/Renci.SshNet/SftpClient.cs
@@ -64,7 +64,7 @@ public TimeSpan OperationTimeout
                 if (timeoutInMilliseconds < -1d || timeoutInMilliseconds > int.MaxValue)
                     throw new ArgumentOutOfRangeException("value", "The timeout must represent a value between -1 and Int32.MaxValue, inclusive.");
 
-                _operationTimeout = (int)timeoutInMilliseconds;
+                _operationTimeout = (int) timeoutInMilliseconds;
             }
         }
 
@@ -141,7 +141,7 @@ public int ProtocolVersion
                 CheckDisposed();
                 if (_sftpSession == null)
                     throw new SshConnectionException("Client not connected.");
-                return (int)_sftpSession.ProtocolVersion;
+                return (int) _sftpSession.ProtocolVersion;
             }
         }
 
@@ -391,10 +391,11 @@ public void DeleteFile(string path)
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         public async Task DeleteFileAsync(string path, CancellationToken cancellationToken)
         {
+            base.CheckDisposed();
             if (path.IsNullOrWhiteSpace())
                 throw new ArgumentException("path");
-
-            CheckDisposedOrNotConnected();
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
             cancellationToken.ThrowIfCancellationRequested();
 
             var fullPath = await _sftpSession.GetCanonicalPathAsync(path, cancellationToken).ConfigureAwait(false);
@@ -432,13 +433,13 @@ public void RenameFile(string oldPath, string newPath)
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         public async Task RenameFileAsync(string oldPath, string newPath, CancellationToken cancellationToken)
         {
+            base.CheckDisposed();
             if (oldPath == null)
                 throw new ArgumentNullException("oldPath");
-
             if (newPath == null)
                 throw new ArgumentNullException("newPath");
-
-            CheckDisposedOrNotConnected();
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
             cancellationToken.ThrowIfCancellationRequested();
 
             var oldFullPath = await _sftpSession.GetCanonicalPathAsync(oldPath, cancellationToken).ConfigureAwait(false);
@@ -553,10 +554,11 @@ public IEnumerable<SftpFile> ListDirectory(string path, Action<int> listCallback
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         public async Task<IEnumerable<SftpFile>> ListDirectoryAsync(string path, CancellationToken cancellationToken)
         {
+            base.CheckDisposed();
             if (path == null)
                 throw new ArgumentNullException("path");
-
-            CheckDisposedOrNotConnected();
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
             cancellationToken.ThrowIfCancellationRequested();
 
             var fullPath = await _sftpSession.GetCanonicalPathAsync(path, cancellationToken).ConfigureAwait(false);
@@ -586,7 +588,7 @@ public async Task<IEnumerable<SftpFile>> ListDirectoryAsync(string path, Cancell
             }
             finally
             {
-                _sftpSession.CloseAsync(handle, cancellationToken);
+                _sftpSession.RequestCloseAsync(handle, cancellationToken);
             }
 
             return result;
@@ -774,12 +776,13 @@ public void DownloadFile(string path, Stream output, Action<ulong> downloadCallb
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         public async Task DownloadFileAsync(string path, Stream output, CancellationToken cancellationToken)
         {
+            base.CheckDisposed();
             if (path == null)
                 throw new ArgumentNullException("path");
             if (output == null)
                 throw new ArgumentNullException("output");
-
-            CheckDisposedOrNotConnected();
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
             cancellationToken.ThrowIfCancellationRequested();
 
             using (SftpFileStream input = await SftpFileStream.OpenAsync(_sftpSession, path, FileMode.Open, FileAccess.Read, (int)_bufferSize, cancellationToken).ConfigureAwait(false))
@@ -977,12 +980,13 @@ public void UploadFile(Stream input, string path, bool canOverride, Action<ulong
         /// </remarks>
         public async Task UploadFileAsync(Stream input, string path, UploadMode createMode, CancellationToken cancellationToken)
         {
+            base.CheckDisposed();
             if (input == null)
                 throw new ArgumentNullException("input");
             if (path == null)
                 throw new ArgumentNullException("path");
-
-            CheckDisposedOrNotConnected();
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
             cancellationToken.ThrowIfCancellationRequested();
 
             using (SftpFileStream output = await SftpFileStream.OpenAsync(_sftpSession, path, (FileMode)createMode, FileAccess.Write, (int)_bufferSize, cancellationToken).ConfigureAwait(false))
@@ -1206,10 +1210,11 @@ public SftpFileSytemInformation GetStatus(string path)
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         public async Task<SftpFileSytemInformation> GetStatusAsync(string path, CancellationToken cancellationToken)
         {
+            base.CheckDisposed();
             if (path == null)
                 throw new ArgumentNullException("path");
-
-            CheckDisposedOrNotConnected();
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
             cancellationToken.ThrowIfCancellationRequested();
 
             var fullPath = await _sftpSession.GetCanonicalPathAsync(path, cancellationToken).ConfigureAwait(false);
@@ -1349,7 +1354,7 @@ public StreamWriter AppendText(string path, Encoding encoding)
             if (encoding == null)
                 throw new ArgumentNullException("encoding");
 
-            return new StreamWriter(new SftpFileStream(_sftpSession, path, FileMode.Append, FileAccess.Write, (int)_bufferSize), encoding);
+            return new StreamWriter(new SftpFileStream(_sftpSession, path, FileMode.Append, FileAccess.Write, (int) _bufferSize), encoding);
         }
 
         /// <summary>
@@ -1370,7 +1375,7 @@ public SftpFileStream Create(string path)
         {
             CheckDisposed();
 
-            return new SftpFileStream(_sftpSession, path, FileMode.Create, FileAccess.ReadWrite, (int)_bufferSize);
+            return new SftpFileStream(_sftpSession, path, FileMode.Create, FileAccess.ReadWrite, (int) _bufferSize);
         }
 
         /// <summary>
@@ -1561,7 +1566,7 @@ public SftpFileStream Open(string path, FileMode mode, FileAccess access)
         {
             CheckDisposed();
 
-            return new SftpFileStream(_sftpSession, path, mode, access, (int)_bufferSize);
+            return new SftpFileStream(_sftpSession, path, mode, access, (int) _bufferSize);
         }
 
 #if FEATURE_TAP
@@ -1581,10 +1586,11 @@ public SftpFileStream Open(string path, FileMode mode, FileAccess access)
         /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
         public Task<SftpFileStream> OpenAsync(string path, FileMode mode, FileAccess access, CancellationToken cancellationToken)
         {
+            base.CheckDisposed();
             if (path == null)
                 throw new ArgumentNullException("path");
-
-            CheckDisposedOrNotConnected();
+            if (_sftpSession == null)
+                throw new SshConnectionException("Client not connected.");
             cancellationToken.ThrowIfCancellationRequested();
 
             return SftpFileStream.OpenAsync(_sftpSession, path, mode, access, (int)_bufferSize, cancellationToken);
@@ -1638,7 +1644,7 @@ public SftpFileStream OpenWrite(string path)
         {
             CheckDisposed();
 
-            return new SftpFileStream(_sftpSession, path, FileMode.OpenOrCreate, FileAccess.Write, (int)_bufferSize);
+            return new SftpFileStream(_sftpSession, path, FileMode.OpenOrCreate, FileAccess.Write, (int) _bufferSize);
         }
 
         /// <summary>
@@ -2301,7 +2307,7 @@ private void InternalDownloadFile(string path, Stream output, SftpDownloadAsyncR
 
                     output.Write(data, 0, data.Length);
 
-                    totalBytesRead += (ulong)data.Length;
+                    totalBytesRead += (ulong) data.Length;
 
                     if (downloadCallback != null)
                     {
@@ -2358,26 +2364,26 @@ private void InternalUploadFile(Stream input, string path, Flags flags, SftpUplo
 
                 if (bytesRead > 0)
                 {
-                    var writtenBytes = offset + (ulong)bytesRead;
+                    var writtenBytes = offset + (ulong) bytesRead;
 
                     _sftpSession.RequestWrite(handle, offset, buffer, 0, bytesRead, null, s =>
-                    {
-                        if (s.StatusCode == StatusCodes.Ok)
                         {
-                            Interlocked.Decrement(ref expectedResponses);
-                            responseReceivedWaitHandle.Set();
-
-                            //  Call callback to report number of bytes written
-                            if (uploadCallback != null)
+                            if (s.StatusCode == StatusCodes.Ok)
                             {
-                                //  Execute callback on different thread
-                                ThreadAbstraction.ExecuteThread(() => uploadCallback(writtenBytes));
+                                Interlocked.Decrement(ref expectedResponses);
+                                responseReceivedWaitHandle.Set();
+
+                                //  Call callback to report number of bytes written
+                                if (uploadCallback != null)
+                                {
+                                    //  Execute callback on different thread
+                                    ThreadAbstraction.ExecuteThread(() => uploadCallback(writtenBytes));
+                                }
                             }
-                        }
-                    });
+                        });
                     Interlocked.Increment(ref expectedResponses);
 
-                    offset += (ulong)bytesRead;
+                    offset += (ulong) bytesRead;
 
                     bytesRead = input.Read(buffer, 0, buffer.Length);
                 }

From b7fd33376fd9b3cce75b973d713057d985def35e Mon Sep 17 00:00:00 2001
From: Igor Milavec <igor.milavec@gmail.com>
Date: Mon, 6 Dec 2021 22:51:58 +0100
Subject: [PATCH 10/11] Code cleanup as requested by review #2

---
 .vs/ProjectSettings.json                      |   3 -
 .vs/VSWorkspaceState.json                     |  10 --
 .vs/slnx.sqlite                               | Bin 90112 -> 0 bytes
 .../Abstractions/DnsAbstraction.cs            |   3 +
 .../Abstractions/SocketAbstraction.cs         |  24 +--
 src/Renci.SshNet/ISftpClient.cs               |  39 -----
 src/Renci.SshNet/Renci.SshNet.csproj          |   6 +-
 src/Renci.SshNet/Session.cs                   | 159 ++++++++----------
 src/Renci.SshNet/Sftp/ISftpSession.cs         |   4 +-
 src/Renci.SshNet/Sftp/SftpFileStream.cs       |  35 ++--
 src/Renci.SshNet/Sftp/SftpSession.cs          |   5 +-
 src/Renci.SshNet/Sftp/UploadMode.cs           |  23 ---
 src/Renci.SshNet/SftpClient.cs                |  75 +--------
 13 files changed, 110 insertions(+), 276 deletions(-)
 delete mode 100644 .vs/ProjectSettings.json
 delete mode 100644 .vs/VSWorkspaceState.json
 delete mode 100644 .vs/slnx.sqlite
 delete mode 100644 src/Renci.SshNet/Sftp/UploadMode.cs

diff --git a/.vs/ProjectSettings.json b/.vs/ProjectSettings.json
deleted file mode 100644
index f8b488856..000000000
--- a/.vs/ProjectSettings.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "CurrentProjectSetting": null
-}
\ No newline at end of file
diff --git a/.vs/VSWorkspaceState.json b/.vs/VSWorkspaceState.json
deleted file mode 100644
index 5bfd8bcbe..000000000
--- a/.vs/VSWorkspaceState.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-  "ExpandedNodes": [
-    "",
-    "\\src",
-    "\\src\\Renci.SshNet",
-    "\\src\\Renci.SshNet\\Sftp"
-  ],
-  "SelectedNode": "\\src\\Renci.SshNet.VS2019.sln",
-  "PreviewInSolutionExplorer": false
-}
\ No newline at end of file
diff --git a/.vs/slnx.sqlite b/.vs/slnx.sqlite
deleted file mode 100644
index 70b0a3daa4edf46e514b0bc0eb2e15f4f7988928..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 90112
zcmeI4&u<&Y6~{?Y*2<J<IzJp9bja2SV6m3u*sjwwL4Z=rmCcx@DE^QmC<L*h#_~4g
z(&jF03v~{(8v}^}13~|S-f|22M-)Bw)KjiK^wvXx0zodF+1=S6vrAEtQyEdeL?n?r
z@6EjTnfKn#%+jfEly!^9clv{#X319*XA{X};<vJ#NF-A9=PmlfUvJPi)BFSdn+&`k
z_coPS`IUT%31@#`GOuTUnEz(}?A*=ti__0%zmrlk8>z3SzMra1eLSuUT>se+m}QoZ
z-Z>-XZZ9WC8@jPe9@Y1IJN<5v+|do)()&i+d28&g>0MIVZI|MNvPw-YG*r1%DXO2y
z+lT6-l}XF=wO)zJx8%j`@UX4?=v+q1Db&pC@n%-E9*H;Z%mm|n%?Tzk!IrG7m&?r8
z%DPghtNAZJnwN6R%gL{nEp4YuMAya78P}LbVYRHrc%DfwI$R<UOS>(~x1nBFYjU+#
zx>cxc$v4$4xzKE^mnyW|TWY02t)f58a(T(^r8?+8(09oosLf>@5jF`mbxp0Q6-BMf
z+gw96EZy2~EqWJd7kOWW&ReruWFRO8rBGBuO+~e=`c2#z2ViBhP*ZLcYKvE{UCVn0
z3tYL%+OXT*-xz9L{f<s{<2ne>2iLnvqr~UMJ?5>2PKTJLzN2@Uiyl@{Oo+jVobPfF
zAWM|`zG;!3hfuu4P|CjcQCODy9gXE@t^aVm16)YycZWSADwj#;N0;WLT$|=q+s-T7
z(vD^rWT0rByQCd8-N`aha6X)6V)NL30y!t@(AbNP-pW61rtOS-*0M8B)Dl0>g)>fU
zrsMOB6PtoLbBK&{Cp6CHNaTbv&K`Giz`R_%@U#v(#p69>4Hxu+mtTnFe|(ZR_V3Xu
z$tx8ff@fYs?-A3|diPo~D;|x~Em}!wy<(BLd|Jv~$|s*>?MURqvi{oa7r)>bmUgGL
zSt)Hay*m$=@stAL#oJuR=skvCaZDBpiPySG1}06kNacT$n3Zz*eDdjsb{z7~obJP)
zPKRSK+!%;J-VmImLqwhv8J@w8JARpccVd<0<9e<hMww072a=Rim-&>5f!wZY17cWh
zR<^~q+1U9LrGh;KrcxAR3x>G6^Af$C*(QhzES5*BGg9s|TKV?<$`{B&cj%~Qp#BBK
zCD$K!2_&jb=xu^;2RL!=RB%}o8J1CrH+W`(!M^4M<Kn>QpWc{uinQVv=>RR!&Qsw8
z5t{=kA~qc@RUDiBC_ltXWb7RHwa%_%Y(2$ZM_3ZPT!k;0j7>{kEk&1sWzDqKcT6&P
zK<Ki_ue|PRQ7)=$g=V=ScZLHyV=Z2$X_EI-Qtt9Xa`d*HCUs(2y0K^Hw7cGRu1tsH
zDJo}&k-gk^6vicOzB)CNyLd6VWk-&ApRUnJ+a&jg#GtFT@W)grZiL1~g9iT+)y$8s
zC#BrNLh=c*`*dw{|4fDY*mkc5Le9N%Y>~F9b%%5wh3IV3z1nN(4E>!-|2>iYXZA1j
z4_+Vu0w4eaAOHd&00JQJ^CR$OFLf%R{P6-khWH)nSW4fxqwfs|_W5R=?pgE>`90ek
zop%LRhkAE6BxRoeK;Cw?Pqrl6fSteRbVr-cn}g1$pVsIGLSLzycPqqN*{olA_wtn$
zvum7p&!&8hhBnwE7S%K8>9gO;wiB$gBH0=4JuVpgvQllHcSil(75g!xUwfsa|N51V
z{+m}ddV?N6nnEnt*H$_v3z(xv!;ypGHr-hFADY#>eS^F&m=<a~E)y-v=s-K-Acigd
z36MT||Ggt6mtgr%IIS$zTXv$KuUp!{8s2jY5<7UYOOV^DIL9bqA-A4n(x3lgYC563
zW|tAC)R;|rG~*sKm^aD(cI&O=bmBs;PM^T^H1|~Y^2*hfYi$3Y%>Fw;|HBIeKmY_l
z00ck)1V8`;KmY_l00cnb<PexkrWTU!;Xo=){YquOO=SO;{Wklrlj9^j0Ra#I0T2KI
z5C8!X009sH0T2LzpD}^AQ%chPjzH-9O76FsQmp-e?*UAmO<g!0`Vs(p{!jnWKVBdJ
z0w4eaAOHd&00JNY0w4eaAOHd<m;ihJkNy7%o?y5J0w4eaAOHd&00JNY0w4eaAOHfC
z0QUa~0}ucK5C8!X009sH0T2KI5C8!XIQayy|3CS23=cs71V8`;KmY_l00ck)1V8`;
zKmh;#A29#|AOHd&00JNY0w4eaAOHd&00JkU0G|J!{5gh)AOHd&00JNY0w4eaAOHd&
z00JO@=l_TS5C8!X009sH0T2KI5C8!X009s<`2_I%|K!gxJOlv{009sH0T2KI5C8!X
z009sH0X+Xl41fR#fB*=900@8p2!H?xfB*=9z{w|o=l>^vj^QB)fB*=900@8p2!H?x
zfB*=900?0Jj~D;}5C8!X009sH0T2KI5C8!X0D+TF0N?*V`Ev{pK>!3m00ck)1V8`;
zKmY_l00cmQ?f=tKDv^Ef%s<YU^WV&$ox7QSar*h}cT#F*BlY#v_fxg0kHHB94o_hE
z&$-*n$<c;x?2<?I{oYQ$TO@aML$~z4(RSV%duw`^ly=*tIH9akQwt4ME>()^C-U~8
z`e<d+GJUOAqVg?yaXUP0D?d7yk#Y((^Lo6Q6|G0&jXN{JIA3#uNldUME9>Pl^R=?B
z6zXdJi;w1|-12hrt7S{u=@QX(@pHyCrcqcet1+Hu(u)q42*lEEi}G!#*VUR_t(9&S
zYFqM6bxSTZ8|$SC?e>;hX;7=^PqSQJa(k%``VaJ7G6-sO8ApUoLQP#$YidPN>+&|&
zPz_7B_FIeI1=>a4SE2LPtQHvvia{w9)lgGWEvtSLH^u>2*(}tQ8-?29m221Xp1}fF
zuCg}lcK0`iT35fLlij!u!t=rPZqg|6d2x?<YoXI2rm64fUFM>PRTL9qFe2x>90bS`
zrM_=kq~{?NFENy|uYDAj<$gzF`C02f9Pa=ZQu^It&xp!p()rP)IVsnsdDXV_%C@wl
z83q|BTIVilM@@IKOcb0CXPMYMwx2-Gi8?g)qNBI+Pn&5w<DRwbj1#rQ&vW676PxMy
zJmbWsV9p#O<J<|2vpEtup^US~og6SP7cV@mgHG{y4_U(nz2M~+BKaSm<c<A%v`X?y
z#fRXT*U)>!w6xy6mduJrqjZZ_Qd+NABrczpa+mVSCs{iZ`LL|NHv7ddIEJO&X>C?Y
z8%^)d!(}|BKzQ*s*D-pJ;a41!g+k)BZjymX6D?BtpCo3bTt1(C`k@_%yfdf!@Tb$^
z7z{TCB9J!(C+QH8=R}5Qu;Y$jX5XDyW%;<CtA|l$Q}%%*<<w<9Wnv(=tJ;7VR-2V=
zv28YX{zR!@4}qx^#n^%&?(V!qZ)dg%q5_NM(dvwp`;1n;eZTSrvd|qmsu`$%0ddLo
z$6W%6Y7=^!;M)OCoI4d<7Da|-RN@VunP9N5Il;I%@cE}Vrkx_K_(eKEOSJP;I6=hb
zK#GV>M@tpQW<Sagu@V_O2Y#)y>lj;4vDXon1TR<NOD1E}l2=R7Wnft|t@Ry~3?2}=
zEb=R_yIPcs>RO>$ZpfYCz|L5UmuZ^h{gjluypSBdZKp|{Se9<=**Wd5x1B4~;dqM5
z*<oZa_Z@|CNt>@u&Ezg#Om5kcW8SB0G}1Q7{UI^vsxAC66^a|7anYc`zeF|jqw7g2
zx3G|WLhL?W+uT1>p+2_VtAUVnuN+&XZED>iokt-$otvb+|4+O~WGnM8=KeFcK6_bu
zJoDG-a_Ud?;<3M;oqba}x4b<2{PqK#JY;M2s%G7_?|?cn#m_G1&60Xs7TaXa%%pFZ
z8aHU(D9u{Ew5djA3Uzm>#`3F9w-`!8j@ARYP?uLVGqeUT?JmjV5}3&=PTV^p&K;bo
zurd*9w(iPnwe?$(QT@!N>yh<}|IxA1|I93}uEdxZ7FnyW{CIOCUD)P7ek@=3^ny(P
zR98GVsUJbFt-HRi<DW2<OuFjJlqwav3;mexJ0m2R<XW9>>wRhJOw25O6tssG9gdxr
zoJ^X}ZhhsKOM=~|7Z{oJLB<}&NNVah+oE$s1M~*nCdUVhT&mj(+0o(~Qf@n+9Bm1!
zilSy|V|PJ5A13xzxRiz)$Mz9>n`YgyLhJXzF}L!6c=Woxfc^5KaF1q6z5@GnE?gtS
zje$}bZa7-S^!xBk^>4B64a*O%Biv?Ra_7w#%R%q>HYaq~=YozK2c4uGw3G601C!VB
zM_AUlH=Bm~N%-KXp$+zk6?YdJb5f)94U0TFj0W2{TzQS2I$RB%I@rs@8o5JgG3b!C
z_m0H_KX~+G!)tzXT(Wo)@m<BHi>E_p%X{w_KsO9m&Q3DANbV71S2L^$M!zxH=-93%
z8ZBtG^3N8sQts;2<nzF3NtkpD)3f8!-D47)^ImH-aSySJ<>x0nZQ}APKJU54<V5??
zN0uVbpSBYD?i}R^(8KKpsBhb=-H3$jVhh5S?3I@>#p8ciZM>7G@VS(G=Jd`P2@gL?
z?3qrWw1^Ka#_rVc@B<G&j&#!Tl1niDT;u=m;RpWx|FIu(U_cN60T2KI5C8!X009sH
z0T2KI5IA-M*#93patsIpAOHd&00JNY0w4eaAOHd&00PHO0RR8LV@HkwK>!3m00ck)
w1V8`;KmY_l00cnb*a_hI|FI*-fFJ+@AOHd&00JNY0w4eaAOHd&aO?#B3ytgc#{d8T

diff --git a/src/Renci.SshNet/Abstractions/DnsAbstraction.cs b/src/Renci.SshNet/Abstractions/DnsAbstraction.cs
index 6e090b0b8..a2ac9d58f 100644
--- a/src/Renci.SshNet/Abstractions/DnsAbstraction.cs
+++ b/src/Renci.SshNet/Abstractions/DnsAbstraction.cs
@@ -9,6 +9,7 @@
 #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;
@@ -45,6 +46,8 @@ 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))
diff --git a/src/Renci.SshNet/Abstractions/SocketAbstraction.cs b/src/Renci.SshNet/Abstractions/SocketAbstraction.cs
index 5bcb690db..1a38612da 100644
--- a/src/Renci.SshNet/Abstractions/SocketAbstraction.cs
+++ b/src/Renci.SshNet/Abstractions/SocketAbstraction.cs
@@ -74,10 +74,10 @@ private static void ConnectCore(Socket socket, IPEndPoint remoteEndpoint, TimeSp
 #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))
@@ -107,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)
                 {
@@ -134,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
         }
 
@@ -154,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
             {
@@ -207,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
         }
 
@@ -269,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
         }
 
@@ -300,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);
         }
 
@@ -505,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
         }
 
@@ -525,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();
         }
diff --git a/src/Renci.SshNet/ISftpClient.cs b/src/Renci.SshNet/ISftpClient.cs
index dc3df9ba9..486344d18 100644
--- a/src/Renci.SshNet/ISftpClient.cs
+++ b/src/Renci.SshNet/ISftpClient.cs
@@ -526,24 +526,6 @@ public interface ISftpClient
         /// </remarks>
         void DownloadFile(string path, Stream output, Action<ulong> downloadCallback = null);
 
-#if FEATURE_TAP
-        /// <summary>
-        /// Asynchronously downloads remote file specified by the path into the stream.
-        /// </summary>
-        /// <param name="path">File to download.</param>
-        /// <param name="output">Stream to write the file into.</param>
-        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
-        /// <returns>A <see cref="Task"/> that represents the asynchronous download operation.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="output" /> is <b>null</b>.</exception>
-        /// <exception cref="ArgumentException"><paramref name="path" /> is <b>null</b> or contains only whitespace characters.</exception>
-        /// <exception cref="SshConnectionException">Client is not connected.</exception>
-        /// <exception cref="SftpPermissionDeniedException">Permission to perform the operation was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
-        /// <exception cref="SftpPathNotFoundException"><paramref name="path"/> was not found on the remote host.</exception>/// 
-        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message" /> is the message from the remote host.</exception>
-        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
-        Task DownloadFileAsync(string path, Stream output, CancellationToken cancellationToken);
-#endif
-
         /// <summary>
         /// Ends an asynchronous file downloading into the stream.
         /// </summary>
@@ -1024,27 +1006,6 @@ public interface ISftpClient
         /// </remarks>
         void UploadFile(Stream input, string path, bool canOverride, Action<ulong> uploadCallback = null);
 
-#if FEATURE_TAP
-        /// <summary>
-        /// Asynchronously uploads stream into remote file.
-        /// </summary>
-        /// <param name="input">Data input stream.</param>
-        /// <param name="path">Remote file path.</param>
-        /// <param name="createMode">Specifies how the file should be created.</param>
-        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
-        /// <returns>A <see cref="Task"/> that represents the asynchronous upload operation.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="input" /> is <b>null</b>.</exception>
-        /// <exception cref="ArgumentException"><paramref name="path" /> is <b>null</b> or contains only whitespace characters.</exception>
-        /// <exception cref="SshConnectionException">Client is not connected.</exception>
-        /// <exception cref="SftpPermissionDeniedException">Permission to upload the file was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
-        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message" /> is the message from the remote host.</exception>
-        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
-        /// <remarks>
-        /// Method calls made by this method to <paramref name="input" />, may under certain conditions result in exceptions thrown by the stream.
-        /// </remarks>
-        Task UploadFileAsync(Stream input, string path, UploadMode createMode, CancellationToken cancellationToken);
-#endif
-
         /// <summary>
         /// Writes the specified byte array to the specified file, and closes the file.
         /// </summary>
diff --git a/src/Renci.SshNet/Renci.SshNet.csproj b/src/Renci.SshNet/Renci.SshNet.csproj
index 24524f3d9..740ec7ee1 100644
--- a/src/Renci.SshNet/Renci.SshNet.csproj
+++ b/src/Renci.SshNet/Renci.SshNet.csproj
@@ -5,9 +5,9 @@
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <AssemblyName>Renci.SshNet</AssemblyName>
     <AssemblyOriginatorKeyFile>../Renci.SshNet.snk</AssemblyOriginatorKeyFile>
-    <LangVersion>5</LangVersion>
+    <LangVersion>6</LangVersion>
     <SignAssembly>true</SignAssembly>
-    <TargetFrameworks>net35;net40;net46;netstandard1.3;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net35;net40;net472;netstandard1.3;netstandard2.0</TargetFrameworks>
   </PropertyGroup>
 
   <!--
@@ -38,7 +38,7 @@
   <PropertyGroup Condition=" '$(TargetFramework)' == 'net40' ">
     <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_REGEX_COMPILE;FEATURE_BINARY_SERIALIZATION;FEATURE_RNG_CREATE;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_EAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_STREAM_APM;FEATURE_DNS_SYNC;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HASH_RIPEMD160_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_HMAC_RIPEMD160;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_ENCODING_ASCII;FEATURE_ECDSA</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(TargetFramework)' == 'net46' ">
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'net472' ">
     <DefineConstants>FEATURE_STRINGBUILDER_CLEAR;FEATURE_HASHALGORITHM_DISPOSE;FEATURE_REGEX_COMPILE;FEATURE_BINARY_SERIALIZATION;FEATURE_RNG_CREATE;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_EAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_SELECT;FEATURE_SOCKET_POLL;FEATURE_SOCKET_DISPOSE;FEATURE_STREAM_APM;FEATURE_DNS_SYNC;FEATURE_THREAD_COUNTDOWNEVENT;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_WAITHANDLE_DISPOSE;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HASH_RIPEMD160_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_HMAC_RIPEMD160;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_ENCODING_ASCII;FEATURE_ECDSA;FEATURE_TAP</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard1.3' ">
diff --git a/src/Renci.SshNet/Session.cs b/src/Renci.SshNet/Session.cs
index abe143e39..c4b49f16c 100644
--- a/src/Renci.SshNet/Session.cs
+++ b/src/Renci.SshNet/Session.cs
@@ -676,6 +676,9 @@ public void Connect()
         /// <summary>
         /// Asynchronously connects to the server.
         /// </summary>
+        /// <remarks>
+        /// Please note this function is NOT thread safe.<br/>
+        /// The caller SHOULD limit the number of simultaneous connection attempts to a server to a single connection attempt.</remarks>
         /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
         /// <returns>A <see cref="Task"/> that represents the asynchronous connect operation.</returns>
         /// <exception cref="SocketException">Socket connection to the SSH server or proxy server could not be established, or an error occurred while resolving the hostname.</exception>
@@ -684,114 +687,94 @@ public void Connect()
         /// <exception cref="ProxyException">Failed to establish proxy connection.</exception>
         public async Task ConnectAsync(CancellationToken cancellationToken)
         {
+            // If connected don't connect again
             if (IsConnected)
                 return;
 
-            try
-            {
-                // ToDo: Migrate to SemaphoreSlim to enable async awaiting
-                // ToDo: SHould we really limit this globally here, or leave it to the app?
-                AuthenticationConnection.Wait();
-
-                if (IsConnected)
-                    return;
-
-                //lock (this)   // ToDo: Why do we need double locking at all?
-                {
-                    // If connected don't connect again
-                    if (IsConnected)
-                        return;
-
-                    // Reset connection specific information
-                    Reset();
+            // Reset connection specific information
+            Reset();
 
-                    // Build list of available messages while connecting
-                    _sshMessageFactory = new SshMessageFactory();
-
-                    _socket = await _serviceFactory.CreateConnector(ConnectionInfo, _socketFactory)
-                                             .ConnectAsync(ConnectionInfo, cancellationToken).ConfigureAwait(false);
-
-                    var serverIdentification = await _serviceFactory.CreateProtocolVersionExchange()
-                                                              .StartAsync(ClientVersion, _socket, cancellationToken).ConfigureAwait(false);
-
-                    // Set connection versions
-                    ServerVersion = ConnectionInfo.ServerVersion = serverIdentification.ToString();
-                    ConnectionInfo.ClientVersion = ClientVersion;
+            // Build list of available messages while connecting
+            _sshMessageFactory = new SshMessageFactory();
 
-                    DiagnosticAbstraction.Log(string.Format("Server version '{0}' on '{1}'.", serverIdentification.ProtocolVersion, serverIdentification.SoftwareVersion));
+            _socket = await _serviceFactory.CreateConnector(ConnectionInfo, _socketFactory)
+                                        .ConnectAsync(ConnectionInfo, cancellationToken).ConfigureAwait(false);
 
-                    if (!(serverIdentification.ProtocolVersion.Equals("2.0") || serverIdentification.ProtocolVersion.Equals("1.99")))
-                    {
-                        throw new SshConnectionException(string.Format(CultureInfo.CurrentCulture, "Server version '{0}' is not supported.", serverIdentification.ProtocolVersion),
-                                                         DisconnectReason.ProtocolVersionNotSupported);
-                    }
+            var serverIdentification = await _serviceFactory.CreateProtocolVersionExchange()
+                                                        .StartAsync(ClientVersion, _socket, cancellationToken).ConfigureAwait(false);
 
-                    // Register Transport response messages
-                    RegisterMessage("SSH_MSG_DISCONNECT");
-                    RegisterMessage("SSH_MSG_IGNORE");
-                    RegisterMessage("SSH_MSG_UNIMPLEMENTED");
-                    RegisterMessage("SSH_MSG_DEBUG");
-                    RegisterMessage("SSH_MSG_SERVICE_ACCEPT");
-                    RegisterMessage("SSH_MSG_KEXINIT");
-                    RegisterMessage("SSH_MSG_NEWKEYS");
+            // Set connection versions
+            ServerVersion = ConnectionInfo.ServerVersion = serverIdentification.ToString();
+            ConnectionInfo.ClientVersion = ClientVersion;
 
-                    // Some server implementations might sent this message first, prior to establishing encryption algorithm
-                    RegisterMessage("SSH_MSG_USERAUTH_BANNER");
+            DiagnosticAbstraction.Log(string.Format("Server version '{0}' on '{1}'.", serverIdentification.ProtocolVersion, serverIdentification.SoftwareVersion));
 
-                    // Mark the message listener threads as started
-                    _messageListenerCompleted.Reset();
+            if (!(serverIdentification.ProtocolVersion.Equals("2.0") || serverIdentification.ProtocolVersion.Equals("1.99")))
+            {
+                throw new SshConnectionException(string.Format(CultureInfo.CurrentCulture, "Server version '{0}' is not supported.", serverIdentification.ProtocolVersion),
+                                                    DisconnectReason.ProtocolVersionNotSupported);
+            }
 
-                    // Start incoming request listener
-                    // ToDo: Make message pump async, to not consume a thread for every session
-                    ThreadAbstraction.ExecuteThreadLongRunning(() => MessageListener());
+            // Register Transport response messages
+            RegisterMessage("SSH_MSG_DISCONNECT");
+            RegisterMessage("SSH_MSG_IGNORE");
+            RegisterMessage("SSH_MSG_UNIMPLEMENTED");
+            RegisterMessage("SSH_MSG_DEBUG");
+            RegisterMessage("SSH_MSG_SERVICE_ACCEPT");
+            RegisterMessage("SSH_MSG_KEXINIT");
+            RegisterMessage("SSH_MSG_NEWKEYS");
 
-                    // Wait for key exchange to be completed
-                    WaitOnHandle(_keyExchangeCompletedWaitHandle);
+            // Some server implementations might sent this message first, prior to establishing encryption algorithm
+            RegisterMessage("SSH_MSG_USERAUTH_BANNER");
 
-                    // If sessionId is not set then its not connected
-                    if (SessionId == null)
-                    {
-                        Disconnect();
-                        return;
-                    }
+            // Mark the message listener threads as started
+            _messageListenerCompleted.Reset();
 
-                    // Request user authorization service
-                    SendMessage(new ServiceRequestMessage(ServiceName.UserAuthentication));
+            // Start incoming request listener
+            // ToDo: Make message pump async, to not consume a thread for every session
+            ThreadAbstraction.ExecuteThreadLongRunning(() => MessageListener());
 
-                    // Wait for service to be accepted
-                    WaitOnHandle(_serviceAccepted);
+            // Wait for key exchange to be completed
+            WaitOnHandle(_keyExchangeCompletedWaitHandle);
 
-                    if (string.IsNullOrEmpty(ConnectionInfo.Username))
-                    {
-                        throw new SshException("Username is not specified.");
-                    }
+            // If sessionId is not set then its not connected
+            if (SessionId == null)
+            {
+                Disconnect();
+                return;
+            }
 
-                    // Some servers send a global request immediately after successful authentication
-                    // Avoid race condition by already enabling SSH_MSG_GLOBAL_REQUEST before authentication
-                    RegisterMessage("SSH_MSG_GLOBAL_REQUEST");
+            // Request user authorization service
+            SendMessage(new ServiceRequestMessage(ServiceName.UserAuthentication));
 
-                    ConnectionInfo.Authenticate(this, _serviceFactory);
-                    _isAuthenticated = true;
+            // Wait for service to be accepted
+            WaitOnHandle(_serviceAccepted);
 
-                    // Register Connection messages
-                    RegisterMessage("SSH_MSG_REQUEST_SUCCESS");
-                    RegisterMessage("SSH_MSG_REQUEST_FAILURE");
-                    RegisterMessage("SSH_MSG_CHANNEL_OPEN_CONFIRMATION");
-                    RegisterMessage("SSH_MSG_CHANNEL_OPEN_FAILURE");
-                    RegisterMessage("SSH_MSG_CHANNEL_WINDOW_ADJUST");
-                    RegisterMessage("SSH_MSG_CHANNEL_EXTENDED_DATA");
-                    RegisterMessage("SSH_MSG_CHANNEL_REQUEST");
-                    RegisterMessage("SSH_MSG_CHANNEL_SUCCESS");
-                    RegisterMessage("SSH_MSG_CHANNEL_FAILURE");
-                    RegisterMessage("SSH_MSG_CHANNEL_DATA");
-                    RegisterMessage("SSH_MSG_CHANNEL_EOF");
-                    RegisterMessage("SSH_MSG_CHANNEL_CLOSE");
-                }
-            }
-            finally
+            if (string.IsNullOrEmpty(ConnectionInfo.Username))
             {
-                AuthenticationConnection.Release();
+                throw new SshException("Username is not specified.");
             }
+
+            // Some servers send a global request immediately after successful authentication
+            // Avoid race condition by already enabling SSH_MSG_GLOBAL_REQUEST before authentication
+            RegisterMessage("SSH_MSG_GLOBAL_REQUEST");
+
+            ConnectionInfo.Authenticate(this, _serviceFactory);
+            _isAuthenticated = true;
+
+            // Register Connection messages
+            RegisterMessage("SSH_MSG_REQUEST_SUCCESS");
+            RegisterMessage("SSH_MSG_REQUEST_FAILURE");
+            RegisterMessage("SSH_MSG_CHANNEL_OPEN_CONFIRMATION");
+            RegisterMessage("SSH_MSG_CHANNEL_OPEN_FAILURE");
+            RegisterMessage("SSH_MSG_CHANNEL_WINDOW_ADJUST");
+            RegisterMessage("SSH_MSG_CHANNEL_EXTENDED_DATA");
+            RegisterMessage("SSH_MSG_CHANNEL_REQUEST");
+            RegisterMessage("SSH_MSG_CHANNEL_SUCCESS");
+            RegisterMessage("SSH_MSG_CHANNEL_FAILURE");
+            RegisterMessage("SSH_MSG_CHANNEL_DATA");
+            RegisterMessage("SSH_MSG_CHANNEL_EOF");
+            RegisterMessage("SSH_MSG_CHANNEL_CLOSE");
         }
 #endif
 
diff --git a/src/Renci.SshNet/Sftp/ISftpSession.cs b/src/Renci.SshNet/Sftp/ISftpSession.cs
index 63696493a..4a3648bd4 100644
--- a/src/Renci.SshNet/Sftp/ISftpSession.cs
+++ b/src/Renci.SshNet/Sftp/ISftpSession.cs
@@ -221,7 +221,7 @@ internal interface ISftpSession : ISubsystemSession
         byte[] EndRead(SftpReadAsyncResult asyncResult);
 
 #if FEATURE_TAP
-        Task<byte[]> ReadAsync(byte[] handle, ulong offset, uint length, CancellationToken cancellationToken);
+        Task<byte[]> RequestReadAsync(byte[] handle, ulong offset, uint length, CancellationToken cancellationToken);
 #endif
 
         /// <summary>
@@ -335,7 +335,7 @@ void RequestWrite(byte[] handle,
                           Action<SftpStatusResponse> writeCompleted = null);
 
 #if FEATURE_TAP
-        Task WriteAsync(byte[] handle, ulong serverOffset, byte[] data, int offset, int length, CancellationToken cancellationToken);
+        Task RequestWriteAsync(byte[] handle, ulong serverOffset, byte[] data, int offset, int length, CancellationToken cancellationToken);
 #endif
 
         /// <summary>
diff --git a/src/Renci.SshNet/Sftp/SftpFileStream.cs b/src/Renci.SshNet/Sftp/SftpFileStream.cs
index babceb226..fa697d0f0 100644
--- a/src/Renci.SshNet/Sftp/SftpFileStream.cs
+++ b/src/Renci.SshNet/Sftp/SftpFileStream.cs
@@ -283,8 +283,8 @@ internal SftpFileStream(ISftpSession session, string path, FileMode mode, FileAc
             // that ensures we always receive or send the max. number of bytes in a single SSH_FXP_READ
             // or SSH_FXP_WRITE message
 
-            _readBufferSize = (int)session.CalculateOptimalReadLength((uint)bufferSize);
-            _writeBufferSize = (int)session.CalculateOptimalWriteLength((uint)bufferSize, _handle);
+            _readBufferSize = (int) session.CalculateOptimalReadLength((uint) bufferSize);
+            _writeBufferSize = (int) session.CalculateOptimalWriteLength((uint) bufferSize, _handle);
 
             if (mode == FileMode.Append)
             {
@@ -346,19 +346,7 @@ internal static async Task<SftpFileStream> OpenAsync(ISftpSession session, strin
                     flags |= Flags.Append | Flags.CreateNewOrOpen;
                     break;
                 case FileMode.Create:
-                    try
-                    {
-                        handle = await session.RequestOpenAsync(path, flags | Flags.Truncate, cancellationToken).ConfigureAwait(false);
-                        flags |= Flags.Truncate;
-                    }
-                    catch (TaskCanceledException)// ToDo: when (cancellationToken.IsCancellationRequested)
-                    {
-                        throw;
-                    }
-                    catch (Exception)
-                    {
-                        flags |= Flags.CreateNew;
-                    }
+                    flags |= Flags.CreateNewOrOpen | Flags.Truncate;
                     break;
                 case FileMode.CreateNew:
                     flags |= Flags.CreateNew;
@@ -388,7 +376,14 @@ internal static async Task<SftpFileStream> OpenAsync(ISftpSession session, strin
                 }
                 catch
                 {
-                    session.RequestClose(handle);
+                    try
+                    {
+                        await session.RequestCloseAsync(handle, cancellationToken).ConfigureAwait(false);
+                    }
+                    catch
+                    { 
+                        // The original exception is presumably more informative, so we just ignore this one.
+                    }
                     throw;
                 }
             }
@@ -628,7 +623,7 @@ public override async Task<int> ReadAsync(byte[] buffer, int offset, int count,
                 var bytesAvailableInBuffer = _bufferLen - _bufferPosition;
                 if (bytesAvailableInBuffer <= 0)
                 {
-                    var data = await _session.ReadAsync(_handle, (ulong)_position, (uint)_readBufferSize, cancellationToken).ConfigureAwait(false);
+                    var data = await _session.RequestReadAsync(_handle, (ulong)_position, (uint)_readBufferSize, cancellationToken).ConfigureAwait(false);
 
                     if (data.Length == 0)
                     {
@@ -1062,7 +1057,7 @@ public override async Task WriteAsync(byte[] buffer, int offset, int count, Canc
                 // Can we short-cut the internal buffer?
                 if (_bufferPosition == 0 && tempLen == _writeBufferSize)
                 {
-                    await _session.WriteAsync(_handle, (ulong)_position, buffer, offset, tempLen, cancellationToken).ConfigureAwait(false);
+                    await _session.RequestWriteAsync(_handle, (ulong)_position, buffer, offset, tempLen, cancellationToken).ConfigureAwait(false);
                 }
                 else
                 {
@@ -1081,7 +1076,7 @@ public override async Task WriteAsync(byte[] buffer, int offset, int count, Canc
             // rather than waiting for the next call to this method.
             if (_bufferPosition >= _writeBufferSize)
             {
-                await _session.WriteAsync(_handle, (ulong)(_position - _bufferPosition), GetOrCreateWriteBuffer(), 0, _bufferPosition, cancellationToken).ConfigureAwait(false);
+                await _session.RequestWriteAsync(_handle, (ulong)(_position - _bufferPosition), GetOrCreateWriteBuffer(), 0, _bufferPosition, cancellationToken).ConfigureAwait(false);
                 _bufferPosition = 0;
             }
         }
@@ -1209,7 +1204,7 @@ private async Task FlushWriteBufferAsync(CancellationToken cancellationToken)
         {
             if (_bufferPosition > 0)
             {
-                await _session.WriteAsync(_handle, (ulong)(_position - _bufferPosition), _writeBuffer, 0, _bufferPosition, cancellationToken);
+                await _session.RequestWriteAsync(_handle, (ulong)(_position - _bufferPosition), _writeBuffer, 0, _bufferPosition, cancellationToken);
                 _bufferPosition = 0;
             }
         }
diff --git a/src/Renci.SshNet/Sftp/SftpSession.cs b/src/Renci.SshNet/Sftp/SftpSession.cs
index b0f7ea9e2..c33c70e34 100644
--- a/src/Renci.SshNet/Sftp/SftpSession.cs
+++ b/src/Renci.SshNet/Sftp/SftpSession.cs
@@ -559,6 +559,7 @@ public async Task RequestCloseAsync(byte[] handle, CancellationToken cancellatio
                     }
                 }));
 
+            // Only check for cancellation after the SftpCloseRequest was sent
             cancellationToken.ThrowIfCancellationRequested();
             using (cancellationToken.Register((s) => ((TaskCompletionSource<bool>)s).TrySetCanceled(), tcs, false))
             {
@@ -732,7 +733,7 @@ public byte[] RequestRead(byte[] handle, ulong offset, uint length)
         }
 
 #if FEATURE_TAP
-        public async Task<byte[]> ReadAsync(byte[] handle, ulong offset, uint length, CancellationToken cancellationToken)
+        public async Task<byte[]> RequestReadAsync(byte[] handle, ulong offset, uint length, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
@@ -804,7 +805,7 @@ public void RequestWrite(byte[] handle,
         }
 
 #if FEATURE_TAP
-        public async Task WriteAsync(byte[] handle, ulong serverOffset, byte[] data, int offset, int length, CancellationToken cancellationToken)
+        public async Task RequestWriteAsync(byte[] handle, ulong serverOffset, byte[] data, int offset, int length, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
diff --git a/src/Renci.SshNet/Sftp/UploadMode.cs b/src/Renci.SshNet/Sftp/UploadMode.cs
deleted file mode 100644
index bedaa8c86..000000000
--- a/src/Renci.SshNet/Sftp/UploadMode.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-namespace Renci.SshNet.Sftp
-{
-    /// <summary>
-    /// Specifies how the uploaded file should be created.
-    /// </summary>
-    public enum UploadMode
-    {
-        /// <summary>
-        /// A new file should be created. If the file already exists, an exception is thrown.
-        /// </summary>
-        CreateNew = 1,
-
-        /// <summary>
-        /// A new file should be created. If the file already exists, it will be overwritten.
-        /// </summary>
-        Overwrite = 2,
-
-        /// <summary>
-        /// Opens the file if it exists and seeks to the end of the file, or creates a new file.
-        /// </summary>
-        Append = 6
-    }
-}
diff --git a/src/Renci.SshNet/SftpClient.cs b/src/Renci.SshNet/SftpClient.cs
index df2d0fb38..9dc541a15 100644
--- a/src/Renci.SshNet/SftpClient.cs
+++ b/src/Renci.SshNet/SftpClient.cs
@@ -588,7 +588,7 @@ public async Task<IEnumerable<SftpFile>> ListDirectoryAsync(string path, Cancell
             }
             finally
             {
-                _sftpSession.RequestCloseAsync(handle, cancellationToken);
+                await _sftpSession.RequestCloseAsync(handle, cancellationToken).ConfigureAwait(false);
             }
 
             return result;
@@ -760,38 +760,6 @@ public void DownloadFile(string path, Stream output, Action<ulong> downloadCallb
             InternalDownloadFile(path, output, null, downloadCallback);
         }
 
-#if FEATURE_TAP
-        /// <summary>
-        /// Asynchronously downloads remote file specified by the path into the stream.
-        /// </summary>
-        /// <param name="path">File to download.</param>
-        /// <param name="output">Stream to write the file into.</param>
-        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
-        /// <returns>A <see cref="Task"/> that represents the asynchronous download operation.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="path" /> is <b>null</b> -or- <paramref name="output" /> is <b>null</b>.</exception>
-        /// <exception cref="SshConnectionException">Client is not connected.</exception>
-        /// <exception cref="SftpPermissionDeniedException">Permission to perform the operation was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
-        /// <exception cref="SftpPathNotFoundException"><paramref name="path"/> was not found on the remote host.</exception>/// 
-        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message" /> is the message from the remote host.</exception>
-        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
-        public async Task DownloadFileAsync(string path, Stream output, CancellationToken cancellationToken)
-        {
-            base.CheckDisposed();
-            if (path == null)
-                throw new ArgumentNullException("path");
-            if (output == null)
-                throw new ArgumentNullException("output");
-            if (_sftpSession == null)
-                throw new SshConnectionException("Client not connected.");
-            cancellationToken.ThrowIfCancellationRequested();
-
-            using (SftpFileStream input = await SftpFileStream.OpenAsync(_sftpSession, path, FileMode.Open, FileAccess.Read, (int)_bufferSize, cancellationToken).ConfigureAwait(false))
-            {
-                await input.CopyToAsync(output, 81920, cancellationToken).ConfigureAwait(false);
-            }
-        }
-#endif
-
         /// <summary>
         /// Begins an asynchronous file downloading into the stream.
         /// </summary>
@@ -961,40 +929,6 @@ public void UploadFile(Stream input, string path, bool canOverride, Action<ulong
             InternalUploadFile(input, path, flags, null, uploadCallback);
         }
 
-#if FEATURE_TAP
-        /// <summary>
-        /// Asynchronously uploads stream into remote file.
-        /// </summary>
-        /// <param name="input">Data input stream.</param>
-        /// <param name="path">Remote file path.</param>
-        /// <param name="createMode">Specifies how the file should be created.</param>
-        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
-        /// <returns>A <see cref="Task"/> that represents the asynchronous upload operation.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="input" /> is <b>null</b> -or- <paramref name="path" /> is <b>null</b>.</exception>
-        /// <exception cref="SshConnectionException">Client is not connected.</exception>
-        /// <exception cref="SftpPermissionDeniedException">Permission to upload the file was denied by the remote host. <para>-or-</para> A SSH command was denied by the server.</exception>
-        /// <exception cref="SshException">A SSH error where <see cref="Exception.Message" /> is the message from the remote host.</exception>
-        /// <exception cref="ObjectDisposedException">The method was called after the client was disposed.</exception>
-        /// <remarks>
-        /// Method calls made by this method to <paramref name="input" />, may under certain conditions result in exceptions thrown by the stream.
-        /// </remarks>
-        public async Task UploadFileAsync(Stream input, string path, UploadMode createMode, CancellationToken cancellationToken)
-        {
-            base.CheckDisposed();
-            if (input == null)
-                throw new ArgumentNullException("input");
-            if (path == null)
-                throw new ArgumentNullException("path");
-            if (_sftpSession == null)
-                throw new SshConnectionException("Client not connected.");
-            cancellationToken.ThrowIfCancellationRequested();
-
-            using (SftpFileStream output = await SftpFileStream.OpenAsync(_sftpSession, path, (FileMode)createMode, FileAccess.Write, (int)_bufferSize, cancellationToken).ConfigureAwait(false))
-            {
-                await input.CopyToAsync(output, (int)_sftpSession.CalculateOptimalWriteLength(_bufferSize, output.Handle), cancellationToken).ConfigureAwait(false);
-            }
-        }
-#endif
         /// <summary>
         /// Begins an asynchronous uploading the stream into remote file.
         /// </summary>
@@ -2443,13 +2377,6 @@ protected override void Dispose(bool disposing)
             }
         }
 
-        private void CheckDisposedOrNotConnected()
-        {
-            base.CheckDisposed();
-            if (_sftpSession == null)
-                throw new SshConnectionException("Client not connected.");
-        }
-
         private ISftpSession CreateAndConnectToSftpSession()
         {
             var sftpSession = ServiceFactory.CreateSftpSession(Session,

From 85839e7d0448046974d3c86480ed3ca39fc5c59a Mon Sep 17 00:00:00 2001
From: Igor Milavec <igor.milavec@gmail.com>
Date: Mon, 6 Dec 2021 23:06:40 +0100
Subject: [PATCH 11/11] Revert formatting changes

---
 src/Renci.SshNet/Abstractions/SocketAbstraction.cs |  2 +-
 src/Renci.SshNet/Sftp/SftpFileStream.cs            | 14 +++++++-------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/Renci.SshNet/Abstractions/SocketAbstraction.cs b/src/Renci.SshNet/Abstractions/SocketAbstraction.cs
index 1a38612da..2029b0143 100644
--- a/src/Renci.SshNet/Abstractions/SocketAbstraction.cs
+++ b/src/Renci.SshNet/Abstractions/SocketAbstraction.cs
@@ -386,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);
diff --git a/src/Renci.SshNet/Sftp/SftpFileStream.cs b/src/Renci.SshNet/Sftp/SftpFileStream.cs
index fa697d0f0..ecb424567 100644
--- a/src/Renci.SshNet/Sftp/SftpFileStream.cs
+++ b/src/Renci.SshNet/Sftp/SftpFileStream.cs
@@ -509,7 +509,7 @@ public override int Read(byte[] buffer, int offset, int count)
                     var bytesAvailableInBuffer = _bufferLen - _bufferPosition;
                     if (bytesAvailableInBuffer <= 0)
                     {
-                        var data = _session.RequestRead(_handle, (ulong)_position, (uint)_readBufferSize);
+                        var data = _session.RequestRead(_handle, (ulong) _position, (uint) _readBufferSize);
 
                         if (data.Length == 0)
                         {
@@ -726,7 +726,7 @@ public override int ReadByte()
                 // Read more data into the internal buffer if necessary.
                 if (_bufferPosition >= _bufferLen)
                 {
-                    var data = _session.RequestRead(_handle, (ulong)_position, (uint)_readBufferSize);
+                    var data = _session.RequestRead(_handle, (ulong) _position, (uint) _readBufferSize);
                     if (data.Length == 0)
                     {
                         // We've reached EOF.
@@ -829,7 +829,7 @@ public override long Seek(long offset, SeekOrigin origin)
                         if (newPosn >= (_position - _bufferPosition) &&
                            newPosn < (_position - _bufferPosition + _bufferLen))
                         {
-                            _bufferPosition = (int)(newPosn - (_position - _bufferPosition));
+                            _bufferPosition = (int) (newPosn - (_position - _bufferPosition));
                             _position = newPosn;
                             return _position;
                         }
@@ -974,7 +974,7 @@ public override void Write(byte[] buffer, int offset, int count)
                     {
                         using (var wait = new AutoResetEvent(false))
                         {
-                            _session.RequestWrite(_handle, (ulong)_position, buffer, offset, tempLen, wait);
+                            _session.RequestWrite(_handle, (ulong) _position, buffer, offset, tempLen, wait);
                         }
                     }
                     else
@@ -996,7 +996,7 @@ public override void Write(byte[] buffer, int offset, int count)
                 {
                     using (var wait = new AutoResetEvent(false))
                     {
-                        _session.RequestWrite(_handle, (ulong)(_position - _bufferPosition), GetOrCreateWriteBuffer(), 0, _bufferPosition, wait);
+                        _session.RequestWrite(_handle, (ulong) (_position - _bufferPosition), GetOrCreateWriteBuffer(), 0, _bufferPosition, wait);
                     }
 
                     _bufferPosition = 0;
@@ -1106,7 +1106,7 @@ public override void WriteByte(byte value)
                 {
                     using (var wait = new AutoResetEvent(false))
                     {
-                        _session.RequestWrite(_handle, (ulong)(_position - _bufferPosition), writeBuffer, 0, _bufferPosition, wait);
+                        _session.RequestWrite(_handle, (ulong) (_position - _bufferPosition), writeBuffer, 0, _bufferPosition, wait);
                     }
 
                     _bufferPosition = 0;
@@ -1192,7 +1192,7 @@ private void FlushWriteBuffer()
             {
                 using (var wait = new AutoResetEvent(false))
                 {
-                    _session.RequestWrite(_handle, (ulong)(_position - _bufferPosition), _writeBuffer, 0, _bufferPosition, wait);
+                    _session.RequestWrite(_handle, (ulong) (_position - _bufferPosition), _writeBuffer, 0, _bufferPosition, wait);
                 }
 
                 _bufferPosition = 0;