aboutsummaryrefslogtreecommitdiff
path: root/vendor/portable-pty/src/unix.rs
diff options
context:
space:
mode:
authorOgulcan Celik <ogulcancelik@gmail.com>2026-06-23 21:43:23 +0300
committerOgulcan Celik <ogulcancelik@gmail.com>2026-06-23 21:43:23 +0300
commita66f4c64e9d1591f042a94d6f3bef3b4298a4d1c (patch)
tree747de08b6ada4300afb4124da9feff0cc66b96a7 /vendor/portable-pty/src/unix.rs
parent5981ba426e8ed8f6785195a03cc0d8a190173e61 (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.rs414
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()
+ }
+}