ReactOS  0.4.15-dev-5488-ge316d61
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 ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define NO_ERROR
Definition: dderror.h:5
DWORD WINAPI GetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
int ret
struct _MIB_IFTABLE * PMIB_IFTABLE
#define NULL
Definition: types.h:112
#define HeapFree(x, y, z)
Definition: compat.h:735
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

◆ 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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define NO_ERROR
Definition: dderror.h:5
DWORD WINAPI GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder)
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
int ret
struct _MIB_IPADDRTABLE * PMIB_IPADDRTABLE
#define NULL
Definition: types.h:112
#define HeapFree(x, y, z)
Definition: compat.h:735
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

◆ 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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define NO_ERROR
Definition: dderror.h:5
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
int ret
struct _MIB_IPFORWARDTABLE * PMIB_IPFORWARDTABLE
DWORD WINAPI GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder)
#define NULL
Definition: types.h:112
#define HeapFree(x, y, z)
Definition: compat.h:735
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
DWORD WINAPI GetIpNetTable(PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder)
#define NO_ERROR
Definition: dderror.h:5
struct _MIB_IPNETTABLE * PMIB_IPNETTABLE
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
int ret
#define NULL
Definition: types.h:112
#define HeapFree(x, y, z)
Definition: compat.h:735
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

◆ 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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define NO_ERROR
Definition: dderror.h:5
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
int ret
#define NULL
Definition: types.h:112
DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
#define HeapFree(x, y, z)
Definition: compat.h:735
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

◆ 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);
341  *ppTcpTable = (PMIB_TCPTABLE_OWNER_PID)HeapAlloc(heap, flags, dwSize);
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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define NO_ERROR
Definition: dderror.h:5
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
int ret
struct _MIB_TCPTABLE_OWNER_PID * PMIB_TCPTABLE_OWNER_PID
#define NULL
Definition: types.h:112
DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
#define HeapFree(x, y, z)
Definition: compat.h:735
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

◆ 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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define NO_ERROR
Definition: dderror.h:5
#define TRACE(s)
Definition: solgame.cpp:4
DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
int ret
struct _MIB_TCPTABLE * PMIB_TCPTABLE
#define NULL
Definition: types.h:112
#define HeapFree(x, y, z)
Definition: compat.h:735
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

◆ 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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define NO_ERROR
Definition: dderror.h:5
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
int ret
DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)
#define NULL
Definition: types.h:112
#define HeapFree(x, y, z)
Definition: compat.h:735
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

◆ 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);
476  *ppUdpTable = (PMIB_UDPTABLE_OWNER_PID)HeapAlloc(heap, flags, dwSize);
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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define NO_ERROR
Definition: dderror.h:5
struct _MIB_UDPTABLE_OWNER_PID * PMIB_UDPTABLE_OWNER_PID
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
int ret
DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)
#define NULL
Definition: types.h:112
#define HeapFree(x, y, z)
Definition: compat.h:735
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

◆ 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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
struct _MIB_UDPTABLE * PMIB_UDPTABLE
#define NO_ERROR
Definition: dderror.h:5
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
int ret
#define NULL
Definition: types.h:112
#define HeapFree(x, y, z)
Definition: compat.h:735
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

◆ 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 L(x)
Definition: ntvdm.h:50
#define FIXME(fmt,...)
Definition: debug.h:111

◆ 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 }
#define FIXME(fmt,...)
Definition: debug.h:111
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95

◆ 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 WideCharToMultiByte
Definition: compat.h:111
#define CP_ACP
Definition: compat.h:109
IP_ADDRESS_STRING IpAddress
Definition: iptypes.h:47
struct _IP_ADDR_STRING * Next
Definition: iptypes.h:46
char String[4 *4]
Definition: iptypes.h:42
static void Server(int port)
Definition: srltest.c:69
struct _NAME_SERVER_LIST_CONTEXT * PNAME_SERVER_LIST_CONTEXT
#define NULL
Definition: types.h:112
struct _IP_ADDR_STRING IP_ADDR_STRING

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 FIXME(fmt,...)
Definition: debug.h:111
#define TRACE(s)
Definition: solgame.cpp:4
#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 }
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
NTSTATUS deleteIpAddress(ULONG NteContext)
#define TRACE(s)
Definition: solgame.cpp:4

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 }
#define FIXME(fmt,...)
Definition: debug.h:111
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95

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 }
#define FIXME(fmt,...)
Definition: debug.h:111
#define TRACE(s)
Definition: solgame.cpp:4
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100

◆ DllMain()

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

Definition at line 39 of file iphlpapi_main.c.

40 {
41  switch (fdwReason) {
42  case DLL_PROCESS_ATTACH:
43  DisableThreadLibraryCalls( hinstDLL );
45  break;
46 
47  case DLL_PROCESS_DETACH:
49  break;
50  }
51  return TRUE;
52 }
#define TRUE
Definition: types.h:120
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
void interfaceMapInit(void)
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
#define DLL_PROCESS_DETACH
Definition: compat.h:130
void interfaceMapFree(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 }
#define FIXME(fmt,...)
Definition: debug.h:111
#define TRACE(s)
Definition: solgame.cpp:4
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100

◆ 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 }
#define FIXME(fmt,...)
Definition: debug.h:111
#define TRACE(s)
Definition: solgame.cpp:4
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100

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 }
#define FIXME(fmt,...)
Definition: debug.h:111
#define TRACE(s)
Definition: solgame.cpp:4
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100
_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:6013

◆ 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 }
#define L(x)
Definition: ntvdm.h:50
#define FIXME(fmt,...)
Definition: debug.h:111

◆ 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;
827  RegCloseKey(hKey);
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
886  ret = ERROR_NO_DATA;
887  }
888  TRACE("returning %ld\n", ret);
889  return ret;
890 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
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
#define inet_addr(cp)
Definition: inet.h:98
#define ERROR_SUCCESS
Definition: deptool.c:10
#define TRUE
Definition: types.h:120
#define ERROR_BUFFER_OVERFLOW
Definition: winerror.h:185
#define HKEY_CURRENT_USER
Definition: winreg.h:11
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
#define free
Definition: debug_ros.c:5
#define INADDR_NONE
Definition: tcp.c:42
#define INADDR_ANY
Definition: StrAddr.c:4
char String[4 *4]
Definition: iptypes.h:42
if(dx==0 &&dy==0)
Definition: linetemp.h:174
#define NO_ERROR
Definition: dderror.h:5
InterfaceIndexTable * getNonLoopbackInterfaceIndexTable(void)
DWORD getNumNonLoopbackInterfaces(void)
#define DWORD
Definition: nt_native.h:44
struct _IP_ADAPTER_INFO IP_ADAPTER_INFO
void consumeInterfaceName(const char *ifname)
const char * getInterfaceNameByIndex(DWORD index)
DWORD getDhcpInfoForAdapter(DWORD AdapterIndex, PBOOL DhcpEnabled, PDWORD DhcpServer, time_t *LeaseObtained, time_t *LeaseExpires)
Definition: dhcp_reactos.c:17
char * toIPAddressString(unsigned int addr, char string[16])
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
static PVOID ptr
Definition: dispmode.c:27
DWORD getInterfacePhysicalByIndex(DWORD index, PDWORD len, PBYTE addr, PDWORD type)
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
#define ERROR_NO_DATA
Definition: winerror.h:284
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD getInterfaceMaskByIndex(DWORD index)
DWORD getInterfaceGatewayByIndex(DWORD index)
Definition: iphlpapi_main.c:76
int ret
#define MAX_ADAPTER_NAME_LENGTH
Definition: iptypes.h:27
GLenum const GLvoid * addr
Definition: glext.h:9621
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
FxAutoRegKey hKey
#define NULL
Definition: types.h:112
unsigned int ULONG
Definition: retypes.h:1
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define memset(x, y, z)
Definition: compat.h:39
BYTE * PBYTE
Definition: pedump.c:66
DWORD getInterfaceIPAddrByIndex(DWORD index)
#define RegCloseKey(hKey)
Definition: registry.h:47
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define ERROR_SUCCESS
Definition: deptool.c:10
IF_INDEX dwForwardIfIndex
Definition: ipmib.h:75
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)

◆ 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 }
#define L(x)
Definition: ntvdm.h:50
#define FIXME(fmt,...)
Definition: debug.h:111

◆ 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));
972  ret = ERROR_SUCCESS;
973  }
974  else
976  TRACE("returning %ld\n", ret);
977  return ret;
978 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask)
Definition: intrin_arm.h:57
#define ERROR_SUCCESS
Definition: deptool.c:10
DWORD WINAPI AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE *ppIpForwardTable, BOOL bOrder, HANDLE heap, DWORD flags)
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
#define FALSE
Definition: types.h:117
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:736
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define ntohl(x)
Definition: module.h:203
#define HeapFree(x, y, z)
Definition: compat.h:735
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13

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  {
1029  return ERROR_INVALID_PARAMETER;
1030  }
1031 
1032  if (ulAf != AF_INET)
1033  {
1034  UNIMPLEMENTED;
1035  return ERROR_INVALID_PARAMETER;
1036  }
1037 
1038  switch (TableClass)
1039  {
1040  case TCP_TABLE_BASIC_ALL:
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 ERROR_INVALID_PARAMETER
Definition: compat.h:101
PVOID getTcpTable(CLASS_TABLE Class)
struct _MIB_TCPROW_OWNER_MODULE MIB_TCPROW_OWNER_MODULE
MIB_TCPROW table[1]
Definition: tcpmib.h:67
static int TcpTableSorter(const void *a, const void *b)
GLuint GLuint GLsizei count
Definition: gl.h:1545
DWORD dwNumEntries
Definition: tcpmib.h:66
#define NO_ERROR
Definition: dderror.h:5
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 *))
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:736
#define ASSERT(a)
Definition: mode.c:44
unsigned long DWORD
Definition: ntddk_ex.h:95
MIB_TCP_STATE State
Definition: tcpmib.h:56
struct _MIB_TCPROW_OWNER_PID MIB_TCPROW_OWNER_PID
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
MIB_TCPROW_OWNER_MODULE table[1]
Definition: tcpmib.h:133
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
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define AF_INET
Definition: tcpip.h:117
#define UNIMPLEMENTED
Definition: debug.h:115
#define HeapFree(x, y, z)
Definition: compat.h:735
MIB_TCPROW_OWNER_PID table[1]
Definition: tcpmib.h:115
struct _MIB_TCPROW MIB_TCPROW
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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  {
1449  return ERROR_INVALID_PARAMETER;
1450  }
1451 
1452  if (ulAf != AF_INET)
1453  {
1454  UNIMPLEMENTED;
1455  return ERROR_INVALID_PARAMETER;
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 
1487  case UDP_TABLE_OWNER_PID:
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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
struct _MIB_UDPROW MIB_UDPROW
struct _MIB_UDPROW_OWNER_PID MIB_UDPROW_OWNER_PID
#define NO_ERROR
Definition: dderror.h:5
MIB_UDPROW_OWNER_PID table[1]
Definition: udpmib.h:48
DWORD dwNumEntries
Definition: udpmib.h:34
MIB_UDPROW_OWNER_MODULE table[1]
Definition: udpmib.h:71
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 *))
static int UdpTableSorter(const void *a, const void *b)
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:736
MIB_UDPROW table[1]
Definition: udpmib.h:35
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
struct _MIB_UDPROW_OWNER_MODULE MIB_UDPROW_OWNER_MODULE
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define AF_INET
Definition: tcpip.h:117
#define UNIMPLEMENTED
Definition: debug.h:115
PVOID getUdpTable(CLASS_TABLE Class)
#define HeapFree(x, y, z)
Definition: compat.h:735
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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 }
#define TRACE(s)
Definition: solgame.cpp:4

◆ 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 }
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
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)
3402  return ERROR_INVALID_PARAMETER;
3403 
3404  if (dwFamily != AF_INET && dwFamily != AF_INET6)
3405  return ERROR_INVALID_PARAMETER;
3406 
3407  return 0L;
3408 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define L(x)
Definition: ntvdm.h:50
#define FIXME(fmt,...)
Definition: debug.h:111
#define AF_INET6
Definition: winsock.h:369
#define AF_INET
Definition: tcpip.h:117

◆ 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)
1617  return ERROR_INVALID_PARAMETER;
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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define NO_ERROR
Definition: dderror.h:5
void consumeInterfaceName(const char *ifname)
const char * getInterfaceNameByIndex(DWORD index)
DWORD getInterfaceStatsByName(const char *name, PMIB_IFROW entry)
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
DWORD getInterfaceEntryByIndex(DWORD index, PMIB_IFROW entry)
#define ERROR_INVALID_DATA
Definition: winerror.h:116
Definition: name.c:38
DWORD dwIndex
Definition: ifmib.h:38
GLuint const GLchar * name
Definition: glext.h:6031

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),
1699  IfTableSorter);
1700  ret = NO_ERROR;
1701  }
1702  free(table);
1703  }
1704  else
1706  }
1707  }
1708  TRACE("returning %ld\n", ret);
1709  return ret;
1710 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
MIB_IFROW table[1]
Definition: ifmib.h:66
InterfaceIndexTable * getInterfaceIndexTable(void)
#define free
Definition: debug_ros.c:5
#define NO_ERROR
Definition: dderror.h:5
static int IfTableSorter(const void *a, const void *b)
void __cdecl qsort(_Inout_updates_bytes_(_NumOfElements *_SizeOfElements) void *_Base, _In_ size_t _NumOfElements, _In_ size_t _SizeOfElements, _In_ int(__cdecl *_PtFuncCompare)(const void *, const void *))
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
struct _MIB_IFTABLE MIB_IFTABLE
DWORD getNumInterfaces(void)
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
DWORD dwNumEntries
Definition: ifmib.h:65
DWORD WINAPI GetIfEntry(PMIB_IFROW pIfRow)
unsigned int ULONG
Definition: retypes.h:1
DWORD dwIndex
Definition: ifmib.h:38
struct _MIB_IFROW MIB_IFROW
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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 }
RouteTable * getRouteTable(void)
DWORD getNumRoutes(void)
GLuint index
Definition: glext.h:6031
#define GetProcessHeap()
Definition: compat.h:736
unsigned long DWORD
Definition: ntddk_ex.h:95
#define HeapFree(x, y, z)
Definition: compat.h:735

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 ERROR_INVALID_PARAMETER
Definition: compat.h:101
IP_ADAPTER_INDEX_MAP Adapter[1]
Definition: ipexport.h:152
#define free
Definition: debug_ros.c:5
#define NO_ERROR
Definition: dderror.h:5
InterfaceIndexTable * getNonLoopbackInterfaceIndexTable(void)
DWORD getNumNonLoopbackInterfaces(void)
void consumeInterfaceName(const char *ifname)
const char * getInterfaceNameByIndex(DWORD index)
#define L(x)
Definition: ntvdm.h:50
WCHAR Name[MAX_ADAPTER_NAME]
Definition: ipexport.h:147
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
struct _IP_ADAPTER_INDEX_MAP IP_ADAPTER_INDEX_MAP
Definition: name.c:38
#define MAX_ADAPTER_NAME
Definition: ipexport.h:143
unsigned int ULONG
Definition: retypes.h:1
struct _IP_INTERFACE_INFO IP_INTERFACE_INFO
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
GLuint const GLchar * name
Definition: glext.h:6031

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)
3428  return ERROR_INVALID_PARAMETER;
3429 
3430  result = RtlStringFromGUID(pInterfaceGUID, &GuidString);
3431 
3432  if (!NT_SUCCESS(result))
3433  {
3434  // failed to convert guid to string
3435  return RtlNtStatusToDosError(result);
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 
3447  result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, szKeyName, 0, KEY_READ, &hKey);
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 
3457  RegCloseKey(hKey);
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_INVALID_PARAMETER
Definition: compat.h:101
static PWSTR GuidString
Definition: apphelp.c:93
#define ERROR_SUCCESS
Definition: deptool.c:10
HRESULT hr
Definition: shlfolder.c:183
GLuint64EXT * result
Definition: glext.h:11304
#define KEY_READ
Definition: nt_native.h:1023
#define ERROR_BUFFER_OVERFLOW
Definition: winerror.h:185
#define L(x)
Definition: ntvdm.h:50
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
STRSAFEAPI StringCbPrintfW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:557
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4120
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
LONG HRESULT
Definition: typedefs.h:79
#define ERROR_NO_DATA
Definition: winerror.h:284
#define MAX_PATH
Definition: compat.h:34
unsigned long DWORD
Definition: ntddk_ex.h:95
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define MAX_INTERFACE_NAME_LEN
Definition: ifmib.h:31
#define ERROR_MORE_DATA
Definition: dderror.h:13
FxAutoRegKey hKey
NTSYSAPI NTSTATUS WINAPI RtlStringFromGUID(REFGUID, PUNICODE_STRING)
#define NULL
Definition: types.h:112
#define ERROR_NOT_FOUND
Definition: winerror.h:690
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3356
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define RegCloseKey(hKey)
Definition: registry.h:47
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
#define REG_SZ
Definition: layer.c:22

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,
1868  sizeof(MIB_IPADDRROW), IpAddrTableSorter);
1869  ret = NO_ERROR;
1870  }
1871  free(table);
1872  }
1873  else
1875  }
1876  }
1877  TRACE("returning %ld\n", ret);
1878  return ret;
1879 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
struct _MIB_IPADDRTABLE MIB_IPADDRTABLE
InterfaceIndexTable * getInterfaceIndexTable(void)
#define free
Definition: debug_ros.c:5
static int IpAddrTableSorter(const void *a, const void *b)
#define NO_ERROR
Definition: dderror.h:5
DWORD dwReasmSize
Definition: ipmib.h:40
DWORD getInterfaceBCastAddrByIndex(DWORD index)
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 *))
unsigned short wType
Definition: ipmib.h:42
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
DWORD dwBCastAddr
Definition: ipmib.h:39
DWORD getNumInterfaces(void)
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD getInterfaceMaskByIndex(DWORD index)
unsigned short unused1
Definition: ipmib.h:41
int ret
DWORD dwMask
Definition: ipmib.h:38
struct _MIB_IPADDRROW MIB_IPADDRROW
DWORD dwNumEntries
Definition: ipmib.h:47
IF_INDEX dwIndex
Definition: ipmib.h:37
unsigned int ULONG
Definition: retypes.h:1
DWORD dwAddr
Definition: ipmib.h:36
DWORD getInterfaceIPAddrByIndex(DWORD index)
MIB_IPADDRROW table[1]
Definition: ipmib.h:48
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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 }
#define L(x)
Definition: ntvdm.h:50
#define FIXME(fmt,...)
Definition: debug.h:111

◆ 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  }
1982  HeapFree(GetProcessHeap(), 0, table);
1983  }
1984  else
1986  }
1987  }
1988  TRACE("returning %ld\n", ret);
1989  return ret;
1990 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
DWORD dwForwardMetric4
Definition: ipmib.h:91
DWORD dwForwardType
Definition: ipmib.h:78
RouteTable * getRouteTable(void)
DWORD dwForwardNextHopAS
Definition: ipmib.h:87
DWORD dwForwardMask
Definition: ipmib.h:72
DWORD dwForwardMetric5
Definition: ipmib.h:92
#define NO_ERROR
Definition: dderror.h:5
DWORD dwForwardMetric3
Definition: ipmib.h:90
DWORD dwForwardAge
Definition: ipmib.h:86
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 *))
DWORD dwForwardMetric2
Definition: ipmib.h:89
DWORD getNumRoutes(void)
IF_INDEX dwForwardIfIndex
Definition: ipmib.h:75
#define TRACE(s)
Definition: solgame.cpp:4
DWORD dwForwardNextHop
Definition: ipmib.h:74
#define GetProcessHeap()
Definition: compat.h:736
static int IpForwardTableSorter(const void *a, const void *b)
DWORD dwNumEntries
Definition: ipmib.h:97
DWORD dwForwardDest
Definition: ipmib.h:71
unsigned long DWORD
Definition: ntddk_ex.h:95
MIB_IPFORWARDROW table[1]
Definition: ipmib.h:98
int ret
DWORD dwForwardPolicy
Definition: ipmib.h:73
struct _MIB_IPFORWARDTABLE MIB_IPFORWARDTABLE
struct _MIB_IPFORWARDROW MIB_IPFORWARDROW
unsigned int ULONG
Definition: retypes.h:1
DWORD dwForwardProto
Definition: ipmib.h:83
DWORD dwForwardMetric1
Definition: ipmib.h:88
#define HeapFree(x, y, z)
Definition: compat.h:735
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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,
2053  sizeof(MIB_IPNETROW), IpNetTableSorter);
2054  ret = NO_ERROR;
2055  }
2056  HeapFree(GetProcessHeap(), 0, table);
2057  }
2058  }
2059  }
2060  TRACE("returning %d\n", ret);
2061  return ret;
2062 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
DWORD getNumArpEntries(void)
struct _MIB_IPNETTABLE MIB_IPNETTABLE
#define NO_ERROR
Definition: dderror.h:5
void __cdecl qsort(_Inout_updates_bytes_(_NumOfElements *_SizeOfElements) void *_Base, _In_ size_t _NumOfElements, _In_ size_t _SizeOfElements, _In_ int(__cdecl *_PtFuncCompare)(const void *, const void *))
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:736
unsigned long DWORD
Definition: ntddk_ex.h:95
PMIB_IPNETTABLE getArpTable(void)
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
MIB_IPNETROW table[1]
Definition: ipmib.h:128
unsigned int ULONG
Definition: retypes.h:1
static int IpNetTableSorter(const void *a, const void *b)
#define HeapFree(x, y, z)
Definition: compat.h:735
DWORD dwNumEntries
Definition: ipmib.h:127
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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 }
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD getIPStats(PMIB_IPSTATS stats, DWORD family)
int ret

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)
2130  return ERROR_INVALID_PARAMETER;
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 */
2146  regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
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  }
2196  RegCloseKey(hKey);
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;
2236  regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2237  "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ, &hKey);
2238  if (regReturn != ERROR_SUCCESS)
2239  regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
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);
2247  RegCloseKey(hKey);
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 }
FxIoTarget * pTarget
Definition: fxdeviceapi.cpp:97
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
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 riCount
Definition: resinfo.h:25
#define ERROR_SUCCESS
Definition: deptool.c:10
#define KEY_READ
Definition: nt_native.h:1023
#define TRUE
Definition: types.h:120
#define ERROR_BUFFER_OVERFLOW
Definition: winerror.h:185
VOID disposeResInfo(PIPHLP_RES_INFO InfoPtr)
Definition: resinfo.c:60
struct _IP_ADDR_STRING * Next
Definition: iptypes.h:46
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3321
#define NO_ERROR
Definition: dderror.h:5
IP_ADDR_STRING * DnsList
Definition: resinfo.h:26
unsigned char * LPBYTE
Definition: typedefs.h:53
long LONG
Definition: pedump.c:60
char DomainName[MAX_DOMAIN_NAME_LEN+4]
Definition: iptypes.h:82
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
#define CopyMemory
Definition: winbase.h:1668
UINT NodeType
Definition: iptypes.h:85
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
PIPHLP_RES_INFO getResInfo()
Definition: resinfo.c:54
char HostName[MAX_HOSTNAME_LEN+4]
Definition: iptypes.h:81
#define HYBRID_NODETYPE
Definition: iptypes.h:39
FxAutoRegKey hKey
#define NULL
Definition: types.h:112
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
IP_ADDR_STRING DnsServerList
Definition: iptypes.h:84
#define memset(x, y, z)
Definition: compat.h:39
char ScopeId[MAX_SCOPE_ID_LEN+4]
Definition: iptypes.h:86
BYTE * PBYTE
Definition: pedump.c:66
#define RegCloseKey(hKey)
Definition: registry.h:47
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
struct _IP_ADDR_STRING IP_ADDR_STRING
#define REG_SZ
Definition: layer.c:22

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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define NO_ERROR
Definition: dderror.h:5
#define TRACE(s)
Definition: solgame.cpp:4
DWORD getNumInterfaces(void)
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret

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 {
2291  HANDLE Process;
2292  DWORD FileLen, PathLen, Error;
2295 
2296  if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
2297  IsBadWritePtr(Buffer, *pdwSize))
2298  {
2299  return ERROR_INVALID_PARAMETER;
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 
2333  if (Error == ERROR_PARTIAL_COPY)
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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define CloseHandle
Definition: compat.h:739
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
Definition: except.c:881
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:166
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1040
#define NO_ERROR
Definition: dderror.h:5
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define L(x)
Definition: ntvdm.h:50
#define FALSE
Definition: types.h:117
#define ERROR_PARTIAL_COPY
Definition: winerror.h:303
#define GetModuleFileNameExW(w, x, y, z)
Definition: compat.h:922
Definition: bufpool.h:45
void * PVOID
Definition: retypes.h:9
DWORD WINAPI GetModuleBaseNameW(HANDLE hProcess, HMODULE hModule, LPWSTR lpBaseName, DWORD nSize)
Definition: psapi.c:914
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MAX_PATH
Definition: compat.h:34
unsigned long DWORD
Definition: ntddk_ex.h:95
BOOL Error
Definition: chkdsk.c:66
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
struct _TCPIP_OWNER_MODULE_BASIC_INFO TCPIP_OWNER_MODULE_BASIC_INFO
HANDLE WINAPI OpenProcess(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
Definition: proc.c:1227
PRTL_UNICODE_STRING_BUFFER Path
#define NULL
Definition: types.h:112
#define ERROR_NOT_FOUND
Definition: winerror.h:690
#define PROCESS_VM_READ
Definition: pstypes.h:161
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
Definition: File.h:15
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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  {
2376  DWORD ProcessId;
2377  DWORD ServiceTag;
2378  DWORD TagType;
2379  PWSTR Buffer;
2380  } ServiceQuery;
2381 
2382  if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
2383  IsBadWritePtr(Buffer, *pdwSize))
2384  {
2385  return ERROR_INVALID_PARAMETER;
2386  }
2387 
2388  /* First, secure (avoid injections) load advapi32.dll */
2389  Size = GetSystemDirectoryW(SysDir, MAX_PATH);
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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ProcessId
Definition: fatprocs.h:2709
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
Definition: except.c:881
#define ERROR_SUCCESS
Definition: deptool.c:10
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
uint16_t * PWSTR
Definition: typedefs.h:56
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1040
#define NO_ERROR
Definition: dderror.h:5
#define DWORD
Definition: nt_native.h:44
STRSAFEAPI StringCchCatW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:325
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define L(x)
Definition: ntvdm.h:50
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define UNICODE_NULL
Definition: bufpool.h:45
void * PVOID
Definition: retypes.h:9
__wchar_t WCHAR
Definition: xmlstorage.h:180
LONG HRESULT
Definition: typedefs.h:79
#define MAX_PATH
Definition: compat.h:34
unsigned long DWORD
Definition: ntddk_ex.h:95
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
struct _TCPIP_OWNER_MODULE_BASIC_INFO TCPIP_OWNER_MODULE_BASIC_INFO
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
UINT WINAPI GetSystemDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2313
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
unsigned int ULONG
Definition: retypes.h:1
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:838
#define GetProcAddress(x, y)
Definition: compat.h:753
static DWORD ServiceTag
Definition: database.c:34
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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)
Definition: bufpool.h:45
ULONGLONG OwningModuleInfo[TCPIP_OWNING_MODULE_SIZE]
Definition: tcpmib.h:127
unsigned long DWORD
Definition: ntddk_ex.h:95
static DWORD GetOwnerModuleFromTagEntry(DWORD OwningPid, DWORD OwningTag, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)

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
static DWORD GetOwnerModuleFromPidEntry(DWORD OwningPid, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)
Definition: bufpool.h:45
unsigned long DWORD
Definition: ntddk_ex.h:95
static DWORD GetOwnerModuleFromTagEntry(DWORD OwningPid, DWORD OwningTag, TCPIP_OWNER_MODULE_INFO_CLASS Class, PVOID Buffer, PDWORD pdwSize)

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)
2568  return ERROR_INVALID_PARAMETER;
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)
2578  return ERROR_INVALID_PARAMETER;
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 ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NOERROR
Definition: winerror.h:2354
#define KEY_READ
Definition: nt_native.h:1023
#define TRUE
Definition: types.h:120
#define ERROR_BUFFER_OVERFLOW
Definition: winerror.h:185
#define CP_ACP
Definition: compat.h:109
#define ZeroMemory
Definition: winbase.h:1670
const char * getInterfaceNameByIndex(DWORD index)
#define L(x)
Definition: ntvdm.h:50
#define FALSE
Definition: types.h:117
#define GetProcessHeap()
Definition: compat.h:736
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4120
__wchar_t WCHAR
Definition: xmlstorage.h:180
struct _IP_PER_ADAPTER_INFO IP_PER_ADAPTER_INFO
unsigned long DWORD
Definition: ntddk_ex.h:95
static void CreateNameServerListEnumNamesFunc(PWCHAR Interface, PWCHAR Server, PVOID Data)
#define NULL
Definition: types.h:112
#define MultiByteToWideChar
Definition: compat.h:110
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100
struct tagContext Context
Definition: acpixf.h:1038
LSTATUS EnumNameServers(HKEY RegHandle, LPWSTR Interface, PVOID Data, EnumNameServersFunc cb)
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3356
#define HeapFree(x, y, z)
Definition: compat.h:735
#define RegCloseKey(hKey)
Definition: registry.h:47
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12

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 }
unsigned int BOOL
Definition: ntddk_ex.h:94
#define FIXME(fmt,...)
Definition: debug.h:111
#define TRACE(s)
Definition: solgame.cpp:4

◆ GetTcpStatistics()

DWORD WINAPI GetTcpStatistics ( PMIB_TCPSTATS  pStats)

Definition at line 2680 of file iphlpapi_main.c.

2681 {
2682  return GetTcpStatisticsEx(pStats, PF_INET);
2683 }
#define PF_INET
Definition: winsock.h:373
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 }
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD getTCPStats(MIB_TCPSTATS *stats, DWORD family)
int ret

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 }
DWORD WINAPI GetExtendedTcpTable(PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved)
#define AF_INET
Definition: tcpip.h:117

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 }
#define PF_INET
Definition: winsock.h:373
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)
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret

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 }
DWORD WINAPI GetExtendedUdpTable(PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved)
#define AF_INET
Definition: tcpip.h:117

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 }
#define TRACE(s)
Definition: solgame.cpp:4
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100

◆ 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
int ret
struct _MIB_IFROW * PMIB_IFROW
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204

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 }
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
int ret
struct _MIB_IPADDRROW * PMIB_IPADDRROW
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204

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
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
DWORD dwForwardNextHop
Definition: ipmib.h:74
DWORD dwForwardDest
Definition: ipmib.h:71
int ret
DWORD dwForwardPolicy
Definition: ipmib.h:73
DWORD dwForwardProto
Definition: ipmib.h:83
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204

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
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
int ret
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204

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)
2822  return ERROR_INVALID_PARAMETER;
2823 
2824  /* Maybe we should do this in DllMain */
2826  return ERROR_PROC_NOT_FOUND;
2827 
2828  if (DhcpReleaseIpAddressLease(AdapterInfo->Index))
2830  else
2832 
2833  DhcpCApiCleanup();
2834 
2835  return Status;
2836 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define ERROR_SUCCESS
Definition: deptool.c:10
DWORD APIENTRY DhcpReleaseIpAddressLease(DWORD AdapterIndex)
Definition: dhcpcsvc.c:139
Status
Definition: gdiplustypes.h:24
unsigned long DWORD
Definition: ntddk_ex.h:95
IN PVOID IN PVOID IN USHORT Version
Definition: pci.h:361
DWORD APIENTRY DhcpCApiInitialize(LPDWORD Version)
Definition: dhcpcsvc.c:26
#define ERROR_PROC_NOT_FOUND
Definition: winerror.h:199
VOID APIENTRY DhcpCApiCleanup(VOID)
Definition: dhcpcsvc.c:71

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)
2856  return ERROR_INVALID_PARAMETER;
2857 
2858  /* Maybe we should do this in DllMain */
2860  return ERROR_PROC_NOT_FOUND;
2861 
2862  if (DhcpRenewIpAddressLease(AdapterInfo->Index))
2864  else
2866 
2867  DhcpCApiCleanup();
2868 
2869  return Status;
2870 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define ERROR_SUCCESS
Definition: deptool.c:10
Status
Definition: gdiplustypes.h:24
unsigned long DWORD
Definition: ntddk_ex.h:95
IN PVOID IN PVOID IN USHORT Version
Definition: pci.h:361
DWORD APIENTRY DhcpCApiInitialize(LPDWORD Version)
Definition: dhcpcsvc.c:26
#define ERROR_PROC_NOT_FOUND
Definition: winerror.h:199
DWORD APIENTRY DhcpRenewIpAddressLease(DWORD AdapterIndex)
Definition: dhcpcsvc.c:165
VOID APIENTRY DhcpCApiCleanup(VOID)
Definition: dhcpcsvc.c:71

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)
3486  return ERROR_INVALID_PARAMETER;
3487 
3488  return GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
3489 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define ERROR_SUCCESS
Definition: deptool.c:10
#define SetLastError(x)
Definition: compat.h:752
DWORD GetInterfaceNameInternal(_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen)
#define NULL
Definition: types.h:112

◆ 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 }
GLuint64EXT * result
Definition: glext.h:11304
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:752
DWORD GetInterfaceNameInternal(_In_ const GUID *pInterfaceGUID, _Out_writes_bytes_to_(*pOutBufLen, *pOutBufLen) PWCHAR pInterfaceName, _Inout_ PULONG pOutBufLen)
#define ERROR_NOT_FOUND
Definition: winerror.h:690
#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 }
#define L(x)
Definition: ntvdm.h:50
#define FIXME(fmt,...)
Definition: debug.h:111

◆ 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);
2893  if (overlapped) ((IO_STATUS_BLOCK *) overlapped)->Status = STATUS_PENDING;
2894  return ERROR_IO_PENDING;
2895 }
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define ERROR_IO_PENDING
Definition: dderror.h:15
#define FIXME(fmt,...)
Definition: debug.h:111
#define STATUS_PENDING
Definition: ntstatus.h:82
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED * overlapped
Definition: sock.c:82
_In_ HANDLE Handle
Definition: extypes.h:390

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 }
#define FIXME(fmt,...)
Definition: debug.h:111
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED * overlapped
Definition: sock.c:82
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100
_In_ HANDLE Handle
Definition: extypes.h:390

◆ 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)))
2941  return ERROR_INVALID_PARAMETER;
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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
Definition: except.c:881
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
ULONG IPAddr
Definition: pfhook.h:35
unsigned int ULONG
Definition: retypes.h:1
#define IOCTL_QUERY_IP_HW_ADDRESS
Definition: tcpioctl.h:40
DWORD TCPSendIoctl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, PULONG pInBufferSize, LPVOID lpOutBuffer, PULONG pOutBufferSize)

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 }
#define FIXME(fmt,...)
Definition: debug.h:111
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100

◆ 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 }
#define L(x)
Definition: ntvdm.h:50
#define FIXME(fmt,...)
Definition: debug.h:111

◆ SetIpNetEntry()

DWORD WINAPI SetIpNetEntry ( PMIB_IPNETROW  pArpEntry)

Definition at line 3007 of file iphlpapi_main.c.

3008 {
3009  HANDLE tcpFile;
3010  NTSTATUS status;
3013  TDIEntityID id;
3014  DWORD returnSize;
3015  PMIB_IPNETROW arpBuff;
3016 
3017  if (!pArpEntry)
3018  return ERROR_INVALID_PARAMETER;
3019 
3021  return ERROR_NOT_SUPPORTED;
3022 
3023  if (!NT_SUCCESS(getNthIpEntity( tcpFile, pArpEntry->dwIndex, &id )))
3024  {
3025  closeTcpFile(tcpFile);
3026  return ERROR_INVALID_PARAMETER;
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
3053  return ERROR_INVALID_PARAMETER;
3054 }
TDIEntityID toi_entity
Definition: tdiinfo.h:74
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define AT_ENTITY
Definition: tdiinfo.h:41
struct _MIB_IPNETROW * PMIB_IPNETROW
ULONG toi_class
Definition: tdiinfo.h:75
unsigned char Buffer[1]
Definition: tdiinfo.h:97
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS getNthIpEntity(HANDLE tcpFile, DWORD index, TDIEntityID *ent)
#define NO_ERROR
Definition: dderror.h:5
#define IP_MIB_ARPTABLE_ENTRY_ID
Definition: tcpioctl.h:54
#define FILE_READ_DATA
Definition: nt_native.h:628
ULONG toi_id
Definition: tdiinfo.h:77
TCP_REQUEST_SET_INFORMATION_EX Req
#define FILE_WRITE_DATA
Definition: nt_native.h:631
ULONG tei_entity
Definition: tdiinfo.h:31
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
ULONG tei_instance
Definition: tdiinfo.h:32
unsigned long DWORD
Definition: ntddk_ex.h:95
#define TCP_REQUEST_SET_INFORMATION_INIT
VOID closeTcpFile(HANDLE h)
Definition: handle.c:43
#define IOCTL_TCP_SET_INFORMATION_EX
Definition: tditest.h:112
struct _MIB_IPNETROW MIB_IPNETROW
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
#define NULL
Definition: types.h:112
#define INFO_TYPE_PROVIDER
Definition: tdiinfo.h:69
NTSTATUS openTcpFile(PHANDLE tcpFile, ACCESS_MASK DesiredAccess)
Definition: handle.c:12
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100
GLenum GLuint id
Definition: glext.h:5579
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
DWORD dwIndex
Definition: ipmib.h:114
static SERVICE_STATUS status
Definition: service.c:31
ULONG toi_type
Definition: tdiinfo.h:76
#define INFO_CLASS_PROTOCOL
Definition: tdiinfo.h:65
Definition: ps.c:97

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 }
#define FIXME(fmt,...)
Definition: debug.h:111

◆ 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 }
#define FIXME(fmt,...)
Definition: debug.h:111

◆ 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 }
#define FIXME(fmt,...)
Definition: debug.h:111

◆ 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 dwRemoteAddr
Definition: tcpmib.h:60
#define b
Definition: ke_i.h:79
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
DWORD dwLocalAddr
Definition: tcpmib.h:58
int ret
DWORD dwRemotePort
Definition: tcpmib.h:61