1 /** 2 * Windows API header module 3 * 4 * Translated from MinGW Windows headers 5 * 6 * Authors: Stewart Gordon 7 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) 8 * Source: $(DRUNTIMESRC core/sys/windows/_winsvc.d) 9 */ 10 module nulib.system.win32.winsvc; 11 12 13 version (ANSI) {} else version = Unicode; 14 pragma(lib, "advapi32"); 15 16 import nulib.system.win32.w32api, nulib.system.win32.windef; 17 18 // FIXME: check Windows version support 19 20 const TCHAR[] 21 SERVICES_ACTIVE_DATABASE = "ServicesActive", 22 SERVICES_FAILED_DATABASE = "ServicesFailed"; 23 24 const TCHAR SC_GROUP_IDENTIFIER = '+'; 25 26 enum DWORD 27 SC_MANAGER_ALL_ACCESS = 0xf003f, 28 SC_MANAGER_CONNECT = 1, 29 SC_MANAGER_CREATE_SERVICE = 2, 30 SC_MANAGER_ENUMERATE_SERVICE = 4, 31 SC_MANAGER_LOCK = 8, 32 SC_MANAGER_QUERY_LOCK_STATUS = 16, 33 SC_MANAGER_MODIFY_BOOT_CONFIG = 32; 34 35 enum DWORD SERVICE_NO_CHANGE = 0xffffffff; 36 37 enum : DWORD { 38 SERVICE_STOPPED = 1, 39 SERVICE_START_PENDING, 40 SERVICE_STOP_PENDING, 41 SERVICE_RUNNING, 42 SERVICE_CONTINUE_PENDING, 43 SERVICE_PAUSE_PENDING, 44 SERVICE_PAUSED // = 7 45 } 46 47 enum DWORD 48 SERVICE_ACCEPT_STOP = 1, 49 SERVICE_ACCEPT_PAUSE_CONTINUE = 2, 50 SERVICE_ACCEPT_SHUTDOWN = 4, 51 SERVICE_ACCEPT_PARAMCHANGE = 8, 52 SERVICE_ACCEPT_NETBINDCHANGE = 16, 53 SERVICE_ACCEPT_HARDWAREPROFILECHANGE = 32, 54 SERVICE_ACCEPT_POWEREVENT = 64, 55 SERVICE_ACCEPT_SESSIONCHANGE = 128; 56 57 enum : DWORD { 58 SERVICE_CONTROL_STOP = 1, 59 SERVICE_CONTROL_PAUSE, 60 SERVICE_CONTROL_CONTINUE, 61 SERVICE_CONTROL_INTERROGATE, 62 SERVICE_CONTROL_SHUTDOWN, 63 SERVICE_CONTROL_PARAMCHANGE, 64 SERVICE_CONTROL_NETBINDADD, 65 SERVICE_CONTROL_NETBINDREMOVE, 66 SERVICE_CONTROL_NETBINDENABLE, 67 SERVICE_CONTROL_NETBINDDISABLE, 68 SERVICE_CONTROL_DEVICEEVENT, 69 SERVICE_CONTROL_HARDWAREPROFILECHANGE, 70 SERVICE_CONTROL_POWEREVENT, 71 SERVICE_CONTROL_SESSIONCHANGE, // = 14 72 } 73 74 enum : DWORD { 75 SERVICE_ACTIVE = 1, 76 SERVICE_INACTIVE, 77 SERVICE_STATE_ALL 78 } 79 80 enum DWORD 81 SERVICE_QUERY_CONFIG = 0x0001, 82 SERVICE_CHANGE_CONFIG = 0x0002, 83 SERVICE_QUERY_STATUS = 0x0004, 84 SERVICE_ENUMERATE_DEPENDENTS = 0x0008, 85 SERVICE_START = 0x0010, 86 SERVICE_STOP = 0x0020, 87 SERVICE_PAUSE_CONTINUE = 0x0040, 88 SERVICE_INTERROGATE = 0x0080, 89 SERVICE_USER_DEFINED_CONTROL = 0x0100, 90 SERVICE_ALL_ACCESS = 0x01FF | STANDARD_RIGHTS_REQUIRED; 91 92 // This is not documented on the MSDN site 93 enum SERVICE_RUNS_IN_SYSTEM_PROCESS = 1; 94 95 enum : DWORD { 96 SERVICE_CONFIG_DESCRIPTION = 1, 97 SERVICE_CONFIG_FAILURE_ACTIONS, 98 SERVICE_CONFIG_DELAYED_AUTO_START_INFO, 99 SERVICE_CONFIG_FAILURE_ACTIONS_FLAG, 100 SERVICE_CONFIG_SERVICE_SID_INFO, 101 SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO, 102 SERVICE_CONFIG_PRESHUTDOWN_INFO // = 7 103 } 104 105 struct SERVICE_STATUS { 106 DWORD dwServiceType; 107 DWORD dwCurrentState; 108 DWORD dwControlsAccepted; 109 DWORD dwWin32ExitCode; 110 DWORD dwServiceSpecificExitCode; 111 DWORD dwCheckPoint; 112 DWORD dwWaitHint; 113 } 114 alias LPSERVICE_STATUS = SERVICE_STATUS*; 115 116 struct ENUM_SERVICE_STATUSA { 117 LPSTR lpServiceName; 118 LPSTR lpDisplayName; 119 SERVICE_STATUS ServiceStatus; 120 } 121 alias LPENUM_SERVICE_STATUSA = ENUM_SERVICE_STATUSA*; 122 123 struct ENUM_SERVICE_STATUSW { 124 LPWSTR lpServiceName; 125 LPWSTR lpDisplayName; 126 SERVICE_STATUS ServiceStatus; 127 } 128 alias LPENUM_SERVICE_STATUSW = ENUM_SERVICE_STATUSW*; 129 130 struct QUERY_SERVICE_CONFIGA { 131 DWORD dwServiceType; 132 DWORD dwStartType; 133 DWORD dwErrorControl; 134 LPSTR lpBinaryPathName; 135 LPSTR lpLoadOrderGroup; 136 DWORD dwTagId; 137 LPSTR lpDependencies; 138 LPSTR lpServiceStartName; 139 LPSTR lpDisplayName; 140 } 141 alias LPQUERY_SERVICE_CONFIGA = QUERY_SERVICE_CONFIGA*; 142 143 struct QUERY_SERVICE_CONFIGW { 144 DWORD dwServiceType; 145 DWORD dwStartType; 146 DWORD dwErrorControl; 147 LPWSTR lpBinaryPathName; 148 LPWSTR lpLoadOrderGroup; 149 DWORD dwTagId; 150 LPWSTR lpDependencies; 151 LPWSTR lpServiceStartName; 152 LPWSTR lpDisplayName; 153 } 154 alias LPQUERY_SERVICE_CONFIGW = QUERY_SERVICE_CONFIGW*; 155 156 struct QUERY_SERVICE_LOCK_STATUSA { 157 DWORD fIsLocked; 158 LPSTR lpLockOwner; 159 DWORD dwLockDuration; 160 } 161 alias LPQUERY_SERVICE_LOCK_STATUSA = QUERY_SERVICE_LOCK_STATUSA*; 162 163 struct QUERY_SERVICE_LOCK_STATUSW { 164 DWORD fIsLocked; 165 LPWSTR lpLockOwner; 166 DWORD dwLockDuration; 167 } 168 alias LPQUERY_SERVICE_LOCK_STATUSW = QUERY_SERVICE_LOCK_STATUSW*; 169 170 extern (Windows) { 171 alias LPSERVICE_MAIN_FUNCTIONA = void function(DWORD, LPSTR*); 172 alias LPSERVICE_MAIN_FUNCTIONW = void function(DWORD, LPWSTR*); 173 } 174 175 struct SERVICE_TABLE_ENTRYA { 176 LPSTR lpServiceName; 177 LPSERVICE_MAIN_FUNCTIONA lpServiceProc; 178 } 179 alias LPSERVICE_TABLE_ENTRYA = SERVICE_TABLE_ENTRYA*; 180 181 struct SERVICE_TABLE_ENTRYW { 182 LPWSTR lpServiceName; 183 LPSERVICE_MAIN_FUNCTIONW lpServiceProc; 184 } 185 alias LPSERVICE_TABLE_ENTRYW = SERVICE_TABLE_ENTRYW*; 186 187 alias SC_HANDLE = HANDLE; 188 alias LPSC_HANDLE = SC_HANDLE*; 189 alias SC_LOCK = void*; 190 alias SERVICE_STATUS_HANDLE = HANDLE; 191 192 extern (Windows) { 193 alias LPHANDLER_FUNCTION = void function(DWORD); 194 alias LPHANDLER_FUNCTION_EX = DWORD function(DWORD, DWORD, LPVOID, LPVOID); 195 } 196 197 static if (_WIN32_WINNT >= 0x500) { 198 struct SERVICE_STATUS_PROCESS { 199 DWORD dwServiceType; 200 DWORD dwCurrentState; 201 DWORD dwControlsAccepted; 202 DWORD dwWin32ExitCode; 203 DWORD dwServiceSpecificExitCode; 204 DWORD dwCheckPoint; 205 DWORD dwWaitHint; 206 DWORD dwProcessId; 207 DWORD dwServiceFlags; 208 } 209 alias LPSERVICE_STATUS_PROCESS = SERVICE_STATUS_PROCESS*; 210 211 enum SC_STATUS_TYPE { 212 SC_STATUS_PROCESS_INFO = 0 213 } 214 215 enum SC_ENUM_TYPE { 216 SC_ENUM_PROCESS_INFO = 0 217 } 218 219 struct ENUM_SERVICE_STATUS_PROCESSA { 220 LPSTR lpServiceName; 221 LPSTR lpDisplayName; 222 SERVICE_STATUS_PROCESS ServiceStatusProcess; 223 } 224 alias LPENUM_SERVICE_STATUS_PROCESSA = ENUM_SERVICE_STATUS_PROCESSA*; 225 226 struct ENUM_SERVICE_STATUS_PROCESSW { 227 LPWSTR lpServiceName; 228 LPWSTR lpDisplayName; 229 SERVICE_STATUS_PROCESS ServiceStatusProcess; 230 } 231 alias LPENUM_SERVICE_STATUS_PROCESSW = ENUM_SERVICE_STATUS_PROCESSW*; 232 233 struct SERVICE_DESCRIPTIONA { 234 LPSTR lpDescription; 235 } 236 alias LPSERVICE_DESCRIPTIONA = SERVICE_DESCRIPTIONA*; 237 238 struct SERVICE_DESCRIPTIONW { 239 LPWSTR lpDescription; 240 } 241 alias LPSERVICE_DESCRIPTIONW = SERVICE_DESCRIPTIONW*; 242 243 enum SC_ACTION_TYPE { 244 SC_ACTION_NONE, 245 SC_ACTION_RESTART, 246 SC_ACTION_REBOOT, 247 SC_ACTION_RUN_COMMAND 248 } 249 250 struct SC_ACTION { 251 SC_ACTION_TYPE Type; 252 DWORD Delay; 253 } 254 alias LPSC_ACTION = SC_ACTION*; 255 256 struct SERVICE_FAILURE_ACTIONSA { 257 DWORD dwResetPeriod; 258 LPSTR lpRebootMsg; 259 LPSTR lpCommand; 260 DWORD cActions; 261 SC_ACTION* lpsaActions; 262 } 263 alias LPSERVICE_FAILURE_ACTIONSA = SERVICE_FAILURE_ACTIONSA*; 264 265 struct SERVICE_FAILURE_ACTIONSW { 266 DWORD dwResetPeriod; 267 LPWSTR lpRebootMsg; 268 LPWSTR lpCommand; 269 DWORD cActions; 270 SC_ACTION* lpsaActions; 271 } 272 alias LPSERVICE_FAILURE_ACTIONSW = SERVICE_FAILURE_ACTIONSW*; 273 } 274 275 extern (Windows) nothrow @nogc { 276 BOOL ChangeServiceConfigA(SC_HANDLE, DWORD, DWORD, DWORD, LPCSTR, 277 LPCSTR, LPDWORD, LPCSTR, LPCSTR, LPCSTR, LPCSTR); 278 BOOL ChangeServiceConfigW(SC_HANDLE, DWORD, DWORD, DWORD, LPCWSTR, 279 LPCWSTR, LPDWORD, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR); 280 BOOL CloseServiceHandle(SC_HANDLE); 281 BOOL ControlService(SC_HANDLE, DWORD, LPSERVICE_STATUS); 282 SC_HANDLE CreateServiceA(SC_HANDLE, LPCSTR, LPCSTR, DWORD, DWORD, 283 DWORD, DWORD, LPCSTR, LPCSTR, PDWORD, LPCSTR, LPCSTR, LPCSTR); 284 SC_HANDLE CreateServiceW(SC_HANDLE, LPCWSTR, LPCWSTR, DWORD, DWORD, 285 DWORD, DWORD, LPCWSTR, LPCWSTR, PDWORD, LPCWSTR, LPCWSTR, LPCWSTR); 286 BOOL DeleteService(SC_HANDLE); 287 BOOL EnumDependentServicesA(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUSA, 288 DWORD, PDWORD, PDWORD); 289 BOOL EnumDependentServicesW(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUSW, 290 DWORD, PDWORD, PDWORD); 291 BOOL EnumServicesStatusA(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUSA, 292 DWORD, PDWORD, PDWORD, PDWORD); 293 BOOL EnumServicesStatusW(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUSW, 294 DWORD, PDWORD, PDWORD, PDWORD); 295 BOOL GetServiceDisplayNameA(SC_HANDLE, LPCSTR, LPSTR, PDWORD); 296 BOOL GetServiceDisplayNameW(SC_HANDLE, LPCWSTR, LPWSTR, PDWORD); 297 BOOL GetServiceKeyNameA(SC_HANDLE, LPCSTR, LPSTR, PDWORD); 298 BOOL GetServiceKeyNameW(SC_HANDLE, LPCWSTR, LPWSTR, PDWORD); 299 SC_LOCK LockServiceDatabase(SC_HANDLE); 300 BOOL NotifyBootConfigStatus(BOOL); 301 SC_HANDLE OpenSCManagerA(LPCSTR, LPCSTR, DWORD); 302 SC_HANDLE OpenSCManagerW(LPCWSTR, LPCWSTR, DWORD); 303 SC_HANDLE OpenServiceA(SC_HANDLE, LPCSTR, DWORD); 304 SC_HANDLE OpenServiceW(SC_HANDLE, LPCWSTR, DWORD); 305 BOOL QueryServiceConfigA(SC_HANDLE, LPQUERY_SERVICE_CONFIGA, DWORD, 306 PDWORD); 307 BOOL QueryServiceConfigW(SC_HANDLE, LPQUERY_SERVICE_CONFIGW, DWORD, 308 PDWORD); 309 BOOL QueryServiceLockStatusA(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUSA, 310 DWORD, PDWORD); 311 BOOL QueryServiceLockStatusW(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUSW, 312 DWORD, PDWORD); 313 BOOL QueryServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION, 314 PSECURITY_DESCRIPTOR, DWORD, LPDWORD); 315 BOOL QueryServiceStatus(SC_HANDLE, LPSERVICE_STATUS); 316 SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerA(LPCSTR, 317 LPHANDLER_FUNCTION); 318 SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerW(LPCWSTR, 319 LPHANDLER_FUNCTION); 320 BOOL SetServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION, 321 PSECURITY_DESCRIPTOR); 322 BOOL SetServiceStatus(SERVICE_STATUS_HANDLE, LPSERVICE_STATUS); 323 BOOL StartServiceA(SC_HANDLE, DWORD, LPCSTR*); 324 BOOL StartServiceW(SC_HANDLE, DWORD, LPCWSTR*); 325 BOOL StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRYA); 326 BOOL StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRYW); 327 BOOL UnlockServiceDatabase(SC_LOCK); 328 329 static if (_WIN32_WINNT >= 0x500) { 330 BOOL EnumServicesStatusExA(SC_HANDLE, SC_ENUM_TYPE, DWORD, DWORD, LPBYTE, 331 DWORD, LPDWORD, LPDWORD, LPDWORD, LPCSTR); 332 BOOL EnumServicesStatusExW(SC_HANDLE, SC_ENUM_TYPE, DWORD, DWORD, LPBYTE, 333 DWORD, LPDWORD, LPDWORD, LPDWORD, LPCWSTR); 334 BOOL QueryServiceConfig2A(SC_HANDLE, DWORD, LPBYTE, DWORD, LPDWORD); 335 BOOL QueryServiceConfig2W(SC_HANDLE, DWORD, LPBYTE, DWORD, LPDWORD); 336 BOOL QueryServiceStatusEx(SC_HANDLE, SC_STATUS_TYPE, LPBYTE, DWORD, 337 LPDWORD); 338 SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerExA(LPCSTR, 339 LPHANDLER_FUNCTION_EX, LPVOID); 340 SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerExW(LPCWSTR, 341 LPHANDLER_FUNCTION_EX, LPVOID); 342 } 343 344 static if (_WIN32_WINNT >= 0x501) { 345 BOOL ChangeServiceConfig2A(SC_HANDLE, DWORD, LPVOID); 346 BOOL ChangeServiceConfig2W(SC_HANDLE, DWORD, LPVOID); 347 } 348 } 349 350 version (Unicode) { 351 alias ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSW; 352 alias QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGW; 353 alias QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSW; 354 alias LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONW; 355 alias SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYW; 356 alias ChangeServiceConfig = ChangeServiceConfigW; 357 alias CreateService = CreateServiceW; 358 alias EnumDependentServices = EnumDependentServicesW; 359 alias EnumServicesStatus = EnumServicesStatusW; 360 alias GetServiceDisplayName = GetServiceDisplayNameW; 361 alias GetServiceKeyName = GetServiceKeyNameW; 362 alias OpenSCManager = OpenSCManagerW; 363 alias OpenService = OpenServiceW; 364 alias QueryServiceConfig = QueryServiceConfigW; 365 alias QueryServiceLockStatus = QueryServiceLockStatusW; 366 alias RegisterServiceCtrlHandler = RegisterServiceCtrlHandlerW; 367 alias StartService = StartServiceW; 368 alias StartServiceCtrlDispatcher = StartServiceCtrlDispatcherW; 369 370 static if (_WIN32_WINNT >= 0x500) { 371 alias ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSW; 372 alias SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONW; 373 alias SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSW; 374 alias EnumServicesStatusEx = EnumServicesStatusExW; 375 alias QueryServiceConfig2 = QueryServiceConfig2W; 376 alias RegisterServiceCtrlHandlerEx = RegisterServiceCtrlHandlerExW; 377 } 378 379 static if (_WIN32_WINNT >= 0x501) { 380 alias ChangeServiceConfig2 = ChangeServiceConfig2W; 381 } 382 383 } else { 384 alias ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSA; 385 alias QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGA; 386 alias QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSA; 387 alias LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONA; 388 alias SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYA; 389 alias ChangeServiceConfig = ChangeServiceConfigA; 390 alias CreateService = CreateServiceA; 391 alias EnumDependentServices = EnumDependentServicesA; 392 alias EnumServicesStatus = EnumServicesStatusA; 393 alias GetServiceDisplayName = GetServiceDisplayNameA; 394 alias GetServiceKeyName = GetServiceKeyNameA; 395 alias OpenSCManager = OpenSCManagerA; 396 alias OpenService = OpenServiceA; 397 alias QueryServiceConfig = QueryServiceConfigA; 398 alias QueryServiceLockStatus = QueryServiceLockStatusA; 399 alias RegisterServiceCtrlHandler = RegisterServiceCtrlHandlerA; 400 alias StartService = StartServiceA; 401 alias StartServiceCtrlDispatcher = StartServiceCtrlDispatcherA; 402 403 static if (_WIN32_WINNT >= 0x500) { 404 alias ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSA; 405 alias SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONA; 406 alias SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSA; 407 alias EnumServicesStatusEx = EnumServicesStatusExA; 408 alias QueryServiceConfig2 = QueryServiceConfig2A; 409 alias RegisterServiceCtrlHandlerEx = RegisterServiceCtrlHandlerExA; 410 } 411 412 static if (_WIN32_WINNT >= 0x501) { 413 alias ChangeServiceConfig2 = ChangeServiceConfig2A; 414 } 415 416 } 417 418 alias LPENUM_SERVICE_STATUS = ENUM_SERVICE_STATUS*; 419 alias LPQUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIG*; 420 alias LPQUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUS*; 421 alias LPSERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRY*; 422 423 static if (_WIN32_WINNT >= 0x500) { 424 alias LPENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESS*; 425 alias LPSERVICE_DESCRIPTION = SERVICE_DESCRIPTION*; 426 alias LPSERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONS*; 427 }