Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 695 insertions, 0 deletions

diff --git a/vendor/winapi/src/um/winsvc.rs b/vendor/winapi/src/um/winsvc.rs
new file mode 100644
index 000000000..baa2a8b84
--- /dev/null
+++ b/vendor/winapi/src/um/winsvc.rs
@@ -0,0 +1,695 @@
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// All files in the project carrying such notice may not be copied, modified, or distributed
+// except according to those terms.
+//! Header file for the Service Control Manager
+use shared::minwindef::{BOOL, DWORD, LPBYTE, LPDWORD, LPVOID};
+use um::winnt::{
+    HANDLE, LPCSTR, LPCWSTR, LPSTR, LPWSTR, PSECURITY_DESCRIPTOR, PVOID,
+    SECURITY_INFORMATION, STANDARD_RIGHTS_REQUIRED
+};
+pub const SERVICE_NO_CHANGE: DWORD = 0xffffffff;
+pub const SERVICE_ACTIVE: DWORD = 0x00000001;
+pub const SERVICE_INACTIVE: DWORD = 0x00000002;
+pub const SERVICE_STATE_ALL: DWORD = SERVICE_ACTIVE | SERVICE_INACTIVE;
+pub const SERVICE_CONTROL_STOP: DWORD = 0x00000001;
+pub const SERVICE_CONTROL_PAUSE: DWORD = 0x00000002;
+pub const SERVICE_CONTROL_CONTINUE: DWORD = 0x00000003;
+pub const SERVICE_CONTROL_INTERROGATE: DWORD = 0x00000004;
+pub const SERVICE_CONTROL_SHUTDOWN: DWORD = 0x00000005;
+pub const SERVICE_CONTROL_PARAMCHANGE: DWORD = 0x00000006;
+pub const SERVICE_CONTROL_NETBINDADD: DWORD = 0x00000007;
+pub const SERVICE_CONTROL_NETBINDREMOVE: DWORD = 0x00000008;
+pub const SERVICE_CONTROL_NETBINDENABLE: DWORD = 0x00000009;
+pub const SERVICE_CONTROL_NETBINDDISABLE: DWORD = 0x0000000A;
+pub const SERVICE_CONTROL_DEVICEEVENT: DWORD = 0x0000000B;
+pub const SERVICE_CONTROL_HARDWAREPROFILECHANGE: DWORD = 0x0000000C;
+pub const SERVICE_CONTROL_POWEREVENT: DWORD = 0x0000000D;
+pub const SERVICE_CONTROL_SESSIONCHANGE: DWORD = 0x0000000E;
+pub const SERVICE_CONTROL_PRESHUTDOWN: DWORD = 0x0000000F;
+pub const SERVICE_CONTROL_TIMECHANGE: DWORD = 0x00000010;
+pub const SERVICE_CONTROL_TRIGGEREVENT: DWORD = 0x00000020;
+pub const SERVICE_STOPPED: DWORD = 0x00000001;
+pub const SERVICE_START_PENDING: DWORD = 0x00000002;
+pub const SERVICE_STOP_PENDING: DWORD = 0x00000003;
+pub const SERVICE_RUNNING: DWORD = 0x00000004;
+pub const SERVICE_CONTINUE_PENDING: DWORD = 0x00000005;
+pub const SERVICE_PAUSE_PENDING: DWORD = 0x00000006;
+pub const SERVICE_PAUSED: DWORD = 0x00000007;
+pub const SERVICE_ACCEPT_STOP: DWORD = 0x00000001;
+pub const SERVICE_ACCEPT_PAUSE_CONTINUE: DWORD = 0x00000002;
+pub const SERVICE_ACCEPT_SHUTDOWN: DWORD = 0x00000004;
+pub const SERVICE_ACCEPT_PARAMCHANGE: DWORD = 0x00000008;
+pub const SERVICE_ACCEPT_NETBINDCHANGE: DWORD = 0x00000010;
+pub const SERVICE_ACCEPT_HARDWAREPROFILECHANGE: DWORD = 0x00000020;
+pub const SERVICE_ACCEPT_POWEREVENT: DWORD = 0x00000040;
+pub const SERVICE_ACCEPT_SESSIONCHANGE: DWORD = 0x00000080;
+pub const SERVICE_ACCEPT_PRESHUTDOWN: DWORD = 0x00000100;
+pub const SERVICE_ACCEPT_TIMECHANGE: DWORD = 0x00000200;
+pub const SERVICE_ACCEPT_TRIGGEREVENT: DWORD = 0x00000400;
+// SERVICE_ACCEPT_USER_LOGOFF
+pub const SC_MANAGER_CONNECT: DWORD = 0x0001;
+pub const SC_MANAGER_CREATE_SERVICE: DWORD = 0x0002;
+pub const SC_MANAGER_ENUMERATE_SERVICE: DWORD = 0x0004;
+pub const SC_MANAGER_LOCK: DWORD = 0x0008;
+pub const SC_MANAGER_QUERY_LOCK_STATUS: DWORD = 0x0010;
+pub const SC_MANAGER_MODIFY_BOOT_CONFIG: DWORD = 0x0020;
+pub const SC_MANAGER_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SC_MANAGER_CONNECT
+    | SC_MANAGER_CREATE_SERVICE | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_LOCK
+    | SC_MANAGER_QUERY_LOCK_STATUS | SC_MANAGER_MODIFY_BOOT_CONFIG;
+pub const SERVICE_QUERY_CONFIG: DWORD = 0x0001;
+pub const SERVICE_CHANGE_CONFIG: DWORD = 0x0002;
+pub const SERVICE_QUERY_STATUS: DWORD = 0x0004;
+pub const SERVICE_ENUMERATE_DEPENDENTS: DWORD = 0x0008;
+pub const SERVICE_START: DWORD = 0x0010;
+pub const SERVICE_STOP: DWORD = 0x0020;
+pub const SERVICE_PAUSE_CONTINUE: DWORD = 0x0040;
+pub const SERVICE_INTERROGATE: DWORD = 0x0080;
+pub const SERVICE_USER_DEFINED_CONTROL: DWORD = 0x0100;
+pub const SERVICE_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | SERVICE_QUERY_CONFIG
+    | SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_START
+    | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_INTERROGATE | SERVICE_USER_DEFINED_CONTROL;
+pub const SERVICE_RUNS_IN_SYSTEM_PROCESS: DWORD = 0x00000001;
+pub const SERVICE_CONFIG_DESCRIPTION: DWORD = 1;
+pub const SERVICE_CONFIG_FAILURE_ACTIONS: DWORD = 2;
+pub const SERVICE_CONFIG_DELAYED_AUTO_START_INFO: DWORD = 3;
+pub const SERVICE_CONFIG_FAILURE_ACTIONS_FLAG: DWORD = 4;
+pub const SERVICE_CONFIG_SERVICE_SID_INFO: DWORD = 5;
+pub const SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO: DWORD = 6;
+pub const SERVICE_CONFIG_PRESHUTDOWN_INFO: DWORD = 7;
+pub const SERVICE_CONFIG_TRIGGER_INFO: DWORD = 8;
+pub const SERVICE_CONFIG_PREFERRED_NODE: DWORD = 9;
+pub const SERVICE_CONFIG_LAUNCH_PROTECTED: DWORD = 12;
+pub const SERVICE_NOTIFY_STATUS_CHANGE_1: DWORD = 1;
+pub const SERVICE_NOTIFY_STATUS_CHANGE_2: DWORD = 2;
+pub const SERVICE_NOTIFY_STATUS_CHANGE: DWORD = SERVICE_NOTIFY_STATUS_CHANGE_2;
+pub const SERVICE_NOTIFY_STOPPED: DWORD = 0x00000001;
+pub const SERVICE_NOTIFY_START_PENDING: DWORD = 0x00000002;
+pub const SERVICE_NOTIFY_STOP_PENDING: DWORD = 0x00000004;
+pub const SERVICE_NOTIFY_RUNNING: DWORD = 0x00000008;
+pub const SERVICE_NOTIFY_CONTINUE_PENDING: DWORD = 0x00000010;
+pub const SERVICE_NOTIFY_PAUSE_PENDING: DWORD = 0x00000020;
+pub const SERVICE_NOTIFY_PAUSED: DWORD = 0x00000040;
+pub const SERVICE_NOTIFY_CREATED: DWORD = 0x00000080;
+pub const SERVICE_NOTIFY_DELETED: DWORD = 0x00000100;
+pub const SERVICE_NOTIFY_DELETE_PENDING: DWORD = 0x00000200;
+pub const SERVICE_STOP_REASON_FLAG_MIN: DWORD = 0x00000000;
+pub const SERVICE_STOP_REASON_FLAG_UNPLANNED: DWORD = 0x10000000;
+pub const SERVICE_STOP_REASON_FLAG_CUSTOM: DWORD = 0x20000000;
+pub const SERVICE_STOP_REASON_FLAG_PLANNED: DWORD = 0x40000000;
+pub const SERVICE_STOP_REASON_FLAG_MAX: DWORD = 0x80000000;
+pub const SERVICE_STOP_REASON_MAJOR_MIN: DWORD = 0x00000000;
+pub const SERVICE_STOP_REASON_MAJOR_OTHER: DWORD = 0x00010000;
+pub const SERVICE_STOP_REASON_MAJOR_HARDWARE: DWORD = 0x00020000;
+pub const SERVICE_STOP_REASON_MAJOR_OPERATINGSYSTEM: DWORD = 0x00030000;
+pub const SERVICE_STOP_REASON_MAJOR_SOFTWARE: DWORD = 0x00040000;
+pub const SERVICE_STOP_REASON_MAJOR_APPLICATION: DWORD = 0x00050000;
+pub const SERVICE_STOP_REASON_MAJOR_NONE: DWORD = 0x00060000;
+pub const SERVICE_STOP_REASON_MAJOR_MAX: DWORD = 0x00070000;
+pub const SERVICE_STOP_REASON_MAJOR_MIN_CUSTOM: DWORD = 0x00400000;
+pub const SERVICE_STOP_REASON_MAJOR_MAX_CUSTOM: DWORD = 0x00ff0000;
+pub const SERVICE_STOP_REASON_MINOR_MIN: DWORD = 0x00000000;
+pub const SERVICE_STOP_REASON_MINOR_OTHER: DWORD = 0x00000001;
+pub const SERVICE_STOP_REASON_MINOR_MAINTENANCE: DWORD = 0x00000002;
+pub const SERVICE_STOP_REASON_MINOR_INSTALLATION: DWORD = 0x00000003;
+pub const SERVICE_STOP_REASON_MINOR_UPGRADE: DWORD = 0x00000004;
+pub const SERVICE_STOP_REASON_MINOR_RECONFIG: DWORD = 0x00000005;
+pub const SERVICE_STOP_REASON_MINOR_HUNG: DWORD = 0x00000006;
+pub const SERVICE_STOP_REASON_MINOR_UNSTABLE: DWORD = 0x00000007;
+pub const SERVICE_STOP_REASON_MINOR_DISK: DWORD = 0x00000008;
+pub const SERVICE_STOP_REASON_MINOR_NETWORKCARD: DWORD = 0x00000009;
+pub const SERVICE_STOP_REASON_MINOR_ENVIRONMENT: DWORD = 0x0000000a;
+pub const SERVICE_STOP_REASON_MINOR_HARDWARE_DRIVER: DWORD = 0x0000000b;
+pub const SERVICE_STOP_REASON_MINOR_OTHERDRIVER: DWORD = 0x0000000c;
+pub const SERVICE_STOP_REASON_MINOR_SERVICEPACK: DWORD = 0x0000000d;
+pub const SERVICE_STOP_REASON_MINOR_SOFTWARE_UPDATE: DWORD = 0x0000000e;
+pub const SERVICE_STOP_REASON_MINOR_SECURITYFIX: DWORD = 0x0000000f;
+pub const SERVICE_STOP_REASON_MINOR_SECURITY: DWORD = 0x00000010;
+pub const SERVICE_STOP_REASON_MINOR_NETWORK_CONNECTIVITY: DWORD = 0x00000011;
+pub const SERVICE_STOP_REASON_MINOR_WMI: DWORD = 0x00000012;
+pub const SERVICE_STOP_REASON_MINOR_SERVICEPACK_UNINSTALL: DWORD = 0x00000013;
+pub const SERVICE_STOP_REASON_MINOR_SOFTWARE_UPDATE_UNINSTALL: DWORD = 0x00000014;
+pub const SERVICE_STOP_REASON_MINOR_SECURITYFIX_UNINSTALL: DWORD = 0x00000015;
+pub const SERVICE_STOP_REASON_MINOR_MMC: DWORD = 0x00000016;
+pub const SERVICE_STOP_REASON_MINOR_NONE: DWORD = 0x00000017;
+pub const SERVICE_STOP_REASON_MINOR_MAX: DWORD = 0x00000018;
+pub const SERVICE_STOP_REASON_MINOR_MIN_CUSTOM: DWORD = 0x00000100;
+pub const SERVICE_STOP_REASON_MINOR_MAX_CUSTOM: DWORD = 0x0000FFFF;
+pub const SERVICE_CONTROL_STATUS_REASON_INFO: DWORD = 1;
+pub const SERVICE_SID_TYPE_NONE: DWORD = 0x00000000;
+pub const SERVICE_SID_TYPE_UNRESTRICTED: DWORD = 0x00000001;
+pub const SERVICE_SID_TYPE_RESTRICTED: DWORD = 0x00000002 | SERVICE_SID_TYPE_UNRESTRICTED;
+pub const SERVICE_TRIGGER_TYPE_DEVICE_INTERFACE_ARRIVAL: DWORD = 1;
+pub const SERVICE_TRIGGER_TYPE_IP_ADDRESS_AVAILABILITY: DWORD = 2;
+pub const SERVICE_TRIGGER_TYPE_DOMAIN_JOIN: DWORD = 3;
+pub const SERVICE_TRIGGER_TYPE_FIREWALL_PORT_EVENT: DWORD = 4;
+pub const SERVICE_TRIGGER_TYPE_GROUP_POLICY: DWORD = 5;
+pub const SERVICE_TRIGGER_TYPE_NETWORK_ENDPOINT: DWORD = 6;
+pub const SERVICE_TRIGGER_TYPE_CUSTOM_SYSTEM_STATE_CHANGE: DWORD = 7;
+pub const SERVICE_TRIGGER_TYPE_CUSTOM: DWORD = 20;
+pub const SERVICE_TRIGGER_DATA_TYPE_BINARY: DWORD = 1;
+pub const SERVICE_TRIGGER_DATA_TYPE_STRING: DWORD = 2;
+pub const SERVICE_TRIGGER_DATA_TYPE_LEVEL: DWORD = 3;
+pub const SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ANY: DWORD = 4;
+pub const SERVICE_TRIGGER_DATA_TYPE_KEYWORD_ALL: DWORD = 5;
+pub const SERVICE_START_REASON_DEMAND: DWORD = 0x00000001;
+pub const SERVICE_START_REASON_AUTO: DWORD = 0x00000002;
+pub const SERVICE_START_REASON_TRIGGER: DWORD = 0x00000004;
+pub const SERVICE_START_REASON_RESTART_ON_FAILURE: DWORD = 0x00000008;
+pub const SERVICE_START_REASON_DELAYEDAUTO: DWORD = 0x00000010;
+pub const SERVICE_DYNAMIC_INFORMATION_LEVEL_START_REASON: DWORD = 1;
+pub const SERVICE_LAUNCH_PROTECTED_NONE: DWORD = 0;
+pub const SERVICE_LAUNCH_PROTECTED_WINDOWS: DWORD = 1;
+pub const SERVICE_LAUNCH_PROTECTED_WINDOWS_LIGHT: DWORD = 2;
+pub const SERVICE_LAUNCH_PROTECTED_ANTIMALWARE_LIGHT: DWORD = 3;
+DEFINE_GUID!{NETWORK_MANAGER_FIRST_IP_ADDRESS_ARRIVAL_GUID,
+    0x4f27f2de, 0x14e2, 0x430b, 0xa5, 0x49, 0x7c, 0xd4, 0x8c, 0xbc, 0x82, 0x45}
+DEFINE_GUID!{NETWORK_MANAGER_LAST_IP_ADDRESS_REMOVAL_GUID,
+    0xcc4ba62a, 0x162e, 0x4648, 0x84, 0x7a, 0xb6, 0xbd, 0xf9, 0x93, 0xe3, 0x35}
+DEFINE_GUID!{DOMAIN_JOIN_GUID,
+    0x1ce20aba, 0x9851, 0x4421, 0x94, 0x30, 0x1d, 0xde, 0xb7, 0x66, 0xe8, 0x09}
+DEFINE_GUID!{DOMAIN_LEAVE_GUID,
+    0xddaf516e, 0x58c2, 0x4866, 0x95, 0x74, 0xc3, 0xb6, 0x15, 0xd4, 0x2e, 0xa1}
+DEFINE_GUID!{FIREWALL_PORT_OPEN_GUID,
+    0xb7569e07, 0x8421, 0x4ee0, 0xad, 0x10, 0x86, 0x91, 0x5a, 0xfd, 0xad, 0x09}
+DEFINE_GUID!{FIREWALL_PORT_CLOSE_GUID,
+    0xa144ed38, 0x8e12, 0x4de4, 0x9d, 0x96, 0xe6, 0x47, 0x40, 0xb1, 0xa5, 0x24}
+DEFINE_GUID!{MACHINE_POLICY_PRESENT_GUID,
+    0x659fcae6, 0x5bdb, 0x4da9, 0xb1, 0xff, 0xca, 0x2a, 0x17, 0x8d, 0x46, 0xe0}
+DEFINE_GUID!{USER_POLICY_PRESENT_GUID,
+    0x54fb46c8, 0xf089, 0x464c, 0xb1, 0xfd, 0x59, 0xd1, 0xb6, 0x2c, 0x3b, 0x50}
+DEFINE_GUID!{RPC_INTERFACE_EVENT_GUID,
+    0xbc90d167, 0x9470, 0x4139, 0xa9, 0xba, 0xbe, 0x0b, 0xbb, 0xf5, 0xb7, 0x4d}
+DEFINE_GUID!{NAMED_PIPE_EVENT_GUID,
+    0x1f81d131, 0x3fac, 0x4537, 0x9e, 0x0c, 0x7e, 0x7b, 0x0c, 0x2f, 0x4b, 0x55}
+DEFINE_GUID!{CUSTOM_SYSTEM_STATE_CHANGE_EVENT_GUID,
+    0x2d7a2816, 0x0c5e, 0x45fc, 0x9c, 0xe7, 0x57, 0x0e, 0x5e, 0xcd, 0xe9, 0xc9}
+ENUM!{enum SC_ACTION_TYPE {
+    SC_ACTION_NONE = 0,
+    SC_ACTION_RESTART = 1,
+    SC_ACTION_REBOOT = 2,
+    SC_ACTION_RUN_COMMAND = 3,
+}}
+STRUCT!{struct SC_ACTION {
+    Type: SC_ACTION_TYPE,
+    Delay: DWORD,
+}}
+pub type LPSC_ACTION = *mut SC_ACTION;
+STRUCT!{struct SERVICE_FAILURE_ACTIONSW {
+    dwResetPeriod: DWORD,
+    lpRebootMsg: LPWSTR,
+    lpCommand: LPWSTR,
+    cActions: DWORD,
+    lpsaActions: LPSC_ACTION,
+}}
+pub type LPSERVICE_FAILURE_ACTIONSW = *mut SERVICE_FAILURE_ACTIONSW;
+STRUCT!{struct SERVICE_FAILURE_ACTIONS_FLAG {
+    fFailureActionsOnNonCrashFailures: BOOL,
+}}
+DECLARE_HANDLE!{SC_HANDLE, SC_HANDLE__}
+pub type LPSC_HANDLE = *mut SC_HANDLE;
+DECLARE_HANDLE!{SERVICE_STATUS_HANDLE, SERVICE_STATUS_HANDLE__}
+ENUM!{enum SC_STATUS_TYPE {
+    SC_STATUS_PROCESS_INFO = 0,
+}}
+ENUM!{enum SC_ENUM_TYPE {
+    SC_ENUM_PROCESS_INFO = 0,
+}}
+STRUCT!{struct SERVICE_STATUS {
+    dwServiceType: DWORD,
+    dwCurrentState: DWORD,
+    dwControlsAccepted: DWORD,
+    dwWin32ExitCode: DWORD,
+    dwServiceSpecificExitCode: DWORD,
+    dwCheckPoint: DWORD,
+    dwWaitHint: DWORD,
+}}
+pub type LPSERVICE_STATUS = *mut SERVICE_STATUS;
+STRUCT!{struct SERVICE_STATUS_PROCESS {
+    dwServiceType: DWORD,
+    dwCurrentState: DWORD,
+    dwControlsAccepted: DWORD,
+    dwWin32ExitCode: DWORD,
+    dwServiceSpecificExitCode: DWORD,
+    dwCheckPoint: DWORD,
+    dwWaitHint: DWORD,
+    dwProcessId: DWORD,
+    dwServiceFlags: DWORD,
+}}
+pub type LPSERVICE_STATUS_PROCESS = *mut SERVICE_STATUS_PROCESS;
+STRUCT!{struct ENUM_SERVICE_STATUSA {
+    lpServiceName: LPSTR,
+    lpDisplayName: LPSTR,
+    ServiceStatus: SERVICE_STATUS,
+}}
+pub type LPENUM_SERVICE_STATUSA = *mut ENUM_SERVICE_STATUSA;
+STRUCT!{struct ENUM_SERVICE_STATUSW {
+    lpServiceName: LPWSTR,
+    lpDisplayName: LPWSTR,
+    ServiceStatus: SERVICE_STATUS,
+}}
+pub type LPENUM_SERVICE_STATUSW = *mut ENUM_SERVICE_STATUSW;
+STRUCT!{struct ENUM_SERVICE_STATUS_PROCESSA {
+    lpServiceName: LPSTR,
+    lpDisplayName: LPSTR,
+    ServiceStatusProcess: SERVICE_STATUS_PROCESS,
+}}
+pub type LPENUM_SERVICE_STATUS_PROCESSA = *mut ENUM_SERVICE_STATUS_PROCESSA;
+STRUCT!{struct ENUM_SERVICE_STATUS_PROCESSW {
+    lpServiceName: LPWSTR,
+    lpDisplayName: LPWSTR,
+    ServiceStatusProcess: SERVICE_STATUS_PROCESS,
+}}
+pub type LPENUM_SERVICE_STATUS_PROCESSW = *mut ENUM_SERVICE_STATUS_PROCESSW;
+pub type SC_LOCK = LPVOID;
+STRUCT!{struct QUERY_SERVICE_LOCK_STATUSA {
+    fIsLocked: DWORD,
+    lpLockOwner: LPSTR,
+    dwLockDuration: DWORD,
+}}
+pub type LPQUERY_SERVICE_LOCK_STATUSA = *mut QUERY_SERVICE_LOCK_STATUSA;
+STRUCT!{struct QUERY_SERVICE_LOCK_STATUSW {
+    fIsLocked: DWORD,
+    lpLockOwner: LPWSTR,
+    dwLockDuration: DWORD,
+}}
+pub type LPQUERY_SERVICE_LOCK_STATUSW = *mut QUERY_SERVICE_LOCK_STATUSW;
+STRUCT!{struct QUERY_SERVICE_CONFIGA {
+    dwServiceType: DWORD,
+    dwStartType: DWORD,
+    dwErrorControl: DWORD,
+    lpBinaryPathName: LPSTR,
+    lpLoadOrderGroup: LPSTR,
+    dwTagId: DWORD,
+    lpDependencies: LPSTR,
+    lpServiceStartName: LPSTR,
+    lpDisplayName: LPSTR,
+}}
+pub type LPQUERY_SERVICE_CONFIGA = *mut QUERY_SERVICE_CONFIGA;
+STRUCT!{struct QUERY_SERVICE_CONFIGW {
+    dwServiceType: DWORD,
+    dwStartType: DWORD,
+    dwErrorControl: DWORD,
+    lpBinaryPathName: LPWSTR,
+    lpLoadOrderGroup: LPWSTR,
+    dwTagId: DWORD,
+    lpDependencies: LPWSTR,
+    lpServiceStartName: LPWSTR,
+    lpDisplayName: LPWSTR,
+}}
+pub type LPQUERY_SERVICE_CONFIGW = *mut QUERY_SERVICE_CONFIGW;
+STRUCT!{struct SERVICE_DESCRIPTIONA {
+    lpDescription: LPSTR,
+}}
+pub type LPSERVICE_DESCRIPTIONA = *mut SERVICE_DESCRIPTIONA;
+STRUCT!{struct SERVICE_DESCRIPTIONW {
+    lpDescription: LPWSTR,
+}}
+pub type LPSERVICE_DESCRIPTIONW = *mut SERVICE_DESCRIPTIONW;
+FN!{stdcall LPSERVICE_MAIN_FUNCTIONW(
+    dwNumServicesArgs: DWORD,
+    lpServiceArgVectors: *mut LPWSTR,
+) -> ()}
+FN!{stdcall LPSERVICE_MAIN_FUNCTIONA(
+    dwNumServicesArgs: DWORD,
+    lpServiceArgVectors: *mut LPSTR,
+) -> ()}
+STRUCT!{struct SERVICE_TABLE_ENTRYA {
+    lpServiceName: LPCSTR,
+    lpServiceProc: LPSERVICE_MAIN_FUNCTIONA,
+}}
+pub type LPSERVICE_TABLE_ENTRYA = *mut SERVICE_TABLE_ENTRYA;
+STRUCT!{struct SERVICE_TABLE_ENTRYW {
+    lpServiceName: LPCWSTR,
+    lpServiceProc: LPSERVICE_MAIN_FUNCTIONW,
+}}
+pub type LPSERVICE_TABLE_ENTRYW = *mut SERVICE_TABLE_ENTRYW;
+FN!{stdcall LPHANDLER_FUNCTION(
+    dwControl: DWORD,
+) -> ()}
+FN!{stdcall LPHANDLER_FUNCTION_EX(
+    dwControl: DWORD,
+    dwEventType: DWORD,
+    lpEventData: LPVOID,
+    lpContext: LPVOID,
+) -> DWORD}
+FN!{stdcall PFN_SC_NOTIFY_CALLBACK(
+    pParameter: PVOID,
+) -> ()}
+STRUCT!{struct SERVICE_NOTIFY_1 {
+    dwVersion: DWORD,
+    pfnNotifyCallback: PFN_SC_NOTIFY_CALLBACK,
+    pContext: PVOID,
+    dwNotificationStatus: DWORD,
+    ServiceStatus: SERVICE_STATUS_PROCESS,
+}}
+pub type PSERVICE_NOTIFY_1 = *mut SERVICE_NOTIFY_1;
+STRUCT!{struct SERVICE_NOTIFY_2A {
+    dwVersion: DWORD,
+    pfnNotifyCallback: PFN_SC_NOTIFY_CALLBACK,
+    pContext: PVOID,
+    dwNotificationStatus: DWORD,
+    ServiceStatus: SERVICE_STATUS_PROCESS,
+    dwNotificationTriggered: DWORD,
+    pszServiceNames: LPSTR,
+}}
+pub type PSERVICE_NOTIFY_2A = *mut SERVICE_NOTIFY_2A;
+STRUCT!{struct SERVICE_NOTIFY_2W {
+    dwVersion: DWORD,
+    pfnNotifyCallback: PFN_SC_NOTIFY_CALLBACK,
+    pContext: PVOID,
+    dwNotificationStatus: DWORD,
+    ServiceStatus: SERVICE_STATUS_PROCESS,
+    dwNotificationTriggered: DWORD,
+    pszServiceNames: LPWSTR,
+}}
+pub type PSERVICE_NOTIFY_2W = *mut SERVICE_NOTIFY_2W;
+pub type SERVICE_NOTIFYA = SERVICE_NOTIFY_2A;
+pub type PSERVICE_NOTIFYA = PSERVICE_NOTIFY_2A;
+pub type SERVICE_NOTIFYW = SERVICE_NOTIFY_2W;
+pub type PSERVICE_NOTIFYW = PSERVICE_NOTIFY_2W;
+extern "system" {
+    pub fn ChangeServiceConfigA(
+        hService: SC_HANDLE,
+        dwServiceType: DWORD,
+        dsStartType: DWORD,
+        dwErrorControl: DWORD,
+        lpBinaryPathName: LPCSTR,
+        lpLoadOrderGroup: LPCSTR,
+        lpdwTagId: LPDWORD,
+        lpDependencies: LPCSTR,
+        lpServiceStartName: LPCSTR,
+        lpPassword: LPCSTR,
+        lpDisplayName: LPCSTR,
+    ) -> BOOL;
+    pub fn ChangeServiceConfigW(
+        hService: SC_HANDLE,
+        dwServiceType: DWORD,
+        dsStartType: DWORD,
+        dwErrorControl: DWORD,
+        lpBinaryPathName: LPCWSTR,
+        lpLoadOrderGroup: LPCWSTR,
+        lpdwTagId: LPDWORD,
+        lpDependencies: LPCWSTR,
+        lpServiceStartName: LPCWSTR,
+        lpPassword: LPCWSTR,
+        lpDisplayName: LPCWSTR,
+    ) -> BOOL;
+    pub fn ChangeServiceConfig2A(
+        hService: SC_HANDLE,
+        dwInfoLevel: DWORD,
+        lpInfo: LPVOID,
+    ) -> BOOL;
+    pub fn ChangeServiceConfig2W(
+        hService: SC_HANDLE,
+        dwInfoLevel: DWORD,
+        lpInfo: LPVOID,
+    ) -> BOOL;
+    pub fn CloseServiceHandle(
+        hSCObject: SC_HANDLE,
+    ) -> BOOL;
+    pub fn ControlService(
+        hService: SC_HANDLE,
+        dwControl: DWORD,
+        lpServiceStatus: LPSERVICE_STATUS,
+    ) -> BOOL;
+    pub fn 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_HANDLE;
+    pub fn 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_HANDLE;
+    pub fn DeleteService(
+        hService: SC_HANDLE,
+    ) -> BOOL;
+    pub fn EnumDependentServicesA(
+        hService: SC_HANDLE,
+        dwServiceState: DWORD,
+        lpServices: LPENUM_SERVICE_STATUSA,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+        lpServicesReturned: LPDWORD,
+    ) -> BOOL;
+    pub fn EnumDependentServicesW(
+        hService: SC_HANDLE,
+        dwServiceState: DWORD,
+        lpServices: LPENUM_SERVICE_STATUSW,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+        lpServicesReturned: LPDWORD,
+    ) -> BOOL;
+    pub fn EnumServicesStatusA(
+        hSCManager: SC_HANDLE,
+        dwServiceType: DWORD,
+        dwServiceState: DWORD,
+        lpServices: LPENUM_SERVICE_STATUSA,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+        lpServicesReturned: LPDWORD,
+        lpResumeHandle: LPDWORD,
+    ) -> BOOL;
+    pub fn EnumServicesStatusW(
+        hSCManager: SC_HANDLE,
+        dwServiceType: DWORD,
+        dwServiceState: DWORD,
+        lpServices: LPENUM_SERVICE_STATUSW,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+        lpServicesReturned: LPDWORD,
+        lpResumeHandle: LPDWORD,
+    ) -> BOOL;
+    pub fn EnumServicesStatusExA(
+        hSCManager: SC_HANDLE,
+        InfoLevel: SC_ENUM_TYPE,
+        dwServiceType: DWORD,
+        dwServiceState: DWORD,
+        lpServices: LPBYTE,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+        lpServicesReturned: LPDWORD,
+        lpResumeHandle: LPDWORD,
+        pszGroupName: LPCSTR,
+    ) -> BOOL;
+    pub fn EnumServicesStatusExW(
+        hSCManager: SC_HANDLE,
+        InfoLevel: SC_ENUM_TYPE,
+        dwServiceType: DWORD,
+        dwServiceState: DWORD,
+        lpServices: LPBYTE,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+        lpServicesReturned: LPDWORD,
+        lpResumeHandle: LPDWORD,
+        pszGroupName: LPCWSTR,
+    ) -> BOOL;
+    pub fn GetServiceKeyNameA(
+        hSCManager: SC_HANDLE,
+        lpDisplayName: LPCSTR,
+        lpServiceName: LPSTR,
+        lpcchBuffer: LPDWORD,
+    ) -> BOOL;
+    pub fn GetServiceKeyNameW(
+        hSCManager: SC_HANDLE,
+        lpDisplayName: LPCWSTR,
+        lpServiceName: LPWSTR,
+        lpcchBuffer: LPDWORD,
+    ) -> BOOL;
+    pub fn GetServiceDisplayNameA(
+        hSCManager: SC_HANDLE,
+        lpServiceName: LPCSTR,
+        lpDisplayName: LPSTR,
+        lpcchBuffer: LPDWORD,
+    ) -> BOOL;
+    pub fn GetServiceDisplayNameW(
+        hSCManager: SC_HANDLE,
+        lpServiceName: LPCWSTR,
+        lpDisplayName: LPWSTR,
+        lpcchBuffer: LPDWORD,
+    ) -> BOOL;
+    pub fn LockServiceDatabase(
+        hSCManager: SC_HANDLE,
+    ) -> SC_LOCK;
+    pub fn NotifyBootConfigStatus(
+        BootAcceptable: BOOL,
+    ) -> BOOL;
+    pub fn OpenSCManagerA(
+        lpMachineName: LPCSTR,
+        lpDatabaseName: LPCSTR,
+        dwDesiredAccess: DWORD,
+    ) -> SC_HANDLE;
+    pub fn OpenSCManagerW(
+        lpMachineName: LPCWSTR,
+        lpDatabaseName: LPCWSTR,
+        dwDesiredAccess: DWORD,
+    ) -> SC_HANDLE;
+    pub fn OpenServiceA(
+        hSCManager: SC_HANDLE,
+        lpServiceName: LPCSTR,
+        dwDesiredAccess: DWORD,
+    ) -> SC_HANDLE;
+    pub fn OpenServiceW(
+        hSCManager: SC_HANDLE,
+        lpServiceName: LPCWSTR,
+        dwDesiredAccess: DWORD,
+    ) -> SC_HANDLE;
+    pub fn QueryServiceConfigA(
+        hService: SC_HANDLE,
+        lpServiceConfig: LPQUERY_SERVICE_CONFIGA,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+    ) -> BOOL;
+    pub fn QueryServiceConfigW(
+        hService: SC_HANDLE,
+        lpServiceConfig: LPQUERY_SERVICE_CONFIGW,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+    ) -> BOOL;
+    pub fn QueryServiceConfig2A(
+        hService: SC_HANDLE,
+        dwInfoLevel: DWORD,
+        lpBuffer: LPBYTE,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+    ) -> BOOL;
+    pub fn QueryServiceConfig2W(
+        hService: SC_HANDLE,
+        dwInfoLevel: DWORD,
+        lpBuffer: LPBYTE,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+    ) -> BOOL;
+    pub fn QueryServiceLockStatusA(
+        hSCManager: SC_HANDLE,
+        lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSA,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+    ) -> BOOL;
+    pub fn QueryServiceLockStatusW(
+        hSCManager: SC_HANDLE,
+        lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSW,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+    ) -> BOOL;
+    pub fn QueryServiceObjectSecurity(
+        hService: SC_HANDLE,
+        dwSecurityInformation: SECURITY_INFORMATION,
+        lpSecurityDescriptor: PSECURITY_DESCRIPTOR,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+    ) -> BOOL;
+    pub fn QueryServiceStatus(
+        hService: SC_HANDLE,
+        lpServiceStatus: LPSERVICE_STATUS,
+    ) -> BOOL;
+    pub fn QueryServiceStatusEx(
+        hService: SC_HANDLE,
+        InfoLevel: SC_STATUS_TYPE,
+        lpBuffer: LPBYTE,
+        cbBufSize: DWORD,
+        pcbBytesNeeded: LPDWORD,
+    ) -> BOOL;
+    pub fn RegisterServiceCtrlHandlerA(
+        lpServiceName: LPCSTR,
+        lpHandlerProc: LPHANDLER_FUNCTION,
+    ) -> SERVICE_STATUS_HANDLE;
+    pub fn RegisterServiceCtrlHandlerW(
+        lpServiceName: LPCWSTR,
+        lpHandlerProc: LPHANDLER_FUNCTION,
+    ) -> SERVICE_STATUS_HANDLE;
+    pub fn RegisterServiceCtrlHandlerExA(
+        lpServiceName: LPCSTR,
+        lpHandlerProc: LPHANDLER_FUNCTION_EX,
+        lpContext: LPVOID,
+    ) -> SERVICE_STATUS_HANDLE;
+    pub fn RegisterServiceCtrlHandlerExW(
+        lpServiceName: LPCWSTR,
+        lpHandlerProc: LPHANDLER_FUNCTION_EX,
+        lpContext: LPVOID,
+    ) -> SERVICE_STATUS_HANDLE;
+    pub fn SetServiceObjectSecurity(
+        hService: SC_HANDLE,
+        dwSecurityInformation: SECURITY_INFORMATION,
+        lpSecurityDescriptor: PSECURITY_DESCRIPTOR,
+    ) -> BOOL;
+    pub fn SetServiceStatus(
+        hServiceStatus: SERVICE_STATUS_HANDLE,
+        lpServiceStatus: LPSERVICE_STATUS,
+    ) -> BOOL;
+    pub fn StartServiceCtrlDispatcherA(
+        lpServiceStartTable: *const SERVICE_TABLE_ENTRYA,
+    ) -> BOOL;
+    pub fn StartServiceCtrlDispatcherW(
+        lpServiceStartTable: *const SERVICE_TABLE_ENTRYW,
+    ) -> BOOL;
+    pub fn StartServiceA(
+        hService: SC_HANDLE,
+        dwNumServiceArgs: DWORD,
+        lpServiceArgVectors: *mut LPCSTR,
+    ) -> BOOL;
+    pub fn StartServiceW(
+        hService: SC_HANDLE,
+        dwNumServiceArgs: DWORD,
+        lpServiceArgVectors: *mut LPCWSTR,
+    ) -> BOOL;
+    pub fn UnlockServiceDatabase(
+        ScLock: SC_LOCK,
+    ) -> BOOL;
+    pub fn NotifyServiceStatusChangeA(
+        hService: SC_HANDLE,
+        dwNotifyMask: DWORD,
+        pNotifyBuffer: PSERVICE_NOTIFYA,
+    ) -> DWORD;
+    pub fn NotifyServiceStatusChangeW(
+        hService: SC_HANDLE,
+        dwNotifyMask: DWORD,
+        pNotifyBuffer: PSERVICE_NOTIFYW,
+    ) -> DWORD;
+    pub fn ControlServiceExA(
+        hService: SC_HANDLE,
+        dwControl: DWORD,
+        dwInfoLevel: DWORD,
+        pControlParams: PVOID,
+    ) -> BOOL;
+    pub fn ControlServiceExW(
+        hService: SC_HANDLE,
+        dwControl: DWORD,
+        dwInfoLevel: DWORD,
+        pControlParams: PVOID,
+    ) -> BOOL;
+    pub fn QueryServiceDynamicInformation(
+        hServiceStatus: SERVICE_STATUS_HANDLE,
+        dwInfoLevel: DWORD,
+        ppDynamicInfo: *mut PVOID,
+    ) -> BOOL;
+    pub fn WaitServiceState (
+        hService: SC_HANDLE,
+        dwNotify: DWORD,
+        dwTimeout: DWORD,
+        hCancelEvent: HANDLE,
+    ) -> DWORD;
+}