ReactOS  0.4.15-dev-3324-gda4e15f
iphlpapi.h File Reference
#include <iprtrmib.h>
#include <ipexport.h>
#include <iptypes.h>
#include <netioapi.h>
Include dependency graph for iphlpapi.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

DWORD WINAPI AddIPAddress (IPAddr, IPMask, DWORD, PULONG, PULONG)
 
DWORD WINAPI CreateIpForwardEntry (PMIB_IPFORWARDROW)
 
DWORD WINAPI CreateIpNetEntry (PMIB_IPNETROW)
 
DWORD WINAPI CreateProxyArpEntry (DWORD, DWORD, DWORD)
 
DWORD WINAPI DeleteIPAddress (ULONG)
 
DWORD WINAPI DeleteIpForwardEntry (PMIB_IPFORWARDROW)
 
DWORD WINAPI DeleteIpNetEntry (PMIB_IPNETROW)
 
DWORD WINAPI DeleteProxyArpEntry (DWORD, DWORD, DWORD)
 
DWORD WINAPI EnableRouter (HANDLE *, OVERLAPPED *)
 
DWORD WINAPI FlushIpNetTable (DWORD)
 
DWORD WINAPI GetAdapterIndex (LPWSTR, PULONG)
 
DWORD WINAPI GetAdaptersInfo (PIP_ADAPTER_INFO, PULONG)
 
DWORD WINAPI GetBestInterface (IPAddr, PDWORD)
 
DWORD WINAPI GetBestRoute (DWORD, DWORD, PMIB_IPFORWARDROW)
 
DWORD WINAPI GetExtendedTcpTable (PVOID, PDWORD, BOOL, ULONG, TCP_TABLE_CLASS, ULONG)
 
DWORD WINAPI GetExtendedUdpTable (PVOID, PDWORD, BOOL, ULONG, UDP_TABLE_CLASS, ULONG)
 
DWORD WINAPI GetFriendlyIfIndex (DWORD)
 
DWORD WINAPI GetIcmpStatistics (PMIB_ICMP)
 
DWORD WINAPI GetIfEntry (PMIB_IFROW)
 
DWORD WINAPI GetIfTable (PMIB_IFTABLE, PULONG, BOOL)
 
DWORD WINAPI GetInterfaceInfo (PIP_INTERFACE_INFO, PULONG)
 
DWORD WINAPI GetIpAddrTable (PMIB_IPADDRTABLE, PULONG, BOOL)
 
DWORD WINAPI GetIpForwardTable (PMIB_IPFORWARDTABLE, PULONG, BOOL)
 
DWORD WINAPI GetIpNetTable (PMIB_IPNETTABLE, PULONG, BOOL)
 
DWORD WINAPI GetIpStatistics (PMIB_IPSTATS)
 
DWORD WINAPI GetIpStatisticsEx (PMIB_IPSTATS, DWORD)
 
DWORD WINAPI GetNetworkParams (PFIXED_INFO, PULONG)
 
DWORD WINAPI GetNumberOfInterfaces (PDWORD)
 
DWORD WINAPI GetOwnerModuleFromTcpEntry (PMIB_TCPROW_OWNER_MODULE, TCPIP_OWNER_MODULE_INFO_CLASS, PVOID, PDWORD)
 
DWORD WINAPI GetOwnerModuleFromUdpEntry (PMIB_UDPROW_OWNER_MODULE, TCPIP_OWNER_MODULE_INFO_CLASS, PVOID, PDWORD)
 
DWORD WINAPI GetPerAdapterInfo (ULONG, PIP_PER_ADAPTER_INFO, PULONG)
 
BOOL WINAPI GetRTTAndHopCount (IPAddr, PULONG, ULONG, PULONG)
 
DWORD WINAPI GetTcpStatistics (PMIB_TCPSTATS)
 
DWORD WINAPI GetTcpTable (PMIB_TCPTABLE, PDWORD, BOOL)
 
DWORD WINAPI GetUniDirectionalAdapterInfo (PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS, PULONG)
 
DWORD WINAPI GetUdpStatistics (PMIB_UDPSTATS)
 
DWORD WINAPI GetUdpTable (PMIB_UDPTABLE, PDWORD, BOOL)
 
DWORD WINAPI IpReleaseAddress (PIP_ADAPTER_INDEX_MAP)
 
DWORD WINAPI IpRenewAddress (PIP_ADAPTER_INDEX_MAP)
 
DWORD WINAPI NotifyAddrChange (PHANDLE, LPOVERLAPPED)
 
DWORD WINAPI NotifyRouteChange (PHANDLE, LPOVERLAPPED)
 
DWORD WINAPI SendARP (IPAddr, IPAddr, PULONG, PULONG)
 
DWORD WINAPI SetIfEntry (PMIB_IFROW)
 
DWORD WINAPI SetIpForwardEntry (PMIB_IPFORWARDROW)
 
DWORD WINAPI SetIpNetEntry (PMIB_IPNETROW)
 
DWORD WINAPI SetIpStatistics (PMIB_IPSTATS)
 
DWORD WINAPI SetIpTTL (UINT)
 
DWORD WINAPI SetTcpEntry (PMIB_TCPROW)
 
DWORD WINAPI UnenableRouter (OVERLAPPED *, LPDWORD)
 

Function Documentation

◆ AddIPAddress()

DWORD WINAPI AddIPAddress ( IPAddr  ,
IPMask  ,
DWORD  ,
PULONG  ,
PULONG   
)

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

◆ CreateIpForwardEntry()

DWORD WINAPI CreateIpForwardEntry ( PMIB_IPFORWARDROW  )

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  )

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

◆ CreateProxyArpEntry()

DWORD WINAPI CreateProxyArpEntry ( DWORD  ,
DWORD  ,
DWORD   
)

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  )

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  )

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  )

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

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

◆ EnableRouter()

DWORD WINAPI EnableRouter ( HANDLE ,
OVERLAPPED  
)

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  )

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

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

◆ GetAdaptersInfo()

DWORD WINAPI GetAdaptersInfo ( PIP_ADAPTER_INFO  ,
PULONG   
)

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)
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
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 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  ,
PDWORD   
)

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)

◆ GetBestRoute()

DWORD WINAPI GetBestRoute ( DWORD  ,
DWORD  ,
PMIB_IPFORWARDROW   
)

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:595
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:594
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13

Referenced by GetBestInterface().

◆ GetExtendedTcpTable()

DWORD WINAPI GetExtendedTcpTable ( PVOID  ,
PDWORD  ,
BOOL  ,
ULONG  ,
TCP_TABLE_CLASS  ,
ULONG   
)

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:595
#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:594
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  ,
PDWORD  ,
BOOL  ,
ULONG  ,
UDP_TABLE_CLASS  ,
ULONG   
)

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:595
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:594
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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

◆ GetFriendlyIfIndex()

DWORD WINAPI GetFriendlyIfIndex ( DWORD  )

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  )

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

◆ GetIfEntry()

DWORD WINAPI GetIfEntry ( PMIB_IFROW  )

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 
1619  name = getInterfaceNameByIndex(pIfRow->dwIndex);
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
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  ,
PULONG  ,
BOOL   
)

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
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 WINAPI GetIfEntry(PMIB_IFROW pIfRow)
unsigned int ULONG
Definition: retypes.h:1
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().

◆ GetInterfaceInfo()

DWORD WINAPI GetInterfaceInfo ( PIP_INTERFACE_INFO  ,
PULONG   
)

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
#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 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)
static const WCHAR L[]
Definition: oid.c:1250
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().

◆ GetIpAddrTable()

DWORD WINAPI GetIpAddrTable ( PMIB_IPADDRTABLE  ,
PULONG  ,
BOOL   
)

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 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 *))
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
DWORD getNumInterfaces(void)
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD getInterfaceMaskByIndex(DWORD index)
int ret
struct _MIB_IPADDRROW MIB_IPADDRROW
unsigned int ULONG
Definition: retypes.h:1
DWORD getInterfaceIPAddrByIndex(DWORD index)
#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().

◆ GetIpForwardTable()

DWORD WINAPI GetIpForwardTable ( PMIB_IPFORWARDTABLE  ,
PULONG  ,
BOOL   
)

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
RouteTable * getRouteTable(void)
#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 *))
DWORD getNumRoutes(void)
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:595
static int IpForwardTableSorter(const void *a, const void *b)
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
struct _MIB_IPFORWARDTABLE MIB_IPFORWARDTABLE
struct _MIB_IPFORWARDROW MIB_IPFORWARDROW
unsigned int ULONG
Definition: retypes.h:1
#define HeapFree(x, y, z)
Definition: compat.h:594
#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  ,
PULONG  ,
BOOL   
)

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:595
unsigned long DWORD
Definition: ntddk_ex.h:95
PMIB_IPNETTABLE getArpTable(void)
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned int ULONG
Definition: retypes.h:1
static int IpNetTableSorter(const void *a, const void *b)
#define HeapFree(x, y, z)
Definition: compat.h:594
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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

◆ GetIpStatistics()

DWORD WINAPI GetIpStatistics ( PMIB_IPSTATS  )

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

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

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
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
unsigned char * LPBYTE
Definition: typedefs.h:53
long LONG
Definition: pedump.c:60
#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:1662
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
PIPHLP_RES_INFO getResInfo()
Definition: resinfo.c:54
#define HYBRID_NODETYPE
Definition: iptypes.h:39
FxAutoRegKey hKey
#define NULL
Definition: types.h:112
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define memset(x, y, z)
Definition: compat.h:39
BYTE * PBYTE
Definition: pedump.c:66
#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  )

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

◆ GetOwnerModuleFromTcpEntry()

DWORD WINAPI GetOwnerModuleFromTcpEntry ( PMIB_TCPROW_OWNER_MODULE  ,
TCPIP_OWNER_MODULE_INFO_CLASS  ,
PVOID  ,
PDWORD   
)

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
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  ,
TCPIP_OWNER_MODULE_INFO_CLASS  ,
PVOID  ,
PDWORD   
)

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 }
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  ,
PIP_PER_ADAPTER_INFO  ,
PULONG   
)

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:1664
const char * getInterfaceNameByIndex(DWORD index)
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
#define FALSE
Definition: types.h:117
#define GetProcessHeap()
Definition: compat.h:595
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 const WCHAR L[]
Definition: oid.c:1250
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:1034
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:594
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  ,
PULONG  ,
ULONG  ,
PULONG   
)

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  )

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

◆ GetTcpTable()

DWORD WINAPI GetTcpTable ( PMIB_TCPTABLE  ,
PDWORD  ,
BOOL   
)

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  )

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

◆ GetUdpTable()

DWORD WINAPI GetUdpTable ( PMIB_UDPTABLE  ,
PDWORD  ,
BOOL   
)

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

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

◆ IpReleaseAddress()

DWORD WINAPI IpReleaseAddress ( PIP_ADAPTER_INDEX_MAP  )

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  )

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

◆ NotifyAddrChange()

DWORD WINAPI NotifyAddrChange ( PHANDLE  ,
LPOVERLAPPED   
)

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:590
#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  ,
LPOVERLAPPED   
)

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  ,
IPAddr  ,
PULONG  ,
PULONG   
)

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

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  )

Definition at line 2989 of file iphlpapi_main.c.

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

◆ SetIpNetEntry()

DWORD WINAPI SetIpNetEntry ( PMIB_IPNETROW  )

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

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  )

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  )

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

◆ UnenableRouter()

DWORD WINAPI UnenableRouter ( OVERLAPPED ,
LPDWORD   
)

Definition at line 3140 of file iphlpapi_main.c.

3141 {
3142  FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped,
3143  lpdwEnableCount);
3144  return ERROR_NOT_SUPPORTED;
3145 }
#define FIXME(fmt,...)
Definition: debug.h:111
#define ERROR_NOT_SUPPORTED
Definition: compat.h:100