Mettre fin à un processus de l'arbre (C pour Windows)

Cela a été demandé avant, mais je ne peux pas trouver une réponse définitive, dans le code.

J'ai ouvert un processus, ProcessA (avec le PID 1234). Ce processus ouvre un processus enfant, ProcessAB PID (5678).
Après je suis fait, je résilier ProcessA mais j'ai encore de la persistance de ProcessAB.

Comment puis-je mettre fin à tout le processus de l'arbre? Ce que je veux dire, comment puis-je m'assurer que si je résilier le processus, je l'ai ouvert, je suis également à la résiliation de tous les processus associés?

Grâce

Code est apprécié.

OriginalL'auteur wonderer | 2009-07-23

c process terminate windows

Vérifier ce fil pour le groupement des processus au sein d'un "job".

Si cela ne fonctionne pas pour vous, une maison grandi approche pourrait aller comme suit:

Vos principaux ID de processus
Appel CreateToolhelp32Snapshot à enumerateall les processus sur le système
Vérifier la th32ParentProcessID membre de la structure PROCESSENTRY32 sur chaque processus, si elle correspond à votre ID parent, puis terminer le processus (à l'aide de TerminateProcess)
Après tous les enfants sont résiliation, résilier le processus principal

Exemple de code:

    DWORD myprocID = 1234; //your main process id

PROCESSENTRY32 pe;

memset(&pe, 0, sizeof(PROCESSENTRY32));
pe.dwSize = sizeof(PROCESSENTRY32);

HANDLE hSnap = :: CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

if (::Process32First(hSnap, &pe))
{
    BOOL bContinue = TRUE;

    //kill child processes
    while (bContinue)
    {
        //only kill child processes
        if (pe.th32ParentProcessID == myprocID)
        {
            HANDLE hChildProc = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe.th32ProcessID);

            if (hChildProc)
            {
                ::TerminateProcess(hChildProc, 1);
                ::CloseHandle(hChildProc);
            }               
        }

        bContinue = ::Process32Next(hSnap, &pe);
    }

    //kill the main process
    HANDLE hProc = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, myprocID);

    if (hProc)
    {
        ::TerminateProcess(hProc, 1);
        ::CloseHandle(hProc);
    }       
}

hmmm cela pourrait fonctionner. laissez-moi voir.
Je n'arrive pas à obtenir ce droit. Avez-vous un exemple extrait? merci
Désolé, j'avais écrit qu'à partir de la mémoire. Le premier devrait être CreateToolhelp32Snapshot, pas EnumProcesses. L'échantillon ci-dessus.
vous avez besoin pour obtenir de débogage de privilèges pour ouvrir le processus, mais il semble être au travail autre que cela. merci
Merci pour cette. À noter que pour les homebrew cas, il vous manque un de la récursivité. J'ai répondu ci-dessous.

OriginalL'auteur Mike Marshall

5

Utilisation Objets.

C'est la chose la plus proche à unix 'processus de groupe" que windows a à offrir.

Objets vous permettent d'indiquer un processus enfant (et de tous ses enfants) peuvent être gérés ensemble, esp. pour être tué. Contrairement à unix, de cette écriture 'objets' ne peut pas être imbriquées à l'. Ce qui signifie que si un parent crée un objet de travail pour un enfant, tout ce que l'enfant les enfants ne peuvent pas eux-mêmes le Travail d'utilisation des Objets (qui est un /grave/limitation à mon humble avis, comme un fichier système qui ne permet qu'à un seul niveau de sous-répertoires).

Soutien pour la nidification de l'emploi des objets a été ajouté à Windows 8 et Windows Server 2012.

OriginalL'auteur seriss

De tuer un arbre entier avec TOUT!!! childs:

bool __fastcall KillProcessTree(DWORD myprocID, DWORD dwTimeout)
{
bool bRet = true;
HANDLE hWnd;
PROCESSENTRY32 pe;
memset(&pe, 0, sizeof(PROCESSENTRY32));
pe.dwSize = sizeof(PROCESSENTRY32);
HANDLE hSnap = :: CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (::Process32First(hSnap, &pe))
{
BOOL bContinue = TRUE;
//kill child processes
while (bContinue)
{
if (pe.th32ParentProcessID == myprocID)
{
ShowMessage ("Gleich - KILL PID: " + AnsiString(pe.th32ProcessID));
//Rekursion
KillProcessTree(pe.th32ProcessID, dwTimeout);
HANDLE hChildProc = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe.th32ProcessID);
if (hChildProc)
{
GetWindowThreadProcessId(hWnd, &myprocID);
//CLOSE Message s
PostMessage(hWnd, WM_CLOSE, 0, 0) ;
if (WaitForSingleObject(hChildProc, dwTimeout) == WAIT_OBJECT_0)
bRet = true;
else
{
bRet = TerminateProcess(hChildProc, 0);
}
::CloseHandle(hChildProc);
}
}
bContinue = ::Process32Next(hSnap, &pe);
}
//kill the main process
HANDLE hProc = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, myprocID);
if (hProc)
{
::TerminateProcess(hProc, 1);
::CloseHandle(hProc);
}
}
return bRet;
}

Vous ne pouvez pas appeler GetWindowThreadProcessId avec hWnd pas défini. Alors que le code certainement démontre une bonne idée d'essayer de fermer les fenêtres bien, il ne fonctionne pas.

OriginalL'auteur Michael

0

Il y a Comment Tuer un Processus d'Arbre, mais c'est en C#. Je ne pense pas que c'est trop dur de port à C.

Voir NtQueryInformationProcess Fonction et Fonction TerminateProcess.

J'ai essayé de convertir le code hier, mais pas de chance. de toute façon, je suis déjà à l'aide de Ntquery et terminateprocess mais ceux-là seulement prendre soin de la mère et pas le reste

OriginalL'auteur Eugene Yokota

@mjmarsh réponses besoins de la récursivité pour le homebrew cas, sinon c'est celui de droite. La création d'emplois objets est meilleur que le bas quand vous le pouvez.

void KillProcessTree(DWORD myprocID)
{
PROCESSENTRY32 pe;
memset(&pe, 0, sizeof(PROCESSENTRY32));
pe.dwSize = sizeof(PROCESSENTRY32);
HANDLE hSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (::Process32First(hSnap, &pe))
{
do //Recursion
{
if (pe.th32ParentProcessID == myprocID)
KillProcessTree(pe.th32ProcessID);
} while (::Process32Next(hSnap, &pe));
}
//kill the main process
HANDLE hProc = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, myprocID);
if (hProc)
{
::TerminateProcess(hProc, 1);
::CloseHandle(hProc);
}
}

Même problème ici, depuis Windows (au moins XP) recycle les PIDs assez rapide, vous devez être très prudent de ne pas tuer sans rapport avec les processus. Ces Api fera rapport PPIDs pour mort depuis longtemps processus dont le Pid peut être recyclé. De vérifier la mère date de début pour s'assurer qu'elle est liée à des processus qui vous a engendré.

OriginalL'auteur user2346536

-1

Ce qui suit est pour Linux, mais j'espère que cela aide pour Windows avec certaines adaptations.

Lorsque vous fork(), enregistrer la valeur de retour, qui est le pid du processus fils, puis, quand la mère est sur le point de quitter, kill() le pid.

Si vous avez plusieurs enfants de processus, vous pouvez envoyer le tuer pour le groupe de processus. Par défaut, le processus enfants ont les mêmes pgid en tant que parent.

1) je souhaite que je travaille sur Linux 2) je souhaite que windows avait fork() 3) je suis d'ouverture est l'ouverture du processus enfants donc je n'ai aucun contrôle sur cela, mais merci quand même

OriginalL'auteur Mike Mu

Vous devez vous connecter pour publier un commentaire.