Comment puis-je trouver l'id de processus du nom du service/de la poignée en Delphi?

J'ai le nom du service pour un service windows en delphi, et je sais comment obtenir la poignée de que la. Ce que j'ai besoin de faire est d'arrêter un service, et si l'arrêt de échoue pour une raison que j'ai besoin de tuer le processus associé au service. Le problème est que j'ai de multiples services en cours d'exécution à partir de la même exécutable, donc je ne peux pas utiliser le nom de l'exécutable de tuer le processus. Cela signifie que j'ai besoin de l'id de processus pour tuer le bon associé à des processus. Comment puis-je obtenir cette carte d'identité ou une certaine façon de tuer le processus approprié du nom du service ou de la poignée?

OriginalL'auteur Chris J | 2009-01-22

  1. 8

    QueryServiceStatusEx?

    Vous n'êtes pas susceptible d'avoir assez de privilèges pour tuer les processus du service...
    Cela ne semble pas être une solution pour delphi, je ne suis pas vraiment à la recherche d'une solution dans une autre langue pour ce que je vais avoir à crochet. @Arkadi - tuer le processus n'est pas un gros problème, le système actuel ne permet cela, mais ne fait pas la différence lorsqu'il y a plusieurs processus en cours d'exécution
    Chris, Jk lié à la QueryServiceStatusEx la fonction de l'API. Vous pouvez appeler à partir de n'importe quelle langue que vous voulez, y compris Delphi. Vous n'avez pas à "crochet" dans une autre langue. Vous appelez les fonctions API de tous les temps: tout ce que vous avez appelé à partir de l'unité Windows, par exemple.
    L'appel donne l'ID de processus ainsi que de l'état, de sorte que devrait être ce qui est voulu.
    J'ai eu du mal à comprendre comment utiliser l'appel en Delphi, je l'ai trouvé dans une autre réponse à cette question.

    OriginalL'auteur Jk.

  2. 6

    Veuillez noter que j'ai seulement accepté cette solution, de sorte que le code delphi solution est acceptée, merci à Jk mais pour me pointer sur le bon chemin.

    --

    Ok, j'ai été en mesure de comprendre comment utiliser la réponse par Jk et ont abouti à cette solution en delphi.

    Pour la référence, c'est le lien fourni par Jk:

    QueryServiceStatusEx

    Ma Solution:

    unit Demo;
interface
uses
Windows, Forms, SysUtils,
StdCtrls, WinSvc, Controls, Classes;
type
//Form for basic demo usage
TForm6 = class(TForm)
Button1: TButton;
Memo1: TMemo;
procedure Button1Click(Sender: TObject);
end;
//Record defined for use as return buffer
_SERVICE_STATUS_PROCESS = record
dwServiceType: DWORD;
dwCurrentState: DWORD;
dwControlsAccepted: DWORD;
dwWin32ExitCode: DWORD;
dwServiceSpecificExitCode: DWORD;
dwCheckPoint: DWORD;
dwWaitHint: DWORD;
dwProcessId: DWORD;
dwServiceFlags: DWORD;
end;
//Function Prototype
function QueryServiceStatusEx(
SC_HANDLE: SC_Handle;
SC_STATUS_TYPE: Cardinal;
out lpBuffer: _SERVICE_STATUS_PROCESS;
cbBufSize: DWORD;
out pcbBytesNeeded: LPDWORD
): BOOL; stdcall;
//internal setup function
function GetPid(sService: String; sMachine: String = '') : Cardinal;
var
Form6: TForm6;
implementation
{$R *.dfm}
const
// windows api library
advapi32 = 'advapi32.dll';
//define the api call
function QueryServiceStatusEx;   external advapi32 name 'QueryServiceStatusEx';
//for demo usage
procedure TForm6.Button1Click(Sender: TObject);
begin
Memo1.Lines.Add(IntToStr(Integer(GetPid('Service'))))
end;
function GetPid(sService: String; sMachine: String = '') : Cardinal;
var
schm,
schs: SC_Handle;
SC_STATUS_TYPE: Cardinal;
lpBuffer: _SERVICE_STATUS_PROCESS;
cbBufSize: DWORD;
pcbBytesNeeded: LPDWORD;
begin
//open the service manager  (defined in WinSvc)
schm := OpenSCManager(PChar(sMachine), nil, SC_MANAGER_CONNECT);
//set the status type to SC_STATUS_PROCESS_INFO
//this is currently the only value supported
SC_STATUS_TYPE := $00000000;
//set the buffer size to the size of the record
cbBufSize := sizeof(_SERVICE_STATUS_PROCESS);
if (schm>0) then
begin
//grab the service handle
schs := OpenService(schm, PChar(sService), SERVICE_QUERY_STATUS);
if (schs>0) then
begin
//call the function
QueryServiceStatusEx(
schs,
SC_STATUS_TYPE,
lpBuffer,
cbBufSize,
pcbBytesNeeded);
CloseServiceHandle(schs);
end;
CloseServiceHandle(schm);
end;
Result := lpBuffer.dwProcessId;
end;
end.

    Veuillez noter que pas toutes externes de nommage et d'autres biens de première nécessité sont inclus.

    OriginalL'auteur Chris J

  3. 1

    Ou utiliser DSiWin32 pour de nombreuses fonctions utiles, y compris DSiGetProcessID. Ce code a été écrit par StackOverflow de l'utilisateur (et programmeur) Gabr.

    Voici la fonction, pour votre propre référence. Il vous donnera ce que vous cherchez:

    //Retrieves ID of the specified process. Requires Toolhelp API.
//  @returns False if ID cannot be retrieved. Check GetLastError - if it is 0, process
//       doesn't exist; otherwise it contains the Win32 error code.
//  @author  gabr
//  @since   2004-02-12
//
function DSiGetProcessID(const processName: string; var processID: DWORD): boolean;
var
hSnapshot: THandle;
procEntry: TProcessEntry32;
begin
Result := false;
hSnapshot := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if hSnapshot = 0 then
Exit;
try
procEntry.dwSize := Sizeof(procEntry);
if not Process32First(hSnapshot, procEntry) then
Exit;
repeat
if AnsiSameText(procEntry.szExeFile, processName) then begin
processID := procEntry.th32ProcessID;
Result := true;
break; // repeat
end;
until not Process32Next(hSnapshot, procEntry);
finally DSiCloseHandleAndNull(hSnapshot); end;
end; { DSiGetProcessID }
    c'est en fait la morue je suis le remplaçant, ce code ne fonctionne pas dans les situations où plusieurs processus distincts sont en cours d'exécution sur le même fichier exécutable. Dans notre cas, nous sommes à l'exécution de plusieurs exécutables à la fois comme séparés services et doivent être en mesure de contrôler les séparer, processus correct par service.

    OriginalL'auteur Mick