www.pudn.com > UCtrl.rar > SYServer.pas

unit SYServer; 
 
interface 
 
uses Windows, WinSvc; 
 
type 
  TSYServer = class 
  private 
  protected 
  //---------------------------------------------------------------------------- 
    function ServiceConnect: SC_HANDLE; 
    function ServiceDisconn(hService: SC_HANDLE): SC_HANDLE; 
    function ServiceOpen(hService: SC_HANDLE; AServName: PChar): SC_HANDLE; 
    function ServiceClose(hService: SC_HANDLE): Boolean; 
    function ServiceGetStatus(hService: SC_HANDLE; AServName: PChar): DWord; 
    function ServiceUninstalled(hService: SC_HANDLE; AServName: PChar): Boolean; 
    function ServiceRunning(hService: SC_HANDLE; AServName: PChar): Boolean; 
    function ServiceStopped(hService: SC_HANDLE; AServName: PChar): Boolean; 
  //---------------------------------------------------------------------------- 
  //-------- ServiceInstall : ServerName ,Discription ,ServerFilePath 
    {//----- Windows.pas 
    ERROR_ACCESS_DENIED = 5 
    ERROR_CIRCULAR_DEPENDENCY = 1059 
    ERROR_DUP_NAME = 52 
    ERROR_INVALID_HANDLE = 6 
    ERROR_INVALID_NAME = 123 
    ERROR_INVALID_PARAMETER = 87 
    ERROR_INVALID_SERVICE_ACCOUNT = 1057 
    ERROR_SERVICE_EXISTS = 1073 
    } 
 
  public 
    function ServiceInstall(AServName, ADispName, AServPath: PChar): SC_HANDLE; 
  //-------- ServiceUnInstall : ServerName    0: NotFound 1: False 2:Successed 
    function ServiceUnInstall(AServName: PChar): DWORD; 
    //------ ServiceStart  0:NotFound 1: Running 2: Successed 3: False 
    function ServiceStart(AServName: PChar): DWORD; 
    //------ ServiceStop   0:NotFound 1:Stoped 2: Successed 3: False 
    function ServiceStop(AServName: PChar): DWORD; 
    //------ FileHandleOpen  only get a handle Error is CreateFileError 
    function FileHandleOpen(AFileName: PChar): SC_HANDLE; 
    //------ FileHandleClose only Close a handle Result is CloseHandle 
    function FileHandleClose(hFileHandle: SC_HANDLE): Boolean; 
  //---------------------------------------------------------------------------- 
    function IOC(FHandle: SC_HANDLE; NCode: Dword; Pin, Pout: Pointer; InSize, OutSize: Dword): Dword; 
    function CTL_CODE(DeviceType, func, meth, access: integer): DWORD; 
    function IOCExec(AFileName: PChar; NCode: Dword; Pin, Pout: Pointer; InSize, OutSize: Dword): Boolean; 
 //   constructor Create; 
 //   destructor Destroy; override; 
  end; 
 
implementation 
 
{ TSYServer } 
 
function TSYServer.ServiceInstall(AServName, ADispName, AServPath: PChar): SC_HANDLE; 
var 
  hManager: SC_HANDLE; 
begin 
  result := 0; 
  hManager := ServiceConnect; 
  try 
    if ServiceUninstalled(hManager, AServName) then 
    begin 
      result := CreateService(hManager, AServName, ADispName, 
        SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START, 
        SERVICE_ERROR_NORMAL, AServPath, nil, nil, nil, nil, nil); 
      ServiceClose(result); 
    end; 
  finally 
    ServiceDisconn(hManager); 
  end; 
end; 
 
function TSYServer.ServiceClose(hService: SC_HANDLE): Boolean; 
begin 
  if (hService <> 0) then 
    result := CloseServiceHandle(hService) 
  else 
    result := True; 
end; 
 
function TSYServer.ServiceConnect: SC_HANDLE; 
begin 
  result := OpenSCManager(nil, nil, SC_MANAGER_ALL_ACCESS); 
end; 
 
function TSYServer.ServiceDisconn(hService: SC_HANDLE): SC_HANDLE; 
begin 
  if (hService <> 0) then 
    CloseServiceHandle(hService); 
  result := 0; 
end; 
 
function TSYServer.FileHandleClose(hFileHandle: SC_HANDLE): Boolean; 
begin 
  Result := CloseHandle(hFileHandle); 
end; 
 
function TSYServer.ServiceOpen(hService: SC_HANDLE; AServName: PChar): SC_HANDLE; 
begin 
  result := OpenService(hService, AServName, SERVICE_ALL_ACCESS); 
end; 
 
function TSYServer.FileHandleOpen(AFileName: PChar): SC_HANDLE; 
begin 
  Result := CreateFile(AFileName, GENERIC_READ or GENERIC_WRITE, 0, 
    PSECURITY_DESCRIPTOR(nil), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); 
end; 
 
function TSYServer.ServiceUnInstall(AServName: PChar): DWORD; 
var 
  hService, hManager: SC_HANDLE; 
  ServiceStatus: TServiceStatus; 
begin 
  result := 0; 
  hManager := ServiceConnect; 
  try 
    if not ServiceUninstalled(hManager, AServName) then 
    begin 
      hService := ServiceOpen(hManager, AServName); 
 
      if (hService <> 0) then 
      begin 
        ControlService(hService, SERVICE_CONTROL_STOP, ServiceStatus); 
        if DeleteService(hService) then 
          result := 2 
        else 
          result := 1; 
      end; 
      ServiceClose(hService); 
    end; 
  finally 
    ServiceDisconn(hManager); 
  end; 
end; 
 
function TSYServer.ServiceStart(AServName: PChar): DWORD; 
var 
  hService, hManager: SC_HANDLE; 
begin 
  result := 0; 
  hManager := ServiceConnect; 
  try 
    if not ServiceUninstalled(hManager, AServName) then 
    begin 
      if not ServiceRunning(hManager, AServName) then 
      begin 
        hService := ServiceOpen(hManager, AServName); 
        if (hService <> 0) then 
          if StartService(hService, 1, AServName) then 
            result := 2 
          else 
            result := 3; 
        ServiceClose(hService); 
      end 
      else 
        result := 1; 
    end; 
  finally 
    ServiceDisconn(hManager); 
  end; 
end; 
 
function TSYServer.ServiceStop(AServName: PChar): DWORD; 
var 
  hService, hManager: SC_HANDLE; 
  ServiceStatus: TServiceStatus; 
begin 
  result := 0; 
  hManager := ServiceConnect; 
  try 
    if not ServiceUninstalled(hManager, AServName) then 
    begin 
      if not ServiceStopped(hManager, AServName) then 
      begin 
        hService := ServiceOpen(hManager, AServName); 
        if (hService <> 0) then 
          if ControlService(hService, SERVICE_CONTROL_STOP, ServiceStatus) then 
            result := 2 
          else 
            result := 3; 
        ServiceClose(hService); 
      end 
      else 
        result := 1; 
    end; 
  finally 
    ServiceDisconn(hManager); 
  end; 
end; 
 
function TSYServer.ServiceGetStatus(hService: SC_HANDLE; AServName: PChar): DWORD; 
var 
  hService2: SC_HANDLE; 
  queryStatus: TServiceStatus; 
  dwStat: DWORD; 
begin 
  dwStat := 0; 
  if (hService > 0) then 
  begin 
    hService2 := ServiceOpen(hService, AServName); 
    if (QueryServiceStatus(hService2, queryStatus)) then 
    begin 
      dwStat := queryStatus.dwCurrentState; 
    end; 
    ServiceClose(hService2); 
  end; 
  Result := dwStat; 
end; 
 
function TSYServer.ServiceUninstalled(hService: SC_HANDLE; AServName: PChar): Boolean; 
begin 
  Result := 0 = ServiceGetStatus(hService, AServName); 
end; 
 
function TSYServer.ServiceRunning(hService: SC_HANDLE; AServName: PChar): Boolean; 
begin 
  Result := SERVICE_RUNNING = ServiceGetStatus(hService, AServName); 
end; 
 
function TSYServer.ServiceStopped(hService: SC_HANDLE; AServName: PChar): Boolean; 
begin 
  Result := SERVICE_STOPPED = ServiceGetStatus(hService, AServName); 
end; 
 
function TSYServer.CTL_CODE(DeviceType, func, meth, access: integer): DWORD; 
begin 
  result := (DeviceType shl 16) or (Access shl 14) or (func shl 2) or (meth); 
end; 
 
function TSYServer.IOC(FHandle: SC_HANDLE; NCode: Dword; Pin, Pout: Pointer; InSize, OutSize: Dword): Dword; 
var 
  CanDo: Boolean; 
  BytesReturned: Dword; 
begin 
  Result := INVALID_HANDLE_VALUE; 
  if (FHandle <> INVALID_HANDLE_VALUE) then begin 
    CanDo := DeviceIoControl(FHandle, NCode, Pin, InSize, Pout, OutSize, BytesReturned, nil); 
    if CanDo then Result := BytesReturned; 
  end; 
end; 
 
function TSYServer.IOCExec(AFileName: PChar; NCode: Dword; Pin, Pout: Pointer; InSize, OutSize: Dword): Boolean; 
var 
  Hd: Dword; 
begin 
  Hd := FileHandleOpen(AFileName); 
  Result := Hd <> INVALID_HANDLE_VALUE; 
  if not Result then Exit; 
  Result := IOC(Hd, NCode, Pin, Pout, InSize, OutSize) <> INVALID_HANDLE_VALUE; 
  FileHandleClose(Hd); 
end; 
 
end.