ReactOS 0.4.15-dev-5884-gab5aff5
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 71 of file iphlpapi_main.c.

72{
73 return RtlNtStatusToDosError(addIPAddress(Address, Netmask, IfIndex, NteContext, NteInstance));
74}
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 107 of file iphlpapi_main.c.

109{
110 DWORD ret;
111
112 TRACE("ppIfTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n", ppIfTable,
113 (DWORD)bOrder, heap, flags);
114 if (!ppIfTable)
116 else {
117 DWORD dwSize = 0;
118
119 *ppIfTable = NULL;
120 ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
122 *ppIfTable = (PMIB_IFTABLE)HeapAlloc(heap, flags, dwSize);
123 ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
124 if (ret != NO_ERROR) {
125 HeapFree(heap, flags, *ppIfTable);
126 *ppIfTable = NULL;
127 }
128 }
129 }
130 TRACE("returning %ld\n", ret);
131 return ret;
132}
#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 151 of file iphlpapi_main.c.

153{
154 DWORD ret;
155
156 TRACE("ppIpAddrTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
157 ppIpAddrTable, (DWORD)bOrder, heap, flags);
158 if (!ppIpAddrTable)
160 else {
161 DWORD dwSize = 0;
162
163 *ppIpAddrTable = NULL;
164 ret = GetIpAddrTable(*ppIpAddrTable, &dwSize, bOrder);
166 *ppIpAddrTable = (PMIB_IPADDRTABLE)HeapAlloc(heap, flags, dwSize);
167 ret = GetIpAddrTable(*ppIpAddrTable, &dwSize, bOrder);
168 if (ret != NO_ERROR) {
169 HeapFree(heap, flags, *ppIpAddrTable);
170 *ppIpAddrTable = NULL;
171 }
172 }
173 }
174 TRACE("returning %ld\n", ret);
175 return ret;
176}
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 193 of file iphlpapi_main.c.

195{
196 DWORD ret;
197
198 TRACE("ppIpForwardTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
199 ppIpForwardTable, (DWORD)bOrder, heap, flags);
200 if (!ppIpForwardTable)
202 else {
203 DWORD dwSize = 0;
204
205 *ppIpForwardTable = NULL;
206 ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
208 *ppIpForwardTable = (PMIB_IPFORWARDTABLE)HeapAlloc(heap, flags, dwSize);
209 ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
210 if (ret != NO_ERROR) {
211 HeapFree(heap, flags, *ppIpForwardTable);
212 *ppIpForwardTable = NULL;
213 }
214 }
215 }
216 TRACE("returning %ld\n", ret);
217 return ret;
218}
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 237 of file iphlpapi_main.c.

239{
240 DWORD ret;
241
242 TRACE("ppIpNetTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
243 ppIpNetTable, (DWORD)bOrder, heap, flags);
244 if (!ppIpNetTable)
246 else {
247 DWORD dwSize = 0;
248
249 *ppIpNetTable = NULL;
250 ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
252 *ppIpNetTable = (PMIB_IPNETTABLE)HeapAlloc(heap, flags, dwSize);
253 ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
254 if (ret != NO_ERROR) {
255 HeapFree(heap, flags, *ppIpNetTable);
256 *ppIpNetTable = NULL;
257 }
258 }
259 }
260 TRACE("returning %ld\n", ret);
261 return ret;
262}
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 372 of file iphlpapi_main.c.

374{
375 DWORD ret;
376
377 TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family %ld, class %ld\n",
378 ppTcpTable, (DWORD)bOrder, heap, flags, family, class);
379 if (!ppTcpTable)
381 else {
382 DWORD dwSize = 0;
383
384 *ppTcpTable = NULL;
385 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, class, 0);
387 *ppTcpTable = HeapAlloc(heap, flags, dwSize);
388 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, class, 0);
389 if (ret != NO_ERROR) {
390 HeapFree(heap, flags, *ppTcpTable);
391 *ppTcpTable = NULL;
392 }
393 }
394 }
395 TRACE("returning %ld\n", ret);
396 return ret;
397}
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 326 of file iphlpapi_main.c.

328{
329 DWORD ret;
330
331 TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family 0x%08lx\n",
332 ppTcpTable, (DWORD)bOrder, heap, flags, family);
333 if (!ppTcpTable)
335 else {
336 DWORD dwSize = 0;
337
338 *ppTcpTable = NULL;
339 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, TCP_TABLE_OWNER_PID_ALL, 0);
342 ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, TCP_TABLE_OWNER_PID_ALL, 0);
343 if (ret != NO_ERROR) {
344 HeapFree(heap, flags, *ppTcpTable);
345 *ppTcpTable = NULL;
346 }
347 }
348 }
349 TRACE("returning %ld\n", ret);
350 return ret;
351}
@ 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 281 of file iphlpapi_main.c.

283{
284 DWORD ret;
285
286 TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
287 ppTcpTable, (DWORD)bOrder, heap, flags);
288 if (!ppTcpTable)
290 else {
291 DWORD dwSize = 0;
292
293 *ppTcpTable = NULL;
294 ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
296 *ppTcpTable = (PMIB_TCPTABLE)HeapAlloc(heap, flags, dwSize);
297 ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
298 if (ret != NO_ERROR) {
299 HeapFree(heap, flags, *ppTcpTable);
300 *ppTcpTable = NULL;
301 }
302 }
303 }
304 TRACE("returning %ld\n", ret);
305 return ret;
306}
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 507 of file iphlpapi_main.c.

509{
510 DWORD ret;
511
512 TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family %ld, class %ld\n",
513 ppUdpTable, (DWORD)bOrder, heap, flags, family, class);
514 if (!ppUdpTable)
516 else {
517 DWORD dwSize = 0;
518
519 *ppUdpTable = NULL;
520 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, class, 0);
522 *ppUdpTable = HeapAlloc(heap, flags, dwSize);
523 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, class, 0);
524 if (ret != NO_ERROR) {
525 HeapFree(heap, flags, *ppUdpTable);
526 *ppUdpTable = NULL;
527 }
528 }
529 }
530 TRACE("returning %ld\n", ret);
531 return ret;
532}
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 461 of file iphlpapi_main.c.

463{
464 DWORD ret;
465
466 TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family 0x%08lx\n",
467 ppUdpTable, (DWORD)bOrder, heap, flags, family);
468 if (!ppUdpTable)
470 else {
471 DWORD dwSize = 0;
472
473 *ppUdpTable = NULL;
474 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, UDP_TABLE_OWNER_PID, 0);
477 ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, UDP_TABLE_OWNER_PID, 0);
478 if (ret != NO_ERROR) {
479 HeapFree(heap, flags, *ppUdpTable);
480 *ppUdpTable = NULL;
481 }
482 }
483 }
484 TRACE("returning %ld\n", ret);
485 return ret;
486}
@ 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 416 of file iphlpapi_main.c.

418{
419 DWORD ret;
420
421 TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
422 ppUdpTable, (DWORD)bOrder, heap, flags);
423 if (!ppUdpTable)
425 else {
426 DWORD dwSize = 0;
427
428 *ppUdpTable = NULL;
429 ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
431 *ppUdpTable = (PMIB_UDPTABLE)HeapAlloc(heap, flags, dwSize);
432 ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
433 if (ret != NO_ERROR) {
434 HeapFree(heap, flags, *ppUdpTable);
435 *ppUdpTable = NULL;
436 }
437 }
438 }
439 TRACE("returning %ld\n", ret);
440 return ret;
441}
DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
struct _MIB_UDPTABLE * PMIB_UDPTABLE

◆ CancelIPChangeNotify()

BOOL WINAPI CancelIPChangeNotify ( LPOVERLAPPED  notifyOverlapped)

Definition at line 3370 of file iphlpapi_main.c.

3371{
3372 FIXME(":stub\n");
3373 return 0L;
3374}
#define FIXME(fmt,...)
Definition: debug.h:111
#define L(x)
Definition: ntvdm.h:50

◆ CreateIpForwardEntry()

DWORD WINAPI CreateIpForwardEntry ( PMIB_IPFORWARDROW  pRoute)

Definition at line 548 of file iphlpapi_main.c.

549{
550 return createIpForwardEntry( pRoute );
551}
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 567 of file iphlpapi_main.c.

568{
569 TRACE("pArpEntry %p\n", pArpEntry);
570 /* could use SIOCSARP on systems that support it, not sure I want to */
571 FIXME(":stub\n");
572 return (DWORD) 0;
573}

◆ CreateNameServerListEnumNamesFunc()

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

Definition at line 2514 of file iphlpapi_main.c.

2515{
2516 IP_ADDR_STRING *pNext;
2518
2519 if (!Context->NumServers)
2520 {
2521 if (Context->uSizeAvailable >= Context->uSizeRequired)
2522 {
2523 WideCharToMultiByte(CP_ACP, 0, Server, -1, Context->pData->DnsServerList.IpAddress.String, 16, NULL, NULL);
2524 Context->pData->DnsServerList.IpAddress.String[15] = '\0';
2525 Context->pLastAddr = &Context->pData->DnsServerList;
2526 }
2527 }
2528 else
2529 {
2530 Context->uSizeRequired += sizeof(IP_ADDR_STRING);
2531 if (Context->uSizeAvailable >= Context->uSizeRequired)
2532 {
2533 pNext = (IP_ADDR_STRING*)(((char*)Context->pLastAddr) + sizeof(IP_ADDR_STRING));
2534 WideCharToMultiByte(CP_ACP, 0, Server, -1, pNext->IpAddress.String, 16, NULL, NULL);
2535 pNext->IpAddress.String[15] = '\0';
2536 Context->pLastAddr->Next = pNext;
2537 Context->pLastAddr = pNext;
2538 pNext->Next = NULL;
2539 }
2540 }
2541 Context->NumServers++;
2542}
#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 591 of file iphlpapi_main.c.

592{
593 TRACE("dwAddress 0x%08lx, dwMask 0x%08lx, dwIfIndex 0x%08lx\n", dwAddress,
594 dwMask, dwIfIndex);
595 FIXME(":stub\n");
596 /* marking Win2K+ functions not supported */
597 return ERROR_NOT_SUPPORTED;
598}
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100

◆ DeleteIPAddress()

DWORD WINAPI DeleteIPAddress ( ULONG  NTEContext)

Definition at line 614 of file iphlpapi_main.c.

615{
616 TRACE("NTEContext %ld\n", NTEContext);
617 return RtlNtStatusToDosError(deleteIpAddress(NTEContext));
618}
NTSTATUS deleteIpAddress(ULONG NteContext)

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

◆ DeleteIpForwardEntry()

DWORD WINAPI DeleteIpForwardEntry ( PMIB_IPFORWARDROW  pRoute)

Definition at line 634 of file iphlpapi_main.c.

635{
636 return deleteIpForwardEntry( pRoute );
637}
DWORD deleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:64

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

◆ DeleteIpNetEntry()

DWORD WINAPI DeleteIpNetEntry ( PMIB_IPNETROW  pArpEntry)

Definition at line 653 of file iphlpapi_main.c.

654{
655 TRACE("pArpEntry %p\n", pArpEntry);
656 /* could use SIOCDARP on systems that support it, not sure I want to */
657 FIXME(":stub\n");
658 return (DWORD) 0;
659}

Referenced by Deletehost().

◆ DeleteProxyArpEntry()

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

Definition at line 677 of file iphlpapi_main.c.

678{
679 TRACE("dwAddress 0x%08lx, dwMask 0x%08lx, dwIfIndex 0x%08lx\n", dwAddress,
680 dwMask, dwIfIndex);
681 FIXME(":stub\n");
682 /* marking Win2K+ functions not supported */
683 return ERROR_NOT_SUPPORTED;
684}

◆ 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}
#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 700 of file iphlpapi_main.c.

701{
702 TRACE("pHandle %p, pOverlapped %p\n", pHandle, pOverlapped);
703 FIXME(":stub\n");
704 /* could echo "1" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
705 could map EACCESS to ERROR_ACCESS_DENIED, I suppose
706 marking Win2K+ functions not supported */
707 return ERROR_NOT_SUPPORTED;
708}

◆ FlushIpNetTable()

DWORD WINAPI FlushIpNetTable ( DWORD  dwIfIndex)

Definition at line 724 of file iphlpapi_main.c.

725{
726 TRACE("dwIfIndex 0x%08lx\n", dwIfIndex);
727 FIXME(":stub\n");
728 /* this flushes the arp cache of the given index
729 marking Win2K+ functions not supported */
730 return ERROR_NOT_SUPPORTED;
731}

Referenced by Deletehost().

◆ GetAdapterIndex()

DWORD WINAPI GetAdapterIndex ( LPWSTR  AdapterName,
PULONG  IfIndex 
)

Definition at line 748 of file iphlpapi_main.c.

749{
750 TRACE("AdapterName %p, IfIndex %p\n", AdapterName, IfIndex);
751 FIXME(":stub\n");
752 /* marking Win2K+ functions not supported */
753 return ERROR_NOT_SUPPORTED;
754}
_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 3160 of file iphlpapi_main.c.

3161{
3162 FIXME(":stub\n");
3163 return 0L;
3164}

◆ GetAdaptersInfo()

DWORD WINAPI GetAdaptersInfo ( PIP_ADAPTER_INFO  pAdapterInfo,
PULONG  pOutBufLen 
)

Definition at line 771 of file iphlpapi_main.c.

772{
773 DWORD ret;
774 BOOL dhcpEnabled;
775 DWORD dhcpServer;
776
777 TRACE("pAdapterInfo %p, pOutBufLen %p\n", pAdapterInfo, pOutBufLen);
778 if (!pOutBufLen)
780 else {
781 DWORD numNonLoopbackInterfaces = getNumNonLoopbackInterfaces();
782
783 if (numNonLoopbackInterfaces > 0) {
784 /* this calculation assumes only one address in the IP_ADDR_STRING lists.
785 that's okay, because:
786 - we don't get multiple addresses per adapter anyway
787 - we don't know about per-adapter gateways
788 - DHCP and WINS servers can have max one entry per list */
789 ULONG size = sizeof(IP_ADAPTER_INFO) * numNonLoopbackInterfaces;
790
791 if (!pAdapterInfo || *pOutBufLen < size) {
792 *pOutBufLen = size;
794 }
795 else {
797
798 if (table) {
799 size = sizeof(IP_ADAPTER_INFO) * table->numIndexes;
800 if (*pOutBufLen < size) {
801 *pOutBufLen = size;
803 }
804 else {
805 DWORD ndx;
806 HKEY hKey;
807 BOOL winsEnabled = FALSE;
808 IP_ADDRESS_STRING primaryWINS, secondaryWINS;
809
810 memset(pAdapterInfo, 0, size);
811 /* @@ Wine registry key: HKCU\Software\Wine\Network */
812 if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Network", &hKey) == ERROR_SUCCESS) {
813 DWORD size = sizeof(primaryWINS.String);
814 unsigned long addr;
815
816 RegQueryValueExA(hKey, "WinsServer", NULL, NULL,
817 (PBYTE)primaryWINS.String, &size);
818 addr = inet_addr(primaryWINS.String);
819 if (addr != INADDR_NONE && addr != INADDR_ANY)
820 winsEnabled = TRUE;
821 size = sizeof(secondaryWINS.String);
822 RegQueryValueExA(hKey, "BackupWinsServer", NULL, NULL,
823 (PBYTE)secondaryWINS.String, &size);
824 addr = inet_addr(secondaryWINS.String);
825 if (addr != INADDR_NONE && addr != INADDR_ANY)
826 winsEnabled = TRUE;
828 }
829 TRACE("num of index is %lu\n", table->numIndexes);
830 for (ndx = 0; ndx < table->numIndexes; ndx++) {
831 PIP_ADAPTER_INFO ptr = &pAdapterInfo[ndx];
832 DWORD addrLen = sizeof(ptr->Address), type;
833 const char *ifname =
834 getInterfaceNameByIndex(table->indexes[ndx]);
835 if (!ifname) {
837 break;
838 }
839
840 /* on Win98 this is left empty, but whatever */
841 strncpy(ptr->AdapterName,ifname,sizeof(ptr->AdapterName));
842 consumeInterfaceName(ifname);
843 ptr->AdapterName[MAX_ADAPTER_NAME_LENGTH] = '\0';
844 getInterfacePhysicalByIndex(table->indexes[ndx], &addrLen,
845 ptr->Address, &type);
846 /* MS defines address length and type as UINT in some places and
847 DWORD in others, **sigh**. Don't want to assume that PUINT and
848 PDWORD are equiv (64-bit?) */
849 ptr->AddressLength = addrLen;
850 ptr->Type = type;
851 ptr->Index = table->indexes[ndx];
853 ptr->IpAddressList.IpAddress.String);
855 ptr->IpAddressList.IpMask.String);
856 ptr->IpAddressList.Context = ptr->Index;
858 ptr->GatewayList.IpAddress.String);
859 getDhcpInfoForAdapter(table->indexes[ndx], &dhcpEnabled,
860 &dhcpServer, &ptr->LeaseObtained,
861 &ptr->LeaseExpires);
862 ptr->DhcpEnabled = (DWORD) dhcpEnabled;
863 toIPAddressString(dhcpServer,
864 ptr->DhcpServer.IpAddress.String);
865 if (winsEnabled) {
866 ptr->HaveWins = TRUE;
867 memcpy(ptr->PrimaryWinsServer.IpAddress.String,
868 primaryWINS.String, sizeof(primaryWINS.String));
869 memcpy(ptr->SecondaryWinsServer.IpAddress.String,
870 secondaryWINS.String, sizeof(secondaryWINS.String));
871 }
872 if (ndx < table->numIndexes - 1)
873 ptr->Next = &pAdapterInfo[ndx + 1];
874 else
875 ptr->Next = NULL;
876 }
877 ret = NO_ERROR;
878 }
879 free(table);
880 }
881 else
883 }
884 }
885 else
887 }
888 TRACE("returning %ld\n", ret);
889 return ret;
890}
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
#define INADDR_NONE
Definition: tcp.c:42
#define RegCloseKey(hKey)
Definition: registry.h:47
#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:3257
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:4027
DWORD getDhcpInfoForAdapter(DWORD AdapterIndex, PBOOL DhcpEnabled, PDWORD DhcpServer, time_t *LeaseObtained, time_t *LeaseExpires)
Definition: dhcp_reactos.c:17
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:76
#define MAX_ADAPTER_NAME_LENGTH
Definition: iptypes.h:27
struct _IP_ADAPTER_INFO IP_ADAPTER_INFO
#define inet_addr(cp)
Definition: inet.h:98
#define INADDR_ANY
Definition: inet.h:53
if(dx< 0)
Definition: linetemp.h:194
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static PVOID ptr
Definition: dispmode.c:27
#define DWORD
Definition: nt_native.h:44
BYTE * PBYTE
Definition: pedump.c:66
#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(), RPC_UuidGetNodeAddress(), ShowInfo(), and TestUM().

◆ GetBestInterface()

DWORD WINAPI GetBestInterface ( IPAddr  dwDestAddr,
PDWORD  pdwBestIfIndex 
)

Definition at line 907 of file iphlpapi_main.c.

908{
909 DWORD ret;
910
911 TRACE("dwDestAddr 0x%08lx, pdwBestIfIndex %p\n", dwDestAddr, pdwBestIfIndex);
912 if (!pdwBestIfIndex)
914 else {
915 MIB_IPFORWARDROW ipRow;
916
917 ret = GetBestRoute(dwDestAddr, 0, &ipRow);
918 if (ret == ERROR_SUCCESS)
919 *pdwBestIfIndex = ipRow.dwForwardIfIndex;
920 }
921 TRACE("returning %ld\n", ret);
922 return ret;
923}
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 3379 of file iphlpapi_main.c.

3380{
3381 FIXME(":stub\n");
3382 return 0L;
3383}

◆ GetBestRoute()

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

Definition at line 941 of file iphlpapi_main.c.

942{
944 DWORD ret;
945
946 TRACE("dwDestAddr 0x%08lx, dwSourceAddr 0x%08lx, pBestRoute %p\n", dwDestAddr,
947 dwSourceAddr, pBestRoute);
948 if (!pBestRoute)
950
952 if (table) {
953 DWORD ndx, minMaskSize, matchedNdx = 0;
954
955 for (ndx = 0, minMaskSize = 255; ndx < table->dwNumEntries; ndx++) {
956 if ((dwDestAddr & table->table[ndx].dwForwardMask) ==
957 (table->table[ndx].dwForwardDest & table->table[ndx].dwForwardMask)) {
958 DWORD hostMaskSize;
959
960 if (!_BitScanForward(&hostMaskSize, ntohl(table->table[ndx].dwForwardMask)))
961 {
962 hostMaskSize = 32;
963 }
964 if (hostMaskSize < minMaskSize) {
965 minMaskSize = hostMaskSize;
966 matchedNdx = ndx;
967 }
968 }
969 }
970 memcpy(pBestRoute, &table->table[matchedNdx], sizeof(MIB_IPFORWARDROW));
973 }
974 else
976 TRACE("returning %ld\n", ret);
977 return ret;
978}
#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:203

Referenced by GetBestInterface().

◆ GetExtendedTcpTable()

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

Definition at line 1022 of file iphlpapi_main.c.

1023{
1024 DWORD i, count, size;
1025 DWORD ret = NO_ERROR;
1026
1027 if (!pdwSize)
1028 {
1030 }
1031
1032 if (ulAf != AF_INET)
1033 {
1036 }
1037
1038 switch (TableClass)
1039 {
1041 {
1042 PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
1043 PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
1044
1045 if (pOurTcpTable)
1046 {
1047 size = FIELD_OFFSET(MIB_TCPTABLE, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW);
1048 if (size > *pdwSize || !pTheirTcpTable)
1049 {
1050 *pdwSize = size;
1052 }
1053 else
1054 {
1055 memcpy(pTheirTcpTable, pOurTcpTable, size);
1056
1057 if (bOrder)
1058 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1059 sizeof(MIB_TCPROW), TcpTableSorter);
1060 }
1061
1062 HeapFree(GetProcessHeap(),0, pOurTcpTable);
1063 }
1064 }
1065 break;
1066
1068 {
1069 PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
1070 PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
1071
1072 if (pOurTcpTable)
1073 {
1074 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1075 {
1076 if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
1077 {
1078 ++count;
1079 }
1080 }
1081
1083 if (size > *pdwSize || !pTheirTcpTable)
1084 {
1085 *pdwSize = size;
1087 }
1088 else
1089 {
1090 pTheirTcpTable->dwNumEntries = count;
1091
1092 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1093 {
1094 if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
1095 {
1096 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
1097 ++count;
1098 }
1099 }
1100 ASSERT(count == pTheirTcpTable->dwNumEntries);
1101
1102 if (bOrder)
1103 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1104 sizeof(MIB_TCPROW), TcpTableSorter);
1105 }
1106
1107 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1108 }
1109 }
1110 break;
1111
1113 {
1114 PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
1115 PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
1116
1117 if (pOurTcpTable)
1118 {
1119 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1120 {
1121 if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
1122 {
1123 ++count;
1124 }
1125 }
1126
1128 if (size > *pdwSize || !pTheirTcpTable)
1129 {
1130 *pdwSize = size;
1132 }
1133 else
1134 {
1135 pTheirTcpTable->dwNumEntries = count;
1136
1137 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1138 {
1139 if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
1140 {
1141 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
1142 ++count;
1143 }
1144 }
1145 ASSERT(count == pTheirTcpTable->dwNumEntries);
1146
1147 if (bOrder)
1148 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1149 sizeof(MIB_TCPROW), TcpTableSorter);
1150 }
1151
1152 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1153 }
1154 }
1155 break;
1156
1158 {
1160 PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1161
1162 if (pOurTcpTable)
1163 {
1165 if (size > *pdwSize || !pTheirTcpTable)
1166 {
1167 *pdwSize = size;
1169 }
1170 else
1171 {
1172 memcpy(pTheirTcpTable, pOurTcpTable, size);
1173
1174 /* Don't sort on PID, so use basic helper */
1175 if (bOrder)
1176 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1178 }
1179
1180 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1181 }
1182 }
1183 break;
1184
1186 {
1188 PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1189
1190 if (pOurTcpTable)
1191 {
1192 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1193 {
1194 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1195 {
1196 ++count;
1197 }
1198 }
1199
1201 if (size > *pdwSize || !pTheirTcpTable)
1202 {
1203 *pdwSize = size;
1205 }
1206 else
1207 {
1208 pTheirTcpTable->dwNumEntries = count;
1209
1210 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1211 {
1212 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1213 {
1214 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_PID));
1215 ++count;
1216 }
1217 }
1218 ASSERT(count == pTheirTcpTable->dwNumEntries);
1219
1220 /* Don't sort on PID, so use basic helper */
1221 if (bOrder)
1222 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1224 }
1225
1226 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1227 }
1228 }
1229 break;
1230
1232 {
1234 PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
1235
1236 if (pOurTcpTable)
1237 {
1238 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1239 {
1240 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1241 {
1242 ++count;
1243 }
1244 }
1245
1247 if (size > *pdwSize || !pTheirTcpTable)
1248 {
1249 *pdwSize = size;
1251 }
1252 else
1253 {
1254 pTheirTcpTable->dwNumEntries = count;
1255
1256 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1257 {
1258 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1259 {
1260 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_PID));
1261 ++count;
1262 }
1263 }
1264 ASSERT(count == pTheirTcpTable->dwNumEntries);
1265
1266 /* Don't sort on PID, so use basic helper */
1267 if (bOrder)
1268 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1270 }
1271
1272 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1273 }
1274 }
1275 break;
1276
1278 {
1280 PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1281
1282 if (pOurTcpTable)
1283 {
1285 if (size > *pdwSize || !pTheirTcpTable)
1286 {
1287 *pdwSize = size;
1289 }
1290 else
1291 {
1292 memcpy(pTheirTcpTable, pOurTcpTable, size);
1293
1294 /* Don't sort on PID, so use basic helper */
1295 if (bOrder)
1296 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1298 }
1299
1300 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1301 }
1302 }
1303 break;
1304
1306 {
1308 PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1309
1310 if (pOurTcpTable)
1311 {
1312 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1313 {
1314 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1315 {
1316 ++count;
1317 }
1318 }
1319
1321 if (size > *pdwSize || !pTheirTcpTable)
1322 {
1323 *pdwSize = size;
1325 }
1326 else
1327 {
1328 pTheirTcpTable->dwNumEntries = count;
1329
1330 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1331 {
1332 if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
1333 {
1334 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
1335 ++count;
1336 }
1337 }
1338 ASSERT(count == pTheirTcpTable->dwNumEntries);
1339
1340 /* Don't sort on PID, so use basic helper */
1341 if (bOrder)
1342 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1344 }
1345
1346 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1347 }
1348 }
1349 break;
1350
1352 {
1354 PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
1355
1356 if (pOurTcpTable)
1357 {
1358 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1359 {
1360 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1361 {
1362 ++count;
1363 }
1364 }
1365
1367 if (size > *pdwSize || !pTheirTcpTable)
1368 {
1369 *pdwSize = size;
1371 }
1372 else
1373 {
1374 pTheirTcpTable->dwNumEntries = count;
1375
1376 for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
1377 {
1378 if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
1379 {
1380 memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
1381 ++count;
1382 }
1383 }
1384 ASSERT(count == pTheirTcpTable->dwNumEntries);
1385
1386 /* Don't sort on PID, so use basic helper */
1387 if (bOrder)
1388 qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
1390 }
1391
1392 HeapFree(GetProcessHeap(), 0, pOurTcpTable);
1393 }
1394 }
1395 break;
1396
1397 default:
1399 break;
1400 }
1401
1402 return ret;
1403}
#define UNIMPLEMENTED
Definition: debug.h:115
#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
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 *))
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 1442 of file iphlpapi_main.c.

1443{
1444 DWORD size;
1445 DWORD ret = NO_ERROR;
1446
1447 if (!pdwSize)
1448 {
1450 }
1451
1452 if (ulAf != AF_INET)
1453 {
1456 }
1457
1458 switch (TableClass)
1459 {
1460 case UDP_TABLE_BASIC:
1461 {
1462 PMIB_UDPTABLE pOurUdpTable = getUdpTable(ClassBasic);
1463 PMIB_UDPTABLE pTheirUdpTable = pUdpTable;
1464
1465 if (pOurUdpTable)
1466 {
1467 size = FIELD_OFFSET(MIB_UDPTABLE, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW);
1468 if (size > *pdwSize || !pTheirUdpTable)
1469 {
1470 *pdwSize = size;
1472 }
1473 else
1474 {
1475 memcpy(pTheirUdpTable, pOurUdpTable, size);
1476
1477 if (bOrder)
1478 qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1479 sizeof(MIB_UDPROW), UdpTableSorter);
1480 }
1481
1482 HeapFree(GetProcessHeap(), 0, pOurUdpTable);
1483 }
1484 }
1485 break;
1486
1488 {
1490 PMIB_UDPTABLE_OWNER_PID pTheirUdpTable = pUdpTable;
1491
1492 if (pOurUdpTable)
1493 {
1495 if (size > *pdwSize || !pTheirUdpTable)
1496 {
1497 *pdwSize = size;
1499 }
1500 else
1501 {
1502 memcpy(pTheirUdpTable, pOurUdpTable, size);
1503
1504 if (bOrder)
1505 qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1507 }
1508
1509 HeapFree(GetProcessHeap(), 0, pOurUdpTable);
1510 }
1511 }
1512 break;
1513
1515 {
1517 PMIB_UDPTABLE_OWNER_MODULE pTheirUdpTable = pUdpTable;
1518
1519 if (pOurUdpTable)
1520 {
1522 if (size > *pdwSize || !pTheirUdpTable)
1523 {
1524 *pdwSize = size;
1526 }
1527 else
1528 {
1529 memcpy(pTheirUdpTable, pOurUdpTable, size);
1530
1531 if (bOrder)
1532 qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
1534 }
1535
1536 HeapFree(GetProcessHeap(), 0, pOurUdpTable);
1537 }
1538 }
1539 break;
1540
1541 default:
1543 break;
1544 }
1545
1546 return ret;
1547}
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 1563 of file iphlpapi_main.c.

1564{
1565 /* windows doesn't validate these, either, just makes sure the top byte is
1566 cleared. I assume my ifenum module never gives an index with the top
1567 byte set. */
1568 TRACE("returning %ld\n", IfIndex);
1569 return IfIndex;
1570}

◆ GetIcmpStatistics()

DWORD WINAPI GetIcmpStatistics ( PMIB_ICMP  pStats)

Definition at line 1586 of file iphlpapi_main.c.

1587{
1588 DWORD ret;
1589
1590 TRACE("pStats %p\n", pStats);
1591 ret = getICMPStats(pStats);
1592 TRACE("returning %ld\n", ret);
1593 return ret;
1594}
DWORD getICMPStats(MIB_ICMP *stats)

Referenced by mib2IcmpInit(), and ShowIcmpStatistics().

◆ GetIcmpStatisticsEx()

DWORD WINAPI GetIcmpStatisticsEx ( PMIB_ICMP_EX  pStats,
DWORD  dwFamily 
)

Definition at line 3397 of file iphlpapi_main.c.

3398{
3399 FIXME(":stub\n");
3400
3401 if (!pStats)
3403
3404 if (dwFamily != AF_INET && dwFamily != AF_INET6)
3406
3407 return 0L;
3408}
#define AF_INET6
Definition: winsock.h:369

◆ GetIfEntry()

DWORD WINAPI GetIfEntry ( PMIB_IFROW  pIfRow)

Definition at line 1610 of file iphlpapi_main.c.

1611{
1612 DWORD ret;
1613 const char *name;
1614
1615 TRACE("pIfRow %p\n", pIfRow);
1616 if (!pIfRow)
1618
1620 if (name) {
1621 ret = getInterfaceEntryByIndex(pIfRow->dwIndex, pIfRow);
1622 if (ret == NO_ERROR)
1623 ret = getInterfaceStatsByName(name, pIfRow);
1625 }
1626 else
1628 TRACE("returning %ld\n", ret);
1629 return ret;
1630}
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(), ShowInfo(), UpdateLanStatus(), and WkstaEnumAdaptersCallback().

◆ GetIfTable()

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

Definition at line 1660 of file iphlpapi_main.c.

1661{
1662 DWORD ret;
1663
1664 TRACE("pIfTable %p, pdwSize %p, bOrder %ld\n", pdwSize, pdwSize,
1665 (DWORD)bOrder);
1666 if (!pdwSize)
1668 else {
1669 DWORD numInterfaces = getNumInterfaces();
1670 ULONG size;
1671 TRACE("GetIfTable: numInterfaces = %d\n", (int)numInterfaces);
1672 size = sizeof(MIB_IFTABLE) + (numInterfaces - 1) * sizeof(MIB_IFROW);
1673
1674 if (!pIfTable || *pdwSize < size) {
1675 *pdwSize = size;
1677 }
1678 else {
1680
1681 if (table) {
1682 size = sizeof(MIB_IFTABLE) + (table->numIndexes - 1) *
1683 sizeof(MIB_IFROW);
1684 if (*pdwSize < size) {
1685 *pdwSize = size;
1687 }
1688 else {
1689 DWORD ndx;
1690
1691 pIfTable->dwNumEntries = 0;
1692 for (ndx = 0; ndx < table->numIndexes; ndx++) {
1693 pIfTable->table[ndx].dwIndex = table->indexes[ndx];
1694 GetIfEntry(&pIfTable->table[ndx]);
1695 pIfTable->dwNumEntries++;
1696 }
1697 if (bOrder)
1698 qsort(pIfTable->table, pIfTable->dwNumEntries, sizeof(MIB_IFROW),
1700 ret = NO_ERROR;
1701 }
1702 free(table);
1703 }
1704 else
1706 }
1707 }
1708 TRACE("returning %ld\n", ret);
1709 return ret;
1710}
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 76 of file iphlpapi_main.c.

77{
78 DWORD ndx, retVal = 0, numRoutes = getNumRoutes();
80 if (!table) return 0;
81
82 for (ndx = 0; ndx < numRoutes; ndx++)
83 {
84 if ((table->routes[ndx].ifIndex == (index)) && (table->routes[ndx].dest == 0))
85 retVal = table->routes[ndx].gateway;
86 }
88 return retVal;
89}
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 1727 of file iphlpapi_main.c.

1728{
1729 DWORD ret;
1730
1731 TRACE("pIfTable %p, dwOutBufLen %p\n", pIfTable, dwOutBufLen);
1732 if (!dwOutBufLen)
1734 else {
1735 DWORD numNonLoopbackInterfaces = getNumNonLoopbackInterfaces();
1736 ULONG size;
1737 TRACE("numNonLoopbackInterfaces == 0x%x\n", numNonLoopbackInterfaces);
1738 size = sizeof(IP_INTERFACE_INFO) + (numNonLoopbackInterfaces) *
1739 sizeof(IP_ADAPTER_INDEX_MAP);
1740
1741 if (!pIfTable || *dwOutBufLen < size) {
1742 *dwOutBufLen = size;
1744 }
1745 else {
1747
1748 if (table) {
1749 TRACE("table->numIndexes == 0x%x\n", table->numIndexes);
1750 size = sizeof(IP_INTERFACE_INFO) + (table->numIndexes) *
1751 sizeof(IP_ADAPTER_INDEX_MAP);
1752 if (*dwOutBufLen < size) {
1753 *dwOutBufLen = size;
1755 }
1756 else {
1757 DWORD ndx;
1758
1759 pIfTable->NumAdapters = 0;
1760 for (ndx = 0; ndx < table->numIndexes; ndx++) {
1761 const char *walker, *name;
1762 WCHAR *assigner;
1763
1764 pIfTable->Adapter[ndx].Index = table->indexes[ndx];
1765 name = getInterfaceNameByIndex(table->indexes[ndx]);
1766 wcscpy(pIfTable->Adapter[ndx].Name, L"\\DEVICE\\TCPIP_");
1767 for (walker = name, assigner = &pIfTable->Adapter[ndx].Name[14];
1768 walker && *walker &&
1769 assigner - pIfTable->Adapter[ndx].Name < MAX_ADAPTER_NAME - 1 - 14;
1770 walker++, assigner++)
1771 *assigner = *walker;
1772 *assigner = 0;
1774 pIfTable->NumAdapters++;
1775 }
1776 ret = NO_ERROR;
1777 }
1778 free(table);
1779 }
1780 else
1782 }
1783 }
1784 TRACE("returning %ld\n", ret);
1785 return ret;
1786}
#define MAX_ADAPTER_NAME
Definition: ipexport.h:143
struct _IP_ADAPTER_INDEX_MAP IP_ADAPTER_INDEX_MAP
struct _IP_INTERFACE_INFO IP_INTERFACE_INFO
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
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(), Release(), Renew(), and test_GetInterfaceName().

◆ GetInterfaceNameInternal()

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

Definition at line 3417 of file iphlpapi_main.c.

3420{
3422 DWORD result, type;
3423 WCHAR szKeyName[2*MAX_PATH];
3424 HRESULT hr;
3425 HKEY hKey;
3426
3427 if (pInterfaceGUID == NULL || pOutBufLen == NULL)
3429
3430 result = RtlStringFromGUID(pInterfaceGUID, &GuidString);
3431
3432 if (!NT_SUCCESS(result))
3433 {
3434 // failed to convert guid to string
3436 }
3437
3438 hr = StringCbPrintfW(szKeyName, sizeof(szKeyName), L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection", GuidString.Buffer);
3440
3441 if (FAILED(hr))
3442 {
3443 // key name is too long
3444 return ERROR_BUFFER_OVERFLOW;
3445 }
3446
3448
3449 if (result != ERROR_SUCCESS)
3450 {
3451 // failed to find adapter entry
3452 return ERROR_NOT_FOUND;
3453 }
3454
3455 result = RegQueryValueExW(hKey, L"Name", NULL, &type, (PVOID)pInterfaceName, pOutBufLen);
3456
3458
3459 if (result == ERROR_MORE_DATA)
3460 {
3461 *pOutBufLen = MAX_INTERFACE_NAME_LEN * 2;
3463 }
3464
3465 if (result != ERROR_SUCCESS || type != REG_SZ)
3466 {
3467 // failed to read adapter name
3468 return ERROR_NO_DATA;
3469 }
3470 return ERROR_SUCCESS;
3471}
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3356
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4121
#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 1816 of file iphlpapi_main.c.

1817{
1818 DWORD ret;
1819
1820 TRACE("pIpAddrTable %p, pdwSize %p, bOrder %ld\n", pIpAddrTable, pdwSize,
1821 (DWORD)bOrder);
1822 if (!pdwSize)
1824 else {
1825 DWORD numInterfaces = getNumInterfaces();
1826 ULONG size = sizeof(MIB_IPADDRTABLE) + (numInterfaces - 1) *
1827 sizeof(MIB_IPADDRROW);
1828
1829 if (!pIpAddrTable || *pdwSize < size) {
1830 *pdwSize = size;
1832 }
1833 else {
1835
1836 if (table) {
1837 size = sizeof(MIB_IPADDRTABLE) + (table->numIndexes - 1) *
1838 sizeof(MIB_IPADDRROW);
1839 if (*pdwSize < size) {
1840 *pdwSize = size;
1842 }
1843 else {
1844 DWORD ndx, bcast;
1845
1846 pIpAddrTable->dwNumEntries = 0;
1847 for (ndx = 0; ndx < table->numIndexes; ndx++) {
1848 pIpAddrTable->table[ndx].dwIndex = table->indexes[ndx];
1849 pIpAddrTable->table[ndx].dwAddr =
1850 getInterfaceIPAddrByIndex(table->indexes[ndx]);
1851 pIpAddrTable->table[ndx].dwMask =
1852 getInterfaceMaskByIndex(table->indexes[ndx]);
1853 /* the dwBCastAddr member isn't the broadcast address, it indicates
1854 * whether the interface uses the 1's broadcast address (1) or the
1855 * 0's broadcast address (0).
1856 */
1857 bcast = getInterfaceBCastAddrByIndex(table->indexes[ndx]);
1858 pIpAddrTable->table[ndx].dwBCastAddr =
1859 (bcast & pIpAddrTable->table[ndx].dwMask) ? 1 : 0;
1860 /* FIXME: hardcoded reasm size, not sure where to get it */
1861 pIpAddrTable->table[ndx].dwReasmSize = 65535;
1862 pIpAddrTable->table[ndx].unused1 = 0;
1863 pIpAddrTable->table[ndx].wType = 0; /* aka unused2 */
1864 pIpAddrTable->dwNumEntries++;
1865 }
1866 if (bOrder)
1867 qsort(pIpAddrTable->table, pIpAddrTable->dwNumEntries,
1869 ret = NO_ERROR;
1870 }
1871 free(table);
1872 }
1873 else
1875 }
1876 }
1877 TRACE("returning %ld\n", ret);
1878 return ret;
1879}
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 3150 of file iphlpapi_main.c.

3151{
3152 FIXME(":stub\n");
3153 return 0L;
3154}

◆ GetIpForwardTable()

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

Definition at line 1920 of file iphlpapi_main.c.

1921{
1922 DWORD ret;
1923
1924 TRACE("pIpForwardTable %p, pdwSize %p, bOrder %ld\n", pIpForwardTable,
1925 pdwSize, (DWORD)bOrder);
1926 if (!pdwSize)
1928 else {
1929 DWORD numRoutes = getNumRoutes();
1930 ULONG sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (numRoutes - 1) *
1931 sizeof(MIB_IPFORWARDROW);
1932
1933 if (!pIpForwardTable || *pdwSize < sizeNeeded) {
1934 *pdwSize = sizeNeeded;
1936 }
1937 else {
1939 if (table) {
1940 sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (table->numRoutes - 1) *
1941 sizeof(MIB_IPFORWARDROW);
1942 if (*pdwSize < sizeNeeded) {
1943 *pdwSize = sizeNeeded;
1945 }
1946 else {
1947 DWORD ndx;
1948
1949 pIpForwardTable->dwNumEntries = table->numRoutes;
1950 for (ndx = 0; ndx < numRoutes; ndx++) {
1951 pIpForwardTable->table[ndx].dwForwardIfIndex =
1952 table->routes[ndx].ifIndex;
1953 pIpForwardTable->table[ndx].dwForwardDest =
1954 table->routes[ndx].dest;
1955 pIpForwardTable->table[ndx].dwForwardMask =
1956 table->routes[ndx].mask;
1957 pIpForwardTable->table[ndx].dwForwardPolicy = 0;
1958 pIpForwardTable->table[ndx].dwForwardNextHop =
1959 table->routes[ndx].gateway;
1960 /* FIXME: this type is appropriate for local interfaces; may not
1961 always be appropriate */
1962 pIpForwardTable->table[ndx].dwForwardType = MIB_IPROUTE_TYPE_DIRECT;
1963 /* FIXME: other protos might be appropriate, e.g. the default route
1964 is typically set with MIB_IPPROTO_NETMGMT instead */
1965 pIpForwardTable->table[ndx].dwForwardProto = MIB_IPPROTO_LOCAL;
1966 /* punt on age and AS */
1967 pIpForwardTable->table[ndx].dwForwardAge = 0;
1968 pIpForwardTable->table[ndx].dwForwardNextHopAS = 0;
1969 pIpForwardTable->table[ndx].dwForwardMetric1 =
1970 table->routes[ndx].metric;
1971 /* rest of the metrics are 0.. */
1972 pIpForwardTable->table[ndx].dwForwardMetric2 = 0;
1973 pIpForwardTable->table[ndx].dwForwardMetric3 = 0;
1974 pIpForwardTable->table[ndx].dwForwardMetric4 = 0;
1975 pIpForwardTable->table[ndx].dwForwardMetric5 = 0;
1976 }
1977 if (bOrder)
1978 qsort(pIpForwardTable->table, pIpForwardTable->dwNumEntries,
1980 ret = NO_ERROR;
1981 }
1983 }
1984 else
1986 }
1987 }
1988 TRACE("returning %ld\n", ret);
1989 return ret;
1990}
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 2020 of file iphlpapi_main.c.

2021{
2022 DWORD ret = NO_ERROR;
2023
2024 TRACE("pIpNetTable %p, pdwSize %p, bOrder %d\n", pIpNetTable, pdwSize,
2025 (DWORD)bOrder);
2026 if (!pdwSize)
2028 else {
2029 DWORD numEntries = getNumArpEntries();
2030 ULONG size = sizeof(MIB_IPNETTABLE);
2031
2032 if (numEntries > 1)
2033 size += (numEntries - 1) * sizeof(MIB_IPNETROW);
2034 if (!pIpNetTable || *pdwSize < size) {
2035 *pdwSize = size;
2037 }
2038 else {
2040 if (table) {
2041 size = sizeof(MIB_IPNETTABLE);
2042 if (table->dwNumEntries > 1)
2043 size += (table->dwNumEntries - 1) * sizeof(MIB_IPNETROW);
2044 if (*pdwSize < size) {
2045 *pdwSize = size;
2047 }
2048 else {
2049 *pdwSize = size;
2050 memcpy(pIpNetTable, table, size);
2051 if (bOrder)
2052 qsort(pIpNetTable->table, pIpNetTable->dwNumEntries,
2054 ret = NO_ERROR;
2055 }
2057 }
2058 }
2059 }
2060 TRACE("returning %d\n", ret);
2061 return ret;
2062}
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 2078 of file iphlpapi_main.c.

2079{
2080 return GetIpStatisticsEx(pStats, PF_INET);
2081}
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 2097 of file iphlpapi_main.c.

2098{
2099 DWORD ret;
2100
2101 TRACE("pStats %p\n", pStats);
2102 ret = getIPStats(pStats, dwFamily);
2103 TRACE("returning %ld\n", ret);
2104 return ret;
2105}
DWORD getIPStats(PMIB_IPSTATS stats, DWORD family)

Referenced by GetIpStatistics().

◆ GetNetworkParams()

DWORD WINAPI GetNetworkParams ( PFIXED_INFO  pFixedInfo,
PULONG  pOutBufLen 
)

Definition at line 2121 of file iphlpapi_main.c.

2122{
2123 DWORD ret, size, type;
2124 LONG regReturn;
2125 HKEY hKey;
2126 PIPHLP_RES_INFO resInfo;
2127
2128 TRACE("pFixedInfo %p, pOutBufLen %p\n", pFixedInfo, pOutBufLen);
2129 if (!pOutBufLen)
2131
2132 resInfo = getResInfo();
2133 if (!resInfo)
2134 return ERROR_OUTOFMEMORY;
2135
2136 size = sizeof(FIXED_INFO) + (resInfo->riCount > 1 ? (resInfo->riCount-1) *
2137 sizeof(IP_ADDR_STRING) : 0);
2138 if (!pFixedInfo || *pOutBufLen < size) {
2139 *pOutBufLen = size;
2140 disposeResInfo( resInfo );
2141 return ERROR_BUFFER_OVERFLOW;
2142 }
2143
2144 memset(pFixedInfo, 0, size);
2145 /* Check for DhcpHostname and DhcpDomain first */
2147 "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters",
2148 0,
2149 KEY_READ,
2150 &hKey);
2151 if (regReturn == ERROR_SUCCESS) {
2152 /* Windows doesn't honor DHCP option 12 even if RFC requires it if it is returned by DHCP server! */
2153#if 0
2154 type = REG_SZ;
2155 size = sizeof(pFixedInfo->HostName);
2156 regReturn = RegQueryValueExA(hKey,
2157 "DhcpHostname",
2158 NULL,
2159 &type,
2160 (LPBYTE)pFixedInfo->HostName,
2161 &size);
2162 if (regReturn == ERROR_FILE_NOT_FOUND || (regReturn == ERROR_SUCCESS && size < 1))
2163 {
2164#endif
2165 type = REG_SZ;
2166 size = sizeof(pFixedInfo->HostName);
2167 regReturn = RegQueryValueExA(hKey,
2168 "Hostname",
2169 NULL,
2170 &type,
2171 (LPBYTE)pFixedInfo->HostName,
2172 &size);
2173#if 0
2174 }
2175#endif
2176
2177 type = REG_SZ;
2178 size = sizeof(pFixedInfo->DomainName);
2179 regReturn = RegQueryValueExA(hKey,
2180 "DhcpDomain",
2181 NULL,
2182 &type,
2183 (LPBYTE)pFixedInfo->DomainName,
2184 &size);
2185 if (regReturn == ERROR_FILE_NOT_FOUND || (regReturn == ERROR_SUCCESS && size < 1))
2186 {
2187 type = REG_SZ;
2188 size = sizeof(pFixedInfo->DomainName);
2189 regReturn = RegQueryValueExA(hKey,
2190 "Domain",
2191 NULL,
2192 &type,
2193 (LPBYTE)pFixedInfo->DomainName,
2194 &size);
2195 }
2197 }
2198
2199 TRACE("GetComputerNameExA: %s\n", pFixedInfo->DomainName);
2200
2201 if (resInfo->riCount > 0)
2202 {
2203 CopyMemory(&pFixedInfo->DnsServerList, resInfo->DnsList, sizeof(IP_ADDR_STRING));
2204 if (resInfo->riCount > 1)
2205 {
2206 IP_ADDR_STRING *pSrc = resInfo->DnsList->Next;
2207 IP_ADDR_STRING *pTarget = (struct _IP_ADDR_STRING*)((char*)pFixedInfo + sizeof(FIXED_INFO));
2208
2209 pFixedInfo->DnsServerList.Next = pTarget;
2210
2211 do
2212 {
2213 CopyMemory(pTarget, pSrc, sizeof(IP_ADDR_STRING));
2214 resInfo->riCount--;
2215 if (resInfo->riCount > 1)
2216 {
2217 pTarget->Next = (IP_ADDR_STRING*)((char*)pTarget + sizeof(IP_ADDR_STRING));
2218 pTarget = pTarget->Next;
2219 pSrc = pSrc->Next;
2220 }
2221 else
2222 {
2223 pTarget->Next = NULL;
2224 break;
2225 }
2226 }
2227 while(TRUE);
2228 }
2229 else
2230 {
2231 pFixedInfo->DnsServerList.Next = NULL;
2232 }
2233 }
2234
2235 pFixedInfo->NodeType = HYBRID_NODETYPE;
2237 "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ, &hKey);
2238 if (regReturn != ERROR_SUCCESS)
2240 "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters", 0, KEY_READ,
2241 &hKey);
2242 if (regReturn == ERROR_SUCCESS)
2243 {
2244 DWORD size = sizeof(pFixedInfo->ScopeId);
2245
2246 RegQueryValueExA(hKey, "ScopeID", NULL, NULL, (PBYTE)pFixedInfo->ScopeId, &size);
2248 }
2249
2250 disposeResInfo( resInfo );
2251 /* FIXME: can check whether routing's enabled in /proc/sys/net/ipv4/ip_forward
2252 I suppose could also check for a listener on port 53 to set EnableDns */
2253 ret = NO_ERROR;
2254 TRACE("returning %ld\n", ret);
2255
2256 return ret;
2257}
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3321
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:1668

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

◆ GetNumberOfInterfaces()

DWORD WINAPI GetNumberOfInterfaces ( PDWORD  pdwNumIf)

Definition at line 2273 of file iphlpapi_main.c.

2274{
2275 DWORD ret;
2276
2277 TRACE("pdwNumIf %p\n", pdwNumIf);
2278 if (!pdwNumIf)
2280 else {
2281 *pdwNumIf = getNumInterfaces();
2282 ret = NO_ERROR;
2283 }
2284 TRACE("returning %ld\n", ret);
2285 return ret;
2286}

Referenced by _RpcEnumInterfaces().

◆ GetOwnerModuleFromPidEntry()

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

Definition at line 2289 of file iphlpapi_main.c.

2290{
2292 DWORD FileLen, PathLen, Error;
2295
2296 if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
2297 IsBadWritePtr(Buffer, *pdwSize))
2298 {
2300 }
2301
2302 if (OwningPid == 0)
2303 {
2304 return ERROR_NOT_FOUND;
2305 }
2306
2308 if (Process == NULL)
2309 {
2310 return GetLastError();
2311 }
2312
2314 if (FileLen != 0)
2315 {
2317 if (PathLen == 0)
2318 {
2320 return GetLastError();
2321 }
2322
2323 /* Add NULL char */
2324 ++FileLen;
2325 ++PathLen;
2326 PathLen *= sizeof(WCHAR);
2327 FileLen *= sizeof(WCHAR);
2328 }
2329 else
2330 {
2331 Error = GetLastError();
2332
2334 {
2335 wcscpy(File, L"System");
2336 wcscpy(Path, L"System");
2337
2338 PathLen = sizeof(L"System");
2339 FileLen = sizeof(L"System");
2340 }
2341 else
2342 {
2344 return Error;
2345 }
2346 }
2347
2349
2350 if (*pdwSize < sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen)
2351 {
2352 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen;
2354 }
2355
2356 BasicInfo = Buffer;
2357 BasicInfo->pModuleName = (PVOID)((ULONG_PTR)BasicInfo + sizeof(TCPIP_OWNER_MODULE_BASIC_INFO));
2358 BasicInfo->pModulePath = (PVOID)((ULONG_PTR)BasicInfo->pModuleName + FileLen);
2359 wcscpy(BasicInfo->pModuleName, File);
2360 wcscpy(BasicInfo->pModulePath, Path);
2361 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen;
2362
2363 return NO_ERROR;
2364}
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:881
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:914
_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:161
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:166
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:1040
#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 2366 of file iphlpapi_main.c.

2367{
2368 UINT Size;
2369 HRESULT Res;
2370 HANDLE hAdvapi32;
2371 WCHAR SysDir[MAX_PATH];
2373 ULONG (NTAPI *_I_QueryTagInformation)(PVOID, DWORD, PVOID);
2374 struct
2375 {
2378 DWORD TagType;
2379 PWSTR Buffer;
2380 } ServiceQuery;
2381
2382 if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
2383 IsBadWritePtr(Buffer, *pdwSize))
2384 {
2386 }
2387
2388 /* First, secure (avoid injections) load advapi32.dll */
2390 if (Size == 0)
2391 {
2392 return GetLastError();
2393 }
2394
2395 Res = StringCchCatW(&SysDir[Size], MAX_PATH - Size, L"\\advapi32.dll");
2396 if (FAILED(Res))
2397 {
2398 return Res;
2399 }
2400
2401 hAdvapi32 = GetModuleHandleW(SysDir);
2402 if (hAdvapi32 == NULL)
2403 {
2404 return GetLastError();
2405 }
2406
2407 /* Now, we'll query the service associated with the tag */
2408 _I_QueryTagInformation = (PVOID)GetProcAddress(hAdvapi32, "I_QueryTagInformation");
2409 if (_I_QueryTagInformation == NULL)
2410 {
2411 return GetLastError();
2412 }
2413
2414 /* Set tag and PID for the query */
2415 ServiceQuery.ProcessId = OwningPid;
2416 ServiceQuery.ServiceTag = OwningTag;
2417 ServiceQuery.TagType = 0;
2418 ServiceQuery.Buffer = NULL;
2419
2420 /* And query */
2421 Res = _I_QueryTagInformation(NULL, 1, &ServiceQuery);
2422 if (Res != ERROR_SUCCESS)
2423 {
2424 return Res;
2425 }
2426
2427 /* Compute service name length */
2428 Size = wcslen(ServiceQuery.Buffer) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
2429
2430 /* We'll copy it twice, so make sure we have enough room */
2431 if (*pdwSize < sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size)
2432 {
2433 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size;
2434 LocalFree(ServiceQuery.Buffer);
2436 }
2437
2438 /* Copy back data */
2439 BasicInfo = Buffer;
2440 BasicInfo->pModuleName = (PVOID)((ULONG_PTR)BasicInfo + sizeof(TCPIP_OWNER_MODULE_BASIC_INFO));
2441 BasicInfo->pModulePath = (PVOID)((ULONG_PTR)BasicInfo->pModuleName + Size);
2442 wcscpy(BasicInfo->pModuleName, ServiceQuery.Buffer);
2443 wcscpy(BasicInfo->pModulePath, ServiceQuery.Buffer);
2444 *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size;
2445 LocalFree(ServiceQuery.Buffer);
2446
2447 return NO_ERROR;
2448}
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:2711
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 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 2469 of file iphlpapi_main.c.

2470{
2471 /* If we have a service tag, that's a service connection */
2472 if (pTcpEntry->OwningModuleInfo[0] != 0)
2473 {
2474 return GetOwnerModuleFromTagEntry(pTcpEntry->dwOwningPid, (DWORD)(pTcpEntry->OwningModuleInfo[0]), Class, Buffer, pdwSize);
2475 }
2476 else
2477 {
2478 return GetOwnerModuleFromPidEntry(pTcpEntry->dwOwningPid, Class, Buffer, pdwSize);
2479 }
2480}
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 2501 of file iphlpapi_main.c.

2502{
2503 /* If we have a service tag, that's a service connection */
2504 if (pUdpEntry->OwningModuleInfo[0] != 0)
2505 {
2506 return GetOwnerModuleFromTagEntry(pUdpEntry->dwOwningPid, (DWORD)(pUdpEntry->OwningModuleInfo[0]), Class, Buffer, pdwSize);
2507 }
2508 else
2509 {
2510 return GetOwnerModuleFromPidEntry(pUdpEntry->dwOwningPid, Class, Buffer, pdwSize);
2511 }
2512}
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 2559 of file iphlpapi_main.c.

2560{
2561 HKEY hkey;
2562 DWORD dwSize = 0;
2563 const char *ifName;
2565 WCHAR keyname[200] = L"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\";
2566
2567 if (!pOutBufLen)
2569
2570 if (!pPerAdapterInfo || *pOutBufLen < sizeof(IP_PER_ADAPTER_INFO))
2571 {
2572 *pOutBufLen = sizeof(IP_PER_ADAPTER_INFO);
2573 return ERROR_BUFFER_OVERFLOW;
2574 }
2575
2576 ifName = getInterfaceNameByIndex(IfIndex);
2577 if (!ifName)
2579
2580 MultiByteToWideChar(CP_ACP, 0, ifName, -1, &keyname[62], sizeof(keyname)/sizeof(WCHAR) - 63);
2581 HeapFree(GetProcessHeap(), 0, (LPVOID)ifName);
2582
2583 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keyname, 0, KEY_READ, &hkey) != ERROR_SUCCESS)
2584 {
2585 return ERROR_NOT_SUPPORTED;
2586 }
2587 Context.NumServers = 0;
2588 Context.uSizeAvailable = *pOutBufLen;
2589 Context.uSizeRequired = sizeof(IP_PER_ADAPTER_INFO);
2590 Context.pData = pPerAdapterInfo;
2591
2592 if (*pOutBufLen >= sizeof(IP_PER_ADAPTER_INFO))
2593 ZeroMemory(pPerAdapterInfo, sizeof(IP_PER_ADAPTER_INFO));
2594
2596
2597 if (Context.uSizeRequired > Context.uSizeAvailable)
2598 {
2599 *pOutBufLen = Context.uSizeRequired;
2600 RegCloseKey(hkey);
2601 return ERROR_BUFFER_OVERFLOW;
2602 }
2603
2604 if(RegQueryValueExW(hkey, L"NameServer", NULL, NULL, NULL, &dwSize) == ERROR_SUCCESS)
2605 {
2606 pPerAdapterInfo->AutoconfigActive = FALSE;
2607 }
2608 else
2609 {
2610 pPerAdapterInfo->AutoconfigActive = TRUE;
2611 }
2612
2613 RegCloseKey(hkey);
2614 return NOERROR;
2615}
#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:1670
#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 2634 of file iphlpapi_main.c.

2635{
2636 TRACE("DestIpAddress 0x%08lx, HopCount %p, MaxHops %ld, RTT %p\n",
2637 DestIpAddress, HopCount, MaxHops, RTT);
2638 FIXME(":stub\n");
2639 return (BOOL) 0;
2640}

◆ GetTcpStatistics()

DWORD WINAPI GetTcpStatistics ( PMIB_TCPSTATS  pStats)

Definition at line 2680 of file iphlpapi_main.c.

2681{
2682 return GetTcpStatisticsEx(pStats, PF_INET);
2683}
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 2657 of file iphlpapi_main.c.

2658{
2659 DWORD ret;
2660
2661 TRACE("pStats %p\n", pStats);
2662 ret = getTCPStats(pStats, dwFamily);
2663 TRACE("returning %ld\n", ret);
2664 return ret;
2665}
DWORD getTCPStats(MIB_TCPSTATS *stats, DWORD family)

Referenced by GetTcpStatistics().

◆ GetTcpTable()

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

Definition at line 2708 of file iphlpapi_main.c.

2709{
2710 return GetExtendedTcpTable(pTcpTable, pdwSize, bOrder, AF_INET, TCP_TABLE_BASIC_ALL, 0);
2711}

Referenced by AllocateAndGetTcpTableFromStack().

◆ GetUdpStatistics()

DWORD WINAPI GetUdpStatistics ( PMIB_UDPSTATS  pStats)

Definition at line 2751 of file iphlpapi_main.c.

2752{
2753 return GetUdpStatisticsEx(pStats, PF_INET);
2754}
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 2728 of file iphlpapi_main.c.

2729{
2730 DWORD ret;
2731
2732 TRACE("pStats %p\n", pStats);
2733 ret = getUDPStats(pStats, dwFamily);
2734 TRACE("returning %ld\n", ret);
2735 return ret;
2736}
DWORD getUDPStats(MIB_UDPSTATS *stats, DWORD family)

Referenced by GetUdpStatistics().

◆ GetUdpTable()

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

Definition at line 2772 of file iphlpapi_main.c.

2773{
2774 return GetExtendedUdpTable(pUdpTable, pdwSize, bOrder, AF_INET, UDP_TABLE_BASIC, 0);
2775}

Referenced by AllocateAndGetUdpTableFromStack(), and mib2UdpEntryInit().

◆ GetUniDirectionalAdapterInfo()

DWORD WINAPI GetUniDirectionalAdapterInfo ( PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS  pIPIfInfo,
PULONG  dwOutBufLen 
)

Definition at line 2796 of file iphlpapi_main.c.

2797{
2798 TRACE("pIPIfInfo %p, dwOutBufLen %p\n", pIPIfInfo, dwOutBufLen);
2799 /* a unidirectional adapter?? not bloody likely! */
2800 return ERROR_NOT_SUPPORTED;
2801}

◆ IfTableSorter()

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

Definition at line 1633 of file iphlpapi_main.c.

1634{
1635 int ret;
1636
1637 if (a && b)
1638 ret = ((PMIB_IFROW)a)->dwIndex - ((PMIB_IFROW)b)->dwIndex;
1639 else
1640 ret = 0;
1641 return ret;
1642}
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 1789 of file iphlpapi_main.c.

1790{
1791 int ret;
1792
1793 if (a && b)
1794 ret = ((PMIB_IPADDRROW)a)->dwAddr - ((PMIB_IPADDRROW)b)->dwAddr;
1795 else
1796 ret = 0;
1797 return ret;
1798}
struct _MIB_IPADDRROW * PMIB_IPADDRROW

Referenced by GetIpAddrTable().

◆ IpForwardTableSorter()

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

Definition at line 1882 of file iphlpapi_main.c.

1883{
1884 int ret;
1885
1886 if (a && b) {
1888
1889 ret = rowA->dwForwardDest - rowB->dwForwardDest;
1890 if (ret == 0) {
1891 ret = rowA->dwForwardProto - rowB->dwForwardProto;
1892 if (ret == 0) {
1893 ret = rowA->dwForwardPolicy - rowB->dwForwardPolicy;
1894 if (ret == 0)
1895 ret = rowA->dwForwardNextHop - rowB->dwForwardNextHop;
1896 }
1897 }
1898 }
1899 else
1900 ret = 0;
1901 return ret;
1902}
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 1993 of file iphlpapi_main.c.

1994{
1995 int ret;
1996
1997 if (a && b)
1998 ret = ((PMIB_IPNETROW)a)->dwAddr - ((PMIB_IPNETROW)b)->dwAddr;
1999 else
2000 ret = 0;
2001 return ret;
2002}
struct _MIB_IPNETROW * PMIB_IPNETROW

Referenced by GetIpNetTable().

◆ IpReleaseAddress()

DWORD WINAPI IpReleaseAddress ( PIP_ADAPTER_INDEX_MAP  AdapterInfo)

Definition at line 2817 of file iphlpapi_main.c.

2818{
2819 DWORD Status, Version = 0;
2820
2821 if (!AdapterInfo)
2823
2824 /* Maybe we should do this in DllMain */
2826 return ERROR_PROC_NOT_FOUND;
2827
2828 if (DhcpReleaseIpAddressLease(AdapterInfo->Index))
2830 else
2832
2834
2835 return Status;
2836}
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:139
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 2851 of file iphlpapi_main.c.

2852{
2853 DWORD Status, Version = 0;
2854
2855 if (!AdapterInfo)
2857
2858 /* Maybe we should do this in DllMain */
2860 return ERROR_PROC_NOT_FOUND;
2861
2862 if (DhcpRenewIpAddressLease(AdapterInfo->Index))
2864 else
2866
2868
2869 return Status;
2870}
DWORD APIENTRY DhcpRenewIpAddressLease(DWORD AdapterIndex)
Definition: dhcpcsvc.c:165

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 3477 of file iphlpapi_main.c.

3482{
3484
3485 if (pInterfaceName == NULL)
3487
3488 return GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
3489}
#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 3495 of file iphlpapi_main.c.

3500{
3501 DWORD result;
3502
3503 result = GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
3504
3505 if (result == ERROR_NOT_FOUND)
3507
3508 return result;
3509}
#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 3388 of file iphlpapi_main.c.

3389{
3390 FIXME(":stub\n");
3391 return 0L;
3392}

◆ NotifyAddrChange()

DWORD WINAPI NotifyAddrChange ( PHANDLE  Handle,
LPOVERLAPPED  overlapped 
)

Definition at line 2889 of file iphlpapi_main.c.

2890{
2891 FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
2894 return ERROR_IO_PENDING;
2895}
#define ERROR_IO_PENDING
Definition: dderror.h:15
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
ULONG Handle
Definition: gdb_input.c:15
#define STATUS_PENDING
Definition: ntstatus.h:82
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 2914 of file iphlpapi_main.c.

2915{
2916 FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
2917 return ERROR_NOT_SUPPORTED;
2918}

◆ SendARP()

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

Definition at line 2935 of file iphlpapi_main.c.

2936{
2937 IPAddr IPs[2];
2938 ULONG Size;
2939
2940 if (IsBadWritePtr(pMacAddr, sizeof(ULONG)) || IsBadWritePtr(PhyAddrLen, sizeof(ULONG)))
2942
2943 IPs[0] = DestIP;
2944 IPs[1] = SrcIP;
2945 Size = sizeof(IPs);
2946 return TCPSendIoctl(INVALID_HANDLE_VALUE, IOCTL_QUERY_IP_HW_ADDRESS, IPs, &Size, pMacAddr, PhyAddrLen);
2947}
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 2965 of file iphlpapi_main.c.

2966{
2967 FIXME("(pIfRow %p): stub\n", pIfRow);
2968 /* this is supposed to set an interface administratively up or down.
2969 Could do SIOCSIFFLAGS and set/clear IFF_UP, but, not sure I want to, and
2970 this sort of down is indistinguishable from other sorts of down (e.g. no
2971 link). */
2972 return ERROR_NOT_SUPPORTED;
2973}

◆ SetIpForwardEntry()

DWORD WINAPI SetIpForwardEntry ( PMIB_IPFORWARDROW  pRoute)

Definition at line 2989 of file iphlpapi_main.c.

2990{
2991 return setIpForwardEntry( pRoute );
2992}
DWORD setIpForwardEntry(PMIB_IPFORWARDROW pRoute)
Definition: route.c:59

◆ SetIpForwardEntryToStack()

DWORD WINAPI SetIpForwardEntryToStack ( PMIB_IPFORWARDROW  pRoute)

Definition at line 3411 of file iphlpapi_main.c.

3412{
3413 FIXME("SetIpForwardEntryToStack() stub\n");
3414 return 0L;
3415}

◆ SetIpNetEntry()

DWORD WINAPI SetIpNetEntry ( PMIB_IPNETROW  pArpEntry)

Definition at line 3007 of file iphlpapi_main.c.

3008{
3009 HANDLE tcpFile;
3014 DWORD returnSize;
3015 PMIB_IPNETROW arpBuff;
3016
3017 if (!pArpEntry)
3019
3021 return ERROR_NOT_SUPPORTED;
3022
3023 if (!NT_SUCCESS(getNthIpEntity( tcpFile, pArpEntry->dwIndex, &id )))
3024 {
3025 closeTcpFile(tcpFile);
3027 }
3028
3032 req.Req.ID.toi_entity.tei_instance = id.tei_instance;
3034 req.Req.BufferSize = sizeof(MIB_IPNETROW);
3035 arpBuff = (PMIB_IPNETROW)&req.Req.Buffer[0];
3036
3037 RtlCopyMemory(arpBuff, pArpEntry, sizeof(MIB_IPNETROW));
3038
3039 status = DeviceIoControl( tcpFile,
3041 &req,
3042 sizeof(req),
3043 NULL,
3044 0,
3045 &returnSize,
3046 NULL );
3047
3048 closeTcpFile(tcpFile);
3049
3050 if (status)
3051 return NO_ERROR;
3052 else
3054}
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 3072 of file iphlpapi_main.c.

3073{
3074 FIXME("(pIpStats %p): stub\n", pIpStats);
3075 return 0;
3076}

◆ SetIpTTL()

DWORD WINAPI SetIpTTL ( UINT  nTTL)

Definition at line 3094 of file iphlpapi_main.c.

3095{
3096 FIXME("(nTTL %d): stub\n", nTTL);
3097 return 0;
3098}

◆ SetTcpEntry()

DWORD WINAPI SetTcpEntry ( PMIB_TCPROW  pTcpRow)

Definition at line 3116 of file iphlpapi_main.c.

3117{
3118 FIXME("(pTcpRow %p): stub\n", pTcpRow);
3119 return 0;
3120}

◆ TcpTableSorter()

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

Definition at line 980 of file iphlpapi_main.c.

981{
982 int ret;
983
984 if (a && b) {
985 PMIB_TCPROW rowA = (PMIB_TCPROW)a, rowB = (PMIB_TCPROW)b;
986
987 ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
988 if (ret == 0) {
989 ret = rowA->dwLocalPort - rowB->dwLocalPort;
990 if (ret == 0) {
991 ret = rowA->dwRemoteAddr - rowB->dwRemoteAddr;
992 if (ret == 0)
993 ret = rowA->dwRemotePort - rowB->dwRemotePort;
994 }
995 }
996 }
997 else
998 ret = 0;
999 return ret;
1000}
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 1406 of file iphlpapi_main.c.

1407{
1408 int ret;
1409
1410 if (a && b) {
1411 PMIB_UDPROW rowA = (PMIB_UDPROW)a, rowB = (PMIB_UDPROW)b;
1412
1413 ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
1414 if (ret == 0)
1415 ret = rowA->dwLocalPort - rowB->dwLocalPort;
1416 }
1417 else
1418 ret = 0;
1419 return ret;
1420}
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 3140 of file iphlpapi_main.c.

3141{
3142 FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped,
3143 lpdwEnableCount);
3144 return ERROR_NOT_SUPPORTED;
3145}

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( iphlpapi  )