Wie erstelle ich einen Dienst für WinNT / Win2000 / Win XP

[MaBuSE]

Ich habe in dem Beitrag ISDN-Anrufmonitor eine kleine Anleitung zu Diensten geschrieben, das gehört aber eigentlich hier hin :mrgreen:

Was ist ein Dienst?
In WinNT/Win2000/WinXP (und neuer) gibt es die Möglichkeit Programme schon beim Starten des Betriebssystems, noch bevor sich ein Benutzer anmeldet, auszuführen. Diese Programme werden als Dienste (engl: Service) bezeichnet. Diese Dienste werden über die Diensteverwaltung gesteuert.
Mit Systemsteuerung -> Verwaltung -> Dienste kommt man zur Diensteverwaltung. hier kann man sehen welche Dienste auf dem Rechner verfügbar sind. Es ist auch der Status und die Beschreibung zu sehen.
(Von der Konsole (cmd.exe) kann man mit "net start" eine Liste der gestarteten Dienste sehen.)

Wie erstellt man einen Dienst?
Unter Delphi 7 geht das ganz einfach.
(Ich habe gerade mal Delphi 5 gestartet, dort geht es auch.)

• Menü Datei -> Neu... aufrufen.
• In der Objektgalerie -> Neu -> Service Anwendung aufrufen.
• Das Grundgerüst zu einem Dienst ist nun da. (Projekt1.dpr und Unit1.pas/dfm)
  
• Es wird eine Unit1.pas mit dem TService namens Service1 angezeigt. (nicht visuelles Form)
• In den Eigenschaften gibt es
  • DisplayName - Das ist der Name des Dienstes, der in der Diensteverwaltung angezeigt wird.
  • Interactive - sollte True sein und bedeutet, das der Dienst auch mit dem Benutzer interagieren darf
    (z.B. Dialogfenster, Icon in der Taskleiste (TNA), ...)
  • Dependencies - Abhängigkeiten von anderen Diensten: z.B. "Telefonie" (TAPI)
• über die Ereignisse wird der Code ausgeführt:
  • onExecute - Das ist das Hauptereignis:
    Es wird aufgerufen wenn der Dienst ausgeführt wird. In diesem Ereignis sollte eine Schleife stehen die die Tätigkeiten des Dienstes ausführt. Benutzt Du eine Komponente (z.B. TTimer) um die Anrufe zu pollen dann z.B.
    Delphi-Quellcode:

    ...
      while not Terminated do
      begin
        ServiceThread.ProcessRequests(False);
      end;
    ...

    Wenn Du das selbst in einer Schleife macht z.B.
    Delphi-Quellcode:

    ...
      while not Terminated do
      begin
        ServiceThread.ProcessRequests(False); 
    
        if isTelephoneCall then 
        begin
          // show Infos about Call
        end;
      end;
    ...

Die Hilfe von Delphi enthält weitere Infos

Zu jedem Dienst wird ein TServiceTread ausgeführt. (Es können auch mehrere Dienste in einer Exe enthalten sein.) Sollten mehrere Dienste in einer Applikation enthalten sein muss unbedingt threadsicher programmiert werden. Der TServiceThread ist so gestaltet, dass die Funktionalität des Dienstes in der OnExecute implementiert wird. Der TServiceThread hat seine eigene Execute Methode die OnStart und OnExecute aufruft.

Delphi-Quellcode:

{*******************************************************}
{       Borland Delphi Visual Component Library         }
{       Services                                        }
{       Copyright (c) 1997,99 Inprise Corporation       }
{*******************************************************}
unit SvcMgr;
...
procedure TServiceThread.Execute;
...
    FService.Status := csStartPending;
    Started := True; 
    if Assigned(FService.OnStart) then FService.OnStart(FService, Started);
    // wird Started in OnStart aud False gesetzt wird OnExecute nie aufgerufen
    if not Started then Exit; 
    try
      FService.Status := csRunning;
      if Assigned(FService.OnExecute) 
        then FService.OnExecute(FService) // onExecute aufrufen 
        else ProcessRequests(True);
      ProcessRequests(False);
...

Da die Ausführung der OnStart / OnExecute zeit braucht kann der Thread derweil nicht auf simultane Anfragen von anderen Clients reagieren. Deshalb kann man auch einen eigenen Thread erzeugen.
Das würde dann so aussehen:

Delphi-Quellcode:

...
  TeigenerThread = class(TThread)
    public
      procedure Execute; override;
  end;
...
var
  eigenerThread: TeigenerThread;
...
procedure TeigenerThread.Execute;
begin
  while not Terminated do
  begin
    Beep;
    // Das braucht die Zeit, in der sonst der Dienst tot wäre.
    Sleep(500); 
  end;
end;
...
procedure TService1.Service1Start(Sender: TService; var Started: Boolean);
begin
  eigenerThread := TeigenerThread.Create(False);
  Started := True;
end;
...
procedure TService1.Service1Continue(Sender: TService; var Continued: Boolean);
begin
  eigenerThread.Resume;
  Continued := True;
end;
...
procedure TService1.Service1Pause(Sender: TService; var Paused: Boolean);
begin
  eigenerThread.Suspend;
  Paused := True;
end;
...
procedure TService1.Service1Stop(Sender: TService; var Stopped: Boolean);
begin
  eigenerThread.Terminate;
  Stopped := True;
end;
...

Das der TeigeneThread thadtsicher programmiert werden sollte versteht sich ja von selbst.

Mein Tipp:
Schreib dir mal einen Dienst, der in jedem Ereignis nur ein ShowMessage stehen hat.
Damit kannst Du dann schnell rausbekommen wann welche Ereignisse aufgerufen werden.
z.B.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, SvcMgr, Dialogs;

type
  TService1 = class(TService)
    procedure ServiceAfterInstall(Sender: TService);
    procedure ServiceAfterUninstall(Sender: TService);
    procedure ServiceBeforeInstall(Sender: TService);
    procedure ServiceBeforeUninstall(Sender: TService);
    procedure ServiceContinue(Sender: TService; var Continued: Boolean);
    procedure ServiceCreate(Sender: TObject);
    procedure ServiceDestroy(Sender: TObject);
    procedure ServiceExecute(Sender: TService);
    procedure ServicePause(Sender: TService; var Paused: Boolean);
    procedure ServiceShutdown(Sender: TService);
    procedure ServiceStart(Sender: TService; var Started: Boolean);
    procedure ServiceStop(Sender: TService; var Stopped: Boolean);
  private
    { Private-Deklarationen }
  public
    function GetServiceController: TServiceController; override;
    { Public-Deklarationen }
  end;

var
  Service1: TService1;

implementation

{$R *.DFM}

procedure ServiceController(CtrlCode: DWord); stdcall;
begin
  Service1.Controller(CtrlCode);
end;

function TService1.GetServiceController: TServiceController;
begin
  Result := ServiceController;
end;

procedure TService1.ServiceAfterInstall(Sender: TService);
begin
  showMessage('AfterInstall');
end;

procedure TService1.ServiceAfterUninstall(Sender: TService);
begin
  showMessage('AfterUninstall');
end;

procedure TService1.ServiceBeforeInstall(Sender: TService);
begin
  showMessage('BeforeInstall');
end;

procedure TService1.ServiceBeforeUninstall(Sender: TService);
begin
  showMessage('BeforeUninstall');
end;

procedure TService1.ServiceContinue(Sender: TService;
  var Continued: Boolean);
begin
  showMessage('OnContinue');
  Continued := True;
end;

procedure TService1.ServiceCreate(Sender: TObject);
begin
  showMessage('OnCreate');
end;

procedure TService1.ServiceDestroy(Sender: TObject);
begin
  showMessage('OnDestroy');
end;

procedure TService1.ServiceExecute(Sender: TService);
begin
  showMessage('OnExecute - begin');
  while not Terminated do
  begin
    ServiceThread.ProcessRequests(False);
  end;
  showMessage('OnExecute - end');
end;

procedure TService1.ServicePause(Sender: TService; var Paused: Boolean);
begin
  showMessage('OnPause');
  Paused := True;
end;

procedure TService1.ServiceShutdown(Sender: TService);
begin
  showMessage('OnShutdown');
end;

procedure TService1.ServiceStart(Sender: TService; var Started: Boolean);
begin
  showMessage('OnStart');
  Started := True;
end;

procedure TService1.ServiceStop(Sender: TService; var Stopped: Boolean);
begin
  showMessage('OnStop');
  Stopped := True;
end;

end.

Die erzeugte Exe Datei mußt Du Mit dem Parameter INSTALL aufrufen um den Dienst zu registrieren.
Mit Projekt1.exe UNINSTALL kannst Du den Dienst wieder aus der Diesteverwaltung entfernen.

Ich hoffe das hilft Dir erst mal weiter.

[Luckie]

Zitat:

Zitat von MaBuSE

Mein Tipp:
Schreib dir mal einen Dienst, der in jedem Ereignis nur ein ShowMessage stehen hat.

Dazu muss es aber ein interaktiver Dienst sein, sonst sieht man nichts. Dienste laufen auf dem Systemkonto mit allen Rechten und dazugehörigen Privilegien des Systemkontos. Ein Dienst läuft auch in einer anderen WindowsStation und können somit nicht mit der interaktiven WindowsStation und dem Desktop des Benutzer interagieren. Erst wenn es ein interaktiver Dienst ist kann er das. Man sollte sich aber den Risiken bewußt sein, den ein interaktiver Dienst mit sich bringr. Hier zu sei auch der Artikel Shatter Attack zu empfehlen. Generell rät auch Micosoft davon ab interaktive Dienste aus sicherheits Gründen nicht zu verwenden.

[mh166]

Und mal als kleine Anmerkung nebenbei: die Komponenten SvCom scheinen auch nicht schlecht zu sein. Habe zwar noch nicht damit gearbeitet, aber die Webseite mal durchgeguckt. Sehr interessant ist besonders auch die Kompatibilität zu Win9X! Schade eigentlich, dass die 99$ kosten. Aber irgendwo kann ich das shcon nachvollziehen. Vielleicht hat ja schon jemand damit gearbeitet?

Ansonsten: geiles Tutorial, MaBuSE. Werd ich mal ausprobieren. Könnte ich nämlich in einem meiner nächsten Projekte vielleicht gebrauchen... :)

mfg, mh166

[MaBuSE]

Zitat:

Zitat von Luckie

Zitat:

Zitat von MaBuSE

Mein Tipp:
Schreib dir mal einen Dienst, der in jedem Ereignis nur ein ShowMessage stehen hat.

Dazu muss es aber ein interaktiver Dienst sein, sonst sieht man nichts.

Das steht auch im Tutorial:

Zitat:

Zitat von MaBuSE

...
In den Eigenschaften gibt es

• DisplayName - Das ist der Name des Dienstes, der in der Diensteverwaltung angezeigt wird.
• Interactive - sollte True sein und bedeutet, das der Dienst auch mit dem Benutzer interagieren darf
  (z.B. Dialogfenster, Icon in der Taskleiste (TNA), ...)

...

Das sollte auf True sein bezieht sich auf den ISDN Monitor für diesen der Beitrag geschrieben wurde.

Ansonsten hat Luckie Recht ;-)

[Luckie]

Oh, aber nichts destotrotz sollte man meine Sicherheisthinweise beachten. Eventuell kannst du noch auf Ollis nonVCL NT Service Tutorial verweisen. Die Service Vorlage gibt es nämlich erst ab der Professional Version von Delphi.

Die Links:
http://www.michael-puff.de/dirindex....orte/Assarbad/
http://assarbad.net/de/stuff

[MaBuSE]

Zitat:

Zitat von Luckie

Eventuell kannst du noch auf Ollis nonVCL NT Service Tutorial verweisen.

Meinst Du das hier:

• NT-Services von Assarbad
  Wie man selbst Services für Windows NT erstellt
  http://www.dsdt.info/tutorials/ntservice/

Es gibt auch noch einen englischen Text von Borland zu Services:
http://info.borland.com/techpubs/del...g/buildap.html
Dort steht auch wie man Dienste debuggt.
(Ich habe den Teil mit den TeigenerThread an diesen Text angelehnt.)

Es ist auch ein Beispiel in der Hilfe von Delphi vorhanden.
Dieser Beispiel Dienst lauscht an Port 80 un loggt die Zugriffe in eine Textdatei.

In der Delphi Hilfe nach "Service-Anwendungen" suchen.

[Luckie]

Zitat:

Zitat von MaBuSE

Meinst Du das hier:

• NT-Services von Assarbad
  Wie man selbst Services für Windows NT erstellt
  http://www.dsdt.info/tutorials/ntservice/

Ja, das ist da wohl.

[Westcliff]

Noch was kleines zum Thema:

Erstellung eines Services mittels der Delphi-Vorlage (TService) hat eigentlich prima funktioniert. Auch das installieren mit PROGRAMMNAME /install bzw. /uninstall.
Hat man allerdings den Dienst via InstallShield versucht zu installieren, hat das jedesmal einen Fehler 1053 nach sich geführt und der Dienst lies sich nicht installieren.

Hab das jetzt auf Asserbads API-Gerüst gesetzt und siehe da - nun geht es auch mit Installshield.
Hat mich dennoch ein wenig verwirrt und ich weiss noch nicht ganz, wem ich da jetz die Schuld in die Schuhe schieben soll ;)

[mimi]

Zitat:

# Menü Datei -> Neu... aufrufen.
# In der Objektgalerie -> Neu -> Service Anwendung aufrufen.
# Das Grundgerüst zu einem Dienst ist nun da. (Projekt1.dpr und Unit1.pas/dfm)

ich finde den menupunkt bei mir nicht unter neu.... in der objektgallerie ! liegt das an d7 PE ?

[sakura]

Zitat:

Zitat von mimi

liegt das an d7 PE ?

Ja, Dienste gibt es in den PE-Versionen nicht. Da müsste alles vonhand gemacht werden :?

...:cat:...

[mimi]

ah alles klar, ich möchte auch kakein dienst erstlelen, war nur mal so ne frage *G*

[Andru]

Hi,
erstmal vielen Dank für dieses TUT. Hat mir auf jeden Fall super weitergeholfen.
Mein Problem jedoch ist, wenn ich den Service installiert habe und starte,
startet er meine Anwendung (ShellExecute in der ServiceStart-Prozedur), aber der Status
in der Dienste verwaltung ändert sich nicht.
Es steht zwar, dass der Dienst gestartet ist, aber ich habe nicht die Möglichkeit ihn wieder
zu beenden.
Was mache ich denn noch falsch? Wird der Status nicht über 'started := true' übergeben?

Hoffe, Ihr könnt mir weiterhelfen!

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, SvcMgr, Dialogs,
  shellAPI, tlhelp32;

type
  TTestService = class(TService)
    procedure ServiceAfterInstall(Sender: TService);
    procedure ServiceAfterUninstall(Sender: TService);
    procedure ServiceBeforeInstall(Sender: TService);
    procedure ServiceBeforeUninstall(Sender: TService);
    procedure ServiceContinue(Sender: TService; var Continued: Boolean);
    procedure ServiceCreate(Sender: TObject);
    procedure ServiceDestroy(Sender: TObject);
    procedure ServiceExecute(Sender: TService);
    procedure ServicePause(Sender: TService; var Paused: Boolean);
    procedure ServiceShutdown(Sender: TService);
    procedure ServiceStart(Sender: TService; var Started: Boolean);
    procedure ServiceStop(Sender: TService; var Stopped: Boolean);

  private
    { Private-Deklarationen }
  public
    function GetServiceController: TServiceController; override;
    { Public-Deklarationen }
  end;

var
  TestService: TTestService;
  ProgHandle, RemoteHandle: THandle;

implementation

{$R *.DFM}

procedure ServiceController(CtrlCode: DWord); stdcall;
begin
  TestService.Controller(CtrlCode);
end;

function TTestService.GetServiceController: TServiceController;
begin
  Result := ServiceController;
end;

procedure TTestService.ServiceAfterInstall(Sender: TService);
begin
  showMessage('AfterInstall');
end;

procedure TTestService.ServiceAfterUninstall(Sender: TService);
begin
  showMessage('AfterUninstall');
end;

procedure TTestService.ServiceBeforeInstall(Sender: TService);
begin
  showMessage('BeforeInstall');
end;

procedure TTestService.ServiceBeforeUninstall(Sender: TService);
begin
  showMessage('BeforeUninstall');
end;

procedure TTestService.ServiceContinue(Sender: TService;
  var Continued: Boolean);
begin
  showMessage('OnContinue');
  Continued := True;
end;

procedure TTestService.ServiceCreate(Sender: TObject);
begin
  showMessage('OnCreate');
   ServiceExecute(self);
end;

procedure TTestService.ServiceDestroy(Sender: TObject);
begin
  showMessage('OnDestroy');
end;

procedure TTestService.ServiceExecute(Sender: TService);
begin
  showMessage('OnExecute - begin');
{  while not Terminated do
  begin
    ServiceThread.ProcessRequests(False);
  end;
}


  showMessage('OnExecute - end');


end;

procedure TTestService.ServicePause(Sender: TService; var Paused: Boolean);
begin
  showMessage('OnPause');
  Paused := True;
end;

procedure TTestService.ServiceShutdown(Sender: TService);
begin
  showMessage('OnShutdown');
end;

procedure TTestService.ServiceStart(Sender: TService; var Started: Boolean);
begin
  ShellExecute(ProgHandle, 'open', PChar('notepad.exe'),
  Nil, Nil, SW_NORMAL);
 // showMessage('OnStart');
  Started := True;
end;

procedure TTestService.ServiceStop(Sender: TService; var Stopped: Boolean);
begin
  RemoteHandle := FindWindow(NIL,'unbenannt - Editor');
  if RemoteHandle<>0 then PostMessage(RemoteHandle, wm_close, 1, 1);
 // showMessage('OnStop');
  Stopped := True;
end;




end.

[franktron]

Zitat:

Zitat von MaBuSE

Die erzeugte Exe Datei mußt Du Mit dem Parameter INSTALL aufrufen um den Dienst zu registrieren.
Mit Projekt1.exe UNINSTALL kannst Du den Dienst wieder aus der Diesteverwaltung entfernen.

Ich hoffe das hilft Dir erst mal weiter.

Da hat sich ein kleiner Fehler eingeschlichen das mus Projekt1.exe /INSTALL und /UNINSTALL heisen

[stz]

Erstmal vielen Dank für das Tutorial :thumb:

Zitat:

Zitat von MaBuSE

Benutzt Du eine Komponente (z.B. TTimer) um die Anrufe zu pollen dann z.B.

Delphi-Quellcode:

...
  while not Terminated do
  begin
    ServiceThread.ProcessRequests(False);
  end;
...

Wenn ich das tatsächlich so mache (inklusive Timer) habe ich einen wunderbaren Dienst zum lahmlegen des Systems :?. Durch die Endlosschleife braucht der Thread fast 100% der CPU-Zeit. Deutlich besser ist in diesem Fall

Delphi-Quellcode:

ServiceThread.ProcessRequests(True);

Nun wartet ProcessRequest auf die nächste Message, bevor es weitergeht. Da man ja eh mit dem Timer auf genau eine solche wartet, empfiehlt sich das.

Ansonsten muss man zu mindestens irgendetwas tun, um die Endlosschleife zu entschärfen (sleep?!)

Noch eine weitere Frage: Kann ich auch irgendwie komfortabel eine Beschreibung definieren, die in Systemsteuerung -> Verwaltung -> Dienste angezeigt wird?

Gruß
Malte

PS: Ich hoffe ich darf den Thread nach so langer Zeit noch aufwärmen...

[SirThornberry]

mit der Funktion ChangeServiceConfig2A kannst du die Beschreibung ändern

Delphi-Quellcode:

function ChangeServiceConfig2A(hService: HWND; dwInfoLevel: DWord; lpInfo: Pointer): BOOL; stdcall; external 'advapi32.dll';
[...]
var
  lDescription    : TSERVICE_DESCRIPTION;
  lManager,
  lServiceHandle  : Cardinal;
begin
  lManager := OpenSCManager(nil, nil, SC_MANAGER_ALL_ACCESS);
  if (lManager <> 0) then
  begin
    lServiceHandle := OpenService(lManager, 'NameDeinesService'{bei Ableitung von TService wäre das: PChar(Self.Name)}, SERVICE_ALL_ACCESS);
    if (lServiceHandle <> 0) then
    begin
      lDescription.lpDescription := 'Deine Beschreibung';
      ChangeServiceConfig2A(lServiceHandle, SERVICE_CONFIG_DESCRIPTION, @lDescription);
      CloseServiceHandle(lServiceHandle);
    end;
    CloseServiceHandle(lManager);
  end;

[stz]

@SirThornberry: Das sieht doch ganz gut aus, aber...
Ich habe jetzt die Unit Winsvc eingebunden und mir den Typ TSERVICE_DESCRIPTION mithilfe des PSDKs zusammengebastelt:

Delphi-Quellcode:

type
  PServiceDescription = ^TServiceDescription;
  {$EXTERNALSYM _SERVICE_DESCRIPTION}
  _SERVICE_DESCRIPTION = record
    lpDescription: LPTSTR;
  end;
  {$EXTERNALSYM SERVICE_DESCRIPTION}
  SERVICE_DESCRIPTION = _SERVICE_DESCRIPTION;
  TServiceDescription = _SERVICE_DESCRIPTION;

Aber die Konstante SERVICE_CONFIG_DESCRIPTION kann ich nirgendwo finden :gruebel:

Gruß
Malte

[xZise]

Es wird hier häufig geschrieben, dass der Dienst möglichst nicht interaktiv sein sollte.
Nun wie kann ich dennoch etwas für den Benutzer ausgeben?
Mir schwebt ein Konzept vor, dass im Autostart sozusagen das Frontend (eine stinknormale exe) gestartet wird.
Aber ich weiß jetzt nicht wie man das machen könnte.

MfG
xZise

[mkinzler]

Das ist auch der zugehende Weg. Du musst entweder per Netzprotokoll oder durch Pipes, IPC o.ä. mit dem Dienst kommunizieren.

[Apollonius]

Wenn es nur um einfache Ausgabe geht, kann man auch die Messagebox mit MB_SERVICE_NOTIFICATION verwenden.

[xZise]

Zitat:

Zitat von Apollonius

Wenn es nur um einfache Ausgabe geht, kann man auch die Messagebox mit MB_SERVICE_NOTIFICATION verwenden.

Achso :) Das reicht dann auch eigentlich ;)

Nun eine ganz andere Frage zu der Schleife.
Und zwar erstelle ich eine UDP-Verbindung mithilfe von UdpSockUtil. Nun weiß ich nicht, wie ich die Schleife gestalten muss, weil das Pollen übernimmt ja die Komponente.
Aber der Dienst wird ja ohne "Aufgaben" beendet.
Kann man irgendwo sagen: "KillOnIdle := false"? ^^

MfG
xZise

[torud]

Ich fand das Tut auch ganz ok.
Was mir fehlte war ein Herunterladbares Beispielprojekt.

Ich habe es mir nun selbst so nachgestellt, um einen eigenen Service zu erstellen. Allerdings habe ich da noch ein kleines Problem. Ich habe mir auf das Formular der Unit1 eine TServerSocket gelegt, weil ich im Hintergrund eine solche permanente interne Verbindung zwischen verschiedenen lokalen Applikationen benötige und nicht will, dass der User eventuell vergisst die entsprechende Applikation zu starten. Der Service lässt sich kompilieren und auch installieren, aber ich kann mich mit keiner TClientSocket auf den Server verbinden. Woran kann das liegen?

Ich habe die gleichen Einstellungen der Server-Komponente mal in einer einfach Beispiel-Applikation nachgestellt. Da ist es mir durchaus möglich mich zu verbinden. Was ist hier das Problem? Muss ich Zusatzeinstellungen vornehmen? Denn soweit ich weiss, ist es durchaus möglich einen Service auch als Server laufen zu lassen.

[Olli]

Ich weiss nicht, aber in Zeiten von Vista kommt mir mein Tutorial von damals ziemlich ... veraltet ... vor :zwinker:

[Schwedenbitter]

Zitat:

Zitat von SirThornberry

Mit Source ist es wie mit Kunst - Hauptsache der Künstler versteht's

Die Frage nach den SERVICE_CONFIG_DESCRIPTION wurde schonmal gestellt, aber leider nicht beantwortet. Wäre es möglich, das auch für mich nochmal zu tun.

Im Übrigen würde auch ich mich über ein Beispielscode insbesondere unter Einbeziehung eines TTimer sehr freuen.

[kersm]

Hallo,

hab ein problem, versuche nach dem tut einen dienst für Vista mit TurboDelphi zu erstellen.

habe allerdings probleme damit, installieren funkt einwandfrei aber beim starten bekomme ich immer "Fehler 1053: Der Dienst antwortete nicht rechtzeitig auf die Start- oder Steuerungsanforderung."
Die message boxes, oncreate und afterinstall werden einwandfrei angezeigt...

mein code:

Delphi-Quellcode:

  
implementation

{$R *.DFM}

procedure ServiceController(CtrlCode: DWord); stdcall;
begin
  Service2.Controller(CtrlCode);
end;

function TService2.GetServiceController: TServiceController;
begin
  Result := ServiceController;
end;

procedure TService2.ServiceAfterInstall(Sender: TService);
begin
  ShowMessage('AfterInstall');
end;

procedure TService2.ServiceAfterUninstall(Sender: TService);
begin
  ShowMessage('AfterUnistall');
end;

procedure TService2.ServiceCreate(Sender: TObject);
begin
  ShowMessage('OnCreate');
end;

procedure TService2.ServiceExecute(Sender: TService);
begin
  ShowMessage('OnExecute - begin');
  while not Terminated do
  begin
    ServiceThread.ProcessRequests(False);
  end;
  ShowMessage('OnExecute - end');
end;

procedure TService2.ServiceStart(Sender: TService; var Started: Boolean);
begin
  ShowMessage('OnStart');
  Started := true;
end;

procedure TService2.ServiceStop(Sender: TService; var Stopped: Boolean);
begin
  ShowMessage('OnStop');
  Stopped := true;
end;

end.

bin für jede hilfe dankbar!

lg martin

[kersm]

Hallo zusammen,

weis niemnad etwas darüber?
Habe mittlerweile versucht den oben geposteten dienst unter winxp laufen zu lassen, mit dem gleichen resultat wie in vista..

[toms]

Was meint Google?
[google]Fehler 1053: Der Dienst antwortete nicht rechtzeitig auf die Start- oder Steuerungsanforderung.[/google]

[kersm]

Danke, aber Google hatte ich vorher schon ohne Erfolg bemüht...

Aber ich hab das Problem mitllerweile durch Herumprobieren gefunden:
Wenn ich alle ShowMessage entferne und durch LogFile schreiben ersetze funzt es plötzlich auf XP und VISTA...

Enfernen der Messages hatte ich sowieso vor aber, weils halt als einfaches BSP so gepostet war hatte ichs vergeblich so probiert...

[MaBuSE]

Zitat:

Zitat von kersm

Aber ich hab das Problem mitllerweile durch Herumprobieren gefunden:
Wenn ich alle ShowMessage entferne und durch LogFile schreiben ersetze funzt es plötzlich auf XP und VISTA...

Hallo,
Evtl hängt das damit zusammen:
[equote="MaBuSE schrieb in http://www.delphipraxis.net/internal...14ab97e#478354 "]

Zitat:

Zitat von Luckie

Zitat:

Zitat von MaBuSE

Mein Tipp:
Schreib dir mal einen Dienst, der in jedem Ereignis nur ein ShowMessage stehen hat.

Dazu muss es aber ein interaktiver Dienst sein, sonst sieht man nichts.

Das steht auch im Tutorial:

Zitat:

Zitat von MaBuSE

...
In den Eigenschaften gibt es

• DisplayName - Das ist der Name des Dienstes, der in der Diensteverwaltung angezeigt wird.
• Interactive - sollte True sein und bedeutet, das der Dienst auch mit dem Benutzer interagieren darf
  (z.B. Dialogfenster, Icon in der Taskleiste (TNA), ...)

...

Das sollte auf True sein bezieht sich auf den ISDN Monitor für diesen der Beitrag geschrieben wurde.

Ansonsten hat Luckie Recht ;-)[/equote]

Solange der Dialog erscheint, und nicht OK gedrückt wird, steht der Dienst.
Das würde den Timeout erklären.

Dumm nur wenn der Dialog nicht angezeigt wird, weil nicht interaktiv.

Ist aber nur eine Vermutung. Ich habe mich bisher noch nicht mit Vista beschäftigt.

[kersm]

Zitat:

Zitat von MaBuSE

Solange der Dialog erscheint, und nicht OK gedrückt wird, steht der Dienst.
Das würde den Timeout erklären.

Dumm nur wenn der Dialog nicht angezeigt wird, weil nicht interaktiv.

Ist aber nur eine Vermutung. Ich habe mich bisher noch nicht mit Vista beschäftigt.

Das Interactive Property war ihm ziemlich egal er hat die Messages von OnStart, OnExecute, OnStop weder im Vista noch im WinXP angezeigt.
Jedoch hat er beim install/uninstall jene von OnCreate, AfterInstall usw. angezeigt, deswegen hatte ich anfangs geglaubt das kann es nicht sein -> aber da wahr ich auf dem falschen Weg. :wall:
Der Grund wird wohl sein weil man ja beim install/uninstall die EXE 'normal' ausführt...

[davtix]

hi , ich hab mal zum testen einen dienst geschrieben und den in nem virtuellen win7 x64 installiert. jedoch lässt sich der dienst einfach nicht starten ...
was mach ich da falsch???

interactive ist auf true
bilder sind in der rar


so hab ich den dienst registriert:

Delphi-Quellcode:

function ServiceRegister(szMachine, szServiceFile, szServiceName,
  szDisplayName: pchar): Boolean;
var
  h_manager, h_svc: SC_Handle;
begin
  Result := false;
  h_manager := OpenSCManager(szMachine, nil, SC_MANAGER_ALL_ACCESS);
  if h_manager > 0 then begin

    h_svc := CreateService(h_manager,
      szServiceName,
      szDisplayName,
      SERVICE_START or SERVICE_QUERY_STATUS or _DELETE,
      SERVICE_WIN32_OWN_PROCESS, // or SERVICE_INTERACTIVE_PROCESS,
      SERVICE_AUTO_START,
      SERVICE_ERROR_NORMAL,
      szServiceFile,
      nil, nil, nil, nil, nil);

    if h_svc > 0 then begin
      result := true;
      CloseServiceHandle(h_svc);
    end;

    CloseServiceHandle(h_manager);
  end;
end;

Delphi-Quellcode:

ServiceRegister(pchar(edit2.text),pchar(edit3.Text),pchar(edit1.text),pchar(edit4.text));

und so den dienst geschrieben:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, SvcMgr, Dialogs,
  ExtCtrls;

type
  TService1 = class(TService)
   procedure ServiceExecute(Sender: TService);
    procedure ServiceStart(Sender: TService; var Started: Boolean);
  private
    { Private-Deklarationen }
  public
   function GetServiceController: TServiceController; override;
    { Public-Deklarationen }
  end;

var
  Service1: TService1;

implementation
{$R *.DFM}

procedure ServiceController(CtrlCode: DWord); stdcall;
begin
  Service1.Controller(CtrlCode);
end;

function TService1.GetServiceController: TServiceController;
begin
  Result := ServiceController;
end;

procedure TService1.ServiceExecute(Sender: TService);
begin
//  ShowMessage('OnExecute - begin');
  while not Terminated do
  begin
    ServiceThread.ProcessRequests(False);
  end;
//  ShowMessage('OnExecute - end');
end;


procedure TService1.ServiceStart(Sender: TService; var Started: Boolean);
begin
   Started := True;
end;

end.

[jaenicke]

Interaktive Dienste gab es mal als sicherheitstechnische Katastrophe unter Windows XP und früher. Seit Vista bzw. 7 gibt es sie zum Glück nicht mehr.

Interactive musst du also auf False setzen.

//EDIT:
Ich sehe aber schon, das eigentliche Problem ist etwas anderes. Du vergibst einen anderen Namen für den Dienst, behandelst das aber nicht in deinem Dienst. Der Dienst muss schon so heißen wie in deinem Dienst gesetzt. Denn Delphi sucht anhand des Namens nach dem korrekten TService Modul und hält daher dein TService1 für unpassend.