Prozesse beenden

[Knotti2015]

Hallo Leutz again,

ich kann mit dem netten Code von Lucki

Delphi-Quellcode:

 uses
  PSAPI, TlHelp32;

function GetProcessName(PID: DWORD; var ProcessName: string): DWORD;
var
  dwReturn     : DWORD;
  hProc        : Cardinal;
  buffer       : array[0..MAX_PATH - 1] of Char;
begin
  dwReturn := 0;
  Zeromemory(@buffer, sizeof(buffer));
  hProc := OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ, FALSE, PID);
  if hProc <> 0 then
  begin
    GetModulebaseName(hProc, 0, buffer, sizeof(buffer));
    ProcessName := (string(buffer));
    CloseHandle(hProc);
  end
  else
    dwReturn := GetLastError;
  result := dwReturn;
end;

type
  TPIDList = array of DWORD;

function GetProcessList(var ProcessList: TPIDList): DWORD;

  function GetOSVersionInfo(var Info: TOSVersionInfo): Boolean;
  begin
    FillChar(Info, SizeOf(TOSVersionInfo), 0);
    Info.dwOSVersionInfoSize := SizeOf(TOSVersionInfo);
    Result := GetVersionEx(TOSVersionInfo(Addr(Info)^));
    if (not Result) then
    begin
      FillChar(Info, SizeOf(TOSVersionInfo), 0);
      Info.dwOSVersionInfoSize := SizeOf(TOSVersionInfo);
      Result := GetVersionEx(TOSVersionInfo(Addr(Info)^));
      if (not Result) then
        Info.dwOSVersionInfoSize := 0;
    end;
  end;

var
  dwReturn     : DWORD;
  OS           : TOSVersionInfo;
  // EnumProcesses
  PidProcesses : PDWORD;
  PidWork      : PDWORD;
  BufferSize   : Cardinal;
  Needed       : DWORD;
  cntProcesses : Cardinal;
  i            : Cardinal;
  // CreateToolhelp32Snapshot
  hProcSnapShot: THandle;
  pe32         : TProcessEntry32;
  j            : Cardinal;

begin
  dwReturn := 0;
  // What OS are we running on?
  if GetOSVersionInfo(OS) then
  begin
    if (OS.dwPlatformId = VER_PLATFORM_WIN32_NT) and (OS.dwMajorVersion = 4) then
    // WinNT and higher
    begin
      Needed := 0;
      BufferSize := 1024;
      GetMem(PidProcesses, BufferSize);
      // make sure memory is allocated
      if Assigned(PidProcesses) then
      begin
        try
          // enumerate the processes
          if EnumProcesses(PidProcesses, BufferSize, Needed) then
          begin
            dwReturn := 0;
            cntProcesses := Needed div sizeof(DWORD) - 1;
            PidWork := PidProcesses;
            setlength(ProcessList, cntProcesses);
            // walk the processes
            for i := 0 to cntProcesses - 1 do
            begin
              ProcessList[i] := PidWork^;
              Inc(PidWork);
            end;
          end
          else // EnumProcesses = False
            dwReturn := GetLastError;
        finally
          // clean up no matter what happend
          FreeMem(PidProcesses, BufferSize);
        end;
      end
      else // GetMem = nil
        dwReturn := GetLastError;
    end
    // Win 9x and higher except WinNT
    else
    begin
      // make the snapshot
      hProcSnapShot := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
      if hProcSnapShot <> INVALID_HANDLE_VALUE then
      begin
        pe32.dwSize := sizeof(TProcessEntry32);
        j := 0;
        setlength(ProcessList, j + 1);
        if Process32First(hProcSnapShot, pe32) then
        begin
          // first process
          ProcessList[j] := pe32.th32ProcessID;
          // walk the processes
          while Process32Next(hProcSnapShot, pe32) do
          begin
            Inc(j);
            setlength(ProcessList, j + 1);
            ProcessList[j] := pe32.th32ProcessID;
          end;
        end
        else // Process32First = False
          dwReturn := GetLastError;
        CloseHandle(hProcSnapShot);
      end
      else // hSnapShot = INVALID_HANDLE_VALUE
        dwReturn := GetLastError;
    end;
  end;
  result := dwReturn;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  retValue     : DWORD;
  ProcessList  : TPIDList;
  i            : Integer;
  ProcessName  : string;
  PID          : DWORD;
resourcestring
  rsUnknown    = 'unbekannt';
begin
  // VCL causes last error to be set, even nothing has already happend :-/
  SetLastError(0);
  retValue := GetProcessList(ProcessList);
  if retValue = 0 then
  begin
    for i := 0 to length(ProcessList) - 1 do
    begin
      PID := ProcessList[i];
      if GetProcessName(ProcessList[i], ProcessName) <> 0 then
        ProcessName := rsUnknown;
      Listbox1.Items.Add(IntToStr(PID) + ' - ' + ProcessName);
    end;
  end
  else
    ShowMessage(SysErrorMessage(retValue));
end;

Die Prozesse auslesen und in eine Listbox einfügen.
Nun meine Frage wie kann ich diese dann beenden bit einen Button2?

[arbu man]

Delphi-Quellcode:

var 
  PrID: Integer;
  Ph: THandle;
begin
  // Prozess öffnen
  Ph := OpenProcess(1, BOOL(0), PrID);
  // Prozess terminieren
  Ret := TerminateProcess(Ph, 0);
end;

Einfach für PrID die Prozessid einsetzen

[Knotti2015]

Naja die Prid wird ja zuvor in dem string ausgelsen so müsste ich ja extra diese Angeben ich will sie aber durch ein OnClick auslesen...

[ReDoX]

Es gibt mehrere Möglichkeinen Einen Prozess zu beenden.

1.Beendet den Prozess so als wenn du auf das [X] Klickst.

SendMessage(WND, WM_SYSCOMMAND, SC_CLOSE, 0);
2.Und es gibt die Möglichkeit einen Prozess mittels TerminateProcess zu "killen".



Mfg ReDoX

[edit]@arbu man: Man sollte das handle mit CloseHandle(ph) schließen.[/edit]

[JasonDX]

Die DP-Suche bringt: Den Tread mit folgendem Source:

Delphi-Quellcode:

{******************************************************************************} 
{**                                                                          **} 
{** ProzessID an Hand der Exe-Datei ermittlen                                **} 
{**                                                                          **} 
{******************************************************************************} 
function GetProcessID(sProcName: String): Integer; 
var 
  hProcSnap: THandle; 
  pe32: TProcessEntry32; 
begin 
  result := -1; 
  hProcSnap := CreateToolHelp32SnapShot(TH32CS_SNAPPROCESS, 0); 
  if hProcSnap = INVALID_HANDLE_VALUE then exit; 

  pe32.dwSize := SizeOf(ProcessEntry32); 

  { wenn es geklappt hat } 
  if Process32First(hProcSnap, pe32) = true then 
    { und los geht's: Prozess suchen} 
    while Process32Next(hProcSnap, pe32) = true do 
    begin 
      if pos(sProcName, pe32.szExeFile) <> 0then 
        result := pe32.th32ProcessID; 
    end; 
CloseHandle(hProcSnap); 
end; 

{******************************************************************************} 
{**                                                                          **} 
{** Prozess beenden                                                          **} 
{**                                                                          **} 
{******************************************************************************} 
procedure KillProcess(dwProcID: DWORD); 
var 
  hProcess : Cardinal; 
  dw       : DWORD; 
begin 
  { open the process and store the process-handle } 
  hProcess := OpenProcess(SYNCHRONIZE or PROCESS_TERMINATE, False, dwProcID); 
  { kill it } 
  TerminateProcess(hProcess, 0); 
  { TerminateProcess returns immediately, so wie have to verify the result via 
    WaitfForSingleObject } 
  dw := WaitForSingleObject(hProcess, 5000); 
  case dw of 
    { everythings's all right, we killed the process } 
    WAIT_OBJECT_0: Messagebox(Application.Handle, 'Prozess wurde beendet.', 'Prozess beenden', 
      MB_ICONINFORMATION); 
    { process could not be terminated after 5 seconds } 
    WAIT_TIMEOUT: 
    begin 
      Messagebox(Application.Handle, 'Prozess konnte nicht innerhalb von 5 Sekunden beendet werden.', 
        'Prozess beenden', MB_ICONSTOP); 
      CloseHandle(hProcess); 
      exit; 
    end; 
    { error in calling WaitForSingleObject } 
    WAIT_FAILED: 
    begin 
      RaiseLastOSError; 
      CloseHandle(hProcess); 
      exit; 
    end; 
  end; 
  CloseHandle(hProcess); 
  end; 

procedure TForm1.Button1Click(Sender: TObject); 
begin 
    KillProcess(GetProcessID(edit1.text)); // in edit1 muss zb icq.exe stehen 
end;

[SirThornberry]

dann lese sie doch einfach durch einen klick aus. In der listbox steht ja dann ungefährt
"3040334 - Prozessname"
dementsprechend kannst du die Zeischen vor dem "-" wieder in eine Zahl zurückwandeln und der funktion "TerminateProcess" übergeben.

[Knotti2015]

Ja aber wie tue ich das. Es müsst ja erstmal der Prozess in der listbox ausgewählt, ausgelesen (1 - vmware), und dann die 1 an

Delphi-Quellcode:

var 
  PrID: Integer; 
  Ph: THandle; 
begin 
  // Prozess öffnen 
  Ph := OpenProcess(1, BOOL(0), PrID); 
  // Prozess terminieren 
  Ret := TerminateProcess(Ph, 0); 
end;

übergeben werden. Ich will nicht erst den Namen oder die ID eintragen einfach anklicken und drop...

[JasonDX]

Falls du das auslesen der Zahl aus einem string wie '1 - asdf' brauchst, schau dir mal copy, delete und pos an.

Zitat von Knotti2015:

Es müsst ja erstmal der Prozess in der listbox ausgewählt, ausgelesen (1 - vmware), und dann die 1 an (...) übergeben werden
Ich will nicht erst den Namen oder die ID eintragen einfach anklicken und drop

Was meinst du genau?
Du willst in der Listbox den Prozess anklicken und er soll beendet werden? (In der Listbox auswählen wird fast sein müssen )
Dann nimm nicht ein OnClick-Ereignis vom Button, sondern von der Listbox!
Den Prozess dann zu beenden dürftest du jetzt Möglichkeiten Genug haben. (durch exe-name, durch PID....)

[Knotti2015]

Ja ich will es in der Listbox ja nur markieren und dann durch einen Button terminieren.

[JasonDX]

Dann hilft dir:

• Die oben angeführten Quellcodes
• Das OnClick-Event von TButton
• Die eigentschaft: TListbox.ItemIndex und TListbox.Items