diff --git a/dll/win32/comdlg32/precomp.h b/dll/win32/comdlg32/precomp.h index 819aa101548..6de83eecc33 100644 --- a/dll/win32/comdlg32/precomp.h +++ b/dll/win32/comdlg32/precomp.h @@ -23,9 +23,6 @@ #include #include #include -/* RegGetValueW is supported by Win2k3 SP1 but headers need Win Vista */ -#undef _WIN32_WINNT -#define _WIN32_WINNT 0x0600 #include #define NO_SHLWAPI_STREAM #include diff --git a/dll/win32/setupapi/driver.c b/dll/win32/setupapi/driver.c index 3ead218522b..a809303b032 100644 --- a/dll/win32/setupapi/driver.c +++ b/dll/win32/setupapi/driver.c @@ -565,152 +565,6 @@ done: return Result; } -#if _WIN32_WINNT < 0x0600 -/* WARNING: - * This code has been copied from advapi32/reg/reg.c, - * so this dll can be tested as is on Windows XP - */ - -#define RRF_RT_REG_NONE (1 << 0) -#define RRF_RT_REG_SZ (1 << 1) -#define RRF_RT_REG_EXPAND_SZ (1 << 2) -#define RRF_RT_REG_BINARY (1 << 3) -#define RRF_RT_REG_DWORD (1 << 4) -#define RRF_RT_REG_MULTI_SZ (1 << 5) -#define RRF_RT_REG_QWORD (1 << 6) -#define RRF_RT_DWORD (RRF_RT_REG_BINARY | RRF_RT_REG_DWORD) -#define RRF_RT_QWORD (RRF_RT_REG_BINARY | RRF_RT_REG_QWORD) -#define RRF_NOEXPAND (1 << 28) -#define RRF_ZEROONFAILURE (1 << 29) - -static VOID -RegpApplyRestrictions( DWORD dwFlags, DWORD dwType, DWORD cbData, - PLONG ret ) -{ - /* Check if the type is restricted by the passed flags */ - if (*ret == ERROR_SUCCESS || *ret == ERROR_MORE_DATA) - { - DWORD dwMask = 0; - - switch (dwType) - { - case REG_NONE: dwMask = RRF_RT_REG_NONE; break; - case REG_SZ: dwMask = RRF_RT_REG_SZ; break; - case REG_EXPAND_SZ: dwMask = RRF_RT_REG_EXPAND_SZ; break; - case REG_MULTI_SZ: dwMask = RRF_RT_REG_MULTI_SZ; break; - case REG_BINARY: dwMask = RRF_RT_REG_BINARY; break; - case REG_DWORD: dwMask = RRF_RT_REG_DWORD; break; - case REG_QWORD: dwMask = RRF_RT_REG_QWORD; break; - } - - if (dwFlags & dwMask) - { - /* Type is not restricted, check for size mismatch */ - if (dwType == REG_BINARY) - { - DWORD cbExpect = 0; - - if ((dwFlags & RRF_RT_DWORD) == RRF_RT_DWORD) - cbExpect = 4; - else if ((dwFlags & RRF_RT_QWORD) == RRF_RT_QWORD) - cbExpect = 8; - - if (cbExpect && cbData != cbExpect) - *ret = ERROR_DATATYPE_MISMATCH; - } - } - else *ret = ERROR_UNSUPPORTED_TYPE; - } -} - -static LONG WINAPI -RegGetValueW( HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, - DWORD dwFlags, LPDWORD pdwType, PVOID pvData, - LPDWORD pcbData ) -{ - DWORD dwType, cbData = pcbData ? *pcbData : 0; - PVOID pvBuf = NULL; - LONG ret; - - TRACE("(%p,%s,%s,%ld,%p,%p,%p=%ld)\n", - hKey, debugstr_w(pszSubKey), debugstr_w(pszValue), dwFlags, pdwType, - pvData, pcbData, cbData); - - if ((dwFlags & RRF_RT_REG_EXPAND_SZ) && !(dwFlags & RRF_NOEXPAND)) - return ERROR_INVALID_PARAMETER; - - if (pszSubKey && pszSubKey[0]) - { - ret = RegOpenKeyExW(hKey, pszSubKey, 0, KEY_QUERY_VALUE, &hKey); - if (ret != ERROR_SUCCESS) return ret; - } - - ret = RegQueryValueExW(hKey, pszValue, NULL, &dwType, pvData, &cbData); - - /* If we are going to expand we need to read in the whole the value even - * if the passed buffer was too small as the expanded string might be - * smaller than the unexpanded one and could fit into cbData bytes. */ - if ((ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && - (dwType == REG_EXPAND_SZ && !(dwFlags & RRF_NOEXPAND))) - { - do { - if (pvBuf) HeapFree(GetProcessHeap(), 0, pvBuf); - - pvBuf = HeapAlloc(GetProcessHeap(), 0, cbData); - if (!pvBuf) - { - ret = ERROR_NOT_ENOUGH_MEMORY; - break; - } - - if (ret == ERROR_MORE_DATA) - ret = RegQueryValueExW(hKey, pszValue, NULL, - &dwType, pvBuf, &cbData); - else - { - /* Even if cbData was large enough we have to copy the - * string since ExpandEnvironmentStrings can't handle - * overlapping buffers. */ - CopyMemory(pvBuf, pvData, cbData); - } - - /* Both the type or the value itself could have been modified in - * between so we have to keep retrying until the buffer is large - * enough or we no longer have to expand the value. */ - } while (dwType == REG_EXPAND_SZ && ret == ERROR_MORE_DATA); - - if (ret == ERROR_SUCCESS) - { - if (dwType == REG_EXPAND_SZ) - { - cbData = ExpandEnvironmentStringsW(pvBuf, pvData, - pcbData ? (*pcbData)/sizeof(WCHAR) : 0); - dwType = REG_SZ; - if(pcbData && cbData > ((*pcbData)/sizeof(WCHAR))) - ret = ERROR_MORE_DATA; - } - else if (pcbData) - CopyMemory(pvData, pvBuf, *pcbData); - } - - if (pvBuf) HeapFree(GetProcessHeap(), 0, pvBuf); - } - - if (pszSubKey && pszSubKey[0]) - RegCloseKey(hKey); - - RegpApplyRestrictions(dwFlags, dwType, cbData, &ret); - - if (pcbData && ret != ERROR_SUCCESS && (dwFlags & RRF_ZEROONFAILURE)) - ZeroMemory(pvData, *pcbData); - - if (pdwType) *pdwType = dwType; - if (pcbData) *pcbData = cbData; - - return ret; -} -#endif /* End of code copied from advapi32/reg/reg.c */ - /*********************************************************************** * SetupDiBuildDriverInfoList (SETUPAPI.@) */ diff --git a/sdk/include/psdk/winreg.h b/sdk/include/psdk/winreg.h index 248d00e4162..f7ef6fc7ddd 100644 --- a/sdk/include/psdk/winreg.h +++ b/sdk/include/psdk/winreg.h @@ -204,7 +204,7 @@ RegEnumValueW( _Out_writes_bytes_to_opt_(*lpcbData, *lpcbData) __out_data_source(REGISTRY) LPBYTE lpData, _Inout_opt_ LPDWORD lpcbData); -#if (_WIN32_WINNT >= 0x0600) +#if (_WIN32_WINNT >= 0x0502) LSTATUS WINAPI @@ -252,6 +252,23 @@ LSTATUS WINAPI RegLoadKeyA(_In_ HKEY, _In_opt_ LPCSTR, _In_ LPCSTR); LSTATUS WINAPI RegLoadKeyW(_In_ HKEY, _In_opt_ LPCWSTR, _In_ LPCWSTR); #if (_WIN32_WINNT >= 0x0600) +LSTATUS +WINAPI +RegLoadAppKeyA( + _In_ LPCSTR lpFile, + _Out_ PHKEY phkResult, + _In_ REGSAM samDesired, + _In_ DWORD dwOptions, + _Reserved_ DWORD Reserved); + +LSTATUS +WINAPI +RegLoadAppKeyW( + _In_ LPCWSTR lpFile, + _Out_ PHKEY phkResult, + _In_ REGSAM samDesired, + _In_ DWORD dwOptions, + _Reserved_ DWORD Reserved); LSTATUS WINAPI @@ -274,7 +291,6 @@ RegLoadMUIStringW( _Out_opt_ LPDWORD pcbData, _In_ DWORD Flags, _In_opt_ LPCWSTR pszDirectory); - #endif LSTATUS WINAPI RegNotifyChangeKeyValue(_In_ HKEY, _In_ BOOL, _In_ DWORD, _In_opt_ HANDLE, _In_ BOOL); @@ -386,6 +402,13 @@ LSTATUS WINAPI RegSetKeySecurity(_In_ HKEY, _In_ SECURITY_INFORMATION, _In_ PSEC #if (_WIN32_WINNT >= 0x0600) +LSTATUS +WINAPI +RegRenameKey( + _In_ HKEY hKey, + _In_opt_ LPCWSTR lpSubKeyName, + _In_ LPCWSTR lpNewKeyName); + LSTATUS WINAPI RegSetKeyValueA( @@ -471,11 +494,12 @@ typedef VALENTW VALENT,*PVALENT; #define RegEnumKey RegEnumKeyW #define RegEnumKeyEx RegEnumKeyExW #define RegEnumValue RegEnumValueW -#if (_WIN32_WINNT >= 0x0600) +#if (_WIN32_WINNT >= 0x0502) #define RegGetValue RegGetValueW #endif #define RegLoadKey RegLoadKeyW #if (_WIN32_WINNT >= 0x0600) +#define RegLoadAppKey RegLoadAppKeyW #define RegLoadMUIString RegLoadMUIStringW #endif #define RegOpenKey RegOpenKeyW @@ -516,11 +540,12 @@ typedef VALENTA VALENT,*PVALENT; #define RegEnumKey RegEnumKeyA #define RegEnumKeyEx RegEnumKeyExA #define RegEnumValue RegEnumValueA -#if (_WIN32_WINNT >= 0x0600) +#if (_WIN32_WINNT >= 0x0502) #define RegGetValue RegGetValueA #endif #define RegLoadKey RegLoadKeyA #if (_WIN32_WINNT >= 0x0600) +#define RegLoadAppKey RegLoadAppKeyA #define RegLoadMUIString RegLoadMUIStringA #endif #define RegOpenKey RegOpenKeyA diff --git a/sdk/include/wine/ntlsa.h b/sdk/include/wine/ntlsa.h new file mode 100644 index 00000000000..9a0cf378c50 --- /dev/null +++ b/sdk/include/wine/ntlsa.h @@ -0,0 +1,22 @@ +/* + * Copyright 2017 Nikolay Sivov + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +NTSTATUS WINAPI LsaEnumerateAccounts(LSA_HANDLE,PLSA_ENUMERATION_HANDLE,PVOID*,ULONG,PULONG); +NTSTATUS WINAPI LsaLookupPrivilegeDisplayName(LSA_HANDLE policy, LSA_UNICODE_STRING *name, + LSA_UNICODE_STRING **display_name, SHORT *language); +NTSTATUS WINAPI LsaLookupPrivilegeName(LSA_HANDLE policy, LUID *value, LSA_UNICODE_STRING **name); diff --git a/sdk/include/wine/ntsecapi.h b/sdk/include/wine/ntsecapi.h new file mode 100644 index 00000000000..d01c04c6867 --- /dev/null +++ b/sdk/include/wine/ntsecapi.h @@ -0,0 +1,729 @@ +/* + * Copyright (C) 1999 Juergen Schmied + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef _NTSECAPI_ +#define _NTSECAPI_ + +#ifndef GUID_DEFINED +# include +#endif + +#ifdef __cplusplus +extern "C" { +#endif /* defined(__cplusplus) */ + +/* Policy access rights */ +#define POLICY_VIEW_LOCAL_INFORMATION __MSABI_LONG(0x00000001) +#define POLICY_VIEW_AUDIT_INFORMATION __MSABI_LONG(0x00000002) +#define POLICY_GET_PRIVATE_INFORMATION __MSABI_LONG(0x00000004) +#define POLICY_TRUST_ADMIN __MSABI_LONG(0x00000008) +#define POLICY_CREATE_ACCOUNT __MSABI_LONG(0x00000010) +#define POLICY_CREATE_SECRET __MSABI_LONG(0x00000020) +#define POLICY_CREATE_PRIVILEGE __MSABI_LONG(0x00000040) +#define POLICY_SET_DEFAULT_QUOTA_LIMITS __MSABI_LONG(0x00000080) +#define POLICY_SET_AUDIT_REQUIREMENTS __MSABI_LONG(0x00000100) +#define POLICY_AUDIT_LOG_ADMIN __MSABI_LONG(0x00000200) +#define POLICY_SERVER_ADMIN __MSABI_LONG(0x00000400) +#define POLICY_LOOKUP_NAMES __MSABI_LONG(0x00000800) +#define POLICY_NOTIFICATION __MSABI_LONG(0x00001000) + +#define POLICY_ALL_ACCESS ( \ + STANDARD_RIGHTS_REQUIRED | \ + POLICY_VIEW_LOCAL_INFORMATION | \ + POLICY_VIEW_AUDIT_INFORMATION | \ + POLICY_GET_PRIVATE_INFORMATION | \ + POLICY_TRUST_ADMIN | \ + POLICY_CREATE_ACCOUNT | \ + POLICY_CREATE_SECRET | \ + POLICY_CREATE_PRIVILEGE | \ + POLICY_SET_DEFAULT_QUOTA_LIMITS | \ + POLICY_SET_AUDIT_REQUIREMENTS | \ + POLICY_AUDIT_LOG_ADMIN | \ + POLICY_SERVER_ADMIN | \ + POLICY_LOOKUP_NAMES) + + +#define POLICY_READ ( \ + STANDARD_RIGHTS_READ | \ + POLICY_VIEW_AUDIT_INFORMATION | \ + POLICY_GET_PRIVATE_INFORMATION) + +#define POLICY_WRITE ( \ + STANDARD_RIGHTS_WRITE | \ + POLICY_TRUST_ADMIN | \ + POLICY_CREATE_ACCOUNT | \ + POLICY_CREATE_SECRET | \ + POLICY_CREATE_PRIVILEGE | \ + POLICY_SET_DEFAULT_QUOTA_LIMITS | \ + POLICY_SET_AUDIT_REQUIREMENTS | \ + POLICY_AUDIT_LOG_ADMIN | \ + POLICY_SERVER_ADMIN) + +#define POLICY_EXECUTE ( \ + STANDARD_RIGHTS_EXECUTE | \ + POLICY_VIEW_LOCAL_INFORMATION | \ + POLICY_LOOKUP_NAMES) + +#define POLICY_AUDIT_EVENT_UNCHANGED __MSABI_LONG(0x00000000) +#define POLICY_AUDIT_EVENT_SUCCESS __MSABI_LONG(0x00000001) +#define POLICY_AUDIT_EVENT_FAILURE __MSABI_LONG(0x00000002) +#define POLICY_AUDIT_EVENT_NONE __MSABI_LONG(0x00000004) + +#define POLICY_AUDIT_EVENT_MASK (POLICY_AUDIT_EVENT_SUCCESS | \ + POLICY_AUDIT_EVENT_FAILURE | \ + POLICY_AUDIT_EVENT_NONE) + +/* logon rights names */ +#define SE_BATCH_LOGON_NAME \ + TEXT("SeBatchLogonRight") +#define SE_INTERACTIVE_LOGON_NAME \ + TEXT("SeInteractiveLogonRight") +#define SE_NETWORK_LOGON_NAME \ + TEXT("SeNetworkLogonRight") +#define SE_REMOTE_INTERACTIVE_LOGON_NAME \ + TEXT("SeRemoteInteractiveLogonRight") +#define SE_SERVICE_LOGON_NAME \ + TEXT("SeServiceLogonRight") +#define SE_DENY_BATCH_LOGON_NAME \ + TEXT("SeDenyBatchLogonRight") +#define SE_DENY_INTERACTIVE_LOGON_NAME \ + TEXT("SeDenyInteractiveLogonRight") +#define SE_DENY_NETWORK_LOGON_NAME \ + TEXT("SeDenyNetworkLogonRight") +#define SE_DENY_REMOTE_INTERACTIVE_LOGON_NAME \ + TEXT("SeDenyRemoteInteractiveLogonRight") +#define SE_DENY_SERVICE_LOGON_NAME \ + TEXT("SeDenyServiceLogonRight") + +#ifndef WINE_NTSTATUS_DECLARED +#define WINE_NTSTATUS_DECLARED +typedef LONG NTSTATUS; +#endif +#ifndef WINE_PNTSTATUS_DECLARED +#define WINE_PNTSTATUS_DECLARED +typedef NTSTATUS *PNTSTATUS; +#endif + +typedef enum _SECURITY_LOGON_TYPE +{ + UndefinedLogonType = 0, + Interactive = 2, + Network, + Batch, + Service, + Proxy, + Unlock, + NetworkCleartext, + NewCredentials, + RemoteInteractive, + CachedInteractive, + CachedRemoteInteractive, + CachedUnlock +} SECURITY_LOGON_TYPE, *PSECURITY_LOGON_TYPE; + +typedef enum _POLICY_AUDIT_EVENT_TYPE +{ + AuditCategorySystem, + AuditCategoryLogon, + AuditCategoryObjectAccess, + AuditCategoryPrivilegeUse, + AuditCategoryDetailedTracking, + AuditCategoryPolicyChange, + AuditCategoryAccountManagement +} POLICY_AUDIT_EVENT_TYPE, *PPOLICY_AUDIT_EVENT_TYPE; + +#ifndef __STRING_DEFINED__ +#define __STRING_DEFINED__ +typedef struct _STRING { + USHORT Length; + USHORT MaximumLength; + PCHAR Buffer; +} STRING, *PSTRING; +#endif + +#ifndef __UNICODE_STRING_DEFINED__ +#define __UNICODE_STRING_DEFINED__ +typedef struct _UNICODE_STRING { + USHORT Length; /* bytes */ + USHORT MaximumLength; /* bytes */ + PWSTR Buffer; +} UNICODE_STRING, *PUNICODE_STRING; +#endif + +#ifndef __OBJECT_ATTRIBUTES_DEFINED__ +#define __OBJECT_ATTRIBUTES_DEFINED__ +typedef struct _OBJECT_ATTRIBUTES { + ULONG Length; + HANDLE RootDirectory; + PUNICODE_STRING ObjectName; + ULONG Attributes; + PVOID SecurityDescriptor; /* type SECURITY_DESCRIPTOR */ + PVOID SecurityQualityOfService; /* type SECURITY_QUALITY_OF_SERVICE */ +} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES; +#endif + +#ifndef __SECHANDLE_DEFINED__ +#define __SECHANDLE_DEFINED__ +typedef struct _SecHandle +{ + ULONG_PTR dwLower; + ULONG_PTR dwUpper; +} SecHandle, *PSecHandle; +#endif + +typedef UNICODE_STRING LSA_UNICODE_STRING, *PLSA_UNICODE_STRING; +typedef STRING LSA_STRING, *PLSA_STRING; + +#ifdef _NTDEF_ +typedef OBJECT_ATTRIBUTES LSA_OBJECT_ATTRIBUTES, *PLSA_OBJECT_ATTRIBUTES; +#else +typedef struct _LSA_OBJECT_ATTRIBUTES +{ + ULONG Length; + HANDLE RootDirectory; + PLSA_UNICODE_STRING ObjectName; + ULONG Attributes; + PVOID SecurityDescriptor; + PVOID SecurityQualityOfService; +} LSA_OBJECT_ATTRIBUTES, *PLSA_OBJECT_ATTRIBUTES; +#endif + + +typedef PVOID LSA_HANDLE, *PLSA_HANDLE; +typedef ULONG LSA_ENUMERATION_HANDLE, *PLSA_ENUMERATION_HANDLE; +typedef ULONG LSA_OPERATIONAL_MODE, *PLSA_OPERATIONAL_MODE; + +typedef enum +{ + PolicyAuditLogInformation = 1, + PolicyAuditEventsInformation, + PolicyPrimaryDomainInformation, + PolicyPdAccountInformation, + PolicyAccountDomainInformation, + PolicyLsaServerRoleInformation, + PolicyReplicaSourceInformation, + PolicyDefaultQuotaInformation, + PolicyModificationInformation, + PolicyAuditFullSetInformation, + PolicyAuditFullQueryInformation, + PolicyDnsDomainInformation +} POLICY_INFORMATION_CLASS, *PPOLICY_INFORMATION_CLASS; + +typedef ULONG POLICY_AUDIT_EVENT_OPTIONS, *PPOLICY_AUDIT_EVENT_OPTIONS; + +typedef struct _POLICY_AUDIT_EVENTS_INFO +{ + BOOLEAN AuditingMode; + PPOLICY_AUDIT_EVENT_OPTIONS EventAuditingOptions; + ULONG MaximumAuditEventCount; +} POLICY_AUDIT_EVENTS_INFO, *PPOLICY_AUDIT_EVENTS_INFO; + +typedef struct _POLICY_PRIMARY_DOMAIN_INFO +{ + LSA_UNICODE_STRING Name; + PSID Sid; +} POLICY_PRIMARY_DOMAIN_INFO, *PPOLICY_PRIMARY_DOMAIN_INFO; + +typedef struct _POLICY_ACCOUNT_DOMAIN_INFO +{ + LSA_UNICODE_STRING DomainName; + PSID DomainSid; +} POLICY_ACCOUNT_DOMAIN_INFO, *PPOLICY_ACCOUNT_DOMAIN_INFO; + +typedef struct _POLICY_DNS_DOMAIN_INFO +{ + LSA_UNICODE_STRING Name; + LSA_UNICODE_STRING DnsDomainName; + LSA_UNICODE_STRING DnsForestName; + GUID DomainGuid; + PSID Sid; +} POLICY_DNS_DOMAIN_INFO, *PPOLICY_DNS_DOMAIN_INFO; + +typedef enum _POLICY_LSA_SERVER_ROLE +{ + PolicyServerRoleBackup = 2, + PolicyServerRolePrimary +} POLICY_LSA_SERVER_ROLE, *PPOLICY_LSA_SERVER_ROLE; + +typedef struct _POLICY_LSA_SERVER_ROLE_INFO +{ + POLICY_LSA_SERVER_ROLE LsaServerRole; +} POLICY_LSA_SERVER_ROLE_INFO, *PPOLICY_LSA_SERVER_ROLE_INFO; + +typedef struct _POLICY_MODIFICATION_INFO +{ + LARGE_INTEGER ModifiedId; + LARGE_INTEGER DatabaseCreationTime; +} POLICY_MODIFICATION_INFO, *PPOLICY_MODIFICATION_INFO; + +typedef struct _LSA_LAST_INTER_LOGON_INFO { + LARGE_INTEGER LastSuccessfulLogon; + LARGE_INTEGER LastFailedLogon; + ULONG FailedAttemptCountSinceLastSuccessfulLogon; +} LSA_LAST_INTER_LOGON_INFO, *PLSA_LAST_INTER_LOGON_INFO; + +typedef struct _SECURITY_LOGON_SESSION_DATA { + ULONG Size; + LUID LogonId; + LSA_UNICODE_STRING UserName; + LSA_UNICODE_STRING LogonDomain; + LSA_UNICODE_STRING AuthenticationPackage; + ULONG LogonType; + ULONG Session; + PSID Sid; + LARGE_INTEGER LogonTime; + LSA_UNICODE_STRING LogonServer; + LSA_UNICODE_STRING DnsDomainName; + LSA_UNICODE_STRING Upn; + ULONG UserFlags; + LSA_LAST_INTER_LOGON_INFO LastLogonInfo; + LSA_UNICODE_STRING LogonScript; + LSA_UNICODE_STRING ProfilePath; + LSA_UNICODE_STRING HomeDirectory; + LSA_UNICODE_STRING HomeDirectoryDrive; + LARGE_INTEGER LogoffTime; + LARGE_INTEGER KickOffTime; + LARGE_INTEGER PasswordLastSet; + LARGE_INTEGER PasswordCanChange; + LARGE_INTEGER PasswordMustChange; +} SECURITY_LOGON_SESSION_DATA, *PSECURITY_LOGON_SESSION_DATA; + +typedef struct +{ + SID_NAME_USE Use; + LSA_UNICODE_STRING Name; + LONG DomainIndex; +} LSA_TRANSLATED_NAME, *PLSA_TRANSLATED_NAME; + +typedef struct +{ + LSA_UNICODE_STRING Name; + PSID Sid; +} LSA_TRUST_INFORMATION, *PLSA_TRUST_INFORMATION; + +typedef struct +{ + ULONG Entries; + PLSA_TRUST_INFORMATION Domains; +} LSA_REFERENCED_DOMAIN_LIST, *PLSA_REFERENCED_DOMAIN_LIST; + +typedef struct _LSA_TRANSLATED_SID +{ + SID_NAME_USE Use; + ULONG RelativeId; + LONG DomainIndex; +} LSA_TRANSLATED_SID, *PLSA_TRANSLATED_SID; + +typedef struct _TRUSTED_DOMAIN_INFORMATION_EX +{ + LSA_UNICODE_STRING Name; + LSA_UNICODE_STRING FlatName; + PSID Sid; + ULONG TrustDirection; + ULONG TrustType; + ULONG TrustAttributes; +} TRUSTED_DOMAIN_INFORMATION_EX, *PTRUSTED_DOMAIN_INFORMATION_EX; + +typedef struct _LSA_AUTH_INFORMATION +{ + LARGE_INTEGER LastUpdateTime; + ULONG AuthType; + ULONG AuthInfoLength; + PUCHAR AuthInfo; +} LSA_AUTH_INFORMATION, *PLSA_AUTH_INFORMATION; + +typedef struct _TRUSTED_DOMAIN_AUTH_INFORMATION +{ + ULONG IncomingAuthInfos; + PLSA_AUTH_INFORMATION IncomingAuthenticationInformation; + PLSA_AUTH_INFORMATION IncomingPreviousAuthenticationInformation; + ULONG OutgoingAuthInfos; + PLSA_AUTH_INFORMATION OutgoingAuthenticationInformation; + PLSA_AUTH_INFORMATION OutgoingPreviousAuthenticationInformation; +} TRUSTED_DOMAIN_AUTH_INFORMATION, *PTRUSTED_DOMAIN_AUTH_INFORMATION; + +typedef struct _LSA_TRANSLATED_SID2 +{ + SID_NAME_USE Use; + PSID Sid; + LONG DomainIndex; + ULONG Flags; +} LSA_TRANSLATED_SID2, *PLSA_TRANSLATED_SID2; + +typedef enum _TRUSTED_INFORMATION_CLASS +{ + TrustedDomainNameInformation = 1, + TrustedControllersInformation, + TrustedPosixOffsetInformation, + TrustedPasswordInformation, + TrustedDomainInformationBasic, + TrustedDomainInformationEx, + TrustedDomainAuthInformation, + TrustedDomainFullInformation +} TRUSTED_INFORMATION_CLASS, *PTRUSTED_INFORMATION_CLASS; + +typedef enum _POLICY_NOTIFICATION_INFORMATION_CLASS +{ + PolicyNotifyAuditEventsInformation = 1, + PolicyNotifyAccountDomainInformation, + PolicyNotifyServerRoleInformation, + PolicyNotifyDnsDomainInformation, + PolicyNotifyDomainEfsInformation, + PolicyNotifyDomainKerberosTicketInformation, + PolicyNotifyMachineAccountPasswordInformation +} POLICY_NOTIFICATION_INFORMATION_CLASS, *PPOLICY_NOTIFICATION_INFORMATION_CLASS; + +typedef struct _AUDIT_POLICY_INFORMATION +{ + GUID AuditSubCategoryGuid; + ULONG AuditingInformation; + GUID AuditCategoryGuid; +} AUDIT_POLICY_INFORMATION, *PAUDIT_POLICY_INFORMATION; + +enum NEGOTIATE_MESSAGES +{ + NegEnumPackagePrefixes, + NegGetCallerName, + NegTransferCredentials, + NegMsgReserved1, + NegCallPackageMax +}; + +typedef struct _NEGOTIATE_CALLER_NAME_REQUEST +{ + ULONG MessageType; + LUID LogonId; +} NEGOTIATE_CALLER_NAME_REQUEST, *PNEGOTIATE_CALLER_NAME_REQUEST; + +typedef struct _NEGOTIATE_CALLER_NAME_RESPONSE +{ + ULONG MessageType; + PWSTR CallerName; +} NEGOTIATE_CALLER_NAME_RESPONSE, *PNEGOTIATE_CALLER_NAME_RESPONSE; + +#define MICROSOFT_KERBEROS_NAME_A "Kerberos" +#if defined(_MSC_VER) || defined(__MINGW32__) +#define MICROSOFT_KERBEROS_NAME_W L"Kerberos" +#else /* _MSC_VER/__MINGW32__ */ +static const WCHAR MICROSOFT_KERBEROS_NAME_W[] = { 'K','e','r','b','e','r','o','s',0 }; +#endif + +#define KERB_TICKET_FLAGS_reserved 0x80000000 +#define KERB_TICKET_FLAGS_forwardable 0x40000000 +#define KERB_TICKET_FLAGS_forwarded 0x20000000 +#define KERB_TICKET_FLAGS_proxiable 0x10000000 +#define KERB_TICKET_FLAGS_proxy 0x08000000 +#define KERB_TICKET_FLAGS_may_postdate 0x04000000 +#define KERB_TICKET_FLAGS_postdated 0x02000000 +#define KERB_TICKET_FLAGS_invalid 0x01000000 +#define KERB_TICKET_FLAGS_renewable 0x00800000 +#define KERB_TICKET_FLAGS_initial 0x00400000 +#define KERB_TICKET_FLAGS_pre_authent 0x00200000 +#define KERB_TICKET_FLAGS_hw_authent 0x00100000 +#define KERB_TICKET_FLAGS_ok_as_delegate 0x00040000 +#define KERB_TICKET_FLAGS_name_canonicalize 0x00010000 +#define KERB_TICKET_FLAGS_cname_in_pa_data 0x00040000 +#define KERB_TICKET_FLAGS_reserved1 0x00000001 + +typedef enum _KERB_PROTOCOL_MESSAGE_TYPE +{ + KerbDebugRequestMessage = 0, + KerbQueryTicketCacheMessage, + KerbChangeMachinePasswordMessage, + KerbVerifyPacMessage, + KerbRetrieveTicketMessage, + KerbUpdateAddressesMessage, + KerbPurgeTicketCacheMessage, + KerbChangePasswordMessage, + KerbRetrieveEncodedTicketMessage, + KerbDecryptDataMessage, + KerbAddBindingCacheEntryMessage, + KerbSetPasswordMessage, + KerbSetPasswordExMessage, + KerbVerifyCredentialsMessage, + KerbQueryTicketCacheExMessage, + KerbPurgeTicketCacheExMessage, + KerbRefreshSmartcardCredentialsMessage, + KerbAddExtraCredentialsMessage, + KerbQuerySupplementalCredentialsMessage, + KerbTransferCredentialsMessage, + KerbQueryTicketCacheEx2Message, + KerbSubmitTicketMessage, + KerbAddExtraCredentialsExMessage, + KerbQueryKdcProxyCacheMessage, + KerbPurgeKdcProxyCacheMessage, + KerbQueryTicketCacheEx3Message, + KerbCleanupMachinePkinitCredsMessage, + KerbAddBindingCacheEntryExMessage, + KerbQueryBindingCacheMessage, + KerbPurgeBindingCacheMessage, + KerbQueryDomainExtendedPoliciesMessage, + KerbQueryS4U2ProxyCacheMessage +} KERB_PROTOCOL_MESSAGE_TYPE, *PKERB_PROTOCOL_MESSAGE_TYPE; + +typedef struct _KERB_TICKET_CACHE_INFO +{ + UNICODE_STRING ServerName; + UNICODE_STRING RealmName; + LARGE_INTEGER StartTime; + LARGE_INTEGER EndTime; + LARGE_INTEGER RenewTime; + LONG EncryptionType; + ULONG TicketFlags; +} KERB_TICKET_CACHE_INFO, *PKERB_TICKET_CACHE_INFO; + +typedef struct _KERB_TICKET_CACHE_INFO_EX +{ + UNICODE_STRING ClientName; + UNICODE_STRING ClientRealm; + + UNICODE_STRING ServerName; + UNICODE_STRING ServerRealm; + LARGE_INTEGER StartTime; + LARGE_INTEGER EndTime; + LARGE_INTEGER RenewTime; + LONG EncryptionType; + ULONG TicketFlags; +} KERB_TICKET_CACHE_INFO_EX, *PKERB_TICKET_CACHE_INFO_EX; + +typedef struct _KERB_TICKET_CACHE_INFO_EX2 +{ + UNICODE_STRING ClientName; + UNICODE_STRING ClientRealm; + UNICODE_STRING ServerName; + UNICODE_STRING ServerRealm; + LARGE_INTEGER StartTime; + LARGE_INTEGER EndTime; + LARGE_INTEGER RenewTime; + LONG EncryptionType; + ULONG TicketFlags; + + ULONG SessionKeyType; + ULONG BranchId; +} KERB_TICKET_CACHE_INFO_EX2, *PKERB_TICKET_CACHE_INFO_EX2; + +typedef struct _KERB_TICKET_CACHE_INFO_EX3 +{ + UNICODE_STRING ClientName; + UNICODE_STRING ClientRealm; + UNICODE_STRING ServerName; + UNICODE_STRING ServerRealm; + LARGE_INTEGER StartTime; + LARGE_INTEGER EndTime; + LARGE_INTEGER RenewTime; + LONG EncryptionType; + ULONG TicketFlags; + ULONG SessionKeyType; + ULONG BranchId; + + ULONG CacheFlags; + UNICODE_STRING KdcCalled; +} KERB_TICKET_CACHE_INFO_EX3, *PKERB_TICKET_CACHE_INFO_EX3; + +typedef struct _KERB_CRYPTO_KEY +{ + LONG KeyType; + ULONG Length; + PUCHAR Value; +} KERB_CRYPTO_KEY, *PKERB_CRYPTO_KEY; + +typedef struct _KERB_EXTERNAL_NAME +{ + SHORT NameType; + USHORT NameCount; + UNICODE_STRING Names[ANYSIZE_ARRAY]; +} KERB_EXTERNAL_NAME, *PKERB_EXTERNAL_NAME; + +typedef struct _KERB_EXTERNAL_TICKET +{ + PKERB_EXTERNAL_NAME ServiceName; + PKERB_EXTERNAL_NAME TargetName; + PKERB_EXTERNAL_NAME ClientName; + UNICODE_STRING DomainName; + UNICODE_STRING TargetDomainName; + UNICODE_STRING AltTargetDomainName; + KERB_CRYPTO_KEY SessionKey; + ULONG TicketFlags; + ULONG Flags; + LARGE_INTEGER KeyExpirationTime; + LARGE_INTEGER StartTime; + LARGE_INTEGER EndTime; + LARGE_INTEGER RenewUntil; + LARGE_INTEGER TimeSkew; + ULONG EncodedTicketSize; + PUCHAR EncodedTicket; +} KERB_EXTERNAL_TICKET, *PKERB_EXTERNAL_TICKET; + +typedef struct _KERB_QUERY_TKT_CACHE_REQUEST +{ + KERB_PROTOCOL_MESSAGE_TYPE MessageType; + LUID LogonId; +} KERB_QUERY_TKT_CACHE_REQUEST, *PKERB_QUERY_TKT_CACHE_REQUEST; + +typedef struct _KERB_QUERY_TKT_CACHE_RESPONSE +{ + KERB_PROTOCOL_MESSAGE_TYPE MessageType; + ULONG CountOfTickets; + KERB_TICKET_CACHE_INFO Tickets[ANYSIZE_ARRAY]; +} KERB_QUERY_TKT_CACHE_RESPONSE, *PKERB_QUERY_TKT_CACHE_RESPONSE; + +typedef struct _KERB_QUERY_TKT_CACHE_EX_RESPONSE +{ + KERB_PROTOCOL_MESSAGE_TYPE MessageType; + ULONG CountOfTickets; + KERB_TICKET_CACHE_INFO_EX Tickets[ANYSIZE_ARRAY]; +} KERB_QUERY_TKT_CACHE_EX_RESPONSE, *PKERB_QUERY_TKT_CACHE_EX_RESPONSE; + +typedef struct _KERB_QUERY_TKT_CACHE_EX2_RESPONSE +{ + KERB_PROTOCOL_MESSAGE_TYPE MessageType; + ULONG CountOfTickets; + KERB_TICKET_CACHE_INFO_EX2 Tickets[ANYSIZE_ARRAY]; +} KERB_QUERY_TKT_CACHE_EX2_RESPONSE, *PKERB_QUERY_TKT_CACHE_EX2_RESPONSE; + +typedef struct _KERB_QUERY_TKT_CACHE_EX3_RESPONSE +{ + KERB_PROTOCOL_MESSAGE_TYPE MessageType; + ULONG CountOfTickets; + KERB_TICKET_CACHE_INFO_EX3 Tickets[ANYSIZE_ARRAY]; +} KERB_QUERY_TKT_CACHE_EX3_RESPONSE, *PKERB_QUERY_TKT_CACHE_EX3_RESPONSE; + +typedef struct _KERB_RETRIEVE_TKT_REQUEST +{ + KERB_PROTOCOL_MESSAGE_TYPE MessageType; + LUID LogonId; + UNICODE_STRING TargetName; + ULONG TicketFlags; + ULONG CacheOptions; + LONG EncryptionType; + SecHandle CredentialsHandle; +} KERB_RETRIEVE_TKT_REQUEST, *PKERB_RETRIEVE_TKT_REQUEST; + +typedef struct _KERB_RETRIEVE_TKT_RESPONSE +{ + KERB_EXTERNAL_TICKET Ticket; +} KERB_RETRIEVE_TKT_RESPONSE,*PKERB_RETRIEVE_TKT_RESPONSE; + +typedef struct _KERB_PURGE_TKT_CACHE_REQUEST +{ + KERB_PROTOCOL_MESSAGE_TYPE MessageType; + LUID LogonId; + UNICODE_STRING ServerName; + UNICODE_STRING RealmName; +} KERB_PURGE_TKT_CACHE_REQUEST, *PKERB_PURGE_TKT_CACHE_REQUEST; + +#define KERB_ETYPE_NULL 0 +#define KERB_ETYPE_DES_CBC_CRC 1 +#define KERB_ETYPE_DES_CBC_MD4 2 +#define KERB_ETYPE_DES_CBC_MD5 3 +#define KERB_ETYPE_AES128_CTS_HMAC_SHA1_96 17 +#define KERB_ETYPE_AES256_CTS_HMAC_SHA1_96 18 + +#define KERB_ETYPE_RC4_MD4 -128 +#define KERB_ETYPE_RC4_PLAIN2 -129 +#define KERB_ETYPE_RC4_LM -130 +#define KERB_ETYPE_RC4_SHA -131 +#define KERB_ETYPE_DES_PLAIN -132 +#define KERB_ETYPE_RC4_HMAC_OLD -133 +#define KERB_ETYPE_RC4_PLAIN_OLD -134 +#define KERB_ETYPE_RC4_HMAC_OLD_EXP -135 +#define KERB_ETYPE_RC4_PLAIN_OLD_EXP -136 +#define KERB_ETYPE_RC4_PLAIN -140 +#define KERB_ETYPE_RC4_PLAIN_EXP -141 +#define KERB_ETYPE_AES128_CTS_HMAC_SHA1_96_PLAIN -148 +#define KERB_ETYPE_AES256_CTS_HMAC_SHA1_96_PLAIN -149 + +#define KERB_ETYPE_DSA_SHA1_CMS 9 +#define KERB_ETYPE_RSA_MD5_CMS 10 +#define KERB_ETYPE_RSA_SHA1_CMS 11 +#define KERB_ETYPE_RC2_CBC_ENV 12 +#define KERB_ETYPE_RSA_ENV 13 +#define KERB_ETYPE_RSA_ES_OEAP_ENV 14 +#define KERB_ETYPE_DES_EDE3_CBC_ENV 15 + +#define KERB_ETYPE_DSA_SIGN 8 +#define KERB_ETYPE_RSA_PRIV 9 +#define KERB_ETYPE_RSA_PUB 10 +#define KERB_ETYPE_RSA_PUB_MD5 11 +#define KERB_ETYPE_RSA_PUB_SHA1 12 +#define KERB_ETYPE_PKCS7_PUB 13 + +#define KERB_ETYPE_DES3_CBC_MD5 5 +#define KERB_ETYPE_DES3_CBC_SHA1 7 +#define KERB_ETYPE_DES3_CBC_SHA1_KD 16 + +#define KERB_ETYPE_DES_CBC_MD5_NT 20 +#define KERB_ETYPE_RC4_HMAC_NT 23 +#define KERB_ETYPE_RC4_HMAC_NT_EXP 24 + +#define RtlGenRandom SystemFunction036 +#define RtlEncryptMemory SystemFunction040 +#define RtlDecryptMemory SystemFunction041 + +#define LSA_SUCCESS(Error) ((LONG)(Error) >= 0) + +WINADVAPI BOOLEAN WINAPI AuditQuerySystemPolicy(const GUID*,ULONG,AUDIT_POLICY_INFORMATION**); +WINADVAPI BOOLEAN WINAPI RtlGenRandom(PVOID,ULONG); +WINADVAPI NTSTATUS WINAPI RtlEncryptMemory(PVOID,ULONG,ULONG); +WINADVAPI NTSTATUS WINAPI RtlDecryptMemory(PVOID,ULONG,ULONG); + +WINADVAPI NTSTATUS WINAPI LsaAddAccountRights(LSA_HANDLE,PSID,PLSA_UNICODE_STRING,ULONG); +WINADVAPI NTSTATUS WINAPI LsaClose(LSA_HANDLE); +WINADVAPI NTSTATUS WINAPI LsaCreateTrustedDomainEx(LSA_HANDLE,PTRUSTED_DOMAIN_INFORMATION_EX, + PTRUSTED_DOMAIN_AUTH_INFORMATION,ACCESS_MASK,PLSA_HANDLE); +WINADVAPI NTSTATUS WINAPI LsaDeleteTrustedDomain(LSA_HANDLE,PSID); +WINADVAPI NTSTATUS WINAPI LsaEnumerateAccountRights(LSA_HANDLE,PSID,PLSA_UNICODE_STRING*,PULONG); +WINADVAPI NTSTATUS WINAPI LsaEnumerateAccountsWithUserRight(LSA_HANDLE,PLSA_UNICODE_STRING,PVOID*,PULONG); +WINADVAPI NTSTATUS WINAPI LsaEnumerateTrustedDomains(LSA_HANDLE,PLSA_ENUMERATION_HANDLE,PVOID*,ULONG,PULONG); +WINADVAPI NTSTATUS WINAPI LsaEnumerateTrustedDomainsEx(LSA_HANDLE,PLSA_ENUMERATION_HANDLE,PVOID*,ULONG,PULONG); +WINADVAPI NTSTATUS WINAPI LsaFreeMemory(PVOID); +WINADVAPI NTSTATUS WINAPI LsaLookupNames(LSA_HANDLE,ULONG,PLSA_UNICODE_STRING,PLSA_REFERENCED_DOMAIN_LIST*, + PLSA_TRANSLATED_SID*); +WINADVAPI NTSTATUS WINAPI LsaLookupNames2(LSA_HANDLE,ULONG,ULONG,PLSA_UNICODE_STRING,PLSA_REFERENCED_DOMAIN_LIST*, + PLSA_TRANSLATED_SID2*); +WINADVAPI NTSTATUS WINAPI LsaLookupSids(LSA_HANDLE,ULONG,PSID *,PLSA_REFERENCED_DOMAIN_LIST *,PLSA_TRANSLATED_NAME *); +WINADVAPI ULONG WINAPI LsaNtStatusToWinError(NTSTATUS); +WINADVAPI NTSTATUS WINAPI LsaOpenPolicy(PLSA_UNICODE_STRING,PLSA_OBJECT_ATTRIBUTES,ACCESS_MASK,PLSA_HANDLE); +WINADVAPI NTSTATUS WINAPI LsaOpenTrustedDomainByName(LSA_HANDLE,PLSA_UNICODE_STRING,ACCESS_MASK,PLSA_HANDLE); +WINADVAPI NTSTATUS WINAPI LsaQueryInformationPolicy(LSA_HANDLE,POLICY_INFORMATION_CLASS,PVOID*); +WINADVAPI NTSTATUS WINAPI LsaQueryTrustedDomainInfo(LSA_HANDLE,PSID,TRUSTED_INFORMATION_CLASS,PVOID*); +WINADVAPI NTSTATUS WINAPI LsaQueryTrustedDomainInfoByName(LSA_HANDLE,PLSA_UNICODE_STRING,TRUSTED_INFORMATION_CLASS,PVOID*); +WINADVAPI NTSTATUS WINAPI LsaRegisterPolicyChangeNotification(POLICY_NOTIFICATION_INFORMATION_CLASS,HANDLE); +WINADVAPI NTSTATUS WINAPI LsaRemoveAccountRights(LSA_HANDLE,PSID,BOOLEAN,PLSA_UNICODE_STRING,ULONG); +WINADVAPI NTSTATUS WINAPI LsaRetrievePrivateData(LSA_HANDLE,PLSA_UNICODE_STRING,PLSA_UNICODE_STRING*); +WINADVAPI NTSTATUS WINAPI LsaSetInformationPolicy(LSA_HANDLE,POLICY_INFORMATION_CLASS,PVOID); +WINADVAPI NTSTATUS WINAPI LsaSetTrustedDomainInfoByName(LSA_HANDLE,PLSA_UNICODE_STRING,TRUSTED_INFORMATION_CLASS,PVOID); +WINADVAPI NTSTATUS WINAPI LsaSetTrustedDomainInformation(LSA_HANDLE,PSID,TRUSTED_INFORMATION_CLASS,PVOID); +WINADVAPI NTSTATUS WINAPI LsaStorePrivateData(LSA_HANDLE,PLSA_UNICODE_STRING,PLSA_UNICODE_STRING); +WINADVAPI NTSTATUS WINAPI LsaUnregisterPolicyChangeNotification(POLICY_NOTIFICATION_INFORMATION_CLASS,HANDLE); + +NTSTATUS WINAPI LsaCallAuthenticationPackage(HANDLE,ULONG,PVOID,ULONG,PVOID*,PULONG,PNTSTATUS); +NTSTATUS WINAPI LsaConnectUntrusted(PHANDLE); +NTSTATUS WINAPI LsaDeregisterLogonProcess(HANDLE); +NTSTATUS WINAPI LsaEnumerateLogonSessions(PULONG,PLUID*); +NTSTATUS WINAPI LsaFreeReturnBuffer(PVOID); +NTSTATUS WINAPI LsaGetLogonSessionData(PLUID,PSECURITY_LOGON_SESSION_DATA*); +NTSTATUS WINAPI LsaLogonUser(HANDLE,PLSA_STRING,SECURITY_LOGON_TYPE,ULONG,PVOID,ULONG,PTOKEN_GROUPS,PTOKEN_SOURCE,PVOID*,PULONG,PLUID,PHANDLE,PQUOTA_LIMITS,PNTSTATUS); +NTSTATUS WINAPI LsaLookupAuthenticationPackage(HANDLE,PLSA_STRING,PULONG); +NTSTATUS WINAPI LsaRegisterLogonProcess(PLSA_STRING,PHANDLE,PLSA_OPERATIONAL_MODE); + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* defined(__cplusplus) */ + +#endif /* !defined(_NTSECAPI_) */ diff --git a/sdk/include/wine/winsvc.h b/sdk/include/wine/winsvc.h new file mode 100644 index 00000000000..1580e3b86a4 --- /dev/null +++ b/sdk/include/wine/winsvc.h @@ -0,0 +1,457 @@ +/* + * Copyright (C) the Wine project + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_WINSVC_H +#define __WINE_WINSVC_H + +#ifdef __cplusplus +extern "C" { +#endif /* defined(__cplusplus) */ + +#ifndef WINADVAPI +#ifdef _ADVAPI32_ +#define WINADVAPI +#else +#define WINADVAPI DECLSPEC_IMPORT +#endif +#endif + +/* Service database names */ +#define SERVICES_ACTIVE_DATABASEA "ServicesActive" +#define SERVICES_FAILED_DATABASEA "ServicesFailed" + +#if defined(_MSC_VER) || defined(__MINGW32__) +# define SERVICES_ACTIVE_DATABASEW L"ServicesActive" +# define SERVICES_FAILED_DATABASEW L"ServicesFailed" +#else +static const WCHAR SERVICES_ACTIVE_DATABASEW[] = { 'S','e','r','v','i','c','e','s','A','c','t','i','v','e',0 }; +static const WCHAR SERVICES_FAILED_DATABASEW[] = { 'S','e','r','v','i','c','e','s','F','a','i','l','e','d',0 }; +#endif + +#define SERVICES_ACTIVE_DATABASE WINELIB_NAME_AW( SERVICES_ACTIVE_DATABASE ) +#define SERVICES_FAILED_DATABASE WINELIB_NAME_AW( SERVICES_FAILED_DATABASE ) + +/* Service State requests */ +#define SERVICE_ACTIVE 0x00000001 +#define SERVICE_INACTIVE 0x00000002 +#define SERVICE_STATE_ALL (SERVICE_ACTIVE | SERVICE_INACTIVE) + +/* Controls */ +#define SERVICE_CONTROL_STOP 0x00000001 +#define SERVICE_CONTROL_PAUSE 0x00000002 +#define SERVICE_CONTROL_CONTINUE 0x00000003 +#define SERVICE_CONTROL_INTERROGATE 0x00000004 +#define SERVICE_CONTROL_SHUTDOWN 0x00000005 +#define SERVICE_CONTROL_PARAMCHANGE 0x00000006 +#define SERVICE_CONTROL_NETBINDADD 0x00000007 +#define SERVICE_CONTROL_NETBINDREMOVE 0x00000008 +#define SERVICE_CONTROL_NETBINDENABLE 0x00000009 +#define SERVICE_CONTROL_NETBINDDISABLE 0x0000000A +#define SERVICE_CONTROL_DEVICEEVENT 0x0000000B +#define SERVICE_CONTROL_HARDWAREPROFILECHANGE 0x0000000C +#define SERVICE_CONTROL_POWEREVENT 0x0000000D +#define SERVICE_CONTROL_SESSIONCHANGE 0x0000000E +#define SERVICE_CONTROL_PRESHUTDOWN 0x0000000F + +/* Service State */ +#define SERVICE_STOPPED 0x00000001 +#define SERVICE_START_PENDING 0x00000002 +#define SERVICE_STOP_PENDING 0x00000003 +#define SERVICE_RUNNING 0x00000004 +#define SERVICE_CONTINUE_PENDING 0x00000005 +#define SERVICE_PAUSE_PENDING 0x00000006 +#define SERVICE_PAUSED 0x00000007 + +/* Controls Accepted */ +#define SERVICE_ACCEPT_STOP 0x00000001 +#define SERVICE_ACCEPT_PAUSE_CONTINUE 0x00000002 +#define SERVICE_ACCEPT_SHUTDOWN 0x00000004 +#define SERVICE_ACCEPT_PARAMCHANGE 0x00000008 +#define SERVICE_ACCEPT_NETBINDCHANGE 0x00000010 +#define SERVICE_ACCEPT_HARDWAREPROFILECHANGE 0x00000020 +#define SERVICE_ACCEPT_POWEREVENT 0x00000040 +#define SERVICE_ACCEPT_SESSIONCHANGE 0x00000080 +#define SERVICE_ACCEPT_PRESHUTDOWN 0x00000100 +#define SERVICE_ACCEPT_TIMECHANGE 0x00000200 +#define SERVICE_ACCEPT_TRIGGEREVENT 0x00000400 + +/* Service Control Manager Object access types */ +#define SC_MANAGER_CONNECT 0x0001 +#define SC_MANAGER_CREATE_SERVICE 0x0002 +#define SC_MANAGER_ENUMERATE_SERVICE 0x0004 +#define SC_MANAGER_LOCK 0x0008 +#define SC_MANAGER_QUERY_LOCK_STATUS 0x0010 +#define SC_MANAGER_MODIFY_BOOT_CONFIG 0x0020 +#define SC_MANAGER_ALL_ACCESS ( 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 ) + +#define SERVICE_QUERY_CONFIG 0x0001 +#define SERVICE_CHANGE_CONFIG 0x0002 +#define SERVICE_QUERY_STATUS 0x0004 +#define SERVICE_ENUMERATE_DEPENDENTS 0x0008 +#define SERVICE_START 0x0010 +#define SERVICE_STOP 0x0020 +#define SERVICE_PAUSE_CONTINUE 0x0040 +#define SERVICE_INTERROGATE 0x0080 +#define SERVICE_USER_DEFINED_CONTROL 0x0100 + +#define SERVICE_ALL_ACCESS ( 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 ) + +#define SERVICE_NO_CHANGE 0xffffffff + +#define SERVICE_RUNS_IN_SYSTEM_PROCESS 0x00000001 + +/* Handle types */ + +DECLARE_HANDLE(SC_HANDLE); +typedef SC_HANDLE *LPSC_HANDLE; +DECLARE_HANDLE(SERVICE_STATUS_HANDLE); +typedef LPVOID SC_LOCK; + +/* Service status structure */ + +typedef struct _SERVICE_STATUS { + DWORD dwServiceType; + DWORD dwCurrentState; + DWORD dwControlsAccepted; + DWORD dwWin32ExitCode; + DWORD dwServiceSpecificExitCode; + DWORD dwCheckPoint; + DWORD dwWaitHint; +} SERVICE_STATUS, *LPSERVICE_STATUS; + +/* Service status process structure */ + +typedef struct _SERVICE_STATUS_PROCESS +{ + DWORD dwServiceType; + DWORD dwCurrentState; + DWORD dwControlsAccepted; + DWORD dwWin32ExitCode; + DWORD dwServiceSpecificExitCode; + DWORD dwCheckPoint; + DWORD dwWaitHint; + DWORD dwProcessId; + DWORD dwServiceFlags; +} SERVICE_STATUS_PROCESS, *LPSERVICE_STATUS_PROCESS; + +#define SERVICE_NOTIFY_STATUS_CHANGE 2 + +#define SERVICE_NOTIFY_STOPPED 0x1 +#define SERVICE_NOTIFY_START_PENDING 0x2 +#define SERVICE_NOTIFY_STOP_PENDING 0x4 +#define SERVICE_NOTIFY_RUNNING 0x8 +#define SERVICE_NOTIFY_CONTINUE_PENDING 0x10 +#define SERVICE_NOTIFY_PAUSE_PENDING 0x20 +#define SERVICE_NOTIFY_PAUSED 0x40 +#define SERVICE_NOTIFY_CREATED 0x80 +#define SERVICE_NOTIFY_DELETED 0x100 +#define SERVICE_NOTIFY_DELETE_PENDING 0x200 + +typedef void (CALLBACK *PFN_SC_NOTIFY_CALLBACK)(void *); + +typedef struct _SERVICE_NOTIFY_2A { + DWORD dwVersion; + PFN_SC_NOTIFY_CALLBACK pfnNotifyCallback; + void *pContext; + DWORD dwNotificationStatus; + SERVICE_STATUS_PROCESS ServiceStatus; + DWORD dwNotificationTriggered; + char *pszServiceNames; +} SERVICE_NOTIFY_2A, SERVICE_NOTIFYA; + +typedef struct _SERVICE_NOTIFY_2W { + DWORD dwVersion; + PFN_SC_NOTIFY_CALLBACK pfnNotifyCallback; + void *pContext; + DWORD dwNotificationStatus; + SERVICE_STATUS_PROCESS ServiceStatus; + DWORD dwNotificationTriggered; + WCHAR *pszServiceNames; +} SERVICE_NOTIFY_2W, SERVICE_NOTIFYW; + +typedef enum _SC_STATUS_TYPE { + SC_STATUS_PROCESS_INFO = 0 +} SC_STATUS_TYPE; + +/* Service main function prototype */ + +typedef VOID (CALLBACK *LPSERVICE_MAIN_FUNCTIONA)(DWORD,LPSTR*); +typedef VOID (CALLBACK *LPSERVICE_MAIN_FUNCTIONW)(DWORD,LPWSTR*); +DECL_WINELIB_TYPE_AW(LPSERVICE_MAIN_FUNCTION) + +/* Service start table */ + +typedef struct _SERVICE_TABLE_ENTRYA { + LPSTR lpServiceName; + LPSERVICE_MAIN_FUNCTIONA lpServiceProc; +} SERVICE_TABLE_ENTRYA, *LPSERVICE_TABLE_ENTRYA; + +typedef struct _SERVICE_TABLE_ENTRYW { + LPWSTR lpServiceName; + LPSERVICE_MAIN_FUNCTIONW lpServiceProc; +} SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW; + +DECL_WINELIB_TYPE_AW(SERVICE_TABLE_ENTRY) +DECL_WINELIB_TYPE_AW(LPSERVICE_TABLE_ENTRY) + +/* Service status enumeration structure */ + +typedef struct _ENUM_SERVICE_STATUSA { + LPSTR lpServiceName; + LPSTR lpDisplayName; + SERVICE_STATUS ServiceStatus; +} ENUM_SERVICE_STATUSA, *LPENUM_SERVICE_STATUSA; + +typedef struct _ENUM_SERVICE_STATUSW { + LPWSTR lpServiceName; + LPWSTR lpDisplayName; + SERVICE_STATUS ServiceStatus; +} ENUM_SERVICE_STATUSW, *LPENUM_SERVICE_STATUSW; + +DECL_WINELIB_TYPE_AW(ENUM_SERVICE_STATUS) +DECL_WINELIB_TYPE_AW(LPENUM_SERVICE_STATUS) + +typedef struct _ENUM_SERVICE_STATUS_PROCESSA { + LPSTR lpServiceName; + LPSTR lpDisplayName; + SERVICE_STATUS_PROCESS ServiceStatusProcess; +} ENUM_SERVICE_STATUS_PROCESSA, *LPENUM_SERVICE_STATUS_PROCESSA; + +typedef struct _ENUM_SERVICE_STATUS_PROCESSW { + LPWSTR lpServiceName; + LPWSTR lpDisplayName; + SERVICE_STATUS_PROCESS ServiceStatusProcess; +} ENUM_SERVICE_STATUS_PROCESSW, *LPENUM_SERVICE_STATUS_PROCESSW; + +DECL_WINELIB_TYPE_AW(ENUM_SERVICE_STATUS_PROCESS) +DECL_WINELIB_TYPE_AW(LPENUM_SERVICE_STATUS_PROCESS) + +typedef enum _SC_ENUM_TYPE { + SC_ENUM_PROCESS_INFO = 0 +} SC_ENUM_TYPE; + +typedef struct _QUERY_SERVICE_CONFIGA { + DWORD dwServiceType; + DWORD dwStartType; + DWORD dwErrorControl; + LPSTR lpBinaryPathName; + LPSTR lpLoadOrderGroup; + DWORD dwTagId; + LPSTR lpDependencies; + LPSTR lpServiceStartName; + LPSTR lpDisplayName; +} QUERY_SERVICE_CONFIGA, *LPQUERY_SERVICE_CONFIGA; + +typedef struct _QUERY_SERVICE_CONFIGW { + DWORD dwServiceType; + DWORD dwStartType; + DWORD dwErrorControl; + LPWSTR lpBinaryPathName; + LPWSTR lpLoadOrderGroup; + DWORD dwTagId; + LPWSTR lpDependencies; + LPWSTR lpServiceStartName; + LPWSTR lpDisplayName; +} QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW; + +/* defines and structures for ChangeServiceConfig2 */ +#define SERVICE_CONFIG_DESCRIPTION 1 +#define SERVICE_CONFIG_FAILURE_ACTIONS 2 +#define SERVICE_CONFIG_DELAYED_AUTO_START_INFO 3 +#define SERVICE_CONFIG_FAILURE_ACTIONS_FLAG 4 +#define SERVICE_CONFIG_SERVICE_SID_INFO 5 +#define SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO 6 +#define SERVICE_CONFIG_PRESHUTDOWN_INFO 7 + + +typedef struct _SERVICE_DESCRIPTIONA { + LPSTR lpDescription; +} SERVICE_DESCRIPTIONA,*LPSERVICE_DESCRIPTIONA; + +typedef struct _SERVICE_DESCRIPTIONW { + LPWSTR lpDescription; +} SERVICE_DESCRIPTIONW,*LPSERVICE_DESCRIPTIONW; + +DECL_WINELIB_TYPE_AW(SERVICE_DESCRIPTION) +DECL_WINELIB_TYPE_AW(LPSERVICE_DESCRIPTION) + +typedef enum _SC_ACTION_TYPE { + SC_ACTION_NONE = 0, + SC_ACTION_RESTART = 1, + SC_ACTION_REBOOT = 2, + SC_ACTION_RUN_COMMAND = 3 +} SC_ACTION_TYPE; + +typedef struct _SC_ACTION { + SC_ACTION_TYPE Type; + DWORD Delay; +} SC_ACTION,*LPSC_ACTION; + +typedef struct _SERVICE_FAILURE_ACTIONSA { + DWORD dwResetPeriod; + LPSTR lpRebootMsg; + LPSTR lpCommand; + DWORD cActions; + SC_ACTION * lpsaActions; +} SERVICE_FAILURE_ACTIONSA,*LPSERVICE_FAILURE_ACTIONSA; + +typedef struct _SERVICE_FAILURE_ACTIONSW { + DWORD dwResetPeriod; + LPWSTR lpRebootMsg; + LPWSTR lpCommand; + DWORD cActions; + SC_ACTION * lpsaActions; +} SERVICE_FAILURE_ACTIONSW,*LPSERVICE_FAILURE_ACTIONSW; + +DECL_WINELIB_TYPE_AW(SERVICE_FAILURE_ACTIONS) +DECL_WINELIB_TYPE_AW(LPSERVICE_FAILURE_ACTIONS) + +typedef struct _SERVICE_DELAYED_AUTO_START_INFO { + BOOL fDelayedAutostart; +} SERVICE_DELAYED_AUTO_START_INFO,*LPSERVICE_DELAYED_AUTO_START_INFO; + +typedef struct _SERVICE_FAILURE_ACTIONS_FLAG { + BOOL fFailureActionsOnNonCrashFailures; +} SERVICE_FAILURE_ACTIONS_FLAG,*LPSERVICE_FAILURE_ACTIONS_FLAG; + +typedef struct _SERVICE_SID_INFO { + DWORD dwServiceSidType; +} SERVICE_SID_INFO,*LPSERVICE_SID_INFO; + +typedef struct _SERVICE_REQUIRED_PRIVILEGES_INFOA { + LPSTR pmszRequiredPrivileges; +} SERVICE_REQUIRED_PRIVILEGES_INFOA,*LPSERVICE_REQUIRED_PRIVILEGES_INFOA; + +typedef struct _SERVICE_REQUIRED_PRIVILEGES_INFOW { + LPWSTR pmszRequiredPrivileges; +} SERVICE_REQUIRED_PRIVILEGES_INFOW,*LPSERVICE_REQUIRED_PRIVILEGES_INFOW; + +DECL_WINELIB_TYPE_AW(SERVICE_REQUIRED_PRIVILEGES_INFO) +DECL_WINELIB_TYPE_AW(LPSERVICE_REQUIRED_PRIVILEGES_INFO) + +typedef struct _SERVICE_PRESHUTDOWN_INFO { + DWORD dwPreshutdownTimeout; +} SERVICE_PRESHUTDOWN_INFO,*LPSERVICE_PRESHUTDOWN_INFO; + +typedef struct _QUERY_SERVICE_LOCK_STATUSA +{ + DWORD fIsLocked; + LPSTR lpLockOwner; + DWORD dwLockDuration; +} QUERY_SERVICE_LOCK_STATUSA, *LPQUERY_SERVICE_LOCK_STATUSA; + +typedef struct _QUERY_SERVICE_LOCK_STATUSW +{ + DWORD fIsLocked; + LPWSTR lpLockOwner; + DWORD dwLockDuration; +} QUERY_SERVICE_LOCK_STATUSW, *LPQUERY_SERVICE_LOCK_STATUSW; + +DECL_WINELIB_TYPE_AW(QUERY_SERVICE_LOCK_STATUS) + +/* Service control handler function prototype */ + +typedef VOID (WINAPI *LPHANDLER_FUNCTION)(DWORD); +typedef DWORD (WINAPI *LPHANDLER_FUNCTION_EX)(DWORD,DWORD,LPVOID,LPVOID); + +/* API function prototypes */ + +WINADVAPI BOOL WINAPI ChangeServiceConfigA(SC_HANDLE,DWORD,DWORD,DWORD,LPCSTR,LPCSTR,LPDWORD,LPCSTR,LPCSTR,LPCSTR,LPCSTR); +WINADVAPI BOOL WINAPI ChangeServiceConfigW(SC_HANDLE,DWORD,DWORD,DWORD,LPCWSTR,LPCWSTR,LPDWORD,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR); +#define ChangeServiceConfig WINELIB_NAME_AW(ChangeServiceConfig) +WINADVAPI BOOL WINAPI ChangeServiceConfig2A(SC_HANDLE,DWORD,LPVOID); +WINADVAPI BOOL WINAPI ChangeServiceConfig2W(SC_HANDLE,DWORD,LPVOID); +#define ChangeServiceConfig2 WINELIB_NAME_AW(ChangeServiceConfig2) +WINADVAPI BOOL WINAPI CloseServiceHandle(SC_HANDLE); +WINADVAPI BOOL WINAPI ControlService(SC_HANDLE,DWORD,LPSERVICE_STATUS); +WINADVAPI SC_HANDLE WINAPI CreateServiceA(SC_HANDLE,LPCSTR,LPCSTR,DWORD,DWORD,DWORD,DWORD,LPCSTR,LPCSTR,LPDWORD,LPCSTR,LPCSTR,LPCSTR); +WINADVAPI SC_HANDLE WINAPI CreateServiceW(SC_HANDLE,LPCWSTR,LPCWSTR,DWORD,DWORD,DWORD,DWORD,LPCWSTR,LPCWSTR,LPDWORD,LPCWSTR,LPCWSTR,LPCWSTR); +#define CreateService WINELIB_NAME_AW(CreateService) +WINADVAPI BOOL WINAPI DeleteService(SC_HANDLE); +WINADVAPI BOOL WINAPI EnumDependentServicesA(SC_HANDLE,DWORD,LPENUM_SERVICE_STATUSA,DWORD,LPDWORD,LPDWORD); +WINADVAPI BOOL WINAPI EnumDependentServicesW(SC_HANDLE,DWORD,LPENUM_SERVICE_STATUSW,DWORD,LPDWORD,LPDWORD); +#define EnumDependentServices WINELIB_NAME_AW(EnumDependentServices) +WINADVAPI BOOL WINAPI EnumServicesStatusA(SC_HANDLE,DWORD,DWORD,LPENUM_SERVICE_STATUSA,DWORD,LPDWORD,LPDWORD,LPDWORD); +WINADVAPI BOOL WINAPI EnumServicesStatusW(SC_HANDLE,DWORD,DWORD,LPENUM_SERVICE_STATUSW,DWORD,LPDWORD,LPDWORD,LPDWORD); +#define EnumServicesStatus WINELIB_NAME_AW(EnumServicesStatus) +WINADVAPI BOOL WINAPI EnumServicesStatusExA(SC_HANDLE,SC_ENUM_TYPE,DWORD,DWORD,LPBYTE,DWORD,LPDWORD,LPDWORD,LPDWORD,LPCSTR); +WINADVAPI BOOL WINAPI EnumServicesStatusExW(SC_HANDLE,SC_ENUM_TYPE,DWORD,DWORD,LPBYTE,DWORD,LPDWORD,LPDWORD,LPDWORD,LPCWSTR); +#define EnumServicesStatus WINELIB_NAME_AW(EnumServicesStatus) +WINADVAPI BOOL WINAPI GetServiceDisplayNameA(SC_HANDLE,LPCSTR,LPSTR,LPDWORD); +WINADVAPI BOOL WINAPI GetServiceDisplayNameW(SC_HANDLE,LPCWSTR,LPWSTR,LPDWORD); +#define GetServiceDisplayName WINELIB_NAME_AW(GetServiceDisplayName) +WINADVAPI BOOL WINAPI GetServiceKeyNameA(SC_HANDLE,LPCSTR,LPSTR,LPDWORD); +WINADVAPI BOOL WINAPI GetServiceKeyNameW(SC_HANDLE,LPCWSTR,LPWSTR,LPDWORD); +#define GetServiceKeyName WINELIB_NAME_AW(GetServiceKeyName) +WINADVAPI SC_LOCK WINAPI LockServiceDatabase(SC_HANDLE); +WINADVAPI BOOL WINAPI NotifyBootConfigStatus(BOOL); +WINADVAPI DWORD WINAPI NotifyServiceStatusChangeW(SC_HANDLE,DWORD,SERVICE_NOTIFYW*); +WINADVAPI SC_HANDLE WINAPI OpenSCManagerA(LPCSTR,LPCSTR,DWORD); +WINADVAPI SC_HANDLE WINAPI OpenSCManagerW(LPCWSTR,LPCWSTR,DWORD); +#define OpenSCManager WINELIB_NAME_AW(OpenSCManager) +WINADVAPI SC_HANDLE WINAPI OpenServiceA(SC_HANDLE,LPCSTR,DWORD); +WINADVAPI SC_HANDLE WINAPI OpenServiceW(SC_HANDLE,LPCWSTR,DWORD); +#define OpenService WINELIB_NAME_AW(OpenService) +WINADVAPI BOOL WINAPI QueryServiceStatus(SC_HANDLE,LPSERVICE_STATUS); +WINADVAPI BOOL WINAPI QueryServiceStatusEx(SC_HANDLE,SC_STATUS_TYPE,LPBYTE,DWORD,LPDWORD); +WINADVAPI BOOL WINAPI QueryServiceConfigA(SC_HANDLE,LPQUERY_SERVICE_CONFIGA,DWORD,LPDWORD); +WINADVAPI BOOL WINAPI QueryServiceConfigW(SC_HANDLE,LPQUERY_SERVICE_CONFIGW,DWORD,LPDWORD); +#define QueryServiceConfig WINELIB_NAME_AW(QueryServiceConfig) +WINADVAPI BOOL WINAPI QueryServiceConfig2A(SC_HANDLE,DWORD,LPBYTE,DWORD,LPDWORD); +WINADVAPI BOOL WINAPI QueryServiceConfig2W(SC_HANDLE,DWORD,LPBYTE,DWORD,LPDWORD); +#define QueryServiceConfig2 WINELIB_NAME_AW(QueryServiceConfig2) +WINADVAPI BOOL WINAPI QueryServiceLockStatusA(SC_HANDLE,LPQUERY_SERVICE_LOCK_STATUSA,DWORD,LPDWORD); +WINADVAPI BOOL WINAPI QueryServiceLockStatusW(SC_HANDLE,LPQUERY_SERVICE_LOCK_STATUSW,DWORD,LPDWORD); +#define QueryServiceLockStatus WINELIB_NAME_AW(QueryServiceLockStatus) +WINADVAPI BOOL WINAPI QueryServiceObjectSecurity(SC_HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,DWORD,LPDWORD); +WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerA(LPCSTR,LPHANDLER_FUNCTION); +WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerW(LPCWSTR,LPHANDLER_FUNCTION); +#define RegisterServiceCtrlHandler WINELIB_NAME_AW(RegisterServiceCtrlHandler) +WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExA(LPCSTR,LPHANDLER_FUNCTION_EX,LPVOID); +WINADVAPI SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExW(LPCWSTR,LPHANDLER_FUNCTION_EX,LPVOID); +#define RegisterServiceCtrlHandlerEx WINELIB_NAME_AW(RegisterServiceCtrlHandlerEx) +WINADVAPI BOOL WINAPI SetServiceObjectSecurity(SC_HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR); +WINADVAPI BOOL WINAPI SetServiceStatus(SERVICE_STATUS_HANDLE,LPSERVICE_STATUS); +WINADVAPI BOOL WINAPI StartServiceA(SC_HANDLE,DWORD,LPCSTR*); +WINADVAPI BOOL WINAPI StartServiceW(SC_HANDLE,DWORD,LPCWSTR*); +#define StartService WINELIB_NAME_AW(StartService) +WINADVAPI BOOL WINAPI StartServiceCtrlDispatcherA(const SERVICE_TABLE_ENTRYA*); +WINADVAPI BOOL WINAPI StartServiceCtrlDispatcherW(const SERVICE_TABLE_ENTRYW*); +#define StartServiceCtrlDispatcher WINELIB_NAME_AW(StartServiceCtrlDispatcher) +WINADVAPI BOOL WINAPI UnlockServiceDatabase(SC_LOCK); + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* defined(__cplusplus) */ + +#endif /* !defined(__WINE_WINSVC_H) */ diff --git a/sdk/include/xdk/winnt_old.h b/sdk/include/xdk/winnt_old.h index 3e9772a8d8c..d8cbcb88546 100644 --- a/sdk/include/xdk/winnt_old.h +++ b/sdk/include/xdk/winnt_old.h @@ -376,7 +376,11 @@ #define PROCESS_QUERY_INFORMATION 1024 #define PROCESS_SUSPEND_RESUME 2048 #define PROCESS_QUERY_LIMITED_INFORMATION 0x1000 +#if (NTDDI_VERSION >= NTDDI_VISTA) +#define PROCESS_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0xFFFF) +#else #define PROCESS_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0xFFF) +#endif #define PROCESS_DUP_HANDLE 64 #define THREAD_TERMINATE 1 #define THREAD_SUSPEND_RESUME 2