use core::future::poll_fn;
use core::pin::Pin;
use core::sync::atomic::{AtomicBool, Ordering};
use core::task::{Context, Poll, ready};
use std::fs::File;
use std::io;
use std::os::fd::{AsRawFd as _, OwnedFd, RawFd};
use std::process::Stdio;
use std::sync::Arc;
use bytes::Bytes;
use rustix::fs::{self, Mode, OFlags};
use rustix::process::{Pid, Signal};
use rustix::pty;
use rustix::termios::{self, LocalModes, Winsize};
use tokio::io::unix::AsyncFd;
use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
use tokio::net::unix::pipe::Receiver;
use tokio::process::{ChildStdout, Command};
use tokio::sync::{broadcast, mpsc};
use super::CHANNEL_CAPACITY;
use super::ansi::AnsiLines;
use super::pump::write_line;
use crate::runner::{PtyCommand, PtyError, PtyHandle, StdinWrite};
pub(super) const PTY_ROWS: u16 = 50;
pub(super) const PTY_COLS: u16 = 200;
#[cfg(target_os = "linux")]
fn open_master() -> io::Result<OwnedFd> {
use rustix::pty::OpenptFlags;
Ok(pty::openpt(
OpenptFlags::RDWR | OpenptFlags::NOCTTY | OpenptFlags::CLOEXEC,
)?)
}
#[cfg(not(target_os = "linux"))]
fn open_master() -> io::Result<OwnedFd> {
Ok(fs::open(
"/dev/ptmx",
OFlags::RDWR | OFlags::NOCTTY | OFlags::CLOEXEC,
Mode::empty(),
)?)
}
fn set_window(fd: impl rustix::fd::AsFd, rows: u16, cols: u16) -> io::Result<()> {
Ok(termios::tcsetwinsize(
fd,
Winsize {
ws_row: rows,
ws_col: cols,
ws_xpixel: 0,
ws_ypixel: 0,
},
)?)
}
fn redraw_group(named: Option<Pid>, sheep_pid: u32) -> io::Result<Pid> {
named
.or_else(|| Pid::from_raw(i32::try_from(sheep_pid).ok()?))
.ok_or_else(|| {
io::Error::new(
io::ErrorKind::InvalidInput,
format!("pid {sheep_pid} is not a signallable process id"),
)
})
}
fn ask_for_a_redraw(fd: impl rustix::fd::AsFd, sheep_pid: u32) -> io::Result<()> {
let named = termios::tcgetpgrp(fd);
if let Err(error) = &named {
tracing::debug!(%error, "this terminal names no foreground group");
}
let group = redraw_group(named.ok(), sheep_pid)?;
Ok(rustix::process::kill_process_group(group, Signal::WINCH)?)
}
pub(super) struct PtyMaster {
fd: Arc<AsyncFd<OwnedFd>>,
closed: Arc<AtomicBool>,
}
impl PtyMaster {
fn register(master: OwnedFd) -> io::Result<Self> {
let flags = fs::fcntl_getfl(&master)?;
fs::fcntl_setfl(&master, flags | OFlags::NONBLOCK)?;
#[allow(deprecated, reason = "register needs a newer tokio floor")]
let fd = AsyncFd::new(master)?;
Ok(Self {
fd: Arc::new(fd),
closed: Arc::new(AtomicBool::new(false)),
})
}
pub(super) fn from_file(file: File) -> io::Result<Self> {
if !termios::isatty(&file) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"a carried pty master is not a terminal",
));
}
Self::register(OwnedFd::from(file))
}
pub(super) fn raw_fd(&self) -> RawFd {
self.fd.get_ref().as_raw_fd()
}
}
pub(super) fn open() -> io::Result<(PtyMaster, OwnedFd)> {
let master = open_master()?;
pty::grantpt(&master)?;
pty::unlockpt(&master)?;
let name = pty::ptsname(&master, Vec::new())?;
let slave = fs::open(
name.as_c_str(),
OFlags::RDWR | OFlags::NOCTTY | OFlags::CLOEXEC,
Mode::empty(),
)?;
set_window(&slave, PTY_ROWS, PTY_COLS)?;
Ok((PtyMaster::register(master)?, slave))
}
pub(super) fn attach(command: &mut Command) -> io::Result<PtyMaster> {
let (master, slave) = open()?;
command.stdin(Stdio::from(slave.try_clone()?));
command.stdout(Stdio::from(slave.try_clone()?));
command.stderr(Stdio::from(slave));
crate::sys::take_terminal_on_exec(command.as_std_mut());
Ok(master)
}
pub(super) enum Stdout {
Pipe(ChildStdout),
Carried(Receiver),
Terminal(AnsiLines<PtyReader>),
}
impl AsyncRead for Stdout {
fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>,
) -> Poll<io::Result<()>> {
match self.get_mut() {
Self::Pipe(pipe) => Pin::new(pipe).poll_read(cx, buf),
Self::Carried(pipe) => Pin::new(pipe).poll_read(cx, buf),
Self::Terminal(lines) => Pin::new(lines).poll_read(cx, buf),
}
}
}
impl PtyMaster {
pub(super) fn into_reader(self, tap: Arc<broadcast::Sender<Bytes>>) -> PtyReader {
PtyReader { master: self, tap }
}
pub(super) fn writer(&self, sheep_pid: u32) -> PtyWriter {
PtyWriter {
fd: Arc::clone(&self.fd),
pending: 0,
sheep_pid,
}
}
}
const PTY_TAP_CAPACITY: usize = 64;
pub(super) fn wire(
master: PtyMaster,
whispers: mpsc::Receiver<StdinWrite>,
sheep_pid: u32,
) -> (Stdout, PtyHandle) {
let tap = Arc::new(broadcast::channel(PTY_TAP_CAPACITY).0);
let (control, commands) = mpsc::channel(CHANNEL_CAPACITY);
let handle = PtyHandle::new(&tap, control, Arc::clone(&master.closed));
spawn_pty_pump(master.writer(sheep_pid), whispers, commands);
let stdout = Stdout::Terminal(AnsiLines::new(master.into_reader(tap)));
(stdout, handle)
}
fn spawn_pty_pump(
mut writer: PtyWriter,
mut whispers: mpsc::Receiver<StdinWrite>,
mut commands: mpsc::Receiver<PtyCommand>,
) {
tokio::spawn(async move {
let (mut whispers_open, mut commands_open) = (true, true);
while whispers_open || commands_open {
tokio::select! {
whisper = whispers.recv(), if whispers_open => match whisper {
Some(request) => write_line(&mut writer, b'\r', request).await,
None => whispers_open = false,
},
command = commands.recv(), if commands_open => match command {
Some(command) => writer.serve(command).await,
None => commands_open = false,
},
}
}
});
}
pub(super) const PTY_WRITE_MAX: usize = 1023;
fn within_terminal_buffer(len: usize) -> io::Result<()> {
if len > PTY_WRITE_MAX {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
format!("a line of {len} bytes is over the {PTY_WRITE_MAX} a terminal holds"),
));
}
Ok(())
}
pub(super) struct PtyWriter {
fd: Arc<AsyncFd<OwnedFd>>,
pending: usize,
sheep_pid: u32,
}
impl PtyWriter {
async fn serve(&mut self, command: PtyCommand) {
match command {
PtyCommand::Input { bytes, done } => {
if done.is_closed() {
return;
}
let _ = done.send(self.write_raw(&bytes).await);
}
PtyCommand::Resize { rows, cols, done } => {
let result = set_window(self.fd.get_ref(), rows, cols)
.map_err(|error| PtyError::Failed(error.to_string()));
if result.is_ok()
&& let Err(error) = ask_for_a_redraw(self.fd.get_ref(), self.sheep_pid)
{
tracing::warn!(
pid = self.sheep_pid,
%error,
"a resize could not ask the sheep to redraw"
);
}
let _ = done.send(result);
}
}
}
async fn write_raw(&mut self, bytes: &[u8]) -> Result<(), PtyError> {
self.check_line(bytes)
.map_err(|error| PtyError::Failed(error.to_string()))?;
let mut rest = bytes;
while !rest.is_empty() {
let piece = &rest[..rest.len().min(PTY_WRITE_MAX)];
let wrote = poll_fn(|cx| self.poll_put(cx, piece))
.await
.map_err(|error| PtyError::Failed(error.to_string()))?;
rest = &rest[wrote..];
}
Ok(())
}
fn check_line(&mut self, bytes: &[u8]) -> io::Result<()> {
let cooked = termios::tcgetattr(self.fd.get_ref())?
.local_modes
.contains(LocalModes::ICANON);
if !cooked {
self.pending = 0;
return Ok(());
}
let longest = bytes
.split_inclusive(|byte| ends_line(*byte))
.enumerate()
.map(|(index, line)| line.len() + if index == 0 { self.pending } else { 0 })
.max()
.unwrap_or(0);
within_terminal_buffer(longest)
}
fn poll_put(&mut self, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
loop {
let mut ready = ready!(self.fd.poll_write_ready(cx))?;
let wrote =
ready.try_io(|fd| rustix::io::write(fd.get_ref(), buf).map_err(io::Error::from));
if let Ok(result) = wrote {
if let Ok(count) = result {
self.note_typed(&buf[..count]);
}
return Poll::Ready(result);
}
}
}
fn note_typed(&mut self, typed: &[u8]) {
self.pending = match typed.iter().rposition(|byte| ends_line(*byte)) {
Some(end) => typed.len() - end - 1,
None => self.pending + typed.len(),
};
}
}
fn ends_line(byte: u8) -> bool {
matches!(byte, b'\n' | b'\r')
}
impl AsyncWrite for PtyWriter {
fn poll_write(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<io::Result<usize>> {
let this = self.get_mut();
within_terminal_buffer(buf.len())?;
this.check_line(buf)?;
this.poll_put(cx, buf)
}
fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
Poll::Ready(Ok(()))
}
fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
Poll::Ready(Ok(()))
}
}
pub(super) struct PtyReader {
master: PtyMaster,
tap: Arc<broadcast::Sender<Bytes>>,
}
impl PtyReader {
fn tee(&self, fresh: &[u8]) {
if self.tap.receiver_count() > 0 {
let _ = self.tap.send(Bytes::copy_from_slice(fresh));
}
}
}
impl Drop for PtyReader {
fn drop(&mut self) {
self.master.closed.store(true, Ordering::Release);
}
}
impl AsyncRead for PtyReader {
fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>,
) -> Poll<io::Result<()>> {
let this = self.get_mut();
let before = buf.filled().len();
loop {
let mut ready = ready!(this.master.fd.poll_read_ready(cx))?;
let read = ready.try_io(|fd| {
rustix::io::read(fd.get_ref(), buf.initialize_unfilled()).map_err(io::Error::from)
});
match read {
Ok(Ok(count)) => {
buf.advance(count);
if count == 0 {
this.master.closed.store(true, Ordering::Release);
} else {
this.tee(&buf.filled()[before..]);
}
return Poll::Ready(Ok(()));
}
Ok(Err(error))
if error.raw_os_error() == Some(rustix::io::Errno::IO.raw_os_error()) =>
{
this.master.closed.store(true, Ordering::Release);
return Poll::Ready(Ok(()));
}
Ok(Err(error)) => return Poll::Ready(Err(error)),
Err(_would_block) => {}
}
}
}
}
#[cfg(test)]
mod tests {
use core::time::Duration;
use tokio::io::AsyncReadExt as _;
use tokio::time::timeout;
use super::*;
const MASTER_DEADLINE: Duration = Duration::from_secs(5);
const WRITTEN: &[u8] = b"bye\n";
const SEEN: &[u8] = b"bye\r\n";
#[tokio::test]
async fn a_master_hands_back_what_its_slave_wrote_and_then_ends() {
let (master, slave) = open().unwrap();
let mut reader = master.into_reader(Arc::new(broadcast::channel(1).0));
rustix::io::write(&slave, WRITTEN).unwrap();
let mut buf = [0u8; 64];
let mut seen = Vec::new();
timeout(MASTER_DEADLINE, async {
while seen != SEEN {
let read = reader
.read(&mut buf)
.await
.expect("the master must answer a read");
assert_ne!(read, 0, "the master ended at {seen:?} before {SEEN:?}");
seen.extend_from_slice(&buf[..read]);
}
})
.await
.expect("the master never handed back what its slave wrote");
drop(slave);
let mut rest = Vec::new();
timeout(MASTER_DEADLINE, reader.read_to_end(&mut rest))
.await
.expect("the reader never saw the end of the stream")
.expect("the end of the stream must not be an error");
assert!(rest.is_empty(), "the master read {rest:?} past its own end");
}
#[cfg(target_os = "linux")]
#[tokio::test]
async fn a_linux_master_hands_back_queued_bytes_before_it_ends_with_eio() {
let (master, slave) = open().unwrap();
rustix::io::write(&slave, WRITTEN).unwrap();
drop(slave);
let mut seen = Vec::new();
timeout(
MASTER_DEADLINE,
master
.into_reader(Arc::new(broadcast::channel(1).0))
.read_to_end(&mut seen),
)
.await
.expect("the reader never saw the end of the stream")
.expect("`EIO` must end the stream, not fail it");
assert_eq!(seen, SEEN);
}
#[test]
fn a_write_is_refused_one_byte_past_what_a_terminal_holds() {
assert!(within_terminal_buffer(PTY_WRITE_MAX).is_ok());
let refusal = within_terminal_buffer(PTY_WRITE_MAX + 1).unwrap_err();
assert_eq!(
refusal.to_string(),
"a line of 1024 bytes is over the 1023 a terminal holds"
);
}
#[test]
fn a_terminal_that_names_a_group_is_asked_there() {
assert_eq!(
redraw_group(Pid::from_raw(4242), 111).unwrap(),
Pid::from_raw(4242).unwrap()
);
}
#[test]
fn a_terminal_that_names_none_falls_back_to_the_sheeps_own_group() {
assert_eq!(
redraw_group(None, 111).unwrap(),
Pid::from_raw(111).unwrap()
);
}
#[test]
fn a_pid_with_no_kill_form_is_refused() {
assert_eq!(
redraw_group(None, 0).unwrap_err().to_string(),
"pid 0 is not a signallable process id"
);
assert!(redraw_group(None, u32::MAX).is_err());
}
}