fix(unix): retry EINTR in poll/select/read so unrelated signals don't surface as spurious key events

`read_single_key_impl` blocks in `poll`/`select` on the tty fd. Any
signal that interrupts that syscall — SIGCHLD from a dying child,
SIGWINCH from a terminal resize, etc. — currently propagates as
`io::ErrorKind::Interrupted`, which `read_single_key` then treats as
'the user pressed Ctrl-C' and forwards by calling `libc::raise(SIGINT)`
on the process. With the default SIGINT handler this kills the program
with exit code 130; with cliclack-style consumers it cancels the prompt.

The original intent of `Err(Interrupted)` is to signal a Ctrl-C byte
(`\\x03`) read from the tty, which `read_bytes` synthesizes
explicitly. Real EINTR from a signal is unrelated and should be retried
per the standard idiom.

This patch retries EINTR inside the syscall wrappers (`poll_fd`,
`select_fd`, `read_bytes`) so `Err(Interrupted)` reaching
`read_single_key` unambiguously means a Ctrl-C byte was read, and
unrelated signals are transparent to callers.

Repro before this patch: any program that fork+execs a child and uses
a console-based prompt (cliclack, dialoguer, etc.) shortly after the
child exits will randomly bail at the prompt because SIGCHLD interrupts
`select` mid-prompt.

Author: jh-block

src/unix_term.rs

@@ -157,43 +157,57 @@ fn poll_fd(fd: RawFd, timeout: i32) -> io::Result<bool> {
         events: libc::POLLIN,
         revents: 0,
     };
-    let ret = unsafe { libc::poll(&mut pollfd as *mut _, 1, timeout) };
-    if ret < 0 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(pollfd.revents & libc::POLLIN != 0)
+    loop {
+        let ret = unsafe { libc::poll(&mut pollfd as *mut _, 1, timeout) };
+        if ret < 0 {
+            let err = io::Error::last_os_error();
+            if err.kind() == io::ErrorKind::Interrupted {
+                // Interrupted by an unrelated signal (e.g. SIGCHLD, SIGWINCH);
+                // do not surface as a spurious key event. Retry the wait.
+                continue;
+            }
+            return Err(err);
+        }
+        return Ok(pollfd.revents & libc::POLLIN != 0);
     }
 }
 
 #[cfg(target_os = "macos")]
 fn select_fd(fd: RawFd, timeout: i32) -> io::Result<bool> {
     unsafe {
-        let mut read_fd_set: libc::fd_set = mem::zeroed();
+        loop {
+            let mut read_fd_set: libc::fd_set = mem::zeroed();
 
-        let mut timeout_val;
-        let timeout = if timeout < 0 {
-            ptr::null_mut()
-        } else {
-            timeout_val = libc::timeval {
-                tv_sec: (timeout / 1000) as _,
-                tv_usec: (timeout * 1000) as _,
+            let mut timeout_val;
+            let timeout = if timeout < 0 {
+                ptr::null_mut()
+            } else {
+                timeout_val = libc::timeval {
+                    tv_sec: (timeout / 1000) as _,
+                    tv_usec: (timeout * 1000) as _,
+                };
+                &mut timeout_val
             };
-            &mut timeout_val
-        };
-
-        libc::FD_ZERO(&mut read_fd_set);
-        libc::FD_SET(fd, &mut read_fd_set);
-        let ret = libc::select(
-            fd + 1,
-            &mut read_fd_set,
-            ptr::null_mut(),
-            ptr::null_mut(),
-            timeout,
-        );
-        if ret < 0 {
-            Err(io::Error::last_os_error())
-        } else {
-            Ok(libc::FD_ISSET(fd, &read_fd_set))
+
+            libc::FD_ZERO(&mut read_fd_set);
+            libc::FD_SET(fd, &mut read_fd_set);
+            let ret = libc::select(
+                fd + 1,
+                &mut read_fd_set,
+                ptr::null_mut(),
+                ptr::null_mut(),
+                timeout,
+            );
+            if ret < 0 {
+                let err = io::Error::last_os_error();
+                if err.kind() == io::ErrorKind::Interrupted {
+                    // Interrupted by an unrelated signal (e.g. SIGCHLD, SIGWINCH);
+                    // do not surface as a spurious key event. Retry the wait.
+                    continue;
+                }
+                return Err(err);
+            }
+            return Ok(libc::FD_ISSET(fd, &read_fd_set));
         }
     }
 }
@@ -230,22 +244,34 @@ fn read_single_char(fd: RawFd) -> io::Result<Option<char>> {
 // Similar to libc::read. Read count bytes into slice buf from descriptor fd.
 // If successful, return the number of bytes read.
 // Will return an error if nothing was read, i.e when called at end of file.
+//
+// Note: this function returns `ErrorKind::Interrupted` *only* to signal that
+// the user typed Ctrl-C (i.e. the first byte read was `\x03`). Real EINTR
+// from `libc::read` (caused by an unrelated signal interrupting the syscall)
+// is retried internally, so callers can treat `Err(Interrupted)` as
+// unambiguously "Ctrl-C was pressed".
 fn read_bytes(fd: RawFd, buf: &mut [u8], count: u8) -> io::Result<u8> {
-    let read = unsafe { libc::read(fd, buf.as_mut_ptr() as *mut _, count as usize) };
-    if read < 0 {
-        Err(io::Error::last_os_error())
-    } else if read == 0 {
-        Err(io::Error::new(
-            io::ErrorKind::UnexpectedEof,
-            "Reached end of file",
-        ))
-    } else if buf[0] == b'\x03' {
-        Err(io::Error::new(
-            io::ErrorKind::Interrupted,
-            "read interrupted",
-        ))
-    } else {
-        Ok(read as u8)
+    loop {
+        let read = unsafe { libc::read(fd, buf.as_mut_ptr() as *mut _, count as usize) };
+        if read < 0 {
+            let err = io::Error::last_os_error();
+            if err.kind() == io::ErrorKind::Interrupted {
+                continue;
+            }
+            return Err(err);
+        } else if read == 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::UnexpectedEof,
+                "Reached end of file",
+            ));
+        } else if buf[0] == b'\x03' {
+            return Err(io::Error::new(
+                io::ErrorKind::Interrupted,
+                "read interrupted",
+            ));
+        } else {
+            return Ok(read as u8);
+        }
     }
 }