ssh: handle Window size changes on Windows. (#421)

tmds · web-flow · commit 8ba5d820e304 · 2025-07-11T17:33:11.000+02:00
diff --git a/src/ssh/Program.cs b/src/ssh/Program.cs
@@ -131,7 +131,6 @@ static async Task<int> ExecuteAsync(string destination, string[] command, bool f
         command.Length == 0 ? await client.ExecuteShellAsync(executeOptions)
                             : await client.ExecuteAsync(string.Join(" ", command), executeOptions);
 
-    using IDisposable? updateWindowSize = allocateTerminal && !Console.IsOutputRedirected ? UpdateTerminalSize(process) : null;
     Task[] tasks = new[]
     {
                 PrintToConsole(process),
@@ -166,6 +165,19 @@ static async Task ReadInputFromConsole(RemoteProcess process)
     {
         using IStandardInputReader reader = CreateConsoleInReader(process.HasTerminal);
 
+        if (process.HasTerminal)
+        {
+            reader.WindowSizeChanged += (width, height) =>
+            {
+                try
+                {
+                    process.SetTerminalSize(width, height);
+                }
+                catch
+                { }
+            };
+        }
+
         char[] buffer = new char[100 * 1024];
         try
         {
@@ -217,26 +229,6 @@ static void PrintExceptions(Task[] tasks)
     return null;
 }
 
-static IDisposable? UpdateTerminalSize(RemoteProcess process)
-{
-    if (OperatingSystem.IsWindows())
-    {
-        return null;
-    }
-    else
-    {
-        return PosixSignalRegistration.Create(PosixSignal.SIGWINCH, ctx =>
-        {
-            try
-            {
-                process.SetTerminalSize(Console.WindowWidth, Console.WindowHeight);
-            }
-            catch
-            { }
-        });
-    }
-}
-
 static IStandardInputReader CreateConsoleInReader(bool forTerminal)
 {
     if (OperatingSystem.IsWindows())
@@ -370,4 +362,5 @@ static SshConfigSettings CreateSshConfigSettings(string[] options)
 interface IStandardInputReader : IDisposable
 {
     ValueTask<int> ReadAsync(Memory<char> buffer, CancellationToken cancellationToken = default);
+    event Action<int, int> WindowSizeChanged;
 }
diff --git a/src/ssh/UnixStandardInputReader.cs b/src/ssh/UnixStandardInputReader.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Net.Sockets;
+using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -11,6 +12,30 @@ sealed partial class UnixStandardInputReader : IStandardInputReader
     private readonly Encoding _encoding;
     private readonly Decoder _decoder;
     private readonly Socket _socket;
+    private readonly IDisposable? _sigWinchHandler;
+    private Action<int, int>? _windowSizeChanged;
+
+    public event Action<int, int>? WindowSizeChanged
+    {
+        add
+        {
+            _windowSizeChanged += value;
+
+            if (_sigWinchHandler is not null)
+            {
+                value?.Invoke(Console.WindowWidth, Console.WindowHeight);
+            }
+        }
+        remove
+        {
+            _windowSizeChanged -= value;
+        }
+    }
+
+    private void EmitWindowSizeChanged(int width, int height)
+    {
+        _windowSizeChanged?.Invoke(width, height);
+    }
 
     public UnixStandardInputReader(bool forTerminal)
     {
@@ -23,6 +48,9 @@ public UnixStandardInputReader(bool forTerminal)
                 // This makes a cursor position read to disable CANON mode.
                 _ = Console.CursorTop;
                 Console.TreatControlCAsInput = true;
+
+                // Register for window size changed.
+                _sigWinchHandler = PosixSignalRegistration.Create(PosixSignal.SIGWINCH, ctx => EmitWindowSizeChanged(Console.WindowWidth, Console.WindowHeight));
             }
         }
 
@@ -44,5 +72,7 @@ public async ValueTask<int> ReadAsync(Memory<char> buffer, CancellationToken can
     }
 
     public void Dispose()
-    { }
+    {
+        _sigWinchHandler?.Dispose();
+    }
 }
diff --git a/src/ssh/WindowsInterop.cs b/src/ssh/WindowsInterop.cs
@@ -22,26 +22,68 @@ internal static partial class WindowsInterop
     public const int STD_OUTPUT_HANDLE = -11;
     public const int STD_INPUT_HANDLE = -10;
 
-    [LibraryImport("kernel32.dll", SetLastError = true)]
+    [LibraryImport(Kernel32, SetLastError = true)]
     [return: MarshalAs(UnmanagedType.Bool)]
     public static partial bool GetConsoleMode(IntPtr handle, out uint mode);
 
-    [LibraryImport("kernel32.dll", SetLastError = true)]
+    [LibraryImport(Kernel32, SetLastError = true)]
     [return: MarshalAs(UnmanagedType.Bool)]
     public static partial bool SetConsoleMode(IntPtr handle, uint mode);
 
-    [LibraryImport("kernel32.dll", SetLastError = true)]
+    [LibraryImport(Kernel32, SetLastError = true)]
     public static partial IntPtr GetStdHandle(int handle);
 
     [LibraryImport(Kernel32, SetLastError = true)]
     [return: MarshalAs(UnmanagedType.Bool)]
     public static partial bool CancelIoEx(IntPtr handle, IntPtr lpOverlapped);
 
     [LibraryImport(Kernel32, SetLastError = true)]
-    internal static unsafe partial int ReadFile(
+    public static unsafe partial int ReadFile(
         IntPtr handle,
         byte* bytes,
         int numBytesToRead,
         out int numBytesRead,
         IntPtr mustBeZero);
+
+    public const int KEY_EVENT = 0x1;
+    public const int WINDOW_BUFFER_SIZE_EVENT = 0x4;
+
+    [LibraryImport(Kernel32, EntryPoint = "ReadConsoleInputW", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public unsafe static partial bool ReadConsoleInput(IntPtr hConsoleInput, INPUT_RECORD* buffer, int length, out int numberOfEventsRead);
+
+    [StructLayout(LayoutKind.Explicit)]
+    public struct INPUT_RECORD
+    {
+        [FieldOffset(0)]
+        public ushort EventType;
+        [FieldOffset(4)]
+        public KEY_EVENT_RECORD KeyEvent;
+        [FieldOffset(4)]
+        public WINDOW_BUFFER_SIZE_RECORD WindowBufferSizeEvent;
+    };
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct KEY_EVENT_RECORD
+    {
+        public int KeyDown;
+        public short RepeatCount;
+        public short VirtualKeyCode;
+        public short VirtualScanCode;
+        public char uChar;
+        public int ControlKeyState;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct COORD
+    {
+        public short X;
+        public short Y;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct WINDOW_BUFFER_SIZE_RECORD
+    {
+        public COORD Size;
+    }
 }
diff --git a/src/ssh/WindowsStandardInputReader.cs b/src/ssh/WindowsStandardInputReader.cs
@@ -20,6 +20,29 @@ sealed class WindowsStandardInputReader : IStandardInputReader
     private readonly WindowsConsoleModeConfig? _stdInConfig;
     private bool _reading;
     private bool _convertLineEndings;
+    private bool _readConsole;
+    private Action<int, int>? _windowSizeChanged;
+
+    public event Action<int, int>? WindowSizeChanged
+    {
+        add
+        {
+            _windowSizeChanged += value;
+            if (_readConsole)
+            {
+                value?.Invoke(Console.WindowWidth, Console.WindowHeight);
+            }
+        }
+        remove
+        {
+            _windowSizeChanged -= value;
+        }
+    }
+
+    private void EmitWindowSizeChanged(int width, int height)
+    {
+        _windowSizeChanged?.Invoke(width, height);
+    }
 
     public WindowsStandardInputReader(bool forTerminal)
     {
@@ -28,6 +51,7 @@ public WindowsStandardInputReader(bool forTerminal)
             _stdInConfig = forTerminal ? WindowsConsoleModeConfig.Configure(STD_INPUT_HANDLE, TerminalEnableStdInFlags, TerminalDisableStdInFlags)
                                        : WindowsConsoleModeConfig.Configure(STD_INPUT_HANDLE, NoTerminalEnableStdInFlags, NoTerminalDisableStdInFlags);
             _convertLineEndings = !forTerminal;
+            _readConsole = forTerminal;
         }
 
         _handle = GetStdHandle(STD_INPUT_HANDLE);
@@ -48,45 +72,90 @@ private unsafe int Read(Memory<char> buffer, CancellationToken cancellationToken
     {
         cancellationToken.ThrowIfCancellationRequested();
 
-        bool readSuccess;
-
         _reading = true;
         // Note: this poor man's cancellation may cause characters to get lost.
         //       we don't care about that because the application exists.
         using var ctr = cancellationToken.UnsafeRegister(o => ((WindowsStandardInputReader)o!).CancelIO(), this);
+        int charsWritten = _readConsole ? ReadConsole(_handle, buffer.Span) : Readfile(_handle, buffer);
+        _reading = false;
+
+        if (charsWritten == -1)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            int errorCode = Marshal.GetLastPInvokeError();
+            throw new Win32Exception(errorCode);
+        }
+
+        return charsWritten;
+    }
+
+    private unsafe int Readfile(IntPtr hConsoleInput, Memory<char> buffer)
+    {
         byte[] bytes = new byte[_encoding.GetMaxByteCount(buffer.Length)];
         int bytesRead;
         fixed (byte* ptr = bytes)
         {
-            readSuccess = (0 != ReadFile(_handle, ptr, buffer.Length, out bytesRead, IntPtr.Zero));
+            bool readSuccess = 0 != ReadFile(_handle, ptr, buffer.Length, out bytesRead, IntPtr.Zero);
+            if (!readSuccess)
+            {
+                return -1;
+            }
         }
-        _reading = false;
+        Span<byte> bytesReadSpan = bytes.AsSpan(0, bytesRead);
+        if (_convertLineEndings)
+        {
+            if (bytesReadSpan.EndsWith("\r\n"u8))
+            {
+                bytesReadSpan = bytesReadSpan[..^1];
+                bytesReadSpan[^1] = (byte)'\n';
+            }
+            else if (bytesReadSpan.EndsWith("\r"u8))
+            {
+                bytesReadSpan[^1] = (byte)'\n';
+            }
+        }
+        _decoder.Convert(bytesReadSpan, buffer.Span, flush: false, out int bytesUsed, out int charsRead, out bool completed);
+        Debug.Assert(bytesReadSpan.Length == bytesUsed);
+        return charsRead;
+    }
 
-        if (readSuccess)
+    private unsafe int ReadConsole(IntPtr hConsoleInput, Span<char> buffer)
+    {
+        Span<INPUT_RECORD> inputRecords = stackalloc INPUT_RECORD[Math.Min(buffer.Length, 1024)];
+        while (true)
         {
-            Span<byte> bytesReadSpan = bytes.AsSpan(0, bytesRead);
-            if (_convertLineEndings)
+            int numEventsRead;
+            fixed (INPUT_RECORD* ptr = inputRecords)
             {
-                if (bytesReadSpan.EndsWith("\r\n"u8))
+                bool readSuccess = ReadConsoleInput(_handle, ptr, inputRecords.Length, out numEventsRead);
+                if (!readSuccess)
                 {
-                    bytesReadSpan = bytesReadSpan[..^1];
-                    bytesReadSpan[^1] = (byte)'\n';
+                    return -1;
                 }
-                else if (bytesReadSpan.EndsWith("\r"u8))
+            }
+
+            int charsWritten = 0;
+            foreach (INPUT_RECORD record in inputRecords.Slice(0, numEventsRead))
+            {
+                switch (record.EventType)
                 {
-                    bytesReadSpan[^1] = (byte)'\n';
+                    case KEY_EVENT:
+                        if (record.KeyEvent.KeyDown != 0 && record.KeyEvent.uChar != 0)
+                        {
+                            buffer[charsWritten++] = record.KeyEvent.uChar;
+                        }
+                        break;
+                    case WINDOW_BUFFER_SIZE_EVENT:
+                        EmitWindowSizeChanged(record.WindowBufferSizeEvent.Size.X, record.WindowBufferSizeEvent.Size.Y);
+                        break;
                 }
             }
-            _decoder.Convert(bytesReadSpan, buffer.Span, flush: false, out int bytesUsed, out int charsUsed, out bool completed);
-            Debug.Assert(bytesReadSpan.Length == bytesUsed);
-            return charsUsed;
-        }
-        else
-        {
-            cancellationToken.ThrowIfCancellationRequested();
 
-            int errorCode = Marshal.GetLastPInvokeError();
-            throw new Win32Exception(errorCode);
+            if (charsWritten > 0)
+            {
+                return charsWritten;
+            }
         }
     }
 
