fix(unix): retry EINTR in poll/select/read

Fixes #212.

read_single_key treats any Err(Interrupted) from read_single_key_impl
as Ctrl-C and forwards it via libc::raise(SIGINT). That's correct only
for the synthesized Err(Interrupted) read_bytes returns when it sees a
\x03 byte. EINTR returned by poll/select/read because of an unrelated
signal (SIGCHLD, SIGWINCH, etc.) takes the same path and incorrectly
kills the program with SIGINT.

Retry EINTR inside the syscall wrappers so Err(Interrupted) reaching
read_single_key unambiguously means a \x03 byte was read.

Author: jh-block

src/unix_term.rs

@@ -157,43 +157,53 @@ 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 {
+                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 {
+                    continue;
+                }
+                return Err(err);
+            }
+            return Ok(libc::FD_ISSET(fd, &read_fd_set));
         }
     }
 }
@@ -231,21 +241,27 @@ fn read_single_char(fd: RawFd) -> io::Result<Option<char>> {
 // If successful, return the number of bytes read.
 // Will return an error if nothing was read, i.e when called at end of file.
 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);
+        }
     }
 }