Méthode Terminate de la classe Win32_Process

La méthode TerminateWMI classe met fin à un processus et à tous ses threads.

Cette rubrique utilise la syntaxe MOF (Managed Object Format). Pour plus d’informations sur l’utilisation de cette méthode, consultez Appel d’une méthode.

Syntaxe

uint32 Terminate(
  [in] uint32 Reason
);

Paramètres

Motif [in]

Code de sortie pour le processus et pour tous les threads arrêtés à la suite de cet appel.

Valeur retournée

Retourne une valeur de 0 (zéro) si le processus a été correctement terminé, et tout autre nombre pour indiquer une erreur. Pour obtenir des codes d’erreur supplémentaires, consultez Constantes d’erreur WMI ou WbemErrorEnum. Pour connaître les valeurs HRESULT générales, consultez Codes d’erreur système.

Achèvement réussi (0)

Accès refusé (2)

Privilège insuffisant (3)

Échec inconnu (8)

Chemin introuvable (9)

Paramètre non valide (21)

Autre (22 4294967295)

Notes

Vue d'ensemble

Les problèmes informatiques sont souvent dus à un processus qui ne fonctionne plus comme prévu. Par exemple, le processus peut fuiter de la mémoire, ou il a peut-être cessé de répondre à l’entrée utilisateur. Lorsque de tels problèmes se produisent, le processus doit être arrêté. Bien que cela puisse sembler une tâche assez simple, l’arrêt d’un processus peut être compliqué par plusieurs facteurs :

• Le processus peut être suspendu et, par conséquent, ne répond plus aux commandes de menu ou de clavier pour fermer l’application. Cela rend presque impossible pour l’utilisateur standard d’ignorer l’application et d’arrêter le processus.
• Le processus peut être orphelin. Par exemple, un script peut créer une instance de Word, puis quitter sans détruire cette instance. En effet, Word reste en cours d’exécution sur l’ordinateur, même si aucune interface utilisateur n’est visible. Étant donné qu’il n’existe aucune interface utilisateur, aucune commande de menu ou de clavier n’est disponible pour arrêter le processus.
• Vous ne savez peut-être pas quel processus doit être arrêté. Par exemple, vous souhaiterez peut-être arrêter tous les programmes qui dépassent une quantité de mémoire spécifiée.
• Étant donné que le Gestionnaire des tâches vous permet d’arrêter uniquement les processus que vous avez créés, vous ne pourrez peut-être pas arrêter un processus, même si vous êtes administrateur sur l’ordinateur.

Les scripts vous permettent de surmonter tous ces obstacles potentiels, ce qui vous offre un contrôle administratif considérable sur vos ordinateurs. Par exemple, si vous pensez que les utilisateurs jouent à des jeux interdits dans votre organization, vous pouvez facilement écrire un script pour vous connecter à chaque ordinateur, déterminer si le jeu est en cours d’exécution et arrêter immédiatement le processus.

Utilisation de la méthode Terminate

Vous pouvez arrêter un processus en procédant comme suit :

• Arrêt d’un processus en cours d’exécution. Par exemple, vous devrez peut-être arrêter un programme de diagnostic en cours d’exécution sur un ordinateur distant. S’il n’existe aucun moyen de contrôler l’application à distance, vous pouvez simplement arrêter le processus pour cette application.
• Empêcher l’exécution d’un processus en premier lieu. En surveillant en continu la création d’un processus sur un ordinateur, vous pouvez identifier et arrêter instantanément tout processus dès qu’il démarre. Cette méthode permet de s’assurer que certaines applications (comme les programmes qui téléchargent des fichiers multimédias volumineux sur Internet) ne sont jamais exécutées sur certains ordinateurs.

Mettre fin à un processus que vous ne possédez pas

Pour mettre fin à un processus qui ne vous appartient pas, activez le privilège SeDebugPrivilege . Dans VBScript, vous pouvez activer ce privilège avec les lignes de code suivantes :

Set objLoc = createobject("wbemscripting.swbemlocator")
objLoc.Security_.privileges.addasstring "sedebugprivilege", true

Pour plus d’informations sur l’activation de ce privilège en C++, consultez Activation et désactivation des privilèges en C++.

Exemples

L’exemple de code Terminer l’exécution du processus sur plusieurs serveurs PowerShell sur TechNet Gallery met fin à un processus en cours d’exécution sur un ou plusieurs ordinateurs.

L’exemple VBScript suivant met fin au processus dans lequel l’application Diagnose.exe est en cours d’exécution.

strComputer = "."
Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colProcessList = objWMIService.ExecQuery("SELECT * FROM Win32_Process WHERE Name = 'Diagnose.exe'")
For Each objProcess in colProcessList
 objProcess.Terminate()
Next

L’exemple VBScript suivant utilise un consommateur d’événements temporaire pour arrêter un processus dès qu’il démarre.

strComputer = "."
Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colMonitoredProcesses = objWMIService.ExecNotificationQuery("SELECT * FROM __InstanceCreationEvent " _
 & " WITHIN 1 WHERE TargetInstance ISA 'Win32_Process'")
i = 0
Do While i = 0
 Set objLatestProcess = colMonitoredProcesses.NextEvent
 If objLatestProcess.TargetInstance.Name = "Download.exe" Then
 objLatestProcess.TargetInstance.Terminate()
 End If
Loop

L’exemple de code VBScript suivant se connecte à un ordinateur distant et arrête Notepad.exe sur cet ordinateur.

strComputer = "FullComputerName" 
strDomain = "DOMAIN" 
strUser = InputBox("Enter user name") 
strPassword = InputBox("Enter password") 
Set objSWbemLocator = CreateObject("WbemScripting.SWbemLocator") 
Set objWMIService = objSWbemLocator.ConnectServer(strComputer, _ 
    "root\CIMV2", _ 
    strUser, _ 
    strPassword, _ 
    "MS_409", _ 
    "ntlmdomain:" + strDomain) 
Set colProcessList = objWMIService.ExecQuery("SELECT * FROM Win32_Process WHERE Name = 'notepad.exe'")
For Each objProcess in colProcessList
    objProcess.Terminate()
Next

Le code C++ suivant met fin au processus de Notepad.exe sur l’ordinateur local. Spécifiez un handle de processus ou (ID de processus) dans le code pour arrêter le processus. Cette valeur se trouve dans la propriété handle de la classe Win32_Process (propriété de clé de la classe ). En spécifiant une valeur pour la propriété Handle, vous fournissez un chemin d’accès au instance de la classe que vous souhaitez terminer. Pour plus d’informations sur la connexion à un ordinateur distant, consultez Exemple : Obtention de données WMI à partir d’un ordinateur distant.

#define _WIN32_DCOM

#include <iostream>
using namespace std;
#include <comdef.h>
#include <Wbemidl.h>

#pragma comment(lib, "wbemuuid.lib")

int main(int iArgCnt, char ** argv)
{
    HRESULT hres;

    // Step 1: --------------------------------------------------
    // Initialize COM. ------------------------------------------

    hres =  CoInitializeEx(0, COINIT_MULTITHREADED); 
    if (FAILED(hres))
    {
        cout << "Failed to initialize COM library. Error code = 0x" 
             << hex << hres << endl;
        return 1;                  // Program has failed.
    }

    // Step 2: --------------------------------------------------
    // Set general COM security levels --------------------------
    // Note: If you are using Windows 2000, specify -
    // the default authentication credentials for a user by using
    // a SOLE_AUTHENTICATION_LIST structure in the pAuthList ----
    // parameter of CoInitializeSecurity ------------------------

    hres =  CoInitializeSecurity(
        NULL, 
        -1,                          // COM negotiates service
        NULL,                        // Authentication services
        NULL,                        // Reserved
        RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication 
        RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation  
        NULL,                        // Authentication info
        EOAC_NONE,                   // Additional capabilities 
        NULL                         // Reserved
        );

                      
    if (FAILED(hres))
    {
        cout << "Failed to initialize security. Error code = 0x" 
             << hex << hres << endl;
        CoUninitialize();
        return 1;                      // Program has failed.
    }
    
    // Step 3: ---------------------------------------------------
    // Obtain the initial locator to WMI -------------------------

    IWbemLocator *pLoc = NULL;

    hres = CoCreateInstance(
        CLSID_WbemLocator,             
        0, 
        CLSCTX_INPROC_SERVER, 
        IID_IWbemLocator, (LPVOID *) &pLoc);
 
    if (FAILED(hres))
    {
        cout << "Failed to create IWbemLocator object. "
             << "Err code = 0x"
             << hex << hres << endl;
        CoUninitialize();
        return 1;                 // Program has failed.
    }

    // Step 4: ---------------------------------------------------
    // Connect to WMI through the IWbemLocator::ConnectServer method

    IWbemServices *pSvc = NULL;
 
    // Connect to the local root\cimv2 namespace
    // and obtain pointer pSvc to make IWbemServices calls.
    hres = pLoc->ConnectServer(
        _bstr_t(L"ROOT\\CIMV2"), 
        NULL,
        NULL, 
        0, 
        NULL, 
        0, 
        0, 
        &pSvc
    );
     
    if (FAILED(hres))
    {
        cout << "Could not connect. Error code = 0x" 
             << hex << hres << endl;
        pLoc->Release();
        pSvc->Release();     
        CoUninitialize();
        return 1;                // Program has failed.
    }

    cout << "Connected to ROOT\\CIMV2 WMI namespace" << endl;


    // Step 5: --------------------------------------------------
    // Set security levels for the proxy ------------------------

    hres = CoSetProxyBlanket(
        pSvc,                        // Indicates the proxy to set
        RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx 
        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx 
        NULL,                        // Server principal name 
        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx 
        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
        NULL,                        // client identity
        EOAC_NONE                    // proxy capabilities 
    );

    if (FAILED(hres))
    {
        cout << "Could not set proxy blanket. Error code = 0x" 
             << hex << hres << endl;
        pSvc->Release();
        pLoc->Release();     
        CoUninitialize();
        return 1;               // Program has failed.
    }

    // Step 6: --------------------------------------------------
    // Use the IWbemServices pointer to make requests of WMI ----

    // Set up to call the Win32_Process::Create method
    BSTR ClassName = SysAllocString(L"Win32_Process");

    /* YOU NEED TO CHANGE THE NUMBER VALUE OF THE HANDLE 
       (PROCESS ID) TO THE CORRECT VALUE OF THE PROCESS YOU 
       ARE TRYING TO TERMINATE (this provides a path to
       the class instance you are tying to terminate). */
    BSTR ClassNameInstance = SysAllocString(
        L"Win32_Process.Handle=\"3168\"");

    _bstr_t MethodName = (L"Terminate");
    BSTR ParameterName = SysAllocString(L"Reason");

    IWbemClassObject* pClass = NULL;
    hres = pSvc->GetObject(ClassName, 0, NULL, &pClass, NULL);

    IWbemClassObject* pInParamsDefinition = NULL;
    IWbemClassObject* pOutMethod = NULL;
    hres = pClass->GetMethod(MethodName, 0, 
        &pInParamsDefinition, &pOutMethod);

    if (FAILED(hres))
    {
        cout << "Could not get the method. Error code = 0x" 
             << hex << hres << endl;
    }

    IWbemClassObject* pClassInstance = NULL;
    hres = pInParamsDefinition->SpawnInstance(0, &pClassInstance);

    // Create the values for the in parameters
    VARIANT pcVal;
    VariantInit(&pcVal);
    V_VT(&pcVal) = VT_I4;

    // Store the value for the in parameters
    hres = pClassInstance->Put(L"Reason", 0,
        &pcVal, 0);

    // Execute Method
    hres = pSvc->ExecMethod(ClassNameInstance, MethodName, 0,
    NULL, pClassInstance, NULL, NULL);

    if (FAILED(hres))
    {
        cout << "Could not execute method. Error code = 0x" 
             << hex << hres << endl;
        VariantClear(&pcVal);
        SysFreeString(ClassName);
        SysFreeString(MethodName);
        pClass->Release();
        pInParamsDefinition->Release();
        pSvc->Release();
        pLoc->Release();     
        CoUninitialize();
        return 1;           // Program has failed.
    }


    // Clean up
    //--------------------------
    VariantClear(&pcVal);
    SysFreeString(ClassName);
    SysFreeString(MethodName);
    pClass->Release();
    pInParamsDefinition->Release();
    pLoc->Release();
    pSvc->Release();
    CoUninitialize();
    return 0;
}

Spécifications

Voir aussi

Classes du système d’exploitation

Win32_Process

Tâches WMI : Analyse des performances

Tâches WMI : Processus