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.

Delphi-Quellcode:

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...

:-D

[JasonDX]

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

Zitat:

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? :gruebel:
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

;)