（C / C ++，Windows）AttachConsole和FreeConsole的问题只能运行一次

Question

I'm trying to send a ctrl+C signal to the console of another process when a button is clicked, by attaching the current process to its console, sending a ctrl+C signal, then freeing the current process from a console. This works fine the first time, but doesn't do anything the second time.

void abort(){
    AttachConsole(processInfo.dwProcessId); //processInfo is of type PROCESS_INFORMATION
    SetConsoleCtrlHandler(0, true);
    GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0);
    FreeConsole();
}

Also, even manually clicking in the console and pressing ctrl+C works the first time but not the second. Closing the console manually always works.

process.exe is a child process, and is created in exactly the same way as in this post .

---

Full code to recreate the problem (using Qt 4.8 with vs2010 compiler on windows 10 for gui/threading):

main.cpp:

#include "dialog.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Dialog w;
    w.show();

    return a.exec();
}

dialog.h:

#ifndef DIALOG_H
#define DIALOG_H

#include <QDialog>
#include "ui_dialog.h"
#include "worker.h"

namespace Ui {
class Dialog;
}

class Dialog : public QDialog
{
    Q_OBJECT

public:
    explicit Dialog(QWidget *parent = 0):
        QDialog(parent),
        ui(new Ui::Dialog),
        w(new worker()),
        t(new QThread(this))
    {
        ui->setupUi(this);
        connect(ui->startButton, SIGNAL(clicked(bool)), this, SLOT(startProcess()));
        connect(ui->abortButton, SIGNAL(clicked(bool)), this, SLOT(abortProcess()));
        connect(w, SIGNAL(finished()), t, SLOT(quit()));

        w->setup(t);
        w->moveToThread(t);
    }

    ~Dialog(){delete ui;}

private slots:
    void startProcess(){
        t->start();
    }

    void abortProcess(){
        w->abort();
        t->quit();
    }

private:
    Ui::Dialog *ui;
    worker *w;
    QThread *t;

};

#endif // DIALOG_H

worker.h:

#ifndef WORKER_H
#define WORKER_H

#include <QDebug>
#include <QObject>
#include <QThread>
#include <Windows.h>

class worker : public QObject
{
    Q_OBJECT
public:
    explicit worker(QObject *parent = 0):QObject(parent){}
    void setup(QThread *t){
        connect(t, SIGNAL(started()), this, SLOT(startProcess()));
    }
    void abort(){
        if(!AttachConsole(p.dwProcessId)) qDebug() << "AttachConsole" << GetLastError();
        if(!SetConsoleCtrlHandler(0, true)) qDebug() << "SetConsoleCtrlHandler" << GetLastError();
        if(!GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0)) qDebug() << "GenerateConsoleCtrlEvent" << GetLastError();
        if(!FreeConsole()) qDebug() << "FreeConsole" << GetLastError();
    }

private slots:
    void startProcess(){
        ZeroMemory(&p, sizeof(p));
        STARTUPINFOA s;
        SECURITY_ATTRIBUTES sec;
        HANDLE read = NULL;
        HANDLE write = NULL;

        ZeroMemory(&sec, sizeof(sec));
        sec.nLength = sizeof(SECURITY_ATTRIBUTES);
        sec.bInheritHandle = true;
        sec.lpSecurityDescriptor = NULL;

        if(!CreatePipe(&read, &write, &sec, 0)) qDebug() << "CreatePipe error" << GetLastError();
        if(!SetHandleInformation(read, HANDLE_FLAG_INHERIT, 0)) qDebug() << "SetHandleInformation error" << GetLastError();

        ZeroMemory(&s, sizeof(s));
        s.cb = sizeof(s);
        s.hStdOutput = write;
        s.hStdError = write;
        s.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
        s.dwFlags |= STARTF_USESTDHANDLES;

        if(!CreateProcessA("helloworld.exe", "helloworld", NULL, NULL, true, CREATE_NO_WINDOW, NULL, NULL, &s, &p)) qDebug() << "CreateProcessA error " << GetLastError() << "\n";

        CloseHandle(write);

        char buff[65];
        DWORD bytesRead;

        while(true){
            if(!ReadFile(read, buff, 64, &bytesRead, NULL)){
                qDebug() << "ReadFile error";
                break;
            }
            if(bytesRead > 0){
                buff[64] = '\0';
                qDebug() << QByteArray(buff);
            }
        }

        CloseHandle(p.hProcess);
        CloseHandle(p.hThread);

        emit finished();
    }

private:
    PROCESS_INFORMATION p;

signals:
    void finished();

};

#endif // WORKER_H

The UI just contains 2 buttons, startButton and abortButton. helloworld.exe is just a program that prints "Hello world!" and then waits for input. When startButton is clicked, the process is created, and the output is redirected to my program correctly. When abortButton is clicked, the process is terminated correctly. startProcess works perfectly the second time as well, but now, clicking abortButton does not work. The abort() function is called, and no error messages are printed, but the helloworld process fails to terminate, and the QThread t does not quit.

Answer 1

Given the symptoms you describe, my psychic debugging powers tell me that the target process ("process.exe") is a child of your process. Assuming that to be the case, this is your problem:

SetConsoleCtrlHandler(0, true);

As described in the documentation :

If the HandlerRoutine parameter is NULL, a TRUE value causes the calling process to ignore CTRL+C input, and a FALSE value restores normal processing of CTRL+C input. This attribute of ignoring or processing CTRL+C is inherited by child processes.

(Emphasis mine.) This means that the child processes are being launched with the option to ignore control-C already turned on.

Instead of configuring the process to ignore control-C altogether, assign a control-C handler function that returns TRUE ; such a handler will not be inherited by child processes. Alternatively, if your application is single-threaded, you could just restore the normal configuration before exiting abort():

SetConsoleCtrlHandler(0, FALSE);

---

You have now posted a MCVE. Note that I don't have Qt installed, so I had to simplify the code in order to test it. It was easy enough to reproduce the problem caused by the abort() function disabling control-C processing, but as soon as I corrected that, the code worked perfectly. Here is the simplified and corrected code, which works perfectly on my system:

#include <Windows.h>

void fail(char *msg)
{
    MessageBoxA(NULL, msg, "Oops", MB_OK);
    ExitProcess(1);
}

PROCESS_INFORMATION p;

BOOL WINAPI HandlerRoutine(
  _In_ DWORD dwCtrlType
)
{
    if (dwCtrlType == CTRL_C_EVENT) return TRUE;
    return FALSE;
}


void abortProcess(void)
{
    static BOOL handler_assigned = FALSE;
    if (handler_assigned)
    {
        if (!SetConsoleCtrlHandler(HandlerRoutine, false)) fail("Removing handler routine failed");
    }
    if (!AttachConsole(p.dwProcessId)) fail("AttachConsole");
    if (!SetConsoleCtrlHandler(HandlerRoutine, true)) fail("SetConsoleCtrlHandler");
    handler_assigned = TRUE;
    if (!GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0)) fail("GenerateConsoleCtrlEvent");
    if (!FreeConsole()) fail("FreeConsole");
}

DWORD WINAPI startProcess(LPVOID * dummy)
{
    ZeroMemory(&p, sizeof(p));
    STARTUPINFOA s;
    SECURITY_ATTRIBUTES sec;
    HANDLE read = NULL;
    HANDLE write = NULL;

    ZeroMemory(&sec, sizeof(sec));
    sec.nLength = sizeof(SECURITY_ATTRIBUTES);
    sec.bInheritHandle = true;
    sec.lpSecurityDescriptor = NULL;

    if(!CreatePipe(&read, &write, &sec, 0)) fail("CreatePipe error");
    if(!SetHandleInformation(read, HANDLE_FLAG_INHERIT, 0)) fail("SetHandleInformation error");

    ZeroMemory(&s, sizeof(s));
    s.cb = sizeof(s);
    s.hStdOutput = write;
    s.hStdError = write;
    s.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    s.dwFlags |= STARTF_USESTDHANDLES;

    if(!CreateProcessA("test1.exe", "helloworld", NULL, NULL, true, CREATE_NO_WINDOW, NULL, NULL, &s, &p)) 
    {
        fail("CreateProcessA error ");
    }

    CloseHandle(write);

    char buff[65];
    DWORD bytesRead;

    while(true){
        if(!ReadFile(read, buff, 64, &bytesRead, NULL)){
            DWORD dw = GetLastError();
            if (dw == 0x0000006d) break;
            fail("ReadFile error");
        }
        if(bytesRead > 0){
            buff[64] = '\0';
            MessageBoxA(NULL, buff, "Output", MB_OK);
        }
    }

    MessageBox(NULL, L"Child has exited", L"Good news", MB_OK);
    CloseHandle(p.hProcess);
    CloseHandle(p.hThread);
    return 0;
}

int CALLBACK WinMain(
  _In_ HINSTANCE hInstance,
  _In_ HINSTANCE hPrevInstance,
  _In_ LPSTR     lpCmdLine,
  _In_ int       nCmdShow
)
{
    HANDLE thread;

    for (;;)
    {
        MessageBox(NULL, L"Press OK to launch child", L"so39616404", MB_OK);
        thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)startProcess, NULL, 0, NULL);
        if (thread == NULL) fail("CreateThread error");
        MessageBox(NULL, L"Press OK to kill child", L"so39616404", MB_OK);
        abortProcess();
        if (WaitForSingleObject(thread, INFINITE) != WAIT_OBJECT_0) fail("Wait error");
    }
}

Note that it proved necessary to reconfigure the handler routine after attaching to each new console, otherwise the parent process died along with the child when the control-C was generated. I'm not sure whether it is actually necessary to remove the handler routine before re-adding it, but it seems safest.

If your MCVE still doesn't work, please edit your post to show the corrected version. (There might be some sort of undesired interaction with Qt, I suppose.)