/*
 * ServiceControlManager.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2011/09/06 Updated createService method.
#pragma once
// 2010/05/30

#include <sol/service/ServiceControl.h>
#include <sol/service/ServiceController.h>

namespace SOL {

class ServiceControlManager :public ServiceControl {
    
public:
    /*
    desiredAccess may take one or some combination of the following values:
    SC_MANAGER_CONNECT             
    SC_MANAGER_CREATE_SERVICE      
    SC_MANAGER_ENUMERATE_SERVICE   
    SC_MANAGER_LOCK                
    SC_MANAGER_QUERY_LOCK_STATUS   
    SC_MANAGER_MODIFY_BOOT_CONFIG  
    SC_MANAGER_ALL_ACCESS
    */

    ServiceControlManager(__in LPCTSTR machineName=NULL, 
            __in LPCTSTR databaseName=NULL,
            __in DWORD desiredAccess=SC_MANAGER_ALL_ACCESS)
        :ServiceControl(NULL)
    {
        SC_HANDLE hServiceControl = OpenSCManager(
              machineName,
            databaseName,
             desiredAccess);
        if (hServiceControl == NULL) {
            throw E_FAIL;
        } else {
            setServiceControl(hServiceControl);
        }
    }
    
/*
The desiredAccess parameter takes one or combinations of the following values
    SERVICE_ALL_ACCESS
    SERVICE_CHANGE_CONFIG
     SERVICE_ENUMERATE_DEPENDENTS
    SERVICE_INTERROGATE
    SERVICE_PAUSE_CONTINUE
    SERVICE_QUERY_CONFIG
    SERVICE_QUERY_STATUS
    SERVICE_START
    SERVICE_STOP
    SERVICE_USER_DEFINED_CONTROL
*/
public:
    BOOL openService(
            __in LPCTSTR serviceName,
            __in DWORD desiredAccess,
            __out ServiceController& service)
    {
        BOOL rc = FALSE;
        SC_HANDLE hServiceControl = getServiceControl();

        SC_HANDLE hService = OpenService(
                  hServiceControl,
                serviceName,
                desiredAccess);
        if (hService == NULL) {
            throw E_FAIL;
        } else {
            service.setServiceControl(hService);
            rc = TRUE;
        }
        return rc;
    }

public:
    SC_HANDLE openService(
            __in LPCTSTR serviceName,
            __in DWORD desiredAccess)
    {
        SC_HANDLE hServiceControl = getServiceControl();

        SC_HANDLE hService = OpenService(
                  hServiceControl,
                serviceName,
                desiredAccess);
        if (hService == NULL) {
            throw E_FAIL;
        }
        return hService;
    }

public:
    SC_HANDLE createService(
            __in        LPCTSTR  lpServiceName,  //2011/09/06 Changed to LPCSTR
            __in_opt    LPCTSTR  lpDisplayName,  //2011/09/06 Changed to LPCTSTR
            __in        DWORD    dwDesiredAccess,
            __in        DWORD    dwServiceType,
            __in        DWORD    dwStartType,
            __in        DWORD    dwErrorControl,
            __in_opt    LPCTSTR  lpBinaryPathName,
            __in_opt    LPCTSTR  lpLoadOrderGroup,
            __out_opt   LPDWORD  lpdwTagId,
            __in_opt    LPCTSTR  lpDependencies,
            __in_opt    LPCTSTR  lpServiceStartName,
            __in_opt    LPCTSTR  lpPassword)
    {

        SC_HANDLE hServiceControl = getServiceControl();
        SC_HANDLE hService =  CreateService(
                hServiceControl,
                lpServiceName,
                lpDisplayName,
                dwDesiredAccess,
                dwServiceType,
                dwStartType,
                dwErrorControl,
                lpBinaryPathName,
                lpLoadOrderGroup,
                lpdwTagId,
                lpDependencies,
                lpServiceStartName,
                lpPassword);
        if (hService == NULL) {
            throw E_FAIL;
        }
        return hService;
    }

public:
    BOOL queryServiceLockStatus(
            __in  LPQUERY_SERVICE_LOCK_STATUS  lpLockStatus,
            __in  DWORD                        cbBufSize,
            __out LPDWORD                      pcbBytesNeeded)
    {
        SC_HANDLE hSCManager = getServiceControl();
        BOOL rc = FALSE;
        if ((rc = QueryServiceLockStatus(
                    hSCManager,
                    lpLockStatus,
                    cbBufSize,
                    pcbBytesNeeded)) == FALSE) {
            throw E_FAIL;
        }
        return rc;
    }


public:
    BOOL enumServicesStatus(
            __in  DWORD                   dwServiceType,
            __in  DWORD                   dwServiceState,
            __in  LPENUM_SERVICE_STATUS   lpServices,
            __in  DWORD                   cbBufSize,
            __out LPDWORD                 pcbBytesNeeded,
            __out LPDWORD                 lpServicesReturned,
            __inout_opt LPDWORD           lpResumeHandle)
    {
        SC_HANDLE hSCManager = getServiceControl();
        BOOL rc = FALSE;
        if ((rc = EnumServicesStatus(
                    hSCManager,
                    dwServiceType,
                    dwServiceState,
                    lpServices,
                    cbBufSize,
                    pcbBytesNeeded,
                    lpServicesReturned,
                    lpResumeHandle)) == FALSE) {
            throw E_FAIL;
        }
        return rc;
    }

public:
    BOOL enumServicesStatusEx(
            __in   SC_ENUM_TYPE    InfoLevel,
            __in   DWORD           dwServiceType,
            __in   DWORD           dwServiceState,
            __in   LPBYTE          lpServices,
            __in   DWORD           cbBufSize,
            __out  LPDWORD         pcbBytesNeeded,
            __out  LPDWORD         lpServicesReturned,
            __inout_opt  LPDWORD   lpResumeHandle,
            __in_opt LPCTSTR       pszGroupName)
    {
        SC_HANDLE hSCManager = getServiceControl();
        BOOL rc = FALSE;
        if ((rc = EnumServicesStatusEx(
                    hSCManager,
                    InfoLevel,
                    dwServiceType,
                    dwServiceState,
                    lpServices,
                    cbBufSize,
                    pcbBytesNeeded,
                    lpServicesReturned,
                    lpResumeHandle,
                    pszGroupName)) == FALSE) {
            throw E_FAIL;
        }
        return rc;
    }

public:
    BOOL getServiceKeyName(
                __in    LPCTSTR  lpDisplayName,
                __in    LPTSTR   lpServiceName,
                __inout LPDWORD  lpcchBuffer)
    {
        SC_HANDLE hSCManager = getServiceControl();
        BOOL rc = FALSE;
        if ((rc = GetServiceKeyName(
                    hSCManager,
                    lpDisplayName,
                    lpServiceName,
                    lpcchBuffer)) == FALSE) {
            throw E_FAIL;
        }
        return rc;
    }

public:
    BOOL getServiceDisplayName(
            __in    LPCTSTR lpServiceName,
            __in    LPTSTR  lpDisplayName,
            __inout LPDWORD lpcchBuffer)
    {
        SC_HANDLE hSCManager = getServiceControl();
        BOOL rc = FALSE;
        if ((rc = GetServiceDisplayName(
                hSCManager,
                lpServiceName,
                lpDisplayName,
                lpcchBuffer)) == FALSE) {
            throw E_FAIL;
        }
        return rc;
    }

public:
    SC_LOCK lockServiceDatabase()
    {
        SC_HANDLE hSCManager = getServiceControl();
        SC_LOCK hLock = NULL;

        if ((hLock = LockServiceDatabase(
            hSCManager)) == NULL) {
            throw E_FAIL;
        }
        return hLock;
    }
};


}