Struct RawTerminal

pub struct RawTerminal<F: AsRawFd> { /* private fields */ }

A structure that will automatically reset terminal mode when dropped

Implementations

impl<F: AsRawFd> RawTerminal<F>

pub fn new(file: F) -> Result<Self>

Switch the terminal to raw mode and return a wrapper that will exit raw mode automatically when dropped

pub fn new_allow_failure(file: F) -> Self

Like new(), but ignores any failure. Useful for switching to raw mode only if that’s actually possible.

Examples found in repository

examples/pty.rs (line 58)

fn main() -> io::Result<()> {
    let mut args = env::args().skip(1);

    let cmd = match args.next() {
        Some(cmd) => cmd,
        None => {
            eprintln!("Usage: pty <cmd>");
            return Ok(());
        }
    };

    // Step 1: Create PTY
    let (mut master, slave) = pseudoterm::openpty(
        &OpenptyOptions::new()
            .with_size(Winsize {
                cols: 80,
                rows: 32,
            })
    )?;

    // Step 2: Launch command
    let mut child = pseudoterm::prepare_cmd(slave, &mut Command::new(cmd))?
        .args(args)
        .spawn()?;

    // Step 3: Forward I/O
    let mut clone = master.try_clone()?;
    thread::spawn(move || {
        let stdin = io::stdin();
        let mut stdin = stdin.lock();

        let mut buf = [0; 1024];
        loop {
            let res = match stdin.read(&mut buf) {
                Ok(0) => break,
                Ok(n) => clone.write_all(&buf[..n]),
                Err(err) => Err(err)
            };
            if let Err(err) = res {
                eprintln!("{}", err);
                return;
            }
        }
    });

    let stdout = io::stdout();
    //let stdout = stdout.lock();
    let mut stdout = RawTerminal::new_allow_failure(stdout);

    let mut buf = [0; 1024];
    loop {
        match master.read(&mut buf) {
            Ok(0) | Err(_) => break,
            Ok(n) => {
                stdout.write_all(&buf[..n])?;
                stdout.flush()?;
            }
        }
    }

    // Step 4: Wait until the process is completely dead
    child.wait()?;

    Ok(())
}

Trait Implementations

impl<F: AsRawFd> Deref for RawTerminal<F>

type Target = F

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<F: AsRawFd> DerefMut for RawTerminal<F>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<F: AsRawFd> Drop for RawTerminal<F>

fn drop(&mut self)

Executes the destructor for this type.