ServiceManager.h

Go to the documentation of this file.

/*  ServiceManager.h - Service Control API wrapper
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_ServiceManager_h
#define OW32_ServiceManager_h

#include <OW32/XSC_HANDLE.h>
#include <OW32/auto_buf.h>

namespace OW32
{
class OW32_LIB_EXPORT CEnumDependentServices;

class OW32_LIB_EXPORT CSCService
{
private:
    XSC_HANDLE m_hService;

public:
    CSCService(SC_HANDLE hService) :
        m_hService(hService)
    {
    }

    ~CSCService()
    {
        // obscure, CloseServiceHandle sets last error to ERROR_IO_PENDING
        DWORD dwLastError = ::GetLastError();
        m_hService.Close();
        ::SetLastError(dwLastError);
    }

    SC_HANDLE GetHandle() const { return m_hService; }

    BOOL Control(DWORD dwControl, LPSERVICE_STATUS lpServiceStatus) 
    {
        return ::ControlService(m_hService, dwControl, lpServiceStatus);
    }

    BOOL Start(DWORD dwNumServiceArgs = 0, LPCTSTR* lpServiceArgVectors = NULL)
    {
        return ::StartService(m_hService, dwNumServiceArgs, lpServiceArgVectors);
    }

    BOOL Stop(LPSERVICE_STATUS lpServiceStatus)
    {
        return ::ControlService(m_hService, SERVICE_CONTROL_STOP, lpServiceStatus);
    }

    BOOL Delete()
    {
        return ::DeleteService(m_hService);
    }

    BOOL QueryStatus(LPSERVICE_STATUS lpServiceStatus) { return ::QueryServiceStatus(m_hService, lpServiceStatus); }

    inline CEnumDependentServices* EnumDependentServices(DWORD dwServiceState = SERVICE_STATE_ALL);

    operator SC_HANDLE() { return m_hService; }
};

#ifdef _MSC_VER
#pragma warning(disable: 4251)
#endif

class OW32_LIB_EXPORT CEnumDependentServices
{
public:
    CEnumDependentServices(CSCService& parent, DWORD dwServiceState) :
        m_parent(parent),
        m_dwServiceState(dwServiceState),
        m_dwCount(0),
        m_dwPos(0),
        m_bGot(false)
    {
        m_buf.reserve(sizeof(ENUM_SERVICE_STATUS) + 256*2); // space for at least one entry
    }

    BOOL Next(ENUM_SERVICE_STATUS** ppEntry)
    {
        if (!m_bGot) 
        {
            for (int i = 0; i < 2; i++) {
                DWORD cbBytesNeeded;
                if (!EnumDependentServices(m_parent, m_dwServiceState, (ENUM_SERVICE_STATUS*)m_buf.str(),
                    (DWORD)m_buf.capacity(), &cbBytesNeeded, &m_dwCount)) {
                    if (i > 0 || GetLastError() != ERROR_MORE_DATA)
                        return FALSE;
                }
                m_buf.reserve(cbBytesNeeded);
            }
            m_bGot = true;
        }

        if (m_dwPos >= m_dwCount) {
            SetLastError(ERROR_NO_MORE_ITEMS);
            return FALSE;
        }

        *ppEntry = &((ENUM_SERVICE_STATUS*)m_buf.str())[m_dwPos++];
        return TRUE;
    }

private:
    CEnumDependentServices(const CEnumDependentServices &other);
    CEnumDependentServices& operator=(const CEnumDependentServices &other);

    CSCService      &m_parent;
    DWORD           m_dwServiceState;
    DWORD           m_dwPos, m_dwCount;
    auto_byte_buf   m_buf;
    bool            m_bGot;
};

#ifdef _MSC_VER
#pragma warning(default: 4251)
#endif

inline CEnumDependentServices* CSCService::EnumDependentServices(DWORD dwServiceState)
{
    return new CEnumDependentServices(*this, dwServiceState);
}

class OW32_LIB_EXPORT CEnumServicesStatus;

class OW32_LIB_EXPORT CSCManager
{
private:
    XSC_HANDLE m_SCManager;

public:
    BOOL Open(DWORD dwDesiredAccess = SC_MANAGER_ALL_ACCESS, LPCTSTR lpszMachineName = NULL)
    {
        m_SCManager = ::OpenSCManager(lpszMachineName, SERVICES_ACTIVE_DATABASE, dwDesiredAccess);
        return m_SCManager != NULL;
    }

    void Close()
    {
        m_SCManager.Close();
    }

    ~CSCManager()
    {
        // obscure, CloseServiceHandle sets last error to ERROR_IO_PENDING
        DWORD dwLastError = ::GetLastError();
        m_SCManager.Close();
        ::SetLastError(dwLastError);
    }

    SC_HANDLE GetHandle() const { return m_SCManager; }

    inline CEnumServicesStatus* EnumServicesStatus(DWORD dwServiceType=SERVICE_WIN32, DWORD dwServiceState=SERVICE_STATE_ALL);

    CSCService* CreateService(
        LPCTSTR lpServiceName,                            // net stop name
        LPCTSTR lpPath,                                   // module path
        LPCTSTR lpServiceDescription = NULL,              // friendly name
        DWORD dwDesiredAccess = STANDARD_RIGHTS_REQUIRED, // delete/control/interrogate/etc
        DWORD dwServiceType = SERVICE_WIN32_OWN_PROCESS,  // own process/shared/drivers
        DWORD dwStartType = SERVICE_AUTO_START,           // auto start flag
        DWORD dwErrorControl = SERVICE_ERROR_NORMAL,      // error handling mode
        LPCTSTR lpLoadOrderGroup = NULL,                  // load order group
        LPDWORD lpLoadOrderTag = NULL,                    // load order tag
        LPCTSTR lpDependencies = NULL,                    // array of dependency names
        LPCTSTR lpAccountName = NULL,                     // local system
        LPCTSTR lpPassword = NULL)                        // (NULL is OK for local system)
    {
        SC_HANDLE hService = 
            ::CreateService(m_SCManager, lpServiceName, lpServiceDescription, dwDesiredAccess,
                            dwServiceType, dwStartType, dwErrorControl, lpPath,
                            lpLoadOrderGroup, lpLoadOrderTag, lpDependencies, lpAccountName, lpPassword);
        if (hService==NULL)
            return NULL;
        return new CSCService(hService);
    }

    CSCService* OpenService(LPCTSTR lpServiceName, DWORD dwDesiredAccess = SERVICE_ALL_ACCESS)
    {
        SC_HANDLE hService = ::OpenService(m_SCManager, lpServiceName, dwDesiredAccess);
        if (hService==NULL)
            return NULL;
        return new CSCService(hService);
    }
};

class OW32_LIB_EXPORT CEnumServicesStatus
{
public:
    inline CEnumServicesStatus(CSCManager& parent, DWORD dwServiceType, DWORD dwServiceState);

    inline DWORD Next(ENUM_SERVICE_STATUS** ppEntry); // returns ERROR_NO_MORE_DATA if finished; ERROR_SUCCESS if OK

private:
    CEnumServicesStatus(const CEnumServicesStatus &other);
    CEnumServicesStatus& operator=(const CEnumServicesStatus &other);

    CSCManager          &m_Parent;
    DWORD               m_CurrentPos,m_BufferCount;
    DWORD               m_dwServiceType,m_dwServiceState,m_dwResumeHandle;
    bool                m_bMoreToCome;
    ENUM_SERVICE_STATUS m_StatusBuffer[1024 / sizeof(ENUM_SERVICE_STATUS)];
};

inline CEnumServicesStatus* CSCManager::EnumServicesStatus(DWORD dwServiceType, DWORD dwServiceState)
{
    return new CEnumServicesStatus(*this, dwServiceType, dwServiceState);
}

inline CEnumServicesStatus::CEnumServicesStatus(CSCManager& parent, DWORD dwServiceType, DWORD dwServiceState) :
    m_Parent(parent),
    m_CurrentPos(0),
    m_BufferCount(0),
    m_dwServiceType(dwServiceType),
    m_dwServiceState(dwServiceState),
    m_dwResumeHandle(0),
    m_bMoreToCome(true)
{
}

inline DWORD CEnumServicesStatus::Next(ENUM_SERVICE_STATUS** ppEntry)
{
    // use current buffer & advance counter
    if (m_CurrentPos < m_BufferCount) {
        *ppEntry = &m_StatusBuffer[m_CurrentPos++];
        return ERROR_SUCCESS;
    }
    
    // otherwise, fetch more data
    if (m_bMoreToCome) {
        DWORD dwBytesNeeded;
        if (!EnumServicesStatus(m_Parent.GetHandle(), m_dwServiceType, m_dwServiceState, m_StatusBuffer, 
                                sizeof(m_StatusBuffer), &dwBytesNeeded, &m_BufferCount, &m_dwResumeHandle))
        {
            DWORD dwError=GetLastError();
            if (dwError!=ERROR_MORE_DATA)
                return dwError;
        } else
            m_bMoreToCome = false; // all data fetched
    } else {
        return 1; // TODO: hack!
    }

    // return the data & reset the buffer pointer
    m_CurrentPos=0;
    *ppEntry = &m_StatusBuffer[m_CurrentPos++];
    return ERROR_SUCCESS;
}

}

#endif // OW32_ServiceManager_h

---