From 435482912c6dc0aaa4371e37b7336b2b1291e65f Mon Sep 17 00:00:00 2001 From: "Carl J. Bialorucki" Date: Thu, 25 Sep 2025 17:54:18 -0500 Subject: [PATCH] [PSDK][INCLUDE/WINE] Header changes needed for iphlpapi, shlwapi, advapi32, and kernel32 winetest syncs (#8317) - [INCLUDE/WINE] Add synced Wine headers for the iphlpapi winetest to use. This helps us slowly decouple our headers and wine's headers. - [PSDK] Add definitions we are missing for other winetest syncs. - [WINETESTS][APITESTS] Fix breaking changes, remove duplicate definitions for debugstr_guid. --- dll/win32/kernelbase/wine/main.c | 5 + dll/win32/wbemprox/builtin.c | 4 +- modules/rostests/apitests/setupapi/devclass.c | 20 - .../rostests/winetests/mscoree/debugging.c | 15 - modules/rostests/winetests/ole32/ole_server.c | 15 - sdk/include/psdk/accctrl.h | 3 +- sdk/include/psdk/appmodel.h | 26 + sdk/include/psdk/delayloadhandler.h | 1 + sdk/include/psdk/iptypes.h | 413 +++++---- sdk/include/psdk/minwinbase.h | 4 + sdk/include/psdk/perflib.h | 2 +- sdk/include/psdk/processthreadsapi.h | 17 + sdk/include/psdk/shlwapi.h | 17 + sdk/include/psdk/tcpestats.h | 216 +++++ sdk/include/psdk/tcpmib.h | 273 +++--- sdk/include/psdk/udpmib.h | 187 +++- sdk/include/psdk/winbase.h | 34 + sdk/include/psdk/winnls.h | 95 +- sdk/include/psdk/winreg.h | 7 + sdk/include/psdk/winsvc.h | 6 + sdk/include/wine/iphlpapi.h | 165 ++++ sdk/include/wine/iptypes.h | 335 +++++++ sdk/include/wine/netioapi.h | 288 ++++++ sdk/include/wine/tcpestats.h | 37 + sdk/include/wine/tcpmib.h | 230 +++++ sdk/include/wine/test.h | 1 + sdk/include/wine/udpmib.h | 136 +++ sdk/include/wine/windns.h | 828 ++++++++++++++++++ 28 files changed, 2981 insertions(+), 399 deletions(-) create mode 100644 sdk/include/psdk/tcpestats.h create mode 100644 sdk/include/wine/iphlpapi.h create mode 100644 sdk/include/wine/iptypes.h create mode 100644 sdk/include/wine/netioapi.h create mode 100644 sdk/include/wine/tcpestats.h create mode 100644 sdk/include/wine/tcpmib.h create mode 100644 sdk/include/wine/udpmib.h create mode 100644 sdk/include/wine/windns.h diff --git a/dll/win32/kernelbase/wine/main.c b/dll/win32/kernelbase/wine/main.c index 60173ba6513..74a93231514 100644 --- a/dll/win32/kernelbase/wine/main.c +++ b/dll/win32/kernelbase/wine/main.c @@ -178,8 +178,13 @@ static struct perf_provider *perf_provider_from_handle(HANDLE prov) /*********************************************************************** * PerfCreateInstance (KERNELBASE.@) */ +#ifdef __REACTOS__ +PERF_COUNTERSET_INSTANCE * WINAPI PerfCreateInstance( HANDLE handle, const GUID *guid, + const WCHAR *name, ULONG id ) +#else PERF_COUNTERSET_INSTANCE WINAPI *PerfCreateInstance( HANDLE handle, const GUID *guid, const WCHAR *name, ULONG id ) +#endif { struct perf_provider *prov = perf_provider_from_handle( handle ); struct counterset_template *template; diff --git a/dll/win32/wbemprox/builtin.c b/dll/win32/wbemprox/builtin.c index 4b92f2809d6..120ca9e1fc2 100644 --- a/dll/win32/wbemprox/builtin.c +++ b/dll/win32/wbemprox/builtin.c @@ -3375,11 +3375,11 @@ static enum fill_status fill_networkadapterconfig( struct table *table, const st DWORD size = 0, ret; enum fill_status status = FILL_STATUS_UNFILTERED; - ret = GetAdaptersAddresses( AF_UNSPEC, GAA_FLAG_INCLUDE_ALL_GATEWAYS, NULL, NULL, &size ); + ret = GetAdaptersAddresses( AF_UNSPEC, GAA_FLAG_INCLUDE_GATEWAYS, NULL, NULL, &size ); if (ret != ERROR_BUFFER_OVERFLOW) return FILL_STATUS_FAILED; if (!(buffer = heap_alloc( size ))) return FILL_STATUS_FAILED; - if (GetAdaptersAddresses( AF_UNSPEC, GAA_FLAG_INCLUDE_ALL_GATEWAYS, NULL, buffer, &size )) + if (GetAdaptersAddresses( AF_UNSPEC, GAA_FLAG_INCLUDE_GATEWAYS, NULL, buffer, &size )) { heap_free( buffer ); return FILL_STATUS_FAILED; diff --git a/modules/rostests/apitests/setupapi/devclass.c b/modules/rostests/apitests/setupapi/devclass.c index 2b3d5699738..0674bc99364 100644 --- a/modules/rostests/apitests/setupapi/devclass.c +++ b/modules/rostests/apitests/setupapi/devclass.c @@ -39,26 +39,6 @@ static GUID test_class_guid = { 0x4d36e967, 0xe325, 0x11ce, { 0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18 } }; static char test_class_name[MAX_CLASS_NAME_LEN] = "DiskDrive"; -static const char *debugstr_guid(const GUID *guid) -{ - static char guidSTR1[39]; - static char guidSTR2[39]; - char* guidSTR; - static BOOL index; - - if (!guid) return NULL; - - index = !index; - guidSTR = index ? guidSTR1 : guidSTR2; - - snprintf(guidSTR, sizeof(guidSTR1), - "{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}", - guid->Data1, guid->Data2, guid->Data3, - guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3], - guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]); - return guidSTR; -} - static void test_SetupDiBuildClassInfoList(void) { LPGUID guid_list = NULL; diff --git a/modules/rostests/winetests/mscoree/debugging.c b/modules/rostests/winetests/mscoree/debugging.c index bd961edc5d4..020ee392a4e 100644 --- a/modules/rostests/winetests/mscoree/debugging.c +++ b/modules/rostests/winetests/mscoree/debugging.c @@ -36,21 +36,6 @@ static HRESULT (WINAPI *pCreateDebuggingInterfaceFromVersion)(int, LPCWSTR, IUnk const WCHAR v2_0[] = {'v','2','.','0','.','5','0','7','2','7',0}; -static const char *debugstr_guid(REFIID riid) -{ - static char buf[50]; - - if(!riid) - return "(null)"; - - sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", - riid->Data1, riid->Data2, riid->Data3, riid->Data4[0], - riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4], - riid->Data4[5], riid->Data4[6], riid->Data4[7]); - - return buf; -} - static HRESULT WINAPI ManagedCallback2_QueryInterface(ICorDebugManagedCallback2 *iface, REFIID riid, void **ppv) { if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_ICorDebugManagedCallback2, riid)) diff --git a/modules/rostests/winetests/ole32/ole_server.c b/modules/rostests/winetests/ole32/ole_server.c index 83f7c660dbb..cee33c29726 100644 --- a/modules/rostests/winetests/ole32/ole_server.c +++ b/modules/rostests/winetests/ole32/ole_server.c @@ -60,21 +60,6 @@ static const struct static LONG obj_ref, class_ref, server_locks; -static const char *debugstr_guid(const GUID *guid) -{ - int i; - - if (!guid) return "(null)"; - - for (i = 0; i < ARRAY_SIZE(guid_name); i++) - { - if (IsEqualIID(guid, guid_name[i].guid)) - return guid_name[i].name; - } - - return wine_dbgstr_guid(guid); -} - /******************************* OLE server *******************************/ typedef struct { diff --git a/sdk/include/psdk/accctrl.h b/sdk/include/psdk/accctrl.h index 92124de363b..ca1283e13ad 100644 --- a/sdk/include/psdk/accctrl.h +++ b/sdk/include/psdk/accctrl.h @@ -168,7 +168,8 @@ typedef enum _SE_OBJECT_TYPE SE_DS_OBJECT_ALL, SE_PROVIDER_DEFINED_OBJECT, SE_WMIGUID_OBJECT, - SE_REGISTRY_WOW64_32KEY + SE_REGISTRY_WOW64_32KEY, + SE_REGISTRY_WOW64_64KEY } SE_OBJECT_TYPE; typedef enum _TRUSTEE_TYPE diff --git a/sdk/include/psdk/appmodel.h b/sdk/include/psdk/appmodel.h index 67bb5936192..be0d1058227 100644 --- a/sdk/include/psdk/appmodel.h +++ b/sdk/include/psdk/appmodel.h @@ -37,6 +37,32 @@ typedef enum AppPolicyWindowingModel AppPolicyWindowingModel_ClassicPhone = 3 } AppPolicyWindowingModel; +typedef struct PACKAGE_VERSION +{ + union + { + UINT64 Version; + struct + { + USHORT Revision; + USHORT Build; + USHORT Minor; + USHORT Major; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PACKAGE_VERSION; + +typedef struct PACKAGE_ID +{ + UINT32 reserved; + UINT32 processorArchitecture; + PACKAGE_VERSION version; + PWSTR name; + PWSTR publisher; + PWSTR resourceId; + PWSTR publisherId; +} PACKAGE_ID; + WINBASEAPI _Check_return_ _Success_(return == ERROR_SUCCESS) diff --git a/sdk/include/psdk/delayloadhandler.h b/sdk/include/psdk/delayloadhandler.h index 06b658990c4..e8336111ff7 100644 --- a/sdk/include/psdk/delayloadhandler.h +++ b/sdk/include/psdk/delayloadhandler.h @@ -47,6 +47,7 @@ typedef struct _DELAYLOAD_INFO } DELAYLOAD_INFO, *PDELAYLOAD_INFO; typedef PVOID (WINAPI *PDELAYLOAD_FAILURE_DLL_CALLBACK)(ULONG, PDELAYLOAD_INFO); +typedef PVOID (WINAPI *PDELAYLOAD_FAILURE_SYSTEM_ROUTINE)(LPCSTR, LPCSTR); #ifdef __cplusplus } diff --git a/sdk/include/psdk/iptypes.h b/sdk/include/psdk/iptypes.h index 256c6752174..c1096b3dfef 100644 --- a/sdk/include/psdk/iptypes.h +++ b/sdk/include/psdk/iptypes.h @@ -1,23 +1,12 @@ -/* WINE iptypes.h - * Copyright (C) 2003 Juan Lang - * - * 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 +/* + * PROJECT: ReactOS PSDK + * LICENSE: MIT (https://spdx.org/licenses/MIT) + * PURPOSE: IP Types Header + * COPYRIGHT: Copyright 2025 Carl Bialorucki */ -#ifndef WINE_IPTYPES_H_ -#define WINE_IPTYPES_H_ +#ifndef IP_TYPES_INCLUDED +#define IP_TYPES_INCLUDED #include #include @@ -33,24 +22,24 @@ #define MAX_DHCPV6_DUID_LENGTH 130 #define MAX_DNS_SUFFIX_STRING_LENGTH 256 -#define BROADCAST_NODETYPE 1 -#define PEER_TO_PEER_NODETYPE 2 -#define MIXED_NODETYPE 4 -#define HYBRID_NODETYPE 8 +#define BROADCAST_NODETYPE 1 +#define PEER_TO_PEER_NODETYPE 2 +#define MIXED_NODETYPE 4 +#define HYBRID_NODETYPE 8 typedef struct { char String[4 * 4]; } IP_ADDRESS_STRING, *PIP_ADDRESS_STRING, IP_MASK_STRING, *PIP_MASK_STRING; typedef struct _IP_ADDR_STRING { - struct _IP_ADDR_STRING* Next; + struct _IP_ADDR_STRING *Next; IP_ADDRESS_STRING IpAddress; IP_MASK_STRING IpMask; DWORD Context; } IP_ADDR_STRING, *PIP_ADDR_STRING; typedef struct _IP_ADAPTER_INFO { - struct _IP_ADAPTER_INFO* Next; + struct _IP_ADAPTER_INFO *Next; DWORD ComboIndex; char AdapterName[MAX_ADAPTER_NAME_LENGTH + 4]; char Description[MAX_ADAPTER_DESCRIPTION_LENGTH + 4]; @@ -70,12 +59,16 @@ typedef struct _IP_ADAPTER_INFO { time_t LeaseExpires; } IP_ADAPTER_INFO, *PIP_ADAPTER_INFO; -typedef struct _IP_PER_ADAPTER_INFO { +typedef struct _IP_PER_ADAPTER_INFO_W2KSP1 { UINT AutoconfigEnabled; UINT AutoconfigActive; PIP_ADDR_STRING CurrentDnsServer; IP_ADDR_STRING DnsServerList; -} IP_PER_ADAPTER_INFO, *PIP_PER_ADAPTER_INFO; +} IP_PER_ADAPTER_INFO_W2KSP1, *PIP_PER_ADAPTER_INFO_W2KSP1; +#if (NTDDI_VERSION >= NTDDI_WIN2KSP1) +typedef IP_PER_ADAPTER_INFO_W2KSP1 IP_PER_ADAPTER_INFO; +typedef IP_PER_ADAPTER_INFO_W2KSP1 *PIP_PER_ADAPTER_INFO; +#endif typedef struct { char HostName[MAX_HOSTNAME_LEN + 4] ; @@ -87,91 +80,134 @@ typedef struct { UINT EnableRouting; UINT EnableProxy; UINT EnableDns; -} FIXED_INFO, *PFIXED_INFO; +} FIXED_INFO_W2KSP1, *PFIXED_INFO_W2KSP1; +#if (NTDDI_VERSION >= NTDDI_WIN2KSP1) +typedef FIXED_INFO_W2KSP1 FIXED_INFO; +typedef FIXED_INFO_W2KSP1 *PFIXED_INFO; +#endif + +#ifdef _WINSOCK2API_ typedef NL_PREFIX_ORIGIN IP_PREFIX_ORIGIN; typedef NL_SUFFIX_ORIGIN IP_SUFFIX_ORIGIN; typedef NL_DAD_STATE IP_DAD_STATE; -/* ReactOS */ -#if (NTDDI_VERSION >= NTDDI_WIN2KSP1) -typedef struct _IP_INTERFACE_NAME_INFO { - ULONG Index; - ULONG MediaType; - UCHAR ConnectionType; - UCHAR AccessType; - GUID DeviceGuid; - GUID InterfaceGuid; -} IP_INTERFACE_NAME_INFO, *PIP_INTERFACE_NAME_INFO; +#define IP_ADAPTER_ADDRESS_DNS_ELIGIBLE 1 +#define IP_ADAPTER_ADDRESS_TRANSIENT 2 + +#define IP_ADAPTER_DDNS_ENABLED 0x0001 +#define IP_ADAPTER_REGISTER_ADAPTER_SUFFIX 0x0002 +#define IP_ADAPTER_DHCP_ENABLED 0x0004 +#define IP_ADAPTER_RECEIVE_ONLY 0x0008 +#define IP_ADAPTER_NO_MULTICAST 0x0010 +#define IP_ADAPTER_IPV6_OTHER_STATEFUL_CONFIG 0x0020 +#define IP_ADAPTER_NETBIOS_OVER_TCPIP_ENABLED 0x0040 +#define IP_ADAPTER_IPV4_ENABLED 0x0080 +#define IP_ADAPTER_IPV6_ENABLED 0x0100 +#define IP_ADAPTER_IPV6_MANAGE_ADDRESS_CONFIG 0x0200 + +#define GAA_FLAG_SKIP_UNICAST 0x0001 +#define GAA_FLAG_SKIP_ANYCAST 0x0002 +#define GAA_FLAG_SKIP_MULTICAST 0x0004 +#define GAA_FLAG_SKIP_DNS_SERVER 0x0008 +#define GAA_FLAG_INCLUDE_PREFIX 0x0010 +#define GAA_FLAG_SKIP_FRIENDLY_NAME 0x0020 +#define GAA_FLAG_INCLUDE_WINS_INFO 0x0040 +#define GAA_FLAG_INCLUDE_GATEWAYS 0x0080 +#define GAA_FLAG_INCLUDE_ALL_INTERFACES 0x0100 +#define GAA_FLAG_INCLUDE_ALL_COMPARTMENTS 0x0200 +#define GAA_FLAG_INCLUDE_TUNNEL_BINDINGORDER 0x0400 + +typedef struct _IP_ADAPTER_UNICAST_ADDRESS_LH { + union { + struct { + ULONG Length; + DWORD Flags; + }; + }; + struct _IP_ADAPTER_UNICAST_ADDRESS_LH *Next; + SOCKET_ADDRESS Address; + IP_PREFIX_ORIGIN PrefixOrigin; + IP_SUFFIX_ORIGIN SuffixOrigin; + IP_DAD_STATE DadState; + ULONG ValidLifetime; + ULONG PreferredLifetime; + ULONG LeaseLifetime; + UINT8 OnLinkPrefixLength; +} IP_ADAPTER_UNICAST_ADDRESS_LH, *PIP_ADAPTER_UNICAST_ADDRESS_LH; + +typedef struct _IP_ADAPTER_UNICAST_ADDRESS_XP { + union { + struct { + ULONG Length; + DWORD Flags; + }; + }; + struct _IP_ADAPTER_UNICAST_ADDRESS_XP *Next; + SOCKET_ADDRESS Address; + IP_PREFIX_ORIGIN PrefixOrigin; + IP_SUFFIX_ORIGIN SuffixOrigin; + IP_DAD_STATE DadState; + ULONG ValidLifetime; + ULONG PreferredLifetime; + ULONG LeaseLifetime; +} IP_ADAPTER_UNICAST_ADDRESS_XP, *PIP_ADAPTER_UNICAST_ADDRESS_XP; + +#if defined(__REACTOS__) || (NTDDI_VERSION >= NTDDI_VISTA) +typedef IP_ADAPTER_UNICAST_ADDRESS_LH IP_ADAPTER_UNICAST_ADDRESS; +typedef IP_ADAPTER_UNICAST_ADDRESS_LH *PIP_ADAPTER_UNICAST_ADDRESS; +#elif (NTDDI_VERSION >= NTDDI_WINXP) +typedef IP_ADAPTER_UNICAST_ADDRESS_XP IP_ADAPTER_UNICAST_ADDRESS; +typedef IP_ADAPTER_UNICAST_ADDRESS_XP *PIP_ADAPTER_UNICAST_ADDRESS; #endif -#ifdef _WINSOCK2API_ - -typedef struct _IP_ADAPTER_UNICAST_ADDRESS { - union { - struct { - ULONG Length; - DWORD Flags; - } DUMMYSTRUCTNAME; - } DUMMYUNIONNAME; - struct _IP_ADAPTER_UNICAST_ADDRESS *Next; - SOCKET_ADDRESS Address; - IP_PREFIX_ORIGIN PrefixOrigin; - IP_SUFFIX_ORIGIN SuffixOrigin; - IP_DAD_STATE DadState; - ULONG ValidLifetime; - ULONG PreferredLifetime; - ULONG LeaseLifetime; -} IP_ADAPTER_UNICAST_ADDRESS, *PIP_ADAPTER_UNICAST_ADDRESS; - -typedef struct _IP_ADAPTER_ANYCAST_ADDRESS { +typedef struct _IP_ADAPTER_ANYCAST_ADDRESS_XP { union { ULONGLONG Alignment; struct { ULONG Length; DWORD Flags; - } DUMMYSTRUCTNAME; - } DUMMYUNIONNAME; + }; + }; struct _IP_ADAPTER_ANYCAST_ADDRESS *Next; - SOCKET_ADDRESS Address; -} IP_ADAPTER_ANYCAST_ADDRESS, *PIP_ADAPTER_ANYCAST_ADDRESS; + SOCKET_ADDRESS Address; +} IP_ADAPTER_ANYCAST_ADDRESS_XP, *PIP_ADAPTER_ANYCAST_ADDRESS_XP; +#if (NTDDI_VERSION >= NTDDI_WINXP) +typedef IP_ADAPTER_ANYCAST_ADDRESS_XP IP_ADAPTER_ANYCAST_ADDRESS; +typedef IP_ADAPTER_ANYCAST_ADDRESS_XP *PIP_ADAPTER_ANYCAST_ADDRESS; +#endif -typedef struct _IP_ADAPTER_MULTICAST_ADDRESS { +typedef struct _IP_ADAPTER_MULTICAST_ADDRESS_XP { union { ULONGLONG Alignment; struct { ULONG Length; DWORD Flags; - } DUMMYSTRUCTNAME; - } DUMMYUNIONNAME; + }; + }; struct _IP_ADAPTER_MULTICAST_ADDRESS *Next; - SOCKET_ADDRESS Address; -} IP_ADAPTER_MULTICAST_ADDRESS, *PIP_ADAPTER_MULTICAST_ADDRESS; + SOCKET_ADDRESS Address; +} IP_ADAPTER_MULTICAST_ADDRESS_XP, *PIP_ADAPTER_MULTICAST_ADDRESS_XP; +#if (NTDDI_VERSION >= NTDDI_WINXP) +typedef IP_ADAPTER_MULTICAST_ADDRESS_XP IP_ADAPTER_MULTICAST_ADDRESS; +typedef IP_ADAPTER_MULTICAST_ADDRESS_XP *PIP_ADAPTER_MULTICAST_ADDRESS; +#endif -typedef struct _IP_ADAPTER_DNS_SERVER_ADDRESS { +typedef struct _IP_ADAPTER_DNS_SERVER_ADDRESS_XP { union { ULONGLONG Alignment; struct { ULONG Length; DWORD Reserved; - } DUMMYSTRUCTNAME; - } DUMMYUNIONNAME; - struct _IP_ADAPTER_DNS_SERVER_ADDRESS *Next; - SOCKET_ADDRESS Address; -} IP_ADAPTER_DNS_SERVER_ADDRESS, *PIP_ADAPTER_DNS_SERVER_ADDRESS; - -typedef struct _IP_ADAPTER_PREFIX { - union { - ULONGLONG Alignment; - struct { - ULONG Length; - DWORD Flags; - } DUMMYSTRUCTNAME; - } DUMMYUNIONNAME; - struct _IP_ADAPTER_PREFIX *Next; - SOCKET_ADDRESS Address; - ULONG PrefixLength; -} IP_ADAPTER_PREFIX, *PIP_ADAPTER_PREFIX; + }; + }; + struct _IP_ADAPTER_DNS_SERVER_ADDRESS_XP *Next; + SOCKET_ADDRESS Address; +} IP_ADAPTER_DNS_SERVER_ADDRESS_XP, *PIP_ADAPTER_DNS_SERVER_ADDRESS_XP; +#if (NTDDI_VERSION >= NTDDI_WINXP) +typedef IP_ADAPTER_DNS_SERVER_ADDRESS_XP IP_ADAPTER_DNS_SERVER_ADDRESS; +typedef IP_ADAPTER_DNS_SERVER_ADDRESS_XP *PIP_ADAPTER_DNS_SERVER_ADDRESS; +#endif typedef struct _IP_ADAPTER_WINS_SERVER_ADDRESS_LH { union { @@ -179,13 +215,15 @@ typedef struct _IP_ADAPTER_WINS_SERVER_ADDRESS_LH { struct { ULONG Length; DWORD Reserved; - } DUMMYSTRUCTNAME; - } DUMMYUNIONNAME; + }; + }; struct _IP_ADAPTER_WINS_SERVER_ADDRESS_LH *Next; SOCKET_ADDRESS Address; } IP_ADAPTER_WINS_SERVER_ADDRESS_LH, *PIP_ADAPTER_WINS_SERVER_ADDRESS_LH; +#if (NTDDI_VERSION >= NTDDI_VISTA) typedef IP_ADAPTER_WINS_SERVER_ADDRESS_LH IP_ADAPTER_WINS_SERVER_ADDRESS; typedef IP_ADAPTER_WINS_SERVER_ADDRESS_LH *PIP_ADAPTER_WINS_SERVER_ADDRESS; +#endif typedef struct _IP_ADAPTER_GATEWAY_ADDRESS_LH { union { @@ -193,87 +231,97 @@ typedef struct _IP_ADAPTER_GATEWAY_ADDRESS_LH { struct { ULONG Length; DWORD Reserved; - } DUMMYSTRUCTNAME; - } DUMMYUNIONNAME; + }; + }; struct _IP_ADAPTER_GATEWAY_ADDRESS_LH *Next; SOCKET_ADDRESS Address; } IP_ADAPTER_GATEWAY_ADDRESS_LH, *PIP_ADAPTER_GATEWAY_ADDRESS_LH; +#if (NTDDI_VERSION >= NTDDI_VISTA) typedef IP_ADAPTER_GATEWAY_ADDRESS_LH IP_ADAPTER_GATEWAY_ADDRESS; typedef IP_ADAPTER_GATEWAY_ADDRESS_LH *PIP_ADAPTER_GATEWAY_ADDRESS; +#endif + +typedef struct _IP_ADAPTER_PREFIX_XP { + union { + ULONGLONG Alignment; + struct { + ULONG Length; + DWORD Flags; + }; + }; + struct _IP_ADAPTER_PREFIX_XP *Next; + SOCKET_ADDRESS Address; + ULONG PrefixLength; +} IP_ADAPTER_PREFIX_XP, *PIP_ADAPTER_PREFIX_XP; +#if (NTDDI_VERSION >= NTDDI_WINXP) +typedef IP_ADAPTER_PREFIX_XP IP_ADAPTER_PREFIX; +typedef IP_ADAPTER_PREFIX_XP *PIP_ADAPTER_PREFIX; +#endif typedef struct _IP_ADAPTER_DNS_SUFFIX { struct _IP_ADAPTER_DNS_SUFFIX *Next; WCHAR String[MAX_DNS_SUFFIX_STRING_LENGTH]; } IP_ADAPTER_DNS_SUFFIX, *PIP_ADAPTER_DNS_SUFFIX; -#define IP_ADAPTER_DDNS_ENABLED 0x1 -#define IP_ADAPTER_REGISTER_ADAPTER_SUFFIX 0x2 -#define IP_ADAPTER_DHCP_ENABLED 0x4 -#define IP_ADAPTER_RECEIVE_ONLY 0x8 -#define IP_ADAPTER_NO_MULTICAST 0x10 -#define IP_ADAPTER_IPV6_OTHER_STATEFUL_CONFIG 0x20 -#define IP_ADAPTER_NETBIOS_OVER_TCPIP_ENABLED 0x40 -#define IP_ADAPTER_IPV4_ENABLED 0x80 -#define IP_ADAPTER_IPV6_ENABLED 0x100 -#define IP_ADAPTER_IPV6_MANAGE_ADDRESS_CONFIG 0x200 - typedef struct _IP_ADAPTER_ADDRESSES_LH { union { ULONGLONG Alignment; struct { ULONG Length; DWORD IfIndex; - } DUMMYSTRUCTNAME; - } DUMMYUNIONNAME; + }; + }; struct _IP_ADAPTER_ADDRESSES_LH *Next; - PCHAR AdapterName; - PIP_ADAPTER_UNICAST_ADDRESS FirstUnicastAddress; - PIP_ADAPTER_ANYCAST_ADDRESS FirstAnycastAddress; - PIP_ADAPTER_MULTICAST_ADDRESS FirstMulticastAddress; - PIP_ADAPTER_DNS_SERVER_ADDRESS FirstDnsServerAddress; - PWCHAR DnsSuffix; - PWCHAR Description; - PWCHAR FriendlyName; - BYTE PhysicalAddress[MAX_ADAPTER_ADDRESS_LENGTH]; - DWORD PhysicalAddressLength; + PCHAR AdapterName; + PIP_ADAPTER_UNICAST_ADDRESS_LH FirstUnicastAddress; + PIP_ADAPTER_ANYCAST_ADDRESS_XP FirstAnycastAddress; + PIP_ADAPTER_MULTICAST_ADDRESS_XP FirstMulticastAddress; + PIP_ADAPTER_DNS_SERVER_ADDRESS_XP FirstDnsServerAddress; + PWCHAR DnsSuffix; + PWCHAR Description; + PWCHAR FriendlyName; + BYTE PhysicalAddress[MAX_ADAPTER_ADDRESS_LENGTH]; + DWORD PhysicalAddressLength; union { - DWORD Flags; + DWORD Flags; struct { - DWORD DdnsEnabled : 1; - DWORD RegisterAdapterSuffix : 1; - DWORD Dhcpv4Enabled : 1; - DWORD ReceiveOnly : 1; - DWORD NoMulticast : 1; - DWORD Ipv6OtherStatefulConfig : 1; - DWORD NetbiosOverTcpipEnabled : 1; - DWORD Ipv4Enabled : 1; - DWORD Ipv6Enabled : 1; - DWORD Ipv6ManagedAddressConfigurationSupported : 1; - } DUMMYSTRUCTNAME1; - } DUMMYUNIONNAME1; - DWORD Mtu; - DWORD IfType; - IF_OPER_STATUS OperStatus; - DWORD Ipv6IfIndex; - DWORD ZoneIndices[16]; - PIP_ADAPTER_PREFIX FirstPrefix; - ULONG64 TransmitLinkSpeed; - ULONG64 ReceiveLinkSpeed; + DWORD DdnsEnabled : 1; + DWORD RegisterAdapterSuffix : 1; + DWORD Dhcpv4Enabled : 1; + DWORD ReceiveOnly : 1; + DWORD NoMulticast : 1; + DWORD Ipv6OtherStatefulConfig : 1; + DWORD NetbiosOverTcpipEnabled : 1; + DWORD Ipv4Enabled : 1; + DWORD Ipv6Enabled : 1; + DWORD Ipv6ManagedAddressConfigurationSupported : 1; + }; + }; + DWORD Mtu; + DWORD IfType; + IF_OPER_STATUS OperStatus; + DWORD Ipv6IfIndex; + DWORD ZoneIndices[16]; + PIP_ADAPTER_PREFIX_XP FirstPrefix; + ULONG64 TransmitLinkSpeed; + ULONG64 ReceiveLinkSpeed; PIP_ADAPTER_WINS_SERVER_ADDRESS_LH FirstWinsServerAddress; - PIP_ADAPTER_GATEWAY_ADDRESS_LH FirstGatewayAddress; - ULONG Ipv4Metric; - ULONG Ipv6Metric; - IF_LUID Luid; - SOCKET_ADDRESS Dhcpv4Server; - NET_IF_COMPARTMENT_ID CompartmentId; - NET_IF_NETWORK_GUID NetworkGuid; - NET_IF_CONNECTION_TYPE ConnectionType; - TUNNEL_TYPE TunnelType; - SOCKET_ADDRESS Dhcpv6Server; - BYTE Dhcpv6ClientDuid[MAX_DHCPV6_DUID_LENGTH]; - ULONG Dhcpv6ClientDuidLength; - ULONG Dhcpv6Iaid; - PIP_ADAPTER_DNS_SUFFIX FirstDnsSuffix; + PIP_ADAPTER_GATEWAY_ADDRESS_LH FirstGatewayAddress; + ULONG Ipv4Metric; + ULONG Ipv6Metric; + IF_LUID Luid; + SOCKET_ADDRESS Dhcpv4Server; + NET_IF_COMPARTMENT_ID CompartmentId; + NET_IF_NETWORK_GUID NetworkGuid; + NET_IF_CONNECTION_TYPE ConnectionType; + TUNNEL_TYPE TunnelType; + SOCKET_ADDRESS Dhcpv6Server; + BYTE Dhcpv6ClientDuid[MAX_DHCPV6_DUID_LENGTH]; + ULONG Dhcpv6ClientDuidLength; + ULONG Dhcpv6Iaid; +#if (NTDDI_VERSION >= NTDDI_VISTASP1) + PIP_ADAPTER_DNS_SUFFIX FirstDnsSuffix; +#endif } IP_ADAPTER_ADDRESSES_LH, *PIP_ADAPTER_ADDRESSES_LH; typedef struct _IP_ADAPTER_ADDRESSES_XP { @@ -282,29 +330,28 @@ typedef struct _IP_ADAPTER_ADDRESSES_XP { struct { ULONG Length; DWORD IfIndex; - } DUMMYSTRUCTNAME; - } DUMMYUNIONNAME; + }; + }; struct _IP_ADAPTER_ADDRESSES_XP *Next; - PCHAR AdapterName; - PIP_ADAPTER_UNICAST_ADDRESS FirstUnicastAddress; - PIP_ADAPTER_ANYCAST_ADDRESS FirstAnycastAddress; - PIP_ADAPTER_MULTICAST_ADDRESS FirstMulticastAddress; - PIP_ADAPTER_DNS_SERVER_ADDRESS FirstDnsServerAddress; - PWCHAR DnsSuffix; - PWCHAR Description; - PWCHAR FriendlyName; - BYTE PhysicalAddress[MAX_ADAPTER_ADDRESS_LENGTH]; - DWORD PhysicalAddressLength; - DWORD Flags; - DWORD Mtu; - DWORD IfType; - IF_OPER_STATUS OperStatus; - DWORD Ipv6IfIndex; - DWORD ZoneIndices[16]; - PIP_ADAPTER_PREFIX FirstPrefix; + PCHAR AdapterName; + PIP_ADAPTER_UNICAST_ADDRESS FirstUnicastAddress; + PIP_ADAPTER_ANYCAST_ADDRESS FirstAnycastAddress; + PIP_ADAPTER_MULTICAST_ADDRESS FirstMulticastAddress; + PIP_ADAPTER_DNS_SERVER_ADDRESS FirstDnsServerAddress; + PWCHAR DnsSuffix; + PWCHAR Description; + PWCHAR FriendlyName; + BYTE PhysicalAddress[MAX_ADAPTER_ADDRESS_LENGTH]; + DWORD PhysicalAddressLength; + DWORD Flags; + DWORD Mtu; + DWORD IfType; + IF_OPER_STATUS OperStatus; + DWORD Ipv6IfIndex; + DWORD ZoneIndices[16]; + PIP_ADAPTER_PREFIX FirstPrefix; } IP_ADAPTER_ADDRESSES_XP, *PIP_ADAPTER_ADDRESSES_XP; -/* ReactOS */ #if (NTDDI_VERSION >= NTDDI_VISTA) typedef IP_ADAPTER_ADDRESSES_LH IP_ADAPTER_ADDRESSES; typedef IP_ADAPTER_ADDRESSES_LH *PIP_ADAPTER_ADDRESSES; @@ -313,18 +360,24 @@ typedef IP_ADAPTER_ADDRESSES_XP IP_ADAPTER_ADDRESSES; typedef IP_ADAPTER_ADDRESSES_XP *PIP_ADAPTER_ADDRESSES; #endif -#define GAA_FLAG_SKIP_UNICAST 0x00000001 -#define GAA_FLAG_SKIP_ANYCAST 0x00000002 -#define GAA_FLAG_SKIP_MULTICAST 0x00000004 -#define GAA_FLAG_SKIP_DNS_SERVER 0x00000008 -#define GAA_FLAG_INCLUDE_PREFIX 0x00000010 -#define GAA_FLAG_SKIP_FRIENDLY_NAME 0x00000020 -#define GAA_FLAG_INCLUDE_WINS_INFO 0x00000040 -#define GAA_FLAG_INCLUDE_ALL_GATEWAYS 0x00000080 -#define GAA_FLAG_INCLUDE_ALL_INTERFACES 0x00000100 -#define GAA_FLAG_INCLUDE_ALL_COMPARTMENTS 0x00000200 -#define GAA_FLAG_INCLUDE_TUNNEL_BINDINGORDER 0x00000400 - #endif /* _WINSOCK2API_ */ -#endif /* WINE_IPTYPES_H_*/ +#ifndef IP_INTERFACE_NAME_INFO_DEFINED +#define IP_INTERFACE_NAME_INFO_DEFINED + +typedef struct ip_interface_name_info_w2ksp1 { + ULONG Index; + ULONG MediaType; + UCHAR ConnectionType; + UCHAR AccessType; + GUID DeviceGuid; + GUID InterfaceGuid; +} IP_INTERFACE_NAME_INFO_W2KSP1, *PIP_INTERFACE_NAME_INFO_W2KSP1; +#if (NTDDI_VERSION >= NTDDI_WIN2KSP1) +typedef IP_INTERFACE_NAME_INFO_W2KSP1 IP_INTERFACE_NAME_INFO; +typedef IP_INTERFACE_NAME_INFO_W2KSP1 *PIP_INTERFACE_NAME_INFO; +#endif + +#endif // IP_INTERFACE_NAME_INFO_DEFINED + +#endif // IP_TYPES_INCLUDED diff --git a/sdk/include/psdk/minwinbase.h b/sdk/include/psdk/minwinbase.h index 533c9392bdb..9c5cb436065 100644 --- a/sdk/include/psdk/minwinbase.h +++ b/sdk/include/psdk/minwinbase.h @@ -245,6 +245,10 @@ typedef RTL_CRITICAL_SECTION_DEBUG CRITICAL_SECTION_DEBUG; typedef PRTL_CRITICAL_SECTION_DEBUG PCRITICAL_SECTION_DEBUG; typedef PRTL_CRITICAL_SECTION_DEBUG LPCRITICAL_SECTION_DEBUG; +#if (_WIN32_WINNT >= 0x0403) +#define CRITICAL_SECTION_NO_DEBUG_INFO RTL_CRITICAL_SECTION_FLAG_NO_DEBUG_INFO +#endif + #ifndef _SYSTEMTIME_ // FIXME #define _SYSTEMTIME_ typedef struct _SYSTEMTIME diff --git a/sdk/include/psdk/perflib.h b/sdk/include/psdk/perflib.h index 188f26e3e74..7871683f88b 100644 --- a/sdk/include/psdk/perflib.h +++ b/sdk/include/psdk/perflib.h @@ -103,7 +103,7 @@ typedef struct _PERF_DATA_HEADER { SYSTEMTIME SystemTime; } PERF_DATA_HEADER, *PPERF_DATA_HEADER; -PERF_COUNTERSET_INSTANCE WINAPI *PerfCreateInstance(HANDLE, const GUID *, const WCHAR *, ULONG); +PERF_COUNTERSET_INSTANCE * WINAPI PerfCreateInstance(HANDLE, const GUID *, const WCHAR *, ULONG); ULONG WINAPI PerfDeleteInstance(HANDLE, PERF_COUNTERSET_INSTANCE *); ULONG WINAPI PerfSetCounterRefValue(HANDLE, PERF_COUNTERSET_INSTANCE *, ULONG, void *); ULONG WINAPI PerfSetCounterSetInfo(HANDLE, PERF_COUNTERSET_INFO *, ULONG); diff --git a/sdk/include/psdk/processthreadsapi.h b/sdk/include/psdk/processthreadsapi.h index f2e892a99cb..c0ce622fe05 100644 --- a/sdk/include/psdk/processthreadsapi.h +++ b/sdk/include/psdk/processthreadsapi.h @@ -143,6 +143,23 @@ GetCurrentThreadEffectiveToken( #endif // (_WIN32_WINNT >= 0x602) || defined(__REACTOS__) +typedef enum _PROCESS_INFORMATION_CLASS +{ + ProcessMemoryPriority, + ProcessMemoryExhaustionInfo, + ProcessAppMemoryInfo, + ProcessInPrivateInfo, + ProcessPowerThrottling, + ProcessReservedValue1, // Formerly ProcessActivityThrottlePolicyInfo + ProcessTelemetryCoverageInfo, + ProcessProtectionLevelInfo, + ProcessLeapSecondInfo, + ProcessMachineTypeInfo, + ProcessOverrideSubsequentPrefetchParameter, + ProcessMaxOverridePrefetchParameter, + ProcessInformationClassMax +} PROCESS_INFORMATION_CLASS; + #ifdef __cplusplus } // extern "C" #endif diff --git a/sdk/include/psdk/shlwapi.h b/sdk/include/psdk/shlwapi.h index 0d076598e80..6bcb40e6bfd 100644 --- a/sdk/include/psdk/shlwapi.h +++ b/sdk/include/psdk/shlwapi.h @@ -1582,6 +1582,23 @@ HRESULT WINAPI SHStrDupA(_In_ LPCSTR psz, _Outptr_ WCHAR** ppwsz); HRESULT WINAPI SHStrDupW(_In_ LPCWSTR psz, _Outptr_ WCHAR** ppwsz); #define SHStrDup WINELIB_NAME_AW(SHStrDup) +#if (NTDDI_VERSION >= NTDDI_VISTASP1) +typedef int SFBS_FLAGS; + +enum tagSFBS_FLAGS +{ + SFBS_FLAGS_ROUND_TO_NEAREST_DISPLAYED_DIGIT = 0x0001, + SFBS_FLAGS_TRUNCATE_UNDISPLAYED_DECIMAL_DIGITS = 0x0002 +}; + +LWSTDAPI +StrFormatByteSizeEx( + ULONGLONG ull, + SFBS_FLAGS flags, + _Out_writes_(cchBuf) PWSTR pszBuf, + _In_range_(>,0) UINT cchBuf); +#endif // (NTDDI_VERSION >= NTDDI_VISTASP1) + LPSTR WINAPI StrFormatByteSizeA( diff --git a/sdk/include/psdk/tcpestats.h b/sdk/include/psdk/tcpestats.h new file mode 100644 index 00000000000..dd3512f3318 --- /dev/null +++ b/sdk/include/psdk/tcpestats.h @@ -0,0 +1,216 @@ +/* + * PROJECT: ReactOS PSDK + * LICENSE: MIT (https://spdx.org/licenses/MIT) + * PURPOSE: TCP Extended Statistics Header + * COPYRIGHT: Copyright 2025 Carl Bialorucki + */ + +#ifndef _TCPESTATS_ +#define _TCPESTATS_ + +/* Enums */ +typedef enum _TCP_BOOLEAN_OPTIONAL { + TcpBoolOptUnchanged = -1, + TcpBoolOptDisabled = 0, + TcpBoolOptEnabled = 1, +} TCP_BOOLEAN_OPTIONAL, *PTCP_BOOLEAN_OPTIONAL; + +typedef enum { + TcpConnectionEstatsSynOpts = 0, + TcpConnectionEstatsData = 1, + TcpConnectionEstatsSndCong = 2, + TcpConnectionEstatsPath = 3, + TcpConnectionEstatsSendBuff = 4, + TcpConnectionEstatsRec = 5, + TcpConnectionEstatsObsRec = 6, + TcpConnectionEstatsBandwidth = 7, + TcpConnectionEstatsFineRtt = 8, + TcpConnectionEstatsMaximum = 9, +} TCP_ESTATS_TYPE, *PTCP_ESTATS_TYPE; + +typedef enum { + TcpErrorNone = 0, + TcpErrorBelowDataWindow = 1, + TcpErrorAboveDataWindow = 2, + TcpErrorBelowAckWindow = 3, + TcpErrorAboveAckWindow = 4, + TcpErrorBelowTsWindow = 5, + TcpErrorAboveTsWindow = 6, + TcpErrorDataChecksumError = 7, + TcpErrorDataLengthError = 8, + TcpErrorMaxSoftError = 9, +} TCP_SOFT_ERROR, *PTCP_SOFT_ERROR; + +/* Structures */ +typedef struct _TCP_ESTATS_BANDWIDTH_ROD_v0 { + ULONG64 OutboundBandwidth; + ULONG64 InboundBandwidth; + ULONG64 OutboundInstability; + ULONG64 InboundInstability; + BOOLEAN OutboundBandwidthPeaked; + BOOLEAN InboundBandwidthPeaked; +} TCP_ESTATS_BANDWIDTH_ROD_v0, *PTCP_ESTATS_BANDWIDTH_ROD_v0; + +typedef struct _TCP_ESTATS_BANDWIDTH_RW_v0 { + TCP_BOOLEAN_OPTIONAL EnableCollectionOutbound; + TCP_BOOLEAN_OPTIONAL EnableCollectionInbound; +} TCP_ESTATS_BANDWIDTH_RW_v0, *PTCP_ESTATS_BANDWIDTH_RW_v0; + +typedef struct _TCP_ESTATS_DATA_ROD_v0 { + ULONG64 DataBytesOut; + ULONG64 DataSegsOut; + ULONG64 DataBytesIn; + ULONG64 DataSegsIn; + ULONG64 SegsOut; + ULONG64 SegsIn; + ULONG SoftErrors; + ULONG SoftErrorReason; + ULONG SndUna; + ULONG SndNxt; + ULONG SndMax; + ULONG64 ThruBytesAcked; + ULONG RcvNxt; + ULONG64 ThruBytesReceived; +} TCP_ESTATS_DATA_ROD_v0, *PTCP_ESTATS_DATA_ROD_v0; + +typedef struct _TCP_ESTATS_DATA_RW_v0 { + BOOLEAN EnableCollection; +} TCP_ESTATS_DATA_RW_v0, *PTCP_ESTATS_DATA_RW_v0; + +typedef struct _TCP_ESTATS_FINE_RTT_RW_v0 { + BOOLEAN EnableCollection; +} TCP_ESTATS_FINE_RTT_RW_v0, *PTCP_ESTATS_FINE_RTT_RW_v0; + +typedef struct _TCP_ESTATS_FINE_RTT_ROD_v0 { + ULONG RttVar; + ULONG MaxRtt; + ULONG MinRtt; + ULONG SumRtt; +} TCP_ESTATS_FINE_RTT_ROD_v0, *PTCP_ESTATS_FINE_RTT_ROD_v0; + +typedef struct _TCP_ESTATS_OBS_REC_ROD_v0 { + ULONG CurRwinRcvd; + ULONG MaxRwinRcvd; + ULONG MinRwinRcvd; + UCHAR WinScaleRcvd; +} TCP_ESTATS_OBS_REC_ROD_v0, *PTCP_ESTATS_OBS_REC_ROD_v0; + +typedef struct _TCP_ESTATS_OBS_REC_RW_v0 { + BOOLEAN EnableCollection; +} TCP_ESTATS_OBS_REC_RW_v0, *PTCP_ESTATS_OBS_REC_RW_v0; + +typedef struct _TCP_ESTATS_PATH_ROD_v0 { + ULONG FastRetran; + ULONG Timeouts; + ULONG SubsequentTimeouts; + ULONG CurTimeoutCount; + ULONG AbruptTimeouts; + ULONG PktsRetrans; + ULONG BytesRetrans; + ULONG DupAcksIn; + ULONG SacksRcvd; + ULONG SackBlocksRcvd; + ULONG CongSignals; + ULONG PreCongSumCwnd; + ULONG PreCongSumRtt; + ULONG PostCongSumRtt; + ULONG PostCongCountRtt; + ULONG EcnSignals; + ULONG EceRcvd; + ULONG SendStall; + ULONG QuenchRcvd; + ULONG RetranThresh; + ULONG SndDupAckEpisodes; + ULONG SumBytesReordered; + ULONG NonRecovDa; + ULONG NonRecovDaEpisodes; + ULONG AckAfterFr; + ULONG DsackDups; + ULONG SampleRtt; + ULONG SmoothedRtt; + ULONG RttVar; + ULONG MaxRtt; + ULONG MinRtt; + ULONG SumRtt; + ULONG CountRtt; + ULONG CurRto; + ULONG MaxRto; + ULONG MinRto; + ULONG CurMss; + ULONG MaxMss; + ULONG MinMss; + ULONG SpuriousRtoDetections; +} TCP_ESTATS_PATH_ROD_v0, *PTCP_ESTATS_PATH_ROD_v0; + +typedef struct _TCP_ESTATS_PATH_RW_v0 { + BOOLEAN EnableCollection; +} TCP_ESTATS_PATH_RW_v0, *PTCP_ESTATS_PATH_RW_v0; + +typedef struct _TCP_ESTATS_REC_ROD_v0 { + ULONG CurRwinSent; + ULONG MaxRwinSent; + ULONG MinRwinSent; + ULONG LimRwin; + ULONG DupAckEpisodes; + ULONG DupAcksOut; + ULONG CeRcvd; + ULONG EcnSent; + ULONG EcnNoncesRcvd; + ULONG CurReasmQueue; + ULONG MaxReasmQueue; + SIZE_T CurAppRQueue; + SIZE_T MaxAppRQueue; + UCHAR WinScaleSent; +} TCP_ESTATS_REC_ROD_v0, *PTCP_ESTATS_REC_ROD_v0; + +typedef struct _TCP_ESTATS_REC_RW_v0 { + BOOLEAN EnableCollection; +} TCP_ESTATS_REC_RW_v0, *PTCP_ESTATS_REC_RW_v0; + +typedef struct _TCP_ESTATS_SEND_BUFF_ROD_v0 { + SIZE_T CurRetxQueue; + SIZE_T MaxRetxQueue; + SIZE_T CurAppWQueue; + SIZE_T MaxAppWQueue; +} TCP_ESTATS_SEND_BUFF_ROD_v0, *PTCP_ESTATS_SEND_BUFF_ROD_v0; + +typedef struct _TCP_ESTATS_SEND_BUFF_RW_v0 { + BOOLEAN EnableCollection; +} TCP_ESTATS_SEND_BUFF_RW_v0, *PTCP_ESTATS_SEND_BUFF_RW_v0; + +typedef struct _TCP_ESTATS_SND_CONG_ROD_v0 { + ULONG SndLimTransRwin; + ULONG SndLimTimeRwin; + SIZE_T SndLimBytesRwin; + ULONG SndLimTransCwnd; + ULONG SndLimTimeCwnd; + SIZE_T SndLimBytesCwnd; + ULONG SndLimTransSnd; + ULONG SndLimTimeSnd; + SIZE_T SndLimBytesSnd; + ULONG SlowStart; + ULONG CongAvoid; + ULONG OtherReductions; + ULONG CurCwnd; + ULONG MaxSsCwnd; + ULONG MaxCaCwnd; + ULONG CurSsthresh; + ULONG MaxSsthresh; + ULONG MinSsthresh; +} TCP_ESTATS_SND_CONG_ROD_v0, *PTCP_ESTATS_SND_CONG_ROD_v0; + +typedef struct _TCP_ESTATS_SND_CONG_ROS_v0 { + ULONG LimCwnd; +} TCP_ESTATS_SND_CONG_ROS_v0, *PTCP_ESTATS_SND_CONG_ROS_v0; + +typedef struct _TCP_ESTATS_SND_CONG_RW_v0 { + BOOLEAN EnableCollection; +} TCP_ESTATS_SND_CONG_RW_v0, *PTCP_ESTATS_SND_CONG_RW_v0; + +typedef struct _TCP_ESTATS_SYN_OPTS_ROS_v0 { + BOOLEAN ActiveOpen; + ULONG MssRcvd; + ULONG MssSent; +} TCP_ESTATS_SYN_OPTS_ROS_v0, *PTCP_ESTATS_SYN_OPTS_ROS_v0; + +#endif // _TCPESTATS_ diff --git a/sdk/include/psdk/tcpmib.h b/sdk/include/psdk/tcpmib.h index 477500c4fb2..3a527530f64 100644 --- a/sdk/include/psdk/tcpmib.h +++ b/sdk/include/psdk/tcpmib.h @@ -1,46 +1,34 @@ /* - * Copyright (C) 2003 Juan Lang - * - * 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 + * PROJECT: ReactOS PSDK + * LICENSE: MIT (https://spdx.org/licenses/MIT) + * PURPOSE: TCPMIB Header + * COPYRIGHT: Copyright 2025 Carl Bialorucki */ -#ifndef __WINE_TCPMIB_H -#define __WINE_TCPMIB_H + +#ifndef _TCPMIB_ +#define _TCPMIB_ #define TCPIP_OWNING_MODULE_SIZE 16 +#define MIB_TCP_MAXCONN_DYNAMIC ((ULONG)-1) - -/* TCP tables */ - -typedef enum -{ - MIB_TCP_STATE_CLOSED = 1, - MIB_TCP_STATE_LISTEN = 2, - MIB_TCP_STATE_SYN_SENT = 3, - MIB_TCP_STATE_SYN_RCVD = 4, - MIB_TCP_STATE_ESTAB = 5, - MIB_TCP_STATE_FIN_WAIT1 = 6, - MIB_TCP_STATE_FIN_WAIT2 = 7, +typedef enum { + MIB_TCP_STATE_CLOSED = 1, + MIB_TCP_STATE_LISTEN = 2, + MIB_TCP_STATE_SYN_SENT = 3, + MIB_TCP_STATE_SYN_RCVD = 4, + MIB_TCP_STATE_ESTAB = 5, + MIB_TCP_STATE_FIN_WAIT1 = 6, + MIB_TCP_STATE_FIN_WAIT2 = 7, MIB_TCP_STATE_CLOSE_WAIT = 8, - MIB_TCP_STATE_CLOSING = 9, - MIB_TCP_STATE_LAST_ACK = 10, - MIB_TCP_STATE_TIME_WAIT = 11, + MIB_TCP_STATE_CLOSING = 9, + MIB_TCP_STATE_LAST_ACK = 10, + MIB_TCP_STATE_TIME_WAIT = 11, MIB_TCP_STATE_DELETE_TCB = 12, + + MIB_TCP_STATE_RESERVED = 100 } MIB_TCP_STATE; -typedef enum -{ +typedef enum { TcpConnectionOffloadStateInHost, TcpConnectionOffloadStateOffloading, TcpConnectionOffloadStateOffloaded, @@ -48,59 +36,44 @@ typedef enum TcpConnectionOffloadStateMax, } TCP_CONNECTION_OFFLOAD_STATE, *PTCP_CONNECTION_OFFLOAD_STATE; -typedef struct _MIB_TCPROW -{ - union - { +typedef struct _MIB_TCPROW { + union { DWORD dwState; MIB_TCP_STATE State; - } DUMMYUNIONNAME; + }; DWORD dwLocalAddr; DWORD dwLocalPort; DWORD dwRemoteAddr; DWORD dwRemotePort; } MIB_TCPROW, *PMIB_TCPROW; -typedef struct _MIB_TCPTABLE -{ +typedef struct _MIB_TCPTABLE { DWORD dwNumEntries; MIB_TCPROW table[1]; } MIB_TCPTABLE, *PMIB_TCPTABLE; -typedef struct _MIB_TCP6ROW { - MIB_TCP_STATE State; - IN6_ADDR LocalAddr; - DWORD dwLocalScopeId; - DWORD dwLocalPort; - IN6_ADDR RemoteAddr; - DWORD dwRemoteScopeId; - DWORD dwRemotePort; -} MIB_TCP6ROW, *PMIB_TCP6ROW; +#define SIZEOF_TCPTABLE(x) \ + (FIELD_OFFSET(MIB_TCPTABLE, table[0]) + ((x) * sizeof(MIB_TCPROW)) + ALIGN_SIZE) -typedef struct _MIB_TCP6TABLE { - DWORD dwNumEntries; - MIB_TCP6ROW table[1]; -} MIB_TCP6TABLE, *PMIB_TCP6TABLE; - -typedef struct _MIB_TCP6ROW2 { - IN6_ADDR LocalAddr; - DWORD dwLocalScopeId; +typedef struct _MIB_TCPROW2 { + DWORD dwState; + DWORD dwLocalAddr; DWORD dwLocalPort; - IN6_ADDR RemoteAddr; - DWORD dwRemoteScopeId; + DWORD dwRemoteAddr; DWORD dwRemotePort; - MIB_TCP_STATE State; DWORD dwOwningPid; TCP_CONNECTION_OFFLOAD_STATE dwOffloadState; -} MIB_TCP6ROW2, *PMIB_TCP6ROW2; +} MIB_TCPROW2, *PMIB_TCPROW2; -typedef struct _MIB_TCP6TABLE2 { - DWORD dwNumEntries; - MIB_TCP6ROW2 table[1]; -} MIB_TCP6TABLE2, *PMIB_TCP6TABLE2; +typedef struct _MIB_TCPTABLE2 { + DWORD dwNumEntries; + MIB_TCPROW2 table[1]; +} MIB_TCPTABLE2, *PMIB_TCPTABLE2; -typedef struct _MIB_TCPROW_OWNER_PID -{ +#define SIZEOF_TCPTABLE2(x) \ + (FIELD_OFFSET(MIB_TCPTABLE2, table[0]) + ((x) * sizeof(MIB_TCPROW2)) + ALIGN_SIZE) + +typedef struct _MIB_TCPROW_OWNER_PID { DWORD dwState; DWORD dwLocalAddr; DWORD dwLocalPort; @@ -109,14 +82,15 @@ typedef struct _MIB_TCPROW_OWNER_PID DWORD dwOwningPid; } MIB_TCPROW_OWNER_PID, *PMIB_TCPROW_OWNER_PID; -typedef struct _MIB_TCPTABLE_OWNER_PID -{ +typedef struct _MIB_TCPTABLE_OWNER_PID { DWORD dwNumEntries; MIB_TCPROW_OWNER_PID table[1]; } MIB_TCPTABLE_OWNER_PID, *PMIB_TCPTABLE_OWNER_PID; -typedef struct _MIB_TCPROW_OWNER_MODULE -{ +#define SIZEOF_TCPTABLE_OWNER_PID(x) \ + (FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table[0]) + ((x) * sizeof(MIB_TCPROW_OWNER_PID)) + ALIGN_SIZE) + +typedef struct _MIB_TCPROW_OWNER_MODULE { DWORD dwState; DWORD dwLocalAddr; DWORD dwLocalPort; @@ -127,52 +101,31 @@ typedef struct _MIB_TCPROW_OWNER_MODULE ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]; } MIB_TCPROW_OWNER_MODULE, *PMIB_TCPROW_OWNER_MODULE; -typedef struct _MIB_TCPTABLE_OWNER_MODULE -{ +typedef struct _MIB_TCPTABLE_OWNER_MODULE { DWORD dwNumEntries; MIB_TCPROW_OWNER_MODULE table[1]; } MIB_TCPTABLE_OWNER_MODULE, *PMIB_TCPTABLE_OWNER_MODULE; -typedef struct _MIB_TCPROW2 -{ - DWORD dwState; - DWORD dwLocalAddr; - DWORD dwLocalPort; - DWORD dwRemoteAddr; - DWORD dwRemotePort; - DWORD dwOwningPid; - TCP_CONNECTION_OFFLOAD_STATE dwOffloadState; -} MIB_TCPROW2, *PMIB_TCPROW2; +#define SIZEOF_TCPTABLE_OWNER_MODULE(x) \ + (FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table[0]) + ((x) * sizeof(MIB_TCPROW_OWNER_MODULE)) + ALIGN_SIZE) -typedef struct _MIB_TCPTABLE2 -{ - DWORD dwNumEntries; - MIB_TCPROW2 table[1]; -} MIB_TCPTABLE2, *PMIB_TCPTABLE2; +typedef enum { + TcpRtoAlgorithmOther = 1, + TcpRtoAlgorithmConstant = 2, + TcpRtoAlgorithmRsre = 3, + TcpRtoAlgorithmVanj = 4, - -/* TCP stats */ - -typedef enum -{ - TcpRtoAlgorithmOther = 0, - TcpRtoAlgorithmConstant = 1, - TcpRtoAlgorithmRsre = 2, - TcpRtoAlgorithmVanj = 3, - - MIB_TCP_RTO_OTHER = 1, - MIB_TCP_RTO_CONSTANT = 2, - MIB_TCP_RTO_RSRE = 3, - MIB_TCP_RTO_VANJ = 4, + MIB_TCP_RTO_OTHER = 1, + MIB_TCP_RTO_CONSTANT = 2, + MIB_TCP_RTO_RSRE = 3, + MIB_TCP_RTO_VANJ = 4, } TCP_RTO_ALGORITHM, *PTCP_RTO_ALGORITHM; -typedef struct _MIB_TCPSTATS -{ - union - { +typedef struct _MIB_TCPSTATS { + union { DWORD dwRtoAlgorithm; TCP_RTO_ALGORITHM RtoAlgorithm; - } DUMMYUNIONNAME; + }; DWORD dwRtoMin; DWORD dwRtoMax; DWORD dwMaxConn; @@ -189,4 +142,106 @@ typedef struct _MIB_TCPSTATS DWORD dwNumConns; } MIB_TCPSTATS, *PMIB_TCPSTATS; -#endif /* __WINE_TCPMIB_H */ +#if (NTDDI_VERSION >= NTDDI_WIN10_RS3) +typedef struct _MIB_TCPSTATS2 { + TCP_RTO_ALGORITHM RtoAlgorithm; + DWORD dwRtoMin; + DWORD dwRtoMax; + DWORD dwMaxConn; + DWORD dwActiveOpens; + DWORD dwPassiveOpens; + DWORD dwAttemptFails; + DWORD dwEstabResets; + DWORD dwCurrEstab; + DWORD64 dw64InSegs; + DWORD64 dw64OutSegs; + DWORD dwRetransSegs; + DWORD dwInErrs; + DWORD dwOutRsts; + DWORD dwNumConns; +} MIB_TCPSTATS2, *PMIB_TCPSTATS2; +#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS3) + +#ifdef _WS2IPDEF_ +typedef struct _MIB_TCP6ROW { + MIB_TCP_STATE State; + IN6_ADDR LocalAddr; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + IN6_ADDR RemoteAddr; + DWORD dwRemoteScopeId; + DWORD dwRemotePort; +} MIB_TCP6ROW, *PMIB_TCP6ROW; + +typedef struct _MIB_TCP6TABLE { + DWORD dwNumEntries; + MIB_TCP6ROW table[1]; +} MIB_TCP6TABLE, *PMIB_TCP6TABLE; + +#define SIZEOF_TCP6TABLE(x) \ + (FIELD_OFFSET(MIB_TCP6TABLE, table[0]) + ((x) * sizeof(MIB_TCP6ROW)) + ALIGN_SIZE) + +typedef struct _MIB_TCP6ROW2 { + IN6_ADDR LocalAddr; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + IN6_ADDR RemoteAddr; + DWORD dwRemoteScopeId; + DWORD dwRemotePort; + MIB_TCP_STATE State; + DWORD dwOwningPid; + TCP_CONNECTION_OFFLOAD_STATE dwOffloadState; +} MIB_TCP6ROW2, *PMIB_TCP6ROW2; + +typedef struct _MIB_TCP6TABLE2 { + DWORD dwNumEntries; + MIB_TCP6ROW2 table[1]; +} MIB_TCP6TABLE2, *PMIB_TCP6TABLE2; + +#define SIZEOF_TCP6TABLE2(x) \ + (FIELD_OFFSET(MIB_TCP6TABLE2, table[0]) + ((x) * sizeof(MIB_TCP6ROW2)) + ALIGN_SIZE) + +typedef struct _MIB_TCP6ROW_OWNER_PID { + UCHAR ucLocalAddr[16]; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + UCHAR ucRemoteAddr[16]; + DWORD dwRemoteScopeId; + DWORD dwRemotePort; + DWORD dwState; + DWORD dwOwningPid; +} MIB_TCP6ROW_OWNER_PID, *PMIB_TCP6ROW_OWNER_PID; + +typedef struct _MIB_TCP6TABLE_OWNER_PID { + DWORD dwNumEntries; + _Field_size_(dwNumEntries) + MIB_TCP6ROW_OWNER_PID table[1]; +} MIB_TCP6TABLE_OWNER_PID, *PMIB_TCP6TABLE_OWNER_PID; + +#define SIZEOF_TCP6TABLE_OWNER_PID(x) \ + (FIELD_OFFSET(MIB_TCP6TABLE_OWNER_PID, table[0]) + ((x) * sizeof(MIB_TCP6ROW_OWNER_PID)) + ALIGN_SIZE) + +typedef struct _MIB_TCP6ROW_OWNER_MODULE { + UCHAR ucLocalAddr[16]; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + UCHAR ucRemoteAddr[16]; + DWORD dwRemoteScopeId; + DWORD dwRemotePort; + DWORD dwState; + DWORD dwOwningPid; + LARGE_INTEGER liCreateTimestamp; + ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]; +} MIB_TCP6ROW_OWNER_MODULE, *PMIB_TCP6ROW_OWNER_MODULE; + +typedef struct _MIB_TCP6TABLE_OWNER_MODULE { + DWORD dwNumEntries; + _Field_size_(dwNumEntries) + MIB_TCP6ROW_OWNER_MODULE table[1]; +} MIB_TCP6TABLE_OWNER_MODULE, *PMIB_TCP6TABLE_OWNER_MODULE; + +#define SIZEOF_TCP6TABLE_OWNER_MODULE(x) \ + (FIELD_OFFSET(MIB_TCP6TABLE_OWNER_MODULE, table[0]) + ((x) * sizeof(MIB_TCP6ROW_OWNER_MODULE)) + ALIGN_SIZE) +#endif // _WS2IPDEF_ + +#endif // _TCPMIB_ diff --git a/sdk/include/psdk/udpmib.h b/sdk/include/psdk/udpmib.h index 6b3f51cf2fe..3aa8f5ad12a 100644 --- a/sdk/include/psdk/udpmib.h +++ b/sdk/include/psdk/udpmib.h @@ -1,42 +1,29 @@ /* - * Copyright (C) 2003 Juan Lang - * - * 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 + * PROJECT: ReactOS PSDK + * LICENSE: MIT (https://spdx.org/licenses/MIT) + * PURPOSE: UDPMIB Header + * COPYRIGHT: Copyright 2025 Carl Bialorucki */ -#ifndef __WINE_UDPMIB_H -#define __WINE_UDPMIB_H + +#ifndef _UDPMIB_ +#define _UDPMIB_ #define TCPIP_OWNING_MODULE_SIZE 16 - -/* UDP table */ - -typedef struct _MIB_UDPROW -{ +typedef struct _MIB_UDPROW { DWORD dwLocalAddr; DWORD dwLocalPort; } MIB_UDPROW, *PMIB_UDPROW; -typedef struct _MIB_UDPTABLE -{ +typedef struct _MIB_UDPTABLE { DWORD dwNumEntries; MIB_UDPROW table[1]; } MIB_UDPTABLE, *PMIB_UDPTABLE; -typedef struct _MIB_UDPROW_OWNER_PID -{ +#define SIZEOF_UDPTABLE(x) \ + (FIELD_OFFSET(MIB_UDPTABLE, table[0]) + ((x) * sizeof(MIB_UDPROW)) + ALIGN_SIZE) + +typedef struct _MIB_UDPROW_OWNER_PID { DWORD dwLocalAddr; DWORD dwLocalPort; DWORD dwOwningPid; @@ -48,38 +35,152 @@ typedef struct _MIB_UDPTABLE_OWNER_PID MIB_UDPROW_OWNER_PID table[1]; } MIB_UDPTABLE_OWNER_PID, *PMIB_UDPTABLE_OWNER_PID; -typedef struct _MIB_UDPROW_OWNER_MODULE -{ +#define SIZEOF_UDPTABLE_OWNER_PID(x) \ + (FIELD_OFFSET(MIB_UDPTABLE_OWNER_PID, table[0]) + ((x) * sizeof(MIB_UDPROW_OWNER_PID)) + ALIGN_SIZE) + +typedef struct _MIB_UDPROW_OWNER_MODULE { DWORD dwLocalAddr; DWORD dwLocalPort; DWORD dwOwningPid; LARGE_INTEGER liCreateTimestamp; - __C89_NAMELESS union - { - __C89_NAMELESS struct - { - int SpecificPortBind:1; - } __C89_NAMELESSSTRUCTNAME; + union { + struct { + int SpecificPortBind : 1; + }; int dwFlags; - } __C89_NAMELESSUNIONNAME; - ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]; + }; + ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]; } MIB_UDPROW_OWNER_MODULE, *PMIB_UDPROW_OWNER_MODULE; -typedef struct _MIB_UDPTABLE_OWNER_MODULE -{ +typedef struct _MIB_UDPTABLE_OWNER_MODULE { DWORD dwNumEntries; MIB_UDPROW_OWNER_MODULE table[1]; } MIB_UDPTABLE_OWNER_MODULE, *PMIB_UDPTABLE_OWNER_MODULE; -/* UDP statistics */ +#define SIZEOF_UDPTABLE_OWNER_MODULE(x) \ + (FIELD_OFFSET(MIB_UDPTABLE_OWNER_MODULE, table[0]) + ((x) * sizeof(MIB_UDPROW_OWNER_MODULE)) + ALIGN_SIZE) -typedef struct _MIB_UDPSTATS -{ +typedef struct _MIB_UDPROW2 { + DWORD dwLocalAddr; + DWORD dwLocalPort; + DWORD dwOwningPid; + LARGE_INTEGER liCreateTimestamp; + union { + struct { + int SpecificPortBind : 1; + }; + int dwFlags; + }; + ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]; + DWORD dwRemoteAddr; + DWORD dwRemotePort; +} MIB_UDPROW2, *PMIB_UDPROW2; + +typedef struct _MIB_UDPTABLE2 { + DWORD dwNumEntries; + MIB_UDPROW2 table[1]; +} MIB_UDPTABLE2, *PMIB_UDPTABLE2; + +#define SIZEOF_UDPTABLE2(x) \ + (FIELD_OFFSET(MIB_UDPTABLE2, table[0]) + ((x) * sizeof(MIB_UDPROW2)) + ALIGN_SIZE) + +typedef struct _MIB_UDPSTATS { DWORD dwInDatagrams; DWORD dwNoPorts; DWORD dwInErrors; DWORD dwOutDatagrams; DWORD dwNumAddrs; -} MIB_UDPSTATS, *PMIB_UDPSTATS; +} MIB_UDPSTATS,*PMIB_UDPSTATS; -#endif /* __WINE_UDPMIB_H */ +#if (NTDDI_VERSION >= NTDDI_WIN10_RS3) +typedef struct _MIB_UDPSTATS2 { + DWORD64 dw64InDatagrams; + DWORD dwNoPorts; + DWORD dwInErrors; + DWORD64 dw64OutDatagrams; + DWORD dwNumAddrs; +} MIB_UDPSTATS2, *PMIB_UDPSTATS2; +#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS3) + +#ifdef _WS2IPDEF_ +typedef struct _MIB_UDP6ROW { + IN6_ADDR dwLocalAddr; + DWORD dwLocalScopeId; + DWORD dwLocalPort; +} MIB_UDP6ROW, *PMIB_UDP6ROW; + +typedef struct _MIB_UDP6TABLE { + DWORD dwNumEntries; + MIB_UDP6ROW table[1]; +} MIB_UDP6TABLE, *PMIB_UDP6TABLE; + +#define SIZEOF_UDP6TABLE(X) (FIELD_OFFSET(MIB_UDP6TABLE, table[0]) + \ + ((X) * sizeof(MIB_UDP6ROW)) + ALIGN_SIZE) + +typedef struct _MIB_UDP6ROW_OWNER_PID { + UCHAR ucLocalAddr[16]; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + DWORD dwOwningPid; +} MIB_UDP6ROW_OWNER_PID, *PMIB_UDP6ROW_OWNER_PID; + +typedef struct _MIB_UDP6TABLE_OWNER_PID { + DWORD dwNumEntries; + _Field_size_(dwNumEntries) + MIB_UDP6ROW_OWNER_PID table[1]; +} MIB_UDP6TABLE_OWNER_PID, *PMIB_UDP6TABLE_OWNER_PID; + +#define SIZEOF_UDP6TABLE_OWNER_PID(x) \ + (FIELD_OFFSET(MIB_UDP6TABLE_OWNER_PID, table[0]) + ((x) * sizeof(MIB_UDP6ROW_OWNER_PID)) + ALIGN_SIZE) + +typedef struct _MIB_UDP6ROW_OWNER_MODULE { + UCHAR ucLocalAddr[16]; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + DWORD dwOwningPid; + LARGE_INTEGER liCreateTimestamp; + union { + struct { + int SpecificPortBind : 1; + }; + int dwFlags; + }; + ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]; +} MIB_UDP6ROW_OWNER_MODULE, *PMIB_UDP6ROW_OWNER_MODULE; + +typedef struct _MIB_UDP6TABLE_OWNER_MODULE { + DWORD dwNumEntries; + MIB_UDP6ROW_OWNER_MODULE table[1]; +} MIB_UDP6TABLE_OWNER_MODULE, *PMIB_UDP6TABLE_OWNER_MODULE; + +#define SIZEOF_UDP6TABLE_OWNER_MODULE(x) \ + (FIELD_OFFSET(MIB_UDP6TABLE_OWNER_MODULE, table[0]) + ((x) * sizeof(MIB_UDP6ROW_OWNER_MODULE)) + ALIGN_SIZE) + +typedef struct _MIB_UDP6ROW2 { + UCHAR ucLocalAddr[16]; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + DWORD dwOwningPid; + LARGE_INTEGER liCreateTimestamp; + union { + struct { + int SpecificPortBind : 1; + }; + int dwFlags; + }; + ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]; + UCHAR ucRemoteAddr[16]; + DWORD dwRemoteScopeId; + DWORD dwRemotePort; +} MIB_UDP6ROW2, *PMIB_UDP6ROW2; + +typedef struct _MIB_UDP6TABLE2 { + DWORD dwNumEntries; + MIB_UDP6ROW2 table[1]; +} MIB_UDP6TABLE2, *PMIB_UDP6TABLE2; + +#define SIZEOF_UDP6TABLE2(x) \ + (FIELD_OFFSET(MIB_UDP6TABLE2, table[0]) + ((x) * sizeof(MIB_UDP6ROW2)) + ALIGN_SIZE) +#endif // _WS2IPDEF_ + +#endif // _UDPMIB_ diff --git a/sdk/include/psdk/winbase.h b/sdk/include/psdk/winbase.h index b8d629b0b0e..86575d8df55 100644 --- a/sdk/include/psdk/winbase.h +++ b/sdk/include/psdk/winbase.h @@ -1124,6 +1124,7 @@ typedef struct _PROC_THREAD_ATTRIBUTE_LIST *PPROC_THREAD_ATTRIBUTE_LIST, *LPPROC #define PROC_THREAD_ATTRIBUTE_INPUT 0x00020000 #define PROC_THREAD_ATTRIBUTE_ADDITIVE 0x00040000 +#ifndef _USE_FULL_PROC_THREAD_ATTRIBUTE typedef enum _PROC_THREAD_ATTRIBUTE_NUM { ProcThreadAttributeParentProcess = 0, ProcThreadAttributeHandleList = 2, @@ -1148,12 +1149,45 @@ typedef enum _PROC_THREAD_ATTRIBUTE_NUM { ProcThreadAttributeTrustedApp = 29, ProcThreadAttributeSveVectorLength = 30, } PROC_THREAD_ATTRIBUTE_NUM; +#endif // _USE_FULL_PROC_THREAD_ATTRIBUTE #define PROC_THREAD_ATTRIBUTE_IDEAL_PROCESSOR (ProcThreadAttributeIdealProcessor | PROC_THREAD_ATTRIBUTE_THREAD | PROC_THREAD_ATTRIBUTE_INPUT) #define PROC_THREAD_ATTRIBUTE_HANDLE_LIST (ProcThreadAttributeHandleList | PROC_THREAD_ATTRIBUTE_INPUT) #define PROC_THREAD_ATTRIBUTE_PARENT_PROCESS (ProcThreadAttributeParentProcess | PROC_THREAD_ATTRIBUTE_INPUT) #define PROC_THREAD_ATTRIBUTE_MACHINE_TYPE (ProcThreadAttributeMachineType | PROC_THREAD_ATTRIBUTE_INPUT) +#if (_WIN32_WINNT >= 0x0600) +#define ProcThreadAttributeValue(Number, Thread, Input, Additive) \ + (((Number) & PROC_THREAD_ATTRIBUTE_NUMBER) | \ + ((Thread != FALSE) ? PROC_THREAD_ATTRIBUTE_THREAD : 0) | \ + ((Input != FALSE) ? PROC_THREAD_ATTRIBUTE_INPUT : 0) | \ + ((Additive != FALSE) ? PROC_THREAD_ATTRIBUTE_ADDITIVE : 0)) +#endif // (_WIN32_WINNT >= 0x0600) + +#if (_WIN32_WINNT >= _WIN32_WINNT_WINTHRESHOLD) +#define PROCESS_CREATION_CHILD_PROCESS_RESTRICTED 0x01 +#define PROCESS_CREATION_CHILD_PROCESS_OVERRIDE 0x02 +#define PROCESS_CREATION_CHILD_PROCESS_RESTRICTED_UNLESS_SECURE 0x04 +#define PROCESS_CREATION_ALL_APPLICATION_PACKAGES_OPT_OUT 0x01 + +#define PROC_THREAD_ATTRIBUTE_JOB_LIST \ + ProcThreadAttributeValue(ProcThreadAttributeJobList, FALSE, TRUE, FALSE) + +#define PROC_THREAD_ATTRIBUTE_CHILD_PROCESS_POLICY \ + ProcThreadAttributeValue(ProcThreadAttributeChildProcessPolicy, FALSE, TRUE, FALSE) + +#define PROC_THREAD_ATTRIBUTE_ALL_APPLICATION_PACKAGES_POLICY \ + ProcThreadAttributeValue(ProcThreadAttributeAllApplicationPackagesPolicy, FALSE, TRUE, FALSE) + +#define PROC_THREAD_ATTRIBUTE_WIN32K_FILTER \ + ProcThreadAttributeValue(ProcThreadAttributeWin32kFilter, FALSE, TRUE, FALSE) +#endif //(_WIN32_WINNT >= _WIN32_WINNT_WINTHRESHOLD) + +#if (NTDDI_VERSION >= NTDDI_WIN10_RS5) +#define PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE \ + ProcThreadAttributeValue(ProcThreadAttributePseudoConsole, FALSE, TRUE, FALSE) +#endif //(NTDDI_VERSION >= NTDDI_WIN10_RS5) + typedef DWORD (WINAPI *PFE_EXPORT_FUNC)( _In_reads_bytes_(ulLength) PBYTE pbData, diff --git a/sdk/include/psdk/winnls.h b/sdk/include/psdk/winnls.h index b796d7864fb..457249f228c 100644 --- a/sdk/include/psdk/winnls.h +++ b/sdk/include/psdk/winnls.h @@ -458,6 +458,30 @@ extern "C" { #define CAL_SABBREVMONTHNAME11 44 #define CAL_SABBREVMONTHNAME12 45 #define CAL_SABBREVMONTHNAME13 46 +#if (WINVER >= _WIN32_WINNT_WIN2K) +#define CAL_SYEARMONTH 47 +#define CAL_ITWODIGITYEARMAX 48 +#endif //(WINVER >= _WIN32_WINNT_WIN2K) +#if (WINVER >= _WIN32_WINNT_VISTA) +#define CAL_SSHORTESTDAYNAME1 49 +#define CAL_SSHORTESTDAYNAME2 50 +#define CAL_SSHORTESTDAYNAME3 51 +#define CAL_SSHORTESTDAYNAME4 52 +#define CAL_SSHORTESTDAYNAME5 53 +#define CAL_SSHORTESTDAYNAME6 54 +#define CAL_SSHORTESTDAYNAME7 55 +#endif //(WINVER >= _WIN32_WINNT_VISTA) +#if (WINVER >= _WIN32_WINNT_WIN7) +#define CAL_SMONTHDAY 56 +#define CAL_SABBREVERASTRING 57 +#endif //(WINVER >= _WIN32_WINNT_WIN7) +#if (WINVER >= _WIN32_WINNT_WIN8) +#define CAL_SRELATIVELONGDATE 58 +#endif //(WINVER >= _WIN32_WINNT_WIN8) +#if (NTDDI_VERSION >= NTDDI_WIN10_RS2) +#define CAL_SENGLISHERANAME 59 +#define CAL_SENGLISHABBREVERANAME 60 +#endif //(NTDDI_VERSION >= NTDDI_WIN10_RS2) #define CAL_GREGORIAN 1 #define CAL_GREGORIAN_US 2 #define CAL_JAPAN 3 @@ -507,8 +531,6 @@ extern "C" { #define DATE_LTRREADING 16 #define DATE_RTLREADING 32 #define MAP_EXPAND_LIGATURES 0x2000 -#define CAL_SYEARMONTH 47 -#define CAL_ITWODIGITYEARMAX 48 #define CAL_NOUSEROVERRIDE LOCALE_NOUSEROVERRIDE #define CAL_RETURN_NUMBER LOCALE_RETURN_NUMBER #define CAL_USE_CP_ACP LOCALE_USE_CP_ACP @@ -524,13 +546,35 @@ typedef long LONG_PTR; #endif #if (WINVER >= 0x0600) -#define MUI_FULL_LANGUAGE 0x01 -#define MUI_LANGUAGE_ID 0x04 -#define MUI_LANGUAGE_NAME 0x08 -#define MUI_MERGE_SYSTEM_FALLBACK 0x10 -#define MUI_MERGE_USER_FALLBACK 0x20 -#define MUI_UI_FALLBACK MUI_MERGE_SYSTEM_FALLBACK | MUI_MERGE_USER_FALLBACK -#define MUI_MACHINE_LANGUAGE_SETTINGS 0x400 +#define MUI_FULL_LANGUAGE 0x0001 +#define MUI_LANGUAGE_ID 0x0004 +#define MUI_LANGUAGE_NAME 0x0008 +#define MUI_MERGE_SYSTEM_FALLBACK 0x0010 +#define MUI_MERGE_USER_FALLBACK 0x0020 +#define MUI_UI_FALLBACK MUI_MERGE_SYSTEM_FALLBACK | MUI_MERGE_USER_FALLBACK +#define MUI_THREAD_LANGUAGES 0x0040 +#define MUI_CONSOLE_FILTER 0x0100 +#define MUI_COMPLEX_SCRIPT_FILTER 0x0200 +#define MUI_RESET_FILTERS 0x0001 +#define MUI_USER_PREFERRED_UI_LANGUAGES 0x0010 +#define MUI_USE_INSTALLED_LANGUAGES 0x0020 +#define MUI_USE_SEARCH_ALL_LANGUAGES 0x0040 +#define MUI_LANG_NEUTRAL_PE_FILE 0x0100 +#define MUI_NON_LANG_NEUTRAL_FILE 0x0200 +#define MUI_MACHINE_LANGUAGE_SETTINGS 0x0400 +#define MUI_FILETYPE_NOT_LANGUAGE_NEUTRAL 0x0001 +#define MUI_FILETYPE_LANGUAGE_NEUTRAL_MAIN 0x0002 +#define MUI_FILETYPE_LANGUAGE_NEUTRAL_MUI 0x0004 +#define MUI_QUERY_TYPE 0x0001 +#define MUI_QUERY_CHECKSUM 0x0002 +#define MUI_QUERY_LANGUAGE_NAME 0x0004 +#define MUI_QUERY_RESOURCE_TYPES 0x0008 +#define MUI_FILEINFO_VERSION 0x0001 +#define MUI_FULL_LANGUAGE 0x0001 +#define MUI_PARTIAL_LANGUAGE 0x0002 +#define MUI_LIP_LANGUAGE 0x0004 +#define MUI_LANGUAGE_INSTALLED 0x0020 +#define MUI_LANGUAGE_LICENSED 0x0040 #endif /* (WINVER >= 0x0600) */ #ifndef RC_INVOKED @@ -572,8 +616,9 @@ enum NLS_FUNCTION { }; typedef enum NLS_FUNCTION NLS_FUNCTION; enum SYSGEOCLASS { - GEOCLASS_NATION = 16, - GEOCLASS_REGION = 14 + GEOCLASS_ALL = 0, + GEOCLASS_REGION = 14, + GEOCLASS_NATION = 16 }; /* Geographic Information types */ @@ -594,7 +639,11 @@ enum SYSGEOTYPE GEO_PARENT, GEO_DIALINGCODE, GEO_CURRENCYCODE, - GEO_CURRENCYSYMBOL + GEO_CURRENCYSYMBOL, +#if (NTDDI_VERSION >= NTDDI_WIN10_RS3) + GEO_NAME, + GEO_ID +#endif }; typedef struct _cpinfo { @@ -638,10 +687,14 @@ typedef struct _currencyfmtW { UINT PositiveOrder; LPWSTR lpCurrencySymbol; } CURRENCYFMTW,*LPCURRENCYFMTW; -typedef struct nlsversioninfo { +typedef struct _nlsversioninfo { DWORD dwNLSVersionInfoSize; DWORD dwNLSVersion; DWORD dwDefinedVersion; +#if (WINVER >= _WIN32_WINNT_WIN8) + DWORD dwEffectiveId; + GUID guidCustomVersion; +#endif } NLSVERSIONINFO,*LPNLSVERSIONINFO; typedef struct _nlsversioninfoex { DWORD dwNLSVersionInfoSize; @@ -978,6 +1031,22 @@ IdnToUnicode( _Out_writes_opt_(cchUnicodeChar) LPWSTR lpUnicodeCharStr, _In_ int cchUnicodeChar); +WINBASEAPI +int +WINAPI +GetSystemDefaultLocaleName( + _Out_writes_(cchLocaleName) LPWSTR lpLocaleName, + _In_ int cchLocaleName); + +WINBASEAPI +BOOL +WINAPI +EnumDateFormatsExEx( + _In_ DATEFMT_ENUMPROCEXEX lpDateFmtEnumProcExEx, + _In_opt_ LPCWSTR lpLocaleName, + _In_ DWORD dwFlags, + _In_ LPARAM lParam); + #endif /* WINVER >= 0x0600 */ BOOL WINAPI IsDBCSLeadByte(_In_ BYTE); diff --git a/sdk/include/psdk/winreg.h b/sdk/include/psdk/winreg.h index bfcb4e59d55..248d00e4162 100644 --- a/sdk/include/psdk/winreg.h +++ b/sdk/include/psdk/winreg.h @@ -39,6 +39,8 @@ extern "C" { #define REG_NOTIFY_CHANGE_ATTRIBUTES 2 #define REG_NOTIFY_CHANGE_LAST_SET 4 #define REG_NOTIFY_CHANGE_SECURITY 8 +#define REG_NOTIFY_THREAD_AGNOSTIC (0x10000000L) +#define REG_MUI_STRING_TRUNCATE 1 /* Shutdown flags for InitiateShutdownA/W */ #define SHUTDOWN_FORCE_OTHERS 0x00000001 @@ -62,6 +64,11 @@ extern "C" { #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_RT_ANY (0x0000FFFF) +#if (_WIN32_WINNT >= _WIN32_WINNT_WIN10) +#define RRF_SUBKEY_WOW6464KEY (0x00010000) +#define RRF_SUBKEY_WOW6432KEY (0x00020000) +#define RRF_WOW64_MASK (0x00030000) +#endif // _WIN32_WINNT >= _WIN32_WINNT_WIN10 #define RRF_NOEXPAND (1 << 28) #define RRF_ZEROONFAILURE (1 << 29) diff --git a/sdk/include/psdk/winsvc.h b/sdk/include/psdk/winsvc.h index 8da56848faf..42705feade2 100644 --- a/sdk/include/psdk/winsvc.h +++ b/sdk/include/psdk/winsvc.h @@ -33,6 +33,12 @@ extern "C" { #define SERVICE_ACCEPT_HARDWAREPROFILECHANGE 32 #define SERVICE_ACCEPT_POWEREVENT 64 #define SERVICE_ACCEPT_SESSIONCHANGE 128 +#define SERVICE_ACCEPT_PRESHUTDOWN 256 +#define SERVICE_ACCEPT_TIMECHANGE 512 +#define SERVICE_ACCEPT_TRIGGEREVENT 1024 +#define SERVICE_ACCEPT_USER_LOGOFF 2048 +#define SERVICE_ACCEPT_LOWRESOURCES 8192 +#define SERVICE_ACCEPT_SYSTEMLOWRESOURCES 16384 #define SERVICE_CONTROL_STOP 1 #define SERVICE_CONTROL_PAUSE 2 #define SERVICE_CONTROL_CONTINUE 3 diff --git a/sdk/include/wine/iphlpapi.h b/sdk/include/wine/iphlpapi.h new file mode 100644 index 00000000000..84b9b7db34c --- /dev/null +++ b/sdk/include/wine/iphlpapi.h @@ -0,0 +1,165 @@ +/* WINE iphlpapi.h + * Copyright (C) 2003 Juan Lang + * + * 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_IPHLPAPI_H__ +#define WINE_IPHLPAPI_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include + +#ifndef IPHLPAPI_DLL_LINKAGE +#define IPHLPAPI_DLL_LINKAGE DECLSPEC_IMPORT +#endif + +#define NET_STRING_IPV4_ADDRESS 0x00000001 +#define NET_STRING_IPV4_SERVICE 0x00000002 +#define NET_STRING_IPV4_NETWORK 0x00000004 +#define NET_STRING_IPV6_ADDRESS 0x00000008 +#define NET_STRING_IPV6_ADDRESS_NO_SCOPE 0x00000010 +#define NET_STRING_IPV6_SERVICE 0x00000020 +#define NET_STRING_IPV6_SERVICE_NO_SCOPE 0x00000040 +#define NET_STRING_IPV6_NETWORK 0x00000080 +#define NET_STRING_NAMED_ADDRESS 0x00000100 +#define NET_STRING_NAMED_SERVICE 0x00000200 +#define NET_STRING_IP_ADDRESS (NET_STRING_IPV4_ADDRESS|NET_STRING_IPV6_ADDRESS) +#define NET_STRING_IP_ADDRESS_NO_SCOPE (NET_STRING_IPV4_ADDRESS|NET_STRING_IPV6_ADDRESS_NO_SCOPE) +#define NET_STRING_IP_SERVICE (NET_STRING_IPV4_SERVICE|NET_STRING_IPV6_SERVICE) +#define NET_STRING_IP_SERVICE_NO_SCOPE (NET_STRING_IPV4_SERVICE|NET_STRING_IPV6_SERVICE_NO_SCOPE) +#define NET_STRING_IP_NETWORK (NET_STRING_IPV4_NETWORK|NET_STRING_IPV6_NETWORK) +#define NET_STRING_ANY_ADDRESS (NET_STRING_NAMED_ADDRESS|NET_STRING_IP_ADDRESS) +#define NET_STRING_ANY_ADDRESS_NO_SCOPE (NET_STRING_NAMED_ADDRESS|NET_STRING_IP_ADDRESS_NO_SCOPE) +#define NET_STRING_ANY_SERVICE (NET_STRING_NAMED_SERVICE|NET_STRING_IP_SERVICE) +#define NET_STRING_ANY_SERVICE_NO_SCOPE (NET_STRING_NAMED_SERVICE|NET_STRING_IP_SERVICE_NO_SCOPE) + +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetNumberOfInterfaces(PDWORD pdwNumIf); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIfEntry(PMIB_IFROW pIfRow); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpNetTable(PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUdp6Table(PMIB_UDP6TABLE pUdpTable, PDWORD pdwSize, BOOL bOrder); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpStatistics(PMIB_IPSTATS pStats); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpStatisticsEx(PMIB_IPSTATS pStats, DWORD dwFamily); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIcmpStatistics(PMIB_ICMP pStats); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIcmpStatisticsEx(PMIB_ICMP_EX pStats, DWORD dwFamily); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetTcpStatistics(PMIB_TCPSTATS pStats); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetTcpStatisticsEx(PMIB_TCPSTATS pStats, DWORD dwFamily); +IPHLPAPI_DLL_LINKAGE ULONG WINAPI GetPerTcpConnectionEStats(MIB_TCPROW *row, TCP_ESTATS_TYPE stats, UCHAR *rw, ULONG rw_version, + ULONG rw_size, UCHAR *ro_static, ULONG ro_static_version, + ULONG ro_static_size, UCHAR *ro_dynamic, ULONG ro_dynamic_version, + ULONG ro_dynamic_size); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUdpStatistics(PMIB_UDPSTATS pStats); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUdpStatisticsEx(PMIB_UDPSTATS pStats, DWORD dwFamily); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetIfEntry(PMIB_IFROW pIfRow); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetIpForwardEntry(PMIB_IPFORWARDROW pRoute); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetIpStatistics(PMIB_IPSTATS pIpStats); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetPerTcpConnectionEStats(MIB_TCPROW *row, TCP_ESTATS_TYPE state, BYTE *rw, ULONG version, ULONG size, ULONG offset); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetIpTTL(UINT nTTL); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI CreateIpNetEntry(PMIB_IPNETROW pArpEntry); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetIpNetEntry(PMIB_IPNETROW pArpEntry); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI DeleteIpNetEntry(PMIB_IPNETROW pArpEntry); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI FlushIpNetTable(DWORD dwIfIndex); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI CreateProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI DeleteProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetTcpEntry(PMIB_TCPROW pTcpRow); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetInterfaceInfo(PIP_INTERFACE_INFO pIfTable, PULONG dwOutBufLen); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUniDirectionalAdapterInfo(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo, PULONG dwOutBufLen); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetBestInterface(IPAddr dwDestAddr, PDWORD pdwBestIfIndex); + +#ifdef __WINE_WINSOCKAPI_STDLIB_H +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetBestInterfaceEx( +#ifdef USE_WS_PREFIX + struct WS_sockaddr *pDestAddr, +#else + struct sockaddr *pDestAddr, +#endif + PDWORD pdwBestIfIndex); +#endif + +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI NotifyAddrChange(PHANDLE Handle, LPOVERLAPPED overlapped); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI NotifyRouteChange(PHANDLE Handle, LPOVERLAPPED overlapped); +IPHLPAPI_DLL_LINKAGE BOOL WINAPI CancelIPChangeNotify(LPOVERLAPPED overlapped); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetAdapterIndex(IN LPWSTR AdapterName, OUT PULONG IfIndex); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI AddIPAddress(IPAddr Address, IPMask IpMask, DWORD IfIndex, PULONG NTEContext, PULONG NTEInstance); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI DeleteIPAddress(ULONG NTEContext); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetNetworkParams(PFIXED_INFO pFixedInfo, PULONG pOutBufLen); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetPerAdapterInfo(ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI IpRenewAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI SendARP(IPAddr DestIP, IPAddr SrcIP, PULONG pMacAddr, PULONG PhyAddrLen); +IPHLPAPI_DLL_LINKAGE BOOL WINAPI GetRTTAndHopCount(IPAddr DestIpAddress, PULONG HopCount, ULONG MaxHops, PULONG RTT); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetFriendlyIfIndex(DWORD IfIndex); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI EnableRouter(HANDLE* pHandle, OVERLAPPED* pOverlapped); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI UnenableRouter(OVERLAPPED* pOverlapped, LPDWORD lpdwEnableCount); + +#ifdef _WINSOCK2API_ +IPHLPAPI_DLL_LINKAGE ULONG WINAPI GetAdaptersAddresses(ULONG family, ULONG flags, PVOID reserved, + PIP_ADAPTER_ADDRESSES aa, PULONG buflen); +#endif + +IPHLPAPI_DLL_LINKAGE DWORD WINAPI AllocateAndGetUdpTableFromStack(PMIB_UDPTABLE *ppUdpTable, BOOL bOrder, HANDLE heap, DWORD flags); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI AllocateAndGetTcpTableFromStack(PMIB_TCPTABLE *ppTcpTable, BOOL bOrder, HANDLE heap, DWORD flags); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI AllocateAndGetTcpExTableFromStack(VOID **ppTcpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI AllocateAndGetIpNetTableFromStack(PMIB_IPNETTABLE *ppIpNetTable, BOOL bOrder, HANDLE heap, DWORD flags); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE *ppIpForwardTable, BOOL bOrder, HANDLE heap, DWORD flags); + +typedef enum NET_ADDRESS_FORMAT_ { + NET_ADDRESS_FORMAT_UNSPECIFIED, + NET_ADDRESS_DNS_NAME, + NET_ADDRESS_IPV4, + NET_ADDRESS_IPV6, +} NET_ADDRESS_FORMAT; + +#ifdef __WINE_WINDNS_H + +typedef struct NET_ADDRESS_INFO_ +{ + NET_ADDRESS_FORMAT Format; + union + { + struct + { + WCHAR Address[DNS_MAX_NAME_BUFFER_LENGTH]; + WCHAR Port[6]; + } NamedAddress; + SOCKADDR_IN Ipv4Address; + SOCKADDR_IN6 Ipv6Address; + SOCKADDR IpAddress; + } DUMMYUNIONNAME; +} NET_ADDRESS_INFO, *PNET_ADDRESS_INFO; + +#endif /* __WINE_WINDNS_H */ + +#ifdef __cplusplus +} +#endif + +#endif /* WINE_IPHLPAPI_H__ */ diff --git a/sdk/include/wine/iptypes.h b/sdk/include/wine/iptypes.h new file mode 100644 index 00000000000..d8609654748 --- /dev/null +++ b/sdk/include/wine/iptypes.h @@ -0,0 +1,335 @@ +/* WINE iptypes.h + * Copyright (C) 2003 Juan Lang + * + * 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_IPTYPES_H_ +#define WINE_IPTYPES_H_ + +#include +#include +#include + +#define MAX_ADAPTER_DESCRIPTION_LENGTH 128 +#define MAX_ADAPTER_NAME_LENGTH 256 +#define MAX_ADAPTER_ADDRESS_LENGTH 8 +#define MAX_HOSTNAME_LEN 128 +#define MAX_DOMAIN_NAME_LEN 128 +#define MAX_SCOPE_ID_LEN 256 +#define MAX_DHCPV6_DUID_LENGTH 130 +#define MAX_DNS_SUFFIX_STRING_LENGTH 256 + +#define BROADCAST_NODETYPE 1 +#define PEER_TO_PEER_NODETYPE 2 +#define MIXED_NODETYPE 4 +#define HYBRID_NODETYPE 8 + +typedef struct { + char String[4 * 4]; +} IP_ADDRESS_STRING, *PIP_ADDRESS_STRING, IP_MASK_STRING, *PIP_MASK_STRING; + +typedef struct _IP_ADDR_STRING { + struct _IP_ADDR_STRING* Next; + IP_ADDRESS_STRING IpAddress; + IP_MASK_STRING IpMask; + DWORD Context; +} IP_ADDR_STRING, *PIP_ADDR_STRING; + +typedef struct _IP_ADAPTER_INFO { + struct _IP_ADAPTER_INFO* Next; + DWORD ComboIndex; + char AdapterName[MAX_ADAPTER_NAME_LENGTH + 4]; + char Description[MAX_ADAPTER_DESCRIPTION_LENGTH + 4]; + UINT AddressLength; + BYTE Address[MAX_ADAPTER_ADDRESS_LENGTH]; + DWORD Index; + UINT Type; + UINT DhcpEnabled; + PIP_ADDR_STRING CurrentIpAddress; + IP_ADDR_STRING IpAddressList; + IP_ADDR_STRING GatewayList; + IP_ADDR_STRING DhcpServer; + BOOL HaveWins; + IP_ADDR_STRING PrimaryWinsServer; + IP_ADDR_STRING SecondaryWinsServer; + time_t LeaseObtained; + time_t LeaseExpires; +} IP_ADAPTER_INFO, *PIP_ADAPTER_INFO; + +typedef struct _IP_PER_ADAPTER_INFO { + UINT AutoconfigEnabled; + UINT AutoconfigActive; + PIP_ADDR_STRING CurrentDnsServer; + IP_ADDR_STRING DnsServerList; +} IP_PER_ADAPTER_INFO, *PIP_PER_ADAPTER_INFO; + +typedef struct { + char HostName[MAX_HOSTNAME_LEN + 4] ; + char DomainName[MAX_DOMAIN_NAME_LEN + 4]; + PIP_ADDR_STRING CurrentDnsServer; + IP_ADDR_STRING DnsServerList; + UINT NodeType; + char ScopeId[MAX_SCOPE_ID_LEN + 4]; + UINT EnableRouting; + UINT EnableProxy; + UINT EnableDns; +} FIXED_INFO, *PFIXED_INFO; + +typedef NL_PREFIX_ORIGIN IP_PREFIX_ORIGIN; +typedef NL_SUFFIX_ORIGIN IP_SUFFIX_ORIGIN; +typedef NL_DAD_STATE IP_DAD_STATE; + +#ifdef _WINSOCK2API_ + +#define IP_ADAPTER_ADDRESS_DNS_ELIGIBLE 0x00000001 +#define IP_ADAPTER_ADDRESS_TRANSIENT 0x00000002 + +typedef struct _IP_ADAPTER_UNICAST_ADDRESS_LH { + union { + struct { + ULONG Length; + DWORD Flags; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + struct _IP_ADAPTER_UNICAST_ADDRESS_LH *Next; + SOCKET_ADDRESS Address; + IP_PREFIX_ORIGIN PrefixOrigin; + IP_SUFFIX_ORIGIN SuffixOrigin; + IP_DAD_STATE DadState; + ULONG ValidLifetime; + ULONG PreferredLifetime; + ULONG LeaseLifetime; + UINT8 OnLinkPrefixLength; +} IP_ADAPTER_UNICAST_ADDRESS_LH, *PIP_ADAPTER_UNICAST_ADDRESS_LH; + +typedef struct _IP_ADAPTER_UNICAST_ADDRESS_XP { + union { + struct { + ULONG Length; + DWORD Flags; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + struct _IP_ADAPTER_UNICAST_ADDRESS_XP *Next; + SOCKET_ADDRESS Address; + IP_PREFIX_ORIGIN PrefixOrigin; + IP_SUFFIX_ORIGIN SuffixOrigin; + IP_DAD_STATE DadState; + ULONG ValidLifetime; + ULONG PreferredLifetime; + ULONG LeaseLifetime; +} IP_ADAPTER_UNICAST_ADDRESS_XP, *PIP_ADAPTER_UNICAST_ADDRESS_XP; + +typedef IP_ADAPTER_UNICAST_ADDRESS_LH IP_ADAPTER_UNICAST_ADDRESS; +typedef IP_ADAPTER_UNICAST_ADDRESS_LH *PIP_ADAPTER_UNICAST_ADDRESS; + +typedef struct _IP_ADAPTER_ANYCAST_ADDRESS { + union { + ULONGLONG Alignment; + struct { + ULONG Length; + DWORD Flags; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + struct _IP_ADAPTER_ANYCAST_ADDRESS *Next; + SOCKET_ADDRESS Address; +} IP_ADAPTER_ANYCAST_ADDRESS, *PIP_ADAPTER_ANYCAST_ADDRESS; + +typedef struct _IP_ADAPTER_MULTICAST_ADDRESS { + union { + ULONGLONG Alignment; + struct { + ULONG Length; + DWORD Flags; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + struct _IP_ADAPTER_MULTICAST_ADDRESS *Next; + SOCKET_ADDRESS Address; +} IP_ADAPTER_MULTICAST_ADDRESS, *PIP_ADAPTER_MULTICAST_ADDRESS; + +typedef struct _IP_ADAPTER_DNS_SERVER_ADDRESS { + union { + ULONGLONG Alignment; + struct { + ULONG Length; + DWORD Reserved; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + struct _IP_ADAPTER_DNS_SERVER_ADDRESS *Next; + SOCKET_ADDRESS Address; +} IP_ADAPTER_DNS_SERVER_ADDRESS, *PIP_ADAPTER_DNS_SERVER_ADDRESS; + +typedef struct _IP_ADAPTER_PREFIX { + union { + ULONGLONG Alignment; + struct { + ULONG Length; + DWORD Flags; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + struct _IP_ADAPTER_PREFIX *Next; + SOCKET_ADDRESS Address; + ULONG PrefixLength; +} IP_ADAPTER_PREFIX, *PIP_ADAPTER_PREFIX; + +typedef struct _IP_ADAPTER_WINS_SERVER_ADDRESS_LH { + union { + ULONGLONG Alignment; + struct { + ULONG Length; + DWORD Reserved; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + struct _IP_ADAPTER_WINS_SERVER_ADDRESS_LH *Next; + SOCKET_ADDRESS Address; +} IP_ADAPTER_WINS_SERVER_ADDRESS_LH, *PIP_ADAPTER_WINS_SERVER_ADDRESS_LH; +typedef IP_ADAPTER_WINS_SERVER_ADDRESS_LH IP_ADAPTER_WINS_SERVER_ADDRESS; +typedef IP_ADAPTER_WINS_SERVER_ADDRESS_LH *PIP_ADAPTER_WINS_SERVER_ADDRESS; + +typedef struct _IP_ADAPTER_GATEWAY_ADDRESS_LH { + union { + ULONGLONG Alignment; + struct { + ULONG Length; + DWORD Reserved; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + struct _IP_ADAPTER_GATEWAY_ADDRESS_LH *Next; + SOCKET_ADDRESS Address; +} IP_ADAPTER_GATEWAY_ADDRESS_LH, *PIP_ADAPTER_GATEWAY_ADDRESS_LH; +typedef IP_ADAPTER_GATEWAY_ADDRESS_LH IP_ADAPTER_GATEWAY_ADDRESS; +typedef IP_ADAPTER_GATEWAY_ADDRESS_LH *PIP_ADAPTER_GATEWAY_ADDRESS; + +typedef struct _IP_ADAPTER_DNS_SUFFIX { + struct _IP_ADAPTER_DNS_SUFFIX *Next; + WCHAR String[MAX_DNS_SUFFIX_STRING_LENGTH]; +} IP_ADAPTER_DNS_SUFFIX, *PIP_ADAPTER_DNS_SUFFIX; + +#define IP_ADAPTER_DDNS_ENABLED 0x1 +#define IP_ADAPTER_REGISTER_ADAPTER_SUFFIX 0x2 +#define IP_ADAPTER_DHCP_ENABLED 0x4 +#define IP_ADAPTER_RECEIVE_ONLY 0x8 +#define IP_ADAPTER_NO_MULTICAST 0x10 +#define IP_ADAPTER_IPV6_OTHER_STATEFUL_CONFIG 0x20 +#define IP_ADAPTER_NETBIOS_OVER_TCPIP_ENABLED 0x40 +#define IP_ADAPTER_IPV4_ENABLED 0x80 +#define IP_ADAPTER_IPV6_ENABLED 0x100 +#define IP_ADAPTER_IPV6_MANAGE_ADDRESS_CONFIG 0x200 + +typedef struct _IP_ADAPTER_ADDRESSES_LH { + union { + ULONGLONG Alignment; + struct { + ULONG Length; + DWORD IfIndex; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + struct _IP_ADAPTER_ADDRESSES_LH *Next; + PCHAR AdapterName; + PIP_ADAPTER_UNICAST_ADDRESS FirstUnicastAddress; + PIP_ADAPTER_ANYCAST_ADDRESS FirstAnycastAddress; + PIP_ADAPTER_MULTICAST_ADDRESS FirstMulticastAddress; + PIP_ADAPTER_DNS_SERVER_ADDRESS FirstDnsServerAddress; + PWCHAR DnsSuffix; + PWCHAR Description; + PWCHAR FriendlyName; + BYTE PhysicalAddress[MAX_ADAPTER_ADDRESS_LENGTH]; + DWORD PhysicalAddressLength; + union { + DWORD Flags; + struct { + DWORD DdnsEnabled : 1; + DWORD RegisterAdapterSuffix : 1; + DWORD Dhcpv4Enabled : 1; + DWORD ReceiveOnly : 1; + DWORD NoMulticast : 1; + DWORD Ipv6OtherStatefulConfig : 1; + DWORD NetbiosOverTcpipEnabled : 1; + DWORD Ipv4Enabled : 1; + DWORD Ipv6Enabled : 1; + DWORD Ipv6ManagedAddressConfigurationSupported : 1; + } DUMMYSTRUCTNAME1; + } DUMMYUNIONNAME1; + DWORD Mtu; + DWORD IfType; + IF_OPER_STATUS OperStatus; + DWORD Ipv6IfIndex; + DWORD ZoneIndices[16]; + PIP_ADAPTER_PREFIX FirstPrefix; + ULONG64 TransmitLinkSpeed; + ULONG64 ReceiveLinkSpeed; + PIP_ADAPTER_WINS_SERVER_ADDRESS_LH FirstWinsServerAddress; + PIP_ADAPTER_GATEWAY_ADDRESS_LH FirstGatewayAddress; + ULONG Ipv4Metric; + ULONG Ipv6Metric; + IF_LUID Luid; + SOCKET_ADDRESS Dhcpv4Server; + NET_IF_COMPARTMENT_ID CompartmentId; + NET_IF_NETWORK_GUID NetworkGuid; + NET_IF_CONNECTION_TYPE ConnectionType; + TUNNEL_TYPE TunnelType; + SOCKET_ADDRESS Dhcpv6Server; + BYTE Dhcpv6ClientDuid[MAX_DHCPV6_DUID_LENGTH]; + ULONG Dhcpv6ClientDuidLength; + ULONG Dhcpv6Iaid; + PIP_ADAPTER_DNS_SUFFIX FirstDnsSuffix; +} IP_ADAPTER_ADDRESSES_LH, *PIP_ADAPTER_ADDRESSES_LH; + +typedef struct _IP_ADAPTER_ADDRESSES_XP { + union { + ULONGLONG Alignment; + struct { + ULONG Length; + DWORD IfIndex; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + struct _IP_ADAPTER_ADDRESSES_XP *Next; + PCHAR AdapterName; + PIP_ADAPTER_UNICAST_ADDRESS FirstUnicastAddress; + PIP_ADAPTER_ANYCAST_ADDRESS FirstAnycastAddress; + PIP_ADAPTER_MULTICAST_ADDRESS FirstMulticastAddress; + PIP_ADAPTER_DNS_SERVER_ADDRESS FirstDnsServerAddress; + PWCHAR DnsSuffix; + PWCHAR Description; + PWCHAR FriendlyName; + BYTE PhysicalAddress[MAX_ADAPTER_ADDRESS_LENGTH]; + DWORD PhysicalAddressLength; + DWORD Flags; + DWORD Mtu; + DWORD IfType; + IF_OPER_STATUS OperStatus; + DWORD Ipv6IfIndex; + DWORD ZoneIndices[16]; + PIP_ADAPTER_PREFIX FirstPrefix; +} IP_ADAPTER_ADDRESSES_XP, *PIP_ADAPTER_ADDRESSES_XP; + +typedef IP_ADAPTER_ADDRESSES_LH IP_ADAPTER_ADDRESSES; +typedef IP_ADAPTER_ADDRESSES_LH *PIP_ADAPTER_ADDRESSES; + +#define GAA_FLAG_SKIP_UNICAST 0x00000001 +#define GAA_FLAG_SKIP_ANYCAST 0x00000002 +#define GAA_FLAG_SKIP_MULTICAST 0x00000004 +#define GAA_FLAG_SKIP_DNS_SERVER 0x00000008 +#define GAA_FLAG_INCLUDE_PREFIX 0x00000010 +#define GAA_FLAG_SKIP_FRIENDLY_NAME 0x00000020 +#define GAA_FLAG_INCLUDE_WINS_INFO 0x00000040 +#define GAA_FLAG_INCLUDE_GATEWAYS 0x00000080 +#define GAA_FLAG_INCLUDE_ALL_INTERFACES 0x00000100 +#define GAA_FLAG_INCLUDE_ALL_COMPARTMENTS 0x00000200 +#define GAA_FLAG_INCLUDE_TUNNEL_BINDINGORDER 0x00000400 + +#endif /* _WINSOCK2API_ */ + +#endif /* WINE_IPTYPES_H_*/ diff --git a/sdk/include/wine/netioapi.h b/sdk/include/wine/netioapi.h new file mode 100644 index 00000000000..9a9cff8ca79 --- /dev/null +++ b/sdk/include/wine/netioapi.h @@ -0,0 +1,288 @@ +/* + * Copyright 2015 Hans Leidekker for CodeWeavers + * + * 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_NETIOAPI_H +#define __WINE_NETIOAPI_H + +#include + +#ifndef IPHLPAPI_DLL_LINKAGE +#define IPHLPAPI_DLL_LINKAGE DECLSPEC_IMPORT +#endif + +#ifndef ANY_SIZE +#define ANY_SIZE 1 +#endif + +typedef enum _MIB_IF_TABLE_LEVEL +{ + MibIfTableNormal, + MibIfTableRaw, + MibIfTableNormalWithoutStatistics, +} MIB_IF_TABLE_LEVEL, *PMIB_IF_TABLE_LEVEL; + +typedef enum _MIB_NOTIFICATION_TYPE +{ + MibParameterNotification, + MibAddInstance, + MibDeleteInstance, + MibInitialNotification, +} MIB_NOTIFICATION_TYPE, *PMIB_NOTIFICATION_TYPE; + +typedef struct _MIB_IF_ROW2 +{ + NET_LUID InterfaceLuid; + NET_IFINDEX InterfaceIndex; + GUID InterfaceGuid; + WCHAR Alias[IF_MAX_STRING_SIZE + 1]; + WCHAR Description[IF_MAX_STRING_SIZE + 1]; + ULONG PhysicalAddressLength; + UCHAR PhysicalAddress[IF_MAX_PHYS_ADDRESS_LENGTH]; + UCHAR PermanentPhysicalAddress[IF_MAX_PHYS_ADDRESS_LENGTH]; + ULONG Mtu; + IFTYPE Type; + TUNNEL_TYPE TunnelType; + NDIS_MEDIUM MediaType; + NDIS_PHYSICAL_MEDIUM PhysicalMediumType; + NET_IF_ACCESS_TYPE AccessType; + NET_IF_DIRECTION_TYPE DirectionType; + struct + { + BOOLEAN HardwareInterface : 1; + BOOLEAN FilterInterface : 1; + BOOLEAN ConnectorPresent : 1; + BOOLEAN NotAuthenticated : 1; + BOOLEAN NotMediaConnected : 1; + BOOLEAN Paused : 1; + BOOLEAN LowPower : 1; + BOOLEAN EndPointInterface : 1; + } InterfaceAndOperStatusFlags; + IF_OPER_STATUS OperStatus; + NET_IF_ADMIN_STATUS AdminStatus; + NET_IF_MEDIA_CONNECT_STATE MediaConnectState; + NET_IF_NETWORK_GUID NetworkGuid; + NET_IF_CONNECTION_TYPE ConnectionType; + ULONG64 TransmitLinkSpeed; + ULONG64 ReceiveLinkSpeed; + ULONG64 InOctets; + ULONG64 InUcastPkts; + ULONG64 InNUcastPkts; + ULONG64 InDiscards; + ULONG64 InErrors; + ULONG64 InUnknownProtos; + ULONG64 InUcastOctets; + ULONG64 InMulticastOctets; + ULONG64 InBroadcastOctets; + ULONG64 OutOctets; + ULONG64 OutUcastPkts; + ULONG64 OutNUcastPkts; + ULONG64 OutDiscards; + ULONG64 OutErrors; + ULONG64 OutUcastOctets; + ULONG64 OutMulticastOctets; + ULONG64 OutBroadcastOctets; + ULONG64 OutQLen; +} MIB_IF_ROW2, *PMIB_IF_ROW2; + +typedef struct _MIB_IF_TABLE2 +{ + ULONG NumEntries; + MIB_IF_ROW2 Table[1]; +} MIB_IF_TABLE2, *PMIB_IF_TABLE2; + +typedef struct _MIB_IPINTERFACE_ROW +{ + ADDRESS_FAMILY Family; + NET_LUID InterfaceLuid; + NET_IFINDEX InterfaceIndex; + ULONG MaxReassemblySize; + ULONG64 InterfaceIdentifier; + ULONG MinRouterAdvertisementInterval; + ULONG MaxRouterAdvertisementInterval; + BOOLEAN AdvertisingEnabled; + BOOLEAN ForwardingEnabled; + BOOLEAN WeakHostSend; + BOOLEAN WeakHostReceive; + BOOLEAN UseAutomaticMetric; + BOOLEAN UseNeighborUnreachabilityDetection; + BOOLEAN ManagedAddressConfigurationSupported; + BOOLEAN OtherStatefulConfigurationSupported; + BOOLEAN AdvertiseDefaultRoute; + NL_ROUTER_DISCOVERY_BEHAVIOR RouterDiscoveryBehavior; + ULONG DadTransmits; + ULONG BaseReachableTime; + ULONG RetransmitTime; + ULONG PathMtuDiscoveryTimeout; + NL_LINK_LOCAL_ADDRESS_BEHAVIOR LinkLocalAddressBehavior; + ULONG LinkLocalAddressTimeout; + ULONG ZoneIndices[ScopeLevelCount]; + ULONG SitePrefixLength; + ULONG Metric; + ULONG NlMtu; + BOOLEAN Connected; + BOOLEAN SupportsWakeUpPatterns; + BOOLEAN SupportsNeighborDiscovery; + BOOLEAN SupportsRouterDiscovery; + ULONG ReachableTime; + NL_INTERFACE_OFFLOAD_ROD TransmitOffload; + NL_INTERFACE_OFFLOAD_ROD ReceiveOffload; + BOOLEAN DisableDefaultRoutes; +} MIB_IPINTERFACE_ROW, *PMIB_IPINTERFACE_ROW; + +typedef struct _MIB_IPINTERFACE_TABLE +{ + ULONG NumEntries; + MIB_IPINTERFACE_ROW Table[ANY_SIZE]; +} MIB_IPINTERFACE_TABLE, *PMIB_IPINTERFACE_TABLE; + +typedef struct _MIB_UNICASTIPADDRESS_ROW +{ + SOCKADDR_INET Address; + NET_LUID InterfaceLuid; + NET_IFINDEX InterfaceIndex; + NL_PREFIX_ORIGIN PrefixOrigin; + NL_SUFFIX_ORIGIN SuffixOrigin; + ULONG ValidLifetime; + ULONG PreferredLifetime; + UINT8 OnLinkPrefixLength; + BOOLEAN SkipAsSource; + NL_DAD_STATE DadState; + SCOPE_ID ScopeId; + LARGE_INTEGER CreationTimeStamp; +} MIB_UNICASTIPADDRESS_ROW, *PMIB_UNICASTIPADDRESS_ROW; + +typedef struct _MIB_UNICASTIPADDRESS_TABLE +{ + ULONG NumEntries; + MIB_UNICASTIPADDRESS_ROW Table[1]; +} MIB_UNICASTIPADDRESS_TABLE, *PMIB_UNICASTIPADDRESS_TABLE; + +typedef struct _MIB_ANYCASTIPADDRESS_ROW +{ + SOCKADDR_INET Address; + NET_LUID InterfaceLuid; + NET_IFINDEX InterfaceIndex; + SCOPE_ID ScopeId; +} MIB_ANYCASTIPADDRESS_ROW, *PMIB_ANYCASTIPADDRESS_ROW; + +typedef struct _MIB_ANYCASTIPADDRESS_TABLE +{ + ULONG NumEntries; + MIB_ANYCASTIPADDRESS_ROW Table[ANY_SIZE]; +} MIB_ANYCASTIPADDRESS_TABLE, *PMIB_ANYCASTIPADDRESS_TABLE; + +typedef struct _IP_ADDRESS_PREFIX +{ + SOCKADDR_INET Prefix; + UINT8 PrefixLength; +} IP_ADDRESS_PREFIX, *PIP_ADDRESS_PREFIX; + +typedef struct _MIB_IPFORWARD_ROW2 +{ + NET_LUID InterfaceLuid; + NET_IFINDEX InterfaceIndex; + IP_ADDRESS_PREFIX DestinationPrefix; + SOCKADDR_INET NextHop; + UCHAR SitePrefixLength; + ULONG ValidLifetime; + ULONG PreferredLifetime; + ULONG Metric; + NL_ROUTE_PROTOCOL Protocol; + BOOLEAN Loopback; + BOOLEAN AutoconfigureAddress; + BOOLEAN Publish; + BOOLEAN Immortal; + ULONG Age; + NL_ROUTE_ORIGIN Origin; +} MIB_IPFORWARD_ROW2, *PMIB_IPFORWARD_ROW2; + +typedef struct _MIB_IPFORWARD_TABLE2 +{ + ULONG NumEntries; + MIB_IPFORWARD_ROW2 Table[ANY_SIZE]; +} MIB_IPFORWARD_TABLE2, *PMIB_IPFORWARD_TABLE2; + +typedef struct _MIB_IPNET_ROW2 +{ + SOCKADDR_INET Address; + NET_IFINDEX InterfaceIndex; + NET_LUID InterfaceLuid; + UCHAR PhysicalAddress[IF_MAX_PHYS_ADDRESS_LENGTH]; + ULONG PhysicalAddressLength; + NL_NEIGHBOR_STATE State; + + union + { + struct + { + BOOLEAN IsRouter : 1; + BOOLEAN IsUnreachable : 1; + } DUMMYSTRUCTNAME; + UCHAR Flags; + } DUMMYUNIONNAME; + + union + { + ULONG LastReachable; + ULONG LastUnreachable; + } ReachabilityTime; +} MIB_IPNET_ROW2, *PMIB_IPNET_ROW2; + +typedef struct _MIB_IPNET_TABLE2 +{ + ULONG NumEntries; + MIB_IPNET_ROW2 Table[ANY_SIZE]; +} MIB_IPNET_TABLE2, *PMIB_IPNET_TABLE2; + +typedef VOID (WINAPI *PIPINTERFACE_CHANGE_CALLBACK)(PVOID, PMIB_IPINTERFACE_ROW, + MIB_NOTIFICATION_TYPE); +typedef VOID (WINAPI *PUNICAST_IPADDRESS_CHANGE_CALLBACK)(PVOID, PMIB_UNICASTIPADDRESS_ROW, + MIB_NOTIFICATION_TYPE); + +typedef VOID (WINAPI *PIPFORWARD_CHANGE_CALLBACK)(VOID*,MIB_IPFORWARD_ROW2*,MIB_NOTIFICATION_TYPE); + +IPHLPAPI_DLL_LINKAGE DWORD WINAPI ConvertInterfaceAliasToLuid(const WCHAR*,NET_LUID*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI ConvertInterfaceGuidToLuid(const GUID*,NET_LUID*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI ConvertInterfaceIndexToLuid(NET_IFINDEX,NET_LUID*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI ConvertInterfaceLuidToAlias(const NET_LUID*,WCHAR*,SIZE_T); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI ConvertInterfaceLuidToGuid(const NET_LUID*,GUID*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI ConvertInterfaceLuidToIndex(const NET_LUID*,NET_IFINDEX*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI ConvertInterfaceLuidToNameA(const NET_LUID*,char*,SIZE_T); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI ConvertInterfaceLuidToNameW(const NET_LUID*,WCHAR*,SIZE_T); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI ConvertInterfaceNameToLuidA(const char*,NET_LUID*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI ConvertInterfaceNameToLuidW(const WCHAR*,NET_LUID*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI ConvertLengthToIpv4Mask(ULONG,ULONG*); +IPHLPAPI_DLL_LINKAGE void WINAPI FreeMibTable(void*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetAnycastIpAddressTable(ADDRESS_FAMILY,MIB_ANYCASTIPADDRESS_TABLE**); +IPHLPAPI_DLL_LINKAGE NET_IF_COMPARTMENT_ID WINAPI GetCurrentThreadCompartmentId(void); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIfEntry2(MIB_IF_ROW2*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIfEntry2Ex(MIB_IF_TABLE_LEVEL,MIB_IF_ROW2*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIfTable2(MIB_IF_TABLE2**); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIfTable2Ex(MIB_IF_TABLE_LEVEL,MIB_IF_TABLE2**); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpForwardEntry2(MIB_IPFORWARD_ROW2*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpForwardTable2(ADDRESS_FAMILY,MIB_IPFORWARD_TABLE2**); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpInterfaceTable(ADDRESS_FAMILY,MIB_IPINTERFACE_TABLE**); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpNetEntry2(MIB_IPNET_ROW2*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpNetTable2(ADDRESS_FAMILY,MIB_IPNET_TABLE2**); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUnicastIpAddressEntry(MIB_UNICASTIPADDRESS_ROW*); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUnicastIpAddressTable(ADDRESS_FAMILY,MIB_UNICASTIPADDRESS_TABLE**); +IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetCurrentThreadCompartmentId(NET_IF_COMPARTMENT_ID); +IPHLPAPI_DLL_LINKAGE PCHAR WINAPI if_indextoname(NET_IFINDEX,PCHAR); +IPHLPAPI_DLL_LINKAGE NET_IFINDEX WINAPI if_nametoindex(PCSTR); + +#endif /* __WINE_NETIOAPI_H */ diff --git a/sdk/include/wine/tcpestats.h b/sdk/include/wine/tcpestats.h new file mode 100644 index 00000000000..0e22ee6b843 --- /dev/null +++ b/sdk/include/wine/tcpestats.h @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2015 Bruno Jesus + * + * 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 _TCPESTATS_ +#define _TCPESTATS_ + +/* Values used in Get/SetPerTcpConnectionEStats */ +typedef enum +{ + TcpConnectionEstatsSynOpts, + TcpConnectionEstatsData, + TcpConnectionEstatsSndCong, + TcpConnectionEstatsPath, + TcpConnectionEstatsSendBuff, + TcpConnectionEstatsRec, + TcpConnectionEstatsObsRec, + TcpConnectionEstatsBandwidth, + TcpConnectionEstatsFineRtt, + TcpConnectionEstatsMaximum +} TCP_ESTATS_TYPE; + +#endif /* _TCPESTATS_ */ diff --git a/sdk/include/wine/tcpmib.h b/sdk/include/wine/tcpmib.h new file mode 100644 index 00000000000..6576f8afa5a --- /dev/null +++ b/sdk/include/wine/tcpmib.h @@ -0,0 +1,230 @@ +/* + * Copyright (C) 2003 Juan Lang + * + * 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_TCPMIB_H +#define __WINE_TCPMIB_H + +#define TCPIP_OWNING_MODULE_SIZE 16 + + +/* TCP tables */ + +typedef enum +{ + MIB_TCP_STATE_CLOSED = 1, + MIB_TCP_STATE_LISTEN = 2, + MIB_TCP_STATE_SYN_SENT = 3, + MIB_TCP_STATE_SYN_RCVD = 4, + MIB_TCP_STATE_ESTAB = 5, + MIB_TCP_STATE_FIN_WAIT1 = 6, + MIB_TCP_STATE_FIN_WAIT2 = 7, + MIB_TCP_STATE_CLOSE_WAIT = 8, + MIB_TCP_STATE_CLOSING = 9, + MIB_TCP_STATE_LAST_ACK = 10, + MIB_TCP_STATE_TIME_WAIT = 11, + MIB_TCP_STATE_DELETE_TCB = 12, +} MIB_TCP_STATE; + +typedef enum +{ + TcpConnectionOffloadStateInHost, + TcpConnectionOffloadStateOffloading, + TcpConnectionOffloadStateOffloaded, + TcpConnectionOffloadStateUploading, + TcpConnectionOffloadStateMax, +} TCP_CONNECTION_OFFLOAD_STATE, *PTCP_CONNECTION_OFFLOAD_STATE; + +typedef struct _MIB_TCPROW +{ + union + { + DWORD dwState; + MIB_TCP_STATE State; + } DUMMYUNIONNAME; + DWORD dwLocalAddr; + DWORD dwLocalPort; + DWORD dwRemoteAddr; + DWORD dwRemotePort; +} MIB_TCPROW, *PMIB_TCPROW; + +typedef struct _MIB_TCPTABLE +{ + DWORD dwNumEntries; + MIB_TCPROW table[1]; +} MIB_TCPTABLE, *PMIB_TCPTABLE; + +typedef struct _MIB_TCP6ROW { + MIB_TCP_STATE State; + IN6_ADDR LocalAddr; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + IN6_ADDR RemoteAddr; + DWORD dwRemoteScopeId; + DWORD dwRemotePort; +} MIB_TCP6ROW, *PMIB_TCP6ROW; + +typedef struct _MIB_TCP6TABLE { + DWORD dwNumEntries; + MIB_TCP6ROW table[1]; +} MIB_TCP6TABLE, *PMIB_TCP6TABLE; + +typedef struct _MIB_TCP6ROW2 { + IN6_ADDR LocalAddr; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + IN6_ADDR RemoteAddr; + DWORD dwRemoteScopeId; + DWORD dwRemotePort; + MIB_TCP_STATE State; + DWORD dwOwningPid; + TCP_CONNECTION_OFFLOAD_STATE dwOffloadState; +} MIB_TCP6ROW2, *PMIB_TCP6ROW2; + +typedef struct _MIB_TCP6TABLE2 { + DWORD dwNumEntries; + MIB_TCP6ROW2 table[1]; +} MIB_TCP6TABLE2, *PMIB_TCP6TABLE2; + +typedef struct _MIB_TCPROW_OWNER_PID +{ + DWORD dwState; + DWORD dwLocalAddr; + DWORD dwLocalPort; + DWORD dwRemoteAddr; + DWORD dwRemotePort; + DWORD dwOwningPid; +} MIB_TCPROW_OWNER_PID, *PMIB_TCPROW_OWNER_PID; + +typedef struct _MIB_TCPTABLE_OWNER_PID +{ + DWORD dwNumEntries; + MIB_TCPROW_OWNER_PID table[1]; +} MIB_TCPTABLE_OWNER_PID, *PMIB_TCPTABLE_OWNER_PID; + +typedef struct _MIB_TCP6ROW_OWNER_PID +{ + UCHAR ucLocalAddr[16]; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + UCHAR ucRemoteAddr[16]; + DWORD dwRemoteScopeId; + DWORD dwRemotePort; + DWORD dwState; + DWORD dwOwningPid; +} MIB_TCP6ROW_OWNER_PID, *PMIB_TCP6ROW_OWNER_PID; + +typedef struct _MIB_TCP6TABLE_OWNER_PID +{ + DWORD dwNumEntries; + MIB_TCP6ROW_OWNER_PID table[1]; +} MIB_TCP6TABLE_OWNER_PID, *PMIB_TCP6TABLE_OWNER_PID; + +typedef struct _MIB_TCPROW_OWNER_MODULE +{ + DWORD dwState; + DWORD dwLocalAddr; + DWORD dwLocalPort; + DWORD dwRemoteAddr; + DWORD dwRemotePort; + DWORD dwOwningPid; + LARGE_INTEGER liCreateTimestamp; + ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]; +} MIB_TCPROW_OWNER_MODULE, *PMIB_TCPROW_OWNER_MODULE; + +typedef struct _MIB_TCPTABLE_OWNER_MODULE +{ + DWORD dwNumEntries; + MIB_TCPROW_OWNER_MODULE table[1]; +} MIB_TCPTABLE_OWNER_MODULE, *PMIB_TCPTABLE_OWNER_MODULE; + +typedef struct _MIB_TCP6ROW_OWNER_MODULE +{ + UCHAR ucLocalAddr[16]; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + UCHAR ucRemoteAddr[16]; + DWORD dwRemoteScopeId; + DWORD dwRemotePort; + DWORD dwState; + DWORD dwOwningPid; + LARGE_INTEGER liCreateTimestamp; + ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]; +} MIB_TCP6ROW_OWNER_MODULE, *PMIB_TCP6ROW_OWNER_MODULE; + +typedef struct _MIB_TCP6TABLE_OWNER_MODULE +{ + DWORD dwNumEntries; + MIB_TCP6ROW_OWNER_MODULE table[1]; +} MIB_TCP6TABLE_OWNER_MODULE, *PMIB_TCP6TABLE_OWNER_MODULE; + +typedef struct _MIB_TCPROW2 +{ + DWORD dwState; + DWORD dwLocalAddr; + DWORD dwLocalPort; + DWORD dwRemoteAddr; + DWORD dwRemotePort; + DWORD dwOwningPid; + TCP_CONNECTION_OFFLOAD_STATE dwOffloadState; +} MIB_TCPROW2, *PMIB_TCPROW2; + +typedef struct _MIB_TCPTABLE2 +{ + DWORD dwNumEntries; + MIB_TCPROW2 table[1]; +} MIB_TCPTABLE2, *PMIB_TCPTABLE2; + + +/* TCP stats */ + +typedef enum +{ + TcpRtoAlgorithmOther = 0, + TcpRtoAlgorithmConstant = 1, + TcpRtoAlgorithmRsre = 2, + TcpRtoAlgorithmVanj = 3, + + MIB_TCP_RTO_OTHER = 1, + MIB_TCP_RTO_CONSTANT = 2, + MIB_TCP_RTO_RSRE = 3, + MIB_TCP_RTO_VANJ = 4, +} TCP_RTO_ALGORITHM, *PTCP_RTO_ALGORITHM; + +typedef struct _MIB_TCPSTATS +{ + union + { + DWORD dwRtoAlgorithm; + TCP_RTO_ALGORITHM RtoAlgorithm; + } DUMMYUNIONNAME; + DWORD dwRtoMin; + DWORD dwRtoMax; + DWORD dwMaxConn; + DWORD dwActiveOpens; + DWORD dwPassiveOpens; + DWORD dwAttemptFails; + DWORD dwEstabResets; + DWORD dwCurrEstab; + DWORD dwInSegs; + DWORD dwOutSegs; + DWORD dwRetransSegs; + DWORD dwInErrs; + DWORD dwOutRsts; + DWORD dwNumConns; +} MIB_TCPSTATS, *PMIB_TCPSTATS; + +#endif /* __WINE_TCPMIB_H */ diff --git a/sdk/include/wine/test.h b/sdk/include/wine/test.h index f1e80c4f77e..2ac1cf7a168 100644 --- a/sdk/include/wine/test.h +++ b/sdk/include/wine/test.h @@ -89,6 +89,7 @@ static inline const char *debugstr_a( const char *s ) { return wine_dbgstr_an( static inline const char *debugstr_an( const CHAR *s, intptr_t n ) { return wine_dbgstr_an( s, n ); } static inline const char *debugstr_w( const WCHAR *s ) { return wine_dbgstr_wn( s, -1 ); } static inline const char *debugstr_wn( const WCHAR *s, int n ) { return wine_dbgstr_wn( s, n ); } +static inline const char *debugstr_guid( const struct _GUID *id ) { return wine_dbgstr_guid(id); } static inline const char *wine_dbgstr_a( const char *s ) { return wine_dbgstr_an( s, -1 ); } static inline const char *wine_dbgstr_w( const WCHAR *s ) { return wine_dbgstr_wn( s, -1 ); } diff --git a/sdk/include/wine/udpmib.h b/sdk/include/wine/udpmib.h new file mode 100644 index 00000000000..4b670b00078 --- /dev/null +++ b/sdk/include/wine/udpmib.h @@ -0,0 +1,136 @@ +/* + * Copyright (C) 2003 Juan Lang + * + * 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_UDPMIB_H +#define __WINE_UDPMIB_H + +#define TCPIP_OWNING_MODULE_SIZE 16 + + +/* UDP table */ + +typedef struct _MIB_UDPROW +{ + DWORD dwLocalAddr; + DWORD dwLocalPort; +} MIB_UDPROW, *PMIB_UDPROW; + +typedef struct _MIB_UDPTABLE +{ + DWORD dwNumEntries; + MIB_UDPROW table[1]; +} MIB_UDPTABLE, *PMIB_UDPTABLE; + +typedef struct _MIB_UDPROW_OWNER_PID +{ + DWORD dwLocalAddr; + DWORD dwLocalPort; + DWORD dwOwningPid; +} MIB_UDPROW_OWNER_PID, *PMIB_UDPROW_OWNER_PID; + +typedef struct _MIB_UDPTABLE_OWNER_PID +{ + DWORD dwNumEntries; + MIB_UDPROW_OWNER_PID table[1]; +} MIB_UDPTABLE_OWNER_PID, *PMIB_UDPTABLE_OWNER_PID; + +typedef struct _MIB_UDPROW_OWNER_MODULE +{ + DWORD dwLocalAddr; + DWORD dwLocalPort; + DWORD dwOwningPid; + LARGE_INTEGER liCreateTimestamp; + __C89_NAMELESS union + { + __C89_NAMELESS struct + { + int SpecificPortBind:1; + } __C89_NAMELESSSTRUCTNAME; + int dwFlags; + } __C89_NAMELESSUNIONNAME; + ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]; +} MIB_UDPROW_OWNER_MODULE, *PMIB_UDPROW_OWNER_MODULE; + +typedef struct _MIB_UDPTABLE_OWNER_MODULE +{ + DWORD dwNumEntries; + MIB_UDPROW_OWNER_MODULE table[1]; +} MIB_UDPTABLE_OWNER_MODULE, *PMIB_UDPTABLE_OWNER_MODULE; + +typedef struct _MIB_UDP6ROW +{ + IN6_ADDR dwLocalAddr; + DWORD dwLocalScopeId; + DWORD dwLocalPort; +} MIB_UDP6ROW, *PMIB_UDP6ROW; + +typedef struct _MIB_UDP6TABLE +{ + DWORD dwNumEntries; + MIB_UDP6ROW table[1]; +} MIB_UDP6TABLE, *PMIB_UDP6TABLE; + +typedef struct _MIB_UDP6ROW_OWNER_PID +{ + UCHAR ucLocalAddr[16]; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + DWORD dwOwningPid; +} MIB_UDP6ROW_OWNER_PID, *PMIB_UDP6ROW_OWNER_PID; + +typedef struct _MIB_UDP6TABLE_OWNER_PID +{ + DWORD dwNumEntries; + MIB_UDP6ROW_OWNER_PID table[1]; +} MIB_UDP6TABLE_OWNER_PID, *PMIB_UDP6TABLE_OWNER_PID; + +typedef struct _MIB_UDP6ROW_OWNER_MODULE +{ + UCHAR ucLocalAddr[16]; + DWORD dwLocalScopeId; + DWORD dwLocalPort; + DWORD dwOwningPid; + LARGE_INTEGER liCreateTimestamp; + __C89_NAMELESS union + { + __C89_NAMELESS struct + { + int SpecificPortBind:1; + } __C89_NAMELESSSTRUCTNAME; + int dwFlags; + } __C89_NAMELESSUNIONNAME; + ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]; +} MIB_UDP6ROW_OWNER_MODULE, *PMIB_UDP6ROW_OWNER_MODULE; + +typedef struct _MIB_UDP6TABLE_OWNER_MODULE +{ + DWORD dwNumEntries; + MIB_UDP6ROW_OWNER_MODULE table[1]; +} MIB_UDP6TABLE_OWNER_MODULE, *PMIB_UDP6TABLE_OWNER_MODULE; + +/* UDP statistics */ + +typedef struct _MIB_UDPSTATS +{ + DWORD dwInDatagrams; + DWORD dwNoPorts; + DWORD dwInErrors; + DWORD dwOutDatagrams; + DWORD dwNumAddrs; +} MIB_UDPSTATS, *PMIB_UDPSTATS; + +#endif /* __WINE_UDPMIB_H */ diff --git a/sdk/include/wine/windns.h b/sdk/include/wine/windns.h new file mode 100644 index 00000000000..05d3359b1df --- /dev/null +++ b/sdk/include/wine/windns.h @@ -0,0 +1,828 @@ +/* + * DNS support + * + * Copyright (C) 2006 Matthew Kehrer + * + * 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_WINDNS_H +#define __WINE_WINDNS_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define DNS_TYPE_ZERO 0x0000 +#define DNS_TYPE_A 0x0001 +#define DNS_TYPE_NS 0x0002 +#define DNS_TYPE_MD 0x0003 +#define DNS_TYPE_MF 0x0004 +#define DNS_TYPE_CNAME 0x0005 +#define DNS_TYPE_SOA 0x0006 +#define DNS_TYPE_MB 0x0007 +#define DNS_TYPE_MG 0x0008 +#define DNS_TYPE_MR 0x0009 +#define DNS_TYPE_NULL 0x000a +#define DNS_TYPE_WKS 0x000b +#define DNS_TYPE_PTR 0x000c +#define DNS_TYPE_HINFO 0x000d +#define DNS_TYPE_MINFO 0x000e +#define DNS_TYPE_MX 0x000f +#define DNS_TYPE_TEXT 0x0010 +#define DNS_TYPE_RP 0x0011 +#define DNS_TYPE_AFSDB 0x0012 +#define DNS_TYPE_X25 0x0013 +#define DNS_TYPE_ISDN 0x0014 +#define DNS_TYPE_RT 0x0015 +#define DNS_TYPE_NSAP 0x0016 +#define DNS_TYPE_NSAPPTR 0x0017 +#define DNS_TYPE_SIG 0x0018 +#define DNS_TYPE_KEY 0x0019 +#define DNS_TYPE_PX 0x001a +#define DNS_TYPE_GPOS 0x001b +#define DNS_TYPE_AAAA 0x001c +#define DNS_TYPE_LOC 0x001d +#define DNS_TYPE_NXT 0x001e +#define DNS_TYPE_EID 0x001f +#define DNS_TYPE_NIMLOC 0x0020 +#define DNS_TYPE_SRV 0x0021 +#define DNS_TYPE_ATMA 0x0022 +#define DNS_TYPE_NAPTR 0x0023 +#define DNS_TYPE_KX 0x0024 +#define DNS_TYPE_CERT 0x0025 +#define DNS_TYPE_A6 0x0026 +#define DNS_TYPE_DNAME 0x0027 +#define DNS_TYPE_SINK 0x0028 +#define DNS_TYPE_OPT 0x0029 +#define DNS_TYPE_UINFO 0x0064 +#define DNS_TYPE_UID 0x0065 +#define DNS_TYPE_GID 0x0066 +#define DNS_TYPE_UNSPEC 0x0067 +#define DNS_TYPE_ADDRS 0x00f8 +#define DNS_TYPE_TKEY 0x00f9 +#define DNS_TYPE_TSIG 0x00fa +#define DNS_TYPE_IXFR 0x00fb +#define DNS_TYPE_AXFR 0x00fc +#define DNS_TYPE_MAILB 0x00fd +#define DNS_TYPE_MAILA 0x00fe +#define DNS_TYPE_ALL 0x00ff +#define DNS_TYPE_ANY 0x00ff + +#define DNS_TYPE_WINS 0xff01 +#define DNS_TYPE_WINSR 0xff02 +#define DNS_TYPE_NBSTAT (DNS_TYPE_WINSR) + +#define DNS_QUERY_STANDARD 0x00000000 +#define DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE 0x00000001 +#define DNS_QUERY_USE_TCP_ONLY 0x00000002 +#define DNS_QUERY_NO_RECURSION 0x00000004 +#define DNS_QUERY_BYPASS_CACHE 0x00000008 +#define DNS_QUERY_NO_WIRE_QUERY 0x00000010 +#define DNS_QUERY_NO_LOCAL_NAME 0x00000020 +#define DNS_QUERY_NO_HOSTS_FILE 0x00000040 +#define DNS_QUERY_NO_NETBT 0x00000080 +#define DNS_QUERY_WIRE_ONLY 0x00000100 +#define DNS_QUERY_RETURN_MESSAGE 0x00000200 +#define DNS_QUERY_MULTICAST_ONLY 0x00000400 +#define DNS_QUERY_NO_MULTICAST 0x00000800 +#define DNS_QUERY_TREAT_AS_FQDN 0x00001000 +#define DNS_QUERY_ADDRCONFIG 0x00002000 +#define DNS_QUERY_DUAL_ADDR 0x00004000 +#define DNS_QUERY_DONT_RESET_TTL_VALUES 0x00100000 +#define DNS_QUERY_DISABLE_IDN_ENCODING 0x00200000 +#define DNS_QUERY_APPEND_MULTILABEL 0x00800000 +#define DNS_QUERY_DNSSEC_OK 0x01000000 +#define DNS_QUERY_DNSSEC_CHECKING_DISABLED 0x02000000 +#define DNS_QUERY_RESERVED 0xff000000 + +#define INLINE_WORD_FLIP(out, in) { WORD _in = (in); (out) = (_in << 8) | (_in >> 8); } +#define INLINE_HTONS(out, in) INLINE_WORD_FLIP(out, in) +#define INLINE_NTOHS(out, in) INLINE_WORD_FLIP(out, in) + +#define DNS_BYTE_FLIP_HEADER_COUNTS(header) { \ + DNS_HEADER *_head = (header); \ + INLINE_HTONS( _head->Xid, _head->Xid ); \ + INLINE_HTONS( _head->QuestionCount, _head->QuestionCount ); \ + INLINE_HTONS( _head->AnswerCount, _head->AnswerCount ); \ + INLINE_HTONS( _head->NameServerCount, _head->NameServerCount ); \ + INLINE_HTONS( _head->AdditionalCount, _head->AdditionalCount ); } + +typedef enum _DNS_NAME_FORMAT +{ + DnsNameDomain, + DnsNameDomainLabel, + DnsNameHostnameFull, + DnsNameHostnameLabel, + DnsNameWildcard, + DnsNameSrvRecord +} DNS_NAME_FORMAT; + +typedef enum _DNS_FREE_TYPE +{ + DnsFreeFlat, + DnsFreeRecordList, + DnsFreeParsedMessageFields +} DNS_FREE_TYPE; + +typedef enum _DNS_CHARSET +{ + DnsCharSetUnknown, + DnsCharSetUnicode, + DnsCharSetUtf8, + DnsCharSetAnsi +} DNS_CHARSET; + +typedef enum _DNS_CONFIG_TYPE +{ + DnsConfigPrimaryDomainName_W, + DnsConfigPrimaryDomainName_A, + DnsConfigPrimaryDomainName_UTF8, + DnsConfigAdapterDomainName_W, + DnsConfigAdapterDomainName_A, + DnsConfigAdapterDomainName_UTF8, + DnsConfigDnsServerList, + DnsConfigSearchList, + DnsConfigAdapterInfo, + DnsConfigPrimaryHostNameRegistrationEnabled, + DnsConfigAdapterHostNameRegistrationEnabled, + DnsConfigAddressRegistrationMaxCount, + DnsConfigHostName_W, + DnsConfigHostName_A, + DnsConfigHostName_UTF8, + DnsConfigFullHostName_W, + DnsConfigFullHostName_A, + DnsConfigFullHostName_UTF8, + + /* These are undocumented and return a DNS_ADDR_ARRAY */ + DnsConfigDnsServersUnspec = 4144, + DnsConfigDnsServersIpv4, + DnsConfigDnsServersIpv6 +} DNS_CONFIG_TYPE; + +typedef enum _DnsSection +{ + DnsSectionQuestion, + DnsSectionAnswer, + DnsSectionAuthority, + DnsSectionAddtional /* Not a typo, as per Microsoft's headers */ +} DNS_SECTION; + +typedef LONG DNS_STATUS, *PDNS_STATUS; +typedef DWORD IP4_ADDRESS, *PIP4_ADDRESS; + +typedef struct +{ + DWORD IP6Dword[4]; +} IP6_ADDRESS, *PIP6_ADDRESS, DNS_IP6_ADDRESS, *PDNS_IP6_ADDRESS; + +#define SIZEOF_IP4_ADDRESS 4 +#define IP4_ADDRESS_STRING_LENGTH 16 +#define IP6_ADDRESS_STRING_LENGTH 65 +#define DNS_ADDRESS_STRING_LENGTH IP6_ADDRESS_STRING_LENGTH +#define IP4_ADDRESS_STRING_BUFFER_LENGTH IP4_ADDRESS_STRING_LENGTH +#define IP6_ADDRESS_STRING_BUFFER_LENGTH IP6_ADDRESS_STRING_LENGTH + +#define DNS_MAX_NAME_LENGTH 255 +#define DNS_MAX_LABEL_LENGTH 63 +#define DNS_MAX_NAME_BUFFER_LENGTH (DNS_MAX_NAME_LENGTH + 1) +#define DNS_MAX_LABEL_BUFFER_LENGTH (DNS_MAX_LABEL_LENGTH + 1) + +typedef struct _IP4_ARRAY +{ + DWORD AddrCount; + IP4_ADDRESS AddrArray[1]; +} IP4_ARRAY, *PIP4_ARRAY; + +#define DNS_OPCODE_QUERY 0 +#define DNS_OPCODE_IQUERY 1 +#define DNS_OPCODE_SERVER_STATUS 2 +#define DNS_OPCODE_UNKNOWN 3 +#define DNS_OPCODE_NOTIFY 4 +#define DNS_OPCODE_UPDATE 5 + +#define DNS_RCODE_NOERROR 0 +#define DNS_RCODE_FORMERR 1 +#define DNS_RCODE_SERVFAIL 2 +#define DNS_RCODE_NXDOMAIN 3 +#define DNS_RCODE_NOTIMPL 4 +#define DNS_RCODE_REFUSED 5 +#define DNS_RCODE_YXDOMAIN 6 +#define DNS_RCODE_YXRRSET 7 +#define DNS_RCODE_NXRRSET 8 +#define DNS_RCODE_NOTAUTH 9 +#define DNS_RCODE_NOTZONE 10 +#define DNS_RCODE_MAX 15 +#define DNS_RCODE_BADVERS 16 +#define DNS_RCODE_BADSIG 16 +#define DNS_RCODE_BADKEY 17 +#define DNS_RCODE_BADTIME 18 + +#define DNS_RCODE_NO_ERROR DNS_RCODE_NOERROR +#define DNS_RCODE_FORMAT_ERROR DNS_RCODE_FORMERR +#define DNS_RCODE_SERVER_FAILURE DNS_RCODE_SERVFAIL +#define DNS_RCODE_NAME_ERROR DNS_RCODE_NXDOMAIN +#define DNS_RCODE_NOT_IMPLEMENTED DNS_RCODE_NOTIMPL + +#include +typedef struct _DNS_HEADER +{ + WORD Xid; + BYTE RecursionDesired:1; + BYTE Truncation:1; + BYTE Authoritative:1; + BYTE Opcode:4; + BYTE IsResponse:1; + BYTE ResponseCode:4; + BYTE CheckingDisabled:1; + BYTE AuthenticatedData:1; + BYTE Reserved:1; + BYTE RecursionAvailable:1; + WORD QuestionCount; + WORD AnswerCount; + WORD NameServerCount; + WORD AdditionalCount; +} DNS_HEADER, *PDNS_HEADER; +#include + +typedef struct _DNS_MESSAGE_BUFFER +{ + DNS_HEADER MessageHead; + CHAR MessageBody[1]; +} DNS_MESSAGE_BUFFER, *PDNS_MESSAGE_BUFFER; + +typedef struct +{ + IP4_ADDRESS IpAddress; +} DNS_A_DATA, *PDNS_A_DATA; + +typedef struct _DnsRecordFlags +{ + DWORD Section :2; + DWORD Delete :1; + DWORD CharSet :2; + DWORD Unused :3; + DWORD Reserved :24; +} DNS_RECORD_FLAGS; + +typedef struct +{ + PSTR pNamePrimaryServer; + PSTR pNameAdministrator; + DWORD dwSerialNo; + DWORD dwRefresh; + DWORD dwRetry; + DWORD dwExpire; + DWORD dwDefaultTtl; +} DNS_SOA_DATAA, *PDNS_SOA_DATAA; + +typedef struct +{ + PWSTR pNamePrimaryServer; + PWSTR pNameAdministrator; + DWORD dwSerialNo; + DWORD dwRefresh; + DWORD dwRetry; + DWORD dwExpire; + DWORD dwDefaultTtl; +} DNS_SOA_DATAW, *PDNS_SOA_DATAW; + +DECL_WINELIB_TYPE_AW(DNS_SOA_DATA) +DECL_WINELIB_TYPE_AW(PDNS_SOA_DATA) + +typedef struct +{ + PSTR pNameHost; +} DNS_PTR_DATAA, *PDNS_PTR_DATAA; + +typedef struct +{ + PWSTR pNameHost; +} DNS_PTR_DATAW, *PDNS_PTR_DATAW; + +DECL_WINELIB_TYPE_AW(DNS_PTR_DATA) +DECL_WINELIB_TYPE_AW(PDNS_PTR_DATA) + +typedef struct +{ + PSTR pNameMailbox; + PSTR pNameErrorsMailbox; +} DNS_MINFO_DATAA, *PDNS_MINFO_DATAA; + +typedef struct +{ + PWSTR pNameMailbox; + PWSTR pNameErrorsMailbox; +} DNS_MINFO_DATAW, *PDNS_MINFO_DATAW; + +DECL_WINELIB_TYPE_AW(DNS_MINFO_DATA) +DECL_WINELIB_TYPE_AW(PDNS_MINFO_DATA) + +typedef struct +{ + PSTR pNameExchange; + WORD wPreference; + WORD Pad; +} DNS_MX_DATAA, *PDNS_MX_DATAA; + +typedef struct +{ + PWSTR pNameExchange; + WORD wPreference; + WORD Pad; +} DNS_MX_DATAW, *PDNS_MX_DATAW; + +DECL_WINELIB_TYPE_AW(DNS_MX_DATA) +DECL_WINELIB_TYPE_AW(PDNS_MX_DATA) + +typedef struct +{ + DWORD dwStringCount; + PSTR pStringArray[1]; +} DNS_TXT_DATAA, *PDNS_TXT_DATAA; + +typedef struct +{ + DWORD dwStringCount; + PWSTR pStringArray[1]; +} DNS_TXT_DATAW, *PDNS_TXT_DATAW; + +DECL_WINELIB_TYPE_AW(DNS_TXT_DATA) +DECL_WINELIB_TYPE_AW(PDNS_TXT_DATA) + +typedef struct +{ + DWORD dwByteCount; + BYTE Data[1]; +} DNS_NULL_DATA, *PDNS_NULL_DATA; + +typedef struct +{ + IP4_ADDRESS IpAddress; + UCHAR chProtocol; + BYTE BitMask[1]; +} DNS_WKS_DATA, *PDNS_WKS_DATA; + +typedef struct +{ + DNS_IP6_ADDRESS Ip6Address; +} DNS_AAAA_DATA, *PDNS_AAAA_DATA; + +typedef struct +{ + WORD wFlags; + BYTE chProtocol; + BYTE chAlgorithm; + WORD wKeyLength; + WORD wPad; + BYTE Key[1]; +} DNS_KEY_DATA, *PDNS_KEY_DATA; + +typedef struct +{ + WORD wVersion; + WORD wSize; + WORD wHorPrec; + WORD wVerPrec; + DWORD dwLatitude; + DWORD dwLongitude; + DWORD dwAltitude; +} DNS_LOC_DATA, *PDNS_LOC_DATA; + +typedef struct +{ + WORD wTypeCovered; + BYTE chAlgorithm; + BYTE chLabelCount; + DWORD dwOriginalTtl; + DWORD dwExpiration; + DWORD dwTimeSigned; + WORD wKeyTag; + WORD wSignatureLength; + PSTR pNameSigner; + BYTE Signature[1]; +} DNS_SIG_DATAA, *PDNS_SIG_DATAA; + +typedef struct +{ + WORD wTypeCovered; + BYTE chAlgorithm; + BYTE chLabelCount; + DWORD dwOriginalTtl; + DWORD dwExpiration; + DWORD dwTimeSigned; + WORD wKeyTag; + WORD wSignatureLength; + PWSTR pNameSigner; + BYTE Signature[1]; +} DNS_SIG_DATAW, *PDNS_SIG_DATAW; + +DECL_WINELIB_TYPE_AW(DNS_SIG_DATA) +DECL_WINELIB_TYPE_AW(PDNS_SIG_DATA) + +#define DNS_ATMA_MAX_ADDR_LENGTH 20 + +typedef struct +{ + BYTE AddressType; + BYTE Address[DNS_ATMA_MAX_ADDR_LENGTH]; +} DNS_ATMA_DATA, *PDNS_ATMA_DATA; + +typedef struct +{ + PSTR pNameNext; + WORD wNumTypes; + WORD wTypes[1]; +} DNS_NXT_DATAA, *PDNS_NXT_DATAA; + +typedef struct +{ + PWSTR pNameNext; + WORD wNumTypes; + WORD wTypes[1]; +} DNS_NXT_DATAW, *PDNS_NXT_DATAW; + +DECL_WINELIB_TYPE_AW(DNS_NXT_DATA) +DECL_WINELIB_TYPE_AW(PDNS_NXT_DATA) + +typedef struct +{ + PSTR pNameTarget; + WORD wPriority; + WORD wWeight; + WORD wPort; + WORD Pad; +} DNS_SRV_DATAA, *PDNS_SRV_DATAA; + +typedef struct +{ + PWSTR pNameTarget; + WORD wPriority; + WORD wWeight; + WORD wPort; + WORD Pad; +} DNS_SRV_DATAW, *PDNS_SRV_DATAW; + +DECL_WINELIB_TYPE_AW(DNS_SRV_DATA) +DECL_WINELIB_TYPE_AW(PDNS_SRV_DATA) + +typedef struct +{ + PSTR pNameAlgorithm; + PBYTE pAlgorithmPacket; + PBYTE pKey; + PBYTE pOtherData; + DWORD dwCreateTime; + DWORD dwExpireTime; + WORD wMode; + WORD wError; + WORD wKeyLength; + WORD wOtherLength; + UCHAR cAlgNameLength; + BOOL bPacketPointers; +} DNS_TKEY_DATAA, *PDNS_TKEY_DATAA; + +typedef struct +{ + PWSTR pNameAlgorithm; + PBYTE pAlgorithmPacket; + PBYTE pKey; + PBYTE pOtherData; + DWORD dwCreateTime; + DWORD dwExpireTime; + WORD wMode; + WORD wError; + WORD wKeyLength; + WORD wOtherLength; + UCHAR cAlgNameLength; + BOOL bPacketPointers; +} DNS_TKEY_DATAW, *PDNS_TKEY_DATAW; + +DECL_WINELIB_TYPE_AW(DNS_TKEY_DATA) +DECL_WINELIB_TYPE_AW(PDNS_TKEY_DATA) + +typedef struct +{ + PSTR pNameAlgorithm; + PBYTE pAlgorithmPacket; + PBYTE pSignature; + PBYTE pOtherData; + LONGLONG i64CreateTime; + WORD wFudgeTime; + WORD wOriginalXid; + WORD wError; + WORD wSigLength; + WORD wOtherLength; + UCHAR cAlgNameLength; + BOOL bPacketPointers; +} DNS_TSIG_DATAA, *PDNS_TSIG_DATAA; + +typedef struct +{ + PWSTR pNameAlgorithm; + PBYTE pAlgorithmPacket; + PBYTE pSignature; + PBYTE pOtherData; + LONGLONG i64CreateTime; + WORD wFudgeTime; + WORD wOriginalXid; + WORD wError; + WORD wSigLength; + WORD wOtherLength; + UCHAR cAlgNameLength; + BOOL bPacketPointers; +} DNS_TSIG_DATAW, *PDNS_TSIG_DATAW; + +typedef struct +{ + DWORD dwMappingFlag; + DWORD dwLookupTimeout; + DWORD dwCacheTimeout; + DWORD cWinsServerCount; + IP4_ADDRESS WinsServers[1]; +} DNS_WINS_DATA, *PDNS_WINS_DATA; + +typedef struct +{ + DWORD dwMappingFlag; + DWORD dwLookupTimeout; + DWORD dwCacheTimeout; + PSTR pNameResultDomain; +} DNS_WINSR_DATAA, *PDNS_WINSR_DATAA; + +typedef struct +{ + DWORD dwMappingFlag; + DWORD dwLookupTimeout; + DWORD dwCacheTimeout; + PWSTR pNameResultDomain; +} DNS_WINSR_DATAW, *PDNS_WINSR_DATAW; + +DECL_WINELIB_TYPE_AW(DNS_WINSR_DATA) +DECL_WINELIB_TYPE_AW(PDNS_WINSR_DATA) + +typedef struct +{ + WORD wDataLength; + WORD wPad; + BYTE Data[1]; +} +DNS_OPT_DATA, *PDNS_OPT_DATA; + +typedef struct _DnsRecordA +{ + struct _DnsRecordA *pNext; + PSTR pName; + WORD wType; + WORD wDataLength; + union + { + DWORD DW; + DNS_RECORD_FLAGS S; + } Flags; + DWORD dwTtl; + DWORD dwReserved; + union + { + DNS_A_DATA A; + DNS_SOA_DATAA SOA, Soa; + DNS_PTR_DATAA PTR, Ptr, NS, Ns, CNAME, Cname, MB, Mb, MD, Md, MF, Mf, MG, Mg, MR, Mr; + DNS_MINFO_DATAA MINFO, Minfo, RP, Rp; + DNS_MX_DATAA MX, Mx, AFSDB, Afsdb, RT, Rt; + DNS_TXT_DATAA HINFO, Hinfo, ISDN, Isdn, TXT, Txt, X25; + DNS_NULL_DATA Null; + DNS_WKS_DATA WKS, Wks; + DNS_AAAA_DATA AAAA; + DNS_KEY_DATA KEY, Key; + DNS_SIG_DATAA SIG, Sig; + DNS_ATMA_DATA ATMA, Atma; + DNS_NXT_DATAA NXT, Nxt; + DNS_SRV_DATAA SRV, Srv; + DNS_TKEY_DATAA TKEY, Tkey; + DNS_TSIG_DATAA TSIG, Tsig; + DNS_WINS_DATA WINS, Wins; + DNS_WINSR_DATAA WINSR, WinsR, NBSTAT, Nbstat; + DNS_OPT_DATA OPT, Opt; + } Data; +} DNS_RECORDA, *PDNS_RECORDA; + +typedef struct _DnsRecordW +{ + struct _DnsRecordW *pNext; + PWSTR pName; + WORD wType; + WORD wDataLength; + union + { + DWORD DW; + DNS_RECORD_FLAGS S; + } Flags; + DWORD dwTtl; + DWORD dwReserved; + union + { + DNS_A_DATA A; + DNS_SOA_DATAW SOA, Soa; + DNS_PTR_DATAW PTR, Ptr, NS, Ns, CNAME, Cname, MB, Mb, MD, Md, MF, Mf, MG, Mg, MR, Mr; + DNS_MINFO_DATAW MINFO, Minfo, RP, Rp; + DNS_MX_DATAW MX, Mx, AFSDB, Afsdb, RT, Rt; + DNS_TXT_DATAW HINFO, Hinfo, ISDN, Isdn, TXT, Txt, X25; + DNS_NULL_DATA Null; + DNS_WKS_DATA WKS, Wks; + DNS_AAAA_DATA AAAA; + DNS_KEY_DATA KEY, Key; + DNS_SIG_DATAW SIG, Sig; + DNS_ATMA_DATA ATMA, Atma; + DNS_NXT_DATAW NXT, Nxt; + DNS_SRV_DATAW SRV, Srv; + DNS_TKEY_DATAW TKEY, Tkey; + DNS_TSIG_DATAW TSIG, Tsig; + DNS_WINS_DATA WINS, Wins; + DNS_WINSR_DATAW WINSR, WinsR, NBSTAT, Nbstat; + DNS_OPT_DATA OPT, Opt; + } Data; +} DNS_RECORDW, *PDNS_RECORDW; + +#if defined(__WINESRC__) || defined(UNICODE) +typedef DNS_RECORDW DNS_RECORD; +typedef PDNS_RECORDW PDNS_RECORD; +#else +typedef DNS_RECORDA DNS_RECORD; +typedef PDNS_RECORDA PDNS_RECORD; +#endif + +typedef struct _DnsRRSet +{ + PDNS_RECORD pFirstRR; + PDNS_RECORD pLastRR; +} DNS_RRSET, *PDNS_RRSET; + +#define DNS_RRSET_INIT( rrset ) \ +{ \ + PDNS_RRSET _prrset = &(rrset); \ + _prrset->pFirstRR = NULL; \ + _prrset->pLastRR = (PDNS_RECORD) &_prrset->pFirstRR; \ +} + +#define DNS_RRSET_ADD( rrset, pnewRR ) \ +{ \ + PDNS_RRSET _prrset = &(rrset); \ + PDNS_RECORD _prrnew = (pnewRR); \ + _prrset->pLastRR->pNext = _prrnew; \ + _prrset->pLastRR = _prrnew; \ +} + +#define DNS_RRSET_TERMINATE( rrset ) \ +{ \ + PDNS_RRSET _prrset = &(rrset); \ + _prrset->pLastRR->pNext = NULL; \ +} + +#define DNS_ADDR_MAX_SOCKADDR_LENGTH 32 + +#include + +typedef struct _DnsAddr +{ + char MaxSa[DNS_ADDR_MAX_SOCKADDR_LENGTH]; + union { + DWORD DnsAddrUserDword[8]; + } Data; +} DNS_ADDR, *PDNS_ADDR; + +typedef struct _DnsAddrArray +{ + DWORD MaxCount; + DWORD AddrCount; + DWORD Tag; + WORD Family; + WORD WordReserved; + DWORD Flags; + DWORD MatchFlag; + DWORD Reserved1; + DWORD Reserved2; + DNS_ADDR AddrArray[1]; +} DNS_ADDR_ARRAY, *PDNS_ADDR_ARRAY; + +#include + +#define DNS_QUERY_RESULTS_VERSION1 0x1 + +typedef struct _DNS_QUERY_RESULT +{ + ULONG Version; + DNS_STATUS QueryStatus; + ULONG64 QueryOptions; + DNS_RECORD *pQueryRecords; + void *Reserved; +} DNS_QUERY_RESULT, *PDNS_QUERY_RESULT; + +typedef void WINAPI DNS_QUERY_COMPLETION_ROUTINE(void*,DNS_QUERY_RESULT*); +typedef DNS_QUERY_COMPLETION_ROUTINE *PDNS_QUERY_COMPLETION_ROUTINE; + +#define DNS_QUERY_REQUEST_VERSION1 0x1 + +typedef struct _DNS_QUERY_REQUEST +{ + ULONG Version; + const WCHAR *QueryName; + WORD QueryType; + ULONG64 QueryOptions; + PDNS_ADDR_ARRAY pDnsServerList; + ULONG InterfaceIndex; + PDNS_QUERY_COMPLETION_ROUTINE pQueryCompletionCallback; + void *pQueryContext; +} DNS_QUERY_REQUEST, *PDNS_QUERY_REQUEST; + +typedef struct _DNS_QUERY_CANCEL +{ + char Reserved[32]; +} DNS_QUERY_CANCEL, *PDNS_QUERY_CANCEL; + +typedef struct _DNS_CACHE_ENTRY +{ + struct _DNS_CACHE_ENTRY* Next; + const WCHAR *Name; + WORD Type; + WORD DataLength; + ULONG Flags; +} DNS_CACHE_ENTRY, *PDNS_CACHE_ENTRY; + +typedef void WINAPI DNS_SERVICE_BROWSE_CALLBACK(DWORD, void *, PDNS_RECORD); +typedef DNS_SERVICE_BROWSE_CALLBACK *PDNS_SERVICE_BROWSE_CALLBACK; + +typedef struct _DNS_SERVICE_BROWSE_REQUEST +{ + ULONG Version; + ULONG InterfaceIndex; + const WCHAR *QueryName; + union + { + PDNS_SERVICE_BROWSE_CALLBACK pBrowseCallback; + DNS_QUERY_COMPLETION_ROUTINE *pBrowseCallbackV2; + }; + void *pQueryContext; +} DNS_SERVICE_BROWSE_REQUEST, *PDNS_SERVICE_BROWSE_REQUEST; + +typedef struct _DNS_SERVICE_CANCEL +{ + void *reserved; +} DNS_SERVICE_CANCEL, *PDNS_SERVICE_CANCEL; + +DNS_STATUS WINAPI DnsAcquireContextHandle_A(DWORD,PVOID,PHANDLE); +DNS_STATUS WINAPI DnsAcquireContextHandle_W(DWORD,PVOID,PHANDLE); +#define DnsAcquireContextHandle WINELIB_NAME_AW(DnsAcquireContextHandle_) +DNS_STATUS WINAPI DnsExtractRecordsFromMessage_W(PDNS_MESSAGE_BUFFER,WORD,PDNS_RECORDW*); +DNS_STATUS WINAPI DnsExtractRecordsFromMessage_UTF8(PDNS_MESSAGE_BUFFER,WORD,PDNS_RECORDA*); +VOID WINAPI DnsFree(PVOID,DNS_FREE_TYPE); +DNS_STATUS WINAPI DnsModifyRecordsInSet_A(PDNS_RECORDA,PDNS_RECORDA,DWORD,HANDLE,PVOID,PVOID); +DNS_STATUS WINAPI DnsModifyRecordsInSet_W(PDNS_RECORDW,PDNS_RECORDW,DWORD,HANDLE,PVOID,PVOID); +DNS_STATUS WINAPI DnsModifyRecordsInSet_UTF8(PDNS_RECORDA,PDNS_RECORDA,DWORD,HANDLE,PVOID,PVOID); +#define DnsModifyRecordsInSet WINELIB_NAME_AW(DnsModifyRecordsInSet_) +BOOL WINAPI DnsNameCompare_A(PCSTR,PCSTR); +BOOL WINAPI DnsNameCompare_W(PCWSTR,PCWSTR); +#define DnsNameCompare WINELIB_NAME_AW(DnsNameCompare_) +DNS_STATUS WINAPI DnsQuery_A(PCSTR,WORD,DWORD,PVOID,PDNS_RECORDA*,PVOID*); +DNS_STATUS WINAPI DnsQuery_W(PCWSTR,WORD,DWORD,PVOID,PDNS_RECORDW*,PVOID*); +DNS_STATUS WINAPI DnsQuery_UTF8(PCSTR,WORD,DWORD,PVOID,PDNS_RECORDA*,PVOID*); +#define DnsQuery WINELIB_NAME_AW(DnsQuery_) +DNS_STATUS WINAPI DnsQueryEx(DNS_QUERY_REQUEST*,DNS_QUERY_RESULT*,DNS_QUERY_CANCEL*); +DNS_STATUS WINAPI DnsCancelQuery(DNS_QUERY_CANCEL*); +DNS_STATUS WINAPI DnsQueryConfig(DNS_CONFIG_TYPE,DWORD,PCWSTR,PVOID,PVOID,PDWORD); +BOOL WINAPI DnsRecordCompare(PDNS_RECORD,PDNS_RECORD); +PDNS_RECORD WINAPI DnsRecordCopyEx(PDNS_RECORD,DNS_CHARSET,DNS_CHARSET); +VOID WINAPI DnsRecordListFree(PDNS_RECORD,DNS_FREE_TYPE); +BOOL WINAPI DnsRecordSetCompare(PDNS_RECORD,PDNS_RECORD,PDNS_RECORD*,PDNS_RECORD*); +PDNS_RECORD WINAPI DnsRecordSetCopyEx(PDNS_RECORD,DNS_CHARSET,DNS_CHARSET); +PDNS_RECORD WINAPI DnsRecordSetDetach(PDNS_RECORD); +void WINAPI DnsReleaseContextHandle(HANDLE); +DNS_STATUS WINAPI DnsReplaceRecordSetA(PDNS_RECORDA,DWORD,HANDLE,PVOID,PVOID); +DNS_STATUS WINAPI DnsReplaceRecordSetW(PDNS_RECORDW,DWORD,HANDLE,PVOID,PVOID); +DNS_STATUS WINAPI DnsReplaceRecordSetUTF8(PDNS_RECORDA,DWORD,HANDLE,PVOID,PVOID); +#define DnsReplaceRecordSet WINELIB_NAME_AW(DnsReplaceRecordSet) +DNS_STATUS WINAPI DnsServiceBrowse(PDNS_SERVICE_BROWSE_REQUEST, PDNS_SERVICE_CANCEL); +DNS_STATUS WINAPI DnsValidateName_A(PCSTR,DNS_NAME_FORMAT); +DNS_STATUS WINAPI DnsValidateName_W(PCWSTR, DNS_NAME_FORMAT); +DNS_STATUS WINAPI DnsValidateName_UTF8(PCSTR,DNS_NAME_FORMAT); +#define DnsValidateName WINELIB_NAME_AW(DnsValidateName_) +BOOL WINAPI DnsWriteQuestionToBuffer_W(PDNS_MESSAGE_BUFFER,PDWORD,PCWSTR,WORD,WORD,BOOL); +BOOL WINAPI DnsWriteQuestionToBuffer_UTF8(PDNS_MESSAGE_BUFFER,PDWORD,PCSTR,WORD,WORD,BOOL); +BOOL WINAPI DnsGetCacheDataTable(PDNS_CACHE_ENTRY*); + +#ifdef __cplusplus +} +#endif + +#endif