Puis-je envoyer un ctrl-C (SIGINT) pour une application sur Windows?

La plus proche que je suis arrivé à une solution, est la SendSignal 3ème partie de l'app. L'auteur liste de code source et un fichier exécutable. J'ai vérifié qu'il fonctionne sous windows 64 bits (comme un programme 32 bits, tuant un autre programme 32 bits), mais j'ai pas trouvé comment intégrer le code dans un programme windows (32 bits ou 64 bits).

Comment cela fonctionne:

Après beaucoup de creuser autour dans le débogueur, j'ai découvert que le point d'entrée qui fait réellement le comportement associé à un signal comme ctrl-break est kernel32!CtrlRoutine. La fonction a le même prototype que ThreadProc, de sorte qu'il peut être utilisé avec CreateRemoteThread directement, sans avoir à injecter du code. Cependant, ce n'est pas un symbole exporté! C'est à des adresses différentes (et même a des noms différents) sur les différentes versions de Windows. Que faire?

Voici la solution que j'ai enfin trouvé. - Je installer une console ctrl gestionnaire pour mon application, puis générer un ctrl-pause signal pour mon application. Quand mon gestionnaire est appelé à la, je reviens sur le haut de la pile pour trouver les paramètres passés à kernel32!BaseThreadStart. Je prends le premier paramètre, qui est le début souhaitée à l'adresse du fil, qui est l'adresse de kernel32!CtrlRoutine. Alors je reviens de mon gestionnaire, indiquant que j'ai manipulé le signal et mon application ne devrait pas être terminé. De retour dans le thread principal, j'attends jusqu'à ce que l'adresse de kernel32!CtrlRoutine a été récupéré. Une fois que j'ai eu, j'ai créer une distance thread dans le processus cible avec la découverte adresse de départ. Cela provoque la touche ctrl gestionnaires dans le processus cible à être évaluées comme si ctrl-break a été pressé!

La bonne chose est que seul le processus cible est touchée, et tout (même fenêtré processus) peuvent être ciblés. Un inconvénient est que ma petite app ne peut pas être utilisé dans un fichier de commandes, car il va le tuer lorsqu'il envoie la combinaison de touches ctrl-pause événement afin de découvrir l'adresse de kernel32!CtrlRoutine.

(Faire précéder de start si en cours d'exécution dans un fichier de commandes.)

Je suppose que je suis un peu en retard sur cette question, mais je vais écrire quelque chose quand même pour quelqu'un ayant le même problème.
C'est la même réponse que j'ai donné à cette question.

Mon problème est que j'aimerais que ma demande soit d'une application graphique, mais le processus exécuté doit être exécuté en arrière-plan sans aucune console interactive de la fenêtre ci-joint. Je pense que cette solution devrait également fonctionner lorsque le processus parent est un processus de console. Vous pouvez avoir à supprimer le "CREATE_NO_WINDOW" drapeau si.

J'ai réussi à résoudre ce à l'aide de GenerateConsoleCtrlEvent() avec une application de wrapper. La partie la plus délicate est juste que la documentation n'est pas vraiment clair sur exactement comment il peut être utilisé et les pièges avec elle.

Ma solution est basée sur ce qui est décrit ici. Mais cela n'a pas vraiment l'expliquer tous les détails et avec une erreur, voici donc les détails sur la façon d'obtenir ce travail.

Créer une nouvelle application d'aide "Helper.exe". Cette application va s'asseoir entre votre application (parent) et le processus de l'enfant que vous voulez être en mesure de fermer. Il permettra aussi de créer de réels processus enfant. Vous devez avoir cet "homme du milieu" ou GenerateConsoleCtrlEvent() échouera.

Utiliser une sorte de mécanisme IPC de communiquer de la part du parent à l'aide de processus que l'aide doit fermer le processus de l'enfant. Lorsque l'assistant d'obtenir cet événement qu'il appelle "GenerateConsoleCtrlEvent(CTRL_BREAK, 0)", qui se ferme de lui-même et le processus de l'enfant. J'ai utilisé un objet d'événement de ce moi-même qui le parent se termine quand il veut annuler le processus de l'enfant.

Pour créer votre Helper.exe créer avec CREATE_NO_WINDOW et CREATE_NEW_PROCESS_GROUP. Et lors de la création de l'enfant à créer avec pas de drapeaux (0) signifie qu'elle va tirer la console de son parent. Sinon, cela va l'amener à ignorer l'événement.

Il est très important que chaque étape se fait de cette manière. J'ai essayé toutes sortes de combinaisons, mais cette combinaison est le seul qui fonctionne. Vous ne pouvez pas envoyer un CTRL_C événement. Il sera de retour le succès, mais sera ignoré par le processus. CTRL_BREAK est le seul qui fonctionne. N'a pas vraiment d'importance, parce qu'ils seront tous deux appel ExitProcess() à la fin.

Vous aussi vous ne pouvez pas appeler GenerateConsoleCtrlEvent() avec un processus de groupd id de l'enfant id de processus directement permettant l'aide du processus de continuer à vivre. Cela ne fonctionne pas ainsi.

J'ai passé une journée entière à essayer d'obtenir ce travail. Cette solution fonctionne pour moi, mais si quelqu'un a quelque chose à ajouter s'il vous plaît. Je suis allé sur le net de trouver beaucoup de gens avec des problèmes similaires, mais pas de solution définitive au problème. Comment GenerateConsoleCtrlEvent() fonctionne est un peu bizarre donc si quelqu'un en sait plus de détails sur le s'il vous plaît partager.

En quelque sorte GenerateConsoleCtrlEvent() retour d'erreur si vous l'appelez pour un autre processus, mais vous pouvez la joindre à une autre application de console et d'envoyer l'événement à tous les processus enfants.

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
}

        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);
            }
        }

En Java, en utilisant la JNA avec l'Kernel32.dll bibliothèque, semblable à un C++ solution. Exécute le CtrlCSender méthode main comme un Processus qui obtient juste la console du processus pour envoyer la combinaison de touches Ctrl+C événement et génère l'événement. Comme il fonctionne séparément, sans console Ctrl+C l'événement n'a pas besoin d'être désactivé et activé à nouveau.

CtrlCSender.java - Basé sur Nemo1024 de l' et KindDragon de l' réponses.

Donné un procédé connu ID, ce consoless application, vous fixez la console de processus ciblées et de générer un CTRL+C Événement sur elle.

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);
    }
}

Principale de l'Application des Pistes de CtrlCSender séparément consoless processus

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();

Basé sur l'id du processus, nous pouvons envoyer le signal à la fin du processus avec force ou avec élégance ou tout autre signal.

Liste de tous les processus :

C:\>tasklist

De tuer le processus:

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

Détails:

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

Oui. Le windows-kill projet est exactement ce que vous voulez:

windows-kill -SIGINT 1234