1 // Licensed under the Apache License, Version 2.0 2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license 3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. 4 // All files in the project carrying such notice may not be copied, modified, or distributed 5 // except according to those terms. 6 //! Header file for the Service Control Manager 7 use shared::minwindef::{BOOL, DWORD, LPBYTE, LPDWORD, LPVOID}; 8 use um::winnt::{ 9 HANDLE, LPCSTR, LPCWSTR, LPSTR, LPWSTR, PSECURITY_DESCRIPTOR, PVOID, 10 SECURITY_INFORMATION, STANDARD_RIGHTS_REQUIRED 11 }; 12 pub const SERVICE_NO_CHANGE: DWORD = 0xffffffff; 13 pub const SERVICE_ACTIVE: DWORD = 0x00000001; 14 pub const SERVICE_INACTIVE: DWORD = 0x00000002; 15 pub const SERVICE_STATE_ALL: DWORD = SERVICE_ACTIVE | SERVICE_INACTIVE; 16 pub const SERVICE_CONTROL_STOP: DWORD = 0x00000001; 17 pub const SERVICE_CONTROL_PAUSE: DWORD = 0x00000002; 18 pub const SERVICE_CONTROL_CONTINUE: DWORD = 0x00000003; 19 pub const SERVICE_CONTROL_INTERROGATE: DWORD = 0x00000004; 20 pub const SERVICE_CONTROL_SHUTDOWN: DWORD = 0x00000005; 21 pub const SERVICE_CONTROL_PARAMCHANGE: DWORD = 0x00000006; 22 pub const SERVICE_CONTROL_NETBINDADD: DWORD = 0x00000007; 23 pub const SERVICE_CONTROL_NETBINDREMOVE: DWORD = 0x00000008; 24 pub const SERVICE_CONTROL_NETBINDENABLE: DWORD = 0x00000009; 25 pub const SERVICE_CONTROL_NETBINDDISABLE: DWORD = 0x0000000A; 26 pub const SERVICE_CONTROL_DEVICEEVENT: DWORD = 0x0000000B; 27 pub const SERVICE_CONTROL_HARDWAREPROFILECHANGE: DWORD = 0x0000000C; 28 pub const SERVICE_CONTROL_POWEREVENT: DWORD = 0x0000000D; 29 pub const SERVICE_CONTROL_SESSIONCHANGE: DWORD = 0x0000000E; 30 pub const SERVICE_CONTROL_PRESHUTDOWN: DWORD = 0x0000000F; 31 pub const SERVICE_CONTROL_TIMECHANGE: DWORD = 0x00000010; 32 pub const SERVICE_CONTROL_TRIGGEREVENT: DWORD = 0x00000020; 33 pub const SERVICE_STOPPED: DWORD = 0x00000001; 34 pub const SERVICE_START_PENDING: DWORD = 0x00000002; 35 pub const SERVICE_STOP_PENDING: DWORD = 0x00000003; 36 pub const SERVICE_RUNNING: DWORD = 0x00000004; 37 pub const SERVICE_CONTINUE_PENDING: DWORD = 0x00000005; 38 pub const SERVICE_PAUSE_PENDING: DWORD = 0x00000006; 39 pub const SERVICE_PAUSED: DWORD = 0x00000007; 40 pub const SERVICE_ACCEPT_STOP: DWORD = 0x00000001; 41 pub const SERVICE_ACCEPT_PAUSE_CONTINUE: DWORD = 0x00000002; 42 pub const SERVICE_ACCEPT_SHUTDOWN: DWORD = 0x00000004; 43 pub const SERVICE_ACCEPT_PARAMCHANGE: DWORD = 0x00000008; 44 pub const SERVICE_ACCEPT_NETBINDCHANGE: DWORD = 0x00000010; 45 pub const SERVICE_ACCEPT_HARDWAREPROFILECHANGE: DWORD = 0x00000020; 46 pub const SERVICE_ACCEPT_POWEREVENT: DWORD = 0x00000040; 47 pub const SERVICE_ACCEPT_SESSIONCHANGE: DWORD = 0x00000080; 48 pub const SERVICE_ACCEPT_PRESHUTDOWN: DWORD = 0x00000100; 49 pub const SERVICE_ACCEPT_TIMECHANGE: DWORD = 0x00000200; 50 pub const SERVICE_ACCEPT_TRIGGEREVENT: DWORD = 0x00000400; 51 // SERVICE_ACCEPT_USER_LOGOFF 52 pub const SC_MANAGER_CONNECT: DWORD = 0x0001; 53 pub const SC_MANAGER_CREATE_SERVICE: DWORD = 0x0002; 54 pub const SC_MANAGER_ENUMERATE_SERVICE: DWORD = 0x0004; 55 pub const SC_MANAGER_LOCK: DWORD = 0x0008; 56 pub const SC_MANAGER_QUERY_LOCK_STATUS: DWORD = 0x0010; 57 pub const SC_MANAGER_MODIFY_BOOT_CONFIG: DWORD = 0x0020; 58 pub const SC_MANAGER_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SC_MANAGER_CONNECT 59 | SC_MANAGER_CREATE_SERVICE | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_LOCK 60 | SC_MANAGER_QUERY_LOCK_STATUS | SC_MANAGER_MODIFY_BOOT_CONFIG; 61 pub const SERVICE_QUERY_CONFIG: DWORD = 0x0001; 62 pub const SERVICE_CHANGE_CONFIG: DWORD = 0x0002; 63 pub const SERVICE_QUERY_STATUS: DWORD = 0x0004; 64 pub const SERVICE_ENUMERATE_DEPENDENTS: DWORD = 0x0008; 65 pub const SERVICE_START: DWORD = 0x0010; 66 pub const SERVICE_STOP: DWORD = 0x0020; 67 pub const SERVICE_PAUSE_CONTINUE: DWORD = 0x0040; 68 pub const SERVICE_INTERROGATE: DWORD = 0x0080; 69 pub const SERVICE_USER_DEFINED_CONTROL: DWORD = 0x0100; 70 pub const SERVICE_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SERVICE_QUERY_CONFIG 71 | SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_START 72 | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_INTERROGATE | SERVICE_USER_DEFINED_CONTROL; 73 pub const SERVICE_RUNS_IN_SYSTEM_PROCESS: DWORD = 0x00000001; 74 pub const SERVICE_CONFIG_DESCRIPTION: DWORD = 1; 75 pub const SERVICE_CONFIG_FAILURE_ACTIONS: DWORD = 2; 76 pub const SERVICE_CONFIG_DELAYED_AUTO_START_INFO: DWORD = 3; 77 pub const SERVICE_CONFIG_FAILURE_ACTIONS_FLAG: DWORD = 4; 78 pub const SERVICE_CONFIG_SERVICE_SID_INFO: DWORD = 5; 79 pub const SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO: DWORD = 6; 80 pub const SERVICE_CONFIG_PRESHUTDOWN_INFO: DWORD = 7; 81 pub const SERVICE_CONFIG_TRIGGER_INFO: DWORD = 8; 82 pub const SERVICE_CONFIG_PREFERRED_NODE: DWORD = 9; 83 pub const SERVICE_CONFIG_LAUNCH_PROTECTED: DWORD = 12; 84 pub const SERVICE_NOTIFY_STATUS_CHANGE_1: DWORD = 1; 85 pub const SERVICE_NOTIFY_STATUS_CHANGE_2: DWORD = 2; 86 pub const SERVICE_NOTIFY_STATUS_CHANGE: DWORD = SERVICE_NOTIFY_STATUS_CHANGE_2; 87 pub const SERVICE_NOTIFY_STOPPED: DWORD = 0x00000001; 88 pub const SERVICE_NOTIFY_START_PENDING: DWORD = 0x00000002; 89 pub const SERVICE_NOTIFY_STOP_PENDING: DWORD = 0x00000004; 90 pub const SERVICE_NOTIFY_RUNNING: DWORD = 0x00000008; 91 pub const SERVICE_NOTIFY_CONTINUE_PENDING: DWORD = 0x00000010; 92 pub const SERVICE_NOTIFY_PAUSE_PENDING: DWORD = 0x00000020; 93 pub const SERVICE_NOTIFY_PAUSED: DWORD = 0x00000040; 94 pub const SERVICE_NOTIFY_CREATED: DWORD = 0x00000080; 95 pub const SERVICE_NOTIFY_DELETED: DWORD = 0x00000100; 96 pub const SERVICE_NOTIFY_DELETE_PENDING: DWORD = 0x00000200; 97 pub const SERVICE_STOP_REASON_FLAG_MIN: DWORD = 0x00000000; 98 pub const SERVICE_STOP_REASON_FLAG_UNPLANNED: DWORD = 0x10000000; 99 pub const SERVICE_STOP_REASON_FLAG_CUSTOM: DWORD = 0x20000000; 100 pub const SERVICE_STOP_REASON_FLAG_PLANNED: DWORD = 0x40000000; 101 pub const SERVICE_STOP_REASON_FLAG_MAX: DWORD = 0x80000000; 102 pub const SERVICE_STOP_REASON_MAJOR_MIN: DWORD = 0x00000000; 103 pub const SERVICE_STOP_REASON_MAJOR_OTHER: DWORD = 0x00010000; 104 pub const SERVICE_STOP_REASON_MAJOR_HARDWARE: DWORD = 0x00020000; 105 pub const SERVICE_STOP_REASON_MAJOR_OPERATINGSYSTEM: DWORD = 0x00030000; 106 pub const SERVICE_STOP_REASON_MAJOR_SOFTWARE: DWORD = 0x00040000; 107 pub const SERVICE_STOP_REASON_MAJOR_APPLICATION: DWORD = 0x00050000; 108 pub const SERVICE_STOP_REASON_MAJOR_NONE: DWORD = 0x00060000; 109 pub const SERVICE_STOP_REASON_MAJOR_MAX: DWORD = 0x00070000; 110 pub const SERVICE_STOP_REASON_MAJOR_MIN_CUSTOM: DWORD = 0x00400000; 111 pub const SERVICE_STOP_REASON_MAJOR_MAX_CUSTOM: DWORD = 0x00ff0000; 112 pub const SERVICE_STOP_REASON_MINOR_MIN: DWORD = 0x00000000; 113 pub const SERVICE_STOP_REASON_MINOR_OTHER: DWORD = 0x00000001; 114 pub const SERVICE_STOP_REASON_MINOR_MAINTENANCE: DWORD = 0x00000002; 115 pub const SERVICE_STOP_REASON_MINOR_INSTALLATION: DWORD = 0x00000003; 116 pub const SERVICE_STOP_REASON_MINOR_UPGRADE: DWORD = 0x00000004; 117 pub const SERVICE_STOP_REASON_MINOR_RECONFIG: DWORD = 0x00000005; 118 pub const SERVICE_STOP_REASON_MINOR_HUNG: DWORD = 0x00000006; 119 pub const SERVICE_STOP_REASON_MINOR_UNSTABLE: DWORD = 0x00000007; 120 pub const SERVICE_STOP_REASON_MINOR_DISK: DWORD = 0x00000008; 121 pub const SERVICE_STOP_REASON_MINOR_NETWORKCARD: DWORD = 0x00000009; 122 pub const SERVICE_STOP_REASON_MINOR_ENVIRONMENT: DWORD = 0x0000000a; 123 pub const SERVICE_STOP_REASON_MINOR_HARDWARE_DRIVER: DWORD = 0x0000000b; 124 pub const SERVICE_STOP_REASON_MINOR_OTHERDRIVER: DWORD = 0x0000000c; 125 pub const SERVICE_STOP_REASON_MINOR_SERVICEPACK: DWORD = 0x0000000d; 126 pub const SERVICE_STOP_REASON_MINOR_SOFTWARE_UPDATE: DWORD = 0x0000000e; 127 pub const SERVICE_STOP_REASON_MINOR_SECURITYFIX: DWORD = 0x0000000f; 128 pub const SERVICE_STOP_REASON_MINOR_SECURITY: DWORD = 0x00000010; 129 pub const SERVICE_STOP_REASON_MINOR_NETWORK_CONNECTIVITY: DWORD = 0x00000011; 130 pub const SERVICE_STOP_REASON_MINOR_WMI: DWORD = 0x00000012; 131 pub const SERVICE_STOP_REASON_MINOR_SERVICEPACK_UNINSTALL: DWORD = 0x00000013; 132 pub const SERVICE_STOP_REASON_MINOR_SOFTWARE_UPDATE_UNINSTALL: DWORD = 0x00000014; 133 pub const SERVICE_STOP_REASON_MINOR_SECURITYFIX_UNINSTALL: DWORD = 0x00000015; 134 pub const SERVICE_STOP_REASON_MINOR_MMC: DWORD = 0x00000016; 135 pub const SERVICE_STOP_REASON_MINOR_NONE: DWORD = 0x00000017; 136 pub const SERVICE_STOP_REASON_MINOR_MAX: DWORD = 0x00000018; 137 pub const SERVICE_STOP_REASON_MINOR_MIN_CUSTOM: DWORD = 0x00000100; 138 pub const SERVICE_STOP_REASON_MINOR_MAX_CUSTOM: DWORD = 0x0000FFFF; 139 pub const SERVICE_CONTROL_STATUS_REASON_INFO: DWORD = 1; 140 pub const SERVICE_SID_TYPE_NONE: DWORD = 0x00000000; 141 pub const SERVICE_SID_TYPE_UNRESTRICTED: DWORD = 0x00000001; 142 pub const SERVICE_SID_TYPE_RESTRICTED: DWORD = 0x00000002 | SERVICE_SID_TYPE_UNRESTRICTED; 143 pub const SERVICE_TRIGGER_TYPE_DEVICE_INTERFACE_ARRIVAL: DWORD = 1; 144 pub const SERVICE_TRIGGER_TYPE_IP_ADDRESS_AVAILABILITY: DWORD = 2; 145 pub const SERVICE_TRIGGER_TYPE_DOMAIN_JOIN: DWORD = 3; 146 pub const SERVICE_TRIGGER_TYPE_FIREWALL_PORT_EVENT: DWORD = 4; 147 pub const SERVICE_TRIGGER_TYPE_GROUP_POLICY: DWORD = 5; 148 pub const SERVICE_TRIGGER_TYPE_NETWORK_ENDPOINT: DWORD = 6; 149 pub const SERVICE_TRIGGER_TYPE_CUSTOM_SYSTEM_STATE_CHANGE: DWORD = 7; 150 pub const SERVICE_TRIGGER_TYPE_CUSTOM: DWORD = 20; 151 pub const SERVICE_TRIGGER_DATA_TYPE_BINARY: DWORD = 1; 152 pub const SERVICE_TRIGGER_DATA_TYPE_STRING: DWORD = 2; 153 pub const SERVICE_TRIGGER_DATA_TYPE_LEVEL: DWORD = 3; 154 pub const SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ANY: DWORD = 4; 155 pub const SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ALL: DWORD = 5; 156 pub const SERVICE_START_REASON_DEMAND: DWORD = 0x00000001; 157 pub const SERVICE_START_REASON_AUTO: DWORD = 0x00000002; 158 pub const SERVICE_START_REASON_TRIGGER: DWORD = 0x00000004; 159 pub const SERVICE_START_REASON_RESTART_ON_FAILURE: DWORD = 0x00000008; 160 pub const SERVICE_START_REASON_DELAYEDAUTO: DWORD = 0x00000010; 161 pub const SERVICE_DYNAMIC_INFORMATION_LEVEL_START_REASON: DWORD = 1; 162 pub const SERVICE_LAUNCH_PROTECTED_NONE: DWORD = 0; 163 pub const SERVICE_LAUNCH_PROTECTED_WINDOWS: DWORD = 1; 164 pub const SERVICE_LAUNCH_PROTECTED_WINDOWS_LIGHT: DWORD = 2; 165 pub const SERVICE_LAUNCH_PROTECTED_ANTIMALWARE_LIGHT: DWORD = 3; 166 DEFINE_GUID!{NETWORK_MANAGER_FIRST_IP_ADDRESS_ARRIVAL_GUID, 167 0x4f27f2de, 0x14e2, 0x430b, 0xa5, 0x49, 0x7c, 0xd4, 0x8c, 0xbc, 0x82, 0x45} 168 DEFINE_GUID!{NETWORK_MANAGER_LAST_IP_ADDRESS_REMOVAL_GUID, 169 0xcc4ba62a, 0x162e, 0x4648, 0x84, 0x7a, 0xb6, 0xbd, 0xf9, 0x93, 0xe3, 0x35} 170 DEFINE_GUID!{DOMAIN_JOIN_GUID, 171 0x1ce20aba, 0x9851, 0x4421, 0x94, 0x30, 0x1d, 0xde, 0xb7, 0x66, 0xe8, 0x09} 172 DEFINE_GUID!{DOMAIN_LEAVE_GUID, 173 0xddaf516e, 0x58c2, 0x4866, 0x95, 0x74, 0xc3, 0xb6, 0x15, 0xd4, 0x2e, 0xa1} 174 DEFINE_GUID!{FIREWALL_PORT_OPEN_GUID, 175 0xb7569e07, 0x8421, 0x4ee0, 0xad, 0x10, 0x86, 0x91, 0x5a, 0xfd, 0xad, 0x09} 176 DEFINE_GUID!{FIREWALL_PORT_CLOSE_GUID, 177 0xa144ed38, 0x8e12, 0x4de4, 0x9d, 0x96, 0xe6, 0x47, 0x40, 0xb1, 0xa5, 0x24} 178 DEFINE_GUID!{MACHINE_POLICY_PRESENT_GUID, 179 0x659fcae6, 0x5bdb, 0x4da9, 0xb1, 0xff, 0xca, 0x2a, 0x17, 0x8d, 0x46, 0xe0} 180 DEFINE_GUID!{USER_POLICY_PRESENT_GUID, 181 0x54fb46c8, 0xf089, 0x464c, 0xb1, 0xfd, 0x59, 0xd1, 0xb6, 0x2c, 0x3b, 0x50} 182 DEFINE_GUID!{RPC_INTERFACE_EVENT_GUID, 183 0xbc90d167, 0x9470, 0x4139, 0xa9, 0xba, 0xbe, 0x0b, 0xbb, 0xf5, 0xb7, 0x4d} 184 DEFINE_GUID!{NAMED_PIPE_EVENT_GUID, 185 0x1f81d131, 0x3fac, 0x4537, 0x9e, 0x0c, 0x7e, 0x7b, 0x0c, 0x2f, 0x4b, 0x55} 186 DEFINE_GUID!{CUSTOM_SYSTEM_STATE_CHANGE_EVENT_GUID, 187 0x2d7a2816, 0x0c5e, 0x45fc, 0x9c, 0xe7, 0x57, 0x0e, 0x5e, 0xcd, 0xe9, 0xc9} 188 ENUM!{enum SC_ACTION_TYPE { 189 SC_ACTION_NONE = 0, 190 SC_ACTION_RESTART = 1, 191 SC_ACTION_REBOOT = 2, 192 SC_ACTION_RUN_COMMAND = 3, 193 }} 194 STRUCT!{struct SC_ACTION { 195 Type: SC_ACTION_TYPE, 196 Delay: DWORD, 197 }} 198 pub type LPSC_ACTION = *mut SC_ACTION; 199 STRUCT!{struct SERVICE_FAILURE_ACTIONSW { 200 dwResetPeriod: DWORD, 201 lpRebootMsg: LPWSTR, 202 lpCommand: LPWSTR, 203 cActions: DWORD, 204 lpsaActions: LPSC_ACTION, 205 }} 206 pub type LPSERVICE_FAILURE_ACTIONSW = *mut SERVICE_FAILURE_ACTIONSW; 207 STRUCT!{struct SERVICE_FAILURE_ACTIONS_FLAG { 208 fFailureActionsOnNonCrashFailures: BOOL, 209 }} 210 DECLARE_HANDLE!{SC_HANDLE, SC_HANDLE__} 211 pub type LPSC_HANDLE = *mut SC_HANDLE; 212 DECLARE_HANDLE!{SERVICE_STATUS_HANDLE, SERVICE_STATUS_HANDLE__} 213 ENUM!{enum SC_STATUS_TYPE { 214 SC_STATUS_PROCESS_INFO = 0, 215 }} 216 ENUM!{enum SC_ENUM_TYPE { 217 SC_ENUM_PROCESS_INFO = 0, 218 }} 219 STRUCT!{struct SERVICE_STATUS { 220 dwServiceType: DWORD, 221 dwCurrentState: DWORD, 222 dwControlsAccepted: DWORD, 223 dwWin32ExitCode: DWORD, 224 dwServiceSpecificExitCode: DWORD, 225 dwCheckPoint: DWORD, 226 dwWaitHint: DWORD, 227 }} 228 pub type LPSERVICE_STATUS = *mut SERVICE_STATUS; 229 STRUCT!{struct SERVICE_STATUS_PROCESS { 230 dwServiceType: DWORD, 231 dwCurrentState: DWORD, 232 dwControlsAccepted: DWORD, 233 dwWin32ExitCode: DWORD, 234 dwServiceSpecificExitCode: DWORD, 235 dwCheckPoint: DWORD, 236 dwWaitHint: DWORD, 237 dwProcessId: DWORD, 238 dwServiceFlags: DWORD, 239 }} 240 pub type LPSERVICE_STATUS_PROCESS = *mut SERVICE_STATUS_PROCESS; 241 STRUCT!{struct ENUM_SERVICE_STATUSA { 242 lpServiceName: LPSTR, 243 lpDisplayName: LPSTR, 244 ServiceStatus: SERVICE_STATUS, 245 }} 246 pub type LPENUM_SERVICE_STATUSA = *mut ENUM_SERVICE_STATUSA; 247 STRUCT!{struct ENUM_SERVICE_STATUSW { 248 lpServiceName: LPWSTR, 249 lpDisplayName: LPWSTR, 250 ServiceStatus: SERVICE_STATUS, 251 }} 252 pub type LPENUM_SERVICE_STATUSW = *mut ENUM_SERVICE_STATUSW; 253 STRUCT!{struct ENUM_SERVICE_STATUS_PROCESSA { 254 lpServiceName: LPSTR, 255 lpDisplayName: LPSTR, 256 ServiceStatusProcess: SERVICE_STATUS_PROCESS, 257 }} 258 pub type LPENUM_SERVICE_STATUS_PROCESSA = *mut ENUM_SERVICE_STATUS_PROCESSA; 259 STRUCT!{struct ENUM_SERVICE_STATUS_PROCESSW { 260 lpServiceName: LPWSTR, 261 lpDisplayName: LPWSTR, 262 ServiceStatusProcess: SERVICE_STATUS_PROCESS, 263 }} 264 pub type LPENUM_SERVICE_STATUS_PROCESSW = *mut ENUM_SERVICE_STATUS_PROCESSW; 265 pub type SC_LOCK = LPVOID; 266 STRUCT!{struct QUERY_SERVICE_LOCK_STATUSA { 267 fIsLocked: DWORD, 268 lpLockOwner: LPSTR, 269 dwLockDuration: DWORD, 270 }} 271 pub type LPQUERY_SERVICE_LOCK_STATUSA = *mut QUERY_SERVICE_LOCK_STATUSA; 272 STRUCT!{struct QUERY_SERVICE_LOCK_STATUSW { 273 fIsLocked: DWORD, 274 lpLockOwner: LPWSTR, 275 dwLockDuration: DWORD, 276 }} 277 pub type LPQUERY_SERVICE_LOCK_STATUSW = *mut QUERY_SERVICE_LOCK_STATUSW; 278 STRUCT!{struct QUERY_SERVICE_CONFIGA { 279 dwServiceType: DWORD, 280 dwStartType: DWORD, 281 dwErrorControl: DWORD, 282 lpBinaryPathName: LPSTR, 283 lpLoadOrderGroup: LPSTR, 284 dwTagId: DWORD, 285 lpDependencies: LPSTR, 286 lpServiceStartName: LPSTR, 287 lpDisplayName: LPSTR, 288 }} 289 pub type LPQUERY_SERVICE_CONFIGA = *mut QUERY_SERVICE_CONFIGA; 290 STRUCT!{struct QUERY_SERVICE_CONFIGW { 291 dwServiceType: DWORD, 292 dwStartType: DWORD, 293 dwErrorControl: DWORD, 294 lpBinaryPathName: LPWSTR, 295 lpLoadOrderGroup: LPWSTR, 296 dwTagId: DWORD, 297 lpDependencies: LPWSTR, 298 lpServiceStartName: LPWSTR, 299 lpDisplayName: LPWSTR, 300 }} 301 pub type LPQUERY_SERVICE_CONFIGW = *mut QUERY_SERVICE_CONFIGW; 302 STRUCT!{struct SERVICE_DESCRIPTIONA { 303 lpDescription: LPSTR, 304 }} 305 pub type LPSERVICE_DESCRIPTIONA = *mut SERVICE_DESCRIPTIONA; 306 STRUCT!{struct SERVICE_DESCRIPTIONW { 307 lpDescription: LPWSTR, 308 }} 309 pub type LPSERVICE_DESCRIPTIONW = *mut SERVICE_DESCRIPTIONW; 310 FN!{stdcall LPSERVICE_MAIN_FUNCTIONW( 311 dwNumServicesArgs: DWORD, 312 lpServiceArgVectors: *mut LPWSTR, 313 ) -> ()} 314 FN!{stdcall LPSERVICE_MAIN_FUNCTIONA( 315 dwNumServicesArgs: DWORD, 316 lpServiceArgVectors: *mut LPSTR, 317 ) -> ()} 318 STRUCT!{struct SERVICE_TABLE_ENTRYA { 319 lpServiceName: LPCSTR, 320 lpServiceProc: LPSERVICE_MAIN_FUNCTIONA, 321 }} 322 pub type LPSERVICE_TABLE_ENTRYA = *mut SERVICE_TABLE_ENTRYA; 323 STRUCT!{struct SERVICE_TABLE_ENTRYW { 324 lpServiceName: LPCWSTR, 325 lpServiceProc: LPSERVICE_MAIN_FUNCTIONW, 326 }} 327 pub type LPSERVICE_TABLE_ENTRYW = *mut SERVICE_TABLE_ENTRYW; 328 FN!{stdcall LPHANDLER_FUNCTION( 329 dwControl: DWORD, 330 ) -> ()} 331 FN!{stdcall LPHANDLER_FUNCTION_EX( 332 dwControl: DWORD, 333 dwEventType: DWORD, 334 lpEventData: LPVOID, 335 lpContext: LPVOID, 336 ) -> DWORD} 337 FN!{stdcall PFN_SC_NOTIFY_CALLBACK( 338 pParameter: PVOID, 339 ) -> ()} 340 STRUCT!{struct SERVICE_NOTIFY_1 { 341 dwVersion: DWORD, 342 pfnNotifyCallback: PFN_SC_NOTIFY_CALLBACK, 343 pContext: PVOID, 344 dwNotificationStatus: DWORD, 345 ServiceStatus: SERVICE_STATUS_PROCESS, 346 }} 347 pub type PSERVICE_NOTIFY_1 = *mut SERVICE_NOTIFY_1; 348 STRUCT!{struct SERVICE_NOTIFY_2A { 349 dwVersion: DWORD, 350 pfnNotifyCallback: PFN_SC_NOTIFY_CALLBACK, 351 pContext: PVOID, 352 dwNotificationStatus: DWORD, 353 ServiceStatus: SERVICE_STATUS_PROCESS, 354 dwNotificationTriggered: DWORD, 355 pszServiceNames: LPSTR, 356 }} 357 pub type PSERVICE_NOTIFY_2A = *mut SERVICE_NOTIFY_2A; 358 STRUCT!{struct SERVICE_NOTIFY_2W { 359 dwVersion: DWORD, 360 pfnNotifyCallback: PFN_SC_NOTIFY_CALLBACK, 361 pContext: PVOID, 362 dwNotificationStatus: DWORD, 363 ServiceStatus: SERVICE_STATUS_PROCESS, 364 dwNotificationTriggered: DWORD, 365 pszServiceNames: LPWSTR, 366 }} 367 pub type PSERVICE_NOTIFY_2W = *mut SERVICE_NOTIFY_2W; 368 pub type SERVICE_NOTIFYA = SERVICE_NOTIFY_2A; 369 pub type PSERVICE_NOTIFYA = PSERVICE_NOTIFY_2A; 370 pub type SERVICE_NOTIFYW = SERVICE_NOTIFY_2W; 371 pub type PSERVICE_NOTIFYW = PSERVICE_NOTIFY_2W; 372 extern "system" { ChangeServiceConfigA( hService: SC_HANDLE, dwServiceType: DWORD, dsStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCSTR, lpLoadOrderGroup: LPCSTR, lpdwTagId: LPDWORD, lpDependencies: LPCSTR, lpServiceStartName: LPCSTR, lpPassword: LPCSTR, lpDisplayName: LPCSTR, ) -> BOOL373 pub fn ChangeServiceConfigA( 374 hService: SC_HANDLE, 375 dwServiceType: DWORD, 376 dsStartType: DWORD, 377 dwErrorControl: DWORD, 378 lpBinaryPathName: LPCSTR, 379 lpLoadOrderGroup: LPCSTR, 380 lpdwTagId: LPDWORD, 381 lpDependencies: LPCSTR, 382 lpServiceStartName: LPCSTR, 383 lpPassword: LPCSTR, 384 lpDisplayName: LPCSTR, 385 ) -> BOOL; ChangeServiceConfigW( hService: SC_HANDLE, dwServiceType: DWORD, dsStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCWSTR, lpLoadOrderGroup: LPCWSTR, lpdwTagId: LPDWORD, lpDependencies: LPCWSTR, lpServiceStartName: LPCWSTR, lpPassword: LPCWSTR, lpDisplayName: LPCWSTR, ) -> BOOL386 pub fn ChangeServiceConfigW( 387 hService: SC_HANDLE, 388 dwServiceType: DWORD, 389 dsStartType: DWORD, 390 dwErrorControl: DWORD, 391 lpBinaryPathName: LPCWSTR, 392 lpLoadOrderGroup: LPCWSTR, 393 lpdwTagId: LPDWORD, 394 lpDependencies: LPCWSTR, 395 lpServiceStartName: LPCWSTR, 396 lpPassword: LPCWSTR, 397 lpDisplayName: LPCWSTR, 398 ) -> BOOL; ChangeServiceConfig2A( hService: SC_HANDLE, dwInfoLevel: DWORD, lpInfo: LPVOID, ) -> BOOL399 pub fn ChangeServiceConfig2A( 400 hService: SC_HANDLE, 401 dwInfoLevel: DWORD, 402 lpInfo: LPVOID, 403 ) -> BOOL; ChangeServiceConfig2W( hService: SC_HANDLE, dwInfoLevel: DWORD, lpInfo: LPVOID, ) -> BOOL404 pub fn ChangeServiceConfig2W( 405 hService: SC_HANDLE, 406 dwInfoLevel: DWORD, 407 lpInfo: LPVOID, 408 ) -> BOOL; CloseServiceHandle( hSCObject: SC_HANDLE, ) -> BOOL409 pub fn CloseServiceHandle( 410 hSCObject: SC_HANDLE, 411 ) -> BOOL; ControlService( hService: SC_HANDLE, dwControl: DWORD, lpServiceStatus: LPSERVICE_STATUS, ) -> BOOL412 pub fn ControlService( 413 hService: SC_HANDLE, 414 dwControl: DWORD, 415 lpServiceStatus: LPSERVICE_STATUS, 416 ) -> BOOL; CreateServiceA( hSCManager: SC_HANDLE, lpServiceName: LPCSTR, lpDisplayName: LPCSTR, dwDesiredAccess: DWORD, dwServiceType: DWORD, dwStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCSTR, lpLoadOrderGroup: LPCSTR, lpdwTagId: LPDWORD, lpDependencies: LPCSTR, lpServiceStartName: LPCSTR, lpPassword: LPCSTR, ) -> SC_HANDLE417 pub fn CreateServiceA( 418 hSCManager: SC_HANDLE, 419 lpServiceName: LPCSTR, 420 lpDisplayName: LPCSTR, 421 dwDesiredAccess: DWORD, 422 dwServiceType: DWORD, 423 dwStartType: DWORD, 424 dwErrorControl: DWORD, 425 lpBinaryPathName: LPCSTR, 426 lpLoadOrderGroup: LPCSTR, 427 lpdwTagId: LPDWORD, 428 lpDependencies: LPCSTR, 429 lpServiceStartName: LPCSTR, 430 lpPassword: LPCSTR, 431 ) -> SC_HANDLE; CreateServiceW( hSCManager: SC_HANDLE, lpServiceName: LPCWSTR, lpDisplayName: LPCWSTR, dwDesiredAccess: DWORD, dwServiceType: DWORD, dwStartType: DWORD, dwErrorControl: DWORD, lpBinaryPathName: LPCWSTR, lpLoadOrderGroup: LPCWSTR, lpdwTagId: LPDWORD, lpDependencies: LPCWSTR, lpServiceStartName: LPCWSTR, lpPassword: LPCWSTR, ) -> SC_HANDLE432 pub fn CreateServiceW( 433 hSCManager: SC_HANDLE, 434 lpServiceName: LPCWSTR, 435 lpDisplayName: LPCWSTR, 436 dwDesiredAccess: DWORD, 437 dwServiceType: DWORD, 438 dwStartType: DWORD, 439 dwErrorControl: DWORD, 440 lpBinaryPathName: LPCWSTR, 441 lpLoadOrderGroup: LPCWSTR, 442 lpdwTagId: LPDWORD, 443 lpDependencies: LPCWSTR, 444 lpServiceStartName: LPCWSTR, 445 lpPassword: LPCWSTR, 446 ) -> SC_HANDLE; DeleteService( hService: SC_HANDLE, ) -> BOOL447 pub fn DeleteService( 448 hService: SC_HANDLE, 449 ) -> BOOL; EnumDependentServicesA( hService: SC_HANDLE, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, ) -> BOOL450 pub fn EnumDependentServicesA( 451 hService: SC_HANDLE, 452 dwServiceState: DWORD, 453 lpServices: LPENUM_SERVICE_STATUSA, 454 cbBufSize: DWORD, 455 pcbBytesNeeded: LPDWORD, 456 lpServicesReturned: LPDWORD, 457 ) -> BOOL; EnumDependentServicesW( hService: SC_HANDLE, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, ) -> BOOL458 pub fn EnumDependentServicesW( 459 hService: SC_HANDLE, 460 dwServiceState: DWORD, 461 lpServices: LPENUM_SERVICE_STATUSW, 462 cbBufSize: DWORD, 463 pcbBytesNeeded: LPDWORD, 464 lpServicesReturned: LPDWORD, 465 ) -> BOOL; EnumServicesStatusA( hSCManager: SC_HANDLE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD, ) -> BOOL466 pub fn EnumServicesStatusA( 467 hSCManager: SC_HANDLE, 468 dwServiceType: DWORD, 469 dwServiceState: DWORD, 470 lpServices: LPENUM_SERVICE_STATUSA, 471 cbBufSize: DWORD, 472 pcbBytesNeeded: LPDWORD, 473 lpServicesReturned: LPDWORD, 474 lpResumeHandle: LPDWORD, 475 ) -> BOOL; EnumServicesStatusW( hSCManager: SC_HANDLE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPENUM_SERVICE_STATUSW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD, ) -> BOOL476 pub fn EnumServicesStatusW( 477 hSCManager: SC_HANDLE, 478 dwServiceType: DWORD, 479 dwServiceState: DWORD, 480 lpServices: LPENUM_SERVICE_STATUSW, 481 cbBufSize: DWORD, 482 pcbBytesNeeded: LPDWORD, 483 lpServicesReturned: LPDWORD, 484 lpResumeHandle: LPDWORD, 485 ) -> BOOL; EnumServicesStatusExA( hSCManager: SC_HANDLE, InfoLevel: SC_ENUM_TYPE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD, pszGroupName: LPCSTR, ) -> BOOL486 pub fn EnumServicesStatusExA( 487 hSCManager: SC_HANDLE, 488 InfoLevel: SC_ENUM_TYPE, 489 dwServiceType: DWORD, 490 dwServiceState: DWORD, 491 lpServices: LPBYTE, 492 cbBufSize: DWORD, 493 pcbBytesNeeded: LPDWORD, 494 lpServicesReturned: LPDWORD, 495 lpResumeHandle: LPDWORD, 496 pszGroupName: LPCSTR, 497 ) -> BOOL; EnumServicesStatusExW( hSCManager: SC_HANDLE, InfoLevel: SC_ENUM_TYPE, dwServiceType: DWORD, dwServiceState: DWORD, lpServices: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, lpServicesReturned: LPDWORD, lpResumeHandle: LPDWORD, pszGroupName: LPCWSTR, ) -> BOOL498 pub fn EnumServicesStatusExW( 499 hSCManager: SC_HANDLE, 500 InfoLevel: SC_ENUM_TYPE, 501 dwServiceType: DWORD, 502 dwServiceState: DWORD, 503 lpServices: LPBYTE, 504 cbBufSize: DWORD, 505 pcbBytesNeeded: LPDWORD, 506 lpServicesReturned: LPDWORD, 507 lpResumeHandle: LPDWORD, 508 pszGroupName: LPCWSTR, 509 ) -> BOOL; GetServiceKeyNameA( hSCManager: SC_HANDLE, lpDisplayName: LPCSTR, lpServiceName: LPSTR, lpcchBuffer: LPDWORD, ) -> BOOL510 pub fn GetServiceKeyNameA( 511 hSCManager: SC_HANDLE, 512 lpDisplayName: LPCSTR, 513 lpServiceName: LPSTR, 514 lpcchBuffer: LPDWORD, 515 ) -> BOOL; GetServiceKeyNameW( hSCManager: SC_HANDLE, lpDisplayName: LPCWSTR, lpServiceName: LPWSTR, lpcchBuffer: LPDWORD, ) -> BOOL516 pub fn GetServiceKeyNameW( 517 hSCManager: SC_HANDLE, 518 lpDisplayName: LPCWSTR, 519 lpServiceName: LPWSTR, 520 lpcchBuffer: LPDWORD, 521 ) -> BOOL; GetServiceDisplayNameA( hSCManager: SC_HANDLE, lpServiceName: LPCSTR, lpDisplayName: LPSTR, lpcchBuffer: LPDWORD, ) -> BOOL522 pub fn GetServiceDisplayNameA( 523 hSCManager: SC_HANDLE, 524 lpServiceName: LPCSTR, 525 lpDisplayName: LPSTR, 526 lpcchBuffer: LPDWORD, 527 ) -> BOOL; GetServiceDisplayNameW( hSCManager: SC_HANDLE, lpServiceName: LPCWSTR, lpDisplayName: LPWSTR, lpcchBuffer: LPDWORD, ) -> BOOL528 pub fn GetServiceDisplayNameW( 529 hSCManager: SC_HANDLE, 530 lpServiceName: LPCWSTR, 531 lpDisplayName: LPWSTR, 532 lpcchBuffer: LPDWORD, 533 ) -> BOOL; LockServiceDatabase( hSCManager: SC_HANDLE, ) -> SC_LOCK534 pub fn LockServiceDatabase( 535 hSCManager: SC_HANDLE, 536 ) -> SC_LOCK; NotifyBootConfigStatus( BootAcceptable: BOOL, ) -> BOOL537 pub fn NotifyBootConfigStatus( 538 BootAcceptable: BOOL, 539 ) -> BOOL; OpenSCManagerA( lpMachineName: LPCSTR, lpDatabaseName: LPCSTR, dwDesiredAccess: DWORD, ) -> SC_HANDLE540 pub fn OpenSCManagerA( 541 lpMachineName: LPCSTR, 542 lpDatabaseName: LPCSTR, 543 dwDesiredAccess: DWORD, 544 ) -> SC_HANDLE; OpenSCManagerW( lpMachineName: LPCWSTR, lpDatabaseName: LPCWSTR, dwDesiredAccess: DWORD, ) -> SC_HANDLE545 pub fn OpenSCManagerW( 546 lpMachineName: LPCWSTR, 547 lpDatabaseName: LPCWSTR, 548 dwDesiredAccess: DWORD, 549 ) -> SC_HANDLE; OpenServiceA( hSCManager: SC_HANDLE, lpServiceName: LPCSTR, dwDesiredAccess: DWORD, ) -> SC_HANDLE550 pub fn OpenServiceA( 551 hSCManager: SC_HANDLE, 552 lpServiceName: LPCSTR, 553 dwDesiredAccess: DWORD, 554 ) -> SC_HANDLE; OpenServiceW( hSCManager: SC_HANDLE, lpServiceName: LPCWSTR, dwDesiredAccess: DWORD, ) -> SC_HANDLE555 pub fn OpenServiceW( 556 hSCManager: SC_HANDLE, 557 lpServiceName: LPCWSTR, 558 dwDesiredAccess: DWORD, 559 ) -> SC_HANDLE; QueryServiceConfigA( hService: SC_HANDLE, lpServiceConfig: LPQUERY_SERVICE_CONFIGA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, ) -> BOOL560 pub fn QueryServiceConfigA( 561 hService: SC_HANDLE, 562 lpServiceConfig: LPQUERY_SERVICE_CONFIGA, 563 cbBufSize: DWORD, 564 pcbBytesNeeded: LPDWORD, 565 ) -> BOOL; QueryServiceConfigW( hService: SC_HANDLE, lpServiceConfig: LPQUERY_SERVICE_CONFIGW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, ) -> BOOL566 pub fn QueryServiceConfigW( 567 hService: SC_HANDLE, 568 lpServiceConfig: LPQUERY_SERVICE_CONFIGW, 569 cbBufSize: DWORD, 570 pcbBytesNeeded: LPDWORD, 571 ) -> BOOL; QueryServiceConfig2A( hService: SC_HANDLE, dwInfoLevel: DWORD, lpBuffer: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, ) -> BOOL572 pub fn QueryServiceConfig2A( 573 hService: SC_HANDLE, 574 dwInfoLevel: DWORD, 575 lpBuffer: LPBYTE, 576 cbBufSize: DWORD, 577 pcbBytesNeeded: LPDWORD, 578 ) -> BOOL; QueryServiceConfig2W( hService: SC_HANDLE, dwInfoLevel: DWORD, lpBuffer: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, ) -> BOOL579 pub fn QueryServiceConfig2W( 580 hService: SC_HANDLE, 581 dwInfoLevel: DWORD, 582 lpBuffer: LPBYTE, 583 cbBufSize: DWORD, 584 pcbBytesNeeded: LPDWORD, 585 ) -> BOOL; QueryServiceLockStatusA( hSCManager: SC_HANDLE, lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSA, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, ) -> BOOL586 pub fn QueryServiceLockStatusA( 587 hSCManager: SC_HANDLE, 588 lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSA, 589 cbBufSize: DWORD, 590 pcbBytesNeeded: LPDWORD, 591 ) -> BOOL; QueryServiceLockStatusW( hSCManager: SC_HANDLE, lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSW, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, ) -> BOOL592 pub fn QueryServiceLockStatusW( 593 hSCManager: SC_HANDLE, 594 lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSW, 595 cbBufSize: DWORD, 596 pcbBytesNeeded: LPDWORD, 597 ) -> BOOL; QueryServiceObjectSecurity( hService: SC_HANDLE, dwSecurityInformation: SECURITY_INFORMATION, lpSecurityDescriptor: PSECURITY_DESCRIPTOR, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, ) -> BOOL598 pub fn QueryServiceObjectSecurity( 599 hService: SC_HANDLE, 600 dwSecurityInformation: SECURITY_INFORMATION, 601 lpSecurityDescriptor: PSECURITY_DESCRIPTOR, 602 cbBufSize: DWORD, 603 pcbBytesNeeded: LPDWORD, 604 ) -> BOOL; QueryServiceStatus( hService: SC_HANDLE, lpServiceStatus: LPSERVICE_STATUS, ) -> BOOL605 pub fn QueryServiceStatus( 606 hService: SC_HANDLE, 607 lpServiceStatus: LPSERVICE_STATUS, 608 ) -> BOOL; QueryServiceStatusEx( hService: SC_HANDLE, InfoLevel: SC_STATUS_TYPE, lpBuffer: LPBYTE, cbBufSize: DWORD, pcbBytesNeeded: LPDWORD, ) -> BOOL609 pub fn QueryServiceStatusEx( 610 hService: SC_HANDLE, 611 InfoLevel: SC_STATUS_TYPE, 612 lpBuffer: LPBYTE, 613 cbBufSize: DWORD, 614 pcbBytesNeeded: LPDWORD, 615 ) -> BOOL; RegisterServiceCtrlHandlerA( lpServiceName: LPCSTR, lpHandlerProc: LPHANDLER_FUNCTION, ) -> SERVICE_STATUS_HANDLE616 pub fn RegisterServiceCtrlHandlerA( 617 lpServiceName: LPCSTR, 618 lpHandlerProc: LPHANDLER_FUNCTION, 619 ) -> SERVICE_STATUS_HANDLE; RegisterServiceCtrlHandlerW( lpServiceName: LPCWSTR, lpHandlerProc: LPHANDLER_FUNCTION, ) -> SERVICE_STATUS_HANDLE620 pub fn RegisterServiceCtrlHandlerW( 621 lpServiceName: LPCWSTR, 622 lpHandlerProc: LPHANDLER_FUNCTION, 623 ) -> SERVICE_STATUS_HANDLE; RegisterServiceCtrlHandlerExA( lpServiceName: LPCSTR, lpHandlerProc: LPHANDLER_FUNCTION_EX, lpContext: LPVOID, ) -> SERVICE_STATUS_HANDLE624 pub fn RegisterServiceCtrlHandlerExA( 625 lpServiceName: LPCSTR, 626 lpHandlerProc: LPHANDLER_FUNCTION_EX, 627 lpContext: LPVOID, 628 ) -> SERVICE_STATUS_HANDLE; RegisterServiceCtrlHandlerExW( lpServiceName: LPCWSTR, lpHandlerProc: LPHANDLER_FUNCTION_EX, lpContext: LPVOID, ) -> SERVICE_STATUS_HANDLE629 pub fn RegisterServiceCtrlHandlerExW( 630 lpServiceName: LPCWSTR, 631 lpHandlerProc: LPHANDLER_FUNCTION_EX, 632 lpContext: LPVOID, 633 ) -> SERVICE_STATUS_HANDLE; SetServiceObjectSecurity( hService: SC_HANDLE, dwSecurityInformation: SECURITY_INFORMATION, lpSecurityDescriptor: PSECURITY_DESCRIPTOR, ) -> BOOL634 pub fn SetServiceObjectSecurity( 635 hService: SC_HANDLE, 636 dwSecurityInformation: SECURITY_INFORMATION, 637 lpSecurityDescriptor: PSECURITY_DESCRIPTOR, 638 ) -> BOOL; SetServiceStatus( hServiceStatus: SERVICE_STATUS_HANDLE, lpServiceStatus: LPSERVICE_STATUS, ) -> BOOL639 pub fn SetServiceStatus( 640 hServiceStatus: SERVICE_STATUS_HANDLE, 641 lpServiceStatus: LPSERVICE_STATUS, 642 ) -> BOOL; StartServiceCtrlDispatcherA( lpServiceStartTable: *const SERVICE_TABLE_ENTRYA, ) -> BOOL643 pub fn StartServiceCtrlDispatcherA( 644 lpServiceStartTable: *const SERVICE_TABLE_ENTRYA, 645 ) -> BOOL; StartServiceCtrlDispatcherW( lpServiceStartTable: *const SERVICE_TABLE_ENTRYW, ) -> BOOL646 pub fn StartServiceCtrlDispatcherW( 647 lpServiceStartTable: *const SERVICE_TABLE_ENTRYW, 648 ) -> BOOL; StartServiceA( hService: SC_HANDLE, dwNumServiceArgs: DWORD, lpServiceArgVectors: *mut LPCSTR, ) -> BOOL649 pub fn StartServiceA( 650 hService: SC_HANDLE, 651 dwNumServiceArgs: DWORD, 652 lpServiceArgVectors: *mut LPCSTR, 653 ) -> BOOL; StartServiceW( hService: SC_HANDLE, dwNumServiceArgs: DWORD, lpServiceArgVectors: *mut LPCWSTR, ) -> BOOL654 pub fn StartServiceW( 655 hService: SC_HANDLE, 656 dwNumServiceArgs: DWORD, 657 lpServiceArgVectors: *mut LPCWSTR, 658 ) -> BOOL; UnlockServiceDatabase( ScLock: SC_LOCK, ) -> BOOL659 pub fn UnlockServiceDatabase( 660 ScLock: SC_LOCK, 661 ) -> BOOL; NotifyServiceStatusChangeA( hService: SC_HANDLE, dwNotifyMask: DWORD, pNotifyBuffer: PSERVICE_NOTIFYA, ) -> DWORD662 pub fn NotifyServiceStatusChangeA( 663 hService: SC_HANDLE, 664 dwNotifyMask: DWORD, 665 pNotifyBuffer: PSERVICE_NOTIFYA, 666 ) -> DWORD; NotifyServiceStatusChangeW( hService: SC_HANDLE, dwNotifyMask: DWORD, pNotifyBuffer: PSERVICE_NOTIFYW, ) -> DWORD667 pub fn NotifyServiceStatusChangeW( 668 hService: SC_HANDLE, 669 dwNotifyMask: DWORD, 670 pNotifyBuffer: PSERVICE_NOTIFYW, 671 ) -> DWORD; ControlServiceExA( hService: SC_HANDLE, dwControl: DWORD, dwInfoLevel: DWORD, pControlParams: PVOID, ) -> BOOL672 pub fn ControlServiceExA( 673 hService: SC_HANDLE, 674 dwControl: DWORD, 675 dwInfoLevel: DWORD, 676 pControlParams: PVOID, 677 ) -> BOOL; ControlServiceExW( hService: SC_HANDLE, dwControl: DWORD, dwInfoLevel: DWORD, pControlParams: PVOID, ) -> BOOL678 pub fn ControlServiceExW( 679 hService: SC_HANDLE, 680 dwControl: DWORD, 681 dwInfoLevel: DWORD, 682 pControlParams: PVOID, 683 ) -> BOOL; QueryServiceDynamicInformation( hServiceStatus: SERVICE_STATUS_HANDLE, dwInfoLevel: DWORD, ppDynamicInfo: *mut PVOID, ) -> BOOL684 pub fn QueryServiceDynamicInformation( 685 hServiceStatus: SERVICE_STATUS_HANDLE, 686 dwInfoLevel: DWORD, 687 ppDynamicInfo: *mut PVOID, 688 ) -> BOOL; WaitServiceState( hService: SC_HANDLE, dwNotify: DWORD, dwTimeout: DWORD, hCancelEvent: HANDLE, ) -> DWORD689 pub fn WaitServiceState ( 690 hService: SC_HANDLE, 691 dwNotify: DWORD, 692 dwTimeout: DWORD, 693 hCancelEvent: HANDLE, 694 ) -> DWORD; 695 } 696