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_CONTEXT *	PNAME_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

typedef struct _NAME_SERVER_LIST_CONTEXT NAME_SERVER_LIST_CONTEXT

PNAME_SERVER_LIST_CONTEXT

typedef struct _NAME_SERVER_LIST_CONTEXT * PNAME_SERVER_LIST_CONTEXT

Function Documentation

AddIPAddress()

DWORD WINAPI AddIPAddress	(	IPAddr	Address,
		IPMask	Netmask,
		DWORD	IfIndex,
		PULONG	NteContext,
		PULONG	NteInstance
	)

Definition at line 67 of file iphlpapi_main.c.

{
    return RtlNtStatusToDosError(addIPAddress(Address, Netmask, IfIndex, NteContext, NteInstance));
}

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

AllocateAndGetIfTableFromStack()

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

Definition at line 100 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("ppIfTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n", ppIfTable,
   (DWORD)bOrder, heap, flags);
  if (!ppIfTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;
 
    *ppIfTable = NULL;
    ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppIfTable = (PMIB_IFTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
      if (ret != NO_ERROR) {
        HeapFree(heap, flags, *ppIfTable);
        *ppIfTable = NULL;
      }
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

AllocateAndGetIpAddrTableFromStack()

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

Definition at line 140 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("ppIpAddrTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
   ppIpAddrTable, (DWORD)bOrder, heap, flags);
  if (!ppIpAddrTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;
 
    *ppIpAddrTable = NULL;
    ret = GetIpAddrTable(*ppIpAddrTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppIpAddrTable = (PMIB_IPADDRTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetIpAddrTable(*ppIpAddrTable, &dwSize, bOrder);
      if (ret != NO_ERROR) {
        HeapFree(heap, flags, *ppIpAddrTable);
        *ppIpAddrTable = NULL;
      }
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

AllocateAndGetIpForwardTableFromStack()

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

Definition at line 180 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("ppIpForwardTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
   ppIpForwardTable, (DWORD)bOrder, heap, flags);
  if (!ppIpForwardTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;
 
    *ppIpForwardTable = NULL;
    ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppIpForwardTable = (PMIB_IPFORWARDTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
      if (ret != NO_ERROR) {
        HeapFree(heap, flags, *ppIpForwardTable);
        *ppIpForwardTable = NULL;
      }
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

Referenced by GetBestRoute().

AllocateAndGetIpNetTableFromStack()

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

Definition at line 220 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("ppIpNetTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
   ppIpNetTable, (DWORD)bOrder, heap, flags);
  if (!ppIpNetTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;
 
    *ppIpNetTable = NULL;
    ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppIpNetTable = (PMIB_IPNETTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
      if (ret != NO_ERROR) {
        HeapFree(heap, flags, *ppIpNetTable);
        *ppIpNetTable = NULL;
      }
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

AllocateAndGetTcpExTable2FromStack()

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

Definition at line 343 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family %ld, class %ld\n",
   ppTcpTable, (DWORD)bOrder, heap, flags, family, class);
  if (!ppTcpTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;
 
    *ppTcpTable = NULL;
    ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, class, 0);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppTcpTable = HeapAlloc(heap, flags, dwSize);
      ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, class, 0);
      if (ret != NO_ERROR) {
        HeapFree(heap, flags, *ppTcpTable);
        *ppTcpTable = NULL;
      }
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

AllocateAndGetTcpExTableFromStack()

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

Definition at line 301 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family 0x%08lx\n",
   ppTcpTable, (DWORD)bOrder, heap, flags, family);
  if (!ppTcpTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;
 
    *ppTcpTable = NULL;
    ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, TCP_TABLE_OWNER_PID_ALL, 0);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppTcpTable = (PMIB_TCPTABLE_OWNER_PID)HeapAlloc(heap, flags, dwSize);
      ret = GetExtendedTcpTable(*ppTcpTable, &dwSize, bOrder, family, TCP_TABLE_OWNER_PID_ALL, 0);
      if (ret != NO_ERROR) {
        HeapFree(heap, flags, *ppTcpTable);
        *ppTcpTable = NULL;
      }
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

AllocateAndGetTcpTableFromStack()

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

Definition at line 260 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("ppTcpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
   ppTcpTable, (DWORD)bOrder, heap, flags);
  if (!ppTcpTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;
 
    *ppTcpTable = NULL;
    ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppTcpTable = (PMIB_TCPTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
      if (ret != NO_ERROR) {
        HeapFree(heap, flags, *ppTcpTable);
        *ppTcpTable = NULL;
      }
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

AllocateAndGetUdpExTable2FromStack()

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

Definition at line 466 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family %ld, class %ld\n",
   ppUdpTable, (DWORD)bOrder, heap, flags, family, class);
  if (!ppUdpTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;
 
    *ppUdpTable = NULL;
    ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, class, 0);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppUdpTable = HeapAlloc(heap, flags, dwSize);
      ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, class, 0);
      if (ret != NO_ERROR) {
        HeapFree(heap, flags, *ppUdpTable);
        *ppUdpTable = NULL;
      }
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

AllocateAndGetUdpExTableFromStack()

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

Definition at line 424 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx, family 0x%08lx\n",
   ppUdpTable, (DWORD)bOrder, heap, flags, family);
  if (!ppUdpTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;
 
    *ppUdpTable = NULL;
    ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, UDP_TABLE_OWNER_PID, 0);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppUdpTable = (PMIB_UDPTABLE_OWNER_PID)HeapAlloc(heap, flags, dwSize);
      ret = GetExtendedUdpTable(*ppUdpTable, &dwSize, bOrder, family, UDP_TABLE_OWNER_PID, 0);
      if (ret != NO_ERROR) {
        HeapFree(heap, flags, *ppUdpTable);
        *ppUdpTable = NULL;
      }
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

AllocateAndGetUdpTableFromStack()

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

Definition at line 383 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("ppUdpTable %p, bOrder %ld, heap 0x%p, flags 0x%08lx\n",
   ppUdpTable, (DWORD)bOrder, heap, flags);
  if (!ppUdpTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;
 
    *ppUdpTable = NULL;
    ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppUdpTable = (PMIB_UDPTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
      if (ret != NO_ERROR) {
        HeapFree(heap, flags, *ppUdpTable);
        *ppUdpTable = NULL;
      }
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

CancelIPChangeNotify()

BOOL WINAPI CancelIPChangeNotify

(

LPOVERLAPPED

notifyOverlapped

)

Definition at line 3189 of file iphlpapi_main.c.

{
    FIXME(":stub\n");
    return 0L;
}

CreateIpForwardEntry()

DWORD WINAPI CreateIpForwardEntry

(

PMIB_IPFORWARDROW

pRoute

)

Definition at line 503 of file iphlpapi_main.c.

{
    return createIpForwardEntry( pRoute );
}

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

CreateIpNetEntry()

DWORD WINAPI CreateIpNetEntry

(

PMIB_IPNETROW

pArpEntry

)

Definition at line 518 of file iphlpapi_main.c.

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

CreateNameServerListEnumNamesFunc()

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

static

Definition at line 2366 of file iphlpapi_main.c.

{
  IP_ADDR_STRING *pNext;
  PNAME_SERVER_LIST_CONTEXT Context = (PNAME_SERVER_LIST_CONTEXT)Data;
 
  if (!Context->NumServers)
  {
    if (Context->uSizeAvailable >= Context->uSizeRequired)
    {
      WideCharToMultiByte(CP_ACP, 0, Server, -1, Context->pData->DnsServerList.IpAddress.String, 16, NULL, NULL);
      Context->pData->DnsServerList.IpAddress.String[15] = '\0';
      Context->pLastAddr = &Context->pData->DnsServerList;
    }
  }
  else
  {
     Context->uSizeRequired += sizeof(IP_ADDR_STRING);
     if (Context->uSizeAvailable >= Context->uSizeRequired)
     {
         pNext = (IP_ADDR_STRING*)(((char*)Context->pLastAddr) + sizeof(IP_ADDR_STRING));
         WideCharToMultiByte(CP_ACP, 0, Server, -1, pNext->IpAddress.String, 16, NULL, NULL);
         pNext->IpAddress.String[15] = '\0';
         Context->pLastAddr->Next = pNext;
         Context->pLastAddr = pNext;
         pNext->Next = NULL;
     }
  }
  Context->NumServers++;
}

Referenced by GetPerAdapterInfo().

CreateProxyArpEntry()

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

Definition at line 538 of file iphlpapi_main.c.

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

DeleteIPAddress()

DWORD WINAPI DeleteIPAddress

(

ULONG

NTEContext

)

Definition at line 557 of file iphlpapi_main.c.

{
  TRACE("NTEContext %ld\n", NTEContext);
  return RtlNtStatusToDosError(deleteIpAddress(NTEContext));
}

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

DeleteIpForwardEntry()

DWORD WINAPI DeleteIpForwardEntry

(

PMIB_IPFORWARDROW

pRoute

)

Definition at line 573 of file iphlpapi_main.c.

{
    return deleteIpForwardEntry( pRoute );
}

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

DeleteIpNetEntry()

DWORD WINAPI DeleteIpNetEntry

(

PMIB_IPNETROW

pArpEntry

)

Definition at line 588 of file iphlpapi_main.c.

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

Referenced by Deletehost().

DeleteProxyArpEntry()

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

Definition at line 608 of file iphlpapi_main.c.

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

DllMain()

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

Definition at line 39 of file iphlpapi_main.c.

{
  switch (fdwReason) {
    case DLL_PROCESS_ATTACH:
      DisableThreadLibraryCalls( hinstDLL );
      interfaceMapInit();
      break;
 
    case DLL_PROCESS_DETACH:
      interfaceMapFree();
      break;
  }
  return TRUE;
}

EnableRouter()

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

Definition at line 627 of file iphlpapi_main.c.

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

FlushIpNetTable()

DWORD WINAPI FlushIpNetTable

(

DWORD

dwIfIndex

)

Definition at line 647 of file iphlpapi_main.c.

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

Referenced by Deletehost().

GetAdapterIndex()

DWORD WINAPI GetAdapterIndex	(	LPWSTR	AdapterName,
		PULONG	IfIndex
	)

Definition at line 667 of file iphlpapi_main.c.

{
  TRACE("AdapterName %p, IfIndex %p\n", AdapterName, IfIndex);
  FIXME(":stub\n");
  /* marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}

GetAdapterOrderMap()

PIP_ADAPTER_ORDER_MAP WINAPI GetAdapterOrderMap

(

VOID

)

Definition at line 2982 of file iphlpapi_main.c.

{
    FIXME(":stub\n");
    return 0L;
}

GetAdaptersInfo()

DWORD WINAPI GetAdaptersInfo	(	PIP_ADAPTER_INFO	pAdapterInfo,
		PULONG	pOutBufLen
	)

Definition at line 686 of file iphlpapi_main.c.

{
  DWORD ret;
  BOOL dhcpEnabled;
  DWORD dhcpServer;
 
  TRACE("pAdapterInfo %p, pOutBufLen %p\n", pAdapterInfo, pOutBufLen);
  if (!pOutBufLen)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD numNonLoopbackInterfaces = getNumNonLoopbackInterfaces();
 
    if (numNonLoopbackInterfaces > 0) {
      /* this calculation assumes only one address in the IP_ADDR_STRING lists.
         that's okay, because:
         - we don't get multiple addresses per adapter anyway
         - we don't know about per-adapter gateways
         - DHCP and WINS servers can have max one entry per list */
      ULONG size = sizeof(IP_ADAPTER_INFO) * numNonLoopbackInterfaces;
 
      if (!pAdapterInfo || *pOutBufLen < size) {
        *pOutBufLen = size;
        ret = ERROR_BUFFER_OVERFLOW;
      }
      else {
        InterfaceIndexTable *table = getNonLoopbackInterfaceIndexTable();
 
        if (table) {
          size = sizeof(IP_ADAPTER_INFO) * table->numIndexes;
          if (*pOutBufLen < size) {
            *pOutBufLen = size;
            ret = ERROR_INSUFFICIENT_BUFFER;
          }
          else {
            DWORD ndx;
            HKEY hKey;
            BOOL winsEnabled = FALSE;
            IP_ADDRESS_STRING primaryWINS, secondaryWINS;
 
            memset(pAdapterInfo, 0, size);
            /* @@ Wine registry key: HKCU\Software\Wine\Network */
            if (RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Network", &hKey) == ERROR_SUCCESS) {
              DWORD size = sizeof(primaryWINS.String);
              unsigned long addr;
 
              RegQueryValueExA(hKey, "WinsServer", NULL, NULL,
               (PBYTE)primaryWINS.String, &size);
              addr = inet_addr(primaryWINS.String);
              if (addr != INADDR_NONE && addr != INADDR_ANY)
                winsEnabled = TRUE;
              size = sizeof(secondaryWINS.String);
              RegQueryValueExA(hKey, "BackupWinsServer", NULL, NULL,
               (PBYTE)secondaryWINS.String, &size);
              addr = inet_addr(secondaryWINS.String);
              if (addr != INADDR_NONE && addr != INADDR_ANY)
                winsEnabled = TRUE;
              RegCloseKey(hKey);
            }
            TRACE("num of index is %lu\n", table->numIndexes);
            for (ndx = 0; ndx < table->numIndexes; ndx++) {
              PIP_ADAPTER_INFO ptr = &pAdapterInfo[ndx];
              DWORD addrLen = sizeof(ptr->Address), type;
              const char *ifname =
                  getInterfaceNameByIndex(table->indexes[ndx]);
              if (!ifname) {
                  ret = ERROR_OUTOFMEMORY;
                  break;
              }
 
              /* on Win98 this is left empty, but whatever */
              strncpy(ptr->AdapterName,ifname,sizeof(ptr->AdapterName));
              consumeInterfaceName(ifname);
              ptr->AdapterName[MAX_ADAPTER_NAME_LENGTH] = '\0';
              getInterfacePhysicalByIndex(table->indexes[ndx], &addrLen,
               ptr->Address, &type);
              /* MS defines address length and type as UINT in some places and
                 DWORD in others, **sigh**.  Don't want to assume that PUINT and
                 PDWORD are equiv (64-bit?) */
              ptr->AddressLength = addrLen;
              ptr->Type = type;
              ptr->Index = table->indexes[ndx];
              toIPAddressString(getInterfaceIPAddrByIndex(table->indexes[ndx]),
               ptr->IpAddressList.IpAddress.String);
              toIPAddressString(getInterfaceMaskByIndex(table->indexes[ndx]),
               ptr->IpAddressList.IpMask.String);
              ptr->IpAddressList.Context = ptr->Index;
              toIPAddressString(getInterfaceGatewayByIndex(table->indexes[ndx]),
               ptr->GatewayList.IpAddress.String);
              getDhcpInfoForAdapter(table->indexes[ndx], &dhcpEnabled,
                                    &dhcpServer, &ptr->LeaseObtained,
                                    &ptr->LeaseExpires);
              ptr->DhcpEnabled = (DWORD) dhcpEnabled;
              toIPAddressString(dhcpServer,
                                ptr->DhcpServer.IpAddress.String);
              if (winsEnabled) {
                ptr->HaveWins = TRUE;
                memcpy(ptr->PrimaryWinsServer.IpAddress.String,
                 primaryWINS.String, sizeof(primaryWINS.String));
                memcpy(ptr->SecondaryWinsServer.IpAddress.String,
                 secondaryWINS.String, sizeof(secondaryWINS.String));
              }
              if (ndx < table->numIndexes - 1)
                ptr->Next = &pAdapterInfo[ndx + 1];
              else
                ptr->Next = NULL;
            }
            ret = NO_ERROR;
          }
          free(table);
        }
        else
          ret = ERROR_OUTOFMEMORY;
      }
    }
    else
      ret = ERROR_NO_DATA;
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

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

GetBestInterface()

DWORD WINAPI GetBestInterface	(	IPAddr	dwDestAddr,
		PDWORD	pdwBestIfIndex
	)

Definition at line 818 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("dwDestAddr 0x%08lx, pdwBestIfIndex %p\n", dwDestAddr, pdwBestIfIndex);
  if (!pdwBestIfIndex)
    ret = ERROR_INVALID_PARAMETER;
  else {
    MIB_IPFORWARDROW ipRow;
 
    ret = GetBestRoute(dwDestAddr, 0, &ipRow);
    if (ret == ERROR_SUCCESS)
      *pdwBestIfIndex = ipRow.dwForwardIfIndex;
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

GetBestInterfaceEx()

DWORD WINAPI GetBestInterfaceEx	(	struct sockaddr *	pDestAddr,
		PDWORD	pdwBestIfIndex
	)

Definition at line 3198 of file iphlpapi_main.c.

{
    FIXME(":stub\n");
    return 0L;
}

GetBestRoute()

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

Definition at line 848 of file iphlpapi_main.c.

{
  PMIB_IPFORWARDTABLE table;
  DWORD ret;
 
  TRACE("dwDestAddr 0x%08lx, dwSourceAddr 0x%08lx, pBestRoute %p\n", dwDestAddr,
   dwSourceAddr, pBestRoute);
  if (!pBestRoute)
    return ERROR_INVALID_PARAMETER;
 
  AllocateAndGetIpForwardTableFromStack(&table, FALSE, GetProcessHeap(), 0);
  if (table) {
    DWORD ndx, minMaskSize, matchedNdx = 0;
 
    for (ndx = 0, minMaskSize = 255; ndx < table->dwNumEntries; ndx++) {
      if ((dwDestAddr & table->table[ndx].dwForwardMask) ==
       (table->table[ndx].dwForwardDest & table->table[ndx].dwForwardMask)) {
        DWORD hostMaskSize;
 
        if (!_BitScanForward(&hostMaskSize, ntohl(table->table[ndx].dwForwardMask)))
        {
            hostMaskSize = 32;
        }
        if (hostMaskSize < minMaskSize) {
          minMaskSize = hostMaskSize;
          matchedNdx = ndx;
        }
      }
    }
    memcpy(pBestRoute, &table->table[matchedNdx], sizeof(MIB_IPFORWARDROW));
    HeapFree(GetProcessHeap(), 0, table);
    ret = ERROR_SUCCESS;
  }
  else
    ret = ERROR_OUTOFMEMORY;
  TRACE("returning %ld\n", ret);
  return ret;
}

Referenced by GetBestInterface().

GetExtendedTcpTable()

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

Definition at line 926 of file iphlpapi_main.c.

{
    DWORD i, count, size;
    DWORD ret = NO_ERROR;
 
    if (!pdwSize)
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    if (ulAf != AF_INET)
    {
        UNIMPLEMENTED;
        return ERROR_INVALID_PARAMETER;
    }
 
    switch (TableClass)
    {
        case TCP_TABLE_BASIC_ALL:
        {
            PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
            PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
 
            if (pOurTcpTable)
            {
                size = FIELD_OFFSET(MIB_TCPTABLE, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW);
                if (size > *pdwSize || !pTheirTcpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    memcpy(pTheirTcpTable, pOurTcpTable, size);
 
                    if (bOrder)
                        qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
                              sizeof(MIB_TCPROW), TcpTableSorter);
                }
 
                HeapFree(GetProcessHeap(),0, pOurTcpTable);
            }
        }
        break;
 
        case TCP_TABLE_BASIC_CONNECTIONS:
        {
            PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
            PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
 
            if (pOurTcpTable)
            {
                for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                {
                    if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
                    {
                        ++count;
                    }
                }
 
                size = FIELD_OFFSET(MIB_TCPTABLE, table) + count * sizeof(MIB_TCPROW);
                if (size > *pdwSize || !pTheirTcpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    pTheirTcpTable->dwNumEntries = count;
 
                    for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                    {
                        if (pOurTcpTable->table[i].State != MIB_TCP_STATE_LISTEN)
                        {
                            memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
                            ++count;
                        }
                    }
                    ASSERT(count == pTheirTcpTable->dwNumEntries);
 
                    if (bOrder)
                        qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
                              sizeof(MIB_TCPROW), TcpTableSorter);
                }
 
                HeapFree(GetProcessHeap(), 0, pOurTcpTable);
            }
        }
        break;
 
        case TCP_TABLE_BASIC_LISTENER:
        {
            PMIB_TCPTABLE pOurTcpTable = getTcpTable(ClassBasic);
            PMIB_TCPTABLE pTheirTcpTable = pTcpTable;
 
            if (pOurTcpTable)
            {
                for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                {
                    if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
                    {
                        ++count;
                    }
                }
 
                size = FIELD_OFFSET(MIB_TCPTABLE, table) + count * sizeof(MIB_TCPROW);
                if (size > *pdwSize || !pTheirTcpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    pTheirTcpTable->dwNumEntries = count;
 
                    for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                    {
                        if (pOurTcpTable->table[i].State == MIB_TCP_STATE_LISTEN)
                        {
                            memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW));
                            ++count;
                        }
                    }
                    ASSERT(count == pTheirTcpTable->dwNumEntries);
 
                    if (bOrder)
                        qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
                              sizeof(MIB_TCPROW), TcpTableSorter);
                }
 
                HeapFree(GetProcessHeap(), 0, pOurTcpTable);
            }
        }
        break;
 
        case TCP_TABLE_OWNER_PID_ALL:
        {
            PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
            PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
 
            if (pOurTcpTable)
            {
                size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_PID);
                if (size > *pdwSize || !pTheirTcpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    memcpy(pTheirTcpTable, pOurTcpTable, size);
 
                    /* Don't sort on PID, so use basic helper */
                    if (bOrder)
                        qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
                              sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
                }
 
                HeapFree(GetProcessHeap(), 0, pOurTcpTable);
            }
        }
        break;
 
        case TCP_TABLE_OWNER_PID_CONNECTIONS:
        {
            PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
            PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
 
            if (pOurTcpTable)
            {
                for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                {
                    if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
                    {
                        ++count;
                    }
                }
 
                size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + count * sizeof(MIB_TCPROW_OWNER_PID);
                if (size > *pdwSize || !pTheirTcpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    pTheirTcpTable->dwNumEntries = count;
 
                    for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                    {
                        if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
                        {
                            memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_PID));
                            ++count;
                        }
                    }
                    ASSERT(count == pTheirTcpTable->dwNumEntries);
 
                    /* Don't sort on PID, so use basic helper */
                    if (bOrder)
                        qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
                              sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
                }
 
                HeapFree(GetProcessHeap(), 0, pOurTcpTable);
            }
        }
        break;
 
        case TCP_TABLE_OWNER_PID_LISTENER:
        {
            PMIB_TCPTABLE_OWNER_PID pOurTcpTable = getTcpTable(ClassModulePid);
            PMIB_TCPTABLE_OWNER_PID pTheirTcpTable = pTcpTable;
 
            if (pOurTcpTable)
            {
                for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                {
                    if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
                    {
                        ++count;
                    }
                }
 
                size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_PID, table) + count * sizeof(MIB_TCPROW_OWNER_PID);
                if (size > *pdwSize || !pTheirTcpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    pTheirTcpTable->dwNumEntries = count;
 
                    for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                    {
                        if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
                        {
                            memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_PID));
                            ++count;
                        }
                    }
                    ASSERT(count == pTheirTcpTable->dwNumEntries);
 
                    /* Don't sort on PID, so use basic helper */
                    if (bOrder)
                        qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
                              sizeof(MIB_TCPROW_OWNER_PID), TcpTableSorter);
                }
 
                HeapFree(GetProcessHeap(), 0, pOurTcpTable);
            }
        }
        break;
 
        case TCP_TABLE_OWNER_MODULE_ALL:
        {
            PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
            PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
 
            if (pOurTcpTable)
            {
                size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + pOurTcpTable->dwNumEntries * sizeof(MIB_TCPROW_OWNER_MODULE);
                if (size > *pdwSize || !pTheirTcpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    memcpy(pTheirTcpTable, pOurTcpTable, size);
 
                    /* Don't sort on PID, so use basic helper */
                    if (bOrder)
                        qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
                              sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
                }
 
                HeapFree(GetProcessHeap(), 0, pOurTcpTable);
            }
        }
        break;
 
        case TCP_TABLE_OWNER_MODULE_CONNECTIONS:
        {
            PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
            PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
 
            if (pOurTcpTable)
            {
                for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                {
                    if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
                    {
                        ++count;
                    }
                }
 
                size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + count * sizeof(MIB_TCPROW_OWNER_MODULE);
                if (size > *pdwSize || !pTheirTcpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    pTheirTcpTable->dwNumEntries = count;
 
                    for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                    {
                        if (pOurTcpTable->table[i].dwState != MIB_TCP_STATE_LISTEN)
                        {
                            memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
                            ++count;
                        }
                    }
                    ASSERT(count == pTheirTcpTable->dwNumEntries);
 
                    /* Don't sort on PID, so use basic helper */
                    if (bOrder)
                        qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
                              sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
                }
 
                HeapFree(GetProcessHeap(), 0, pOurTcpTable);
            }
        }
        break;
 
        case TCP_TABLE_OWNER_MODULE_LISTENER:
        {
            PMIB_TCPTABLE_OWNER_MODULE pOurTcpTable = getTcpTable(ClassModule);
            PMIB_TCPTABLE_OWNER_MODULE pTheirTcpTable = pTcpTable;
 
            if (pOurTcpTable)
            {
                for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                {
                    if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
                    {
                        ++count;
                    }
                }
 
                size = FIELD_OFFSET(MIB_TCPTABLE_OWNER_MODULE, table) + count * sizeof(MIB_TCPROW_OWNER_MODULE);
                if (size > *pdwSize || !pTheirTcpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    pTheirTcpTable->dwNumEntries = count;
 
                    for (i = 0, count = 0; i < pOurTcpTable->dwNumEntries; ++i)
                    {
                        if (pOurTcpTable->table[i].dwState == MIB_TCP_STATE_LISTEN)
                        {
                            memcpy(&pTheirTcpTable->table[count], &pOurTcpTable->table[i], sizeof(MIB_TCPROW_OWNER_MODULE));
                            ++count;
                        }
                    }
                    ASSERT(count == pTheirTcpTable->dwNumEntries);
 
                    /* Don't sort on PID, so use basic helper */
                    if (bOrder)
                        qsort(pTheirTcpTable->table, pTheirTcpTable->dwNumEntries,
                              sizeof(MIB_TCPROW_OWNER_MODULE), TcpTableSorter);
                }
 
                HeapFree(GetProcessHeap(), 0, pOurTcpTable);
            }
        }
        break;
 
        default:
            ret = ERROR_INVALID_PARAMETER;
            break;
    }
 
    return ret;
}

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

{
    DWORD size;
    DWORD ret = NO_ERROR;
 
    if (!pdwSize)
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    if (ulAf != AF_INET)
    {
        UNIMPLEMENTED;
        return ERROR_INVALID_PARAMETER;
    }
 
    switch (TableClass)
    {
        case UDP_TABLE_BASIC:
        {
            PMIB_UDPTABLE pOurUdpTable = getUdpTable(ClassBasic);
            PMIB_UDPTABLE pTheirUdpTable = pUdpTable;
 
            if (pOurUdpTable)
            {
                size = FIELD_OFFSET(MIB_UDPTABLE, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW);
                if (size > *pdwSize || !pTheirUdpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    memcpy(pTheirUdpTable, pOurUdpTable, size);
 
                    if (bOrder)
                        qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
                              sizeof(MIB_UDPROW), UdpTableSorter);
                }
 
                HeapFree(GetProcessHeap(), 0, pOurUdpTable);
            }
        }
        break;
 
        case UDP_TABLE_OWNER_PID:
        {
            PMIB_UDPTABLE_OWNER_PID pOurUdpTable = getUdpTable(ClassModulePid);
            PMIB_UDPTABLE_OWNER_PID pTheirUdpTable = pUdpTable;
 
            if (pOurUdpTable)
            {
                size = FIELD_OFFSET(MIB_UDPTABLE_OWNER_PID, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_PID);
                if (size > *pdwSize || !pTheirUdpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    memcpy(pTheirUdpTable, pOurUdpTable, size);
 
                    if (bOrder)
                        qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
                              sizeof(MIB_UDPROW_OWNER_PID), UdpTableSorter);
                }
 
                HeapFree(GetProcessHeap(), 0, pOurUdpTable);
            }
        }
        break;
 
        case UDP_TABLE_OWNER_MODULE:
        {
            PMIB_UDPTABLE_OWNER_MODULE pOurUdpTable = getUdpTable(ClassModule);
            PMIB_UDPTABLE_OWNER_MODULE pTheirUdpTable = pUdpTable;
 
            if (pOurUdpTable)
            {
                size = FIELD_OFFSET(MIB_UDPTABLE_OWNER_MODULE, table) + pOurUdpTable->dwNumEntries * sizeof(MIB_UDPROW_OWNER_MODULE);
                if (size > *pdwSize || !pTheirUdpTable)
                {
                    *pdwSize = size;
                    ret = ERROR_INSUFFICIENT_BUFFER;
                }
                else
                {
                    memcpy(pTheirUdpTable, pOurUdpTable, size);
 
                    if (bOrder)
                        qsort(pTheirUdpTable->table, pTheirUdpTable->dwNumEntries,
                              sizeof(MIB_UDPROW_OWNER_MODULE), UdpTableSorter);
                }
 
                HeapFree(GetProcessHeap(), 0, pOurUdpTable);
            }
        }
        break;
 
        default:
            ret = ERROR_INVALID_PARAMETER;
            break;
    }
 
    return ret;
}

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

GetFriendlyIfIndex()

DWORD WINAPI GetFriendlyIfIndex

(

DWORD

IfIndex

)

Definition at line 1459 of file iphlpapi_main.c.

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

GetIcmpStatistics()

DWORD WINAPI GetIcmpStatistics

(

PMIB_ICMP

pStats

)

Definition at line 1478 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("pStats %p\n", pStats);
  ret = getICMPStats(pStats);
  TRACE("returning %ld\n", ret);
  return ret;
}

Referenced by mib2IcmpInit(), and ShowIcmpStatistics().

GetIcmpStatisticsEx()

DWORD WINAPI GetIcmpStatisticsEx	(	PMIB_ICMP_EX	pStats,
		DWORD	dwFamily
	)

Definition at line 3216 of file iphlpapi_main.c.

{
    FIXME(":stub\n");
 
    if (!pStats)
        return ERROR_INVALID_PARAMETER;
 
    if (dwFamily != AF_INET && dwFamily != AF_INET6)
        return ERROR_INVALID_PARAMETER;
 
    return 0L;
}

GetIfEntry()

DWORD WINAPI GetIfEntry

(

PMIB_IFROW

pIfRow

)

Definition at line 1498 of file iphlpapi_main.c.

{
  DWORD ret;
  const char *name;
 
  TRACE("pIfRow %p\n", pIfRow);
  if (!pIfRow)
    return ERROR_INVALID_PARAMETER;
 
  name = getInterfaceNameByIndex(pIfRow->dwIndex);
  if (name) {
    ret = getInterfaceEntryByIndex(pIfRow->dwIndex, pIfRow);
    if (ret == NO_ERROR)
      ret = getInterfaceStatsByName(name, pIfRow);
    consumeInterfaceName(name);
  }
  else
    ret = ERROR_INVALID_DATA;
  TRACE("returning %ld\n", ret);
  return ret;
}

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

GetIfTable()

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

Definition at line 1544 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("pIfTable %p, pdwSize %p, bOrder %ld\n", pdwSize, pdwSize,
   (DWORD)bOrder);
  if (!pdwSize)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD numInterfaces = getNumInterfaces();
    ULONG size;
    TRACE("GetIfTable: numInterfaces = %d\n", (int)numInterfaces);
    size = sizeof(MIB_IFTABLE) + (numInterfaces - 1) * sizeof(MIB_IFROW);
 
    if (!pIfTable || *pdwSize < size) {
      *pdwSize = size;
      ret = ERROR_INSUFFICIENT_BUFFER;
    }
    else {
      InterfaceIndexTable *table = getInterfaceIndexTable();
 
      if (table) {
        size = sizeof(MIB_IFTABLE) + (table->numIndexes - 1) *
         sizeof(MIB_IFROW);
        if (*pdwSize < size) {
          *pdwSize = size;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          DWORD ndx;
 
          pIfTable->dwNumEntries = 0;
          for (ndx = 0; ndx < table->numIndexes; ndx++) {
            pIfTable->table[ndx].dwIndex = table->indexes[ndx];
            GetIfEntry(&pIfTable->table[ndx]);
            pIfTable->dwNumEntries++;
          }
          if (bOrder)
            qsort(pIfTable->table, pIfTable->dwNumEntries, sizeof(MIB_IFROW),
             IfTableSorter);
          ret = NO_ERROR;
        }
        free(table);
      }
      else
        ret = ERROR_OUTOFMEMORY;
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

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

getInterfaceGatewayByIndex()

DWORD getInterfaceGatewayByIndex

(

DWORD

index

)

Definition at line 72 of file iphlpapi_main.c.

{
    DWORD ndx, retVal = 0, numRoutes = getNumRoutes();
    RouteTable *table = getRouteTable();
    if (!table) return 0;
 
    for (ndx = 0; ndx < numRoutes; ndx++)
    {
        if ((table->routes[ndx].ifIndex == (index)) && (table->routes[ndx].dest == 0))
            retVal = table->routes[ndx].gateway;
    }
    HeapFree(GetProcessHeap(), 0, table);
    return retVal;
}

Referenced by GetAdaptersInfo().

GetInterfaceInfo()

DWORD WINAPI GetInterfaceInfo	(	PIP_INTERFACE_INFO	pIfTable,
		PULONG	dwOutBufLen
	)

Definition at line 1607 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("pIfTable %p, dwOutBufLen %p\n", pIfTable, dwOutBufLen);
  if (!dwOutBufLen)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD numNonLoopbackInterfaces = getNumNonLoopbackInterfaces();
    ULONG size;
    TRACE("numNonLoopbackInterfaces == 0x%x\n", numNonLoopbackInterfaces);
    size = sizeof(IP_INTERFACE_INFO) + (numNonLoopbackInterfaces) *
     sizeof(IP_ADAPTER_INDEX_MAP);
 
    if (!pIfTable || *dwOutBufLen < size) {
      *dwOutBufLen = size;
      ret = ERROR_INSUFFICIENT_BUFFER;
    }
    else {
      InterfaceIndexTable *table = getNonLoopbackInterfaceIndexTable();
 
      if (table) {
        TRACE("table->numIndexes == 0x%x\n", table->numIndexes);
        size = sizeof(IP_INTERFACE_INFO) + (table->numIndexes) *
         sizeof(IP_ADAPTER_INDEX_MAP);
        if (*dwOutBufLen < size) {
          *dwOutBufLen = size;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          DWORD ndx;
 
          pIfTable->NumAdapters = 0;
          for (ndx = 0; ndx < table->numIndexes; ndx++) {
            const char *walker, *name;
            WCHAR *assigner;
 
            pIfTable->Adapter[ndx].Index = table->indexes[ndx];
            name = getInterfaceNameByIndex(table->indexes[ndx]);
            wcscpy(pIfTable->Adapter[ndx].Name, L"\\DEVICE\\TCPIP_");
            for (walker = name, assigner = &pIfTable->Adapter[ndx].Name[14];
             walker && *walker &&
             assigner - pIfTable->Adapter[ndx].Name < MAX_ADAPTER_NAME - 1 - 14;
             walker++, assigner++)
              *assigner = *walker;
            *assigner = 0;
            consumeInterfaceName(name);
            pIfTable->NumAdapters++;
          }
          ret = NO_ERROR;
        }
        free(table);
      }
      else
        ret = ERROR_OUTOFMEMORY;
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

Referenced by OpenAdapterHandle(), and test_GetInterfaceName().

GetInterfaceNameInternal()

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

Definition at line 3236 of file iphlpapi_main.c.

{
    UNICODE_STRING GuidString;
    DWORD result, type;
    WCHAR szKeyName[2*MAX_PATH];
    HRESULT hr;
    HKEY hKey;
 
    if (pInterfaceGUID == NULL || pOutBufLen == NULL)
        return ERROR_INVALID_PARAMETER;
 
    result = RtlStringFromGUID(pInterfaceGUID, &GuidString);
 
    if (!NT_SUCCESS(result))
    {
        // failed to convert guid to string
        return RtlNtStatusToDosError(result);
    }
 
    hr = StringCbPrintfW(szKeyName, sizeof(szKeyName), L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection", GuidString.Buffer);
    RtlFreeUnicodeString(&GuidString);
 
    if (FAILED(hr))
    {
        // key name is too long
        return ERROR_BUFFER_OVERFLOW;
    }
 
    result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, szKeyName, 0, KEY_READ, &hKey);
 
    if (result != ERROR_SUCCESS)
    {
        // failed to find adapter entry
        return ERROR_NOT_FOUND;
    }
 
    result = RegQueryValueExW(hKey, L"Name", NULL, &type, (PVOID)pInterfaceName, pOutBufLen);
 
    RegCloseKey(hKey);
 
    if (result == ERROR_MORE_DATA)
    {
        *pOutBufLen = MAX_INTERFACE_NAME_LEN * 2;
        return ERROR_INSUFFICIENT_BUFFER;
    }
 
    if (result != ERROR_SUCCESS || type != REG_SZ)
    {
        // failed to read adapter name
        return ERROR_NO_DATA;
    }
    return ERROR_SUCCESS;
}

Referenced by NhGetInterfaceNameFromDeviceGuid(), and NhGetInterfaceNameFromGuid().

GetIpAddrTable()

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

Definition at line 1692 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("pIpAddrTable %p, pdwSize %p, bOrder %ld\n", pIpAddrTable, pdwSize,
   (DWORD)bOrder);
  if (!pdwSize)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD numInterfaces = getNumInterfaces();
    ULONG size = sizeof(MIB_IPADDRTABLE) + (numInterfaces - 1) *
     sizeof(MIB_IPADDRROW);
 
    if (!pIpAddrTable || *pdwSize < size) {
      *pdwSize = size;
      ret = ERROR_INSUFFICIENT_BUFFER;
    }
    else {
      InterfaceIndexTable *table = getInterfaceIndexTable();
 
      if (table) {
        size = sizeof(MIB_IPADDRTABLE) + (table->numIndexes - 1) *
         sizeof(MIB_IPADDRROW);
        if (*pdwSize < size) {
          *pdwSize = size;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          DWORD ndx, bcast;
 
          pIpAddrTable->dwNumEntries = 0;
          for (ndx = 0; ndx < table->numIndexes; ndx++) {
            pIpAddrTable->table[ndx].dwIndex = table->indexes[ndx];
            pIpAddrTable->table[ndx].dwAddr =
             getInterfaceIPAddrByIndex(table->indexes[ndx]);
            pIpAddrTable->table[ndx].dwMask =
             getInterfaceMaskByIndex(table->indexes[ndx]);
            /* the dwBCastAddr member isn't the broadcast address, it indicates
             * whether the interface uses the 1's broadcast address (1) or the
             * 0's broadcast address (0).
             */
            bcast = getInterfaceBCastAddrByIndex(table->indexes[ndx]);
            pIpAddrTable->table[ndx].dwBCastAddr =
             (bcast & pIpAddrTable->table[ndx].dwMask) ? 1 : 0;
            /* FIXME: hardcoded reasm size, not sure where to get it */
            pIpAddrTable->table[ndx].dwReasmSize = 65535;
            pIpAddrTable->table[ndx].unused1 = 0;
            pIpAddrTable->table[ndx].wType = 0; /* aka unused2 */
            pIpAddrTable->dwNumEntries++;
          }
          if (bOrder)
            qsort(pIpAddrTable->table, pIpAddrTable->dwNumEntries,
             sizeof(MIB_IPADDRROW), IpAddrTableSorter);
          ret = NO_ERROR;
        }
        free(table);
      }
      else
        ret = ERROR_OUTOFMEMORY;
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

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

GetIpErrorString()

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

Definition at line 2972 of file iphlpapi_main.c.

{
    FIXME(":stub\n");
    return 0L;
}

GetIpForwardTable()

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

Definition at line 1792 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("pIpForwardTable %p, pdwSize %p, bOrder %ld\n", pIpForwardTable,
        pdwSize, (DWORD)bOrder);
  if (!pdwSize)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD numRoutes = getNumRoutes();
    ULONG sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (numRoutes - 1) *
     sizeof(MIB_IPFORWARDROW);
 
    if (!pIpForwardTable || *pdwSize < sizeNeeded) {
      *pdwSize = sizeNeeded;
      ret = ERROR_INSUFFICIENT_BUFFER;
    }
    else {
      RouteTable *table = getRouteTable();
      if (table) {
        sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (table->numRoutes - 1) *
         sizeof(MIB_IPFORWARDROW);
        if (*pdwSize < sizeNeeded) {
          *pdwSize = sizeNeeded;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          DWORD ndx;
 
          pIpForwardTable->dwNumEntries = table->numRoutes;
          for (ndx = 0; ndx < numRoutes; ndx++) {
            pIpForwardTable->table[ndx].dwForwardIfIndex =
             table->routes[ndx].ifIndex;
            pIpForwardTable->table[ndx].dwForwardDest =
             table->routes[ndx].dest;
            pIpForwardTable->table[ndx].dwForwardMask =
             table->routes[ndx].mask;
            pIpForwardTable->table[ndx].dwForwardPolicy = 0;
            pIpForwardTable->table[ndx].dwForwardNextHop =
             table->routes[ndx].gateway;
            /* FIXME: this type is appropriate for local interfaces; may not
               always be appropriate */
            pIpForwardTable->table[ndx].dwForwardType = MIB_IPROUTE_TYPE_DIRECT;
            /* FIXME: other protos might be appropriate, e.g. the default route
               is typically set with MIB_IPPROTO_NETMGMT instead */
            pIpForwardTable->table[ndx].dwForwardProto = MIB_IPPROTO_LOCAL;
            /* punt on age and AS */
            pIpForwardTable->table[ndx].dwForwardAge = 0;
            pIpForwardTable->table[ndx].dwForwardNextHopAS = 0;
            pIpForwardTable->table[ndx].dwForwardMetric1 =
             table->routes[ndx].metric;
            /* rest of the metrics are 0.. */
            pIpForwardTable->table[ndx].dwForwardMetric2 = 0;
            pIpForwardTable->table[ndx].dwForwardMetric3 = 0;
            pIpForwardTable->table[ndx].dwForwardMetric4 = 0;
            pIpForwardTable->table[ndx].dwForwardMetric5 = 0;
          }
          if (bOrder)
            qsort(pIpForwardTable->table, pIpForwardTable->dwNumEntries,
             sizeof(MIB_IPFORWARDROW), IpForwardTableSorter);
          ret = NO_ERROR;
        }
        HeapFree(GetProcessHeap(), 0, table);
      }
      else
        ret = ERROR_OUTOFMEMORY;
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

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

GetIpNetTable()

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

Definition at line 1888 of file iphlpapi_main.c.

{
  DWORD ret = NO_ERROR;
 
  TRACE("pIpNetTable %p, pdwSize %p, bOrder %d\n", pIpNetTable, pdwSize,
   (DWORD)bOrder);
  if (!pdwSize)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD numEntries = getNumArpEntries();
    ULONG size = sizeof(MIB_IPNETTABLE);
 
    if (numEntries > 1)
      size += (numEntries - 1) * sizeof(MIB_IPNETROW);
    if (!pIpNetTable || *pdwSize < size) {
      *pdwSize = size;
      ret = ERROR_INSUFFICIENT_BUFFER;
    }
    else {
      PMIB_IPNETTABLE table = getArpTable();
      if (table) {
        size = sizeof(MIB_IPNETTABLE);
        if (table->dwNumEntries > 1)
          size += (table->dwNumEntries - 1) * sizeof(MIB_IPNETROW);
        if (*pdwSize < size) {
          *pdwSize = size;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          *pdwSize = size;
          memcpy(pIpNetTable, table, size);
          if (bOrder)
            qsort(pIpNetTable->table, pIpNetTable->dwNumEntries,
             sizeof(MIB_IPNETROW), IpNetTableSorter);
          ret = NO_ERROR;
        }
        HeapFree(GetProcessHeap(), 0, table);
      }
    }
  }
  TRACE("returning %d\n", ret);
  return ret;
}

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

GetIpStatistics()

DWORD WINAPI GetIpStatistics

(

PMIB_IPSTATS

pStats

)

Definition at line 1942 of file iphlpapi_main.c.

{
    return GetIpStatisticsEx(pStats, PF_INET);
}

Referenced by mib2IpStatsInit(), and ShowIpStatistics().

GetIpStatisticsEx()

DWORD WINAPI GetIpStatisticsEx	(	PMIB_IPSTATS	pStats,
		DWORD	dwFamily
	)

Definition at line 1957 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("pStats %p\n", pStats);
  ret = getIPStats(pStats, dwFamily);
  TRACE("returning %ld\n", ret);
  return ret;
}

Referenced by GetIpStatistics().

GetNetworkParams()

DWORD WINAPI GetNetworkParams	(	PFIXED_INFO	pFixedInfo,
		PULONG	pOutBufLen
	)

Definition at line 1977 of file iphlpapi_main.c.

{
  DWORD ret, size, type;
  LONG regReturn;
  HKEY hKey;
  PIPHLP_RES_INFO resInfo;
 
  TRACE("pFixedInfo %p, pOutBufLen %p\n", pFixedInfo, pOutBufLen);
  if (!pOutBufLen)
    return ERROR_INVALID_PARAMETER;
 
  resInfo = getResInfo();
  if (!resInfo)
    return ERROR_OUTOFMEMORY;
 
  size = sizeof(FIXED_INFO) + (resInfo->riCount > 1 ? (resInfo->riCount-1) *
   sizeof(IP_ADDR_STRING) : 0);
  if (!pFixedInfo || *pOutBufLen < size) {
    *pOutBufLen = size;
    disposeResInfo( resInfo );
    return ERROR_BUFFER_OVERFLOW;
  }
 
  memset(pFixedInfo, 0, size);
  /* Check for DhcpHostname and DhcpDomain first */
  regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
                            "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters",
                            0,
                            KEY_READ,
                            &hKey);
  if (regReturn == ERROR_SUCCESS) {
      /* Windows doesn't honor DHCP option 12 even if RFC requires it if it is returned by DHCP server! */
#if 0
      type = REG_SZ;
      size = sizeof(pFixedInfo->HostName);
      regReturn = RegQueryValueExA(hKey,
                                      "DhcpHostname",
                                      NULL,
                                      &type,
                                      (LPBYTE)pFixedInfo->HostName,
                                      &size);
      if (regReturn == ERROR_FILE_NOT_FOUND || (regReturn == ERROR_SUCCESS && size < 1))
      {
#endif
          type = REG_SZ;
          size = sizeof(pFixedInfo->HostName);
          regReturn = RegQueryValueExA(hKey,
                                          "Hostname",
                                          NULL,
                                          &type,
                                          (LPBYTE)pFixedInfo->HostName,
                                          &size);
#if 0
      }
#endif
 
      type = REG_SZ;
      size = sizeof(pFixedInfo->DomainName);
      regReturn = RegQueryValueExA(hKey,
                                      "DhcpDomain",
                                      NULL,
                                      &type,
                                      (LPBYTE)pFixedInfo->DomainName,
                                      &size);
      if (regReturn == ERROR_FILE_NOT_FOUND || (regReturn == ERROR_SUCCESS && size < 1))
      {
          type = REG_SZ;
          size = sizeof(pFixedInfo->DomainName);
          regReturn = RegQueryValueExA(hKey,
                                          "Domain",
                                          NULL,
                                          &type,
                                          (LPBYTE)pFixedInfo->DomainName,
                                          &size);
      }
      RegCloseKey(hKey);
  }
 
  TRACE("GetComputerNameExA: %s\n", pFixedInfo->DomainName);
 
  if (resInfo->riCount > 0) 
  {
    CopyMemory(&pFixedInfo->DnsServerList, resInfo->DnsList, sizeof(IP_ADDR_STRING));
    if (resInfo->riCount > 1)
    {
      IP_ADDR_STRING *pSrc = resInfo->DnsList->Next;
      IP_ADDR_STRING *pTarget = (struct _IP_ADDR_STRING*)((char*)pFixedInfo + sizeof(FIXED_INFO));
 
      pFixedInfo->DnsServerList.Next = pTarget;
 
      do
      {
        CopyMemory(pTarget, pSrc, sizeof(IP_ADDR_STRING));
        resInfo->riCount--;
        if (resInfo->riCount > 1)
        {
          pTarget->Next = (IP_ADDR_STRING*)((char*)pTarget + sizeof(IP_ADDR_STRING));
          pTarget = pTarget->Next;
          pSrc = pSrc->Next;
        }
        else
        {
          pTarget->Next = NULL;
          break;
        }
      }
      while(TRUE);
    }
    else
    {
      pFixedInfo->DnsServerList.Next = NULL;
    }
  }
 
  pFixedInfo->NodeType = HYBRID_NODETYPE;
  regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
   "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ, &hKey);
  if (regReturn != ERROR_SUCCESS)
    regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
     "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters", 0, KEY_READ,
     &hKey);
  if (regReturn == ERROR_SUCCESS)
  {
    DWORD size = sizeof(pFixedInfo->ScopeId);
 
    RegQueryValueExA(hKey, "ScopeID", NULL, NULL, (PBYTE)pFixedInfo->ScopeId, &size);
    RegCloseKey(hKey);
  }
 
  disposeResInfo( resInfo );
  /* FIXME: can check whether routing's enabled in /proc/sys/net/ipv4/ip_forward
     I suppose could also check for a listener on port 53 to set EnableDns */
  ret = NO_ERROR;
  TRACE("returning %ld\n", ret);
 
  return ret;
}

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

GetNumberOfInterfaces()

DWORD WINAPI GetNumberOfInterfaces

(

PDWORD

pdwNumIf

)

Definition at line 2125 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("pdwNumIf %p\n", pdwNumIf);
  if (!pdwNumIf)
    ret = ERROR_INVALID_PARAMETER;
  else {
    *pdwNumIf = getNumInterfaces();
    ret = NO_ERROR;
  }
  TRACE("returning %ld\n", ret);
  return ret;
}

Referenced by _RpcEnumInterfaces().

GetOwnerModuleFromPidEntry()

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

static

Definition at line 2141 of file iphlpapi_main.c.

{
    HANDLE Process;
    DWORD FileLen, PathLen, Error;
    WCHAR File[MAX_PATH], Path[MAX_PATH];
    PTCPIP_OWNER_MODULE_BASIC_INFO BasicInfo;
 
    if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
        IsBadWritePtr(Buffer, *pdwSize))
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    if (OwningPid == 0)
    {
        return ERROR_NOT_FOUND;
    }
 
    Process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, OwningPid);
    if (Process == NULL)
    {
        return GetLastError();
    }
 
    FileLen = GetModuleBaseNameW(Process, NULL, File, MAX_PATH);
    if (FileLen != 0)
    {
        PathLen = GetModuleFileNameExW(Process, NULL, Path, MAX_PATH);
        if (PathLen == 0)
        {
            CloseHandle(Process);
            return GetLastError();
        }
 
        /* Add NULL char */
        ++FileLen;
        ++PathLen;
        PathLen *= sizeof(WCHAR);
        FileLen *= sizeof(WCHAR);
    }
    else
    {
        Error = GetLastError();
 
        if (Error == ERROR_PARTIAL_COPY)
        {
            wcscpy(File, L"System");
            wcscpy(Path, L"System");
 
            PathLen = sizeof(L"System");
            FileLen = sizeof(L"System");
        }
        else
        {
            CloseHandle(Process);
            return Error;
        }
    }
 
    CloseHandle(Process);
 
    if (*pdwSize < sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen)
    {
        *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen;
        return ERROR_INSUFFICIENT_BUFFER;
    }
 
    BasicInfo = Buffer;
    BasicInfo->pModuleName = (PVOID)((ULONG_PTR)BasicInfo + sizeof(TCPIP_OWNER_MODULE_BASIC_INFO));
    BasicInfo->pModulePath = (PVOID)((ULONG_PTR)BasicInfo->pModuleName + FileLen);
    wcscpy(BasicInfo->pModuleName, File);
    wcscpy(BasicInfo->pModulePath, Path);
    *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + PathLen + FileLen;
 
    return NO_ERROR;
}

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

{
    UINT Size;
    HRESULT Res;
    HANDLE hAdvapi32;
    WCHAR SysDir[MAX_PATH];
    PTCPIP_OWNER_MODULE_BASIC_INFO BasicInfo;
    ULONG (NTAPI *_I_QueryTagInformation)(PVOID, DWORD, PVOID);
    struct
    {
        DWORD ProcessId;
        DWORD ServiceTag;
        DWORD TagType;
        PWSTR Buffer;
    } ServiceQuery;
 
    if (IsBadWritePtr(pdwSize, sizeof(DWORD)) ||
        IsBadWritePtr(Buffer, *pdwSize))
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    /* First, secure (avoid injections) load advapi32.dll */
    Size = GetSystemDirectoryW(SysDir, MAX_PATH);
    if (Size == 0)
    {
        return GetLastError();
    }
 
    Res = StringCchCatW(&SysDir[Size], MAX_PATH - Size, L"\\advapi32.dll");
    if (FAILED(Res))
    {
        return Res;
    }
 
    hAdvapi32 = GetModuleHandleW(SysDir);
    if (hAdvapi32 == NULL)
    {
        return GetLastError();
    }
 
    /* Now, we'll query the service associated with the tag */
    _I_QueryTagInformation = (PVOID)GetProcAddress(hAdvapi32, "I_QueryTagInformation");
    if (_I_QueryTagInformation == NULL)
    {
        return GetLastError();
    }
 
    /* Set tag and PID for the query */
    ServiceQuery.ProcessId = OwningPid;
    ServiceQuery.ServiceTag = OwningTag;
    ServiceQuery.TagType = 0;
    ServiceQuery.Buffer = NULL;
 
    /* And query */
    Res = _I_QueryTagInformation(NULL, 1, &ServiceQuery);
    if (Res != ERROR_SUCCESS)
    {
        return Res;
    }
 
    /* Compute service name length */
    Size = wcslen(ServiceQuery.Buffer) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
 
    /* We'll copy it twice, so make sure we have enough room */
    if (*pdwSize < sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size)
    {
        *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size;
        LocalFree(ServiceQuery.Buffer);
        return ERROR_INSUFFICIENT_BUFFER;
    }
 
    /* Copy back data */
    BasicInfo = Buffer;
    BasicInfo->pModuleName = (PVOID)((ULONG_PTR)BasicInfo + sizeof(TCPIP_OWNER_MODULE_BASIC_INFO));
    BasicInfo->pModulePath = (PVOID)((ULONG_PTR)BasicInfo->pModuleName + Size);
    wcscpy(BasicInfo->pModuleName, ServiceQuery.Buffer);
    wcscpy(BasicInfo->pModulePath, ServiceQuery.Buffer);
    *pdwSize = sizeof(TCPIP_OWNER_MODULE_BASIC_INFO) + 2 * Size;
    LocalFree(ServiceQuery.Buffer);
 
    return NO_ERROR;
}

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

{
    /* If we have a service tag, that's a service connection */
    if (pTcpEntry->OwningModuleInfo[0] != 0)
    {
        return GetOwnerModuleFromTagEntry(pTcpEntry->dwOwningPid, (DWORD)(pTcpEntry->OwningModuleInfo[0]), Class, Buffer, pdwSize);
    }
    else
    {
        return GetOwnerModuleFromPidEntry(pTcpEntry->dwOwningPid, Class, Buffer, 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 2353 of file iphlpapi_main.c.

{
    /* If we have a service tag, that's a service connection */
    if (pUdpEntry->OwningModuleInfo[0] != 0)
    {
        return GetOwnerModuleFromTagEntry(pUdpEntry->dwOwningPid, (DWORD)(pUdpEntry->OwningModuleInfo[0]), Class, Buffer, pdwSize);
    }
    else
    {
        return GetOwnerModuleFromPidEntry(pUdpEntry->dwOwningPid, Class, Buffer, pdwSize);
    }
}

Referenced by START_TEST(), and test_udp().

GetPerAdapterInfo()

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

Definition at line 2407 of file iphlpapi_main.c.

{
  HKEY hkey;
  DWORD dwSize = 0;
  const char *ifName;
  NAME_SERVER_LIST_CONTEXT Context;
  WCHAR keyname[200] = L"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\";
 
  if (!pOutBufLen)
    return ERROR_INVALID_PARAMETER;
 
  if (!pPerAdapterInfo || *pOutBufLen < sizeof(IP_PER_ADAPTER_INFO))
  {
    *pOutBufLen = sizeof(IP_PER_ADAPTER_INFO);
    return ERROR_BUFFER_OVERFLOW;
  }
 
  ifName = getInterfaceNameByIndex(IfIndex);
  if (!ifName)
    return ERROR_INVALID_PARAMETER;
 
  MultiByteToWideChar(CP_ACP, 0, ifName, -1, &keyname[62], sizeof(keyname)/sizeof(WCHAR) - 63);
  HeapFree(GetProcessHeap(), 0, (LPVOID)ifName);
 
  if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keyname, 0, KEY_READ, &hkey) != ERROR_SUCCESS)
  {
    return ERROR_NOT_SUPPORTED;
  }
  Context.NumServers = 0;
  Context.uSizeAvailable = *pOutBufLen;
  Context.uSizeRequired = sizeof(IP_PER_ADAPTER_INFO);
  Context.pData = pPerAdapterInfo;
 
  if (*pOutBufLen >= sizeof(IP_PER_ADAPTER_INFO))
    ZeroMemory(pPerAdapterInfo, sizeof(IP_PER_ADAPTER_INFO));
 
  EnumNameServers(hkey, &keyname[62], &Context, CreateNameServerListEnumNamesFunc);
 
  if (Context.uSizeRequired > Context.uSizeAvailable)
  {
    *pOutBufLen = Context.uSizeRequired;
    RegCloseKey(hkey);
    return ERROR_BUFFER_OVERFLOW;
  }
 
  if(RegQueryValueExW(hkey, L"NameServer", NULL, NULL, NULL, &dwSize) == ERROR_SUCCESS)
  {
    pPerAdapterInfo->AutoconfigActive = FALSE;
  }
  else
  {
    pPerAdapterInfo->AutoconfigActive = TRUE;
  }
 
  RegCloseKey(hkey);
  return NOERROR;
}

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

GetRTTAndHopCount()

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

Definition at line 2478 of file iphlpapi_main.c.

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

GetTcpStatistics()

DWORD WINAPI GetTcpStatistics

(

PMIB_TCPSTATS

pStats

)

Definition at line 2516 of file iphlpapi_main.c.

{
    return GetTcpStatisticsEx(pStats, PF_INET);
}

Referenced by mib2TcpInit(), and ShowTcpStatistics().

GetTcpStatisticsEx()

DWORD WINAPI GetTcpStatisticsEx	(	PMIB_TCPSTATS	pStats,
		DWORD	dwFamily
	)

Definition at line 2497 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("pStats %p\n", pStats);
  ret = getTCPStats(pStats, dwFamily);
  TRACE("returning %ld\n", ret);
  return ret;
}

Referenced by GetTcpStatistics().

GetTcpTable()

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

Definition at line 2544 of file iphlpapi_main.c.

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

Referenced by AllocateAndGetTcpTableFromStack().

GetUdpStatistics()

DWORD WINAPI GetUdpStatistics

(

PMIB_UDPSTATS

pStats

)

Definition at line 2579 of file iphlpapi_main.c.

{
    return GetUdpStatisticsEx(pStats, PF_INET);
}

Referenced by mib2UdpInit(), and ShowUdpStatistics().

GetUdpStatisticsEx()

DWORD WINAPI GetUdpStatisticsEx	(	PMIB_UDPSTATS	pStats,
		DWORD	dwFamily
	)

Definition at line 2560 of file iphlpapi_main.c.

{
  DWORD ret;
 
  TRACE("pStats %p\n", pStats);
  ret = getUDPStats(pStats, dwFamily);
  TRACE("returning %ld\n", ret);
  return ret;
}

Referenced by GetUdpStatistics().

GetUdpTable()

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

Definition at line 2596 of file iphlpapi_main.c.

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

Referenced by AllocateAndGetUdpTableFromStack(), and mib2UdpEntryInit().

GetUniDirectionalAdapterInfo()

DWORD WINAPI GetUniDirectionalAdapterInfo	(	PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS	pIPIfInfo,
		PULONG	dwOutBufLen
	)

Definition at line 2620 of file iphlpapi_main.c.

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

IfTableSorter()

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

static

Definition at line 1521 of file iphlpapi_main.c.

{
  int ret;
 
  if (a && b)
    ret = ((PMIB_IFROW)a)->dwIndex - ((PMIB_IFROW)b)->dwIndex;
  else
    ret = 0;
  return ret;
}

Referenced by GetIfTable().

IpAddrTableSorter()

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

static

Definition at line 1669 of file iphlpapi_main.c.

{
  int ret;
 
  if (a && b)
    ret = ((PMIB_IPADDRROW)a)->dwAddr - ((PMIB_IPADDRROW)b)->dwAddr;
  else
    ret = 0;
  return ret;
}

Referenced by GetIpAddrTable().

IpForwardTableSorter()

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

static

Definition at line 1758 of file iphlpapi_main.c.

{
  int ret;
 
  if (a && b) {
    PMIB_IPFORWARDROW rowA = (PMIB_IPFORWARDROW)a, rowB = (PMIB_IPFORWARDROW)b;
 
    ret = rowA->dwForwardDest - rowB->dwForwardDest;
    if (ret == 0) {
      ret = rowA->dwForwardProto - rowB->dwForwardProto;
      if (ret == 0) {
        ret = rowA->dwForwardPolicy - rowB->dwForwardPolicy;
        if (ret == 0)
          ret = rowA->dwForwardNextHop - rowB->dwForwardNextHop;
      }
    }
  }
  else
    ret = 0;
  return ret;
}

Referenced by GetIpForwardTable().

IpNetTableSorter()

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

static

Definition at line 1865 of file iphlpapi_main.c.

{
  int ret;
 
  if (a && b)
    ret = ((PMIB_IPNETROW)a)->dwAddr - ((PMIB_IPNETROW)b)->dwAddr;
  else
    ret = 0;
  return ret;
}

Referenced by GetIpNetTable().

IpReleaseAddress()

DWORD WINAPI IpReleaseAddress

(

PIP_ADAPTER_INDEX_MAP

AdapterInfo

)

Definition at line 2640 of file iphlpapi_main.c.

{
  DWORD Status, Version = 0;
 
  if (!AdapterInfo)
      return ERROR_INVALID_PARAMETER;
 
  /* Maybe we should do this in DllMain */
  if (DhcpCApiInitialize(&Version) != ERROR_SUCCESS)
      return ERROR_PROC_NOT_FOUND;
 
  if (DhcpReleaseIpAddressLease(AdapterInfo->Index))
      Status = ERROR_SUCCESS;
  else
      Status = ERROR_PROC_NOT_FOUND;
 
  DhcpCApiCleanup();
 
  return Status;
}

Referenced by Release(), and WlanDisconnect().

IpRenewAddress()

DWORD WINAPI IpRenewAddress

(

PIP_ADAPTER_INDEX_MAP

AdapterInfo

)

Definition at line 2674 of file iphlpapi_main.c.

{
  DWORD Status, Version = 0;
 
  if (!AdapterInfo)
      return ERROR_INVALID_PARAMETER;
 
  /* Maybe we should do this in DllMain */
  if (DhcpCApiInitialize(&Version) != ERROR_SUCCESS)
      return ERROR_PROC_NOT_FOUND;
 
  if (DhcpRenewIpAddressLease(AdapterInfo->Index))
      Status = ERROR_SUCCESS;
  else
      Status = ERROR_PROC_NOT_FOUND;
 
  DhcpCApiCleanup();
 
  return Status;
}

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

{
    SetLastError(ERROR_SUCCESS);
 
    if (pInterfaceName == NULL)
        return ERROR_INVALID_PARAMETER;
 
    return GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
}

NhGetInterfaceNameFromGuid()

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

Definition at line 3308 of file iphlpapi_main.c.

{
    DWORD result;
 
    result = GetInterfaceNameInternal(pInterfaceGUID, pInterfaceName, pOutBufLen);
 
    if (result == ERROR_NOT_FOUND)
        SetLastError(ERROR_PATH_NOT_FOUND);
 
    return result;
}

NhpAllocateAndGetInterfaceInfoFromStack()

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

Definition at line 3207 of file iphlpapi_main.c.

{
    FIXME(":stub\n");
    return 0L;
}

NotifyAddrChange()

DWORD WINAPI NotifyAddrChange	(	PHANDLE	Handle,
		LPOVERLAPPED	overlapped
	)

Definition at line 2712 of file iphlpapi_main.c.

{
  FIXME("(Handle %p, overlapped %p): stub\n", Handle, overlapped);
  if (Handle) *Handle = INVALID_HANDLE_VALUE;
  if (overlapped) ((IO_STATUS_BLOCK *) overlapped)->Status = STATUS_PENDING;
  return ERROR_IO_PENDING;
}

Referenced by AdapterDiscoveryThread(), and detectChange().

NotifyRouteChange()

DWORD WINAPI NotifyRouteChange	(	PHANDLE	Handle,
		LPOVERLAPPED	overlapped
	)

Definition at line 2737 of file iphlpapi_main.c.

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

SendARP()

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

Definition at line 2758 of file iphlpapi_main.c.

{
  IPAddr IPs[2];
  ULONG Size;
 
  if (IsBadWritePtr(pMacAddr, sizeof(ULONG)) || IsBadWritePtr(PhyAddrLen, sizeof(ULONG)))
    return ERROR_INVALID_PARAMETER;
 
  IPs[0] = DestIP;
  IPs[1] = SrcIP;
  Size = sizeof(IPs);
  return TCPSendIoctl(INVALID_HANDLE_VALUE, IOCTL_QUERY_IP_HW_ADDRESS, IPs, &Size, pMacAddr, PhyAddrLen);
}

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

SetIfEntry()

DWORD WINAPI SetIfEntry

(

PMIB_IFROW

pIfRow

)

Definition at line 2788 of file iphlpapi_main.c.

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

SetIpForwardEntry()

DWORD WINAPI SetIpForwardEntry

(

PMIB_IPFORWARDROW

pRoute

)

Definition at line 2811 of file iphlpapi_main.c.

{
    return setIpForwardEntry( pRoute );
}

SetIpForwardEntryToStack()

DWORD WINAPI SetIpForwardEntryToStack

(

PMIB_IPFORWARDROW

pRoute

)

Definition at line 3230 of file iphlpapi_main.c.

{
    FIXME("SetIpForwardEntryToStack() stub\n");
    return 0L;
}

SetIpNetEntry()

DWORD WINAPI SetIpNetEntry

(

PMIB_IPNETROW

pArpEntry

)

Definition at line 2829 of file iphlpapi_main.c.

{
  HANDLE tcpFile;
  NTSTATUS status;
  TCP_REQUEST_SET_INFORMATION_EX_ARP_ENTRY req =
      TCP_REQUEST_SET_INFORMATION_INIT;
  TDIEntityID id;
  DWORD returnSize;
  PMIB_IPNETROW arpBuff;
 
  if (!pArpEntry)
      return ERROR_INVALID_PARAMETER;
 
  if (!NT_SUCCESS(openTcpFile( &tcpFile, FILE_READ_DATA | FILE_WRITE_DATA )))
      return ERROR_NOT_SUPPORTED;
 
  if (!NT_SUCCESS(getNthIpEntity( tcpFile, pArpEntry->dwIndex, &id )))
  {
      closeTcpFile(tcpFile);
      return ERROR_INVALID_PARAMETER;
  }
 
  req.Req.ID.toi_class = INFO_CLASS_PROTOCOL;
  req.Req.ID.toi_type = INFO_TYPE_PROVIDER;
  req.Req.ID.toi_id = IP_MIB_ARPTABLE_ENTRY_ID;
  req.Req.ID.toi_entity.tei_instance = id.tei_instance;
  req.Req.ID.toi_entity.tei_entity = AT_ENTITY;
  req.Req.BufferSize = sizeof(MIB_IPNETROW);
  arpBuff = (PMIB_IPNETROW)&req.Req.Buffer[0];
 
  RtlCopyMemory(arpBuff, pArpEntry, sizeof(MIB_IPNETROW));
 
  status = DeviceIoControl( tcpFile,
                            IOCTL_TCP_SET_INFORMATION_EX,
                            &req,
                            sizeof(req),
                            NULL,
                            0,
                            &returnSize,
                            NULL );
 
  closeTcpFile(tcpFile);
 
  if (status)
     return NO_ERROR;
  else
     return ERROR_INVALID_PARAMETER;
}

Referenced by Addhost().

SetIpStatistics()

DWORD WINAPI SetIpStatistics

(

PMIB_IPSTATS

pIpStats

)

Definition at line 2894 of file iphlpapi_main.c.

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

SetIpTTL()

DWORD WINAPI SetIpTTL

(

UINT

nTTL

)

Definition at line 2916 of file iphlpapi_main.c.

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

SetTcpEntry()

DWORD WINAPI SetTcpEntry

(

PMIB_TCPROW

pTcpRow

)

Definition at line 2938 of file iphlpapi_main.c.

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

TcpTableSorter()

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

static

Definition at line 887 of file iphlpapi_main.c.

{
  int ret;
 
  if (a && b) {
    PMIB_TCPROW rowA = (PMIB_TCPROW)a, rowB = (PMIB_TCPROW)b;
 
    ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
    if (ret == 0) {
      ret = rowA->dwLocalPort - rowB->dwLocalPort;
      if (ret == 0) {
        ret = rowA->dwRemoteAddr - rowB->dwRemoteAddr;
        if (ret == 0)
          ret = rowA->dwRemotePort - rowB->dwRemotePort;
      }
    }
  }
  else
    ret = 0;
  return ret;
}

Referenced by GetExtendedTcpTable().

UdpTableSorter()

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

static

Definition at line 1309 of file iphlpapi_main.c.

{
  int ret;
 
  if (a && b) {
    PMIB_UDPROW rowA = (PMIB_UDPROW)a, rowB = (PMIB_UDPROW)b;
 
    ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
    if (ret == 0)
      ret = rowA->dwLocalPort - rowB->dwLocalPort;
  }
  else
    ret = 0;
  return ret;
}

Referenced by GetExtendedUdpTable().

UnenableRouter()

DWORD WINAPI UnenableRouter	(	OVERLAPPED *	pOverlapped,
		LPDWORD	lpdwEnableCount
	)

Definition at line 2962 of file iphlpapi_main.c.

{
  FIXME("(pOverlapped %p, lpdwEnableCount %p): stub\n", pOverlapped,
   lpdwEnableCount);
  return ERROR_NOT_SUPPORTED;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

iphlpapi

)