FAQ DelphiConsultez toutes les FAQ

1
2
3
4
5
6
7
8
procedure Start_Service(Srv_Hwnd:Sc_Handle); 
Var ArrayOfArguments : PChar; 
  
begin 
 ArrayOfArguments := nil; 
 if StartService(Handle_Service, 0, ArrayOfArguments) =0 
  then MessageDlg(SysErrorMessage(GetLastError), mtError, [mbOK], 0); 
end;

1
2
3
4
5
6
7
8
9
10
11
var  
 NomService : String;  
 Handle_Service :SC_Handle; // handle du service  
 Status_Service : TServiceStatus;  
 EtatDuService : Word;  
  
begin  
 NomService:='UPS'; // Nom interne du service, nom public 'Onduleur'  
 Handle_Service := OpenService(Handle_SCM, PChar(NomService), SERVICE_ALL_ACCESS);  
 If Handle_Service=0  
  then ShowMessage('Erreur lors de l''ouverture du service :'+NomService)

1
2
3
4
5
Else  
  begin  
   QueryServiceStatus(Handle_Service, Status_Service);  
   EtatDuService:=Status_Service.dwCurrentState;  
  end;

1
2
if Not CloseServiceHandle(Handle_Service)  
   then ShowMessage('Erreur : le handle spécifié est invalide.');

1
2
3
4
5
6
procedure Stop_Service(Srv_Hwnd:Sc_Handle); 
Var Status_Service : TServiceStatus; 
begin 
   if ControlService(Srv_Hwnd, SERVICE_CONTROL_STOP,Status_Service)=0 
    then MessageDlg(SysErrorMessage(GetLastError), mtError, [mbOK], 0); 
end;

1
2
3
Type 
 PNTServices = ^TNTServices ; 
 TNTServices = array[0..512] of TEnumServiceStatus;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Procedure GetDependanceService(AHandle_Service : SC_Handle; List : TStringList); 
  
Var 
 Mes_Services : PNTServices; 
 OctetsNecessaires, Nombre_Services : DWord; 
 i : Integer; 
begin 
 Try 
  New(Mes_Services); // Alloue un tableau de la taille du type TNTServices 
  Nombre_Services := 0; 
  BytesNeeded:=0; 
  If EnumDependentServices(AHandle_Service, 
                           SERVICE_STATE_ALL, 
                           Mes_Services^[0], 
                           SizeOf(Mes_Services^), 
                           OctetsNecessaires, 
                           Nombre_Services)<>0 
    Then 
     begin 
      List.Clear; 
      For i := 0 to Nombre_Services-1 do 
        List.Add(Mes_Services^[i].lpServiceName); //Ou Mes_Services^[i].lpDisplayName 
     end; 
  Finally 
    Dispose(Mes_Services); 
  end; 
end;

1
2
3
4
5
6
Function ConnectToServicesManager(Computer_Name   : String; 
                                  Var AHandle_SCM : SC_Handle):Boolean; 
Begin 
 AHandle_SCM:= OpenSCManager(PChar(Computer_Name), nil, SC_MANAGER_ALL_ACCESS); 
 Result :=AHandle_SCM <> 0; 
end;

1
2
3
4
If Handle_Service <> 0 then 
   CloseServiceHandle(Handle_Service); 
If Handle_SCM <> 0 then 
 CloseServiceHandle(Handle_SCM);CloseServiceHandle(Handle_Service);

1
2
3
Type 
 PNTServices = ^TNTServices ; 
 TNTServices = array[0..512] of TEnumServiceStatus;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Procedure Refresh_Liste_Services(AHandle_SCM : SC_Handle;List : TStringList); 
Var 
 Mes_Services : PNTServices; 
 ResumeHandle, 
 OctetsNecessaires, 
 Nombre_Service : DWord; 
 i : Integer; 
begin 
Try 
 New(Mes_Services); 
 Nombre_Service := 0; 
 OctetsNecessaires:=0; 
 ResumeHandle := 0; 
 if EnumServicesStatus(AHandle_SCM, 
                       SERVICE_WIN32, //Uniquement les services, pas les drivers 
                       SERVICE_STATE_ALL, // Peut importe l'état 
                       Mes_Services^[0], 
                       SizeOf(Mes_Services^), 
                       OctetsNecessaires, 
                       Nombre_Service, 
                       ResumeHandle) <>0 
  then 
   begin 
     List.Clear; 
     For i := 0 to Nombre_Service-1 do 
      List.Add(Mes_Services^[i].lpServiceName); 
   end; 
  //else GetlastErrorCode 
  
 Finally 
  Dispose(Mes_Services); 
 end; 
end;

1
2
if Not CloseServiceHandle(Handle_SCM)  
  then  ShowMessage('Erreur: le handle SCM spécifié est invalide');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
Procedure GetConfigurationService(AHandle_Service: Sc_Handle); 
var Config_Service : PQueryServiceConfig; 
    OctetsNecessaires: DWORD; 
    ErrorCode : Cardinal; 
begin 
 try 
  Config_Service:=Nil; 
    //Premier appel, obtient la taille du buffer 
  QueryServiceConfig(AHandle_Service, nil, 0, OctetsNecessaires); 
  
 ErrorCode := GetLastError; 
  if ErrorCode <> ERROR_INSUFFICIENT_BUFFER 
   then 
    begin 
      MessageDlg(SysErrorMessage(ErrorCode), mtError, [mbOK], 0); 
      Exit; 
    end; 
  
GetMem(Config_Service, OctetsNecessaires); 
   //Second appel, obtient les infos dans le buffer dimensionné à la taille nécessaire 
  if WinSvc.QueryServiceConfig(AHandle_Service, Config_Service, OctetsNecessaires, OctetsNecessaires) 
   then 
    case Config_Service^.dwStartType of 
      SERVICE_AUTO_START   : rbtAuto.Checked:=True; 
      SERVICE_DEMAND_START : rbtManuel.Checked:=True; 
      SERVICE_DISABLED     : rbtDesactive.Checked:=True; 
    end 
   else MessageDlg(SysErrorMessage(GetLastError), mtError, [mbOK], 0); 
  
 finally 
  If Assigned(Config_Service) 
   then FreeMem(Config_Service); 
 end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
procedure TMainForm.SetConfigurationService(AHandle_Service: Sc_Handle;StartType:DWORD); 
Var Verrou_SCM : SC_LOCK; 
  
 procedure Informe; 
 begin 
  MessageDlg('La configuration du service ne peut être modifiée.'+#13+#10+SysErrorMessage(GetLastError), mtError, [mbOK], 0); 
 end; 
  
begin 
 // If StateType=Config_Service^.dwStartType then Exit // On ne change rien 
  
 Verrou_SCM:=NIL; 
 try 
  Verrou_SCM:=LockServiceDatabase(Handle_SCM); 
  if Not Assigned(Verrou_SCM) 
   then 
    begin 
     Informe; 
     Exit; 
    end; 
  
  if ChangeServiceConfig(AHandle_Service, 
                         SERVICE_NO_CHANGE, // On ne change pas le type du service 
                         StartType,         // Nouvelle configuration de démarrage 
                         SERVICE_NO_CHANGE, // On ne change pas le mode de contrôle des erreurs 
                         NiL,NiL,NiL,NiL,NiL,NiL,NiL) // On ne modifie aucune des autres paramètres de configuration 
   then ShowMessage('La configuration du service a été modifiée.') 
   else Informe; 
  
 Finally 
 if Assigned(Verrou_SCM) 
  then UnlockServiceDatabase(Verrou_SCM) 
 end; 
end;

1
2
3
4
Type 
  // Key     : nom de service court 
  // Display : nom de service long 
 DisplayService=(Key,Display);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function TMainForm.ServiceGetName(AServiceName:string ; ATypeAffichage:DisplayService) : string; 
Const LongueurMaxNomSvr = 255; 
  
var NomService : Array[0..LongueurMaxNomSvr+1] of Char; 
    TailleBuffer: DWord; 
    Erreur: Boolean; 
  
begin 
 FillChar(NomService,SizeOf(NomService),#0); 
 TailleBuffer:=LongueurMaxNomSvr+1; 
  
 Case ATypeAffichage of 
  Key : Erreur:=GetServiceKeyName(Handle_SCM,PChar(AServiceName),NomService,TailleBuffer)=False; 
  Display: Erreur:=GetServiceDisplayName(Handle_SCM,PChar(AServiceName),NomService,TailleBuffer)=False; 
 end; 
  
 if Erreur 
  then MessageDlg(SysErrorMessage(GetLastError), mtError, [mbOK], 0); 
  
 Result :=NomService; 
end;