libphobos/libdruntime/core/sys/windows/winsvc.d - gcc - Git at Google


            
            /**

            
             * Windows API header module

            
             *

            
             * Translated from MinGW Windows headers

            
             *

            
             * Authors: Stewart Gordon

            
             * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)

            
             * Source: $(DRUNTIMESRC core/sys/windows/_winsvc.d)

            
             */

            
            module core.sys.windows.winsvc;

            
            version (Windows):


            version (ANSI) {} else version = Unicode;

            
            pragma(lib, "advapi32");


            import core.sys.windows.w32api, core.sys.windows.windef;


            // FIXME: check Windows version support


            const TCHAR[]

            
                SERVICES_ACTIVE_DATABASE = "ServicesActive",

            
                SERVICES_FAILED_DATABASE = "ServicesFailed";


            const TCHAR SC_GROUP_IDENTIFIER = '+';


            enum DWORD

            
                SC_MANAGER_ALL_ACCESS         = 0xf003f,

            
                SC_MANAGER_CONNECT            =  1,

            
                SC_MANAGER_CREATE_SERVICE     =  2,

            
                SC_MANAGER_ENUMERATE_SERVICE  =  4,

            
                SC_MANAGER_LOCK               =  8,

            
                SC_MANAGER_QUERY_LOCK_STATUS  = 16,

            
                SC_MANAGER_MODIFY_BOOT_CONFIG = 32;


            enum DWORD SERVICE_NO_CHANGE = 0xffffffff;


            enum : DWORD {

            
                SERVICE_STOPPED = 1,

            
                SERVICE_START_PENDING,

            
                SERVICE_STOP_PENDING,

            
                SERVICE_RUNNING,

            
                SERVICE_CONTINUE_PENDING,

            
                SERVICE_PAUSE_PENDING,

            
                SERVICE_PAUSED // = 7

            
            }


            enum DWORD

            
                SERVICE_ACCEPT_STOP                  =   1,

            
                SERVICE_ACCEPT_PAUSE_CONTINUE        =   2,

            
                SERVICE_ACCEPT_SHUTDOWN              =   4,

            
                SERVICE_ACCEPT_PARAMCHANGE           =   8,

            
                SERVICE_ACCEPT_NETBINDCHANGE         =  16,

            
                SERVICE_ACCEPT_HARDWAREPROFILECHANGE =  32,

            
                SERVICE_ACCEPT_POWEREVENT            =  64,

            
                SERVICE_ACCEPT_SESSIONCHANGE         = 128;


            enum : DWORD {

            
                SERVICE_CONTROL_STOP = 1,

            
                SERVICE_CONTROL_PAUSE,

            
                SERVICE_CONTROL_CONTINUE,

            
                SERVICE_CONTROL_INTERROGATE,

            
                SERVICE_CONTROL_SHUTDOWN,

            
                SERVICE_CONTROL_PARAMCHANGE,

            
                SERVICE_CONTROL_NETBINDADD,

            
                SERVICE_CONTROL_NETBINDREMOVE,

            
                SERVICE_CONTROL_NETBINDENABLE,

            
                SERVICE_CONTROL_NETBINDDISABLE,

            
                SERVICE_CONTROL_DEVICEEVENT,

            
                SERVICE_CONTROL_HARDWAREPROFILECHANGE,

            
                SERVICE_CONTROL_POWEREVENT,

            
                SERVICE_CONTROL_SESSIONCHANGE, // = 14

            
            }


            enum : DWORD {

            
                SERVICE_ACTIVE = 1,

            
                SERVICE_INACTIVE,

            
                SERVICE_STATE_ALL

            
            }


            enum DWORD

            
                SERVICE_QUERY_CONFIG         = 0x0001,

            
                SERVICE_CHANGE_CONFIG        = 0x0002,

            
                SERVICE_QUERY_STATUS         = 0x0004,

            
                SERVICE_ENUMERATE_DEPENDENTS = 0x0008,

            
                SERVICE_START                = 0x0010,

            
                SERVICE_STOP                 = 0x0020,

            
                SERVICE_PAUSE_CONTINUE       = 0x0040,

            
                SERVICE_INTERROGATE          = 0x0080,

            
                SERVICE_USER_DEFINED_CONTROL = 0x0100,

            
                SERVICE_ALL_ACCESS           = 0x01FF | STANDARD_RIGHTS_REQUIRED;


            // This is not documented on the MSDN site

            
            enum SERVICE_RUNS_IN_SYSTEM_PROCESS = 1;


            enum : DWORD {

            
                SERVICE_CONFIG_DESCRIPTION         = 1,

            
                SERVICE_CONFIG_FAILURE_ACTIONS,

            
                SERVICE_CONFIG_DELAYED_AUTO_START_INFO,

            
                SERVICE_CONFIG_FAILURE_ACTIONS_FLAG,

            
                SERVICE_CONFIG_SERVICE_SID_INFO,

            
                SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO,

            
                SERVICE_CONFIG_PRESHUTDOWN_INFO // = 7

            
            }


            struct SERVICE_STATUS {

            
                DWORD dwServiceType;

            
                DWORD dwCurrentState;

            
                DWORD dwControlsAccepted;

            
                DWORD dwWin32ExitCode;

            
                DWORD dwServiceSpecificExitCode;

            
                DWORD dwCheckPoint;

            
                DWORD dwWaitHint;

            
            }

            
            alias LPSERVICE_STATUS = SERVICE_STATUS*;


            struct ENUM_SERVICE_STATUSA {

            
                LPSTR          lpServiceName;

            
                LPSTR          lpDisplayName;

            
                SERVICE_STATUS ServiceStatus;

            
            }

            
            alias LPENUM_SERVICE_STATUSA = ENUM_SERVICE_STATUSA*;


            struct ENUM_SERVICE_STATUSW {

            
                LPWSTR         lpServiceName;

            
                LPWSTR         lpDisplayName;

            
                SERVICE_STATUS ServiceStatus;

            
            }

            
            alias LPENUM_SERVICE_STATUSW = ENUM_SERVICE_STATUSW*;


            struct QUERY_SERVICE_CONFIGA {

            
                DWORD dwServiceType;

            
                DWORD dwStartType;

            
                DWORD dwErrorControl;

            
                LPSTR lpBinaryPathName;

            
                LPSTR lpLoadOrderGroup;

            
                DWORD dwTagId;

            
                LPSTR lpDependencies;

            
                LPSTR lpServiceStartName;

            
                LPSTR lpDisplayName;

            
            }

            
            alias LPQUERY_SERVICE_CONFIGA = QUERY_SERVICE_CONFIGA*;


            struct QUERY_SERVICE_CONFIGW {

            
                DWORD  dwServiceType;

            
                DWORD  dwStartType;

            
                DWORD  dwErrorControl;

            
                LPWSTR lpBinaryPathName;

            
                LPWSTR lpLoadOrderGroup;

            
                DWORD  dwTagId;

            
                LPWSTR lpDependencies;

            
                LPWSTR lpServiceStartName;

            
                LPWSTR lpDisplayName;

            
            }

            
            alias LPQUERY_SERVICE_CONFIGW = QUERY_SERVICE_CONFIGW*;


            struct QUERY_SERVICE_LOCK_STATUSA {

            
                DWORD fIsLocked;

            
                LPSTR lpLockOwner;

            
                DWORD dwLockDuration;

            
            }

            
            alias LPQUERY_SERVICE_LOCK_STATUSA = QUERY_SERVICE_LOCK_STATUSA*;


            struct QUERY_SERVICE_LOCK_STATUSW {

            
                DWORD  fIsLocked;

            
                LPWSTR lpLockOwner;

            
                DWORD  dwLockDuration;

            
            }

            
            alias LPQUERY_SERVICE_LOCK_STATUSW = QUERY_SERVICE_LOCK_STATUSW*;


            extern (Windows) {

            
                alias LPSERVICE_MAIN_FUNCTIONA = void function(DWORD, LPSTR*);

            
                alias LPSERVICE_MAIN_FUNCTIONW = void function(DWORD, LPWSTR*);

            
            }


            struct SERVICE_TABLE_ENTRYA {

            
                LPSTR                    lpServiceName;

            
                LPSERVICE_MAIN_FUNCTIONA lpServiceProc;

            
            }

            
            alias LPSERVICE_TABLE_ENTRYA = SERVICE_TABLE_ENTRYA*;


            struct SERVICE_TABLE_ENTRYW {

            
                LPWSTR                   lpServiceName;

            
                LPSERVICE_MAIN_FUNCTIONW lpServiceProc;

            
            }

            
            alias LPSERVICE_TABLE_ENTRYW = SERVICE_TABLE_ENTRYW*;


            alias SC_HANDLE = HANDLE;

            
            alias LPSC_HANDLE = SC_HANDLE*;

            
            alias SC_LOCK = void*;

            
            alias SERVICE_STATUS_HANDLE = HANDLE;


            extern (Windows) {

            
                alias LPHANDLER_FUNCTION = void function(DWORD);

            
                alias LPHANDLER_FUNCTION_EX = DWORD function(DWORD, DWORD, LPVOID, LPVOID);

            
            }


            static if (_WIN32_WINNT >= 0x500) {

            
                struct SERVICE_STATUS_PROCESS {

            
                    DWORD dwServiceType;

            
                    DWORD dwCurrentState;

            
                    DWORD dwControlsAccepted;

            
                    DWORD dwWin32ExitCode;

            
                    DWORD dwServiceSpecificExitCode;

            
                    DWORD dwCheckPoint;

            
                    DWORD dwWaitHint;

            
                    DWORD dwProcessId;

            
                    DWORD dwServiceFlags;

            
                }

            
                alias LPSERVICE_STATUS_PROCESS = SERVICE_STATUS_PROCESS*;


                enum SC_STATUS_TYPE {

            
                    SC_STATUS_PROCESS_INFO = 0

            
                }


                enum SC_ENUM_TYPE {

            
                    SC_ENUM_PROCESS_INFO = 0

            
                }


                struct ENUM_SERVICE_STATUS_PROCESSA {

            
                    LPSTR                  lpServiceName;

            
                    LPSTR                  lpDisplayName;

            
                    SERVICE_STATUS_PROCESS ServiceStatusProcess;

            
                }

            
                alias LPENUM_SERVICE_STATUS_PROCESSA = ENUM_SERVICE_STATUS_PROCESSA*;


                struct ENUM_SERVICE_STATUS_PROCESSW {

            
                    LPWSTR                 lpServiceName;

            
                    LPWSTR                 lpDisplayName;

            
                    SERVICE_STATUS_PROCESS ServiceStatusProcess;

            
                }

            
                alias LPENUM_SERVICE_STATUS_PROCESSW = ENUM_SERVICE_STATUS_PROCESSW*;


                struct SERVICE_DESCRIPTIONA {

            
                    LPSTR lpDescription;

            
                }

            
                alias LPSERVICE_DESCRIPTIONA = SERVICE_DESCRIPTIONA*;


                struct SERVICE_DESCRIPTIONW {

            
                    LPWSTR lpDescription;

            
                }

            
                alias LPSERVICE_DESCRIPTIONW = SERVICE_DESCRIPTIONW*;


                enum SC_ACTION_TYPE {

            
                    SC_ACTION_NONE,

            
                    SC_ACTION_RESTART,

            
                    SC_ACTION_REBOOT,

            
                    SC_ACTION_RUN_COMMAND

            
                }


                struct SC_ACTION {

            
                    SC_ACTION_TYPE Type;

            
                    DWORD          Delay;

            
                }

            
                alias LPSC_ACTION = SC_ACTION*;


                struct SERVICE_FAILURE_ACTIONSA {

            
                    DWORD      dwResetPeriod;

            
                    LPSTR      lpRebootMsg;

            
                    LPSTR      lpCommand;

            
                    DWORD      cActions;

            
                    SC_ACTION* lpsaActions;

            
                }

            
                alias LPSERVICE_FAILURE_ACTIONSA = SERVICE_FAILURE_ACTIONSA*;


                struct SERVICE_FAILURE_ACTIONSW {

            
                    DWORD      dwResetPeriod;

            
                    LPWSTR     lpRebootMsg;

            
                    LPWSTR     lpCommand;

            
                    DWORD      cActions;

            
                    SC_ACTION* lpsaActions;

            
                }

            
                alias LPSERVICE_FAILURE_ACTIONSW = SERVICE_FAILURE_ACTIONSW*;

            
            }


            extern (Windows) nothrow @nogc {

            
                BOOL ChangeServiceConfigA(SC_HANDLE, DWORD, DWORD, DWORD, LPCSTR,

            
                  LPCSTR, LPDWORD, LPCSTR, LPCSTR, LPCSTR, LPCSTR);

            
                BOOL ChangeServiceConfigW(SC_HANDLE, DWORD, DWORD, DWORD, LPCWSTR,

            
                  LPCWSTR, LPDWORD, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR);

            
                BOOL CloseServiceHandle(SC_HANDLE);

            
                BOOL ControlService(SC_HANDLE, DWORD, LPSERVICE_STATUS);

            
                SC_HANDLE CreateServiceA(SC_HANDLE, LPCSTR, LPCSTR, DWORD, DWORD,

            
                  DWORD, DWORD, LPCSTR, LPCSTR, PDWORD, LPCSTR, LPCSTR, LPCSTR);

            
                SC_HANDLE CreateServiceW(SC_HANDLE, LPCWSTR, LPCWSTR, DWORD, DWORD,

            
                  DWORD, DWORD, LPCWSTR, LPCWSTR, PDWORD, LPCWSTR, LPCWSTR, LPCWSTR);

            
                BOOL DeleteService(SC_HANDLE);

            
                BOOL EnumDependentServicesA(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUSA,

            
                  DWORD, PDWORD, PDWORD);

            
                BOOL EnumDependentServicesW(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUSW,

            
                  DWORD, PDWORD, PDWORD);

            
                BOOL EnumServicesStatusA(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUSA,

            
                  DWORD, PDWORD, PDWORD, PDWORD);

            
                BOOL EnumServicesStatusW(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUSW,

            
                  DWORD, PDWORD, PDWORD, PDWORD);

            
                BOOL GetServiceDisplayNameA(SC_HANDLE, LPCSTR, LPSTR, PDWORD);

            
                BOOL GetServiceDisplayNameW(SC_HANDLE, LPCWSTR, LPWSTR, PDWORD);

            
                BOOL GetServiceKeyNameA(SC_HANDLE, LPCSTR, LPSTR, PDWORD);

            
                BOOL GetServiceKeyNameW(SC_HANDLE, LPCWSTR, LPWSTR, PDWORD);

            
                SC_LOCK LockServiceDatabase(SC_HANDLE);

            
                BOOL NotifyBootConfigStatus(BOOL);

            
                SC_HANDLE OpenSCManagerA(LPCSTR, LPCSTR, DWORD);

            
                SC_HANDLE OpenSCManagerW(LPCWSTR, LPCWSTR, DWORD);

            
                SC_HANDLE OpenServiceA(SC_HANDLE, LPCSTR, DWORD);

            
                SC_HANDLE OpenServiceW(SC_HANDLE, LPCWSTR, DWORD);

            
                BOOL QueryServiceConfigA(SC_HANDLE, LPQUERY_SERVICE_CONFIGA, DWORD,

            
                  PDWORD);

            
                BOOL QueryServiceConfigW(SC_HANDLE, LPQUERY_SERVICE_CONFIGW, DWORD,

            
                  PDWORD);

            
                BOOL QueryServiceLockStatusA(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUSA,

            
                  DWORD, PDWORD);

            
                BOOL QueryServiceLockStatusW(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUSW,

            
                  DWORD, PDWORD);

            
                BOOL QueryServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION,

            
                  PSECURITY_DESCRIPTOR, DWORD, LPDWORD);

            
                BOOL QueryServiceStatus(SC_HANDLE, LPSERVICE_STATUS);

            
                SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerA(LPCSTR,

            
                  LPHANDLER_FUNCTION);

            
                SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerW(LPCWSTR,

            
                  LPHANDLER_FUNCTION);

            
                BOOL SetServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION,

            
                  PSECURITY_DESCRIPTOR);

            
                BOOL SetServiceStatus(SERVICE_STATUS_HANDLE, LPSERVICE_STATUS);

            
                BOOL StartServiceA(SC_HANDLE, DWORD, LPCSTR*);

            
                BOOL StartServiceW(SC_HANDLE, DWORD, LPCWSTR*);

            
                BOOL StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRYA);

            
                BOOL StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRYW);

            
                BOOL UnlockServiceDatabase(SC_LOCK);


                static if (_WIN32_WINNT >= 0x500) {

            
                    BOOL EnumServicesStatusExA(SC_HANDLE, SC_ENUM_TYPE, DWORD, DWORD, LPBYTE,

            
                      DWORD, LPDWORD, LPDWORD, LPDWORD, LPCSTR);

            
                    BOOL EnumServicesStatusExW(SC_HANDLE, SC_ENUM_TYPE, DWORD, DWORD, LPBYTE,

            
                      DWORD, LPDWORD, LPDWORD, LPDWORD, LPCWSTR);

            
                    BOOL QueryServiceConfig2A(SC_HANDLE, DWORD, LPBYTE, DWORD, LPDWORD);

            
                    BOOL QueryServiceConfig2W(SC_HANDLE, DWORD, LPBYTE, DWORD, LPDWORD);

            
                    BOOL QueryServiceStatusEx(SC_HANDLE, SC_STATUS_TYPE, LPBYTE, DWORD,

            
                      LPDWORD);

            
                    SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerExA(LPCSTR,

            
                      LPHANDLER_FUNCTION_EX, LPVOID);

            
                    SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerExW(LPCWSTR,

            
                      LPHANDLER_FUNCTION_EX, LPVOID);

            
                }


                static if (_WIN32_WINNT >= 0x501) {

            
                    BOOL ChangeServiceConfig2A(SC_HANDLE, DWORD, LPVOID);

            
                    BOOL ChangeServiceConfig2W(SC_HANDLE, DWORD, LPVOID);

            
                }

            
            }


            version (Unicode) {

            
                alias ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSW;

            
                alias QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGW;

            
                alias QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSW;

            
                alias LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONW;

            
                alias SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYW;

            
                alias ChangeServiceConfig = ChangeServiceConfigW;

            
                alias CreateService = CreateServiceW;

            
                alias EnumDependentServices = EnumDependentServicesW;

            
                alias EnumServicesStatus = EnumServicesStatusW;

            
                alias GetServiceDisplayName = GetServiceDisplayNameW;

            
                alias GetServiceKeyName = GetServiceKeyNameW;

            
                alias OpenSCManager = OpenSCManagerW;

            
                alias OpenService = OpenServiceW;

            
                alias QueryServiceConfig = QueryServiceConfigW;

            
                alias QueryServiceLockStatus = QueryServiceLockStatusW;

            
                alias RegisterServiceCtrlHandler = RegisterServiceCtrlHandlerW;

            
                alias StartService = StartServiceW;

            
                alias StartServiceCtrlDispatcher = StartServiceCtrlDispatcherW;


                static if (_WIN32_WINNT >= 0x500) {

            
                    alias ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSW;

            
                    alias SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONW;

            
                    alias SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSW;

            
                    alias EnumServicesStatusEx = EnumServicesStatusExW;

            
                    alias QueryServiceConfig2 = QueryServiceConfig2W;

            
                    alias RegisterServiceCtrlHandlerEx = RegisterServiceCtrlHandlerExW;

            
                }


                static if (_WIN32_WINNT >= 0x501) {

            
                    alias ChangeServiceConfig2 = ChangeServiceConfig2W;

            
                }


            } else {

            
                alias ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSA;

            
                alias QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGA;

            
                alias QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSA;

            
                alias LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONA;

            
                alias SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYA;

            
                alias ChangeServiceConfig = ChangeServiceConfigA;

            
                alias CreateService = CreateServiceA;

            
                alias EnumDependentServices = EnumDependentServicesA;

            
                alias EnumServicesStatus = EnumServicesStatusA;

            
                alias GetServiceDisplayName = GetServiceDisplayNameA;

            
                alias GetServiceKeyName = GetServiceKeyNameA;

            
                alias OpenSCManager = OpenSCManagerA;

            
                alias OpenService = OpenServiceA;

            
                alias QueryServiceConfig = QueryServiceConfigA;

            
                alias QueryServiceLockStatus = QueryServiceLockStatusA;

            
                alias RegisterServiceCtrlHandler = RegisterServiceCtrlHandlerA;

            
                alias StartService = StartServiceA;

            
                alias StartServiceCtrlDispatcher = StartServiceCtrlDispatcherA;


                static if (_WIN32_WINNT >= 0x500) {

            
                    alias ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSA;

            
                    alias SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONA;

            
                    alias SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSA;

            
                    alias EnumServicesStatusEx = EnumServicesStatusExA;

            
                    alias QueryServiceConfig2 = QueryServiceConfig2A;

            
                    alias RegisterServiceCtrlHandlerEx = RegisterServiceCtrlHandlerExA;

            
                }


                static if (_WIN32_WINNT >= 0x501) {

            
                    alias ChangeServiceConfig2 = ChangeServiceConfig2A;

            
                }


            }


            alias LPENUM_SERVICE_STATUS = ENUM_SERVICE_STATUS*;

            
            alias LPQUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIG*;

            
            alias LPQUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUS*;

            
            alias LPSERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRY*;


            static if (_WIN32_WINNT >= 0x500) {

            
                alias LPENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESS*;

            
                alias LPSERVICE_DESCRIPTION = SERVICE_DESCRIPTION*;

            
                alias LPSERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONS*;

            
            }
	/**
	* Windows API header module
	*
	* Translated from MinGW Windows headers
	*
	* Authors: Stewart Gordon
	* License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
	* Source: $(DRUNTIMESRC core/sys/windows/_winsvc.d)
	*/
	module core.sys.windows.winsvc;
	version (Windows):

	version (ANSI) {} else version = Unicode;
	pragma(lib, "advapi32");

	import core.sys.windows.w32api, core.sys.windows.windef;

	// FIXME: check Windows version support

	const TCHAR[]
	SERVICES_ACTIVE_DATABASE = "ServicesActive",
	SERVICES_FAILED_DATABASE = "ServicesFailed";

	const TCHAR SC_GROUP_IDENTIFIER = '+';

	enum DWORD
	SC_MANAGER_ALL_ACCESS = 0xf003f,
	SC_MANAGER_CONNECT = 1,
	SC_MANAGER_CREATE_SERVICE = 2,
	SC_MANAGER_ENUMERATE_SERVICE = 4,
	SC_MANAGER_LOCK = 8,
	SC_MANAGER_QUERY_LOCK_STATUS = 16,
	SC_MANAGER_MODIFY_BOOT_CONFIG = 32;

	enum DWORD SERVICE_NO_CHANGE = 0xffffffff;

	enum : DWORD {
	SERVICE_STOPPED = 1,
	SERVICE_START_PENDING,
	SERVICE_STOP_PENDING,
	SERVICE_RUNNING,
	SERVICE_CONTINUE_PENDING,
	SERVICE_PAUSE_PENDING,
	SERVICE_PAUSED // = 7
	}

	enum DWORD
	SERVICE_ACCEPT_STOP = 1,
	SERVICE_ACCEPT_PAUSE_CONTINUE = 2,
	SERVICE_ACCEPT_SHUTDOWN = 4,
	SERVICE_ACCEPT_PARAMCHANGE = 8,
	SERVICE_ACCEPT_NETBINDCHANGE = 16,
	SERVICE_ACCEPT_HARDWAREPROFILECHANGE = 32,
	SERVICE_ACCEPT_POWEREVENT = 64,
	SERVICE_ACCEPT_SESSIONCHANGE = 128;

	enum : DWORD {
	SERVICE_CONTROL_STOP = 1,
	SERVICE_CONTROL_PAUSE,
	SERVICE_CONTROL_CONTINUE,
	SERVICE_CONTROL_INTERROGATE,
	SERVICE_CONTROL_SHUTDOWN,
	SERVICE_CONTROL_PARAMCHANGE,
	SERVICE_CONTROL_NETBINDADD,
	SERVICE_CONTROL_NETBINDREMOVE,
	SERVICE_CONTROL_NETBINDENABLE,
	SERVICE_CONTROL_NETBINDDISABLE,
	SERVICE_CONTROL_DEVICEEVENT,
	SERVICE_CONTROL_HARDWAREPROFILECHANGE,
	SERVICE_CONTROL_POWEREVENT,
	SERVICE_CONTROL_SESSIONCHANGE, // = 14
	}

	enum : DWORD {
	SERVICE_ACTIVE = 1,
	SERVICE_INACTIVE,
	SERVICE_STATE_ALL
	}

	enum DWORD
	SERVICE_QUERY_CONFIG = 0x0001,
	SERVICE_CHANGE_CONFIG = 0x0002,
	SERVICE_QUERY_STATUS = 0x0004,
	SERVICE_ENUMERATE_DEPENDENTS = 0x0008,
	SERVICE_START = 0x0010,
	SERVICE_STOP = 0x0020,
	SERVICE_PAUSE_CONTINUE = 0x0040,
	SERVICE_INTERROGATE = 0x0080,
	SERVICE_USER_DEFINED_CONTROL = 0x0100,
	SERVICE_ALL_ACCESS = 0x01FF \| STANDARD_RIGHTS_REQUIRED;

	// This is not documented on the MSDN site
	enum SERVICE_RUNS_IN_SYSTEM_PROCESS = 1;

	enum : DWORD {
	SERVICE_CONFIG_DESCRIPTION = 1,
	SERVICE_CONFIG_FAILURE_ACTIONS,
	SERVICE_CONFIG_DELAYED_AUTO_START_INFO,
	SERVICE_CONFIG_FAILURE_ACTIONS_FLAG,
	SERVICE_CONFIG_SERVICE_SID_INFO,
	SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO,
	SERVICE_CONFIG_PRESHUTDOWN_INFO // = 7
	}

	struct SERVICE_STATUS {
	DWORD dwServiceType;
	DWORD dwCurrentState;
	DWORD dwControlsAccepted;
	DWORD dwWin32ExitCode;
	DWORD dwServiceSpecificExitCode;
	DWORD dwCheckPoint;
	DWORD dwWaitHint;
	}
	alias LPSERVICE_STATUS = SERVICE_STATUS*;

	struct ENUM_SERVICE_STATUSA {
	LPSTR lpServiceName;
	LPSTR lpDisplayName;
	SERVICE_STATUS ServiceStatus;
	}
	alias LPENUM_SERVICE_STATUSA = ENUM_SERVICE_STATUSA*;

	struct ENUM_SERVICE_STATUSW {
	LPWSTR lpServiceName;
	LPWSTR lpDisplayName;
	SERVICE_STATUS ServiceStatus;
	}
	alias LPENUM_SERVICE_STATUSW = ENUM_SERVICE_STATUSW*;

	struct QUERY_SERVICE_CONFIGA {
	DWORD dwServiceType;
	DWORD dwStartType;
	DWORD dwErrorControl;
	LPSTR lpBinaryPathName;
	LPSTR lpLoadOrderGroup;
	DWORD dwTagId;
	LPSTR lpDependencies;
	LPSTR lpServiceStartName;
	LPSTR lpDisplayName;
	}
	alias LPQUERY_SERVICE_CONFIGA = QUERY_SERVICE_CONFIGA*;

	struct QUERY_SERVICE_CONFIGW {
	DWORD dwServiceType;
	DWORD dwStartType;
	DWORD dwErrorControl;
	LPWSTR lpBinaryPathName;
	LPWSTR lpLoadOrderGroup;
	DWORD dwTagId;
	LPWSTR lpDependencies;
	LPWSTR lpServiceStartName;
	LPWSTR lpDisplayName;
	}
	alias LPQUERY_SERVICE_CONFIGW = QUERY_SERVICE_CONFIGW*;

	struct QUERY_SERVICE_LOCK_STATUSA {
	DWORD fIsLocked;
	LPSTR lpLockOwner;
	DWORD dwLockDuration;
	}
	alias LPQUERY_SERVICE_LOCK_STATUSA = QUERY_SERVICE_LOCK_STATUSA*;

	struct QUERY_SERVICE_LOCK_STATUSW {
	DWORD fIsLocked;
	LPWSTR lpLockOwner;
	DWORD dwLockDuration;
	}
	alias LPQUERY_SERVICE_LOCK_STATUSW = QUERY_SERVICE_LOCK_STATUSW*;

	extern (Windows) {
	alias LPSERVICE_MAIN_FUNCTIONA = void function(DWORD, LPSTR*);
	alias LPSERVICE_MAIN_FUNCTIONW = void function(DWORD, LPWSTR*);
	}

	struct SERVICE_TABLE_ENTRYA {
	LPSTR lpServiceName;
	LPSERVICE_MAIN_FUNCTIONA lpServiceProc;
	}
	alias LPSERVICE_TABLE_ENTRYA = SERVICE_TABLE_ENTRYA*;

	struct SERVICE_TABLE_ENTRYW {
	LPWSTR lpServiceName;
	LPSERVICE_MAIN_FUNCTIONW lpServiceProc;
	}
	alias LPSERVICE_TABLE_ENTRYW = SERVICE_TABLE_ENTRYW*;

	alias SC_HANDLE = HANDLE;
	alias LPSC_HANDLE = SC_HANDLE*;
	alias SC_LOCK = void*;
	alias SERVICE_STATUS_HANDLE = HANDLE;

	extern (Windows) {
	alias LPHANDLER_FUNCTION = void function(DWORD);
	alias LPHANDLER_FUNCTION_EX = DWORD function(DWORD, DWORD, LPVOID, LPVOID);
	}

	static if (_WIN32_WINNT >= 0x500) {
	struct SERVICE_STATUS_PROCESS {
	DWORD dwServiceType;
	DWORD dwCurrentState;
	DWORD dwControlsAccepted;
	DWORD dwWin32ExitCode;
	DWORD dwServiceSpecificExitCode;
	DWORD dwCheckPoint;
	DWORD dwWaitHint;
	DWORD dwProcessId;
	DWORD dwServiceFlags;
	}
	alias LPSERVICE_STATUS_PROCESS = SERVICE_STATUS_PROCESS*;

	enum SC_STATUS_TYPE {
	SC_STATUS_PROCESS_INFO = 0
	}

	enum SC_ENUM_TYPE {
	SC_ENUM_PROCESS_INFO = 0
	}

	struct ENUM_SERVICE_STATUS_PROCESSA {
	LPSTR lpServiceName;
	LPSTR lpDisplayName;
	SERVICE_STATUS_PROCESS ServiceStatusProcess;
	}
	alias LPENUM_SERVICE_STATUS_PROCESSA = ENUM_SERVICE_STATUS_PROCESSA*;

	struct ENUM_SERVICE_STATUS_PROCESSW {
	LPWSTR lpServiceName;
	LPWSTR lpDisplayName;
	SERVICE_STATUS_PROCESS ServiceStatusProcess;
	}
	alias LPENUM_SERVICE_STATUS_PROCESSW = ENUM_SERVICE_STATUS_PROCESSW*;

	struct SERVICE_DESCRIPTIONA {
	LPSTR lpDescription;
	}
	alias LPSERVICE_DESCRIPTIONA = SERVICE_DESCRIPTIONA*;

	struct SERVICE_DESCRIPTIONW {
	LPWSTR lpDescription;
	}
	alias LPSERVICE_DESCRIPTIONW = SERVICE_DESCRIPTIONW*;

	enum SC_ACTION_TYPE {
	SC_ACTION_NONE,
	SC_ACTION_RESTART,
	SC_ACTION_REBOOT,
	SC_ACTION_RUN_COMMAND
	}

	struct SC_ACTION {
	SC_ACTION_TYPE Type;
	DWORD Delay;
	}
	alias LPSC_ACTION = SC_ACTION*;

	struct SERVICE_FAILURE_ACTIONSA {
	DWORD dwResetPeriod;
	LPSTR lpRebootMsg;
	LPSTR lpCommand;
	DWORD cActions;
	SC_ACTION* lpsaActions;
	}
	alias LPSERVICE_FAILURE_ACTIONSA = SERVICE_FAILURE_ACTIONSA*;

	struct SERVICE_FAILURE_ACTIONSW {
	DWORD dwResetPeriod;
	LPWSTR lpRebootMsg;
	LPWSTR lpCommand;
	DWORD cActions;
	SC_ACTION* lpsaActions;
	}
	alias LPSERVICE_FAILURE_ACTIONSW = SERVICE_FAILURE_ACTIONSW*;
	}

	extern (Windows) nothrow @nogc {
	BOOL ChangeServiceConfigA(SC_HANDLE, DWORD, DWORD, DWORD, LPCSTR,
	LPCSTR, LPDWORD, LPCSTR, LPCSTR, LPCSTR, LPCSTR);
	BOOL ChangeServiceConfigW(SC_HANDLE, DWORD, DWORD, DWORD, LPCWSTR,
	LPCWSTR, LPDWORD, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR);
	BOOL CloseServiceHandle(SC_HANDLE);
	BOOL ControlService(SC_HANDLE, DWORD, LPSERVICE_STATUS);
	SC_HANDLE CreateServiceA(SC_HANDLE, LPCSTR, LPCSTR, DWORD, DWORD,
	DWORD, DWORD, LPCSTR, LPCSTR, PDWORD, LPCSTR, LPCSTR, LPCSTR);
	SC_HANDLE CreateServiceW(SC_HANDLE, LPCWSTR, LPCWSTR, DWORD, DWORD,
	DWORD, DWORD, LPCWSTR, LPCWSTR, PDWORD, LPCWSTR, LPCWSTR, LPCWSTR);
	BOOL DeleteService(SC_HANDLE);
	BOOL EnumDependentServicesA(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUSA,
	DWORD, PDWORD, PDWORD);
	BOOL EnumDependentServicesW(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUSW,
	DWORD, PDWORD, PDWORD);
	BOOL EnumServicesStatusA(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUSA,
	DWORD, PDWORD, PDWORD, PDWORD);
	BOOL EnumServicesStatusW(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUSW,
	DWORD, PDWORD, PDWORD, PDWORD);
	BOOL GetServiceDisplayNameA(SC_HANDLE, LPCSTR, LPSTR, PDWORD);
	BOOL GetServiceDisplayNameW(SC_HANDLE, LPCWSTR, LPWSTR, PDWORD);
	BOOL GetServiceKeyNameA(SC_HANDLE, LPCSTR, LPSTR, PDWORD);
	BOOL GetServiceKeyNameW(SC_HANDLE, LPCWSTR, LPWSTR, PDWORD);
	SC_LOCK LockServiceDatabase(SC_HANDLE);
	BOOL NotifyBootConfigStatus(BOOL);
	SC_HANDLE OpenSCManagerA(LPCSTR, LPCSTR, DWORD);
	SC_HANDLE OpenSCManagerW(LPCWSTR, LPCWSTR, DWORD);
	SC_HANDLE OpenServiceA(SC_HANDLE, LPCSTR, DWORD);
	SC_HANDLE OpenServiceW(SC_HANDLE, LPCWSTR, DWORD);
	BOOL QueryServiceConfigA(SC_HANDLE, LPQUERY_SERVICE_CONFIGA, DWORD,
	PDWORD);
	BOOL QueryServiceConfigW(SC_HANDLE, LPQUERY_SERVICE_CONFIGW, DWORD,
	PDWORD);
	BOOL QueryServiceLockStatusA(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUSA,
	DWORD, PDWORD);
	BOOL QueryServiceLockStatusW(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUSW,
	DWORD, PDWORD);
	BOOL QueryServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION,
	PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
	BOOL QueryServiceStatus(SC_HANDLE, LPSERVICE_STATUS);
	SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerA(LPCSTR,
	LPHANDLER_FUNCTION);
	SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerW(LPCWSTR,
	LPHANDLER_FUNCTION);
	BOOL SetServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION,
	PSECURITY_DESCRIPTOR);
	BOOL SetServiceStatus(SERVICE_STATUS_HANDLE, LPSERVICE_STATUS);
	BOOL StartServiceA(SC_HANDLE, DWORD, LPCSTR*);
	BOOL StartServiceW(SC_HANDLE, DWORD, LPCWSTR*);
	BOOL StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRYA);
	BOOL StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRYW);
	BOOL UnlockServiceDatabase(SC_LOCK);

	static if (_WIN32_WINNT >= 0x500) {
	BOOL EnumServicesStatusExA(SC_HANDLE, SC_ENUM_TYPE, DWORD, DWORD, LPBYTE,
	DWORD, LPDWORD, LPDWORD, LPDWORD, LPCSTR);
	BOOL EnumServicesStatusExW(SC_HANDLE, SC_ENUM_TYPE, DWORD, DWORD, LPBYTE,
	DWORD, LPDWORD, LPDWORD, LPDWORD, LPCWSTR);
	BOOL QueryServiceConfig2A(SC_HANDLE, DWORD, LPBYTE, DWORD, LPDWORD);
	BOOL QueryServiceConfig2W(SC_HANDLE, DWORD, LPBYTE, DWORD, LPDWORD);
	BOOL QueryServiceStatusEx(SC_HANDLE, SC_STATUS_TYPE, LPBYTE, DWORD,
	LPDWORD);
	SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerExA(LPCSTR,
	LPHANDLER_FUNCTION_EX, LPVOID);
	SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerExW(LPCWSTR,
	LPHANDLER_FUNCTION_EX, LPVOID);
	}

	static if (_WIN32_WINNT >= 0x501) {
	BOOL ChangeServiceConfig2A(SC_HANDLE, DWORD, LPVOID);
	BOOL ChangeServiceConfig2W(SC_HANDLE, DWORD, LPVOID);
	}
	}

	version (Unicode) {
	alias ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSW;
	alias QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGW;
	alias QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSW;
	alias LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONW;
	alias SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYW;
	alias ChangeServiceConfig = ChangeServiceConfigW;
	alias CreateService = CreateServiceW;
	alias EnumDependentServices = EnumDependentServicesW;
	alias EnumServicesStatus = EnumServicesStatusW;
	alias GetServiceDisplayName = GetServiceDisplayNameW;
	alias GetServiceKeyName = GetServiceKeyNameW;
	alias OpenSCManager = OpenSCManagerW;
	alias OpenService = OpenServiceW;
	alias QueryServiceConfig = QueryServiceConfigW;
	alias QueryServiceLockStatus = QueryServiceLockStatusW;
	alias RegisterServiceCtrlHandler = RegisterServiceCtrlHandlerW;
	alias StartService = StartServiceW;
	alias StartServiceCtrlDispatcher = StartServiceCtrlDispatcherW;

	static if (_WIN32_WINNT >= 0x500) {
	alias ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSW;
	alias SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONW;
	alias SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSW;
	alias EnumServicesStatusEx = EnumServicesStatusExW;
	alias QueryServiceConfig2 = QueryServiceConfig2W;
	alias RegisterServiceCtrlHandlerEx = RegisterServiceCtrlHandlerExW;
	}

	static if (_WIN32_WINNT >= 0x501) {
	alias ChangeServiceConfig2 = ChangeServiceConfig2W;
	}

	} else {
	alias ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSA;
	alias QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGA;
	alias QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSA;
	alias LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONA;
	alias SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYA;
	alias ChangeServiceConfig = ChangeServiceConfigA;
	alias CreateService = CreateServiceA;
	alias EnumDependentServices = EnumDependentServicesA;
	alias EnumServicesStatus = EnumServicesStatusA;
	alias GetServiceDisplayName = GetServiceDisplayNameA;
	alias GetServiceKeyName = GetServiceKeyNameA;
	alias OpenSCManager = OpenSCManagerA;
	alias OpenService = OpenServiceA;
	alias QueryServiceConfig = QueryServiceConfigA;
	alias QueryServiceLockStatus = QueryServiceLockStatusA;
	alias RegisterServiceCtrlHandler = RegisterServiceCtrlHandlerA;
	alias StartService = StartServiceA;
	alias StartServiceCtrlDispatcher = StartServiceCtrlDispatcherA;

	static if (_WIN32_WINNT >= 0x500) {
	alias ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSA;
	alias SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONA;
	alias SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSA;
	alias EnumServicesStatusEx = EnumServicesStatusExA;
	alias QueryServiceConfig2 = QueryServiceConfig2A;
	alias RegisterServiceCtrlHandlerEx = RegisterServiceCtrlHandlerExA;
	}

	static if (_WIN32_WINNT >= 0x501) {
	alias ChangeServiceConfig2 = ChangeServiceConfig2A;
	}

	}

	alias LPENUM_SERVICE_STATUS = ENUM_SERVICE_STATUS*;
	alias LPQUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIG*;
	alias LPQUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUS*;
	alias LPSERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRY*;

	static if (_WIN32_WINNT >= 0x500) {
	alias LPENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESS*;
	alias LPSERVICE_DESCRIPTION = SERVICE_DESCRIPTION*;
	alias LPSERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONS*;
	}