change final loop to loop until a blocking condition would occur

Author: squell

src/exec/use_pty/parent.rs

@@ -235,6 +235,7 @@ pub(in crate::exec) fn exec_pty(
     // FIXME (ogsudo): Retry if `/dev/tty` is revoked.
 
     // Flush the terminal
+    closure.tty_pipe.right().set_nonblocking()?;
     closure.tty_pipe.flush_left().ok();
 
     // Restore the terminal settings

src/exec/use_pty/pipe/mod.rs

@@ -104,20 +104,19 @@ impl<L: Read + Write + AsFd, R: Read + Write + AsFd> Pipe<L, R> {
         let source = &mut self.right;
         let sink = &mut self.left;
 
-        // Remove bytes from the right buffer and write them to the left buffer;
-        // then flush the left buffer.
+        // Flush the ring buffer, then process any eventual bytes still in-flight.
+        buffer.internal.remove(sink)?;
 
         if buffer.write_handle.is_active() {
-            // There may still be data in flight, read until EOF
+            let mut buf = [0u8; RingBuffer::LEN];
             loop {
-                buffer.internal.remove(sink)?;
-                buffer.internal.insert(source)?;
-                if !buffer.internal.is_full() {
-                    break;
+                match source.read(&mut buf) {
+                    Ok(read_bytes) => sink.write_all(&buf[..read_bytes])?,
+                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => break,
+                    Err(e) => return Err(e),
                 }
             }
         }
-        buffer.internal.remove(sink)?;
 
         sink.flush()
     }

src/exec/use_pty/pipe/ring_buffer.rs

@@ -10,7 +10,7 @@ pub(super) struct RingBuffer {
 
 impl RingBuffer {
     /// The size of the internal storage of the ring buffer.
-    const LEN: usize = 8 * 1024;
+    pub(super) const LEN: usize = 8 * 1024;
 
     /// Create a new, empty buffer.
     pub(super) fn new() -> Self {

src/system/term/mod.rs

@@ -97,6 +97,22 @@ impl PtyLeader {
 
         Ok(())
     }
+
+    pub(crate) fn set_nonblocking(&self) -> io::Result<()> {
+        let fd = self.file.as_fd();
+        // SAFETY: these two calls to fcntl are memory safe (and the file descriptor is valid as well)
+        unsafe {
+            let flags = cerr(libc::fcntl(fd.as_raw_fd(), libc::F_GETFL))?;
+
+            // Set the O_NONBLOCK flag
+            cerr(libc::fcntl(
+                fd.as_raw_fd(),
+                libc::F_SETFL,
+                flags | libc::O_NONBLOCK,
+            ))?;
+        }
+        Ok(())
+    }
 }
 
 impl io::Read for PtyLeader {