Unter welchem ​​Benutzer laufen Dienste in Windows? Windows-Dienste. Was sind Dienstleistungen?

Betriebsarten

In den meisten Fällen ist es Diensten untersagt, mit der Konsole oder dem Desktop von Benutzern (sowohl lokal als auch remote) zu interagieren, aber für einige Dienste ist eine Ausnahme möglich – Interaktion mit der Konsole (Sitzungsnummer 0, in der der Benutzer lokal registriert ist oder wenn die Der Dienst beginnt mstsc mit dem /console-Schalter).

Es gibt verschiedene Modi für Dienste:

  • Startverbot;
  • manueller Start (auf Anfrage);
  • automatischer Start beim Hochfahren des Computers;
  • automatischer (verzögerter) Start (eingeführt in Windows Vista und Windows Server 2008);
  • obligatorischer Dienst/Treiber (automatischer Start und Unmöglichkeit (für den Benutzer), den Dienst zu stoppen).

Hintergrundmodus

Windows-Dienste starten, stoppen und ändern

Dienste und ihre Attribute können in der MMC geändert werden:

In verschiedenen Ausführungen Betriebssysteme Einige Dienste können vorhanden sein, andere fehlen. Einige Anwendungen und Programme, die separat installiert werden, können auch eigene Dienste erstellen.

Liste der Microsoft Windows-Betriebssystemdienste

Anzeigename Dienstname Funktionen Beschreibung
DHCP-Client Dhcp Registriert und aktualisiert IP-Adressen und DNS-Einträge für diesen Computer. Wenn dieser Dienst beendet wird, kann dieser Computer keine dynamischen IP-Adressen beziehen und keine DNS-Updates durchführen.
DNS-Client Dnscache Der DNS-Clientdienst (dnscache) speichert DNS-Namen (Domain Name System) zwischen und registriert den vollständig qualifizierten Namen dieses Computers. Wenn der Dienst beendet wird, wird die DNS-Namensauflösung fortgesetzt. Die Ergebnisse von DNS-Namenswarteschlangen werden jedoch nicht zwischengespeichert und der Computername wird nicht registriert.
KtmRm für verteilten Transaktionskoordinator KtmRm Koordiniert Transaktionen zwischen MSDTC und dem Kernel Transaction Manager (KTM).
ReadyBoost EMDMgmt ReadyBoost Unterstützung zur Verbesserung der Systemleistung mithilfe der ReadyBoost-Technologie.
Superfetch SysMain Superfetch Erhält und verbessert die Systemleistung.
Windows-Audio Audiosrv Verwalten von Audio-Tools für Windows-Programme. Wenn dieser Dienst beendet wird, funktionieren Audiogeräte und Effekte nicht ordnungsgemäß.
Windows CardSpace idsvc Bietet eine sichere Möglichkeit zum Erstellen, Verwalten und Offenlegen digitaler Identitäten.
Automatisches Update WUAUSERV Inklusive Download und Installation Windows-Updates. Wenn der Dienst deaktiviert ist, können Sie die Funktionen auf diesem Computer nicht nutzen. Automatisches Update oder auf der Windows Update-Website.

Liste der von Microsoft-Anwendungen und -Programmen erstellten Dienste

Liste der Dienste, die von Anwendungen und Programmen anderer Hersteller erstellt wurden

siehe auch

Liste der Windows-Dienste

Links

  • pcs.suite101.com/article.cfm/index_of_services: Index der Windows XP-Dienste – Ein Index der Dienste, die unter Windows XP ausgeführt werden Betriebssystem
  • So entfernen Sie einen Dienst in Windows Vista oder Windows XP
  • Windows XP-Dienste (Russisch)

Wikimedia-Stiftung. 2010.

Sehen Sie, was „Windows-Dienste“ in anderen Wörterbüchern ist:

    Windows SharePoint Services (WSS) kostenloses Add-on Zu Microsoft Windows Server 2003 und 2008, die eine voll funktionsfähige Webplattform mit Unterstützung für die folgenden Funktionen implementieren: Content-Management-System, Tools für die Zusammenarbeit... ... Wikipedia

    Entwickler der Microsoft Windows-Betriebssystemfamilie ... Wikipedia

    Microsoft Windows-Komponente ... Wikipedia


Der Windows NT-Dienst ist ein spezieller Prozess, der über eine einheitliche Schnittstelle für die Interaktion mit dem Betriebssystem verfügt Windows-System N.T. Dienste werden in zwei Typen unterteilt: Win32-Dienste, die über den Service Control Manager (SCM) mit dem Betriebssystem interagieren, und Treiber, die mithilfe des Treiberprotokolls arbeiten. Windows-Geräte N.T. Wir werden später in diesem Artikel nur auf Win32-Dienste eingehen.

Anwendung von Dienstleistungen

Eine der wichtigsten Eigenschaften des Dienstes ist die Nichtinteraktivität. Ein typischer Dienst läuft im Hintergrund, unbemerkt vom durchschnittlichen Benutzer. Aus diesem Grund eignen sich Dienste am besten für die Implementierung der folgenden Arten von Anwendungen:

  • Server in Client-Server-Architektur (z. B. MS SQL, MS Exchange Server)
  • Netzwerk Windows-Dienste NT (Server, Workstation);
  • Server (in Bezug auf die Funktionalität) Komponenten verteilter Anwendungen (z. B. alle Arten von Überwachungsprogrammen).

Grundlegende Eigenschaften von Diensten

Der Dienst unterscheidet sich von einer regulären Win32-Anwendung durch drei Haupteigenschaften. Schauen wir uns jeden von ihnen an.

Erstens ist es möglich, den Dienst ordnungsgemäß zu stoppen (auszusetzen). Ein Benutzer oder eine andere Anwendung, die Standardmechanismen verwendet, hat die Möglichkeit, den Status eines Dienstes zu ändern – ihn von einem laufenden Zustand in einen angehaltenen Zustand zu versetzen oder ihn sogar an der Ausführung zu hindern. In diesem Fall erhält der Dienst vor der Änderung seines Status eine spezielle Benachrichtigung, dank derer er die für den Übergang in einen neuen Status erforderlichen Aktionen ausführen kann, beispielsweise die Freigabe belegter Ressourcen.

Zweitens die Möglichkeit, den Dienst zu starten, bevor der Benutzer registriert ist, und dadurch die Möglichkeit, überhaupt ohne registrierten Benutzer zu arbeiten. Jeder Dienst kann beim Start des Betriebssystems automatisch gestartet werden und seine Arbeit aufnehmen, noch bevor sich der Benutzer am System anmeldet.

Und schließlich die Fähigkeit, in einem beliebigen Sicherheitskontext zu arbeiten. Kontext Windows-Sicherheit NT definiert eine Reihe von Prozesszugriffsrechten auf verschiedene Systemobjekte und Daten. Im Gegensatz zu einer typischen Win32-Anwendung, die immer im Sicherheitskontext des aktuell am System angemeldeten Benutzers ausgeführt wird, kann für einen Dienst der Sicherheitskontext seiner Ausführung im Voraus bestimmt werden. Dies bedeutet, dass die Zugriffsrechte eines Dienstes auf Systemobjekte im Voraus definiert werden können und dadurch der Umfang seiner Aktivitäten eingeschränkt wird. Für Dienste gibt es eine spezielle Art von Standardsicherheitskontext namens „Lokales System“. Ein in diesem Kontext ausgeführter Dienst hat nur Rechte für Ressourcen auf dem lokalen Computer. Mit lokalen Systemrechten können keine Netzwerkoperationen durchgeführt werden, da nur dieser Kontext sinnvoll ist lokalen Computer und wird von anderen Computern im Netzwerk nicht erkannt.

Interaktion des Dienstes mit anderen Anwendungen

Jede Anwendung, die über die entsprechenden Rechte verfügt, kann mit dem Dienst interagieren. Bei der Interaktion geht es zunächst darum, den Status des Dienstes zu ändern, d. Es gibt drei Arten von Anfragen: Nachrichten von Diensten (zur Festlegung ihres Status), Anfragen im Zusammenhang mit der Änderung der Konfiguration eines Dienstes oder dem Erhalt von Informationen darüber und Anwendungsanfragen zur Änderung des Status eines Dienstes.

Um einen Dienst zu verwalten, müssen Sie zunächst sein Handle mithilfe der OpenService Win32-API-Funktion abrufen. Die StartService-Funktion startet einen Dienst. Bei Bedarf wird der Status des Dienstes durch Aufruf der ControlService-Funktion geändert.

Servicedatenbank

Informationen zu jedem Dienst werden in der Registrierung gespeichert – im Schlüssel HKLM\SYSTEM\CurrentControlSet\Services\ServiceName. Es enthält folgende Informationen:

  • Servicetyp. Gibt an, ob diese Anwendung nur einen Dienst implementiert (exklusiv) oder ob mehrere davon in der Anwendung vorhanden sind. Ein exklusiver Dienst kann in jedem Sicherheitskontext betrieben werden. Mehrere Dienste innerhalb derselben Anwendung können nur im LocalSystem-Kontext ausgeführt werden.
  • Starttyp. Automatisch – der Dienst startet beim Systemstart. Bei Bedarf – der Dienst wird vom Benutzer manuell gestartet. Deaktiviert – Der Dienst kann nicht gestartet werden.
  • Der Name des ausführbaren Moduls (EXE-Datei).
  • Startreihenfolge in Bezug auf andere Dienste. In manchen Fällen müssen ein oder mehrere andere Dienste ausgeführt werden, damit ein Dienst ordnungsgemäß funktioniert. In diesem Fall enthält die Registrierung Informationen zu den Diensten, die vor diesem gestartet wurden.
  • Sicherheitskontext für die Dienstausführung ( Netzwerkname und Passwort). Standardmäßig ist der Sicherheitskontext LocalSystem.

Anwendungen, die Informationen zu einem Dienst abrufen oder eine Diensteinstellung ändern möchten, müssen im Wesentlichen Informationen in der Datenbank des Dienstes in der Registrierung ändern. Dies kann über die entsprechenden Win32-API-Funktionen erfolgen:

  • OpenSCManager, CreateService, OpenService, CloseServiceHandle – um einen Dienst zu erstellen (öffnen);
  • QueryServiceConfig, QueryServiceObjectSecurity, EnumDependentServices, EnumServicesStatus – um Informationen über den Dienst zu erhalten;
  • ChangeServiceConfig, SetServiceObjectSecurity, LockServiceDatabase, UnlockServiceDatabase, QueryServiceLockStatus – um Dzu ändern.

Interne Struktur des Dienstes.

Damit dies geschieht, muss die Anwendung entsprechend strukturiert sein, nämlich einen bestimmten Satz von Funktionen (in C++-Begriffen) mit einer bestimmten Funktionalität enthalten. Schauen wir uns jeden einzelnen kurz an.

Hauptfunktion

Wie Sie wissen, ist die Hauptfunktion der Einstiegspunkt jeder Win32-Konsolenanwendung. Wenn der Dienst gestartet wird, wird zuerst der Code für diese Funktion ausgeführt. Innerhalb von 30 Sekunden nach dem Start muss die Hauptfunktion StartServiceCtrlDispatcher aufrufen, um eine Verbindung zwischen der Anwendung und dem SCM herzustellen. Die gesamte Kommunikation zwischen einem beliebigen Dienst in einer bestimmten Anwendung und dem SCM erfolgt innerhalb der StartServiceCtrlDispatcher-Funktion, die erst beendet wird, nachdem alle Dienste in der Anwendung gestoppt wurden.

ServiceMain-Funktion

Zusätzlich zum prozessweiten Einstiegspunkt gibt es auch einen separaten Einstiegspunkt für jeden der in der Anwendung implementierten Dienste. Die Namen der Funktionen, die Service-Einstiegspunkte sind (der Einfachheit halber nennen wir sie alle gleich: ServiceMain), werden beim Aufruf von StartServiceCtrlDispatcher in einem der Parameter an SCM übergeben. Wenn jeder Dienst gestartet wird, wird ein separater Thread erstellt, um ServiceMain auszuführen.

Nachdem ServiceMain die Kontrolle erhalten hat, muss es zunächst für jeden Dienst in der Anwendung einen Dienstanforderungshandler, die Handler-Funktion, registrieren. Darauf folgen in ServiceMain normalerweise einige Aktionen zur Initialisierung des Dienstes – Zuweisen von Speicher, Lesen von Daten usw. Diese Aktionen müssen von SCM-Benachrichtigungen begleitet sein, dass der Dienst noch gestartet wird und keine Fehler aufgetreten sind. Benachrichtigungen werden über Aufrufe der SetServiceStatus-Funktion gesendet. Alle Aufrufe außer dem allerletzten müssen mit dem Parameter SERVICE_START_PENDING erfolgen, und der jüngste muss mit dem Parameter SERVICE_RUNNING erfolgen. Die Häufigkeit der Aufrufe wird vom Dienstentwickler anhand der folgenden Bedingung bestimmt: Die Dauer des Zeitintervalls zwischen zwei benachbarten SetServiceStatus-Aufrufen darf den Wert des dwWaitHint-Parameters, der beim ersten der beiden Aufrufe an den SCM übergeben wurde, nicht überschreiten. Andernfalls wird SCM den Dienst zwangsweise stoppen, da er die nächste Benachrichtigung nicht rechtzeitig erhält. Mit dieser Methode können Sie verhindern, dass der Dienst aufgrund des Auftretens bestimmter Fehler startet (denken Sie daran, dass Dienste normalerweise nicht interaktiv sind und in Abwesenheit des Benutzers gestartet werden können). Die übliche Praxis besteht darin, dass der SCM nach Abschluss des nächsten Initialisierungsschritts benachrichtigt wird.

Handler-Funktion

Wie oben erwähnt, ist Handler ein Prototyp einer Callback-Funktion, ein Service-Request-Handler, der für jeden Service in der Anwendung einzigartig ist. Der Handler wird aufgerufen, wenn der Dienst eine Anfrage empfängt (Start, Pause, Wiederaufnahme, Stopp, aktuelle Statusmeldung) und führt die erforderlichen Aktionen entsprechend der Anfrage aus und meldet anschließend den neuen Status an den SCM.

Besonders hervorzuheben ist eine Anfrage – die Anfrage, die beim Herunterfahren des Systems (Shutdown) eingeht. Diese Anfrage signalisiert die Notwendigkeit einer Deinitialisierung und Beendigung. Microsoft gibt an, dass jedem Dienst 20 Sekunden Zeit zum Herunterfahren gegeben wird, bevor er zum Stoppen gezwungen wird. Tests haben jedoch gezeigt, dass diese Bedingung nicht immer erfüllt ist und der Dienst vor Ablauf dieser Zeitspanne zwangsweise beendet werden muss.

Service-Sicherheitssystem

Für jede Aktion an Diensten muss die Anwendung über entsprechende Rechte verfügen. Alle Anwendungen haben das Recht, eine Verbindung zum SCM herzustellen, Dienste aufzulisten und zu prüfen, ob die Dienstdatenbank blockiert ist. Nur Anwendungen mit Administratorrechten können einen neuen Dienst im System registrieren oder die Dienstdatenbank blockieren.

Jeder Dienst verfügt über eine Sicherheitsbeschreibung, die beschreibt, welche Benutzer Rechte für welchen Vorgang haben. Default:

  • Alle Benutzer verfügen über die Rechte SERVICE_QUERY_CONFIG, SERVICE_QUERY_STATUS, SERVICE_ENUMERATE_DEPENDENTS, SERVICE_INTERROGATE und SERVICE_USER_DEFINED_CONTROL;
  • Benutzer der Gruppe Power Users und des LocalSystem-Kontos verfügen zusätzlich über die Rechte SERVICE_START, SERVICE_PAUSE_CONTINUE und SERVICE_STOP;
  • Benutzer, die zu den Gruppen „Administratoren“ und „Systembetreiber“ gehören, verfügen über das Recht SERVICE_ALL_ACCESS.

Dienste und Interaktivität

Standardmäßig können interaktive Dienste nur im LocalSystem-Sicherheitskontext ausgeführt werden. Dies liegt an den Besonderheiten der Anzeige auf dem Monitorbildschirm in Windows NT, wo es beispielsweise ein Objekt wie „Desktop“ gibt, für dessen Arbeit Sie über die entsprechenden Zugriffsrechte verfügen müssen, was bei einem beliebigen Objekt möglicherweise nicht der Fall ist haben. Konto, außer LocalSystem. Trotz der Tatsache, dass diese Einschränkung in den allermeisten Fällen nicht erheblich ist, besteht manchmal die Notwendigkeit, einen Dienst zu erstellen, der Informationen auf dem Monitorbildschirm anzeigt und gleichzeitig in einem anderen Sicherheitskontext als LocalSystem ausgeführt wird, z Beispiel: eine Anwendungsserverkomponente zum Ausführen von Anwendungen auf einem Remotecomputer.

Codeausschnitt von . veranschaulicht diese Möglichkeit.

In diesem Fragment zeigt der Dienst als Reaktion auf eine von der Clientseite der Anwendung als RPC-Konsequenz gesendete Anfrage eine Textnachricht auf dem Monitorbildschirm an.

Beispieldienst (Schlüsselausschnitte)

Schauen wir uns das Beispiel von Schlüsselfragmenten einer Anwendung in C++ an, die einen Windows NT-Dienst implementiert. Aus Gründen der Übersichtlichkeit wurden nicht wesentliche Teile des Codes weggelassen.

Hauptfunktion

Der Hauptfunktionscode ist in B dargestellt.

ServiceMain-Funktion

Ein Merkmal des in ServiceMain enthaltenen Codes besteht darin, dass es oft unmöglich ist, die Ausführungszeit eines bestimmten Vorgangs im Voraus vorherzusagen, insbesondere wenn man bedenkt, dass seine Ausführung auf einem Betriebssystem mit präemptivem Multitasking erfolgt. Wenn der Vorgang länger dauert als das im Aufrufparameter SetServiceStatus angegebene Zeitintervall, kann der Dienst die nächste Benachrichtigung nicht rechtzeitig senden, was dazu führt, dass SCM seinen Vorgang stoppt. Beispiele für mögliche Vorgänge könnten Aufrufe von Netzwerkfunktionen mit großen Zeitüberschreitungen oder einmaliges Lesen sein große Menge Informationen aus langsamen Medien. Darüber hinaus ist dieser Ansatz beim Debuggen eines Dienstes völlig unbrauchbar, da die Ausführung des Programms im Debugger mit langen Pausen einhergeht, die für den Entwickler notwendig sind.

Um dieses Problem zu lösen, sollten alle Vorgänge, die mit dem SCM interagieren, in einem separaten Thread ausgeführt werden, unabhängig von den Aktionen, die während der Initialisierungsphase stattfinden.

B zeigt einen Algorithmus zum korrekten Starten eines Dienstes mithilfe eines Hilfsthreads.

Handler-Funktion

B zeigt den Code für die Handler-Funktion und Hilfsthreads. Für „Stop“- und „Shutdown“-Anfragen wird ein Algorithmus zum korrekten Stoppen des Dienstes verwendet, der dem beim Starten eines Dienstes ähnelt, mit dem einzigen Unterschied, dass anstelle des Parameters SERVICE_START_PENDING der Parameter SERVICE_STOP_PENDING an SetserviceStatus übergeben wird, und stattdessen von SERVICE_RUNNING - SERVICE_STOPPED.

Idealerweise sollten auch „Pause“- und „Fortfahren“-Anfragen diesen Ansatz verwenden. Ein neugieriger Leser kann es anhand dieser Beispiele leicht umsetzen.

Abschluss

Abschließend möchten wir festhalten, dass sich die Entwicklung der Dienste mit der Umstellung auf Windows NT 2000 nicht verändert hat. Dienste sind nach wie vor ein wichtiger Bestandteil der Software auf der Windows-Plattform und bieten Entwicklern eine Vielzahl von Optionen.


// Funktion ähnlich der MessageBox Win32 API int ServerMessageBox(RPC_BINDING_HANDLE h, LPSTR lpszText, LPSTR lpszTitle, UINT fuStyle) ( DWORD dwThreadId; HWINSTA hwinstaSave; HDESK hdeskSave; HWINSTA hwinstaUser; HDESK hdeskUser; int result; // Merken Sie sich die aktuellen Objekte "W indow station " und "Desktop". GetDesktopWindow(); hwinstaSave = GetProcessWindowStation(); dwThreadId = GetCurrentThreadId(); hdeskSave = GetThreadDesktop(dwThreadId); // Ändern Sie den Sicherheitskontext in den, // den der aufrufende RPC-Client hat // und Zugriff auf Benutzerobjekte // „Window Station“ und „Desktop“ erhalten. RpcImpersonateClient(h); hwinstaUser = OpenWindowStation("WinSta0", FALSE, MAXIMUM_ALLOWED); if (hwinstaUser == NULL) ( RpcRevertToSelf(); return 0; ) SetProcessWindowStation( hwinstaUser); hdeskUser = OpenDesktop("Default", 0, FALSE, MAXIMUM_ALLOWED); RpcRevertToSelf(); if (hdeskUser == NULL) ( SetProcessWindowStation(hwinstaSave); CloseWindowStation(hwinstaUser); return 0; ) SetThreadDesktop(hdeskUser); // Ein normales Textfenster anzeigen. result = MessageBox(NULL, lpszText, lpszTitle, fuStyle); // Gespeicherte Objekte wiederherstellen // „Fensterstation“ und „Desktop“. SetThreadDesktop(hdeskSave); SetProcessWindowStation(hwinstaSave); CloseDesktop(hdeskUser); CloseWindowStation(hwinstaUser); Ergebnis zurückgeben; ) void main() ( SERVICE_TABLE_ENTRY steTable = ( (SERVICENAME, ServiceMain), (NULL, NULL) ); // Verbindung mit SCM herstellen. Innerhalb dieser Funktion // werden Anfragen empfangen und versendet. StartServiceCtrlDispatcher(steTable); ) void WINAPI ServiceMain (DWORD dwArgc, LPSTR *psArgv) ( // Registrieren Sie den Anforderungshandler sofort. hSS = RegisterServiceCtrlHandler(SERVICENAME, ServiceHandler); sStatus.dwCheckPoint = 0; sStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE; sStatus.dwServiceSpecificExitC ode = 0;sStatus. dwServiceType = SERVICE_WIN32_OWN_PROCESS ; sStatus.dwWaitHint = 0; sStatus.dwWin32ExitCode = NOERROR; // Um ​​den Dienst zu initialisieren, wird die Funktion InitService() aufgerufen; // Um ​​sicherzustellen, dass das System den Dienst während des Initialisierungsprozesses nicht // entlädt, Es wird ein Thread gestartet, der alle // Sekunden meldet, dass der Dienst gerade initialisiert wird. // Ein Ereignis wird erstellt, um den Thread zu synchronisieren. // Danach wird ein Arbeitsthread gestartet, // für den ein Ereignis erfolgt wird auch // zur Synchronisierung erstellt. hSendStartPending = CreateEvent(NULL, TRUE, FALSE, NULL); HANDLE hSendStartThread; DWORD dwThreadId; hSendStartThread = CreateThread(NULL, 0, SendStartPending, NULL, 0, &dwThreadId); //Die gesamte Dienstinitialisierung wird hier durchgeführt. InitService(); SetEvent(hSendStartPending); if(WaitForSingleObject(hSendStartThread, 2000) != WAIT_OBJECT_0) ( TerminateThread(hSendStartThread, 0); ) CloseHandle(hSendStartPending); CloseHandle(hSendStartThread); hWork = CreateEvent(NULL, TRUE, FALSE, NULL); hServiceThread = CreateThread(NULL, 0, ServiceFunc, 0, 0, &dwThreadId); sStatus.dwCurrentState = SERVICE_RUNNING; SetServiceStatus(hSS, &sStatus); ) // Eine Thread-Funktion, die jede Sekunde Benachrichtigungen an den SCM // sendet, dass der Initialisierungsprozess ausgeführt wird. Die Funktion // endet, wenn das Ereignis hSendStartPending // gesetzt wird. DWORD WINAPI SendStartPending(LPVOID) ( sStatus.dwCheckPoint = 0; sStatus.dwCurrentState = SERVICE_START_PENDING; sStatus.dwWaitHint = 2000; // „Ruhezustand“ für 1 Sekunde. Wenn nach 1 Sekunde // das hSendStartPending-Ereignis nicht // in das Signal eingetreten ist state (Dienstinitialisierung ist noch nicht // abgeschlossen), wir senden die nächste Benachrichtigung, // setzen das maximale Zeitintervall // auf 2 Sekunden, sodass bis zur // nächsten Benachrichtigung ein Zeitspielraum verbleibt. while (true) ( ​​SetServiceStatus(hSS, &sStatus); sStatus .dwCheckPoint++; if(WaitForSingleObject(hSendStartPending, 1000)!=WAIT_TIMEOUT) break; ) sStatus.dwCheckPoint = 0; return 0; ) // Funktion, die den Dienst initialisiert. Daten lesen, // Speicherzuweisung usw. void InitService() ( ... ) // Funktion, die Servicecode enthält. DWORD WINAPI ServiceFunc(LPVOID) ( while (true) ( ​​​​if (!bPause) ( // Dies enthält Code, der normalerweise // eine Art zyklischer Operationen ausführt... ) if (WaitForSingleObject(hWork, 1000)!=WAIT_TIMEOUT ) break; ) return 0; ) // Handler von SCM anfordern void WINAPI ServiceHandler(DWORD dwCode) ( switch (dwCode) ( case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_SHUTDOWN: ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0, 1000); hSendStopPending = CreateEvent(NULL, TRUE, FALSE, NULL); hSendStopThread = CreateThread(NULL, 0, SendStopPending, NULL, 0, & dwThreadId); SetEvent(hWork); if (WaitForSingleObject(hServiceThread, 1000) != WAIT_OBJECT_0) ( TerminateThread(hServiceThread, 0); ) SetEvent(hSendStopPending); CloseHandle(hServiceThread); CloseHandle(hWork); if(WaitForSingleObject(hSendStopThread, 2000) != WAIT_OBJECT_0) ( TerminateThread(hSendStopThread, 0); ) CloseHandle(hSendStopPending); sStatus.dwCurrentState = SERVICE_STOPPED; SetServiceStatus( hSS, &sStatus); brechen; case SERVICE_CONTROL_PAUSE: bPause = true; sStatus.dwCurrentState = SERVICE_PAUSED; SetServiceStatus(hSS, &sStatus); brechen; case SERVICE_CONTROL_CONTINUE: bPause = true; sStatus.dwCurrentState = SERVICE_RUNNING; SetServiceStatus(hSS, &sStatus); brechen; case SERVICE_CONTROL_INTERROGATE: SetServiceStatus(hSS, &sStatus); brechen; Standard: SetServiceStatus(hSS, &sStatus); brechen; ) ) // Thread-Funktion ähnlich SendStartPending // zum Stoppen des Dienstes. DWORD WINAPI SendStopPending(LPVOID) ( sStatus.dwCheckPoint = 0; sStatus.dwCurrentState = SERVICE_STOP_PENDING; sStatus.dwWaitHint = 2000; while (true) ( ​​​​SetServiceStatus(hSS, &sStatus); sStatus.dwCheckPoint++; if(WaitForSingleObject( hSendStopPending, 1000 )! =WAIT_TIMEOUT) break; ) sStatus.dwCheckPoint = 0; return 0; )

So führen Sie eine Anwendung als Windows-Dienst aus

Ist es möglich, eine Clientanwendung als Dienst auszuführen? In einem davon habe ich Möglichkeiten zum Erstellen eines Windows-Dienstes mit Standard-Betriebssystemtools beschrieben. Allerdings kann nicht jede Konsolenanwendung als Dienst ausgeführt werden und Programme mit grafischer Oberfläche können auf diese Weise grundsätzlich nicht funktionieren. Es ist jedoch weiterhin möglich, die Anwendung als Dienst auszuführen, und ein Programm mit einem Originalnamen hilft uns dabei Nicht saugender Servicemanager.

NSSM ist kostenlos Software Mit Open Source und unterstützt alle Microsoft-Betriebssysteme, von Windows 2000 bis Windows 8. NSSM erfordert keine Installation, laden Sie es einfach herunter und entpacken Sie es. Die Distribution umfasst Versionen für 32- und 64-Bit-Betriebssysteme. Sie können das Programm von der Website nssm.cc herunterladen, die aktuellste stabile Version ist 2.21.1, die ich verwenden werde.

Um die Fähigkeiten von NSSM zu demonstrieren, versuchen wir es auszuführen Windows-Notizblock als Dienst unter Windows 8.1.

Einen Dienst erstellen

So erstellen Sie einen Dienst mit dem Namen Notizblock Starten Sie die Befehlskonsole, gehen Sie zum Ordner mit dem entpackten NSSM (für 64-Bit-Windows) und geben Sie den Befehl nssm install notepad ein, der das grafische NSSM-Installationsfenster öffnet. Um einen Dienst zu erstellen, geben Sie einfach den Pfad zur ausführbaren Datei im Feld „Pfad“ an und klicken Sie auf die Schaltfläche „Dienst installieren“. Darüber hinaus können Sie im Feld Optionen die zum Starten des Dienstes erforderlichen Schlüssel angeben.

Sie können beim Erstellen eines neuen Dienstes auch einige zusätzliche Parameter angeben.

Auf der Registerkarte „Herunterfahren“ werden die Methoden und Zeitüberschreitungen zum Herunterfahren aufgeführt, die verwendet werden, wenn die Anwendung normal heruntergefahren wird oder abstürzt. Wenn NSSM einen Stoppbefehl empfängt (z. B. wenn eine Anwendung heruntergefahren wird), versucht es, die gesteuerte Anwendung auf normale Weise zu stoppen. Wenn die Anwendung nicht antwortet, kann NSSM alle Prozesse und Unterprozesse dieser Anwendung zwangsweise beenden.

Zum Beenden der Anwendung sind vier Schritte erforderlich, die standardmäßig in dieser Reihenfolge ausgeführt werden:

In der ersten Phase versucht NSSM, ein Ereignis zu generieren und zu senden Strg+C. Diese Methode eignet sich gut für Konsolenanwendungen oder Skripts, ist jedoch nicht für grafische Anwendungen anwendbar.
NSSM erkennt dann alle von der Anwendung erstellten Fenster und sendet ihnen eine WM_CLOSE-Nachricht, wodurch die Anwendung beendet wird.
Der dritte Schritt besteht darin, dass NSSM alle von der Anwendung erstellten Threads berechnet und ihnen eine WM_QUIT-Nachricht sendet, die empfangen wird, wenn die Anwendung über eine Thread-Nachrichtenwarteschlange verfügt.
Als letzten Ausweg kann NSSM die Methode TerminateProcess() aufrufen und so die Beendigung der Anwendung erzwingen.

Es ist möglich, einige oder sogar alle Methoden zu deaktivieren verschiedene Anwendungen Verschiedene Methoden funktionieren, und um die Anwendung ordnungsgemäß zu beenden, wird empfohlen, alles so zu lassen, wie es ist.

Wenn ein Dienst abstürzt, versucht NSSM standardmäßig, ihn neu zu starten. Auf der Registerkarte „Exit-Aktionen“ können Sie die automatische Aktion ändern, wenn die Anwendung abnormal beendet wird, sowie eine Verzögerung festlegen, bevor die Anwendung automatisch neu gestartet wird.

Auf der Registerkarte „Eingabe/Ausgabe (E/A)“ können Sie die Umleitung der Anwendungseingabe/-ausgabe in eine bestimmte Datei festlegen.

Auf der Registerkarte „Umgebung“ können Sie neue Umgebungsvariablen für den Dienst festlegen oder vorhandene überschreiben.

Sie können auch nicht die grafische Shell verwenden und mit dem folgenden Befehl sofort einen Dienst in der Konsole erstellen:

nssm install notepad ″C:\Windows\system32\notepad.exe″

Service-Management

Nachdem Sie den Dienst mit NSSM erstellt haben, gehen Sie zum Snap-In „Dienste“ und suchen Sie den Notepad-Dienst. Wie Sie sehen, unterscheidet es sich optisch nicht von anderen Diensten; wir können es auch starten, stoppen oder den Startmodus ändern. Beachten Sie jedoch, dass nssm.exe als ausführbare Datei aufgeführt ist.

Und wenn wir zum Task-Manager gehen, sehen wir das folgende Bild: NSSM wird als Hauptprozess (übergeordneter Prozess) ausgeführt, der Notepad-Dienst wird als untergeordneter Prozess ausgeführt und die Notepad-Anwendung wird bereits in diesem untergeordneten Prozess ausgeführt.

Entfernen eines Dienstes

Um einen Dienst zu entfernen, geben Sie den Befehl nssm Remove Notepad ein und bestätigen Sie die Entfernung. Und durch Eingabe des Befehls nssm Remove Notepad Confirm können Sie auf eine Bestätigung verzichten.

Starten Sie einen Dienst interaktiv

Hauptunterschied benutzerdefinierte Anwendung Der Nachteil eines Dienstes besteht darin, dass nach dem Start der Anwendung möglicherweise zusätzliche Aktionen vom Benutzer erforderlich sind, um mit der Arbeit fortzufahren – beispielsweise das Drücken einer Taste oder die Eingabe eines Befehls. Dazu müssen Sie sich Zugang verschaffen, was, wie sich herausstellt, nicht so einfach ist.

Um einen Dienst im interaktiven Modus zu starten, müssen Sie seine Eigenschaften im Dienste-Snap-In öffnen und auf der Registerkarte „Anmelden“ das Kontrollkästchen „Interaktion mit dem Desktop zulassen“ aktivieren.

Und dann beginnen Wunder :) Ein im interaktiven Modus gestarteter Dienst wird in einer isolierten Sitzung (Sitzung 0) geöffnet. Auf diese Sitzung kann nur mit dem Interactive Services Detection Service (ui0detect) zugegriffen werden, der den Start interaktiver Dienste auf dem Computer überwacht und eine Warnung ausgibt. In Windows 7\Server 2008 ist dieser Dienst standardmäßig aktiv, aber in Windows 8\Server 2012 ist er deaktiviert und erscheint nicht im grafischen Snap-In „Dienste“ (zumindest habe ich ihn dort nicht gefunden). Wenn Sie diesen mysteriösen Dienst finden und versuchen, ihn zu starten, erhalten Sie außerdem eine Fehlermeldung.

Tatsache ist jedoch, dass Sie zum Ausführen interaktiver Dienste die Ausführung interaktiver Dienste auf Ihrem Computer zulassen müssen. Öffnen Sie daher den Registrierungseditor und suchen Sie im Abschnitt HKLM\System\CurrentControlSet\Control\Windows einen Parameter vom Typ DWORD mit dem Namen Keine interaktiven Dienste und setzen Sie den Wert auf 0 .

Öffnen Sie dann die PowerShell-Konsole und starten Sie den Discovery-Dienst mit dem Befehl:

Start-Service-Name ui0detect

Nachdem wir sichergestellt haben, dass der Erkennungsdienst ausgeführt wird, starten wir den Notepad-Dienst neu und erhalten dieses Fenster. Wählen Sie „Nachricht anzeigen“

und wir befinden uns in der Nullsitzung, in der unsere Anwendung ausgeführt wird. Dann führen wir damit die notwendigen Aktionen durch und kehren zurück.

Dies ist eine interessante Lösung, um Anwendungen als Windows-Dienste auszuführen. Nicht das schönste, aber durchaus passend zu seinem Namen :)

Letzte Aktualisierung: 31.10.2015

Eine der wichtigsten Komponenten des Windows-Betriebssystems sind Dienste. Tatsächlich handelt es sich dabei um separate Anwendungen, die über keine grafische Oberfläche verfügen und im Hintergrund verschiedene Aufgaben ausführen. Dienste können beim Start des Betriebssystems oder zu jedem anderen Zeitpunkt, zu dem der Benutzer arbeitet, gestartet werden. Ein gängiges Beispiel für Dienste sind verschiedene Webserver, die im Hintergrund auf einen bestimmten Port auf Verbindungen warten und bei bestehenden Verbindungen mit diesen interagieren. Dabei kann es sich auch um verschiedene Hilfsaktualisierungsdienste für andere handeln installierte Programme, die den Server kontaktieren, um herauszufinden, ob dies der Fall ist eine neue Version Anwendungen. Im Allgemeinen können wir das Dienstefenster öffnen und alle installierten und ausgeführten Dienste selbst sehen:

Sehen wir uns an, wie Sie Ihre eigenen Dienste in C# erstellen. Als zu implementierende Aufgabe wählen wir die Überwachung von Änderungen in einem bestimmten Ordner im Dateisystem. Lassen Sie uns nun einen Dienst erstellen, um ihn auszuführen.

Erstellen wir zunächst ein neues Projekt vom Typ Windows-Dienst. Nennen wir das Projekt FileWatcherService:

Visual Studio generiert dann ein Projekt, das alles enthält, was Sie brauchen. Obwohl wir diesen Projekttyp nicht unbedingt auswählen müssen, könnten wir ein Klassenbibliotheksprojekt erstellen und dann alle erforderlichen Klassen darin definieren.

Das neue Projekt sieht also so aus:

Es gibt auch eine Datei Program.cs und den eigentlichen Dienstknoten Service1.cs.

Der Dienst stellt eine normale Anwendung dar, startet jedoch nicht von alleine. Alle Anrufe und der Zugriff darauf laufen über den Service Control Manager (Service Control Manager oder SCM). Wenn ein Dienst automatisch beim Systemstart oder manuell gestartet wird, ruft SCM die Main-Methode in der Program-Klasse auf:

Statisches Klassenprogramm ( static void Main() ( ServiceBase ServicesToRun; ServicesToRun = new ServiceBase ( new Service1() ); ServiceBase.Run(ServicesToRun); ) )

Die Main-Methode ist standardmäßig so definiert, dass sie mehrere Dienste gleichzeitig ausführt, die im ServicesToRun-Array definiert sind. Standardmäßig enthält das Projekt jedoch nur einen Dienst, Service1. Der Start selbst erfolgt über die Run-Methode: ServiceBase.Run(ServicesToRun) .

Der gestartete Dienst wird durch den Knoten Service1.cs dargestellt. Dabei handelt es sich jedoch nicht wirklich um eine einfache Codedatei. Wenn wir diesen Knoten öffnen, sehen wir die Service-Designer-Datei Service1.Designer.cs und die Klasse Service1.

Die Klasse Service1 repräsentiert tatsächlich den Dienst. Standardmäßig hat es den folgenden Code:

Verwenden des Systems; mit System.Collections.Generic; mit System.ComponentModel; Verwenden von System.Data; Verwenden von System.Diagnostics; mit System.Linq; Verwenden von System.ServiceProcess; Verwenden von System.Text; Verwenden von System.Threading.Tasks; Namespace FileWatcherService ( öffentliche Teilklasse Service1: ServiceBase ( public Service1() ( InitializeComponent(); ) protected override void OnStart(string args) ( ) protected override void OnStop() ( ) ) )

Die Serviceklasse muss von der ServiceBase-Basisklasse erben. Diese Klasse definiert eine Reihe von Methoden. Die wichtigsten davon sind die Methode OnStart(), die die vom Dienst ausgeführten Aktionen startet, und die Methode OnStop(), die den Dienst stoppt.

Nachdem SCM die Main-Methode aufgerufen und den Dienst registriert hat, wird er direkt durch Ausführen der OnStart-Methode aufgerufen.

In der Dienstekonsole oder über Befehlszeile Wir senden einen Befehl, um den Dienst zu stoppen, und dann ruft SCM die OnStop-Methode auf, um ihn zu stoppen.

Zusätzlich zu diesen beiden Methoden in der Serviceklasse können Sie mehrere weitere Methoden der ServiceBase-Basisklasse überschreiben:

    OnPause: Wird aufgerufen, wenn der Dienst angehalten wird

    OnContinue: Wird aufgerufen, wenn ein Dienst fortgesetzt wird, nachdem er angehalten wurde

    OnShutdown: Wird aufgerufen, wenn Windows heruntergefahren wird

    OnPowerEvent: Wird aufgerufen, wenn sich der Energiemodus ändert

    OnCustomCommand: Wird aufgerufen, wenn ein Dienst einen benutzerdefinierten Befehl vom Service Control Manager (SCM) empfängt.

Im Konstruktor der Klasse Service1 wird die Methode InitializeComponent() aufgerufen, die in der Designerdatei Service1.Designer.cs definiert ist:

Namespace FileWatcherService ( partielle Klasse Service1 ( private System.ComponentModel.IContainer Components = null; protected override void Dispose(bool disposing) ( if (disposed && (components != null)) ( Components.Dispose(); ) base.Dispose(dispose ); ) private void InitializeComponent() ( Components = new System.ComponentModel.Container(); this.ServiceName = "Service1"; ) ) )

Das Einzige, was darin beachtet werden muss, ist die Festlegung des Namens des Dienstes (Eigenschaft ServiceName):

This.ServiceName = "Service1";

Dies ist der Name, der nach der Installation dieses Dienstes in der Dienstekonsole angezeigt wird. Wir können es ändern, oder wir können es so lassen, wie es ist.

Jetzt ändern wir den Servicecode wie folgt:

Verwenden des Systems; Verwenden von System.ServiceProcess; mit System.IO; Verwenden von System.Threading; Namespace FileWatcherService ( öffentliche Teilklasse Service1: ServiceBase ( Logger Logger; public Service1() ( InitializeComponent(); this.CanStop = true; this.CanPauseAndContinue = true; this.AutoLog = true; ) protected override void OnStart(string args) ( logger = new Logger(); Thread loggerThread = new Thread(new ThreadStart(logger.Start)); loggerThread.Start(); ) protected override void OnStop() ( logger.Stop(); Thread.Sleep(1000); ) ) class Logger ( FileSystemWatcher watcher; object obj = new object(); bool aktiviert = true; public Logger() ( watcher = new FileSystemWatcher("D:\\Temp"); watcher.Deleted += Watcher_Deleted; watcher.Created + = Watcher_Created; watcher.Changed += Watcher_Changed; watcher.Renamed += Watcher_Renamed; ) public void Start() ( watcher.EnableRaisingEvents = true; while(enabled) ( Thread.Sleep(1000); ) ) public void Stop() ( watcher.EnableRaisingEvents = false; aktiviert = false; ) // Dateien umbenennen private void Watcher_Renamed(object sender, RenamedEventArgs e) ( string fileEvent = "renamed to " + e.FullPath; string filePath = e.OldFullPath; RecordEntry(fileEvent, filePath); ) // Dateien ändern private void Watcher_Changed(object sender, FileSystemEventArgs e) ( string fileEvent = "changed"; string filePath = e.FullPath; RecordEntry(fileEvent, filePath); ) // Dateien erstellen private void Watcher_Created(object sender, FileSystemEventArgs e) ( string fileEvent = "created"; string filePath = e.FullPath; RecordEntry(fileEvent, filePath); ) // Dateien löschen private void Watcher_Deleted(object sender, FileSystemEventArgs e) ( string fileEvent = "deleted"; string filePath = e.FullPath; RecordEntry(fileEvent, filePath); ) private void RecordEntry(string fileEvent, string filePath) ( lock (obj) ( using (StreamWriterwriter = new StreamWriter("D:\\templog.txt", true)) ( Writer.WriteLine(String.Format("(0) Datei (1) war (2)", DateTime.Now.ToString("TT/MM/JJJJ hh:mm:ss"), filePath, fileEvent)); Writer. Flush(); ) ) ) ) )

Die Schlüsselklasse, die die gesamte Funktionalität kapselt, ist die Logger-Klasse. Mithilfe des FileSystemWatcher-Objekts werden Änderungen im Ordner überwacht D://Temp. Die Start()-Methode gibt an, dass wir über das FileSystemWatcher-Objekt auf Änderungen achten. Und die ganze Arbeit wird fortgesetzt, solange die aktivierte boolesche Variable true ist. Und die Stop()-Methode ermöglicht das Beenden der Klasse.

Mit FileSystemWatcher-Ereignissen können Sie alle Änderungen an einem überwachten Ordner überwachen. Dadurch werden Änderungen an der Datei templog.txt aufgezeichnet. Um einen Ressourcenwettlauf um die Datei templog.txt, in der Änderungen aufgezeichnet werden, zu vermeiden, wird der Aufzeichnungsvorgang durch den Stub lock(obj) blockiert.

Infolgedessen enthält die Protokolldatei nach dem Erstellen, Ändern, Umbenennen und Löschen etwa Folgendes:

30.07.2015 12:15:40 Datei D:\Temp\Neues Textdokument.txt wurde erstellt 30.07.2015 12:15:46 Datei D:\Temp\Neues Textdokument.txt wurde in D:\ umbenannt Temp\hello. txt 30.07.2015 12:15:55 Datei D:\Temp\hello.txt wurde geändert 30.07.2015 12:15:55 Datei D:\Temp\hello.txt wurde am 30.07. geändert /2015 12:16:01 Datei D: \Temp\hello.txt wurde gelöscht

In der Serviceklasse Service1 selbst werden im Konstruktor eine Reihe von Optionen festgelegt:

This.CanStop = true; // der Dienst kann gestoppt werden this.CanPauseAndContinue = true; // der Dienst kann pausiert und dann fortgesetzt werden this.AutoLog = true; // Der Dienst kann in das Protokoll schreiben

In der OnStart()-Methode wird ein neuer Thread aufgerufen, um das Logger-Objekt zu starten:

Geschützte Überschreibung void OnStart(string args) ( logger = new Logger(); Thread loggerThread = new Thread(new ThreadStart(logger.Start)); loggerThread.Start(); )

Der neue Thread wird benötigt, da der aktuelle Thread nur SCM-Befehle verarbeitet und so schnell wie möglich von der OnStart-Methode zurückkehren muss.

Wenn vom SCM ein Befehl zum Stoppen des Dienstes empfangen wird, wird die OnStop-Methode ausgelöst, die die logger.Stop()-Methode aufruft. Durch die zusätzliche Verzögerung kann der Logger-Thread angehalten werden:

Geschützte Überschreibung void OnStop() ( logger.Stop(); Thread.Sleep(1000); )

Die Serviceklasse selbst reicht jedoch nicht aus. Wir müssen auch einen Service-Installer erstellen.

Oder der Desktop von Benutzern (sowohl lokal als auch remote), bei einigen Diensten ist jedoch eine Ausnahme möglich – Interaktion mit der Konsole (Sitzungsnummer 0, in der der Benutzer lokal oder beim Starten des Dienstes registriert ist mstsc mit dem /console-Schalter).

Es gibt verschiedene Modi für Dienste:

  • Startverbot;
  • manueller Start (auf Anfrage);
  • automatischer Start beim Hochfahren des Computers;
  • automatischer (verzögerter) Start (eingeführt in Windows Vista und Windows Server 2008);
  • obligatorischer Dienst/Treiber (automatischer Start und Unmöglichkeit (für den Benutzer), den Dienst zu stoppen).

Hintergrundmodus

Windows-Dienste starten, stoppen und ändern

Dienste und ihre Attribute können in der MMC geändert werden:

Verschiedene Versionen von Betriebssystemen verfügen möglicherweise über einige Dienste, andere jedoch nicht. Einige Anwendungen und Programme, die separat installiert werden, können auch eigene Dienste erstellen.

Liste der Microsoft Windows-Betriebssystemdienste

Anzeigename Dienstname Funktionen Beschreibung
DHCP-Client Dhcp Registriert und aktualisiert IP-Adressen und DNS-Einträge für diesen Computer. Wenn dieser Dienst beendet wird, kann dieser Computer keine dynamischen IP-Adressen beziehen und keine DNS-Updates durchführen.
DNS-Client Dnscache Der DNS-Clientdienst (dnscache) speichert DNS-Namen (Domain Name System) zwischen und registriert den vollständig qualifizierten Namen eines bestimmten Computers. Wenn der Dienst beendet wird, wird die DNS-Namensauflösung fortgesetzt. Die Ergebnisse von DNS-Namenswarteschlangen werden jedoch nicht zwischengespeichert und der Computername wird nicht registriert.
KtmRm für verteilten Transaktionskoordinator KtmRm Koordiniert Transaktionen zwischen MSDTC und dem Kernel Transaction Manager (KTM).
ReadyBoost EMDMgmt ReadyBoost Unterstützung zur Verbesserung der Systemleistung mithilfe der ReadyBoost-Technologie.
Superfetch SysMain Superfetch Erhält und verbessert die Systemleistung.
Windows-Audio Audiosrv Verwalten von Audiotools für Windows-Programme. Wenn dieser Dienst beendet wird, funktionieren Audiogeräte und Effekte nicht ordnungsgemäß.
Windows CardSpace idsvc Bietet eine sichere Möglichkeit zum Erstellen, Verwalten und Offenlegen digitaler Identitäten.
Automatisches Update WUAUSERV Beinhaltet das Herunterladen und Installieren von Windows-Updates. Wenn der Dienst deaktiviert ist, kann dieser Computer weder automatische Updates noch die Windows Update-Website verwenden.
Remoteprozeduraufruf (RPC) RpcSs Bietet Zuordnung zwischen Endpunkten und anderen RPC-Diensten.

Liste der von Microsoft-Anwendungen und -Programmen erstellten Dienste

Beispiele für Dienste, die von Anwendungen und Programmen Dritter erstellt wurden

Anzeigename Dienstname Funktionen Beschreibung
ESET HTTP-Server EhttpSrv Virenschutz ESET HTTP Server-Komponente


IN VERBINDUNG STEHENDE ARTIKEL