Sending ctrl + z doesn't work on windows

[hellow554]

I try to send a ctrl + z to sisterm to suspend a running linux process on the other end of the serial line.

But unfortunately the key doesn't go through.
Here's the output of the getch example:

Ctrl('v')
Ctrl('c')
Ctrl('x')
Null <-- should be Ctrl('z')

Do you know, whether that's a limiation of windows?
On linux this works flawlessly.

[kumavale]

Hello, hellow554!
Thanks for the Issue.

Indeed ctrl + z did not work as expected.
But in my environment, I got the following error instead of Key::Null:

Windows stdin in console mode does not support non-UTF-16 input; encountered unpaired surrogate

---

getch-rs/src/lib.rs

Line 128 in 6282214

match source.read(&mut buf) {

ctrl + z represents EOF on Windows.
The read function expects UTF16 as input, but EOF seems to result in invalid input.
A workaround is to use read_to_string to take it as a string, but since we want to take it as a byte sequence, this idea is not usable.

So I confirmed that using winapi::um::consoleapi::ReadConsoleA works fine on Windows.

Ctrl('z')

I still don't understand why the error message appears in my environment but Key::Null in yours.
I'm worried that even ReadConsoleA will be Key::Null depending on the environment. 🤔
Observed to be Key::Null in MinGW.
I haven't found a detailed source, but according to ChatGPT, read() seems to return Ok(0) or Err.

[kumavale]

Rust's standard IO library cannot detect ctrl + z as an input.
Using WinAPI's ReadConsoleA() and ReadConsoleW(), ctrl + z can be detected, but multi-byte characters (e.g. あä🚀) cannot be handled as expected.

@@ -116,7 +116,6 @@ impl Getch {
     #[allow(clippy::unused_io_amount)]
     pub fn getch(&self) -> Result<Key, std::io::Error> {
         let source = &mut std::io::stdin();
-        let mut buf: [u8; 2] = [0; 2];

         if self.leftover.borrow().is_some() {
             // we have a leftover byte, use it
@@ -125,7 +124,28 @@ impl Getch {
             return parse_key(c, &mut source.bytes());
         }

-        match source.read(&mut buf) {
+        let (read, buf) = {
+            #[cfg(windows)]
+            unsafe {
+                let input_handle = GetStdHandle(STD_INPUT_HANDLE);
+                let mut buffer: [u8; 2] = [0; 2];
+                let mut chars_read = 0;
+                winapi::um::consoleapi::ReadConsoleA(
+                    input_handle,
+                    buffer.as_mut_ptr() as *mut _,
+                    buffer.len() as _,
+                    &mut chars_read,
+                    std::ptr::null_mut());
+                (Ok(chars_read), buffer)
+            }
+            #[cfg(not(windows))]
+            {
+                let mut buffer: [u8; 2] = [0; 2];
+                (source.read(&mut buffer), buffer)
+            }
+        };
+
+        match read {
             Ok(0) => Ok(Key::Null),
             Ok(1) => match buf[0] {
                 b'\x1B' => Ok(Key::Esc),

[kumavale]

I guess I should parse ReadConsoleW() as UTF-16, huh?

[hellow554]

Sadly, I have close to zero knowledge about windows programming, but that sounds good to me?
As you might know, there's the String::from_utf16 method if you need that.

[kumavale]

rust-lang/rust#112154
allows Ctrl + Z to be recognized correctly.

Then it comes back as a string of length 0, so the following pattern works.
I think that it is sufficient to judge whether the Ctrl and Z keys are pressed here.

getch-rs/src/lib.rs

Line 129 in 6282214

Ok(0) => Ok(Key::Null),