RemoteProcess.StandardInputStream/StandardOutputStream: only wrap SshExceptions in IOException. (#441)

tmds · web-flow · commit 66b2b5230292 · 2025-12-08T12:26:45.000+01:00
diff --git a/README.md b/README.md
@@ -2,7 +2,7 @@
 
 # Tmds.Ssh
 
-`Tmds.Ssh` is a modern, managed .NET SSH client library for .NET 6+.
+Tmds.Ssh is a modern, managed .NET SSH client library for .NET 6+.
 
 Documentation: https://tmds.github.io/Tmds.Ssh
 
diff --git a/src/Tmds.Ssh/ISshChannel.cs b/src/Tmds.Ssh/ISshChannel.cs
@@ -13,14 +13,15 @@ interface ISshChannel
     void Abort(Exception exception);
 
     ValueTask<(ChannelReadType ReadType, int BytesRead)> ReadAsync
-            (Memory<byte>? stdoutBuffer = default,
-             Memory<byte>? stderrBuffer = default,
-            CancellationToken cancellationToken = default);
+            (Memory<byte>? stdoutBuffer,
+             Memory<byte>? stderrBuffer,
+            CancellationToken cancellationToken,
+            bool forStream = false);
 
-    ValueTask WriteAsync(ReadOnlyMemory<byte> data, CancellationToken cancellationToken = default);
-    void WriteEof(bool noThrow = false);
+    ValueTask WriteAsync(ReadOnlyMemory<byte> data, CancellationToken cancellationToken, bool forStream = false);
+    void WriteEof(bool noThrow, bool forStream);
     bool ChangeTerminalSize(int width, int height);
     bool SendSignal(string signalName);
 
-    Exception CreateCloseException();
+    SshException CreateCloseException();
 }
diff --git a/src/Tmds.Ssh/README.md b/src/Tmds.Ssh/README.md
@@ -1,4 +1,4 @@
-`Tmds.Ssh` is a modern, open-source SSH client library.
+Tmds.Ssh is a modern, open-source SSH client library.
 
 Documentation: https://tmds.github.io/Tmds.Ssh
 Release notes: https://github.com/tmds/Tmds.Ssh/releases
diff --git a/src/Tmds.Ssh/RemoteProcess.cs b/src/Tmds.Ssh/RemoteProcess.cs
@@ -311,9 +311,9 @@ internal enum ReadMode
 
     internal bool EofSent => _channel.EofSent;
 
-    private void WriteEof(bool noThrow)
+    private void WriteEof(bool noThrow, bool forStream = false)
     {
-        _channel.WriteEof(noThrow);
+        _channel.WriteEof(noThrow, forStream);
     }
 
     /// <summary>
@@ -355,9 +355,12 @@ public bool SendSignal(string signalName)
     /// <param name="buffer">The buffer to write.</param>
     /// <param name="cancellationToken">Token to cancel the operation.</param>
     public ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+        => WriteAsync(buffer, cancellationToken, forStream: false);
+
+    internal ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken, bool forStream)
     {
         ThrowIfDisposed();
-        return _channel.WriteAsync(buffer, cancellationToken);
+        return _channel.WriteAsync(buffer, cancellationToken, forStream);
     }
 
     /// <summary>
@@ -510,9 +513,11 @@ public StreamReader ReadAsStreamReader(StderrHandler stderrHandler, int bufferSi
     {
         CheckReadMode(readMode);
 
+        bool forStream = readMode == ReadMode.ReadStream;
+
         while (true)
         {
-            (ChannelReadType ReadType, int BytesRead) = await _channel.ReadAsync(stdoutBuffer, stderrBuffer, cancellationToken).ConfigureAwait(false); ;
+            (ChannelReadType ReadType, int BytesRead) = await _channel.ReadAsync(stdoutBuffer, stderrBuffer, cancellationToken, forStream).ConfigureAwait(false); ;
             switch (ReadType)
             {
                 case ChannelReadType.StandardOutput:
@@ -993,42 +998,31 @@ public override async ValueTask<int> ReadAsync(Memory<byte> buffer, Cancellation
                 return 0;
             }
 
-            try
+            while (true)
             {
-                while (true)
-                {
-                    Memory<byte>? stderrBuffer = _stderrBuffer != null ? (Memory<byte>?)_stderrBuffer : default(Memory<byte>?);
-                    (bool isError, int bytesRead) = await _process.ReadAsync(ReadMode.ReadStream, buffer, stderrBuffer, cancellationToken).ConfigureAwait(false);
+                Memory<byte>? stderrBuffer = _stderrBuffer != null ? (Memory<byte>?)_stderrBuffer : default(Memory<byte>?);
+                (bool isError, int bytesRead) = await _process.ReadAsync(ReadMode.ReadStream, buffer, stderrBuffer, cancellationToken).ConfigureAwait(false);
 
-                    if (isError)
+                if (isError)
+                {
+                    // Handle stderr data
+                    if (_stderrHandler != null && bytesRead > 0)
                     {
-                        // Handle stderr data
-                        if (_stderrHandler != null && bytesRead > 0)
-                        {
-                            await _stderrHandler.HandleBufferAsync(_stderrBuffer.AsMemory(0, bytesRead), cancellationToken).ConfigureAwait(false);
-                        }
-                        // Continue reading to get stdout data
-                        continue;
+                        await _stderrHandler.HandleBufferAsync(_stderrBuffer.AsMemory(0, bytesRead), cancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    // Continue reading to get stdout data
+                    continue;
+                }
+                else
+                {
+                    // Signal end of stream to the stderr handler.
+                    if (_stderrHandler != null && bytesRead == 0)
                     {
-                        // Signal end of stream to the stderr handler.
-                        if (_stderrHandler != null && bytesRead == 0)
-                        {
-                            await _stderrHandler.HandleBufferAsync(default, cancellationToken).ConfigureAwait(false);
-                        }
-                        return bytesRead;
+                        await _stderrHandler.HandleBufferAsync(default, cancellationToken).ConfigureAwait(false);
                     }
+                    return bytesRead;
                 }
             }
-            catch (OperationCanceledException)
-            {
-                throw;
-            }
-            catch (Exception ex)
-            {
-                throw new IOException($"Failed to read from remote process: {ex.Message}", ex);
-            }
         }
 
         public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
@@ -1103,27 +1097,14 @@ public override Task FlushAsync(CancellationToken cancellationToken = default)
             return Task.CompletedTask; // WriteAsync always flushes.
         }
 
-        public async override ValueTask WriteAsync(System.ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            try
-            {
-                await _process.WriteAsync(buffer, cancellationToken).ConfigureAwait(false);
-            }
-            catch (OperationCanceledException)
-            {
-                throw;
-            }
-            catch (Exception ex)
-            {
-                throw new IOException($"Failed to write to remote process: {ex.Message}", ex);
-            }
-        }
+        public override ValueTask WriteAsync(System.ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
+            => _process.WriteAsync(buffer, cancellationToken, forStream: true);
 
         public override void Close()
         {
             // The base Stream class calls Close for implementing Dispose.
             // We mustn't throw to avoid throwing on Dispose.
-            _process.WriteEof(noThrow: true);
+            _process.WriteEof(noThrow: true, forStream: true);
         }
     }
 }
diff --git a/src/Tmds.Ssh/SftpChannel.cs b/src/Tmds.Ssh/SftpChannel.cs
@@ -1585,7 +1585,7 @@ private async Task SendPacketsAsync()
             {
                 try
                 {
-                    await _channel.WriteAsync(packet.Data).ConfigureAwait(false);
+                    await _channel.WriteAsync(packet.Data, cancellationToken: default).ConfigureAwait(false);
                 }
                 catch
                 {
diff --git a/src/Tmds.Ssh/SshChannel.cs b/src/Tmds.Ssh/SshChannel.cs
@@ -85,7 +85,8 @@ public CancellationToken ChannelAborted
     public async ValueTask<(ChannelReadType ReadType, int BytesRead)> ReadAsync
         (Memory<byte>? stdoutBuffer = default,
         Memory<byte>? stderrBuffer = default,
-        CancellationToken cancellationToken = default)
+        CancellationToken cancellationToken = default,
+        bool forStream = false)
     {
         ThrowIfDisposed();
 
@@ -128,7 +129,7 @@ public CancellationToken ChannelAborted
                 }
             }
 
-            using Packet packet = await ReceivePacketAsync(cancellationToken);
+            using Packet packet = await ReceivePacketAsync(cancellationToken, forStream);
             MessageId messageId = packet.MessageId!.Value;
             switch (messageId)
             {
@@ -182,12 +183,12 @@ string    data
         }
     }
 
-    public void WriteEof(bool noThrow)
+    public void WriteEof(bool noThrow = false, bool forStream = false)
     {
         if (!noThrow)
         {
             ThrowIfDisposed();
-            ThrowIfAborted();
+            ThrowIfAborted(forStream);
             ThrowIfEofSent();
         }
 
@@ -255,27 +256,27 @@ static void ThrowEofSent()
         }
     }
 
-    private void ThrowIfAborted()
+    private void ThrowIfAborted(bool forStream = false)
     {
         if (_abortState >= (int)AbortState.Closed)
         {
-            ThrowCloseException();
+            ThrowCloseException(forStream);
         }
     }
 
-    private void ThrowCloseException()
+    private void ThrowCloseException(bool forStream = false)
     {
-        throw CreateCloseException();
+        throw CreateCloseException(forStream);
     }
 
-    public async ValueTask WriteAsync(ReadOnlyMemory<byte> memory, CancellationToken cancellationToken)
+    public async ValueTask WriteAsync(ReadOnlyMemory<byte> memory, CancellationToken cancellationToken = default, bool forStream = false)
     {
         ThrowIfDisposed();
         ThrowIfEofSent();
 
         while (memory.Length > 0)
         {
-            ThrowIfAborted();
+            ThrowIfAborted(forStream);
 
             int sendWindow = Volatile.Read(ref _sendWindow);
             if (sendWindow > 0)
@@ -342,7 +343,7 @@ public void Dispose()
     public void Abort(Exception exception)
         => Abort(AbortState.Aborted, exception);
 
-    public Exception CreateCloseException()
+    public SshException CreateCloseException()
         => (AbortState)_abortState switch
         {
             AbortState.ConnectionClosed => _client.CreateCloseException(),
@@ -353,6 +354,17 @@ public Exception CreateCloseException()
             _ => throw new IndexOutOfRangeException($"Unhandled state: {_abortState}."),
         };
 
+    private Exception CreateCloseException(bool forStream)
+    {
+        SshException exception = CreateCloseException();
+        // Stream methods should throw IOException. Wrap the exception.
+        if (forStream)
+        {
+            return new IOException($"SSH failure: {exception.Message}", exception);
+        }
+        return exception;
+    }
+
     private void Cancel()
         => Abort(AbortState.Canceled);
 
@@ -512,7 +524,7 @@ private void TrySendPacket(Packet packet, bool canSendWhenDisposed = false)
         }
     }
 
-    private async ValueTask<Packet> ReceivePacketAsync(CancellationToken ct)
+    private async ValueTask<Packet> ReceivePacketAsync(CancellationToken ct, bool forStream = false)
     {
         // Allow reading while in the Closed state so we can receive the peer CLOSE message.
         // After that message, the channel is completed, and TryRead returns false.
@@ -532,7 +544,7 @@ await _receiveQueue.Reader.WaitToReadAsync(ct).ConfigureAwait(false) &&
 
         if (!hasPacket || !_receiveQueue.Reader.TryRead(out Packet packet))
         {
-            throw CreateCloseException();
+            throw CreateCloseException(forStream);
         }
 
         return packet;
diff --git a/src/Tmds.Ssh/SshDataStream.cs b/src/Tmds.Ssh/SshDataStream.cs
@@ -84,48 +84,30 @@ protected override void Dispose(bool disposing)
     /// <inheritdoc />
     public override async ValueTask<int> ReadAsync(System.Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
     {
-        try
+        while (true)
         {
-            while (true)
+            (ChannelReadType ReadType, int BytesRead) = await _channel.ReadAsync(buffer, default, cancellationToken, forStream: true).ConfigureAwait(false); ;
+            switch (ReadType)
             {
-                (ChannelReadType ReadType, int BytesRead) = await _channel.ReadAsync(buffer, default, cancellationToken).ConfigureAwait(false); ;
-                switch (ReadType)
-                {
-                    case ChannelReadType.StandardOutput:
-                        return BytesRead;
-                    case ChannelReadType.Eof:
-                        return 0;
-                }
+                case ChannelReadType.StandardOutput:
+                    return BytesRead;
+                case ChannelReadType.Eof:
+                    return 0;
             }
         }
-        catch (SshException ex)
-        {
-            // TODO: move IOException wrapping into SshChannel.ReadAsync
-            throw new IOException($"Unable to transport data: {ex.Message}.", ex);
-        }
     }
 
     /// <summary>
     /// Writes end-of-file.
     /// </summary>
     public void WriteEof()
     {
-        _channel.WriteEof();
+        _channel.WriteEof(noThrow: false, forStream: true);
     }
 
     /// <inheritdoc />
-    public override async ValueTask WriteAsync(System.ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
-    {
-        try
-        {
-            await _channel.WriteAsync(buffer, cancellationToken).ConfigureAwait(false);
-        }
-        catch (SshException ex)
-        {
-            // TODO: move IOException wrapping into SshChannel.WriteAsync
-            throw new IOException($"Unable to transport data: {ex.Message}.", ex);
-        }
-    }
+    public override ValueTask WriteAsync(System.ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
+        => _channel.WriteAsync(buffer, cancellationToken, forStream: true);
 
     /// <inheritdoc />
     public override Task FlushAsync(CancellationToken cancellationToken)
diff --git a/src/Tmds.Ssh/SshSession.cs b/src/Tmds.Ssh/SshSession.cs
@@ -761,7 +761,7 @@ private void ThrowNewConnectionClosedException()
         throw CreateCloseException();
     }
 
-    internal Exception CreateCloseException()
+    internal SshException CreateCloseException()
     {
         if (_abortReason == null)
         {
diff --git a/src/docfx/index.md b/src/docfx/index.md
@@ -1,4 +1,4 @@
-`Tmds.Ssh` is a modern, open-source SSH client library for .NET.
+Tmds.Ssh is a modern, open-source SSH client library for .NET.
 
 ## Getting Started
 
diff --git a/test/Tmds.Ssh.Tests/PublicApiTest.PublicApi.DotNet.verified.txt b/test/Tmds.Ssh.Tests/PublicApiTest.PublicApi.DotNet.verified.txt
@@ -242,7 +242,7 @@ namespace Tmds.Ssh
         public System.IO.Stream StandardInputStream { get; }
         public System.IO.StreamWriter StandardInputWriter { get; }
         public void Dispose() { }
-        [System.Runtime.CompilerServices.AsyncIteratorStateMachine(typeof(Tmds.Ssh.RemoteProcess.<ReadAllLinesAsync>d__52))]
+        [System.Runtime.CompilerServices.AsyncIteratorStateMachine(typeof(Tmds.Ssh.RemoteProcess.<ReadAllLinesAsync>d__53))]
         [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
                 "isError",
                 "line"})]

Original file line number	Diff line number	Diff line change
`@@ -1585,7 +1585,7 @@ private async Task SendPacketsAsync()`
`1585`	`1585`	`{`
`1586`	`1586`	`try`
`1587`	`1587`	`{`
`1588`		`- await _channel.WriteAsync(packet.Data).ConfigureAwait(false);`
	`1588`	`+ await _channel.WriteAsync(packet.Data, cancellationToken: default).ConfigureAwait(false);`
`1589`	`1589`	`}`
`1590`	`1590`	`catch`
`1591`	`1591`	`{`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,8 @@ public CancellationToken ChannelAborted`
`85`	`85`	`public async ValueTask<(ChannelReadType ReadType, int BytesRead)> ReadAsync`
`86`	`86`	`(Memory<byte>? stdoutBuffer = default,`
`87`	`87`	`Memory<byte>? stderrBuffer = default,`
`88`		`- CancellationToken cancellationToken = default)`
	`88`	`+ CancellationToken cancellationToken = default,`
	`89`	`+ bool forStream = false)`
`89`	`90`	`{`
`90`	`91`	`ThrowIfDisposed();`
`91`	`92`
`@@ -128,7 +129,7 @@ public CancellationToken ChannelAborted`
`128`	`129`	`}`
`129`	`130`	`}`
`130`	`131`
`131`		`- using Packet packet = await ReceivePacketAsync(cancellationToken);`
	`132`	`+ using Packet packet = await ReceivePacketAsync(cancellationToken, forStream);`
`132`	`133`	`MessageId messageId = packet.MessageId!.Value;`
`133`	`134`	`switch (messageId)`
`134`	`135`	`{`
`@@ -182,12 +183,12 @@ string data`
`182`	`183`	`}`
`183`	`184`	`}`
`184`	`185`
`185`		`- public void WriteEof(bool noThrow)`
	`186`	`+ public void WriteEof(bool noThrow = false, bool forStream = false)`
`186`	`187`	`{`
`187`	`188`	`if (!noThrow)`
`188`	`189`	`{`
`189`	`190`	`ThrowIfDisposed();`
`190`		`- ThrowIfAborted();`
	`191`	`+ ThrowIfAborted(forStream);`
`191`	`192`	`ThrowIfEofSent();`
`192`	`193`	`}`
`193`	`194`
`@@ -255,27 +256,27 @@ static void ThrowEofSent()`
`255`	`256`	`}`
`256`	`257`	`}`
`257`	`258`
`258`		`- private void ThrowIfAborted()`
	`259`	`+ private void ThrowIfAborted(bool forStream = false)`
`259`	`260`	`{`
`260`	`261`	`if (_abortState >= (int)AbortState.Closed)`
`261`	`262`	`{`
`262`		`- ThrowCloseException();`
	`263`	`+ ThrowCloseException(forStream);`
`263`	`264`	`}`
`264`	`265`	`}`
`265`	`266`
`266`		`- private void ThrowCloseException()`
	`267`	`+ private void ThrowCloseException(bool forStream = false)`
`267`	`268`	`{`
`268`		`- throw CreateCloseException();`
	`269`	`+ throw CreateCloseException(forStream);`
`269`	`270`	`}`
`270`	`271`
`271`		`- public async ValueTask WriteAsync(ReadOnlyMemory<byte> memory, CancellationToken cancellationToken)`
	`272`	`+ public async ValueTask WriteAsync(ReadOnlyMemory<byte> memory, CancellationToken cancellationToken = default, bool forStream = false)`
`272`	`273`	`{`
`273`	`274`	`ThrowIfDisposed();`
`274`	`275`	`ThrowIfEofSent();`
`275`	`276`
`276`	`277`	`while (memory.Length > 0)`
`277`	`278`	`{`
`278`		`- ThrowIfAborted();`
	`279`	`+ ThrowIfAborted(forStream);`
`279`	`280`
`280`	`281`	`int sendWindow = Volatile.Read(ref _sendWindow);`
`281`	`282`	`if (sendWindow > 0)`
`@@ -342,7 +343,7 @@ public void Dispose()`
`342`	`343`	`public void Abort(Exception exception)`
`343`	`344`	`=> Abort(AbortState.Aborted, exception);`
`344`	`345`
`345`		`- public Exception CreateCloseException()`
	`346`	`+ public SshException CreateCloseException()`
`346`	`347`	`=> (AbortState)_abortState switch`
`347`	`348`	`{`
`348`	`349`	`AbortState.ConnectionClosed => _client.CreateCloseException(),`
`@@ -353,6 +354,17 @@ public Exception CreateCloseException()`
`353`	`354`	`_ => throw new IndexOutOfRangeException($"Unhandled state: {_abortState}."),`
`354`	`355`	`};`
`355`	`356`
	`357`	`+ private Exception CreateCloseException(bool forStream)`
	`358`	`+ {`
	`359`	`+ SshException exception = CreateCloseException();`
	`360`	`+ // Stream methods should throw IOException. Wrap the exception.`
	`361`	`+ if (forStream)`
	`362`	`+ {`
	`363`	`+ return new IOException($"SSH failure: {exception.Message}", exception);`
	`364`	`+ }`
	`365`	`+ return exception;`
	`366`	`+ }`
	`367`	`+`
`356`	`368`	`private void Cancel()`
`357`	`369`	`=> Abort(AbortState.Canceled);`
`358`	`370`
`@@ -512,7 +524,7 @@ private void TrySendPacket(Packet packet, bool canSendWhenDisposed = false)`
`512`	`524`	`}`
`513`	`525`	`}`
`514`	`526`
`515`		`- private async ValueTask<Packet> ReceivePacketAsync(CancellationToken ct)`
	`527`	`+ private async ValueTask<Packet> ReceivePacketAsync(CancellationToken ct, bool forStream = false)`
`516`	`528`	`{`
`517`	`529`	`// Allow reading while in the Closed state so we can receive the peer CLOSE message.`
`518`	`530`	`// After that message, the channel is completed, and TryRead returns false.`
`@@ -532,7 +544,7 @@ await _receiveQueue.Reader.WaitToReadAsync(ct).ConfigureAwait(false) &&`
`532`	`544`
`533`	`545`	`if (!hasPacket \|\| !_receiveQueue.Reader.TryRead(out Packet packet))`
`534`	`546`	`{`
`535`		`- throw CreateCloseException();`
	`547`	`+ throw CreateCloseException(forStream);`
`536`	`548`	`}`
`537`	`549`
`538`	`550`	`return packet;`
Original file line number	Diff line number	Diff line change
`@@ -761,7 +761,7 @@ private void ThrowNewConnectionClosedException()`
`761`	`761`	`throw CreateCloseException();`
`762`	`762`	`}`
`763`	`763`
`764`		`- internal Exception CreateCloseException()`
	`764`	`+ internal SshException CreateCloseException()`
`765`	`765`	`{`
`766`	`766`	`if (_abortReason == null)`
`767`	`767`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		-`Tmds.Ssh` is a modern, open-source SSH client library for .NET.
	`1`	`+Tmds.Ssh is a modern, open-source SSH client library for .NET.`
`2`	`2`
`3`	`3`	`## Getting Started`
`4`	`4`