ReactOS 0.4.16-dev-1946-g52006dd
Macros | Typedefs | Enumerations | Functions
iphlpapi.h File Reference
#include <iprtrmib.h>
#include <ipexport.h>
#include <iptypes.h>
#include <tcpestats.h>
Include dependency graph for iphlpapi.h:

Go to the source code of this file.

Macros

#define IPHLPAPI_DLL_LINKAGE   DECLSPEC_IMPORT
 
#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)
 

Typedefs

typedef enum NET_ADDRESS_FORMAT_ NET_ADDRESS_FORMAT
 

Enumerations

enum  NET_ADDRESS_FORMAT_ { NET_ADDRESS_FORMAT_UNSPECIFIED , NET_ADDRESS_DNS_NAME , NET_ADDRESS_IPV4 , NET_ADDRESS_IPV6 }
 

Functions

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)
 
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)
 
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)
 

Macro Definition Documentation

◆ IPHLPAPI_DLL_LINKAGE

#define IPHLPAPI_DLL_LINKAGE   DECLSPEC_IMPORT

Definition at line 35 of file iphlpapi.h.

◆ NET_STRING_ANY_ADDRESS

#define NET_STRING_ANY_ADDRESS   (NET_STRING_NAMED_ADDRESS|NET_STRING_IP_ADDRESS)

Definition at line 54 of file iphlpapi.h.

◆ NET_STRING_ANY_ADDRESS_NO_SCOPE

#define NET_STRING_ANY_ADDRESS_NO_SCOPE   (NET_STRING_NAMED_ADDRESS|NET_STRING_IP_ADDRESS_NO_SCOPE)

Definition at line 55 of file iphlpapi.h.

◆ NET_STRING_ANY_SERVICE

#define NET_STRING_ANY_SERVICE   (NET_STRING_NAMED_SERVICE|NET_STRING_IP_SERVICE)

Definition at line 56 of file iphlpapi.h.

◆ NET_STRING_ANY_SERVICE_NO_SCOPE

#define NET_STRING_ANY_SERVICE_NO_SCOPE   (NET_STRING_NAMED_SERVICE|NET_STRING_IP_SERVICE_NO_SCOPE)

Definition at line 57 of file iphlpapi.h.

◆ NET_STRING_IP_ADDRESS

#define NET_STRING_IP_ADDRESS   (NET_STRING_IPV4_ADDRESS|NET_STRING_IPV6_ADDRESS)

Definition at line 49 of file iphlpapi.h.

◆ NET_STRING_IP_ADDRESS_NO_SCOPE

#define NET_STRING_IP_ADDRESS_NO_SCOPE   (NET_STRING_IPV4_ADDRESS|NET_STRING_IPV6_ADDRESS_NO_SCOPE)

Definition at line 50 of file iphlpapi.h.

◆ NET_STRING_IP_NETWORK

#define NET_STRING_IP_NETWORK   (NET_STRING_IPV4_NETWORK|NET_STRING_IPV6_NETWORK)

Definition at line 53 of file iphlpapi.h.

◆ NET_STRING_IP_SERVICE

#define NET_STRING_IP_SERVICE   (NET_STRING_IPV4_SERVICE|NET_STRING_IPV6_SERVICE)

Definition at line 51 of file iphlpapi.h.

◆ NET_STRING_IP_SERVICE_NO_SCOPE

#define NET_STRING_IP_SERVICE_NO_SCOPE   (NET_STRING_IPV4_SERVICE|NET_STRING_IPV6_SERVICE_NO_SCOPE)

Definition at line 52 of file iphlpapi.h.

◆ NET_STRING_IPV4_ADDRESS

#define NET_STRING_IPV4_ADDRESS   0x00000001

Definition at line 39 of file iphlpapi.h.

◆ NET_STRING_IPV4_NETWORK

#define NET_STRING_IPV4_NETWORK   0x00000004

Definition at line 41 of file iphlpapi.h.

◆ NET_STRING_IPV4_SERVICE

#define NET_STRING_IPV4_SERVICE   0x00000002

Definition at line 40 of file iphlpapi.h.

◆ NET_STRING_IPV6_ADDRESS

#define NET_STRING_IPV6_ADDRESS   0x00000008

Definition at line 42 of file iphlpapi.h.

◆ NET_STRING_IPV6_ADDRESS_NO_SCOPE

#define NET_STRING_IPV6_ADDRESS_NO_SCOPE   0x00000010

Definition at line 43 of file iphlpapi.h.

◆ NET_STRING_IPV6_NETWORK

#define NET_STRING_IPV6_NETWORK   0x00000080

Definition at line 46 of file iphlpapi.h.

◆ NET_STRING_IPV6_SERVICE

#define NET_STRING_IPV6_SERVICE   0x00000020

Definition at line 44 of file iphlpapi.h.

◆ NET_STRING_IPV6_SERVICE_NO_SCOPE

#define NET_STRING_IPV6_SERVICE_NO_SCOPE   0x00000040

Definition at line 45 of file iphlpapi.h.

◆ NET_STRING_NAMED_ADDRESS

#define NET_STRING_NAMED_ADDRESS   0x00000100

Definition at line 47 of file iphlpapi.h.

◆ NET_STRING_NAMED_SERVICE

#define NET_STRING_NAMED_SERVICE   0x00000200

Definition at line 48 of file iphlpapi.h.

Typedef Documentation

◆ NET_ADDRESS_FORMAT

typedef enum NET_ADDRESS_FORMAT_ NET_ADDRESS_FORMAT

Enumeration Type Documentation

◆ NET_ADDRESS_FORMAT_

enum NET_ADDRESS_FORMAT_
Enumerator
NET_ADDRESS_FORMAT_UNSPECIFIED 
NET_ADDRESS_DNS_NAME 
NET_ADDRESS_IPV4 
NET_ADDRESS_IPV6 

Definition at line 139 of file iphlpapi.h.

139 {
140 NET_ADDRESS_FORMAT_UNSPECIFIED,
141 NET_ADDRESS_DNS_NAME,
142 NET_ADDRESS_IPV4,
143 NET_ADDRESS_IPV6,
144} NET_ADDRESS_FORMAT;
NET_ADDRESS_IPV4
@ NET_ADDRESS_IPV4
Definition: iphlpapi.h:142
NET_ADDRESS_DNS_NAME
@ NET_ADDRESS_DNS_NAME
Definition: iphlpapi.h:141
NET_ADDRESS_IPV6
@ NET_ADDRESS_IPV6
Definition: iphlpapi.h:143
NET_ADDRESS_FORMAT_UNSPECIFIED
@ NET_ADDRESS_FORMAT_UNSPECIFIED
Definition: iphlpapi.h:140
NET_ADDRESS_FORMAT
enum NET_ADDRESS_FORMAT_ NET_ADDRESS_FORMAT

Function Documentation

◆ AddIPAddress()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI AddIPAddress ( IPAddr  Address,
IPMask  IpMask,
DWORD  IfIndex,
PULONG  NTEContext,
PULONG  NTEInstance 
)

Definition at line 67 of file iphlpapi_main.c.

68{
69 return RtlNtStatusToDosError(addIPAddress(Address, Netmask, IfIndex, NteContext, NteInstance));
70}
addIPAddress
NTSTATUS addIPAddress(IPAddr Address, IPMask Mask, DWORD IfIndex, PULONG NteContext, PULONG NteInstance)
Definition: ifenum_reactos.c:643
RtlNtStatusToDosError
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
Address
static WCHAR Address[46]
Definition: ping.c:68

Referenced by INetCfgComponentControl_fnApplyRegistryChanges(), Server_StaticRefreshParams(), setup_adapter(), and state_panic().

◆ AllocateAndGetIpForwardTableFromStack()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI AllocateAndGetIpForwardTableFromStack ( PMIB_IPFORWARDTABLE *  ppIpForwardTable,
BOOL  bOrder,
HANDLE  heap,
DWORD  flags 
)

Definition at line 180 of file iphlpapi_main.c.

182{
183 DWORD ret;
184
185 TRACE("ppIpForwardTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
186 ppIpForwardTable, (DWORD)bOrder, heap, flags);
187 if (!ppIpForwardTable)
188 ret = ERROR_INVALID_PARAMETER;
189 else {
190 DWORD dwSize = 0;
191
192 *ppIpForwardTable = NULL;
193 ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
194 if (ret == ERROR_INSUFFICIENT_BUFFER) {
195 *ppIpForwardTable = (PMIB_IPFORWARDTABLE)HeapAlloc(heap, flags, dwSize);
196 ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
197 if (ret != NO_ERROR) {
198 HeapFree(heap, flags, *ppIpForwardTable);
199 *ppIpForwardTable = NULL;
200 }
201 }
202 }
203 TRACE("returning %ld\n", ret);
204 return ret;
205}
NO_ERROR
#define NO_ERROR
Definition: dderror.h:5
ERROR_INSUFFICIENT_BUFFER
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
NULL
#define NULL
Definition: types.h:112
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735
ret
return ret
Definition: mutex.c:146
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
flags
GLbitfield flags
Definition: glext.h:7161
GetIpForwardTable
DWORD WINAPI GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder)
Definition: iphlpapi_main.c:1785
PMIB_IPFORWARDTABLE
struct _MIB_IPFORWARDTABLE * PMIB_IPFORWARDTABLE
dwSize
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
heap
static HANDLE heap
Definition: heap.c:65
TRACE
#define TRACE(s)
Definition: solgame.cpp:4

Referenced by GetBestRoute().

◆ AllocateAndGetIpNetTableFromStack()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI AllocateAndGetIpNetTableFromStack ( PMIB_IPNETTABLE *  ppIpNetTable,
BOOL  bOrder,
HANDLE  heap,
DWORD  flags 
)

Definition at line 220 of file iphlpapi_main.c.

222{
223 DWORD ret;
224
225 TRACE("ppIpNetTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
226 ppIpNetTable, (DWORD)bOrder, heap, flags);
227 if (!ppIpNetTable)
228 ret = ERROR_INVALID_PARAMETER;
229 else {
230 DWORD dwSize = 0;
231
232 *ppIpNetTable = NULL;
233 ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
234 if (ret == ERROR_INSUFFICIENT_BUFFER) {
235 *ppIpNetTable = (PMIB_IPNETTABLE)HeapAlloc(heap, flags, dwSize);
236 ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
237 if (ret != NO_ERROR) {
238 HeapFree(heap, flags, *ppIpNetTable);
239 *ppIpNetTable = NULL;
240 }
241 }
242 }
243 TRACE("returning %ld\n", ret);
244 return ret;
245}
GetIpNetTable
DWORD WINAPI GetIpNetTable(PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder)
Definition: iphlpapi_main.c:1881
PMIB_IPNETTABLE
struct _MIB_IPNETTABLE * PMIB_IPNETTABLE

◆ AllocateAndGetTcpExTableFromStack()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI AllocateAndGetTcpExTableFromStack ( VOID **  ppTcpTable,
BOOL  bOrder,
HANDLE  heap,
DWORD  flags,
DWORD  family 
)

◆ AllocateAndGetTcpTableFromStack()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI AllocateAndGetTcpTableFromStack ( PMIB_TCPTABLE *  ppTcpTable,
BOOL  bOrder,
HANDLE  heap,
DWORD  flags 
)

Definition at line 260 of file iphlpapi_main.c.

262{
263 DWORD ret;
264
265 TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
266 ppTcpTable, (DWORD)bOrder, heap, flags);
267 if (!ppTcpTable)
268 ret = ERROR_INVALID_PARAMETER;
269 else {
270 DWORD dwSize = 0;
271
272 *ppTcpTable = NULL;
273 ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
274 if (ret == ERROR_INSUFFICIENT_BUFFER) {
275 *ppTcpTable = (PMIB_TCPTABLE)HeapAlloc(heap, flags, dwSize);
276 ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
277 if (ret != NO_ERROR) {
278 HeapFree(heap, flags, *ppTcpTable);
279 *ppTcpTable = NULL;
280 }
281 }
282 }
283 TRACE("returning %ld\n", ret);
284 return ret;
285}
GetTcpTable
DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
Definition: iphlpapi_main.c:2559
PMIB_TCPTABLE
struct _MIB_TCPTABLE * PMIB_TCPTABLE

◆ AllocateAndGetUdpTableFromStack()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI AllocateAndGetUdpTableFromStack ( PMIB_UDPTABLE *  ppUdpTable,
BOOL  bOrder,
HANDLE  heap,
DWORD  flags 
)

Definition at line 383 of file iphlpapi_main.c.

385{
386 DWORD ret;
387
388 TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
389 ppUdpTable, (DWORD)bOrder, heap, flags);
390 if (!ppUdpTable)
391 ret = ERROR_INVALID_PARAMETER;
392 else {
393 DWORD dwSize = 0;
394
395 *ppUdpTable = NULL;
396 ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
397 if (ret == ERROR_INSUFFICIENT_BUFFER) {
398 *ppUdpTable = (PMIB_UDPTABLE)HeapAlloc(heap, flags, dwSize);
399 ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
400 if (ret != NO_ERROR) {
401 HeapFree(heap, flags, *ppUdpTable);
402 *ppUdpTable = NULL;
403 }
404 }
405 }
406 TRACE("returning %ld\n", ret);
407 return ret;
408}
GetUdpTable
DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
Definition: iphlpapi_main.c:2622
PMIB_UDPTABLE
struct _MIB_UDPTABLE * PMIB_UDPTABLE

◆ CancelIPChangeNotify()

IPHLPAPI_DLL_LINKAGE BOOL WINAPI CancelIPChangeNotify ( LPOVERLAPPED  overlapped)

Definition at line 3209 of file iphlpapi_main.c.

3210{
3211 FIXME(":stub\n");
3212 return 0L;
3213}
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
L
#define L(x)
Definition: resources.c:13

Referenced by testNotifyAddrChange().

◆ CreateIpForwardEntry()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI CreateIpForwardEntry ( PMIB_IPFORWARDROW  pRoute)

Definition at line 503 of file iphlpapi_main.c.

504{
505 return createIpForwardEntry( pRoute );
506}
createIpForwardEntry
DWORD createIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:52

Referenced by AddRoute(), INetCfgComponentControl_fnApplyRegistryChanges(), and setup_adapter().

◆ CreateIpNetEntry()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI CreateIpNetEntry ( PMIB_IPNETROW  pArpEntry)

Definition at line 518 of file iphlpapi_main.c.

519{
520 TRACE("pArpEntry %p\n", pArpEntry);
521 /* could use SIOCSARP on systems that support it, not sure I want to */
522 FIXME(":stub\n");
523 return (DWORD) 0;
524}

◆ CreateProxyArpEntry()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI CreateProxyArpEntry ( DWORD  dwAddress,
DWORD  dwMask,
DWORD  dwIfIndex 
)

Definition at line 538 of file iphlpapi_main.c.

539{
540 TRACE("dwAddress 0x%08lx, dwMask 0x%08lx, dwIfIndex 0x%08lx\n", dwAddress,
541 dwMask, dwIfIndex);
542 FIXME(":stub\n");
543 /* marking Win2K+ functions not supported */
544 return ERROR_NOT_SUPPORTED;
545}
ERROR_NOT_SUPPORTED
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100

◆ DeleteIPAddress()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI DeleteIPAddress ( ULONG  NTEContext)

Definition at line 557 of file iphlpapi_main.c.

558{
559 TRACE("NTEContext %ld\n", NTEContext);
560 return RtlNtStatusToDosError(deleteIpAddress(NTEContext));
561}
deleteIpAddress
NTSTATUS deleteIpAddress(ULONG NteContext)
Definition: ifenum_reactos.c:685

Referenced by INetCfgComponentControl_fnApplyRegistryChanges(), reset_adapter(), send_request(), Server_StaticRefreshParams(), and setup_adapter().

◆ DeleteIpForwardEntry()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI DeleteIpForwardEntry ( PMIB_IPFORWARDROW  pRoute)

Definition at line 573 of file iphlpapi_main.c.

574{
575 return deleteIpForwardEntry( pRoute );
576}
deleteIpForwardEntry
DWORD deleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:64

Referenced by DeleteActiveRoutes(), DeleteCustomRoutes(), INetCfgComponentControl_fnApplyRegistryChanges(), reset_adapter(), Server_StaticRefreshParams(), and setup_adapter().

◆ DeleteIpNetEntry()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI DeleteIpNetEntry ( PMIB_IPNETROW  pArpEntry)

Definition at line 588 of file iphlpapi_main.c.

589{
590 TRACE("pArpEntry %p\n", pArpEntry);
591 /* could use SIOCDARP on systems that support it, not sure I want to */
592 FIXME(":stub\n");
593 return (DWORD) 0;
594}

Referenced by Deletehost().

◆ DeleteProxyArpEntry()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI DeleteProxyArpEntry ( DWORD  dwAddress,
DWORD  dwMask,
DWORD  dwIfIndex 
)

Definition at line 608 of file iphlpapi_main.c.

609{
610 TRACE("dwAddress 0x%08lx, dwMask 0x%08lx, dwIfIndex 0x%08lx\n", dwAddress,
611 dwMask, dwIfIndex);
612 FIXME(":stub\n");
613 /* marking Win2K+ functions not supported */
614 return ERROR_NOT_SUPPORTED;
615}

◆ EnableRouter()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI EnableRouter ( HANDLE *  pHandle,
OVERLAPPED *  pOverlapped 
)

Definition at line 627 of file iphlpapi_main.c.

628{
629 TRACE("pHandle %p, pOverlapped %p\n", pHandle, pOverlapped);
630 FIXME(":stub\n");
631 /* could echo "1" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
632 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
633 marking Win2K+ functions not supported */
634 return ERROR_NOT_SUPPORTED;
635}

◆ FlushIpNetTable()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI FlushIpNetTable ( DWORD  dwIfIndex)

Definition at line 647 of file iphlpapi_main.c.

648{
649 TRACE("dwIfIndex 0x%08lx\n", dwIfIndex);
650 FIXME(":stub\n");
651 /* this flushes the arp cache of the given index
652 marking Win2K+ functions not supported */
653 return ERROR_NOT_SUPPORTED;
654}

Referenced by Deletehost().

◆ GetAdapterIndex()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetAdapterIndex ( IN LPWSTR  AdapterName,
OUT PULONG  IfIndex 
)

◆ GetAdaptersInfo()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetAdaptersInfo ( PIP_ADAPTER_INFO  pAdapterInfo,
PULONG  pOutBufLen 
)

Definition at line 686 of file iphlpapi_main.c.

687{
688 DWORD ret;
689
690 TRACE("pAdapterInfo %p, pOutBufLen %p\n", pAdapterInfo, pOutBufLen);
691 if (!pOutBufLen)
692 ret = ERROR_INVALID_PARAMETER;
693 else {
694 DWORD numNonLoopbackInterfaces = getNumNonLoopbackInterfaces();
695
696 if (numNonLoopbackInterfaces > 0) {
697 /* this calculation assumes only one address in the IP_ADDR_STRING lists.
698 that's okay, because:
699 - we don't get multiple addresses per adapter anyway
700 - we don't know about per-adapter gateways
701 - DHCP and WINS servers can have max one entry per list */
702 ULONG size = sizeof(IP_ADAPTER_INFO) * numNonLoopbackInterfaces;
703
704 if (!pAdapterInfo || *pOutBufLen < size) {
705 *pOutBufLen = size;
706 ret = ERROR_BUFFER_OVERFLOW;
707 }
708 else {
709 InterfaceIndexTable *table = getNonLoopbackInterfaceIndexTable();
710
711 if (table) {
712 size = sizeof(IP_ADAPTER_INFO) * table->numIndexes;
713 if (*pOutBufLen < size) {
714 *pOutBufLen = size;
715 ret = ERROR_INSUFFICIENT_BUFFER;
716 }
717 else {
718 DWORD ndx;
719 HKEY hKey;
720 BOOL winsEnabled = FALSE;
721 IP_ADDRESS_STRING primaryWINS, secondaryWINS;
722
723 memset(pAdapterInfo, 0, size);
724 /* @@ Wine registry key: HKCU\Software\Wine\Network */
725 if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Network", &hKey) == ERROR_SUCCESS) {
726 DWORD size = sizeof(primaryWINS.String);
727 unsigned long addr;
728
729 RegQueryValueExA(hKey, "WinsServer", NULL, NULL,
730 (PBYTE)primaryWINS.String, &size);
731 addr = inet_addr(primaryWINS.String);
732 if (addr != INADDR_NONE && addr != INADDR_ANY)
733 winsEnabled = TRUE;
734 size = sizeof(secondaryWINS.String);
735 RegQueryValueExA(hKey, "BackupWinsServer", NULL, NULL,
736 (PBYTE)secondaryWINS.String, &size);
737 addr = inet_addr(secondaryWINS.String);
738 if (addr != INADDR_NONE && addr != INADDR_ANY)
739 winsEnabled = TRUE;
740 RegCloseKey(hKey);
741 }
742 TRACE("num of index is %lu\n", table->numIndexes);
743 for (ndx = 0; ndx < table->numIndexes; ndx++) {
744 PIP_ADAPTER_INFO ptr = &pAdapterInfo[ndx];
745 DWORD addrLen = sizeof(ptr->Address), type;
746 const char *ifname =
747 getInterfaceNameByIndex(table->indexes[ndx]);
748 if (!ifname) {
749 ret = ERROR_OUTOFMEMORY;
750 break;
751 }
752
753 /* on Win98 this is left empty, but whatever */
754 strncpy(ptr->AdapterName,ifname,sizeof(ptr->AdapterName));
755 consumeInterfaceName(ifname);
756 ptr->AdapterName[MAX_ADAPTER_NAME_LENGTH] = '\0';
757 getInterfacePhysicalByIndex(table->indexes[ndx], &addrLen,
758 ptr->Address, &type);
759 /* MS defines address length and type as UINT in some places and
760 DWORD in others, **sigh**. Don't want to assume that PUINT and
761 PDWORD are equiv (64-bit?) */
762 ptr->AddressLength = addrLen;
763 ptr->Type = type;
764 ptr->Index = table->indexes[ndx];
765 toIPAddressString(getInterfaceIPAddrByIndex(table->indexes[ndx]),
766 ptr->IpAddressList.IpAddress.String);
767 toIPAddressString(getInterfaceMaskByIndex(table->indexes[ndx]),
768 ptr->IpAddressList.IpMask.String);
769 ptr->IpAddressList.Context = ptr->Index;
770 toIPAddressString(getInterfaceGatewayByIndex(table->indexes[ndx]),
771 ptr->GatewayList.IpAddress.String);
772 getDhcpInfoForAdapter(table->indexes[ndx], ptr);
773 if (winsEnabled) {
774 ptr->HaveWins = TRUE;
775 memcpy(ptr->PrimaryWinsServer.IpAddress.String,
776 primaryWINS.String, sizeof(primaryWINS.String));
777 memcpy(ptr->SecondaryWinsServer.IpAddress.String,
778 secondaryWINS.String, sizeof(secondaryWINS.String));
779 }
780 if (ndx < table->numIndexes - 1)
781 ptr->Next = &pAdapterInfo[ndx + 1];
782 else
783 ptr->Next = NULL;
784 }
785 ret = NO_ERROR;
786 }
787 free(table);
788 }
789 else
790 ret = ERROR_OUTOFMEMORY;
791 }
792 }
793 else
794 ret = ERROR_NO_DATA;
795 }
796 TRACE("returning %ld\n", ret);
797 return ret;
798}
inet_addr
ULONG WSAAPI inet_addr(IN CONST CHAR FAR *cp)
Definition: addrconv.c:71
INADDR_NONE
#define INADDR_NONE
Definition: tcp.c:42
RegCloseKey
#define RegCloseKey(hKey)
Definition: registry.h:49
free
#define free
Definition: debug_ros.c:5
ERROR_OUTOFMEMORY
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
RegOpenKeyA
LONG WINAPI RegOpenKeyA(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3234
RegQueryValueExA
LONG WINAPI RegQueryValueExA(_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)
Definition: reg.c:4009
getDhcpInfoForAdapter
DWORD getDhcpInfoForAdapter(DWORD AdapterIndex, PIP_ADAPTER_INFO ptr)
Definition: dhcp_reactos.c:12
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
hKey
FxAutoRegKey hKey
Definition: fxdriverapikm.cpp:59
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
size
GLsizeiptr size
Definition: glext.h:5919
addr
GLenum const GLvoid * addr
Definition: glext.h:9621
getInterfacePhysicalByIndex
DWORD getInterfacePhysicalByIndex(DWORD index, PDWORD len, PBYTE addr, PDWORD type)
Definition: ifenum_reactos.c:545
getNumNonLoopbackInterfaces
DWORD getNumNonLoopbackInterfaces(void)
Definition: ifenum_reactos.c:269
getInterfaceMaskByIndex
DWORD getInterfaceMaskByIndex(DWORD index)
Definition: ifenum_reactos.c:517
getNonLoopbackInterfaceIndexTable
InterfaceIndexTable * getNonLoopbackInterfaceIndexTable(void)
Definition: ifenum_reactos.c:451
getInterfaceNameByIndex
const char * getInterfaceNameByIndex(DWORD index)
Definition: ifenum_reactos.c:352
toIPAddressString
char * toIPAddressString(unsigned int addr, char string[16])
Definition: ifenum_reactos.c:631
getInterfaceIPAddrByIndex
DWORD getInterfaceIPAddrByIndex(DWORD index)
Definition: ifenum_reactos.c:501
consumeInterfaceName
void consumeInterfaceName(const char *ifname)
Definition: ifenum_reactos.c:377
getInterfaceGatewayByIndex
DWORD getInterfaceGatewayByIndex(DWORD index)
Definition: iphlpapi_main.c:72
if
if(dx< 0)
Definition: linetemp.h:194
INADDR_ANY
#define INADDR_ANY
Definition: inet.h:80
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
ptr
static PVOID ptr
Definition: dispmode.c:27
PBYTE
BYTE * PBYTE
Definition: pedump.c:66
MAX_ADAPTER_NAME_LENGTH
#define MAX_ADAPTER_NAME_LENGTH
Definition: iptypes.h:16
IP_ADAPTER_INFO
struct _IP_ADAPTER_INFO IP_ADAPTER_INFO
strncpy
strncpy
Definition: string.h:335
memset
#define memset(x, y, z)
Definition: compat.h:39
IP_ADDRESS_STRING
Definition: iptypes.h:30
IP_ADDRESS_STRING::String
char String[4 *4]
Definition: iptypes.h:31
_IP_ADAPTER_INFO
Definition: iptypes.h:41
_InterfaceIndexTable
Definition: ifenum.h:61
ULONG
uint32_t ULONG
Definition: typedefs.h:59
ERROR_BUFFER_OVERFLOW
#define ERROR_BUFFER_OVERFLOW
Definition: winerror.h:307
ERROR_NO_DATA
#define ERROR_NO_DATA
Definition: winerror.h:406
HKEY_CURRENT_USER
#define HKEY_CURRENT_USER
Definition: winreg.h:11

Referenced by CNetConnectionManager::EnumerateINetConnections(), Initialize(), InitializePropertyDialog(), IsReconnectHackNeeded(), LANStatusUiDetailsDlg(), Release(), Renew(), RPC_UuidGetNodeAddress(), SetClassId(), ShowInfo(), testGetAdaptersInfo(), and TestUM().

◆ GetBestInterface()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetBestInterface ( IPAddr  dwDestAddr,
PDWORD  pdwBestIfIndex 
)

Definition at line 811 of file iphlpapi_main.c.

812{
813 DWORD ret;
814
815 TRACE("dwDestAddr 0x%08lx, pdwBestIfIndex %p\n", dwDestAddr, pdwBestIfIndex);
816 if (!pdwBestIfIndex)
817 ret = ERROR_INVALID_PARAMETER;
818 else {
819 MIB_IPFORWARDROW ipRow;
820
821 ret = GetBestRoute(dwDestAddr, 0, &ipRow);
822 if (ret == ERROR_SUCCESS)
823 *pdwBestIfIndex = ipRow.dwForwardIfIndex;
824 }
825 TRACE("returning %ld\n", ret);
826 return ret;
827}
GetBestRoute
DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
Definition: iphlpapi_main.c:841
_MIB_IPFORWARDROW
Definition: ipmib.h:70
_MIB_IPFORWARDROW::dwForwardIfIndex
IF_INDEX dwForwardIfIndex
Definition: ipmib.h:75

Referenced by testGetBestInterface().

◆ GetBestRoute()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetBestRoute ( DWORD  dwDestAddr,
DWORD  dwSourceAddr,
PMIB_IPFORWARDROW  pBestRoute 
)

Definition at line 841 of file iphlpapi_main.c.

842{
843 PMIB_IPFORWARDTABLE table;
844 DWORD ret;
845
846 TRACE("dwDestAddr 0x%08lx, dwSourceAddr 0x%08lx, pBestRoute %p\n", dwDestAddr,
847 dwSourceAddr, pBestRoute);
848 if (!pBestRoute)
849 return ERROR_INVALID_PARAMETER;
850
851 AllocateAndGetIpForwardTableFromStack(&table, FALSE, GetProcessHeap(), 0);
852 if (table) {
853 DWORD ndx, minMaskSize, matchedNdx = 0;
854
855 for (ndx = 0, minMaskSize = 255; ndx < table->dwNumEntries; ndx++) {
856 if ((dwDestAddr & table->table[ndx].dwForwardMask) ==
857 (table->table[ndx].dwForwardDest & table->table[ndx].dwForwardMask)) {
858 DWORD hostMaskSize;
859
860 if (!_BitScanForward(&hostMaskSize, ntohl(table->table[ndx].dwForwardMask)))
861 {
862 hostMaskSize = 32;
863 }
864 if (hostMaskSize < minMaskSize) {
865 minMaskSize = hostMaskSize;
866 matchedNdx = ndx;
867 }
868 }
869 }
870 memcpy(pBestRoute, &table->table[matchedNdx], sizeof(MIB_IPFORWARDROW));
871 HeapFree(GetProcessHeap(), 0, table);
872 ret = ERROR_SUCCESS;
873 }
874 else
875 ret = ERROR_OUTOFMEMORY;
876 TRACE("returning %ld\n", ret);
877 return ret;
878}
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
_BitScanForward
unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask)
Definition: intrin_arm.h:57
AllocateAndGetIpForwardTableFromStack
DWORD WINAPI AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE *ppIpForwardTable, BOOL bOrder, HANDLE heap, DWORD flags)
Definition: iphlpapi_main.c:180
ntohl
#define ntohl(x)
Definition: module.h:205
_MIB_IPFORWARDTABLE
Definition: ipmib.h:96

Referenced by GetBestInterface(), and testGetBestRoute().

◆ GetExtendedTcpTable()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetExtendedTcpTable ( PVOID  pTcpTable,
PDWORD  pdwSize,
BOOL  bOrder,
ULONG  ulAf,
TCP_TABLE_CLASS  TableClass,
ULONG  Reserved 
)

Definition at line 919 of file iphlpapi_main.c.

920{
921 DWORD i, count, size;
922 DWORD ret = NO_ERROR;
923
924 if (!pdwSize)
925 {
926 return ERROR_INVALID_PARAMETER;
927 }
928
929 if (ulAf != AF_INET)
930 {
931 UNIMPLEMENTED;
932 return ERROR_INVALID_PARAMETER;
933 }
934
935 switch (TableClass)
936 {
937 case TCP_TABLE_BASIC_ALL:
938 {
939 PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
940 PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
941
942 if (pOurTcpTable)
943 {
944 size = FIELD_OFFSET(MIB_TCPTABLE, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW);
945 if (size > *pdwSize || !pTheirTcpTable)
946 {
947 *pdwSize = size;
948 ret = ERROR_INSUFFICIENT_BUFFER;
949 }
950 else
951 {
952 memcpy(pTheirTcpTable, pOurTcpTable, size);
953
954 if (bOrder)
955 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
956 sizeof(MIB_TCPROW), TcpTableSorter);
957 }
958
959 HeapFree(GetProcessHeap(),0, pOurTcpTable);
960 }
961 }
962 break;
963
964 case TCP_TABLE_BASIC_CONNECTIONS:
965 {
966 PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
967 PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
968
969 if (pOurTcpTable)
970 {
971 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
972 {
973 if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
974 {
975 ++count;
976 }
977 }
978
979 size = FIELD_OFFSET(MIB_TCPTABLE, table) + count * sizeof(MIB_TCPROW);
980 if (size > *pdwSize || !pTheirTcpTable)
981 {
982 *pdwSize = size;
983 ret = ERROR_INSUFFICIENT_BUFFER;
984 }
985 else
986 {
987 pTheirTcpTable->dwNumEntries = count;
988
989 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
990 {
991 if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
992 {
993 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
994 ++count;
995 }
996 }
997 ASSERT(count == pTheirTcpTable->dwNumEntries);
998
999 if (bOrder)
1000 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1001 sizeof(MIB_TCPROW), TcpTableSorter);
1002 }
1003
1004 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1005 }
1006 }
1007 break;
1008
1009 case TCP_TABLE_BASIC_LISTENER:
1010 {
1011 PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
1012 PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
1013
1014 if (pOurTcpTable)
1015 {
1016 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1017 {
1018 if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
1019 {
1020 ++count;
1021 }
1022 }
1023
1024 size = FIELD_OFFSET(MIB_TCPTABLE, table) + count * sizeof(MIB_TCPROW);
1025 if (size > *pdwSize || !pTheirTcpTable)
1026 {
1027 *pdwSize = size;
1028 ret = ERROR_INSUFFICIENT_BUFFER;
1029 }
1030 else
1031 {
1032 pTheirTcpTable->dwNumEntries = count;
1033
1034 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1035 {
1036 if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
1037 {
1038 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
1039 ++count;
1040 }
1041 }
1042 ASSERT(count == pTheirTcpTable->dwNumEntries);
1043
1044 if (bOrder)
1045 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1046 sizeof(MIB_TCPROW), TcpTableSorter);
1047 }
1048
1049 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1050 }
1051 }
1052 break;
1053
1054 case TCP_TABLE_OWNER_PID_ALL:
1055 {
1056 PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
1057 PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1058
1059 if (pOurTcpTable)
1060 {
1061 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_PID);
1062 if (size > *pdwSize || !pTheirTcpTable)
1063 {
1064 *pdwSize = size;
1065 ret = ERROR_INSUFFICIENT_BUFFER;
1066 }
1067 else
1068 {
1069 memcpy(pTheirTcpTable, pOurTcpTable, size);
1070
1071 /* Don't sort on PID, so use basic helper */
1072 if (bOrder)
1073 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1074 sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
1075 }
1076
1077 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1078 }
1079 }
1080 break;
1081
1082 case TCP_TABLE_OWNER_PID_CONNECTIONS:
1083 {
1084 PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
1085 PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1086
1087 if (pOurTcpTable)
1088 {
1089 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1090 {
1091 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1092 {
1093 ++count;
1094 }
1095 }
1096
1097 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + count * sizeof(MIB_TCPROW_OWNER_PID);
1098 if (size > *pdwSize || !pTheirTcpTable)
1099 {
1100 *pdwSize = size;
1101 ret = ERROR_INSUFFICIENT_BUFFER;
1102 }
1103 else
1104 {
1105 pTheirTcpTable->dwNumEntries = count;
1106
1107 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1108 {
1109 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1110 {
1111 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_PID));
1112 ++count;
1113 }
1114 }
1115 ASSERT(count == pTheirTcpTable->dwNumEntries);
1116
1117 /* Don't sort on PID, so use basic helper */
1118 if (bOrder)
1119 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1120 sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
1121 }
1122
1123 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1124 }
1125 }
1126 break;
1127
1128 case TCP_TABLE_OWNER_PID_LISTENER:
1129 {
1130 PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
1131 PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1132
1133 if (pOurTcpTable)
1134 {
1135 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1136 {
1137 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1138 {
1139 ++count;
1140 }
1141 }
1142
1143 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + count * sizeof(MIB_TCPROW_OWNER_PID);
1144 if (size > *pdwSize || !pTheirTcpTable)
1145 {
1146 *pdwSize = size;
1147 ret = ERROR_INSUFFICIENT_BUFFER;
1148 }
1149 else
1150 {
1151 pTheirTcpTable->dwNumEntries = count;
1152
1153 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1154 {
1155 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1156 {
1157 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_PID));
1158 ++count;
1159 }
1160 }
1161 ASSERT(count == pTheirTcpTable->dwNumEntries);
1162
1163 /* Don't sort on PID, so use basic helper */
1164 if (bOrder)
1165 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1166 sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
1167 }
1168
1169 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1170 }
1171 }
1172 break;
1173
1174 case TCP_TABLE_OWNER_MODULE_ALL:
1175 {
1176 PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
1177 PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1178
1179 if (pOurTcpTable)
1180 {
1181 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_MODULE);
1182 if (size > *pdwSize || !pTheirTcpTable)
1183 {
1184 *pdwSize = size;
1185 ret = ERROR_INSUFFICIENT_BUFFER;
1186 }
1187 else
1188 {
1189 memcpy(pTheirTcpTable, pOurTcpTable, size);
1190
1191 /* Don't sort on PID, so use basic helper */
1192 if (bOrder)
1193 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1194 sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
1195 }
1196
1197 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1198 }
1199 }
1200 break;
1201
1202 case TCP_TABLE_OWNER_MODULE_CONNECTIONS:
1203 {
1204 PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
1205 PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1206
1207 if (pOurTcpTable)
1208 {
1209 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1210 {
1211 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1212 {
1213 ++count;
1214 }
1215 }
1216
1217 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + count * sizeof(MIB_TCPROW_OWNER_MODULE);
1218 if (size > *pdwSize || !pTheirTcpTable)
1219 {
1220 *pdwSize = size;
1221 ret = ERROR_INSUFFICIENT_BUFFER;
1222 }
1223 else
1224 {
1225 pTheirTcpTable->dwNumEntries = count;
1226
1227 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1228 {
1229 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1230 {
1231 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
1232 ++count;
1233 }
1234 }
1235 ASSERT(count == pTheirTcpTable->dwNumEntries);
1236
1237 /* Don't sort on PID, so use basic helper */
1238 if (bOrder)
1239 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1240 sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
1241 }
1242
1243 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1244 }
1245 }
1246 break;
1247
1248 case TCP_TABLE_OWNER_MODULE_LISTENER:
1249 {
1250 PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
1251 PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1252
1253 if (pOurTcpTable)
1254 {
1255 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1256 {
1257 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1258 {
1259 ++count;
1260 }
1261 }
1262
1263 size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + count * sizeof(MIB_TCPROW_OWNER_MODULE);
1264 if (size > *pdwSize || !pTheirTcpTable)
1265 {
1266 *pdwSize = size;
1267 ret = ERROR_INSUFFICIENT_BUFFER;
1268 }
1269 else
1270 {
1271 pTheirTcpTable->dwNumEntries = count;
1272
1273 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1274 {
1275 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1276 {
1277 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
1278 ++count;
1279 }
1280 }
1281 ASSERT(count == pTheirTcpTable->dwNumEntries);
1282
1283 /* Don't sort on PID, so use basic helper */
1284 if (bOrder)
1285 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1286 sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
1287 }
1288
1289 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1290 }
1291 }
1292 break;
1293
1294 default:
1295 ret = ERROR_INVALID_PARAMETER;
1296 break;
1297 }
1298
1299 return ret;
1300}
UNIMPLEMENTED
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15
qsort
void __cdecl qsort(_Inout_updates_bytes_(_NumOfElements *_SizeOfElements) void *_Base, _In_ size_t _NumOfElements, _In_ size_t _SizeOfElements, _In_ int(__cdecl *_PtFuncCompare)(const void *, const void *))
AF_INET
#define AF_INET
Definition: tcpip.h:117
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
TcpTableSorter
static int TcpTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:880
TCP_TABLE_OWNER_MODULE_CONNECTIONS
@ TCP_TABLE_OWNER_MODULE_CONNECTIONS
Definition: iprtrmib.h:37
TCP_TABLE_BASIC_CONNECTIONS
@ TCP_TABLE_BASIC_CONNECTIONS
Definition: iprtrmib.h:31
TCP_TABLE_BASIC_LISTENER
@ TCP_TABLE_BASIC_LISTENER
Definition: iprtrmib.h:30
TCP_TABLE_OWNER_MODULE_ALL
@ TCP_TABLE_OWNER_MODULE_ALL
Definition: iprtrmib.h:38
TCP_TABLE_OWNER_PID_LISTENER
@ TCP_TABLE_OWNER_PID_LISTENER
Definition: iprtrmib.h:33
TCP_TABLE_BASIC_ALL
@ TCP_TABLE_BASIC_ALL
Definition: iprtrmib.h:32
TCP_TABLE_OWNER_PID_ALL
@ TCP_TABLE_OWNER_PID_ALL
Definition: iprtrmib.h:35
TCP_TABLE_OWNER_PID_CONNECTIONS
@ TCP_TABLE_OWNER_PID_CONNECTIONS
Definition: iprtrmib.h:34
TCP_TABLE_OWNER_MODULE_LISTENER
@ TCP_TABLE_OWNER_MODULE_LISTENER
Definition: iprtrmib.h:36
getTcpTable
PVOID getTcpTable(CLASS_TABLE Class)
Definition: ipstats_reactos.c:879
ClassModulePid
@ ClassModulePid
Definition: ipstats.h:81
ClassBasic
@ ClassBasic
Definition: ipstats.h:80
ClassModule
@ ClassModule
Definition: ipstats.h:82
ASSERT
#define ASSERT(a)
Definition: mode.c:44
MIB_TCPROW
struct _MIB_TCPROW MIB_TCPROW
MIB_TCPROW_OWNER_PID
struct _MIB_TCPROW_OWNER_PID MIB_TCPROW_OWNER_PID
MIB_TCP_STATE_LISTEN
@ MIB_TCP_STATE_LISTEN
Definition: tcpmib.h:16
MIB_TCPROW_OWNER_MODULE
struct _MIB_TCPROW_OWNER_MODULE MIB_TCPROW_OWNER_MODULE
_MIB_TCPROW_OWNER_MODULE
Definition: tcpmib.h:93
_MIB_TCPROW_OWNER_MODULE::dwState
DWORD dwState
Definition: tcpmib.h:94
_MIB_TCPROW_OWNER_PID
Definition: tcpmib.h:76
_MIB_TCPROW_OWNER_PID::dwState
DWORD dwState
Definition: tcpmib.h:77
_MIB_TCPROW
Definition: tcpmib.h:39
_MIB_TCPROW::State
MIB_TCP_STATE State
Definition: tcpmib.h:42
_MIB_TCPTABLE_OWNER_MODULE
Definition: tcpmib.h:104
_MIB_TCPTABLE_OWNER_MODULE::dwNumEntries
DWORD dwNumEntries
Definition: tcpmib.h:105
_MIB_TCPTABLE_OWNER_MODULE::table
MIB_TCPROW_OWNER_MODULE table[1]
Definition: tcpmib.h:106
_MIB_TCPTABLE_OWNER_PID
Definition: tcpmib.h:85
_MIB_TCPTABLE_OWNER_PID::table
MIB_TCPROW_OWNER_PID table[1]
Definition: tcpmib.h:87
_MIB_TCPTABLE_OWNER_PID::dwNumEntries
DWORD dwNumEntries
Definition: tcpmib.h:86
_MIB_TCPTABLE
Definition: tcpmib.h:50
_MIB_TCPTABLE::dwNumEntries
DWORD dwNumEntries
Definition: tcpmib.h:51
_MIB_TCPTABLE::table
MIB_TCPROW table[1]
Definition: tcpmib.h:52
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255

Referenced by AllocateAndGetTcpExTable2FromStack(), AllocateAndGetTcpExTableFromStack(), GetExtendedTcpTableWithAlloc(), GetTcpTable(), and ShowTcpTable().

◆ GetExtendedUdpTable()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetExtendedUdpTable ( PVOID  pUdpTable,
PDWORD  pdwSize,
BOOL  bOrder,
ULONG  ulAf,
UDP_TABLE_CLASS  TableClass,
ULONG  Reserved 
)

Definition at line 1335 of file iphlpapi_main.c.

1336{
1337 DWORD size;
1338 DWORD ret = NO_ERROR;
1339
1340 if (!pdwSize)
1341 {
1342 return ERROR_INVALID_PARAMETER;
1343 }
1344
1345 if (ulAf != AF_INET)
1346 {
1347 UNIMPLEMENTED;
1348 return ERROR_INVALID_PARAMETER;
1349 }
1350
1351 switch (TableClass)
1352 {
1353 case UDP_TABLE_BASIC:
1354 {
1355 PMIB_UDPTABLE pOurUdpTable = getUdpTable(ClassBasic);
1356 PMIB_UDPTABLE pTheirUdpTable = pUdpTable;
1357
1358 if (pOurUdpTable)
1359 {
1360 size = FIELD_OFFSET(MIB_UDPTABLE, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW);
1361 if (size > *pdwSize || !pTheirUdpTable)
1362 {
1363 *pdwSize = size;
1364 ret = ERROR_INSUFFICIENT_BUFFER;
1365 }
1366 else
1367 {
1368 memcpy(pTheirUdpTable, pOurUdpTable, size);
1369
1370 if (bOrder)
1371 qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1372 sizeof(MIB_UDPROW), UdpTableSorter);
1373 }
1374
1375 HeapFree(GetProcessHeap(), 0, pOurUdpTable);
1376 }
1377 }
1378 break;
1379
1380 case UDP_TABLE_OWNER_PID:
1381 {
1382 PMIB_UDPTABLE_OWNER_PID pOurUdpTable = getUdpTable(ClassModulePid);
1383 PMIB_UDPTABLE_OWNER_PID pTheirUdpTable = pUdpTable;
1384
1385 if (pOurUdpTable)
1386 {
1387 size = FIELD_OFFSET(MIB_UDPTABLE_OWNER_PID, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID);
1388 if (size > *pdwSize || !pTheirUdpTable)
1389 {
1390 *pdwSize = size;
1391 ret = ERROR_INSUFFICIENT_BUFFER;
1392 }
1393 else
1394 {
1395 memcpy(pTheirUdpTable, pOurUdpTable, size);
1396
1397 if (bOrder)
1398 qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1399 sizeof(MIB_UDPROW_OWNER_PID), UdpTableSorter);
1400 }
1401
1402 HeapFree(GetProcessHeap(), 0, pOurUdpTable);
1403 }
1404 }
1405 break;
1406
1407 case UDP_TABLE_OWNER_MODULE:
1408 {
1409 PMIB_UDPTABLE_OWNER_MODULE pOurUdpTable = getUdpTable(ClassModule);
1410 PMIB_UDPTABLE_OWNER_MODULE pTheirUdpTable = pUdpTable;
1411
1412 if (pOurUdpTable)
1413 {
1414 size = FIELD_OFFSET(MIB_UDPTABLE_OWNER_MODULE, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_MODULE);
1415 if (size > *pdwSize || !pTheirUdpTable)
1416 {
1417 *pdwSize = size;
1418 ret = ERROR_INSUFFICIENT_BUFFER;
1419 }
1420 else
1421 {
1422 memcpy(pTheirUdpTable, pOurUdpTable, size);
1423
1424 if (bOrder)
1425 qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1426 sizeof(MIB_UDPROW_OWNER_MODULE), UdpTableSorter);
1427 }
1428
1429 HeapFree(GetProcessHeap(), 0, pOurUdpTable);
1430 }
1431 }
1432 break;
1433
1434 default:
1435 ret = ERROR_INVALID_PARAMETER;
1436 break;
1437 }
1438
1439 return ret;
1440}
UdpTableSorter
static int UdpTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:1302
UDP_TABLE_BASIC
@ UDP_TABLE_BASIC
Definition: iprtrmib.h:43
UDP_TABLE_OWNER_MODULE
@ UDP_TABLE_OWNER_MODULE
Definition: iprtrmib.h:45
UDP_TABLE_OWNER_PID
@ UDP_TABLE_OWNER_PID
Definition: iprtrmib.h:44
getUdpTable
PVOID getUdpTable(CLASS_TABLE Class)
Definition: ipstats_reactos.c:771
MIB_UDPROW_OWNER_MODULE
struct _MIB_UDPROW_OWNER_MODULE MIB_UDPROW_OWNER_MODULE
MIB_UDPROW_OWNER_PID
struct _MIB_UDPROW_OWNER_PID MIB_UDPROW_OWNER_PID
MIB_UDPROW
struct _MIB_UDPROW MIB_UDPROW
_MIB_UDPROW_OWNER_MODULE
Definition: udpmib.h:41
_MIB_UDPROW_OWNER_PID
Definition: udpmib.h:26
_MIB_UDPROW
Definition: udpmib.h:13
_MIB_UDPTABLE_OWNER_MODULE
Definition: udpmib.h:55
_MIB_UDPTABLE_OWNER_MODULE::dwNumEntries
DWORD dwNumEntries
Definition: udpmib.h:56
_MIB_UDPTABLE_OWNER_MODULE::table
MIB_UDPROW_OWNER_MODULE table[1]
Definition: udpmib.h:57
_MIB_UDPTABLE_OWNER_PID
Definition: udpmib.h:33
_MIB_UDPTABLE_OWNER_PID::table
MIB_UDPROW_OWNER_PID table[1]
Definition: udpmib.h:35
_MIB_UDPTABLE_OWNER_PID::dwNumEntries
DWORD dwNumEntries
Definition: udpmib.h:34
_MIB_UDPTABLE
Definition: udpmib.h:18
_MIB_UDPTABLE::dwNumEntries
DWORD dwNumEntries
Definition: udpmib.h:19
_MIB_UDPTABLE::table
MIB_UDPROW table[1]
Definition: udpmib.h:20

Referenced by AllocateAndGetUdpExTable2FromStack(), AllocateAndGetUdpExTableFromStack(), GetExtendedUdpTableWithAlloc(), GetUdpTable(), and ShowUdpTable().

◆ GetFriendlyIfIndex()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetFriendlyIfIndex ( DWORD  IfIndex)

Definition at line 1452 of file iphlpapi_main.c.

1453{
1454 /* windows doesn't validate these, either, just makes sure the top byte is
1455 cleared. I assume my ifenum module never gives an index with the top
1456 byte set. */
1457 TRACE("returning %ld\n", IfIndex);
1458 return IfIndex;
1459}

◆ GetIcmpStatistics()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIcmpStatistics ( PMIB_ICMP  pStats)

Definition at line 1471 of file iphlpapi_main.c.

1472{
1473 DWORD ret;
1474
1475 TRACE("pStats %p\n", pStats);
1476 ret = getICMPStats(pStats);
1477 TRACE("returning %ld\n", ret);
1478 return ret;
1479}
getICMPStats
DWORD getICMPStats(MIB_ICMP *stats)
Definition: ipstats_reactos.c:294

Referenced by mib2IcmpInit(), ShowIcmpStatistics(), and testGetIcmpStatistics().

◆ GetIcmpStatisticsEx()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIcmpStatisticsEx ( PMIB_ICMP_EX  pStats,
DWORD  dwFamily 
)

Definition at line 3238 of file iphlpapi_main.c.

3239{
3240 FIXME(":stub\n");
3241
3242 if (!pStats)
3243 return ERROR_INVALID_PARAMETER;
3244
3245 if (dwFamily != AF_INET && dwFamily != AF_INET6)
3246 return ERROR_INVALID_PARAMETER;
3247
3248 return 0L;
3249}
AF_INET6
#define AF_INET6
Definition: winsock.h:363

Referenced by testGetIcmpStatisticsEx().

◆ GetIfEntry()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIfEntry ( PMIB_IFROW  pIfRow)

Definition at line 1491 of file iphlpapi_main.c.

1492{
1493 DWORD ret;
1494 const char *name;
1495
1496 TRACE("pIfRow %p\n", pIfRow);
1497 if (!pIfRow)
1498 return ERROR_INVALID_PARAMETER;
1499
1500 name = getInterfaceNameByIndex(pIfRow->dwIndex);
1501 if (name) {
1502 ret = getInterfaceEntryByIndex(pIfRow->dwIndex, pIfRow);
1503 if (ret == NO_ERROR)
1504 ret = getInterfaceStatsByName(name, pIfRow);
1505 consumeInterfaceName(name);
1506 }
1507 else
1508 ret = ERROR_INVALID_DATA;
1509 TRACE("returning %ld\n", ret);
1510 return ret;
1511}
getInterfaceEntryByIndex
DWORD getInterfaceEntryByIndex(DWORD index, PMIB_IFROW entry)
Definition: ifenum_reactos.c:608
getInterfaceStatsByName
DWORD getInterfaceStatsByName(const char *name, PMIB_IFROW entry)
Definition: ipstats_reactos.c:279
_MIB_IFROW::dwIndex
DWORD dwIndex
Definition: ifmib.h:38
name
Definition: name.c:39
ERROR_INVALID_DATA
#define ERROR_INVALID_DATA
Definition: winerror.h:238

Referenced by CNetConnectionManager::EnumerateINetConnections(), GetIfTable(), CNetConnection::GetProperties(), NetBTAstat(), Release(), Renew(), SetClassId(), ShowInfo(), testGetAdaptersInfo(), testGetIfEntry(), testGetInterfaceInfo(), UpdateLanStatus(), and WkstaEnumAdaptersCallback().

◆ GetIfTable()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIfTable ( PMIB_IFTABLE  pIfTable,
PULONG  pdwSize,
BOOL  bOrder 
)

Definition at line 1537 of file iphlpapi_main.c.

1538{
1539 DWORD ret;
1540
1541 TRACE("pIfTable %p, pdwSize %p, bOrder %ld\n", pdwSize, pdwSize,
1542 (DWORD)bOrder);
1543 if (!pdwSize)
1544 ret = ERROR_INVALID_PARAMETER;
1545 else {
1546 DWORD numInterfaces = getNumInterfaces();
1547 ULONG size;
1548 TRACE("GetIfTable: numInterfaces = %d\n", (int)numInterfaces);
1549 size = sizeof(MIB_IFTABLE) + (numInterfaces - 1) * sizeof(MIB_IFROW);
1550
1551 if (!pIfTable || *pdwSize < size) {
1552 *pdwSize = size;
1553 ret = ERROR_INSUFFICIENT_BUFFER;
1554 }
1555 else {
1556 InterfaceIndexTable *table = getInterfaceIndexTable();
1557
1558 if (table) {
1559 size = sizeof(MIB_IFTABLE) + (table->numIndexes - 1) *
1560 sizeof(MIB_IFROW);
1561 if (*pdwSize < size) {
1562 *pdwSize = size;
1563 ret = ERROR_INSUFFICIENT_BUFFER;
1564 }
1565 else {
1566 DWORD ndx;
1567
1568 pIfTable->dwNumEntries = 0;
1569 for (ndx = 0; ndx < table->numIndexes; ndx++) {
1570 pIfTable->table[ndx].dwIndex = table->indexes[ndx];
1571 GetIfEntry(&pIfTable->table[ndx]);
1572 pIfTable->dwNumEntries++;
1573 }
1574 if (bOrder)
1575 qsort(pIfTable->table, pIfTable->dwNumEntries, sizeof(MIB_IFROW),
1576 IfTableSorter);
1577 ret = NO_ERROR;
1578 }
1579 free(table);
1580 }
1581 else
1582 ret = ERROR_OUTOFMEMORY;
1583 }
1584 }
1585 TRACE("returning %ld\n", ret);
1586 return ret;
1587}
getNumInterfaces
DWORD getNumInterfaces(void)
Definition: ifenum_reactos.c:264
getInterfaceIndexTable
InterfaceIndexTable * getInterfaceIndexTable(void)
Definition: ifenum_reactos.c:447
MIB_IFTABLE
struct _MIB_IFTABLE MIB_IFTABLE
MIB_IFROW
struct _MIB_IFROW MIB_IFROW
GetIfEntry
DWORD WINAPI GetIfEntry(PMIB_IFROW pIfRow)
Definition: iphlpapi_main.c:1491
IfTableSorter
static int IfTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:1514
_MIB_IFROW
Definition: ifmib.h:36
_MIB_IFTABLE::table
MIB_IFROW table[1]
Definition: ifmib.h:66
_MIB_IFTABLE::dwNumEntries
DWORD dwNumEntries
Definition: ifmib.h:65

Referenced by AdapterDiscoveryThread(), AllocateAndGetIfTableFromStack(), CNetConnectionManager::EnumerateINetConnections(), mib2IfNumberInit(), ShowEthernetStatistics(), and testGetIfTable().

◆ GetInterfaceInfo()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetInterfaceInfo ( PIP_INTERFACE_INFO  pIfTable,
PULONG  dwOutBufLen 
)

Definition at line 1600 of file iphlpapi_main.c.

1601{
1602 DWORD ret;
1603
1604 TRACE("pIfTable %p, dwOutBufLen %p\n", pIfTable, dwOutBufLen);
1605 if (!dwOutBufLen)
1606 ret = ERROR_INVALID_PARAMETER;
1607 else {
1608 DWORD numNonLoopbackInterfaces = getNumNonLoopbackInterfaces();
1609 ULONG size;
1610 TRACE("numNonLoopbackInterfaces == 0x%x\n", numNonLoopbackInterfaces);
1611 size = sizeof(IP_INTERFACE_INFO) + (numNonLoopbackInterfaces) *
1612 sizeof(IP_ADAPTER_INDEX_MAP);
1613
1614 if (!pIfTable || *dwOutBufLen < size) {
1615 *dwOutBufLen = size;
1616 ret = ERROR_INSUFFICIENT_BUFFER;
1617 }
1618 else {
1619 InterfaceIndexTable *table = getNonLoopbackInterfaceIndexTable();
1620
1621 if (table) {
1622 TRACE("table->numIndexes == 0x%x\n", table->numIndexes);
1623 size = sizeof(IP_INTERFACE_INFO) + (table->numIndexes) *
1624 sizeof(IP_ADAPTER_INDEX_MAP);
1625 if (*dwOutBufLen < size) {
1626 *dwOutBufLen = size;
1627 ret = ERROR_INSUFFICIENT_BUFFER;
1628 }
1629 else {
1630 DWORD ndx;
1631
1632 pIfTable->NumAdapters = 0;
1633 for (ndx = 0; ndx < table->numIndexes; ndx++) {
1634 const char *walker, *name;
1635 WCHAR *assigner;
1636
1637 pIfTable->Adapter[ndx].Index = table->indexes[ndx];
1638 name = getInterfaceNameByIndex(table->indexes[ndx]);
1639 wcscpy(pIfTable->Adapter[ndx].Name, L"\\DEVICE\\TCPIP_");
1640 for (walker = name, assigner = &pIfTable->Adapter[ndx].Name[14];
1641 walker && *walker &&
1642 assigner - pIfTable->Adapter[ndx].Name < MAX_ADAPTER_NAME - 1 - 14;
1643 walker++, assigner++)
1644 *assigner = *walker;
1645 *assigner = 0;
1646 consumeInterfaceName(name);
1647 pIfTable->NumAdapters++;
1648 }
1649 ret = NO_ERROR;
1650 }
1651 free(table);
1652 }
1653 else
1654 ret = ERROR_OUTOFMEMORY;
1655 }
1656 }
1657 TRACE("returning %ld\n", ret);
1658 return ret;
1659}
wcscpy
wcscpy
Definition: corecrt_wstring.h:120
MAX_ADAPTER_NAME
#define MAX_ADAPTER_NAME
Definition: ipexport.h:143
IP_ADAPTER_INDEX_MAP
struct _IP_ADAPTER_INDEX_MAP IP_ADAPTER_INDEX_MAP
IP_INTERFACE_INFO
struct _IP_INTERFACE_INFO IP_INTERFACE_INFO
_IP_ADAPTER_INDEX_MAP::Index
ULONG Index
Definition: ipexport.h:146
_IP_ADAPTER_INDEX_MAP::Name
WCHAR Name[MAX_ADAPTER_NAME]
Definition: ipexport.h:147
_IP_INTERFACE_INFO::NumAdapters
LONG NumAdapters
Definition: ipexport.h:151
_IP_INTERFACE_INFO::Adapter
IP_ADAPTER_INDEX_MAP Adapter[1]
Definition: ipexport.h:152
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by OpenAdapterHandle(), test_GetInterfaceName(), and testGetInterfaceInfo().

◆ GetIpAddrTable()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpAddrTable ( PMIB_IPADDRTABLE  pIpAddrTable,
PULONG  pdwSize,
BOOL  bOrder 
)

Definition at line 1685 of file iphlpapi_main.c.

1686{
1687 DWORD ret;
1688
1689 TRACE("pIpAddrTable %p, pdwSize %p, bOrder %ld\n", pIpAddrTable, pdwSize,
1690 (DWORD)bOrder);
1691 if (!pdwSize)
1692 ret = ERROR_INVALID_PARAMETER;
1693 else {
1694 DWORD numInterfaces = getNumInterfaces();
1695 ULONG size = sizeof(MIB_IPADDRTABLE) + (numInterfaces - 1) *
1696 sizeof(MIB_IPADDRROW);
1697
1698 if (!pIpAddrTable || *pdwSize < size) {
1699 *pdwSize = size;
1700 ret = ERROR_INSUFFICIENT_BUFFER;
1701 }
1702 else {
1703 InterfaceIndexTable *table = getInterfaceIndexTable();
1704
1705 if (table) {
1706 size = sizeof(MIB_IPADDRTABLE) + (table->numIndexes - 1) *
1707 sizeof(MIB_IPADDRROW);
1708 if (*pdwSize < size) {
1709 *pdwSize = size;
1710 ret = ERROR_INSUFFICIENT_BUFFER;
1711 }
1712 else {
1713 DWORD ndx, bcast;
1714
1715 pIpAddrTable->dwNumEntries = 0;
1716 for (ndx = 0; ndx < table->numIndexes; ndx++) {
1717 pIpAddrTable->table[ndx].dwIndex = table->indexes[ndx];
1718 pIpAddrTable->table[ndx].dwAddr =
1719 getInterfaceIPAddrByIndex(table->indexes[ndx]);
1720 pIpAddrTable->table[ndx].dwMask =
1721 getInterfaceMaskByIndex(table->indexes[ndx]);
1722 /* the dwBCastAddr member isn't the broadcast address, it indicates
1723 * whether the interface uses the 1's broadcast address (1) or the
1724 * 0's broadcast address (0).
1725 */
1726 bcast = getInterfaceBCastAddrByIndex(table->indexes[ndx]);
1727 pIpAddrTable->table[ndx].dwBCastAddr =
1728 (bcast & pIpAddrTable->table[ndx].dwMask) ? 1 : 0;
1729 /* FIXME: hardcoded reasm size, not sure where to get it */
1730 pIpAddrTable->table[ndx].dwReasmSize = 65535;
1731 pIpAddrTable->table[ndx].unused1 = 0;
1732 pIpAddrTable->table[ndx].wType = 0; /* aka unused2 */
1733 pIpAddrTable->dwNumEntries++;
1734 }
1735 if (bOrder)
1736 qsort(pIpAddrTable->table, pIpAddrTable->dwNumEntries,
1737 sizeof(MIB_IPADDRROW), IpAddrTableSorter);
1738 ret = NO_ERROR;
1739 }
1740 free(table);
1741 }
1742 else
1743 ret = ERROR_OUTOFMEMORY;
1744 }
1745 }
1746 TRACE("returning %ld\n", ret);
1747 return ret;
1748}
getInterfaceBCastAddrByIndex
DWORD getInterfaceBCastAddrByIndex(DWORD index)
Definition: ifenum_reactos.c:509
IpAddrTableSorter
static int IpAddrTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:1662
MIB_IPADDRROW
struct _MIB_IPADDRROW MIB_IPADDRROW
MIB_IPADDRTABLE
struct _MIB_IPADDRTABLE MIB_IPADDRTABLE
_MIB_IPADDRROW
Definition: ipmib.h:35
_MIB_IPADDRROW::unused1
unsigned short unused1
Definition: ipmib.h:41
_MIB_IPADDRROW::dwReasmSize
DWORD dwReasmSize
Definition: ipmib.h:40
_MIB_IPADDRROW::dwBCastAddr
DWORD dwBCastAddr
Definition: ipmib.h:39
_MIB_IPADDRROW::dwMask
DWORD dwMask
Definition: ipmib.h:38
_MIB_IPADDRROW::dwAddr
DWORD dwAddr
Definition: ipmib.h:36
_MIB_IPADDRROW::dwIndex
IF_INDEX dwIndex
Definition: ipmib.h:37
_MIB_IPADDRROW::wType
unsigned short wType
Definition: ipmib.h:42
_MIB_IPADDRTABLE::table
MIB_IPADDRROW table[1]
Definition: ipmib.h:48
_MIB_IPADDRTABLE::dwNumEntries
DWORD dwNumEntries
Definition: ipmib.h:47

Referenced by AllocateAndGetIpAddrTableFromStack(), DisplayArpEntries(), mib2IpAddrInit(), NetBTEnum(), Test_WSAIoctl_InitTest(), and testGetIpAddrTable().

◆ GetIpForwardTable()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpForwardTable ( PMIB_IPFORWARDTABLE  pIpForwardTable,
PULONG  pdwSize,
BOOL  bOrder 
)

Definition at line 1785 of file iphlpapi_main.c.

1786{
1787 DWORD ret;
1788
1789 TRACE("pIpForwardTable %p, pdwSize %p, bOrder %ld\n", pIpForwardTable,
1790 pdwSize, (DWORD)bOrder);
1791 if (!pdwSize)
1792 ret = ERROR_INVALID_PARAMETER;
1793 else {
1794 DWORD numRoutes = getNumRoutes();
1795 ULONG sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (numRoutes - 1) *
1796 sizeof(MIB_IPFORWARDROW);
1797
1798 if (!pIpForwardTable || *pdwSize < sizeNeeded) {
1799 *pdwSize = sizeNeeded;
1800 ret = ERROR_INSUFFICIENT_BUFFER;
1801 }
1802 else {
1803 RouteTable *table = getRouteTable();
1804 if (table) {
1805 sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (table->numRoutes - 1) *
1806 sizeof(MIB_IPFORWARDROW);
1807 if (*pdwSize < sizeNeeded) {
1808 *pdwSize = sizeNeeded;
1809 ret = ERROR_INSUFFICIENT_BUFFER;
1810 }
1811 else {
1812 DWORD ndx;
1813
1814 pIpForwardTable->dwNumEntries = table->numRoutes;
1815 for (ndx = 0; ndx < numRoutes; ndx++) {
1816 pIpForwardTable->table[ndx].dwForwardIfIndex =
1817 table->routes[ndx].ifIndex;
1818 pIpForwardTable->table[ndx].dwForwardDest =
1819 table->routes[ndx].dest;
1820 pIpForwardTable->table[ndx].dwForwardMask =
1821 table->routes[ndx].mask;
1822 pIpForwardTable->table[ndx].dwForwardPolicy = 0;
1823 pIpForwardTable->table[ndx].dwForwardNextHop =
1824 table->routes[ndx].gateway;
1825 /* FIXME: this type is appropriate for local interfaces; may not
1826 always be appropriate */
1827 pIpForwardTable->table[ndx].dwForwardType = MIB_IPROUTE_TYPE_DIRECT;
1828 /* FIXME: other protos might be appropriate, e.g. the default route
1829 is typically set with MIB_IPPROTO_NETMGMT instead */
1830 pIpForwardTable->table[ndx].dwForwardProto = MIB_IPPROTO_LOCAL;
1831 /* punt on age and AS */
1832 pIpForwardTable->table[ndx].dwForwardAge = 0;
1833 pIpForwardTable->table[ndx].dwForwardNextHopAS = 0;
1834 pIpForwardTable->table[ndx].dwForwardMetric1 =
1835 table->routes[ndx].metric;
1836 /* rest of the metrics are 0.. */
1837 pIpForwardTable->table[ndx].dwForwardMetric2 = 0;
1838 pIpForwardTable->table[ndx].dwForwardMetric3 = 0;
1839 pIpForwardTable->table[ndx].dwForwardMetric4 = 0;
1840 pIpForwardTable->table[ndx].dwForwardMetric5 = 0;
1841 }
1842 if (bOrder)
1843 qsort(pIpForwardTable->table, pIpForwardTable->dwNumEntries,
1844 sizeof(MIB_IPFORWARDROW), IpForwardTableSorter);
1845 ret = NO_ERROR;
1846 }
1847 HeapFree(GetProcessHeap(), 0, table);
1848 }
1849 else
1850 ret = ERROR_OUTOFMEMORY;
1851 }
1852 }
1853 TRACE("returning %ld\n", ret);
1854 return ret;
1855}
IpForwardTableSorter
static int IpForwardTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:1751
MIB_IPROUTE_TYPE_DIRECT
@ MIB_IPROUTE_TYPE_DIRECT
Definition: ipmib.h:63
MIB_IPFORWARDTABLE
struct _MIB_IPFORWARDTABLE MIB_IPFORWARDTABLE
MIB_IPFORWARDROW
struct _MIB_IPFORWARDROW MIB_IPFORWARDROW
getRouteTable
RouteTable * getRouteTable(void)
Definition: ipstats_reactos.c:534
getNumRoutes
DWORD getNumRoutes(void)
Definition: ipstats_reactos.c:475
_MIB_IPFORWARDROW::dwForwardMetric5
DWORD dwForwardMetric5
Definition: ipmib.h:92
_MIB_IPFORWARDROW::dwForwardNextHop
DWORD dwForwardNextHop
Definition: ipmib.h:74
_MIB_IPFORWARDROW::dwForwardMetric2
DWORD dwForwardMetric2
Definition: ipmib.h:89
_MIB_IPFORWARDROW::dwForwardPolicy
DWORD dwForwardPolicy
Definition: ipmib.h:73
_MIB_IPFORWARDROW::dwForwardMetric3
DWORD dwForwardMetric3
Definition: ipmib.h:90
_MIB_IPFORWARDROW::dwForwardProto
DWORD dwForwardProto
Definition: ipmib.h:83
_MIB_IPFORWARDROW::dwForwardMetric1
DWORD dwForwardMetric1
Definition: ipmib.h:88
_MIB_IPFORWARDROW::dwForwardNextHopAS
DWORD dwForwardNextHopAS
Definition: ipmib.h:87
_MIB_IPFORWARDROW::dwForwardDest
DWORD dwForwardDest
Definition: ipmib.h:71
_MIB_IPFORWARDROW::dwForwardMask
DWORD dwForwardMask
Definition: ipmib.h:72
_MIB_IPFORWARDROW::dwForwardMetric4
DWORD dwForwardMetric4
Definition: ipmib.h:91
_MIB_IPFORWARDROW::dwForwardAge
DWORD dwForwardAge
Definition: ipmib.h:86
_MIB_IPFORWARDROW::dwForwardType
DWORD dwForwardType
Definition: ipmib.h:78
_MIB_IPFORWARDTABLE::dwNumEntries
DWORD dwNumEntries
Definition: ipmib.h:97
_MIB_IPFORWARDTABLE::table
MIB_IPFORWARDROW table[1]
Definition: ipmib.h:98
_RouteTable
Definition: ipstats.h:74

Referenced by AllocateAndGetIpForwardTableFromStack(), DeleteActiveRoutes(), DeleteCustomRoutes(), fill_ip4routetable(), INetCfgComponentControl_fnApplyRegistryChanges(), mib2IpRouteInit(), PrintActiveRoutes(), and testGetIpForwardTable().

◆ GetIpNetTable()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpNetTable ( PMIB_IPNETTABLE  pIpNetTable,
PULONG  pdwSize,
BOOL  bOrder 
)

Definition at line 1881 of file iphlpapi_main.c.

1882{
1883 DWORD ret = NO_ERROR;
1884
1885 TRACE("pIpNetTable %p, pdwSize %p, bOrder %d\n", pIpNetTable, pdwSize,
1886 (DWORD)bOrder);
1887 if (!pdwSize)
1888 ret = ERROR_INVALID_PARAMETER;
1889 else {
1890 DWORD numEntries = getNumArpEntries();
1891 ULONG size = sizeof(MIB_IPNETTABLE);
1892
1893 if (numEntries > 1)
1894 size += (numEntries - 1) * sizeof(MIB_IPNETROW);
1895 if (!pIpNetTable || *pdwSize < size) {
1896 *pdwSize = size;
1897 ret = ERROR_INSUFFICIENT_BUFFER;
1898 }
1899 else {
1900 PMIB_IPNETTABLE table = getArpTable();
1901 if (table) {
1902 size = sizeof(MIB_IPNETTABLE);
1903 if (table->dwNumEntries > 1)
1904 size += (table->dwNumEntries - 1) * sizeof(MIB_IPNETROW);
1905 if (*pdwSize < size) {
1906 *pdwSize = size;
1907 ret = ERROR_INSUFFICIENT_BUFFER;
1908 }
1909 else {
1910 *pdwSize = size;
1911 memcpy(pIpNetTable, table, size);
1912 if (bOrder)
1913 qsort(pIpNetTable->table, pIpNetTable->dwNumEntries,
1914 sizeof(MIB_IPNETROW), IpNetTableSorter);
1915 ret = NO_ERROR;
1916 }
1917 HeapFree(GetProcessHeap(), 0, table);
1918 }
1919 }
1920 }
1921 TRACE("returning %d\n", ret);
1922 return ret;
1923}
IpNetTableSorter
static int IpNetTableSorter(const void *a, const void *b)
Definition: iphlpapi_main.c:1858
MIB_IPNETTABLE
struct _MIB_IPNETTABLE MIB_IPNETTABLE
getNumArpEntries
DWORD getNumArpEntries(void)
Definition: ipstats_reactos.c:602
getArpTable
PMIB_IPNETTABLE getArpTable(void)
Definition: ipstats_reactos.c:650
_MIB_IPNETROW
Definition: ipmib.h:113
_MIB_IPNETTABLE
Definition: ipmib.h:126
_MIB_IPNETTABLE::dwNumEntries
DWORD dwNumEntries
Definition: ipmib.h:127
_MIB_IPNETTABLE::table
MIB_IPNETROW table[1]
Definition: ipmib.h:128

Referenced by Addhost(), AllocateAndGetIpNetTableFromStack(), Deletehost(), DisplayArpEntries(), mib2IpNetInit(), and testGetIpNetTable().

◆ GetIpStatistics()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpStatistics ( PMIB_IPSTATS  pStats)

Definition at line 1935 of file iphlpapi_main.c.

1936{
1937 return GetIpStatisticsEx(pStats, PF_INET);
1938}
GetIpStatisticsEx
DWORD WINAPI GetIpStatisticsEx(PMIB_IPSTATS pStats, DWORD dwFamily)
Definition: iphlpapi_main.c:1950
PF_INET
#define PF_INET
Definition: winsock.h:367

Referenced by mib2IpStatsInit(), ShowIpStatistics(), and testGetIpStatistics().

◆ GetIpStatisticsEx()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetIpStatisticsEx ( PMIB_IPSTATS  pStats,
DWORD  dwFamily 
)

Definition at line 1950 of file iphlpapi_main.c.

1951{
1952 HANDLE tcpFile;
1953 DWORD ret;
1954
1955 if (!pStats)
1956 return ERROR_INVALID_PARAMETER;
1957
1958 if (dwFamily != AF_INET && dwFamily != AF_INET6)
1959 return ERROR_INVALID_PARAMETER;
1960
1961 if (!NT_SUCCESS(openTcpFile(&tcpFile, FILE_READ_DATA)))
1962 return ERROR_NOT_SUPPORTED;
1963
1964 TRACE("pStats %p\n", pStats);
1965 ret = getIPStats(tcpFile, pStats);
1966 closeTcpFile(tcpFile);
1967 TRACE("returning %ld\n", ret);
1968 return ret;
1969}
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
getIPStats
DWORD getIPStats(HANDLE tcpFile, PMIB_IPSTATS stats)
FILE_READ_DATA
#define FILE_READ_DATA
Definition: nt_native.h:628
openTcpFile
NTSTATUS openTcpFile(PHANDLE tcpFile, ACCESS_MASK DesiredAccess)
Definition: handle.c:12
closeTcpFile
VOID closeTcpFile(HANDLE h)
Definition: handle.c:43

Referenced by GetIpStatistics(), and testGetIpStatisticsEx().

◆ GetNetworkParams()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetNetworkParams ( PFIXED_INFO  pFixedInfo,
PULONG  pOutBufLen 
)

Definition at line 1981 of file iphlpapi_main.c.

1982{
1983 DWORD ret, size, type;
1984 LONG regReturn;
1985 HKEY hKey;
1986 PIPHLP_RES_INFO resInfo;
1987
1988 TRACE("pFixedInfo %p, pOutBufLen %p\n", pFixedInfo, pOutBufLen);
1989 if (!pOutBufLen)
1990 return ERROR_INVALID_PARAMETER;
1991
1992 resInfo = getResInfo();
1993 if (!resInfo)
1994 return ERROR_OUTOFMEMORY;
1995
1996 size = sizeof(FIXED_INFO) + (resInfo->riCount > 1 ? (resInfo->riCount-1) *
1997 sizeof(IP_ADDR_STRING) : 0);
1998 if (!pFixedInfo || *pOutBufLen < size) {
1999 *pOutBufLen = size;
2000 disposeResInfo( resInfo );
2001 return ERROR_BUFFER_OVERFLOW;
2002 }
2003
2004 memset(pFixedInfo, 0, size);
2005 /* Check for DhcpHostname and DhcpDomain first */
2006 regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2007 "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters",
2008 0,
2009 KEY_READ,
2010 &hKey);
2011 if (regReturn == ERROR_SUCCESS) {
2012 /* Windows doesn't honor DHCP option 12 even if RFC requires it if it is returned by DHCP server! */
2013#if 0
2014 type = REG_SZ;
2015 size = sizeof(pFixedInfo->HostName);
2016 regReturn = RegQueryValueExA(hKey,
2017 "DhcpHostname",
2018 NULL,
2019 &type,
2020 (LPBYTE)pFixedInfo->HostName,
2021 &size);
2022 if (regReturn == ERROR_FILE_NOT_FOUND || (regReturn == ERROR_SUCCESS && size < 1))
2023 {
2024#endif
2025 type = REG_SZ;
2026 size = sizeof(pFixedInfo->HostName);
2027 regReturn = RegQueryValueExA(hKey,
2028 "Hostname",
2029 NULL,
2030 &type,
2031 (LPBYTE)pFixedInfo->HostName,
2032 &size);
2033#if 0
2034 }
2035#endif
2036
2037 type = REG_SZ;
2038 size = sizeof(pFixedInfo->DomainName);
2039 regReturn = RegQueryValueExA(hKey,
2040 "DhcpDomain",
2041 NULL,
2042 &type,
2043 (LPBYTE)pFixedInfo->DomainName,
2044 &size);
2045 if (regReturn == ERROR_FILE_NOT_FOUND || (regReturn == ERROR_SUCCESS && size < 1))
2046 {
2047 type = REG_SZ;
2048 size = sizeof(pFixedInfo->DomainName);
2049 regReturn = RegQueryValueExA(hKey,
2050 "Domain",
2051 NULL,
2052 &type,
2053 (LPBYTE)pFixedInfo->DomainName,
2054 &size);
2055 }
2056 RegCloseKey(hKey);
2057 }
2058
2059 TRACE("GetComputerNameExA: %s\n", pFixedInfo->DomainName);
2060
2061 if (resInfo->riCount > 0)
2062 {
2063 CopyMemory(&pFixedInfo->DnsServerList, resInfo->DnsList, sizeof(IP_ADDR_STRING));
2064 if (resInfo->riCount > 1)
2065 {
2066 IP_ADDR_STRING *pSrc = resInfo->DnsList->Next;
2067 IP_ADDR_STRING *pTarget = (struct _IP_ADDR_STRING*)((char*)pFixedInfo + sizeof(FIXED_INFO));
2068
2069 pFixedInfo->DnsServerList.Next = pTarget;
2070
2071 do
2072 {
2073 CopyMemory(pTarget, pSrc, sizeof(IP_ADDR_STRING));
2074 resInfo->riCount--;
2075 if (resInfo->riCount > 1)
2076 {
2077 pTarget->Next = (IP_ADDR_STRING*)((char*)pTarget + sizeof(IP_ADDR_STRING));
2078 pTarget = pTarget->Next;
2079 pSrc = pSrc->Next;
2080 }
2081 else
2082 {
2083 pTarget->Next = NULL;
2084 break;
2085 }
2086 }
2087 while(TRUE);
2088 }
2089 else
2090 {
2091 pFixedInfo->DnsServerList.Next = NULL;
2092 }
2093 }
2094
2095 pFixedInfo->NodeType = HYBRID_NODETYPE;
2096 regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2097 "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ, &hKey);
2098 if (regReturn != ERROR_SUCCESS)
2099 regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2100 "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters", 0, KEY_READ,
2101 &hKey);
2102 if (regReturn == ERROR_SUCCESS)
2103 {
2104 DWORD size = sizeof(pFixedInfo->ScopeId);
2105
2106 RegQueryValueExA(hKey, "ScopeID", NULL, NULL, (PBYTE)pFixedInfo->ScopeId, &size);
2107 RegCloseKey(hKey);
2108 }
2109
2110 disposeResInfo( resInfo );
2111 /* FIXME: can check whether routing's enabled in /proc/sys/net/ipv4/ip_forward
2112 I suppose could also check for a listener on port 53 to set EnableDns */
2113 ret = NO_ERROR;
2114 TRACE("returning %ld\n", ret);
2115
2116 return ret;
2117}
RegOpenKeyExA
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3298
pTarget
FxIoTarget * pTarget
Definition: fxdeviceapi.cpp:97
REG_SZ
#define REG_SZ
Definition: layer.c:22
CopyMemory
#define CopyMemory
Definition: minwinbase.h:29
ERROR_FILE_NOT_FOUND
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
KEY_READ
#define KEY_READ
Definition: nt_native.h:1026
LONG
long LONG
Definition: pedump.c:60
HYBRID_NODETYPE
#define HYBRID_NODETYPE
Definition: iptypes.h:28
IP_ADDR_STRING
struct _IP_ADDR_STRING IP_ADDR_STRING
disposeResInfo
VOID disposeResInfo(PIPHLP_RES_INFO InfoPtr)
Definition: resinfo.c:60
getResInfo
PIPHLP_RES_INFO getResInfo()
Definition: resinfo.c:54
FIXED_INFO_W2KSP1::DomainName
char DomainName[MAX_DOMAIN_NAME_LEN+4]
Definition: iptypes.h:75
FIXED_INFO_W2KSP1::HostName
char HostName[MAX_HOSTNAME_LEN+4]
Definition: iptypes.h:74
FIXED_INFO_W2KSP1::DnsServerList
IP_ADDR_STRING DnsServerList
Definition: iptypes.h:77
FIXED_INFO_W2KSP1::ScopeId
char ScopeId[MAX_SCOPE_ID_LEN+4]
Definition: iptypes.h:79
FIXED_INFO_W2KSP1::NodeType
UINT NodeType
Definition: iptypes.h:78
FIXED_INFO
Definition: iptypes.h:79
_IPHLP_RES_INFO
Definition: resinfo.h:24
_IPHLP_RES_INFO::DnsList
IP_ADDR_STRING * DnsList
Definition: resinfo.h:26
_IPHLP_RES_INFO::riCount
DWORD riCount
Definition: resinfo.h:25
_IP_ADDR_STRING
Definition: iptypes.h:34
_IP_ADDR_STRING::Next
struct _IP_ADDR_STRING * Next
Definition: iptypes.h:35
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12

Referenced by getdomainname(), main(), Query_Main(), ShowInfo(), test_GetNetworkParams(), testGetNetworkParams(), and TestHostName().

◆ GetNumberOfInterfaces()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetNumberOfInterfaces ( PDWORD  pdwNumIf)

Definition at line 2129 of file iphlpapi_main.c.

2130{
2131 DWORD ret;
2132
2133 TRACE("pdwNumIf %p\n", pdwNumIf);
2134 if (!pdwNumIf)
2135 ret = ERROR_INVALID_PARAMETER;
2136 else {
2137 *pdwNumIf = getNumInterfaces();
2138 ret = NO_ERROR;
2139 }
2140 TRACE("returning %ld\n", ret);
2141 return ret;
2142}

Referenced by _RpcEnumInterfaces(), and testGetNumberOfInterfaces().

◆ GetPerAdapterInfo()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetPerAdapterInfo ( ULONG  IfIndex,
PIP_PER_ADAPTER_INFO  pPerAdapterInfo,
PULONG  pOutBufLen 
)

Definition at line 2411 of file iphlpapi_main.c.

2412{
2413 HKEY hkey;
2414 DWORD dwSize = 0;
2415 const char *ifName;
2416 NAME_SERVER_LIST_CONTEXT Context;
2417 WCHAR keyname[200] = L"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\";
2418
2419 if (!pOutBufLen)
2420 return ERROR_INVALID_PARAMETER;
2421
2422 if (!pPerAdapterInfo || *pOutBufLen < sizeof(IP_PER_ADAPTER_INFO))
2423 {
2424 *pOutBufLen = sizeof(IP_PER_ADAPTER_INFO);
2425 return ERROR_BUFFER_OVERFLOW;
2426 }
2427
2428 ifName = getInterfaceNameByIndex(IfIndex);
2429 if (!ifName)
2430 return ERROR_INVALID_PARAMETER;
2431
2432 MultiByteToWideChar(CP_ACP, 0, ifName, -1, &keyname[62], sizeof(keyname)/sizeof(WCHAR) - 63);
2433 HeapFree(GetProcessHeap(), 0, (LPVOID)ifName);
2434
2435 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keyname, 0, KEY_READ, &hkey) != ERROR_SUCCESS)
2436 {
2437 return ERROR_NOT_SUPPORTED;
2438 }
2439 Context.NumServers = 0;
2440 Context.uSizeAvailable = *pOutBufLen;
2441 Context.uSizeRequired = sizeof(IP_PER_ADAPTER_INFO);
2442 Context.pData = pPerAdapterInfo;
2443
2444 if (*pOutBufLen >= sizeof(IP_PER_ADAPTER_INFO))
2445 ZeroMemory(pPerAdapterInfo, sizeof(IP_PER_ADAPTER_INFO));
2446
2447 EnumNameServers(hkey, &keyname[62], &Context, CreateNameServerListEnumNamesFunc);
2448
2449 if (Context.uSizeRequired > Context.uSizeAvailable)
2450 {
2451 *pOutBufLen = Context.uSizeRequired;
2452 RegCloseKey(hkey);
2453 return ERROR_BUFFER_OVERFLOW;
2454 }
2455
2456 if(RegQueryValueExW(hkey, L"NameServer", NULL, NULL, NULL, &dwSize) == ERROR_SUCCESS)
2457 {
2458 pPerAdapterInfo->AutoconfigActive = FALSE;
2459 }
2460 else
2461 {
2462 pPerAdapterInfo->AutoconfigActive = TRUE;
2463 }
2464
2465 RegCloseKey(hkey);
2466 return NOERROR;
2467}
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
RegQueryValueExW
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
CP_ACP
#define CP_ACP
Definition: compat.h:109
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
CreateNameServerListEnumNamesFunc
static void CreateNameServerListEnumNamesFunc(PWCHAR Interface, PWCHAR Server, PVOID Data)
Definition: iphlpapi_main.c:2370
EnumNameServers
LSTATUS EnumNameServers(HKEY RegHandle, LPWSTR Interface, PVOID Data, EnumNameServersFunc cb)
ZeroMemory
#define ZeroMemory
Definition: minwinbase.h:31
IP_PER_ADAPTER_INFO
IP_PER_ADAPTER_INFO_W2KSP1 IP_PER_ADAPTER_INFO
Definition: iptypes.h:69
_IP_PER_ADAPTER_INFO_W2KSP1
Definition: iptypes.h:62
_IP_PER_ADAPTER_INFO_W2KSP1::AutoconfigActive
UINT AutoconfigActive
Definition: iptypes.h:64
_NAME_SERVER_LIST_CONTEXT
Definition: iphlpapi_main.c:31
NOERROR
#define NOERROR
Definition: winerror.h:3448

Referenced by Initialize(), LANStatusUiDetailsDlg(), ShowInfo(), and testGetPerAdapterInfo().

◆ GetPerTcpConnectionEStats()

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 
)

◆ GetRTTAndHopCount()

IPHLPAPI_DLL_LINKAGE BOOL WINAPI GetRTTAndHopCount ( IPAddr  DestIpAddress,
PULONG  HopCount,
ULONG  MaxHops,
PULONG  RTT 
)

Definition at line 2482 of file iphlpapi_main.c.

2483{
2484 TRACE("DestIpAddress 0x%08lx, HopCount %p, MaxHops %ld, RTT %p\n",
2485 DestIpAddress, HopCount, MaxHops, RTT);
2486 FIXME(":stub\n");
2487 return (BOOL) 0;
2488}

◆ GetTcpStatistics()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetTcpStatistics ( PMIB_TCPSTATS  pStats)

Definition at line 2531 of file iphlpapi_main.c.

2532{
2533 return GetTcpStatisticsEx(pStats, PF_INET);
2534}
GetTcpStatisticsEx
DWORD WINAPI GetTcpStatisticsEx(PMIB_TCPSTATS pStats, DWORD dwFamily)
Definition: iphlpapi_main.c:2501

Referenced by mib2TcpInit(), ShowTcpStatistics(), and testGetTcpStatistics().

◆ GetTcpStatisticsEx()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetTcpStatisticsEx ( PMIB_TCPSTATS  pStats,
DWORD  dwFamily 
)

Definition at line 2501 of file iphlpapi_main.c.

2502{
2503 HANDLE tcpFile;
2504 DWORD ret;
2505
2506 if (!pStats)
2507 return ERROR_INVALID_PARAMETER;
2508
2509 if (dwFamily != AF_INET && dwFamily != AF_INET6)
2510 return ERROR_INVALID_PARAMETER;
2511
2512 if (!NT_SUCCESS(openTcpFile(&tcpFile, FILE_READ_DATA)))
2513 return ERROR_NOT_SUPPORTED;
2514
2515 TRACE("pStats %p\n", pStats);
2516 ret = getTCPStats(tcpFile, pStats);
2517 closeTcpFile(tcpFile);
2518 TRACE("returning %ld\n", ret);
2519 return ret;
2520}
getTCPStats
DWORD getTCPStats(HANDLE tcpFile, MIB_TCPSTATS *stats)

Referenced by GetTcpStatistics(), and testGetTcpStatisticsEx().

◆ GetTcpTable()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetTcpTable ( PMIB_TCPTABLE  pTcpTable,
PDWORD  pdwSize,
BOOL  bOrder 
)

Definition at line 2559 of file iphlpapi_main.c.

2560{
2561 return GetExtendedTcpTable(pTcpTable, pdwSize, bOrder, AF_INET, TCP_TABLE_BASIC_ALL, 0);
2562}
GetExtendedTcpTable
DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
Definition: iphlpapi_main.c:919

Referenced by AllocateAndGetTcpTableFromStack(), and testGetTcpTable().

◆ GetUdp6Table()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUdp6Table ( PMIB_UDP6TABLE  pUdpTable,
PDWORD  pdwSize,
BOOL  bOrder 
)

◆ GetUdpStatistics()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUdpStatistics ( PMIB_UDPSTATS  pStats)

Definition at line 2605 of file iphlpapi_main.c.

2606{
2607 return GetUdpStatisticsEx(pStats, PF_INET);
2608}
GetUdpStatisticsEx
DWORD WINAPI GetUdpStatisticsEx(PMIB_UDPSTATS pStats, DWORD dwFamily)
Definition: iphlpapi_main.c:2575

Referenced by mib2UdpInit(), ShowUdpStatistics(), and testGetUdpStatistics().

◆ GetUdpStatisticsEx()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUdpStatisticsEx ( PMIB_UDPSTATS  pStats,
DWORD  dwFamily 
)

Definition at line 2575 of file iphlpapi_main.c.

2576{
2577 HANDLE tcpFile;
2578 DWORD ret;
2579
2580 if (!pStats)
2581 return ERROR_INVALID_PARAMETER;
2582
2583 if (dwFamily != AF_INET && dwFamily != AF_INET6)
2584 return ERROR_INVALID_PARAMETER;
2585
2586 if (!NT_SUCCESS(openTcpFile(&tcpFile, FILE_READ_DATA)))
2587 return ERROR_NOT_SUPPORTED;
2588
2589 TRACE("pStats %p\n", pStats);
2590 ret = getUDPStats(tcpFile, pStats);
2591 closeTcpFile(tcpFile);
2592 TRACE("returning %ld\n", ret);
2593 return ret;
2594}
getUDPStats
DWORD getUDPStats(HANDLE tcpFile, MIB_UDPSTATS *stats)

Referenced by GetUdpStatistics(), and testGetUdpStatisticsEx().

◆ GetUdpTable()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUdpTable ( PMIB_UDPTABLE  pUdpTable,
PDWORD  pdwSize,
BOOL  bOrder 
)

Definition at line 2622 of file iphlpapi_main.c.

2623{
2624 return GetExtendedUdpTable(pUdpTable, pdwSize, bOrder, AF_INET, UDP_TABLE_BASIC, 0);
2625}
GetExtendedUdpTable
DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)
Definition: iphlpapi_main.c:1335

Referenced by AllocateAndGetUdpTableFromStack(), mib2UdpEntryInit(), and testGetUdpTable().

◆ GetUniDirectionalAdapterInfo()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI GetUniDirectionalAdapterInfo ( PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS  pIPIfInfo,
PULONG  dwOutBufLen 
)

Definition at line 2646 of file iphlpapi_main.c.

2647{
2648 TRACE("pIPIfInfo %p, dwOutBufLen %p\n", pIPIfInfo, dwOutBufLen);
2649 /* a unidirectional adapter?? not bloody likely! */
2650 return ERROR_NOT_SUPPORTED;
2651}

◆ IpReleaseAddress()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI IpReleaseAddress ( PIP_ADAPTER_INDEX_MAP  AdapterInfo)

Definition at line 2666 of file iphlpapi_main.c.

2667{
2668 DWORD Status, Version = 0;
2669
2670 if (!AdapterInfo)
2671 return ERROR_INVALID_PARAMETER;
2672
2673 /* Maybe we should do this in DllMain */
2674 if (DhcpCApiInitialize(&Version) != ERROR_SUCCESS)
2675 return ERROR_PROC_NOT_FOUND;
2676
2677 Status = DhcpReleaseParameters(AdapterInfo->Name);
2678
2679 DhcpCApiCleanup();
2680
2681 return Status;
2682}
DhcpCApiInitialize
DWORD APIENTRY DhcpCApiInitialize(_Out_ LPDWORD Version)
Definition: dhcpcsvc.c:102
DhcpReleaseParameters
DWORD APIENTRY DhcpReleaseParameters(_In_ PWSTR AdapterName)
Definition: dhcpcsvc.c:266
DhcpCApiCleanup
VOID APIENTRY DhcpCApiCleanup(VOID)
Definition: dhcpcsvc.c:116
Status
Status
Definition: gdiplustypes.h:25
Version
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE _In_ USHORT _In_ USHORT Version
Definition: wdffdo.h:469
ERROR_PROC_NOT_FOUND
#define ERROR_PROC_NOT_FOUND
Definition: winerror.h:321

Referenced by WlanDisconnect().

◆ IpRenewAddress()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI IpRenewAddress ( PIP_ADAPTER_INDEX_MAP  AdapterInfo)

Definition at line 2697 of file iphlpapi_main.c.

2698{
2699 DWORD Status, Version = 0;
2700
2701 if (!AdapterInfo)
2702 return ERROR_INVALID_PARAMETER;
2703
2704 /* Maybe we should do this in DllMain */
2705 if (DhcpCApiInitialize(&Version) != ERROR_SUCCESS)
2706 return ERROR_PROC_NOT_FOUND;
2707
2708 Status = DhcpAcquireParameters(AdapterInfo->Name);
2709
2710 DhcpCApiCleanup();
2711
2712 return Status;
2713}
DhcpAcquireParameters
DWORD APIENTRY DhcpAcquireParameters(_In_ PWSTR AdapterName)
Definition: dhcpcsvc.c:132

◆ NotifyAddrChange()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI NotifyAddrChange ( PHANDLE  Handle,
LPOVERLAPPED  overlapped 
)

Definition at line 2732 of file iphlpapi_main.c.

2733{
2734 FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
2735 if (Handle) *Handle = INVALID_HANDLE_VALUE;
2736 if (overlapped) ((IO_STATUS_BLOCK *) overlapped)->Status = STATUS_PENDING;
2737 return ERROR_IO_PENDING;
2738}
ERROR_IO_PENDING
#define ERROR_IO_PENDING
Definition: dderror.h:15
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
Handle
ULONG Handle
Definition: gdb_input.c:15
overlapped
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED * overlapped
Definition: sock.c:81
_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870
STATUS_PENDING
#define STATUS_PENDING
Definition: telnetd.h:14

Referenced by AdapterDiscoveryThread(), detectChange(), and testNotifyAddrChange().

◆ NotifyRouteChange()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI NotifyRouteChange ( PHANDLE  Handle,
LPOVERLAPPED  overlapped 
)

Definition at line 2757 of file iphlpapi_main.c.

2758{
2759 FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
2760 return ERROR_NOT_SUPPORTED;
2761}

◆ SendARP()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI SendARP ( IPAddr  DestIP,
IPAddr  SrcIP,
PULONG  pMacAddr,
PULONG  PhyAddrLen 
)

Definition at line 2778 of file iphlpapi_main.c.

2779{
2780 IPAddr IPs[2];
2781 ULONG Size;
2782
2783 if (IsBadWritePtr(pMacAddr, sizeof(ULONG)) || IsBadWritePtr(PhyAddrLen, sizeof(ULONG)))
2784 return ERROR_INVALID_PARAMETER;
2785
2786 IPs[0] = DestIP;
2787 IPs[1] = SrcIP;
2788 Size = sizeof(IPs);
2789 return TCPSendIoctl(INVALID_HANDLE_VALUE, IOCTL_QUERY_IP_HW_ADDRESS, IPs, &Size, pMacAddr, PhyAddrLen);
2790}
IsBadWritePtr
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
Definition: except.c:883
TCPSendIoctl
DWORD TCPSendIoctl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, PULONG pInBufferSize, LPVOID lpOutBuffer, PULONG pOutBufferSize)
Definition: iphlpapi_reactos.c:13
IPAddr
ULONG IPAddr
Definition: pfhook.h:35
IOCTL_QUERY_IP_HW_ADDRESS
#define IOCTL_QUERY_IP_HW_ADDRESS
Definition: tcpioctl.h:40
Size
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4539

Referenced by Ping(), state_panic(), and TestUM().

◆ SetIfEntry()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetIfEntry ( PMIB_IFROW  pIfRow)

Definition at line 2808 of file iphlpapi_main.c.

2809{
2810 FIXME("(pIfRow %p): stub\n", pIfRow);
2811 /* this is supposed to set an interface administratively up or down.
2812 Could do SIOCSIFFLAGS and set/clear IFF_UP, but, not sure I want to, and
2813 this sort of down is indistinguishable from other sorts of down (e.g. no
2814 link). */
2815 return ERROR_NOT_SUPPORTED;
2816}

◆ SetIpForwardEntry()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetIpForwardEntry ( PMIB_IPFORWARDROW  pRoute)

Definition at line 2831 of file iphlpapi_main.c.

2832{
2833 return setIpForwardEntry( pRoute );
2834}
setIpForwardEntry
DWORD setIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:59

◆ SetIpNetEntry()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetIpNetEntry ( PMIB_IPNETROW  pArpEntry)

Definition at line 2849 of file iphlpapi_main.c.

2850{
2851 HANDLE tcpFile;
2852 NTSTATUS status;
2853 TCP_REQUEST_SET_INFORMATION_EX_ARP_ENTRY req =
2854 TCP_REQUEST_SET_INFORMATION_INIT;
2855 TDIEntityID id;
2856 DWORD returnSize;
2857 PMIB_IPNETROW arpBuff;
2858
2859 if (!pArpEntry)
2860 return ERROR_INVALID_PARAMETER;
2861
2862 if (!NT_SUCCESS(openTcpFile( &tcpFile, FILE_READ_DATA | FILE_WRITE_DATA )))
2863 return ERROR_NOT_SUPPORTED;
2864
2865 if (!NT_SUCCESS(getNthIpEntity( tcpFile, pArpEntry->dwIndex, &id )))
2866 {
2867 closeTcpFile(tcpFile);
2868 return ERROR_INVALID_PARAMETER;
2869 }
2870
2871 req.Req.ID.toi_class = INFO_CLASS_PROTOCOL;
2872 req.Req.ID.toi_type = INFO_TYPE_PROVIDER;
2873 req.Req.ID.toi_id = IP_MIB_ARPTABLE_ENTRY_ID;
2874 req.Req.ID.toi_entity.tei_instance = id.tei_instance;
2875 req.Req.ID.toi_entity.tei_entity = AT_ENTITY;
2876 req.Req.BufferSize = sizeof(MIB_IPNETROW);
2877 arpBuff = (PMIB_IPNETROW)&req.Req.Buffer[0];
2878
2879 RtlCopyMemory(arpBuff, pArpEntry, sizeof(MIB_IPNETROW));
2880
2881 status = DeviceIoControl( tcpFile,
2882 IOCTL_TCP_SET_INFORMATION_EX,
2883 &req,
2884 sizeof(req),
2885 NULL,
2886 0,
2887 &returnSize,
2888 NULL );
2889
2890 closeTcpFile(tcpFile);
2891
2892 if (status)
2893 return NO_ERROR;
2894 else
2895 return ERROR_INVALID_PARAMETER;
2896}
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
DeviceIoControl
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
id
GLuint id
Definition: glext.h:5910
getNthIpEntity
NTSTATUS getNthIpEntity(HANDLE tcpFile, DWORD index, TDIEntityID *ent)
Definition: ipstats_reactos.c:65
TCP_REQUEST_SET_INFORMATION_INIT
#define TCP_REQUEST_SET_INFORMATION_INIT
Definition: iphlpapi_private.h:74
MIB_IPNETROW
struct _MIB_IPNETROW MIB_IPNETROW
PMIB_IPNETROW
struct _MIB_IPNETROW * PMIB_IPNETROW
FILE_WRITE_DATA
#define FILE_WRITE_DATA
Definition: nt_native.h:631
_MIB_IPNETROW::dwIndex
DWORD dwIndex
Definition: ipmib.h:114
_TCP_REQUEST_SET_INFORMATION_EX::BufferSize
unsigned int BufferSize
Definition: tdiinfo.h:96
_TCP_REQUEST_SET_INFORMATION_EX::ID
TDIObjectID ID
Definition: tdiinfo.h:95
_TCP_REQUEST_SET_INFORMATION_EX::Buffer
unsigned char Buffer[1]
Definition: tdiinfo.h:97
_TDIEntityID
Definition: tdiinfo.h:30
_TDIEntityID::tei_entity
ULONG tei_entity
Definition: tdiinfo.h:31
_TDIEntityID::tei_instance
ULONG tei_instance
Definition: tdiinfo.h:32
_TDIObjectID::toi_id
ULONG toi_id
Definition: tdiinfo.h:77
_TDIObjectID::toi_type
ULONG toi_type
Definition: tdiinfo.h:76
_TDIObjectID::toi_class
ULONG toi_class
Definition: tdiinfo.h:75
_TDIObjectID::toi_entity
TDIEntityID toi_entity
Definition: tdiinfo.h:74
status
Definition: ps.c:97
IP_MIB_ARPTABLE_ENTRY_ID
#define IP_MIB_ARPTABLE_ENTRY_ID
Definition: tcpioctl.h:54
INFO_CLASS_PROTOCOL
#define INFO_CLASS_PROTOCOL
Definition: tdiinfo.h:65
AT_ENTITY
#define AT_ENTITY
Definition: tdiinfo.h:41
INFO_TYPE_PROVIDER
#define INFO_TYPE_PROVIDER
Definition: tdiinfo.h:69
IOCTL_TCP_SET_INFORMATION_EX
#define IOCTL_TCP_SET_INFORMATION_EX
Definition: tditest.h:112
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
_TCP_REQUEST_SET_INFORMATION_EX_ARP_ENTRY
Definition: iphlpapi_private.h:120
_TCP_REQUEST_SET_INFORMATION_EX_ARP_ENTRY::Req
TCP_REQUEST_SET_INFORMATION_EX Req
Definition: iphlpapi_private.h:123

Referenced by Addhost().

◆ SetIpStatistics()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetIpStatistics ( PMIB_IPSTATS  pIpStats)

Definition at line 2914 of file iphlpapi_main.c.

2915{
2916 FIXME("(pIpStats %p): stub\n", pIpStats);
2917 return 0;
2918}

◆ SetIpTTL()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetIpTTL ( UINT  nTTL)

Definition at line 2936 of file iphlpapi_main.c.

2937{
2938 FIXME("(nTTL %d): stub\n", nTTL);
2939 return 0;
2940}

◆ SetPerTcpConnectionEStats()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetPerTcpConnectionEStats ( MIB_TCPROW *  row,
TCP_ESTATS_TYPE  state,
BYTE *  rw,
ULONG  version,
ULONG  size,
ULONG  offset 
)

◆ SetTcpEntry()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI SetTcpEntry ( PMIB_TCPROW  pTcpRow)

Definition at line 2958 of file iphlpapi_main.c.

2959{
2960 FIXME("(pTcpRow %p): stub\n", pTcpRow);
2961 return 0;
2962}

Referenced by testSetTcpEntry().

◆ UnenableRouter()

IPHLPAPI_DLL_LINKAGE DWORD WINAPI UnenableRouter ( OVERLAPPED *  pOverlapped,
LPDWORD  lpdwEnableCount 
)

Definition at line 2982 of file iphlpapi_main.c.

2983{
2984 FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped,
2985 lpdwEnableCount);
2986 return ERROR_NOT_SUPPORTED;
2987}