Prüfen ob Service läuft...

[Tyrael Y.]

Hallo erst mal zusammen,

wie kann ich prüfen, ob ein bestimmter Service gerade läuft oder nicht ?
Man beachte ich meine nicht, ob ein bestimmter Prozess läuft, sondern ob ein bestimter Service läuft.

Ob eine Applikation gerade läuft das habe ich schon gelöst, jetzt frage ich mich wie ich denn rausfinden soll, ob ein Service läuft.

Bin für jegliche Hilfe dankbar.

Schöne Grüße Tyrael


ääääh sry :oops: Luckie kannst du bitte diesen Beitrag nach "WINDOWS API" verschieben , bitte ?

[sakura]

In folgendem Thread solltest Du alle nötigen Routinen finden. Desweiteren lade ich mal noch eine Unit hoch, die die nötigen Funktionen bereitstellt.

...:cat:...

[Tyrael Y.]

Danke dir Sakura sieht sehr vielversprechend aus und enthält ja sogar mehr :P ....

Hier ist ja auch die Möglichkeit wie man einen Service startet und stoppt, .... danke dir sehr ...Tyrael

[sakura]

Wobei mir gerade auffällt, dass ich vergessen hatte den Link mitzuliefern :oops:

http://www.delphipraxis.net/internal...hlight=service


...:cat:...

[ralfiii]

Zitat:

Zitat von sakura (Beitrag 55083)

Desweiteren lade ich mal noch eine Unit hoch, die die nötigen Funktionen bereitstellt.

Hallo!

Nachdem dieses Posting doch schon längere Zeit her ist: Hast du (oder sonstwer) eine aktuellere Version der Unit? (oder eine andere Unit über die man Services gemütlich steuern kann)
Unter Delphi2010 lässt sich diese Unit nicht compilieren, da dürften einige Unicode-String-Problemchen drin sein...

Danke!
Ralf

[Luckie]

Zitat:

Zitat von ralfiii (Beitrag 1122566)

Unter Delphi2010 lässt sich diese Unit nicht compilieren, da dürften einige Unicode-String-Problemchen drin sein...

Na dann beheb die doch. Dürfte ja nicht so schwer sein alle Strings durch AnsiStrings zu ersetzen.

[ralfiii]

Zitat:

Zitat von Luckie (Beitrag 1122577)

Na dann beheb die doch. Dürfte ja nicht so schwer sein alle Strings durch AnsiStrings zu ersetzen.

Ich dachte nachdem das Posting aus 2003 war gibt's möglicherweise sinnvolle Korrekturen. Und möglicherweise liegen die auch schon irgendwo an zentraler Stelle rum. Find ich besser als den Code nur für mich auszubessern.

Eine "zentrale" Unit hab ich nicht gefunden, aber:

http://www.delphipraxis.net/101017-w...ht-laeuft.html
http://www.delphipraxis.net/88581-di...-abfragen.html

Die zwei zusammen geben ein nettes Paar ab.

Ralf

[DeddyH]

Zitat:

Zitat von Luckie (Beitrag 1122577)

Zitat:

Zitat von ralfiii (Beitrag 1122566)

Unter Delphi2010 lässt sich diese Unit nicht compilieren, da dürften einige Unicode-String-Problemchen drin sein...

Na dann beheb die doch. Dürfte ja nicht so schwer sein alle Strings durch AnsiStrings zu ersetzen.

Es sind bereits AnsiStrings, werden aber dann nach PChar statt PAnsiChar gecastet ;)

[Luckie]

Und die Lösungen funktionieren?

[ralfiii]

Zitat:

Zitat von Luckie (Beitrag 1122596)

Und die Lösungen funktionieren?

Soweit ich das sehe passt das.

Der vollständigkeit halber poste ich's mal:

Delphi-Quellcode:

unit ServiceUtils;

// ###################################
// ######  Unit for working with services
// ###################################

// Discussion:
// http://www.delphipraxis.net/7547-pruefen-ob-service-laeuft.html#post1122577


interface

function ServiceGetStatus(sMachine, sService: PChar): Integer;
function IsServiceRunning(sMachine, sService: PChar): Boolean;
function IsServiceInstalled(sMachine, sService: PChar): Boolean;
function ServiceStart(Machine, ServiceName: string): Boolean;
function ServiceStop(Machine, ServiceName: string): Boolean;

implementation

uses WinSvc, Windows;

// ###################################
// ######
// ###################################

// This block taken from
// http://www.delphipraxis.net/101017-wie-pruefen-ob-service-dienst-installiert-nicht-laeuft.html

function ServiceGetStatus(sMachine, sService: PChar): Integer;
  {******************************************}
  {*** Parameters: ***}
  {*** sService: specifies the name of the service to open
  {*** sMachine: specifies the name of the target computer
  {*** ***}
  {*** Return Values: ***}
  {*** -1 = Error opening service ***}
  {*** 1 = SERVICE_STOPPED ***}
  {*** 2 = SERVICE_START_PENDING ***}
  {*** 3 = SERVICE_STOP_PENDING ***}
  {*** 4 = SERVICE_RUNNING ***}
  {*** 5 = SERVICE_CONTINUE_PENDING ***}
  {*** 6 = SERVICE_PAUSE_PENDING ***}
  {*** 7 = SERVICE_PAUSED ***}
  {******************************************}
var
  SCManHandle, SvcHandle: SC_Handle;
  SS: TServiceStatus;
  dwStat: Integer;
begin
  dwStat := -1;
  // Open service manager handle.
  SCManHandle := OpenSCManager(sMachine, nil, SC_MANAGER_CONNECT);
  if (SCManHandle > 0) then
  begin
    SvcHandle := OpenService(SCManHandle, sService, SERVICE_QUERY_STATUS);
    // if Service installed
    if (SvcHandle > 0) then
    begin
      // SS structure holds the service status (TServiceStatus);
      if (QueryServiceStatus(SvcHandle, SS)) then
        dwStat := ss.dwCurrentState;
      CloseServiceHandle(SvcHandle);
    end;
    CloseServiceHandle(SCManHandle);
  end;
  Result := dwStat;
end;


function IsServiceRunning(sMachine, sService: PChar): Boolean;
begin
  Result := SERVICE_RUNNING = ServiceGetStatus(sMachine, sService);
end;

function IsServiceInstalled(sMachine, sService: PChar): Boolean;
begin
  Result := -1 <> ServiceGetStatus(sMachine, sService);
end;

// ###################################
// ######
// ###################################

// This block taken from here:
// http://www.delphipraxis.net/88581-dienst-service-starten-stoppen-oder-status-abfragen.html

function ServiceStart(Machine, ServiceName: string): Boolean;
// Machine is UNC path or local machine if empty
var
  h_manager, h_svc: SC_Handle;
  ServiceStatus: TServiceStatus;
  dwCheckPoint: DWORD;
  ServiceArgVectors: PChar;
begin
  h_manager := OpenSCManager(PChar(Machine), nil, SC_MANAGER_CONNECT);
  if h_manager > 0 then
  begin
    h_svc := OpenService(h_manager, PChar(ServiceName),
      SERVICE_START or SERVICE_QUERY_STATUS or SC_MANAGER_ALL_ACCESS);
    if h_svc > 0 then
    begin
      if (StartService(h_svc, 0, ServiceArgVectors)) then { succeeded }
      begin
        if (QueryServiceStatus(h_svc, ServiceStatus)) then
        begin
          while (SERVICE_RUNNING <> ServiceStatus.dwCurrentState) do
          begin
            dwCheckPoint := ServiceStatus.dwCheckPoint;
            Sleep(ServiceStatus.dwWaitHint);
            if (not QueryServiceStatus(h_svc, ServiceStatus)) then
              // couldn't check status
              break;
            if (ServiceStatus.dwCheckPoint < dwCheckPoint) then
              break;
          end;
        end;
      end;
      CloseServiceHandle(h_svc);
    end;
    CloseServiceHandle(h_manager);
  end;

  Result := (SERVICE_RUNNING = ServiceStatus.dwCurrentState);
end;

function ServiceStop(Machine, ServiceName: string): Boolean;
// Machine is UNC path or local machine if empty
var
  h_manager, h_svc: SC_Handle;
  ServiceStatus: TServiceStatus;
  dwCheckPoint: DWORD;
begin
  h_manager := OpenSCManager(PChar(Machine), nil, SC_MANAGER_CONNECT);
  if h_manager > 0 then
  begin
    h_svc := OpenService(h_manager, PChar(ServiceName),
      SERVICE_STOP or SERVICE_QUERY_STATUS);
    if h_svc > 0 then
    begin
      if (ControlService(h_svc, SERVICE_CONTROL_STOP, ServiceStatus)) then
      begin
        if (QueryServiceStatus(h_svc, ServiceStatus)) then
        begin
          while (SERVICE_STOPPED <> ServiceStatus.dwCurrentState) do
          begin
            dwCheckPoint := ServiceStatus.dwCheckPoint;
            Sleep(ServiceStatus.dwWaitHint);
            if (not QueryServiceStatus(h_svc, ServiceStatus)) then
              // couldn't check status
              break;
            if (ServiceStatus.dwCheckPoint < dwCheckPoint) then
              break;
          end;
        end;
      end;
      CloseServiceHandle(h_svc);
    end;
    CloseServiceHandle(h_manager);
  end;

  Result := (SERVICE_STOPPED = ServiceStatus.dwCurrentState);
end;

end.

und hier noch eine Unit die ich grad noch zugeschickt gekriegt hab:

Delphi-Quellcode:

{*******************************************************************************

  Description:    provides functions to control and check status of
                  service applications

  Last change:    26. July 2009

  based on
  http://www.delphipraxis.net/topic105934_dienstservice+starten+stoppen+oder+status+abfragen.html

*******************************************************************************}

unit ServiceFunctions;

interface

{$IFNDEF UNICODE}
type
  UnicodeString = WideString;
{$ENDIF}

function IsServiceInstalled(const ServiceName: UnicodeString;
  const MachineName: UnicodeString = ''): Boolean;

function IsServiceRunning(const ServiceName: UnicodeString;
  const MachineName: UnicodeString = ''): Boolean;

// the following functions need admin rights (will trigger UAC under Vista+)
function ServiceStart(const ServiceName: UnicodeString;
  const MachineName: UnicodeString = ''): Boolean;

function ServiceStop(const ServiceName: UnicodeString;
  const MachineName: UnicodeString = ''): Boolean;

function ServiceRestart(const ServiceName: UnicodeString;
  const MachineName: UnicodeString = ''): Boolean;

implementation

uses
  Windows, WinSvc{$IFNDEF UNICODE}, SysUtils{$ENDIF};

//------------------------------------------------------------------------------
// internal helper functions
//------------------------------------------------------------------------------

function WrappedOpenServiceManager(const MachineName: UnicodeString): SC_HANDLE;
begin
  {$IFNDEF UNICODE}
  if (Win32Platform = VER_PLATFORM_WIN32_NT) then
    Result := OpenSCManagerW(PWideChar(MachineName), nil, SC_MANAGER_CONNECT)
  else
  {$ENDIF}
    // Note: the following uses the Wide-Version when using an Unicode capable
    // Delphi version (D2009+) but the Ansi-Version with lower Delphi versions.
    // Do not remove the string() type for this wanted and correct behaviour.
    Result := OpenSCManager(PChar(string(MachineName)), nil, SC_MANAGER_CONNECT);
end;

function WrappedOpenService(const ManagerHandle: SC_HANDLE;
  const ServiceName: UnicodeString; const DesiredAccess: Cardinal): SC_HANDLE;
begin
  {$IFNDEF UNICODE}
  if (Win32Platform = VER_PLATFORM_WIN32_NT) then
    Result := OpenServiceW(ManagerHandle, PWideChar(ServiceName), DesiredAccess)
  else
  {$ENDIF}
    // Note: the following uses the Wide-Version when using an Unicode capable
    // Delphi version (D2009+) but the Ansi-Version with lower Delphi versions.
    // Do not remove the string() type for this wanted and correct behaviour.
    Result := OpenService(ManagerHandle, PChar(string(ServiceName)), DesiredAccess);
end;

procedure WrappedQueryServiceStatus(const SvcHandle: SC_HANDLE;
  var ServiceStatus: TServiceStatus; const StatusWaitingFor: Cardinal);
var
  dwCheckPoint: DWORD;
begin
  if QueryServiceStatus(SvcHandle, ServiceStatus) then
  begin
    while (ServiceStatus.dwCurrentState <> StatusWaitingFor) do
    begin
      dwCheckPoint := ServiceStatus.dwCheckPoint;
      Sleep(ServiceStatus.dwWaitHint);
      if (not QueryServiceStatus(SvcHandle, ServiceStatus)) then
        // couldn't check status
        Break;
      if (ServiceStatus.dwCheckPoint < dwCheckPoint) then
        Break;
    end;
  end;
end;

function GetServiceStatus(const ServiceName, MachineName: UnicodeString): Cardinal;
{
  Parameters:
  ServiceName   specifies the name of the service to open
  MachineName   specifies the name of the target computer

  Return Values:
  0             Error opening service
  1             SERVICE_STOPPED
  2             SERVICE_START_PENDING
  3             SERVICE_STOP_PENDING
  4             SERVICE_RUNNING
  5             SERVICE_CONTINUE_PENDING
  6             SERVICE_PAUSE_PENDING
  7             SERVICE_PAUSED
}
var
  SCManHandle,
  SvcHandle: SC_Handle;
  ServiceStatus: TServiceStatus;
  dwStat: Cardinal;
begin
  dwStat := 0;
  SCManHandle := WrappedOpenServiceManager(MachineName);
  if SCManHandle > 0 then
  begin
    try
      SvcHandle := WrappedOpenService(SCManHandle, ServiceName,
        SERVICE_QUERY_STATUS);
      if SvcHandle > 0 then
      begin
        try
          if QueryServiceStatus(SvcHandle, ServiceStatus) then
            dwStat := ServiceStatus.dwCurrentState;
        finally
          CloseServiceHandle(SvcHandle);
        end;
      end;
    finally
      CloseServiceHandle(SCManHandle);
    end;
  end;
  Result := dwStat;
end;

//------------------------------------------------------------------------------
// public functions
//------------------------------------------------------------------------------

function IsServiceInstalled(const ServiceName: UnicodeString;
  const MachineName: UnicodeString = ''): Boolean;
begin
  Result := GetServiceStatus(ServiceName, MachineName) <> 0;
end;

function IsServiceRunning(const ServiceName: UnicodeString;
  const MachineName: UnicodeString = ''): Boolean;
begin
  Result := GetServiceStatus(ServiceName, MachineName) = SERVICE_RUNNING;
end;

function ServiceStart(const ServiceName: UnicodeString;
  const MachineName: UnicodeString = ''): Boolean;
var
  SCManHandle,
  SvcHandle: SC_Handle;
  ServiceStatus: TServiceStatus;
  ServiceArgVectors: PChar;
begin
  SCManHandle := WrappedOpenServiceManager(MachineName);
  if SCManHandle > 0 then
  begin
    try
      SvcHandle := WrappedOpenService(SCManHandle, ServiceName,
        SERVICE_START or SERVICE_QUERY_STATUS or SC_MANAGER_ALL_ACCESS);
      if SvcHandle > 0 then
      begin
        try
          if StartService(SvcHandle, 0, ServiceArgVectors) then // succeeded
            WrappedQueryServiceStatus(SvcHandle, ServiceStatus, SERVICE_RUNNING);
        finally
          CloseServiceHandle(SvcHandle);
        end;
      end;
    finally
      CloseServiceHandle(SCManHandle);
    end;
  end;
  Result := (ServiceStatus.dwCurrentState = SERVICE_RUNNING);
end;

function ServiceStop(const ServiceName: UnicodeString;
  const MachineName: UnicodeString = ''): Boolean;
var
  SCManHandle,
  SvcHandle: SC_Handle;
  ServiceStatus: TServiceStatus;
begin
  SCManHandle := WrappedOpenServiceManager(MachineName);
  if SCManHandle > 0 then
  begin
    try
      SvcHandle := WrappedOpenService(SCManHandle, ServiceName,
        SERVICE_STOP or SERVICE_QUERY_STATUS);
      if SvcHandle > 0 then
      begin
        try
          if ControlService(SvcHandle, SERVICE_CONTROL_STOP, ServiceStatus) then
            WrappedQueryServiceStatus(SvcHandle, ServiceStatus, SERVICE_STOPPED);
        finally
          CloseServiceHandle(SvcHandle);
        end;
      end;
    finally
      CloseServiceHandle(SCManHandle);
    end;
  end;
  Result := (ServiceStatus.dwCurrentState = SERVICE_STOPPED);
end;

function ServiceRestart(const ServiceName: UnicodeString;
  const MachineName: UnicodeString = ''): Boolean;
begin
  Result := ServiceStop(ServiceName, MachineName) and
    ServiceStart(ServiceName, MachineName);
end;

end.

[Luckie]

Na ja, anstatt so eine lose Sammlung von Funktionen, sollte man das doch mal sauber in einer Klasse kapseln, denke ich.

[ralfiii]

Zitat:

Zitat von Luckie (Beitrag 1122615)

Na ja, anstatt so eine lose Sammlung von Funktionen, sollte man das doch mal sauber in einer Klasse kapseln, denke ich.

Find ich in dem Fall nicht.
Objekte machen natürlich schon Sinn, aber doch eher wenn irgendwas persistent bleibt, oder?
Bei Services wird man im Allgemeinen checken ob sie laufen, irgendwann starten, irgendwann stoppen.
Da dazwischen das Objekt aufzubehalten hat ja echt keinen Mehrwert.

Wenn's denn unbedingt sein muss könnte man Class-functions draus machen.

[ASM]

Zitat:

Zitat von Luckie (Beitrag 1122615)

Na ja, anstatt so eine lose Sammlung von Funktionen, sollte man das doch mal sauber in einer Klasse kapseln, denke ich.

Gibt's doch schon, sogar als Komponente einsetzbar: http://www.programmersheaven.com/mb/...n-delphi-code/

[Luckie]

Zitat:

Zitat von ralfiii (Beitrag 1122620)

Zitat:

Zitat von Luckie (Beitrag 1122615)

Na ja, anstatt so eine lose Sammlung von Funktionen, sollte man das doch mal sauber in einer Klasse kapseln, denke ich.

Find ich in dem Fall nicht.

Denke schon, da die Funktionen ein paar Gemeinsamkeiten haben, wie zum Beispiel den Computernamen und so. Und global muss das Objekt auch nicht sein.

Ich finde so was nicht schlecht:

Delphi-Quellcode:

ServiceManager := TServicemanager.Create;
ServiceManager.Computer := 'Komm_Puter';
ServiceManager.Service := 'Kaffee_Servcice';
Servicemanager.StartService;

Es geht ja auch darum, dass zusammengehörige Funktionen auch logisch in einer Klasse zusammengefasst werden und nicht nur physisch in einer Unit.

[ralfiii]

Zitat:

Zitat von Luckie (Beitrag 1122634)

Ich finde so was nicht schlecht:

Delphi-Quellcode:

ServiceManager := TServicemanager.Create;
ServiceManager.Computer := 'Komm_Puter';
ServiceManager.Service := 'Kaffee_Servcice';
Servicemanager.StartService;

Es geht ja auch darum, dass zusammengehörige Funktionen auch logisch in einer Klasse zusammengefasst werden und nicht nur physisch in einer Unit.

Hmmm

Delphi-Quellcode:

StringConcat:=TStringConcatter.Create;
StringConcat.FirstString:='Bisserl overkill, ';
StringConcat.SecondString:='findest nicht?';
StringConcat.PerformStringConcatting;
ShowMessage(StringConcat.ConcatResult;

:)
Objektorientiert ist nicht IMMER besser - meine Meinung halt.
Mir gefällt jedenfalls "ServiceStart('Komm_Puter', 'Kaffee_Servcice')" deutlich besser.

[Luckie]

Natürlich tut der Code das gleiche, keine Frage. Es geht mir in diesem Fall mehr um "aufgeräumten" Code.

Oder so:

Delphi-Quellcode:

ServiceManager := TServiceManager.Create('Komm_Puter', 'Kaffee_Service');
ServiceManager.Start;

[Sir Rufo]

Ich schmeiss mich da mal auf Luckies Seite.

Bei einem Service kann es durchaus sein, dass man den Dienst starten möchte und nach einer Zeit x wieder anhalten möchte.

Gerade kursiert hier auch noch ein CodeFragment rum, was die Statusänderungen von Services überwacht.
Das komplett in eine Klasse gegossen würde definitiv Sinn machen.

Für alle Hardcore Fans können die Funktionen auch als Class Functions zusätzlich verfügbar gemacht werden.

Delphi-Quellcode:

ServiceControl := TServiceControl.Create( 'MeinService', 'DerComputer' );
ServiceControl.OnStart := ServiceStart;
ServiceControl.Start;

TServiceControl.Start( 'DeinService', 'DeinComputer' );

[Luckie]

Zitat:

Zitat von Sir Rufo (Beitrag 1122754)

Ich schmeiss mich da mal auf Luckies Seite.

Danke. ;)

[Ludger Seegers]

Hallo Leute kann mir einer dabei helfen?

Ich möchte aus einer ISAPI-DLL / Webserver-Anwendung prüfen ob ein bestimmter Dienst gestartet ist.

In einem normalen Programm erhalte ich den Status korrekt.
Wenn diese Funktion in der Webserveranwendung einbaue liefert die Funktion
OpenService(SCManHandle, sService, SC_MANAGER_ALL_ACCESS) immer nur den wert 0 zurück.

Liegt das evtl. an irgendwelchen Rechten?

Danke für die Info voraus.

Ludger Seegers

function ServiceGetStatus(sMachine, sService: PChar): DWORD;
var
SCManHandle, SvcHandle: SC_Handle;
SS: TServiceStatus;
dwStat: DWORD;
begin
dwStat := 0;
SCManHandle := OpenSCManager(sMachine, nil, SC_MANAGER_CONNECT);
SaveInfo('SCmanHandle',asr(SCmanHandle));
if (SCManHandle > 0) then
begin
SvcHandle := OpenService(SCManHandle, sService, SC_MANAGER_ALL_ACCESS);
SaveInfo('SvcHandle',asr(SvcHandle));
if (SvcHandle > 0) then
begin
if (QueryServiceStatus(SvcHandle, SS)) then
dwStat := SS.dwCurrentState;
CloseServiceHandle(SvcHandle);
end;
CloseServiceHandle(SCManHandle);
end;
Result := dwStat;
end;

function ServiceRunning(sMachine, sService: PChar): Boolean;
begin
Result := SERVICE_RUNNING = ServiceGetStatus(sMachine, sService);
end;

[Luckie]

Und was sagt GetLastError dazu?

[Ludger Seegers]

Ich habe Getlasterror mal direkt nach dem Functionsaufruf abgefragt.
Getlasterror liefert aber keinen Fehler zurück

[Luckie]

Sondern? Schreib ihn in eine Logdatei, weil einen Dialog wirst du von deinem Dienst nicht sehen.

[Ludger Seegers]

Getlasterror liefert "Zugriff verweigert" zurück
Bei der isapi.dll sind alle möglichen Berechtigungen: lesen, schreiben, ausführen gesetzt.
Ich benutze den IIS7.5 auf Windows Webserver 2008 und Windows 7.
Auf beiden Rechnern habe habe ich dieses Problem.

Was kann ich machen?

Ludger Seegers

[Ludger Seegers]

Problem gelöst

Es liegt daran das für den Zugriff auf die Dienste noch keine Rechte vergeben wurden.

Einfach im IIS unter Default Web Site ein Virtuelles Verzeichnis anlegen. Beim Anlegen erscheint eine Taste "Verbinden als", diese drücken und dort die Anmeldedaten vom Admin eingeben.

Dann funktioniert's..