Terminate-Methode der Win32 _ Process-Klasse

Die Terminate WMI-Klassenmethode beendet einen Prozess und alle zugehörigen Threads.

In diesem Thema wird die MOF-Syntax (Managed Object Format) verwendet. Weitere Informationen zur Verwendung dieser Methode finden Sie unter Aufrufen einer Methode.

Syntax

uint32 Terminate(
  [in] uint32 Reason
);

Parameter

Grund [ In]

Beenden Sie den Code für den Prozess und für alle Threads, die als Ergebnis dieses Aufrufs beendet wurden.

Rückgabewert

Gibt den Wert 0 (null) zurück, wenn der Prozess erfolgreich beendet wurde, und eine beliebige andere Zahl, um einen Fehler anzugeben. Weitere Fehlercodes finden Sie unter WMI-Fehlerkonstanten oder WbemErrorEnum. Allgemeine HRESULT-Werte finden Sie unter Systemfehlercodes.

Erfolgreicher Abschluss (0)

Zugriff verweigert (2)

Unzureichende Berechtigungen (3)

Unbekannter Fehler (8)

Pfad nicht gefunden (9)

Ungültiger Parameter (21)

Sonstige (22 4294967295)

Bemerkungen

Übersicht

Computerprobleme sind häufig auf einen Prozess zurückzuführen, der nicht mehr wie erwartet funktioniert. Der Prozess kann z. B. Arbeitsspeicherverlust aufweisen, oder er reagiert nicht mehr auf Benutzereingaben. Wenn Probleme wie diese auftreten, muss der Prozess beendet werden. Obwohl dies wie eine einfache Aufgabe erscheinen mag, kann das Beenden eines Prozesses durch mehrere Faktoren kompliziert werden:

  • Der Prozess kann hängen bleiben und reagiert daher nicht mehr auf Menü- oder Tastaturbefehle zum Schließen der Anwendung. Dies macht es für den typischen Benutzer unmöglich, die Anwendung zu schließen und den Prozess zu beenden.
  • Der Prozess ist möglicherweise verwaist. Beispielsweise kann ein Skript eine Instanz von Word erstellen und dann beenden, ohne diese Instanz zu zerstören. Tatsächlich wird Word weiterhin auf dem Computer ausgeführt, obwohl keine Benutzeroberfläche sichtbar ist. Da es keine Benutzeroberfläche gibt, sind keine Menü- oder Tastaturbefehle verfügbar, um den Prozess zu beenden.
  • Möglicherweise wissen Sie nicht, welcher Prozess beendet werden muss. Beispielsweise können Sie alle Programme beenden, die eine angegebene Arbeitsspeichermenge überschreiten.
  • Da sie mit Task-Manager nur die prozesse beenden können, die Sie erstellt haben, können Sie einen Prozess möglicherweise auch dann nicht beenden, wenn Sie ein Administrator auf dem Computer sind.

Skripts ermöglichen es Ihnen, all diese potenziellen Hindernisse zu überwinden, was Ihnen eine erhebliche administrative Kontrolle über Ihre Computer bietet. Wenn Sie beispielsweise vermuten, dass Benutzer Spiele spielen, die in Ihrer Organisation nicht zulässig sind, können Sie einfach ein Skript schreiben, um eine Verbindung mit jedem Computer herzustellen, zu ermitteln, ob das Spiel ausgeführt wird, und den Prozess sofort beenden.

Verwenden der Terminate-Methode

Sie können einen Prozess wie folgt beenden:

  • Beenden eines Prozesses, der gerade ausgeführt wird. Beispielsweise müssen Sie möglicherweise ein Diagnoseprogramm beenden, das auf einem Remotecomputer ausgeführt wird. Wenn es keine Möglichkeit gibt, die Anwendung remote zu steuern, können Sie einfach den Prozess für diese Anwendung beenden.
  • Verhindern, dass ein Prozess überhaupt ausgeführt wird. Durch die kontinuierliche Überwachung der Prozesserstellung auf einem Computer können Sie jeden Prozess identifizieren und sofort beenden, sobald er gestartet wird. Dies bietet eine Methode, um sicherzustellen, dass bestimmte Anwendungen (z. B. Programme, die große Mediendateien über das Internet herunterladen) nie auf bestimmten Computern ausgeführt werden.

Hinweis

Gruppenrichtlinie können auch verwendet werden, um die programme einzuschränken, die auf einem Computer ausgeführt werden. Gruppenrichtlinie können jedoch nur die Programme einschränken, die entweder mit dem Startmenü oder Windows Explorer ausgeführt werden. Sie hat keine Auswirkungen auf Programme, die mit anderen Mitteln gestartet wurden, z. B. über die Befehlszeile. Im Gegensatz dazu kann WMI verhindern, dass ein Prozess unabhängig davon ausgeführt wird, wie der Prozess gestartet wurde.

Beenden eines Prozesses, den Sie nicht besitzen

Aktivieren Sie die Berechtigung SeDebugPrivilege, um einen Prozess zu beenden, den Sie nicht besitzen. In VBScript können Sie diese Berechtigung mit den folgenden Codezeilen aktivieren:

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

Weitere Informationen zum Aktivieren dieser Berechtigung in C++ finden Sie unter Aktivieren und Deaktivieren von Berechtigungen in C++.

Beispiele

Das PowerShell-Codebeispiel Terminate running process on multiple servers in TechNet Gallery beendet einen Prozess, der auf einem einzelnen oder mehreren Computern ausgeführt wird.

Im folgenden VBScript-Beispiel wird der Prozess beendet, in dem die Anwendung Diagnose.exe derzeit ausgeführt wird.

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

Im folgenden VBScript-Beispiel wird ein temporärer Ereignisverbraucher verwendet, um einen Prozess zu beenden, sobald er gestartet wird.

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

Im folgenden VBScript-Codebeispiel wird eine Verbindung mit einem Remotecomputer hergestellt und Notepad.exe auf diesem Computer beendet.

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

Der folgende C++-Code beendet den Notepad.exe Prozess auf dem lokalen Computer. Geben Sie ein - oder -Prozesshandle (Prozess-ID) im Code an, um den Prozess zu beenden. Dieser Wert befindet sich in der handle-Eigenschaft in der Win32 _ Process-Klasse (der Schlüsseleigenschaft für die -Klasse). Indem Sie einen Wert für die Handle-Eigenschaft angeben, geben Sie einen Pfad zur Instanz der Klasse an, die Sie beenden möchten. Weitere Informationen zum Herstellen einer Verbindung mit einem Remotecomputer finden Sie unter Beispiel: Abrufen von WMI-Daten von einem Remotecomputer.

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

Requirements (Anforderungen)

Anforderung Wert
Unterstützte Mindestversion (Client)
Windows Vista
Unterstützte Mindestversion (Server)
Windows Server 2008
Namespace
Stamm \ CIMV2
MOF
CIMWin32.mof
DLL
CIMWin32.dll

Weitere Informationen

Betriebssystemklassen

_Win32-Prozess

WMI-Aufgaben: Leistungsüberwachung

WMI-Aufgaben: Prozesse