Posso enviar um ctrl-C (SIGINT) para um aplicativo no Windows?

Eu (no passado) escrito multi-plataforma (Windows / Unix) aplicações que, quando iniciado a partir da linha de comando, manipulados um digitado pelo usuário Ctrl- Ccombinação da mesma forma (ou seja, para encerrar o aplicativo limpa).

É possível no Windows enviar um Ctrl- C/ SIGINT / equivalente a um processo de outro processo (não relacionado) para solicitar que ele seja encerrado de forma limpa (dando-lhe a oportunidade de organizar recursos, etc.)?

O mais próximo que cheguei de uma solução é o aplicativo de terceiros SendSignal . O autor lista o código-fonte e um executável. Eu verifiquei que ele funciona em janelas de 64 bits (executando como um programa de 32 bits, eliminando outro programa de 32 bits), mas não descobri como incorporar o código em um programa do Windows (seja de 32 bits ou 64 bits).

Como funciona:

Depois de vasculhar muito o depurador, descobri que o ponto de entrada que realmente faz o comportamento associado a um sinal como ctrl-break é kernel32! CtrlRoutine. A função tinha o mesmo protótipo de ThreadProc, portanto, pode ser usada com CreateRemoteThread diretamente, sem a necessidade de injetar código. No entanto, esse não é um símbolo exportado! Ele está em endereços diferentes (e até tem nomes diferentes) em diferentes versões do Windows. O que fazer?

Aqui está a solução que finalmente encontrei. Eu instalo um manipulador de controle de console para meu aplicativo e, em seguida, gere um sinal ctrl-break para meu aplicativo. Quando meu manipulador é chamado, eu olho novamente para o topo da pilha para descobrir os parâmetros passados ​​para kernel32! BaseThreadStart. Eu pego o primeiro parâmetro, que é o endereço inicial desejado do thread, que é o endereço do kernel32! CtrlRoutine. Em seguida, volto do meu manipulador, indicando que manipulei o sinal e meu aplicativo não deve ser encerrado. De volta ao thread principal, espero até que o endereço de kernel32! CtrlRoutine seja recuperado. Depois de obtê-lo, crio um thread remoto no processo de destino com o endereço inicial descoberto. Isso faz com que os manipuladores de ctrl no processo de destino sejam avaliados como se ctrl-break tivesse sido pressionado!

O bom é que apenas o processo de destino é afetado e qualquer processo (mesmo um processo em janela) pode ser direcionado. Uma desvantagem é que meu pequeno aplicativo não pode ser usado em um arquivo em lote, pois ele o matará quando enviar o evento ctrl-break para descobrir o endereço de kernel32! CtrlRoutine.

(Preceda-o startse estiver executando em um arquivo em lote.)

Fiz algumas pesquisas em torno desse tópico, que se tornaram mais populares do que eu esperava. A resposta de KindDragon foi um dos pontos principais.

Escrevi uma postagem mais longa no blog sobre o assunto e criei um programa de demonstração funcional, que demonstra o uso desse tipo de sistema para fechar um aplicativo de linha de comando em algumas maneiras legais. Esse post também lista links externos que usei em minha pesquisa.

Resumindo, esses programas de demonstração fazem o seguinte:

• Inicie um programa com uma janela visível usando .Net, esconda-se com pinvoke, execute por 6 segundos, mostre com pinvoke, pare com .Net.
• Inicie um programa sem janela usando .Net, execute por 6 segundos, pare anexando o console e emitindo ConsoleCtrlEvent

Edit: A solução alterada da KindDragon para aqueles que estão interessados ​​no código aqui e agora. Se você planeja iniciar outros programas após interromper o primeiro, deve reativar o manuseio de Ctrl-C, caso contrário, o próximo processo herdará o estado desativado do pai e não responderá a Ctrl-C.

[DllImport("kernel32.dll", SetLastError = true)]
static extern bool AttachConsole(uint dwProcessId);

[DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
static extern bool FreeConsole();

[DllImport("kernel32.dll")]
static extern bool SetConsoleCtrlHandler(ConsoleCtrlDelegate HandlerRoutine, bool Add);

delegate bool ConsoleCtrlDelegate(CtrlTypes CtrlType);

// Enumerated type for the control messages sent to the handler routine
enum CtrlTypes : uint
{
  CTRL_C_EVENT = 0,
  CTRL_BREAK_EVENT,
  CTRL_CLOSE_EVENT,
  CTRL_LOGOFF_EVENT = 5,
  CTRL_SHUTDOWN_EVENT
}

[DllImport("kernel32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool GenerateConsoleCtrlEvent(CtrlTypes dwCtrlEvent, uint dwProcessGroupId);

public void StopProgram(Process proc)
{
  //This does not require the console window to be visible.
  if (AttachConsole((uint)proc.Id))
  {
    // Disable Ctrl-C handling for our program
    SetConsoleCtrlHandler(null, true); 
    GenerateConsoleCtrlEvent(CtrlTypes.CTRL_C_EVENT, 0);

    //Moved this command up on suggestion from Timothy Jannace (see comments below)
    FreeConsole();

    // Must wait here. If we don't and re-enable Ctrl-C
    // handling below too fast, we might terminate ourselves.
    proc.WaitForExit(2000);

    //Re-enable Ctrl-C handling or any subsequently started
    //programs will inherit the disabled state.
    SetConsoleCtrlHandler(null, false); 
  }
}

Além disso, planeje uma solução de contingência se AttachConsole()ou o sinal enviado falhar, por exemplo, dormindo, então:

if (!proc.HasExited)
{
  try
  {
    proc.Kill();
  }
  catch (InvalidOperationException e){}
}

Acho que estou um pouco atrasado nessa questão, mas vou escrever algo de qualquer maneira para qualquer pessoa com o mesmo problema. Esta é a mesma resposta que dei a esta pergunta.

Meu problema era que eu gostaria que meu aplicativo fosse um aplicativo GUI, mas os processos executados deveriam ser executados em segundo plano, sem nenhuma janela de console interativo anexada. Acho que essa solução também deve funcionar quando o processo pai é um processo de console. Você pode ter que remover o sinalizador "CREATE_NO_WINDOW".

Consegui resolver isso usando GenerateConsoleCtrlEvent () com um aplicativo wrapper. A parte complicada é apenas que a documentação não é realmente clara sobre como exatamente pode ser usado e as armadilhas com ele.

Minha solução é baseada no que está descrito aqui . Mas isso também não explicava realmente todos os detalhes e com um erro, então aqui estão os detalhes de como fazer isso funcionar.

Crie um novo aplicativo auxiliar "Helper.exe". Este aplicativo ficará entre o seu aplicativo (pai) e o processo filho que você deseja fechar. Ele também criará o processo filho real. Você deve ter este processo de "intermediário" ou GenerateConsoleCtrlEvent () falhará.

Use algum tipo de mecanismo IPC para comunicar do pai para o processo auxiliar que o auxiliar deve fechar o processo filho. Quando o auxiliar obtém este evento, ele chama "GenerateConsoleCtrlEvent (CTRL_BREAK, 0)" que fecha a si mesmo e ao processo filho. Eu mesmo usei um objeto de evento para isso, que o pai conclui quando deseja cancelar o processo filho.

Para criar seu Helper.exe, crie-o com CREATE_NO_WINDOW e CREATE_NEW_PROCESS_GROUP. E ao criar o processo filho, crie-o sem sinalizadores (0), o que significa que ele derivará o console de seu pai. Deixar de fazer isso fará com que ele ignore o evento.

É muito importante que cada etapa seja executada assim. Tenho tentado todos os tipos de combinações, mas essa combinação é a única que funciona. Você não pode enviar um evento CTRL_C. Ele retornará sucesso, mas será ignorado pelo processo. CTRL_BREAK é o único que funciona. Realmente não importa, pois ambos chamarão ExitProcess () no final.

Você também não pode chamar GenerateConsoleCtrlEvent () com um ID de grupo de processo do ID do processo filho, permitindo diretamente que o processo auxiliar continue ativo. Isso também falhará.

Passei um dia inteiro tentando fazer isso funcionar. Esta solução funciona para mim, mas se alguém tiver mais alguma coisa a acrescentar, faça-o. Eu procurei por toda a rede muitas pessoas com problemas semelhantes, mas nenhuma solução definitiva para o problema. Como GenerateConsoleCtrlEvent () funciona também é um pouco estranho, então se alguém souber mais detalhes sobre ele, compartilhe.

Editar:

Para um aplicativo GUI, a maneira "normal" de lidar com isso no desenvolvimento do Windows seria enviar uma mensagem WM_CLOSE para a janela principal do processo.

Para um aplicativo de console, você precisa usar SetConsoleCtrlHandler para adicionar um CTRL_C_EVENT.

Se o aplicativo não respeitar isso, você pode chamar TerminateProcess .

De alguma forma, GenerateConsoleCtrlEvent()retorne um erro se você chamá-lo para outro processo, mas você pode anexar a outro aplicativo de console e enviar o evento para todos os processos filho.

void SendControlC(int pid)
{
    AttachConsole(pid); // attach to process console
    SetConsoleCtrlHandler(NULL, TRUE); // disable Control+C handling for our app
    GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0); // generate Control+C event
}

Aqui está o código que uso em meu aplicativo C ++.

Pontos positivos:

• Funciona a partir do aplicativo de console
• Funciona a partir do serviço Windows
• Sem necessidade de atraso
• Não fecha o aplicativo atual

Pontos negativos:

• O console principal é perdido e um novo é criado (ver FreeConsole )
• A troca de console deu resultados estranhos ...

// Inspired from http://stackoverflow.com/a/15281070/1529139
// and http://stackoverflow.com/q/40059902/1529139
bool signalCtrl(DWORD dwProcessId, DWORD dwCtrlEvent)
{
    bool success = false;
    DWORD thisConsoleId = GetCurrentProcessId();
    // Leave current console if it exists
    // (otherwise AttachConsole will return ERROR_ACCESS_DENIED)
    bool consoleDetached = (FreeConsole() != FALSE);

    if (AttachConsole(dwProcessId) != FALSE)
    {
        // Add a fake Ctrl-C handler for avoid instant kill is this console
        // WARNING: do not revert it or current program will be also killed
        SetConsoleCtrlHandler(nullptr, true);
        success = (GenerateConsoleCtrlEvent(dwCtrlEvent, 0) != FALSE);
        FreeConsole();
    }

    if (consoleDetached)
    {
        // Create a new console if previous was deleted by OS
        if (AttachConsole(thisConsoleId) == FALSE)
        {
            int errorCode = GetLastError();
            if (errorCode == 31) // 31=ERROR_GEN_FAILURE
            {
                AllocConsole();
            }
        }
    }
    return success;
}

Exemplo de uso:

DWORD dwProcessId = ...;
if (signalCtrl(dwProcessId, CTRL_C_EVENT))
{
    cout << "Signal sent" << endl;
}

        void SendSIGINT( HANDLE hProcess )
        {
            DWORD pid = GetProcessId(hProcess);
            FreeConsole();
            if (AttachConsole(pid))
            {
                // Disable Ctrl-C handling for our program
                SetConsoleCtrlHandler(NULL, true);

                GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0); // SIGINT

                //Re-enable Ctrl-C handling or any subsequently started
                //programs will inherit the disabled state.
                SetConsoleCtrlHandler(NULL, false);

                WaitForSingleObject(hProcess, 10000);
            }
        }

Deve ficar bem claro, porque no momento não é. Existe uma versão modificada e compilada de SendSignal para enviar Ctrl-C (por padrão, envia apenas Ctrl + Break). Aqui estão alguns binários:

(2014-3-7): Criei as versões de 32 e 64 bits com Ctrl-C, é chamado SendSignalCtrlC.exe e você pode baixá-lo em: https://dl.dropboxusercontent.com/u/49065779/ sendignalctrlc / x86 / SendSignalCtrlC.exe https://dl.dropboxusercontent.com/u/49065779/sendsignalctrlc/x86_64/SendSignalCtrlC.exe - Juraj Michalak

Também espelhei esses arquivos para o caso de:
versão de 32 bits: https://www.dropbox.com/s/r96jxglhkm4sjz2/SendSignalCtrlC.exe?dl=0 versão de
64 bits: https://www.dropbox.com /s/hhe0io7mcgcle1c/SendSignalCtrlC64.exe?dl=0

Isenção de responsabilidade: eu não construí esses arquivos. Nenhuma modificação foi feita nos arquivos originais compilados. A única plataforma testada é a Windows 7 de 64 bits. Recomenda-se adaptar a fonte disponível em http://www.latenighthacking.com/projects/2003/sendSignal/ e compilá-la você mesmo.

Em Java, usando JNA com a biblioteca Kernel32.dll, semelhante a uma solução C ++. Executa o método principal CtrlCSender como um Processo que apenas obtém o console do processo para enviar o evento Ctrl + C e gera o evento. Como é executado separadamente sem um console, o evento Ctrl + C não precisa ser desativado e ativado novamente.

CtrlCSender.java - Baseado nas respostas do Nemo1024 e KindDragon .

Dado um ID de processo conhecido, este aplicativo sem console anexará o console do processo de destino e gerará um evento CTRL + C nele.

import com.sun.jna.platform.win32.Kernel32;    

public class CtrlCSender {

    public static void main(String args[]) {
        int processId = Integer.parseInt(args[0]);
        Kernel32.INSTANCE.AttachConsole(processId);
        Kernel32.INSTANCE.GenerateConsoleCtrlEvent(Kernel32.CTRL_C_EVENT, 0);
    }
}

Aplicativo principal - executa CtrlCSender como um processo sem console separado

ProcessBuilder pb = new ProcessBuilder();
pb.command("javaw", "-cp", System.getProperty("java.class.path", "."), CtrlCSender.class.getName(), processId);
pb.redirectErrorStream();
pb.redirectOutput(ProcessBuilder.Redirect.INHERIT);
pb.redirectError(ProcessBuilder.Redirect.INHERIT);
Process ctrlCProcess = pb.start();
ctrlCProcess.waitFor();

Sim. O windows-killprojeto faz exatamente o que você deseja:

windows-kill -SIGINT 1234

Uma solução que encontrei aqui é muito simples se você tiver o python 3.x disponível em sua linha de comando. Primeiro, salve um arquivo (ctrl_c.py) com o conteúdo:

import ctypes
import sys

kernel = ctypes.windll.kernel32

pid = int(sys.argv[1])
kernel.FreeConsole()
kernel.AttachConsole(pid)
kernel.SetConsoleCtrlHandler(None, 1)
kernel.GenerateConsoleCtrlEvent(0, 0)
sys.exit(0)

Então ligue:

python ctrl_c.py 12345

Se isso não funcionar, recomendo experimentar o projeto windows-kill: https://github.com/alirdn/windows-kill

Graças à resposta de Jimhark e outras respostas aqui, encontrei uma maneira de fazer isso no PowerShell:

$ProcessID = 1234
$MemberDefinition = '
    [DllImport("kernel32.dll")]public static extern bool FreeConsole();
    [DllImport("kernel32.dll")]public static extern bool AttachConsole(uint p);
    [DllImport("kernel32.dll")]public static extern bool GenerateConsoleCtrlEvent(uint e, uint p);
    public static void SendCtrlC(uint p) {
        FreeConsole();
        if (AttachConsole(p)) {
            GenerateConsoleCtrlEvent(0, p);
            FreeConsole();
        }
        AttachConsole(uint.MaxValue);
    }'
Add-Type -Name 'dummyName' -Namespace 'dummyNamespace' -MemberDefinition $MemberDefinition
[dummyNamespace.dummyName]::SendCtrlC($ProcessID) }

O que fez as coisas funcionarem foi enviar o GenerateConsoleCtrlEvent para o grupo de processos desejado em vez de all processes that share the console of the calling processe o AttachConsole de volta the console of the parent of the current process.

Um amigo meu sugeriu uma maneira completamente diferente de resolver o problema e funcionou para mim. Use um vbscript como abaixo. Ele inicia um aplicativo, deixe-o funcionar por 7 segundos e feche-o usando ctrl + c .

'Exemplo de VBScript

Set WshShell = WScript.CreateObject("WScript.Shell")

WshShell.Run "notepad.exe"

WshShell.AppActivate "notepad"

WScript.Sleep 7000

WshShell.SendKeys "^C"

Eu achei tudo isso muito complicado e usado SendKeys para enviar uma CTRL- C(janela ou seja cmd.exe) de teclas para a janela de linha de comando como uma solução alternativa.

// Send [CTRL-C] to interrupt a batch file running in a Command Prompt window, even if the Command Prompt window is not visible,
// without bringing the Command Prompt window into focus.
// [CTRL-C] will have an effect on the batch file, but not on the Command Prompt  window itself -- in other words,
// [CTRL-C] will not have the same visible effect on a Command Prompt window that isn't running a batch file at the moment
// as bringing a Command Prompt window that isn't running a batch file into focus and pressing [CTRL-C] on the keyboard.
ulong ulProcessId = 0UL;
// hwC = Find Command Prompt window HWND
GetWindowThreadProcessId (hwC, (LPDWORD) &ulProcessId);
AttachConsole ((DWORD) ulProcessId);
SetConsoleCtrlHandler (NULL, TRUE);
GenerateConsoleCtrlEvent (CTRL_C_EVENT, 0UL);
SetConsoleCtrlHandler (NULL, FALSE);
FreeConsole ();

O SIGINT pode ser enviado para o programa usando o windows-kill , por sintaxe windows-kill -SIGINT PID, onde PIDpode ser obtido no pslist da Microsoft .

Com relação à captura de SIGINTs, se seu programa estiver em Python, você pode implementar o processamento / captura de SIGINT como nesta solução .

Com base na identificação do processo, podemos enviar o sinal para o processo terminar de forma forçada ou normal ou qualquer outro sinal.

Liste todos os processos:

C:\>tasklist

Para matar o processo:

C:\>Taskkill /IM firefox.exe /F
or
C:\>Taskkill /PID 26356 /F

Detalhes:

http://tweaks.com/windows/39559/kill-processes-from-command-prompt/