使用 QProcess 将 EndOfText (Ctrl-C) 发送到交互式 shell

Question

I use a QProcess to open /bin/sh or /usr/bin/bash and it's possible to write commands to the shell and read the output into my program.

The actual problem occurs when trying to send a end-of-text control signal to the shell to abort the running child process of the shell.

What I tried:

• The shell gets started in -i nteractive mode
• I use the shell-builtin set -m command to enable job control
• For debugging purposes I read out the $- variable, it seems to be himBHs
• Sending arbitrary commands usually works (eg ls )
• Sending \\x04 (end-of-transmission, Ctrl+D) works and kills the shell.

How could I appropriately kill the running process, without opening the shell again?

QProcess process;
process.start("/bin/sh", QStringList() << "-i");
process.write("set -m\necho $-\n");                 // returns himBHs
process.waitForBytesWritten();

// start a running program here (E.g. tail -f logfile)
process.write("tail -f logfile\n");

process.write("\x03");
process.write("newcommand\n");
process.waitForBytesWritten();

Running the first command inside the shell returns output on stdout, but I don' t receive anything anymore after sending the ETX and the next command, although the shell is still running ( process.state() == QProcess::Running )

1. Is there a better way to send control signals or to communicate with the child's child process?
2. What could I possibly do to start a new program inside the shell without reopening the shell again? (The reason I'm asking this is because the program is probably going to use ssh as the shell and I want it to avoid re-initiating a entirely new connection for a minor program/argument change)

Answer 1

A shell never sees Ctrl-C . It is interpreted by the (pseudo)-terminal, and converted to SIGINT , that is then acted on.

Locally, start the program in a sub-shell that reports its pid, and then use that PID to kill it directly.

#include <QtCore>
#include <signal.h>
#include <cstdio>

int getPID(const QByteArray &line) {
   int pid = 0;
   char c1, c2;
   if (sscanf(line.data(), "@@@%d@@%c%c", &pid, &c1, &c2) == 3)
      if (c1 == '@' && (c2 == '\r' || c2 == '\n')) return pid;
   return 0;
}

int main(int argc, char *argv[]) {
   auto input = QByteArray(
                    "echo _kill_me_now_ > log\n"
                    "/bin/sh -c 'echo @@@$$@@@>&2; exec tail -f log'\n"
                    "echo done\n"
                    "exit\n")
                    .split('\n');
   // tail -f will block

   QCoreApplication app(argc, argv);
   QProcess process;
   int pid = 0;

   auto const writeInputLine = [&] {
      if (input.isEmpty()) return;
      auto const line = input.takeFirst();
      puts(line.data());
      fflush(stdout);
      process.write(line);
      process.write("\n");
   };

   process.setProcessChannelMode(QProcess::SeparateChannels);
   QObject::connect(&process, &QProcess::stateChanged, [](auto state) {
      auto static const meta = QMetaEnum::fromType<QProcess::ProcessState>();
      fprintf(stderr, "State=%s\n", meta.key(state));
      fflush(stderr);
      if (state == QProcess::NotRunning) QCoreApplication::quit();
   });
   QObject::connect(&process, &QProcess::readyReadStandardError, [&] {
      auto const data = process.readAllStandardError();
      if (auto p = getPID(data)) pid = p; // we could suppress pid output here
      fputs(data.data(), stdout);
      fflush(stdout);
      if (data.endsWith("$ ")) writeInputLine();
   });
   QObject::connect(&process, &QProcess::readyReadStandardOutput, [&] {
      while (process.canReadLine()) {
         auto const line = process.readLine();
         fputs(line.data(), stdout);
         if (line.startsWith("_kill_me_now_") && pid) {
            kill(pid, SIGTERM);
            pid = 0;
         }
      }
      fflush(stdout);
   });

   process.start("/bin/sh", {"--noediting", "-i"});
   return app.exec();
}

With ssh, since you need to forward a signal to the remote process, and thus you need a remote controlling terminal ( ssh -t ). And for that you will be sending a Ctrl-C , that the remote terminal will reinterpret as a proper signal.

Answer 2

have you tried to play with the Signal and Slots for QProcess ? Here is a simple example:

test::test(QObject* p)
    : QObject (p),
      process{}
{

    connect(&process, SIGNAL(finished(int, QProcess::ExitStatus) ),
                    this, SLOT(hFinish()) );

    process.start("/bin/sh", QStringList() << "-i");
    process.write("set -m\necho $-\n");                 // returns himBHs
    process.waitForBytesWritten();

    // start a running program here (E.g. tail -f logfile)
    process.write("tail -f logfile\n");

    process.write("\x03");
    process.write("newcommand\n");
    process.waitForBytesWritten();

}

void test::hFinish()
{
    this->process.kill();
}