diff options
| author | Ogulcan Celik <ogulcancelik@gmail.com> | 2026-06-23 21:43:23 +0300 |
|---|---|---|
| committer | Ogulcan Celik <ogulcancelik@gmail.com> | 2026-06-23 21:43:23 +0300 |
| commit | a66f4c64e9d1591f042a94d6f3bef3b4298a4d1c (patch) | |
| tree | 747de08b6ada4300afb4124da9feff0cc66b96a7 /vendor/portable-pty/src/unix.rs | |
| parent | 5981ba426e8ed8f6785195a03cc0d8a190173e61 (diff) | |
fix: force system conpty on windows
refs #761
Diffstat (limited to 'vendor/portable-pty/src/unix.rs')
| -rw-r--r-- | vendor/portable-pty/src/unix.rs | 414 |
1 files changed, 414 insertions, 0 deletions
diff --git a/vendor/portable-pty/src/unix.rs b/vendor/portable-pty/src/unix.rs new file mode 100644 index 00000000..cc458ce9 --- /dev/null +++ b/vendor/portable-pty/src/unix.rs @@ -0,0 +1,414 @@ +//! Working with pseudo-terminals + +use crate::{Child, CommandBuilder, MasterPty, PtyPair, PtySize, PtySystem, SlavePty}; +use anyhow::{bail, Error}; +use filedescriptor::FileDescriptor; +use libc::{self, winsize}; +use std::cell::RefCell; +use std::ffi::OsStr; +use std::io::{Read, Write}; +use std::os::fd::AsFd; +use std::os::unix::ffi::OsStrExt; +use std::os::unix::io::{AsRawFd, FromRawFd}; +use std::os::unix::process::CommandExt; +use std::path::PathBuf; +use std::{io, mem, ptr}; + +pub use std::os::unix::io::RawFd; + +#[derive(Default)] +pub struct UnixPtySystem {} + +fn openpty(size: PtySize) -> anyhow::Result<(UnixMasterPty, UnixSlavePty)> { + let mut master: RawFd = -1; + let mut slave: RawFd = -1; + + let mut size = winsize { + ws_row: size.rows, + ws_col: size.cols, + ws_xpixel: size.pixel_width, + ws_ypixel: size.pixel_height, + }; + + let result = unsafe { + // BSDish systems may require mut pointers to some args + #[allow(clippy::unnecessary_mut_passed)] + libc::openpty( + &mut master, + &mut slave, + ptr::null_mut(), + ptr::null_mut(), + &mut size, + ) + }; + + if result != 0 { + bail!("failed to openpty: {:?}", io::Error::last_os_error()); + } + + let tty_name = tty_name(slave); + + let master = UnixMasterPty { + fd: PtyFd(unsafe { FileDescriptor::from_raw_fd(master) }), + took_writer: RefCell::new(false), + tty_name, + }; + let slave = UnixSlavePty { + fd: PtyFd(unsafe { FileDescriptor::from_raw_fd(slave) }), + }; + + // Ensure that these descriptors will get closed when we execute + // the child process. This is done after constructing the Pty + // instances so that we ensure that the Ptys get drop()'d if + // the cloexec() functions fail (unlikely!). + cloexec(master.fd.as_raw_fd())?; + cloexec(slave.fd.as_raw_fd())?; + + Ok((master, slave)) +} + +impl PtySystem for UnixPtySystem { + fn openpty(&self, size: PtySize) -> anyhow::Result<PtyPair> { + let (master, slave) = openpty(size)?; + Ok(PtyPair { + master: Box::new(master), + slave: Box::new(slave), + }) + } +} + +struct PtyFd(pub FileDescriptor); +impl std::ops::Deref for PtyFd { + type Target = FileDescriptor; + fn deref(&self) -> &FileDescriptor { + &self.0 + } +} +impl std::ops::DerefMut for PtyFd { + fn deref_mut(&mut self) -> &mut FileDescriptor { + &mut self.0 + } +} + +impl Read for PtyFd { + fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> { + match self.0.read(buf) { + Err(ref e) if e.raw_os_error() == Some(libc::EIO) => { + // EIO indicates that the slave pty has been closed. + // Treat this as EOF so that std::io::Read::read_to_string + // and similar functions gracefully terminate when they + // encounter this condition + Ok(0) + } + x => x, + } + } +} + +fn tty_name(fd: RawFd) -> Option<PathBuf> { + let mut buf = vec![0 as std::ffi::c_char; 128]; + + loop { + let res = unsafe { libc::ttyname_r(fd, buf.as_mut_ptr(), buf.len()) }; + + if res == libc::ERANGE { + if buf.len() > 64 * 1024 { + // on macOS, if the buf is "too big", ttyname_r can + // return ERANGE, even though that is supposed to + // indicate buf is "too small". + return None; + } + buf.resize(buf.len() * 2, 0 as std::ffi::c_char); + continue; + } + + return if res == 0 { + let cstr = unsafe { std::ffi::CStr::from_ptr(buf.as_ptr()) }; + let osstr = OsStr::from_bytes(cstr.to_bytes()); + Some(PathBuf::from(osstr)) + } else { + None + }; + } +} + +/// On Big Sur, Cocoa leaks various file descriptors to child processes, +/// so we need to make a pass through the open descriptors beyond just the +/// stdio descriptors and close them all out. +/// This is approximately equivalent to the darwin `posix_spawnattr_setflags` +/// option POSIX_SPAWN_CLOEXEC_DEFAULT which is used as a bit of a cheat +/// on macOS. +/// On Linux, gnome/mutter leak shell extension fds to wezterm too, so we +/// also need to make an effort to clean up the mess. +/// +/// This function enumerates the open filedescriptors in the current process +/// and then will forcibly call close(2) on each open fd that is numbered +/// 3 or higher, effectively closing all descriptors except for the stdio +/// streams. +/// +/// The implementation of this function relies on `/dev/fd` being available +/// to provide the list of open fds. Any errors in enumerating or closing +/// the fds are silently ignored. +pub fn close_random_fds() { + // FreeBSD, macOS and presumably other BSDish systems have /dev/fd as + // a directory listing the current fd numbers for the process. + // + // On Linux, /dev/fd is a symlink to /proc/self/fd + if let Ok(dir) = std::fs::read_dir("/dev/fd") { + let mut fds = vec![]; + for entry in dir { + if let Some(num) = entry + .ok() + .map(|e| e.file_name()) + .and_then(|s| s.into_string().ok()) + .and_then(|n| n.parse::<libc::c_int>().ok()) + { + if num > 2 { + fds.push(num); + } + } + } + for fd in fds { + unsafe { + libc::close(fd); + } + } + } +} + +impl PtyFd { + fn resize(&self, size: PtySize) -> Result<(), Error> { + let ws_size = winsize { + ws_row: size.rows, + ws_col: size.cols, + ws_xpixel: size.pixel_width, + ws_ypixel: size.pixel_height, + }; + + if unsafe { + libc::ioctl( + self.0.as_raw_fd(), + libc::TIOCSWINSZ as _, + &ws_size as *const _, + ) + } != 0 + { + bail!( + "failed to ioctl(TIOCSWINSZ): {:?}", + io::Error::last_os_error() + ); + } + + Ok(()) + } + + fn get_size(&self) -> Result<PtySize, Error> { + let mut size: winsize = unsafe { mem::zeroed() }; + if unsafe { + libc::ioctl( + self.0.as_raw_fd(), + libc::TIOCGWINSZ as _, + &mut size as *mut _, + ) + } != 0 + { + bail!( + "failed to ioctl(TIOCGWINSZ): {:?}", + io::Error::last_os_error() + ); + } + Ok(PtySize { + rows: size.ws_row, + cols: size.ws_col, + pixel_width: size.ws_xpixel, + pixel_height: size.ws_ypixel, + }) + } + + fn spawn_command(&self, builder: CommandBuilder) -> anyhow::Result<std::process::Child> { + let configured_umask = builder.umask; + + let mut cmd = builder.as_command()?; + let controlling_tty = builder.get_controlling_tty(); + + unsafe { + cmd.stdin(self.as_stdio()?) + .stdout(self.as_stdio()?) + .stderr(self.as_stdio()?) + .pre_exec(move || { + // Clean up a few things before we exec the program + // Clear out any potentially problematic signal + // dispositions that we might have inherited + for signo in &[ + libc::SIGCHLD, + libc::SIGHUP, + libc::SIGINT, + libc::SIGQUIT, + libc::SIGTERM, + libc::SIGALRM, + ] { + libc::signal(*signo, libc::SIG_DFL); + } + + let empty_set: libc::sigset_t = std::mem::zeroed(); + libc::sigprocmask(libc::SIG_SETMASK, &empty_set, std::ptr::null_mut()); + + // Establish ourselves as a session leader. + if libc::setsid() == -1 { + return Err(io::Error::last_os_error()); + } + + // Clippy wants us to explicitly cast TIOCSCTTY using + // type::from(), but the size and potentially signedness + // are system dependent, which is why we're using `as _`. + // Suppress this lint for this section of code. + #[allow(clippy::cast_lossless)] + if controlling_tty { + // Set the pty as the controlling terminal. + // Failure to do this means that delivery of + // SIGWINCH won't happen when we resize the + // terminal, among other undesirable effects. + if libc::ioctl(0, libc::TIOCSCTTY as _, 0) == -1 { + return Err(io::Error::last_os_error()); + } + } + + close_random_fds(); + + if let Some(mask) = configured_umask { + libc::umask(mask); + } + + Ok(()) + }) + }; + + let mut child = cmd.spawn()?; + + // Ensure that we close out the slave fds that Child retains; + // they are not what we need (we need the master side to reference + // them) and won't work in the usual way anyway. + // In practice these are None, but it seems best to be move them + // out in case the behavior of Command changes in the future. + child.stdin.take(); + child.stdout.take(); + child.stderr.take(); + + Ok(child) + } +} + +/// Represents the master end of a pty. +/// The file descriptor will be closed when the Pty is dropped. +struct UnixMasterPty { + fd: PtyFd, + took_writer: RefCell<bool>, + tty_name: Option<PathBuf>, +} + +/// Represents the slave end of a pty. +/// The file descriptor will be closed when the Pty is dropped. +struct UnixSlavePty { + fd: PtyFd, +} + +/// Helper function to set the close-on-exec flag for a raw descriptor +fn cloexec(fd: RawFd) -> Result<(), Error> { + let flags = unsafe { libc::fcntl(fd, libc::F_GETFD) }; + if flags == -1 { + bail!( + "fcntl to read flags failed: {:?}", + io::Error::last_os_error() + ); + } + let result = unsafe { libc::fcntl(fd, libc::F_SETFD, flags | libc::FD_CLOEXEC) }; + if result == -1 { + bail!( + "fcntl to set CLOEXEC failed: {:?}", + io::Error::last_os_error() + ); + } + Ok(()) +} + +impl SlavePty for UnixSlavePty { + fn spawn_command( + &self, + builder: CommandBuilder, + ) -> Result<Box<dyn Child + Send + Sync>, Error> { + Ok(Box::new(self.fd.spawn_command(builder)?)) + } +} + +impl MasterPty for UnixMasterPty { + fn resize(&self, size: PtySize) -> Result<(), Error> { + self.fd.resize(size) + } + + fn get_size(&self) -> Result<PtySize, Error> { + self.fd.get_size() + } + + fn try_clone_reader(&self) -> Result<Box<dyn Read + Send>, Error> { + let fd = PtyFd(self.fd.try_clone()?); + Ok(Box::new(fd)) + } + + fn take_writer(&self) -> Result<Box<dyn Write + Send>, Error> { + if *self.took_writer.borrow() { + anyhow::bail!("cannot take writer more than once"); + } + *self.took_writer.borrow_mut() = true; + let fd = PtyFd(self.fd.try_clone()?); + Ok(Box::new(UnixMasterWriter { fd })) + } + + fn as_raw_fd(&self) -> Option<RawFd> { + Some(self.fd.0.as_raw_fd()) + } + + fn tty_name(&self) -> Option<PathBuf> { + self.tty_name.clone() + } + + fn process_group_leader(&self) -> Option<libc::pid_t> { + match unsafe { libc::tcgetpgrp(self.fd.0.as_raw_fd()) } { + pid if pid > 0 => Some(pid), + _ => None, + } + } + + fn get_termios(&self) -> Option<nix::sys::termios::Termios> { + nix::sys::termios::tcgetattr(self.fd.0.as_fd()).ok() + } +} + +/// Represents the master end of a pty. +/// EOT will be sent, and then the file descriptor will be closed when +/// the Pty is dropped. +struct UnixMasterWriter { + fd: PtyFd, +} + +impl Drop for UnixMasterWriter { + fn drop(&mut self) { + let mut t: libc::termios = unsafe { std::mem::MaybeUninit::zeroed().assume_init() }; + if unsafe { libc::tcgetattr(self.fd.0.as_raw_fd(), &mut t) } == 0 { + // EOF is only interpreted after a newline, so if it is set, + // we send a newline followed by EOF. + let eot = t.c_cc[libc::VEOF]; + if eot != 0 { + let _ = self.fd.0.write_all(&[b'\n', eot]); + } + } + } +} + +impl Write for UnixMasterWriter { + fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> { + self.fd.write(buf) + } + fn flush(&mut self) -> Result<(), io::Error> { + self.fd.flush() + } +} |
