Spawning a shell into portable_pty

[seabass-space]

Hello! I was interested in created an embedded terminal for my own app, and came across portable_pty as a possible library. I was able to get the example whoami.rs to work well! However, when I tried to spawn a shell into the pty, it ends up hanging.

Here is the code:

use portable_pty::{CommandBuilder, PtySize, PtySystem, NativePtySystem};
use anyhow::Error;

fn main() -> Result<(), Error> {
    // Use the native pty implementation for the system
    let pty_system = NativePtySystem::default();

    // Create a new pty
    let mut pair = pty_system.openpty(PtySize {
        rows: 24,
        cols: 80,
        pixel_width: 0,
        pixel_height: 0,
    })?;

    // Spawn a shell into the pty
    let command = CommandBuilder::new("bash");
    let mut child = pair.slave.spawn_command(command)?;
    drop(pair.slave);

    // Read and parse output from the pty with reader
    let mut reader = pair.master.try_clone_reader()?;

    // Send data to the pty by writing to the master
    writeln!(pair.master, "ls -l\r\n")?;
    drop(pair.master);

    let mut out = String::new();
    reader.read_to_string(&mut out)?;
    println!("{}", out);
    
    println!("{}", child.wait()?);
    Ok(())
}

System: macOS 12.4

What I want for it to do is for it to enter a bash environment and run ls -l, however after running, the programming never ends up completing. Is it even possible to spawn shell into a pseudo terminal, or do I need to do more reading into what I'm doing? I am really new to this pseudo terminal world, I apologize!

Thank you so much!

[wez]

The issue is that the kernel hasn't flagged the stdin stream as having reached EOF so bash is waiting for the next line of input, so the read_to_string call is blocked waiting for bash to output more or signal EOF.

You can force the kernel to recognize EOF by sending EOT (\x04) at the end of your input:

writeln!(pair.master, "ls -l\r\n\x04")?;

[wez]

The reason that EOF isn't signalled is because the master end of the pty is used for both read and write, so dropping just the write side doesn't close the underlying handle: you need it open to continue reading from it.

[seabass-space]

Thank you so much for the quick response and explanation! It was very helpful!

[walidkorchi]

The issue is that the kernel hasn't flagged the stdin stream as having reached EOF so bash is waiting for the next line of input, so the read_to_string call is blocked waiting for bash to output more or signal EOF.

You can force the kernel to recognize EOF by sending EOT (\x04) at the end of your input:

writeln!(pair.master, "ls -l\r\n\x04")?;

Something I've tried on Linux, and yet no result. Can this be different in other operating systems?
PS: I'm on Linux.

[uwejan]

Hello @wez
I am having the same issue, Say i wish to run su with args of - jason and wanting to keep the session running with both read and write.
// Obtain the writer.
// When the writer is dropped, EOF will be sent to
// the program that was spawned.
// It is important to take the writer even if you don't
// send anything to its stdin so that EOF can be
// generated, otherwise you risk deadlocking yourself.
This part in the examples is a bit confusing me, whereas i wish to keep both read and write .

[wez]

This question was primarily about detecting termination of a single execution. In that context, you must drop the writer to signal EOF in order for the program to terminate.
You don't have to drop it immediately, but you do need to drop it when you are done sending data so that you can detect EOF.

[uwejan]

@wez Hey, Thank you for taking a look on this :)

        let mut cmd = CommandBuilder::new("su");
        cmd.args(&["-", "ubuntu"]);
        let child = pair.slave.spawn_command(cmd.clone()).unwrap();
        let  reader = pair.master.try_clone_reader().unwrap();

        let writer = pair.master.take_writer().unwrap();
        let  lines = smol::io::BufReader::new(smol::Unblock::new(reader)).lines();
        
     ....dealing with `lines` as stream to display stdout
     
     then somewhere in my app calling `writer.as_mut().write("password".as_bytes()).unwrap()`
     The app crashes.
        

My question; I know I might be missing something here or there.
using writer, am I good to keep writing to the session? And will reader be my stdout as well?