通过向 stdin 发送 ctrl-c 来向进程发送 SIGINT

Question

我正在寻找一种模仿终端进行一些自动化测试的方法：即启动一个进程，然后通过将数据发送到标准输入并从标准输出读取来与其交互。例如，将一些输入行发送到标准输入，包括ctrl-c和 ，ctrl-\这将导致向进程发送信号。

使用std::process::Commannd我能够将输入发送到eg cat，并且我还在stdout上看到它的输出，但是发送ctrl-c（据我所知3）不会导致SIGINT发送到shell。例如这个程序应该终止：

use std::process::{Command, Stdio};
use std::io::Write;

fn main() {
    let mut child = Command::new("sh")
        .arg("-c").arg("-i").arg("cat")
        .stdin(Stdio::piped())
        .spawn().unwrap();
    let mut stdin = child.stdin.take().unwrap();
    stdin.write(&[3]).expect("cannot send ctrl-c");
    child.wait();
}

我怀疑问题是发送ctrl-c需要一些 tty 并且通过sh -i它仅处于“交互模式”。

我是否需要成熟并使用例如termion或ncurses？

更新：我在原来的问题中混淆了 shell 和终端。我现在把这事弄清楚了。我还提到了ssh应该是的sh。

Answer 1

经过大量研究后，我发现自己做 pty fork 并不算太多工作。有pty-rs，但它有错误并且似乎没有维护。

以下代码需要的pty模块nix尚未出现在 crates.io 上，因此Cargo.toml现在需要此：

[dependencies]
nix = {git = "https://github.com/nix-rust/nix.git"}

以下代码在 tty 中运行 cat，然后从中写入/读取并发送 Ctrl-C ( 3)：

extern crate nix;

use std::path::Path;
use nix::pty::{posix_openpt, grantpt, unlockpt, ptsname};
use nix::fcntl::{O_RDWR, open};
use nix::sys::stat;
use nix::unistd::{fork, ForkResult, setsid, dup2};
use nix::libc::{STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
use std::os::unix::io::{AsRawFd, FromRawFd};
use std::io::prelude::*;
use std::io::{BufReader, LineWriter};


fn run() -> std::io::Result<()> {
    // Open a new PTY master
    let master_fd = posix_openpt(O_RDWR)?;

    // Allow a slave to be generated for it
    grantpt(&master_fd)?;
    unlockpt(&master_fd)?;

    // Get the name of the slave
    let slave_name = ptsname(&master_fd)?;

    match fork() {
        Ok(ForkResult::Child) => {
            setsid()?; // create new session with child as session leader
            let slave_fd = open(Path::new(&slave_name), O_RDWR, stat::Mode::empty())?;

            // assign stdin, stdout, stderr to the tty, just like a terminal does
            dup2(slave_fd, STDIN_FILENO)?;
            dup2(slave_fd, STDOUT_FILENO)?;
            dup2(slave_fd, STDERR_FILENO)?;
            std::process::Command::new("cat").status()?;
        }
        Ok(ForkResult::Parent { child: _ }) => {
            let f = unsafe { std::fs::File::from_raw_fd(master_fd.as_raw_fd()) };
            let mut reader = BufReader::new(&f);
            let mut writer = LineWriter::new(&f);

            writer.write_all(b"hello world\n")?;
            let mut s = String::new();
            reader.read_line(&mut s)?; // what we just wrote in
            reader.read_line(&mut s)?; // what cat wrote out
            writer.write(&[3])?; // send ^C
            writer.flush()?;
            let mut buf = [0; 2]; // needs bytewise read as ^C has no newline
            reader.read(&mut buf)?;
            s += &String::from_utf8_lossy(&buf).to_string();
            println!("{}", s);
            println!("cat exit code: {:?}", wait::wait()?); // make sure cat really exited
        }
        Err(_) => println!("error"),
    }
    Ok(())
}

fn main() {
    run().expect("could not execute command");
}

输出：

hello world
hello world
^C
cat exit code: Signaled(2906, SIGINT, false)