ReactOS 0.4.16-dev-1059-gb1cf981
iphlpapi_main.c File Reference
#include <config.h>
#include "iphlpapi_private.h"
#include <strsafe.h>
#include <psapi.h>
Include dependency graph for iphlpapi_main.c:

Go to the source code of this file.

Classes

struct  _NAME_SERVER_LIST_CONTEXT
 

Macros

#define DEBUG
 

Typedefs

typedef struct _NAME_SERVER_LIST_CONTEXT NAME_SERVER_LIST_CONTEXT
 
typedef struct _NAME_SERVER_LIST_CONTEXTPNAME_SERVER_LIST_CONTEXT
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (iphlpapi)
 
BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 
DWORD WINAPI AddIPAddress (IPAddr Address, IPMask Netmask, DWORD IfIndex, PULONG NteContext, PULONG NteInstance)
 
DWORD getInterfaceGatewayByIndex (DWORD index)
 
DWORD WINAPI AllocateAndGetIfTableFromStack (PMIB_IFTABLE *ppIfTable, BOOL bOrder, HANDLE heap, DWORD flags)
 
DWORD WINAPI AllocateAndGetIpAddrTableFromStack (PMIB_IPADDRTABLE *ppIpAddrTable, BOOL bOrder, HANDLE heap, DWORD flags)
 
DWORD WINAPI AllocateAndGetIpForwardTableFromStack (PMIB_IPFORWARDTABLE *ppIpForwardTable, BOOL bOrder, HANDLE heap, DWORD flags)
 
DWORD WINAPI AllocateAndGetIpNetTableFromStack (PMIB_IPNETTABLE *ppIpNetTable, BOOL bOrder, HANDLE heap, DWORD flags)
 
DWORD WINAPI AllocateAndGetTcpTableFromStack (PMIB_TCPTABLE *ppTcpTable, BOOL bOrder, HANDLE heap, DWORD flags)
 
DWORD WINAPI AllocateAndGetTcpExTableFromStack (PVOID *ppTcpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family)
 
DWORD WINAPI AllocateAndGetTcpExTable2FromStack (PVOID *ppTcpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family, TCP_TABLE_CLASS class)
 
DWORD WINAPI AllocateAndGetUdpTableFromStack (PMIB_UDPTABLE *ppUdpTable, BOOL bOrder, HANDLE heap, DWORD flags)
 
DWORD WINAPI AllocateAndGetUdpExTableFromStack (PVOID *ppUdpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family)
 
DWORD WINAPI AllocateAndGetUdpExTable2FromStack (PVOID *ppUdpTable, BOOL bOrder, HANDLE heap, DWORD flags, DWORD family, UDP_TABLE_CLASS class)
 
DWORD WINAPI CreateIpForwardEntry (PMIB_IPFORWARDROW pRoute)
 
DWORD WINAPI CreateIpNetEntry (PMIB_IPNETROW pArpEntry)
 
DWORD WINAPI CreateProxyArpEntry (DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
 
DWORD WINAPI DeleteIPAddress (ULONG NTEContext)
 
DWORD WINAPI DeleteIpForwardEntry (PMIB_IPFORWARDROW pRoute)
 
DWORD WINAPI DeleteIpNetEntry (PMIB_IPNETROW pArpEntry)
 
DWORD WINAPI DeleteProxyArpEntry (DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
 
DWORD WINAPI EnableRouter (HANDLE *pHandle, OVERLAPPED *pOverlapped)
 
DWORD WINAPI FlushIpNetTable (DWORD dwIfIndex)
 
DWORD WINAPI GetAdapterIndex (LPWSTR AdapterName, PULONG IfIndex)
 
DWORD WINAPI GetAdaptersInfo (PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen)
 
DWORD WINAPI GetBestInterface (IPAddr dwDestAddr, PDWORD pdwBestIfIndex)
 
DWORD WINAPI GetBestRoute (DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
 
static int TcpTableSorter (const void *a, const void *b)
 
DWORD WINAPI GetExtendedTcpTable (PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
 
static int UdpTableSorter (const void *a, const void *b)
 
DWORD WINAPI GetExtendedUdpTable (PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)
 
DWORD WINAPI GetFriendlyIfIndex (DWORD IfIndex)
 
DWORD WINAPI GetIcmpStatistics (PMIB_ICMP pStats)
 
DWORD WINAPI GetIfEntry (PMIB_IFROW pIfRow)
 
static int IfTableSorter (const void *a, const void *b)
 
DWORD WINAPI GetIfTable (PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
 
DWORD WINAPI GetInterfaceInfo (PIP_INTERFACE_INFO pIfTable, PULONG dwOutBufLen)
 
static int IpAddrTableSorter (const void *a, const void *b)
 
DWORD WINAPI GetIpAddrTable (PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder)
 
static int IpForwardTableSorter (const void *a, const void *b)
 
DWORD WINAPI GetIpForwardTable (PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder)
 
static int IpNetTableSorter (const void *a, const void *b)
 
DWORD WINAPI GetIpNetTable (PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder)
 
DWORD WINAPI GetIpStatistics (PMIB_IPSTATS pStats)
 
DWORD WINAPI GetIpStatisticsEx (PMIB_IPSTATS pStats, DWORD dwFamily)
 
DWORD WINAPI GetNetworkParams (PFIXED_INFO pFixedInfo, PULONG pOutBufLen)
 
DWORD WINAPI GetNumberOfInterfaces (PDWORD pdwNumIf)
 
static DWORD GetOwnerModuleFromPidEntry (DWORD OwningPid, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
 
static DWORD GetOwnerModuleFromTagEntry (DWORD OwningPid, DWORD OwningTag, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
 
DWORD WINAPI GetOwnerModuleFromTcpEntry (PMIB_TCPROW_OWNER_MODULE pTcpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
 
DWORD WINAPI GetOwnerModuleFromUdpEntry (PMIB_UDPROW_OWNER_MODULE pUdpEntry, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
 
static void CreateNameServerListEnumNamesFunc (PWCHAR Interface, PWCHAR Server, PVOID Data)
 
DWORD WINAPI GetPerAdapterInfo (ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen)
 
BOOL WINAPI GetRTTAndHopCount (IPAddr DestIpAddress, PULONG HopCount, ULONG MaxHops, PULONG RTT)
 
DWORD WINAPI GetTcpStatisticsEx (PMIB_TCPSTATS pStats, DWORD dwFamily)
 
DWORD WINAPI GetTcpStatistics (PMIB_TCPSTATS pStats)
 
DWORD WINAPI GetTcpTable (PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
 
DWORD WINAPI GetUdpStatisticsEx (PMIB_UDPSTATS pStats, DWORD dwFamily)
 
DWORD WINAPI GetUdpStatistics (PMIB_UDPSTATS pStats)
 
DWORD WINAPI GetUdpTable (PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
 
DWORD WINAPI GetUniDirectionalAdapterInfo (PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo, PULONG dwOutBufLen)
 
DWORD WINAPI IpReleaseAddress (PIP_ADAPTER_INDEX_MAP AdapterInfo)
 
DWORD WINAPI IpRenewAddress (PIP_ADAPTER_INDEX_MAP AdapterInfo)
 
DWORD WINAPI NotifyAddrChange (PHANDLE Handle, LPOVERLAPPED overlapped)
 
DWORD WINAPI NotifyRouteChange (PHANDLE Handle, LPOVERLAPPED overlapped)
 
DWORD WINAPI SendARP (IPAddr DestIP, IPAddr SrcIP, PULONG pMacAddr, PULONG PhyAddrLen)
 
DWORD WINAPI SetIfEntry (PMIB_IFROW pIfRow)
 
DWORD WINAPI SetIpForwardEntry (PMIB_IPFORWARDROW pRoute)
 
DWORD WINAPI SetIpNetEntry (PMIB_IPNETROW pArpEntry)
 
DWORD WINAPI SetIpStatistics (PMIB_IPSTATS pIpStats)
 
DWORD WINAPI SetIpTTL (UINT nTTL)
 
DWORD WINAPI SetTcpEntry (PMIB_TCPROW pTcpRow)
 
DWORD WINAPI UnenableRouter (OVERLAPPED *pOverlapped, LPDWORD lpdwEnableCount)
 
DWORD WINAPI GetIpErrorString (IP_STATUS ErrorCode, PWCHAR Buffer, PDWORD Size)
 
PIP_ADAPTER_ORDER_MAP WINAPI GetAdapterOrderMap (VOID)
 
BOOL WINAPI CancelIPChangeNotify (LPOVERLAPPED notifyOverlapped)
 
DWORD WINAPI GetBestInterfaceEx (struct sockaddr *pDestAddr, PDWORD pdwBestIfIndex)
 
DWORD WINAPI NhpAllocateAndGetInterfaceInfoFromStack (IP_INTERFACE_NAME_INFO **ppTable, PDWORD pdwCount, BOOL bOrder, HANDLE hHeap, DWORD dwFlags)
 
DWORD WINAPI GetIcmpStatisticsEx (PMIB_ICMP_EX pStats, DWORD dwFamily)
 
DWORD WINAPI SetIpForwardEntryToStack (PMIB_IPFORWARDROW pRoute)
 
DWORD GetInterfaceNameInternal (_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen)
 
DWORD WINAPI NhGetInterfaceNameFromDeviceGuid (_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen, DWORD dwUnknown4, DWORD dwUnknown5)
 
DWORD WINAPI NhGetInterfaceNameFromGuid (_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen, DWORD dwUnknown4, DWORD dwUnknown5)
 

Macro Definition Documentation

◆ DEBUG

#define DEBUG

Definition at line 22 of file iphlpapi_main.c.

Typedef Documentation

◆ NAME_SERVER_LIST_CONTEXT

◆ PNAME_SERVER_LIST_CONTEXT

Function Documentation

◆ AddIPAddress()

DWORD WINAPI AddIPAddress ( IPAddr  Address,
IPMask  Netmask,
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}
NTSTATUS addIPAddress(IPAddr Address, IPMask Mask, DWORD IfIndex, PULONG NteContext, PULONG NteInstance)
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
static WCHAR Address[46]
Definition: ping.c:68

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

◆ AllocateAndGetIfTableFromStack()

DWORD WINAPI AllocateAndGetIfTableFromStack ( PMIB_IFTABLE ppIfTable,
BOOL  bOrder,
HANDLE  heap,
DWORD  flags 
)

Definition at line 100 of file iphlpapi_main.c.

102{
103 DWORD ret;
104
105 TRACE("ppIfTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n", ppIfTable,
106 (DWORD)bOrder, heap, flags);
107 if (!ppIfTable)
109 else {
110 DWORD dwSize = 0;
111
112 *ppIfTable = NULL;
113 ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
115 *ppIfTable = (PMIB_IFTABLE)HeapAlloc(heap, flags, dwSize);
116 ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
117 if (ret != NO_ERROR) {
118 HeapFree(heap, flags, *ppIfTable);
119 *ppIfTable = NULL;
120 }
121 }
122 }
123 TRACE("returning %ld\n", ret);
124 return ret;
125}
#define NO_ERROR
Definition: dderror.h:5
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
#define NULL
Definition: types.h:112
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
struct _MIB_IFTABLE * PMIB_IFTABLE
DWORD WINAPI GetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
static HANDLE heap
Definition: heap.c:65
#define TRACE(s)
Definition: solgame.cpp:4
int ret

◆ AllocateAndGetIpAddrTableFromStack()

DWORD WINAPI AllocateAndGetIpAddrTableFromStack ( PMIB_IPADDRTABLE ppIpAddrTable,
BOOL  bOrder,
HANDLE  heap,
DWORD  flags 
)

Definition at line 140 of file iphlpapi_main.c.

142{
143 DWORD ret;
144
145 TRACE("ppIpAddrTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
146 ppIpAddrTable, (DWORD)bOrder, heap, flags);
147 if (!ppIpAddrTable)
149 else {
150 DWORD dwSize = 0;
151
152 *ppIpAddrTable = NULL;
153 ret = GetIpAddrTable(*ppIpAddrTable, &dwSize, bOrder);
155 *ppIpAddrTable = (PMIB_IPADDRTABLE)HeapAlloc(heap, flags, dwSize);
156 ret = GetIpAddrTable(*ppIpAddrTable, &dwSize, bOrder);
157 if (ret != NO_ERROR) {
158 HeapFree(heap, flags, *ppIpAddrTable);
159 *ppIpAddrTable = NULL;
160 }
161 }
162 }
163 TRACE("returning %ld\n", ret);
164 return ret;
165}
DWORD WINAPI GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder)
struct _MIB_IPADDRTABLE * PMIB_IPADDRTABLE

◆ AllocateAndGetIpForwardTableFromStack()

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)
189 else {
190 DWORD dwSize = 0;
191
192 *ppIpForwardTable = NULL;
193 ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
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}
DWORD WINAPI GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder)
struct _MIB_IPFORWARDTABLE * PMIB_IPFORWARDTABLE

Referenced by GetBestRoute().

◆ AllocateAndGetIpNetTableFromStack()

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)
229 else {
230 DWORD dwSize = 0;
231
232 *ppIpNetTable = NULL;
233 ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
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}
DWORD WINAPI GetIpNetTable(PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder)
struct _MIB_IPNETTABLE * PMIB_IPNETTABLE

◆ AllocateAndGetTcpExTable2FromStack()

DWORD WINAPI AllocateAndGetTcpExTable2FromStack ( PVOID ppTcpTable,
BOOL  bOrder,
HANDLE  heap,
DWORD  flags,
DWORD  family,
TCP_TABLE_CLASS  class 
)

Definition at line 343 of file iphlpapi_main.c.

345{
346 DWORD ret;
347
348 TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family %ld, class %ld\n",
349 ppTcpTable, (DWORD)bOrder, heap, flags, family, class);
350 if (!ppTcpTable)
352 else {
353 DWORD dwSize = 0;
354
355 *ppTcpTable = NULL;
356 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, class, 0);
358 *ppTcpTable = HeapAlloc(heap, flags, dwSize);
359 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, class, 0);
360 if (ret != NO_ERROR) {
361 HeapFree(heap, flags, *ppTcpTable);
362 *ppTcpTable = NULL;
363 }
364 }
365 }
366 TRACE("returning %ld\n", ret);
367 return ret;
368}
DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)

◆ AllocateAndGetTcpExTableFromStack()

DWORD WINAPI AllocateAndGetTcpExTableFromStack ( PVOID ppTcpTable,
BOOL  bOrder,
HANDLE  heap,
DWORD  flags,
DWORD  family 
)

Definition at line 301 of file iphlpapi_main.c.

303{
304 DWORD ret;
305
306 TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family 0x%08lx\n",
307 ppTcpTable, (DWORD)bOrder, heap, flags, family);
308 if (!ppTcpTable)
310 else {
311 DWORD dwSize = 0;
312
313 *ppTcpTable = NULL;
314 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, TCP_TABLE_OWNER_PID_ALL, 0);
317 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, TCP_TABLE_OWNER_PID_ALL, 0);
318 if (ret != NO_ERROR) {
319 HeapFree(heap, flags, *ppTcpTable);
320 *ppTcpTable = NULL;
321 }
322 }
323 }
324 TRACE("returning %ld\n", ret);
325 return ret;
326}
@ TCP_TABLE_OWNER_PID_ALL
Definition: iprtrmib.h:35
struct _MIB_TCPTABLE_OWNER_PID * PMIB_TCPTABLE_OWNER_PID

◆ AllocateAndGetTcpTableFromStack()

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)
269 else {
270 DWORD dwSize = 0;
271
272 *ppTcpTable = NULL;
273 ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
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}
DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
struct _MIB_TCPTABLE * PMIB_TCPTABLE

◆ AllocateAndGetUdpExTable2FromStack()

DWORD WINAPI AllocateAndGetUdpExTable2FromStack ( PVOID ppUdpTable,
BOOL  bOrder,
HANDLE  heap,
DWORD  flags,
DWORD  family,
UDP_TABLE_CLASS  class 
)

Definition at line 466 of file iphlpapi_main.c.

468{
469 DWORD ret;
470
471 TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family %ld, class %ld\n",
472 ppUdpTable, (DWORD)bOrder, heap, flags, family, class);
473 if (!ppUdpTable)
475 else {
476 DWORD dwSize = 0;
477
478 *ppUdpTable = NULL;
479 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, class, 0);
481 *ppUdpTable = HeapAlloc(heap, flags, dwSize);
482 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, class, 0);
483 if (ret != NO_ERROR) {
484 HeapFree(heap, flags, *ppUdpTable);
485 *ppUdpTable = NULL;
486 }
487 }
488 }
489 TRACE("returning %ld\n", ret);
490 return ret;
491}
DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)

◆ AllocateAndGetUdpExTableFromStack()

DWORD WINAPI AllocateAndGetUdpExTableFromStack ( PVOID ppUdpTable,
BOOL  bOrder,
HANDLE  heap,
DWORD  flags,
DWORD  family 
)

Definition at line 424 of file iphlpapi_main.c.

426{
427 DWORD ret;
428
429 TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family 0x%08lx\n",
430 ppUdpTable, (DWORD)bOrder, heap, flags, family);
431 if (!ppUdpTable)
433 else {
434 DWORD dwSize = 0;
435
436 *ppUdpTable = NULL;
437 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, UDP_TABLE_OWNER_PID, 0);
440 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, UDP_TABLE_OWNER_PID, 0);
441 if (ret != NO_ERROR) {
442 HeapFree(heap, flags, *ppUdpTable);
443 *ppUdpTable = NULL;
444 }
445 }
446 }
447 TRACE("returning %ld\n", ret);
448 return ret;
449}
@ UDP_TABLE_OWNER_PID
Definition: iprtrmib.h:44
struct _MIB_UDPTABLE_OWNER_PID * PMIB_UDPTABLE_OWNER_PID

◆ AllocateAndGetUdpTableFromStack()

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)
392 else {
393 DWORD dwSize = 0;
394
395 *ppUdpTable = NULL;
396 ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
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}
DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
struct _MIB_UDPTABLE * PMIB_UDPTABLE

◆ CancelIPChangeNotify()

BOOL WINAPI CancelIPChangeNotify ( LPOVERLAPPED  notifyOverlapped)

Definition at line 3182 of file iphlpapi_main.c.

3183{
3184 FIXME(":stub\n");
3185 return 0L;
3186}
#define FIXME(fmt,...)
Definition: precomp.h:53
#define L(x)
Definition: ntvdm.h:50

◆ CreateIpForwardEntry()

DWORD WINAPI CreateIpForwardEntry ( PMIB_IPFORWARDROW  pRoute)

Definition at line 503 of file iphlpapi_main.c.

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

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

◆ CreateIpNetEntry()

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}

◆ CreateNameServerListEnumNamesFunc()

static void CreateNameServerListEnumNamesFunc ( PWCHAR  Interface,
PWCHAR  Server,
PVOID  Data 
)
static

Definition at line 2359 of file iphlpapi_main.c.

2360{
2361 IP_ADDR_STRING *pNext;
2363
2364 if (!Context->NumServers)
2365 {
2366 if (Context->uSizeAvailable >= Context->uSizeRequired)
2367 {
2368 WideCharToMultiByte(CP_ACP, 0, Server, -1, Context->pData->DnsServerList.IpAddress.String, 16, NULL, NULL);
2369 Context->pData->DnsServerList.IpAddress.String[15] = '\0';
2370 Context->pLastAddr = &Context->pData->DnsServerList;
2371 }
2372 }
2373 else
2374 {
2375 Context->uSizeRequired += sizeof(IP_ADDR_STRING);
2376 if (Context->uSizeAvailable >= Context->uSizeRequired)
2377 {
2378 pNext = (IP_ADDR_STRING*)(((char*)Context->pLastAddr) + sizeof(IP_ADDR_STRING));
2379 WideCharToMultiByte(CP_ACP, 0, Server, -1, pNext->IpAddress.String, 16, NULL, NULL);
2380 pNext->IpAddress.String[15] = '\0';
2381 Context->pLastAddr->Next = pNext;
2382 Context->pLastAddr = pNext;
2383 pNext->Next = NULL;
2384 }
2385 }
2386 Context->NumServers++;
2387}
#define CP_ACP
Definition: compat.h:109
#define WideCharToMultiByte
Definition: compat.h:111
struct _NAME_SERVER_LIST_CONTEXT * PNAME_SERVER_LIST_CONTEXT
struct _IP_ADDR_STRING IP_ADDR_STRING
static void Server(int port)
Definition: srltest.c:69
char String[4 *4]
Definition: iptypes.h:42
struct _IP_ADDR_STRING * Next
Definition: iptypes.h:46
IP_ADDRESS_STRING IpAddress
Definition: iptypes.h:47

Referenced by GetPerAdapterInfo().

◆ CreateProxyArpEntry()

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}
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100

◆ DeleteIPAddress()

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}
NTSTATUS deleteIpAddress(ULONG NteContext)

Referenced by DSReleaseIpAddressLease(), DSReleaseParams(), DSStaticRefreshParams(), INetCfgComponentControl_fnApplyRegistryChanges(), send_request(), and setup_adapter().

◆ DeleteIpForwardEntry()

DWORD WINAPI DeleteIpForwardEntry ( PMIB_IPFORWARDROW  pRoute)

Definition at line 573 of file iphlpapi_main.c.

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

Referenced by del_route(), DSReleaseIpAddressLease(), DSReleaseParams(), DSStaticRefreshParams(), INetCfgComponentControl_fnApplyRegistryChanges(), and setup_adapter().

◆ DeleteIpNetEntry()

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

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}

◆ DllMain()

BOOL WINAPI DllMain ( HINSTANCE  hinstDLL,
DWORD  fdwReason,
LPVOID  lpvReserved 
)

Definition at line 39 of file iphlpapi_main.c.

40{
41 switch (fdwReason) {
43 DisableThreadLibraryCalls( hinstDLL );
45 break;
46
49 break;
50 }
51 return TRUE;
52}
static DWORD const fdwReason
#define TRUE
Definition: types.h:120
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
#define DLL_PROCESS_DETACH
Definition: compat.h:130
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
void interfaceMapFree(void)
void interfaceMapInit(void)

◆ EnableRouter()

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

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

DWORD WINAPI GetAdapterIndex ( LPWSTR  AdapterName,
PULONG  IfIndex 
)

Definition at line 667 of file iphlpapi_main.c.

668{
669 TRACE("AdapterName %p, IfIndex %p\n", AdapterName, IfIndex);
670 FIXME(":stub\n");
671 /* marking Win2K+ functions not supported */
672 return ERROR_NOT_SUPPORTED;
673}
_Must_inspect_result_ _Out_ PNDIS_STATUS _Out_ PNDIS_STATUS _Out_ PNDIS_HANDLE _Out_ PUINT _In_ UINT _In_ NDIS_HANDLE _In_ NDIS_HANDLE _In_ PNDIS_STRING AdapterName
Definition: ndis.h:6016

◆ GetAdapterOrderMap()

PIP_ADAPTER_ORDER_MAP WINAPI GetAdapterOrderMap ( VOID  )

Definition at line 2975 of file iphlpapi_main.c.

2976{
2977 FIXME(":stub\n");
2978 return 0L;
2979}

◆ GetAdaptersInfo()

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)
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;
707 }
708 else {
710
711 if (table) {
712 size = sizeof(IP_ADAPTER_INFO) * table->numIndexes;
713 if (*pOutBufLen < size) {
714 *pOutBufLen = size;
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;
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) {
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];
766 ptr->IpAddressList.IpAddress.String);
768 ptr->IpAddressList.IpMask.String);
769 ptr->IpAddressList.Context = ptr->Index;
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
791 }
792 }
793 else
795 }
796 TRACE("returning %ld\n", ret);
797 return ret;
798}
ULONG WSAAPI inet_addr(IN CONST CHAR FAR *cp)
Definition: addrconv.c:71
#define INADDR_NONE
Definition: tcp.c:42
#define RegCloseKey(hKey)
Definition: registry.h:49
#define free
Definition: debug_ros.c:5
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define ERROR_SUCCESS
Definition: deptool.c:10
#define FALSE
Definition: types.h:117
LONG WINAPI RegOpenKeyA(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3234
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
DWORD getDhcpInfoForAdapter(DWORD AdapterIndex, PIP_ADAPTER_INFO ptr)
Definition: dhcp_reactos.c:12
unsigned int BOOL
Definition: ntddk_ex.h:94
FxAutoRegKey hKey
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLsizeiptr size
Definition: glext.h:5919
GLenum const GLvoid * addr
Definition: glext.h:9621
DWORD getInterfacePhysicalByIndex(DWORD index, PDWORD len, PBYTE addr, PDWORD type)
DWORD getNumNonLoopbackInterfaces(void)
DWORD getInterfaceMaskByIndex(DWORD index)
InterfaceIndexTable * getNonLoopbackInterfaceIndexTable(void)
const char * getInterfaceNameByIndex(DWORD index)
char * toIPAddressString(unsigned int addr, char string[16])
DWORD getInterfaceIPAddrByIndex(DWORD index)
void consumeInterfaceName(const char *ifname)
DWORD getInterfaceGatewayByIndex(DWORD index)
Definition: iphlpapi_main.c:72
#define MAX_ADAPTER_NAME_LENGTH
Definition: iptypes.h:27
struct _IP_ADAPTER_INFO IP_ADAPTER_INFO
if(dx< 0)
Definition: linetemp.h:194
#define INADDR_ANY
Definition: inet.h:80
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static PVOID ptr
Definition: dispmode.c:27
BYTE * PBYTE
Definition: pedump.c:66
strncpy
Definition: string.h:335
#define memset(x, y, z)
Definition: compat.h:39
uint32_t ULONG
Definition: typedefs.h:59
#define ERROR_BUFFER_OVERFLOW
Definition: winerror.h:185
#define ERROR_NO_DATA
Definition: winerror.h:284
#define HKEY_CURRENT_USER
Definition: winreg.h:11

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

◆ GetBestInterface()

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)
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}
DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
IF_INDEX dwForwardIfIndex
Definition: ipmib.h:75

◆ GetBestInterfaceEx()

DWORD WINAPI GetBestInterfaceEx ( struct sockaddr pDestAddr,
PDWORD  pdwBestIfIndex 
)

Definition at line 3191 of file iphlpapi_main.c.

3192{
3193 FIXME(":stub\n");
3194 return 0L;
3195}

◆ GetBestRoute()

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

Definition at line 841 of file iphlpapi_main.c.

842{
844 DWORD ret;
845
846 TRACE("dwDestAddr 0x%08lx, dwSourceAddr 0x%08lx, pBestRoute %p\n", dwDestAddr,
847 dwSourceAddr, pBestRoute);
848 if (!pBestRoute)
850
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));
873 }
874 else
876 TRACE("returning %ld\n", ret);
877 return ret;
878}
#define GetProcessHeap()
Definition: compat.h:736
unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask)
Definition: intrin_arm.h:57
DWORD WINAPI AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE *ppIpForwardTable, BOOL bOrder, HANDLE heap, DWORD flags)
#define ntohl(x)
Definition: module.h:205

Referenced by GetBestInterface().

◆ GetExtendedTcpTable()

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;
923
924 if (!pdwSize)
925 {
927 }
928
929 if (ulAf != AF_INET)
930 {
933 }
934
935 switch (TableClass)
936 {
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;
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
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
980 if (size > *pdwSize || !pTheirTcpTable)
981 {
982 *pdwSize = size;
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
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
1025 if (size > *pdwSize || !pTheirTcpTable)
1026 {
1027 *pdwSize = size;
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
1055 {
1057 PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1058
1059 if (pOurTcpTable)
1060 {
1062 if (size > *pdwSize || !pTheirTcpTable)
1063 {
1064 *pdwSize = size;
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,
1075 }
1076
1077 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1078 }
1079 }
1080 break;
1081
1083 {
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
1098 if (size > *pdwSize || !pTheirTcpTable)
1099 {
1100 *pdwSize = size;
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,
1121 }
1122
1123 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1124 }
1125 }
1126 break;
1127
1129 {
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
1144 if (size > *pdwSize || !pTheirTcpTable)
1145 {
1146 *pdwSize = size;
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,
1167 }
1168
1169 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1170 }
1171 }
1172 break;
1173
1175 {
1177 PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1178
1179 if (pOurTcpTable)
1180 {
1182 if (size > *pdwSize || !pTheirTcpTable)
1183 {
1184 *pdwSize = size;
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,
1195 }
1196
1197 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1198 }
1199 }
1200 break;
1201
1203 {
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
1218 if (size > *pdwSize || !pTheirTcpTable)
1219 {
1220 *pdwSize = size;
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,
1241 }
1242
1243 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1244 }
1245 }
1246 break;
1247
1249 {
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
1264 if (size > *pdwSize || !pTheirTcpTable)
1265 {
1266 *pdwSize = size;
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,
1287 }
1288
1289 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1290 }
1291 }
1292 break;
1293
1294 default:
1296 break;
1297 }
1298
1299 return ret;
1300}
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15
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 *))
#define AF_INET
Definition: tcpip.h:117
GLuint GLuint GLsizei count
Definition: gl.h:1545
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
static int TcpTableSorter(const void *a, const void *b)
@ TCP_TABLE_OWNER_MODULE_CONNECTIONS
Definition: iprtrmib.h:37
@ TCP_TABLE_BASIC_CONNECTIONS
Definition: iprtrmib.h:31
@ TCP_TABLE_BASIC_LISTENER
Definition: iprtrmib.h:30
@ TCP_TABLE_OWNER_MODULE_ALL
Definition: iprtrmib.h:38
@ TCP_TABLE_OWNER_PID_LISTENER
Definition: iprtrmib.h:33
@ TCP_TABLE_BASIC_ALL
Definition: iprtrmib.h:32
@ TCP_TABLE_OWNER_PID_CONNECTIONS
Definition: iprtrmib.h:34
@ TCP_TABLE_OWNER_MODULE_LISTENER
Definition: iprtrmib.h:36
PVOID getTcpTable(CLASS_TABLE Class)
@ ClassModulePid
Definition: ipstats.h:81
@ ClassBasic
Definition: ipstats.h:80
@ ClassModule
Definition: ipstats.h:82
#define ASSERT(a)
Definition: mode.c:44
MIB_TCP_STATE State
Definition: tcpmib.h:56
MIB_TCPROW_OWNER_MODULE table[1]
Definition: tcpmib.h:133
MIB_TCPROW_OWNER_PID table[1]
Definition: tcpmib.h:115
DWORD dwNumEntries
Definition: tcpmib.h:66
MIB_TCPROW table[1]
Definition: tcpmib.h:67
struct _MIB_TCPROW MIB_TCPROW
struct _MIB_TCPROW_OWNER_PID MIB_TCPROW_OWNER_PID
@ MIB_TCP_STATE_LISTEN
Definition: tcpmib.h:29
struct _MIB_TCPROW_OWNER_MODULE MIB_TCPROW_OWNER_MODULE
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255

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

◆ GetExtendedUdpTable()

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 {
1343 }
1344
1345 if (ulAf != AF_INET)
1346 {
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;
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
1381 {
1383 PMIB_UDPTABLE_OWNER_PID pTheirUdpTable = pUdpTable;
1384
1385 if (pOurUdpTable)
1386 {
1388 if (size > *pdwSize || !pTheirUdpTable)
1389 {
1390 *pdwSize = size;
1392 }
1393 else
1394 {
1395 memcpy(pTheirUdpTable, pOurUdpTable, size);
1396
1397 if (bOrder)
1398 qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1400 }
1401
1402 HeapFree(GetProcessHeap(), 0, pOurUdpTable);
1403 }
1404 }
1405 break;
1406
1408 {
1410 PMIB_UDPTABLE_OWNER_MODULE pTheirUdpTable = pUdpTable;
1411
1412 if (pOurUdpTable)
1413 {
1415 if (size > *pdwSize || !pTheirUdpTable)
1416 {
1417 *pdwSize = size;
1419 }
1420 else
1421 {
1422 memcpy(pTheirUdpTable, pOurUdpTable, size);
1423
1424 if (bOrder)
1425 qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1427 }
1428
1429 HeapFree(GetProcessHeap(), 0, pOurUdpTable);
1430 }
1431 }
1432 break;
1433
1434 default:
1436 break;
1437 }
1438
1439 return ret;
1440}
static int UdpTableSorter(const void *a, const void *b)
@ UDP_TABLE_BASIC
Definition: iprtrmib.h:43
@ UDP_TABLE_OWNER_MODULE
Definition: iprtrmib.h:45
PVOID getUdpTable(CLASS_TABLE Class)
MIB_UDPROW_OWNER_MODULE table[1]
Definition: udpmib.h:71
MIB_UDPROW_OWNER_PID table[1]
Definition: udpmib.h:48
DWORD dwNumEntries
Definition: udpmib.h:34
MIB_UDPROW table[1]
Definition: udpmib.h:35
struct _MIB_UDPROW_OWNER_MODULE MIB_UDPROW_OWNER_MODULE
struct _MIB_UDPROW_OWNER_PID MIB_UDPROW_OWNER_PID
struct _MIB_UDPROW MIB_UDPROW

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

◆ GetFriendlyIfIndex()

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

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}
DWORD getICMPStats(MIB_ICMP *stats)

Referenced by mib2IcmpInit(), and ShowIcmpStatistics().

◆ GetIcmpStatisticsEx()

DWORD WINAPI GetIcmpStatisticsEx ( PMIB_ICMP_EX  pStats,
DWORD  dwFamily 
)

Definition at line 3209 of file iphlpapi_main.c.

3210{
3211 FIXME(":stub\n");
3212
3213 if (!pStats)
3215
3216 if (dwFamily != AF_INET && dwFamily != AF_INET6)
3218
3219 return 0L;
3220}
#define AF_INET6
Definition: winsock.h:369

◆ GetIfEntry()

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)
1499
1501 if (name) {
1502 ret = getInterfaceEntryByIndex(pIfRow->dwIndex, pIfRow);
1503 if (ret == NO_ERROR)
1504 ret = getInterfaceStatsByName(name, pIfRow);
1506 }
1507 else
1509 TRACE("returning %ld\n", ret);
1510 return ret;
1511}
DWORD getInterfaceEntryByIndex(DWORD index, PMIB_IFROW entry)
DWORD getInterfaceStatsByName(const char *name, PMIB_IFROW entry)
DWORD dwIndex
Definition: ifmib.h:38
Definition: name.c:39
#define ERROR_INVALID_DATA
Definition: winerror.h:116

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

◆ GetIfTable()

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)
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;
1554 }
1555 else {
1557
1558 if (table) {
1559 size = sizeof(MIB_IFTABLE) + (table->numIndexes - 1) *
1560 sizeof(MIB_IFROW);
1561 if (*pdwSize < size) {
1562 *pdwSize = size;
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),
1577 ret = NO_ERROR;
1578 }
1579 free(table);
1580 }
1581 else
1583 }
1584 }
1585 TRACE("returning %ld\n", ret);
1586 return ret;
1587}
DWORD getNumInterfaces(void)
InterfaceIndexTable * getInterfaceIndexTable(void)
struct _MIB_IFTABLE MIB_IFTABLE
struct _MIB_IFROW MIB_IFROW
DWORD WINAPI GetIfEntry(PMIB_IFROW pIfRow)
static int IfTableSorter(const void *a, const void *b)
MIB_IFROW table[1]
Definition: ifmib.h:66
DWORD dwNumEntries
Definition: ifmib.h:65

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

◆ getInterfaceGatewayByIndex()

DWORD getInterfaceGatewayByIndex ( DWORD  index)

Definition at line 72 of file iphlpapi_main.c.

73{
74 DWORD ndx, retVal = 0, numRoutes = getNumRoutes();
76 if (!table) return 0;
77
78 for (ndx = 0; ndx < numRoutes; ndx++)
79 {
80 if ((table->routes[ndx].ifIndex == (index)) && (table->routes[ndx].dest == 0))
81 retVal = table->routes[ndx].gateway;
82 }
84 return retVal;
85}
GLuint index
Definition: glext.h:6031
RouteTable * getRouteTable(void)
DWORD getNumRoutes(void)

Referenced by GetAdaptersInfo().

◆ GetInterfaceInfo()

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)
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;
1617 }
1618 else {
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;
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;
1647 pIfTable->NumAdapters++;
1648 }
1649 ret = NO_ERROR;
1650 }
1651 free(table);
1652 }
1653 else
1655 }
1656 }
1657 TRACE("returning %ld\n", ret);
1658 return ret;
1659}
wcscpy
#define MAX_ADAPTER_NAME
Definition: ipexport.h:143
struct _IP_ADAPTER_INDEX_MAP IP_ADAPTER_INDEX_MAP
struct _IP_INTERFACE_INFO IP_INTERFACE_INFO
WCHAR Name[MAX_ADAPTER_NAME]
Definition: ipexport.h:147
IP_ADAPTER_INDEX_MAP Adapter[1]
Definition: ipexport.h:152
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by OpenAdapterHandle(), and test_GetInterfaceName().

◆ GetInterfaceNameInternal()

DWORD GetInterfaceNameInternal ( _In_ const GUID pInterfaceGUID,
_Out_writes_bytes_to_ *, *pOutBufLen PWCHAR  pInterfaceName,
_Inout_ PULONG  pOutBufLen 
)

Definition at line 3229 of file iphlpapi_main.c.

3232{
3234 DWORD result, type;
3235 WCHAR szKeyName[2*MAX_PATH];
3236 HRESULT hr;
3237 HKEY hKey;
3238
3239 if (pInterfaceGUID == NULL || pOutBufLen == NULL)
3241
3242 result = RtlStringFromGUID(pInterfaceGUID, &GuidString);
3243
3244 if (!NT_SUCCESS(result))
3245 {
3246 // failed to convert guid to string
3248 }
3249
3250 hr = StringCbPrintfW(szKeyName, sizeof(szKeyName), L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection", GuidString.Buffer);
3252
3253 if (FAILED(hr))
3254 {
3255 // key name is too long
3256 return ERROR_BUFFER_OVERFLOW;
3257 }
3258
3260
3261 if (result != ERROR_SUCCESS)
3262 {
3263 // failed to find adapter entry
3264 return ERROR_NOT_FOUND;
3265 }
3266
3267 result = RegQueryValueExW(hKey, L"Name", NULL, &type, (PVOID)pInterfaceName, pOutBufLen);
3268
3270
3271 if (result == ERROR_MORE_DATA)
3272 {
3273 *pOutBufLen = MAX_INTERFACE_NAME_LEN * 2;
3275 }
3276
3277 if (result != ERROR_SUCCESS || type != REG_SZ)
3278 {
3279 // failed to read adapter name
3280 return ERROR_NO_DATA;
3281 }
3282 return ERROR_SUCCESS;
3283}
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
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
#define MAX_PATH
Definition: compat.h:34
GLuint64EXT * result
Definition: glext.h:11304
#define MAX_INTERFACE_NAME_LEN
Definition: ifmib.h:31
NTSYSAPI NTSTATUS WINAPI RtlStringFromGUID(REFGUID, PUNICODE_STRING)
#define FAILED(hr)
Definition: intsafe.h:51
#define REG_SZ
Definition: layer.c:22
static PWSTR GuidString
Definition: apphelp.c:93
#define KEY_READ
Definition: nt_native.h:1023
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
HRESULT hr
Definition: shlfolder.c:183
STRSAFEAPI StringCbPrintfW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:557
#define ERROR_NOT_FOUND
Definition: winerror.h:690
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12

Referenced by NhGetInterfaceNameFromDeviceGuid(), and NhGetInterfaceNameFromGuid().

◆ GetIpAddrTable()

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)
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;
1701 }
1702 else {
1704
1705 if (table) {
1706 size = sizeof(MIB_IPADDRTABLE) + (table->numIndexes - 1) *
1707 sizeof(MIB_IPADDRROW);
1708 if (*pdwSize < size) {
1709 *pdwSize = size;
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,
1738 ret = NO_ERROR;
1739 }
1740 free(table);
1741 }
1742 else
1744 }
1745 }
1746 TRACE("returning %ld\n", ret);
1747 return ret;
1748}
DWORD getInterfaceBCastAddrByIndex(DWORD index)
static int IpAddrTableSorter(const void *a, const void *b)
struct _MIB_IPADDRROW MIB_IPADDRROW
struct _MIB_IPADDRTABLE MIB_IPADDRTABLE
unsigned short unused1
Definition: ipmib.h:41
DWORD dwReasmSize
Definition: ipmib.h:40
DWORD dwBCastAddr
Definition: ipmib.h:39
DWORD dwMask
Definition: ipmib.h:38
DWORD dwAddr
Definition: ipmib.h:36
IF_INDEX dwIndex
Definition: ipmib.h:37
unsigned short wType
Definition: ipmib.h:42
MIB_IPADDRROW table[1]
Definition: ipmib.h:48
DWORD dwNumEntries
Definition: ipmib.h:47

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

◆ GetIpErrorString()

DWORD WINAPI GetIpErrorString ( IP_STATUS  ErrorCode,
PWCHAR  Buffer,
PDWORD  Size 
)

Definition at line 2965 of file iphlpapi_main.c.

2966{
2967 FIXME(":stub\n");
2968 return 0L;
2969}

◆ GetIpForwardTable()

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)
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;
1801 }
1802 else {
1804 if (table) {
1805 sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (table->numRoutes - 1) *
1806 sizeof(MIB_IPFORWARDROW);
1807 if (*pdwSize < sizeNeeded) {
1808 *pdwSize = sizeNeeded;
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,
1845 ret = NO_ERROR;
1846 }
1848 }
1849 else
1851 }
1852 }
1853 TRACE("returning %ld\n", ret);
1854 return ret;
1855}
static int IpForwardTableSorter(const void *a, const void *b)
@ MIB_IPROUTE_TYPE_DIRECT
Definition: ipmib.h:63
struct _MIB_IPFORWARDTABLE MIB_IPFORWARDTABLE
struct _MIB_IPFORWARDROW MIB_IPFORWARDROW
DWORD dwForwardMetric5
Definition: ipmib.h:92
DWORD dwForwardNextHop
Definition: ipmib.h:74
DWORD dwForwardMetric2
Definition: ipmib.h:89
DWORD dwForwardPolicy
Definition: ipmib.h:73
DWORD dwForwardMetric3
Definition: ipmib.h:90
DWORD dwForwardProto
Definition: ipmib.h:83
DWORD dwForwardMetric1
Definition: ipmib.h:88
DWORD dwForwardNextHopAS
Definition: ipmib.h:87
DWORD dwForwardDest
Definition: ipmib.h:71
DWORD dwForwardMask
Definition: ipmib.h:72
DWORD dwForwardMetric4
Definition: ipmib.h:91
DWORD dwForwardAge
Definition: ipmib.h:86
DWORD dwForwardType
Definition: ipmib.h:78
DWORD dwNumEntries
Definition: ipmib.h:97
MIB_IPFORWARDROW table[1]
Definition: ipmib.h:98

Referenced by AllocateAndGetIpForwardTableFromStack(), fill_ip4routetable(), INetCfgComponentControl_fnApplyRegistryChanges(), mib2IpRouteInit(), and PrintRoutes().

◆ GetIpNetTable()

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)
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;
1898 }
1899 else {
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;
1908 }
1909 else {
1910 *pdwSize = size;
1911 memcpy(pIpNetTable, table, size);
1912 if (bOrder)
1913 qsort(pIpNetTable->table, pIpNetTable->dwNumEntries,
1915 ret = NO_ERROR;
1916 }
1918 }
1919 }
1920 }
1921 TRACE("returning %d\n", ret);
1922 return ret;
1923}
static int IpNetTableSorter(const void *a, const void *b)
struct _MIB_IPNETTABLE MIB_IPNETTABLE
DWORD getNumArpEntries(void)
PMIB_IPNETTABLE getArpTable(void)
DWORD dwNumEntries
Definition: ipmib.h:127
MIB_IPNETROW table[1]
Definition: ipmib.h:128

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

◆ GetIpStatistics()

DWORD WINAPI GetIpStatistics ( PMIB_IPSTATS  pStats)

Definition at line 1935 of file iphlpapi_main.c.

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

Referenced by mib2IpStatsInit(), and ShowIpStatistics().

◆ GetIpStatisticsEx()

DWORD WINAPI GetIpStatisticsEx ( PMIB_IPSTATS  pStats,
DWORD  dwFamily 
)

Definition at line 1950 of file iphlpapi_main.c.

1951{
1952 DWORD ret;
1953
1954 TRACE("pStats %p\n", pStats);
1955 ret = getIPStats(pStats, dwFamily);
1956 TRACE("returning %ld\n", ret);
1957 return ret;
1958}
DWORD getIPStats(PMIB_IPSTATS stats, DWORD family)

Referenced by GetIpStatistics().

◆ GetNetworkParams()

DWORD WINAPI GetNetworkParams ( PFIXED_INFO  pFixedInfo,
PULONG  pOutBufLen 
)

Definition at line 1970 of file iphlpapi_main.c.

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

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

◆ GetNumberOfInterfaces()

DWORD WINAPI GetNumberOfInterfaces ( PDWORD  pdwNumIf)

Definition at line 2118 of file iphlpapi_main.c.

2119{
2120 DWORD ret;
2121
2122 TRACE("pdwNumIf %p\n", pdwNumIf);
2123 if (!pdwNumIf)
2125 else {
2126 *pdwNumIf = getNumInterfaces();
2127 ret = NO_ERROR;
2128 }
2129 TRACE("returning %ld\n", ret);
2130 return ret;
2131}

Referenced by _RpcEnumInterfaces().

◆ GetOwnerModuleFromPidEntry()

static DWORD GetOwnerModuleFromPidEntry ( DWORD  OwningPid,
TCPIP_OWNER_MODULE_INFO_CLASS  Class,
PVOID  Buffer,
PDWORD  pdwSize 
)
static

Definition at line 2134 of file iphlpapi_main.c.

2135{
2137 DWORD FileLen, PathLen, Error;
2140
2141 if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
2142 IsBadWritePtr(Buffer, *pdwSize))
2143 {
2145 }
2146
2147 if (OwningPid == 0)
2148 {
2149 return ERROR_NOT_FOUND;
2150 }
2151
2153 if (Process == NULL)
2154 {
2155 return GetLastError();
2156 }
2157
2159 if (FileLen != 0)
2160 {
2162 if (PathLen == 0)
2163 {
2165 return GetLastError();
2166 }
2167
2168 /* Add NULL char */
2169 ++FileLen;
2170 ++PathLen;
2171 PathLen *= sizeof(WCHAR);
2172 FileLen *= sizeof(WCHAR);
2173 }
2174 else
2175 {
2176 Error = GetLastError();
2177
2179 {
2180 wcscpy(File, L"System");
2181 wcscpy(Path, L"System");
2182
2183 PathLen = sizeof(L"System");
2184 FileLen = sizeof(L"System");
2185 }
2186 else
2187 {
2189 return Error;
2190 }
2191 }
2192
2194
2195 if (*pdwSize < sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen)
2196 {
2197 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen;
2199 }
2200
2201 BasicInfo = Buffer;
2202 BasicInfo->pModuleName = (PVOID)((ULONG_PTR)BasicInfo + sizeof(TCPIP_OWNER_MODULE_BASIC_INFO));
2203 BasicInfo->pModulePath = (PVOID)((ULONG_PTR)BasicInfo->pModuleName + FileLen);
2204 wcscpy(BasicInfo->pModuleName, File);
2205 wcscpy(BasicInfo->pModulePath, Path);
2206 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen;
2207
2208 return NO_ERROR;
2209}
PRTL_UNICODE_STRING_BUFFER Path
BOOL Error
Definition: chkdsk.c:66
Definition: bufpool.h:45
Definition: File.h:16
#define CloseHandle
Definition: compat.h:739
#define GetModuleFileNameExW(w, x, y, z)
Definition: compat.h:922
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
Definition: except.c:883
HANDLE WINAPI OpenProcess(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
Definition: proc.c:1227
DWORD WINAPI GetModuleBaseNameW(HANDLE hProcess, HMODULE hModule, LPWSTR lpBaseName, DWORD nSize)
Definition: psapi.c:853
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
#define PROCESS_VM_READ
Definition: pstypes.h:162
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:167
struct _TCPIP_OWNER_MODULE_BASIC_INFO TCPIP_OWNER_MODULE_BASIC_INFO
void * PVOID
Definition: typedefs.h:50
uint32_t ULONG_PTR
Definition: typedefs.h:65
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define ERROR_PARTIAL_COPY
Definition: winerror.h:303

Referenced by GetOwnerModuleFromTcpEntry(), and GetOwnerModuleFromUdpEntry().

◆ GetOwnerModuleFromTagEntry()

static DWORD GetOwnerModuleFromTagEntry ( DWORD  OwningPid,
DWORD  OwningTag,
TCPIP_OWNER_MODULE_INFO_CLASS  Class,
PVOID  Buffer,
PDWORD  pdwSize 
)
static

Definition at line 2211 of file iphlpapi_main.c.

2212{
2213 UINT Size;
2214 HRESULT Res;
2215 HANDLE hAdvapi32;
2216 WCHAR SysDir[MAX_PATH];
2218 ULONG (NTAPI *_I_QueryTagInformation)(PVOID, DWORD, PVOID);
2219 struct
2220 {
2223 DWORD TagType;
2224 PWSTR Buffer;
2225 } ServiceQuery;
2226
2227 if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
2228 IsBadWritePtr(Buffer, *pdwSize))
2229 {
2231 }
2232
2233 /* First, secure (avoid injections) load advapi32.dll */
2235 if (Size == 0)
2236 {
2237 return GetLastError();
2238 }
2239
2240 Res = StringCchCatW(&SysDir[Size], MAX_PATH - Size, L"\\advapi32.dll");
2241 if (FAILED(Res))
2242 {
2243 return Res;
2244 }
2245
2246 hAdvapi32 = GetModuleHandleW(SysDir);
2247 if (hAdvapi32 == NULL)
2248 {
2249 return GetLastError();
2250 }
2251
2252 /* Now, we'll query the service associated with the tag */
2253 _I_QueryTagInformation = (PVOID)GetProcAddress(hAdvapi32, "I_QueryTagInformation");
2254 if (_I_QueryTagInformation == NULL)
2255 {
2256 return GetLastError();
2257 }
2258
2259 /* Set tag and PID for the query */
2260 ServiceQuery.ProcessId = OwningPid;
2261 ServiceQuery.ServiceTag = OwningTag;
2262 ServiceQuery.TagType = 0;
2263 ServiceQuery.Buffer = NULL;
2264
2265 /* And query */
2266 Res = _I_QueryTagInformation(NULL, 1, &ServiceQuery);
2267 if (Res != ERROR_SUCCESS)
2268 {
2269 return Res;
2270 }
2271
2272 /* Compute service name length */
2273 Size = wcslen(ServiceQuery.Buffer) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
2274
2275 /* We'll copy it twice, so make sure we have enough room */
2276 if (*pdwSize < sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size)
2277 {
2278 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size;
2279 LocalFree(ServiceQuery.Buffer);
2281 }
2282
2283 /* Copy back data */
2284 BasicInfo = Buffer;
2285 BasicInfo->pModuleName = (PVOID)((ULONG_PTR)BasicInfo + sizeof(TCPIP_OWNER_MODULE_BASIC_INFO));
2286 BasicInfo->pModulePath = (PVOID)((ULONG_PTR)BasicInfo->pModuleName + Size);
2287 wcscpy(BasicInfo->pModuleName, ServiceQuery.Buffer);
2288 wcscpy(BasicInfo->pModulePath, ServiceQuery.Buffer);
2289 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size;
2290 LocalFree(ServiceQuery.Buffer);
2291
2292 return NO_ERROR;
2293}
static DWORD ServiceTag
Definition: database.c:34
#define GetProcAddress(x, y)
Definition: compat.h:753
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:838
UINT WINAPI GetSystemDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2313
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ProcessId
Definition: fatprocs.h:2712
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
unsigned int UINT
Definition: ndis.h:50
#define DWORD
Definition: nt_native.h:44
#define UNICODE_NULL
STRSAFEAPI StringCchCatW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:325
uint16_t * PWSTR
Definition: typedefs.h:56
#define NTAPI
Definition: typedefs.h:36
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533

Referenced by GetOwnerModuleFromTcpEntry(), and GetOwnerModuleFromUdpEntry().

◆ GetOwnerModuleFromTcpEntry()

DWORD WINAPI GetOwnerModuleFromTcpEntry ( PMIB_TCPROW_OWNER_MODULE  pTcpEntry,
TCPIP_OWNER_MODULE_INFO_CLASS  Class,
PVOID  Buffer,
PDWORD  pdwSize 
)

Definition at line 2314 of file iphlpapi_main.c.

2315{
2316 /* If we have a service tag, that's a service connection */
2317 if (pTcpEntry->OwningModuleInfo[0] != 0)
2318 {
2319 return GetOwnerModuleFromTagEntry(pTcpEntry->dwOwningPid, (DWORD)(pTcpEntry->OwningModuleInfo[0]), Class, Buffer, pdwSize);
2320 }
2321 else
2322 {
2323 return GetOwnerModuleFromPidEntry(pTcpEntry->dwOwningPid, Class, Buffer, pdwSize);
2324 }
2325}
static DWORD GetOwnerModuleFromPidEntry(DWORD OwningPid, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
static DWORD GetOwnerModuleFromTagEntry(DWORD OwningPid, DWORD OwningTag, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]
Definition: tcpmib.h:127

Referenced by START_TEST(), and test_tcp().

◆ GetOwnerModuleFromUdpEntry()

DWORD WINAPI GetOwnerModuleFromUdpEntry ( PMIB_UDPROW_OWNER_MODULE  pUdpEntry,
TCPIP_OWNER_MODULE_INFO_CLASS  Class,
PVOID  Buffer,
PDWORD  pdwSize 
)

Definition at line 2346 of file iphlpapi_main.c.

2347{
2348 /* If we have a service tag, that's a service connection */
2349 if (pUdpEntry->OwningModuleInfo[0] != 0)
2350 {
2351 return GetOwnerModuleFromTagEntry(pUdpEntry->dwOwningPid, (DWORD)(pUdpEntry->OwningModuleInfo[0]), Class, Buffer, pdwSize);
2352 }
2353 else
2354 {
2355 return GetOwnerModuleFromPidEntry(pUdpEntry->dwOwningPid, Class, Buffer, pdwSize);
2356 }
2357}
ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]
Definition: udpmib.h:65

Referenced by START_TEST(), and test_udp().

◆ GetPerAdapterInfo()

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

Definition at line 2400 of file iphlpapi_main.c.

2401{
2402 HKEY hkey;
2403 DWORD dwSize = 0;
2404 const char *ifName;
2406 WCHAR keyname[200] = L"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\";
2407
2408 if (!pOutBufLen)
2410
2411 if (!pPerAdapterInfo || *pOutBufLen < sizeof(IP_PER_ADAPTER_INFO))
2412 {
2413 *pOutBufLen = sizeof(IP_PER_ADAPTER_INFO);
2414 return ERROR_BUFFER_OVERFLOW;
2415 }
2416
2417 ifName = getInterfaceNameByIndex(IfIndex);
2418 if (!ifName)
2420
2421 MultiByteToWideChar(CP_ACP, 0, ifName, -1, &keyname[62], sizeof(keyname)/sizeof(WCHAR) - 63);
2422 HeapFree(GetProcessHeap(), 0, (LPVOID)ifName);
2423
2424 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keyname, 0, KEY_READ, &hkey) != ERROR_SUCCESS)
2425 {
2426 return ERROR_NOT_SUPPORTED;
2427 }
2428 Context.NumServers = 0;
2429 Context.uSizeAvailable = *pOutBufLen;
2430 Context.uSizeRequired = sizeof(IP_PER_ADAPTER_INFO);
2431 Context.pData = pPerAdapterInfo;
2432
2433 if (*pOutBufLen >= sizeof(IP_PER_ADAPTER_INFO))
2434 ZeroMemory(pPerAdapterInfo, sizeof(IP_PER_ADAPTER_INFO));
2435
2437
2438 if (Context.uSizeRequired > Context.uSizeAvailable)
2439 {
2440 *pOutBufLen = Context.uSizeRequired;
2441 RegCloseKey(hkey);
2442 return ERROR_BUFFER_OVERFLOW;
2443 }
2444
2445 if(RegQueryValueExW(hkey, L"NameServer", NULL, NULL, NULL, &dwSize) == ERROR_SUCCESS)
2446 {
2447 pPerAdapterInfo->AutoconfigActive = FALSE;
2448 }
2449 else
2450 {
2451 pPerAdapterInfo->AutoconfigActive = TRUE;
2452 }
2453
2454 RegCloseKey(hkey);
2455 return NOERROR;
2456}
#define MultiByteToWideChar
Definition: compat.h:110
static void CreateNameServerListEnumNamesFunc(PWCHAR Interface, PWCHAR Server, PVOID Data)
LSTATUS EnumNameServers(HKEY RegHandle, LPWSTR Interface, PVOID Data, EnumNameServersFunc cb)
struct _IP_PER_ADAPTER_INFO IP_PER_ADAPTER_INFO
#define ZeroMemory
Definition: winbase.h:1743
#define NOERROR
Definition: winerror.h:2354

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

◆ GetRTTAndHopCount()

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

Definition at line 2471 of file iphlpapi_main.c.

2472{
2473 TRACE("DestIpAddress 0x%08lx, HopCount %p, MaxHops %ld, RTT %p\n",
2474 DestIpAddress, HopCount, MaxHops, RTT);
2475 FIXME(":stub\n");
2476 return (BOOL) 0;
2477}

◆ GetTcpStatistics()

DWORD WINAPI GetTcpStatistics ( PMIB_TCPSTATS  pStats)

Definition at line 2509 of file iphlpapi_main.c.

2510{
2511 return GetTcpStatisticsEx(pStats, PF_INET);
2512}
DWORD WINAPI GetTcpStatisticsEx(PMIB_TCPSTATS pStats, DWORD dwFamily)

Referenced by mib2TcpInit(), and ShowTcpStatistics().

◆ GetTcpStatisticsEx()

DWORD WINAPI GetTcpStatisticsEx ( PMIB_TCPSTATS  pStats,
DWORD  dwFamily 
)

Definition at line 2490 of file iphlpapi_main.c.

2491{
2492 DWORD ret;
2493
2494 TRACE("pStats %p\n", pStats);
2495 ret = getTCPStats(pStats, dwFamily);
2496 TRACE("returning %ld\n", ret);
2497 return ret;
2498}
DWORD getTCPStats(MIB_TCPSTATS *stats, DWORD family)

Referenced by GetTcpStatistics().

◆ GetTcpTable()

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

Definition at line 2537 of file iphlpapi_main.c.

2538{
2539 return GetExtendedTcpTable(pTcpTable, pdwSize, bOrder, AF_INET, TCP_TABLE_BASIC_ALL, 0);
2540}

Referenced by AllocateAndGetTcpTableFromStack().

◆ GetUdpStatistics()

DWORD WINAPI GetUdpStatistics ( PMIB_UDPSTATS  pStats)

Definition at line 2572 of file iphlpapi_main.c.

2573{
2574 return GetUdpStatisticsEx(pStats, PF_INET);
2575}
DWORD WINAPI GetUdpStatisticsEx(PMIB_UDPSTATS pStats, DWORD dwFamily)

Referenced by mib2UdpInit(), and ShowUdpStatistics().

◆ GetUdpStatisticsEx()

DWORD WINAPI GetUdpStatisticsEx ( PMIB_UDPSTATS  pStats,
DWORD  dwFamily 
)

Definition at line 2553 of file iphlpapi_main.c.

2554{
2555 DWORD ret;
2556
2557 TRACE("pStats %p\n", pStats);
2558 ret = getUDPStats(pStats, dwFamily);
2559 TRACE("returning %ld\n", ret);
2560 return ret;
2561}
DWORD getUDPStats(MIB_UDPSTATS *stats, DWORD family)

Referenced by GetUdpStatistics().

◆ GetUdpTable()

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

Definition at line 2589 of file iphlpapi_main.c.

2590{
2591 return GetExtendedUdpTable(pUdpTable, pdwSize, bOrder, AF_INET, UDP_TABLE_BASIC, 0);
2592}

Referenced by AllocateAndGetUdpTableFromStack(), and mib2UdpEntryInit().

◆ GetUniDirectionalAdapterInfo()

DWORD WINAPI GetUniDirectionalAdapterInfo ( PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS  pIPIfInfo,
PULONG  dwOutBufLen 
)

Definition at line 2613 of file iphlpapi_main.c.

2614{
2615 TRACE("pIPIfInfo %p, dwOutBufLen %p\n", pIPIfInfo, dwOutBufLen);
2616 /* a unidirectional adapter?? not bloody likely! */
2617 return ERROR_NOT_SUPPORTED;
2618}

◆ IfTableSorter()

static int IfTableSorter ( const void a,
const void b 
)
static

Definition at line 1514 of file iphlpapi_main.c.

1515{
1516 int ret;
1517
1518 if (a && b)
1519 ret = ((PMIB_IFROW)a)->dwIndex - ((PMIB_IFROW)b)->dwIndex;
1520 else
1521 ret = 0;
1522 return ret;
1523}
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
struct _MIB_IFROW * PMIB_IFROW

Referenced by GetIfTable().

◆ IpAddrTableSorter()

static int IpAddrTableSorter ( const void a,
const void b 
)
static

Definition at line 1662 of file iphlpapi_main.c.

1663{
1664 int ret;
1665
1666 if (a && b)
1667 ret = ((PMIB_IPADDRROW)a)->dwAddr - ((PMIB_IPADDRROW)b)->dwAddr;
1668 else
1669 ret = 0;
1670 return ret;
1671}
struct _MIB_IPADDRROW * PMIB_IPADDRROW

Referenced by GetIpAddrTable().

◆ IpForwardTableSorter()

static int IpForwardTableSorter ( const void a,
const void b 
)
static

Definition at line 1751 of file iphlpapi_main.c.

1752{
1753 int ret;
1754
1755 if (a && b) {
1757
1758 ret = rowA->dwForwardDest - rowB->dwForwardDest;
1759 if (ret == 0) {
1760 ret = rowA->dwForwardProto - rowB->dwForwardProto;
1761 if (ret == 0) {
1762 ret = rowA->dwForwardPolicy - rowB->dwForwardPolicy;
1763 if (ret == 0)
1764 ret = rowA->dwForwardNextHop - rowB->dwForwardNextHop;
1765 }
1766 }
1767 }
1768 else
1769 ret = 0;
1770 return ret;
1771}
struct _MIB_IPFORWARDROW * PMIB_IPFORWARDROW
#define b
Definition: ke_i.h:79

Referenced by GetIpForwardTable().

◆ IpNetTableSorter()

static int IpNetTableSorter ( const void a,
const void b 
)
static

Definition at line 1858 of file iphlpapi_main.c.

1859{
1860 int ret;
1861
1862 if (a && b)
1863 ret = ((PMIB_IPNETROW)a)->dwAddr - ((PMIB_IPNETROW)b)->dwAddr;
1864 else
1865 ret = 0;
1866 return ret;
1867}
struct _MIB_IPNETROW * PMIB_IPNETROW

Referenced by GetIpNetTable().

◆ IpReleaseAddress()

DWORD WINAPI IpReleaseAddress ( PIP_ADAPTER_INDEX_MAP  AdapterInfo)

Definition at line 2633 of file iphlpapi_main.c.

2634{
2635 DWORD Status, Version = 0;
2636
2637 if (!AdapterInfo)
2639
2640 /* Maybe we should do this in DllMain */
2642 return ERROR_PROC_NOT_FOUND;
2643
2644 if (DhcpReleaseIpAddressLease(AdapterInfo->Index))
2646 else
2648
2650
2651 return Status;
2652}
void WINAPI DhcpCApiCleanup(void)
Definition: dhcpcsvc.c:71
DWORD APIENTRY DhcpCApiInitialize(LPDWORD Version)
Definition: dhcpcsvc.c:26
DWORD APIENTRY DhcpReleaseIpAddressLease(DWORD AdapterIndex)
Definition: dhcpcsvc.c:202
Status
Definition: gdiplustypes.h:25
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE _In_ USHORT _In_ USHORT Version
Definition: wdffdo.h:469
#define ERROR_PROC_NOT_FOUND
Definition: winerror.h:199

Referenced by Release(), and WlanDisconnect().

◆ IpRenewAddress()

DWORD WINAPI IpRenewAddress ( PIP_ADAPTER_INDEX_MAP  AdapterInfo)

Definition at line 2667 of file iphlpapi_main.c.

2668{
2669 DWORD Status, Version = 0;
2670
2671 if (!AdapterInfo)
2673
2674 /* Maybe we should do this in DllMain */
2676 return ERROR_PROC_NOT_FOUND;
2677
2678 if (DhcpRenewIpAddressLease(AdapterInfo->Index))
2680 else
2682
2684
2685 return Status;
2686}
DWORD APIENTRY DhcpRenewIpAddressLease(DWORD AdapterIndex)
Definition: dhcpcsvc.c:228

Referenced by Renew().

◆ NhGetInterfaceNameFromDeviceGuid()

DWORD WINAPI NhGetInterfaceNameFromDeviceGuid ( _In_ const GUID pInterfaceGUID,
_Out_writes_bytes_to_ *, *pOutBufLen PWCHAR  pInterfaceName,
_Inout_ PULONG  pOutBufLen,
DWORD  dwUnknown4,
DWORD  dwUnknown5 
)

Definition at line 3286 of file iphlpapi_main.c.

3291{
3293
3294 if (pInterfaceName == NULL)
3296
3297 return GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
3298}
#define SetLastError(x)
Definition: compat.h:752
DWORD GetInterfaceNameInternal(_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen)

◆ NhGetInterfaceNameFromGuid()

DWORD WINAPI NhGetInterfaceNameFromGuid ( _In_ const GUID pInterfaceGUID,
_Out_writes_bytes_to_ *, *pOutBufLen PWCHAR  pInterfaceName,
_Inout_ PULONG  pOutBufLen,
DWORD  dwUnknown4,
DWORD  dwUnknown5 
)

Definition at line 3301 of file iphlpapi_main.c.

3306{
3307 DWORD result;
3308
3309 result = GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
3310
3311 if (result == ERROR_NOT_FOUND)
3313
3314 return result;
3315}
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106

◆ NhpAllocateAndGetInterfaceInfoFromStack()

DWORD WINAPI NhpAllocateAndGetInterfaceInfoFromStack ( IP_INTERFACE_NAME_INFO **  ppTable,
PDWORD  pdwCount,
BOOL  bOrder,
HANDLE  hHeap,
DWORD  dwFlags 
)

Definition at line 3200 of file iphlpapi_main.c.

3201{
3202 FIXME(":stub\n");
3203 return 0L;
3204}

◆ NotifyAddrChange()

DWORD WINAPI NotifyAddrChange ( PHANDLE  Handle,
LPOVERLAPPED  overlapped 
)

Definition at line 2705 of file iphlpapi_main.c.

2706{
2707 FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
2710 return ERROR_IO_PENDING;
2711}
#define STATUS_PENDING
Definition: d3dkmdt.h:43
#define ERROR_IO_PENDING
Definition: dderror.h:15
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
ULONG Handle
Definition: gdb_input.c:15
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED * overlapped
Definition: sock.c:81

Referenced by AdapterDiscoveryThread(), and detectChange().

◆ NotifyRouteChange()

DWORD WINAPI NotifyRouteChange ( PHANDLE  Handle,
LPOVERLAPPED  overlapped 
)

Definition at line 2730 of file iphlpapi_main.c.

2731{
2732 FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
2733 return ERROR_NOT_SUPPORTED;
2734}

◆ SendARP()

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

Definition at line 2751 of file iphlpapi_main.c.

2752{
2753 IPAddr IPs[2];
2754 ULONG Size;
2755
2756 if (IsBadWritePtr(pMacAddr, sizeof(ULONG)) || IsBadWritePtr(PhyAddrLen, sizeof(ULONG)))
2758
2759 IPs[0] = DestIP;
2760 IPs[1] = SrcIP;
2761 Size = sizeof(IPs);
2762 return TCPSendIoctl(INVALID_HANDLE_VALUE, IOCTL_QUERY_IP_HW_ADDRESS, IPs, &Size, pMacAddr, PhyAddrLen);
2763}
DWORD TCPSendIoctl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, PULONG pInBufferSize, LPVOID lpOutBuffer, PULONG pOutBufferSize)
ULONG IPAddr
Definition: pfhook.h:35
#define IOCTL_QUERY_IP_HW_ADDRESS
Definition: tcpioctl.h:40

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

◆ SetIfEntry()

DWORD WINAPI SetIfEntry ( PMIB_IFROW  pIfRow)

Definition at line 2781 of file iphlpapi_main.c.

2782{
2783 FIXME("(pIfRow %p): stub\n", pIfRow);
2784 /* this is supposed to set an interface administratively up or down.
2785 Could do SIOCSIFFLAGS and set/clear IFF_UP, but, not sure I want to, and
2786 this sort of down is indistinguishable from other sorts of down (e.g. no
2787 link). */
2788 return ERROR_NOT_SUPPORTED;
2789}

◆ SetIpForwardEntry()

DWORD WINAPI SetIpForwardEntry ( PMIB_IPFORWARDROW  pRoute)

Definition at line 2804 of file iphlpapi_main.c.

2805{
2806 return setIpForwardEntry( pRoute );
2807}
DWORD setIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:59

◆ SetIpForwardEntryToStack()

DWORD WINAPI SetIpForwardEntryToStack ( PMIB_IPFORWARDROW  pRoute)

Definition at line 3223 of file iphlpapi_main.c.

3224{
3225 FIXME("SetIpForwardEntryToStack() stub\n");
3226 return 0L;
3227}

◆ SetIpNetEntry()

DWORD WINAPI SetIpNetEntry ( PMIB_IPNETROW  pArpEntry)

Definition at line 2822 of file iphlpapi_main.c.

2823{
2824 HANDLE tcpFile;
2829 DWORD returnSize;
2830 PMIB_IPNETROW arpBuff;
2831
2832 if (!pArpEntry)
2834
2836 return ERROR_NOT_SUPPORTED;
2837
2838 if (!NT_SUCCESS(getNthIpEntity( tcpFile, pArpEntry->dwIndex, &id )))
2839 {
2840 closeTcpFile(tcpFile);
2842 }
2843
2847 req.Req.ID.toi_entity.tei_instance = id.tei_instance;
2849 req.Req.BufferSize = sizeof(MIB_IPNETROW);
2850 arpBuff = (PMIB_IPNETROW)&req.Req.Buffer[0];
2851
2852 RtlCopyMemory(arpBuff, pArpEntry, sizeof(MIB_IPNETROW));
2853
2854 status = DeviceIoControl( tcpFile,
2856 &req,
2857 sizeof(req),
2858 NULL,
2859 0,
2860 &returnSize,
2861 NULL );
2862
2863 closeTcpFile(tcpFile);
2864
2865 if (status)
2866 return NO_ERROR;
2867 else
2869}
LONG NTSTATUS
Definition: precomp.h:26
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
GLuint id
Definition: glext.h:5910
NTSTATUS getNthIpEntity(HANDLE tcpFile, DWORD index, TDIEntityID *ent)
#define TCP_REQUEST_SET_INFORMATION_INIT
struct _MIB_IPNETROW MIB_IPNETROW
#define FILE_WRITE_DATA
Definition: nt_native.h:631
#define FILE_READ_DATA
Definition: nt_native.h:628
NTSTATUS openTcpFile(PHANDLE tcpFile, ACCESS_MASK DesiredAccess)
Definition: handle.c:12
VOID closeTcpFile(HANDLE h)
Definition: handle.c:43
DWORD dwIndex
Definition: ipmib.h:114
unsigned char Buffer[1]
Definition: tdiinfo.h:97
ULONG tei_entity
Definition: tdiinfo.h:31
ULONG tei_instance
Definition: tdiinfo.h:32
ULONG toi_id
Definition: tdiinfo.h:77
ULONG toi_type
Definition: tdiinfo.h:76
ULONG toi_class
Definition: tdiinfo.h:75
TDIEntityID toi_entity
Definition: tdiinfo.h:74
Definition: ps.c:97
#define IP_MIB_ARPTABLE_ENTRY_ID
Definition: tcpioctl.h:54
#define INFO_CLASS_PROTOCOL
Definition: tdiinfo.h:65
#define AT_ENTITY
Definition: tdiinfo.h:41
#define INFO_TYPE_PROVIDER
Definition: tdiinfo.h:69
#define IOCTL_TCP_SET_INFORMATION_EX
Definition: tditest.h:112
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
TCP_REQUEST_SET_INFORMATION_EX Req

Referenced by Addhost().

◆ SetIpStatistics()

DWORD WINAPI SetIpStatistics ( PMIB_IPSTATS  pIpStats)

Definition at line 2887 of file iphlpapi_main.c.

2888{
2889 FIXME("(pIpStats %p): stub\n", pIpStats);
2890 return 0;
2891}

◆ SetIpTTL()

DWORD WINAPI SetIpTTL ( UINT  nTTL)

Definition at line 2909 of file iphlpapi_main.c.

2910{
2911 FIXME("(nTTL %d): stub\n", nTTL);
2912 return 0;
2913}

◆ SetTcpEntry()

DWORD WINAPI SetTcpEntry ( PMIB_TCPROW  pTcpRow)

Definition at line 2931 of file iphlpapi_main.c.

2932{
2933 FIXME("(pTcpRow %p): stub\n", pTcpRow);
2934 return 0;
2935}

◆ TcpTableSorter()

static int TcpTableSorter ( const void a,
const void b 
)
static

Definition at line 880 of file iphlpapi_main.c.

881{
882 int ret;
883
884 if (a && b) {
885 PMIB_TCPROW rowA = (PMIB_TCPROW)a, rowB = (PMIB_TCPROW)b;
886
887 ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
888 if (ret == 0) {
889 ret = rowA->dwLocalPort - rowB->dwLocalPort;
890 if (ret == 0) {
891 ret = rowA->dwRemoteAddr - rowB->dwRemoteAddr;
892 if (ret == 0)
893 ret = rowA->dwRemotePort - rowB->dwRemotePort;
894 }
895 }
896 }
897 else
898 ret = 0;
899 return ret;
900}
DWORD dwLocalPort
Definition: tcpmib.h:59
DWORD dwLocalAddr
Definition: tcpmib.h:58
DWORD dwRemotePort
Definition: tcpmib.h:61
DWORD dwRemoteAddr
Definition: tcpmib.h:60
struct _MIB_TCPROW * PMIB_TCPROW

Referenced by GetExtendedTcpTable().

◆ UdpTableSorter()

static int UdpTableSorter ( const void a,
const void b 
)
static

Definition at line 1302 of file iphlpapi_main.c.

1303{
1304 int ret;
1305
1306 if (a && b) {
1307 PMIB_UDPROW rowA = (PMIB_UDPROW)a, rowB = (PMIB_UDPROW)b;
1308
1309 ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
1310 if (ret == 0)
1311 ret = rowA->dwLocalPort - rowB->dwLocalPort;
1312 }
1313 else
1314 ret = 0;
1315 return ret;
1316}
DWORD dwLocalAddr
Definition: udpmib.h:28
DWORD dwLocalPort
Definition: udpmib.h:29
struct _MIB_UDPROW * PMIB_UDPROW

Referenced by GetExtendedUdpTable().

◆ UnenableRouter()

DWORD WINAPI UnenableRouter ( OVERLAPPED pOverlapped,
LPDWORD  lpdwEnableCount 
)

Definition at line 2955 of file iphlpapi_main.c.

2956{
2957 FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped,
2958 lpdwEnableCount);
2959 return ERROR_NOT_SUPPORTED;
2960}

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( iphlpapi  )